C:/Anonymizer/anonymizer0_3_3.cpp

Go to the documentation of this file.

#include <pcap.h>
#include <net/ethernet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <netinet/ip_icmp.h>

/*//-----I seguenti solo per FreeBSD--------
#include <netinet/ip_var.h>
#include <netinet/udp_var.h>
#include <netinet/tcp_var.h>
#include <netinet/icmp_var.h>
//-------Fine FreeBSD--------------
*/

/*
#include <pcap.h>
#include <stdio.h>
#include <netinet/udp.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netinet/ether.h>
#include <netinet/ip_icmp.h>
#include <time.h>
*/

#include "Codifier.h"
#define PACKET_SIZE 65535


void sec_to_min(long seconds, double usec);

typedef struct{
  int live;
  int dimPayload;  
  int dimIPaddr;   
  int cutPayload;  
  int verbose;
  int invalidOption;
  int prefix;
}options;       

typedef struct{
  struct in_addr src;
  struct in_addr dst;
  u_int8_t zeros;
  u_int8_t prot;//=ipp->ip_p;
  u_int16_t transplen;//udp (or tcp)->len;
}pseudo1;

pcap_t *pcap_open_live (const char *device, int snaplen, int promisc, int to_ms, char *errbuf);
pcap_t *pcap_open_offline(const char *input,char *errbuf);
int pcap_findalldevs(pcap_if_t **alldevsp, char *errbuf);
pcap_dumper_t *pcap_dump_open(pcap_t *descr, const char *output);
void pcap_dump(u_char *user, const struct pcap_pkthdr *h, const u_char *sp);                     
void pcap_dump_close(pcap_dumper_t *p);
void pcap_close(pcap_t *p);
const u_char *pcap_next(pcap_t *p, struct pcap_pkthdr *h);
int pcap_datalink(pcap_t *p);

options readOptions(int argcc,char **argv,int *count);

void processIP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o, Codifier&);
void processARP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o, Codifier& codificatore);
void processUDP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o);
void processTCP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o);
void processICMP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o, Codifier& codificatore);

int handle_ip(const struct ip* ip,int *lev4);
int Checksum(const u_char* Buff, int BufLen);
int checksumTCPUDP(const struct in_addr src, const struct in_addr dst,const u_int8_t protocol,const u_int16_t length,u_char *pkth);

void showHelp();
int pktprocessed,pktanonymized,pktdropped;

