analyse.c

Go to the documentation of this file.

/* Linux Prism II Stumbler - Utility Scan for 802_11 networks under Linux
 * 
 * File : analyse.c
 * Project : WifiScanner (c) 2002 Hervé Schauer Consultants
 * Usage : This utility is written for use with IEEE 802.11 adapters based
 * on Intersil's PRISM II chipset (PCMCIA).
 * 
 * Base code was from prismstumbler Jan Fernquist <Jan.B.Fernquist@telia.com>
 * and wlanctl from www.linux-wlan.com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Id: analyse.c 178 2007-08-11 16:57:24Z poggij $
 */

#include <include.h>
#include <src/analyse.h>
#include <src/interface.h>
#include <src/crt_io.h>
#include <src/conversion.h>
#include <src/manuf.h>
#include <src/airjack.h>
#include <src/functions.h>

// Private declaration
void LogPutSSID_byAddMAc(UINT8 AddMac[WLAN_ADDR_LEN], char *SSID);
void LogPutSSID_byBSSID(UINT8 BSSID[WLAN_ADDR_LEN], char *SSID);
void CalculCoef(UINT32 X[HISTORY_SIZE],
                UINT32 Y[HISTORY_SIZE], float *a, float *b);
char DetermineCryptType(UINT8 hasWep, UINT8 hasWPA, UINT8 hasTKIP,
                        UINT8 hasCCMP, UINT8 hasWPAPSK, UINT8 hasWPA2PSK);

const char svnid[] = "@(#) $Id: analyse.c 178 2007-08-11 16:57:24Z poggij $";

UINT16 NumberOfDetectedClient = 0;
ClientInfo_t ClientInfo[MAX_NUMBER_OF_DETECTED_CLIENT];

// External references
extern WINDOW *Panel_WND, *RealTime_WND;
extern ScanResult_t Res;
extern Statistics_t Stats;
extern UINT8 ids_warning;
extern ConfigStruct config;

#ifdef WITH_THREAD
extern pthread_mutex_t screen_mutex;
#endif

const UINT8 BroadcastMAC[WLAN_ADDR_LEN] =
    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };

enum CRYPT_TYPE {
  CRYPT_TYPE_CLEAR = 0,
  CRYPT_TYPE_WEP,
  CRYPT_TYPE_WPA,
  CRYPT_TYPE_TKIP,
  CRYPT_TYPE_CCMP,
  CRYPT_TYPE_PSK1,
  CRYPT_TYPE_PSK2
};

const char CryptTypeASCII[] = {
  [CRYPT_TYPE_CLEAR] = ' ',     // Data is clear
  [CRYPT_TYPE_WEP] = 'w',       // Data is crypted with WEP
  [CRYPT_TYPE_WPA] = 'W',       // Data is crypted with WPA
  [CRYPT_TYPE_TKIP] = 'T',      // Data is crypted with TKIP
  [CRYPT_TYPE_CCMP] = 'C',      // Data is crypted with AES CCMP (WPA2)
  [CRYPT_TYPE_PSK1] = 'p',      // Data is crypted with PSK in WPA
  [CRYPT_TYPE_PSK2] = 'P'       // Data is crypted with PSK in WPA2
};

#define WPA_OUI "\x00\x50\xF2"
#define RSN_OUI "\x00\x0F\xAC"
#define WME_OUI "\x00\x50\xF2"

// --------------------

/*
 * Compare two MAC address
 * Function indian compliant :-)
 */
UINT8
CompareAddMac(UINT8 AddMac1[WLAN_ADDR_LEN], UINT8 AddMac2[WLAN_ADDR_LEN])
{
  return (((UINT8) AddMac1[0] == (UINT8) AddMac2[0]) &&
          ((UINT8) AddMac1[1] == (UINT8) AddMac2[1]) &&
          ((UINT8) AddMac1[2] == (UINT8) AddMac2[2]) &&
          ((UINT8) AddMac1[3] == (UINT8) AddMac2[3]) &&
          ((UINT8) AddMac1[4] == (UINT8) AddMac2[4]) &&
          ((UINT8) AddMac1[5] == (UINT8) AddMac2[5]));
}

/*
 * Compare a MAC add with Broadcast Add
 */
UINT8 AddMacIsBroadcast(UINT8 AddMac1[WLAN_ADDR_LEN])
{
  return (((UINT8) AddMac1[0] == 0xFF) &&
          ((UINT8) AddMac1[1] == 0xFF) &&
          ((UINT8) AddMac1[2] == 0xFF) &&
          ((UINT8) AddMac1[3] == 0xFF) &&
          ((UINT8) AddMac1[4] == 0xFF) && ((UINT8) AddMac1[5] == 0xFF));
}

UINT8 AddMacIsNULL(UINT8 AddMac1[WLAN_ADDR_LEN])
{
  return (((UINT8) AddMac1[0] == 0x00) &&
          ((UINT8) AddMac1[1] == 0x00) &&
          ((UINT8) AddMac1[2] == 0x00) &&
          ((UINT8) AddMac1[3] == 0x00) &&
          ((UINT8) AddMac1[4] == 0x00) && ((UINT8) AddMac1[5] == 0x00));
}

/*
 * Clear all detected client
 */
void ResetAllDetectedClient(void)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    memset(&ClientInfo[i], 0, sizeof(ClientInfo_t));
  }
  NumberOfDetectedClient = 0;
}

/*
 * Function to put Signal / Noise ratio in database
 * keep the last HISTORY_SIZE value
 * put the max and min, 
 * calcul the mid value
 */
