X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/f7e20cf4da324fb040b4601cc71abd9025848387..refs/heads/master:/print-esp.c

diff --git a/print-esp.c b/print-esp.c
index 5548bf18..d89fefbe 100644
--- a/print-esp.c
+++ b/print-esp.c
@@ -23,32 +23,26 @@
 
 /* \summary: IPSEC Encapsulating Security Payload (ESP) printer */
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include <config.h>
 
-#include <netdissect-stdinc.h>
+#include "netdissect-stdinc.h"
 
 #include <string.h>
 #include <stdlib.h>
 
-/* Any code in this file that depends on HAVE_LIBCRYPTO depends on
- * HAVE_OPENSSL_EVP_H too. Undefining the former when the latter isn't defined
- * is the simplest way of handling the dependency.
- */
 #ifdef HAVE_LIBCRYPTO
-#ifdef HAVE_OPENSSL_EVP_H
 #include <openssl/evp.h>
-#else
-#undef HAVE_LIBCRYPTO
-#endif
 #endif
 
 #include "netdissect.h"
-#include "strtoaddr.h"
 #include "extract.h"
 
+#include "diag-control.h"
+
+#ifdef HAVE_LIBCRYPTO
+#include "strtoaddr.h"
 #include "ascii_strcasecmp.h"
+#endif
 
 #include "ip.h"
 #include "ip6.h"
