f1564eaf4e87259a49dc1840459c1f99d313df51
[obnox/wireshark/wip.git] / epan / dissectors / packet-ipsec.c
1 /* packet-ipsec.c
2  * Routines for IPsec/IPComp packet disassembly
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25
26 /*
27
28 Addon: ESP Decryption and Authentication Checking
29
30 Frederic ROUDAUT (frederic.roudaut@free.fr)
31 Copyright 2006 Frederic ROUDAUT
32
33 - Decrypt ESP Payload for the following Algorithms defined in RFC 4305:
34
35 Encryption Algorithm
36 --------------------
37 NULL
38 TripleDES-CBC [RFC2451] : keylen 192 bits.
39 AES-CBC with 128-bit keys [RFC3602] : keylen 128 and 192/256 bits.
40 AES-CTR [RFC3686] : keylen 160/224/288 bits. The remaining 32 bits will be used as nonce.
41 DES-CBC [RFC2405] : keylen 64 bits
42
43 - Add ESP Payload Decryption support for the following Encryption Algorithms :
44 BLOWFISH-CBC : keylen 128 bits.
45 TWOFISH-CBC : keylen 128/256 bits.
46 CAST5-CBC :  keylen 128
47
48 - Check ESP Authentication for the following Algorithms defined in RFC 4305:
49
50 Authentication Algorithm
51 ------------------------
52 NULL
53 HMAC-SHA1-96 [RFC2404] : any keylen
54 HMAC-MD5-96 [RFC2403] : any keylen
55 AES-XCBC-MAC-96 [RFC3566] : Not available because no implementation found.
56
57 - Add ESP Authentication checking for the following Authentication Algorithm :
58 HMAC-SHA256 : any keylen
59 HMAC-RIPEMD160-96 [RFC2857] : any keylen
60 */
61
62 #ifdef HAVE_CONFIG_H
63 #include "config.h"
64 #endif
65
66 #include <stdio.h>
67
68 #include <string.h>
69 #include <glib.h>
70 #include <epan/packet.h>
71 #include <epan/emem.h>
72 #include "packet-ipsec.h"
73 #include <epan/addr_resolv.h>
74 #include <epan/ipproto.h>
75 #include <epan/prefs.h>
76
77 #include <ctype.h>
78
79 /* If you want to be able to decrypt or Check Authentication of ESP packets you MUST define this : */
80 #ifdef HAVE_LIBGCRYPT
81
82 #ifdef _WIN32
83 #include <winposixtype.h>
84 #endif /* _WIN32 */
85
86 #include <gcrypt.h>
87 #endif /* HAVE_LIBGCRYPT */
88
89
90 static int proto_ah = -1;
91 static int hf_ah_spi = -1;
92 static int hf_ah_iv = -1;
93 static int hf_ah_sequence = -1;
94 static int proto_esp = -1;
95 static int hf_esp_spi = -1;
96 static int hf_esp_iv = -1;
97 static int hf_esp_sequence = -1;
98 static int hf_esp_pad_len = -1;
99 static int hf_esp_protocol = -1;
100 static int proto_ipcomp = -1;
101 static int hf_ipcomp_flags = -1;
102 static int hf_ipcomp_cpi = -1;
103
104 static gint ett_ah = -1;
105 static gint ett_esp = -1;
106 static gint ett_ipcomp = -1;
107
108 static dissector_handle_t data_handle;
109
110 static dissector_table_t ip_dissector_table;
111
112 #ifdef  HAVE_LIBGCRYPT
113 /* Encryption algorithms defined in RFC 4305 */
114 #define IPSEC_ENCRYPT_NULL 0
115 #define IPSEC_ENCRYPT_3DES_CBC 1
116 #define IPSEC_ENCRYPT_AES_CBC 2
117 #define IPSEC_ENCRYPT_AES_CTR 3
118 #define IPSEC_ENCRYPT_DES_CBC 4
119 #define IPSEC_ENCRYPT_BLOWFISH_CBC 5
120 #define IPSEC_ENCRYPT_TWOFISH_CBC 6
121
122 /* Encryption algorithm defined in RFC 2144 */
123 #define IPSEC_ENCRYPT_CAST5_CBC 7
124
125 /* Authentication algorithms defined in RFC 4305 */
126 #define IPSEC_AUTH_NULL 0
127 #define IPSEC_AUTH_HMAC_SHA1_96 1
128 #define IPSEC_AUTH_HMAC_SHA256 2
129 #define IPSEC_AUTH_HMAC_MD5_96 3
130 #define IPSEC_AUTH_HMAC_RIPEMD160_96 4
131 #define IPSEC_AUTH_ANY_12BYTES 5
132 /* define IPSEC_AUTH_AES_XCBC_MAC_96 6 */
133 #endif
134
135 /* well-known algorithm number (in CPI), from RFC2409 */
136 #define IPCOMP_OUI      1       /* vendor specific */
137 #define IPCOMP_DEFLATE  2       /* RFC2394 */
138 #define IPCOMP_LZS      3       /* RFC2395 */
139 #define IPCOMP_MAX      4
140
141 #ifdef HAVE_LIBGCRYPT
142 #define IPSEC_IPV6_ADDR_LEN 128
143 #define IPSEC_IPV4_ADDR_LEN 32
144 #define IPSEC_STRLEN_IPV6 32
145 #define IPSEC_STRLEN_IPV4 8
146 #define IPSEC_SA_IPV4 1
147 #define IPSEC_SA_IPV6 2
148 #define IPSEC_SA_UNKNOWN -1
149 #define IPSEC_SA_WILDCARDS_ANY '*'
150 #define IPSEC_SA_SEPARATOR '|'
151 #define IPSEC_SA_ADDR_LEN_SEPARATOR '/'
152 #define IPSEC_IPV6_ADDR_MAX 40
153 #define IPSEC_IPV4_ADDR_MAX 16
154 #define IPSEC_SPI_LEN_MAX 10
155 #define IPSEC_TYP_LEN 4
156 #define IPSEC_ADDR_LEN_MAX 3
157
158 /* Number of Security Associations */
159 #define IPSEC_NB_SA 16
160 #endif
161
162 static const value_string cpi2val[] = {
163   { IPCOMP_OUI, "OUI" },
164   { IPCOMP_DEFLATE, "DEFLATE" },
165   { IPCOMP_LZS, "LZS" },
166   { 0, NULL },
167 };
168
169 struct newah {
170   guint8        ah_nxt;         /* Next Header */
171   guint8        ah_len;         /* Length of data + 1, in 32bit */
172   guint16       ah_reserve;     /* Reserved for future use */
173   guint32       ah_spi;         /* Security parameter index */
174   guint32       ah_seq;         /* Sequence number field */
175   /* variable size, 32bit bound*/       /* Authentication data */
176 };
177
178 struct newesp {
179   guint32       esp_spi;        /* ESP */
180   guint32       esp_seq;        /* Sequence number */
181   /*variable size*/             /* (IV and) Payload data */
182   /*variable size*/             /* padding */
183   /*8bit*/                      /* pad size */
184   /*8bit*/                      /* next header */
185   /*8bit*/                      /* next header */
186   /*variable size, 32bit bound*/        /* Authentication data */
187 };
188
189 struct ipcomp {
190   guint8 comp_nxt;      /* Next Header */
191   guint8 comp_flags;    /* Must be zero */
192   guint16 comp_cpi;     /* Compression parameter index */
193 };
194
195 #ifdef HAVE_LIBGCRYPT
196 /* SA Paramaters and SAD */
197 static guint g_esp_nb_sa = IPSEC_NB_SA;
198 static guint g_max_esp_nb_sa = 100;
199
200 typedef struct  {
201   const gchar *sa;
202   gint typ;
203   gchar *src;
204   gint src_len;
205   gchar *dst;
206   gint dst_len;
207   gchar *spi;
208   gint encryption_algo;
209   gint authentication_algo;
210   const gchar *encryption_key;
211   const gchar *authentication_key;
212   gboolean is_valid;
213 } g_esp_sa;
214
215 typedef struct  {
216   gint nb;
217   g_esp_sa table[IPSEC_NB_SA];
218 } g_esp_sa_database;
219
220 static g_esp_sa_database g_esp_sad;
221
222
223 /* Default ESP payload decode to off */
224 static gboolean g_esp_enable_encryption_decode = FALSE;
225
226 /* Default ESP payload Authentication Checking to off */
227 static gboolean g_esp_enable_authentication_check = FALSE;
228 #endif
229
230 /*
231    Default ESP payload heuristic decode to off
232    (only works if payload is NULL encrypted and ESP payload decode is off or payload is NULL encrypted
233    and the packet does not match a Security Association).
234 */
235 static gboolean g_esp_enable_null_encryption_decode_heuristic = FALSE;
236
237 /* Place AH payload in sub tree */
238 static gboolean g_ah_payload_in_subtree = FALSE;
239
240 #ifndef offsetof
241 #define offsetof(type, member)  ((size_t)(&((type *)0)->member))
242 #endif
243
244
245
246
247 /*
248    Name : static int get_ipv6_suffix(char* ipv6_suffix, char *ipv6_address)
249    Description : Get the extended IPv6 Suffix of an IPv6 Address
250    Return : Return the number of char of the IPv6 address suffix parsed
251    Params:
252       - char *ipv6_address : the valid ipv6 address to parse in char *
253       - char *ipv6_suffix : the ipv6 suffix associated in char *
254
255       ex: if IPv6 address is "3ffe::1" the IPv6 suffix will be "0001" and the function will return 3
256 */
257 #ifdef HAVE_LIBGCRYPT
258 static int get_ipv6_suffix(char* ipv6_suffix, char *ipv6_address)
259 {
260   char suffix[IPSEC_STRLEN_IPV6 + 1];
261   int cpt = 0;
262   int cpt_suffix = 0;
263   int cpt_seg = 0;
264   int j =0;
265   int ipv6_len = 0;
266   gboolean found = FALSE;
267
268   ipv6_len = strlen(ipv6_address);
269   if(ipv6_len  == 0)
270     {
271       /* Found a suffix */
272       found = TRUE;
273     }
274   else
275     {
276       while ( (cpt_suffix < IPSEC_STRLEN_IPV6) && (ipv6_len - cpt -1 >= 0) && (found == FALSE))
277         {
278           if(ipv6_address[ipv6_len - cpt - 1] == ':')
279             {
280               /* Add some 0 to the prefix; */
281               for(j = cpt_seg; j < 4; j++)
282                 {
283                   suffix[IPSEC_STRLEN_IPV6 -1 -cpt_suffix] = '0';
284                   cpt_suffix ++;
285                 }
286               cpt_seg = 0;
287
288               if(ipv6_len - cpt - 1 == 0)
289                 {
290                   /* Found a suffix */
291                   found = TRUE;
292                 }
293               else
294                 if(ipv6_address[ipv6_len - cpt - 2] == ':')
295                   {
296                     /* found a suffix */
297                     cpt +=2;
298                     found = TRUE;
299                   }
300
301                 else
302                   {
303                     cpt++;
304                   }
305             }
306           else
307             {
308               suffix[IPSEC_STRLEN_IPV6 -1 -cpt_suffix] = toupper(ipv6_address[ipv6_len - cpt - 1]);
309               cpt_seg ++;
310               cpt_suffix ++;
311               cpt++;
312             }
313         }
314
315       if(cpt_suffix % 4 != 0)
316         {
317           for(j = cpt_seg; j < 4; j++)
318             {
319               suffix[IPSEC_STRLEN_IPV6 -1 -cpt_suffix] = '0';
320               cpt_suffix ++;
321             }
322           cpt_seg = 0;
323         }
324
325     }
326
327   for(j = 0 ; j < cpt_suffix ; j ++)
328     {
329       suffix[j] = suffix[j + IPSEC_STRLEN_IPV6 - cpt_suffix] ;
330     }
331
332   suffix[j] = '\0';
333   memcpy(ipv6_suffix,suffix,j + 1);
334   return cpt;
335 }
336 #endif
337
338
339
340 /*
341    Name : static int get_full_ipv6_addr(char* ipv6_addr_expanded, char *ipv6_addr)
342    Description : Get the extended IPv6 Address of an IPv6 Address
343    Return : Return the remaining number of char of the IPv6 address parsed
344    Params:
345       - char *ipv6_addr : the valid ipv6 address to parse in char *
346       - char *ipv6_addr_expansed : the expanded ipv6 address associated in char *
347
348       ex: if IPv6 address is "3ffe::1" the IPv6 expanded address will be "3FFE0000000000000000000000000001" and the function will return 0
349           if IPV6 address is "3ffe::*" the IPv6 expanded address will be "3FFE000000000000000000000000****" and the function will return 0
350 */
351 #ifdef HAVE_LIBGCRYPT
352 static int
353 get_full_ipv6_addr(char* ipv6_addr_expanded, char *ipv6_addr)
354 {
355   char suffix[IPSEC_STRLEN_IPV6 + 1];
356   char prefix[IPSEC_STRLEN_IPV6 + 1];
357   char *prefix_addr;
358
359   int suffix_cpt = 0;
360   int suffix_len = 0;
361   int prefix_remaining = 0;
362   int prefix_len = 0;
363   int j = 0;
364
365
366   if((ipv6_addr == NULL) || (strcmp(ipv6_addr, "") == 0))  return -1;
367   if((strlen(ipv6_addr) == 1) && (ipv6_addr[0] == IPSEC_SA_WILDCARDS_ANY))
368     {
369       for(j = 0; j <= IPSEC_STRLEN_IPV6; j++)
370         {
371           ipv6_addr_expanded[j] = IPSEC_SA_WILDCARDS_ANY;
372         }
373       ipv6_addr_expanded[IPSEC_STRLEN_IPV6] = '\0';
374       return 0;
375     }
376
377   suffix_cpt = get_ipv6_suffix(suffix,ipv6_addr);
378   suffix_len = strlen(suffix);
379
380   if(suffix_len <  IPSEC_STRLEN_IPV6)
381     {
382       prefix_addr = ep_alloc(strlen(ipv6_addr) - suffix_cpt + 1);
383       memcpy(prefix_addr,ipv6_addr,strlen(ipv6_addr) - suffix_cpt);
384       prefix_addr[strlen(ipv6_addr) - suffix_cpt] = '\0';
385       prefix_remaining = get_ipv6_suffix(prefix,prefix_addr);
386       prefix_len = strlen(prefix);
387       memcpy(ipv6_addr_expanded,prefix,prefix_len);
388     }
389
390
391   for(j = 0; j <= IPSEC_STRLEN_IPV6 - prefix_len - suffix_len; j++)
392     {
393       ipv6_addr_expanded[j + prefix_len] = '0';
394     }
395
396   memcpy(ipv6_addr_expanded + IPSEC_STRLEN_IPV6 - suffix_len, suffix,suffix_len + 1);
397
398   if(suffix_len < IPSEC_STRLEN_IPV6)
399     return (prefix_len - prefix_remaining);
400   else
401     return strlen(ipv6_addr) - suffix_cpt;
402 }
403 #endif
404
405
406
407 /*
408    Name : static gboolean get_full_ipv4_addr(char* ipv4_addr_expanded, char *ipv4_addr)
409    Description : Get the extended IPv4 Address of an IPv4 Address
410    Return : Return true if it can derive an IPv4 address. It does not mean that the previous one was valid.
411    Params:
412       - char *ipv4_addr : the valid ipv4 address to parse in char *
413       - char *ipv4_addr_expansed : the expanded ipv4 address associated in char *
414
415       ex: if IPv4 address is "190.*.*.1" the IPv4 expanded address will be "BE****01" and the function will return 0
416           if IPv4 address is "*" the IPv4 expanded address will be "********" and the function will return 0
417 */
418 #ifdef HAVE_LIBGCRYPT
419 static gboolean
420 get_full_ipv4_addr(char* ipv4_addr_expanded, char *ipv4_addr)
421 {
422   char addr_byte_string_tmp[4];
423   char addr_byte_string[4];
424
425   guint addr_byte = 0;
426   guint i = 0;
427   guint j = 0;
428   guint k = 0;
429   guint cpt = 0;
430   gboolean done_flag = FALSE;
431
432   if((ipv4_addr == NULL) || (strcmp(ipv4_addr, "") == 0))  return done_flag;
433
434   if((strlen(ipv4_addr) == 1) && (ipv4_addr[0] == IPSEC_SA_WILDCARDS_ANY))
435     {
436       for(i = 0; i <= IPSEC_STRLEN_IPV4; i++)
437         {
438           ipv4_addr_expanded[i] = IPSEC_SA_WILDCARDS_ANY;
439         }
440       ipv4_addr_expanded[IPSEC_STRLEN_IPV4] = '\0';
441       done_flag = TRUE;
442     }
443
444   else {
445     j = 0;
446     cpt = 0;
447     k = 0;
448     while((done_flag == FALSE) && (j <= strlen(ipv4_addr)) && (cpt < IPSEC_STRLEN_IPV4))
449       {
450         if(j == strlen(ipv4_addr))
451           {
452             addr_byte_string_tmp[k] = '\0';
453             if((strlen(addr_byte_string_tmp) == 1) && (addr_byte_string_tmp[0] == IPSEC_SA_WILDCARDS_ANY))
454               {
455                 for(i = 0; i < 2; i++)
456                   {
457                     ipv4_addr_expanded[cpt] = IPSEC_SA_WILDCARDS_ANY;
458                     cpt ++;
459                   }
460               }
461             else
462               {
463                 sscanf(addr_byte_string_tmp,"%u",&addr_byte);
464                 if(addr_byte < 16) g_snprintf(addr_byte_string,4,"0%X",addr_byte);
465                 else g_snprintf(addr_byte_string,4,"%X",addr_byte);
466                 for(i = 0; i < strlen(addr_byte_string); i++)
467                   {
468                     ipv4_addr_expanded[cpt] = addr_byte_string[i];
469                     cpt ++;
470                   }
471               }
472             done_flag = TRUE;
473           }
474
475         else if(ipv4_addr[j] == '.')
476           {
477             addr_byte_string_tmp[k] = '\0';
478             if((strlen(addr_byte_string_tmp) == 1) && (addr_byte_string_tmp[0] == IPSEC_SA_WILDCARDS_ANY))
479               {
480                 for(i = 0; i < 2; i++)
481                   {
482                     ipv4_addr_expanded[cpt] = IPSEC_SA_WILDCARDS_ANY;
483                     cpt ++;
484                   }
485               }
486             else
487               {
488                 sscanf(addr_byte_string_tmp,"%u",&addr_byte);
489                 if(addr_byte < 16) g_snprintf(addr_byte_string,4,"0%X",addr_byte);
490                 else g_snprintf(addr_byte_string,4,"%X",addr_byte);
491                 for(i = 0; i < strlen(addr_byte_string); i++)
492                   {
493                     ipv4_addr_expanded[cpt] = addr_byte_string[i];
494                     cpt ++;
495                   }
496               }
497             k = 0;
498             j++;
499           }
500         else
501           {
502             if(k >= 3)
503               {
504                 /* Incorrect IPv4 Address. Erase previous Values in the Byte. (LRU mechanism) */
505                 addr_byte_string_tmp[0] = ipv4_addr[j];
506                 k = 1;
507                 j++;
508               }
509             else
510               {
511                 addr_byte_string_tmp[k] = ipv4_addr[j];
512                 k++;
513                 j++;
514               }
515           }
516
517       }
518
519     ipv4_addr_expanded[cpt] = '\0';
520   }
521
522   return done_flag;
523 }
524 #endif
525
526
527
528 /*
529    Name : static gboolean esp_sa_parse_ipv6addr(const gchar *sa, guint index_start, gchar **pt_ipv6addr, guint *index_end)
530    Description : Get the IPv6 address of a Security Association
531    Return : Return true if it can get an address. It does not mean that the address is valid.
532    Params:
533       - char *sa : the Security Association in char *
534       - guint index_start : the index to start to find the address
535       - gchar **pt_ipv6addr : the address found. The Allocation is done here !
536       - guint *index_end : the last index of the address
537 */
538 #ifdef HAVE_LIBGCRYPT
539 static gboolean
540 esp_sa_parse_ipv6addr(const gchar *sa, guint index_start, gchar **pt_ipv6addr, guint *index_end)
541 {
542   guint cpt = 0;
543
544   char addr_string[IPSEC_IPV6_ADDR_MAX + 1];
545   gboolean done_flag = FALSE;
546
547   if((sa == NULL) || (strcmp(sa, "") == 0))
548     return FALSE;
549
550   /* Get Address */
551   while(((cpt + index_start) < strlen(sa)) && (done_flag == FALSE) && (cpt <= IPSEC_IPV6_ADDR_MAX))
552     {
553       if((sa[cpt + index_start] == IPSEC_SA_SEPARATOR)  || (sa[cpt + index_start] == IPSEC_SA_ADDR_LEN_SEPARATOR))
554         {
555           if(cpt == 0) return FALSE;
556           *index_end = cpt + index_start;
557           addr_string[cpt] = '\0';
558           done_flag = TRUE;
559         }
560
561       else
562         {
563           if((cpt >= IPSEC_IPV6_ADDR_MAX - 1) && ((cpt  + index_start) < strlen(sa)) && (sa[cpt + index_start + 1] != IPSEC_SA_ADDR_LEN_SEPARATOR) && (sa[cpt + index_start + 1] != IPSEC_SA_SEPARATOR))
564             return FALSE;
565           addr_string[cpt] = toupper(sa[cpt + index_start]);
566           cpt ++;
567         }
568     }
569
570   if(done_flag)
571     {
572       *pt_ipv6addr = (gchar *)g_malloc((strlen(addr_string) + 1) * sizeof(gchar));
573       memcpy(*pt_ipv6addr,addr_string,strlen(addr_string) + 1);
574     }
575
576   return done_flag;
577 }
578 #endif
579
580
581 /*
582    Name : static gboolean esp_sa_parse_ipv4addr(const gchar *sa, guint index_start, gchar **pt_ipv4addr, guint *index_end)
583    Description : Get the IPv4 address of a Security Association
584    Return : Return true if it can get an address. It does not mean that the address is valid.
585    Params:
586       - char *sa : the Security Association in char *
587       - guint index_start : the index to start to find the address
588       - gchar **pt_ipv4addr : the address found. The Allocation is done here !
589       - guint *index_end : the last index of the address
590 */
591 #ifdef HAVE_LIBGCRYPT
592 static gboolean
593 esp_sa_parse_ipv4addr(const gchar *sa, guint index_start, gchar **pt_ipv4addr, guint *index_end)
594 {
595   guint cpt = 0;
596
597   char addr_string[IPSEC_IPV4_ADDR_MAX + 1];
598   gboolean done_flag = FALSE;
599
600   if((sa == NULL) || (strcmp(sa, "") == 0))
601     return FALSE;
602
603   /* Get Address */
604   while(((cpt + index_start) < strlen(sa)) && (done_flag == FALSE) && (cpt <= IPSEC_IPV4_ADDR_MAX))
605     {
606       if((sa[cpt + index_start] == IPSEC_SA_SEPARATOR)  || (sa[cpt + index_start] == IPSEC_SA_ADDR_LEN_SEPARATOR))
607         {
608           if(cpt == 0) return FALSE;
609           *index_end = cpt + index_start;
610           addr_string[cpt] = '\0';
611           done_flag = TRUE;
612         }
613
614       else
615         {
616           if((cpt == IPSEC_IPV4_ADDR_MAX - 1) && ((cpt  + index_start) < strlen(sa)) && (sa[cpt + index_start + 1] != IPSEC_SA_ADDR_LEN_SEPARATOR) && (sa[cpt + index_start + 1] != IPSEC_SA_SEPARATOR))
617             return FALSE;
618           addr_string[cpt] = toupper(sa[cpt + index_start]);
619           cpt ++;
620         }
621     }
622
623   if(done_flag)
624     {
625       *pt_ipv4addr = (gchar *)g_malloc((strlen(addr_string) + 1) * sizeof(gchar));
626       memcpy(*pt_ipv4addr,addr_string,strlen(addr_string) + 1);
627     }
628
629   return done_flag;
630 }
631 #endif
632
633
634 /*
635    Name : static gboolean esp_sa_parse_spi(const gchar *sa, guint index_start, gchar **pt_spi, guint *index_end)
636    Description : Get the SPI of a Security Association
637    Return : Return true if it can get a SPI. It does not mean that the SPI is valid.
638    Params:
639       - char *sa : the Security Association in char *
640       - guint index_start : the index to start to find the spi
641       - gchar **pt_spi : the spi found. The Allocation is done here !
642       - guint *index_end : the last index of the address
643 */
644 #ifdef HAVE_LIBGCRYPT
645 static gboolean
646 esp_sa_parse_spi(const gchar *sa, guint index_start, gchar **pt_spi, guint *index_end)
647 {
648   guint cpt = 0;
649   guint32 spi = 0;
650   guint i = 0;
651
652   gchar spi_string[IPSEC_SPI_LEN_MAX + 1];
653   gchar spi_string_tmp[IPSEC_SPI_LEN_MAX + 1];
654   gboolean done_flag = FALSE;
655
656   if((sa == NULL) || (strcmp(sa, "") == 0))  return FALSE;
657
658   while(((cpt + index_start) < strlen(sa)) && (cpt < IPSEC_SPI_LEN_MAX))
659     {
660       spi_string[cpt] = toupper(sa[cpt + index_start]);
661       cpt ++;
662     }
663
664   if(cpt == 0)
665     done_flag = FALSE;
666   else
667     {
668       spi_string[cpt] = '\0';
669       if((cpt >= 2) &&
670          (spi_string[0] == '0') &&
671          (spi_string[1] == 'X'))
672         {
673           for(i = 0; i <= cpt - 2; i++) spi_string_tmp[i] = spi_string[i+2];
674           sscanf(spi_string_tmp,"%x",&spi);
675           g_snprintf(spi_string, IPSEC_SPI_LEN_MAX, "%i", spi);
676         }
677
678       *index_end = cpt + index_start - 1;
679       *pt_spi = (gchar *)g_malloc((strlen(spi_string) + 1) * sizeof(gchar));
680       memcpy(*pt_spi, spi_string, strlen(spi_string) + 1);
681
682       done_flag = TRUE;
683     }
684
685   return done_flag;
686 }
687 #endif
688
689
690 /*
691    Name : static gboolean esp_sa_parse_protocol_typ(const gchar *sa, guint index_start, gint *pt_protocol_typ, guint *index_end)
692    Description : Get the Protocol Type of a Security Association
693    Return : Return true if it can get a valid protocol type.
694    Params:
695       - char *sa : the Security Association in char *
696       - guint index_start : the index to start to find the protocol type
697       - gint *pt_protocol_typ : the protocol type found. Either IPv4 or IPv6 (IPSEC_SA_IPV4, IPSEC_SA_IPV6)
698       - guint *index_end : the last index of the protocol type
699 */
700 #ifdef HAVE_LIBGCRYPT
701 static gboolean
702 esp_sa_parse_protocol_typ(const gchar *sa, guint index_start, gint *pt_protocol_typ, guint *index_end)
703 {
704   gboolean done_flag = FALSE;
705
706   *pt_protocol_typ = IPSEC_SA_UNKNOWN;
707   if((sa == NULL) || (strlen(&sa[index_start]) <= IPSEC_TYP_LEN) ||
708       (sa[index_start + IPSEC_TYP_LEN] != IPSEC_SA_SEPARATOR))
709     return FALSE;
710
711   if(g_ascii_strncasecmp(&sa[index_start], "IPV6", IPSEC_TYP_LEN) == 0)
712     {
713       *pt_protocol_typ = IPSEC_SA_IPV6;
714       done_flag = TRUE;
715     }
716   else if (g_ascii_strncasecmp(&sa[index_start], "IPV4", IPSEC_TYP_LEN) == 0)
717     {
718       *pt_protocol_typ = IPSEC_SA_IPV4;
719       done_flag = TRUE;
720     }
721   else
722     {
723       *pt_protocol_typ = IPSEC_SA_UNKNOWN;
724       done_flag = FALSE;
725     }
726
727   *index_end = IPSEC_TYP_LEN + index_start + 1;
728
729 /* g_warning("For %s returning %d, %c, %d", sa, *pt_protocol_typ, sa[*index_end], *index_end); */
730   return done_flag;
731 }
732 #endif
733
734
735 /*
736    Name : static gboolean esp_sa_parse_addr_len(const gchar *sa, guint index_start, guint *len, guint *index_end)
737    Description : Get the Address Length of an address (IPv4/IPv6)
738    Return : Return true if it can get an Address Length. It does not mean that the length is valid
739    Params:
740       - char *sa : the Security Association in char *
741       - guint index_start : the index to start to find the length
742       - guint *len : the address length found. If none -1 is given.
743       - guint *index_end : the last index of the address length in the SA
744 */
745 #ifdef HAVE_LIBGCRYPT
746 static gboolean
747 esp_sa_parse_addr_len(const gchar *sa, guint index_start, gint *len, guint *index_end)
748 {
749   guint cpt = 0;
750   char len_string[IPSEC_ADDR_LEN_MAX + 1];
751   gboolean done_flag = FALSE;
752
753   *len = -1;
754
755   if((sa == NULL) || (strcmp(sa, "") == 0))  return FALSE;
756
757   if(sa[index_start] == IPSEC_SA_SEPARATOR)
758     {
759       *index_end = index_start + 1;
760       *len = -1;
761       done_flag = TRUE;
762     }
763
764   else if(sa[index_start] == IPSEC_SA_ADDR_LEN_SEPARATOR)
765     {
766       cpt ++;
767       while(((cpt + index_start) < strlen(sa)) && (done_flag == FALSE) && (cpt < IPSEC_ADDR_LEN_MAX))
768         {
769           if(sa[cpt + index_start] == IPSEC_SA_SEPARATOR)
770             {
771               if(cpt == 1)
772                 {
773                   *index_end = index_start + cpt + 1;
774                   *len = -1;
775                   done_flag = TRUE;
776
777                 }
778               else
779                 {
780                   *index_end = cpt + index_start + 1;
781                   len_string[cpt - 1] = '\0';
782                   *len = atoi(len_string);
783                   done_flag = TRUE;
784                 }
785             }
786
787           else
788             {
789               if((cpt == IPSEC_ADDR_LEN_MAX) && ((cpt  + index_start) < strlen(sa)) && (sa[cpt + index_start + 1] != IPSEC_SA_ADDR_LEN_SEPARATOR) && (sa[cpt + index_start + 1] != IPSEC_SA_SEPARATOR))
790                 return FALSE;
791               len_string[cpt -1] = sa[cpt + index_start];
792               cpt ++;
793             }
794         }
795     }
796
797   return done_flag;
798 }
799 #endif
800
801
802 /*
803    Name : esp_sa_remove_white(const gchar *sa, gchar **sa_bis)
804    Description : Remote White Space in a SA
805                  Parse a Security Association and give the SA without space.
806                  There is no need to allocate memory before the call. All is done !
807
808    Return : Void
809    Params:
810       - char *sa : the Security Association in char *
811       - char **sa_bis : the Security Association in char * without white space
812 */
813
814 #ifdef HAVE_LIBGCRYPT
815 static void
816 esp_sa_remove_white(const gchar *sa, gchar **sa_bis)
817 {
818   guint i = 0;
819   guint cpt = 0;
820   gchar *sa_tmp;
821
822   if((sa == NULL) || (strcmp(sa, "") == 0))
823     {
824       *sa_bis = NULL;
825       return;
826     }
827
828   sa_tmp = ep_alloc(strlen(sa) + 1);
829   for(i = 0; i < strlen(sa); i++)
830     {
831
832       if((sa[i] != ' ') && (sa[i] != '\t'))
833         {
834           sa_tmp[cpt] = sa[i];
835           cpt ++;
836         }
837     }
838   sa_tmp[cpt] = '\0';
839
840   /* XXX - Should this be se_allocated instead? */
841   *sa_bis = (gchar *)g_malloc((cpt +1) * sizeof(gchar));
842   memcpy(*sa_bis,sa_tmp,cpt);
843   (*sa_bis)[cpt] = '\0';
844 }
845 #endif
846
847
848
849 /*
850    Name : static goolean esp_sa_parse_filter(const gchar *sa, gint *pt_protocol_typ, gchar **pt_src, gint *pt_src_len,  gchar **pt_dst, gint *pt_dst_len,  gchar **pt_spi)
851    Description : Parse a Security Association.
852                  Parse a Security Association and give the correspondings parameter : SPI, Source, Destination, Source Length, Destination Length, Protocol Type
853                  There is no need to allocate memory before the call. All is done !
854                  If the SA is not correct FALSE is returned.
855                  This security association Must have the following format :
856
857                  "Type/Source IPv6 or IPv4/Destination IPv6 or IPv4/SPI"
858
859                  Where Type is either IPv4 either IPv6
860                  - source And destination Must have a correct IPv6/IPv4 Address Format.
861                  - SPI is an integer on 4 bytes.
862                  Any element may use the following wildcard :
863
864                  "*" : for an IPv4 Address, it allows all bytes until the next ".". For IPv6 it is the same until the next ":".
865                  For SPI it allows any SPI.
866
867                  ex:
868                  a) IPV4/131.254.200.* /131.254.*.123/ *
869                  b) IPv6/3ffe:*:1/2001::200:* / 456
870
871    Return : Return true if the parsing is correct.
872    Params:
873       - char *sa : the Security Association in char *
874       - gint *pt_protocol_typ : the protocol type
875       - gchar **pt_src : the source address
876       - gint *pt_src_len : the source address length
877       - gchar **pt_dst : the destination address
878       - gint *pt_dst_len : the destination address length
879       - gchar **pt_spi : the spi of the SA
880 */
881 #ifdef HAVE_LIBGCRYPT
882 static gboolean
883 esp_sa_parse_filter(const gchar *sa_src, gint *pt_protocol_typ, gchar **pt_src, gint *pt_src_len,  gchar **pt_dst, gint *pt_dst_len,  gchar **pt_spi)
884 {
885   gchar *src_string;
886   gchar *dst_string;
887   gchar *spi_string;
888   gint src_len = 0;
889   gint dst_len = 0;
890   gchar *src;
891   gchar *dst;
892   gchar *sa;
893
894   guint index_end1 = 0;
895   guint index_end2 = 0;
896
897   esp_sa_remove_white(sa_src,&sa);
898   if(!esp_sa_parse_protocol_typ(sa, 0, pt_protocol_typ, &index_end1)) return FALSE;
899
900   switch(*pt_protocol_typ)
901     {
902
903     case IPSEC_SA_IPV4 :
904       {
905         if(esp_sa_parse_ipv4addr(sa, index_end1, &src_string, &index_end2))
906           {
907             if(esp_sa_parse_addr_len(sa, index_end2, pt_src_len, &index_end1))
908               {
909                 if(esp_sa_parse_ipv4addr(sa, index_end1, &dst_string, &index_end2))
910                   {
911                     if(esp_sa_parse_addr_len(sa, index_end2, pt_dst_len, &index_end1))
912                       {
913                         if(!esp_sa_parse_spi(sa, index_end1, &spi_string, &index_end2))
914                           {
915                             g_free(src_string);
916                             g_free(dst_string);
917                             g_free(spi_string);
918                             g_free(sa);
919                             return FALSE;
920                           }
921                       }
922                     else
923                       {
924                         g_free(src_string);
925                         g_free(dst_string);
926                         g_free(sa);
927                         return FALSE;
928                       }
929                   }
930                 else
931                   {
932                     g_free(src_string);
933                     g_free(sa);
934                     return FALSE;
935                   }
936               }
937             else
938               {
939                 g_free(src_string);
940                 g_free(sa);
941                 return FALSE;
942               }
943           }
944         else
945           {
946             g_free(sa);
947             return FALSE;
948           }
949
950
951         /* Fill the Source Filter */
952         src = (gchar *)g_malloc((IPSEC_STRLEN_IPV4 + 1) * sizeof(gchar));
953         get_full_ipv4_addr(src, src_string);
954         g_free(src_string);
955
956         /* Fill the Destination Filter */
957         dst = (gchar *)g_malloc((IPSEC_STRLEN_IPV4 + 1) * sizeof(gchar));
958         get_full_ipv4_addr(dst, dst_string);
959         g_free(dst_string);
960
961         g_free(sa);
962         break;
963       }
964
965     case IPSEC_SA_IPV6 :
966       {
967         if(esp_sa_parse_ipv6addr(sa, index_end1, &src_string, &index_end2))
968           {
969             if(esp_sa_parse_addr_len(sa, index_end2, &src_len, &index_end1))
970               {
971                 if(esp_sa_parse_ipv6addr(sa, index_end1, &dst_string, &index_end2))
972                   {
973                     if(esp_sa_parse_addr_len(sa, index_end2, &dst_len, &index_end1))
974                       {
975                         if(!esp_sa_parse_spi(sa, index_end1, &spi_string, &index_end2))
976                           {
977                             g_free(src_string);
978                             g_free(dst_string);
979                             g_free(spi_string);
980                             g_free(sa);
981                             return FALSE;
982                           }
983                       }
984                     else
985                       {
986                         g_free(src_string);
987                         g_free(dst_string);
988                         g_free(sa);
989                         return FALSE;
990                       }
991                   }
992                 else
993                   {
994                     g_free(src_string);
995                     g_free(sa);
996                     return FALSE;
997                   }
998               }
999             else
1000               {
1001                 g_free(src_string);
1002                 g_free(sa);
1003                 return FALSE;
1004               }
1005           }
1006         else
1007           {
1008             g_free(sa);
1009             return FALSE;
1010           }
1011
1012         /* Fill the Source Filter */
1013         src = (gchar *)g_malloc((IPSEC_STRLEN_IPV6 + 1) * sizeof(gchar));
1014         get_full_ipv6_addr(src, src_string);
1015         g_free(src_string);
1016
1017         /* Fill the Destination Filter */
1018         dst = (gchar *)g_malloc((IPSEC_STRLEN_IPV6 + 1) * sizeof(gchar));
1019         get_full_ipv6_addr(dst, dst_string);
1020         g_free(dst_string);
1021
1022         g_free(sa);
1023         break;
1024       }
1025
1026     default:
1027       {
1028         g_free(sa);
1029         return FALSE;
1030       }
1031     }
1032
1033   *pt_spi = spi_string;
1034   *pt_src = src;
1035   *pt_dst = dst;
1036
1037   return TRUE;
1038 }
1039 #endif
1040
1041
1042 /*
1043    Name : static goolean filter_address_match(gchar *address, gchar *filter, gint len, gint typ)
1044    Description : check the matching of an address with a filter
1045    Return : Return TRUE if the filter and the address match
1046    Params:
1047       - gchar *address : the address to check
1048       - gchar *filter : the filter
1049       - gint len : the len of the address that should match the filter
1050       - gint typ : the Address type : either IPv6 or IPv4 (IPSEC_SA_IPV6, IPSEC_SA_IPV4)
1051 */
1052 #ifdef HAVE_LIBGCRYPT
1053 static gboolean
1054 filter_address_match(gchar *address, gchar *filter, gint len, gint typ)
1055 {
1056   gint i = 0;
1057   guint filter_tmp = 0;
1058   guint addr_tmp = 0;
1059   char filter_string_tmp[3];
1060   char addr_string_tmp[3];
1061
1062   if(strlen(address) != strlen(filter)) return FALSE;
1063   /* No length specified */
1064   if((len < 0) || ((typ == IPSEC_SA_IPV6) && (len > IPSEC_IPV6_ADDR_LEN)) || ((typ == IPSEC_SA_IPV4) && (len > IPSEC_IPV4_ADDR_LEN)))
1065     {
1066       for(i = 0; (guint)i < strlen(address); i++)
1067         {
1068           if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != address[i])) return FALSE;
1069         }
1070       return TRUE;
1071     }
1072   else
1073     {
1074       for(i = 0; i < (len/ 4); i++)
1075         {
1076           if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != address[i])) return FALSE;
1077         }
1078
1079       if(filter[i] == IPSEC_SA_WILDCARDS_ANY) return TRUE;
1080       else if (len  % 4 != 0)
1081         {
1082           /* take the end of the Netmask/Prefixlen into account */
1083           filter_string_tmp[0] = filter[i];
1084           filter_string_tmp[1] = '\0';
1085           addr_string_tmp[0] = address[i];
1086           addr_string_tmp[1] = '\0';
1087
1088           sscanf(filter_string_tmp,"%x",&filter_tmp);
1089           sscanf(addr_string_tmp,"%x",&addr_tmp);
1090           for(i = 0; i < (len % 4); i++)
1091             {
1092               if(((filter_tmp >> (4 -i -1)) & 1) != ((addr_tmp >> (4 -i -1)) & 1))
1093                 {
1094                   return FALSE;
1095                 }
1096             }
1097         }
1098     }
1099
1100   return TRUE;
1101
1102 }
1103 #endif
1104
1105
1106
1107 /*
1108    Name : static goolean filter_spi_match(gchar *spi, gchar *filter)
1109    Description : check the matching of a spi with a filter
1110    Return : Return TRUE if the filter match the spi.
1111    Params:
1112       - gchar *spi : the spi to check
1113       - gchar *filter : the filter
1114 */
1115 #ifdef HAVE_LIBGCRYPT
1116 static gboolean
1117 filter_spi_match(gchar *spi, gchar *filter)
1118 {
1119   guint i = 0;
1120
1121   if((strlen(filter) == 1) && (filter[0] == IPSEC_SA_WILDCARDS_ANY)) {
1122     return TRUE;
1123   }
1124
1125   else if(strlen(spi) != strlen(filter)) {
1126     return FALSE;
1127   }
1128
1129   for(i = 0; i < strlen(filter); i++)
1130     {
1131       if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != spi[i])) return FALSE;
1132     }
1133
1134   return TRUE;
1135 }
1136 #endif
1137
1138
1139 /*
1140    Name : static gint compute_ascii_key(gchar **ascii_key, gchar *key)
1141    Description : Allocate memory for the key and transform the key if it is hexadecimal
1142    Return : Return the key length
1143    Params:
1144       - gchar **ascii_key : the resulting ascii key allocated here
1145       - gchar *key : the key to compute
1146 */
1147 #ifdef HAVE_LIBGCRYPT
1148 static gint
1149 compute_ascii_key(gchar **ascii_key, gchar *key)
1150 {
1151   guint key_len = 0;
1152   gint hex_digit;
1153   guchar key_byte;
1154   guint i, j;
1155
1156   if(key != NULL)
1157     {
1158       if((strlen(key) > 2) && (key[0] == '0') && ((key[1] == 'x') || (key[1] == 'X')))
1159         {
1160           /*
1161            * Key begins with "0x" or "0X"; skip that and treat the rest
1162            * as a sequence of hex digits.
1163            */
1164           i = 2;        /* first character after "0[Xx]" */
1165           j = 0;
1166           if(strlen(key) %2  == 1)
1167             {
1168               /*
1169                * Key has an odd number of characters; we act as if the
1170                * first character had a 0 in front of it, making the
1171                * number of characters even.
1172                */
1173               key_len = (strlen(key) - 2) / 2 + 1;
1174               *ascii_key = (gchar *) g_malloc ((key_len + 1)* sizeof(gchar));
1175               hex_digit = g_ascii_xdigit_value(key[i]);
1176               i++;
1177               if (hex_digit == -1)
1178                 {
1179                   g_free(*ascii_key);
1180                   *ascii_key = NULL;
1181                   return -1;    /* not a valid hex digit */
1182                 }
1183               (*ascii_key)[j] = (guchar)hex_digit;
1184               j++;
1185              } 
1186            else 
1187              {
1188                /*
1189                 * Key has an even number of characters, so we treat each
1190                 * pair of hex digits as a single byte value.
1191                 */
1192                key_len = (strlen(key) - 2) / 2;
1193               *ascii_key = (gchar *) g_malloc ((key_len + 1)* sizeof(gchar));
1194              }
1195              
1196            while(i < (strlen(key) -1))
1197              {
1198                hex_digit = g_ascii_xdigit_value(key[i]);
1199                i++;
1200                if (hex_digit == -1)
1201                  {
1202                    g_free(*ascii_key);
1203                    *ascii_key = NULL;
1204                    return -1;   /* not a valid hex digit */
1205                  }
1206                key_byte = ((guchar)hex_digit) << 4;
1207                hex_digit = g_ascii_xdigit_value(key[i]);
1208                i++;
1209                if (hex_digit == -1)
1210                  {
1211                    g_free(*ascii_key);
1212                    *ascii_key = NULL;
1213                    return -1;   /* not a valid hex digit */
1214                  }
1215                key_byte |= (guchar)hex_digit;
1216                (*ascii_key)[j] = key_byte;
1217                j++;
1218              }
1219            (*ascii_key)[j] = '\0';
1220         }
1221
1222       else if((strlen(key) == 2) && (key[0] == '0') && ((key[1] == 'x') || (key[1] == 'X')))
1223         {
1224           return 0;
1225         }
1226
1227       else
1228         {
1229           key_len = strlen(key);
1230           *ascii_key = (gchar *) g_malloc ((key_len + 1)* sizeof(gchar));
1231           memcpy(*ascii_key, key, key_len + 1);
1232         }
1233     }
1234
1235   return key_len;
1236 }
1237 #endif
1238
1239
1240 /*
1241    Name : static goolean get_esp_sa(g_esp_sa_database *sad, gint protocol_typ, gchar *src,  gchar *dst,  gint spi,
1242            gint *entry_index
1243            gint *encryption_algo,
1244            gint *authentication_algo,
1245            gchar **encryption_key,
1246            guint *encryption_key_len,
1247            gchar **authentication_key,
1248            guint *authentication_key_len
1249
1250    Description : Give Encryption Algo, Key and Authentification Algo for a Packet if a corresponding SA is available in a Security Association database
1251    Return: If the SA is not present, FALSE is then returned.
1252    Params:
1253       - g_esp_sa_database *sad : the Security Association Database
1254       - gint *pt_protocol_typ : the protocol type
1255       - gchar *src : the source address
1256       - gchar *dst : the destination address
1257       - gchar *spi : the spi of the SA
1258       - gint *entry_index : the index of the SA that matches
1259       - gint *encryption_algo : the Encryption Algorithm to apply the packet
1260       - gint *authentication_algo : the Authentication Algorithm to apply to the packet
1261       - gchar **encryption_key : the Encryption Key to apply to the packet
1262       - guint *encryption_key_len : the Encryption Key length to apply to the packet
1263       - gchar **authentication_key : the Authentication Key to apply to the packet
1264       - guint *authentication_key_len : the Authentication Key len to apply to the packet
1265
1266 */
1267 #ifdef HAVE_LIBGCRYPT
1268 static gboolean
1269 get_esp_sa(g_esp_sa_database *sad, gint protocol_typ, gchar *src,  gchar *dst,  gint spi, gint *entry_index,
1270            gint *encryption_algo,
1271            gint *authentication_algo,
1272            gchar **encryption_key,
1273            guint *encryption_key_len,
1274            gchar **authentication_key,
1275            guint *authentication_key_len
1276            )
1277
1278 {
1279   gboolean found = FALSE;
1280   gint i = 0;
1281   gchar spi_string[IPSEC_SPI_LEN_MAX];
1282   gint key_len;
1283
1284   *entry_index = -1;
1285
1286   g_snprintf(spi_string, IPSEC_SPI_LEN_MAX,"%i", spi);
1287
1288   while((found == FALSE) && (i < sad -> nb))
1289     {
1290       if(esp_sa_parse_filter(sad -> table[i].sa, &sad -> table[i].typ, &sad -> table[i].src, &sad -> table[i].src_len,
1291                              &sad -> table[i].dst, &sad -> table[i].dst_len, &sad -> table[i].spi))
1292         {
1293           g_esp_sad.table[i].is_valid = TRUE;
1294
1295           /* Debugging Purpose */
1296           /*
1297           fprintf(stderr, "VALID SA => <SA : %s> <Filter Source : %s/%i> <Filter Destination : %s/%i> <SPI : %s>\n", g_esp_sad.table[i].sa, g_esp_sad.table[i].src, g_esp_sad.table[i].src_len,
1298                   g_esp_sad.table[i].dst, g_esp_sad.table[i].dst_len, g_esp_sad.table[i].spi);
1299           */
1300
1301           if((protocol_typ == sad -> table[i].typ)
1302              && filter_address_match(src,sad -> table[i].src, sad -> table[i].src_len, protocol_typ)
1303              && filter_address_match(dst,sad -> table[i].dst, sad -> table[i].dst_len, protocol_typ)
1304              && filter_spi_match(spi_string, sad -> table[i].spi))
1305             {
1306               found = TRUE;
1307
1308               *entry_index = i;
1309               *encryption_algo = sad -> table[i].encryption_algo;
1310               *authentication_algo = sad -> table[i].authentication_algo;
1311               key_len = compute_ascii_key(authentication_key, (gchar *)sad -> table[i].authentication_key);
1312               if (key_len == -1)
1313                 {
1314                   /* Bad key; XXX - report this */
1315                   *authentication_key_len = 0;
1316                   found = FALSE;
1317                 }
1318               else
1319                 *authentication_key_len = (guint)key_len;
1320               key_len = compute_ascii_key(encryption_key, (gchar *)sad -> table[i].encryption_key);
1321               if (key_len == -1)
1322                 {
1323                   /* Bad key; XXX - report this */
1324                   *encryption_key_len = 0;
1325                   found = FALSE;
1326                 }
1327               else
1328                 *encryption_key_len = key_len;
1329
1330               /* Debugging Purpose */
1331               /*
1332               fprintf(stderr,"MATCHING SA => <IP Source : %s> <IP Destination : %s> <SPI : %s>\n\
1333             => <FILTER Source : %s/%i> <FILTER Destination : %s/%i> <FILTER SPI : %s>\n\
1334             => <Encryption Algo : %i> <Encryption Key: %s> <Authentication Algo : %i>\n",
1335                       src,dst,spi_string,
1336                       sad -> table[i].src, sad -> table[i].src_len,
1337                       sad -> table[i].dst, sad -> table[i].dst_len,
1338                       sad -> table[i].spi,
1339                       *encryption_algo, *encryption_key, *authentication_algo);
1340                       */
1341             }
1342
1343           /* We free the Src, Dst and Spi in the SA, but perhaps to allocate it again with the same value !!! */
1344           g_free(g_esp_sad.table[i].src);
1345           g_free(g_esp_sad.table[i].dst);
1346           g_free(g_esp_sad.table[i].spi);
1347           g_esp_sad.table[i].is_valid = FALSE;
1348
1349         }
1350
1351       else
1352         {
1353           /* Debugging Purpose */
1354           /* fprintf(stderr, "INVALID SA => %s \n", g_esp_sad.table[i].sa); */
1355         }
1356
1357       i++;
1358     }
1359   return found;
1360 }
1361 #endif
1362
1363 static void
1364 dissect_ah(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
1365 {
1366   proto_tree *next_tree;
1367   guint8 nxt;
1368   tvbuff_t *next_tvb;
1369   int advance;
1370
1371   advance = dissect_ah_header(tvb, pinfo, tree, &nxt, &next_tree);
1372   next_tvb = tvb_new_subset(tvb, advance, -1, -1);
1373
1374   if (g_ah_payload_in_subtree) {
1375     col_set_writable(pinfo->cinfo, FALSE);
1376   }
1377
1378   /* do lookup with the subdissector table */
1379   if (!dissector_try_port(ip_dissector_table, nxt, next_tvb, pinfo, tree)) {
1380     call_dissector(data_handle,next_tvb, pinfo, next_tree);
1381   }
1382 }
1383
1384 int
1385 dissect_ah_header(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
1386                   guint8 *nxt_p, proto_tree **next_tree_p)
1387 {
1388   proto_tree *ah_tree;
1389   proto_item *ti;
1390   struct newah ah;
1391   int advance;
1392
1393   if (check_col(pinfo->cinfo, COL_PROTOCOL))
1394     col_set_str(pinfo->cinfo, COL_PROTOCOL, "AH");
1395   if (check_col(pinfo->cinfo, COL_INFO))
1396     col_clear(pinfo->cinfo, COL_INFO);
1397
1398   tvb_memcpy(tvb, (guint8 *)&ah, 0, sizeof(ah));
1399   advance = sizeof(ah) + ((ah.ah_len - 1) << 2);
1400
1401   if (check_col(pinfo->cinfo, COL_INFO)) {
1402     col_add_fstr(pinfo->cinfo, COL_INFO, "AH (SPI=0x%08x)",
1403                  (guint32)g_ntohl(ah.ah_spi));
1404   }
1405
1406   if (tree) {
1407     /* !!! specify length */
1408     ti = proto_tree_add_item(tree, proto_ah, tvb, 0, advance, FALSE);
1409     ah_tree = proto_item_add_subtree(ti, ett_ah);
1410
1411     proto_tree_add_text(ah_tree, tvb,
1412                         offsetof(struct newah, ah_nxt), 1,
1413                         "Next Header: %s (0x%02x)",
1414                         ipprotostr(ah.ah_nxt), ah.ah_nxt);
1415     proto_tree_add_text(ah_tree, tvb,
1416                         offsetof(struct newah, ah_len), 1,
1417                         "Length: %u", (ah.ah_len + 2) << 2);
1418     proto_tree_add_uint(ah_tree, hf_ah_spi, tvb,
1419                         offsetof(struct newah, ah_spi), 4,
1420                         (guint32)g_ntohl(ah.ah_spi));
1421     proto_tree_add_uint(ah_tree, hf_ah_sequence, tvb,
1422                         offsetof(struct newah, ah_seq), 4,
1423                         (guint32)g_ntohl(ah.ah_seq));
1424     proto_tree_add_item(ah_tree, hf_ah_iv, tvb,
1425                         sizeof(ah), (ah.ah_len) ? (ah.ah_len - 1) << 2 : 0,
1426                         FALSE);
1427
1428     if (next_tree_p != NULL) {
1429       /* Decide where to place next protocol decode */
1430       if (g_ah_payload_in_subtree) {
1431         *next_tree_p = ah_tree;
1432       }
1433       else {
1434         *next_tree_p = tree;
1435       }
1436     }
1437   } else {
1438     if (next_tree_p != NULL)
1439       *next_tree_p = NULL;
1440   }
1441
1442   if (nxt_p != NULL)
1443     *nxt_p = ah.ah_nxt;
1444
1445   /* start of the new header (could be a extension header) */
1446   return advance;
1447 }
1448
1449
1450 /*
1451    Name : dissect_esp_authentication(proto_tree *tree, tvbuff_t *tvb, gint len, gint esp_auth_len, guint8 *authenticator_data_computed,
1452           gboolean authentication_ok, gboolean authentication_checking_ok)
1453    Description : used to print Authenticator field when linked with libgcrypt. Print the expected authenticator value
1454                  if requested and if it is wrong.
1455    Return : void
1456    Params:
1457       - proto_tree *tree : the current tree
1458       - tvbuff_t *tvb : the tvbuffer
1459       - gint len : length of the data availabale in tvbuff
1460       - gint esp_auth_len : size of authenticator field
1461       - guint8 *authenticator_data_computed : give the authenticator computed (only needed when authentication_ok and !authentication_checking_ok
1462       - gboolean authentication_ok : set to true if the authentication checking has been run successfully
1463       - gboolean authentication_checking_ok : set to true if the authentication was the one expected
1464 */
1465 #ifdef HAVE_LIBGCRYPT
1466 static void
1467 dissect_esp_authentication(proto_tree *tree, tvbuff_t *tvb, gint len, gint esp_auth_len, guint8 *authenticator_data_computed,
1468                           gboolean authentication_ok, gboolean authentication_checking_ok)
1469 {
1470   if(esp_auth_len == 0)
1471     {
1472       proto_tree_add_text(tree, tvb, len, 0,
1473                           "NULL Authentication");
1474     }
1475
1476   /* Make sure we have the auth trailer data */
1477   else if(tvb_bytes_exist(tvb, len - esp_auth_len, esp_auth_len))
1478     {
1479       if((authentication_ok) && (authentication_checking_ok))
1480         {
1481           proto_tree_add_text(tree, tvb, len - esp_auth_len, esp_auth_len,
1482                               "Authentication Data [correct]");
1483         }
1484
1485       else if((authentication_ok) && (!authentication_checking_ok))
1486         {
1487           proto_tree_add_text(tree, tvb, len - esp_auth_len, esp_auth_len,
1488                               "Authentication Data [incorrect, should be 0x%s]", authenticator_data_computed);
1489
1490           g_free(authenticator_data_computed);
1491         }
1492
1493       else proto_tree_add_text(tree, tvb, len - esp_auth_len, esp_auth_len,
1494                                "Authentication Data");
1495     }
1496   else
1497     {
1498       /* Truncated so just display what we have */
1499       proto_tree_add_text(tree, tvb, len - esp_auth_len, esp_auth_len - (len - tvb_length(tvb)),
1500                           "Authentication Data (truncated)");
1501     }
1502 }
1503 #endif
1504
1505 static void
1506 dissect_esp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
1507 {
1508   proto_tree *esp_tree = NULL;
1509   proto_item *ti;
1510   struct newesp esp;
1511
1512   gint len = 0;
1513   gint i = 0;
1514
1515 #ifdef HAVE_LIBGCRYPT
1516   char res[3];
1517
1518   /* Packet Variables related */
1519   gchar *ip_src = NULL;
1520   gchar *ip_dst = NULL;
1521   guint32 spi = 0;
1522 #endif
1523
1524   guint encapsulated_protocol = 0;
1525   gboolean decrypt_dissect_ok = FALSE;
1526
1527 #ifdef HAVE_LIBGCRYPT
1528   gboolean get_address_ok = FALSE;
1529   gboolean null_encryption_decode_heuristic = FALSE;
1530   guint8 *decrypted_data = NULL;
1531   guint8 *encrypted_data = NULL;
1532   guint8 *authenticator_data = NULL;
1533   guint8 *esp_data = NULL;
1534   tvbuff_t *tvb_decrypted;
1535   gint entry_index;
1536
1537   /* IPSEC encryption Variables related */
1538   gint protocol_typ = IPSEC_SA_UNKNOWN;
1539   gint esp_crypt_algo = IPSEC_ENCRYPT_NULL;
1540   gint esp_auth_algo = IPSEC_AUTH_NULL;
1541   gchar *esp_crypt_key = NULL;
1542   gchar *esp_auth_key = NULL;
1543   guint esp_crypt_key_len = 0;
1544   guint esp_auth_key_len = 0;
1545   gint esp_iv_len = 0;
1546   gint esp_auth_len = 0;
1547   gint decrypted_len = 0;
1548   gboolean decrypt_ok = FALSE;
1549   gboolean decrypt_using_libgcrypt = FALSE;
1550   gboolean authentication_check_using_hmac_libgcrypt = FALSE;
1551   gboolean authentication_ok = FALSE;
1552   gboolean authentication_checking_ok = FALSE;
1553   gboolean sad_is_present = FALSE;
1554 #endif
1555   gint esp_pad_len = 0;
1556
1557 #ifdef HAVE_LIBGCRYPT
1558
1559   /* Variables for decryption and authentication checking used for libgrypt */
1560   int decrypted_len_alloc = 0;
1561   gcry_cipher_hd_t cypher_hd;
1562   gcry_md_hd_t md_hd;
1563   int md_len = 0;
1564   gcry_error_t err = 0;
1565   int crypt_algo_libgcrypt = 0;
1566   int crypt_mode_libgcrypt = 0;
1567   int auth_algo_libgcrypt = 0;
1568   unsigned char *authenticator_data_computed = NULL;
1569   unsigned char *authenticator_data_computed_md;
1570
1571
1572   /*
1573    * load the top pane info. This should be overwritten by
1574    * the next protocol in the stack
1575    */
1576
1577 #endif
1578
1579   if (check_col(pinfo->cinfo, COL_PROTOCOL))
1580     col_set_str(pinfo->cinfo, COL_PROTOCOL, "ESP");
1581   if (check_col(pinfo->cinfo, COL_INFO))
1582     col_clear(pinfo->cinfo, COL_INFO);
1583
1584   tvb_memcpy(tvb, (guint8 *)&esp, 0, sizeof(esp));
1585
1586   if (check_col(pinfo->cinfo, COL_INFO)) {
1587     col_add_fstr(pinfo->cinfo, COL_INFO, "ESP (SPI=0x%08x)",
1588                  (guint32)g_ntohl(esp.esp_spi));
1589   }
1590
1591
1592   /*
1593    * populate a tree in the second pane with the status of the link layer
1594    * (ie none)
1595    */
1596
1597   if(tree) {
1598     len = 0, encapsulated_protocol = 0;
1599     decrypt_dissect_ok = FALSE;
1600     i = 0;
1601
1602     ti = proto_tree_add_item(tree, proto_esp, tvb, 0, -1, FALSE);
1603     esp_tree = proto_item_add_subtree(ti, ett_esp);
1604     proto_tree_add_uint(esp_tree, hf_esp_spi, tvb,
1605                         offsetof(struct newesp, esp_spi), 4,
1606                         (guint32)g_ntohl(esp.esp_spi));
1607     proto_tree_add_uint(esp_tree, hf_esp_sequence, tvb,
1608                         offsetof(struct newesp, esp_seq), 4,
1609                         (guint32)g_ntohl(esp.esp_seq));
1610   }
1611
1612
1613 #ifdef HAVE_LIBGCRYPT
1614   /* The SAD is not activated */
1615   if(g_esp_enable_null_encryption_decode_heuristic &&
1616     !g_esp_enable_encryption_decode)
1617     null_encryption_decode_heuristic = TRUE;
1618
1619   if(g_esp_enable_encryption_decode || g_esp_enable_authentication_check)
1620     {
1621       /* Get Source & Destination Addresses in gchar * with all the bytes available.  */
1622       switch (pinfo -> src.type)
1623         {
1624
1625         case AT_IPv4 :
1626           {
1627             const guint8 *srcaddr = pinfo -> src.data;
1628             const guint8 *dstaddr = pinfo -> dst.data;
1629
1630             ip_src = (gchar *) g_malloc((IPSEC_STRLEN_IPV4 + 1) * sizeof(gchar));
1631             ip_dst = (gchar *) g_malloc((IPSEC_STRLEN_IPV4 + 1) * sizeof(gchar));
1632             protocol_typ = IPSEC_SA_IPV4;
1633
1634             for(i = 0 ; i < pinfo -> src.len; i++)
1635               {
1636                 if(srcaddr[i] < 16)
1637                   {
1638                     g_snprintf(res,3,"0%X ", srcaddr[i]);
1639                   }
1640                 else
1641                   {
1642                     g_snprintf(res,3,"%X ", srcaddr[i]);
1643                   }
1644                 memcpy(ip_src + i*2, res, 2);
1645               }
1646             ip_src[IPSEC_STRLEN_IPV4] = '\0';
1647
1648             for(i = 0 ; i < pinfo -> dst.len; i++)
1649               {
1650                 if(dstaddr[i] < 16)
1651                   {
1652                     g_snprintf(res,3,"0%X ", dstaddr[i]);
1653                   }
1654                 else
1655                   {
1656                     g_snprintf(res,3,"%X ", dstaddr[i]);
1657                   }
1658                 memcpy(ip_dst + i*2, res, 2);
1659               }
1660             ip_dst[IPSEC_STRLEN_IPV4] = '\0';
1661
1662             get_address_ok = TRUE;
1663           break;
1664           }
1665
1666         case AT_IPv6 :
1667           {
1668             const guint8 *srcaddr = pinfo -> src.data;
1669             const guint8 *dstaddr = pinfo -> dst.data;
1670
1671             ip_src = (gchar *) g_malloc((IPSEC_STRLEN_IPV6 + 1) * sizeof(gchar));
1672             ip_dst = (gchar *) g_malloc((IPSEC_STRLEN_IPV6 + 1) * sizeof(gchar));
1673             protocol_typ = IPSEC_SA_IPV6;
1674
1675             for(i = 0 ; i < pinfo -> src.len; i++)
1676               {
1677                 if(srcaddr[i] < 16)
1678                   {
1679                     g_snprintf(res,3,"0%X ", srcaddr[i]);
1680                   }
1681                 else
1682                   {
1683                     g_snprintf(res,3,"%X ", srcaddr[i]);
1684                   }
1685                 memcpy(ip_src + i*2, res, 2);
1686               }
1687             ip_src[IPSEC_STRLEN_IPV6] = '\0';
1688
1689             for(i = 0 ; i < pinfo -> dst.len; i++)
1690               {
1691                 if(dstaddr[i] < 16)
1692                   {
1693                     g_snprintf(res,3,"0%X ", dstaddr[i]);
1694                   }
1695                 else
1696                   {
1697                     g_snprintf(res,3,"%X ", dstaddr[i]);
1698                   }
1699                 memcpy(ip_dst + i*2, res, 2);
1700               }
1701             ip_dst[IPSEC_STRLEN_IPV6] = '\0';
1702
1703             get_address_ok = TRUE;
1704             break;
1705           }
1706
1707         default :
1708           {
1709             get_address_ok = FALSE;
1710             break;
1711           }
1712         }
1713
1714       /* The packet cannot be decoded using the SAD */
1715       if(g_esp_enable_null_encryption_decode_heuristic && !get_address_ok)
1716         null_encryption_decode_heuristic = TRUE;
1717
1718       if(get_address_ok)
1719         {
1720           /* Get the SPI */
1721           if (tvb_length(tvb) >= 4) 
1722             {
1723               spi = tvb_get_ntohl(tvb, 0);
1724             }
1725
1726
1727           /*
1728             PARSE the SAD and fill it. It may take some time since it will
1729             be called every times an ESP Payload is found.
1730           */
1731
1732           if((sad_is_present = get_esp_sa(&g_esp_sad, protocol_typ, ip_src, ip_dst, spi, &entry_index,
1733                                           &esp_crypt_algo, &esp_auth_algo,
1734                                           &esp_crypt_key, &esp_crypt_key_len, &esp_auth_key, &esp_auth_key_len)))
1735             {
1736
1737               /* Get length of whole ESP packet. */
1738               len = tvb_reported_length(tvb);
1739
1740               switch(esp_auth_algo)
1741                 {
1742
1743                 case IPSEC_AUTH_HMAC_SHA1_96:
1744                   {
1745                     esp_auth_len = 12;
1746                     break;
1747                   }
1748
1749                 case IPSEC_AUTH_HMAC_SHA256:
1750                   {
1751                     esp_auth_len = 12;
1752                     break;
1753                   }
1754
1755                 case IPSEC_AUTH_NULL:
1756                   {
1757                     esp_auth_len = 0;
1758                     break;
1759                   }
1760
1761                   /*
1762                     case IPSEC_AUTH_AES_XCBC_MAC_96:
1763                     {
1764                     esp_auth_len = 12;
1765                     break;
1766                     }
1767                   */
1768
1769                 case IPSEC_AUTH_HMAC_MD5_96:
1770                   {
1771                     esp_auth_len = 12;
1772                     break;
1773                   }
1774
1775                 case IPSEC_AUTH_HMAC_RIPEMD160_96:
1776                   {
1777                     esp_auth_len = 12;
1778                     break;
1779                   }
1780
1781                 case IPSEC_AUTH_ANY_12BYTES:
1782                 default:
1783                   {
1784                     esp_auth_len = 12;
1785                     break;
1786                   }
1787
1788                 }
1789
1790               if(g_esp_enable_authentication_check)
1791                 {
1792                   switch(esp_auth_algo)
1793                     {
1794
1795                     case IPSEC_AUTH_HMAC_SHA1_96:
1796                       /*
1797                         RFC 2404 : HMAC-SHA-1-96 is a secret key algorithm.
1798                         While no fixed key length is specified in [RFC-2104],
1799                         for use with either ESP or AH a fixed key length of
1800                         160-bits MUST be supported.  Key lengths other than
1801                         160-bits MUST NOT be supported (i.e. only 160-bit keys
1802                         are to be used by HMAC-SHA-1-96).  A key length of
1803                         160-bits was chosen based on the recommendations in
1804                         [RFC-2104] (i.e. key lengths less than the
1805                         authenticator length decrease security strength and
1806                         keys longer than the authenticator length do not
1807                         significantly increase security strength).
1808                       */
1809                       {
1810                         auth_algo_libgcrypt = GCRY_MD_SHA1;
1811                         authentication_check_using_hmac_libgcrypt = TRUE;
1812                         break;
1813                       }
1814
1815                     case IPSEC_AUTH_NULL:
1816                       {
1817                         authentication_check_using_hmac_libgcrypt = FALSE;
1818                         authentication_checking_ok = TRUE;
1819                         authentication_ok = TRUE;
1820                         break;
1821                       }
1822
1823                       /*
1824                         case IPSEC_AUTH_AES_XCBC_MAC_96:
1825                         {
1826                         auth_algo_libgcrypt =
1827                         authentication_check_using_libgcrypt = TRUE;
1828                         break;
1829                         }
1830                       */
1831
1832                     case IPSEC_AUTH_HMAC_SHA256:
1833                       {
1834                         auth_algo_libgcrypt = GCRY_MD_SHA256;
1835                         authentication_check_using_hmac_libgcrypt = TRUE;
1836                         break;
1837                       }
1838
1839                     case IPSEC_AUTH_HMAC_MD5_96:
1840                       /*
1841                         RFC 2403 : HMAC-MD5-96 is a secret key algorithm.
1842                         While no fixed key length is specified in [RFC-2104],
1843                         for use with either ESP or AH a fixed key length of
1844                         128-bits MUST be supported.  Key lengths other than
1845                         128-bits MUST NOT be supported (i.e. only 128-bit keys
1846                         are to be used by HMAC-MD5-96).  A key length of
1847                         128-bits was chosen based on the recommendations in
1848                         [RFC-2104] (i.e. key lengths less than the
1849                         authenticator length decrease security strength and
1850                         keys longer than the authenticator length do not
1851                         significantly increase security strength).
1852                       */
1853                       {
1854                         auth_algo_libgcrypt = GCRY_MD_MD5;
1855                         authentication_check_using_hmac_libgcrypt = TRUE;
1856                         break;
1857                       }
1858
1859                     case IPSEC_AUTH_HMAC_RIPEMD160_96:
1860                       /*
1861                         RFC 2857 : HMAC-RIPEMD-160-96 produces a 160-bit 
1862                         authenticator value.  This 160-bit value can be 
1863                         truncated as described in RFC2104.  For use with 
1864                         either ESP or AH, a truncated value using the first 
1865                         96 bits MUST be supported. 
1866                       */
1867                       {
1868                         auth_algo_libgcrypt = GCRY_MD_RMD160;
1869                         authentication_check_using_hmac_libgcrypt = TRUE;
1870                         break;
1871                       }
1872
1873                     case IPSEC_AUTH_ANY_12BYTES:
1874                     default:
1875                       {
1876                         authentication_ok = FALSE;
1877                         authentication_check_using_hmac_libgcrypt = FALSE;
1878                         break;
1879                       }
1880
1881                       }
1882
1883                   if((authentication_check_using_hmac_libgcrypt) && (!authentication_ok))
1884                     {
1885                       gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1886                       gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1887
1888                       /* Allocate Buffers for Authenticator Field  */
1889                       authenticator_data = (guint8 *) g_malloc (( esp_auth_len + 1) * sizeof(guint8));
1890                       memset(authenticator_data,0, esp_auth_len + 1);
1891                       tvb_memcpy(tvb, authenticator_data, len - esp_auth_len, esp_auth_len);
1892
1893                       esp_data = (guint8 *) g_malloc (( len - esp_auth_len + 1) * sizeof(guint8));
1894                       memset(esp_data,0,  len - esp_auth_len + 1);
1895                       tvb_memcpy(tvb, esp_data, 0, len - esp_auth_len);
1896
1897                       err = gcry_md_open (&md_hd, auth_algo_libgcrypt, GCRY_MD_FLAG_HMAC);
1898                       if (err)
1899                         {
1900                           fprintf (stderr,"<IPsec/ESP Dissector> Error in Algorithm %s, gcry_md_open failed: %s\n", gcry_md_algo_name(auth_algo_libgcrypt), gpg_strerror (err));
1901                           authentication_ok = FALSE;
1902                           g_free(authenticator_data);
1903                           g_free(esp_data);
1904                         }
1905
1906                       else
1907                         {
1908                           md_len = gcry_md_get_algo_dlen (auth_algo_libgcrypt);
1909                           if (md_len < 1 || md_len < esp_auth_len)
1910                             {
1911                               fprintf (stderr,"<IPsec/ESP Dissector> Error in Algorithm %s, grcy_md_get_algo_dlen failed: %d\n", gcry_md_algo_name(auth_algo_libgcrypt), md_len);
1912                               authentication_ok = FALSE;
1913                             }
1914
1915                           else
1916                             {
1917                               gcry_md_setkey( md_hd, esp_auth_key, esp_auth_key_len );
1918
1919                               gcry_md_write (md_hd, esp_data, len - esp_auth_len);
1920
1921                               authenticator_data_computed_md = gcry_md_read (md_hd, auth_algo_libgcrypt);
1922                               if (authenticator_data_computed_md == 0)
1923                                 {
1924                                   fprintf (stderr,"<IPsec/ESP Dissector> Error in Algorithm %s, gcry_md_read failed\n", gcry_md_algo_name(auth_algo_libgcrypt));
1925                                   authentication_ok = FALSE;
1926                                 }
1927                               else
1928                                 {
1929                                   if(memcmp (authenticator_data_computed_md, authenticator_data, esp_auth_len))
1930                                     {
1931                                       unsigned char authenticator_data_computed_car[3];
1932                                       authenticator_data_computed = (guint8 *) g_malloc (( esp_auth_len * 2 + 1) * sizeof(guint8));
1933                                       for (i = 0; i < esp_auth_len; i++)
1934                                         {
1935                                           g_snprintf((char *)authenticator_data_computed_car, 3, "%02X", authenticator_data_computed_md[i] & 0xFF);
1936                                           authenticator_data_computed[i*2] = authenticator_data_computed_car[0];
1937                                           authenticator_data_computed[i*2 + 1] = authenticator_data_computed_car[1];
1938                                         }
1939
1940                                       authenticator_data_computed[esp_auth_len * 2] ='\0';
1941
1942                                       authentication_ok = TRUE;
1943                                       authentication_checking_ok = FALSE;
1944                                     }
1945                                   else
1946                                     {
1947
1948                                       authentication_ok = TRUE;
1949                                       authentication_checking_ok = TRUE;
1950                                     }
1951                                 }
1952                             }
1953
1954                             gcry_md_close (md_hd);
1955                             g_free(authenticator_data);
1956                             g_free(esp_data);
1957                           }
1958                       }
1959                   }
1960
1961               if(g_esp_enable_encryption_decode)
1962                 {
1963                   /* Deactivation of the Heuristic to decrypt using the NULL encryption algorithm since the packet is matching a SA */
1964                   null_encryption_decode_heuristic = FALSE;
1965
1966                   switch(esp_crypt_algo)
1967                     {
1968
1969                     case IPSEC_ENCRYPT_3DES_CBC :
1970                       {
1971                         /* RFC 2451 says :
1972                            3DES CBC uses a key of 192 bits.
1973                            The first 3DES key is taken from the first 64 bits,
1974                            the second from the next 64 bits, and the third
1975                            from the last 64 bits.
1976                            Implementations MUST take into consideration the
1977                            parity bits when initially accepting a new set of
1978                            keys.  Each of the three keys is really 56 bits in
1979                            length with the extra 8 bits used for parity. */
1980
1981                         /* Fix parameters for 3DES-CBC */
1982                         esp_iv_len = 8;
1983                         crypt_algo_libgcrypt = GCRY_CIPHER_3DES;
1984                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1985
1986                         decrypted_len = len - sizeof(struct newesp);
1987
1988                         if (decrypted_len <= 0)
1989                           decrypt_ok = FALSE;
1990                         else
1991                           {
1992                             if(decrypted_len % esp_iv_len  == 0)
1993                               decrypted_len_alloc = decrypted_len;
1994                             else
1995                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1996
1997                             if (esp_crypt_key_len != gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt))
1998                               {
1999                                 fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm 3DES-CBC : Bad Keylen (got %i Bits, need %lu)\n",
2000                                          esp_crypt_key_len * 8, (unsigned long) gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt) * 8);
2001                                 decrypt_ok = FALSE;
2002                               }
2003                             else
2004                               decrypt_using_libgcrypt = TRUE;
2005                           }
2006
2007                         break;
2008                       }
2009
2010                     case IPSEC_ENCRYPT_AES_CBC :
2011                       {
2012                         /* RFC 3602 says :
2013                            AES supports three key sizes: 128 bits, 192 bits,
2014                            and 256 bits.  The default key size is 128 bits,
2015                            and all implementations MUST support this key size.
2016                            Implementations MAY also support key sizes of 192
2017                            bits and 256 bits. */
2018
2019                         /* Fix parameters for AES-CBC */
2020                         esp_iv_len = 16;
2021                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
2022
2023                         decrypted_len = len - sizeof(struct newesp);
2024
2025                         if (decrypted_len <= 0)
2026                           decrypt_ok = FALSE;
2027                         else
2028                           {
2029                             if(decrypted_len % esp_iv_len  == 0)
2030                               decrypted_len_alloc = decrypted_len;
2031                             else
2032                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
2033
2034                             switch(esp_crypt_key_len * 8)
2035                               {
2036                               case 128:
2037                                 {
2038                                   crypt_algo_libgcrypt = GCRY_CIPHER_AES128;
2039                                   decrypt_using_libgcrypt = TRUE;
2040                                   break;
2041                                 }
2042                               case 192:
2043                                 {
2044                                   crypt_algo_libgcrypt = GCRY_CIPHER_AES192;
2045                                   decrypt_using_libgcrypt = TRUE;
2046                                   break;
2047                                 }
2048                               case 256:
2049                                 {
2050                                   crypt_algo_libgcrypt = GCRY_CIPHER_AES256;
2051                                   decrypt_using_libgcrypt = TRUE;
2052                                   break;
2053                                 }
2054                               default:
2055                                 {
2056                                   fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm AES-CBC : Bad Keylen (%i Bits)\n",
2057                                            esp_crypt_key_len * 8);
2058                                   decrypt_ok = FALSE;
2059                                 }
2060                               }
2061                           }
2062                         break;
2063                       }
2064
2065
2066                     case IPSEC_ENCRYPT_CAST5_CBC :
2067                       {
2068                         /* RFC 2144 says :
2069                            The CAST-128 encryption algorithm has been designed to allow a key
2070                            size that can vary from 40 bits to 128 bits, in 8-bit increments
2071                            (that is, the allowable key sizes are 40, 48, 56, 64, ..., 112, 120,
2072                            and 128 bits. 
2073                            We support only 128 bits. */
2074
2075                         /* Fix parameters for CAST5-CBC */
2076                         esp_iv_len = 8;
2077                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
2078
2079                         decrypted_len = len - sizeof(struct newesp);
2080
2081                         if (decrypted_len <= 0)
2082                           decrypt_ok = FALSE;
2083                         else
2084                           {
2085                             if(decrypted_len % esp_iv_len  == 0)
2086                               decrypted_len_alloc = decrypted_len;
2087                             else
2088                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
2089
2090                             switch(esp_crypt_key_len * 8)
2091                               {
2092                               case 128:
2093                                 {
2094                                   crypt_algo_libgcrypt = GCRY_CIPHER_CAST5;
2095                                   decrypt_using_libgcrypt = TRUE;
2096                                   break;
2097                                 }
2098                               default:
2099                                 {
2100                                   fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm CAST5-CBC : Bad Keylen (%i Bits)\n",
2101                                            esp_crypt_key_len * 8);
2102                                   decrypt_ok = FALSE;
2103                                 }
2104                               }
2105                           }
2106                         break;
2107                       }
2108
2109
2110                     case IPSEC_ENCRYPT_DES_CBC :
2111                       {
2112                         /* RFC 2405 says :
2113                            DES-CBC is a symmetric secret key algorithm.
2114                            The key size is 64-bits.
2115                            [It is commonly known as a 56-bit key as the key
2116                            has 56 significant bits; the least significant
2117                            bit in every byte is the parity bit.] */
2118
2119                         /* Fix parameters for DES-CBC */
2120                         esp_iv_len = 8;
2121                         crypt_algo_libgcrypt = GCRY_CIPHER_DES;
2122                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
2123                         decrypted_len = len - sizeof(struct newesp);
2124
2125                         if (decrypted_len <= 0)
2126                           decrypt_ok = FALSE;
2127                         else
2128                           {
2129                             if(decrypted_len % esp_iv_len == 0)
2130                               decrypted_len_alloc = decrypted_len;
2131                             else
2132                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
2133
2134                             if (esp_crypt_key_len != gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt))
2135                               {
2136                                 fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm DES-CBC : Bad Keylen (%i Bits, need %lu)\n",
2137                                          esp_crypt_key_len * 8, (unsigned long) gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt) * 8);
2138                                 decrypt_ok = FALSE;
2139                               }
2140                             else
2141                               decrypt_using_libgcrypt = TRUE;
2142                           }
2143
2144                         break;
2145                       }
2146
2147
2148                     case IPSEC_ENCRYPT_AES_CTR :
2149                       {
2150                         /* RFC 3686 says :
2151                            AES supports three key sizes: 128 bits, 192 bits,
2152                            and 256 bits.  The default key size is 128 bits,
2153                            and all implementations MUST support this key
2154                            size.  Implementations MAY also support key sizes
2155                            of 192 bits and 256 bits. The remaining 32 bits
2156                            will be used as nonce. */
2157
2158                         /* Fix parameters for AES-CTR */
2159                         esp_iv_len = 8;
2160                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CTR;
2161
2162                         decrypted_len = len - sizeof(struct newesp);
2163
2164                         if (decrypted_len <= 0)
2165                           decrypt_ok = FALSE;
2166                         else
2167                           {
2168                             if(decrypted_len % esp_iv_len  == 0)
2169                               decrypted_len_alloc = decrypted_len;
2170                             else
2171                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
2172
2173                             switch(esp_crypt_key_len * 8)
2174                               {
2175                               case 160:
2176                                 {
2177                                   crypt_algo_libgcrypt = GCRY_CIPHER_AES128;
2178                                   decrypt_using_libgcrypt = TRUE;
2179                                   break;
2180                                 }
2181                               case 224:
2182                                 {
2183                                   crypt_algo_libgcrypt = GCRY_CIPHER_AES192;
2184                                   decrypt_using_libgcrypt = TRUE;
2185                                   break;
2186                                 }
2187                               case 288:
2188                                 {
2189                                   crypt_algo_libgcrypt = GCRY_CIPHER_AES256;
2190                                   decrypt_using_libgcrypt = TRUE;
2191                                   break;
2192                                 }
2193                               default:
2194                                 {
2195                                   fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm AES-CTR : Bad Keylen (%i Bits)\n",esp_crypt_key_len * 8);
2196                                   decrypt_ok = FALSE;
2197                                 }
2198                               }
2199                           }
2200
2201                         break;
2202                       }
2203
2204                     case IPSEC_ENCRYPT_TWOFISH_CBC :
2205                       {
2206                         /*  Twofish is a 128-bit block cipher developed by
2207                             Counterpane Labs that accepts a variable-length
2208                             key up to 256 bits.
2209                             We will only accept key sizes of 128 and 256 bits.
2210                         */
2211
2212                         /* Fix parameters for TWOFISH-CBC */
2213                         esp_iv_len = 16;
2214                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
2215
2216                         decrypted_len = len - sizeof(struct newesp);
2217
2218                         if (decrypted_len <= 0)
2219                           decrypt_ok = FALSE;
2220                         else
2221                           {
2222                             if(decrypted_len % esp_iv_len  == 0)
2223                               decrypted_len_alloc = decrypted_len;
2224                             else
2225                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
2226
2227                             switch(esp_crypt_key_len * 8)
2228                               {
2229                               case 128:
2230                                 {
2231                                   crypt_algo_libgcrypt = GCRY_CIPHER_TWOFISH128;
2232                                   decrypt_using_libgcrypt = TRUE;
2233                                   break;
2234                                 }
2235                               case 256:
2236                                 {
2237                                   crypt_algo_libgcrypt = GCRY_CIPHER_TWOFISH;
2238                                   decrypt_using_libgcrypt = TRUE;
2239                                   break;
2240                                 }
2241                               default:
2242                                 {
2243                                   fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm TWOFISH-CBC : Bad Keylen (%i Bits)\n",esp_crypt_key_len * 8);
2244                                   decrypt_ok = FALSE;
2245                                 }
2246                               }
2247                           }
2248
2249                         break;
2250                       }
2251
2252
2253                     case IPSEC_ENCRYPT_BLOWFISH_CBC :
2254                       {
2255                         /* Bruce Schneier of Counterpane Systems developed
2256                            the Blowfish block cipher algorithm.
2257                            RFC 2451 shows that Blowfish uses key sizes from
2258                            40 to 448 bits. The Default size is 128 bits.
2259                            We will only accept key sizes of 128 bits, because
2260                            libgrypt only accept this key size.
2261                         */
2262
2263                         /* Fix parameters for BLOWFISH-CBC */
2264                         esp_iv_len = 8;
2265                         crypt_algo_libgcrypt = GCRY_CIPHER_BLOWFISH;
2266                         crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
2267
2268                         decrypted_len = len - sizeof(struct newesp);
2269
2270                         if (decrypted_len <= 0)
2271                           decrypt_ok = FALSE;
2272                         else
2273                           {
2274                             if(decrypted_len % esp_iv_len  == 0)
2275                               decrypted_len_alloc = decrypted_len;
2276                             else
2277                               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
2278
2279                             if (esp_crypt_key_len != gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt))
2280                               {
2281                                 fprintf (stderr,"<ESP Preferences> Error in Encryption Algorithm BLOWFISH-CBC : Bad Keylen (%i Bits, need %lu)\n",
2282                                         esp_crypt_key_len * 8, (unsigned long) gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt) * 8);
2283                                 decrypt_ok = FALSE;
2284                               }
2285                             else
2286                               decrypt_using_libgcrypt = TRUE;
2287                           }
2288
2289                         break;
2290
2291                       }
2292
2293
2294                     case IPSEC_ENCRYPT_NULL :
2295                     default :
2296                       {
2297                         /* Fix parameters */
2298                         esp_iv_len = 0;
2299                         decrypted_len = len - sizeof(struct newesp);
2300
2301                         if (decrypted_len <= 0)
2302                           decrypt_ok = FALSE;
2303                         else
2304                           {
2305                             /* Allocate Buffers for Encrypted and Decrypted data  */
2306                             decrypted_data = (guint8 *) g_malloc ((decrypted_len + 1)* sizeof(guint8));
2307                             tvb_memcpy(tvb, decrypted_data , sizeof(struct newesp), decrypted_len);
2308
2309                             decrypt_ok = TRUE;
2310                           }
2311
2312                         break;
2313                       }
2314                     }
2315
2316                   if(decrypt_using_libgcrypt)
2317                     {
2318                       /* Allocate Buffers for Encrypted and Decrypted data  */
2319                       encrypted_data = (guint8 *) g_malloc ((decrypted_len_alloc) * sizeof(guint8));
2320                       memset(encrypted_data,0,decrypted_len_alloc);
2321                       decrypted_data = (guint8 *) g_malloc ((decrypted_len_alloc + esp_iv_len)* sizeof(guint8));
2322                       tvb_memcpy(tvb, encrypted_data , sizeof(struct newesp), decrypted_len);
2323
2324                       err = gcry_cipher_open (&cypher_hd, crypt_algo_libgcrypt, crypt_mode_libgcrypt, 0);
2325                       if (err)
2326                         {
2327                           fprintf(stderr,"<IPsec/ESP Dissector> Error in Algorithm %s Mode %d, grcy_open_cipher failed: %s\n",
2328                                   gcry_cipher_algo_name(crypt_algo_libgcrypt), crypt_mode_libgcrypt, gpg_strerror (err));
2329                           g_free(encrypted_data);
2330                           g_free(decrypted_data);
2331                           decrypt_ok = FALSE;
2332                         }
2333
2334                       else
2335                         {
2336                           err = gcry_cipher_setkey (cypher_hd, esp_crypt_key, esp_crypt_key_len);
2337                           if (err)
2338                             {
2339                               fprintf(stderr,"<IPsec/ESP Dissector> Error in Algorithm %s Mode %d, gcry_cipher_setkey failed: %s\n",
2340                                       gcry_cipher_algo_name(crypt_algo_libgcrypt), crypt_mode_libgcrypt, gpg_strerror (err));
2341                               gcry_cipher_close (cypher_hd);
2342                               g_free(encrypted_data);
2343                               g_free(decrypted_data);
2344                               decrypt_ok = FALSE;
2345                             }
2346                           else
2347                             {
2348                               err = gcry_cipher_decrypt (cypher_hd, decrypted_data, decrypted_len_alloc + esp_iv_len, encrypted_data, decrypted_len_alloc);
2349                               if (err)
2350                                 {
2351                                   fprintf(stderr,"<IPsec/ESP Dissector> Error in Algorithm %s, Mode %d, gcry_cipher_decrypt failed: %s\n",
2352                                           gcry_cipher_algo_name(crypt_algo_libgcrypt), crypt_mode_libgcrypt, gpg_strerror (err));
2353                                   gcry_cipher_close (cypher_hd);
2354                                   g_free(encrypted_data);
2355                                   g_free(decrypted_data);
2356                                   decrypt_ok = FALSE;
2357                                 }
2358                               else
2359                                 {
2360                                   gcry_cipher_close (cypher_hd);
2361
2362                                   /* Add the Authentication which was not encrypted */
2363                                   if(decrypted_len >= esp_auth_len)
2364                                     {
2365                                       for(i = 0; i <  esp_auth_len; i++)
2366                                         {
2367                                           decrypted_data[i + decrypted_len -esp_auth_len] = encrypted_data[i + decrypted_len - esp_auth_len];
2368                                         }
2369                                     }
2370
2371                                   fprintf(stderr,"\n\n ");
2372                                   g_free(encrypted_data);
2373                                   decrypt_ok = TRUE;
2374                                 }
2375                             }
2376                         }
2377                     }
2378
2379                   if(decrypt_ok)
2380                     {
2381                       tvb_decrypted = tvb_new_real_data(decrypted_data, decrypted_len, decrypted_len);
2382                       tvb_set_child_real_data_tvbuff(tvb, tvb_decrypted);
2383
2384                       add_new_data_source(pinfo,
2385                                           tvb_decrypted,
2386                                           "Decrypted Data");
2387
2388                       /* Handler to free the Decrypted Data Buffer. */
2389                       tvb_set_free_cb(tvb_decrypted,g_free);
2390                       
2391                       if(tvb_bytes_exist(tvb_decrypted, 0, esp_iv_len))
2392                         {
2393                           if(esp_iv_len > 0)
2394                             proto_tree_add_item(esp_tree, hf_esp_iv,
2395                                                 tvb_decrypted,
2396                                                 0, esp_iv_len,
2397                                                 FALSE);
2398                         }
2399
2400                       else
2401                         proto_tree_add_text(esp_tree, tvb_decrypted,
2402                                             0, -1,
2403                                             "IV (truncated)");
2404
2405                       /* Make sure the packet is not truncated before the fields
2406                        * we need to read to determine the encapsulated protocol */
2407                       if(tvb_bytes_exist(tvb_decrypted, decrypted_len - esp_auth_len - 2, 2))
2408                         {
2409                           esp_pad_len = tvb_get_guint8(tvb_decrypted, decrypted_len - esp_auth_len - 2);
2410
2411                           if(decrypted_len - esp_auth_len - esp_pad_len - esp_iv_len - 2 >= esp_iv_len)
2412                             {
2413                               /* Get the encapsulated protocol */
2414                               encapsulated_protocol = tvb_get_guint8(tvb_decrypted, decrypted_len - esp_auth_len - 1);
2415
2416                               if(dissector_try_port(ip_dissector_table,
2417                                                     encapsulated_protocol,
2418                                                     tvb_new_subset(tvb_decrypted, esp_iv_len,
2419                                                                    decrypted_len - esp_auth_len - esp_pad_len - esp_iv_len - 2,
2420                                                                    decrypted_len - esp_auth_len - esp_pad_len - esp_iv_len - 2),
2421                                                     pinfo,
2422                                                     tree))
2423                                 {
2424                                   decrypt_dissect_ok = TRUE;
2425                                 }
2426                             }
2427
2428                         }
2429
2430                       if(decrypt_dissect_ok)
2431                         {
2432                           if(esp_tree)
2433                             {
2434                               if(esp_pad_len !=0)
2435                                 proto_tree_add_text(esp_tree, tvb_decrypted, decrypted_len - esp_auth_len - 2 - esp_pad_len, esp_pad_len,"Pad");
2436
2437                               proto_tree_add_uint(esp_tree, hf_esp_pad_len, tvb_decrypted,
2438                                                   decrypted_len - esp_auth_len - 2, 1,
2439                                                   esp_pad_len);
2440
2441                               proto_tree_add_uint_format(esp_tree, hf_esp_protocol, tvb_decrypted,
2442                                          decrypted_len - esp_auth_len - 1, 1,
2443                                          encapsulated_protocol,
2444                                         "Next header: %s (0x%02x)",
2445                                          ipprotostr(encapsulated_protocol), encapsulated_protocol);
2446
2447                               dissect_esp_authentication(esp_tree, tvb_decrypted, decrypted_len, esp_auth_len, authenticator_data_computed, authentication_ok, authentication_checking_ok );
2448
2449                             }
2450                         }
2451                       else
2452                         {
2453                           call_dissector(data_handle,
2454                                          tvb_new_subset(tvb_decrypted, 0, decrypted_len - esp_auth_len, decrypted_len - esp_auth_len),
2455                                          pinfo, esp_tree);
2456
2457                           if(esp_tree)
2458                             dissect_esp_authentication(esp_tree, tvb_decrypted, decrypted_len, esp_auth_len, authenticator_data_computed, authentication_ok, authentication_checking_ok );
2459
2460                         }
2461                     }
2462
2463                 }
2464
2465               else
2466                 {
2467                   /* The packet does not belong to a security Association */
2468                   null_encryption_decode_heuristic = g_esp_enable_null_encryption_decode_heuristic;
2469                 }
2470
2471               g_free(ip_src);
2472               g_free(ip_dst);
2473               if(esp_auth_key_len != 0) g_free(esp_auth_key);
2474               if(esp_crypt_key_len != 0) g_free(esp_crypt_key);
2475
2476             }
2477         }
2478     }
2479
2480   /*
2481     If the packet is present in the security association database and the field g_esp_enable_authentication_check set.
2482   */
2483   if(!g_esp_enable_encryption_decode && g_esp_enable_authentication_check && sad_is_present)
2484     {
2485       sad_is_present = FALSE;
2486       call_dissector(data_handle,
2487                      tvb_new_subset(tvb, sizeof(struct newesp), len - sizeof(struct newesp) - esp_auth_len, -1),
2488                      pinfo, esp_tree);
2489
2490       if(esp_tree)
2491         dissect_esp_authentication(esp_tree, tvb, len , esp_auth_len, authenticator_data_computed, authentication_ok, authentication_checking_ok );
2492
2493     }
2494
2495
2496   /* The packet does not belong to a security association and the field g_esp_enable_null_encryption_decode_heuristic is set */
2497   else if(null_encryption_decode_heuristic)
2498     {
2499 #endif
2500       if(g_esp_enable_null_encryption_decode_heuristic)
2501         {
2502           /* Get length of whole ESP packet. */
2503           len = tvb_reported_length(tvb);
2504
2505           /* Make sure the packet is not truncated before the fields
2506            * we need to read to determine the encapsulated protocol */
2507           if(tvb_bytes_exist(tvb, len - 14, 2))
2508             {
2509               esp_pad_len = tvb_get_guint8(tvb, len - 14);
2510               encapsulated_protocol = tvb_get_guint8(tvb, len - 13);
2511               if(dissector_try_port(ip_dissector_table,
2512                                     encapsulated_protocol,
2513                                     tvb_new_subset(tvb,
2514                                                    sizeof(struct newesp),
2515                                                    -1,
2516                                                    len - sizeof(struct newesp) - 14 - esp_pad_len),
2517                                     pinfo,
2518                                     tree))
2519                 {
2520                   decrypt_dissect_ok = TRUE;
2521                 }
2522             }
2523         }
2524
2525       if(decrypt_dissect_ok)
2526         {
2527           if(esp_tree)
2528             {
2529               proto_tree_add_uint(esp_tree, hf_esp_pad_len, tvb,
2530                                   len - 14, 1,
2531                                   esp_pad_len);
2532
2533               proto_tree_add_uint_format(esp_tree, hf_esp_protocol, tvb,
2534                                   len - 13, 1,
2535                                   encapsulated_protocol,
2536                                  "Next header: %s (0x%02x)",
2537                                   ipprotostr(encapsulated_protocol), encapsulated_protocol);
2538
2539               /* Make sure we have the auth trailer data */
2540               if(tvb_bytes_exist(tvb, len - 12, 12))
2541                 {
2542                   proto_tree_add_text(esp_tree, tvb, len - 12, 12,
2543                                       "Authentication Data");
2544                 }
2545
2546               else
2547                 {
2548                   /* Truncated so just display what we have */
2549                   proto_tree_add_text(esp_tree, tvb, len - 12, 12 - (len - tvb_length(tvb)),
2550                                       "Authentication Data (truncated)");
2551                 }
2552             }
2553         }
2554 #ifdef HAVE_LIBGCRYPT
2555
2556   }
2557
2558 #endif
2559 }
2560
2561
2562 static void
2563 dissect_ipcomp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
2564 {
2565   proto_tree *ipcomp_tree;
2566   proto_item *ti;
2567   struct ipcomp ipcomp;
2568   const char *p;
2569
2570   /*
2571    * load the top pane info. This should be overwritten by
2572    * the next protocol in the stack
2573    */
2574   if (check_col(pinfo->cinfo, COL_PROTOCOL))
2575     col_set_str(pinfo->cinfo, COL_PROTOCOL, "IPComp");
2576   if (check_col(pinfo->cinfo, COL_INFO))
2577     col_clear(pinfo->cinfo, COL_INFO);
2578
2579   tvb_memcpy(tvb, (guint8 *)&ipcomp, 0, sizeof(ipcomp));
2580
2581   if (check_col(pinfo->cinfo, COL_INFO)) {
2582     p = match_strval(g_ntohs(ipcomp.comp_cpi), cpi2val);
2583     if (p == NULL) {
2584       col_add_fstr(pinfo->cinfo, COL_INFO, "IPComp (CPI=0x%04x)",
2585                    g_ntohs(ipcomp.comp_cpi));
2586     } else
2587       col_add_fstr(pinfo->cinfo, COL_INFO, "IPComp (CPI=%s)", p);
2588   }
2589
2590   /*
2591    * populate a tree in the second pane with the status of the link layer
2592    * (ie none)
2593    */
2594   if (tree) {
2595     ti = proto_tree_add_item(tree, proto_ipcomp, tvb, 0, -1, FALSE);
2596     ipcomp_tree = proto_item_add_subtree(ti, ett_ipcomp);
2597
2598     proto_tree_add_text(ipcomp_tree, tvb,
2599                         offsetof(struct ipcomp, comp_nxt), 1,
2600                         "Next Header: %s (0x%02x)",
2601                         ipprotostr(ipcomp.comp_nxt), ipcomp.comp_nxt);
2602     proto_tree_add_uint(ipcomp_tree, hf_ipcomp_flags, tvb,
2603                         offsetof(struct ipcomp, comp_flags), 1,
2604                         ipcomp.comp_flags);
2605     proto_tree_add_uint(ipcomp_tree, hf_ipcomp_cpi, tvb,
2606                         offsetof(struct ipcomp, comp_cpi), 2,
2607                         g_ntohs(ipcomp.comp_cpi));
2608     call_dissector(data_handle,
2609                    tvb_new_subset(tvb, sizeof(struct ipcomp), -1, -1), pinfo,
2610                    ipcomp_tree);
2611   }
2612 }
2613
2614 void
2615 proto_register_ipsec(void)
2616 {
2617
2618 #ifdef HAVE_LIBGCRYPT
2619   guint i=0;
2620 #endif
2621
2622   static hf_register_info hf_ah[] = {
2623     { &hf_ah_spi,
2624       { "AH SPI", "ah.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
2625         "IP Authentication Header Security Parameters Index", HFILL }},
2626     { &hf_ah_iv,
2627       { "AH ICV", "ah.icv", FT_BYTES, BASE_HEX, NULL, 0x0,
2628         "IP Authentication Header Integrity Check Value", HFILL }},
2629     { &hf_ah_sequence,
2630       { "AH Sequence", "ah.sequence", FT_UINT32, BASE_DEC, NULL, 0x0,
2631         "IP Authentication Header Sequence Number", HFILL }}
2632   };
2633
2634   static hf_register_info hf_esp[] = {
2635     { &hf_esp_spi,
2636       { "ESP SPI", "esp.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
2637         "IP Encapsulating Security Payload Security Parameters Index", HFILL }},
2638     { &hf_esp_sequence,
2639       { "ESP Sequence", "esp.sequence", FT_UINT32, BASE_DEC, NULL, 0x0,
2640         "IP Encapsulating Security Payload Sequence Number", HFILL }},
2641     { &hf_esp_pad_len,
2642       { "ESP Pad Length", "esp.pad_len", FT_UINT8, BASE_DEC, NULL, 0x0,
2643         "IP Encapsulating Security Payload Pad Length", HFILL }},
2644     { &hf_esp_protocol,
2645       { "ESP Next Header", "esp.protocol", FT_UINT8, BASE_HEX, NULL, 0x0,
2646         "IP Encapsulating Security Payload Next Header", HFILL }},
2647     { &hf_esp_iv,
2648       { "ESP IV", "esp.iv", FT_BYTES, BASE_HEX, NULL, 0x0,
2649         "IP Encapsulating Security Payload ", HFILL }}
2650   };
2651
2652   static hf_register_info hf_ipcomp[] = {
2653     { &hf_ipcomp_flags,
2654       { "IPComp Flags", "ipcomp.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
2655         "IP Payload Compression Protocol Flags", HFILL }},
2656     { &hf_ipcomp_cpi,
2657       { "IPComp CPI", "ipcomp.cpi", FT_UINT16, BASE_HEX, VALS(cpi2val), 0x0,
2658         "IP Payload Compression Protocol Compression Parameter Index", HFILL }},
2659   };
2660   static gint *ett[] = {
2661     &ett_ah,
2662     &ett_esp,
2663     &ett_ipcomp,
2664   };
2665
2666 #ifdef HAVE_LIBGCRYPT
2667   GString *name_str, *title_str;
2668
2669 #define PREF_STR_INIT() \
2670   name_str = g_string_new(""); \
2671   title_str = g_string_new("")
2672
2673 #define PREF_STR_FREE() \
2674   g_string_free(name_str, FALSE); \
2675   g_string_free(title_str, FALSE)
2676
2677   static enum_val_t esp_encryption_algo[] = {
2678
2679     {"null", "NULL", IPSEC_ENCRYPT_NULL},
2680     {"3descbc", "TripleDES-CBC [RFC2451]", IPSEC_ENCRYPT_3DES_CBC},
2681     {"aescbc", "AES-CBC [RFC3602]", IPSEC_ENCRYPT_AES_CBC},
2682     {"aesctr", "AES-CTR [RFC3686]", IPSEC_ENCRYPT_AES_CTR},
2683     {"descbc", "DES-CBC [RFC2405]", IPSEC_ENCRYPT_DES_CBC},
2684     {"cast5cbc", "CAST5-CBC [RFC2144]", IPSEC_ENCRYPT_CAST5_CBC},
2685     {"blowfishcbc","BLOWFISH-CBC [RFC2451]", IPSEC_ENCRYPT_BLOWFISH_CBC},
2686     {"twofishcbc","TWOFISH-CBC", IPSEC_ENCRYPT_TWOFISH_CBC},
2687     {NULL,NULL,0}
2688   };
2689
2690   static enum_val_t esp_authentication_algo[] = {
2691
2692     {"null", "NULL", IPSEC_AUTH_NULL},
2693     {"hmacsha196", "HMAC-SHA1-96 [RFC2404]", IPSEC_AUTH_HMAC_SHA1_96},
2694     {"hmacsha256", "HMAC-SHA256", IPSEC_AUTH_HMAC_SHA256},
2695     {"hmacmd596", "HMAC-MD5-96 [RFC2403]", IPSEC_AUTH_HMAC_MD5_96},
2696     {"hmacripemd160", "HMAC-RIPEMD", IPSEC_AUTH_HMAC_RIPEMD160_96},
2697     /*    {"aesxcbcmac96", "AES-XCBC-MAC-96 [RFC3566]", IPSEC_AUTH_AES_XCBC_MAC_96}, */
2698     {"any12bytes", "ANY 12-bytes of Authentication [No Checking]", IPSEC_AUTH_ANY_12BYTES},
2699     {NULL,NULL,0}
2700   };
2701 #endif
2702
2703   module_t *ah_module;
2704   module_t *esp_module;
2705
2706   proto_ah = proto_register_protocol("Authentication Header", "AH", "ah");
2707   proto_register_field_array(proto_ah, hf_ah, array_length(hf_ah));
2708
2709   proto_esp = proto_register_protocol("Encapsulating Security Payload",
2710                                       "ESP", "esp");
2711   proto_register_field_array(proto_esp, hf_esp, array_length(hf_esp));
2712
2713   proto_ipcomp = proto_register_protocol("IP Payload Compression",
2714                                          "IPComp", "ipcomp");
2715   proto_register_field_array(proto_ipcomp, hf_ipcomp, array_length(hf_ipcomp));
2716
2717   proto_register_subtree_array(ett, array_length(ett));
2718
2719   /* Register a configuration option for placement of AH payload dissection */
2720   ah_module = prefs_register_protocol(proto_ah, NULL);
2721   prefs_register_bool_preference(ah_module, "place_ah_payload_in_subtree",
2722                                  "Place AH payload in subtree",
2723                                  "Whether the AH payload decode should be placed in a subtree",
2724                                  &g_ah_payload_in_subtree);
2725   esp_module = prefs_register_protocol(proto_esp, NULL);
2726
2727 #ifdef HAVE_LIBGCRYPT
2728   /* Register SA configuration options for ESP decryption */
2729   g_esp_sad.nb = g_esp_nb_sa;
2730   for(i = 0; i < g_esp_nb_sa; i++)
2731     {
2732       g_esp_sad.table[i].sa = NULL;
2733       g_esp_sad.table[i].typ = IPSEC_SA_UNKNOWN;
2734       g_esp_sad.table[i].src = NULL;
2735       g_esp_sad.table[i].dst = NULL;
2736       g_esp_sad.table[i].spi = NULL;
2737       g_esp_sad.table[i].src_len = -1;
2738       g_esp_sad.table[i].dst_len = -1;
2739       g_esp_sad.table[i].encryption_algo = IPSEC_ENCRYPT_NULL;
2740       g_esp_sad.table[i].authentication_algo = IPSEC_AUTH_NULL;
2741       g_esp_sad.table[i].encryption_key = NULL;
2742       g_esp_sad.table[i].authentication_key = NULL;
2743       g_esp_sad.table[i].is_valid = FALSE;
2744     }
2745 #endif
2746
2747   prefs_register_bool_preference(esp_module, "enable_null_encryption_decode_heuristic",
2748                                  "Attempt to detect/decode NULL encrypted ESP payloads",
2749                                  "This is done only if the Decoding is not SET or the packet does not belong to a SA. Assumes a 12 byte auth (HMAC-SHA1-96/HMAC-MD5-96/AES-XCBC-MAC-96) and attempts decode based on the ethertype 13 bytes from packet end",
2750                                  &g_esp_enable_null_encryption_decode_heuristic);
2751
2752
2753 #ifdef HAVE_LIBGCRYPT
2754   prefs_register_bool_preference(esp_module, "enable_encryption_decode",
2755                                  "Attempt to detect/decode encrypted ESP payloads",
2756                                  "Attempt to decode based on the SAD described hereafter.",
2757                                  &g_esp_enable_encryption_decode);
2758
2759   prefs_register_bool_preference(esp_module, "enable_authentication_check",
2760                                  "Attempt to Check ESP Authentication",
2761                                  "Attempt to Check ESP Authentication based on the SAD described hereafter.",
2762                                  &g_esp_enable_authentication_check);
2763
2764
2765   /* prefs_register_uint_preference(esp_module, "nb_sa",
2766      "Number of Security Associations",
2767      "Number of Security Associations in the SAD",
2768      10, &g_esp_nb_sa); */
2769
2770   for (i = 0; i < g_esp_nb_sa; i++)
2771     {
2772
2773       if (i >=  g_max_esp_nb_sa)
2774         {
2775           break;
2776         }
2777
2778       PREF_STR_INIT();
2779       g_string_printf(name_str,"sa_%d", i + 1);
2780       g_string_printf(title_str,"SA #%d", i + 1);
2781
2782       prefs_register_string_preference(esp_module, name_str->str, title_str->str,
2783                         "SA identifier.  Must have the form "
2784                         "\"Protocol|Source Address|Destination Adress|SPI\". "
2785                         "Example: \"IPv4|192.168.0.45|10.1.2.7|*\" "
2786                         "See the ESP Preferences page on the Wireshark wiki "
2787                         "(http://wiki.wireshark.org/ESP_Preferences) for "
2788                         "more details.",
2789                         &g_esp_sad.table[i].sa);
2790       PREF_STR_FREE();
2791
2792
2793       PREF_STR_INIT();
2794       g_string_printf(name_str, "encryption_algorithm_%d", i + 1);
2795       g_string_printf(title_str, "Encryption Algorithm #%d", i + 1);
2796
2797       prefs_register_enum_preference(esp_module, name_str->str, title_str->str,
2798                         "Encryption algorithm",
2799                         &g_esp_sad.table[i].encryption_algo, esp_encryption_algo, FALSE);
2800       PREF_STR_FREE();
2801
2802       PREF_STR_INIT();
2803       g_string_printf(name_str, "authentication_algorithm_%d", i + 1);
2804       g_string_printf(title_str, "Authentication Algorithm #%d", i + 1);
2805
2806       prefs_register_enum_preference(esp_module, name_str->str, title_str->str,
2807                         "Authentication algorithm",
2808                         &g_esp_sad.table[i].authentication_algo, esp_authentication_algo, FALSE);
2809       PREF_STR_FREE();
2810
2811
2812       PREF_STR_INIT();
2813       g_string_printf(name_str, "encryption_key_%d", i + 1);
2814       g_string_printf(title_str, "Encryption Key #%d", i + 1);
2815
2816       prefs_register_string_preference(esp_module, name_str->str, title_str->str,
2817                         "Encryption key. May be ASCII or hexadecimal (if "
2818                         "prepended with 0x)."
2819                         "See the ESP Preferences page on the Wireshark wiki "
2820                         "(http://wiki.wireshark.org/ESP_Preferences) for "
2821                         "supported sizes.",
2822                         &g_esp_sad.table[i].encryption_key);
2823       PREF_STR_FREE();
2824
2825
2826       PREF_STR_INIT();
2827       g_string_printf(name_str, "authentication_key_%d", i + 1);
2828       g_string_printf(title_str, "Authentication Key #%d", i + 1);
2829
2830       prefs_register_string_preference(esp_module, name_str->str, title_str->str,
2831                         "Authentication key. May be ASCII or hexadecimal (if "
2832                         "prepended with 0x)."
2833                         "See the ESP Preferences page on the Wireshark wiki "
2834                         "(http://wiki.wireshark.org/ESP_Preferences) for "
2835                         "supported sizes.",
2836                         &g_esp_sad.table[i].authentication_key);
2837       PREF_STR_FREE();
2838
2839     }
2840
2841
2842 #endif
2843
2844   register_dissector("esp", dissect_esp, proto_esp);
2845   register_dissector("ah", dissect_ah, proto_ah);
2846
2847 }
2848
2849 void
2850 proto_reg_handoff_ipsec(void)
2851 {
2852   dissector_handle_t esp_handle, ah_handle, ipcomp_handle;
2853
2854   data_handle = find_dissector("data");
2855   ah_handle = find_dissector("ah");
2856   dissector_add("ip.proto", IP_PROTO_AH, ah_handle);
2857   esp_handle = find_dissector("esp");
2858   dissector_add("ip.proto", IP_PROTO_ESP, esp_handle);
2859   ipcomp_handle = create_dissector_handle(dissect_ipcomp, proto_ipcomp);
2860   dissector_add("ip.proto", IP_PROTO_IPCOMP, ipcomp_handle);
2861
2862   ip_dissector_table = find_dissector_table("ip.proto");
2863 }
2864
2865
2866