Add boundary check for 802.11 decryption
[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     /* Assume that the decrypt_data field is at least this size. */
667     if (tot_len > AIRPDCAP_MAX_CAPLEN) {
668         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "length too large", AIRPDCAP_DEBUG_LEVEL_3);
669         return AIRPDCAP_RET_UNSUCCESS;
670     }
671
672     /* get BSSID */
673     if ( (addr=AirPDcapGetBssidAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
674         memcpy(id.bssid, addr, AIRPDCAP_MAC_LEN);
675         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
676     } else {
677         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "BSSID not found", AIRPDCAP_DEBUG_LEVEL_5);
678         return AIRPDCAP_RET_REQ_DATA;
679     }
680
681     /* get STA address */
682     if ( (addr=AirPDcapGetStaAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
683         memcpy(id.sta, addr, AIRPDCAP_MAC_LEN);
684         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
685     } else {
686         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "SA not found", AIRPDCAP_DEBUG_LEVEL_5);
687         return AIRPDCAP_RET_REQ_DATA;
688     }
689
690     /* check if data is encrypted (use the WEP bit in the Frame Control field) */
691     if (AIRPDCAP_WEP(data[1])==0) {
692         if (scanHandshake) {
693             /* data is sent in cleartext, check if is an authentication message or end the process */
694             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Unencrypted data", AIRPDCAP_DEBUG_LEVEL_3);
695             return (AirPDcapScanForKeys(ctx, data, mac_header_len, tot_len, id));
696         }
697         return AIRPDCAP_RET_NO_DATA_ENCRYPTED;
698     } else {
699         PAIRPDCAP_SEC_ASSOCIATION sa;
700         int offset = 0;
701
702         /* get the Security Association structure for the STA and AP */
703         sa = AirPDcapGetSaPtr(ctx, &id);
704         if (sa == NULL){
705             return AIRPDCAP_RET_REQ_DATA;
706         }
707
708         /* cache offset in the packet data (to scan encryption data) */
709         offset = mac_header_len;
710
711         if (decrypt_data==NULL) {
712             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "no decrypt buffer, use local", AIRPDCAP_DEBUG_LEVEL_3);
713             decrypt_data=tmp_data;
714             decrypt_len=&tmp_len;
715         }
716
717         /* create new header and data to modify */
718         *decrypt_len = tot_len;
719         memcpy(decrypt_data, data, *decrypt_len);
720
721         /* encrypted data */
722         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Encrypted data", AIRPDCAP_DEBUG_LEVEL_3);
723
724         /* check the Extension IV to distinguish between WEP encryption and WPA encryption */
725         /* refer to IEEE 802.11i-2004, 8.2.1.2, pag.35 for WEP,    */
726         /*          IEEE 802.11i-2004, 8.3.2.2, pag. 45 for TKIP,  */
727         /*          IEEE 802.11i-2004, 8.3.3.2, pag. 57 for CCMP   */
728         if (AIRPDCAP_EXTIV(data[offset+3])==0) {
729             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "WEP encryption", AIRPDCAP_DEBUG_LEVEL_3);
730             return AirPDcapWepMng(ctx, decrypt_data, mac_header_len, decrypt_len, key, sa, offset);
731         } else {
732             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "TKIP or CCMP encryption", AIRPDCAP_DEBUG_LEVEL_3);
733
734             /* If index >= 1, then use the group key.  This will not work if the AP is using
735                more than one group key simultaneously.  I've not seen this in practice, however.
736                Usually an AP will rotate between the two key index values of 1 and 2 whenever
737                it needs to change the group key to be used. */
738             if (AIRPDCAP_KEY_INDEX(data[offset+3])>=1){
739
740                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "The key index >= 1. This is encrypted with a group key.", AIRPDCAP_DEBUG_LEVEL_3);
741
742                 /* force STA address to broadcast MAC so we load the SA for the groupkey */
743                 memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
744
745 #ifdef _DEBUG
746                 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]);
747                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
748 #endif
749
750                 /* search for a cached Security Association for current BSSID and broadcast MAC */
751                 sa = AirPDcapGetSaPtr(ctx, &id);
752                 if (sa == NULL)
753                     return AIRPDCAP_RET_REQ_DATA;
754             }
755
756             /* Decrypt the packet using the appropriate SA */
757             if (AirPDcapRsnaMng(decrypt_data, mac_header_len, decrypt_len, key, sa, offset) == AIRPDCAP_RET_SUCCESS) {
758                 /* If we successfully decrypted a packet, scan it to see if it contains a key handshake.
759                    The group key handshake could be sent at any time the AP wants to change the key (such as when
760                    it is using key rotation) and it also could be a rekey for the Pairwise key. So we must scan every packet. */
761                 if (scanHandshake) {
762                     return (AirPDcapScanForKeys(ctx, decrypt_data, mac_header_len, *decrypt_len, id));
763                 } else {
764                     return AIRPDCAP_RET_SUCCESS;
765                 }
766             }
767         }
768     }
769     return AIRPDCAP_RET_UNSUCCESS;
770 }
771
772 INT AirPDcapSetKeys(
773     PAIRPDCAP_CONTEXT ctx,
774     AIRPDCAP_KEY_ITEM keys[],
775     const size_t keys_nr)
776 {
777     INT i;
778     INT success;
779     AIRPDCAP_DEBUG_TRACE_START("AirPDcapSetKeys");
780
781     if (ctx==NULL || keys==NULL) {
782         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "NULL context or NULL keys array", AIRPDCAP_DEBUG_LEVEL_3);
783         AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
784         return 0;
785     }
786
787     if (keys_nr>AIRPDCAP_MAX_KEYS_NR) {
788         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Keys number greater than maximum", AIRPDCAP_DEBUG_LEVEL_3);
789         AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
790         return 0;
791     }
792
793     /* clean key and SA collections before setting new ones */
794     AirPDcapInitContext(ctx);
795
796     /* check and insert keys */
797     for (i=0, success=0; i<(INT)keys_nr; i++) {
798         if (AirPDcapValidateKey(keys+i)==TRUE) {
799             if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD) {
800                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WPA-PWD key", AIRPDCAP_DEBUG_LEVEL_4);
801                 AirPDcapRsnaPwd2Psk(keys[i].UserPwd.Passphrase, keys[i].UserPwd.Ssid, keys[i].UserPwd.SsidLen, keys[i].KeyData.Wpa.Psk);
802             }
803 #ifdef _DEBUG
804             else if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK) {
805                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WPA-PMK key", AIRPDCAP_DEBUG_LEVEL_4);
806             } else if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WEP) {
807                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WEP key", AIRPDCAP_DEBUG_LEVEL_4);
808             } else {
809                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a key", AIRPDCAP_DEBUG_LEVEL_4);
810             }
811 #endif
812             memcpy(&ctx->keys[success], &keys[i], sizeof(keys[i]));
813             success++;
814         }
815     }
816
817     ctx->keys_nr=success;
818
819     AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
820     return success;
821 }
822
823 static void
824 AirPDcapCleanKeys(
825     PAIRPDCAP_CONTEXT ctx)
826 {
827     AIRPDCAP_DEBUG_TRACE_START("AirPDcapCleanKeys");
828
829     if (ctx==NULL) {
830         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapCleanKeys", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
831         AIRPDCAP_DEBUG_TRACE_END("AirPDcapCleanKeys");
832         return;
833     }
834
835     memset(ctx->keys, 0, sizeof(AIRPDCAP_KEY_ITEM) * AIRPDCAP_MAX_KEYS_NR);
836
837     ctx->keys_nr=0;
838
839     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapCleanKeys", "Keys collection cleaned!", AIRPDCAP_DEBUG_LEVEL_5);
840     AIRPDCAP_DEBUG_TRACE_END("AirPDcapCleanKeys");
841 }
842
843 static void
844 AirPDcapRecurseCleanSA(
845     PAIRPDCAP_SEC_ASSOCIATION sa)
846 {
847     if (sa->next != NULL) {
848         AirPDcapRecurseCleanSA(sa->next);
849         g_free(sa->next);
850         sa->next = NULL;
851     }
852 }
853
854 static void
855 AirPDcapCleanSecAssoc(
856     PAIRPDCAP_CONTEXT ctx)
857 {
858     PAIRPDCAP_SEC_ASSOCIATION psa;
859     int i;
860
861     for (psa = ctx->sa, i = 0; i < AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR; i++, psa++) {
862         /* To iterate is human, to recurse, divine */
863         AirPDcapRecurseCleanSA(psa);
864     }
865 }
866
867 INT AirPDcapGetKeys(
868     const PAIRPDCAP_CONTEXT ctx,
869     AIRPDCAP_KEY_ITEM keys[],
870     const size_t keys_nr)
871 {
872     UINT i;
873     UINT j;
874     AIRPDCAP_DEBUG_TRACE_START("AirPDcapGetKeys");
875
876     if (ctx==NULL) {
877         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
878         AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
879         return 0;
880     } else if (keys==NULL) {
881         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "NULL keys array", AIRPDCAP_DEBUG_LEVEL_5);
882         AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
883         return (INT)ctx->keys_nr;
884     } else {
885         for (i=0, j=0; i<ctx->keys_nr && i<keys_nr && i<AIRPDCAP_MAX_KEYS_NR; i++) {
886             memcpy(&keys[j], &ctx->keys[i], sizeof(keys[j]));
887             j++;
888             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "Got a key", AIRPDCAP_DEBUG_LEVEL_5);
889         }
890
891         AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
892         return j;
893     }
894 }
895
896 /*
897  * XXX - This won't be reliable if a packet containing SSID "B" shows
898  * up in the middle of a 4-way handshake for SSID "A".
899  * We should probably use a small array or hash table to keep multiple
900  * SSIDs.
901  */
902 INT AirPDcapSetLastSSID(
903     PAIRPDCAP_CONTEXT ctx,
904     CHAR *pkt_ssid,
905     size_t pkt_ssid_len)
906 {
907     if (!ctx || !pkt_ssid || pkt_ssid_len < 1 || pkt_ssid_len > WPA_SSID_MAX_SIZE)
908         return AIRPDCAP_RET_UNSUCCESS;
909
910     memcpy(ctx->pkt_ssid, pkt_ssid, pkt_ssid_len);
911     ctx->pkt_ssid_len = pkt_ssid_len;
912
913     return AIRPDCAP_RET_SUCCESS;
914 }
915
916 INT AirPDcapInitContext(
917     PAIRPDCAP_CONTEXT ctx)
918 {
919     AIRPDCAP_DEBUG_TRACE_START("AirPDcapInitContext");
920
921     if (ctx==NULL) {
922         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapInitContext", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
923         AIRPDCAP_DEBUG_TRACE_END("AirPDcapInitContext");
924         return AIRPDCAP_RET_UNSUCCESS;
925     }
926
927     AirPDcapCleanKeys(ctx);
928
929     ctx->first_free_index=0;
930     ctx->index=-1;
931     ctx->sa_index=-1;
932     ctx->pkt_ssid_len = 0;
933
934     memset(ctx->sa, 0, AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR * sizeof(AIRPDCAP_SEC_ASSOCIATION));
935
936     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapInitContext", "Context initialized!", AIRPDCAP_DEBUG_LEVEL_5);
937     AIRPDCAP_DEBUG_TRACE_END("AirPDcapInitContext");
938     return AIRPDCAP_RET_SUCCESS;
939 }
940
941 INT AirPDcapDestroyContext(
942     PAIRPDCAP_CONTEXT ctx)
943 {
944     AIRPDCAP_DEBUG_TRACE_START("AirPDcapDestroyContext");
945
946     if (ctx==NULL) {
947         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapDestroyContext", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
948         AIRPDCAP_DEBUG_TRACE_END("AirPDcapDestroyContext");
949         return AIRPDCAP_RET_UNSUCCESS;
950     }
951
952     AirPDcapCleanKeys(ctx);
953     AirPDcapCleanSecAssoc(ctx);
954
955     ctx->first_free_index=0;
956     ctx->index=-1;
957     ctx->sa_index=-1;
958
959     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapDestroyContext", "Context destroyed!", AIRPDCAP_DEBUG_LEVEL_5);
960     AIRPDCAP_DEBUG_TRACE_END("AirPDcapDestroyContext");
961     return AIRPDCAP_RET_SUCCESS;
962 }
963
964 #ifdef __cplusplus
965 }
966 #endif
967
968 /****************************************************************************/
969
970 /****************************************************************************/
971 /* Internal function definitions                                         */
972
973 #ifdef __cplusplus
974 extern "C" {
975 #endif
976
977 static INT
978 AirPDcapRsnaMng(
979     UCHAR *decrypt_data,
980     guint mac_header_len,
981     guint *decrypt_len,
982     PAIRPDCAP_KEY_ITEM key,
983     AIRPDCAP_SEC_ASSOCIATION *sa,
984     INT offset)
985 {
986     INT ret_value=1;
987     UCHAR *try_data;
988     guint try_data_len = *decrypt_len;
989
990     if (sa->key==NULL) {
991         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "No key associated", AIRPDCAP_DEBUG_LEVEL_3);
992         return AIRPDCAP_RET_REQ_DATA;
993     }
994
995     if (*decrypt_len > try_data_len) {
996         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Invalid decryption length", AIRPDCAP_DEBUG_LEVEL_3);
997         return AIRPDCAP_RET_UNSUCCESS;
998     }
999
1000     /* allocate a temp buffer for the decryption loop */
1001     try_data=(UCHAR *)g_malloc(try_data_len);
1002
1003     /* start of loop added by GCS */
1004     for(/* sa */; sa != NULL ;sa=sa->next) {
1005
1006        if (sa->validKey==FALSE) {
1007            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Key not yet valid", AIRPDCAP_DEBUG_LEVEL_3);
1008            continue;
1009        }
1010
1011        /* copy the encrypted data into a temp buffer */
1012        memcpy(try_data, decrypt_data, *decrypt_len);
1013
1014        if (sa->wpa.key_ver==1) {
1015            /* CCMP -> HMAC-MD5 is the EAPOL-Key MIC, RC4 is the EAPOL-Key encryption algorithm */
1016            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP", AIRPDCAP_DEBUG_LEVEL_3);
1017            DEBUG_DUMP("ptk", sa->wpa.ptk, 64);
1018            DEBUG_DUMP("ptk portion used", AIRPDCAP_GET_TK(sa->wpa.ptk), 16);
1019
1020            ret_value=AirPDcapTkipDecrypt(try_data+offset, *decrypt_len-offset, try_data+AIRPDCAP_TA_OFFSET, AIRPDCAP_GET_TK(sa->wpa.ptk));
1021            if (ret_value){
1022                AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP failed!", AIRPDCAP_DEBUG_LEVEL_3);
1023                continue;
1024            }
1025
1026            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1027            /* remove MIC (8bytes) and ICV (4bytes) from the end of packet */
1028            *decrypt_len-=12;
1029            break;
1030        } else {
1031            /* AES-CCMP -> HMAC-SHA1-128 is the EAPOL-Key MIC, AES wep_key wrap is the EAPOL-Key encryption algorithm */
1032            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "CCMP", AIRPDCAP_DEBUG_LEVEL_3);
1033
1034            ret_value=AirPDcapCcmpDecrypt(try_data, mac_header_len, (INT)*decrypt_len, AIRPDCAP_GET_TK(sa->wpa.ptk));
1035            if (ret_value)
1036               continue;
1037
1038            AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "CCMP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1039            /* remove MIC (8bytes) from the end of packet */
1040            *decrypt_len-=8;
1041            break;
1042        }
1043     }
1044     /* end of loop */
1045
1046     /* none of the keys worked */
1047     if(sa == NULL) {
1048         g_free(try_data);
1049         return ret_value;
1050     }
1051
1052     if (*decrypt_len > try_data_len || *decrypt_len < 8) {
1053         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Invalid decryption length", AIRPDCAP_DEBUG_LEVEL_3);
1054         g_free(try_data);
1055         return AIRPDCAP_RET_UNSUCCESS;
1056     }
1057
1058     /* copy the decrypted data into the decrypt buffer GCS*/
1059     memcpy(decrypt_data, try_data, *decrypt_len);
1060     g_free(try_data);
1061
1062     /* remove protection bit */
1063     decrypt_data[1]&=0xBF;
1064
1065     /* remove TKIP/CCMP header */
1066     offset = mac_header_len;
1067     *decrypt_len-=8;
1068     memmove(decrypt_data+offset, decrypt_data+offset+8, *decrypt_len-offset);
1069
1070     if (key!=NULL) {
1071         memcpy(key, sa->key, sizeof(AIRPDCAP_KEY_ITEM));
1072         memcpy(key->KeyData.Wpa.Ptk, sa->wpa.ptk, AIRPDCAP_WPA_PTK_LEN); /* copy the PTK to the key structure for future use by wireshark */
1073         if (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP)
1074             key->KeyType=AIRPDCAP_KEY_TYPE_TKIP;
1075         else if (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP)
1076             key->KeyType=AIRPDCAP_KEY_TYPE_CCMP;
1077     }
1078
1079     return AIRPDCAP_RET_SUCCESS;
1080 }
1081
1082 static INT
1083 AirPDcapWepMng(
1084     PAIRPDCAP_CONTEXT ctx,
1085     UCHAR *decrypt_data,
1086     guint mac_header_len,
1087     guint *decrypt_len,
1088     PAIRPDCAP_KEY_ITEM key,
1089     AIRPDCAP_SEC_ASSOCIATION *sa,
1090     INT offset)
1091 {
1092     UCHAR wep_key[AIRPDCAP_WEP_KEY_MAXLEN+AIRPDCAP_WEP_IVLEN];
1093     size_t keylen;
1094     INT ret_value=1;
1095     INT key_index;
1096     AIRPDCAP_KEY_ITEM *tmp_key;
1097     UINT8 useCache=FALSE;
1098     UCHAR *try_data;
1099     guint try_data_len = *decrypt_len;
1100
1101     try_data = (UCHAR *)g_malloc(try_data_len);
1102
1103     if (sa->key!=NULL)
1104         useCache=TRUE;
1105
1106     for (key_index=0; key_index<(INT)ctx->keys_nr; key_index++) {
1107         /* use the cached one, or try all keys */
1108         if (!useCache) {
1109             tmp_key=&ctx->keys[key_index];
1110         } else {
1111             if (sa->key!=NULL && sa->key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1112                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Try cached WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1113                 tmp_key=sa->key;
1114             } else {
1115                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Cached key is not valid, try another WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1116                 tmp_key=&ctx->keys[key_index];
1117             }
1118         }
1119
1120         /* obviously, try only WEP keys... */
1121         if (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1122             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Try WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1123
1124             memset(wep_key, 0, sizeof(wep_key));
1125             memcpy(try_data, decrypt_data, *decrypt_len);
1126
1127             /* 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) */
1128             memcpy(wep_key, try_data+mac_header_len, AIRPDCAP_WEP_IVLEN);
1129             keylen=tmp_key->KeyData.Wep.WepKeyLen;
1130             memcpy(wep_key+AIRPDCAP_WEP_IVLEN, tmp_key->KeyData.Wep.WepKey, keylen);
1131
1132             ret_value=AirPDcapWepDecrypt(wep_key,
1133                 keylen+AIRPDCAP_WEP_IVLEN,
1134                 try_data + (mac_header_len+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN),
1135                 *decrypt_len-(mac_header_len+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN+AIRPDCAP_CRC_LEN));
1136
1137             if (ret_value == AIRPDCAP_RET_SUCCESS)
1138                 memcpy(decrypt_data, try_data, *decrypt_len);
1139         }
1140
1141         if (!ret_value && tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1142             /* the tried key is the correct one, cached in the Security Association */
1143
1144             sa->key=tmp_key;
1145
1146             if (key!=NULL) {
1147                 memcpy(key, sa->key, sizeof(AIRPDCAP_KEY_ITEM));
1148                 key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1149             }
1150
1151             break;
1152         } else {
1153             /* the cached key was not valid, try other keys */
1154
1155             if (useCache==TRUE) {
1156                 useCache=FALSE;
1157                 key_index--;
1158             }
1159         }
1160     }
1161
1162     g_free(try_data);
1163     if (ret_value)
1164         return AIRPDCAP_RET_UNSUCCESS;
1165
1166     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "WEP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1167
1168     /* remove ICV (4bytes) from the end of packet */
1169     *decrypt_len-=4;
1170
1171     if (*decrypt_len < 4) {
1172         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Decryption length too short", AIRPDCAP_DEBUG_LEVEL_3);
1173         return AIRPDCAP_RET_UNSUCCESS;
1174     }
1175
1176     /* remove protection bit */
1177     decrypt_data[1]&=0xBF;
1178
1179     /* remove IC header */
1180     offset = mac_header_len;
1181     *decrypt_len-=4;
1182     memmove(decrypt_data+offset, decrypt_data+offset+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN, *decrypt_len-offset);
1183
1184     return AIRPDCAP_RET_SUCCESS;
1185 }
1186
1187 /* Refer to IEEE 802.11i-2004, 8.5.3, pag. 85 */
1188 static INT
1189 AirPDcapRsna4WHandshake(
1190     PAIRPDCAP_CONTEXT ctx,
1191     const UCHAR *data,
1192     AIRPDCAP_SEC_ASSOCIATION *sa,
1193     INT offset)
1194 {
1195     AIRPDCAP_KEY_ITEM *tmp_key, *tmp_pkt_key, pkt_key;
1196     AIRPDCAP_SEC_ASSOCIATION *tmp_sa;
1197     INT key_index;
1198     INT ret_value=1;
1199     UCHAR useCache=FALSE;
1200     UCHAR eapol[AIRPDCAP_EAPOL_MAX_LEN];
1201     USHORT eapol_len;
1202
1203     if (sa->key!=NULL)
1204         useCache=TRUE;
1205
1206     /* a 4-way handshake packet use a Pairwise key type (IEEE 802.11i-2004, pg. 79) */
1207     if (AIRPDCAP_EAP_KEY(data[offset+1])!=1) {
1208         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Group/STAKey message (not used)", AIRPDCAP_DEBUG_LEVEL_5);
1209         return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1210     }
1211
1212     /* TODO timeouts? */
1213
1214     /* TODO consider key-index */
1215
1216     /* TODO considera Deauthentications */
1217
1218     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake...", AIRPDCAP_DEBUG_LEVEL_5);
1219
1220     /* manage 4-way handshake packets; this step completes the 802.1X authentication process (IEEE 802.11i-2004, pag. 85) */
1221
1222     /* message 1: Authenticator->Supplicant (Sec=0, Mic=0, Ack=1, Inst=0, Key=1(pairwise), KeyRSC=0, Nonce=ANonce, MIC=0) */
1223     if (AIRPDCAP_EAP_INST(data[offset+1])==0 &&
1224         AIRPDCAP_EAP_ACK(data[offset+1])==1 &&
1225         AIRPDCAP_EAP_MIC(data[offset])==0)
1226     {
1227         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 1", AIRPDCAP_DEBUG_LEVEL_3);
1228
1229         /* On reception of Message 1, the Supplicant determines whether the Key Replay Counter field value has been        */
1230         /* used before with the current PMKSA. If the Key Replay Counter field value is less than or equal to the current  */
1231         /* local value, the Supplicant discards the message.                                                               */
1232         /* -> not checked, the Authenticator will be send another Message 1 (hopefully!)                                   */
1233
1234         /* This saves the sa since we are reauthenticating which will overwrite our current sa GCS*/
1235         if( sa->handshake >= 2) {
1236             tmp_sa= g_new(AIRPDCAP_SEC_ASSOCIATION, 1);
1237             memcpy(tmp_sa, sa, sizeof(AIRPDCAP_SEC_ASSOCIATION));
1238             sa->validKey=FALSE;
1239             sa->next=tmp_sa;
1240         }
1241
1242         /* save ANonce (from authenticator) to derive the PTK with the SNonce (from the 2 message) */
1243         memcpy(sa->wpa.nonce, data+offset+12, 32);
1244
1245         /* get the Key Descriptor Version (to select algorithm used in decryption -CCMP or TKIP-) */
1246         sa->wpa.key_ver=AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1]);
1247
1248         sa->handshake=1;
1249
1250         return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1251     }
1252
1253     /* 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)) */
1254     if (AIRPDCAP_EAP_INST(data[offset+1])==0 &&
1255         AIRPDCAP_EAP_ACK(data[offset+1])==0 &&
1256         AIRPDCAP_EAP_MIC(data[offset])==1)
1257     {
1258          /* Check nonce to differentiate between message 2 or 4
1259           * nonce will be non zero for message 2 and zero for message 4.
1260           * At least needed for Windows, since it is setting the secure bit on message 2 when rekeying */
1261         if (!memiszero(data+offset+12, 32)) {
1262             /* message 2 */
1263             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 2", AIRPDCAP_DEBUG_LEVEL_3);
1264
1265             /* On reception of Message 2, the Authenticator checks that the key replay counter corresponds to the */
1266             /* outstanding Message 1. If not, it silently discards the message.                                   */
1267             /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame,  */
1268             /* the Authenticator silently discards Message 2.                                                     */
1269             /* -> not checked; the Supplicant will send another message 2 (hopefully!)                            */
1270
1271             /* now you can derive the PTK */
1272             for (key_index=0; key_index<(INT)ctx->keys_nr || useCache; key_index++) {
1273                 /* use the cached one, or try all keys */
1274                 if (!useCache) {
1275                     AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Try WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1276                     tmp_key=&ctx->keys[key_index];
1277                 } else {
1278                     /* there is a cached key in the security association, if it's a WPA key try it... */
1279                     if (sa->key!=NULL &&
1280                         (sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1281                          sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1282                          sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK)) {
1283                             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Try cached WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1284                             tmp_key=sa->key;
1285                     } else {
1286                         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Cached key is of a wrong type, try WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1287                         tmp_key=&ctx->keys[key_index];
1288                     }
1289                 }
1290
1291                 /* obviously, try only WPA keys... */
1292                 if (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1293                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1294                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK)
1295                 {
1296                     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) {
1297                         /* We have a "wildcard" SSID.  Use the one from the packet. */
1298                         memcpy(&pkt_key, tmp_key, sizeof(pkt_key));
1299                         memcpy(&pkt_key.UserPwd.Ssid, ctx->pkt_ssid, ctx->pkt_ssid_len);
1300                          pkt_key.UserPwd.SsidLen = ctx->pkt_ssid_len;
1301                         AirPDcapRsnaPwd2Psk(pkt_key.UserPwd.Passphrase, pkt_key.UserPwd.Ssid,
1302                             pkt_key.UserPwd.SsidLen, pkt_key.KeyData.Wpa.Psk);
1303                         tmp_pkt_key = &pkt_key;
1304                     } else {
1305                         tmp_pkt_key = tmp_key;
1306                     }
1307
1308                     /* derive the PTK from the BSSID, STA MAC, PMK, SNonce, ANonce */
1309                     AirPDcapRsnaPrfX(sa,                            /* authenticator nonce, bssid, station mac */
1310                                      tmp_pkt_key->KeyData.Wpa.Psk,      /* PSK == PMK */
1311                                      data+offset+12,                /* supplicant nonce */
1312                                      512,
1313                                      sa->wpa.ptk);
1314
1315                     /* verify the MIC (compare the MIC in the packet included in this message with a MIC calculated with the PTK) */
1316                     eapol_len=pntoh16(data+offset-3)+4;
1317                     memcpy(eapol, &data[offset-5], (eapol_len<AIRPDCAP_EAPOL_MAX_LEN?eapol_len:AIRPDCAP_EAPOL_MAX_LEN));
1318                     ret_value=AirPDcapRsnaMicCheck(eapol,           /*      eapol frame (header also) */
1319                                                    eapol_len,       /*      eapol frame length        */
1320                                                    sa->wpa.ptk,     /*      Key Confirmation Key      */
1321                                                    AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1])); /*  EAPOL-Key description version */
1322
1323                     /* If the MIC is valid, the Authenticator checks that the RSN information element bit-wise matches       */
1324                     /* that from the (Re)Association Request message.                                                        */
1325                     /*              i) TODO If these are not exactly the same, the Authenticator uses MLME-DEAUTHENTICATE.request */
1326                     /* primitive to terminate the association.                                                               */
1327                     /*              ii) If they do match bit-wise, the Authenticator constructs Message 3.                   */
1328                 }
1329
1330                 if (!ret_value &&
1331                     (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1332                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1333                     tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK))
1334                 {
1335                     /* the temporary key is the correct one, cached in the Security Association */
1336
1337                     sa->key=tmp_key;
1338                     break;
1339                 } else {
1340                     /* the cached key was not valid, try other keys */
1341
1342                     if (useCache==TRUE) {
1343                         useCache=FALSE;
1344                         key_index--;
1345                     }
1346                 }
1347             }
1348
1349             if (ret_value) {
1350                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "handshake step failed", AIRPDCAP_DEBUG_LEVEL_3);
1351                 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1352             }
1353
1354             sa->handshake=2;
1355             sa->validKey=TRUE; /* we can use the key to decode, even if we have not captured the other eapol packets */
1356
1357             return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1358         } else {
1359         /* message 4 */
1360
1361             /* TODO "Note that when the 4-Way Handshake is first used Message 4 is sent in the clear." */
1362
1363             /* TODO check MIC and Replay Counter                                                                     */
1364             /* On reception of Message 4, the Authenticator verifies that the Key Replay Counter field value is one  */
1365             /* that it used on this 4-Way Handshake; if it is not, it silently discards the message.                 */
1366             /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame, the */
1367             /* Authenticator silently discards Message 4.                                                            */
1368
1369             AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 4", AIRPDCAP_DEBUG_LEVEL_3);
1370
1371             sa->handshake=4;
1372
1373             return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1374         }
1375     }
1376
1377     /* message 3: Authenticator->Supplicant (Sec=1, Mic=1, Ack=1, Inst=0/1, Key=1(pairwise), KeyRSC=???, Nonce=ANonce, MIC=1) */
1378     if (AIRPDCAP_EAP_ACK(data[offset+1])==1 &&
1379         AIRPDCAP_EAP_MIC(data[offset])==1)
1380     {
1381         const EAPOL_RSN_KEY *pEAPKey;
1382         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 3", AIRPDCAP_DEBUG_LEVEL_3);
1383
1384         /* On reception of Message 3, the Supplicant silently discards the message if the Key Replay Counter field     */
1385         /* value has already been used or if the ANonce value in Message 3 differs from the ANonce value in Message 1. */
1386         /* -> not checked, the Authenticator will send another message 3 (hopefully!)                                  */
1387
1388         /* TODO check page 88 (RNS) */
1389
1390         /* If using WPA2 PSK, message 3 will contain an RSN for the group key (GTK KDE).
1391            In order to properly support decrypting WPA2-PSK packets, we need to parse this to get the group key. */
1392         pEAPKey = (const EAPOL_RSN_KEY *)(&(data[offset-1]));
1393         if (pEAPKey->type == AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR){
1394             PAIRPDCAP_SEC_ASSOCIATION broadcast_sa;
1395             AIRPDCAP_SEC_ASSOCIATION_ID id;
1396
1397             /* Get broadcacst SA for the current BSSID */
1398             memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
1399             memcpy(id.bssid, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1400             broadcast_sa = AirPDcapGetSaPtr(ctx, &id);
1401
1402             if (broadcast_sa == NULL){
1403                 return AIRPDCAP_RET_REQ_DATA;
1404             }
1405             return (AirPDcapDecryptWPABroadcastKey(pEAPKey, sa->wpa.ptk+16, broadcast_sa, FALSE));
1406         }
1407     }
1408
1409     return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1410 }
1411
1412 static INT
1413 AirPDcapRsnaMicCheck(
1414     UCHAR *eapol,
1415     USHORT eapol_len,
1416     UCHAR KCK[AIRPDCAP_WPA_KCK_LEN],
1417     USHORT key_ver)
1418 {
1419     UCHAR mic[AIRPDCAP_WPA_MICKEY_LEN];
1420     UCHAR c_mic[20];  /* MIC 16 byte, the HMAC-SHA1 use a buffer of 20 bytes */
1421
1422     /* copy the MIC from the EAPOL packet */
1423     memcpy(mic, eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, AIRPDCAP_WPA_MICKEY_LEN);
1424
1425     /* set to 0 the MIC in the EAPOL packet (to calculate the MIC) */
1426     memset(eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, 0, AIRPDCAP_WPA_MICKEY_LEN);
1427
1428     if (key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP) {
1429         /* use HMAC-MD5 for the EAPOL-Key MIC */
1430         md5_hmac(eapol, eapol_len, KCK, AIRPDCAP_WPA_KCK_LEN, c_mic);
1431     } else if (key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP) {
1432         /* use HMAC-SHA1-128 for the EAPOL-Key MIC */
1433         sha1_hmac(KCK, AIRPDCAP_WPA_KCK_LEN, eapol, eapol_len, c_mic);
1434     } else
1435         /* key descriptor version not recognized */
1436         return AIRPDCAP_RET_UNSUCCESS;
1437
1438     /* compare calculated MIC with the Key MIC and return result (0 means success) */
1439     return memcmp(mic, c_mic, AIRPDCAP_WPA_MICKEY_LEN);
1440 }
1441
1442 static INT
1443 AirPDcapValidateKey(
1444     PAIRPDCAP_KEY_ITEM key)
1445 {
1446     size_t len;
1447     UCHAR ret=TRUE;
1448     AIRPDCAP_DEBUG_TRACE_START("AirPDcapValidateKey");
1449
1450     if (key==NULL) {
1451         AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "NULL key", AIRPDCAP_DEBUG_LEVEL_5);
1452         AIRPDCAP_DEBUG_TRACE_START("AirPDcapValidateKey");
1453         return FALSE;
1454     }
1455
1456     switch (key->KeyType) {
1457         case AIRPDCAP_KEY_TYPE_WEP:
1458             /* check key size limits */
1459             len=key->KeyData.Wep.WepKeyLen;
1460             if (len<AIRPDCAP_WEP_KEY_MINLEN || len>AIRPDCAP_WEP_KEY_MAXLEN) {
1461                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WEP key: key length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1462                 ret=FALSE;
1463             }
1464             break;
1465
1466         case AIRPDCAP_KEY_TYPE_WEP_40:
1467             /* set the standard length and use a generic WEP key type */
1468             key->KeyData.Wep.WepKeyLen=AIRPDCAP_WEP_40_KEY_LEN;
1469             key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1470             break;
1471
1472         case AIRPDCAP_KEY_TYPE_WEP_104:
1473             /* set the standard length and use a generic WEP key type */
1474             key->KeyData.Wep.WepKeyLen=AIRPDCAP_WEP_104_KEY_LEN;
1475             key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1476             break;
1477
1478         case AIRPDCAP_KEY_TYPE_WPA_PWD:
1479             /* check passphrase and SSID size limits */
1480             len=strlen(key->UserPwd.Passphrase);
1481             if (len<AIRPDCAP_WPA_PASSPHRASE_MIN_LEN || len>AIRPDCAP_WPA_PASSPHRASE_MAX_LEN) {
1482                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WPA-PWD key: passphrase length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1483                 ret=FALSE;
1484             }
1485
1486             len=key->UserPwd.SsidLen;
1487             if (len>AIRPDCAP_WPA_SSID_MAX_LEN) {
1488                 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WPA-PWD key: ssid length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1489                 ret=FALSE;
1490             }
1491
1492             break;
1493
1494         case AIRPDCAP_KEY_TYPE_WPA_PSK:
1495             break;
1496
1497         case AIRPDCAP_KEY_TYPE_WPA_PMK:
1498             break;
1499
1500         default:
1501             ret=FALSE;
1502     }
1503
1504     AIRPDCAP_DEBUG_TRACE_END("AirPDcapValidateKey");
1505     return ret;
1506 }
1507
1508 static INT
1509 AirPDcapGetSa(
1510     PAIRPDCAP_CONTEXT ctx,
1511     AIRPDCAP_SEC_ASSOCIATION_ID *id)
1512 {
1513     INT sa_index;
1514     if (ctx->sa_index!=-1) {
1515         /* at least one association was stored                               */
1516         /* search for the association from sa_index to 0 (most recent added) */
1517         for (sa_index=ctx->sa_index; sa_index>=0; sa_index--) {
1518             if (ctx->sa[sa_index].used) {
1519                 if (memcmp(id, &(ctx->sa[sa_index].saId), sizeof(AIRPDCAP_SEC_ASSOCIATION_ID))==0) {
1520                     ctx->index=sa_index;
1521                     return sa_index;
1522                 }
1523             }
1524         }
1525     }
1526
1527     return -1;
1528 }
1529
1530 static INT
1531 AirPDcapStoreSa(
1532     PAIRPDCAP_CONTEXT ctx,
1533     AIRPDCAP_SEC_ASSOCIATION_ID *id)
1534 {
1535     INT last_free;
1536     if (ctx->first_free_index>=AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR) {
1537         /* there is no empty space available. FAILURE */
1538         return -1;
1539     }
1540     if (ctx->sa[ctx->first_free_index].used) {
1541         /* last addition was in the middle of the array (and the first_free_index was just incremented by 1)   */
1542         /* search for a free space from the first_free_index to AIRPDCAP_STA_INFOS_NR (to avoid free blocks in */
1543         /*              the middle)                                                                            */
1544         for (last_free=ctx->first_free_index; last_free<AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR; last_free++)
1545             if (!ctx->sa[last_free].used)
1546                 break;
1547
1548         if (last_free>=AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR) {
1549             /* there is no empty space available. FAILURE */
1550             return -1;
1551         }
1552
1553         /* store first free space index */
1554         ctx->first_free_index=last_free;
1555     }
1556
1557     /* use this info */
1558     ctx->index=ctx->first_free_index;
1559
1560     /* reset the info structure */
1561     memset(ctx->sa+ctx->index, 0, sizeof(AIRPDCAP_SEC_ASSOCIATION));
1562
1563     ctx->sa[ctx->index].used=1;
1564
1565     /* set the info structure */
1566     memcpy(&(ctx->sa[ctx->index].saId), id, sizeof(AIRPDCAP_SEC_ASSOCIATION_ID));
1567
1568     /* increment by 1 the first_free_index (heuristic) */
1569     ctx->first_free_index++;
1570
1571     /* set the sa_index if the added index is greater the the sa_index */
1572     if (ctx->index > ctx->sa_index)
1573         ctx->sa_index=ctx->index;
1574
1575     return ctx->index;
1576 }
1577
1578 /*
1579  * AirPDcapGetBssidAddress() and AirPDcapGetBssidAddress() are used for
1580  * key caching.  In each case, it's more important to return a value than
1581  * to return a _correct_ value, so we fudge addresses in some cases, e.g.
1582  * the BSSID in bridged connections.
1583  * FromDS    ToDS    Sta    BSSID
1584  * 0         0       addr2  addr3
1585  * 0         1       addr2  addr1
1586  * 1         0       addr1  addr2
1587  * 1         1       addr2  addr1
1588  */
1589
1590 static const UCHAR *
1591 AirPDcapGetStaAddress(
1592     const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
1593 {
1594     switch(AIRPDCAP_DS_BITS(frame->fc[1])) { /* Bit 1 = FromDS, bit 0 = ToDS */
1595         case 0:
1596         case 1:
1597             return frame->addr2;
1598         case 2:
1599             return frame->addr1;
1600         case 3:
1601             if (memcmp(frame->addr1, frame->addr2, AIRPDCAP_MAC_LEN) < 0)
1602                 return frame->addr1;
1603             else
1604                 return frame->addr2;
1605
1606         default:
1607             return NULL;
1608     }
1609 }
1610
1611 static const UCHAR *
1612 AirPDcapGetBssidAddress(
1613     const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
1614 {
1615     switch(AIRPDCAP_DS_BITS(frame->fc[1])) { /* Bit 1 = FromDS, bit 0 = ToDS */
1616         case 0:
1617             return frame->addr3;
1618         case 1:
1619             return frame->addr1;
1620         case 2:
1621             return frame->addr2;
1622         case 3:
1623             if (memcmp(frame->addr1, frame->addr2, AIRPDCAP_MAC_LEN) > 0)
1624                 return frame->addr1;
1625             else
1626                 return frame->addr2;
1627
1628         default:
1629             return NULL;
1630     }
1631 }
1632
1633 /* Function used to derive the PTK. Refer to IEEE 802.11I-2004, pag. 74
1634  * and IEEE 802.11i-2004, pag. 164 */
1635 static void
1636 AirPDcapRsnaPrfX(
1637     AIRPDCAP_SEC_ASSOCIATION *sa,
1638     const UCHAR pmk[32],
1639     const UCHAR snonce[32],
1640     const INT x,        /*      for TKIP 512, for CCMP 384 */
1641     UCHAR *ptk)
1642 {
1643     UINT8 i;
1644     UCHAR R[100];
1645     INT offset=sizeof("Pairwise key expansion");
1646     UCHAR output[80]; /* allow for sha1 overflow. */
1647
1648     memset(R, 0, 100);
1649
1650     memcpy(R, "Pairwise key expansion", offset);
1651
1652     /* Min(AA, SPA) || Max(AA, SPA) */
1653     if (memcmp(sa->saId.sta, sa->saId.bssid, AIRPDCAP_MAC_LEN) < 0)
1654     {
1655         memcpy(R + offset, sa->saId.sta, AIRPDCAP_MAC_LEN);
1656         memcpy(R + offset+AIRPDCAP_MAC_LEN, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1657     }
1658     else
1659     {
1660         memcpy(R + offset, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1661         memcpy(R + offset+AIRPDCAP_MAC_LEN, sa->saId.sta, AIRPDCAP_MAC_LEN);
1662     }
1663
1664     offset+=AIRPDCAP_MAC_LEN*2;
1665
1666     /* Min(ANonce,SNonce) || Max(ANonce,SNonce) */
1667     if( memcmp(snonce, sa->wpa.nonce, 32) < 0 )
1668     {
1669         memcpy(R + offset, snonce, 32);
1670         memcpy(R + offset + 32, sa->wpa.nonce, 32);
1671     }
1672     else
1673     {
1674         memcpy(R + offset, sa->wpa.nonce, 32);
1675         memcpy(R + offset + 32, snonce, 32);
1676     }
1677
1678     offset+=32*2;
1679
1680     for(i = 0; i < (x+159)/160; i++)
1681     {
1682         R[offset] = i;
1683         sha1_hmac(pmk, 32, R, 100, &output[20 * i]);
1684     }
1685     memcpy(ptk, output, x/8);
1686 }
1687
1688 #define MAX_SSID_LENGTH 32 /* maximum SSID length */
1689
1690 static INT
1691 AirPDcapRsnaPwd2PskStep(
1692     const guint8 *ppBytes,
1693     const guint ppLength,
1694     const CHAR *ssid,
1695     const size_t ssidLength,
1696     const INT iterations,
1697     const INT count,
1698     UCHAR *output)
1699 {
1700     UCHAR digest[MAX_SSID_LENGTH+4];  /* SSID plus 4 bytes of count */
1701     UCHAR digest1[SHA1_DIGEST_LEN];
1702     INT i, j;
1703
1704     if (ssidLength > MAX_SSID_LENGTH) {
1705         /* This "should not happen" */
1706         return AIRPDCAP_RET_UNSUCCESS;
1707     }
1708
1709     memset(digest, 0, sizeof digest);
1710     memset(digest1, 0, sizeof digest1);
1711
1712     /* U1 = PRF(P, S || INT(i)) */
1713     memcpy(digest, ssid, ssidLength);
1714     digest[ssidLength] = (UCHAR)((count>>24) & 0xff);
1715     digest[ssidLength+1] = (UCHAR)((count>>16) & 0xff);
1716     digest[ssidLength+2] = (UCHAR)((count>>8) & 0xff);
1717     digest[ssidLength+3] = (UCHAR)(count & 0xff);
1718     sha1_hmac(ppBytes, ppLength, digest, (guint32) ssidLength+4, digest1);
1719
1720     /* output = U1 */
1721     memcpy(output, digest1, SHA1_DIGEST_LEN);
1722     for (i = 1; i < iterations; i++) {
1723         /* Un = PRF(P, Un-1) */
1724         sha1_hmac(ppBytes, ppLength, digest1, SHA1_DIGEST_LEN, digest);
1725
1726         memcpy(digest1, digest, SHA1_DIGEST_LEN);
1727         /* output = output xor Un */
1728         for (j = 0; j < SHA1_DIGEST_LEN; j++) {
1729             output[j] ^= digest[j];
1730         }
1731     }
1732
1733     return AIRPDCAP_RET_SUCCESS;
1734 }
1735
1736 static INT
1737 AirPDcapRsnaPwd2Psk(
1738     const CHAR *passphrase,
1739     const CHAR *ssid,
1740     const size_t ssidLength,
1741     UCHAR *output)
1742 {
1743     UCHAR m_output[2*SHA1_DIGEST_LEN];
1744     GByteArray *pp_ba = g_byte_array_new();
1745
1746     memset(m_output, 0, 2*SHA1_DIGEST_LEN);
1747
1748     if (!uri_str_to_bytes(passphrase, pp_ba)) {
1749         g_byte_array_free(pp_ba, TRUE);
1750         return 0;
1751     }
1752
1753     AirPDcapRsnaPwd2PskStep(pp_ba->data, pp_ba->len, ssid, ssidLength, 4096, 1, m_output);
1754     AirPDcapRsnaPwd2PskStep(pp_ba->data, pp_ba->len, ssid, ssidLength, 4096, 2, &m_output[SHA1_DIGEST_LEN]);
1755
1756     memcpy(output, m_output, AIRPDCAP_WPA_PSK_LEN);
1757     g_byte_array_free(pp_ba, TRUE);
1758
1759     return 0;
1760 }
1761
1762 /*
1763  * Returns the decryption_key_t struct given a string describing the key.
1764  * Returns NULL if the input_string cannot be parsed.
1765  */
1766 decryption_key_t*
1767 parse_key_string(gchar* input_string, guint8 key_type)
1768 {
1769     gchar *key, *tmp_str;
1770     gchar *ssid;
1771
1772     GString    *key_string = NULL;
1773     GByteArray *ssid_ba = NULL, *key_ba;
1774     gboolean    res;
1775
1776     gchar **tokens;
1777     guint n = 0;
1778     decryption_key_t *dk;
1779
1780     if(input_string == NULL)
1781         return NULL;
1782
1783     /*
1784      * Parse the input_string. WEP and WPA will be just a string
1785      * of hexadecimal characters (if key is wrong, null will be
1786      * returned...).
1787      * WPA-PWD should be in the form
1788      * <key data>[:<ssid>]
1789      */
1790
1791     switch(key_type)
1792     {
1793     case AIRPDCAP_KEY_TYPE_WEP:
1794     case AIRPDCAP_KEY_TYPE_WEP_40:
1795     case AIRPDCAP_KEY_TYPE_WEP_104:
1796
1797        key_ba = g_byte_array_new();
1798        res = hex_str_to_bytes(input_string, key_ba, FALSE);
1799
1800        if (res && key_ba->len > 0) {
1801            /* Key is correct! It was probably an 'old style' WEP key */
1802            /* Create the decryption_key_t structure, fill it and return it*/
1803            dk = (decryption_key_t *)g_malloc(sizeof(decryption_key_t));
1804
1805            dk->type = AIRPDCAP_KEY_TYPE_WEP;
1806            /* XXX - The current key handling code in the GUI requires
1807             * no separators and lower case */
1808            tmp_str = bytes_to_str(NULL, key_ba->data, key_ba->len);
1809            dk->key  = g_string_new(tmp_str);
1810            g_string_ascii_down(dk->key);
1811            dk->bits = key_ba->len * 8;
1812            dk->ssid = NULL;
1813
1814            wmem_free(NULL, tmp_str);
1815            g_byte_array_free(key_ba, TRUE);
1816            return dk;
1817        }
1818
1819        /* Key doesn't work */
1820        g_byte_array_free(key_ba, TRUE);
1821        return NULL;
1822
1823     case AIRPDCAP_KEY_TYPE_WPA_PWD:
1824
1825         tokens = g_strsplit(input_string,":",0);
1826
1827         /* Tokens is a null termiated array of strings ... */
1828         while(tokens[n] != NULL)
1829             n++;
1830
1831         if(n < 1)
1832         {
1833             /* Free the array of strings */
1834             g_strfreev(tokens);
1835             return NULL;
1836         }
1837
1838         /*
1839          * The first token is the key
1840          */
1841         key = g_strdup(tokens[0]);
1842
1843         ssid = NULL;
1844         /* Maybe there is a second token (an ssid, if everything else is ok) */
1845         if(n >= 2)
1846         {
1847            ssid = g_strdup(tokens[1]);
1848         }
1849
1850         /* Create a new string */
1851         key_string = g_string_new(key);
1852         ssid_ba = NULL;
1853
1854         /* Two (or more) tokens mean that the user entered a WPA-PWD key ... */
1855         if( ((key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
1856         {
1857             g_string_free(key_string, TRUE);
1858
1859             g_free(key);
1860             g_free(ssid);
1861
1862             /* Free the array of strings */
1863             g_strfreev(tokens);
1864             return NULL;
1865         }
1866
1867         if(ssid != NULL) /* more than two tokens found, means that the user specified the ssid */
1868         {
1869             ssid_ba = g_byte_array_new();
1870             if (! uri_str_to_bytes(ssid, ssid_ba)) {
1871                 g_string_free(key_string, TRUE);
1872                 g_byte_array_free(ssid_ba, TRUE);
1873                 g_free(key);
1874                 g_free(ssid);
1875                 /* Free the array of strings */
1876                 g_strfreev(tokens);
1877                 return NULL;
1878             }
1879
1880             if(ssid_ba->len > WPA_SSID_MAX_CHAR_SIZE)
1881             {
1882                 g_string_free(key_string, TRUE);
1883                 g_byte_array_free(ssid_ba, TRUE);
1884
1885                 g_free(key);
1886                 g_free(ssid);
1887
1888                 /* Free the array of strings */
1889                 g_strfreev(tokens);
1890                 return NULL;
1891             }
1892         }
1893
1894         /* Key was correct!!! Create the new decryption_key_t ... */
1895         dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1896
1897         dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD;
1898         dk->key  = g_string_new(key);
1899         dk->bits = 256; /* This is the length of the array pf bytes that will be generated using key+ssid ...*/
1900         dk->ssid = byte_array_dup(ssid_ba); /* NULL if ssid_ba is NULL */
1901
1902         g_string_free(key_string, TRUE);
1903         if (ssid_ba != NULL)
1904             g_byte_array_free(ssid_ba, TRUE);
1905
1906         g_free(key);
1907         if(ssid != NULL)
1908             g_free(ssid);
1909
1910         /* Free the array of strings */
1911         g_strfreev(tokens);
1912         return dk;
1913
1914     case AIRPDCAP_KEY_TYPE_WPA_PSK:
1915
1916         key_ba = g_byte_array_new();
1917         res = hex_str_to_bytes(input_string, key_ba, FALSE);
1918
1919         /* Two tokens means that the user should have entered a WPA-BIN key ... */
1920         if(!res || ((key_ba->len) != WPA_PSK_KEY_SIZE))
1921         {
1922             g_byte_array_free(key_ba, TRUE);
1923
1924             /* No ssid has been created ... */
1925             return NULL;
1926         }
1927
1928         /* Key was correct!!! Create the new decryption_key_t ... */
1929         dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1930
1931         dk->type = AIRPDCAP_KEY_TYPE_WPA_PSK;
1932         dk->key  = g_string_new(input_string);
1933         dk->bits = (guint) dk->key->len * 4;
1934         dk->ssid = NULL;
1935
1936         g_byte_array_free(key_ba, TRUE);
1937         return dk;
1938     }
1939
1940     /* Type not supported */
1941     return NULL;
1942 }
1943
1944 void
1945 free_key_string(decryption_key_t *dk)
1946 {
1947     if (dk->key)
1948         g_string_free(dk->key, TRUE);
1949     if (dk->ssid)
1950         g_byte_array_free(dk->ssid, TRUE);
1951     g_free(dk);
1952 }
1953
1954 /*
1955  * Returns a newly allocated string representing the given decryption_key_t
1956  * struct, or NULL if something is wrong...
1957  */
1958 gchar*
1959 get_key_string(decryption_key_t* dk)
1960 {
1961     gchar* output_string = NULL;
1962
1963     if(dk == NULL || dk->key == NULL)
1964         return NULL;
1965
1966     switch(dk->type) {
1967         case AIRPDCAP_KEY_TYPE_WEP:
1968             output_string = g_strdup(dk->key->str);
1969             break;
1970         case AIRPDCAP_KEY_TYPE_WPA_PWD:
1971             if(dk->ssid == NULL)
1972                 output_string = g_strdup(dk->key->str);
1973             else
1974                 output_string = g_strdup_printf("%s:%s",
1975                     dk->key->str, format_uri(dk->ssid, ":"));
1976             break;
1977         case AIRPDCAP_KEY_TYPE_WPA_PMK:
1978             output_string = g_strdup(dk->key->str);
1979             break;
1980         default:
1981             return NULL;
1982     }
1983
1984     return output_string;
1985 }
1986
1987 #ifdef __cplusplus
1988 }
1989 #endif
1990
1991 /****************************************************************************/
1992
1993 /*
1994  * Editor modelines
1995  *
1996  * Local Variables:
1997  * c-basic-offset: 4
1998  * tab-width: 8
1999  * indent-tabs-mode: nil
2000  * End:
2001  *
2002  * ex: set shiftwidth=4 tabstop=8 expandtab:
2003  * :indentSize=4:tabSize=8:noTabs=true:
2004  */