通过java的nio实例分析tcp握手与SYN泛洪攻击

一时失言乱红尘 2022-12-05 10:22 134阅读 0赞

*好吧，对于工作这事我又冲动了.*

*我总是这样一次次的犹豫，失去了一次次的机会.*

*也总是一次次的冲动，让原来可以挽回的事情就这样被我搞砸了.*

*我何时才能不再优柔寡断，成为那个刚毅果决爷们.*

*一定要加油，改变！*

--------------------

我还记得对于tcp三次握手和四次挥手的概念和主要过程还是大一时计算机网络课上学过，但是一直没有实际分析过。

今天周末，闲来无事，决定来研究一下tcp握手和挥手的过程。

## 实践环境 ##

1.  物理机(windows),ip:192.168.85.1
2.  虚拟机(ubuntu),ip:192.168.85.136
3.  wireshark

## 测试代码 ##

为了查看tcp建立连接的过程，以及熟悉下nio的编写过程，我就直接写一个服务端和客户端吧

### nio-server端源码 ###

import java.io.IOException;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.nio.ByteBuffer;
    import java.nio.channels.*;
    import java.util.Iterator;
    import java.util.Set;
    
    public class NioServer {
        /**
         * 监听的端口
         */
        private int listenPort;
        /**
         * 选择器
         */
        private Selector selector;
    
        private ByteBuffer buffer = ByteBuffer.allocate(1024);
    
        /**
         * @param listenPort 监听的端口
         */
        public NioServer(int listenPort) throws IOException {
            this.listenPort = listenPort;
            init(listenPort);
        }
    
    
        private void init(int listenPort) throws IOException {
            //Opens a server-socket channel.通过SelectorProvider打开的
            ServerSocketChannel socketChannel = ServerSocketChannel.open();
            //Adjusts this channel's blocking mode.false为非阻塞,也就是non-blocking:NB
            socketChannel.configureBlocking(false);
            //Retrieves a server socket associated with this channel.
            ServerSocket socket = socketChannel.socket();
            //绑定socket的端口
            socket.bind(new InetSocketAddress("192.168.85.1", listenPort));
            //通过SelectorProvider打一个selector
            selector = Selector.open();
            //把socket的连接事件注册到selector中
            socketChannel.register(selector, SelectionKey.OP_ACCEPT);
        }
    
        public static void main(String[] args) throws IOException {
            NioServer nioServer = new NioServer(1234);
            nioServer.start();
        }
    
        /**
         * 启动
         */
        private void start() throws IOException {
            for (; ; ) {
                //阻塞监听,返回关联IO操作的keys;如果已就绪的操作被改变了就返回0
                int numberOfKeys = selector.select();
                if (numberOfKeys == 0) {
                    continue;
                }
                System.out.println("key:" + numberOfKeys);
                //This selector's selected-key set
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                //遍历上面的key
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    //拿到selectionKey
                    SelectionKey key = iterator.next();
                    handleKey(key);
                    //处理完毕后手动移除
                    iterator.remove();
                }
            }
        }
    
        private void handleKey(SelectionKey key) throws IOException {
            if (key.isAcceptable()) {
                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                SocketChannel socketChannel = serverSocketChannel.accept();
                registerChannel(selector, socketChannel, SelectionKey.OP_READ);
                if (socketChannel.isConnected()) {
                    buffer.clear();
                    buffer.put("I am server...".getBytes());
                    buffer.flip();
                    socketChannel.write(buffer);
                }
            }
            if (key.isReadable()) {
                SocketChannel socketChannel = (SocketChannel) key.channel();
                buffer.clear();
                int len;
                while ((len = socketChannel.read(buffer)) > 0) {
                    buffer.flip();
                    System.out.println("server读取的数据：" + new String(buffer.array(), 0, len));
                }
                if (len < 0) {
                    socketChannel.close();
                }
                // SocketChannel通道的可写事件注册到Selector中
                registerChannel(selector, socketChannel, SelectionKey.OP_WRITE);
            }
            if (key.isWritable()) {
                SocketChannel socketChannel = (SocketChannel) key.channel();
                buffer.clear();
                String message_from_server = "hello,client." + socketChannel.getLocalAddress() + " your addr:" + socketChannel.getRemoteAddress();
                buffer.put(message_from_server.getBytes());
                buffer.flip();
                socketChannel.write(buffer);
                System.out.println("server发送的数据:" + message_from_server);
                registerChannel(selector, socketChannel, SelectionKey.OP_READ);
            }
        }
    
        private void registerChannel(Selector selector, SocketChannel socketChannel, int ops) throws IOException {
            if (socketChannel == null) {
                return;
            }
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, ops);
        }
    }

