packet-isakmp.c

   1 /* packet-gre.c
   2  * Routines for the Internet Security Association and Key Management Protocol (ISAKMP)
   3  * Brad Robel-Forrest <brad.robel-forrest@watchguard.com>
   4  *
   5  * $Id: packet-isakmp.c,v 1.12 2000/01/07 22:05:31 guy Exp $
   6  *
   7  * Ethereal - Network traffic analyzer
   8  * By Gerald Combs <gerald@zing.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #ifdef HAVE_SYS_TYPES_H
  32 # include <sys/types.h>
  33 #endif
  34
  35 #include <stdio.h>
  36
  37 #ifdef HAVE_NETINET_IN_H
  38 #include <netinet/in.h>
  39 #endif
  40
  41 #include <glib.h>
  42 #include "packet.h"
  43
  44 #ifdef NEED_SNPRINTF_H
  45 # ifdef HAVE_STDARG_H
  46 #  include <stdarg.h>
  47 # else
  48 #  include <varargs.h>
  49 # endif
  50 # include "snprintf.h"
  51 #endif
  52
  53 static int proto_isakmp = -1;
  54
  55 static gint ett_isakmp = -1;
  56 static gint ett_isakmp_flags = -1;
  57 static gint ett_isakmp_payload = -1;
  58
  59 #define NUM_PROTO_TYPES 5
  60 #define proto2str(t)    \
  61   ((t < NUM_PROTO_TYPES) ? prototypestr[t] : "UNKNOWN-PROTO-TYPE")
  62
  63 static const char *prototypestr[NUM_PROTO_TYPES] = {
  64   "RESERVED",
  65   "ISAKMP",
  66   "IPSEC_AH",
  67   "IPSEC_ESP",
  68   "IPCOMP"
  69 };
  70
  71 #define NUM_P1_ATT_TYPES        17
  72 #define p1_atttype2str(t)       \
  73   ((t < NUM_P1_ATT_TYPES) ? p1_atttypestr[t] : "UNKNOWN-ATTRIBUTE-TYPE")
  74
  75 static const char *p1_atttypestr[NUM_P1_ATT_TYPES] = {
  76   "UNKNOWN-ATTRIBUTE-TYPE",
  77   "Encryption-Algorithm",
  78   "Hash-Algorithm",
  79   "Authentication-Method",
  80   "Group-Description",
  81   "Group-Type",
  82   "Group-Prime",
  83   "Group-Generator-One",
  84   "Group-Generator-Two",
  85   "Group-Curve-A",
  86   "Group-Curve-B",
  87   "Life-Type",
  88   "Life-Duration",
  89   "PRF",
  90   "Key-Length",
  91   "Field-Size",
  92   "Group-Order"
  93 };
  94
  95 #define NUM_ATT_TYPES   10
  96 #define atttype2str(t)  \
  97   ((t < NUM_ATT_TYPES) ? atttypestr[t] : "UNKNOWN-ATTRIBUTE-TYPE")
  98
  99 static const char *atttypestr[NUM_ATT_TYPES] = {
 100   "UNKNOWN-ATTRIBUTE-TYPE",
 101   "SA-Life-Type",
 102   "SA-Life-Duration",
 103   "Group-Description",
 104   "Encapsulation-Mode",
 105   "Authentication-Algorithm",
 106   "Key-Length",
 107   "Key-Rounds",
 108   "Compress-Dictinary-Size",
 109   "Compress-Private-Algorithm"
 110 };
 111
 112 #define NUM_TRANS_TYPES 2
 113 #define trans2str(t)    \
 114   ((t < NUM_TRANS_TYPES) ? transtypestr[t] : "UNKNOWN-TRANS-TYPE")
 115
 116 static const char *transtypestr[NUM_TRANS_TYPES] = {
 117   "RESERVED",
 118   "KEY_IKE"
 119 };
 120
 121 #define NUM_AH_TRANS_TYPES      5
 122 #define ah_trans2str(t)         \
 123   ((t < NUM_AH_TRANS_TYPES) ? ah_transtypestr[t] : "UNKNOWN-AH-TRANS-TYPE")
 124
 125 static const char *ah_transtypestr[NUM_AH_TRANS_TYPES] = {
 126   "RESERVED",
 127   "RESERVED",
 128   "MD5",
 129   "SHA",
 130   "DES"
 131 };
 132
 133 #define NUM_ESP_TRANS_TYPES     12
 134 #define esp_trans2str(t)        \
 135   ((t < NUM_ESP_TRANS_TYPES) ? esp_transtypestr[t] : "UNKNOWN-ESP-TRANS-TYPE")
 136
 137 static const char *esp_transtypestr[NUM_ESP_TRANS_TYPES] = {
 138   "RESERVED",
 139   "DES-IV64",
 140   "DES",
 141   "3DES",
 142   "RC5",
 143   "IDEA",
 144   "CAST",
 145   "BLOWFISH",
 146   "3IDEA",
 147   "DES-IV32",
 148   "RC4",
 149   "NULL"
 150 };
 151
 152 #define NUM_ID_TYPES    12
 153 #define id2str(t)       \
 154   ((t < NUM_ID_TYPES) ? idtypestr[t] : "UNKNOWN-ID-TYPE")
 155
 156 static const char *idtypestr[NUM_ID_TYPES] = {
 157   "RESERVED",
 158   "IPV4_ADDR",
 159   "FQDN",
 160   "USER_FQDN",
 161   "IPV4_ADDR_SUBNET",
 162   "IPV6_ADDR",
 163   "IPV6_ADDR_SUBNET",
 164   "IPV4_ADDR_RANGE",
 165   "IPV6_ADDR_RANGE",
 166   "DER_ASN1_DN",
 167   "DER_ASN1_GN",
 168   "KEY_ID"
 169 };
 170
 171 struct isakmp_hdr {
 172   guint8        icookie[8];
 173   guint8        rcookie[8];
 174   guint8        next_payload;
 175   guint8        version;
 176   guint8        exch_type;
 177   guint8        flags;
 178 #define E_FLAG          0x01
 179 #define C_FLAG          0x02
 180 #define A_FLAG          0x04
 181   guint32       message_id;
 182   guint32       length;
 183 };
 184
 185 struct sa_hdr {
 186   guint8        next_payload;
 187   guint8        reserved;
 188   guint16       length;
 189   guint32       doi;
 190   guint32       situation;
 191 };
 192
 193 struct proposal_hdr {
 194   guint8        next_payload;
 195   guint8        reserved;
 196   guint16       length;
 197   guint8        proposal_num;
 198   guint8        protocol_id;
 199   guint8        spi_size;
 200   guint8        num_transforms;
 201 };
 202
 203 struct trans_hdr {
 204   guint8        next_payload;
 205   guint8        reserved;
 206   guint16       length;
 207   guint8        transform_num;
 208   guint8        transform_id;
 209   guint16       reserved2;
 210 };
 211
 212 #define TRANS_LEN(p)    (pntohs(&((struct trans_hdr *)(p))->length))
 213
 214 struct ke_hdr {
 215   guint8        next_payload;
 216   guint8        reserved;
 217   guint16       length;
 218 };
 219
 220 struct id_hdr {
 221   guint8        next_payload;
 222   guint8        reserved;
 223   guint16       length;
 224   guint8        id_type;
 225   guint8        protocol_id;
 226   guint16       port;
 227 };
 228
 229 struct cert_hdr {
 230   guint8        next_payload;
 231   guint8        reserved;
 232   guint16       length;
 233   guint8        cert_enc;
 234 };
 235
 236 struct certreq_hdr {
 237   guint8        next_payload;
 238   guint8        reserved;
 239   guint16       length;
 240   guint8        cert_type;
 241 };
 242
 243 struct hash_hdr {
 244   guint8        next_payload;
 245   guint8        reserved;
 246   guint16       length;
 247 };
 248
 249 struct sig_hdr {
 250   guint8        next_payload;
 251   guint8        reserved;
 252   guint16       length;
 253 };
 254
 255 struct nonce_hdr {
 256   guint8        next_payload;
 257   guint8        reserved;
 258   guint16       length;
 259 };
 260
 261 struct notif_hdr {
 262   guint8        next_payload;
 263   guint8        reserved;
 264   guint16       length;
 265   guint32       doi;
 266   guint8        protocol_id;
 267   guint8        spi_size;
 268   guint16       msgtype;
 269 };
 270
 271 struct delete_hdr {
 272   guint8        next_payload;
 273   guint8        reserved;
 274   guint16       length;
 275   guint32       doi;
 276   guint8        protocol_id;
 277   guint8        spi_size;
 278   guint16       num_spis;
 279 };
 280
 281 struct vid_hdr {
 282   guint8        next_payload;
 283   guint8        reserved;
 284   guint16       length;
 285 };
 286
 287 static void dissect_none(const u_char *, int, frame_data *, proto_tree *);
 288 static void dissect_sa(const u_char *, int, frame_data *, proto_tree *);
 289 static void dissect_proposal(const u_char *, int, frame_data *, proto_tree *);
 290 static void dissect_transform(const u_char *, int, frame_data *, proto_tree *,
 291                 guint8);
 292 static void dissect_key_exch(const u_char *, int, frame_data *, proto_tree *);
 293 static void dissect_id(const u_char *, int, frame_data *, proto_tree *);
 294 static void dissect_cert(const u_char *, int, frame_data *, proto_tree *);
 295 static void dissect_certreq(const u_char *, int, frame_data *, proto_tree *);
 296 static void dissect_hash(const u_char *, int, frame_data *, proto_tree *);
 297 static void dissect_sig(const u_char *, int, frame_data *, proto_tree *);
 298 static void dissect_nonce(const u_char *, int, frame_data *, proto_tree *);
 299 static void dissect_notif(const u_char *, int, frame_data *, proto_tree *);
 300 static void dissect_delete(const u_char *, int, frame_data *, proto_tree *);
 301 static void dissect_vid(const u_char *, int, frame_data *, proto_tree *);
 302
 303 static const char *payloadtype2str(guint8);
 304 static const char *exchtype2str(guint8);
 305 static const char *doitype2str(guint32);
 306 static const char *msgtype2str(guint16);
 307 static const char *situation2str(guint32);
 308 static const char *value2str(int, guint16, guint16);
 309 static const char *num2str(const guint8 *, guint16);
 310
 311 #define NUM_LOAD_TYPES          14
 312 #define loadtype2str(t) \
 313   ((t < NUM_LOAD_TYPES) ? strfuncs[t].str : "Unknown payload type")
 314 #define LOAD_TYPE_TRANSFORM     3
 315
 316 static struct strfunc {
 317   const char *  str;
 318   void          (*func)(const u_char *, int, frame_data *, proto_tree *);
 319 } strfuncs[NUM_LOAD_TYPES] = {
 320   {"NONE",                      dissect_none      },
 321   {"Security Association",      dissect_sa        },
 322   {"Proposal",                  dissect_proposal  },
 323   {"Transform",                 NULL },
 324   {"Key Exchange",              dissect_key_exch  },
 325   {"Identification",            dissect_id        },
 326   {"Certificate",               dissect_cert      },
 327   {"Certificate Request",       dissect_certreq   },
 328   {"Hash",                      dissect_hash      },
 329   {"Signature",                 dissect_sig       },
 330   {"Nonce",                     dissect_nonce     },
 331   {"Notification",              dissect_notif     },
 332   {"Delete",                    dissect_delete    },
 333   {"Vendor ID",                 dissect_vid       }
 334 };
 335
 336 void dissect_isakmp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 337
 338   struct isakmp_hdr *   hdr = (struct isakmp_hdr *)(pd + offset);
 339   guint32               len;
 340
 341   if (check_col(fd, COL_PROTOCOL))
 342     col_add_str(fd, COL_PROTOCOL, "ISAKMP");
 343
 344   len = pntohl(&hdr->length);
 345
 346   if (check_col(fd, COL_INFO))
 347     col_add_fstr(fd, COL_INFO, "%s", exchtype2str(hdr->exch_type));
 348
 349   if (IS_DATA_IN_FRAME(offset) && tree) {
 350     proto_item *        ti;
 351     proto_tree *        isakmp_tree;
 352
 353     ti = proto_tree_add_item(tree, proto_isakmp, offset, len, NULL);
 354     isakmp_tree = proto_item_add_subtree(ti, ett_isakmp);
 355
 356     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->icookie),
 357                         "Initiator cookie");
 358     offset += sizeof(hdr->icookie);
 359
 360     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->rcookie),
 361                         "Responder cookie");
 362     offset += sizeof(hdr->rcookie);
 363
 364     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->next_payload),
 365                         "Next payload: %s (%u)",
 366                         payloadtype2str(hdr->next_payload), hdr->next_payload);
 367     offset += sizeof(hdr->next_payload);
 368
 369     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->version),
 370                         "Version: %u.%u",
 371                         hi_nibble(hdr->version), lo_nibble(hdr->version));
 372     offset += sizeof(hdr->version);
 373
 374     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->exch_type),
 375                         "Exchange type: %s (%u)",
 376                         exchtype2str(hdr->exch_type), hdr->exch_type);
 377     offset += sizeof(hdr->exch_type);
 378
 379     {
 380       proto_item *      fti;
 381       proto_tree *      ftree;
 382
 383       fti   = proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->flags), "Flags");
 384       ftree = proto_item_add_subtree(fti, ett_isakmp_flags);
 385
 386       proto_tree_add_text(ftree, offset, 1, "%s",
 387                           decode_boolean_bitfield(hdr->flags, E_FLAG, sizeof(hdr->flags)*8,
 388                                                   "Encryption", "No encryption"));
 389       proto_tree_add_text(ftree, offset, 1, "%s",
 390                           decode_boolean_bitfield(hdr->flags, C_FLAG, sizeof(hdr->flags)*8,
 391                                                   "Commit", "No commit"));
 392       proto_tree_add_text(ftree, offset, 1, "%s",
 393                           decode_boolean_bitfield(hdr->flags, A_FLAG, sizeof(hdr->flags)*8,
 394                                                   "Authentication", "No authentication"));
 395       offset += sizeof(hdr->flags);
 396     }
 397
 398     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->message_id), "Message ID");
 399     offset += sizeof(hdr->message_id);
 400
 401     proto_tree_add_text(isakmp_tree, offset, sizeof(hdr->length),
 402                         "Length: %u", len);
 403     offset += sizeof(hdr->length);
 404
 405     if (hdr->next_payload < NUM_LOAD_TYPES) {
 406       if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 407         dissect_transform(pd, offset, fd, isakmp_tree, 0);      /* XXX - protocol ID? */
 408       else
 409         (*strfuncs[hdr->next_payload].func)(pd, offset, fd, isakmp_tree);
 410     }
 411     else
 412       dissect_data(pd, offset, fd, isakmp_tree);
 413   }
 414 }
 415
 416 static void
 417 dissect_none(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 418 }
 419
 420 static void
 421 dissect_sa(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 422
 423   struct sa_hdr *       hdr       = (struct sa_hdr *)(pd + offset);
 424   guint16               length    = pntohs(&hdr->length);
 425   guint32               doi       = pntohl(&hdr->doi);
 426   guint32               situation = pntohl(&hdr->situation);
 427   proto_item *          ti        = proto_tree_add_text(tree, offset, length, "Security Association payload");
 428   proto_tree *          ntree;
 429
 430   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 431
 432   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 433                       "Next payload: %s (%u)",
 434                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 435   offset += sizeof(hdr->next_payload) * 2;
 436
 437   proto_tree_add_text(ntree, offset, sizeof(length),
 438                       "Length: %u", length);
 439   offset += sizeof(length);
 440
 441   proto_tree_add_text(ntree, offset, sizeof(doi),
 442                       "Domain of interpretation: %s (%u)",
 443                       doitype2str(doi), doi);
 444   offset += sizeof(doi);
 445
 446   proto_tree_add_text(ntree, offset, sizeof(situation),
 447                       "Situation: %s (%u)",
 448                       situation2str(situation), situation);
 449   offset += sizeof(situation);
 450
 451   dissect_proposal(pd, offset, fd, ntree);
 452   offset += (length - sizeof(*hdr));
 453
 454   if (hdr->next_payload < NUM_LOAD_TYPES) {
 455     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 456       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 457     else
 458       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 459   }
 460   else
 461     dissect_data(pd, offset, fd, tree);
 462 }
 463
 464 static void
 465 dissect_proposal(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 466
 467   struct proposal_hdr * hdr     = (struct proposal_hdr *)(pd + offset);
 468   guint16               length  = pntohs(&hdr->length);
 469   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Proposal payload");
 470   proto_tree *          ntree;
 471
 472   int                   next_hdr_offset = offset + length;
 473
 474   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 475
 476   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 477                       "Next payload: %s (%u)",
 478                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 479   offset += sizeof(hdr->next_payload) * 2;
 480
 481   proto_tree_add_text(ntree, offset, sizeof(length),
 482                       "Length: %u", length);
 483   offset += sizeof(length);
 484
 485   proto_tree_add_text(ntree, offset, sizeof(hdr->proposal_num),
 486                       "Proposal number: %u", hdr->proposal_num);
 487   offset += sizeof(hdr->proposal_num);
 488
 489   proto_tree_add_text(ntree, offset, sizeof(hdr->protocol_id),
 490                       "Protocol ID: %s (%u)",
 491                       proto2str(hdr->protocol_id), hdr->protocol_id);
 492   offset += sizeof(hdr->protocol_id);
 493
 494   proto_tree_add_text(ntree, offset, sizeof(hdr->spi_size),
 495                       "SPI size: %u", hdr->spi_size);
 496   offset += sizeof(hdr->spi_size);
 497
 498   proto_tree_add_text(ntree, offset, sizeof(hdr->num_transforms),
 499                       "Number of transforms: %u", hdr->num_transforms);
 500   offset += sizeof(hdr->num_transforms);
 501
 502   if (hdr->spi_size) {
 503     proto_tree_add_text(ntree, offset, hdr->spi_size, "SPI");
 504     offset += hdr->spi_size;
 505   }
 506
 507   if (hdr->num_transforms > 0)
 508     dissect_transform(pd, offset, fd, ntree, hdr->protocol_id);
 509
 510   if (hdr->next_payload < NUM_LOAD_TYPES) {
 511     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 512       dissect_transform(pd, next_hdr_offset, fd, tree, 0);      /* XXX - protocol ID? */
 513     else
 514       (*strfuncs[hdr->next_payload].func)(pd, next_hdr_offset, fd, tree);
 515   }
 516   else
 517     dissect_data(pd, next_hdr_offset, fd, tree);
 518 }
 519
 520 static void
 521 dissect_transform(const u_char *pd, int offset, frame_data *fd,
 522                 proto_tree *tree, guint8 protocol_id)
 523 {
 524
 525   struct trans_hdr *    hdr     = (struct trans_hdr *)(pd + offset);
 526   guint16               length  = pntohs(&hdr->length);
 527   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Transform payload");
 528   proto_tree *          ntree;
 529
 530   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 531
 532   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 533                       "Next payload: %s (%u)",
 534                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 535   offset += sizeof(hdr->next_payload) * 2;
 536
 537   proto_tree_add_text(ntree, offset, sizeof(length),
 538                       "Length: %u", length);
 539   offset += sizeof(length);
 540
 541   proto_tree_add_text(ntree, offset, sizeof(hdr->transform_num),
 542                       "Transform number: %u", hdr->transform_num);
 543   offset += sizeof(hdr->transform_num);
 544
 545   switch (protocol_id) {
 546   default:
 547   case 1:       /* ISAKMP */
 548     proto_tree_add_text(ntree, offset, sizeof(hdr->transform_id),
 549                         "Transform ID: %s (%u)",
 550                         trans2str(hdr->transform_id), hdr->transform_id);
 551     break;
 552   case 2:       /* AH */
 553     proto_tree_add_text(ntree, offset, sizeof(hdr->transform_id),
 554                         "Transform ID: %s (%u)",
 555                         ah_trans2str(hdr->transform_id), hdr->transform_id);
 556     break;
 557   case 3:       /* ESP */
 558     proto_tree_add_text(ntree, offset, sizeof(hdr->transform_id),
 559                         "Transform ID: %s (%u)",
 560                         esp_trans2str(hdr->transform_id), hdr->transform_id);
 561     break;
 562   }
 563   offset += sizeof(hdr->transform_id) + sizeof(hdr->reserved2);
 564
 565   length -= sizeof(*hdr);
 566   while (length) {
 567     const char *str = NULL;
 568     int ike_phase1 = 0;
 569     guint16 type    = pntohs(pd + offset) & 0x7fff;
 570     guint16 val_len = pntohs(pd + offset + 2);
 571
 572     if (protocol_id == 1 && hdr->transform_id == 1) {
 573       ike_phase1 = 1;
 574       str = p1_atttype2str(type);
 575     }
 576     else {
 577       str = atttype2str(type);
 578     }
 579
 580     if (pd[offset] & 0xf0) {
 581       proto_tree_add_text(ntree, offset, 4,
 582                           "%s (%u): %s (%u)",
 583                           str, type,
 584                           value2str(ike_phase1, type, val_len), val_len);
 585       offset += 4;
 586       length -= 4;
 587     }
 588     else {
 589       guint16   pack_len = 4 + val_len;
 590
 591       proto_tree_add_text(ntree, offset, pack_len,
 592                           "%s (%u): %s",
 593                           str, type,
 594                           num2str(pd + offset + 4, val_len));
 595       offset += pack_len;
 596       length -= pack_len;
 597     }
 598   }
 599
 600   if (hdr->next_payload < NUM_LOAD_TYPES) {
 601     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 602       dissect_transform(pd, offset, fd, tree, protocol_id);
 603     else
 604       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 605   }
 606   else
 607     dissect_data(pd, offset, fd, tree);
 608 }
 609
 610 static void
 611 dissect_key_exch(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 612
 613   struct ke_hdr *       hdr     = (struct ke_hdr *)(pd + offset);
 614   guint16               length  = pntohs(&hdr->length);
 615   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Key Exchange payload");
 616   proto_tree *          ntree;
 617
 618   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 619
 620   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 621                       "Next payload: %s (%u)",
 622                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 623   offset += sizeof(hdr->next_payload) * 2;
 624
 625   proto_tree_add_text(ntree, offset, sizeof(length),
 626                       "Length: %u", length);
 627   offset += sizeof(length);
 628
 629   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Key Exchange Data");
 630   offset += (length - sizeof(*hdr));
 631
 632   if (hdr->next_payload < NUM_LOAD_TYPES) {
 633     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 634       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 635     else
 636       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 637   }
 638   else
 639     dissect_data(pd, offset, fd, tree);
 640 }
 641
 642 static void
 643 dissect_id(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 644
 645   struct id_hdr *       hdr     = (struct id_hdr *)(pd + offset);
 646   guint16               length  = pntohs(&hdr->length);
 647   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Identification payload");
 648   proto_tree *          ntree;
 649
 650   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 651
 652   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 653                       "Next payload: %s (%u)",
 654                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 655   offset += sizeof(hdr->next_payload) * 2;
 656
 657   proto_tree_add_text(ntree, offset, sizeof(length),
 658                       "Length: %u", length);
 659   offset += sizeof(length);
 660
 661   proto_tree_add_text(ntree, offset, sizeof(hdr->id_type),
 662                       "ID type: %s (%u)", id2str(hdr->id_type), hdr->id_type);
 663   offset += sizeof(hdr->id_type);
 664
 665   proto_tree_add_text(ntree, offset, sizeof(hdr->protocol_id),
 666                       "Protocol ID: %u", hdr->protocol_id);
 667   offset += sizeof(hdr->protocol_id);
 668
 669   proto_tree_add_text(ntree, offset, sizeof(hdr->port),
 670                       "Port: %u", pntohs(&hdr->port));
 671   offset += sizeof(hdr->port);
 672
 673   switch (hdr->id_type) {
 674     case 1:
 675     case 4:
 676       proto_tree_add_text(ntree, offset, length-sizeof(*hdr),
 677                           "Identification data: %s", ip_to_str(pd+offset));
 678       break;
 679     case 2:
 680     case 3:
 681       proto_tree_add_text(ntree, offset, length-sizeof(*hdr),
 682                           "Identification data: %s", (char *)(pd+offset));
 683       break;
 684     default:
 685       proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Identification Data");
 686   }
 687   offset += (length - sizeof(*hdr));
 688
 689   if (hdr->next_payload < NUM_LOAD_TYPES) {
 690     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 691       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 692     else
 693       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 694   }
 695   else
 696     dissect_data(pd, offset, fd, tree);
 697 }
 698
 699 static void
 700 dissect_cert(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 701
 702   struct cert_hdr *     hdr     = (struct cert_hdr *)(pd + offset);
 703   guint16               length  = pntohs(&hdr->length);
 704   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Certificate payload");
 705   proto_tree *          ntree;
 706
 707   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 708
 709   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 710                       "Next payload: %s (%u)",
 711                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 712   offset += sizeof(hdr->next_payload) * 2;
 713
 714   proto_tree_add_text(ntree, offset, sizeof(length),
 715                       "Length: %u", length);
 716   offset += sizeof(length);
 717
 718   proto_tree_add_text(ntree, offset, sizeof(hdr->cert_enc),
 719                       "Certificate encoding: %u", hdr->cert_enc);
 720   offset += sizeof(hdr->cert_enc);
 721
 722   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Certificate Data");
 723   offset += (length - sizeof(*hdr));
 724
 725   if (hdr->next_payload < NUM_LOAD_TYPES) {
 726     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 727       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 728     else
 729       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 730   }
 731   else
 732     dissect_data(pd, offset, fd, tree);
 733 }
 734
 735 static void
 736 dissect_certreq(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 737
 738   struct certreq_hdr *  hdr     = (struct certreq_hdr *)(pd + offset);
 739   guint16               length  = pntohs(&hdr->length);
 740   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Certificate Request payload");
 741   proto_tree *          ntree;
 742
 743   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 744
 745   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 746                       "Next payload: %s (%u)",
 747                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 748   offset += sizeof(hdr->next_payload) * 2;
 749
 750   proto_tree_add_text(ntree, offset, sizeof(length),
 751                       "Length: %u", length);
 752   offset += sizeof(length);
 753
 754   proto_tree_add_text(ntree, offset, sizeof(hdr->cert_type),
 755                       "Certificate type: %u", hdr->cert_type);
 756   offset += sizeof(hdr->cert_type);
 757
 758   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Certificate Authority");
 759   offset += (length - sizeof(*hdr));
 760
 761   if (hdr->next_payload < NUM_LOAD_TYPES) {
 762     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 763       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 764     else
 765       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 766   }
 767   else
 768     dissect_data(pd, offset, fd, tree);
 769 }
 770
 771 static void
 772 dissect_hash(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 773
 774   struct hash_hdr *     hdr     = (struct hash_hdr *)(pd + offset);
 775   guint16               length  = pntohs(&hdr->length);
 776   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Hash payload");
 777   proto_tree *          ntree;
 778
 779   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 780
 781   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 782                       "Next payload: %s (%u)",
 783                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 784   offset += sizeof(hdr->next_payload) * 2;
 785
 786   proto_tree_add_text(ntree, offset, sizeof(length),
 787                       "Length: %u", length);
 788   offset += sizeof(length);
 789
 790   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Hash Data");
 791   offset += (length - sizeof(*hdr));
 792
 793   if (hdr->next_payload < NUM_LOAD_TYPES) {
 794     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 795       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 796     else
 797       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 798   }
 799   else
 800     dissect_data(pd, offset, fd, tree);
 801 }
 802
 803 static void
 804 dissect_sig(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 805
 806   struct sig_hdr *      hdr     = (struct sig_hdr *)(pd + offset);
 807   guint16               length  = pntohs(&hdr->length);
 808   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Signature payload");
 809   proto_tree *          ntree;
 810
 811   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 812
 813   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 814                       "Next payload: %s (%u)",
 815                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 816   offset += sizeof(hdr->next_payload) * 2;
 817
 818   proto_tree_add_text(ntree, offset, sizeof(length),
 819                       "Length: %u", length);
 820   offset += sizeof(length);
 821
 822   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Signature Data");
 823   offset += (length - sizeof(*hdr));
 824
 825   if (hdr->next_payload < NUM_LOAD_TYPES) {
 826     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 827       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 828     else
 829       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 830   }
 831   else
 832     dissect_data(pd, offset, fd, tree);
 833 }
 834
 835 static void
 836 dissect_nonce(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 837
 838   struct nonce_hdr *    hdr     = (struct nonce_hdr *)(pd + offset);
 839   guint16               length  = pntohs(&hdr->length);
 840   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Nonce payload");
 841   proto_tree *          ntree;
 842
 843   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 844
 845   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 846                       "Next payload: %s (%u)",
 847                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 848   offset += sizeof(hdr->next_payload) * 2;
 849
 850   proto_tree_add_text(ntree, offset, sizeof(length),
 851                       "Length: %u", length);
 852   offset += sizeof(length);
 853
 854   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Nonce Data");
 855   offset += (length - sizeof(*hdr));
 856
 857   if (hdr->next_payload < NUM_LOAD_TYPES) {
 858     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 859       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 860     else
 861       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 862   }
 863   else
 864     dissect_data(pd, offset, fd, tree);
 865 }
 866
 867 static void
 868 dissect_notif(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 869
 870   struct notif_hdr *    hdr     = (struct notif_hdr *)(pd + offset);
 871   guint16               length  = pntohs(&hdr->length);
 872   guint32               doi     = pntohl(&hdr->doi);
 873   guint16               msgtype = pntohs(&hdr->msgtype);
 874   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Notification payload");
 875   proto_tree *          ntree;
 876
 877   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 878
 879   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 880                       "Next payload: %s (%u)",
 881                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 882   offset += sizeof(hdr->next_payload) * 2;
 883
 884   proto_tree_add_text(ntree, offset, sizeof(length),
 885                       "Length: %u", length);
 886   offset += sizeof(length);
 887
 888   proto_tree_add_text(ntree, offset, sizeof(doi),
 889                       "Domain of Interpretation: %s (%u)", doitype2str(doi), doi);
 890   offset += sizeof(doi);
 891
 892   proto_tree_add_text(ntree, offset, sizeof(hdr->protocol_id),
 893                       "Protocol ID: %s (%u)",
 894                       proto2str(hdr->protocol_id), hdr->protocol_id);
 895   offset += sizeof(hdr->protocol_id);
 896
 897   proto_tree_add_text(ntree, offset, sizeof(hdr->spi_size),
 898                       "SPI size: %u", hdr->spi_size);
 899   offset += sizeof(hdr->spi_size);
 900
 901   proto_tree_add_text(ntree, offset, sizeof(msgtype),
 902                       "Message type: %s (%u)", msgtype2str(msgtype), msgtype);
 903   offset += sizeof(msgtype);
 904
 905   if (hdr->spi_size) {
 906     proto_tree_add_text(ntree, offset, hdr->spi_size, "Security Parameter Index");
 907     offset += hdr->spi_size;
 908   }
 909
 910   if (length - sizeof(*hdr)) {
 911     proto_tree_add_text(ntree, offset, length - sizeof(*hdr) - hdr->spi_size,
 912                         "Notification Data");
 913     offset += (length - sizeof(*hdr) - hdr->spi_size);
 914   }
 915
 916   if (hdr->next_payload < NUM_LOAD_TYPES) {
 917     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 918       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 919     else
 920       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 921   }
 922   else
 923     dissect_data(pd, offset, fd, tree);
 924 }
 925
 926 static void
 927 dissect_delete(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 928
 929   struct delete_hdr *   hdr      = (struct delete_hdr *)(pd + offset);
 930   guint16               length   = pntohs(&hdr->length);
 931   guint32               doi      = pntohl(&hdr->doi);
 932   guint16               num_spis = pntohs(&hdr->num_spis);
 933   proto_item *          ti       = proto_tree_add_text(tree, offset, length, "Delete payload");
 934   proto_tree *          ntree;
 935   guint16               i;
 936
 937   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 938
 939   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 940                       "Next payload: %s (%u)",
 941                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 942   offset += sizeof(hdr->next_payload) * 2;
 943
 944   proto_tree_add_text(ntree, offset, sizeof(length),
 945                       "Length: %u", length);
 946   offset += sizeof(length);
 947
 948   proto_tree_add_text(ntree, offset, sizeof(doi),
 949                       "Domain of Interpretation: %s (%u)", doitype2str(doi), doi);
 950   offset += sizeof(doi);
 951
 952   proto_tree_add_text(ntree, offset, sizeof(hdr->protocol_id),
 953                       "Protocol ID: %s (%u)",
 954                       proto2str(hdr->protocol_id), hdr->protocol_id);
 955   offset += sizeof(hdr->protocol_id);
 956
 957   proto_tree_add_text(ntree, offset, sizeof(hdr->spi_size),
 958                       "SPI size: %u", hdr->spi_size);
 959   offset += sizeof(hdr->spi_size);
 960
 961   proto_tree_add_text(ntree, offset, num_spis,
 962                       "Number of SPIs: %u", num_spis);
 963   offset += sizeof(hdr->num_spis);
 964
 965   for (i = 0; i < num_spis; ++i) {
 966     proto_tree_add_text(ntree, offset, hdr->spi_size,
 967                         "SPI (%d)", i);
 968     offset += hdr->spi_size;
 969   }
 970
 971   if (hdr->next_payload < NUM_LOAD_TYPES) {
 972     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
 973       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
 974     else
 975       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
 976   }
 977   else
 978     dissect_data(pd, offset, fd, tree);
 979 }
 980
 981 static void
 982 dissect_vid(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
 983
 984   struct vid_hdr *      hdr     = (struct vid_hdr *)(pd + offset);
 985   guint16               length  = pntohs(&hdr->length);
 986   proto_item *          ti      = proto_tree_add_text(tree, offset, length, "Vendor ID payload");
 987   proto_tree *          ntree;
 988
 989   ntree = proto_item_add_subtree(ti, ett_isakmp_payload);
 990
 991   proto_tree_add_text(ntree, offset, sizeof(hdr->next_payload),
 992                       "Next payload: %s (%u)",
 993                       payloadtype2str(hdr->next_payload), hdr->next_payload);
 994   offset += sizeof(hdr->next_payload) * 2;
 995
 996   proto_tree_add_text(ntree, offset, sizeof(length),
 997                       "Length: %u", length);
 998   offset += sizeof(length);
 999
1000   proto_tree_add_text(ntree, offset, length - sizeof(*hdr), "Vendor ID");
1001   offset += (length - sizeof(*hdr));
1002
1003   if (hdr->next_payload < NUM_LOAD_TYPES) {
1004     if (hdr->next_payload == LOAD_TYPE_TRANSFORM)
1005       dissect_transform(pd, offset, fd, tree, 0);       /* XXX - protocol ID? */
1006     else
1007       (*strfuncs[hdr->next_payload].func)(pd, offset, fd, tree);
1008   }
1009   else
1010     dissect_data(pd, offset, fd, tree);
1011 }
1012
1013 static const char *
1014 payloadtype2str(guint8 type) {
1015
1016   if (type < NUM_LOAD_TYPES) return strfuncs[type].str;
1017   if (type < 128)            return "RESERVED";
1018   if (type < 256)            return "Private USE";
1019
1020   return "Huh? You should never see this! Shame on you!";
1021 }
1022
1023 static const char *
1024 exchtype2str(guint8 type) {
1025
1026 #define NUM_EXCHSTRS    6
1027   static const char * exchstrs[NUM_EXCHSTRS] = {
1028     "NONE",
1029     "Base",
1030     "Identity Protection (Main Mode)",
1031     "Authentication Only",
1032     "Aggressive",
1033     "Informational"
1034   };
1035
1036   if (type < NUM_EXCHSTRS) return exchstrs[type];
1037   if (type < 32)           return "ISAKMP Future Use";
1038   switch (type) {
1039   case 32:
1040     return "Quick Mode";
1041   case 33:
1042     return "New Group Mode";
1043   }
1044   if (type < 240)          return "DOI Specific Use";
1045   if (type < 256)          return "Private Use";
1046
1047   return "Huh? You should never see this! Shame on you!";
1048 }
1049
1050 static const char *
1051 doitype2str(guint32 type) {
1052   if (type == 1) return "IPSEC";
1053   return "Unknown DOI Type";
1054 }
1055
1056 static const char *
1057 msgtype2str(guint16 type) {
1058
1059 #define NUM_PREDEFINED  31
1060   static const char *msgs[NUM_PREDEFINED] = {
1061     "<UNKNOWN>",
1062     "INVALID-PAYLOAD-TYPE",
1063     "DOI-NOT-SUPPORTED",
1064     "SITUATION-NOT-SUPPORTED",
1065     "INVALID-COOKIE",
1066     "INVALID-MAJOR-VERSION",
1067     "INVALID-MINOR-VERSION",
1068     "INVALID-EXCHANGE-TYPE",
1069     "INVALID-FLAGS",
1070     "INVALID-MESSAGE-ID",
1071     "INVALID-PROTOCOL-ID",
1072     "INVALID-SPI",
1073     "INVALID-TRANSFORM-ID",
1074     "ATTRIBUTES-NOT-SUPPORTED",
1075     "NO-PROPOSAL-CHOSEN",
1076     "BAD-PROPOSAL-SYNTAX",
1077     "PAYLOAD-MALFORMED",
1078     "INVALID-KEY-INFORMATION",
1079     "INVALID-ID-INFORMATION",
1080     "INVALID-CERT-ENCODING",
1081     "INVALID-CERTIFICATE",
1082     "CERT-TYPE-UNSUPPORTED",
1083     "INVALID-CERT-AUTHORITY",
1084     "INVALID-HASH-INFORMATION",
1085     "AUTHENTICATION-FAILED",
1086     "INVALID-SIGNATURE",
1087     "ADDRESS-NOTIFICATION",
1088     "NOTIFY-SA-LIFETIME",
1089     "CERTIFICATE-UNAVAILABLE",
1090     "UNSUPPORTED-EXCHANGE-TYPE",
1091     "UNEQUAL-PAYLOAD-LENGTHS"
1092   };
1093
1094   if (type < NUM_PREDEFINED) return msgs[type];
1095   if (type < 8192)           return "RESERVED (Future Use)";
1096   if (type < 16384)          return "Private Use";
1097   if (type < 16385)          return "CONNECTED";
1098   if (type < 24576)          return "RESERVED (Future Use) - status";
1099   if (type < 24577)          return "RESPONDER-LIFETIME";
1100   if (type < 24578)          return "REPLAY-STATUS";
1101   if (type < 24579)          return "INITIAL-CONTACT";
1102   if (type < 32768)          return "DOI-specific codes";
1103   if (type < 40960)          return "Private Use - status";
1104   if (type < 65535)          return "RESERVED (Future Use) - status (2)";
1105
1106   return "Huh? You should never see this! Shame on you!";
1107 }
1108
1109 static const char *
1110 situation2str(guint32 type) {
1111
1112 #define SIT_MSG_NUM     1024
1113 #define SIT_IDENTITY    0x01
1114 #define SIT_SECRECY     0x02
1115 #define SIT_INTEGRITY   0x04
1116
1117   static char   msg[SIT_MSG_NUM];
1118   int           n = 0;
1119   char *        sep = "";
1120
1121   if (type & SIT_IDENTITY) {
1122     n += snprintf(msg, SIT_MSG_NUM-n, "%sIDENTITY", sep);
1123     sep = " & ";
1124   }
1125   if (type & SIT_SECRECY) {
1126     n += snprintf(msg, SIT_MSG_NUM-n, "%sSECRECY", sep);
1127     sep = " & ";
1128   }
1129   if (type & SIT_INTEGRITY) {
1130     n += snprintf(msg, SIT_MSG_NUM-n, "%sINTEGRITY", sep);
1131     sep = " & ";
1132   }
1133
1134   return msg;
1135 }
1136
1137 static const char *
1138 value2str(int ike_p1, guint16 att_type, guint16 value) {
1139
1140   if (value == 0) return "RESERVED";
1141
1142   if (!ike_p1) {
1143   switch (att_type) {
1144     case 1:
1145       switch (value) {
1146         case 1:  return "Seconds";
1147         case 2:  return "Kilobytes";
1148         default: return "UNKNOWN-SA-VALUE";
1149       }
1150     case 2:
1151       return "Duration-Value";
1152     case 3:
1153       return "Group-Value";
1154     case 4:
1155       switch (value) {
1156         case 1:  return "Tunnel";
1157         case 2:  return "Transport";
1158         default: return "UNKNOWN-ENCAPSULATION-VALUE";
1159       }
1160     case 5:
1161       switch (value) {
1162         case 1:  return "HMAC-MD5";
1163         case 2:  return "HMAC-SHA";
1164         case 3:  return "DES-MAC";
1165         case 4:  return "KPDK";
1166         default: return "UNKNOWN-AUTHENTICATION-VALUE";
1167       }
1168     case 6:
1169       return "Key-Length";
1170     case 7:
1171       return "Key-Rounds";
1172     case 8:
1173       return "log2-size";
1174     default: return "UNKNOWN-ATTRIBUTE-TYPE";
1175   }
1176   }
1177   else {
1178     switch (att_type) {
1179       case 1:
1180         switch (value) {
1181           case 1:  return "DES-CBC";
1182           case 2:  return "IDEA-CBC";
1183           case 3:  return "BLOWFISH-CBC";
1184           case 4:  return "RC5-R16-B64-CBC";
1185           case 5:  return "3DES-CBC";
1186           case 6:  return "CAST-CBC";
1187           default: return "UNKNOWN-ENCRYPTION-ALG";
1188         }
1189       case 2:
1190         switch (value) {
1191           case 1:  return "MD5";
1192           case 2:  return "SHA";
1193           case 3:  return "TIGER";
1194           default: return "UNKNOWN-HASH-ALG";
1195         }
1196       case 3:
1197         switch (value) {
1198           case 1:  return "PSK";
1199           case 2:  return "DSS-SIG";
1200           case 3:  return "RSA-SIG";
1201           case 4:  return "RSA-ENC";
1202           case 5:  return "RSA-Revised-ENC";
1203           default: return "UNKNOWN-AUTH-METHOD";
1204         }
1205       case 4:
1206       case 6:
1207       case 7:
1208       case 8:
1209       case 9:
1210       case 10:
1211       case 16:
1212         return "Group-Value";
1213       case 5:
1214         switch (value) {
1215           case 1:  return "MODP";
1216           case 2:  return "ECP";
1217           case 3:  return "EC2N";
1218           default: return "UNKNOWN-GROUPT-TYPE";
1219         }
1220       case 11:
1221         switch (value) {
1222           case 1:  return "Seconds";
1223           case 2:  return "Kilobytes";
1224           default: return "UNKNOWN-SA-VALUE";
1225         }
1226       case 12:
1227         return "Duration-Value";
1228       case 13:
1229         return "PRF-Value";
1230       case 14:
1231         return "Key-Length";
1232       case 15:
1233         return "Field-Size";
1234       default: return "UNKNOWN-ATTRIBUTE-TYPE";
1235     }
1236   }
1237 }
1238
1239 static const char *
1240 num2str(const guint8 *pd, guint16 len) {
1241
1242 #define NUMSTR_LEN      1024
1243   static char           numstr[NUMSTR_LEN];
1244
1245   switch (len) {
1246   case 1:
1247     snprintf(numstr, NUMSTR_LEN, "%u", *pd);
1248     break;
1249   case 2:
1250     snprintf(numstr, NUMSTR_LEN, "%u", pntohs(pd));
1251     break;
1252   case 3:
1253     snprintf(numstr, NUMSTR_LEN, "%u", pntohl(pd) & 0x0fff);
1254     break;
1255   case 4:
1256     snprintf(numstr, NUMSTR_LEN, "%u", pntohl(pd));
1257     break;
1258   default:
1259     snprintf(numstr, NUMSTR_LEN, "<too big>");
1260   }
1261
1262   return numstr;
1263 }
1264
1265 void
1266 proto_register_isakmp(void)
1267 {
1268 /*        static hf_register_info hf[] = {
1269                 { &variable,
1270                 { "Name",           "isakmp.abbreviation", TYPE, VALS_POINTER }},
1271         };*/
1272         static gint *ett[] = {
1273                 &ett_isakmp,
1274                 &ett_isakmp_flags,
1275                 &ett_isakmp_payload,
1276         };
1277
1278         proto_isakmp = proto_register_protocol("Internet Security Association and Key Management Protocol", "isakmp");
1279  /*       proto_register_field_array(proto_isakmp, hf, array_length(hf));*/
1280         proto_register_subtree_array(ett, array_length(ett));
1281 }