contrib/tcpdump/print-esp.c

   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 #ifndef lint
  25 static const char rcsid[] _U_ =
  26     "@(#) $Header: /tcpdump/master/tcpdump/print-esp.c,v 1.55.2.1 2005/04/21 06:44:57 guy Exp $ (LBL)";
  27 #endif
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <string.h>
  34
  35 #include <tcpdump-stdinc.h>
  36
  37 #include <stdlib.h>
  38
  39 #ifdef HAVE_LIBCRYPTO
  40 #ifdef HAVE_OPENSSL_EVP_H
  41 #include <openssl/evp.h>
  42 #endif
  43 #endif
  44
  45 #include <stdio.h>
  46
  47 #include "ip.h"
  48 #include "esp.h"
  49 #ifdef INET6
  50 #include "ip6.h"
  51 #endif
  52
  53 #include "netdissect.h"
  54 #include "addrtoname.h"
  55 #include "extract.h"
  56
  57 #ifndef HAVE_SOCKADDR_STORAGE
  58 #ifdef INET6
  59 struct sockaddr_storage {
  60         union {
  61                 struct sockaddr_in sin;
  62                 struct sockaddr_in6 sin6;
  63         } un;
  64 };
  65 #else
  66 #define sockaddr_storage sockaddr
  67 #endif
  68 #endif /* HAVE_SOCKADDR_STORAGE */
  69
  70 #ifdef HAVE_LIBCRYPTO
  71 struct sa_list {
  72         struct sa_list  *next;
  73         struct sockaddr_storage daddr;
  74         u_int32_t       spi;
  75         const EVP_CIPHER *evp;
  76         int             ivlen;
  77         int             authlen;
  78         u_char          secret[256];  /* is that big enough for all secrets? */
  79         int             secretlen;
  80 };
  81
  82 static void esp_print_addsa(netdissect_options *ndo,
  83                             struct sa_list *sa, int sa_def)
  84 {
  85         /* copy the "sa" */
  86
  87         struct sa_list *nsa;
  88
  89         nsa = (struct sa_list *)malloc(sizeof(struct sa_list));
  90         if (nsa == NULL)
  91                 (*ndo->ndo_error)(ndo, "ran out of memory to allocate sa structure");
  92
  93         *nsa = *sa;
  94
  95         if (sa_def)
  96                 ndo->ndo_sa_default = nsa;
  97
  98         nsa->next = ndo->ndo_sa_list_head;
  99         ndo->ndo_sa_list_head = nsa;
 100 }
 101
 102
 103 static u_int hexdigit(netdissect_options *ndo, char hex)
 104 {
 105         if (hex >= '0' && hex <= '9')
 106                 return (hex - '0');
 107         else if (hex >= 'A' && hex <= 'F')
 108                 return (hex - 'A' + 10);
 109         else if (hex >= 'a' && hex <= 'f')
 110                 return (hex - 'a' + 10);
 111         else {
 112                 (*ndo->ndo_error)(ndo, "invalid hex digit %c in espsecret\n", hex);
 113                 return 0;
 114         }
 115 }
 116
 117 static u_int hex2byte(netdissect_options *ndo, char *hexstring)
 118 {
 119         u_int byte;
 120
 121         byte = (hexdigit(ndo, hexstring[0]) << 4) + hexdigit(ndo, hexstring[1]);
 122         return byte;
 123 }
 124
 125 /*
 126  * decode the form:    SPINUM@IP <tab> ALGONAME:0xsecret
 127  *
 128  * special form: file /name
 129  * causes us to go read from this file instead.
 130  *
 131  */
 132 static void esp_print_decode_onesecret(netdissect_options *ndo, char *line)
 133 {
 134         struct sa_list sa1;
 135         int sa_def;
 136
 137         char *spikey;
 138         char *decode;
 139
 140         spikey = strsep(&line, " \t");
 141         sa_def = 0;
 142         memset(&sa1, 0, sizeof(struct sa_list));
 143
 144         /* if there is only one token, then it is an algo:key token */
 145         if (line == NULL) {
 146                 decode = spikey;
 147                 spikey = NULL;
 148                 /* memset(&sa1.daddr, 0, sizeof(sa1.daddr)); */
 149                 /* sa1.spi = 0; */
 150                 sa_def    = 1;
 151         } else
 152                 decode = line;
 153
 154         if (spikey && strcasecmp(spikey, "file") == 0) {
 155                 /* open file and read it */
 156                 FILE *secretfile;
 157                 char  fileline[1024];
 158                 char  *nl;
 159
 160                 secretfile = fopen(line, FOPEN_READ_TXT);
 161                 if (secretfile == NULL) {
 162                         perror(line);
 163                         exit(3);
 164                 }
 165
 166                 while (fgets(fileline, sizeof(fileline)-1, secretfile) != NULL) {
 167                         /* remove newline from the line */
 168                         nl = strchr(fileline, '\n');
 169                         if (nl)
 170                                 *nl = '\0';
 171                         if (fileline[0] == '#') continue;
 172                         if (fileline[0] == '\0') continue;
 173
 174                         esp_print_decode_onesecret(ndo, fileline);
 175                 }
 176                 fclose(secretfile);
 177
 178                 return;
 179         }
 180
 181         if (spikey) {
 182                 char *spistr, *foo;
 183                 u_int32_t spino;
 184                 struct sockaddr_in *sin;
 185 #ifdef INET6
 186                 struct sockaddr_in6 *sin6;
 187 #endif
 188
 189                 spistr = strsep(&spikey, "@");
 190
 191                 spino = strtoul(spistr, &foo, 0);
 192                 if (spistr == foo || !spikey) {
 193                         (*ndo->ndo_warning)(ndo, "print_esp: failed to decode spi# %s\n", foo);
 194                         return;
 195                 }
 196
 197                 sa1.spi = spino;
 198
 199                 sin = (struct sockaddr_in *)&sa1.daddr;
 200 #ifdef INET6
 201                 sin6 = (struct sockaddr_in6 *)&sa1.daddr;
 202                 if (inet_pton(AF_INET6, spikey, &sin6->sin6_addr) == 1) {
 203 #ifdef HAVE_SOCKADDR_SA_LEN
 204                         sin6->sin6_len = sizeof(struct sockaddr_in6);
 205 #endif
 206                         sin6->sin6_family = AF_INET6;
 207                 } else
 208 #endif
 209                 if (inet_pton(AF_INET, spikey, &sin->sin_addr) == 1) {
 210 #ifdef HAVE_SOCKADDR_SA_LEN
 211                         sin->sin_len = sizeof(struct sockaddr_in);
 212 #endif
 213                         sin->sin_family = AF_INET;
 214                 } else {
 215                         (*ndo->ndo_warning)(ndo, "print_esp: can not decode IP# %s\n", spikey);
 216                         return;
 217                 }
 218         }
 219
 220         if (decode) {
 221                 char *colon, *p;
 222                 u_char espsecret_key[256];
 223                 int len;
 224                 size_t i;
 225                 const EVP_CIPHER *evp;
 226                 int authlen = 0;
 227
 228                 /* skip any blank spaces */
 229                 while (isspace((unsigned char)*decode))
 230                         decode++;
 231
 232                 colon = strchr(decode, ':');
 233                 if (colon == NULL) {
 234                         (*ndo->ndo_warning)(ndo, "failed to decode espsecret: %s\n", decode);
 235                         return;
 236                 }
 237                 *colon = '\0';
 238
 239                 len = colon - decode;
 240                 if (strlen(decode) > strlen("-hmac96") &&
 241                     !strcmp(decode + strlen(decode) - strlen("-hmac96"),
 242                     "-hmac96")) {
 243                         p = strstr(decode, "-hmac96");
 244                         *p = '\0';
 245                         authlen = 12;
 246                 }
 247                 if (strlen(decode) > strlen("-cbc") &&
 248                     !strcmp(decode + strlen(decode) - strlen("-cbc"), "-cbc")) {
 249                         p = strstr(decode, "-cbc");
 250                         *p = '\0';
 251                 }
 252                 evp = EVP_get_cipherbyname(decode);
 253                 if (!evp) {
 254                         (*ndo->ndo_warning)(ndo, "failed to find cipher algo %s\n", decode);
 255                         sa1.evp = NULL;
 256                         sa1.authlen = 0;
 257                         sa1.ivlen = 0;
 258                         return;
 259                 }
 260
 261                 sa1.evp = evp;
 262                 sa1.authlen = authlen;
 263                 sa1.ivlen = EVP_CIPHER_iv_length(evp);
 264
 265                 colon++;
 266                 if (colon[0] == '0' && colon[1] == 'x') {
 267                         /* decode some hex! */
 268                         colon += 2;
 269                         len = strlen(colon) / 2;
 270
 271                         if (len > 256) {
 272                                 (*ndo->ndo_warning)(ndo, "secret is too big: %d\n", len);
 273                                 return;
 274                         }
 275
 276                         i = 0;
 277                         while (colon[0] != '\0' && colon[1]!='\0') {
 278                                 espsecret_key[i] = hex2byte(ndo, colon);
 279                                 colon += 2;
 280                                 i++;
 281                         }
 282
 283                         memcpy(sa1.secret, espsecret_key, i);
 284                         sa1.secretlen = i;
 285                 } else {
 286                         i = strlen(colon);
 287
 288                         if (i < sizeof(sa1.secret)) {
 289                                 memcpy(sa1.secret, colon, i);
 290                                 sa1.secretlen = i;
 291                         } else {
 292                                 memcpy(sa1.secret, colon, sizeof(sa1.secret));
 293                                 sa1.secretlen = sizeof(sa1.secret);
 294                         }
 295                 }
 296         }
 297
 298         esp_print_addsa(ndo, &sa1, sa_def);
 299 }
 300
 301 static void esp_print_decodesecret(netdissect_options *ndo)
 302 {
 303         char *line;
 304         char *p;
 305
 306         p = ndo->ndo_espsecret;
 307
 308         while (ndo->ndo_espsecret && ndo->ndo_espsecret[0] != '\0') {
 309                 /* pick out the first line or first thing until a comma */
 310                 if ((line = strsep(&ndo->ndo_espsecret, "\n,")) == NULL) {
 311                         line = ndo->ndo_espsecret;
 312                         ndo->ndo_espsecret = NULL;
 313                 }
 314
 315                 esp_print_decode_onesecret(ndo, line);
 316         }
 317 }
 318
 319 static void esp_init(netdissect_options *ndo _U_)
 320 {
 321
 322         OpenSSL_add_all_algorithms();
 323         EVP_add_cipher_alias(SN_des_ede3_cbc, "3des");
 324 }
 325 #endif
 326
 327 int
 328 esp_print(netdissect_options *ndo,
 329           const u_char *bp, const int length, const u_char *bp2
 330 #ifndef HAVE_LIBCRYPTO
 331         _U_
 332 #endif
 333         ,
 334         int *nhdr
 335 #ifndef HAVE_LIBCRYPTO
 336         _U_
 337 #endif
 338         ,
 339         int *padlen
 340 #ifndef HAVE_LIBCRYPTO
 341         _U_
 342 #endif
 343         )
 344 {
 345         register const struct newesp *esp;
 346         register const u_char *ep;
 347 #ifdef HAVE_LIBCRYPTO
 348         struct ip *ip;
 349         struct sa_list *sa = NULL;
 350         int espsecret_keylen;
 351 #ifdef INET6
 352         struct ip6_hdr *ip6 = NULL;
 353 #endif
 354         int advance;
 355         int len;
 356         u_char *secret;
 357         int ivlen = 0;
 358         u_char *ivoff;
 359         u_char *p;
 360         EVP_CIPHER_CTX ctx;
 361         int blocksz;
 362         static int initialized = 0;
 363 #endif
 364
 365         esp = (struct newesp *)bp;
 366
 367 #ifdef HAVE_LIBCRYPTO
 368         secret = NULL;
 369         advance = 0;
 370
 371         if (!initialized) {
 372                 esp_init(ndo);
 373                 initialized = 1;
 374         }
 375 #endif
 376
 377 #if 0
 378         /* keep secret out of a register */
 379         p = (u_char *)&secret;
 380 #endif
 381
 382         /* 'ep' points to the end of available data. */
 383         ep = ndo->ndo_snapend;
 384
 385         if ((u_char *)(esp + 1) >= ep) {
 386                 fputs("[|ESP]", stdout);
 387                 goto fail;
 388         }
 389         (*ndo->ndo_printf)(ndo, "ESP(spi=0x%08x", EXTRACT_32BITS(&esp->esp_spi));
 390         (*ndo->ndo_printf)(ndo, ",seq=0x%x)", EXTRACT_32BITS(&esp->esp_seq));
 391         (*ndo->ndo_printf)(ndo, ", length %u", length);
 392
 393 #ifndef HAVE_LIBCRYPTO
 394         goto fail;
 395 #else
 396         /* initiailize SAs */
 397         if (ndo->ndo_sa_list_head == NULL) {
 398                 if (!ndo->ndo_espsecret)
 399                         goto fail;
 400
 401                 esp_print_decodesecret(ndo);
 402         }
 403
 404         if (ndo->ndo_sa_list_head == NULL)
 405                 goto fail;
 406
 407         ip = (struct ip *)bp2;
 408         switch (IP_V(ip)) {
 409 #ifdef INET6
 410         case 6:
 411                 ip6 = (struct ip6_hdr *)bp2;
 412                 /* we do not attempt to decrypt jumbograms */
 413                 if (!EXTRACT_16BITS(&ip6->ip6_plen))
 414                         goto fail;
 415                 /* if we can't get nexthdr, we do not need to decrypt it */
 416                 len = sizeof(struct ip6_hdr) + EXTRACT_16BITS(&ip6->ip6_plen);
 417
 418                 /* see if we can find the SA, and if so, decode it */
 419                 for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
 420                         struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&sa->daddr;
 421                         if (sa->spi == ntohl(esp->esp_spi) &&
 422                             sin6->sin6_family == AF_INET6 &&
 423                             memcmp(&sin6->sin6_addr, &ip6->ip6_dst,
 424                                    sizeof(struct in6_addr)) == 0) {
 425                                 break;
 426                         }
 427                 }
 428                 break;
 429 #endif /*INET6*/
 430         case 4:
 431                 /* nexthdr & padding are in the last fragment */
 432                 if (EXTRACT_16BITS(&ip->ip_off) & IP_MF)
 433                         goto fail;
 434                 len = EXTRACT_16BITS(&ip->ip_len);
 435
 436                 /* see if we can find the SA, and if so, decode it */
 437                 for (sa = ndo->ndo_sa_list_head; sa != NULL; sa = sa->next) {
 438                         struct sockaddr_in *sin = (struct sockaddr_in *)&sa->daddr;
 439                         if (sa->spi == ntohl(esp->esp_spi) &&
 440                             sin->sin_family == AF_INET &&
 441                             sin->sin_addr.s_addr == ip->ip_dst.s_addr) {
 442                                 break;
 443                         }
 444                 }
 445                 break;
 446         default:
 447                 goto fail;
 448         }
 449
 450         /* if we didn't find the specific one, then look for
 451          * an unspecified one.
 452          */
 453         if (sa == NULL)
 454                 sa = ndo->ndo_sa_default;
 455
 456         /* if not found fail */
 457         if (sa == NULL)
 458                 goto fail;
 459
 460         /* if we can't get nexthdr, we do not need to decrypt it */
 461         if (ep - bp2 < len)
 462                 goto fail;
 463         if (ep - bp2 > len) {
 464                 /* FCS included at end of frame (NetBSD 1.6 or later) */
 465                 ep = bp2 + len;
 466         }
 467
 468         ivoff = (u_char *)(esp + 1) + 0;
 469         ivlen = sa->ivlen;
 470         secret = sa->secret;
 471         espsecret_keylen = sa->secretlen;
 472         ep = ep - sa->authlen;
 473
 474         if (sa->evp) {
 475                 memset(&ctx, 0, sizeof(ctx));
 476                 if (EVP_CipherInit(&ctx, sa->evp, secret, NULL, 0) < 0)
 477                         (*ndo->ndo_warning)(ndo, "espkey init failed");
 478
 479                 blocksz = EVP_CIPHER_CTX_block_size(&ctx);
 480
 481                 p = ivoff;
 482                 EVP_CipherInit(&ctx, NULL, NULL, p, 0);
 483                 EVP_Cipher(&ctx, p + ivlen, p + ivlen, ep - (p + ivlen));
 484                 advance = ivoff - (u_char *)esp + ivlen;
 485         } else
 486                 advance = sizeof(struct newesp);
 487
 488         /* sanity check for pad length */
 489         if (ep - bp < *(ep - 2))
 490                 goto fail;
 491
 492         if (padlen)
 493                 *padlen = *(ep - 2) + 2;
 494
 495         if (nhdr)
 496                 *nhdr = *(ep - 1);
 497
 498         (ndo->ndo_printf)(ndo, ": ");
 499         return advance;
 500 #endif
 501
 502 fail:
 503         return -1;
 504 }
 505
 506 /*
 507  * Local Variables:
 508  * c-style: whitesmith
 509  * c-basic-offset: 8
 510  * End:
 511  */