void LogPutSN(UINT8 AddMac[WLAN_ADDR_LEN], UINT32 SN)
{
  register UINT16 i, j;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      // shift all value
      for (j = (HISTORY_SIZE - 1); j != 0; j--) {
        ClientInfo[i].SN[j] = ClientInfo[i].SN[j - 1];
      }
      // Put value
      ClientInfo[i].SN[0] = SN;

      // Put the Max value and the Min Value
      if (ClientInfo[i].SNMax < SN) {
        ClientInfo[i].SNMax = SN;
      } else if ((ClientInfo[i].SNMin > SN)
                 || (ClientInfo[i].SNMin == 0)) {
        ClientInfo[i].SNMin = SN;
      }
      // Calulate the medium value
      UINT32 summe = 0;
      for (j = 0; j < 4; j++) {
        summe += ClientInfo[i].SN[j];
      }
      ClientInfo[i].SNMed = (summe / HISTORY_SIZE);

      // we have finish our work, so exit loop
      break;
    }
  }
}

/*
 * Put the Maximum and Minimum packet speed SEEN
 */
void LogPutRate(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 Rate)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      if (ClientInfo[i].RateMax < Rate)
        ClientInfo[i].RateMax = Rate;
      else if ((ClientInfo[i].RateMin > Rate)
               || (ClientInfo[i].RateMin == 0))
        ClientInfo[i].RateMin = Rate;
      break;
    }
  }
}

/*
 * Put the Maximum capable speed of a host
 */
void LogPutMaxSpeed(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 Rate)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].MaxSpeed = Rate;
    }
  }
}

void LogDetectedClient(UINT8 AddMac[WLAN_ADDR_LEN])
{
  register UINT16 i;
  UINT8 Founded = 0;

  if (NumberOfDetectedClient >= MAX_NUMBER_OF_DETECTED_CLIENT) {
    warning("Maximum of host is detected : %d.\n",
            MAX_NUMBER_OF_DETECTED_CLIENT);
    return;
  }
  // ignore broadcast - BUG #557306
  if (AddMacIsBroadcast(AddMac)) {
    Founded = 2;
    // TODO : do a different think for special ADD MAC
  }

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      Founded = 1;
      // It 's not a new host, so bye
      break;
    }
  }
  if (!Founded) {
    debug(1,
          "New client found (%02X:%02X:%02X:%02X:%02X:%02X)\n",
          AddMac[0], AddMac[1], AddMac[2], AddMac[3],
          AddMac[4], AddMac[5]);
    // All memcopy if with a fixed size, so ... no BOF! :-)
    memset(&ClientInfo[NumberOfDetectedClient], 0, sizeof(ClientInfo_t));
    memcpy(&ClientInfo[NumberOfDetectedClient].AddMac, AddMac,
           WLAN_ADDR_LEN);
    memcpy(&ClientInfo[NumberOfDetectedClient].Manuf,
           AddMacToManufName(ClientInfo[i].AddMac), MANUF_MAXSTRINGLENGTH);
    memcpy(&ClientInfo[NumberOfDetectedClient].Model,
           AddMacToManufModel(ClientInfo[i].AddMac),
           MANUF_MAXSTRINGLENGTH);
    NumberOfDetectedClient++;
  }
}

/*
 * we have found the BSSID of a host, so we notice it in the DB
 */
void LogPutBSSID(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 BSSID[WLAN_ADDR_LEN])
{
  register UINT16 i;

  // ignore broadcast - BUG #557306
  if (AddMacIsBroadcast(BSSID) == 0) {
    for (i = 0; i < NumberOfDetectedClient; i++) {
      if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
        memcpy(&ClientInfo[i].BSSID, BSSID, WLAN_ADDR_LEN);
        break;
      }
    }
  }
}

void LogPutDS(UINT8 AddMac[WLAN_ADDR_LEN])
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].IsDS = 1;
      break;
    }
  }
}

/*
 * WEP is used in this SSID
 */
void LogPutWep(UINT8 BSSID[WLAN_ADDR_LEN], UINT8 hasWep, UINT8 hasWPA)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, BSSID)) {
      ClientInfo[i].hasWep = hasWep;
      ClientInfo[i].hasWPA = hasWPA;
    }
  }
}

void LogPutChannel_byAddMac(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 Channel)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].Channel = Channel;
      break;
    }
  }
}


void LogPutChannel_byBSSID(UINT8 BSSID[WLAN_ADDR_LEN], UINT8 Channel)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, BSSID)) {
      ClientInfo[i].Channel = Channel;
    }
  }
}

void
LogPutChannel(UINT8 AddMac[WLAN_ADDR_LEN],
              UINT8 BSSID[WLAN_ADDR_LEN], UINT8 Channel)
{
  if (AddMacIsBroadcast(BSSID))
    LogPutChannel_byAddMac(AddMac, Channel);
  else
    LogPutChannel_byBSSID(BSSID, Channel);
}


void LogPutSSID_byAddMac(UINT8 AddMac[WLAN_ADDR_LEN], char *SSID)
{
  register UINT16 i;

/*  warning (">>1 SSID '%s' (%02X:%02X:%02X:%02X:%02X:%02X)\n",
     SSID, AddMac[0], AddMac[1], AddMac[2], AddMac[3], AddMac[4], AddMac[5]);
*/
  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      //    ClientInfo[i].SSID ""           and SSID not " "
      //if ((strlen (ClientInfo[i].SSID) == 0) && (strncmp (SSID, " ", 32))) {  // BUG #557123
      safe_strncpy(ClientInfo[i].SSID, SSID, WLAN_SSID_MAXLEN + 1);
      //}
      break;
    }
  }
}


