VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/checksum/ipv4.cpp@ 81106

Last change on this file since 81106 was 76553, checked in by vboxsync, 6 years ago

scm --update-copyright-year

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 29.7 KB
Line 
1/* $Id: ipv4.cpp 76553 2019-01-01 01:45:53Z vboxsync $ */
2/** @file
3 * IPRT - IPv4 Checksum calculation and validation.
4 */
5
6/*
7 * Copyright (C) 2008-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 */
26
27
28/*********************************************************************************************************************************
29* Header Files *
30*********************************************************************************************************************************/
31#include <iprt/net.h>
32#include "internal/iprt.h"
33
34#include <iprt/asm.h>
35#include <iprt/assert.h>
36
37
38/**
39 * Calculates the checksum of the IPv4 header.
40 *
41 * @returns Checksum (network endian).
42 * @param pIpHdr Pointer to the IPv4 header to checksum, network endian (big).
43 * Assumes the caller already checked the minimum size requirement.
44 */
45RTDECL(uint16_t) RTNetIPv4HdrChecksum(PCRTNETIPV4 pIpHdr)
46{
47 uint16_t const *paw = (uint16_t const *)pIpHdr;
48 uint32_t u32Sum = paw[0] /* ip_hl */
49 + paw[1] /* ip_len */
50 + paw[2] /* ip_id */
51 + paw[3] /* ip_off */
52 + paw[4] /* ip_ttl */
53 /*+ paw[5] == 0 */ /* ip_sum */
54 + paw[6] /* ip_src */
55 + paw[7] /* ip_src:16 */
56 + paw[8] /* ip_dst */
57 + paw[9]; /* ip_dst:16 */
58 /* any options */
59 if (pIpHdr->ip_hl > 20 / 4)
60 {
61 /* this is a bit insane... (identical to the TCP header) */
62 switch (pIpHdr->ip_hl)
63 {
64 case 6: u32Sum += paw[10] + paw[11]; break;
65 case 7: u32Sum += paw[10] + paw[11] + paw[12] + paw[13]; break;
66 case 8: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15]; break;
67 case 9: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17]; break;
68 case 10: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19]; break;
69 case 11: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21]; break;
70 case 12: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23]; break;
71 case 13: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25]; break;
72 case 14: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27]; break;
73 case 15: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27] + paw[28] + paw[29]; break;
74 default:
75 AssertFailed();
76 }
77 }
78
79 /* 16-bit one complement fun */
80 u32Sum = (u32Sum >> 16) + (u32Sum & 0xffff); /* hi + low words */
81 u32Sum += u32Sum >> 16; /* carry */
82 return (uint16_t)~u32Sum;
83}
84RT_EXPORT_SYMBOL(RTNetIPv4HdrChecksum);
85
86
87/**
88 * Verifies the header version, header size, packet size, and header checksum
89 * of the specified IPv4 header.
90 *
91 * @returns true if valid, false if invalid.
92 * @param pIpHdr Pointer to the IPv4 header to validate. Network endian (big).
93 * @param cbHdrMax The max header size, or the max size of what pIpHdr points
94 * to if you like. Note that an IPv4 header can be up to 60 bytes.
95 * @param cbPktMax The max IP packet size, IP header and payload. This doesn't have
96 * to be mapped following pIpHdr.
97 * @param fChecksum Whether to validate the checksum (GSO).
98 */
99RTDECL(bool) RTNetIPv4IsHdrValid(PCRTNETIPV4 pIpHdr, size_t cbHdrMax, size_t cbPktMax, bool fChecksum)
100{
101 /*
102 * The header fields.
103 */
104 Assert(cbPktMax >= cbHdrMax);
105 if (RT_UNLIKELY(cbHdrMax < RTNETIPV4_MIN_LEN))
106 return false;
107 if (RT_UNLIKELY(pIpHdr->ip_hl * 4 < RTNETIPV4_MIN_LEN))
108 return false;
109 if (RT_UNLIKELY((size_t)pIpHdr->ip_hl * 4 > cbHdrMax))
110 {
111 Assert((size_t)pIpHdr->ip_hl * 4 > cbPktMax); /* You'll hit this if you mapped/copy too little of the header! */
112 return false;
113 }
114 if (RT_UNLIKELY(pIpHdr->ip_v != 4))
115 return false;
116 if (RT_UNLIKELY(RT_BE2H_U16(pIpHdr->ip_len) > cbPktMax))
117 return false;
118
119 /*
120 * The header checksum if requested.
121 */
122 if (fChecksum)
123 {
124 uint16_t u16Sum = RTNetIPv4HdrChecksum(pIpHdr);
125 if (RT_UNLIKELY(pIpHdr->ip_sum != u16Sum))
126 return false;
127 }
128 return true;
129}
130RT_EXPORT_SYMBOL(RTNetIPv4IsHdrValid);
131
132
133/**
134 * Calculates the checksum of a pseudo header given an IPv4 header [inlined].
135 *
136 * @returns 32-bit intermediary checksum value.
137 * @param pIpHdr The IP header (network endian (big)).
138 */
139DECLINLINE(uint32_t) rtNetIPv4PseudoChecksum(PCRTNETIPV4 pIpHdr)
140{
141 uint16_t cbPayload = RT_BE2H_U16(pIpHdr->ip_len) - pIpHdr->ip_hl * 4;
142 uint32_t u32Sum = pIpHdr->ip_src.au16[0]
143 + pIpHdr->ip_src.au16[1]
144 + pIpHdr->ip_dst.au16[0]
145 + pIpHdr->ip_dst.au16[1]
146#ifdef RT_BIG_ENDIAN
147 + pIpHdr->ip_p
148#else
149 + ((uint32_t)pIpHdr->ip_p << 8)
150#endif
151 + RT_H2BE_U16(cbPayload);
152 return u32Sum;
153}
154
155
156/**
157 * Calculates the checksum of a pseudo header given an IPv4 header.
158 *
159 * @returns 32-bit intermediary checksum value.
160 * @param pIpHdr The IP header (network endian (big)).
161 */
162RTDECL(uint32_t) RTNetIPv4PseudoChecksum(PCRTNETIPV4 pIpHdr)
163{
164 return rtNetIPv4PseudoChecksum(pIpHdr);
165}
166RT_EXPORT_SYMBOL(RTNetIPv4PseudoChecksum);
167
168
169/**
170 * Calculates the checksum of a pseudo header given the individual components.
171 *
172 * @returns 32-bit intermediary checksum value.
173 * @param SrcAddr The source address in host endian.
174 * @param DstAddr The destination address in host endian.
175 * @param bProtocol The protocol number.
176 * @param cbPkt The packet size (host endian of course) (no IPv4 header).
177 */
178RTDECL(uint32_t) RTNetIPv4PseudoChecksumBits(RTNETADDRIPV4 SrcAddr, RTNETADDRIPV4 DstAddr, uint8_t bProtocol, uint16_t cbPkt)
179{
180 uint32_t u32Sum = RT_H2BE_U16(SrcAddr.au16[0])
181 + RT_H2BE_U16(SrcAddr.au16[1])
182 + RT_H2BE_U16(DstAddr.au16[0])
183 + RT_H2BE_U16(DstAddr.au16[1])
184#ifdef RT_BIG_ENDIAN
185 + bProtocol
186#else
187 + ((uint32_t)bProtocol << 8)
188#endif
189 + RT_H2BE_U16(cbPkt);
190 return u32Sum;
191}
192RT_EXPORT_SYMBOL(RTNetIPv4PseudoChecksumBits);
193
194
195/**
196 * Adds the checksum of the UDP header to the intermediate checksum value [inlined].
197 *
198 * @returns 32-bit intermediary checksum value.
199 * @param pUdpHdr Pointer to the UDP header to checksum, network endian (big).
200 * @param u32Sum The 32-bit intermediate checksum value.
201 */
202DECLINLINE(uint32_t) rtNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t u32Sum)
203{
204 u32Sum += pUdpHdr->uh_sport
205 + pUdpHdr->uh_dport
206 /*+ pUdpHdr->uh_sum = 0 */
207 + pUdpHdr->uh_ulen;
208 return u32Sum;
209}
210
211
212/**
213 * Adds the checksum of the UDP header to the intermediate checksum value.
214 *
215 * @returns 32-bit intermediary checksum value.
216 * @param pUdpHdr Pointer to the UDP header to checksum, network endian (big).
217 * @param u32Sum The 32-bit intermediate checksum value.
218 */
219RTDECL(uint32_t) RTNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t u32Sum)
220{
221 return rtNetIPv4AddUDPChecksum(pUdpHdr, u32Sum);
222}
223RT_EXPORT_SYMBOL(RTNetIPv4AddUDPChecksum);
224
225
226/**
227 * Adds the checksum of the TCP header to the intermediate checksum value [inlined].
228 *
229 * @returns 32-bit intermediary checksum value.
230 * @param pTcpHdr Pointer to the TCP header to checksum, network
231 * endian (big). Assumes the caller has already validate
232 * it and made sure the entire header is present.
233 * @param u32Sum The 32-bit intermediate checksum value.
234 */
235DECLINLINE(uint32_t) rtNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t u32Sum)
236{
237 uint16_t const *paw = (uint16_t const *)pTcpHdr;
238 u32Sum += paw[0] /* th_sport */
239 + paw[1] /* th_dport */
240 + paw[2] /* th_seq */
241 + paw[3] /* th_seq:16 */
242 + paw[4] /* th_ack */
243 + paw[5] /* th_ack:16 */
244 + paw[6] /* th_off, th_x2, th_flags */
245 + paw[7] /* th_win */
246 /*+ paw[8] == 0 */ /* th_sum */
247 + paw[9]; /* th_urp */
248 if (pTcpHdr->th_off > RTNETTCP_MIN_LEN / 4)
249 {
250 /* this is a bit insane... (identical to the IPv4 header) */
251 switch (pTcpHdr->th_off)
252 {
253 case 6: u32Sum += paw[10] + paw[11]; break;
254 case 7: u32Sum += paw[10] + paw[11] + paw[12] + paw[13]; break;
255 case 8: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15]; break;
256 case 9: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17]; break;
257 case 10: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19]; break;
258 case 11: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21]; break;
259 case 12: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23]; break;
260 case 13: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25]; break;
261 case 14: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27]; break;
262 case 15: u32Sum += paw[10] + paw[11] + paw[12] + paw[13] + paw[14] + paw[15] + paw[16] + paw[17] + paw[18] + paw[19] + paw[20] + paw[21] + paw[22] + paw[23] + paw[24] + paw[25] + paw[26] + paw[27] + paw[28] + paw[29]; break;
263 default:
264 AssertFailed();
265 }
266 }
267
268 return u32Sum;
269}
270
271
272/**
273 * Adds the checksum of the TCP header to the intermediate checksum value.
274 *
275 * @returns 32-bit intermediary checksum value.
276 * @param pTcpHdr Pointer to the TCP header to checksum, network
277 * endian (big). Assumes the caller has already validate
278 * it and made sure the entire header is present.
279 * @param u32Sum The 32-bit intermediate checksum value.
280 */
281RTDECL(uint32_t) RTNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t u32Sum)
282{
283 return rtNetIPv4AddTCPChecksum(pTcpHdr, u32Sum);
284}
285RT_EXPORT_SYMBOL(RTNetIPv4AddTCPChecksum);
286
287
288/**
289 * Adds the checksum of the specified data segment to the intermediate checksum value [inlined].
290 *
291 * @returns 32-bit intermediary checksum value.
292 * @param pvData Pointer to the data that should be checksummed.
293 * @param cbData The number of bytes to checksum.
294 * @param u32Sum The 32-bit intermediate checksum value.
295 * @param pfOdd This is used to keep track of odd bits, initialize to false
296 * when starting to checksum the data (aka text) after a TCP
297 * or UDP header (data never start at an odd offset).
298 */
299DECLINLINE(uint32_t) rtNetIPv4AddDataChecksum(void const *pvData, size_t cbData, uint32_t u32Sum, bool *pfOdd)
300{
301 uint16_t const *pw = (uint16_t const *)pvData;
302 if (*pfOdd)
303 {
304#ifdef RT_BIG_ENDIAN
305 /* there was an odd byte in the previous chunk, add the lower byte. */
306 u32Sum += *(uint8_t *)pvData;
307#else
308 /* there was an odd byte in the previous chunk, add the upper byte. */
309 u32Sum += (uint32_t)*(uint8_t *)pvData << 8;
310#endif
311 /* skip the byte. */
312 cbData--;
313 if (!cbData)
314 return u32Sum;
315 pvData = (uint8_t const *)pvData + 1;
316 }
317
318 /* iterate the data. */
319 while (cbData > 1)
320 {
321 u32Sum += *pw;
322 pw++;
323 cbData -= 2;
324 }
325
326 /* handle odd byte. */
327 if (cbData)
328 {
329#ifdef RT_BIG_ENDIAN
330 u32Sum += (uint32_t)*(uint8_t *)pw << 8;
331#else
332 u32Sum += *(uint8_t *)pw;
333#endif
334 *pfOdd = true;
335 }
336 else
337 *pfOdd = false;
338 return u32Sum;
339}
340
341/**
342 * Adds the checksum of the specified data segment to the intermediate checksum value.
343 *
344 * @returns 32-bit intermediary checksum value.
345 * @param pvData The data bits to checksum.
346 * @param cbData The number of bytes to checksum.
347 * @param u32Sum The 32-bit intermediate checksum value.
348 * @param pfOdd This is used to keep track of odd bits, initialize to false
349 * when starting to checksum the data (aka text) after a TCP
350 * or UDP header (data never start at an odd offset).
351 */
352RTDECL(uint32_t) RTNetIPv4AddDataChecksum(void const *pvData, size_t cbData, uint32_t u32Sum, bool *pfOdd)
353{
354 return rtNetIPv4AddDataChecksum(pvData, cbData, u32Sum, pfOdd);
355}
356RT_EXPORT_SYMBOL(RTNetIPv4AddDataChecksum);
357
358
359/**
360 * Finalizes a IPv4 checksum [inlined].
361 *
362 * @returns The checksum (network endian).
363 * @param u32Sum The 32-bit intermediate checksum value.
364 */
365DECLINLINE(uint16_t) rtNetIPv4FinalizeChecksum(uint32_t u32Sum)
366{
367 /* 16-bit one complement fun */
368 u32Sum = (u32Sum >> 16) + (u32Sum & 0xffff); /* hi + low words */
369 u32Sum += u32Sum >> 16; /* carry */
370 return (uint16_t)~u32Sum;
371}
372
373
374/**
375 * Finalizes a IPv4 checksum.
376 *
377 * @returns The checksum (network endian).
378 * @param u32Sum The 32-bit intermediate checksum value.
379 */
380RTDECL(uint16_t) RTNetIPv4FinalizeChecksum(uint32_t u32Sum)
381{
382 return rtNetIPv4FinalizeChecksum(u32Sum);
383}
384RT_EXPORT_SYMBOL(RTNetIPv4FinalizeChecksum);
385
386
387/**
388 * Calculates the checksum for the UDP header given the UDP header w/ payload
389 * and the checksum of the pseudo header.
390 *
391 * @returns The checksum (network endian).
392 * @param u32Sum The checksum of the pseudo header. See
393 * RTNetIPv4PseudoChecksum and RTNetIPv6PseudoChecksum.
394 * @param pUdpHdr Pointer to the UDP header and the payload, in
395 * network endian (big). We use the uh_ulen field to
396 * figure out how much to checksum.
397 */
398RTDECL(uint16_t) RTNetUDPChecksum(uint32_t u32Sum, PCRTNETUDP pUdpHdr)
399{
400 bool fOdd;
401 u32Sum = rtNetIPv4AddUDPChecksum(pUdpHdr, u32Sum);
402 fOdd = false;
403 u32Sum = rtNetIPv4AddDataChecksum(pUdpHdr + 1, RT_BE2H_U16(pUdpHdr->uh_ulen) - sizeof(*pUdpHdr), u32Sum, &fOdd);
404 return rtNetIPv4FinalizeChecksum(u32Sum);
405}
406RT_EXPORT_SYMBOL(RTNetUDPChecksum);
407
408
409/**
410 * Calculates the checksum for the UDP header given the IP header,
411 * UDP header and payload.
412 *
413 * @returns The checksum (network endian).
414 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
415 * @param pUdpHdr Pointer to the UDP header, in network endian (big).
416 * @param pvData Pointer to the UDP payload. The size is taken from the
417 * UDP header and the caller is supposed to have validated
418 * this before calling.
419 */
420RTDECL(uint16_t) RTNetIPv4UDPChecksum(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, void const *pvData)
421{
422 bool fOdd;
423 uint32_t u32Sum = rtNetIPv4PseudoChecksum(pIpHdr);
424 u32Sum = rtNetIPv4AddUDPChecksum(pUdpHdr, u32Sum);
425 fOdd = false;
426 u32Sum = rtNetIPv4AddDataChecksum(pvData, RT_BE2H_U16(pUdpHdr->uh_ulen) - sizeof(*pUdpHdr), u32Sum, &fOdd);
427 return rtNetIPv4FinalizeChecksum(u32Sum);
428}
429RT_EXPORT_SYMBOL(RTNetIPv4UDPChecksum);
430
431
432/**
433 * Simple verification of an UDP packet size.
434 *
435 * @returns true if valid, false if invalid.
436 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
437 * This is assumed to be valid and the minimum size being mapped.
438 * @param pUdpHdr Pointer to the UDP header, in network endian (big).
439 * @param cbPktMax The max UDP packet size, UDP header and payload (data).
440 */
441DECLINLINE(bool) rtNetIPv4IsUDPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, size_t cbPktMax)
442{
443 /*
444 * Size validation.
445 */
446 size_t cb;
447 if (RT_UNLIKELY(cbPktMax < RTNETUDP_MIN_LEN))
448 return false;
449 cb = RT_BE2H_U16(pUdpHdr->uh_ulen);
450 if (RT_UNLIKELY(cb > cbPktMax))
451 return false;
452 if (RT_UNLIKELY(cb > (size_t)(RT_BE2H_U16(pIpHdr->ip_len) - pIpHdr->ip_hl * 4)))
453 return false;
454 return true;
455}
456
457
458/**
459 * Simple verification of an UDP packet size.
460 *
461 * @returns true if valid, false if invalid.
462 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
463 * This is assumed to be valid and the minimum size being mapped.
464 * @param pUdpHdr Pointer to the UDP header, in network endian (big).
465 * @param cbPktMax The max UDP packet size, UDP header and payload (data).
466 */
467RTDECL(bool) RTNetIPv4IsUDPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, size_t cbPktMax)
468{
469 return rtNetIPv4IsUDPSizeValid(pIpHdr, pUdpHdr, cbPktMax);
470}
471RT_EXPORT_SYMBOL(RTNetIPv4IsUDPSizeValid);
472
473
474/**
475 * Simple verification of an UDP packet (size + checksum).
476 *
477 * @returns true if valid, false if invalid.
478 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
479 * This is assumed to be valid and the minimum size being mapped.
480 * @param pUdpHdr Pointer to the UDP header, in network endian (big).
481 * @param pvData Pointer to the data, assuming it's one single segment
482 * and that cbPktMax - sizeof(RTNETUDP) is mapped here.
483 * @param cbPktMax The max UDP packet size, UDP header and payload (data).
484 * @param fChecksum Whether to validate the checksum (GSO).
485 */
486RTDECL(bool) RTNetIPv4IsUDPValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, void const *pvData, size_t cbPktMax, bool fChecksum)
487{
488 if (RT_UNLIKELY(!rtNetIPv4IsUDPSizeValid(pIpHdr, pUdpHdr, cbPktMax)))
489 return false;
490 if (fChecksum && pUdpHdr->uh_sum)
491 {
492 uint16_t u16Sum = RTNetIPv4UDPChecksum(pIpHdr, pUdpHdr, pvData);
493 if (RT_UNLIKELY(pUdpHdr->uh_sum != u16Sum))
494 return false;
495 }
496 return true;
497}
498RT_EXPORT_SYMBOL(RTNetIPv4IsUDPValid);
499
500
501/**
502 * Calculates the checksum for the TCP header given the IP header,
503 * TCP header and payload.
504 *
505 * @returns The checksum (network endian).
506 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
507 * @param pTcpHdr Pointer to the TCP header, in network endian (big).
508 * @param pvData Pointer to the TCP payload. The size is derived from
509 * the two headers and the caller is supposed to have
510 * validated this before calling. If NULL, we assume
511 * the data follows immediately after the TCP header.
512 */
513RTDECL(uint16_t) RTNetIPv4TCPChecksum(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, void const *pvData)
514{
515 bool fOdd;
516 size_t cbData;
517 uint32_t u32Sum = rtNetIPv4PseudoChecksum(pIpHdr);
518 u32Sum = rtNetIPv4AddTCPChecksum(pTcpHdr, u32Sum);
519 fOdd = false;
520 cbData = RT_BE2H_U16(pIpHdr->ip_len) - pIpHdr->ip_hl * 4 - pTcpHdr->th_off * 4;
521 u32Sum = rtNetIPv4AddDataChecksum(pvData ? pvData : (uint8_t const *)pTcpHdr + pTcpHdr->th_off * 4,
522 cbData, u32Sum, &fOdd);
523 return rtNetIPv4FinalizeChecksum(u32Sum);
524}
525RT_EXPORT_SYMBOL(RTNetIPv4TCPChecksum);
526
527
528/**
529 * Calculates the checksum for the TCP header given the TCP header, payload and
530 * the checksum of the pseudo header.
531 *
532 * This is not specific to IPv4.
533 *
534 * @returns The checksum (network endian).
535 * @param u32Sum The checksum of the pseudo header. See
536 * RTNetIPv4PseudoChecksum and RTNetIPv6PseudoChecksum.
537 * @param pTcpHdr Pointer to the TCP header, in network endian (big).
538 * @param pvData Pointer to the TCP payload.
539 * @param cbData The size of the TCP payload.
540 */
541RTDECL(uint16_t) RTNetTCPChecksum(uint32_t u32Sum, PCRTNETTCP pTcpHdr, void const *pvData, size_t cbData)
542{
543 bool fOdd;
544 u32Sum = rtNetIPv4AddTCPChecksum(pTcpHdr, u32Sum);
545 fOdd = false;
546 u32Sum = rtNetIPv4AddDataChecksum(pvData, cbData, u32Sum, &fOdd);
547 return rtNetIPv4FinalizeChecksum(u32Sum);
548}
549RT_EXPORT_SYMBOL(RTNetTCPChecksum);
550
551
552/**
553 * Verification of a TCP header.
554 *
555 * @returns true if valid, false if invalid.
556 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
557 * This is assumed to be valid and the minimum size being mapped.
558 * @param pTcpHdr Pointer to the TCP header, in network endian (big).
559 * @param cbHdrMax The max TCP header size (what pTcpHdr points to).
560 * @param cbPktMax The max TCP packet size, TCP header and payload (data).
561 */
562DECLINLINE(bool) rtNetIPv4IsTCPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, size_t cbHdrMax, size_t cbPktMax)
563{
564 size_t cbTcpHdr;
565 size_t cbTcp;
566
567 Assert(cbPktMax >= cbHdrMax);
568
569 /*
570 * Size validations.
571 */
572 if (RT_UNLIKELY(cbPktMax < RTNETTCP_MIN_LEN))
573 return false;
574 cbTcpHdr = pTcpHdr->th_off * 4;
575 if (RT_UNLIKELY(cbTcpHdr > cbHdrMax))
576 return false;
577 cbTcp = RT_BE2H_U16(pIpHdr->ip_len) - pIpHdr->ip_hl * 4;
578 if (RT_UNLIKELY(cbTcp > cbPktMax))
579 return false;
580 return true;
581}
582
583
584/**
585 * Simple verification of an TCP packet size.
586 *
587 * @returns true if valid, false if invalid.
588 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
589 * This is assumed to be valid and the minimum size being mapped.
590 * @param pTcpHdr Pointer to the TCP header, in network endian (big).
591 * @param cbHdrMax The max TCP header size (what pTcpHdr points to).
592 * @param cbPktMax The max TCP packet size, TCP header and payload (data).
593 */
594RTDECL(bool) RTNetIPv4IsTCPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, size_t cbHdrMax, size_t cbPktMax)
595{
596 return rtNetIPv4IsTCPSizeValid(pIpHdr, pTcpHdr, cbHdrMax, cbPktMax);
597}
598RT_EXPORT_SYMBOL(RTNetIPv4IsTCPSizeValid);
599
600
601/**
602 * Simple verification of an TCP packet (size + checksum).
603 *
604 * @returns true if valid, false if invalid.
605 * @param pIpHdr Pointer to the IPv4 header, in network endian (big).
606 * This is assumed to be valid and the minimum size being mapped.
607 * @param pTcpHdr Pointer to the TCP header, in network endian (big).
608 * @param cbHdrMax The max TCP header size (what pTcpHdr points to).
609 * @param pvData Pointer to the data, assuming it's one single segment
610 * and that cbPktMax - sizeof(RTNETTCP) is mapped here.
611 * If NULL then we assume the data follows immediately after
612 * the TCP header.
613 * @param cbPktMax The max TCP packet size, TCP header and payload (data).
614 * @param fChecksum Whether to validate the checksum (GSO).
615 */
616RTDECL(bool) RTNetIPv4IsTCPValid(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, size_t cbHdrMax, void const *pvData, size_t cbPktMax,
617 bool fChecksum)
618{
619 if (RT_UNLIKELY(!rtNetIPv4IsTCPSizeValid(pIpHdr, pTcpHdr, cbHdrMax, cbPktMax)))
620 return false;
621 if (fChecksum)
622 {
623 uint16_t u16Sum = RTNetIPv4TCPChecksum(pIpHdr, pTcpHdr, pvData);
624 if (RT_UNLIKELY(pTcpHdr->th_sum != u16Sum))
625 return false;
626 }
627 return true;
628}
629RT_EXPORT_SYMBOL(RTNetIPv4IsTCPValid);
630
631
632/**
633 * Minimal validation of a DHCP packet.
634 *
635 * This will fail on BOOTP packets (if sufficient data is supplied).
636 * It will not verify the source and destination ports, that's the
637 * caller's responsibility.
638 *
639 * This function will ASSUME that the hardware type is ethernet
640 * and use that for htype/hlen validation.
641 *
642 * @returns true if valid, false if invalid.
643 * @param pUdpHdr Pointer to the UDP header, in network endian (big).
644 * This is assumed to be valid and fully mapped.
645 * @param pDhcp Pointer to the DHCP packet.
646 * This might not be the entire thing, see cbDhcp.
647 * @param cbDhcp The number of valid bytes that pDhcp points to.
648 * @param pMsgType Where to store the message type (if found).
649 * This will be set to 0 if not found and on failure.
650 */
651RTDECL(bool) RTNetIPv4IsDHCPValid(PCRTNETUDP pUdpHdr, PCRTNETBOOTP pDhcp, size_t cbDhcp, uint8_t *pMsgType)
652{
653 ssize_t cbLeft;
654 uint8_t MsgType;
655 PCRTNETDHCPOPT pOpt;
656 NOREF(pUdpHdr); /** @todo rainy-day: Why isn't the UDP header used? */
657
658 AssertPtrNull(pMsgType);
659 if (pMsgType)
660 *pMsgType = 0;
661
662 /*
663 * Validate all the header fields we're able to...
664 */
665 if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_op) + sizeof(pDhcp->bp_op))
666 return true;
667 if (RT_UNLIKELY( pDhcp->bp_op != RTNETBOOTP_OP_REQUEST
668 && pDhcp->bp_op != RTNETBOOTP_OP_REPLY))
669 return false;
670
671 if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_htype) + sizeof(pDhcp->bp_htype))
672 return true;
673 if (RT_UNLIKELY(pDhcp->bp_htype != RTNET_ARP_ETHER))
674 return false;
675
676 if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_hlen) + sizeof(pDhcp->bp_hlen))
677 return true;
678 if (RT_UNLIKELY(pDhcp->bp_hlen != sizeof(RTMAC)))
679 return false;
680
681 if (cbDhcp < RT_UOFFSETOF(RTNETBOOTP, bp_flags) + sizeof(pDhcp->bp_flags))
682 return true;
683 if (RT_UNLIKELY(RT_BE2H_U16(pDhcp->bp_flags) & ~(RTNET_DHCP_FLAGS_NO_BROADCAST)))
684 return false;
685
686 /*
687 * Check the DHCP cookie and make sure it isn't followed by an END option
688 * (because that seems to be indicating that it's BOOTP and not DHCP).
689 */
690 cbLeft = (ssize_t)cbDhcp - RT_UOFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_cookie) + sizeof(pDhcp->bp_vend.Dhcp.dhcp_cookie);
691 if (cbLeft < 0)
692 return true;
693 if (RT_UNLIKELY(RT_BE2H_U32(pDhcp->bp_vend.Dhcp.dhcp_cookie) != RTNET_DHCP_COOKIE))
694 return false;
695 if (cbLeft < 1)
696 return true;
697 pOpt = (PCRTNETDHCPOPT)&pDhcp->bp_vend.Dhcp.dhcp_opts[0];
698 if (pOpt->dhcp_opt == RTNET_DHCP_OPT_END)
699 return false;
700
701 /*
702 * Scan the options until we find the message type or run out of message.
703 *
704 * We're not strict about termination (END) for many reasons, however,
705 * we don't accept END without MSG_TYPE.
706 */
707 MsgType = 0;
708 while (cbLeft > 0)
709 {
710 if (pOpt->dhcp_opt == RTNET_DHCP_OPT_END)
711 {
712 /* Fail if no MSG_TYPE. */
713 if (!MsgType)
714 return false;
715 break;
716 }
717 if (pOpt->dhcp_opt == RTNET_DHCP_OPT_PAD)
718 {
719 pOpt = (PCRTNETDHCPOPT)((uint8_t const *)pOpt + 1);
720 cbLeft--;
721 }
722 else
723 {
724 switch (pOpt->dhcp_opt)
725 {
726 case RTNET_DHCP_OPT_MSG_TYPE:
727 {
728 if (cbLeft < 3)
729 return true;
730 MsgType = *(const uint8_t *)(pOpt + 1);
731 switch (MsgType)
732 {
733 case RTNET_DHCP_MT_DISCOVER:
734 case RTNET_DHCP_MT_OFFER:
735 case RTNET_DHCP_MT_REQUEST:
736 case RTNET_DHCP_MT_DECLINE:
737 case RTNET_DHCP_MT_ACK:
738 case RTNET_DHCP_MT_NAC:
739 case RTNET_DHCP_MT_RELEASE:
740 case RTNET_DHCP_MT_INFORM:
741 break;
742
743 default:
744 /* we don't know this message type, fail. */
745 return false;
746 }
747
748 /* Found a known message type, consider the job done. */
749 if (pMsgType)
750 *pMsgType = MsgType;
751 return true;
752 }
753 }
754
755 /* Skip the option. */
756 cbLeft -= pOpt->dhcp_len + sizeof(*pOpt);
757 pOpt = (PCRTNETDHCPOPT)((uint8_t const *)pOpt + pOpt->dhcp_len + sizeof(*pOpt));
758 }
759 }
760
761 return true;
762}
763RT_EXPORT_SYMBOL(RTNetIPv4IsDHCPValid);
764
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette