IP/TCP/UDP报文解析（1）IP报文

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
public class IPPacket extends Packet{
    private final static String TAG = IPPacket.class.getSimpleName();

    private final static int VERSION_BIT = 0;
    private final static int HEADER_LENGTH_BIT = 0;
    private final static int TOS_BIT = 1;
    private final static int TOTAL_LENGTH_BIT = 2;
    private final static int SEQUENCE_BIT = 4;
    private final static int TAG_BIT = 6;
    private final static int OFFSET_BIT = 6;
    private final static int LIVE_BIT = 8;

    private final static int PROTOCL_BIT = 9;
    public final static int PROTOCL_ICMP = 1;
    public final static int PROTOCL_IGMP = 2;
    public final static int PROTOCL_OSPF = 89;
    public final static int PROTOCL_TCP = 6;
    public final static int PROTOCL_UDP = 17;

    private final static int HEADER_SUM_BIT = 10;
    private final static int LOCAL_IP_BIT = 12;
    private final static int REMOTE_IP_BIT = 16;


    public IPPacket(byte[] bytes, int... parameters){
        super(bytes,parameters);
    }

    /**
     * 获取IP报文协议版本
     * 协议版本
     *     在IP报文第0个字节中前4位 占1/2字节 共4位
     * @return
     */
    public int getVersion(){
        return (bytes[VERSION_BIT] & 0xFF) >> 4;
    }

    /**
     * 获取IP报文头长度
     * 报头长度
     *     在IP报文第0个字节中后4位 占1/2字节 共4位
     *     最小表示为 0000(十进制0) 最大表示为 1111(十进制15) 单位为4字节
     *     也就是报头 最小为0 * 4字节0 * 4 * 8 = 0位，最大为15 * 4字节15 * 4 * 8 = 480位
     *     一般报头长度是0101（十进制5），也就是5 * 4 = 20字节
     * @return
     */
    public int getHeaderLength(){
        return (bytes[HEADER_LENGTH_BIT] & 0xF) * 4;
    }

    /**
     * 获取TOS服务字段
     * 服务类型
     *     在IP报文中第1个字节 占1字节 共8位
     *     一般情况不使用 也没查到具体有什么用
     * @return
     */
    public int getTos(){
        return bytes[TOS_BIT] & 0xFF;
    }

    /**
     * 获取IP报文总长度
     * 数据报总长度
     *     在IP报文中第2、3字节 占2字节 共16位 单位为1字节
     *     标注没有分片前整个IP请求的总长度（包括 数据 和 报头）
     * @return
     */
    public int getTotalLength(){
        return byteToInt(bytes[TOTAL_LENGTH_BIT],bytes[TOTAL_LENGTH_BIT + 1]);
    }

    /**
     * 获取序列码
     * 序列码
     *     在IP报文中第4个和第5个字节 占2字节 共16位
     *     分片请求时用作同IP请求标识
     *     开始发送数据时由发送方生成。标识发送方发送的每一个数据报，如果发送的数据报未发生分片，则此值依次加1，如果发生了分片，分片后的各个数据报使用同一个序列号。
     * @return
     */
    public int getSequence(){
        return byteToInt(bytes[SEQUENCE_BIT],bytes[SEQUENCE_BIT + 1]);
    }

    /**
     * 获取标志位
     * 分片标志
     *     在IP报文中第6个字节的前3位 占3/8字节 共3位
     *     第一位保留，未使用。
     *     第二位是DF（Don’t Fragment），如果为1，表示未发生分片;如果为0，表示发生了分片。
     *     第三位是MF（More Fragment），如果为1，表示发生了分片，并且除了分片出的最后一个报文中此标志为0，其余报文中此标志均为1
     *     该标志位有以下几个可能的值
     *      001（十进制1）：发生分片且后续还有分片
     *      000（十进制0）：发生分片且这是最后一个分片
     *      010（十进制2）：不能分片
     * @return
     */
    public int getTag(){
        return (bytes[TAG_BIT] & 0xFF) >> 5 ;
    }

    /**
     * 是否发生分片
     * 1 为未发生分片 返回false
     * 0 为发生了分片 返回true
     * DF Don't Fragment
     * @return
     */
    public boolean isDF(){
        if((getTag() >> 1) == 1){
            return false;
        }else{
            return true;
        }
    }

    /**
     * 是否还有分片
     * 如果未发生分片直接返回false
     * 如果发生分片且后面还有分片返回true
     * 如果发生分片且后面没有分片了返回false
     * MF  More Fragment
     * @return
     */
    public boolean isMF(){
        if(isDF() && (getTag() & 1) == 1){
            return true;
        }else{
            return false;
        }
    }