@@ -87,8 +81,8 @@
  */
 
 struct newesp {
-	uint32_t	esp_spi;	/* ESP */
-	uint32_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 */
@@ -99,8 +93,8 @@ struct newesp {
 
 #ifdef HAVE_LIBCRYPTO
 union inaddr_u {
-	struct in_addr in4;
-	struct in6_addr in6;
+	nd_ipv4 in4;
+	nd_ipv6 in6;
 };
 struct sa_list {
 	struct sa_list	*next;
@@ -111,7 +105,7 @@ struct sa_list {
 	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;
@@ -130,10 +124,7 @@ EVP_CIPHER_CTX_new(void)
 {
 	EVP_CIPHER_CTX *ctx;
 
-	ctx = malloc(sizeof(*ctx));
-	if (ctx == NULL)
-		return (NULL);
-	memset(ctx, 0, sizeof(*ctx));
+	ctx = calloc(1, sizeof(*ctx));
 	return (ctx);
 }
 
@@ -145,21 +136,149 @@ EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
 }
 #endif
 
+#ifdef HAVE_EVP_DECRYPTINIT_EX
 /*
- * this will adjust ndo_packetp and ndo_snapend to new buffer!
+ * Initialize the cipher by calling EVP_DecryptInit_ex(), because
+ * calling EVP_DecryptInit() 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_DecryptInit_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_DecryptInit_ex()
+ * to set the cipher and the key.
+ *
+ * XXX - is there some reason why we need to make two calls?
  */
-USES_APPLE_DEPRECATED_API
-int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
+static int
+set_cipher_parameters(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
+		      const unsigned char *key,
+		      const unsigned char *iv)
+{
+	return EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv);
+}
+#else
+/*
+ * Initialize the cipher by calling EVP_DecryptInit(), because we don't
+ * have EVP_DecryptInit_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)
+{
+	return EVP_DecryptInit(ctx, cipher, key, iv);
+}
+#endif
+
+static u_char *
+do_decrypt(netdissect_options *ndo, const char *caller, struct sa_list *sa,
+    const u_char *iv, const u_char *ct, unsigned int ctlen)
+{
+	EVP_CIPHER_CTX *ctx;
+	unsigned int block_size;
+	unsigned int ptlen;
+	u_char *pt;
+	int len;
+
+	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,
+		    "%s: can't allocate memory for cipher context", caller);
+		return NULL;
+	}
+
+	if (set_cipher_parameters(ctx, sa->evp, sa->secret, NULL) < 0) {
+		EVP_CIPHER_CTX_free(ctx);
+		(*ndo->ndo_warning)(ndo, "%s: espkey init failed", caller);
+		return NULL;
+	}
+	if (set_cipher_parameters(ctx, NULL, NULL, iv) < 0) {
+		EVP_CIPHER_CTX_free(ctx);
+		(*ndo->ndo_warning)(ndo, "%s: IV init failed", caller);
+		return NULL;
+	}
+
+	/*
+	 * At least as I read RFC 5996 section 3.14 and RFC 4303 section 2.4,
+	 * if the cipher has a block size of which the ciphertext's size must
+	 * be a multiple, the payload must be padded to make that happen, so
+	 * the ciphertext length must be a multiple of the block size.  Fail
+	 * if that's not the case.
+	 */
+	block_size = (unsigned int)EVP_CIPHER_CTX_block_size(ctx);
+	if ((ctlen % block_size) != 0) {
+		EVP_CIPHER_CTX_free(ctx);
+		(*ndo->ndo_warning)(ndo,
+		    "%s: ciphertext size %u is not a multiple of the cipher block size %u",
+		    caller, ctlen, block_size);
+		return NULL;
+	}
+
+	/*
+	 * Attempt to allocate a buffer for the decrypted data, because
+	 * we can't decrypt on top of the input buffer.
+	 */
+	ptlen = ctlen;
+	pt = (u_char *)calloc(1, ptlen);
+	if (pt == NULL) {
+		EVP_CIPHER_CTX_free(ctx);
+		(*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+		    "%s: can't allocate memory for decryption buffer", caller);
+		return NULL;
+	}
+
+	/*
+	 * The size of the ciphertext handed to us is a multiple of the
+	 * cipher block size, so we don't need to worry about padding.
+	 */
+	if (!EVP_CIPHER_CTX_set_padding(ctx, 0)) {
+		free(pt);
+		EVP_CIPHER_CTX_free(ctx);
+		(*ndo->ndo_warning)(ndo,
+		    "%s: EVP_CIPHER_CTX_set_padding failed", caller);
+		return NULL;
+	}
+	if (!EVP_DecryptUpdate(ctx, pt, &len, ct, ctlen)) {
+		free(pt);
+		EVP_CIPHER_CTX_free(ctx);
+		(*ndo->ndo_warning)(ndo, "%s: EVP_DecryptUpdate failed",
+		    caller);
+		return NULL;
+	}
+	EVP_CIPHER_CTX_free(ctx);
+	return pt;
+}
+
+/*
+ * 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.
+ */
+DIAG_OFF_DEPRECATION
+int esp_decrypt_buffer_by_ikev2_print(netdissect_options *ndo,
 				      int initiator,
-				      u_char spii[8], u_char spir[8],
+				      const u_char spii[8],
+				      const u_char spir[8],
 				      const u_char *buf, const u_char *end)
 {
 	struct sa_list *sa;
 	const u_char *iv;
-	unsigned int len;
-	EVP_CIPHER_CTX *ctx;
-	unsigned int block_size, output_buffer_size;
-	u_char *output_buffer;
+	const u_char *ct;
+	unsigned int ctlen;
+	u_char *pt;
 
 	/* initiator arg is any non-zero value */
 	if(initiator) initiator=1;
@@ -182,56 +301,43 @@ int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
 	 */
 	end = end - sa->authlen;
 	iv  = buf;
-	buf = buf + sa->ivlen;
-	len = end-buf;
+	ct = iv + sa->ivlen;
+	ctlen = end-ct;
 
-	if(end <= buf) return 0;
+	if(end <= ct) return 0;
 
-	ctx = EVP_CIPHER_CTX_new();
-	if (ctx == NULL)
-		return 0;
-	/*
-	 * Allocate a buffer for the decrypted data.
-	 * The output buffer must be separate from the input buffer, and
-	 * its size must be a multiple of the cipher block size.
-	 */
-	block_size = (unsigned int)EVP_CIPHER_CTX_block_size(ctx);
-	output_buffer_size = len + (block_size - len % block_size);
-	output_buffer = (u_char *)malloc(output_buffer_size);
-	if (output_buffer == NULL) {
-		(*ndo->ndo_warning)(ndo, "can't allocate memory for decryption buffer");
+	pt = do_decrypt(ndo, __func__, sa, iv,
+	    ct, ctlen);
+	if (pt == NULL)
 		return 0;
-	}
-	if (EVP_CipherInit(ctx, sa->evp, sa->secret, NULL, 0) < 0)
-		(*ndo->ndo_warning)(ndo, "espkey init failed");
-	EVP_CipherInit(ctx, NULL, NULL, iv, 0);
-	EVP_Cipher(ctx, output_buffer, buf, len);
-	EVP_CIPHER_CTX_free(ctx);
 
 	/*
-	 * XXX - of course this is wrong, because buf is a const buffer,
-	 * but changing this would require a more complicated fix.
+	 * 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.
 	 */
-	memcpy(buf, output_buffer, len);
-	free(output_buffer);
-
-	ndo->ndo_packetp = buf;
-	ndo->ndo_snapend = end;
+	if (!nd_push_buffer(ndo, pt, pt, ctlen)) {
+		free(pt);
+		(*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+			"%s: can't push buffer on buffer stack", __func__);
+	}
 
 	return 1;
 }
-USES_APPLE_RST
+DIAG_ON_DEPRECATION
 
 static void esp_print_addsa(netdissect_options *ndo,
-			    struct sa_list *sa, int sa_def)
+			    const struct sa_list *sa, int sa_def)
 {
 	/* copy the "sa" */
 
 	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)