//------------------------------------------------main---------------------------------------------
int main(int argc,char **argv){

   struct timeval pstart,pstop;
   long seconds;
   double usec;
   srand(time(NULL) * clock());
   Codifier codificatore;
   int promisc=1;
   int count;   
   // signal(SIGINT, sigproc);
  if((argc==1)||(strcmp(argv[1],"--help")==0)){
    showHelp();
        return 0;
  }       
 
 options o=readOptions(argc,argv,&count);
  if(o.invalidOption) return 0;
  if((o.verbose==1)||(o.dimPayload==0)||
        (o.dimIPaddr==0)||(o.cutPayload==1)||(o.live==1)) fprintf(stdout,"\n\n----****Options****----\n");       
  if(o.verbose==1) fprintf(stdout,"enable count...\n");
  if(o.dimPayload==0) fprintf(stdout,"disable payload darkening...\n");
  if(o.dimIPaddr==0) fprintf(stdout,"disable IP address darkening...\n");         
  if(o.cutPayload==1) fprintf(stdout,"enable cut payload...\n");
  if(o.prefix==1) fprintf(stdout,"enable prefix-preserving...\n");
  if(o.live==1) {
        fprintf(stdout,"enable live anonymizing...\n\n"); 
  
    pcap_if_t *interfaccia, *d;
    unsigned int select,npack;
    char errbuf[PCAP_ERRBUF_SIZE];
    pcap_t *descr; 
    pcap_dumper_t *descrOUT;
    const u_char * datipkt;
    struct pcap_pkthdr hdr;     
    char *output;
    u_int i=0;
    struct pcap_stat ps;

     if (pcap_findalldevs(&interfaccia, errbuf) == -1)
        {
          printf("Error to find the devices :%s\n",errbuf);
          return 0;
        } 
         for(d=interfaccia; d; d=d->next)
        {
          printf("%d. %s", ++i, d->name);

          if (d->description)
            printf(" (%s)\n", d->description);
          else
           printf(" (no description available)\n");
        }
        if(i==0)
           printf("No device!");
        
        do{
      printf("Select the device. Type a number. \n");
      scanf("%d",&select);
     } while(select<1 || select>i);
     
    for (d=interfaccia,i=0; i<select-1;d=d->next,i++);   

   printf("Insert the number of packets to capture:\n");
   scanf("%d",&npack);  
              
   if ((descr= pcap_open_live(d->name, PACKET_SIZE, promisc, -1, errbuf) ) == NULL)
          printf("Error : %s \n",errbuf);

   char temp[100];  //argv max. 100 caratteri
   strcpy(temp,argv[count]);
   output=strcat(temp,".anonim");
   
   descrOUT = pcap_dump_open(descr,output); 
   if(descrOUT==NULL) printf("Error in writing\n");
   
  fprintf(stdout,"\nAnonymizer version 0.3 processing...\n");
  fprintf(stdout,"(sourceforge.net/project/Anonymizer)\n\n");

  fprintf(stdout,"%s anonymizing...\n",argv[count]);
          
    if(o.verbose)
      fprintf(stdout,"\nPacket number: %d\n", 0);
   pktprocessed=0;
   pktanonymized=0;
   pktdropped=0;         
   gettimeofday(&pstart,NULL);    
  
   for(unsigned int i=0; i< npack; i++){ 
   datipkt=pcap_next(descr,&hdr);
        int datalink;
    pktprocessed=pktprocessed+1;
    
    if(o.verbose)
           fprintf(stdout," %d\n",pktprocessed);        

           
    if(pktprocessed>=0){
     if((datalink=pcap_datalink(descr)) != DLT_EN10MB ){
     //scarto i pacchetti non Ethernet 10, 100, 1000 (in pratica nessuno...a noi)
         pktdropped=pktdropped+1;
         }      
     else{ //si va avanti nella pila
      //consideriamo solo trame ethernet IP e da li IP->UDP, IP->TCP, IP->ICMP e ARP
      u_int16_t tipoeth;
      struct ether_header *eptr;  
      eptr=(struct ether_header *) (datipkt);
          tipoeth=eptr->ether_type; 
      
      //Se l'indirizzo mac sorgente non è broadcast (?!), lo cambio in 1.2.3.x.y.z (in hex 01.02.03.xx.yy.zz) dove x,y,z sono quelli originari
      if(!((eptr->ether_shost[0]==255)&&(eptr->ether_shost[1]==255)&&(eptr->ether_shost[2]==255)&&(eptr->ether_shost[3]==255)&&(eptr->ether_shost[4]==255)&&(eptr->ether_shost[5]==255)))
        
           eptr->ether_shost[0]=1;eptr->ether_shost[1]=2;eptr->ether_shost[2]=3;
        
      //Se l'indirizzo mac destinazione non è broadcast, lo cambio in 1.2.3.x.y.z 
      if(!((eptr->ether_dhost[0]==255)&&(eptr->ether_dhost[1]==255)&&(eptr->ether_dhost[2]==255)&&(eptr->ether_dhost[3]==255)&&(eptr->ether_dhost[4]==255)&&(eptr->ether_dhost[5]==255)))
        
           eptr->ether_dhost[0]=1;eptr->ether_dhost[1]=2;eptr->ether_dhost[2]=3;
         
   
          if(ntohs(tipoeth)==ETHERTYPE_ARP){
                  processARP(datipkt,hdr,descrOUT,o,codificatore);
                  pktanonymized=pktanonymized+1;
          }
          
          if(ntohs(tipoeth)==ETHERTYPE_IP)
                  processIP(datipkt,hdr,descrOUT,o,codificatore);
          
       else{
       pktdropped=pktdropped+1;
           if(o.verbose)
             fprintf(stdout,"%d dropped packet!\n",pktprocessed);                 
        }  
     }
   }
 }
  if(( pcap_stats(descr, &ps))!=0)
        printf("Stats Error!");
   
  pcap_dump_close(descrOUT); //Chiude il file di destinazione
  pcap_close(descr);         //Chiude il file di lettura
  
  fprintf(stdout,"%d received packets \n",ps.ps_recv);
  //fprintf(stdout,"%d dropped packets\n",ps.ps_drop);
  fprintf(stdout,"%d processed packets \n",pktprocessed);
  fprintf(stdout,"%d anonymized packets\n",pktanonymized);
  fprintf(stdout,"%d dropped packets \n",pktdropped);
  gettimeofday(&pstop,NULL);
  seconds =(pstop.tv_sec - pstart.tv_sec);
  usec=((pstop.tv_usec - pstart.tv_usec) / 1000000.0);
  sec_to_min(seconds, usec);
  fprintf(stdout,"\n%s anonymized!\n",argv[count]); 

}
else{  
  
  fprintf(stdout,"\nAnonymizer version 0.3 processing...\n");
  fprintf(stdout,"(sourceforge.net/project/Anonymizer)\n\n");
      int n;    
  for(n=count;n<argc;(n=n+1)){
   pktprocessed=0;
   pktanonymized=0;
   pktdropped=0;         
   gettimeofday(&pstart,NULL);   
   
   pcap_t *descr;          //Struttura che definisce la cattura dei pacchetti
   pcap_dumper_t *descrOUT;
   const u_char * datipkt;
   struct pcap_pkthdr hdr;     
   char *output; 
   char errbuf[PCAP_ERRBUF_SIZE];      //Stringa che conterrà messaggi di errore (max 255 caratteri)
   char temp[100];  //argv max. 100 caratteri
   
   //fprintf(stdout,"strlen(argv[n])=%d\n",strlen(argv[n]));      
   fprintf(stdout,"%s anonymizing...\n",argv[n]);
   descr = pcap_open_offline(argv[n], errbuf);    //Definizione di descr 
   if(descr==NULL) printf("Error: %s\n",errbuf); //Se da 0 c'è errore  

   strcpy(temp,argv[n]);
   //fprintf(stdout,"strlen(temp)=%d\n",strlen(temp));
   output=strcat(temp,".anonim");
   //fprintf(stdout,"strlen(output)=%d\n",strlen(output));
   descrOUT = pcap_dump_open(descr,output);     //Definizione di questo
   if(descrOUT==NULL) printf("Error in writing\n");
 
   if(o.verbose)
     fprintf(stdout,"\nPacket number: %d\n",0);

   while((datipkt) = (pcap_next(descr,&hdr)))
   {
    int datalink;
    pktprocessed=pktprocessed+1;
    if(o.verbose)
           fprintf(stdout," %d\n",pktprocessed);        

    if(pktprocessed>=0)
     {
     if((datalink=pcap_datalink(descr)) != DLT_EN10MB )
     //scarto i pacchetti non Ethernet 10, 100, 1000 (in pratica nessuno...a noi)
         pktdropped=pktdropped+1;
                
     else
        {//si va avanti nella pila
      //consideriamo solo trame ethernet IP e da li IP->UDP, IP->TCP, IP->ICMP e ARP
      u_int16_t tipoeth;
      struct ether_header *eptr;  
      eptr=(struct ether_header *) (datipkt);
      tipoeth=eptr->ether_type; 
      
      //Se l'indirizzo mac sorgente non è broadcast (?!), lo cambio in 1.2.3.x.y.z (in hex 01.02.03.xx.yy.zz) dove x,y,z sono quelli originari
      if(!((eptr->ether_shost[0]==255)&&(eptr->ether_shost[1]==255)&&(eptr->ether_shost[2]==255)&&(eptr->ether_shost[3]==255)&&(eptr->ether_shost[4]==255)&&(eptr->ether_shost[5]==255)))

           eptr->ether_shost[0]=1;eptr->ether_shost[1]=2;eptr->ether_shost[2]=3;

      //Se l'indirizzo mac destinazione non è broadcast, lo cambio in 1.2.3.x.y.z 
       if(!((eptr->ether_dhost[0]==255)&&(eptr->ether_dhost[1]==255)&&(eptr->ether_dhost[2]==255)&&(eptr->ether_dhost[3]==255)&&(eptr->ether_dhost[4]==255)&&(eptr->ether_dhost[5]==255)))

           eptr->ether_dhost[0]=1;eptr->ether_dhost[1]=2;eptr->ether_dhost[2]=3;
   
          if(ntohs(tipoeth)==ETHERTYPE_ARP){
                  processARP(datipkt,hdr,descrOUT,o,codificatore);
                  pktanonymized=pktanonymized+1;
          }
          else
          if(ntohs(tipoeth)==ETHERTYPE_IP)
                processIP(datipkt,hdr,descrOUT,o,codificatore);
          
      else{
       pktdropped=pktdropped+1;
           if(o.verbose)
                fprintf(stdout,"%d dropped packet!\n",pktprocessed);              
          }  
     }
    }
   }  
   
  pcap_dump_close(descrOUT); //Chiude il file di destinazione
  pcap_close(descr);         //Chiude il file di lettura
  

  fprintf(stdout,"\n%d processed packets \n",pktprocessed);
  fprintf(stdout,"%d anonymized packets\n",pktanonymized);
  fprintf(stdout,"%d dropped packets \n",pktdropped);
  gettimeofday(&pstop,NULL);
  seconds =(pstop.tv_sec - pstart.tv_sec);
  usec=((pstop.tv_usec - pstart.tv_usec) / 1000000.0);
  sec_to_min(seconds, usec);
 // fprintf(stdout,"\n%s anonymized!\n"/*,argv[n]*/); 
  }
 }


  return 0;     
}

