开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
ec_illithid.c
资源名称：ettercap-0.4.0.tar.gz　[点击查看]
上传用户：nilegod
上传日期：2007-01-08
资源大小：220k
文件大小：21k
源码类别：

网络截获/分析

开发平台：

C/C++

ec_illithid.c：源码内容
  1. /*
  2.     ettercap -- illithid -- the sniffer module
  4.     Copyright (C) 2001  ALoR <alor@users.sourceforge.net>, NaGA <crwm@freemail.it>
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. */
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <sys/time.h>
  24. #include <string.h>
  25. #include <unistd.h>
  26. #include <fcntl.h>
  27. #include <errno.h>
  28. #include <signal.h>
  30. #include "include/ec_main.h"
  31. #include "include/ec_inet.h"
  32. #include "include/ec_inet_forge.h"
  33. #include "include/ec_inet_structures.h"
  34. #include "include/ec_buffer.h"
  35. #include "include/ec_error.h"
  36. #include "include/ec_dissector.h"
  38. #ifdef DEBUG
  39.    #include "include/ec_debug.h"
  40. #endif
  42. // global data
  43. short IPIDD=0, IPIDS=0;
  44. int SeqS=0, AckS=0, SeqD=0, AckD=0,
  45.     ByteSentS=0, ByteSentD=0, PacketSentS=0,
  46.     PacketSentD=0, datalenS=0, datalenD=0;
  47. int sock, G_PortSource, G_PortDest, IP1, IP2;
  48. int Connection_Mode=1;
  49. unsigned char MAC1[6];
  50. unsigned char MAC2[6];
  51. unsigned char MyMAC[6];
  53. // protos...
  55. int Illithid_ARPBased_GetData(char *iface, char proto, char *IPsource, int PortSource, char *IPdest, int PortDest, char *MAC1, char *MAC2);
  56. int Illithid_ARPBased_GetConnections(char *iface, char *IP1p, char *IP2p, char *MAC1, char *MAC2);
  57. int Illithid_PublicARP_GetConnections(char *iface, char *IP1p, char *IP2p, char *MAC1, char *MAC2);
  58. int Illithid_IPBased_GetConnections(char *iface, char *IP1p, char *IP2p);
  59. int Illithid_MACBased_GetConnections(char *iface, char *MAC1p, char *MAC2p);
  60. int Illithid_ToBeSniffed(char *source, int psource, char *dest, int pdest, SNIFFED_DATA *data);
  61. int Illithid_ToBeSniffed_ip(char *source, char *dest, CONNECTION *data);
  62. void Illithid_GetConnections(short mode, char *iface, char *IP1p, char *IP2p, char *MAC1p, char *MAC2p);
  63. void Illithid_Reset_Conn(void);
  65. //---------------------------
  67. void Illithid_Reset_Conn(void)
  68. {
  69.    int i;
  70.    char *buf1, *buf2, *pck_to_send;
  72.    if (ByteSentS || ByteSentD)
  73.    {
  75. #ifdef DEBUG
  76.    Debug_msg("Illithid_Reset_Conn");
  77. #endif
  79.       buf1 = Inet_Forge_packet( ETH_HEADER + IP_HEADER + TCP_HEADER );
  80.       pck_to_send = buf1;
  81.       pck_to_send += Inet_Forge_ethernet( pck_to_send, MyMAC, MAC2, ETH_P_IP );
  82.       pck_to_send += Inet_Forge_ip( pck_to_send, IP1, IP2, TCP_HEADER, IPIDD+PacketSentD+1, 0, IPPROTO_TCP);
  83.       pck_to_send += Inet_Forge_tcp( pck_to_send, G_PortSource, G_PortDest, SeqD+datalenD+ByteSentD, AckD-ByteSentS, TH_RST | TH_ACK, 0, 0);
  84. #ifdef DEBUG
  85.    Debug_msg("Illithid_Reset_Conn -- packet 1");
  86. #endif
  87.       buf2 = Inet_Forge_packet( ETH_HEADER + IP_HEADER + TCP_HEADER );
  88.       pck_to_send = buf2;
  89.       pck_to_send += Inet_Forge_ethernet( pck_to_send, MyMAC, MAC1, ETH_P_IP );
  90.       pck_to_send += Inet_Forge_ip( pck_to_send, IP2, IP1, TCP_HEADER, IPIDS+PacketSentS+1, 0, IPPROTO_TCP);
  91.       pck_to_send += Inet_Forge_tcp( pck_to_send, G_PortDest, G_PortSource, SeqS+datalenS+ByteSentS, AckS-ByteSentD, TH_RST | TH_ACK, 0, 0);
  92. #ifdef DEBUG
  93.    Debug_msg("Illithid_Reset_Conn -- packet 2");
  94. #endif
  95.       for(i=0; i<5; i++)
  96.       {
  97.          Inet_SendRawPacket(sock, buf1, ETH_HEADER + IP_HEADER + TCP_HEADER );
  98.          Inet_SendRawPacket(sock, buf2, ETH_HEADER + IP_HEADER + TCP_HEADER );
  99.          usleep(1000);
  100.       }
  101.    }
  102. #ifdef DEBUG
  103.    Debug_msg("Illithid_Reset_Conn_END");
  104. #endif
  105. }
  107. int Illithid_ARPBased_GetData(char *iface, char proto, char *IPsource, int PortSource, char *IPdest, int PortDest, char *MAC1p, char *MAC2p)
  108. {
  109.    int MTU, Illithid_pid;
  110.    short pkttype;
  111.    struct in_addr addr;
  112.    ETH_header *eth;
  113.    IP_header *ip;
  114.    TCP_header *tcp;
  115.    unsigned char *data;
  116.    char nchars;
  117.    char tosendchar[150];
  118.    char *ins_pck;
  119.    u_char *buffer;
  120.    SNIFFED_DATA data_to_test;
  122. #ifdef DEBUG
  123.    Debug_msg("Illithid_ARPBased_GetData -- %c [%s:%d] [%s:%d] -- [%s] [%s]", proto, IPsource, PortSource, IPdest, PortDest, MAC1, MAC2);
  124. #endif
  126.    if ((Illithid_pid = fork()))
  127.       return Illithid_pid;
  129.    strcpy(program_argv0, "illidata");
  131.    if (proto == 'T') exit_func(Illithid_Reset_Conn);
  133.    sock = Inet_OpenRawSock(iface);
  134.    Inet_GetIfaceInfo( iface, &MTU, MyMAC, NULL, NULL);
  136.    G_PortSource = PortSource;
  137.    G_PortDest = PortDest;
  139.    inet_aton(IPsource,&addr);
  140.    IP1 = addr.s_addr;
  141.    inet_aton(IPdest,&addr);
  142.    IP2 = addr.s_addr;
  144.    Inet_GetMACfromString(MAC1p, MAC1);
  145.    Inet_GetMACfromString(MAC2p, MAC2);
  147.    fcntl(sock,F_SETFL,O_NONBLOCK);
  148.    fcntl(pipe_inject_stod[0], F_SETFL, O_NONBLOCK);
  149.    fcntl(pipe_inject_dtos[0], F_SETFL, O_NONBLOCK);
  151.    ins_pck = Inet_Forge_packet(MTU);
  152.    buffer = Inet_Forge_packet(MTU);
  154.    for (;;)
  155.    {
  156.       int len;
  157.       char ok;
  159.       //memset(buffer, 0, MTU);
  161.       len = Inet_GetRawPacket(sock, buffer, MTU, &pkttype);
  163.       if (len > 0 && pkttype == PACKET_HOST)
  164.       {
  165.          eth = (ETH_header *)buffer;
  167.          if ( ntohs(eth->type) == ETH_P_IP )
  168.          {
  169.             ip = (IP_header *)(eth+1);
  170.             ok = 0;
  172.             if (ip->dest_ip==IP1 && ip->source_ip==IP2)
  173.             {
  174.                memcpy(eth->dest_mac, MAC1, 6);
  175.                memcpy(eth->source_mac, MyMAC, 6);
  176.                ok = 1;
  177.             }
  179.             if (ip->dest_ip==IP2 && ip->source_ip==IP1)
  180.             {
  181.                memcpy(eth->dest_mac, MAC2, 6);
  182.                memcpy(eth->source_mac, MyMAC, 6);
  183.                ok = 2;
  184.             }
  186.             if (ok && ip->proto == IPPROTO_TCP && proto == 'T')
  187.             {
  188.                tcp = (TCP_header *) ((int)ip + ip->h_len * 4);
  190.                if (ntohs(ip->frag_and_flags) & IP_OFFMASK) goto send;
  192.                strcpy(data_to_test.ip_source, inet_ntoa(*(struct in_addr *)&ip->source_ip) );
  193.                strcpy(data_to_test.ip_dest, inet_ntoa(*(struct in_addr *)&ip->dest_ip) );
  194.                data_to_test.source_port = ntohs(tcp->source);
  195.                data_to_test.dest_port = ntohs(tcp->dest);
  197.                if ( Illithid_ToBeSniffed(IPsource,PortSource, IPdest, PortDest, &data_to_test) )
  198.                {
  199.                   if (ok == 1)
  200.                   {
  201.                      SeqS = ntohl(tcp->seq);
  202.                      AckS = ntohl(tcp->ack_seq);
  203.                      tcp->seq = htonl(SeqS+ByteSentS);
  204.                      tcp->ack_seq = htonl(AckS-ByteSentD);
  205.                      IPIDS = ntohs(ip->ident);
  206.                      ip->ident = htons(IPIDS+PacketSentS);
  207.                      data = (char *)((int)tcp + tcp->doff * 4);
  208.                      datalenS = (int)ip + ntohs(ip->t_len) - (int)data;
  210.                      ip->checksum = 0;
  211.                      tcp->checksum = 0;
  212.                      ip->checksum = Inet_Forge_ChecksumIP( (unsigned short *) ip, sizeof(IP_header));
  214.                      if (tcp->doff*4 > sizeof(TCP_header))
  215.                      {
  216.                          char *pointer;
  217.                          pointer=(char *)(tcp + 1);
  218.                          Inet_Forge_RemoveTimeStamp(pointer,tcp->doff*4-sizeof(TCP_header));
  219.                      }
  220.                      tcp->checksum = Inet_Forge_Checksum((unsigned short *)tcp, IPPROTO_TCP, ntohs(ip->t_len)-ip->h_len*4, IP2, IP1);
  221.                   }
  222.                   else
  223.                   {
  224.                      SeqD = ntohl(tcp->seq);
  225.                      AckD = ntohl(tcp->ack_seq);
  226.                      tcp->seq = htonl(SeqD+ByteSentD);
  227.                      tcp->ack_seq = htonl(AckD-ByteSentS);
  228.                      IPIDD = ntohs(ip->ident);
  229.                      ip->ident = htons(IPIDD+PacketSentD);
  230.                      data = (char *)((int)tcp + tcp->doff * 4);
  231.                      datalenD = (int)ip + ntohs(ip->t_len) - (int)data;
  233.                      ip->checksum = 0;
  234.                      tcp->checksum = 0;
  235.                      ip->checksum = Inet_Forge_ChecksumIP( (unsigned short *) ip, sizeof(IP_header));
  237.                      if (tcp->doff*4 > sizeof(TCP_header))
  238.                      {
  239.                          char *pointer;
  240.                          pointer=(char *)(tcp + 1);
  241.                          Inet_Forge_RemoveTimeStamp(pointer,tcp->doff*4-sizeof(TCP_header));
  242.                      }
  243.                      tcp->checksum = Inet_Forge_Checksum((unsigned short *)tcp, IPPROTO_TCP, ntohs(ip->t_len)-ip->h_len*4, IP2, IP1);
  244.                   }
  245.                }
  246.             }
  247. send:       if (ok) Inet_SendRawPacket(sock, buffer, len);
  248.          }
  249.       }
  250.       else
  251.          usleep(1000);
  253.       nchars = read(pipe_inject_stod[0],tosendchar,MAX_INJECT);
  254.       if (nchars > 0)
  255.       {
  256.          char *pck_to_send;
  258.          pck_to_send = ins_pck;
  259.          pck_to_send += Inet_Forge_ethernet( pck_to_send, MyMAC, MAC2, ETH_P_IP );
  260.          if (proto == 'T')
  261.          {
  262.             pck_to_send += Inet_Forge_ip( pck_to_send, IP1, IP2, TCP_HEADER+nchars, IPIDD+PacketSentD+1, 0, IPPROTO_TCP);
  263.             pck_to_send += Inet_Forge_tcp( pck_to_send, PortSource, PortDest, SeqD+datalenD+ByteSentD, AckD-ByteSentS, TH_PSH | TH_ACK, tosendchar, nchars);
  264.          }
  265.          else if (proto == 'U')
  266.          {
  267.             pck_to_send += Inet_Forge_ip( pck_to_send, IP1, IP2, UDP_HEADER+nchars, IPIDD+PacketSentD+1, 0, IPPROTO_UDP);
  268.             pck_to_send += Inet_Forge_udp( pck_to_send, PortSource, PortDest, tosendchar, nchars);
  269.          }
  271.          Inet_SendRawPacket(sock, ins_pck, pck_to_send-ins_pck);
  272.          ByteSentD+=nchars;
  273.          PacketSentD++;
  274.       }
  276.       nchars = read(pipe_inject_dtos[0],tosendchar,MAX_INJECT);
  277.       if (nchars > 0)
  278.       {
  279.          char *pck_to_send;
  281.          pck_to_send = ins_pck;
  282.          pck_to_send += Inet_Forge_ethernet( pck_to_send, MyMAC, MAC1, ETH_P_IP );
  283.          if (proto == 'T')
  284.          {
  285.             pck_to_send += Inet_Forge_ip( pck_to_send, IP2, IP1, TCP_HEADER+nchars, IPIDS+PacketSentS+1, 0, IPPROTO_TCP);
  286.             pck_to_send += Inet_Forge_tcp( pck_to_send, PortDest, PortSource, SeqS+datalenS+ByteSentS, AckS-ByteSentD, TH_PSH | TH_ACK, tosendchar, nchars);
  287.          }
  288.          else if (proto == 'U')
  289.          {
  290.             pck_to_send += Inet_Forge_ip( pck_to_send, IP2, IP1, UDP_HEADER+nchars, IPIDS+PacketSentS+1, 0, IPPROTO_UDP);
  291.             pck_to_send += Inet_Forge_udp( pck_to_send, PortDest, PortSource, tosendchar, nchars);
  292.          }
  293.          Inet_SendRawPacket(sock, ins_pck, pck_to_send-ins_pck);
  294.          ByteSentS+=nchars;
  295.          PacketSentS++;
  296.       }
  297.    }
  298. }
  301. int Illithid_ARPBased_GetConnections(char *iface, char *IP1p, char *IP2p, char *MAC1p, char *MAC2p)
  302. {
  303.    int Illithid_pid;
  305. #ifdef DEBUG
  306.    Debug_msg("Illithid_ARPBased_GetConnections -- [%s] [%s] [%s] [%s]", IP1p, IP2p, MAC1p, MAC2p);
  307. #endif
  309.    if (!(Illithid_pid = fork()))
  310.       Illithid_GetConnections(ARPBASED, iface, IP1p, IP2p, MAC1p, MAC2p);
  311.    else
  312.       return Illithid_pid;
  314.    return 0;
  315. }
  317. int Illithid_PublicARP_GetConnections(char *iface, char *IP1p, char *IP2p, char *MAC1p, char *MAC2p)
  318. {
  319.    int Illithid_pid;
  321. #ifdef DEBUG
  322.    Debug_msg("Illithid_PublicARP_GetConnections -- [%s] [%s] [%s] [%s]", IP1p, IP2p, MAC1p, MAC2p);
  323. #endif
  325.    if (!(Illithid_pid = fork()))
  326.       Illithid_GetConnections(PUBLICARP, iface, IP1p, IP2p, MAC1p, MAC2p);
  327.    else
  328.       return Illithid_pid;
  330.    return 0;
  331. }
  335. int Illithid_IPBased_GetConnections(char *iface, char *IP1p, char *IP2p)
  336. {
  337.       int Illithid_pid;
  339. #ifdef DEBUG
  340.    Debug_msg("Illithid_IPBased_GetConnections -- [%s] [%s]", IP1p, IP2p);
  341. #endif
  343.    if (!(Illithid_pid = fork()))
  344.            Illithid_GetConnections(IPBASED, iface, IP1p, IP2p, "", "");
  345.    else
  346.       return Illithid_pid;
  348.    return 0;
  349. }
  352. int Illithid_MACBased_GetConnections(char *iface, char *MAC1p, char *MAC2p)
  353. {
  354.       int Illithid_pid;
  356. #ifdef DEBUG
  357.    Debug_msg("Illithid_MACBased_GetConnections -- [%s] [%s]", MAC1p, MAC2p);
  358. #endif
  360.    if (!(Illithid_pid = fork()))
  361.       Illithid_GetConnections(MACBASED, iface, "", "", MAC1p, MAC2p);
  362.    else
  363.       return Illithid_pid;
  365.    return 0;
  366. }
  369. void Illithid_GetConnections(short mode, char *iface, char *IP1p, char *IP2p, char *MAC1p, char *MAC2p)
  370. {
  371.    int len, MTU;
  372.    short pkttype;
  373.    struct in_addr addr;
  374.    ETH_header *eth;
  375.    IP_header *ip;
  376.    TCP_header *tcp;
  377.    UDP_header *udp;
  378.    CONNECTION data_to_ettercap;
  379.    SNIFFED_DATA sniff_data_to_ettercap;
  380.    u_char *buffer;
  381.    u_long IP_Test, NetMask;
  382.    int Act_Connection_Mode;
  384.    strcpy(program_argv0, "illithid");
  386.    inet_aton(IP1p,&addr);
  387.    IP1 = addr.s_addr;
  388.    inet_aton(IP2p,&addr);
  389.    IP2 = addr.s_addr;
  391.    Inet_GetMACfromString(MAC1p, MAC1);
  392.    Inet_GetMACfromString(MAC2p, MAC2);
  394.    sock = Inet_OpenRawSock(iface);
  395.    Inet_GetIfaceInfo( iface, &MTU, MyMAC, &IP_Test, &NetMask);
  397.    if (mode > PUBLICARP)
  398.        Inet_SetPromisc(iface);
  399.    else
  400.       IP_Test=IP_Test&NetMask;
  402.    buffer = Inet_Forge_packet(MTU);
  404.    for (;;)
  405.    {
  406.       if (getppid() == 1) exit(0);
  408.       memset(&data_to_ettercap, 0, sizeof(CONNECTION));
  409.       memset(&sniff_data_to_ettercap, 0, sizeof(SNIFFED_DATA));
  410.       memset(buffer, 0, MTU);
  412.       len = Inet_GetRawPacket(sock, buffer, MTU, &pkttype);
  413.       Act_Connection_Mode=Connection_Mode;
  415.       if (len > 0 && ( mode > PUBLICARP || pkttype == PACKET_HOST))
  416.       {
  417.          char ok1 = 0;
  419.          eth = (ETH_header *)buffer;
  420.          memcpy(data_to_ettercap.mac_source,eth->source_mac,6);
  422.          if (mode == MACBASED)
  423.          {
  424.             if ( memcmp(eth->source_mac, MAC1, 6) != 0 && memcmp(eth->source_mac, MAC2, 6) != 0 ) continue;
  425.             if ( memcmp(eth->dest_mac, MAC1, 6) != 0 && memcmp(eth->dest_mac, MAC2, 6) != 0 ) continue;
  426.             ok1 = 1;
  427.          }
  429.          if ( ntohs(eth->type) == ETH_P_IP )
  430.          {
  431.             ip = (IP_header *)(eth+1);
  433.             strcpy(data_to_ettercap.ip_source, inet_ntoa(*(struct in_addr *)&ip->source_ip) );
  434.             strcpy(data_to_ettercap.ip_dest, inet_ntoa(*(struct in_addr *)&ip->dest_ip) );
  435.             strcpy(sniff_data_to_ettercap.ip_source, inet_ntoa(*(struct in_addr *)&ip->source_ip) );
  436.             strcpy(sniff_data_to_ettercap.ip_dest, inet_ntoa(*(struct in_addr *)&ip->dest_ip) );
  438.             if ( mode == IPBASED && Illithid_ToBeSniffed_ip(IP1p, IP2p, &data_to_ettercap) ) ok1 = 1;
  440.             if ( mode == ARPBASED && (ip->dest_ip==IP1 || ip->source_ip==IP2) && (((ip->dest_ip&NetMask)!=IP_Test || (ip->source_ip&NetMask)!=IP_Test)
  441.                  || (ip->dest_ip==IP1 && ip->source_ip==IP2)))
  442.             {
  443.                memcpy(eth->dest_mac, MAC1, 6);
  444.                memcpy(eth->source_mac, MyMAC, 6);
  445.                ok1 = 1;
  446.             }
  448.             if ( mode == ARPBASED && (ip->dest_ip==IP2 || ip->source_ip==IP1) && (((ip->dest_ip&NetMask)!=IP_Test || (ip->source_ip&NetMask)!=IP_Test)
  449.                  || (ip->dest_ip==IP2 && ip->source_ip==IP1)))
  450.             {
  451.                memcpy(eth->dest_mac, MAC2, 6);
  452.                memcpy(eth->source_mac, MyMAC, 6);
  453.                ok1 = 1;
  454.             }
  456.             if (mode == PUBLICARP && !Act_Connection_Mode) ok1=1;
  458.             if ( mode == PUBLICARP && !strcmp(data_to_ettercap.ip_dest,IP1p))
  459.             {
  460.                memcpy(eth->dest_mac, MAC1, 6);
  461.                memcpy(eth->source_mac, MyMAC, 6);
  462.                ok1 = 1;
  463.             }
  464.             else
  465.             if ( mode == PUBLICARP && !strcmp(data_to_ettercap.ip_dest,IP2p))
  466.             {
  467.                memcpy(eth->dest_mac, MAC2, 6);
  468.                memcpy(eth->source_mac, MyMAC, 6);
  469.                ok1 = 1;
  470.             }
  471.             else
  472.             if ( mode == PUBLICARP && (ip->dest_ip&NetMask)!=IP_Test)
  473.             {
  474.                if (!strcmp(IP1p,""))
  475.                   memcpy(eth->dest_mac, MAC2, 6);
  476.                else
  477.                   memcpy(eth->dest_mac, MAC1, 6);
  479.                memcpy(eth->source_mac, MyMAC, 6);
  480.                ok1 = 1;
  481.             }
  483.             memcpy(data_to_ettercap.mac_dest,eth->dest_mac,6);
  485.             if ( ok1 && ip->proto == IPPROTO_TCP)
  486.             {
  487.                unsigned char *data;
  488.                int datalen;
  489.                tcp = (TCP_header *) ((int)ip + ip->h_len * 4);
  491.                if (!( ntohs(ip->frag_and_flags) & IP_OFFMASK))
  492.                {
  493.                   data = (char *)((int)tcp + tcp->doff * 4);
  494.                   datalen = (int)ip + ntohs(ip->t_len) - (int)data;
  496.                   if (Act_Connection_Mode)
  497.                   {
  498.                       data_to_ettercap.source_port = ntohs(tcp->source);
  499.                       data_to_ettercap.dest_port = ntohs(tcp->dest);
  500.                       data_to_ettercap.source_seq = ntohl(tcp->seq) + datalen;
  501.                       data_to_ettercap.dest_seq = ntohl(tcp->seq) + datalen;
  502.                       data_to_ettercap.flags = tcp->flags;
  503.                       data_to_ettercap.proto = 'T';
  504.                       data_to_ettercap.datalen = datalen;
  505.                       Dissector_Connections( mode, IPPROTO_TCP, (u_char *)tcp, &data_to_ettercap, Act_Connection_Mode);
  506.                       Buffer_Put(pipe_with_illithid, &data_to_ettercap, sizeof(CONNECTION));
  507.                   }
  508.                   else
  509.                   {
  510.                       sniff_data_to_ettercap.source_port = ntohs(tcp->source);
  511.                       sniff_data_to_ettercap.dest_port = ntohs(tcp->dest);
  512.                       sniff_data_to_ettercap.seq = ntohl(tcp->seq);
  513.                       sniff_data_to_ettercap.ack_seq = ntohl(tcp->ack_seq);
  514.                       sniff_data_to_ettercap.flags = tcp->flags;
  515.                       sniff_data_to_ettercap.proto = 'T';
  516.                       datalen = (datalen > MAX_DATA) ? MAX_DATA : datalen;
  517.                       sniff_data_to_ettercap.datasize = datalen;
  518.                       memset(&sniff_data_to_ettercap.data, 0, sizeof(sniff_data_to_ettercap.data));
  519.                       memcpy(&sniff_data_to_ettercap.data, data, datalen);
  520.                       Dissector_Connections( mode, IPPROTO_TCP, (u_char *)tcp, &sniff_data_to_ettercap, Act_Connection_Mode);
  521.                       Buffer_Put(pipe_with_illithid_data, &sniff_data_to_ettercap, sizeof(SNIFFED_DATA));
  522.                   }
  523.                }
  524.             }
  526.             if ( ok1 && ip->proto == IPPROTO_UDP)
  527.             {
  528.                unsigned char *data;
  529.                int datalen;
  530.                udp = (UDP_header *) ((int)ip + ip->h_len * 4);
  532.                if (!( ntohs(ip->frag_and_flags) & IP_OFFMASK))
  533.                {
  534.                   data =  (char *)((int)udp + UDP_HEADER);
  535.                   datalen = ntohs(udp->len) - UDP_HEADER;
  537.                   if (Act_Connection_Mode)
  538.                   {
  539.                      data_to_ettercap.source_port = ntohs(udp->source);
  540.                      data_to_ettercap.dest_port = ntohs(udp->dest);
  541.                      data_to_ettercap.proto = 'U';
  542.                      data_to_ettercap.datalen = datalen;
  543.                      Dissector_Connections( mode, IPPROTO_UDP, (u_char *)udp, &data_to_ettercap, Act_Connection_Mode);
  544.                      Buffer_Put(pipe_with_illithid, &data_to_ettercap, sizeof(CONNECTION));
  545.                   }
  546.                   else
  547.                   {
  548.                      sniff_data_to_ettercap.source_port = ntohs(udp->source);
  549.                      sniff_data_to_ettercap.dest_port = ntohs(udp->dest);
  550.                      sniff_data_to_ettercap.proto = 'U';
  551.                      datalen = (datalen > MAX_DATA) ? MAX_DATA : datalen;
  552.                      sniff_data_to_ettercap.datasize = datalen;
  553.                      memset(&sniff_data_to_ettercap.data, 0, sizeof(sniff_data_to_ettercap.data));
  554.                      memcpy(&sniff_data_to_ettercap.data, data, datalen);
  555.                      Dissector_Connections( mode, IPPROTO_UDP, (u_char *)udp, &sniff_data_to_ettercap, Act_Connection_Mode);
  556.                      Buffer_Put(pipe_with_illithid_data, &sniff_data_to_ettercap, sizeof(SNIFFED_DATA));
  557.                   }
  558.                }
  559.             }
  560.             if (mode <= PUBLICARP && ok1 && Act_Connection_Mode) Inet_SendRawPacket(sock, buffer, len);
  561.          }
  562.       }
  563.    }
  564. }
  567. int Illithid_ToBeSniffed(char *source, int psource, char *dest, int pdest, SNIFFED_DATA *data)
  568. {
  569.    char s=0, ps=0, d=0, pd=0;
  571.    if (psource == 0) ps = 1;
  572.    if (pdest == 0) pd = 1;
  573.    if (!strcmp(source, "")) s = 1;
  574.    if (!strcmp(dest, "")) d = 1;
  576.    if (s || !strcmp(source, data->ip_source))
  577.       if (ps || psource == data->source_port)
  578.       {  s = 1;   ps = 1;  }
  580.    if (s || !strcmp(source, data->ip_dest))
  581.       if (ps || psource == data->dest_port)
  582.       {  s = 1;   ps = 1;  }
  584.    if (d || !strcmp(dest, data->ip_source))
  585.       if (pd || pdest == data->source_port)
  586.       {  d = 1;   pd = 1;  }
  588.    if (d || !strcmp(dest, data->ip_dest))
  589.       if (pd || pdest == data->dest_port)
  590.       {  d = 1;   pd = 1;  }
  592.    return ( s && ps && d && pd );
  593. }
  596. int Illithid_ToBeSniffed_ip(char *source, char *dest, CONNECTION *data)
  597. {
  598.    char s=0, d=0;
  600.    if (!strcmp(source, "")) s = 1;
  601.    if (!strcmp(dest, "")) d = 1;
  603.    if (s || !strcmp(source, data->ip_source)) s = 1;
  605.    if (s || !strcmp(source, data->ip_dest)) s = 1;
  607.    if (d || !strcmp(dest, data->ip_source)) d = 1;
  609.    if (d || !strcmp(dest, data->ip_dest)) d = 1;
  611.    return ( s && d );
  613. }
  616. /* EOF */