socksify 1.1.1 → 1.1.2

data/lib/socksify.rb

@@ -16,6 +16,7 @@
 =end
 
 require 'socket'
+require 'resolv'
 require 'socksify_debug'
 
 class SOCKSError < RuntimeError
@@ -90,6 +91,14 @@ class SOCKSError < RuntimeError
 end
 
 class TCPSocket
+  @@socks_version ||= "5"
+  
+  def self.socks_version
+    (@@socks_version == "4a" or @@socks_version == "4") ? "\004" : "\005"
+  end
+  def self.socks_version=(version)
+    @@socks_version = version.to_s
+  end
   def self.socks_server
     @@socks_server ||= nil
   end
@@ -121,7 +130,7 @@ class TCPSocket
       Socksify::debug_notice "Connecting to SOCKS server #{socks_server}:#{socks_port}"
       initialize_tcp socks_server, socks_port
 
-      socks_authenticate
+      socks_authenticate unless @@socks_version =~ /^4/
 
       if host
         socks_connect(host, port)
@@ -150,20 +159,39 @@ class TCPSocket
   # Connect
   def socks_connect(host, port)
     Socksify::debug_debug "Sending destination address"
-    write "\005\001\000"
+    write TCPSocket.socks_version
+    Socksify::debug_debug TCPSocket.socks_version.unpack "H*"
+    write "\001"
+    write "\000" if @@socks_version == "5"
+    write [port].pack('n') if @@socks_version =~ /^4/
+
+    if @@socks_version == "4"
+      host = Resolv::DNS.new.getaddress(host).to_s
+    end
+    Socksify::debug_debug host
     if host =~ /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/  # to IPv4 address
-      write "\001" + [$1.to_i,
-                      $2.to_i,
-                      $3.to_i,
-                      $4.to_i
-                     ].pack('CCCC')
+      write "\001" if @@socks_version == "5"
+      _ip = [$1.to_i,
+             $2.to_i,
+             $3.to_i,
+             $4.to_i
+            ].pack('CCCC')
+      write _ip
     elsif host =~ /^[:0-9a-f]+$/  # to IPv6 address
       raise "TCP/IPv6 over SOCKS is not yet supported (inet_pton missing in Ruby & not supported by Tor"
       write "\004"
     else                          # to hostname
-      write "\003" + [host.size].pack('C') + host
+      if @@socks_version == "5"
+        write "\003" + [host.size].pack('C') + host
+      else
+        write "\000\000\000\001"
+        write "\007\000"
+        Socksify::debug_notice host
+        write host
+        write "\000"
+      end
     end
-    write [port].pack('n')
+    write [port].pack('n') if @@socks_version == "5"
 
     socks_receive_reply
     Socksify::debug_notice "Connected to #{host}:#{port} over SOCKS"
@@ -172,44 +200,53 @@ class TCPSocket
   # returns [bind_addr: String, bind_port: Fixnum]
   def socks_receive_reply
     Socksify::debug_debug "Waiting for SOCKS reply"
-    connect_reply = recv(4)
-    if connect_reply[0..0] != "\005"
-      raise SOCKSError.new("SOCKS version #{connect_reply[0..0]} is not 5")
-    end
-    if connect_reply[1..1] != "\000"
-      raise SOCKSError.for_response_code(connect_reply.bytes.to_a[1])
-    end
-    Socksify::debug_debug "Waiting for bind_addr"
-    bind_addr_len = case connect_reply[3..3]
-                    when "\001"
-                      4
-                    when "\003"
-                      recv(1).bytes.first
-                    when "\004"
-                      16
-                    else
-                      raise SOCKSError.for_response_code(connect_reply.bytes.to_a[3])
-                    end
-    bind_addr_s = recv(bind_addr_len)
-    bind_addr = case connect_reply[3..3]
-                when "\001"
-                  bind_addr_s.bytes.to_a.join('.')
-                when "\003"
-                  bind_addr_s
-                when "\004"  # Untested!
-                  i = 0
-                  ip6 = ""
-                  bind_addr_s.each_byte do |b|
-                    if i > 0 and i % 2 == 0
-                      ip6 += ":"
-                    end
-                    i += 1
+    if @@socks_version == "5"
+      connect_reply = recv(4)
+      Socksify::debug_debug connect_reply.unpack "H*"
+      if connect_reply[0..0] != "\005"
+        raise SOCKSError.new("SOCKS version #{connect_reply[0..0]} is not 5")
+      end
+      if connect_reply[1..1] != "\000"
+        raise SOCKSError.for_response_code(connect_reply.bytes.to_a[1])
+      end
+      Socksify::debug_debug "Waiting for bind_addr"
+      bind_addr_len = case connect_reply[3..3]
+                      when "\001"
+                        4
+                      when "\003"
+                        recv(1).bytes.first
+                      when "\004"
+                        16
+                      else
+                        raise SOCKSError.for_response_code(connect_reply.bytes.to_a[3])
+                      end
+      bind_addr_s = recv(bind_addr_len)
+      bind_addr = case connect_reply[3..3]
+                  when "\001"
+                    bind_addr_s.bytes.to_a.join('.')
+                  when "\003"
+                    bind_addr_s
+                  when "\004"  # Untested!
+                    i = 0
+                    ip6 = ""
+                    bind_addr_s.each_byte do |b|
+                      if i > 0 and i % 2 == 0
+                        ip6 += ":"
+                      end
+                      i += 1
 
