xref: /freebsd/contrib/tcpdump/print-esp.c (revision 0b3105a37d7adcadcb720112fed4dc4e8040be99) 
1 /*	$NetBSD: print-ah.c,v 1.4 1996/05/20 00:41:16 fvdl Exp $	*/
2 
3 /*
4  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that: (1) source code distributions
9  * retain the above copyright notice and this paragraph in its entirety, (2)
10  * distributions including binary code include the above copyright notice and
11  * this paragraph in its entirety in the documentation or other materials
12  * provided with the distribution, and (3) all advertising materials mentioning
13  * features or use of this software display the following acknowledgement:
14  * ``This product includes software developed by the University of California,
15  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
16  * the University nor the names of its contributors may be used to endorse
17  * or promote products derived from this software without specific prior
18  * written permission.
19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22  */
23 
24 #define NETDISSECT_REWORKED
25 #ifdef HAVE_CONFIG_H
26 #include "config.h"
27 #endif
28 
29 #include <tcpdump-stdinc.h>
30 
31 #include <string.h>
32 #include <stdlib.h>
33 
34 /* Any code in this file that depends on HAVE_LIBCRYPTO depends on
35  * HAVE_OPENSSL_EVP_H too. Undefining the former when the latter isn't defined
36  * is the simplest way of handling the dependency.
37  */
38 #ifdef HAVE_LIBCRYPTO
39 #ifdef HAVE_OPENSSL_EVP_H
40 #include <openssl/evp.h>
41 #else
42 #undef HAVE_LIBCRYPTO
43 #endif
44 #endif
45 
46 #include "ip.h"
47 #ifdef INET6
48 #include "ip6.h"
49 #endif
50 
51 #include "interface.h"
52 #include "extract.h"
53 
54 /*
55  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
56  * All rights reserved.
57  *
58  * Redistribution and use in source and binary forms, with or without
59  * modification, are permitted provided that the following conditions
60  * are met:
61  * 1. Redistributions of source code must retain the above copyright
62  *    notice, this list of conditions and the following disclaimer.
63  * 2. Redistributions in binary form must reproduce the above copyright
64  *    notice, this list of conditions and the following disclaimer in the
65  *    documentation and/or other materials provided with the distribution.
66  * 3. Neither the name of the project nor the names of its contributors
67  *    may be used to endorse or promote products derived from this software
68  *    without specific prior written permission.
69  *
70  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
71  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
72  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
73  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
74  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
75  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
76  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
77  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
78  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
79  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
80  * SUCH DAMAGE.
81  */
82 
83 /*
84  * RFC1827/2406 Encapsulated Security Payload.
85  */
86 
87 struct newesp {
88 	uint32_t	esp_spi;	/* ESP */
89 	uint32_t	esp_seq;	/* Sequence number */
90 	/*variable size*/		/* (IV and) Payload data */
91 	/*variable size*/		/* padding */
92 	/*8bit*/			/* pad size */
93 	/*8bit*/			/* next header */
94 	/*8bit*/			/* next header */
95 	/*variable size, 32bit bound*/	/* Authentication data */
96 };
97 
98 #ifdef HAVE_LIBCRYPTO
99 union inaddr_u {
100 	struct in_addr in4;
101 #ifdef INET6
102 	struct in6_addr in6;
103 #endif
104 };
105 struct sa_list {
106 	struct sa_list	*next;
107 	u_int		daddr_version;
108 	union inaddr_u	daddr;
109 	uint32_t	spi;          /* if == 0, then IKEv2 */
110 	int             initiator;
111 	u_char          spii[8];      /* for IKEv2 */
112 	u_char          spir[8];
113 	const EVP_CIPHER *evp;
114 	int		ivlen;
115 	int		authlen;
116 	u_char          authsecret[256];
117 	int             authsecret_len;
118 	u_char		secret[256];  /* is that big enough for all secrets? */
119 	int		secretlen;
120 };
121 
122 /*
123  * this will adjust ndo_packetp and ndo_snapend to new buffer!
124  */
125 USES_APPLE_DEPRECATED_API
126 int esp_print_decrypt_buffer_by_ikev2(netdissect_options *ndo,
127 				      int initiator,
128 				      u_char spii[8], u_char spir[8],
129 				      u_char *buf, u_char *end)
130 {
131 	struct sa_list *sa;
132 	u_char *iv;
133 	int len;
134 	EVP_CIPHER_CTX ctx;
135 
136 	/* initiator arg is any non-zero value */
137 	if(initiator) initiator=1;
138 
139 	/* see if we can find the SA, and if so, decode it */
140 	for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
141 		if (sa->spi == 0
142 		    && initiator == sa->initiator
143 		    && memcmp(spii, sa->spii, 8) == 0
144 		    && memcmp(spir, sa->spir, 8) == 0)
145 			break;
146 	}
147 
148 	if(sa == NULL) return 0;
149 	if(sa->evp == NULL) return 0;
150 
151 	/*
152 	 * remove authenticator, and see if we still have something to
153 	 * work with
154 	 */
155 	end = end - sa->authlen;
156 	iv  = buf;
157 	buf = buf + sa->ivlen;
158 	len = end-buf;
159 
160 	if(end <= buf) return 0;
161 
162 	memset(&ctx, 0, sizeof(ctx));
163 	if (EVP_CipherInit(&ctx, sa->evp, sa->secret, NULL, 0) < 0)
164 		(*ndo->ndo_warning)(ndo, "espkey init failed");
165 	EVP_CipherInit(&ctx, NULL, NULL, iv, 0);
166 	EVP_Cipher(&ctx, buf, buf, len);
167 	EVP_CIPHER_CTX_cleanup(&ctx);
168 
169 	ndo->ndo_packetp = buf;
170 	ndo->ndo_snapend = end;
171 
172 	return 1;
173 
174 }
175 USES_APPLE_RST
176 
177 static void esp_print_addsa(netdissect_options *ndo,
178 			    struct sa_list *sa, int sa_def)
179 {
180 	/* copy the "sa" */
181 
182 	struct sa_list *nsa;
183 
184 	nsa = (struct sa_list *)malloc(sizeof(struct sa_list));
185 	if (nsa == NULL)
186 		(*ndo->ndo_error)(ndo, "ran out of memory to allocate sa structure");
187 
188 	*nsa = *sa;
189 
190 	if (sa_def)
191 		ndo->ndo_sa_default = nsa;
192 
193 	nsa->next = ndo->ndo_sa_list_head;
194 	ndo->ndo_sa_list_head = nsa;
195 }
196 
197 
198 static u_int hexdigit(netdissect_options *ndo, char hex)
199 {
200 	if (hex >= '0' && hex <= '9')
201 		return (hex - '0');
202 	else if (hex >= 'A' && hex <= 'F')
203 		return (hex - 'A' + 10);
204 	else if (hex >= 'a' && hex <= 'f')
205 		return (hex - 'a' + 10);
206 	else {
207 		(*ndo->ndo_error)(ndo, "invalid hex digit %c in espsecret\n", hex);
208 		return 0;
209 	}
210 }
211 
212 static u_int hex2byte(netdissect_options *ndo, char *hexstring)
213 {
214 	u_int byte;
215 
216 	byte = (hexdigit(ndo, hexstring[0]) << 4) + hexdigit(ndo, hexstring[1]);
217 	return byte;
218 }
219 
220 /*
221  * returns size of binary, 0 on failure.
222  */
223 static
224 int espprint_decode_hex(netdissect_options *ndo,
225 			u_char *binbuf, unsigned int binbuf_len,
226 			char *hex)
227 {
228 	unsigned int len;
229 	int i;
230 
231 	len = strlen(hex) / 2;
232 
233 	if (len > binbuf_len) {
234 		(*ndo->ndo_warning)(ndo, "secret is too big: %d\n", len);
235 		return 0;
236 	}
237 
238 	i = 0;
239 	while (hex[0] != '\0' && hex[1]!='\0') {
240 		binbuf[i] = hex2byte(ndo, hex);
241 		hex += 2;
242 		i++;
243 	}
244 
245 	return i;
246 }
247 
248 /*
249  * decode the form:    SPINUM@IP <tab> ALGONAME:0xsecret
250  */
251 
252 USES_APPLE_DEPRECATED_API
253 static int
254 espprint_decode_encalgo(netdissect_options *ndo,
255 			char *decode, struct sa_list *sa)
256 {
257 	size_t i;
258 	const EVP_CIPHER *evp;
259 	int authlen = 0;
260 	char *colon, *p;
261 
262 	colon = strchr(decode, ':');
263 	if (colon == NULL) {
264 		(*ndo->ndo_warning)(ndo, "failed to decode espsecret: %s\n", decode);
265 		return 0;
266 	}
267 	*colon = '\0';
268 
269 	if (strlen(decode) > strlen("-hmac96") &&
270 	    !strcmp(decode + strlen(decode) - strlen("-hmac96"),
271 		    "-hmac96")) {
272 		p = strstr(decode, "-hmac96");
273 		*p = '\0';
274 		authlen = 12;
275 	}
276 	if (strlen(decode) > strlen("-cbc") &&
277 	    !strcmp(decode + strlen(decode) - strlen("-cbc"), "-cbc")) {
278 		p = strstr(decode, "-cbc");
279 		*p = '\0';
280 	}
281 	evp = EVP_get_cipherbyname(decode);
282 
283 	if (!evp) {
284 		(*ndo->ndo_warning)(ndo, "failed to find cipher algo %s\n", decode);
285 		sa->evp = NULL;
286 		sa->authlen = 0;
287 		sa->ivlen = 0;
288 		return 0;
289 	}
290 
291 	sa->evp = evp;
292 	sa->authlen = authlen;
293 	sa->ivlen = EVP_CIPHER_iv_length(evp);
294 
295 	colon++;
296 	if (colon[0] == '0' && colon[1] == 'x') {
297 		/* decode some hex! */
298 
299 		colon += 2;
300 		sa->secretlen = espprint_decode_hex(ndo, sa->secret, sizeof(sa->secret), colon);
301 		if(sa->secretlen == 0) return 0;
302 	} else {
303 		i = strlen(colon);
304 
305 		if (i < sizeof(sa->secret)) {
306 			memcpy(sa->secret, colon, i);
307 			sa->secretlen = i;
308 		} else {
309 			memcpy(sa->secret, colon, sizeof(sa->secret));
310 			sa->secretlen = sizeof(sa->secret);
311 		}
312 	}
313 
314 	return 1;
315 }
316 USES_APPLE_RST
317 
318 /*
319  * for the moment, ignore the auth algorith, just hard code the authenticator
320  * length. Need to research how openssl looks up HMAC stuff.
321  */
322 static int
323 espprint_decode_authalgo(netdissect_options *ndo,
324 			 char *decode, struct sa_list *sa)
325 {
326 	char *colon;
327 
328 	colon = strchr(decode, ':');
329 	if (colon == NULL) {
330 		(*ndo->ndo_warning)(ndo, "failed to decode espsecret: %s\n", decode);
331 		return 0;
332 	}
333 	*colon = '\0';
334 
335 	if(strcasecmp(colon,"sha1") == 0 ||
336 	   strcasecmp(colon,"md5") == 0) {
337 		sa->authlen = 12;
338 	}
339 	return 1;
340 }
341 
342 static void esp_print_decode_ikeline(netdissect_options *ndo, char *line,
343 				     const char *file, int lineno)
344 {
345 	/* it's an IKEv2 secret, store it instead */
346 	struct sa_list sa1;
347 
348 	char *init;
349 	char *icookie, *rcookie;
350 	int   ilen, rlen;
351 	char *authkey;
352 	char *enckey;
353 
354 	init = strsep(&line, " \t");
355 	icookie = strsep(&line, " \t");
356 	rcookie = strsep(&line, " \t");
357 	authkey = strsep(&line, " \t");
358 	enckey  = strsep(&line, " \t");
359 
360 	/* if any fields are missing */
361 	if(!init || !icookie || !rcookie || !authkey || !enckey) {
362 		(*ndo->ndo_warning)(ndo, "print_esp: failed to find all fields for ikev2 at %s:%u",
363 				    file, lineno);
364 
365 		return;
366 	}
367 
368 	ilen = strlen(icookie);
369 	rlen = strlen(rcookie);
370 
371 	if((init[0]!='I' && init[0]!='R')
372 	   || icookie[0]!='0' || icookie[1]!='x'
373 	   || rcookie[0]!='0' || rcookie[1]!='x'
374 	   || ilen!=18
375 	   || rlen!=18) {
376 		(*ndo->ndo_warning)(ndo, "print_esp: line %s:%u improperly formatted.",
377 				    file, lineno);
378 
379 		(*ndo->ndo_warning)(ndo, "init=%s icookie=%s(%u) rcookie=%s(%u)",
380 				    init, icookie, ilen, rcookie, rlen);
381 
382 		return;
383 	}
384 
385 	sa1.spi = 0;
386 	sa1.initiator = (init[0] == 'I');
387 	if(espprint_decode_hex(ndo, sa1.spii, sizeof(sa1.spii), icookie+2)!=8)
388 		return;
389 
390 	if(espprint_decode_hex(ndo, sa1.spir, sizeof(sa1.spir), rcookie+2)!=8)
391 		return;
392 
393 	if(!espprint_decode_encalgo(ndo, enckey, &sa1)) return;
394 
395 	if(!espprint_decode_authalgo(ndo, authkey, &sa1)) return;
396 
397 	esp_print_addsa(ndo, &sa1, FALSE);
398 }
399 
400 /*
401  *
402  * special form: file /name
403  * causes us to go read from this file instead.
404  *
405  */
406 static void esp_print_decode_onesecret(netdissect_options *ndo, char *line,
407 				       const char *file, int lineno)
408 {
409 	struct sa_list sa1;
410 	int sa_def;
411 
412 	char *spikey;
413 	char *decode;
414 
415 	spikey = strsep(&line, " \t");
416 	sa_def = 0;
417 	memset(&sa1, 0, sizeof(struct sa_list));
418 
419 	/* if there is only one token, then it is an algo:key token */
420 	if (line == NULL) {
421 		decode = spikey;
422 		spikey = NULL;
423 		/* sa1.daddr.version = 0; */
424 		/* memset(&sa1.daddr, 0, sizeof(sa1.daddr)); */
425 		/* sa1.spi = 0; */
426 		sa_def    = 1;
427 	} else
428 		decode = line;
429 
430 	if (spikey && strcasecmp(spikey, "file") == 0) {
431 		/* open file and read it */
432 		FILE *secretfile;
433 		char  fileline[1024];
434 		int   lineno=0;
435 		char  *nl;
436 		char *filename = line;
437 
438 		secretfile = fopen(filename, FOPEN_READ_TXT);
439 		if (secretfile == NULL) {
440 			perror(filename);
441 			exit(3);
442 		}
443 
444 		while (fgets(fileline, sizeof(fileline)-1, secretfile) != NULL) {
445 			lineno++;
446 			/* remove newline from the line */
447 			nl = strchr(fileline, '\n');
448 			if (nl)
449 				*nl = '\0';
450 			if (fileline[0] == '#') continue;
451 			if (fileline[0] == '\0') continue;
452 
453 			esp_print_decode_onesecret(ndo, fileline, filename, lineno);
454 		}
455 		fclose(secretfile);
456 
457 		return;
458 	}
459 
460 	if (spikey && strcasecmp(spikey, "ikev2") == 0) {
461 		esp_print_decode_ikeline(ndo, line, file, lineno);
462 		return;
463 	}
464 
465 	if (spikey) {
466 
467 		char *spistr, *foo;
468 		uint32_t spino;
469 
470 		spistr = strsep(&spikey, "@");
471 
472 		spino = strtoul(spistr, &foo, 0);
473 		if (spistr == foo || !spikey) {
474 			(*ndo->ndo_warning)(ndo, "print_esp: failed to decode spi# %s\n", foo);
475 			return;
476 		}
477 
478 		sa1.spi = spino;
479 
480 #ifdef INET6
481 		if (inet_pton(AF_INET6, spikey, &sa1.daddr.in6) == 1) {
482 			sa1.daddr_version = 6;
483 		} else
484 #endif
485 			if (inet_pton(AF_INET, spikey, &sa1.daddr.in4) == 1) {
486 				sa1.daddr_version = 4;
487 			} else {
488 				(*ndo->ndo_warning)(ndo, "print_esp: can not decode IP# %s\n", spikey);
489 				return;
490 			}
491 	}
492 
493 	if (decode) {
494 		/* skip any blank spaces */
495 		while (isspace((unsigned char)*decode))
496 			decode++;
497 
498 		if(!espprint_decode_encalgo(ndo, decode, &sa1)) {
499 			return;
500 		}
501 	}
502 
503 	esp_print_addsa(ndo, &sa1, sa_def);
504 }
505 
506 USES_APPLE_DEPRECATED_API
507 static void esp_init(netdissect_options *ndo _U_)
508 {
509 
510 	OpenSSL_add_all_algorithms();
511 	EVP_add_cipher_alias(SN_des_ede3_cbc, "3des");
512 }
513 USES_APPLE_RST
514 
515 void esp_print_decodesecret(netdissect_options *ndo)
516 {
517 	char *line;
518 	char *p;
519 	static int initialized = 0;
520 
521 	if (!initialized) {
522 		esp_init(ndo);
523 		initialized = 1;
524 	}
525 
526 	p = ndo->ndo_espsecret;
527 
528 	while (p && p[0] != '\0') {
529 		/* pick out the first line or first thing until a comma */
530 		if ((line = strsep(&p, "\n,")) == NULL) {
531 			line = p;
532 			p = NULL;
533 		}
534 
535 		esp_print_decode_onesecret(ndo, line, "cmdline", 0);
536 	}
537 
538 	ndo->ndo_espsecret = NULL;
539 }
540 
541 #endif
542 
543 #ifdef HAVE_LIBCRYPTO
544 USES_APPLE_DEPRECATED_API
545 #endif
546 int
547 esp_print(netdissect_options *ndo,
548 	  const u_char *bp, const int length, const u_char *bp2
549 #ifndef HAVE_LIBCRYPTO
550 	_U_
551 #endif
552 	,
553 	int *nhdr
554 #ifndef HAVE_LIBCRYPTO
555 	_U_
556 #endif
557 	,
558 	int *padlen
559 #ifndef HAVE_LIBCRYPTO
560 	_U_
561 #endif
562 	)
563 {
564 	register const struct newesp *esp;
565 	register const u_char *ep;
566 #ifdef HAVE_LIBCRYPTO
567 	struct ip *ip;
568 	struct sa_list *sa = NULL;
569 #ifdef INET6
570 	struct ip6_hdr *ip6 = NULL;
571 #endif
572 	int advance;
573 	int len;
574 	u_char *secret;
575 	int ivlen = 0;
576 	u_char *ivoff;
577 	u_char *p;
578 	EVP_CIPHER_CTX ctx;
579 #endif
580 
581 	esp = (struct newesp *)bp;
582 
583 #ifdef HAVE_LIBCRYPTO
584 	secret = NULL;
585 	advance = 0;
586 #endif
587 
588 #if 0
589 	/* keep secret out of a register */
590 	p = (u_char *)&secret;
591 #endif
592 
593 	/* 'ep' points to the end of available data. */
594 	ep = ndo->ndo_snapend;
595 
596 	if ((u_char *)(esp + 1) >= ep) {
597 		ND_PRINT((ndo, "[|ESP]"));
598 		goto fail;
599 	}
600 	ND_PRINT((ndo, "ESP(spi=0x%08x", EXTRACT_32BITS(&esp->esp_spi)));
601 	ND_PRINT((ndo, ",seq=0x%x)", EXTRACT_32BITS(&esp->esp_seq)));
602 	ND_PRINT((ndo, ", length %u", length));
603 
604 #ifndef HAVE_LIBCRYPTO
605 	goto fail;
606 #else
607 	/* initiailize SAs */
608 	if (ndo->ndo_sa_list_head == NULL) {
609 		if (!ndo->ndo_espsecret)
610 			goto fail;
611 
612 		esp_print_decodesecret(ndo);
613 	}
614 
615 	if (ndo->ndo_sa_list_head == NULL)
616 		goto fail;
617 
618 	ip = (struct ip *)bp2;
619 	switch (IP_V(ip)) {
620 #ifdef INET6
621 	case 6:
622 		ip6 = (struct ip6_hdr *)bp2;
623 		/* we do not attempt to decrypt jumbograms */
624 		if (!EXTRACT_16BITS(&ip6->ip6_plen))
625 			goto fail;
626 		/* if we can't get nexthdr, we do not need to decrypt it */
627 		len = sizeof(struct ip6_hdr) + EXTRACT_16BITS(&ip6->ip6_plen);
628 
629 		/* see if we can find the SA, and if so, decode it */
630 		for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
631 			if (sa->spi == EXTRACT_32BITS(&esp->esp_spi) &&
632 			    sa->daddr_version == 6 &&
633 			    UNALIGNED_MEMCMP(&sa->daddr.in6, &ip6->ip6_dst,
634 				   sizeof(struct in6_addr)) == 0) {
635 				break;
636 			}
637 		}
638 		break;
639 #endif /*INET6*/
640 	case 4:
641 		/* nexthdr & padding are in the last fragment */
642 		if (EXTRACT_16BITS(&ip->ip_off) & IP_MF)
643 			goto fail;
644 		len = EXTRACT_16BITS(&ip->ip_len);
645 
646 		/* see if we can find the SA, and if so, decode it */
647 		for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
648 			if (sa->spi == EXTRACT_32BITS(&esp->esp_spi) &&
649 			    sa->daddr_version == 4 &&
650 			    UNALIGNED_MEMCMP(&sa->daddr.in4, &ip->ip_dst,
651 				   sizeof(struct in_addr)) == 0) {
652 				break;
653 			}
654 		}
655 		break;
656 	default:
657 		goto fail;
658 	}
659 
660 	/* if we didn't find the specific one, then look for
661 	 * an unspecified one.
662 	 */
663 	if (sa == NULL)
664 		sa = ndo->ndo_sa_default;
665 
666 	/* if not found fail */
667 	if (sa == NULL)
668 		goto fail;
669 
670 	/* if we can't get nexthdr, we do not need to decrypt it */
671 	if (ep - bp2 < len)
672 		goto fail;
673 	if (ep - bp2 > len) {
674 		/* FCS included at end of frame (NetBSD 1.6 or later) */
675 		ep = bp2 + len;
676 	}
677 
678 	ivoff = (u_char *)(esp + 1) + 0;
679 	ivlen = sa->ivlen;
680 	secret = sa->secret;
681 	ep = ep - sa->authlen;
682 
683 	if (sa->evp) {
684 		memset(&ctx, 0, sizeof(ctx));
685 		if (EVP_CipherInit(&ctx, sa->evp, secret, NULL, 0) < 0)
686 			(*ndo->ndo_warning)(ndo, "espkey init failed");
687 
688 		p = ivoff;
689 		EVP_CipherInit(&ctx, NULL, NULL, p, 0);
690 		EVP_Cipher(&ctx, p + ivlen, p + ivlen, ep - (p + ivlen));
691 		EVP_CIPHER_CTX_cleanup(&ctx);
692 		advance = ivoff - (u_char *)esp + ivlen;
693 	} else
694 		advance = sizeof(struct newesp);
695 
696 	/* sanity check for pad length */
697 	if (ep - bp < *(ep - 2))
698 		goto fail;
699 
700 	if (padlen)
701 		*padlen = *(ep - 2) + 2;
702 
703 	if (nhdr)
704 		*nhdr = *(ep - 1);
705 
706 	ND_PRINT((ndo, ": "));
707 	return advance;
708 #endif
709 
710 fail:
711 	return -1;
712 }
713 #ifdef HAVE_LIBCRYPTO
714 USES_APPLE_RST
715 #endif
716 
717 /*
718  * Local Variables:
719  * c-style: whitesmith
720  * c-basic-offset: 8
721  * End:
722  */
723