shadowsocks 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75e7362c5a7e492c1a72ce66fe087442c2196867
+  data.tar.gz: 0f9abb4370f9185c79ec822f62cce07b17bb43c8
+SHA512:
+  metadata.gz: 0fb909540f9566f272e19db7eb289abd03106d94c6cf4862dd4af63aab55a047730c087024b74982959868acf4a41bc0cf98fbba89612e9f54624288da0c8dde
+  data.tar.gz: 5083e49dd9fed51a947b94ad0e4868f55237a6fb4d7d3a9aa2b3497e5ec69a4999fb4442fbb4ef67a0014cdcb5ac50c7e29a499f6f11f2f50bbe6795e85fcb97

data/.gitignore

@@ -0,0 +1,7 @@
+*.so
+*.o
+.DS_Store
+*.gem
+tmp
+*.bundle
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,20 @@
+shadowsocks-ruby
+================
+
+a Ruby EventMachine port of shadowsocks-nodejs (not stable yet). use shadowsocks-nodejs instead
+
+install
+
+``` ruby
+gem install eventmachine
+gem install ffi
+rake
+```
+
+server side
+
+``` ruby
+nohup ruby server.rb > log &
+```
+
+then enjoy!

data/Rakefile

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+require 'rake'
+
+# Load custom tasks
+Dir['tasks/*.rake'].sort.each { |f| load f }

data/bin/ss-local

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'shadowsocks'
+require 'shadowsocks/cli'
+require 'shadowsocks/config'
+
+begin
+  config = Shadowsocks::Config.new ARGV
+  cli = Shadowsocks::Cli.new({side: :local, config: config})
+  cli.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/bin/ss-server

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'shadowsocks'
+require 'shadowsocks/cli'
+require 'shadowsocks/config'
+
+begin
+  config = Shadowsocks::Config.new ARGV
+  cli = Shadowsocks::Cli.new({side: :server, config: config})
+  cli.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/config.json

@@ -0,0 +1,7 @@
+{
+    "server":"127.0.0.1",
+    "server_port":8388,
+    "local_port":1080,
+    "password":"foobar!",
+    "timeout":600
+}

data/ext/encrypt/encrypt.c

@@ -0,0 +1,11 @@
+char* encrypt(int table[], char buf[], int len)
+{
+    int j = 0;
+    char *end = buf + len;
+    while (buf < end) {
+        *buf = (char)table[(unsigned char)*buf];
+        buf++;
+    }
+
+    return buf - len;
+}

data/ext/encrypt/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('encrypt')

data/lib/shadowsocks.rb

@@ -0,0 +1,9 @@
+require 'eventmachine'
+
+module Shadowsocks
+  autoload :Server,   'shadowsocks/server'
+  autoload :Local,    'shadowsocks/local'
+  autoload :Table,    'shadowsocks/table'
+  autoload :Tunnel,   'shadowsocks/tunnel'
+  autoload :Listener, 'shadowsocks/listener'
+end

data/lib/shadowsocks/cli.rb

@@ -0,0 +1,51 @@
+require 'optparse'
+require 'pp'
+
+require File.expand_path('../version', __FILE__)
+
+module Shadowsocks
+  class Cli
+    include ::Shadowsocks::Table
+
+    attr_accessor :side, :args, :config, :table
+
+    def initialize(options)
+      @side   = options[:side]
+      @config = options[:config]
+      @table  = get_table(config.password)
+    end
+
+    def run
+      case side
+      when :local
+        EventMachine::run {
+          Signal.trap("INT")  { EventMachine.stop }
+          Signal.trap("TERM") { EventMachine.stop }
+
+          puts "*** Local side is up, port:#{config.local_port}"
+          puts "*** Hit Ctrl+c to stop"
+          EventMachine::start_server "0.0.0.0", config.local_port, Shadowsocks::Local::LocalListener, &method(:initialize_connection)
+        }
+      when :server
+        EventMachine::run {
+          Signal.trap("INT")  { EventMachine.stop }
+          Signal.trap("TERM") { EventMachine.stop }
+
+          puts "*** Server side is up, port:#{config.server_port}"
+          puts "*** Hit Ctrl+c to stop"
+
+          EventMachine::start_server "0.0.0.0", config.server_port, Shadowsocks::Server::ServerListener, &method(:initialize_connection)
+        }
+      end
+    end
+
+    private
+
+    def initialize_connection connection
+      connection.config                  = @config
+      connection.table                   = @table
+      connection.pending_connect_timeout = @config.timeout
+    end
+
+  end
+end

