contrib/tcpdump/print-isakmp.c

   1 /*
   2  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the project nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  */
  30
  31 /* \summary: Internet Security Association and Key Management Protocol (ISAKMP) printer */
  32
  33 /* specification: RFC 2407, RFC 2408, RFC 5996 */
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38
  39 /* The functions from print-esp.c used in this file are only defined when both
  40  * OpenSSL and evp.h are detected. Employ the same preprocessor device here.
  41  */
  42 #ifndef HAVE_OPENSSL_EVP_H
  43 #undef HAVE_LIBCRYPTO
  44 #endif
  45
  46 #include "netdissect-stdinc.h"
  47
  48 #include <string.h>
  49
  50 #include "netdissect-ctype.h"
  51
  52 #include "netdissect.h"
  53 #include "addrtoname.h"
  54 #include "extract.h"
  55
  56 #include "ip.h"
  57 #include "ip6.h"
  58 #include "ipproto.h"
  59
  60 typedef nd_byte cookie_t[8];
  61 typedef nd_byte msgid_t[4];
  62
  63 #define PORT_ISAKMP 500
  64
  65 /* 3.1 ISAKMP Header Format (IKEv1 and IKEv2)
  66          0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
  67         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  68         !                          Initiator                            !
  69         !                            Cookie                             !
  70         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  71         !                          Responder                            !
  72         !                            Cookie                             !
  73         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  74         !  Next Payload ! MjVer ! MnVer ! Exchange Type !     Flags     !
  75         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  76         !                          Message ID                           !
  77         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  78         !                            Length                             !
  79         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  80 */
  81 struct isakmp {
  82         cookie_t i_ck;          /* Initiator Cookie */
  83         cookie_t r_ck;          /* Responder Cookie */
  84         nd_uint8_t np;          /* Next Payload Type */
  85         nd_uint8_t vers;
  86 #define ISAKMP_VERS_MAJOR       0xf0
  87 #define ISAKMP_VERS_MAJOR_SHIFT 4
  88 #define ISAKMP_VERS_MINOR       0x0f
  89 #define ISAKMP_VERS_MINOR_SHIFT 0
  90         nd_uint8_t etype;       /* Exchange Type */
  91         nd_uint8_t flags;       /* Flags */
  92         msgid_t msgid;
  93         nd_uint32_t len;        /* Length */
  94 };
  95
  96 /* Next Payload Type */
  97 #define ISAKMP_NPTYPE_NONE   0 /* NONE*/
  98 #define ISAKMP_NPTYPE_SA     1 /* Security Association */
  99 #define ISAKMP_NPTYPE_P      2 /* Proposal */
 100 #define ISAKMP_NPTYPE_T      3 /* Transform */
 101 #define ISAKMP_NPTYPE_KE     4 /* Key Exchange */
 102 #define ISAKMP_NPTYPE_ID     5 /* Identification */
 103 #define ISAKMP_NPTYPE_CERT   6 /* Certificate */
 104 #define ISAKMP_NPTYPE_CR     7 /* Certificate Request */
 105 #define ISAKMP_NPTYPE_HASH   8 /* Hash */
 106 #define ISAKMP_NPTYPE_SIG    9 /* Signature */
 107 #define ISAKMP_NPTYPE_NONCE 10 /* Nonce */
 108 #define ISAKMP_NPTYPE_N     11 /* Notification */
 109 #define ISAKMP_NPTYPE_D     12 /* Delete */
 110 #define ISAKMP_NPTYPE_VID   13 /* Vendor ID */
 111 #define ISAKMP_NPTYPE_v2E   46 /* v2 Encrypted payload */
 112
 113 #define IKEv1_MAJOR_VERSION  1
 114 #define IKEv1_MINOR_VERSION  0
 115
 116 #define IKEv2_MAJOR_VERSION  2
 117 #define IKEv2_MINOR_VERSION  0
 118
 119 /* Flags */
 120 #define ISAKMP_FLAG_E 0x01 /* Encryption Bit */
 121 #define ISAKMP_FLAG_C 0x02 /* Commit Bit */
 122 #define ISAKMP_FLAG_extra 0x04
 123
 124 /* IKEv2 */
 125 #define ISAKMP_FLAG_I (1 << 3)  /* (I)nitiator */
 126 #define ISAKMP_FLAG_V (1 << 4)  /* (V)ersion   */
 127 #define ISAKMP_FLAG_R (1 << 5)  /* (R)esponse  */
 128
 129
 130 /* 3.2 Payload Generic Header
 131          0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 132         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 133         ! Next Payload  !   RESERVED    !         Payload Length        !
 134         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 135 */
 136 struct isakmp_gen {
 137         nd_uint8_t  np;       /* Next Payload */
 138         nd_uint8_t  critical; /* bit 7 - critical, rest is RESERVED */
 139         nd_uint16_t len;      /* Payload Length */
 140 };
 141
 142 /* 3.3 Data Attributes
 143          0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 144         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 145         !A!       Attribute Type        !    AF=0  Attribute Length     !
 146         !F!                             !    AF=1  Attribute Value      !
 147         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 148         .                   AF=0  Attribute Value                       .
 149         .                   AF=1  Not Transmitted                       .
 150         +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 151 */
 152 struct isakmp_data {
 153         nd_uint16_t type;     /* defined by DOI-spec, and Attribute Format */
 154         nd_uint16_t lorv;     /* if f equal 1, Attribute Length */
 155                               /* if f equal 0, Attribute Value */
 156         /* if f equal 1, Attribute Value */
 157 };
 158
 159 /* 3.4 Security Association Payload */
 160         /* MAY NOT be used, because of being defined in ipsec-doi. */
 161         /*
 162         If the current payload is the last in the message,
 163         then the value of the next payload field will be 0.
 164         This field MUST NOT contain the
 165         values for the Proposal or Transform payloads as they are considered
 166         part of the security association negotiation.  For example, this
 167         field would contain the value "10" (Nonce payload) in the first
 168         message of a Base Exchange (see Section 4.4) and the value "0" in the
 169         first message of an Identity Protect Exchange (see Section 4.5).
 170         */
 171 struct ikev1_pl_sa {
 172         struct isakmp_gen h;
 173         nd_uint32_t doi; /* Domain of Interpretation */
 174         nd_uint32_t sit; /* Situation */
 175 };
 176
 177 /* 3.5 Proposal Payload */
 178         /*
 179         The value of the next payload field MUST only contain the value "2"
 180         or "0".  If there are additional Proposal payloads in the message,
 181         then this field will be 2.  If the current Proposal payload is the
 182         last within the security association proposal, then this field will
 183         be 0.
 184         */
 185 struct ikev1_pl_p {
 186         struct isakmp_gen h;
 187         nd_uint8_t p_no;      /* Proposal # */
 188         nd_uint8_t prot_id;   /* Protocol */
 189         nd_uint8_t spi_size;  /* SPI Size */
 190         nd_uint8_t num_t;     /* Number of Transforms */
 191         /* SPI */
 192 };
 193
 194 /* 3.6 Transform Payload */
 195         /*
 196         The value of the next payload field MUST only contain the value "3"
 197         or "0".  If there are additional Transform payloads in the proposal,
 198         then this field will be 3.  If the current Transform payload is the
 199         last within the proposal, then this field will be 0.
 200         */
 201 struct ikev1_pl_t {
 202         struct isakmp_gen h;
 203         nd_uint8_t  t_no;        /* Transform # */
 204         nd_uint8_t  t_id;        /* Transform-Id */
 205         nd_byte     reserved[2]; /* RESERVED2 */
 206         /* SA Attributes */
 207 };
 208
 209 /* 3.7 Key Exchange Payload */
 210 struct ikev1_pl_ke {
 211         struct isakmp_gen h;
 212         /* Key Exchange Data */
 213 };
 214
 215 /* 3.8 Identification Payload */
 216         /* MUST NOT to be used, because of being defined in ipsec-doi. */
 217 struct ikev1_pl_id {
 218         struct isakmp_gen h;
 219         union {
 220                 nd_uint8_t  id_type;   /* ID Type */
 221                 nd_uint32_t doi_data;  /* DOI Specific ID Data */
 222         } d;
 223         /* Identification Data */
 224 };
 225
 226 /* 3.9 Certificate Payload */
 227 struct ikev1_pl_cert {
 228         struct isakmp_gen h;
 229         nd_uint8_t encode; /* Cert Encoding */
 230         nd_uint8_t cert;   /* Certificate Data */
 231                 /*
 232                 This field indicates the type of
 233                 certificate or certificate-related information contained in the
 234                 Certificate Data field.
 235                 */
 236 };
 237
 238 /* 3.10 Certificate Request Payload */
 239 struct ikev1_pl_cr {
 240         struct isakmp_gen h;
 241         nd_uint8_t num_cert; /* # Cert. Types */
 242         /*
 243         Certificate Types (variable length)
 244           -- Contains a list of the types of certificates requested,
 245           sorted in order of preference.  Each individual certificate
 246           type is 1 octet.  This field is NOT requiredo
 247         */
 248         /* # Certificate Authorities (1 octet) */
 249         /* Certificate Authorities (variable length) */
 250 };
 251
 252 /* 3.11 Hash Payload */
 253         /* may not be used, because of having only data. */
 254 struct ikev1_pl_hash {
 255         struct isakmp_gen h;
 256         /* Hash Data */
 257 };
 258
 259 /* 3.12 Signature Payload */
 260         /* may not be used, because of having only data. */
 261 struct ikev1_pl_sig {
 262         struct isakmp_gen h;
 263         /* Signature Data */
 264 };
 265
 266 /* 3.13 Nonce Payload */
 267         /* may not be used, because of having only data. */
 268 struct ikev1_pl_nonce {
 269         struct isakmp_gen h;
 270         /* Nonce Data */
 271 };
 272
 273 /* 3.14 Notification Payload */
 274 struct ikev1_pl_n {
 275         struct isakmp_gen h;
 276         nd_uint32_t doi;      /* Domain of Interpretation */
 277         nd_uint8_t  prot_id;  /* Protocol-ID */
 278         nd_uint8_t  spi_size; /* SPI Size */
 279         nd_uint16_t type;     /* Notify Message Type */
 280         /* SPI */
 281         /* Notification Data */
 282 };
 283
 284 /* 3.14.1 Notify Message Types */
 285 /* NOTIFY MESSAGES - ERROR TYPES */
 286 #define ISAKMP_NTYPE_INVALID_PAYLOAD_TYPE           1
 287 #define ISAKMP_NTYPE_DOI_NOT_SUPPORTED              2
 288 #define ISAKMP_NTYPE_SITUATION_NOT_SUPPORTED        3
 289 #define ISAKMP_NTYPE_INVALID_COOKIE                 4
 290 #define ISAKMP_NTYPE_INVALID_MAJOR_VERSION          5
 291 #define ISAKMP_NTYPE_INVALID_MINOR_VERSION          6
 292 #define ISAKMP_NTYPE_INVALID_EXCHANGE_TYPE          7
 293 #define ISAKMP_NTYPE_INVALID_FLAGS                  8
 294 #define ISAKMP_NTYPE_INVALID_MESSAGE_ID             9
 295 #define ISAKMP_NTYPE_INVALID_PROTOCOL_ID            10
 296 #define ISAKMP_NTYPE_INVALID_SPI                    11
 297 #define ISAKMP_NTYPE_INVALID_TRANSFORM_ID           12
 298 #define ISAKMP_NTYPE_ATTRIBUTES_NOT_SUPPORTED       13
 299 #define ISAKMP_NTYPE_NO_PROPOSAL_CHOSEN             14
 300 #define ISAKMP_NTYPE_BAD_PROPOSAL_SYNTAX            15
 301 #define ISAKMP_NTYPE_PAYLOAD_MALFORMED              16
 302 #define ISAKMP_NTYPE_INVALID_KEY_INFORMATION        17
 303 #define ISAKMP_NTYPE_INVALID_ID_INFORMATION         18
 304 #define ISAKMP_NTYPE_INVALID_CERT_ENCODING          19
 305 #define ISAKMP_NTYPE_INVALID_CERTIFICATE            20
 306 #define ISAKMP_NTYPE_BAD_CERT_REQUEST_SYNTAX        21
 307 #define ISAKMP_NTYPE_INVALID_CERT_AUTHORITY         22
 308 #define ISAKMP_NTYPE_INVALID_HASH_INFORMATION       23
 309 #define ISAKMP_NTYPE_AUTHENTICATION_FAILED          24
 310 #define ISAKMP_NTYPE_INVALID_SIGNATURE              25
 311 #define ISAKMP_NTYPE_ADDRESS_NOTIFICATION           26
 312
 313 /* 3.15 Delete Payload */
 314 struct ikev1_pl_d {
 315         struct isakmp_gen h;
 316         nd_uint32_t doi;      /* Domain of Interpretation */
 317         nd_uint8_t  prot_id;  /* Protocol-Id */
 318         nd_uint8_t  spi_size; /* SPI Size */
 319         nd_uint16_t num_spi;  /* # of SPIs */
 320         /* SPI(es) */
 321 };
 322
 323 /* IKEv2 (RFC4306) */
 324
 325 /* 3.3  Security Association Payload -- generic header */
 326 /* 3.3.1.  Proposal Substructure */
 327 struct ikev2_p {
 328         struct isakmp_gen h;
 329         nd_uint8_t p_no;      /* Proposal # */
 330         nd_uint8_t prot_id;   /* Protocol */
 331         nd_uint8_t spi_size;  /* SPI Size */
 332         nd_uint8_t num_t;     /* Number of Transforms */
 333 };
 334
 335 /* 3.3.2.  Transform Substructure */
 336 struct ikev2_t {
 337         struct isakmp_gen h;
 338         nd_uint8_t  t_type;    /* Transform Type (ENCR,PRF,INTEG,etc.*/
 339         nd_byte     res2;      /* reserved byte */
 340         nd_uint16_t t_id;     /* Transform ID */
 341 };
 342
 343 enum ikev2_t_type {
 344         IV2_T_ENCR = 1,
 345         IV2_T_PRF  = 2,
 346         IV2_T_INTEG= 3,
 347         IV2_T_DH   = 4,
 348         IV2_T_ESN  = 5
 349 };
 350
 351 /* 3.4.  Key Exchange Payload */
 352 struct ikev2_ke {
 353         struct isakmp_gen h;
 354         nd_uint16_t  ke_group;
 355         nd_uint16_t  ke_res1;
 356         /* KE data */
 357 };
 358
 359
 360 /* 3.5.  Identification Payloads */
 361 enum ikev2_id_type {
 362         ID_IPV4_ADDR=1,
 363         ID_FQDN=2,
 364         ID_RFC822_ADDR=3,
 365         ID_IPV6_ADDR=5,
 366         ID_DER_ASN1_DN=9,
 367         ID_DER_ASN1_GN=10,
 368         ID_KEY_ID=11
 369 };
 370 struct ikev2_id {
 371         struct isakmp_gen h;
 372         nd_uint8_t type;        /* ID type */
 373         nd_byte    res1;
 374         nd_byte    res2[2];
 375         /* SPI */
 376         /* Notification Data */
 377 };
 378
 379 /* 3.10 Notification Payload */
 380 struct ikev2_n {
 381         struct isakmp_gen h;
 382         nd_uint8_t  prot_id;  /* Protocol-ID */
 383         nd_uint8_t  spi_size; /* SPI Size */
 384         nd_uint16_t type;     /* Notify Message Type */
 385 };
 386
 387 enum ikev2_n_type {
 388         IV2_NOTIFY_UNSUPPORTED_CRITICAL_PAYLOAD            = 1,
 389         IV2_NOTIFY_INVALID_IKE_SPI                         = 4,
 390         IV2_NOTIFY_INVALID_MAJOR_VERSION                   = 5,
 391         IV2_NOTIFY_INVALID_SYNTAX                          = 7,
 392         IV2_NOTIFY_INVALID_MESSAGE_ID                      = 9,
 393         IV2_NOTIFY_INVALID_SPI                             =11,
 394         IV2_NOTIFY_NO_PROPOSAL_CHOSEN                      =14,
 395         IV2_NOTIFY_INVALID_KE_PAYLOAD                      =17,
 396         IV2_NOTIFY_AUTHENTICATION_FAILED                   =24,
 397         IV2_NOTIFY_SINGLE_PAIR_REQUIRED                    =34,
 398         IV2_NOTIFY_NO_ADDITIONAL_SAS                       =35,
 399         IV2_NOTIFY_INTERNAL_ADDRESS_FAILURE                =36,
 400         IV2_NOTIFY_FAILED_CP_REQUIRED                      =37,
 401         IV2_NOTIFY_INVALID_SELECTORS                       =39,
 402         IV2_NOTIFY_INITIAL_CONTACT                         =16384,
 403         IV2_NOTIFY_SET_WINDOW_SIZE                         =16385,
 404         IV2_NOTIFY_ADDITIONAL_TS_POSSIBLE                  =16386,
 405         IV2_NOTIFY_IPCOMP_SUPPORTED                        =16387,
 406         IV2_NOTIFY_NAT_DETECTION_SOURCE_IP                 =16388,
 407         IV2_NOTIFY_NAT_DETECTION_DESTINATION_IP            =16389,
 408         IV2_NOTIFY_COOKIE                                  =16390,
 409         IV2_NOTIFY_USE_TRANSPORT_MODE                      =16391,
 410         IV2_NOTIFY_HTTP_CERT_LOOKUP_SUPPORTED              =16392,
 411         IV2_NOTIFY_REKEY_SA                                =16393,
 412         IV2_NOTIFY_ESP_TFC_PADDING_NOT_SUPPORTED           =16394,
 413         IV2_NOTIFY_NON_FIRST_FRAGMENTS_ALSO                =16395
 414 };
 415
 416 struct notify_messages {
 417         uint16_t type;
 418         char     *msg;
 419 };
 420
 421 /* 3.8 Authentication Payload */
 422 struct ikev2_auth {
 423         struct isakmp_gen h;
 424         nd_uint8_t  auth_method;  /* Protocol-ID */
 425         nd_byte     reserved[3];
 426         /* authentication data */
 427 };
 428
 429 enum ikev2_auth_type {
 430         IV2_RSA_SIG = 1,
 431         IV2_SHARED  = 2,
 432         IV2_DSS_SIG = 3
 433 };
 434
 435 /* refer to RFC 2409 */
 436
 437 #if 0
 438 /* isakmp sa structure */
 439 struct oakley_sa {
 440         uint8_t  proto_id;            /* OAKLEY */
 441         vchar_t   *spi;                /* spi */
 442         uint8_t  dhgrp;               /* DH; group */
 443         uint8_t  auth_t;              /* method of authentication */
 444         uint8_t  prf_t;               /* type of prf */
 445         uint8_t  hash_t;              /* type of hash */
 446         uint8_t  enc_t;               /* type of cipher */
 447         uint8_t  life_t;              /* type of duration of lifetime */
 448         uint32_t ldur;                /* life duration */
 449 };
 450 #endif
 451
 452 /* refer to RFC 2407 */
 453
 454 #define IPSEC_DOI 1
 455
 456 /* 4.2 IPSEC Situation Definition */
 457 #define IPSECDOI_SIT_IDENTITY_ONLY           0x00000001
 458 #define IPSECDOI_SIT_SECRECY                 0x00000002
 459 #define IPSECDOI_SIT_INTEGRITY               0x00000004
 460
 461 /* 4.4.1 IPSEC Security Protocol Identifiers */
 462   /* 4.4.2 IPSEC ISAKMP Transform Values */
 463 #define IPSECDOI_PROTO_ISAKMP                        1
 464 #define   IPSECDOI_KEY_IKE                             1
 465
 466 /* 4.4.1 IPSEC Security Protocol Identifiers */
 467 #define IPSECDOI_PROTO_IPSEC_AH                      2
 468   /* 4.4.3 IPSEC AH Transform Values */
 469 #define   IPSECDOI_AH_MD5                              2
 470 #define   IPSECDOI_AH_SHA                              3
 471 #define   IPSECDOI_AH_DES                              4
 472 #define   IPSECDOI_AH_SHA2_256                         5
 473 #define   IPSECDOI_AH_SHA2_384                         6
 474 #define   IPSECDOI_AH_SHA2_512                         7
 475
 476 /* 4.4.1 IPSEC Security Protocol Identifiers */
 477 #define IPSECDOI_PROTO_IPSEC_ESP                     3
 478   /* 4.4.4 IPSEC ESP Transform Identifiers */
 479 #define   IPSECDOI_ESP_DES_IV64                        1
 480 #define   IPSECDOI_ESP_DES                             2
 481 #define   IPSECDOI_ESP_3DES                            3
 482 #define   IPSECDOI_ESP_RC5                             4
 483 #define   IPSECDOI_ESP_IDEA                            5
 484 #define   IPSECDOI_ESP_CAST                            6
 485 #define   IPSECDOI_ESP_BLOWFISH                        7
 486 #define   IPSECDOI_ESP_3IDEA                           8
 487 #define   IPSECDOI_ESP_DES_IV32                        9
 488 #define   IPSECDOI_ESP_RC4                            10
 489 #define   IPSECDOI_ESP_NULL                           11
 490 #define   IPSECDOI_ESP_RIJNDAEL                         12
 491 #define   IPSECDOI_ESP_AES                              12
 492
 493 /* 4.4.1 IPSEC Security Protocol Identifiers */
 494 #define IPSECDOI_PROTO_IPCOMP                        4
 495   /* 4.4.5 IPSEC IPCOMP Transform Identifiers */
 496 #define   IPSECDOI_IPCOMP_OUI                          1
 497 #define   IPSECDOI_IPCOMP_DEFLATE                      2
 498 #define   IPSECDOI_IPCOMP_LZS                          3
 499
 500 /* 4.5 IPSEC Security Association Attributes */
 501 #define IPSECDOI_ATTR_SA_LTYPE                1 /* B */
 502 #define   IPSECDOI_ATTR_SA_LTYPE_DEFAULT        1
 503 #define   IPSECDOI_ATTR_SA_LTYPE_SEC            1
 504 #define   IPSECDOI_ATTR_SA_LTYPE_KB             2
 505 #define IPSECDOI_ATTR_SA_LDUR                 2 /* V */
 506 #define   IPSECDOI_ATTR_SA_LDUR_DEFAULT         28800 /* 8 hours */
 507 #define IPSECDOI_ATTR_GRP_DESC                3 /* B */
 508 #define IPSECDOI_ATTR_ENC_MODE                4 /* B */
 509         /* default value: host dependent */
 510 #define   IPSECDOI_ATTR_ENC_MODE_TUNNEL         1
 511 #define   IPSECDOI_ATTR_ENC_MODE_TRNS           2
 512 #define IPSECDOI_ATTR_AUTH                    5 /* B */
 513         /* 0 means not to use authentication. */
 514 #define   IPSECDOI_ATTR_AUTH_HMAC_MD5           1
 515 #define   IPSECDOI_ATTR_AUTH_HMAC_SHA1          2
 516 #define   IPSECDOI_ATTR_AUTH_DES_MAC            3
 517 #define   IPSECDOI_ATTR_AUTH_KPDK               4 /*RFC-1826(Key/Pad/Data/Key)*/
 518         /*
 519          * When negotiating ESP without authentication, the Auth
 520          * Algorithm attribute MUST NOT be included in the proposal.
 521          * When negotiating ESP without confidentiality, the Auth
 522          * Algorithm attribute MUST be included in the proposal and
 523          * the ESP transform ID must be ESP_NULL.
 524         */
 525 #define IPSECDOI_ATTR_KEY_LENGTH              6 /* B */
 526 #define IPSECDOI_ATTR_KEY_ROUNDS              7 /* B */
 527 #define IPSECDOI_ATTR_COMP_DICT_SIZE          8 /* B */
 528 #define IPSECDOI_ATTR_COMP_PRIVALG            9 /* V */
 529
 530 /* 4.6.1 Security Association Payload */
 531 struct ipsecdoi_sa {
 532         struct isakmp_gen h;
 533         nd_uint32_t doi; /* Domain of Interpretation */
 534         nd_uint32_t sit; /* Situation */
 535 };
 536
 537 struct ipsecdoi_secrecy_h {
 538         nd_uint16_t len;
 539         nd_uint16_t reserved;
 540 };
 541
 542 /* 4.6.2.1 Identification Type Values */
 543 struct ipsecdoi_id {
 544         struct isakmp_gen h;
 545         nd_uint8_t  type;       /* ID Type */
 546         nd_uint8_t  proto_id;   /* Protocol ID */
 547         nd_uint16_t port;       /* Port */
 548         /* Identification Data */
 549 };
 550
 551 #define IPSECDOI_ID_IPV4_ADDR                        1
 552 #define IPSECDOI_ID_FQDN                             2
 553 #define IPSECDOI_ID_USER_FQDN                        3
 554 #define IPSECDOI_ID_IPV4_ADDR_SUBNET                 4
 555 #define IPSECDOI_ID_IPV6_ADDR                        5
 556 #define IPSECDOI_ID_IPV6_ADDR_SUBNET                 6
 557 #define IPSECDOI_ID_IPV4_ADDR_RANGE                  7
 558 #define IPSECDOI_ID_IPV6_ADDR_RANGE                  8
 559 #define IPSECDOI_ID_DER_ASN1_DN                      9
 560 #define IPSECDOI_ID_DER_ASN1_GN                      10
 561 #define IPSECDOI_ID_KEY_ID                           11
 562
 563 /* 4.6.3 IPSEC DOI Notify Message Types */
 564 /* Notify Messages - Status Types */
 565 #define IPSECDOI_NTYPE_RESPONDER_LIFETIME                  24576
 566 #define IPSECDOI_NTYPE_REPLAY_STATUS                       24577
 567 #define IPSECDOI_NTYPE_INITIAL_CONTACT                     24578
 568
 569 #define DECLARE_PRINTER(func) static const u_char *ike##func##_print( \
 570                 netdissect_options *ndo, u_char tpay,                 \
 571                 const struct isakmp_gen *ext,                         \
 572                 u_int item_len, \
 573                 const u_char *end_pointer, \
 574                 uint32_t phase,\
 575                 uint32_t doi0, \
 576                 uint32_t proto0, int depth)
 577
 578 DECLARE_PRINTER(v1_sa);
 579 DECLARE_PRINTER(v1_p);
 580 DECLARE_PRINTER(v1_t);
 581 DECLARE_PRINTER(v1_ke);
 582 DECLARE_PRINTER(v1_id);
 583 DECLARE_PRINTER(v1_cert);
 584 DECLARE_PRINTER(v1_cr);
 585 DECLARE_PRINTER(v1_sig);
 586 DECLARE_PRINTER(v1_hash);
 587 DECLARE_PRINTER(v1_nonce);
 588 DECLARE_PRINTER(v1_n);
 589 DECLARE_PRINTER(v1_d);
 590 DECLARE_PRINTER(v1_vid);
 591
 592 DECLARE_PRINTER(v2_sa);
 593 DECLARE_PRINTER(v2_ke);
 594 DECLARE_PRINTER(v2_ID);
 595 DECLARE_PRINTER(v2_cert);
 596 DECLARE_PRINTER(v2_cr);
 597 DECLARE_PRINTER(v2_auth);
 598 DECLARE_PRINTER(v2_nonce);
 599 DECLARE_PRINTER(v2_n);
 600 DECLARE_PRINTER(v2_d);
 601 DECLARE_PRINTER(v2_vid);
 602 DECLARE_PRINTER(v2_TS);
 603 DECLARE_PRINTER(v2_cp);
 604 DECLARE_PRINTER(v2_eap);
 605
 606 static const u_char *ikev2_e_print(netdissect_options *ndo,
 607                                    const struct isakmp *base,
 608                                    u_char tpay,
 609                                    const struct isakmp_gen *ext,
 610                                    u_int item_len,
 611                                    const u_char *end_pointer,
 612                                    uint32_t phase,
 613                                    uint32_t doi0,
 614                                    uint32_t proto0, int depth);
 615
 616
 617 static const u_char *ike_sub0_print(netdissect_options *ndo,u_char, const struct isakmp_gen *,
 618         const u_char *, uint32_t, uint32_t, uint32_t, int);
 619 static const u_char *ikev1_sub_print(netdissect_options *ndo,u_char, const struct isakmp_gen *,
 620         const u_char *, uint32_t, uint32_t, uint32_t, int);
 621
 622 static const u_char *ikev2_sub_print(netdissect_options *ndo,
 623                                      const struct isakmp *base,
 624                                      u_char np, const struct isakmp_gen *ext,
 625                                      const u_char *ep, uint32_t phase,
 626                                      uint32_t doi, uint32_t proto,
 627                                      int depth);
 628
 629
 630 static char *numstr(u_int);
 631
 632 static void
 633 ikev1_print(netdissect_options *ndo,
 634             const u_char *bp,  u_int length,
 635             const u_char *bp2, const struct isakmp *base);
 636
 637 #define MAXINITIATORS   20
 638 static int ninitiator = 0;
 639 union inaddr_u {
 640         nd_ipv4 in4;
 641         nd_ipv6 in6;
 642 };
 643 static struct {
 644         cookie_t initiator;
 645         u_int version;
 646         union inaddr_u iaddr;
 647         union inaddr_u raddr;
 648 } cookiecache[MAXINITIATORS];
 649
 650 /* protocol id */
 651 static const char *protoidstr[] = {
 652         NULL, "isakmp", "ipsec-ah", "ipsec-esp", "ipcomp",
 653 };
 654
 655 /* isakmp->np */
 656 static const char *npstr[] = {
 657         "none", "sa", "p", "t", "ke", "id", "cert", "cr", "hash", /* 0 - 8 */
 658         "sig", "nonce", "n", "d", "vid",      /* 9 - 13 */
 659         "pay14", "pay15", "pay16", "pay17", "pay18", /* 14- 18 */
 660         "pay19", "pay20", "pay21", "pay22", "pay23", /* 19- 23 */
 661         "pay24", "pay25", "pay26", "pay27", "pay28", /* 24- 28 */
 662         "pay29", "pay30", "pay31", "pay32",          /* 29- 32 */
 663         "v2sa",  "v2ke",  "v2IDi", "v2IDr", "v2cert",/* 33- 37 */
 664         "v2cr",  "v2auth","v2nonce", "v2n",   "v2d",   /* 38- 42 */
 665         "v2vid", "v2TSi", "v2TSr", "v2e",   "v2cp",  /* 43- 47 */
 666         "v2eap",                                     /* 48 */
 667
 668 };
 669
 670 /* isakmp->np */
 671 static const u_char *(*npfunc[])(netdissect_options *ndo, u_char tpay,
 672                                  const struct isakmp_gen *ext,
 673                                  u_int item_len,
 674                                  const u_char *end_pointer,
 675                                  uint32_t phase,
 676                                  uint32_t doi0,
 677                                  uint32_t proto0, int depth) = {
 678         NULL,
 679         ikev1_sa_print,
 680         ikev1_p_print,
 681         ikev1_t_print,
 682         ikev1_ke_print,
 683         ikev1_id_print,
 684         ikev1_cert_print,
 685         ikev1_cr_print,
 686         ikev1_hash_print,
 687         ikev1_sig_print,
 688         ikev1_nonce_print,
 689         ikev1_n_print,
 690         ikev1_d_print,
 691         ikev1_vid_print,                  /* 13 */
 692         NULL, NULL, NULL, NULL, NULL,     /* 14- 18 */
 693         NULL, NULL, NULL, NULL, NULL,     /* 19- 23 */
 694         NULL, NULL, NULL, NULL, NULL,     /* 24- 28 */
 695         NULL, NULL, NULL, NULL,           /* 29- 32 */
 696         ikev2_sa_print,                 /* 33 */
 697         ikev2_ke_print,                 /* 34 */
 698         ikev2_ID_print,                 /* 35 */
 699         ikev2_ID_print,                 /* 36 */
 700         ikev2_cert_print,               /* 37 */
 701         ikev2_cr_print,                 /* 38 */
 702         ikev2_auth_print,               /* 39 */
 703         ikev2_nonce_print,              /* 40 */
 704         ikev2_n_print,                  /* 41 */
 705         ikev2_d_print,                  /* 42 */
 706         ikev2_vid_print,                /* 43 */
 707         ikev2_TS_print,                 /* 44 */
 708         ikev2_TS_print,                 /* 45 */
 709         NULL, /* ikev2_e_print,*/       /* 46 - special */
 710         ikev2_cp_print,                 /* 47 */
 711         ikev2_eap_print,                /* 48 */
 712 };
 713
 714 /* isakmp->etype */
 715 static const char *etypestr[] = {
 716 /* IKEv1 exchange types */
 717         "none", "base", "ident", "auth", "agg", "inf", NULL, NULL,  /* 0-7 */
 718         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,  /*  8-15 */
 719         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,  /* 16-23 */
 720         NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,  /* 24-31 */
 721         "oakley-quick", "oakley-newgroup",               /* 32-33 */
 722 /* IKEv2 exchange types */
 723         "ikev2_init", "ikev2_auth", "child_sa", "inf2"   /* 34-37 */
 724 };
 725
 726 #define STR_OR_ID(x, tab) \
 727         (((x) < sizeof(tab)/sizeof(tab[0]) && tab[(x)]) ? tab[(x)] : numstr(x))
 728 #define PROTOIDSTR(x)   STR_OR_ID(x, protoidstr)
 729 #define NPSTR(x)        STR_OR_ID(x, npstr)
 730 #define ETYPESTR(x)     STR_OR_ID(x, etypestr)
 731
 732 #define CHECKLEN(p, np)                                                 \
 733                 if (ep < (const u_char *)(p)) {                         \
 734                         ND_PRINT(" [|%s]", NPSTR(np));          \
 735                         goto done;                                      \
 736                 }
 737
 738
 739 #define NPFUNC(x) \
 740         (((x) < sizeof(npfunc)/sizeof(npfunc[0]) && npfunc[(x)]) \
 741                 ? npfunc[(x)] : NULL)
 742
 743 static int
 744 iszero(const u_char *p, size_t l)
 745 {
 746         while (l != 0) {
 747                 if (*p)
 748                         return 0;
 749                 p++;
 750                 l--;
 751         }
 752         return 1;
 753 }
 754
 755 /* find cookie from initiator cache */
 756 static int
 757 cookie_find(const cookie_t *in)
 758 {
 759         int i;
 760
 761         for (i = 0; i < MAXINITIATORS; i++) {
 762                 if (memcmp(in, &cookiecache[i].initiator, sizeof(*in)) == 0)
 763                         return i;
 764         }
 765
 766         return -1;
 767 }
 768
 769 /* record initiator */
 770 static void
 771 cookie_record(netdissect_options *ndo, const cookie_t *in, const u_char *bp2)
 772 {
 773         int i;
 774         const struct ip *ip;
 775         const struct ip6_hdr *ip6;
 776
 777         i = cookie_find(in);
 778         if (0 <= i) {
 779                 ninitiator = (i + 1) % MAXINITIATORS;
 780                 return;
 781         }
 782
 783         ip = (const struct ip *)bp2;
 784         switch (IP_V(ip)) {
 785         case 4:
 786                 cookiecache[ninitiator].version = 4;
 787                 UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in4,
 788                                  ip->ip_src, sizeof(nd_ipv4));
 789                 UNALIGNED_MEMCPY(&cookiecache[ninitiator].raddr.in4,
 790                                  ip->ip_dst, sizeof(nd_ipv4));
 791                 break;
 792         case 6:
 793                 ip6 = (const struct ip6_hdr *)bp2;
 794                 cookiecache[ninitiator].version = 6;
 795                 UNALIGNED_MEMCPY(&cookiecache[ninitiator].iaddr.in6,
 796                                  ip6->ip6_src, sizeof(nd_ipv6));
 797                 UNALIGNED_MEMCPY(&cookiecache[ninitiator].raddr.in6,
 798                                  ip6->ip6_dst, sizeof(nd_ipv6));
 799                 break;
 800         default:
 801                 return;
 802         }
 803         UNALIGNED_MEMCPY(&cookiecache[ninitiator].initiator, in, sizeof(*in));
 804         ninitiator = (ninitiator + 1) % MAXINITIATORS;
 805 }
 806
 807 #define cookie_isinitiator(ndo, x, y)   cookie_sidecheck(ndo, (x), (y), 1)
 808 #define cookie_isresponder(ndo, x, y)   cookie_sidecheck(ndo, (x), (y), 0)
 809 static int
 810 cookie_sidecheck(netdissect_options *ndo, int i, const u_char *bp2, int initiator)
 811 {
 812         const struct ip *ip;
 813         const struct ip6_hdr *ip6;
 814
 815         ip = (const struct ip *)bp2;
 816         switch (IP_V(ip)) {
 817         case 4:
 818                 if (cookiecache[i].version != 4)
 819                         return 0;
 820                 if (initiator) {
 821                         if (UNALIGNED_MEMCMP(ip->ip_src, &cookiecache[i].iaddr.in4, sizeof(nd_ipv4)) == 0)
 822                                 return 1;
 823                 } else {
 824                         if (UNALIGNED_MEMCMP(ip->ip_src, &cookiecache[i].raddr.in4, sizeof(nd_ipv4)) == 0)
 825                                 return 1;
 826                 }
 827                 break;
 828         case 6:
 829                 if (cookiecache[i].version != 6)
 830                         return 0;
 831                 ip6 = (const struct ip6_hdr *)bp2;
 832                 if (initiator) {
 833                         if (UNALIGNED_MEMCMP(ip6->ip6_src, &cookiecache[i].iaddr.in6, sizeof(nd_ipv6)) == 0)
 834                                 return 1;
 835                 } else {
 836                         if (UNALIGNED_MEMCMP(ip6->ip6_src, &cookiecache[i].raddr.in6, sizeof(nd_ipv6)) == 0)
 837                                 return 1;
 838                 }
 839                 break;
 840         default:
 841                 break;
 842         }
 843
 844         return 0;
 845 }
 846
 847 static void
 848 hexprint(netdissect_options *ndo, const uint8_t *loc, size_t len)
 849 {
 850         const uint8_t *p;
 851         size_t i;
 852
 853         p = loc;
 854         for (i = 0; i < len; i++)
 855                 ND_PRINT("%02x", p[i] & 0xff);
 856 }
 857
 858 static int
 859 rawprint(netdissect_options *ndo, const uint8_t *loc, size_t len)
 860 {
 861         ND_TCHECK_LEN(loc, len);
 862
 863         hexprint(ndo, loc, len);
 864         return 1;
 865 trunc:
 866         return 0;
 867 }
 868
 869
 870 /*
 871  * returns false if we run out of data buffer
 872  */
 873 static int ike_show_somedata(netdissect_options *ndo,
 874                              const u_char *cp, const u_char *ep)
 875 {
 876         /* there is too much data, just show some of it */
 877         const u_char *end = ep - 20;
 878         size_t  elen = 20;
 879         size_t  len = ep - cp;
 880         if(len > 10) {
 881                 len = 10;
 882         }
 883
 884         /* really shouldn't happen because of above */
 885         if(end < cp + len) {
 886                 end = cp+len;
 887                 elen = ep - end;
 888         }
 889
 890         ND_PRINT(" data=(");
 891         if(!rawprint(ndo, (const uint8_t *)(cp), len)) goto trunc;
 892         ND_PRINT("...");
 893         if(elen) {
 894                 if(!rawprint(ndo, (const uint8_t *)(end), elen)) goto trunc;
 895         }
 896         ND_PRINT(")");
 897         return 1;
 898
 899 trunc:
 900         return 0;
 901 }
 902
 903 struct attrmap {
 904         const char *type;
 905         u_int nvalue;
 906         const char *value[30];  /*XXX*/
 907 };
 908
 909 static const u_char *
 910 ikev1_attrmap_print(netdissect_options *ndo,
 911                     const u_char *p, const u_char *ep2,
 912                     const struct attrmap *map, size_t nmap)
 913 {
 914         u_int totlen;
 915         uint32_t t, v;
 916
 917         if (GET_U_1(p) & 0x80)
 918                 totlen = 4;
 919         else {
 920                 totlen = 4 + GET_BE_U_2(p + 2);
 921         }
 922         if (ep2 < p + totlen) {
 923                 ND_PRINT("[|attr]");
 924                 return ep2 + 1;
 925         }
 926
 927         ND_PRINT("(");
 928         t = GET_BE_U_2(p) & 0x7fff;
 929         if (map && t < nmap && map[t].type)
 930                 ND_PRINT("type=%s ", map[t].type);
 931         else
 932                 ND_PRINT("type=#%u ", t);
 933         if (GET_U_1(p) & 0x80) {
 934                 ND_PRINT("value=");
 935                 v = GET_BE_U_2(p + 2);
 936                 if (map && t < nmap && v < map[t].nvalue && map[t].value[v])
 937                         ND_PRINT("%s", map[t].value[v]);
 938                 else {
 939                         if (!rawprint(ndo, (const uint8_t *)(p + 2), 2)) {
 940                                 ND_PRINT(")");
 941                                 goto trunc;
 942                         }
 943                 }
 944         } else {
 945                 ND_PRINT("len=%u value=", totlen - 4);
 946                 if (!rawprint(ndo, (const uint8_t *)(p + 4), totlen - 4)) {
 947                         ND_PRINT(")");
 948                         goto trunc;
 949                 }
 950         }
 951         ND_PRINT(")");
 952         return p + totlen;
 953
 954 trunc:
 955         return NULL;
 956 }
 957
 958 static const u_char *
 959 ikev1_attr_print(netdissect_options *ndo, const u_char *p, const u_char *ep2)
 960 {
 961         u_int totlen;
 962         uint32_t t;
 963
 964         if (GET_U_1(p) & 0x80)
 965                 totlen = 4;
 966         else {
 967                 totlen = 4 + GET_BE_U_2(p + 2);
 968         }
 969         if (ep2 < p + totlen) {
 970                 ND_PRINT("[|attr]");
 971                 return ep2 + 1;
 972         }
 973
 974         ND_PRINT("(");
 975         t = GET_BE_U_2(p) & 0x7fff;
 976         ND_PRINT("type=#%u ", t);
 977         if (GET_U_1(p) & 0x80) {
 978                 ND_PRINT("value=");
 979                 t = GET_U_1(p + 2);
 980                 if (!rawprint(ndo, (const uint8_t *)(p + 2), 2)) {
 981                         ND_PRINT(")");
 982                         goto trunc;
 983                 }
 984         } else {
 985                 ND_PRINT("len=%u value=", totlen - 4);
 986                 if (!rawprint(ndo, (const uint8_t *)(p + 4), totlen - 4)) {
 987                         ND_PRINT(")");
 988                         goto trunc;
 989                 }
 990         }
 991         ND_PRINT(")");
 992         return p + totlen;
 993
 994 trunc:
 995         return NULL;
 996 }
 997
 998 static const u_char *
 999 ikev1_sa_print(netdissect_options *ndo, u_char tpay _U_,
1000                const struct isakmp_gen *ext,
1001                 u_int item_len _U_,
1002                 const u_char *ep, uint32_t phase, uint32_t doi0 _U_,
1003                 uint32_t proto0, int depth)
1004 {
1005         const struct ikev1_pl_sa *p;
1006         uint32_t doi, sit, ident;
1007         const u_char *cp, *np;
1008         int t;
1009
1010         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_SA));
1011
1012         p = (const struct ikev1_pl_sa *)ext;
1013         ND_TCHECK_SIZE(p);
1014         doi = GET_BE_U_4(p->doi);
1015         sit = GET_BE_U_4(p->sit);
1016         if (doi != 1) {
1017                 ND_PRINT(" doi=%u", doi);
1018                 ND_PRINT(" situation=%u", sit);
1019                 return (const u_char *)(p + 1);
1020         }
1021
1022         ND_PRINT(" doi=ipsec");
1023         ND_PRINT(" situation=");
1024         t = 0;
1025         if (sit & 0x01) {
1026                 ND_PRINT("identity");
1027                 t++;
1028         }
1029         if (sit & 0x02) {
1030                 ND_PRINT("%ssecrecy", t ? "+" : "");
1031                 t++;
1032         }
1033         if (sit & 0x04)
1034                 ND_PRINT("%sintegrity", t ? "+" : "");
1035
1036         np = (const u_char *)ext + sizeof(struct ikev1_pl_sa);
1037         if (sit != 0x01) {
1038                 ident = GET_BE_U_4(ext + 1);
1039                 ND_PRINT(" ident=%u", ident);
1040                 np += sizeof(ident);
1041         }
1042
1043         ext = (const struct isakmp_gen *)np;
1044         ND_TCHECK_SIZE(ext);
1045
1046         cp = ikev1_sub_print(ndo, ISAKMP_NPTYPE_P, ext, ep, phase, doi, proto0,
1047                 depth);
1048
1049         return cp;
1050 trunc:
1051         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_SA));
1052         return NULL;
1053 }
1054
1055 static const u_char *
1056 ikev1_p_print(netdissect_options *ndo, u_char tpay _U_,
1057               const struct isakmp_gen *ext, u_int item_len _U_,
1058                const u_char *ep, uint32_t phase, uint32_t doi0,
1059                uint32_t proto0 _U_, int depth)
1060 {
1061         const struct ikev1_pl_p *p;
1062         const u_char *cp;
1063         uint8_t spi_size;
1064
1065         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_P));
1066
1067         p = (const struct ikev1_pl_p *)ext;
1068         ND_TCHECK_SIZE(p);
1069         ND_PRINT(" #%u protoid=%s transform=%u",
1070                   GET_U_1(p->p_no), PROTOIDSTR(GET_U_1(p->prot_id)),
1071                   GET_U_1(p->num_t));
1072         spi_size = GET_U_1(p->spi_size);
1073         if (spi_size) {
1074                 ND_PRINT(" spi=");
1075                 if (!rawprint(ndo, (const uint8_t *)(p + 1), spi_size))
1076                         goto trunc;
1077         }
1078
1079         ext = (const struct isakmp_gen *)((const u_char *)(p + 1) + spi_size);
1080         ND_TCHECK_SIZE(ext);
1081
1082         cp = ikev1_sub_print(ndo, ISAKMP_NPTYPE_T, ext, ep, phase, doi0,
1083                              GET_U_1(p->prot_id), depth);
1084
1085         return cp;
1086 trunc:
1087         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_P));
1088         return NULL;
1089 }
1090
1091 static const char *ikev1_p_map[] = {
1092         NULL, "ike",
1093 };
1094
1095 static const char *ikev2_t_type_map[]={
1096         NULL, "encr", "prf", "integ", "dh", "esn"
1097 };
1098
1099 static const char *ah_p_map[] = {
1100         NULL, "(reserved)", "md5", "sha", "1des",
1101         "sha2-256", "sha2-384", "sha2-512",
1102 };
1103
1104 static const char *prf_p_map[] = {
1105         NULL, "hmac-md5", "hmac-sha", "hmac-tiger",
1106         "aes128_xcbc"
1107 };
1108
1109 static const char *integ_p_map[] = {
1110         NULL, "hmac-md5", "hmac-sha", "dec-mac",
1111         "kpdk-md5", "aes-xcbc"
1112 };
1113
1114 static const char *esn_p_map[] = {
1115         "no-esn", "esn"
1116 };
1117
1118 static const char *dh_p_map[] = {
1119         NULL, "modp768",
1120         "modp1024",    /* group 2 */
1121         "EC2N 2^155",  /* group 3 */
1122         "EC2N 2^185",  /* group 4 */
1123         "modp1536",    /* group 5 */
1124         "iana-grp06", "iana-grp07", /* reserved */
1125         "iana-grp08", "iana-grp09",
1126         "iana-grp10", "iana-grp11",
1127         "iana-grp12", "iana-grp13",
1128         "modp2048",    /* group 14 */
1129         "modp3072",    /* group 15 */
1130         "modp4096",    /* group 16 */
1131         "modp6144",    /* group 17 */
1132         "modp8192",    /* group 18 */
1133 };
1134
1135 static const char *esp_p_map[] = {
1136         NULL, "1des-iv64", "1des", "3des", "rc5", "idea", "cast",
1137         "blowfish", "3idea", "1des-iv32", "rc4", "null", "aes"
1138 };
1139
1140 static const char *ipcomp_p_map[] = {
1141         NULL, "oui", "deflate", "lzs",
1142 };
1143
1144 static const struct attrmap ipsec_t_map[] = {
1145         { NULL, 0, { NULL } },
1146         { "lifetype", 3, { NULL, "sec", "kb", }, },
1147         { "life", 0, { NULL } },
1148         { "group desc", 18,     { NULL, "modp768",
1149                                   "modp1024",    /* group 2 */
1150                                   "EC2N 2^155",  /* group 3 */
1151                                   "EC2N 2^185",  /* group 4 */
1152                                   "modp1536",    /* group 5 */
1153                                   "iana-grp06", "iana-grp07", /* reserved */
1154                                   "iana-grp08", "iana-grp09",
1155                                   "iana-grp10", "iana-grp11",
1156                                   "iana-grp12", "iana-grp13",
1157                                   "modp2048",    /* group 14 */
1158                                   "modp3072",    /* group 15 */
1159                                   "modp4096",    /* group 16 */
1160                                   "modp6144",    /* group 17 */
1161                                   "modp8192",    /* group 18 */
1162                 }, },
1163         { "enc mode", 3, { NULL, "tunnel", "transport", }, },
1164         { "auth", 5, { NULL, "hmac-md5", "hmac-sha1", "1des-mac", "keyed", }, },
1165         { "keylen", 0, { NULL } },
1166         { "rounds", 0, { NULL } },
1167         { "dictsize", 0, { NULL } },
1168         { "privalg", 0, { NULL } },
1169 };
1170
1171 static const struct attrmap encr_t_map[] = {
1172         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 0, 1 */
1173         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 2, 3 */
1174         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 4, 5 */
1175         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 6, 7 */
1176         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 8, 9 */
1177         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 10,11*/
1178         { NULL, 0, { NULL } },  { NULL, 0, { NULL } },  /* 12,13*/
1179         { "keylen", 14, { NULL }},
1180 };
1181
1182 static const struct attrmap oakley_t_map[] = {
1183         { NULL, 0, { NULL } },
1184         { "enc", 8,     { NULL, "1des", "idea", "blowfish", "rc5",
1185                           "3des", "cast", "aes", }, },
1186         { "hash", 7,    { NULL, "md5", "sha1", "tiger",
1187                           "sha2-256", "sha2-384", "sha2-512", }, },
1188         { "auth", 6,    { NULL, "preshared", "dss", "rsa sig", "rsa enc",
1189                           "rsa enc revised", }, },
1190         { "group desc", 18,     { NULL, "modp768",
1191                                   "modp1024",    /* group 2 */
1192                                   "EC2N 2^155",  /* group 3 */
1193                                   "EC2N 2^185",  /* group 4 */
1194                                   "modp1536",    /* group 5 */
1195                                   "iana-grp06", "iana-grp07", /* reserved */
1196                                   "iana-grp08", "iana-grp09",
1197                                   "iana-grp10", "iana-grp11",
1198                                   "iana-grp12", "iana-grp13",
1199                                   "modp2048",    /* group 14 */
1200                                   "modp3072",    /* group 15 */
1201                                   "modp4096",    /* group 16 */
1202                                   "modp6144",    /* group 17 */
1203                                   "modp8192",    /* group 18 */
1204                 }, },
1205         { "group type", 4,      { NULL, "MODP", "ECP", "EC2N", }, },
1206         { "group prime", 0, { NULL } },
1207         { "group gen1", 0, { NULL } },
1208         { "group gen2", 0, { NULL } },
1209         { "group curve A", 0, { NULL } },
1210         { "group curve B", 0, { NULL } },
1211         { "lifetype", 3,        { NULL, "sec", "kb", }, },
1212         { "lifeduration", 0, { NULL } },
1213         { "prf", 0, { NULL } },
1214         { "keylen", 0, { NULL } },
1215         { "field", 0, { NULL } },
1216         { "order", 0, { NULL } },
1217 };
1218
1219 static const u_char *
1220 ikev1_t_print(netdissect_options *ndo, u_char tpay _U_,
1221               const struct isakmp_gen *ext, u_int item_len,
1222               const u_char *ep, uint32_t phase _U_, uint32_t doi _U_,
1223               uint32_t proto, int depth _U_)
1224 {
1225         const struct ikev1_pl_t *p;
1226         const u_char *cp;
1227         const char *idstr;
1228         const struct attrmap *map;
1229         size_t nmap;
1230         const u_char *ep2;
1231
1232         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_T));
1233
1234         p = (const struct ikev1_pl_t *)ext;
1235         ND_TCHECK_SIZE(p);
1236
1237         switch (proto) {
1238         case 1:
1239                 idstr = STR_OR_ID(GET_U_1(p->t_id), ikev1_p_map);
1240                 map = oakley_t_map;
1241                 nmap = sizeof(oakley_t_map)/sizeof(oakley_t_map[0]);
1242                 break;
1243         case 2:
1244                 idstr = STR_OR_ID(GET_U_1(p->t_id), ah_p_map);
1245                 map = ipsec_t_map;
1246                 nmap = sizeof(ipsec_t_map)/sizeof(ipsec_t_map[0]);
1247                 break;
1248         case 3:
1249                 idstr = STR_OR_ID(GET_U_1(p->t_id), esp_p_map);
1250                 map = ipsec_t_map;
1251                 nmap = sizeof(ipsec_t_map)/sizeof(ipsec_t_map[0]);
1252                 break;
1253         case 4:
1254                 idstr = STR_OR_ID(GET_U_1(p->t_id), ipcomp_p_map);
1255                 map = ipsec_t_map;
1256                 nmap = sizeof(ipsec_t_map)/sizeof(ipsec_t_map[0]);
1257                 break;
1258         default:
1259                 idstr = NULL;
1260                 map = NULL;
1261                 nmap = 0;
1262                 break;
1263         }
1264
1265         if (idstr)
1266                 ND_PRINT(" #%u id=%s ", GET_U_1(p->t_no), idstr);
1267         else
1268                 ND_PRINT(" #%u id=%u ", GET_U_1(p->t_no), GET_U_1(p->t_id));
1269         cp = (const u_char *)(p + 1);
1270         ep2 = (const u_char *)p + item_len;
1271         while (cp < ep && cp < ep2) {
1272                 if (map && nmap)
1273                         cp = ikev1_attrmap_print(ndo, cp, ep2, map, nmap);
1274                 else
1275                         cp = ikev1_attr_print(ndo, cp, ep2);
1276                 if (cp == NULL)
1277                         goto trunc;
1278         }
1279         if (ep < ep2)
1280                 ND_PRINT("...");
1281         return cp;
1282 trunc:
1283         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_T));
1284         return NULL;
1285 }
1286
1287 static const u_char *
1288 ikev1_ke_print(netdissect_options *ndo, u_char tpay _U_,
1289                const struct isakmp_gen *ext, u_int item_len,
1290                const u_char *ep _U_, uint32_t phase _U_, uint32_t doi _U_,
1291                uint32_t proto _U_, int depth _U_)
1292 {
1293         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_KE));
1294
1295         ND_TCHECK_SIZE(ext);
1296         /*
1297          * Our caller has ensured that the length is >= 4.
1298          */
1299         ND_PRINT(" key len=%u", item_len - 4);
1300         if (2 < ndo->ndo_vflag && item_len > 4) {
1301                 /* Print the entire payload in hex */
1302                 ND_PRINT(" ");
1303                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1304                         goto trunc;
1305         }
1306         return (const u_char *)ext + item_len;
1307 trunc:
1308         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_KE));
1309         return NULL;
1310 }
1311
1312 static const u_char *
1313 ikev1_id_print(netdissect_options *ndo, u_char tpay _U_,
1314                const struct isakmp_gen *ext, u_int item_len,
1315                const u_char *ep _U_, uint32_t phase, uint32_t doi _U_,
1316                uint32_t proto _U_, int depth _U_)
1317 {
1318 #define USE_IPSECDOI_IN_PHASE1  1
1319         const struct ikev1_pl_id *p;
1320         static const char *idtypestr[] = {
1321                 "IPv4", "IPv4net", "IPv6", "IPv6net",
1322         };
1323         static const char *ipsecidtypestr[] = {
1324                 NULL, "IPv4", "FQDN", "user FQDN", "IPv4net", "IPv6",
1325                 "IPv6net", "IPv4range", "IPv6range", "ASN1 DN", "ASN1 GN",
1326                 "keyid",
1327         };
1328         u_int len;
1329         const u_char *data;
1330
1331         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_ID));
1332
1333         p = (const struct ikev1_pl_id *)ext;
1334         ND_TCHECK_SIZE(p);
1335         if (sizeof(*p) < item_len) {
1336                 data = (const u_char *)(p + 1);
1337                 len = item_len - sizeof(*p);
1338         } else {
1339                 data = NULL;
1340                 len = 0;
1341         }
1342
1343 #if 0 /*debug*/
1344         ND_PRINT(" [phase=%u doi=%u proto=%u]", phase, doi, proto);
1345 #endif
1346         switch (phase) {
1347 #ifndef USE_IPSECDOI_IN_PHASE1
1348         case 1:
1349 #endif
1350         default:
1351                 ND_PRINT(" idtype=%s",
1352                          STR_OR_ID(GET_U_1(p->d.id_type), idtypestr));
1353                 ND_PRINT(" doi_data=%u",
1354                           GET_BE_U_4(p->d.doi_data) & 0xffffff);
1355                 break;
1356
1357 #ifdef USE_IPSECDOI_IN_PHASE1
1358         case 1:
1359 #endif
1360         case 2:
1361             {
1362                 const struct ipsecdoi_id *doi_p;
1363                 const char *p_name;
1364                 uint8_t type, proto_id;
1365
1366                 doi_p = (const struct ipsecdoi_id *)ext;
1367                 ND_TCHECK_SIZE(doi_p);
1368                 type = GET_U_1(doi_p->type);
1369                 ND_PRINT(" idtype=%s", STR_OR_ID(type, ipsecidtypestr));
1370                 /* A protocol ID of 0 DOES NOT mean IPPROTO_IP! */
1371                 proto_id = GET_U_1(doi_p->proto_id);
1372                 if (!ndo->ndo_nflag && proto_id && (p_name = netdb_protoname(proto_id)) != NULL)
1373                         ND_PRINT(" protoid=%s", p_name);
1374                 else
1375                         ND_PRINT(" protoid=%u", proto_id);
1376                 ND_PRINT(" port=%u", GET_BE_U_2(doi_p->port));
1377                 if (!len)
1378                         break;
1379                 if (data == NULL)
1380                         goto trunc;
1381                 ND_TCHECK_LEN(data, len);
1382                 switch (type) {
1383                 case IPSECDOI_ID_IPV4_ADDR:
1384                         if (len < 4)
1385                                 ND_PRINT(" len=%u [bad: < 4]", len);
1386                         else
1387                                 ND_PRINT(" len=%u %s", len, GET_IPADDR_STRING(data));
1388                         len = 0;
1389                         break;
1390                 case IPSECDOI_ID_FQDN:
1391                 case IPSECDOI_ID_USER_FQDN:
1392                     {
1393                         u_int i;
1394                         ND_PRINT(" len=%u ", len);
1395                         for (i = 0; i < len; i++)
1396                                 fn_print_char(ndo, GET_U_1(data + i));
1397                         len = 0;
1398                         break;
1399                     }
1400                 case IPSECDOI_ID_IPV4_ADDR_SUBNET:
1401                     {
1402                         const u_char *mask;
1403                         if (len < 8)
1404                                 ND_PRINT(" len=%u [bad: < 8]", len);
1405                         else {
1406                                 mask = data + sizeof(nd_ipv4);
1407                                 ND_PRINT(" len=%u %s/%u.%u.%u.%u", len,
1408                                           GET_IPADDR_STRING(data),
1409                                           GET_U_1(mask), GET_U_1(mask + 1),
1410                                           GET_U_1(mask + 2),
1411                                           GET_U_1(mask + 3));
1412                         }
1413                         len = 0;
1414                         break;
1415                     }
1416                 case IPSECDOI_ID_IPV6_ADDR:
1417                         if (len < 16)
1418                                 ND_PRINT(" len=%u [bad: < 16]", len);
1419                         else
1420                                 ND_PRINT(" len=%u %s", len, GET_IP6ADDR_STRING(data));
1421                         len = 0;
1422                         break;
1423                 case IPSECDOI_ID_IPV6_ADDR_SUBNET:
1424                     {
1425                         const u_char *mask;
1426                         if (len < 32)
1427                                 ND_PRINT(" len=%u [bad: < 32]", len);
1428                         else {
1429                                 mask = (const u_char *)(data + sizeof(nd_ipv6));
1430                                 /*XXX*/
1431                                 ND_PRINT(" len=%u %s/0x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", len,
1432                                           GET_IP6ADDR_STRING(data),
1433                                           GET_U_1(mask), GET_U_1(mask + 1),
1434                                           GET_U_1(mask + 2),
1435                                           GET_U_1(mask + 3),
1436                                           GET_U_1(mask + 4),
1437                                           GET_U_1(mask + 5),
1438                                           GET_U_1(mask + 6),
1439                                           GET_U_1(mask + 7),
1440                                           GET_U_1(mask + 8),
1441                                           GET_U_1(mask + 9),
1442                                           GET_U_1(mask + 10),
1443                                           GET_U_1(mask + 11),
1444                                           GET_U_1(mask + 12),
1445                                           GET_U_1(mask + 13),
1446                                           GET_U_1(mask + 14),
1447                                           GET_U_1(mask + 15));
1448                         }
1449                         len = 0;
1450                         break;
1451                     }
1452                 case IPSECDOI_ID_IPV4_ADDR_RANGE:
1453                         if (len < 8)
1454                                 ND_PRINT(" len=%u [bad: < 8]", len);
1455                         else {
1456                                 ND_PRINT(" len=%u %s-%s", len,
1457                                           GET_IPADDR_STRING(data),
1458                                           GET_IPADDR_STRING(data + sizeof(nd_ipv4)));
1459                         }
1460                         len = 0;
1461                         break;
1462                 case IPSECDOI_ID_IPV6_ADDR_RANGE:
1463                         if (len < 32)
1464                                 ND_PRINT(" len=%u [bad: < 32]", len);
1465                         else {
1466                                 ND_PRINT(" len=%u %s-%s", len,
1467                                           GET_IP6ADDR_STRING(data),
1468                                           GET_IP6ADDR_STRING(data + sizeof(nd_ipv6)));
1469                         }
1470                         len = 0;
1471                         break;
1472                 case IPSECDOI_ID_DER_ASN1_DN:
1473                 case IPSECDOI_ID_DER_ASN1_GN:
1474                 case IPSECDOI_ID_KEY_ID:
1475                         break;
1476                 }
1477                 break;
1478             }
1479         }
1480         if (data && len) {
1481                 ND_PRINT(" len=%u", len);
1482                 if (2 < ndo->ndo_vflag) {
1483                         ND_PRINT(" ");
1484                         if (!rawprint(ndo, (const uint8_t *)data, len))
1485                                 goto trunc;
1486                 }
1487         }
1488         return (const u_char *)ext + item_len;
1489 trunc:
1490         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_ID));
1491         return NULL;
1492 }
1493
1494 static const u_char *
1495 ikev1_cert_print(netdissect_options *ndo, u_char tpay _U_,
1496                  const struct isakmp_gen *ext, u_int item_len,
1497                  const u_char *ep _U_, uint32_t phase _U_,
1498                  uint32_t doi0 _U_,
1499                  uint32_t proto0 _U_, int depth _U_)
1500 {
1501         const struct ikev1_pl_cert *p;
1502         static const char *certstr[] = {
1503                 "none", "pkcs7", "pgp", "dns",
1504                 "x509sign", "x509ke", "kerberos", "crl",
1505                 "arl", "spki", "x509attr",
1506         };
1507
1508         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_CERT));
1509
1510         p = (const struct ikev1_pl_cert *)ext;
1511         ND_TCHECK_SIZE(p);
1512         /*
1513          * Our caller has ensured that the length is >= 4.
1514          */
1515         ND_PRINT(" len=%u", item_len - 4);
1516         ND_PRINT(" type=%s", STR_OR_ID(GET_U_1(p->encode), certstr));
1517         if (2 < ndo->ndo_vflag && 4 < item_len) {
1518                 /* Print the entire payload in hex */
1519                 ND_PRINT(" ");
1520                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1521                         goto trunc;
1522         }
1523         return (const u_char *)ext + item_len;
1524 trunc:
1525         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_CERT));
1526         return NULL;
1527 }
1528
1529 static const u_char *
1530 ikev1_cr_print(netdissect_options *ndo, u_char tpay _U_,
1531                const struct isakmp_gen *ext, u_int item_len,
1532                const u_char *ep _U_, uint32_t phase _U_, uint32_t doi0 _U_,
1533                uint32_t proto0 _U_, int depth _U_)
1534 {
1535         const struct ikev1_pl_cert *p;
1536         static const char *certstr[] = {
1537                 "none", "pkcs7", "pgp", "dns",
1538                 "x509sign", "x509ke", "kerberos", "crl",
1539                 "arl", "spki", "x509attr",
1540         };
1541
1542         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_CR));
1543
1544         p = (const struct ikev1_pl_cert *)ext;
1545         ND_TCHECK_SIZE(p);
1546         /*
1547          * Our caller has ensured that the length is >= 4.
1548          */
1549         ND_PRINT(" len=%u", item_len - 4);
1550         ND_PRINT(" type=%s", STR_OR_ID(GET_U_1(p->encode), certstr));
1551         if (2 < ndo->ndo_vflag && 4 < item_len) {
1552                 /* Print the entire payload in hex */
1553                 ND_PRINT(" ");
1554                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1555                         goto trunc;
1556         }
1557         return (const u_char *)ext + item_len;
1558 trunc:
1559         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_CR));
1560         return NULL;
1561 }
1562
1563 static const u_char *
1564 ikev1_hash_print(netdissect_options *ndo, u_char tpay _U_,
1565                  const struct isakmp_gen *ext, u_int item_len,
1566                  const u_char *ep _U_, uint32_t phase _U_, uint32_t doi _U_,
1567                  uint32_t proto _U_, int depth _U_)
1568 {
1569         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_HASH));
1570
1571         ND_TCHECK_SIZE(ext);
1572         /*
1573          * Our caller has ensured that the length is >= 4.
1574          */
1575         ND_PRINT(" len=%u", item_len - 4);
1576         if (2 < ndo->ndo_vflag && 4 < item_len) {
1577                 /* Print the entire payload in hex */
1578                 ND_PRINT(" ");
1579                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1580                         goto trunc;
1581         }
1582         return (const u_char *)ext + item_len;
1583 trunc:
1584         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_HASH));
1585         return NULL;
1586 }
1587
1588 static const u_char *
1589 ikev1_sig_print(netdissect_options *ndo, u_char tpay _U_,
1590                 const struct isakmp_gen *ext, u_int item_len,
1591                 const u_char *ep _U_, uint32_t phase _U_, uint32_t doi _U_,
1592                 uint32_t proto _U_, int depth _U_)
1593 {
1594         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_SIG));
1595
1596         ND_TCHECK_SIZE(ext);
1597         /*
1598          * Our caller has ensured that the length is >= 4.
1599          */
1600         ND_PRINT(" len=%u", item_len - 4);
1601         if (2 < ndo->ndo_vflag && 4 < item_len) {
1602                 /* Print the entire payload in hex */
1603                 ND_PRINT(" ");
1604                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1605                         goto trunc;
1606         }
1607         return (const u_char *)ext + item_len;
1608 trunc:
1609         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_SIG));
1610         return NULL;
1611 }
1612
1613 static const u_char *
1614 ikev1_nonce_print(netdissect_options *ndo, u_char tpay _U_,
1615                   const struct isakmp_gen *ext,
1616                   u_int item_len,
1617                   const u_char *ep,
1618                   uint32_t phase _U_, uint32_t doi _U_,
1619                   uint32_t proto _U_, int depth _U_)
1620 {
1621         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_NONCE));
1622
1623         ND_TCHECK_SIZE(ext);
1624         /*
1625          * Our caller has ensured that the length is >= 4.
1626          */
1627         ND_PRINT(" n len=%u", item_len - 4);
1628         if (item_len > 4) {
1629                 if (ndo->ndo_vflag > 2) {
1630                         ND_PRINT(" ");
1631                         if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1632                                 goto trunc;
1633                 } else if (ndo->ndo_vflag > 1) {
1634                         ND_PRINT(" ");
1635                         if (!ike_show_somedata(ndo, (const u_char *)(ext + 1), ep))
1636                                 goto trunc;
1637                 }
1638         }
1639         return (const u_char *)ext + item_len;
1640 trunc:
1641         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_NONCE));
1642         return NULL;
1643 }
1644
1645 static const u_char *
1646 ikev1_n_print(netdissect_options *ndo, u_char tpay _U_,
1647               const struct isakmp_gen *ext, u_int item_len,
1648               const u_char *ep, uint32_t phase _U_, uint32_t doi0 _U_,
1649               uint32_t proto0 _U_, int depth _U_)
1650 {
1651         const struct ikev1_pl_n *p;
1652         const u_char *cp;
1653         const u_char *ep2;
1654         uint32_t doi;
1655         uint32_t proto;
1656         uint16_t type;
1657         uint8_t spi_size;
1658         static const char *notify_error_str[] = {
1659                 NULL,                           "INVALID-PAYLOAD-TYPE",
1660                 "DOI-NOT-SUPPORTED",            "SITUATION-NOT-SUPPORTED",
1661                 "INVALID-COOKIE",               "INVALID-MAJOR-VERSION",
1662                 "INVALID-MINOR-VERSION",        "INVALID-EXCHANGE-TYPE",
1663                 "INVALID-FLAGS",                "INVALID-MESSAGE-ID",
1664                 "INVALID-PROTOCOL-ID",          "INVALID-SPI",
1665                 "INVALID-TRANSFORM-ID",         "ATTRIBUTES-NOT-SUPPORTED",
1666                 "NO-PROPOSAL-CHOSEN",           "BAD-PROPOSAL-SYNTAX",
1667                 "PAYLOAD-MALFORMED",            "INVALID-KEY-INFORMATION",
1668                 "INVALID-ID-INFORMATION",       "INVALID-CERT-ENCODING",
1669                 "INVALID-CERTIFICATE",          "CERT-TYPE-UNSUPPORTED",
1670                 "INVALID-CERT-AUTHORITY",       "INVALID-HASH-INFORMATION",
1671                 "AUTHENTICATION-FAILED",        "INVALID-SIGNATURE",
1672                 "ADDRESS-NOTIFICATION",         "NOTIFY-SA-LIFETIME",
1673                 "CERTIFICATE-UNAVAILABLE",      "UNSUPPORTED-EXCHANGE-TYPE",
1674                 "UNEQUAL-PAYLOAD-LENGTHS",
1675         };
1676         static const char *ipsec_notify_error_str[] = {
1677                 "RESERVED",
1678         };
1679         static const char *notify_status_str[] = {
1680                 "CONNECTED",
1681         };
1682         static const char *ipsec_notify_status_str[] = {
1683                 "RESPONDER-LIFETIME",           "REPLAY-STATUS",
1684                 "INITIAL-CONTACT",
1685         };
1686 /* NOTE: these macro must be called with x in proper range */
1687
1688 /* 0 - 8191 */
1689 #define NOTIFY_ERROR_STR(x) \
1690         STR_OR_ID((x), notify_error_str)
1691
1692 /* 8192 - 16383 */
1693 #define IPSEC_NOTIFY_ERROR_STR(x) \
1694         STR_OR_ID((u_int)((x) - 8192), ipsec_notify_error_str)
1695
1696 /* 16384 - 24575 */
1697 #define NOTIFY_STATUS_STR(x) \
1698         STR_OR_ID((u_int)((x) - 16384), notify_status_str)
1699
1700 /* 24576 - 32767 */
1701 #define IPSEC_NOTIFY_STATUS_STR(x) \
1702         STR_OR_ID((u_int)((x) - 24576), ipsec_notify_status_str)
1703
1704         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_N));
1705
1706         p = (const struct ikev1_pl_n *)ext;
1707         ND_TCHECK_SIZE(p);
1708         doi = GET_BE_U_4(p->doi);
1709         proto = GET_U_1(p->prot_id);
1710         if (doi != 1) {
1711                 ND_PRINT(" doi=%u", doi);
1712                 ND_PRINT(" proto=%u", proto);
1713                 type = GET_BE_U_2(p->type);
1714                 if (type < 8192)
1715                         ND_PRINT(" type=%s", NOTIFY_ERROR_STR(type));
1716                 else if (type < 16384)
1717                         ND_PRINT(" type=%s", numstr(type));
1718                 else if (type < 24576)
1719                         ND_PRINT(" type=%s", NOTIFY_STATUS_STR(type));
1720                 else
1721                         ND_PRINT(" type=%s", numstr(type));
1722                 spi_size = GET_U_1(p->spi_size);
1723                 if (spi_size) {
1724                         ND_PRINT(" spi=");
1725                         if (!rawprint(ndo, (const uint8_t *)(p + 1), spi_size))
1726                                 goto trunc;
1727                 }
1728                 return (const u_char *)(p + 1) + spi_size;
1729         }
1730
1731         ND_PRINT(" doi=ipsec");
1732         ND_PRINT(" proto=%s", PROTOIDSTR(proto));
1733         type = GET_BE_U_2(p->type);
1734         if (type < 8192)
1735                 ND_PRINT(" type=%s", NOTIFY_ERROR_STR(type));
1736         else if (type < 16384)
1737                 ND_PRINT(" type=%s", IPSEC_NOTIFY_ERROR_STR(type));
1738         else if (type < 24576)
1739                 ND_PRINT(" type=%s", NOTIFY_STATUS_STR(type));
1740         else if (type < 32768)
1741                 ND_PRINT(" type=%s", IPSEC_NOTIFY_STATUS_STR(type));
1742         else
1743                 ND_PRINT(" type=%s", numstr(type));
1744         spi_size = GET_U_1(p->spi_size);
1745         if (spi_size) {
1746                 ND_PRINT(" spi=");
1747                 if (!rawprint(ndo, (const uint8_t *)(p + 1), spi_size))
1748                         goto trunc;
1749         }
1750
1751         cp = (const u_char *)(p + 1) + spi_size;
1752         ep2 = (const u_char *)p + item_len;
1753
1754         if (cp < ep) {
1755                 switch (type) {
1756                 case IPSECDOI_NTYPE_RESPONDER_LIFETIME:
1757                     {
1758                         const struct attrmap *map = oakley_t_map;
1759                         size_t nmap = sizeof(oakley_t_map)/sizeof(oakley_t_map[0]);
1760                         ND_PRINT(" attrs=(");
1761                         while (cp < ep && cp < ep2) {
1762                                 cp = ikev1_attrmap_print(ndo, cp, ep2, map, nmap);
1763                                 if (cp == NULL) {
1764                                         ND_PRINT(")");
1765                                         goto trunc;
1766                                 }
1767                         }
1768                         ND_PRINT(")");
1769                         break;
1770                     }
1771                 case IPSECDOI_NTYPE_REPLAY_STATUS:
1772                         ND_PRINT(" status=(");
1773                         ND_PRINT("replay detection %sabled",
1774                                   GET_BE_U_4(cp) ? "en" : "dis");
1775                         ND_PRINT(")");
1776                         break;
1777                 default:
1778                         /*
1779                          * XXX - fill in more types here; see, for example,
1780                          * draft-ietf-ipsec-notifymsg-04.
1781                          */
1782                         if (ndo->ndo_vflag > 3) {
1783                                 ND_PRINT(" data=(");
1784                                 if (!rawprint(ndo, (const uint8_t *)(cp), ep - cp))
1785                                         goto trunc;
1786                                 ND_PRINT(")");
1787                         } else {
1788                                 if (!ike_show_somedata(ndo, cp, ep))
1789                                         goto trunc;
1790                         }
1791                         break;
1792                 }
1793         }
1794         return (const u_char *)ext + item_len;
1795 trunc:
1796         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_N));
1797         return NULL;
1798 }
1799
1800 static const u_char *
1801 ikev1_d_print(netdissect_options *ndo, u_char tpay _U_,
1802               const struct isakmp_gen *ext, u_int item_len _U_,
1803               const u_char *ep _U_, uint32_t phase _U_, uint32_t doi0 _U_,
1804               uint32_t proto0 _U_, int depth _U_)
1805 {
1806         const struct ikev1_pl_d *p;
1807         const uint8_t *q;
1808         uint32_t doi;
1809         uint32_t proto;
1810         uint8_t spi_size;
1811         uint16_t num_spi;
1812         u_int i;
1813
1814         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_D));
1815
1816         p = (const struct ikev1_pl_d *)ext;
1817         ND_TCHECK_SIZE(p);
1818         doi = GET_BE_U_4(p->doi);
1819         proto = GET_U_1(p->prot_id);
1820         if (doi != 1) {
1821                 ND_PRINT(" doi=%u", doi);
1822                 ND_PRINT(" proto=%u", proto);
1823         } else {
1824                 ND_PRINT(" doi=ipsec");
1825                 ND_PRINT(" proto=%s", PROTOIDSTR(proto));
1826         }
1827         spi_size = GET_U_1(p->spi_size);
1828         ND_PRINT(" spilen=%u", spi_size);
1829         num_spi = GET_BE_U_2(p->num_spi);
1830         ND_PRINT(" nspi=%u", num_spi);
1831         ND_PRINT(" spi=");
1832         q = (const uint8_t *)(p + 1);
1833         for (i = 0; i < num_spi; i++) {
1834                 if (i != 0)
1835                         ND_PRINT(",");
1836                 if (!rawprint(ndo, (const uint8_t *)q, spi_size))
1837                         goto trunc;
1838                 q += spi_size;
1839         }
1840         return q;
1841 trunc:
1842         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_D));
1843         return NULL;
1844 }
1845
1846 static const u_char *
1847 ikev1_vid_print(netdissect_options *ndo, u_char tpay _U_,
1848                 const struct isakmp_gen *ext,
1849                 u_int item_len, const u_char *ep _U_,
1850                 uint32_t phase _U_, uint32_t doi _U_,
1851                 uint32_t proto _U_, int depth _U_)
1852 {
1853         ND_PRINT("%s:", NPSTR(ISAKMP_NPTYPE_VID));
1854
1855         ND_TCHECK_SIZE(ext);
1856         /*
1857          * Our caller has ensured that the length is >= 4.
1858          */
1859         ND_PRINT(" len=%u", item_len - 4);
1860         if (2 < ndo->ndo_vflag && 4 < item_len) {
1861                 /* Print the entire payload in hex */
1862                 ND_PRINT(" ");
1863                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1864                         goto trunc;
1865         }
1866         return (const u_char *)ext + item_len;
1867 trunc:
1868         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_VID));
1869         return NULL;
1870 }
1871
1872 /************************************************************/
1873 /*                                                          */
1874 /*              IKE v2 - rfc4306 - dissector                */
1875 /*                                                          */
1876 /************************************************************/
1877
1878 static void
1879 ikev2_pay_print(netdissect_options *ndo, const char *payname, uint8_t critical)
1880 {
1881         ND_PRINT("%s%s:", payname, critical&0x80 ? "[C]" : "");
1882 }
1883
1884 static const u_char *
1885 ikev2_gen_print(netdissect_options *ndo, u_char tpay,
1886                 const struct isakmp_gen *ext, u_int item_len)
1887 {
1888         const struct isakmp_gen *p = (const struct isakmp_gen *)ext;
1889
1890         ND_TCHECK_SIZE(ext);
1891         ikev2_pay_print(ndo, NPSTR(tpay), GET_U_1(p->critical));
1892
1893         /*
1894          * Our caller has ensured that the length is >= 4.
1895          */
1896         ND_PRINT(" len=%u", item_len - 4);
1897         if (2 < ndo->ndo_vflag && 4 < item_len) {
1898                 /* Print the entire payload in hex */
1899                 ND_PRINT(" ");
1900                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
1901                         goto trunc;
1902         }
1903         return (const u_char *)ext + item_len;
1904 trunc:
1905         ND_PRINT(" [|%s]", NPSTR(tpay));
1906         return NULL;
1907 }
1908
1909 static const u_char *
1910 ikev2_t_print(netdissect_options *ndo, int tcount,
1911               const struct isakmp_gen *ext, u_int item_len,
1912               const u_char *ep)
1913 {
1914         const struct ikev2_t *p;
1915         uint16_t  t_id;
1916         uint8_t t_type;
1917         const u_char *cp;
1918         const char *idstr;
1919         const struct attrmap *map;
1920         size_t nmap;
1921         const u_char *ep2;
1922
1923         p = (const struct ikev2_t *)ext;
1924         ND_TCHECK_SIZE(p);
1925         ikev2_pay_print(ndo, NPSTR(ISAKMP_NPTYPE_T), GET_U_1(p->h.critical));
1926
1927         t_id = GET_BE_U_2(p->t_id);
1928
1929         map = NULL;
1930         nmap = 0;
1931
1932         t_type = GET_U_1(p->t_type);
1933         switch (t_type) {
1934         case IV2_T_ENCR:
1935                 idstr = STR_OR_ID(t_id, esp_p_map);
1936                 map = encr_t_map;
1937                 nmap = sizeof(encr_t_map)/sizeof(encr_t_map[0]);
1938                 break;
1939
1940         case IV2_T_PRF:
1941                 idstr = STR_OR_ID(t_id, prf_p_map);
1942                 break;
1943
1944         case IV2_T_INTEG:
1945                 idstr = STR_OR_ID(t_id, integ_p_map);
1946                 break;
1947
1948         case IV2_T_DH:
1949                 idstr = STR_OR_ID(t_id, dh_p_map);
1950                 break;
1951
1952         case IV2_T_ESN:
1953                 idstr = STR_OR_ID(t_id, esn_p_map);
1954                 break;
1955
1956         default:
1957                 idstr = NULL;
1958                 break;
1959         }
1960
1961         if (idstr)
1962                 ND_PRINT(" #%u type=%s id=%s ", tcount,
1963                           STR_OR_ID(t_type, ikev2_t_type_map),
1964                           idstr);
1965         else
1966                 ND_PRINT(" #%u type=%s id=%u ", tcount,
1967                           STR_OR_ID(t_type, ikev2_t_type_map),
1968                           t_id);
1969         cp = (const u_char *)(p + 1);
1970         ep2 = (const u_char *)p + item_len;
1971         while (cp < ep && cp < ep2) {
1972                 if (map && nmap) {
1973                         cp = ikev1_attrmap_print(ndo, cp, ep2, map, nmap);
1974                 } else
1975                         cp = ikev1_attr_print(ndo, cp, ep2);
1976                 if (cp == NULL)
1977                         goto trunc;
1978         }
1979         if (ep < ep2)
1980                 ND_PRINT("...");
1981         return cp;
1982 trunc:
1983         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_T));
1984         return NULL;
1985 }
1986
1987 static const u_char *
1988 ikev2_p_print(netdissect_options *ndo, u_char tpay _U_, int pcount _U_,
1989               const struct isakmp_gen *ext, u_int oprop_length,
1990               const u_char *ep, int depth)
1991 {
1992         const struct ikev2_p *p;
1993         u_int prop_length;
1994         uint8_t spi_size;
1995         const u_char *cp;
1996         int i;
1997         int tcount;
1998         u_char np;
1999         u_int item_len;
2000
2001         p = (const struct ikev2_p *)ext;
2002         ND_TCHECK_SIZE(p);
2003
2004         ikev2_pay_print(ndo, NPSTR(ISAKMP_NPTYPE_P), GET_U_1(p->h.critical));
2005
2006         /*
2007          * ikev2_sa_print() guarantees that this is >= 4.
2008          */
2009         prop_length = oprop_length - 4;
2010         ND_PRINT(" #%u protoid=%s transform=%u len=%u",
2011                   GET_U_1(p->p_no),  PROTOIDSTR(GET_U_1(p->prot_id)),
2012                   GET_U_1(p->num_t), oprop_length);
2013         cp = (const u_char *)(p + 1);
2014
2015         spi_size = GET_U_1(p->spi_size);
2016         if (spi_size) {
2017                 if (prop_length < spi_size)
2018                         goto toolong;
2019                 ND_PRINT(" spi=");
2020                 if (!rawprint(ndo, (const uint8_t *)cp, spi_size))
2021                         goto trunc;
2022                 cp += spi_size;
2023                 prop_length -= spi_size;
2024         }
2025
2026         /*
2027          * Print the transforms.
2028          */
2029         tcount = 0;
2030         for (np = ISAKMP_NPTYPE_T; np != 0; np = GET_U_1(ext->np)) {
2031                 tcount++;
2032                 ext = (const struct isakmp_gen *)cp;
2033                 if (prop_length < sizeof(*ext))
2034                         goto toolong;
2035                 ND_TCHECK_SIZE(ext);
2036
2037                 /*
2038                  * Since we can't have a payload length of less than 4 bytes,
2039                  * we need to bail out here if the generic header is nonsensical
2040                  * or truncated, otherwise we could loop forever processing
2041                  * zero-length items or otherwise misdissect the packet.
2042                  */
2043                 item_len = GET_BE_U_2(ext->len);
2044                 if (item_len <= 4)
2045                         goto trunc;
2046
2047                 if (prop_length < item_len)
2048                         goto toolong;
2049                 ND_TCHECK_LEN(cp, item_len);
2050
2051                 depth++;
2052                 ND_PRINT("\n");
2053                 for (i = 0; i < depth; i++)
2054                         ND_PRINT("    ");
2055                 ND_PRINT("(");
2056                 if (np == ISAKMP_NPTYPE_T) {
2057                         cp = ikev2_t_print(ndo, tcount, ext, item_len, ep);
2058                         if (cp == NULL) {
2059                                 /* error, already reported */
2060                                 return NULL;
2061                         }
2062                 } else {
2063                         ND_PRINT("%s", NPSTR(np));
2064                         cp += item_len;
2065                 }
2066                 ND_PRINT(")");
2067                 depth--;
2068                 prop_length -= item_len;
2069         }
2070         return cp;
2071 toolong:
2072         /*
2073          * Skip the rest of the proposal.
2074          */
2075         cp += prop_length;
2076         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_P));
2077         return cp;
2078 trunc:
2079         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_P));
2080         return NULL;
2081 }
2082
2083 static const u_char *
2084 ikev2_sa_print(netdissect_options *ndo, u_char tpay,
2085                 const struct isakmp_gen *ext1,
2086                 u_int osa_length, const u_char *ep,
2087                 uint32_t phase _U_, uint32_t doi _U_,
2088                 uint32_t proto _U_, int depth)
2089 {
2090         const struct isakmp_gen *ext;
2091         u_int sa_length;
2092         const u_char *cp;
2093         int i;
2094         int pcount;
2095         u_char np;
2096         u_int item_len;
2097
2098         ND_TCHECK_SIZE(ext1);
2099         ikev2_pay_print(ndo, "sa", GET_U_1(ext1->critical));
2100
2101         /*
2102          * ikev2_sub0_print() guarantees that this is >= 4.
2103          */
2104         osa_length= GET_BE_U_2(ext1->len);
2105         sa_length = osa_length - 4;
2106         ND_PRINT(" len=%u", sa_length);
2107
2108         /*
2109          * Print the payloads.
2110          */
2111         cp = (const u_char *)(ext1 + 1);
2112         pcount = 0;
2113         for (np = ISAKMP_NPTYPE_P; np != 0; np = GET_U_1(ext->np)) {
2114                 pcount++;
2115                 ext = (const struct isakmp_gen *)cp;
2116                 if (sa_length < sizeof(*ext))
2117                         goto toolong;
2118                 ND_TCHECK_SIZE(ext);
2119
2120                 /*
2121                  * Since we can't have a payload length of less than 4 bytes,
2122                  * we need to bail out here if the generic header is nonsensical
2123                  * or truncated, otherwise we could loop forever processing
2124                  * zero-length items or otherwise misdissect the packet.
2125                  */
2126                 item_len = GET_BE_U_2(ext->len);
2127                 if (item_len <= 4)
2128                         goto trunc;
2129
2130                 if (sa_length < item_len)
2131                         goto toolong;
2132                 ND_TCHECK_LEN(cp, item_len);
2133
2134                 depth++;
2135                 ND_PRINT("\n");
2136                 for (i = 0; i < depth; i++)
2137                         ND_PRINT("    ");
2138                 ND_PRINT("(");
2139                 if (np == ISAKMP_NPTYPE_P) {
2140                         cp = ikev2_p_print(ndo, np, pcount, ext, item_len,
2141                                            ep, depth);
2142                         if (cp == NULL) {
2143                                 /* error, already reported */
2144                                 return NULL;
2145                         }
2146                 } else {
2147                         ND_PRINT("%s", NPSTR(np));
2148                         cp += item_len;
2149                 }
2150                 ND_PRINT(")");
2151                 depth--;
2152                 sa_length -= item_len;
2153         }
2154         return cp;
2155 toolong:
2156         /*
2157          * Skip the rest of the SA.
2158          */
2159         cp += sa_length;
2160         ND_PRINT(" [|%s]", NPSTR(tpay));
2161         return cp;
2162 trunc:
2163         ND_PRINT(" [|%s]", NPSTR(tpay));
2164         return NULL;
2165 }
2166
2167 static const u_char *
2168 ikev2_ke_print(netdissect_options *ndo, u_char tpay,
2169                 const struct isakmp_gen *ext,
2170                 u_int item_len, const u_char *ep _U_,
2171                 uint32_t phase _U_, uint32_t doi _U_,
2172                 uint32_t proto _U_, int depth _U_)
2173 {
2174         const struct ikev2_ke *k;
2175
2176         k = (const struct ikev2_ke *)ext;
2177         ND_TCHECK_SIZE(k);
2178         ikev2_pay_print(ndo, NPSTR(tpay), GET_U_1(k->h.critical));
2179
2180         if (item_len < 8) {
2181                 ND_PRINT(" len=%u < 8", item_len);
2182                 return (const u_char *)ext + item_len;
2183         }
2184         ND_PRINT(" len=%u group=%s", item_len - 8,
2185                   STR_OR_ID(GET_BE_U_2(k->ke_group), dh_p_map));
2186
2187         if (2 < ndo->ndo_vflag && 8 < item_len) {
2188                 ND_PRINT(" ");
2189                 if (!rawprint(ndo, (const uint8_t *)(k + 1), item_len - 8))
2190                         goto trunc;
2191         }
2192         return (const u_char *)ext + item_len;
2193 trunc:
2194         ND_PRINT(" [|%s]", NPSTR(tpay));
2195         return NULL;
2196 }
2197
2198 static const u_char *
2199 ikev2_ID_print(netdissect_options *ndo, u_char tpay,
2200                 const struct isakmp_gen *ext,
2201                 u_int item_len, const u_char *ep _U_,
2202                 uint32_t phase _U_, uint32_t doi _U_,
2203                 uint32_t proto _U_, int depth _U_)
2204 {
2205         const struct ikev2_id *idp;
2206         u_int idtype_len, i;
2207         unsigned int dumpascii, dumphex;
2208         const unsigned char *typedata;
2209
2210         idp = (const struct ikev2_id *)ext;
2211         ND_TCHECK_SIZE(idp);
2212         ikev2_pay_print(ndo, NPSTR(tpay), GET_U_1(idp->h.critical));
2213
2214         /*
2215          * Our caller has ensured that the length is >= 4.
2216          */
2217         ND_PRINT(" len=%u", item_len - 4);
2218         if (2 < ndo->ndo_vflag && 4 < item_len) {
2219                 /* Print the entire payload in hex */
2220                 ND_PRINT(" ");
2221                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
2222                         goto trunc;
2223         }
2224
2225         idtype_len =item_len - sizeof(struct ikev2_id);
2226         dumpascii = 0;
2227         dumphex   = 0;
2228         typedata  = (const unsigned char *)(ext)+sizeof(struct ikev2_id);
2229
2230         switch(GET_U_1(idp->type)) {
2231         case ID_IPV4_ADDR:
2232                 ND_PRINT(" ipv4:");
2233                 dumphex=1;
2234                 break;
2235         case ID_FQDN:
2236                 ND_PRINT(" fqdn:");
2237                 dumpascii=1;
2238                 break;
2239         case ID_RFC822_ADDR:
2240                 ND_PRINT(" rfc822:");
2241                 dumpascii=1;
2242                 break;
2243         case ID_IPV6_ADDR:
2244                 ND_PRINT(" ipv6:");
2245                 dumphex=1;
2246                 break;
2247         case ID_DER_ASN1_DN:
2248                 ND_PRINT(" dn:");
2249                 dumphex=1;
2250                 break;
2251         case ID_DER_ASN1_GN:
2252                 ND_PRINT(" gn:");
2253                 dumphex=1;
2254                 break;
2255         case ID_KEY_ID:
2256                 ND_PRINT(" keyid:");
2257                 dumphex=1;
2258                 break;
2259         }
2260
2261         if(dumpascii) {
2262                 ND_TCHECK_LEN(typedata, idtype_len);
2263                 for(i=0; i<idtype_len; i++) {
2264                         if(ND_ASCII_ISPRINT(GET_U_1(typedata + i))) {
2265                                 ND_PRINT("%c", GET_U_1(typedata + i));
2266                         } else {
2267                                 ND_PRINT(".");
2268                         }
2269                 }
2270         }
2271         if(dumphex) {
2272                 if (!rawprint(ndo, (const uint8_t *)typedata, idtype_len))
2273                         goto trunc;
2274         }
2275
2276         return (const u_char *)ext + item_len;
2277 trunc:
2278         ND_PRINT(" [|%s]", NPSTR(tpay));
2279         return NULL;
2280 }
2281
2282 static const u_char *
2283 ikev2_cert_print(netdissect_options *ndo, u_char tpay,
2284                 const struct isakmp_gen *ext,
2285                 u_int item_len, const u_char *ep _U_,
2286                 uint32_t phase _U_, uint32_t doi _U_,
2287                 uint32_t proto _U_, int depth _U_)
2288 {
2289         return ikev2_gen_print(ndo, tpay, ext, item_len);
2290 }
2291
2292 static const u_char *
2293 ikev2_cr_print(netdissect_options *ndo, u_char tpay,
2294                 const struct isakmp_gen *ext,
2295                 u_int item_len, const u_char *ep _U_,
2296                 uint32_t phase _U_, uint32_t doi _U_,
2297                 uint32_t proto _U_, int depth _U_)
2298 {
2299         return ikev2_gen_print(ndo, tpay, ext, item_len);
2300 }
2301
2302 static const u_char *
2303 ikev2_auth_print(netdissect_options *ndo, u_char tpay,
2304                 const struct isakmp_gen *ext,
2305                 u_int item_len, const u_char *ep,
2306                 uint32_t phase _U_, uint32_t doi _U_,
2307                 uint32_t proto _U_, int depth _U_)
2308 {
2309         const struct ikev2_auth *p;
2310         const char *v2_auth[]={ "invalid", "rsasig",
2311                                 "shared-secret", "dsssig" };
2312         const u_char *authdata = (const u_char*)ext + sizeof(struct ikev2_auth);
2313
2314         ND_TCHECK_LEN(ext, sizeof(struct ikev2_auth));
2315         p = (const struct ikev2_auth *)ext;
2316         ikev2_pay_print(ndo, NPSTR(tpay), GET_U_1(p->h.critical));
2317
2318         /*
2319          * Our caller has ensured that the length is >= 4.
2320          */
2321         ND_PRINT(" len=%u method=%s", item_len-4,
2322                   STR_OR_ID(GET_U_1(p->auth_method), v2_auth));
2323         if (item_len > 4) {
2324                 if (ndo->ndo_vflag > 1) {
2325                         ND_PRINT(" authdata=(");
2326                         if (!rawprint(ndo, (const uint8_t *)authdata, item_len - sizeof(struct ikev2_auth)))
2327                                 goto trunc;
2328                         ND_PRINT(") ");
2329                 } else if (ndo->ndo_vflag) {
2330                         if (!ike_show_somedata(ndo, authdata, ep))
2331                                 goto trunc;
2332                 }
2333         }
2334
2335         return (const u_char *)ext + item_len;
2336 trunc:
2337         ND_PRINT(" [|%s]", NPSTR(tpay));
2338         return NULL;
2339 }
2340
2341 static const u_char *
2342 ikev2_nonce_print(netdissect_options *ndo, u_char tpay,
2343                 const struct isakmp_gen *ext,
2344                 u_int item_len, const u_char *ep,
2345                 uint32_t phase _U_, uint32_t doi _U_,
2346                 uint32_t proto _U_, int depth _U_)
2347 {
2348         ND_TCHECK_SIZE(ext);
2349         ikev2_pay_print(ndo, "nonce", GET_U_1(ext->critical));
2350
2351         /*
2352          * Our caller has ensured that the length is >= 4.
2353          */
2354         ND_PRINT(" len=%u", item_len - 4);
2355         if (1 < ndo->ndo_vflag && 4 < item_len) {
2356                 ND_PRINT(" nonce=(");
2357                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
2358                         goto trunc;
2359                 ND_PRINT(") ");
2360         } else if(ndo->ndo_vflag && 4 < item_len) {
2361                 if(!ike_show_somedata(ndo, (const u_char *)(ext+1), ep)) goto trunc;
2362         }
2363
2364         return (const u_char *)ext + item_len;
2365 trunc:
2366         ND_PRINT(" [|%s]", NPSTR(tpay));
2367         return NULL;
2368 }
2369
2370 /* notify payloads */
2371 static const u_char *
2372 ikev2_n_print(netdissect_options *ndo, u_char tpay _U_,
2373                 const struct isakmp_gen *ext,
2374                 u_int item_len, const u_char *ep,
2375                 uint32_t phase _U_, uint32_t doi _U_,
2376                 uint32_t proto _U_, int depth _U_)
2377 {
2378         const struct ikev2_n *p;
2379         uint16_t type;
2380         uint8_t spi_size;
2381         const u_char *cp;
2382         u_char showspi, showsomedata;
2383         const char *notify_name;
2384
2385         p = (const struct ikev2_n *)ext;
2386         ND_TCHECK_SIZE(p);
2387         ikev2_pay_print(ndo, NPSTR(ISAKMP_NPTYPE_N), GET_U_1(p->h.critical));
2388
2389         showspi = 1;
2390         showsomedata=0;
2391         notify_name=NULL;
2392
2393         ND_PRINT(" prot_id=%s", PROTOIDSTR(GET_U_1(p->prot_id)));
2394
2395         type = GET_BE_U_2(p->type);
2396
2397         /* notify space is annoying sparse */
2398         switch(type) {
2399         case IV2_NOTIFY_UNSUPPORTED_CRITICAL_PAYLOAD:
2400                 notify_name = "unsupported_critical_payload";
2401                 showspi = 0;
2402                 break;
2403
2404         case IV2_NOTIFY_INVALID_IKE_SPI:
2405                 notify_name = "invalid_ike_spi";
2406                 showspi = 1;
2407                 break;
2408
2409         case IV2_NOTIFY_INVALID_MAJOR_VERSION:
2410                 notify_name = "invalid_major_version";
2411                 showspi = 0;
2412                 break;
2413
2414         case IV2_NOTIFY_INVALID_SYNTAX:
2415                 notify_name = "invalid_syntax";
2416                 showspi = 1;
2417                 break;
2418
2419         case IV2_NOTIFY_INVALID_MESSAGE_ID:
2420                 notify_name = "invalid_message_id";
2421                 showspi = 1;
2422                 break;
2423
2424         case IV2_NOTIFY_INVALID_SPI:
2425                 notify_name = "invalid_spi";
2426                 showspi = 1;
2427                 break;
2428
2429         case IV2_NOTIFY_NO_PROPOSAL_CHOSEN:
2430                 notify_name = "no_protocol_chosen";
2431                 showspi = 1;
2432                 break;
2433
2434         case IV2_NOTIFY_INVALID_KE_PAYLOAD:
2435                 notify_name = "invalid_ke_payload";
2436                 showspi = 1;
2437                 break;
2438
2439         case IV2_NOTIFY_AUTHENTICATION_FAILED:
2440                 notify_name = "authentication_failed";
2441                 showspi = 1;
2442                 break;
2443
2444         case IV2_NOTIFY_SINGLE_PAIR_REQUIRED:
2445                 notify_name = "single_pair_required";
2446                 showspi = 1;
2447                 break;
2448
2449         case IV2_NOTIFY_NO_ADDITIONAL_SAS:
2450                 notify_name = "no_additional_sas";
2451                 showspi = 0;
2452                 break;
2453
2454         case IV2_NOTIFY_INTERNAL_ADDRESS_FAILURE:
2455                 notify_name = "internal_address_failure";
2456                 showspi = 0;
2457                 break;
2458
2459         case IV2_NOTIFY_FAILED_CP_REQUIRED:
2460                 notify_name = "failed:cp_required";
2461                 showspi = 0;
2462                 break;
2463
2464         case IV2_NOTIFY_INVALID_SELECTORS:
2465                 notify_name = "invalid_selectors";
2466                 showspi = 0;
2467                 break;
2468
2469         case IV2_NOTIFY_INITIAL_CONTACT:
2470                 notify_name = "initial_contact";
2471                 showspi = 0;
2472                 break;
2473
2474         case IV2_NOTIFY_SET_WINDOW_SIZE:
2475                 notify_name = "set_window_size";
2476                 showspi = 0;
2477                 break;
2478
2479         case IV2_NOTIFY_ADDITIONAL_TS_POSSIBLE:
2480                 notify_name = "additional_ts_possible";
2481                 showspi = 0;
2482                 break;
2483
2484         case IV2_NOTIFY_IPCOMP_SUPPORTED:
2485                 notify_name = "ipcomp_supported";
2486                 showspi = 0;
2487                 break;
2488
2489         case IV2_NOTIFY_NAT_DETECTION_SOURCE_IP:
2490                 notify_name = "nat_detection_source_ip";
2491                 showspi = 1;
2492                 break;
2493
2494         case IV2_NOTIFY_NAT_DETECTION_DESTINATION_IP:
2495                 notify_name = "nat_detection_destination_ip";
2496                 showspi = 1;
2497                 break;
2498
2499         case IV2_NOTIFY_COOKIE:
2500                 notify_name = "cookie";
2501                 showspi = 1;
2502                 showsomedata= 1;
2503                 break;
2504
2505         case IV2_NOTIFY_USE_TRANSPORT_MODE:
2506                 notify_name = "use_transport_mode";
2507                 showspi = 0;
2508                 break;
2509
2510         case IV2_NOTIFY_HTTP_CERT_LOOKUP_SUPPORTED:
2511                 notify_name = "http_cert_lookup_supported";
2512                 showspi = 0;
2513                 break;
2514
2515         case IV2_NOTIFY_REKEY_SA:
2516                 notify_name = "rekey_sa";
2517                 showspi = 1;
2518                 break;
2519
2520         case IV2_NOTIFY_ESP_TFC_PADDING_NOT_SUPPORTED:
2521                 notify_name = "tfc_padding_not_supported";
2522                 showspi = 0;
2523                 break;
2524
2525         case IV2_NOTIFY_NON_FIRST_FRAGMENTS_ALSO:
2526                 notify_name = "non_first_fragment_also";
2527                 showspi = 0;
2528                 break;
2529
2530         default:
2531                 if (type < 8192) {
2532                         notify_name="error";
2533                 } else if(type < 16384) {
2534                         notify_name="private-error";
2535                 } else if(type < 40960) {
2536                         notify_name="status";
2537                 } else {
2538                         notify_name="private-status";
2539                 }
2540         }
2541
2542         if(notify_name) {
2543                 ND_PRINT(" type=%u(%s)", type, notify_name);
2544         }
2545
2546
2547         spi_size = GET_U_1(p->spi_size);
2548         if (showspi && spi_size) {
2549                 ND_PRINT(" spi=");
2550                 if (!rawprint(ndo, (const uint8_t *)(p + 1), spi_size))
2551                         goto trunc;
2552         }
2553
2554         cp = (const u_char *)(p + 1) + spi_size;
2555
2556         if (cp < ep) {
2557                 if (ndo->ndo_vflag > 3 || (showsomedata && ep-cp < 30)) {
2558                         ND_PRINT(" data=(");
2559                         if (!rawprint(ndo, (const uint8_t *)(cp), ep - cp))
2560                                 goto trunc;
2561
2562                         ND_PRINT(")");
2563                 } else if (showsomedata) {
2564                         if (!ike_show_somedata(ndo, cp, ep))
2565                                 goto trunc;
2566                 }
2567         }
2568
2569         return (const u_char *)ext + item_len;
2570 trunc:
2571         ND_PRINT(" [|%s]", NPSTR(ISAKMP_NPTYPE_N));
2572         return NULL;
2573 }
2574
2575 static const u_char *
2576 ikev2_d_print(netdissect_options *ndo, u_char tpay,
2577                 const struct isakmp_gen *ext,
2578                 u_int item_len, const u_char *ep _U_,
2579                 uint32_t phase _U_, uint32_t doi _U_,
2580                 uint32_t proto _U_, int depth _U_)
2581 {
2582         return ikev2_gen_print(ndo, tpay, ext, item_len);
2583 }
2584
2585 static const u_char *
2586 ikev2_vid_print(netdissect_options *ndo, u_char tpay,
2587                 const struct isakmp_gen *ext,
2588                 u_int item_len, const u_char *ep _U_,
2589                 uint32_t phase _U_, uint32_t doi _U_,
2590                 uint32_t proto _U_, int depth _U_)
2591 {
2592         const u_char *vid;
2593         u_int i, len;
2594
2595         ND_TCHECK_SIZE(ext);
2596         ikev2_pay_print(ndo, NPSTR(tpay), GET_U_1(ext->critical));
2597
2598         /*
2599          * Our caller has ensured that the length is >= 4.
2600          */
2601         ND_PRINT(" len=%u vid=", item_len - 4);
2602
2603         vid = (const u_char *)(ext+1);
2604         len = item_len - 4;
2605         ND_TCHECK_LEN(vid, len);
2606         for(i=0; i<len; i++) {
2607                 if(ND_ASCII_ISPRINT(GET_U_1(vid + i)))
2608                         ND_PRINT("%c", GET_U_1(vid + i));
2609                 else ND_PRINT(".");
2610         }
2611         if (2 < ndo->ndo_vflag && 4 < len) {
2612                 /* Print the entire payload in hex */
2613                 ND_PRINT(" ");
2614                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), item_len - 4))
2615                         goto trunc;
2616         }
2617         return (const u_char *)ext + item_len;
2618 trunc:
2619         ND_PRINT(" [|%s]", NPSTR(tpay));
2620         return NULL;
2621 }
2622
2623 static const u_char *
2624 ikev2_TS_print(netdissect_options *ndo, u_char tpay,
2625                 const struct isakmp_gen *ext,
2626                 u_int item_len, const u_char *ep _U_,
2627                 uint32_t phase _U_, uint32_t doi _U_,
2628                 uint32_t proto _U_, int depth _U_)
2629 {
2630         return ikev2_gen_print(ndo, tpay, ext, item_len);
2631 }
2632
2633 static const u_char *
2634 ikev2_e_print(netdissect_options *ndo,
2635 #ifndef HAVE_LIBCRYPTO
2636               _U_
2637 #endif
2638               const struct isakmp *base,
2639               u_char tpay,
2640               const struct isakmp_gen *ext,
2641               u_int item_len, const u_char *ep _U_,
2642 #ifndef HAVE_LIBCRYPTO
2643               _U_
2644 #endif
2645               uint32_t phase,
2646 #ifndef HAVE_LIBCRYPTO
2647               _U_
2648 #endif
2649               uint32_t doi,
2650 #ifndef HAVE_LIBCRYPTO
2651               _U_
2652 #endif
2653               uint32_t proto,
2654 #ifndef HAVE_LIBCRYPTO
2655               _U_
2656 #endif
2657               int depth)
2658 {
2659         const u_char *dat;
2660         u_int dlen;
2661 #ifdef HAVE_LIBCRYPTO
2662         uint8_t np;
2663 #endif
2664
2665         ND_TCHECK_SIZE(ext);
2666         ikev2_pay_print(ndo, NPSTR(tpay), GET_U_1(ext->critical));
2667
2668         dlen = item_len-4;
2669
2670         ND_PRINT(" len=%u", dlen);
2671         if (2 < ndo->ndo_vflag && 4 < dlen) {
2672                 ND_PRINT(" ");
2673                 if (!rawprint(ndo, (const uint8_t *)(ext + 1), dlen))
2674                         goto trunc;
2675         }
2676
2677         dat = (const u_char *)(ext+1);
2678         ND_TCHECK_LEN(dat, dlen);
2679
2680 #ifdef HAVE_LIBCRYPTO
2681         np = GET_U_1(ext->np);
2682
2683         /* try to decrypt it! */
2684         if(esp_decrypt_buffer_by_ikev2_print(ndo,
2685                                              GET_U_1(base->flags) & ISAKMP_FLAG_I,
2686                                              base->i_ck, base->r_ck,
2687                                              dat, dat+dlen)) {
2688
2689                 ext = (const struct isakmp_gen *)ndo->ndo_packetp;
2690
2691                 /* got it decrypted, print stuff inside. */
2692                 ikev2_sub_print(ndo, base, np, ext,
2693                                 ndo->ndo_snapend, phase, doi, proto, depth+1);
2694
2695                 /*
2696                  * esp_decrypt_buffer_by_ikev2_print pushed information
2697                  * on the buffer stack; we're done with the buffer, so
2698                  * pop it (which frees the buffer)
2699                  */
2700                 nd_pop_packet_info(ndo);
2701         }
2702 #endif
2703
2704
2705         /* always return NULL, because E must be at end, and NP refers
2706          * to what was inside.
2707          */
2708         return NULL;
2709 trunc:
2710         ND_PRINT(" [|%s]", NPSTR(tpay));
2711         return NULL;
2712 }
2713
2714 static const u_char *
2715 ikev2_cp_print(netdissect_options *ndo, u_char tpay,
2716                 const struct isakmp_gen *ext,
2717                 u_int item_len, const u_char *ep _U_,
2718                 uint32_t phase _U_, uint32_t doi _U_,
2719                 uint32_t proto _U_, int depth _U_)
2720 {
2721         return ikev2_gen_print(ndo, tpay, ext, item_len);
2722 }
2723
2724 static const u_char *
2725 ikev2_eap_print(netdissect_options *ndo, u_char tpay,
2726                 const struct isakmp_gen *ext,
2727                 u_int item_len, const u_char *ep _U_,
2728                 uint32_t phase _U_, uint32_t doi _U_,
2729                 uint32_t proto _U_, int depth _U_)
2730 {
2731         return ikev2_gen_print(ndo, tpay, ext, item_len);
2732 }
2733
2734 static const u_char *
2735 ike_sub0_print(netdissect_options *ndo,
2736                  u_char np, const struct isakmp_gen *ext, const u_char *ep,
2737
2738                uint32_t phase, uint32_t doi, uint32_t proto, int depth)
2739 {
2740         const u_char *cp;
2741         u_int item_len;
2742
2743         cp = (const u_char *)ext;
2744         ND_TCHECK_SIZE(ext);
2745
2746         /*
2747          * Since we can't have a payload length of less than 4 bytes,
2748          * we need to bail out here if the generic header is nonsensical
2749          * or truncated, otherwise we could loop forever processing
2750          * zero-length items or otherwise misdissect the packet.
2751          */
2752         item_len = GET_BE_U_2(ext->len);
2753         if (item_len <= 4)
2754                 return NULL;
2755
2756         if (NPFUNC(np)) {
2757                 /*
2758                  * XXX - what if item_len is too short, or too long,
2759                  * for this payload type?
2760                  */
2761                 cp = (*npfunc[np])(ndo, np, ext, item_len, ep, phase, doi, proto, depth);
2762         } else {
2763                 ND_PRINT("%s", NPSTR(np));
2764                 cp += item_len;
2765         }
2766
2767         return cp;
2768 trunc:
2769         nd_print_trunc(ndo);
2770         return NULL;
2771 }
2772
2773 static const u_char *
2774 ikev1_sub_print(netdissect_options *ndo,
2775                 u_char np, const struct isakmp_gen *ext, const u_char *ep,
2776                 uint32_t phase, uint32_t doi, uint32_t proto, int depth)
2777 {
2778         const u_char *cp;
2779         int i;
2780         u_int item_len;
2781
2782         cp = (const u_char *)ext;
2783
2784         while (np) {
2785                 ND_TCHECK_SIZE(ext);
2786
2787                 item_len = GET_BE_U_2(ext->len);
2788                 ND_TCHECK_LEN(ext, item_len);
2789
2790                 depth++;
2791                 ND_PRINT("\n");
2792                 for (i = 0; i < depth; i++)
2793                         ND_PRINT("    ");
2794                 ND_PRINT("(");
2795                 cp = ike_sub0_print(ndo, np, ext, ep, phase, doi, proto, depth);
2796                 ND_PRINT(")");
2797                 depth--;
2798
2799                 if (cp == NULL) {
2800                         /* Zero-length subitem */
2801                         return NULL;
2802                 }
2803
2804                 np = GET_U_1(ext->np);
2805                 ext = (const struct isakmp_gen *)cp;
2806         }
2807         return cp;
2808 trunc:
2809         ND_PRINT(" [|%s]", NPSTR(np));
2810         return NULL;
2811 }
2812
2813 static char *
2814 numstr(u_int x)
2815 {
2816         static char buf[20];
2817         snprintf(buf, sizeof(buf), "#%u", x);
2818         return buf;
2819 }
2820
2821 static void
2822 ikev1_print(netdissect_options *ndo,
2823             const u_char *bp,  u_int length,
2824             const u_char *bp2, const struct isakmp *base)
2825 {
2826         const struct isakmp *p;
2827         const u_char *ep;
2828         u_int flags;
2829         u_char np;
2830         int i;
2831         u_int phase;
2832
2833         p = (const struct isakmp *)bp;
2834         ep = ndo->ndo_snapend;
2835
2836         phase = (GET_BE_U_4(base->msgid) == 0) ? 1 : 2;
2837         if (phase == 1)
2838                 ND_PRINT(" phase %u", phase);
2839         else
2840                 ND_PRINT(" phase %u/others", phase);
2841
2842         i = cookie_find(&base->i_ck);
2843         if (i < 0) {
2844                 if (iszero((const u_char *)&base->r_ck, sizeof(base->r_ck))) {
2845                         /* the first packet */
2846                         ND_PRINT(" I");
2847                         if (bp2)
2848                                 cookie_record(ndo, &base->i_ck, bp2);
2849                 } else
2850                         ND_PRINT(" ?");
2851         } else {
2852                 if (bp2 && cookie_isinitiator(ndo, i, bp2))
2853                         ND_PRINT(" I");
2854                 else if (bp2 && cookie_isresponder(ndo, i, bp2))
2855                         ND_PRINT(" R");
2856                 else
2857                         ND_PRINT(" ?");
2858         }
2859
2860         ND_PRINT(" %s", ETYPESTR(GET_U_1(base->etype)));
2861         flags = GET_U_1(base->flags);
2862         if (flags) {
2863                 ND_PRINT("[%s%s]", flags & ISAKMP_FLAG_E ? "E" : "",
2864                           flags & ISAKMP_FLAG_C ? "C" : "");
2865         }
2866
2867         if (ndo->ndo_vflag) {
2868                 const struct isakmp_gen *ext;
2869
2870                 ND_PRINT(":");
2871
2872                 np = GET_U_1(base->np);
2873
2874                 /* regardless of phase... */
2875                 if (flags & ISAKMP_FLAG_E) {
2876                         /*
2877                          * encrypted, nothing we can do right now.
2878                          * we hope to decrypt the packet in the future...
2879                          */
2880                         ND_PRINT(" [encrypted %s]", NPSTR(np));
2881                         goto done;
2882                 }
2883
2884                 CHECKLEN(p + 1, np);
2885                 ext = (const struct isakmp_gen *)(p + 1);
2886                 ikev1_sub_print(ndo, np, ext, ep, phase, 0, 0, 0);
2887         }
2888
2889 done:
2890         if (ndo->ndo_vflag) {
2891                 if (GET_BE_U_4(base->len) != length) {
2892                         ND_PRINT(" (len mismatch: isakmp %u/ip %u)",
2893                                   GET_BE_U_4(base->len), length);
2894                 }
2895         }
2896 }
2897
2898 static const u_char *
2899 ikev2_sub0_print(netdissect_options *ndo, const struct isakmp *base,
2900                  u_char np,
2901                  const struct isakmp_gen *ext, const u_char *ep,
2902                  uint32_t phase, uint32_t doi, uint32_t proto, int depth)
2903 {
2904         const u_char *cp;
2905         u_int item_len;
2906
2907         cp = (const u_char *)ext;
2908         ND_TCHECK_SIZE(ext);
2909
2910         /*
2911          * Since we can't have a payload length of less than 4 bytes,
2912          * we need to bail out here if the generic header is nonsensical
2913          * or truncated, otherwise we could loop forever processing
2914          * zero-length items or otherwise misdissect the packet.
2915          */
2916         item_len = GET_BE_U_2(ext->len);
2917         if (item_len <= 4)
2918                 return NULL;
2919
2920         if (np == ISAKMP_NPTYPE_v2E) {
2921                 cp = ikev2_e_print(ndo, base, np, ext, item_len,
2922                                    ep, phase, doi, proto, depth);
2923         } else if (NPFUNC(np)) {
2924                 /*
2925                  * XXX - what if item_len is too short, or too long,
2926                  * for this payload type?
2927                  */
2928                 cp = (*npfunc[np])(ndo, np, ext, item_len,
2929                                    ep, phase, doi, proto, depth);
2930         } else {
2931                 ND_PRINT("%s", NPSTR(np));
2932                 cp += item_len;
2933         }
2934
2935         return cp;
2936 trunc:
2937         nd_print_trunc(ndo);
2938         return NULL;
2939 }
2940
2941 static const u_char *
2942 ikev2_sub_print(netdissect_options *ndo,
2943                 const struct isakmp *base,
2944                 u_char np, const struct isakmp_gen *ext, const u_char *ep,
2945                 uint32_t phase, uint32_t doi, uint32_t proto, int depth)
2946 {
2947         const u_char *cp;
2948         int i;
2949
2950         cp = (const u_char *)ext;
2951         while (np) {
2952                 ND_TCHECK_SIZE(ext);
2953
2954                 ND_TCHECK_LEN(ext, GET_BE_U_2(ext->len));
2955
2956                 depth++;
2957                 ND_PRINT("\n");
2958                 for (i = 0; i < depth; i++)
2959                         ND_PRINT("    ");
2960                 ND_PRINT("(");
2961                 cp = ikev2_sub0_print(ndo, base, np,
2962                                       ext, ep, phase, doi, proto, depth);
2963                 ND_PRINT(")");
2964                 depth--;
2965
2966                 if (cp == NULL) {
2967                         /* Zero-length subitem */
2968                         return NULL;
2969                 }
2970
2971                 np = GET_U_1(ext->np);
2972                 ext = (const struct isakmp_gen *)cp;
2973         }
2974         return cp;
2975 trunc:
2976         ND_PRINT(" [|%s]", NPSTR(np));
2977         return NULL;
2978 }
2979
2980 static void
2981 ikev2_print(netdissect_options *ndo,
2982             const u_char *bp,  u_int length,
2983             const u_char *bp2 _U_, const struct isakmp *base)
2984 {
2985         const struct isakmp *p;
2986         const u_char *ep;
2987         uint8_t flags;
2988         u_char np;
2989         u_int phase;
2990
2991         p = (const struct isakmp *)bp;
2992         ep = ndo->ndo_snapend;
2993
2994         phase = (GET_BE_U_4(base->msgid) == 0) ? 1 : 2;
2995         if (phase == 1)
2996                 ND_PRINT(" parent_sa");
2997         else
2998                 ND_PRINT(" child_sa ");
2999
3000         ND_PRINT(" %s", ETYPESTR(GET_U_1(base->etype)));
3001         flags = GET_U_1(base->flags);
3002         if (flags) {
3003                 ND_PRINT("[%s%s%s]",
3004                           flags & ISAKMP_FLAG_I ? "I" : "",
3005                           flags & ISAKMP_FLAG_V ? "V" : "",
3006                           flags & ISAKMP_FLAG_R ? "R" : "");
3007         }
3008
3009         if (ndo->ndo_vflag) {
3010                 const struct isakmp_gen *ext;
3011
3012                 ND_PRINT(":");
3013
3014                 np = GET_U_1(base->np);
3015
3016                 /* regardless of phase... */
3017                 if (flags & ISAKMP_FLAG_E) {
3018                         /*
3019                          * encrypted, nothing we can do right now.
3020                          * we hope to decrypt the packet in the future...
3021                          */
3022                         ND_PRINT(" [encrypted %s]", NPSTR(np));
3023                         goto done;
3024                 }
3025
3026                 CHECKLEN(p + 1, np)
3027                 ext = (const struct isakmp_gen *)(p + 1);
3028                 ikev2_sub_print(ndo, base, np, ext, ep, phase, 0, 0, 0);
3029         }
3030
3031 done:
3032         if (ndo->ndo_vflag) {
3033                 if (GET_BE_U_4(base->len) != length) {
3034                         ND_PRINT(" (len mismatch: isakmp %u/ip %u)",
3035                                   GET_BE_U_4(base->len), length);
3036                 }
3037         }
3038 }
3039
3040 void
3041 isakmp_print(netdissect_options *ndo,
3042              const u_char *bp, u_int length,
3043              const u_char *bp2)
3044 {
3045         const struct isakmp *p;
3046         const u_char *ep;
3047         u_int major, minor;
3048
3049         ndo->ndo_protocol = "isakmp";
3050 #ifdef HAVE_LIBCRYPTO
3051         /* initialize SAs */
3052         if (ndo->ndo_sa_list_head == NULL) {
3053                 if (ndo->ndo_espsecret)
3054                         esp_decodesecret_print(ndo);
3055         }
3056 #endif
3057
3058         p = (const struct isakmp *)bp;
3059         ep = ndo->ndo_snapend;
3060
3061         if ((const struct isakmp *)ep < p + 1) {
3062                 nd_print_trunc(ndo);
3063                 return;
3064         }
3065
3066         ND_PRINT("isakmp");
3067         major = (GET_U_1(p->vers) & ISAKMP_VERS_MAJOR)
3068                 >> ISAKMP_VERS_MAJOR_SHIFT;
3069         minor = (GET_U_1(p->vers) & ISAKMP_VERS_MINOR)
3070                 >> ISAKMP_VERS_MINOR_SHIFT;
3071
3072         if (ndo->ndo_vflag) {
3073                 ND_PRINT(" %u.%u", major, minor);
3074         }
3075
3076         if (ndo->ndo_vflag) {
3077                 ND_PRINT(" msgid ");
3078                 hexprint(ndo, p->msgid, sizeof(p->msgid));
3079         }
3080
3081         if (1 < ndo->ndo_vflag) {
3082                 ND_PRINT(" cookie ");
3083                 hexprint(ndo, p->i_ck, sizeof(p->i_ck));
3084                 ND_PRINT("->");
3085                 hexprint(ndo, p->r_ck, sizeof(p->r_ck));
3086         }
3087         ND_PRINT(":");
3088
3089         switch(major) {
3090         case IKEv1_MAJOR_VERSION:
3091                 ikev1_print(ndo, bp, length, bp2, p);
3092                 break;
3093
3094         case IKEv2_MAJOR_VERSION:
3095                 ikev2_print(ndo, bp, length, bp2, p);
3096                 break;
3097         }
3098 }
3099
3100 void
3101 isakmp_rfc3948_print(netdissect_options *ndo,
3102                      const u_char *bp, u_int length,
3103                      const u_char *bp2, int ver, int fragmented, u_int ttl_hl)
3104 {
3105         ndo->ndo_protocol = "isakmp_rfc3948";
3106         if(length == 1 && GET_U_1(bp)==0xff) {
3107                 ND_PRINT("isakmp-nat-keep-alive");
3108                 return;
3109         }
3110
3111         if(length < 4) {
3112                 goto trunc;
3113         }
3114
3115         /*
3116          * see if this is an IKE packet
3117          */
3118         if (GET_BE_U_4(bp) == 0) {
3119                 ND_PRINT("NONESP-encap: ");
3120                 isakmp_print(ndo, bp+4, length-4, bp2);
3121                 return;
3122         }
3123
3124         /* must be an ESP packet */
3125         {
3126                 ND_PRINT("UDP-encap: ");
3127
3128                 esp_print(ndo, bp, length, bp2, ver, fragmented, ttl_hl);
3129
3130                 /*
3131                  * Either this has decrypted the payload and
3132                  * printed it, in which case there's nothing more
3133                  * to do, or it hasn't, in which case there's
3134                  * nothing more to do.
3135                  */
3136                 return;
3137         }
3138
3139 trunc:
3140         nd_print_trunc(ndo);
3141 }