Add printing support for vsockmon devices.

[tcpdump] / print-esp.c

diff --git a/print-esp.c b/print-esp.c
index 8b90641adff486fc3bcd3194889ce0c24ff9e446..f182f1623aa978821e0cecb1928ece5aebe4b9f4 100644 (file)
--- a/print-esp.c
+++ b/print-esp.c
@@ -21,14 +21,15 @@
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */
 

+/* \summary: IPSEC Encapsulating Security Payload (ESP) printer */
+

 #ifdef HAVE_CONFIG_H
 #ifdef HAVE_CONFIG_H

-#include "config.h"
+#include <config.h>

 #endif
 
 #endif
 

-#include <string.h>
-
-#include <tcpdump-stdinc.h>
+#include "netdissect-stdinc.h"

 
 

+#include <string.h>

 #include <stdlib.h>
 
 /* Any code in this file that depends on HAVE_LIBCRYPTO depends on
 #include <stdlib.h>
 
 /* Any code in this file that depends on HAVE_LIBCRYPTO depends on


@@ -43,29 +44,14 @@
 #endif
 #endif
 
 #endif
 #endif
 

-#include <stdio.h>
-
-#include "ip.h"
-#ifdef INET6
-#include "ip6.h"
-#endif
-

 #include "netdissect.h"
 #include "netdissect.h"

-#include "addrtoname.h"
+#include "strtoaddr.h"

 #include "extract.h"
 
 #include "extract.h"
 

-#ifndef HAVE_SOCKADDR_STORAGE
-#ifdef INET6
-struct sockaddr_storage {
-       union {
-               struct sockaddr_in sin;
-               struct sockaddr_in6 sin6;
-       } un;
-};
-#else
-#define sockaddr_storage sockaddr
-#endif
-#endif /* HAVE_SOCKADDR_STORAGE */
+#include "ascii_strcasecmp.h"
+
+#include "ip.h"
+#include "ip6.h"

 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.


