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

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

其他

开发平台：

Unix_Linux

airodump.c：源码内容
  1. /*
  2.  *  pcap-compatible 802.11 packet sniffer (Win32 version)
  3.  *
  4.  *  Copyright (C) 2004,2005  Christophe Devine
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  */
  21. #include <windows.h>
  22. #include <stdio.h>
  23. #include <time.h>
  25. #define snprintf _snprintf
  27. #include "capture.h"
  28. #include "console.h"
  29. #include "timeval.h"
  30. #include "pcap.h"
  32. #include "uniqueiv.c"
  34. #define FORMAT_CAP 1
  35. #define FORMAT_IVS 2
  37. #define REFRESH_TIMEOUT 200000
  39. #define BROADCAST_ADDR "xFFxFFxFFxFFxFFxFF"
  41. /* linked list of detected access points */
  43. struct AP_info
  44. {
  45.     struct AP_info *prev;     /* the prev AP in list      */
  46.     struct AP_info *next;     /* the next AP in list      */
  48.     time_t tinit, tlast;      /* first and last time seen */
  50.     int power, chanl;         /* signal power and channel */
  51.     int speed, crypt;         /* maxrate & encryption alg */
  53.     unsigned long nb_bcn;     /* total number of beacons  */
  54.     unsigned long nb_pkt;     /* total number of packets  */
  55.     unsigned long nb_data;    /* number of WEP data pkts  */
  57.     unsigned char bssid[6];   /* the access point's MAC   */
  58.     unsigned char essid[33];  /* ascii network identifier */
  60.     unsigned char lanip[4];   /* last detected ip address */
  61.                               /* if non-encrypted network */
  63.     unsigned char **uiv_root; /* unique iv root structure */
  64.                               /* if wep-encrypted network */
  65. };
  67. /* linked list of detected clients */
  69. struct ST_info
  70. {
  71.     struct ST_info *prev;    /* the prev client in list   */
  72.     struct ST_info *next;    /* the next client in list   */
  73.     struct AP_info *base;    /* AP this client belongs to */
  74.     time_t tinit, tlast;     /* first and last time seen  */
  75.     int power;               /* signal power              */
  76.     unsigned long nb_pkt;    /* total number of packets   */
  77.     unsigned char stmac[6];  /* the client's MAC address  */
  78. };
  80. /* bunch of global stuff */
  82. struct AP_info *ap_1st, *ap_end;
  83. struct AP_info *ap_cur, *ap_prv;
  85. struct ST_info *st_1st, *st_end;
  86. struct ST_info *st_cur, *st_prv;
  88. struct pcap_file_header pfh_out;
  89. struct pcap_file_header pfh_out;
  91. unsigned char prev_bssid[6];
  93. FILE *f_cap_in  = NULL;
  94. FILE *f_csv_out = NULL;
  95. FILE *f_cap_out = NULL;
  96. FILE *f_ivs_out = NULL;
  98. int dump_initialize( char *output_prefix, int ivs_only )
  99. {
  100.     int n;
  101.     char o_filename[1024];
  103.     ap_1st = ap_end = NULL;
  104.     st_1st = st_end = NULL;
  106.     /* create the output csv file */
  108.     if( strlen( output_prefix ) >= sizeof( o_filename ) - 5 )
  109.         output_prefix[sizeof( o_filename ) - 5] = '';
  111.     if( strcmp( output_prefix, "-" ) != 0 )
  112.     {
  113.         memset( o_filename, 0, sizeof( o_filename ) );
  114.         snprintf( o_filename,  sizeof( o_filename ) - 1,
  115.                   "%s.txt", output_prefix );
  117.         if( ( f_csv_out = fopen( o_filename, "wb+" ) ) == NULL )
  118.         {
  119.             perror( "fopen failed" );
  120.             fprintf( stderr, "n  Could not create "%s".n", o_filename );
  121.             return( 1 );
  122.         }
  123.     }
  125.     /* open or create the output packet capture file */
  127.     if( ivs_only == 0 )
  128.     {
  129.         n = sizeof( struct pcap_file_header );
  131.         if( strcmp( output_prefix, "-" ) != 0 )
  132.         {
  133.             memset( o_filename, 0, sizeof( o_filename ) );
  134.             snprintf( o_filename,  sizeof( o_filename ) - 1,
  135.                       "%s.cap", output_prefix );
  136.         }
  137.         else
  138.         {
  139.             f_cap_out = fdopen( 1, "wb" );
  140.             goto write_cap_header;
  141.         }
  143.         if( ( f_cap_out = fopen( o_filename, "rb+" ) ) == NULL )
  144.         {
  145.         create_cap_file:
  147.             if( ( f_cap_out = fopen( o_filename, "wb+" ) ) == NULL )
  148.             {
  149.                 perror( "fopen failed" );
  150.                 fprintf( stderr, "n  Could not create "%s".n", o_filename );
  151.                 return( 1 );
  152.             }
  154.         write_cap_header:
  156.             pfh_out.magic           = TCPDUMP_MAGIC;
  157.             pfh_out.version_major   = PCAP_VERSION_MAJOR;
  158.             pfh_out.version_minor   = PCAP_VERSION_MINOR;
  159.             pfh_out.thiszone        = 0;
  160.             pfh_out.sigfigs         = 0;
  161.             pfh_out.snaplen         = 65535;
  162.             pfh_out.linktype        = LINKTYPE_IEEE802_11;
  164.             if( fwrite( &pfh_out, 1, n, f_cap_out ) != (size_t) n )
  165.             {
  166.                 perror( "fwrite(pcap file header) failed" );
  167.                 return( 1 );
  168.             }
  169.         }
  170.         else
  171.         {
  172.             if( fread( &pfh_out, 1, n, f_cap_out ) != (size_t) n )
  173.                 goto create_cap_file;
  175.             if( pfh_out.magic != TCPDUMP_MAGIC &&
  176.                 pfh_out.magic != TCPDUMP_CIGAM )
  177.             {
  178.                 fprintf( stderr, "n  "%s" isn't a pcap file (expected "
  179.                                  "TCPDUMP_MAGIC).n", o_filename );
  180.                 return( 1 );
  181.             }
  183.             if( pfh_out.magic == TCPDUMP_CIGAM )
  184.                 SWAP32( pfh_out.linktype );
  186.             if( pfh_out.linktype != LINKTYPE_IEEE802_11 )
  187.             {
  188.                 fprintf( stderr, "n  Wrong linktype from pcap file header "
  189.                                  "(expected LINKTYPE_IEEE802_11) -n"
  190.                                  "this doesn't look like a regular 802.11 "
  191.                                  "capture.n" );
  192.                 return( 1 );
  193.             }
  195.             if( fseek( f_cap_out, 0, SEEK_END ) != 0 )
  196.             {
  197.                 perror( "fseek(SEEK_END) failed" );
  198.                 return( 1 );
  199.             }
  200.         }
  201.     }
  203.     if( ivs_only == 1 )
  204.     {
  205.         memset( prev_bssid, 0, 6 );
  207.         if( strcmp( output_prefix, "-" ) != 0 )
  208.         {
  209.             memset( o_filename, 0, sizeof( o_filename ) );
  210.             snprintf( o_filename,  sizeof( o_filename ) - 1,
  211.                       "%s.ivs", output_prefix );
  212.         }
  213.         else
  214.         {
  215.             f_ivs_out = fdopen( 1, "wb" );
  216.             goto write_ivs_header;
  217.         }
  219.         if( ( f_ivs_out = fopen( o_filename, "rb+" ) ) == NULL )
  220.         {
  221.         create_ivs_file:
  223.             if( ( f_ivs_out = fopen( o_filename, "wb+" ) ) == NULL )
  224.             {
  225.                 perror( "fopen failed" );
  226.                 fprintf( stderr, "n  Could not create "%s".n", o_filename );
  227.                 return( 1 );
  228.             }
  230.         write_ivs_header:
  232.             if( fwrite( IVSONLY_MAGIC, 1, 4, f_ivs_out ) != sizeof( n ) )
  233.             {
  234.                 perror( "fwrite(IVs file header) failed" );
  235.                 return( 1 );
  236.             }
  237.         }
  238.         else
  239.         {
  240.             unsigned char ivs_hdr[4];
  242.             if( fread( ivs_hdr, 1, 4, f_ivs_out ) != 4 )
  243.                 goto create_ivs_file;
  245.             if( memcmp( ivs_hdr, IVSONLY_MAGIC, 4 ) != 0 )
  246.             {
  247.                 fprintf( stderr, "n  "%s" isn't a IVs file (expected "
  248.                                  "IVSONLY_MAGIC).n", o_filename );
  249.                 return( 1 );
  250.             }
  252.             if( fseek( f_ivs_out, 0, SEEK_END ) != 0 )
  253.             {
  254.                 perror( "fseek(SEEK_END) failed" );
  255.                 return( 1 );
  256.             }
  257.         }
  258.     }
  260.     return( 0 );
  261. }
  263. int dump_add_packet( unsigned char *h80211, int caplen, int power,
  264.                      int channel, uint tv_sec, uint tv_usec )
  266. {
  267.     int i, n;
  269.     struct pcap_pkthdr pkh;
  271.     unsigned char *p;
  272.     unsigned char bssid[6];
  273.     unsigned char stmac[6];
  275.     ap_cur = NULL;
  276.     st_cur = NULL;
  278.     pkh.caplen = pkh.len = caplen;
  280.     /* skip packets smaller than a 802.11 header */
  282.     if( pkh.caplen < 24 )
  283.         goto write_packet;
  285.     /* skip (uninteresting) control frames */
  287.     if( ( h80211[0] & 0x0C ) == 0x04 )
  288.         goto write_packet;
  290.     /* locate the access point's MAC address */
  292.     switch( h80211[1] & 3 )
  293.     {
  294.         case  0: memcpy( bssid, h80211 + 16, 6 ); break;
  295.         case  1: memcpy( bssid, h80211 +  4, 6 ); break;
  296.         case  2: memcpy( bssid, h80211 + 10, 6 ); break;
  297.         default: memcpy( bssid, h80211 +  4, 6 ); break;
  298.     }
  300.     /* skip broadcast packets */
  302.     if( memcmp( bssid, BROADCAST_ADDR, 6 ) == 0 )
  303.         goto write_packet;
  305.     /* update our chained list of access points */
  307.     ap_cur = ap_1st;
  308.     ap_prv = NULL;
  310.     while( ap_cur != NULL )
  311.     {
  312.         if( ! memcmp( ap_cur->bssid, bssid, 6 ) )
  313.             break;
  315.         ap_prv = ap_cur;
  316.         ap_cur = ap_cur->next;
  317.     }
  319.     /* if it's a new access point, add it */
  321.     if( ap_cur == NULL )
  322.     {
  323.         if( ! ( ap_cur = (struct AP_info *) malloc(
  324.                          sizeof( struct AP_info ) ) ) )
  325.         {
  326.             perror( "malloc failed" );
  327.             return( 1 );
  328.         }
  330.         memset( ap_cur, 0, sizeof( struct AP_info ) );
  332.         if( ap_1st == NULL )
  333.             ap_1st = ap_cur;
  334.         else
  335.             ap_prv->next  = ap_cur;
  337.         memcpy( ap_cur->bssid, bssid, 6 );
  339.         ap_cur->prev = ap_prv;
  341.         if( tv_sec == 0 )
  342.         {
  343.             ap_cur->tinit = time( NULL );
  344.             ap_cur->tlast = time( NULL );
  345.         }
  346.         else
  347.         {
  348.             ap_cur->tinit = tv_sec;
  349.             ap_cur->tlast = tv_sec;
  350.         }
  352.         ap_cur->power = power;
  354.         ap_cur->chanl = -1;
  355.         ap_cur->speed = -1;
  356.         ap_cur->crypt = -1;
  358.         ap_cur->uiv_root = uniqueiv_init();
  360.         ap_end = ap_cur;
  361.     }
  363.     if( tv_sec == 0 )
  364.         ap_cur->tlast = time( NULL );
  365.     else
  366.         ap_cur->tlast = tv_sec;
  368.     if( ( h80211[1] & 1 ) == 0 )
  369.         ap_cur->power = power;
  371.     if( h80211[0] == 0x80 )
  372.         ap_cur->nb_bcn++;
  374.     ap_cur->nb_pkt++;
  376.     /* locate the station MAC in the 802.11 header */
  378.     switch( h80211[1] & 3 )
  379.     {
  380.         case  0: memcpy( stmac, h80211 + 10, 6 ); break;
  381.         case  1: memcpy( stmac, h80211 + 10, 6 ); break;
  382.         case  2:
  384.             /* reject broadcast MACs */
  386.             if( h80211[4] != 0 ) goto skip_station;
  387.             memcpy( stmac, h80211 +  4, 6 ); break;
  389.         default: goto skip_station; break;
  390.     }
  392.     /* skip non-data packets */
  394.     if( ( h80211[0] & 0x0C ) != 0x08 )
  395.         goto skip_station;
  397.     /* update our chained list of wireless clients */
  399.     st_cur = st_1st;
  400.     st_prv = NULL;
  402.     while( st_cur != NULL )
  403.     {
  404.         if( ! memcmp( st_cur->stmac, stmac, 6 ) )
  405.             break;
  407.         st_prv = st_cur;
  408.         st_cur = st_cur->next;
  409.     }
  411.     /* if it's a new client, add it */
  413.     if( st_cur == NULL )
  414.     {
  415.         if( ! ( st_cur = (struct ST_info *) malloc(
  416.                          sizeof( struct ST_info ) ) ) )
  417.         {
  418.             perror( "malloc failed" );
  419.             return( 1 );
  420.         }
  422.         memset( st_cur, 0, sizeof( struct ST_info ) );
  424.         if( st_1st == NULL )
  425.             st_1st = st_cur;
  426.         else
  427.             st_prv->next  = st_cur;
  429.         memcpy( st_cur->stmac, stmac, 6 );
  431.         st_cur->prev = st_prv;
  432.         st_cur->base = ap_cur;
  434.         if( tv_sec == 0 )
  435.         {
  436.             st_cur->tinit = time( NULL );
  437.             st_cur->tlast = time( NULL );
  438.         }
  439.         else
  440.         {
  441.             st_cur->tinit = tv_sec;
  442.             st_cur->tlast = tv_sec;
  443.         }
  445.         st_cur->power = power;
  447.         st_end = st_cur;
  448.     }
  450.     /* every 1s, update the last time seen & receive power */
  452.     if( tv_sec == 0 )
  453.         st_cur->tlast = time( NULL );
  454.     else
  455.         st_cur->tlast = tv_sec;
  457.     if( ( h80211[1] & 3 ) == 1 )
  458.         st_cur->power = power;
  460.     st_cur->nb_pkt++;
  462. skip_station:
  464.     /* packet parsing: Beacon or Probe Response */
  466.     if( h80211[0] == 0x80 ||
  467.         h80211[0] == 0x50 )
  468.     {
  469.         if( ap_cur->crypt < 0 )
  470.             ap_cur->crypt = ( h80211[34] & 0x10 ) >> 4;
  472.         p = h80211 + 36;
  474.         while( p < h80211 + pkh.caplen )
  475.         {
  476.             if( p + 2 + p[1] > h80211 + pkh.caplen )
  477.                 break;
  479.             if( p[0] == 0x00 && p[1] > 0 && p[2] != '' &&
  480.                 ( p[1] > 1 || p[2] != ' ' ) )
  481.             {
  482.                 /* found a non-cloaked ESSID */
  484.                 n = ( p[1] > 32 ) ? 32 : p[1];
  486.                 memset( ap_cur->essid, 0, 33 );
  487.                 memcpy( ap_cur->essid, p + 2, n );
  489.                 for( i = 0; i < n; i++ )
  490.                     if( ap_cur->essid[i] < 32 ||
  491.                       ( ap_cur->essid[i] > 126 && ap_cur->essid[i] < 160 ) )
  492.                         ap_cur->essid[i] = '.';
  493.             }
  495.             if( p[0] == 0x01 || p[0] == 0x32 )
  496.                 ap_cur->speed = ( p[1 + p[1]] & 0x7F ) / 2;
  498.             if( p[0] == 0x03 )
  499.                 ap_cur->chanl = p[2];
  501.             p += 2 + p[1];
  502.         }
  503.     }
  505.     /* packet parsing: Association Request */
  507.     if( h80211[0] == 0x00 )
  508.     {
  509.         p = h80211 + 28;
  511.         while( p < h80211 + pkh.caplen )
  512.         {
  513.             if( p + 2 + p[1] > h80211 + pkh.caplen )
  514.                 break;
  516.             if( p[0] == 0x00 && p[1] > 0 && p[2] != '' &&
  517.                 ( p[1] > 1 || p[2] != ' ' ) )
  518.             {
  519.                 /* found a non-cloaked ESSID */
  521.                 n = ( p[1] > 32 ) ? 32 : p[1];
  523.                 memset( ap_cur->essid, 0, 33 );
  524.                 memcpy( ap_cur->essid, p + 2, n );
  526.                 for( i = 0; i < n; i++ )
  527.                     if( ap_cur->essid[i] < 32 ||
  528.                       ( ap_cur->essid[i] > 126 && ap_cur->essid[i] < 160 ) )
  529.                         ap_cur->essid[i] = '.';
  530.             }
  532.             p += 2 + p[1];
  533.         }
  534.     }
  536.     /* packet parsing: some data */
  538.     if( ap_cur->chanl == -1 )
  539.         ap_cur->chanl = channel;
  541.     if( ( h80211[0] & 0x0C ) == 0x08 )
  542.     {
  543.         /* check the SNAP header to see if data is encrypted */
  545.         unsigned int z = ( ( h80211[1] & 3 ) != 3 ) ? 24 : 30;
  547.         if( z + 26 > pkh.caplen )
  548.             goto write_packet;
  550.         if( h80211[z] == h80211[z + 1] && h80211[z + 2] == 0x03 )
  551.         {
  552.             if( ap_cur->crypt < 0 )
  553.                 ap_cur->crypt = 0;
  555.             /* if ethertype == IPv4, find the LAN address */
  557.             if( h80211[z + 6] == 0x08 && h80211[z + 7] == 0x00 &&
  558.                 ( h80211[1] & 3 ) == 0x01 )
  559.                     memcpy( ap_cur->lanip, &h80211[z + 20], 4 );
  561.             if( h80211[z + 6] == 0x08 && h80211[z + 7] == 0x06 )
  562.                 memcpy( ap_cur->lanip, &h80211[z + 22], 4 );
  563.         }
  564.         else
  565.             ap_cur->crypt = 2 + ( ( h80211[z + 3] & 0x20 ) >> 5 );
  567.         if( z + 10 > pkh.caplen )
  568.             goto write_packet;
  570.         if( ap_cur->crypt == 2 )
  571.         {
  572.             /* WEP: check if we've already seen this IV */
  574.             if( ! uniqueiv_check( ap_cur->uiv_root, &h80211[z] ) )
  575.             {
  576.                 /* first time seen IVs */
  578.                 if( f_ivs_out != NULL )
  579.                 {
  580.                     unsigned char iv_info[64];
  582.                     if( memcmp( prev_bssid, ap_cur->bssid, 6 ) == 0 )
  583.                     {
  584.                         iv_info[0] = 0xFF;
  585.                         memcpy( iv_info + 1, &h80211[z    ], 3 );
  586.                         memcpy( iv_info + 4, &h80211[z + 4], 2 );
  587.                         n =  6;
  588.                     }
  589.                     else
  590.                     {
  591.                         memcpy( prev_bssid , ap_cur->bssid,  6 );
  592.                         memcpy( iv_info    , ap_cur->bssid,  6 );
  593.                         memcpy( iv_info + 6, &h80211[z    ], 3 );
  594.                         memcpy( iv_info + 9, &h80211[z + 4], 2 );
  595.                         n = 11;
  596.                     }
  598.                     if( fwrite( iv_info, 1, n, f_ivs_out ) != (size_t) n )
  599.                     {
  600.                         perror( "fwrite(IV info) failed" );
  601.                         return( 1 );
  602.                     }
  603.                 }
  605.                 uniqueiv_mark( ap_cur->uiv_root, &h80211[z] );
  607.                 ap_cur->nb_data++;
  608.             }
  609.         }
  610.         else
  611.             ap_cur->nb_data++;
  612.     }
  614. write_packet:
  616.     if( f_cap_out != NULL )
  617.     {
  618.         struct timeval tv;
  620.         gettimeofday( &tv, NULL );
  622.         if( tv_sec == 0 )
  623.         {
  624.             pkh.tv_sec  = tv.tv_sec;
  625.             pkh.tv_usec = ( tv.tv_usec & ~0x1ff ) + power;
  626.         }
  627.         else
  628.         {
  629.             pkh.tv_sec  = tv_sec;
  630.             pkh.tv_usec = tv_usec;
  631.         }
  633.         if( pfh_out.magic == TCPDUMP_CIGAM )
  634.         {
  635.             SWAP32( pkh.tv_sec  );
  636.             SWAP32( pkh.tv_usec );
  637.             SWAP32( pkh.caplen  );
  638.             SWAP32( pkh.len     );
  639.         }
  641.         n = sizeof( pkh );
  643.         if( fwrite( &pkh, 1, n, f_cap_out ) != (size_t) n )
  644.         {
  645.             perror( "fwrite(packet header) failed" );
  646.             return( 1 );
  647.         }
  649.         fflush( stdout );
  651.         n = pkh.caplen;
  653.         if( fwrite( h80211, 1, n, f_cap_out ) != (size_t) n )
  654.         {
  655.             perror( "fwrite(packet data) failed" );
  656.             return( 1 );
  657.         }
  659.         fflush( stdout );
  660.     }
  662.     return( 0 );
  663. }
  665. void dump_print( int ws_row, int ws_col )
  666. {
  667.     int nlines;
  668.     char strbuf[512];
  670.     /* print some informations about each detected AP */
  672.     fprintf( stderr, "n BSSID              PWR  Beacons"
  673.                      "   # Data  CH  MB  ENC   ESSIDnn" );
  675.     nlines = 5;
  677.     ap_cur = ap_end;
  679.     while( ap_cur != NULL )
  680.     {
  681.         if( f_cap_in == NULL && ( ap_cur->nb_pkt < 2 ||
  682.               time( NULL ) - ap_cur->tlast > 120 ) )
  683.         {
  684.             ap_cur = ap_cur->prev;
  685.             continue;
  686.         }
  688.         if( ws_row != 0 && nlines > ws_row )
  689.             return;
  691.         nlines++;
  693.         fprintf( stderr, " %02X:%02X:%02X:%02X:%02X:%02X",
  694.                 ap_cur->bssid[0], ap_cur->bssid[1],
  695.                 ap_cur->bssid[2], ap_cur->bssid[3],
  696.                 ap_cur->bssid[4], ap_cur->bssid[5] );
  698.         fprintf( stderr, "  %3d %8ld %8ld",
  699.                  ap_cur->power,
  700.                  ap_cur->nb_bcn,
  701.                  ap_cur->nb_data );
  703.         fprintf( stderr, " %3d %3d  ", ap_cur->chanl, ap_cur->speed );
  705.         switch( ap_cur->crypt )
  706.         {
  707.             case  0: fprintf( stderr, "OPN " ); break;
  708.             case  1: fprintf( stderr, "WEP?" ); break;
  709.             case  2: fprintf( stderr, "WEP " ); break;
  710.             case  3: fprintf( stderr, "WPA " ); break;
  711.             default: fprintf( stderr, "    " ); break;
  712.         }
  714.         memset( strbuf, 0, sizeof( strbuf ) );
  715.         snprintf( strbuf,  sizeof( strbuf ) - 1,
  716.                   "%-32s", ap_cur->essid );
  717.         strbuf[ws_col - 58] = '';
  718.         fprintf( stderr, "  %sn", strbuf );
  720.         ap_cur = ap_cur->prev;
  721.     }
  723.     /* print some informations about each detected station */
  725.     memset( strbuf, 0, ws_col );
  727.     nlines += 3;
  729.     if( ws_row != 0 && nlines > ws_row )
  730.         return;
  732.     memset( strbuf, 0x20, ws_col - 1 );
  733.     fprintf( stderr, "%sn", strbuf );
  735.     memcpy( strbuf, " BSSID              STATION "
  736.             "           PWR  Packets  ESSID", 58 );
  737.     fprintf( stderr, "%sn", strbuf );
  739.     memset( strbuf, 0x20, ws_col - 1 );
  740.     fprintf( stderr, "%sn", strbuf );
  742.     ap_cur = ap_end;
  744.     while( ap_cur != NULL )
  745.     {
  746.         if( f_cap_in == NULL && ( ap_cur->nb_pkt < 2 ||
  747.               time( NULL ) - ap_cur->tlast > 120 ) )
  748.         {
  749.             ap_cur = ap_cur->prev;
  750.             continue;
  751.         }
  753.         if( ws_row != 0 && nlines > ws_row )
  754.             return;
  756.         st_cur = st_end;
  758.         while( st_cur != NULL )
  759.         {
  760.             if( st_cur->base != ap_cur || ( f_cap_in == NULL &&
  761.                   time( NULL ) - ap_cur->tlast > 120 ) )
  762.             {
  763.                 st_cur = st_cur->prev;
  764.                 continue;
  765.             }
  767.             if( ws_row != 0 && nlines > ws_row )
  768.                 return;
  770.             nlines++;
  772.             fprintf( stderr, " %02X:%02X:%02X:%02X:%02X:%02X",
  773.                     ap_cur->bssid[0], ap_cur->bssid[1],
  774.                     ap_cur->bssid[2], ap_cur->bssid[3],
  775.                     ap_cur->bssid[4], ap_cur->bssid[5] );
  777.             fprintf( stderr, "  %02X:%02X:%02X:%02X:%02X:%02X",
  778.                     st_cur->stmac[0], st_cur->stmac[1],
  779.                     st_cur->stmac[2], st_cur->stmac[3],
  780.                     st_cur->stmac[4], st_cur->stmac[5] );
  782.             if( st_cur->power != -1 )
  783.                 fprintf( stderr, "  %3d", st_cur->power );
  784.             else
  785.                 fprintf( stderr, "     " );
  787.             fprintf( stderr, " %8ld", st_cur->nb_pkt );
  789.             memset( strbuf, 0, sizeof( strbuf ) );
  790.             snprintf( strbuf,  sizeof( strbuf ) - 1,
  791.                       "%-32s", ap_cur->essid );
  792.             strbuf[ws_col - 54] = '';
  793.             fprintf( stderr, "  %sn", strbuf );
  795.             st_cur = st_cur->prev;
  796.         }
  798.         ap_cur = ap_cur->prev;
  799.     }
  800. }
  802. void dump_write_csv( void )
  803. {
  804.     struct tm *ltime;
  806.     if( f_csv_out == NULL )
  807.         return;
  809.     fseek( f_csv_out, 0, SEEK_SET );
  811.     fprintf( f_csv_out,
  812.         "rnBSSID, First time seen, Last time seen, Channel, Speed, "
  813.         "Privacy, Power, # beacons, # data, LAN IP, ESSIDrn" );
  815.     ap_cur = ap_1st;
  817.     while( ap_cur != NULL )
  818.     {
  819.         if( ap_cur->nb_pkt < 2 )
  820.         {
  821.             ap_cur = ap_cur->next;
  822.             continue;
  823.         }
  825.         fprintf( f_csv_out, "%02X:%02X:%02X:%02X:%02X:%02X, ",
  826.                  ap_cur->bssid[0], ap_cur->bssid[1],
  827.                  ap_cur->bssid[2], ap_cur->bssid[3],
  828.                  ap_cur->bssid[4], ap_cur->bssid[5] );
  830.         ltime = localtime( &ap_cur->tinit );
  832.         fprintf( f_csv_out, "%04d-%02d-%02d %02d:%02d:%02d, ",
  833.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  834.                  ltime->tm_mday, ltime->tm_hour,
  835.                  ltime->tm_min,  ltime->tm_sec );
  837.         ltime = localtime( &ap_cur->tlast );
  839.         fprintf( f_csv_out, "%04d-%02d-%02d %02d:%02d:%02d, ",
  840.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  841.                  ltime->tm_mday, ltime->tm_hour,
  842.                  ltime->tm_min,  ltime->tm_sec );
  844.         fprintf( f_csv_out, "%2d, %3d, ",
  845.                  ap_cur->chanl,
  846.                  ap_cur->speed );
  848.         switch( ap_cur->crypt )
  849.         {
  850.             case  0: fprintf( f_csv_out, "OPN " ); break;
  851.             case  1: fprintf( f_csv_out, "WEP?" ); break;
  852.             case  2: fprintf( f_csv_out, "WEP " ); break;
  853.             case  3: fprintf( f_csv_out, "WPA " ); break;
  854.             default: fprintf( f_csv_out, "    " ); break;
  855.         }
  857.         fprintf( f_csv_out, ", %3d, %8ld, %8ld, ",
  858.                  ap_cur->power,
  859.                  ap_cur->nb_bcn,
  860.                  ap_cur->nb_data );
  862.         fprintf( f_csv_out, "%3d.%3d.%3d.%3d, ",
  863.                  ap_cur->lanip[0], ap_cur->lanip[1],
  864.                  ap_cur->lanip[2], ap_cur->lanip[2] );
  866.         fprintf( f_csv_out, "%-32srn", ap_cur->essid );
  868.         ap_cur = ap_cur->next;
  869.     }
  871.     fprintf( f_csv_out,
  872.         "rnStation MAC, First time seen, Last time seen, "
  873.         "Power, # packets, BSSID, ESSIDrn" );
  875.     st_cur = st_1st;
  877.     while( st_cur != NULL )
  878.     {
  879.         ap_cur = st_cur->base;
  881.         if( ap_cur->nb_pkt < 2 )
  882.         {
  883.             st_cur = st_cur->next;
  884.             continue;
  885.         }
  887.         fprintf( f_csv_out, "%02X:%02X:%02X:%02X:%02X:%02X, ",
  888.                  st_cur->stmac[0], st_cur->stmac[1],
  889.                  st_cur->stmac[2], st_cur->stmac[3],
  890.                  st_cur->stmac[4], st_cur->stmac[5] );
  892.         ltime = localtime( &st_cur->tinit );
  894.         fprintf( f_csv_out, "%04d-%02d-%02d %02d:%02d:%02d, ",
  895.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  896.                  ltime->tm_mday, ltime->tm_hour,
  897.                  ltime->tm_min,  ltime->tm_sec );
  899.         ltime = localtime( &st_cur->tlast );
  901.         fprintf( f_csv_out, "%04d-%02d-%02d %02d:%02d:%02d, ",
  902.                  1900 + ltime->tm_year, 1 + ltime->tm_mon,
  903.                  ltime->tm_mday, ltime->tm_hour,
  904.                  ltime->tm_min,  ltime->tm_sec );
  906.         fprintf( f_csv_out, "%3d, %8ld, ",
  907.                  st_cur->power,
  908.                  st_cur->nb_pkt );
  910.         fprintf( f_csv_out, "%02X:%02X:%02X:%02X:%02X:%02X, ",
  911.                  ap_cur->bssid[0], ap_cur->bssid[1],
  912.                  ap_cur->bssid[2], ap_cur->bssid[3],
  913.                  ap_cur->bssid[4], ap_cur->bssid[5] );
  915.         fprintf( f_csv_out, "%-32srn", ap_cur->essid );
  917.         st_cur = st_cur->next;
  918.     }
  920.     fprintf( f_csv_out, "rn" );
  922.     fflush( f_csv_out );
  923. }
  925. struct arguments
  926. {
  927.     int card_index;
  928.     int card_model;
  929.     int channels[16];
  930.     char *oprefix;
  931.     int ivs_only;
  932. }
  933. arg;
  935. int rawlen;
  936. unsigned char rawbuf[65536];
  937. unsigned char buffer[65536];
  939. HANDLE semPacket1;
  940. HANDLE semPacket2;
  942. int prompt_exit( int retval )
  943. {
  944.     int i;
  945.     printf( "n  Press Ctrl-C to exit.n" );
  946.     scanf( "%d", &i );
  947.     exit( retval );
  948. }
  950. int bg_chans[] = { 1, 5, 10, 2, 6, 11, 3, 7, 12, 4, 8, 13, 9, 0 };
  952. int parse_channels( char *s )
  953. {
  954.     int i = 0, j, n;
  956.     while( sscanf( s, "%d", &n ) == 1 )
  957.     {
  958.         if( n == 0 )
  959.         {
  960.             for( j = 0; j < 14; j++ )
  961.                 arg.channels[j] = bg_chans[j];
  963.             return( 0 );
  964.         }
  966.         if( n < 1 || n > 14 )
  967.             return( 1 );
  969.         arg.channels[i] = n; i++;
  970.         arg.channels[i] = 0;
  972.         if( i == 14 ) break;
  974.         while( isdigit( *s ) != 0 )
  975.             s++;
  977.         while( isdigit( *s ) == 0 )
  978.         {
  979.             if( *s == '' )
  980.                 return( 0 );
  982.             s++;
  983.         }
  984.     }
  986.     return( i == 0 );
  987. }
  989. void ask_parameters( void )
  990. {
  991.     int nbcards;
  992.     char strbuf[512];
  994.     nbcards = show_cards();
  996.     if( nbcards == 0 )
  997.     {
  998.         fprintf( stderr, "  No adapters have been detected - make sure"
  999.                  " peek5.sys is present and your card is plugged in.n" );
  1000.         prompt_exit( 1 );
  1001.     }
  1003. ask_arg1:
  1005.     printf( "  Network interface index number  -> " );
  1006.     scanf( "%s", strbuf );
  1007.     arg.card_index = atoi( strbuf );
  1008.     if( open_adapter( arg.card_index ) != 0 )
  1009.         goto ask_arg1;
  1011.     printf( "n  Interface types:  'o' = HermesI/Realtekn"
  1012.             "                    'a' = Aironet/Atherosn" );
  1014. ask_arg2:
  1016.     printf( "n  Network interface type (o/a)  -> " );
  1017.     scanf( "%s", strbuf );
  1018.     arg.card_model = strbuf[0] & 0xDF;
  1019.     if( arg.card_model != 'O' &&
  1020.         arg.card_model != 'A' )
  1021.         goto ask_arg2;
  1023. ask_arg3:
  1025.     printf( "n  Channel(s): 1 to 14, 0 = all  -> " );
  1026.     scanf( "%s", strbuf );
  1027.     if( parse_channels( strbuf ) != 0 )
  1028.         goto ask_arg3;
  1030.     printf( "n  (note: if you specify the same output prefix, " 
  1031.             "airodump will resumen   the capture session by "    
  1032.             "appending data to the existing capture file)n" );
  1034. ask_arg4:
  1036.     printf( "n  Output filename prefix        -> " );
  1037.     scanf( "%s", strbuf );
  1038.     if( strbuf[0] == '' )
  1039.         goto ask_arg4;
  1041.     arg.oprefix = malloc( strlen( strbuf ) );
  1042.     memcpy( arg.oprefix, strbuf, strlen( strbuf ) + 1 );
  1044.     printf( "n  (note: to save space and only store the captured " 
  1045.             "WEP IVs, press y.n   The resulting capture file "   
  1046.             "will only be useful for WEP cracking)n" );
  1048. ask_arg5:
  1050.     printf( "n  Only write WEP IVs (y/n)      -> " );
  1051.     scanf( "%s", strbuf );
  1052.     if( ( strbuf[0] & 0xDF ) != 'Y' &&
  1053.         ( strbuf[0] & 0xDF ) != 'N' )
  1054.         goto ask_arg5;
  1056.     arg.ivs_only = ( ( strbuf[0] & 0xDF ) == 'Y' ) ? 1 : 0;
  1058.     printf( "n" );
  1059. }
  1061. int WINAPI capture_thread( unsigned char *data, int len, int caplen,
  1062.                            __int64 timestamp, int flags, int arg7 )
  1063. {
  1064.     if( ( flags & 1 ) == 0 )
  1065.     {
  1066.         rawlen = len;
  1067.         memcpy( rawbuf, data, rawlen );
  1069.         ReleaseSemaphore( semPacket1, 1, NULL );
  1070.         WaitForSingleObject( semPacket2, INFINITE );
  1071.     }
  1073.     return( 1 );
  1074. }
  1076. int do_exit = 0;
  1078. int WINAPI sighandler( int signum )
  1079. {
  1080.     stop_monitor();
  1081.     do_exit = 1;
  1082.     return( TRUE );
  1083. }
  1085. int main( int argc, char *argv[] )
  1086. {
  1087.     unsigned char *h80211;
  1088.     unsigned long tick_prev;
  1089.     int caplen, chan_index;
  1090.     int ws_row, ws_col;
  1091.     time_t tt;
  1093.     set_console_icon( " airodump 2.3 " );
  1094.     set_console_size( 45, 90 );
  1096.     printf( "nnnttt" );
  1097.     set_text_color( BLUE_WHITE );
  1098.     printf( "airodump 2.3 - (C) 2004,2005 Christophe Devine" );
  1099.     set_text_color( TEXTATTR );
  1100.     printf( "nnnn  usage: airodump <nic index> <nic type> "
  1101.             "<channel(s)> <output prefix> [ivs only flag]nnn" );
  1103.     if( argc < 5 || argc > 6 )
  1104.     {
  1105.         if( load_peek() != 0 )
  1106.             prompt_exit( 1 );
  1108.         ask_parameters();
  1109.     }
  1110.     else
  1111.     {
  1112.         if( load_peek() != 0 )
  1113.             prompt_exit( 1 );
  1115.         arg.card_index = atoi( argv[1] );
  1117.         if( open_adapter( arg.card_index ) != 0 )
  1118.         {
  1119.             fprintf( stderr, "  Invalid network card indexn" );
  1120.             prompt_exit( 1 );
  1121.         }
  1123.         arg.card_model = argv[2][0] & 0xDF;
  1125.         if( arg.card_model != 'O' &&
  1126.             arg.card_model != 'A' )
  1127.         {
  1128.             fprintf( stderr, "  Invalid network card typen" );
  1129.             prompt_exit( 1 );
  1130.         }
  1132.         if( parse_channels( argv[3] ) != 0 )
  1133.         {
  1134.             fprintf( stderr, "  Invalid wireless channel listn" );
  1135.             prompt_exit( 1 );
  1136.         }
  1138.         arg.oprefix = argv[4];
  1140.         if( argc == 6 )
  1141.             arg.ivs_only = ( ( argv[5][0] & 0xDF ) == 'Y' ) ? 1 : 0;
  1142.     }
  1144.     if( dump_initialize( arg.oprefix, arg.ivs_only ) )
  1145.         prompt_exit( 1 );
  1147.     semPacket1 = CreateSemaphore( NULL, 0, 1, NULL );
  1148.     semPacket2 = CreateSemaphore( NULL, 0, 1, NULL );
  1150.     SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
  1152.     if( start_monitor( capture_thread ) != 0 )
  1153.         prompt_exit( 1 );
  1155.     tick_prev = GetTickCount();
  1156.     set_channel( arg.channels[chan_index = 0] );
  1158.     set_cursor_pos( 0, 0 );
  1159.     clear_console( NULL, NULL );
  1161.     tt = time( NULL );
  1163.     while( 1 )
  1164.     {
  1165.         if( do_exit )
  1166.             break;
  1168.         if( time( NULL ) - tt >= 20 )
  1169.         {
  1170.             tt = time( NULL );
  1171.             dump_write_csv();
  1172.         }
  1174.         if( GetTickCount() - tick_prev >= 300 ||
  1175.             GetTickCount() < tick_prev )
  1176.         {
  1177.             tick_prev = GetTickCount();
  1179.             if( arg.channels[++chan_index] == 0 )
  1180.                 chan_index = 0;
  1182.             set_channel( arg.channels[chan_index] );
  1184.             sprintf( buffer, " Channel : %02d - airodump 2.1 ",
  1185.                        arg.channels[chan_index] );
  1187.             SetConsoleTitle( buffer );
  1189.             clear_console( &ws_row, &ws_col );
  1190.             set_cursor_pos( 0, 0 );
  1192.             dump_print( ws_row, ws_col );
  1193.         }
  1195.         if( WaitForSingleObject( semPacket1, 100 ) == WAIT_TIMEOUT )
  1196.             continue;
  1198.         memcpy( buffer, rawbuf, rawlen );
  1200.         switch( arg.card_model )
  1201.         {
  1202.         case 'A':
  1203.             caplen = rawlen - 12;
  1204.             h80211 = buffer +  8;
  1205.             break;
  1207.         default:
  1208.             caplen = rawlen -  8;
  1209.             h80211 = buffer +  4;
  1210.             break;
  1211.         }
  1213.         ReleaseSemaphore( semPacket2, 1, NULL );
  1215.         if( dump_add_packet( h80211, caplen, buffer[2],
  1216.                              arg.channels[chan_index], 0, 0 ) != 0 )
  1217.         {
  1218.             dump_write_csv();
  1220.             if( f_csv_out != NULL ) fclose( f_csv_out );
  1221.             if( f_cap_out != NULL ) fclose( f_cap_out );
  1222.             if( f_ivs_out != NULL ) fclose( f_ivs_out );
  1224.             stop_monitor();
  1225.             prompt_exit( 1 );
  1226.         }
  1227.     }
  1229.     dump_write_csv();
  1231.     if( f_csv_out != NULL ) fclose( f_csv_out );
  1232.     if( f_cap_out != NULL ) fclose( f_cap_out );
  1233.     if( f_ivs_out != NULL ) fclose( f_ivs_out );
  1235.     stop_monitor();
  1236.     return( 0 );
  1237. }