//------------------------------------------Sec to Min-----------------------------------
void sec_to_min(long seconds,double usec){
    if (seconds >= 0 && seconds < 60)
        fprintf(stdout,"in %2.6f sec\n",(seconds+usec));
        
    else  if (seconds >= 60 && seconds < 3600)
        fprintf(stdout,"in %2d min %2.6f sec\n", (seconds/60),(seconds % 60 +usec));
        
    else if ( seconds >= 3600 && seconds < 86400 )
        fprintf(stdout,"in %2d h %2d min %2.6f sec\n", 
        (seconds /3600),((seconds % 3600) /60),((seconds % 60) +usec));
        
    else if ( seconds >= 86400 ) 
        fprintf(stdout,"in %d d %2d h %2d min %2.6f sec\n",
        (seconds/86400),((seconds % 86400)/3600),(((seconds % 86400) %3600) / 60),(((((seconds %86400) %3600) % 60 ) %60 )+usec));        
 
}

//---------------------------------------Help----------------------------------------------
void showHelp(){
  fprintf(stdout,"\n-----***HELP***-----\n");
  fprintf(stdout,"Anonymizer version 0.3\n");
  fprintf(stdout,"Usage: Anonymizer [options] fileInput1 [fileInput2...fileInputN]\n");
  fprintf(stdout,"For Live usage: Anonymizer [-l] [options] fileOutput \n");
  fprintf(stdout,"Options:\n");
  fprintf(stdout,"              -l              enable live anonymizing\n");
  fprintf(stdout,"              -s              enable prefix-preserving\n");
  fprintf(stdout,"              -p              disable payload darkening\n");  
  fprintf(stdout,"              -o              disable IP address darkening \n");
  fprintf(stdout,"              -x              cut payload\n");
  fprintf(stdout,"              -v              enable count(verbose mode)\n");
  fprintf(stdout,"              --help          show help\n\n");
}
        

