1 /* 2 * Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997 3 * John Robert LoVerso. 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 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 * 27 * 28 * This implementation has been influenced by the CMU SNMP release, 29 * by Steve Waldbusser. However, this shares no code with that system. 30 * Additional ASN.1 insight gained from Marshall T. Rose's _The_Open_Book_. 31 * Earlier forms of this implementation were derived and/or inspired by an 32 * awk script originally written by C. Philip Wood of LANL (but later 33 * heavily modified by John Robert LoVerso). The copyright notice for 34 * that work is preserved below, even though it may not rightly apply 35 * to this file. 36 * 37 * Support for SNMPv2c/SNMPv3 and the ability to link the module against 38 * the libsmi was added by J. Schoenwaelder, Copyright (c) 1999. 39 * 40 * This started out as a very simple program, but the incremental decoding 41 * (into the BE structure) complicated things. 42 * 43 # Los Alamos National Laboratory 44 # 45 # Copyright (c) 1990, 1991, 1993, 1994, 1995, 1996, 1997 46 # This software was produced under a U.S. Government contract 47 # (W-7405-ENG-36) by Los Alamos National Laboratory, which is 48 # operated by the University of California for the U.S. Department 49 # of Energy. The U.S. Government is licensed to use, reproduce, 50 # and distribute this software. Permission is granted to the 51 # public to copy and use this software without charge, provided 52 # that this Notice and any statement of authorship are reproduced 53 # on all copies. Neither the Government nor the University makes 54 # any warranty, express or implied, or assumes any liability or 55 # responsibility for the use of this software. 56 # @(#)snmp.awk.x 1.1 (LANL) 1/15/90 57 */ 58 59 /* \summary: Simple Network Management Protocol (SNMP) printer */ 60 61 #ifdef HAVE_CONFIG_H 62 #include "config.h" 63 #endif 64 65 #include <netdissect-stdinc.h> 66 67 #include <stdio.h> 68 #include <string.h> 69 70 #ifdef USE_LIBSMI 71 #include <smi.h> 72 #endif 73 74 #include "netdissect.h" 75 76 #undef OPAQUE /* defined in <wingdi.h> */ 77 78 static const char tstr[] = "[|snmp]"; 79 80 /* 81 * Universal ASN.1 types 82 * (we only care about the tag values for those allowed in the Internet SMI) 83 */ 84 static const char *Universal[] = { 85 "U-0", 86 "Boolean", 87 "Integer", 88 #define INTEGER 2 89 "Bitstring", 90 "String", 91 #define STRING 4 92 "Null", 93 #define ASN_NULL 5 94 "ObjID", 95 #define OBJECTID 6 96 "ObjectDes", 97 "U-8","U-9","U-10","U-11", /* 8-11 */ 98 "U-12","U-13","U-14","U-15", /* 12-15 */ 99 "Sequence", 100 #define SEQUENCE 16 101 "Set" 102 }; 103 104 /* 105 * Application-wide ASN.1 types from the Internet SMI and their tags 106 */ 107 static const char *Application[] = { 108 "IpAddress", 109 #define IPADDR 0 110 "Counter", 111 #define COUNTER 1 112 "Gauge", 113 #define GAUGE 2 114 "TimeTicks", 115 #define TIMETICKS 3 116 "Opaque", 117 #define OPAQUE 4 118 "C-5", 119 "Counter64" 120 #define COUNTER64 6 121 }; 122 123 /* 124 * Context-specific ASN.1 types for the SNMP PDUs and their tags 125 */ 126 static const char *Context[] = { 127 "GetRequest", 128 #define GETREQ 0 129 "GetNextRequest", 130 #define GETNEXTREQ 1 131 "GetResponse", 132 #define GETRESP 2 133 "SetRequest", 134 #define SETREQ 3 135 "Trap", 136 #define TRAP 4 137 "GetBulk", 138 #define GETBULKREQ 5 139 "Inform", 140 #define INFORMREQ 6 141 "V2Trap", 142 #define V2TRAP 7 143 "Report" 144 #define REPORT 8 145 }; 146 147 #define NOTIFY_CLASS(x) (x == TRAP || x == V2TRAP || x == INFORMREQ) 148 #define READ_CLASS(x) (x == GETREQ || x == GETNEXTREQ || x == GETBULKREQ) 149 #define WRITE_CLASS(x) (x == SETREQ) 150 #define RESPONSE_CLASS(x) (x == GETRESP) 151 #define INTERNAL_CLASS(x) (x == REPORT) 152 153 /* 154 * Context-specific ASN.1 types for the SNMP Exceptions and their tags 155 */ 156 static const char *Exceptions[] = { 157 "noSuchObject", 158 #define NOSUCHOBJECT 0 159 "noSuchInstance", 160 #define NOSUCHINSTANCE 1 161 "endOfMibView", 162 #define ENDOFMIBVIEW 2 163 }; 164 165 /* 166 * Private ASN.1 types 167 * The Internet SMI does not specify any 168 */ 169 static const char *Private[] = { 170 "P-0" 171 }; 172 173 /* 174 * error-status values for any SNMP PDU 175 */ 176 static const char *ErrorStatus[] = { 177 "noError", 178 "tooBig", 179 "noSuchName", 180 "badValue", 181 "readOnly", 182 "genErr", 183 "noAccess", 184 "wrongType", 185 "wrongLength", 186 "wrongEncoding", 187 "wrongValue", 188 "noCreation", 189 "inconsistentValue", 190 "resourceUnavailable", 191 "commitFailed", 192 "undoFailed", 193 "authorizationError", 194 "notWritable", 195 "inconsistentName" 196 }; 197 #define DECODE_ErrorStatus(e) \ 198 ( e >= 0 && (size_t)e < sizeof(ErrorStatus)/sizeof(ErrorStatus[0]) \ 199 ? ErrorStatus[e] \ 200 : (snprintf(errbuf, sizeof(errbuf), "err=%u", e), errbuf)) 201 202 /* 203 * generic-trap values in the SNMP Trap-PDU 204 */ 205 static const char *GenericTrap[] = { 206 "coldStart", 207 "warmStart", 208 "linkDown", 209 "linkUp", 210 "authenticationFailure", 211 "egpNeighborLoss", 212 "enterpriseSpecific" 213 #define GT_ENTERPRISE 6 214 }; 215 #define DECODE_GenericTrap(t) \ 216 ( t >= 0 && (size_t)t < sizeof(GenericTrap)/sizeof(GenericTrap[0]) \ 217 ? GenericTrap[t] \ 218 : (snprintf(buf, sizeof(buf), "gt=%d", t), buf)) 219 220 /* 221 * ASN.1 type class table 222 * Ties together the preceding Universal, Application, Context, and Private 223 * type definitions. 224 */ 225 #define defineCLASS(x) { "x", x, sizeof(x)/sizeof(x[0]) } /* not ANSI-C */ 226 static const struct { 227 const char *name; 228 const char **Id; 229 int numIDs; 230 } Class[] = { 231 defineCLASS(Universal), 232 #define UNIVERSAL 0 233 defineCLASS(Application), 234 #define APPLICATION 1 235 defineCLASS(Context), 236 #define CONTEXT 2 237 defineCLASS(Private), 238 #define PRIVATE 3 239 defineCLASS(Exceptions), 240 #define EXCEPTIONS 4 241 }; 242 243 /* 244 * defined forms for ASN.1 types 245 */ 246 static const char *Form[] = { 247 "Primitive", 248 #define PRIMITIVE 0 249 "Constructed", 250 #define CONSTRUCTED 1 251 }; 252 253 /* 254 * A structure for the OID tree for the compiled-in MIB. 255 * This is stored as a general-order tree. 256 */ 257 static struct obj { 258 const char *desc; /* name of object */ 259 u_char oid; /* sub-id following parent */ 260 u_char type; /* object type (unused) */ 261 struct obj *child, *next; /* child and next sibling pointers */ 262 } *objp = NULL; 263 264 /* 265 * Include the compiled in SNMP MIB. "mib.h" is produced by feeding 266 * RFC-1156 format files into "makemib". "mib.h" MUST define at least 267 * a value for `mibroot'. 268 * 269 * In particular, this is gross, as this is including initialized structures, 270 * and by right shouldn't be an "include" file. 271 */ 272 #include "mib.h" 273 274 /* 275 * This defines a list of OIDs which will be abbreviated on output. 276 * Currently, this includes the prefixes for the Internet MIB, the 277 * private enterprises tree, and the experimental tree. 278 */ 279 #define OID_FIRST_OCTET(x, y) (((x)*40) + (y)) /* X.690 8.19.4 */ 280 281 #ifndef NO_ABREV_MIB 282 static const uint8_t mib_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 2, 1 }; 283 #endif 284 #ifndef NO_ABREV_ENTER 285 static const uint8_t enterprises_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 4, 1 }; 286 #endif 287 #ifndef NO_ABREV_EXPERI 288 static const uint8_t experimental_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 3 }; 289 #endif 290 #ifndef NO_ABBREV_SNMPMODS 291 static const uint8_t snmpModules_oid[] = { OID_FIRST_OCTET(1, 3), 6, 1, 6, 3 }; 292 #endif 293 294 #define OBJ_ABBREV_ENTRY(prefix, obj) \ 295 { prefix, &_ ## obj ## _obj, obj ## _oid, sizeof (obj ## _oid) } 296 static const struct obj_abrev { 297 const char *prefix; /* prefix for this abrev */ 298 struct obj *node; /* pointer into object table */ 299 const uint8_t *oid; /* ASN.1 encoded OID */ 300 size_t oid_len; /* length of OID */ 301 } obj_abrev_list[] = { 302 #ifndef NO_ABREV_MIB 303 /* .iso.org.dod.internet.mgmt.mib */ 304 OBJ_ABBREV_ENTRY("", mib), 305 #endif 306 #ifndef NO_ABREV_ENTER 307 /* .iso.org.dod.internet.private.enterprises */ 308 OBJ_ABBREV_ENTRY("E:", enterprises), 309 #endif 310 #ifndef NO_ABREV_EXPERI 311 /* .iso.org.dod.internet.experimental */ 312 OBJ_ABBREV_ENTRY("X:", experimental), 313 #endif 314 #ifndef NO_ABBREV_SNMPMODS 315 /* .iso.org.dod.internet.snmpV2.snmpModules */ 316 OBJ_ABBREV_ENTRY("S:", snmpModules), 317 #endif 318 { 0,0,0,0 } 319 }; 320 321 /* 322 * This is used in the OID print routine to walk down the object tree 323 * rooted at `mibroot'. 324 */ 325 #define OBJ_PRINT(o, suppressdot) \ 326 { \ 327 if (objp) { \ 328 do { \ 329 if ((o) == objp->oid) \ 330 break; \ 331 } while ((objp = objp->next) != NULL); \ 332 } \ 333 if (objp) { \ 334 ND_PRINT((ndo, suppressdot?"%s":".%s", objp->desc)); \ 335 objp = objp->child; \ 336 } else \ 337 ND_PRINT((ndo, suppressdot?"%u":".%u", (o))); \ 338 } 339 340 /* 341 * This is the definition for the Any-Data-Type storage used purely for 342 * temporary internal representation while decoding an ASN.1 data stream. 343 */ 344 struct be { 345 uint32_t asnlen; 346 union { 347 const uint8_t *raw; 348 int32_t integer; 349 uint32_t uns; 350 const u_char *str; 351 uint64_t uns64; 352 } data; 353 u_short id; 354 u_char form, class; /* tag info */ 355 u_char type; 356 #define BE_ANY 255 357 #define BE_NONE 0 358 #define BE_NULL 1 359 #define BE_OCTET 2 360 #define BE_OID 3 361 #define BE_INT 4 362 #define BE_UNS 5 363 #define BE_STR 6 364 #define BE_SEQ 7 365 #define BE_INETADDR 8 366 #define BE_PDU 9 367 #define BE_UNS64 10 368 #define BE_NOSUCHOBJECT 128 369 #define BE_NOSUCHINST 129 370 #define BE_ENDOFMIBVIEW 130 371 }; 372 373 /* 374 * SNMP versions recognized by this module 375 */ 376 static const char *SnmpVersion[] = { 377 "SNMPv1", 378 #define SNMP_VERSION_1 0 379 "SNMPv2c", 380 #define SNMP_VERSION_2 1 381 "SNMPv2u", 382 #define SNMP_VERSION_2U 2 383 "SNMPv3" 384 #define SNMP_VERSION_3 3 385 }; 386 387 /* 388 * Defaults for SNMP PDU components 389 */ 390 #define DEF_COMMUNITY "public" 391 392 /* 393 * constants for ASN.1 decoding 394 */ 395 #define OIDMUX 40 396 #define ASNLEN_INETADDR 4 397 #define ASN_SHIFT7 7 398 #define ASN_SHIFT8 8 399 #define ASN_BIT8 0x80 400 #define ASN_LONGLEN 0x80 401 402 #define ASN_ID_BITS 0x1f 403 #define ASN_FORM_BITS 0x20 404 #define ASN_FORM_SHIFT 5 405 #define ASN_CLASS_BITS 0xc0 406 #define ASN_CLASS_SHIFT 6 407 408 #define ASN_ID_EXT 0x1f /* extension ID in tag field */ 409 410 /* 411 * This decodes the next ASN.1 object in the stream pointed to by "p" 412 * (and of real-length "len") and stores the intermediate data in the 413 * provided BE object. 414 * 415 * This returns -l if it fails (i.e., the ASN.1 stream is not valid). 416 * O/w, this returns the number of bytes parsed from "p". 417 */ 418 static int 419 asn1_parse(netdissect_options *ndo, 420 register const u_char *p, u_int len, struct be *elem) 421 { 422 u_char form, class, id; 423 int i, hdr; 424 425 elem->asnlen = 0; 426 elem->type = BE_ANY; 427 if (len < 1) { 428 ND_PRINT((ndo, "[nothing to parse]")); 429 return -1; 430 } 431 ND_TCHECK(*p); 432 433 /* 434 * it would be nice to use a bit field, but you can't depend on them. 435 * +---+---+---+---+---+---+---+---+ 436 * + class |frm| id | 437 * +---+---+---+---+---+---+---+---+ 438 * 7 6 5 4 3 2 1 0 439 */ 440 id = *p & ASN_ID_BITS; /* lower 5 bits, range 00-1f */ 441 #ifdef notdef 442 form = (*p & 0xe0) >> 5; /* move upper 3 bits to lower 3 */ 443 class = form >> 1; /* bits 7&6 -> bits 1&0, range 0-3 */ 444 form &= 0x1; /* bit 5 -> bit 0, range 0-1 */ 445 #else 446 form = (u_char)(*p & ASN_FORM_BITS) >> ASN_FORM_SHIFT; 447 class = (u_char)(*p & ASN_CLASS_BITS) >> ASN_CLASS_SHIFT; 448 #endif 449 elem->form = form; 450 elem->class = class; 451 elem->id = id; 452 p++; len--; hdr = 1; 453 /* extended tag field */ 454 if (id == ASN_ID_EXT) { 455 /* 456 * The ID follows, as a sequence of octets with the 457 * 8th bit set and the remaining 7 bits being 458 * the next 7 bits of the value, terminated with 459 * an octet with the 8th bit not set. 460 * 461 * First, assemble all the octets with the 8th 462 * bit set. XXX - this doesn't handle a value 463 * that won't fit in 32 bits. 464 */ 465 id = 0; 466 ND_TCHECK(*p); 467 while (*p & ASN_BIT8) { 468 if (len < 1) { 469 ND_PRINT((ndo, "[Xtagfield?]")); 470 return -1; 471 } 472 id = (id << 7) | (*p & ~ASN_BIT8); 473 len--; 474 hdr++; 475 p++; 476 ND_TCHECK(*p); 477 } 478 if (len < 1) { 479 ND_PRINT((ndo, "[Xtagfield?]")); 480 return -1; 481 } 482 ND_TCHECK(*p); 483 elem->id = id = (id << 7) | *p; 484 --len; 485 ++hdr; 486 ++p; 487 } 488 if (len < 1) { 489 ND_PRINT((ndo, "[no asnlen]")); 490 return -1; 491 } 492 ND_TCHECK(*p); 493 elem->asnlen = *p; 494 p++; len--; hdr++; 495 if (elem->asnlen & ASN_BIT8) { 496 uint32_t noct = elem->asnlen % ASN_BIT8; 497 elem->asnlen = 0; 498 if (len < noct) { 499 ND_PRINT((ndo, "[asnlen? %d<%d]", len, noct)); 500 return -1; 501 } 502 ND_TCHECK2(*p, noct); 503 for (; noct-- > 0; len--, hdr++) 504 elem->asnlen = (elem->asnlen << ASN_SHIFT8) | *p++; 505 } 506 if (len < elem->asnlen) { 507 ND_PRINT((ndo, "[len%d<asnlen%u]", len, elem->asnlen)); 508 return -1; 509 } 510 if (form >= sizeof(Form)/sizeof(Form[0])) { 511 ND_PRINT((ndo, "[form?%d]", form)); 512 return -1; 513 } 514 if (class >= sizeof(Class)/sizeof(Class[0])) { 515 ND_PRINT((ndo, "[class?%c/%d]", *Form[form], class)); 516 return -1; 517 } 518 if ((int)id >= Class[class].numIDs) { 519 ND_PRINT((ndo, "[id?%c/%s/%d]", *Form[form], Class[class].name, id)); 520 return -1; 521 } 522 ND_TCHECK2(*p, elem->asnlen); 523 524 switch (form) { 525 case PRIMITIVE: 526 switch (class) { 527 case UNIVERSAL: 528 switch (id) { 529 case STRING: 530 elem->type = BE_STR; 531 elem->data.str = p; 532 break; 533 534 case INTEGER: { 535 register int32_t data; 536 elem->type = BE_INT; 537 data = 0; 538 539 if (elem->asnlen == 0) { 540 ND_PRINT((ndo, "[asnlen=0]")); 541 return -1; 542 } 543 if (*p & ASN_BIT8) /* negative */ 544 data = -1; 545 for (i = elem->asnlen; i-- > 0; p++) 546 data = (data << ASN_SHIFT8) | *p; 547 elem->data.integer = data; 548 break; 549 } 550 551 case OBJECTID: 552 elem->type = BE_OID; 553 elem->data.raw = (const uint8_t *)p; 554 break; 555 556 case ASN_NULL: 557 elem->type = BE_NULL; 558 elem->data.raw = NULL; 559 break; 560 561 default: 562 elem->type = BE_OCTET; 563 elem->data.raw = (const uint8_t *)p; 564 ND_PRINT((ndo, "[P/U/%s]", Class[class].Id[id])); 565 break; 566 } 567 break; 568 569 case APPLICATION: 570 switch (id) { 571 case IPADDR: 572 elem->type = BE_INETADDR; 573 elem->data.raw = (const uint8_t *)p; 574 break; 575 576 case COUNTER: 577 case GAUGE: 578 case TIMETICKS: { 579 register uint32_t data; 580 elem->type = BE_UNS; 581 data = 0; 582 for (i = elem->asnlen; i-- > 0; p++) 583 data = (data << 8) + *p; 584 elem->data.uns = data; 585 break; 586 } 587 588 case COUNTER64: { 589 register uint64_t data64; 590 elem->type = BE_UNS64; 591 data64 = 0; 592 for (i = elem->asnlen; i-- > 0; p++) 593 data64 = (data64 << 8) + *p; 594 elem->data.uns64 = data64; 595 break; 596 } 597 598 default: 599 elem->type = BE_OCTET; 600 elem->data.raw = (const uint8_t *)p; 601 ND_PRINT((ndo, "[P/A/%s]", 602 Class[class].Id[id])); 603 break; 604 } 605 break; 606 607 case CONTEXT: 608 switch (id) { 609 case NOSUCHOBJECT: 610 elem->type = BE_NOSUCHOBJECT; 611 elem->data.raw = NULL; 612 break; 613 614 case NOSUCHINSTANCE: 615 elem->type = BE_NOSUCHINST; 616 elem->data.raw = NULL; 617 break; 618 619 case ENDOFMIBVIEW: 620 elem->type = BE_ENDOFMIBVIEW; 621 elem->data.raw = NULL; 622 break; 623 } 624 break; 625 626 default: 627 ND_PRINT((ndo, "[P/%s/%s]", Class[class].name, Class[class].Id[id])); 628 elem->type = BE_OCTET; 629 elem->data.raw = (const uint8_t *)p; 630 break; 631 } 632 break; 633 634 case CONSTRUCTED: 635 switch (class) { 636 case UNIVERSAL: 637 switch (id) { 638 case SEQUENCE: 639 elem->type = BE_SEQ; 640 elem->data.raw = (const uint8_t *)p; 641 break; 642 643 default: 644 elem->type = BE_OCTET; 645 elem->data.raw = (const uint8_t *)p; 646 ND_PRINT((ndo, "C/U/%s", Class[class].Id[id])); 647 break; 648 } 649 break; 650 651 case CONTEXT: 652 elem->type = BE_PDU; 653 elem->data.raw = (const uint8_t *)p; 654 break; 655 656 default: 657 elem->type = BE_OCTET; 658 elem->data.raw = (const uint8_t *)p; 659 ND_PRINT((ndo, "C/%s/%s", Class[class].name, Class[class].Id[id])); 660 break; 661 } 662 break; 663 } 664 p += elem->asnlen; 665 len -= elem->asnlen; 666 return elem->asnlen + hdr; 667 668 trunc: 669 ND_PRINT((ndo, "%s", tstr)); 670 return -1; 671 } 672 673 static int 674 asn1_print_octets(netdissect_options *ndo, struct be *elem) 675 { 676 const u_char *p = (const u_char *)elem->data.raw; 677 uint32_t asnlen = elem->asnlen; 678 uint32_t i; 679 680 ND_TCHECK2(*p, asnlen); 681 for (i = asnlen; i-- > 0; p++) 682 ND_PRINT((ndo, "_%.2x", *p)); 683 return 0; 684 685 trunc: 686 ND_PRINT((ndo, "%s", tstr)); 687 return -1; 688 } 689 690 static int 691 asn1_print_string(netdissect_options *ndo, struct be *elem) 692 { 693 register int printable = 1, first = 1; 694 const u_char *p; 695 uint32_t asnlen = elem->asnlen; 696 uint32_t i; 697 698 p = elem->data.str; 699 ND_TCHECK2(*p, asnlen); 700 for (i = asnlen; printable && i-- > 0; p++) 701 printable = ND_ISPRINT(*p); 702 p = elem->data.str; 703 if (printable) { 704 ND_PRINT((ndo, "\"")); 705 if (fn_printn(ndo, p, asnlen, ndo->ndo_snapend)) { 706 ND_PRINT((ndo, "\"")); 707 goto trunc; 708 } 709 ND_PRINT((ndo, "\"")); 710 } else { 711 for (i = asnlen; i-- > 0; p++) { 712 ND_PRINT((ndo, first ? "%.2x" : "_%.2x", *p)); 713 first = 0; 714 } 715 } 716 return 0; 717 718 trunc: 719 ND_PRINT((ndo, "%s", tstr)); 720 return -1; 721 } 722 723 /* 724 * Display the ASN.1 object represented by the BE object. 725 * This used to be an integral part of asn1_parse() before the intermediate 726 * BE form was added. 727 */ 728 static int 729 asn1_print(netdissect_options *ndo, 730 struct be *elem) 731 { 732 const u_char *p; 733 uint32_t asnlen = elem->asnlen; 734 uint32_t i; 735 736 switch (elem->type) { 737 738 case BE_OCTET: 739 if (asn1_print_octets(ndo, elem) == -1) 740 return -1; 741 break; 742 743 case BE_NULL: 744 break; 745 746 case BE_OID: { 747 int o = 0, first = -1; 748 749 p = (const u_char *)elem->data.raw; 750 i = asnlen; 751 if (!ndo->ndo_nflag && asnlen > 2) { 752 const struct obj_abrev *a = &obj_abrev_list[0]; 753 for (; a->node; a++) { 754 if (i < a->oid_len) 755 continue; 756 if (!ND_TTEST2(*p, a->oid_len)) 757 continue; 758 if (memcmp(a->oid, p, a->oid_len) == 0) { 759 objp = a->node->child; 760 i -= a->oid_len; 761 p += a->oid_len; 762 ND_PRINT((ndo, "%s", a->prefix)); 763 first = 1; 764 break; 765 } 766 } 767 } 768 769 for (; i-- > 0; p++) { 770 ND_TCHECK(*p); 771 o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8); 772 if (*p & ASN_LONGLEN) 773 continue; 774 775 /* 776 * first subitem encodes two items with 777 * 1st*OIDMUX+2nd 778 * (see X.690:1997 clause 8.19 for the details) 779 */ 780 if (first < 0) { 781 int s; 782 if (!ndo->ndo_nflag) 783 objp = mibroot; 784 first = 0; 785 s = o / OIDMUX; 786 if (s > 2) s = 2; 787 OBJ_PRINT(s, first); 788 o -= s * OIDMUX; 789 } 790 OBJ_PRINT(o, first); 791 if (--first < 0) 792 first = 0; 793 o = 0; 794 } 795 break; 796 } 797 798 case BE_INT: 799 ND_PRINT((ndo, "%d", elem->data.integer)); 800 break; 801 802 case BE_UNS: 803 ND_PRINT((ndo, "%u", elem->data.uns)); 804 break; 805 806 case BE_UNS64: 807 ND_PRINT((ndo, "%" PRIu64, elem->data.uns64)); 808 break; 809 810 case BE_STR: 811 if (asn1_print_string(ndo, elem) == -1) 812 return -1; 813 break; 814 815 case BE_SEQ: 816 ND_PRINT((ndo, "Seq(%u)", elem->asnlen)); 817 break; 818 819 case BE_INETADDR: 820 if (asnlen != ASNLEN_INETADDR) 821 ND_PRINT((ndo, "[inetaddr len!=%d]", ASNLEN_INETADDR)); 822 p = (const u_char *)elem->data.raw; 823 ND_TCHECK2(*p, asnlen); 824 for (i = asnlen; i-- != 0; p++) { 825 ND_PRINT((ndo, (i == asnlen-1) ? "%u" : ".%u", *p)); 826 } 827 break; 828 829 case BE_NOSUCHOBJECT: 830 case BE_NOSUCHINST: 831 case BE_ENDOFMIBVIEW: 832 ND_PRINT((ndo, "[%s]", Class[EXCEPTIONS].Id[elem->id])); 833 break; 834 835 case BE_PDU: 836 ND_PRINT((ndo, "%s(%u)", Class[CONTEXT].Id[elem->id], elem->asnlen)); 837 break; 838 839 case BE_ANY: 840 ND_PRINT((ndo, "[BE_ANY!?]")); 841 break; 842 843 default: 844 ND_PRINT((ndo, "[be!?]")); 845 break; 846 } 847 return 0; 848 849 trunc: 850 ND_PRINT((ndo, "%s", tstr)); 851 return -1; 852 } 853 854 #ifdef notdef 855 /* 856 * This is a brute force ASN.1 printer: recurses to dump an entire structure. 857 * This will work for any ASN.1 stream, not just an SNMP PDU. 858 * 859 * By adding newlines and spaces at the correct places, this would print in 860 * Rose-Normal-Form. 861 * 862 * This is not currently used. 863 */ 864 static void 865 asn1_decode(u_char *p, u_int length) 866 { 867 struct be elem; 868 int i = 0; 869 870 while (i >= 0 && length > 0) { 871 i = asn1_parse(ndo, p, length, &elem); 872 if (i >= 0) { 873 ND_PRINT((ndo, " ")); 874 if (asn1_print(ndo, &elem) < 0) 875 return; 876 if (elem.type == BE_SEQ || elem.type == BE_PDU) { 877 ND_PRINT((ndo, " {")); 878 asn1_decode(elem.data.raw, elem.asnlen); 879 ND_PRINT((ndo, " }")); 880 } 881 length -= i; 882 p += i; 883 } 884 } 885 } 886 #endif 887 888 #ifdef USE_LIBSMI 889 890 struct smi2be { 891 SmiBasetype basetype; 892 int be; 893 }; 894 895 static const struct smi2be smi2betab[] = { 896 { SMI_BASETYPE_INTEGER32, BE_INT }, 897 { SMI_BASETYPE_OCTETSTRING, BE_STR }, 898 { SMI_BASETYPE_OCTETSTRING, BE_INETADDR }, 899 { SMI_BASETYPE_OBJECTIDENTIFIER, BE_OID }, 900 { SMI_BASETYPE_UNSIGNED32, BE_UNS }, 901 { SMI_BASETYPE_INTEGER64, BE_NONE }, 902 { SMI_BASETYPE_UNSIGNED64, BE_UNS64 }, 903 { SMI_BASETYPE_FLOAT32, BE_NONE }, 904 { SMI_BASETYPE_FLOAT64, BE_NONE }, 905 { SMI_BASETYPE_FLOAT128, BE_NONE }, 906 { SMI_BASETYPE_ENUM, BE_INT }, 907 { SMI_BASETYPE_BITS, BE_STR }, 908 { SMI_BASETYPE_UNKNOWN, BE_NONE } 909 }; 910 911 static int 912 smi_decode_oid(netdissect_options *ndo, 913 struct be *elem, unsigned int *oid, 914 unsigned int oidsize, unsigned int *oidlen) 915 { 916 const u_char *p = (const u_char *)elem->data.raw; 917 uint32_t asnlen = elem->asnlen; 918 int o = 0, first = -1, i = asnlen; 919 unsigned int firstval; 920 921 for (*oidlen = 0; i-- > 0; p++) { 922 ND_TCHECK(*p); 923 o = (o << ASN_SHIFT7) + (*p & ~ASN_BIT8); 924 if (*p & ASN_LONGLEN) 925 continue; 926 927 /* 928 * first subitem encodes two items with 1st*OIDMUX+2nd 929 * (see X.690:1997 clause 8.19 for the details) 930 */ 931 if (first < 0) { 932 first = 0; 933 firstval = o / OIDMUX; 934 if (firstval > 2) firstval = 2; 935 o -= firstval * OIDMUX; 936 if (*oidlen < oidsize) { 937 oid[(*oidlen)++] = firstval; 938 } 939 } 940 if (*oidlen < oidsize) { 941 oid[(*oidlen)++] = o; 942 } 943 o = 0; 944 } 945 return 0; 946 947 trunc: 948 ND_PRINT((ndo, "%s", tstr)); 949 return -1; 950 } 951 952 static int smi_check_type(SmiBasetype basetype, int be) 953 { 954 int i; 955 956 for (i = 0; smi2betab[i].basetype != SMI_BASETYPE_UNKNOWN; i++) { 957 if (smi2betab[i].basetype == basetype && smi2betab[i].be == be) { 958 return 1; 959 } 960 } 961 962 return 0; 963 } 964 965 static int smi_check_a_range(SmiType *smiType, SmiRange *smiRange, 966 struct be *elem) 967 { 968 int ok = 1; 969 970 switch (smiType->basetype) { 971 case SMI_BASETYPE_OBJECTIDENTIFIER: 972 case SMI_BASETYPE_OCTETSTRING: 973 if (smiRange->minValue.value.unsigned32 974 == smiRange->maxValue.value.unsigned32) { 975 ok = (elem->asnlen == smiRange->minValue.value.unsigned32); 976 } else { 977 ok = (elem->asnlen >= smiRange->minValue.value.unsigned32 978 && elem->asnlen <= smiRange->maxValue.value.unsigned32); 979 } 980 break; 981 982 case SMI_BASETYPE_INTEGER32: 983 ok = (elem->data.integer >= smiRange->minValue.value.integer32 984 && elem->data.integer <= smiRange->maxValue.value.integer32); 985 break; 986 987 case SMI_BASETYPE_UNSIGNED32: 988 ok = (elem->data.uns >= smiRange->minValue.value.unsigned32 989 && elem->data.uns <= smiRange->maxValue.value.unsigned32); 990 break; 991 992 case SMI_BASETYPE_UNSIGNED64: 993 /* XXX */ 994 break; 995 996 /* case SMI_BASETYPE_INTEGER64: SMIng */ 997 /* case SMI_BASETYPE_FLOAT32: SMIng */ 998 /* case SMI_BASETYPE_FLOAT64: SMIng */ 999 /* case SMI_BASETYPE_FLOAT128: SMIng */ 1000 1001 case SMI_BASETYPE_ENUM: 1002 case SMI_BASETYPE_BITS: 1003 case SMI_BASETYPE_UNKNOWN: 1004 ok = 1; 1005 break; 1006 1007 default: 1008 ok = 0; 1009 break; 1010 } 1011 1012 return ok; 1013 } 1014 1015 static int smi_check_range(SmiType *smiType, struct be *elem) 1016 { 1017 SmiRange *smiRange; 1018 int ok = 1; 1019 1020 for (smiRange = smiGetFirstRange(smiType); 1021 smiRange; 1022 smiRange = smiGetNextRange(smiRange)) { 1023 1024 ok = smi_check_a_range(smiType, smiRange, elem); 1025 1026 if (ok) { 1027 break; 1028 } 1029 } 1030 1031 if (ok) { 1032 SmiType *parentType; 1033 parentType = smiGetParentType(smiType); 1034 if (parentType) { 1035 ok = smi_check_range(parentType, elem); 1036 } 1037 } 1038 1039 return ok; 1040 } 1041 1042 static SmiNode * 1043 smi_print_variable(netdissect_options *ndo, 1044 struct be *elem, int *status) 1045 { 1046 unsigned int oid[128], oidlen; 1047 SmiNode *smiNode = NULL; 1048 unsigned int i; 1049 1050 if (!nd_smi_module_loaded) { 1051 *status = asn1_print(ndo, elem); 1052 return NULL; 1053 } 1054 *status = smi_decode_oid(ndo, elem, oid, sizeof(oid) / sizeof(unsigned int), 1055 &oidlen); 1056 if (*status < 0) 1057 return NULL; 1058 smiNode = smiGetNodeByOID(oidlen, oid); 1059 if (! smiNode) { 1060 *status = asn1_print(ndo, elem); 1061 return NULL; 1062 } 1063 if (ndo->ndo_vflag) { 1064 ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name)); 1065 } 1066 ND_PRINT((ndo, "%s", smiNode->name)); 1067 if (smiNode->oidlen < oidlen) { 1068 for (i = smiNode->oidlen; i < oidlen; i++) { 1069 ND_PRINT((ndo, ".%u", oid[i])); 1070 } 1071 } 1072 *status = 0; 1073 return smiNode; 1074 } 1075 1076 static int 1077 smi_print_value(netdissect_options *ndo, 1078 SmiNode *smiNode, u_short pduid, struct be *elem) 1079 { 1080 unsigned int i, oid[128], oidlen; 1081 SmiType *smiType; 1082 SmiNamedNumber *nn; 1083 int done = 0; 1084 1085 if (! smiNode || ! (smiNode->nodekind 1086 & (SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN))) { 1087 return asn1_print(ndo, elem); 1088 } 1089 1090 if (elem->type == BE_NOSUCHOBJECT 1091 || elem->type == BE_NOSUCHINST 1092 || elem->type == BE_ENDOFMIBVIEW) { 1093 return asn1_print(ndo, elem); 1094 } 1095 1096 if (NOTIFY_CLASS(pduid) && smiNode->access < SMI_ACCESS_NOTIFY) { 1097 ND_PRINT((ndo, "[notNotifyable]")); 1098 } 1099 1100 if (READ_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_ONLY) { 1101 ND_PRINT((ndo, "[notReadable]")); 1102 } 1103 1104 if (WRITE_CLASS(pduid) && smiNode->access < SMI_ACCESS_READ_WRITE) { 1105 ND_PRINT((ndo, "[notWritable]")); 1106 } 1107 1108 if (RESPONSE_CLASS(pduid) 1109 && smiNode->access == SMI_ACCESS_NOT_ACCESSIBLE) { 1110 ND_PRINT((ndo, "[noAccess]")); 1111 } 1112 1113 smiType = smiGetNodeType(smiNode); 1114 if (! smiType) { 1115 return asn1_print(ndo, elem); 1116 } 1117 1118 if (! smi_check_type(smiType->basetype, elem->type)) { 1119 ND_PRINT((ndo, "[wrongType]")); 1120 } 1121 1122 if (! smi_check_range(smiType, elem)) { 1123 ND_PRINT((ndo, "[outOfRange]")); 1124 } 1125 1126 /* resolve bits to named bits */ 1127 1128 /* check whether instance identifier is valid */ 1129 1130 /* apply display hints (integer, octetstring) */ 1131 1132 /* convert instance identifier to index type values */ 1133 1134 switch (elem->type) { 1135 case BE_OID: 1136 if (smiType->basetype == SMI_BASETYPE_BITS) { 1137 /* print bit labels */ 1138 } else { 1139 if (nd_smi_module_loaded && 1140 smi_decode_oid(ndo, elem, oid, 1141 sizeof(oid)/sizeof(unsigned int), 1142 &oidlen) == 0) { 1143 smiNode = smiGetNodeByOID(oidlen, oid); 1144 if (smiNode) { 1145 if (ndo->ndo_vflag) { 1146 ND_PRINT((ndo, "%s::", smiGetNodeModule(smiNode)->name)); 1147 } 1148 ND_PRINT((ndo, "%s", smiNode->name)); 1149 if (smiNode->oidlen < oidlen) { 1150 for (i = smiNode->oidlen; 1151 i < oidlen; i++) { 1152 ND_PRINT((ndo, ".%u", oid[i])); 1153 } 1154 } 1155 done++; 1156 } 1157 } 1158 } 1159 break; 1160 1161 case BE_INT: 1162 if (smiType->basetype == SMI_BASETYPE_ENUM) { 1163 for (nn = smiGetFirstNamedNumber(smiType); 1164 nn; 1165 nn = smiGetNextNamedNumber(nn)) { 1166 if (nn->value.value.integer32 1167 == elem->data.integer) { 1168 ND_PRINT((ndo, "%s", nn->name)); 1169 ND_PRINT((ndo, "(%d)", elem->data.integer)); 1170 done++; 1171 break; 1172 } 1173 } 1174 } 1175 break; 1176 } 1177 1178 if (! done) { 1179 return asn1_print(ndo, elem); 1180 } 1181 return 0; 1182 } 1183 #endif 1184 1185 /* 1186 * General SNMP header 1187 * SEQUENCE { 1188 * version INTEGER {version-1(0)}, 1189 * community OCTET STRING, 1190 * data ANY -- PDUs 1191 * } 1192 * PDUs for all but Trap: (see rfc1157 from page 15 on) 1193 * SEQUENCE { 1194 * request-id INTEGER, 1195 * error-status INTEGER, 1196 * error-index INTEGER, 1197 * varbindlist SEQUENCE OF 1198 * SEQUENCE { 1199 * name ObjectName, 1200 * value ObjectValue 1201 * } 1202 * } 1203 * PDU for Trap: 1204 * SEQUENCE { 1205 * enterprise OBJECT IDENTIFIER, 1206 * agent-addr NetworkAddress, 1207 * generic-trap INTEGER, 1208 * specific-trap INTEGER, 1209 * time-stamp TimeTicks, 1210 * varbindlist SEQUENCE OF 1211 * SEQUENCE { 1212 * name ObjectName, 1213 * value ObjectValue 1214 * } 1215 * } 1216 */ 1217 1218 /* 1219 * Decode SNMP varBind 1220 */ 1221 static void 1222 varbind_print(netdissect_options *ndo, 1223 u_short pduid, const u_char *np, u_int length) 1224 { 1225 struct be elem; 1226 int count = 0, ind; 1227 #ifdef USE_LIBSMI 1228 SmiNode *smiNode = NULL; 1229 #endif 1230 int status; 1231 1232 /* Sequence of varBind */ 1233 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1234 return; 1235 if (elem.type != BE_SEQ) { 1236 ND_PRINT((ndo, "[!SEQ of varbind]")); 1237 asn1_print(ndo, &elem); 1238 return; 1239 } 1240 if ((u_int)count < length) 1241 ND_PRINT((ndo, "[%d extra after SEQ of varbind]", length - count)); 1242 /* descend */ 1243 length = elem.asnlen; 1244 np = (const u_char *)elem.data.raw; 1245 1246 for (ind = 1; length > 0; ind++) { 1247 const u_char *vbend; 1248 u_int vblength; 1249 1250 ND_PRINT((ndo, " ")); 1251 1252 /* Sequence */ 1253 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1254 return; 1255 if (elem.type != BE_SEQ) { 1256 ND_PRINT((ndo, "[!varbind]")); 1257 asn1_print(ndo, &elem); 1258 return; 1259 } 1260 vbend = np + count; 1261 vblength = length - count; 1262 /* descend */ 1263 length = elem.asnlen; 1264 np = (const u_char *)elem.data.raw; 1265 1266 /* objName (OID) */ 1267 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1268 return; 1269 if (elem.type != BE_OID) { 1270 ND_PRINT((ndo, "[objName!=OID]")); 1271 asn1_print(ndo, &elem); 1272 return; 1273 } 1274 #ifdef USE_LIBSMI 1275 smiNode = smi_print_variable(ndo, &elem, &status); 1276 #else 1277 status = asn1_print(ndo, &elem); 1278 #endif 1279 if (status < 0) 1280 return; 1281 length -= count; 1282 np += count; 1283 1284 if (pduid != GETREQ && pduid != GETNEXTREQ 1285 && pduid != GETBULKREQ) 1286 ND_PRINT((ndo, "=")); 1287 1288 /* objVal (ANY) */ 1289 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1290 return; 1291 if (pduid == GETREQ || pduid == GETNEXTREQ 1292 || pduid == GETBULKREQ) { 1293 if (elem.type != BE_NULL) { 1294 ND_PRINT((ndo, "[objVal!=NULL]")); 1295 if (asn1_print(ndo, &elem) < 0) 1296 return; 1297 } 1298 } else { 1299 if (elem.type != BE_NULL) { 1300 #ifdef USE_LIBSMI 1301 status = smi_print_value(ndo, smiNode, pduid, &elem); 1302 #else 1303 status = asn1_print(ndo, &elem); 1304 #endif 1305 } 1306 if (status < 0) 1307 return; 1308 } 1309 length = vblength; 1310 np = vbend; 1311 } 1312 } 1313 1314 /* 1315 * Decode SNMP PDUs: GetRequest, GetNextRequest, GetResponse, SetRequest, 1316 * GetBulk, Inform, V2Trap, and Report 1317 */ 1318 static void 1319 snmppdu_print(netdissect_options *ndo, 1320 u_short pduid, const u_char *np, u_int length) 1321 { 1322 struct be elem; 1323 int count = 0, error_status; 1324 1325 /* reqId (Integer) */ 1326 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1327 return; 1328 if (elem.type != BE_INT) { 1329 ND_PRINT((ndo, "[reqId!=INT]")); 1330 asn1_print(ndo, &elem); 1331 return; 1332 } 1333 if (ndo->ndo_vflag) 1334 ND_PRINT((ndo, "R=%d ", elem.data.integer)); 1335 length -= count; 1336 np += count; 1337 1338 /* errorStatus (Integer) */ 1339 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1340 return; 1341 if (elem.type != BE_INT) { 1342 ND_PRINT((ndo, "[errorStatus!=INT]")); 1343 asn1_print(ndo, &elem); 1344 return; 1345 } 1346 error_status = 0; 1347 if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ 1348 || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT) 1349 && elem.data.integer != 0) { 1350 char errbuf[20]; 1351 ND_PRINT((ndo, "[errorStatus(%s)!=0]", 1352 DECODE_ErrorStatus(elem.data.integer))); 1353 } else if (pduid == GETBULKREQ) { 1354 ND_PRINT((ndo, " N=%d", elem.data.integer)); 1355 } else if (elem.data.integer != 0) { 1356 char errbuf[20]; 1357 ND_PRINT((ndo, " %s", DECODE_ErrorStatus(elem.data.integer))); 1358 error_status = elem.data.integer; 1359 } 1360 length -= count; 1361 np += count; 1362 1363 /* errorIndex (Integer) */ 1364 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1365 return; 1366 if (elem.type != BE_INT) { 1367 ND_PRINT((ndo, "[errorIndex!=INT]")); 1368 asn1_print(ndo, &elem); 1369 return; 1370 } 1371 if ((pduid == GETREQ || pduid == GETNEXTREQ || pduid == SETREQ 1372 || pduid == INFORMREQ || pduid == V2TRAP || pduid == REPORT) 1373 && elem.data.integer != 0) 1374 ND_PRINT((ndo, "[errorIndex(%d)!=0]", elem.data.integer)); 1375 else if (pduid == GETBULKREQ) 1376 ND_PRINT((ndo, " M=%d", elem.data.integer)); 1377 else if (elem.data.integer != 0) { 1378 if (!error_status) 1379 ND_PRINT((ndo, "[errorIndex(%d) w/o errorStatus]", elem.data.integer)); 1380 else 1381 ND_PRINT((ndo, "@%d", elem.data.integer)); 1382 } else if (error_status) { 1383 ND_PRINT((ndo, "[errorIndex==0]")); 1384 } 1385 length -= count; 1386 np += count; 1387 1388 varbind_print(ndo, pduid, np, length); 1389 return; 1390 } 1391 1392 /* 1393 * Decode SNMP Trap PDU 1394 */ 1395 static void 1396 trappdu_print(netdissect_options *ndo, 1397 const u_char *np, u_int length) 1398 { 1399 struct be elem; 1400 int count = 0, generic; 1401 1402 ND_PRINT((ndo, " ")); 1403 1404 /* enterprise (oid) */ 1405 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1406 return; 1407 if (elem.type != BE_OID) { 1408 ND_PRINT((ndo, "[enterprise!=OID]")); 1409 asn1_print(ndo, &elem); 1410 return; 1411 } 1412 if (asn1_print(ndo, &elem) < 0) 1413 return; 1414 length -= count; 1415 np += count; 1416 1417 ND_PRINT((ndo, " ")); 1418 1419 /* agent-addr (inetaddr) */ 1420 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1421 return; 1422 if (elem.type != BE_INETADDR) { 1423 ND_PRINT((ndo, "[agent-addr!=INETADDR]")); 1424 asn1_print(ndo, &elem); 1425 return; 1426 } 1427 if (asn1_print(ndo, &elem) < 0) 1428 return; 1429 length -= count; 1430 np += count; 1431 1432 /* generic-trap (Integer) */ 1433 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1434 return; 1435 if (elem.type != BE_INT) { 1436 ND_PRINT((ndo, "[generic-trap!=INT]")); 1437 asn1_print(ndo, &elem); 1438 return; 1439 } 1440 generic = elem.data.integer; 1441 { 1442 char buf[20]; 1443 ND_PRINT((ndo, " %s", DECODE_GenericTrap(generic))); 1444 } 1445 length -= count; 1446 np += count; 1447 1448 /* specific-trap (Integer) */ 1449 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1450 return; 1451 if (elem.type != BE_INT) { 1452 ND_PRINT((ndo, "[specific-trap!=INT]")); 1453 asn1_print(ndo, &elem); 1454 return; 1455 } 1456 if (generic != GT_ENTERPRISE) { 1457 if (elem.data.integer != 0) 1458 ND_PRINT((ndo, "[specific-trap(%d)!=0]", elem.data.integer)); 1459 } else 1460 ND_PRINT((ndo, " s=%d", elem.data.integer)); 1461 length -= count; 1462 np += count; 1463 1464 ND_PRINT((ndo, " ")); 1465 1466 /* time-stamp (TimeTicks) */ 1467 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1468 return; 1469 if (elem.type != BE_UNS) { /* XXX */ 1470 ND_PRINT((ndo, "[time-stamp!=TIMETICKS]")); 1471 asn1_print(ndo, &elem); 1472 return; 1473 } 1474 if (asn1_print(ndo, &elem) < 0) 1475 return; 1476 length -= count; 1477 np += count; 1478 1479 varbind_print(ndo, TRAP, np, length); 1480 return; 1481 } 1482 1483 /* 1484 * Decode arbitrary SNMP PDUs. 1485 */ 1486 static void 1487 pdu_print(netdissect_options *ndo, 1488 const u_char *np, u_int length, int version) 1489 { 1490 struct be pdu; 1491 int count = 0; 1492 1493 /* PDU (Context) */ 1494 if ((count = asn1_parse(ndo, np, length, &pdu)) < 0) 1495 return; 1496 if (pdu.type != BE_PDU) { 1497 ND_PRINT((ndo, "[no PDU]")); 1498 return; 1499 } 1500 if ((u_int)count < length) 1501 ND_PRINT((ndo, "[%d extra after PDU]", length - count)); 1502 if (ndo->ndo_vflag) { 1503 ND_PRINT((ndo, "{ ")); 1504 } 1505 if (asn1_print(ndo, &pdu) < 0) 1506 return; 1507 ND_PRINT((ndo, " ")); 1508 /* descend into PDU */ 1509 length = pdu.asnlen; 1510 np = (const u_char *)pdu.data.raw; 1511 1512 if (version == SNMP_VERSION_1 && 1513 (pdu.id == GETBULKREQ || pdu.id == INFORMREQ || 1514 pdu.id == V2TRAP || pdu.id == REPORT)) { 1515 ND_PRINT((ndo, "[v2 PDU in v1 message]")); 1516 return; 1517 } 1518 1519 if (version == SNMP_VERSION_2 && pdu.id == TRAP) { 1520 ND_PRINT((ndo, "[v1 PDU in v2 message]")); 1521 return; 1522 } 1523 1524 switch (pdu.id) { 1525 case TRAP: 1526 trappdu_print(ndo, np, length); 1527 break; 1528 case GETREQ: 1529 case GETNEXTREQ: 1530 case GETRESP: 1531 case SETREQ: 1532 case GETBULKREQ: 1533 case INFORMREQ: 1534 case V2TRAP: 1535 case REPORT: 1536 snmppdu_print(ndo, pdu.id, np, length); 1537 break; 1538 } 1539 1540 if (ndo->ndo_vflag) { 1541 ND_PRINT((ndo, " } ")); 1542 } 1543 } 1544 1545 /* 1546 * Decode a scoped SNMP PDU. 1547 */ 1548 static void 1549 scopedpdu_print(netdissect_options *ndo, 1550 const u_char *np, u_int length, int version) 1551 { 1552 struct be elem; 1553 int count = 0; 1554 1555 /* Sequence */ 1556 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1557 return; 1558 if (elem.type != BE_SEQ) { 1559 ND_PRINT((ndo, "[!scoped PDU]")); 1560 asn1_print(ndo, &elem); 1561 return; 1562 } 1563 length = elem.asnlen; 1564 np = (const u_char *)elem.data.raw; 1565 1566 /* contextEngineID (OCTET STRING) */ 1567 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1568 return; 1569 if (elem.type != BE_STR) { 1570 ND_PRINT((ndo, "[contextEngineID!=STR]")); 1571 asn1_print(ndo, &elem); 1572 return; 1573 } 1574 length -= count; 1575 np += count; 1576 1577 ND_PRINT((ndo, "E=")); 1578 if (asn1_print_octets(ndo, &elem) == -1) 1579 return; 1580 ND_PRINT((ndo, " ")); 1581 1582 /* contextName (OCTET STRING) */ 1583 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1584 return; 1585 if (elem.type != BE_STR) { 1586 ND_PRINT((ndo, "[contextName!=STR]")); 1587 asn1_print(ndo, &elem); 1588 return; 1589 } 1590 length -= count; 1591 np += count; 1592 1593 ND_PRINT((ndo, "C=")); 1594 if (asn1_print_string(ndo, &elem) == -1) 1595 return; 1596 ND_PRINT((ndo, " ")); 1597 1598 pdu_print(ndo, np, length, version); 1599 } 1600 1601 /* 1602 * Decode SNMP Community Header (SNMPv1 and SNMPv2c) 1603 */ 1604 static void 1605 community_print(netdissect_options *ndo, 1606 const u_char *np, u_int length, int version) 1607 { 1608 struct be elem; 1609 int count = 0; 1610 1611 /* Community (String) */ 1612 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1613 return; 1614 if (elem.type != BE_STR) { 1615 ND_PRINT((ndo, "[comm!=STR]")); 1616 asn1_print(ndo, &elem); 1617 return; 1618 } 1619 /* default community */ 1620 if (!(elem.asnlen == sizeof(DEF_COMMUNITY) - 1 && 1621 strncmp((const char *)elem.data.str, DEF_COMMUNITY, 1622 sizeof(DEF_COMMUNITY) - 1) == 0)) { 1623 /* ! "public" */ 1624 ND_PRINT((ndo, "C=")); 1625 if (asn1_print_string(ndo, &elem) == -1) 1626 return; 1627 ND_PRINT((ndo, " ")); 1628 } 1629 length -= count; 1630 np += count; 1631 1632 pdu_print(ndo, np, length, version); 1633 } 1634 1635 /* 1636 * Decode SNMPv3 User-based Security Message Header (SNMPv3) 1637 */ 1638 static void 1639 usm_print(netdissect_options *ndo, 1640 const u_char *np, u_int length) 1641 { 1642 struct be elem; 1643 int count = 0; 1644 1645 /* Sequence */ 1646 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1647 return; 1648 if (elem.type != BE_SEQ) { 1649 ND_PRINT((ndo, "[!usm]")); 1650 asn1_print(ndo, &elem); 1651 return; 1652 } 1653 length = elem.asnlen; 1654 np = (const u_char *)elem.data.raw; 1655 1656 /* msgAuthoritativeEngineID (OCTET STRING) */ 1657 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1658 return; 1659 if (elem.type != BE_STR) { 1660 ND_PRINT((ndo, "[msgAuthoritativeEngineID!=STR]")); 1661 asn1_print(ndo, &elem); 1662 return; 1663 } 1664 length -= count; 1665 np += count; 1666 1667 /* msgAuthoritativeEngineBoots (INTEGER) */ 1668 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1669 return; 1670 if (elem.type != BE_INT) { 1671 ND_PRINT((ndo, "[msgAuthoritativeEngineBoots!=INT]")); 1672 asn1_print(ndo, &elem); 1673 return; 1674 } 1675 if (ndo->ndo_vflag) 1676 ND_PRINT((ndo, "B=%d ", elem.data.integer)); 1677 length -= count; 1678 np += count; 1679 1680 /* msgAuthoritativeEngineTime (INTEGER) */ 1681 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1682 return; 1683 if (elem.type != BE_INT) { 1684 ND_PRINT((ndo, "[msgAuthoritativeEngineTime!=INT]")); 1685 asn1_print(ndo, &elem); 1686 return; 1687 } 1688 if (ndo->ndo_vflag) 1689 ND_PRINT((ndo, "T=%d ", elem.data.integer)); 1690 length -= count; 1691 np += count; 1692 1693 /* msgUserName (OCTET STRING) */ 1694 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1695 return; 1696 if (elem.type != BE_STR) { 1697 ND_PRINT((ndo, "[msgUserName!=STR]")); 1698 asn1_print(ndo, &elem); 1699 return; 1700 } 1701 length -= count; 1702 np += count; 1703 1704 ND_PRINT((ndo, "U=")); 1705 if (asn1_print_string(ndo, &elem) == -1) 1706 return; 1707 ND_PRINT((ndo, " ")); 1708 1709 /* msgAuthenticationParameters (OCTET STRING) */ 1710 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1711 return; 1712 if (elem.type != BE_STR) { 1713 ND_PRINT((ndo, "[msgAuthenticationParameters!=STR]")); 1714 asn1_print(ndo, &elem); 1715 return; 1716 } 1717 length -= count; 1718 np += count; 1719 1720 /* msgPrivacyParameters (OCTET STRING) */ 1721 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1722 return; 1723 if (elem.type != BE_STR) { 1724 ND_PRINT((ndo, "[msgPrivacyParameters!=STR]")); 1725 asn1_print(ndo, &elem); 1726 return; 1727 } 1728 length -= count; 1729 np += count; 1730 1731 if ((u_int)count < length) 1732 ND_PRINT((ndo, "[%d extra after usm SEQ]", length - count)); 1733 } 1734 1735 /* 1736 * Decode SNMPv3 Message Header (SNMPv3) 1737 */ 1738 static void 1739 v3msg_print(netdissect_options *ndo, 1740 const u_char *np, u_int length) 1741 { 1742 struct be elem; 1743 int count = 0; 1744 u_char flags; 1745 int model; 1746 const u_char *xnp = np; 1747 int xlength = length; 1748 1749 /* Sequence */ 1750 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1751 return; 1752 if (elem.type != BE_SEQ) { 1753 ND_PRINT((ndo, "[!message]")); 1754 asn1_print(ndo, &elem); 1755 return; 1756 } 1757 length = elem.asnlen; 1758 np = (const u_char *)elem.data.raw; 1759 1760 if (ndo->ndo_vflag) { 1761 ND_PRINT((ndo, "{ ")); 1762 } 1763 1764 /* msgID (INTEGER) */ 1765 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1766 return; 1767 if (elem.type != BE_INT) { 1768 ND_PRINT((ndo, "[msgID!=INT]")); 1769 asn1_print(ndo, &elem); 1770 return; 1771 } 1772 length -= count; 1773 np += count; 1774 1775 /* msgMaxSize (INTEGER) */ 1776 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1777 return; 1778 if (elem.type != BE_INT) { 1779 ND_PRINT((ndo, "[msgMaxSize!=INT]")); 1780 asn1_print(ndo, &elem); 1781 return; 1782 } 1783 length -= count; 1784 np += count; 1785 1786 /* msgFlags (OCTET STRING) */ 1787 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1788 return; 1789 if (elem.type != BE_STR) { 1790 ND_PRINT((ndo, "[msgFlags!=STR]")); 1791 asn1_print(ndo, &elem); 1792 return; 1793 } 1794 if (elem.asnlen != 1) { 1795 ND_PRINT((ndo, "[msgFlags size %d]", elem.asnlen)); 1796 return; 1797 } 1798 flags = elem.data.str[0]; 1799 if (flags != 0x00 && flags != 0x01 && flags != 0x03 1800 && flags != 0x04 && flags != 0x05 && flags != 0x07) { 1801 ND_PRINT((ndo, "[msgFlags=0x%02X]", flags)); 1802 return; 1803 } 1804 length -= count; 1805 np += count; 1806 1807 ND_PRINT((ndo, "F=%s%s%s ", 1808 flags & 0x01 ? "a" : "", 1809 flags & 0x02 ? "p" : "", 1810 flags & 0x04 ? "r" : "")); 1811 1812 /* msgSecurityModel (INTEGER) */ 1813 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1814 return; 1815 if (elem.type != BE_INT) { 1816 ND_PRINT((ndo, "[msgSecurityModel!=INT]")); 1817 asn1_print(ndo, &elem); 1818 return; 1819 } 1820 model = elem.data.integer; 1821 length -= count; 1822 np += count; 1823 1824 if ((u_int)count < length) 1825 ND_PRINT((ndo, "[%d extra after message SEQ]", length - count)); 1826 1827 if (ndo->ndo_vflag) { 1828 ND_PRINT((ndo, "} ")); 1829 } 1830 1831 if (model == 3) { 1832 if (ndo->ndo_vflag) { 1833 ND_PRINT((ndo, "{ USM ")); 1834 } 1835 } else { 1836 ND_PRINT((ndo, "[security model %d]", model)); 1837 return; 1838 } 1839 1840 np = xnp + (np - xnp); 1841 length = xlength - (np - xnp); 1842 1843 /* msgSecurityParameters (OCTET STRING) */ 1844 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1845 return; 1846 if (elem.type != BE_STR) { 1847 ND_PRINT((ndo, "[msgSecurityParameters!=STR]")); 1848 asn1_print(ndo, &elem); 1849 return; 1850 } 1851 length -= count; 1852 np += count; 1853 1854 if (model == 3) { 1855 usm_print(ndo, elem.data.str, elem.asnlen); 1856 if (ndo->ndo_vflag) { 1857 ND_PRINT((ndo, "} ")); 1858 } 1859 } 1860 1861 if (ndo->ndo_vflag) { 1862 ND_PRINT((ndo, "{ ScopedPDU ")); 1863 } 1864 1865 scopedpdu_print(ndo, np, length, 3); 1866 1867 if (ndo->ndo_vflag) { 1868 ND_PRINT((ndo, "} ")); 1869 } 1870 } 1871 1872 /* 1873 * Decode SNMP header and pass on to PDU printing routines 1874 */ 1875 void 1876 snmp_print(netdissect_options *ndo, 1877 const u_char *np, u_int length) 1878 { 1879 struct be elem; 1880 int count = 0; 1881 int version = 0; 1882 1883 ND_PRINT((ndo, " ")); 1884 1885 /* initial Sequence */ 1886 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1887 return; 1888 if (elem.type != BE_SEQ) { 1889 ND_PRINT((ndo, "[!init SEQ]")); 1890 asn1_print(ndo, &elem); 1891 return; 1892 } 1893 if ((u_int)count < length) 1894 ND_PRINT((ndo, "[%d extra after iSEQ]", length - count)); 1895 /* descend */ 1896 length = elem.asnlen; 1897 np = (const u_char *)elem.data.raw; 1898 1899 /* Version (INTEGER) */ 1900 if ((count = asn1_parse(ndo, np, length, &elem)) < 0) 1901 return; 1902 if (elem.type != BE_INT) { 1903 ND_PRINT((ndo, "[version!=INT]")); 1904 asn1_print(ndo, &elem); 1905 return; 1906 } 1907 1908 switch (elem.data.integer) { 1909 case SNMP_VERSION_1: 1910 case SNMP_VERSION_2: 1911 case SNMP_VERSION_3: 1912 if (ndo->ndo_vflag) 1913 ND_PRINT((ndo, "{ %s ", SnmpVersion[elem.data.integer])); 1914 break; 1915 default: 1916 ND_PRINT((ndo, "SNMP [version = %d]", elem.data.integer)); 1917 return; 1918 } 1919 version = elem.data.integer; 1920 length -= count; 1921 np += count; 1922 1923 switch (version) { 1924 case SNMP_VERSION_1: 1925 case SNMP_VERSION_2: 1926 community_print(ndo, np, length, version); 1927 break; 1928 case SNMP_VERSION_3: 1929 v3msg_print(ndo, np, length); 1930 break; 1931 default: 1932 ND_PRINT((ndo, "[version = %d]", elem.data.integer)); 1933 break; 1934 } 1935 1936 if (ndo->ndo_vflag) { 1937 ND_PRINT((ndo, "} ")); 1938 } 1939 } 1940
