Python實現簡單的udp打洞（P2P）

大囚長發表於2018-06-26
PythonUDP

UDP穿越NAT的具體設計

   首先，Client A登入伺服器，NAT 1為這次的Session分配了一個埠60000，那麼Server S收到的Client A的地址是200.0.0.132:60000，這就是ClientA的外網地址了。同樣，Client B登入Server S，NAT B給此次Session分配的埠是40000，那麼Server S收到的B的地址是200.0.0.133:40000。

此時，Client A與Client B都可以與ServerS通訊了。如果Client A此時想直接傳送資訊給ClientB，那麼他可以從Server S那兒獲得B的公網地址200.0.0.133:40000，在雙方都是FullCone NAT的情況下，Client A就能夠直接往ClientB的公網IP：Port傳送資料了。

總結一下這個過程：如果ClientA想向Client B傳送資訊，那麼雙方都需要在Server上通訊一次做登記，然後將Client B的公網地址和埠傳送給ClientA，最好Client A直接連線ClientB的公網地址和埠。呵呵，是不是很繞口，不過沒關係，想一想就很清楚了。

注意：以上過程只適合於ConeNAT的情況，如果是Symmetric NAT，那麼當Client A向Client B在NAT裝置上沒有形成一個Session，而只有和ClientB 連線Server的Session，所以NAT裝置是會對包進行丟棄的。不過如何Symmetric NAT的埠是按照順序進行開啟的話，那可以通過Server命令Client B傳送資料給ClientA的IP:Port，然後Client A通過線性埠掃描對埠進行猜測。不過這個方式存在失敗率，而且不能明確瞭解NAT裝置開啟的埠的規律，所以沒有去實現。

四種型別的NAT介紹

NAT的分類：在STUN協議中，根據內部終端的地址(LocalIP:LocalPort)到NAT出口的公網地址(PublicIP:PublicPort)的影射方式，把NAT分為四種型別（英文原文詳見rfc3489標準：http://www.ietf.org/rfc/rfc3489.txt）：

1.Full Cone

這種NAT內部的機器A連線過外網機器C後，NAT會開啟一個埠，然後外網的任何發到這個開啟的埠的UDP資料包都可以到達A.不管是不是C發過來的。

2. Restricted Cone

這種NAT內部的機器A連線過外網的機器C後，NAT開啟一個埠，然後C可以用任何埠和A通訊，其他的外網機器不行。

3. Port Restricted Cone

這種NAT內部的機器A連線過外網的機器C後，NAT開啟一個埠，然後C可以用原來的埠和A通訊，其他的外網機器不行。

4.Symmetic

對於這種NAT.連線不同的外部目標。原來NAT開啟的埠會變化，而Cone NAT不會，雖然可以用埠猜測，但是成功的概率很小，因此放棄這種NAT的UDP打洞。


不同NAT環境下UDP穿透可行性分析

兩側NAT屬於Full Cone NAT

則無論A側NAT屬於Cone NAT還是SymmetricNAT，包都能順利到達B。如果P2P程式設計得好，使得B主動到A的包也能借用A主動發起建立的通道的話，則即使A側NAT屬於Symmetric NAT，B發出的包也能順利到達A。

B側NAT屬於Restricted Cone或PortRestricted Cone

則包不能到達B。再細分兩種情況

（1）、A側NAT屬於RestrictedCone或Port Restricted Cone

雖然先前那個初始包不曾到達B，但該發包過程已經在A側NAT上留下了足夠的記錄。如果在這個記錄沒有超時之前，B也重複和A一樣的動作，即向A發包，雖然A側NAT屬於RestrictedCone或Port Restricted Cone，但先前A側NAT已經認為A已經向B發過包，故B向A發包能夠順利到達A。同理，此後A到B的包，也能順利到達。

（2）、A側NAT屬於SymmetricNAT

因為A側NAT屬於Symmetric NAT，且最初A到Server發包的過程在A側NAT留下了記錄，故A到B發包過程在A側NAT上留下的記錄埠產生了變化。而B向A的發包，只能根據Sever給他的關於A的資訊，發往A，因為A埠受限，故此路不通。再來看B側NAT，由於B也向A發過了包，且B側NAT屬於Restricted Cone或Port Restricted Cone，故在B側NAT上留下的記錄，此後，如果A還繼續向B發包的話（因為同一目標，故仍然使用前面的對映），如果B側NAT屬於Restricted Cone，則從A（210.21.12.140:8001）來的包能夠順利到達B；如果B側NAT屬於PortRestricted Cone，則包永遠無法到達B。

