udpip: 用UDP封装IP数据包建立VPN

2012年2月23日 | 分类: 翻墙相关 | 标签: , , , ,

原理

使用Linux内核提供的tun设备建立可以在脚本读写的虚拟网卡，然后通过UDP将两个网卡的数据连接。
此方法能够使用以下特殊环境下：

1、客户端所在网络的路由不支持ppp，或者网络受到限制
2、TCP数据包被劫持或者受到限制
3、服务器是OpenVZ等不支持建立pptp，像我的burst的VPS就是这样子。

使用

服务器：

# python udptun.py -s 86 -l 10.0.0.1/24
Configuring interface t0 with ip 10.0.0.1/24

客户端：

# python udptun.py -c xiaoxia.org,86 -l 10.0.0.2/24
Configuring interface t0 with ip 10.0.0.2/24
Setting up new gateway …
Do login …
Logged in server succefully!

脚本代码

udptun.py:

  1. #!/usr/bin/python
  3. ””’
  4.     UDP Tunnel VPN
  5.     Xiaoxia (xiaoxia@xiaoxia.org)
  6.     Updated: 2012-2-21
  7. ”’
  9. import os, sys
  10. import hashlib
  11. import getopt
  12. import fcntl
  13. import time
  14. import struct
  15. import socket, select
  16. import traceback
  17. import signal
  18. import ctypes
  19. import binascii
  21. SHARED_PASSWORD = hashlib.sha1(“xiaoxia”).digest()
  22. TUNSETIFF = 0x400454ca
  23. IFF_TUN   = 0×0001
  25. BUFFER_SIZE = 8192
  26. MODE = 0
  27. DEBUG = 0
  28. PORT = 0
  29. IFACE_IP = ”10.0.0.1/24″
  30. MTU = 1500
  31. TIMEOUT = 60*10 # seconds
  33. class Tunnel():
  34.     def create(self):
  35.         try:
  36.             self.tfd = os.open(“/dev/net/tun”, os.O_RDWR)
  37.         except:
  38.             self.tfd = os.open(“/dev/tun”, os.O_RDWR)
  39.         ifs = fcntl.ioctl(self.tfd, TUNSETIFF, struct.pack(“16sH”, ”t%d”, IFF_TUN))
  40.         self.tname = ifs[:16].strip(“\x00″)
  42.     def close(self):
  43.         os.close(self.tfd)
  45.     def config(self, ip):
  46.         print ”Configuring interface %s with ip %s” % (self.tname, ip)
  47.         os.system(“ip link set %s up” % (self.tname))
  48.         os.system(“ip link set %s mtu 1000″ % (self.tname))
  49.         os.system(“ip addr add %s dev %s” % (ip, self.tname))
  51.     def config_routes(self):
  52.         if MODE == 1: # Server
  53.             pass
  54.         else: # Client
  55.             print ”Setting up new gateway …”
  56.             # Look for default route
  57.             routes = os.popen(“ip route show”).readlines()
  58.             defaults = [x.rstrip() for x in routes if x.startswith("default")]
  59.             if not defaults:
  60.                 raise Exception(“Default route not found, maybe not connected!”)
  61.             self.prev_gateway = defaults[0]
  62.             self.prev_gateway_metric = self.prev_gateway + ” metric 2″
  63.             self.new_gateway = ”default dev %s metric 1″ % (self.tname)
  64.             self.tun_gateway = self.prev_gateway.replace(“default”, IP)
  65.             self.old_dns = file(“/etc/resolv.conf”, ”rb”).read()
  66.             # Remove default gateway
  67.             os.system(“ip route del ” + self.prev_gateway)
  68.             # Add default gateway with metric
  69.             os.system(“ip route add ” + self.prev_gateway_metric)
  70.             # Add exception for server
  71.             os.system(“ip route add ” + self.tun_gateway)
  72.             # Add new default gateway
  73.             os.system(“ip route add ” + self.new_gateway)
  74.             # Set new DNS to 8.8.8.8
  75.             file(“/etc/resolv.conf”, ”wb”).write(“nameserver 8.8.8.8″)
  77.     def restore_routes(self):
  78.         if MODE == 1: # Server
  79.             pass
  80.         else: # Client
  81.             print ”Restoring previous gateway …”
  82.             os.system(“ip route del ” + self.new_gateway)
  83.             os.system(“ip route del ” + self.prev_gateway_metric)
  84.             os.system(“ip route del ” + self.tun_gateway)
  85.             os.system(“ip route add ” + self.prev_gateway)
  86.             file(“/etc/resolv.conf”, ”wb”).write(self.old_dns)
  88.     def run(self):
  89.         global PORT
  90.         self.udpfd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  91.         if MODE == 1:
  92.             self.udpfd.bind((“”, PORT))
  93.         else:
  94.             self.udpfd.bind((“”, 0))
  96.         self.clients = {}
  97.         self.logged = False
  98.         self.try_logins = 5
  99.         self.log_time = 0
  101.         while True:
  102.             if MODE == 2 and not self.logged and time.time() - self.log_time > 2.:
  103.                 print ”Do login …”
  104.                 self.udpfd.sendto(“LOGIN:” + SHARED_PASSWORD + ”:” +
  105.                     IFACE_IP.split(“/”)[0], (IP, PORT))
  106.                 self.try_logins -= 1
  107.                 if self.try_logins == 0:
  108.                     raise Exception(“Failed to log in server.”)
  109.                 self.log_time = time.time()
  111.             rset = select.select([self.udpfd, self.tfd], [], [], 1)[0]
  112.             for r in rset:
  113.                 if r == self.tfd:
  114.                     if DEBUG: os.write(1, ”>”)
  115.                     data = os.read(self.tfd, MTU)
  116.                     if MODE == 1: # Server
  117.                         src, dst = data[16:20], data[20:24]
  118.                         for key in self.clients:
  119.                             if dst == self.clients[key]["localIPn"]:
  120.                                 self.udpfd.sendto(data, key)
  121.                         # Remove timeout clients
  122.                         curTime = time.time()
  123.                         for key in self.clients.keys():
  124.                             if curTime - self.clients[key]["aliveTime"] > TIMEOUT:
  125.                                 print ”Remove timeout client”, key
  126.                                 del self.clients[key]
  127.                     else: # Client
  128.                         self.udpfd.sendto(data, (IP, PORT))
  129.                 elif r == self.udpfd:
  130.                     if DEBUG: os.write(1, ”<”)
  131.                     data, src = self.udpfd.recvfrom(BUFFER_SIZE)
  132.                     if MODE == 1: # Server
  133.                         key = src
  134.                         if key not in self.clients:
  135.                             # New client comes
  136.                             try:
  137.                                 if data.startswith(“LOGIN:”) and data.split(“:”)[1]==SHARED_PASSWORD:
  138.                                     localIP = data.split(“:”)[2]
  139.                                     self.clients[key] = {“aliveTime”: time.time(),
  140.                                                         ”localIPn”: socket.inet_aton(localIP)}
  141.                                     print ”New Client from”, src, ”request IP”, localIP
  142.                                     self.udpfd.sendto(“LOGIN:SUCCESS”, src)
  143.                             except:
  144.                                 print ”Need valid password from”, src
  145.                                 self.udpfd.sendto(“LOGIN:PASSWORD”, src)
  146.                         else:
  147.                             # Simply write the packet to local or forward them to other clients ???
  148.                             os.write(self.tfd, data)
  149.                             self.clients[key]["aliveTime"] = time.time()
  150.                     else: # Client
  151.                         if data.startswith(“LOGIN”):
  152.                             if data.endswith(“PASSWORD”):
  153.                                 self.logged = False
  154.                                 print ”Need password to login!”
  155.                             elif data.endswith(“SUCCESS”):
  156.                                 self.logged = True
  157.                                 self.try_logins = 5
  158.                                 print ”Logged in server succefully!”
  159.                         else:
  160.                             os.write(self.tfd, data)
  162. def usage(status = 0):
  163.     print ”Usage: %s [-s port|-c serverip] [-hd] [-l localip]“ % (sys.argv[0])
  164.     sys.exit(status)
  166. def on_exit(no, info):
  167.     raise Exception(“TERM signal caught!”)
  169. if __name__==”__main__”:
  170.     opts = getopt.getopt(sys.argv[1:],”s:c:l:hd”)
  171.     for opt,optarg in opts[0]:
  172.         if opt == ”-h”:
  173.             usage()
  174.         elif opt == ”-d”:
  175.             DEBUG += 1
  176.         elif opt == ”-s”:
  177.             MODE = 1
  178.             PORT = int(optarg)
  179.         elif opt == ”-c”:
  180.             MODE = 2
  181.             IP, PORT = optarg.split(“,”)
  182.             IP = socket.gethostbyname(IP)
  183.             PORT = int(PORT)
  184.         elif opt == ”-l”:
  185.             IFACE_IP = optarg
  187.     if MODE == 0 or PORT == 0:
  188.         usage(1)
  190.     tun = Tunnel()
  191.     tun.create()
  192.     tun.config(IFACE_IP)
  193.     signal.signal(signal.SIGTERM, on_exit)
  194.     tun.config_routes()
  195.     try:
  196.         tun.run()
  197.     except KeyboardInterrupt:
  198.         pass
  199.     except:
  200.         print traceback.format_exc()
  201.     finally:
  202.         tun.restore_routes()
  203.         tun.close()

