girl 0.95.0 → 1.0.0

data/lib/girl/version.rb

@@ -1,3 +1,3 @@
 module Girl
-  VERSION = '0.95.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: girl
 version: !ruby/object:Gem::Version
-  version: 0.95.0
+  version: 1.0.0
 platform: ruby
 authors:
 - takafan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-15 00:00:00.000000000 Z
+date: 2020-11-21 00:00:00.000000000 Z
 dependencies: []
 description: escape evil.
 email:
@@ -27,8 +27,6 @@ files:
 - lib/girl/proxyd.rb
 - lib/girl/proxyd_custom.rb
 - lib/girl/proxyd_worker.rb
-- lib/girl/udp.rb
-- lib/girl/udpd.rb
 - lib/girl/version.rb
 homepage: https://github.com/takafan/girl
 licenses:

data/lib/girl/udp.rb

@@ -1,326 +0,0 @@
-require 'girl/version'
-require 'socket'
-
-##
-# Girl::Udp - udp透明转发，近端。
-#
-# usage
-# ======
-#
-# Girl::Udpd.new( 3030 ).looping # 远端
-#
-# Girl::Udp.new( 'your.server.ip', 3030, 1313 ).looping # 近端
-#
-# iptables -t nat -A PREROUTING -p udp -d game.server.ip -j REDIRECT --to-ports 1313
-#
-module Girl
-  class Udp
-
-    def initialize( udpd_host, udpd_port = 3030, redir_port = 1313 )
-      @udpd_host = udpd_host
-      @udpd_addr = Socket.sockaddr_in( udpd_port, udpd_host )
-      @mutex = Mutex.new
-      @reads = []
-      @writes = []
-      @roles = {}        # :dotr / :redir / :tun
-      @redir_wbuffs = [] # [ src_addr data ] ...
-      @tuns = {}         # [ orig_src_addr dst_addr ]=> tun
-      @mappings = {}     # src_addr => [ orig_src_addr dst_addr ]
-      @tun_infos = {}    # tun => {}
-                         #   orig_src_addr: sockaddr
-                         #   dst_addr: sockaddr
-                         #   src_addr: sockaddr
-                         #   tund_addr: sockaddr
-                         #   rbuffs: []
-                         #   wbuffs: []
-                         #   last_traff_at: now
-      dotr, dotw = IO.pipe
-      @dotw = dotw
-      add_read( dotr, :dotr )
-      new_a_redir( redir_port )
-    end
-
-    def looping
-      loop_expire
-
-      loop do
-        rs, ws = IO.select( @reads, @writes )
-
-        @mutex.synchronize do
-          rs.each do | sock |
-            case @roles[ sock ]
-            when :dotr then
-              read_dotr( sock )
-            when :redir then
-              read_redir( sock )
-            when :tun then
-              read_tun( sock )
-            end
-          end
-
-          ws.each do | sock |
-            case @roles[ sock ]
-            when :redir then
-              write_redir( sock )
-            when :tun then
-              write_tun( sock )
-            end
-          end
-        end
-      end
-    end
-
-    def quit!
-      exit
-    end
-
-    private
-
-    def loop_expire
-      Thread.new do
-        loop do
-          sleep 30
-
-          @mutex.synchronize do
-            trigger = false
-            now = Time.new
-
-            @tun_infos.each do | tun, tun_info |
-              # net.netfilter.nf_conntrack_udp_timeout_stream
-              if now - tun_info[ :last_traff_at ] > 180 then
-                set_is_closing( tun )
-                trigger = true
-              end
-            end
-
-            next_tick if trigger
-          end
-        end
-      end
-    end
-
-    def new_a_redir( redir_port )
-      redir = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      redir.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      redir.bind( Socket.sockaddr_in( redir_port, '0.0.0.0' ) )
-      puts "redir bound on #{ redir_port } #{ Time.new }"
-      @redir = redir
-      add_read( redir, :redir )
-    end
-
-    def new_a_tun( orig_src_addr, dst_addr, src_addr )
-      tun = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      tun.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      tun.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-
-      @tun_infos[ tun ] = {
-        orig_src_addr: orig_src_addr,
-        dst_addr: dst_addr,
-        src_addr: src_addr,
-        tund_addr: nil,
-        rbuffs: [],
-        wbuffs: [],
-        last_traff_at: Time.new,
-        is_closing: false
-      }
-
-      @tuns[ [ orig_src_addr, dst_addr ].join ] = tun
-      add_read( tun, :tun )
-
-      tun
-    end
-
-    def add_redir_wbuff( redir, to_addr, data )
-      @redir_wbuffs << [ to_addr, data ]
-      add_write( redir )
-    end
-
-    def add_tun_wbuff( tun, to_addr, data )
-      tun_info = @tun_infos[ tun ]
-
-      if to_addr then
-        tun_info[ :wbuffs ] << [ to_addr, data ]
-        add_write( tun )
-      else
-        tun_info[ :rbuffs ] << data
-      end
-    end
-
-    def add_read( sock, role )
-      unless @reads.include?( sock ) then
-        @reads << sock
-      end
-
-      @roles[ sock ] = role
-    end
-
-    def add_write( sock )
-      unless @writes.include?( sock ) then
-        @writes << sock
-      end
-    end
-
-    def set_is_closing( tun )
-      if tun && !tun.closed? then
-        # puts "debug1 set tun is closing"
-
-        tun_info = @tun_infos[ tun ]
-        tun_info[ :is_closing ] = true
-
-        @reads.delete( tun )
-        add_write( tun )
-      end
-    end
-
-    def send_data( sock, data, to_addr )
-      begin
-        sock.sendmsg( data, 0, to_addr )
-      rescue IO::WaitWritable, Errno::EINTR
-        return false
-      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN => e
-        if @roles[ sock ] == :tun then
-          puts "#{ Time.new } #{ e.class }, close tun"
-          close_tun( sock )
-          return false
-        end
-      end
-
-      true
-    end
-
-    def close_tun( tun )
-      tun.close
-      @reads.delete( tun )
-      @writes.delete( tun )
-      @roles.delete( tun )
-      tun_info = @tun_infos.delete( tun )
-      @tuns.delete( [ tun_info[ :orig_src_addr ], tun_info[ :dst_addr ] ].join )
-
-      if @mappings.include?( tun_info[ :src_addr ] ) then
-        orig_src_addr, dst_addr, timeout, read_at = @mappings[ tun_info[ :src_addr ] ]
-
-        if orig_src_addr == tun_info[ :orig_src_addr ] && dst_addr == tun_info[ :dst_addr ] then
-          @mappings.delete( tun_info[ :src_addr ] )
-        end
-      end
-    end
-
-    def write_redir( redir )
-      while @redir_wbuffs.any? do
-        to_addr, data = @redir_wbuffs.first
-        return unless send_data( redir, data, to_addr )
-        @redir_wbuffs.shift
-      end
-
-      @writes.delete( redir )
-    end
-
-    def write_tun( tun )
-      tun_info = @tun_infos[ tun ]
-
-      if tun_info[ :is_closing ] then
-        close_tun( tun )
-        return
-      end
-
-      while tun_info[ :wbuffs ].any? do
-        to_addr, data = tun_info[ :wbuffs ].first
-        return unless send_data( tun, data, to_addr )
-        tun_info[ :wbuffs ].shift
-      end
-
-      @writes.delete( tun )
-    end
-
-    def read_dotr( dotr )
-      dotr.read( 1 )
-    end
-
-    def read_redir( redir )
-      data, addrinfo, rflags, *controls = redir.recvmsg
-      src_addr = addrinfo.to_sockaddr
-      is_hit_cache = false
-      now = Time.new
-      # puts "debug redir recv #{ data.inspect } from #{ addrinfo.inspect }"
-
-      if @mappings.include?( src_addr ) then
-        orig_src_addr, dst_addr, timeout, read_at = @mappings[ src_addr ]
-
-        if now - read_at < timeout then
-          # puts "debug hit cache #{ addrinfo.inspect }"
-          is_hit_cache = true
-        else
-          # puts "debug cache timeout #{ addrinfo.inspect }"
-          @mappings.delete( src_addr )
-        end
-      end
-
-      unless is_hit_cache then
-        # 2 udp 4 timeout 5 src 7 sport 9 [UNREPLIED] 11 dst 13 dport
-        # 2 udp 4 timeout 5 src 7 sport 10 dst 12 dport
-        bin = IO.binread( '/proc/net/nf_conntrack' )
-        rows = bin.split( "\n" ).map { | line | line.split( ' ' ) }
-        row = rows.find { | _row | _row[ 2 ] == 'udp' && ( ( _row[ 10 ].split( '=' )[ 1 ] == addrinfo.ip_address && _row[ 12 ].split( '=' )[ 1 ].to_i == addrinfo.ip_port ) || ( _row[ 9 ] == '[UNREPLIED]' && _row[ 11 ].split( '=' )[ 1 ] == addrinfo.ip_address && _row[ 13 ].split( '=' )[ 1 ].to_i == addrinfo.ip_port ) ) }
-
-        unless row then
-          puts "miss conntrack #{ addrinfo.inspect } #{ Time.new }"
-          IO.binwrite( '/tmp/nf_conntrack', bin )
-          return
-        end
-
-        timeout = row[ 4 ].to_i
-        orig_src_ip = row[ 5 ].split( '=' )[ 1 ]
-        orig_src_port = row[ 7 ].split( '=' )[ 1 ].to_i
-        dst_ip = row[ 6 ].split( '=' )[ 1 ]
-        dst_port = row[ 8 ].split( '=' )[ 1 ].to_i
-        orig_src_addr = Socket.sockaddr_in( orig_src_port, orig_src_ip )
-        dst_addr = Socket.sockaddr_in( dst_port, dst_ip )
-
-        if Addrinfo.new( dst_addr ).ipv4_private? then
-          puts "dst is private? #{ Addrinfo.new( dst_addr ).inspect } #{ Addrinfo.new( src_addr ).inspect } #{ Addrinfo.new( orig_src_addr ).inspect } #{ Time.new }"
-          add_redir_wbuff( redir, dst_addr, data )
-          return
-        end
-
-        # puts "debug save cache #{ addrinfo.inspect } #{ Addrinfo.new( orig_src_addr ).inspect } #{ Addrinfo.new( dst_addr ).inspect } #{ timeout } #{ now }"
-        @mappings[ src_addr ] = [ orig_src_addr, dst_addr, timeout, now ]
-      end
-
-      tun = @tuns[ [ orig_src_addr, dst_addr ].join ]
-
-      unless tun then
-        tun = new_a_tun( orig_src_addr, dst_addr, src_addr )
-
-        # puts "debug tun send to udpd #{ Addrinfo.new( orig_src_addr ).inspect } #{ Addrinfo.new( dst_addr ).inspect }"
-        ctlmsg = [ orig_src_addr, dst_addr ].join
-        add_tun_wbuff( tun, @udpd_addr, ctlmsg )
-      end
-
-      tun_info = @tun_infos[ tun ]
-      add_tun_wbuff( tun, tun_info[ :tund_addr ], data )
-    end
-
-    def read_tun( tun )
-      data, addrinfo, rflags, *controls = tun.recvmsg
-      from_addr = addrinfo.to_sockaddr
-      tun_info = @tun_infos[ tun ]
-      tun_info[ :last_traff_at ] = Time.new
-
-      if from_addr == @udpd_addr then
-        tund_port = data[ 0, 2 ].unpack( 'n' ).first
-        tund_addr = Socket.sockaddr_in( tund_port, @udpd_host )
-        tun_info[ :tund_addr ] = tund_addr
-
-        if tun_info[ :rbuffs ].any? then
-          tun_info[ :wbuffs ] += tun_info[ :rbuffs ].map{ | rbuff | [ tund_addr, rbuff ] }
-          tun_info[ :rbuffs ].clear
-          add_write( tun )
-        end
-
-      elsif from_addr == tun_info[ :tund_addr ] then
-        add_redir_wbuff( @redir, tun_info[ :src_addr ], data )
-      end
-    end
-
-  end
-end