### bio-client端源码 ###

import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    import java.util.Scanner;
    
    public class TcpClient {
        public static void main(String[] args) throws Exception {
            // 要连接的服务端IP地址和端口
            String host = "192.168.31.22";
            int port = 1234;
            // 与服务端建立连接
            Socket socket = new Socket(host, port);
            // 建立连接后获得输出流
            OutputStream outputStream = socket.getOutputStream();
            String message = "你好  我是大佬";
            socket.getOutputStream().write(message.getBytes("UTF-8"));
            //通过shutdownOutput高速服务器已经发送完数据，后续只能接受数据
    //        socket.shutdownOutput();
    
            System.out.println("准备接收消息");
            InputStream inputStream = socket.getInputStream();
            byte[] bytes = new byte[1024];
            int len;
            StringBuilder sb = new StringBuilder();
            while ((len = inputStream.read(bytes)) != -1) {
                //注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
                sb.append(new String(bytes, 0, len, "UTF-8"));
                System.out.println("get message from server: " + sb);
            }
            Scanner scanner = new Scanner(System.in);
            String next = scanner.next();
            if ("c".equals(next)) {
                inputStream.close();
                outputStream.close();
                socket.close();
            }
        }
    }

### 运行及测试 ###

之前想的是直接在idea里启动两个程序，直接进行抓包分析的，但是试了几次后发现wireshark根本抓不到本地的数据包(搜索了资料后发现也可以下载其它软件抓本地的包后用wireshark打开也是可以的，觉得麻烦就不研究了)，所以最终我决定将server端放在物理机上运行，客户端放在VM里运行，这样应该就能抓到包了，实践证明也确实如此。

server端直接在idea里先启动好，client端直接用java命令编译运行启动即可。  
其运行截图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 1]

#### 抓包查看 ####

打开wireshark进行抓包，并选择对应的网卡。  
过滤下1234端口即可，因为服务端windows上监听的是1234端口

> tcp.port in \{1234\}

开启后重新运行下代码，查看一下被抓到的数据包，我这里抓的到数据包如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 2]

结合着server端的输出信息一起查看下：

key:1
    key:1
    server读取的数据：你好  我是大佬
    key:1
    server发送的数据:hello,client./192.168.85.1:1234 your addr:/192.168.85.136:47006

wireshark输出内容如下：

30	0.862162	192.168.85.136	192.168.85.1	TCP	74	47006 → 1234 [SYN] Seq=0 Win=29200 Len=0 MSS=1460 SACK_PERM=1 TSval=3171927 TSecr=0 WS=128
    31	0.862213	192.168.85.1	192.168.85.136	TCP	66	1234 → 47006 [SYN, ACK] Seq=0 Ack=1 Win=65535 Len=0 MSS=1460 WS=256 SACK_PERM=1
    32	0.862339	192.168.85.136	192.168.85.1	TCP	60	47006 → 1234 [ACK] Seq=1 Ack=1 Win=29312 Len=0
    33	0.862726	192.168.85.1	192.168.85.136	TCP	68	1234 → 47006 [PSH, ACK] Seq=1 Ack=1 Win=1051136 Len=14
    34	0.862787	192.168.85.136	192.168.85.1	TCP	74	47006 → 1234 [PSH, ACK] Seq=1 Ack=1 Win=29312 Len=20
    35	0.862872	192.168.85.136	192.168.85.1	TCP	60	47006 → 1234 [ACK] Seq=21 Ack=15 Win=29312 Len=0
    36	0.863085	192.168.85.1	192.168.85.136	TCP	117	1234 → 47006 [PSH, ACK] Seq=15 Ack=21 Win=1051136 Len=63
    37	0.863197	192.168.85.136	192.168.85.1	TCP	60	47006 → 1234 [ACK] Seq=21 Ack=78 Win=29312 Len=0
    48	3.399703	192.168.85.136	192.168.85.1	TCP	60	47006 → 1234 [FIN, ACK] Seq=21 Ack=78 Win=29312 Len=0
    49	3.399748	192.168.85.1	192.168.85.136	TCP	54	1234 → 47006 [ACK] Seq=78 Ack=22 Win=1051136 Len=0
    50	3.400053	192.168.85.1	192.168.85.136	TCP	54	1234 → 47006 [FIN, ACK] Seq=78 Ack=22 Win=1051136 Len=0
    51	3.400601	192.168.85.136	192.168.85.1	TCP	60	47006 → 1234 [ACK] Seq=22 Ack=79 Win=29312 Len=0