来源：http://xiaoxia.org/2012/02/21/udpip-vpn/

发表评论
  1. 小zz的好基友
    2012年2月23日09:51
    回复 | 引用 | #1

    看起来挺不错，没有机会实验。

  2. GayShyFool
    2012年2月23日17:59
    回复 | 引用 | #2

    貌似好东西呀，电信路由器限制就是只拦截tcp，要是用这个的话估计就无敌了~……就是没有vps试试

  3. 天生多疑
    2012年2月23日20:11
    回复 | 引用 | #3

    xiaoxia这家伙，研究网络协议很深入。

  4. 天生多疑
    2012年2月23日20:12
    回复 | 引用 | #4

    希望TA能搞个自己的协议出来，兼容其他所有协议，然后我们就畅通无阻的上网，呵呵.

  5. ym
    2012年2月23日20:58
    回复 | 引用 | #5

    hi.博主用vpn能访问youtube吗？我这里显示connection reset,其他被封网站均可访问。真是活见鬼了

    • GayShyFool
      2012年2月23日22:35
      回复 | 引用 | #6

      ym :hi.博主用vpn能访问youtube吗？我这里显示connection reset,其他被封网站均可访问。真是活见鬼了

      可能你用的vpn限制youtube，换一个试试

    • iGFW
      2012年2月24日08:32
      回复 | 引用 | #7

      能，你修改本机DNS为国外，然后刷新本机DNS缓存和浏览器缓存再试试。

  6. wave
    2012年2月24日09:39
    回复 | 引用 | #8

    呵呵 有些复杂 博主要是能修改一下大众都能易懂就更好了

    • iGFW
      2012年2月24日10:56
      回复 | 引用 | #9

      呵呵，这个我也不懂