    /**
     * 获取片偏移
     * 片偏移量 单位 8 byte
     *     在IP报文中第6个字节的后5位和第7个字节 占13/8字节 共13位
     *     标识分片相对于原始IP数据报开始处的偏移。只在分片传输时起作用
     *     链路层MTU（Maximum Transmission Unit 最大传输单元）为1500
     *     如果IP报文总长度超过这个数值，就会产生IP分片
     *      下面是计算公式
     *      假设链路层传输时分片数量为 n
     *      IP报头长度为20字节（实际传输时默认为20）
     *      IP报文总长度为 m
     *      分片后的片偏移为y (不管有没有分片，首个IP分片的片偏移肯定是0 如果有分片n肯定是大于1的)
     *      n = m > 1500  ? (m - m % 1500) / 1500 + 1 ：1
     *      y = (1500 - 20) * (n - 1) / 8
     *      可能会觉得懵逼 为什么还会除一个8 这是因为片偏移的单位是 8 byte 这里得到的值是最后写到报文中片偏移的值
     *      我看过一个文档上面写的有个这样的描述：从0位到1479位是IP报数据位 当时不明白这个1479是怎么来的
     *      后来仔细想想   这玩意是从下标读数来的 数组中读数是从0位开始到 数组长度 - 1 结束。
     *      也就是 MTU - 报头长度 - 1 => 1500 - 20 - 1 = 1479
     *      从0位数到1479位 正好是1500个位置。
     * @return
     */
    public int getOffsetByte(){
        return byteToInt(bytes[OFFSET_BIT],bytes[OFFSET_BIT + 1]) * 8;
    }

    /**
     * 获取生命周期
     * 生存时间
     *     在IP报文中第8个字节 占1字节 共8位
     *     表示生存周期，每经过一个路由值减一，防止路由环路。（windows系统下默认值为128 二进制 10000000）
     *     例如 路由A发数据给B B又转发给A 值依次衰减，值为0时或主动停止时停止转发
     * @return
     */
    public int getLive(){
        return bytes[LIVE_BIT] & 0xFF;
    }

    /**
     * 获取上层协议
     * 上层协议
     *     在IP报文中第9个字节 占1字节 共8位
     *     该值标识上层协议
     *     其中常见的值有
     *      ICMP协议 十进制 1 二进制 00000001
     *      IGMP协议 十进制 2 二进制 00000010
     *      OSPF协议 十进制 89 二进制 01011001
     *      TCP协议 十进制 6 二进制 00000110
     *      UDP协议 十进制 17 二进制 00010001
     * @return
     */
    public int getProtocl(){
        return bytes[PROTOCL_BIT] & 0xFF;
    }

    /**
     * 获取头部校验和
     * 头部校验和
     *     在IP报文中第10、11个字节 占2字节 共16位
     *     该值是对整个数据包的包头进行的校验
     * @return
     */
    public int getHeaderSum(){
        return byteToInt(bytes[HEADER_SUM_BIT],bytes[HEADER_SUM_BIT + 1]);
    }



    /**
     * 获取本地IP地址 String类型
     * x.x.x.x格式
     * 源IP地址
     *        在IP报文中第12、13、14、15个字节 占4个字节（32位）
     *        表示本地IP地址（发送方MAC地址 也就是发送方的物理硬件地址） 那么地址掩码又是怎么回事？
     *        因为一个字节最大表示数为255 所以我们看到的IP地址通常写为x.x.x.x的格式(x为0-255的十进制数 转换为二进制数为00000000~11111111)
     * @return
     */
    public String getLocalIpString(){
        return (bytes[LOCAL_IP_BIT] & 0xFF)
                + "." + (bytes[LOCAL_IP_BIT + 1] & 0xFF)
                + "." + (bytes[LOCAL_IP_BIT + 2] & 0xFF)
                + "." + (bytes[LOCAL_IP_BIT + 3] & 0xFF);
    }

    public int getLocalIpInt(){
        return byteToInt(bytes[LOCAL_IP_BIT],bytes[LOCAL_IP_BIT + 1],bytes[LOCAL_IP_BIT + 2],bytes[LOCAL_IP_BIT + 3]);
    }

    /**
     * 获取远程IP地址 String类型
     * x.x.x.x格式
     * 目的IP地址
     *           在IP报文中第16、17、18、19个字节 占4个字节（32位）
     *           远程IP地址（接收方MAC地址 也就是接收方的物理硬件地址）
     *           因为一个字节最大表示数为255 所以我们看到的IP地址通常写为x.x.x.x的格式(x为0-255的十进制数 转换为二进制数为00000000~11111111)
     * @return
     */
    public String getRemoteIpString(){
        return (bytes[REMOTE_IP_BIT] & 0xFF)
                + "." + (bytes[REMOTE_IP_BIT + 1] & 0xFF)
                + "." + (bytes[REMOTE_IP_BIT + 2] & 0xFF)
                + "." + (bytes[REMOTE_IP_BIT + 3] & 0xFF);
    }

    public int getRemoteIpInt(){
        return byteToInt(bytes[REMOTE_IP_BIT],bytes[REMOTE_IP_BIT + 1],bytes[REMOTE_IP_BIT + 2],bytes[REMOTE_IP_BIT + 3]);
    }



