Ticket #23971: dsniff.patch

File dsniff.patch, 29.2 KB (added by shadow@…, 11 years ago)

dsniff 2.4b1 patch for new libnet, libnids.

  • arpspoof.c

    diff -ur dsniff-2.4/arpspoof.c dsniff-2.4-mine/arpspoof.c
    old new  
    2121#include <err.h>
    2222#include <libnet.h>
    2323#include <pcap.h>
    24 
     24#ifdef HAVE_NET_ETHERNET_H
     25#include <net/ethernet.h>
     26#else
     27extern char *ether_ntoa(struct ether_addr *);
     28#endif
    2529#include "arp.h"
    2630#include "version.h"
    2731
    28 extern char *ether_ntoa(struct ether_addr *);
    29 
    30 static struct libnet_link_int *llif;
     32static libnet_t *l;
    3133static struct ether_addr spoof_mac, target_mac;
    3234static in_addr_t spoof_ip, target_ip;
    3335static char *intf;
     
    4143}
    4244
    4345static int
    44 arp_send(struct libnet_link_int *llif, char *dev,
    45          int op, u_char *sha, in_addr_t spa, u_char *tha, in_addr_t tpa)
     46arp_send(libnet_t *l, int op, u_int8_t *sha,
     47         in_addr_t spa, u_int8_t *tha, in_addr_t tpa)
    4648{
    47         char ebuf[128];
    48         u_char pkt[60];
    49        
     49        int retval;
     50
    5051        if (sha == NULL &&
    51             (sha = (u_char *)libnet_get_hwaddr(llif, dev, ebuf)) == NULL) {
     52            (sha = (u_int8_t *)libnet_get_hwaddr(l)) == NULL) {
    5253                return (-1);
    5354        }
    5455        if (spa == 0) {
    55                 if ((spa = libnet_get_ipaddr(llif, dev, ebuf)) == 0)
     56                if ((spa = libnet_get_ipaddr4(l)) == -1)
    5657                        return (-1);
    57                 spa = htonl(spa); /* XXX */
    5858        }
    5959        if (tha == NULL)
    6060                tha = "\xff\xff\xff\xff\xff\xff";
    6161       
    62         libnet_build_ethernet(tha, sha, ETHERTYPE_ARP, NULL, 0, pkt);
     62        libnet_autobuild_arp(op, sha, (u_int8_t *)&spa,
     63                             tha, (u_int8_t *)&tpa, l);
     64        libnet_build_ethernet(tha, sha, ETHERTYPE_ARP, NULL, 0, l, 0);
    6365       
    64         libnet_build_arp(ARPHRD_ETHER, ETHERTYPE_IP, ETHER_ADDR_LEN, 4,
    65                          op, sha, (u_char *)&spa, tha, (u_char *)&tpa,
    66                          NULL, 0, pkt + ETH_H);
    67 
    6866        fprintf(stderr, "%s ",
    6967                ether_ntoa((struct ether_addr *)sha));
    7068
    7169        if (op == ARPOP_REQUEST) {
    7270                fprintf(stderr, "%s 0806 42: arp who-has %s tell %s\n",
    7371                        ether_ntoa((struct ether_addr *)tha),
    74                         libnet_host_lookup(tpa, 0),
    75                         libnet_host_lookup(spa, 0));
     72                        libnet_addr2name4(tpa, LIBNET_DONT_RESOLVE),
     73                        libnet_addr2name4(spa, LIBNET_DONT_RESOLVE));
    7674        }
    7775        else {
    7876                fprintf(stderr, "%s 0806 42: arp reply %s is-at ",
    7977                        ether_ntoa((struct ether_addr *)tha),
    80                         libnet_host_lookup(spa, 0));
     78                        libnet_addr2name4(spa, LIBNET_DONT_RESOLVE));
    8179                fprintf(stderr, "%s\n",
    8280                        ether_ntoa((struct ether_addr *)sha));
    8381        }
    84         return (libnet_write_link_layer(llif, dev, pkt, sizeof(pkt)) == sizeof(pkt));
     82        retval = libnet_write(l);
     83        if (retval)
     84                fprintf(stderr, "%s", libnet_geterror(l));
     85
     86        libnet_clear_packet(l);
     87
     88        return retval;
    8589}
    8690
    8791#ifdef __linux__
     
    119123                /* XXX - force the kernel to arp. feh. */
    120124                arp_force(ip);
    121125#else
    122                 arp_send(llif, intf, ARPOP_REQUEST, NULL, 0, NULL, ip);
     126                arp_send(l, ARPOP_REQUEST, NULL, 0, NULL, ip);
    123127#endif
    124128                sleep(1);
    125129        }
     
    136140        if (arp_find(spoof_ip, &spoof_mac)) {
    137141                for (i = 0; i < 3; i++) {
    138142                        /* XXX - on BSD, requires ETHERSPOOF kernel. */
    139                         arp_send(llif, intf, ARPOP_REPLY,
    140                                  (u_char *)&spoof_mac, spoof_ip,
    141                                  (target_ip ? (u_char *)&target_mac : NULL),
     143                        arp_send(l, ARPOP_REPLY,
     144                                 (u_int8_t *)&spoof_mac, spoof_ip,
     145                                 (target_ip ? (u_int8_t *)&target_mac : NULL),
    142146                                 target_ip);
    143147                        sleep(1);
    144148                }
     
    151155{
    152156        extern char *optarg;
    153157        extern int optind;
    154         char ebuf[PCAP_ERRBUF_SIZE];
     158        char pcap_ebuf[PCAP_ERRBUF_SIZE];
     159        char libnet_ebuf[LIBNET_ERRBUF_SIZE];
    155160        int c;
    156161       
    157162        intf = NULL;
     
    163168                        intf = optarg;
    164169                        break;
    165170                case 't':
    166                         if ((target_ip = libnet_name_resolve(optarg, 1)) == -1)
     171                        if ((target_ip = libnet_name2addr4(l, optarg, LIBNET_RESOLVE)) == -1)
    167172                                usage();
    168173                        break;
    169174                default:
     
    176181        if (argc != 1)
    177182                usage();
    178183       
    179         if ((spoof_ip = libnet_name_resolve(argv[0], 1)) == -1)
     184        if ((spoof_ip = libnet_name2addr4(l, argv[0], LIBNET_RESOLVE)) == -1)
    180185                usage();
    181186       
    182         if (intf == NULL && (intf = pcap_lookupdev(ebuf)) == NULL)
    183                 errx(1, "%s", ebuf);
     187        if (intf == NULL && (intf = pcap_lookupdev(pcap_ebuf)) == NULL)
     188                errx(1, "%s", pcap_ebuf);
    184189       
    185         if ((llif = libnet_open_link_interface(intf, ebuf)) == 0)
    186                 errx(1, "%s", ebuf);
     190        if ((l = libnet_init(LIBNET_LINK, intf, libnet_ebuf)) == NULL)
     191                errx(1, "%s", libnet_ebuf);
    187192       
    188193        if (target_ip != 0 && !arp_find(target_ip, &target_mac))
    189194                errx(1, "couldn't arp for host %s",
    190                      libnet_host_lookup(target_ip, 0));
     195                     libnet_addr2name4(target_ip, LIBNET_DONT_RESOLVE));
    191196       
    192197        signal(SIGHUP, cleanup);
    193198        signal(SIGINT, cleanup);
    194199        signal(SIGTERM, cleanup);
    195200       
    196201        for (;;) {
    197                 arp_send(llif, intf, ARPOP_REPLY, NULL, spoof_ip,
    198                          (target_ip ? (u_char *)&target_mac : NULL),
     202                arp_send(l, ARPOP_REPLY, NULL, spoof_ip,
     203                         (target_ip ? (u_int8_t *)&target_mac : NULL),
    199204                         target_ip);
    200205                sleep(2);
    201206        }
  • configure.in

    diff -ur dsniff-2.4/configure.in dsniff-2.4-mine/configure.in
    old new  
    2121dnl Checks for header files.
    2222AC_PATH_XTRA
    2323AC_HEADER_STDC
    24 AC_CHECK_HEADERS(err.h fcntl.h sys/ioctl.h sys/queue.h unistd.h libgen.h net/if_tun.h)
     24AC_CHECK_HEADERS(err.h fcntl.h sys/ioctl.h sys/queue.h unistd.h libgen.h net/if_tun.h net/ethernet.h)
    2525dnl XXX - Solaris sux.
    2626AC_MSG_CHECKING(for MIN and MAX in sys/param.h)
    2727AC_EGREP_CPP(yes, [
     
    4343AC_CHECK_TYPE(u_int64_t, uint64_t)
    4444dnl XXX - Linux sux.
    4545AC_CHECK_TYPE(in_addr_t, u_int32_t)
    46 CFLAGS="$CFLAGS -D_BSD_SOURCE"
     46CFLAGS="$CFLAGS -D_BSD_SOURCE -DBIND_8_COMPAT"
    4747
    4848dnl Checks for library functions.
    4949AC_PROG_GCC_TRADITIONAL
  • dnsspoof.c

    diff -ur dsniff-2.4/dnsspoof.c dsniff-2.4-mine/dnsspoof.c
    old new  
    3838
    3939pcap_t          *pcap_pd = NULL;
    4040int              pcap_off = -1;
    41 int              lnet_sock = -1;
     41libnet_t        *l;
    4242u_long           lnet_ip = -1;
    4343
    4444static void
     
    9090dns_init(char *dev, char *filename)
    9191{
    9292        FILE *f;
    93         struct libnet_link_int *llif;
     93        libnet_t *l;
     94        char libnet_ebuf[LIBNET_ERRBUF_SIZE];
    9495        struct dnsent *de;
    9596        char *ip, *name, buf[1024];
    9697
    97         if ((llif = libnet_open_link_interface(dev, buf)) == NULL)
    98                 errx(1, "%s", buf);
     98        if ((l = libnet_init(LIBNET_LINK, dev, libnet_ebuf)) == NULL)
     99                errx(1, "%s", libnet_ebuf);
    99100       
    100         if ((lnet_ip = libnet_get_ipaddr(llif, dev, buf)) == -1)
    101                 errx(1, "%s", buf);
     101        if ((lnet_ip = libnet_get_ipaddr4(l)) == -1)
     102                errx(1, "%s", libnet_geterror(l));
    102103
    103         lnet_ip = htonl(lnet_ip);
    104        
    105         libnet_close_link_interface(llif);
     104        libnet_destroy(l);
    106105
    107106        SLIST_INIT(&dns_entries);
    108107       
     
    180179static void
    181180dns_spoof(u_char *u, const struct pcap_pkthdr *pkthdr, const u_char *pkt)
    182181{
    183         struct libnet_ip_hdr *ip;
     182        struct libnet_ipv4_hdr *ip;
    184183        struct libnet_udp_hdr *udp;
    185184        HEADER *dns;
    186185        char name[MAXHOSTNAMELEN];
     
    189188        in_addr_t dst;
    190189        u_short type, class;
    191190
    192         ip = (struct libnet_ip_hdr *)(pkt + pcap_off);
     191        ip = (struct libnet_ipv4_hdr *)(pkt + pcap_off);
    193192        udp = (struct libnet_udp_hdr *)(pkt + pcap_off + (ip->ip_hl * 4));
    194193        dns = (HEADER *)(udp + 1);
    195194        p = (u_char *)(dns + 1);
     
    212211        if (class != C_IN)
    213212                return;
    214213
    215         p = buf + IP_H + UDP_H + dnslen;
     214        p = buf + dnslen;
    216215       
    217216        if (type == T_A) {
    218217                if ((dst = dns_lookup_a(name)) == -1)
     
    234233                anslen += 12;
    235234        }
    236235        else return;
    237        
    238         libnet_build_ip(UDP_H + dnslen + anslen, 0, libnet_get_prand(PRu16),
    239                         0, 64, IPPROTO_UDP, ip->ip_dst.s_addr,
    240                         ip->ip_src.s_addr, NULL, 0, buf);
    241        
    242         libnet_build_udp(ntohs(udp->uh_dport), ntohs(udp->uh_sport),
    243                          NULL, dnslen + anslen, buf + IP_H);
    244236
    245         memcpy(buf + IP_H + UDP_H, (u_char *)dns, dnslen);
     237        memcpy(buf, (u_char *)dns, dnslen);
    246238
    247         dns = (HEADER *)(buf + IP_H + UDP_H);
     239        dns = (HEADER *)buf;
    248240        dns->qr = dns->ra = 1;
    249241        if (type == T_PTR) dns->aa = 1;
    250242        dns->ancount = htons(1);
    251243
    252244        dnslen += anslen;
     245
     246        libnet_clear_packet(l);
     247        libnet_build_udp(ntohs(udp->uh_dport), ntohs(udp->uh_sport),
     248                         LIBNET_UDP_H + dnslen, 0,
     249                         (u_int8_t *)buf, dnslen, l, 0);
     250
     251        libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_UDP_H + dnslen, 0,
     252                          libnet_get_prand(LIBNET_PRu16), 0, 64, IPPROTO_UDP, 0,
     253                          ip->ip_dst.s_addr, ip->ip_src.s_addr, NULL, 0, l, 0);
    253254       
    254         libnet_do_checksum(buf, IPPROTO_UDP, UDP_H + dnslen);
    255        
    256         if (libnet_write_ip(lnet_sock, buf, IP_H + UDP_H + dnslen) < 0)
     255        if (libnet_write(l) < 0)
    257256                warn("write");
    258257
    259258        fprintf(stderr, "%s.%d > %s.%d:  %d+ %s? %s\n",
    260               libnet_host_lookup(ip->ip_src.s_addr, 0), ntohs(udp->uh_sport),
    261               libnet_host_lookup(ip->ip_dst.s_addr, 0), ntohs(udp->uh_dport),
     259              libnet_addr2name4(ip->ip_src.s_addr, 0), ntohs(udp->uh_sport),
     260              libnet_addr2name4(ip->ip_dst.s_addr, 0), ntohs(udp->uh_dport),
    262261              ntohs(dns->id), type == T_A ? "A" : "PTR", name);
    263262}
    264263
    265264static void
    266265cleanup(int sig)
    267266{
    268         libnet_close_raw_sock(lnet_sock);
     267        libnet_destroy(l);
    269268        pcap_close(pcap_pd);
    270269        exit(0);
    271270}
     
    276275        extern char *optarg;
    277276        extern int optind;
    278277        char *p, *dev, *hosts, buf[1024];
     278        char ebuf[LIBNET_ERRBUF_SIZE];
    279279        int i;
    280280
    281281        dev = hosts = NULL;
     
    306306                strlcpy(buf, p, sizeof(buf));
    307307        }
    308308        else snprintf(buf, sizeof(buf), "udp dst port 53 and not src %s",
    309                       libnet_host_lookup(lnet_ip, 0));
     309                      libnet_addr2name4(lnet_ip, LIBNET_DONT_RESOLVE));
    310310       
    311311        if ((pcap_pd = pcap_init(dev, buf, 128)) == NULL)
    312312                errx(1, "couldn't initialize sniffing");
     
    314314        if ((pcap_off = pcap_dloff(pcap_pd)) < 0)
    315315                errx(1, "couldn't determine link layer offset");
    316316       
    317         if ((lnet_sock = libnet_open_raw_sock(IPPROTO_RAW)) == -1)
     317        if ((l = libnet_init(LIBNET_RAW4, dev, ebuf)) == NULL)
    318318                errx(1, "couldn't initialize sending");
    319319       
    320         libnet_seed_prand();
     320        libnet_seed_prand(l);
    321321       
    322322        signal(SIGHUP, cleanup);
    323323        signal(SIGINT, cleanup);
  • filesnarf.c

    diff -ur dsniff-2.4/filesnarf.c dsniff-2.4-mine/filesnarf.c
    old new  
    134134        int fd;
    135135
    136136        warnx("%s.%d > %s.%d: %s (%d@%d)",
    137               libnet_host_lookup(addr->daddr, 0), addr->dest,
    138               libnet_host_lookup(addr->saddr, 0), addr->source,
     137              libnet_addr2name4(addr->daddr, LIBNET_DONT_RESOLVE), addr->dest,
     138              libnet_addr2name4(addr->saddr, LIBNET_DONT_RESOLVE), addr->source,
    139139              ma->filename, len, ma->offset);
    140140       
    141141        if ((fd = open(ma->filename, O_WRONLY|O_CREAT, 0644)) >= 0) {
     
    353353}
    354354
    355355static void
    356 decode_udp_nfs(struct libnet_ip_hdr *ip)
     356decode_udp_nfs(struct libnet_ipv4_hdr *ip)
    357357{
    358358        static struct tuple4 addr;
    359359        struct libnet_udp_hdr *udp;
  • dsniff-2.

    diff -ur dsniff-2.4/macof.c dsniff-2.4-mine/macof.c
    old new  
    4848static void
    4949gen_mac(u_char *mac)
    5050{
    51         *((in_addr_t *)mac) = libnet_get_prand(PRu32);
    52         *((u_short *)(mac + 4)) = libnet_get_prand(PRu16);
     51        *((in_addr_t *)mac) = libnet_get_prand(LIBNET_PRu32);
     52        *((u_short *)(mac + 4)) = libnet_get_prand(LIBNET_PRu16);
    5353}
    5454
    5555int
     
    5959        extern int optind;
    6060        int c, i;
    6161        struct libnet_link_int *llif;
    62         char ebuf[PCAP_ERRBUF_SIZE];
     62        char pcap_ebuf[PCAP_ERRBUF_SIZE];
     63        char libnet_ebuf[LIBNET_ERRBUF_SIZE];
    6364        u_char sha[ETHER_ADDR_LEN], tha[ETHER_ADDR_LEN];
    6465        in_addr_t src, dst;
    6566        u_short sport, dport;
    6667        u_int32_t seq;
    67         u_char pkt[ETH_H + IP_H + TCP_H];
     68        libnet_t *l;
    6869       
    6970        while ((c = getopt(argc, argv, "vs:d:e:x:y:i:n:h?V")) != -1) {
    7071                switch (c) {
    7172                case 'v':
    7273                        break;
    7374                case 's':
    74                         Src = libnet_name_resolve(optarg, 0);
     75                        Src = libnet_name2addr4(l, optarg, 0);
    7576                        break;
    7677                case 'd':
    77                         Dst = libnet_name_resolve(optarg, 0);
     78                        Dst = libnet_name2addr4(l, optarg, 0);
    7879                        break;
    7980                case 'e':
    8081                        Tha = (u_char *)ether_aton(optarg);
     
    101102        if (argc != 0)
    102103                usage();
    103104       
    104         if (!Intf && (Intf = pcap_lookupdev(ebuf)) == NULL)
    105                 errx(1, "%s", ebuf);
     105        if (!Intf && (Intf = pcap_lookupdev(pcap_ebuf)) == NULL)
     106                errx(1, "%s", pcap_ebuf);
    106107       
    107         if ((llif = libnet_open_link_interface(Intf, ebuf)) == 0)
    108                 errx(1, "%s", ebuf);
     108        if ((l = libnet_init(LIBNET_LINK, Intf, libnet_ebuf)) == NULL)
     109                errx(1, "%s", libnet_ebuf);
    109110       
    110         libnet_seed_prand();
     111        libnet_seed_prand(l);
    111112       
    112113        for (i = 0; i != Repeat; i++) {
    113114               
     
    117118                else memcpy(tha, Tha, sizeof(tha));
    118119               
    119120                if (Src != 0) src = Src;
    120                 else src = libnet_get_prand(PRu32);
     121                else src = libnet_get_prand(LIBNET_PRu32);
    121122               
    122123                if (Dst != 0) dst = Dst;
    123                 else dst = libnet_get_prand(PRu32);
     124                else dst = libnet_get_prand(LIBNET_PRu32);
    124125               
    125126                if (Sport != 0) sport = Sport;
    126                 else sport = libnet_get_prand(PRu16);
     127                else sport = libnet_get_prand(LIBNET_PRu16);
    127128               
    128129                if (Dport != 0) dport = Dport;
    129                 else dport = libnet_get_prand(PRu16);
     130                else dport = libnet_get_prand(LIBNET_PRu16);
    130131
    131                 seq = libnet_get_prand(PRu32);
    132                
    133                 libnet_build_ethernet(tha, sha, ETHERTYPE_IP, NULL, 0, pkt);
    134                
    135                 libnet_build_ip(TCP_H, 0, libnet_get_prand(PRu16), 0, 64,
    136                                 IPPROTO_TCP, src, dst, NULL, 0, pkt + ETH_H);
     132                seq = libnet_get_prand(LIBNET_PRu32);
    137133               
    138134                libnet_build_tcp(sport, dport, seq, 0, TH_SYN, 512,
    139                                  0, NULL, 0, pkt + ETH_H + IP_H);
     135                                 0, 0, LIBNET_TCP_H, NULL, 0, l, 0);
    140136               
    141                 libnet_do_checksum(pkt + ETH_H, IPPROTO_IP, IP_H);
    142                 libnet_do_checksum(pkt + ETH_H, IPPROTO_TCP, TCP_H);
     137                libnet_build_ipv4(LIBNET_TCP_H, 0,
     138                                  libnet_get_prand(LIBNET_PRu16), 0, 64,
     139                                  IPPROTO_TCP, 0, src, dst, NULL, 0, l, 0);
    143140               
    144                 if (libnet_write_link_layer(llif, Intf, pkt, sizeof(pkt)) < 0)
     141                libnet_build_ethernet(tha, sha, ETHERTYPE_IP, NULL, 0, l, 0);
     142               
     143                if (libnet_write(l) < 0)
    145144                        errx(1, "write");
    146145
     146                libnet_clear_packet(l);
     147
    147148                fprintf(stderr, "%s ",
    148149                        ether_ntoa((struct ether_addr *)sha));
    149150                fprintf(stderr, "%s %s.%d > %s.%d: S %u:%u(0) win 512\n",
    150151                        ether_ntoa((struct ether_addr *)tha),
    151                         libnet_host_lookup(Src, 0), sport,
    152                         libnet_host_lookup(Dst, 0), dport, seq, seq);
     152                        libnet_addr2name4(Src, 0), sport,
     153                        libnet_addr2name4(Dst, 0), dport, seq, seq);
    153154        }
    154155        exit(0);
    155156}
  • pcaputil.c

    diff -ur dsniff-2.4/pcaputil.c dsniff-2.4-mine/pcaputil.c
    old new  
    1717#include <string.h>
    1818#include <err.h>
    1919#include <pcap.h>
     20#ifdef __APPLE__
     21#undef BSD
     22#endif
    2023#ifdef BSD
    2124#include <pcap-int.h>
    2225#endif
  • record.c

    diff -ur dsniff-2.4/record.c dsniff-2.4-mine/record.c
    old new  
    6565        tm = localtime(&rec->time);
    6666        strftime(tstr, sizeof(tstr), "%x %X", tm);
    6767       
    68         srcp = libnet_host_lookup(rec->src, Opt_dns);
    69         dstp = libnet_host_lookup(rec->dst, Opt_dns);
     68        srcp = libnet_addr2name4(rec->src, Opt_dns);
     69        dstp = libnet_addr2name4(rec->dst, Opt_dns);
    7070
    7171        if ((pr = getprotobynumber(rec->proto)) == NULL)
    7272                protop = "unknown";
  • sshcrypto.c

    diff -ur dsniff-2.4/sshcrypto.c dsniff-2.4-mine/sshcrypto.c
    old new  
    1414
    1515#include <sys/types.h>
    1616#include <openssl/ssl.h>
     17#ifndef BF_ENCRYPT
     18#include <openssl/blowfish.h>
     19#endif
     20#ifndef DES_DECRYPT
     21#include <openssl/des.h>
     22#endif
    1723
    1824#include <err.h>
    1925#include <stdio.h>
  • sshmitm.c

    diff -ur dsniff-2.4/sshmitm.c dsniff-2.4-mine/sshmitm.c
    old new  
    389389        if (argc < 1)
    390390                usage();
    391391       
    392         if ((ip = libnet_name_resolve(argv[0], 1)) == -1)
     392        if ((ip = libnet_name2addr4(NULL, argv[0], LIBNET_RESOLVE)) == -1)
    393393                usage();
    394394
    395395        if (argc == 2 && (rport = atoi(argv[1])) == 0)
  • dsniff-2.

    diff -ur dsniff-2.4/sshow.c dsniff-2.4-mine/sshow.c
    old new  
    1515
    1616#include <sys/types.h>
    1717#include <sys/times.h>
     18#include <machine/limits.h>
    1819
    1920#include <netinet/in_systm.h>
    2021#include <netinet/in.h>
  • tcp_raw.c

    diff -ur dsniff-2.4/tcp_raw.c dsniff-2.4-mine/tcp_raw.c
    old new  
    119119}
    120120
    121121struct iovec *
    122 tcp_raw_input(struct libnet_ip_hdr *ip, struct libnet_tcp_hdr *tcp, int len)
     122tcp_raw_input(struct libnet_ipv4_hdr *ip, struct libnet_tcp_hdr *tcp, int len)
    123123{
    124124        struct tha tha;
    125125        struct tcp_conn *conn;
     
    131131
    132132        /* Verify TCP checksum. */
    133133        cksum = tcp->th_sum;
    134         libnet_do_checksum((u_char *) ip, IPPROTO_TCP, len);
     134        libnet_do_checksum(NULL, (u_char *) ip, IPPROTO_TCP, len);
    135135
    136136        if (cksum != tcp->th_sum)
    137137                return (NULL);
  • tcp_raw.h

    diff -ur dsniff-2.4/tcp_raw.h dsniff-2.4-mine/tcp_raw.h
    old new  
    1515                                   u_short sport, u_short dport,
    1616                                   u_char *buf, int len);
    1717
    18 struct iovec   *tcp_raw_input(struct libnet_ip_hdr *ip,
     18struct iovec   *tcp_raw_input(struct libnet_ipv4_hdr *ip,
    1919                              struct libnet_tcp_hdr *tcp, int len);
    2020
    2121void            tcp_raw_timeout(int timeout, tcp_raw_callback_t callback);
  • tcpkill.c

    diff -ur dsniff-2.4/tcpkill.c dsniff-2.4-mine/tcpkill.c
    old new  
    3939static void
    4040tcp_kill_cb(u_char *user, const struct pcap_pkthdr *pcap, const u_char *pkt)
    4141{
    42         struct libnet_ip_hdr *ip;
     42        struct libnet_ipv4_hdr *ip;
    4343        struct libnet_tcp_hdr *tcp;
    44         u_char ctext[64], buf[IP_H + TCP_H];
     44        u_char ctext[64];
    4545        u_int32_t seq, win;
    46         int i, *sock, len;
     46        int i, len;
     47        libnet_t *l;
    4748
    48         sock = (int *)user;
     49        l = (libnet_t *)user;
    4950        pkt += pcap_off;
    5051        len = pcap->caplen - pcap_off;
    5152
    52         ip = (struct libnet_ip_hdr *)pkt;
     53        ip = (struct libnet_ipv4_hdr *)pkt;
    5354        if (ip->ip_p != IPPROTO_TCP)
    5455                return;
    5556       
     
    5758        if (tcp->th_flags & (TH_SYN|TH_FIN|TH_RST))
    5859                return;
    5960
    60         libnet_build_ip(TCP_H, 0, 0, 0, 64, IPPROTO_TCP,
    61                         ip->ip_dst.s_addr, ip->ip_src.s_addr,
    62                         NULL, 0, buf);
    63 
    64         libnet_build_tcp(ntohs(tcp->th_dport), ntohs(tcp->th_sport),
    65                          0, 0, TH_RST, 0, 0, NULL, 0, buf + IP_H);
    66        
    6761        seq = ntohl(tcp->th_ack);
    6862        win = ntohs(tcp->th_win);
    6963       
    7064        snprintf(ctext, sizeof(ctext), "%s:%d > %s:%d:",
    71                  libnet_host_lookup(ip->ip_src.s_addr, 0),
     65                 libnet_addr2name4(ip->ip_src.s_addr, LIBNET_DONT_RESOLVE),
    7266                 ntohs(tcp->th_sport),
    73                  libnet_host_lookup(ip->ip_dst.s_addr, 0),
     67                 libnet_addr2name4(ip->ip_dst.s_addr, LIBNET_DONT_RESOLVE),
    7468                 ntohs(tcp->th_dport));
    7569       
    76         ip = (struct libnet_ip_hdr *)buf;
    77         tcp = (struct libnet_tcp_hdr *)(ip + 1);
    78        
    7970        for (i = 0; i < Opt_severity; i++) {
    80                 ip->ip_id = libnet_get_prand(PRu16);
    8171                seq += (i * win);
    82                 tcp->th_seq = htonl(seq);
    8372               
    84                 libnet_do_checksum(buf, IPPROTO_TCP, TCP_H);
     73                libnet_clear_packet(l);
     74               
     75                libnet_build_tcp(ntohs(tcp->th_dport), ntohs(tcp->th_sport),
     76                                 seq, 0, TH_RST, 0, 0, 0, LIBNET_TCP_H,
     77                                 NULL, 0, l, 0);
     78               
     79                libnet_build_ipv4(LIBNET_IPV4_H + LIBNET_TCP_H, 0,
     80                                  libnet_get_prand(LIBNET_PRu16), 0, 64,
     81                                  IPPROTO_TCP, 0, ip->ip_dst.s_addr,
     82                                  ip->ip_src.s_addr, NULL, 0, l, 0);
    8583               
    86                 if (libnet_write_ip(*sock, buf, sizeof(buf)) < 0)
    87                         warn("write_ip");
     84                if (libnet_write(l) < 0)
     85                        warn("write");
    8886               
    8987                fprintf(stderr, "%s R %lu:%lu(0) win 0\n", ctext, seq, seq);
    9088        }
     
    9593{
    9694        extern char *optarg;
    9795        extern int optind;
    98         int c, sock;
     96        int c;
    9997        char *p, *intf, *filter, ebuf[PCAP_ERRBUF_SIZE];
     98        char libnet_ebuf[LIBNET_ERRBUF_SIZE];
     99        libnet_t *l;
    100100        pcap_t *pd;
    101101       
    102102        intf = NULL;
     
    136136        if ((pcap_off = pcap_dloff(pd)) < 0)
    137137                errx(1, "couldn't determine link layer offset");
    138138       
    139         if ((sock = libnet_open_raw_sock(IPPROTO_RAW)) == -1)
     139        if ((l = libnet_init(LIBNET_RAW4, intf, libnet_ebuf)) == NULL)
    140140                errx(1, "couldn't initialize sending");
    141141       
    142         libnet_seed_prand();
     142        libnet_seed_prand(l);
    143143       
    144144        warnx("listening on %s [%s]", intf, filter);
    145145       
    146         pcap_loop(pd, -1, tcp_kill_cb, (u_char *)&sock);
     146        pcap_loop(pd, -1, tcp_kill_cb, (u_char *)l);
    147147 
    148148        /* NOTREACHED */
    149149       
  • tcpnice.c

    diff -ur dsniff-2.4/tcpnice.c dsniff-2.4-mine/tcpnice.c
    old new  
    4141}
    4242
    4343static void
    44 send_tcp_window_advertisement(int sock, struct libnet_ip_hdr *ip,
     44send_tcp_window_advertisement(libnet_t *l, struct libnet_ipv4_hdr *ip,
    4545                             struct libnet_tcp_hdr *tcp)
    4646{
    4747        int len;
    4848       
    4949        ip->ip_hl = 5;
    50         ip->ip_len = htons(IP_H + TCP_H);
    51         ip->ip_id = libnet_get_prand(PRu16);
    52         memcpy(buf, (u_char *)ip, IP_H);
     50        ip->ip_len = htons(LIBNET_IPV4_H + LIBNET_TCP_H);
     51        ip->ip_id = libnet_get_prand(LIBNET_PRu16);
     52        memcpy(buf, (u_char *)ip, LIBNET_IPV4_H);
    5353       
    5454        tcp->th_off = 5;
    5555        tcp->th_win = htons(MIN_WIN);
    56         memcpy(buf + IP_H, (u_char *)tcp, TCP_H);
     56        memcpy(buf + LIBNET_IPV4_H, (u_char *)tcp, LIBNET_TCP_H);
    5757       
    58         libnet_do_checksum(buf, IPPROTO_TCP, TCP_H);
     58        libnet_do_checksum(l, buf, IPPROTO_TCP, LIBNET_TCP_H);
    5959       
    60         len = IP_H + TCP_H;
     60        len = LIBNET_IPV4_H + LIBNET_TCP_H;
    6161       
    62         if (libnet_write_ip(sock, buf, len) != len)
     62        if (libnet_write_raw_ipv4(l, buf, len) != len)
    6363                warn("write");
    6464       
    6565        fprintf(stderr, "%s:%d > %s:%d: . ack %lu win %d\n",
    66                 libnet_host_lookup(ip->ip_src.s_addr, 0), ntohs(tcp->th_sport),
    67                 libnet_host_lookup(ip->ip_dst.s_addr, 0), ntohs(tcp->th_dport),
     66                libnet_addr2name4(ip->ip_src.s_addr, 0), ntohs(tcp->th_sport),
     67                libnet_addr2name4(ip->ip_dst.s_addr, 0), ntohs(tcp->th_dport),
    6868                ntohl(tcp->th_ack), 1);
    6969}
    7070
    7171static void
    72 send_icmp_source_quench(int sock, struct libnet_ip_hdr *ip)
     72send_icmp_source_quench(libnet_t *l, struct libnet_ipv4_hdr *ip)
    7373{
    74         struct libnet_icmp_hdr *icmp;
     74        struct libnet_icmpv4_hdr *icmp;
    7575        int len;
    7676       
    7777        len = (ip->ip_hl * 4) + 8;
    7878
    79         libnet_build_ip(ICMP_ECHO_H + len, 0, libnet_get_prand(PRu16),
    80                         0, 64, IPPROTO_ICMP, ip->ip_dst.s_addr,
    81                         ip->ip_src.s_addr, NULL, 0, buf);
    82        
    83         icmp = (struct libnet_icmp_hdr *)(buf + IP_H);
     79        icmp = (struct libnet_icmpv4_hdr *)(buf + LIBNET_IPV4_H);
    8480        icmp->icmp_type = ICMP_SOURCEQUENCH;
    8581        icmp->icmp_code = 0;
    86         memcpy((u_char *)icmp + ICMP_ECHO_H, (u_char *)ip, len);
     82        memcpy((u_char *)icmp + LIBNET_ICMPV4_ECHO_H, (u_char *)ip, len);
    8783       
    88         libnet_do_checksum(buf, IPPROTO_ICMP, ICMP_ECHO_H + len);
     84        len += LIBNET_ICMPV4_ECHO_H;
    8985       
    90         len += (IP_H + ICMP_ECHO_H);
     86        libnet_build_ipv4(LIBNET_IPV4_H + len, 0,
     87                          libnet_get_prand(LIBNET_PRu16), 0, 64, IPPROTO_ICMP,
     88                          0, ip->ip_dst.s_addr, ip->ip_src.s_addr,
     89                          (u_int8_t *) icmp, len, l, 0);
    9190       
    92         if (libnet_write_ip(sock, buf, len) != len)
     91        if (libnet_write(l) != len)
    9392                warn("write");
    9493       
    9594        fprintf(stderr, "%s > %s: icmp: source quench\n",
    96                 libnet_host_lookup(ip->ip_dst.s_addr, 0),
    97                 libnet_host_lookup(ip->ip_src.s_addr, 0));
     95                libnet_addr2name4(ip->ip_dst.s_addr, 0),
     96                libnet_addr2name4(ip->ip_src.s_addr, 0));
    9897}
    9998
    10099static void
    101 send_icmp_frag_needed(int sock, struct libnet_ip_hdr *ip)
     100send_icmp_frag_needed(libnet_t *l, struct libnet_ipv4_hdr *ip)
    102101{
    103         struct libnet_icmp_hdr *icmp;
     102        struct libnet_icmpv4_hdr *icmp;
    104103        int len;
    105104
    106105        len = (ip->ip_hl * 4) + 8;
    107106       
    108         libnet_build_ip(ICMP_MASK_H + len, 4, libnet_get_prand(PRu16),
    109                         0, 64, IPPROTO_ICMP, ip->ip_dst.s_addr,
    110                         ip->ip_src.s_addr, NULL, 0, buf);
    111 
    112         icmp = (struct libnet_icmp_hdr *)(buf + IP_H);
     107        icmp = (struct libnet_icmpv4_hdr *)(buf + LIBNET_IPV4_H);
    113108        icmp->icmp_type = ICMP_UNREACH;
    114109        icmp->icmp_code = ICMP_UNREACH_NEEDFRAG;
    115110        icmp->hun.frag.pad = 0;
    116111        icmp->hun.frag.mtu = htons(MIN_MTU);
    117         memcpy((u_char *)icmp + ICMP_MASK_H, (u_char *)ip, len);
     112        memcpy((u_char *)icmp + LIBNET_ICMPV4_MASK_H, (u_char *)ip, len);
    118113
    119         libnet_do_checksum(buf, IPPROTO_ICMP, ICMP_MASK_H + len);
    120        
    121         len += (IP_H + ICMP_MASK_H);
     114        len += LIBNET_ICMPV4_MASK_H;
     115
     116        libnet_build_ipv4(LIBNET_IPV4_H + len, 4,
     117                          libnet_get_prand(LIBNET_PRu16), 0, 64, IPPROTO_ICMP,
     118                          0, ip->ip_dst.s_addr, ip->ip_src.s_addr,
     119                          (u_int8_t *) icmp, len, l, 0);
    122120       
    123         if (libnet_write_ip(sock, buf, len) != len)
     121        if (libnet_write(l) != len)
    124122                warn("write");
    125123       
    126124        fprintf(stderr, "%s > %s: icmp: ",
    127                 libnet_host_lookup(ip->ip_dst.s_addr, 0),
    128                 libnet_host_lookup(ip->ip_src.s_addr, 0));
     125                libnet_addr2name4(ip->ip_dst.s_addr, 0),
     126                libnet_addr2name4(ip->ip_src.s_addr, 0));
    129127        fprintf(stderr, "%s unreachable - need to frag (mtu %d)\n",
    130                 libnet_host_lookup(ip->ip_src.s_addr, 0), MIN_MTU);
     128                libnet_addr2name4(ip->ip_src.s_addr, 0), MIN_MTU);
    131129}
    132130
    133131static void
    134132tcp_nice_cb(u_char *user, const struct pcap_pkthdr *pcap, const u_char *pkt)
    135133{
    136         struct libnet_ip_hdr *ip;
     134        struct libnet_ipv4_hdr *ip;
    137135        struct libnet_tcp_hdr *tcp;
    138         int *sock, len;
     136        int len;
     137        libnet_t *l;
    139138
    140         sock = (int *)user;
     139        l = (libnet_t *)user;
    141140        pkt += pcap_off;
    142141        len = pcap->caplen - pcap_off;
    143142
    144         ip = (struct libnet_ip_hdr *)pkt;
     143        ip = (struct libnet_ipv4_hdr *)pkt;
    145144        if (ip->ip_p != IPPROTO_TCP)
    146145                return;
    147146       
     
    151150       
    152151        if (ntohs(ip->ip_len) > (ip->ip_hl << 2) + (tcp->th_off << 2)) {
    153152                if (Opt_icmp)
    154                         send_icmp_source_quench(*sock, ip);
     153                        send_icmp_source_quench(l, ip);
    155154                if (Opt_win)
    156                         send_tcp_window_advertisement(*sock, ip, tcp);
     155                        send_tcp_window_advertisement(l, ip, tcp);
    157156                if (Opt_pmtu)
    158                         send_icmp_frag_needed(*sock, ip);
     157                        send_icmp_frag_needed(l, ip);
    159158        }
    160159}
    161160
     
    164163{
    165164        extern char *optarg;
    166165        extern int optind;
    167         int c, sock;
     166        int c;
    168167        char *intf, *filter, ebuf[PCAP_ERRBUF_SIZE];
     168        char libnet_ebuf[LIBNET_ERRBUF_SIZE];
     169        libnet_t *l;
    169170        pcap_t *pd;
    170171       
    171172        intf = NULL;
     
    209210        if ((pcap_off = pcap_dloff(pd)) < 0)
    210211                errx(1, "couldn't determine link layer offset");
    211212       
    212         if ((sock = libnet_open_raw_sock(IPPROTO_RAW)) == -1)
     213        if ((l = libnet_init(LIBNET_RAW4, intf, libnet_ebuf)) == NULL)
    213214                errx(1, "couldn't initialize sending");
    214215       
    215         libnet_seed_prand();
     216        libnet_seed_prand(l);
    216217       
    217218        warnx("listening on %s [%s]", intf, filter);
    218219       
    219         pcap_loop(pd, -1, tcp_nice_cb, (u_char *)&sock);
     220        pcap_loop(pd, -1, tcp_nice_cb, (u_char *)l);
    220221       
    221222        /* NOTREACHED */
    222223       
  • trigger.c

    diff -ur dsniff-2.4/trigger.c dsniff-2.4-mine/trigger.c
    old new  
    276276}
    277277       
    278278void
    279 trigger_ip(struct libnet_ip_hdr *ip)
     279trigger_ip(struct libnet_ipv4_hdr *ip)
    280280{
    281281        struct trigger *t, tr;
    282282        u_char *buf;
     
    305305
    306306/* libnids needs a nids_register_udp()... */
    307307void
    308 trigger_udp(struct libnet_ip_hdr *ip)
     308trigger_udp(struct libnet_ipv4_hdr *ip)
    309309{
    310310        struct trigger *t, tr;
    311311        struct libnet_udp_hdr *udp;
     
    437437}
    438438
    439439void
    440 trigger_tcp_raw(struct libnet_ip_hdr *ip)
     440trigger_tcp_raw(struct libnet_ipv4_hdr *ip)
    441441{
    442442        struct trigger *t, tr;
    443443        struct libnet_tcp_hdr *tcp;
  • trigger.h

    diff -ur dsniff-2.4/trigger.h dsniff-2.4-mine/trigger.h
    old new  
    2424int     trigger_set_tcp(int port, char *name);
    2525int     trigger_set_rpc(int program, char *name);
    2626
    27 void    trigger_ip(struct libnet_ip_hdr *ip);
    28 void    trigger_udp(struct libnet_ip_hdr *ip);
     27void    trigger_ip(struct libnet_ipv4_hdr *ip);
     28void    trigger_udp(struct libnet_ipv4_hdr *ip);
    2929void    trigger_tcp(struct tcp_stream *ts, void **conn_save);
    30 void    trigger_tcp_raw(struct libnet_ip_hdr *ip);
     30void    trigger_tcp_raw(struct libnet_ipv4_hdr *ip);
    3131void    trigger_tcp_raw_timeout(int signal);
    3232void    trigger_rpc(int program, int proto, int port);
    3333
  • urlsnarf.c

    diff -ur dsniff-2.4/urlsnarf.c dsniff-2.4-mine/urlsnarf.c
    old new  
    145145                if (user == NULL)
    146146                        user = "-";
    147147                if (vhost == NULL)
    148                         vhost = libnet_host_lookup(addr->daddr, Opt_dns);
     148                        vhost = libnet_addr2name4(addr->daddr, Opt_dns);
    149149                if (referer == NULL)
    150150                        referer = "-";
    151151                if (agent == NULL)
    152152                        agent = "-";
    153153               
    154154                printf("%s - %s [%s] \"%s http://%s%s\" - - \"%s\" \"%s\"\n",
    155                        libnet_host_lookup(addr->saddr, Opt_dns),
     155                       libnet_addr2name4(addr->saddr, Opt_dns),
    156156                       user, timestamp(), req, vhost, uri, referer, agent);
    157157        }
    158158        fflush(stdout);
  • webmitm.c

    diff -ur dsniff-2.4/webmitm.c dsniff-2.4-mine/webmitm.c
    old new  
    242242                        word = buf_tok(&msg, "/", 1);
    243243                        vhost = buf_strdup(word);
    244244                }
    245                 ssin.sin_addr.s_addr = libnet_name_resolve(vhost, 1);
     245                ssin.sin_addr.s_addr = libnet_name2addr4(NULL, vhost, 1);
    246246                free(vhost);
    247247               
    248248                if (ssin.sin_addr.s_addr == ntohl(INADDR_LOOPBACK) ||
     
    510510        argv += optind;
    511511
    512512        if (argc == 1) {
    513                 if ((static_host = libnet_name_resolve(argv[0], 1)) == -1)
     513                if ((static_host = libnet_name2addr4(NULL, argv[0], 1)) == -1)
    514514                        usage();
    515515        }
    516516        else if (argc != 0) usage();
  • webspy.c

    diff -ur dsniff-2.4/webspy.c dsniff-2.4-mine/webspy.c
    old new  
    126126                if (auth == NULL)
    127127                        auth = "";
    128128                if (vhost == NULL)
    129                         vhost = libnet_host_lookup(addr->daddr, 0);
     129                        vhost = libnet_addr2name4(addr->daddr, 0);
    130130               
    131131                snprintf(cmd, sizeof(cmd), "openURL(http://%s%s%s%s)",
    132132                         auth, *auth ? "@" : "", vhost, uri);
     
    202202        cmdtab[0] = cmd;
    203203        cmdtab[1] = NULL;
    204204       
    205         if ((host = libnet_name_resolve(argv[0], 1)) == -1)
     205        if ((host = libnet_name2addr4(NULL, argv[0], 1)) == -1)
    206206                errx(1, "unknown host");
    207207       
    208208        if ((dpy = XOpenDisplay(NULL)) == NULL)