再画一个图:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 3]

加点注释：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 4]

## 思考 ##

### 为什么需要三次握手? ###

人个理解：因为TCP是可靠的，既然可靠，那么就必须确保客户端和服务端都是能正常通信且都具备收发消息的能力；下图画黄线的字代表每次握手能体现的能力;

1.  第一次握手，由客户端发起，至于有没有成功发现服务端，现在还不知道；【client发送能力，client接收能力】【server发送能力，server接收能力】
2.  第二次握手，由服务端响应客户端，既然服务端都知道响应消息了，那么说明服务端已经收到了客户端的消息了 【client发送能力，client接收能力】【server发送能力，server接收能力】
3.  第三次握手，在客户端收到服务端的确认消息后，向服务端回应一条确认消息以告诉服务端自己收到了刚刚发过来的消息 【client发送能力，client接收能力】【server发送能力，server接收能力】

### TCP会话过程中为什么是可靠的？ ###

个人理解：所谓的可靠是与UDP相对比而言的，大家都知道TCP是可靠的，UDP是不可靠的。那么这里的可靠指的是TCP发一条消息出去，能确保消息发送成功；  
而UDP发消息则是只管发，不管对方有没有收到。

**那么tcp报文里又是怎么体现出来消息可靠的呢？**

再继续看上面抓包的报文，从图片我们可以知道，发消息对应的是PSH操作，确认消息对应的是ACK操作。每发一条PSH过去后，都有一条对应的ACK消息响应回来。

### 断开连接时为什么就需要四次？ ###

先看一下在client端按ctrl+c结束程序时的数据包信息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 5]  
server端readble部分修改后的代码如下：

if (key.isReadable()) {
                SocketChannel socketChannel = (SocketChannel) key.channel();
                if (socketChannel.finishConnect()) {
                    System.out.println("fin");
                } else {
                    System.out.println("not fin");
                }
                buffer.clear();
                int len;
                while ((len = socketChannel.read(buffer)) > 0) {
                    buffer.flip();
                    System.out.println("server读取的数据：" + new String(buffer.array(), 0, len));
                }
                if (len < 0) {
                    //读取到的数据为-1代表连接将要断开
                    System.out.println("client要断开连接." + socketChannel.getRemoteAddress());
                    buffer.clear();
                    buffer.put("bye client!!!!!!!!...".getBytes());
                    buffer.flip();
                    System.out.println("再次发送byebye消息");
                    socketChannel.write(buffer);
    
                    socketChannel.close();
                    System.out.println("连接关闭");
                    return;
                } else {
                    // SocketChannel通道的可写事件注册到Selector中
                    registerChannel(selector, socketChannel, SelectionKey.OP_WRITE);
                }
            }

改造代码，来个6次挥手  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 6]  
通过实践我们可以得知，TCP的断开连接并不一定就是四次挥手，如果有数据包需要继续发送的话，可能会是多于四次的，比如上面就进行了六次挥手才将TCP连接断开。但是可以证明一点，正常情况下的TCP断开是至少进行了四次挥手才将连接释放掉的.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 7]

那么为什么TCP断开连接时需要进行四次挥手呢？**是为了确保客户端与服务端的数据已发送完毕**

## syn泛洪攻击 ##

### 演示 ###

### 分析和解决办法 ###

TCP泛洪攻击，未完待续……

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/606973944ba1449d974468b767e1d699.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/ea75ca1f863f4c608e6fa1e785cf042d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/a3537c86a53a4acc87c659f0867b04c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/3af3d9369c424be98406f23b18daec44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/057f253611404a54b535cd089282fb0d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/4b8589d3dba840e995b1c138a936ef45.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/1a465806dff94b579c4cdec2f903083a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3B1aGFpeWFuZw_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/eec05e2e784d4afb83fbf49105965654.png