data/lib/shadowsocks/config.rb

@@ -0,0 +1,50 @@
+require 'json'
+
+module Shadowsocks
+  class Config
+    attr_reader :args, :server, :server_port, :local_port, :password, :timeout, :config_path
+
+    def initialize(_args)
+      @args = _args || []
+
+      parse_args
+      read_config
+    end
+
+    def read_config
+      @config_path = File.expand_path('../..', File.dirname(__FILE__)) + '/config.json' unless @config_file
+      cfg_file = File.open @config_path
+      json = JSON.parse cfg_file.read
+      cfg_file.close
+
+      @server       = json["server"]           if @server.nil?
+      @password     = json["password"]         if @password.nil?
+      @server_port  = json["server_port"].to_i if @server_port.nil?
+      @local_port   = json["local_port"].to_i  if @local_port.nil?
+      @timeout      = json["timeout"].to_i     if @timeout.nil?
+    end
+
+    private
+
+    def parse_args
+      opt_parser = OptionParser.new do |opts| 
+        opts.banner = "Usage: ss-server [options]"
+
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        opts.on("-s", "--server ADDR", "Remote server, IP address or domain")                        { |c| @server      = c }
+        opts.on("-k", "--password PASSWORD", "Password, should be same in client and server sides")  { |c| @password    = c }
+        opts.on("-c", "--config PATH", "config.json path")                                           { |c| @config_path = c }
+        opts.on("-p", "--port PORT", Integer, "Remote server port")                                  { |c| @server_port = c }
+        opts.on("-l", "--local_port PORT", Integer,"Local client port")                              { |c| @local_port  = c }
+        opts.on("-t", "--timeout NUMBER", Integer, "connection timeout")                             { |c| @timeout     = c }
+
+        opts.on_tail("-v", "--version", "Show shadowsocks gem version")                              { puts Shadowsocks::VERSION; exit }
+        opts.on_tail("-h", "--help", "Show this message")                                            { puts opts; exit }
+      end
+
+      opt_parser.parse!(args)
+    end
+  end
+end

data/lib/shadowsocks/listener.rb

@@ -0,0 +1,58 @@
+module Shadowsocks
+  class Listener < EventMachine::Connection
+    include ::Shadowsocks::Table
+
+    attr_accessor :stage, :remote_addr, :remote_port, :addr_to_send, :cached_pieces,
+                  :header_length, :connector, :config, :table
+
+    def receive_data data
+      data_handler data
+    end
+
+    def post_init
+      @stage = 0
+      @cached_pieces = []
+      puts "A client has connected..."
+    end
+
+    def unbind
+      puts "A client has left..."
+      connection_cleanup
+    end
+
+    private
+
+    def connection_cleanup
+      connector.close_connection if connector
+      self.close_connection
+    end
+
+    def resolve_addrtype data
+      case @addrtype
+      when "\x01"
+        ip_address data
+      when "\x03"
+        domain_address data
+      else
+        warn "unsupported addrtype: " + @addrtype.unpack('c')[0].to_s
+        connection_cleanup
+      end
+    end
+
+    def domain_address data
+      @remote_addr   = data[2, @addr_len]
+      @remote_port   = data[2 + @addr_len, 2].unpack('s>')[0]
+      @header_length = 2 + @addr_len + 2
+    end
+
+    def ip_address data
+      @remote_addr   = inet_ntoa data[1..4]
+      @remote_port   = data[5, 2].unpack('s>')[0]
+      @header_length = 7
+    end
+
+    def inet_ntoa n
+      n.unpack("C*").join "."
+    end
+  end
+end

data/lib/shadowsocks/local.rb

