ipv4.cpp@ 28587

Last change on this file since 28587 was 28024, checked in by vboxsync, 15 years ago
iprt: ipv6 header and pseudo checksumming; tcp flags; tcp/udp checksumming additions.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 29.5 KB

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

Note: See TracBrowser for help on using the repository browser.

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

Download in other formats: