ESP: fix a memory leak in UAT management
[metze/wireshark/wip.git] / epan / dissectors / packet-ipsec.c
1 /* packet-ipsec.c
2  * Routines for IPsec/IPComp packet disassembly
3  *
4  * Wireshark - Network traffic analyzer
5  * By Gerald Combs <gerald@wireshark.org>
6  * Copyright 1998 Gerald Combs
7  *
8  * SPDX-License-Identifier: GPL-2.0-or-later
9  */
10
11
12 /*
13
14 Addon: ESP Decryption and Authentication Checking
15
16 Frederic ROUDAUT (frederic.roudaut@free.fr)
17 Copyright 2006 Frederic ROUDAUT
18
19 - Decrypt ESP Payload for the following Algorithms defined in RFC 4305:
20
21 Encryption Algorithm
22 --------------------
23 NULL
24 TripleDES-CBC [RFC2451] : keylen 192 bits.
25 AES-CBC with 128-bit keys [RFC3602] : keylen 128 and 192/256 bits.
26 AES-CTR [RFC3686] : keylen 160/224/288 bits. The remaining 32 bits will be used as nonce.
27 DES-CBC [RFC2405] : keylen 64 bits
28
29 - Add ESP Payload Decryption support for the following Encryption Algorithms :
30 BLOWFISH-CBC : keylen 128 bits.
31 TWOFISH-CBC : keylen 128/256 bits.
32 CAST5-CBC :  keylen 128
33
34 - Check ESP Authentication for the following Algorithms defined in RFC 4305:
35
36 Authentication Algorithm
37 ------------------------
38 NULL
39 HMAC-SHA1-96 [RFC2404] : any keylen
40 HMAC-MD5-96 [RFC2403] : any keylen
41 AES-XCBC-MAC-96 [RFC3566] : Not available because no implementation found.
42
43 - Add ESP Authentication checking for the following Authentication Algorithm :
44 HMAC-SHA256 : any keylen
45 HMAC-RIPEMD160-96 [RFC2857] : any keylen
46
47 - Added/Modified Authentication checking (David Dahlberg <dahlberg@fgan.de>):
48 CHG: HMAC-SHA256 is now HMAC-SHA-256-96 [draft-ietf-ipsec-ciph-sha-256-00]
49      -> It is implemented this way in USAGI/KAME (Linux/BSD).
50 ADD: HMAC-SHA-256-128 [RFC4868]
51      ICV length of HMAC-SHA-256 was changed in draft-ietf-ipsec-ciph-sha-256-01
52      to 128 bit. This is "SHOULD" be the standard now!
53 ADD: Additional generic (non-checked) ICV length of 128, 192 and 256.
54      This follows RFC 4868 for the SHA-256+ family.
55
56 */
57
58 #include "config.h"
59
60
61 #include <epan/packet.h>
62 #include <epan/addr_resolv.h>
63 #include <epan/ipproto.h>
64 #include <epan/prefs.h>
65 #include <epan/expert.h>
66 #include <epan/tap.h>
67 #include <epan/exported_pdu.h>
68 #include <epan/proto_data.h>
69 #include <epan/decode_as.h>
70 #include <epan/capture_dissectors.h>
71
72 #include <stdio.h>
73 #include <epan/uat.h>
74 #include <wsutil/wsgcrypt.h>
75
76 #include "packet-ipsec.h"
77 #include "packet-ip.h"
78
79 void proto_register_ipsec(void);
80 void proto_reg_handoff_ipsec(void);
81
82 static int proto_ah = -1;
83 static int hf_ah_next_header = -1;
84 static int hf_ah_length = -1;
85 static int hf_ah_reserved = -1;
86 static int hf_ah_spi = -1;
87 static int hf_ah_iv = -1;
88 static int hf_ah_sequence = -1;
89 static int proto_esp = -1;
90 static int hf_esp_spi = -1;
91 static int hf_esp_iv = -1;
92 static int hf_esp_icv_good = -1;
93 static int hf_esp_icv_bad = -1;
94 static int hf_esp_sequence = -1;
95 static int hf_esp_pad = -1;
96 static int hf_esp_pad_len = -1;
97 static int hf_esp_protocol = -1;
98 static int hf_esp_authentication_data = -1;
99 static int hf_esp_sequence_analysis_expected_sn = -1;
100 static int hf_esp_sequence_analysis_previous_frame = -1;
101
102 static int proto_ipcomp = -1;
103 static int hf_ipcomp_next_header = -1;
104 static int hf_ipcomp_flags = -1;
105 static int hf_ipcomp_cpi = -1;
106
107 static gint ett_ah = -1;
108 static gint ett_esp = -1;
109 static gint ett_esp_icv = -1;
110 static gint ett_ipcomp = -1;
111
112 static expert_field ei_esp_sequence_analysis_wrong_sequence_number = EI_INIT;
113
114
115 static gint exported_pdu_tap = -1;
116
117 static dissector_handle_t data_handle;
118
119 static dissector_table_t ip_dissector_table;
120
121 /* Encryption algorithms defined in RFC 4305 */
122 #define IPSEC_ENCRYPT_NULL 0
123 #define IPSEC_ENCRYPT_3DES_CBC 1
124 #define IPSEC_ENCRYPT_AES_CBC 2
125 #define IPSEC_ENCRYPT_AES_CTR 3
126 #define IPSEC_ENCRYPT_DES_CBC 4
127 #define IPSEC_ENCRYPT_BLOWFISH_CBC 5
128 #define IPSEC_ENCRYPT_TWOFISH_CBC 6
129
130 /* Encryption algorithm defined in RFC 2144 */
131 #define IPSEC_ENCRYPT_CAST5_CBC 7
132
133 /* Encryption algorithm defined in RFC 4106 */
134 #define IPSEC_ENCRYPT_AES_GCM 8
135
136 /* Authentication algorithms defined in RFC 4305 */
137 #define IPSEC_AUTH_NULL 0
138 #define IPSEC_AUTH_HMAC_SHA1_96 1
139 #define IPSEC_AUTH_HMAC_SHA256_96 2
140 #define IPSEC_AUTH_HMAC_SHA256_128 3
141 #define IPSEC_AUTH_HMAC_SHA384_192 4
142 #define IPSEC_AUTH_HMAC_SHA512_256 5
143 #define IPSEC_AUTH_HMAC_MD5_96 6
144 #define IPSEC_AUTH_HMAC_RIPEMD160_96 7
145 /* define IPSEC_AUTH_AES_XCBC_MAC_96 6 */
146 #define IPSEC_AUTH_ANY_64BIT 8
147 #define IPSEC_AUTH_ANY_96BIT 9
148 #define IPSEC_AUTH_ANY_128BIT 10
149 #define IPSEC_AUTH_ANY_192BIT 11
150 #define IPSEC_AUTH_ANY_256BIT 12
151
152 #define IPSEC_IPV6_ADDR_LEN 128
153 #define IPSEC_IPV4_ADDR_LEN 32
154 #define IPSEC_STRLEN_IPV6 32
155 #define IPSEC_STRLEN_IPV4 8
156 #define IPSEC_SA_IPV4 1
157 #define IPSEC_SA_IPV6 2
158 #define IPSEC_SA_UNKNOWN -1
159 #define IPSEC_SA_WILDCARDS_ANY '*'
160 /* the maximum number of bytes (10)(including the terminating nul character(11)) */
161 #define IPSEC_SPI_LEN_MAX 11
162
163
164 /* well-known algorithm number (in CPI), from RFC2409 */
165 #define IPCOMP_OUI      1       /* vendor specific */
166 #define IPCOMP_DEFLATE  2       /* RFC2394 */
167 #define IPCOMP_LZS      3       /* RFC2395 */
168 #define IPCOMP_MAX      4
169
170
171 static const value_string cpi2val[] = {
172   { IPCOMP_OUI, "OUI" },
173   { IPCOMP_DEFLATE, "DEFLATE" },
174   { IPCOMP_LZS, "LZS" },
175   { 0, NULL },
176 };
177
178 #define NEW_ESP_DATA_SIZE       8
179
180 /*-------------------------------------
181  * UAT for ESP
182  *-------------------------------------
183  */
184 /* UAT entry structure. */
185 typedef struct {
186   guint8 protocol;
187   gchar *srcIP;
188   gchar *dstIP;
189   gchar *spi;
190
191   guint8 encryption_algo;
192   gchar *encryption_key_string;
193   gchar *encryption_key;
194   gint encryption_key_length;
195   gboolean         cipher_hd_created;
196   gcry_cipher_hd_t cipher_hd;     /* Key is stored here and closed with the SA */
197
198   guint8 authentication_algo;
199   gchar *authentication_key_string;
200   gchar *authentication_key;
201   gint authentication_key_length;
202 } uat_esp_sa_record_t;
203
204 static uat_esp_sa_record_t *uat_esp_sa_records = NULL;
205
206 /* Extra SA records that may be set programmatically */
207 /* 'records' array is now allocated on the heap */
208 #define MAX_EXTRA_SA_RECORDS 16
209 typedef struct extra_esp_sa_records_t {
210   guint num_records;
211   uat_esp_sa_record_t *records;
212 } extra_esp_sa_records_t;
213 static extra_esp_sa_records_t extra_esp_sa_records;
214
215 static uat_t * esp_uat = NULL;
216 static guint num_sa_uat = 0;
217
218 /*
219    Name : static gint compute_ascii_key(gchar **ascii_key, gchar *key)
220    Description : Allocate memory for the key and transform the key if it is hexadecimal
221    Return : Return the key length
222    Params:
223       - gchar **ascii_key : the resulting ascii key allocated here
224       - gchar *key : the key to compute
225 */
226 static gint
227 compute_ascii_key(gchar **ascii_key, const gchar *key)
228 {
229   guint key_len = 0, raw_key_len;
230   gint hex_digit;
231   guchar key_byte;
232   guint i, j;
233
234   if(key != NULL)
235   {
236     raw_key_len = (guint)strlen(key);
237     if((raw_key_len > 2) && (key[0] == '0') && ((key[1] == 'x') || (key[1] == 'X')))
238     {
239       /*
240        * Key begins with "0x" or "0X"; skip that and treat the rest
241        * as a sequence of hex digits.
242        */
243       i = 2;    /* first character after "0[Xx]" */
244       j = 0;
245       if(raw_key_len %2  == 1)
246       {
247         /*
248          * Key has an odd number of characters; we act as if the
249          * first character had a 0 in front of it, making the
250          * number of characters even.
251          */
252         key_len = (raw_key_len - 2) / 2 + 1;
253         *ascii_key = (gchar *) g_malloc ((key_len + 1)* sizeof(gchar));
254         hex_digit = g_ascii_xdigit_value(key[i]);
255         i++;
256         if (hex_digit == -1)
257         {
258           g_free(*ascii_key);
259           *ascii_key = NULL;
260           return -1;    /* not a valid hex digit */
261         }
262         (*ascii_key)[j] = (guchar)hex_digit;
263         j++;
264       }
265       else
266       {
267         /*
268          * Key has an even number of characters, so we treat each
269          * pair of hex digits as a single byte value.
270          */
271         key_len = (raw_key_len - 2) / 2;
272         *ascii_key = (gchar *) g_malloc ((key_len + 1)* sizeof(gchar));
273       }
274
275       while(i < (raw_key_len -1))
276       {
277         hex_digit = g_ascii_xdigit_value(key[i]);
278         i++;
279         if (hex_digit == -1)
280         {
281           g_free(*ascii_key);
282           *ascii_key = NULL;
283           return -1;    /* not a valid hex digit */
284         }
285         key_byte = ((guchar)hex_digit) << 4;
286         hex_digit = g_ascii_xdigit_value(key[i]);
287         i++;
288         if (hex_digit == -1)
289         {
290           g_free(*ascii_key);
291           *ascii_key = NULL;
292           return -1;    /* not a valid hex digit */
293         }
294         key_byte |= (guchar)hex_digit;
295         (*ascii_key)[j] = key_byte;
296         j++;
297       }
298       (*ascii_key)[j] = '\0';
299     }
300
301     else if((raw_key_len == 2) && (key[0] == '0') && ((key[1] == 'x') || (key[1] == 'X')))
302     {
303       *ascii_key = NULL;
304       return 0;
305     }
306     else
307     {
308       key_len = raw_key_len;
309       *ascii_key = g_strdup(key);
310     }
311   }
312
313   return key_len;
314 }
315
316
317 static gboolean uat_esp_sa_record_update_cb(void* r, char** err _U_) {
318   uat_esp_sa_record_t* rec = (uat_esp_sa_record_t *)r;
319
320   /* Compute keys & lengths once and for all */
321   g_free(rec->encryption_key);
322   if (rec->cipher_hd_created) {
323     gcry_cipher_close(rec->cipher_hd);
324     rec->cipher_hd_created = FALSE;
325   }
326   if (rec->encryption_key_string) {
327     rec->encryption_key_length = compute_ascii_key(&rec->encryption_key, rec->encryption_key_string);
328   }
329   else {
330     rec->encryption_key_length = 0;
331     rec->encryption_key = NULL;
332   }
333
334   g_free(rec->authentication_key);
335   if (rec->authentication_key_string) {
336     rec->authentication_key_length = compute_ascii_key(&rec->authentication_key, rec->authentication_key_string);
337   }
338   else {
339     rec->authentication_key_length = 0;
340     rec->authentication_key = NULL;
341   }
342   return TRUE;
343 }
344
345 static void* uat_esp_sa_record_copy_cb(void* n, const void* o, size_t siz _U_) {
346   uat_esp_sa_record_t* new_rec = (uat_esp_sa_record_t *)n;
347   const uat_esp_sa_record_t* old_rec = (const uat_esp_sa_record_t *)o;
348
349   /* Copy UAT fields */
350   new_rec->protocol = old_rec->protocol;
351   new_rec->srcIP = g_strdup(old_rec->srcIP);
352   new_rec->dstIP = g_strdup(old_rec->dstIP);
353   new_rec->spi = g_strdup(old_rec->spi);
354   new_rec->encryption_algo = old_rec->encryption_algo;
355   new_rec->encryption_key_string = g_strdup(old_rec->encryption_key_string);
356   new_rec->encryption_key = NULL;
357   new_rec->cipher_hd_created = FALSE;
358   new_rec->authentication_algo = old_rec->authentication_algo;
359   new_rec->authentication_key_string = g_strdup(old_rec->authentication_key_string);
360   new_rec->authentication_key = NULL;
361
362   /* Parse keys as in an update */
363   uat_esp_sa_record_update_cb(new_rec, NULL);
364
365   return new_rec;
366 }
367
368 static void uat_esp_sa_record_free_cb(void*r) {
369   uat_esp_sa_record_t* rec = (uat_esp_sa_record_t*)r;
370
371   g_free(rec->srcIP);
372   g_free(rec->dstIP);
373   g_free(rec->spi);
374   g_free(rec->encryption_key_string);
375   g_free(rec->encryption_key);
376   g_free(rec->authentication_key_string);
377   g_free(rec->authentication_key);
378
379   if (rec->cipher_hd_created) {
380     gcry_cipher_close(rec->cipher_hd);
381     rec->cipher_hd_created = FALSE;
382   }
383 }
384
385 UAT_VS_DEF(uat_esp_sa_records, protocol, uat_esp_sa_record_t, guint8, IPSEC_SA_IPV4, "IPv4")
386 UAT_CSTRING_CB_DEF(uat_esp_sa_records, srcIP, uat_esp_sa_record_t)
387 UAT_CSTRING_CB_DEF(uat_esp_sa_records, dstIP, uat_esp_sa_record_t)
388 UAT_CSTRING_CB_DEF(uat_esp_sa_records, spi, uat_esp_sa_record_t)
389 UAT_VS_DEF(uat_esp_sa_records, encryption_algo, uat_esp_sa_record_t, guint8, 0, "FIXX")
390 UAT_CSTRING_CB_DEF(uat_esp_sa_records, encryption_key_string, uat_esp_sa_record_t)
391 UAT_VS_DEF(uat_esp_sa_records, authentication_algo, uat_esp_sa_record_t, guint8, 0, "FIXX")
392 UAT_CSTRING_CB_DEF(uat_esp_sa_records, authentication_key_string, uat_esp_sa_record_t)
393
394
395 /* Configure a new SA (programmatically, most likely from a private dissector).
396    The arguments here are deliberately in the same string formats as the UAT fields
397    in order to keep code paths common.
398    Note that an attempt to match with these entries will be made *before* entries
399    added through the UAT entry interface/file. */
400 void esp_sa_record_add_from_dissector(guint8 protocol, const gchar *srcIP, const char *dstIP,
401                                       gchar *spi,
402                                       guint8 encryption_algo, const gchar *encryption_key,
403                                       guint8 authentication_algo, const gchar *authentication_key)
404 {
405    uat_esp_sa_record_t* record = NULL;
406    if (extra_esp_sa_records.num_records == 0) {
407       extra_esp_sa_records.records = (uat_esp_sa_record_t *)g_malloc(sizeof(uat_esp_sa_record_t)*MAX_EXTRA_SA_RECORDS);
408    }
409    if (extra_esp_sa_records.num_records < MAX_EXTRA_SA_RECORDS) {
410       record = &extra_esp_sa_records.records[extra_esp_sa_records.num_records++];
411    }
412    else {
413       /* No room left!! */
414       fprintf(stderr, "<IPsec/ESP Dissector> Failed to add UE as already have max (%d) configured\n",
415               MAX_EXTRA_SA_RECORDS);
416       return;
417    }
418
419    /* Copy key fields */
420    record->protocol = protocol;
421    record->srcIP = g_strdup(srcIP);
422    record->dstIP = g_strdup(dstIP);
423    record->spi = g_strdup(spi);
424
425    /* Encryption */
426    record->encryption_algo = encryption_algo;
427    record->encryption_key_string = g_strdup(encryption_key);
428    record->encryption_key = NULL;
429    record->cipher_hd_created = FALSE;
430
431    /* Authentication */
432    record->authentication_algo = authentication_algo;
433    record->authentication_key_string = g_strdup(authentication_key);
434    record->authentication_key = NULL;
435
436    /* Parse keys */
437    uat_esp_sa_record_update_cb(record, NULL);
438 }
439
440 /*************************************/
441 /* Preference settings               */
442
443 /* Default ESP payload decode to off */
444 static gboolean g_esp_enable_encryption_decode = FALSE;
445
446 /* Default ESP payload Authentication Checking to off */
447 static gboolean g_esp_enable_authentication_check = FALSE;
448
449 /**************************************************/
450 /* Sequence number analysis                       */
451
452 /* SPI state, key is just 32-bit SPI */
453 typedef struct
454 {
455     guint32  previousSequenceNumber;
456     guint32  previousFrameNum;
457 } spi_status;
458
459 /* The sequence analysis SPI hash table.
460    Maps SPI -> spi_status */
461 static wmem_map_t *esp_sequence_analysis_hash = NULL;
462
463 /* Results are stored here: framenum -> spi_status */
464 /* N.B. only store entries for out-of-order frames, if there is no entry for
465    a given frame, it was found to be in-order */
466 static wmem_map_t *esp_sequence_analysis_report_hash = NULL;
467
468 /* During the first pass, update the SPI state.  If the sequence numbers
469    are out of order, add an entry to the report table */
470 static void check_esp_sequence_info(guint32 spi, guint32 sequence_number, packet_info *pinfo)
471 {
472   /* Do the table lookup */
473   spi_status *status = (spi_status*)wmem_map_lookup(esp_sequence_analysis_hash,
474                                                         GUINT_TO_POINTER((guint)spi));
475   if (status == NULL) {
476     /* Create an entry for this SPI */
477     status = wmem_new0(wmem_file_scope(), spi_status);
478     status->previousSequenceNumber = sequence_number;
479     status->previousFrameNum = pinfo->num;
480
481     /* And add it to the table */
482     wmem_map_insert(esp_sequence_analysis_hash, GUINT_TO_POINTER((guint)spi), status);
483   }
484   else {
485     spi_status *frame_status;
486
487     /* Entry already existed, so check that we got the sequence number we expected. */
488     if (sequence_number != status->previousSequenceNumber+1) {
489       /* Create report entry */
490       frame_status = wmem_new0(wmem_file_scope(), spi_status);
491       /* Copy what was expected */
492       *frame_status = *status;
493       /* And add it into the report table */
494       wmem_map_insert(esp_sequence_analysis_report_hash, GUINT_TO_POINTER(pinfo->num), frame_status);
495     }
496     /* Adopt this setting as 'current' regardless of whether expected */
497     status->previousSequenceNumber = sequence_number;
498     status->previousFrameNum = pinfo->num;
499   }
500 }
501
502 /* Check to see if there is a report stored for this frame.  If there is,
503    add it to the tree and report using expert info */
504 static void show_esp_sequence_info(guint32 spi, guint32 sequence_number,
505                                    tvbuff_t *tvb, proto_tree *tree, packet_info *pinfo)
506 {
507   /* Look up this frame in the report table. */
508   spi_status *status = (spi_status*)wmem_map_lookup(esp_sequence_analysis_report_hash,
509                                                         GUINT_TO_POINTER(pinfo->num));
510   if (status != NULL) {
511     proto_item *sn_ti, *frame_ti;
512
513     /* Expected sequence number */
514     sn_ti = proto_tree_add_uint(tree, hf_esp_sequence_analysis_expected_sn,
515                                 tvb, 0, 0, status->previousSequenceNumber+1);
516     if (sequence_number > (status->previousSequenceNumber+1)) {
517       proto_item_append_text(sn_ti, " (%u SNs missing)",
518                              sequence_number - (status->previousSequenceNumber+1));
519     }
520     PROTO_ITEM_SET_GENERATED(sn_ti);
521
522     /* Link back to previous frame for SPI */
523     frame_ti = proto_tree_add_uint(tree, hf_esp_sequence_analysis_previous_frame,
524                                    tvb, 0, 0, status->previousFrameNum);
525     PROTO_ITEM_SET_GENERATED(frame_ti);
526
527     /* Expert info */
528     if (sequence_number == status->previousSequenceNumber) {
529       expert_add_info_format(pinfo, sn_ti, &ei_esp_sequence_analysis_wrong_sequence_number,
530                              "Wrong Sequence Number for SPI %08x - %u repeated",
531                              spi, sequence_number);
532     }
533     else if (sequence_number > status->previousSequenceNumber+1) {
534       expert_add_info_format(pinfo, sn_ti, &ei_esp_sequence_analysis_wrong_sequence_number,
535                              "Wrong Sequence Number for SPI %08x - %u missing",
536                              spi,
537                              sequence_number - (status->previousSequenceNumber+1));
538     }
539     else {
540       expert_add_info_format(pinfo, sn_ti, &ei_esp_sequence_analysis_wrong_sequence_number,
541                              "Wrong Sequence Number for SPI %08x - %u less than expected",
542                              spi,
543                              (status->previousSequenceNumber+1) - sequence_number);
544     }
545   }
546 }
547
548 /*
549    Default ESP payload heuristic decode to off
550    (only works if payload is NULL encrypted and ESP payload decode is off or payload is NULL encrypted
551    and the packet does not match a Security Association).
552 */
553 static gboolean g_esp_enable_null_encryption_decode_heuristic = FALSE;
554
555 /* Default to doing ESP sequence analysis */
556 static gboolean g_esp_do_sequence_analysis = TRUE;
557
558
559
560 /*
561    Name : static int get_ipv6_suffix(char* ipv6_suffix, char *ipv6_address)
562    Description : Get the extended IPv6 Suffix of an IPv6 Address
563    Return : Return the number of char of the IPv6 address suffix parsed
564    Params:
565       - char *ipv6_address : the valid ipv6 address to parse in char *
566       - char *ipv6_suffix : the ipv6 suffix associated in char *
567
568       ex: if IPv6 address is "3ffe::1" the IPv6 suffix will be "0001" and the function will return 3
569 */
570 static int get_ipv6_suffix(char* ipv6_suffix, char *ipv6_address)
571 {
572   char suffix[IPSEC_STRLEN_IPV6 + 1];
573   int cpt = 0;
574   int cpt_suffix = 0;
575   int cpt_seg = 0;
576   int j =0;
577   int ipv6_len = 0;
578   gboolean found = FALSE;
579
580   ipv6_len = (int) strlen(ipv6_address);
581   if(ipv6_len  != 0)
582     {
583       while ( (cpt_suffix < IPSEC_STRLEN_IPV6) && (ipv6_len - cpt -1 >= 0) && (found == FALSE))
584         {
585           if(ipv6_address[ipv6_len - cpt - 1] == ':')
586             {
587               /* Add some 0 to the prefix; */
588               for(j = cpt_seg; j < 4; j++)
589                 {
590                   suffix[IPSEC_STRLEN_IPV6 -1 -cpt_suffix] = '0';
591                   cpt_suffix ++;
592                 }
593               cpt_seg = 0;
594
595               if(ipv6_len - cpt - 1 == 0)
596                 {
597                   /* Found a suffix */
598                   found = TRUE;
599                 }
600               else
601                 if(ipv6_address[ipv6_len - cpt - 2] == ':')
602                   {
603                     /* found a suffix */
604                     cpt +=2;
605                     found = TRUE;
606                   }
607
608                 else
609                   {
610                     cpt++;
611                   }
612             }
613           else
614             {
615               suffix[IPSEC_STRLEN_IPV6 -1 -cpt_suffix] = g_ascii_toupper(ipv6_address[ipv6_len - cpt - 1]);
616               cpt_seg ++;
617               cpt_suffix ++;
618               cpt++;
619             }
620         }
621
622       if(cpt_suffix % 4 != 0)
623         {
624           for(j = cpt_seg; j < 4; j++)
625             {
626               suffix[IPSEC_STRLEN_IPV6 -1 -cpt_suffix] = '0';
627               cpt_suffix ++;
628             }
629         }
630
631     }
632
633   for(j = 0 ; j < cpt_suffix ; j ++)
634     {
635       suffix[j] = suffix[j + IPSEC_STRLEN_IPV6 - cpt_suffix] ;
636     }
637
638   suffix[j] = '\0';
639   memcpy(ipv6_suffix,suffix,j + 1);
640   return cpt;
641 }
642
643 /*
644    Name : static int get_full_ipv6_addr(char* ipv6_addr_expanded, char *ipv6_addr)
645    Description : Get the extended IPv6 Address of an IPv6 Address
646    Return : Return the remaining number of char of the IPv6 address parsed
647    Params:
648       - char *ipv6_addr : the valid ipv6 address to parse in char *
649       - char *ipv6_addr_expanded : the expanded ipv6 address associated in char *
650
651       ex: if IPv6 address is "3ffe::1" the IPv6 expanded address
652             will be "3FFE0000000000000000000000000001" and the function will return 0
653           if IPV6 address is "3ffe::*" the IPv6 expanded address
654             will be "3FFE000000000000000000000000****" and the function will return 0
655 */
656 static int
657 get_full_ipv6_addr(char* ipv6_addr_expanded, char *ipv6_addr)
658 {
659   char suffix[IPSEC_STRLEN_IPV6 + 1];
660   char prefix[IPSEC_STRLEN_IPV6 + 1];
661   char *prefix_addr;
662
663   int suffix_cpt = 0;
664   int suffix_len = 0;
665   int prefix_remaining = 0;
666   int prefix_len = 0;
667   int j = 0;
668   guint i = 0;
669   guint addr_byte = 0;
670   guint mask = IPSEC_IPV6_ADDR_LEN;
671   char* mask_begin = NULL;
672
673
674   if((ipv6_addr == NULL) || (strcmp(ipv6_addr, "") == 0))  return -1;
675
676   memset(ipv6_addr_expanded, 0x0, IPSEC_STRLEN_IPV6);
677
678   mask_begin = strchr(ipv6_addr, '/');
679   if(mask_begin)
680   {
681     if(sscanf(mask_begin, "/%u", &mask) == EOF)
682       mask = IPSEC_IPV6_ADDR_LEN;
683     mask_begin[0] = '\0';
684   }
685
686   if((strlen(ipv6_addr) == 1) && (ipv6_addr[0] == IPSEC_SA_WILDCARDS_ANY))
687     {
688       for(j = 0; j < IPSEC_STRLEN_IPV6; j++)
689         {
690           ipv6_addr_expanded[j] = IPSEC_SA_WILDCARDS_ANY;
691         }
692       ipv6_addr_expanded[IPSEC_STRLEN_IPV6] = '\0';
693       return 0;
694     }
695
696   suffix_cpt = get_ipv6_suffix(suffix,ipv6_addr);
697   suffix_len = (int) strlen(suffix);
698
699   if(suffix_len <  IPSEC_STRLEN_IPV6)
700     {
701       prefix_addr = wmem_strndup(wmem_packet_scope(), ipv6_addr,strlen(ipv6_addr) - suffix_cpt);
702       prefix_remaining = get_ipv6_suffix(prefix,prefix_addr);
703       prefix_len = (int) strlen(prefix);
704       memcpy(ipv6_addr_expanded,prefix,prefix_len);
705     }
706
707
708   for(j = 0; j <= IPSEC_STRLEN_IPV6 - prefix_len - suffix_len; j++)
709     {
710       ipv6_addr_expanded[j + prefix_len] = '0';
711     }
712
713   memcpy(ipv6_addr_expanded + IPSEC_STRLEN_IPV6 - suffix_len, suffix,suffix_len + 1);
714
715   for(i = 0; i < IPSEC_STRLEN_IPV6; i++)
716   {
717     if(4 * (i + 1) > mask)
718     {
719       if(mask <= 4 * i || ipv6_addr_expanded[i] == '*')
720         ipv6_addr_expanded[i] = '*';
721       else {
722         if(sscanf(ipv6_addr_expanded + i, "%X", &addr_byte) == EOF)
723            break;
724         addr_byte &= (0x0F << (4 * (i + 1) - mask));
725         addr_byte &= 0x0F;
726         g_snprintf(ipv6_addr_expanded + i, 4, "%X", addr_byte);
727       }
728     }
729   }
730
731   if(suffix_len < IPSEC_STRLEN_IPV6)
732     return (prefix_len - prefix_remaining);
733   else
734     return (int) strlen(ipv6_addr) - suffix_cpt;
735 }
736
737
738 /*
739    Name : static gboolean get_full_ipv4_addr(char* ipv4_addr_expanded, char *ipv4_addr)
740    Description : Get the extended IPv4 Address of an IPv4 Address
741    Return : Return true if it can derive an IPv4 address. It does not mean that
742             the previous one was valid.
743    Params:
744       - char *ipv4_addr : the valid ipv4 address to parse in char *
745       - char *ipv4_addr_expanded : the expanded ipv4 address associated in char *
746
747       ex: if IPv4 address is "190.*.*.1" the IPv4 expanded address will be "BE****01" and
748             the function will return 0
749           if IPv4 address is "*" the IPv4 expanded address will be "********" and
750             the function will return 0
751 */
752 static gboolean
753 get_full_ipv4_addr(char* ipv4_address_expanded, char *ipv4_address)
754 {
755   char addr_byte_string_tmp[4];
756   char addr_byte_string[4];
757
758   guint addr_byte = 0;
759   guint i = 0;
760   guint j = 0;
761   guint k = 0;
762   guint cpt = 0;
763   gboolean done_flag = FALSE;
764   guint mask = IPSEC_IPV4_ADDR_LEN;
765   char* mask_begin = NULL;
766
767   if((ipv4_address == NULL) || (strcmp(ipv4_address, "") == 0))  return done_flag;
768
769   mask_begin = strchr(ipv4_address, '/');
770   if(mask_begin)
771   {
772     if(sscanf(mask_begin, "/%u", &mask) == EOF)
773       mask = IPSEC_IPV4_ADDR_LEN;
774     mask_begin[0] = '\0';
775   }
776
777   if((strlen(ipv4_address) == 1) && (ipv4_address[0] == IPSEC_SA_WILDCARDS_ANY))
778   {
779     for(i = 0; i <= IPSEC_STRLEN_IPV4; i++)
780     {
781       ipv4_address_expanded[i] = IPSEC_SA_WILDCARDS_ANY;
782     }
783     ipv4_address_expanded[IPSEC_STRLEN_IPV4] = '\0';
784     done_flag = TRUE;
785   }
786
787   else {
788     j = 0;
789     cpt = 0;
790     k = 0;
791     while((done_flag == FALSE) && (j <= strlen(ipv4_address)) && (cpt < IPSEC_STRLEN_IPV4))
792     {
793       if(j == strlen(ipv4_address))
794       {
795         addr_byte_string_tmp[k] = '\0';
796         if((strlen(addr_byte_string_tmp) == 1) && (addr_byte_string_tmp[0] == IPSEC_SA_WILDCARDS_ANY))
797         {
798           for(i = 0; i < 2; i++)
799           {
800             ipv4_address_expanded[cpt] = IPSEC_SA_WILDCARDS_ANY;
801             cpt ++;
802           }
803         }
804         else
805         {
806           if (sscanf(addr_byte_string_tmp,"%u",&addr_byte) == EOF)
807             return FALSE;
808
809           if(addr_byte < 16)
810             g_snprintf(addr_byte_string,4,"0%X",addr_byte);
811           else
812             g_snprintf(addr_byte_string,4,"%X",addr_byte);
813           for(i = 0; i < strlen(addr_byte_string); i++)
814           {
815             ipv4_address_expanded[cpt] = addr_byte_string[i];
816             cpt ++;
817           }
818         }
819         done_flag = TRUE;
820       }
821
822       else if(ipv4_address[j] == '.')
823       {
824         addr_byte_string_tmp[k] = '\0';
825         if((strlen(addr_byte_string_tmp) == 1) && (addr_byte_string_tmp[0] == IPSEC_SA_WILDCARDS_ANY))
826         {
827           for(i = 0; i < 2; i++)
828           {
829             ipv4_address_expanded[cpt] = IPSEC_SA_WILDCARDS_ANY;
830             cpt ++;
831           }
832         }
833         else
834         {
835           if (sscanf(addr_byte_string_tmp,"%u",&addr_byte) == EOF)
836             return FALSE;
837
838           if(addr_byte < 16)
839             g_snprintf(addr_byte_string,4,"0%X",addr_byte);
840           else
841             g_snprintf(addr_byte_string,4,"%X",addr_byte);
842           for(i = 0; i < strlen(addr_byte_string); i++)
843           {
844             ipv4_address_expanded[cpt] = addr_byte_string[i];
845             cpt ++;
846           }
847         }
848         k = 0;
849         j++;
850       }
851       else
852       {
853         if(k >= 3)
854         {
855           /* Incorrect IPv4 Address. Erase previous Values in the Byte. (LRU mechanism) */
856           addr_byte_string_tmp[0] = ipv4_address[j];
857           k = 1;
858           j++;
859         }
860         else
861         {
862           addr_byte_string_tmp[k] = ipv4_address[j];
863           k++;
864           j++;
865         }
866       }
867
868     }
869
870     for(i = 0; i < IPSEC_STRLEN_IPV4; i++)
871     {
872       if(4 * (i + 1) > mask)
873       {
874         if(mask <= 4 * i || ipv4_address_expanded[i] == '*')
875           ipv4_address_expanded[i] = '*';
876         else {
877           if(sscanf(ipv4_address_expanded + i, "%X", &addr_byte) == EOF)
878              return FALSE;
879           addr_byte &= (0x0F << (4 * (i + 1) - mask));
880           addr_byte &= 0x0F;
881           g_snprintf(ipv4_address_expanded + i, 4, "%X", addr_byte);
882         }
883       }
884     }
885     ipv4_address_expanded[cpt] = '\0';
886   }
887
888   return done_flag;
889 }
890
891 /*
892    Name : static goolean filter_address_match(gchar *addr, gchar *filter, gint len, gint typ)
893    Description : check the matching of an address with a filter
894    Return : Return TRUE if the filter and the address match
895    Params:
896       - gchar *addr : the address to check
897       - gchar *filter : the filter
898       - gint typ : the Address type : either IPv6 or IPv4 (IPSEC_SA_IPV6, IPSEC_SA_IPV4)
899 */
900 static gboolean
901 filter_address_match(gchar *addr, gchar *filter, gint typ)
902 {
903   guint i;
904   char addr_hex[IPSEC_STRLEN_IPV6 + 1];
905   char filter_hex[IPSEC_STRLEN_IPV6 + 1];
906   guint addr_len;
907   guint filter_len;
908
909   if (typ == IPSEC_SA_IPV4) {
910       if (!get_full_ipv4_addr(addr_hex, addr))
911           return FALSE;
912       if (!get_full_ipv4_addr(filter_hex, filter))
913           return FALSE;
914   } else {
915       if (get_full_ipv6_addr(addr_hex, addr))
916           return FALSE;
917       if (get_full_ipv6_addr(filter_hex, filter))
918           return FALSE;
919   }
920
921   addr_len = (guint)strlen(addr_hex);
922   filter_len = (guint)strlen(filter_hex);
923
924   if((filter_len == 1) && (filter[0] == IPSEC_SA_WILDCARDS_ANY)){
925       return TRUE;
926   }
927
928   if(addr_len != filter_len)
929       return FALSE;
930
931   /* No length specified */
932    if( ((typ == IPSEC_SA_IPV6) && (filter_len == IPSEC_STRLEN_IPV6)) ||
933        ((typ == IPSEC_SA_IPV4) && (filter_len == IPSEC_STRLEN_IPV4)))
934    {
935       /* Check byte by byte ... */
936       for(i = 0; i < addr_len; i++)
937       {
938          if((filter_hex[i] != IPSEC_SA_WILDCARDS_ANY) && (filter_hex[i] != addr_hex[i]))
939             return FALSE;
940       }
941       return TRUE;
942    }
943    else
944       return FALSE;
945   return TRUE;
946
947 }
948
949
950 /*
951    Name : static goolean filter_spi_match(gchar *spi, gchar *filter)
952    Description : check the matching of a spi with a filter
953    Return : Return TRUE if the filter matches the spi.
954    Params:
955       - guint spi : the spi to check
956       - gchar *filter : the filter
957 */
958 static gboolean
959 filter_spi_match(guint spi, gchar *filter)
960 {
961   guint i;
962   guint filter_len = (guint)strlen(filter);
963
964   /* "*" matches against anything */
965   if((filter_len == 1) && (filter[0] == IPSEC_SA_WILDCARDS_ANY))
966     return TRUE;
967
968   /* If the filter has a wildcard, treat SPI as a string */
969   if (strchr(filter, IPSEC_SA_WILDCARDS_ANY) != NULL) {
970     gchar spi_string[IPSEC_SPI_LEN_MAX];
971
972     g_snprintf(spi_string, IPSEC_SPI_LEN_MAX,"0x%08x", spi);
973
974     /* Lengths need to match exactly... */
975     if(strlen(spi_string) != filter_len)
976       return FALSE;
977
978     /* ... which means '*' can only appear in the last position of the filter? */
979     /* Start at 2, don't compare "0x" each time */
980     for(i = 2; filter[i]; i++)
981       if((filter[i] != IPSEC_SA_WILDCARDS_ANY) && (filter[i] != spi_string[i]))
982         return FALSE;
983   } else if (strtoul(filter, NULL, 0) != spi) {
984     return FALSE;
985   }
986   return TRUE;
987 }
988
989
990 /*
991    Name : static goolean get_esp_sa(g_esp_sa_database *sad, gint protocol_typ, gchar *src,  gchar *dst,  guint spi,
992            gint *encryption_algo,
993            gint *authentication_algo,
994            gchar **encryption_key,
995            guint *encryption_key_len,
996            gchar **authentication_key,
997            guint *authentication_key_len,
998            gcry_cipher_hd_t **cipher_hd,
999            gboolean **cipher_hd_created
1000
1001    Description : Give Encryption Algo, Key and Authentication Algo for a Packet if a corresponding SA is available in a Security Association database
1002    Return: If the SA is not present, FALSE is then returned.
1003    Params:
1004       - g_esp_sa_database *sad : the Security Association Database
1005       - gint *pt_protocol_typ : the protocol type
1006       - gchar *src : the source address
1007       - gchar *dst : the destination address
1008       - gchar *spi : the spi of the SA
1009       - gint *encryption_algo : the Encryption Algorithm to apply the packet
1010       - gint *authentication_algo : the Authentication Algorithm to apply to the packet
1011       - gchar **encryption_key : the Encryption Key to apply to the packet
1012       - guint *encryption_key_len : the Encryption Key length to apply to the packet
1013       - gchar **authentication_key : the Authentication Key to apply to the packet
1014       - guint *authentication_key_len : the Authentication Key len to apply to the packet
1015       - gcry_cipher_hd_t **cipher_hd : pointer handle to be used for ciphering
1016       - gboolean **cipher_hd_created: points to boolean indicating that cipher handle has
1017                                       been created.  If FALSE, should assign handle to
1018                                       *cipher_hd and set this to TRUE.
1019
1020 */
1021 static gboolean
1022 get_esp_sa(gint protocol_typ, gchar *src,  gchar *dst,  guint spi,
1023            gint *encryption_algo,
1024            gint *authentication_algo,
1025            gchar **encryption_key,
1026            guint *encryption_key_len,
1027            gchar **authentication_key,
1028            guint *authentication_key_len,
1029            gcry_cipher_hd_t **cipher_hd,
1030            gboolean **cipher_hd_created
1031   )
1032 {
1033   gboolean found = FALSE;
1034   guint i, j;
1035
1036   *cipher_hd = NULL;
1037   *cipher_hd_created = NULL;
1038
1039   /* Check each known SA in turn */
1040   for (i = 0, j=0; (found == FALSE) && ((i < num_sa_uat) || (j < extra_esp_sa_records.num_records)); )
1041   {
1042     /* Get the next record to try */
1043     uat_esp_sa_record_t *record;
1044     if (j < extra_esp_sa_records.num_records) {
1045       /* Extra ones checked first */
1046       record = &extra_esp_sa_records.records[j++];
1047     }
1048     else {
1049       /* Then UAT ones */
1050       record = &uat_esp_sa_records[i++];
1051     }
1052
1053     if((protocol_typ == record->protocol)
1054        && filter_address_match(src, record->srcIP, protocol_typ)
1055        && filter_address_match(dst, record->dstIP, protocol_typ)
1056        && filter_spi_match(spi, record->spi))
1057     {
1058       found = TRUE;
1059
1060       *encryption_algo = record->encryption_algo;
1061       *authentication_algo = record->authentication_algo;
1062       *authentication_key = record->authentication_key;
1063       if (record->authentication_key_length == -1)
1064       {
1065         /* Bad key; XXX - report this */
1066         *authentication_key_len = 0;
1067         found = FALSE;
1068       }
1069       else {
1070         *authentication_key_len = record->authentication_key_length;
1071       }
1072
1073       *encryption_key = record->encryption_key;
1074       if (record->encryption_key_length == -1)
1075       {
1076         /* Bad key; XXX - report this */
1077         *encryption_key_len = 0;
1078         found = FALSE;
1079       }
1080       else {
1081         *encryption_key_len = record->encryption_key_length;
1082       }
1083
1084       /* Tell the caller whether cipher_hd has been created yet and a pointer.
1085          Pass pointer to created flag so that caller can set if/when
1086          it opens the cipher_hd. */
1087       *cipher_hd = &record->cipher_hd;
1088       *cipher_hd_created = &record->cipher_hd_created;
1089     }
1090   }
1091
1092   return found;
1093 }
1094
1095 static void ah_prompt(packet_info *pinfo, gchar *result)
1096 {
1097     g_snprintf(result, MAX_DECODE_AS_PROMPT_LEN, "IP protocol %u as",
1098         GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, proto_ah, pinfo->curr_layer_num)));
1099 }
1100
1101 static gpointer ah_value(packet_info *pinfo)
1102 {
1103     return p_get_proto_data(pinfo->pool, pinfo, proto_ah, pinfo->curr_layer_num);
1104 }
1105
1106 static void
1107 export_ipsec_pdu(dissector_handle_t dissector_handle, packet_info *pinfo, tvbuff_t *tvb)
1108 {
1109   if (have_tap_listener(exported_pdu_tap)) {
1110     exp_pdu_data_t *exp_pdu_data = export_pdu_create_common_tags(pinfo, dissector_handle_get_dissector_name(dissector_handle), EXP_PDU_TAG_PROTO_NAME);
1111
1112     exp_pdu_data->tvb_captured_length = tvb_captured_length(tvb);
1113     exp_pdu_data->tvb_reported_length = tvb_reported_length(tvb);
1114     exp_pdu_data->pdu_tvb = tvb;
1115
1116     tap_queue_packet(exported_pdu_tap, pinfo, exp_pdu_data);
1117   }
1118 }
1119
1120 static gboolean
1121 capture_ah(const guchar *pd, int offset, int len, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header)
1122 {
1123   guint8 nxt;
1124   int    advance;
1125
1126   if (!BYTES_ARE_IN_FRAME(offset, len, 2))
1127     return FALSE;
1128   nxt = pd[offset];
1129   advance = 8 + ((pd[offset+1] - 1) << 2);
1130   if (!BYTES_ARE_IN_FRAME(offset, len, advance))
1131     return FALSE;
1132   offset += advance;
1133
1134   return try_capture_dissector("ip.proto", nxt, pd, offset, len, cpinfo, pseudo_header);
1135 }
1136
1137 static int
1138 dissect_ah(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data)
1139 {
1140   proto_tree *ah_tree, *root_tree;
1141   proto_item *pi, *ti;
1142   guint       ah_nxt;         /* Next header */
1143   guint8      ah_len;         /* Length of header in 32bit words minus 2 */
1144   guint       ah_hdr_len;     /* Length of header in octets */
1145   guint       ah_icv_len;     /* Length of ICV header field in octets */
1146   guint32     ah_spi;         /* Security parameter index */
1147   tvbuff_t   *next_tvb;
1148   dissector_handle_t dissector_handle;
1149   guint32 saved_match_uint;
1150
1151   col_set_str(pinfo->cinfo, COL_PROTOCOL, "AH");
1152   col_clear(pinfo->cinfo, COL_INFO);
1153
1154   ah_nxt = tvb_get_guint8(tvb, 0);
1155   ah_len = tvb_get_guint8(tvb, 1);
1156   ah_hdr_len = (ah_len + 2) * 4;
1157   ah_icv_len = ah_len ? (ah_len - 1) * 4 : 0;
1158
1159   root_tree = p_ipv6_pinfo_select_root(pinfo, tree);
1160   p_ipv6_pinfo_add_len(pinfo, ah_hdr_len);
1161
1162   pi = proto_tree_add_item(root_tree, proto_ah, tvb, 0, -1, ENC_NA);
1163   ah_tree = proto_item_add_subtree(pi, ett_ah);
1164
1165   proto_tree_add_item(ah_tree, hf_ah_next_header, tvb, 0, 1, ENC_BIG_ENDIAN);
1166   ti = proto_tree_add_item(ah_tree, hf_ah_length, tvb, 1, 1, ENC_BIG_ENDIAN);
1167   proto_item_append_text(ti, " (%u bytes)", ah_hdr_len);
1168   proto_tree_add_item(ah_tree, hf_ah_reserved, tvb, 2, 2, ENC_NA);
1169   proto_tree_add_item_ret_uint(ah_tree, hf_ah_spi, tvb, 4, 4, ENC_BIG_ENDIAN, &ah_spi);
1170
1171   col_add_fstr(pinfo->cinfo, COL_INFO, "AH (SPI=0x%08x)", ah_spi);
1172
1173   proto_tree_add_item(ah_tree, hf_ah_sequence, tvb, 8, 4, ENC_BIG_ENDIAN);
1174   proto_tree_add_item(ah_tree, hf_ah_iv, tvb, 12, ah_icv_len, ENC_NA);
1175
1176   proto_item_set_len(pi, ah_hdr_len);
1177
1178   /* Save next header value for Decode As dialog */
1179   p_add_proto_data(pinfo->pool, pinfo, proto_ah,
1180                     pinfo->curr_layer_num, GUINT_TO_POINTER(ah_nxt));
1181
1182   next_tvb = tvb_new_subset_remaining(tvb, ah_hdr_len);
1183
1184   if (pinfo->dst.type == AT_IPv6) {
1185     ipv6_dissect_next(ah_nxt, next_tvb, pinfo, tree, (ws_ip6 *)data);
1186   } else {
1187     /* do lookup with the subdissector table */
1188     saved_match_uint  = pinfo->match_uint;
1189     dissector_handle = dissector_get_uint_handle(ip_dissector_table, ah_nxt);
1190     if (dissector_handle) {
1191       pinfo->match_uint = ah_nxt;
1192     } else {
1193       dissector_handle = data_handle;
1194     }
1195     export_ipsec_pdu(dissector_handle, pinfo, next_tvb);
1196     call_dissector(dissector_handle, next_tvb, pinfo, tree);
1197     pinfo->match_uint = saved_match_uint;
1198   }
1199   return tvb_captured_length(tvb);
1200 }
1201
1202 /*
1203 Name : dissect_esp_authentication(proto_tree *tree, tvbuff_t *tvb, gint len, gint esp_auth_len, guint8 *authenticator_data_computed,
1204 gboolean authentication_ok, gboolean authentication_checking_ok)
1205 Description : used to print Authenticator field when linked with libgcrypt. Print the expected authenticator value
1206 if requested and if it is wrong.
1207 Return : void
1208 Params:
1209 - proto_tree *tree : the current tree
1210 - tvbuff_t *tvb : the tvbuffer
1211 - gint len : length of the data available in tvbuff
1212 - gint esp_auth_len : size of authenticator field
1213 - guint8 *authenticator_data_computed : give the authenticator computed (only needed when authentication_ok and !authentication_checking_ok
1214 - gboolean authentication_ok : set to true if the authentication checking has been run successfully
1215 - gboolean authentication_checking_ok : set to true if the authentication was the one expected
1216 */
1217 static void
1218 dissect_esp_authentication(proto_tree *tree, tvbuff_t *tvb, gint len, gint esp_auth_len, guint8 *authenticator_data_computed,
1219                            gboolean authentication_ok, gboolean authentication_checking_ok)
1220 {
1221   proto_item *item;
1222   proto_tree *icv_tree;
1223   gboolean good = FALSE, bad = FALSE;
1224
1225   if(esp_auth_len == 0)
1226   {
1227     icv_tree = proto_tree_add_subtree(tree, tvb, len, 0,
1228                                ett_esp_icv, NULL, "NULL Authentication");
1229     good = TRUE;
1230   }
1231
1232   /* Make sure we have the auth trailer data */
1233   else if(tvb_bytes_exist(tvb, len - esp_auth_len, esp_auth_len))
1234   {
1235     if((authentication_ok) && (authentication_checking_ok))
1236     {
1237       icv_tree = proto_tree_add_subtree(tree, tvb, len - esp_auth_len, esp_auth_len,
1238                                  ett_esp_icv, NULL, "Authentication Data [correct]");
1239       good = TRUE;
1240     }
1241
1242     else if((authentication_ok) && (!authentication_checking_ok))
1243     {
1244       icv_tree = proto_tree_add_subtree_format(tree, tvb, len - esp_auth_len, esp_auth_len,
1245                                  ett_esp_icv, NULL, "Authentication Data [incorrect, should be 0x%s]", authenticator_data_computed);
1246       bad = TRUE;
1247     }
1248
1249     else
1250         icv_tree = proto_tree_add_subtree(tree, tvb, len - esp_auth_len, esp_auth_len,
1251                                     ett_esp_icv, NULL, "Authentication Data");
1252   }
1253   else
1254   {
1255     /* Truncated so just display what we have */
1256     icv_tree = proto_tree_add_subtree(tree, tvb, len - esp_auth_len, esp_auth_len - (len - tvb_captured_length(tvb)),
1257                                ett_esp_icv, NULL, "Authentication Data (truncated)");
1258     bad = TRUE;
1259   }
1260
1261   item = proto_tree_add_boolean(icv_tree, hf_esp_icv_good,
1262                                 tvb, len - esp_auth_len, esp_auth_len, good);
1263   PROTO_ITEM_SET_GENERATED(item);
1264
1265   item = proto_tree_add_boolean(icv_tree, hf_esp_icv_bad,
1266                                 tvb, len - esp_auth_len, esp_auth_len, bad);
1267   PROTO_ITEM_SET_GENERATED(item);
1268 }
1269
1270 static int
1271 dissect_esp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _U_)
1272 {
1273   proto_tree *esp_tree = NULL;
1274   proto_item *ti;
1275   gint len = 0;
1276
1277   gint i;
1278
1279   /* Packet Variables related */
1280   gchar *ip_src = NULL;
1281   gchar *ip_dst = NULL;
1282
1283   guint32 spi = 0;
1284   guint encapsulated_protocol = 0;
1285   gboolean decrypt_dissect_ok = FALSE;
1286   tvbuff_t *next_tvb;
1287   dissector_handle_t dissector_handle;
1288   guint32 saved_match_uint;
1289
1290   gboolean null_encryption_decode_heuristic = FALSE;
1291   guint8 *decrypted_data = NULL;
1292   guint8 *authenticator_data = NULL;
1293   guint8 *esp_data = NULL;
1294   tvbuff_t *tvb_decrypted;
1295
1296   /* IPSEC encryption Variables related */
1297   gint protocol_typ = IPSEC_SA_UNKNOWN;
1298   gint esp_crypt_algo = IPSEC_ENCRYPT_NULL;
1299   gint esp_auth_algo = IPSEC_AUTH_NULL;
1300   gchar *esp_crypt_key = NULL;
1301   gchar *esp_auth_key = NULL;
1302   guint esp_crypt_key_len = 0;
1303   guint esp_auth_key_len = 0;
1304   gcry_cipher_hd_t *cipher_hd;
1305   gboolean         *cipher_hd_created;
1306
1307   gint esp_iv_len = 0;
1308   gint esp_auth_len = 0;
1309   gint decrypted_len = 0;
1310   gboolean decrypt_ok = FALSE;
1311   gboolean decrypt_using_libgcrypt = FALSE;
1312   gboolean authentication_check_using_hmac_libgcrypt = FALSE;
1313   gboolean authentication_ok = FALSE;
1314   gboolean authentication_checking_ok = FALSE;
1315   gboolean sad_is_present = FALSE;
1316   gint esp_pad_len = 0;
1317
1318
1319   /* Variables for decryption and authentication checking used for libgrypt */
1320   int decrypted_len_alloc = 0;
1321   gcry_md_hd_t md_hd;
1322   int md_len = 0;
1323   gcry_error_t err = 0;
1324   int crypt_algo_libgcrypt = 0;
1325   int crypt_mode_libgcrypt = 0;
1326   int auth_algo_libgcrypt = 0;
1327   unsigned char *authenticator_data_computed = NULL;
1328   unsigned char *authenticator_data_computed_md;
1329
1330   unsigned char ctr_block[16];
1331
1332
1333   guint32 sequence_number;
1334
1335   /*
1336    * load the top pane info. This should be overwritten by
1337    * the next protocol in the stack
1338    */
1339
1340   col_set_str(pinfo->cinfo, COL_PROTOCOL, "ESP");
1341   col_clear(pinfo->cinfo, COL_INFO);
1342
1343   /*
1344    * populate a tree in the second pane with the status of the link layer
1345    * (ie none)
1346    */
1347   len = 0;
1348   encapsulated_protocol = 0;
1349   decrypt_dissect_ok = FALSE;
1350
1351   ti = proto_tree_add_item(tree, proto_esp, tvb, 0, -1, ENC_NA);
1352   esp_tree = proto_item_add_subtree(ti, ett_esp);
1353   proto_tree_add_item_ret_uint(esp_tree, hf_esp_spi, tvb,
1354                       0, 4, ENC_BIG_ENDIAN, &spi);
1355   proto_tree_add_item_ret_uint(esp_tree, hf_esp_sequence, tvb,
1356                       4, 4, ENC_BIG_ENDIAN, &sequence_number);
1357
1358   col_add_fstr(pinfo->cinfo, COL_INFO, "ESP (SPI=0x%08x)", spi);
1359
1360   /* Sequence number analysis */
1361   if (g_esp_do_sequence_analysis) {
1362     if (!pinfo->fd->flags.visited) {
1363       check_esp_sequence_info(spi, sequence_number, pinfo);
1364     }
1365     show_esp_sequence_info(spi, sequence_number,
1366                            tvb, esp_tree, pinfo);
1367   }
1368
1369   /* The SAD is not activated */
1370   if(g_esp_enable_null_encryption_decode_heuristic &&
1371      !g_esp_enable_encryption_decode)
1372     null_encryption_decode_heuristic = TRUE;
1373
1374   if(g_esp_enable_encryption_decode || g_esp_enable_authentication_check)
1375   {
1376     /* Get Source & Destination Addresses in gchar * with all the bytes available.  */
1377
1378     if (pinfo->src.type == AT_IPv4){
1379       protocol_typ = IPSEC_SA_IPV4;
1380     }else if (pinfo->src.type == AT_IPv6){
1381       protocol_typ = IPSEC_SA_IPV6;
1382     }
1383
1384     /* Create strings for src, dst addresses */
1385     ip_src = address_to_str(wmem_packet_scope(), &pinfo->src);
1386     ip_dst = address_to_str(wmem_packet_scope(), &pinfo->dst);
1387
1388     /* Get the SPI */
1389     if (tvb_captured_length(tvb) >= 4)
1390     {
1391       spi = tvb_get_ntohl(tvb, 0);
1392     }
1393
1394
1395     /*
1396       PARSE the SAD and fill it. It may take some time since it will
1397       be called every times an ESP Payload is found.
1398     */
1399
1400     if((sad_is_present = get_esp_sa(protocol_typ, ip_src, ip_dst, spi,
1401                                     &esp_crypt_algo, &esp_auth_algo,
1402                                     &esp_crypt_key, &esp_crypt_key_len, &esp_auth_key, &esp_auth_key_len,
1403                                     &cipher_hd, &cipher_hd_created)))
1404     {
1405       /* Get length of whole ESP packet. */
1406       len = tvb_reported_length(tvb);
1407
1408       switch(esp_auth_algo)
1409       {
1410       case IPSEC_AUTH_NULL:
1411         esp_auth_len = 0;
1412         break;
1413
1414       case IPSEC_AUTH_ANY_64BIT:
1415         esp_auth_len = 8;
1416         break;
1417
1418       case IPSEC_AUTH_HMAC_SHA256_128:
1419       case IPSEC_AUTH_ANY_128BIT:
1420         esp_auth_len = 16;
1421         break;
1422
1423       case IPSEC_AUTH_HMAC_SHA512_256:
1424       case IPSEC_AUTH_ANY_256BIT:
1425         esp_auth_len = 32;
1426         break;
1427
1428       case IPSEC_AUTH_HMAC_SHA384_192:
1429       case IPSEC_AUTH_ANY_192BIT:
1430         esp_auth_len = 24;
1431         break;
1432
1433       case IPSEC_AUTH_HMAC_SHA1_96:
1434       case IPSEC_AUTH_HMAC_SHA256_96:
1435         /*             case IPSEC_AUTH_AES_XCBC_MAC_96: */
1436       case IPSEC_AUTH_HMAC_MD5_96:
1437       case IPSEC_AUTH_HMAC_RIPEMD160_96:
1438       case IPSEC_AUTH_ANY_96BIT:
1439       default:
1440         esp_auth_len = 12;
1441         break;
1442       }
1443
1444       if(g_esp_enable_authentication_check)
1445       {
1446         switch(esp_auth_algo)
1447         {
1448         case IPSEC_AUTH_HMAC_SHA1_96:
1449           /*
1450             RFC 2404 : HMAC-SHA-1-96 is a secret key algorithm.
1451             While no fixed key length is specified in [RFC-2104],
1452             for use with either ESP or AH a fixed key length of
1453             160-bits MUST be supported.  Key lengths other than
1454             160-bits MUST NOT be supported (i.e. only 160-bit keys
1455             are to be used by HMAC-SHA-1-96).  A key length of
1456             160-bits was chosen based on the recommendations in
1457             [RFC-2104] (i.e. key lengths less than the
1458             authenticator length decrease security strength and
1459             keys longer than the authenticator length do not
1460             significantly increase security strength).
1461           */
1462           auth_algo_libgcrypt = GCRY_MD_SHA1;
1463           authentication_check_using_hmac_libgcrypt = TRUE;
1464           break;
1465
1466         case IPSEC_AUTH_NULL:
1467           authentication_check_using_hmac_libgcrypt = FALSE;
1468           authentication_checking_ok = TRUE;
1469           authentication_ok = TRUE;
1470           break;
1471
1472           /*
1473             case IPSEC_AUTH_AES_XCBC_MAC_96:
1474             auth_algo_libgcrypt =
1475             authentication_check_using_libgcrypt = TRUE;
1476             break;
1477           */
1478
1479         case IPSEC_AUTH_HMAC_SHA256_96:
1480         case IPSEC_AUTH_HMAC_SHA256_128:
1481           auth_algo_libgcrypt = GCRY_MD_SHA256;
1482           authentication_check_using_hmac_libgcrypt = TRUE;
1483           break;
1484
1485         case IPSEC_AUTH_HMAC_SHA384_192:
1486           auth_algo_libgcrypt = GCRY_MD_SHA384;
1487           authentication_check_using_hmac_libgcrypt = TRUE;
1488           break;
1489
1490         case IPSEC_AUTH_HMAC_SHA512_256:
1491           auth_algo_libgcrypt = GCRY_MD_SHA512;
1492           authentication_check_using_hmac_libgcrypt = TRUE;
1493           break;
1494
1495         case IPSEC_AUTH_HMAC_MD5_96:
1496           /*
1497             RFC 2403 : HMAC-MD5-96 is a secret key algorithm.
1498             While no fixed key length is specified in [RFC-2104],
1499             for use with either ESP or AH a fixed key length of
1500             128-bits MUST be supported.  Key lengths other than
1501             128-bits MUST NOT be supported (i.e. only 128-bit keys
1502             are to be used by HMAC-MD5-96).  A key length of
1503             128-bits was chosen based on the recommendations in
1504             [RFC-2104] (i.e. key lengths less than the
1505             authenticator length decrease security strength and
1506             keys longer than the authenticator length do not
1507             significantly increase security strength).
1508           */
1509           auth_algo_libgcrypt = GCRY_MD_MD5;
1510           authentication_check_using_hmac_libgcrypt = TRUE;
1511           break;
1512
1513         case IPSEC_AUTH_HMAC_RIPEMD160_96:
1514           /*
1515             RFC 2857 : HMAC-RIPEMD-160-96 produces a 160-bit
1516             authenticator value.  This 160-bit value can be
1517             truncated as described in RFC2104.  For use with
1518             either ESP or AH, a truncated value using the first
1519             96 bits MUST be supported.
1520           */
1521           auth_algo_libgcrypt = GCRY_MD_RMD160;
1522           authentication_check_using_hmac_libgcrypt = TRUE;
1523           break;
1524
1525         case IPSEC_AUTH_ANY_64BIT:
1526         case IPSEC_AUTH_ANY_96BIT:
1527         case IPSEC_AUTH_ANY_128BIT:
1528         case IPSEC_AUTH_ANY_192BIT:
1529         case IPSEC_AUTH_ANY_256BIT:
1530         default:
1531           authentication_ok = FALSE;
1532           authentication_check_using_hmac_libgcrypt = FALSE;
1533           break;
1534
1535         }
1536
1537         if((authentication_check_using_hmac_libgcrypt) && (!authentication_ok))
1538         {
1539           gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
1540           gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
1541
1542           /* Allocate Buffers for Authenticator Field  */
1543           authenticator_data = (guint8 *)wmem_alloc0(wmem_packet_scope(), esp_auth_len + 1);
1544           tvb_memcpy(tvb, authenticator_data, len - esp_auth_len, esp_auth_len);
1545
1546           esp_data = (guint8 *)wmem_alloc0(wmem_packet_scope(), len - esp_auth_len + 1);
1547           tvb_memcpy(tvb, esp_data, 0, len - esp_auth_len);
1548
1549           err = gcry_md_open (&md_hd, auth_algo_libgcrypt, GCRY_MD_FLAG_HMAC);
1550           if (err)
1551           {
1552             fprintf (stderr, "<IPsec/ESP Dissector> Error in Algorithm %s, gcry_md_open failed: %s\n",
1553                      gcry_md_algo_name(auth_algo_libgcrypt), gcry_strerror(err));
1554             authentication_ok = FALSE;
1555           }
1556           else
1557           {
1558             md_len = gcry_md_get_algo_dlen (auth_algo_libgcrypt);
1559             if (md_len < 1 || md_len < esp_auth_len)
1560             {
1561               fprintf (stderr, "<IPsec/ESP Dissector> Error in Algorithm %s, grcy_md_get_algo_dlen failed: %d\n",
1562                        gcry_md_algo_name(auth_algo_libgcrypt), md_len);
1563               authentication_ok = FALSE;
1564             }
1565             else
1566             {
1567               gcry_md_setkey( md_hd, esp_auth_key, esp_auth_key_len );
1568
1569               gcry_md_write (md_hd, esp_data, len - esp_auth_len);
1570
1571               authenticator_data_computed_md = gcry_md_read (md_hd, auth_algo_libgcrypt);
1572               if (authenticator_data_computed_md == 0)
1573               {
1574                 fprintf (stderr, "<IPsec/ESP Dissector> Error in Algorithm %s, gcry_md_read failed\n",
1575                          gcry_md_algo_name(auth_algo_libgcrypt));
1576                 authentication_ok = FALSE;
1577               }
1578               else
1579               {
1580                 if(memcmp (authenticator_data_computed_md, authenticator_data, esp_auth_len))
1581                 {
1582                   /* XXX - just use bytes_to_str() or is string too big? */
1583                   unsigned char authenticator_data_computed_car[3];
1584                   authenticator_data_computed = (guint8 *)wmem_alloc(wmem_packet_scope(), esp_auth_len * 2 + 1);
1585                   for (i = 0; i < esp_auth_len; i++)
1586                   {
1587                     g_snprintf((char *)authenticator_data_computed_car, 3,
1588                                "%02X", authenticator_data_computed_md[i] & 0xFF);
1589                     authenticator_data_computed[i*2] = authenticator_data_computed_car[0];
1590                     authenticator_data_computed[i*2 + 1] = authenticator_data_computed_car[1];
1591                   }
1592
1593                   authenticator_data_computed[esp_auth_len * 2] ='\0';
1594
1595                   authentication_ok = TRUE;
1596                   authentication_checking_ok = FALSE;
1597                 }
1598                 else
1599                 {
1600                   authentication_ok = TRUE;
1601                   authentication_checking_ok = TRUE;
1602                 }
1603               }
1604             }
1605
1606             gcry_md_close (md_hd);
1607           }
1608         }
1609       }
1610
1611       if(g_esp_enable_encryption_decode)
1612       {
1613         /* Deactivation of the Heuristic to decrypt using the NULL encryption algorithm since the packet is matching a SA */
1614         null_encryption_decode_heuristic = FALSE;
1615
1616         switch(esp_crypt_algo)
1617         {
1618         case IPSEC_ENCRYPT_3DES_CBC :
1619           /* RFC 2451 says :
1620              3DES CBC uses a key of 192 bits.
1621              The first 3DES key is taken from the first 64 bits,
1622              the second from the next 64 bits, and the third
1623              from the last 64 bits.
1624              Implementations MUST take into consideration the
1625              parity bits when initially accepting a new set of
1626              keys.  Each of the three keys is really 56 bits in
1627              length with the extra 8 bits used for parity. */
1628
1629           /* Fix parameters for 3DES-CBC */
1630           esp_iv_len = 8;
1631           crypt_algo_libgcrypt = GCRY_CIPHER_3DES;
1632           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1633
1634           decrypted_len = len - 8;
1635
1636           if (decrypted_len <= 0)
1637             decrypt_ok = FALSE;
1638           else
1639           {
1640             if(decrypted_len % esp_iv_len  == 0)
1641               decrypted_len_alloc = decrypted_len;
1642             else
1643               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1644
1645             if (esp_crypt_key_len != gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt))
1646             {
1647               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm 3DES-CBC : Bad Keylen (got %u Bits, need %lu)\n",
1648                        esp_crypt_key_len * 8,
1649                        (unsigned long) gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt) * 8);
1650               decrypt_ok = FALSE;
1651             }
1652             else
1653               decrypt_using_libgcrypt = TRUE;
1654           }
1655           break;
1656
1657         case IPSEC_ENCRYPT_AES_CBC :
1658           /* RFC 3602 says :
1659              AES supports three key sizes: 128 bits, 192 bits,
1660              and 256 bits.  The default key size is 128 bits,
1661              and all implementations MUST support this key size.
1662              Implementations MAY also support key sizes of 192
1663              bits and 256 bits. */
1664
1665           /* Fix parameters for AES-CBC */
1666           esp_iv_len = 16;
1667           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1668
1669           decrypted_len = len - 8;
1670
1671           if (decrypted_len <= 0)
1672             decrypt_ok = FALSE;
1673           else
1674           {
1675             if(decrypted_len % esp_iv_len  == 0)
1676               decrypted_len_alloc = decrypted_len;
1677             else
1678               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1679
1680             switch(esp_crypt_key_len * 8)
1681             {
1682             case 128:
1683               crypt_algo_libgcrypt = GCRY_CIPHER_AES128;
1684               decrypt_using_libgcrypt = TRUE;
1685               break;
1686
1687             case 192:
1688               crypt_algo_libgcrypt = GCRY_CIPHER_AES192;
1689               decrypt_using_libgcrypt = TRUE;
1690               break;
1691
1692             case 256:
1693               crypt_algo_libgcrypt = GCRY_CIPHER_AES256;
1694               decrypt_using_libgcrypt = TRUE;
1695               break;
1696
1697             default:
1698               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm AES-CBC : Bad Keylen (%u Bits)\n",
1699                        esp_crypt_key_len * 8);
1700               decrypt_ok = FALSE;
1701             }
1702           }
1703           break;
1704
1705         case IPSEC_ENCRYPT_CAST5_CBC :
1706           /* RFC 2144 says :
1707              The CAST-128 encryption algorithm has been designed to allow a key
1708              size that can vary from 40 bits to 128 bits, in 8-bit increments
1709              (that is, the allowable key sizes are 40, 48, 56, 64, ..., 112, 120,
1710              and 128 bits.
1711              We support only 128 bits. */
1712
1713           /* Fix parameters for CAST5-CBC */
1714           esp_iv_len = 8;
1715           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1716
1717           decrypted_len = len - 8;
1718
1719           if (decrypted_len <= 0)
1720             decrypt_ok = FALSE;
1721           else
1722           {
1723             if(decrypted_len % esp_iv_len  == 0)
1724               decrypted_len_alloc = decrypted_len;
1725             else
1726               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1727
1728             switch(esp_crypt_key_len * 8)
1729             {
1730             case 128:
1731               crypt_algo_libgcrypt = GCRY_CIPHER_CAST5;
1732               decrypt_using_libgcrypt = TRUE;
1733               break;
1734             default:
1735               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm CAST5-CBC : Bad Keylen (%u Bits)\n",
1736                        esp_crypt_key_len * 8);
1737               decrypt_ok = FALSE;
1738             }
1739           }
1740           break;
1741
1742         case IPSEC_ENCRYPT_DES_CBC :
1743           /* RFC 2405 says :
1744              DES-CBC is a symmetric secret key algorithm.
1745              The key size is 64-bits.
1746              [It is commonly known as a 56-bit key as the key
1747              has 56 significant bits; the least significant
1748              bit in every byte is the parity bit.] */
1749
1750           /* Fix parameters for DES-CBC */
1751           esp_iv_len = 8;
1752           crypt_algo_libgcrypt = GCRY_CIPHER_DES;
1753           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1754           decrypted_len = len - 8;
1755
1756           if (decrypted_len <= 0)
1757             decrypt_ok = FALSE;
1758           else
1759           {
1760             if(decrypted_len % esp_iv_len == 0)
1761               decrypted_len_alloc = decrypted_len;
1762             else
1763               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1764
1765             if (esp_crypt_key_len != gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt))
1766             {
1767               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm DES-CBC : Bad Keylen (%u Bits, need %lu)\n",
1768                        esp_crypt_key_len * 8, (unsigned long) gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt) * 8);
1769               decrypt_ok = FALSE;
1770             }
1771             else
1772               decrypt_using_libgcrypt = TRUE;
1773           }
1774           break;
1775
1776         case IPSEC_ENCRYPT_AES_CTR :
1777         case IPSEC_ENCRYPT_AES_GCM :
1778           /* RFC 3686 says :
1779              AES supports three key sizes: 128 bits, 192 bits,
1780              and 256 bits.  The default key size is 128 bits,
1781              and all implementations MUST support this key
1782              size.  Implementations MAY also support key sizes
1783              of 192 bits and 256 bits. The remaining 32 bits
1784              will be used as nonce. */
1785
1786           /* Fix parameters for AES-CTR */
1787           esp_iv_len = 8;
1788           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CTR;
1789
1790           decrypted_len = len - 8;
1791
1792           if (decrypted_len <= 0)
1793             decrypt_ok = FALSE;
1794           else
1795           {
1796             if(decrypted_len % esp_iv_len  == 0)
1797               decrypted_len_alloc = decrypted_len;
1798             else
1799               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1800
1801             switch(esp_crypt_key_len * 8)
1802             {
1803             case 160:
1804               crypt_algo_libgcrypt = GCRY_CIPHER_AES128;
1805               decrypt_using_libgcrypt = TRUE;
1806               break;
1807
1808             case 224:
1809               crypt_algo_libgcrypt = GCRY_CIPHER_AES192;
1810               decrypt_using_libgcrypt = TRUE;
1811               break;
1812
1813             case 288:
1814               crypt_algo_libgcrypt = GCRY_CIPHER_AES256;
1815               decrypt_using_libgcrypt = TRUE;
1816               break;
1817
1818             default:
1819               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm AES-CTR / AES-GCM : Bad Keylen (%u Bits)\n",
1820                        esp_crypt_key_len * 8);
1821               decrypt_ok = FALSE;
1822             }
1823           }
1824           break;
1825
1826         case IPSEC_ENCRYPT_TWOFISH_CBC :
1827           /*  Twofish is a 128-bit block cipher developed by
1828               Counterpane Labs that accepts a variable-length
1829               key up to 256 bits.
1830               We will only accept key sizes of 128 and 256 bits.
1831           */
1832
1833           /* Fix parameters for TWOFISH-CBC */
1834           esp_iv_len = 16;
1835           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1836
1837           decrypted_len = len - 8;
1838
1839           if (decrypted_len <= 0)
1840             decrypt_ok = FALSE;
1841           else
1842           {
1843             if(decrypted_len % esp_iv_len  == 0)
1844               decrypted_len_alloc = decrypted_len;
1845             else
1846               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1847
1848             switch(esp_crypt_key_len * 8)
1849             {
1850             case 128:
1851               crypt_algo_libgcrypt = GCRY_CIPHER_TWOFISH128;
1852               decrypt_using_libgcrypt = TRUE;
1853               break;
1854
1855             case 256:
1856               crypt_algo_libgcrypt = GCRY_CIPHER_TWOFISH;
1857               decrypt_using_libgcrypt = TRUE;
1858               break;
1859
1860             default:
1861               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm TWOFISH-CBC : Bad Keylen (%u Bits)\n",
1862                        esp_crypt_key_len * 8);
1863               decrypt_ok = FALSE;
1864             }
1865           }
1866
1867           break;
1868
1869         case IPSEC_ENCRYPT_BLOWFISH_CBC :
1870           /* Bruce Schneier of Counterpane Systems developed
1871              the Blowfish block cipher algorithm.
1872              RFC 2451 shows that Blowfish uses key sizes from
1873              40 to 448 bits. The Default size is 128 bits.
1874              We will only accept key sizes of 128 bits, because
1875              libgrypt only accept this key size.
1876           */
1877
1878           /* Fix parameters for BLOWFISH-CBC */
1879           esp_iv_len = 8;
1880           crypt_algo_libgcrypt = GCRY_CIPHER_BLOWFISH;
1881           crypt_mode_libgcrypt = GCRY_CIPHER_MODE_CBC;
1882
1883           decrypted_len = len - 8;
1884
1885           if (decrypted_len <= 0)
1886             decrypt_ok = FALSE;
1887           else
1888           {
1889             if(decrypted_len % esp_iv_len  == 0)
1890               decrypted_len_alloc = decrypted_len;
1891             else
1892               decrypted_len_alloc = (decrypted_len / esp_iv_len) * esp_iv_len + esp_iv_len;
1893
1894             if (esp_crypt_key_len != gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt))
1895             {
1896               fprintf (stderr, "<ESP Preferences> Error in Encryption Algorithm BLOWFISH-CBC : Bad Keylen (%u Bits, need %lu)\n",
1897                        esp_crypt_key_len * 8, (unsigned long) gcry_cipher_get_algo_keylen (crypt_algo_libgcrypt) * 8);
1898               decrypt_ok = FALSE;
1899             }
1900             else
1901               decrypt_using_libgcrypt = TRUE;
1902           }
1903           break;
1904
1905         case IPSEC_ENCRYPT_NULL :
1906         default :
1907           /* Fix parameters */
1908           esp_iv_len = 0;
1909           decrypted_len = len - 8;
1910
1911           if (decrypted_len <= 0)
1912             decrypt_ok = FALSE;
1913           else
1914           {
1915             /* Allocate Buffers for Encrypted and Decrypted data  */
1916             decrypted_data = (guint8 *)wmem_alloc(wmem_packet_scope(), decrypted_len + 1);
1917             tvb_memcpy(tvb, decrypted_data, NEW_ESP_DATA_SIZE, decrypted_len);
1918
1919             decrypt_ok = TRUE;
1920           }
1921           break;
1922         }
1923
1924         if (decrypt_using_libgcrypt)
1925         {
1926           /* Allocate Buffers for Encrypted and Decrypted data  */
1927           decrypted_data = (guint8 *)wmem_alloc(wmem_packet_scope(), decrypted_len_alloc + esp_iv_len);
1928           tvb_memcpy(tvb, decrypted_data, NEW_ESP_DATA_SIZE, decrypted_len);
1929
1930           /* (Lazily) create the cipher_hd */
1931           if (!(*cipher_hd_created)) {
1932             err = gcry_cipher_open(cipher_hd, crypt_algo_libgcrypt, crypt_mode_libgcrypt, 0);
1933             if (err)
1934             {
1935               fprintf(stderr, "<IPsec/ESP Dissector> Error in Algorithm %s Mode %d, grcy_open_cipher failed: %s\n",
1936                       gcry_cipher_algo_name(crypt_algo_libgcrypt), crypt_mode_libgcrypt, gcry_strerror(err));
1937             }
1938             else
1939             {
1940               /* OK, set the key */
1941               if (*cipher_hd_created == FALSE)
1942               {
1943                 if (crypt_mode_libgcrypt == GCRY_CIPHER_MODE_CTR)
1944                 {
1945                   /* Counter mode key includes a 4 byte, (32 bit), nonce following the key */
1946                   err = gcry_cipher_setkey(*cipher_hd, esp_crypt_key, esp_crypt_key_len - 4);
1947                 }
1948                 else
1949                 {
1950                   err = gcry_cipher_setkey(*cipher_hd, esp_crypt_key, esp_crypt_key_len);
1951                 }
1952
1953                 if (err)
1954                 {
1955                   fprintf(stderr, "<IPsec/ESP Dissector> Error in Algorithm %s Mode %d, gcry_cipher_setkey(key_len=%u) failed: %s\n",
1956                           gcry_cipher_algo_name(crypt_algo_libgcrypt), crypt_mode_libgcrypt, esp_crypt_key_len, gcry_strerror(err));
1957                   gcry_cipher_close(*cipher_hd);
1958                 }
1959               }
1960
1961               /* Key is created and has its key set now */
1962               *cipher_hd_created = TRUE;
1963             }
1964           }
1965
1966           /* Now try to decrypt */
1967           if (crypt_mode_libgcrypt == GCRY_CIPHER_MODE_CTR)
1968           {
1969             /* Set CTR first */
1970             memset(ctr_block, 0, 16);
1971             memcpy(ctr_block, esp_crypt_key + esp_crypt_key_len - 4, 4);
1972             memcpy(ctr_block + 4, decrypted_data, 8);
1973             ctr_block[15] = 1;
1974             if (esp_crypt_algo == IPSEC_ENCRYPT_AES_GCM) {
1975               ctr_block[15]++;
1976             }
1977             err = gcry_cipher_setctr(*cipher_hd, ctr_block, 16);
1978             if (!err)
1979             {
1980               err = gcry_cipher_decrypt(*cipher_hd, decrypted_data + esp_iv_len, decrypted_len_alloc, NULL, 0);
1981             }
1982           }
1983           else
1984           {
1985             err = gcry_cipher_decrypt(*cipher_hd, decrypted_data, decrypted_len_alloc + esp_iv_len, NULL, 0);
1986           }
1987
1988           if (err)
1989           {
1990             fprintf(stderr, "<IPsec/ESP Dissector> Error in Algorithm %s, Mode %d, gcry_cipher_decrypt failed: %s\n",
1991                     gcry_cipher_algo_name(crypt_algo_libgcrypt), crypt_mode_libgcrypt, gcry_strerror(err));
1992             gcry_cipher_close(*cipher_hd);
1993             decrypt_ok = FALSE;
1994           }
1995           else
1996           {
1997             /* Copy back the Authentication which was not encrypted */
1998             if(decrypted_len >= esp_auth_len)
1999             {
2000               tvb_memcpy(tvb, decrypted_data+decrypted_len-esp_auth_len, (gint)(NEW_ESP_DATA_SIZE+decrypted_len-esp_auth_len), esp_auth_len);
2001             }
2002
2003             /* Decryption has finished */
2004             decrypt_ok = TRUE;
2005           }
2006         }
2007       }
2008     }
2009     else if(g_esp_enable_null_encryption_decode_heuristic)
2010     {
2011       /* The packet does not belong to a Security Association */
2012       null_encryption_decode_heuristic = TRUE;
2013     }
2014
2015     if(decrypt_ok && (decrypted_len > esp_iv_len))
2016     {
2017       tvb_decrypted = tvb_new_child_real_data(tvb, (guint8 *)wmem_memdup(pinfo->pool, decrypted_data+sizeof(guint8)*esp_iv_len,
2018                                                                       decrypted_len - esp_iv_len),
2019                                               decrypted_len - esp_iv_len, decrypted_len - esp_iv_len);
2020
2021       add_new_data_source(pinfo, tvb_decrypted, "Decrypted Data");
2022
2023       if(tvb_bytes_exist(tvb, 8, esp_iv_len))
2024       {
2025         if(esp_iv_len > 0)
2026           proto_tree_add_item(esp_tree, hf_esp_iv, tvb, 8, esp_iv_len, ENC_NA);
2027       }
2028       else
2029       {
2030           proto_tree_add_bytes_format(esp_tree, hf_esp_iv, tvb, 8, -1, NULL, "IV (truncated)");
2031       }
2032
2033       /* Make sure the packet is not truncated before the fields
2034        * we need to read to determine the encapsulated protocol */
2035       if(tvb_bytes_exist(tvb_decrypted, decrypted_len - esp_iv_len - esp_auth_len - 2, 2))
2036       {
2037         esp_pad_len = tvb_get_guint8(tvb_decrypted, decrypted_len - esp_iv_len - esp_auth_len - 2);
2038
2039         if(decrypted_len - esp_iv_len - esp_auth_len - esp_pad_len - 2 >= 0)
2040         {
2041           /* Get the encapsulated protocol */
2042           encapsulated_protocol = tvb_get_guint8(tvb_decrypted, decrypted_len - esp_iv_len - esp_auth_len - 1);
2043
2044           dissector_handle = dissector_get_uint_handle(ip_dissector_table, encapsulated_protocol);
2045           if (dissector_handle) {
2046             saved_match_uint  = pinfo->match_uint;
2047             pinfo->match_uint = encapsulated_protocol;
2048             next_tvb = tvb_new_subset_length(tvb_decrypted, 0,
2049                                       decrypted_len - esp_auth_len - esp_pad_len - esp_iv_len - 2);
2050             export_ipsec_pdu(dissector_handle, pinfo, next_tvb);
2051             call_dissector(dissector_handle, next_tvb, pinfo, tree);
2052             pinfo->match_uint = saved_match_uint;
2053             decrypt_dissect_ok = TRUE;
2054           }
2055         }
2056       }
2057
2058       if(decrypt_dissect_ok)
2059       {
2060         if(esp_tree)
2061         {
2062           if(esp_pad_len !=0)
2063             proto_tree_add_item(esp_tree, hf_esp_pad,
2064                                 tvb_decrypted,
2065                                 decrypted_len - esp_iv_len - esp_auth_len - 2 - esp_pad_len,
2066                                 esp_pad_len, ENC_NA);
2067
2068           proto_tree_add_uint(esp_tree, hf_esp_pad_len, tvb_decrypted,
2069                               decrypted_len - esp_iv_len - esp_auth_len - 2, 1,
2070                               esp_pad_len);
2071
2072           proto_tree_add_uint_format(esp_tree, hf_esp_protocol, tvb_decrypted,
2073                                      decrypted_len - esp_iv_len - esp_auth_len - 1, 1,
2074                                      encapsulated_protocol,
2075                                      "Next header: %s (0x%02x)",
2076                                      ipprotostr(encapsulated_protocol), encapsulated_protocol);
2077
2078           dissect_esp_authentication(esp_tree,
2079                                      tvb_decrypted,
2080                                      decrypted_len - esp_iv_len,
2081                                      esp_auth_len,
2082                                      authenticator_data_computed,
2083                                      authentication_ok,
2084                                      authentication_checking_ok );
2085         }
2086       }
2087       else
2088       {
2089         next_tvb = tvb_new_subset_length(tvb_decrypted, 0,
2090                                   decrypted_len - esp_iv_len - esp_auth_len);
2091         export_ipsec_pdu(data_handle, pinfo, next_tvb);
2092         call_dissector(data_handle, next_tvb, pinfo, esp_tree);
2093
2094         dissect_esp_authentication(esp_tree,
2095                                      tvb_decrypted,
2096                                      decrypted_len - esp_iv_len, esp_auth_len,
2097                                      authenticator_data_computed, authentication_ok,
2098                                      authentication_checking_ok );
2099       }
2100     }
2101   }
2102
2103   /*
2104     If the packet is present in the security association database and the field g_esp_enable_authentication_check set.
2105   */
2106   if(!g_esp_enable_encryption_decode && g_esp_enable_authentication_check && sad_is_present)
2107   {
2108     next_tvb = tvb_new_subset_length_caplen(tvb, 8, len - 8 - esp_auth_len, -1);
2109     export_ipsec_pdu(data_handle, pinfo, next_tvb);
2110     call_dissector(data_handle, next_tvb, pinfo, esp_tree);
2111
2112     dissect_esp_authentication(esp_tree, tvb, len ,
2113                                  esp_auth_len, authenticator_data_computed,
2114                                  authentication_ok, authentication_checking_ok );
2115   }
2116
2117   /* The packet does not belong to a security association and the field g_esp_enable_null_encryption_decode_heuristic is set */
2118   else if(null_encryption_decode_heuristic)
2119   {
2120     if(g_esp_enable_null_encryption_decode_heuristic)
2121     {
2122       /* Get length of whole ESP packet. */
2123       len = tvb_reported_length(tvb);
2124
2125       /* Make sure the packet is not truncated before the fields
2126        * we need to read to determine the encapsulated protocol */
2127       if(tvb_bytes_exist(tvb, len - 14, 2))
2128       {
2129         esp_pad_len = tvb_get_guint8(tvb, len - 14);
2130         encapsulated_protocol = tvb_get_guint8(tvb, len - 13);
2131         dissector_handle = dissector_get_uint_handle(ip_dissector_table, encapsulated_protocol);
2132         if (dissector_handle) {
2133           saved_match_uint  = pinfo->match_uint;
2134           pinfo->match_uint = encapsulated_protocol;
2135           next_tvb = tvb_new_subset_length(tvb, 8, len - 8 - 14 - esp_pad_len);
2136           export_ipsec_pdu(dissector_handle, pinfo, next_tvb);
2137           call_dissector(dissector_handle, next_tvb, pinfo, tree);
2138           pinfo->match_uint = saved_match_uint;
2139           decrypt_dissect_ok = TRUE;
2140         }
2141       }
2142     }
2143
2144     if(decrypt_dissect_ok)
2145     {
2146       if(esp_tree)
2147       {
2148         proto_tree_add_uint(esp_tree, hf_esp_pad_len, tvb,
2149                             len - 14, 1,
2150                             esp_pad_len);
2151
2152         proto_tree_add_uint_format(esp_tree, hf_esp_protocol, tvb,
2153                                    len - 13, 1,
2154                                    encapsulated_protocol,
2155                                    "Next header: %s (0x%02x)",
2156                                    ipprotostr(encapsulated_protocol), encapsulated_protocol);
2157
2158         /* Make sure we have the auth trailer data */
2159         if(tvb_bytes_exist(tvb, len - 12, 12))
2160         {
2161           proto_tree_add_item(esp_tree, hf_esp_authentication_data, tvb, len - 12, 12, ENC_NA);
2162         }
2163         else
2164         {
2165           /* Truncated so just display what we have */
2166           proto_tree_add_bytes_format(esp_tree, hf_esp_authentication_data, tvb, len - 12, 12 - (len - tvb_captured_length(tvb)),
2167                               NULL, "Authentication Data (truncated)");
2168         }
2169       }
2170     }
2171   }
2172   return tvb_captured_length(tvb);
2173 }
2174
2175
2176 static int
2177 dissect_ipcomp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* dissector_data _U_)
2178 {
2179   proto_tree *ipcomp_tree;
2180   proto_item *ti;
2181   guint8 comp_nxt;      /* Next Header */
2182   guint32 comp_cpi;     /* Compression parameter index */
2183   dissector_handle_t dissector_handle;
2184   guint32 saved_match_uint;
2185   tvbuff_t *data, *decomp;
2186
2187   /*
2188    * load the top pane info. This should be overwritten by
2189    * the next protocol in the stack
2190    */
2191   col_set_str(pinfo->cinfo, COL_PROTOCOL, "IPComp");
2192   col_clear(pinfo->cinfo, COL_INFO);
2193
2194   comp_nxt = tvb_get_guint8(tvb, 0);
2195
2196   /*
2197    * populate a tree in the second pane with the status of the link layer
2198    * (ie none)
2199    */
2200     ti = proto_tree_add_item(tree, proto_ipcomp, tvb, 0, -1, ENC_NA);
2201     ipcomp_tree = proto_item_add_subtree(ti, ett_ipcomp);
2202
2203     proto_tree_add_uint_format_value(ipcomp_tree, hf_ipcomp_next_header, tvb,
2204                         0, 1, comp_nxt, "%s (0x%02x)", ipprotostr(comp_nxt), comp_nxt);
2205     proto_tree_add_item(ipcomp_tree, hf_ipcomp_flags, tvb, 1, 1, ENC_NA);
2206     proto_tree_add_item_ret_uint(ipcomp_tree, hf_ipcomp_cpi, tvb, 2, 2, ENC_BIG_ENDIAN, &comp_cpi);
2207
2208     col_add_fstr(pinfo->cinfo, COL_INFO, "IPComp (CPI=%s)", val_to_str(comp_cpi, cpi2val, "0x%04x"));
2209
2210     data = tvb_new_subset_remaining(tvb, 4);
2211     export_ipsec_pdu(data_handle, pinfo, data);
2212     call_dissector(data_handle, data, pinfo, ipcomp_tree);
2213
2214     /*
2215      * try to uncompress as if it were DEFLATEd.  With negotiated
2216      * CPIs, we don't know the algorithm beforehand; if we get it
2217      * wrong, tvb_uncompress() returns NULL and nothing is displayed.
2218      */
2219     decomp = tvb_child_uncompress(data, data, 0, tvb_captured_length(data));
2220     if (decomp) {
2221         add_new_data_source(pinfo, decomp, "IPcomp inflated data");
2222         saved_match_uint  = pinfo->match_uint;
2223         dissector_handle = dissector_get_uint_handle(ip_dissector_table, comp_nxt);
2224         if (dissector_handle) {
2225           pinfo->match_uint = comp_nxt;
2226         } else {
2227           dissector_handle = data_handle;
2228         }
2229         export_ipsec_pdu(dissector_handle, pinfo, decomp);
2230         call_dissector(dissector_handle, decomp, pinfo, tree);
2231         pinfo->match_uint = saved_match_uint;
2232     }
2233
2234         return tvb_captured_length(tvb);
2235 }
2236
2237 static void ipsec_cleanup_protocol(void)
2238 {
2239   /* Free any SA records added by other dissectors */
2240   guint n;
2241   for (n=0; n < extra_esp_sa_records.num_records; n++) {
2242     uat_esp_sa_record_free_cb(&(extra_esp_sa_records.records[n]));
2243   }
2244
2245   /* Free overall block of records */
2246   g_free(extra_esp_sa_records.records);
2247   extra_esp_sa_records.records = NULL;
2248   extra_esp_sa_records.num_records = 0;
2249 }
2250
2251 void
2252 proto_register_ipsec(void)
2253 {
2254   static hf_register_info hf_ah[] = {
2255     { &hf_ah_next_header,
2256       { "Next header", "ah.next_header", FT_UINT8, BASE_DEC | BASE_EXT_STRING, &ipproto_val_ext, 0x0,
2257         NULL, HFILL }},
2258     { &hf_ah_length,
2259       { "Length", "ah.length", FT_UINT8, BASE_DEC, NULL, 0x0,
2260         NULL, HFILL }},
2261     { &hf_ah_reserved,
2262       { "Reserved", "ah.reserved", FT_BYTES, BASE_NONE, NULL, 0x0,
2263         NULL, HFILL }},
2264     { &hf_ah_spi,
2265       { "AH SPI", "ah.spi", FT_UINT32, BASE_HEX, NULL, 0x0,
2266         "IP Authentication Header Security Parameters Index", HFILL }},
2267     { &hf_ah_iv,
2268       { "AH ICV", "ah.icv", FT_BYTES, BASE_NONE, NULL, 0x0,
2269         "IP Authentication Header Integrity Check Value", HFILL }},
2270     { &hf_ah_sequence,
2271       { "AH Sequence", "ah.sequence", FT_UINT32, BASE_DEC, NULL, 0x0,
2272         "IP Authentication Header Sequence Number", HFILL }}
2273   };
2274
2275   static hf_register_info hf_esp[] = {
2276     { &hf_esp_spi,
2277       { "ESP SPI", "esp.spi", FT_UINT32, BASE_HEX_DEC, NULL, 0x0,
2278         "IP Encapsulating Security Payload Security Parameters Index", HFILL }},
2279     { &hf_esp_sequence,
2280       { "ESP Sequence", "esp.sequence", FT_UINT32, BASE_DEC, NULL, 0x0,
2281         "IP Encapsulating Security Payload Sequence Number", HFILL }},
2282     { &hf_esp_pad,
2283       { "Pad", "esp.pad", FT_BYTES, BASE_NONE, NULL, 0x0,
2284         NULL, HFILL }},
2285     { &hf_esp_pad_len,
2286       { "ESP Pad Length", "esp.pad_len", FT_UINT8, BASE_DEC, NULL, 0x0,
2287         "IP Encapsulating Security Payload Pad Length", HFILL }},
2288     { &hf_esp_protocol,
2289       { "ESP Next Header", "esp.protocol", FT_UINT8, BASE_HEX, NULL, 0x0,
2290         "IP Encapsulating Security Payload Next Header", HFILL }},
2291     { &hf_esp_authentication_data,
2292       { "Authentication Data", "esp.authentication_data", FT_BYTES, BASE_NONE, NULL, 0x0,
2293         NULL, HFILL }},
2294     { &hf_esp_iv,
2295       { "ESP IV", "esp.iv", FT_BYTES, BASE_NONE, NULL, 0x0,
2296         "IP Encapsulating Security Payload", HFILL }},
2297
2298     { &hf_esp_icv_good,
2299       { "Good", "esp.icv_good", FT_BOOLEAN, BASE_NONE,  NULL, 0x0,
2300         "True: ICV matches packet content; False: doesn't match content or not checked", HFILL }},
2301     { &hf_esp_icv_bad,
2302       { "Bad", "esp.icv_bad", FT_BOOLEAN, BASE_NONE,  NULL, 0x0,
2303         "True: ICV doesn't match packet content; False: matches content or not checked", HFILL }},
2304     { &hf_esp_sequence_analysis_expected_sn,
2305       { "Expected SN", "esp.sequence-analysis.expected-sn", FT_UINT32, BASE_DEC,  NULL, 0x0,
2306         NULL, HFILL }},
2307     { &hf_esp_sequence_analysis_previous_frame,
2308       { "Previous Frame", "esp.sequence-analysis.previous-frame", FT_FRAMENUM, BASE_NONE,  NULL, 0x0,
2309         NULL, HFILL }},
2310   };
2311
2312   static hf_register_info hf_ipcomp[] = {
2313     { &hf_ipcomp_next_header,
2314       { "Next Header", "ipcomp.next_header", FT_UINT8, BASE_HEX, NULL, 0x0,
2315         NULL, HFILL }},
2316     { &hf_ipcomp_flags,
2317       { "IPComp Flags", "ipcomp.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
2318         "IP Payload Compression Protocol Flags", HFILL }},
2319     { &hf_ipcomp_cpi,
2320       { "IPComp CPI", "ipcomp.cpi", FT_UINT16, BASE_HEX, VALS(cpi2val), 0x0,
2321         "IP Payload Compression Protocol Compression Parameter Index", HFILL }},
2322   };
2323
2324   static gint *ett[] = {
2325     &ett_ah,
2326     &ett_esp,
2327     &ett_esp_icv,
2328     &ett_ipcomp,
2329   };
2330
2331   static ei_register_info ei[] = {
2332     { &ei_esp_sequence_analysis_wrong_sequence_number, { "esp.sequence-analysis.wrong-sequence-number", PI_SEQUENCE, PI_WARN, "Wrong Sequence Number", EXPFILL }}
2333   };
2334
2335   static const value_string esp_proto_type_vals[] = {
2336     { IPSEC_SA_IPV4, "IPv4" },
2337     { IPSEC_SA_IPV6, "IPv6" },
2338     { 0x00, NULL }
2339   };
2340
2341   static const value_string esp_encryption_type_vals[] = {
2342     { IPSEC_ENCRYPT_NULL, "NULL" },
2343     { IPSEC_ENCRYPT_3DES_CBC, "TripleDES-CBC [RFC2451]" },
2344     { IPSEC_ENCRYPT_AES_CBC, "AES-CBC [RFC3602]" },
2345     { IPSEC_ENCRYPT_AES_CTR, "AES-CTR [RFC3686]" },
2346     { IPSEC_ENCRYPT_DES_CBC, "DES-CBC [RFC2405]" },
2347     { IPSEC_ENCRYPT_CAST5_CBC, "CAST5-CBC [RFC2144]" },
2348     { IPSEC_ENCRYPT_BLOWFISH_CBC, "BLOWFISH-CBC [RFC2451]" },
2349     { IPSEC_ENCRYPT_TWOFISH_CBC, "TWOFISH-CBC" },
2350     { IPSEC_ENCRYPT_AES_GCM, "AES-GCM [RFC4106]" },
2351     { 0x00, NULL }
2352   };
2353
2354   static const value_string esp_authentication_type_vals[] = {
2355     { IPSEC_AUTH_NULL, "NULL" },
2356     { IPSEC_AUTH_HMAC_SHA1_96, "HMAC-SHA-1-96 [RFC2404]" },
2357     { IPSEC_AUTH_HMAC_SHA256_96, "HMAC-SHA-256-96 [draft-ietf-ipsec-ciph-sha-256-00]" },
2358     { IPSEC_AUTH_HMAC_SHA256_128, "HMAC-SHA-256-128 [RFC4868]" },
2359     { IPSEC_AUTH_HMAC_SHA384_192, "HMAC-SHA-384-192 [RFC4868]" },
2360     { IPSEC_AUTH_HMAC_SHA512_256, "HMAC-SHA-512-256 [RFC4868]" },
2361     { IPSEC_AUTH_HMAC_MD5_96, "HMAC-MD5-96 [RFC2403]" },
2362     { IPSEC_AUTH_HMAC_RIPEMD160_96, "MAC-RIPEMD-160-96 [RFC2857]" },
2363 /*    { IPSEC_AUTH_AES_XCBC_MAC_96, "AES-XCBC-MAC-96 [RFC3566]" }, */
2364     { IPSEC_AUTH_ANY_64BIT, "ANY 64 bit authentication [no checking]" },
2365     { IPSEC_AUTH_ANY_96BIT, "ANY 96 bit authentication [no checking]" },
2366     { IPSEC_AUTH_ANY_128BIT, "ANY 128 bit authentication [no checking]" },
2367     { IPSEC_AUTH_ANY_192BIT, "ANY 192 bit authentication [no checking]" },
2368     { IPSEC_AUTH_ANY_256BIT, "ANY 256 bit authentication [no checking]" },
2369     { 0x00, NULL }
2370   };
2371
2372   static uat_field_t esp_uat_flds[] = {
2373       UAT_FLD_VS(uat_esp_sa_records, protocol, "Protocol", esp_proto_type_vals, "Protocol used"),
2374       UAT_FLD_CSTRING(uat_esp_sa_records, srcIP, "Src IP", "Source Address"),
2375       UAT_FLD_CSTRING(uat_esp_sa_records, dstIP, "Dest IP", "Destination Address"),
2376       UAT_FLD_CSTRING(uat_esp_sa_records, spi, "SPI", "SPI"),
2377       UAT_FLD_VS(uat_esp_sa_records, encryption_algo, "Encryption", esp_encryption_type_vals, "Encryption algorithm"),
2378       UAT_FLD_CSTRING(uat_esp_sa_records, encryption_key_string, "Encryption Key", "Encryption Key"),
2379       UAT_FLD_VS(uat_esp_sa_records, authentication_algo, "Authentication", esp_authentication_type_vals, "Authentication algorithm"),
2380       UAT_FLD_CSTRING(uat_esp_sa_records, authentication_key_string, "Authentication Key", "Authentication Key"),
2381       UAT_END_FIELDS
2382     };
2383
2384   static build_valid_func ah_da_build_value[1] = {ah_value};
2385   static decode_as_value_t ah_da_values = {ah_prompt, 1, ah_da_build_value};
2386   static decode_as_t ah_da = {"ah", "Network", "ip.proto", 1, 0, &ah_da_values, NULL, NULL,
2387                                   decode_as_default_populate_list, decode_as_default_reset, decode_as_default_change, NULL};
2388
2389   module_t *ah_module;
2390   module_t *esp_module;
2391
2392   expert_module_t* expert_esp;
2393
2394   proto_ah = proto_register_protocol("Authentication Header", "AH", "ah");
2395   proto_register_field_array(proto_ah, hf_ah, array_length(hf_ah));
2396
2397   proto_esp = proto_register_protocol("Encapsulating Security Payload",
2398                                       "ESP", "esp");
2399   proto_register_field_array(proto_esp, hf_esp, array_length(hf_esp));
2400
2401   proto_ipcomp = proto_register_protocol("IP Payload Compression",
2402                                          "IPComp", "ipcomp");
2403   proto_register_field_array(proto_ipcomp, hf_ipcomp, array_length(hf_ipcomp));
2404
2405   proto_register_subtree_array(ett, array_length(ett));
2406
2407   expert_esp = expert_register_protocol(proto_esp);
2408   expert_register_field_array(expert_esp, ei, array_length(ei));
2409
2410   ah_module = prefs_register_protocol(proto_ah, NULL);
2411
2412   prefs_register_obsolete_preference(ah_module, "place_ah_payload_in_subtree");
2413
2414   esp_module = prefs_register_protocol(proto_esp, NULL);
2415
2416   prefs_register_bool_preference(esp_module, "enable_null_encryption_decode_heuristic",
2417                                  "Attempt to detect/decode NULL encrypted ESP payloads",
2418                                  "This is done only if the Decoding is not SET or the packet does not belong to a SA. "
2419                                  "Assumes a 12 byte auth (HMAC-SHA1-96/HMAC-MD5-96/AES-XCBC-MAC-96) "
2420                                  "and attempts decode based on the ethertype 13 bytes from packet end",
2421                                  &g_esp_enable_null_encryption_decode_heuristic);
2422
2423   prefs_register_bool_preference(esp_module, "do_esp_sequence_analysis",
2424                                  "Check sequence numbers of ESP frames",
2425                                  "Check that successive frames increase sequence number by 1 within an SPI.  This should work OK when only one host is sending frames on an SPI",
2426                                  &g_esp_do_sequence_analysis);
2427
2428   prefs_register_bool_preference(esp_module, "enable_encryption_decode",
2429                                  "Attempt to detect/decode encrypted ESP payloads",
2430                                  "Attempt to decode based on the SAD described hereafter.",
2431                                  &g_esp_enable_encryption_decode);
2432
2433   prefs_register_bool_preference(esp_module, "enable_authentication_check",
2434                                  "Attempt to Check ESP Authentication",
2435                                  "Attempt to Check ESP Authentication based on the SAD described hereafter.",
2436                                  &g_esp_enable_authentication_check);
2437
2438   esp_uat = uat_new("ESP SAs",
2439             sizeof(uat_esp_sa_record_t),    /* record size */
2440             "esp_sa",                       /* filename */
2441             TRUE,                           /* from_profile */
2442             &uat_esp_sa_records,            /* data_ptr */
2443             &num_sa_uat,                    /* numitems_ptr */
2444             UAT_AFFECTS_DISSECTION,         /* affects dissection of packets, but not set of named fields */
2445             NULL,                           /* help */
2446             uat_esp_sa_record_copy_cb,      /* copy callback */
2447             uat_esp_sa_record_update_cb,    /* update callback */
2448             uat_esp_sa_record_free_cb,      /* free callback */
2449             NULL,                           /* post update callback */
2450             NULL,                           /* reset callback */
2451             esp_uat_flds);                  /* UAT field definitions */
2452
2453   prefs_register_uat_preference(esp_module,
2454                                 "sa_table",
2455                                 "ESP SAs",
2456                                 "Preconfigured ESP Security Associations",
2457                                 esp_uat);
2458
2459   esp_sequence_analysis_hash = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), g_direct_hash, g_direct_equal);
2460   esp_sequence_analysis_report_hash = wmem_map_new_autoreset(wmem_epan_scope(), wmem_file_scope(), g_direct_hash, g_direct_equal);
2461   register_cleanup_routine(&ipsec_cleanup_protocol);
2462
2463   register_dissector("esp", dissect_esp, proto_esp);
2464   register_dissector("ah", dissect_ah, proto_ah);
2465
2466   register_decode_as(&ah_da);
2467 }
2468
2469 void
2470 proto_reg_handoff_ipsec(void)
2471 {
2472   dissector_handle_t esp_handle, ah_handle, ipcomp_handle;
2473   capture_dissector_handle_t ah_cap_handle;
2474
2475   data_handle = find_dissector("data");
2476   ah_handle = find_dissector("ah");
2477   dissector_add_uint("ip.proto", IP_PROTO_AH, ah_handle);
2478   esp_handle = find_dissector("esp");
2479   dissector_add_uint("ip.proto", IP_PROTO_ESP, esp_handle);
2480   ipcomp_handle = create_dissector_handle(dissect_ipcomp, proto_ipcomp);
2481   dissector_add_uint("ip.proto", IP_PROTO_IPCOMP, ipcomp_handle);
2482
2483   ip_dissector_table = find_dissector_table("ip.proto");
2484
2485   ah_cap_handle = create_capture_dissector_handle(capture_ah, proto_ah);
2486   capture_dissector_add_uint("ip.proto", IP_PROTO_AH, ah_cap_handle);
2487
2488   exported_pdu_tap = find_tap_id(EXPORT_PDU_TAP_NAME_LAYER_3);
2489 }
2490
2491 /*
2492  * Editor modelines
2493  *
2494  * Local Variables:
2495  * c-basic-offset: 2
2496  * tab-width: 8
2497  * indent-tabs-mode: nil
2498  * End:
2499  *
2500  * ex: set shiftwidth=2 tabstop=8 expandtab:
2501  * :indentSize=2:tabSize=8:noTabs=true:
2502  */