@@ -0,0 +1,79 @@
+module Shadowsocks
+  module Local
+    class ServerConnector < ::Shadowsocks::Tunnel
+      def post_init
+        p "connecting #{server.remote_addr[3..-1]} via #{server.config.server}"
+        addr_to_send = server.addr_to_send.clone
+
+        send_data encrypt(table[:encrypt_table], addr_to_send)
+        server.cached_pieces.each { |piece| send_data encrypt(table[:encrypt_table], piece) }
+        server.cached_pieces = []
+
+        server.stage = 5
+      end
+
+      def receive_data data
+        server.send_data encrypt(table[:decrypt_table], data)
+      end
+    end
+
+    class LocalListener < ::Shadowsocks::Listener
+      private
+
+      def data_handler data
+        case stage
+        when 0
+          send_data "\x05\x00"
+          @stage = 1
+        when 1
+          fireup_tunnel data
+        when 4
+          cached_pieces.push data
+        when 5
+          connector.send_data(encrypt(table[:encrypt_table], data)) and return
+        end
+      end
+
+      def fireup_tunnel(data)
+        begin
+          unless data[1] == "\x01"
+            send_data "\x05\x07\x00\x01"
+            connection_cleanup and return
+          end
+
+          @addr_to_send = data[3]
+
+          resolve_addrtype data
+
+          send_data "\x05\x00\x00\x01\x00\x00\x00\x00" + [config.server_port].pack('s>')
+
+          @stage = 4
+          @connector = EventMachine.connect config.server, config.server_port, ServerConnector, self, @table
+
+          if data.size > header_length
+            cached_pieces.push data[header_length, data.size]
+          end
+        rescue Exception => e
+          warn e
+          connection_cleanup
+        end
+      end
+
+      def resolve_addrtype data
+        @addrtype = data[3]
+        super
+      end
+
+      def domain_address data
+        @addr_len       = data[4].unpack('c')[0]
+        @addr_to_send  += data[4..5 + @addr_len + 2]
+        super
+      end
+
+      def ip_address data
+        @addr_to_send  += data[4..9]
+        super
+      end
+    end
+  end
+end

data/lib/shadowsocks/server.rb

@@ -0,0 +1,62 @@
+module Shadowsocks
+  module Server
+    class RequestConnector < ::Shadowsocks::Tunnel
+      def post_init
+        p "connecting #{server.remote_addr} via #{server.config.server}"
+
+        server.cached_pieces.each { |piece| send_data piece }
+        server.cached_pieces = nil
+
+        server.stage = 5
+      end
+
+      def receive_data data
+        server.send_data encrypt(table[:encrypt_table], data)
+      end
+    end
+
+    class ServerListener < ::Shadowsocks::Listener
+      private
+
+      def data_handler data
+        data = encrypt table[:decrypt_table], data
+        case stage
+        when 0
+          fireup_tunnel data
+        when 4
+          cached_pieces.push data
+        when 5
+          connector.send_data(data) and return
+        end
+      end
+
+      def fireup_tunnel data
+        begin
+          resolve_addrtype data
+
+          @stage = 4
+
+          if data.size > header_length
+            cached_pieces.push data[header_length, data.size]
+          end
+
+          @connector = EventMachine.connect @remote_addr, @remote_port, RequestConnector, self, table
+        rescue Exception => e
+          warn e
+          connection_cleanup
+        end
+      end
+
+      def resolve_addrtype data
+        @addrtype = data[0]
+        super
+      end
+
+      def domain_address data
+        @addr_len = data[1].unpack('c')[0]
+        super
+      end
+    end
+  end
+end
+

data/lib/shadowsocks/table.rb