-                    ip6 += b.to_s(16).rjust(2, '0')
+                      ip6 += b.to_s(16).rjust(2, '0')
+                    end
                   end
-                end
-    bind_port = recv(bind_addr_len + 2)
-    [bind_addr, bind_port.unpack('n')]
+      bind_port = recv(bind_addr_len + 2)
+      [bind_addr, bind_port.unpack('n')]
+    else
+      connect_reply = recv(8)
+      unless connect_reply[0] == "\000" and connect_reply[1] == "\x5A"
+        Socksify::debug_debug connect_reply.unpack 'H'
+        raise SOCKSError.new("Failed while connecting througth socks")
+      end
+    end
   end
 end
 

metadata

@@ -1,15 +1,22 @@
 --- !ruby/object:Gem::Specification 
 name: socksify
 version: !ruby/object:Gem::Version 
-  version: 1.1.1
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 2
+  version: 1.1.2
 platform: ruby
 authors: 
 - Stephan Maka
+- Andrey Kouznetsov
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-03-15 00:00:00 +01:00
+date: 2010-10-20 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -26,7 +33,6 @@ extra_rdoc_files:
 files: 
 - COPYING
 - lib/socksify_debug.rb
-- lib/socksify.rb.orig
 - lib/socksify.rb
 - bin/socksify_ruby
 - doc/index.css
@@ -41,21 +47,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: socksify
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Redirect all TCPSockets through a SOCKS5 proxy

data/lib/socksify.rb.orig

