為什麼兩個都掛在 NAT 後面的電腦,明明各自都能上網,卻很難直接連上對方?答案藏在 NAT 的連線追蹤機制裡,而破解之道是一套叫做 UDP Hole Punching 的技巧。
NAT(Network Address Translator,網路位址轉換)出現的背景是 IP 位址不夠用,核心目的是位址重用。它大體分兩類。
基本 NAT:最早提出的版本,立論前提是一個私有網段中只有少數節點需要對外溝通,因此只有這些節點需要全球唯一 IP,其餘的可以重用。運作方式是在子網內使用保留的私有 IP 段,對外不可見;當內部節點要出網時,NAT 把來源 IP 換成一個全球唯一 IP 再送出去。請注意:基本 NAT 只改 IP,不改連接埠。相關定義可參考 RFC 1631。
NAPT( also 常被泛稱 NAT):它不只改 IP,還會改寫 TCP/UDP 的連接埠。日常我們遇到的家用路由器幾乎都是這一類,也是本文真正的主角。
設想私有網段 10.0.0.0/8 中的 Client A(10.0.0.1),其閘道 NAT 對外 IP 是 155.99.25.11。A 上某個行程開了一個綁定 1234 埠的 UDP Socket,要存取外部主機 18.181.0.31 的 1235 埠。
封包經過 NAT 時會發生这些事:NAT 把來源 IP 改成 155.99.25.11;接著為這條傳輸建立一個 Session,並分配一個埠號(例如 62000),把來源埠也改成 62000。於是原本 10.0.0.1:1234 → 18.181.0.31:1235 的封包,在網際網路上變成 155.99.25.11:62000 → 18.181.0.31:1235。
關鍵在於:Session 建立之後,NAT 會記住「62000 對應 10.0.0.1 的 1234」。此後凡是 18.181.0.31 送來 62000 的封包,NAT 都會自動轉給 10.0.0.1;其他 IP 送來的則直接丟棄。Client A 就這樣與 Server S1 建立了雙向通路。
Session 是個抽象概念。TCP 的 Session 也許從 SYN 開始、到 FIN 結束;UDP 則從這個 IP 這個埠的第一個封包開始,結束時間可能是幾分鐘,也可能是幾小時,取決於實作。
接著讓 A 的那個 Socket 再對另一台 Server S2 送一個封包。這時有兩種可能:
· NAT 再開一個 Session,並重新分配一個埠號(例如 62001)——這叫 Symmetric NAT。
· NAT 再開一個 Session,但沿用原本的 62000——這叫 Cone NAT。
P2P 需要的是後者。如果你的 NAT 屬於前者,多數 P2P 軟體都會失靈。所幸目前市面上的 NAT 絕大多數是 Cone NAT。
內網主機向外連線很簡單,NAT 幾乎是透明的;反過來,外部主機要主動連進內網就困難得多——而這正是 P2P 的需求。
解法是在 NAT 上「打一個洞」,也就是建立一個 Session。這個洞有兩個限制:一是不能由外部建立,必須由內網主機發起;二是它有方向性。當內部某台主機(例如 192.168.0.10)向外部某個 IP(例如 219.237.60.1)送出一個 UDP 封包,NAT 上就開了一個「朝向 219.237.60.1」的洞,之後這個 IP 就能透過它與內部主機通訊,其他 IP 依然被擋在外面。這就是 UDP Hole Punching。
於是出現一個死結:兩邊都在內網,誰也不知道對方的公網位址,誰也無法主動連線——那這個洞到底由誰先打?答案是需要一個中間人。
流程如下:
1. Client A(192.168.0.20:4000)登入位於公網的 Server S。NAT A 為這條 Session 分配 60000,於是 S 看到的 A 是 202.187.45.3:60000,這就是 A 的公網位址。Client B 同樣登入,S 看到的 B 是 187.34.1.56:40000。
2. A 向 S 索取 B 的公網位址。若 A 直接對 187.34.1.56:40000 送封包,會失敗——因為 NAT B 上沒有對應的 Session,這個「不請自來」的封包基於安全會被丟棄。
3. 正確做法是讓 B 先朝 A 的方向打洞。這個指令由 S 下達:A 送請求給 S,S 轉告 B「請向這個位址送一個封包」。B 照做之後,NAT B 上就開了一個朝向 A 的洞,A 隨後送出的資料便能抵達 B。
用一句話總結:A 想連 B,就請 S 叫 B 先朝 A 打洞,之後兩邊即可直接互通。
這個流程只適用於 Cone NAT。若雙方有一邊是 Symmetric NAT,打洞時用的埠已經被重新分配,對方無從得知新埠號。有人主張可以「猜」相鄰埠號(若作業系統是順序分配),但失敗因素太多,不建議依賴。
以下是一份最小可用的協定定義,共用的訊息類型與資料結構:
#define LOGIN 1 // 用戶端登入
#define LOGOUT 2 // 用戶端登出
#define P2PTRANS 3 // 請求伺服器通知對方打洞
#define GETALLUSER 4 // 取得線上人數與列表
#define SERVER_PORT 2280
// 用戶節點資訊
struct stUserListNode {
char userName[10];
unsigned int ip;
unsigned short port;
};
// 用戶端 → 伺服器
struct stMessage {
int iMessageType;
union {
struct { char userName[10]; char passWord[10]; } loginmember;
struct { char userName[10]; } logoutmember;
struct { char userName[10]; } translatemessage;
} message;
};
// 用戶端之間
#define P2PMESSAGE 100 // 傳送訊息
#define P2PMESSAGEACK 101 // 收到訊息的應答
#define P2PSOMEONEWANTTOCALLYOU 102 // 伺服器要求該用戶端打洞
#define P2PTRASH 103 // 打洞封包,接收端應忽略
struct stP2PMessage {
int iMessageType;
int iStringLen; // 訊息長度,或對方 IP
unsigned short Port;
};
伺服器實際上只做兩件事:維護一份登入用戶清單,以及轉發 P2P 請求。
SOCKET PrimaryUDP = mksock(SOCK_DGRAM);
sockaddr_in local;
local.sin_family = AF_INET;
local.sin_port = htons(SERVER_PORT);
local.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(PrimaryUDP, (sockaddr*)&local, sizeof(sockaddr)) == SOCKET_ERROR)
throw Exception("bind error");
for (;;) {
sockaddr_in sender;
stMessage recvbuf;
int dwSender = sizeof(sender);
memset(&recvbuf, 0, sizeof(stMessage));
int ret = recvfrom(PrimaryUDP, (char*)&recvbuf, sizeof(stMessage), 0,
(sockaddr*)&sender, &dwSender);
if (ret <= 0) continue;
switch (recvbuf.iMessageType) {
case LOGIN: {
// 記錄使用者,並把現有線上名單回傳給新使用者
stUserListNode *node = new stUserListNode();
strcpy(node->userName, recvbuf.message.loginmember.userName);
node->ip = ntohl(sender.sin_addr.S_un.S_addr);
node->port = ntohs(sender.sin_port);
ClientList.push_back(node);
// ... 回傳 nodecount 與各節點資訊
break;
}
case LOGOUT: {
// 從清單中移除該使用者
// ... 比對 userName 後 erase
break;
}
case P2PTRANS: {
// 找出目標使用者的公網位址,請對方朝呼叫者打洞
stUserListNode node = GetUser(recvbuf.message.translatemessage.userName);
sockaddr_in remote;
remote.sin_family = AF_INET;
remote.sin_port = htons(node.port);
remote.sin_addr.s_addr = htonl(node.ip);
stP2PMessage transMessage;
transMessage.iMessageType = P2PSOMEONEWANTTOCALLYOU;
transMessage.iStringLen = ntohl(sender.sin_addr.S_un.S_addr);
transMessage.Port = ntohs(sender.sin_port);
sendto(PrimaryUDP, (const char*)&transMessage, sizeof(transMessage),
0, (const sockaddr*)&remote, sizeof(remote));
break;
}
case GETALLUSER: {
// 回傳目前線上人數與清單
break;
}
}
}
用戶端最關鍵的一段是「送訊息給某個人」。它先直接往對方的公網位址送;若對方那側的洞還沒開,封包會被丟棄,送端等到逾時後,轉而請求伺服器叫對方打洞,然後重試。整個流程最多重複 MAXRETRY 次。
bool SendMessageTo(char *UserName, char *Message)
{
unsigned int UserIP;
unsigned short UserPort;
bool FindUser = false;
for (UserList::iterator it = ClientList.begin();
it != ClientList.end(); ++it) {
if (strcmp((*it)->userName, UserName) == 0) {
UserIP = (*it)->ip;
UserPort = (*it)->port;
FindUser = true;
}
}
if (!FindUser) return false;
for (int i = 0; i < MAXRETRY; i++) {
RecvedACK = false;
sockaddr_in remote;
remote.sin_family = AF_INET;
remote.sin_addr.s_addr = htonl(UserIP);
remote.sin_port = htons(UserPort);
stP2PMessage head;
head.iMessageType = P2PMESSAGE;
head.iStringLen = (int)strlen(Message) + 1;
sendto(PrimaryUDP, (const char*)&head, sizeof(head), 0,
(const sockaddr*)&remote, sizeof(remote));
sendto(PrimaryUDP, (const char*)Message, head.iStringLen, 0,
(const sockaddr*)&remote, sizeof(remote));
// 等待接收線程設定 ACK 旗標
for (int j = 0; j < 10; j++) {
if (RecvedACK) return true;
Sleep(300);
}
// 沒有回應 → 判斷對方尚未打洞,請伺服器協助
sockaddr_in server;
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(ServerIP);
server.sin_port = htons(SERVER_PORT);
stMessage trans;
trans.iMessageType = P2PTRANS;
strcpy(trans.message.translatemessage.userName, UserName);
sendto(PrimaryUDP, (const char*)&trans, sizeof(trans), 0,
(const sockaddr*)&server, sizeof(server));
Sleep(100); // 讓對方有機會先送封包過來
}
return false;
}
收到 P2PSOMEONEWANTTOCALLYOU 時,用戶端就朝指定位址送一個空封包。這個封包本身沒有資訊價值,作用是讓 NAT 開啟映射;對方收到後以 P2PTRASH 類型忽略即可。
case P2PSOMEONEWANTTOCALLYOU: {
sockaddr_in remote;
remote.sin_family = AF_INET;
remote.sin_addr.s_addr = htonl(recvbuf.iStringLen);
remote.sin_port = htons(recvbuf.Port);
stP2PMessage junk;
junk.iMessageType = P2PTRASH;
sendto(PrimaryUDP, (const char*)&junk, sizeof(junk), 0,
(const sockaddr*)&remote, sizeof(remote)); // UDP hole punching
break;
}
case P2PMESSAGE: {
// 讀出訊息本文,回送 ACK
stP2PMessage ack;
ack.iMessageType = P2PMESSAGEACK;
sendto(PrimaryUDP, (const char*)&ack, sizeof(ack), 0,
(const sockaddr*)&remote, sizeof(remote));
break;
}
case P2PMESSAGEACK:
RecvedACK = true;
break;
同一個 NAT 後面的兩台機器。這個流程很可能連不上,取決於你的 NAT 是否支援 loopback translation(有相關的 IETF draft 討論)。解法之一是雙方先嘗試連對方的內網 IP,內網直連成功就不必繞公網。
伺服器不會自動偵測斷線。用戶端必須自行送出 logout,否則伺服器清單裡會留下幽靈使用者。
訊息邊界。範例把「標頭」與「本文」拆成兩個 UDP 封包,實作上必須處理本文封包遺失或亂序的情況;正式環境建議改用單一封包承載,或加上序號與重送機制。
UDP 打洞本質上是best-effort。它依賴 NAT 的實作行為,沒有任何協定層級的保證。要提升成功率,實務上的做法是搭配 STUN 探測 NAT 類型、失敗時回退到伺服器中繼(TURN 模式),這也是現代 WebRTC 的架構基礎。