//-------------------------------Opzioni-------------------------------------------
options readOptions(int argc,char **argv,int *count){
        options o;
        o.live=0;
        o.dimPayload=1;
        o.dimIPaddr=1;
        o.cutPayload=0;
        o.verbose=0;
        o.invalidOption=0;
        o.prefix=0;
        *count=1;
        
        while((*count<argc)&&(strncmp(argv[*count],"-",1)==0)&&(o.invalidOption==0)){
          if(strcmp(argv[*count],"-l")==0)
           o.live=1;
           else
      if(strcmp(argv[*count],"-s")==0)
           o.prefix=1;
           else
      if(strcmp(argv[*count],"-v")==0)
           o.verbose=1; 
      
      else
      if(strcmp(argv[*count],"-x")==0){
           if(o.dimPayload!=0){
                o.cutPayload=1;  
            //se taglio il payload è inutile che l'offusco     
            o.dimPayload=0;    
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-o -x)!\n");
                o.invalidOption=1;
           }   
          }      
      else        
          if(strcmp(argv[*count],"-o")==0){
       if(o.cutPayload!=1)
                o.dimPayload=0; 
           
           else{
                fprintf(stdout,"WARNING: incompatible options (-x -o)!\n");
                o.invalidOption=1;
           }   
          }
          else
           if(strcmp(argv[*count],"-p")==0)
            o.dimIPaddr=0; 
          
           else
            if((strcmp(argv[*count],"-vx")==0)||(strcmp(argv[*count],"-xv")==0)){
             if(o.dimPayload!=0){
                o.cutPayload=1;  
            //se taglio il payload è inutile che l'offusco      
            o.dimPayload=0; 
                o.verbose=1;    
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-o -x)!\n");
                o.invalidOption=1;
           } 
      }
      else
      if((strcmp(argv[*count],"-vo")==0)||(strcmp(argv[*count],"-ov")==0)){
       if(o.cutPayload!=1){
                o.dimPayload=0; 
                o.verbose=1;    
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-x -o)!\n");
                o.invalidOption=1;
           } 
      }
      else
      if((strcmp(argv[*count],"-vp")==0)||(strcmp(argv[*count],"-pv")==0)){
       o.dimIPaddr=0; 
           o.verbose=1;    
          }
      else
      if((strcmp(argv[*count],"-ox")==0)||(strcmp(argv[*count],"-xo")==0)){
       fprintf(stdout,"WARNING: incompatible options (-x -o)!\n");
           o.invalidOption=1;  
          }
      else
          if((strcmp(argv[*count],"-xp")==0)||(strcmp(argv[*count],"-px")==0)){
           if(o.dimPayload!=0){
                o.cutPayload=1;  
            //se taglio il payload è inutile che l'offusco     
            o.dimPayload=0; 
                o.dimIPaddr=0;    
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-o -x)!\n");
                o.invalidOption=1;
           } 
      }
      else
      if((strcmp(argv[*count],"-op")==0)||(strcmp(argv[*count],"-po")==0)){
       if(o.cutPayload!=1){
                o.dimPayload=0; 
                o.dimIPaddr=0;    
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-x -o)!\n");
                o.invalidOption=1;
           } 
      }
      else
      if((strcmp(argv[*count],"-vop")==0)||(strcmp(argv[*count],"-vpo")==0)||
                 (strcmp(argv[*count],"-ovp")==0)||(strcmp(argv[*count],"-opv")==0)||
             (strcmp(argv[*count],"-pvo")==0)||(strcmp(argv[*count],"-pov")==0)){
       if(o.cutPayload!=1){
                o.dimPayload=0; 
                o.dimIPaddr=0; 
        o.verbose=1;               
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-x -o)!\n");
                o.invalidOption=1;
           } 
      }
          else
      if((strcmp(argv[*count],"-vxp")==0)||(strcmp(argv[*count],"-vpx")==0)||
                 (strcmp(argv[*count],"-xvp")==0)||(strcmp(argv[*count],"-xpv")==0)||
             (strcmp(argv[*count],"-pvx")==0)||(strcmp(argv[*count],"-pxv")==0)){
       if(o.dimPayload!=0){
                o.cutPayload=1;
                //se taglio il payload è inutile che l'offusco   
                o.dimPayload=0; 
                o.dimIPaddr=0; 
        o.verbose=1;               
           }
           else{
                fprintf(stdout,"WARNING: incompatible options (-o -x)!\n");
                o.invalidOption=1;
           } 
      }
      else
      if((strcmp(argv[*count],"-xop")==0)||(strcmp(argv[*count],"-xpo")==0)||
                 (strcmp(argv[*count],"-oxp")==0)||(strcmp(argv[*count],"-opx")==0)||
             (strcmp(argv[*count],"-pxo")==0)||(strcmp(argv[*count],"-pox")==0)||
             (strcmp(argv[*count],"-vxo")==0)||(strcmp(argv[*count],"-vox")==0)||
                 (strcmp(argv[*count],"-xvo")==0)||(strcmp(argv[*count],"-xov")==0)||
             (strcmp(argv[*count],"-ovx")==0)||(strcmp(argv[*count],"-oxv")==0)){
           fprintf(stdout,"WARNING: incompatible options (-x -o)!\n");
           o.invalidOption=1;
          }               
          else{
           fprintf(stdout,"%s Invalid Option!\n",argv[*count]);   
           showHelp();  
           o.invalidOption=1;  
          }                               
          *count=*count+1;
        }
            
        return o;
}       
//---------------------------------------------Process ARP-------------------------------------------

