The Tcpdump Group git mirrors - tcpdump/blob - 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[] =
  26     "@(#) $Header: /tcpdump/master/tcpdump/print-esp.c,v 1.26 2002-07-27 19:30:36 guy Exp $ (LBL)";
  27 #endif
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <string.h>
  34 #include <sys/param.h>
  35 #include <sys/time.h>
  36 #include <sys/types.h>
  37 #include <sys/socket.h>
  38 #include <stdlib.h>
  39
  40 #include <netinet/in.h>
  41
  42 #ifdef HAVE_LIBCRYPTO
  43 #include <openssl/des.h>
  44 #include <openssl/blowfish.h>
  45 #ifdef HAVE_OPENSSL_RC5_H
  46 #include <openssl/rc5.h>
  47 #endif
  48 #ifdef HAVE_OPENSSL_CAST_H
  49 #include <openssl/cast.h>
  50 #endif
  51 #endif
  52
  53 #include <stdio.h>
  54
  55 #include "ip.h"
  56 #include "esp.h"
  57 #ifdef INET6
  58 #include "ip6.h"
  59 #endif
  60
  61 #define AVOID_CHURN 1
  62 #include "interface.h"
  63 #include "addrtoname.h"
  64
  65 static struct esp_algorithm *espsecret_xform=NULL;  /* cache of decoded alg. */
  66 static char                 *espsecret_key=NULL;
  67
  68
  69 enum cipher { NONE,
  70               DESCBC,
  71               BLOWFISH,
  72               RC5,
  73               CAST128,
  74               DES3CBC};
  75
  76
  77
  78 struct esp_algorithm {
  79         char        *name;
  80         enum  cipher algo;
  81         int          ivlen;
  82         int          authlen;
  83         int          replaysize;
  84 };
  85
  86 struct esp_algorithm esp_xforms[]={
  87         {"none",                  NONE,    0,  0, 0},
  88         {"des-cbc",               DESCBC,  8,  0, 0},
  89         {"des-cbc-hmac96",        DESCBC,  8, 12, 4},
  90         {"blowfish-cbc",          BLOWFISH,8,  0, 0},
  91         {"blowfish-cbc-hmac96",   BLOWFISH,8, 12, 4},
  92         {"rc5-cbc",               RC5,     8,  0, 0},
  93         {"rc5-cbc-hmac96",        RC5,     8, 12, 4},
  94         {"cast128-cbc",           CAST128, 8,  0, 0},
  95         {"cast128-cbc-hmac96",    CAST128, 8, 12, 4},
  96         {"3des-cbc-hmac96",       DES3CBC, 8, 12, 4},
  97         {NULL,                    NONE,    0,  0, 0}
  98 };
  99
 100 static int hexdigit(char hex)
 101 {
 102         if(hex >= '0' && hex <= '9') {
 103                 return (hex - '0');
 104         } else if(hex >= 'A' && hex <= 'F') {
 105                 return (hex - 'A' + 10);
 106         } else if(hex >= 'a' && hex <= 'f') {
 107                 return (hex - 'a' + 10);
 108         } else {
 109                 printf("invalid hex digit %c in espsecret\n", hex);
 110                 return 0;
 111         }
 112 }
 113
 114 static int hex2byte(char *hexstring)
 115 {
 116         int byte;
 117
 118         byte = (hexdigit(hexstring[0]) << 4) +
 119                 hexdigit(hexstring[1]);
 120         return byte;
 121 }
 122
 123
 124 static void esp_print_decodesecret(void)
 125 {
 126         char *colon;
 127         int   len, i;
 128         struct esp_algorithm *xf;
 129         struct esp_algorithm *null_xf =
 130                 &esp_xforms[sizeof(esp_xforms)/sizeof(esp_xforms[0]) - 1];
 131
 132         if(espsecret == NULL) {
 133                 /* set to NULL transform */
 134                 espsecret_xform = null_xf;
 135                 return;
 136         }
 137
 138         if(espsecret_key != NULL) {
 139                 return;
 140         }
 141
 142         colon = strchr(espsecret, ':');
 143         if(colon == NULL) {
 144                 printf("failed to decode espsecret: %s\n",
 145                        espsecret);
 146                 /* set to NULL transform */
 147                 espsecret_xform = null_xf;
 148                 return;
 149         }
 150
 151         len = colon - espsecret;
 152         xf = esp_xforms;
 153         while(xf->name && strncasecmp(espsecret, xf->name, len)!=0) {
 154                 xf++;
 155         }
 156         if(xf->name == NULL) {
 157                 printf("failed to find cipher algo %s\n",
 158                        espsecret);
 159                 /* set to NULL transform */
 160                 espsecret_xform = null_xf;
 161                 return;
 162         }
 163         espsecret_xform = xf;
 164
 165         colon++;
 166         if(colon[0]=='0' && colon[1]=='x') {
 167                 /* decode some hex! */
 168                 colon+=2;
 169                 len = strlen(colon) / 2;
 170                 espsecret_key = (char *)malloc(len);
 171                 if(espsecret_key == NULL) {
 172                   fprintf(stderr, "%s: ran out of memory (%d) to allocate secret key\n",
 173                           program_name, len);
 174                   exit(2);
 175                 }
 176                 i = 0;
 177                 while(colon[0] != '\0' && colon[1]!='\0') {
 178                         espsecret_key[i]=hex2byte(colon);
 179                         colon+=2;
 180                         i++;
 181                 }
 182         } else {
 183                 espsecret_key = colon;
 184         }
 185 }
 186
 187 int
 188 esp_print(register const u_char *bp, register const u_char *bp2,
 189           int *nhdr, int *padlen)
 190 {
 191         register const struct newesp *esp;
 192         register const u_char *ep;
 193         struct ip *ip = NULL;
 194 #ifdef INET6
 195         struct ip6_hdr *ip6 = NULL;
 196 #endif
 197         int advance;
 198         int len;
 199         char *secret;
 200         int ivlen = 0;
 201         u_char *ivoff;
 202 #ifdef HAVE_LIBCRYPTO
 203         u_char *p;
 204 #endif
 205
 206         esp = (struct newesp *)bp;
 207         secret = NULL;
 208
 209 #if 0
 210         /* keep secret out of a register */
 211         p = (u_char *)&secret;
 212 #endif
 213
 214         /* 'ep' points to the end of available data. */
 215         ep = snapend;
 216
 217         if ((u_char *)(esp + 1) >= ep) {
 218                 fputs("[|ESP]", stdout);
 219                 goto fail;
 220         }
 221         printf("ESP(spi=0x%08x", (u_int32_t)ntohl(esp->esp_spi));
 222         printf(",seq=0x%x", (u_int32_t)ntohl(esp->esp_seq));
 223         printf(")");
 224
 225         /* if we don't have decryption key, we can't decrypt this packet. */
 226         if (!espsecret)
 227                 goto fail;
 228
 229         if(!espsecret_xform) {
 230                 esp_print_decodesecret();
 231         }
 232         if(espsecret_xform->name == NULL) {
 233                 goto fail;
 234         }
 235
 236         ip = (struct ip *)bp2;
 237         switch (IP_V(ip)) {
 238 #ifdef INET6
 239         case 6:
 240                 ip6 = (struct ip6_hdr *)bp2;
 241                 ip = NULL;
 242                 /* we do not attempt to decrypt jumbograms */
 243                 if (!ntohs(ip6->ip6_plen))
 244                         goto fail;
 245                 /* if we can't get nexthdr, we do not need to decrypt it */
 246                 len = sizeof(struct ip6_hdr) + ntohs(ip6->ip6_plen);
 247                 break;
 248 #endif /*INET6*/
 249         case 4:
 250                 /* nexthdr & padding are in the last fragment */
 251                 if (ntohs(ip->ip_off) & IP_MF)
 252                         goto fail;
 253 #ifdef INET6
 254                 ip6 = NULL;
 255 #endif
 256                 len = ntohs(ip->ip_len);
 257                 break;
 258         default:
 259                 goto fail;
 260         }
 261
 262         /* if we can't get nexthdr, we do not need to decrypt it */
 263         if (ep - bp2 < len)
 264                 goto fail;
 265
 266         ivoff = (u_char *)(esp + 1) + espsecret_xform->replaysize;
 267         ivlen = espsecret_xform->ivlen;
 268         secret = espsecret_key;
 269
 270         switch (espsecret_xform->algo) {
 271         case DESCBC:
 272 #ifdef HAVE_LIBCRYPTO
 273             {
 274                 u_char iv[8];
 275                 des_key_schedule schedule;
 276
 277                 switch (ivlen) {
 278                 case 4:
 279                         memcpy(iv, ivoff, 4);
 280                         memcpy(&iv[4], ivoff, 4);
 281                         p = &iv[4];
 282                         *p++ ^= 0xff;
 283                         *p++ ^= 0xff;
 284                         *p++ ^= 0xff;
 285                         *p++ ^= 0xff;
 286                         break;
 287                 case 8:
 288                         memcpy(iv, ivoff, 8);
 289                         break;
 290                 default:
 291                         goto fail;
 292                 }
 293
 294                 des_check_key = 0;
 295                 des_set_key((void *)secret, schedule);
 296
 297                 p = ivoff + ivlen;
 298                 des_cbc_encrypt((void *)p, (void *)p,
 299                         (long)(ep - p), schedule, (void *)iv,
 300                         DES_DECRYPT);
 301                 advance = ivoff - (u_char *)esp + ivlen;
 302                 break;
 303             }
 304 #else
 305                 goto fail;
 306 #endif /*HAVE_LIBCRYPTO*/
 307
 308         case BLOWFISH:
 309 #ifdef HAVE_LIBCRYPTO
 310             {
 311                 BF_KEY schedule;
 312
 313                 BF_set_key(&schedule, strlen(secret), secret);
 314
 315                 p = ivoff + ivlen;
 316                 BF_cbc_encrypt(p, p, (long)(ep - p), &schedule, ivoff,
 317                         BF_DECRYPT);
 318                 advance = ivoff - (u_char *)esp + ivlen;
 319                 break;
 320             }
 321 #else
 322                 goto fail;
 323 #endif /*HAVE_LIBCRYPTO*/
 324
 325         case RC5:
 326 #if defined(HAVE_LIBCRYPTO) && defined(HAVE_RC5_H)
 327             {
 328                 RC5_32_KEY schedule;
 329
 330                 RC5_32_set_key(&schedule, strlen(secret), secret,
 331                         RC5_16_ROUNDS);
 332
 333                 p = ivoff + ivlen;
 334                 RC5_32_cbc_encrypt(p, p, (long)(ep - p), &schedule, ivoff,
 335                         RC5_DECRYPT);
 336                 advance = ivoff - (u_char *)esp + ivlen;
 337                 break;
 338             }
 339 #else
 340                 goto fail;
 341 #endif /*HAVE_LIBCRYPTO*/
 342
 343         case CAST128:
 344 #if defined(HAVE_LIBCRYPTO) && defined(HAVE_CAST_H) && !defined(HAVE_BUGGY_CAST128)
 345             {
 346                 CAST_KEY schedule;
 347
 348                 CAST_set_key(&schedule, strlen(secret), secret);
 349
 350                 p = ivoff + ivlen;
 351                 CAST_cbc_encrypt(p, p, (long)(ep - p), &schedule, ivoff,
 352                         CAST_DECRYPT);
 353                 advance = ivoff - (u_char *)esp + ivlen;
 354                 break;
 355             }
 356 #else
 357                 goto fail;
 358 #endif /*HAVE_LIBCRYPTO*/
 359
 360         case DES3CBC:
 361 #if defined(HAVE_LIBCRYPTO)
 362             {
 363                 des_key_schedule s1, s2, s3;
 364
 365                 des_check_key = 1;
 366                 des_set_odd_parity((void *)secret);
 367                 des_set_odd_parity((void *)(secret + 8));
 368                 des_set_odd_parity((void *)(secret + 16));
 369                 if(des_set_key((void *)secret, s1) != 0) {
 370                   printf("failed to schedule key 1\n");
 371                 }
 372                 if(des_set_key((void *)(secret + 8), s2)!=0) {
 373                   printf("failed to schedule key 2\n");
 374                 }
 375                 if(des_set_key((void *)(secret + 16), s3)!=0) {
 376                   printf("failed to schedule key 3\n");
 377                 }
 378
 379                 p = ivoff + ivlen;
 380                 des_ede3_cbc_encrypt((void *)p, (void *)p,
 381                                      (long)(ep - p),
 382                                      s1, s2, s3,
 383                                      (void *)ivoff, DES_DECRYPT);
 384                 advance = ivoff - (u_char *)esp + ivlen;
 385                 break;
 386             }
 387 #else
 388                 goto fail;
 389 #endif /*HAVE_LIBCRYPTO*/
 390
 391         case NONE:
 392         default:
 393                 advance = sizeof(struct newesp) + espsecret_xform->replaysize;
 394                 break;
 395         }
 396
 397         ep = ep - espsecret_xform->authlen;
 398         /* sanity check for pad length */
 399         if (ep - bp < *(ep - 2))
 400                 goto fail;
 401
 402         if (padlen)
 403                 *padlen = *(ep - 2) + 2;
 404
 405         if (nhdr)
 406                 *nhdr = *(ep - 1);
 407
 408         printf(": ");
 409         return advance;
 410
 411 fail:
 412         if (nhdr)
 413                 *nhdr = -1;
 414         return 65536;
 415 }