From 437d3489a8df7eae517289a221173459eb2d7be2 Mon Sep 17 00:00:00 2001 From: wbx Date: Sat, 11 Jun 2005 11:40:04 +0000 Subject: dsniff, still segfaults, but some tools work fine urlsnarf,.. git-svn-id: svn://svn.openwrt.org/openwrt/trunk/openwrt@1199 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- package/dsniff/patches/dns.patch | 704 +++++++++++++++++++++++++++++++ package/dsniff/patches/gdbm.patch | 188 +++++++++ package/dsniff/patches/noyp.patch | 33 ++ package/dsniff/patches/pcap-header.patch | 12 + 4 files changed, 937 insertions(+) create mode 100644 package/dsniff/patches/dns.patch create mode 100644 package/dsniff/patches/gdbm.patch create mode 100644 package/dsniff/patches/noyp.patch create mode 100644 package/dsniff/patches/pcap-header.patch (limited to 'package/dsniff/patches') diff --git a/package/dsniff/patches/dns.patch b/package/dsniff/patches/dns.patch new file mode 100644 index 000000000..e5cf8b2af --- /dev/null +++ b/package/dsniff/patches/dns.patch @@ -0,0 +1,704 @@ +diff -Nur dsniff-2.3/dns.c dsniff-2.3.patched/dns.c +--- dsniff-2.3/dns.c 1970-01-01 01:00:00.000000000 +0100 ++++ dsniff-2.3.patched/dns.c 2005-06-09 14:06:36.000000000 +0200 +@@ -0,0 +1,677 @@ ++/* ++ * Copyright (c) 1985, 1993 ++ * The Regents of the University of California. All rights reserved. ++ * ++ * Redistribution and use in source and binary forms, with or without ++ * modification, are permitted provided that the following conditions ++ * are met: ++ * 1. Redistributions of source code must retain the above copyright ++ * notice, this list of conditions and the following disclaimer. ++ * 2. Redistributions in binary form must reproduce the above copyright ++ * notice, this list of conditions and the following disclaimer in the ++ * documentation and/or other materials provided with the distribution. ++ * 4. Neither the name of the University nor the names of its contributors ++ * may be used to endorse or promote products derived from this software ++ * without specific prior written permission. ++ * ++ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ++ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ++ * SUCH DAMAGE. ++ */ ++ ++/* ++ * Portions Copyright (c) 1993 by Digital Equipment Corporation. ++ * ++ * Permission to use, copy, modify, and distribute this software for any ++ * purpose with or without fee is hereby granted, provided that the above ++ * copyright notice and this permission notice appear in all copies, and that ++ * the name of Digital Equipment Corporation not be used in advertising or ++ * publicity pertaining to distribution of the document or software without ++ * specific, written prior permission. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL ++ * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES ++ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT ++ * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL ++ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR ++ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ++ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ++ * SOFTWARE. ++ */ ++ ++/* ++ * Portions Copyright (c) 1996-1999 by Internet Software Consortium. ++ * ++ * Permission to use, copy, modify, and distribute this software for any ++ * purpose with or without fee is hereby granted, provided that the above ++ * copyright notice and this permission notice appear in all copies. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS ++ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES ++ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE ++ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL ++ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR ++ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ++ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ++ * SOFTWARE. ++ */ ++ ++/* ++ * Copyright (c) 1996,1999 by Internet Software Consortium. ++ * ++ * Permission to use, copy, modify, and distribute this software for any ++ * purpose with or without fee is hereby granted, provided that the above ++ * copyright notice and this permission notice appear in all copies. ++ * ++ * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS ++ * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES ++ * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE ++ * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL ++ * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR ++ * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ++ * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ++ * SOFTWARE. ++ */ ++ ++/* ++ * ++ * DNS helper functions not implemented in uclibc ++ * ++ */ ++ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++static const char digits[] = "0123456789"; ++ ++/* Forward. */ ++ ++static int special(int); ++static int printable(int); ++static int dn_find(const u_char *, const u_char *, ++ const u_char * const *, ++ const u_char * const *); ++ ++ ++/* ++ * ns_name_ntop(src, dst, dstsiz) ++ * Convert an encoded domain name to printable ascii as per RFC1035. ++ * return: ++ * Number of bytes written to buffer, or -1 (with errno set) ++ * notes: ++ * The root is returned as "." ++ * All other domains are returned in non absolute form ++ */ ++int ++ns_name_ntop(const u_char *src, char *dst, size_t dstsiz) { ++ const u_char *cp; ++ char *dn, *eom; ++ u_char c; ++ u_int n; ++ ++ cp = src; ++ dn = dst; ++ eom = dst + dstsiz; ++ ++ while ((n = *cp++) != 0) { ++ if ((n & NS_CMPRSFLGS) != 0) { ++ /* Some kind of compression pointer. */ ++ return (-1); ++ } ++ if (dn != dst) { ++ if (dn >= eom) { ++ return (-1); ++ } ++ *dn++ = '.'; ++ } ++ if (dn + n >= eom) { ++ return (-1); ++ } ++ for ((void)NULL; n > 0; n--) { ++ c = *cp++; ++ if (special(c)) { ++ if (dn + 1 >= eom) { ++ return (-1); ++ } ++ *dn++ = '\\'; ++ *dn++ = (char)c; ++ } else if (!printable(c)) { ++ if (dn + 3 >= eom) { ++ return (-1); ++ } ++ *dn++ = '\\'; ++ *dn++ = digits[c / 100]; ++ *dn++ = digits[(c % 100) / 10]; ++ *dn++ = digits[c % 10]; ++ } else { ++ if (dn >= eom) { ++ return (-1); ++ } ++ *dn++ = (char)c; ++ } ++ } ++ } ++ if (dn == dst) { ++ if (dn >= eom) { ++ return (-1); ++ } ++ *dn++ = '.'; ++ } ++ if (dn >= eom) { ++ return (-1); ++ } ++ *dn++ = '\0'; ++ return (dn - dst); ++} ++ ++/* ++ * ns_name_pton(src, dst, dstsiz) ++ * Convert a ascii string into an encoded domain name as per RFC1035. ++ * return: ++ * -1 if it fails ++ * 1 if string was fully qualified ++ * 0 is string was not fully qualified ++ * notes: ++ * Enforces label and domain length limits. ++ */ ++ ++int ++ns_name_pton(const char *src, u_char *dst, size_t dstsiz) { ++ u_char *label, *bp, *eom; ++ int c, n, escaped; ++ char *cp; ++ ++ escaped = 0; ++ bp = dst; ++ eom = dst + dstsiz; ++ label = bp++; ++ ++ while ((c = *src++) != 0) { ++ if (escaped) { ++ if ((cp = strchr(digits, c)) != NULL) { ++ n = (cp - digits) * 100; ++ if ((c = *src++) == 0 || ++ (cp = strchr(digits, c)) == NULL) { ++ return (-1); ++ } ++ n += (cp - digits) * 10; ++ if ((c = *src++) == 0 || ++ (cp = strchr(digits, c)) == NULL) { ++ return (-1); ++ } ++ n += (cp - digits); ++ if (n > 255) { ++ return (-1); ++ } ++ c = n; ++ } ++ escaped = 0; ++ } else if (c == '\\') { ++ escaped = 1; ++ continue; ++ } else if (c == '.') { ++ c = (bp - label - 1); ++ if ((c & NS_CMPRSFLGS) != 0) { /* Label too big. */ ++ return (-1); ++ } ++ if (label >= eom) { ++ return (-1); ++ } ++ *label = c; ++ /* Fully qualified ? */ ++ if (*src == '\0') { ++ if (c != 0) { ++ if (bp >= eom) { ++ return (-1); ++ } ++ *bp++ = '\0'; ++ } ++ if ((bp - dst) > MAXCDNAME) { ++ return (-1); ++ } ++ return (1); ++ } ++ if (c == 0 || *src == '.') { ++ return (-1); ++ } ++ label = bp++; ++ continue; ++ } ++ if (bp >= eom) { ++ return (-1); ++ } ++ *bp++ = (u_char)c; ++ } ++ c = (bp - label - 1); ++ if ((c & NS_CMPRSFLGS) != 0) { /* Label too big. */ ++ return (-1); ++ } ++ if (label >= eom) { ++ return (-1); ++ } ++ *label = c; ++ if (c != 0) { ++ if (bp >= eom) { ++ return (-1); ++ } ++ *bp++ = 0; ++ } ++ if ((bp - dst) > MAXCDNAME) { /* src too big */ ++ return (-1); ++ } ++ return (0); ++} ++ ++/* ++ * ns_name_ntol(src, dst, dstsiz) ++ * Convert a network strings labels into all lowercase. ++ * return: ++ * Number of bytes written to buffer, or -1 (with errno set) ++ * notes: ++ * Enforces label and domain length limits. ++ */ ++ ++int ++ns_name_ntol(const u_char *src, u_char *dst, size_t dstsiz) { ++ const u_char *cp; ++ u_char *dn, *eom; ++ u_char c; ++ u_int n; ++ ++ cp = src; ++ dn = dst; ++ eom = dst + dstsiz; ++ ++ while ((n = *cp++) != 0) { ++ if ((n & NS_CMPRSFLGS) != 0) { ++ /* Some kind of compression pointer. */ ++ return (-1); ++ } ++ *dn++ = n; ++ if (dn + n >= eom) { ++ return (-1); ++ } ++ for ((void)NULL; n > 0; n--) { ++ c = *cp++; ++ if (isupper(c)) ++ *dn++ = tolower(c); ++ else ++ *dn++ = c; ++ } ++ } ++ *dn++ = '\0'; ++ return (dn - dst); ++} ++ ++/* ++ * ns_name_unpack(msg, eom, src, dst, dstsiz) ++ * Unpack a domain name from a message, source may be compressed. ++ * return: ++ * -1 if it fails, or consumed octets if it succeeds. ++ */ ++int ++ns_name_unpack(const u_char *msg, const u_char *eom, const u_char *src, ++ u_char *dst, size_t dstsiz) ++{ ++ const u_char *srcp, *dstlim; ++ u_char *dstp; ++ int n, len, checked; ++ ++ len = -1; ++ checked = 0; ++ dstp = dst; ++ srcp = src; ++ dstlim = dst + dstsiz; ++ if (srcp < msg || srcp >= eom) { ++ return (-1); ++ } ++ /* Fetch next label in domain name. */ ++ while ((n = *srcp++) != 0) { ++ /* Check for indirection. */ ++ switch (n & NS_CMPRSFLGS) { ++ case 0: ++ /* Limit checks. */ ++ if (dstp + n + 1 >= dstlim || srcp + n >= eom) { ++ return (-1); ++ } ++ checked += n + 1; ++ *dstp++ = n; ++ memcpy(dstp, srcp, n); ++ dstp += n; ++ srcp += n; ++ break; ++ ++ case NS_CMPRSFLGS: ++ if (srcp >= eom) { ++ return (-1); ++ } ++ if (len < 0) ++ len = srcp - src + 1; ++ srcp = msg + (((n & 0x3f) << 8) | (*srcp & 0xff)); ++ if (srcp < msg || srcp >= eom) { /* Out of range. */ ++ return (-1); ++ } ++ checked += 2; ++ /* ++ * Check for loops in the compressed name; ++ * if we've looked at the whole message, ++ * there must be a loop. ++ */ ++ if (checked >= eom - msg) { ++ return (-1); ++ } ++ break; ++ ++ default: ++ return (-1); /* flag error */ ++ } ++ } ++ *dstp = '\0'; ++ if (len < 0) ++ len = srcp - src; ++ return (len); ++} ++ ++/* ++ * ns_name_pack(src, dst, dstsiz, dnptrs, lastdnptr) ++ * Pack domain name 'domain' into 'comp_dn'. ++ * return: ++ * Size of the compressed name, or -1. ++ * notes: ++ * 'dnptrs' is an array of pointers to previous compressed names. ++ * dnptrs[0] is a pointer to the beginning of the message. The array ++ * ends with NULL. ++ * 'lastdnptr' is a pointer to the end of the array pointed to ++ * by 'dnptrs'. ++ * Side effects: ++ * The list of pointers in dnptrs is updated for labels inserted into ++ * the message as we compress the name. If 'dnptr' is NULL, we don't ++ * try to compress names. If 'lastdnptr' is NULL, we don't update the ++ * list. ++ */ ++int ++ns_name_pack(const u_char *src, u_char *dst, int dstsiz, ++ const u_char **dnptrs, const u_char **lastdnptr) ++{ ++ u_char *dstp; ++ const u_char **cpp, **lpp, *eob, *msg; ++ const u_char *srcp; ++ int n, l, first = 1; ++ ++ srcp = src; ++ dstp = dst; ++ eob = dstp + dstsiz; ++ lpp = cpp = NULL; ++ if (dnptrs != NULL) { ++ if ((msg = *dnptrs++) != NULL) { ++ for (cpp = dnptrs; *cpp != NULL; cpp++) ++ (void)NULL; ++ lpp = cpp; /* end of list to search */ ++ } ++ } else ++ msg = NULL; ++ ++ /* make sure the domain we are about to add is legal */ ++ l = 0; ++ do { ++ n = *srcp; ++ if ((n & NS_CMPRSFLGS) != 0) { ++ return (-1); ++ } ++ l += n + 1; ++ if (l > MAXCDNAME) { ++ return (-1); ++ } ++ srcp += n + 1; ++ } while (n != 0); ++ ++ /* from here on we need to reset compression pointer array on error */ ++ srcp = src; ++ do { ++ /* Look to see if we can use pointers. */ ++ n = *srcp; ++ if (n != 0 && msg != NULL) { ++ l = dn_find(srcp, msg, (const u_char * const *)dnptrs, ++ (const u_char * const *)lpp); ++ if (l >= 0) { ++ if (dstp + 1 >= eob) { ++ goto cleanup; ++ } ++ *dstp++ = (l >> 8) | NS_CMPRSFLGS; ++ *dstp++ = l % 256; ++ return (dstp - dst); ++ } ++ /* Not found, save it. */ ++ if (lastdnptr != NULL && cpp < lastdnptr - 1 && ++ (dstp - msg) < 0x4000 && first) { ++ *cpp++ = dstp; ++ *cpp = NULL; ++ first = 0; ++ } ++ } ++ /* copy label to buffer */ ++ if (n & NS_CMPRSFLGS) { /* Should not happen. */ ++ goto cleanup; ++ } ++ if (dstp + 1 + n >= eob) { ++ goto cleanup; ++ } ++ memcpy(dstp, srcp, n + 1); ++ srcp += n + 1; ++ dstp += n + 1; ++ } while (n != 0); ++ ++ if (dstp > eob) { ++cleanup: ++ if (msg != NULL) ++ *lpp = NULL; ++ return (-1); ++ } ++ return (dstp - dst); ++} ++ ++/* ++ * ns_name_uncompress(msg, eom, src, dst, dstsiz) ++ * Expand compressed domain name to presentation format. ++ * return: ++ * Number of bytes read out of `src', or -1 (with errno set). ++ * note: ++ * Root domain returns as "." not "". ++ */ ++int ++ns_name_uncompress(const u_char *msg, const u_char *eom, const u_char *src, ++ char *dst, size_t dstsiz) ++{ ++ u_char tmp[NS_MAXCDNAME]; ++ int n; ++ ++ if ((n = ns_name_unpack(msg, eom, src, tmp, sizeof tmp)) == -1) ++ return (-1); ++ if (ns_name_ntop(tmp, dst, dstsiz) == -1) ++ return (-1); ++ return (n); ++} ++ ++/* ++ * ns_name_compress(src, dst, dstsiz, dnptrs, lastdnptr) ++ * Compress a domain name into wire format, using compression pointers. ++ * return: ++ * Number of bytes consumed in `dst' or -1 (with errno set). ++ * notes: ++ * 'dnptrs' is an array of pointers to previous compressed names. ++ * dnptrs[0] is a pointer to the beginning of the message. ++ * The list ends with NULL. 'lastdnptr' is a pointer to the end of the ++ * array pointed to by 'dnptrs'. Side effect is to update the list of ++ * pointers for labels inserted into the message as we compress the name. ++ * If 'dnptr' is NULL, we don't try to compress names. If 'lastdnptr' ++ * is NULL, we don't update the list. ++ */ ++int ++ns_name_compress(const char *src, u_char *dst, size_t dstsiz, ++ const u_char **dnptrs, const u_char **lastdnptr) ++{ ++ u_char tmp[NS_MAXCDNAME]; ++ ++ if (ns_name_pton(src, tmp, sizeof tmp) == -1) ++ return (-1); ++ return (ns_name_pack(tmp, dst, dstsiz, dnptrs, lastdnptr)); ++} ++ ++/* ++ * special(ch) ++ * Thinking in noninternationalized USASCII (per the DNS spec), ++ * is this characted special ("in need of quoting") ? ++ * return: ++ * boolean. ++ */ ++static int ++special(int ch) { ++ switch (ch) { ++ case 0x22: /* '"' */ ++ case 0x2E: /* '.' */ ++ case 0x3B: /* ';' */ ++ case 0x5C: /* '\\' */ ++ /* Special modifiers in zone files. */ ++ case 0x40: /* '@' */ ++ case 0x24: /* '$' */ ++ return (1); ++ default: ++ return (0); ++ } ++} ++ ++/* ++ * printable(ch) ++ * Thinking in noninternationalized USASCII (per the DNS spec), ++ * is this character visible and not a space when printed ? ++ * return: ++ * boolean. ++ */ ++static int ++printable(int ch) { ++ return (ch > 0x20 && ch < 0x7f); ++} ++ ++/* ++ * Thinking in noninternationalized USASCII (per the DNS spec), ++ * convert this character to lower case if it's upper case. ++ */ ++static int ++mklower(int ch) { ++ if (ch >= 0x41 && ch <= 0x5A) ++ return (ch + 0x20); ++ return (ch); ++} ++ ++/* ++ * dn_find(domain, msg, dnptrs, lastdnptr) ++ * Search for the counted-label name in an array of compressed names. ++ * return: ++ * offset from msg if found, or -1. ++ * notes: ++ * dnptrs is the pointer to the first name on the list, ++ * not the pointer to the start of the message. ++ */ ++static int ++dn_find(const u_char *domain, const u_char *msg, ++ const u_char * const *dnptrs, ++ const u_char * const *lastdnptr) ++{ ++ const u_char *dn, *cp, *sp; ++ const u_char * const *cpp; ++ u_int n; ++ ++ for (cpp = dnptrs; cpp < lastdnptr; cpp++) { ++ sp = *cpp; ++ /* ++ * terminate search on: ++ * root label ++ * compression pointer ++ * unusable offset ++ */ ++ while (*sp != 0 && (*sp & NS_CMPRSFLGS) == 0 && ++ (sp - msg) < 0x4000) { ++ dn = domain; ++ cp = sp; ++ while ((n = *cp++) != 0) { ++ /* ++ * check for indirection ++ */ ++ switch (n & NS_CMPRSFLGS) { ++ case 0: /* normal case, n == len */ ++ if (n != *dn++) ++ goto next; ++ for ((void)NULL; n > 0; n--) ++ if (mklower(*dn++) != ++ mklower(*cp++)) ++ goto next; ++ /* Is next root for both ? */ ++ if (*dn == '\0' && *cp == '\0') ++ return (sp - msg); ++ if (*dn) ++ continue; ++ goto next; ++ ++ case NS_CMPRSFLGS: /* indirection */ ++ cp = msg + (((n & 0x3f) << 8) | *cp); ++ break; ++ ++ default: /* illegal type */ ++ return (-1); ++ } ++ } ++ next: ++ sp += *sp + 1; ++ } ++ } ++ return (-1); ++} ++ ++/* ++ * Expand compressed domain name 'comp_dn' to full domain name. ++ * 'msg' is a pointer to the begining of the message, ++ * 'eomorig' points to the first location after the message, ++ * 'exp_dn' is a pointer to a buffer of size 'length' for the result. ++ * Return size of compressed name or -1 if there was an error. ++ */ ++int ++dn_expand(const u_char *msg, const u_char *eom, const u_char *src, ++ char *dst, int dstsiz) ++{ ++ int n = ns_name_uncompress(msg, eom, src, dst, (size_t)dstsiz); ++ ++ if (n > 0 && dst[0] == '.') ++ dst[0] = '\0'; ++ return (n); ++} ++ ++/* ++ * Pack domain name 'exp_dn' in presentation form into 'comp_dn'. ++ * Return the size of the compressed name or -1. ++ * 'length' is the size of the array pointed to by 'comp_dn'. ++ */ ++int ++dn_comp(const char *src, u_char *dst, int dstsiz, ++ u_char **dnptrs, u_char **lastdnptr) ++{ ++ return (ns_name_compress(src, dst, (size_t)dstsiz, ++ (const u_char **)dnptrs, ++ (const u_char **)lastdnptr)); ++} ++ +diff -Nur dsniff-2.3/Makefile.in dsniff-2.3.patched/Makefile.in +--- dsniff-2.3/Makefile.in 2000-12-15 21:03:26.000000000 +0100 ++++ dsniff-2.3.patched/Makefile.in 2005-06-09 14:03:18.000000000 +0200 +@@ -51,7 +51,7 @@ + pathnames.h pcaputil.h record.h rpc.h tcp_raw.h trigger.h \ + version.h vroot.h + +-SRCS = asn1.c base64.c buf.c hex.c magic.c mount.c pcaputil.c rpc.c \ ++SRCS = asn1.c base64.c buf.c dns.c hex.c magic.c mount.c pcaputil.c rpc.c \ + tcp_raw.c trigger.c record.c dsniff.c decode.c decode_aim.c \ + decode_citrix.c decode_cvs.c decode_ftp.c decode_hex.c \ + decode_http.c decode_icq.c decode_imap.c decode_irc.c \ +@@ -99,8 +99,8 @@ + arpspoof: arpspoof.o arp.o + $(CC) $(LDFLAGS) -o $@ arpspoof.o arp.o $(LIBS) $(PCAPLIB) $(LNETLIB) + +-dnsspoof: dnsspoof.o pcaputil.o +- $(CC) $(LDFLAGS) -o $@ dnsspoof.o pcaputil.o $(LIBS) $(PCAPLIB) $(LNETLIB) ++dnsspoof: dnsspoof.o pcaputil.o dns.o ++ $(CC) $(LDFLAGS) -o $@ dnsspoof.o pcaputil.o dns.o $(LIBS) $(PCAPLIB) $(LNETLIB) + + filesnarf: nfs_prot.o filesnarf.o pcaputil.o rpc.o + $(CC) $(LDFLAGS) -o $@ filesnarf.o nfs_prot.o pcaputil.o rpc.o $(LIBS) $(NIDSLIB) $(PCAPLIB) $(LNETLIB) diff --git a/package/dsniff/patches/gdbm.patch b/package/dsniff/patches/gdbm.patch new file mode 100644 index 000000000..2d9256aae --- /dev/null +++ b/package/dsniff/patches/gdbm.patch @@ -0,0 +1,188 @@ +diff -Nur dsniff-2.3/configure dsniff-2.3.patched/configure +--- dsniff-2.3/configure 2005-06-09 15:21:49.000000000 +0200 ++++ dsniff-2.3.patched/configure 2005-06-09 15:26:41.000000000 +0200 +@@ -3051,7 +3051,40 @@ + + fi + ++echo $ac_n "checking for libgdbm""... $ac_c" 1>&6 ++echo "configure:3059: checking for libgdbm" >&5 ++# Check whether --with-gdbm or --without-gdbm was given. ++if test "${with_gdbm+set}" = set; then ++ withval="$with_gdbm" ++ case "$withval" in ++ yes|no) ++ echo "$ac_t""no" 1>&6 ++ ;; ++ *) ++ echo "$ac_t""$withval" 1>&6 ++ if test -f $withval/include/gdbm.h -a -f $withval/lib/libgdbm.a; then ++ owd=`pwd` ++ if cd $withval; then withval=`pwd`; cd $owd; fi ++ DBINC="-I$withval/include" ++ DBLIB="-L$withval/lib -lgdbm" ++ else ++ { echo "configure: error: gdbm.h or libgdbm.a not found in $withval" 1>&2; exit 1; } ++ fi ++ ;; ++ esac ++else ++ if test -f ${prefix}/include/gdbm.h; then ++ LNETINC="-I${prefix}/include" ++ LNETLIB="-L${prefix}/lib -lgdbm" ++ elif test -f /usr/include/gdbm.h; then ++ LNETLIB="-lgdbm" ++ else ++ echo "$ac_t""no" 1>&6 ++ { echo "configure: error: libgdbm not found" 1>&2; exit 1; } ++ fi ++ echo "$ac_t""yes" 1>&6 + ++fi + + + echo $ac_n "checking for libnet""... $ac_c" 1>&6 +diff -Nur dsniff-2.3/configure dsniff-2.3.patched/configure +--- dsniff-2.3/configure 2005-06-09 15:17:11.000000000 +0200 ++++ dsniff-2.3.patched/configure 2005-06-09 14:47:24.000000000 +0200 +@@ -16,6 +16,8 @@ + ac_help="$ac_help + --with-db=DIR use Berkeley DB (with --enable-compat185) in DIR" + ac_help="$ac_help ++ --with-gdbm=DIR use GNU DBM in DIR" ++ac_help="$ac_help + --with-libpcap=DIR use libpcap in DIR" + ac_help="$ac_help + --with-libnet=DIR use libnet in DIR" +diff -Nur dsniff-2.3/record.c dsniff-2.3.patched/record.c +--- dsniff-2.3/record.c 2000-11-14 16:51:02.000000000 +0100 ++++ dsniff-2.3.patched/record.c 2005-06-09 15:16:50.000000000 +0200 +@@ -13,12 +13,7 @@ + #include + #include + #include +-#ifdef HAVE_DB_185_H +-#define DB_LIBRARY_COMPATIBILITY_API +-#include +-#elif HAVE_DB_H +-#include +-#endif ++#include + #include + #include "options.h" + #include "record.h" +@@ -34,7 +29,7 @@ + struct netobj data; + }; + +-static DB *db; ++GDBM_FILE dbf; + + static int + xdr_rec(XDR *xdrs, struct rec *rec) +@@ -86,10 +81,10 @@ + fflush(stdout); + } + +-static DBT * ++static datum + record_hash(struct rec *rec) + { +- static DBT key; ++ static datum key; + static u_char hash[16]; + MD5_CTX ctx; + +@@ -102,16 +97,16 @@ + MD5Update(&ctx, rec->data.n_bytes, rec->data.n_len); + MD5Final(hash, &ctx); + +- key.data = hash; +- key.size = sizeof(hash); ++ key.dptr = hash; ++ key.dsize = sizeof(hash); + +- return (&key); ++ return (key); + } + + static int + record_save(struct rec *rec) + { +- DBT *key, data; ++ datum key, data; + XDR xdrs; + u_char buf[2048]; + +@@ -120,15 +115,15 @@ + if (!xdr_rec(&xdrs, rec)) + return (0); + +- data.data = buf; +- data.size = xdr_getpos(&xdrs); ++ data.dptr = buf; ++ data.dsize = xdr_getpos(&xdrs); + + xdr_destroy(&xdrs); + + key = record_hash(rec); + +- if (db->put(db, key, &data, R_NOOVERWRITE) == 0) +- db->sync(db, 0); ++ if (gdbm_store(dbf, key, data, GDBM_INSERT) == 0) ++ gdbm_sync(dbf); + + return (1); + } +@@ -136,18 +131,22 @@ + void + record_dump(void) + { +- DBT key, data; ++ datum nextkey, data; + XDR xdrs; + struct rec rec; + +- while (db->seq(db, &key, &data, R_NEXT) == 0) { ++ data = gdbm_firstkey ( dbf ); ++ while (data.dptr) { ++ nextkey = gdbm_nextkey ( dbf, data ); + memset(&rec, 0, sizeof(rec)); +- xdrmem_create(&xdrs, data.data, data.size, XDR_DECODE); ++ xdrmem_create(&xdrs, data.dptr, data.dsize, XDR_DECODE); + + if (xdr_rec(&xdrs, &rec)) { + record_print(&rec); + } + xdr_destroy(&xdrs); ++ free(data.dptr); ++ data = nextkey; + } + } + +@@ -157,14 +156,14 @@ + int flags, mode; + + if (Opt_read) { +- flags = O_RDONLY; ++ flags = GDBM_READER; + mode = 0; + } + else { +- flags = O_RDWR|O_CREAT; ++ flags = GDBM_WRCREAT; + mode = S_IRUSR|S_IWUSR; + } +- if ((db = dbopen(file, flags, mode, DB_BTREE, NULL)) == NULL) ++ if ((dbf = gdbm_open(file, 1024, flags, mode, NULL)) == NULL) + return (0); + + return (1); +@@ -203,6 +202,6 @@ + void + record_close(void) + { +- db->close(db); ++ gdbm_close(dbf); + } + diff --git a/package/dsniff/patches/noyp.patch b/package/dsniff/patches/noyp.patch new file mode 100644 index 000000000..47dda9515 --- /dev/null +++ b/package/dsniff/patches/noyp.patch @@ -0,0 +1,33 @@ +diff -Nur dsniff-2.3/decode.c dsniff-2.3.patched/decode.c +--- dsniff-2.3/decode.c 2000-12-15 21:03:26.000000000 +0100 ++++ dsniff-2.3.patched/decode.c 2005-06-09 15:20:16.000000000 +0200 +@@ -49,8 +49,6 @@ + extern int decode_portmap(u_char *, int, u_char *, int); + extern int decode_mountd(u_char *, int, u_char *, int); + extern int decode_vrrp(u_char *, int, u_char *, int); +-extern int decode_ypserv(u_char *, int, u_char *, int); +-extern int decode_yppasswd(u_char *, int, u_char *, int); + + static struct decode decodes[] = { + { "hex", decode_hex }, +@@ -86,8 +84,6 @@ + { "irc", decode_irc }, + { "portmap", decode_portmap }, + { "mountd", decode_mountd }, +- { "ypserv", decode_ypserv }, +- { "yppasswd", decode_yppasswd }, + { NULL } + }; + +diff -Nur dsniff-2.3/Makefile.in dsniff-2.3.patched/Makefile.in +--- dsniff-2.3/Makefile.in 2005-06-09 15:20:41.000000000 +0200 ++++ dsniff-2.3.patched/Makefile.in 2005-06-09 15:18:51.000000000 +0200 +@@ -60,7 +60,7 @@ + decode_pop.c decode_portmap.c decode_postgresql.c decode_pptp.c \ + decode_rip.c decode_rlogin.c decode_smb.c decode_smtp.c \ + decode_sniffer.c decode_snmp.c decode_socks.c decode_tds.c \ +- decode_telnet.c decode_vrrp.c decode_yp.c decode_x11.c ++ decode_telnet.c decode_vrrp.c decode_x11.c + + GEN = mount.h mount.c nfs_prot.h nfs_prot.c + diff --git a/package/dsniff/patches/pcap-header.patch b/package/dsniff/patches/pcap-header.patch new file mode 100644 index 000000000..6be3bf2d6 --- /dev/null +++ b/package/dsniff/patches/pcap-header.patch @@ -0,0 +1,12 @@ +diff -Nur dsniff-2.3/configure dsniff-2.3.patched/configure +--- dsniff-2.3/configure 2000-12-03 05:35:46.000000000 +0100 ++++ dsniff-2.3.patched/configure 2005-06-09 11:44:33.000000000 +0200 +@@ -3023,7 +3023,7 @@ + PCAPINC="-I$withval -I$withval/bpf" + PCAPLIB="-L$withval -lpcap" + elif test -f $withval/include/pcap.h -a \ +- -f $withval/include/net/bpf.h -a \ ++ -f $withval/include/pcap-bpf.h -a \ + -f $withval/lib/libpcap.a; then + owd=`pwd` + if cd $withval; then withval=`pwd`; cd $owd; fi -- cgit v1.2.3