void processARP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o,Codifier& codificatore)
{
  int ethlen=sizeof(struct ether_header); //Dimensione header ethernet
  struct ether_arp *arpp;
  arpp=(struct ether_arp *)(datipkt + ethlen);
  if(o.dimIPaddr!=0){
   //Modifica indirizzo IP sender 
   struct in_addr temparp1,temparp2;
   u_int32_t A=*(u_int32_t*)(arpp->arp_spa);    

   temparp1.s_addr=ntohl(A);
   temparp2=codificatore.Codifica(temparp1,o.prefix);
   temparp2.s_addr=htonl(temparp2.s_addr);
   u_int32_t *b= &temparp2.s_addr;
   u_int8_t a[4]; memcpy(a,b,4);       // u_int8_t arp_spa[4];          /* sender protocol address */
   arpp->arp_spa[0]=a[0];arpp->arp_spa[1]=a[1];arpp->arp_spa[2]=a[2];arpp->arp_spa[3]=a[3];

   //Modifica hardware address sender
   arpp->arp_sha[0]=1;arpp->arp_sha[1]=2;arpp->arp_sha[2]=3;//arpp->arp_sha[3]=4;arpp->arp_sha[4]=5;arpp->arp_sha[5]=6;

   //Modifica indirizzo IP request
   A=*(u_int32_t*)(arpp->arp_tpa);    
   temparp1.s_addr=ntohl(A);
   temparp2=codificatore.Codifica(temparp1,o.prefix);
   temparp2.s_addr=htonl(temparp2.s_addr);
   u_int32_t *b2= &temparp2.s_addr;
   memcpy(a,b2,4);
   arpp->arp_tpa[0]=a[0];arpp->arp_tpa[1]=a[1];arpp->arp_tpa[2]=a[2];arpp->arp_tpa[3]=a[3];

   //Modifica indirizzo hardware request (sempre che non sia broadcast (0.0.0.0.0.0) )
   if(!((arpp->arp_tha[0]==0)&&(arpp->arp_tha[1]==0)&&(arpp->arp_tha[2]==0)&&(arpp->arp_tha[3]==0)&&(arpp->arp_tha[4]==0)&&(arpp->arp_tha[5]==0))){
    arpp->arp_tha[0]=1;arpp->arp_tha[1]=2;arpp->arp_tha[2]=3;}//arpp->arp_tha[3]=10;arpp->arp_tha[4]=11;arpp->arp_tha[5]=12;}
  }
  pcap_dump((u_char*)descrOUT,&hdr,datipkt);
     
}

void processIP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o,Codifier& codificatore){
        int ethlen=sizeof(struct ether_header); //Dimensione header ethernet
        struct ip *ipp;
    ipp=(struct ip *)(datipkt + ethlen);//avanzo e faccio il casting
                 
        u_short flag=(ipp->ip_off);flag= flag & 0x00d0; //0x00d0 è la maschera per i fragment flag
        
        if(ntohs(flag)==IP_DF || (ipp->ip_off == 0x0000)){  
           
     int nextlevel,iphl;
     iphl=handle_ip(ipp,&nextlevel); //calcolo l'header length ip per eventuali opzioni (>20byte)
     //fprintf(stdout,"HL=%d NL=%d\n",iphl,nextlevel); //stampa di questi valori

     if(o.dimIPaddr!=0){
         //Offuscamento indirizzi IP
     //sorgente...
     struct in_addr tempA;
     ipp->ip_src.s_addr=ntohl(ipp->ip_src.s_addr);
     tempA=codificatore.Codifica(ipp->ip_src, o.prefix);
     ipp->ip_src.s_addr=htonl(tempA.s_addr);              
     //...destinatario 
     struct in_addr tempB;       
     ipp->ip_dst.s_addr=ntohl(ipp->ip_dst.s_addr);
     tempB=codificatore.Codifica(ipp->ip_dst, o.prefix);
     ipp->ip_dst.s_addr=htonl(tempB.s_addr); 
     }  
          
     //UDP
         if(nextlevel==17){ 
       processUDP(datipkt,hdr,descrOUT,o);
           pktanonymized=pktanonymized+1;        
         }      
     //TCP
         else 
         if(nextlevel==6){
          processTCP(datipkt,hdr,descrOUT,o);
          pktanonymized=pktanonymized+1;
         }
         //ICMP
     else 
         if(nextlevel==1){
      processICMP(datipkt,hdr,descrOUT,o,codificatore);
          pktanonymized=pktanonymized+1;
     }
     //Scarto dei pacchetti diversi da tcp/ip o udp/ip o Icmp/Ip
         else{
       pktdropped=pktdropped+1;
       if(o.verbose)
        fprintf(stdout,"IP packet dropped!\n");            
     }
             /*u_char * A;
         A=(u_char * )(datipkt + ethlen);
         int check;
         ipp->ip_sum=0x0000;
                 check=Checksum(  A, iphl*4);   
         ipp->ip_sum=check;
                 
                 pcap_dump((u_char*)descrOUT,&hdr,datipkt);*/
    }
    else{ //gestione dei frammenti (MF=1 oppure offset =! 0)
         if(o.verbose)
                fprintf(stdout,"\n Fragmented packet \n");
         ipp->ip_len=ntohs((u_short)ipp->ip_len); 
     int len1=ipp->ip_len;
     
     int nextlevel,iphl;
     iphl=handle_ip(ipp,&nextlevel); //calcolo l'header length ip per eventuali opzioni (>20byte)
     u_char * ipfragdata=((u_char*)ipp)+iphl*4; //punta al payload del pkt IP
     if(o.dimIPaddr!=0){    
          //Offuscamento indirizzi IP
      //sorgente...
          struct in_addr tempA;
      ipp->ip_src.s_addr=ntohl(ipp->ip_src.s_addr);
      tempA=codificatore.Codifica(ipp->ip_src,o.prefix);
      ipp->ip_src.s_addr=htonl(tempA.s_addr);      
      //...destinatario
      struct in_addr tempB;       
      ipp->ip_dst.s_addr=ntohl(ipp->ip_dst.s_addr);
      tempB=codificatore.Codifica(ipp->ip_dst,o.prefix);
      ipp->ip_dst.s_addr=htonl(tempB.s_addr); 
     }
         if(o.dimPayload!=0){  
          memset(ipfragdata,0,len1-iphl*4);//offuscamento payload
         }
     //Checksum IP
         u_char * A;
     A=(u_char * )(datipkt + ethlen);
     int check;
     ipp->ip_sum=0x0000;
         check=Checksum(A, iphl*4);   
     ipp->ip_sum=check;
     if(o.cutPayload!=0){
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);       
          hdr.caplen=ethlen+iphl*4;
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
        }
         
     pcap_dump((u_char*)descrOUT,&hdr,datipkt);
         pktanonymized=pktanonymized+1;
        }
}