@@ -1,244 +0,0 @@
-=begin
-    Copyright (C) 2007 Stephan Maka <stephan@spaceboyz.net>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
-require 'socket'
-require 'socksify_debug'
-
-class SOCKSError < RuntimeError
-  def initialize(msg)
-    Socksify::debug_error("#{self.class}: #{msg}")
-    super
-  end
-
-  class ServerFailure < SOCKSError
-    def initialize
-      super("general SOCKS server failure")
-    end
-  end
-  class NotAllowed < SOCKSError
-    def initialize
-      super("connection not allowed by ruleset")
-    end
-  end
-  class NetworkUnreachable < SOCKSError
-    def initialize
-      super("Network unreachable")
-    end
-  end
-  class HostUnreachable < SOCKSError
-    def initialize
-      super("Host unreachable")
-    end
-  end
-  class ConnectionRefused < SOCKSError
-    def initialize
-      super("Connection refused")
-    end
-  end
-  class TTLExpired < SOCKSError
-    def initialize
-      super("TTL expired")
-    end
-  end
-  class CommandNotSupported < SOCKSError
-    def initialize
-      super("Command not supported")
-    end
-  end
-  class AddressTypeNotSupported < SOCKSError
-    def initialize
-      super("Address type not supported")
-    end
-  end
-
-  def self.for_response_code(code)
-    case code
-    when 1
-      ServerFailure
-    when 2
-      NotAllowed
-    when 3
-      NetworkUnreachable
-    when 4
-      HostUnreachable
-    when 5
-      ConnectionRefused
-    when 6
-      TTLExpired
-    when 7
-      CommandNotSupported
-    when 8
-      AddressTypeNotSupported
-    else
-      self
-    end
-  end
-end
-
-class TCPSocket
-  def self.socks_server
-    @@socks_server
-  end
-  def self.socks_server=(host)
-    @@socks_server = host
-  end
-  def self.socks_port
-    @@socks_port
-  end
-  def self.socks_port=(port)
-    @@socks_port = port
-  end
-  def self.socks_ignores
-    @@socks_ignores ||= []
-  end
-  def self.socks_ignores=(ignores)
-    @@socks_ignores = ignores
-  end
-
-  alias :initialize_tcp :initialize
-
-  # See http://tools.ietf.org/html/rfc1928
-  def initialize(host=nil, port=0, local_host="0.0.0.0", local_port=0)
-    socks_server = self.class.socks_server
-    socks_port = self.class.socks_port
-    socks_ignores = self.class.socks_ignores
-
-    if socks_server and socks_port and not socks_ignores.include?(host)
-      Socksify::debug_notice "Connecting to SOCKS server #{socks_server}:#{socks_port}"
-      initialize_tcp socks_server, socks_port
-
-      socks_authenticate
-
-      if host
-        socks_connect(host, port)
-      end
-    else
-      Socksify::debug_notice "Connecting directly to #{host}:#{port}"
-      initialize_tcp host, port, local_host, local_port
-      Socksify::debug_debug "Connected to #{host}:#{port}"
-    end
-  end
-  
-  # Authentication
-  def socks_authenticate
-    Socksify::debug_debug "Sending no authentication"
-    write "\005\001\000"
-    Socksify::debug_debug "Waiting for authentication reply"
-    auth_reply = recv(2)
-    if auth_reply[0] != 4 and auth_reply[0] != 5
-      raise SOCKSError.new("SOCKS version #{auth_reply[0]} not supported")
-    end
-    if auth_reply[1] != 0
-      raise SOCKSError.new("SOCKS authentication method #{auth_reply[1]} neither requested nor supported")
-    end
-  end
-
-  # Connect
-  def socks_connect(host, port)
-    Socksify::debug_debug "Sending destination address"
-    write "\005\001\000"
-    if host =~ /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/  # to IPv4 address
-      write "\001" + [$1.to_i,
-                      $2.to_i,
-                      $3.to_i,
-                      $4.to_i
-                     ].pack('CCCC')
-    elsif host =~ /^[:0-9a-f]+$/  # to IPv6 address
-      raise "TCP/IPv6 over SOCKS is not yet supported (inet_pton missing in Ruby & not supported by Tor"
-      write "\004"
-    else                          # to hostname
-      write "\003" + [host.size].pack('C') + host
-    end
-    write [port].pack('n')
-
-    socks_receive_reply
-    Socksify::debug_notice "Connected to #{host}:#{port} over SOCKS"
-  end
-
-  # returns [bind_addr: String, bind_port: Fixnum]
-  def socks_receive_reply
-    Socksify::debug_debug "Waiting for SOCKS reply"
-    connect_reply = recv(4)
-    if connect_reply[0] != 5
-      raise SOCKSError.new("SOCKS version #{connect_reply[0]} is not 5")
-    end
-    if connect_reply[1] != 0
-      raise SOCKSError.for_response_code(connect_reply[1])
-    end
-    Socksify::debug_debug "Waiting for bind_addr"
-    bind_addr_len = case connect_reply[3]
-                    when 1
-                      4
-                    when 3
-                      recv(1)[0]
-                    when 4
-                      16
-                    else
-                      raise SOCKSError.for_response_code(connect_reply[3])
-                    end
-    bind_addr_s = recv(bind_addr_len)
-    bind_addr = case connect_reply[3]
-                when 1
-                  "#{bind_addr_s[0]}.#{bind_addr_s[1]}.#{bind_addr_s[2]}.#{bind_addr_s[3]}"
-                when 3
-                  bind_addr_s
-                when 4  # Untested!
-                  i = 0
-                  ip6 = ""
-                  bind_addr_s.each_byte do |b|
-                    if i > 0 and i % 2 == 0
-                      ip6 += ":"
-                    end
-                    i += 1
-
-                    ip6 += b.to_s(16).rjust(2, '0')
-                  end
-                end
-    bind_port = recv(bind_addr_len + 2)
-    [bind_addr, bind_port.unpack('n')]
-  end
-end
-
-module Socksify
-  def self.resolve(host)
-    s = TCPSocket.new
-
-    begin
-      Socksify::debug_debug "Sending hostname to resolve: #{host}"
-      s.write "\005"
-      if host =~ /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/  # to IPv4 address
-        s.write "\xF1\000\001" + [$1.to_i,
-                                  $2.to_i,
-                                  $3.to_i,
-                                  $4.to_i
-                                 ].pack('CCCC')
-      elsif host =~ /^[:0-9a-f]+$/  # to IPv6 address
-        raise "TCP/IPv6 over SOCKS is not yet supported (inet_pton missing in Ruby & not supported by Tor"
-        s.write "\004"
-      else                          # to hostname
-        s.write "\xF0\000\003" + [host.size].pack('C') + host
-      end
-      s.write [0].pack('n')  # Port
-      
-      addr, port = s.socks_receive_reply
-      Socksify::debug_notice "Resolved #{host} as #{addr} over SOCKS"
-      addr
-    ensure
-      s.close
-    end
-  end
-end