    /**
     * 检查头部校验和
     * 很无语这个校验和的算法模式为什么会这样设计
     * 直接取每个字节中表示的十进制数相加不就得了
     * 还非得用16位来表示肯定会溢出的校验和
     * 这个方法还没有搞明白
     */
    public boolean checkSum(){
        return (( ~getSum() ) & 0xFFFF) == 0;
    }

    /**
     * 校验求和
     * @return
     */
    private int getSum(){
        int headerLength = getHeaderLength();
        int sum = 0;

        // 两字节一组依次计算16位和得到累加值
        for(int i = offset; i < offset + headerLength; i += 2){
            sum +=  byteToInt(bytes[i],bytes[i + 1]);
        }

        // 如果报头为奇数 那么最后一个字节的和也需要加上
        if((offset + headerLength) % 2 > 0 ){
            sum += (bytes[offset + headerLength - 1] & 0xFF) << 8;
        }

        //这里计算校验和16位之上是否有进位 若有进位则循环折叠求和 直到16位之上没有进位
        while ((sum >> 16) > 0){
            sum = (sum >> 16) + (sum & 0xFFFF);
        }

        return sum;
    }

    /**
     * 设置完参数后重新计算校验和并设置
     */
    public void refreshCheckSum(){
        bytes[HEADER_SUM_BIT] = 0;
        bytes[HEADER_SUM_BIT + 1] = 0;
        int sum = ~getSum();
        bytes[HEADER_SUM_BIT] = (byte) (sum >> 8);
        bytes[HEADER_SUM_BIT + 1] = (byte)(sum);
    }


    public void setLocalIp(String ip){
        String[] strings = ip.split("\.");

        if(strings.length != 4) return;

        int y = 255;

        for(int i = 0;i < 4; i++){
            try {
                y = Integer.valueOf(strings[0]);
            }catch (NumberFormatException e){}

            bytes[REMOTE_IP_BIT + i] = (byte) y;
        }
    }

    public void setLocalIp(int ip){
        for(int i = 0; i < 4;i ++){
            bytes[LOCAL_IP_BIT + i] = (byte) (ip >> ((3 - i) * 8));
        }
    }

    public void setRemoteIp(String ip){

        String[] strings = ip.split("\.");

        if(strings.length != 4) return;

        int y = 255;

        for(int i = 0;i < 4; i++){
            try {
                y = Integer.valueOf(strings[0]);
            }catch (NumberFormatException e){}

            bytes[REMOTE_IP_BIT + i] = (byte) y;
        }

    }

    public void setRemoteIp(int ip){
        for(int i = 0; i < 4;i ++){
            bytes[REMOTE_IP_BIT + i] = (byte) (ip >> ((3 - i) * 8));
        }
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
public class Packet {

    // 数据报文
    protected byte[] bytes;

    // 偏移值
    protected int offset;

    // 有效数据长度
    protected int validLength;

    // 下一层的包
    protected Packet packet;

    /**
     *
     * @param bytes 收到的byte数据集合
     * @param parameters 一些参数 如：数据偏移 有效长度
     */
    public Packet(byte[] bytes,int... parameters){
        this.bytes = bytes;
        if(parameters != null){
            if(parameters.length > 0){
                offset = parameters[0];
                if(parameters.length > 1){
                    validLength = parameters[1];
                }
            }
        }

        if(validLength == 0){
            validLength = bytes.length;
        }else if(validLength > bytes.length){
            validLength = bytes.length;
        }
    }

    /**
     * 获取下级协议
     * @return
     */
    public Packet getPacket() {
        return packet;
    }

    /**
     * 设置下级协议 从上至下依次为 HTTP/HTTPS -> TCP/UDP -> IP -> 网路路由
     * @param packet
     */
    public void setPacket(Packet packet) {
        this.packet = packet;
    }

    /**
     * 获取数据
     * @return
     */
    public byte[] getBytes(){
        return bytes;
    }

    /**
     * 获取数据偏移
     * @return
     */
    public int getOffset(){
        return offset;
    }

    /**
     * 获取数据有效长度
     * @return
     */
    public int getValidLength(){
        return validLength;
    }

    /**
     * 获取报头长度
     * @return
     */
    public int getHeaderLength(){
        return 0;
    }


    public int byteToInt(byte... bytes){

        int sum = 0;

        if(bytes == null) return 0;

        for (int i =  0; i < bytes.length && bytes.length <= 4; i ++){
            sum |= (bytes[i] & 0xFF) << ((bytes.length - 1 - i) * 8);
        }

        return sum;
    }

    public byte intToByte(int i){
        return (byte) i;
    }

    public byte[] intToBytes(int i){
        byte[] bytes = new byte[4];
        bytes[0] = (byte) (i >> 24);
        bytes[1] = (byte) (i >> 16);
        bytes[2] = (byte) (i >> 8);
        bytes[3] = (byte) i;
        return bytes;
    }

}