/* \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"
*/
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 */
#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;
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;
{
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);
}
}
#endif
-#ifdef HAVE_EVP_CIPHERINIT_EX
+#ifdef HAVE_EVP_DECRYPTINIT_EX
/*
- * Initialize the cipher by calling EVP_CipherInit_ex(), because
- * calling EVP_CipherInit() will reset the cipher context, clearing
+ * 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_CipherInit_ex(),
+ * 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 oin a second call after a first call to EVP_CipherInit_ex()
+ * 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?
static int
set_cipher_parameters(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher,
const unsigned char *key,
- const unsigned char *iv, int enc)
+ const unsigned char *iv)
{
- return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, enc);
+ return EVP_DecryptInit_ex(ctx, cipher, NULL, key, iv);
}
#else
/*
- * Initialize the cipher by calling EVP_CipherInit(), because we don't
- * have EVP_CipherInit_ex(); we rely on it not trashing the context.
+ * 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, int enc)
+ const unsigned char *iv)
{
- return EVP_CipherInit(ctx, cipher, key, iv, enc);
+ 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 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,
+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;
*/
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;
- 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);
- /*
- * 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");
- EVP_CIPHER_CTX_free(ctx);
+ pt = do_decrypt(ndo, __func__, sa, iv,
+ ct, ctlen);
+ if (pt == NULL)
return 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;
}
-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');
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++;
}
* 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)
const EVP_CIPHER *evp;
int authlen = 0;
char *colon, *p;
+ const char *real_decode;
colon = strchr(decode, ':');
if (colon == NULL) {
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;
sa->evp = evp;
sa->authlen = authlen;
+ /* This returns an int, but it should never be negative */
sa->ivlen = EVP_CIPHER_iv_length(evp);
colon++;
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
}
*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;
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) {
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) {
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)) {
esp_print_addsa(ndo, &sa1, sa_def);
}
-USES_APPLE_DEPRECATED_API
+DIAG_OFF_DEPRECATION
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;
#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
- ,
- u_int *nhdr
-#ifndef HAVE_LIBCRYPTO
- _U_
+#define USED_IF_LIBCRYPTO
+#else
+#define USED_IF_LIBCRYPTO _U_
#endif
- ,
- u_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_BE_32BITS(&esp->esp_spi)));
- ND_PRINT((ndo, ",seq=0x%x)", EXTRACT_BE_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_BE_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_BE_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_BE_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_BE_16BITS(&ip->ip_off) & IP_MF)
- goto fail;
- len = EXTRACT_BE_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_BE_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
/* 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) {
- if (set_cipher_parameters(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;
+ */
+ payloadlen = ep - ct;
- p = ivoff;
- set_cipher_parameters(ctx, NULL, NULL, p, 0);
- len = ep - (p + ivlen);
+ if (sa->evp == NULL)
+ return;
- /*
- * 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");
- EVP_CIPHER_CTX_free(ctx);
- return -1;
- }
+ /*
+ * 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 < EXTRACT_8BITS(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 = EXTRACT_8BITS(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 = EXTRACT_8BITS(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:
- */
projects / tcpdump / blobdiff