void LogPutSSID_byBSSID(UINT8 BSSID[WLAN_ADDR_LEN], char *SSID)
{
  register UINT16 i;

/*  warning (">>2 SSID '%s' (%02X:%02X:%02X:%02X:%02X:%02X)\n",
     SSID, BSSID[0], BSSID[1], BSSID[2], BSSID[3], BSSID[4], BSSID[5]); /// XXX
*/
  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, BSSID)) {
      if ((strlen(ClientInfo[i].SSID) == 0)
          || ((strncmp(SSID, "<Hidden SSID>", WLAN_SSID_MAXLEN))
              &&
              (strncmp
               (SSID, "<Hidden SSID of known length>",
                WLAN_SSID_MAXLEN)))) {
        safe_strncpy(ClientInfo[i].SSID, SSID, WLAN_SSID_MAXLEN + 1);
      }
    }
  }
}

void
LogPutSSID(UINT8 AddMac[WLAN_ADDR_LEN],
           UINT8 BSSID[WLAN_ADDR_LEN], char *SSID)
{
  // We don't initialyse SSID if it's blank, BUG #557123
  //   SSID not ""         and  SSID not " "
  if ((strlen(SSID) != 0) && (strncmp(SSID, " ", 32))) {
    if (AddMacIsBroadcast(BSSID))
      LogPutSSID_byAddMac(AddMac, SSID);
    else
      LogPutSSID_byBSSID(BSSID, SSID);
  }
}

void LogPutIsAP(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 hasWep, UINT8 hasWPA,
                UINT16 bcn_int)
{
  register UINT16 i, j;
  UINT8 BSSID[WLAN_ADDR_LEN];

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].hasWep = hasWep;
      ClientInfo[i].hasWPA = hasWPA;
      // A little rotation of Beacon Interval
      for (j = (HISTORY_SIZE - 1); j != 0; j--)
        ClientInfo[i].bcn_int[j] = ClientInfo[i].bcn_int[j - 1];
      if (bcn_int != 0)
        ClientInfo[i].bcn_int[0] = bcn_int;
      memcpy(&BSSID, ClientInfo[i].BSSID, WLAN_ADDR_LEN);
      //if (!ClientInfo[i].IsP2P)
      ClientInfo[i].IsAP = 1;

      // Jamming is here :-)
      if (config.JammingNow == TRUE) {
        sendDeauth(BroadcastMAC, BSSID, 0);
      }
      break;
    }
  }
  LogPutWep(BSSID, hasWep, hasWPA);
}

void LogPutIsP2P(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 hasWep, UINT16 bcn_int)
{
  register UINT16 i, j;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].hasWep = hasWep;
      // A little rotation of Beacon Interval
      for (j = (HISTORY_SIZE - 1); j != 0; j--)
        ClientInfo[i].bcn_int[j] = ClientInfo[i].bcn_int[j - 1];
      if (bcn_int != 0)
        ClientInfo[i].bcn_int[0] = bcn_int;
      ClientInfo[i].IsP2P = 1;
      ClientInfo[i].IsAP = 0;
      debug(1, "IsP2P > %s\n", ClientInfo[i].AddMac);
      break;
    }
  }
}

void
LogPutOtherInformation(UINT8 AddMac[WLAN_ADDR_LEN], char *OtherInformation)
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      safe_strncpy(ClientInfo[i].OtherInformation,
                   OtherInformation, MAXSIZE_OTHERINFORMATION);
      break;
    }
  }
}

void LogPutTimestamp(UINT8 AddMac[WLAN_ADDR_LEN], UINT64 TimeStamp)
{
  register UINT16 i;
  UINT8 j;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      for (j = (HISTORY_SIZE - 1); j != 0; j--) {
        ClientInfo[i].TimeStamp[j] = ClientInfo[i].TimeStamp[j - 1];
      }
      ClientInfo[i].TimeStamp[0] = TimeStamp;
      debug(3, "TS : %016llX %016llX %016llX %016llX\n",
            ClientInfo[i].TimeStamp[0],
            ClientInfo[i].TimeStamp[1],
            ClientInfo[i].TimeStamp[2], ClientInfo[i].TimeStamp[3]);
      break;
    }
  }
}

void
LogPutSeqNum(UINT8 AddMac[WLAN_ADDR_LEN],
             UINT8 AddMacDst[WLAN_ADDR_LEN], UINT16 SeqNum)
{
  register UINT16 i, j;

  if (AddMacIsBroadcast(AddMacDst)) {
    for (i = 0; i < NumberOfDetectedClient; i++) {
      if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
        for (j = (HISTORY_SIZE - 1); j != 0; j--) {
          ClientInfo[i].SeqNum[j] = ClientInfo[i].SeqNum[j - 1];
        }
        ClientInfo[i].SeqNum[0] = WLAN_GET_SEQ_SEQNUM(SeqNum);
        break;
      }
    }
  }
}

void LogPutLastIV(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 IV[4])
{
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].AddMac, AddMac)) {
      ClientInfo[i].LastIV[0] = IV[0];
      ClientInfo[i].LastIV[1] = IV[1];
      ClientInfo[i].LastIV[2] = IV[2];
      ClientInfo[i].LastIV[3] = IV[3];
      break;
    }
  }
}

