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