Salut,je suis en train de faire un detecteur d'attaque de FLOOD Syn,
j'ai utiliser une librairie LibCap ,mais le probleme cest que jarrive pas a filter les packets.J'arrive seulement a lire les packets,ie lentete du packet.
voila mais comment fair epour filtrer les packets?
voila la source
 
#include <stdio.h>
#include <pcap.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/ether.h>
#include <net/ethernet.h>
 
#define IP_LEN 17
 
void callback (u_char *args , const struct pcap_pkthdr *header , const u_char *packet) {
 int type;
 
 char adresse_source[IP_LEN];
 char adresse_destination[IP_LEN];
 
 unsigned short int port_source;
 unsigned short int port_destination;
 
 unsigned int numero_seq;
 unsigned int numero_ack_seq;
 
 const struct ether_header *eth;
 const struct iphdr *ip;
 const struct tcphdr *tcp;
 
 int size_ethernet = sizeof(struct ether_header);
 int size_ip = sizeof(struct iphdr);
 int size_tcp = sizeof(struct tcphdr);
 
 eth = (struct ether_header*) (packet);
 ip = (struct iphdr*) (packet + size_ethernet);
 tcp = (struct tcphdr*) (packet + size_ethernet + size_ip);
 
 type = ntohs(eth->ether_type);
 
 if (type != ETHERTYPE_IP)
  return;
 
 strncpy(adresse_source,(char *)inet_ntoa(ip->saddr),IP_LEN);
 strncpy(adresse_destination,(char *)inet_ntoa(ip->daddr),IP_LEN);
 
 int off;
 off = ntohs(ip->frag_off);
 if (!(off & 0x1fff) && (ip->protocol==IPPROTO_TCP)) {
  int syn = tcp->syn;
  int ack = tcp->ack;
   
  if ((syn) && (!ack)) {
   port_source = ntohs(tcp->source);
   port_destination = ntohs(tcp->dest);
   
        numero_seq = ntohl(tcp->seq);
   numero_ack_seq = ntohl(tcp->ack_seq);
 
   printf("Paquet TCP SYN
    Adresse IP src : %s  
    Adresse IP dest : %s  
    Port Source : %d  
    Port Destination : %d
    SEQ : %lu
    ACK : %lu\n\n"
   ,adresse_source,adresse_destination,port_source,port_destination,
   numero_seq,numero_ack_seq,tcp->syn,tcp->ack);
  }
 }
}
 
int main() {
 char *dev, errbuf[PCAP_ERRBUF_SIZE];
 dev = pcap_lookupdev(errbuf);
 printf("Device : %s\n" , dev);
 pcap_t *handle;
 handle = pcap_open_live(dev , BUFSIZ , 0  , 0 , errbuf);
 u_char *packet;
 pcap_loop (handle,-1,callback,NULL);
 pcap_close(handle);
}
 
 

bah faut faire ça dans le noyau!

cets a dire?

C'est à dire que c'a serait plutot un module pour netfilter qu'il faudrait que tu codes

et là attention aux conneries

uoi...en fait ya pas une ligne de code qui permet au moins  
que si je toruve un flood qui provient dune ip  fixe,je puisse  fermer toute connexion provenant de cette adresse ip.?                                                         ,

iptables -s adresse -j DROP

effectivement ça c'est faisable (à coups de iptables et de DROP/REJECT), mais autant le faire en shell

nan mais un module pour faire ça c'est vite fait...
init_module() ton init, aprés tu pleugue ton callback (qui fait return NF_DROP; ou  return NF_ACCEPT; ) dans netfilter avec nf_register_hook, tu bidouilles ton skbuff et pis cleanup_module() pour finir.

et là t'as un buffer overflow car t'as fait une connerie, et c'est la fête ...
 
alors qu'en shell ce sera bcp plus souple et robuste

 
Bah y'a qu'un pauvre compteur de syn à implémenter...  
D'un autre coté il pourrait trés bien le faire avec "seulement" iptables...
 
Et puis c'est rigolo et un minimum formateur de faire un fois dans sa vie un module noyo!!  

pour en avoir fais quelques uns je peux t'assurer que c'est "bien" pédagogiquement

 vi c'est vrai  
je dirais aussi : c'est "sympa" professionnellement!

moue

Ah sisi j'te jure...    
rien qu'expliquer à ton chef qu'on peut pas allouer 512Mo contigües comme ça, c'est "sympa"

et lui : "ah beh bien sûr" (mais qu'est ce qu'il dit lui )
 

pour faire le compteur ca a lair facile mais je suis bloquer,jai essayer de faire avec une liste mais ca marche pas;jai essayer avec une liste chaine mais marhce pas

tu fais un module, du coup?

 
Voilà, quoi, finger in the noze, mouaaaahhahahaha      
Je suis le seul à avoir rit devant autant de débauches techniques?

 
pas gentil ça!
 
Tu le prends comme tu veux, mais c'est plutôt plus simple techniquement de faire un kernel module qu'une appli en userspace. T'as déjà pas à t'emmerder à te farcir la doc de 25 libs, ce que t'as le droit d'utiliser c'est dans les .h de /usr/src/linux/include point barre. Nivo déboguage ca va bien avec une vm...
 
Pis bon "débauches techniques" si c'est parce que j'écris trois noms de fonctions et deux #define... t'as peut être jamais rien codé de ta vie???

Bon,jai reussit a faire le code qui "detecte" une attaque,
L'algorithme va consister a enregistrer les adresse ip ainsi que la date de reception des paquets arrivant sur la carte reseaux dans un tableau de structure.
Ce tableau sera gérée commme une file circulaire.
 
A chaque nouveau paquet(donc a chaque nouvelle ip),on execute une procedure qui va rechercher le nombre d'adresse ip identique a celle nouvellement recus,et si le nombre ces adresse ip est superieur a un certain nbre, de plus,si et ce si l'intervalle de temps entre le dernier paquet recus  
et le paquet en cours est inferieur a un certain nombre,alors on considere qu'il y a une attaque.
 
 
voila,mais si le paquet est spoofer,comment faire?
Est quil faut verifier la validite de l'adresse ip du client,et apres decider?(mais on aura jamais le temps de verfier).

le spoof sur le net tu peux oublier