X-Git-Url: https://git.tcpdump.org/tcpdump/blobdiff_plain/b0acedad189fd00412b56a5e63d6a89930a76830..cda9bf8c5f842fc7110fbbf2234bcc898f78c0bd:/print-esp.c

diff --git a/print-esp.c b/print-esp.c
index 85a5d5ac..f182f162 100644
--- a/print-esp.c
+++ b/print-esp.c
@@ -111,7 +111,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;
@@ -152,7 +152,7 @@ EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx)
  * 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 oin a second call after a first call to EVP_CipherInit_ex()
+ * 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?
@@ -179,7 +179,16 @@ set_cipher_parameters(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
 #endif
 
 /*
- * this will adjust ndo_packetp and ndo_snapend to new buffer!
+ * 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,
@@ -190,10 +199,12 @@ int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
 {
 	struct sa_list *sa;
 	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;
@@ -216,17 +227,22 @@ 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;
+	len = end-ct;
 
-	if(end <= buf) return 0;
+	if(end <= ct) return 0;
 
 	ctx = EVP_CIPHER_CTX_new();
 	if (ctx == NULL)
 		return 0;
-	if (set_cipher_parameters(ctx, sa->evp, sa->secret, NULL, 0) < 0)
+	if (set_cipher_parameters(ctx, sa->evp, sa->secret, NULL, 0) < 0) {
 		(*ndo->ndo_warning)(ndo, "espkey init failed");
-	set_cipher_parameters(ctx, NULL, NULL, iv, 0);
+		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
@@ -249,7 +265,7 @@ int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
 	 * Copy the input data to the encrypted data buffer, and pad it
 	 * with zeroes.
 	 */
-	memcpy(input_buffer, buf, len);
+	memcpy(input_buffer, ct, len);
 	memset(input_buffer + len, 0, buffer_size - len);
 
 	/*
@@ -262,19 +278,31 @@ int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
 		(*ndo->ndo_error)(ndo, S_ERR_ND_MEM_ALLOC,
 			"can't allocate memory for decryption buffer");
 	}
-	EVP_Cipher(ctx, output_buffer, input_buffer, len);
+	if (!EVP_Cipher(ctx, output_buffer, input_buffer, len)) {
+		(*ndo->ndo_warning)(ndo, "EVP_Cipher failed");
+		return 0;
+	}
 	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.
+	 * Free the input buffer; we no longer need it.
 	 */
-	memcpy(buf, output_buffer, len);
 	free(input_buffer);
-	free(output_buffer);
 
-	ndo->ndo_packetp = buf;
-	ndo->ndo_snapend = end;
+	/*
+	 * 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;
 }
@@ -398,6 +426,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++;
@@ -679,15 +708,15 @@ esp_print(netdissect_options *ndo,
 	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;
+	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
@@ -695,16 +724,6 @@ esp_print(netdissect_options *ndo,
 	ndo->ndo_protocol = "esp";
 	esp = (const struct newesp *)bp;
 
-#ifdef HAVE_LIBCRYPTO
-	secret = NULL;
-	advance = 0;
-#endif
-
-#if 0
-	/* keep secret out of a register */
-	p = (u_char *)&secret;
-#endif
-
 	/* 'ep' points to the end of available data. */
 	ep = ndo->ndo_snapend;
 
@@ -737,7 +756,6 @@ esp_print(netdissect_options *ndo,
 			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) + GET_BE_U_2(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) {
@@ -753,7 +771,6 @@ esp_print(netdissect_options *ndo,
 		/* nexthdr & padding are in the last fragment */
 		if (fragmented)
 			return;
-		len = GET_BE_U_2(ip->ip_len);
 
 		/* see if we can find the SA, and if so, decode it */
 		for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
@@ -779,30 +796,54 @@ esp_print(netdissect_options *ndo,
 	if (sa == NULL)
 		return;
 
-	/* if we can't get nexthdr, we do not need to decrypt it */
-	if (ep - bp2 < len)
-		return;
-	if (ep - bp2 > len) {
-		/* FCS included at end of frame (NetBSD 1.6 or later) */
-		ep = bp2 + len;
-	}
-
 	/* 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 and, if
-	 * not, slice that off.
+	 * 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 - bp < sa->authlen)
+	if (ep - ct < sa->authlen) {
+		nd_print_trunc(ndo);
 		return;
+	}
 	ep = ep - sa->authlen;
 
+	/*
+	 * 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;
+
 	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) {
 		/*
@@ -816,12 +857,15 @@ esp_print(netdissect_options *ndo,
 			"esp_print: can't allocate memory for cipher context");
 	}
 
-	if (set_cipher_parameters(ctx, sa->evp, secret, NULL, 0) < 0)
+	if (set_cipher_parameters(ctx, sa->evp, sa->secret, NULL, 0) < 0) {
 		(*ndo->ndo_warning)(ndo, "espkey init failed");
+		return;
+	}
 
-	p = ivoff;
-	set_cipher_parameters(ctx, NULL, NULL, p, 0);
-	len = ep - (p + ivlen);
+	if (set_cipher_parameters(ctx, NULL, NULL, iv, 0) < 0) {
+		(*ndo->ndo_warning)(ndo, "IV init failed");
+		return;
+	}
 
 	/*
 	 * Allocate buffers for the encrypted and decrypted
@@ -830,7 +874,7 @@ esp_print(netdissect_options *ndo,
 	 * be separate from the input buffer.
 	 */
 	block_size = (unsigned int)EVP_CIPHER_CTX_block_size(ctx);
-	buffer_size = len + (block_size - len % block_size);
+	buffer_size = ctlen + (block_size - ctlen % block_size);
 
 	/*
 	 * Attempt to allocate the input buffer.
@@ -845,8 +889,8 @@ esp_print(netdissect_options *ndo,
 	 * Copy the input data to the encrypted data buffer,
 	 * and pad it with zeroes.
 	 */
-	memcpy(input_buffer, p + ivlen, len);
-	memset(input_buffer + len, 0, buffer_size - len);
+	memcpy(input_buffer, ct, ctlen);
+	memset(input_buffer + ctlen, 0, buffer_size - ctlen);
 
 	/*
 	 * Attempt to allocate the output buffer.
@@ -859,53 +903,62 @@ esp_print(netdissect_options *ndo,
 			"esp_print: can't allocate memory for decryption buffer");
 	}
 
-	EVP_Cipher(ctx, output_buffer, input_buffer, len);
+	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);
+
 	/*
-	 * XXX - of course this is wrong, because buf is a
-	 * const buffer, but changing this would require a
-	 * more complicated fix.
+	 * Pointer to the plaintext.
 	 */
-	memcpy(p + ivlen, output_buffer, len);
-	free(output_buffer);
-	advance = ivoff - (const u_char *)esp + ivlen;
+	pt = output_buffer;
 
 	/*
-	 * Sanity check for pad length.
-	 *
-	 * 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.
+	 * Length of the plaintext, which is the same as the length
+	 * of the ciphertext.
 	 */
-	padlen = GET_U_1(ep - 2);
-	if (ep - bp < padlen) {
-		nd_print_trunc(ndo);
-		return;
+	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 payload length; +2 is for the pad length
-	 * and next header fields.
+	 * 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.
 	 */
-	if (length <= advance + padlen + 2) {
+	padlen = GET_U_1(ep - 2);
+	if (padlen + 2 > ptlen) {
 		nd_print_trunc(ndo);
 		return;
 	}
-	bp += advance;
-	length -= advance + padlen + 2;
 
 	/* Get the next header */
 	nh = GET_U_1(ep - 1);
 
 	ND_PRINT(": ");
 
-	/* Now print the payload. */
-	ip_print_demux(ndo, bp, length, ver, fragmented, ttl_hl, nh, bp2);
+	/* 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