add files

Author: iphelix

CHANGELOG

@@ -0,0 +1,14 @@
+Version 0.2.1
+* Fixed a Python 2.6 compatibility issue. (thanks Mehran Goudarzi)
+
+Version 0.2
+
+Changes
+* Added IPv6 support.
+* Added AAAA, MX, CNAME, NS, SOA and NAPTR support.
+* Added support for ANY queries (returns all known fake records).
+* Changed file format to support more DNS record types.
+* Added alternative DNS port support (contributed by fnv).
+* Added alternative listening port support for the server (contributed by Mark Straver).
+* Updated bundled dnslib library to the latest version - 0.8.2.
+* Included IPy library for IPv6 support.

LICENSE

@@ -0,0 +1,22 @@
+Copyright (C) 2013 Peter Kacherginsky
+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. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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.

README

@@ -0,0 +1 @@
+[*] Run in MiTM mode and inject fake DNS responses.

TODO

@@ -0,0 +1,26 @@
+[A]     # Queries for IPv4 address records
+*.thesprawl.org=192.0.2.1
+
+[AAAA]  # Queries for IPv6 address records
+*.thesprawl.org=2001:db8::1
+
+[MX]    # Queries for mail server records
+*.thesprawl.org=mail.fake.com
+
+[NS]    # Queries for mail server records
+*.thesprawl.org=ns.fake.com
+
+[CNAME] # Queries for alias records
+*.thesprawl.org=www.fake.com
+
+[TXT]   # Queries for text records
+*.thesprawl.org=fake message
+
+[PTR]
+*.2.0.192.in-addr.arpa=fake.com
+
+[SOA]
+*.thesprawl.org=ns.fake.com. hostmaster.fake.com. 1 10800 3600 604800 3600
+
+[NAPTR]
+*.thesprawl.org=100 10 U E2U+sip !^.*$!sip:[email protected]! .

dnschef.ini

@@ -0,0 +1,2 @@
+
+from dns import *

dnschef.py

@@ -0,0 +1,45 @@
+
+class Bimap(object):
+
+    """
+
+    A simple bi-directional map which returns either forward or
+    reverse lookup of key through explicit 'lookup' method or 
+    through __getattr__ or __getitem__. If the key is not found
+    in either the forward/reverse dictionaries it is returned.
+
+    >>> m = Bimap({1:'a',2:'b',3:'c'})
+    >>> m[1]
+    'a'
+    >>> m.lookup('a')
+    1
+    >>> m.a
+    1
+
+    """
+
+    def __init__(self,forward):
+        self.forward = forward
+        self.reverse = dict([(v,k) for (k,v) in forward.items()])
+
+    def lookup(self,k,default=None):
+        try:
+            try:
+                return self.forward[k]
+            except KeyError:
+                return self.reverse[k]
+        except KeyError:
+            if default:
+                return default
+            else:
+                raise
+    
+    def __getitem__(self,k):
+        return self.lookup(k,k)
+
+    def __getattr__(self,k):
+        return self.lookup(k,k)
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()

lib/IPy.py

@@ -0,0 +1,76 @@
+
+"""
+    Some basic bit mainpulation utilities
+"""
+
+FILTER=''.join([(len(repr(chr(x)))==3) and chr(x) or '.' for x in range(256)])
+
+def hexdump(src, length=16, prefix=''):
+    """
+        Print hexdump of string
+
+        >>> print hexdump("abcd\x00" * 4)
+        0000  61 62 63 64 00 61 62 63  64 00 61 62 63 64 00 61  abcd.abc d.abcd.a
+        0010  62 63 64 00                                       bcd. 
+    """
+    n = 0
+    left = length / 2 
+    right = length - left
+    result= []
+    while src:
+        s,src = src[:length],src[length:]
+        l,r = s[:left],s[left:]
+        hexa = "%-*s" % (left*3,' '.join(["%02x"%ord(x) for x in l]))
+        hexb = "%-*s" % (right*3,' '.join(["%02x"%ord(x) for x in r]))
+        lf = l.translate(FILTER)
+        rf = r.translate(FILTER)
+        result.append("%s%04x  %s %s %s %s" % (prefix, n, hexa, hexb, lf, rf))
+        n += length
+    return "\n".join(result)
+
+def get_bits(data,offset,bits=1):
+    """
+        Get specified bits from integer
+
+        >>> bin(get_bits(0b0011100,2)
+        0b1
+        >>> bin(get_bits(0b0011100,0,4))
+        0b1100
+        
+    """
+    mask = ((1 << bits) - 1) << offset
+    return (data & mask) >> offset 
+
+def set_bits(data,value,offset,bits=1):
+    """
+        Set specified bits in integer
+
+        >>> bin(set_bits(0,0b1010,0,4))
+        0b1010
+        >>> bin(set_bits(0,0b1010,3,4))
+        0b1010000
+    """
+    mask = ((1 << bits) - 1) << offset
+    clear = 0xffff ^ mask
+    data = (data & clear) | ((value << offset) & mask)
+    return data
+
+def binary(n,count=16,reverse=False):
+    """
+        Display n in binary (only difference from built-in `bin` is
+        that this function returns a fixed width string and can
+        optionally be reversed
+
+        >>> binary(6789)
+        0001101010000101
+        >>> binary(6789,8)
+        10000101
+        >>> binary(6789,reverse=True)
+        1010000101011000
+
+    """
+    bits = [str((n >> y) & 1) for y in range(count-1, -1, -1)]
+    if reverse:
+        bits.reverse()
+    return "".join(bits)
+

lib/__init__.py

@@ -0,0 +1,81 @@
+
+import struct
+
+class Buffer(object):
+
+    """
+    A simple data buffer - supports packing/unpacking in struct format 
+
+    >>> b = Buffer()
+    >>> b.pack("!BHI",1,2,3)
+    >>> b.offset
+    7
+    >>> b.append("0123456789")
+    >>> b.offset
+    17
+    >>> b.offset = 0
+    >>> b.unpack("!BHI")
+    (1, 2, 3)
+    >>> b.get(5)
+    '01234'
+    >>> b.get(5)
+    '56789'
+    >>> b.update(7,"2s","xx")
+    >>> b.offset = 7
+    >>> b.get(5)
+    'xx234'
+    """
+
+    def __init__(self,data=""):
+        """
+            Initialise Buffer from data
+        """
+        self.data = data
+        self.offset = 0
+
+    def remaining(self):
+        """
+            Return bytes remaining
+        """
+        return len(self.data) - self.offset
+
+    def get(self,len):
+        """
+            Gen len bytes at current offset (& increment offset)
+        """
+        start = self.offset
+        end = self.offset + len
+        self.offset += len
+        return self.data[start:end]
+
+    def pack(self,fmt,*args):
+        """
+            Pack data at end of data according to fmt (from struct) & increment
+            offset
+        """
+        self.offset += struct.calcsize(fmt)
+        self.data += struct.pack(fmt,*args)
+
+    def append(self,s):
+        """
+            Append s to end of data & increment offset
+        """
+        self.offset += len(s)
+        self.data += s
+
+    def update(self,ptr,fmt,*args):
+        """
+            Modify data at offset `ptr` 
+        """
+        s = struct.pack(fmt,*args)
+        self.data = self.data[:ptr] + s + self.data[ptr+len(s):]
+
+    def unpack(self,fmt):
+        """
+            Unpack data at current offset according to fmt (from struct)
+        """
+        return struct.unpack(fmt,self.get(struct.calcsize(fmt)))
+
+if __name__ == '__main__':
+    import doctest
+    doctest.testmod()