4 * Copyright (c) 2006 CACE Technologies, Davis (California)
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the project nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * Alternatively, this software may be distributed under the terms of the
20 * GNU General Public License ("GPL") version 2 as published by the Free
21 * Software Foundation.
23 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 /****************************************************************************/
43 #include <epan/tvbuff.h>
44 #include <wsutil/crc32.h>
45 #include <epan/strutil.h>
46 #include <epan/emem.h>
47 #include <epan/pint.h>
48 #include <epan/crypt/rc4.h>
49 #include <epan/crypt/airpdcap_rijndael.h>
51 #include "airpdcap_system.h"
52 #include "airpdcap_int.h"
57 #include "airpdcap_debug.h"
59 #include "wep-wpadefs.h"
62 /****************************************************************************/
64 /****************************************************************************/
65 /* Constant definitions */
67 #define AIRPDCAP_SHA_DIGEST_LEN 20
69 /* EAPOL definitions */
71 * Length of the EAPOL-Key key confirmation key (KCK) used to calculate
72 * MIC over EAPOL frame and validate an EAPOL packet (128 bits)
74 #define AIRPDCAP_WPA_KCK_LEN 16
76 *Offset of the Key MIC in the EAPOL packet body
78 #define AIRPDCAP_WPA_MICKEY_OFFSET 77
80 * Maximum length of the EAPOL packet (it depends on the maximum MAC
83 #define AIRPDCAP_WPA_MAX_EAPOL_LEN 4095
85 * EAPOL Key Descriptor Version 1, used for all EAPOL-Key frames to and
86 * from a STA when neither the group nor pairwise ciphers are CCMP for
89 * Defined in 802.11i-2004, page 78
91 #define AIRPDCAP_WPA_KEY_VER_NOT_CCMP 1
93 * EAPOL Key Descriptor Version 2, used for all EAPOL-Key frames to and
94 * from a STA when either the pairwise or the group cipher is AES-CCMP
95 * for Key Descriptor 2.
97 * Defined in 802.11i-2004, page 78
99 #define AIRPDCAP_WPA_KEY_VER_AES_CCMP 2
101 /** Define EAPOL Key Descriptor type values: use 254 for WPA and 2 for WPA2 **/
102 #define AIRPDCAP_RSN_WPA_KEY_DESCRIPTOR 254
103 #define AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR 2
105 /****************************************************************************/
109 /****************************************************************************/
110 /* Macro definitions */
112 extern const UINT32 crc32_table[256];
113 #define CRC(crc, ch) (crc = (crc >> 8) ^ crc32_table[(crc ^ (ch)) & 0xff])
115 #define AIRPDCAP_GET_TK(ptk) (ptk + 32)
117 /****************************************************************************/
119 /****************************************************************************/
120 /* Type definitions */
122 /* Internal function prototype declarations */
129 * It is a step of the PBKDF2 (specifically the PKCS #5 v2.0) defined in
130 * the RFC 2898 to derive a key (used as PMK in WPA)
131 * @param password [IN] pointer to a password (sequence of between 8 and
132 * 63 ASCII encoded characters)
133 * @param ssid [IN] pointer to the SSID string encoded in max 32 ASCII
135 * @param iterations [IN] times to hash the password (4096 for WPA)
136 * @param count [IN] ???
137 * @param output [OUT] pointer to a preallocated buffer of
138 * AIRPDCAP_SHA_DIGEST_LEN characters that will contain a part of the key
140 static INT AirPDcapRsnaPwd2PskStep(
141 const guint8 *ppbytes,
142 const guint passLength,
144 const size_t ssidLength,
145 const INT iterations,
151 * It calculates the passphrase-to-PSK mapping reccomanded for use with
152 * RSNAs. This implementation uses the PBKDF2 method defined in the RFC
154 * @param password [IN] pointer to a password (sequence of between 8 and
155 * 63 ASCII encoded characters)
156 * @param ssid [IN] pointer to the SSID string encoded in max 32 ASCII
158 * @param output [OUT] calculated PSK (to use as PMK in WPA)
160 * Described in 802.11i-2004, page 165
162 static INT AirPDcapRsnaPwd2Psk(
163 const CHAR *passphrase,
165 const size_t ssidLength,
169 static INT AirPDcapRsnaMng(
171 guint mac_header_len,
173 PAIRPDCAP_KEY_ITEM key,
174 AIRPDCAP_SEC_ASSOCIATION *sa,
178 static INT AirPDcapWepMng(
179 PAIRPDCAP_CONTEXT ctx,
181 guint mac_header_len,
183 PAIRPDCAP_KEY_ITEM key,
184 AIRPDCAP_SEC_ASSOCIATION *sa,
188 static INT AirPDcapRsna4WHandshake(
189 PAIRPDCAP_CONTEXT ctx,
191 AIRPDCAP_SEC_ASSOCIATION *sa,
192 PAIRPDCAP_KEY_ITEM key,
196 * It checks whether the specified key is corrected or not.
198 * For a standard WEP key the length will be changed to the standard
199 * length, and the type changed in a generic WEP key.
200 * @param key [IN] pointer to the key to validate
202 * - TRUE: the key contains valid fields and values
203 * - FALSE: the key has some invalid field or value
205 static INT AirPDcapValidateKey(
206 PAIRPDCAP_KEY_ITEM key)
209 static INT AirPDcapRsnaMicCheck(
212 UCHAR KCK[AIRPDCAP_WPA_KCK_LEN],
217 * @param ctx [IN] pointer to the current context
218 * @param id [IN] id of the association (composed by BSSID and MAC of
221 * - index of the Security Association structure if found
222 * - -1, if the specified addresses pair BSSID-STA MAC has not been found
224 static INT AirPDcapGetSa(
225 PAIRPDCAP_CONTEXT ctx,
226 AIRPDCAP_SEC_ASSOCIATION_ID *id)
229 static INT AirPDcapStoreSa(
230 PAIRPDCAP_CONTEXT ctx,
231 AIRPDCAP_SEC_ASSOCIATION_ID *id)
234 static const UCHAR * AirPDcapGetStaAddress(
235 const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
238 static const UCHAR * AirPDcapGetBssidAddress(
239 const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
242 static void AirPDcapRsnaPrfX(
243 AIRPDCAP_SEC_ASSOCIATION *sa,
245 const UCHAR snonce[32],
246 const INT x, /* for TKIP 512, for CCMP 384 */
254 /****************************************************************************/
256 /****************************************************************************/
257 /* Exported function definitions */
263 const guint8 broadcast_mac[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
266 /* NOTE : this assumes the WPA RSN IE format. If it were to be a generic RSN IE, then
267 we would need to change the structure since it could be variable length depending on the number
268 of unicast OUI and auth OUI. */
274 guint8 multicastOUI[4];
275 guint16 iUnicastCount; /* this should always be 1 for WPA client */
276 guint8 unicastOUI[4];
277 guint16 iAuthCount; /* this should always be 1 for WPA client */
282 #define EAPKEY_MIC_LEN 16 /* length of the MIC key for EAPoL_Key packet's MIC using MD5 */
287 guint8 key_information[2]; /* Make this an array to avoid alignment issues */
288 guint8 key_length[2]; /* Make this an array to avoid alignment issues */
289 guint8 replay_counter[8];
290 guint8 key_nonce[NONCE_LEN];
292 guint8 key_sequence_counter[8]; /* also called the RSC */
294 guint8 key_mic[EAPKEY_MIC_LEN];
295 guint8 key_data_len[2]; /* Make this an array rather than a U16 to avoid alignment shifting */
296 guint8 ie[sizeof(RSN_IE)]; /* Make this an array to avoid alignment issues */
297 } EAPOL_RSN_KEY, * P_EAPOL_RSN_KEY;
301 /* A note about some limitations with the WPA decryption:
303 Unless someone takes the time to restructure the current method used for maintaining decryption keys, there
304 will be some anomalies observed when using the decryption feature.
306 Currently, there is only one pairwise (unicast) key and one group (broadcast) key saved for each security association
307 (SA). As a result, if a wireless sniffer session captures the traffic of a station (STA) associating with an AP
308 more than once, or captures a STA roaming, then you will not be able to arbitrarilly click on different encrypted
309 packets in the trace and observe their internal decrypted structure. This is because when you click on a packet,
310 Wireshark immediately performs the decryption routine with whatever the last key used was. It does not maintain a
311 cache of all the keys that were used by this STA/AP pairing.
313 However, if you are just looking at the summary lines of a capture, it will appear that everything was decrypted properly.
314 This is because when first performing a capture or initially reading a capture file, Wireshark will first
315 process the packets in order. As it encounters new EAPOL packets, it will update its internal key list with the
316 newfound key. Then it will use that key for decrypting subsequent packets. Each time a new key is found, the old key
317 is overwritten. So, if you then click on a packet that was previously decrypted properly, it might suddenly no longer
318 be decrypted because a later EAPOL key had caused the internal decryption key to be updated.
320 For broadcast packets, there is a clunky work-around. If the AP is using group-key rotation, you simply have to find the appropriate
321 EAPOL group key packet (usually size is 211 bytes and will have a protocol type of EAPOL and Info field of Key). If you click on it
322 and then click on the broadcast packet you are trying to decrypt, the packet will be decrypted properly. By first
323 clicking on the EAPOL packet for the group-key, you will force Wireshark to parse that packet and load the group-key it
324 contains. That group key will then be used for decrypting all subsequent broadcast packets you click on.
326 Ideally, it would be best to maintain an expanding list of SA keys. Perhaps we could associate packet number ranges
327 that they apply to. Then, whenever we need to decrypt a packet, we can determine which key to use based on whether
328 it is broadcast or unicast and within what packet number range it falls.
330 Either that, or store two versions of encrypted packets - the orginal packet and it's successfully
331 decrypted version. Then Wireshark wouldn't have to decrypt packets on the fly if they were already successfully decrypted.
337 AirPDcapDecryptWPABroadcastKey(const EAPOL_RSN_KEY *pEAPKey, guint8 *decryption_key, PAIRPDCAP_SEC_ASSOCIATION sa)
341 guint8 *szEncryptedKey;
343 static AIRPDCAP_KEY_ITEM dummy_key; /* needed in case AirPDcapRsnaMng() wants the key structure */
345 /* 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. */
347 /* Preparation for decrypting the group key - determine group key data length */
348 /* depending on whether it's a TKIP or AES encryption key */
349 key_version = AIRPDCAP_EAP_KEY_DESCR_VER(pEAPKey->key_information[1]);
350 if (key_version == AIRPDCAP_WPA_KEY_VER_NOT_CCMP){
352 key_len = pntohs(pEAPKey->key_length);
353 }else if (key_version == AIRPDCAP_WPA_KEY_VER_AES_CCMP){
355 key_len = pntohs(pEAPKey->key_data_len);
357 if (key_len > sizeof(RSN_IE) || key_len == 0) { /* Don't read past the end of pEAPKey->ie */
361 /* Encrypted key is in the information element field of the EAPOL key packet */
362 szEncryptedKey = (guint8 *)g_memdup(pEAPKey->ie, key_len);
364 DEBUG_DUMP("Encrypted Broadcast key:", szEncryptedKey, key_len);
365 DEBUG_DUMP("KeyIV:", pEAPKey->key_iv, 16);
366 DEBUG_DUMP("decryption_key:", decryption_key, 16);
368 /* Build the full decryption key based on the IV and part of the pairwise key */
369 memcpy(new_key, pEAPKey->key_iv, 16);
370 memcpy(new_key+16, decryption_key, 16);
371 DEBUG_DUMP("FullDecrKey:", new_key, 32);
373 if (key_version == AIRPDCAP_WPA_KEY_VER_NOT_CCMP){
376 /* Per 802.11i, Draft 3.0 spec, section 8.5.2, p. 97, line 4-8, */
377 /* group key is decrypted using RC4. Concatenate the IV with the 16 byte EK (PTK+16) to get the decryption key */
379 rc4_state_struct rc4_state;
380 crypt_rc4_init(&rc4_state, new_key, sizeof(new_key));
382 /* Do dummy 256 iterations of the RC4 algorithm (per 802.11i, Draft 3.0, p. 97 line 6) */
383 crypt_rc4(&rc4_state, dummy, 256);
384 crypt_rc4(&rc4_state, szEncryptedKey, key_len);
386 } else if (key_version == AIRPDCAP_WPA_KEY_VER_AES_CCMP){
391 guint8 *decrypted_data;
393 /* This storage is needed for the AES_unwrap function */
394 decrypted_data = (guint8 *) g_malloc(key_len);
396 AES_unwrap(decryption_key, 16, szEncryptedKey, key_len, decrypted_data);
398 /* With WPA2 what we get after Broadcast Key decryption is an actual RSN structure.
399 The key itself is stored as a GTK KDE
400 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
401 pass pointer to the actual key with 8 bytes offset */
405 while(key_index < key_len && !key_found){
409 rsn_id = decrypted_data[key_index];
412 key_index += decrypted_data[key_index+1]+2;
419 /* Skip over the GTK header info, and don't copy past the end of the encrypted data */
420 memcpy(szEncryptedKey, decrypted_data+key_index+8, key_len-key_index-8);
423 g_free(decrypted_data);
426 /* Decrypted key is now in szEncryptedKey with len of key_len */
427 DEBUG_DUMP("Broadcast key:", szEncryptedKey, key_len);
429 /* Load the proper key material info into the SA */
430 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 */
432 sa->wpa.key_ver = key_version;
434 /* Since this is a GTK and it's 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 */
435 /* AirPDcapRsnaMng() function will extract the right piece of the GTK for decryption. (The first 16 bytes of the GTK are used for decryption.) */
436 memset(sa->wpa.ptk, 0, sizeof(sa->wpa.ptk));
437 memcpy(sa->wpa.ptk+32, szEncryptedKey, key_len);
438 g_free(szEncryptedKey);
442 /* Return a pointer the the requested SA. If it doesn't exist create it. */
443 static PAIRPDCAP_SEC_ASSOCIATION
445 PAIRPDCAP_CONTEXT ctx,
446 AIRPDCAP_SEC_ASSOCIATION_ID *id)
450 /* search for a cached Security Association for supplied BSSID and STA MAC */
451 if ((sa_index=AirPDcapGetSa(ctx, id))==-1) {
452 /* create a new Security Association if it doesn't currently exist */
453 if ((sa_index=AirPDcapStoreSa(ctx, id))==-1) {
457 /* get the Security Association structure */
458 return &ctx->sa[sa_index];
461 #define GROUP_KEY_PAYLOAD_LEN (8+4+sizeof(EAPOL_RSN_KEY))
462 static INT AirPDcapScanForGroupKey(
463 PAIRPDCAP_CONTEXT ctx,
465 const guint mac_header_len,
469 const UCHAR *address;
470 AIRPDCAP_SEC_ASSOCIATION_ID id;
472 PAIRPDCAP_SEC_ASSOCIATION sta_sa;
473 PAIRPDCAP_SEC_ASSOCIATION sa;
475 const guint8 dot1x_header[] = {
476 0xAA, /* DSAP=SNAP */
477 0xAA, /* SSAP=SNAP */
478 0x03, /* Control field=Unnumbered frame */
479 0x00, 0x00, 0x00, /* Org. code=encaps. Ethernet */
480 0x88, 0x8E /* Type: 802.1X authentication */
483 const EAPOL_RSN_KEY *pEAPKey;
488 AIRPDCAP_DEBUG_TRACE_START("AirPDcapScanForGroupKey");
490 if (mac_header_len + GROUP_KEY_PAYLOAD_LEN < tot_len) {
491 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "Message too short", AIRPDCAP_DEBUG_LEVEL_3);
492 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
495 /* cache offset in the packet data */
496 offset = mac_header_len;
498 /* check if the packet has an LLC header and the packet is 802.1X authentication (IEEE 802.1X-2004, pg. 24) */
499 if (memcmp(data+offset, dot1x_header, 8) == 0) {
501 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "Authentication: EAPOL packet", AIRPDCAP_DEBUG_LEVEL_3);
503 /* skip LLC header */
507 /* check if the packet is a EAPOL-Key (0x03) (IEEE 802.1X-2004, pg. 25) */
508 if (data[offset+1]!=3) {
509 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "Not EAPOL-Key", AIRPDCAP_DEBUG_LEVEL_3);
510 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
513 /* get and check the body length (IEEE 802.1X-2004, pg. 25) */
514 bodyLength=pntohs(data+offset+2);
515 if ((tot_len-offset-4) < bodyLength) {
516 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "EAPOL body too short", AIRPDCAP_DEBUG_LEVEL_3);
517 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
520 /* skip EAPOL MPDU and go to the first byte of the body */
523 pEAPKey = (const EAPOL_RSN_KEY *) (data+offset);
525 /* check if the key descriptor type is valid (IEEE 802.1X-2004, pg. 27) */
526 if (/*pEAPKey->type!=0x1 &&*/ /* RC4 Key Descriptor Type (deprecated) */
527 pEAPKey->type != AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR && /* IEEE 802.11 Key Descriptor Type (WPA2) */
528 pEAPKey->type != AIRPDCAP_RSN_WPA_KEY_DESCRIPTOR) /* 254 = RSN_KEY_DESCRIPTOR - WPA, */
530 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "Not valid key descriptor type", AIRPDCAP_DEBUG_LEVEL_3);
531 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
534 /* start with descriptor body */
537 /* Verify the bitfields: Key = 0(groupwise) Mic = 1 Ack = 1 Secure = 1 */
538 if (AIRPDCAP_EAP_KEY(data[offset+1])!=0 ||
539 AIRPDCAP_EAP_ACK(data[offset+1])!=1 ||
540 AIRPDCAP_EAP_MIC(data[offset]) != 1 ||
541 AIRPDCAP_EAP_SEC(data[offset]) != 1){
543 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "Key bitfields not correct", AIRPDCAP_DEBUG_LEVEL_3);
544 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
548 if ( (address=AirPDcapGetBssidAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
549 memcpy(id.bssid, address, AIRPDCAP_MAC_LEN);
551 sprintf(msgbuf, "BSSID: %2X.%2X.%2X.%2X.%2X.%2X\t", id.bssid[0],id.bssid[1],id.bssid[2],id.bssid[3],id.bssid[4],id.bssid[5]);
553 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
555 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "BSSID not found", AIRPDCAP_DEBUG_LEVEL_5);
556 return AIRPDCAP_RET_REQ_DATA;
559 /* force STA address to be the broadcast MAC so we create an SA for the groupkey */
560 memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
562 /* get the Security Association structure for the broadcast MAC and AP */
563 sa = AirPDcapGetSaPtr(ctx, &id);
565 return AIRPDCAP_RET_UNSUCCESS;
568 /* Get the SA for the STA, since we need its pairwise key to decrpyt the group key */
570 /* get STA address */
571 if ( (address=AirPDcapGetStaAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
572 memcpy(id.sta, address, AIRPDCAP_MAC_LEN);
574 sprintf(msgbuf, "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]);
576 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
578 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "SA not found", AIRPDCAP_DEBUG_LEVEL_5);
579 return AIRPDCAP_RET_REQ_DATA;
582 sta_sa = AirPDcapGetSaPtr(ctx, &id);
584 return AIRPDCAP_RET_UNSUCCESS;
587 /* Extract the group key and install it in the SA */
588 AirPDcapDecryptWPABroadcastKey(pEAPKey, sta_sa->wpa.ptk+16, sa);
591 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapScanForGroupKey", "Skipping: not an EAPOL packet", AIRPDCAP_DEBUG_LEVEL_3);
594 AIRPDCAP_DEBUG_TRACE_END("AirPDcapScanForGroupKey");
599 INT AirPDcapPacketProcess(
600 PAIRPDCAP_CONTEXT ctx,
602 const guint mac_header_len,
606 PAIRPDCAP_KEY_ITEM key,
607 gboolean mngHandshake,
610 const UCHAR *address;
611 AIRPDCAP_SEC_ASSOCIATION_ID id;
612 PAIRPDCAP_SEC_ASSOCIATION sa;
615 const guint8 dot1x_header[] = {
616 0xAA, /* DSAP=SNAP */
617 0xAA, /* SSAP=SNAP */
618 0x03, /* Control field=Unnumbered frame */
619 0x00, 0x00, 0x00, /* Org. code=encaps. Ethernet */
620 0x88, 0x8E /* Type: 802.1X authentication */
627 AIRPDCAP_DEBUG_TRACE_START("AirPDcapPacketProcess");
630 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
631 AIRPDCAP_DEBUG_TRACE_END("AirPDcapPacketProcess");
632 return AIRPDCAP_RET_UNSUCCESS;
634 if (data==NULL || tot_len==0) {
635 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "NULL data or length=0", AIRPDCAP_DEBUG_LEVEL_5);
636 AIRPDCAP_DEBUG_TRACE_END("AirPDcapPacketProcess");
637 return AIRPDCAP_RET_UNSUCCESS;
640 /* check if the packet is of data type */
641 if (AIRPDCAP_TYPE(data[0])!=AIRPDCAP_TYPE_DATA) {
642 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "not data packet", AIRPDCAP_DEBUG_LEVEL_5);
643 return AIRPDCAP_RET_NO_DATA;
646 /* check correct packet size, to avoid wrong elaboration of encryption algorithms */
647 if (tot_len < (UINT)(mac_header_len+AIRPDCAP_CRYPTED_DATA_MINLEN)) {
648 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "minimum length violated", AIRPDCAP_DEBUG_LEVEL_5);
649 return AIRPDCAP_RET_WRONG_DATA_SIZE;
653 if ( (address=AirPDcapGetBssidAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
654 memcpy(id.bssid, address, AIRPDCAP_MAC_LEN);
656 sprintf(msgbuf, "BSSID: %2X.%2X.%2X.%2X.%2X.%2X\t", id.bssid[0],id.bssid[1],id.bssid[2],id.bssid[3],id.bssid[4],id.bssid[5]);
658 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
660 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "BSSID not found", AIRPDCAP_DEBUG_LEVEL_5);
661 return AIRPDCAP_RET_REQ_DATA;
664 /* get STA address */
665 if ( (address=AirPDcapGetStaAddress((const AIRPDCAP_MAC_FRAME_ADDR4 *)(data))) != NULL) {
666 memcpy(id.sta, address, AIRPDCAP_MAC_LEN);
668 sprintf(msgbuf, "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]);
670 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
672 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "SA not found", AIRPDCAP_DEBUG_LEVEL_5);
673 return AIRPDCAP_RET_REQ_DATA;
676 /* get the Security Association structure for the STA and AP */
677 sa = AirPDcapGetSaPtr(ctx, &id);
679 return AIRPDCAP_RET_UNSUCCESS;
682 /* cache offset in the packet data (to scan encryption data) */
683 offset = mac_header_len;
685 /* check if data is encrypted (use the WEP bit in the Frame Control field) */
686 if (AIRPDCAP_WEP(data[1])==0)
689 /* data is sent in cleartext, check if is an authentication message or end the process */
690 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Unencrypted data", AIRPDCAP_DEBUG_LEVEL_3);
692 /* check if the packet as an LLC header and the packet is 802.1X authentication (IEEE 802.1X-2004, pg. 24) */
693 if (memcmp(data+offset, dot1x_header, 8) == 0) {
694 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Authentication: EAPOL packet", AIRPDCAP_DEBUG_LEVEL_3);
696 /* skip LLC header */
699 /* check the version of the EAPOL protocol used (IEEE 802.1X-2004, pg. 24) */
700 /* TODO EAPOL protocol version to check? */
702 if (data[offset]!=2) {
703 AIRPDCAP_DEBUG_PRINT_LINE("EAPOL protocol version not recognized", AIRPDCAP_DEBUG_LEVEL_5);
704 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
708 /* check if the packet is a EAPOL-Key (0x03) (IEEE 802.1X-2004, pg. 25) */
709 if (data[offset+1]!=3) {
710 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Not EAPOL-Key", AIRPDCAP_DEBUG_LEVEL_5);
711 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
714 /* get and check the body length (IEEE 802.1X-2004, pg. 25) */
715 bodyLength=pntohs(data+offset+2);
716 if ((tot_len-offset-4) < bodyLength) {
717 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "EAPOL body too short", AIRPDCAP_DEBUG_LEVEL_5);
718 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
721 /* skip EAPOL MPDU and go to the first byte of the body */
724 /* check if the key descriptor type is valid (IEEE 802.1X-2004, pg. 27) */
725 if (/*data[offset]!=0x1 &&*/ /* RC4 Key Descriptor Type (deprecated) */
726 data[offset]!=0x2 && /* IEEE 802.11 Key Descriptor Type */
727 data[offset]!=0xFE) /* TODO what's this value??? */
729 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Not valid key descriptor type", AIRPDCAP_DEBUG_LEVEL_5);
730 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
733 /* start with descriptor body */
736 /* manage the 4-way handshake to define the key */
737 return AirPDcapRsna4WHandshake(ctx, data, sa, key, offset);
739 /* cleartext message, not authentication */
740 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "No authentication data", AIRPDCAP_DEBUG_LEVEL_5);
741 return AIRPDCAP_RET_NO_DATA_ENCRYPTED;
747 if (decrypt_data==NULL)
748 return AIRPDCAP_RET_UNSUCCESS;
750 /* create new header and data to modify */
751 *decrypt_len = tot_len;
752 memcpy(decrypt_data, data, *decrypt_len);
755 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "Encrypted data", AIRPDCAP_DEBUG_LEVEL_3);
757 /* check the Extension IV to distinguish between WEP encryption and WPA encryption */
758 /* refer to IEEE 802.11i-2004, 8.2.1.2, pag.35 for WEP, */
759 /* IEEE 802.11i-2004, 8.3.2.2, pag. 45 for TKIP, */
760 /* IEEE 802.11i-2004, 8.3.3.2, pag. 57 for CCMP */
761 if (AIRPDCAP_EXTIV(data[offset+3])==0) {
762 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "WEP encryption", AIRPDCAP_DEBUG_LEVEL_3);
763 return AirPDcapWepMng(ctx, decrypt_data, mac_header_len, decrypt_len, key, sa, offset);
766 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "TKIP or CCMP encryption", AIRPDCAP_DEBUG_LEVEL_3);
768 /* If index >= 1, then use the group key. This will not work if the AP is using
769 more than one group key simultaneously. I've not seen this in practice, however.
770 Usually an AP will rotate between the two key index values of 1 and 2 whenever
771 it needs to change the group key to be used. */
772 if (AIRPDCAP_KEY_INDEX(data[offset+3])>=1){
774 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", "The key index = 1. This is encrypted with a group key.", AIRPDCAP_DEBUG_LEVEL_3);
776 /* force STA address to broadcast MAC so we load the SA for the groupkey */
777 memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
780 sprintf(msgbuf, "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]);
781 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapPacketProcess", msgbuf, AIRPDCAP_DEBUG_LEVEL_3);
784 /* search for a cached Security Association for current BSSID and broadcast MAC */
785 sa = AirPDcapGetSaPtr(ctx, &id);
787 return AIRPDCAP_RET_UNSUCCESS;
791 /* Decrypt the packet using the appropriate SA */
792 status = AirPDcapRsnaMng(decrypt_data, mac_header_len, decrypt_len, key, sa, offset);
794 /* If we successfully decrypted a packet, scan it to see if it contains a group key handshake.
795 The group key handshake could be sent at any time the AP wants to change the key (such as when
796 it is using key rotation) so we must scan every packet. */
797 if (status == AIRPDCAP_RET_SUCCESS)
798 AirPDcapScanForGroupKey(ctx, decrypt_data, mac_header_len, *decrypt_len);
804 return AIRPDCAP_RET_UNSUCCESS;
808 PAIRPDCAP_CONTEXT ctx,
809 AIRPDCAP_KEY_ITEM keys[],
810 const size_t keys_nr)
814 AIRPDCAP_DEBUG_TRACE_START("AirPDcapSetKeys");
816 if (ctx==NULL || keys==NULL) {
817 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "NULL context or NULL keys array", AIRPDCAP_DEBUG_LEVEL_3);
818 AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
822 if (keys_nr>AIRPDCAP_MAX_KEYS_NR) {
823 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Keys number greater than maximum", AIRPDCAP_DEBUG_LEVEL_3);
824 AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
828 /* clean key and SA collections before setting new ones */
829 AirPDcapInitContext(ctx);
831 /* check and insert keys */
832 for (i=0, success=0; i<(INT)keys_nr; i++) {
833 if (AirPDcapValidateKey(keys+i)==TRUE) {
834 if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD) {
835 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WPA-PWD key", AIRPDCAP_DEBUG_LEVEL_4);
836 AirPDcapRsnaPwd2Psk(keys[i].UserPwd.Passphrase, keys[i].UserPwd.Ssid, keys[i].UserPwd.SsidLen, keys[i].KeyData.Wpa.Psk);
839 else if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK) {
840 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WPA-PMK key", AIRPDCAP_DEBUG_LEVEL_4);
841 } else if (keys[i].KeyType==AIRPDCAP_KEY_TYPE_WEP) {
842 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a WEP key", AIRPDCAP_DEBUG_LEVEL_4);
844 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapSetKeys", "Set a key", AIRPDCAP_DEBUG_LEVEL_4);
847 memcpy(&ctx->keys[success], &keys[i], sizeof(keys[i]));
852 ctx->keys_nr=success;
854 AIRPDCAP_DEBUG_TRACE_END("AirPDcapSetKeys");
860 PAIRPDCAP_CONTEXT ctx)
862 AIRPDCAP_DEBUG_TRACE_START("AirPDcapCleanKeys");
865 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapCleanKeys", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
866 AIRPDCAP_DEBUG_TRACE_END("AirPDcapCleanKeys");
870 memset(ctx->keys, 0, sizeof(AIRPDCAP_KEY_ITEM) * AIRPDCAP_MAX_KEYS_NR);
874 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapCleanKeys", "Keys collection cleaned!", AIRPDCAP_DEBUG_LEVEL_5);
875 AIRPDCAP_DEBUG_TRACE_END("AirPDcapCleanKeys");
879 const PAIRPDCAP_CONTEXT ctx,
880 AIRPDCAP_KEY_ITEM keys[],
881 const size_t keys_nr)
885 AIRPDCAP_DEBUG_TRACE_START("AirPDcapGetKeys");
888 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
889 AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
891 } else if (keys==NULL) {
892 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "NULL keys array", AIRPDCAP_DEBUG_LEVEL_5);
893 AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
894 return (INT)ctx->keys_nr;
896 for (i=0, j=0; i<ctx->keys_nr && i<keys_nr && i<AIRPDCAP_MAX_KEYS_NR; i++) {
897 memcpy(&keys[j], &ctx->keys[i], sizeof(keys[j]));
899 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapGetKeys", "Got a key", AIRPDCAP_DEBUG_LEVEL_5);
902 AIRPDCAP_DEBUG_TRACE_END("AirPDcapGetKeys");
908 * XXX - This won't be reliable if a packet containing SSID "B" shows
909 * up in the middle of a 4-way handshake for SSID "A".
910 * We should probably use a small array or hash table to keep multiple
913 INT AirPDcapSetLastSSID(
914 PAIRPDCAP_CONTEXT ctx,
918 if (!ctx || !pkt_ssid || pkt_ssid_len < 1 || pkt_ssid_len > WPA_SSID_MAX_SIZE)
919 return AIRPDCAP_RET_UNSUCCESS;
921 memcpy(ctx->pkt_ssid, pkt_ssid, pkt_ssid_len);
922 ctx->pkt_ssid_len = pkt_ssid_len;
924 return AIRPDCAP_RET_SUCCESS;
927 INT AirPDcapInitContext(
928 PAIRPDCAP_CONTEXT ctx)
930 AIRPDCAP_DEBUG_TRACE_START("AirPDcapInitContext");
933 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapInitContext", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
934 AIRPDCAP_DEBUG_TRACE_END("AirPDcapInitContext");
935 return AIRPDCAP_RET_UNSUCCESS;
938 AirPDcapCleanKeys(ctx);
940 ctx->first_free_index=0;
943 ctx->pkt_ssid_len = 0;
945 memset(ctx->sa, 0, AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR * sizeof(AIRPDCAP_SEC_ASSOCIATION));
947 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapInitContext", "Context initialized!", AIRPDCAP_DEBUG_LEVEL_5);
948 AIRPDCAP_DEBUG_TRACE_END("AirPDcapInitContext");
949 return AIRPDCAP_RET_SUCCESS;
952 INT AirPDcapDestroyContext(
953 PAIRPDCAP_CONTEXT ctx)
955 AIRPDCAP_DEBUG_TRACE_START("AirPDcapDestroyContext");
958 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapDestroyContext", "NULL context", AIRPDCAP_DEBUG_LEVEL_5);
959 AIRPDCAP_DEBUG_TRACE_END("AirPDcapDestroyContext");
960 return AIRPDCAP_RET_UNSUCCESS;
963 AirPDcapCleanKeys(ctx);
965 ctx->first_free_index=0;
969 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapDestroyContext", "Context destroyed!", AIRPDCAP_DEBUG_LEVEL_5);
970 AIRPDCAP_DEBUG_TRACE_END("AirPDcapDestroyContext");
971 return AIRPDCAP_RET_SUCCESS;
978 /****************************************************************************/
980 /****************************************************************************/
981 /* Internal function definitions */
990 guint mac_header_len,
992 PAIRPDCAP_KEY_ITEM key,
993 AIRPDCAP_SEC_ASSOCIATION *sa,
998 guint try_data_len = *decrypt_len;
1000 if (sa->key==NULL) {
1001 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "No key associated", AIRPDCAP_DEBUG_LEVEL_3);
1002 return AIRPDCAP_RET_REQ_DATA;
1004 if (sa->validKey==FALSE) {
1005 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Key not yet valid", AIRPDCAP_DEBUG_LEVEL_3);
1006 return AIRPDCAP_RET_UNSUCCESS;
1009 /* allocate a temp buffer for the decryption loop */
1010 try_data=(UCHAR *)ep_alloc(try_data_len);
1012 /* start of loop added by GCS */
1013 for(/* sa */; sa != NULL ;sa=sa->next) {
1015 if (*decrypt_len > try_data_len) {
1016 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Invalid decryption length", AIRPDCAP_DEBUG_LEVEL_3);
1017 return AIRPDCAP_RET_UNSUCCESS;
1020 /* copy the encrypted data into a temp buffer */
1021 memcpy(try_data, decrypt_data, *decrypt_len);
1023 if (sa->wpa.key_ver==1) {
1024 /* CCMP -> HMAC-MD5 is the EAPOL-Key MIC, RC4 is the EAPOL-Key encryption algorithm */
1025 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP", AIRPDCAP_DEBUG_LEVEL_3);
1026 DEBUG_DUMP("ptk", sa->wpa.ptk, 64);
1027 DEBUG_DUMP("ptk portion used", AIRPDCAP_GET_TK(sa->wpa.ptk), 16);
1029 ret_value=AirPDcapTkipDecrypt(try_data+offset, *decrypt_len-offset, try_data+AIRPDCAP_TA_OFFSET, AIRPDCAP_GET_TK(sa->wpa.ptk));
1031 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP failed!", AIRPDCAP_DEBUG_LEVEL_3);
1035 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "TKIP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1036 /* remove MIC (8bytes) and ICV (4bytes) from the end of packet */
1040 /* AES-CCMP -> HMAC-SHA1-128 is the EAPOL-Key MIC, AES wep_key wrap is the EAPOL-Key encryption algorithm */
1041 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "CCMP", AIRPDCAP_DEBUG_LEVEL_3);
1043 ret_value=AirPDcapCcmpDecrypt(try_data, mac_header_len, (INT)*decrypt_len, AIRPDCAP_GET_TK(sa->wpa.ptk));
1047 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "CCMP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1048 /* remove MIC (8bytes) from the end of packet */
1055 /* none of the keys worked */
1059 if (*decrypt_len > try_data_len || *decrypt_len < 8) {
1060 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsnaMng", "Invalid decryption length", AIRPDCAP_DEBUG_LEVEL_3);
1061 return AIRPDCAP_RET_UNSUCCESS;
1064 /* copy the decrypted data into the decrypt buffer GCS*/
1065 memcpy(decrypt_data, try_data, *decrypt_len);
1067 /* remove protection bit */
1068 decrypt_data[1]&=0xBF;
1070 /* remove TKIP/CCMP header */
1071 offset = mac_header_len;
1073 memmove(decrypt_data+offset, decrypt_data+offset+8, *decrypt_len-offset);
1076 memcpy(key, sa->key, sizeof(AIRPDCAP_KEY_ITEM));
1078 if (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP)
1079 key->KeyType=AIRPDCAP_KEY_TYPE_TKIP;
1080 else if (sa->wpa.key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP)
1081 key->KeyType=AIRPDCAP_KEY_TYPE_CCMP;
1084 return AIRPDCAP_RET_SUCCESS;
1089 PAIRPDCAP_CONTEXT ctx,
1090 UCHAR *decrypt_data,
1091 guint mac_header_len,
1093 PAIRPDCAP_KEY_ITEM key,
1094 AIRPDCAP_SEC_ASSOCIATION *sa,
1097 UCHAR wep_key[AIRPDCAP_WEP_KEY_MAXLEN+AIRPDCAP_WEP_IVLEN];
1101 AIRPDCAP_KEY_ITEM *tmp_key;
1102 UINT8 useCache=FALSE;
1104 guint try_data_len = *decrypt_len;
1106 try_data = (UCHAR *)ep_alloc(try_data_len);
1111 for (key_index=0; key_index<(INT)ctx->keys_nr; key_index++) {
1112 /* use the cached one, or try all keys */
1114 tmp_key=&ctx->keys[key_index];
1116 if (sa->key!=NULL && sa->key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1117 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Try cached WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1120 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Cached key is not valid, try another WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1121 tmp_key=&ctx->keys[key_index];
1125 /* obviously, try only WEP keys... */
1126 if (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WEP)
1128 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Try WEP key...", AIRPDCAP_DEBUG_LEVEL_3);
1130 memset(wep_key, 0, sizeof(wep_key));
1131 memcpy(try_data, decrypt_data, *decrypt_len);
1133 /* 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) */
1134 memcpy(wep_key, try_data+mac_header_len, AIRPDCAP_WEP_IVLEN);
1135 keylen=tmp_key->KeyData.Wep.WepKeyLen;
1136 memcpy(wep_key+AIRPDCAP_WEP_IVLEN, tmp_key->KeyData.Wep.WepKey, keylen);
1138 ret_value=AirPDcapWepDecrypt(wep_key,
1139 keylen+AIRPDCAP_WEP_IVLEN,
1140 try_data + (mac_header_len+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN),
1141 *decrypt_len-(mac_header_len+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN+AIRPDCAP_CRC_LEN));
1143 if (ret_value == AIRPDCAP_RET_SUCCESS)
1144 memcpy(decrypt_data, try_data, *decrypt_len);
1147 if (!ret_value && tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WEP) {
1148 /* the tried key is the correct one, cached in the Security Association */
1153 memcpy(key, &sa->key, sizeof(AIRPDCAP_KEY_ITEM));
1154 key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1159 /* the cached key was not valid, try other keys */
1161 if (useCache==TRUE) {
1171 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "WEP DECRYPTED!!!", AIRPDCAP_DEBUG_LEVEL_3);
1173 /* remove ICV (4bytes) from the end of packet */
1176 if (*decrypt_len < 4) {
1177 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapWepMng", "Decryption length too short", AIRPDCAP_DEBUG_LEVEL_3);
1178 return AIRPDCAP_RET_UNSUCCESS;
1181 /* remove protection bit */
1182 decrypt_data[1]&=0xBF;
1184 /* remove IC header */
1185 offset = mac_header_len;
1187 memcpy(decrypt_data+offset, decrypt_data+offset+AIRPDCAP_WEP_IVLEN+AIRPDCAP_WEP_KIDLEN, *decrypt_len-offset);
1189 return AIRPDCAP_RET_SUCCESS;
1192 /* Refer to IEEE 802.11i-2004, 8.5.3, pag. 85 */
1194 AirPDcapRsna4WHandshake(
1195 PAIRPDCAP_CONTEXT ctx,
1197 AIRPDCAP_SEC_ASSOCIATION *sa,
1198 PAIRPDCAP_KEY_ITEM key,
1201 AIRPDCAP_KEY_ITEM *tmp_key, pkt_key;
1202 AIRPDCAP_SEC_ASSOCIATION *tmp_sa;
1205 UCHAR useCache=FALSE;
1206 UCHAR eapol[AIRPDCAP_EAPOL_MAX_LEN];
1212 /* a 4-way handshake packet use a Pairwise key type (IEEE 802.11i-2004, pg. 79) */
1213 if (AIRPDCAP_EAP_KEY(data[offset+1])!=1) {
1214 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Group/STAKey message (not used)", AIRPDCAP_DEBUG_LEVEL_5);
1215 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1218 /* TODO timeouts? */
1220 /* This saves the sa since we are reauthenticating which will overwrite our current sa GCS*/
1221 if(sa->handshake == 4) {
1222 tmp_sa=(AIRPDCAP_SEC_ASSOCIATION *)se_alloc(sizeof(AIRPDCAP_SEC_ASSOCIATION));
1223 memcpy(tmp_sa, sa, sizeof(AIRPDCAP_SEC_ASSOCIATION));
1227 /* TODO consider key-index */
1229 /* TODO considera Deauthentications */
1231 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake...", AIRPDCAP_DEBUG_LEVEL_5);
1233 /* manage 4-way handshake packets; this step completes the 802.1X authentication process (IEEE 802.11i-2004, pag. 85) */
1235 /* message 1: Authenticator->Supplicant (Sec=0, Mic=0, Ack=1, Inst=0, Key=1(pairwise), KeyRSC=0, Nonce=ANonce, MIC=0) */
1236 if (AIRPDCAP_EAP_INST(data[offset+1])==0 &&
1237 AIRPDCAP_EAP_ACK(data[offset+1])==1 &&
1238 AIRPDCAP_EAP_MIC(data[offset])==0)
1240 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 1", AIRPDCAP_DEBUG_LEVEL_3);
1242 /* On reception of Message 1, the Supplicant determines whether the Key Replay Counter field value has been */
1243 /* used before with the current PMKSA. If the Key Replay Counter field value is less than or equal to the current */
1244 /* local value, the Supplicant discards the message. */
1245 /* -> not checked, the Authenticator will be send another Message 1 (hopefully!) */
1247 /* save ANonce (from authenticator) to derive the PTK with the SNonce (from the 2 message) */
1248 memcpy(sa->wpa.nonce, data+offset+12, 32);
1250 /* get the Key Descriptor Version (to select algorithm used in decryption -CCMP or TKIP-) */
1251 sa->wpa.key_ver=AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1]);
1255 return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1258 /* 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)) */
1259 if (AIRPDCAP_EAP_INST(data[offset+1])==0 &&
1260 AIRPDCAP_EAP_ACK(data[offset+1])==0 &&
1261 AIRPDCAP_EAP_MIC(data[offset])==1)
1263 if (AIRPDCAP_EAP_SEC(data[offset])==0) {
1265 /* PATCH: some implementations set secure bit to 0 also in the 4th message */
1266 /* to recognize which message is this check if wep_key data length is 0 */
1267 /* in the 4th message */
1268 if (data[offset+92]!=0 || data[offset+93]!=0) {
1270 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 2", AIRPDCAP_DEBUG_LEVEL_3);
1272 /* On reception of Message 2, the Authenticator checks that the key replay counter corresponds to the */
1273 /* outstanding Message 1. If not, it silently discards the message. */
1274 /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame, */
1275 /* the Authenticator silently discards Message 2. */
1276 /* -> not checked; the Supplicant will send another message 2 (hopefully!) */
1278 /* now you can derive the PTK */
1279 for (key_index=0; key_index<(INT)ctx->keys_nr || useCache; key_index++) {
1280 /* use the cached one, or try all keys */
1282 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Try WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1283 tmp_key=&ctx->keys[key_index];
1285 /* there is a cached key in the security association, if it's a WPA key try it... */
1286 if (sa->key!=NULL &&
1287 (sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1288 sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1289 sa->key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK)) {
1290 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Try cached WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1293 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "Cached key is of a wrong type, try WPA key...", AIRPDCAP_DEBUG_LEVEL_3);
1294 tmp_key=&ctx->keys[key_index];
1298 /* obviously, try only WPA keys... */
1299 if (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1300 tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1301 tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK)
1303 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) {
1304 /* We have a "wildcard" SSID. Use the one from the packet. */
1305 memcpy(&pkt_key, tmp_key, sizeof(pkt_key));
1306 memcpy(&pkt_key.UserPwd.Ssid, ctx->pkt_ssid, ctx->pkt_ssid_len);
1307 pkt_key.UserPwd.SsidLen = ctx->pkt_ssid_len;
1308 AirPDcapRsnaPwd2Psk(pkt_key.UserPwd.Passphrase, pkt_key.UserPwd.Ssid,
1309 pkt_key.UserPwd.SsidLen, pkt_key.KeyData.Wpa.Psk);
1313 /* derive the PTK from the BSSID, STA MAC, PMK, SNonce, ANonce */
1314 AirPDcapRsnaPrfX(sa, /* authenticator nonce, bssid, station mac */
1315 tmp_key->KeyData.Wpa.Pmk, /* PMK */
1316 data+offset+12, /* supplicant nonce */
1320 /* verify the MIC (compare the MIC in the packet included in this message with a MIC calculated with the PTK) */
1321 eapol_len=pntohs(data+offset-3)+4;
1322 memcpy(eapol, &data[offset-5], (eapol_len<AIRPDCAP_EAPOL_MAX_LEN?eapol_len:AIRPDCAP_EAPOL_MAX_LEN));
1323 ret_value=AirPDcapRsnaMicCheck(eapol, /* eapol frame (header also) */
1324 eapol_len, /* eapol frame length */
1325 sa->wpa.ptk, /* Key Confirmation Key */
1326 AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1])); /* EAPOL-Key description version */
1328 /* If the MIC is valid, the Authenticator checks that the RSN information element bit-wise matches */
1329 /* that from the (Re)Association Request message. */
1330 /* i) TODO If these are not exactly the same, the Authenticator uses MLME-DEAUTHENTICATE.request */
1331 /* primitive to terminate the association. */
1332 /* ii) If they do match bit-wise, the Authenticator constructs Message 3. */
1336 (tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PWD ||
1337 tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PSK ||
1338 tmp_key->KeyType==AIRPDCAP_KEY_TYPE_WPA_PMK))
1340 /* the temporary key is the correct one, cached in the Security Association */
1345 memcpy(key, &tmp_key, sizeof(AIRPDCAP_KEY_ITEM));
1346 if (AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1])==AIRPDCAP_WPA_KEY_VER_NOT_CCMP)
1347 key->KeyType=AIRPDCAP_KEY_TYPE_TKIP;
1348 else if (AIRPDCAP_EAP_KEY_DESCR_VER(data[offset+1])==AIRPDCAP_WPA_KEY_VER_AES_CCMP)
1349 key->KeyType=AIRPDCAP_KEY_TYPE_CCMP;
1354 /* the cached key was not valid, try other keys */
1356 if (useCache==TRUE) {
1364 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "handshake step failed", AIRPDCAP_DEBUG_LEVEL_3);
1365 return AIRPDCAP_RET_NO_VALID_HANDSHAKE;
1370 return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1374 /* TODO "Note that when the 4-Way Handshake is first used Message 4 is sent in the clear." */
1376 /* TODO check MIC and Replay Counter */
1377 /* On reception of Message 4, the Authenticator verifies that the Key Replay Counter field value is one */
1378 /* that it used on this 4-Way Handshake; if it is not, it silently discards the message. */
1379 /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame, the */
1380 /* Authenticator silently discards Message 4. */
1382 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 4 (patched)", AIRPDCAP_DEBUG_LEVEL_3);
1388 return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1395 /* TODO "Note that when the 4-Way Handshake is first used Message 4 is sent in the clear." */
1397 /* TODO check MIC and Replay Counter */
1398 /* On reception of Message 4, the Authenticator verifies that the Key Replay Counter field value is one */
1399 /* that it used on this 4-Way Handshake; if it is not, it silently discards the message. */
1400 /* If the calculated MIC does not match the MIC that the Supplicant included in the EAPOL-Key frame, the */
1401 /* Authenticator silently discards Message 4. */
1403 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 4", AIRPDCAP_DEBUG_LEVEL_3);
1409 return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1413 /* message 3: Authenticator->Supplicant (Sec=1, Mic=1, Ack=1, Inst=0/1, Key=1(pairwise), KeyRSC=???, Nonce=ANonce, MIC=1) */
1414 if (AIRPDCAP_EAP_ACK(data[offset+1])==1 &&
1415 AIRPDCAP_EAP_MIC(data[offset])==1)
1417 const EAPOL_RSN_KEY *pEAPKey;
1418 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapRsna4WHandshake", "4-way handshake message 3", AIRPDCAP_DEBUG_LEVEL_3);
1420 /* On reception of Message 3, the Supplicant silently discards the message if the Key Replay Counter field */
1421 /* value has already been used or if the ANonce value in Message 3 differs from the ANonce value in Message 1. */
1422 /* -> not checked, the Authenticator will send another message 3 (hopefully!) */
1424 /* TODO check page 88 (RNS) */
1426 /* If using WPA2 PSK, message 3 will contain an RSN for the group key (GTK KDE).
1427 In order to properly support decrypting WPA2-PSK packets, we need to parse this to get the group key. */
1428 pEAPKey = (const EAPOL_RSN_KEY *)(&(data[offset-1]));
1429 if (pEAPKey->type == AIRPDCAP_RSN_WPA2_KEY_DESCRIPTOR){
1430 PAIRPDCAP_SEC_ASSOCIATION broadcast_sa;
1431 AIRPDCAP_SEC_ASSOCIATION_ID id;
1433 /* Get broadcacst SA for the current BSSID */
1434 memcpy(id.sta, broadcast_mac, AIRPDCAP_MAC_LEN);
1435 memcpy(id.bssid, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1436 broadcast_sa = AirPDcapGetSaPtr(ctx, &id);
1438 if (broadcast_sa == NULL){
1439 return AIRPDCAP_RET_UNSUCCESS;
1441 AirPDcapDecryptWPABroadcastKey(pEAPKey, sa->wpa.ptk+16, broadcast_sa);
1444 return AIRPDCAP_RET_SUCCESS_HANDSHAKE;
1447 return AIRPDCAP_RET_UNSUCCESS;
1451 AirPDcapRsnaMicCheck(
1454 UCHAR KCK[AIRPDCAP_WPA_KCK_LEN],
1457 UCHAR mic[AIRPDCAP_WPA_MICKEY_LEN];
1458 UCHAR c_mic[20]; /* MIC 16 byte, the HMAC-SHA1 use a buffer of 20 bytes */
1460 /* copy the MIC from the EAPOL packet */
1461 memcpy(mic, eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, AIRPDCAP_WPA_MICKEY_LEN);
1463 /* set to 0 the MIC in the EAPOL packet (to calculate the MIC) */
1464 memset(eapol+AIRPDCAP_WPA_MICKEY_OFFSET+4, 0, AIRPDCAP_WPA_MICKEY_LEN);
1466 if (key_ver==AIRPDCAP_WPA_KEY_VER_NOT_CCMP) {
1467 /* use HMAC-MD5 for the EAPOL-Key MIC */
1468 md5_hmac(eapol, eapol_len, KCK, AIRPDCAP_WPA_KCK_LEN, c_mic);
1469 } else if (key_ver==AIRPDCAP_WPA_KEY_VER_AES_CCMP) {
1470 /* use HMAC-SHA1-128 for the EAPOL-Key MIC */
1471 sha1_hmac(KCK, AIRPDCAP_WPA_KCK_LEN, eapol, eapol_len, c_mic);
1473 /* key descriptor version not recognized */
1474 return AIRPDCAP_RET_UNSUCCESS;
1476 /* compare calculated MIC with the Key MIC and return result (0 means success) */
1477 return memcmp(mic, c_mic, AIRPDCAP_WPA_MICKEY_LEN);
1481 AirPDcapValidateKey(
1482 PAIRPDCAP_KEY_ITEM key)
1486 AIRPDCAP_DEBUG_TRACE_START("AirPDcapValidateKey");
1489 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "NULL key", AIRPDCAP_DEBUG_LEVEL_5);
1490 AIRPDCAP_DEBUG_TRACE_START("AirPDcapValidateKey");
1494 switch (key->KeyType) {
1495 case AIRPDCAP_KEY_TYPE_WEP:
1496 /* check key size limits */
1497 len=key->KeyData.Wep.WepKeyLen;
1498 if (len<AIRPDCAP_WEP_KEY_MINLEN || len>AIRPDCAP_WEP_KEY_MAXLEN) {
1499 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WEP key: key length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1504 case AIRPDCAP_KEY_TYPE_WEP_40:
1505 /* set the standard length and use a generic WEP key type */
1506 key->KeyData.Wep.WepKeyLen=AIRPDCAP_WEP_40_KEY_LEN;
1507 key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1510 case AIRPDCAP_KEY_TYPE_WEP_104:
1511 /* set the standard length and use a generic WEP key type */
1512 key->KeyData.Wep.WepKeyLen=AIRPDCAP_WEP_104_KEY_LEN;
1513 key->KeyType=AIRPDCAP_KEY_TYPE_WEP;
1516 case AIRPDCAP_KEY_TYPE_WPA_PWD:
1517 /* check passphrase and SSID size limits */
1518 len=strlen(key->UserPwd.Passphrase);
1519 if (len<AIRPDCAP_WPA_PASSPHRASE_MIN_LEN || len>AIRPDCAP_WPA_PASSPHRASE_MAX_LEN) {
1520 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WPA-PWD key: passphrase length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1524 len=key->UserPwd.SsidLen;
1525 if (len>AIRPDCAP_WPA_SSID_MAX_LEN) {
1526 AIRPDCAP_DEBUG_PRINT_LINE("AirPDcapValidateKey", "WPA-PWD key: ssid length not accepted", AIRPDCAP_DEBUG_LEVEL_5);
1532 case AIRPDCAP_KEY_TYPE_WPA_PSK:
1535 case AIRPDCAP_KEY_TYPE_WPA_PMK:
1542 AIRPDCAP_DEBUG_TRACE_END("AirPDcapValidateKey");
1548 PAIRPDCAP_CONTEXT ctx,
1549 AIRPDCAP_SEC_ASSOCIATION_ID *id)
1553 if (ctx->sa_index!=-1) {
1554 /* at least one association was stored */
1555 /* search for the association from sa_index to 0 (most recent added) */
1556 for (sa_index=ctx->sa_index; sa_index>=0; sa_index--) {
1557 if (ctx->sa[sa_index].used) {
1558 if (memcmp(id, &(ctx->sa[sa_index].saId), sizeof(AIRPDCAP_SEC_ASSOCIATION_ID))==0) {
1559 ctx->index=sa_index;
1571 PAIRPDCAP_CONTEXT ctx,
1572 AIRPDCAP_SEC_ASSOCIATION_ID *id)
1576 if (ctx->sa[ctx->first_free_index].used) {
1577 /* last addition was in the middle of the array (and the first_free_index was just incremented by 1) */
1578 /* search for a free space from the first_free_index to AIRPDCAP_STA_INFOS_NR (to avoid free blocks in */
1580 for (last_free=ctx->first_free_index; last_free<AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR; last_free++)
1581 if (!ctx->sa[last_free].used)
1584 if (last_free>=AIRPDCAP_MAX_SEC_ASSOCIATIONS_NR) {
1585 /* there is no empty space available. FAILURE */
1589 /* store first free space index */
1590 ctx->first_free_index=last_free;
1594 ctx->index=ctx->first_free_index;
1596 /* reset the info structure */
1597 memset(ctx->sa+ctx->index, 0, sizeof(AIRPDCAP_SEC_ASSOCIATION));
1599 ctx->sa[ctx->index].used=1;
1601 /* set the info structure */
1602 memcpy(&(ctx->sa[ctx->index].saId), id, sizeof(AIRPDCAP_SEC_ASSOCIATION_ID));
1604 /* increment by 1 the first_free_index (heuristic) */
1605 ctx->first_free_index++;
1607 /* set the sa_index if the added index is greater the the sa_index */
1608 if (ctx->index > ctx->sa_index)
1609 ctx->sa_index=ctx->index;
1615 * AirPDcapGetBssidAddress() and AirPDcapGetBssidAddress() are used for
1616 * key caching. In each case, it's more important to return a value than
1617 * to return a _correct_ value, so we fudge addresses in some cases, e.g.
1618 * the BSSID in bridged connections.
1619 * FromDS ToDS Sta BSSID
1626 static const UCHAR *
1627 AirPDcapGetStaAddress(
1628 const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
1630 switch(AIRPDCAP_DS_BITS(frame->fc[1])) { /* Bit 1 = FromDS, bit 0 = ToDS */
1634 return frame->addr2;
1636 return frame->addr1;
1642 static const UCHAR *
1643 AirPDcapGetBssidAddress(
1644 const AIRPDCAP_MAC_FRAME_ADDR4 *frame)
1646 switch(AIRPDCAP_DS_BITS(frame->fc[1])) { /* Bit 1 = FromDS, bit 0 = ToDS */
1648 return frame->addr3;
1651 return frame->addr1;
1653 return frame->addr2;
1659 /* Function used to derive the PTK. Refer to IEEE 802.11I-2004, pag. 74 */
1662 AIRPDCAP_SEC_ASSOCIATION *sa,
1663 const UCHAR pmk[32],
1664 const UCHAR snonce[32],
1665 const INT x, /* for TKIP 512, for CCMP 384 */
1670 INT offset=sizeof("Pairwise key expansion");
1674 memcpy(R, "Pairwise key expansion", offset);
1676 /* Min(AA, SPA) || Max(AA, SPA) */
1677 if (memcmp(sa->saId.sta, sa->saId.bssid, AIRPDCAP_MAC_LEN) < 0)
1679 memcpy(R + offset, sa->saId.sta, AIRPDCAP_MAC_LEN);
1680 memcpy(R + offset+AIRPDCAP_MAC_LEN, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1684 memcpy(R + offset, sa->saId.bssid, AIRPDCAP_MAC_LEN);
1685 memcpy(R + offset+AIRPDCAP_MAC_LEN, sa->saId.sta, AIRPDCAP_MAC_LEN);
1688 offset+=AIRPDCAP_MAC_LEN*2;
1690 /* Min(ANonce,SNonce) || Max(ANonce,SNonce) */
1691 if( memcmp(snonce, sa->wpa.nonce, 32) < 0 )
1693 memcpy(R + offset, snonce, 32);
1694 memcpy(R + offset + 32, sa->wpa.nonce, 32);
1698 memcpy(R + offset, sa->wpa.nonce, 32);
1699 memcpy(R + offset + 32, snonce, 32);
1704 for(i = 0; i < (x+159)/160; i++)
1707 sha1_hmac(pmk, 32, R, 100, ptk + i * 20);
1712 AirPDcapRsnaPwd2PskStep(
1713 const guint8 *ppBytes,
1714 const guint ppLength,
1716 const size_t ssidLength,
1717 const INT iterations,
1721 UCHAR digest[64], digest1[64];
1724 if (ssidLength+4 > 36)
1725 return AIRPDCAP_RET_UNSUCCESS;
1727 memset(digest, 0, 64);
1728 memset(digest1, 0, 64);
1730 /* U1 = PRF(P, S || INT(i)) */
1731 memcpy(digest, ssid, ssidLength);
1732 digest[ssidLength] = (UCHAR)((count>>24) & 0xff);
1733 digest[ssidLength+1] = (UCHAR)((count>>16) & 0xff);
1734 digest[ssidLength+2] = (UCHAR)((count>>8) & 0xff);
1735 digest[ssidLength+3] = (UCHAR)(count & 0xff);
1736 sha1_hmac(ppBytes, ppLength, digest, (guint32) ssidLength+4, digest1);
1739 memcpy(output, digest1, AIRPDCAP_SHA_DIGEST_LEN);
1740 for (i = 1; i < iterations; i++) {
1741 /* Un = PRF(P, Un-1) */
1742 sha1_hmac(ppBytes, ppLength, digest1, AIRPDCAP_SHA_DIGEST_LEN, digest);
1744 memcpy(digest1, digest, AIRPDCAP_SHA_DIGEST_LEN);
1745 /* output = output xor Un */
1746 for (j = 0; j < AIRPDCAP_SHA_DIGEST_LEN; j++) {
1747 output[j] ^= digest[j];
1751 return AIRPDCAP_RET_SUCCESS;
1755 AirPDcapRsnaPwd2Psk(
1756 const CHAR *passphrase,
1758 const size_t ssidLength,
1761 UCHAR m_output[AIRPDCAP_WPA_PSK_LEN];
1762 GByteArray *pp_ba = g_byte_array_new();
1764 memset(m_output, 0, AIRPDCAP_WPA_PSK_LEN);
1766 if (!uri_str_to_bytes(passphrase, pp_ba)) {
1767 g_byte_array_free(pp_ba, TRUE);
1771 AirPDcapRsnaPwd2PskStep(pp_ba->data, pp_ba->len, ssid, ssidLength, 4096, 1, m_output);
1772 AirPDcapRsnaPwd2PskStep(pp_ba->data, pp_ba->len, ssid, ssidLength, 4096, 2, &m_output[AIRPDCAP_SHA_DIGEST_LEN]);
1774 memcpy(output, m_output, AIRPDCAP_WPA_PSK_LEN);
1775 g_byte_array_free(pp_ba, TRUE);
1781 * Returns the decryption_key_t struct given a string describing the key.
1782 * Returns NULL if the input_string cannot be parsed.
1785 parse_key_string(gchar* input_string, guint8 key_type)
1790 GString *key_string = NULL;
1791 GByteArray *ssid_ba = NULL, *key_ba;
1796 decryption_key_t *dk;
1798 if(input_string == NULL)
1802 * Parse the input_string. WEP and WPA will be just a string
1803 * of hexadecimal characters (if key is wrong, null will be
1805 * WPA-PWD should be in the form
1806 * <key data>[:<ssid>]
1811 case AIRPDCAP_KEY_TYPE_WEP:
1812 case AIRPDCAP_KEY_TYPE_WEP_40:
1813 case AIRPDCAP_KEY_TYPE_WEP_104:
1815 key_ba = g_byte_array_new();
1816 res = hex_str_to_bytes(input_string, key_ba, FALSE);
1818 if (res && key_ba->len > 0) {
1819 /* Key is correct! It was probably an 'old style' WEP key */
1820 /* Create the decryption_key_t structure, fill it and return it*/
1821 dk = (decryption_key_t *)g_malloc(sizeof(decryption_key_t));
1823 dk->type = AIRPDCAP_KEY_TYPE_WEP;
1824 /* XXX - The current key handling code in the GUI requires
1825 * no separators and lower case */
1826 dk->key = g_string_new(bytes_to_str(key_ba->data, key_ba->len));
1827 g_string_ascii_down(dk->key);
1828 dk->bits = key_ba->len * 8;
1831 g_byte_array_free(key_ba, TRUE);
1835 /* Key doesn't work */
1836 g_byte_array_free(key_ba, TRUE);
1839 case AIRPDCAP_KEY_TYPE_WPA_PWD:
1841 tokens = g_strsplit(input_string,":",0);
1843 /* Tokens is a null termiated array of strings ... */
1844 while(tokens[n] != NULL)
1849 /* Free the array of strings */
1855 * The first token is the key
1857 key = g_strdup(tokens[0]);
1860 /* Maybe there is a second token (an ssid, if everything else is ok) */
1863 ssid = g_strdup(tokens[1]);
1866 /* Create a new string */
1867 key_string = g_string_new(key);
1870 /* Two (or more) tokens mean that the user entered a WPA-PWD key ... */
1871 if( ((key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((key_string->len) < WPA_KEY_MIN_CHAR_SIZE))
1873 g_string_free(key_string, TRUE);
1878 /* Free the array of strings */
1883 if(ssid != NULL) /* more than two tokens found, means that the user specified the ssid */
1885 ssid_ba = g_byte_array_new();
1886 if (! uri_str_to_bytes(ssid, ssid_ba)) {
1887 g_string_free(key_string, TRUE);
1888 g_byte_array_free(ssid_ba, TRUE);
1891 /* Free the array of strings */
1896 if(ssid_ba->len > WPA_SSID_MAX_CHAR_SIZE)
1898 g_string_free(key_string, TRUE);
1899 g_byte_array_free(ssid_ba, TRUE);
1904 /* Free the array of strings */
1910 /* Key was correct!!! Create the new decryption_key_t ... */
1911 dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1913 dk->type = AIRPDCAP_KEY_TYPE_WPA_PWD;
1914 dk->key = g_string_new(key);
1915 dk->bits = 256; /* This is the length of the array pf bytes that will be generated using key+ssid ...*/
1916 dk->ssid = byte_array_dup(ssid_ba); /* NULL if ssid_ba is NULL */
1918 g_string_free(key_string, TRUE);
1919 if (ssid_ba != NULL)
1920 g_byte_array_free(ssid_ba, TRUE);
1926 /* Free the array of strings */
1930 case AIRPDCAP_KEY_TYPE_WPA_PSK:
1932 key_ba = g_byte_array_new();
1933 res = hex_str_to_bytes(input_string, key_ba, FALSE);
1935 /* Two tokens means that the user should have entered a WPA-BIN key ... */
1936 if(!res || ((key_ba->len) != WPA_PSK_KEY_CHAR_SIZE))
1938 g_byte_array_free(key_ba, TRUE);
1940 /* No ssid has been created ... */
1944 /* Key was correct!!! Create the new decryption_key_t ... */
1945 dk = (decryption_key_t*)g_malloc(sizeof(decryption_key_t));
1947 dk->type = AIRPDCAP_KEY_TYPE_WPA_PMK;
1948 dk->key = g_string_new(input_string);
1949 dk->bits = (guint) dk->key->len * 4;
1952 g_byte_array_free(key_ba, TRUE);
1956 /* Type not supported */
1961 * Returns a newly allocated string representing the given decryption_key_t
1962 * struct, or NULL if something is wrong...
1965 get_key_string(decryption_key_t* dk)
1967 gchar* output_string = NULL;
1969 if(dk == NULL || dk->key == NULL)
1973 case AIRPDCAP_KEY_TYPE_WEP:
1974 output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WEP,dk->key->str);
1976 case AIRPDCAP_KEY_TYPE_WPA_PWD:
1977 if(dk->ssid == NULL)
1978 output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WPA_PWD,dk->key->str);
1980 output_string = g_strdup_printf("%s:%s:%s",
1981 STRING_KEY_TYPE_WPA_PWD, dk->key->str,
1982 format_uri(dk->ssid, ":"));
1984 case AIRPDCAP_KEY_TYPE_WPA_PMK:
1985 output_string = g_strdup_printf("%s:%s",STRING_KEY_TYPE_WPA_PSK,dk->key->str);
1991 return output_string;
1998 /****************************************************************************/
2006 * indent-tabs-mode: nil
2009 * ex: set shiftwidth=4 tabstop=8 expandtab:
2010 * :indentSize=4:tabSize=8:noTabs=true: