struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, uint32_t);
    __type(value, uint64_t);
    __uint(max_entries, 1024);
} icmp_count_map SEC(".maps");

#include <linux/bpf.h>
#include <bpf/bpf_helpers.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/icmp.h>
#include <arpa/inet.h>

// Definición de eBPF Map
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, uint32_t);
    __type(value, uint64_t);
    __uint(max_entries, 1024);
} icmp_count_map SEC(".maps");

SEC("xdp")
int xdp_drop_icmp(struct xdp_md *ctx) {
    void *data_end = (void *)(unsigned long)ctx->data_end;
    void *data = (void *)(unsigned long)ctx->data;

    // Obtener el puntero de la cabecera Ethernet
    struct ethhdr *eth = data;
    if ((void *)eth + sizeof(*eth) > data_end)
        return XDP_PASS;

    // Verificar si el marco Ethernet contiene un paquete IP
    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;

    // Obtener el puntero de la cabecera IP
    struct iphdr *ip = data + sizeof(*eth);
    if ((void *)ip + sizeof(*ip) > data_end)
        return XDP_PASS;

    // Verificar si el protocolo es ICMP
    if (ip->protocol != IPPROTO_ICMP)
        return XDP_PASS;

    // Obtener el puntero de la cabecera ICMP
    struct icmphdr *icmp = (void *)ip + sizeof(*ip);
    if ((void *)icmp + sizeof(*icmp) > data_end)
        return XDP_PASS;

    // Extraer la dirección IP de origen
    uint32_t src_ip = ip->saddr;

    // Buscar en icmp_count_map utilizando la dirección IP de origen
    uint64_t *count = bpf_map_lookup_elem(&icmp_count_map, &src_ip);

    // Si el puntero de tipo u64 no es NULL, incrementar el conteo
    if (count) {
        __sync_fetch_and_add(count, 1);
    } else {
        // Si es NULL, añadir a icmp_count_map
        bpf_map_update_elem(&icmp_count_map, &src_ip, &(uint64_t){1}, BPF_ANY);
    }  

    // DROPAR el paquete ICMP
    return XDP_DROP;
}

char _license[] SEC("license") = "MIT";

$ clang -O2 -target bpf -g -c xdp.c -o xdp.o
$ sudo ip link set dev eth0 xdp obj xdp.o sec xdp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <linux/bpf.h>
#include <linux/if_link.h>
#include <bpf/libbpf.h>
#include <bpf/bpf.h>

int main(int argc, char **argv) {
    int map_fd = bpf_obj_get("/sys/fs/bpf/xdp/icmp_count_map");
    if (map_fd < 0) {
        perror("bpf_obj_get");
        return 1;
    }

    struct bpf_map_info map_info = {};
    uint32_t info_len = sizeof(map_info);
    if (bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len)) {
        perror("bpf_obj_get_info_by_fd");
        return 1;
    }

    // Mostrar la información del Map
    printf("Nombre del Map: %s\n", map_info.name);
    printf("Tipo del Map: %d\n", map_info.type);
    printf("Tamaño de clave del Map: %d\n", map_info.key_size);
    printf("Tamaño de valor del Map: %d\n", map_info.value_size);
    printf("Máximo de entradas del Map: %d\n", map_info.max_entries);

    // Obtener todas las entradas
    uint32_t key, next_key;
    uint64_t value;
    key = next_key = 0;
    while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
        key = next_key; // Usar la clave actualizada
        if (bpf_map_lookup_elem(map_fd, &key, &value) == 0) {
            // Convertir la dirección IP a una cadena
            char ip_str[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &key, ip_str, sizeof(ip_str));
            printf("Clave: %s, Valor: %lu\n", ip_str, value);
        }
        key = next_key; // Prepararse para la siguiente iteración
    }

    return 0;
}

$ gcc -o map_info map_info.c -lbpf
$ sudo ./map_info
Nombre del Map: icmp_count_map
Tipo del Map: 1
Tamaño de clave del Map: 4
Tamaño de valor del Map: 8
Máximo de entradas del Map: 1024
Clave: 192.168.XX.10, Valor: 320
Clave: 192.168.XX.11, Valor: 2307

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <linux/bpf.h>
#include <linux/if_link.h>
#include <bpf/libbpf.h>
#include <bpf/bpf.h>
#include <unistd.h>
#include <net/if.h>

int main(int argc, char **argv) {
    struct bpf_object *obj;
    struct bpf_map *map;
    struct bpf_program *prog;
    struct bpf_link *link = NULL;
    int map_fd, prog_fd;
    int err;

    if (argc != 2) {
        fprintf(stderr, "Uso: %s <interface>\n", argv[0]);
        return 1;
    }

    // Cargar programa xdp
    obj = bpf_object__open_file("./xdp.o", NULL);
    if (libbpf_get_error(obj)) {
        perror("Fallo al abrir el objeto BPF");
        return 1;
    }

    if (bpf_object__load(obj)) {
        perror("Fallo al cargar el objeto BPF");
        return 1;
    }

    // Obtener el programa
    prog = bpf_object__find_program_by_name(obj, "xdp_drop_icmp");
    if (libbpf_get_error(prog)) {
        perror("Fallo al encontrar programa BPF por nombre");
        return 1;
    }

    // Obtener el Map
    map = bpf_object__find_map_by_name(obj, "icmp_count_map");
    if (!map) {
        perror("Fallo al encontrar Map BPF por nombre");
        return 1;
    }

    map_fd = bpf_map__fd(map);
    if (map_fd < 0) {
        perror("Fallo al obtener fd del map");
        return 1;
    }

    // Adjuntar el programa XDP a eth0
    const char* if_name = argv[1];
    int ifindex = if_nametoindex(if_name);
    if (ifindex == 0) {
        perror("Fallo al obtener el índice de la interfaz");
        return 1;
    }

    link = bpf_program__attach_xdp(prog, ifindex);
    if (libbpf_get_error(link)) {
        perror("Fallo al adjuntar el programa XDP");
        return 1;
    }

    // Mostrar el estado del mapa cada segundo en un bucle infinito
    while (1) {
        // Línea divisoria
        printf("==============================\n");
        // Mostrar información del Map
        struct bpf_map_info map_info = {};
        uint32_t info_len = sizeof(map_info);
        if (bpf_obj_get_info_by_fd(map_fd, &map_info, &info_len)) {
            perror("Fallo al obtener información del mapa");
            return 1;
        }

        printf("Nombre del Map: %s\n", map_info.name);
        printf("Tipo del Map: %d\n", map_info.type);
        printf("Tamaño de clave del Map: %d\n", map_info.key_size);
        printf("Tamaño de valor del Map: %d\n", map_info.value_size);
        printf("Máximo de entradas del Map: %d\n", map_info.max_entries);

        // Obtener todas las entradas
        uint32_t key, next_key;
        uint64_t value;
        key = next_key = 0;
        while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
            key = next_key; // Usar la clave actualizada
            if (bpf_map_lookup_elem(map_fd, &key, &value) == 0) {
                // Convertir la dirección IP a una cadena
                char ip_str[INET_ADDRSTRLEN];
                inet_ntop(AF_INET, &key, ip_str, sizeof(ip_str));
                printf("Clave: %s, Valor: %lu\n", ip_str, value);
            }
            key = next_key; // Preparar para la próxima iteración
        }
        sleep(1);  // Bucle con un intervalo de 1 segundo
    }

    return 0;
}