data/lib/girl/udpd.rb

@@ -1,316 +0,0 @@
-require 'girl/version'
-require 'socket'
-
-##
-# Girl::Udpd - udp透明转发，远端。
-#
-module Girl
-  class Udpd
-
-    def initialize( port = 3030 )
-      @mutex = Mutex.new
-      @reads = []
-      @writes = []
-      @roles = {}       # :dotr / :udpd / :tund
-      @udpd_wbuffs = [] # [ tun_addr ctlmsg ] ...
-      @tunds = {}       # [ tun_ip_addr orig_src_addr ] => tund
-      @tund_infos = {}  # tund => {}
-                        #   port: port
-                        #   tun_ip_addr: sockaddr
-                        #   orig_src_addr: sockaddr
-                        #   wbuffs: [] # [ to_addr, data ] ...
-                        #   dst_addrs: { tun_addr => dst_addr }
-                        #   tun_addrs: { dst_addr => tun_addr }
-                        #   is_tunneleds: { [ tun_addr dst_addr ] => false }
-                        #   unpaired_dst_rbuffs: { dst_addr => [] }
-                        #   last_traff_at: now
-      dotr, dotw = IO.pipe
-      @dotw = dotw
-      add_read( dotr, :dotr )
-      new_a_udpd( port )
-    end
-
-    def looping
-      loop_expire
-
-      loop do
-        rs, ws = IO.select( @reads, @writes )
-
-        @mutex.synchronize do
-          ws.each do | sock |
-            case @roles[ sock ]
-            when :udpd then
-              write_udpd( sock )
-            when :tund then
-              write_tund( sock )
-            end
-          end
-
-          rs.each do | sock |
-            case @roles[ sock ]
-            when :dotr then
-              read_dotr( sock )
-            when :udpd then
-              read_udpd( sock )
-            when :tund then
-              read_tund( sock )
-            end
-          end
-        end
-      end
-    end
-
-    def quit!
-      exit
-    end
-
-    private
-
-    def loop_expire
-      Thread.new do
-        loop do
-          sleep 30
-
-          @mutex.synchronize do
-            trigger = false
-            now = Time.new
-
-            @tund_infos.each do | tund, tund_info |
-              # net.netfilter.nf_conntrack_udp_timeout_stream
-              if now - tund_info[ :last_traff_at ] > 180 then
-                set_is_closing( tund )
-                trigger = true
-              end
-            end
-
-            next_tick if trigger
-          end
-        end
-      end
-    end
-
-    def new_a_udpd( port )
-      udpd = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      udpd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      udpd.bind( Socket.sockaddr_in( port, '0.0.0.0' ) )
-      puts "udpd bound on #{ port } #{ Time.new }"
-      @udpd = udpd
-      add_read( udpd, :udpd )
-    end
-
-    def pair_tund( tun_addr, tun_ip_addr, orig_src_addr, dst_addr )
-      from_addr = [ tun_ip_addr, orig_src_addr ].join
-      td_addr = [ tun_addr, dst_addr ].join
-      tund = @tunds[ from_addr ]
-
-      if tund then
-        tund_info = @tund_infos[ tund ]
-        tund_info[ :dst_addrs ][ tun_addr ] = dst_addr
-        tund_info[ :tun_addrs ][ dst_addr ] = tun_addr
-        tund_info[ :is_tunneleds ][ td_addr ] = false
-      else
-        tund = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-        tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-        tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1 )
-        tund.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-        tund_port = tund.local_address.ip_unpack.last
-
-        @tund_infos[ tund ] = {
-          port: tund_port,
-          tun_ip_addr: tun_ip_addr,
-          orig_src_addr: orig_src_addr,
-          wbuffs: [],
-          dst_addrs: { tun_addr => dst_addr },
-          tun_addrs: { dst_addr => tun_addr },
-          is_tunneleds: { td_addr => false },
-          unpaired_dst_rbuffs: {},
-          last_traff_at: Time.new,
-          is_closing: false
-        }
-
-        @tunds[ from_addr ] = tund
-        add_read( tund, :tund )
-      end
-
-      tund
-    end
-
-    def add_tund_wbuff( tund, to_addr, data )
-      tund_info = @tund_infos[ tund ]
-      tund_info[ :wbuffs ] << [ to_addr, data ]
-
-      add_write( tund )
-    end
-
-    def add_read( sock, role )
-      unless @reads.include?( sock ) then
-        @reads << sock
-      end
-
-      @roles[ sock ] = role
-    end
-
-    def add_write( sock )
-      unless @writes.include?( sock ) then
-        @writes << sock
-      end
-    end
-
-    def set_is_closing( tund )
-      if tund && !tund.closed? then
-        # puts "debug1 set tund is closing"
-
-        tund_info = @tund_infos[ tund ]
-        tund_info[ :is_closing ] = true
-
-        @reads.delete( tund )
-        add_write( tund )
-      end
-    end
-
-    def send_data( sock, data, to_addr )
-      begin
-        sock.sendmsg( data, 0, to_addr )
-      rescue IO::WaitWritable, Errno::EINTR
-        return false
-      rescue Errno::EHOSTUNREACH, Errno::ENETUNREACH, Errno::ENETDOWN => e
-        if @roles[ sock ] == :tund then
-          puts "#{ Time.new } #{ e.class }, close tund"
-          close_tund( sock )
-          return false
-        end
-      end
-
-      true
-    end
-
-    def close_tund( tund )
-      tund.close
-      @reads.delete( tund )
-      @writes.delete( tund )
-      @roles.delete( tund )
-      tund_info = @tund_infos.delete( tund )
-      @tunds.delete( [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join )
-    end
-
-    def next_tick
-      @dotw.write( '.' )
-    end
-
-    def write_udpd( udpd )
-      while @udpd_wbuffs.any? do
-        to_addr, data = @udpd_wbuffs.first
-        return unless send_data( udpd, data, to_addr )
-        @udpd_wbuffs.shift
-      end
-
-      @writes.delete( udpd )
-    end
-
-    def write_tund( tund )
-      tund_info = @tund_infos[ tund ]
-
-      if tund_info[ :is_closing ] then
-        close_tund( tund )
-        return
-      end
-
-      while tund_info[ :wbuffs ].any? do
-        to_addr, data = tund_info[ :wbuffs ].first
-        return unless send_data( tund, data, to_addr )
-        tund_info[ :wbuffs ].shift
-      end
-
-      @writes.delete( tund )
-    end
-
-    def read_dotr( dotr )
-      dotr.read( 1 )
-    end
-
-    def read_udpd( udpd )
-      data, addrinfo, rflags, *controls = udpd.recvmsg
-      # puts "debug udpd recv #{ data.inspect } from #{ addrinfo.inspect }"
-      orig_src_addr = data[ 0, 16 ]
-      dst_addr = data[ 16, 16 ]
-      tun_addr = addrinfo.to_sockaddr
-      tun_ip_addr = Addrinfo.ip( addrinfo.ip_address ).to_sockaddr
-
-      return unless Addrinfo.new( orig_src_addr ).ipv4?
-
-      dst_addrinfo = Addrinfo.new( dst_addr )
-      return unless dst_addrinfo.ipv4?
-      return if dst_addrinfo.ipv4_private?
-
-      tund = pair_tund( tun_addr, tun_ip_addr, orig_src_addr, dst_addr )
-      tund_info = @tund_infos[ tund ]
-      tund_port = tund_info[ :port ]
-
-      # puts "debug udpd send to tun #{ tund_port } #{ addrinfo.inspect }"
-      ctlmsg = [ tund_port ].pack( 'n' )
-      @udpd_wbuffs << [ tun_addr, ctlmsg ]
-      add_write( udpd )
-    end
-
-    def read_tund( tund )
-      data, addrinfo, rflags, *controls = tund.recvmsg
-      from_addr = addrinfo.to_sockaddr
-      tund_info = @tund_infos[ tund ]
-      tund_info[ :last_traff_at ] = Time.new
-      to_addr = tund_info[ :dst_addrs ][ from_addr ]
-
-      if to_addr then
-        # 来自tun，发给dst。
-        td_addr = [ from_addr, to_addr ].join
-        is_tunneled = tund_info[ :is_tunneleds ][ td_addr ]
-
-        unless is_tunneled then
-          # puts "debug first traffic from tun #{ addrinfo.inspect } to #{ Addrinfo.new( to_addr ).inspect }"
-          # 发暂存
-          if tund_info[ :unpaired_dst_rbuffs ].include?( to_addr ) then
-            rbuffs = tund_info[ :unpaired_dst_rbuffs ].delete( to_addr )
-            # puts "debug move tund.dst.rbuffs to tund.wbuffs #{ rbuffs.inspect }"
-            tund_info[ :wbuffs ] += rbuffs.map{ | rbuff | [ from_addr, rbuff ] }
-          end
-
-          tund_info[ :is_tunneleds ][ td_addr ] = true
-        end
-
-        # 如果对面没来过流量，且在nat里，nat规则是只对去过的目的地做接收，那么，先过去的流量会撞死。
-        # 没关系，撞死的流量通常是打洞数据，在应用计算之内，打洞数据通常是连发的。
-        # puts "debug #{ data.inspect } from #{ addrinfo.inspect } to #{ Addrinfo.new( to_addr ).inspect }"
-        add_tund_wbuff( tund, to_addr, data )
-        return
-      end
-
-      to_addr = tund_info[ :tun_addrs ][ from_addr ]
-
-      if to_addr then
-        # 来自dst，发给tun。
-        # puts "debug #{ data.inspect } from #{ addrinfo.inspect } to #{ Addrinfo.new( to_addr ).inspect }"
-
-        td_addr = [ to_addr, from_addr ].join
-        is_tunneled = tund_info[ :is_tunneleds ][ td_addr ]
-
-        if is_tunneled then
-          add_tund_wbuff( tund, to_addr, data )
-          return
-        end
-
-        # puts "debug #{ Addrinfo.new( to_addr ).inspect } #{ addrinfo.inspect } not tunneled"
-      end
-
-      # 来自未知的地方，或者对应的tun还没来流量，记暂存
-      unless tund_info[ :unpaired_dst_rbuffs ][ from_addr ] then
-        tund_info[ :unpaired_dst_rbuffs ][ from_addr ] = []
-      end
-
-      # 暂存5条（连发打洞数据，不需要存多）。
-      if tund_info[ :unpaired_dst_rbuffs ][ from_addr ].size < 5 then
-        # puts "debug save other dst rbuff #{ addrinfo.inspect } #{ data.inspect }"
-        tund_info[ :unpaired_dst_rbuffs ][ from_addr ] << data
-      end
-    end
-
-  end
-end