結論1：只要單側NAT屬於Full Cone NAT，即可實現雙向通訊。

結論2：只要兩側NAT都不屬於Symmetric NAT，也可雙向通訊。換種說法，只要兩側NAT都屬於Cone NAT，即可雙向通訊。

結論3：一側NAT屬於Symmetric NAT，另一側NAT屬於Restricted Cone，也可雙向通訊。

結論4，兩個都是Symmetric NAT或者一個是SymmetricNAT、另一個是Port Restricted Cone，則不能雙向通訊。

常見的NAT實現

由於存在有4種NAT的型別，所以在方案設計中，必須要考慮到用哪種軟體或者裝置來模擬NAT環境。我在實現過程中嘗試過了很多選擇，包括Linux下的iptables，海蜘蛛的軟路由，使用CISCO的IOS模擬，window2003自帶的NAT服務，還有VMWARE自帶的NAT網路環境。最終發現window2003和VMWARE是支援full cone nat的。

iptables

通過前人的試驗和我自己的驗證，iptables確實是貨真價實的Symmetric NAT。不過也有人通過改寫在Linux2.4核心下的iptables原始碼將SymmetricNAT改為了Full Cone NAT，也可以通過編寫規則作弊的方式實現full nat cone，不過我最終沒有采取iptables。一是改寫原始碼的方式比較繁瑣，需要修改很多個原始碼檔案。而使用編寫規則作弊的方式也覺得有點自欺欺人了。

window2003

Window 2003自帶有路由和遠端訪問服務，其中包含有NAT服務。經過測試，可以實現完全的Full Cone NAT。

ciscoIOS模擬

我曾使用c3640-is-mz.122-27版本的IOS，通過Dynamips模擬路由器配置NAT，發現不支援Full Cone NAT。可能有老版本的IOS會有支援，不過我沒有一一測試。

Server端程式碼：

  1. #!/usr/bin/python
  2. #coding:utf-8
  3. import socket, sys, SocketServer, threading, thread, time 
  4. SERVER_PORT = 1234
  5. sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
  6. sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) 
  7. sock.bind((”, SERVER_PORT)) 
  8. user_list = [] 
  9. def server_handle(): 
  10. whileTrue: 
  11.         cli_date, cli_pub_add = sock.recvfrom(8192) 
  12.         now_user = [] 
  13.         headder = [] 
  14.         cli_str = {} 
  15.         headder = cli_date.split(‘\t’) 
  16. for one_line in headder: 
  17.             str = {} 
  18.             str = one_line 
  19.             args = str.split(‘:’) 
  20.             cli_str[args[0]] = args[1] 
  21. if cli_str[‘type’] == ‘login’ : 
  22. del cli_str[‘type’] 
  23.             now_user = cli_str 
  24.             now_user[‘cli_pub_ip’] = cli_pub_add[0] 
  25.             now_user[‘cli_pub_port’] = cli_pub_add[1] 
  26.             user_list.append(now_user) 
  27.             toclient = ‘info#%s login in successful , the info from server’%now_user[‘user_name’] 
  28.             sock.sendto(toclient,cli_pub_add) 
  29. print’-‘*100
  30. print”%s 已經登入,公網IP:%s 埠:%d\n”%(now_user[‘user_name’],now_user[‘cli_pub_ip’],now_user[‘cli_pub_port’]) 
  31. print”以下是已經登入的使用者列表”
  32. for one_user in user_list: 
  33. print’使用者名稱:%s 公網ip:%s 公網埠:%s 私網ip:%s 私網埠:%s’%(one_user[‘user_name’],one_user[‘cli_pub_ip’],one_user[‘cli_pub_port’],one_user[‘private_ip’],one_user[‘private_port’]) 
  34. elif cli_str[‘type’] == ‘alive’: 
  35. pass
  36. elif cli_str[‘type’] == ‘logout’ : 
  37. pass
  38. elif cli_str[‘type’] == ‘getalluser’ : 
  39. print’-‘*100
  40. for one_user in user_list : 
  41.                         toclient = ‘getalluser#username:%s pub_ip:%s pub_port:%s pri_ip:%s pri_port:%s’%(one_user[‘user_name’],one_user[‘cli_pub_ip’],one_user[‘cli_pub_port’],one_user[‘private_ip’],one_user[‘private_port’]) 
  42.                         sock.sendto(toclient,cli_pub_add) 
  43. if __name__ == ‘__main__’: 
  44.     thread.start_new_thread(server_handle, ()) 
  45. print’伺服器程式已啟動，等待客戶連線’
  46. whileTrue: 
  47. for one_user in user_list: 
  48.             toclient = ‘keepconnect#111’
  49.             sock.sendto(toclient,(one_user[‘cli_pub_ip’],one_user[‘cli_pub_port’]))  
  50.             time.sleep(1) 




