ipv4.cpp@ 57444

Last change on this file since 57444 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
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 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* IPRT - IPv4 Checksum calculation and validation.
4	*/
5
6	/*
7	* Copyright (C) 2008-2015 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	*/
45	RTDECL(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	}
84	RT_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	*/
99	RTDECL(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	}
130	RT_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	*/
139	DECLINLINE(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	*/
162	RTDECL(uint32_t) RTNetIPv4PseudoChecksum(PCRTNETIPV4 pIpHdr)
163	{
164	return rtNetIPv4PseudoChecksum(pIpHdr);
165	}
166	RT_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	*/
178	RTDECL(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	}
192	RT_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	*/
202	DECLINLINE(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	*/
219	RTDECL(uint32_t) RTNetIPv4AddUDPChecksum(PCRTNETUDP pUdpHdr, uint32_t u32Sum)
220	{
221	return rtNetIPv4AddUDPChecksum(pUdpHdr, u32Sum);
222	}
223	RT_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	*/
235	DECLINLINE(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	*/
281	RTDECL(uint32_t) RTNetIPv4AddTCPChecksum(PCRTNETTCP pTcpHdr, uint32_t u32Sum)
282	{
283	return rtNetIPv4AddTCPChecksum(pTcpHdr, u32Sum);
284	}
285	RT_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	*/
299	DECLINLINE(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	*/
352	RTDECL(uint32_t) RTNetIPv4AddDataChecksum(void const pvData, size_t cbData, uint32_t u32Sum, bool pfOdd)
353	{
354	return rtNetIPv4AddDataChecksum(pvData, cbData, u32Sum, pfOdd);
355	}
356	RT_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	*/
365	DECLINLINE(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	*/
380	RTDECL(uint16_t) RTNetIPv4FinalizeChecksum(uint32_t u32Sum)
381	{
382	return rtNetIPv4FinalizeChecksum(u32Sum);
383	}
384	RT_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	*/
398	RTDECL(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	}
406	RT_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	*/
420	RTDECL(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	}
429	RT_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	*/
441	DECLINLINE(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	*/
467	RTDECL(bool) RTNetIPv4IsUDPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETUDP pUdpHdr, size_t cbPktMax)
468	{
469	return rtNetIPv4IsUDPSizeValid(pIpHdr, pUdpHdr, cbPktMax);
470	}
471	RT_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	*/
486	RTDECL(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	}
498	RT_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	*/
513	RTDECL(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	}
525	RT_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	*/
541	RTDECL(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	}
549	RT_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	*/
562	DECLINLINE(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	*/
594	RTDECL(bool) RTNetIPv4IsTCPSizeValid(PCRTNETIPV4 pIpHdr, PCRTNETTCP pTcpHdr, size_t cbHdrMax, size_t cbPktMax)
595	{
596	return rtNetIPv4IsTCPSizeValid(pIpHdr, pTcpHdr, cbHdrMax, cbPktMax);
597	}
598	RT_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	*/
616	RTDECL(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	}
629	RT_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	*/
651	RTDECL(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_OFFSETOF(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_OFFSETOF(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_OFFSETOF(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_OFFSETOF(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_OFFSETOF(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	}
763	RT_EXPORT_SYMBOL(RTNetIPv4IsDHCPValid);
764

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

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

Download in other formats: