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