wsgcrypt.h checks internally if we HAVE_LIBGCRYPT
[metze/wireshark/wip.git] / epan / dissectors / packet-zbee-security.c
1 /* packet-zbee-security.c
2  * Dissector helper routines for encrypted ZigBee frames.
3  * By Owen Kirby <osk@exegin.com>; portions by Fred Fierling <fff@exegin.com>
4  * Copyright 2009 Exegin Technologies Limited
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 /*  Include Files */
26 #include "config.h"
27
28
29 #include <epan/packet.h>
30 #include <epan/exceptions.h>
31
32 #include <epan/prefs.h>
33 #include <epan/expert.h>
34 #include <epan/uat.h>
35
36 /* We require libgcrpyt in order to decrypt ZigBee packets. Without it the best
37  * we can do is parse the security header and give up.
38  */
39 #include <wsutil/wsgcrypt.h>
40
41 #include "packet-ieee802154.h"
42 #include "packet-zbee.h"
43 #include "packet-zbee-nwk.h"
44 #include "packet-zbee-security.h"
45
46 /* Helper Functions */
47 #ifdef HAVE_LIBGCRYPT
48 static void        zbee_sec_key_hash(guint8 *, guint8, guint8 *);
49 static void        zbee_sec_make_nonce (zbee_security_packet *, guint8 *);
50 static gboolean    zbee_sec_decrypt_payload(zbee_security_packet *, const gchar *, const gchar, guint8 *,
51         guint, guint, guint8 *);
52 #endif
53 static gboolean    zbee_security_parse_key(const gchar *, guint8 *, gboolean);
54
55 /* Field pointers. */
56 static int hf_zbee_sec_field = -1;
57 static int hf_zbee_sec_key_id = -1;
58 static int hf_zbee_sec_nonce = -1;
59 static int hf_zbee_sec_counter = -1;
60 static int hf_zbee_sec_src64 = -1;
61 static int hf_zbee_sec_key_seqno = -1;
62 static int hf_zbee_sec_mic = -1;
63 static int hf_zbee_sec_key = -1;
64 static int hf_zbee_sec_key_origin = -1;
65 static int hf_zbee_sec_decryption_key = -1;
66
67 /* Subtree pointers. */
68 static gint ett_zbee_sec = -1;
69 static gint ett_zbee_sec_control = -1;
70
71 static expert_field ei_zbee_sec_encrypted_payload = EI_INIT;
72 static expert_field ei_zbee_sec_encrypted_payload_sliced = EI_INIT;
73 static expert_field ei_zbee_sec_extended_source_unknown = EI_INIT;
74
75 static dissector_handle_t   data_handle;
76
77 static const value_string zbee_sec_key_names[] = {
78     { ZBEE_SEC_KEY_LINK,        "Link Key" },
79     { ZBEE_SEC_KEY_NWK,         "Network Key" },
80     { ZBEE_SEC_KEY_TRANSPORT,   "Key-Transport Key" },
81     { ZBEE_SEC_KEY_LOAD,        "Key-Load Key" },
82     { 0, NULL }
83 };
84
85 #if 0
86 /* These aren't really used anymore, as ZigBee no longer includes them in the
87  * security control field. If we were to display them all we would ever see is
88  * security level 0.
89  */
90 static const value_string zbee_sec_level_names[] = {
91     { ZBEE_SEC_NONE,        "None" },
92     { ZBEE_SEC_MIC32,       "No Encryption, 32-bit MIC" },
93     { ZBEE_SEC_MIC64,       "No Encryption, 64-bit MIC" },
94     { ZBEE_SEC_MIC128,      "No Encryption, 128-bit MIC" },
95     { ZBEE_SEC_ENC,         "Encryption, No MIC" },
96     { ZBEE_SEC_ENC_MIC32,   "Encryption, 32-bit MIC" },
97     { ZBEE_SEC_ENC_MIC64,   "Encryption, 64-bit MIC" },
98     { ZBEE_SEC_ENC_MIC128,  "Encryption, 128-bit MIC" },
99     { 0, NULL }
100 };
101 #endif
102
103 /* The ZigBee security level, in enum_val_t for the security preferences. */
104 static const enum_val_t zbee_sec_level_enums[] = {
105     { "None",       "No Security",                                      ZBEE_SEC_NONE },
106     { "MIC32",      "No Encryption, 32-bit Integrity Protection",       ZBEE_SEC_MIC32 },
107     { "MIC64",      "No Encryption, 64-bit Integrity Protection",       ZBEE_SEC_MIC64 },
108     { "MIC128",     "No Encryption, 128-bit Integrity Protection",      ZBEE_SEC_MIC128 },
109     { "ENC",        "AES-128 Encryption, No Integrity Protection",      ZBEE_SEC_ENC },
110     { "ENC-MIC32",  "AES-128 Encryption, 32-bit Integrity Protection",  ZBEE_SEC_ENC_MIC32 },
111     { "ENC-MIC64",  "AES-128 Encryption, 64-bit Integrity Protection",  ZBEE_SEC_ENC_MIC64 },
112     { "ENC-MIC128", "AES-128 Encryption, 128-bit Integrity Protection", ZBEE_SEC_ENC_MIC128 },
113     { NULL, NULL, 0 }
114 };
115
116 static gint         gPREF_zbee_sec_level = ZBEE_SEC_ENC_MIC32;
117 static uat_t       *zbee_sec_key_table_uat;
118
119 static const value_string byte_order_vals[] = {
120     { 0, "Normal"},
121     { 1, "Reverse"},
122     { 0, NULL }
123 };
124
125 /* UAT Key Entry */
126 typedef struct _uat_key_record_t {
127     gchar    *string;
128     guint8    byte_order;
129     gchar    *label;
130 } uat_key_record_t;
131
132 UAT_CSTRING_CB_DEF(uat_key_records, string, uat_key_record_t)
133 UAT_VS_DEF(uat_key_records, byte_order, uat_key_record_t, guint8, 0, "Normal")
134 UAT_CSTRING_CB_DEF(uat_key_records, label, uat_key_record_t)
135
136 static GSList           *zbee_pc_keyring = NULL;
137 static uat_key_record_t *uat_key_records = NULL;
138 static guint             num_uat_key_records = 0;
139
140 static void* uat_key_record_copy_cb(void* n, const void* o, size_t siz _U_) {
141     uat_key_record_t* new_key = (uat_key_record_t *)n;
142     const uat_key_record_t* old_key = (const uat_key_record_t *)o;
143
144     if (old_key->string) {
145         new_key->string = g_strdup(old_key->string);
146     } else {
147         new_key->string = NULL;
148     }
149
150     if (old_key->label) {
151         new_key->label = g_strdup(old_key->label);
152     } else {
153         new_key->label = NULL;
154     }
155
156     new_key->byte_order = old_key->byte_order;
157
158     return new_key;
159 }
160
161 static gboolean uat_key_record_update_cb(void* r, char** err) {
162     uat_key_record_t* rec = (uat_key_record_t *)r;
163     guint8 key[ZBEE_SEC_CONST_KEYSIZE];
164
165     if (rec->string == NULL) {
166         *err = g_strdup("Key can't be blank");
167         return FALSE;
168     } else {
169         g_strstrip(rec->string);
170
171         if (rec->string[0] != 0) {
172             *err = NULL;
173             if ( !zbee_security_parse_key(rec->string, key, rec->byte_order) ) {
174                 *err = g_strdup_printf("Expecting %d hexadecimal bytes or\n"
175                         "a %d character double-quoted string", ZBEE_SEC_CONST_KEYSIZE, ZBEE_SEC_CONST_KEYSIZE);
176                 return FALSE;
177             }
178         } else {
179             *err = g_strdup("Key can't be blank");
180             return FALSE;
181         }
182     }
183     return TRUE;
184 }
185
186 static void uat_key_record_free_cb(void*r) {
187     uat_key_record_t* key = (uat_key_record_t *)r;
188
189     if (key->string) g_free(key->string);
190     if (key->label) g_free(key->label);
191 }
192
193 static void uat_key_record_post_update(void) {
194     guint           i;
195     key_record_t    key_record;
196     guint8          key[ZBEE_SEC_CONST_KEYSIZE];
197
198     /* empty the key ring */
199     if (zbee_pc_keyring) {
200        g_slist_free(zbee_pc_keyring);
201        zbee_pc_keyring = NULL;
202     }
203
204     /* Load the pre-configured slist from the UAT. */
205     for (i=0; (uat_key_records) && (i<num_uat_key_records) ; i++) {
206         key_record.frame_num = ZBEE_SEC_PC_KEY; /* means it's a user PC key */
207         key_record.label = g_strdup(uat_key_records[i].label);
208         if (zbee_security_parse_key(uat_key_records[i].string, key, uat_key_records[i].byte_order)) {
209             memcpy(&key_record.key, key, ZBEE_SEC_CONST_KEYSIZE);
210             zbee_pc_keyring = g_slist_prepend(zbee_pc_keyring, g_memdup(&key_record, sizeof(key_record_t)));
211         }
212     }
213 }
214
215 /*
216  * Enable this macro to use libgcrypt's CBC_MAC mode for the authentication
217  * phase. Unfortunately, this is broken, and I don't know why. However, using
218  * the messier EBC mode (to emulate CCM*) still works fine.
219  */
220 #if 0
221 #define ZBEE_SEC_USE_GCRYPT_CBC_MAC
222 #endif
223 /*FUNCTION:------------------------------------------------------
224  *  NAME
225  *      zbee_security_register
226  *  DESCRIPTION
227  *      Called by proto_register_zbee_nwk() to initialize the security
228  *      dissectors.
229  *  PARAMETERS
230  *      module_t    zbee_prefs   - Prefs module to load preferences under.
231  *  RETURNS
232  *      none
233  *---------------------------------------------------------------
234  */
235 void zbee_security_register(module_t *zbee_prefs, int proto)
236 {
237     static hf_register_info hf[] = {
238         { &hf_zbee_sec_field,
239           { "Security Control Field",   "zbee.sec.field", FT_UINT8, BASE_HEX, NULL,
240             0x0, NULL, HFILL }},
241
242         { &hf_zbee_sec_key_id,
243           { "Key Id",                    "zbee.sec.key", FT_UINT8, BASE_HEX, VALS(zbee_sec_key_names),
244             ZBEE_SEC_CONTROL_KEY, NULL, HFILL }},
245
246         { &hf_zbee_sec_nonce,
247           { "Extended Nonce",         "zbee.sec.ext_nonce", FT_BOOLEAN, 8, NULL, ZBEE_SEC_CONTROL_NONCE,
248             NULL, HFILL }},
249
250         { &hf_zbee_sec_counter,
251           { "Frame Counter",          "zbee.sec.counter", FT_UINT32, BASE_DEC, NULL, 0x0,
252             NULL, HFILL }},
253
254         { &hf_zbee_sec_src64,
255           { "Extended Source",                 "zbee.sec.src64", FT_EUI64, BASE_NONE, NULL, 0x0,
256             NULL, HFILL }},
257
258         { &hf_zbee_sec_key_seqno,
259           { "Key Sequence Number",    "zbee.sec.key_seqno", FT_UINT8, BASE_DEC, NULL, 0x0,
260             NULL, HFILL }},
261
262         { &hf_zbee_sec_mic,
263           { "Message Integrity Code", "zbee.sec.mic", FT_BYTES, BASE_NONE, NULL, 0x0,
264             NULL, HFILL }},
265
266         { &hf_zbee_sec_key,
267           { "Key", "zbee.sec.key", FT_BYTES, BASE_NONE, NULL, 0x0,
268             NULL, HFILL }},
269
270         { &hf_zbee_sec_key_origin,
271           { "Key Origin", "zbee.sec.key.origin", FT_FRAMENUM, BASE_NONE, NULL, 0x0,
272             NULL, HFILL }},
273
274         { &hf_zbee_sec_decryption_key,
275           { "Key Label", "zbee.sec.decryption_key", FT_STRING, BASE_NONE, NULL, 0x0,
276             NULL, HFILL }}
277     };
278
279     static gint *ett[] = {
280         &ett_zbee_sec,
281         &ett_zbee_sec_control
282     };
283
284     static ei_register_info ei[] = {
285         { &ei_zbee_sec_encrypted_payload, { "zbee_sec.encrypted_payload", PI_UNDECODED, PI_WARN, "Encrypted Payload", EXPFILL }},
286         { &ei_zbee_sec_encrypted_payload_sliced, { "zbee_sec.encrypted_payload_sliced", PI_UNDECODED, PI_WARN, "Encrypted payload, cut short when capturing - can't decrypt", EXPFILL }},
287         { &ei_zbee_sec_extended_source_unknown, { "zbee_sec.extended_source_unknown", PI_PROTOCOL, PI_NOTE, "Extended Source: Unknown", EXPFILL }},
288     };
289
290     expert_module_t* expert_zbee_sec;
291
292     static uat_field_t key_uat_fields[] = {
293         UAT_FLD_CSTRING(uat_key_records, string, "Key",
294                         "A 16-byte key in hexadecimal with optional dash-,\n"
295                         "colon-, or space-separator characters, or a\n"
296                         "a 16-character string in double-quotes."),
297         UAT_FLD_VS(uat_key_records, byte_order, "Byte Order", byte_order_vals,
298                         "Byte order of key."),
299         UAT_FLD_CSTRING(uat_key_records, label, "Label", "User label for key."),
300         UAT_END_FIELDS
301     };
302
303     /* If no prefs module was supplied, register our own. */
304     if (zbee_prefs == NULL) {
305         zbee_prefs = prefs_register_protocol(proto, NULL);
306     }
307
308     /*  Register preferences */
309     prefs_register_enum_preference(zbee_prefs, "seclevel", "Security Level",
310                  "Specifies the security level to use in the\n"
311                  "decryption process. This value is ignored\n"
312                  "for ZigBee 2004 and unsecured networks.",
313                  &gPREF_zbee_sec_level, zbee_sec_level_enums, FALSE);
314
315     zbee_sec_key_table_uat = uat_new("Pre-configured Keys",
316                                sizeof(uat_key_record_t),
317                                "zigbee_pc_keys",
318                                TRUE,
319                                &uat_key_records,
320                                &num_uat_key_records,
321                                UAT_AFFECTS_DISSECTION, /* affects dissection of packets, but not set of named fields */
322                                NULL,  /* TODO: ptr to help manual? */
323                                uat_key_record_copy_cb,
324                                uat_key_record_update_cb,
325                                uat_key_record_free_cb,
326                                uat_key_record_post_update,
327                                key_uat_fields );
328
329     prefs_register_uat_preference(zbee_prefs,
330                                   "key_table",
331                                   "Pre-configured Keys",
332                                   "Pre-configured link or network keys.",
333                                   zbee_sec_key_table_uat);
334
335     proto_register_field_array(proto, hf, array_length(hf));
336     proto_register_subtree_array(ett, array_length(ett));
337     expert_zbee_sec = expert_register_protocol(proto);
338     expert_register_field_array(expert_zbee_sec, ei, array_length(ei));
339
340 } /* zbee_security_register */
341
342 /*FUNCTION:------------------------------------------------------
343  *  NAME
344  *      zbee_security_parse_key
345  *  DESCRIPTION
346  *      Parses a key string from left to right into a buffer with
347  *      increasing (normal byte order) or decreasing (reverse byte
348  *      order) address.
349  *  PARAMETERS
350  *      const gchar    *key_str - pointer to the string
351  *      guint8         *key_buf - destination buffer in memory
352  *      gboolean        big_end - fill key_buf with incrementing address
353  *  RETURNS
354  *      gboolean
355  *---------------------------------------------------------------
356  */
357 static gboolean
358 zbee_security_parse_key(const gchar *key_str, guint8 *key_buf, gboolean byte_order)
359 {
360     int             i, j;
361     gchar           temp;
362     gboolean        string_mode = FALSE;
363
364     /* Clear the key. */
365     memset(key_buf, 0, ZBEE_SEC_CONST_KEYSIZE);
366     if (key_str == NULL) {
367         return FALSE;
368     }
369
370     /*
371      * Attempt to parse the key string. The key string must
372      * be at least 16 pairs of hexidecimal digits with the
373      * following optional separators: ':', '-', " ", or 16
374      * alphanumeric characters after a double-quote.
375      */
376     if ( (temp = *key_str++) == '"') {
377         string_mode = TRUE;
378         temp = *key_str++;
379     }
380
381     j = byte_order?ZBEE_SEC_CONST_KEYSIZE-1:0;
382     for (i=ZBEE_SEC_CONST_KEYSIZE-1; i>=0; i--) {
383         if ( string_mode ) {
384             if ( g_ascii_isprint(temp) ) {
385                 key_buf[j] = temp;
386                 temp = *key_str++;
387             } else {
388                 return FALSE;
389             }
390         }
391         else {
392             /* If this character is a separator, skip it. */
393             if ( (temp == ':') || (temp == '-') || (temp == ' ') ) temp = *(key_str++);
394
395             /* Process a nibble. */
396             if ( g_ascii_isxdigit (temp) ) key_buf[j] = g_ascii_xdigit_value(temp)<<4;
397             else return FALSE;
398
399             /* Get the next nibble. */
400             temp = *(key_str++);
401
402             /* Process another nibble. */
403             if ( g_ascii_isxdigit (temp) ) key_buf[j] |= g_ascii_xdigit_value(temp);
404             else return FALSE;
405
406             /* Get the next nibble. */
407             temp = *(key_str++);
408         }
409
410         /* Move key_buf pointer */
411         if ( byte_order ) {
412             j--;
413         } else {
414             j++;
415         }
416
417     } /* for */
418
419     /* If we get this far, then the key was good. */
420     return TRUE;
421 } /* zbee_security_parse_key */
422
423 /*FUNCTION:------------------------------------------------------
424  *  NAME
425  *      zbee_security_handoff
426  *  DESCRIPTION
427  *      Hands off the security dissector.
428  *  PARAMETERS
429  *      none
430  *  RETURNS
431  *      tvbuff_t *
432  *---------------------------------------------------------------
433  */
434 void
435 zbee_security_handoff(void)
436 {
437     /* Lookup the data dissector. */
438     data_handle = find_dissector("data");
439 } /* zbee_security_handoff */
440
441 /*FUNCTION:------------------------------------------------------
442  *  NAME
443  *      dissect_zbee_secure
444  *  DESCRIPTION
445  *      Dissects and decrypts secured ZigBee frames.
446  *
447  *      Will return a valid tvbuff only if security processing was
448  *      successful. If processing fails, then this function will
449  *      handle internally and return NULL.
450  *  PARAMETERS
451  *      tvbuff_t    *tvb    - pointer to buffer containing raw packet.
452  *      packet_info *pinfo  - pointer to packet information fields
453  *      proto_tree  *tree   - pointer to data tree Wireshark uses to display packet.
454  *      guint       offset  - pointer to the start of the auxilliary security header.
455  *      guint64     src64   - extended source address, or 0 if unknown.
456  *  RETURNS
457  *      tvbuff_t *
458  *---------------------------------------------------------------
459  */
460 tvbuff_t *
461 dissect_zbee_secure(tvbuff_t *tvb, packet_info *pinfo, proto_tree* tree, guint offset)
462 {
463     proto_tree     *sec_tree;
464
465     zbee_security_packet    packet;
466     guint           mic_len;
467     gint            payload_len;
468     tvbuff_t       *payload_tvb;
469
470 #ifdef HAVE_LIBGCRYPT
471     proto_item         *ti;
472     proto_item         *key_item;
473     guint8             *enc_buffer;
474     guint8             *dec_buffer;
475     gboolean            decrypted;
476     GSList            **nwk_keyring;
477     GSList             *GSList_i;
478     key_record_t       *key_rec = NULL;
479 #endif
480     zbee_nwk_hints_t   *nwk_hints;
481     ieee802154_hints_t *ieee_hints;
482     ieee802154_map_rec *map_rec = NULL;
483
484     static const int * sec_flags[] = {
485         &hf_zbee_sec_key_id,
486         &hf_zbee_sec_nonce,
487         NULL
488     };
489
490     /* Init */
491     memset(&packet, 0, sizeof(zbee_security_packet));
492
493     /* Get pointers to any useful frame data from lower layers */
494     nwk_hints = (zbee_nwk_hints_t *)p_get_proto_data(wmem_file_scope(), pinfo,
495         proto_get_id_by_filter_name(ZBEE_PROTOABBREV_NWK), 0);
496     ieee_hints = (ieee802154_hints_t *)p_get_proto_data(wmem_file_scope(), pinfo,
497         proto_get_id_by_filter_name(IEEE802154_PROTOABBREV_WPAN), 0);
498
499     /* Create a subtree for the security information. */
500     sec_tree = proto_tree_add_subtree(tree, tvb, offset, -1, ett_zbee_sec, NULL, "ZigBee Security Header");
501
502     /*  Get and display the Security control field */
503     packet.control  = tvb_get_guint8(tvb, offset);
504
505     /* Patch the security level. */
506     packet.control &= ~ZBEE_SEC_CONTROL_LEVEL;
507     packet.control |= (ZBEE_SEC_CONTROL_LEVEL & gPREF_zbee_sec_level);
508
509     /*
510      * Eww, I think I just threw up a little...  ZigBee requires this field
511      * to be patched before computing the MIC, but we don't have write-access
512      * to the tvbuff. So we need to allocate a copy of the whole thing just
513      * so we can fix these 3 bits. Memory allocated by tvb_memdup(wmem_packet_scope(),...)
514      * is automatically freed before the next packet is processed.
515      */
516 #ifdef HAVE_LIBGCRYPT
517     enc_buffer = (guint8 *)tvb_memdup(wmem_packet_scope(), tvb, 0, tvb_captured_length(tvb));
518     /*
519      * Override the const qualifiers and patch the security level field, we
520      * know it is safe to overide the const qualifiers because we just
521      * allocated this memory via tvb_memdup(wmem_packet_scope(),...).
522      */
523     enc_buffer[offset] = packet.control;
524 #endif /* HAVE_LIBGCRYPT */
525     packet.level    = zbee_get_bit_field(packet.control, ZBEE_SEC_CONTROL_LEVEL);
526     packet.key_id   = zbee_get_bit_field(packet.control, ZBEE_SEC_CONTROL_KEY);
527     packet.nonce    = zbee_get_bit_field(packet.control, ZBEE_SEC_CONTROL_NONCE);
528
529     proto_tree_add_bitmask(sec_tree, tvb, offset, hf_zbee_sec_field, ett_zbee_sec_control, sec_flags, ENC_NA);
530     offset += 1;
531
532     /* Get and display the frame counter field. */
533     packet.counter = tvb_get_letohl(tvb, offset);
534     proto_tree_add_uint(sec_tree, hf_zbee_sec_counter, tvb, offset, 4, packet.counter);
535     offset += 4;
536
537     if (packet.nonce) {
538         /* Get and display the source address of the device that secured this payload. */
539         packet.src64 = tvb_get_letoh64(tvb, offset);
540         proto_tree_add_item(sec_tree, hf_zbee_sec_src64, tvb, offset, 8, ENC_LITTLE_ENDIAN);
541 #if 1
542         if (!pinfo->fd->flags.visited) {
543             switch ( packet.key_id ) {
544                 case ZBEE_SEC_KEY_LINK:
545                 if (nwk_hints && ieee_hints) {
546                     /* Map this long address with the nwk layer short address. */
547                     nwk_hints->map_rec = ieee802154_addr_update(&zbee_nwk_map, nwk_hints->src,
548                             ieee_hints->src_pan, packet.src64, pinfo->current_proto, pinfo->fd->num);
549                 }
550                 break;
551
552                 case ZBEE_SEC_KEY_NWK:
553                 if (ieee_hints) {
554                     /* Map this long address with the ieee short address. */
555                     ieee_hints->map_rec = ieee802154_addr_update(&zbee_nwk_map, ieee_hints->src16,
556                         ieee_hints->src_pan, packet.src64, pinfo->current_proto, pinfo->fd->num);
557                 }
558                 break;
559
560                 /* We ignore the extended source addresses used to encrypt payloads with these
561                  * types of keys, because they can emerge from APS tunnels created by nodes whose
562                  * short address is not recorded in the packet. */
563                 case ZBEE_SEC_KEY_TRANSPORT:
564                 case ZBEE_SEC_KEY_LOAD:
565                 break;
566             }
567         }
568 #endif
569         offset += 8;
570     }
571     else {
572         /* Look for a source address in hints */
573         switch ( packet.key_id ) {
574             case ZBEE_SEC_KEY_NWK:
575                 /* use the ieee extended source address for NWK decryption */
576                 if ( ieee_hints && (map_rec = ieee_hints->map_rec) )
577                     packet.src64 = map_rec->addr64;
578                 else
579                     proto_tree_add_expert(sec_tree, pinfo, &ei_zbee_sec_extended_source_unknown, tvb, 0, 0);
580                 break;
581
582             default:
583                 /* use the nwk extended source address for APS decryption */
584                 if ( nwk_hints && (map_rec = nwk_hints->map_rec) )
585                     packet.src64 = map_rec->addr64;
586                 else
587                     proto_tree_add_expert(sec_tree, pinfo, &ei_zbee_sec_extended_source_unknown, tvb, 0, 0);
588                 break;
589         }
590     }
591
592     if (packet.key_id == ZBEE_SEC_KEY_NWK) {
593         /* Get and display the key sequence number. */
594         packet.key_seqno = tvb_get_guint8(tvb, offset);
595         proto_tree_add_uint(sec_tree, hf_zbee_sec_key_seqno, tvb, offset, 1, packet.key_seqno);
596         offset += 1;
597     }
598
599     /* Determine the length of the MIC. */
600     switch (packet.level) {
601         case ZBEE_SEC_ENC:
602         case ZBEE_SEC_NONE:
603         default:
604             mic_len=0;
605             break;
606
607         case ZBEE_SEC_ENC_MIC32:
608         case ZBEE_SEC_MIC32:
609             mic_len=4;
610             break;
611
612         case ZBEE_SEC_ENC_MIC64:
613         case ZBEE_SEC_MIC64:
614             mic_len=8;
615             break;
616
617         case ZBEE_SEC_ENC_MIC128:
618         case ZBEE_SEC_MIC128:
619             mic_len=16;
620             break;
621     } /* switch */
622
623     /* Get and display the MIC. */
624     if (mic_len) {
625         /* Display the MIC. */
626         proto_tree_add_item(sec_tree, hf_zbee_sec_mic, tvb, (gint)(tvb_captured_length(tvb)-mic_len),
627                 mic_len, ENC_NA);
628     }
629
630     /* Check for null payload. */
631     payload_len = tvb_reported_length_remaining(tvb, offset+mic_len);
632     if (payload_len == 0)
633         return NULL;
634
635     /**********************************************
636      *  Perform Security Operations on the Frame  *
637      **********************************************
638      */
639     if ((packet.level == ZBEE_SEC_NONE) ||
640         (packet.level == ZBEE_SEC_MIC32) ||
641         (packet.level == ZBEE_SEC_MIC64) ||
642         (packet.level == ZBEE_SEC_MIC128)) {
643
644         /* Payload is only integrity protected. Just return the sub-tvbuff. */
645         return tvb_new_subset_length(tvb, offset, payload_len);
646     }
647
648 #ifdef HAVE_LIBGCRYPT
649     /* Have we captured all the payload? */
650     if (tvb_captured_length_remaining(tvb, offset+mic_len) < payload_len) {
651         /*
652          * No - don't try to decrypt it.
653          *
654          * XXX - it looks as if the decryption code is assuming we have the
655          * MIC, which won't be the case if the packet was cut short.  Is
656          * that in fact that case, or can we still make this work with a
657          * partially-captured packet?
658          */
659         /* Add expert info. */
660         expert_add_info(pinfo, sec_tree, &ei_zbee_sec_encrypted_payload_sliced);
661         /* Create a buffer for the undecrypted payload. */
662         payload_tvb = tvb_new_subset_length(tvb, offset, payload_len);
663         /* Dump the payload to the data dissector. */
664         call_dissector(data_handle, payload_tvb, pinfo, tree);
665         /* Couldn't decrypt, so return NULL. */
666         return NULL;
667     }
668
669     /* Allocate memory to decrypt the payload into. */
670     dec_buffer = (guint8 *)g_malloc(payload_len);
671
672     decrypted = FALSE;
673     if ( packet.src64 ) {
674         if (pinfo->fd->flags.visited) {
675             if ( nwk_hints ) {
676                 /* Use previously found key */
677                 switch ( packet.key_id ) {
678                     case ZBEE_SEC_KEY_NWK:
679                         if ( (key_rec = nwk_hints->nwk) ) {
680                             decrypted = zbee_sec_decrypt_payload( &packet, enc_buffer, offset, dec_buffer,
681                                 payload_len, mic_len, nwk_hints->nwk->key);
682                         }
683                         break;
684
685                     default:
686                         if ( (key_rec = nwk_hints->link) ) {
687                             decrypted = zbee_sec_decrypt_payload( &packet, enc_buffer, offset, dec_buffer,
688                                 payload_len, mic_len, nwk_hints->link->key);
689                         }
690                         break;
691                 }
692             }
693         } /* ( !pinfo->fd->flags.visited ) */
694         else {
695             /* We only search for sniffed keys in the first pass,
696              * to save time, and because decrypting with keys
697              * transported in future packets is cheating */
698
699             /* Lookup NWK and link key in hash for this pan. */
700             /* This overkill approach is a placeholder for a hash that looks up
701              * a key ring for a link key associated with a pair of devices.
702              */
703             if ( nwk_hints ) {
704                 nwk_keyring = (GSList **)g_hash_table_lookup(zbee_table_nwk_keyring, &nwk_hints->src_pan);
705
706                 if ( nwk_keyring ) {
707                     GSList_i = *nwk_keyring;
708                     while ( GSList_i && !decrypted ) {
709                         decrypted = zbee_sec_decrypt_payload( &packet, enc_buffer, offset, dec_buffer,
710                                 payload_len, mic_len, ((key_record_t *)(GSList_i->data))->key);
711
712                         if (decrypted) {
713                             /* save pointer to the successful key record */
714                             switch (packet.key_id) {
715                                 case ZBEE_SEC_KEY_NWK:
716                                     key_rec = nwk_hints->nwk = (key_record_t *)(GSList_i->data);
717                                     break;
718
719                                 default:
720                                     key_rec = nwk_hints->link = (key_record_t *)(GSList_i->data);
721                                     break;
722                             }
723                         } else {
724                             GSList_i = g_slist_next(GSList_i);
725                         }
726                     }
727                 }
728
729                 /* Loop through user's password table for preconfigured keys, our last resort */
730                 GSList_i = zbee_pc_keyring;
731                 while ( GSList_i && !decrypted ) {
732                     decrypted = zbee_sec_decrypt_payload( &packet, enc_buffer, offset, dec_buffer,
733                             payload_len, mic_len, ((key_record_t *)(GSList_i->data))->key);
734
735                     if (decrypted) {
736                         /* save pointer to the successful key record */
737                         switch (packet.key_id) {
738                             case ZBEE_SEC_KEY_NWK:
739                                 key_rec = nwk_hints->nwk = (key_record_t *)(GSList_i->data);
740                                 break;
741
742                             default:
743                                 key_rec = nwk_hints->link = (key_record_t *)(GSList_i->data);
744                                 break;
745                         }
746                     } else {
747                         GSList_i = g_slist_next(GSList_i);
748                     }
749                 }
750             }
751         } /* ( ! pinfo->fd->flags.visited ) */
752     } /* ( packet.src64 ) */
753
754     if ( decrypted ) {
755         if ( tree && key_rec ) {
756             key_item = proto_tree_add_bytes(sec_tree, hf_zbee_sec_key, tvb, 0, ZBEE_SEC_CONST_KEYSIZE, key_rec->key);
757             PROTO_ITEM_SET_GENERATED(key_item);
758
759             if ( key_rec->frame_num == ZBEE_SEC_PC_KEY ) {
760                 ti = proto_tree_add_string(sec_tree, hf_zbee_sec_decryption_key, tvb, 0, 0, key_rec->label);
761             } else {
762                 ti = proto_tree_add_uint(sec_tree, hf_zbee_sec_key_origin, tvb, 0, 0,
763                         key_rec->frame_num);
764             }
765             PROTO_ITEM_SET_GENERATED(ti);
766         }
767
768         /* Found a key that worked, setup the new tvbuff_t and return */
769         payload_tvb = tvb_new_child_real_data(tvb, dec_buffer, payload_len, payload_len);
770         tvb_set_free_cb(payload_tvb, g_free); /* set up callback to free dec_buffer */
771         add_new_data_source(pinfo, payload_tvb, "Decrypted ZigBee Payload");
772
773         /* Done! */
774         return payload_tvb;
775     }
776
777     g_free(dec_buffer);
778 #endif /* HAVE_LIBGCRYPT */
779
780     /* Add expert info. */
781     expert_add_info(pinfo, sec_tree, &ei_zbee_sec_encrypted_payload);
782     /* Create a buffer for the undecrypted payload. */
783     payload_tvb = tvb_new_subset_length(tvb, offset, payload_len);
784     /* Dump the payload to the data dissector. */
785     call_dissector(data_handle, payload_tvb, pinfo, tree);
786     /* Couldn't decrypt, so return NULL. */
787     return NULL;
788 } /* dissect_zbee_secure */
789
790 #ifdef HAVE_LIBGCRYPT
791 /*FUNCTION:------------------------------------------------------
792  *  NAME
793  *      zbee_sec_decrypt_payload
794  *  DESCRIPTION
795  *      Creates a nonce and decrypts a secured payload.
796  *  PARAMETERS
797  *      gchar                *nonce  - Nonce Buffer.
798  *      zbee_security_packet *packet - Security information.
799  *  RETURNS
800  *      void
801  *---------------------------------------------------------------
802  */
803 static gboolean
804 zbee_sec_decrypt_payload(zbee_security_packet *packet, const gchar *enc_buffer, const gchar offset, guint8 *dec_buffer,
805         guint payload_len, guint mic_len, guint8 *key)
806 {
807     guint8  nonce[ZBEE_SEC_CONST_NONCE_LEN];
808     guint8  buffer[ZBEE_SEC_CONST_BLOCKSIZE+1];
809     guint8 *key_buffer = buffer;
810
811     switch (packet->key_id) {
812         case ZBEE_SEC_KEY_NWK:
813             /* Decrypt with the PAN's current network key */
814         case ZBEE_SEC_KEY_LINK:
815             /* Decrypt with the unhashed link key assigned by the trust center to this
816              * source/destination pair */
817             key_buffer = key;
818             break;
819
820         case ZBEE_SEC_KEY_TRANSPORT:
821             /* Decrypt with a Key-Transport key, a hashed link key that protects network
822              * keys sent from the trust center */
823             zbee_sec_key_hash(key, 0x00, buffer);
824             key_buffer = buffer;
825             break;
826
827         case ZBEE_SEC_KEY_LOAD:
828             /* Decrypt with a Key-Load key, a hashed link key that protects link keys
829              * sent from the trust center. */
830             zbee_sec_key_hash(key, 0x02, buffer);
831             key_buffer = buffer;
832             break;
833
834         default:
835             break;
836     } /* switch */
837
838     /* Perform Decryption. */
839     zbee_sec_make_nonce(packet, nonce);
840
841     if ( zbee_sec_ccm_decrypt(key_buffer,   /* key */
842                         nonce,              /* Nonce */
843                         enc_buffer,         /* a, length l(a) */
844                         enc_buffer+offset,  /* c, length l(c) = l(m) + M */
845                         dec_buffer,         /* m, length l(m) */
846                         offset,             /* l(a) */
847                         payload_len,        /* l(m) */
848                         mic_len) ) {        /* M */
849         return TRUE;
850     }
851     else return FALSE;
852 }
853
854 /*FUNCTION:------------------------------------------------------
855  *  NAME
856  *      zbee_sec_make_nonce
857  *  DESCRIPTION
858  *      Fills in the ZigBee security nonce from the provided security
859  *      packet structure.
860  *  PARAMETERS
861  *      zbee_security_packet *packet - Security information.
862  *      gchar           *nonce  - Nonce Buffer.
863  *  RETURNS
864  *      void
865  *---------------------------------------------------------------
866  */
867 static void
868 zbee_sec_make_nonce(zbee_security_packet *packet, guint8 *nonce)
869 {
870     /* First 8 bytes are the extended source address (little endian). */
871     *(nonce++) = (guint8)((packet->src64)>>0 & 0xff);
872     *(nonce++) = (guint8)((packet->src64)>>8 & 0xff);
873     *(nonce++) = (guint8)((packet->src64)>>16 & 0xff);
874     *(nonce++) = (guint8)((packet->src64)>>24 & 0xff);
875     *(nonce++) = (guint8)((packet->src64)>>32 & 0xff);
876     *(nonce++) = (guint8)((packet->src64)>>40 & 0xff);
877     *(nonce++) = (guint8)((packet->src64)>>48 & 0xff);
878     *(nonce++) = (guint8)((packet->src64)>>56 & 0xff);
879     /* Next 4 bytes are the frame counter (little endian). */
880     *(nonce++) = (guint8)((packet->counter)>>0 & 0xff);
881     *(nonce++) = (guint8)((packet->counter)>>8 & 0xff);
882     *(nonce++) = (guint8)((packet->counter)>>16 & 0xff);
883     *(nonce++) = (guint8)((packet->counter)>>24 & 0xff);
884     /* Next byte is the security control field. */
885     *(nonce) = packet->control;
886 } /* zbee_sec_make_nonce */
887 #endif
888
889 #ifdef HAVE_LIBGCRYPT
890 /*FUNCTION:------------------------------------------------------
891  *  NAME
892  *      zbee_sec_ccm_decrypt
893  *  DESCRIPTION
894  *      Performs the Reverse CCM* Transformation (specified in
895  *      section A.3 of ZigBee Specification (053474r17).
896  *
897  *      The length of parameter c (l(c)) is derived from the length
898  *      of the payload and length of the MIC tag. Input buffer a
899  *      will NOT be modified.
900  *
901  *      When l_m is 0, then there is no payload to encrypt (ie: the
902  *      payload is in plaintext), and this function will perform
903  *      MIC verification only. When l_m is 0, m may be NULL.
904  *  PARAMETERS
905  *      gchar   *key    - ZigBee Security Key (must be ZBEE_SEC_CONST_KEYSIZE) in length.
906  *      gchar   *nonce  - ZigBee CCM* Nonce (must be ZBEE_SEC_CONST_NONCE_LEN) in length.
907  *      gchar   *a      - CCM* Parameter a (must be l(a) in length). Additional data covered
908  *                          by the authentication process.
909  *      gchar   *c      - CCM* Parameter c (must be l(c) = l(m) + M in length). Encrypted
910  *                          payload + encrypted authentication tag U.
911  *      gchar   *m      - CCM* Output (must be l(m) in length). Decrypted Payload.
912  *      guint   l_a     - l(a), length of CCM* parameter a.
913  *      guint   l_m     - l(m), length of expected payload.
914  *      guint   M       - M, length of CCM* authentication tag.
915  *  RETURNS
916  *      gboolean        - TRUE if successful.
917  *---------------------------------------------------------------
918  */
919 gboolean
920 zbee_sec_ccm_decrypt(const gchar    *key,   /* Input */
921                     const gchar     *nonce, /* Input */
922                     const gchar     *a,     /* Input */
923                     const gchar     *c,     /* Input */
924                     gchar           *m,     /* Output */
925                     guint           l_a,    /* sizeof(a) */
926                     guint           l_m,    /* sizeof(m) */
927                     guint           M)      /* sizeof(c) - sizeof(m) = sizeof(MIC) */
928 {
929     guint8              cipher_in[ZBEE_SEC_CONST_BLOCKSIZE];
930     guint8              cipher_out[ZBEE_SEC_CONST_BLOCKSIZE];
931     guint8              decrypted_mic[ZBEE_SEC_CONST_BLOCKSIZE];
932     guint               i, j;
933     /* Cipher Instance. */
934     gcry_cipher_hd_t    cipher_hd;
935
936     /* Sanity-Check. */
937     if (M > ZBEE_SEC_CONST_BLOCKSIZE) return FALSE;
938     /*
939      * The CCM* counter is L bytes in length, ensure that the payload
940      * isn't long enough to overflow it.
941      */
942     if ((1 + (l_a/ZBEE_SEC_CONST_BLOCKSIZE)) > (1<<(ZBEE_SEC_CONST_L*8))) return FALSE;
943
944     /******************************************************
945      * Step 1: Encryption/Decryption Transformation
946      ******************************************************
947      */
948     /* Create the CCM* counter block A0 */
949     memset(cipher_in, 0, ZBEE_SEC_CONST_BLOCKSIZE);
950     cipher_in[0] = ZBEE_SEC_CCM_FLAG_L;
951     memcpy(cipher_in + 1, nonce, ZBEE_SEC_CONST_NONCE_LEN);
952     /*
953      * The encryption/decryption process of CCM* works in CTR mode. Open a CTR
954      * mode cipher for this phase. NOTE: The 'counter' part of the CCM* counter
955      * block is the last two bytes, and is big-endian.
956      */
957     if (gcry_cipher_open(&cipher_hd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_CTR, 0)) {
958         return FALSE;
959     }
960     /* Set the Key. */
961     if (gcry_cipher_setkey(cipher_hd, key, ZBEE_SEC_CONST_KEYSIZE)) {
962         gcry_cipher_close(cipher_hd);
963         return FALSE;
964     }
965     /* Set the counter. */
966     if (gcry_cipher_setctr(cipher_hd, cipher_in, ZBEE_SEC_CONST_BLOCKSIZE)) {
967         gcry_cipher_close(cipher_hd);
968         return FALSE;
969     }
970     /*
971      * Copy the MIC into the stack buffer. We need to feed the cipher a full
972      * block when decrypting the MIC (so that the payload starts on the second
973      * block). However, the MIC may be less than a full block so use a fixed
974      * size buffer to store the MIC, letting the CTR cipher overstep the MIC
975      * if need be.
976      */
977     memset(decrypted_mic, 0, ZBEE_SEC_CONST_BLOCKSIZE);
978     memcpy(decrypted_mic, c + l_m, M);
979     /* Encrypt/Decrypt the MIC in-place. */
980     if (gcry_cipher_encrypt(cipher_hd, decrypted_mic, ZBEE_SEC_CONST_BLOCKSIZE, decrypted_mic, ZBEE_SEC_CONST_BLOCKSIZE)) {
981         gcry_cipher_close(cipher_hd);
982         return FALSE;
983     }
984     /* Encrypt/Decrypt the payload. */
985     if (gcry_cipher_encrypt(cipher_hd, m, l_m, c, l_m)) {
986         gcry_cipher_close(cipher_hd);
987         return FALSE;
988     }
989     /* Done with the CTR Cipher. */
990     gcry_cipher_close(cipher_hd);
991
992     /******************************************************
993      * Step 3: Authentication Transformation
994      ******************************************************
995      */
996     if (M == 0) {
997         /* There is no authentication tag. We're done! */
998         return TRUE;
999     }
1000     /*
1001      * The authentication process in CCM* operates in CBC-MAC mode, but
1002      * unfortunately, the input to the CBC-MAC process needs some substantial
1003      * transformation and padding before we can feed it into the CBC-MAC
1004      * algorithm. Instead we will operate in ECB mode and perform the
1005      * transformation and padding on the fly.
1006      *
1007      * I also think that libgcrypt requires the input to be memory-aligned
1008      * when using CBC-MAC mode, in which case can't just feed it with data
1009      * from the packet buffer. All things considered it's just a lot easier
1010      * to use ECB mode and do CBC-MAC manually.
1011      */
1012     /* Re-open the cipher in ECB mode. */
1013     if (gcry_cipher_open(&cipher_hd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB, 0)) {
1014         return FALSE;
1015     }
1016     /* Re-load the key. */
1017     if (gcry_cipher_setkey(cipher_hd, key, ZBEE_SEC_CONST_KEYSIZE)) {
1018         gcry_cipher_close(cipher_hd);
1019         return FALSE;
1020     }
1021     /* Generate the first cipher block B0. */
1022     cipher_in[0] = ZBEE_SEC_CCM_FLAG_M(M) |
1023                     ZBEE_SEC_CCM_FLAG_ADATA(l_a) |
1024                     ZBEE_SEC_CCM_FLAG_L;
1025     memcpy(cipher_in+sizeof(gchar), nonce, ZBEE_SEC_CONST_NONCE_LEN);
1026     for (i=0;i<ZBEE_SEC_CONST_L; i++) {
1027         cipher_in[(ZBEE_SEC_CONST_BLOCKSIZE-1)-i] = (l_m >> (8*i)) & 0xff;
1028     } /* for */
1029     /* Generate the first cipher block, X1 = E(Key, 0^128 XOR B0). */
1030     if (gcry_cipher_encrypt(cipher_hd, cipher_out, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in, ZBEE_SEC_CONST_BLOCKSIZE)) {
1031         gcry_cipher_close(cipher_hd);
1032         return FALSE;
1033     }
1034     /*
1035      * We avoid mallocing() big chunks of memory by recycling small stack
1036      * buffers for the encryption process. Throughout this process, j is always
1037      * pointed to the position within the current buffer.
1038      */
1039     j = 0;
1040     /* AuthData = L(a) || a || Padding || m || Padding
1041      * Where L(a) =
1042      *      - an empty string if l(a) == 0.
1043      *      - 2-octet encoding of l(a) if 0 < l(a) < (2^16 - 2^8)
1044      *      - 0xff || 0xfe || 4-octet encoding of l(a) if (2^16 - 2^8) <= l(a) < 2^32
1045      *      - 0xff || 0xff || 8-octet encoding of l(a)
1046      * But for ZigBee, the largest packet size we should ever see is 2^7, so we
1047      * are only really concerned with the first two cases.
1048      *
1049      * To generate the MIC tag CCM* operates similar to CBC-MAC mode. Each block
1050      * of AuthData is XOR'd with the last block of cipher output to produce the
1051      * next block of cipher output. Padding sections have the minimum non-negative
1052      * length such that the padding ends on a block boundary. Padded bytes are 0.
1053      */
1054     if (l_a > 0) {
1055         /* Process L(a) into the cipher block. */
1056         cipher_in[j] = cipher_out[j] ^ ((l_a >> 8) & 0xff);
1057         j++;
1058         cipher_in[j] = cipher_out[j] ^ ((l_a >> 0) & 0xff);
1059         j++;
1060         /* Process a into the cipher block. */
1061         for (i=0;i<l_a;i++,j++) {
1062             if (j>=ZBEE_SEC_CONST_BLOCKSIZE) {
1063                 /* Generate the next cipher block. */
1064                 if (gcry_cipher_encrypt(cipher_hd, cipher_out, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in,
1065                             ZBEE_SEC_CONST_BLOCKSIZE)) {
1066                     gcry_cipher_close(cipher_hd);
1067                     return FALSE;
1068                 }
1069                 /* Reset j to point back to the start of the new cipher block. */
1070                 j = 0;
1071             }
1072             /* Cipher in = cipher_out ^ a */
1073             cipher_in[j] = cipher_out[j] ^ a[i];
1074         } /* for */
1075         /* Process padding into the cipher block. */
1076         for (;j<ZBEE_SEC_CONST_BLOCKSIZE;j++)
1077             cipher_in[j] = cipher_out[j];
1078     }
1079     /* Process m into the cipher block. */
1080     for (i=0; i<l_m; i++, j++) {
1081         if (j>=ZBEE_SEC_CONST_BLOCKSIZE) {
1082             /* Generate the next cipher block. */
1083             if (gcry_cipher_encrypt(cipher_hd, cipher_out, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in,
1084                        ZBEE_SEC_CONST_BLOCKSIZE)) {
1085                 gcry_cipher_close(cipher_hd);
1086                 return FALSE;
1087             }
1088             /* Reset j to point back to the start of the new cipher block. */
1089             j = 0;
1090         }
1091         /* Cipher in = cipher out ^ m */
1092         cipher_in[j] = cipher_out[j] ^ m[i];
1093     } /* for */
1094     /* Padding. */
1095     for (;j<ZBEE_SEC_CONST_BLOCKSIZE;j++)
1096         cipher_in[j] = cipher_out[j];
1097     /* Generate the last cipher block, which will be the MIC tag. */
1098     if (gcry_cipher_encrypt(cipher_hd, cipher_out, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in, ZBEE_SEC_CONST_BLOCKSIZE)) {
1099         gcry_cipher_close(cipher_hd);
1100         return FALSE;
1101     }
1102     /* Done with the Cipher. */
1103     gcry_cipher_close(cipher_hd);
1104
1105     /* Compare the MIC's */
1106     return (memcmp(cipher_out, decrypted_mic, M) == 0);
1107 } /* zbee_ccm_decrypt */
1108
1109 /*FUNCTION:------------------------------------------------------
1110  *  NAME
1111  *      zbee_sec_hash
1112  *  DESCRIPTION
1113  *      ZigBee Cryptographic Hash Function, described in ZigBee
1114  *      specification sections B.1.3 and B.6.
1115  *
1116  *      This is a Matyas-Meyer-Oseas hash function using the AES-128
1117  *      cipher. We use the ECB mode of libgcrypt to get a raw block
1118  *      cipher.
1119  *
1120  *      Input may be any length, and the output must be exactly 1-block in length.
1121  *
1122  *      Implements the function:
1123  *          Hash(text) = Hash[t];
1124  *          Hash[0] = 0^(blocksize).
1125  *          Hash[i] = E(Hash[i-1], M[i]) XOR M[j];
1126  *          M[i] = i'th block of text, with some padding and flags concatenated.
1127  *  PARAMETERS
1128  *      guint8 *    input       - Hash Input (any length).
1129  *      guint8      input_len   - Hash Input Length.
1130  *      guint8 *    output      - Hash Output (exactly one block in length).
1131  *  RETURNS
1132  *      void
1133  *---------------------------------------------------------------
1134  */
1135 static void
1136 zbee_sec_hash(guint8 *input, guint input_len, guint8 *output)
1137 {
1138     guint8              cipher_in[ZBEE_SEC_CONST_BLOCKSIZE];
1139     guint               i, j;
1140     /* Cipher Instance. */
1141     gcry_cipher_hd_t    cipher_hd;
1142
1143     /* Clear the first hash block (Hash0). */
1144     memset(output, 0, ZBEE_SEC_CONST_BLOCKSIZE);
1145     /* Create the cipher instance in ECB mode. */
1146     if (gcry_cipher_open(&cipher_hd, GCRY_CIPHER_AES128, GCRY_CIPHER_MODE_ECB, 0)) {
1147         return; /* Failed. */
1148     }
1149     /* Create the subsequent hash blocks using the formula: Hash[i] = E(Hash[i-1], M[i]) XOR M[i]
1150      *
1151      * because we can't garauntee that M will be exactly a multiple of the
1152      * block size, we will need to copy it into local buffers and pad it.
1153      *
1154      * Note that we check for the next cipher block at the end of the loop
1155      * rather than the start. This is so that if the input happens to end
1156      * on a block boundary, the next cipher block will be generated for the
1157      * start of the padding to be placed into.
1158      */
1159     i = 0;
1160     j = 0;
1161     while (i<input_len) {
1162         /* Copy data into the cipher input. */
1163         cipher_in[j++] = input[i++];
1164         /* Check if this cipher block is done. */
1165         if (j >= ZBEE_SEC_CONST_BLOCKSIZE) {
1166             /* We have reached the end of this block. Process it with the
1167              * cipher, note that the Key input to the cipher is actually
1168              * the previous hash block, which we are keeping in output.
1169              */
1170             (void)gcry_cipher_setkey(cipher_hd, output, ZBEE_SEC_CONST_BLOCKSIZE);
1171             (void)gcry_cipher_encrypt(cipher_hd, output, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in, ZBEE_SEC_CONST_BLOCKSIZE);
1172             /* Now we have to XOR the input into the hash block. */
1173             for (j=0;j<ZBEE_SEC_CONST_BLOCKSIZE;j++) output[j] ^= cipher_in[j];
1174             /* Reset j to start again at the beginning at the next block. */
1175             j = 0;
1176         }
1177     } /* for */
1178     /* Need to append the bit '1', followed by '0' padding long enough to end
1179      * the hash input on a block boundary. However, because 'n' is 16, and 'l'
1180      * will be a multiple of 8, the padding will be >= 7-bits, and we can just
1181      * append the byte 0x80.
1182      */
1183     cipher_in[j++] = 0x80;
1184     /* Pad with '0' until the the current block is exactly 'n' bits from the
1185      * end.
1186      */
1187     while (j!=(ZBEE_SEC_CONST_BLOCKSIZE-2)) {
1188         if (j >= ZBEE_SEC_CONST_BLOCKSIZE) {
1189             /* We have reached the end of this block. Process it with the
1190              * cipher, note that the Key input to the cipher is actually
1191              * the previous hash block, which we are keeping in output.
1192              */
1193             (void)gcry_cipher_setkey(cipher_hd, output, ZBEE_SEC_CONST_BLOCKSIZE);
1194             (void)gcry_cipher_encrypt(cipher_hd, output, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in, ZBEE_SEC_CONST_BLOCKSIZE);
1195             /* Now we have to XOR the input into the hash block. */
1196             for (j=0;j<ZBEE_SEC_CONST_BLOCKSIZE;j++) output[j] ^= cipher_in[j];
1197             /* Reset j to start again at the beginning at the next block. */
1198             j = 0;
1199         }
1200         /* Pad the input with 0. */
1201         cipher_in[j++] = 0x00;
1202     } /* while */
1203     /* Add the 'n'-bit representation of 'l' to the end of the block. */
1204     cipher_in[j++] = ((input_len * 8) >> 8) & 0xff;
1205     cipher_in[j] = ((input_len * 8) >> 0) & 0xff;
1206     /* Process the last cipher block. */
1207     (void)gcry_cipher_setkey(cipher_hd, output, ZBEE_SEC_CONST_BLOCKSIZE);
1208     (void)gcry_cipher_encrypt(cipher_hd, output, ZBEE_SEC_CONST_BLOCKSIZE, cipher_in, ZBEE_SEC_CONST_BLOCKSIZE);
1209     /* XOR the last input block back into the cipher output to get the hash. */
1210     for (j=0;j<ZBEE_SEC_CONST_BLOCKSIZE;j++) output[j] ^= cipher_in[j];
1211     /* Cleanup the cipher. */
1212     gcry_cipher_close(cipher_hd);
1213     /* Done */
1214 } /* zbee_sec_hash */
1215
1216 /*FUNCTION:------------------------------------------------------
1217  *  NAME
1218  *      zbee_sec_key_hash
1219  *  DESCRIPTION
1220  *      ZigBee Keyed Hash Function. Described in ZigBee specification
1221  *      section B.1.4, and in FIPS Publication 198. Strictly speaking
1222  *      there is nothing about the Keyed Hash Function which restricts
1223  *      it to only a single byte input, but that's all ZigBee ever uses.
1224  *
1225  *      This function implements the hash function:
1226  *          Hash(Key, text) = H((Key XOR opad) || H((Key XOR ipad) || text));
1227  *          ipad = 0x36 repeated.
1228  *          opad = 0x5c repeated.
1229  *          H() = ZigBee Cryptographic Hash (B.1.3 and B.6).
1230  *  PARAMETERS
1231  *      guint8  *key      - ZigBee Security Key (must be ZBEE_SEC_CONST_KEYSIZE) in length.
1232  *      guint8  input     - ZigBee CCM* Nonce (must be ZBEE_SEC_CONST_NONCE_LEN) in length.
1233  *      guint8  *hash_out - buffer into which the key-hashed output is placed
1234  *  RETURNS
1235  *      void
1236  *---------------------------------------------------------------
1237  */
1238 static void
1239 zbee_sec_key_hash(guint8 *key, guint8 input, guint8 *hash_out)
1240 {
1241     guint8              hash_in[2*ZBEE_SEC_CONST_BLOCKSIZE];
1242     int                 i;
1243     static const guint8 ipad = 0x36;
1244     static const guint8 opad = 0x5c;
1245
1246     /* Copy the key into hash_in and XOR with opad to form: (Key XOR opad) */
1247     for (i=0; i<ZBEE_SEC_CONST_KEYSIZE; i++) hash_in[i] = key[i] ^ opad;
1248     /* Copy the Key into hash_out and XOR with ipad to form: (Key XOR ipad) */
1249     for (i=0; i<ZBEE_SEC_CONST_KEYSIZE; i++) hash_out[i] = key[i] ^ ipad;
1250     /* Append the input byte to form: (Key XOR ipad) || text. */
1251     hash_out[ZBEE_SEC_CONST_BLOCKSIZE] = input;
1252     /* Hash the contents of hash_out and append the contents to hash_in to
1253      * form: (Key XOR opad) || H((Key XOR ipad) || text).
1254      */
1255     zbee_sec_hash(hash_out, ZBEE_SEC_CONST_BLOCKSIZE+1, hash_in+ZBEE_SEC_CONST_BLOCKSIZE);
1256     /* Hash the contents of hash_in to get the final result. */
1257     zbee_sec_hash(hash_in, 2*ZBEE_SEC_CONST_BLOCKSIZE, hash_out);
1258 } /* zbee_sec_key_hash */
1259 #else   /* HAVE_LIBGCRYPT */
1260 gboolean
1261 zbee_sec_ccm_decrypt(const gchar    *key _U_,   /* Input */
1262                     const gchar     *nonce _U_, /* Input */
1263                     const gchar     *a _U_,     /* Input */
1264                     const gchar     *c _U_,     /* Input */
1265                     gchar           *m _U_,     /* Output */
1266                     guint           l_a _U_,    /* sizeof(a) */
1267                     guint           l_m _U_,    /* sizeof(m) */
1268                     guint           M _U_)      /* sizeof(c) - sizeof(m) = sizeof(MIC) */
1269 {
1270     /* No libgcrypt, no decryption. */
1271     return FALSE;
1272 }
1273 #endif  /* HAVE_LIBGCRYPT */
1274
1275 /*
1276  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
1277  *
1278  * Local variables:
1279  * c-basic-offset: 4
1280  * tab-width: 8
1281  * indent-tabs-mode: nil
1282  * End:
1283  *
1284  * vi: set shiftwidth=4 tabstop=8 expandtab:
1285  * :indentSize=4:tabSize=8:noTabs=true:
1286  */