void processUDP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o){
  //fprintf(stdout,"processUDP chiamata\n");
     int ethlen=sizeof(struct ether_header); //Dimensione header ethernet
         //fprintf(stdout,"ethlen=%d\n",ethlen);
         struct ip *ipp;
     ipp=(struct ip *)(datipkt + ethlen);//avanzo e faccio il casting
        
         int iphl,nextlevel;
         iphl=handle_ip(ipp,&nextlevel);
                
      struct udphdr *udp;
      udp=(struct udphdr *)(datipkt+ethlen+iphl*4);
          u_int16_t udplen=ntohs(udp->len);
         
          //fprintf(stdout,"Lunghezza totale UDP (con i dati): %d e %d\n",udplen,udp->len);
          u_char *rawdata;
      //Andiamo nella parte dati vera e propria
      rawdata=(u_char *)(datipkt+ethlen+iphl*4+8);
          
          int len1=ntohs((u_short)ipp->ip_len); //Prelevo la dimensione totale del pacchetto IP; mi servirà dopo
         
          if((len1-iphl*4)==udplen){
                //fprintf(stdout,"(len1-iphl*4)==udplen\n");  
            int dim_datiudp= udplen-8; //lunghezza pkt - header udp (8) = lunghezza dati
          //fprintf(stdout,"Dimensione dei dati = %d\n",dim_datiudp);
                  //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
                  if(hdr.caplen!=hdr.len){
                          //fprintf(stdout,"pkt incompleto\n");
                   dim_datiudp=hdr.caplen-ethlen-iphl*4-8;
                   //fprintf(stdout,"Dimensione dei dati = %d\n",dim_datiudp);
                  }
           if(o.dimPayload!=0){
                 //fprintf(stdout,"OK\n");  
            memset(rawdata,0,dim_datiudp);
        //fprintf(stdout,"OK\n");                  
           }
      }
          else{
           int dim_datiudp= len1-iphl*4-8;      
       if(hdr.caplen!=hdr.len){
                        //fprintf(stdout,"pkt incompleto\n");
                   dim_datiudp=hdr.caplen-ethlen-iphl*4-8;
                   //fprintf(stdout,"Dimensione dei dati = %d\n",dim_datiudp);
                  }               
           udplen=len1-iphl*4;
                //fprintf(stdout,"Dimensione dei dati = %d\n",dim_datiudp);  
           if(o.dimPayload!=0){
                  //fprintf(stdout,"OK\n");
            memset(rawdata,0,dim_datiudp);
           }
          }      
          //Checksum ip 
          int check;
      ipp->ip_sum=0x0000;
          check=Checksum((u_char *)ipp,iphl*4);   
      ipp->ip_sum=check;
          //fprintf(stdout,"Checksum ip ok\n");
      //Checksum udp
      udp->check=0x0000;
          int checks=checksumTCPUDP(ipp->ip_src,ipp->ip_dst,ipp->ip_p,udplen,(u_char *)udp);     
          udp->check=checks;
      //fprintf(stdout,"Checksum udp ok\n");
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
          
          if(o.cutPayload!=0){
           hdr.caplen=ethlen+iphl*4+8;
          }
      
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
          pcap_dump((u_char*)descrOUT,&hdr,datipkt);
        
}
void processTCP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o){
  int ethlen=sizeof(struct ether_header); //Dimensione header ethernet
  struct ip *ipp;
  ipp=(struct ip *)(datipkt + ethlen);//avanzo e faccio il casting
        
  int iphl,nextlevel;
  iphl=handle_ip(ipp,&nextlevel);
         
  struct tcphdr *tcp;
  tcp=(struct tcphdr *)(datipkt + ethlen + iphl*4 ) ;
  u_int8_t s=tcp->doff;
  //fprintf(stdout,"OFFSET =  %d\n",s);
  int tcplength=s*4; //dimensione header TCP in byte
  //fprintf(stdout,"tcplength=%d\n",tcplength);
        
  int len1=ntohs((u_short)ipp->ip_len); //Prelevo la dimensione totale del pacchetto IP; mi servirà dopo
  //fprintf(stdout,"len1=%d\n",len1);
  //fprintf(stdout,"iphl*4=%d\n",iphl*4);  
  if(!((len1-iphl*4)<tcplength)){
         //fprintf(stdout,"!((len1-iphl*4)<tcplength)\n"); 
        u_char *rawdata;
        rawdata=(u_char *)(datipkt + ethlen + iphl*4 +tcplength );
    //"Formula" per calcolare la dimensione del payload tcp in byte
    int tcpdatalength = len1 - iphl*4 - tcplength; 
    //  fprintf(stdout,"Dimensione dati TCP = %d \n",tcpdatalength);
        if((hdr.caplen!=hdr.len)&&(hdr.caplen>=ethlen+iphl*4+tcplength)){
      tcpdatalength=hdr.caplen-ethlen-iphl*4-tcplength;
        }       
    if(o.dimPayload!=0){
         memset(rawdata,0,tcpdatalength); //ANNULLAMENTO !!!
    }
    //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum(  (u_char*)ipp, iphl*4);   
    ipp->ip_sum=check;
        //Checksum tcp
    tcp->check=0x0000;
        int checks=checksumTCPUDP(ipp->ip_src,ipp->ip_dst,ipp->ip_p,(len1-iphl*4),(u_char *)tcp);
    tcp->check=checks;           
        
        if(o.cutPayload!=0){
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
          hdr.caplen=ethlen+iphl*4+tcplength;
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);       
        }
        pcap_dump((u_char*)descrOUT,&hdr,datipkt); 
  }
  else{
        if(o.verbose)
          fprintf(stdout,"\n Not valid TCP packet\n");
        //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum((u_char*)ipp,iphl*4);   
    ipp->ip_sum=check;  
                
        pcap_dump((u_char*)descrOUT,&hdr,datipkt);
  }
}

