cc60176a2785343808e8895d2d8b498780e8fb83
[metze/wireshark/wip.git] / epan / crypt / airpdcap.c
1 /* airpdcap.c
2  *
3  * Copyright (c) 2006 CACE Technologies, Davis (California)
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. Neither the name of the project nor the names of its contributors
15  *    may be used to endorse or promote products derived from this software
16  *    without specific prior written permission.
17  *
18  * Alternatively, this software may be distributed under the terms of the
19  * GNU General Public License ("GPL") version 2 as published by the Free
20  * Software Foundation.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34
35 /*
36  * The files matching airpcap*.[ch] were originally developed as part of
37  * Wireshark's support for AirPcap adapters. However, they've been used
38  * for general 802.11 decryption for quite some time. It might make sense
39  * to rename them accordingly.
40  */
41
42 /****************************************************************************/
43 /*      File includes                                                       */
44
45 #include "config.h"
46
47 #include <glib.h>
48
49 #include <wsutil/crc32.h>
50 #include <wsutil/rc4.h>
51 #include <wsutil/sha1.h>
52 #include <wsutil/md5.h>
53 #include <wsutil/pint.h>
54
55 #include <epan/tvbuff.h>
56 #include <epan/to_str.h>
57 #include <epan/strutil.h>
58 #include <epan/crypt/airpdcap_rijndael.h>
59
60 #include "airpdcap_system.h"
61 #include "airpdcap_int.h"
62
63 #include "airpdcap_debug.h"
64
65 #include "wep-wpadefs.h"
66
67
68 /****************************************************************************/
69
70 /****************************************************************************/
71 /*      Constant definitions                                                    */
72
73 /*      EAPOL definitions                                                       */
74 /**
75  * Length of the EAPOL-Key key confirmation key (KCK) used to calculate
76  * MIC over EAPOL frame and validate an EAPOL packet (128 bits)
77  */
78 #define AIRPDCAP_WPA_KCK_LEN    16
79 /**
80  *Offset of the Key MIC in the EAPOL packet body
81  */
82 #define AIRPDCAP_WPA_MICKEY_OFFSET      77
83 /**
84  * Maximum length of the EAPOL packet (it depends on the maximum MAC
85  * frame size)
86  */
87 #define AIRPDCAP_WPA_MAX_EAPOL_LEN      4095
88 /**
89  * EAPOL Key Descriptor Version 1, used for all EAPOL-Key frames to and
90  * from a STA when neither the group nor pairwise ciphers are CCMP for
91  * Key Descriptor 1.
92  * @note
93  * Defined in 802.11i-2004, page 78
94  */
95 #define AIRPDCAP_WPA_KEY_VER_NOT_CCMP   1
96 /**
97  * EAPOL Key Descriptor Version 2, used for all EAPOL-Key frames to and
98  * from a STA when either the pairwise or the group cipher is AES-CCMP
99  * for Key Descriptor 2.
100  * /note
101  * Defined in 802.11i-2004, page 78
102  */
103 #define AIRPDCAP_WPA_KEY_VER_AES_CCMP   2
104
105 /** Define EAPOL Key Descriptor type values:  use 254 for WPA and 2 for WPA2 **/
106 #define AIRPDCAP_RSN_WPA_KEY_DESCRIPTOR 254
107 #define AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR 2
108
109 /****************************************************************************/
110
111
112
113 /****************************************************************************/
114 /*      Macro definitions                                                       */
115
116 extern const UINT32 crc32_table[256];
117 #define CRC(crc, ch)     (crc = (crc >> 8) ^ crc32_table[(crc ^ (ch)) & 0xff])
118
119 #define AIRPDCAP_GET_TK(ptk)    (ptk + 32)
120
121 /****************************************************************************/
122
123 /****************************************************************************/
124 /*      Type definitions                                                        */
125
126 /*      Internal function prototype declarations                                */
127
128 #ifdef  __cplusplus
129 extern "C" {
130 #endif
131
132 /**
133  * It is a step of the PBKDF2 (specifically the PKCS #5 v2.0) defined in
134  * the RFC 2898 to derive a key (used as PMK in WPA)
135  * @param ppbytes [IN] pointer to a password (sequence of between 8 and
136  * 63 ASCII encoded characters)
137  * @param ssid [IN] pointer to the SSID string encoded in max 32 ASCII
138  * encoded characters
139  * @param iterations [IN] times to hash the password (4096 for WPA)
140  * @param count [IN] ???
141  * @param output [OUT] pointer to a preallocated buffer of
142  * SHA1_DIGEST_LEN characters that will contain a part of the key
143  */
144 static INT AirPDcapRsnaPwd2PskStep(
145     const guint8 *ppbytes,
146     const guint passLength,
147     const CHAR *ssid,
148     const size_t ssidLength,
149     const INT iterations,
150     const INT count,
151     UCHAR *output)
152     ;
153
154 /**
155  * It calculates the passphrase-to-PSK mapping reccomanded for use with
156  * RSNAs. This implementation uses the PBKDF2 method defined in the RFC
157  * 2898.
158  * @param passphrase [IN] pointer to a password (sequence of between 8 and
159  * 63 ASCII encoded characters)
160  * @param ssid [IN] pointer to the SSID string encoded in max 32 ASCII
161  * encoded characters
162  * @param output [OUT] calculated PSK (to use as PMK in WPA)
163  * @note
164  * Described in 802.11i-2004, page 165
165  */
166 static INT AirPDcapRsnaPwd2Psk(
167     const CHAR *passphrase,
168     const CHAR *ssid,
169     const size_t ssidLength,
170     UCHAR *output)
171     ;
172
173 static INT AirPDcapRsnaMng(
174     UCHAR *decrypt_data,
175     guint mac_header_len,
176     guint *decrypt_len,
177     PAIRPDCAP_KEY_ITEM key,
178     AIRPDCAP_SEC_ASSOCIATION *sa,
179     INT offset)
180     ;
181
182 static INT AirPDcapWepMng(
183     PAIRPDCAP_CONTEXT ctx,
184     UCHAR *decrypt_data,
185     guint mac_header_len,
186     guint *decrypt_len,
187     PAIRPDCAP_KEY_ITEM key,
188     AIRPDCAP_SEC_ASSOCIATION *sa,
189     INT offset)
190     ;
191
192 static INT AirPDcapRsna4WHandshake(
193     PAIRPDCAP_CONTEXT ctx,
194     const UCHAR *data,
195     AIRPDCAP_SEC_ASSOCIATION *sa,
196     INT offset)
197     ;
198 /**
199  * It checks whether the specified key is corrected or not.
200  * @note
201  * For a standard WEP key the length will be changed to the standard
202  * length, and the type changed in a generic WEP key.
203  * @param key [IN] pointer to the key to validate
204  * @return
205  * - TRUE: the key contains valid fields and values
206  * - FALSE: the key has some invalid field or value
207  */
208 static INT AirPDcapValidateKey(
209     PAIRPDCAP_KEY_ITEM key)
210     ;
211
212 static INT AirPDcapRsnaMicCheck(
213     UCHAR *eapol,
214     USHORT eapol_len,
215     UCHAR KCK[AIRPDCAP_WPA_KCK_LEN],
216     USHORT key_ver)
217     ;
218
219 /**
220  * @param ctx [IN] pointer to the current context
221  * @param id [IN] id of the association (composed by BSSID and MAC of
222  * the station)
223  * @return
224  * - index of the Security Association structure if found
225  * - -1, if the specified addresses pair BSSID-STA MAC has not been found
226  */
227 static INT AirPDcapGetSa(
228     PAIRPDCAP_CONTEXT ctx,
229     AIRPDCAP_SEC_ASSOCIATION_ID *id)
230     ;
231
232 static INT AirPDcapStoreSa(
233     PAIRPDCAP_CONTEXT ctx,
234     AIRPDCAP_SEC_ASSOCIATION_ID *id)
235     ;
236
237 static const UCHAR * AirPDcapGetStaAddress(
238     const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
239     ;
240
241 static const UCHAR * AirPDcapGetBssidAddress(
242     const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
243     ;
244
245 static void AirPDcapRsnaPrfX(
246     AIRPDCAP_SEC_ASSOCIATION *sa,
247     const UCHAR pmk[32],
248     const UCHAR snonce[32],
249     const INT x,        /*      for TKIP 512, for CCMP 384      */
250     UCHAR *ptk)
251     ;
252
253 #ifdef  __cplusplus
254 }
255 #endif
256
257 /****************************************************************************/
258
259 /****************************************************************************/
260 /* Exported function definitions                                                */
261
262 #ifdef  __cplusplus
263 extern "C" {
264 #endif
265
266 const guint8 broadcast_mac[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
267
268
269 /* NOTE : this assumes the WPA RSN IE format.  If it were to be a generic RSN IE, then
270    we would need to change the structure since it could be variable length depending on the number
271    of unicast OUI and auth OUI. */
272 typedef struct {
273     guint8 bElementID;
274     guint8 bLength;
275     guint8  OUI[4];
276     guint16 iVersion;
277     guint8  multicastOUI[4];
278     guint16 iUnicastCount;      /* this should always be 1 for WPA client */
279     guint8  unicastOUI[4];
280     guint16 iAuthCount;         /* this should always be 1 for WPA client */
281     guint8  authOUI[4];
282     guint16 iWPAcap;
283 } RSN_IE;
284
285 #define EAPKEY_MIC_LEN  16  /* length of the MIC key for EAPoL_Key packet's MIC using MD5 */
286 #define NONCE_LEN 32
287
288 #define TKIP_GROUP_KEY_LEN 32
289 #define CCMP_GROUP_KEY_LEN 16
290 /* Minimum size of the key bytes payload for a TKIP group key in an M3 message*/
291 #define TKIP_GROUP_KEYBYTES_LEN ( sizeof(RSN_IE) + 8 + TKIP_GROUP_KEY_LEN + 6 ) /* 72 */
292 /* arbitrary upper limit */
293 #define TKIP_GROUP_KEYBYTES_LEN_MAX ( TKIP_GROUP_KEYBYTES_LEN + 28 )
294 /* Minimum size of the key bytes payload for a TKIP group key in a group key message */
295 #define TKIP_GROUP_KEYBYTES_LEN_GKEY (8 + 8 + TKIP_GROUP_KEY_LEN ) /* 48 */
296 /*  size of CCMP key bytes payload */
297 #define CCMP_GROUP_KEYBYTES_LEN ( sizeof(RSN_IE) + 8 + CCMP_GROUP_KEY_LEN + 6 ) /* 56 */
298 typedef struct {
299     guint8  type;
300     guint8  key_information[2];  /* Make this an array to avoid alignment issues */
301     guint8  key_length[2];  /* Make this an array to avoid alignment issues */
302     guint8  replay_counter[8];
303     guint8  key_nonce[NONCE_LEN];
304     guint8  key_iv[16];
305     guint8  key_sequence_counter[8];  /* also called the RSC */
306     guint8  key_id[8];
307     guint8  key_mic[EAPKEY_MIC_LEN];
308     guint8  key_data_len[2];  /* Make this an array rather than a U16 to avoid alignment shifting */
309     guint8  ie[TKIP_GROUP_KEYBYTES_LEN_MAX]; /* Make this an array to avoid alignment issues */
310 } EAPOL_RSN_KEY,  * P_EAPOL_RSN_KEY;
311 #define RSN_KEY_WITHOUT_KEYBYTES_LEN sizeof(EAPOL_RSN_KEY)-TKIP_GROUP_KEYBYTES_LEN_MAX
312 /* Minimum possible group key msg size (group key msg using CCMP as cipher)*/
313 #define GROUP_KEY_PAYLOAD_LEN_MIN RSN_KEY_WITHOUT_KEYBYTES_LEN+CCMP_GROUP_KEY_LEN
314
315 /* XXX - what if this doesn't get the key? */
316 static INT
317 AirPDcapDecryptWPABroadcastKey(const EAPOL_RSN_KEY *pEAPKey, guint8  *decryption_key, PAIRPDCAP_SEC_ASSOCIATION sa, gboolean group_hshake)
318 {
319     guint8 key_version;
320     guint8  *szEncryptedKey;
321     guint16 key_bytes_len = 0; /* Length of the total key data field */
322     guint16 key_len;           /* Actual group key length */
323     static AIRPDCAP_KEY_ITEM dummy_key; /* needed in case AirPDcapRsnaMng() wants the key structure */
324     AIRPDCAP_SEC_ASSOCIATION *tmp_sa;
325
326     /* We skip verifying the MIC of the key. If we were implementing a WPA supplicant we'd want to verify, but for a sniffer it's not needed. */
327
328     /* Preparation for decrypting the group key -  determine group key data length */
329     /* depending on whether the pairwise key is TKIP or AES encryption key */
330     key_version = AIRPDCAP_EAP_KEY_DESCR_VER(pEAPKey->key_information[1]);
331     if (key_version == AIRPDCAP_WPA_KEY_VER_NOT_CCMP){
332         /* TKIP */
333         key_bytes_len = pntoh16(pEAPKey->key_length);
334     }else if (key_version == AIRPDCAP_WPA_KEY_VER_AES_CCMP){
335         /* AES */
336         key_bytes_len = pntoh16(pEAPKey->key_data_len);
337
338         /* AES keys must be at least 128 bits = 16 bytes. */
339         if (key_bytes_len < 16) {
340             return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
341         }
342     }
343
344     if (key_bytes_len > TKIP_GROUP_KEYBYTES_LEN_MAX || key_bytes_len == 0) { /* Don't read past the end of pEAPKey->ie */
345         return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
346     }
347
348     /* Encrypted key is in the information element field of the EAPOL key packet */
349     szEncryptedKey = (guint8 *)g_memdup(pEAPKey->ie, key_bytes_len);
350
351     DEBUG_DUMP("Encrypted Broadcast key:", szEncryptedKey, key_bytes_len);
352     DEBUG_DUMP("KeyIV:", pEAPKey->key_iv, 16);
353     DEBUG_DUMP("decryption_key:", decryption_key, 16);
354
355     /* We are rekeying, save old sa */
356     tmp_sa=(AIRPDCAP_SEC_ASSOCIATION *)g_malloc(sizeof(AIRPDCAP_SEC_ASSOCIATION));
357     memcpy(tmp_sa, sa, sizeof(AIRPDCAP_SEC_ASSOCIATION));
358     sa->next=tmp_sa;
359
360     /* As we have no concept of the prior association request at this point, we need to deduce the     */
361     /* group key cipher from the length of the key bytes. In WPA this is straightforward as the        */
362     /* keybytes just contain the GTK, and the GTK is only in the group handshake, NOT the M3.          */
363     /* In WPA2 its a little more tricky as the M3 keybytes contain an RSN_IE, but the group handshake  */
364     /* does not. Also there are other (variable length) items in the keybytes which we need to account */
365     /* for to determine the true key length, and thus the group cipher.                                */
366
367     if (key_version == AIRPDCAP_WPA_KEY_VER_NOT_CCMP){
368         guint8 new_key[32];
369         guint8 dummy[256];
370         /* TKIP key */
371         /* Per 802.11i, Draft 3.0 spec, section 8.5.2, p. 97, line 4-8, */
372         /* group key is decrypted using RC4.  Concatenate the IV with the 16 byte EK (PTK+16) to get the decryption key */
373
374         rc4_state_struct rc4_state;
375
376         /* The WPA group key just contains the GTK bytes so deducing the type is straightforward   */
377         /* Note - WPA M3 doesn't contain a group key so we'll only be here for the group handshake */
378         sa->wpa.key_ver = (key_bytes_len >=TKIP_GROUP_KEY_LEN)?AIRPDCAP_WPA_KEY_VER_NOT_CCMP:AIRPDCAP_WPA_KEY_VER_AES_CCMP;
379
380         /* Build the full decryption key based on the IV and part of the pairwise key */
381         memcpy(new_key, pEAPKey->key_iv, 16);
382         memcpy(new_key+16, decryption_key, 16);
383         DEBUG_DUMP("FullDecrKey:", new_key, 32);
384
385         crypt_rc4_init(&rc4_state, new_key, sizeof(new_key));
386
387         /* Do dummy 256 iterations of the RC4 algorithm (per 802.11i, Draft 3.0, p. 97 line 6) */
388         crypt_rc4(&rc4_state, dummy, 256);
389         crypt_rc4(&rc4_state, szEncryptedKey, key_bytes_len);
390
391     } else if (key_version == AIRPDCAP_WPA_KEY_VER_AES_CCMP){
392         /* AES CCMP key */
393
394         guint8 key_found;
395         guint16 key_index;
396         guint8 *decrypted_data;
397
398         /* If this EAPOL frame is part of a separate group key handshake then this contains no    */
399         /* RSN IE, so we can deduct that from the calculation.                                    */
400         if (group_hshake)
401             sa->wpa.key_ver = (key_bytes_len >= (TKIP_GROUP_KEYBYTES_LEN_GKEY))?AIRPDCAP_WPA_KEY_VER_NOT_CCMP:AIRPDCAP_WPA_KEY_VER_AES_CCMP;
402         else
403             sa->wpa.key_ver = (key_bytes_len >= (TKIP_GROUP_KEYBYTES_LEN))?AIRPDCAP_WPA_KEY_VER_NOT_CCMP:AIRPDCAP_WPA_KEY_VER_AES_CCMP;
404
405         /* Unwrap the key; the result is key_bytes_len in length */
406         decrypted_data = AES_unwrap(decryption_key, 16, szEncryptedKey,  key_bytes_len);
407
408         /* With WPA2 what we get after Broadcast Key decryption is an actual RSN structure.
409            The key itself is stored as a GTK KDE
410            WPA2 IE (1 byte) id = 0xdd, length (1 byte), GTK OUI (4 bytes), key index (1 byte) and 1 reserved byte. Thus we have to
411            pass pointer to the actual key with 8 bytes offset */
412
413         key_found = FALSE;
414         key_index = 0;
415         while(key_index < key_bytes_len && !key_found){
416             guint8 rsn_id;
417
418             /* Get RSN ID */
419             rsn_id = decrypted_data[key_index];
420
421             if (rsn_id != 0xdd){
422                 if (key_index+1 >= key_bytes_len){
423                     return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
424                 }
425                 key_index += decrypted_data[key_index+1]+2;
426             }else{
427                 key_found = TRUE;
428             }
429         }
430
431         if (key_found){
432             if (key_index+8 >= key_bytes_len)
433                 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
434
435             /* Skip over the GTK header info, and don't copy past the end of the encrypted data */
436             memcpy(szEncryptedKey, decrypted_data+key_index+8, key_bytes_len-key_index-8);
437         }
438
439         g_free(decrypted_data);
440     }
441
442     key_len = (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP)?TKIP_GROUP_KEY_LEN:CCMP_GROUP_KEY_LEN;
443
444     /* Decrypted key is now in szEncryptedKey with len of key_len */
445     DEBUG_DUMP("Broadcast key:", szEncryptedKey, key_len);
446
447     /* Load the proper key material info into the SA */
448     sa->key = &dummy_key;  /* we just need key to be not null because it is checked in AirPDcapRsnaMng().  The WPA key materials are actually in the .wpa structure */
449     sa->validKey = TRUE;
450
451     /* Since this is a GTK and its size is only 32 bytes (vs. the 64 byte size of a PTK), we fake it and put it in at a 32-byte offset so the  */
452     /* AirPDcapRsnaMng() function will extract the right piece of the GTK for decryption. (The first 16 bytes of the GTK are used for decryption.) */
453     memset(sa->wpa.ptk, 0, sizeof(sa->wpa.ptk));
454     memcpy(sa->wpa.ptk+32, szEncryptedKey, key_len);
455     g_free(szEncryptedKey);
456     return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
457 }
458
459
460 /* Return a pointer the the requested SA. If it doesn't exist create it. */
461 static PAIRPDCAP_SEC_ASSOCIATION
462 AirPDcapGetSaPtr(
463     PAIRPDCAP_CONTEXT ctx,
464     AIRPDCAP_SEC_ASSOCIATION_ID *id)
465 {
466     int sa_index;
467
468     /* search for a cached Security Association for supplied BSSID and STA MAC  */
469     if ((sa_index=AirPDcapGetSa(ctx, id))==-1) {
470         /* create a new Security Association if it doesn't currently exist      */
471         if ((sa_index=AirPDcapStoreSa(ctx, id))==-1) {
472             return NULL;
473         }
474     }
475     /* get the Security Association structure   */
476     return &ctx->sa[sa_index];
477 }
478
479 static INT AirPDcapScanForKeys(
480     PAIRPDCAP_CONTEXT ctx,
481     const guint8 *data,
482     const guint mac_header_len,
483     const guint tot_len,
484     AIRPDCAP_SEC_ASSOCIATION_ID id
485 )
486 {
487     const UCHAR *addr;
488     guint bodyLength;
489     PAIRPDCAP_SEC_ASSOCIATION sta_sa;
490     PAIRPDCAP_SEC_ASSOCIATION sa;
491     int offset = 0;
492     const guint8 dot1x_header[] = {
493         0xAA,             /* DSAP=SNAP */
494         0xAA,             /* SSAP=SNAP */
495         0x03,             /* Control field=Unnumbered frame */
496         0x00, 0x00, 0x00, /* Org. code=encaps. Ethernet */
497         0x88, 0x8E        /* Type: 802.1X authentication */
498     };
499     const guint8 bt_dot1x_header[] = {
500         0xAA,             /* DSAP=SNAP */
501         0xAA,             /* SSAP=SNAP */
502         0x03,             /* Control field=Unnumbered frame */
503         0x00, 0x19, 0x58, /* Org. code=Bluetooth SIG */
504         0x00, 0x03        /* Type: Bluetooth Security */
505     };
506
507     const EAPOL_RSN_KEY *pEAPKey;
508 #ifdef _DEBUG
509 #define MSGBUF_LEN 255
510     CHAR msgbuf[MSGBUF_LEN];
511 #endif
512     AIRPDCAP_DEBUG_TRACE_START("AirPDcapScanForKeys");
513
514     /* cache offset in the packet data */
515     offset = mac_header_len;
516
517     /* check if the packet has an LLC header and the packet is 802.1X authentication (IEEE 802.1X-2004, pg. 24) */
518     if (memcmp(data+offset, dot1x_header, 8) == 0 || memcmp(data+offset, bt_dot1x_header, 8) == 0) {
519
520         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "Authentication: EAPOL packet", AIRPDCAP_DEBUG_LEVEL_3);
521
522         /* skip LLC header */
523         offset+=8;
524
525         /* check if the packet is a EAPOL-Key (0x03) (IEEE 802.1X-2004, pg. 25) */
526         if (data[offset+1]!=3) {
527             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "Not EAPOL-Key", AIRPDCAP_DEBUG_LEVEL_3);
528             return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
529         }
530
531         /* get and check the body length (IEEE 802.1X-2004, pg. 25) */
532         bodyLength=pntoh16(data+offset+2);
533         if ((tot_len-offset-4) < bodyLength) { /* Only check if frame is long enough for eapol header, ignore tailing garbage, see bug 9065 */
534             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "EAPOL body too short", AIRPDCAP_DEBUG_LEVEL_3);
535             return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
536         }
537
538         /* skip EAPOL MPDU and go to the first byte of the body */
539         offset+=4;
540
541         pEAPKey = (const EAPOL_RSN_KEY *) (data+offset);
542
543         /* check if the key descriptor type is valid (IEEE 802.1X-2004, pg. 27) */
544         if (/*pEAPKey->type!=0x1 &&*/ /* RC4 Key Descriptor Type (deprecated) */
545             pEAPKey->type != AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR &&             /* IEEE 802.11 Key Descriptor Type  (WPA2) */
546             pEAPKey->type != AIRPDCAP_RSN_WPA_KEY_DESCRIPTOR)           /* 254 = RSN_KEY_DESCRIPTOR - WPA,              */
547         {
548             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "Not valid key descriptor type", AIRPDCAP_DEBUG_LEVEL_3);
549             return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
550         }
551
552         /* start with descriptor body */
553         offset+=1;
554
555         /* search for a cached Security Association for current BSSID and AP */
556         sa = AirPDcapGetSaPtr(ctx, &id);
557         if (sa == NULL){
558             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "No SA for BSSID found", AIRPDCAP_DEBUG_LEVEL_3);
559             return AIRPDCAP_RET_REQ_DATA;
560         }
561
562         /* It could be a Pairwise Key exchange, check */
563         if (AirPDcapRsna4WHandshake(ctx, data, sa, offset) == AIRPDCAP_RET_SUCCESS_HANDSHAKE)
564             return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
565
566         if (mac_header_len + GROUP_KEY_PAYLOAD_LEN_MIN > tot_len) {
567             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "Message too short for Group Key", AIRPDCAP_DEBUG_LEVEL_3);
568             return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
569         }
570
571         /* Verify the bitfields: Key = 0(groupwise) Mic = 1 Ack = 1 Secure = 1 */
572         if (AIRPDCAP_EAP_KEY(data[offset+1])!=0 ||
573             AIRPDCAP_EAP_ACK(data[offset+1])!=1 ||
574             AIRPDCAP_EAP_MIC(data[offset]) != 1 ||
575             AIRPDCAP_EAP_SEC(data[offset]) != 1){
576
577             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "Key bitfields not correct for Group Key", AIRPDCAP_DEBUG_LEVEL_3);
578             return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
579         }
580
581         /* force STA address to be the broadcast MAC so we create an SA for the groupkey */
582         memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
583
584         /* get the Security Association structure for the broadcast MAC and AP */
585         sa = AirPDcapGetSaPtr(ctx, &id);
586         if (sa == NULL){
587             return AIRPDCAP_RET_REQ_DATA;
588         }
589
590         /* Get the SA for the STA, since we need its pairwise key to decrpyt the group key */
591
592         /* get STA address */
593         if ( (addr=AirPDcapGetStaAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
594             memcpy(id.sta, addr, AIRPDCAP_MAC_LEN);
595 #ifdef _DEBUG
596             g_snprintf(msgbuf, MSGBUF_LEN, "ST_MAC: %2X.%2X.%2X.%2X.%2X.%2X\t", id.sta[0],id.sta[1],id.sta[2],id.sta[3],id.sta[4],id.sta[5]);
597 #endif
598             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
599         } else {
600             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "SA not found", AIRPDCAP_DEBUG_LEVEL_5);
601             return AIRPDCAP_RET_REQ_DATA;
602         }
603
604         sta_sa = AirPDcapGetSaPtr(ctx, &id);
605         if (sta_sa == NULL){
606             return AIRPDCAP_RET_REQ_DATA;
607         }
608
609         /* Try to extract the group key and install it in the SA */
610         return (AirPDcapDecryptWPABroadcastKey(pEAPKey, sta_sa->wpa.ptk+16, sa, TRUE));
611
612     }else{
613         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForKeys", "Skipping: not an EAPOL packet", AIRPDCAP_DEBUG_LEVEL_3);
614     }
615
616     AIRPDCAP_DEBUG_TRACE_END("AirPDcapScanForKeys");
617     return AIRPDCAP_RET_NO_VALID_HANDSHAKE;;
618 }
619
620
621 INT AirPDcapPacketProcess(
622     PAIRPDCAP_CONTEXT ctx,
623     const guint8 *data,
624     const guint mac_header_len,
625     const guint tot_len,
626     UCHAR *decrypt_data,
627     guint *decrypt_len,
628     PAIRPDCAP_KEY_ITEM key,
629     gboolean scanHandshake)
630 {
631     const UCHAR *addr;
632     AIRPDCAP_SEC_ASSOCIATION_ID id;
633     UCHAR tmp_data[AIRPDCAP_MAX_CAPLEN];
634     guint tmp_len;
635
636 #ifdef _DEBUG
637 #define MSGBUF_LEN 255
638     CHAR msgbuf[MSGBUF_LEN];
639 #endif
640
641     AIRPDCAP_DEBUG_TRACE_START("AirPDcapPacketProcess");
642
643     if (ctx==NULL) {
644         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
645         AIRPDCAP_DEBUG_TRACE_END("AirPDcapPacketProcess");
646         return AIRPDCAP_RET_REQ_DATA;
647     }
648     if (data==NULL || tot_len==0) {
649         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "NULL data or length=0", AIRPDCAP_DEBUG_LEVEL_5);
650         AIRPDCAP_DEBUG_TRACE_END("AirPDcapPacketProcess");
651         return AIRPDCAP_RET_REQ_DATA;
652     }
653
654     /* check if the packet is of data type */
655     if (AIRPDCAP_TYPE(data[0])!=AIRPDCAP_TYPE_DATA) {
656         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "not data packet", AIRPDCAP_DEBUG_LEVEL_5);
657         return AIRPDCAP_RET_NO_DATA;
658     }
659
660     /* check correct packet size, to avoid wrong elaboration of encryption algorithms */
661     if (tot_len < (UINT)(mac_header_len+AIRPDCAP_CRYPTED_DATA_MINLEN)) {
662         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "minimum length violated", AIRPDCAP_DEBUG_LEVEL_5);
663         return AIRPDCAP_RET_WRONG_DATA_SIZE;
664     }
665
666     /* get BSSID */
667     if ( (addr=AirPDcapGetBssidAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
668         memcpy(id.bssid, addr, AIRPDCAP_MAC_LEN);
669         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
670     } else {
671         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "BSSID not found", AIRPDCAP_DEBUG_LEVEL_5);
672         return AIRPDCAP_RET_REQ_DATA;
673     }
674
675     /* get STA address */
676     if ( (addr=AirPDcapGetStaAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
677         memcpy(id.sta, addr, AIRPDCAP_MAC_LEN);
678         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
679     } else {
680         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "SA not found", AIRPDCAP_DEBUG_LEVEL_5);
681         return AIRPDCAP_RET_REQ_DATA;
682     }
683
684     /* check if data is encrypted (use the WEP bit in the Frame Control field) */
685     if (AIRPDCAP_WEP(data[1])==0) {
686         if (scanHandshake) {
687             /* data is sent in cleartext, check if is an authentication message or end the process */
688             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Unencrypted data", AIRPDCAP_DEBUG_LEVEL_3);
689             return (AirPDcapScanForKeys(ctx, data, mac_header_len, tot_len, id));
690         }
691         return AIRPDCAP_RET_NO_DATA_ENCRYPTED;
692     } else {
693         PAIRPDCAP_SEC_ASSOCIATION sa;
694         int offset = 0;
695
696         /* get the Security Association structure for the STA and AP */
697         sa = AirPDcapGetSaPtr(ctx, &id);
698         if (sa == NULL){
699             return AIRPDCAP_RET_REQ_DATA;
700         }
701
702         /* cache offset in the packet data (to scan encryption data) */
703         offset = mac_header_len;
704
705         if (decrypt_data==NULL) {
706             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "no decrypt buffer, use local", AIRPDCAP_DEBUG_LEVEL_3);
707             decrypt_data=tmp_data;
708             decrypt_len=&tmp_len;
709         }
710
711         /* create new header and data to modify */
712         *decrypt_len = tot_len;
713         memcpy(decrypt_data, data, *decrypt_len);
714
715         /* encrypted data */
716         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Encrypted data", AIRPDCAP_DEBUG_LEVEL_3);
717
718         /* check the Extension IV to distinguish between WEP encryption and WPA encryption */
719         /* refer to IEEE 802.11i-2004, 8.2.1.2, pag.35 for WEP,    */
720         /*          IEEE 802.11i-2004, 8.3.2.2, pag. 45 for TKIP,  */
721         /*          IEEE 802.11i-2004, 8.3.3.2, pag. 57 for CCMP   */
722         if (AIRPDCAP_EXTIV(data[offset+3])==0) {
723             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "WEP encryption", AIRPDCAP_DEBUG_LEVEL_3);
724             return AirPDcapWepMng(ctx, decrypt_data, mac_header_len, decrypt_len, key, sa, offset);
725         } else {
726             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "TKIP or CCMP encryption", AIRPDCAP_DEBUG_LEVEL_3);
727
728             /* If index >= 1, then use the group key.  This will not work if the AP is using
729                more than one group key simultaneously.  I've not seen this in practice, however.
730                Usually an AP will rotate between the two key index values of 1 and 2 whenever
731                it needs to change the group key to be used. */
732             if (AIRPDCAP_KEY_INDEX(data[offset+3])>=1){
733
734                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "The key index >= 1. This is encrypted with a group key.", AIRPDCAP_DEBUG_LEVEL_3);
735
736                 /* force STA address to broadcast MAC so we load the SA for the groupkey */
737                 memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
738
739 #ifdef _DEBUG
740                 g_snprintf(msgbuf, MSGBUF_LEN, "ST_MAC: %2X.%2X.%2X.%2X.%2X.%2X\t", id.sta[0],id.sta[1],id.sta[2],id.sta[3],id.sta[4],id.sta[5]);
741                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
742 #endif
743
744                 /* search for a cached Security Association for current BSSID and broadcast MAC */
745                 sa = AirPDcapGetSaPtr(ctx, &id);
746                 if (sa == NULL)
747                     return AIRPDCAP_RET_REQ_DATA;
748             }
749
750             /* Decrypt the packet using the appropriate SA */
751             if (AirPDcapRsnaMng(decrypt_data, mac_header_len, decrypt_len, key, sa, offset) == AIRPDCAP_RET_SUCCESS) {
752                 /* If we successfully decrypted a packet, scan it to see if it contains a key handshake.
753                    The group key handshake could be sent at any time the AP wants to change the key (such as when
754                    it is using key rotation) and it also could be a rekey for the Pairwise key. So we must scan every packet. */
755                 if (scanHandshake) {
756                     return (AirPDcapScanForKeys(ctx, decrypt_data, mac_header_len, *decrypt_len, id));
757                 } else {
758                     return AIRPDCAP_RET_SUCCESS;
759                 }
760             }
761         }
762     }
763     return AIRPDCAP_RET_UNSUCCESS;
764 }
765
766 INT AirPDcapSetKeys(
767     PAIRPDCAP_CONTEXT ctx,
768     AIRPDCAP_KEY_ITEM keys[],
769     const size_t keys_nr)
770 {
771     INT i;
772     INT success;
773     AIRPDCAP_DEBUG_TRACE_START("AirPDcapSetKeys");
774
775     if (ctx==NULL || keys==NULL) {
776         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "NULL context or NULL keys array", AIRPDCAP_DEBUG_LEVEL_3);
777         AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
778         return 0;
779     }
780
781     if (keys_nr>AIRPDCAP_MAX_KEYS_NR) {
782         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Keys number greater than maximum", AIRPDCAP_DEBUG_LEVEL_3);
783         AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
784         return 0;
785     }
786
787     /* clean key and SA collections before setting new ones */
788     AirPDcapInitContext(ctx);
789
790     /* check and insert keys */
791     for (i=0, success=0; i<(INT)keys_nr; i++) {
792         if (AirPDcapValidateKey(keys+i)==TRUE) {
793             if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD) {
794                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WPA-PWD key", AIRPDCAP_DEBUG_LEVEL_4);
795                 AirPDcapRsnaPwd2Psk(keys[i].UserPwd.Passphrase, keys[i].UserPwd.Ssid, keys[i].UserPwd.SsidLen, keys[i].KeyData.Wpa.Psk);
796             }
797 #ifdef _DEBUG
798             else if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK) {
799                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WPA-PMK key", AIRPDCAP_DEBUG_LEVEL_4);
800             } else if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WEP) {
801                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WEP key", AIRPDCAP_DEBUG_LEVEL_4);
802             } else {
803                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a key", AIRPDCAP_DEBUG_LEVEL_4);
804             }
805 #endif
806             memcpy(&ctx->keys[success], &keys[i], sizeof(keys[i]));
807             success++;
808         }
809     }
810
811     ctx->keys_nr=success;
812
813     AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
814     return success;
815 }
816
817 static void
818 AirPDcapCleanKeys(
819     PAIRPDCAP_CONTEXT ctx)
820 {
821     AIRPDCAP_DEBUG_TRACE_START("AirPDcapCleanKeys");
822
823     if (ctx==NULL) {
824         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapCleanKeys", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
825         AIRPDCAP_DEBUG_TRACE_END("AirPDcapCleanKeys");
826         return;
827     }
828
829     memset(ctx->keys, 0, sizeof(AIRPDCAP_KEY_ITEM) * AIRPDCAP_MAX_KEYS_NR);
830
831     ctx->keys_nr=0;
832
833     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapCleanKeys", "Keys collection cleaned!", AIRPDCAP_DEBUG_LEVEL_5);
834     AIRPDCAP_DEBUG_TRACE_END("AirPDcapCleanKeys");
835 }
836
837 static void
838 AirPDcapRecurseCleanSA(
839     PAIRPDCAP_SEC_ASSOCIATION sa)
840 {
841     if (sa->next != NULL) {
842         AirPDcapRecurseCleanSA(sa->next);
843         g_free(sa->next);
844         sa->next = NULL;
845     }
846 }
847
848 static void
849 AirPDcapCleanSecAssoc(
850     PAIRPDCAP_CONTEXT ctx)
851 {
852     PAIRPDCAP_SEC_ASSOCIATION psa;
853     int i;
854
855     for (psa = ctx->sa, i = 0; i < AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR; i++, psa++) {
856         /* To iterate is human, to recurse, divine */
857         AirPDcapRecurseCleanSA(psa);
858     }
859 }
860
861 INT AirPDcapGetKeys(
862     const PAIRPDCAP_CONTEXT ctx,
863     AIRPDCAP_KEY_ITEM keys[],
864     const size_t keys_nr)
865 {
866     UINT i;
867     UINT j;
868     AIRPDCAP_DEBUG_TRACE_START("AirPDcapGetKeys");
869
870     if (ctx==NULL) {
871         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
872         AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
873         return 0;
874     } else if (keys==NULL) {
875         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "NULL keys array", AIRPDCAP_DEBUG_LEVEL_5);
876         AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
877         return (INT)ctx->keys_nr;
878     } else {
879         for (i=0, j=0; i<ctx->keys_nr && i<keys_nr && i<AIRPDCAP_MAX_KEYS_NR; i++) {
880             memcpy(&keys[j], &ctx->keys[i], sizeof(keys[j]));
881             j++;
882             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "Got a key", AIRPDCAP_DEBUG_LEVEL_5);
883         }
884
885         AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
886         return j;
887     }
888 }
889
890 /*
891  * XXX - This won't be reliable if a packet containing SSID "B" shows
892  * up in the middle of a 4-way handshake for SSID "A".
893  * We should probably use a small array or hash table to keep multiple
894  * SSIDs.
895  */
896 INT AirPDcapSetLastSSID(
897     PAIRPDCAP_CONTEXT ctx,
898     CHAR *pkt_ssid,
899     size_t pkt_ssid_len)
900 {
901     if (!ctx || !pkt_ssid || pkt_ssid_len < 1 || pkt_ssid_len > WPA_SSID_MAX_SIZE)
902         return AIRPDCAP_RET_UNSUCCESS;
903
904     memcpy(ctx->pkt_ssid, pkt_ssid, pkt_ssid_len);
905     ctx->pkt_ssid_len = pkt_ssid_len;
906
907     return AIRPDCAP_RET_SUCCESS;
908 }
909
910 INT AirPDcapInitContext(
911     PAIRPDCAP_CONTEXT ctx)
912 {
913     AIRPDCAP_DEBUG_TRACE_START("AirPDcapInitContext");
914
915     if (ctx==NULL) {
916         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapInitContext", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
917         AIRPDCAP_DEBUG_TRACE_END("AirPDcapInitContext");
918         return AIRPDCAP_RET_UNSUCCESS;
919     }
920
921     AirPDcapCleanKeys(ctx);
922
923     ctx->first_free_index=0;
924     ctx->index=-1;
925     ctx->sa_index=-1;
926     ctx->pkt_ssid_len = 0;
927
928     memset(ctx->sa, 0, AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR * sizeof(AIRPDCAP_SEC_ASSOCIATION));
929
930     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapInitContext", "Context initialized!", AIRPDCAP_DEBUG_LEVEL_5);
931     AIRPDCAP_DEBUG_TRACE_END("AirPDcapInitContext");
932     return AIRPDCAP_RET_SUCCESS;
933 }
934
935 INT AirPDcapDestroyContext(
936     PAIRPDCAP_CONTEXT ctx)
937 {
938     AIRPDCAP_DEBUG_TRACE_START("AirPDcapDestroyContext");
939
940     if (ctx==NULL) {
941         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapDestroyContext", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
942         AIRPDCAP_DEBUG_TRACE_END("AirPDcapDestroyContext");
943         return AIRPDCAP_RET_UNSUCCESS;
944     }
945
946     AirPDcapCleanKeys(ctx);
947     AirPDcapCleanSecAssoc(ctx);
948
949     ctx->first_free_index=0;
950     ctx->index=-1;
951     ctx->sa_index=-1;
952
953     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapDestroyContext", "Context destroyed!", AIRPDCAP_DEBUG_LEVEL_5);
954     AIRPDCAP_DEBUG_TRACE_END("AirPDcapDestroyContext");
955     return AIRPDCAP_RET_SUCCESS;
956 }
957
958 #ifdef __cplusplus
959 }
960 #endif
961
962 /****************************************************************************/
963
964 /****************************************************************************/
965 /* Internal function definitions                                         */
966
967 #ifdef __cplusplus
968 extern "C" {
969 #endif
970
971 static INT
972 AirPDcapRsnaMng(
973     UCHAR *decrypt_data,
974     guint mac_header_len,
975     guint *decrypt_len,
976     PAIRPDCAP_KEY_ITEM key,
977     AIRPDCAP_SEC_ASSOCIATION *sa,
978     INT offset)
979 {
980     INT ret_value=1;
981     UCHAR *try_data;
982     guint try_data_len = *decrypt_len;
983
984     if (sa->key==NULL) {
985         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "No key associated", AIRPDCAP_DEBUG_LEVEL_3);
986         return AIRPDCAP_RET_REQ_DATA;
987     }
988
989     if (*decrypt_len > try_data_len) {
990         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Invalid decryption length", AIRPDCAP_DEBUG_LEVEL_3);
991         return AIRPDCAP_RET_UNSUCCESS;
992     }
993
994     /* allocate a temp buffer for the decryption loop */
995     try_data=(UCHAR *)g_malloc(try_data_len);
996
997     /* start of loop added by GCS */
998     for(/* sa */; sa != NULL ;sa=sa->next) {
999
1000        if (sa->validKey==FALSE) {
1001            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Key not yet valid", AIRPDCAP_DEBUG_LEVEL_3);
1002            continue;
1003        }
1004
1005        /* copy the encrypted data into a temp buffer */
1006        memcpy(try_data, decrypt_data, *decrypt_len);
1007
1008        if (sa->wpa.key_ver==1) {
1009            /* CCMP -> HMAC-MD5 is the EAPOL-Key MIC, RC4 is the EAPOL-Key encryption algorithm */
1010            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP", AIRPDCAP_DEBUG_LEVEL_3);
1011            DEBUG_DUMP("ptk", sa->wpa.ptk, 64);
1012            DEBUG_DUMP("ptk portion used", AIRPDCAP_GET_TK(sa->wpa.ptk), 16);
1013
1014            ret_value=AirPDcapTkipDecrypt(try_data+offset, *decrypt_len-offset, try_data+AIRPDCAP_TA_OFFSET, AIRPDCAP_GET_TK(sa->wpa.ptk));
1015            if (ret_value){
1016                AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP failed!", AIRPDCAP_DEBUG_LEVEL_3);
1017                continue;
1018            }
1019
1020            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1021            /* remove MIC (8bytes) and ICV (4bytes) from the end of packet */
1022            *decrypt_len-=12;
1023            break;
1024        } else {
1025            /* AES-CCMP -> HMAC-SHA1-128 is the EAPOL-Key MIC, AES wep_key wrap is the EAPOL-Key encryption algorithm */
1026            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "CCMP", AIRPDCAP_DEBUG_LEVEL_3);
1027
1028            ret_value=AirPDcapCcmpDecrypt(try_data, mac_header_len, (INT)*decrypt_len, AIRPDCAP_GET_TK(sa->wpa.ptk));
1029            if (ret_value)
1030               continue;
1031
1032            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "CCMP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1033            /* remove MIC (8bytes) from the end of packet */
1034            *decrypt_len-=8;
1035            break;
1036        }
1037     }
1038     /* end of loop */
1039
1040     /* none of the keys worked */
1041     if(sa == NULL) {
1042         g_free(try_data);
1043         return ret_value;
1044     }
1045
1046     if (*decrypt_len > try_data_len || *decrypt_len < 8) {
1047         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Invalid decryption length", AIRPDCAP_DEBUG_LEVEL_3);
1048         g_free(try_data);
1049         return AIRPDCAP_RET_UNSUCCESS;
1050     }
1051
1052     /* copy the decrypted data into the decrypt buffer GCS*/
1053     memcpy(decrypt_data, try_data, *decrypt_len);
1054     g_free(try_data);
1055
1056     /* remove protection bit */
1057     decrypt_data[1]&=0xBF;
1058
1059     /* remove TKIP/CCMP header */
1060     offset = mac_header_len;
1061     *decrypt_len-=8;
1062     memmove(decrypt_data+offset, decrypt_data+offset+8, *decrypt_len-offset);
1063
1064     if (key!=NULL) {
1065         memcpy(key, sa->key, sizeof(AIRPDCAP_KEY_ITEM));
1066         memcpy(key->KeyData.Wpa.Ptk, sa->wpa.ptk, AIRPDCAP_WPA_PTK_LEN); /* copy the PTK to the key structure for future use by wireshark */
1067         if (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP)
1068             key->KeyType=AIRPDCAP_KEY_TYPE_TKIP;
1069         else if (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP)
1070             key->KeyType=AIRPDCAP_KEY_TYPE_CCMP;
1071     }
1072
1073     return AIRPDCAP_RET_SUCCESS;
1074 }
1075
1076 static INT
1077 AirPDcapWepMng(
1078     PAIRPDCAP_CONTEXT ctx,
1079     UCHAR *decrypt_data,
1080     guint mac_header_len,
1081     guint *decrypt_len,
1082     PAIRPDCAP_KEY_ITEM key,
1083     AIRPDCAP_SEC_ASSOCIATION *sa,
1084     INT offset)
1085 {
1086     UCHAR wep_key[AIRPDCAP_WEP_KEY_MAXLEN+AIRPDCAP_WEP_IVLEN];
1087     size_t keylen;
1088     INT ret_value=1;
1089     INT key_index;
1090     AIRPDCAP_KEY_ITEM *tmp_key;
1091     UINT8 useCache=FALSE;
1092     UCHAR *try_data;
1093     guint try_data_len = *decrypt_len;
1094
1095     try_data = (UCHAR *)g_malloc(try_data_len);
1096
1097     if (sa->key!=NULL)
1098         useCache=TRUE;
1099
1100     for (key_index=0; key_index<(INT)ctx->keys_nr; key_index++) {
1101         /* use the cached one, or try all keys */
1102         if (!useCache) {
1103             tmp_key=&ctx->keys[key_index];
1104         } else {
1105             if (sa->key!=NULL && sa->key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1106                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Try cached WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1107                 tmp_key=sa->key;
1108             } else {
1109                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Cached key is not valid, try another WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1110                 tmp_key=&ctx->keys[key_index];
1111             }
1112         }
1113
1114         /* obviously, try only WEP keys... */
1115         if (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1116             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Try WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1117
1118             memset(wep_key, 0, sizeof(wep_key));
1119             memcpy(try_data, decrypt_data, *decrypt_len);
1120
1121             /* Costruct the WEP seed: copy the IV in first 3 bytes and then the WEP key (refer to 802-11i-2004, 8.2.1.4.3, pag. 36) */
1122             memcpy(wep_key, try_data+mac_header_len, AIRPDCAP_WEP_IVLEN);
1123             keylen=tmp_key->KeyData.Wep.WepKeyLen;
1124             memcpy(wep_key+AIRPDCAP_WEP_IVLEN, tmp_key->KeyData.Wep.WepKey, keylen);
1125
1126             ret_value=AirPDcapWepDecrypt(wep_key,
1127                 keylen+AIRPDCAP_WEP_IVLEN,
1128                 try_data + (mac_header_len+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN),
1129                 *decrypt_len-(mac_header_len+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN+AIRPDCAP_CRC_LEN));
1130
1131             if (ret_value == AIRPDCAP_RET_SUCCESS)
1132                 memcpy(decrypt_data, try_data, *decrypt_len);
1133         }
1134
1135         if (!ret_value && tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1136             /* the tried key is the correct one, cached in the Security Association */
1137
1138             sa->key=tmp_key;
1139
1140             if (key!=NULL) {
1141                 memcpy(key, sa->key, sizeof(AIRPDCAP_KEY_ITEM));
1142                 key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1143             }
1144
1145             break;
1146         } else {
1147             /* the cached key was not valid, try other keys */
1148
1149             if (useCache==TRUE) {
1150                 useCache=FALSE;
1151                 key_index--;
1152             }
1153         }
1154     }
1155
1156     g_free(try_data);
1157     if (ret_value)
1158         return AIRPDCAP_RET_UNSUCCESS;
1159
1160     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "WEP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1161
1162     /* remove ICV (4bytes) from the end of packet */
1163     *decrypt_len-=4;
1164
1165     if (*decrypt_len < 4) {
1166         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Decryption length too short", AIRPDCAP_DEBUG_LEVEL_3);
1167         return AIRPDCAP_RET_UNSUCCESS;
1168     }
1169
1170     /* remove protection bit */
1171     decrypt_data[1]&=0xBF;
1172
1173     /* remove IC header */
1174     offset = mac_header_len;
1175     *decrypt_len-=4;
1176     memmove(decrypt_data+offset, decrypt_data+offset+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN, *decrypt_len-offset);
1177
1178     return AIRPDCAP_RET_SUCCESS;
1179 }
1180
1181 /* Refer to IEEE 802.11i-2004, 8.5.3, pag. 85 */
1182 static INT
1183 AirPDcapRsna4WHandshake(
1184     PAIRPDCAP_CONTEXT ctx,
1185     const UCHAR *data,
1186     AIRPDCAP_SEC_ASSOCIATION *sa,
1187     INT offset)
1188 {
1189     AIRPDCAP_KEY_ITEM *tmp_key, *tmp_pkt_key, pkt_key;
1190     AIRPDCAP_SEC_ASSOCIATION *tmp_sa;
1191     INT key_index;
1192     INT ret_value=1;
1193     UCHAR useCache=FALSE;
1194     UCHAR eapol[AIRPDCAP_EAPOL_MAX_LEN];
1195     USHORT eapol_len;
1196
1197     if (sa->key!=NULL)
1198         useCache=TRUE;
1199
1200     /* a 4-way handshake packet use a Pairwise key type (IEEE 802.11i-2004, pg. 79) */
1201     if (AIRPDCAP_EAP_KEY(data[offset+1])!=1) {
1202         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Group/STAKey message (not used)", AIRPDCAP_DEBUG_LEVEL_5);
1203         return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1204     }
1205
1206     /* TODO timeouts? */
1207
1208     /* TODO consider key-index */
1209
1210     /* TODO considera Deauthentications */
1211
1212     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake...", AIRPDCAP_DEBUG_LEVEL_5);
1213
1214     /* manage 4-way handshake packets; this step completes the 802.1X authentication process (IEEE 802.11i-2004, pag. 85) */
1215
1216     /* message 1: Authenticator->Supplicant (Sec=0, Mic=0, Ack=1, Inst=0, Key=1(pairwise), KeyRSC=0, Nonce=ANonce, MIC=0) */
1217     if (AIRPDCAP_EAP_INST(data[offset+1])==0 &&
1218         AIRPDCAP_EAP_ACK(data[offset+1])==1 &&
1219         AIRPDCAP_EAP_MIC(data[offset])==0)
1220     {
1221         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 1", AIRPDCAP_DEBUG_LEVEL_3);
1222
1223         /* On reception of Message 1, the Supplicant determines whether the Key Replay Counter field value has been        */
1224         /* used before with the current PMKSA. If the Key Replay Counter field value is less than or equal to the current  */
1225         /* local value, the Supplicant discards the message.                                                               */
1226         /* -> not checked, the Authenticator will be send another Message 1 (hopefully!)                                   */
1227
1228         /* This saves the sa since we are reauthenticating which will overwrite our current sa GCS*/
1229         if( sa->handshake >= 2) {
1230             tmp_sa= g_new(AIRPDCAP_SEC_ASSOCIATION, 1);
1231             memcpy(tmp_sa, sa, sizeof(AIRPDCAP_SEC_ASSOCIATION));
1232             sa->validKey=FALSE;
1233             sa->next=tmp_sa;
1234         }
1235
1236         /* save ANonce (from authenticator) to derive the PTK with the SNonce (from the 2 message) */
1237         memcpy(sa->wpa.nonce, data+offset+12, 32);
1238
1239         /* get the Key Descriptor Version (to select algorithm used in decryption -CCMP or TKIP-) */
1240         sa->wpa.key_ver=AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1]);
1241
1242         sa->handshake=1;
1243
1244         return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1245     }
1246
1247     /* message 2|4: Supplicant->Authenticator (Sec=0|1, Mic=1, Ack=0, Inst=0, Key=1(pairwise), KeyRSC=0, Nonce=SNonce|0, MIC=MIC(KCK,EAPOL)) */
1248     if (AIRPDCAP_EAP_INST(data[offset+1])==0 &&
1249         AIRPDCAP_EAP_ACK(data[offset+1])==0 &&
1250         AIRPDCAP_EAP_MIC(data[offset])==1)
1251     {
1252          /* Check nonce to differentiate between message 2 or 4
1253           * nonce will be non zero for message 2 and zero for message 4.
1254           * At least needed for Windows, since it is setting the secure bit on message 2 when rekeying */
1255         if (!memiszero(data+offset+12, 32)) {
1256             /* message 2 */
1257             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 2", AIRPDCAP_DEBUG_LEVEL_3);
1258
1259             /* On reception of Message 2, the Authenticator checks that the key replay counter corresponds to the */
1260             /* outstanding Message 1. If not, it silently discards the message.                                   */
1261             /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame,  */
1262             /* the Authenticator silently discards Message 2.                                                     */
1263             /* -> not checked; the Supplicant will send another message 2 (hopefully!)                            */
1264
1265             /* now you can derive the PTK */
1266             for (key_index=0; key_index<(INT)ctx->keys_nr || useCache; key_index++) {
1267                 /* use the cached one, or try all keys */
1268                 if (!useCache) {
1269                     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Try WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1270                     tmp_key=&ctx->keys[key_index];
1271                 } else {
1272                     /* there is a cached key in the security association, if it's a WPA key try it... */
1273                     if (sa->key!=NULL &&
1274                         (sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1275                          sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1276                          sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK)) {
1277                             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Try cached WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1278                             tmp_key=sa->key;
1279                     } else {
1280                         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Cached key is of a wrong type, try WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1281                         tmp_key=&ctx->keys[key_index];
1282                     }
1283                 }
1284
1285                 /* obviously, try only WPA keys... */
1286                 if (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1287                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1288                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK)
1289                 {
1290                     if (tmp_key->KeyType == AIRPDCAP_KEY_TYPE_WPA_PWD && tmp_key->UserPwd.SsidLen == 0 && ctx->pkt_ssid_len > 0 && ctx->pkt_ssid_len <= AIRPDCAP_WPA_SSID_MAX_LEN) {
1291                         /* We have a "wildcard" SSID.  Use the one from the packet. */
1292                         memcpy(&pkt_key, tmp_key, sizeof(pkt_key));
1293                         memcpy(&pkt_key.UserPwd.Ssid, ctx->pkt_ssid, ctx->pkt_ssid_len);
1294                          pkt_key.UserPwd.SsidLen = ctx->pkt_ssid_len;
1295                         AirPDcapRsnaPwd2Psk(pkt_key.UserPwd.Passphrase, pkt_key.UserPwd.Ssid,
1296                             pkt_key.UserPwd.SsidLen, pkt_key.KeyData.Wpa.Psk);
1297                         tmp_pkt_key = &pkt_key;
1298                     } else {
1299                         tmp_pkt_key = tmp_key;
1300                     }
1301
1302                     /* derive the PTK from the BSSID, STA MAC, PMK, SNonce, ANonce */
1303                     AirPDcapRsnaPrfX(sa,                            /* authenticator nonce, bssid, station mac */
1304                                      tmp_pkt_key->KeyData.Wpa.Psk,      /* PSK == PMK */
1305                                      data+offset+12,                /* supplicant nonce */
1306                                      512,
1307                                      sa->wpa.ptk);
1308
1309                     /* verify the MIC (compare the MIC in the packet included in this message with a MIC calculated with the PTK) */
1310                     eapol_len=pntoh16(data+offset-3)+4;
1311                     memcpy(eapol, &data[offset-5], (eapol_len<AIRPDCAP_EAPOL_MAX_LEN?eapol_len:AIRPDCAP_EAPOL_MAX_LEN));
1312                     ret_value=AirPDcapRsnaMicCheck(eapol,           /*      eapol frame (header also) */
1313                                                    eapol_len,       /*      eapol frame length        */
1314                                                    sa->wpa.ptk,     /*      Key Confirmation Key      */
1315                                                    AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1])); /*  EAPOL-Key description version */
1316
1317                     /* If the MIC is valid, the Authenticator checks that the RSN information element bit-wise matches       */
1318                     /* that from the (Re)Association Request message.                                                        */
1319                     /*              i) TODO If these are not exactly the same, the Authenticator uses MLME-DEAUTHENTICATE.request */
1320                     /* primitive to terminate the association.                                                               */
1321                     /*              ii) If they do match bit-wise, the Authenticator constructs Message 3.                   */
1322                 }
1323
1324                 if (!ret_value &&
1325                     (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1326                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1327                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK))
1328                 {
1329                     /* the temporary key is the correct one, cached in the Security Association */
1330
1331                     sa->key=tmp_key;
1332                     break;
1333                 } else {
1334                     /* the cached key was not valid, try other keys */
1335
1336                     if (useCache==TRUE) {
1337                         useCache=FALSE;
1338                         key_index--;
1339                     }
1340                 }
1341             }
1342
1343             if (ret_value) {
1344                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "handshake step failed", AIRPDCAP_DEBUG_LEVEL_3);
1345                 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1346             }
1347
1348             sa->handshake=2;
1349             sa->validKey=TRUE; /* we can use the key to decode, even if we have not captured the other eapol packets */
1350
1351             return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1352         } else {
1353         /* message 4 */
1354
1355             /* TODO "Note that when the 4-Way Handshake is first used Message 4 is sent in the clear." */
1356
1357             /* TODO check MIC and Replay Counter                                                                     */
1358             /* On reception of Message 4, the Authenticator verifies that the Key Replay Counter field value is one  */
1359             /* that it used on this 4-Way Handshake; if it is not, it silently discards the message.                 */
1360             /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame, the */
1361             /* Authenticator silently discards Message 4.                                                            */
1362
1363             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 4", AIRPDCAP_DEBUG_LEVEL_3);
1364
1365             sa->handshake=4;
1366
1367             return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1368         }
1369     }
1370
1371     /* message 3: Authenticator->Supplicant (Sec=1, Mic=1, Ack=1, Inst=0/1, Key=1(pairwise), KeyRSC=???, Nonce=ANonce, MIC=1) */
1372     if (AIRPDCAP_EAP_ACK(data[offset+1])==1 &&
1373         AIRPDCAP_EAP_MIC(data[offset])==1)
1374     {
1375         const EAPOL_RSN_KEY *pEAPKey;
1376         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 3", AIRPDCAP_DEBUG_LEVEL_3);
1377
1378         /* On reception of Message 3, the Supplicant silently discards the message if the Key Replay Counter field     */
1379         /* value has already been used or if the ANonce value in Message 3 differs from the ANonce value in Message 1. */
1380         /* -> not checked, the Authenticator will send another message 3 (hopefully!)                                  */
1381
1382         /* TODO check page 88 (RNS) */
1383
1384         /* If using WPA2 PSK, message 3 will contain an RSN for the group key (GTK KDE).
1385            In order to properly support decrypting WPA2-PSK packets, we need to parse this to get the group key. */
1386         pEAPKey = (const EAPOL_RSN_KEY *)(&(data[offset-1]));
1387         if (pEAPKey->type == AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR){
1388             PAIRPDCAP_SEC_ASSOCIATION broadcast_sa;
1389             AIRPDCAP_SEC_ASSOCIATION_ID id;
1390
1391             /* Get broadcacst SA for the current BSSID */
1392             memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
1393             memcpy(id.bssid, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1394             broadcast_sa = AirPDcapGetSaPtr(ctx, &id);
1395
1396             if (broadcast_sa == NULL){
1397                 return AIRPDCAP_RET_REQ_DATA;
1398             }
1399             return (AirPDcapDecryptWPABroadcastKey(pEAPKey, sa->wpa.ptk+16, broadcast_sa, FALSE));
1400         }
1401     }
1402
1403     return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1404 }
1405
1406 static INT
1407 AirPDcapRsnaMicCheck(
1408     UCHAR *eapol,
1409     USHORT eapol_len,
1410     UCHAR KCK[AIRPDCAP_WPA_KCK_LEN],
1411     USHORT key_ver)
1412 {
1413     UCHAR mic[AIRPDCAP_WPA_MICKEY_LEN];
1414     UCHAR c_mic[20];  /* MIC 16 byte, the HMAC-SHA1 use a buffer of 20 bytes */
1415
1416     /* copy the MIC from the EAPOL packet */
1417     memcpy(mic, eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, AIRPDCAP_WPA_MICKEY_LEN);
1418
1419     /* set to 0 the MIC in the EAPOL packet (to calculate the MIC) */
1420     memset(eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, 0, AIRPDCAP_WPA_MICKEY_LEN);
1421
1422     if (key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP) {
1423         /* use HMAC-MD5 for the EAPOL-Key MIC */
1424         md5_hmac(eapol, eapol_len, KCK, AIRPDCAP_WPA_KCK_LEN, c_mic);
1425     } else if (key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP) {
1426         /* use HMAC-SHA1-128 for the EAPOL-Key MIC */
1427         sha1_hmac(KCK, AIRPDCAP_WPA_KCK_LEN, eapol, eapol_len, c_mic);
1428     } else
1429         /* key descriptor version not recognized */
1430         return AIRPDCAP_RET_UNSUCCESS;
1431
1432     /* compare calculated MIC with the Key MIC and return result (0 means success) */
1433     return memcmp(mic, c_mic, AIRPDCAP_WPA_MICKEY_LEN);
1434 }
1435
1436 static INT
1437 AirPDcapValidateKey(
1438     PAIRPDCAP_KEY_ITEM key)
1439 {
1440     size_t len;
1441     UCHAR ret=TRUE;
1442     AIRPDCAP_DEBUG_TRACE_START("AirPDcapValidateKey");
1443
1444     if (key==NULL) {
1445         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "NULL key", AIRPDCAP_DEBUG_LEVEL_5);
1446         AIRPDCAP_DEBUG_TRACE_START("AirPDcapValidateKey");
1447         return FALSE;
1448     }
1449
1450     switch (key->KeyType) {
1451         case AIRPDCAP_KEY_TYPE_WEP:
1452             /* check key size limits */
1453             len=key->KeyData.Wep.WepKeyLen;
1454             if (len<AIRPDCAP_WEP_KEY_MINLEN || len>AIRPDCAP_WEP_KEY_MAXLEN) {
1455                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WEP key: key length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1456                 ret=FALSE;
1457             }
1458             break;
1459
1460         case AIRPDCAP_KEY_TYPE_WEP_40:
1461             /* set the standard length and use a generic WEP key type */
1462             key->KeyData.Wep.WepKeyLen=AIRPDCAP_WEP_40_KEY_LEN;
1463             key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1464             break;
1465
1466         case AIRPDCAP_KEY_TYPE_WEP_104:
1467             /* set the standard length and use a generic WEP key type */
1468             key->KeyData.Wep.WepKeyLen=AIRPDCAP_WEP_104_KEY_LEN;
1469             key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1470             break;
1471
1472         case AIRPDCAP_KEY_TYPE_WPA_PWD:
1473             /* check passphrase and SSID size limits */
1474             len=strlen(key->UserPwd.Passphrase);
1475             if (len<AIRPDCAP_WPA_PASSPHRASE_MIN_LEN || len>AIRPDCAP_WPA_PASSPHRASE_MAX_LEN) {
1476                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WPA-PWD key: passphrase length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1477                 ret=FALSE;
1478             }
1479
1480             len=key->UserPwd.SsidLen;
1481             if (len>AIRPDCAP_WPA_SSID_MAX_LEN) {
1482                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WPA-PWD key: ssid length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1483                 ret=FALSE;
1484             }
1485
1486             break;
1487
1488         case AIRPDCAP_KEY_TYPE_WPA_PSK:
1489             break;
1490
1491         case AIRPDCAP_KEY_TYPE_WPA_PMK:
1492             break;
1493
1494         default:
1495             ret=FALSE;
1496     }
1497
1498     AIRPDCAP_DEBUG_TRACE_END("AirPDcapValidateKey");
1499     return ret;
1500 }
1501
1502 static INT
1503 AirPDcapGetSa(
1504     PAIRPDCAP_CONTEXT ctx,
1505     AIRPDCAP_SEC_ASSOCIATION_ID *id)
1506 {
1507     INT sa_index;
1508     if (ctx->sa_index!=-1) {
1509         /* at least one association was stored                               */
1510         /* search for the association from sa_index to 0 (most recent added) */
1511         for (sa_index=ctx->sa_index; sa_index>=0; sa_index--) {
1512             if (ctx->sa[sa_index].used) {
1513                 if (memcmp(id, &(ctx->sa[sa_index].saId), sizeof(AIRPDCAP_SEC_ASSOCIATION_ID))==0) {
1514                     ctx->index=sa_index;
1515                     return sa_index;
1516                 }
1517             }
1518         }
1519     }
1520
1521     return -1;
1522 }
1523
1524 static INT
1525 AirPDcapStoreSa(
1526     PAIRPDCAP_CONTEXT ctx,
1527     AIRPDCAP_SEC_ASSOCIATION_ID *id)
1528 {
1529     INT last_free;
1530     if (ctx->first_free_index>=AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR) {
1531         /* there is no empty space available. FAILURE */
1532         return -1;
1533     }
1534     if (ctx->sa[ctx->first_free_index].used) {
1535         /* last addition was in the middle of the array (and the first_free_index was just incremented by 1)   */
1536         /* search for a free space from the first_free_index to AIRPDCAP_STA_INFOS_NR (to avoid free blocks in */
1537         /*              the middle)                                                                            */
1538         for (last_free=ctx->first_free_index; last_free<AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR; last_free++)
1539             if (!ctx->sa[last_free].used)
1540                 break;
1541
1542         if (last_free>=AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR) {
1543             /* there is no empty space available. FAILURE */
1544             return -1;
1545         }
1546
1547         /* store first free space index */
1548         ctx->first_free_index=last_free;
1549     }
1550
1551     /* use this info */
1552     ctx->index=ctx->first_free_index;
1553
1554     /* reset the info structure */
1555     memset(ctx->sa+ctx->index, 0, sizeof(AIRPDCAP_SEC_ASSOCIATION));
1556
1557     ctx->sa[ctx->index].used=1;
1558
1559     /* set the info structure */
1560     memcpy(&(ctx->sa[ctx->index].saId), id, sizeof(AIRPDCAP_SEC_ASSOCIATION_ID));
1561
1562     /* increment by 1 the first_free_index (heuristic) */
1563     ctx->first_free_index++;
1564
1565     /* set the sa_index if the added index is greater the the sa_index */
1566     if (ctx->index > ctx->sa_index)
1567         ctx->sa_index=ctx->index;
1568
1569     return ctx->index;
1570 }
1571
1572 /*
1573  * AirPDcapGetBssidAddress() and AirPDcapGetBssidAddress() are used for
1574  * key caching.  In each case, it's more important to return a value than
1575  * to return a _correct_ value, so we fudge addresses in some cases, e.g.
1576  * the BSSID in bridged connections.
1577  * FromDS    ToDS    Sta    BSSID
1578  * 0         0       addr2  addr3
1579  * 0         1       addr2  addr1
1580  * 1         0       addr1  addr2
1581  * 1         1       addr2  addr1
1582  */
1583
1584 static const UCHAR *
1585 AirPDcapGetStaAddress(
1586     const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
1587 {
1588     switch(AIRPDCAP_DS_BITS(frame->fc[1])) { /* Bit 1 = FromDS, bit 0 = ToDS */
1589         case 0:
1590         case 1:
1591             return frame->addr2;
1592         case 2:
1593             return frame->addr1;
1594         case 3:
1595             if (memcmp(frame->addr1, frame->addr2, AIRPDCAP_MAC_LEN) < 0)
1596                 return frame->addr1;
1597             else
1598                 return frame->addr2;
1599
1600         default:
1601             return NULL;
1602     }
1603 }
1604
1605 static const UCHAR *
1606 AirPDcapGetBssidAddress(
1607     const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
1608 {
1609     switch(AIRPDCAP_DS_BITS(frame->fc[1])) { /* Bit 1 = FromDS, bit 0 = ToDS */
1610         case 0:
1611             return frame->addr3;
1612         case 1:
1613             return frame->addr1;
1614         case 2:
1615             return frame->addr2;
1616         case 3:
1617             if (memcmp(frame->addr1, frame->addr2, AIRPDCAP_MAC_LEN) > 0)
1618                 return frame->addr1;
1619             else
1620                 return frame->addr2;
1621
1622         default:
1623             return NULL;
1624     }
1625 }
1626
1627 /* Function used to derive the PTK. Refer to IEEE 802.11I-2004, pag. 74
1628  * and IEEE 802.11i-2004, pag. 164 */
1629 static void
1630 AirPDcapRsnaPrfX(
1631     AIRPDCAP_SEC_ASSOCIATION *sa,
1632     const UCHAR pmk[32],
1633     const UCHAR snonce[32],
1634     const INT x,        /*      for TKIP 512, for CCMP 384 */
1635     UCHAR *ptk)
1636 {
1637     UINT8 i;
1638     UCHAR R[100];
1639     INT offset=sizeof("Pairwise key expansion");
1640     UCHAR output[80]; /* allow for sha1 overflow. */
1641
1642     memset(R, 0, 100);
1643
1644     memcpy(R, "Pairwise key expansion", offset);
1645
1646     /* Min(AA, SPA) || Max(AA, SPA) */
1647     if (memcmp(sa->saId.sta, sa->saId.bssid, AIRPDCAP_MAC_LEN) < 0)
1648     {
1649         memcpy(R + offset, sa->saId.sta, AIRPDCAP_MAC_LEN);
1650         memcpy(R + offset+AIRPDCAP_MAC_LEN, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1651     }
1652     else
1653     {
1654         memcpy(R + offset, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1655         memcpy(R + offset+AIRPDCAP_MAC_LEN, sa->saId.sta, AIRPDCAP_MAC_LEN);
1656     }
1657
1658     offset+=AIRPDCAP_MAC_LEN*2;
1659
1660     /* Min(ANonce,SNonce) || Max(ANonce,SNonce) */
1661     if( memcmp(snonce, sa->wpa.nonce, 32) < 0 )
1662     {
1663         memcpy(R + offset, snonce, 32);
1664         memcpy(R + offset + 32, sa->wpa.nonce, 32);
1665     }
1666     else
1667     {
1668         memcpy(R + offset, sa->wpa.nonce, 32);
1669         memcpy(R + offset + 32, snonce, 32);
1670     }
1671
1672     offset+=32*2;
1673
1674     for(i = 0; i < (x+159)/160; i++)
1675     {
1676         R[offset] = i;
1677         sha1_hmac(pmk, 32, R, 100, &output[20 * i]);
1678     }
1679     memcpy(ptk, output, x/8);
1680 }
1681
1682 #define MAX_SSID_LENGTH 32 /* maximum SSID length */
1683
1684 static INT
1685 AirPDcapRsnaPwd2PskStep(
1686     const guint8 *ppBytes,
1687     const guint ppLength,
1688     const CHAR *ssid,
1689     const size_t ssidLength,
1690     const INT iterations,
1691     const INT count,
1692     UCHAR *output)
1693 {
1694     UCHAR digest[MAX_SSID_LENGTH+4];  /* SSID plus 4 bytes of count */
1695     UCHAR digest1[SHA1_DIGEST_LEN];
1696     INT i, j;
1697
1698     if (ssidLength > MAX_SSID_LENGTH) {
1699         /* This "should not happen" */
1700         return AIRPDCAP_RET_UNSUCCESS;
1701     }
1702
1703     memset(digest, 0, sizeof digest);
1704     memset(digest1, 0, sizeof digest1);
1705
1706     /* U1 = PRF(P, S || INT(i)) */
1707     memcpy(digest, ssid, ssidLength);
1708     digest[ssidLength] = (UCHAR)((count>>24) & 0xff);
1709     digest[ssidLength+1] = (UCHAR)((count>>16) & 0xff);
1710     digest[ssidLength+2] = (UCHAR)((count>>8) & 0xff);
1711     digest[ssidLength+3] = (UCHAR)(count & 0xff);
1712     sha1_hmac(ppBytes, ppLength, digest, (guint32) ssidLength+4, digest1);
1713
1714     /* output = U1 */
1715     memcpy(output, digest1, SHA1_DIGEST_LEN);
1716     for (i = 1; i < iterations; i++) {
1717         /* Un = PRF(P, Un-1) */
1718         sha1_hmac(ppBytes, ppLength, digest1, SHA1_DIGEST_LEN, digest);
1719
1720         memcpy(digest1, digest, SHA1_DIGEST_LEN);
1721         /* output = output xor Un */
1722         for (j = 0; j < SHA1_DIGEST_LEN; j++) {
1723             output[j] ^= digest[j];
1724         }
1725     }
1726
1727     return AIRPDCAP_RET_SUCCESS;
1728 }
1729
1730 static INT
1731 AirPDcapRsnaPwd2Psk(
1732     const CHAR *passphrase,
1733     const CHAR *ssid,
1734     const size_t ssidLength,
1735     UCHAR *output)
1736 {
1737     UCHAR m_output[2*SHA1_DIGEST_LEN];
1738     GByteArray *pp_ba = g_byte_array_new();
1739
1740     memset(m_output, 0, 2*SHA1_DIGEST_LEN);
1741
1742     if (!uri_str_to_bytes(passphrase, pp_ba)) {
1743         g_byte_array_free(pp_ba, TRUE);
1744         return 0;
1745     }
1746
1747     AirPDcapRsnaPwd2PskStep(pp_ba->data, pp_ba->len, ssid, ssidLength, 4096, 1, m_output);
1748     AirPDcapRsnaPwd2PskStep(pp_ba->data, pp_ba->len, ssid, ssidLength, 4096, 2, &m_output[SHA1_DIGEST_LEN]);
1749
1750     memcpy(output, m_output, AIRPDCAP_WPA_PSK_LEN);
1751     g_byte_array_free(pp_ba, TRUE);
1752
1753     return 0;
1754 }
1755
1756 /*
1757  * Returns the decryption_key_t struct given a string describing the key.
1758  * Returns NULL if the input_string cannot be parsed.
1759  */
1760 decryption_key_t*
1761 parse_key_string(gchar* input_string, guint8 key_type)
1762 {
1763     gchar *key, *tmp_str;
1764     gchar *ssid;
1765
1766     GString    *key_string = NULL;
1767     GByteArray *ssid_ba = NULL, *key_ba;
1768     gboolean    res;
1769
1770     gchar **tokens;
1771     guint n = 0;
1772     decryption_key_t *dk;
1773
1774     if(input_string == NULL)
1775         return NULL;
1776
1777     /*
1778      * Parse the input_string. WEP and WPA will be just a string
1779      * of hexadecimal characters (if key is wrong, null will be
1780      * returned...).
1781      * WPA-PWD should be in the form
1782      * <key data>[:<ssid>]
1783      */
1784
1785     switch(key_type)
1786     {
1787     case AIRPDCAP_KEY_TYPE_WEP:
1788     case AIRPDCAP_KEY_TYPE_WEP_40:
1789     case AIRPDCAP_KEY_TYPE_WEP_104:
1790
1791        key_ba = g_byte_array_new();
1792        res = hex_str_to_bytes(input_string, key_ba, FALSE);
1793
1794        if (res && key_ba->len > 0) {
1795            /* Key is correct! It was probably an 'old style' WEP key */
1796            /* Create the decryption_key_t structure, fill it and return it*/
1797            dk = (decryption_key_t *)g_malloc(sizeof(decryption_key_t));
1798
1799            dk->type = AIRPDCAP_KEY_TYPE_WEP;
1800            /* XXX - The current key handling code in the GUI requires
1801             * no separators and lower case */
1802            tmp_str = bytes_to_str(NULL, key_ba->data, key_ba->len);
1803            dk->key  = g_string_new(tmp_str);
1804            g_string_ascii_down(dk->key);
1805            dk->bits = key_ba->len * 8;
1806            dk->ssid = NULL;
1807
1808            wmem_free(NULL, tmp_str);
1809            g_byte_array_free(key_ba, TRUE);
1810            return dk;
1811        }
1812
1813        /* Key doesn't work */
1814        g_byte_array_free(key_ba, TRUE);
1815        return NULL;
1816
1817     case AIRPDCAP_KEY_TYPE_WPA_PWD:
1818
1819         tokens = g_strsplit(input_string,":",0);
1820
1821         /* Tokens is a null termiated array of strings ... */
1822         while(tokens[n] != NULL)
1823             n++;
1824
1825         if(n < 1)
1826         {
1827             /* Free the array of strings */
1828             g_strfreev(tokens);
1829             return NULL;
1830         }
1831
1832         /*
1833          * The first token is the key
1834          */
1835         key = g_strdup(tokens[0]);
1836
1837         ssid = NULL;
1838         /* Maybe there is a second token (an ssid, if everything else is ok) */
1839         if(n >= 2)
1840         {
1841            ssid = g_strdup(tokens[1]);
1842         }
1843
1844         /* Create a new string */
1845         key_string = g_string_new(key);
1846         ssid_ba = NULL;
1847
1848         /* Two (or more) tokens mean that the user entered a WPA-PWD key ... */
1849         if( ((key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
1850         {
1851             g_string_free(key_string, TRUE);
1852
1853             g_free(key);
1854             g_free(ssid);
1855
1856             /* Free the array of strings */
1857             g_strfreev(tokens);
1858             return NULL;
1859         }
1860
1861         if(ssid != NULL) /* more than two tokens found, means that the user specified the ssid */
1862         {
1863             ssid_ba = g_byte_array_new();
1864             if (! uri_str_to_bytes(ssid, ssid_ba)) {
1865                 g_string_free(key_string, TRUE);
1866                 g_byte_array_free(ssid_ba, TRUE);
1867                 g_free(key);
1868                 g_free(ssid);
1869                 /* Free the array of strings */
1870                 g_strfreev(tokens);
1871                 return NULL;
1872             }
1873
1874             if(ssid_ba->len > WPA_SSID_MAX_CHAR_SIZE)
1875             {
1876                 g_string_free(key_string, TRUE);
1877                 g_byte_array_free(ssid_ba, TRUE);
1878
1879                 g_free(key);
1880                 g_free(ssid);
1881
1882                 /* Free the array of strings */
1883                 g_strfreev(tokens);
1884                 return NULL;
1885             }
1886         }
1887
1888         /* Key was correct!!! Create the new decryption_key_t ... */
1889         dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1890
1891         dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD;
1892         dk->key  = g_string_new(key);
1893         dk->bits = 256; /* This is the length of the array pf bytes that will be generated using key+ssid ...*/
1894         dk->ssid = byte_array_dup(ssid_ba); /* NULL if ssid_ba is NULL */
1895
1896         g_string_free(key_string, TRUE);
1897         if (ssid_ba != NULL)
1898             g_byte_array_free(ssid_ba, TRUE);
1899
1900         g_free(key);
1901         if(ssid != NULL)
1902             g_free(ssid);
1903
1904         /* Free the array of strings */
1905         g_strfreev(tokens);
1906         return dk;
1907
1908     case AIRPDCAP_KEY_TYPE_WPA_PSK:
1909
1910         key_ba = g_byte_array_new();
1911         res = hex_str_to_bytes(input_string, key_ba, FALSE);
1912
1913         /* Two tokens means that the user should have entered a WPA-BIN key ... */
1914         if(!res || ((key_ba->len) != WPA_PSK_KEY_SIZE))
1915         {
1916             g_byte_array_free(key_ba, TRUE);
1917
1918             /* No ssid has been created ... */
1919             return NULL;
1920         }
1921
1922         /* Key was correct!!! Create the new decryption_key_t ... */
1923         dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1924
1925         dk->type = AIRPDCAP_KEY_TYPE_WPA_PSK;
1926         dk->key  = g_string_new(input_string);
1927         dk->bits = (guint) dk->key->len * 4;
1928         dk->ssid = NULL;
1929
1930         g_byte_array_free(key_ba, TRUE);
1931         return dk;
1932     }
1933
1934     /* Type not supported */
1935     return NULL;
1936 }
1937
1938 void
1939 free_key_string(decryption_key_t *dk)
1940 {
1941     if (dk->key)
1942         g_string_free(dk->key, TRUE);
1943     if (dk->ssid)
1944         g_byte_array_free(dk->ssid, TRUE);
1945     g_free(dk);
1946 }
1947
1948 /*
1949  * Returns a newly allocated string representing the given decryption_key_t
1950  * struct, or NULL if something is wrong...
1951  */
1952 gchar*
1953 get_key_string(decryption_key_t* dk)
1954 {
1955     gchar* output_string = NULL;
1956
1957     if(dk == NULL || dk->key == NULL)
1958         return NULL;
1959
1960     switch(dk->type) {
1961         case AIRPDCAP_KEY_TYPE_WEP:
1962             output_string = g_strdup(dk->key->str);
1963             break;
1964         case AIRPDCAP_KEY_TYPE_WPA_PWD:
1965             if(dk->ssid == NULL)
1966                 output_string = g_strdup(dk->key->str);
1967             else
1968                 output_string = g_strdup_printf("%s:%s",
1969                     dk->key->str, format_uri(dk->ssid, ":"));
1970             break;
1971         case AIRPDCAP_KEY_TYPE_WPA_PMK:
1972             output_string = g_strdup(dk->key->str);
1973             break;
1974         default:
1975             return NULL;
1976     }
1977
1978     return output_string;
1979 }
1980
1981 #ifdef __cplusplus
1982 }
1983 #endif
1984
1985 /****************************************************************************/
1986
1987 /*
1988  * Editor modelines
1989  *
1990  * Local Variables:
1991  * c-basic-offset: 4
1992  * tab-width: 8
1993  * indent-tabs-mode: nil
1994  * End:
1995  *
1996  * ex: set shiftwidth=4 tabstop=8 expandtab:
1997  * :indentSize=4:tabSize=8:noTabs=true:
1998  */