@@ -0,0 +1,84 @@
+require "digest"
+require 'ffi'
+
+module Ext
+  def self.binary_path
+    path = ''
+    %w( so bundle dll ).each do |ext|
+      path = File.expand_path('..', File.dirname(__FILE__)) + "/encrypt.#{ext}"
+      break if File.exists? path
+    end
+
+    path
+  end
+
+  extend FFI::Library
+  ffi_lib binary_path
+  attach_function "encrypt", [:pointer, :pointer, :int], :pointer
+end
+
+module Shadowsocks
+  module Table
+    include Ext
+
+    def get_table key
+      table = Array.new(256, 0)
+      decrypt_table = Array.new(256, 0)
+
+      a = Digest::MD5.digest(key).unpack('Q<')[0]
+      i = 0
+
+      while i < 256
+        table[i] = i
+        i += 1
+      end
+      i = 1
+
+      while i < 1024
+        table = merge_sort(table, lambda { |x, y|
+          a % (x + i) - a % (y + i)
+        })
+        i += 1
+      end
+      i = 0
+      while i < 256
+        decrypt_table[table[i]] = i
+        i += 1
+      end
+      { encrypt_table: table, decrypt_table: decrypt_table }
+    end
+
+    def encrypt (table, buf)
+      table_ptr = FFI::MemoryPointer.new(:int, table.length)
+      table_ptr.put_array_of_int32(0, table)
+
+      buf_ptr = FFI::MemoryPointer.new(:string, buf.length)
+      buf_ptr.put_bytes(0, buf)
+
+      r = Ext.encrypt(table_ptr, buf_ptr, buf.length).get_bytes(0, buf.length)
+      table_ptr.free
+      buf_ptr.free
+      r
+    end
+
+    def merge (left, right, comparison)
+      result = []
+      while (left.length > 0) and (right.length > 0)
+        if comparison.call(left[0], right[0]) <= 0
+          result.push left.shift()
+        else
+          result.push right.shift()
+        end
+      end
+      result.push left.shift() while left.length > 0
+      result.push right.shift() while right.length > 0
+      result
+    end
+
+    def merge_sort (array, comparison)
+      return array if array.size < 2
+      middle = (array.size / 2).ceil
+      merge(merge_sort(array.slice(0, middle), comparison), merge_sort(array.slice(middle .. array.size), comparison), comparison)
+    end
+  end
+end

data/lib/shadowsocks/tunnel.rb

@@ -0,0 +1,19 @@
+module Shadowsocks
+  class Tunnel < EventMachine::Connection
+    attr_accessor :server, :table
+
+    def initialize server, table
+      @server = server
+      @table  = table
+      super
+    end
+
+    def unbind
+      server.close_connection_after_writing
+    end
+
+    def encrypt table, data
+      server.encrypt table, data
+    end
+  end
+end

data/lib/shadowsocks/version.rb

@@ -0,0 +1,3 @@
+module Shadowsocks
+  VERSION = '0.1'
+end

data/shadowsocks.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/shadowsocks/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'shadowsocks'
+  s.version       = Shadowsocks::VERSION
+  s.date          = '2013-09-26'
+  s.summary       = "ruby version of shadowsocks"
+  s.description   = "Fuck GFW"
+  s.authors       = ["Sen"]
+  s.email         = 'sen9ob@gmail.com'
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/{functional,unit}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.homepage      = 'http://rubygems.org/gems/shadowsocks'
+  s.license       = 'MIT'
+  s.extensions    = %w[ext/encrypt/extconf.rb]
+
+  s.add_dependency "eventmachine", "~> 1.0.3"
+  s.add_dependency "json", "~> 1.8.0"
+  s.add_dependency "ffi", "~> 1.9.0"
+
+  s.add_development_dependency "rake-compiler", "~> 0.9.1"
+  s.add_development_dependency "mocha", "~> 0.14.0"
+  s.add_development_dependency "rake"
+end

data/tasks/compile.rake

@@ -0,0 +1,9 @@
+require 'rake/extensiontask'
+
+def gemspec
+  @clean_gemspec ||= eval(File.read(File.expand_path('../../shadowsocks.gemspec', __FILE__)))
+end
+
+Rake::ExtensionTask.new('encrypt', gemspec) do |ext|
+  ext.ext_dir = 'ext/encrypt'
+end

data/tasks/dev.rake

@@ -0,0 +1,7 @@
+task :gem do
+  `gem build ./shadowsocks.gemspec`
+end
+
+task :install do
+  `gem install ./shadowsocks-#{Shadowsocks::VERSION}.gem`
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: shadowsocks
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Sen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.9.0
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fuck GFW
+email: sen9ob@gmail.com
+executables:
+- ss-local
+- ss-server
+extensions:
+- ext/encrypt/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/ss-local
+- bin/ss-server
+- config.json
+- ext/encrypt/encrypt.c
+- ext/encrypt/extconf.rb
+- lib/shadowsocks.rb
+- lib/shadowsocks/cli.rb
+- lib/shadowsocks/config.rb
+- lib/shadowsocks/listener.rb
+- lib/shadowsocks/local.rb
+- lib/shadowsocks/server.rb
+- lib/shadowsocks/table.rb
+- lib/shadowsocks/tunnel.rb
+- lib/shadowsocks/version.rb
+- shadowsocks.gemspec
+- tasks/compile.rake
+- tasks/dev.rake
+homepage: http://rubygems.org/gems/shadowsocks
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: ruby version of shadowsocks
+test_files: []