231f88b06bebca7cc84d659ce24acc2fcab61c60
[metze/wireshark/wip.git] / epan / dissectors / packet-snmp.c
1 /* Do not modify this file. Changes will be overwritten.                      */
2 /* Generated automatically by the ASN.1 to Wireshark dissector compiler       */
3 /* packet-snmp.c                                                              */
4 /* ../../tools/asn2wrs.py -b -p snmp -c ./snmp.cnf -s ./packet-snmp-template -D . -O ../../epan/dissectors snmp.asn */
5
6 /* Input file: packet-snmp-template.c */
7
8 #line 1 "../../asn1/snmp/packet-snmp-template.c"
9 /* packet-snmp.c
10  * Routines for SNMP (simple network management protocol)
11  * Copyright (C) 1998 Didier Jorand
12  *
13  * See RFC 1157 for SNMPv1.
14  *
15  * See RFCs 1901, 1905, and 1906 for SNMPv2c.
16  *
17  * See RFCs 1905, 1906, 1909, and 1910 for SNMPv2u [historic].
18  *
19  * See RFCs 2570-2576 for SNMPv3
20  * Updated to use the asn2wrs compiler made by Tomas Kukosa
21  * Copyright (C) 2005 - 2006 Anders Broman [AT] ericsson.com
22  *
23  * See RFC 3414 for User-based Security Model for SNMPv3
24  * See RFC 3826 for  (AES) Cipher Algorithm in the SNMP USM
25  * See RFC 2578 for Structure of Management Information Version 2 (SMIv2)
26  * Copyright (C) 2007 Luis E. Garcia Ontanon <luis@ontanon.org>
27  *
28  * $Id$
29  *
30  * Wireshark - Network traffic analyzer
31  * By Gerald Combs <gerald@wireshark.org>
32  * Copyright 1998 Gerald Combs
33  *
34  * Some stuff from:
35  *
36  * GXSNMP -- An snmp mangament application
37  * Copyright (C) 1998 Gregory McLean & Jochen Friedrich
38  * Beholder RMON ethernet network monitor,Copyright (C) 1993 DNPAP group
39  *
40  * This program is free software; you can redistribute it and/or
41  * modify it under the terms of the GNU General Public License
42  * as published by the Free Software Foundation; either version 2
43  * of the License, or (at your option) any later version.
44  *
45  * This program is distributed in the hope that it will be useful,
46  * but WITHOUT ANY WARRANTY; without even the implied warranty of
47  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
48  * GNU General Public License for more details.
49  *
50  * You should have received a copy of the GNU General Public License
51  * along with this program; if not, write to the Free Software
52  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
53  */
54
55 #define D(args) do {printf args; fflush(stdout); } while(0)
56
57 #include "config.h"
58
59 #include <string.h>
60 #include <ctype.h>
61
62 #include <glib.h>
63
64 #include <epan/packet.h>
65 #include <epan/strutil.h>
66 #include <epan/conversation.h>
67 #include <epan/etypes.h>
68 #include <epan/prefs.h>
69 #include <epan/sminmpec.h>
70 #include <epan/emem.h>
71 #include <epan/next_tvb.h>
72 #include <epan/uat.h>
73 #include <epan/asn1.h>
74 #include "packet-ipx.h"
75 #include "packet-hpext.h"
76
77
78 #include "packet-ber.h"
79
80 #include "packet-snmp.h"
81
82 #include <epan/crypt/sha1.h>
83 #include <epan/crypt/md5.h>
84 #include <epan/expert.h>
85 #include <epan/report_err.h>
86 #include <epan/oids.h>
87
88
89 #ifdef HAVE_LIBGCRYPT
90 #include <wsutil/wsgcrypt.h>
91 #endif
92
93 /* Take a pointer that may be null and return a pointer that's not null
94    by turning null pointers into pointers to the above null string,
95    and, if the argument pointer wasn't null, make sure we handle
96    non-printable characters in the string by escaping them. */
97 #define SAFE_STRING(s, l)       (((s) != NULL) ? format_text((s), (l)) : "")
98
99 #define PNAME  "Simple Network Management Protocol"
100 #define PSNAME "SNMP"
101 #define PFNAME "snmp"
102
103 #define UDP_PORT_SNMP           161
104 #define UDP_PORT_SNMP_TRAP      162
105 #define TCP_PORT_SNMP           161
106 #define TCP_PORT_SNMP_TRAP      162
107 #define TCP_PORT_SMUX           199
108 #define UDP_PORT_SNMP_PATROL 8161
109
110 /* Initialize the protocol and registered fields */
111 static int proto_snmp = -1;
112 static int proto_smux = -1;
113
114 static gboolean display_oid = TRUE;
115 static gboolean snmp_var_in_tree = TRUE;
116
117 void proto_register_snmp(void);
118 void proto_reg_handoff_snmp(void);
119 void proto_register_smux(void);
120 void proto_reg_handoff_smux(void);
121
122 static gboolean snmp_usm_auth_md5(snmp_usm_params_t* p, guint8**, guint*, gchar const**);
123 static gboolean snmp_usm_auth_sha1(snmp_usm_params_t* p, guint8**, guint*, gchar const**);
124
125 static tvbuff_t* snmp_usm_priv_des(snmp_usm_params_t*, tvbuff_t*, gchar const**);
126 static tvbuff_t* snmp_usm_priv_aes128(snmp_usm_params_t*, tvbuff_t*, gchar const**);
127 static tvbuff_t* snmp_usm_priv_aes192(snmp_usm_params_t*, tvbuff_t*, gchar const**);
128 static tvbuff_t* snmp_usm_priv_aes256(snmp_usm_params_t*, tvbuff_t*, gchar const**);
129
130
131 static void snmp_usm_password_to_key_md5(const guint8 *password, guint passwordlen, const guint8 *engineID, guint engineLength, guint8 *key);
132 static void snmp_usm_password_to_key_sha1(const guint8 *password, guint passwordlen, const guint8 *engineID, guint engineLength, guint8 *key);
133
134
135 static snmp_usm_auth_model_t model_md5 = {snmp_usm_password_to_key_md5, snmp_usm_auth_md5, 16};
136 static snmp_usm_auth_model_t model_sha1 = {snmp_usm_password_to_key_sha1, snmp_usm_auth_sha1, 20};
137
138 static const value_string auth_types[] = {
139         {0,"MD5"},
140         {1,"SHA1"},
141         {0,NULL}
142 };
143 static snmp_usm_auth_model_t* auth_models[] = {&model_md5,&model_sha1};
144
145 #define PRIV_DES     0
146 #define PRIV_AES128  1
147 #define PRIV_AES192  2
148 #define PRIV_AES256  3
149
150 static const value_string priv_types[] = {
151         { PRIV_DES,    "DES" },
152         { PRIV_AES128, "AES" },
153         { PRIV_AES192, "AES192" },
154         { PRIV_AES256, "AES256" },
155         { 0, NULL}
156 };
157 static snmp_usm_decoder_t priv_protos[] = {
158         snmp_usm_priv_des,
159         snmp_usm_priv_aes128,
160         snmp_usm_priv_aes192,
161         snmp_usm_priv_aes256
162 };
163
164 static snmp_ue_assoc_t* ueas = NULL;
165 static guint num_ueas = 0;
166 static snmp_ue_assoc_t* localized_ues = NULL;
167 static snmp_ue_assoc_t* unlocalized_ues = NULL;
168 /****/
169
170 /* Variabled used for handling enterprise spesific trap types */
171 typedef struct _snmp_st_assoc_t {
172         char *enterprise;
173         guint trap;
174         char *desc;
175 } snmp_st_assoc_t;
176 static guint num_specific_traps = 0;
177 static snmp_st_assoc_t *specific_traps = NULL;
178 static const char *enterprise_oid = NULL;
179 static guint generic_trap = 0;
180
181
182 static snmp_usm_params_t usm_p = {FALSE,FALSE,0,0,0,0,NULL,NULL,NULL,NULL,NULL,NULL,NULL,FALSE};
183
184 #define TH_AUTH   0x01
185 #define TH_CRYPT  0x02
186 #define TH_REPORT 0x04
187
188 /* desegmentation of SNMP-over-TCP */
189 static gboolean snmp_desegment = TRUE;
190
191 /* Global variables */
192
193 guint32 MsgSecurityModel;
194 tvbuff_t *oid_tvb=NULL;
195 tvbuff_t *value_tvb=NULL;
196
197 static dissector_handle_t snmp_handle;
198 static dissector_handle_t data_handle;
199
200 static next_tvb_list_t var_list;
201
202 static int hf_snmp_v3_flags_auth = -1;
203 static int hf_snmp_v3_flags_crypt = -1;
204 static int hf_snmp_v3_flags_report = -1;
205
206 static int hf_snmp_engineid_conform = -1;
207 static int hf_snmp_engineid_enterprise = -1;
208 static int hf_snmp_engineid_format = -1;
209 static int hf_snmp_engineid_ipv4 = -1;
210 static int hf_snmp_engineid_ipv6 = -1;
211 static int hf_snmp_engineid_cisco_type = -1;
212 static int hf_snmp_engineid_mac = -1;
213 static int hf_snmp_engineid_text = -1;
214 static int hf_snmp_engineid_time = -1;
215 static int hf_snmp_engineid_data = -1;
216 static int hf_snmp_decryptedPDU = -1;
217 static int hf_snmp_msgAuthentication = -1;
218
219 static int hf_snmp_noSuchObject = -1;
220 static int hf_snmp_noSuchInstance = -1;
221 static int hf_snmp_endOfMibView = -1;
222 static int hf_snmp_unSpecified = -1;
223
224 static int hf_snmp_integer32_value = -1;
225 static int hf_snmp_octetstring_value = -1;
226 static int hf_snmp_oid_value = -1;
227 static int hf_snmp_null_value = -1;
228 static int hf_snmp_ipv4_value = -1;
229 static int hf_snmp_ipv6_value = -1;
230 static int hf_snmp_anyaddress_value = -1;
231 static int hf_snmp_unsigned32_value = -1;
232 static int hf_snmp_unknown_value = -1;
233 static int hf_snmp_opaque_value = -1;
234 static int hf_snmp_nsap_value = -1;
235 static int hf_snmp_counter_value = -1;
236 static int hf_snmp_timeticks_value = -1;
237 static int hf_snmp_big_counter_value = -1;
238 static int hf_snmp_gauge32_value = -1;
239
240 static int hf_snmp_objectname = -1;
241 static int hf_snmp_scalar_instance_index = -1;
242
243
244
245 /*--- Included file: packet-snmp-hf.c ---*/
246 #line 1 "../../asn1/snmp/packet-snmp-hf.c"
247 static int hf_snmp_SMUX_PDUs_PDU = -1;            /* SMUX_PDUs */
248 static int hf_snmp_version = -1;                  /* Version */
249 static int hf_snmp_community = -1;                /* Community */
250 static int hf_snmp_data = -1;                     /* PDUs */
251 static int hf_snmp_parameters = -1;               /* OCTET_STRING */
252 static int hf_snmp_datav2u = -1;                  /* T_datav2u */
253 static int hf_snmp_v2u_plaintext = -1;            /* PDUs */
254 static int hf_snmp_encrypted = -1;                /* OCTET_STRING */
255 static int hf_snmp_msgAuthoritativeEngineID = -1;  /* T_msgAuthoritativeEngineID */
256 static int hf_snmp_msgAuthoritativeEngineBoots = -1;  /* T_msgAuthoritativeEngineBoots */
257 static int hf_snmp_msgAuthoritativeEngineTime = -1;  /* T_msgAuthoritativeEngineTime */
258 static int hf_snmp_msgUserName = -1;              /* T_msgUserName */
259 static int hf_snmp_msgAuthenticationParameters = -1;  /* T_msgAuthenticationParameters */
260 static int hf_snmp_msgPrivacyParameters = -1;     /* T_msgPrivacyParameters */
261 static int hf_snmp_msgVersion = -1;               /* Version */
262 static int hf_snmp_msgGlobalData = -1;            /* HeaderData */
263 static int hf_snmp_msgSecurityParameters = -1;    /* T_msgSecurityParameters */
264 static int hf_snmp_msgData = -1;                  /* ScopedPduData */
265 static int hf_snmp_msgID = -1;                    /* INTEGER_0_2147483647 */
266 static int hf_snmp_msgMaxSize = -1;               /* INTEGER_484_2147483647 */
267 static int hf_snmp_msgFlags = -1;                 /* T_msgFlags */
268 static int hf_snmp_msgSecurityModel = -1;         /* T_msgSecurityModel */
269 static int hf_snmp_plaintext = -1;                /* ScopedPDU */
270 static int hf_snmp_encryptedPDU = -1;             /* T_encryptedPDU */
271 static int hf_snmp_contextEngineID = -1;          /* SnmpEngineID */
272 static int hf_snmp_contextName = -1;              /* OCTET_STRING */
273 static int hf_snmp_get_request = -1;              /* GetRequest_PDU */
274 static int hf_snmp_get_next_request = -1;         /* GetNextRequest_PDU */
275 static int hf_snmp_get_response = -1;             /* GetResponse_PDU */
276 static int hf_snmp_set_request = -1;              /* SetRequest_PDU */
277 static int hf_snmp_trap = -1;                     /* Trap_PDU */
278 static int hf_snmp_getBulkRequest = -1;           /* GetBulkRequest_PDU */
279 static int hf_snmp_informRequest = -1;            /* InformRequest_PDU */
280 static int hf_snmp_snmpV2_trap = -1;              /* SNMPv2_Trap_PDU */
281 static int hf_snmp_report = -1;                   /* Report_PDU */
282 static int hf_snmp_request_id = -1;               /* INTEGER */
283 static int hf_snmp_error_status = -1;             /* T_error_status */
284 static int hf_snmp_error_index = -1;              /* INTEGER */
285 static int hf_snmp_variable_bindings = -1;        /* VarBindList */
286 static int hf_snmp_bulkPDU_request_id = -1;       /* Integer32 */
287 static int hf_snmp_non_repeaters = -1;            /* INTEGER_0_2147483647 */
288 static int hf_snmp_max_repetitions = -1;          /* INTEGER_0_2147483647 */
289 static int hf_snmp_enterprise = -1;               /* EnterpriseOID */
290 static int hf_snmp_agent_addr = -1;               /* NetworkAddress */
291 static int hf_snmp_generic_trap = -1;             /* GenericTrap */
292 static int hf_snmp_specific_trap = -1;            /* SpecificTrap */
293 static int hf_snmp_time_stamp = -1;               /* TimeTicks */
294 static int hf_snmp_name = -1;                     /* ObjectName */
295 static int hf_snmp_valueType = -1;                /* NULL */
296 static int hf_snmp_VarBindList_item = -1;         /* VarBind */
297 static int hf_snmp_open = -1;                     /* OpenPDU */
298 static int hf_snmp_close = -1;                    /* ClosePDU */
299 static int hf_snmp_registerRequest = -1;          /* RReqPDU */
300 static int hf_snmp_registerResponse = -1;         /* RegisterResponse */
301 static int hf_snmp_commitOrRollback = -1;         /* SOutPDU */
302 static int hf_snmp_rRspPDU = -1;                  /* RRspPDU */
303 static int hf_snmp_pDUs = -1;                     /* PDUs */
304 static int hf_snmp_smux_simple = -1;              /* SimpleOpen */
305 static int hf_snmp_smux_version = -1;             /* T_smux_version */
306 static int hf_snmp_identity = -1;                 /* OBJECT_IDENTIFIER */
307 static int hf_snmp_description = -1;              /* DisplayString */
308 static int hf_snmp_password = -1;                 /* OCTET_STRING */
309 static int hf_snmp_subtree = -1;                  /* ObjectName */
310 static int hf_snmp_priority = -1;                 /* INTEGER_M1_2147483647 */
311 static int hf_snmp_operation = -1;                /* T_operation */
312
313 /*--- End of included file: packet-snmp-hf.c ---*/
314 #line 237 "../../asn1/snmp/packet-snmp-template.c"
315
316 static int hf_smux_version = -1;
317 static int hf_smux_pdutype = -1;
318
319 /* Initialize the subtree pointers */
320 static gint ett_smux = -1;
321 static gint ett_snmp = -1;
322 static gint ett_engineid = -1;
323 static gint ett_msgFlags = -1;
324 static gint ett_encryptedPDU = -1;
325 static gint ett_decrypted = -1;
326 static gint ett_authParameters = -1;
327 static gint ett_internet = -1;
328 static gint ett_varbind = -1;
329 static gint ett_name = -1;
330 static gint ett_value = -1;
331 static gint ett_decoding_error = -1;
332
333
334 /*--- Included file: packet-snmp-ett.c ---*/
335 #line 1 "../../asn1/snmp/packet-snmp-ett.c"
336 static gint ett_snmp_Message = -1;
337 static gint ett_snmp_Messagev2u = -1;
338 static gint ett_snmp_T_datav2u = -1;
339 static gint ett_snmp_UsmSecurityParameters = -1;
340 static gint ett_snmp_SNMPv3Message = -1;
341 static gint ett_snmp_HeaderData = -1;
342 static gint ett_snmp_ScopedPduData = -1;
343 static gint ett_snmp_ScopedPDU = -1;
344 static gint ett_snmp_PDUs = -1;
345 static gint ett_snmp_PDU = -1;
346 static gint ett_snmp_BulkPDU = -1;
347 static gint ett_snmp_Trap_PDU_U = -1;
348 static gint ett_snmp_VarBind = -1;
349 static gint ett_snmp_VarBindList = -1;
350 static gint ett_snmp_SMUX_PDUs = -1;
351 static gint ett_snmp_RegisterResponse = -1;
352 static gint ett_snmp_OpenPDU = -1;
353 static gint ett_snmp_SimpleOpen_U = -1;
354 static gint ett_snmp_RReqPDU_U = -1;
355
356 /*--- End of included file: packet-snmp-ett.c ---*/
357 #line 256 "../../asn1/snmp/packet-snmp-template.c"
358
359 static const true_false_string auth_flags = {
360         "OK",
361         "Failed"
362 };
363
364 /* Security Models */
365
366 #define SNMP_SEC_ANY                    0
367 #define SNMP_SEC_V1                             1
368 #define SNMP_SEC_V2C                    2
369 #define SNMP_SEC_USM                    3
370
371 static const value_string sec_models[] = {
372         { SNMP_SEC_ANY,                 "Any" },
373         { SNMP_SEC_V1,                  "V1" },
374         { SNMP_SEC_V2C,                 "V2C" },
375         { SNMP_SEC_USM,                 "USM" },
376         { 0,                            NULL }
377 };
378
379 /* SMUX PDU types */
380 #define SMUX_MSG_OPEN           0
381 #define SMUX_MSG_CLOSE          1
382 #define SMUX_MSG_RREQ           2
383 #define SMUX_MSG_RRSP           3
384 #define SMUX_MSG_SOUT           4
385
386 static const value_string smux_types[] = {
387         { SMUX_MSG_OPEN,        "Open" },
388         { SMUX_MSG_CLOSE,       "Close" },
389         { SMUX_MSG_RREQ,        "Registration Request" },
390         { SMUX_MSG_RRSP,        "Registration Response" },
391         { SMUX_MSG_SOUT,        "Commit Or Rollback" },
392         { 0,                    NULL }
393 };
394
395
396 #define SNMP_IPA    0           /* IP Address */
397 #define SNMP_CNT    1           /* Counter (Counter32) */
398 #define SNMP_GGE    2           /* Gauge (Gauge32) */
399 #define SNMP_TIT    3           /* TimeTicks */
400 #define SNMP_OPQ    4           /* Opaque */
401 #define SNMP_NSP    5           /* NsapAddress */
402 #define SNMP_C64    6           /* Counter64 */
403 #define SNMP_U32    7           /* Uinteger32 */
404
405 #define SERR_NSO    0
406 #define SERR_NSI    1
407 #define SERR_EOM    2
408
409
410 dissector_table_t value_sub_dissectors_table;
411
412
413 static const gchar *
414 snmp_lookup_specific_trap (guint specific_trap)
415 {
416         guint i;
417
418         for (i = 0; i < num_specific_traps; i++) {
419                 snmp_st_assoc_t *u = &(specific_traps[i]);
420
421                 if ((u->trap == specific_trap) &&
422                     (strcmp (u->enterprise, enterprise_oid) == 0))
423                 {
424                         return u->desc;
425                 }
426         }
427
428         return NULL;
429 }
430
431 /*
432  *  dissect_snmp_VarBind
433  *  this routine dissects variable bindings, looking for the oid information in our oid reporsitory
434  *  to format and add the value adequatelly.
435  *
436  * The choice to handwrite this code instead of using the asn compiler is to avoid having tons
437  * of uses of global variables distributed in very different parts of the code.
438  * Other than that there's a cosmetic thing: the tree from ASN generated code would be so
439  * convoluted due to the nesting of CHOICEs in the definition of VarBind/value.
440  *
441  * XXX: the length of this function (~400 lines) is an aberration!
442  *  oid_key_t:key_type could become a series of callbacks instead of an enum
443  *  the (! oid_info_is_ok) switch could be made into an array (would be slower)
444  *
445
446         NetworkAddress ::=  CHOICE { internet IpAddress }
447         IpAddress ::= [APPLICATION 0] IMPLICIT OCTET STRING (SIZE (4))
448         TimeTicks ::= [APPLICATION 3] IMPLICIT INTEGER (0..4294967295)
449         Integer32 ::= INTEGER (-2147483648..2147483647)
450         ObjectName ::= OBJECT IDENTIFIER
451         Counter32 ::= [APPLICATION 1] IMPLICIT INTEGER (0..4294967295)
452         Gauge32 ::= [APPLICATION 2] IMPLICIT INTEGER (0..4294967295)
453         Unsigned32 ::= [APPLICATION 2] IMPLICIT INTEGER (0..4294967295)
454         Integer-value ::=  INTEGER (-2147483648..2147483647)
455         Integer32 ::= INTEGER (-2147483648..2147483647)
456         ObjectID-value ::= OBJECT IDENTIFIER
457         Empty ::= NULL
458         TimeTicks ::= [APPLICATION 3] IMPLICIT INTEGER (0..4294967295)
459         Opaque ::= [APPLICATION 4] IMPLICIT OCTET STRING
460         Counter64 ::= [APPLICATION 6] IMPLICIT INTEGER (0..18446744073709551615)
461
462         ObjectSyntax ::= CHOICE {
463                  simple SimpleSyntax,
464                  application-wide ApplicationSyntax
465         }
466
467         SimpleSyntax ::= CHOICE {
468            integer-value Integer-value,
469            string-value String-value,
470            objectID-value ObjectID-value,
471            empty  Empty
472         }
473
474         ApplicationSyntax ::= CHOICE {
475            ipAddress-value IpAddress,
476            counter-value Counter32,
477            timeticks-value TimeTicks,
478            arbitrary-value Opaque,
479            big-counter-value Counter64,
480            unsigned-integer-value Unsigned32
481         }
482
483         ValueType ::=  CHOICE {
484            value ObjectSyntax,
485            unSpecified NULL,
486            noSuchObject[0] IMPLICIT NULL,
487            noSuchInstance[1] IMPLICIT NULL,
488            endOfMibView[2] IMPLICIT NULL
489         }
490
491         VarBind ::= SEQUENCE {
492            name ObjectName,
493            valueType ValueType
494         }
495
496  */
497
498 extern int
499 dissect_snmp_VarBind(gboolean implicit_tag _U_, tvbuff_t *tvb, int offset,
500                      asn1_ctx_t *actx, proto_tree *tree, int hf_index _U_)
501 {
502         int seq_offset, name_offset, value_offset, value_start;
503         guint32 seq_len, name_len, value_len;
504         gint8 ber_class;
505         gboolean pc;
506         gint32 tag;
507         gboolean ind;
508         guint32* subids;
509         guint8* oid_bytes;
510         oid_info_t* oid_info = NULL;
511         guint oid_matched, oid_left;
512         proto_item *pi_name, *pi_varbind, *pi_value = NULL;
513         proto_tree *pt, *pt_varbind, *pt_name, *pt_value;
514         char label[ITEM_LABEL_LENGTH];
515         const char* repr = NULL;
516         const char* info_oid = NULL;
517         char* valstr;
518         int hfid = -1;
519         int min_len = 0, max_len = 0;
520         gboolean oid_info_is_ok;
521         const char* oid_string = NULL;
522         enum {BER_NO_ERROR, BER_WRONG_LENGTH, BER_WRONG_TAG} format_error = BER_NO_ERROR;
523
524         seq_offset = offset;
525
526         /* first have the VarBind's sequence header */
527         offset = get_ber_identifier(tvb, offset, &ber_class, &pc, &tag);
528         offset = get_ber_length(tvb, offset, &seq_len, &ind);
529
530         seq_len += offset - seq_offset;
531
532         if (!pc && ber_class==BER_CLASS_UNI && tag==BER_UNI_TAG_SEQUENCE) {
533                 proto_item* pi = proto_tree_add_text(tree, tvb, seq_offset, seq_len,"VarBind must be an universal class sequence");
534                 pt = proto_item_add_subtree(pi,ett_decoding_error);
535                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "VarBind is not an universal class sequence");
536                 return dissect_unknown_ber(actx->pinfo, tvb, seq_offset, pt);
537         }
538
539         if (ind) {
540                 proto_item* pi = proto_tree_add_text(tree, tvb, seq_offset, seq_len,"Indicator must be clear in VarBind");
541                 pt = proto_item_add_subtree(pi,ett_decoding_error);
542                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "VarBind has indicator set");
543                 return dissect_unknown_ber(actx->pinfo, tvb, seq_offset, pt);
544         }
545
546         /* then we have the ObjectName's header */
547
548         offset = get_ber_identifier(tvb, offset, &ber_class, &pc, &tag);
549         name_offset = offset = get_ber_length(tvb, offset, &name_len, &ind);
550
551         if (! ( !pc && ber_class==BER_CLASS_UNI && tag==BER_UNI_TAG_OID) ) {
552                 proto_item* pi = proto_tree_add_text(tree, tvb, seq_offset, seq_len,"ObjectName must be an OID in primitive encoding");
553                 pt = proto_item_add_subtree(pi,ett_decoding_error);
554                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "ObjectName not an OID");
555                 return dissect_unknown_ber(actx->pinfo, tvb, seq_offset, pt);
556         }
557
558         if (ind) {
559                 proto_item* pi = proto_tree_add_text(tree, tvb, seq_offset, seq_len,"Indicator must be clear in ObjectName");
560                 pt = proto_item_add_subtree(pi,ett_decoding_error);
561                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "ObjectName has indicator set");
562                 return dissect_unknown_ber(actx->pinfo, tvb, seq_offset, pt);
563         }
564
565         offset += name_len;
566         value_start = offset;
567
568         /* then we have the  value's header */
569         offset = get_ber_identifier(tvb, offset, &ber_class, &pc, &tag);
570         value_offset = get_ber_length(tvb, offset, &value_len, &ind);
571
572         if (! (!pc) ) {
573                 proto_item* pi = proto_tree_add_text(tree, tvb, seq_offset, seq_len,"the value must be in primitive encoding");
574                 pt = proto_item_add_subtree(pi,ett_decoding_error);
575                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "value not in primitive encoding");
576                 return dissect_unknown_ber(actx->pinfo, tvb, seq_offset, pt);
577         }
578
579         /* Now, we know where everithing is */
580
581
582
583         /* we add the varbind tree root with a dummy label we'll fill later on */
584         pi_varbind = proto_tree_add_text(tree,tvb,seq_offset,seq_len,"VarBind");
585         pt_varbind = proto_item_add_subtree(pi_varbind,ett_varbind);
586         *label = '\0';
587
588         pi_name = proto_tree_add_item(pt_varbind,hf_snmp_objectname,tvb,name_offset,name_len,ENC_NA);
589         pt_name = proto_item_add_subtree(pi_name,ett_name);
590
591         /* fetch ObjectName and its relative oid_info */
592         oid_bytes = (guint8*)ep_tvb_memdup(tvb, name_offset, name_len);
593         oid_info = oid_get_from_encoded(oid_bytes, name_len, &subids, &oid_matched, &oid_left);
594
595         add_oid_debug_subtree(oid_info,pt_name);
596
597         if (!subids) {
598                 proto_item* pi;
599
600                 repr = oid_encoded2string(oid_bytes, name_len);
601                 pi = proto_tree_add_text(pt_name,tvb, 0, 0, "invalid oid: %s", repr);
602                 pt = proto_item_add_subtree(pi, ett_decoding_error);
603                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "invalid oid: %s", repr);
604                 return dissect_unknown_ber(actx->pinfo, tvb, name_offset, pt);
605         }
606
607         if (oid_matched+oid_left) {
608                 oid_string = oid_subid2string(subids,oid_matched+oid_left);
609         }
610
611         if (ber_class == BER_CLASS_CON) {
612                 /* if we have an error value just add it and get out the way ASAP */
613                 proto_item* pi;
614                 const char* note;
615
616                 if (value_len != 0) {
617                         min_len = max_len = 0;
618                         format_error = BER_WRONG_LENGTH;
619                 }
620
621                 switch (tag) {
622                         case SERR_NSO:
623                                 hfid = hf_snmp_noSuchObject;
624                                 note = "noSuchObject";
625                                 break;
626                         case SERR_NSI:
627                                 hfid = hf_snmp_noSuchInstance;
628                                 note = "noSuchInstance";
629                                 break;
630                         case SERR_EOM:
631                                 hfid = hf_snmp_endOfMibView;
632                                 note = "endOfMibView";
633                                 break;
634                         default: {
635                                 pi = proto_tree_add_text(pt_varbind,tvb,0,0,"Wrong tag for Error Value: expected 0, 1, or 2 but got: %d",tag);
636                                 pt = proto_item_add_subtree(pi,ett_decoding_error);
637                                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "Wrong tag for SNMP VarBind error value");
638                                 return dissect_unknown_ber(actx->pinfo, tvb, value_start, pt);
639                         }
640                 }
641
642                 pi = proto_tree_add_item(pt_varbind,hfid,tvb,value_offset,value_len,ENC_BIG_ENDIAN);
643                 expert_add_info_format(actx->pinfo, pi, PI_RESPONSE_CODE, PI_NOTE, "%s",note);
644                 g_strlcpy (label, note, ITEM_LABEL_LENGTH);
645                 goto set_label;
646         }
647
648         /* now we'll try to figure out which are the indexing sub-oids and whether the oid we know about is the one oid we have to use */
649         switch (oid_info->kind) {
650                 case OID_KIND_SCALAR:
651                         if (oid_left  == 1) {
652                                 /* OK: we got the instance sub-id */
653                                 proto_tree_add_uint64(pt_name,hf_snmp_scalar_instance_index,tvb,name_offset,name_len,subids[oid_matched]);
654                                 oid_info_is_ok = TRUE;
655                                 goto indexing_done;
656                         } else if (oid_left  == 0) {
657                                 if (ber_class == BER_CLASS_UNI && tag == BER_UNI_TAG_NULL) {
658                                         /* unSpecified  does not require an instance sub-id add the new value and get off the way! */
659                                         pi_value = proto_tree_add_item(pt_varbind,hf_snmp_unSpecified,tvb,value_offset,value_len,ENC_NA);
660                                         goto set_label;
661                                 } else {
662                                         proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"A scalar should have one instance sub-id this one has none");
663                                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "No instance sub-id in scalar value");
664                                         oid_info_is_ok = FALSE;
665                                         goto indexing_done;
666                                 }
667                         } else {
668                                 proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"A scalar should have only one instance sub-id this has: %d",oid_left);
669                                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "Wrong number of instance sub-ids in scalar value");
670                                 oid_info_is_ok = FALSE;
671                                 goto indexing_done;
672                         }
673                 break;
674                 case OID_KIND_COLUMN:
675                         if ( oid_info->parent->kind == OID_KIND_ROW) {
676                                 oid_key_t* k = oid_info->parent->key;
677                                 guint key_start = oid_matched;
678                                 guint key_len = oid_left;
679                                 oid_info_is_ok = TRUE;
680
681                                 if ( key_len == 0 && ber_class == BER_CLASS_UNI && tag == BER_UNI_TAG_NULL) {
682                                         /* unSpecified  does not require an instance sub-id add the new value and get off the way! */
683                                         pi_value = proto_tree_add_item(pt_varbind,hf_snmp_unSpecified,tvb,value_offset,value_len,ENC_NA);
684                                         goto set_label;
685                                 }
686
687                                 if (k) {
688                                         for (;k;k = k->next) {
689                                                 guint suboid_len;
690
691                                                 if (key_start >= oid_matched+oid_left) {
692                                                         proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"index sub-oid shorter than expected");
693                                                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "index sub-oid shorter than expected");
694                                                         oid_info_is_ok = FALSE;
695                                                         goto indexing_done;
696                                                 }
697
698                                                 switch(k->key_type) {
699                                                         case OID_KEY_TYPE_WRONG: {
700                                                                 proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"OID instaces not handled, if you want this implemented please contact the wireshark developers");
701                                                                 expert_add_info_format(actx->pinfo, pi, PI_UNDECODED, PI_WARN, "Unimplemented instance index");
702                                                                 oid_info_is_ok = FALSE;
703                                                                 goto indexing_done;
704                                                         }
705                                                         case OID_KEY_TYPE_INTEGER: {
706                                                                 if (IS_FT_INT(k->ft_type)) {
707                                                                         proto_tree_add_int(pt_name,k->hfid,tvb,name_offset,name_len,(guint)subids[key_start]);
708                                                                 } else { /* if it's not an unsigned int let proto_tree_add_uint throw a warning */
709                                                                         proto_tree_add_uint64(pt_name,k->hfid,tvb,name_offset,name_len,(guint)subids[key_start]);
710                                                                 }
711                                                                 key_start++;
712                                                                 key_len--;
713                                                                 continue; /* k->next */
714                                                         }
715                                                         case OID_KEY_TYPE_IMPLIED_OID:
716                                                                 suboid_len = key_len;
717
718                                                                 goto show_oid_index;
719
720                                                         case OID_KEY_TYPE_OID: {
721                                                                 guint8* suboid_buf;
722                                                                 guint suboid_buf_len;
723                                                                 guint32* suboid;
724
725                                                                 suboid_len = subids[key_start++];
726                                                                 key_len--;
727
728 show_oid_index:
729                                                                 suboid = &(subids[key_start]);
730
731                                                                 if( suboid_len == 0 ) {
732                                                                         proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"an index sub-oid OID cannot be 0 bytes long!");
733                                                                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "index sub-oid OID with len=0");
734                                                                         oid_info_is_ok = FALSE;
735                                                                         goto indexing_done;
736                                                                 }
737
738                                                                 if( key_len < suboid_len ) {
739                                                                         proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"index sub-oid should not be longer than remaining oid size");
740                                                                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "index sub-oid longer than remaining oid size");
741                                                                         oid_info_is_ok = FALSE;
742                                                                         goto indexing_done;
743                                                                 }
744
745                                                                 suboid_buf_len = oid_subid2encoded(suboid_len, suboid, &suboid_buf);
746
747                                                                 DISSECTOR_ASSERT(suboid_buf_len);
748
749                                                                 proto_tree_add_oid(pt_name,k->hfid,tvb,name_offset, suboid_buf_len, suboid_buf);
750
751                                                                 key_start += suboid_len;
752                                                                 key_len -= suboid_len + 1;
753                                                                 continue; /* k->next */
754                                                         }
755                                                         default: {
756                                                                 guint8* buf;
757                                                                 guint buf_len;
758                                                                 guint32* suboid;
759                                                                 guint i;
760
761
762                                                                 switch (k->key_type) {
763                                                                         case OID_KEY_TYPE_IPADDR:
764                                                                                 suboid = &(subids[key_start]);
765                                                                                 buf_len = 4;
766                                                                                 break;
767                                                                         case OID_KEY_TYPE_IMPLIED_STRING:
768                                                                         case OID_KEY_TYPE_IMPLIED_BYTES:
769                                                                         case OID_KEY_TYPE_ETHER:
770                                                                                 suboid = &(subids[key_start]);
771                                                                                 buf_len = key_len;
772                                                                                 break;
773                                                                         default:
774                                                                                 buf_len = k->num_subids;
775                                                                                 suboid = &(subids[key_start]);
776
777                                                                                 if(!buf_len) {
778                                                                                         buf_len = *suboid++;
779                                                                                         key_len--;
780                                                                                         key_start++;
781                                                                                 }
782                                                                                 break;
783                                                                 }
784
785                                                                 if( key_len < buf_len ) {
786                                                                         proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"index string should not be longer than remaining oid size");
787                                                                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "index string longer than remaining oid size");
788                                                                         oid_info_is_ok = FALSE;
789                                                                         goto indexing_done;
790                                                                 }
791
792                                                                 buf = (guint8*)ep_alloc(buf_len+1);
793                                                                 for (i = 0; i < buf_len; i++)
794                                                                         buf[i] = (guint8)suboid[i];
795                                                                 buf[i] = '\0';
796
797                                                                 switch(k->key_type) {
798                                                                         case OID_KEY_TYPE_STRING:
799                                                                         case OID_KEY_TYPE_IMPLIED_STRING:
800                                                                                 proto_tree_add_string(pt_name,k->hfid,tvb,name_offset,buf_len, buf);
801                                                                                 break;
802                                                                         case OID_KEY_TYPE_BYTES:
803                                                                         case OID_KEY_TYPE_NSAP:
804                                                                         case OID_KEY_TYPE_IMPLIED_BYTES:
805                                                                                 proto_tree_add_bytes(pt_name,k->hfid,tvb,name_offset,buf_len, buf);
806                                                                                 break;
807                                                                         case OID_KEY_TYPE_ETHER:
808                                                                                 proto_tree_add_ether(pt_name,k->hfid,tvb,name_offset,buf_len, buf);
809                                                                                 break;
810                                                                         case OID_KEY_TYPE_IPADDR: {
811                                                                                 guint32* ipv4_p = (guint32*)buf;
812                                                                                 proto_tree_add_ipv4(pt_name,k->hfid,tvb,name_offset,buf_len, *ipv4_p);
813                                                                                 }
814                                                                                 break;
815                                                                         default:
816                                                                                 DISSECTOR_ASSERT_NOT_REACHED();
817                                                                                 break;
818                                                                 }
819
820                                                                 key_start += buf_len;
821                                                                 key_len -= buf_len;
822                                                                 continue; /* k->next*/
823                                                         }
824                                                 }
825                                         }
826                                         goto indexing_done;
827                                 } else {
828                                         proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"We do not know how to handle this OID, if you want this implemented please contact the wireshark developers");
829                                         expert_add_info_format(actx->pinfo, pi, PI_UNDECODED, PI_WARN, "Unimplemented instance index");
830                                         oid_info_is_ok = FALSE;
831                                         goto indexing_done;
832                                 }
833                         } else {
834                                 proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"The COLUMS's parent is not a ROW. This is a BUG! please contact the wireshark developers.");
835                                 expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_ERROR, "COLUMS's parent is not a ROW");
836                                 oid_info_is_ok = FALSE;
837                                 goto indexing_done;
838                         }
839                 default: {
840 /*                      proto_item* pi = proto_tree_add_text(pt_name,tvb,0,0,"This kind OID should have no value");
841                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "This kind OID should have no value"); */
842                         oid_info_is_ok = FALSE;
843                         goto indexing_done;
844                 }
845         }
846 indexing_done:
847
848         if (oid_info_is_ok && oid_info->value_type) {
849                 if (ber_class == BER_CLASS_UNI && tag == BER_UNI_TAG_NULL) {
850                         pi_value = proto_tree_add_item(pt_varbind,hf_snmp_unSpecified,tvb,value_offset,value_len,ENC_NA);
851                 } else {
852                         /* Provide a tree_item to attach errors to, if needed. */
853                         pi_value = pi_name;
854
855                         if ((oid_info->value_type->ber_class != BER_CLASS_ANY) &&
856                                 (ber_class != oid_info->value_type->ber_class))
857                                 format_error = BER_WRONG_TAG;
858                         else if ((oid_info->value_type->ber_tag != BER_TAG_ANY) &&
859                                 (tag != oid_info->value_type->ber_tag))
860                                 format_error = BER_WRONG_TAG;
861                         else {
862                                 max_len = oid_info->value_type->max_len == -1 ? 0xffffff : oid_info->value_type->max_len;
863                                 min_len  = oid_info->value_type->min_len;
864
865                                 if ((int)value_len < min_len || (int)value_len > max_len)
866                                         format_error = BER_WRONG_LENGTH;
867                         }
868
869                         if (format_error == BER_NO_ERROR)
870                                 pi_value = proto_tree_add_item(pt_varbind,oid_info->value_hfid,tvb,value_offset,value_len,ENC_BIG_ENDIAN);
871                 }
872         } else {
873                 switch(ber_class|(tag<<4)) {
874                         case BER_CLASS_UNI|(BER_UNI_TAG_INTEGER<<4):
875                         {
876                                 gint64 val=0;
877                                 unsigned int int_val_offset = value_offset;
878                                 unsigned int i;
879
880                                 max_len = 4; min_len = 1;
881                                 if (value_len > (guint)max_len || value_len < (guint)min_len) {
882                                         hfid = hf_snmp_integer32_value;
883                                         format_error = BER_WRONG_LENGTH;
884                                         break;
885                                 }
886
887                                 if(value_len > 0) {
888                                         /* extend sign bit */
889                                         if(tvb_get_guint8(tvb, int_val_offset)&0x80) {
890                                                 val=-1;
891                                         }
892                                         for(i=0;i<value_len;i++) {
893                                                 val=(val<<8)|tvb_get_guint8(tvb, int_val_offset);
894                                                 int_val_offset++;
895                                         }
896                                 }
897                                 proto_tree_add_int64(pt_varbind, hf_snmp_integer32_value, tvb,value_offset,value_len, val);
898
899                                 goto already_added;
900                         }
901                         case BER_CLASS_UNI|(BER_UNI_TAG_OCTETSTRING<<4):
902                                 hfid = hf_snmp_octetstring_value;
903                                 break;
904                         case BER_CLASS_UNI|(BER_UNI_TAG_OID<<4):
905                                 max_len = -1; min_len = 1;
906                                 if (value_len < (guint)min_len) format_error = BER_WRONG_LENGTH;
907                                 hfid = hf_snmp_oid_value;
908                                 break;
909                         case BER_CLASS_UNI|(BER_UNI_TAG_NULL<<4):
910                                 max_len = 0; min_len = 0;
911                                 if (value_len != 0) format_error = BER_WRONG_LENGTH;
912                                 hfid = hf_snmp_null_value;
913                                 break;
914                         case BER_CLASS_APP: /* | (SNMP_IPA<<4)*/
915                                 switch(value_len) {
916                                         case 4: hfid = hf_snmp_ipv4_value; break;
917                                         case 16: hfid = hf_snmp_ipv6_value; break;
918                                         default: hfid = hf_snmp_anyaddress_value; break;
919                                 }
920                                 break;
921                         case BER_CLASS_APP|(SNMP_U32<<4):
922                                 hfid = hf_snmp_unsigned32_value;
923                                 break;
924                         case BER_CLASS_APP|(SNMP_GGE<<4):
925                                 hfid = hf_snmp_gauge32_value;
926                                 break;
927                         case BER_CLASS_APP|(SNMP_CNT<<4):
928                                 hfid = hf_snmp_counter_value;
929                                 break;
930                         case BER_CLASS_APP|(SNMP_TIT<<4):
931                                 hfid = hf_snmp_timeticks_value;
932                                 break;
933                         case BER_CLASS_APP|(SNMP_OPQ<<4):
934                                 hfid = hf_snmp_opaque_value;
935                                 break;
936                         case BER_CLASS_APP|(SNMP_NSP<<4):
937                                 hfid = hf_snmp_nsap_value;
938                                 break;
939                         case BER_CLASS_APP|(SNMP_C64<<4):
940                                 hfid = hf_snmp_big_counter_value;
941                                 break;
942                         default:
943                                 hfid = hf_snmp_unknown_value;
944                                 break;
945                 }
946                 if (value_len > 8) {
947                         /*
948                          * Too long for an FT_UINT64 or an FT_INT64.
949                          */
950                         header_field_info *hfinfo = proto_registrar_get_nth(hfid);
951                         if (hfinfo->type == FT_UINT64) {
952                                 /*
953                                  * Check if this is an unsigned int64 with
954                                  * a big value.
955                                  */
956                                 if (value_len > 9 || tvb_get_guint8(tvb, value_offset) != 0) {
957                                         /* It is.  Fail. */
958                                         pi_value = proto_tree_add_text(pt_varbind,tvb,value_offset,value_len,"Integral value too large");
959                                         expert_add_info_format(actx->pinfo, pi_value, PI_UNDECODED, PI_NOTE, "Unsigned integer value > 2^64 - 1");
960                                         goto already_added;
961                                 }
962                                 /* Cheat and skip the leading 0 byte */
963                                 value_len--;
964                                 value_offset++;
965                         } else if (hfinfo->type == FT_INT64) {
966                                 /*
967                                  * For now, just reject these.
968                                  */
969                                 pi_value = proto_tree_add_text(pt_varbind,tvb,value_offset,value_len,"Integral value too large or too small");
970                                 expert_add_info_format(actx->pinfo, pi_value, PI_UNDECODED, PI_NOTE, "Signed integer value > 2^63 - 1 or <= -2^63");
971                                 goto already_added;
972                         }
973                 } else if (value_len == 0) {
974                         /*
975                          * X.690 section 8.3.1 "Encoding of an integer value":
976                          * "The encoding of an integer value shall be
977                          * primitive. The contents octets shall consist of
978                          * one or more octets."
979                          *
980                          * Zero is not "one or more".
981                          */
982                         header_field_info *hfinfo = proto_registrar_get_nth(hfid);
983                         if (hfinfo->type == FT_UINT64 || hfinfo->type == FT_INT64) {
984                                 pi_value = proto_tree_add_text(pt_varbind,tvb,value_offset,value_len,"Integral value is zero-length");
985                                 expert_add_info_format(actx->pinfo, pi_value, PI_UNDECODED, PI_NOTE, "Integral value is zero-length");
986                                 goto already_added;
987                         }
988                 }
989                 pi_value = proto_tree_add_item(pt_varbind,hfid,tvb,value_offset,value_len,ENC_BIG_ENDIAN);
990                 if (format_error != BER_NO_ERROR) {
991                         expert_add_info_format(actx->pinfo, pi_value, PI_UNDECODED, PI_NOTE, "Unresolved value, Missing MIB");
992                 }
993
994 already_added:
995                 oid_info_is_ok = FALSE;
996         }
997
998         pt_value = proto_item_add_subtree(pi_value,ett_value);
999
1000         if (value_len > 0 && oid_string) {
1001                 tvbuff_t* sub_tvb = tvb_new_subset(tvb, value_offset, value_len, value_len);
1002
1003                 next_tvb_add_string(&var_list, sub_tvb, (snmp_var_in_tree) ? pt_value : NULL, value_sub_dissectors_table, oid_string);
1004         }
1005
1006
1007 set_label:
1008         if (pi_value) proto_item_fill_label(PITEM_FINFO(pi_value), label);
1009
1010         if (oid_info && oid_info->name) {
1011                 if (oid_left >= 1) {
1012                         repr  = ep_strdup_printf("%s.%s (%s)", oid_info->name,
1013                                                  oid_subid2string(&(subids[oid_matched]),oid_left),
1014                                                  oid_subid2string(subids,oid_matched+oid_left));
1015                         info_oid = ep_strdup_printf("%s.%s", oid_info->name,
1016                                                     oid_subid2string(&(subids[oid_matched]),oid_left));
1017                 } else {
1018                         repr  = ep_strdup_printf("%s (%s)", oid_info->name,
1019                                                  oid_subid2string(subids,oid_matched));
1020                         info_oid = oid_info->name;
1021                 }
1022         } else if (oid_string) {
1023                 repr  = ep_strdup(oid_string);
1024                 info_oid = oid_string;
1025         } else {
1026                 repr  = ep_strdup("[Bad OID]");
1027         }
1028
1029         valstr = strstr(label,": ");
1030         valstr = valstr ? valstr+2 : label;
1031
1032         proto_item_set_text(pi_varbind,"%s: %s",repr,valstr);
1033
1034         if (display_oid && info_oid) {
1035           col_append_fstr (actx->pinfo->cinfo, COL_INFO, " %s", info_oid);
1036         }
1037
1038         switch (format_error) {
1039                 case BER_WRONG_LENGTH: {
1040                         proto_tree* p_tree = proto_item_add_subtree(pi_value,ett_decoding_error);
1041                         proto_item* pi = proto_tree_add_text(p_tree,tvb,0,0,"Wrong value length: %u  expecting: %u <= len <= %u",
1042                                                              value_len, min_len, max_len == -1 ? 0xFFFFFF : max_len);
1043                         pt = proto_item_add_subtree(pi,ett_decoding_error);
1044                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "Wrong length for SNMP VarBind/value");
1045                         return dissect_unknown_ber(actx->pinfo, tvb, value_start, pt);
1046                 }
1047                 case BER_WRONG_TAG: {
1048                         proto_tree* p_tree = proto_item_add_subtree(pi_value,ett_decoding_error);
1049                         proto_item* pi = proto_tree_add_text(p_tree,tvb,0,0,"Wrong class/tag for Value expected: %d,%d got: %d,%d",
1050                                                              oid_info->value_type->ber_class, oid_info->value_type->ber_tag,
1051                                                              ber_class, tag);
1052                         pt = proto_item_add_subtree(pi,ett_decoding_error);
1053                         expert_add_info_format(actx->pinfo, pi, PI_MALFORMED, PI_WARN, "Wrong class/tag for SNMP VarBind/value");
1054                         return dissect_unknown_ber(actx->pinfo, tvb, value_start, pt);
1055                 }
1056                 default:
1057                         break;
1058         }
1059
1060         return seq_offset + seq_len;
1061 }
1062
1063
1064 #define F_SNMP_ENGINEID_CONFORM 0x80
1065 #define SNMP_ENGINEID_RFC1910 0x00
1066 #define SNMP_ENGINEID_RFC3411 0x01
1067
1068 static const true_false_string tfs_snmp_engineid_conform = {
1069   "RFC3411 (SNMPv3)",
1070   "RFC1910 (Non-SNMPv3)"
1071 };
1072
1073 #define SNMP_ENGINEID_FORMAT_IPV4 0x01
1074 #define SNMP_ENGINEID_FORMAT_IPV6 0x02
1075 #define SNMP_ENGINEID_FORMAT_MACADDRESS 0x03
1076 #define SNMP_ENGINEID_FORMAT_TEXT 0x04
1077 #define SNMP_ENGINEID_FORMAT_OCTETS 0x05
1078
1079 static const value_string snmp_engineid_format_vals[] = {
1080         { SNMP_ENGINEID_FORMAT_IPV4,    "IPv4 address" },
1081         { SNMP_ENGINEID_FORMAT_IPV6,    "IPv6 address" },
1082         { SNMP_ENGINEID_FORMAT_MACADDRESS,      "MAC address" },
1083         { SNMP_ENGINEID_FORMAT_TEXT,    "Text, administratively assigned" },
1084         { SNMP_ENGINEID_FORMAT_OCTETS,  "Octets, administratively assigned" },
1085         { 0,    NULL }
1086 };
1087
1088 #define SNMP_ENGINEID_CISCO_AGENT 0x00
1089 #define SNMP_ENGINEID_CISCO_MANAGER 0x01
1090
1091 static const value_string snmp_engineid_cisco_type_vals[] = {
1092         { SNMP_ENGINEID_CISCO_AGENT,    "Agent" },
1093         { SNMP_ENGINEID_CISCO_MANAGER,  "Manager" },
1094         { 0,    NULL }
1095 };
1096
1097 /*
1098  * SNMP Engine ID dissection according to RFC 3411 (SnmpEngineID TC)
1099  * or historic RFC 1910 (AgentID)
1100  */
1101 int
1102 dissect_snmp_engineid(proto_tree *tree, tvbuff_t *tvb, int offset, int len)
1103 {
1104     proto_item *item = NULL;
1105     guint8 conformance, format;
1106     guint32 enterpriseid, seconds;
1107     nstime_t ts;
1108     int len_remain = len;
1109
1110     /* first bit: engine id conformance */
1111     if (len_remain<1) return offset;
1112     conformance = ((tvb_get_guint8(tvb, offset)>>7) & 0x01);
1113     proto_tree_add_item(tree, hf_snmp_engineid_conform, tvb, offset, 1, ENC_BIG_ENDIAN);
1114
1115     /* 4-byte enterprise number/name */
1116     if (len_remain<4) return offset;
1117     enterpriseid = tvb_get_ntohl(tvb, offset);
1118     if (conformance)
1119       enterpriseid -= 0x80000000; /* ignore first bit */
1120     proto_tree_add_uint(tree, hf_snmp_engineid_enterprise, tvb, offset, 4, enterpriseid);
1121     offset+=4;
1122     len_remain-=4;
1123
1124     switch(conformance) {
1125
1126     case SNMP_ENGINEID_RFC1910:
1127       /* 12-byte AgentID w/ 8-byte trailer */
1128       if (len_remain==8) {
1129         proto_tree_add_text(tree, tvb, offset, 8, "AgentID Trailer: 0x%s",
1130                             tvb_bytes_to_str(tvb, offset, 8));
1131         offset+=8;
1132         len_remain-=8;
1133       } else {
1134         proto_tree_add_text(tree, tvb, offset, len_remain, "<Data not conforming to RFC1910>");
1135         return offset;
1136       }
1137       break;
1138
1139     case SNMP_ENGINEID_RFC3411: /* variable length: 5..32 */
1140
1141       /* 1-byte format specifier */
1142       if (len_remain<1) return offset;
1143       format = tvb_get_guint8(tvb, offset);
1144       item = proto_tree_add_uint_format(tree, hf_snmp_engineid_format, tvb, offset, 1, format, "Engine ID Format: %s (%d)",
1145                                         val_to_str(format, snmp_engineid_format_vals, "Reserved/Enterprise-specific"), format);
1146       offset+=1;
1147       len_remain-=1;
1148
1149       switch(format) {
1150       case SNMP_ENGINEID_FORMAT_IPV4:
1151         /* 4-byte IPv4 address */
1152         if (len_remain==4) {
1153           proto_tree_add_item(tree, hf_snmp_engineid_ipv4, tvb, offset, 4, ENC_BIG_ENDIAN);
1154           offset+=4;
1155           len_remain=0;
1156         }
1157         break;
1158       case SNMP_ENGINEID_FORMAT_IPV6:
1159         /* 16-byte IPv6 address */
1160         if (len_remain==16) {
1161           proto_tree_add_item(tree, hf_snmp_engineid_ipv6, tvb, offset, 16, ENC_NA);
1162           offset+=16;
1163           len_remain=0;
1164         }
1165         break;
1166       case SNMP_ENGINEID_FORMAT_MACADDRESS:
1167         /* See: https://supportforums.cisco.com/message/3010617#3010617 for details. */
1168         if ((enterpriseid==9)&&(len_remain==7)) {
1169           proto_tree_add_item(tree, hf_snmp_engineid_cisco_type, tvb, offset, 1, ENC_BIG_ENDIAN);
1170           offset++;
1171           len_remain--;
1172         }
1173         /* 6-byte MAC address */
1174         if (len_remain==6) {
1175           proto_tree_add_item(tree, hf_snmp_engineid_mac, tvb, offset, 6, ENC_NA);
1176           offset+=6;
1177           len_remain=0;
1178         }
1179         break;
1180       case SNMP_ENGINEID_FORMAT_TEXT:
1181         /* max. 27-byte string, administratively assigned */
1182         if (len_remain<=27) {
1183           proto_tree_add_item(tree, hf_snmp_engineid_text, tvb, offset, len_remain, ENC_ASCII|ENC_NA);
1184           offset+=len_remain;
1185           len_remain=0;
1186         }
1187         break;
1188       case 128:
1189         /* most common enterprise-specific format: (ucd|net)-snmp random */
1190         if ((enterpriseid==2021)||(enterpriseid==8072)) {
1191           proto_item_append_text(item, (enterpriseid==2021) ? ": UCD-SNMP Random" : ": Net-SNMP Random");
1192           /* demystify: 4B random, 4B epoch seconds */
1193           if (len_remain==8) {
1194             proto_tree_add_item(tree, hf_snmp_engineid_data, tvb, offset, 4, ENC_NA);
1195             seconds = tvb_get_letohl(tvb, offset+4);
1196             ts.secs = seconds;
1197             ts.nsecs = 0;
1198             proto_tree_add_time_format_value(tree, hf_snmp_engineid_time, tvb, offset+4, 4,
1199                                              &ts, "%s",
1200                                              abs_time_secs_to_str(seconds, ABSOLUTE_TIME_LOCAL, TRUE));
1201             offset+=8;
1202             len_remain=0;
1203           }
1204           break;
1205         }
1206         /* fall through */
1207       case SNMP_ENGINEID_FORMAT_OCTETS:
1208       default:
1209         /* max. 27 bytes, administratively assigned or unknown format */
1210         if (len_remain<=27) {
1211           proto_tree_add_item(tree, hf_snmp_engineid_data, tvb, offset, len_remain, ENC_NA);
1212           offset+=len_remain;
1213           len_remain=0;
1214         }
1215         break;
1216       }
1217     }
1218
1219     if (len_remain>0) {
1220       proto_tree_add_text(tree, tvb, offset, len_remain, "<Data not conforming to RFC3411>");
1221       offset+=len_remain;
1222     }
1223     return offset;
1224 }
1225
1226
1227 static void set_ue_keys(snmp_ue_assoc_t* n ) {
1228         guint key_size = n->user.authModel->key_size;
1229
1230         n->user.authKey.data = (guint8 *)se_alloc(key_size);
1231         n->user.authKey.len = key_size;
1232         n->user.authModel->pass2key(n->user.authPassword.data,
1233                                     n->user.authPassword.len,
1234                                     n->engine.data,
1235                                     n->engine.len,
1236                                     n->user.authKey.data);
1237
1238         if (n->priv_proto == PRIV_AES128 || n->priv_proto == PRIV_AES192 || n->priv_proto == PRIV_AES256) {
1239                 guint need_key_len = 
1240                         (n->priv_proto == PRIV_AES128) ? 16 :
1241                         (n->priv_proto == PRIV_AES192) ? 24 :
1242                         (n->priv_proto == PRIV_AES256) ? 32 :
1243                         0;
1244
1245                 guint key_len = key_size;
1246
1247                 while (key_len < need_key_len)
1248                         key_len += key_size;
1249
1250                 n->user.privKey.data = (guint8 *)se_alloc(key_len);
1251                 n->user.privKey.len  = need_key_len;
1252
1253                 n->user.authModel->pass2key(n->user.privPassword.data,
1254                                             n->user.privPassword.len,
1255                                             n->engine.data,
1256                                             n->engine.len,
1257                                             n->user.privKey.data);
1258
1259                 key_len = key_size;
1260
1261                 /* extend key if needed */
1262                 while (key_len < need_key_len) {
1263                         n->user.authModel->pass2key(
1264                                 n->user.privKey.data,
1265                                 key_len,
1266                                 n->engine.data,
1267                                 n->engine.len,
1268                                 n->user.privKey.data + key_len);
1269
1270                         key_len += key_size;
1271                 }
1272
1273         } else {
1274                 n->user.privKey.data = (guint8 *)se_alloc(key_size);
1275                 n->user.privKey.len = key_size;
1276                 n->user.authModel->pass2key(n->user.privPassword.data,
1277                                             n->user.privPassword.len,
1278                                             n->engine.data,
1279                                             n->engine.len,
1280                                             n->user.privKey.data);
1281         }
1282 }
1283
1284 static snmp_ue_assoc_t*
1285 ue_se_dup(snmp_ue_assoc_t* o)
1286 {
1287         snmp_ue_assoc_t* d = (snmp_ue_assoc_t*)se_memdup(o,sizeof(snmp_ue_assoc_t));
1288
1289         d->user.authModel = o->user.authModel;
1290
1291         d->user.privProtocol = o->user.privProtocol;
1292
1293         d->user.userName.data = (guint8 *)se_memdup(o->user.userName.data,o->user.userName.len);
1294         d->user.userName.len = o->user.userName.len;
1295
1296         d->user.authPassword.data = o->user.authPassword.data ? (guint8 *)se_memdup(o->user.authPassword.data,o->user.authPassword.len) : NULL;
1297         d->user.authPassword.len = o->user.authPassword.len;
1298
1299         d->user.privPassword.data = o->user.privPassword.data ? (guint8 *)se_memdup(o->user.privPassword.data,o->user.privPassword.len) : NULL;
1300         d->user.privPassword.len = o->user.privPassword.len;
1301
1302         d->engine.len = o->engine.len;
1303
1304         if (d->engine.len) {
1305                 d->engine.data = (guint8 *)se_memdup(o->engine.data,o->engine.len);
1306                 set_ue_keys(d);
1307         }
1308
1309         return d;
1310
1311 }
1312
1313
1314 #define CACHE_INSERT(c,a) if (c) { snmp_ue_assoc_t* t = c; c = a; c->next = t; } else { c = a; a->next = NULL; }
1315
1316 static void
1317 renew_ue_cache(void)
1318 {
1319         localized_ues = NULL;
1320         unlocalized_ues = NULL;
1321
1322         if (num_ueas) {
1323                 guint i;
1324
1325                 for(i = 0; i < num_ueas; i++) {
1326                         snmp_ue_assoc_t* a = ue_se_dup(&(ueas[i]));
1327
1328                         if (a->engine.len) {
1329                                 CACHE_INSERT(localized_ues,a);
1330
1331                         } else {
1332                                 CACHE_INSERT(unlocalized_ues,a);
1333                         }
1334
1335                 }
1336         }
1337 }
1338
1339
1340 static snmp_ue_assoc_t*
1341 localize_ue( snmp_ue_assoc_t* o, const guint8* engine, guint engine_len )
1342 {
1343         snmp_ue_assoc_t* n = (snmp_ue_assoc_t*)se_memdup(o,sizeof(snmp_ue_assoc_t));
1344
1345         n->engine.data = (guint8*)se_memdup(engine,engine_len);
1346         n->engine.len = engine_len;
1347
1348         set_ue_keys(n);
1349
1350         return n;
1351 }
1352
1353
1354 #define localized_match(a,u,ul,e,el) \
1355         ( a->user.userName.len == ul \
1356         && a->engine.len == el \
1357         && memcmp( a->user.userName.data, u, ul ) == 0 \
1358         && memcmp( a->engine.data,   e,  el ) == 0 )
1359
1360 #define unlocalized_match(a,u,l) \
1361         ( a->user.userName.len == l && memcmp( a->user.userName.data, u, l) == 0 )
1362
1363 static snmp_ue_assoc_t*
1364 get_user_assoc(tvbuff_t* engine_tvb, tvbuff_t* user_tvb)
1365 {
1366         static snmp_ue_assoc_t* a;
1367         guint given_username_len;
1368         guint8* given_username;
1369         guint given_engine_len;
1370         guint8* given_engine;
1371
1372         if ( ! (localized_ues || unlocalized_ues ) ) return NULL;
1373
1374         if (! ( user_tvb && engine_tvb ) ) return NULL;
1375
1376         given_username_len = tvb_length(user_tvb);
1377         given_engine_len = tvb_length(engine_tvb);
1378         if (! ( given_engine_len && given_username_len ) ) return NULL;
1379         given_username = (guint8*)ep_tvb_memdup(user_tvb,0,-1);
1380         given_engine = (guint8*)ep_tvb_memdup(engine_tvb,0,-1);
1381
1382         for (a = localized_ues; a; a = a->next) {
1383                 if ( localized_match(a, given_username, given_username_len, given_engine, given_engine_len) ) {
1384                         return a;
1385                 }
1386         }
1387
1388         for (a = unlocalized_ues; a; a = a->next) {
1389                 if ( unlocalized_match(a, given_username, given_username_len) ) {
1390                         snmp_ue_assoc_t* n = localize_ue( a, given_engine, given_engine_len );
1391                         CACHE_INSERT(localized_ues,n);
1392                         return n;
1393                 }
1394         }
1395
1396         return NULL;
1397 }
1398
1399 static gboolean
1400 snmp_usm_auth_md5(snmp_usm_params_t* p, guint8** calc_auth_p, guint* calc_auth_len_p, gchar const** error)
1401 {
1402         gint msg_len;
1403         guint8* msg;
1404         guint auth_len;
1405         guint8* auth;
1406         guint8* key;
1407         guint key_len;
1408         guint8 *calc_auth;
1409         guint start;
1410         guint end;
1411         guint i;
1412
1413         if (!p->auth_tvb) {
1414                 *error = "No Authenticator";
1415                 return FALSE;
1416         }
1417
1418         key = p->user_assoc->user.authKey.data;
1419         key_len = p->user_assoc->user.authKey.len;
1420
1421         if (! key ) {
1422                 *error = "User has no authKey";
1423                 return FALSE;
1424         }
1425
1426
1427         auth_len = tvb_length_remaining(p->auth_tvb,0);
1428
1429         if (auth_len != 12) {
1430                 *error = "Authenticator length wrong";
1431                 return FALSE;
1432         }
1433
1434         msg_len = tvb_length_remaining(p->msg_tvb,0);
1435         if (msg_len <= 0) {
1436                 *error = "Not enough data remaining";
1437                 return FALSE;
1438         }
1439         msg = (guint8*)ep_tvb_memdup(p->msg_tvb,0,msg_len);
1440
1441
1442         auth = (guint8*)ep_tvb_memdup(p->auth_tvb,0,auth_len);
1443
1444         start = p->auth_offset - p->start_offset;
1445         end =   start + auth_len;
1446
1447         /* fill the authenticator with zeros */
1448         for ( i = start ; i < end ; i++ ) {
1449                 msg[i] = '\0';
1450         }
1451
1452         calc_auth = (guint8*)ep_alloc(16);
1453
1454         md5_hmac(msg, msg_len, key, key_len, calc_auth);
1455
1456         if (calc_auth_p) *calc_auth_p = calc_auth;
1457         if (calc_auth_len_p) *calc_auth_len_p = 12;
1458
1459         return ( memcmp(auth,calc_auth,12) != 0 ) ? FALSE : TRUE;
1460 }
1461
1462
1463 static gboolean
1464 snmp_usm_auth_sha1(snmp_usm_params_t* p _U_, guint8** calc_auth_p, guint* calc_auth_len_p,  gchar const** error _U_)
1465 {
1466         gint msg_len;
1467         guint8* msg;
1468         guint auth_len;
1469         guint8* auth;
1470         guint8* key;
1471         guint key_len;
1472         guint8 *calc_auth;
1473         guint start;
1474         guint end;
1475         guint i;
1476
1477         if (!p->auth_tvb) {
1478                 *error = "No Authenticator";
1479                 return FALSE;
1480         }
1481
1482         key = p->user_assoc->user.authKey.data;
1483         key_len = p->user_assoc->user.authKey.len;
1484
1485         if (! key ) {
1486                 *error = "User has no authKey";
1487                 return FALSE;
1488         }
1489
1490
1491         auth_len = tvb_length_remaining(p->auth_tvb,0);
1492
1493
1494         if (auth_len != 12) {
1495                 *error = "Authenticator length wrong";
1496                 return FALSE;
1497         }
1498
1499         msg_len = tvb_length_remaining(p->msg_tvb,0);
1500         if (msg_len <= 0) {
1501                 *error = "Not enough data remaining";
1502                 return FALSE;
1503         }
1504         msg = (guint8*)ep_tvb_memdup(p->msg_tvb,0,msg_len);
1505
1506         auth = (guint8*)ep_tvb_memdup(p->auth_tvb,0,auth_len);
1507
1508         start = p->auth_offset - p->start_offset;
1509         end =   start + auth_len;
1510
1511         /* fill the authenticator with zeros */
1512         for ( i = start ; i < end ; i++ ) {
1513                 msg[i] = '\0';
1514         }
1515
1516         calc_auth = (guint8*)ep_alloc(20);
1517
1518         sha1_hmac(key, key_len, msg, msg_len, calc_auth);
1519
1520         if (calc_auth_p) *calc_auth_p = calc_auth;
1521         if (calc_auth_len_p) *calc_auth_len_p = 12;
1522
1523         return ( memcmp(auth,calc_auth,12) != 0 ) ? FALSE : TRUE;
1524 }
1525
1526 static tvbuff_t*
1527 snmp_usm_priv_des(snmp_usm_params_t* p _U_, tvbuff_t* encryptedData _U_, gchar const** error _U_)
1528 {
1529 #ifdef HAVE_LIBGCRYPT
1530     gcry_error_t err;
1531     gcry_cipher_hd_t hd = NULL;
1532
1533         guint8* cleartext;
1534         guint8* des_key = p->user_assoc->user.privKey.data; /* first 8 bytes */
1535         guint8* pre_iv = &(p->user_assoc->user.privKey.data[8]); /* last 8 bytes */
1536         guint8* salt;
1537         gint salt_len;
1538         gint cryptgrm_len;
1539         guint8* cryptgrm;
1540         tvbuff_t* clear_tvb;
1541         guint8 iv[8];
1542         guint i;
1543
1544
1545         salt_len = tvb_length_remaining(p->priv_tvb,0);
1546
1547         if (salt_len != 8)  {
1548                 *error = "decryptionError: msgPrivacyParameters length != 8";
1549                 return NULL;
1550         }
1551
1552         salt = (guint8*)ep_tvb_memdup(p->priv_tvb,0,salt_len);
1553
1554         /*
1555          The resulting "salt" is XOR-ed with the pre-IV to obtain the IV.
1556          */
1557         for (i=0; i<8; i++) {
1558                 iv[i] = pre_iv[i] ^ salt[i];
1559         }
1560
1561         cryptgrm_len = tvb_length_remaining(encryptedData,0);
1562
1563         if ((cryptgrm_len <= 0) || (cryptgrm_len % 8)) {
1564                 *error = "decryptionError: the length of the encrypted data is not a mutiple of 8 octets";
1565                 return NULL;
1566         }
1567
1568         cryptgrm = (guint8*)ep_tvb_memdup(encryptedData,0,-1);
1569
1570         cleartext = (guint8*)ep_alloc(cryptgrm_len);
1571
1572         err = gcry_cipher_open(&hd, GCRY_CIPHER_DES, GCRY_CIPHER_MODE_CBC, 0);
1573         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1574
1575         err = gcry_cipher_setiv(hd, iv, 8);
1576         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1577
1578         err = gcry_cipher_setkey(hd,des_key,8);
1579         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1580
1581         err = gcry_cipher_decrypt(hd, cleartext, cryptgrm_len, cryptgrm, cryptgrm_len);
1582         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1583
1584         gcry_cipher_close(hd);
1585
1586         clear_tvb = tvb_new_child_real_data(encryptedData, cleartext, cryptgrm_len, cryptgrm_len);
1587
1588         return clear_tvb;
1589
1590 on_gcry_error:
1591         *error = (const gchar *)gpg_strerror(err);
1592         if (hd) gcry_cipher_close(hd);
1593         return NULL;
1594 #else
1595         *error = "libgcrypt not present, cannot decrypt";
1596         return NULL;
1597 #endif
1598 }
1599
1600 #ifdef HAVE_LIBGCRYPT
1601 static tvbuff_t*
1602 snmp_usm_priv_aes_common(snmp_usm_params_t* p, tvbuff_t* encryptedData, gchar const** error, int algo)
1603 {
1604         gcry_error_t err;
1605         gcry_cipher_hd_t hd = NULL;
1606
1607         guint8* cleartext;
1608         guint8* aes_key = p->user_assoc->user.privKey.data;
1609         int aes_key_len = p->user_assoc->user.privKey.len;
1610         guint8 iv[16];
1611         gint priv_len;
1612         gint cryptgrm_len;
1613         guint8* cryptgrm;
1614         tvbuff_t* clear_tvb;
1615
1616         priv_len = tvb_length_remaining(p->priv_tvb,0);
1617
1618         if (priv_len != 8)  {
1619                 *error = "decryptionError: msgPrivacyParameters length != 8";
1620                 return NULL;
1621         }
1622
1623         iv[0] = (p->boots & 0xff000000) >> 24;
1624         iv[1] = (p->boots & 0x00ff0000) >> 16;
1625         iv[2] = (p->boots & 0x0000ff00) >> 8;
1626         iv[3] = (p->boots & 0x000000ff);
1627         iv[4] = (p->time & 0xff000000) >> 24;
1628         iv[5] = (p->time & 0x00ff0000) >> 16;
1629         iv[6] = (p->time & 0x0000ff00) >> 8;
1630         iv[7] = (p->time & 0x000000ff);
1631         tvb_memcpy(p->priv_tvb,&(iv[8]),0,8);
1632
1633         cryptgrm_len = tvb_length_remaining(encryptedData,0);
1634         if (cryptgrm_len <= 0) {
1635                 *error = "Not enough data remaining";
1636                 return NULL;
1637         }
1638         cryptgrm = (guint8*)ep_tvb_memdup(encryptedData,0,-1);
1639
1640         cleartext = (guint8*)ep_alloc(cryptgrm_len);
1641
1642         err = gcry_cipher_open(&hd, algo, GCRY_CIPHER_MODE_CFB, 0);
1643         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1644
1645         err = gcry_cipher_setiv(hd, iv, 16);
1646         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1647
1648         err = gcry_cipher_setkey(hd,aes_key,aes_key_len);
1649         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1650
1651         err = gcry_cipher_decrypt(hd, cleartext, cryptgrm_len, cryptgrm, cryptgrm_len);
1652         if (err != GPG_ERR_NO_ERROR) goto on_gcry_error;
1653
1654         gcry_cipher_close(hd);
1655
1656         clear_tvb = tvb_new_child_real_data(encryptedData, cleartext, cryptgrm_len, cryptgrm_len);
1657
1658         return clear_tvb;
1659
1660 on_gcry_error:
1661         *error = (const gchar *)gpg_strerror(err);
1662         if (hd) gcry_cipher_close(hd);
1663         return NULL;
1664 }
1665 #endif
1666
1667 static tvbuff_t*
1668 snmp_usm_priv_aes128(snmp_usm_params_t* p _U_, tvbuff_t* encryptedData _U_, gchar const** error)
1669 {
1670 #ifdef HAVE_LIBGCRYPT
1671         return snmp_usm_priv_aes_common(p, encryptedData, error, GCRY_CIPHER_AES);
1672 #else
1673         *error = "libgcrypt not present, cannot decrypt";
1674         return NULL;
1675 #endif
1676 }
1677
1678 static tvbuff_t*
1679 snmp_usm_priv_aes192(snmp_usm_params_t* p _U_, tvbuff_t* encryptedData _U_, gchar const** error)
1680 {
1681 #ifdef HAVE_LIBGCRYPT
1682         return snmp_usm_priv_aes_common(p, encryptedData, error, GCRY_CIPHER_AES192);
1683 #else
1684         *error = "libgcrypt not present, cannot decrypt";
1685         return NULL;
1686 #endif
1687 }
1688
1689 static tvbuff_t*
1690 snmp_usm_priv_aes256(snmp_usm_params_t* p _U_, tvbuff_t* encryptedData _U_, gchar const** error)
1691 {
1692 #ifdef HAVE_LIBGCRYPT
1693         return snmp_usm_priv_aes_common(p, encryptedData, error, GCRY_CIPHER_AES256);
1694 #else
1695         *error = "libgcrypt not present, cannot decrypt";
1696         return NULL;
1697 #endif
1698 }
1699
1700 static gboolean
1701 check_ScopedPdu(tvbuff_t* tvb)
1702 {
1703         int offset;
1704         gint8 ber_class;
1705         gboolean pc;
1706         gint32 tag;
1707         int hoffset, eoffset;
1708         guint32 len;
1709
1710         offset = get_ber_identifier(tvb, 0, &ber_class, &pc, &tag);
1711         offset = get_ber_length(tvb, offset, NULL, NULL);
1712
1713         if ( ! (((ber_class!=BER_CLASS_APP) && (ber_class!=BER_CLASS_PRI) )
1714                         && ( (!pc) || (ber_class!=BER_CLASS_UNI) || (tag!=BER_UNI_TAG_ENUMERATED) )
1715                         )) return FALSE;
1716
1717         if((tvb_get_guint8(tvb, offset)==0)&&(tvb_get_guint8(tvb, offset+1)==0))
1718                 return TRUE;
1719
1720         hoffset = offset;
1721
1722         offset = get_ber_identifier(tvb, offset, &ber_class, &pc, &tag);
1723         offset = get_ber_length(tvb, offset, &len, NULL);
1724         eoffset = offset + len;
1725
1726         if (eoffset <= hoffset) return FALSE;
1727
1728         if ((ber_class!=BER_CLASS_APP)&&(ber_class!=BER_CLASS_PRI))
1729                 if( (ber_class!=BER_CLASS_UNI)
1730                         ||((tag<BER_UNI_TAG_NumericString)&&(tag!=BER_UNI_TAG_OCTETSTRING)&&(tag!=BER_UNI_TAG_UTF8String)) )
1731                         return FALSE;
1732
1733         return TRUE;
1734
1735 }
1736
1737
1738 /*--- Included file: packet-snmp-fn.c ---*/
1739 #line 1 "../../asn1/snmp/packet-snmp-fn.c"
1740
1741
1742
1743 static int
1744 dissect_snmp_EnterpriseOID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1745 #line 64 "../../asn1/snmp/snmp.cnf"
1746   const gchar* name;
1747
1748   offset = dissect_ber_object_identifier_str(implicit_tag, actx, tree, tvb, offset, hf_index, &enterprise_oid);
1749
1750
1751   if (display_oid && enterprise_oid) {
1752     name = oid_resolved_from_string(enterprise_oid);
1753     if (name) {
1754       col_append_fstr (actx->pinfo->cinfo, COL_INFO, " %s", name);
1755     }
1756   }
1757
1758
1759
1760   return offset;
1761 }
1762
1763
1764
1765 static int
1766 dissect_snmp_OCTET_STRING_SIZE_4(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1767   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1768                                        NULL);
1769
1770   return offset;
1771 }
1772
1773
1774
1775 static int
1776 dissect_snmp_NetworkAddress(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1777   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1778                                       hf_index, BER_CLASS_APP, 0, TRUE, dissect_snmp_OCTET_STRING_SIZE_4);
1779
1780   return offset;
1781 }
1782
1783
1784
1785 static int
1786 dissect_snmp_INTEGER_0_4294967295(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1787   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1788                                                 NULL);
1789
1790   return offset;
1791 }
1792
1793
1794
1795 static int
1796 dissect_snmp_TimeTicks(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1797   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1798                                       hf_index, BER_CLASS_APP, 3, TRUE, dissect_snmp_INTEGER_0_4294967295);
1799
1800   return offset;
1801 }
1802
1803
1804
1805 static int
1806 dissect_snmp_Integer32(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1807   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1808                                                 NULL);
1809
1810   return offset;
1811 }
1812
1813
1814
1815 static int
1816 dissect_snmp_ObjectName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1817   offset = dissect_ber_object_identifier(implicit_tag, actx, tree, tvb, offset, hf_index, NULL);
1818
1819   return offset;
1820 }
1821
1822
1823 static const value_string snmp_Version_vals[] = {
1824   {   0, "version-1" },
1825   {   1, "v2c" },
1826   {   2, "v2u" },
1827   {   3, "snmpv3" },
1828   { 0, NULL }
1829 };
1830
1831
1832 static int
1833 dissect_snmp_Version(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1834   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1835                                                 NULL);
1836
1837   return offset;
1838 }
1839
1840
1841
1842 static int
1843 dissect_snmp_Community(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1844   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
1845                                        NULL);
1846
1847   return offset;
1848 }
1849
1850
1851
1852 static int
1853 dissect_snmp_INTEGER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1854   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1855                                                 NULL);
1856
1857   return offset;
1858 }
1859
1860
1861 static const value_string snmp_T_error_status_vals[] = {
1862   {   0, "noError" },
1863   {   1, "tooBig" },
1864   {   2, "noSuchName" },
1865   {   3, "badValue" },
1866   {   4, "readOnly" },
1867   {   5, "genErr" },
1868   {   6, "noAccess" },
1869   {   7, "wrongType" },
1870   {   8, "wrongLength" },
1871   {   9, "wrongEncoding" },
1872   {  10, "wrongValue" },
1873   {  11, "noCreation" },
1874   {  12, "inconsistentValue" },
1875   {  13, "resourceUnavailable" },
1876   {  14, "commitFailed" },
1877   {  15, "undoFailed" },
1878   {  16, "authorizationError" },
1879   {  17, "notWritable" },
1880   {  18, "inconsistentName" },
1881   { 0, NULL }
1882 };
1883
1884
1885 static int
1886 dissect_snmp_T_error_status(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1887   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1888                                                 NULL);
1889
1890   return offset;
1891 }
1892
1893
1894
1895 static int
1896 dissect_snmp_NULL(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1897   offset = dissect_ber_null(implicit_tag, actx, tree, tvb, offset, hf_index);
1898
1899   return offset;
1900 }
1901
1902
1903
1904 static const ber_sequence_t VarBindList_sequence_of[1] = {
1905   { &hf_snmp_VarBindList_item, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_snmp_VarBind },
1906 };
1907
1908 static int
1909 dissect_snmp_VarBindList(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1910   offset = dissect_ber_sequence_of(implicit_tag, actx, tree, tvb, offset,
1911                                       VarBindList_sequence_of, hf_index, ett_snmp_VarBindList);
1912
1913   return offset;
1914 }
1915
1916
1917 static const ber_sequence_t PDU_sequence[] = {
1918   { &hf_snmp_request_id     , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER },
1919   { &hf_snmp_error_status   , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_T_error_status },
1920   { &hf_snmp_error_index    , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER },
1921   { &hf_snmp_variable_bindings, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_snmp_VarBindList },
1922   { NULL, 0, 0, 0, NULL }
1923 };
1924
1925 static int
1926 dissect_snmp_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1927   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
1928                                    PDU_sequence, hf_index, ett_snmp_PDU);
1929
1930   return offset;
1931 }
1932
1933
1934
1935 static int
1936 dissect_snmp_GetRequest_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1937   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1938                                       hf_index, BER_CLASS_CON, 0, TRUE, dissect_snmp_PDU);
1939
1940   return offset;
1941 }
1942
1943
1944
1945 static int
1946 dissect_snmp_GetNextRequest_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1947   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1948                                       hf_index, BER_CLASS_CON, 1, TRUE, dissect_snmp_PDU);
1949
1950   return offset;
1951 }
1952
1953
1954
1955 static int
1956 dissect_snmp_GetResponse_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1957   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1958                                       hf_index, BER_CLASS_CON, 2, TRUE, dissect_snmp_PDU);
1959
1960   return offset;
1961 }
1962
1963
1964
1965 static int
1966 dissect_snmp_SetRequest_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1967   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
1968                                       hf_index, BER_CLASS_CON, 3, TRUE, dissect_snmp_PDU);
1969
1970   return offset;
1971 }
1972
1973
1974 static const value_string snmp_GenericTrap_vals[] = {
1975   {   0, "coldStart" },
1976   {   1, "warmStart" },
1977   {   2, "linkDown" },
1978   {   3, "linkUp" },
1979   {   4, "authenticationFailure" },
1980   {   5, "egpNeighborLoss" },
1981   {   6, "enterpriseSpecific" },
1982   { 0, NULL }
1983 };
1984
1985
1986 static int
1987 dissect_snmp_GenericTrap(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1988   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
1989                                                 &generic_trap);
1990
1991   return offset;
1992 }
1993
1994
1995
1996 static int
1997 dissect_snmp_SpecificTrap(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
1998 #line 48 "../../asn1/snmp/snmp.cnf"
1999   guint specific_trap;
2000   
2001   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2002                                                 &specific_trap);
2003
2004
2005   if (generic_trap == 6) { /* enterprise specific */
2006     const gchar *specific_str = snmp_lookup_specific_trap (specific_trap);
2007     if (specific_str) {
2008       proto_item_append_text(actx->created_item, " (%s)", specific_str);
2009     }
2010   }
2011
2012
2013   return offset;
2014 }
2015
2016
2017 static const ber_sequence_t Trap_PDU_U_sequence[] = {
2018   { &hf_snmp_enterprise     , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_snmp_EnterpriseOID },
2019   { &hf_snmp_agent_addr     , BER_CLASS_APP, 0, BER_FLAGS_NOOWNTAG, dissect_snmp_NetworkAddress },
2020   { &hf_snmp_generic_trap   , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_GenericTrap },
2021   { &hf_snmp_specific_trap  , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_SpecificTrap },
2022   { &hf_snmp_time_stamp     , BER_CLASS_APP, 3, BER_FLAGS_NOOWNTAG, dissect_snmp_TimeTicks },
2023   { &hf_snmp_variable_bindings, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_snmp_VarBindList },
2024   { NULL, 0, 0, 0, NULL }
2025 };
2026
2027 static int
2028 dissect_snmp_Trap_PDU_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2029 #line 40 "../../asn1/snmp/snmp.cnf"
2030   generic_trap = 0;
2031   enterprise_oid = NULL;
2032
2033   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2034                                    Trap_PDU_U_sequence, hf_index, ett_snmp_Trap_PDU_U);
2035
2036
2037
2038
2039   return offset;
2040 }
2041
2042
2043
2044 static int
2045 dissect_snmp_Trap_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2046   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2047                                       hf_index, BER_CLASS_CON, 4, TRUE, dissect_snmp_Trap_PDU_U);
2048
2049   return offset;
2050 }
2051
2052
2053
2054 static int
2055 dissect_snmp_INTEGER_0_2147483647(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2056   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2057                                                 NULL);
2058
2059   return offset;
2060 }
2061
2062
2063 static const ber_sequence_t BulkPDU_sequence[] = {
2064   { &hf_snmp_bulkPDU_request_id, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_Integer32 },
2065   { &hf_snmp_non_repeaters  , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER_0_2147483647 },
2066   { &hf_snmp_max_repetitions, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER_0_2147483647 },
2067   { &hf_snmp_variable_bindings, BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_snmp_VarBindList },
2068   { NULL, 0, 0, 0, NULL }
2069 };
2070
2071 static int
2072 dissect_snmp_BulkPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2073   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2074                                    BulkPDU_sequence, hf_index, ett_snmp_BulkPDU);
2075
2076   return offset;
2077 }
2078
2079
2080
2081 static int
2082 dissect_snmp_GetBulkRequest_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2083   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2084                                       hf_index, BER_CLASS_CON, 5, TRUE, dissect_snmp_BulkPDU);
2085
2086   return offset;
2087 }
2088
2089
2090
2091 static int
2092 dissect_snmp_InformRequest_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2093   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2094                                       hf_index, BER_CLASS_CON, 6, TRUE, dissect_snmp_PDU);
2095
2096   return offset;
2097 }
2098
2099
2100
2101 static int
2102 dissect_snmp_SNMPv2_Trap_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2103   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2104                                       hf_index, BER_CLASS_CON, 7, TRUE, dissect_snmp_PDU);
2105
2106   return offset;
2107 }
2108
2109
2110
2111 static int
2112 dissect_snmp_Report_PDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2113   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2114                                       hf_index, BER_CLASS_CON, 8, TRUE, dissect_snmp_PDU);
2115
2116   return offset;
2117 }
2118
2119
2120 static const value_string snmp_PDUs_vals[] = {
2121   {   0, "get-request" },
2122   {   1, "get-next-request" },
2123   {   2, "get-response" },
2124   {   3, "set-request" },
2125   {   4, "trap" },
2126   {   5, "getBulkRequest" },
2127   {   6, "informRequest" },
2128   {   7, "snmpV2-trap" },
2129   {   8, "report" },
2130   { 0, NULL }
2131 };
2132
2133 static const ber_choice_t PDUs_choice[] = {
2134   {   0, &hf_snmp_get_request    , BER_CLASS_CON, 0, BER_FLAGS_NOOWNTAG, dissect_snmp_GetRequest_PDU },
2135   {   1, &hf_snmp_get_next_request, BER_CLASS_CON, 1, BER_FLAGS_NOOWNTAG, dissect_snmp_GetNextRequest_PDU },
2136   {   2, &hf_snmp_get_response   , BER_CLASS_CON, 2, BER_FLAGS_NOOWNTAG, dissect_snmp_GetResponse_PDU },
2137   {   3, &hf_snmp_set_request    , BER_CLASS_CON, 3, BER_FLAGS_NOOWNTAG, dissect_snmp_SetRequest_PDU },
2138   {   4, &hf_snmp_trap           , BER_CLASS_CON, 4, BER_FLAGS_NOOWNTAG, dissect_snmp_Trap_PDU },
2139   {   5, &hf_snmp_getBulkRequest , BER_CLASS_CON, 5, BER_FLAGS_NOOWNTAG, dissect_snmp_GetBulkRequest_PDU },
2140   {   6, &hf_snmp_informRequest  , BER_CLASS_CON, 6, BER_FLAGS_NOOWNTAG, dissect_snmp_InformRequest_PDU },
2141   {   7, &hf_snmp_snmpV2_trap    , BER_CLASS_CON, 7, BER_FLAGS_NOOWNTAG, dissect_snmp_SNMPv2_Trap_PDU },
2142   {   8, &hf_snmp_report         , BER_CLASS_CON, 8, BER_FLAGS_NOOWNTAG, dissect_snmp_Report_PDU },
2143   { 0, NULL, 0, 0, 0, NULL }
2144 };
2145
2146 static int
2147 dissect_snmp_PDUs(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2148 #line 28 "../../asn1/snmp/snmp.cnf"
2149 gint pdu_type=-1;
2150
2151   col_clear(actx->pinfo->cinfo, COL_INFO);
2152
2153   offset = dissect_ber_choice(actx, tree, tvb, offset,
2154                                  PDUs_choice, hf_index, ett_snmp_PDUs,
2155                                  &pdu_type);
2156
2157   if( (pdu_type!=-1) && snmp_PDUs_vals[pdu_type].strptr ){
2158         col_prepend_fstr(actx->pinfo->cinfo, COL_INFO, "%s", snmp_PDUs_vals[pdu_type].strptr);
2159   }
2160
2161
2162
2163   return offset;
2164 }
2165
2166
2167 static const ber_sequence_t Message_sequence[] = {
2168   { &hf_snmp_version        , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_Version },
2169   { &hf_snmp_community      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_Community },
2170   { &hf_snmp_data           , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_snmp_PDUs },
2171   { NULL, 0, 0, 0, NULL }
2172 };
2173
2174 static int
2175 dissect_snmp_Message(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2176   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2177                                    Message_sequence, hf_index, ett_snmp_Message);
2178
2179   return offset;
2180 }
2181
2182
2183
2184 static int
2185 dissect_snmp_OCTET_STRING(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2186   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2187                                        NULL);
2188
2189   return offset;
2190 }
2191
2192
2193 static const value_string snmp_T_datav2u_vals[] = {
2194   {   0, "plaintext" },
2195   {   1, "encrypted" },
2196   { 0, NULL }
2197 };
2198
2199 static const ber_choice_t T_datav2u_choice[] = {
2200   {   0, &hf_snmp_v2u_plaintext  , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG, dissect_snmp_PDUs },
2201   {   1, &hf_snmp_encrypted      , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_OCTET_STRING },
2202   { 0, NULL, 0, 0, 0, NULL }
2203 };
2204
2205 static int
2206 dissect_snmp_T_datav2u(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2207   offset = dissect_ber_choice(actx, tree, tvb, offset,
2208                                  T_datav2u_choice, hf_index, ett_snmp_T_datav2u,
2209                                  NULL);
2210
2211   return offset;
2212 }
2213
2214
2215 static const ber_sequence_t Messagev2u_sequence[] = {
2216   { &hf_snmp_version        , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_Version },
2217   { &hf_snmp_parameters     , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_OCTET_STRING },
2218   { &hf_snmp_datav2u        , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_snmp_T_datav2u },
2219   { NULL, 0, 0, 0, NULL }
2220 };
2221
2222 static int
2223 dissect_snmp_Messagev2u(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2224   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2225                                    Messagev2u_sequence, hf_index, ett_snmp_Messagev2u);
2226
2227   return offset;
2228 }
2229
2230
2231
2232 static int
2233 dissect_snmp_SnmpEngineID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2234 #line 99 "../../asn1/snmp/snmp.cnf"
2235         tvbuff_t* param_tvb = NULL;
2236
2237         offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2238                                        &param_tvb);
2239          if (param_tvb) {
2240                 proto_tree* engine_tree = proto_item_add_subtree(actx->created_item,ett_engineid);
2241                 dissect_snmp_engineid(engine_tree, param_tvb, 0, tvb_length_remaining(param_tvb,0));
2242         }
2243
2244
2245
2246   return offset;
2247 }
2248
2249
2250
2251 static int
2252 dissect_snmp_T_msgAuthoritativeEngineID(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2253 #line 90 "../../asn1/snmp/snmp.cnf"
2254
2255   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2256                                        &usm_p.engine_tvb);
2257          if (usm_p.engine_tvb) {
2258                 proto_tree* engine_tree = proto_item_add_subtree(actx->created_item,ett_engineid);
2259                 dissect_snmp_engineid(engine_tree, usm_p.engine_tvb, 0, tvb_length_remaining(usm_p.engine_tvb,0));
2260         }
2261
2262
2263
2264   return offset;
2265 }
2266
2267
2268
2269 static int
2270 dissect_snmp_T_msgAuthoritativeEngineBoots(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2271   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2272                                                 &usm_p.boots);
2273
2274   return offset;
2275 }
2276
2277
2278
2279 static int
2280 dissect_snmp_T_msgAuthoritativeEngineTime(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2281   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2282                                                 &usm_p.time);
2283
2284   return offset;
2285 }
2286
2287
2288
2289 static int
2290 dissect_snmp_T_msgUserName(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2291   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2292                                        &usm_p.user_tvb);
2293
2294   return offset;
2295 }
2296
2297
2298
2299 static int
2300 dissect_snmp_T_msgAuthenticationParameters(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2301 #line 112 "../../asn1/snmp/snmp.cnf"
2302         offset = dissect_ber_octet_string(FALSE, actx, tree, tvb, offset, hf_index, &usm_p.auth_tvb);
2303         if (usm_p.auth_tvb) {
2304                 usm_p.auth_item = actx->created_item;
2305                 usm_p.auth_offset = tvb_offset_from_real_beginning(usm_p.auth_tvb);
2306         }
2307
2308
2309   return offset;
2310 }
2311
2312
2313
2314 static int
2315 dissect_snmp_T_msgPrivacyParameters(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2316   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2317                                        &usm_p.priv_tvb);
2318
2319   return offset;
2320 }
2321
2322
2323 static const ber_sequence_t UsmSecurityParameters_sequence[] = {
2324   { &hf_snmp_msgAuthoritativeEngineID, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgAuthoritativeEngineID },
2325   { &hf_snmp_msgAuthoritativeEngineBoots, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgAuthoritativeEngineBoots },
2326   { &hf_snmp_msgAuthoritativeEngineTime, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgAuthoritativeEngineTime },
2327   { &hf_snmp_msgUserName    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgUserName },
2328   { &hf_snmp_msgAuthenticationParameters, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgAuthenticationParameters },
2329   { &hf_snmp_msgPrivacyParameters, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgPrivacyParameters },
2330   { NULL, 0, 0, 0, NULL }
2331 };
2332
2333 static int
2334 dissect_snmp_UsmSecurityParameters(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2335   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2336                                    UsmSecurityParameters_sequence, hf_index, ett_snmp_UsmSecurityParameters);
2337
2338   return offset;
2339 }
2340
2341
2342
2343 static int
2344 dissect_snmp_INTEGER_484_2147483647(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2345   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2346                                                 NULL);
2347
2348   return offset;
2349 }
2350
2351
2352
2353 static int
2354 dissect_snmp_T_msgFlags(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2355 #line 227 "../../asn1/snmp/snmp.cnf"
2356         tvbuff_t *parameter_tvb = NULL;
2357
2358    offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2359                                        &parameter_tvb);
2360
2361  if (parameter_tvb){
2362         guint8 v3_flags = tvb_get_guint8(parameter_tvb, 0);
2363         proto_tree* flags_tree = proto_item_add_subtree(actx->created_item,ett_msgFlags);
2364         
2365         proto_tree_add_item(flags_tree, hf_snmp_v3_flags_report, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
2366         proto_tree_add_item(flags_tree, hf_snmp_v3_flags_crypt, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
2367         proto_tree_add_item(flags_tree, hf_snmp_v3_flags_auth, parameter_tvb, 0, 1, ENC_BIG_ENDIAN);
2368         
2369         usm_p.encrypted = v3_flags & TH_CRYPT ? TRUE : FALSE;
2370         usm_p.authenticated = v3_flags & TH_AUTH ? TRUE : FALSE;
2371   }
2372
2373
2374
2375
2376   return offset;
2377 }
2378
2379
2380
2381 static int
2382 dissect_snmp_T_msgSecurityModel(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2383   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2384                                                 &MsgSecurityModel);
2385
2386   return offset;
2387 }
2388
2389
2390 static const ber_sequence_t HeaderData_sequence[] = {
2391   { &hf_snmp_msgID          , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER_0_2147483647 },
2392   { &hf_snmp_msgMaxSize     , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER_484_2147483647 },
2393   { &hf_snmp_msgFlags       , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgFlags },
2394   { &hf_snmp_msgSecurityModel, BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgSecurityModel },
2395   { NULL, 0, 0, 0, NULL }
2396 };
2397
2398 static int
2399 dissect_snmp_HeaderData(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2400   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2401                                    HeaderData_sequence, hf_index, ett_snmp_HeaderData);
2402
2403   return offset;
2404 }
2405
2406
2407
2408 static int
2409 dissect_snmp_T_msgSecurityParameters(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2410 #line 170 "../../asn1/snmp/snmp.cnf"
2411
2412         switch(MsgSecurityModel){
2413                 case SNMP_SEC_USM:      /* 3 */         
2414                         offset = dissect_snmp_UsmSecurityParameters(FALSE, tvb, offset+2, actx, tree, -1);
2415                         usm_p.user_assoc = get_user_assoc(usm_p.engine_tvb, usm_p.user_tvb);
2416                         break;
2417                 case SNMP_SEC_ANY:      /* 0 */
2418                 case SNMP_SEC_V1:       /* 1 */
2419                 case SNMP_SEC_V2C:      /* 2 */
2420                 default:
2421                           offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2422                                        NULL);
2423
2424                         break;
2425         }
2426
2427
2428
2429   return offset;
2430 }
2431
2432
2433 static const ber_sequence_t ScopedPDU_sequence[] = {
2434   { &hf_snmp_contextEngineID, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_SnmpEngineID },
2435   { &hf_snmp_contextName    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_OCTET_STRING },
2436   { &hf_snmp_data           , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_snmp_PDUs },
2437   { NULL, 0, 0, 0, NULL }
2438 };
2439
2440 static int
2441 dissect_snmp_ScopedPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2442   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2443                                    ScopedPDU_sequence, hf_index, ett_snmp_ScopedPDU);
2444
2445   return offset;
2446 }
2447
2448
2449
2450 static int
2451 dissect_snmp_T_encryptedPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2452 #line 121 "../../asn1/snmp/snmp.cnf"
2453         tvbuff_t* crypt_tvb;
2454         offset = dissect_ber_octet_string(FALSE, actx, tree, tvb, offset, hf_snmp_encryptedPDU, &crypt_tvb);
2455
2456         if( usm_p.encrypted && crypt_tvb
2457                 && usm_p.user_assoc
2458                 && usm_p.user_assoc->user.privProtocol ) {
2459                 
2460                 const gchar* error = NULL;
2461                 proto_tree* encryptedpdu_tree = proto_item_add_subtree(actx->created_item,ett_encryptedPDU);
2462                 tvbuff_t* cleartext_tvb = usm_p.user_assoc->user.privProtocol(&usm_p, crypt_tvb, &error );
2463
2464                 if (! cleartext_tvb) {
2465                         proto_item* cause = proto_tree_add_text(encryptedpdu_tree, crypt_tvb, 0, -1,
2466                                 "Failed to decrypt encryptedPDU: %s", error);
2467                         
2468                         expert_add_info_format(actx->pinfo, cause, PI_MALFORMED, PI_WARN,
2469                                 "Failed to decrypt encryptedPDU: %s", error);
2470
2471                         col_set_str(actx->pinfo->cinfo, COL_INFO, "encryptedPDU: Failed to decrypt");
2472                                 
2473                         return offset;
2474                 } else {
2475                         proto_item* decrypted_item;
2476                         proto_tree* decrypted_tree;
2477
2478                         if (! check_ScopedPdu(cleartext_tvb)) {
2479                                 proto_item* cause = proto_tree_add_text(encryptedpdu_tree, cleartext_tvb, 0, -1,
2480                                                                                         "Decrypted data not formatted as expected, wrong key?");
2481                                 
2482                                 expert_add_info_format(actx->pinfo, cause, PI_MALFORMED, PI_WARN,
2483                                                                            "Decrypted data not formatted as expected");
2484
2485                                 col_set_str(actx->pinfo->cinfo, COL_INFO, "encryptedPDU: Decrypted data not formatted as expected");
2486                                 
2487                                 return offset;
2488                         }
2489
2490                         
2491             add_new_data_source(actx->pinfo, cleartext_tvb, "Decrypted ScopedPDU");
2492                         
2493                         decrypted_item = proto_tree_add_item(encryptedpdu_tree, hf_snmp_decryptedPDU,cleartext_tvb,0,-1,ENC_NA);
2494                         decrypted_tree = proto_item_add_subtree(decrypted_item,ett_decrypted);
2495                         dissect_snmp_ScopedPDU(FALSE, cleartext_tvb, 0, actx, decrypted_tree, -1);
2496                  }
2497         } else {
2498                         col_set_str(actx->pinfo->cinfo, COL_INFO, "encryptedPDU: privKey Unknown");
2499         }
2500
2501
2502
2503   return offset;
2504 }
2505
2506
2507 static const value_string snmp_ScopedPduData_vals[] = {
2508   {   0, "plaintext" },
2509   {   1, "encryptedPDU" },
2510   { 0, NULL }
2511 };
2512
2513 static const ber_choice_t ScopedPduData_choice[] = {
2514   {   0, &hf_snmp_plaintext      , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_snmp_ScopedPDU },
2515   {   1, &hf_snmp_encryptedPDU   , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_encryptedPDU },
2516   { 0, NULL, 0, 0, 0, NULL }
2517 };
2518
2519 static int
2520 dissect_snmp_ScopedPduData(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2521   offset = dissect_ber_choice(actx, tree, tvb, offset,
2522                                  ScopedPduData_choice, hf_index, ett_snmp_ScopedPduData,
2523                                  NULL);
2524
2525   return offset;
2526 }
2527
2528
2529 static const ber_sequence_t SNMPv3Message_sequence[] = {
2530   { &hf_snmp_msgVersion     , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_Version },
2531   { &hf_snmp_msgGlobalData  , BER_CLASS_UNI, BER_UNI_TAG_SEQUENCE, BER_FLAGS_NOOWNTAG, dissect_snmp_HeaderData },
2532   { &hf_snmp_msgSecurityParameters, BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_T_msgSecurityParameters },
2533   { &hf_snmp_msgData        , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG|BER_FLAGS_NOTCHKTAG, dissect_snmp_ScopedPduData },
2534   { NULL, 0, 0, 0, NULL }
2535 };
2536
2537 static int
2538 dissect_snmp_SNMPv3Message(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2539   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2540                                    SNMPv3Message_sequence, hf_index, ett_snmp_SNMPv3Message);
2541
2542 #line 185 "../../asn1/snmp/snmp.cnf"
2543
2544         if( usm_p.authenticated
2545                 && usm_p.user_assoc
2546                 && usm_p.user_assoc->user.authModel ) {
2547                 const gchar* error = NULL;
2548                 proto_item* authen_item;
2549                 proto_tree* authen_tree = proto_item_add_subtree(usm_p.auth_item,ett_authParameters);
2550                 guint8* calc_auth;
2551                 guint calc_auth_len;
2552                 
2553                 usm_p.authOK = usm_p.user_assoc->user.authModel->authenticate( &usm_p, &calc_auth, &calc_auth_len, &error );
2554
2555                 if (error) {
2556                         authen_item = proto_tree_add_text(authen_tree,tvb,0,0,"Error while verifying Message authenticity: %s", error);
2557                         PROTO_ITEM_SET_GENERATED(authen_item);
2558                         expert_add_info_format( actx->pinfo, authen_item, PI_MALFORMED, PI_ERROR, "Error while verifying Message authenticity: %s", error );
2559                 } else {
2560                         int severity;
2561                         const gchar* msg;                       
2562
2563                         authen_item = proto_tree_add_boolean(authen_tree, hf_snmp_msgAuthentication, tvb, 0, 0, usm_p.authOK);
2564                         PROTO_ITEM_SET_GENERATED(authen_item);
2565                         
2566                         if (usm_p.authOK) {
2567                                 msg = "SNMP Authentication OK";
2568                                 severity = PI_CHAT;
2569                         } else {
2570                                 const gchar* calc_auth_str = bytestring_to_str(calc_auth,calc_auth_len,' ');
2571                                 proto_item_append_text(authen_item, " calculated = %s", calc_auth_str);
2572                                 msg = "SNMP Authentication Error";
2573                                 severity = PI_WARN;
2574                         }
2575
2576                         expert_add_info_format( actx->pinfo, authen_item, PI_CHECKSUM, severity, "%s", msg );
2577                 }
2578         }
2579
2580
2581   return offset;
2582 }
2583
2584
2585 static const value_string snmp_T_smux_version_vals[] = {
2586   {   0, "version-1" },
2587   { 0, NULL }
2588 };
2589
2590
2591 static int
2592 dissect_snmp_T_smux_version(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2593   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2594                                                 NULL);
2595
2596   return offset;
2597 }
2598
2599
2600
2601 static int
2602 dissect_snmp_OBJECT_IDENTIFIER(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2603   offset = dissect_ber_object_identifier(implicit_tag, actx, tree, tvb, offset, hf_index, NULL);
2604
2605   return offset;
2606 }
2607
2608
2609
2610 static int
2611 dissect_snmp_DisplayString(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2612   offset = dissect_ber_octet_string(implicit_tag, actx, tree, tvb, offset, hf_index,
2613                                        NULL);
2614
2615   return offset;
2616 }
2617
2618
2619 static const ber_sequence_t SimpleOpen_U_sequence[] = {
2620   { &hf_snmp_smux_version   , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_T_smux_version },
2621   { &hf_snmp_identity       , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_snmp_OBJECT_IDENTIFIER },
2622   { &hf_snmp_description    , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_DisplayString },
2623   { &hf_snmp_password       , BER_CLASS_UNI, BER_UNI_TAG_OCTETSTRING, BER_FLAGS_NOOWNTAG, dissect_snmp_OCTET_STRING },
2624   { NULL, 0, 0, 0, NULL }
2625 };
2626
2627 static int
2628 dissect_snmp_SimpleOpen_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2629   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2630                                    SimpleOpen_U_sequence, hf_index, ett_snmp_SimpleOpen_U);
2631
2632   return offset;
2633 }
2634
2635
2636
2637 static int
2638 dissect_snmp_SimpleOpen(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2639   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2640                                       hf_index, BER_CLASS_APP, 0, TRUE, dissect_snmp_SimpleOpen_U);
2641
2642   return offset;
2643 }
2644
2645
2646 static const value_string snmp_OpenPDU_vals[] = {
2647   {   0, "smux-simple" },
2648   { 0, NULL }
2649 };
2650
2651 static const ber_choice_t OpenPDU_choice[] = {
2652   {   0, &hf_snmp_smux_simple    , BER_CLASS_APP, 0, BER_FLAGS_NOOWNTAG, dissect_snmp_SimpleOpen },
2653   { 0, NULL, 0, 0, 0, NULL }
2654 };
2655
2656 static int
2657 dissect_snmp_OpenPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2658   offset = dissect_ber_choice(actx, tree, tvb, offset,
2659                                  OpenPDU_choice, hf_index, ett_snmp_OpenPDU,
2660                                  NULL);
2661
2662   return offset;
2663 }
2664
2665
2666 static const value_string snmp_ClosePDU_U_vals[] = {
2667   {   0, "goingDown" },
2668   {   1, "unsupportedVersion" },
2669   {   2, "packetFormat" },
2670   {   3, "protocolError" },
2671   {   4, "internalError" },
2672   {   5, "authenticationFailure" },
2673   { 0, NULL }
2674 };
2675
2676
2677 static int
2678 dissect_snmp_ClosePDU_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2679   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2680                                                 NULL);
2681
2682   return offset;
2683 }
2684
2685
2686
2687 static int
2688 dissect_snmp_ClosePDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2689   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2690                                       hf_index, BER_CLASS_APP, 1, TRUE, dissect_snmp_ClosePDU_U);
2691
2692   return offset;
2693 }
2694
2695
2696
2697 static int
2698 dissect_snmp_INTEGER_M1_2147483647(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2699   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2700                                                 NULL);
2701
2702   return offset;
2703 }
2704
2705
2706 static const value_string snmp_T_operation_vals[] = {
2707   {   0, "delete" },
2708   {   1, "readOnly" },
2709   {   2, "readWrite" },
2710   { 0, NULL }
2711 };
2712
2713
2714 static int
2715 dissect_snmp_T_operation(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2716   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2717                                                 NULL);
2718
2719   return offset;
2720 }
2721
2722
2723 static const ber_sequence_t RReqPDU_U_sequence[] = {
2724   { &hf_snmp_subtree        , BER_CLASS_UNI, BER_UNI_TAG_OID, BER_FLAGS_NOOWNTAG, dissect_snmp_ObjectName },
2725   { &hf_snmp_priority       , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_INTEGER_M1_2147483647 },
2726   { &hf_snmp_operation      , BER_CLASS_UNI, BER_UNI_TAG_INTEGER, BER_FLAGS_NOOWNTAG, dissect_snmp_T_operation },
2727   { NULL, 0, 0, 0, NULL }
2728 };
2729
2730 static int
2731 dissect_snmp_RReqPDU_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2732   offset = dissect_ber_sequence(implicit_tag, actx, tree, tvb, offset,
2733                                    RReqPDU_U_sequence, hf_index, ett_snmp_RReqPDU_U);
2734
2735   return offset;
2736 }
2737
2738
2739
2740 static int
2741 dissect_snmp_RReqPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2742   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2743                                       hf_index, BER_CLASS_APP, 2, TRUE, dissect_snmp_RReqPDU_U);
2744
2745   return offset;
2746 }
2747
2748
2749 static const value_string snmp_RRspPDU_U_vals[] = {
2750   {  -1, "failure" },
2751   { 0, NULL }
2752 };
2753
2754
2755 static int
2756 dissect_snmp_RRspPDU_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2757   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2758                                                 NULL);
2759
2760   return offset;
2761 }
2762
2763
2764
2765 static int
2766 dissect_snmp_RRspPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2767   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2768                                       hf_index, BER_CLASS_APP, 3, TRUE, dissect_snmp_RRspPDU_U);
2769
2770   return offset;
2771 }
2772
2773
2774 static const value_string snmp_RegisterResponse_vals[] = {
2775   {   0, "rRspPDU" },
2776   {   1, "pDUs" },
2777   { 0, NULL }
2778 };
2779
2780 static const ber_choice_t RegisterResponse_choice[] = {
2781   {   0, &hf_snmp_rRspPDU        , BER_CLASS_APP, 3, BER_FLAGS_NOOWNTAG, dissect_snmp_RRspPDU },
2782   {   1, &hf_snmp_pDUs           , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG, dissect_snmp_PDUs },
2783   { 0, NULL, 0, 0, 0, NULL }
2784 };
2785
2786 static int
2787 dissect_snmp_RegisterResponse(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2788   offset = dissect_ber_choice(actx, tree, tvb, offset,
2789                                  RegisterResponse_choice, hf_index, ett_snmp_RegisterResponse,
2790                                  NULL);
2791
2792   return offset;
2793 }
2794
2795
2796 static const value_string snmp_SOutPDU_U_vals[] = {
2797   {   0, "commit" },
2798   {   1, "rollback" },
2799   { 0, NULL }
2800 };
2801
2802
2803 static int
2804 dissect_snmp_SOutPDU_U(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2805   offset = dissect_ber_integer(implicit_tag, actx, tree, tvb, offset, hf_index,
2806                                                 NULL);
2807
2808   return offset;
2809 }
2810
2811
2812
2813 static int
2814 dissect_snmp_SOutPDU(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2815   offset = dissect_ber_tagged_type(implicit_tag, actx, tree, tvb, offset,
2816                                       hf_index, BER_CLASS_APP, 4, TRUE, dissect_snmp_SOutPDU_U);
2817
2818   return offset;
2819 }
2820
2821
2822 static const value_string snmp_SMUX_PDUs_vals[] = {
2823   {   0, "open" },
2824   {   1, "close" },
2825   {   2, "registerRequest" },
2826   {   3, "registerResponse" },
2827   {   4, "commitOrRollback" },
2828   { 0, NULL }
2829 };
2830
2831 static const ber_choice_t SMUX_PDUs_choice[] = {
2832   {   0, &hf_snmp_open           , BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG, dissect_snmp_OpenPDU },
2833   {   1, &hf_snmp_close          , BER_CLASS_APP, 1, BER_FLAGS_NOOWNTAG, dissect_snmp_ClosePDU },
2834   {   2, &hf_snmp_registerRequest, BER_CLASS_APP, 2, BER_FLAGS_NOOWNTAG, dissect_snmp_RReqPDU },
2835   {   3, &hf_snmp_registerResponse, BER_CLASS_ANY/*choice*/, -1/*choice*/, BER_FLAGS_NOOWNTAG, dissect_snmp_RegisterResponse },
2836   {   4, &hf_snmp_commitOrRollback, BER_CLASS_APP, 4, BER_FLAGS_NOOWNTAG, dissect_snmp_SOutPDU },
2837   { 0, NULL, 0, 0, 0, NULL }
2838 };
2839
2840 static int
2841 dissect_snmp_SMUX_PDUs(gboolean implicit_tag _U_, tvbuff_t *tvb _U_, int offset _U_, asn1_ctx_t *actx _U_, proto_tree *tree _U_, int hf_index _U_) {
2842   offset = dissect_ber_choice(actx, tree, tvb, offset,
2843                                  SMUX_PDUs_choice, hf_index, ett_snmp_SMUX_PDUs,
2844                                  NULL);
2845
2846   return offset;
2847 }
2848
2849 /*--- PDUs ---*/
2850
2851 static void dissect_SMUX_PDUs_PDU(tvbuff_t *tvb _U_, packet_info *pinfo _U_, proto_tree *tree _U_) {
2852   asn1_ctx_t asn1_ctx;
2853   asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
2854   dissect_snmp_SMUX_PDUs(FALSE, tvb, 0, &asn1_ctx, tree, hf_snmp_SMUX_PDUs_PDU);
2855 }
2856
2857
2858 /*--- End of included file: packet-snmp-fn.c ---*/
2859 #line 1636 "../../asn1/snmp/packet-snmp-template.c"
2860
2861
2862 guint
2863 dissect_snmp_pdu(tvbuff_t *tvb, int offset, packet_info *pinfo,
2864                  proto_tree *tree, int proto, gint ett, gboolean is_tcp)
2865 {
2866
2867         guint length_remaining;
2868         gint8 ber_class;
2869         gboolean pc, ind = 0;
2870         gint32 tag;
2871         guint32 len;
2872         guint message_length;
2873         int start_offset = offset;
2874         guint32 version = 0;
2875         tvbuff_t        *next_tvb;
2876
2877         proto_tree *snmp_tree = NULL;
2878         proto_item *item = NULL;
2879         asn1_ctx_t asn1_ctx;
2880         asn1_ctx_init(&asn1_ctx, ASN1_ENC_BER, TRUE, pinfo);
2881
2882
2883         usm_p.msg_tvb = tvb;
2884         usm_p.start_offset = tvb_offset_from_real_beginning(tvb);
2885         usm_p.engine_tvb = NULL;
2886         usm_p.user_tvb = NULL;
2887         usm_p.auth_item = NULL;
2888         usm_p.auth_tvb = NULL;
2889         usm_p.auth_offset = 0;
2890         usm_p.priv_tvb = NULL;
2891         usm_p.user_assoc = NULL;
2892         usm_p.authenticated = FALSE;
2893         usm_p.encrypted = FALSE;
2894         usm_p.boots = 0;
2895         usm_p.time = 0;
2896         usm_p.authOK = FALSE;
2897
2898         /*
2899          * This will throw an exception if we don't have any data left.
2900          * That's what we want.  (See "tcp_dissect_pdus()", which is
2901          * similar, but doesn't have to deal with ASN.1.
2902          * XXX - can we make "tcp_dissect_pdus()" provide enough
2903          * information to the "get_pdu_len" routine so that we could
2904          * have that routine deal with ASN.1, and just use
2905          * "tcp_dissect_pdus()"?)
2906          */
2907         length_remaining = tvb_ensure_length_remaining(tvb, offset);
2908
2909         /* NOTE: we have to parse the message piece by piece, since the
2910          * capture length may be less than the message length: a 'global'
2911          * parsing is likely to fail.
2912          */
2913
2914         /*
2915          * If this is SNMP-over-TCP, we might have to do reassembly
2916          * in order to read the "Sequence Of" header.
2917          */
2918         if (is_tcp && snmp_desegment && pinfo->can_desegment) {
2919                 /*
2920                  * This is TCP, and we should, and can, do reassembly.
2921                  *
2922                  * Is the "Sequence Of" header split across segment
2923                  * boundaries?  We require at least 6 bytes for the
2924                  * header, which allows for a 4-byte length (ASN.1
2925                  * BER).
2926                  */
2927                 if (length_remaining < 6) {
2928                         /*
2929                          * Yes.  Tell the TCP dissector where the data
2930                          * for this message starts in the data it handed
2931                          * us and that we need "some more data."  Don't tell
2932                          * it exactly how many bytes we need because if/when
2933                          * we ask for even more (after the header) that will
2934                          * break reassembly.
2935                          */
2936                         pinfo->desegment_offset = offset;
2937                         pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
2938
2939                         /*
2940                          * Return 0, which means "I didn't dissect anything
2941                          * because I don't have enough data - we need
2942                          * to desegment".
2943                          */
2944                         return 0;
2945                 }
2946         }
2947
2948         /*
2949          * OK, try to read the "Sequence Of" header; this gets the total
2950          * length of the SNMP message.
2951          */
2952         /* Set tree to 0 to not display internal BER fields if option used.*/
2953         offset = dissect_ber_identifier(pinfo, 0, tvb, offset, &ber_class, &pc, &tag);
2954         /*Get the total octet length of the SNMP data*/
2955         offset = dissect_ber_length(pinfo, 0, tvb, offset, &len, &ind);
2956         message_length = len + offset;
2957
2958         /*Get the SNMP version data*/
2959         offset = dissect_ber_integer(FALSE, &asn1_ctx, 0, tvb, offset, -1, &version);
2960
2961
2962         /*
2963          * If this is SNMP-over-TCP, we might have to do reassembly
2964          * to get all of this message.
2965          */
2966         if (is_tcp && snmp_desegment && pinfo->can_desegment) {
2967                 /*
2968                  * Yes - is the message split across segment boundaries?
2969                  */
2970                 if (length_remaining < message_length) {
2971                         /*
2972                          * Yes.  Tell the TCP dissector where the data
2973                          * for this message starts in the data it handed
2974                          * us, and how many more bytes we need, and
2975                          * return.
2976                          */
2977                         pinfo->desegment_offset = start_offset;
2978                         pinfo->desegment_len =
2979                         message_length - length_remaining;
2980
2981                         /*
2982                          * Return 0, which means "I didn't dissect anything
2983                          * because I don't have enough data - we need
2984                          * to desegment".
2985                          */
2986                         return 0;
2987                 }
2988         }
2989
2990         next_tvb_init(&var_list);
2991
2992         col_set_str(pinfo->cinfo, COL_PROTOCOL,
2993             proto_get_protocol_short_name(find_protocol_by_id(proto)));
2994
2995         if (tree) {
2996                 item = proto_tree_add_item(tree, proto, tvb, start_offset,
2997                                            message_length, ENC_BIG_ENDIAN);
2998                 snmp_tree = proto_item_add_subtree(item, ett);
2999         }
3000
3001         switch (version) {
3002         case 0: /* v1 */
3003         case 1: /* v2c */
3004                 offset = dissect_snmp_Message(FALSE , tvb, start_offset, &asn1_ctx, snmp_tree, -1);
3005                 break;
3006         case 2: /* v2u */
3007                 offset = dissect_snmp_Messagev2u(FALSE , tvb, start_offset, &asn1_ctx, snmp_tree, -1);
3008                 break;
3009                         /* v3 */
3010         case 3:
3011                 offset = dissect_snmp_SNMPv3Message(FALSE , tvb, start_offset, &asn1_ctx, snmp_tree, -1);
3012                 break;
3013         default:
3014                 /*
3015                  * Return the length remaining in the tvbuff, so
3016                  * if this is SNMP-over-TCP, our caller thinks there's
3017                  * nothing left to dissect.
3018                  */
3019                 proto_tree_add_text(snmp_tree, tvb, offset, -1,"Unknown version");
3020                 return length_remaining;
3021                 break;
3022         }
3023
3024         /* There may be appended data after the SNMP data, so treat as raw
3025          * data which needs to be dissected in case of UDP as UDP is PDU oriented.
3026          */
3027         if((!is_tcp) && (length_remaining > (guint)offset)) {
3028                 next_tvb = tvb_new_subset_remaining(tvb, offset);
3029                 call_dissector(data_handle, next_tvb, pinfo, tree);
3030         } else {
3031                 next_tvb_call(&var_list, pinfo, tree, NULL, data_handle);
3032         }
3033
3034         return offset;
3035 }
3036
3037 static gint
3038 dissect_snmp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
3039 {
3040         conversation_t  *conversation;
3041         int offset;
3042         gint8 tmp_class;
3043         gboolean tmp_pc;
3044         gint32 tmp_tag;
3045         guint32 tmp_length;
3046         gboolean tmp_ind;
3047
3048         /*
3049          * See if this looks like SNMP or not. if not, return 0 so
3050          * wireshark can try som other dissector instead.
3051          */
3052         /* All SNMP packets are BER encoded and consist of a SEQUENCE
3053          * that spans the entire PDU. The first item is an INTEGER that
3054          * has the values 0-2 (version 1-3).
3055          * if not it is not snmp.
3056          */
3057         /* SNMP starts with a SEQUENCE */
3058         offset = get_ber_identifier(tvb, 0, &tmp_class, &tmp_pc, &tmp_tag);
3059         if((tmp_class!=BER_CLASS_UNI)||(tmp_tag!=BER_UNI_TAG_SEQUENCE)) {
3060                 return 0;
3061         }
3062         /* then comes a length which spans the rest of the tvb */
3063         offset = get_ber_length(tvb, offset, &tmp_length, &tmp_ind);
3064         /* if(tmp_length!=(guint32)tvb_reported_length_remaining(tvb, offset)) {
3065          * Losen the heuristic a bit to handle the case where data has intentionally
3066          * been added after the snmp PDU ( UDP case)
3067          */
3068         if ( pinfo->ptype == PT_UDP ) {
3069                 if(tmp_length>(guint32)tvb_reported_length_remaining(tvb, offset)) {
3070                         return 0;
3071                 }
3072         }else{
3073                 if(tmp_length!=(guint32)tvb_reported_length_remaining(tvb, offset)) {
3074                         return 0;
3075                 }
3076         }
3077         /* then comes an INTEGER (version)*/
3078         get_ber_identifier(tvb, offset, &tmp_class, &tmp_pc, &tmp_tag);
3079         if((tmp_class!=BER_CLASS_UNI)||(tmp_tag!=BER_UNI_TAG_INTEGER)) {
3080                 return 0;
3081         }
3082         /* do we need to test that version is 0 - 2 (version1-3) ? */
3083
3084
3085         /*
3086          * The first SNMP packet goes to the SNMP port; the second one
3087          * may come from some *other* port, but goes back to the same
3088          * IP address and port as the ones from which the first packet
3089          * came; all subsequent packets presumably go between those two
3090          * IP addresses and ports.
3091          *
3092          * If this packet went to the SNMP port, we check to see if
3093          * there's already a conversation with one address/port pair
3094          * matching the source IP address and port of this packet,
3095          * the other address matching the destination IP address of this
3096          * packet, and any destination port.
3097          *
3098          * If not, we create one, with its address 1/port 1 pair being
3099          * the source address/port of this packet, its address 2 being
3100          * the destination address of this packet, and its port 2 being
3101          * wildcarded, and give it the SNMP dissector as a dissector.
3102          */
3103         if (pinfo->destport == UDP_PORT_SNMP) {
3104           conversation = find_conversation(pinfo->fd->num, &pinfo->src, &pinfo->dst, PT_UDP,
3105                                            pinfo->srcport, 0, NO_PORT_B);
3106           if( (conversation == NULL) || (conversation->dissector_handle!=snmp_handle) ) {
3107             conversation = conversation_new(pinfo->fd->num, &pinfo->src, &pinfo->dst, PT_UDP,
3108                                             pinfo->srcport, 0, NO_PORT2);
3109             conversation_set_dissector(conversation, snmp_handle);
3110           }
3111         }
3112
3113         return dissect_snmp_pdu(tvb, 0, pinfo, tree, proto_snmp, ett_snmp, FALSE);
3114 }
3115
3116 static void
3117 dissect_snmp_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
3118 {
3119         int offset = 0;
3120         guint message_len;
3121
3122         while (tvb_reported_length_remaining(tvb, offset) > 0) {
3123                 message_len = dissect_snmp_pdu(tvb, 0, pinfo, tree,
3124                                                proto_snmp, ett_snmp, TRUE);
3125                 if (message_len == 0) {
3126                         /*
3127                          * We don't have all the data for that message,
3128                          * so we need to do desegmentation;
3129                          * "dissect_snmp_pdu()" has set that up.
3130                          */
3131                         break;
3132                 }
3133                 offset += message_len;
3134         }
3135 }
3136
3137 static void
3138 dissect_smux(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
3139 {
3140         proto_tree *smux_tree = NULL;
3141         proto_item *item = NULL;
3142
3143         next_tvb_init(&var_list);
3144
3145         col_set_str(pinfo->cinfo, COL_PROTOCOL, "SMUX");
3146
3147         if (tree) {
3148                 item = proto_tree_add_item(tree, proto_smux, tvb, 0, -1, ENC_NA);
3149                 smux_tree = proto_item_add_subtree(item, ett_smux);
3150         }
3151
3152         dissect_SMUX_PDUs_PDU(tvb, pinfo, smux_tree);
3153 }
3154
3155
3156 /*
3157   MD5 Password to Key Algorithm
3158   from RFC 3414 A.2.1
3159 */
3160 static void
3161 snmp_usm_password_to_key_md5(const guint8 *password, guint passwordlen,
3162                              const guint8 *engineID, guint   engineLength,
3163                              guint8 *key)
3164 {
3165         md5_state_t     MD;
3166         guint8     *cp, password_buf[64];
3167         guint32      password_index = 0;
3168         guint32      count = 0, i;
3169         guint8          key1[16];
3170         md5_init(&MD);   /* initialize MD5 */
3171
3172         /**********************************************/
3173         /* Use while loop until we've done 1 Megabyte */
3174         /**********************************************/
3175         while (count < 1048576) {
3176                 cp = password_buf;
3177                 if (passwordlen != 0) {
3178                         for (i = 0; i < 64; i++) {
3179                                 /*************************************************/
3180                                 /* Take the next octet of the password, wrapping */
3181                                 /* to the beginning of the password as necessary.*/
3182                                 /*************************************************/
3183                                 *cp++ = password[password_index++ % passwordlen];
3184                         }
3185                 } else {
3186                         *cp = 0;
3187                 }
3188                 md5_append(&MD, password_buf, 64);
3189                 count += 64;
3190         }
3191         md5_finish(&MD, key1);          /* tell MD5 we're done */
3192
3193         /*****************************************************/
3194         /* Now localize the key with the engineID and pass   */
3195         /* through MD5 to produce final key                  */
3196         /* We ignore invalid engineLengths here. More strict */
3197         /* checking is done in snmp_users_update_cb.         */
3198         /*****************************************************/
3199
3200         md5_init(&MD);
3201         md5_append(&MD, key1, 16);
3202         md5_append(&MD, engineID, engineLength);
3203         md5_append(&MD, key1, 16);
3204         md5_finish(&MD, key);
3205
3206         return;
3207 }
3208
3209
3210
3211
3212 /*
3213    SHA1 Password to Key Algorithm COPIED from RFC 3414 A.2.2
3214  */
3215
3216 static void
3217 snmp_usm_password_to_key_sha1(const guint8 *password, guint passwordlen,
3218                               const guint8 *engineID, guint engineLength,
3219                               guint8 *key)
3220 {
3221         sha1_context     SH;
3222         guint8     *cp, password_buf[64];
3223         guint32      password_index = 0;
3224         guint32      count = 0, i;
3225
3226         sha1_starts(&SH);   /* initialize SHA */
3227
3228         /**********************************************/
3229         /* Use while loop until we've done 1 Megabyte */
3230         /**********************************************/
3231         while (count < 1048576) {
3232                 cp = password_buf;
3233                 if (passwordlen != 0) {
3234                         for (i = 0; i < 64; i++) {
3235                                 /*************************************************/
3236                                 /* Take the next octet of the password, wrapping */
3237                                 /* to the beginning of the password as necessary.*/
3238                                 /*************************************************/
3239                                 *cp++ = password[password_index++ % passwordlen];
3240                         }
3241                 } else {
3242                         *cp = 0;
3243                 }
3244                 sha1_update (&SH, password_buf, 64);
3245                 count += 64;
3246         }
3247         sha1_finish(&SH, key);
3248
3249         /*****************************************************/
3250         /* Now localize the key with the engineID and pass   */
3251         /* through SHA to produce final key                  */
3252         /* We ignore invalid engineLengths here. More strict */
3253         /* checking is done in snmp_users_update_cb.         */
3254         /*****************************************************/
3255
3256         sha1_starts(&SH);
3257         sha1_update(&SH, key, 20);
3258         sha1_update(&SH, engineID, engineLength);
3259         sha1_update(&SH, key, 20);
3260         sha1_finish(&SH, key);
3261         return;
3262  }
3263
3264
3265 static void
3266 process_prefs(void)
3267 {
3268 }
3269
3270 static void*
3271 snmp_users_copy_cb(void* dest, const void* orig, size_t len _U_)
3272 {
3273         const snmp_ue_assoc_t* o = (const snmp_ue_assoc_t*)orig;
3274         snmp_ue_assoc_t* d = (snmp_ue_assoc_t*)dest;
3275
3276         d->auth_model = o->auth_model;
3277         d->user.authModel = auth_models[o->auth_model];
3278
3279         d->priv_proto = o->priv_proto;
3280         d->user.privProtocol = priv_protos[o->priv_proto];
3281
3282         d->user.userName.data = (guint8*)g_memdup(o->user.userName.data,o->user.userName.len);
3283         d->user.userName.len = o->user.userName.len;
3284
3285         d->user.authPassword.data = o->user.authPassword.data ? (guint8*)g_memdup(o->user.authPassword.data,o->user.authPassword.len) : NULL;
3286         d->user.authPassword.len = o->user.authPassword.len;
3287
3288         d->user.privPassword.data = o->user.privPassword.data ? (guint8*)g_memdup(o->user.privPassword.data,o->user.privPassword.len) : NULL;
3289         d->user.privPassword.len = o->user.privPassword.len;
3290
3291         d->engine.len = o->engine.len;
3292         if (o->engine.data) {
3293                 d->engine.data = (guint8*)g_memdup(o->engine.data,o->engine.len);
3294         }
3295
3296         d->user.authKey.data = o->user.authKey.data ? (guint8*)g_memdup(o->user.authKey.data,o->user.authKey.len) : NULL;
3297         d->user.authKey.len = o->user.authKey.len;
3298
3299         d->user.privKey.data = o->user.privKey.data ? (guint8*)g_memdup(o->user.privKey.data,o->user.privKey.len) : NULL;
3300         d->user.privKey.len = o->user.privKey.len;
3301
3302         return d;
3303 }
3304
3305 static void
3306 snmp_users_free_cb(void* p)
3307 {
3308         snmp_ue_assoc_t* ue = (snmp_ue_assoc_t*)p;
3309         g_free(ue->user.userName.data);
3310         g_free(ue->user.authPassword.data);
3311         g_free(ue->user.privPassword.data);
3312         g_free(ue->user.authKey.data);
3313         g_free(ue->user.privKey.data);
3314         g_free(ue->engine.data);
3315 }
3316
3317 static void
3318 snmp_users_update_cb(void* p _U_, const char** err)
3319 {
3320         snmp_ue_assoc_t* ue = (snmp_ue_assoc_t*)p;
3321         emem_strbuf_t* es = ep_strbuf_new("");
3322         unsigned int i;
3323
3324         *err = NULL;
3325
3326         if (num_ueas == 0)
3327                 /* Nothing to update */
3328                 return;
3329
3330         if (! ue->user.userName.len)
3331                 ep_strbuf_append_printf(es,"no userName\n");
3332
3333         for (i=0; i<num_ueas-1; i++) {
3334                 snmp_ue_assoc_t* u = &(ueas[i]);
3335
3336                 /* RFC 3411 section 5 */
3337                 if ((u->engine.len > 0) && (u->engine.len < 5 || u->engine.len > 32)) {
3338                         ep_strbuf_append_printf(es, "Invalid engineId length (%u). Must be between 5 and 32 (10 and 64 hex digits)\n", u->engine.len);
3339                 }
3340
3341
3342                 if ( u->user.userName.len == ue->user.userName.len
3343                         && u->engine.len == ue->engine.len && (u != ue)) {
3344
3345                         if (u->engine.len > 0 && memcmp( u->engine.data,   ue->engine.data,  u->engine.len ) == 0) {
3346                                 if ( memcmp( u->user.userName.data, ue->user.userName.data, ue->user.userName.len ) == 0 ) {
3347                                         /* XXX: make a string for the engineId */
3348                                         ep_strbuf_append_printf(es,"Duplicate key (userName='%s')\n",ue->user.userName.data);
3349                                 }
3350                         }
3351
3352                         if (u->engine.len == 0) {
3353                                 if ( memcmp( u->user.userName.data, ue->user.userName.data, ue->user.userName.len ) == 0 ) {
3354                                         ep_strbuf_append_printf(es,"Duplicate key (userName='%s' engineId=NONE)\n",ue->user.userName.data);
3355                                 }
3356                         }
3357                 }
3358         }
3359
3360         if (es->len) {
3361                 es = ep_strbuf_truncate(es,es->len-1);
3362                 *err = ep_strdup(es->str);
3363         }
3364
3365         return;
3366 }
3367
3368
3369 UAT_LSTRING_CB_DEF(snmp_users,userName,snmp_ue_assoc_t,user.userName.data,user.userName.len)
3370 UAT_LSTRING_CB_DEF(snmp_users,authPassword,snmp_ue_assoc_t,user.authPassword.data,user.authPassword.len)
3371 UAT_LSTRING_CB_DEF(snmp_users,privPassword,snmp_ue_assoc_t,user.privPassword.data,user.privPassword.len)
3372 UAT_BUFFER_CB_DEF(snmp_users,engine_id,snmp_ue_assoc_t,engine.data,engine.len)
3373 UAT_VS_DEF(snmp_users,auth_model,snmp_ue_assoc_t,guint,0,"MD5")
3374 UAT_VS_DEF(snmp_users,priv_proto,snmp_ue_assoc_t,guint,0,"DES")
3375
3376 static void *
3377 snmp_specific_trap_copy_cb(void *dest, const void *orig, size_t len _U_)
3378 {
3379         snmp_st_assoc_t *u = (snmp_st_assoc_t *)dest;
3380         const snmp_st_assoc_t *o = (const snmp_st_assoc_t *)orig;
3381
3382         u->enterprise = g_strdup(o->enterprise);
3383         u->trap = o->trap;
3384         u->desc = g_strdup(o->desc);
3385
3386         return dest;
3387 }
3388
3389 static void
3390 snmp_specific_trap_free_cb(void *r)
3391 {
3392         snmp_st_assoc_t *u = (snmp_st_assoc_t *)r;
3393
3394         g_free(u->enterprise);
3395         g_free(u->desc);
3396 }
3397
3398 UAT_CSTRING_CB_DEF(specific_traps, enterprise, snmp_st_assoc_t)
3399 UAT_DEC_CB_DEF(specific_traps, trap, snmp_st_assoc_t)
3400 UAT_CSTRING_CB_DEF(specific_traps, desc, snmp_st_assoc_t)
3401
3402         /*--- proto_register_snmp -------------------------------------------*/
3403 void proto_register_snmp(void) {
3404   /* List of fields */
3405   static hf_register_info hf[] = {
3406                 { &hf_snmp_v3_flags_auth,
3407                 { "Authenticated", "snmp.v3.flags.auth", FT_BOOLEAN, 8,
3408                     TFS(&tfs_set_notset), TH_AUTH, NULL, HFILL }},
3409                 { &hf_snmp_v3_flags_crypt,
3410                 { "Encrypted", "snmp.v3.flags.crypt", FT_BOOLEAN, 8,
3411                     TFS(&tfs_set_notset), TH_CRYPT, NULL, HFILL }},
3412                 { &hf_snmp_v3_flags_report,
3413                 { "Reportable", "snmp.v3.flags.report", FT_BOOLEAN, 8,
3414                     TFS(&tfs_set_notset), TH_REPORT, NULL, HFILL }},
3415                 { &hf_snmp_engineid_conform, {
3416                     "Engine ID Conformance", "snmp.engineid.conform", FT_BOOLEAN, 8,
3417                     TFS(&tfs_snmp_engineid_conform), F_SNMP_ENGINEID_CONFORM, "Engine ID RFC3411 Conformance", HFILL }},
3418                 { &hf_snmp_engineid_enterprise, {
3419                     "Engine Enterprise ID", "snmp.engineid.enterprise", FT_UINT32, BASE_DEC|BASE_EXT_STRING,
3420                     &sminmpec_values_ext, 0, NULL, HFILL }},
3421                 { &hf_snmp_engineid_format, {
3422                     "Engine ID Format", "snmp.engineid.format", FT_UINT8, BASE_DEC,
3423                     VALS(snmp_engineid_format_vals), 0, NULL, HFILL }},
3424                 { &hf_snmp_engineid_ipv4, {
3425                     "Engine ID Data: IPv4 address", "snmp.engineid.ipv4", FT_IPv4, BASE_NONE,
3426                     NULL, 0, NULL, HFILL }},
3427                 { &hf_snmp_engineid_ipv6, {
3428                     "Engine ID Data: IPv6 address", "snmp.engineid.ipv6", FT_IPv6, BASE_NONE,
3429                     NULL, 0, NULL, HFILL }},
3430                 { &hf_snmp_engineid_cisco_type, {
3431                     "Engine ID Data: Cisco type", "snmp.engineid.cisco.type", FT_UINT8, BASE_HEX,
3432                     VALS(snmp_engineid_cisco_type_vals), 0, NULL, HFILL }},
3433                 { &hf_snmp_engineid_mac, {
3434                     "Engine ID Data: MAC address", "snmp.engineid.mac", FT_ETHER, BASE_NONE,
3435                     NULL, 0, NULL, HFILL }},
3436                 { &hf_snmp_engineid_text, {
3437                     "Engine ID Data: Text", "snmp.engineid.text", FT_STRING, BASE_NONE,
3438                     NULL, 0, NULL, HFILL }},
3439                 { &hf_snmp_engineid_time, {
3440                     "Engine ID Data: Creation Time", "snmp.engineid.time", FT_ABSOLUTE_TIME, ABSOLUTE_TIME_LOCAL,
3441                     NULL, 0, NULL, HFILL }},
3442                 { &hf_snmp_engineid_data, {
3443                     "Engine ID Data", "snmp.engineid.data", FT_BYTES, BASE_NONE,
3444                     NULL, 0, NULL, HFILL }},
3445                 { &hf_snmp_msgAuthentication, {
3446                     "Authentication", "snmp.v3.auth", FT_BOOLEAN, BASE_NONE,
3447                     TFS(&auth_flags), 0, NULL, HFILL }},
3448                 { &hf_snmp_decryptedPDU, {
3449                     "Decrypted ScopedPDU", "snmp.decrypted_pdu", FT_BYTES, BASE_NONE,
3450                     NULL, 0, "Decrypted PDU", HFILL }},
3451                 { &hf_snmp_noSuchObject, {
3452                     "noSuchObject", "snmp.noSuchObject", FT_NONE, BASE_NONE,
3453                     NULL, 0, NULL, HFILL }},
3454                 { &hf_snmp_noSuchInstance, {
3455                     "noSuchInstance", "snmp.noSuchInstance", FT_NONE, BASE_NONE,
3456                     NULL, 0, NULL, HFILL }},
3457                 { &hf_snmp_endOfMibView, {
3458                     "endOfMibView", "snmp.endOfMibView", FT_NONE, BASE_NONE,
3459                     NULL, 0, NULL, HFILL }},
3460                 { &hf_snmp_unSpecified, {
3461                     "unSpecified", "snmp.unSpecified", FT_NONE, BASE_NONE,
3462                     NULL, 0, NULL, HFILL }},
3463
3464                 { &hf_snmp_integer32_value, {
3465                     "Value (Integer32)", "snmp.value.int", FT_INT64, BASE_DEC,
3466                     NULL, 0, NULL, HFILL }},
3467                 { &hf_snmp_octetstring_value, {
3468                     "Value (OctetString)", "snmp.value.octets", FT_BYTES, BASE_NONE,
3469                     NULL, 0, NULL, HFILL }},
3470                 { &hf_snmp_oid_value, {
3471                     "Value (OID)", "snmp.value.oid", FT_OID, BASE_NONE,
3472                     NULL, 0, NULL, HFILL }},
3473                 { &hf_snmp_null_value, {
3474                     "Value (Null)", "snmp.value.null", FT_NONE, BASE_NONE,
3475                     NULL, 0, NULL, HFILL }},
3476                 { &hf_snmp_ipv4_value, {
3477                     "Value (IpAddress)", "snmp.value.ipv4", FT_IPv4, BASE_NONE,
3478                     NULL, 0, NULL, HFILL }},
3479                 { &hf_snmp_ipv6_value, {
3480                     "Value (IpAddress)", "snmp.value.ipv6", FT_IPv6, BASE_NONE,
3481                     NULL, 0, NULL, HFILL }},
3482                 { &hf_snmp_anyaddress_value, {
3483                     "Value (IpAddress)", "snmp.value.addr", FT_BYTES, BASE_NONE,
3484                     NULL, 0, NULL, HFILL }},
3485                 { &hf_snmp_unsigned32_value, {
3486                     "Value (Unsigned32)", "snmp.value.u32", FT_INT64, BASE_DEC,
3487                     NULL, 0, NULL, HFILL }},
3488                 { &hf_snmp_gauge32_value, {
3489                     "Value (Gauge32)", "snmp.value.g32", FT_INT64, BASE_DEC,
3490                     NULL, 0, NULL, HFILL }},
3491                 { &hf_snmp_unknown_value, {
3492                     "Value (Unknown)", "snmp.value.unk", FT_BYTES, BASE_NONE,
3493                     NULL, 0, NULL, HFILL }},
3494                 { &hf_snmp_counter_value, {
3495                     "Value (Counter32)", "snmp.value.counter", FT_UINT64, BASE_DEC,
3496                     NULL, 0, NULL, HFILL }},
3497                 { &hf_snmp_big_counter_value, {
3498                     "Value (Counter64)", "snmp.value.counter", FT_UINT64, BASE_DEC,
3499                     NULL, 0, NULL, HFILL }},
3500                 { &hf_snmp_nsap_value, {
3501                     "Value (NSAP)", "snmp.value.nsap", FT_UINT64, BASE_DEC,
3502                     NULL, 0, NULL, HFILL }},
3503                 { &hf_snmp_timeticks_value, {
3504                     "Value (Timeticks)", "snmp.value.timeticks", FT_UINT64, BASE_DEC,
3505                     NULL, 0, NULL, HFILL }},
3506                 { &hf_snmp_opaque_value, {
3507                     "Value (Opaque)", "snmp.value.opaque", FT_BYTES, BASE_NONE,
3508                     NULL, 0, NULL, HFILL }},
3509                 { &hf_snmp_objectname, {
3510                     "Object Name", "snmp.name", FT_OID, BASE_NONE,
3511                     NULL, 0, NULL, HFILL }},
3512                 { &hf_snmp_scalar_instance_index, {
3513                     "Scalar Instance Index", "snmp.name.index", FT_UINT64, BASE_DEC,
3514                     NULL, 0, NULL, HFILL }},
3515
3516
3517
3518 /*--- Included file: packet-snmp-hfarr.c ---*/
3519 #line 1 "../../asn1/snmp/packet-snmp-hfarr.c"
3520     { &hf_snmp_SMUX_PDUs_PDU,
3521       { "SMUX-PDUs", "snmp.SMUX_PDUs",
3522         FT_UINT32, BASE_DEC, VALS(snmp_SMUX_PDUs_vals), 0,
3523         NULL, HFILL }},
3524     { &hf_snmp_version,
3525       { "version", "snmp.version",
3526         FT_INT32, BASE_DEC, VALS(snmp_Version_vals), 0,
3527         NULL, HFILL }},
3528     { &hf_snmp_community,
3529       { "community", "snmp.community",
3530         FT_STRING, BASE_NONE, NULL, 0,
3531         NULL, HFILL }},
3532     { &hf_snmp_data,
3533       { "data", "snmp.data",
3534         FT_UINT32, BASE_DEC, VALS(snmp_PDUs_vals), 0,
3535         "PDUs", HFILL }},
3536     { &hf_snmp_parameters,
3537       { "parameters", "snmp.parameters",
3538         FT_BYTES, BASE_NONE, NULL, 0,
3539         "OCTET_STRING", HFILL }},
3540     { &hf_snmp_datav2u,
3541       { "datav2u", "snmp.datav2u",
3542         FT_UINT32, BASE_DEC, VALS(snmp_T_datav2u_vals), 0,
3543         NULL, HFILL }},
3544     { &hf_snmp_v2u_plaintext,
3545       { "plaintext", "snmp.plaintext",
3546         FT_UINT32, BASE_DEC, VALS(snmp_PDUs_vals), 0,
3547         "PDUs", HFILL }},
3548     { &hf_snmp_encrypted,
3549       { "encrypted", "snmp.encrypted",
3550         FT_BYTES, BASE_NONE, NULL, 0,
3551         "OCTET_STRING", HFILL }},
3552     { &hf_snmp_msgAuthoritativeEngineID,
3553       { "msgAuthoritativeEngineID", "snmp.msgAuthoritativeEngineID",
3554         FT_BYTES, BASE_NONE, NULL, 0,
3555         NULL, HFILL }},
3556     { &hf_snmp_msgAuthoritativeEngineBoots,
3557       { "msgAuthoritativeEngineBoots", "snmp.msgAuthoritativeEngineBoots",
3558         FT_UINT32, BASE_DEC, NULL, 0,
3559         NULL, HFILL }},
3560     { &hf_snmp_msgAuthoritativeEngineTime,
3561       { "msgAuthoritativeEngineTime", "snmp.msgAuthoritativeEngineTime",
3562         FT_UINT32, BASE_DEC, NULL, 0,
3563         NULL, HFILL }},
3564     { &hf_snmp_msgUserName,
3565       { "msgUserName", "snmp.msgUserName",
3566         FT_STRING, BASE_NONE, NULL, 0,
3567         NULL, HFILL }},
3568     { &hf_snmp_msgAuthenticationParameters,
3569       { "msgAuthenticationParameters", "snmp.msgAuthenticationParameters",