@@ -101,8 +87,8 @@ struct sockaddr_storage {
  */
 
 struct newesp {
  */
 
 struct newesp {

-       u_int32_t       esp_spi;        /* ESP */
-       u_int32_t       esp_seq;        /* Sequence number */
+       nd_uint32_t     esp_spi;        /* ESP */
+       nd_uint32_t     esp_seq;        /* Sequence number */

        /*variable size*/               /* (IV and) Payload data */
        /*variable size*/               /* padding */
        /*8bit*/                        /* pad size */
        /*variable size*/               /* (IV and) Payload data */
        /*variable size*/               /* padding */
        /*8bit*/                        /* pad size */


@@ -112,15 +98,20 @@ struct newesp {
 };
 
 #ifdef HAVE_LIBCRYPTO
 };
 
 #ifdef HAVE_LIBCRYPTO

+union inaddr_u {
+       struct in_addr in4;
+       struct in6_addr in6;
+};

 struct sa_list {
        struct sa_list  *next;
 struct sa_list {
        struct sa_list  *next;

-       struct sockaddr_storage daddr;
-       u_int32_t       spi;          /* if == 0, then IKEv2 */
+       u_int           daddr_version;
+       union inaddr_u  daddr;
+       uint32_t        spi;          /* if == 0, then IKEv2 */

        int             initiator;
        u_char          spii[8];      /* for IKEv2 */
        u_char          spir[8];
        const EVP_CIPHER *evp;
        int             initiator;
        u_char          spii[8];      /* for IKEv2 */
        u_char          spir[8];
        const EVP_CIPHER *evp;

-       int             ivlen;
+       u_int           ivlen;

        int             authlen;
        u_char          authsecret[256];
        int             authsecret_len;
        int             authlen;
        u_char          authsecret[256];
        int             authsecret_len;


@@ -128,19 +119,92 @@ struct sa_list {
        int             secretlen;
 };
 
        int             secretlen;
 };
 

+#ifndef HAVE_EVP_CIPHER_CTX_NEW
+/*
+ * Allocate an EVP_CIPHER_CTX.
+ * Used if we have an older version of OpenSSL that doesn't provide
+ * routines to allocate and free them.
+ */
+static EVP_CIPHER_CTX *
+EVP_CIPHER_CTX_new(void)
+{
+       EVP_CIPHER_CTX *ctx;
+
+       ctx = malloc(sizeof(*ctx));
+       if (ctx == NULL)
+               return (NULL);
+       memset(ctx, 0, sizeof(*ctx));
+       return (ctx);
+}
+
+static void
+EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
+{
+       EVP_CIPHER_CTX_cleanup(ctx);
+       free(ctx);
+}
+#endif
+
+#ifdef HAVE_EVP_CIPHERINIT_EX
+/*
+ * Initialize the cipher by calling EVP_CipherInit_ex(), because
+ * calling EVP_CipherInit() will reset the cipher context, clearing
+ * the cipher, so calling it twice, with the second call having a
+ * null cipher, will clear the already-set cipher.  EVP_CipherInit_ex(),
+ * however, won't reset the cipher context, so you can use it to specify
+ * the IV in a second call after a first call to EVP_CipherInit_ex()
+ * to set the cipher and the key.
+ *
+ * XXX - is there some reason why we need to make two calls?
+ */
+static int
+set_cipher_parameters(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                     const unsigned char *key,
+                     const unsigned char *iv, int enc)
+{
+       return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc);
+}
+#else

 /*
 /*

- * this will adjust ndo_packetp and ndo_snapend to new buffer!
+ * Initialize the cipher by calling EVP_CipherInit(), because we don't
+ * have EVP_CipherInit_ex(); we rely on it not trashing the context.
+ */
+static int
+set_cipher_parameters(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+                     const unsigned char *key,
+                     const unsigned char *iv, int enc)
+{
+       return EVP_CipherInit(ctx, cipher, key, iv, enc);
+}
+#endif
+
+/*
+ * This will allocate a new buffer containing the decrypted data.
+ * It returns 1 on success and 0 on failure.
+ *
+ * It will push the new buffer and the values of ndo->ndo_packetp and
+ * ndo->ndo_snapend onto the buffer stack, and change ndo->ndo_packetp
+ * and ndo->ndo_snapend to refer to the new buffer.
+ *
+ * Our caller must pop the buffer off the stack when it's finished
+ * dissecting anything in it and before it does any dissection of
+ * anything in the old buffer.  That will free the new buffer.

  */
 USES_APPLE_DEPRECATED_API
 int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
                                      int initiator,
  */
 USES_APPLE_DEPRECATED_API
 int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
                                      int initiator,

-                                     u_char spii[8], u_char spir[8],
-                                     u_char *buf, u_char *end)
+                                     const u_char spii[8],
+                                     const u_char spir[8],
+                                     const u_char *buf, const u_char *end)

 {
        struct sa_list *sa;
 {
        struct sa_list *sa;

-       u_char *iv;
-       int len;
-       EVP_CIPHER_CTX ctx;
+       const u_char *iv;
+       const u_char *ct;
+       unsigned int len;
+       EVP_CIPHER_CTX *ctx;
+       unsigned int block_size, buffer_size;
+       u_char *input_buffer, *output_buffer;
+       const u_char *pt;

 
        /* initiator arg is any non-zero value */
        if(initiator) initiator=1;
 
        /* initiator arg is any non-zero value */
        if(initiator) initiator=1;


@@ -163,23 +227,84 @@ int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
         */
        end = end - sa->authlen;
        iv  = buf;
         */
        end = end - sa->authlen;
        iv  = buf;

-       buf = buf + sa->ivlen;
-       len = end-buf;
+       ct = iv + sa->ivlen;
+       len = end-ct;

 
 

-       if(end <= buf) return 0;
+       if(end <= ct) return 0;

 
 

-       memset(&ctx, 0, sizeof(ctx));
-       if (EVP_CipherInit(&ctx, sa->evp, sa->secret, NULL, 0) < 0)
+       ctx = EVP_CIPHER_CTX_new();
+       if (ctx == NULL)
+               return 0;
+       if (set_cipher_parameters(ctx, sa->evp, sa->secret, NULL, 0) < 0) {

                (*ndo->ndo_warning)(ndo, "espkey init failed");
                (*ndo->ndo_warning)(ndo, "espkey init failed");

-       EVP_CipherInit(&ctx, NULL, NULL, iv, 0);
-       EVP_Cipher(&ctx, buf, buf, len);
-       EVP_CIPHER_CTX_cleanup(&ctx);
+               return 0;
+       }
+       if (set_cipher_parameters(ctx, NULL, NULL, iv, 0) < 0) {
+               (*ndo->ndo_warning)(ndo, "IV init failed");
+               return 0;
+       }
+       /*
+        * Allocate buffers for the encrypted and decrypted data.
+        * Both buffers' sizes must be a multiple of the cipher block
+        * size, and the output buffer must be separate from the input
+        * buffer.
+        */
+       block_size = (unsigned int)EVP_CIPHER_CTX_block_size(ctx);
+       buffer_size = len + (block_size - len % block_size);
+
+       /*
+        * Attempt to allocate the input buffer.
+        */
+       input_buffer = (u_char *)malloc(buffer_size);
+       if (input_buffer == NULL) {
+               EVP_CIPHER_CTX_free(ctx);
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                       "can't allocate memory for encrypted data buffer");
+       }
+       /*
+        * Copy the input data to the encrypted data buffer, and pad it
+        * with zeroes.
+        */
+       memcpy(input_buffer, ct, len);
+       memset(input_buffer + len, 0, buffer_size - len);

 
 

-       ndo->ndo_packetp = buf;
-       ndo->ndo_snapend = end;
+       /*
+        * Attempt to allocate the output buffer.
+        */
+       output_buffer = (u_char *)malloc(buffer_size);
+       if (output_buffer == NULL) {
+               free(input_buffer);
+               EVP_CIPHER_CTX_free(ctx);
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                       "can't allocate memory for decryption buffer");
+       }
+       if (!EVP_Cipher(ctx, output_buffer, input_buffer, len)) {
+               (*ndo->ndo_warning)(ndo, "EVP_Cipher failed");
+               return 0;
+       }
+       EVP_CIPHER_CTX_free(ctx);

 
 

