iptables NAT 学习
- - BlogJava-首页技术区为了搞清楚iptables NAT的过程，做了这个实验. 使用了1台双网卡服务器和1台单网卡服务器，2个网段. 1. 为了看到调度服务器上的数据转发过程，首先在调度服务器上分出内核的debug日志：. l 在/etc/rsyslog.conf最后增加：kern.debug /var/log/iptables.log.
NAT穿透解决方案介绍
标签：
nat
| 发表时间：2015-04-01 03:12 | 作者：vanadiumlin
出处：http://www.iteye.com
最近公司要实现在各种网络环境下面的多屏互动（机顶盒、android phone、iphone及PC端）的需求；由于IP地址资源有限的原因，目前我们使用的各种终端设备都位于局域网后面也就是多台设备共享同一个公网IP；例如：如果位于局域网里面的一个终端Agent A要与互联网上的另一个终端Agent B通信，当A发送的data packet经过局域网出口处的NAT设备时，NAT会将data packet里面的source address字段替换成相应的公网IP和Port，然后再发送data packet到Agent B。Agent B看到的source address就是经过转换后的IP和Port并不知道Agent A的局域网地址；当Agent B的响应到达Agent A的NAT设备后，NAT设备查找内存中保存的和这个外网地址相对应的内网地址，如果找到后就将这个data packet转发到这个地址，这样就实现了通信。
然而由于目前存在着各种不同类型的NAT设备对NAT有着不同的实现方式（将内外地址映射成外网地址的时候有着不同的行为方式），这就给NAT的穿透带来了麻烦；目前主要的NAT类型有如下几种：
1)Full-cone NAT, also known as one-to-one NAT
一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将通过 eAddr:ePort 发送. 任何外部主机能够通过eAddr:ePort这个地址发送数据包到iAddr:iPort.
2)Address-restricted-cone NAT
一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将通过 eAddr:ePort 发送. 仅只有接收到主机(iAddr:iPort)通过eAddr:ePort发送的数据包的外部主机通过该主机的任何端口发送到eAddr:ePort的数据包才能够被正确的转发到iAddr:iPort.也就是说主机有关端口无关.
3)Port-restricted cone NAT
类似于address restricted cone NAT, 但是端口号有限制.
一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将通过 eAddr:ePort 发送. 仅只有接收到主机(iAddr:iPort)通过eAddr:ePort发送的数据包的外部主机通过该主机的相同端口发送到eAddr:ePort的数据包才能够被正确的转发到iAddr:iPort.
4)Symmetric NAT
来自相同内部ip和port发送到相同目的地ip和port的请求被映射到唯一的外部ip和port地址；如果相同的内部主机采用相同的ip和port地址发送到不同的目的地，那么重新分配映射地址。 只有先前收到内部主机发送的包的外部主机才能够发送返回包到内部主机。
针对前面三种NAT类型（即cone NAT）只要通信双方彼此知道对方的内部地址和外部地址的映射关系，然后通过UDP打洞的方式就可以建立相互连接的通信；但是第四种也就是Symmetric NAT的话由于每次向不同目的地发送数据包时采用不同的外部地址，也就没办法通过直接的方式建立P2P连接。
1.各种网络环境下的P2P通信解决方法：
（1）如果通信双方在同一个局域网内，这种情况下可以不借助任何外力直接通过内网地址通信即可； （2）如果通信双方都在有独立的公网地址，这种情况下当然可以不借助任何外力直接通信即可；
（3）如果通信双方一方拥有独立的公网地址另一方在NAT后面，那么可以由位于NAT后面的一方主动发起通信请求；
（4）如果通信双方都位于NAT后面，且双方的NAT类型都是cone NAT，那么可以通过一个STUN服务器发现自己的NAT类型以及内网和外网传输地址映射信息，然后通过Signaling(信令服务器，实现了SIP协议的主机)交换彼此的NAT类型及内网和外网传输地址映射信息，然后通过UDP打洞的方式建立通信连接；
4>如果通信双方有一方的NAT类型是Symmetric NAT，则无法直接建立P2P连接，这个时候就需要借助TURN(Traversal Using Relay NAT)服务器即转发服务器来实现间接的通信；
2.协议及用到的相关技术介绍：
SDP: 也就是Session Description Protocol的缩写，当初始化多媒体电视会议、IP电话、视频流等会话的时候，参与者之间会要求传送媒介的详细、传输地址和其他会话描述元数据等信息；SDP为这些信息提供一种和传输方式无关的标准的表现形式。也就是说SDP仅仅只是一种描述会话信息的格式。它主要被各种不同的传输协议作为一种信息交换的格式使用列如：HTTP、RTSP、SIP、Email等各种协议。 如ICE里面的SDP内容为： v=0 o=ice4j.org 0 0 IN IP4 192.168.106.215 s=- t=0 0 a=ice-options:trickle a=ice-ufrag:bc01a a=ice-pwd:1boove7ehnpo1lqho7unefni36 m=audio 3030 RTP/AVP 0 c=IN 192.168.106.215 IP4 a=mid:audio a=candidate:1 1 udp 2130706431 192.168.106.215 3030 typ host a=candidate:2 1 udp 1694498815 121.15.130.xxx 64923 typ srflx raddr 192.168.106.215 rport 3030
STUN:也就是Session Traversal Utilities for NAT的缩写，NAT会话穿透工具；STUN提供了一种方式使一个端点能够确定NAT分配给它的和本地私有IP地址和端口相对应的公网IP地址和端口以及NAT的类型信息。它也为端点提供了一种方式保持一个NAT绑定不过期。NAT绑定过期则表示为相同的内网地址重新分配外网地址也就是端口号。
TURN:也就是Traversal Using Relay NAT的缩写，TURN是STUN协议的扩展，在实际应用中他也可以充当STUN的角色；如果一个位于NAT后面的设备想要和另外一个位于NAT后面的设备建立通信，当采用UDP打洞技术不能改实现的时候就必须要一台中间服务器扮演数据包转发的角色，这台TURN服务器需要拥有公网的IP地址；
SIP:也就是Session Initiation Protocol的缩写，是一种Signaling（信令）通信协议；有许多互联网应用需要创建有多个参与者的会话和管理参与者之间相互的数据交换，然而如果这些工作让应用的参与者来实现是比较复杂的如：用户也许在端点之间移动、通过多个名称寻址和也许同时使用几种不同的媒介通信。有许多协议能够实现各种形式的多媒体会话进行数据传送例如声音、视频或者文本消息。SIP能够和这些协议一同合作，使一个客服端能够发现参与这个会话的其他客服端并共享同一会话。为了定位后面加入会话的参与者等功能，SIP能够为代理服务器创建基础设施，客服端可以通过这个代理服务器实现会话注册、邀请参与会话等功能。SIP是一个创建、修改和终止会话的灵活的多种用途的工具，不依赖于底层的传输协议并且不依赖于被创建的会话类型。
ICE:也就是Interactive Connectivity Establishment的缩写，是实现NAT穿透的一种技术方案；ICE是一种NAT穿透技术，通过offer/answer模型建立基于UDP的媒介流。ICE是offer/answer模型的扩展，通过在offer和answer的SDP里面包含多种IP地址和端口，然后对本地SDP和远程SDP里面的IP地址进行配对，然后通过P2P连通性检查进行连通性测试工作，如果测试通过即表明该传输地址对可以建立连接。其中IP地址和端口（也就是地址）有以下几种：本机地址、通过STUN服务器反射后获取的server-reflexive地址（内网地址被NAT映射后的地址）、relayed地址（和TURN转发服务器相对应的地址）及Peer reflexive地址等。
3.ICE进行NAT穿透的基本过程： 在通常的ICE部署环境中，我们有两个客服端想要建立通信连接，他们可以直接通过signaling服务器（如SIP服务器）执行offer/answer过程来交换SDP消息。 在ICE过程开始的时候，客服端忽略他们各自的网络拓扑结构，不管是不是在NAT设备后面或者多个NAT后面，ICE允许客服端发现他们的所在网络的拓扑结构的信息，然后找出一个或者更多的可以建立通信连接的路径。 下图显示了一个典型的ICE部署环境，客服端L和R都在各自的NAT设备后面，下面简单描述下ICE建立通信的过程： （1）L和R先分别通过STUN和TURN服务器获取自己的host address,server-reflexive address、relayed address（和TURN转发服务器相对应的地址），其中server-reflexive address和relayed address通过定时刷新保证地址不过期。这些地址通常叫做candinate地址。 （2）给这些candinate地址分配优先级排序并格式化成SDP格式，通过SIP服务器交换彼此的SDP； （3）交换完成后根据一定的原则把本地的候选和远程的候选进行配对，每一对都有自己的优先级并根据优先级进行排序后放入Check列表里面（两边都会有相同的Check列表）。 （4）然后进行连接性测试，测试前会选择一个客服端扮演Controlled角色和另一个扮演Controling角色，连通性检查完成后扮演Controling角色的客服端负责在有效的Candinate对列表里面选择一个作为一个被选中的传输通道并通知Controlled的客服端。 （5）利用被选中的candinate地址对进行通信。 \
4.ICE JAVA实现代码 我这里的样例代码采用ICE4J来实现，ICE4J的API文档可以参考http://bluejimp.com/jitsi/ice4j/javadoc/，在这个实现里面没有利用SIP服务器进行SDP信息的交换而是采用手动输入的方式，在生产环境中可以部署一台WebRTC服务器（NodeJS有很多开源的WebRTC实现模块） 加载中...加载中...
view sourceprint?
001.
/**
002.
* Copyright (c) 2014 All Rights Reserved.
003.
* TODO
004.
*/
005.
006.
import java.beans.PropertyChangeEvent;
007.
import java.beans.PropertyChangeListener;
008.
import java.io.BufferedReader;
009.
import java.io.InputStreamReader;
010.
import java.net.DatagramSocket;
011.
import java.net.SocketAddress;
012.
import java.util.List;
013.
014.
import org.apache.commons.lang3.StringUtils;
015.
import org.apache.log4j.Logger;
016.
import org.ice4j.Transport;
017.
import org.ice4j.TransportAddress;
018.
import org.ice4j.ice.Agent;
019.
import org.ice4j.ice.Component;
020.
import org.ice4j.ice.IceMediaStream;
021.
import org.ice4j.ice.IceProcessingState;
022.
import org.ice4j.ice.LocalCandidate;
023.
import org.ice4j.ice.NominationStrategy;
024.
import org.ice4j.ice.RemoteCandidate;
025.
import org.ice4j.ice.harvest.StunCandidateHarvester;
026.
import org.ice4j.ice.harvest.TurnCandidateHarvester;
027.
import org.ice4j.security.LongTermCredential;
028.
029.
import test.SdpUtils;
030.
031.
public class IceClient {
032.
033.
private int port;
034.
035.
private String streamName;
036.
037.
private Agent agent;
038.
039.
private String localSdp;
040.
041.
private String remoteSdp;
042.
043.
private String[] turnServers = new String[] { "stun.jitsi.net:3478" };
044.
045.
private String[] stunServers = new String[] { "stun.stunprotocol.org:3478" };
046.
047.
private String username = "guest";
048.
049.
private String pass<a href="http://www.it165.net/edu/ebg/" target="_blank" class="keylink">word</a> = "anonymouspower!!";
050.
051.
private IceProcessingListener listener;
052.
053.
static Logger log = Logger.getLogger(IceClient.class);
054.
055.
public IceClient(int port, String streamName) {
056.
this.port = port;
057.
this.streamName = streamName;
058.
this.listener = new IceProcessingListener();
059.
}
060.
061.
public void init() throws Throwable {
062.
063.
agent = createAgent(port, streamName);
064.
065.
agent.setNominationStrategy(NominationStrategy.NOMINATE_HIGHEST_PRIO);
066.
067.
agent.addStateChangeListener(listener);
068.
069.
agent.setControlling(false);
070.
071.
agent.setTa(10000);
072.
073.
localSdp = SdpUtils.createSDPDescription(agent);
074.
075.
log.info("=================== feed the following"
076.
+ " to the remote agent ===================");
077.
078.
System.out.println(localSdp);
079.
080.
log.info("======================================"
081.
+ "========================================\n");
082.
}
083.
084.
public DatagramSocket getDatagramSocket() throws Throwable {
085.
086.
LocalCandidate localCandidate = agent
087.
.getSelectedLocalCandidate(streamName);
088.
089.
IceMediaStream stream = agent.getStream(streamName);
090.
List<Component> components = stream.getComponents();
091.
for (Component c : components) {
092.
log.info(c);
093.
}
094.
log.info(localCandidate.toString());
095.
LocalCandidate candidate = (LocalCandidate) localCandidate;
096.
return candidate.getDatagramSocket();
097.
098.
}
099.
100.
public SocketAddress getRemotePeerSocketAddress() {
101.
RemoteCandidate remoteCandidate = agent
102.
.getSelectedRemoteCandidate(streamName);
103.
log.info("Remote candinate transport address:"
104.
+ remoteCandidate.getTransportAddress());
105.
log.info("Remote candinate host address:"
106.
+ remoteCandidate.getHostAddress());
107.
log.info("Remote candinate mapped address:"
108.
+ remoteCandidate.getMappedAddress());
109.
log.info("Remote candinate relayed address:"
110.
+ remoteCandidate.getRelayedAddress());
111.
log.info("Remote candinate reflexive address:"
112.
+ remoteCandidate.getReflexiveAddress());
113.
return remoteCandidate.getTransportAddress();
114.
}
115.
116.
/**
117.
* Reads an SDP description from the standard input.In production
118.
* environment that we can exchange SDP with peer through signaling
119.
* server(SIP server)
120.
*/
121.
public void exchangeSdpWithPeer() throws Throwable {
122.
log.info("Paste remote SDP here. Enter an empty line to proceed:");
123.
BufferedReader reader = new BufferedReader(new InputStreamReader(
124.
System.in));
125.
126.
StringBuilder buff = new StringBuilder();
127.
String line = new String();
128.
129.
while ((line = reader.readLine()) != null) {
130.
line = line.trim();
131.
if (line.length() == 0) {
132.
break;
133.
}
134.
buff.append(line);
135.
buff.append("\r\n");
136.
}
137.
138.
remoteSdp = buff.toString();
139.
140.
SdpUtils.parseSDP(agent, remoteSdp);
141.
}
142.
143.
public void startConnect() throws InterruptedException {
144.
145.
if (StringUtils.isBlank(remoteSdp)) {
146.
throw new NullPointerException(
147.
"Please exchange sdp information with peer before start connect! ");
148.
}
149.
150.
agent.startConnectivityEstablishment();
151.
152.
// agent.runInStunKeepAliveThread();
153.
154.
synchronized (listener) {
155.
listener.wait();
156.
}
157.
158.
}
159.
160.
private Agent createAgent(int rtpPort, String streamName) throws Throwable {
161.
return createAgent(rtpPort, streamName, false);
162.
}
163.
164.
private Agent createAgent(int rtpPort, String streamName,
165.
boolean isTrickling) throws Throwable {
166.
167.
long startTime = System.currentTimeMillis();
168.
169.
Agent agent = new Agent();
170.
171.
agent.setTrickling(isTrickling);
172.
173.
// STUN
174.
for (String server : stunServers){
175.
String[] pair = server.split(":");
176.
agent.addCandidateHarvester(new StunCandidateHarvester(
177.
new TransportAddress(pair[0], Integer.parseInt(pair[1]),
178.
Transport.UDP)));
179.
}
180.
181.
// TURN
182.
LongTermCredential longTermCredential = new LongTermCredential(username,
183.
pass<a href="http://www.it165.net/edu/ebg/" target="_blank" class="keylink">word</a>);
184.
185.
for (String server : turnServers){
186.
String[] pair = server.split(":");
187.
agent.addCandidateHarvester(new TurnCandidateHarvester(
188.
new TransportAddress(pair[0], Integer.parseInt(pair[1]), Transport.UDP),
189.
longTermCredential));
190.
}
191.
// STREAMS
192.
createStream(rtpPort, streamName, agent);
193.
194.
long endTime = System.currentTimeMillis();
195.
long total = endTime - startTime;
196.
197.
log.info("Total harvesting time: " + total + "ms.");
198.
199.
return agent;
200.
}
201.
202.
private IceMediaStream createStream(int rtpPort, String streamName,
203.
Agent agent) throws Throwable {
204.
long startTime = System.currentTimeMillis();
205.
IceMediaStream stream = agent.createMediaStream(streamName);
206.
// rtp
207.
Component component = agent.createComponent(stream, Transport.UDP,
208.
rtpPort, rtpPort, rtpPort + 100);
209.
210.
long endTime = System.currentTimeMillis();
211.
log.info("Component Name:" + component.getName());
212.
log.info("RTP Component created in " + (endTime - startTime) + " ms");
213.
214.
return stream;
215.
}
216.
217.
/**
218.
* Receive notify event when ice processing state has changed.
219.
*/
220.
public static final class IceProcessingListener implements
221.
PropertyChangeListener {
222.
223.
private long startTime = System.currentTimeMillis();
224.
225.
public void propertyChange(PropertyChangeEvent event) {
226.
227.
Object state = event.getNewValue();
228.
229.
log.info("Agent entered the " + state + " state.");
230.
if (state == IceProcessingState.COMPLETED) {
231.
long processingEndTime = System.currentTimeMillis();
232.
log.info("Total ICE processing time: "
233.
+ (processingEndTime - startTime) + "ms");
234.
Agent agent = (Agent) event.getSource();
235.
List<IceMediaStream> streams = agent.getStreams();
236.
237.
for (IceMediaStream stream : streams) {
238.
log.info("Stream name: " + stream.getName());
239.
List<Component> components = stream.getComponents();
240.
for (Component c : components) {
241.
log.info("------------------------------------------");
242.
log.info("Component of stream:" + c.getName()
243.
+ ",selected of pair:" + c.getSelectedPair());
244.
log.info("------------------------------------------");
245.
}
246.
}
247.
248.
log.info("Printing the completed check lists:");
249.
for (IceMediaStream stream : streams) {
250.
251.
log.info("Check list for stream: " + stream.getName());
252.
253.
log.info("nominated check list:" + stream.getCheckList());
254.
}
255.
synchronized (this) {
256.
this.notifyAll();
257.
}
258.
} else if (state == IceProcessingState.TERMINATED) {
259.
log.info("ice processing TERMINATED");
260.
} else if (state == IceProcessingState.FAILED) {
261.
log.info("ice processing FAILED");
262.
((Agent) event.getSource()).free();
263.
}
264.
}
265.
}
266.
}
267.
268.
import java.io.IOException;
269.
import java.net.DatagramPacket;
270.
import java.net.DatagramSocket;
271.
import java.net.SocketAddress;
272.
import java.util.concurrent.TimeUnit;
273.
274.
275.
public class PeerA {
276.
277.
public static void main(String[] args) throws Throwable {
278.
try {
279.
IceClient client = new IceClient(2020, "audio");
280.
client.init();
281.
client.exchangeSdpWithPeer();
282.
client.startConnect();
283.
final DatagramSocket socket = client.getDatagramSocket();
284.
final SocketAddress remoteAddress = client
285.
.getRemotePeerSocketAddress();
286.
System.out.println(socket.toString());
287.
new Thread(new Runnable() {
288.
289.
public void run() {
290.
while (true) {
291.
try {
292.
byte[] buf = new byte[1024];
293.
DatagramPacket packet = new DatagramPacket(buf,
294.
buf.length);
295.
socket.receive(packet);
296.
System.out.println("receive:"
297.
+ new String(packet.getData(), 0, packet
298.
.getLength()));
299.
} catch (IOException e) {
300.
// TODO Auto-generated catch block
301.
e.printStackTrace();
302.
}
303.
304.
}
305.
}
306.
}).start();
307.
308.
new Thread(new Runnable() {
309.
310.
public void run() {
311.
int count = 1;
312.
while (true) {
313.
try {
314.
byte[] buf = ("send msg " + count++ + "").getBytes();
315.
DatagramPacket packet = new DatagramPacket(buf,
316.
buf.length);
317.
318.
packet.setSocketAddress(remoteAddress);
319.
socket.send(packet);
320.
System.out.println("send msg");
321.
TimeUnit.SECONDS.sleep(10);
322.
} catch (Exception e) {
323.
// TODO Auto-generated catch block
324.
e.printStackTrace();
325.
}
326.
327.
}
328.
}
329.
}).start();
330.
} catch (Exception e) {
331.
// TODO Auto-generated catch block
332.
e.printStackTrace();
333.
}
334.
335.
}
336.
337.
}
已有 0 人发表留言，猛击->> 这里<<-参与讨论
ITeye推荐
然而由于目前存在着各种不同类型的NAT设备对NAT有着不同的实现方式（将内外地址映射成外网地址的时候有着不同的行为方式），这就给NAT的穿透带来了麻烦；目前主要的NAT类型有如下几种：
1)Full-cone NAT, also known as one-to-one NAT
一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将通过 eAddr:ePort 发送. 任何外部主机能够通过eAddr:ePort这个地址发送数据包到iAddr:iPort.
2)Address-restricted-cone NAT
一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将通过 eAddr:ePort 发送. 仅只有接收到主机(iAddr:iPort)通过eAddr:ePort发送的数据包的外部主机通过该主机的任何端口发送到eAddr:ePort的数据包才能够被正确的转发到iAddr:iPort.也就是说主机有关端口无关.
3)Port-restricted cone NAT
类似于address restricted cone NAT, 但是端口号有限制.
一旦一个内网地址 (iAddr:iPort) 被映射到一个外部地址 (eAddr:ePort), 来自 iAddr:iPort 的任何数据包将通过 eAddr:ePort 发送. 仅只有接收到主机(iAddr:iPort)通过eAddr:ePort发送的数据包的外部主机通过该主机的相同端口发送到eAddr:ePort的数据包才能够被正确的转发到iAddr:iPort.
4)Symmetric NAT
来自相同内部ip和port发送到相同目的地ip和port的请求被映射到唯一的外部ip和port地址；如果相同的内部主机采用相同的ip和port地址发送到不同的目的地，那么重新分配映射地址。 只有先前收到内部主机发送的包的外部主机才能够发送返回包到内部主机。
针对前面三种NAT类型（即cone NAT）只要通信双方彼此知道对方的内部地址和外部地址的映射关系，然后通过UDP打洞的方式就可以建立相互连接的通信；但是第四种也就是Symmetric NAT的话由于每次向不同目的地发送数据包时采用不同的外部地址，也就没办法通过直接的方式建立P2P连接。
1.各种网络环境下的P2P通信解决方法：
（1）如果通信双方在同一个局域网内，这种情况下可以不借助任何外力直接通过内网地址通信即可； （2）如果通信双方都在有独立的公网地址，这种情况下当然可以不借助任何外力直接通信即可；
（3）如果通信双方一方拥有独立的公网地址另一方在NAT后面，那么可以由位于NAT后面的一方主动发起通信请求；
（4）如果通信双方都位于NAT后面，且双方的NAT类型都是cone NAT，那么可以通过一个STUN服务器发现自己的NAT类型以及内网和外网传输地址映射信息，然后通过Signaling(信令服务器，实现了SIP协议的主机)交换彼此的NAT类型及内网和外网传输地址映射信息，然后通过UDP打洞的方式建立通信连接；
4>如果通信双方有一方的NAT类型是Symmetric NAT，则无法直接建立P2P连接，这个时候就需要借助TURN(Traversal Using Relay NAT)服务器即转发服务器来实现间接的通信；
2.协议及用到的相关技术介绍：
SDP: 也就是Session Description Protocol的缩写，当初始化多媒体电视会议、IP电话、视频流等会话的时候，参与者之间会要求传送媒介的详细、传输地址和其他会话描述元数据等信息；SDP为这些信息提供一种和传输方式无关的标准的表现形式。也就是说SDP仅仅只是一种描述会话信息的格式。它主要被各种不同的传输协议作为一种信息交换的格式使用列如：HTTP、RTSP、SIP、Email等各种协议。 如ICE里面的SDP内容为： v=0 o=ice4j.org 0 0 IN IP4 192.168.106.215 s=- t=0 0 a=ice-options:trickle a=ice-ufrag:bc01a a=ice-pwd:1boove7ehnpo1lqho7unefni36 m=audio 3030 RTP/AVP 0 c=IN 192.168.106.215 IP4 a=mid:audio a=candidate:1 1 udp 2130706431 192.168.106.215 3030 typ host a=candidate:2 1 udp 1694498815 121.15.130.xxx 64923 typ srflx raddr 192.168.106.215 rport 3030
STUN:也就是Session Traversal Utilities for NAT的缩写，NAT会话穿透工具；STUN提供了一种方式使一个端点能够确定NAT分配给它的和本地私有IP地址和端口相对应的公网IP地址和端口以及NAT的类型信息。它也为端点提供了一种方式保持一个NAT绑定不过期。NAT绑定过期则表示为相同的内网地址重新分配外网地址也就是端口号。
TURN:也就是Traversal Using Relay NAT的缩写，TURN是STUN协议的扩展，在实际应用中他也可以充当STUN的角色；如果一个位于NAT后面的设备想要和另外一个位于NAT后面的设备建立通信，当采用UDP打洞技术不能改实现的时候就必须要一台中间服务器扮演数据包转发的角色，这台TURN服务器需要拥有公网的IP地址；
SIP:也就是Session Initiation Protocol的缩写，是一种Signaling（信令）通信协议；有许多互联网应用需要创建有多个参与者的会话和管理参与者之间相互的数据交换，然而如果这些工作让应用的参与者来实现是比较复杂的如：用户也许在端点之间移动、通过多个名称寻址和也许同时使用几种不同的媒介通信。有许多协议能够实现各种形式的多媒体会话进行数据传送例如声音、视频或者文本消息。SIP能够和这些协议一同合作，使一个客服端能够发现参与这个会话的其他客服端并共享同一会话。为了定位后面加入会话的参与者等功能，SIP能够为代理服务器创建基础设施，客服端可以通过这个代理服务器实现会话注册、邀请参与会话等功能。SIP是一个创建、修改和终止会话的灵活的多种用途的工具，不依赖于底层的传输协议并且不依赖于被创建的会话类型。
ICE:也就是Interactive Connectivity Establishment的缩写，是实现NAT穿透的一种技术方案；ICE是一种NAT穿透技术，通过offer/answer模型建立基于UDP的媒介流。ICE是offer/answer模型的扩展，通过在offer和answer的SDP里面包含多种IP地址和端口，然后对本地SDP和远程SDP里面的IP地址进行配对，然后通过P2P连通性检查进行连通性测试工作，如果测试通过即表明该传输地址对可以建立连接。其中IP地址和端口（也就是地址）有以下几种：本机地址、通过STUN服务器反射后获取的server-reflexive地址（内网地址被NAT映射后的地址）、relayed地址（和TURN转发服务器相对应的地址）及Peer reflexive地址等。
3.ICE进行NAT穿透的基本过程： 在通常的ICE部署环境中，我们有两个客服端想要建立通信连接，他们可以直接通过signaling服务器（如SIP服务器）执行offer/answer过程来交换SDP消息。 在ICE过程开始的时候，客服端忽略他们各自的网络拓扑结构，不管是不是在NAT设备后面或者多个NAT后面，ICE允许客服端发现他们的所在网络的拓扑结构的信息，然后找出一个或者更多的可以建立通信连接的路径。 下图显示了一个典型的ICE部署环境，客服端L和R都在各自的NAT设备后面，下面简单描述下ICE建立通信的过程： （1）L和R先分别通过STUN和TURN服务器获取自己的host address,server-reflexive address、relayed address（和TURN转发服务器相对应的地址），其中server-reflexive address和relayed address通过定时刷新保证地址不过期。这些地址通常叫做candinate地址。 （2）给这些candinate地址分配优先级排序并格式化成SDP格式，通过SIP服务器交换彼此的SDP； （3）交换完成后根据一定的原则把本地的候选和远程的候选进行配对，每一对都有自己的优先级并根据优先级进行排序后放入Check列表里面（两边都会有相同的Check列表）。 （4）然后进行连接性测试，测试前会选择一个客服端扮演Controlled角色和另一个扮演Controling角色，连通性检查完成后扮演Controling角色的客服端负责在有效的Candinate对列表里面选择一个作为一个被选中的传输通道并通知Controlled的客服端。 （5）利用被选中的candinate地址对进行通信。 \
4.ICE JAVA实现代码 我这里的样例代码采用ICE4J来实现，ICE4J的API文档可以参考http://bluejimp.com/jitsi/ice4j/javadoc/，在这个实现里面没有利用SIP服务器进行SDP信息的交换而是采用手动输入的方式，在生产环境中可以部署一台WebRTC服务器（NodeJS有很多开源的WebRTC实现模块） 加载中...加载中...
view sourceprint?
001.
/**
002.
* Copyright (c) 2014 All Rights Reserved.
003.
* TODO
004.
*/
005.
006.
import java.beans.PropertyChangeEvent;
007.
import java.beans.PropertyChangeListener;
008.
import java.io.BufferedReader;
009.
import java.io.InputStreamReader;
010.
import java.net.DatagramSocket;
011.
import java.net.SocketAddress;
012.
import java.util.List;
013.
014.
import org.apache.commons.lang3.StringUtils;
015.
import org.apache.log4j.Logger;
016.
import org.ice4j.Transport;
017.
import org.ice4j.TransportAddress;
018.
import org.ice4j.ice.Agent;
019.
import org.ice4j.ice.Component;
020.
import org.ice4j.ice.IceMediaStream;
021.
import org.ice4j.ice.IceProcessingState;
022.
import org.ice4j.ice.LocalCandidate;
023.
import org.ice4j.ice.NominationStrategy;
024.
import org.ice4j.ice.RemoteCandidate;
025.
import org.ice4j.ice.harvest.StunCandidateHarvester;
026.
import org.ice4j.ice.harvest.TurnCandidateHarvester;
027.
import org.ice4j.security.LongTermCredential;
028.
029.
import test.SdpUtils;
030.
031.
public class IceClient {
032.
033.
private int port;
034.
035.
private String streamName;
036.
037.
private Agent agent;
038.
039.
private String localSdp;
040.
041.
private String remoteSdp;
042.
043.
private String[] turnServers = new String[] { "stun.jitsi.net:3478" };
044.
045.
private String[] stunServers = new String[] { "stun.stunprotocol.org:3478" };
046.
047.
private String username = "guest";
048.
049.
private String pass<a href="http://www.it165.net/edu/ebg/" target="_blank" class="keylink">word</a> = "anonymouspower!!";
050.
051.
private IceProcessingListener listener;
052.
053.
static Logger log = Logger.getLogger(IceClient.class);
054.
055.
public IceClient(int port, String streamName) {
056.
this.port = port;
057.
this.streamName = streamName;
058.
this.listener = new IceProcessingListener();
059.
}
060.
061.
public void init() throws Throwable {
062.
063.
agent = createAgent(port, streamName);
064.
065.
agent.setNominationStrategy(NominationStrategy.NOMINATE_HIGHEST_PRIO);
066.
067.
agent.addStateChangeListener(listener);
068.
069.
agent.setControlling(false);
070.
071.
agent.setTa(10000);
072.
073.
localSdp = SdpUtils.createSDPDescription(agent);
074.
075.
log.info("=================== feed the following"
076.
+ " to the remote agent ===================");
077.
078.
System.out.println(localSdp);
079.
080.
log.info("======================================"
081.
+ "========================================\n");
082.
}
083.
084.
public DatagramSocket getDatagramSocket() throws Throwable {
085.
086.
LocalCandidate localCandidate = agent
087.
.getSelectedLocalCandidate(streamName);
088.
089.
IceMediaStream stream = agent.getStream(streamName);
090.
List<Component> components = stream.getComponents();
091.
for (Component c : components) {
092.
log.info(c);
093.
}
094.
log.info(localCandidate.toString());
095.
LocalCandidate candidate = (LocalCandidate) localCandidate;
096.
return candidate.getDatagramSocket();
097.
098.
}
099.
100.
public SocketAddress getRemotePeerSocketAddress() {
101.
RemoteCandidate remoteCandidate = agent
102.
.getSelectedRemoteCandidate(streamName);
103.
log.info("Remote candinate transport address:"
104.
+ remoteCandidate.getTransportAddress());
105.
log.info("Remote candinate host address:"
106.
+ remoteCandidate.getHostAddress());
107.
log.info("Remote candinate mapped address:"
108.
+ remoteCandidate.getMappedAddress());
109.
log.info("Remote candinate relayed address:"
110.
+ remoteCandidate.getRelayedAddress());
111.
log.info("Remote candinate reflexive address:"
112.
+ remoteCandidate.getReflexiveAddress());
113.
return remoteCandidate.getTransportAddress();
114.
}
115.
116.
/**
117.
* Reads an SDP description from the standard input.In production
118.
* environment that we can exchange SDP with peer through signaling
119.
* server(SIP server)
120.
*/
121.
public void exchangeSdpWithPeer() throws Throwable {
122.
log.info("Paste remote SDP here. Enter an empty line to proceed:");
123.
BufferedReader reader = new BufferedReader(new InputStreamReader(
124.
System.in));
125.
126.
StringBuilder buff = new StringBuilder();
127.
String line = new String();
128.
129.
while ((line = reader.readLine()) != null) {
130.
line = line.trim();
131.
if (line.length() == 0) {
132.
break;
133.
}
134.
buff.append(line);
135.
buff.append("\r\n");
136.
}
137.
138.
remoteSdp = buff.toString();
139.
140.
SdpUtils.parseSDP(agent, remoteSdp);
141.
}
142.
143.
public void startConnect() throws InterruptedException {
144.
145.
if (StringUtils.isBlank(remoteSdp)) {
146.
throw new NullPointerException(
147.
"Please exchange sdp information with peer before start connect! ");
148.
}
149.
150.
agent.startConnectivityEstablishment();
151.
152.
// agent.runInStunKeepAliveThread();
153.
154.
synchronized (listener) {
155.
listener.wait();
156.
}
157.
158.
}
159.
160.
private Agent createAgent(int rtpPort, String streamName) throws Throwable {
161.
return createAgent(rtpPort, streamName, false);
162.
}
163.
164.
private Agent createAgent(int rtpPort, String streamName,
165.
boolean isTrickling) throws Throwable {
166.
167.
long startTime = System.currentTimeMillis();
168.
169.
Agent agent = new Agent();
170.
171.
agent.setTrickling(isTrickling);
172.
173.
// STUN
174.
for (String server : stunServers){
175.
String[] pair = server.split(":");
176.
agent.addCandidateHarvester(new StunCandidateHarvester(
177.
new TransportAddress(pair[0], Integer.parseInt(pair[1]),
178.
Transport.UDP)));
179.
}
180.
181.
// TURN
182.
LongTermCredential longTermCredential = new LongTermCredential(username,
183.
pass<a href="http://www.it165.net/edu/ebg/" target="_blank" class="keylink">word</a>);
184.
185.
for (String server : turnServers){
186.
String[] pair = server.split(":");
187.
agent.addCandidateHarvester(new TurnCandidateHarvester(
188.
new TransportAddress(pair[0], Integer.parseInt(pair[1]), Transport.UDP),
189.
longTermCredential));
190.
}
191.
// STREAMS
192.
createStream(rtpPort, streamName, agent);
193.
194.
long endTime = System.currentTimeMillis();
195.
long total = endTime - startTime;
196.
197.
log.info("Total harvesting time: " + total + "ms.");
198.
199.
return agent;
200.
}
201.
202.
private IceMediaStream createStream(int rtpPort, String streamName,
203.
Agent agent) throws Throwable {
204.
long startTime = System.currentTimeMillis();
205.
IceMediaStream stream = agent.createMediaStream(streamName);
206.
// rtp
207.
Component component = agent.createComponent(stream, Transport.UDP,
208.
rtpPort, rtpPort, rtpPort + 100);
209.
210.
long endTime = System.currentTimeMillis();
211.
log.info("Component Name:" + component.getName());
212.
log.info("RTP Component created in " + (endTime - startTime) + " ms");
213.
214.
return stream;
215.
}
216.
217.
/**
218.
* Receive notify event when ice processing state has changed.
219.
*/
220.
public static final class IceProcessingListener implements
221.
PropertyChangeListener {
222.
223.
private long startTime = System.currentTimeMillis();
224.
225.
public void propertyChange(PropertyChangeEvent event) {
226.
227.
Object state = event.getNewValue();
228.
229.
log.info("Agent entered the " + state + " state.");
230.
if (state == IceProcessingState.COMPLETED) {
231.
long processingEndTime = System.currentTimeMillis();
232.
log.info("Total ICE processing time: "
233.
+ (processingEndTime - startTime) + "ms");
234.
Agent agent = (Agent) event.getSource();
235.
List<IceMediaStream> streams = agent.getStreams();
236.
237.
for (IceMediaStream stream : streams) {
238.
log.info("Stream name: " + stream.getName());
239.
List<Component> components = stream.getComponents();
240.
for (Component c : components) {
241.
log.info("------------------------------------------");
242.
log.info("Component of stream:" + c.getName()
243.
+ ",selected of pair:" + c.getSelectedPair());
244.
log.info("------------------------------------------");
245.
}
246.
}
247.
248.
log.info("Printing the completed check lists:");
249.
for (IceMediaStream stream : streams) {
250.
251.
log.info("Check list for stream: " + stream.getName());
252.
253.
log.info("nominated check list:" + stream.getCheckList());
254.
}
255.
synchronized (this) {
256.
this.notifyAll();
257.
}
258.
} else if (state == IceProcessingState.TERMINATED) {
259.
log.info("ice processing TERMINATED");
260.
} else if (state == IceProcessingState.FAILED) {
261.
log.info("ice processing FAILED");
262.
((Agent) event.getSource()).free();
263.
}
264.
}
265.
}
266.
}
267.
268.
import java.io.IOException;
269.
import java.net.DatagramPacket;
270.
import java.net.DatagramSocket;
271.
import java.net.SocketAddress;
272.
import java.util.concurrent.TimeUnit;
273.
274.
275.
public class PeerA {
276.
277.
public static void main(String[] args) throws Throwable {
278.
try {
279.
IceClient client = new IceClient(2020, "audio");
280.
client.init();
281.
client.exchangeSdpWithPeer();
282.
client.startConnect();
283.
final DatagramSocket socket = client.getDatagramSocket();
284.
final SocketAddress remoteAddress = client
285.
.getRemotePeerSocketAddress();
286.
System.out.println(socket.toString());
287.
new Thread(new Runnable() {
288.
289.
public void run() {
290.
while (true) {
291.
try {
292.
byte[] buf = new byte[1024];
293.
DatagramPacket packet = new DatagramPacket(buf,
294.
buf.length);
295.
socket.receive(packet);
296.
System.out.println("receive:"
297.
+ new String(packet.getData(), 0, packet
298.
.getLength()));
299.
} catch (IOException e) {
300.
// TODO Auto-generated catch block
301.
e.printStackTrace();
302.
}
303.
304.
}
305.
}
306.
}).start();
307.
308.
new Thread(new Runnable() {
309.
310.
public void run() {
311.
int count = 1;
312.
while (true) {
313.
try {
314.
byte[] buf = ("send msg " + count++ + "").getBytes();
315.
DatagramPacket packet = new DatagramPacket(buf,
316.
buf.length);
317.
318.
packet.setSocketAddress(remoteAddress);
319.
socket.send(packet);
320.
System.out.println("send msg");
321.
TimeUnit.SECONDS.sleep(10);
322.
} catch (Exception e) {
323.
// TODO Auto-generated catch block
324.
e.printStackTrace();
325.
}
326.
327.
}
328.
}
329.
}).start();
330.
} catch (Exception e) {
331.
// TODO Auto-generated catch block
332.
e.printStackTrace();
333.
}
334.
335.
}
336.
337.
}
已有 0 人发表留言，猛击->> 这里<<-参与讨论
ITeye推荐
相关 [nat] 推荐：
nat穿透原理
- - 开源软件 - ITeye博客一直以来，说起NAT穿透，很多人都会被告知使用UDP打孔这个技术，基本上没有人会告诉你如何使用TCP协议去穿透（甚至有的人会直接告诉你TCP协议是无法实现穿透的）. 但是，众所周知的是，UDP是一个无连接的数据报协议，使用它就必须自己维护收发数据包的完整性，这常常会大大增加程序的复杂度，而且一些程序由于某些原因，必须使用TCP协议，这样就常常令一些开发TCP网络程序的人员“谈穿透色变”.
[转]iptables防火墙与NAT服务
- - 小鸥的博客iptables防火墙与NAT服务. (1)设置在不同的网络或网络安全域之间的一系列部件的组合,它能增强机构内部网络的安全性. (2)通过审查经过每一个数据包，判断它是否有相匹配的过滤规则，根据规则先后顺序一一进行比较，直到满足其中的一条规则为止，然后依据控制机制做出相应的动作，若都不能满足，则将数据包丢弃，从而保护网络安全.
Xen 虚拟机的 NAT 网络配置
- - vpsee.com我们使用 Xen 虚拟机的时候一般都是用桥接（bridging）的方式把虚拟机（domU）直接暴露在网络上，就像网络上单独的一台服务器一样，这种方式简单好用，不用在 dom0 做任何的端口转发也不用任何 iptable 规则. 不过除了 bridging 以外，Xen 还支持 routing 和 NAT 的方式配置虚拟机网络.
NAT穿透解决方案介绍
- - 编程语言 - ITeye博客Agent B看到的source address就是经过转换后的IP和Port并不知道Agent A的局域网地址；当Agent B的响应到达Agent A的NAT设备后，NAT设备查找内存中保存的和这个外网地址相对应的内网地址，如果找到后就将这个data packet转发到这个地址，这样就实现了通信.
Docker 中 NAT 和 HOST 的区别
- - snoopyxdy的博客官方说明使用Dokcer容器启动应用可以媲美直接在宿主机上启动的性能，宣称使用Docker启动应用大约可以达到原来性能的90%，如此低的性能损耗应当归功于Docker容器虚拟化的轻量级. 但是事实真的如官方所说，仅有10%的损耗吗. 我们下面将比较原生启动 redis 实例和使用Docker启动的性能对比.
NAT穿透（UDP打洞） - heaventouch - 博客园
- -1、NAT（Network Address Translator）介绍. NAT有两大类，基本NAT和NAPT. 静态NAT：一个公网IP对应一个内部IP，一对一转换. 动态NAT：N个公网IP对应M个内部IP，不固定的一对一转换关系. 现在基本使用这种，又分为对称和锥型NAT. 锥型NAT，有完全锥型、受限制锥型、端口受限制锥型三种：.
udp打洞穿透nat实现p2p GitHub - pannzh/P2P-Over-MiddleBoxes-Demo: A simple demo of P2P communication over middle boxes such as NAT
- -一个P2P聊天程序，使用UDP打洞创建链接. ./p2pchat/server <服务器端口号>
./p2pchat/client <服务器IP>:<服务器端口号>
>>> help. 该UDP打洞示例仅支持锥形地址转换器（Cone NAT），如果两个客户端都在同一个公网结点下，需要确保出口路由器支持.
TPROXY之殇-NAT设备加代理的恶果
- - CSDN博客推荐文章无独有偶，过了N多年，又到了这个时候，碰到了同样的事情. xx年的万圣节，由于服务器瘫痪我们被罚了500块钱，最终发现瘫痪的原因是TPROXY造成的，当时每个大服务区有一台LVS负载均衡设备，工作在NAT模式下，下联一台核心交换机，核心交换机分出N条线路去往各小区域服务器群，每一个小区域服务群拥有一台TPROXY实现的登录代理服务器，仅仅对登录数据包做代理，其它的包直接通过.
用TCP穿透NAT（TCP打洞）的实现
- - 操作系统 - ITeye博客 我们假设在两个不同的局域网后面分别有2台客户机A和 B，AB所在的局域网都分别通过一个路由器接入互联网. 现在AB是无法直接和对方发送信息的，AB都不知道对方在互联网上真正的IP和端口， AB所在的局域网的路由器只允许内部向外主动发送的信息通过. 对于B直接发送给A的路由器的消息，路由会认为其“不被信任”而直接丢弃.