-		(*ndo->ndo_error)(ndo, "ran out of memory to allocate sa structure");
+		(*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+				  "%s: malloc", __func__);
 
 	*nsa = *sa;
 
@@ -243,7 +349,7 @@ static void esp_print_addsa(netdissect_options *ndo,
 }
 
 
-static u_int hexdigit(netdissect_options *ndo, char hex)
+static int hexdigit(netdissect_options *ndo, char hex)
 {
 	if (hex >= '0' && hex <= '9')
 		return (hex - '0');
@@ -252,40 +358,53 @@ static u_int hexdigit(netdissect_options *ndo, char hex)
 	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_warning)(ndo,
+				    "invalid hex digit %c in espsecret\n", hex);
+		return (-1);
 	}
 }
 
-static u_int hex2byte(netdissect_options *ndo, char *hexstring)
-{
-	u_int byte;
-
-	byte = (hexdigit(ndo, hexstring[0]) << 4) + hexdigit(ndo, hexstring[1]);
-	return byte;
-}
-
 /*
  * returns size of binary, 0 on failure.
  */
-static
-int espprint_decode_hex(netdissect_options *ndo,
-			u_char *binbuf, unsigned int binbuf_len,
-			char *hex)
+static int
+espprint_decode_hex(netdissect_options *ndo,
+		    u_char *binbuf, unsigned int binbuf_len, char *hex)
 {
-	unsigned int len;
+	size_t len;
 	int i;
 
+	/*
+	 * XXX - fail if the string length isn't a multiple of 2?
+	 */
 	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: %zu\n", len);
 		return 0;
 	}
 
 	i = 0;
 	while (hex[0] != '\0' && hex[1]!='\0') {
-		binbuf[i] = hex2byte(ndo, hex);
+		int upper_nibble, lower_nibble;
+
+		upper_nibble = hexdigit(ndo, hex[0]);
+		if (upper_nibble < 0) {
+			/*
+			 * Invalid hex digit; a warning has already been
+			 * printed.
+			 */
+			return 0;
+		}
+		lower_nibble = hexdigit(ndo, hex[1]);
+		if (lower_nibble < 0) {
+			/*
+			 * Invalid hex digit; a warning has already been
+			 * printed.
+			 */
+			return 0;
+		}
+		binbuf[i] = (((u_int)upper_nibble) << 4) + (((u_int)lower_nibble) << 0);
 		hex += 2;
 		i++;
 	}