void Send_To_All_BSSID_A_Deauth(void)
{
  UINT8 bssid[WLAN_ADDR_LEN];
  UINT8 dest[WLAN_ADDR_LEN];
  register UINT16 i;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (!AddMacIsNULL(ClientInfo[i].AddMac)
        && !AddMacIsNULL(ClientInfo[i].BSSID)) {
      memcpy(bssid, &ClientInfo[i].BSSID, WLAN_ADDR_LEN);
      memcpy(dest, &ClientInfo[i].AddMac, WLAN_ADDR_LEN);
      sendDeauth(dest, bssid, ClientInfo[i].Channel);
      sendDeauth(BroadcastMAC, bssid, ClientInfo[i].Channel);
    }
  }
}



void LogWriteReport(void)
{
  int i;
  UINT8 j;

  printf("\n\n");
  printf("Now a summary of the detection :\n");
  printf("--------------------------------\n");

  if (NumberOfDetectedClient == 0) {
    printf("No 802.11b information has been catched\n\n");
  }

  for (i = 0; i < NumberOfDetectedClient; i++) {
    printf("Station (%02X:%02X:%02X:%02X:%02X:%02X)  -  ",
           ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
           ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
           ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    printf("BSSID=%02X:%02X:%02X:%02X:%02X:%02X  -  ",
           ClientInfo[i].BSSID[0], ClientInfo[i].BSSID[1],
           ClientInfo[i].BSSID[2], ClientInfo[i].BSSID[3],
           ClientInfo[i].BSSID[4], ClientInfo[i].BSSID[5]);

    if ((strlen(ClientInfo[i].SSID) == 0)
        || ((strlen(ClientInfo[i].SSID) == 1)
            && (*ClientInfo[i].SSID == 0x20)))
      printf("SSID is not broadcasted\n");
    else {
      //printf ("SSID='%s'\n", ClientInfo[i].SSID);
      printf("SSID='");
      for (j = 0; j < strlen(ClientInfo[i].SSID); j++) {
        if (isprint(ClientInfo[i].SSID[j]))
          printf("%c", ClientInfo[i].SSID[j]);
        else
          printf("/0x%02X", ClientInfo[i].SSID[j]);
      }
      printf("'\n");
    }

    printf("  Manufacturer/Model : %s / %s\n",
           AddMacToManufName(ClientInfo[i].AddMac),
           AddMacToManufModel(ClientInfo[i].AddMac));

    if (ClientInfo[i].SNMax != ClientInfo[i].SNMin)
      printf("  Signal is between %u and %u",
             ClientInfo[i].SNMin, ClientInfo[i].SNMax);
    else
      printf("  Signal is stable at %u", ClientInfo[i].SNMax);

    if (ClientInfo[i].RateMax != ClientInfo[i].RateMin)
      printf(" and Data rate is between %s and %s\n",
             RateToString(ClientInfo[i].RateMin),
             RateToString(ClientInfo[i].RateMax));
    else
      printf(" and Data rate is %s\n",
             RateToString(ClientInfo[i].RateMax));

    if (ClientInfo[i].MaxSpeed != 0)
      printf("  Max speed available is %s\n",
             RateToString(ClientInfo[i].MaxSpeed));

    if (ClientInfo[i].hasWep)
      if (ClientInfo[i].hasWPA)
        printf("  Channel %d with WPA\n", ClientInfo[i].Channel);
      else
        printf("  Channel %d with Wep\n", ClientInfo[i].Channel);
    else
      printf("  Channel %d with no Wep\n", ClientInfo[i].Channel);

    if (ClientInfo[i].bcn_int[0] != 0)
      printf("  1 beacon every %d ms is sent\n", ClientInfo[i].bcn_int[0]);

    if (ClientInfo[i].IsDS) {
      if (ClientInfo[i].IsAP) { // #568053
        printf
            ("  This is an AP that do some NAT or is a router (because it's also a DS)\n");
      } else {
        printf
            ("  This station is in the Wired network (DS) of the BSSID\n");
      }
    } else {
      if (ClientInfo[i].IsAP)
        printf("  This is an AP\n");
      else if (ClientInfo[i].IsP2P)
        printf("  This an Ad-HOC client\n");
      else
        printf("  This is a client\n");
    }

    if (ClientInfo[i].OtherInformation == NULL) {
      printf("  Other information discovered:\n");
      printf("   > \"%s\"\n", ClientInfo[i].OtherInformation);
    }

    printf("-------------\n");
  }
}

void LogWriteDOT(FILE * filename)
{
  int i;

  if (NumberOfDetectedClient == 0) {
    printf("No 802.11b information has catched\n");
    printf("So no .dot file is created\n\n");
  } else {
    printf("802.11b information has catched so I make my .dot file ");
  }

  fprintf(filename,
          "digraph xyz {\n  ratio=compress;\n  size=\"8,8\";\n"
          "  rankdir=LR;\n  node [shape=box,fontsize=8];\n");

  for (i = 0; i < NumberOfDetectedClient; i++) {
    printf(".");
    fprintf(filename, "\"%02X:%02X:%02X:%02X:%02X:%02X\" -> ",
            ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
            ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
            ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    fprintf(filename, "\"%02X:%02X:%02X:%02X:%02X:%02X\";\n",
            ClientInfo[i].BSSID[0], ClientInfo[i].BSSID[1],
            ClientInfo[i].BSSID[2], ClientInfo[i].BSSID[3],
            ClientInfo[i].BSSID[4], ClientInfo[i].BSSID[5]);
    if (ClientInfo[i].IsDS)
      fprintf(filename,
              "\"%02X:%02X:%02X:%02X:%02X:%02X\" [shape=diamond];\n",
              ClientInfo[i].AddMac[0],
              ClientInfo[i].AddMac[1],
              ClientInfo[i].AddMac[2],
              ClientInfo[i].AddMac[3],
              ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
    else {
      if (ClientInfo[i].IsAP) {
        fprintf(filename,
                "\"%02X:%02X:%02X:%02X:%02X:%02X\" [shape=circle,label=\"",
                ClientInfo[i].AddMac[0],
                ClientInfo[i].AddMac[1],
                ClientInfo[i].AddMac[2],
                ClientInfo[i].AddMac[3],
                ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        fprintf(filename,
                "%02X:%02X:%02X:%02X:%02X:%02X\\nSSID='%s'\"];\n",
                ClientInfo[i].AddMac[0],
                ClientInfo[i].AddMac[1],
                ClientInfo[i].AddMac[2],
                ClientInfo[i].AddMac[3],
                ClientInfo[i].AddMac[4],
                ClientInfo[i].AddMac[5], ClientInfo[i].SSID);
      }
    }
  }
  fprintf(filename, "}\n");
  printf("Done!\n\n");
}

void LogWriteHisto(void)
{
#define HISTO_SIGNAL_SIZE 32
#define HISTO_SIGNAL_CHAN 14

  UINT8 i, Max = 0, Min=0xFF;
  float divid = 0;
  int j;
  char histo[HISTO_SIGNAL_SIZE][HISTO_SIGNAL_CHAN];

  if (NumberOfDetectedClient != 0) {

    printf("\n Spectral repartition :\n-----------------------\n\n");

    // Find the Max and the Min
    debug(3, "    ");
    for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
      debug(3, "%02X,", Stats.MaxSignal[i]);
      if (Stats.MaxSignal[i] > Max)
        Max = Stats.MaxSignal[i];
      if (Stats.MaxSignal[i] < Min)
  Min = Stats.MaxSignal[i];
    }

    // So we get the scale
    divid = (float) (Max + 1 - Min) / (float) HISTO_SIGNAL_SIZE;
    debug(3, "divid=%f ", divid);
    debug(3, "Min=%02X Max=%02X\n", Min, Max);

    // Clear the histogramm
    for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
      for (j = 0; j < HISTO_SIGNAL_SIZE; j++)
        histo[j][i] = '-';      // Clear histo
    }

    // And now fill it !
    for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
      for (j = 0; j < ((Stats.MaxSignal[i] - Min) / divid); j++) {
        histo[j][i] = '*';      // Fill histo
      }
    }

    printf("    01 02 03 04 05 06 07 08 09 10 11 12 13     14\n");
    for (j = HISTO_SIGNAL_SIZE; j != 0; j--) {
      printf("%3d ", (UINT8) ((j * divid) + Min));
      for (i = 0; i < HISTO_SIGNAL_CHAN; i++) {
        if (i == (HISTO_SIGNAL_CHAN - 1))
          printf("    ");       // separation between channel 13 and 14
        printf("%c%c ", histo[j - 1][i], histo[j - 1][i]);
      }
      printf("\n");
    }
    printf("    01 02 03 04 05 06 07 08 09 10 11 12 13     14\n\n");
  }
}

void ClearPanel(void)
{
#ifdef WITH_THREAD
  pthread_mutex_lock(&screen_mutex);
#endif
  wclear(Panel_WND);
  box(Panel_WND, '|', '-');
  wrefresh(Panel_WND);
#ifdef WITH_THREAD
  pthread_mutex_unlock(&screen_mutex);
#endif
}

/*
Function that display the Upper Panel
*/
void WritePanel(UINT8 GoodPacket)
// TODO : Old Code must be rewrite with MACRO and better function
{
  UINT8 i;
  char Line[256];
  char Histo[HISTOSIZE + 2];
  char MAC[20];
  char TYPE[4];
  UINT8 SNMax = 0;
  static UINT8 MaxFromAll = 1;
  UINT16 HistoSize = 0, HostDisplayed;
  UINT16 MinAff, MaxAff, Posit = 1, SizeOfWin;
  UINT16 NumberOfDetectedClientToDisplay = 0;

  // calculate the windows Size
  SizeOfWin = (ROW_WND_PANEL - 2);
  if (IS_DISPLAY_STATION(config.DoNotDisplay)) {
    NumberOfDetectedClientToDisplay = Stats.AP;
  } else {
    NumberOfDetectedClientToDisplay = NumberOfDetectedClient;
  }

  if (config.FirstNIC == 0) {
    if (NumberOfDetectedClientToDisplay > SizeOfWin)
      MinAff = NumberOfDetectedClientToDisplay - SizeOfWin;
    else
      MinAff = 0;
    MaxAff = NumberOfDetectedClientToDisplay;
  } else {
    if (config.FirstNIC < (NumberOfDetectedClientToDisplay - SizeOfWin)) {
      MinAff = config.FirstNIC;
      if (config.FirstNIC + SizeOfWin > NumberOfDetectedClientToDisplay)
        MaxAff = NumberOfDetectedClientToDisplay - 1;
      else
        MaxAff = config.FirstNIC + SizeOfWin;
    } else {
      config.FirstNIC = 0;
      MinAff = NumberOfDetectedClientToDisplay - SizeOfWin - 1;
    }
  }
  //debug (3, "#### NumberOfDetectedClientToDisplay = %02u, MinAff = %02u, MaxAff= %02u\n",NumberOfDetectedClientToDisplay,MinAff,MaxAff);

#ifdef WITH_THREAD
  pthread_mutex_lock(&screen_mutex);
#endif

  //for (i = MinAff; i < MaxAff; i++) {
  HostDisplayed = 0;
  i = MinAff;
  while ((HostDisplayed < SizeOfWin) || (i < NumberOfDetectedClient)) {
    // If we don't need to display this AP/STA, we skip it
    if (IS_DISPLAY_STATION(config.DoNotDisplay) && (!ClientInfo[i].IsAP)) {
      i++;
      if (i >= NumberOfDetectedClient)
        break;
    } else {
      if (i >= NumberOfDetectedClient)
        break;
      snprintf(MAC, 20, "%02X:%02X:%02X:%02X:%02X:%02X",
               ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
               ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
               ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
      safe_strncpy(Histo,
                   "|________________________________________________",
                   HISTOSIZE + 2);

      if ((ClientInfo[i].SNMax > MaxFromAll)
          || (Res.Signal > MaxFromAll)) {
        if (Res.Signal > MaxFromAll)
          MaxFromAll = Res.Signal;
        else
          MaxFromAll = ClientInfo[i].SNMax;
      }

      //if (GoodPacket == TRUE) {
        HistoSize =
            (UINT16) ((ClientInfo[i].SNMed * HISTOSIZE) / MaxFromAll);
        if (!strncmp(MAC, Res.SrcMac, 20)) {
          strncpy(Histo,
                  "|=======================================================",
                  HistoSize + 1);
          mvwprintw(Panel_WND, Posit, 1, ">");
        } else {
          strncpy(Histo,
                  "|.......................................................",
                  HistoSize + 1);
          mvwprintw(Panel_WND, Posit, 1, " ");
        }
      //}

      /* if SN/2 > 64 then SNMax = 64 else SNMax = SN/2 */
      SNMax = (ClientInfo[i].SNMax * HISTOSIZE) / MaxFromAll;
      if (SNMax <= HISTOSIZE) {
        Histo[SNMax - 1] = '|';
        //Histo[HISTOSIZE] = ' ';
      }
      Histo[HISTOSIZE + 1] = 0;
      snprintf(Line, COL_WND_PANEL - POS_HISTO - 1,
               "%s (%d,%d,%d) %s  ", Histo,
               (((GoodPacket == TRUE)
                 && !strncmp(MAC, Res.SrcMac,
                             20)) ? Res.Signal : 0),
               (int) ClientInfo[i].SNMed,
               (int) ClientInfo[i].SNMax, ClientInfo[i].Manuf);

      if (ClientInfo[i].IsP2P)
        snprintf(TYPE, 4, "ADH");
      else if (ClientInfo[i].IsAP)
        snprintf(TYPE, 4, "AP ");
      else
  if (ClientInfo[i].IsDS)
    snprintf(TYPE, 4, "sta");
  else
    snprintf(TYPE, 4, "STA");

      // We Write now
      mvwprintw(Panel_WND, Posit, 2, "%s", TYPE);
      mvwprintw(Panel_WND, Posit, POS_MAC, "%s", MAC);
      mvwprintw(Panel_WND, Posit, POS_SSID,
                "\"%s\"                                 ", ClientInfo[i].SSID);
      mvwprintw(Panel_WND, Posit, POS_CHANNEL, "%X",
                ClientInfo[i].Channel);


      mvwprintw(Panel_WND, Posit, POS_CRYPT, "%c",
                DetermineCryptType(ClientInfo[i].hasWep,
                                   ClientInfo[i].hasWPA,
                                   ClientInfo[i].hasTKIP,
                                   ClientInfo[i].hasCCMP,
                                   ClientInfo[i].hasWPAPSK,
                                   ClientInfo[i].hasWPA2PSK));
      mvwprintw(Panel_WND, Posit, POS_HISTO, "%s", Line);
      Posit++;
      HostDisplayed++;
      i++;
    }
  }

  wrefresh(Panel_WND);
#ifdef WITH_THREAD
  pthread_mutex_unlock(&screen_mutex);
#endif
  debug(3, "WritePanel Line #%d\n", __LINE__);
}


/* In this part we can determine the cryptage used for the BSSID
 * w: WEP, 
 * W: WPA without any more information,
 * T: WPA enterprise with TKIP
 * C: WPA2 enterprise with CCMP,
 * p: for WPA PSK (TKIP)
 * P: for WPA2 PSK (CCMP), ...
 */
char DetermineCryptType(UINT8 hasWep, UINT8 hasWPA, UINT8 hasTKIP,
                        UINT8 hasCCMP, UINT8 hasWPAPSK, UINT8 hasWPA2PSK)
{
  UINT8 CryptType = 0;

  if (hasWPA) {
    if (hasTKIP) {
      if (hasWPAPSK)
        CryptType = CRYPT_TYPE_PSK1;
      else
        CryptType = CRYPT_TYPE_TKIP;
    } else {
      if (hasCCMP) {
        if (hasWPA2PSK)
          CryptType = CRYPT_TYPE_PSK2;
        else
          CryptType = CRYPT_TYPE_CCMP;
      } else
        CryptType = CRYPT_TYPE_WPA;
    }
  } else {
    if (hasWep)
      CryptType = CRYPT_TYPE_WEP;
    else
      CryptType = CRYPT_TYPE_CLEAR;
  }
  return CryptTypeASCII[CryptType];
}

void DoSummary(void)
{
  UINT8 i;
  UINT8 ChanTab[14] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

  Stats.AP = 0;
  Stats.STA = 0;
  Stats.Channel = 0;

  for (i = 0; i < NumberOfDetectedClient; i++) {
    ChanTab[ClientInfo[i].Channel] = 1;

    if (ClientInfo[i].IsAP)
      Stats.AP++;
    else
      Stats.STA++;
  }

  for (i = 0; i < 14; i++) {
    if (ChanTab[i] != 0)
      Stats.Channel++;
  }
}

/* ******** */
/* IDS ZONE */
/* ******** */

void CalculCoef(UINT32 X[HISTORY_SIZE],
                UINT32 Y[HISTORY_SIZE], float *a, float *b)
{
  float aa[HISTORY_SIZE], bb[HISTORY_SIZE];
  UINT8 NbData, i;

  // in case of ...
#if (HISTORY_SIZE < 2)
#error "STOP ?! HISTORY_SIZE MUST be greater than 1. Change it on include.h"
#endif

  // Find number of data to analyse
  NbData = 0;
  for (i = 0; i < HISTORY_SIZE; i++) {
    if ((X[i] != 0) && (Y[i] != 0))
      NbData++;
  }

  // Calculate all aa and all bb
  for (i = 0; i < (NbData - 1); i++) {
    aa[i] = (Y[i] - Y[i + 1]) / (X[i] - X[i + 1]);
    bb[i] = Y[i] / (aa[i] * X[i]);
  }

  *a = *b = 0;
  for (i = 0; i < NbData; i++) {
    *a = *a + aa[i];
    *b = *b + bb[i];
  }
  *a = *a / NbData;
  *b = *b / NbData;
}


UINT8 IDS_BcnInt(void)
{
  register UINT16 i;
  UINT8 ret = 0, j;
  char MAC[20];
  char Message[1024];

  for (i = 0; i < NumberOfDetectedClient; i++) {
    for (j = 0; j < (HISTORY_SIZE - 1); j++) {
      if (((ClientInfo[i].bcn_int[j] != 0)
           && (ClientInfo[i].bcn_int[j + 1] != 0))
          && (ClientInfo[i].bcn_int[j] != ClientInfo[i].bcn_int[j + 1])) {
        snprintf(MAC, 20,
                 "%02X:%02X:%02X:%02X:%02X:%02X",
                 ClientInfo[i].AddMac[0],
                 ClientInfo[i].AddMac[1],
                 ClientInfo[i].AddMac[2],
                 ClientInfo[i].AddMac[3],
                 ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        snprintf(Message, 1024,
                 "IDS WARNING - beacon interval is changing for %s from %dms to %dms\n",
                 MAC, ClientInfo[i].bcn_int[j + 1],
                 ClientInfo[i].bcn_int[j]);
        Send_IDS_Warning(Message);
        ret = 0x01;             
        break;
      }
    }
  }
  return ret;
}

UINT8 IDS_TimeStamp(void)
{
  register UINT16 i;
  UINT8 ret = 0, j;
  char MAC[20];
  char Message[1024];

  // Analysis of Time Stamps
  for (i = 0; i < NumberOfDetectedClient; i++) {
    for (j = 0; j < (HISTORY_SIZE - 1); j++) {
      if (((ClientInfo[i].TimeStamp[j] != 0)
           && (ClientInfo[i].TimeStamp[j + 1] != 0))
          && (ClientInfo[i].TimeStamp[j] < ClientInfo[i].TimeStamp[j + 1])) {
        snprintf(MAC, 20, "%02X:%02X:%02X:%02X:%02X:%02X",
                 ClientInfo[i].AddMac[0], ClientInfo[i].AddMac[1],
                 ClientInfo[i].AddMac[2], ClientInfo[i].AddMac[3],
                 ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        snprintf(Message, 1024,
                 "IDS WARNING - Time Stamp is not correct for %s\n", MAC);
        Send_IDS_Warning(Message);
        snprintf(Message, 1024,
                 " Difference between two catched packets is : %lluµs %llums\n",
                 ClientInfo[i].TimeStamp[j + 1] -
                 ClientInfo[i].TimeStamp[j],
                 (ClientInfo[i].TimeStamp[j + 1] -
                  ClientInfo[i].TimeStamp[j]) * 100);
        Send_IDS_Warning(Message);
/*        snprintf(Message, 1024, "Timestamps = (0x%016llX,0x%016llX)\n",
                 ClientInfo[i].TimeStamp[j],
                 ClientInfo[i].TimeStamp[j + 1]);
        Send_IDS_Warning(Message); */
        ret = 0x02;             
        break;
      }
    }
  }
  return ret;
}

UINT8 IDS_Var_SeqNum(void)
{
  register UINT16 i;
  UINT8 ret = 0, j;
  char MAC[20];
  char Message[1024];

  // Analysis of variation of Seqnum
  for (i = 0; i < NumberOfDetectedClient; i++) {
    for (j = 0; j < (HISTORY_SIZE - 1); j++) {
      if (((ClientInfo[i].SeqNum[j] != 0)
           && (ClientInfo[i].SeqNum[j + 1] != 0))
          && (ClientInfo[i].SeqNum[j] < ClientInfo[i].SeqNum[j + 1])) {
        snprintf(MAC, 20,
                 "%02X:%02X:%02X:%02X:%02X:%02X",
                 ClientInfo[i].AddMac[0],
                 ClientInfo[i].AddMac[1],
                 ClientInfo[i].AddMac[2],
                 ClientInfo[i].AddMac[3],
                 ClientInfo[i].AddMac[4], ClientInfo[i].AddMac[5]);
        snprintf(Message, 1024,
                 "IDS WARNING - Sequence Number is not correct for %s\n",
                 MAC);
        Send_IDS_Warning(Message);
        debug(1, "SeqNum = (0x%04X,0x%04X)\n", ClientInfo[i].SeqNum[j],
              ClientInfo[i].SeqNum[j + 1]);
        ret = 0x04;             
        break;
      }
    }
  }
  return ret;
}

UINT8 IDS_Detect_FakeAP(void)
{
  // TODO
  //  must use CalcCoef ...
  return 0;
}

UINT8 IDS(void)
{
  UINT8 ret = 0;

  ret += IDS_BcnInt();
  ret += IDS_TimeStamp();
  ret += IDS_Var_SeqNum();
  ret += IDS_Detect_FakeAP();

  return (ret);
}

void AnalyseTAG221(UINT8 AddMac[WLAN_ADDR_LEN], UINT8 * varBits,
                   int tagLen)
{
  register UINT16 i;
  UINT8 hasWep = 0;
  UINT8 hasWPA = 0;
  UINT8 hasTKIP = 0;
  UINT8 hasCCMP = 0;
  UINT8 hasWPAPSK = 0;
  UINT8 hasWPA2PSK = 0;
  int offset = 0;
  int nb_UnicastCipherSuite = 0;
  int nb_AuthKeyMgmntSuite = 0;
  UINT8 Byte1, Byte2;


  if (tagLen - 6 >= offset && !memcmp(varBits, WPA_OUI "\x01", 4)) {
    debug(3, "Analyse of tag 221 : %02X%02X%02X%02X\n", varBits[0],
          varBits[1], varBits[2], varBits[3]);
    // At least 6 octets can be read and it's some WPA DATA
    hasWPA = 1;
    offset += 6;
    if (tagLen - 4 >= offset) {
      /* multicast cipher suite */
      if (!memcmp(&varBits[offset], WPA_OUI, 3)) {
        debug(2, "Multicast cipher suite : %02X%02X%02X\n",
              varBits[0 + offset], varBits[1 + offset],
              varBits[2 + offset]);
        offset += 3;
        switch (varBits[0 + offset]) {
        case 0:
          hasWPA = 0;           // Cypher NULL
          break;
        case 1:
          hasWPA = 0;
          hasWep = 1;           // WEP 40 bits
          break;
        case 2:
          hasTKIP = 1;          // TKIP
          break;
        case 3:                // AES (OCB) or WRAP
        case 4:
          hasCCMP = 1;          // AES (CCM)
          break;
        case 5:
          hasWPA = 0;
          hasWep = 1;           // WEP 104 bits;
          break;
        default:
          warning("WPA IE is with an unknowed cypher suite");
        }
        offset += 1;
        if (offset + 2 <= tagLen) {
          /* unicast cipher suites */
          // We Skip them
          // TODO : Analyse them !
          hasWPA = 1;
          Byte1 = (UINT8) varBits[offset + 0];
          Byte2 = (UINT8) varBits[offset + 1];
          nb_UnicastCipherSuite = Byte1 + (Byte2 << 8);
          debug(3, "nb_UnicastCipherSuite = %04X\n",
                nb_UnicastCipherSuite);
          offset += 2;
          debug(2, "Unicast cipher suite : %02X%02X%02X%02X\n",
                varBits[0 + offset], varBits[1 + offset],
                varBits[2 + offset], varBits[3 + offset]);
          offset += (4 * nb_UnicastCipherSuite);        // Skip it ...
          // TODO : if more than One Unicast Cipher Suite ...

          /* authenticated key management suites */
          if (offset + 2 <= tagLen) {
            Byte1 = (UINT8) varBits[offset + 0];
            Byte2 = (UINT8) varBits[offset + 1];
            nb_AuthKeyMgmntSuite = Byte1 + (Byte2 << 8);
            debug(3, "nb_AuthKeyMgmntSuite = %04X\n",
                  nb_AuthKeyMgmntSuite);
            offset += 2;
            while (offset + 4 <= tagLen) {
              offset += 3;
              switch (varBits[offset]) {
              case 0:
                break;          // NONE
              case 1:
                break;          // WPA
              case 2:
                if (hasCCMP)
                  hasWPA2PSK = 1;
                else
                  hasWPAPSK = 1;
                break;
              default:
                warning
                    ("WPA IE is with an unknowed authenticated key management suites : %02X\n",
                     varBits[offset]);
              }
            }
          }
        }
      }
    }
  } else if (tagLen - 7 >= offset
             && !memcmp(varBits, WME_OUI "\x02\x00", 5)) {
    // At least 7 octets can be read and it's some WME DATA
  } else if (tagLen - 24 >= offset
             && !memcmp(varBits, WME_OUI "\x02\x01", 5)) {
    // At least 24 octets can be read and it's some WME DATA
  } else if (tagLen - 56 >= offset
             && !memcmp(varBits, WME_OUI "\x02\x02", 5)) {
    // At least 56 octets can be read and it's some WME DATA
  } else if (tagLen - 4 >= offset && !memcmp(varBits, RSN_OUI "\x04", 4)) {
    // At least 4 octets can be read and it's some RSN DATA
    /* IEEE 802.11i / Key Data Encapsulation / Data Type=4 - PMKID.
     * This is only used within EAPOL-Key frame Key Data. */
  } else {
    1;                          // Unknowed Vendor ID, not interpreted
  }


  // Now save this analyse :-)
  for (i = 0; i < NumberOfDetectedClient; i++) {
    if (CompareAddMac(ClientInfo[i].BSSID, AddMac)) {
      ClientInfo[i].hasWep = hasWep;
      ClientInfo[i].hasWPA = hasWPA;
      ClientInfo[i].hasTKIP = hasTKIP;
      ClientInfo[i].hasCCMP = hasCCMP;
      ClientInfo[i].hasWPAPSK = hasWPAPSK;
      ClientInfo[i].hasWPA2PSK = hasWPA2PSK;
    }
  }
}

---