void processICMP(const u_char *datipkt,struct pcap_pkthdr hdr, pcap_dumper_t *descrOUT, options o,Codifier& codificatore){
  int ethlen=sizeof(struct ether_header); //Dimensione header ethernet
  struct ip *ipp;
  ipp=(struct ip *)(datipkt + ethlen);//avanzo e faccio il casting
        
  int iphl,nextlevel;
  iphl=handle_ip(ipp,&nextlevel);
  int esiste=0; //Booleano per il controllo sul tipo di ICMP analizzato
  struct icmphdr * icmp1; //Nota: le strutture icmphdr e icmp sono diverse. La seconda prevede più tipi. 
  icmp1=(struct icmphdr *)(datipkt + ethlen + iphl*4 ) ;
          
  int len1=ntohs((u_short)ipp->ip_len); //Prelevo la dimensione totale del pacchetto IP; mi servirà dopo
 // fprintf(stdout,"len1=%d\n",len1);
  if((icmp1->type==ICMP_ECHO )||(icmp1->type==ICMP_ECHOREPLY)) {
        //dimensione area dati icmp echo        
        int dimecho=len1-iphl*4-8;
        //posizionamento
    u_char *rawdata;
        rawdata=(u_char *)(datipkt + ethlen + iphl*4 + 8 );
        if(hdr.caplen!=hdr.len){
         //fprintf(stdout,"pkt incompleto\n");
         dimecho=hdr.caplen-ethlen-iphl*4-8;
        }                
    if(o.dimPayload){   
     //fprintf(stdout,"dimecho=%d\n",dimecho);          
         memset(rawdata,0,dimecho); //ANNULLAMENTO !!!
    }
    //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum((u_char*)ipp,iphl*4);   
    ipp->ip_sum=check;
    //Checksum icmp echo 
        int dimechofull=len1-iphl*4;
    rawdata=rawdata - 8;//torniamo all'inizio dell'header icmp                    
        icmp1->checksum=0x0000;
    check=Checksum(rawdata, dimechofull);                 
    icmp1->checksum=check;
    if(o.cutPayload!=0){
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);       
          hdr.caplen=ethlen+iphl*4+8;
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
        }               
        
        pcap_dump((u_char*)descrOUT,&hdr,datipkt); 
        esiste=1;
  }
  if((icmp1->type==ICMP_DEST_UNREACH)||(icmp1->type==ICMP_TIME_EXCEEDED)||(icmp1->type==ICMP_PARAMETERPROB)||(icmp1->type==ICMP_SOURCE_QUENCH)){
    //int dimdata=8; //Dimensione dati: RFC 792 (64 bits of original data datagram) 
    //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum((u_char*)ipp, iphl*4);   
    ipp->ip_sum=check;
                           
        struct ip* ipicmp=(struct ip *)(datipkt + ethlen + iphl*4 + 8);//sposto il puntatore all'inizio dell'header ip incapsulato
                  
    if(o.dimIPaddr!=0){
         //cambio degli indirizzi ip dell'header interno
         //sorgente...   
         struct in_addr tempICMP;
     ipicmp->ip_src.s_addr=ntohl(ipicmp->ip_src.s_addr);                           
     tempICMP=codificatore.Codifica(ipicmp->ip_src,o.prefix);
     ipicmp->ip_src.s_addr=htonl(tempICMP.s_addr);
         //...destinatario   
     ipicmp->ip_dst.s_addr=ntohl(ipicmp->ip_dst.s_addr);
     tempICMP=codificatore.Codifica(ipicmp->ip_dst,o.prefix);
     ipicmp->ip_dst.s_addr=htonl(tempICMP.s_addr);  
    }   
        //Checksum ip incapsulato icmp 
    ipicmp->ip_sum=0x0000;
    check=Checksum((u_char *)ipicmp, (ipicmp->ip_hl)*4);
        ipicmp->ip_sum=check;
        //calcolo checksum icmp redirect
        //prima calcoliamo le checksum dei pacchetti interni
                   
        //A questo punto potrebbero presentarsi pacchetti interni del tipo tcp,udp...
        //Se il pkt è tcp non è necessario ricalcolare checksum in quanto ne 
        //vediamo solo i primi 8 byte che non includono checksum.
        //Se il pacchetto è udp invece la checks non viene considerata dai riceventi il pkt.
                                
        u_char *rawdata;
        rawdata=(u_char *)(datipkt + ethlen + iphl*4);
        int dimechofull=len1-iphl*4;
        icmp1->checksum=0x0000;
        check=Checksum(rawdata, dimechofull);             
    icmp1->checksum=check;
        
        if(ipicmp->ip_p==17){
        int hl=ipicmp->ip_hl;
        //fprintf(stdout,"hl=%d\n",hl);
        rawdata=(u_char *)(datipkt + ethlen + iphl*4 + 8 + hl*4 + 8);
        int dim=len1 - iphl*4 - 8 - hl*4 - 8;
        if(o.dimPayload){
          memset(rawdata,0,dim);
        }
        if(o.cutPayload!=0){
                //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
                hdr.caplen=ethlen + iphl*4 + 8 + hl*4 + 8;
                //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
        }
    }              
        pcap_dump((u_char*)descrOUT,&hdr,datipkt);
    esiste=1;
  }
  //Cambiamento della struttura icmp di riferimento     
  struct icmp * icmpp;
  icmpp=(struct icmp *)(datipkt + ethlen + iphl*4 ) ;
          
  if((icmpp->icmp_type==ICMP_REDIRECT )){
    icmpp->icmp_hun.ih_gwaddr.s_addr=0x0affff0a;//Indirizzo gateway 10.255.255.10.                 pcap_dump((u_char*)descrOUT,&hdr,datipkt); esiste=1;}        
    //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum( (u_char*)ipp, iphl*4);   
    ipp->ip_sum=check;
           
        struct ip* ipicmp=(struct ip *)(datipkt + ethlen + iphl*4 + 8);//sposto il puntatore all'inizio dell'header ip incapsulato
                  
    if(o.dimIPaddr!=0){ 
         //cambio degli indirizzi ip dell'header interno
         //sorgente...
     struct in_addr tempICMP;
     ipicmp->ip_src.s_addr=ntohl(ipicmp->ip_src.s_addr);                           
     tempICMP=codificatore.Codifica(ipicmp->ip_src,o.prefix);
     ipicmp->ip_src.s_addr=htonl(tempICMP.s_addr);
         //...destinatario   
     ipicmp->ip_dst.s_addr=ntohl(ipicmp->ip_dst.s_addr);
     tempICMP=codificatore.Codifica(ipicmp->ip_dst,o.prefix);
     ipicmp->ip_dst.s_addr=htonl(tempICMP.s_addr);   
    }
    //checksum ip incapsulato icmp 
    ipicmp->ip_sum=0x0000;
        check=Checksum((u_char *)ipicmp,(ipicmp->ip_hl)*4);
        ipicmp->ip_sum=check;
        //calcolo checksum icmp redirect
        //prima calcoliamo le checksum dei pacchetti interni
           
        //A questo punto potrebbero presentarsi pacchetti interni del tipo tcp,udp...
        //Se il pkt è tcp non è necessario ricalcolare checksum in quanto ne 
        //vediamo solo i primi 8 byte che non includono checksum.
        //Se il pacchetto è udp invece non vengono analizzate dal ricevente.
                           
        u_char *rawdata;
        rawdata=(u_char *)(datipkt + ethlen + iphl*4);
        int dimechofull=len1-iphl*4;
        icmp1->checksum=0x0000;
        check=Checksum(rawdata, dimechofull);             
    icmp1->checksum=check;
                   
        pcap_dump((u_char*)descrOUT,&hdr,datipkt); 
        esiste=1;
  }  
  if((icmpp->icmp_type==ICMP_ROUTERADVERT)){
    //Offuscamento indirizzi dei router
    int dim=len1-iphl*4-8;
    u_char *rawdata;
        rawdata=(u_char *)(datipkt + ethlen + iphl*4 + 8 );
    if(o.dimPayload!=0){
         memset(rawdata,0,dim); //ANNULLAMENTO DEGLI indirizzi dei router e dei Preference level
    }  
        //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum( (u_char*) ipp, iphl*4);   
    ipp->ip_sum=check;
    //Checksum icmp routeradvert
        icmpp->icmp_cksum=0x0000;
        check=Checksum((u_char *)icmpp, len1-iphl*4);
    icmpp->icmp_cksum=check;
    if(o.cutPayload!=0){
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);       
          hdr.caplen=ethlen+iphl*4+8;
          //fprintf(stdout,"hdr.caplen=%d\n",hdr.caplen);
        }
        
        pcap_dump((u_char*)descrOUT,&hdr,datipkt);      
        esiste=1;
  }
  if(!esiste){
    //Checksum ip
    int check;
    ipp->ip_sum=0x0000;
        check=Checksum( (u_char*)ipp, iphl*4);   
    ipp->ip_sum=check;
                 
        //Se il pkt ICMP non è tra questi lo copio interamente
        pcap_dump((u_char*)descrOUT,&hdr,datipkt);
  }
        
}

