shadowsocks_ruby 0.1.0

data/lib/shadowsocks_ruby/protocols/protocol.rb

@@ -0,0 +1,164 @@
+module ShadowsocksRuby
+  # Protocols are layered. Each layer know nothing about other layers.
+  #        (data)   |   TOP: HTTP, FTP, STMP ...     ^   (data)
+  #          Pack   |   layer 3 protocol packet      |   Unpack
+  #       Encrypt   |   layer 2 protocol cipher      |   Decrypt
+  #     Obfuscate   |   layer 1 protocol obfuscate   |   DeObfuscate
+  #      (opaque)   V   Bottom: TCP/UDP              |   (opaque)
+  #
+  #
+  # === Protocols
+  # There are 16 hooks can be called on protocols, which are:
+  # * tcp_receive_from_client
+  # * tcp_send_to_client
+  # * tcp_receive_from_remoteserver
+  # * tcp_send_to_remoteserver
+  # * tcp_receive_from_localbackend
+  # * tcp_send_to_localbackend
+  # * tcp_receive_from_destination
+  # * tcp_send_to_destination
+  # * udp_receive_from_client
+  # * udp_send_to_client
+  # * udp_receive_from_remoteserver
+  # * udp_send_to_remoteserver
+  # * udp_receive_from_localbackend
+  # * udp_send_to_localbackend
+  # * udp_receive_from_destination
+  # * udp_send_to_destination
+  # 
+  # Each receive_from hook's job is to return data of exact length required by upper level protocol.
+  #
+  # Each send_to hook's job is to get the send work done, with the data it received from the upper level protocol.
+  #
+  # Each hook can call next layer protocols's corresponding receive_from and send_to hook,
+  #
+  # The bottom layer calls +Connection+'s corresponding receive_from and send_to hook.
+  #
+  # The +Connection+ then map corresponding receive_from and send_to hook to real data transfer 
+  # methods +async_recv+ and +send_data+.
+  #
+  #
+  # @see Connections
+  # @see ProtocolStack
+  module Protocols
+
+    # This module include helper methods for a Packet/Cipher/Obfs Protocol.
+    #
+    # To simplify boring long method name writing (eg: tcp_receive_from_client, tcp_send_to_client),
+    # two Adapter method are introduced and could be untilized: 
+    # +#async_recv+ and +#send_data+,
+    # they will be adapted to long method names (eg: tcp_receive_from_client, tcp_send_to_client) at runtime.
+    # 
+    # This helper module implement dummy {#async_recv} and {#send_data}, do nothing but just raise,
+    # in order to make things clear.
+    #
+    # To use it, use +include DummyHelper+ to include it into your protocol implementation.
+    module DummyHelper
+
+      # Receive n bytes of data
+      # @param[Integer] n            length of data to receive
+      # @raise ProtocolError
+      # @return [String]             Should return real data on runtime
+      def async_recv n
+        raise ProtocolError, "async_recv must be set before use"
+      end
+
+      # Send data 
+      # @param[String] data          data to send
+      # @raise ProtocolError
+      def send_data data
+        raise ProtocolError, "send_data must be set before use"
+      end
+
+      # If user code don't want to implement a method, it can call this to raise Error.
+      # @raise UnimplementError
+      def raise_me *args
+        raise UnimplementError, "Some day may implement this: " + caller[0][/`.*'/][1..-2]
+      end
+    end
+
+    # This module include helper methods for deal with @buffer.
+    #
+    module BufferHelper
+      def tcp_receive_from_remoteserver_other_packet_helper n
+        if n == -1
+          return @buffer.slice!(0, @buffer.length)          
+        elsif n < @buffer.length
+          class << self
+            alias tcp_receive_from_remoteserver tcp_receive_from_remoteserver_in_buffer
+          end
+          return @buffer.slice!(0, n)
+        else
+          if n == @buffer.length
+            return @buffer.slice!(0, n)
+          else
+            data = async_recv(n - @buffer.length)
+            return @buffer.slice!(0, n) << data 
+          end
+        end
+      end
+
+      def tcp_receive_from_remoteserver_in_buffer n
+        if n == -1
+          class << self
+            alias tcp_receive_from_remoteserver tcp_receive_from_remoteserver_other_packet
+          end
+          return @buffer.slice!(0, @buffer.length)          
+        elsif n < @buffer.length
+          return @buffer.slice!(0, n)
+        else
+          class << self
+            alias tcp_receive_from_remoteserver tcp_receive_from_remoteserver_other_packet
+          end
+          if n == @buffer.length
+            return @buffer.slice!(0, n)
+          else
+            data = async_recv(n - @buffer.length)
+            return @buffer.slice!(0, n) << data 
+          end
+        end
+      end
+
+      def tcp_receive_from_localbackend_other_packet_helper n
+        if n == -1
+          return @buffer.slice!(0, @buffer.length)
+        elsif n < @buffer.length
+          class << self
+            alias tcp_receive_from_localbackend tcp_receive_from_localbackend_in_buffer
+          end
+          return @buffer.slice!(0, n)
+        else
+          if n == @buffer.length
+            return @buffer.slice!(0, n)
+          else
+            data = async_recv(n - @buffer.length)
+            return @buffer.slice!(0, n) << data 
+          end
+        end
+      end
+
+
+      def tcp_receive_from_localbackend_in_buffer n
+        if n == -1
+          class << self
+            alias tcp_receive_from_localbackend tcp_receive_from_localbackend_other_packet
+          end
+          return @buffer.slice!(0, @buffer.length)
+        elsif n < @buffer.length
+          return @buffer.slice!(0, n)
+        else
+          class << self
+            alias tcp_receive_from_localbackend tcp_receive_from_localbackend_other_packet
+          end
+          if n == @buffer.length
+            return @buffer.slice!(0, n)
+          else
+            data = async_recv(n - @buffer.length)
+            return @buffer.slice!(0, n) << data 
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/shadowsocks_ruby/protocols/protocol_stack.rb

@@ -0,0 +1,117 @@
+require "to_camel_case"
+
+module ShadowsocksRuby
+  module Protocols
+
+    # Factory class for build protocol stacks
+    #
+    # @see Protocols
+    class ProtocolStack
+
+      # @example This is what a cfg_ary Array look like
+      #   [ 
+      #     ["some_packet_protocol_name"], # a packet protocol is required
+      #     ["some_cipher_protocol_name", {:cipher => "some_cipher_object"}], # a cipher protocol is optional
+      #     ["some_obfs_protocol_name", {:obfs_params => "..."}] # a obfs protocol is optional
+      #   ]
+      #
+      # @param [Array] cfg_ary
+      # @param [String] cipher_name
+      # @param [password] password
+      def initialize cfg_ary, cipher_name, password
+        @cfg_ary = cfg_ary.map do |protocol_name, param|
+          protocol_class = protocol_name.to_camel_case + "Protocol"
+          protocol_class = Protocols.const_get(protocol_class)
+          [protocol_class, param ||= {}]
+        end
+        @cipher_name = cipher_name
+        @password = password
+      end
+
+      # Factory method for build a protocol stack
+      #
+      # @param [EventMachine::Connection] conn
+      # @return top protocol (packet protocol) in the stack
+      def build! conn
+        cipher = nil
+
+        protocols = @cfg_ary.map do | klass, params|
+          case klass.to_s
+          when Protocols::PlainProtocol.to_s, Protocols::Socks5Protocol.to_s, \
+            Protocols::ShadowsocksProtocol.to_s, Protocols::HttpSimpleProtocol.to_s
+            # do nothing, these are known protocols don't need cipher
+          when Protocols::TlsTicketProtocol.to_s
+            # this protocol need a key
+            params = {:key => (cipher ||= Cipher.build(@cipher_name, @password)).key}.merge(params)
+          else
+            params = {:cipher => (cipher ||= Cipher.build(@cipher_name, @password))}.merge(params)
+          end
+            klass.new(params)
+        end
+
+        protocols.each_cons(2) do | p, p1 |
+          p.next_protocol = p1
+        end
+
+        protocols.last.tap do |p|
+          p.next_protocol = conn
+        end
+
+        protocols.each do |p|
+          case
+          when conn.is_a?(ShadowsocksRuby::Connections::TCP::ClientConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :tcp_receive_from_client, :async_recv
+              def_delegator :@next_protocol, :tcp_send_to_client, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::TCP::RemoteServerConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :tcp_receive_from_remoteserver, :async_recv
+              def_delegator :@next_protocol, :tcp_send_to_remoteserver, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::TCP::LocalBackendConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :tcp_receive_from_localbackend, :async_recv
+              def_delegator :@next_protocol, :tcp_send_to_localbackend, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::TCP::DestinationConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :tcp_receive_from_destination, :async_recv
+              def_delegator :@next_protocol, :tcp_send_to_destination, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::UDP::ClientConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :udp_receive_from_client, :async_recv
+              def_delegator :@next_protocol, :udp_send_to_client, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::UDP::RemoteServerConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :udp_receive_from_remoteserver, :async_recv
+              def_delegator :@next_protocol, :udp_send_to_remoteserver, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::UDP::LocalBackendConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :udp_receive_from_localbackend, :async_recv
+              def_delegator :@next_protocol, :udp_send_to_localbackend, :send_data
+            end
+          when conn.is_a?(ShadowsocksRuby::Connections::UDP::DestinationConnection)
+            class << p
+              extend Forwardable
+              def_delegator :@next_protocol, :udp_receive_from_destination, :async_recv
+              def_delegator :@next_protocol, :udp_send_to_destination, :send_data
+            end
+          end
+        end          
+        
+        protocols.first
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/util.rb

@@ -0,0 +1,52 @@
+module ShadowsocksRuby
+  # Various utility functions
+  module Util
+    module_function
+
+    ATYP_IPV4      = 1
+    ATYP_DOMAIN    = 3
+    ATYP_IPV6      = 4
+
+    # Hex encodes a message
+    #
+    # @param [String] bytes The bytes to encode
+    #
+    # @return [String] Tasty, tasty hexadecimal
+    def bin2hex(bytes)
+      bytes.to_s.unpack("H*").first
+    end
+
+    # Hex decodes a message
+    #
+    # @param [String] hex hex to decode.
+    #
+    # @return [String] crisp and clean bytes
+    def hex2bin(hex)
+      [hex.to_s].pack("H*")
+    end
+
+    # Parse address bytes
+    # @param [String] bytes The bytes to parse
+    # @return [Array<String, Integer>] Return Host, Port
+    def parse_address_bin(bytes)
+      address_type = bytes.slice!(0, 1).unpack("C").first
+      case address_type
+      when ATYP_IPV4
+        host = IPAddr.ntop bytes.slice!(0, 4)
+        port = bytes.slice!(0, 2).unpack('n').first
+        [host, port]
+      when ATYP_IPV6
+        host = IPAddr.ntop bytes.slice!(0, 16)
+        port = bytes.slice!(0, 2).unpack('n').first
+        [host, port]
+      when ATYP_DOMAIN
+        domain_len = bytes.slice!(0, 1).unpack("C").first
+        host = bytes.slice!(0, domain_len)
+        port = bytes.slice!(0, 2).unpack('n').first
+        [host, port]
+      else
+        raise PharseError, "unknown address_type: #{address_type}"
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/version.rb

@@ -0,0 +1,3 @@
+module ShadowsocksRuby
+  VERSION = "0.1.0"
+end

data/lib/shadowsocks_ruby.rb

@@ -0,0 +1,86 @@
+require 'logger'
+require 'eventmachine'
+require 'forwardable'
+
+require "shadowsocks_ruby/version"
+require "shadowsocks_ruby/util"
+require "shadowsocks_ruby/cipher/cipher"
+require "shadowsocks_ruby/cipher/openssl"
+
+%w[ openssl rbnacl rc4_md5 table ].each do |file|
+  require "shadowsocks_ruby/cipher/#{file}"
+end
+
+require "shadowsocks_ruby/protocols/protocol"
+require "shadowsocks_ruby/protocols/protocol_stack"
+
+# autoload protocols in these directories
+%w[ packet cipher obfs ].each do |dir|
+  Dir[File.join(File.dirname(__FILE__) ,"shadowsocks_ruby", "protocols", dir , "*.rb")].each do |file|
+    file = File.basename(file,".rb")
+    require "shadowsocks_ruby/protocols/#{dir}/#{file}"
+  end
+end
+
+require "shadowsocks_ruby/connections/connection"
+require "shadowsocks_ruby/connections/server_connection"
+require "shadowsocks_ruby/connections/backend_connection"
+
+%w[ client_connection remoteserver_connection localbackend_connection destination_connection ].each do |file|
+  require "shadowsocks_ruby/connections/tcp/#{file}"
+end
+
+%w[ client_connection remoteserver_connection localbackend_connection destination_connection ].each do |file|
+  require "shadowsocks_ruby/connections/udp/#{file}"
+end
+
+require "shadowsocks_ruby/app"
+
+require "shadowsocks_ruby/cli/ssserver_runner"
+require "shadowsocks_ruby/cli/sslocal_runner"
+
+module ShadowsocksRuby
+  # This indicate a known failure by Shadowsock package.
+  # rescue this module will rescue all Shadowsocks known failure.
+  module MyErrorModule; end
+  # This indicates a failure in the App Class.
+  class AppError < ArgumentError
+    include MyErrorModule
+  end
+
+  # This indicates a failure in the Cipher Class.
+  class CipherError < ArgumentError
+    include MyErrorModule
+  end
+
+  # This indicates a failure in the Protocol Class.
+  class ProtocolError < ArgumentError
+    include MyErrorModule
+  end
+
+  # This indicates a failure in the Protocol pharse.
+  class PharseError < StandardError
+    include MyErrorModule
+  end
+
+    # This indicates a failure in Connection. A function is called out of fiber context.
+  class OutOfFiberContextError < StandardError
+    include MyErrorModule
+  end
+  
+    # This indicates a failure in Connection
+  class ConnectionError < StandardError
+    include MyErrorModule
+  end
+  
+    # This indicates a failure in Connection. The Buffer is oversized.
+  class BufferOversizeError < StandardError
+    include MyErrorModule
+  end
+
+  # This indicates something is unimplemented
+  class UnimplementError < StandardError
+    include MyErrorModule
+  end
+
+end

data/shadowsocks_ruby.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "shadowsocks_ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "shadowsocks_ruby"
+  spec.version       = ShadowsocksRuby::VERSION
+  spec.author        = "zhenkyle"
+  spec.email         = "zhenkyle@gmail.com"
+
+  spec.summary       = %q{A flexible platform for writing tunnel proxy to help you bypass firewalls.}
+  spec.description   = %q{ShadowsocksRuby is a flexible platform for writing [shadowsocks](https://github.com/shadowsocks/shadowsocks) like tunnel proxy to help you bypass firewalls.}
+  spec.homepage      = "https://github.com/zhenkyle/shadowsocks_ruby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata["yard.run"] = "yri" # use "yard" to build full HTML docs.
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "evented-spec", "~> 1.0.0.beta2"
+  spec.add_development_dependency "em-http-request", "~> 1.1.5"
+  spec.add_development_dependency('aruba', '~> 0.14.2')
+  spec.add_development_dependency('yard', '~> 0.9.8')
+
+  spec.add_runtime_dependency "eventmachine", "~> 1.2.1"
+  spec.add_runtime_dependency "rbnacl-libsodium", "~> 1.0.11"
+  spec.add_runtime_dependency "openssl", "~> 2.0.2"
+  spec.add_runtime_dependency "lrucache", "~> 0.1.4"
+  spec.add_runtime_dependency "to_camel_case", "~>1.0.0"
+  spec.add_runtime_dependency 'einhorn'
+end