开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 其他 > 查看源码
airdecap.c
资源名称：1121aircrack-2.41.zip　[点击查看]
上传用户：fubang
上传日期：2009-06-18
资源大小：2071k
文件大小：34k
源码类别：

其他

开发平台：

Unix_Linux

airdecap.c：源码内容
  1. /*
  2.  *  802.11 to Ethernet pcap translator
  3.  *
  4.  *  Copyright (C) 2004,2005  Christophe Devine
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  */
  21. #include <unistd.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25. #include <time.h>
  27. #include "crctable.h"
  28. #include "crypto.h"
  29. #include "pcap.h"
  31. #define CRYPT_NONE 0
  32. #define CRYPT_WEP  1
  33. #define CRYPT_WPA  2
  35. const short Sbox[2][256]=
  36. {
  37.     {
  38.         0xC6A5, 0xF884, 0xEE99, 0xF68D, 0xFF0D, 0xD6BD, 0xDEB1, 0x9154,
  39.         0x6050, 0x0203, 0xCEA9, 0x567D, 0xE719, 0xB562, 0x4DE6, 0xEC9A,
  40.         0x8F45, 0x1F9D, 0x8940, 0xFA87, 0xEF15, 0xB2EB, 0x8EC9, 0xFB0B,
  41.         0x41EC, 0xB367, 0x5FFD, 0x45EA, 0x23BF, 0x53F7, 0xE496, 0x9B5B,
  42.         0x75C2, 0xE11C, 0x3DAE, 0x4C6A, 0x6C5A, 0x7E41, 0xF502, 0x834F,
  43.         0x685C, 0x51F4, 0xD134, 0xF908, 0xE293, 0xAB73, 0x6253, 0x2A3F,
  44.         0x080C, 0x9552, 0x4665, 0x9D5E, 0x3028, 0x37A1, 0x0A0F, 0x2FB5,
  45.         0x0E09, 0x2436, 0x1B9B, 0xDF3D, 0xCD26, 0x4E69, 0x7FCD, 0xEA9F,
  46.         0x121B, 0x1D9E, 0x5874, 0x342E, 0x362D, 0xDCB2, 0xB4EE, 0x5BFB,
  47.         0xA4F6, 0x764D, 0xB761, 0x7DCE, 0x527B, 0xDD3E, 0x5E71, 0x1397,
  48.         0xA6F5, 0xB968, 0x0000, 0xC12C, 0x4060, 0xE31F, 0x79C8, 0xB6ED,
  49.         0xD4BE, 0x8D46, 0x67D9, 0x724B, 0x94DE, 0x98D4, 0xB0E8, 0x854A,
  50.         0xBB6B, 0xC52A, 0x4FE5, 0xED16, 0x86C5, 0x9AD7, 0x6655, 0x1194,
  51.         0x8ACF, 0xE910, 0x0406, 0xFE81, 0xA0F0, 0x7844, 0x25BA, 0x4BE3,
  52.         0xA2F3, 0x5DFE, 0x80C0, 0x058A, 0x3FAD, 0x21BC, 0x7048, 0xF104,
  53.         0x63DF, 0x77C1, 0xAF75, 0x4263, 0x2030, 0xE51A, 0xFD0E, 0xBF6D,
  54.         0x814C, 0x1814, 0x2635, 0xC32F, 0xBEE1, 0x35A2, 0x88CC, 0x2E39,
  55.         0x9357, 0x55F2, 0xFC82, 0x7A47, 0xC8AC, 0xBAE7, 0x322B, 0xE695,
  56.         0xC0A0, 0x1998, 0x9ED1, 0xA37F, 0x4466, 0x547E, 0x3BAB, 0x0B83,
  57.         0x8CCA, 0xC729, 0x6BD3, 0x283C, 0xA779, 0xBCE2, 0x161D, 0xAD76,
  58.         0xDB3B, 0x6456, 0x744E, 0x141E, 0x92DB, 0x0C0A, 0x486C, 0xB8E4,
  59.         0x9F5D, 0xBD6E, 0x43EF, 0xC4A6, 0x39A8, 0x31A4, 0xD337, 0xF28B,
  60.         0xD532, 0x8B43, 0x6E59, 0xDAB7, 0x018C, 0xB164, 0x9CD2, 0x49E0,
  61.         0xD8B4, 0xACFA, 0xF307, 0xCF25, 0xCAAF, 0xF48E, 0x47E9, 0x1018,
  62.         0x6FD5, 0xF088, 0x4A6F, 0x5C72, 0x3824, 0x57F1, 0x73C7, 0x9751,
  63.         0xCB23, 0xA17C, 0xE89C, 0x3E21, 0x96DD, 0x61DC, 0x0D86, 0x0F85,
  64.         0xE090, 0x7C42, 0x71C4, 0xCCAA, 0x90D8, 0x0605, 0xF701, 0x1C12,
  65.         0xC2A3, 0x6A5F, 0xAEF9, 0x69D0, 0x1791, 0x9958, 0x3A27, 0x27B9,
  66.         0xD938, 0xEB13, 0x2BB3, 0x2233, 0xD2BB, 0xA970, 0x0789, 0x33A7,
  67.         0x2DB6, 0x3C22, 0x1592, 0xC920, 0x8749, 0xAAFF, 0x5078, 0xA57A,
  68.         0x038F, 0x59F8, 0x0980, 0x1A17, 0x65DA, 0xD731, 0x84C6, 0xD0B8,
  69.         0x82C3, 0x29B0, 0x5A77, 0x1E11, 0x7BCB, 0xA8FC, 0x6DD6, 0x2C3A
  70.     },
  71.     {
  72.         0xA5C6, 0x84F8, 0x99EE, 0x8DF6, 0x0DFF, 0xBDD6, 0xB1DE, 0x5491,
  73.         0x5060, 0x0302, 0xA9CE, 0x7D56, 0x19E7, 0x62B5, 0xE64D, 0x9AEC,
  74.         0x458F, 0x9D1F, 0x4089, 0x87FA, 0x15EF, 0xEBB2, 0xC98E, 0x0BFB,
  75.         0xEC41, 0x67B3, 0xFD5F, 0xEA45, 0xBF23, 0xF753, 0x96E4, 0x5B9B,
  76.         0xC275, 0x1CE1, 0xAE3D, 0x6A4C, 0x5A6C, 0x417E, 0x02F5, 0x4F83,
  77.         0x5C68, 0xF451, 0x34D1, 0x08F9, 0x93E2, 0x73AB, 0x5362, 0x3F2A,
  78.         0x0C08, 0x5295, 0x6546, 0x5E9D, 0x2830, 0xA137, 0x0F0A, 0xB52F,
  79.         0x090E, 0x3624, 0x9B1B, 0x3DDF, 0x26CD, 0x694E, 0xCD7F, 0x9FEA,
  80.         0x1B12, 0x9E1D, 0x7458, 0x2E34, 0x2D36, 0xB2DC, 0xEEB4, 0xFB5B,
  81.         0xF6A4, 0x4D76, 0x61B7, 0xCE7D, 0x7B52, 0x3EDD, 0x715E, 0x9713,
  82.         0xF5A6, 0x68B9, 0x0000, 0x2CC1, 0x6040, 0x1FE3, 0xC879, 0xEDB6,
  83.         0xBED4, 0x468D, 0xD967, 0x4B72, 0xDE94, 0xD498, 0xE8B0, 0x4A85,
  84.         0x6BBB, 0x2AC5, 0xE54F, 0x16ED, 0xC586, 0xD79A, 0x5566, 0x9411,
  85.         0xCF8A, 0x10E9, 0x0604, 0x81FE, 0xF0A0, 0x4478, 0xBA25, 0xE34B,
  86.         0xF3A2, 0xFE5D, 0xC080, 0x8A05, 0xAD3F, 0xBC21, 0x4870, 0x04F1,
  87.         0xDF63, 0xC177, 0x75AF, 0x6342, 0x3020, 0x1AE5, 0x0EFD, 0x6DBF,
  88.         0x4C81, 0x1418, 0x3526, 0x2FC3, 0xE1BE, 0xA235, 0xCC88, 0x392E,
  89.         0x5793, 0xF255, 0x82FC, 0x477A, 0xACC8, 0xE7BA, 0x2B32, 0x95E6,
  90.         0xA0C0, 0x9819, 0xD19E, 0x7FA3, 0x6644, 0x7E54, 0xAB3B, 0x830B,
  91.         0xCA8C, 0x29C7, 0xD36B, 0x3C28, 0x79A7, 0xE2BC, 0x1D16, 0x76AD,
  92.         0x3BDB, 0x5664, 0x4E74, 0x1E14, 0xDB92, 0x0A0C, 0x6C48, 0xE4B8,
  93.         0x5D9F, 0x6EBD, 0xEF43, 0xA6C4, 0xA839, 0xA431, 0x37D3, 0x8BF2,
  94.         0x32D5, 0x438B, 0x596E, 0xB7DA, 0x8C01, 0x64B1, 0xD29C, 0xE049,
  95.         0xB4D8, 0xFAAC, 0x07F3, 0x25CF, 0xAFCA, 0x8EF4, 0xE947, 0x1810,
  96.         0xD56F, 0x88F0, 0x6F4A, 0x725C, 0x2438, 0xF157, 0xC773, 0x5197,
  97.         0x23CB, 0x7CA1, 0x9CE8, 0x213E, 0xDD96, 0xDC61, 0x860D, 0x850F,
  98.         0x90E0, 0x427C, 0xC471, 0xAACC, 0xD890, 0x0506, 0x01F7, 0x121C,
  99.         0xA3C2, 0x5F6A, 0xF9AE, 0xD069, 0x9117, 0x5899, 0x273A, 0xB927,
  100.         0x38D9, 0x13EB, 0xB32B, 0x3322, 0xBBD2, 0x70A9, 0x8907, 0xA733,
  101.         0xB62D, 0x223C, 0x9215, 0x20C9, 0x4987, 0xFFAA, 0x7850, 0x7AA5,
  102.         0x8F03, 0xF859, 0x8009, 0x171A, 0xDA65, 0x31D7, 0xC684, 0xB8D0,
  103.         0xC382, 0xB029, 0x775A, 0x111E, 0xCB7B, 0xFCA8, 0xD66D, 0x3A2C
  104.     }
  105. };
  107. /* derive the PMK from the passphrase and the essid */
  109. void calc_pmk( char *key, char *essid, uchar pmk[40] )
  110. {
  111.     int i, j, slen;
  112.     uchar buffer[65];
  113.     sha1_context ctx_ipad;
  114.     sha1_context ctx_opad;
  115.     sha1_context sha1_ctx;
  117.     slen = strlen( essid ) + 4;
  119.     /* setup the inner and outer contexts */
  121.     memset( buffer, 0, sizeof( buffer ) );
  122.     strncpy( (char *) buffer, key, sizeof( buffer ) - 1 );
  124.     for( i = 0; i < 64; i++ )
  125.         buffer[i] ^= 0x36;
  127.     sha1_starts( &ctx_ipad );
  128.     sha1_update( &ctx_ipad, buffer, 64 );
  130.     for( i = 0; i < 64; i++ )
  131.         buffer[i] ^= 0x6A;
  133.     sha1_starts( &ctx_opad );
  134.     sha1_update( &ctx_opad, buffer, 64 );
  136.     /* iterate HMAC-SHA1 over itself 8192 times */
  138.     essid[slen - 1] = '1';
  139.     hmac_sha1( (uchar *) key, strlen( key ),
  140.                (uchar *) essid, slen, pmk );
  141.     memcpy( buffer, pmk, 20 );
  143.     for( i = 1; i < 4096; i++ )
  144.     {
  145.         memcpy( &sha1_ctx, &ctx_ipad, sizeof( sha1_ctx ) );
  146.         sha1_update( &sha1_ctx, buffer, 20 );
  147.         sha1_finish( &sha1_ctx, buffer );
  149.         memcpy( &sha1_ctx, &ctx_opad, sizeof( sha1_ctx ) );
  150.         sha1_update( &sha1_ctx, buffer, 20 );
  151.         sha1_finish( &sha1_ctx, buffer );
  153.         for( j = 0; j < 20; j++ )
  154.             pmk[j] ^= buffer[j];
  155.     }
  157.     essid[slen - 1] = '2';
  158.     hmac_sha1( (uchar *) key, strlen( key ),
  159.                (uchar *) essid, slen, pmk + 20 );
  160.     memcpy( buffer, pmk + 20, 20 );
  162.     for( i = 1; i < 4096; i++ )
  163.     {
  164.         memcpy( &sha1_ctx, &ctx_ipad, sizeof( sha1_ctx ) );
  165.         sha1_update( &sha1_ctx, buffer, 20 );
  166.         sha1_finish( &sha1_ctx, buffer );
  168.         memcpy( &sha1_ctx, &ctx_opad, sizeof( sha1_ctx ) );
  169.         sha1_update( &sha1_ctx, buffer, 20 );
  170.         sha1_finish( &sha1_ctx, buffer );
  172.         for( j = 0; j < 20; j++ )
  173.             pmk[j + 20] ^= buffer[j];
  174.     }
  175. }
  177. struct ST_info
  178. {
  179.     struct ST_info *next;       /* next supplicant              */
  180.     uchar stmac[6];             /* supplicant MAC               */
  181.     uchar bssid[6];             /* authenticator MAC            */
  182.     uchar snonce[32];           /* supplicant nonce             */
  183.     uchar anonce[32];           /* authenticator nonce          */
  184.     uchar keymic[20];           /* eapol frame MIC              */
  185.     uchar eapol[256];           /* eapol frame contents         */
  186.     uchar ptk[80];              /* pairwise transcient key      */
  187.     int eapol_size;             /* eapol frame size             */
  188.     unsigned long t_crc;        /* last ToDS   frame CRC        */
  189.     unsigned long f_crc;        /* last FromDS frame CRC        */
  190.     int keyver, valid_ptk;
  191. };
  193. /* derive the pairwise transcient keys from a bunch of stuff */
  195. int calc_ptk( struct ST_info *wpa, uchar pmk[32] )
  196. {
  197.     int i;
  198.     uchar pke[100];
  199.     uchar mic[20];
  201.     memcpy( pke, "Pairwise key expansion", 23 );
  203.     if( memcmp( wpa->stmac, wpa->bssid, 6 ) < 0 )
  204.     {
  205.         memcpy( pke + 23, wpa->stmac, 6 );
  206.         memcpy( pke + 29, wpa->bssid, 6 );
  207.     }
  208.     else
  209.     {
  210.         memcpy( pke + 23, wpa->bssid, 6 );
  211.         memcpy( pke + 29, wpa->stmac, 6 );
  212.     }
  214.     if( memcmp( wpa->snonce, wpa->anonce, 32 ) < 0 )
  215.     {
  216.         memcpy( pke + 35, wpa->snonce, 32 );
  217.         memcpy( pke + 67, wpa->anonce, 32 );
  218.     }
  219.     else
  220.     {
  221.         memcpy( pke + 35, wpa->anonce, 32 );
  222.         memcpy( pke + 67, wpa->snonce, 32 );
  223.     }
  225.     for( i = 0; i < 4; i++ )
  226.     {
  227.         pke[99] = i;
  228.         hmac_sha1( pmk, 32, pke, 100, wpa->ptk + i * 20 );
  229.     }
  231.     /* check the EAPOL frame MIC */
  233.     if( ( wpa->keyver & 0x07 ) == 1 )
  234.         hmac_md5(  wpa->ptk, 16, wpa->eapol, wpa->eapol_size, mic );
  235.     else
  236.         hmac_sha1( wpa->ptk, 16, wpa->eapol, wpa->eapol_size, mic );
  238.     return( memcmp( mic, wpa->keymic, 16 ) == 0 );
  239. }
  241. /* CRC checksum calculation routine */
  243. int calc_crc_buf( unsigned char *buf, int len )
  244. {
  245.     unsigned long crc = 0xFFFFFFFF;
  247.     for( ; len > 0; len--, buf++ )
  248.         crc = crc_tbl[(crc ^ *buf) & 0xFF] ^ ( crc >> 8 );
  250.     return( ~crc );
  251. }
  253. /* CRC checksum verification routine */
  255. int check_crc_buf( unsigned char *buf, int len )
  256. {
  257.     unsigned long crc = 0xFFFFFFFF;
  259.     for( ; len > 0; len--, buf++ )
  260.         crc = crc_tbl[(crc ^ *buf) & 0xFF] ^ ( crc >> 8 );
  262.     crc = ~crc;
  264.     return( ( ( crc       ) & 0xFF ) == buf[0] &&
  265.             ( ( crc >>  8 ) & 0xFF ) == buf[1] &&
  266.             ( ( crc >> 16 ) & 0xFF ) == buf[2] &&
  267.             ( ( crc >> 24 ) & 0xFF ) == buf[3] );
  268. }
  270. /* WEP (barebone RC4) decryption routine */
  272. int decrypt_wep( uchar *data, int len, uchar *key, int keylen )
  273. {
  274.     struct rc4_state S;
  276.     rc4_setup( &S, key, keylen );
  277.     rc4_crypt( &S, data, len );
  279.     return( check_crc_buf( data, len - 4 ) );
  280. }
  282. /* TKIP (RC4 + key mixing) decryption routine */
  284. #define ROTR1(x)      ((((x) >> 1) & 0x7FFF) ^ (((x) & 1) << 15))
  285. #define LO8(x)        ( (x) & 0x00FF )
  286. #define LO16(x)       ( (x) & 0xFFFF )
  287. #define HI8(x)        ( ((x) >>  8) & 0x00FF )
  288. #define HI16(x)       ( ((x) >> 16) & 0xFFFF )
  289. #define MK16(hi,lo)   ( (lo) ^ ( LO8(hi) << 8 ) )
  290. #define TK16(N)       MK16(TK1[2*(N)+1],TK1[2*(N)])
  291. #define _S_(x)        (Sbox[0][LO8(x)] ^ Sbox[1][HI8(x)])
  293. int decrypt_tkip( uchar *h80211, int caplen, uchar TK1[16] )
  294. {
  295.     int i, z;
  296.     uint IV32;
  297.     ushort IV16;
  298.     ushort PPK[6];
  299.     uchar K[16];
  301.     z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  303.     IV16 = MK16( h80211[z], h80211[z + 2] );
  305.     IV32 = ( h80211[z + 4]       ) | ( h80211[z + 5] <<  8 ) |
  306.            ( h80211[z + 6] << 16 ) | ( h80211[z + 7] << 24 );
  308.     PPK[0] = LO16( IV32 );
  309.     PPK[1] = HI16( IV32 );
  310.     PPK[2] = MK16( h80211[11], h80211[10] );
  311.     PPK[3] = MK16( h80211[13], h80211[12] );
  312.     PPK[4] = MK16( h80211[15], h80211[14] );
  314.     for( i = 0; i < 8; i++ )
  315.     {
  316.         PPK[0] += _S_( PPK[4] ^ TK16( (i & 1) + 0 ) );
  317.         PPK[1] += _S_( PPK[0] ^ TK16( (i & 1) + 2 ) );
  318.         PPK[2] += _S_( PPK[1] ^ TK16( (i & 1) + 4 ) );
  319.         PPK[3] += _S_( PPK[2] ^ TK16( (i & 1) + 6 ) );
  320.         PPK[4] += _S_( PPK[3] ^ TK16( (i & 1) + 0 ) ) + i;
  321.     }
  323.     PPK[5] = PPK[4] + IV16;
  325.     PPK[0] += _S_( PPK[5] ^ TK16(0) );
  326.     PPK[1] += _S_( PPK[0] ^ TK16(1) );
  327.     PPK[2] += _S_( PPK[1] ^ TK16(2) );
  328.     PPK[3] += _S_( PPK[2] ^ TK16(3) );
  329.     PPK[4] += _S_( PPK[3] ^ TK16(4) );
  330.     PPK[5] += _S_( PPK[4] ^ TK16(5) );
  332.     PPK[0] += ROTR1( PPK[5] ^ TK16(6) );
  333.     PPK[1] += ROTR1( PPK[0] ^ TK16(7) );
  334.     PPK[2] += ROTR1( PPK[1] );
  335.     PPK[3] += ROTR1( PPK[2] );
  336.     PPK[4] += ROTR1( PPK[3] );
  337.     PPK[5] += ROTR1( PPK[4] );
  339.     K[0] =   HI8( IV16 );
  340.     K[1] = ( HI8( IV16 ) | 0x20 ) & 0x7F;
  341.     K[2] =   LO8( IV16 );
  342.     K[3] =   LO8( (PPK[5] ^ TK16(0) ) >> 1);
  344.     for( i = 0; i < 6; i++ )
  345.     {
  346.         K[4 + ( 2 * i)] = LO8( PPK[i] );
  347.         K[5 + ( 2 * i)] = HI8( PPK[i] );
  348.     }
  350.     return( decrypt_wep( h80211 + z + 8, caplen - z - 8, K, 16 ) );
  351. }
  353. /* CCMP (AES-CTR-MAC) decryption routine */
  355. static inline void XOR( uchar *dst, uchar *src, int len )
  356. {
  357.     int i;
  358.     for( i = 0; i < len; i++ )
  359.         dst[i] ^= src[i];
  360. }
  362. int decrypt_ccmp( uchar *h80211, int caplen, uchar TK1[16] )
  363. {
  364.     int is_a4, i, n, z, blocks;
  365.     int data_len, last, offset;
  366.     uchar B0[16], B[16], MIC[16];
  367.     uchar PN[6], AAD[32];
  368.     aes_context aes_ctx;
  370.     is_a4 = ( h80211[0] & 3 ) == 3;
  372.     z = 24 + 6 * is_a4;
  374.     PN[0] = h80211[z + 7];
  375.     PN[1] = h80211[z + 6];
  376.     PN[2] = h80211[z + 5];
  377.     PN[3] = h80211[z + 4];
  378.     PN[4] = h80211[z + 1];
  379.     PN[5] = h80211[z + 0];
  381.     data_len = caplen - z - 8 - 8;
  383.     B0[0] = 0x59;
  384.     B0[1] = 0;
  385.     memcpy( B0 + 2, h80211 + 10, 6 );
  386.     memcpy( B0 + 8, PN, 6 );
  387.     B0[14] = ( data_len >> 8 ) & 0xFF;
  388.     B0[15] = ( data_len & 0xFF );
  390.     memset( AAD, 0, sizeof( AAD ) );
  392.     AAD[1] = 22 + 6 * is_a4;
  393.     AAD[2] = h80211[0] & 0x8F;
  394.     AAD[3] = h80211[1] & 0xC7;
  395.     memcpy( AAD + 4, h80211 + 4, 3 * 6 );
  396.     AAD[22] = h80211[22] & 0x0F;
  397.     if( is_a4 )
  398.         memcpy( AAD + 24, h80211 + 24, 6 );
  400.     aes_set_key( &aes_ctx, TK1, 128 );
  401.     aes_encrypt( &aes_ctx, B0, MIC );
  402.     XOR( MIC, AAD, 16 );
  403.     aes_encrypt( &aes_ctx, MIC, MIC );
  404.     XOR( MIC, AAD + 16, 16 );
  405.     aes_encrypt( &aes_ctx, MIC, MIC );
  407.     B0[0] &= 0x07;
  408.     B0[14] = B0[15] = 0;
  409.     aes_encrypt( &aes_ctx, B0, B );
  410.     XOR( h80211 + caplen - 8, B, 8 );
  412.     blocks = ( data_len + 16 - 1 ) / 16;
  413.     last = data_len % 16;
  414.     offset = z + 8;
  416.     for( i = 1; i <= blocks; i++ )
  417.     {
  418.         n = ( last > 0 && i == blocks ) ? last : 16;
  420.         B0[14] = ( i >> 8 ) & 0xFF;
  421.         B0[15] =   i & 0xFF;
  423.         aes_encrypt( &aes_ctx, B0, B );
  424.         XOR( h80211 + offset, B, n );
  425.         XOR( MIC, h80211 + offset, n );
  426.         aes_encrypt( &aes_ctx, MIC, MIC );
  428.         offset += n;
  429.     }
  431.     return( memcmp( h80211 + offset, MIC, 8 ) == 0 );
  432. }
  434. struct decap_stats
  435. {
  436.     unsigned long nb_read;      /* # of packets read       */
  437.     unsigned long nb_wep;       /* # of WEP data packets   */
  438.     unsigned long nb_wpa;       /* # of WPA data packets   */
  439.     unsigned long nb_plain;     /* # of plaintext packets  */
  440.     unsigned long nb_unwep;     /* # of decrypted WEP pkt  */
  441.     unsigned long nb_unwpa;     /* # of decrypted WPA pkt  */
  442. }
  443. stats;
  445. struct options
  446. {
  447.     int no_convert;
  448.     char essid[36];
  449.     char passphrase[65];
  450.     uchar bssid[6];
  451.     uchar pmk[40];
  452.     uchar wepkey[64];
  453.     int weplen, crypt;
  454. }
  455. opt;
  457. char usage[] =
  459. "n"
  460. "  airdecap %d.%d - (C) 2004,2005 Christophe Devinen"
  461. "n"
  462. "  usage: airdecap [options] <pcap file>n"
  463. "n"
  464. "      -l       : don't remove the 802.11 headern"
  465. "      -b bssid : access point MAC address filtern"
  466. "      -k pmk   : WPA Pairwise Master Key in hexn"
  467. "      -e essid : target network ascii identifiern"
  468. "      -p pass  : target network WPA passphrasen"
  469. "      -w key   : target network WEP key in hexn"
  470. "n"
  471. "  examples:n"
  472. "n"
  473. "  airdecap -b 00:09:5B:10:BC:5A open-network.capn"
  474. "  airdecap -w 11A3E229084349BC25D97E2939 wep.capn"
  475. "  airdecap -e my_essid -p my_passphrase tkip.capn"
  476. "n";
  478. uchar buffer[65536];
  480. /* this routine handles to 802.11 to Ethernet translation */
  482. int write_packet( FILE *f_out, struct pcap_pkthdr *pkh, uchar *h80211 )
  483. {
  484.     int n;
  485.     uchar arphdr[12];
  487.     if( opt.no_convert )
  488.     {
  489.         if( buffer != h80211 )
  490.             memcpy( buffer, h80211, pkh->caplen );
  491.     }
  492.     else
  493.     {
  494.         /* create the Ethernet link layer (MAC dst+src) */
  496.         switch( h80211[1] & 3 )
  497.         {
  498.             case  0:    /* To DS = 0, From DS = 0: DA, SA, BSSID */
  500.                 memcpy( arphdr + 0, h80211 +  4, 6 );
  501.                 memcpy( arphdr + 6, h80211 + 10, 6 );
  502.                 break;
  504.             case  1:    /* To DS = 1, From DS = 0: BSSID, SA, DA */
  506.                 memcpy( arphdr + 0, h80211 + 16, 6 );
  507.                 memcpy( arphdr + 6, h80211 + 10, 6 );
  508.                 break;
  510.             case  2:    /* To DS = 0, From DS = 1: DA, BSSID, SA */
  512.                 memcpy( arphdr + 0, h80211 +  4, 6 );
  513.                 memcpy( arphdr + 6, h80211 + 16, 6 );
  514.                 break;
  516.             default:    /* To DS = 1, From DS = 1: RA, TA, DA, SA */
  518.                 memcpy( arphdr + 0, h80211 + 16, 6 );
  519.                 memcpy( arphdr + 6, h80211 + 24, 6 );
  520.                 break;
  521.         }
  523.         /* remove the 802.11 + LLC header */
  525.         if( ( h80211[1] & 3 ) != 3 )
  526.         {
  527.             pkh->len    -= 24 + 6;
  528.             pkh->caplen -= 24 + 6;
  530.             memcpy( buffer + 12, h80211 + 30, pkh->caplen );
  531.         }
  532.         else
  533.         {
  534.             pkh->len    -= 30 + 6;
  535.             pkh->caplen -= 30 + 6;
  537.             memcpy( buffer + 12, h80211 + 36, pkh->caplen );
  538.         }
  540.         memcpy( buffer, arphdr, 12 );
  542.         pkh->len    += 12;
  543.         pkh->caplen += 12;
  544.     }
  546.     n = sizeof( struct pcap_pkthdr );
  548.     if( fwrite( pkh, 1, n, f_out ) != (size_t) n )
  549.     {
  550.         perror( "fwrite(packet header) failed" );
  551.         return( 1 );
  552.     }
  554.     n = pkh->caplen;
  556.     if( fwrite( buffer, 1, n, f_out ) != (size_t) n )
  557.     {
  558.         perror( "fwrite(packet data) failed" );
  559.         return( 1 );
  560.     }
  562.     return( 0 );
  563. }
  565. int main( int argc, char *argv[] )
  566. {
  567.     time_t tt;
  568.     uint magic;
  569.     char *s, buf[128];
  570.     FILE *f_in, *f_out;
  571.     unsigned long crc;
  572.     int i = 0, n, z, linktype;
  573.     uchar ZERO[32], *h80211;
  574.     uchar bssid[6], stmac[6];
  576.     struct ST_info *st_1st;
  577.     struct ST_info *st_cur;
  578.     struct ST_info *st_prv;
  579.     struct pcap_file_header pfh;
  580.     struct pcap_pkthdr pkh;    
  582.     /* parse the arguments */
  584.     memset( ZERO, 0, sizeof( ZERO ) );
  585.     memset( &opt, 0, sizeof( opt  ) );
  587.     while( 1 )
  588.     {
  589.         int option = getopt( argc, argv, "lb:k:e:p:w:" );
  591.         if( option < 0 ) break;
  593.         switch( option )
  594.         {
  595.             case 'l' :
  597.                 opt.no_convert = 1;
  598.                 break;
  600.             case 'b' :
  602.                 i = 0;
  603.                 s = optarg;
  605.                 while( sscanf( s, "%x", &n ) == 1 )
  606.                 {
  607.                     if( n < 0 || n > 255 )
  608.                     {
  609.                         printf( "Invalid BSSID (not a MAC).n" );
  610.                         return( 1 );
  611.                     }
  613.                     opt.bssid[i] = n;
  615.                     if( ++i > 6 ) break;
  617.                     if( ! ( s = strchr( s, ':' ) ) )
  618.                         break;
  620.                     s++;
  621.                 }
  623.                 if( i != 6 )
  624.                 {
  625.                     printf( "Invalid BSSID (not a MAC).n" );
  626.                     return( 1 );
  627.                 }
  629.                 break;
  631.             case 'k' :
  633.                 if( opt.crypt != CRYPT_NONE )
  634.                 {
  635.                     printf( "Encryption key already specified.n" );
  636.                     return( 1 );
  637.                 }
  639.                 opt.crypt = CRYPT_WPA;
  641.                 i = 0;
  642.                 s = optarg;
  644.                 buf[0] = s[0];
  645.                 buf[1] = s[1];
  646.                 buf[2] = '';
  648.                 while( sscanf( buf, "%x", &n ) == 1 )
  649.                 {
  650.                     if( n < 0 || n > 255 )
  651.                     {
  652.                         printf( "Invalid WPA PMK.n" );
  653.                         return( 1 );
  654.                     }
  656.                     opt.pmk[i++] = n;
  658.                     if( i >= 32 ) break;
  660.                     s += 2;
  662.                     if( s[0] == ':' || s[0] == '-' )
  663.                         s++;
  665.                     if( s[0] == '' || s[1] == '' )
  666.                         break;
  668.                     buf[0] = s[0];
  669.                     buf[1] = s[1];
  670.                 }
  672.                 if( i != 32 )
  673.                 {
  674.                     printf( "Invalid WPA PMK.n" );
  675.                     return( 1 );
  676.                 }
  678.                 break;
  680.             case 'e' :
  682.                 memset(  opt.essid, 0, sizeof( opt.essid ) );
  683.                 strncpy( opt.essid, optarg, sizeof( opt.essid ) - 1 );
  684.                 break;
  686.             case 'p' :
  688.                 if( opt.crypt != CRYPT_NONE )
  689.                 {
  690.                     printf( "Encryption key already specified.n" );
  691.                     return( 1 );
  692.                 }
  694.                 opt.crypt = CRYPT_WPA;
  696.                 memset(  opt.passphrase, 0, sizeof( opt.passphrase ) );
  697.                 strncpy( opt.passphrase, optarg, sizeof( opt.passphrase ) - 1 );
  698.                 break;
  700.             case 'w' :
  702.                 if( opt.crypt != CRYPT_NONE )
  703.                 {
  704.                     printf( "Encryption key already specified.n" );
  705.                     return( 1 );
  706.                 }
  708.                 opt.crypt = CRYPT_WEP;
  710.                 i = 0;
  711.                 s = optarg;
  713.                 buf[0] = s[0];
  714.                 buf[1] = s[1];
  715.                 buf[2] = '';
  717.                 while( sscanf( buf, "%x", &n ) == 1 )
  718.                 {
  719.                     if( n < 0 || n > 255 )
  720.                     {
  721.                         printf( "Invalid WEP key.n" );
  722.                         return( 1 );
  723.                     }
  725.                     opt.wepkey[i++] = n;
  727.                     if( i >= 64 ) break;
  729.                     s += 2;
  731.                     if( s[0] == ':' || s[0] == '-' )
  732.                         s++;
  734.                     if( s[0] == '' || s[1] == '' )
  735.                         break;
  737.                     buf[0] = s[0];
  738.                     buf[1] = s[1];
  739.                 }
  741.                 if( i != 5 && i != 13 && i != 16 && i != 29 && i != 61 )
  742.                 {
  743.                     printf( "Invalid WEP key length.n" );
  744.                     return( 1 );
  745.                 }
  747.                 opt.weplen = i;
  749.                 break;
  751.             default : goto usage;
  752.         }
  753.     }
  755.     if( argc - optind != 1 )
  756.     {
  757.     usage:
  758.         printf( usage, _MAJ, _MIN );
  759.         return( 1 );
  760.     }
  762.     if( opt.crypt == CRYPT_WPA )
  763.     {
  764.         if( opt.passphrase[0] != '' )
  765.         {
  766.             /* compute the Pairwise Master Key */
  768.             if( opt.essid[0] == '' )
  769.             {
  770.                 printf( "You must also specify the ESSID (-e).n" );
  771.                 return( 1 );
  772.             }
  774.             calc_pmk( opt.passphrase, opt.essid, opt.pmk );
  775.         }
  776.     }
  778.     /* open the input and output pcap files */
  780.     if( ( f_in = fopen( argv[optind], "rb" ) ) == NULL )
  781.     {
  782.         perror( "fopen failedn" );
  783.         printf( "Could not open "%s".n", argv[optind] );
  784.         return( 1 );
  785.     }
  787.     n = sizeof( pfh );
  789.     if( fread( &pfh, 1, n, f_in ) != (size_t) n )
  790.     {
  791.         perror( "fread(pcap file header) failed" );
  792.         return( 1 );
  793.     }
  795.     if( pfh.magic != TCPDUMP_MAGIC &&
  796.         pfh.magic != TCPDUMP_CIGAM )
  797.     {
  798.         printf( ""%s" isn't a pcap file (expected "
  799.                 "TCPDUMP_MAGIC).n", argv[optind] );
  800.         return( 1 );
  801.     }
  803.     if( ( magic = pfh.magic ) == TCPDUMP_CIGAM )
  804.         SWAP32( pfh.linktype );
  806.     if( pfh.linktype != LINKTYPE_IEEE802_11 &&
  807.         pfh.linktype != LINKTYPE_PRISM_HEADER &&
  808.         pfh.linktype != LINKTYPE_RADIOTAP_HDR )
  809.     {
  810.         printf( ""%s" isn't a regular 802.11 "
  811.                 "(wireless) capture.n", argv[optind] );
  812.         return( 1 );
  813.     }
  815.     linktype = pfh.linktype;
  817.     n = strlen( argv[optind] );
  819.     if( n > 4 && ( n + 5 < (int) sizeof( buffer ) ) &&
  820.         argv[optind][n - 4] == '.' )
  821.     {
  822.         memcpy( buffer, argv[optind], n - 4 );
  823.         memcpy( buffer + n - 4, "-dec", 4 );
  824.         memcpy( buffer + n, argv[optind] + n - 4, 5 );
  825.     }
  826.     else
  827.     {
  828.         if( n > 5 && ( n + 6 < (int) sizeof( buffer ) ) &&
  829.             argv[optind][n - 5] == '.' )
  830.         {
  831.             memcpy( buffer, argv[optind], n - 5 );
  832.             memcpy( buffer + n - 5, "-dec", 4 );
  833.             memcpy( buffer + n - 1, argv[optind] + n - 5, 6 );
  834.         }
  835.         else
  836.         {
  837.             memset( buffer, 0, sizeof( buffer ) );
  838.             snprintf( (char *) buffer, sizeof( buffer ) - 1,
  839.                       "%s-dec", argv[optind] );
  840.         }
  841.     }
  843.     if( ( f_out = fopen( (char *) buffer, "wb+" ) ) == NULL )
  844.     {
  845.         perror( "fopen failed" );
  846.         printf( "Could not create "%s".n", buffer );
  847.         return( 1 );
  848.     }
  850.     pfh.magic           = TCPDUMP_MAGIC;
  851.     pfh.version_major   = PCAP_VERSION_MAJOR;
  852.     pfh.version_minor   = PCAP_VERSION_MINOR;
  853.     pfh.thiszone        = 0;
  854.     pfh.sigfigs         = 0;
  855.     pfh.snaplen         = 65535;
  856.     pfh.linktype        = ( opt.no_convert ) ? 
  857.                             LINKTYPE_IEEE802_11 :
  858.                             LINKTYPE_ETHERNET;
  860.     n = sizeof( pfh );
  862.     if( fwrite( &pfh, 1, n, f_out ) != (size_t) n )
  863.     {
  864.         perror( "fwrite(pcap file header) failed" );
  865.         return( 1 );
  866.     }
  868.     /* loop reading and deciphering the packets */
  870.     memset( &stats, 0, sizeof( stats ) );
  871.     tt = time( NULL );
  872.     st_1st = NULL;
  874.     while( 1 )
  875.     {
  876.         if( time( NULL ) - tt > 0 )
  877.         {
  878.             /* update the status line every second */
  880.             printf( "33[KRead %ld packets...r", stats.nb_read );
  881.             fflush( stdout );
  882.             tt = time( NULL );
  883.         }
  885.         /* read one packet */
  887.         n = sizeof( pkh );
  889.         if( fread( &pkh, 1, n, f_in ) != (size_t) n )
  890.             break;
  892.         if( magic == TCPDUMP_CIGAM )
  893.             SWAP32( pkh.caplen );
  895.         n = pkh.caplen;
  897.         if( n <= 0 || n > 65535 )
  898.         {
  899.             printf( "Corrupted file? Invalid packet length %d.n", n );
  900.             break;
  901.         }
  903.         if( fread( buffer, 1, n, f_in ) != (size_t) n )
  904.             break;
  906.         stats.nb_read++;
  908.         h80211 = buffer;
  910.         if( linktype == LINKTYPE_PRISM_HEADER )
  911.         {
  912.             /* remove the prism header */
  914.             if( h80211[7] == 0x40 )
  915.                 n = 64; /* prism54 */
  916.             else
  917.             {
  918.                 n = *(int *)( h80211 + 4 );
  920.                 if( magic == TCPDUMP_CIGAM )
  921.                     SWAP32( n );
  922.             }
  924.             if( n < 8 || n >= (int) pkh.caplen )
  925.                 continue;
  927.             h80211 += n; pkh.caplen -= n;
  928.         }
  930.         if( linktype == LINKTYPE_RADIOTAP_HDR )
  931.         {
  932.             /* remove the radiotap header */
  934.             n = *(unsigned short *)( h80211 + 2 );
  936.             if( n <= 0 || n >= (int) pkh.caplen )
  937.                 continue;
  939.             h80211 += n; pkh.caplen -= n;
  940.         }
  942.         /* remove the FCS if present (madwifi) */
  944.         if( check_crc_buf( h80211, pkh.caplen - 4 ) == 1 )
  945.         {
  946.             pkh.len    -= 4;
  947.             pkh.caplen -= 4;
  948.         }
  950.         /* check if data */
  952.         if( ( h80211[0] & 0x0C ) != 0x08 )
  953.             continue;
  955.         /* check minimum size */
  957.         z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  959.         if( z + 16 > (int) pkh.caplen )
  960.             continue;
  962.         /* check the BSSID */
  964.         switch( h80211[0] & 3 )
  965.         {
  966.             case  0: memcpy( bssid, h80211 + 16, 6 ); break;
  967.             case  1: memcpy( bssid, h80211 +  4, 6 ); break;
  968.             case  2: memcpy( bssid, h80211 + 10, 6 ); break;
  969.             default: memcpy( bssid, h80211 +  4, 6 ); break;
  970.         }
  972.         if( memcmp( opt.bssid, ZERO, 6 ) != 0 )
  973.             if( memcmp( opt.bssid, bssid, 6 ) != 0 )
  974.                 continue;    
  976.         /* locate the station's MAC address */
  978.         switch( h80211[1] & 3 )
  979.         {
  980.             case  1: memcpy( stmac, h80211 + 10, 6 ); break;
  981.             case  2: memcpy( stmac, h80211 +  4, 6 ); break;
  982.             case  3: memcpy( stmac, h80211 + 10, 6 ); break;
  983.             default: continue;
  984.         }
  986.         st_prv = NULL;
  987.         st_cur = st_1st;
  989.         while( st_cur != NULL )
  990.         {
  991.             if( ! memcmp( st_cur->stmac, stmac, 6 ) )
  992.                 break;
  994.             st_prv = st_cur;
  995.             st_cur = st_cur->next;
  996.         }
  998.         /* if it's a new station, add it */
  1000.         if( st_cur == NULL )
  1001.         {
  1002.             if( ! ( st_cur = (struct ST_info *) malloc(
  1003.                              sizeof( struct ST_info ) ) ) )
  1004.             {
  1005.                 perror( "malloc failed" );
  1006.                 break;
  1007.             }
  1009.             memset( st_cur, 0, sizeof( struct ST_info ) );
  1011.             if( st_1st == NULL )
  1012.                 st_1st = st_cur;
  1013.             else
  1014.                 st_prv->next = st_cur;
  1016.             memcpy( st_cur->stmac, stmac, 6 );
  1017.             memcpy( st_cur->bssid, bssid, 6 );
  1018.         }
  1020.         /* check if we haven't already processed this packet */
  1022.         crc = calc_crc_buf( h80211 + z, pkh.caplen - z );
  1024.         if( ( h80211[1] & 3 ) == 2 )
  1025.         {
  1026.             if( st_cur->t_crc == crc )
  1027.                 continue;
  1029.             st_cur->t_crc = crc;
  1030.         }
  1031.         else
  1032.         {
  1033.             if( st_cur->f_crc == crc )
  1034.                 continue;
  1036.             st_cur->f_crc = crc;
  1037.         }
  1039.         /* check the SNAP header to see if data is encrypted *
  1040.          * as unencrypted data begins with AA AA 03 00 00 00 */
  1042.         if( h80211[z] != h80211[z + 1] || h80211[z + 2] != 0x03 )
  1043.         {
  1044.             /* check the extended IV flag */
  1046.             if( ( h80211[z + 3] & 0x20 ) == 0 )
  1047.             {
  1048.                 uchar K[64];
  1050.                 stats.nb_wep++;
  1052.                 if( opt.crypt != CRYPT_WEP )
  1053.                     continue;
  1055.                 memcpy( K, h80211 + z, 3 );
  1056.                 memcpy( K + 3, opt.wepkey, opt.weplen );
  1058.                 if( decrypt_wep( h80211 + z + 4, pkh.caplen - z - 4,
  1059.                                  K, 3 + opt.weplen ) == 0 )
  1060.                     continue;
  1062.                 /* WEP data packet was successfully decrypted, *
  1063.                  * remove the WEP IV & ICV and write the data  */
  1065.                 pkh.len    -= 8;
  1066.                 pkh.caplen -= 8;
  1068.                 memcpy( h80211 + z, h80211 + z + 4, pkh.caplen - z );
  1070.                 stats.nb_unwep++;
  1072.                 h80211[1] &= 0xBF;
  1074.                 if( write_packet( f_out, &pkh, h80211 ) != 0 )
  1075.                     break;
  1076.             }
  1077.             else
  1078.             {
  1079.                 stats.nb_wpa++;
  1081.                 if( opt.crypt != CRYPT_WPA )
  1082.                     continue;
  1084.                 /* if the PTK is valid, try to decrypt */
  1086.                 if( st_cur == NULL || ! st_cur->valid_ptk )
  1087.                     continue;
  1089.                 if( st_cur->keyver == 1 )
  1090.                 {
  1091.                     if( decrypt_tkip( h80211, pkh.caplen,
  1092.                                       st_cur->ptk + 32 ) == 0 )
  1093.                         continue;
  1095.                     pkh.len    -= 20;
  1096.                     pkh.caplen -= 20;
  1097.                 }
  1098.                 else
  1099.                 {
  1100.                     if( decrypt_ccmp( h80211, pkh.caplen,
  1101.                                       st_cur->ptk + 32 ) == 0 )
  1102.                         continue;
  1104.                     pkh.len    -= 16;
  1105.                     pkh.caplen -= 16;
  1106.                 }
  1108.                 /* WPA data packet was successfully decrypted, *
  1109.                  * remove the WPA Ext.IV & MIC, write the data */
  1111.                 memcpy( h80211 + z, h80211 + z + 8, pkh.caplen - z );
  1113.                 stats.nb_unwpa++;
  1115.                 h80211[1] &= 0xBF;
  1117.                 if( write_packet( f_out, &pkh, h80211 ) != 0 )
  1118.                     break;
  1119.             }
  1120.         }
  1121.         else
  1122.         {
  1123.             /* check ethertype == EAPOL */
  1125.             z += 6;
  1127.             if( h80211[z] != 0x88 || h80211[z + 1] != 0x8E )
  1128.             {
  1129.                 stats.nb_plain++;
  1131.                 if( opt.crypt != CRYPT_NONE )
  1132.                     continue;
  1134.                 if( write_packet( f_out, &pkh, h80211 ) != 0 )
  1135.                     break;
  1136.             }
  1138.             z += 2;
  1140.             /* type == 3 (key), desc. == 254 (WPA) or 2 (RSN) */
  1142.             if( h80211[z + 1] != 0x03 ||
  1143.                 ( h80211[z + 4] != 0xFE && h80211[z + 4] != 0x02 ) )
  1144.                 continue;
  1146.             /* frame 1: Pairwise == 1, Install == 0, Ack == 1, MIC == 0 */
  1148.             if( ( h80211[z + 6] & 0x08 ) != 0 &&
  1149.                 ( h80211[z + 6] & 0x40 ) == 0 &&
  1150.                 ( h80211[z + 6] & 0x80 ) != 0 &&
  1151.                 ( h80211[z + 5] & 0x01 ) == 0 )
  1152.             {
  1153.                 /* set authenticator nonce */
  1155.                 memcpy( st_cur->anonce, &h80211[z + 17], 32 );
  1156.             }
  1158.             /* frame 2 or 4: Pairwise == 1, Install == 0, Ack == 0, MIC == 1 */
  1160.             if( ( h80211[z + 6] & 0x08 ) != 0 &&
  1161.                 ( h80211[z + 6] & 0x40 ) == 0 &&
  1162.                 ( h80211[z + 6] & 0x80 ) == 0 &&
  1163.                 ( h80211[z + 5] & 0x01 ) != 0 )
  1164.             {
  1165.                 if( memcmp( &h80211[z + 17], ZERO, 32 ) != 0 )
  1166.                 {
  1167.                     /* set supplicant nonce */
  1169.                     memcpy( st_cur->snonce, &h80211[z + 17], 32 );
  1170.                 }
  1171.             }
  1173.             /* frame 3: Pairwise == 1, Install == 1, Ack == 1, MIC == 1 */
  1175.             if( ( h80211[z + 6] & 0x08 ) != 0 &&
  1176.                 ( h80211[z + 6] & 0x40 ) != 0 &&
  1177.                 ( h80211[z + 6] & 0x80 ) != 0 &&
  1178.                 ( h80211[z + 5] & 0x01 ) != 0 )
  1179.             {
  1180.                 if( memcmp( &h80211[z + 17], ZERO, 32 ) != 0 )
  1181.                 {
  1182.                     /* set authenticator nonce */
  1184.                     memcpy( st_cur->anonce, &h80211[z + 17], 32 );
  1185.                 }
  1187.                 /* copy the MIC & eapol frame */
  1189.                 st_cur->eapol_size = ( h80211[z + 2] << 8 )
  1190.                                    +   h80211[z + 3] + 4;
  1192.                 memcpy( st_cur->keymic, &h80211[z + 81], 16 );
  1193.                 memcpy( st_cur->eapol, &h80211[z], st_cur->eapol_size );
  1194.                 memset( st_cur->eapol + 81, 0, 16 );
  1196.                 /* copy the key descriptor version */
  1198.                 st_cur->keyver = h80211[z + 6] & 7;
  1199.             }
  1201.             st_cur->valid_ptk = calc_ptk( st_cur, opt.pmk );
  1202.         }
  1203.     }
  1205.     fclose( f_in  );
  1206.     fclose( f_out );
  1208.     /* write some statistics */
  1210.     printf( "33[KTotal number of packets read      % 8ldn"
  1211.                  "Total number of WEP data packets  % 8ldn"
  1212.                  "Total number of WPA data packets  % 8ldn"
  1213.                  "Number of plaintext data packets  % 8ldn"
  1214.                  "Number of decrypted WEP  packets  % 8ldn"
  1215.                  "Number of decrypted WPA  packets  % 8ldn",
  1216.             stats.nb_read, stats.nb_wep, stats.nb_wpa,
  1217.             stats.nb_plain, stats.nb_unwep, stats.nb_unwpa );
  1219.     return( 0 );
  1220. }