-       return 1;
+       /*
+        * Free the input buffer; we no longer need it.
+        */
+       free(input_buffer);

 
 

+       /*
+        * Get a pointer to the plaintext.
+        */
+       pt = output_buffer;
+
+       /*
+        * Switch to the output buffer for dissection, and save it
+        * on the buffer stack so it can be freed; our caller must
+        * pop it when done.
+        */
+       if (!nd_push_buffer(ndo, output_buffer, pt, pt + len)) {
+               free(output_buffer);
+               return 0;
+       }
+
+       return 1;

 }
 USES_APPLE_RST
 
 }
 USES_APPLE_RST
 


@@ -190,9 +315,11 @@ static void esp_print_addsa(netdissect_options *ndo,
 
        struct sa_list *nsa;
 
 
        struct sa_list *nsa;
 

+       /* malloc() return used in a 'struct sa_list': do not free() */

        nsa = (struct sa_list *)malloc(sizeof(struct sa_list));
        if (nsa == NULL)
        nsa = (struct sa_list *)malloc(sizeof(struct sa_list));
        if (nsa == NULL)

-               (*ndo->ndo_error)(ndo, "ran out of memory to allocate sa structure");
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                                 "esp_print_addsa: malloc");

 
        *nsa = *sa;
 
 
        *nsa = *sa;
 


@@ -213,8 +340,8 @@ static u_int hexdigit(netdissect_options *ndo, char hex)
        else if (hex >= 'a' && hex <= 'f')
                return (hex - 'a' + 10);
        else {
        else if (hex >= 'a' && hex <= 'f')
                return (hex - 'a' + 10);
        else {

-               (*ndo->ndo_error)(ndo, "invalid hex digit %c in espsecret\n", hex);
-               return 0;
+               (*ndo->ndo_error)(ndo, S_ERR_ND_ESP_SECRET,
+                                 "invalid hex digit %c in espsecret\n", hex);

        }
 }
 
        }
 }
 