Client端程式碼：



  1. #!/usr/bin/python
  2. #coding:utf-8
  3. import socket, SocketServer, threading, thread, time 
  4. CLIENT_PORT = 4321
  5. SERVER_IP = “200.0.0.128”
  6. SERVER_PORT = 1234
  7. user_list = {} 
  8. local_ip = socket.gethostbyname(socket.gethostname()) 
  9. sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) 
  10. def server_handle(): 
  11. print’客戶端執行緒已經啟動 , 等待其它客戶端連線’
  12. whileTrue: 
  13.         data, addr = sock.recvfrom(8192) 
  14.         data_str = data.split(‘#’) 
  15.         data_type = data_str[0] 
  16.         data_info = data_str[1] 
  17. if data_type == ‘info’ : 
  18. del data_str[0] 
  19. print data_info      
  20. if data_type == ‘getalluser’ : 
  21.             data_sp = data_info.split(’ ‘) 
  22.             user_name = data_sp[0].split(‘:’)[1] 
  23. del data_sp[0] 
  24.             user_list[user_name] = {} 
  25. for one_line in data_sp: 
  26.                 arg = one_line.split(‘:’) 
  27.                 user_list[user_name][arg[0]] = arg[1] 
  28. if data_type == ‘echo’ : 
  29. print data_info 
  30. if data_type == ‘keepconnect’: 
  31.             messeg = ‘type:alive’
  32.             sock.sendto(messeg, addr) 
  33. if __name__ == ‘__main__’: 
  34.     thread.start_new_thread(server_handle, ()) 
  35.     time.sleep(0.1) 
  36.     cmd = raw_input(‘輸入指令>>’) 
  37. whileTrue: 
  38.         args = cmd.split(’ ‘) 
  39. if args[0] == ‘login’: 
  40.             user_name = args[1] 
  41.             local_uname = args[1] 
  42.             address = “private_ip:%s private_port:%d” % (local_ip, CLIENT_PORT) 
  43.             headder = “type:login\tuser_name:%s\tprivate_ip:%s\tprivate_port:%d” % (user_name,local_ip,CLIENT_PORT) 
  44.             sock.sendto(headder, (SERVER_IP, SERVER_PORT)) 
  45. elif args[0] == ‘getalluser’: 
  46.             headder = “type:getalluser\tuser_name:al”
  47.             sock.sendto(headder,(SERVER_IP,SERVER_PORT)) 
  48. print’獲取使用者列表中。。。’
  49.             time.sleep(1) 
  50. for one_user in user_list: 
  51. print’username:%s pub_ip:%s pub_port:%s pri_ip:%s pri_port:%s’%(one_user,user_list[one_user][‘pub_ip’],user_list[one_user][‘pub_port’],user_list[one_user][‘pri_ip’],user_list[one_user][‘pri_port’]) 
  52. elif args[0] == ‘connect’: 
  53.             user_name = args[1] 
  54.             to_user_ip = user_list[user_name][‘pub_ip’] 
  55.             to_user_port = int(user_list[user_name][‘pub_port’]) 
  56. elif args[0] ==’echo’: 
  57.             m = ’ ‘.join(args[1:]) 
  58.             messeg = ‘echo#from %s:%s’%(local_uname,m) 
  59.             sock.sendto(messeg, (to_user_ip, to_user_port)) 
  60.         time.sleep(0.1)  
  61.         cmd = raw_input(‘輸入指令>>’) 

            
            




相關文章