//Funzione che estrapola alcuni valori dall'header IP
//Ci interessa solo la dimensione dell'header per poter avanzare,
//e preleviamo anche il tipo di protocollo di livello 4 per il casting successivo
int handle_ip(const struct ip* ipp,int *lev4){
 *lev4=ipp->ip_p;
 return ipp->ip_hl;
}

//Checksum generica su 16 bit
int Checksum(const u_char* Buff, int BufLen) {
// Calculate Checksum.
        u_int16_t *sp = (u_int16_t *) Buff; 
        u_int32_t sum = 0;

        /* Sum half-words */
        while (BufLen>1) {
                sum += *sp++;
                BufLen -= 2;
        }
        /* Add left-over byte, if any */
        if (BufLen>0)
                sum += * (char *) sp;
        /* Fold 32-bit sum to 16 bits */
        sum = (sum & 0x0000ffff)+(sum >> 16);
                sum = ~(sum + (sum >> 16)) & 0x0000ffff;
        if (sum == 0x0000ffff)
                sum = 0;
        return (u_int16_t)sum;
}
//Checksum TCP UDP
int checksumTCPUDP(const struct in_addr src, const struct in_addr dst,const u_int8_t protocol,const u_int16_t length,u_char *pkth){
         pseudo1 psehead; 
                 psehead.src=src;
                 psehead.dst=dst;
                 psehead.zeros=0x00;
                 psehead.prot=protocol;
                 psehead.transplen=ntohs(length);
         
                 int che;
                 
                 u_char buffe[100000];
                 int l=0;
                 for(l=0;l<100000;l++){buffe[l]=0x00;}
                 memcpy(buffe,&psehead,sizeof(psehead));
                 memcpy(buffe+sizeof(psehead),pkth,length);
                 che=Checksum(buffe,sizeof(psehead)+ length);
         return che;
}

---