@@ -240,7 +367,7 @@ int espprint_decode_hex(netdissect_options *ndo,
        len = strlen(hex) / 2;
 
        if (len > binbuf_len) {
        len = strlen(hex) / 2;
 
        if (len > binbuf_len) {

-               (*ndo->ndo_warning)(ndo, "secret is too big: %d\n", len);
+               (*ndo->ndo_warning)(ndo, "secret is too big: %u\n", len);

                return 0;
        }
 
                return 0;
        }
 


@@ -299,6 +426,7 @@ espprint_decode_encalgo(netdissect_options *ndo,
 
        sa->evp = evp;
        sa->authlen = authlen;
 
        sa->evp = evp;
        sa->authlen = authlen;

+       /* This returns an int, but it should never be negative */

        sa->ivlen = EVP_CIPHER_iv_length(evp);
 
        colon++;
        sa->ivlen = EVP_CIPHER_iv_length(evp);
 
        colon++;


@@ -325,7 +453,7 @@ espprint_decode_encalgo(netdissect_options *ndo,
 USES_APPLE_RST
 
 /*
 USES_APPLE_RST
 
 /*

- * for the moment, ignore the auth algorith, just hard code the authenticator
+ * for the moment, ignore the auth algorithm, just hard code the authenticator

  * length. Need to research how openssl looks up HMAC stuff.
  */
 static int
  * length. Need to research how openssl looks up HMAC stuff.
  */
 static int


@@ -341,8 +469,8 @@ espprint_decode_authalgo(netdissect_options *ndo,
        }
        *colon = '\0';
 
        }
        *colon = '\0';
 

-       if(strcasecmp(colon,"sha1") == 0 ||
-          strcasecmp(colon,"md5") == 0) {
+       if(ascii_strcasecmp(colon,"sha1") == 0 ||
+          ascii_strcasecmp(colon,"md5") == 0) {

                sa->authlen = 12;
        }
        return 1;
                sa->authlen = 12;
        }
        return 1;


@@ -429,28 +557,30 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
        if (line == NULL) {
                decode = spikey;
                spikey = NULL;
        if (line == NULL) {
                decode = spikey;
                spikey = NULL;

+               /* sa1.daddr.version = 0; */

                /* memset(&sa1.daddr, 0, sizeof(sa1.daddr)); */
                /* sa1.spi = 0; */
                sa_def    = 1;
        } else
                decode = line;
 
                /* memset(&sa1.daddr, 0, sizeof(sa1.daddr)); */
                /* sa1.spi = 0; */
                sa_def    = 1;
        } else
                decode = line;
 

-       if (spikey && strcasecmp(spikey, "file") == 0) {
+       if (spikey && ascii_strcasecmp(spikey, "file") == 0) {

                /* open file and read it */
                FILE *secretfile;
                char  fileline[1024];
                /* open file and read it */
                FILE *secretfile;
                char  fileline[1024];

-               int   lineno=0;
+               int   subfile_lineno=0;

                char  *nl;
                char *filename = line;
 
                secretfile = fopen(filename, FOPEN_READ_TXT);
                if (secretfile == NULL) {
                char  *nl;
                char *filename = line;
 
                secretfile = fopen(filename, FOPEN_READ_TXT);
                if (secretfile == NULL) {

-                       perror(filename);
-                       exit(3);
+                       (*ndo->ndo_error)(ndo, S_ERR_ND_OPEN_FILE,
+                                         "print_esp: can't open %s: %s\n",
+                                         filename, strerror(errno));

                }
 
                while (fgets(fileline, sizeof(fileline)-1, secretfile) != NULL) {
                }
 
                while (fgets(fileline, sizeof(fileline)-1, secretfile) != NULL) {

-                       lineno++;
+                       subfile_lineno++;

                        /* remove newline from the line */
                        nl = strchr(fileline, '\n');
                        if (nl)
                        /* remove newline from the line */
                        nl = strchr(fileline, '\n');
                        if (nl)


@@ -458,14 +588,14 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
                        if (fileline[0] == '#') continue;
                        if (fileline[0] == '\0') continue;
 
                        if (fileline[0] == '#') continue;
                        if (fileline[0] == '\0') continue;
 

-                       esp_print_decode_onesecret(ndo, fileline, filename, lineno);
+                       esp_print_decode_onesecret(ndo, fileline, filename, subfile_lineno);

                }
                fclose(secretfile);
 
                return;
        }
 
                }
                fclose(secretfile);
 
                return;
        }
 

-       if (spikey && strcasecmp(spikey, "ikev2") == 0) {
+       if (spikey && ascii_strcasecmp(spikey, "ikev2") == 0) {

                esp_print_decode_ikeline(ndo, line, file, lineno);
                return;
        }
                esp_print_decode_ikeline(ndo, line, file, lineno);
                return;
        }


@@ -473,13 +603,13 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
        if (spikey) {
 
                char *spistr, *foo;
        if (spikey) {
 
                char *spistr, *foo;

-               u_int32_t spino;
-               struct sockaddr_in *sin;
-#ifdef INET6
-               struct sockaddr_in6 *sin6;
-#endif
+               uint32_t spino;

 
                spistr = strsep(&spikey, "@");
 
                spistr = strsep(&spikey, "@");

+               if (spistr == NULL) {
+                       (*ndo->ndo_warning)(ndo, "print_esp: failed to find the @ token");
+                       return;
+               }

 
                spino = strtoul(spistr, &foo, 0);
                if (spistr == foo || !spikey) {
 
                spino = strtoul(spistr, &foo, 0);
                if (spistr == foo || !spikey) {


@@ -489,25 +619,14 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
 
                sa1.spi = spino;
 
 
                sa1.spi = spino;
 

-               sin = (struct sockaddr_in *)&sa1.daddr;
-#ifdef INET6
-               sin6 = (struct sockaddr_in6 *)&sa1.daddr;
-               if (inet_pton(AF_INET6, spikey, &sin6->sin6_addr) == 1) {
-#ifdef HAVE_SOCKADDR_SA_LEN
-                       sin6->sin6_len = sizeof(struct sockaddr_in6);
-#endif
-                       sin6->sin6_family = AF_INET6;
-               } else
-#endif
-                       if (inet_pton(AF_INET, spikey, &sin->sin_addr) == 1) {
-#ifdef HAVE_SOCKADDR_SA_LEN
-                               sin->sin_len = sizeof(struct sockaddr_in);
-#endif
-                               sin->sin_family = AF_INET;
-                       } else {
-                               (*ndo->ndo_warning)(ndo, "print_esp: can not decode IP# %s\n", spikey);
-                               return;
-                       }
+               if (strtoaddr6(spikey, &sa1.daddr.in6) == 1) {
+                       sa1.daddr_version = 6;
+               } else if (strtoaddr(spikey, &sa1.daddr.in4) == 1) {
+                       sa1.daddr_version = 4;
+               } else {
+                       (*ndo->ndo_warning)(ndo, "print_esp: can not decode IP# %s\n", spikey);
+                       return;
+               }

        }
 
        if (decode) {
        }
 
        if (decode) {


@@ -526,8 +645,14 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
 USES_APPLE_DEPRECATED_API
 static void esp_init(netdissect_options *ndo _U_)
 {
 USES_APPLE_DEPRECATED_API
 static void esp_init(netdissect_options *ndo _U_)
 {

-
+       /*
+        * 0.9.6 doesn't appear to define OPENSSL_API_COMPAT, so
+        * we check whether it's undefined or it's less than the
+        * value for 1.1.0.
+        */
+#if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < 0x10100000L

        OpenSSL_add_all_algorithms();
        OpenSSL_add_all_algorithms();

+#endif

        EVP_add_cipher_alias(SN_des_ede3_cbc, "3des");
 }
 USES_APPLE_RST
        EVP_add_cipher_alias(SN_des_ede3_cbc, "3des");
 }
 USES_APPLE_RST


@@ -560,122 +685,105 @@ void esp_print_decodesecret(netdissect_options *ndo)
 
 #endif
 
 
 #endif
 

+#ifdef HAVE_LIBCRYPTO
+#define USED_IF_LIBCRYPTO
+#else
+#define USED_IF_LIBCRYPTO _U_
+#endif
+

 #ifdef HAVE_LIBCRYPTO
 USES_APPLE_DEPRECATED_API
 #endif
 #ifdef HAVE_LIBCRYPTO
 USES_APPLE_DEPRECATED_API
 #endif

-int
+void

 esp_print(netdissect_options *ndo,
 esp_print(netdissect_options *ndo,

-         const u_char *bp, const int length, const u_char *bp2
-#ifndef HAVE_LIBCRYPTO
-       _U_
-#endif
-       ,
-       int *nhdr
-#ifndef HAVE_LIBCRYPTO
-       _U_
-#endif
-       ,
-       int *padlen
-#ifndef HAVE_LIBCRYPTO
-       _U_
-#endif
-       )
+         const u_char *bp, u_int length,
+         const u_char *bp2 USED_IF_LIBCRYPTO,
+         u_int ver USED_IF_LIBCRYPTO,
+         int fragmented USED_IF_LIBCRYPTO,
+         u_int ttl_hl USED_IF_LIBCRYPTO)

 {
 {

-       register const struct newesp *esp;
-       register const u_char *ep;
+       const struct newesp *esp;
+       const u_char *ep;

 #ifdef HAVE_LIBCRYPTO
 #ifdef HAVE_LIBCRYPTO

-       struct ip *ip;
+       const struct ip *ip;

        struct sa_list *sa = NULL;
        struct sa_list *sa = NULL;

-#ifdef INET6
-       struct ip6_hdr *ip6 = NULL;
-#endif
-       int advance;
-       int len;
-       u_char *secret;
-       int ivlen = 0;
-       u_char *ivoff;
-       u_char *p;
-       EVP_CIPHER_CTX ctx;
-#endif
-
-       esp = (struct newesp *)bp;
-
-#ifdef HAVE_LIBCRYPTO
-       secret = NULL;
-       advance = 0;
+       const struct ip6_hdr *ip6 = NULL;
+       const u_char *iv;
+       u_int ivlen;
+       const u_char *ct;
+       u_int ctlen;
+       EVP_CIPHER_CTX *ctx;
+       unsigned int block_size, buffer_size;
+       u_char *input_buffer, *output_buffer;
+       const u_char *pt;
+       u_int ptlen;
+       u_int padlen;
+       u_int nh;

 #endif
 
 #endif
 

-#if 0
-       /* keep secret out of a register */
-       p = (u_char *)&secret;
-#endif
+       ndo->ndo_protocol = "esp";
+       esp = (const struct newesp *)bp;

 
        /* 'ep' points to the end of available data. */
        ep = ndo->ndo_snapend;
 
 
        /* 'ep' points to the end of available data. */
        ep = ndo->ndo_snapend;
 

-       if ((u_char *)(esp + 1) >= ep) {
-               fputs("[|ESP]", stdout);
-               goto fail;
+       if ((const u_char *)(esp + 1) >= ep) {
+               nd_print_trunc(ndo);
+               return;

        }
        }

-       (*ndo->ndo_printf)(ndo, "ESP(spi=0x%08x", EXTRACT_32BITS(&esp->esp_spi));
-       (*ndo->ndo_printf)(ndo, ",seq=0x%x)", EXTRACT_32BITS(&esp->esp_seq));
-        (*ndo->ndo_printf)(ndo, ", length %u", length);
+       ND_PRINT("ESP(spi=0x%08x", GET_BE_U_4(esp->esp_spi));
+       ND_PRINT(",seq=0x%x)", GET_BE_U_4(esp->esp_seq));
+       ND_PRINT(", length %u", length);

 
 

-#ifndef HAVE_LIBCRYPTO
-       goto fail;
-#else
+#ifdef HAVE_LIBCRYPTO

        /* initiailize SAs */
        if (ndo->ndo_sa_list_head == NULL) {
                if (!ndo->ndo_espsecret)
        /* initiailize SAs */
        if (ndo->ndo_sa_list_head == NULL) {
                if (!ndo->ndo_espsecret)

-                       goto fail;
+                       return;

 
                esp_print_decodesecret(ndo);
        }
 
        if (ndo->ndo_sa_list_head == NULL)
 
                esp_print_decodesecret(ndo);
        }
 
        if (ndo->ndo_sa_list_head == NULL)

-               goto fail;
+               return;

 
 

-       ip = (struct ip *)bp2;
-       switch (IP_V(ip)) {
-#ifdef INET6
+       ip = (const struct ip *)bp2;
+       switch (ver) {

        case 6:
        case 6:

-               ip6 = (struct ip6_hdr *)bp2;
+               ip6 = (const struct ip6_hdr *)bp2;

                /* we do not attempt to decrypt jumbograms */
                /* we do not attempt to decrypt jumbograms */

-               if (!EXTRACT_16BITS(&ip6->ip6_plen))
-                       goto fail;
+               if (!GET_BE_U_2(ip6->ip6_plen))
+                       return;
+               /* XXX - check whether it's fragmented? */

                /* if we can't get nexthdr, we do not need to decrypt it */
                /* if we can't get nexthdr, we do not need to decrypt it */

-               len = sizeof(struct ip6_hdr) + EXTRACT_16BITS(&ip6->ip6_plen);

 
                /* see if we can find the SA, and if so, decode it */
                for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
 
                /* see if we can find the SA, and if so, decode it */
                for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {

-                       struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&sa->daddr;
-                       if (sa->spi == EXTRACT_32BITS(&esp->esp_spi) &&
-                           sin6->sin6_family == AF_INET6 &&
-                           memcmp(&sin6->sin6_addr, &ip6->ip6_dst,
-                                  sizeof(struct in6_addr)) == 0) {
+                       if (sa->spi == GET_BE_U_4(esp->esp_spi) &&
+                           sa->daddr_version == 6 &&
+                           UNALIGNED_MEMCMP(&sa->daddr.in6, &ip6->ip6_dst,
+                                  sizeof(nd_ipv6)) == 0) {

                                break;
                        }
                }
                break;
                                break;
                        }
                }
                break;

-#endif /*INET6*/

        case 4:
                /* nexthdr & padding are in the last fragment */
        case 4:
                /* nexthdr & padding are in the last fragment */

-               if (EXTRACT_16BITS(&ip->ip_off) & IP_MF)
-                       goto fail;
-               len = EXTRACT_16BITS(&ip->ip_len);
+               if (fragmented)
+                       return;

 
                /* see if we can find the SA, and if so, decode it */
                for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
 
                /* see if we can find the SA, and if so, decode it */
                for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {

-                       struct sockaddr_in *sin = (struct sockaddr_in *)&sa->daddr;
-                       if (sa->spi == EXTRACT_32BITS(&esp->esp_spi) &&
-                           sin->sin_family == AF_INET &&
-                           sin->sin_addr.s_addr == ip->ip_dst.s_addr) {
+                       if (sa->spi == GET_BE_U_4(esp->esp_spi) &&
+                           sa->daddr_version == 4 &&
+                           UNALIGNED_MEMCMP(&sa->daddr.in4, &ip->ip_dst,
+                                  sizeof(nd_ipv4)) == 0) {

                                break;
                        }
                }
                break;
        default:
                                break;
                        }
                }
                break;
        default:

-               goto fail;
+               return;

        }
 
        /* if we didn't find the specific one, then look for
        }
 
        /* if we didn't find the specific one, then look for


@@ -686,58 +794,173 @@ esp_print(netdissect_options *ndo,
 
        /* if not found fail */
        if (sa == NULL)
 
        /* if not found fail */
        if (sa == NULL)

-               goto fail;
-
-       /* if we can't get nexthdr, we do not need to decrypt it */
-       if (ep - bp2 < len)
-               goto fail;
-       if (ep - bp2 > len) {
-               /* FCS included at end of frame (NetBSD 1.6 or later) */
-               ep = bp2 + len;
-       }
+               return;

 
 

-       ivoff = (u_char *)(esp + 1) + 0;
+       /* pointer to the IV, if there is one */
+       iv = (const u_char *)(esp + 1) + 0;
+       /* length of the IV, if there is one; 0, if there isn't */

        ivlen = sa->ivlen;
        ivlen = sa->ivlen;

-       secret = sa->secret;
+
+       /*
+        * Get a pointer to the ciphertext.
+        *
+        * p points to the beginning of the payload, i.e. to the
+        * initialization vector, so if we skip past the initialization
+        * vector, it points to the beginning of the ciphertext.
+        */
+       ct = iv + ivlen;
+
+       /*
+        * Make sure the authentication data/integrity check value length
+        * isn't bigger than the total amount of data available after
+        * the ESP header and initialization vector is removed and,
+        * if not, slice the authentication data/ICV off.
+        */
+       if (ep - ct < sa->authlen) {
+               nd_print_trunc(ndo);
+               return;
+       }

        ep = ep - sa->authlen;
 
        ep = ep - sa->authlen;
 

-       if (sa->evp) {
-               memset(&ctx, 0, sizeof(ctx));
-               if (EVP_CipherInit(&ctx, sa->evp, secret, NULL, 0) < 0)
-                       (*ndo->ndo_warning)(ndo, "espkey init failed");
+       /*
+        * Calculate the length of the ciphertext.  ep points to
+        * the beginning of the authentication data/integrity check
+        * value, i.e. right past the end of the ciphertext;
+        */
+       ctlen = ep - ct;

 
 

-               p = ivoff;
-               EVP_CipherInit(&ctx, NULL, NULL, p, 0);
-               EVP_Cipher(&ctx, p + ivlen, p + ivlen, ep - (p + ivlen));
-               EVP_CIPHER_CTX_cleanup(&ctx);
-               advance = ivoff - (u_char *)esp + ivlen;
-       } else
-               advance = sizeof(struct newesp);
+       if (sa->evp == NULL)
+               return;
+
+       /*
+        * If the next header value is past the end of the available
+        * data, we won't be able to fetch it once we've decrypted
+        * the ciphertext, so there's no point in decrypting the data.
+        *
+        * Report it as truncation.
+        */
+       if (!ND_TTEST_1(ep - 1)) {
+               nd_print_trunc(ndo);
+               return;
+       }
+
+       ctx = EVP_CIPHER_CTX_new();
+       if (ctx == NULL) {
+               /*
+                * Failed to initialize the cipher context.
+                * From a look at the OpenSSL code, this appears to
+                * mean "couldn't allocate memory for the cipher context";
+                * note that we're not passing any parameters, so there's
+                * not much else it can mean.
+                */
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                       "esp_print: can't allocate memory for cipher context");
+       }

 
 

-       /* sanity check for pad length */
-       if (ep - bp < *(ep - 2))
-               goto fail;
+       if (set_cipher_parameters(ctx, sa->evp, sa->secret, NULL, 0) < 0) {
+               (*ndo->ndo_warning)(ndo, "espkey init failed");
+               return;
+       }

 
 

-       if (padlen)
-               *padlen = *(ep - 2) + 2;
+       if (set_cipher_parameters(ctx, NULL, NULL, iv, 0) < 0) {
+               (*ndo->ndo_warning)(ndo, "IV init failed");
+               return;
+       }

 
 

-       if (nhdr)
-               *nhdr = *(ep - 1);
+       /*
+        * Allocate buffers for the encrypted and decrypted
+        * data.  Both buffers' sizes must be a multiple of
+        * the cipher block size, and the output buffer must
+        * be separate from the input buffer.
+        */
+       block_size = (unsigned int)EVP_CIPHER_CTX_block_size(ctx);
+       buffer_size = ctlen + (block_size - ctlen % block_size);

 
 

-       (ndo->ndo_printf)(ndo, ": ");
-       return advance;
-#endif
+       /*
+        * Attempt to allocate the input buffer.
+        */
+       input_buffer = (u_char *)malloc(buffer_size);
+       if (input_buffer == NULL) {
+               EVP_CIPHER_CTX_free(ctx);
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                       "esp_print: can't allocate memory for encrypted data buffer");
+       }
+       /*
+        * Copy the input data to the encrypted data buffer,
+        * and pad it with zeroes.
+        */
+       memcpy(input_buffer, ct, ctlen);
+       memset(input_buffer + ctlen, 0, buffer_size - ctlen);

 
 

-fail:
-       return -1;
+       /*
+        * Attempt to allocate the output buffer.
+        */
+       output_buffer = (u_char *)malloc(buffer_size);
+       if (output_buffer == NULL) {
+               free(input_buffer);
+               EVP_CIPHER_CTX_free(ctx);
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                       "esp_print: can't allocate memory for decryption buffer");
+       }
+
+       if (!EVP_Cipher(ctx, output_buffer, input_buffer, ctlen)) {
+               free(input_buffer);
+               (*ndo->ndo_warning)(ndo, "EVP_Cipher failed");
+               return;
+       }
+       free(input_buffer);
+       EVP_CIPHER_CTX_free(ctx);
+
+       /*
+        * Pointer to the plaintext.
+        */
+       pt = output_buffer;
+
+       /*
+        * Length of the plaintext, which is the same as the length
+        * of the ciphertext.
+        */
+       ptlen = ctlen;
+
+       /*
+        * Switch to the output buffer for dissection, and
+        * save it on the buffer stack so it can be freed.
+        */
+       if (!nd_push_buffer(ndo, output_buffer, pt, pt + ctlen)) {
+               free(output_buffer);
+               (*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+                       "esp_print: can't push buffer on buffer stack");
+       }
+       ep = pt + ptlen;
+
+       /*
+        * Sanity check for pad length; if it, plus 2 for the pad
+        * length and next header fields, is bigger than the ciphertext
+        * length (which is also the plaintext length), it's too big.
+        *
+        * XXX - the check can fail if the packet is corrupt *or* if
+        * it was not decrypted with the correct key, so that the
+        * "plaintext" is not what was being sent.
+        */
+       padlen = GET_U_1(ep - 2);
+       if (padlen + 2 > ptlen) {
+               nd_print_trunc(ndo);
+               return;
+       }
+
+       /* Get the next header */
+       nh = GET_U_1(ep - 1);
+
+       ND_PRINT(": ");
+
+       /* Now dissect the plaintext. */
+       ip_print_demux(ndo, pt, ptlen - (padlen + 2), ver, fragmented,
+           ttl_hl, nh, bp2);
+
+       /* Pop the buffer, freeing it. */
+       nd_pop_buffer(ndo);
+#endif

 }
 #ifdef HAVE_LIBCRYPTO
 USES_APPLE_RST
 #endif
 }
 #ifdef HAVE_LIBCRYPTO
 USES_APPLE_RST
 #endif

-
-/*
- * Local Variables:
- * c-style: whitesmith
- * c-basic-offset: 8
- * End:
- */