mcy
/
owlps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
owlps/loc-mobile/librtapscanmob/librtapscanmob.c

601 lines
20 KiB
C
Raw Blame History

/*
* This is the rtapanalyser library, Wi-Fi packet sniffer and analyser,
* thanks to the radiotap header of each packet.
*/
#include "rtapscanmob.h"
BOOL run = TRUE ;
/* Capture des paquets en utilisant l'interface "capture_iface" pendant "capture_time" millisecondes,
* et enregistre les paquets lus dans "results" */
int capture(char *capture_iface, unsigned long capture_time, mac_list **results, BOOL print_values)
{
pcap_t *handle ; // Descripteur de capture de paquets
char errbuf[PCAP_ERRBUF_SIZE] ; // Message d'erreur
struct timeval tbegin, tcurrent ;
/* Sous-fonction de traitement des paquets capturés */
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet)
{
read_packet(args, header, packet, results, print_values) ; // On appelle la fonction read_packet() avec les mêmes arguments, plus "results" que l'on passe en modification, et "print_values" qui indique si on doit afficher le paquet.
}
handle = pcap_open_live(capture_iface, BUFSIZ, 1, 1000, errbuf) ; // Début de la capture
if (handle == NULL) // Le lancement de la capture a-t-il échoué ?
{
fprintf(stderr, "Impossible d'ouvrir l'interface « %s » : %s\n", capture_iface, errbuf) ;
return ERR_OPENING_IFACE ;
}
if (capture_time > 0) // Si le temps de capture est positif
{
gettimeofday(&tbegin, NULL) ; // Récupère l'heure courante (heure du lancement de la capture)
while (run)
{
pcap_loop(handle, 1, got_packet, NULL) ; // Collecte 1 paquet et appelle la fonction got_packet quand pcaploop a recupéré des paquets
gettimeofday(&tcurrent, NULL) ; // Récupère l'heure courante
if(sub_date(tcurrent, tbegin) > capture_time) // Si le temps de capture est écoulé
break ; // on arrête la collecte.
}
}
else // On fonctionne en mode démon (tant que run est vrai)
while (run)
pcap_loop(handle, 1, got_packet, NULL) ; // Collecte 1 paquet et appelle la fonction got_packet quand pcaploop a recupéré des paquets
pcap_close(handle) ; // Arrêt de la capture.
return 0 ;
}
/* Traite un paquet et enregistre les valeurs dans la liste des résultats (results) */
void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet, mac_list **results, BOOL print_values)
{
unsigned char *data = (unsigned char *) packet ; // Recopie dans data l'adresse du paquet capturé
unsigned short rtap_bytes ; // Taille des données reçues
unsigned int rtap_presentflags, rtap_position ;
BOOL check[15] ; // Champs présents
unsigned char raw_packet_type ; // Type du packet reçu (beacon, data...)
unsigned char mac_addr_bytes[6] ;
mac_list *tmp_mac = NULL ;
ss_list *tmp_ss = NULL ;
int i ; // Compteur
memcpy(&rtap_bytes, &data[2], sizeof(unsigned short)) ; // Recopie les deux octets à partir du troisième octet de donnée qui est la taille de l'en-tête rtap (change avec des flags)
raw_packet_type = data[rtap_bytes] ; // Au bout de l'en-tête rtap il y a celle du 802.11 dont le premier determine le type (beacon ou pas)
if (raw_packet_type == RAW_PACKET_TYPE_BEACON) // Si le paquet est de type beacon, on le traite
{
memcpy(mac_addr_bytes, &data[rtap_bytes+10], 6); // Dans le cas du beacon, l'adresse MAC est 10 octets plus loin que le type de paquet
memcpy(&rtap_presentflags, &data[RTAP_P_PRESENTFLAGS], RTAP_L_PRESENTFLAGS); // Récupère les flags de l'en-tête rtap
/* Ajout du résultat du scan à la structure */
tmp_ss = malloc(sizeof(ss_list)) ;
tmp_ss->next = NULL ;
memcpy(&(tmp_ss->header_revision), &data[RTAP_P_HREVISION], RTAP_L_HREVISION) ;
memcpy(&(tmp_ss->header_pad), &data[RTAP_P_HPAD], RTAP_L_HPAD) ;
memcpy(&(tmp_ss->header_length), &data[RTAP_P_HLENGTH], RTAP_L_HLENGTH) ;
memcpy(&(tmp_ss->present_flags), &data[RTAP_P_PRESENTFLAGS], RTAP_L_PRESENTFLAGS) ;
for(i = 0 ; i < 15 ; i++) // Initialisation de la structure des champs présents
tmp_ss->check[i] = FALSE ;
rtap_position = 8 ; // début des champs déterminés par le present flag
if (print_values)
{
char *mac_string = mac_bytes_to_string(mac_addr_bytes) ;
printf("[%s]\n", mac_string) ;
printf("Header revision : %hhu\n", tmp_ss->header_revision) ;
printf("Header Pad : %hhu\n", tmp_ss->header_pad) ;
printf("Header Length : %hu\n", tmp_ss->header_length) ;
printf("Present flags : %#010lx\n", tmp_ss->present_flags) ;
free(mac_string) ;
}
for(i=0 ; i < 15 ; i++) // on teste les 15 premiers bits du champ flag afin de valider la présence et de les copier
{
if((rtap_presentflags % 2) == 1)
{
switch(i)
{
case RTAP_MACTS:
memcpy(&(tmp_ss->mac_timestamp), &data[rtap_position], RTAP_L_MACTS) ;
tmp_ss->check[RTAP_MACTS] = TRUE ;
if (print_values)
printf("Mac timestamp : %llu\n", tmp_ss->mac_timestamp) ;
rtap_position += RTAP_L_MACTS ;
break ;
case RTAP_FLAGS:
memcpy(&(tmp_ss->flags), &data[rtap_position], RTAP_L_FLAGS) ;
tmp_ss->check[RTAP_FLAGS] = TRUE;
if (print_values)
printf("Flags : %hu\n", tmp_ss->flags);
rtap_position += RTAP_L_FLAGS ;
break ;
case RTAP_RATE:
memcpy(&(tmp_ss->data_rate), &data[rtap_position], RTAP_L_RATE) ;
tmp_ss->check[RTAP_RATE] = TRUE;
if (print_values)
printf("Data rate : %hhd MB/s\n", tmp_ss->data_rate / 2) ;
rtap_position += RTAP_L_RATE ;
break ;
case RTAP_CHANNEL:
memcpy(&(tmp_ss->channel), &data[rtap_position], RTAP_L_CHANNEL) ;
rtap_position += RTAP_L_CHANNEL ;
tmp_ss->check[RTAP_CHANNEL] = TRUE;
memcpy(&(tmp_ss->channel_type), &data[rtap_position], RTAP_L_CHANNELTYPE) ;
if (print_values)
printf("Channel : %hu MHz\nChannel Type : %#06x\n", tmp_ss->channel, tmp_ss->channel_type);
rtap_position += RTAP_L_CHANNELTYPE ;
break ;
case RTAP_FHSS:
memcpy(&(tmp_ss->fhss), &data[rtap_position], RTAP_L_FHSS) ;
tmp_ss->check[RTAP_FHSS] = TRUE;
if (print_values)
printf("FHSS : %hu\n", tmp_ss->fhss);
rtap_position += RTAP_L_FHSS ;
break ;
case RTAP_ANTENNASIGNALDBM:
memcpy(&(tmp_ss->antenna_signal_dbm), &data[rtap_position], RTAP_L_ANTENNASIGNALDBM) ;
tmp_ss->check[RTAP_ANTENNASIGNALDBM] = TRUE;
if (print_values)
printf("Antenna Signal : %d dBm\n", tmp_ss->antenna_signal_dbm - 0x100);
rtap_position += RTAP_L_ANTENNASIGNALDBM ;
break ;
case RTAP_ANTENNANOISEDBM:
memcpy(&(tmp_ss->antenna_noise_dbm), &data[rtap_position], RTAP_L_ANTENNANOISEDBM) ;
tmp_ss->check[RTAP_ANTENNANOISEDBM] = TRUE;
if (print_values)
printf("Antenna Noise : %d dBm\n", tmp_ss->antenna_noise_dbm - 0x100);
rtap_position += RTAP_L_ANTENNANOISEDBM ;
break ;
case RTAP_LOCKQUALITY:
memcpy(&(tmp_ss->lock_quality), &data[rtap_position], RTAP_L_LOCKQUALITY) ;
tmp_ss->check[RTAP_LOCKQUALITY] = TRUE;
if (print_values)
printf("Lock Quality : %hu\n", tmp_ss->lock_quality);
rtap_position += RTAP_L_LOCKQUALITY ;
break ;
case RTAP_TXATTENUATION:
memcpy(&(tmp_ss->tx_attenuation), &data[rtap_position], RTAP_L_TXATTENUATION) ;
tmp_ss->check[RTAP_TXATTENUATION] = TRUE;
if (print_values)
printf("Taux Attenuation : %hu\n", tmp_ss->tx_attenuation);
rtap_position += RTAP_L_TXATTENUATION ;
break ;
case RTAP_TXATTENUATIONDB:
memcpy(&(tmp_ss->tx_attenuation_db), &data[rtap_position], RTAP_L_TXATTENUATIONDB) ;
tmp_ss->check[RTAP_TXATTENUATIONDB] = TRUE;
if (print_values)
printf("Atténuation : %hu dB\n", tmp_ss->tx_attenuation_db);
rtap_position += RTAP_L_TXATTENUATIONDB ;
break ;
case RTAP_TXATTENUATIONDBM:
memcpy(&(tmp_ss->tx_attenuation_dbm), &data[rtap_position], RTAP_L_TXATTENUATIONDBM) ;
tmp_ss->check[RTAP_TXATTENUATIONDBM] = TRUE;
if (print_values)
printf("Atténuation : %hu dBm\n", tmp_ss->tx_attenuation_dbm);
rtap_position += RTAP_L_TXATTENUATIONDBM ;
break ;
case RTAP_ANTENNA:
memcpy(&(tmp_ss->antenna), &data[rtap_position], RTAP_L_ANTENNA) ;
tmp_ss->check[RTAP_ANTENNA] = TRUE;
if (print_values)
printf("Antenna : %hhu\n", tmp_ss->antenna);
rtap_position += RTAP_L_ANTENNA ;
break ;
case RTAP_ANTENNASIGNALDB:
memcpy(&(tmp_ss->antenna_signal_db), &data[rtap_position], RTAP_L_ANTENNASIGNALDB) ;
tmp_ss->check[RTAP_ANTENNASIGNALDB] = TRUE;
if (print_values)
printf("Antenna Signal : %hhu dB\n", tmp_ss->antenna_signal_db);
rtap_position += RTAP_L_ANTENNASIGNALDB ;
break ;
case RTAP_ANTENNANOISEDB:
memcpy(&(tmp_ss->antenna_noise_db), &data[rtap_position], RTAP_L_ANTENNANOISEDB) ;
tmp_ss->check[RTAP_ANTENNANOISEDB] = TRUE;
if (print_values)
printf("Antenna Noise : %hhu dB\n", tmp_ss->antenna_noise_db);
rtap_position += RTAP_L_ANTENNANOISEDB ;
break ;
case RTAP_FCS:
memcpy(&(tmp_ss->fcs), &data[rtap_position], RTAP_L_FCS) ;
tmp_ss->check[RTAP_FCS] = TRUE;
if (print_values)
printf("FCS : %lu\n", tmp_ss->fcs) ;
rtap_position += RTAP_L_FCS ;
break ;
}
}
rtap_presentflags /= 2 ;
}
if (print_values)
printf("\n") ;
tmp_mac = *results ;
if(*results == NULL) // Si la liste de résultats n'existe pas encore,
{
tmp_mac = malloc(sizeof(mac_list)) ; // on la crée.
memcpy(tmp_mac->mac_addr_bytes, mac_addr_bytes, 6) ;
tmp_mac->nb_samples = 1 ;
tmp_mac->next = NULL ;
tmp_mac->samples_list = tmp_ss ;
*results = tmp_mac ;
}
else
{
while(tmp_mac != NULL)
{
if(mac_cmp(mac_addr_bytes, tmp_mac->mac_addr_bytes) == 1)
break ;
tmp_mac = tmp_mac->next ;
}
if(tmp_mac == NULL)
{
tmp_mac = malloc(sizeof(mac_list)) ;
memcpy(tmp_mac->mac_addr_bytes, mac_addr_bytes, 6) ;
tmp_mac->nb_samples = 1 ;
tmp_mac->next = *results ;
tmp_mac->samples_list = tmp_ss ;
*results = tmp_mac ;
}
else
{
tmp_mac->nb_samples++ ;
tmp_ss->next = tmp_mac->samples_list ;
tmp_mac->samples_list = tmp_ss ;
}
}
}
}
/* Affiche la liste chaînée des résultats */
void print_mac_list(mac_list *results, BOOL verbose)
{
mac_list *mac_ptr = results ; // Récupère la liste d'adresse MAC en entrée
ss_list *ss_ptr = NULL ; // Initialise la sous-liste
char *mac_string ;
double antenna_signal_average = 0 ; // Moyenne des valeurs récupérées de antenna signal en dBm
double antenna_noise_average = 0; // Moyenne des valeurs récupérées de antenna noise en dBm
double data_rate_average = 0; // Moyenne du débit
unsigned short channel = -1 ; // Canal utilisé pour la MAC courante
unsigned short channel_type = -1 ; // Type de liaison utilisée pour la MAC courante
if (results == NULL) // Si la liste est vide
{
printf("Aucun résultat.\n") ; // on l'affiche.
return ;
}
while (mac_ptr != NULL)
{
mac_string = mac_bytes_to_string(mac_ptr->mac_addr_bytes) ;
ss_ptr = mac_ptr->samples_list ; // On récupère le pointeur de la sous-liste
antenna_signal_average = 0 ;
antenna_noise_average = 0 ;
data_rate_average = 0 ;
while (ss_ptr != NULL) // On parcourt toutes les valeurs de l'affaiblissement en dB et on en fait la moyenne.
{
antenna_signal_average += pow((double)10, ((double)(ss_ptr->antenna_signal_dbm - 0x100) / 10)) ; // Il faut le minorer de 256 pour avoir la vrai puissance car sinon codage serai sur plus d'un octet.
antenna_noise_average += pow((double)10, ((double)(ss_ptr->antenna_noise_dbm - 0x100) / 10)) ;
data_rate_average += ((ss_ptr->data_rate) / 2);
channel = ss_ptr->channel ;
channel_type = ss_ptr->channel_type ;
if (verbose) // Affichage du maillon si on est en mode verbeux.
{
printf("[%s]\n", mac_string) ;
print_ss_list(ss_ptr) ;
putchar('\n') ;
}
ss_ptr = ss_ptr->next ;
}
/* Calcul des moyennes */
antenna_signal_average = 10 * log10((double)(antenna_signal_average / mac_ptr->nb_samples)) ;
antenna_noise_average = 10 * log10((double)(antenna_noise_average / mac_ptr->nb_samples)) ;
data_rate_average /= (double)mac_ptr->nb_samples ;
/* Affichage */
printf("[%s] [Canal : %hhd] [Fréquence : %hu MHz] [Type de liaison : %#06x] [Moyenne du débit : %0.1f Mo/s] [Moyenne du signal : %0.1f dBm] [Moyenne du bruit : %0.1f dBm]\n", mac_string, frequency_to_channel(channel), channel, channel_type, data_rate_average, antenna_signal_average, antenna_noise_average) ;
if (verbose)
printf("\n\n") ;
free(mac_string) ;
mac_ptr = mac_ptr->next ;
}
}
/* Affiche un maillon d'une sous-liste de résultats */
void print_ss_list(ss_list *ss)
{
if (ss == NULL)
return ;
/* Champs statiques */
printf("Header revision : %hhu\n", ss->header_revision) ;
printf("Header Pad : %hhu\n", ss->header_pad) ;
printf("Header Length : %hu\n", ss->header_length) ;
printf("Present flags : %#010lx\n", ss->present_flags) ; // Largeur de champ 10 : 2 pour "0x" et 8 pour la valeur.
/* Champs dynamiques */
if (ss->check[RTAP_MACTS])
printf("Mac timestamp : %llu\n", ss->mac_timestamp) ;
if (ss->check[RTAP_FLAGS])
printf("Flags : %hu\n", ss->flags) ;
if (ss->check[RTAP_RATE])
printf("Data rate : %hhd MB/s\n", ss->data_rate / 2) ;
if (ss->check[RTAP_CHANNEL])
printf("Channel : %hu MHz\nChannel Type : %#06x\n", ss->channel, ss->channel_type) ;
if (ss->check[RTAP_FHSS])
printf("FHSS : %hu\n", ss->fhss) ;
if (ss->check[RTAP_ANTENNASIGNALDBM])
printf("Antenna Signal : %d dBm\n", ss->antenna_signal_dbm - 0x100) ;
if (ss->check[RTAP_ANTENNANOISEDBM])
printf("Antenna Noise : %d dBm\n", ss->antenna_noise_dbm - 0x100) ;
if (ss->check[RTAP_LOCKQUALITY])
printf("Lock Quality : %hu\n", ss->lock_quality) ;
if (ss->check[RTAP_TXATTENUATION])
printf("Taux Attenuation : %hu\n", ss->tx_attenuation) ;
if (ss->check[RTAP_TXATTENUATIONDB])
printf("Atténuation : %hu dB\n", ss->tx_attenuation_db) ;
if (ss->check[RTAP_TXATTENUATIONDBM])
printf("Atténuation : %hu dBm\n", ss->tx_attenuation_dbm) ;
if (ss->check[RTAP_ANTENNA])
printf("Antenna : %hhu\n", ss->antenna) ;
if (ss->check[RTAP_ANTENNASIGNALDB])
printf("Antenna Signal : %hhu dB\n", ss->antenna_signal_db) ;
if (ss->check[RTAP_ANTENNANOISEDB])
printf("Antenna Noise : %hhu dB\n", ss->antenna_noise_db) ;
if (ss->check[RTAP_FCS])
printf("FCS : %lu\n", ss->fcs) ;
}
/* Vide la liste chaînée d'adresse MAC */
void free_mac_list(mac_list **results)
{
mac_list *mac_ptr = *results ;
ss_list *ss_ptr = NULL ;
if (*results != NULL)
{
while(mac_ptr != NULL)
{
ss_ptr = mac_ptr->samples_list ;
while (ss_ptr != NULL)
{
ss_ptr = ss_ptr->next ;
free(mac_ptr->samples_list) ;
mac_ptr->samples_list = ss_ptr ;
}
mac_ptr = mac_ptr->next ;
free(*results) ;
*results = mac_ptr ;
}
}
}
/* Enregistre la liste "results" dans le fichier nommé "file" */
int write_mac_list_to_file(char *file, mac_list *results)
{
int fd = 0 ; // Descripteur de fichier.
mac_list *ptr ; // Tête de lecture de la liste chaînée.
ss_list *ss_ptr ; // Tête de lecture de la sous-liste.
int mac_list_size = sizeof(mac_list) ;
int ss_list_size = sizeof(ss_list) ;
/* Ouverture du fichier */
fd = open(file, O_WRONLY | O_CREAT) ;
if (fd < 0)
{
perror("Impossible d'ouvrir le fichier de sortie ") ;
return ERR_OPENING_FILE ;
}
/* Écriture des données */
ptr = results ; // On commence par la tête de la liste (forcément...).
while (ptr != NULL)
{
/* Enregistrement du maillon de la liste principale */
if (write(fd, ptr, mac_list_size) != mac_list_size)
perror("Erreur d'écriture (mac_list) ") ;
/* Enregistrement de la sous-liste */
ss_ptr = ptr->samples_list ;
while (ss_ptr != NULL)
{
if (write(fd, ss_ptr, ss_list_size) != ss_list_size) // Écriture du maillon courant.
perror("Erreur d'écriture (ss_list) ") ;
ss_ptr = ss_ptr->next ;
}
ptr = ptr->next ;
}
/* Fermeture du fichier */
if (close(fd) != 0)
{
perror("Erreur lors de la fermeture du fichier de sortie ") ;
return ERR_CLOSING_FILE ;
}
return 0 ;
}
/* Lit le fichier nommé "file" et enregistre la liste lue dans "results" */
int read_mac_list_from_file(char *file, mac_list **results)
{
int fd = 0 ; // Descripteur de fichier.
mac_list *ptr = NULL ; // Tête de lecture de la liste chaînée.
ss_list *ss_ptr ; // Tête de lecture de la sous-liste.
ss_list *ss_prev ; // Maillon précédent lors de la lecture.
int mac_list_size = sizeof(mac_list) ;
int ss_list_size = sizeof(ss_list) ;
mac_list mac_list_lu ;
ss_list ss_list_lu ;
/* Ouverture du fichier */
fd = open(file, O_RDONLY) ;
if (fd < 0)
{
perror("Impossible d'ouvrir le fichier d'entrée ") ;
return ERR_OPENING_FILE ;
}
/* Lecture des données */
while (read(fd, &mac_list_lu, mac_list_size) == mac_list_size) // Lecture du premier champ
{
/* Allocation du maillon courant */
if (*results == NULL)
{
*results = malloc(mac_list_size) ; // Création de la liste
ptr = *results ;
}
else
{
ptr->next = malloc(mac_list_size) ; // Création du maillon suivant
ptr = ptr->next ;
}
*ptr = mac_list_lu ;
/* Lecture de la sous-liste */
ss_prev = NULL ;
ss_ptr = ptr->samples_list ;
while (ss_ptr != NULL)
{
if (read(fd, &ss_list_lu, ss_list_size) != ss_list_size) // Lecture d'un maillon ss_list.
perror("Erreur de lecture (ss_list) ") ;
else // Si on a bien lu un maillon entier :
{
if (ss_prev == NULL) // Si c'est le premier maillon,
{
ptr->samples_list = malloc(ss_list_size) ; // allocation du premier maillon.
ss_ptr = ptr->samples_list ;
}
else // Si ce n'est pas le premier maillon,
{
ss_prev->next = malloc(ss_list_size) ; // allocation d'un nouveau maillon.
ss_ptr = ss_prev->next ;
}
*ss_ptr = ss_list_lu ;
ss_prev = ss_ptr ;
ss_ptr = ss_ptr->next ;
}
}
if (ss_prev != NULL)
ss_prev->next = NULL ;
}
if (ptr != NULL)
ptr->next = NULL ;
/* Fermeture du fichier */
if (close(fd) != 0)
perror("Erreur lors de la fermeture du fichier de sortie ") ;
return 0 ;
}
/* Enregistre la liste "results" dans le fichier nommé "file", au format texte */
int write_mac_list_to_text_file(char *file, mac_list *results, char direction, float pos_x, float pos_y, float pos_z)
{
FILE *fd = NULL ; // Descripteur de fichier.
mac_list *ptr ; // Tête de lecture de la liste chaînée.
ss_list *ss_ptr ; // Tête de lecture de la sous-liste.
/* Ouverture du fichier */
fd = fopen(file, "a") ; // Ouverture du fichier de sortie en ajout
if (fd == NULL) // Si ouverture échouée,
{
perror("Impossible d'ouvrir le fichier de sortie ") ;
fprintf(stderr, "Redirection de la sortie sur la sortie standard.") ;
fd = stdout ; // on redirige sur stdout
}
/* Écriture des données */
ptr = results ; // On commence par la tête de la liste (forcément...).
while (ptr != NULL)
{
char *mac_string ;
/* Enregistrement des données fixes */
fprintf(fd, "%0.2f;%0.2f;%0.2f;%hhd", pos_x, pos_y, pos_z, direction) ;
/* Enregistrement du maillon de la liste principale */
mac_string = mac_bytes_to_string(ptr->mac_addr_bytes) ;
fprintf(fd, ";%s", mac_string) ;
/* Enregistrement de la sous-liste */
ss_ptr = ptr->samples_list ;
while (ss_ptr != NULL)
{
fprintf(fd, ";%d", ss_ptr->antenna_signal_dbm - 0x100) ; // Écriture de la puissance du signal
ss_ptr = ss_ptr->next ;
}
fprintf(fd, "\n") ;
free(mac_string) ;
ptr = ptr->next ;
}
/* Fermeture du fichier */
if (fclose(fd) != 0)
{
perror("Erreur lors de la fermeture du fichier de sortie ") ;
return ERR_CLOSING_FILE ;
}
return 0 ;
}
Reference in New Issue View Git Blame Copy Permalink