@@ -297,7 +416,7 @@ int espprint_decode_hex(netdissect_options *ndo,
  * decode the form:    SPINUM@IP <tab> ALGONAME:0xsecret
  */
 
-USES_APPLE_DEPRECATED_API
+DIAG_OFF_DEPRECATION
 static int
 espprint_decode_encalgo(netdissect_options *ndo,
 			char *decode, struct sa_list *sa)
@@ -306,6 +425,7 @@ espprint_decode_encalgo(netdissect_options *ndo,
 	const EVP_CIPHER *evp;
 	int authlen = 0;
 	char *colon, *p;
+	const char *real_decode;
 
 	colon = strchr(decode, ':');
 	if (colon == NULL) {
@@ -326,10 +446,23 @@ espprint_decode_encalgo(netdissect_options *ndo,
 		p = strstr(decode, "-cbc");
 		*p = '\0';
 	}
-	evp = EVP_get_cipherbyname(decode);
+	/*
+	 * Not all versions of libcrypto support calls to add aliases
+	 * to ciphers - newer versions of libressl don't - so, instead
+	 * of making "3des" an alias for "des_ede3_cbc", if attempting
+	 * to get the cipher fails and the name is "3des", we try
+	 * "des_ede3_cbc".
+	 */
+	real_decode = decode;
+	if (strcmp(real_decode, "3des") == 0)
+		real_decode = "des-ede3-cbc";
+	evp = EVP_get_cipherbyname(real_decode);
 
 	if (!evp) {
-		(*ndo->ndo_warning)(ndo, "failed to find cipher algo %s\n", decode);
+		if (decode != real_decode)
+			(*ndo->ndo_warning)(ndo, "failed to find cipher algo %s (%s)\n", real_decode, decode);
+		else
+			(*ndo->ndo_warning)(ndo, "failed to find cipher algo %s\n", decode);
 		sa->evp = NULL;
 		sa->authlen = 0;
 		sa->ivlen = 0;
@@ -338,6 +471,7 @@ espprint_decode_encalgo(netdissect_options *ndo,
 
 	sa->evp = evp;
 	sa->authlen = authlen;
+	/* This returns an int, but it should never be negative */
 	sa->ivlen = EVP_CIPHER_iv_length(evp);
 
 	colon++;
@@ -361,10 +495,10 @@ espprint_decode_encalgo(netdissect_options *ndo,
 
 	return 1;
 }
-USES_APPLE_RST
+DIAG_ON_DEPRECATION
 
 /*
- * 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
@@ -380,8 +514,8 @@ espprint_decode_authalgo(netdissect_options *ndo,
 	}
 	*colon = '\0';
 
-	if(ascii_strcasecmp(colon,"sha1") == 0 ||
-	   ascii_strcasecmp(colon,"md5") == 0) {
+	if(ascii_strcasecmp(decode,"sha1") == 0 ||
+	   ascii_strcasecmp(decode,"md5") == 0) {
 		sa->authlen = 12;
 	}
 	return 1;
@@ -485,9 +619,9 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
 
 		secretfile = fopen(filename, FOPEN_READ_TXT);
 		if (secretfile == NULL) {
-			(*ndo->ndo_error)(ndo, "print_esp: can't open %s: %s\n",
-			    filename, strerror(errno));
-			return;
+			(*ndo->ndo_error)(ndo, S_ERR_ND_OPEN_FILE,
+					  "%s: can't open %s: %s\n",
+					  __func__, filename, strerror(errno));
 		}
 
 		while (fgets(fileline, sizeof(fileline)-1, secretfile) != NULL) {
@@ -517,6 +651,10 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
 		uint32_t spino;
 
 		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) {
@@ -538,7 +676,7 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
 
 	if (decode) {
 		/* skip any blank spaces */
-		while (isspace((unsigned char)*decode))
+		while (*decode == ' ' || *decode == '\t' || *decode == '\r' || *decode == '\n')
 			decode++;
 
 		if(!espprint_decode_encalgo(ndo, decode, &sa1)) {
@@ -549,7 +687,7 @@ static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
 	esp_print_addsa(ndo, &sa1, sa_def);
 }
 
-USES_APPLE_DEPRECATED_API
+DIAG_OFF_DEPRECATION
 static void esp_init(netdissect_options *ndo _U_)
 {
 	/*
@@ -560,11 +698,10 @@ static void esp_init(netdissect_options *ndo _U_)
 #if !defined(OPENSSL_API_COMPAT) || OPENSSL_API_COMPAT < 0x10100000L
 	OpenSSL_add_all_algorithms();
 #endif
-	EVP_add_cipher_alias(SN_des_ede3_cbc, "3des");
 }
-USES_APPLE_RST
+DIAG_ON_DEPRECATION
 
-void esp_print_decodesecret(netdissect_options *ndo)
+void esp_decodesecret_print(netdissect_options *ndo)
 {
 	char *line;
 	char *p;
@@ -593,118 +730,98 @@ void esp_print_decodesecret(netdissect_options *ndo)
 #endif
 
 #ifdef HAVE_LIBCRYPTO
-USES_APPLE_DEPRECATED_API
-#endif
-int
-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_
+#define USED_IF_LIBCRYPTO
+#else
+#define USED_IF_LIBCRYPTO _U_
 #endif
-	,
-	int *padlen
-#ifndef HAVE_LIBCRYPTO
-	_U_
+
+#ifdef HAVE_LIBCRYPTO
+DIAG_OFF_DEPRECATION
 #endif
-	)
+void
+esp_print(netdissect_options *ndo,
+	  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;
 #ifdef HAVE_LIBCRYPTO
+	const u_char *ep;
 	const struct ip *ip;
 	struct sa_list *sa = NULL;
 	const struct ip6_hdr *ip6 = NULL;
-	int advance;
-	int len;
-	u_char *secret;
-	int ivlen = 0;
-	const u_char *ivoff;
-	const u_char *p;
-	EVP_CIPHER_CTX *ctx;
-	unsigned int block_size, output_buffer_size;
-	u_char *output_buffer;
+	const u_char *iv;
+	u_int ivlen;
+	u_int payloadlen;
+	const u_char *ct;
+	u_char *pt;
+	u_int padlen;
+	u_int nh;
 #endif
 
+	ndo->ndo_protocol = "esp";
 	esp = (const struct newesp *)bp;
 
-#ifdef HAVE_LIBCRYPTO
-	secret = NULL;
-	advance = 0;
-#endif
+	nd_print_protocol_caps(ndo);
 
-#if 0
-	/* keep secret out of a register */
-	p = (u_char *)&secret;
-#endif
+	ND_PRINT("(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);
 
+#ifdef HAVE_LIBCRYPTO
 	/* 'ep' points to the end of available data. */
 	ep = ndo->ndo_snapend;
 
-	if ((const u_char *)(esp + 1) >= ep) {
-		ND_PRINT((ndo, "[|ESP]"));
-		goto fail;
-	}
-	ND_PRINT((ndo, "ESP(spi=0x%08x", EXTRACT_32BITS(&esp->esp_spi)));
-	ND_PRINT((ndo, ",seq=0x%x)", EXTRACT_32BITS(&esp->esp_seq)));
-	ND_PRINT((ndo, ", length %u", length));
-
-#ifndef HAVE_LIBCRYPTO
-	goto fail;
-#else
-	/* initiailize SAs */
+	/* initialize SAs */
 	if (ndo->ndo_sa_list_head == NULL) {
 		if (!ndo->ndo_espsecret)
-			goto fail;
+			return;
 
-		esp_print_decodesecret(ndo);
+		esp_decodesecret_print(ndo);
 	}
 
 	if (ndo->ndo_sa_list_head == NULL)
-		goto fail;
+		return;
 
 	ip = (const struct ip *)bp2;
-	switch (IP_V(ip)) {
+	switch (ver) {
 	case 6:
 		ip6 = (const struct ip6_hdr *)bp2;
 		/* 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 */
-		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) {
-			if (sa->spi == EXTRACT_32BITS(&esp->esp_spi) &&
+			if (sa->spi == GET_BE_U_4(esp->esp_spi) &&
 			    sa->daddr_version == 6 &&
 			    UNALIGNED_MEMCMP(&sa->daddr.in6, &ip6->ip6_dst,
-				   sizeof(struct in6_addr)) == 0) {
+				   sizeof(nd_ipv6)) == 0) {
 				break;
 			}
 		}
 		break;
 	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) {
-			if (sa->spi == EXTRACT_32BITS(&esp->esp_spi) &&
+			if (sa->spi == GET_BE_U_4(esp->esp_spi) &&
 			    sa->daddr_version == 4 &&
 			    UNALIGNED_MEMCMP(&sa->daddr.in4, &ip->ip_dst,
-				   sizeof(struct in_addr)) == 0) {
+				   sizeof(nd_ipv4)) == 0) {
 				break;
 			}
 		}
 		break;
 	default:
-		goto fail;
+		return;
 	}
 
 	/* if we didn't find the specific one, then look for
@@ -715,86 +832,109 @@ esp_print(netdissect_options *ndo,
 
 	/* 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;
 
 	/* pointer to the IV, if there is one */
-	ivoff = (const u_char *)(esp + 1) + 0;
+	iv = (const u_char *)(esp + 1) + 0;
 	/* length of the IV, if there is one; 0, if there isn't */
 	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;
 
-	if (sa->evp) {
-		ctx = EVP_CIPHER_CTX_new();
-		if (ctx != NULL) {
-			/*
-			 * Allocate a buffer for the decrypted data.
-			 * The output buffer must be separate from the
-			 * input buffer, and its size must be a multiple
-			 * of the cipher block size.
-			 */
-			block_size = (unsigned int)EVP_CIPHER_CTX_block_size(ctx);
-			output_buffer_size = len + (block_size - len % block_size);
-			output_buffer = (u_char *)malloc(output_buffer_size);
-			if (output_buffer == NULL) {
-				(*ndo->ndo_warning)(ndo, "can't allocate memory for decryption buffer");
-				return -1;
-			}
+	/*
+	 * 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;
+	 */
+	payloadlen = ep - ct;
 
-			if (EVP_CipherInit(ctx, sa->evp, secret, NULL, 0) < 0)
-				(*ndo->ndo_warning)(ndo, "espkey init failed");
+	if (sa->evp == NULL)
+		return;
 
-			p = ivoff;
-			EVP_CipherInit(ctx, NULL, NULL, p, 0);
-			len = ep - (p + ivlen);
+	/*
+	 * 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;
+	}
 
-			EVP_Cipher(ctx, output_buffer, p + ivlen, len);
-			EVP_CIPHER_CTX_free(ctx);
-			/*
-			 * XXX - of course this is wrong, because buf is a
-			 * const buffer, but changing this would require a
-			 * more complicated fix.
-			 */
-			memcpy(p + ivlen, output_buffer, len);
-			free(output_buffer);
-			advance = ivoff - (const u_char *)esp + ivlen;
-		} else
-			advance = sizeof(struct newesp);
-	} else
-		advance = sizeof(struct newesp);
+	pt = do_decrypt(ndo, __func__, sa, iv, ct, payloadlen);
+	if (pt == NULL)
+		return;
 
-	/* sanity check for pad length */
-	if (ep - bp < *(ep - 2))
-		goto fail;
+	/*
+	 * Switch to the output buffer for dissection, and
+	 * save it on the buffer stack so it can be freed.
+	 */
+	if (!nd_push_buffer(ndo, pt, pt, payloadlen)) {
+		free(pt);
+		(*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+			"%s: can't push buffer on buffer stack", __func__);
+	}
 
-	if (padlen)
-		*padlen = *(ep - 2) + 2;
+	/*
+	 * 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(pt + payloadlen - 2);
+	if (padlen + 2 > payloadlen) {
+		nd_print_trunc(ndo);
+		return;
+	}
 
-	if (nhdr)
-		*nhdr = *(ep - 1);
+	/* Get the next header */
+	nh = GET_U_1(pt + payloadlen - 1);
 
-	ND_PRINT((ndo, ": "));
-	return advance;
-#endif
+	ND_PRINT(": ");
 
-fail:
-	return -1;
+	/*
+	 * Don't put padding + padding length(1 byte) + next header(1 byte)
+	 * in the buffer because they are not part of the plaintext to decode.
+	 */
+	if (!nd_push_snaplen(ndo, pt, payloadlen - (padlen + 2))) {
+		(*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
+			"%s: can't push snaplen on buffer stack", __func__);
+	}
+
+	/* Now dissect the plaintext. */
+	ip_demux_print(ndo, pt, payloadlen - (padlen + 2), ver, fragmented,
+		       ttl_hl, nh, bp2);
+
+	/* Pop the buffer, freeing it. */
+	nd_pop_packet_info(ndo);
+	/* Pop the nd_push_snaplen */
+	nd_pop_packet_info(ndo);
+#endif
 }
 #ifdef HAVE_LIBCRYPTO
-USES_APPLE_RST
+DIAG_ON_DEPRECATION
 #endif
-
-/*
- * Local Variables:
- * c-style: whitesmith
- * c-basic-offset: 8
- * End:
- */