1 // SoftEther VPN Source Code - Stable Edition Repository
2 // Cedar Communication Module
3 //
4 // SoftEther VPN Server, Client and Bridge are free software under the Apache License, Version 2.0.
5 //
6 // Copyright (c) Daiyuu Nobori.
7 // Copyright (c) SoftEther VPN Project, University of Tsukuba, Japan.
8 // Copyright (c) SoftEther Corporation.
9 // Copyright (c) all contributors on SoftEther VPN project in GitHub.
10 //
11 // All Rights Reserved.
12 //
13 // http://www.softether.org/
14 //
15 // This stable branch is officially managed by Daiyuu Nobori, the owner of SoftEther VPN Project.
16 // Pull requests should be sent to the Developer Edition Master Repository on https://github.com/SoftEtherVPN/SoftEtherVPN
17 //
18 // License: The Apache License, Version 2.0
19 // https://www.apache.org/licenses/LICENSE-2.0
20 //
21 // DISCLAIMER
22 // ==========
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 // SOFTWARE.
31 //
32 // THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN, UNDER
33 // JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY, MERGE, PUBLISH,
34 // DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS SOFTWARE, THAT ANY
35 // JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS SOFTWARE OR ITS CONTENTS,
36 // AGAINST US (SOFTETHER PROJECT, SOFTETHER CORPORATION, DAIYUU NOBORI OR OTHER
37 // SUPPLIERS), OR ANY JURIDICAL DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND
38 // OF USING, COPYING, MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING,
39 // AND/OR SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
40 // CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO EXCLUSIVE
41 // JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO, JAPAN. YOU MUST WAIVE
42 // ALL DEFENSES OF LACK OF PERSONAL JURISDICTION AND FORUM NON CONVENIENS.
43 // PROCESS MAY BE SERVED ON EITHER PARTY IN THE MANNER AUTHORIZED BY APPLICABLE
44 // LAW OR COURT RULE.
45 //
46 // USE ONLY IN JAPAN. DO NOT USE THIS SOFTWARE IN ANOTHER COUNTRY UNLESS YOU HAVE
47 // A CONFIRMATION THAT THIS SOFTWARE DOES NOT VIOLATE ANY CRIMINAL LAWS OR CIVIL
48 // RIGHTS IN THAT PARTICULAR COUNTRY. USING THIS SOFTWARE IN OTHER COUNTRIES IS
49 // COMPLETELY AT YOUR OWN RISK. THE SOFTETHER VPN PROJECT HAS DEVELOPED AND
50 // DISTRIBUTED THIS SOFTWARE TO COMPLY ONLY WITH THE JAPANESE LAWS AND EXISTING
51 // CIVIL RIGHTS INCLUDING PATENTS WHICH ARE SUBJECTS APPLY IN JAPAN. OTHER
52 // COUNTRIES' LAWS OR CIVIL RIGHTS ARE NONE OF OUR CONCERNS NOR RESPONSIBILITIES.
53 // WE HAVE NEVER INVESTIGATED ANY CRIMINAL REGULATIONS, CIVIL LAWS OR
54 // INTELLECTUAL PROPERTY RIGHTS INCLUDING PATENTS IN ANY OF OTHER 200+ COUNTRIES
55 // AND TERRITORIES. BY NATURE, THERE ARE 200+ REGIONS IN THE WORLD, WITH
56 // DIFFERENT LAWS. IT IS IMPOSSIBLE TO VERIFY EVERY COUNTRIES' LAWS, REGULATIONS
57 // AND CIVIL RIGHTS TO MAKE THE SOFTWARE COMPLY WITH ALL COUNTRIES' LAWS BY THE
58 // PROJECT. EVEN IF YOU WILL BE SUED BY A PRIVATE ENTITY OR BE DAMAGED BY A
59 // PUBLIC SERVANT IN YOUR COUNTRY, THE DEVELOPERS OF THIS SOFTWARE WILL NEVER BE
60 // LIABLE TO RECOVER OR COMPENSATE SUCH DAMAGES, CRIMINAL OR CIVIL
61 // RESPONSIBILITIES. NOTE THAT THIS LINE IS NOT LICENSE RESTRICTION BUT JUST A
62 // STATEMENT FOR WARNING AND DISCLAIMER.
63 //
64 // READ AND UNDERSTAND THE 'WARNING.TXT' FILE BEFORE USING THIS SOFTWARE.
65 // SOME SOFTWARE PROGRAMS FROM THIRD PARTIES ARE INCLUDED ON THIS SOFTWARE WITH
66 // LICENSE CONDITIONS WHICH ARE DESCRIBED ON THE 'THIRD_PARTY.TXT' FILE.
67 //
68 //
69 // SOURCE CODE CONTRIBUTION
70 // ------------------------
71 //
72 // Your contribution to SoftEther VPN Project is much appreciated.
73 // Please send patches to us through GitHub.
74 // Read the SoftEther VPN Patch Acceptance Policy in advance:
75 // http://www.softether.org/5-download/src/9.patch
76 //
77 //
78 // DEAR SECURITY EXPERTS
79 // ---------------------
80 //
81 // If you find a bug or a security vulnerability please kindly inform us
82 // about the problem immediately so that we can fix the security problem
83 // to protect a lot of users around the world as soon as possible.
84 //
85 // Our e-mail address for security reports is:
86 // softether-vpn-security [at] softether.org
87 //
88 // Please note that the above e-mail address is not a technical support
89 // inquiry address. If you need technical assistance, please visit
90 // http://www.softether.org/ and ask your question on the users forum.
91 //
92 // Thank you for your cooperation.
93 //
94 //
95 // NO MEMORY OR RESOURCE LEAKS
96 // ---------------------------
97 //
98 // The memory-leaks and resource-leaks verification under the stress
99 // test has been passed before release this source code.
100
101
102 // IPsec_IkePacket.c
103 // IKE (ISAKMP) packet processing
104
105 #include "CedarPch.h"
106
107 // Convert the string to a password
IkeStrToPassword(char * str)108 BUF *IkeStrToPassword(char *str)
109 {
110 BUF *b;
111 // Validate arguments
112 if (str == NULL)
113 {
114 return NewBuf();
115 }
116
117 if (StartWith(str, "0x") == false)
118 {
119 // Accept the string as is
120 b = NewBuf();
121 WriteBuf(b, str, StrLen(str));
122 }
123 else
124 {
125 // Interpret as a hexadecimal value
126 b = StrToBin(str + 2);
127 }
128
129 return b;
130 }
131
132 // Phase 1: Convert the encryption algorithm name to key size
IkePhase1CryptIdToKeySize(UCHAR id)133 UINT IkePhase1CryptIdToKeySize(UCHAR id)
134 {
135 switch (id)
136 {
137 case IKE_P1_CRYPTO_3DES_CBC:
138 return DES3_KEY_SIZE;
139
140 case IKE_P1_CRYPTO_DES_CBC:
141 return DES_KEY_SIZE;
142 }
143
144 return 0;
145 }
146
147 // Phase 2: Convert the encryption algorithm name to key size
IkePhase2CryptIdToKeySize(UCHAR id)148 UINT IkePhase2CryptIdToKeySize(UCHAR id)
149 {
150 switch (id)
151 {
152 case IKE_TRANSFORM_ID_P2_ESP_3DES:
153 return DES3_KEY_SIZE;
154
155 case IKE_TRANSFORM_ID_P2_ESP_DES:
156 return DES_KEY_SIZE;
157 }
158
159 return 0;
160 }
161
162 // Convert a string to an algorithm name
IkeStrToPhase1CryptId(char * name)163 UCHAR IkeStrToPhase1CryptId(char *name)
164 {
165 if (StartWith(name, "3DES") || StartWith("3DES", name))
166 {
167 return IKE_P1_CRYPTO_3DES_CBC;
168 }
169 else if (StartWith(name, "DES") || StartWith("DES", name))
170 {
171 return IKE_P1_CRYPTO_DES_CBC;
172 }
173 else
174 {
175 return 0;
176 }
177 }
IkeStrToPhase1HashId(char * name)178 UCHAR IkeStrToPhase1HashId(char *name)
179 {
180 if (StartWith(name, "SHA-1") || StartWith("SHA-1", name))
181 {
182 return IKE_P1_HASH_SHA1;
183 }
184
185 return 0;
186 }
IkeStrToPhase2CryptId(char * name)187 UCHAR IkeStrToPhase2CryptId(char *name)
188 {
189 if (StartWith(name, "3DES") || StartWith("3DES", name))
190 {
191 return IKE_TRANSFORM_ID_P2_ESP_3DES;
192 }
193 else if (StartWith(name, "DES") || StartWith("DES", name))
194 {
195 return IKE_TRANSFORM_ID_P2_ESP_DES;
196 }
197 else
198 {
199 return 0;
200 }
201 }
IkeStrToPhase2HashId(char * name)202 UCHAR IkeStrToPhase2HashId(char *name)
203 {
204 if (StartWith(name, "SHA-1") || StartWith("SHA-1", name))
205 {
206 return IKE_P2_HMAC_SHA1_96;
207 }
208
209 return 0;
210 }
211
212 // Build a data payload
IkeBuildDataPayload(IKE_PACKET_DATA_PAYLOAD * t)213 BUF *IkeBuildDataPayload(IKE_PACKET_DATA_PAYLOAD *t)
214 {
215 BUF *b;
216 // Validate arguments
217 if (t == NULL)
218 {
219 return NULL;
220 }
221
222 b = NewBuf();
223 WriteBuf(b, t->Data->Buf, t->Data->Size);
224
225 return b;
226 }
227
228 // Build a SA payload
IkeBuildSaPayload(IKE_PACKET_SA_PAYLOAD * t)229 BUF *IkeBuildSaPayload(IKE_PACKET_SA_PAYLOAD *t)
230 {
231 IKE_SA_HEADER h;
232 BUF *ret;
233 BUF *b;
234 // Validate arguments
235 if (t == NULL)
236 {
237 return NULL;
238 }
239
240 Zero(&h, sizeof(h));
241 h.DoI = Endian32(IKE_SA_DOI_IPSEC);
242 h.Situation = Endian32(IKE_SA_SITUATION_IDENTITY);
243
244 ret = NewBuf();
245
246 WriteBuf(ret, &h, sizeof(h));
247
248 b = IkeBuildPayloadList(t->PayloadList);
249 WriteBufBuf(ret, b);
250
251 FreeBuf(b);
252
253 return ret;
254 }
255
256 // Build a proposal payload
IkeBuildProposalPayload(IKE_PACKET_PROPOSAL_PAYLOAD * t)257 BUF *IkeBuildProposalPayload(IKE_PACKET_PROPOSAL_PAYLOAD *t)
258 {
259 IKE_PROPOSAL_HEADER h;
260 BUF *ret, *b;
261 // Validate arguments
262 if (t == NULL)
263 {
264 return NULL;
265 }
266
267 Zero(&h, sizeof(h));
268 h.Number = t->Number;
269 h.NumTransforms = LIST_NUM(t->PayloadList);
270 h.ProtocolId = t->ProtocolId;
271 h.SpiSize = t->Spi->Size;
272
273 ret = NewBuf();
274 WriteBuf(ret, &h, sizeof(h));
275 WriteBufBuf(ret, t->Spi);
276
277 b = IkeBuildPayloadList(t->PayloadList);
278 WriteBufBuf(ret, b);
279
280 FreeBuf(b);
281
282 return ret;
283 }
284
285 // Build the transform value list
IkeBuildTransformValueList(LIST * o)286 BUF *IkeBuildTransformValueList(LIST *o)
287 {
288 BUF *b;
289 UINT i;
290 // Validate arguments
291 if (o == NULL)
292 {
293 return NULL;
294 }
295
296 b = NewBuf();
297
298 for (i = 0;i < LIST_NUM(o);i++)
299 {
300 IKE_PACKET_TRANSFORM_VALUE *v = LIST_DATA(o, i);
301 BUF *tmp = IkeBuildTransformValue(v);
302
303 WriteBufBuf(b, tmp);
304
305 FreeBuf(tmp);
306 }
307
308 return b;
309 }
310
311 // Build a transform value
IkeBuildTransformValue(IKE_PACKET_TRANSFORM_VALUE * v)312 BUF *IkeBuildTransformValue(IKE_PACKET_TRANSFORM_VALUE *v)
313 {
314 BUF *b;
315 UCHAR af_bit, type;
316 USHORT size_or_value;
317 // Validate arguments
318 if (v == NULL)
319 {
320 return NULL;
321 }
322
323 type = v->Type;
324
325 if (v->Value >= 65536)
326 {
327 // 32 bit
328 af_bit = 0;
329 size_or_value = Endian16(sizeof(UINT));
330 }
331 else
332 {
333 // 16 bit
334 af_bit = 0x80;
335 size_or_value = Endian16((USHORT)v->Value);
336 }
337
338 b = NewBuf();
339 WriteBuf(b, &af_bit, sizeof(af_bit));
340 WriteBuf(b, &type, sizeof(type));
341 WriteBuf(b, &size_or_value, sizeof(size_or_value));
342
343 if (af_bit == 0)
344 {
345 UINT value = Endian32(v->Value);
346 WriteBuf(b, &value, sizeof(UINT));
347 }
348
349 return b;
350 }
351
352 // Build a transform payload
IkeBuildTransformPayload(IKE_PACKET_TRANSFORM_PAYLOAD * t)353 BUF *IkeBuildTransformPayload(IKE_PACKET_TRANSFORM_PAYLOAD *t)
354 {
355 IKE_TRANSFORM_HEADER h;
356 BUF *ret, *b;
357 // Validate arguments
358 if (t == NULL)
359 {
360 return NULL;
361 }
362
363 Zero(&h, sizeof(h));
364 h.Number = t->Number;
365 h.TransformId = t->TransformId;
366
367 ret = NewBuf();
368 WriteBuf(ret, &h, sizeof(h));
369
370 b = IkeBuildTransformValueList(t->ValueList);
371 WriteBufBuf(ret, b);
372
373 FreeBuf(b);
374
375 return ret;
376 }
377
378 // Get the value from the transform payload
IkeGetTransformValue(IKE_PACKET_TRANSFORM_PAYLOAD * t,UINT type,UINT index)379 UINT IkeGetTransformValue(IKE_PACKET_TRANSFORM_PAYLOAD *t, UINT type, UINT index)
380 {
381 UINT i;
382 UINT num;
383 // Validate arguments
384 if (t == NULL)
385 {
386 return 0;
387 }
388
389 num = 0;
390
391 for (i = 0;i < LIST_NUM(t->ValueList);i++)
392 {
393 IKE_PACKET_TRANSFORM_VALUE *v = LIST_DATA(t->ValueList, i);
394
395 if (v->Type == type)
396 {
397 if (num == index)
398 {
399 return v->Value;
400 }
401
402 num++;
403 }
404 }
405
406 return 0;
407 }
408
409 // Get the number of values from the transform payload
IkeGetTransformValueNum(IKE_PACKET_TRANSFORM_PAYLOAD * t,UINT type)410 UINT IkeGetTransformValueNum(IKE_PACKET_TRANSFORM_PAYLOAD *t, UINT type)
411 {
412 UINT i;
413 UINT num;
414 // Validate arguments
415 if (t == NULL)
416 {
417 return 0;
418 }
419
420 num = 0;
421
422 for (i = 0;i < LIST_NUM(t->ValueList);i++)
423 {
424 IKE_PACKET_TRANSFORM_VALUE *v = LIST_DATA(t->ValueList, i);
425
426 if (v->Type == type)
427 {
428 num++;
429 }
430 }
431
432 return num;
433 }
434
435 // Build the ID payload
IkeBuildIdPayload(IKE_PACKET_ID_PAYLOAD * t)436 BUF *IkeBuildIdPayload(IKE_PACKET_ID_PAYLOAD *t)
437 {
438 IKE_ID_HEADER h;
439 BUF *ret;
440 // Validate arguments
441 if (t == NULL)
442 {
443 return NULL;
444 }
445
446 Zero(&h, sizeof(h));
447 h.IdType = t->Type;
448 h.Port = Endian16(t->Port);
449 h.ProtocolId = t->ProtocolId;
450
451 ret = NewBuf();
452 WriteBuf(ret, &h, sizeof(h));
453
454 WriteBufBuf(ret, t->IdData);
455
456 return ret;
457 }
458
459 // Build a certificate payload
IkeBuildCertPayload(IKE_PACKET_CERT_PAYLOAD * t)460 BUF *IkeBuildCertPayload(IKE_PACKET_CERT_PAYLOAD *t)
461 {
462 IKE_CERT_HEADER h;
463 BUF *ret;
464 // Validate arguments
465 if (t == NULL)
466 {
467 return NULL;
468 }
469
470 Zero(&h, sizeof(h));
471 h.CertType = t->CertType;
472
473 ret = NewBuf();
474 WriteBuf(ret, &h, sizeof(h));
475 WriteBufBuf(ret, t->CertData);
476
477 return ret;
478 }
479
480 // Build a certificate request payload
IkeBuildCertRequestPayload(IKE_PACKET_CERT_REQUEST_PAYLOAD * t)481 BUF *IkeBuildCertRequestPayload(IKE_PACKET_CERT_REQUEST_PAYLOAD *t)
482 {
483 IKE_CERT_REQUEST_HEADER h;
484 BUF *ret;
485 // Validate arguments
486 if (t == NULL)
487 {
488 return NULL;
489 }
490
491 Zero(&h, sizeof(h));
492 h.CertType = t->CertType;
493
494 ret = NewBuf();
495 WriteBuf(ret, &h, sizeof(h));
496 WriteBufBuf(ret, t->Data);
497
498 return ret;
499 }
500
501 // Build a notification payload
IkeBuildNoticePayload(IKE_PACKET_NOTICE_PAYLOAD * t)502 BUF *IkeBuildNoticePayload(IKE_PACKET_NOTICE_PAYLOAD *t)
503 {
504 IKE_NOTICE_HEADER h;
505 BUF *ret;
506 // Validate arguments
507 if (t == NULL)
508 {
509 return NULL;
510 }
511
512 Zero(&h, sizeof(h));
513 h.DoI = Endian32(IKE_SA_DOI_IPSEC);
514 h.MessageType = Endian16(t->MessageType);
515 h.ProtocolId = t->ProtocolId;
516 h.SpiSize = t->Spi->Size;
517
518 ret = NewBuf();
519 WriteBuf(ret, &h, sizeof(h));
520 WriteBuf(ret, t->Spi->Buf, t->Spi->Size);
521
522 if (t->MessageData != NULL)
523 {
524 WriteBuf(ret, t->MessageData->Buf, t->MessageData->Size);
525 }
526
527 return ret;
528 }
529
530 // Build a NAT-OA payload
IkeBuildNatOaPayload(IKE_PACKET_NAT_OA_PAYLOAD * t)531 BUF *IkeBuildNatOaPayload(IKE_PACKET_NAT_OA_PAYLOAD *t)
532 {
533 IKE_NAT_OA_HEADER h;
534 BUF *ret;
535 // Validate arguments
536 if (t == NULL)
537 {
538 return NULL;
539 }
540
541 Zero(&h, sizeof(h));
542
543 if (IsIP6(&t->IpAddress))
544 {
545 h.IdType = IKE_ID_IPV6_ADDR;
546 }
547 else
548 {
549 h.IdType = IKE_ID_IPV4_ADDR;
550 }
551
552 ret = NewBuf();
553
554 WriteBuf(ret, &h, sizeof(h));
555
556 if (IsIP6(&t->IpAddress))
557 {
558 WriteBuf(ret, t->IpAddress.ipv6_addr, 16);
559 }
560 else
561 {
562 WriteBuf(ret, t->IpAddress.addr, 4);
563 }
564
565 return ret;
566 }
567
568 // Build a deletion payload
IkeBuildDeletePayload(IKE_PACKET_DELETE_PAYLOAD * t)569 BUF *IkeBuildDeletePayload(IKE_PACKET_DELETE_PAYLOAD *t)
570 {
571 IKE_DELETE_HEADER h;
572 BUF *ret;
573 UINT i;
574 // Validate arguments
575 if (t == NULL)
576 {
577 return NULL;
578 }
579
580 Zero(&h, sizeof(h));
581 h.DoI = Endian32(IKE_SA_DOI_IPSEC);
582 h.NumSpis = Endian16(LIST_NUM(t->SpiList));
583 h.ProtocolId = t->ProtocolId;
584
585 if (LIST_NUM(t->SpiList) >= 1)
586 {
587 BUF *b = LIST_DATA(t->SpiList, 0);
588
589 h.SpiSize = b->Size;
590 }
591
592 ret = NewBuf();
593 WriteBuf(ret, &h, sizeof(h));
594
595 for (i = 0;i < LIST_NUM(t->SpiList);i++)
596 {
597 BUF *b = LIST_DATA(t->SpiList, i);
598
599 WriteBuf(ret, b->Buf, b->Size);
600 }
601
602 return ret;
603 }
604
605 // Build a bit array from the payload
IkeBuildPayload(IKE_PACKET_PAYLOAD * p)606 BUF *IkeBuildPayload(IKE_PACKET_PAYLOAD *p)
607 {
608 BUF *b = NULL;
609 // Validate arguments
610 if (p == NULL)
611 {
612 return NULL;
613 }
614
615 switch (p->PayloadType)
616 {
617 case IKE_PAYLOAD_SA: // SA payload
618 b = IkeBuildSaPayload(&p->Payload.Sa);
619 break;
620
621 case IKE_PAYLOAD_PROPOSAL: // Proposal payload
622 b = IkeBuildProposalPayload(&p->Payload.Proposal);
623 break;
624
625 case IKE_PAYLOAD_TRANSFORM: // Transform payload
626 b = IkeBuildTransformPayload(&p->Payload.Transform);
627 break;
628
629 case IKE_PAYLOAD_ID: // ID payload
630 b = IkeBuildIdPayload(&p->Payload.Id);
631 break;
632
633 case IKE_PAYLOAD_CERT: // Certificate payload
634 b = IkeBuildCertPayload(&p->Payload.Cert);
635 break;
636
637 case IKE_PAYLOAD_CERT_REQUEST: // Certificate request payload
638 b = IkeBuildCertRequestPayload(&p->Payload.CertRequest);
639 break;
640
641 case IKE_PAYLOAD_NOTICE: // Notification Payload
642 b = IkeBuildNoticePayload(&p->Payload.Notice);
643 break;
644
645 case IKE_PAYLOAD_DELETE: // Deletion payload
646 b = IkeBuildDeletePayload(&p->Payload.Delete);
647 break;
648
649 case IKE_PAYLOAD_NAT_OA: // NAT-OA payload
650 case IKE_PAYLOAD_NAT_OA_DRAFT:
651 case IKE_PAYLOAD_NAT_OA_DRAFT_2:
652 b = IkeBuildNatOaPayload(&p->Payload.NatOa);
653 break;
654
655 case IKE_PAYLOAD_KEY_EXCHANGE: // Key exchange payload
656 case IKE_PAYLOAD_HASH: // Hash payload
657 case IKE_PAYLOAD_SIGN: // Signature payload
658 case IKE_PAYLOAD_RAND: // Random number payload
659 case IKE_PAYLOAD_VENDOR_ID: // Vendor ID payload
660 case IKE_PAYLOAD_NAT_D: // NAT-D payload
661 case IKE_PAYLOAD_NAT_D_DRAFT: // NAT-D payload (draft)
662 default:
663 b = IkeBuildDataPayload(&p->Payload.GeneralData);
664 break;
665 }
666
667 if (b != NULL)
668 {
669 if (p->BitArray != NULL)
670 {
671 FreeBuf(p->BitArray);
672 }
673 p->BitArray = CloneBuf(b);
674 }
675
676 return b;
677 }
678
679 // Get the payload type of the first item
IkeGetFirstPayloadType(LIST * o)680 UCHAR IkeGetFirstPayloadType(LIST *o)
681 {
682 IKE_PACKET_PAYLOAD *p;
683 // Validate arguments
684 if (o == NULL)
685 {
686 return IKE_PAYLOAD_NONE;
687 }
688
689 if (LIST_NUM(o) == 0)
690 {
691 return IKE_PAYLOAD_NONE;
692 }
693
694 p = (IKE_PACKET_PAYLOAD *)LIST_DATA(o, 0);
695
696 return p->PayloadType;
697 }
698
699 // Build a bit array from the payload list
IkeBuildPayloadList(LIST * o)700 BUF *IkeBuildPayloadList(LIST *o)
701 {
702 BUF *b;
703 UINT i;
704 // Validate arguments
705 if (o == NULL)
706 {
707 return NULL;
708 }
709
710 b = NewBuf();
711
712 for (i = 0;i < LIST_NUM(o);i++)
713 {
714 IKE_PACKET_PAYLOAD *p = LIST_DATA(o, i);
715 IKE_PACKET_PAYLOAD *next = NULL;
716 IKE_COMMON_HEADER h;
717 BUF *tmp;
718
719 if (i < (LIST_NUM(o) - 1))
720 {
721 next = LIST_DATA(o, i + 1);
722 }
723
724 Zero(&h, sizeof(h));
725 if (next != NULL)
726 {
727 h.NextPayload = next->PayloadType;
728 }
729 else
730 {
731 h.NextPayload = IKE_PAYLOAD_NONE;
732 }
733
734 tmp = IkeBuildPayload(p);
735 if (tmp != NULL)
736 {
737 h.PayloadSize = Endian16(tmp->Size + (USHORT)sizeof(h));
738
739 WriteBuf(b, &h, sizeof(h));
740 WriteBuf(b, tmp->Buf, tmp->Size);
741
742 FreeBuf(tmp);
743 }
744 }
745
746 SeekBuf(b, 0, 0);
747
748 return b;
749 }
750
751 // Get the specified payload
IkeGetPayload(LIST * o,UINT payload_type,UINT index)752 IKE_PACKET_PAYLOAD *IkeGetPayload(LIST *o, UINT payload_type, UINT index)
753 {
754 UINT i, num;
755 IKE_PACKET_PAYLOAD *ret = NULL;
756 // Validate arguments
757 if (o == NULL)
758 {
759 return 0;
760 }
761
762 num = 0;
763
764 for (i = 0;i < LIST_NUM(o);i++)
765 {
766 IKE_PACKET_PAYLOAD *p = LIST_DATA(o, i);
767
768 if (p->PayloadType == payload_type)
769 {
770 if (num == index)
771 {
772 ret = p;
773 break;
774 }
775
776 num++;
777 }
778 }
779
780 return ret;
781 }
782
783 // Get the number of the payload of the specified type
IkeGetPayloadNum(LIST * o,UINT payload_type)784 UINT IkeGetPayloadNum(LIST *o, UINT payload_type)
785 {
786 UINT i, num;
787 // Validate arguments
788 if (o == NULL)
789 {
790 return 0;
791 }
792
793 num = 0;
794
795 for (i = 0;i < LIST_NUM(o);i++)
796 {
797 IKE_PACKET_PAYLOAD *p = LIST_DATA(o, i);
798
799 if (p->PayloadType == payload_type)
800 {
801 num++;
802 }
803 }
804
805 return num;
806 }
807
808 // Create a deletion payload
IkeNewDeletePayload(UCHAR protocol_id,LIST * spi_list)809 IKE_PACKET_PAYLOAD *IkeNewDeletePayload(UCHAR protocol_id, LIST *spi_list)
810 {
811 IKE_PACKET_PAYLOAD *p;
812 if (spi_list == NULL)
813 {
814 return NULL;
815 }
816
817 p = IkeNewPayload(IKE_PAYLOAD_DELETE);
818 p->Payload.Delete.ProtocolId = protocol_id;
819 p->Payload.Delete.SpiList = spi_list;
820
821 return p;
822 }
823
824 // Create a Notification payload
IkeNewNoticePayload(UCHAR protocol_id,USHORT message_type,void * spi,UINT spi_size,void * message,UINT message_size)825 IKE_PACKET_PAYLOAD *IkeNewNoticePayload(UCHAR protocol_id, USHORT message_type,
826 void *spi, UINT spi_size,
827 void *message, UINT message_size)
828 {
829 IKE_PACKET_PAYLOAD *p;
830 if (spi == NULL && spi_size != 0)
831 {
832 return NULL;
833 }
834 if (message == NULL && message_size != 0)
835 {
836 return NULL;
837 }
838
839 p = IkeNewPayload(IKE_PAYLOAD_NOTICE);
840 p->Payload.Notice.MessageType = message_type;
841 p->Payload.Notice.MessageData = MemToBuf(message, message_size);
842 p->Payload.Notice.Spi = MemToBuf(spi, spi_size);
843 p->Payload.Notice.ProtocolId = protocol_id;
844
845 return p;
846 }
847
848 // Create a Invalid Cookie Payload
IkeNewNoticeErrorInvalidCookiePayload(UINT64 init_cookie,UINT64 resp_cookie)849 IKE_PACKET_PAYLOAD *IkeNewNoticeErrorInvalidCookiePayload(UINT64 init_cookie, UINT64 resp_cookie)
850 {
851 IKE_PACKET_PAYLOAD *ret;
852 BUF *b = NewBuf();
853
854 WriteBufInt64(b, init_cookie);
855 WriteBufInt64(b, resp_cookie);
856
857 ret = IkeNewNoticePayload(IKE_PROTOCOL_ID_IKE, IKE_NOTICE_ERROR_INVALID_COOKIE, b->Buf, b->Size,
858 b->Buf, b->Size);
859
860 FreeBuf(b);
861
862 return ret;
863 }
864
865 // Create an Invalid Exchange Type Payload
IkeNewNoticeErrorInvalidExchangeTypePayload(UINT64 init_cookie,UINT64 resp_cookie,UCHAR exchange_type)866 IKE_PACKET_PAYLOAD *IkeNewNoticeErrorInvalidExchangeTypePayload(UINT64 init_cookie, UINT64 resp_cookie, UCHAR exchange_type)
867 {
868 IKE_PACKET_PAYLOAD *ret;
869 BUF *b = NewBuf();
870
871 WriteBufInt64(b, init_cookie);
872 WriteBufInt64(b, resp_cookie);
873
874 ret = IkeNewNoticePayload(IKE_PROTOCOL_ID_IKE, IKE_NOTICE_ERROR_INVALID_EXCHANGE_TYPE, b->Buf, b->Size,
875 &exchange_type, 1);
876
877 FreeBuf(b);
878
879 return ret;
880 }
881
882 // Create an Invalid SPI payload
IkeNewNoticeErrorInvalidSpiPayload(UINT spi)883 IKE_PACKET_PAYLOAD *IkeNewNoticeErrorInvalidSpiPayload(UINT spi)
884 {
885 IKE_PACKET_PAYLOAD *ret;
886 spi = Endian32(spi);
887
888 ret = IkeNewNoticePayload(IKE_PROTOCOL_ID_IPSEC_ESP, IKE_NOTICE_ERROR_INVALID_SPI, &spi, sizeof(UINT),
889 &spi, sizeof(UINT));
890
891 return ret;
892 }
893
894 // Create a No Proposal Chosen payload
IkeNewNoticeErrorNoProposalChosenPayload(bool quick_mode,UINT64 init_cookie,UINT64 resp_cookie)895 IKE_PACKET_PAYLOAD *IkeNewNoticeErrorNoProposalChosenPayload(bool quick_mode, UINT64 init_cookie, UINT64 resp_cookie)
896 {
897 BUF *b = NewBuf();
898 IKE_PACKET_PAYLOAD *ret;
899
900 WriteBufInt64(b, init_cookie);
901 WriteBufInt64(b, resp_cookie);
902
903 ret = IkeNewNoticePayload((quick_mode ? IKE_PROTOCOL_ID_IPSEC_ESP : IKE_PROTOCOL_ID_IKE),
904 IKE_NOTICE_ERROR_NO_PROPOSAL_CHOSEN, b->Buf, b->Size,
905 NULL, 0);
906
907 FreeBuf(b);
908
909 return ret;
910 }
911
912 // Create a DPD payload
IkeNewNoticeDpdPayload(bool ack,UINT64 init_cookie,UINT64 resp_cookie,UINT seq_no)913 IKE_PACKET_PAYLOAD *IkeNewNoticeDpdPayload(bool ack, UINT64 init_cookie, UINT64 resp_cookie, UINT seq_no)
914 {
915 IKE_PACKET_PAYLOAD *ret;
916 BUF *b = NewBuf();
917
918 seq_no = Endian32(seq_no);
919
920 WriteBufInt64(b, init_cookie);
921 WriteBufInt64(b, resp_cookie);
922
923 ret = IkeNewNoticePayload(IKE_PROTOCOL_ID_IKE, (ack ? IKE_NOTICE_DPD_RESPONSE : IKE_NOTICE_DPD_REQUEST),
924 b->Buf, b->Size,
925 &seq_no, sizeof(UINT));
926
927 FreeBuf(b);
928
929 return ret;
930 }
931
932 // Create a Certificate Request Payload
IkeNewCertRequestPayload(UCHAR cert_type,void * data,UINT size)933 IKE_PACKET_PAYLOAD *IkeNewCertRequestPayload(UCHAR cert_type, void *data, UINT size)
934 {
935 IKE_PACKET_PAYLOAD *p;
936 if (data == NULL && size != 0)
937 {
938 return NULL;
939 }
940
941 p = IkeNewPayload(IKE_PAYLOAD_CERT_REQUEST);
942 p->Payload.CertRequest.CertType = cert_type;
943 p->Payload.CertRequest.Data = MemToBuf(data, size);
944
945 return p;
946 }
947
948 // Create a Certificate payload
IkeNewCertPayload(UCHAR cert_type,void * cert_data,UINT cert_size)949 IKE_PACKET_PAYLOAD *IkeNewCertPayload(UCHAR cert_type, void *cert_data, UINT cert_size)
950 {
951 IKE_PACKET_PAYLOAD *p;
952 if (cert_data == NULL && cert_size != 0)
953 {
954 return NULL;
955 }
956
957 p = IkeNewPayload(IKE_PAYLOAD_CERT);
958 p->Payload.Cert.CertType = cert_type;
959 p->Payload.Cert.CertData = MemToBuf(cert_data, cert_size);
960
961 return p;
962 }
963
964 // Create an ID payload
IkeNewIdPayload(UCHAR id_type,UCHAR protocol_id,USHORT port,void * id_data,UINT id_size)965 IKE_PACKET_PAYLOAD *IkeNewIdPayload(UCHAR id_type, UCHAR protocol_id, USHORT port, void *id_data, UINT id_size)
966 {
967 IKE_PACKET_PAYLOAD *p;
968 if (id_data == NULL && id_size != 0)
969 {
970 return NULL;
971 }
972
973 p = IkeNewPayload(IKE_PAYLOAD_ID);
974 p->Payload.Id.IdData = MemToBuf(id_data, id_size);
975 p->Payload.Id.Port = port;
976 p->Payload.Id.ProtocolId = protocol_id;
977 p->Payload.Id.Type = id_type;
978
979 return p;
980 }
981
982 // Create a transform payload
IkeNewTransformPayload(UCHAR number,UCHAR transform_id,LIST * value_list)983 IKE_PACKET_PAYLOAD *IkeNewTransformPayload(UCHAR number, UCHAR transform_id, LIST *value_list)
984 {
985 IKE_PACKET_PAYLOAD *p;
986 if (value_list == NULL)
987 {
988 return NULL;
989 }
990
991 p = IkeNewPayload(IKE_PAYLOAD_TRANSFORM);
992 p->Payload.Transform.Number = number;
993 p->Payload.Transform.TransformId = transform_id;
994 p->Payload.Transform.ValueList = value_list;
995
996 return p;
997 }
998
999 // Create a proposal payload
IkeNewProposalPayload(UCHAR number,UCHAR protocol_id,void * spi,UINT spi_size,LIST * payload_list)1000 IKE_PACKET_PAYLOAD *IkeNewProposalPayload(UCHAR number, UCHAR protocol_id, void *spi, UINT spi_size, LIST *payload_list)
1001 {
1002 IKE_PACKET_PAYLOAD *p;
1003 if (payload_list == NULL || (spi == NULL && spi_size != 0))
1004 {
1005 return NULL;
1006 }
1007
1008 p = IkeNewPayload(IKE_PAYLOAD_PROPOSAL);
1009 p->Payload.Proposal.Number = number;
1010 p->Payload.Proposal.ProtocolId = protocol_id;
1011 p->Payload.Proposal.Spi = MemToBuf(spi, spi_size);
1012 p->Payload.Proposal.PayloadList = payload_list;
1013
1014 return p;
1015 }
1016
1017 // Create an SA payload
IkeNewSaPayload(LIST * payload_list)1018 IKE_PACKET_PAYLOAD *IkeNewSaPayload(LIST *payload_list)
1019 {
1020 IKE_PACKET_PAYLOAD *p;
1021 // Validate arguments
1022 if (payload_list == NULL)
1023 {
1024 return NULL;
1025 }
1026
1027 p = IkeNewPayload(IKE_PAYLOAD_SA);
1028 p->Payload.Sa.PayloadList = payload_list;
1029
1030 return p;
1031 }
1032
1033 // Create a NAT-OA payload
IkeNewNatOaPayload(UCHAR payload_type,IP * ip)1034 IKE_PACKET_PAYLOAD *IkeNewNatOaPayload(UCHAR payload_type, IP *ip)
1035 {
1036 IKE_PACKET_PAYLOAD *p;
1037 // Validate arguments
1038 if (ip == NULL)
1039 {
1040 return NULL;
1041 }
1042
1043 p = IkeNewPayload(payload_type);
1044 Copy(&p->Payload.NatOa.IpAddress, ip, sizeof(IP));
1045 p->PayloadType = payload_type;
1046
1047 return p;
1048 }
1049
1050 // Create a data payload
IkeNewDataPayload(UCHAR payload_type,void * data,UINT size)1051 IKE_PACKET_PAYLOAD *IkeNewDataPayload(UCHAR payload_type, void *data, UINT size)
1052 {
1053 IKE_PACKET_PAYLOAD *p;
1054 // Validate arguments
1055 if (data == NULL)
1056 {
1057 return NULL;
1058 }
1059
1060 p = IkeNewPayload(payload_type);
1061 p->Payload.GeneralData.Data = MemToBuf(data, size);
1062
1063 return p;
1064 }
1065
1066 // Create a new payload
IkeNewPayload(UINT payload_type)1067 IKE_PACKET_PAYLOAD *IkeNewPayload(UINT payload_type)
1068 {
1069 IKE_PACKET_PAYLOAD *p;
1070
1071 p = ZeroMalloc(sizeof(IKE_PACKET_PAYLOAD));
1072
1073 p->PayloadType = payload_type;
1074
1075 return p;
1076 }
1077
1078 // Analyse the IKE payload body
IkeParsePayload(UINT payload_type,BUF * b)1079 IKE_PACKET_PAYLOAD *IkeParsePayload(UINT payload_type, BUF *b)
1080 {
1081 IKE_PACKET_PAYLOAD *p = NULL;
1082 bool ok = true;
1083 // Validate arguments
1084 if (b == NULL)
1085 {
1086 return NULL;
1087 }
1088
1089 p = ZeroMalloc(sizeof(IKE_PACKET_PAYLOAD));
1090 p->PayloadType = payload_type;
1091
1092 switch (p->PayloadType)
1093 {
1094 case IKE_PAYLOAD_SA: // SA payload
1095 ok = IkeParseSaPayload(&p->Payload.Sa, b);
1096 break;
1097
1098 case IKE_PAYLOAD_PROPOSAL: // Proposal payload
1099 ok = IkeParseProposalPayload(&p->Payload.Proposal, b);
1100 break;
1101
1102 case IKE_PAYLOAD_TRANSFORM: // Proposal payload
1103 ok = IkeParseTransformPayload(&p->Payload.Transform, b);
1104 break;
1105
1106 case IKE_PAYLOAD_ID: // ID payload
1107 ok = IkeParseIdPayload(&p->Payload.Id, b);
1108 break;
1109
1110 case IKE_PAYLOAD_CERT: // Certificate payload
1111 ok = IkeParseCertPayload(&p->Payload.Cert, b);
1112 break;
1113
1114 case IKE_PAYLOAD_CERT_REQUEST: // Certificate request payload
1115 ok = IkeParseCertRequestPayload(&p->Payload.CertRequest, b);
1116 break;
1117
1118 case IKE_PAYLOAD_NOTICE: // Notification Payload
1119 ok = IkeParseNoticePayload(&p->Payload.Notice, b);
1120 break;
1121
1122 case IKE_PAYLOAD_DELETE: // Deletion payload
1123 ok = IkeParseDeletePayload(&p->Payload.Delete, b);
1124 break;
1125
1126 case IKE_PAYLOAD_NAT_OA:
1127 case IKE_PAYLOAD_NAT_OA_DRAFT:
1128 case IKE_PAYLOAD_NAT_OA_DRAFT_2:
1129 ok = IkeParseNatOaPayload(&p->Payload.NatOa, b);
1130 break;
1131
1132 case IKE_PAYLOAD_KEY_EXCHANGE: // Key exchange payload
1133 case IKE_PAYLOAD_HASH: // Hash payload
1134 case IKE_PAYLOAD_SIGN: // Signature payload
1135 case IKE_PAYLOAD_RAND: // Random number payload
1136 case IKE_PAYLOAD_VENDOR_ID: // Vendor ID payload
1137 case IKE_PAYLOAD_NAT_D: // NAT-D payload
1138 case IKE_PAYLOAD_NAT_D_DRAFT: // NAT-D payload (draft)
1139 default:
1140 ok = IkeParseDataPayload(&p->Payload.GeneralData, b);
1141 break;
1142 }
1143
1144 if (ok == false)
1145 {
1146 Free(p);
1147 p = NULL;
1148 }
1149 else
1150 {
1151 p->BitArray = CloneBuf(b);
1152 }
1153
1154 return p;
1155 }
1156
1157 // Parse the SA payload
IkeParseSaPayload(IKE_PACKET_SA_PAYLOAD * t,BUF * b)1158 bool IkeParseSaPayload(IKE_PACKET_SA_PAYLOAD *t, BUF *b)
1159 {
1160 IKE_SA_HEADER *h;
1161 UCHAR *buf;
1162 UINT size;
1163 // Validate arguments
1164 if (t == NULL || b == NULL)
1165 {
1166 return false;
1167 }
1168
1169 if (b->Size < sizeof(IKE_SA_HEADER))
1170 {
1171 return false;
1172 }
1173
1174 h = (IKE_SA_HEADER *)b->Buf;
1175 buf = (UCHAR *)b->Buf;
1176 buf += sizeof(IKE_SA_HEADER);
1177 size = b->Size - sizeof(IKE_SA_HEADER);
1178
1179 if (Endian32(h->DoI) != IKE_SA_DOI_IPSEC)
1180 {
1181 Debug("ISAKMP: Invalid DoI Value: 0x%x\n", Endian32(h->DoI));
1182 return false;
1183 }
1184
1185 if (Endian32(h->Situation) != IKE_SA_SITUATION_IDENTITY)
1186 {
1187 Debug("ISAKMP: Invalid Situation Value: 0x%x\n", Endian32(h->Situation));
1188 return false;
1189 }
1190
1191 t->PayloadList = IkeParsePayloadList(buf, size, IKE_PAYLOAD_PROPOSAL);
1192
1193 return true;
1194 }
1195
1196 // Release the SA payload
IkeFreeSaPayload(IKE_PACKET_SA_PAYLOAD * t)1197 void IkeFreeSaPayload(IKE_PACKET_SA_PAYLOAD *t)
1198 {
1199 // Validate arguments
1200 if (t == NULL)
1201 {
1202 return;
1203 }
1204
1205 if (t->PayloadList != NULL)
1206 {
1207 IkeFreePayloadList(t->PayloadList);
1208 t->PayloadList = NULL;
1209 }
1210 }
1211
1212 // Parse the proposal payload
IkeParseProposalPayload(IKE_PACKET_PROPOSAL_PAYLOAD * t,BUF * b)1213 bool IkeParseProposalPayload(IKE_PACKET_PROPOSAL_PAYLOAD *t, BUF *b)
1214 {
1215 IKE_PROPOSAL_HEADER *h;
1216 UCHAR *buf;
1217 UINT size;
1218 // Validate arguments
1219 if (t == NULL || b == NULL)
1220 {
1221 return false;
1222 }
1223
1224 if (b->Size < sizeof(IKE_PROPOSAL_HEADER))
1225 {
1226 return false;
1227 }
1228
1229 h = (IKE_PROPOSAL_HEADER *)b->Buf;
1230
1231 t->Number = h->Number;
1232 t->ProtocolId = h->ProtocolId;
1233
1234 buf = (UCHAR *)b->Buf;
1235 buf += sizeof(IKE_PROPOSAL_HEADER);
1236 size = b->Size - sizeof(IKE_PROPOSAL_HEADER);
1237
1238 if (size < (UINT)h->SpiSize)
1239 {
1240 return false;
1241 }
1242
1243 t->Spi = MemToBuf(buf, h->SpiSize);
1244
1245 buf += h->SpiSize;
1246 size -= h->SpiSize;
1247
1248 t->PayloadList = IkeParsePayloadList(buf, size, IKE_PAYLOAD_TRANSFORM);
1249
1250 return true;
1251 }
1252
1253 // Release the proposal payload
IkeFreeProposalPayload(IKE_PACKET_PROPOSAL_PAYLOAD * t)1254 void IkeFreeProposalPayload(IKE_PACKET_PROPOSAL_PAYLOAD *t)
1255 {
1256 // Validate arguments
1257 if (t == NULL)
1258 {
1259 return;
1260 }
1261
1262 if (t->Spi != NULL)
1263 {
1264 FreeBuf(t->Spi);
1265 t->Spi = NULL;
1266 }
1267
1268 if (t->PayloadList != NULL)
1269 {
1270 IkeFreePayloadList(t->PayloadList);
1271 t->PayloadList = NULL;
1272 }
1273 }
1274
1275 // Parse the transform payload
IkeParseTransformPayload(IKE_PACKET_TRANSFORM_PAYLOAD * t,BUF * b)1276 bool IkeParseTransformPayload(IKE_PACKET_TRANSFORM_PAYLOAD *t, BUF *b)
1277 {
1278 IKE_TRANSFORM_HEADER h;
1279 // Validate arguments
1280 if (t == NULL || b == NULL)
1281 {
1282 return false;
1283 }
1284
1285 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1286 {
1287 return false;
1288 }
1289
1290 t->Number = h.Number;
1291 t->TransformId = h.TransformId;
1292 t->ValueList = IkeParseTransformValueList(b);
1293
1294 return true;
1295 }
1296
1297 // Create a new transform value
IkeNewTransformValue(UCHAR type,UINT value)1298 IKE_PACKET_TRANSFORM_VALUE *IkeNewTransformValue(UCHAR type, UINT value)
1299 {
1300 IKE_PACKET_TRANSFORM_VALUE *v = ZeroMalloc(sizeof(IKE_PACKET_TRANSFORM_VALUE));
1301
1302 v->Type = type;
1303 v->Value = value;
1304
1305 return v;
1306 }
1307
1308 // Parse the transform value list
IkeParseTransformValueList(BUF * b)1309 LIST *IkeParseTransformValueList(BUF *b)
1310 {
1311 LIST *o;
1312 bool ok = true;
1313 // Validate arguments
1314 if (b == NULL)
1315 {
1316 return NULL;
1317 }
1318
1319 o = NewListFast(NULL);
1320
1321 while (b->Current < b->Size)
1322 {
1323 UCHAR af_bit, type;
1324 USHORT size;
1325 UINT value = 0;
1326 IKE_PACKET_TRANSFORM_VALUE *v;
1327
1328 if (ReadBuf(b, &af_bit, sizeof(af_bit)) != sizeof(af_bit))
1329 {
1330 ok = false;
1331 break;
1332 }
1333
1334 if (ReadBuf(b, &type, sizeof(type)) != sizeof(type))
1335 {
1336 ok = false;
1337 break;
1338 }
1339
1340 if (ReadBuf(b, &size, sizeof(size)) != sizeof(size))
1341 {
1342 ok = false;
1343 }
1344
1345 size = Endian16(size);
1346
1347 if (af_bit == 0)
1348 {
1349 UCHAR *tmp = Malloc(size);
1350
1351 if (ReadBuf(b, tmp, size) != size)
1352 {
1353 ok = false;
1354 Free(tmp);
1355 break;
1356 }
1357
1358 switch (size)
1359 {
1360 case sizeof(UINT):
1361 value = READ_UINT(tmp);
1362 break;
1363
1364 case sizeof(USHORT):
1365 value = READ_USHORT(tmp);
1366 break;
1367
1368 case sizeof(UCHAR):
1369 value = *((UCHAR *)tmp);
1370 break;
1371 }
1372
1373 Free(tmp);
1374 }
1375 else
1376 {
1377 value = (UINT)size;
1378 }
1379
1380 v = ZeroMalloc(sizeof(IKE_PACKET_TRANSFORM_VALUE));
1381 v->Type = type;
1382 v->Value = value;
1383
1384 Add(o, v);
1385 }
1386
1387 if (ok == false)
1388 {
1389 IkeFreeTransformValueList(o);
1390 o = NULL;
1391 }
1392
1393 return o;
1394 }
1395
1396 // Release the transform value list
IkeFreeTransformValueList(LIST * o)1397 void IkeFreeTransformValueList(LIST *o)
1398 {
1399 UINT i;
1400 // Validate arguments
1401 if (o == NULL)
1402 {
1403 return;
1404 }
1405
1406 for (i = 0;i < LIST_NUM(o);i++)
1407 {
1408 IKE_PACKET_TRANSFORM_VALUE *v = LIST_DATA(o, i);
1409
1410 Free(v);
1411 }
1412
1413 ReleaseList(o);
1414 }
1415
1416 // Release the transform payload
IkeFreeTransformPayload(IKE_PACKET_TRANSFORM_PAYLOAD * t)1417 void IkeFreeTransformPayload(IKE_PACKET_TRANSFORM_PAYLOAD *t)
1418 {
1419 // Validate arguments
1420 if (t == NULL)
1421 {
1422 return;
1423 }
1424
1425 if (t->ValueList != NULL)
1426 {
1427 IkeFreeTransformValueList(t->ValueList);
1428 t->ValueList = NULL;
1429 }
1430 }
1431
1432 // Parse the ID payload
IkeParseIdPayload(IKE_PACKET_ID_PAYLOAD * t,BUF * b)1433 bool IkeParseIdPayload(IKE_PACKET_ID_PAYLOAD *t, BUF *b)
1434 {
1435 IKE_ID_HEADER h;
1436 IP ip;
1437 IP subnet;
1438 // Validate arguments
1439 if (t == NULL || b == NULL)
1440 {
1441 return false;
1442 }
1443
1444 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1445 {
1446 return false;
1447 }
1448
1449 t->Type = h.IdType;
1450 t->ProtocolId = h.ProtocolId;
1451 t->Port = Endian16(h.Port);
1452 t->IdData = ReadRemainBuf(b);
1453 if (t->IdData == NULL)
1454 {
1455 return false;
1456 }
1457
1458 Zero(&ip, sizeof(ip));
1459 Zero(&subnet, sizeof(subnet));
1460
1461 // Convert to string
1462 Zero(t->StrData, sizeof(t->StrData));
1463 switch (t->Type)
1464 {
1465 case IKE_ID_FQDN:
1466 case IKE_ID_USER_FQDN:
1467 case IKE_ID_KEY_ID:
1468 Copy(t->StrData, t->IdData->Buf, MIN(t->IdData->Size, sizeof(t->StrData) - 1));
1469 break;
1470
1471 case IKE_ID_IPV4_ADDR:
1472 if (t->IdData->Size == 4)
1473 {
1474 Copy(ip.addr, t->IdData->Buf, 4);
1475
1476 IPToStr(t->StrData, sizeof(t->StrData), &ip);
1477 }
1478 break;
1479
1480 case IKE_ID_IPV6_ADDR:
1481 if (t->IdData->Size == 16)
1482 {
1483 SetIP6(&ip, t->IdData->Buf);
1484
1485 IPToStr(t->StrData, sizeof(t->StrData), &ip);
1486 }
1487 break;
1488
1489 case IKE_ID_IPV4_ADDR_SUBNET:
1490 if (t->IdData->Size == 8)
1491 {
1492 char ipstr[MAX_SIZE];
1493 char subnetstr[MAX_SIZE];
1494 Copy(ip.addr, t->IdData->Buf, 4);
1495 Copy(subnet.addr, ((UCHAR *)t->IdData->Buf) + 4, 4);
1496
1497 IPToStr(ipstr, sizeof(ipstr), &ip);
1498 MaskToStr(subnetstr, sizeof(subnetstr), &subnet);
1499
1500 Format(t->StrData, sizeof(t->StrData), "%s/%s", ipstr, subnetstr);
1501 }
1502 break;
1503
1504 case IKE_ID_IPV6_ADDR_SUBNET:
1505 if (t->IdData->Size == 32)
1506 {
1507 char ipstr[MAX_SIZE];
1508 char subnetstr[MAX_SIZE];
1509 SetIP6(&ip, t->IdData->Buf);
1510 SetIP6(&subnet, ((UCHAR *)t->IdData->Buf) + 16);
1511
1512 IPToStr(ipstr, sizeof(ipstr), &ip);
1513 MaskToStr(subnetstr, sizeof(subnetstr), &subnet);
1514
1515 Format(t->StrData, sizeof(t->StrData), "%s/%s", ipstr, subnetstr);
1516 }
1517 break;
1518 }
1519
1520 return true;
1521 }
1522
1523 // Release the ID payload
IkeFreeIdPayload(IKE_PACKET_ID_PAYLOAD * t)1524 void IkeFreeIdPayload(IKE_PACKET_ID_PAYLOAD *t)
1525 {
1526 // Validate arguments
1527 if (t == NULL)
1528 {
1529 return;
1530 }
1531
1532 if (t->IdData != NULL)
1533 {
1534 FreeBuf(t->IdData);
1535 t->IdData = NULL;
1536 }
1537 }
1538
1539 // Parse the certificate payload
IkeParseCertPayload(IKE_PACKET_CERT_PAYLOAD * t,BUF * b)1540 bool IkeParseCertPayload(IKE_PACKET_CERT_PAYLOAD *t, BUF *b)
1541 {
1542 IKE_CERT_HEADER h;
1543 // Validate arguments
1544 if (t == NULL || b == NULL)
1545 {
1546 return false;
1547 }
1548
1549 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1550 {
1551 return false;
1552 }
1553
1554 t->CertType = h.CertType;
1555 t->CertData = ReadRemainBuf(b);
1556 if (t->CertData == NULL)
1557 {
1558 return false;
1559 }
1560
1561 return true;
1562 }
1563
1564 // Release the certificate payload
IkeFreeCertPayload(IKE_PACKET_CERT_PAYLOAD * t)1565 void IkeFreeCertPayload(IKE_PACKET_CERT_PAYLOAD *t)
1566 {
1567 // Validate arguments
1568 if (t == NULL)
1569 {
1570 return;
1571 }
1572
1573 if (t->CertData != NULL)
1574 {
1575 FreeBuf(t->CertData);
1576 t->CertData = NULL;
1577 }
1578 }
1579
1580 // Parse the certificate request payload
IkeParseCertRequestPayload(IKE_PACKET_CERT_REQUEST_PAYLOAD * t,BUF * b)1581 bool IkeParseCertRequestPayload(IKE_PACKET_CERT_REQUEST_PAYLOAD *t, BUF *b)
1582 {
1583 IKE_CERT_REQUEST_HEADER h;
1584 // Validate arguments
1585 if (t == NULL || b == NULL)
1586 {
1587 return false;
1588 }
1589
1590 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1591 {
1592 return false;
1593 }
1594
1595 t->CertType = h.CertType;
1596 t->Data = ReadRemainBuf(b);
1597 if (t->Data == NULL)
1598 {
1599 return false;
1600 }
1601
1602 return true;
1603 }
1604
1605 // Release the certificate request payload
IkeFreeCertRequestPayload(IKE_PACKET_CERT_REQUEST_PAYLOAD * t)1606 void IkeFreeCertRequestPayload(IKE_PACKET_CERT_REQUEST_PAYLOAD *t)
1607 {
1608 // Validate arguments
1609 if (t == NULL)
1610 {
1611 return;
1612 }
1613
1614 if (t->Data != NULL)
1615 {
1616 FreeBuf(t->Data);
1617 t->Data = NULL;
1618 }
1619 }
1620
1621 // Parse the notification payload
IkeParseNoticePayload(IKE_PACKET_NOTICE_PAYLOAD * t,BUF * b)1622 bool IkeParseNoticePayload(IKE_PACKET_NOTICE_PAYLOAD *t, BUF *b)
1623 {
1624 IKE_NOTICE_HEADER h;
1625 // Validate arguments
1626 if (t == NULL || b == NULL)
1627 {
1628 return false;
1629 }
1630
1631 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1632 {
1633 return false;
1634 }
1635
1636 if (Endian32(h.DoI) != IKE_SA_DOI_IPSEC)
1637 {
1638 Debug("ISAKMP: Invalid DoI Value: 0x%x\n", Endian32(h.DoI));
1639 return false;
1640 }
1641
1642 t->MessageType = Endian16(h.MessageType);
1643 t->ProtocolId = h.ProtocolId;
1644 t->Spi = ReadBufFromBuf(b, h.SpiSize);
1645 if (t->Spi == NULL)
1646 {
1647 return false;
1648 }
1649 t->MessageData = ReadRemainBuf(b);
1650
1651 return true;
1652 }
1653
1654 // Release the notification payload
IkeFreeNoticePayload(IKE_PACKET_NOTICE_PAYLOAD * t)1655 void IkeFreeNoticePayload(IKE_PACKET_NOTICE_PAYLOAD *t)
1656 {
1657 // Validate arguments
1658 if (t == NULL)
1659 {
1660 return;
1661 }
1662
1663 if (t->MessageData != NULL)
1664 {
1665 FreeBuf(t->MessageData);
1666 t->MessageData = NULL;
1667 }
1668
1669 if (t->Spi != NULL)
1670 {
1671 FreeBuf(t->Spi);
1672 t->Spi = NULL;
1673 }
1674 }
1675
1676 // Parse the NAT-OA payload
IkeParseNatOaPayload(IKE_PACKET_NAT_OA_PAYLOAD * t,BUF * b)1677 bool IkeParseNatOaPayload(IKE_PACKET_NAT_OA_PAYLOAD *t, BUF *b)
1678 {
1679 IKE_NAT_OA_HEADER h;
1680 UCHAR ip4[4];
1681 UCHAR ip6[16];
1682 IP ip;
1683 // Validate arguments
1684 if (t == NULL || b == NULL)
1685 {
1686 return false;
1687 }
1688
1689 Zero(&ip, sizeof(ip));
1690
1691 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1692 {
1693 return false;
1694 }
1695
1696 if (h.IdType != IKE_ID_IPV4_ADDR && h.IdType != IKE_ID_IPV6_ADDR)
1697 {
1698 return false;
1699 }
1700
1701 switch (h.IdType)
1702 {
1703 case IKE_ID_IPV4_ADDR: // IPv4
1704 if (ReadBuf(b, ip4, sizeof(ip4)) != sizeof(ip4))
1705 {
1706 return false;
1707 }
1708
1709 SetIP(&ip, ip4[0], ip4[1], ip4[2], ip4[3]);
1710
1711 break;
1712
1713 case IKE_ID_IPV6_ADDR: // IPv6
1714 if (ReadBuf(b, ip6, sizeof(ip6)) != sizeof(ip6))
1715 {
1716 return false;
1717 }
1718
1719 SetIP6(&ip, ip6);
1720
1721 break;
1722
1723 default:
1724 return false;
1725 }
1726
1727 Copy(&t->IpAddress, &ip, sizeof(IP));
1728
1729 return true;
1730 }
1731
1732 // Parse the deletion payload
IkeParseDeletePayload(IKE_PACKET_DELETE_PAYLOAD * t,BUF * b)1733 bool IkeParseDeletePayload(IKE_PACKET_DELETE_PAYLOAD *t, BUF *b)
1734 {
1735 IKE_DELETE_HEADER h;
1736 UINT num_spi;
1737 UINT spi_size;
1738 UINT i;
1739 bool ok = true;
1740 // Validate arguments
1741 if (t == NULL || b == NULL)
1742 {
1743 return false;
1744 }
1745
1746 if (ReadBuf(b, &h, sizeof(h)) != sizeof(h))
1747 {
1748 return false;
1749 }
1750
1751 if (Endian32(h.DoI) != IKE_SA_DOI_IPSEC)
1752 {
1753 Debug("ISAKMP: Invalid DoI Value: 0x%x\n", Endian32(h.DoI));
1754 return false;
1755 }
1756
1757 t->ProtocolId = h.ProtocolId;
1758 t->SpiList = NewListFast(NULL);
1759 num_spi = Endian16(h.NumSpis);
1760 spi_size = h.SpiSize;
1761
1762 for (i = 0;i < num_spi;i++)
1763 {
1764 BUF *spi = ReadBufFromBuf(b, spi_size);
1765
1766 if (spi == NULL)
1767 {
1768 ok = false;
1769 break;
1770 }
1771
1772 Add(t->SpiList, spi);
1773 }
1774
1775 if (ok == false)
1776 {
1777 IkeFreeDeletePayload(t);
1778 return false;
1779 }
1780
1781 return true;
1782 }
1783
1784 // Release the deletion payload
IkeFreeDeletePayload(IKE_PACKET_DELETE_PAYLOAD * t)1785 void IkeFreeDeletePayload(IKE_PACKET_DELETE_PAYLOAD *t)
1786 {
1787 UINT i;
1788 // Validate arguments
1789 if (t == NULL)
1790 {
1791 return;
1792 }
1793
1794 if (t->SpiList != NULL)
1795 {
1796 for (i = 0;i < LIST_NUM(t->SpiList);i++)
1797 {
1798 BUF *spi = LIST_DATA(t->SpiList, i);
1799
1800 FreeBuf(spi);
1801 }
1802
1803 ReleaseList(t->SpiList);
1804
1805 t->SpiList = NULL;
1806 }
1807 }
1808
1809 // Check whether the hash matches
IkeCompareHash(IKE_PACKET_PAYLOAD * hash_payload,void * hash_data,UINT hash_size)1810 bool IkeCompareHash(IKE_PACKET_PAYLOAD *hash_payload, void *hash_data, UINT hash_size)
1811 {
1812 //char tmp1[MAX_SIZE], tmp2[MAX_SIZE];
1813 // Validate arguments
1814 if (hash_payload == NULL || hash_data == NULL || hash_size == 0)
1815 {
1816 return false;
1817 }
1818
1819 if (hash_payload->PayloadType != IKE_PAYLOAD_HASH)
1820 {
1821 return false;
1822 }
1823
1824 if (hash_payload->Payload.Hash.Data == NULL)
1825 {
1826 return false;
1827 }
1828
1829 if (hash_payload->Payload.Hash.Data->Size != hash_size)
1830 {
1831 return false;
1832 }
1833
1834 //BinToStrEx(tmp1, sizeof(tmp1), hash_payload->Payload.Hash.Data->Buf, hash_size);
1835 //BinToStrEx(tmp2, sizeof(tmp2), hash_data, hash_size);
1836
1837 //Debug("IkeCompareHash\n 1: %s\n 2: %s\n", tmp1, tmp2);
1838
1839 if (Cmp(hash_payload->Payload.Hash.Data->Buf, hash_data, hash_size) != 0)
1840 {
1841 return false;
1842 }
1843
1844 return true;
1845 }
1846
1847 // Parse the data payload
IkeParseDataPayload(IKE_PACKET_DATA_PAYLOAD * t,BUF * b)1848 bool IkeParseDataPayload(IKE_PACKET_DATA_PAYLOAD *t, BUF *b)
1849 {
1850 // Validate arguments
1851 if (t == NULL || b == NULL)
1852 {
1853 return false;
1854 }
1855
1856 t->Data = MemToBuf(b->Buf, b->Size);
1857
1858 return true;
1859 }
1860
1861 // Release the data payload
IkeFreeDataPayload(IKE_PACKET_DATA_PAYLOAD * t)1862 void IkeFreeDataPayload(IKE_PACKET_DATA_PAYLOAD *t)
1863 {
1864 // Validate arguments
1865 if (t == NULL)
1866 {
1867 return;
1868 }
1869
1870 FreeBuf(t->Data);
1871 }
1872
1873 // Release the IKE payload body
IkeFreePayload(IKE_PACKET_PAYLOAD * p)1874 void IkeFreePayload(IKE_PACKET_PAYLOAD *p)
1875 {
1876 // Validate arguments
1877 if (p == NULL)
1878 {
1879 return;
1880 }
1881
1882 switch (p->PayloadType)
1883 {
1884 case IKE_PAYLOAD_SA: // SA payload
1885 IkeFreeSaPayload(&p->Payload.Sa);
1886 break;
1887
1888 case IKE_PAYLOAD_PROPOSAL: // Proposal payload
1889 IkeFreeProposalPayload(&p->Payload.Proposal);
1890 break;
1891
1892 case IKE_PAYLOAD_TRANSFORM: // Proposal payload
1893 IkeFreeTransformPayload(&p->Payload.Transform);
1894 break;
1895
1896 case IKE_PAYLOAD_ID: // ID payload
1897 IkeFreeIdPayload(&p->Payload.Id);
1898 break;
1899
1900 case IKE_PAYLOAD_CERT: // Certificate payload
1901 IkeFreeCertPayload(&p->Payload.Cert);
1902 break;
1903
1904 case IKE_PAYLOAD_CERT_REQUEST: // Certificate request payload
1905 IkeFreeCertRequestPayload(&p->Payload.CertRequest);
1906 break;
1907
1908 case IKE_PAYLOAD_NOTICE: // Notification Payload
1909 IkeFreeNoticePayload(&p->Payload.Notice);
1910 break;
1911
1912 case IKE_PAYLOAD_DELETE: // Deletion payload
1913 IkeFreeDeletePayload(&p->Payload.Delete);
1914 break;
1915
1916 case IKE_PAYLOAD_NAT_OA: // NAT-OD payload
1917 case IKE_PAYLOAD_NAT_OA_DRAFT:
1918 case IKE_PAYLOAD_NAT_OA_DRAFT_2:
1919 // Do Nothing
1920 break;
1921
1922 case IKE_PAYLOAD_KEY_EXCHANGE: // Key exchange payload
1923 case IKE_PAYLOAD_HASH: // Hash payload
1924 case IKE_PAYLOAD_SIGN: // Signature payload
1925 case IKE_PAYLOAD_RAND: // Random number payload
1926 case IKE_PAYLOAD_VENDOR_ID: // Vendor ID payload
1927 case IKE_PAYLOAD_NAT_D: // NAT-D payload
1928 case IKE_PAYLOAD_NAT_D_DRAFT: // NAT-D payload (draft)
1929 default:
1930 IkeFreeDataPayload(&p->Payload.GeneralData);
1931 break;
1932 }
1933
1934 if (p->BitArray != NULL)
1935 {
1936 FreeBuf(p->BitArray);
1937 }
1938
1939 Free(p);
1940 }
1941
1942 // Analyse the IKE payload list
IkeParsePayloadList(void * data,UINT size,UCHAR first_payload)1943 LIST *IkeParsePayloadList(void *data, UINT size, UCHAR first_payload)
1944 {
1945 return IkeParsePayloadListEx(data, size, first_payload, NULL);
1946 }
IkeParsePayloadListEx(void * data,UINT size,UCHAR first_payload,UINT * total_read_size)1947 LIST *IkeParsePayloadListEx(void *data, UINT size, UCHAR first_payload, UINT *total_read_size)
1948 {
1949 LIST *o;
1950 BUF *b;
1951 UCHAR payload_type = first_payload;
1952 UINT total = 0;
1953 // Validate arguments
1954 if (data == NULL)
1955 {
1956 return NULL;
1957 }
1958
1959 o = NewListFast(NULL);
1960 b = MemToBuf(data, size);
1961
1962 while (payload_type != IKE_PAYLOAD_NONE)
1963 {
1964 // Read the common header
1965 IKE_COMMON_HEADER header;
1966 USHORT payload_size;
1967 BUF *payload_data;
1968 IKE_PACKET_PAYLOAD *pay;
1969
1970 if (ReadBuf(b, &header, sizeof(header)) != sizeof(header))
1971 {
1972 Debug("ISAKMP: Broken Packet (Invalid Payload Size)\n");
1973
1974 LABEL_ERROR:
1975 // Header reading failure
1976 IkeFreePayloadList(o);
1977 o = NULL;
1978
1979 break;
1980 }
1981
1982 total += sizeof(header);
1983
1984 // Get the payload size
1985 payload_size = Endian16(header.PayloadSize);
1986
1987 if (payload_size < sizeof(header))
1988 {
1989 Debug("ISAKMP: Broken Packet (Invalid Payload Size)\n");
1990 goto LABEL_ERROR;
1991 }
1992
1993 payload_size -= sizeof(header);
1994
1995 // Read the payload data
1996 payload_data = ReadBufFromBuf(b, payload_size);
1997 if (payload_data == NULL)
1998 {
1999 // Data read failure
2000 Debug("ISAKMP: Broken Packet (Invalid Payload Data)\n");
2001 goto LABEL_ERROR;
2002 }
2003
2004 total += payload_size;
2005
2006 // Analyse the payload body
2007 if (IKE_IS_SUPPORTED_PAYLOAD_TYPE(payload_type))
2008 {
2009 // Supported payload type
2010 pay = IkeParsePayload(payload_type, payload_data);
2011
2012 if (pay == NULL)
2013 {
2014 FreeBuf(payload_data);
2015 Debug("ISAKMP: Broken Packet (Payload Data Parse Failed)\n");
2016 goto LABEL_ERROR;
2017 }
2018
2019 Add(o, pay);
2020 }
2021 else
2022 {
2023 // Unsupported payload type
2024 Debug("ISAKMP: Ignored Payload Type: %u\n", payload_type);
2025 pay = IkeParsePayload(payload_type, payload_data);
2026
2027 if (pay == NULL)
2028 {
2029 FreeBuf(payload_data);
2030 Debug("ISAKMP: Broken Packet (Payload Data Parse Failed)\n");
2031 goto LABEL_ERROR;
2032 }
2033
2034 Add(o, pay);
2035 }
2036
2037 payload_type = header.NextPayload;
2038
2039 FreeBuf(payload_data);
2040 }
2041
2042 FreeBuf(b);
2043
2044 if (total_read_size != NULL)
2045 {
2046 *total_read_size = total;
2047 }
2048
2049 return o;
2050 }
2051
2052 // Release the IKE payload list
IkeFreePayloadList(LIST * o)2053 void IkeFreePayloadList(LIST *o)
2054 {
2055 UINT i;
2056 // Validate arguments
2057 if (o == NULL)
2058 {
2059 return;
2060 }
2061
2062 for (i = 0;i < LIST_NUM(o);i++)
2063 {
2064 IKE_PACKET_PAYLOAD *p = LIST_DATA(o, i);
2065
2066 IkeFreePayload(p);
2067 }
2068
2069 ReleaseList(o);
2070 }
2071
2072 // Build an IKE packet
IkeBuild(IKE_PACKET * p,IKE_CRYPTO_PARAM * cparam)2073 BUF *IkeBuild(IKE_PACKET *p, IKE_CRYPTO_PARAM *cparam)
2074 {
2075 return IkeBuildEx(p, cparam, false);
2076 }
IkeBuildEx(IKE_PACKET * p,IKE_CRYPTO_PARAM * cparam,bool use_original_decrypted)2077 BUF *IkeBuildEx(IKE_PACKET *p, IKE_CRYPTO_PARAM *cparam, bool use_original_decrypted)
2078 {
2079 IKE_HEADER h;
2080 BUF *msg_buf;
2081 BUF *ret;
2082 // Validate arguments
2083 if (p == NULL)
2084 {
2085 return NULL;
2086 }
2087
2088 if (p->PayloadList == NULL)
2089 {
2090 return NULL;
2091 }
2092
2093 Zero(&h, sizeof(h));
2094 h.InitiatorCookie = Endian64(p->InitiatorCookie);
2095 h.ResponderCookie = Endian64(p->ResponderCookie);
2096 h.NextPayload = IkeGetFirstPayloadType(p->PayloadList);
2097 h.Version = IKE_VERSION;
2098 h.ExchangeType = p->ExchangeType;
2099 h.Flag = (p->FlagEncrypted ? IKE_HEADER_FLAG_ENCRYPTED : 0) |
2100 (p->FlagCommit ? IKE_HEADER_FLAG_COMMIT : 0) |
2101 (p->FlagAuthOnly ? IKE_HEADER_FLAG_AUTH_ONLY : 0);
2102 h.MessageId = Endian32(p->MessageId);
2103
2104 if (p->DecryptedPayload != NULL && use_original_decrypted)
2105 {
2106 msg_buf = CloneBuf(p->DecryptedPayload);
2107 }
2108 else
2109 {
2110 msg_buf = IkeBuildPayloadList(p->PayloadList);
2111 }
2112
2113 if (p->DecryptedPayload != NULL)
2114 {
2115 FreeBuf(p->DecryptedPayload);
2116 }
2117
2118 p->DecryptedPayload = CloneBuf(msg_buf);
2119
2120 if (p->FlagEncrypted)
2121 {
2122 BUF *b;
2123 // Encryption
2124 b = IkeEncryptWithPadding(msg_buf->Buf, msg_buf->Size, cparam);
2125
2126 if (b == NULL)
2127 {
2128 Debug("ISAKMP: Packet Encrypt Failed\n");
2129 FreeBuf(msg_buf);
2130 return NULL;
2131 }
2132
2133 FreeBuf(msg_buf);
2134
2135 msg_buf = b;
2136 }
2137
2138 h.MessageSize = Endian32(msg_buf->Size + sizeof(h));
2139
2140 ret = NewBuf();
2141 WriteBuf(ret, &h, sizeof(h));
2142 WriteBufBuf(ret, msg_buf);
2143
2144 FreeBuf(msg_buf);
2145
2146 SeekBuf(ret, 0, 0);
2147
2148 return ret;
2149 }
2150
2151 // Analyse the IKE packet
IkeParseEx(void * data,UINT size,IKE_CRYPTO_PARAM * cparam,bool header_only)2152 IKE_PACKET *IkeParseEx(void *data, UINT size, IKE_CRYPTO_PARAM *cparam, bool header_only)
2153 {
2154 IKE_PACKET *p = NULL;
2155 BUF *b;
2156 // Validate arguments
2157 if (data == NULL)
2158 {
2159 return NULL;
2160 }
2161
2162 b = MemToBuf(data, size);
2163
2164 if (b->Size < sizeof(IKE_HEADER))
2165 {
2166 Debug("ISAKMP: Invalid Packet Size\n");
2167 }
2168 else
2169 {
2170 // Header analysis
2171 IKE_HEADER *h = (IKE_HEADER *)b->Buf;
2172
2173 p = ZeroMalloc(sizeof(IKE_PACKET));
2174
2175 p->MessageSize = Endian32(h->MessageSize);
2176 p->InitiatorCookie = Endian64(h->InitiatorCookie);
2177 p->ResponderCookie = Endian64(h->ResponderCookie);
2178 p->ExchangeType = h->ExchangeType;
2179 p->FlagEncrypted = (h->Flag & IKE_HEADER_FLAG_ENCRYPTED) ? true : false;
2180 p->FlagCommit = (h->Flag & IKE_HEADER_FLAG_COMMIT) ? true : false;
2181 p->FlagAuthOnly = (h->Flag & IKE_HEADER_FLAG_AUTH_ONLY) ? true : false;
2182 p->MessageId = Endian32(h->MessageId);
2183
2184 if (b->Size < Endian32(h->MessageSize) ||
2185 Endian32(h->MessageSize) < sizeof(IKE_HEADER))
2186 {
2187 Debug("ISAKMP: Invalid Packet Size\n");
2188
2189 IkeFree(p);
2190 p = NULL;
2191 }
2192 else
2193 {
2194 if (header_only == false)
2195 {
2196 bool ok = false;
2197 UCHAR *payload_data;
2198 UINT payload_size;
2199 BUF *buf = NULL;
2200
2201 payload_data = ((UCHAR *)h) + sizeof(IKE_HEADER);
2202 payload_size = Endian32(h->MessageSize) - sizeof(IKE_HEADER);
2203
2204 // Decrypt if it is encrypted
2205 if (p->FlagEncrypted)
2206 {
2207 buf = IkeDecrypt(payload_data, payload_size, cparam);
2208
2209 if (buf != NULL)
2210 {
2211 ok = true;
2212
2213 payload_data = buf->Buf;
2214 payload_size = buf->Size;
2215
2216 p->DecryptedPayload = CloneBuf(buf);
2217 }
2218 }
2219 else
2220 {
2221 ok = true;
2222 }
2223
2224 if (ok == false)
2225 {
2226 Debug("ISAKMP: Decrypt Failed\n");
2227
2228 IkeFree(p);
2229 p = NULL;
2230 }
2231 else
2232 {
2233 UINT total_read_size;
2234
2235 // Payload analysis
2236 p->PayloadList = IkeParsePayloadListEx(payload_data,
2237 payload_size,
2238 h->NextPayload,
2239 &total_read_size);
2240
2241 if (p->DecryptedPayload != NULL)
2242 {
2243 p->DecryptedPayload->Size = MIN(p->DecryptedPayload->Size, total_read_size);
2244 }
2245 else
2246 {
2247 p->DecryptedPayload = MemToBuf(payload_data, payload_size);
2248 }
2249 }
2250
2251 if (buf != NULL)
2252 {
2253 FreeBuf(buf);
2254 }
2255 }
2256 }
2257 }
2258
2259 FreeBuf(b);
2260
2261 return p;
2262 }
IkeParseHeader(void * data,UINT size,IKE_CRYPTO_PARAM * cparam)2263 IKE_PACKET *IkeParseHeader(void *data, UINT size, IKE_CRYPTO_PARAM *cparam)
2264 {
2265 return IkeParseEx(data, size, cparam, true);
2266 }
IkeParse(void * data,UINT size,IKE_CRYPTO_PARAM * cparam)2267 IKE_PACKET *IkeParse(void *data, UINT size, IKE_CRYPTO_PARAM *cparam)
2268 {
2269 return IkeParseEx(data, size, cparam, false);
2270 }
2271
2272 // Send packet for debugging by UDP (For debugging with Ethereal)
IkeDebugUdpSendRawPacket(IKE_PACKET * p)2273 void IkeDebugUdpSendRawPacket(IKE_PACKET *p)
2274 {
2275 BUF *b;
2276 IP ip;
2277 SOCK *udp;
2278 // Validate arguments
2279 if (p == NULL)
2280 {
2281 return;
2282 }
2283
2284 p->FlagEncrypted = false;
2285
2286 b = NULL;
2287
2288 if (b == NULL)
2289 {
2290 b = IkeBuildEx(p, NULL, true);
2291 }
2292
2293 if (b == NULL)
2294 {
2295 return;
2296 }
2297
2298 Zero(&ip, sizeof(ip));
2299 SetIP(&ip, 1, 2, 3, 4);
2300
2301 udp = NewUDP(0);
2302
2303 SendTo(udp, &ip, 500, b->Buf, b->Size);
2304
2305 ReleaseSock(udp);
2306 FreeBuf(b);
2307 }
2308
2309 // Output the payload list
IkeDebugPrintPayloads(LIST * o,UINT depth)2310 void IkeDebugPrintPayloads(LIST *o, UINT depth)
2311 {
2312 UINT i;
2313 char space[MAX_SIZE];
2314 // Validate arguments
2315 if (o == NULL)
2316 {
2317 return;
2318 }
2319
2320 MakeCharArray2(space, ' ', depth * 2);
2321
2322 for (i = 0;i < LIST_NUM(o);i++)
2323 {
2324 IKE_PACKET_PAYLOAD *payload = LIST_DATA(o, i);
2325
2326 Debug("%s%u: Type = %u, Size = %u\n", space, i, payload->PayloadType, payload->BitArray->Size);
2327
2328 switch (payload->PayloadType)
2329 {
2330 case IKE_PAYLOAD_SA:
2331 IkeDebugPrintPayloads(payload->Payload.Sa.PayloadList, depth + 1);
2332 break;
2333
2334 case IKE_PAYLOAD_PROPOSAL:
2335 IkeDebugPrintPayloads(payload->Payload.Proposal.PayloadList, depth + 1);
2336 break;
2337 }
2338 }
2339 }
2340
2341 // Encryption (also with padding)
IkeEncryptWithPadding(void * data,UINT size,IKE_CRYPTO_PARAM * cparam)2342 BUF *IkeEncryptWithPadding(void *data, UINT size, IKE_CRYPTO_PARAM *cparam)
2343 {
2344 UINT total_size;
2345 UINT i;
2346 UCHAR n = 0;
2347 UCHAR *tmp;
2348 BUF *ret;
2349 UCHAR tmp1600[1600];
2350 bool no_free = false;
2351 // Validate arguments
2352 if (data == NULL || cparam == NULL)
2353 {
2354 return NULL;
2355 }
2356
2357 total_size = ((size / cparam->Key->Crypto->BlockSize) + ((size % cparam->Key->Crypto->BlockSize) == 0 ? 0 : 1))
2358 * cparam->Key->Crypto->BlockSize;
2359 if (total_size == 0)
2360 {
2361 total_size = cparam->Key->Crypto->BlockSize;
2362 }
2363
2364 if (total_size > sizeof(tmp1600))
2365 {
2366 tmp = Malloc(total_size);
2367 }
2368 else
2369 {
2370 tmp = tmp1600;
2371 no_free = true;
2372 }
2373
2374 Copy(tmp, data, size);
2375
2376 for (i = size;i < total_size;i++)
2377 {
2378 tmp[i] = ++n;
2379 }
2380
2381 ret = IkeEncrypt(tmp, total_size, cparam);
2382
2383 if (no_free == false)
2384 {
2385 Free(tmp);
2386 }
2387
2388 return ret;
2389 }
2390
2391 // Encryption
IkeEncrypt(void * data,UINT size,IKE_CRYPTO_PARAM * cparam)2392 BUF *IkeEncrypt(void *data, UINT size, IKE_CRYPTO_PARAM *cparam)
2393 {
2394 void *tmp;
2395 BUF *b;
2396 UCHAR tmp1600[1600];
2397 bool no_free = false;
2398 // Validate arguments
2399 if (data == NULL || cparam == NULL)
2400 {
2401 return NULL;
2402 }
2403
2404 if ((size % cparam->Key->Crypto->BlockSize) != 0)
2405 {
2406 // Not an integral multiple of block size
2407 return NULL;
2408 }
2409
2410 if (size > sizeof(tmp1600))
2411 {
2412 tmp = Malloc(size);
2413 }
2414 else
2415 {
2416 tmp = tmp1600;
2417 no_free = true;
2418 }
2419
2420 IkeCryptoEncrypt(cparam->Key, tmp, data, size, cparam->Iv);
2421
2422 if (size >= cparam->Key->Crypto->BlockSize)
2423 {
2424 Copy(cparam->NextIv, ((UCHAR *)tmp) + (size - cparam->Key->Crypto->BlockSize), cparam->Key->Crypto->BlockSize);
2425 }
2426 else
2427 {
2428 Zero(cparam->NextIv, cparam->Key->Crypto->BlockSize);
2429 }
2430
2431 b = MemToBuf(tmp, size);
2432
2433 if (no_free == false)
2434 {
2435 Free(tmp);
2436 }
2437
2438 return b;
2439 }
2440
2441 // Decryption
IkeDecrypt(void * data,UINT size,IKE_CRYPTO_PARAM * cparam)2442 BUF *IkeDecrypt(void *data, UINT size, IKE_CRYPTO_PARAM *cparam)
2443 {
2444 void *tmp;
2445 BUF *b;
2446 UCHAR tmp1600[1600];
2447 bool no_free = false;
2448 // Validate arguments
2449 if (data == NULL || cparam == NULL)
2450 {
2451 return NULL;
2452 }
2453
2454 if ((size % cparam->Key->Crypto->BlockSize) != 0)
2455 {
2456 // Not an integral multiple of block size
2457 return NULL;
2458 }
2459
2460 if (size > sizeof(tmp1600))
2461 {
2462 tmp = Malloc(size);
2463 }
2464 else
2465 {
2466 tmp = tmp1600;
2467 no_free = true;
2468 }
2469
2470 IkeCryptoDecrypt(cparam->Key, tmp, data, size, cparam->Iv);
2471
2472 if (size >= cparam->Key->Crypto->BlockSize)
2473 {
2474 Copy(cparam->NextIv, ((UCHAR *)data) + (size - cparam->Key->Crypto->BlockSize), cparam->Key->Crypto->BlockSize);
2475 }
2476 else
2477 {
2478 Zero(cparam->NextIv, cparam->Key->Crypto->BlockSize);
2479 }
2480
2481 b = MemToBuf(tmp, size);
2482
2483 if (no_free == false)
2484 {
2485 Free(tmp);
2486 }
2487
2488 return b;
2489 }
2490
2491 // Release the IKE packet
IkeFree(IKE_PACKET * p)2492 void IkeFree(IKE_PACKET *p)
2493 {
2494 // Validate arguments
2495 if (p == NULL)
2496 {
2497 return;
2498 }
2499
2500 if (p->PayloadList != NULL)
2501 {
2502 IkeFreePayloadList(p->PayloadList);
2503 }
2504
2505 if (p->DecryptedPayload != NULL)
2506 {
2507 FreeBuf(p->DecryptedPayload);
2508 }
2509
2510 Free(p);
2511 }
2512
2513 // Create an IKE packet
IkeNew(UINT64 init_cookie,UINT64 resp_cookie,UCHAR exchange_type,bool encrypted,bool commit,bool auth_only,UINT msg_id,LIST * payload_list)2514 IKE_PACKET *IkeNew(UINT64 init_cookie, UINT64 resp_cookie, UCHAR exchange_type,
2515 bool encrypted, bool commit, bool auth_only, UINT msg_id,
2516 LIST *payload_list)
2517 {
2518 IKE_PACKET *p = ZeroMalloc(sizeof(IKE_PACKET));
2519
2520 p->InitiatorCookie = init_cookie;
2521 p->ResponderCookie = resp_cookie;
2522 p->ExchangeType = exchange_type;
2523 p->FlagEncrypted = encrypted;
2524 p->FlagCommit = commit;
2525 p->FlagAuthOnly = auth_only;
2526 p->MessageId = msg_id;
2527 p->PayloadList = payload_list;
2528
2529 return p;
2530 }
2531
2532 // Create a new SPI value
IkeNewSpi()2533 UINT IkeNewSpi()
2534 {
2535 while (true)
2536 {
2537 UINT i = Rand32();
2538
2539 if (i >= 4096)
2540 {
2541 return i;
2542 }
2543 }
2544 }
2545
2546
2547 // Create an encryption engine for IKE
NewIkeEngine()2548 IKE_ENGINE *NewIkeEngine()
2549 {
2550 IKE_ENGINE *e = ZeroMalloc(sizeof(IKE_ENGINE));
2551 IKE_CRYPTO *des, *des3, *aes;
2552 IKE_HASH *sha1, *md5, *sha2_256, *sha2_384, *sha2_512;
2553 IKE_DH *dh1, *dh2, *dh5, *dh2048, *dh3072, *dh4096;
2554 UINT des_key_sizes[] =
2555 {
2556 8,
2557 };
2558 UINT des3_key_sizes[] =
2559 {
2560 24,
2561 };
2562 UINT aes_key_sizes[] =
2563 {
2564 16, 24, 32,
2565 };
2566
2567 e->CryptosList = NewListFast(NULL);
2568 e->HashesList = NewListFast(NULL);
2569 e->DhsList = NewListFast(NULL);
2570
2571 //// Encryption algorithm
2572 // DES
2573 des = NewIkeCrypto(e, IKE_CRYPTO_DES_ID, IKE_CRYPTO_DES_STRING,
2574 des_key_sizes, sizeof(des_key_sizes) / sizeof(UINT), 8);
2575
2576 // 3DES
2577 des3 = NewIkeCrypto(e, IKE_CRYPTO_3DES_ID, IKE_CRYPTO_3DES_STRING,
2578 des3_key_sizes, sizeof(des3_key_sizes) / sizeof(UINT), 8);
2579
2580 // AES
2581 aes = NewIkeCrypto(e, IKE_CRYPTO_AES_ID, IKE_CRYPTO_AES_STRING,
2582 aes_key_sizes, sizeof(aes_key_sizes) / sizeof(UINT), 16);
2583
2584 //// Hash algorithm
2585 // SHA-1
2586 sha1 = NewIkeHash(e, IKE_HASH_SHA1_ID, IKE_HASH_SHA1_STRING, 20);
2587
2588 // SHA-2
2589 // sha2-256
2590 sha2_256 = NewIkeHash(e, IKE_HASH_SHA2_256_ID, IKE_HASH_SHA2_256_STRING, 32);
2591 // sha2-384
2592 sha2_384 = NewIkeHash(e, IKE_HASH_SHA2_384_ID, IKE_HASH_SHA2_384_STRING, 48);
2593 // sha2-512
2594 sha2_512 = NewIkeHash(e, IKE_HASH_SHA2_512_ID, IKE_HASH_SHA2_512_STRING, 64);
2595
2596 // MD5
2597 md5 = NewIkeHash(e, IKE_HASH_MD5_ID, IKE_HASH_MD5_STRING, 16);
2598
2599 //// DH algorithm
2600 dh1 = NewIkeDh(e, IKE_DH_1_ID, IKE_DH_1_STRING, 96);
2601 dh2 = NewIkeDh(e, IKE_DH_2_ID, IKE_DH_2_STRING, 128);
2602 dh5 = NewIkeDh(e, IKE_DH_5_ID, IKE_DH_5_STRING, 192);
2603 dh2048 = NewIkeDh(e, IKE_DH_2048_ID, IKE_DH_2048_STRING, 256);
2604 dh3072 = NewIkeDh(e, IKE_DH_3072_ID, IKE_DH_3072_STRING, 384);
2605 dh4096 = NewIkeDh(e, IKE_DH_4096_ID, IKE_DH_4096_STRING, 512);
2606
2607 // Define the IKE algorithm
2608 e->IkeCryptos[IKE_P1_CRYPTO_DES_CBC] = des;
2609 e->IkeCryptos[IKE_P1_CRYPTO_3DES_CBC] = des3;
2610 e->IkeCryptos[IKE_P1_CRYPTO_AES_CBC] = aes;
2611 e->IkeHashes[IKE_P1_HASH_MD5] = md5;
2612 e->IkeHashes[IKE_P1_HASH_SHA1] = sha1;
2613 e->IkeHashes[IKE_P1_HASH_SHA2_256] = sha2_256;
2614 e->IkeHashes[IKE_P1_HASH_SHA2_384] = sha2_384;
2615 e->IkeHashes[IKE_P1_HASH_SHA2_512] = sha2_512;
2616
2617
2618 // Definition of ESP algorithm
2619 e->EspCryptos[IKE_TRANSFORM_ID_P2_ESP_DES] = des;
2620 e->EspCryptos[IKE_TRANSFORM_ID_P2_ESP_3DES] = des3;
2621 e->EspCryptos[IKE_TRANSFORM_ID_P2_ESP_AES] = aes;
2622 e->EspHashes[IKE_P2_HMAC_MD5_96] = md5;
2623 e->EspHashes[IKE_P2_HMAC_SHA1_96] = sha1;
2624
2625 // Definition of the DH algorithm
2626 e->IkeDhs[IKE_P1_DH_GROUP_768_MODP] = e->EspDhs[IKE_P2_DH_GROUP_768_MODP] = dh1;
2627 e->IkeDhs[IKE_P1_DH_GROUP_1024_MODP] = e->EspDhs[IKE_P2_DH_GROUP_1024_MODP] = dh2;
2628 e->IkeDhs[IKE_P1_DH_GROUP_1536_MODP] = e->EspDhs[IKE_P2_DH_GROUP_1536_MODP] = dh5;
2629 e->IkeDhs[IKE_P1_DH_GROUP_2048_MODP] = e->EspDhs[IKE_P2_DH_GROUP_2048_MODP] = dh2048;
2630 e->IkeDhs[IKE_P1_DH_GROUP_3072_MODP] = e->EspDhs[IKE_P2_DH_GROUP_3072_MODP] = dh3072;
2631 e->IkeDhs[IKE_P1_DH_GROUP_4096_MODP] = e->EspDhs[IKE_P2_DH_GROUP_4096_MODP] = dh4096;
2632
2633 return e;
2634 }
2635
2636 // Release the encryption engine for IKE
FreeIkeEngine(IKE_ENGINE * e)2637 void FreeIkeEngine(IKE_ENGINE *e)
2638 {
2639 UINT i;
2640 // Validate arguments
2641 if (e == NULL)
2642 {
2643 return;
2644 }
2645
2646 for (i = 0;i < LIST_NUM(e->CryptosList);i++)
2647 {
2648 IKE_CRYPTO *c = LIST_DATA(e->CryptosList, i);
2649
2650 FreeIkeCrypto(c);
2651 }
2652
2653 ReleaseList(e->CryptosList);
2654
2655 for (i = 0;i < LIST_NUM(e->HashesList);i++)
2656 {
2657 IKE_HASH *h = LIST_DATA(e->HashesList, i);
2658
2659 FreeIkeHash(h);
2660 }
2661 ReleaseList(e->HashesList);
2662
2663 for (i = 0;i < LIST_NUM(e->DhsList);i++)
2664 {
2665 IKE_DH *d = LIST_DATA(e->DhsList, i);
2666
2667 FreeIkeDh(d);
2668 }
2669 ReleaseList(e->DhsList);
2670
2671 Free(e);
2672 }
2673
2674 // Definition of a new DH algorithm for IKE
NewIkeDh(IKE_ENGINE * e,UINT dh_id,char * name,UINT key_size)2675 IKE_DH *NewIkeDh(IKE_ENGINE *e, UINT dh_id, char *name, UINT key_size)
2676 {
2677 IKE_DH *d;
2678 // Validate arguments
2679 if (e == NULL || name == NULL || key_size == 0)
2680 {
2681 return NULL;
2682 }
2683
2684 d = ZeroMalloc(sizeof(IKE_DH));
2685
2686 d->DhId = dh_id;
2687 d->Name = name;
2688 d->KeySize = key_size;
2689
2690 Add(e->DhsList, d);
2691
2692 return d;
2693 }
2694
2695 // Definition of a new encryption algorithm for IKE
NewIkeCrypto(IKE_ENGINE * e,UINT crypto_id,char * name,UINT * key_sizes,UINT num_key_sizes,UINT block_size)2696 IKE_CRYPTO *NewIkeCrypto(IKE_ENGINE *e, UINT crypto_id, char *name, UINT *key_sizes, UINT num_key_sizes, UINT block_size)
2697 {
2698 IKE_CRYPTO *c;
2699 UINT i;
2700 // Validate arguments
2701 if (e == NULL || name == NULL || key_sizes == NULL)
2702 {
2703 return NULL;
2704 }
2705
2706 c = ZeroMalloc(sizeof(IKE_CRYPTO));
2707
2708 c->CryptoId = crypto_id;
2709 c->Name = name;
2710
2711 for (i = 0;i < MIN(num_key_sizes, 16);i++)
2712 {
2713 c->KeySizes[i] = key_sizes[i];
2714 }
2715
2716 if (num_key_sizes >= 2)
2717 {
2718 c->VariableKeySize = true;
2719 }
2720
2721 c->BlockSize = block_size;
2722
2723 Add(e->CryptosList, c);
2724
2725 return c;
2726 }
2727
2728 // Release the definition of Encryption algorithm for IKE
FreeIkeCrypto(IKE_CRYPTO * c)2729 void FreeIkeCrypto(IKE_CRYPTO *c)
2730 {
2731 // Validate arguments
2732 if (c == NULL)
2733 {
2734 return;
2735 }
2736
2737 Free(c);
2738 }
2739
2740 // Release the definition of IKE hash algorithm
FreeIkeHash(IKE_HASH * h)2741 void FreeIkeHash(IKE_HASH *h)
2742 {
2743 // Validate arguments
2744 if (h == NULL)
2745 {
2746 return;
2747 }
2748
2749 Free(h);
2750 }
2751
2752 // Release the definition of the DH algorithm for IKE
FreeIkeDh(IKE_DH * d)2753 void FreeIkeDh(IKE_DH *d)
2754 {
2755 // Validate arguments
2756 if (d == NULL)
2757 {
2758 return;
2759 }
2760
2761 Free(d);
2762 }
2763
2764 // Definition of a new hash algorithm for IKE
NewIkeHash(IKE_ENGINE * e,UINT hash_id,char * name,UINT size)2765 IKE_HASH *NewIkeHash(IKE_ENGINE *e, UINT hash_id, char *name, UINT size)
2766 {
2767 IKE_HASH *h;
2768 // Validate arguments
2769 if (e == NULL || name == NULL || size == 0)
2770 {
2771 return NULL;
2772 }
2773
2774 h = ZeroMalloc(sizeof(IKE_HASH));
2775
2776 h->HashId = hash_id;
2777 h->Name = name;
2778 h->HashSize = size;
2779
2780 Add(e->HashesList, h);
2781
2782 return h;
2783 }
2784
2785 // Get the encryption algorithm that is used in IKE
GetIkeCrypto(IKE_ENGINE * e,bool for_esp,UINT i)2786 IKE_CRYPTO *GetIkeCrypto(IKE_ENGINE *e, bool for_esp, UINT i)
2787 {
2788 // Validate arguments
2789 if (e == NULL || i == 0 || i >= MAX_IKE_ENGINE_ELEMENTS)
2790 {
2791 return NULL;
2792 }
2793
2794 if (for_esp)
2795 {
2796 return e->EspCryptos[i];
2797 }
2798 else
2799 {
2800 return e->IkeCryptos[i];
2801 }
2802 }
2803
2804 // Get the hash algorithm used in the IKE
GetIkeHash(IKE_ENGINE * e,bool for_esp,UINT i)2805 IKE_HASH *GetIkeHash(IKE_ENGINE *e, bool for_esp, UINT i)
2806 {
2807 // Validate arguments
2808 if (e == NULL || i == 0 || i >= MAX_IKE_ENGINE_ELEMENTS)
2809 {
2810 return NULL;
2811 }
2812
2813 if (for_esp)
2814 {
2815 return e->EspHashes[i];
2816 }
2817 else
2818 {
2819 return e->IkeHashes[i];
2820 }
2821 }
2822
2823 // Get the DH algorithm used in the IKE
GetIkeDh(IKE_ENGINE * e,bool for_esp,UINT i)2824 IKE_DH *GetIkeDh(IKE_ENGINE *e, bool for_esp, UINT i)
2825 {
2826 // Validate arguments
2827 if (e == NULL || i == 0 || i >= MAX_IKE_ENGINE_ELEMENTS)
2828 {
2829 return NULL;
2830 }
2831
2832 if (for_esp)
2833 {
2834 return e->EspDhs[i];
2835 }
2836 else
2837 {
2838 return e->IkeDhs[i];
2839 }
2840 }
2841
2842 // Perform encryption
IkeCryptoEncrypt(IKE_CRYPTO_KEY * k,void * dst,void * src,UINT size,void * ivec)2843 void IkeCryptoEncrypt(IKE_CRYPTO_KEY *k, void *dst, void *src, UINT size, void *ivec)
2844 {
2845 // Validate arguments
2846 if (k == NULL || dst == NULL || src == NULL || size == 0 || ivec == NULL)
2847 {
2848 Zero(dst, size);
2849 return;
2850 }
2851
2852 if ((size % k->Crypto->BlockSize) != 0)
2853 {
2854 Zero(dst, size);
2855 return;
2856 }
2857
2858 switch (k->Crypto->CryptoId)
2859 {
2860 case IKE_CRYPTO_DES_ID: // DES
2861 DesEncrypt(dst, src, size, k->DesKey1, ivec);
2862 break;
2863
2864 case IKE_CRYPTO_3DES_ID: // 3DES
2865 Des3Encrypt2(dst, src, size, k->DesKey1, k->DesKey2, k->DesKey3, ivec);
2866 break;
2867
2868 case IKE_CRYPTO_AES_ID: // AES
2869 AesEncrypt(dst, src, size, k->AesKey, ivec);
2870 break;
2871
2872 default:
2873 // Unknown
2874 Zero(dst, size);
2875 break;
2876 }
2877 }
2878
2879 // Perform decryption
IkeCryptoDecrypt(IKE_CRYPTO_KEY * k,void * dst,void * src,UINT size,void * ivec)2880 void IkeCryptoDecrypt(IKE_CRYPTO_KEY *k, void *dst, void *src, UINT size, void *ivec)
2881 {
2882 // Validate arguments
2883 if (k == NULL || dst == NULL || src == NULL || size == 0 || ivec == NULL)
2884 {
2885 Zero(dst, size);
2886 return;
2887 }
2888
2889 if ((size % k->Crypto->BlockSize) != 0)
2890 {
2891 Zero(dst, size);
2892 return;
2893 }
2894
2895 switch (k->Crypto->CryptoId)
2896 {
2897 case IKE_CRYPTO_DES_ID: // DES
2898 DesDecrypt(dst, src, size, k->DesKey1, ivec);
2899 break;
2900
2901 case IKE_CRYPTO_3DES_ID: // 3DES
2902 Des3Decrypt2(dst, src, size, k->DesKey1, k->DesKey2, k->DesKey3, ivec);
2903 break;
2904
2905 case IKE_CRYPTO_AES_ID: // AES
2906 AesDecrypt(dst, src, size, k->AesKey, ivec);
2907 break;
2908
2909 default:
2910 // Unknown
2911 Zero(dst, size);
2912 break;
2913 }
2914 }
2915
2916 // Calculate a hash
IkeHash(IKE_HASH * h,void * dst,void * src,UINT size)2917 void IkeHash(IKE_HASH *h, void *dst, void *src, UINT size)
2918 {
2919 // Validate arguments
2920 if (h == NULL || dst == NULL || (size != 0 && src == NULL))
2921 {
2922 Zero(dst, size);
2923 return;
2924 }
2925
2926 switch (h->HashId)
2927 {
2928 case IKE_HASH_MD5_ID:
2929 // MD5
2930 Md5(dst, src, size);
2931 break;
2932
2933 case IKE_HASH_SHA1_ID:
2934 // SHA-1
2935 Sha1(dst, src, size);
2936 break;
2937 case IKE_HASH_SHA2_256_ID:
2938 Sha2_256(dst, src, size);
2939 break;
2940 case IKE_HASH_SHA2_384_ID:
2941 Sha2_384(dst, src, size);
2942 break;
2943 case IKE_HASH_SHA2_512_ID:
2944 Sha2_512(dst, src, size);
2945 break;
2946
2947 default:
2948 // Unknown
2949 Zero(dst, size);
2950 break;
2951 }
2952 }
2953
2954 // Calculation of HMAC
IkeHMac(IKE_HASH * h,void * dst,void * key,UINT key_size,void * data,UINT data_size)2955 void IkeHMac(IKE_HASH *h, void *dst, void *key, UINT key_size, void *data, UINT data_size)
2956 {
2957 UINT hmac_block_size = HMAC_BLOCK_SIZE;
2958 UCHAR k[HMAC_BLOCK_SIZE_MAX];
2959 UCHAR *data1;
2960 UCHAR hash1[IKE_MAX_HASH_SIZE];
2961 UINT data1_size;
2962 UCHAR data2[IKE_MAX_HASH_SIZE + HMAC_BLOCK_SIZE_MAX];
2963 UINT data2_size;
2964 UCHAR tmp1600[1600];
2965 bool no_free = false;
2966 UINT i;
2967 // Validate arguments
2968 if (h == NULL || dst == NULL || (key == NULL && key_size != 0) || (data == NULL && data_size != 0))
2969 {
2970 return;
2971 }
2972
2973 switch (h->HashId)
2974 {
2975 case IKE_HASH_SHA1_ID:
2976 case IKE_HASH_SHA2_256_ID:
2977 case IKE_HASH_MD5_ID:
2978 hmac_block_size = HMAC_BLOCK_SIZE;
2979 break;
2980
2981 case IKE_HASH_SHA2_384_ID:
2982 case IKE_HASH_SHA2_512_ID:
2983 hmac_block_size = HMAC_BLOCK_SIZE_1024;
2984 break;
2985
2986 default:
2987 return;
2988 }
2989
2990 if (hmac_block_size > HMAC_BLOCK_SIZE_MAX)
2991 {
2992 return;
2993 }
2994
2995 if (h->HashId == IKE_HASH_SHA1_ID)
2996 {
2997 // Use special function (fast) in the case of SHA-1
2998 HMacSha1(dst, key, key_size, data, data_size);
2999 return;
3000 }
3001 else if (h->HashId == IKE_HASH_MD5_ID)
3002 {
3003 // Use the special function (fast) in the case of MD5
3004 HMacMd5(dst, key, key_size, data, data_size);
3005 return;
3006 }
3007
3008 // Creating a K
3009 Zero(k, sizeof(k));
3010 if (key_size <= hmac_block_size)
3011 {
3012 Copy(k, key, key_size);
3013 }
3014 else
3015 {
3016 IkeHash(h, k, key, key_size);
3017 }
3018
3019 // Generation of data 1
3020 data1_size = data_size + hmac_block_size;
3021
3022 if (data1_size > sizeof(tmp1600))
3023 {
3024 data1 = Malloc(data1_size);
3025 }
3026 else
3027 {
3028 data1 = tmp1600;
3029 no_free = true;
3030 }
3031
3032 for (i = 0;i < hmac_block_size;i++)
3033 {
3034 data1[i] = k[i] ^ 0x36;
3035 }
3036
3037 Copy(data1 + hmac_block_size, data, data_size);
3038
3039 // Calculate the hash value
3040 IkeHash(h, hash1, data1, data1_size);
3041
3042 if (no_free == false)
3043 {
3044 Free(data1);
3045 }
3046
3047 // Generation of data 2
3048 data2_size = h->HashSize + hmac_block_size;
3049
3050 for (i = 0;i < hmac_block_size;i++)
3051 {
3052 data2[i] = k[i] ^ 0x5c;
3053 }
3054
3055 Copy(data2 + hmac_block_size, hash1, h->HashSize);
3056
3057 // Calculate the hash value
3058 IkeHash(h, dst, data2, data2_size);
3059 }
IkeHMacBuf(IKE_HASH * h,void * dst,BUF * key,BUF * data)3060 void IkeHMacBuf(IKE_HASH *h, void *dst, BUF *key, BUF *data)
3061 {
3062 // Validate arguments
3063 if (h == NULL || dst == NULL || key == NULL || data == NULL)
3064 {
3065 return;
3066 }
3067
3068 IkeHMac(h, dst, key->Buf, key->Size, data->Buf, data->Size);
3069 }
3070
3071 // Check whether the key size is valid
IkeCheckKeySize(IKE_CRYPTO * c,UINT size)3072 bool IkeCheckKeySize(IKE_CRYPTO *c, UINT size)
3073 {
3074 bool ok = false;
3075 UINT i;
3076 // Validate arguments
3077 if (c == NULL || size == 0)
3078 {
3079 return false;
3080 }
3081
3082 for (i = 0;i < sizeof(c->KeySizes) / sizeof(UINT);i++)
3083 {
3084 if (c->KeySizes[i] == size)
3085 {
3086 ok = true;
3087 break;
3088 }
3089 }
3090
3091 return ok;
3092 }
3093
3094 // Create a key
IkeNewKey(IKE_CRYPTO * c,void * data,UINT size)3095 IKE_CRYPTO_KEY *IkeNewKey(IKE_CRYPTO *c, void *data, UINT size)
3096 {
3097 IKE_CRYPTO_KEY *k;
3098 // Validate arguments
3099 if (c == NULL || data == NULL || size == 0)
3100 {
3101 return NULL;
3102 }
3103
3104 if (IkeCheckKeySize(c, size) == false)
3105 {
3106 return NULL;
3107 }
3108
3109 k = ZeroMalloc(sizeof(IKE_CRYPTO_KEY));
3110 k->Crypto = c;
3111 k->Data = Clone(data, size);
3112 k->Size = size;
3113
3114 switch (k->Crypto->CryptoId)
3115 {
3116 case IKE_CRYPTO_DES_ID:
3117 // DES 64bit key
3118 k->DesKey1 = DesNewKeyValue(data);
3119 break;
3120
3121 case IKE_CRYPTO_3DES_ID:
3122 // 3DES 192bit key
3123 k->DesKey1 = DesNewKeyValue(((UCHAR *)data) + DES_KEY_SIZE * 0);
3124 k->DesKey2 = DesNewKeyValue(((UCHAR *)data) + DES_KEY_SIZE * 1);
3125 k->DesKey3 = DesNewKeyValue(((UCHAR *)data) + DES_KEY_SIZE * 2);
3126 break;
3127
3128 case IKE_CRYPTO_AES_ID:
3129 // AES variable length key
3130 k->AesKey = AesNewKey(data, size);
3131 break;
3132 }
3133
3134 return k;
3135 }
3136
3137 // Release the key
IkeFreeKey(IKE_CRYPTO_KEY * k)3138 void IkeFreeKey(IKE_CRYPTO_KEY *k)
3139 {
3140 // Validate arguments
3141 if (k == NULL)
3142 {
3143 return;
3144 }
3145
3146 DesFreeKeyValue(k->DesKey1);
3147 DesFreeKeyValue(k->DesKey2);
3148 DesFreeKeyValue(k->DesKey3);
3149
3150 AesFreeKey(k->AesKey);
3151
3152 Free(k->Data);
3153
3154 Free(k);
3155 }
3156
3157 // Create a DH object
IkeDhNewCtx(IKE_DH * d)3158 DH_CTX *IkeDhNewCtx(IKE_DH *d)
3159 {
3160 // Validate arguments
3161 if (d == NULL)
3162 {
3163 return NULL;
3164 }
3165
3166 switch (d->DhId)
3167 {
3168 case IKE_DH_1_ID:
3169 return DhNewGroup1();
3170
3171 case IKE_DH_2_ID:
3172 return DhNewGroup2();
3173
3174 case IKE_DH_5_ID:
3175 return DhNewGroup5();
3176
3177 case IKE_DH_2048_ID:
3178 return DhNew2048();
3179
3180 case IKE_DH_3072_ID:
3181 return DhNew3072();
3182
3183 case IKE_DH_4096_ID:
3184 return DhNew4096();
3185 }
3186
3187 return NULL;
3188 }
3189
3190 // Release the DH object
IkeDhFreeCtx(DH_CTX * dh)3191 void IkeDhFreeCtx(DH_CTX *dh)
3192 {
3193 // Validate arguments
3194 if (dh == NULL)
3195 {
3196 return;
3197 }
3198
3199 DhFree(dh);
3200 }
3201
3202
3203
3204
3205
3206