diff options
| author |   Hanoh Haim <hhaim@cisco.com> | 2016-03-21 12:55:16 +0200 |
|---|---|---|
| committer | Hanoh Haim <hhaim@cisco.com> | 2016-03-21 12:55:16 +0200 |
| commit | 1831e9bbc03484b078dbd604dfec0e025cea8eca (patch) | |
| tree | 96ffe76ee50a29f8eea36ada1cc21738de09bcb7 /scripts | |
| parent | 33c80d0f2c3af8b302e50ce3925869dfd37267ed (diff) | |
scapy 3-0.18 with trex client diff
Diffstat (limited to 'scripts')
116 files changed, 50933 insertions, 0 deletions
diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/__init__.py new file mode 100644 index 00000000..443b3675 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/__init__.py @@ -0,0 +1,15 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Scapy: create, send, sniff, dissect and manipulate network packets. + +Usable either from an interactive console or as a Python library. +http://www.secdev.org/projects/scapy +""" + +if __name__ == "__main__": + from scapy.main import interact + interact() diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/abc.py b/scripts/external_libs/scapy-python3-0.18/scapy/abc.py new file mode 100644 index 00000000..3d5f06e2 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/abc.py @@ -0,0 +1 @@ +from config import conf diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/all.py b/scripts/external_libs/scapy-python3-0.18/scapy/all.py new file mode 100644 index 00000000..46030c66 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/all.py @@ -0,0 +1,49 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Aggregate top level objects from all Scapy modules. +""" + +from .config import * +from .base_classes import * +from .dadict import * +from .data import * +from .error import * +#from .themes import * +from .arch import * + +from .plist import * +from .fields import * +from .packet import * +#from .asn1fields import * +#from .asn1packet import * + +from .utils import * +#from .route import * +#if conf.ipv6_enabled: +# from .utils6 import * +# from .route6 import * +#from .sendrecv import * +#from .supersocket import * +#from .volatile import * +#from .as_resolvers import * + +#from .ansmachine import * +#from .automaton import * +#from .autorun import * + +from .main import * + +from .layers.all import * + +#from .asn1.asn1 import * +#from .asn1.ber import * +#from .asn1.mib import * + +#from .crypto import * + +#from .pipetool import * +#from .scapypipes import * diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/ansmachine.py b/scripts/external_libs/scapy-python3-0.18/scapy/ansmachine.py new file mode 100644 index 00000000..b087ac44 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/ansmachine.py @@ -0,0 +1,130 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Answering machines. +""" + +######################## +## Answering machines ## +######################## + +from .sendrecv import send,sendp,sniff +from .config import conf +from .error import log_interactive + +class ReferenceAM(type): + def __new__(cls, name, bases, dct): + o = super(ReferenceAM, cls).__new__(cls, name, bases, dct) + if o.function_name: + globals()[o.function_name] = lambda o=o,*args,**kargs: o(*args,**kargs)() + return o + + +class AnsweringMachine(object): + __metaclass__ = ReferenceAM + function_name = "" + filter = None + sniff_options = { "store":0 } + sniff_options_list = [ "store", "iface", "count", "promisc", "filter", "type", "prn", "stop_filter" ] + send_options = { "verbose":0 } + send_options_list = ["iface", "inter", "loop", "verbose"] + send_function = staticmethod(send) + + + def __init__(self, **kargs): + self.mode = 0 + if self.filter: + kargs.setdefault("filter",self.filter) + kargs.setdefault("prn", self.reply) + self.optam1 = {} + self.optam2 = {} + self.optam0 = {} + doptsend,doptsniff = self.parse_all_options(1, kargs) + self.defoptsend = self.send_options.copy() + self.defoptsend.update(doptsend) + self.defoptsniff = self.sniff_options.copy() + self.defoptsniff.update(doptsniff) + self.optsend,self.optsniff = [{},{}] + + def __getattr__(self, attr): + for d in [self.optam2, self.optam1]: + if attr in d: + return d[attr] + raise AttributeError(attr) + + def __setattr__(self, attr, val): + mode = self.__dict__.get("mode",0) + if mode == 0: + self.__dict__[attr] = val + else: + [self.optam1, self.optam2][mode-1][attr] = val + + def parse_options(self): + pass + + def parse_all_options(self, mode, kargs): + sniffopt = {} + sendopt = {} + for k in list(kargs): + if k in self.sniff_options_list: + sniffopt[k] = kargs[k] + if k in self.send_options_list: + sendopt[k] = kargs[k] + if k in self.sniff_options_list+self.send_options_list: + del(kargs[k]) + if mode != 2 or kargs: + if mode == 1: + self.optam0 = kargs + elif mode == 2 and kargs: + k = self.optam0.copy() + k.update(kargs) + self.parse_options(**k) + kargs = k + omode = self.__dict__.get("mode",0) + self.__dict__["mode"] = mode + self.parse_options(**kargs) + self.__dict__["mode"] = omode + return sendopt,sniffopt + + def is_request(self, req): + return 1 + + def make_reply(self, req): + return req + + def send_reply(self, reply): + self.send_function(reply, **self.optsend) + + def print_reply(self, req, reply): + print("%s ==> %s" % (req.summary(),reply.summary())) + + def reply(self, pkt): + if not self.is_request(pkt): + return + reply = self.make_reply(pkt) + self.send_reply(reply) + if conf.verb >= 0: + self.print_reply(pkt, reply) + + def run(self, *args, **kargs): + log_interactive.warning("run() method deprecated. The intance is now callable") + self(*args,**kargs) + + def __call__(self, *args, **kargs): + optsend,optsniff = self.parse_all_options(2,kargs) + self.optsend=self.defoptsend.copy() + self.optsend.update(optsend) + self.optsniff=self.defoptsniff.copy() + self.optsniff.update(optsniff) + + try: + self.sniff() + except KeyboardInterrupt: + print("Interrupted by user") + + def sniff(self): + sniff(**self.optsniff) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/__init__.py new file mode 100644 index 00000000..0066e049 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/__init__.py @@ -0,0 +1,108 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Operating system specific functionality. +""" + + +import sys,os,socket +from scapy.error import * +import scapy.config + +try: + import matplotlib.pyplot as plt + MATPLOTLIB = True + if scapy.config.conf.interactive: + plt.ion() +except ImportError: + log_loading.info("Can't import matplotlib. Not critical, but won't be able to plot.") + MATPLOTLIB = False + +try: + import networkx as nx + NETWORKX = True +except ImportError: + log_loading.info("Can't import networkx. Not criticial, but won't be able to draw network graphs.") + NETWORKX = False + +try: + import pyx + PYX=1 +except ImportError: + log_loading.info("Can't import PyX. Won't be able to use psdump() or pdfdump().") + PYX=0 + + +def str2mac(s): + #return ("%02x:"*6)[:-1] % tuple(map(ord, s)) + return ("%02x:"*6)[:-1] % tuple(s) + + + +def get_if_addr(iff): + return socket.inet_ntoa(get_if_raw_addr(iff)) + +def get_if_hwaddr(iff): + mac = get_if_raw_hwaddr(iff) + return str2mac(mac) + + +LINUX=sys.platform.startswith("linux") +OPENBSD=sys.platform.startswith("openbsd") +FREEBSD=sys.platform.startswith("freebsd") +NETBSD = sys.platform.startswith("netbsd") +DARWIN=sys.platform.startswith("darwin") +SOLARIS=sys.platform.startswith("sunos") +WINDOWS=sys.platform.startswith("win32") + +X86_64 = not WINDOWS and (os.uname()[4] == 'x86_64') + +#if WINDOWS: +# log_loading.warning("Windows support for scapy3k is currently in testing. Sniffing/sending/receiving packets should be working with WinPcap driver and Powershell. Create issues at https://github.com/phaethon/scapy") + +# Next step is to import following architecture specific functions: +# def get_if_raw_hwaddr(iff) +# def get_if_raw_addr(iff): +# def get_if_list(): +# def get_working_if(): +# def attach_filter(s, filter): +# def set_promisc(s,iff,val=1): +# def read_routes(): +# def get_if(iff,cmd): +# def get_if_index(iff): + + + +if LINUX: + from .linux import * + if scapy.config.conf.use_winpcapy or scapy.config.conf.use_netifaces: + from pcapdnet import * +elif OPENBSD or FREEBSD or NETBSD or DARWIN: + from .bsd import * +elif SOLARIS: + from .solaris import * +elif WINDOWS: + pass; + #from .windows import * + +LOOPBACK_NAME="a" + +if scapy.config.conf.iface is None: + scapy.config.conf.iface = LOOPBACK_NAME + +def get_if_raw_addr6(iff): + """ + Returns the main global unicast address associated with provided + interface, in network format. If no global address is found, None + is returned. + """ + #r = filter(lambda x: x[2] == iff and x[1] == IPV6_ADDR_GLOBAL, in6_getifaddr()) + r = [ x for x in in6_getifaddr() if x[2] == iff and x[1] == IPV6_ADDR_GLOBAL] + if len(r) == 0: + return None + else: + r = r[0][0] + return inet_pton(socket.AF_INET6, r) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/bsd.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/bsd.py new file mode 100644 index 00000000..c4220308 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/bsd.py @@ -0,0 +1,12 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Support for BSD-like operating systems such as FreeBSD, OpenBSD and Mac OS X. +""" + +LOOPBACK_NAME="lo0" + +from .unix import * diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/cdnet.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/cdnet.py new file mode 100644 index 00000000..98ebf084 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/cdnet.py @@ -0,0 +1,229 @@ +from ctypes import * +from ctypes.util import find_library +import sys + +WIN=False + +if sys.platform.startswith('win'): + WIN=True + +if WIN: + SOCKET = c_uint + _lib=CDLL('dnet') +else: + SOCKET = c_int + _lib_name = find_library('dnet') + if not _lib_name: + raise OSError("Cannot find libdnet.so") + _lib=CDLL(_lib_name) + +ETH_ADDR_LEN = 6 +INTF_NAME_LEN = 16 +INTF_NAME_COUNT = 20 +INTF_ALIAS_COUNT = 20 +IP6_ADDR_LEN = 16 + +ADDR_TYPE_NONE = 0 +ADDR_TYPE_ETH = 1 +ADDR_TYPE_IP = 2 +ADDR_TYPE_IP6 = 3 + +INTF_TYPE_OTHER = 1 +INTF_TYPE_ETH = 6 +INTF_TYPE_TOKENRING = 9 +INTF_TYPE_FDDI = 15 +INTF_TYPE_PPP = 23 +INTF_TYPE_LOOPBACK = 24 +INTF_TYPE_SLIP = 28 +INTF_TYPE_TUN = 53 + + +uint8_t = c_ubyte +uint16_t = c_ushort +uint32_t = c_uint +ssize_t = c_long +dnet_ip_addr_t = uint32_t + +dnet_intf_name = c_char * INTF_NAME_LEN + +class dnet_intf_list(Structure): + pass + +dnet_intf_list._fields_ = [ ('length', c_int), + ('interfaces', dnet_intf_name * 20) ] + +class dnet_eth_addr(Structure): + pass + +dnet_eth_addr._fields_ = [ ('data', uint8_t * ETH_ADDR_LEN) ] +dnet_eth_addr_t = dnet_eth_addr + +class dnet_ip6_addr(Structure): + pass + +dnet_ip6_addr._fields_ = [ ('data', uint8_t * IP6_ADDR_LEN) ] +dnet_ip6_addr_t = dnet_ip6_addr + +class dnet_addr_u(Union): + pass + +dnet_addr_u._fields_ = [ ('eth', dnet_eth_addr_t), + ('ip', dnet_ip_addr_t), + ('ip6', dnet_ip6_addr_t), + ('data8', uint8_t * 16), + ('data16', uint16_t * 8), + ('data32', uint32_t * 4) ] + +class dnet_addr(Structure): + pass +dnet_addr._anonymous_ = ('__addr_u', ) +dnet_addr._fields_ = [ ('addr_type', uint16_t), + ('addr_bits', uint16_t), + ('__addr_u', dnet_addr_u) ] + +class dnet_intf_entry(Structure): + pass + +dnet_intf_entry._fields_ = [ ('intf_len', c_uint), + ('intf_name', c_char * INTF_NAME_LEN), + ('intf_type', c_ushort), + ('intf_flags', c_ushort), + ('intf_mtu', c_uint), + ('intf_addr', dnet_addr), + ('intf_dst_addr', dnet_addr), + ('intf_link_addr', dnet_addr), + ('intf_alias_num', c_uint), + ('intf_alias_addrs', dnet_addr * INTF_ALIAS_COUNT) ] + + +eth_t = c_void_p +intf_t = c_void_p +ip_t = c_void_p +dnet_intf_handler = CFUNCTYPE(c_int, POINTER(dnet_intf_entry), POINTER(c_void_p)) + +dnet_eth_open = _lib.eth_open +dnet_eth_open.restype = POINTER(eth_t) +dnet_eth_open.argtypes = [ POINTER(c_char) ] + +dnet_eth_get = _lib.eth_get +dnet_eth_get.restype = c_int +dnet_eth_get.argtypes = [ POINTER(eth_t), POINTER(dnet_eth_addr_t) ] + +dnet_eth_set = _lib.eth_set +dnet_eth_set.restype = c_int +dnet_eth_set.argtypes = [ POINTER(eth_t), POINTER(dnet_eth_addr_t) ] + +dnet_eth_send = _lib.eth_send +dnet_eth_send.restype = ssize_t +dnet_eth_send.argtypes = [ POINTER(eth_t), c_void_p, c_size_t ] + +dnet_eth_close = _lib.eth_close +dnet_eth_close.restype = POINTER(eth_t) +dnet_eth_close.argtypes = [ POINTER(eth_t) ] + +dnet_intf_open = _lib.intf_open +dnet_intf_open.restype = POINTER(intf_t) +dnet_intf_open.argtypes = [ ] + +dnet_intf_get = _lib.intf_get +dnet_intf_get.restype = c_int +dnet_intf_get.argtypes = [ POINTER(intf_t), POINTER(dnet_intf_entry) ] + +dnet_intf_get_src = _lib.intf_get_src +dnet_intf_get_src.restype = c_int +dnet_intf_get_src.argtypes = [ POINTER(intf_t), POINTER(dnet_intf_entry), POINTER(dnet_addr) ] + +dnet_intf_get_dst = _lib.intf_get_dst +dnet_intf_get_dst.restype = c_int +dnet_intf_get_dst.argtypes = [ POINTER(intf_t), POINTER(dnet_intf_entry), POINTER(dnet_addr) ] + +dnet_intf_set = _lib.intf_set +dnet_intf_set.restype = c_int +dnet_intf_set.argtypes = [ POINTER(intf_t), POINTER(dnet_intf_entry) ] + +dnet_intf_loop = _lib.intf_loop +dnet_intf_loop.restype = POINTER(intf_t) +dnet_intf_loop.argtypes = [ POINTER(intf_t), dnet_intf_handler, c_void_p ] + +dnet_intf_close = _lib.intf_close +dnet_intf_close.restype = POINTER(intf_t) +dnet_intf_close.argtypes = [ POINTER(intf_t) ] + +dnet_ip_open = _lib.ip_open +dnet_ip_open.restype = POINTER(ip_t) +dnet_ip_open.argtypes = [ ] + +dnet_ip_add_option = _lib.ip_add_option +dnet_ip_add_option.restype = ssize_t +dnet_ip_add_option.argtypes = [ POINTER(c_void_p), c_size_t, c_int, POINTER(c_void_p), c_size_t ] + +dnet_ip_checksum = _lib.ip_checksum +dnet_ip_checksum.restype = None +dnet_ip_checksum.argtypes = [ POINTER(c_void_p), c_size_t ] + +dnet_ip_send = _lib.ip_send +dnet_ip_send.restype = ssize_t +dnet_ip_send.argtypes = [ POINTER(ip_t), c_void_p, c_size_t ] + +dnet_ip_close = _lib.ip_close +dnet_ip_close.restype = POINTER(ip_t) +dnet_ip_close.argtypes = [ POINTER(ip_t) ] + +class dnet_eth: + def __init__(self, iface): + self.iface_b = create_string_buffer(iface.encode('ascii')) + self.eth = dnet_eth_open(self.iface_b) + def send(self, sx): + dnet_eth_send(self.eth, sx, len(sx)) + def close(self): + return dnet_eth_close(self.eth) + +class dnet_ip: + def __init__(self): + self.ip = dnet_ip_open() + def send(self, sx): + dnet_ip_send(self.ip, sx, len(sx)) + def close(self): + return dnet_ip_close(self.ip) + +def dnet_intf_name_loop(entry, intf_list): + l = cast(intf_list, POINTER(dnet_intf_list)) + if l.contents.length >= INTF_NAME_COUNT: + return -1 + for i in enumerate(entry.contents.intf_name): + l.contents.interfaces[l.contents.length][i[0]] = i[1] + l.contents.length += 1 + return 0 + +class dnet_intf: + def __init__(self): + self.intf = dnet_intf_open() + intf_list = dnet_intf_list() + intf_list.length = 0 + dnet_intf_loop(self.intf, dnet_intf_handler(dnet_intf_name_loop), pointer(intf_list)) + self.names = [] + for i in range(INTF_NAME_COUNT): + if i >= intf_list.length: + break + self.names.append(intf_list.interfaces[i].value.decode('ascii').strip('\0')) + + def close(self): + return dnet_intf_close(self.intf) + + def get(self, iface): + ret = {} + entry = dnet_intf_entry() + entry.intf_name = iface.encode('ascii') + entry.intf_len = sizeof(entry) + r = dnet_intf_get(self.intf, byref(entry)) + if r < 0: + return {} + ret['addr6'] = [] + for i in range(entry.intf_alias_num): + if entry.intf_alias_addrs[i].addr_type == ADDR_TYPE_IP6: + ret['addr6'].append(bytes(entry.intf_alias_addrs[i].data8[:16])) + ret['type'] = entry.intf_type + ret['addr'] = bytes(entry.intf_addr.data8[:4]) + ret['link_addr'] = bytes(entry.intf_link_addr.data8[:6]) + return ret + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/linux.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/linux.py new file mode 100644 index 00000000..3eab16c6 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/linux.py @@ -0,0 +1,530 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Linux specific functions. +""" + +import sys,os,struct,socket,time,ctypes +from select import select +from fcntl import ioctl +import scapy.utils +import scapy.utils6 +from scapy.config import conf +from scapy.data import * +from scapy.supersocket import SuperSocket +import scapy.arch +from scapy.error import warning, Scapy_Exception + + + +# From bits/ioctls.h +SIOCGIFHWADDR = 0x8927 # Get hardware address +SIOCGIFADDR = 0x8915 # get PA address +SIOCGIFNETMASK = 0x891b # get network PA mask +SIOCGIFNAME = 0x8910 # get iface name +SIOCSIFLINK = 0x8911 # set iface channel +SIOCGIFCONF = 0x8912 # get iface list +SIOCGIFFLAGS = 0x8913 # get flags +SIOCSIFFLAGS = 0x8914 # set flags +SIOCGIFINDEX = 0x8933 # name -> if_index mapping +SIOCGIFCOUNT = 0x8938 # get number of devices +SIOCGSTAMP = 0x8906 # get packet timestamp (as a timeval) + +# From if.h +IFF_UP = 0x1 # Interface is up. +IFF_BROADCAST = 0x2 # Broadcast address valid. +IFF_DEBUG = 0x4 # Turn on debugging. +IFF_LOOPBACK = 0x8 # Is a loopback net. +IFF_POINTOPOINT = 0x10 # Interface is point-to-point link. +IFF_NOTRAILERS = 0x20 # Avoid use of trailers. +IFF_RUNNING = 0x40 # Resources allocated. +IFF_NOARP = 0x80 # No address resolution protocol. +IFF_PROMISC = 0x100 # Receive all packets. + +# From netpacket/packet.h +PACKET_ADD_MEMBERSHIP = 1 +PACKET_DROP_MEMBERSHIP = 2 +PACKET_RECV_OUTPUT = 3 +PACKET_RX_RING = 5 +PACKET_STATISTICS = 6 +PACKET_MR_MULTICAST = 0 +PACKET_MR_PROMISC = 1 +PACKET_MR_ALLMULTI = 2 + +# From bits/socket.h +SOL_PACKET = 263 +# From asm/socket.h +SO_ATTACH_FILTER = 26 +SOL_SOCKET = 1 + +# From net/route.h +RTF_UP = 0x0001 # Route usable +RTF_REJECT = 0x0200 + +# From pcap/pcap.h +PCAP_ERRBUF_SIZE=256 + + + +LOOPBACK_NAME="lo" + +with os.popen("tcpdump -V 2> /dev/null") as _f: + if _f.close() >> 8 == 0x7f: + log_loading.warning("Failed to execute tcpdump. Check it is installed and in the PATH") + TCPDUMP=0 + else: + TCPDUMP=1 +del(_f) + + +def get_if_raw_hwaddr(iff): + return struct.unpack("16xh6s8x",get_if(iff,SIOCGIFHWADDR))[1] + +def get_if_raw_addr(iff): + try: + return get_if(iff, SIOCGIFADDR)[20:24] + except IOError: + return b"\0\0\0\0" + + +def get_if_list(): + try: + f=open("/proc/net/dev","r") + except IOError: + warning("Can't open /proc/net/dev !") + return [] + lst = [] + f.readline() + f.readline() + for l in f: + lst.append(l.split(":")[0].strip()) + f.close() + return lst + +def get_working_if(): + for i in get_if_list(): + if i == LOOPBACK_NAME: + continue + ifflags = struct.unpack("16xH14x",get_if(i,SIOCGIFFLAGS))[0] + if ifflags & IFF_UP: + return i + return LOOPBACK_NAME +def attach_filter(s, filter): + # XXX We generate the filter on the interface conf.iface + # because tcpdump open the "any" interface and ppp interfaces + # in cooked mode. As we use them in raw mode, the filter will not + # work... one solution could be to use "any" interface and translate + # the filter from cooked mode to raw mode + # mode + if not TCPDUMP: + return + try: + f = os.popen("%s -i %s -ddd -s 1600 '%s'" % (conf.prog.tcpdump,conf.iface,filter)) + except OSError as msg: + log_interactive.warning("Failed to execute tcpdump: (%s)") + return + lines = f.readlines() + if f.close(): + raise Scapy_Exception("Filter parse error") + nb = int(lines[0]) + bpf = b"" + for l in lines[1:]: + bpf += struct.pack("HBBI",*[int(x) for x in l.split()]) + + # XXX. Argl! We need to give the kernel a pointer on the BPF, + # python object header seems to be 20 bytes. 36 bytes for x86 64bits arch. + bpf_buf = ctypes.create_string_buffer(bpf) + class BpfProgram(ctypes.Structure): + _fields_ = [ ("bf_len", ctypes.c_int), ("bf_insn", ctypes.POINTER(type(bpf_buf))) ] + #if scapy.arch.X86_64: + # bpfh = struct.pack("HL", nb, id(bpf)+36) + #else: + # bpfh = struct.pack("HI", nb, id(bpf)+20) + bpfh = BpfProgram(nb, ctypes.pointer(bpf_buf)) + s.setsockopt(SOL_SOCKET, SO_ATTACH_FILTER, bpfh) + +def set_promisc(s,iff,val=1): + mreq = struct.pack("IHH8s", get_if_index(iff), PACKET_MR_PROMISC, 0, b"") + if val: + cmd = PACKET_ADD_MEMBERSHIP + else: + cmd = PACKET_DROP_MEMBERSHIP + s.setsockopt(SOL_PACKET, cmd, mreq) + + + +def read_routes(): + try: + f=open("/proc/net/route","rb") + except IOError: + warning("Can't open /proc/net/route !") + return [] + routes = [] + s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + ifreq = ioctl(s, SIOCGIFADDR,struct.pack("16s16x",LOOPBACK_NAME.encode('utf-8'))) + addrfamily = struct.unpack("h",ifreq[16:18])[0] + if addrfamily == socket.AF_INET: + ifreq2 = ioctl(s, SIOCGIFNETMASK,struct.pack("16s16x",LOOPBACK_NAME.encode('utf-8'))) + msk = socket.ntohl(struct.unpack("I",ifreq2[20:24])[0]) + dst = socket.ntohl(struct.unpack("I",ifreq[20:24])[0]) & msk + ifaddr = scapy.utils.inet_ntoa(ifreq[20:24]) + routes.append((dst, msk, "0.0.0.0", LOOPBACK_NAME, ifaddr)) + else: + warning("Interface lo: unkown address family (%i)"% addrfamily) + + for l in f.readlines()[1:]: + iff,dst,gw,flags,x,x,x,msk,x,x,x = l.split() + flags = int(flags,16) + if flags & RTF_UP == 0: + continue + if flags & RTF_REJECT: + continue + try: + ifreq = ioctl(s, SIOCGIFADDR,struct.pack("16s16x",iff)) + except IOError: # interface is present in routing tables but does not have any assigned IP + ifaddr="0.0.0.0" + else: + addrfamily = struct.unpack("h",ifreq[16:18])[0] + if addrfamily == socket.AF_INET: + ifaddr = scapy.utils.inet_ntoa(ifreq[20:24]) + else: + warning("Interface %s: unkown address family (%i)"%(iff, addrfamily)) + continue + routes.append((socket.htonl(int(dst,16))&0xffffffff, + socket.htonl(int(msk,16))&0xffffffff, + scapy.utils.inet_ntoa(struct.pack("I",int(gw,16))), + iff.decode('utf-8'), ifaddr)) + + f.close() + return routes + +############ +### IPv6 ### +############ + +def in6_getifaddr(): + """ + Returns a list of 3-tuples of the form (addr, scope, iface) where + 'addr' is the address of scope 'scope' associated to the interface + 'ifcace'. + + This is the list of all addresses of all interfaces available on + the system. + """ + ret = [] + try: + f = open("/proc/net/if_inet6","rb") + except IOError as err: + return ret + l = f.readlines() + for i in l: + # addr, index, plen, scope, flags, ifname + tmp = i.split() + addr = struct.unpack('4s4s4s4s4s4s4s4s', tmp[0]) + addr = scapy.utils6.in6_ptop(b':'.join(addr).decode('ascii')) + ret.append((addr, int(tmp[3], 16), tmp[5].decode('ascii'))) # (addr, scope, iface) + f.close() + return ret + +def read_routes6(): + try: + f = open("/proc/net/ipv6_route","r") + except IOError as err: + return [] + # 1. destination network + # 2. destination prefix length + # 3. source network displayed + # 4. source prefix length + # 5. next hop + # 6. metric + # 7. reference counter (?!?) + # 8. use counter (?!?) + # 9. flags + # 10. device name + routes = [] + def proc2r(p): + ret = struct.unpack('4s4s4s4s4s4s4s4s', p.encode('ascii')) + ret = b':'.join(ret) + return scapy.utils6.in6_ptop(ret.decode('ascii')) + + lifaddr = in6_getifaddr() + for l in f.readlines(): + d,dp,s,sp,nh,m,rc,us,fl,dev = l.split() + fl = int(fl, 16) + + if fl & RTF_UP == 0: + continue + if fl & RTF_REJECT: + continue + + d = proc2r(d) ; dp = int(dp, 16) + s = proc2r(s) ; sp = int(sp, 16) + nh = proc2r(nh) + + cset = [] # candidate set (possible source addresses) + if dev == LOOPBACK_NAME: + if d == '::': + continue + cset = ['::1'] + else: + #devaddrs = filter(lambda x: x[2] == dev, lifaddr) + devaddrs = [ x for x in lifaddr if x[2] == dev ] + cset = scapy.utils6.construct_source_candidate_set(d, dp, devaddrs, LOOPBACK_NAME) + + if len(cset) != 0: + routes.append((d, dp, nh, dev, cset)) + f.close() + return routes + + + + +def get_if(iff,cmd): + s=socket.socket() + ifreq = ioctl(s, cmd, struct.pack("16s16x",bytes(iff,'utf-8'))) + s.close() + return ifreq + + +def get_if_index(iff): + return int(struct.unpack("I",get_if(iff, SIOCGIFINDEX)[16:20])[0]) + +if os.uname()[4] == 'x86_64': + def get_last_packet_timestamp(sock): + ts = ioctl(sock, SIOCGSTAMP, "1234567890123456") + s,us = struct.unpack("QQ",ts) + return s+us/1000000.0 +else: + def get_last_packet_timestamp(sock): + ts = ioctl(sock, SIOCGSTAMP, "12345678") + s,us = struct.unpack("II",ts) + return s+us/1000000.0 + + +def _flush_fd(fd): + if type(fd) is not int: + fd = fd.fileno() + while 1: + r,w,e = select([fd],[],[],0) + if r: + os.read(fd,MTU) + else: + break + + + + + +class L3PacketSocket(SuperSocket): + desc = "read/write packets at layer 3 using Linux PF_PACKET sockets" + def __init__(self, type = ETH_P_ALL, filter=None, promisc=None, iface=None, nofilter=0): + self.type = type + self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) + self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) + if iface: + self.ins.bind((iface, type)) + if not nofilter: + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if filter is not None: + attach_filter(self.ins, filter) + _flush_fd(self.ins) + self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) + self.outs = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) + self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**30) + if promisc is None: + promisc = conf.promisc + self.promisc = promisc + if self.promisc: + if iface is None: + self.iff = get_if_list() + else: + if iface.__class__ is list: + self.iff = iface + else: + self.iff = [iface] + for i in self.iff: + set_promisc(self.ins, i) + def close(self): + if self.closed: + return + self.closed=1 + if self.promisc: + for i in self.iff: + set_promisc(self.ins, i, 0) + SuperSocket.close(self) + def recv(self, x=MTU): + pkt, sa_ll = self.ins.recvfrom(x) + if sa_ll[2] == socket.PACKET_OUTGOING: + return None + if sa_ll[3] in conf.l2types: + cls = conf.l2types[sa_ll[3]] + lvl = 2 + elif sa_ll[1] in conf.l3types: + cls = conf.l3types[sa_ll[1]] + lvl = 3 + else: + cls = conf.default_l2 + warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using %s" % (sa_ll[0],sa_ll[1],sa_ll[3],cls.name)) + lvl = 2 + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + if lvl == 2: + pkt = pkt.payload + + if pkt is not None: + pkt.time = get_last_packet_timestamp(self.ins) + return pkt + + def send(self, x): + iff,a,gw = x.route() + if iff is None: + iff = conf.iface + sdto = (iff, self.type) + self.outs.bind(sdto) + sn = self.outs.getsockname() + ll = lambda x:x + if type(x) in conf.l3types: + sdto = (iff, conf.l3types[type(x)]) + if sn[3] in conf.l2types: + ll = lambda x:conf.l2types[sn[3]]()/x + try: + sx = bytes(ll(x)) + x.sent_time = time.time() + self.outs.sendto(sx, sdto) + except OSError as msg: + x.sent_time = time.time() # bad approximation + if conf.auto_fragment and msg.errno == 90: + for p in x.fragment(): + self.outs.sendto(bytes(ll(p)), sdto) + else: + raise + + + +class L2Socket(SuperSocket): + desc = "read/write packets at layer 2 using Linux PF_PACKET sockets" + def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): + if iface is None: + iface = conf.iface + self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) + self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) + if not nofilter: + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if filter is not None: + attach_filter(self.ins, filter) + self.ins.bind((iface, type)) + _flush_fd(self.ins) + self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) + self.outs = self.ins + self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 2**30) + sa_ll = self.outs.getsockname() + if sa_ll[3] in conf.l2types: + self.LL = conf.l2types[sa_ll[3]] + elif sa_ll[1] in conf.l3types: + self.LL = conf.l3types[sa_ll[1]] + else: + self.LL = conf.default_l2 + warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using %s" % (sa_ll[0],sa_ll[1],sa_ll[3],self.LL.name)) + + def recv(self, x=MTU): + pkt, sa_ll = self.ins.recvfrom(x) + if sa_ll[2] == socket.PACKET_OUTGOING: + return None + try: + q = self.LL(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + q = conf.raw_layer(pkt) + q.time = get_last_packet_timestamp(self.ins) + return q + + +class L2ListenSocket(SuperSocket): + desc = "read packets at layer 2 using Linux PF_PACKET sockets" + def __init__(self, iface = None, type = ETH_P_ALL, promisc=None, filter=None, nofilter=0): + self.type = type + self.outs = None + self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) + self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 0) + if iface is not None: + self.ins.bind((iface, type)) + if not nofilter: + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if filter is not None: + attach_filter(self.ins, filter) + if promisc is None: + promisc = conf.sniff_promisc + self.promisc = promisc + if iface is None: + self.iff = get_if_list() + else: + if iface.__class__ is list: + self.iff = iface + else: + self.iff = [iface] + if self.promisc: + for i in self.iff: + set_promisc(self.ins, i) + _flush_fd(self.ins) + self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2**30) + def close(self): + if self.promisc: + for i in self.iff: + set_promisc(self.ins, i, 0) + SuperSocket.close(self) + + def recv(self, x=MTU): + pkt, sa_ll = self.ins.recvfrom(x) + if sa_ll[3] in conf.l2types : + cls = conf.l2types[sa_ll[3]] + elif sa_ll[1] in conf.l3types: + cls = conf.l3types[sa_ll[1]] + else: + cls = conf.default_l2 + warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using %s" % (sa_ll[0],sa_ll[1],sa_ll[3],cls.name)) + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + pkt.time = get_last_packet_timestamp(self.ins) + return pkt + + def send(self, x): + raise Scapy_Exception("Can't send anything with L2ListenSocket") + + +conf.L3socket = L3PacketSocket +conf.L2socket = L2Socket +conf.L2listen = L2ListenSocket + +conf.iface = get_working_if() diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/pcapdnet.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/pcapdnet.py new file mode 100644 index 00000000..a2e8aa59 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/pcapdnet.py @@ -0,0 +1,565 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Packet sending and receiving with libdnet and libpcap/WinPcap. +""" + +import time,struct,sys,socket +if not sys.platform.startswith("win"): + from fcntl import ioctl +from scapy.data import * +from scapy.config import conf +from scapy.utils import warning +from scapy.supersocket import SuperSocket +from scapy.error import Scapy_Exception +import scapy.arch + +if conf.use_dnet: + try: + from .cdnet import * + except OSError as e: + if conf.interactive: + log_loading.error("Unable to import libdnet library: %s" % e) + conf.use_dnet = False + else: + raise + +if conf.use_winpcapy: + try: + from .winpcapy import * + def winpcapy_get_if_list(): + err = create_string_buffer(PCAP_ERRBUF_SIZE) + devs = POINTER(pcap_if_t)() + ret = [] + if pcap_findalldevs(byref(devs), err) < 0: + return ret + try: + p = devs + while p: + ret.append(p.contents.name.decode('ascii')) + p = p.contents.next + return ret + finally: + pcap_freealldevs(devs) + + except OSError as e: + if conf.interactive: + log_loading.error("Unable to import libpcap library: %s" % e) + conf.use_winpcapy = False + else: + raise + + # From BSD net/bpf.h + #BIOCIMMEDIATE=0x80044270 + BIOCIMMEDIATE=-2147204496 + + class PcapTimeoutElapsed(Scapy_Exception): + pass + +if conf.use_netifaces: + try: + import netifaces + except ImportError as e: + log_loading.warning("Could not load module netifaces: %s" % e) + conf.use_netifaces = False + +if conf.use_netifaces: + def get_if_raw_hwaddr(iff): + if iff == scapy.arch.LOOPBACK_NAME: + return (772, '\x00'*6) + try: + s = netifaces.ifaddresses(iff)[netifaces.AF_LINK][0]['addr'] + return struct.pack('BBBBBB', *[ int(i, 16) for i in s.split(':') ]) + except: + raise Scapy_Exception("Error in attempting to get hw address for interface [%s]" % iff) + return l + def get_if_raw_addr(ifname): + try: + s = netifaces.ifaddresses(ifname)[netifaces.AF_INET][0]['addr'] + return socket.inet_aton(s) + except Exception as e: + return None + def get_if_list(): + #return [ i[1] for i in socket.if_nameindex() ] + return netifaces.interfaces() + def in6_getifaddr(): + """ + Returns a list of 3-tuples of the form (addr, scope, iface) where + 'addr' is the address of scope 'scope' associated to the interface + 'ifcace'. + + This is the list of all addresses of all interfaces available on + the system. + """ + + ret = [] + interfaces = get_if_list() + for i in interfaces: + addrs = netifaces.ifaddresses(i) + if netifaces.AF_INET6 not in addrs: + continue + for a in addrs[netifaces.AF_INET6]: + addr = a['addr'].split('%')[0] + scope = scapy.utils6.in6_getscope(addr) + ret.append((addr, scope, i)) + return ret +elif conf.use_winpcapy: + def get_if_raw_hwaddr(iff): + err = create_string_buffer(PCAP_ERRBUF_SIZE) + devs = POINTER(pcap_if_t)() + ret = b"\0\0\0\0\0\0" + if pcap_findalldevs(byref(devs), err) < 0: + return ret + try: + p = devs + while p: + if p.contents.name.endswith(iff.encode('ascii')): + a = p.contents.addresses + while a: + if hasattr(socket, 'AF_LINK') and a.contents.addr.contents.sa_family == socket.AF_LINK: + ap = a.contents.addr + val = cast(ap, POINTER(sockaddr_dl)) + ret = bytes(val.contents.sdl_data[ val.contents.sdl_nlen : val.contents.sdl_nlen + val.contents.sdl_alen ]) + a = a.contents.next + break + p = p.contents.next + return ret + finally: + pcap_freealldevs(devs) + def get_if_raw_addr(iff): + err = create_string_buffer(PCAP_ERRBUF_SIZE) + devs = POINTER(pcap_if_t)() + ret = b"\0\0\0\0" + if pcap_findalldevs(byref(devs), err) < 0: + return ret + try: + p = devs + while p: + if p.contents.name.endswith(iff.encode('ascii')): + a = p.contents.addresses + while a: + if a.contents.addr.contents.sa_family == socket.AF_INET: + ap = a.contents.addr + val = cast(ap, POINTER(sockaddr_in)) + ret = bytes(val.contents.sin_addr[:4]) + a = a.contents.next + break + p = p.contents.next + return ret + finally: + pcap_freealldevs(devs) + get_if_list = winpcapy_get_if_list + def in6_getifaddr(): + err = create_string_buffer(PCAP_ERRBUF_SIZE) + devs = POINTER(pcap_if_t)() + ret = [] + if pcap_findalldevs(byref(devs), err) < 0: + return ret + try: + p = devs + ret = [] + while p: + a = p.contents.addresses + while a: + if a.contents.addr.contents.sa_family == socket.AF_INET6: + ap = a.contents.addr + val = cast(ap, POINTER(sockaddr_in6)) + addr = socket.inet_ntop(socket.AF_INET6, bytes(val.contents.sin6_addr[:])) + scope = scapy.utils6.in6_getscope(addr) + ret.append((addr, scope, p.contents.name.decode('ascii'))) + a = a.contents.next + p = p.contents.next + return ret + finally: + pcap_freealldevs(devs) + +elif conf.use_dnet: + intf = dnet_intf() + def get_if_raw_hwaddr(iff): + return intf.get(iff)['link_addr'] + def get_if_raw_addr(iff): + return intf.get(iff)['addr'] + def get_if_list(): + return intf.names + def in6_getifaddr(): + ret = [] + for i in get_if_list(): + for a in intf.get(i)['addr6']: + addr = socket.inet_ntop(socket.AF_INET6, a) + scope = scapy.utils6.in6_getscope(addr) + ret.append((addr, scope, i)) + return ret + +else: + log_loading.warning("No known method to get ip and hw address for interfaces") + def get_if_raw_hwaddr(iff): + "dummy" + return b"\0\0\0\0\0\0" + def get_if_raw_addr(iff): + "dummy" + return b"\0\0\0\0" + def get_if_list(): + "dummy" + return [] + def in6_getifaddr(): + return [] + +if conf.use_winpcapy: + from ctypes import POINTER, byref, create_string_buffer + class _PcapWrapper_pypcap: + def __init__(self, device, snaplen, promisc, to_ms): + self.errbuf = create_string_buffer(PCAP_ERRBUF_SIZE) + self.iface = create_string_buffer(device.encode('ascii')) + self.pcap = pcap_open_live(self.iface, snaplen, promisc, to_ms, self.errbuf) + self.header = POINTER(pcap_pkthdr)() + self.pkt_data = POINTER(c_ubyte)() + self.bpf_program = bpf_program() + def next(self): + c = pcap_next_ex(self.pcap, byref(self.header), byref(self.pkt_data)) + if not c > 0: + return + ts = self.header.contents.ts.tv_sec + #pkt = "".join([ chr(i) for i in self.pkt_data[:self.header.contents.len] ]) + pkt = bytes(self.pkt_data[:self.header.contents.len]) + return ts, pkt + def datalink(self): + return pcap_datalink(self.pcap) + def fileno(self): + if sys.platform.startswith("win"): + error("Cannot get selectable PCAP fd on Windows") + return 0 + return pcap_get_selectable_fd(self.pcap) + def setfilter(self, f): + filter_exp = create_string_buffer(f.encode('ascii')) + if pcap_compile(self.pcap, byref(self.bpf_program), filter_exp, 0, -1) == -1: + error("Could not compile filter expression %s" % f) + return False + else: + if pcap_setfilter(self.pcap, byref(self.bpf_program)) == -1: + error("Could not install filter %s" % f) + return False + return True + def setnonblock(self, i): + pcap_setnonblock(self.pcap, i, self.errbuf) + def send(self, x): + pcap_sendpacket(self.pcap, x, len(x)) + def close(self): + pcap_close(self.pcap) + open_pcap = lambda *args,**kargs: _PcapWrapper_pypcap(*args,**kargs) + class PcapTimeoutElapsed(Scapy_Exception): + pass + + class L2pcapListenSocket(SuperSocket): + desc = "read packets at layer 2 using libpcap" + def __init__(self, iface = None, type = ETH_P_ALL, promisc=None, filter=None): + self.type = type + self.outs = None + self.iface = iface + if iface is None: + iface = conf.iface + if promisc is None: + promisc = conf.sniff_promisc + self.promisc = promisc + self.ins = open_pcap(iface, 1600, self.promisc, 100) + try: + ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) + except: + pass + if type == ETH_P_ALL: # Do not apply any filter if Ethernet type is given + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if filter: + self.ins.setfilter(filter) + + def close(self): + self.ins.close() + + def recv(self, x=MTU): + ll = self.ins.datalink() + if ll in conf.l2types: + cls = conf.l2types[ll] + else: + cls = conf.default_l2 + warning("Unable to guess datalink type (interface=%s linktype=%i). Using %s" % (self.iface, ll, cls.name)) + + pkt = None + while pkt is None: + pkt = self.ins.next() + if pkt is not None: + ts,pkt = pkt + if scapy.arch.WINDOWS and pkt is None: + raise PcapTimeoutElapsed + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + pkt.time = ts + return pkt + + def send(self, x): + raise Scapy_Exception("Can't send anything with L2pcapListenSocket") + + + conf.L2listen = L2pcapListenSocket + class L2pcapSocket(SuperSocket): + desc = "read/write packets at layer 2 using only libpcap" + def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): + if iface is None: + iface = conf.iface + self.iface = iface + self.ins = open_pcap(iface, 1600, 0, 100) + try: + ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) + except: + pass + if nofilter: + if type != ETH_P_ALL: # PF_PACKET stuff. Need to emulate this for pcap + filter = "ether proto %i" % type + else: + filter = None + else: + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if type != ETH_P_ALL: # PF_PACKET stuff. Need to emulate this for pcap + if filter: + filter = "(ether proto %i) and (%s)" % (type,filter) + else: + filter = "ether proto %i" % type + if filter: + self.ins.setfilter(filter) + def send(self, x): + sx = bytes(x) + if hasattr(x, "sent_time"): + x.sent_time = time.time() + return self.ins.send(sx) + + def recv(self,x=MTU): + ll = self.ins.datalink() + if ll in conf.l2types: + cls = conf.l2types[ll] + else: + cls = conf.default_l2 + warning("Unable to guess datalink type (interface=%s linktype=%i). Using %s" % (self.iface, ll, cls.name)) + + pkt = self.ins.next() + if pkt is not None: + ts,pkt = pkt + if pkt is None: + return + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + pkt.time = ts + return pkt + + def nonblock_recv(self): + self.ins.setnonblock(1) + p = self.recv(MTU) + self.ins.setnonblock(0) + return p + + def close(self): + if hasattr(self, "ins"): + self.ins.close() + if hasattr(self, "outs"): + self.outs.close() + + class L3pcapSocket(L2pcapSocket): + #def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): + # L2pcapSocket.__init__(self, iface, type, filter, nofilter) + def recv(self, x = MTU): + r = L2pcapSocket.recv(self, x) + if r: + return r.payload + else: + return + def send(self, x): + cls = conf.l2types[1] + sx = bytes(cls()/x) + if hasattr(x, "sent_time"): + x.sent_time = time.time() + return self.ins.send(sx) + conf.L2socket=L2pcapSocket + conf.L3socket=L3pcapSocket + +if conf.use_winpcapy and conf.use_dnet: + class L3dnetSocket(SuperSocket): + desc = "read/write packets at layer 3 using libdnet and libpcap" + def __init__(self, type = ETH_P_ALL, filter=None, promisc=None, iface=None, nofilter=0): + self.iflist = {} + self.intf = dnet_intf() + if iface is None: + iface = conf.iface + self.iface = iface + self.ins = open_pcap(iface, 1600, 0, 100) + try: + ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) + except: + pass + if nofilter: + if type != ETH_P_ALL: # PF_PACKET stuff. Need to emulate this for pcap + filter = "ether proto %i" % type + else: + filter = None + else: + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if type != ETH_P_ALL: # PF_PACKET stuff. Need to emulate this for pcap + if filter: + filter = "(ether proto %i) and (%s)" % (type,filter) + else: + filter = "ether proto %i" % type + if filter: + self.ins.setfilter(filter) + def send(self, x): + iff,a,gw = x.route() + if iff is None: + iff = conf.iface + ifs,cls = self.iflist.get(iff,(None,None)) + if ifs is None: + iftype = self.intf.get(iff)["type"] + if iftype == INTF_TYPE_ETH: + try: + cls = conf.l2types[1] + except KeyError: + warning("Unable to find Ethernet class. Using nothing") + ifs = dnet_eth(iff) + else: + ifs = dnet_ip() + self.iflist[iff] = ifs,cls + if cls is None: + #sx = str(x) + sx = bytes(x) + else: + sx = bytes(cls()/x) + x.sent_time = time.time() + ifs.send(sx) + def recv(self,x=MTU): + ll = self.ins.datalink() + if ll in conf.l2types: + cls = conf.l2types[ll] + else: + cls = conf.default_l2 + warning("Unable to guess datalink type (interface=%s linktype=%i). Using %s" % (self.iface, ll, cls.name)) + + pkt = self.ins.next() + if pkt is not None: + ts,pkt = pkt + if pkt is None: + return + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + pkt.time = ts + return pkt.payload + + def nonblock_recv(self): + self.ins.setnonblock(1) + p = self.recv() + self.ins.setnonblock(0) + return p + + def close(self): + if hasattr(self, "ins"): + self.ins.close() + if hasattr(self, "outs"): + self.outs.close() + + class L2dnetSocket(SuperSocket): + desc = "read/write packets at layer 2 using libdnet and libpcap" + def __init__(self, iface = None, type = ETH_P_ALL, filter=None, nofilter=0): + if iface is None: + iface = conf.iface + self.iface = iface + self.ins = open_pcap(iface, 1600, 0, 100) + try: + ioctl(self.ins.fileno(),BIOCIMMEDIATE,struct.pack("I",1)) + except: + pass + if nofilter: + if type != ETH_P_ALL: # PF_PACKET stuff. Need to emulate this for pcap + filter = "ether proto %i" % type + else: + filter = None + else: + if conf.except_filter: + if filter: + filter = "(%s) and not (%s)" % (filter, conf.except_filter) + else: + filter = "not (%s)" % conf.except_filter + if type != ETH_P_ALL: # PF_PACKET stuff. Need to emulate this for pcap + if filter: + filter = "(ether proto %i) and (%s)" % (type,filter) + else: + filter = "ether proto %i" % type + if filter: + self.ins.setfilter(filter) + self.outs = dnet_eth(iface) + def recv(self,x=MTU): + ll = self.ins.datalink() + if ll in conf.l2types: + cls = conf.l2types[ll] + else: + cls = conf.default_l2 + warning("Unable to guess datalink type (interface=%s linktype=%i). Using %s" % (self.iface, ll, cls.name)) + + pkt = self.ins.next() + if pkt is not None: + ts,pkt = pkt + if pkt is None: + return + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + pkt.time = ts + return pkt + + def nonblock_recv(self): + self.ins.setnonblock(1) + p = self.recv(MTU) + self.ins.setnonblock(0) + return p + + def close(self): + if hasattr(self, "ins"): + self.ins.close() + if hasattr(self, "outs"): + self.outs.close() + + conf.L3socket=L3dnetSocket + conf.L2socket=L2dnetSocket diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/solaris.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/solaris.py new file mode 100644 index 00000000..3117076a --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/solaris.py @@ -0,0 +1,16 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Customization for the Solaris operation system. +""" + +# IPPROTO_GRE is missing on Solaris +import socket +socket.IPPROTO_GRE = 47 + +LOOPBACK_NAME="lo0" + +from unix import * diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/unix.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/unix.py new file mode 100644 index 00000000..43e694b5 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/unix.py @@ -0,0 +1,168 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Common customizations for all Unix-like operating systems other than Linux +""" + +import sys,os,struct,socket,time +from subprocess import check_output +from fcntl import ioctl +from scapy.error import warning +import scapy.config +import scapy.utils +import scapy.utils6 +import scapy.arch + +scapy.config.conf.use_winpcapy = True +scapy.config.conf.use_netifaces = True +scapy.config.conf.use_dnet = True +from .pcapdnet import * + + + +################## +## Routes stuff ## +################## + + +def read_routes(): + if scapy.arch.SOLARIS: + f=check_output(["netstat", "-rvn"], universal_newlines = True) # -f inet + elif scapy.arch.FREEBSD: + f=check_output(["netstat", "-rnW"], universal_newlines = True) # -W to handle long interface names + else: + f=check_output(["netstat", "-rn"], universal_newlines = True) # -f inet + ok = False + routes = [] + pending_if = [] + for l in f.split('\n'): + l = l.strip() + if l.find("----") >= 0: # a separation line + continue + if not ok: + if_index = [ l.split().index(i) for i in ['Iface', 'Netif', 'Interface', 'Device'] if i in l.split()] + if if_index: + ok = True + if_index = if_index[0] + continue + if not l: + break + if scapy.arch.SOLARIS: + lspl = l.split() + if len(lspl) == 10: + dest,mask,gw,netif,mxfrg,rtt,ref,flg = lspl[:8] + else: # missing interface + dest,mask,gw,mxfrg,rtt,ref,flg = lspl[:7] + netif=None + else: + rt = l.split() + dest,gw,flg = rt[:3] + netif = rt[if_index] + if flg.find("Lc") >= 0: + continue + if dest == "default": + dest = 0 + netmask = 0 + else: + if scapy.arch.SOLARIS: + netmask = scapy.utils.atol(mask) + elif "/" in dest: + dest,netmask = dest.split("/") + netmask = scapy.utils.itom(int(netmask)) + else: + netmask = scapy.utils.itom((dest.count(".") + 1) * 8) + dest += ".0"*(3-dest.count(".")) + dest = scapy.utils.atol(dest) + if not "G" in flg: + gw = '0.0.0.0' + if netif is not None: + ifaddr = scapy.arch.get_if_addr(netif) + routes.append((dest,netmask,gw,netif,ifaddr)) + else: + pending_if.append((dest,netmask,gw)) + + # On Solaris, netstat does not provide output interfaces for some routes + # We need to parse completely the routing table to route their gw and + # know their output interface + for dest,netmask,gw in pending_if: + gw_l = scapy.utils.atol(gw) + max_rtmask,gw_if,gw_if_addr, = 0,None,None + for rtdst,rtmask,_,rtif,rtaddr in routes[:]: + if gw_l & rtmask == rtdst: + if rtmask >= max_rtmask: + max_rtmask = rtmask + gw_if = rtif + gw_if_addr = rtaddr + if gw_if: + routes.append((dest,netmask,gw,gw_if,gw_if_addr)) + else: + warning("Did not find output interface to reach gateway %s" % gw) + + return routes + +############ +### IPv6 ### +############ + +def read_routes6(): + f = os.popen("netstat -rn -f inet6") + ok = False + mtu_present = False + prio_present = False + routes = [] + lifaddr = in6_getifaddr() + for l in f.readlines(): + if not l: + break + l = l.strip() + if not ok: + if l.find("Destination") >= 0: + ok = 1 + mtu_present = l.find("Mtu") >= 0 + prio_present = l.find("Prio") >= 0 + continue + # gv 12/12/06: under debugging + if scapy.arch.NETBSD or scapy.arch.OPENBSD: + lspl = l.split() + d,nh,fl = lspl[:3] + dev = lspl[5+mtu_present+prio_present] + expire = None + else: # FREEBSD or DARWIN + d,nh,fl,dev = l.split()[:4] + if [ x for x in lifaddr if x[2] == dev] == []: + continue + if 'L' in fl: # drop MAC addresses + continue + + if 'link' in nh: + nh = '::' + + cset = [] # candidate set (possible source addresses) + dp = 128 + if d == 'default': + d = '::' + dp = 0 + if '/' in d: + d,dp = d.split("/") + dp = int(dp) + if '%' in d: + d,dev = d.split('%') + if '%' in nh: + nh,dev = nh.split('%') + if scapy.arch.LOOPBACK_NAME in dev: + if d == '::' and dp == 96: #Do not use ::/96 deprecated IPV4 mapping address + continue + cset = ['::1'] + nh = '::' + else: + devaddrs = [ x for x in lifaddr if x[2] == dev ] + cset = scapy.utils6.construct_source_candidate_set(d, dp, devaddrs, scapy.arch.LOOPBACK_NAME) + + if len(cset) != 0: + routes.append((d, dp, nh, dev, cset)) + + f.close() + return routes diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/windows/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/windows/__init__.py new file mode 100644 index 00000000..3bd1ade3 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/windows/__init__.py @@ -0,0 +1,501 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Customizations needed to support Microsoft Windows. +""" + +import os,re,sys,socket,time, itertools +import subprocess as sp +from glob import glob +from scapy.config import conf,ConfClass +from scapy.error import Scapy_Exception,log_loading,log_runtime +from scapy.utils import atol, itom, inet_aton, inet_ntoa, PcapReader +from scapy.base_classes import Gen, Net, SetGen +import scapy.plist as plist +from scapy.sendrecv import debug, srp1 +from scapy.layers.l2 import Ether, ARP +from scapy.data import MTU, ETHER_BROADCAST, ETH_P_ARP + +conf.use_winpcapy = True +from scapy.arch import pcapdnet +from scapy.arch.pcapdnet import * + +LOOPBACK_NAME="lo0" +WINDOWS = True + + +def _where(filename, dirs=[], env="PATH"): + """Find file in current dir or system path""" + if not isinstance(dirs, list): + dirs = [dirs] + if glob(filename): + return filename + paths = [os.curdir] + os.environ[env].split(os.path.pathsep) + dirs + for path in paths: + for match in glob(os.path.join(path, filename)): + if match: + return os.path.normpath(match) + raise IOError("File not found: %s" % filename) + +def win_find_exe(filename, installsubdir=None, env="ProgramFiles"): + """Find executable in current dir, system path or given ProgramFiles subdir""" + for fn in [filename, filename+".exe"]: + try: + if installsubdir is None: + path = _where(fn) + else: + path = _where(fn, dirs=[os.path.join(os.environ[env], installsubdir)]) + except IOError: + path = filename + else: + break + return path + + +class WinProgPath(ConfClass): + _default = "<System default>" + # We try some magic to find the appropriate executables + pdfreader = win_find_exe("AcroRd32") + psreader = win_find_exe("gsview32.exe", "Ghostgum/gsview") + dot = win_find_exe("dot", "ATT/Graphviz/bin") + tcpdump = win_find_exe("windump") + tcpreplay = win_find_exe("tcpreplay") + display = _default + hexedit = win_find_exe("hexer") + wireshark = win_find_exe("wireshark", "wireshark") + +conf.prog = WinProgPath() + +class PcapNameNotFoundError(Scapy_Exception): + pass + +def get_windows_if_list(): + ps = sp.Popen(['powershell', 'Get-NetAdapter', '|', 'select Name, InterfaceIndex, InterfaceDescription, InterfaceGuid, MacAddress', '|', 'fl'], stdout = sp.PIPE) + stdout, stdin = ps.communicate(timeout = 10) + current_interface = None + interface_list = [] + for i in stdout.split(b'\r\n'): + if not i.strip(): + continue + if i.find(b':')<0: + continue + name, value = [ j.strip() for j in i.split(b':') ] + if name == b'Name': + if current_interface: + interface_list.append(current_interface) + current_interface = {} + current_interface['name'] = value.decode('ascii') + elif name == b'InterfaceIndex': + current_interface['win_index'] = int(value) + elif name == b'InterfaceDescription': + current_interface['description'] = value.decode('ascii') + elif name == b'InterfaceGuid': + current_interface['guid'] = value.decode('ascii') + elif name == b'MacAddress': + current_interface['mac'] = ':'.join([ j.decode('ascii') for j in value.split(b'-')]) + if current_interface: + interface_list.append(current_interface) + return interface_list + +class NetworkInterface(object): + """A network interface of your local host""" + + def __init__(self, data=None): + self.name = None + self.ip = None + self.mac = None + self.pcap_name = None + self.description = None + self.data = data + if data is not None: + self.update(data) + + def update(self, data): + """Update info about network interface according to given dnet dictionary""" + self.name = data["name"] + self.description = data['description'] + self.win_index = data['win_index'] + # Other attributes are optional + self._update_pcapdata() + try: + self.ip = socket.inet_ntoa(get_if_raw_addr(data['guid'])) + except (KeyError, AttributeError, NameError): + pass + try: + self.mac = data['mac'] + except KeyError: + pass + + def _update_pcapdata(self): + for i in winpcapy_get_if_list(): + if i.endswith(self.data['guid']): + self.pcap_name = i + return + + raise PcapNameNotFoundError + + def __repr__(self): + return "<%s: %s %s %s pcap_name=%s description=%s>" % (self.__class__.__name__, + self.name, self.ip, self.mac, self.pcap_name, self.description) + +from collections import UserDict + +class NetworkInterfaceDict(UserDict): + """Store information about network interfaces and convert between names""" + def load_from_powershell(self): + for i in get_windows_if_list(): + try: + interface = NetworkInterface(i) + self.data[interface.name] = interface + except (KeyError, PcapNameNotFoundError): + pass + if len(self.data) == 0: + log_loading.warning("No match between your pcap and windows network interfaces found. " + "You probably won't be able to send packets. " + "Deactivating unneeded interfaces and restarting Scapy might help." + "Check your winpcap and powershell installation, and access rights.") + + def pcap_name(self, devname): + """Return pcap device name for given Windows device name.""" + + try: + pcap_name = self.data[devname].pcap_name + except KeyError: + raise ValueError("Unknown network interface %r" % devname) + else: + return pcap_name + + def devname(self, pcap_name): + """Return Windows device name for given pcap device name.""" + + for devname, iface in self.items(): + if iface.pcap_name == pcap_name: + return iface.name + raise ValueError("Unknown pypcap network interface %r" % pcap_name) + + def devname_from_index(self, if_index): + """Return interface name from interface index""" + for devname, iface in self.items(): + if iface.win_index == if_index: + return iface.name + raise ValueError("Unknown network interface index %r" % if_index) + + def show(self, resolve_mac=True): + """Print list of available network interfaces in human readable form""" + + print("%s %s %s %s" % ("INDEX".ljust(5), "IFACE".ljust(35), "IP".ljust(15), "MAC")) + for iface_name in sorted(self.data.keys()): + dev = self.data[iface_name] + mac = dev.mac + if resolve_mac: + mac = conf.manufdb._resolve_MAC(mac) + print("%s %s %s %s" % (str(dev.win_index).ljust(5), str(dev.name).ljust(35), str(dev.ip).ljust(15), mac) ) + +ifaces = NetworkInterfaceDict() +ifaces.load_from_powershell() + +def pcap_name(devname): + """Return pypcap device name for given libdnet/Scapy device name""" + try: + pcap_name = ifaces.pcap_name(devname) + except ValueError: + # pcap.pcap() will choose a sensible default for sniffing if iface=None + pcap_name = None + return pcap_name + +def devname(pcap_name): + """Return libdnet/Scapy device name for given pypcap device name""" + return ifaces.devname(pcap_name) + +def devname_from_index(if_index): + """Return Windows adapter name for given Windows interface index""" + return ifaces.devname_from_index(if_index) + +def show_interfaces(resolve_mac=True): + """Print list of available network interfaces""" + return ifaces.show(resolve_mac) + +_orig_open_pcap = pcapdnet.open_pcap +pcapdnet.open_pcap = lambda iface,*args,**kargs: _orig_open_pcap(pcap_name(iface),*args,**kargs) + +_orig_get_if_raw_hwaddr = pcapdnet.get_if_raw_hwaddr +pcapdnet.get_if_raw_hwaddr = lambda iface,*args,**kargs: [ int(i, 16) for i in ifaces[iface].mac.split(':') ] +get_if_raw_hwaddr = pcapdnet.get_if_raw_hwaddr + +def read_routes(): + routes = [] + if_index = '(\d+)' + dest = '(\d+\.\d+\.\d+\.\d+)/(\d+)' + next_hop = '(\d+\.\d+\.\d+\.\d+)' + metric_pattern = "(\d+)" + delim = "\s+" # The columns are separated by whitespace + netstat_line = delim.join([if_index, dest, next_hop, metric_pattern]) + pattern = re.compile(netstat_line) + ps = sp.Popen(['powershell', 'Get-NetRoute', '-AddressFamily IPV4', '|', 'select ifIndex, DestinationPrefix, NextHop, RouteMetric'], stdout = sp.PIPE) + stdout, stdin = ps.communicate(timeout = 10) + for l in stdout.split(b'\r\n'): + match = re.search(pattern,l.decode('utf-8')) + if match: + try: + iface = devname_from_index(int(match.group(1))) + addr = ifaces[iface].ip + except: + continue + dest = atol(match.group(2)) + mask = itom(int(match.group(3))) + gw = match.group(4) + # try: + # intf = pcapdnet.dnet.intf().get_dst(pcapdnet.dnet.addr(type=2, addrtxt=dest)) + # except OSError: + # log_loading.warning("Building Scapy's routing table: Couldn't get outgoing interface for destination %s" % dest) + # continue + routes.append((dest, mask, gw, iface, addr)) + return routes + +def read_routes6(): + return [] + +try: + __IPYTHON__ +except NameError: + try: + import readline + console = readline.GetOutputFile() + except (ImportError, AttributeError): + log_loading.info("Could not get readline console. Will not interpret ANSI color codes.") + else: + conf.readfunc = readline.rl.readline + orig_stdout = sys.stdout + sys.stdout = console + +def sndrcv(pks, pkt, timeout = 2, inter = 0, verbose=None, chainCC=0, retry=0, multi=0): + if not isinstance(pkt, Gen): + pkt = SetGen(pkt) + + if verbose is None: + verbose = conf.verb + debug.recv = plist.PacketList([],"Unanswered") + debug.sent = plist.PacketList([],"Sent") + debug.match = plist.SndRcvList([]) + nbrecv=0 + ans = [] + # do it here to fix random fields, so that parent and child have the same + all_stimuli = tobesent = [p for p in pkt] + notans = len(tobesent) + + hsent={} + for i in tobesent: + h = i.hashret() + if h in hsent: + hsent[h].append(i) + else: + hsent[h] = [i] + if retry < 0: + retry = -retry + autostop=retry + else: + autostop=0 + + + while retry >= 0: + found=0 + + if timeout < 0: + timeout = None + + pid=1 + try: + if WINDOWS or pid == 0: + try: + try: + i = 0 + if verbose: + print("Begin emission:") + for p in tobesent: + pks.send(p) + i += 1 + time.sleep(inter) + if verbose: + print("Finished to send %i packets." % i) + except SystemExit: + pass + except KeyboardInterrupt: + pass + except: + log_runtime.exception("--- Error sending packets") + log_runtime.info("--- Error sending packets") + finally: + try: + sent_times = [p.sent_time for p in all_stimuli if p.sent_time] + except: + pass + if WINDOWS or pid > 0: + # Timeout starts after last packet is sent (as in Unix version) + if timeout: + stoptime = time.time()+timeout + else: + stoptime = 0 + remaintime = None + # inmask = [pks.ins.fd] + try: + try: + while 1: + if stoptime: + remaintime = stoptime-time.time() + if remaintime <= 0: + break + r = pks.recv(MTU) + if r is None: + continue + ok = 0 + h = r.hashret() + if h in hsent: + hlst = hsent[h] + for i in range(len(hlst)): + if r.answers(hlst[i]): + ans.append((hlst[i],r)) + if verbose > 1: + os.write(1, b"*") + ok = 1 + if not multi: + del(hlst[i]) + notans -= 1; + else: + if not hasattr(hlst[i], '_answered'): + notans -= 1; + hlst[i]._answered = 1; + break + if notans == 0 and not multi: + break + if not ok: + if verbose > 1: + os.write(1, b".") + nbrecv += 1 + if conf.debug_match: + debug.recv.append(r) + except KeyboardInterrupt: + if chainCC: + raise + finally: + if WINDOWS: + for p,t in zip(all_stimuli, sent_times): + p.sent_time = t + finally: + pass + + # remain = reduce(list.__add__, hsent.values(), []) + remain = list(itertools.chain(*[ i for i in hsent.values() ])) + + if multi: + #remain = filter(lambda p: not hasattr(p, '_answered'), remain); + remain = [ p for p in remain if not hasattr(p, '_answered')] + + if autostop and len(remain) > 0 and len(remain) != len(tobesent): + retry = autostop + + tobesent = remain + if len(tobesent) == 0: + break + retry -= 1 + + if conf.debug_match: + debug.sent=plist.PacketList(remain[:],"Sent") + debug.match=plist.SndRcvList(ans[:]) + + #clean the ans list to delete the field _answered + if (multi): + for s,r in ans: + if hasattr(s, '_answered'): + del(s._answered) + + if verbose: + print("\nReceived %i packets, got %i answers, remaining %i packets" % (nbrecv+len(ans), len(ans), notans)) + return plist.SndRcvList(ans),plist.PacketList(remain,"Unanswered") + + +import scapy.sendrecv +scapy.sendrecv.sndrcv = sndrcv + +def sniff(count=0, store=1, offline=None, prn = None, lfilter=None, L2socket=None, timeout=None, *arg, **karg): + """Sniff packets +sniff([count=0,] [prn=None,] [store=1,] [offline=None,] [lfilter=None,] + L2ListenSocket args) -> list of packets +Select interface to sniff by setting conf.iface. Use show_interfaces() to see interface names. + count: number of packets to capture. 0 means infinity + store: wether to store sniffed packets or discard them + prn: function to apply to each packet. If something is returned, + it is displayed. Ex: + ex: prn = lambda x: x.summary() +lfilter: python function applied to each packet to determine + if further action may be done + ex: lfilter = lambda x: x.haslayer(Padding) +offline: pcap file to read packets from, instead of sniffing them +timeout: stop sniffing after a given time (default: None) +L2socket: use the provided L2socket + """ + c = 0 + + if offline is None: + log_runtime.info('Sniffing on %s' % conf.iface) + if L2socket is None: + L2socket = conf.L2listen + s = L2socket(type=ETH_P_ALL, *arg, **karg) + else: + s = PcapReader(offline) + + lst = [] + if timeout is not None: + stoptime = time.time()+timeout + remain = None + while 1: + try: + if timeout is not None: + remain = stoptime-time.time() + if remain <= 0: + break + + try: + p = s.recv(MTU) + except PcapTimeoutElapsed: + continue + if p is None: + break + if lfilter and not lfilter(p): + continue + if store: + lst.append(p) + c += 1 + if prn: + r = prn(p) + if r is not None: + print(r) + if count > 0 and c >= count: + break + except KeyboardInterrupt: + break + s.close() + return plist.PacketList(lst,"Sniffed") + +import scapy.sendrecv +scapy.sendrecv.sniff = sniff + +# def get_if_list(): +# print('windows if_list') +# return sorted(ifaces.keys()) + +def get_working_if(): + try: + if 'Ethernet' in ifaces and ifaces['Ethernet'].ip != '0.0.0.0': + return 'Ethernet' + elif 'Wi-Fi' in ifaces and ifaces['Wi-Fi'].ip != '0.0.0.0': + return 'Wi-Fi' + elif len(ifaces) > 0: + return ifaces[list(ifaces.keys())[0]] + else: + return LOOPBACK_NAME + except: + return LOOPBACK_NAME + +conf.iface = get_working_if() diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/arch/winpcapy.py b/scripts/external_libs/scapy-python3-0.18/scapy/arch/winpcapy.py new file mode 100644 index 00000000..fc452a02 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/arch/winpcapy.py @@ -0,0 +1,739 @@ +#------------------------------------------------------------------------------- +# Name: winpcapy.py +# +# Author: Massimo Ciani +# +# Created: 01/09/2009 +# Copyright: (c) Massimo Ciani 2009 +# +#------------------------------------------------------------------------------- + + +from ctypes import * +from ctypes.util import find_library +import sys + +WIN32=False +HAVE_REMOTE=False + + +if sys.platform.startswith('win'): + WIN32=True + HAVE_REMOTE=True + +if WIN32: + SOCKET = c_uint + _lib=CDLL('wpcap.dll') +else: + SOCKET = c_int + _lib_name = find_library('pcap') + if not _lib_name: + raise OSError("Cannot fine libpcap.so library") + _lib=CDLL(_lib_name) + + + +## +## misc +## +u_short = c_ushort +bpf_int32 = c_int +u_int = c_int +bpf_u_int32 = u_int +pcap = c_void_p +pcap_dumper = c_void_p +u_char = c_ubyte +FILE = c_void_p +STRING = c_char_p + +class bpf_insn(Structure): + _fields_=[("code",c_ushort), + ("jt",c_ubyte), + ("jf",c_ubyte), + ("k",bpf_u_int32)] + +class bpf_program(Structure): + pass +bpf_program._fields_ = [('bf_len', u_int), + ('bf_insns', POINTER(bpf_insn))] + +class bpf_version(Structure): + _fields_=[("bv_major",c_ushort), + ("bv_minor",c_ushort)] + + +class timeval(Structure): + pass +timeval._fields_ = [('tv_sec', c_long), + ('tv_usec', c_long)] + +## sockaddr is used by pcap_addr. +## For exapmle if sa_family==socket.AF_INET then we need cast +## with sockaddr_in +if WIN32: + class sockaddr(Structure): + _fields_ = [("sa_family", c_ushort), + ("sa_data",c_ubyte * 14)] + + class sockaddr_in(Structure): + _fields_ = [("sin_family", c_ushort), + ("sin_port", c_uint16), + ("sin_addr", 4 * c_ubyte)] + + class sockaddr_in6(Structure): + _fields_ = [("sin6_family", c_ushort), + ("sin6_port", c_uint16), + ("sin6_flowinfo", c_uint32), + ("sin6_addr", 16 * c_ubyte), + ("sin6_scope", c_uint32)] +else: + class sockaddr(Structure): + _fields_ = [("sa_len", c_ubyte), + ("sa_family",c_ubyte), + ("sa_data",c_ubyte * 14)] + + class sockaddr_in(Structure): + _fields_ = [("sin_len", c_ubyte), + ("sin_family", c_ubyte), + ("sin_port", c_uint16), + ("sin_addr", 4 * c_ubyte), + ("sin_zero", 8 * c_char)] + + class sockaddr_in6(Structure): + _fields_ = [("sin6_len", c_ubyte), + ("sin6_family", c_ubyte), + ("sin6_port", c_uint16), + ("sin6_flowinfo", c_uint32), + ("sin6_addr", 16 * c_ubyte), + ("sin6_scope", c_uint32)] + + class sockaddr_dl(Structure): + _fields_ = [("sdl_len", c_ubyte), + ("sdl_family", c_ubyte), + ("sdl_index", c_ushort), + ("sdl_type", c_ubyte), + ("sdl_nlen", c_ubyte), + ("sdl_alen", c_ubyte), + ("sdl_slen", c_ubyte), + ("sdl_data", 46 * c_ubyte)] +## +## END misc +## + +## +## Data Structures +## + +## struct pcap_file_header +## Header of a libpcap dump file. +class pcap_file_header(Structure): + _fields_ = [('magic', bpf_u_int32), + ('version_major', u_short), + ('version_minor', u_short), + ('thiszone', bpf_int32), + ('sigfigs', bpf_u_int32), + ('snaplen', bpf_u_int32), + ('linktype', bpf_u_int32)] + +## struct pcap_pkthdr +## Header of a packet in the dump file. +class pcap_pkthdr(Structure): + _fields_ = [('ts', timeval), + ('caplen', bpf_u_int32), + ('len', bpf_u_int32)] + +## struct pcap_stat +## Structure that keeps statistical values on an interface. +class pcap_stat(Structure): + pass +### _fields_ list in Structure is final. +### We need a temp list +_tmpList=[] +_tmpList.append(("ps_recv",c_uint)) +_tmpList.append(("ps_drop",c_uint)) +_tmpList.append(("ps_ifdrop",c_uint)) +if HAVE_REMOTE: + _tmpList.append(("ps_capt",c_uint)) + _tmpList.append(("ps_sent",c_uint)) + _tmpList.append(("ps_netdrop",c_uint)) +pcap_stat._fields_=_tmpList + +## struct pcap_addr +## Representation of an interface address, used by pcap_findalldevs(). +class pcap_addr(Structure): + pass +pcap_addr._fields_ = [('next', POINTER(pcap_addr)), + ('addr', POINTER(sockaddr)), + ('netmask', POINTER(sockaddr)), + ('broadaddr', POINTER(sockaddr)), + ('dstaddr', POINTER(sockaddr))] + +## struct pcap_if +## Item in a list of interfaces, used by pcap_findalldevs(). +class pcap_if(Structure): + pass +pcap_if._fields_ = [('next', POINTER(pcap_if)), + ('name', STRING), + ('description', STRING), + ('addresses', POINTER(pcap_addr)), + ('flags', bpf_u_int32)] + +## +## END Data Structures +## + +## +## Defines +## + +##define PCAP_VERSION_MAJOR 2 +# Major libpcap dump file version. +PCAP_VERSION_MAJOR = 2 +##define PCAP_VERSION_MINOR 4 +# Minor libpcap dump file version. +PCAP_VERSION_MINOR = 4 +##define PCAP_ERRBUF_SIZE 256 +# Size to use when allocating the buffer that contains the libpcap errors. +PCAP_ERRBUF_SIZE = 256 +##define PCAP_IF_LOOPBACK 0x00000001 +# interface is loopback +PCAP_IF_LOOPBACK = 1 +##define MODE_CAPT 0 +# Capture mode, to be used when calling pcap_setmode(). +MODE_CAPT = 0 +##define MODE_STAT 1 +# Statistical mode, to be used when calling pcap_setmode(). +MODE_STAT = 1 + +## +## END Defines +## + +## +## Typedefs +## + +#typedef int bpf_int32 (already defined) +# 32-bit integer +#typedef u_int bpf_u_int32 (already defined) +# 32-bit unsigned integer +#typedef struct pcap pcap_t +# Descriptor of an open capture instance. This structure is opaque to the user, that handles its content through the functions provided by wpcap.dll. +pcap_t = pcap +#typedef struct pcap_dumper pcap_dumper_t +# libpcap savefile descriptor. +pcap_dumper_t = pcap_dumper +#typedef struct pcap_if pcap_if_t +# Item in a list of interfaces, see pcap_if. +pcap_if_t = pcap_if +#typedef struct pcap_addr pcap_addr_t +# Representation of an interface address, see pcap_addr. +pcap_addr_t = pcap_addr + +## +## END Typedefs +## + + + + + +# values for enumeration 'pcap_direction_t' +#pcap_direction_t = c_int # enum + +## +## Unix-compatible Functions +## These functions are part of the libpcap library, and therefore work both on Windows and on Linux. +## + +#typedef void(* pcap_handler )(u_char *user, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data) +# Prototype of the callback function that receives the packets. +## This one is defined from programmer +pcap_handler=CFUNCTYPE(None,POINTER(c_ubyte),POINTER(pcap_pkthdr),POINTER(c_ubyte)) + +#pcap_t * pcap_open_live (const char *device, int snaplen, int promisc, int to_ms, char *ebuf) +# Open a live capture from the network. +pcap_open_live = _lib.pcap_open_live +pcap_open_live.restype = POINTER(pcap_t) +pcap_open_live.argtypes = [STRING, c_int, c_int, c_int, STRING] + +#pcap_t * pcap_open_dead (int linktype, int snaplen) +# Create a pcap_t structure without starting a capture. +pcap_open_dead = _lib.pcap_open_dead +pcap_open_dead.restype = POINTER(pcap_t) +pcap_open_dead.argtypes = [c_int, c_int] + +#pcap_t * pcap_open_offline (const char *fname, char *errbuf) +# Open a savefile in the tcpdump/libpcap format to read packets. +pcap_open_offline = _lib.pcap_open_offline +pcap_open_offline.restype = POINTER(pcap_t) +pcap_open_offline.argtypes = [STRING, STRING] + +#pcap_dumper_t * pcap_dump_open (pcap_t *p, const char *fname) +# Open a file to write packets. +pcap_dump_open = _lib.pcap_dump_open +pcap_dump_open.restype = POINTER(pcap_dumper_t) +pcap_dump_open.argtypes = [POINTER(pcap_t), STRING] + +#int pcap_setnonblock (pcap_t *p, int nonblock, char *errbuf) +# Switch between blocking and nonblocking mode. +pcap_setnonblock = _lib.pcap_setnonblock +pcap_setnonblock.restype = c_int +pcap_setnonblock.argtypes = [POINTER(pcap_t), c_int, STRING] + +#int pcap_getnonblock (pcap_t *p, char *errbuf) +# Get the "non-blocking" state of an interface. +pcap_getnonblock = _lib.pcap_getnonblock +pcap_getnonblock.restype = c_int +pcap_getnonblock.argtypes = [POINTER(pcap_t), STRING] + +#int pcap_findalldevs (pcap_if_t **alldevsp, char *errbuf) +# Construct a list of network devices that can be opened with pcap_open_live(). +pcap_findalldevs = _lib.pcap_findalldevs +pcap_findalldevs.restype = c_int +pcap_findalldevs.argtypes = [POINTER(POINTER(pcap_if_t)), STRING] + +#void pcap_freealldevs (pcap_if_t *alldevsp) +# Free an interface list returned by pcap_findalldevs(). +pcap_freealldevs = _lib.pcap_freealldevs +pcap_freealldevs.restype = None +pcap_freealldevs.argtypes = [POINTER(pcap_if_t)] + +#char * pcap_lookupdev (char *errbuf) +# Return the first valid device in the system. +pcap_lookupdev = _lib.pcap_lookupdev +pcap_lookupdev.restype = STRING +pcap_lookupdev.argtypes = [STRING] + +#int pcap_lookupnet (const char *device, bpf_u_int32 *netp, bpf_u_int32 *maskp, char *errbuf) +# Return the subnet and netmask of an interface. +pcap_lookupnet = _lib.pcap_lookupnet +pcap_lookupnet.restype = c_int +pcap_lookupnet.argtypes = [STRING, POINTER(bpf_u_int32), POINTER(bpf_u_int32), STRING] + +#int pcap_dispatch (pcap_t *p, int cnt, pcap_handler callback, u_char *user) +# Collect a group of packets. +pcap_dispatch = _lib.pcap_dispatch +pcap_dispatch.restype = c_int +pcap_dispatch.argtypes = [POINTER(pcap_t), c_int, pcap_handler, POINTER(u_char)] + +#int pcap_loop (pcap_t *p, int cnt, pcap_handler callback, u_char *user) +# Collect a group of packets. +pcap_loop = _lib.pcap_loop +pcap_loop.restype = c_int +pcap_loop.argtypes = [POINTER(pcap_t), c_int, pcap_handler, POINTER(u_char)] + +#u_char * pcap_next (pcap_t *p, struct pcap_pkthdr *h) +# Return the next available packet. +pcap_next = _lib.pcap_next +pcap_next.restype = POINTER(u_char) +pcap_next.argtypes = [POINTER(pcap_t), POINTER(pcap_pkthdr)] + +#int pcap_next_ex (pcap_t *p, struct pcap_pkthdr **pkt_header, const u_char **pkt_data) +# Read a packet from an interface or from an offline capture. +pcap_next_ex = _lib.pcap_next_ex +pcap_next_ex.restype = c_int +pcap_next_ex.argtypes = [POINTER(pcap_t), POINTER(POINTER(pcap_pkthdr)), POINTER(POINTER(u_char))] + +#void pcap_breakloop (pcap_t *) +# set a flag that will force pcap_dispatch() or pcap_loop() to return rather than looping. +pcap_breakloop = _lib.pcap_breakloop +pcap_breakloop.restype = None +pcap_breakloop.argtypes = [POINTER(pcap_t)] + +#int pcap_sendpacket (pcap_t *p, u_char *buf, int size) +# Send a raw packet. +pcap_sendpacket = _lib.pcap_sendpacket +pcap_sendpacket.restype = c_int +#pcap_sendpacket.argtypes = [POINTER(pcap_t), POINTER(u_char), c_int] +pcap_sendpacket.argtypes = [POINTER(pcap_t), c_void_p, c_int] + +#void pcap_dump (u_char *user, const struct pcap_pkthdr *h, const u_char *sp) +# Save a packet to disk. +pcap_dump = _lib.pcap_dump +pcap_dump.restype = None +pcap_dump.argtypes = [POINTER(pcap_dumper_t), POINTER(pcap_pkthdr), POINTER(u_char)] + +#long pcap_dump_ftell (pcap_dumper_t *) +# Return the file position for a "savefile". +pcap_dump_ftell = _lib.pcap_dump_ftell +pcap_dump_ftell.restype = c_long +pcap_dump_ftell.argtypes = [POINTER(pcap_dumper_t)] + +#int pcap_compile (pcap_t *p, struct bpf_program *fp, char *str, int optimize, bpf_u_int32 netmask) +# Compile a packet filter, converting an high level filtering expression (see Filtering expression syntax) in a program that can be interpreted by the kernel-level filtering engine. +pcap_compile = _lib.pcap_compile +pcap_compile.restype = c_int +pcap_compile.argtypes = [POINTER(pcap_t), POINTER(bpf_program), STRING, c_int, bpf_u_int32] + +#int pcap_compile_nopcap (int snaplen_arg, int linktype_arg, struct bpf_program *program, char *buf, int optimize, bpf_u_int32 mask) +# Compile a packet filter without the need of opening an adapter. This function converts an high level filtering expression (see Filtering expression syntax) in a program that can be interpreted by the kernel-level filtering engine. +pcap_compile_nopcap = _lib.pcap_compile_nopcap +pcap_compile_nopcap.restype = c_int +pcap_compile_nopcap.argtypes = [c_int, c_int, POINTER(bpf_program), STRING, c_int, bpf_u_int32] + +#int pcap_setfilter (pcap_t *p, struct bpf_program *fp) +# Associate a filter to a capture. +pcap_setfilter = _lib.pcap_setfilter +pcap_setfilter.restype = c_int +pcap_setfilter.argtypes = [POINTER(pcap_t), POINTER(bpf_program)] + +#void pcap_freecode (struct bpf_program *fp) +# Free a filter. +pcap_freecode = _lib.pcap_freecode +pcap_freecode.restype = None +pcap_freecode.argtypes = [POINTER(bpf_program)] + +#int pcap_datalink (pcap_t *p) +# Return the link layer of an adapter. +pcap_datalink = _lib.pcap_datalink +pcap_datalink.restype = c_int +pcap_datalink.argtypes = [POINTER(pcap_t)] + +#int pcap_list_datalinks (pcap_t *p, int **dlt_buf) +# list datalinks +pcap_list_datalinks = _lib.pcap_list_datalinks +pcap_list_datalinks.restype = c_int +#pcap_list_datalinks.argtypes = [POINTER(pcap_t), POINTER(POINTER(c_int))] + +#int pcap_set_datalink (pcap_t *p, int dlt) +# Set the current data link type of the pcap descriptor to the type specified by dlt. -1 is returned on failure. +pcap_set_datalink = _lib.pcap_set_datalink +pcap_set_datalink.restype = c_int +pcap_set_datalink.argtypes = [POINTER(pcap_t), c_int] + +#int pcap_datalink_name_to_val (const char *name) +# Translates a data link type name, which is a DLT_ name with the DLT_ removed, to the corresponding data link type value. The translation is case-insensitive. -1 is returned on failure. +pcap_datalink_name_to_val = _lib.pcap_datalink_name_to_val +pcap_datalink_name_to_val.restype = c_int +pcap_datalink_name_to_val.argtypes = [STRING] + +#const char * pcap_datalink_val_to_name (int dlt) +# Translates a data link type value to the corresponding data link type name. NULL is returned on failure. +pcap_datalink_val_to_name = _lib.pcap_datalink_val_to_name +pcap_datalink_val_to_name.restype = STRING +pcap_datalink_val_to_name.argtypes = [c_int] + +#const char * pcap_datalink_val_to_description (int dlt) +# Translates a data link type value to a short description of that data link type. NULL is returned on failure. +pcap_datalink_val_to_description = _lib.pcap_datalink_val_to_description +pcap_datalink_val_to_description.restype = STRING +pcap_datalink_val_to_description.argtypes = [c_int] + +#int pcap_snapshot (pcap_t *p) +# Return the dimension of the packet portion (in bytes) that is delivered to the application. +pcap_snapshot = _lib.pcap_snapshot +pcap_snapshot.restype = c_int +pcap_snapshot.argtypes = [POINTER(pcap_t)] + +#int pcap_is_swapped (pcap_t *p) +# returns true if the current savefile uses a different byte order than the current system. +pcap_is_swapped = _lib.pcap_is_swapped +pcap_is_swapped.restype = c_int +pcap_is_swapped.argtypes = [POINTER(pcap_t)] + +#int pcap_major_version (pcap_t *p) +# return the major version number of the pcap library used to write the savefile. +pcap_major_version = _lib.pcap_major_version +pcap_major_version.restype = c_int +pcap_major_version.argtypes = [POINTER(pcap_t)] + +#int pcap_minor_version (pcap_t *p) +# return the minor version number of the pcap library used to write the savefile. +pcap_minor_version = _lib.pcap_minor_version +pcap_minor_version.restype = c_int +pcap_minor_version.argtypes = [POINTER(pcap_t)] + +#FILE * pcap_file (pcap_t *p) +# Return the standard stream of an offline capture. +pcap_file=_lib.pcap_file +pcap_file.restype = FILE +pcap_file.argtypes = [POINTER(pcap_t)] + +#int pcap_stats (pcap_t *p, struct pcap_stat *ps) +# Return statistics on current capture. +pcap_stats = _lib.pcap_stats +pcap_stats.restype = c_int +pcap_stats.argtypes = [POINTER(pcap_t), POINTER(pcap_stat)] + +#void pcap_perror (pcap_t *p, char *prefix) +# print the text of the last pcap library error on stderr, prefixed by prefix. +pcap_perror = _lib.pcap_perror +pcap_perror.restype = None +pcap_perror.argtypes = [POINTER(pcap_t), STRING] + +#char * pcap_geterr (pcap_t *p) +# return the error text pertaining to the last pcap library error. +pcap_geterr = _lib.pcap_geterr +pcap_geterr.restype = STRING +pcap_geterr.argtypes = [POINTER(pcap_t)] + +#char * pcap_strerror (int error) +# Provided in case strerror() isn't available. +pcap_strerror = _lib.pcap_strerror +pcap_strerror.restype = STRING +pcap_strerror.argtypes = [c_int] + +#const char * pcap_lib_version (void) +# Returns a pointer to a string giving information about the version of the libpcap library being used; note that it contains more information than just a version number. +pcap_lib_version = _lib.pcap_lib_version +pcap_lib_version.restype = STRING +pcap_lib_version.argtypes = [] + +#void pcap_close (pcap_t *p) +# close the files associated with p and deallocates resources. +pcap_close = _lib.pcap_close +pcap_close.restype = None +pcap_close.argtypes = [POINTER(pcap_t)] + +#FILE * pcap_dump_file (pcap_dumper_t *p) +# return the standard I/O stream of the 'savefile' opened by pcap_dump_open(). +pcap_dump_file=_lib.pcap_dump_file +pcap_dump_file.restype=FILE +pcap_dump_file.argtypes= [POINTER(pcap_dumper_t)] + +#int pcap_dump_flush (pcap_dumper_t *p) +# Flushes the output buffer to the ``savefile,'' so that any packets written with pcap_dump() but not yet written to the ``savefile'' will be written. -1 is returned on error, 0 on success. +pcap_dump_flush = _lib.pcap_dump_flush +pcap_dump_flush.restype = c_int +pcap_dump_flush.argtypes = [POINTER(pcap_dumper_t)] + +#void pcap_dump_close (pcap_dumper_t *p) +# Closes a savefile. +pcap_dump_close = _lib.pcap_dump_close +pcap_dump_close.restype = None +pcap_dump_close.argtypes = [POINTER(pcap_dumper_t)] + +if not WIN32: + + pcap_get_selectable_fd = _lib.pcap_get_selectable_fd + pcap_get_selectable_fd.restype = c_int + pcap_get_selectable_fd.argtypes = [POINTER(pcap_t)] + +########################################### +## Windows-specific Extensions +## The functions in this section extend libpcap to offer advanced functionalities +## (like remote packet capture, packet buffer size variation or high-precision packet injection). +## Howerver, at the moment they can be used only in Windows. +########################################### +if WIN32: + HANDLE = c_void_p + + ############## + ## Identifiers related to the new source syntax + ############## + #define PCAP_SRC_FILE 2 + #define PCAP_SRC_IFLOCAL 3 + #define PCAP_SRC_IFREMOTE 4 + #Internal representation of the type of source in use (file, remote/local interface). + PCAP_SRC_FILE = 2 + PCAP_SRC_IFLOCAL = 3 + PCAP_SRC_IFREMOTE = 4 + + ############## + ## Strings related to the new source syntax + ############## + #define PCAP_SRC_FILE_STRING "file://" + #define PCAP_SRC_IF_STRING "rpcap://" + #String that will be used to determine the type of source in use (file, remote/local interface). + PCAP_SRC_FILE_STRING="file://" + PCAP_SRC_IF_STRING="rpcap://" + + ############## + ## Flags defined in the pcap_open() function + ############## + # define PCAP_OPENFLAG_PROMISCUOUS 1 + # Defines if the adapter has to go in promiscuous mode. + PCAP_OPENFLAG_PROMISCUOUS=1 + # define PCAP_OPENFLAG_DATATX_UDP 2 + # Defines if the data trasfer (in case of a remote capture) has to be done with UDP protocol. + PCAP_OPENFLAG_DATATX_UDP=2 + # define PCAP_OPENFLAG_NOCAPTURE_RPCAP 4 + PCAP_OPENFLAG_NOCAPTURE_RPCAP=4 + # Defines if the remote probe will capture its own generated traffic. + # define PCAP_OPENFLAG_NOCAPTURE_LOCAL 8 + PCAP_OPENFLAG_NOCAPTURE_LOCAL = 8 + # define PCAP_OPENFLAG_MAX_RESPONSIVENESS 16 + # This flag configures the adapter for maximum responsiveness. + PCAP_OPENFLAG_MAX_RESPONSIVENESS=16 + + ############## + ## Sampling methods defined in the pcap_setsampling() function + ############## + # define PCAP_SAMP_NOSAMP 0 + # No sampling has to be done on the current capture. + PCAP_SAMP_NOSAMP=0 + # define PCAP_SAMP_1_EVERY_N 1 + # It defines that only 1 out of N packets must be returned to the user. + PCAP_SAMP_1_EVERY_N=1 + #define PCAP_SAMP_FIRST_AFTER_N_MS 2 + # It defines that we have to return 1 packet every N milliseconds. + PCAP_SAMP_FIRST_AFTER_N_MS=2 + + ############## + ## Authentication methods supported by the RPCAP protocol + ############## + # define RPCAP_RMTAUTH_NULL 0 + # It defines the NULL authentication. + RPCAP_RMTAUTH_NULL=0 + # define RPCAP_RMTAUTH_PWD 1 + # It defines the username/password authentication. + RPCAP_RMTAUTH_PWD=1 + + + ############## + ## Remote struct and defines + ############## + # define PCAP_BUF_SIZE 1024 + # Defines the maximum buffer size in which address, port, interface names are kept. + PCAP_BUF_SIZE = 1024 + # define RPCAP_HOSTLIST_SIZE 1024 + # Maximum lenght of an host name (needed for the RPCAP active mode). + RPCAP_HOSTLIST_SIZE = 1024 + + class pcap_send_queue(Structure): + _fields_=[("maxlen",c_uint), + ("len",c_uint), + ("buffer",c_char_p)] + + ## struct pcap_rmtauth + ## This structure keeps the information needed to autheticate the user on a remote machine + class pcap_rmtauth(Structure): + _fields_=[("type",c_int), + ("username",c_char_p), + ("password",c_char_p)] + + ## struct pcap_samp + ## This structure defines the information related to sampling + class pcap_samp(Structure): + _fields_=[("method",c_int), + ("value",c_int)] + + #PAirpcapHandle pcap_get_airpcap_handle (pcap_t *p) + # Returns the AirPcap handler associated with an adapter. This handler can be used to change the wireless-related settings of the CACE Technologies AirPcap wireless capture adapters. + + #bool pcap_offline_filter (struct bpf_program *prog, const struct pcap_pkthdr *header, const u_char *pkt_data) + # Returns if a given filter applies to an offline packet. + pcap_offline_filter = _lib.pcap_offline_filter + pcap_offline_filter.restype = c_bool + pcap_offline_filter.argtypes = [POINTER(bpf_program),POINTER(pcap_pkthdr),POINTER(u_char)] + + #int pcap_live_dump (pcap_t *p, char *filename, int maxsize, int maxpacks) + # Save a capture to file. + pcap_live_dump = _lib.pcap_live_dump + pcap_live_dump.restype = c_int + pcap_live_dump.argtypes = [POINTER(pcap_t), POINTER(c_char), c_int,c_int] + + #int pcap_live_dump_ended (pcap_t *p, int sync) + # Return the status of the kernel dump process, i.e. tells if one of the limits defined with pcap_live_dump() has been reached. + pcap_live_dump_ended = _lib.pcap_live_dump_ended + pcap_live_dump_ended.restype = c_int + pcap_live_dump_ended.argtypes = [POINTER(pcap_t), c_int] + + #struct pcap_stat * pcap_stats_ex (pcap_t *p, int *pcap_stat_size) + # Return statistics on current capture. + pcap_stats_ex = _lib.pcap_stats_ex + pcap_stats_ex.restype = POINTER(pcap_stat) + pcap_stats_ex.argtypes = [POINTER(pcap_t), POINTER(c_int)] + + #int pcap_setbuff (pcap_t *p, int dim) + # Set the size of the kernel buffer associated with an adapter. + pcap_setbuff = _lib.pcap_setbuff + pcap_setbuff.restype = c_int + pcap_setbuff.argtypes = [POINTER(pcap_t), c_int] + + #int pcap_setmode (pcap_t *p, int mode) + # Set the working mode of the interface p to mode. + pcap_setmode = _lib.pcap_setmode + pcap_setmode.restype = c_int + pcap_setmode.argtypes = [POINTER(pcap_t), c_int] + + #int pcap_setmintocopy (pcap_t *p, int size) + # Set the minumum amount of data received by the kernel in a single call. + pcap_setmintocopy = _lib.pcap_setmintocopy + pcap_setmintocopy.restype = c_int + pcap_setmintocopy.argtype = [POINTER(pcap_t), c_int] + + #HANDLE pcap_getevent (pcap_t *p) + # Return the handle of the event associated with the interface p. + pcap_getevent = _lib.pcap_getevent + pcap_getevent.restype = HANDLE + pcap_getevent.argtypes = [POINTER(pcap_t)] + + #pcap_send_queue * pcap_sendqueue_alloc (u_int memsize) + # Allocate a send queue. + pcap_sendqueue_alloc = _lib.pcap_sendqueue_alloc + pcap_sendqueue_alloc.restype = POINTER(pcap_send_queue) + pcap_sendqueue_alloc.argtypes = [c_uint] + + #void pcap_sendqueue_destroy (pcap_send_queue *queue) + # Destroy a send queue. + pcap_sendqueue_destroy = _lib.pcap_sendqueue_destroy + pcap_sendqueue_destroy.restype = None + pcap_sendqueue_destroy.argtypes = [POINTER(pcap_send_queue)] + + #int pcap_sendqueue_queue (pcap_send_queue *queue, const struct pcap_pkthdr *pkt_header, const u_char *pkt_data) + # Add a packet to a send queue. + pcap_sendqueue_queue = _lib.pcap_sendqueue_queue + pcap_sendqueue_queue.restype = c_int + pcap_sendqueue_queue.argtypes = [POINTER(pcap_send_queue), POINTER(pcap_pkthdr), POINTER(u_char)] + + #u_int pcap_sendqueue_transmit (pcap_t *p, pcap_send_queue *queue, int sync) + # Send a queue of raw packets to the network. + pcap_sendqueue_transmit = _lib.pcap_sendqueue_transmit + pcap_sendqueue_transmit.retype = u_int + pcap_sendqueue_transmit.argtypes = [POINTER(pcap_t), POINTER(pcap_send_queue), c_int] + + #int pcap_findalldevs_ex (char *source, struct pcap_rmtauth *auth, pcap_if_t **alldevs, char *errbuf) + # Create a list of network devices that can be opened with pcap_open(). + pcap_findalldevs_ex = _lib.pcap_findalldevs_ex + pcap_findalldevs_ex.retype = c_int + pcap_findalldevs_ex.argtypes = [STRING, POINTER(pcap_rmtauth), POINTER(POINTER(pcap_if_t)), STRING] + + #int pcap_createsrcstr (char *source, int type, const char *host, const char *port, const char *name, char *errbuf) + # Accept a set of strings (host name, port, ...), and it returns the complete source string according to the new format (e.g. 'rpcap://1.2.3.4/eth0'). + pcap_createsrcstr = _lib.pcap_createsrcstr + pcap_createsrcstr.restype = c_int + pcap_createsrcstr.argtypes = [STRING, c_int, STRING, STRING, STRING, STRING] + + #int pcap_parsesrcstr (const char *source, int *type, char *host, char *port, char *name, char *errbuf) + # Parse the source string and returns the pieces in which the source can be split. + pcap_parsesrcstr = _lib.pcap_parsesrcstr + pcap_parsesrcstr.retype = c_int + pcap_parsesrcstr.argtypes = [STRING, POINTER(c_int), STRING, STRING, STRING, STRING] + + #pcap_t * pcap_open (const char *source, int snaplen, int flags, int read_timeout, struct pcap_rmtauth *auth, char *errbuf) + # Open a generic source in order to capture / send (WinPcap only) traffic. + pcap_open = _lib.pcap_open + pcap_open.restype = POINTER(pcap_t) + pcap_open.argtypes = [STRING, c_int, c_int, c_int, POINTER(pcap_rmtauth), STRING] + + #struct pcap_samp * pcap_setsampling (pcap_t *p) + # Define a sampling method for packet capture. + pcap_setsampling = _lib.pcap_setsampling + pcap_setsampling.restype = POINTER(pcap_samp) + pcap_setsampling.argtypes = [POINTER(pcap_t)] + + #SOCKET pcap_remoteact_accept (const char *address, const char *port, const char *hostlist, char *connectinghost, struct pcap_rmtauth *auth, char *errbuf) + # Block until a network connection is accepted (active mode only). + pcap_remoteact_accept = _lib.pcap_remoteact_accept + pcap_remoteact_accept.restype = SOCKET + pcap_remoteact_accept.argtypes = [STRING, STRING, STRING, STRING, POINTER(pcap_rmtauth), STRING] + + #int pcap_remoteact_close (const char *host, char *errbuf) + # Drop an active connection (active mode only). + pcap_remoteact_close = _lib.pcap_remoteact_close + pcap_remoteact_close.restypes = c_int + pcap_remoteact_close.argtypes = [STRING, STRING] + + #void pcap_remoteact_cleanup () + # Clean the socket that is currently used in waiting active connections. + pcap_remoteact_cleanup = _lib.pcap_remoteact_cleanup + pcap_remoteact_cleanup.restypes = None + pcap_remoteact_cleanup.argtypes = [] + + #int pcap_remoteact_list (char *hostlist, char sep, int size, char *errbuf) + # Return the hostname of the host that have an active connection with us (active mode only). + pcap_remoteact_list = _lib.pcap_remoteact_list + pcap_remoteact_list.restype = c_int + pcap_remoteact_list.argtypes = [STRING, c_char, c_int, STRING] diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/as_resolvers.py b/scripts/external_libs/scapy-python3-0.18/scapy/as_resolvers.py new file mode 100644 index 00000000..f04322b8 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/as_resolvers.py @@ -0,0 +1,115 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Resolve Autonomous Systems (AS). +""" + + +import socket +from .config import conf + +class AS_resolver: + server = None + options = "-k" + def __init__(self, server=None, port=43, options=None): + if server is not None: + self.server = server + self.port = port + if options is not None: + self.options = options + + def _start(self): + self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self.s.connect((self.server,self.port)) + if self.options: + self.s.send(self.options+b"\n") + self.s.recv(8192) + def _stop(self): + self.s.close() + + def _parse_whois(self, txt): + asn,desc = None,b"" + for l in txt.splitlines(): + if not asn and l.startswith(b"origin:"): + asn = l[7:].strip().decode('utf-8') + if l.startswith(b"descr:"): + if desc: + desc += br"\n" + desc += l[6:].strip() + if asn is not None and desc.strip(): + desc = desc.strip().decode('utf-8') + break + return asn, desc + + def _resolve_one(self, ip): + self.s.send(b"".join([ip.encode('ascii')])+b"\n") + x = b"" + while not (b"%" in x or b"source" in x): + x += self.s.recv(8192) + asn, desc = self._parse_whois(x) + return ip,asn,desc + def resolve(self, *ips): + self._start() + ret = [] + for ip in ips: + ip,asn,desc = self._resolve_one(ip) + if asn is not None: + ret.append((ip,asn,desc)) + self._stop() + return ret + +class AS_resolver_riswhois(AS_resolver): + server = "riswhois.ripe.net" + options = b"-k -M -1" + + +class AS_resolver_radb(AS_resolver): + server = "whois.ra.net" + options = b"-k -M" + + +class AS_resolver_cymru(AS_resolver): + server = "whois.cymru.com" + options = None + def resolve(self, *ips): + ASNlist = [] + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.connect((self.server,self.port)) + s.send(b"begin\r\n"+b"\r\n".join([ i.encode('ascii') for i in ips])+b"\r\nend\r\n") + r = b"" + while 1: + l = s.recv(8192) + if l == b"": + break + r += l + s.close() + for l in r.splitlines()[1:]: + if b"|" not in l: + continue + asn,ip,desc = [ i.decode('ascii') for i in map(bytes.strip, l.split(b"|")) ] + if asn == "NA": + continue + asn = int(asn) + ASNlist.append((ip,asn,desc)) + return ASNlist + +class AS_resolver_multi(AS_resolver): + resolvers_list = ( AS_resolver_cymru(),AS_resolver_riswhois(),AS_resolver_radb() ) + def __init__(self, *reslist): + if reslist: + self.resolvers_list = reslist + def resolve(self, *ips): + todo = ips + ret = [] + for ASres in self.resolvers_list: + res = ASres.resolve(*todo) + resolved = [ ip for ip,asn,desc in res ] + todo = [ ip for ip in todo if ip not in resolved ] + ret += res + return ret + + +conf.AS_resolver = AS_resolver_multi() diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/asn1/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/__init__.py new file mode 100644 index 00000000..4827a588 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/__init__.py @@ -0,0 +1,12 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Package holding ASN.1 related modules. +""" + +# We do not import mib.py because it is more bound to scapy and +# less prone to be used in a standalone fashion +__all__ = ["asn1","ber"] diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/asn1/asn1.py b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/asn1.py new file mode 100644 index 00000000..c94d0b12 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/asn1.py @@ -0,0 +1,321 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +ASN.1 (Abstract Syntax Notation One) +""" + +import random +from scapy.config import conf +from scapy.error import Scapy_Exception,warning +from scapy.volatile import RandField +from scapy.utils import Enum_metaclass, EnumElement + +class RandASN1Object(RandField): + def __init__(self, objlist=None): + if objlist is None: + objlist = [ x._asn1_obj for x in + [ x for x in ASN1_Class_UNIVERSAL.__rdict__.values() if hasattr(x,"_asn1_obj") ]] +# objlist = map(lambda x:x._asn1_obj, +# [ x for x in ASN1_Class_UNIVERSAL.__rdict__.values() if hasattr(x,"_asn1_obj") ]) + self.objlist = objlist + self.chars = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" + def _fix(self, n=0): + o = random.choice(self.objlist) + if issubclass(o, ASN1_INTEGER): + return o(int(random.gauss(0,1000))) + elif issubclass(o, ASN1_IPADDRESS): + z = RandIP()._fix() + return o(z) + elif issubclass(o, ASN1_STRING): + z = int(random.expovariate(0.05)+1) + return o(bytes([random.choice(self.chars) for i in range(z)])) + elif issubclass(o, ASN1_SEQUENCE) and (n < 10): + z = int(random.expovariate(0.08)+1) +# return o(map(lambda x:x._fix(n+1), [self.__class__(objlist=self.objlist)]*z)) + return o([ x._fix(n+1) for x in [self.__class__(objlist=self.objlist)]*z]) + return ASN1_INTEGER(int(random.gauss(0,1000))) + + +############## +#### ASN1 #### +############## + +class ASN1_Error(Scapy_Exception): + pass + +class ASN1_Encoding_Error(ASN1_Error): + pass + +class ASN1_Decoding_Error(ASN1_Error): + pass + +class ASN1_BadTag_Decoding_Error(ASN1_Decoding_Error): + pass + + + +class ASN1Codec(EnumElement): + def register_stem(cls, stem): + cls._stem = stem + def dec(cls, s, context=None): + return cls._stem.dec(s, context=context) + def safedec(cls, s, context=None): + return cls._stem.safedec(s, context=context) + def get_stem(cls): + return cls.stem + + +class ASN1_Codecs_metaclass(Enum_metaclass): + element_class = ASN1Codec + +class ASN1_Codecs(metaclass = ASN1_Codecs_metaclass): + #__metaclass__ = ASN1_Codecs_metaclass + BER = 1 + DER = 2 + PER = 3 + CER = 4 + LWER = 5 + BACnet = 6 + OER = 7 + SER = 8 + XER = 9 + +class ASN1Tag(EnumElement): + def __init__(self, key, value, context=None, codec=None): + EnumElement.__init__(self, key, value) + self._context = context + if codec == None: + codec = {} + self._codec = codec + def clone(self): # /!\ not a real deep copy. self.codec is shared + return self.__class__(self._key, self._value, self._context, self._codec) + def register_asn1_object(self, asn1obj): + self._asn1_obj = asn1obj + def asn1_object(self, val): + if hasattr(self,"_asn1_obj"): + return self._asn1_obj(val) + raise ASN1_Error("%r does not have any assigned ASN1 object" % self) + def register(self, codecnum, codec): + self._codec[codecnum] = codec + def get_codec(self, codec): + try: + c = self._codec[codec] + except KeyError as msg: + raise ASN1_Error("Codec %r not found for tag %r" % (codec, self)) + return c + +class ASN1_Class_metaclass(Enum_metaclass): + element_class = ASN1Tag + def __new__(cls, name, bases, dct): # XXX factorise a bit with Enum_metaclass.__new__() + for b in bases: + for k,v in b.__dict__.items(): + if k not in dct and isinstance(v,ASN1Tag): + dct[k] = v.clone() + + rdict = {} + for k,v in dct.items(): + if type(v) is int: + v = ASN1Tag(k,v) + dct[k] = v + rdict[v] = v + elif isinstance(v, ASN1Tag): + rdict[v] = v + dct["__rdict__"] = rdict + + cls = type.__new__(cls, name, bases, dct) + for v in cls.__dict__.values(): + if isinstance(v, ASN1Tag): + v.context = cls # overwrite ASN1Tag contexts, even cloned ones + return cls + + +class ASN1_Class(metaclass = ASN1_Class_metaclass): + pass + +class ASN1_Class_UNIVERSAL(ASN1_Class): + name = "UNIVERSAL" + ERROR = -3 + RAW = -2 + NONE = -1 + ANY = 0 + BOOLEAN = 1 + INTEGER = 2 + BIT_STRING = 3 + STRING = 4 + NULL = 5 + OID = 6 + OBJECT_DESCRIPTOR = 7 + EXTERNAL = 8 + REAL = 9 + ENUMERATED = 10 + EMBEDDED_PDF = 11 + UTF8_STRING = 12 + RELATIVE_OID = 13 + SEQUENCE = 0x30#XXX 16 ?? + SET = 0x31 #XXX 17 ?? + NUMERIC_STRING = 18 + PRINTABLE_STRING = 19 + T61_STRING = 20 + VIDEOTEX_STRING = 21 + IA5_STRING = 22 + UTC_TIME = 23 + GENERALIZED_TIME = 24 + GRAPHIC_STRING = 25 + ISO646_STRING = 26 + GENERAL_STRING = 27 + UNIVERSAL_STRING = 28 + CHAR_STRING = 29 + BMP_STRING = 30 + IPADDRESS = 0x40 + COUNTER32 = 0x41 + GAUGE32 = 0x42 + TIME_TICKS = 0x43 + SEP = 0x80 + +class ASN1_Object_metaclass(type): + def __new__(cls, name, bases, dct): + c = super(ASN1_Object_metaclass, cls).__new__(cls, name, bases, dct) + try: + c.tag.register_asn1_object(c) + except: + warning("Error registering %r for %r" % (c.tag, c.codec)) + return c + + +class ASN1_Object(metaclass = ASN1_Object_metaclass): + tag = ASN1_Class_UNIVERSAL.ANY + def __init__(self, val): + self.val = val + def enc(self, codec): + return self.tag.get_codec(codec).enc(self.val) + def __repr__(self): + return "<%s[%r]>" % (self.__dict__.get("name", self.__class__.__name__), self.val) + def __str__(self): + raise Exception("Should not get here") + #return self.enc(conf.ASN1_default_codec) + def __bytes__(self): + return self.enc(conf.ASN1_default_codec) + def strshow(self, lvl=0): + return (" "*lvl)+repr(self)+"\n" + def show(self, lvl=0): + print(self.strshow(lvl)) + def __eq__(self, other): + return self.val == other + def __hash__(self): + return self.val + def __cmp__(self, other): + return cmp(self.val, other) + +class ASN1_DECODING_ERROR(ASN1_Object): + tag = ASN1_Class_UNIVERSAL.ERROR + def __init__(self, val, exc=None): + ASN1_Object.__init__(self, val) + self.exc = exc + def __repr__(self): + return "<%s[%r]{{%s}}>" % (self.__dict__.get("name", self.__class__.__name__), + self.val, self.exc.args[0]) + def enc(self, codec): + if isinstance(self.val, ASN1_Object): + return self.val.enc(codec) + return self.val + +class ASN1_force(ASN1_Object): + tag = ASN1_Class_UNIVERSAL.RAW + def enc(self, codec): + if isinstance(self.val, ASN1_Object): + return self.val.enc(codec) + return self.val + +class ASN1_BADTAG(ASN1_force): + pass + +class ASN1_INTEGER(ASN1_Object): + tag = ASN1_Class_UNIVERSAL.INTEGER + +class ASN1_STRING(ASN1_Object): + tag = ASN1_Class_UNIVERSAL.STRING + def __init__(self, val): + if type(val) is str: + self.val = val.encode('ascii') + elif type(val) is bytes: + self.val = val + else: + raise Exception("Unknown value type for ASN1_STRING") + +class ASN1_BIT_STRING(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.BIT_STRING + +class ASN1_PRINTABLE_STRING(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.PRINTABLE_STRING + +class ASN1_T61_STRING(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.T61_STRING + +class ASN1_IA5_STRING(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.IA5_STRING + +class ASN1_NUMERIC_STRING(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.NUMERIC_STRING + +class ASN1_VIDEOTEX_STRING(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.VIDEOTEX_STRING + +class ASN1_IPADDRESS(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.IPADDRESS + +class ASN1_UTC_TIME(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.UTC_TIME + +class ASN1_GENERALIZED_TIME(ASN1_STRING): + tag = ASN1_Class_UNIVERSAL.GENERALIZED_TIME + +class ASN1_TIME_TICKS(ASN1_INTEGER): + tag = ASN1_Class_UNIVERSAL.TIME_TICKS + +class ASN1_BOOLEAN(ASN1_INTEGER): + tag = ASN1_Class_UNIVERSAL.BOOLEAN + +class ASN1_ENUMERATED(ASN1_INTEGER): + tag = ASN1_Class_UNIVERSAL.ENUMERATED + +class ASN1_NULL(ASN1_INTEGER): + tag = ASN1_Class_UNIVERSAL.NULL + +class ASN1_SEP(ASN1_NULL): + tag = ASN1_Class_UNIVERSAL.SEP + +class ASN1_GAUGE32(ASN1_INTEGER): + tag = ASN1_Class_UNIVERSAL.GAUGE32 + +class ASN1_COUNTER32(ASN1_INTEGER): + tag = ASN1_Class_UNIVERSAL.COUNTER32 + +class ASN1_SEQUENCE(ASN1_Object): + tag = ASN1_Class_UNIVERSAL.SEQUENCE + def strshow(self, lvl=0): + s = (" "*lvl)+("# %s:" % self.__class__.__name__)+"\n" + for o in self.val: + s += o.strshow(lvl=lvl+1) + return s + +class ASN1_SET(ASN1_SEQUENCE): + tag = ASN1_Class_UNIVERSAL.SET + +class ASN1_OID(ASN1_Object): + tag = ASN1_Class_UNIVERSAL.OID + def __init__(self, val): + if type(val) is str: + val = val.encode('ascii') + val = conf.mib._oid(val) + ASN1_Object.__init__(self, val) + def __repr__(self): + return "<%s[%r]>" % (self.__dict__.get("name", self.__class__.__name__), conf.mib._oidname(self.val)) + def __oidname__(self): + return '%s'%conf.mib._oidname(self.val) + + + +conf.ASN1_default_codec = ASN1_Codecs.BER diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/asn1/ber.py b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/ber.py new file mode 100644 index 00000000..48cb1c2d --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/ber.py @@ -0,0 +1,370 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Basic Encoding Rules (BER) for ASN.1 +""" + +from scapy.error import warning +from scapy.utils import inet_aton,inet_ntoa +from scapy.asn1.asn1 import ASN1_Decoding_Error,ASN1_Encoding_Error,ASN1_BadTag_Decoding_Error,ASN1_Codecs,ASN1_Class_UNIVERSAL,ASN1_Error,ASN1_DECODING_ERROR,ASN1_BADTAG + +################## +## BER encoding ## +################## + + + +#####[ BER tools ]##### + + +class BER_Exception(Exception): + pass + +class BER_Encoding_Error(ASN1_Encoding_Error): + def __init__(self, msg, encoded=None, remaining=None): + Exception.__init__(self, msg) + self.remaining = remaining + self.encoded = encoded + def __str__(self): + s = Exception.__str__(self) + if isinstance(self.encoded, BERcodec_Object): + s+="\n### Already encoded ###\n%s" % self.encoded.strshow() + else: + s+="\n### Already encoded ###\n%r" % self.encoded + s+="\n### Remaining ###\n%r" % self.remaining + return s + +class BER_Decoding_Error(ASN1_Decoding_Error): + def __init__(self, msg, decoded=None, remaining=None): + Exception.__init__(self, msg) + self.remaining = remaining + self.decoded = decoded + def __str__(self): + s = Exception.__str__(self) + if isinstance(self.decoded, BERcodec_Object): + s+="\n### Already decoded ###\n%s" % self.decoded.strshow() + else: + s+="\n### Already decoded ###\n%r" % self.decoded + s+="\n### Remaining ###\n%r" % self.remaining + return s + +class BER_BadTag_Decoding_Error(BER_Decoding_Error, ASN1_BadTag_Decoding_Error): + pass + +def BER_len_enc(l, size=0): + if l <= 127 and size==0: + return bytes([l]) + s = b"" + while l or size>0: + s = bytes([l&0xff])+s + l >>= 8 + size -= 1 + if len(s) > 127: + raise BER_Exception("BER_len_enc: Length too long (%i) to be encoded [%r]" % (len(s),s)) + return bytes([len(s)|0x80])+s +def BER_len_dec(s): + l = (s[0]) + if not l & 0x80: + return l,s[1:] + l &= 0x7f + if len(s) <= l: + raise BER_Decoding_Error("BER_len_dec: Got %i bytes while expecting %i" % (len(s)-1, l),remaining=s) + ll = 0 + for c in s[1:l+1]: + ll <<= 8 + ll |= (c) + return ll,s[l+1:] + +def BER_num_enc(l, size=1): + x=[] + while l or size>0: + x.insert(0, l & 0x7f) + if len(x) > 1: + x[0] |= 0x80 + l >>= 7 + size -= 1 + return bytes([(k) for k in x]) +def BER_num_dec(s): + x = 0 + for i in range(len(s)): + c = (s[i]) + x <<= 7 + x |= c&0x7f + if not c&0x80: + break + if c&0x80: + raise BER_Decoding_Error("BER_num_dec: unfinished number description", remaining=s) + return x, s[i+1:] + +#####[ BER classes ]##### + +class BERcodec_metaclass(type): + def __new__(cls, name, bases, dct): + c = super(BERcodec_metaclass, cls).__new__(cls, name, bases, dct) + try: + c.tag.register(c.codec, c) + except: + warning("Error registering %r for %r" % (c.tag, c.codec)) + return c + + +class BERcodec_Object( metaclass = BERcodec_metaclass): + codec = ASN1_Codecs.BER + tag = ASN1_Class_UNIVERSAL.ANY + + @classmethod + def asn1_object(cls, val): + return cls.tag.asn1_object(val) + + @classmethod + def check_string(cls, s): + if not s: + raise BER_Decoding_Error("%s: Got empty object while expecting tag %r" % + (cls.__name__,cls.tag), remaining=s) + @classmethod + def check_type(cls, s): + cls.check_string(s) + if hash(cls.tag) != (s[0]): + raise BER_BadTag_Decoding_Error("%s: Got tag [%i/%#x] while expecting %r" % + (cls.__name__, (s[0]), (s[0]),cls.tag), remaining=s) + return s[1:] + @classmethod + def check_type_get_len(cls, s): + s2 = cls.check_type(s) + if not s2: + raise BER_Decoding_Error("%s: No bytes while expecting a length" % + cls.__name__, remaining=s) + return BER_len_dec(s2) + @classmethod + def check_type_check_len(cls, s): + l,s3 = cls.check_type_get_len(s) + if len(s3) < l: + raise BER_Decoding_Error("%s: Got %i bytes while expecting %i" % + (cls.__name__, len(s3), l), remaining=s) + return l,s3[:l],s3[l:] + + @classmethod + def do_dec(cls, s, context=None, safe=False): + if context is None: + context = cls.tag.context + cls.check_string(s) + p = (s[0]) + if p not in context: + t = s + if len(t) > 18: + t = t[:15]+"..." + raise BER_Decoding_Error("Unknown prefix [%02x] for [%r]" % (p,t), remaining=s) + codec = context[p].get_codec(ASN1_Codecs.BER) + return codec.dec(s,context,safe) + + @classmethod + def dec(cls, s, context=None, safe=False): + if not safe: + return cls.do_dec(s, context, safe) + try: + return cls.do_dec(s, context, safe) + except BER_BadTag_Decoding_Error as e: + o,remain = BERcodec_Object.dec(e.remaining, context, safe) + return ASN1_BADTAG(o),remain + except BER_Decoding_Error as e: + return ASN1_DECODING_ERROR(s, exc=e),"" + except ASN1_Error as e: + return ASN1_DECODING_ERROR(s, exc=e),"" + + @classmethod + def safedec(cls, s, context=None): + return cls.dec(s, context, safe=True) + + + @classmethod + def enc(cls, s): + if type(s) is str: + return BERcodec_STRING.enc(s) + #TODO3 wild guess + elif type(s) is bytes: + return BERcodec_STRING.enc(s) + else: + return BERcodec_INTEGER.enc(hash(s)) + + + +ASN1_Codecs.BER.register_stem(BERcodec_Object) + + +class BERcodec_INTEGER(BERcodec_Object): + tag = ASN1_Class_UNIVERSAL.INTEGER + @classmethod + def enc(cls, i): + s = [] + while 1: + s.append(i&0xff) + if -127 <= i < 0: + break + if 128 <= i <= 255: + s.append(0) + i >>= 8 + if not i: + break + #s = map(chr, s) + s = bytes(s) + BER_len_enc(len(s)) + bytes([hash(cls.tag)]) + #s.reverse() + #return b"".join(s) + return s[::-1] + @classmethod + def do_dec(cls, s, context=None, safe=False): + l,s,t = cls.check_type_check_len(s) + x = 0 + if s: + if (s[0])&0x80: # negative int + x = -1 + for c in s: + x <<= 8 + x |= (c) + return cls.asn1_object(x),t + + +class BERcodec_BOOLEAN(BERcodec_INTEGER): + tag = ASN1_Class_UNIVERSAL.BOOLEAN + +class BERcodec_ENUMERATED(BERcodec_INTEGER): + tag = ASN1_Class_UNIVERSAL.ENUMERATED + +class BERcodec_NULL(BERcodec_INTEGER): + tag = ASN1_Class_UNIVERSAL.NULL + @classmethod + def enc(cls, i): + if i == 0: + return bytes([hash(cls.tag)])+b"\0" + else: + return BERcodec_INTEGER.enc(i) + +class BERcodec_SEP(BERcodec_NULL): + tag = ASN1_Class_UNIVERSAL.SEP + +class BERcodec_STRING(BERcodec_Object): + tag = ASN1_Class_UNIVERSAL.STRING + @classmethod + def enc(cls,s): + if type(s) is str: + s = s.encode('ascii') + return bytes([hash(cls.tag)])+BER_len_enc(len(s))+s + @classmethod + def do_dec(cls, s, context=None, safe=False): + l,s,t = cls.check_type_check_len(s) + return cls.tag.asn1_object(s),t + +class BERcodec_BIT_STRING(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.BIT_STRING + +class BERcodec_PRINTABLE_STRING(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.PRINTABLE_STRING + +class BERcodec_T61_STRING (BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.T61_STRING + +class BERcodec_IA5_STRING(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.IA5_STRING + +class BERcodec_NUMERIC_STRING(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.NUMERIC_STRING + +class BERcodec_VIDEOTEX_STRING(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.VIDEOTEX_STRING + +class BERcodec_IPADDRESS(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.IPADDRESS + + @classmethod + def enc(cls, ipaddr_ascii): + try: + s = inet_aton(ipaddr_ascii) + except Exception: + raise BER_Encoding_Error("IPv4 address could not be encoded") + return bytes([hash(cls.tag)])+BER_len_enc(len(s))+s + + @classmethod + def do_dec(cls, s, context=None, safe=False): + l,s,t = cls.check_type_check_len(s) + try: + ipaddr_ascii = inet_ntoa(s) + except Exception: + raise BER_Decoding_Error("IP address could not be decoded", decoded=obj) + return cls.asn1_object(ipaddr_ascii), t + +class BERcodec_UTC_TIME(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.UTC_TIME + +class BERcodec_GENERALIZED_TIME(BERcodec_STRING): + tag = ASN1_Class_UNIVERSAL.GENERALIZED_TIME + +class BERcodec_TIME_TICKS(BERcodec_INTEGER): + tag = ASN1_Class_UNIVERSAL.TIME_TICKS + +class BERcodec_GAUGE32(BERcodec_INTEGER): + tag = ASN1_Class_UNIVERSAL.GAUGE32 + +class BERcodec_COUNTER32(BERcodec_INTEGER): + tag = ASN1_Class_UNIVERSAL.COUNTER32 + +class BERcodec_SEQUENCE(BERcodec_Object): + tag = ASN1_Class_UNIVERSAL.SEQUENCE + @classmethod + def enc(cls, l): + #if type(l) is not str: + if type(l) is not bytes: + l = b"".join(map(lambda x: x.enc(cls.codec), l)) + return bytes([hash(cls.tag)])+BER_len_enc(len(l))+l + @classmethod + def do_dec(cls, s, context=None, safe=False): + if context is None: + context = cls.tag.context + l,st = cls.check_type_get_len(s) # we may have len(s) < l + s,t = st[:l],st[l:] + obj = [] + while s: + try: + o,s = BERcodec_Object.dec(s, context, safe) + except BER_Decoding_Error as err: + err.remaining += t + if err.decoded is not None: + obj.append(err.decoded) + err.decoded = obj + raise + obj.append(o) + if len(st) < l: + raise BER_Decoding_Error("Not enough bytes to decode sequence", decoded=obj) + return cls.asn1_object(obj),t + +class BERcodec_SET(BERcodec_SEQUENCE): + tag = ASN1_Class_UNIVERSAL.SET + + +class BERcodec_OID(BERcodec_Object): + tag = ASN1_Class_UNIVERSAL.OID + + @classmethod + def enc(cls, oid): + if type(oid) is str: + oid = oid.encode('ascii') + lst = [int(x) for x in oid.strip(b".").split(b".")] + if len(lst) >= 2: + lst[1] += 40*lst[0] + del(lst[0]) + s = b"".join([BER_num_enc(k) for k in lst]) + return bytes([hash(cls.tag)])+BER_len_enc(len(s))+s + @classmethod + def do_dec(cls, s, context=None, safe=False): + l,s,t = cls.check_type_check_len(s) + lst = [] + while s: + l,s = BER_num_dec(s) + lst.append(l) + if (len(lst) > 0): + lst.insert(0,lst[0]//40) + lst[1] %= 40 + return cls.asn1_object(b".".join([str(k).encode('ascii') for k in lst])), t + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/asn1/mib.py b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/mib.py new file mode 100644 index 00000000..8f3df25c --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/asn1/mib.py @@ -0,0 +1,149 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Management Information Base (MIB) parsing +""" + +import re +from glob import glob +from scapy.dadict import DADict,fixname +from scapy.config import conf +from scapy.utils import do_graph + +################# +## MIB parsing ## +################# + +_mib_re_integer = re.compile(b"^[0-9]+$") +_mib_re_both = re.compile(b"^([a-zA-Z_][a-zA-Z0-9_-]*)\(([0-9]+)\)$") +_mib_re_oiddecl = re.compile(b"$\s*([a-zA-Z0-9_-]+)\s+OBJECT([^:\{\}]|\{[^:]+\})+::=\s*\{([^\}]+)\}",re.M) +_mib_re_strings = re.compile(b'"[^"]*"') +_mib_re_comments = re.compile(b'--.*(\r|\n)') + +class MIBDict(DADict): + def _findroot(self, x): + if x.startswith(b"."): + x = x[1:] + if not x.endswith(b"."): + x += b"." + max=0 + root=b"." + for k in self.keys(): + if x.startswith(self[k]+b"."): + if max < len(self[k]): + max = len(self[k]) + root = k + return root, x[max:-1] + def _oidname(self, x): + root,remainder = self._findroot(x) + return root+remainder + def _oid(self, x): + if type(x) is str: + x = x.encode('ascii') + xl = x.strip(b".").split(b".") + p = len(xl)-1 + while p >= 0 and _mib_re_integer.match(xl[p]): + p -= 1 + if p != 0 or xl[p] not in self: + return x + xl[p] = self[xl[p]] + return b".".join(xl[p:]) + def _make_graph(self, other_keys=[], **kargs): + nodes = [(k,self[k]) for k in self.keys()] + oids = [self[k] for k in self.keys()] + for k in other_keys: + if k not in oids: + nodes.append(self.oidname(k),k) + s = 'digraph "mib" {\n\trankdir=LR;\n\n' + for k,o in nodes: + s += '\t"%s" [ label="%s" ];\n' % (o,k) + s += "\n" + for k,o in nodes: + parent,remainder = self._findroot(o[:-1]) + remainder = remainder[1:]+o[-1] + if parent != ".": + parent = self[parent] + s += '\t"%s" -> "%s" [label="%s"];\n' % (parent, o,remainder) + s += "}\n" + do_graph(s, **kargs) + def __len__(self): + return len(self.keys()) + + +def mib_register(ident, value, the_mib, unresolved): + if ident in the_mib or ident in unresolved: + return ident in the_mib + resval = [] + not_resolved = 0 + for v in value: + if _mib_re_integer.match(v): + resval.append(v) + else: + v = fixname(v) + if v not in the_mib: + not_resolved = 1 + if v in the_mib: + v = the_mib[v] + elif v in unresolved: + v = unresolved[v] + if type(v) is list: + resval += v + else: + resval.append(v) + if not_resolved: + unresolved[ident] = resval + return False + else: + the_mib[ident] = resval + keys = unresolved.keys() + i = 0 + while i < len(keys): + k = keys[i] + if mib_register(k,unresolved[k], the_mib, {}): + del(unresolved[k]) + del(keys[i]) + i = 0 + else: + i += 1 + + return True + + +def load_mib(filenames): + the_mib = {'iso': ['1']} + unresolved = {} + for k in conf.mib.keys(): + mib_register(k, conf.mib[k].split("."), the_mib, unresolved) + + if type(filenames) is str: + filenames = [filenames] + for fnames in filenames: + for fname in glob(fnames): + f = open(fname) + text = f.read() + cleantext = " ".join(_mib_re_strings.split(" ".join(_mib_re_comments.split(text)))) + for m in _mib_re_oiddecl.finditer(cleantext): + gr = m.groups() + ident,oid = gr[0],gr[-1] + ident=fixname(ident) + oid = oid.split() + for i in range(len(oid)): + m = _mib_re_both.match(oid[i]) + if m: + oid[i] = m.groups()[1] + mib_register(ident, oid, the_mib, unresolved) + + newmib = MIBDict(_name="MIB") + for k,o in the_mib.items(): + newmib[k]=".".join(o) + for k,o in unresolved.items(): + newmib[k]=".".join(o) + + conf.mib=newmib + + + +conf.mib = MIBDict(_name="MIB") diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/asn1fields.py b/scripts/external_libs/scapy-python3-0.18/scapy/asn1fields.py new file mode 100644 index 00000000..e7165a83 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/asn1fields.py @@ -0,0 +1,341 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Classes that implement ASN.1 data structures. +""" + +import itertools +from scapy.asn1.asn1 import * +from scapy.asn1.ber import * +from scapy.volatile import * +from scapy.base_classes import BasePacket + + +##################### +#### ASN1 Fields #### +##################### + +class ASN1F_badsequence(Exception): + pass + +class ASN1F_element: + pass + +class ASN1F_optionnal(ASN1F_element): + def __init__(self, field): + self._field=field + def __getattr__(self, attr): + return getattr(self._field,attr) + def dissect(self,pkt,s): + try: + return self._field.dissect(pkt,s) + except ASN1F_badsequence: + self._field.set_val(pkt,None) + return s + except BER_Decoding_Error: + self._field.set_val(pkt,None) + return s + def build(self, pkt): + if self._field.is_empty(pkt): + return b"" + return self._field.build(pkt) + +class ASN1F_field(ASN1F_element): + holds_packets=0 + islist=0 + + ASN1_tag = ASN1_Class_UNIVERSAL.ANY + context=ASN1_Class_UNIVERSAL + + def __init__(self, name, default, context=None): + if context is not None: + self.context = context + self.name = name + self.default = default + + def i2repr(self, pkt, x): + return repr(x) + def i2h(self, pkt, x): + return x + def any2i(self, pkt, x): + return x + def m2i(self, pkt, x): + return self.ASN1_tag.get_codec(pkt.ASN1_codec).safedec(x, context=self.context) + def i2m(self, pkt, x): + if x is None: + x = 0 + if isinstance(x, ASN1_Object): + if ( self.ASN1_tag == ASN1_Class_UNIVERSAL.ANY + or x.tag == ASN1_Class_UNIVERSAL.RAW + or x.tag == ASN1_Class_UNIVERSAL.ERROR + or self.ASN1_tag == x.tag ): + return x.enc(pkt.ASN1_codec) + else: + raise ASN1_Error("Encoding Error: got %r instead of an %r for field [%s]" % (x, self.ASN1_tag, self.name)) + return self.ASN1_tag.get_codec(pkt.ASN1_codec).enc(x) + + def do_copy(self, x): + if hasattr(x, "copy"): + return x.copy() + if type(x) is list: + x = x[:] + for i in range(len(x)): + if isinstance(x[i], BasePacket): + x[i] = x[i].copy() + return x + + def build(self, pkt): + return self.i2m(pkt, getattr(pkt, self.name)) + + def set_val(self, pkt, val): + setattr(pkt, self.name, val) + def is_empty(self, pkt): + return getattr(pkt,self.name) is None + + def dissect(self, pkt, s): + v,s = self.m2i(pkt, s) + self.set_val(pkt, v) + return s + + def get_fields_list(self): + return [self] + + def __hash__(self): + return hash(self.name) + def __str__(self): + return self.name + def __eq__(self, other): + return self.name == other + def __repr__(self): + return self.name + def randval(self): + return RandInt() + + +class ASN1F_INTEGER(ASN1F_field): + ASN1_tag= ASN1_Class_UNIVERSAL.INTEGER + def randval(self): + return RandNum(-2**64, 2**64-1) + +class ASN1F_BOOLEAN(ASN1F_field): + ASN1_tag= ASN1_Class_UNIVERSAL.BOOLEAN + def randval(self): + return RandChoice(True,False) + +class ASN1F_NULL(ASN1F_INTEGER): + ASN1_tag= ASN1_Class_UNIVERSAL.NULL + +class ASN1F_SEP(ASN1F_NULL): + ASN1_tag= ASN1_Class_UNIVERSAL.SEP + +class ASN1F_enum_INTEGER(ASN1F_INTEGER): + def __init__(self, name, default, enum): + ASN1F_INTEGER.__init__(self, name, default) + i2s = self.i2s = {} + s2i = self.s2i = {} + if type(enum) is list: + keys = range(len(enum)) + else: + keys = enum.keys() + #if filter(lambda x: type(x) is str, keys): + if list(filter(lambda x: type(x) is str, keys)): + i2s,s2i = s2i,i2s + for k in keys: + i2s[k] = enum[k] + s2i[enum[k]] = k + def any2i_one(self, pkt, x): + if type(x) is str: + x = self.s2i[x] + return x + def i2repr_one(self, pkt, x): + return self.i2s.get(x, repr(x)) + + def any2i(self, pkt, x): + if type(x) is list: + return map(lambda z,pkt=pkt:self.any2i_one(pkt,z), x) + else: + return self.any2i_one(pkt,x) + def i2repr(self, pkt, x): + if type(x) is list: + return map(lambda z,pkt=pkt:self.i2repr_one(pkt,z), x) + else: + return self.i2repr_one(pkt,x) + +class ASN1F_ENUMERATED(ASN1F_enum_INTEGER): + ASN1_tag = ASN1_Class_UNIVERSAL.ENUMERATED + +class ASN1F_STRING(ASN1F_field): + ASN1_tag = ASN1_Class_UNIVERSAL.STRING + def randval(self): + return RandString(RandNum(0, 1000)) + +class ASN1F_PRINTABLE_STRING(ASN1F_STRING): + ASN1_tag = ASN1_Class_UNIVERSAL.PRINTABLE_STRING + +class ASN1F_BIT_STRING(ASN1F_STRING): + ASN1_tag = ASN1_Class_UNIVERSAL.BIT_STRING + +class ASN1F_IPADDRESS(ASN1F_STRING): + ASN1_tag = ASN1_Class_UNIVERSAL.IPADDRESS + +class ASN1F_TIME_TICKS(ASN1F_INTEGER): + ASN1_tag = ASN1_Class_UNIVERSAL.TIME_TICKS + +class ASN1F_UTC_TIME(ASN1F_STRING): + ASN1_tag = ASN1_Class_UNIVERSAL.UTC_TIME + +class ASN1F_GENERALIZED_TIME(ASN1F_STRING): + ASN1_tag = ASN1_Class_UNIVERSAL.GENERALIZED_TIME + +class ASN1F_OID(ASN1F_field): + ASN1_tag = ASN1_Class_UNIVERSAL.OID + def randval(self): + return RandOID() + +class ASN1F_SEQUENCE(ASN1F_field): + ASN1_tag = ASN1_Class_UNIVERSAL.SEQUENCE + def __init__(self, *seq, **kargs): + if "ASN1_tag" in kargs: + self.ASN1_tag = kargs["ASN1_tag"] + self.seq = seq + def __repr__(self): + return "<%s%r>" % (self.__class__.__name__,self.seq,) + def set_val(self, pkt, val): + for f in self.seq: + f.set_val(pkt,val) + def is_empty(self, pkt): + for f in self.seq: + if not f.is_empty(pkt): + return False + return True + def get_fields_list(self): + #return reduce(lambda x,y: x+y.get_fields_list(), self.seq, []) + return list(itertools.chain(*[ i.get_fields_list() for i in self.seq ])) + def build(self, pkt): + #s = reduce(lambda x,y: x+y.build(pkt), self.seq, b"") + s = b"" + for i in self.seq: + s += i.build(pkt) + return self.i2m(pkt, s) + def dissect(self, pkt, s): + codec = self.ASN1_tag.get_codec(pkt.ASN1_codec) + try: + i,s,remain = codec.check_type_check_len(s) + for obj in self.seq: + s = obj.dissect(pkt,s) + if s: + warning("Too many bytes to decode sequence: [%r]" % s) # XXX not reversible! + return remain + except ASN1_Error as e: + raise ASN1F_badsequence(e) + +class ASN1F_SET(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_UNIVERSAL.SET + +class ASN1F_SEQUENCE_OF(ASN1F_SEQUENCE): + holds_packets = 1 + islist = 1 + def __init__(self, name, default, asn1pkt, ASN1_tag=0x30): + self.asn1pkt = asn1pkt + self.tag = bytes([ASN1_tag]) + self.name = name + self.default = default + def i2repr(self, pkt, i): + if i is None: + return [] + return i + def get_fields_list(self): + return [self] + def set_val(self, pkt, val): + ASN1F_field.set_val(self, pkt, val) + def is_empty(self, pkt): + return ASN1F_field.is_empty(self, pkt) + def build(self, pkt): + val = getattr(pkt, self.name) + if isinstance(val, ASN1_Object) and val.tag == ASN1_Class_UNIVERSAL.RAW: + s = val + elif val is None: + s = b"" + else: + #print(val) + #s = b"".join(map(str, val )) + s = b"".join([ bytes(i) for i in val ]) + return self.i2m(pkt, s) + def dissect(self, pkt, s): + codec = self.ASN1_tag.get_codec(pkt.ASN1_codec) + i,s1,remain = codec.check_type_check_len(s) + lst = [] + while s1: + try: + p = self.asn1pkt(s1) + except ASN1F_badsequence as e: + lst.append(conf.raw_layer(s1)) + break + lst.append(p) + if conf.raw_layer in p: + s1 = p[conf.raw_layer].load + del(p[conf.raw_layer].underlayer.payload) + else: + break + self.set_val(pkt, lst) + return remain + def randval(self): + return fuzz(self.asn1pkt()) + def __repr__(self): + return "<%s %s>" % (self.__class__.__name__,self.name) + +class ASN1F_PACKET(ASN1F_field): + holds_packets = 1 + def __init__(self, name, default, cls): + ASN1F_field.__init__(self, name, default) + self.cls = cls + def i2m(self, pkt, x): + if x is None: + x = b"" + return bytes(x) + def extract_packet(self, cls, x): + try: + c = cls(x) + except ASN1F_badsequence: + c = conf.raw_layer(x) + cpad = c.getlayer(conf.padding_layer) + x = b"" + if cpad is not None: + x = cpad.load + del(cpad.underlayer.payload) + return c,x + def m2i(self, pkt, x): + return self.extract_packet(self.cls, x) + + +class ASN1F_CHOICE(ASN1F_PACKET): + ASN1_tag = ASN1_Class_UNIVERSAL.NONE + def __init__(self, name, default, *args): + self.name=name + self.choice = {} + for p in args: + self.choice[p.ASN1_root.ASN1_tag] = p +# self.context=context + self.default=default + def m2i(self, pkt, x): + if len(x) == 0: + return conf.raw_layer(),b"" + raise ASN1_Error("ASN1F_CHOICE: got empty string") + #if ord(x[0]) not in self.choice: + if (x[0]) not in self.choice: + return conf.raw_layer(x),b"" # XXX return RawASN1 packet ? Raise error + #raise ASN1_Error("Decoding Error: choice [%i] not found in %r" % (ord(x[0]), self.choice.keys())) + raise ASN1_Error("Decoding Error: choice [%i] not found in %r" % ((x[0]), self.choice.keys())) + + #z = ASN1F_PACKET.extract_packet(self, self.choice[ord(x[0])], x) + z = ASN1F_PACKET.extract_packet(self, self.choice[(x[0])], x) + return z + def randval(self): + return RandChoice(*map(lambda x:fuzz(x()), self.choice.values())) + + +# This import must come in last to avoid problems with cyclic dependencies +import scapy.packet diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/asn1packet.py b/scripts/external_libs/scapy-python3-0.18/scapy/asn1packet.py new file mode 100644 index 00000000..049e2b75 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/asn1packet.py @@ -0,0 +1,26 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Packet holding data in Abstract Syntax Notation (ASN.1). +""" + +from scapy.packet import * + +class ASN1_Packet(Packet): + ASN1_root = None + ASN1_codec = None + def init_fields(self): + flist = self.ASN1_root.get_fields_list() + self.do_init_fields(flist) + self.fields_desc = flist + def self_build(self): + if self.raw_packet_cache is not None: + return self.raw_packet_cache + return self.ASN1_root.build(self) + def do_dissect(self, x): + return self.ASN1_root.dissect(self, x) + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/automaton.py b/scripts/external_libs/scapy-python3-0.18/scapy/automaton.py new file mode 100644 index 00000000..cd32b5c0 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/automaton.py @@ -0,0 +1,753 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Automata with states, transitions and actions. +""" + +from __future__ import with_statement +import types,itertools,time,os,sys,socket,functools +from select import select +from collections import deque +import _thread +from .config import conf +from .utils import do_graph +from .error import log_interactive +from .plist import PacketList +from .data import MTU +from .supersocket import SuperSocket + +class ObjectPipe: + def __init__(self): + self.rd,self.wr = os.pipe() + self.queue = deque() + def fileno(self): + return self.rd + def send(self, obj): + self.queue.append(obj) + os.write(self.wr,b"X") + def recv(self, n=0): + os.read(self.rd,1) + return self.queue.popleft() + + +class Message: + def __init__(self, **args): + self.__dict__.update(args) + def __repr__(self): + return "<Message %s>" % " ".join("%s=%r"%(k,v) + for (k,v) in self.__dict__.items() + if not k.startswith("_")) + +# Currently does not seem necessary +# class _meta_instance_state(type): +# def __init__(cls, name, bases, dct): +# def special_gen(special_method): +# def special_wrapper(self): +# print("Calling %s" % special_method) +# return getattr(getattr(self, "im_func"), special_method) +# return special_wrapper + +# type.__init__(cls, name, bases, dct) +# for i in ["__int__", "__repr__", "__str__", "__index__", "__add__", "__radd__", "__bytes__"]: +# setattr(cls, i, property(special_gen(i))) + +class _instance_state(): + def __init__(self, instance): + self.im_self = instance.__self__ + self.im_func = instance.__func__ + self.im_class = instance.__self__.__class__ + def __getattr__(self, attr): + return getattr(self.im_func, attr) + + def __call__(self, *args, **kargs): + return self.im_func(self.im_self, *args, **kargs) + def breaks(self): + return self.im_self.add_breakpoints(self.im_func) + def intercepts(self): + return self.im_self.add_interception_points(self.im_func) + def unbreaks(self): + return self.im_self.remove_breakpoints(self.im_func) + def unintercepts(self): + return self.im_self.remove_interception_points(self.im_func) + + +############## +## Automata ## +############## + +class ATMT: + STATE = "State" + ACTION = "Action" + CONDITION = "Condition" + RECV = "Receive condition" + TIMEOUT = "Timeout condition" + IOEVENT = "I/O event" + + class NewStateRequested(Exception): + def __init__(self, state_func, automaton, *args, **kargs): + self.func = state_func + self.state = state_func.atmt_state + self.initial = state_func.atmt_initial + self.error = state_func.atmt_error + self.final = state_func.atmt_final + Exception.__init__(self, "Request state [%s]" % self.state) + self.automaton = automaton + self.args = args + self.kargs = kargs + self.action_parameters() # init action parameters + def action_parameters(self, *args, **kargs): + self.action_args = args + self.action_kargs = kargs + return self + def run(self): + return self.func(self.automaton, *self.args, **self.kargs) + def __repr__(self): + return "NewStateRequested(%s)" % self.state + + @staticmethod + def state(initial=0,final=0,error=0): + def deco(f,initial=initial, final=final): + f.atmt_type = ATMT.STATE + f.atmt_state = f.__name__ + f.atmt_initial = initial + f.atmt_final = final + f.atmt_error = error +# @functools.wraps(f) This is possible alternative to assigning __qualname__; it would save __doc__, too + def state_wrapper(self, *args, **kargs): + return ATMT.NewStateRequested(f, self, *args, **kargs) + + state_wrapper.__qualname__ = "%s_wrapper" % f.__name__ + state_wrapper.atmt_type = ATMT.STATE + state_wrapper.atmt_state = f.__name__ + state_wrapper.atmt_initial = initial + state_wrapper.atmt_final = final + state_wrapper.atmt_error = error + state_wrapper.atmt_origfunc = f + return state_wrapper + return deco + @staticmethod + def action(cond, prio=0): + def deco(f,cond=cond): + if not hasattr(f,"atmt_type"): + f.atmt_cond = {} + f.atmt_type = ATMT.ACTION + f.atmt_cond[cond.atmt_condname] = prio + return f + return deco + @staticmethod + def condition(state, prio=0): + def deco(f, state=state): + f.atmt_type = ATMT.CONDITION + f.atmt_state = state.atmt_state + f.atmt_condname = f.__name__ + f.atmt_prio = prio + return f + return deco + @staticmethod + def receive_condition(state, prio=0): + def deco(f, state=state): + f.atmt_type = ATMT.RECV + f.atmt_state = state.atmt_state + f.atmt_condname = f.__name__ + f.atmt_prio = prio + return f + return deco + @staticmethod + def ioevent(state, name, prio=0, as_supersocket=None): + def deco(f, state=state): + f.atmt_type = ATMT.IOEVENT + f.atmt_state = state.atmt_state + f.atmt_condname = f.__name__ + f.atmt_ioname = name + f.atmt_prio = prio + f.atmt_as_supersocket = as_supersocket + return f + return deco + @staticmethod + def timeout(state, timeout): + def deco(f, state=state, timeout=timeout): + f.atmt_type = ATMT.TIMEOUT + f.atmt_state = state.atmt_state + f.atmt_timeout = timeout + f.atmt_condname = f.__name__ + return f + return deco + +class _ATMT_Command: + RUN = "RUN" + NEXT = "NEXT" + FREEZE = "FREEZE" + STOP = "STOP" + END = "END" + EXCEPTION = "EXCEPTION" + SINGLESTEP = "SINGLESTEP" + BREAKPOINT = "BREAKPOINT" + INTERCEPT = "INTERCEPT" + ACCEPT = "ACCEPT" + REPLACE = "REPLACE" + REJECT = "REJECT" + +class _ATMT_supersocket(SuperSocket): + def __init__(self, name, ioevent, automaton, proto, args, kargs): + self.name = name + self.ioevent = ioevent + self.proto = proto + self.spa,self.spb = socket.socketpair(socket.AF_UNIX, socket.SOCK_DGRAM) + kargs["external_fd"] = {ioevent:self.spb} + self.atmt = automaton(*args, **kargs) + self.atmt.runbg() + def fileno(self): + return self.spa.fileno() + def send(self, s): + if type(s) is str: + s = s.encode() + elif type(s) is not bytes: + s = bytes(s) + return self.spa.send(s) + def recv(self, n=MTU): + r = self.spa.recv(n) + if self.proto is not None: + r = self.proto(r) + return r + def close(self): + pass + +class _ATMT_to_supersocket: + def __init__(self, name, ioevent, automaton): + self.name = name + self.ioevent = ioevent + self.automaton = automaton + def __call__(self, proto, *args, **kargs): + return _ATMT_supersocket(self.name, self.ioevent, self.automaton, proto, args, kargs) + +class Automaton_metaclass(type): + def __new__(cls, name, bases, dct): + cls = super(Automaton_metaclass, cls).__new__(cls, name, bases, dct) + cls.states={} + cls.state = None + cls.recv_conditions={} + cls.conditions={} + cls.ioevents={} + cls.timeout={} + cls.actions={} + cls.initial_states=[] + cls.ionames = [] + cls.iosupersockets = [] + + members = {} + classes = [cls] + while classes: + c = classes.pop(0) # order is important to avoid breaking method overloading + classes += list(c.__bases__) + for k,v in c.__dict__.items(): + if k not in members: + members[k] = v + + decorated = [v for v in members.values() + if type(v) is types.FunctionType and hasattr(v, "atmt_type")] + + for m in decorated: + if m.atmt_type == ATMT.STATE: + s = m.atmt_state + cls.states[s] = m + cls.recv_conditions[s]=[] + cls.ioevents[s]=[] + cls.conditions[s]=[] + cls.timeout[s]=[] + if m.atmt_initial: + cls.initial_states.append(m) + elif m.atmt_type in [ATMT.CONDITION, ATMT.RECV, ATMT.TIMEOUT, ATMT.IOEVENT]: + cls.actions[m.atmt_condname] = [] + + for m in decorated: + if m.atmt_type == ATMT.CONDITION: + cls.conditions[m.atmt_state].append(m) + elif m.atmt_type == ATMT.RECV: + cls.recv_conditions[m.atmt_state].append(m) + elif m.atmt_type == ATMT.IOEVENT: + cls.ioevents[m.atmt_state].append(m) + cls.ionames.append(m.atmt_ioname) + if m.atmt_as_supersocket is not None: + cls.iosupersockets.append(m) + elif m.atmt_type == ATMT.TIMEOUT: + cls.timeout[m.atmt_state].append((m.atmt_timeout, m)) + elif m.atmt_type == ATMT.ACTION: + for c in m.atmt_cond: + cls.actions[c].append(m) + + + for v in cls.timeout.values(): + #v.sort(lambda (t1,f1),(t2,f2): cmp(t1,t2)) + v.sort(key = lambda x: x[0]) + v.append((None, None)) + for v in itertools.chain(cls.conditions.values(), + cls.recv_conditions.values(), + cls.ioevents.values()): + v.sort(key = lambda x: x.atmt_prio) + for condname,actlst in cls.actions.items(): + actlst.sort(key = lambda x: x.atmt_cond[condname]) + + for ioev in cls.iosupersockets: + setattr(cls, ioev.atmt_as_supersocket, _ATMT_to_supersocket(ioev.atmt_as_supersocket, ioev.atmt_ioname, cls)) + + return cls + + def graph(self, **kargs): + s = 'digraph "%s" {\n' % self.__class__.__name__ + + se = "" # Keep initial nodes at the begining for better rendering + for st in self.states.values(): + if st.atmt_initial: + se = ('\t"%s" [ style=filled, fillcolor=blue, shape=box, root=true];\n' % st.atmt_state)+se + elif st.atmt_final: + se += '\t"%s" [ style=filled, fillcolor=green, shape=octagon ];\n' % st.atmt_state + elif st.atmt_error: + se += '\t"%s" [ style=filled, fillcolor=red, shape=octagon ];\n' % st.atmt_state + s += se + + for st in self.states.values(): + for n in st.atmt_origfunc.__code__.co_names+st.atmt_origfunc.__code__.co_consts: + if n in self.states: + s += '\t"%s" -> "%s" [ color=green ];\n' % (st.atmt_state,n) + + + for c,k,v in ([("purple",k,v) for k,v in self.conditions.items()]+ + [("red",k,v) for k,v in self.recv_conditions.items()]+ + [("orange",k,v) for k,v in self.ioevents.items()]): + for f in v: + for n in f.__code__.co_names+f.__code__.co_consts: + if n in self.states: + l = f.atmt_condname + for x in self.actions[f.atmt_condname]: + l += "\\l>[%s]" % x.__name__ + s += '\t"%s" -> "%s" [label="%s", color=%s];\n' % (k,n,l,c) + for k,v in self.timeout.items(): + for t,f in v: + if f is None: + continue + for n in f.__code__.co_names+f.__code__.co_consts: + if n in self.states: + l = "%s/%.1fs" % (f.atmt_condname,t) + for x in self.actions[f.atmt_condname]: + l += "\\l>[%s]" % x.__name__ + s += '\t"%s" -> "%s" [label="%s",color=blue];\n' % (k,n,l) + s += "}\n" + return do_graph(s, **kargs) + + + +class Automaton(metaclass = Automaton_metaclass): + + ## Methods to overload + def parse_args(self, debug=0, store=1, **kargs): + self.debug_level=debug + self.socket_kargs = kargs + self.store_packets = store + + def master_filter(self, pkt): + return True + + def my_send(self, pkt): + self.send_sock.send(pkt) + + + ## Utility classes and exceptions + class _IO_fdwrapper: + def __init__(self,rd,wr): + if rd is not None and type(rd) is not int: + rd = rd.fileno() + if wr is not None and type(wr) is not int: + wr = wr.fileno() + self.rd = rd + self.wr = wr + def fileno(self): + return self.rd + def read(self, n=65535): + return os.read(self.rd, n) + def write(self, msg): + return os.write(self.wr,msg) + def recv(self, n=65535): + return self.read(n) + def send(self, msg): + return self.write(msg) + + class _IO_mixer: + def __init__(self,rd,wr): + self.rd = rd + self.wr = wr + def fileno(self): + if type(self.rd) is int: + return self.rd + return self.rd.fileno() + def recv(self, n=None): + return self.rd.recv(n) + def read(self, n=None): + return self.rd.recv(n) + def send(self, msg): + return self.wr.send(msg) + def write(self, msg): + return self.wr.send(msg) + + + class AutomatonException(Exception): + def __init__(self, msg, state=None, result=None): + Exception.__init__(self, msg) + self.state = state + self.result = result + + class AutomatonError(AutomatonException): + pass + class ErrorState(AutomatonException): + pass + class Stuck(AutomatonException): + pass + class AutomatonStopped(AutomatonException): + pass + + class Breakpoint(AutomatonStopped): + pass + class Singlestep(AutomatonStopped): + pass + class InterceptionPoint(AutomatonStopped): + def __init__(self, msg, state=None, result=None, packet=None): + Automaton.AutomatonStopped.__init__(self, msg, state=state, result=result) + self.packet = packet + + class CommandMessage(AutomatonException): + pass + + + ## Services + def debug(self, lvl, msg): + if self.debug_level >= lvl: + log_interactive.debug(msg) + + def send(self, pkt): + if self.state.state in self.interception_points: + self.debug(3,"INTERCEPT: packet intercepted: %s" % pkt.summary()) + self.intercepted_packet = pkt + cmd = Message(type = _ATMT_Command.INTERCEPT, state=self.state, pkt=pkt) + self.cmdout.send(cmd) + cmd = self.cmdin.recv() + self.intercepted_packet = None + if cmd.type == _ATMT_Command.REJECT: + self.debug(3,"INTERCEPT: packet rejected") + return + elif cmd.type == _ATMT_Command.REPLACE: + pkt = cmd.pkt + self.debug(3,"INTERCEPT: packet replaced by: %s" % pkt.summary()) + elif cmd.type == _ATMT_Command.ACCEPT: + self.debug(3,"INTERCEPT: packet accepted") + else: + raise self.AutomatonError("INTERCEPT: unkown verdict: %r" % cmd.type) + self.my_send(pkt) + self.debug(3,"SENT : %s" % pkt.summary()) + self.packets.append(pkt.copy()) + + + ## Internals + def __init__(self, *args, **kargs): + external_fd = kargs.pop("external_fd",{}) + self.send_sock_class = kargs.pop("ll", conf.L3socket) + self.started = _thread.allocate_lock() + self.threadid = None + self.breakpointed = None + self.breakpoints = set() + self.interception_points = set() + self.intercepted_packet = None + self.debug_level=0 + self.init_args=args + self.init_kargs=kargs + self.io = type.__new__(type, "IOnamespace",(),{}) + self.oi = type.__new__(type, "IOnamespace",(),{}) + self.cmdin = ObjectPipe() + self.cmdout = ObjectPipe() + self.ioin = {} + self.ioout = {} + for n in self.ionames: + extfd = external_fd.get(n) + if type(extfd) is not tuple: + extfd = (extfd,extfd) + ioin,ioout = extfd + if ioin is None: + ioin = ObjectPipe() + #elif type(ioin) is not types.InstanceType: + else: + #print(type(ioin)) + ioin = self._IO_fdwrapper(ioin,None) + if ioout is None: + ioout = ObjectPipe() + #elif type(ioout) is not types.InstanceType: + else: + #print(type(ioout)) + ioout = self._IO_fdwrapper(None,ioout) + + self.ioin[n] = ioin + self.ioout[n] = ioout + ioin.ioname = n + ioout.ioname = n + setattr(self.io, n, self._IO_mixer(ioout,ioin)) + setattr(self.oi, n, self._IO_mixer(ioin,ioout)) + + for stname in self.states: + setattr(self, stname, + _instance_state(getattr(self, stname))) + + self.parse_args(*args, **kargs) + + self.start() + + def __iter__(self): + return self + + def __del__(self): + self.stop() + + def _run_condition(self, cond, *args, **kargs): + try: + self.debug(5, "Trying %s [%s]" % (cond.atmt_type, cond.atmt_condname)) + cond(self,*args, **kargs) + except ATMT.NewStateRequested as state_req: + self.debug(2, "%s [%s] taken to state [%s]" % (cond.atmt_type, cond.atmt_condname, state_req.state)) + if cond.atmt_type == ATMT.RECV: + self.packets.append(args[0]) + for action in self.actions[cond.atmt_condname]: + self.debug(2, " + Running action [%s]" % action.__name__) + action(self, *state_req.action_args, **state_req.action_kargs) + raise + except Exception as e: + self.debug(2, "%s [%s] raised exception [%s]" % (cond.atmt_type, cond.atmt_condname, e)) + raise + else: + self.debug(2, "%s [%s] not taken" % (cond.atmt_type, cond.atmt_condname)) + + def _do_start(self, *args, **kargs): + + _thread.start_new_thread(self._do_control, args, kargs) + + + def _do_control(self, *args, **kargs): + with self.started: + self.threadid = _thread.get_ident() + + # Update default parameters + a = args+self.init_args[len(args):] + k = self.init_kargs.copy() + k.update(kargs) + self.parse_args(*a,**k) + + # Start the automaton + self.state=self.initial_states[0](self) + self.send_sock = self.send_sock_class() + self.listen_sock = conf.L2listen(**self.socket_kargs) + self.packets = PacketList(name="session[%s]"%self.__class__.__name__) + + singlestep = True + iterator = self._do_iter() + self.debug(3, "Starting control thread [tid=%i]" % self.threadid) + try: + while True: + c = self.cmdin.recv() + self.debug(5, "Received command %s" % c.type) + if c.type == _ATMT_Command.RUN: + singlestep = False + elif c.type == _ATMT_Command.NEXT: + singlestep = True + elif c.type == _ATMT_Command.FREEZE: + continue + elif c.type == _ATMT_Command.STOP: + break + while True: + state = next(iterator) + if isinstance(state, self.CommandMessage): + break + elif isinstance(state, self.Breakpoint): + c = Message(type=_ATMT_Command.BREAKPOINT,state=state) + self.cmdout.send(c) + break + if singlestep: + c = Message(type=_ATMT_Command.SINGLESTEP,state=state) + self.cmdout.send(c) + break + except StopIteration as e: + c = Message(type=_ATMT_Command.END, result=e.args[0]) + self.cmdout.send(c) + except Exception as e: + self.debug(3, "Transfering exception [%s] from tid=%i"% (e,self.threadid)) + m = Message(type = _ATMT_Command.EXCEPTION, exception=e, exc_info=sys.exc_info()) + self.cmdout.send(m) + self.debug(3, "Stopping control thread (tid=%i)"%self.threadid) + self.threadid = None + + def _do_iter(self): + while True: + try: + self.debug(1, "## state=[%s]" % self.state.state) + + # Entering a new state. First, call new state function + if self.state.state in self.breakpoints and self.state.state != self.breakpointed: + self.breakpointed = self.state.state + yield self.Breakpoint("breakpoint triggered on state %s" % self.state.state, + state = self.state.state) + self.breakpointed = None + state_output = self.state.run() + if self.state.error: + raise self.ErrorState("Reached %s: [%r]" % (self.state.state, state_output), + result=state_output, state=self.state.state) + if self.state.final: + raise StopIteration(state_output) + + if state_output is None: + state_output = () + elif type(state_output) is not list: + state_output = state_output, + + # Then check immediate conditions + for cond in self.conditions[self.state.state]: + self._run_condition(cond, *state_output) + + # If still there and no conditions left, we are stuck! + if ( len(self.recv_conditions[self.state.state]) == 0 and + len(self.ioevents[self.state.state]) == 0 and + len(self.timeout[self.state.state]) == 1 ): + raise self.Stuck("stuck in [%s]" % self.state.state, + state=self.state.state, result=state_output) + + # Finally listen and pay attention to timeouts + expirations = iter(self.timeout[self.state.state]) + next_timeout,timeout_func = next(expirations) + t0 = time.time() + + fds = [self.cmdin] + if len(self.recv_conditions[self.state.state]) > 0: + fds.append(self.listen_sock) + for ioev in self.ioevents[self.state.state]: + fds.append(self.ioin[ioev.atmt_ioname]) + while 1: + t = time.time()-t0 + if next_timeout is not None: + if next_timeout <= t: + self._run_condition(timeout_func, *state_output) + next_timeout,timeout_func = next(expirations) + if next_timeout is None: + remain = None + else: + remain = next_timeout-t + + self.debug(5, "Select on %r" % fds) + r,_,_ = select(fds,[],[],remain) + self.debug(5, "Selected %r" % r) + for fd in r: + self.debug(5, "Looking at %r" % fd) + if fd == self.cmdin: + yield self.CommandMessage("Received command message") + elif fd == self.listen_sock: + pkt = self.listen_sock.recv(MTU) + if pkt is not None: + if self.master_filter(pkt): + self.debug(3, "RECVD: %s" % pkt.summary()) + for rcvcond in self.recv_conditions[self.state.state]: + self._run_condition(rcvcond, pkt, *state_output) + else: + self.debug(4, "FILTR: %s" % pkt.summary()) + else: + self.debug(3, "IOEVENT on %s" % fd.ioname) + for ioevt in self.ioevents[self.state.state]: + if ioevt.atmt_ioname == fd.ioname: + self._run_condition(ioevt, fd, *state_output) + + except ATMT.NewStateRequested as state_req: + self.debug(2, "switching from [%s] to [%s]" % (self.state.state,state_req.state)) + self.state = state_req + yield state_req + + ## Public API + def add_interception_points(self, *ipts): + for ipt in ipts: + if hasattr(ipt,"atmt_state"): + ipt = ipt.atmt_state + self.interception_points.add(ipt) + + def remove_interception_points(self, *ipts): + for ipt in ipts: + if hasattr(ipt,"atmt_state"): + ipt = ipt.atmt_state + self.interception_points.discard(ipt) + + def add_breakpoints(self, *bps): + for bp in bps: + if hasattr(bp,"atmt_state"): + bp = bp.atmt_state + self.breakpoints.add(bp) + + def remove_breakpoints(self, *bps): + for bp in bps: + if hasattr(bp,"atmt_state"): + bp = bp.atmt_state + self.breakpoints.discard(bp) + + def start(self, *args, **kargs): + if not self.started.locked(): + self._do_start(*args, **kargs) + + def run(self, resume=None, wait=True): + if resume is None: + resume = Message(type = _ATMT_Command.RUN) + self.cmdin.send(resume) + if wait: + try: + c = self.cmdout.recv() + except KeyboardInterrupt: + self.cmdin.send(Message(type = _ATMT_Command.FREEZE)) + return + if c.type == _ATMT_Command.END: + return c.result + elif c.type == _ATMT_Command.INTERCEPT: + raise self.InterceptionPoint("packet intercepted", state=c.state.state, packet=c.pkt) + elif c.type == _ATMT_Command.SINGLESTEP: + raise self.Singlestep("singlestep state=[%s]"%c.state.state, state=c.state.state) + elif c.type == _ATMT_Command.BREAKPOINT: + raise self.Breakpoint("breakpoint triggered on state [%s]"%c.state.state, state=c.state.state) + elif c.type == _ATMT_Command.EXCEPTION: + raise c.exc_info[0](c.exc_info[1]) + #raise c.exc_info[0],c.exc_info[1],c.exc_info[2] + + def runbg(self, resume=None, wait=False): + self.run(resume, wait) + + def next(self): + return self.run(resume = Message(type=_ATMT_Command.NEXT)) + + def stop(self): + self.cmdin.send(Message(type=_ATMT_Command.STOP)) + with self.started: + # Flush command pipes + while True: + r,_,_ = select([self.cmdin, self.cmdout],[],[],0) + if not r: + break + for fd in r: + fd.recv() + + def restart(self, *args, **kargs): + self.stop() + self.start(*args, **kargs) + + def accept_packet(self, pkt=None, wait=False): + rsm = Message() + if pkt is None: + rsm.type = _ATMT_Command.ACCEPT + else: + rsm.type = _ATMT_Command.REPLACE + rsm.pkt = pkt + return self.run(resume=rsm, wait=wait) + + def reject_packet(self, wait=False): + rsm = Message(type = _ATMT_Command.REJECT) + return self.run(resume=rsm, wait=wait) + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/autorun.py b/scripts/external_libs/scapy-python3-0.18/scapy/autorun.py new file mode 100644 index 00000000..063d93dc --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/autorun.py @@ -0,0 +1,142 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Run commands when the Scapy interpreter starts. +""" + +import code,sys +from .config import conf +from .themes import * +from .error import Scapy_Exception +from .utils import tex_escape + + +######################### +##### Autorun stuff ##### +######################### + +class StopAutorun(Scapy_Exception): + code_run = "" + +class ScapyAutorunInterpreter(code.InteractiveInterpreter): + def __init__(self, *args, **kargs): + code.InteractiveInterpreter.__init__(self, *args, **kargs) + self.error = 0 + def showsyntaxerror(self, *args, **kargs): + self.error = 1 + return code.InteractiveInterpreter.showsyntaxerror(self, *args, **kargs) + def showtraceback(self, *args, **kargs): + self.error = 1 + exc_type, exc_value, exc_tb = sys.exc_info() + if isinstance(exc_value, StopAutorun): + raise exc_value + return code.InteractiveInterpreter.showtraceback(self, *args, **kargs) + + +def autorun_commands(cmds,my_globals=None,verb=0): + sv = conf.verb + import builtins + try: + try: + if my_globals is None: + my_globals = __import__("scapy.all").all.__dict__ + conf.verb = verb + interp = ScapyAutorunInterpreter(my_globals) + cmd = "" + cmds = cmds.splitlines() + cmds.append("") # ensure we finish multiline commands + cmds.reverse() + builtins.__dict__["_"] = None + while 1: + if cmd: + sys.stderr.write(sys.__dict__.get("ps2","... ")) + else: + sys.stderr.write(str(sys.__dict__.get("ps1",ColorPrompt()))) + + l = cmds.pop() + print(l) + cmd += "\n"+l + if interp.runsource(cmd): + continue + if interp.error: + return 0 + cmd = "" + if len(cmds) <= 1: + break + except SystemExit: + pass + finally: + conf.verb = sv + return _ + +def autorun_get_interactive_session(cmds, **kargs): + class StringWriter: + def __init__(self): + self.s = "" + def write(self, x): + self.s += x + + sw = StringWriter() + sstdout,sstderr = sys.stdout,sys.stderr + try: + try: + sys.stdout = sys.stderr = sw + res = autorun_commands(cmds, **kargs) + except StopAutorun as e: + e.code_run = sw.s + raise + finally: + sys.stdout,sys.stderr = sstdout,sstderr + return sw.s,res + +def autorun_get_text_interactive_session(cmds, **kargs): + ct = conf.color_theme + try: + conf.color_theme = NoTheme() + s,res = autorun_get_interactive_session(cmds, **kargs) + finally: + conf.color_theme = ct + return s,res + +def autorun_get_ansi_interactive_session(cmds, **kargs): + ct = conf.color_theme + try: + conf.color_theme = DefaultTheme() + s,res = autorun_get_interactive_session(cmds, **kargs) + finally: + conf.color_theme = ct + return s,res + +def autorun_get_html_interactive_session(cmds, **kargs): + ct = conf.color_theme + to_html = lambda s: s.replace("<","<").replace(">",">").replace("#[#","<").replace("#]#",">") + try: + try: + conf.color_theme = HTMLTheme2() + s,res = autorun_get_interactive_session(cmds, **kargs) + except StopAutorun as e: + e.code_run = to_html(e.code_run) + raise + finally: + conf.color_theme = ct + + return to_html(s),res + +def autorun_get_latex_interactive_session(cmds, **kargs): + ct = conf.color_theme + to_latex = lambda s: tex_escape(s).replace("@[@","{").replace("@]@","}").replace("@`@","\\") + try: + try: + conf.color_theme = LatexTheme2() + s,res = autorun_get_interactive_session(cmds, **kargs) + except StopAutorun as e: + e.code_run = to_latex(e.code_run) + raise + finally: + conf.color_theme = ct + return to_latex(s),res + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/base_classes.py b/scripts/external_libs/scapy-python3-0.18/scapy/base_classes.py new file mode 100644 index 00000000..bace90d6 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/base_classes.py @@ -0,0 +1,237 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Generators and packet meta classes. +""" + +############### +## Generators ## +################ + +import re,random,socket +from types import GeneratorType +import scapy.config +from . import error + +class Gen(object): + def __iter__(self): + return iter([]) + +class SetGen(Gen): + def __init__(self, col, _iterpacket=1): + self._iterpacket=_iterpacket + if type(col) is list or isinstance(col, GeneratorType): + self.col = col + elif isinstance(col, BasePacketList): + self.col = list(col) + else: + self.col = [col] + # DEPRECATED + # def transf(self, element): + # return element + def __iter__(self): + for i in self.col: + if (type(i) is tuple) and (len(i) == 2) and type(i[0]) is int and type(i[1]) is int: + if (i[0] <= i[1]): + j=i[0] + while j <= i[1]: + yield j + j += 1 + elif isinstance(i, Gen) and (self._iterpacket or not isinstance(i,BasePacket)): + for j in i: + yield j + else: + yield i + def __repr__(self): + return "<SetGen %s>" % self.col.__repr__() + +class Net(Gen): + """Generate a list of IPs from a network address or a name""" + name = "ip" + ipaddress = re.compile(r"^(\*|[0-2]?[0-9]?[0-9](-[0-2]?[0-9]?[0-9])?)\.(\*|[0-2]?[0-9]?[0-9](-[0-2]?[0-9]?[0-9])?)\.(\*|[0-2]?[0-9]?[0-9](-[0-2]?[0-9]?[0-9])?)\.(\*|[0-2]?[0-9]?[0-9](-[0-2]?[0-9]?[0-9])?)(/[0-3]?[0-9])?$") + + @staticmethod + def _parse_digit(a,netmask): + netmask = min(8,max(netmask,0)) + if a == "*": + a = (0,256) + elif a.find("-") >= 0: + x,y = map(int,a.split("-")) + if x > y: + y = x + a = (x & (0xff<<netmask) , max(y, (x | (0xff>>(8-netmask))))+1) + else: + a = (int(a) & (0xff<<netmask),(int(a) | (0xff>>(8-netmask)))+1) + return a + + @classmethod + def _parse_net(cls, net): + tmp=net.split('/')+["32"] + if not cls.ipaddress.match(net): + tmp[0]=socket.gethostbyname(tmp[0]) + netmask = int(tmp[1]) + #return map(lambda x,y: cls._parse_digit(x,y), tmp[0].split("."), map(lambda x,nm=netmask: x-nm, (8,16,24,32))),netmask + return list(map(lambda x,y: cls._parse_digit(x,y), tmp[0].split("."), [ i - netmask for i in (8,16,24,32)] )),netmask + + def __init__(self, net): + self.repr=net + self.parsed,self.netmask = self._parse_net(net) + + def __iter__(self): + for d in range(*self.parsed[3]): + for c in range(*self.parsed[2]): + for b in range(*self.parsed[1]): + for a in range(*self.parsed[0]): + yield "%i.%i.%i.%i" % (a,b,c,d) + def choice(self): + ip = [] + for v in self.parsed: + ip.append(str(random.randint(v[0],v[1]-1))) + return ".".join(ip) + + def __repr__(self): + return "Net(%r)" % self.repr + def __eq__(self, other): + if hasattr(other, "parsed"): + p2 = other.parsed + else: + p2,nm2 = self._parse_net(other) + return self.parsed == p2 + def __contains__(self, other): + if hasattr(other, "parsed"): + p2 = other.parsed + else: + p2,nm2 = self._parse_net(other) + for (a1,b1),(a2,b2) in zip(self.parsed,p2): + if a1 > a2 or b1 < b2: + return False + return True + def __rcontains__(self, other): + return self in self.__class__(other) + + +class OID(Gen): + name = "OID" + def __init__(self, oid): + self.oid = oid + self.cmpt = [] + fmt = [] + for i in oid.split("."): + if "-" in i: + fmt.append("%i") + self.cmpt.append(tuple(map(int, i.split("-")))) + else: + fmt.append(i) + self.fmt = ".".join(fmt) + def __repr__(self): + return "OID(%r)" % self.oid + def __iter__(self): + ii = [k[0] for k in self.cmpt] + while 1: + yield self.fmt % tuple(ii) + i = 0 + while 1: + if i >= len(ii): + raise StopIteration + if ii[i] < self.cmpt[i][1]: + ii[i]+=1 + break + else: + ii[i] = self.cmpt[i][0] + i += 1 + + + +###################################### +## Packet abstract and base classes ## +###################################### + +class Packet_metaclass(type): + def __new__(cls, name, bases, dct): + if "fields_desc" in dct: # perform resolution of references to other packets + current_fld = dct["fields_desc"] + resolved_fld = [] + for f in current_fld: + if isinstance(f, Packet_metaclass): # reference to another fields_desc + for f2 in f.fields_desc: + resolved_fld.append(f2) + else: + resolved_fld.append(f) + else: # look for a field_desc in parent classes + resolved_fld = None + for b in bases: + if hasattr(b,"fields_desc"): + resolved_fld = b.fields_desc + break + + if resolved_fld: # perform default value replacements + final_fld = [] + for f in resolved_fld: + if f.name in dct: + f = f.copy() + f.default = dct[f.name] + del(dct[f.name]) + final_fld.append(f) + + dct["fields_desc"] = final_fld + + newcls = super(Packet_metaclass, cls).__new__(cls, name, bases, dct) + if hasattr(newcls,"register_variant"): + newcls.register_variant() + for f in newcls.fields_desc: + f.register_owner(newcls) + scapy.config.conf.layers.register(newcls) + return newcls + + def __getattr__(self, attr): + for k in self.fields_desc: + if k.name == attr: + return k + raise AttributeError(attr) + + def __call__(cls, *args, **kargs): + if "dispatch_hook" in cls.__dict__: + cls = cls.dispatch_hook(*args, **kargs) + i = cls.__new__(cls, cls.__name__, cls.__bases__, cls.__dict__) + i.__init__(*args, **kargs) + return i + + +class NewDefaultValues(Packet_metaclass): + """NewDefaultValues is deprecated (not needed anymore) + + remove this: + __metaclass__ = NewDefaultValues + and it should still work. + """ + def __new__(cls, name, bases, dct): + from error import log_loading + import traceback + try: + for tb in traceback.extract_stack()+[("??",-1,None,"")]: + f,l,_,line = tb + if line.startswith("class"): + break + except: + f,l="??",-1 + raise + log_loading.warning("Deprecated (no more needed) use of NewDefaultValues (%s l. %i)." % (f,l)) + + return super(NewDefaultValues, cls).__new__(cls, name, bases, dct) + +class BasePacket(Gen): + pass + + +############################# +## Packet list base classe ## +############################# + +class BasePacketList: + pass + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/config.py b/scripts/external_libs/scapy-python3-0.18/scapy/config.py new file mode 100644 index 00000000..88c324f8 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/config.py @@ -0,0 +1,394 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Implementation for of the configuration object. +""" + +import os,time,socket,sys +from .data import * +import scapy.base_classes +import scapy.themes +from .error import log_scapy + +############ +## Config ## +############ + +class ConfClass(object): + def configure(self, cnf): + self.__dict__ = cnf.__dict__.copy() + def __repr__(self): + return str(self) + def __str__(self): + s="" + keys = self.__class__.__dict__.copy() + keys.update(self.__dict__) + keys = list(keys.keys()) + keys.sort() + for i in keys: + if i[0] != "_": + r = repr(getattr(self, i)) + r = " ".join(r.split()) + wlen = 76-max(len(i),10) + if len(r) > wlen: + r = r[:wlen-3]+"..." + s += "%-10s = %s\n" % (i, r) + return s[:-1] + +class Interceptor(object): + def __init__(self, name, default, hook, args=None, kargs=None): + self.name = name + self.intname = "_intercepted_%s" % name + self.default=default + self.hook = hook + self.args = args if args is not None else [] + self.kargs = kargs if kargs is not None else {} + def __get__(self, obj, typ=None): + if not hasattr(obj, self.intname): + setattr(obj, self.intname, self.default) + return getattr(obj, self.intname) + def __set__(self, obj, val): + setattr(obj, self.intname, val) + self.hook(self.name, val, *self.args, **self.kargs) + + +class ProgPath(ConfClass): + pdfreader = "acroread" + psreader = "gv" + dot = "dot" + display = "display" + tcpdump = "tcpdump" + tcpreplay = "tcpreplay" + hexedit = "hexedit" + wireshark = "wireshark" + + +class ConfigFieldList: + def __init__(self): + self.fields = set() + self.layers = set() + @staticmethod + def _is_field(f): + return hasattr(f, "owners") + def _recalc_layer_list(self): + self.layers = set([owner for f in self.fields for owner in f.owners]) + def add(self, *flds): + self.fields |= set([f for f in flds if self._is_field(f)]) + self._recalc_layer_list() + def remove(self, *flds): + self.fields -= set(flds) + self._recalc_layer_list() + def __contains__(self, elt): + if isinstance(elt, scapy.base_classes.Packet_metaclass): + return elt in self.layers + return elt in self.fields + def __repr__(self): + return "<%s [%s]>" % (self.__class__.__name__," ".join(str(x) for x in self.fields)) + +class Emphasize(ConfigFieldList): + pass + +class Resolve(ConfigFieldList): + pass + + +class Num2Layer: + def __init__(self): + self.num2layer = {} + self.layer2num = {} + + def register(self, num, layer): + self.register_num2layer(num, layer) + self.register_layer2num(num, layer) + + def register_num2layer(self, num, layer): + self.num2layer[num] = layer + def register_layer2num(self, num, layer): + self.layer2num[layer] = num + + def __getitem__(self, item): + if isinstance(item, scapy.base_classes.Packet_metaclass): + return self.layer2num[item] + return self.num2layer[item] + def __contains__(self, item): + if isinstance(item, scapy.base_classes.Packet_metaclass): + return item in self.layer2num + return item in self.num2layer + def get(self, item, default=None): + if item in self: + return self[item] + return default + + def __repr__(self): + lst = [] + for num,layer in self.num2layer.items(): + if layer in self.layer2num and self.layer2num[layer] == num: + dir = "<->" + else: + dir = " ->" + lst.append((num,"%#6x %s %-20s (%s)" % (num,dir,layer.__name__,layer.name))) + for layer,num in self.layer2num.items(): + if num not in self.num2layer or self.num2layer[num] != layer: + lst.append((num,"%#6x <- %-20s (%s)" % (num,layer.__name__,layer.name))) + lst.sort() + return "\n".join(y for x,y in lst) + + +class LayersList(list): + def __repr__(self): + s=[] + for l in self: + s.append("%-20s: %s" % (l.__name__,l.name)) + return "\n".join(s) + def register(self, layer): + self.append(layer) + +class CommandsList(list): + def __repr__(self): + s=[] + for l in sorted(self,key=lambda x:x.__name__): + if l.__doc__: + doc = l.__doc__.split("\n")[0] + else: + doc = "--" + s.append("%-20s: %s" % (l.__name__,doc)) + return "\n".join(s) + def register(self, cmd): + self.append(cmd) + return cmd # return cmd so that method can be used as a decorator + +def lsc(): + print(repr(conf.commands)) + +class CacheInstance(dict): + def __init__(self, name="noname", timeout=None): + self.timeout = timeout + self.name = name + self._timetable = {} + def __getitem__(self, item): + val = dict.__getitem__(self,item) + if self.timeout is not None: + t = self._timetable[item] + if time.time()-t > self.timeout: + raise KeyError(item) + return val + def get(self, item, default=None): + # overloading this method is needed to force the dict to go through + # the timetable check + try: + return self[item] + except KeyError: + return default + def __setitem__(self, item, v): + try: + self._timetable[item] = time.time() + except AttributeError: + pass + dict.__setitem__(self, item,v) + def update(self, other): + dict.update(self, other) + self._timetable.update(other._timetable) + def items(self): + if self.timeout is None: + return dict.items(self) + t0=time.time() + return ((k,v) for (k,v) in dict.items(self) if t0-self._timetable[k] < self.timeout) + def keys(self): + if self.timeout is None: + return dict.keys(self) + t0=time.time() + return (k for k in dict.keys(self) if t0-self._timetable[k] < self.timeout) + def __iter__(self): + return self.keys() + def values(self): + if self.timeout is None: + return dict.values(self) + t0=time.time() + return (v for (k,v) in dict.items(self) if t0-self._timetable[k] < self.timeout) + def items(self): + if self.timeout is None: + return dict.items(self) + t0=time.time() + return [(k,v) for (k,v) in dict.items(self) if t0-self._timetable[k] < self.timeout] + def keys(self): + if self.timeout is None: + return dict.keys(self) + t0=time.time() + return [k for k in dict.keys(self) if t0-self._timetable[k] < self.timeout] + def values(self): + if self.timeout is None: + return dict.values(self) + t0=time.time() + return [v for (k,v) in dict.items(self) if t0-self._timetable[k] < self.timeout] + def __len__(self): + if self.timeout is None: + return dict.__len__(self) + return len(self.keys()) + def summary(self): + return "%s: %i valid items. Timeout=%rs" % (self.name, len(self), self.timeout) + def __repr__(self): + s = [] + if self: + mk = max(len(k) for k in self.keys()) + fmt = "%%-%is %%s" % (mk+1) + for item in self.items(): + s.append(fmt % item) + return "\n".join(s) + + + + +class NetCache: + def __init__(self): + self._caches_list = [] + + + def add_cache(self, cache): + self._caches_list.append(cache) + setattr(self,cache.name,cache) + def new_cache(self, name, timeout=None): + c = CacheInstance(name=name, timeout=timeout) + self.add_cache(c) + def __delattr__(self, attr): + raise AttributeError("Cannot delete attributes") + def update(self, other): + for co in other._caches_list: + if hasattr(self, co.name): + getattr(self,co.name).update(co) + else: + self.add_cache(co.copy()) + def flush(self): + for c in self._caches_list: + c.flush() + def __repr__(self): + return "\n".join(c.summary() for c in self._caches_list) + + +class LogLevel(object): + def __get__(self, obj, otype): + return obj._logLevel + def __set__(self,obj,val): + log_scapy.setLevel(val) + obj._logLevel = val + + + +def _prompt_changer(attr,val): + prompt = conf.prompt + try: + ct = val + if isinstance(ct, AnsiColorTheme) and ct.prompt(""): + ## ^A and ^B delimit invisible caracters for readline to count right. + ## And we need ct.prompt() to do change something or else ^A and ^B will be + ## displayed + prompt = "\001%s\002" % ct.prompt("\002"+prompt+"\001") + else: + prompt = ct.prompt(prompt) + except: + pass + sys.ps1 = prompt + + +class Conf(ConfClass): + """This object contains the configuration of scapy. +session : filename where the session will be saved +interactive_shell : If set to "ipython", use IPython as shell. Default: IPython. +ipython_embedded : If True use embedded ipython shell, standard ipython shell otherwise. +stealth : if 1, prevents any unwanted packet to go out (ARP, DNS, ...) +checkIPID: if 0, doesn't check that IPID matches between IP sent and ICMP IP citation received + if 1, checks that they either are equal or byte swapped equals (bug in some IP stacks) + if 2, strictly checks that they are equals +checkIPsrc: if 1, checks IP src in IP and ICMP IP citation match (bug in some NAT stacks) +check_TCPerror_seqack: if 1, also check that TCP seq and ack match the ones in ICMP citation +iff : selects the default output interface for srp() and sendp(). default:"eth0") +verb : level of verbosity, from 0 (almost mute) to 3 (verbose) +promisc : default mode for listening socket (to get answers if you spoof on a lan) +sniff_promisc : default mode for sniff() +filter : bpf filter added to every sniffing socket to exclude traffic from analysis +histfile : history file +padding : includes padding in desassembled packets +except_filter : BPF filter for packets to ignore +debug_match : when 1, store received packet that are not matched into debug.recv +route : holds the Scapy routing table and provides methods to manipulate it +warning_threshold : how much time between warnings from the same place +ASN1_default_codec: Codec used by default for ASN1 objects +mib : holds MIB direct access dictionnary +resolve : holds list of fields for which resolution should be done +noenum : holds list of enum fields for which conversion to string should NOT be done +AS_resolver: choose the AS resolver class to use +extensions_paths: path or list of paths where extensions are to be looked for +""" + version = "3.0.0" + session = "" + interactive = False + interactive_shell = "ipython" + ipython_embedded = True + stealth = "not implemented" + iface = None + readfunc = None + layers = LayersList() + commands = CommandsList() + logLevel = LogLevel() + checkIPID = 0 + checkIPsrc = 1 + checkIPaddr = 1 + check_TCPerror_seqack = 0 + verb = 2 + prompt = ">>> " + promisc = 1 + sniff_promisc = 1 + raw_layer = None + raw_summary = False + default_l2 = None + l2types = Num2Layer() + l3types = Num2Layer() + L3socket = None + L2socket = None + L2listen = None + histfile = os.path.join(os.path.expanduser("~"), ".scapy_history") + padding = 1 + except_filter = "" + debug_match = 0 + wepkey = "" + route = None # Filled by route.py + route6 = None # Filled by route6.py + auto_fragment = 1 + debug_dissector = 0 + color_theme = Interceptor("color_theme", scapy.themes.NoTheme(), _prompt_changer) + warning_threshold = 5 + prog = ProgPath() + resolve = Resolve() + noenum = Resolve() + emph = Emphasize() + use_dnet = False + use_winpcapy = False + use_netifaces = False + ipv6_enabled = socket.has_ipv6 + ethertypes = ETHER_TYPES + protocols = IP_PROTOS + services_tcp = TCP_SERVICES + services_udp = UDP_SERVICES + extensions_paths = "." + manufdb = MANUFDB + stats_classic_protocols = [] + stats_dot11_protocols = [] + temp_files = [] + netcache = NetCache() + load_layers = [ "l2", "inet", "dhcp", "dns", "dot11", "gprs", "hsrp", "inet6", "ir", "isakmp", "l2tp", + "mgcp", "mobileip", "netbios", "netflow", "ntp", "ppp", "radius", "rip", "rtp", + "sebek", "skinny", "smb", "snmp", "tftp", "x509", "bluetooth", "dhcp6", "llmnr", "sctp", "vrrp", + "ipsec" ] + +if not Conf.ipv6_enabled: + log_scapy.warning("IPv6 support disabled in Python. Cannot load scapy IPv6 layers.") + for m in ["inet6","dhcp6"]: + if m in Conf.load_layers: + Conf.load_layers.remove(m) + + +conf=Conf() +conf.logLevel=30 # 30=Warning + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/__init__.py new file mode 100644 index 00000000..99654377 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/__init__.py @@ -0,0 +1,8 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Package of contrib modules that have to be loaded explicitly. +""" diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/avs.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/avs.py new file mode 100644 index 00000000..461b94b8 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/avs.py @@ -0,0 +1,57 @@ +#! /usr/bin/env python + +# http://trac.secdev.org/scapy/ticket/82 + +# scapy.contrib.description = AVS WLAN Monitor Header +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.dot11 import * + +AVSWLANPhyType = { 0 : "Unknown", + 1 : "FHSS 802.11 '97", + 2 : "DSSS 802.11 '97", + 3 : "IR Baseband", + 4 : "DSSS 802.11b", + 5 : "PBCC 802.11b", + 6 : "OFDM 802.11g", + 7 : "PBCC 802.11g", + 8 : "OFDM 802.11a" } + +AVSWLANEncodingType = { 0 : "Unknown", + 1 : "CCK", + 2 : "PBCC", + 3 : "OFDM"} + +AVSWLANSSIType = { 0 : "None", + 1 : "Normalized RSSI", + 2 : "dBm", + 3 : "Raw RSSI"} + +AVSWLANPreambleType = { 0 : "Unknown", + 1 : "Short", + 2 : "Long" } + + +class AVSWLANHeader(Packet): + """ iwpriv eth1 set_prismhdr 1 """ + name = "AVS WLAN Monitor Header" + fields_desc = [ IntField("version",1), + IntField("len",64), + LongField("mactime",0), + LongField("hosttime",0), + IntEnumField("phytype",0, AVSWLANPhyType), + IntField("channel",0), + IntField("datarate",0), + IntField("antenna",0), + IntField("priority",0), + IntEnumField("ssi_type",0, AVSWLANSSIType), + SignedIntField("ssi_signal",0), + SignedIntField("ssi_noise",0), + IntEnumField("preamble",0, AVSWLANPreambleType), + IntEnumField("encoding",0, AVSWLANEncodingType), + ] + +bind_layers(AVSWLANHeader, Dot11) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/bgp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/bgp.py new file mode 100644 index 00000000..525dac5f --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/bgp.py @@ -0,0 +1,168 @@ +#! /usr/bin/env python + +# http://trac.secdev.org/scapy/ticket/162 + +# scapy.contrib.description = BGP +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import TCP + + +class BGPIPField(Field): + """Represents how bgp dose an ip prefix in (length, prefix)""" + def mask2iplen(self,mask): + """turn the mask into the length in bytes of the ip field""" + return (mask + 7) // 8 + def h2i(self, pkt, h): + """human x.x.x.x/y to internal""" + ip,mask = re.split( '/', h) + return int(mask), ip + def i2h( self, pkt, i): + mask, ip = i + return ip + '/' + str( mask ) + def i2repr( self, pkt, i): + """make it look nice""" + return self.i2h(pkt,i) + def i2len(self, pkt, i): + """rely on integer division""" + mask, ip = i + return self.mask2iplen(mask) + 1 + def i2m(self, pkt, i): + """internal (ip as bytes, mask as int) to machine""" + mask, ip = i + ip = inet_aton( ip ) + return struct.pack(">B",mask) + ip[:self.mask2iplen(mask)] + def addfield(self, pkt, s, val): + return s+self.i2m(pkt, val) + def getfield(self, pkt, s): + l = self.mask2iplen( struct.unpack(">B",s[0])[0] ) + 1 + return s[l:], self.m2i(pkt,s[:l]) + def m2i(self,pkt,m): + mask = struct.unpack(">B",m[0])[0] + ip = "".join( [ m[i + 1] if i < self.mask2iplen(mask) else '\x00' for i in range(4)] ) + return (mask,inet_ntoa(ip)) + +class BGPHeader(Packet): + """The first part of any BGP packet""" + name = "BGP header" + fields_desc = [ + XBitField("marker",0xffffffffffffffffffffffffffffffff, 0x80 ), + ShortField("len", None), + ByteEnumField("type", 4, {0:"none", 1:"open",2:"update",3:"notification",4:"keep_alive"}), + ] + def post_build(self, p, pay): + if self.len is None and pay: + l = len(p) + len(pay) + p = p[:16]+struct.pack("!H", l)+p[18:] + return p+pay + +class BGPOptionalParameter(Packet): + """Format of optional Parameter for BGP Open""" + name = "BGP Optional Parameters" + fields_desc = [ + ByteField("type", 2), + ByteField("len", None), + StrLenField("value", "", length_from = lambda x: x.len), + ] + def post_build(self,p,pay): + if self.len is None: + l = len(p) - 2 # 2 is length without value + p = p[:1]+struct.pack("!B", l)+p[2:] + return p+pay + def extract_padding(self, p): + """any thing after this packet is extracted is padding""" + return "",p + +class BGPOpen(Packet): + """ Opens a new BGP session""" + name = "BGP Open Header" + fields_desc = [ + ByteField("version", 4), + ShortField("AS", 0), + ShortField("hold_time", 0), + IPField("bgp_id","0.0.0.0"), + ByteField("opt_parm_len", None), + PacketListField("opt_parm",[], BGPOptionalParameter, length_from=lambda p:p.opt_parm_len), + ] + def post_build(self, p, pay): + if self.opt_parm_len is None: + l = len(p) - 10 # 10 is regular length with no additional options + p = p[:9] + struct.pack("!B",l) +p[10:] + return p+pay + +class BGPAuthenticationData(Packet): + name = "BGP Authentication Data" + fields_desc = [ + ByteField("AuthenticationCode", 0), + ByteField("FormMeaning", 0), + FieldLenField("Algorithm", 0), + ] + +class BGPPathAttribute(Packet): + "the attribute of total path" + name = "BGP Attribute fields" + fields_desc = [ + FlagsField("flags", 0x40, 8, ["NA0","NA1","NA2","NA3","Extended-Length","Partial","Transitive","Optional"]), #Extened leght may not work + ByteEnumField("type", 1, {1:"ORIGIN", 2:"AS_PATH", 3:"NEXT_HOP", 4:"MULTI_EXIT_DISC", 5:"LOCAL_PREF", 6:"ATOMIC_AGGREGATE", 7:"AGGREGATOR"}), + ByteField("attr_len", None), + StrLenField("value", "", length_from = lambda p: p.attr_len), + ] + def post_build(self, p, pay): + if self.attr_len is None: + l = len(p) - 3 # 3 is regular length with no additional options + p = p[:2] + struct.pack("!B",l) +p[3:] + return p+pay + def extract_padding(self, p): + """any thing after this packet is extracted is padding""" + return "",p + +class BGPUpdate(Packet): + """Update the routes WithdrawnRoutes = UnfeasiableRoutes""" + name = "BGP Update fields" + fields_desc = [ + ShortField("withdrawn_len", None), + FieldListField("withdrawn",[], BGPIPField("","0.0.0.0/0"), length_from=lambda p:p.withdrawn_len), + ShortField("tp_len", None), + PacketListField("total_path", [], BGPPathAttribute, length_from = lambda p: p.tp_len), + FieldListField("nlri",[], BGPIPField("","0.0.0.0/0"), length_from=lambda p:p.underlayer.len - 23 - p.tp_len - p.withdrawn_len), # len should be BGPHeader.len + ] + def post_build(self,p,pay): + wl = self.withdrawn_len + subpacklen = lambda p: len ( str( p )) + subfieldlen = lambda p: BGPIPField("", "0.0.0.0/0").i2len(self, p ) + if wl is None: + wl = sum ( map ( subfieldlen , self.withdrawn)) + p = p[:0]+struct.pack("!H", wl)+p[2:] + if self.tp_len is None: + l = sum ( map ( subpacklen , self.total_path)) + p = p[:2+wl]+struct.pack("!H", l)+p[4+wl:] + return p+pay + +class BGPNotification(Packet): + name = "BGP Notification fields" + fields_desc = [ + ByteEnumField("ErrorCode",0,{1:"Message Header Error",2:"OPEN Message Error",3:"UPDATE Messsage Error",4:"Hold Timer Expired",5:"Finite State Machine",6:"Cease"}), + ByteEnumField("ErrorSubCode",0,{1:"MessageHeader",2:"OPENMessage",3:"UPDATEMessage"}), + LongField("Data", 0), + ] + +class BGPErrorSubcodes(Packet): + name = "BGP Error Subcodes" + Fields_desc = [ + ByteEnumField("MessageHeader",0,{1:"Connection Not Synchronized",2:"Bad Message Length",3:"Bad Messsage Type"}), + ByteEnumField("OPENMessage",0,{1:"Unsupported Version Number",2:"Bad Peer AS",3:"Bad BGP Identifier",4:"Unsupported Optional Parameter",5:"Authentication Failure",6:"Unacceptable Hold Time"}), + ByteEnumField("UPDATEMessage",0,{1:"Malformed Attribute List",2:"Unrecognized Well-Known Attribute",3:"Missing Well-Known Attribute",4:"Attribute Flags Error",5:"Attribute Length Error",6:"Invalid ORIGIN Attribute",7:"AS Routing Loop",8:"Invalid NEXT_HOP Attribute",9:"Optional Attribute Error",10:"Invalid Network Field",11:"Malformed AS_PATH"}), + ] + +bind_layers( TCP, BGPHeader, dport=179) +bind_layers( TCP, BGPHeader, sport=179) +bind_layers( BGPHeader, BGPOpen, type=1) +bind_layers( BGPHeader, BGPUpdate, type=2) +bind_layers( BGPHeader, BGPHeader, type=4) + + +if __name__ == "__main__": + interact(mydict=globals(), mybanner="BGP addon .05") + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/carp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/carp.py new file mode 100644 index 00000000..e785adef --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/carp.py @@ -0,0 +1,65 @@ + +# scapy.contrib.description = CARP +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.layers.inet import IP +from scapy.fields import BitField, ByteField, XShortField, IntField, XIntField +from scapy.utils import checksum +import struct, hmac, hashlib + +class CARP(Packet): + name = "CARP" + fields_desc = [ BitField("version", 4, 4), + BitField("type", 4, 4), + ByteField("vhid", 1), + ByteField("advskew", 0), + ByteField("authlen", 0), + ByteField("demotion", 0), + ByteField("advbase", 0), + XShortField("chksum", 0), + XIntField("counter1", 0), + XIntField("counter2", 0), + XIntField("hmac1", 0), + XIntField("hmac2", 0), + XIntField("hmac3", 0), + XIntField("hmac4", 0), + XIntField("hmac5", 0) + ] + + def post_build(self, pkt, pay): + if self.chksum == None: + pkt = pkt[:6] + struct.pack("!H", checksum(pkt)) + pkt[8:] + + return pkt + +def build_hmac_sha1(pkt, pw = '\0' * 20, ip4l = [], ip6l = []): + if not pkt.haslayer(CARP): + return None + + p = pkt[CARP] + h = hmac.new(pw, digestmod = hashlib.sha1) + # XXX: this is a dirty hack. it needs to pack version and type into a single 8bit field + h.update('\x21') + # XXX: mac addy if different from special link layer. comes before vhid + h.update(struct.pack('!B', p.vhid)) + + sl = [] + for i in ip4l: + # sort ips from smallest to largest + sl.append(inet_aton(i)) + sl.sort() + + for i in sl: + h.update(i) + + # XXX: do ip6l sorting + + return h.digest() + +""" +XXX: Usually CARP is multicast to 224.0.0.18 but because of virtual setup, it'll +be unicast between nodes. Uncomment the following line for normal use +bind_layers(IP, CARP, proto=112, dst='224.0.0.18') +""" +bind_layers(IP, CARP, proto=112) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/cdp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/cdp.py new file mode 100644 index 00000000..ed336162 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/cdp.py @@ -0,0 +1,306 @@ +#! /usr/bin/env python + +# scapy.contrib.description = Cisco Discovery Protocol +# scapy.contrib.status = loads + +############################################################################# +## ## +## cdp.py --- Cisco Discovery Protocol (CDP) extension for Scapy ## +## ## +## Copyright (C) 2006 Nicolas Bareil <nicolas.bareil AT eads DOT net> ## +## Arnaud Ebalard <arnaud.ebalard AT eads DOT net> ## +## EADS/CRC security team ## +## ## +## This program is free software; you can redistribute it and/or modify it ## +## under the terms of the GNU General Public License version 2 as ## +## published by the Free Software Foundation; version 2. ## +## ## +## This program is distributed in the hope that it will be useful, but ## +## WITHOUT ANY WARRANTY; without even the implied warranty of ## +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ## +## General Public License for more details. ## +## ## +############################################################################# + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet6 import * + + +##################################################################### +# Helpers and constants +##################################################################### + +# CDP TLV classes keyed by type +_cdp_tlv_cls = { 0x0001: "CDPMsgDeviceID", + 0x0002: "CDPMsgAddr", + 0x0003: "CDPMsgPortID", + 0x0004: "CDPMsgCapabilities", + 0x0005: "CDPMsgSoftwareVersion", + 0x0006: "CDPMsgPlatform", + 0x0007: "CDPMsgIPPrefix", + 0x0008: "CDPMsgProtoHello", + 0x0009: "CDPMsgVTPMgmtDomain", # CDPv2 + 0x000a: "CDPMsgNativeVLAN", # CDPv2 + 0x000b: "CDPMsgDuplex", # +# 0x000c: "CDPMsgGeneric", +# 0x000d: "CDPMsgGeneric", + 0x000e: "CDPMsgVoIPVLANReply", + 0x000f: "CDPMsgVoIPVLANQuery", + 0x0010: "CDPMsgPower", + 0x0011: "CDPMsgMTU", +# 0x0012: "CDPMsgTrustBitmap", +# 0x0013: "CDPMsgUntrustedPortCoS", +# 0x0014: "CDPMsgSystemName", +# 0x0015: "CDPMsgSystemOID", + 0x0016: "CDPMsgMgmtAddr", +# 0x0017: "CDPMsgLocation", + 0x0019: "CDPMsgUnknown19", +# 0x001a: "CDPPowerAvailable" + } + +_cdp_tlv_types = { 0x0001: "Device ID", + 0x0002: "Addresses", + 0x0003: "Port ID", + 0x0004: "Capabilities", + 0x0005: "Software Version", + 0x0006: "Platform", + 0x0007: "IP Prefix", + 0x0008: "Protocol Hello", + 0x0009: "VTP Mangement Domain", # CDPv2 + 0x000a: "Native VLAN", # CDPv2 + 0x000b: "Duplex", # + 0x000c: "CDP Unknown command (send us a pcap file)", + 0x000d: "CDP Unknown command (send us a pcap file)", + 0x000e: "VoIP VLAN Reply", + 0x000f: "VoIP VLAN Query", + 0x0010: "Power", + 0x0011: "MTU", + 0x0012: "Trust Bitmap", + 0x0013: "Untrusted Port CoS", + 0x0014: "System Name", + 0x0015: "System OID", + 0x0016: "Management Address", + 0x0017: "Location", + 0x0018: "CDP Unknown command (send us a pcap file)", + 0x0019: "CDP Unknown command (send us a pcap file)", + 0x001a: "Power Available"} + +def _CDPGuessPayloadClass(p, **kargs): + cls = conf.raw_layer + if len(p) >= 2: + t = struct.unpack("!H", p[:2])[0] + clsname = _cdp_tlv_cls.get(t, "CDPMsgGeneric") + cls = globals()[clsname] + + return cls(p, **kargs) + +class CDPMsgGeneric(Packet): + name = "CDP Generic Message" + fields_desc = [ XShortEnumField("type", None, _cdp_tlv_types), + FieldLenField("len", None, "val", "!H"), + StrLenField("val", "", length_from=lambda x:x.len - 4) ] + + + def guess_payload_class(self, p): + return conf.padding_layer # _CDPGuessPayloadClass + +class CDPMsgDeviceID(CDPMsgGeneric): + name = "Device ID" + type = 0x0001 + +_cdp_addr_record_ptype = {0x01: "NLPID", 0x02: "802.2"} +_cdp_addrrecord_proto_ip = "\xcc" +_cdp_addrrecord_proto_ipv6 = "\xaa\xaa\x03\x00\x00\x00\x86\xdd" + +class CDPAddrRecord(Packet): + name = "CDP Address" + fields_desc = [ ByteEnumField("ptype", 0x01, _cdp_addr_record_ptype), + FieldLenField("plen", None, "proto", "B"), + StrLenField("proto", None, length_from=lambda x:x.plen), + FieldLenField("addrlen", None, length_of=lambda x:x.addr), + StrLenField("addr", None, length_from=lambda x:x.addrlen)] + + def guess_payload_class(self, p): + return conf.padding_layer + +class CDPAddrRecordIPv4(CDPAddrRecord): + name = "CDP Address IPv4" + fields_desc = [ ByteEnumField("ptype", 0x01, _cdp_addr_record_ptype), + FieldLenField("plen", 1, "proto", "B"), + StrLenField("proto", _cdp_addrrecord_proto_ip, length_from=lambda x:x.plen), + ShortField("addrlen", 4), + IPField("addr", "0.0.0.0")] + +class CDPAddrRecordIPv6(CDPAddrRecord): + name = "CDP Address IPv6" + fields_desc = [ ByteEnumField("ptype", 0x02, _cdp_addr_record_ptype), + FieldLenField("plen", 8, "proto", "B"), + StrLenField("proto", _cdp_addrrecord_proto_ipv6, length_from=lambda x:x.plen), + ShortField("addrlen", 16), + IP6Field("addr", "::1")] + +def _CDPGuessAddrRecord(p, **kargs): + cls = conf.raw_layer + if len(p) >= 2: + plen = struct.unpack("B", p[1])[0] + proto = ''.join(struct.unpack("s" * plen, p[2:plen + 2])[0:plen]) + + if proto == _cdp_addrrecord_proto_ip: + clsname = "CDPAddrRecordIPv4" + elif proto == _cdp_addrrecord_proto_ipv6: + clsname = "CDPAddrRecordIPv6" + else: + clsname = "CDPAddrRecord" + + cls = globals()[clsname] + + return cls(p, **kargs) + +class CDPMsgAddr(CDPMsgGeneric): + name = "Addresses" + fields_desc = [ XShortEnumField("type", 0x0002, _cdp_tlv_types), + ShortField("len", None), + FieldLenField("naddr", None, "addr", "!I"), + PacketListField("addr", [], _CDPGuessAddrRecord, count_from=lambda x:x.naddr) ] + + def post_build(self, pkt, pay): + if self.len is None: + l = 8 + len(self.addr) * 9 + pkt = pkt[:2] + struct.pack("!H", l) + pkt[4:] + p = pkt + pay + return p + +class CDPMsgPortID(CDPMsgGeneric): + name = "Port ID" + fields_desc = [ XShortEnumField("type", 0x0003, _cdp_tlv_types), + FieldLenField("len", None, "iface", "!H"), + StrLenField("iface", "Port 1", length_from=lambda x:x.len - 4) ] + + +_cdp_capabilities = [ "Router", + "TransparentBridge", + "SourceRouteBridge", + "Switch", + "Host", + "IGMPCapable", + "Repeater"] + ["Bit%d" % x for x in range(25,0,-1)] + + +class CDPMsgCapabilities(CDPMsgGeneric): + name = "Capabilities" + fields_desc = [ XShortEnumField("type", 0x0004, _cdp_tlv_types), + ShortField("len", 8), + FlagsField("cap", 0, 32, _cdp_capabilities) ] + + +class CDPMsgSoftwareVersion(CDPMsgGeneric): + name = "Software Version" + type = 0x0005 + + +class CDPMsgPlatform(CDPMsgGeneric): + name = "Platform" + type = 0x0006 + +_cdp_duplex = { 0x00: "Half", 0x01: "Full" } + +# ODR Routing +class CDPMsgIPPrefix(CDPMsgGeneric): + name = "IP Prefix" + type = 0x0007 + fields_desc = [ XShortEnumField("type", 0x0007, _cdp_tlv_types), + ShortField("len", 8), + IPField("defaultgw", "192.168.0.1") ] + +# TODO : Do me !!!!!! 0x0008 +class CDPMsgProtoHello(CDPMsgGeneric): + name = "Protocol Hello" + type = 0x0008 + +class CDPMsgVTPMgmtDomain(CDPMsgGeneric): + name = "VTP Management Domain" + type = 0x0009 + +class CDPMsgNativeVLAN(CDPMsgGeneric): + name = "Native VLAN" + fields_desc = [ XShortEnumField("type", 0x000a, _cdp_tlv_types), + ShortField("len", 6), + ShortField("vlan", 1) ] + +class CDPMsgDuplex(CDPMsgGeneric): + name = "Duplex" + fields_desc = [ XShortEnumField("type", 0x000b, _cdp_tlv_types), + ShortField("len", 5), + ByteEnumField("duplex", 0x00, _cdp_duplex) ] + +class CDPMsgVoIPVLANReply(CDPMsgGeneric): + name = "VoIP VLAN Reply" + fields_desc = [ XShortEnumField("type", 0x000e, _cdp_tlv_types), + ShortField("len", 7), + ByteField("status?", 1), + ShortField("vlan", 1)] + + +# TODO : Do me !!! 0x000F +class CDPMsgVoIPVLANQuery(CDPMsgGeneric): + name = "VoIP VLAN Query" + type = 0x000f + +# fields_desc = [XShortEnumField("type", 0x000f, _cdp_tlv_types), +# FieldLenField("len", None, "val", "!H") ] + + +class _CDPPowerField(ShortField): + def i2repr(self, pkt, x): + if x is None: + x = 0 + return "%d mW" % x + + +class CDPMsgPower(CDPMsgGeneric): + name = "Power" + # Check if field length is fixed (2 bytes) + fields_desc = [ XShortEnumField("type", 0x0010, _cdp_tlv_types), + ShortField("len", 6), + _CDPPowerField("power", 1337)] + + +class CDPMsgMTU(CDPMsgGeneric): + name = "MTU" + # Check if field length is fixed (2 bytes) + fields_desc = [ XShortEnumField("type", 0x0011, _cdp_tlv_types), + ShortField("len", 6), + ShortField("mtu", 1500)] + +class CDPMsgMgmtAddr(CDPMsgAddr): + name = "Management Address" + type = 0x0016 + +class CDPMsgUnknown19(CDPMsgGeneric): + name = "Unknown CDP Message" + type = 0x0019 + +class CDPMsg(CDPMsgGeneric): + name = "CDP " + fields_desc = [ XShortEnumField("type", None, _cdp_tlv_types), + FieldLenField("len", None, "val", "!H"), + StrLenField("val", "", length_from=lambda x:x.len - 4) ] + +class _CDPChecksum: + def post_build(self, pkt, pay): + p = pkt + pay + if self.cksum is None: + cksum = checksum(p) + p = p[:2] + struct.pack("!H", cksum) + p[4:] + return p + +class CDPv2_HDR(_CDPChecksum, CDPMsgGeneric): + name = "Cisco Discovery Protocol version 2" + fields_desc = [ ByteField("vers", 2), + ByteField("ttl", 180), + XShortField("cksum", None), + PacketListField("msg", [], _CDPGuessPayloadClass) ] + +bind_layers(SNAP, CDPv2_HDR, {"code": 0x2000, "OUI": 0xC}) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/chdlc.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/chdlc.py new file mode 100644 index 00000000..6e483762 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/chdlc.py @@ -0,0 +1,42 @@ +# http://trac.secdev.org/scapy/ticket/88 + +# scapy.contrib.description = Cisco HDLC and SLARP +# scapy.contrib.status = loads + +# This layer is based on information from http://www.nethelp.no/net/cisco-hdlc.txt + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.l2 import * +from scapy.layers.inet import * +from scapy.layers.inet6 import * + +class CHDLC(Packet): + name = "Cisco HDLC" + fields_desc = [ ByteEnumField("address", 0x0f, {0x0f : "unicast", 0x8f :"multicast"}), + ByteField("control", 0), + XShortField("proto", 0x0800)] + +class SLARP(Packet): + name = "SLARP" + fields_desc = [ IntEnumField("type", 2, {0 : "request", 1 : "reply", 2 :"line keepalive"}), + ConditionalField(IPField("address", "192.168.0.1"), + lambda pkt : pkt.type == 0 or pkt.type == 1), + ConditionalField(IPField("mask", "255.255.255.0"), + lambda pkt : pkt.type == 0 or pkt.type == 1), + ConditionalField(XShortField("unused", 0), + lambda pkt : pkt.type == 0 or pkt.type == 1), + ConditionalField(IntField("mysequence", 0), + lambda pkt : pkt.type == 2), + ConditionalField(IntField("yoursequence", 0), + lambda pkt : pkt.type == 2), + ConditionalField(XShortField("reliability", 0xffff), + lambda pkt : pkt.type == 2)] + +bind_layers( CHDLC, Dot3, proto=0x6558) +bind_layers( CHDLC, IP, proto=0x800) +bind_layers( CHDLC, IPv6, proto=0x86dd) +bind_layers( CHDLC, SLARP, proto=0x8035) +bind_layers( CHDLC, STP, proto=0x4242) + +conf.l2types.register(104, CHDLC) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/dtp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/dtp.py new file mode 100644 index 00000000..1907300b --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/dtp.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python + +# scapy.contrib.description = DTP +# scapy.contrib.status = loads + +""" + DTP Scapy Extension + ~~~~~~~~~~~~~~~~~~~ + + :version: 2008-12-22 + :author: Jochen Bartl <lobo@c3a.de> + + :Thanks: + + - TLV code derived from the CDP implementation of scapy. (Thanks to Nicolas Bareil and Arnaud Ebalard) + http://trac.secdev.org/scapy/ticket/18 +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.l2 import SNAP,Dot3,LLC +from scapy.sendrecv import sendp + +class DtpGenericTlv(Packet): + name = "DTP Generic TLV" + fields_desc = [ XShortField("type", 0x0001), + FieldLenField("length", None, length_of=lambda pkt:pkt.value + 4), + StrLenField("value", "", length_from=lambda pkt:pkt.length - 4) + ] + + def guess_payload_class(self, p): + return conf.padding_layer + +class RepeatedTlvListField(PacketListField): + def __init__(self, name, default, cls): + PacketField.__init__(self, name, default, cls) + + def getfield(self, pkt, s): + lst = [] + remain = s + while len(remain) > 0: + p = self.m2i(pkt,remain) + if conf.padding_layer in p: + pad = p[conf.padding_layer] + remain = pad.load + del(pad.underlayer.payload) + else: + remain = "" + lst.append(p) + return remain,lst + + def addfield(self, pkt, s, val): + return s+reduce(str.__add__, map(str, val),"") + +_DTP_TLV_CLS = { + 0x0001 : "DTPDomain", + 0x0002 : "DTPStatus", + 0x0003 : "DTPType", + 0x0004 : "DTPNeighbor" + } + +class DTPDomain(DtpGenericTlv): + name = "DTP Domain" + fields_desc = [ ShortField("type", 1), + FieldLenField("length", None, "domain", adjust=lambda pkt,x:x + 4), + StrLenField("domain", "\x00", length_from=lambda pkt:pkt.length - 4) + ] + +class DTPStatus(DtpGenericTlv): + name = "DTP Status" + fields_desc = [ ShortField("type", 2), + FieldLenField("length", None, "status", adjust=lambda pkt,x:x + 4), + StrLenField("status", "\x03", length_from=lambda pkt:pkt.length - 4) + ] + +class DTPType(DtpGenericTlv): + name = "DTP Type" + fields_desc = [ ShortField("type", 3), + FieldLenField("length", None, "dtptype", adjust=lambda pkt,x:x + 4), + StrLenField("dtptype", "\xa5", length_from=lambda pkt:pkt.length - 4) + ] + +class DTPNeighbor(DtpGenericTlv): + name = "DTP Neighbor" + fields_desc = [ ShortField("type", 4), + #FieldLenField("length", None, "neighbor", adjust=lambda pkt,x:x + 4), + ShortField("len", 10), + MACField("neighbor", None) + ] + +def _DTPGuessPayloadClass(p, **kargs): + cls = conf.raw_layer + if len(p) >= 2: + t = struct.unpack("!H", p[:2])[0] + clsname = _DTP_TLV_CLS.get(t, "DtpGenericTlv") + cls = globals()[clsname] + return cls(p, **kargs) + +class DTP(Packet): + name = "DTP" + fields_desc = [ ByteField("ver", 1), + RepeatedTlvListField("tlvlist", [], _DTPGuessPayloadClass) + ] + +bind_layers(SNAP, DTP, code=0x2004, OUI=0xc) + + +def negotiate_trunk(iface=conf.iface, mymac=str(RandMAC())): + print("Trying to negotiate a trunk on interface %s" % iface) + p = Dot3(src=mymac, dst="01:00:0c:cc:cc:cc")/LLC()/SNAP()/DTP(tlvlist=[DTPDomain(),DTPStatus(),DTPType(),DTPNeighbor(neighbor=mymac)]) + sendp(p) + +if __name__ == "__main__": + from scapy.main import interact + interact(mydict=globals(), mybanner="DTP") diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/eigrp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/eigrp.py new file mode 100644 index 00000000..f304ae68 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/eigrp.py @@ -0,0 +1,488 @@ +#!/usr/bin/env python + +# scapy.contrib.description = EIGRP +# scapy.contrib.status = loads + +""" + EIGRP Scapy Extension + ~~~~~~~~~~~~~~~~~~~~~ + + :version: 2009-08-13 + :copyright: 2009 by Jochen Bartl + :e-mail: lobo@c3a.de / jochen.bartl@gmail.com + :license: GPL v2 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + :TODO + + - Replace TLV code with a more generic solution + * http://trac.secdev.org/scapy/ticket/90 + - Write function for calculating authentication data + + :Known bugs: + + - + + :Thanks: + + - TLV code derived from the CDP implementation of scapy. (Thanks to Nicolas Bareil and Arnaud Ebalard) + http://trac.secdev.org/scapy/ticket/18 + - IOS / EIGRP Version Representation FIX by Dirk Loss +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import IP +from scapy.layers.inet6 import * + +class EigrpIPField(StrField, IPField): + """ + This is a special field type for handling ip addresses of destination networks in internal and + external route updates. + + EIGRP removes zeros from the host portion of the ip address if the netmask is 8, 16 or 24 bits. + """ + + def __init__(self, name, default, length=None, length_from=None): + StrField.__init__(self, name, default) + self.length_from = length_from + if length is not None: + self.length_from = lambda pkt,length=length: length + + def h2i(self, pkt, x): + return IPField.h2i(self, pkt, x) + + def i2m(self, pkt, x): + x = inet_aton(x) + l = self.length_from(pkt) + + if l <= 8: + return x[:1] + elif l <= 16: + return x[:2] + elif l <= 24: + return x[:3] + else: + return x + + def m2i(self, pkt, x): + l = self.length_from(pkt) + + if l <= 8: + x += "\x00\x00\x00" + elif l <= 16: + x += "\x00\x00" + elif l <= 24: + x += "\x00" + + return inet_ntoa(x) + + def prefixlen_to_bytelen(self, l): + if l <= 8: + l = 1 + elif l <= 16: + l = 2 + elif l <= 24: + l = 3 + else: + l = 4 + + return l + + def i2len(self, pkt, x): + l = self.length_from(pkt) + l = self.prefixlen_to_bytelen(l) + + return l + + def getfield(self, pkt, s): + l = self.length_from(pkt) + l = self.prefixlen_to_bytelen(l) + + return s[l:], self.m2i(pkt, s[:l]) + + def randval(self): + return IPField.randval(self) + +class EigrpIP6Field(StrField, IP6Field, EigrpIPField): + """ + This is a special field type for handling ip addresses of destination networks in internal and + external route updates. + + """ + + def __init__(self, name, default, length=None, length_from=None): + StrField.__init__(self, name, default) + self.length_from = length_from + if length is not None: + self.length_from = lambda pkt,length=length: length + + def any2i(self, pkt, x): + return IP6Field.any2i(self, pkt, x) + + def i2repr(self, pkt, x): + return IP6Field.i2repr(self, pkt, x) + + def h2i(self, pkt, x): + return IP6Field.h2i(self, pkt, x) + + def i2m(self, pkt, x): + x = inet_pton(socket.AF_INET6, x) + l = self.length_from(pkt) + l = self.prefixlen_to_bytelen(l) + + return x[:l] + + def m2i(self, pkt, x): + l = self.length_from(pkt) + + prefixlen = self.prefixlen_to_bytelen(l) + if l > 128: + warning("EigrpIP6Field: Prefix length is > 128. Dissection of this packet will fail") + else: + pad = "\x00" * (16 - prefixlen) + x += pad + + return inet_ntop(socket.AF_INET6, x) + + def prefixlen_to_bytelen(self, l): + l = l / 8 + + if l < 16: + l += 1 + + return l + + def i2len(self, pkt, x): + return EigrpIPField.i2len(self, pkt, x) + + def getfield(self, pkt, s): + return EigrpIPField.getfield(self, pkt, s) + +class ThreeBytesField(X3BytesField, ByteField): + def i2repr(self, pkt, x): + return ByteField.i2repr(self, pkt, x) + + +class EIGRPGeneric(Packet): + name = "EIGRP Generic TLV" + fields_desc = [ XShortField("type", 0x0000), + FieldLenField("len", None, "value", "!H", adjust=lambda pkt,x: x + 4), + StrLenField("value", "\x00", length_from=lambda pkt: pkt.len - 4)] + + def guess_payload_class(self, p): + return conf.padding_layer + +class EIGRPParam(EIGRPGeneric): + name = "EIGRP Parameters" + fields_desc = [ XShortField("type", 0x0001), + ShortField("len", 12), + # Bandwidth + ByteField("k1", 1), + # Load + ByteField("k2", 0), + # Delay + ByteField("k3", 1), + # Reliability + ByteField("k4", 0), + # MTU + ByteField("k5", 0), + ByteField("reserved", 0), + ShortField("holdtime", 15) + ] + +class EIGRPAuthData(EIGRPGeneric): + name = "EIGRP Authentication Data" + fields_desc = [ XShortField("type", 0x0002), + FieldLenField("len", None, "authdata", "!H", adjust=lambda pkt,x: x + 24), + ShortEnumField("authtype", 2, {2 : "MD5"}), + ShortField("keysize", None), + IntField("keyid", 1), + StrFixedLenField("nullpad", "\x00" * 12, 12), + StrLenField("authdata", RandString(16), length_from=lambda pkt: pkt.keysize) + ] + + def post_build(self, p, pay): + p += pay + + if self.keysize is None: + keysize = len(self.authdata) + p = p[:6] + chr((keysize >> 8) & 0xff) + chr(keysize & 0xff) + p[8:] + + return p + +class EIGRPSeq(EIGRPGeneric): + name = "EIGRP Sequence" + fields_desc = [ XShortField("type", 0x0003), + ShortField("len", None), + ByteField("addrlen", 4), + ConditionalField(IPField("ipaddr", "192.168.0.1"), + lambda pkt:pkt.addrlen == 4), + ConditionalField(IP6Field("ip6addr", "2001::"), + lambda pkt:pkt.addrlen == 16) + ] + + def post_build(self, p, pay): + p += pay + + if self.len is None: + l = len(p) + p = p[:2] + chr((l >> 8) & 0xff) + chr(l & 0xff) + p[4:] + + return p + +class ShortVersionField(ShortField): + def i2repr(self, pkt, x): + try: + minor = x & 0xff + major = (x >> 8) & 0xff + except TypeError: + return "unknown" + else: + # We print a leading 'v' so that these values don't look like floats + return "v%s.%s" % (major, minor) + + def h2i(self, pkt, x): + """The field accepts string values like v12.1, v1.1 or integer values. + String values have to start with a "v" folled by a floating point number. + Valid numbers are between 0 and 255. + """ + + if type(x) is str and x.startswith("v") and len(x) <= 8: + major = int(x.split(".")[0][1:]) + minor = int(x.split(".")[1]) + + return (major << 8) | minor + + elif type(x) is int and x >= 0 and x <= 65535: + return x + else: + if self.default != None: + warning("set value to default. Format of %r is invalid" % x) + return self.default + else: + raise Scapy_Exception("Format of value is invalid") + + def randval(self): + return RandShort() + +class EIGRPSwVer(EIGRPGeneric): + name = "EIGRP Software Version" + fields_desc = [ XShortField("type", 0x0004), + ShortField("len", 8), + ShortVersionField("ios", "v12.0"), + ShortVersionField("eigrp", "v1.2") + ] + +class EIGRPNms(EIGRPGeneric): + name = "EIGRP Next Multicast Sequence" + fields_desc = [ XShortField("type", 0x0005), + ShortField("len", 8), + IntField("nms", 2) + ] + +# Don't get confused by the term "receive-only". This flag is always set, when you configure +# one of the stub options. It's also the only flag set, when you configure "eigrp stub receive-only". +_EIGRP_STUB_FLAGS = ["connected", "static", "summary", "receive-only", "redistributed", "leak-map"] + +class EIGRPStub(EIGRPGeneric): + name = "EIGRP Stub Router" + fields_desc = [ XShortField("type", 0x0006), + ShortField("len", 6), + FlagsField("flags", 0x000d, 16, _EIGRP_STUB_FLAGS)] + +# Delay 0xffffffff == Destination Unreachable +class EIGRPIntRoute(EIGRPGeneric): + name = "EIGRP Internal Route" + fields_desc = [ XShortField("type", 0x0102), + FieldLenField("len", None, "dst", "!H", adjust=lambda pkt,x: x + 25), + IPField("nexthop", "192.168.0.0"), + IntField("delay", 128000), + IntField("bandwidth", 256), + ThreeBytesField("mtu", 1500), + ByteField("hopcount", 0), + ByteField("reliability", 255), + ByteField("load", 0), + XShortField("reserved", 0), + ByteField("prefixlen", 24), + EigrpIPField("dst", "192.168.1.0", length_from=lambda pkt: pkt.prefixlen), + ] + +_EIGRP_EXTERNAL_PROTOCOL_ID = { + 0x01 : "IGRP", + 0x02 : "EIGRP", + 0x03 : "Static Route", + 0x04 : "RIP", + 0x05 : "Hello", + 0x06 : "OSPF", + 0x07 : "IS-IS", + 0x08 : "EGP", + 0x09 : "BGP", + 0x0A : "IDRP", + 0x0B : "Connected Link" + } + +_EIGRP_EXTROUTE_FLAGS = ["external", "candidate-default"] + +class EIGRPExtRoute(EIGRPGeneric): + name = "EIGRP External Route" + fields_desc = [ XShortField("type", 0x0103), + FieldLenField("len", None, "dst", "!H", adjust=lambda pkt,x: x + 45), + IPField("nexthop", "192.168.0.0"), + IPField("originrouter", "192.168.0.1"), + IntField("originasn", 0), + IntField("tag", 0), + IntField("externalmetric", 0), + ShortField("reserved", 0), + ByteEnumField("extprotocolid", 3, _EIGRP_EXTERNAL_PROTOCOL_ID), + FlagsField("flags", 0, 8, _EIGRP_EXTROUTE_FLAGS), + IntField("delay", 0), + IntField("bandwidth", 256), + ThreeBytesField("mtu", 1500), + ByteField("hopcount", 0), + ByteField("reliability", 255), + ByteField("load", 0), + XShortField("reserved2", 0), + ByteField("prefixlen", 24), + EigrpIPField("dst", "192.168.1.0", length_from=lambda pkt: pkt.prefixlen) + ] + +class EIGRPv6IntRoute(EIGRPGeneric): + name = "EIGRP for IPv6 Internal Route" + fields_desc = [ XShortField("type", 0x0402), + FieldLenField("len", None, "dst", "!H", adjust=lambda pkt,x: x + 37), + IP6Field("nexthop", "::"), + IntField("delay", 128000), + IntField("bandwidth", 256000), + ThreeBytesField("mtu", 1500), + ByteField("hopcount", 1), + ByteField("reliability", 255), + ByteField("load", 0), + XShortField("reserved", 0), + ByteField("prefixlen", 16), + EigrpIP6Field("dst", "2001::", length_from=lambda pkt: pkt.prefixlen) + ] + +class EIGRPv6ExtRoute(EIGRPGeneric): + name = "EIGRP for IPv6 External Route" + fields_desc = [ XShortField("type", 0x0403), + FieldLenField("len", None, "dst", "!H", adjust=lambda pkt,x: x + 57), + IP6Field("nexthop", "::"), + IPField("originrouter", "192.168.0.1"), + IntField("originasn", 0), + IntField("tag", 0), + IntField("externalmetric", 0), + ShortField("reserved", 0), + ByteEnumField("extprotocolid", 3, _EIGRP_EXTERNAL_PROTOCOL_ID), + FlagsField("flags", 0, 8, _EIGRP_EXTROUTE_FLAGS), + IntField("delay", 0), + IntField("bandwidth", 256000), + ThreeBytesField("mtu", 1500), + ByteField("hopcount", 1), + ByteField("reliability", 0), + ByteField("load", 1), + XShortField("reserved2", 0), + ByteField("prefixlen", 8), + EigrpIP6Field("dst", "::", length_from=lambda pkt: pkt.prefixlen) + ] + +_eigrp_tlv_cls = { + 0x0001: "EIGRPParam", + 0x0002: "EIGRPAuthData", + 0x0003: "EIGRPSeq", + 0x0004: "EIGRPSwVer", + 0x0005: "EIGRPNms", + 0x0006: "EIGRPStub", + 0x0102: "EIGRPIntRoute", + 0x0103: "EIGRPExtRoute", + 0x0402: "EIGRPv6IntRoute", + 0x0403: "EIGRPv6ExtRoute" + } + +class RepeatedTlvListField(PacketListField): + def __init__(self, name, default, cls): + PacketField.__init__(self, name, default, cls) + + def getfield(self, pkt, s): + lst = [] + remain = s + while len(remain) > 0: + p = self.m2i(pkt, remain) + if conf.padding_layer in p: + pad = p[conf.padding_layer] + remain = pad.load + del(pad.underlayer.payload) + else: + remain = "" + lst.append(p) + return remain,lst + + def addfield(self, pkt, s, val): + return s + reduce(str.__add__, map(str, val), "") + +def _EIGRPGuessPayloadClass(p, **kargs): + cls = conf.raw_layer + if len(p) >= 2: + t = struct.unpack("!H", p[:2])[0] + clsname = _eigrp_tlv_cls.get(t, "EIGRPGeneric") + cls = globals()[clsname] + return cls(p, **kargs) + +_EIGRP_OPCODES = { 1 : "Update", + 2 : "Request", + 3 : "Query", + 4 : "Replay", + 5 : "Hello", + 6 : "IPX SAP", + 10 : "SIA Query", + 11 : "SIA Reply" } + +# The Conditional Receive bit is used for reliable multicast communication. +# Update-Flag: Not sure if Cisco calls it that way, but it's set when neighbors +# are exchanging routing information +_EIGRP_FLAGS = ["init", "cond-recv", "unknown", "update"] + +class EIGRP(Packet): + name = "EIGRP" + fields_desc = [ ByteField("ver", 2), + ByteEnumField("opcode", 5, _EIGRP_OPCODES), + XShortField("chksum", None), + FlagsField("flags", 0, 32, _EIGRP_FLAGS), + IntField("seq", 0), + IntField("ack", 0), + IntField("asn", 100), + RepeatedTlvListField("tlvlist", [], _EIGRPGuessPayloadClass) + ] + + def post_build(self, p, pay): + p += pay + if self.chksum is None: + c = checksum(p) + p = p[:2] + chr((c >> 8) & 0xff) + chr(c & 0xff) + p[4:] + return p + + def mysummary(self): + summarystr = "EIGRP (AS=%EIGRP.asn% Opcode=%EIGRP.opcode%" + if self.opcode == 5 and self.ack != 0: + summarystr += " (ACK)" + if self.flags != 0: + summarystr += " Flags=%EIGRP.flags%" + + return self.sprintf(summarystr + ")") + +bind_layers(IP, EIGRP, proto=88) +bind_layers(IPv6, EIGRP, nh=88) + +if __name__ == "__main__": + from scapy.main import interact + interact(mydict=globals(), mybanner="EIGRP") + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/etherip.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/etherip.py new file mode 100644 index 00000000..e331c146 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/etherip.py @@ -0,0 +1,19 @@ + +# http://trac.secdev.org/scapy/ticket/297 + +# scapy.contrib.description = EtherIP +# scapy.contrib.status = loads + +from scapy.fields import BitField +from scapy.packet import Packet, bind_layers +from scapy.layers.inet import IP +from scapy.layers.l2 import Ether + +class EtherIP(Packet): + name = "EtherIP / RFC 3378" + fields_desc = [ BitField("version", 3, 4), + BitField("reserved", 0, 12)] + +bind_layers( IP, EtherIP, frag=0, proto=0x61) +bind_layers( EtherIP, Ether) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/gsm_um.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/gsm_um.py new file mode 100644 index 00000000..7b1354a4 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/gsm_um.py @@ -0,0 +1,13119 @@ +#!/usr/bin/env python + +# scapy.contrib.description = PPI +# scapy.contrib.status = loads + +""" + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +""" + + #################################################################### + # This file holds the GSM UM interface implementation for Scapy # + # author: Laurent Weber <k@0xbadcab1e.lu> # + # # + # Some examples on how to use this script: # + # http://0xbadcab1e.lu/scapy_gsm_um-howto.txt # + # # + # tested on: scapy-version: 2.2.0 (dev) # + #################################################################### + +import logging +from types import IntType +from types import NoneType +from types import StringType +#from time import sleep +import socket +logging.getLogger("scapy").setLevel(1) +from scapy.all import * + +# This method is intended to send gsm air packets. It uses a unix domain +# socket. It opens a socket, sends the parameter to the socket and +# closes the socket. +# typeSock determines the type of the socket, can be: +# 0 for UDP Socket +# 1 for Unix Domain Socket +# 2 for TCP + + +def sendum(x, typeSock=0): + try: + if type(x) is not str: + x = str(x) + if typeSock is 0: + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + host = '127.0.0.1' + port = 28670 # default for openBTS + s.connect((host, port)) + elif typeSock is 1: + s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + s.connect("/tmp/osmoL") + elif typeSock is 2: + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + host = '127.0.0.1' + port = 43797 + s.connect((host, port)) + s.send(x) + s.close() + except: + print("[Error]: There was a problem when trying to transmit data.\ + Please make sure you started the socket server.") + +# Known Bugs/Problems: +# If a message uses multiple times the same IE you cannot set the values +# of this IE's if you use the preconfigured packets. You need to build +# the IE's by hand and than assemble them as entire messages. + +# The ErrorLength class is a custom exception that gets raised when a +# packet doesn't have the correct size. + + +class ErrorLength(Exception): + def __str__(self): + error = "ERROR: Please make sure you build entire, 8 bit fields." + return repr(error) +### +# This method computes the length of the actual IE. +# It computes how many "None" fields have to be removed (if any). +# The method returns an integer containing the number of bytes that have to be +# cut off the packet. +# parameter length contains the max length of the IE can be found in +# 0408 +# The parameter fields contains the value of the fields (not the default but +# the real, actual value. +# The parameter fields2 contains fields_desc. +# Location contains the location of the length field in the IE. Everything +# after the the length field has to be counted (04.07 11.2.1.1.2) + + +def adapt(min_length, max_length, fields, fields2, location=2): + # find out how much bytes there are between min_length and the location of + # the length field + location = min_length - location + i = len(fields) - 1 + rm = mysum = 0 + while i >= 0: + if fields[i] is None: + rm += 1 + try: + mysum += fields2[i].size + except AttributeError: # ByteFields don't have .size + mysum += 8 + else: + break + i -= 1 + if mysum % 8 is 0: + length = mysum / 8 # Number of bytes we have to delete + dyn_length = (max_length - min_length - length) + if dyn_length < 0: + dyn_length = 0 + if length is max_length: # Fix for packets that have all values set + length -= min_length # to None + return [length, dyn_length + location] + else: + raise ErrorLength() + + +def examples(example=None): + if example == None: + print("""This command presents some example to introduce scapy +gsm-um to new users. +The following parameters can be used: + examples("imsiDetach") + examples("call") + examples("dissect")""") + elif example == "imsiDetach": + print(""" +>>> a=imsiDetachIndication() +... a.typeOfId=1; a.odd=1; a.idDigit1=0xF; +... a.idDigit2_1=2; a.idDigit2=7; a.idDigit3_1=0; +... a.idDigit3=7; a.idDigit4_1=7; a.idDigit4=2; +... a.idDigit5_1=0; a.idDigit5=0; a.idDigit6_1=0; +... a.idDigit6=1; a.idDigit7_1=2; a.idDigit7=7; +... a.idDigit8_1=7; a.idDigit8=5; a.idDigit9_1=1; a.idDigit9=4; +>>> hexdump(a) +0000 05 01 00 08 F0 27 07 72 00 01 27 75 14 .....'.r..'u. +>>> sendum(a) +""") + elif example == "call": + print(""" +If you use an USRP and the testcall function this sets up a phonecall: +>>> sendum(setupMobileOriginated()) +>>> sendum(connectAcknowledge()) +""") + + +# Section 10.2/3 +class TpPd(Packet): + """Skip indicator and transaction identifier and Protocol Discriminator""" + name = "Skip Indicator And Transaction Identifier and Protocol \ +Discriminator" + fields_desc = [ + BitField("ti", 0x0, 4), + BitField("pd", 0x3, 4) + ] + + +class MessageType(Packet): + """Message Type Section 10.4""" + name = "Message Type" + fields_desc = [ + XByteField("mesType", 0x3C) + ] + + +## +# Message for Radio Resources management (RR) Section 9.1 +### + +# Network to MS +def additionalAssignment(MobileAllocation_presence=0, + StartingTime_presence=0): + """ADDITIONAL ASSIGNMENT Section 9.1.1""" + # Mandatory + a = TpPd(pd=0x6) + b = MessageType(mesType=0x3B) # 00111011 + c = ChannelDescription() + packet = a / b / c + # Not Mandatory + if MobileAllocation_presence is 1: + d = MobileAllocationHdr(ieiMA=0x72, eightBitMA=0x0) + packet = packet / d + if StartingTime_presence is 1: + e = StartingTimeHdr(ieiST=0x7C, eightBitST=0x0) + packet = packet / e + return packet + + +# Network to MS +def assignmentCommand(FrequencyList_presence=0, + CellChannelDescription_presence=0, + CellChannelDescription_presence1=0, + MultislotAllocation_presence=0, + ChannelMode_presence=0, ChannelMode_presence1=0, + ChannelMode_presence2=0, ChannelMode_presence3=0, + ChannelMode_presence4=0, ChannelMode_presence5=0, + ChannelMode_presence6=0, ChannelMode_presence7=0, + ChannelDescription=0, ChannelMode2_presence=0, + MobileAllocation_presence=0, StartingTime_presence=0, + FrequencyList_presence1=0, + ChannelDescription2_presence=0, + ChannelDescription_presence=0, + FrequencyChannelSequence_presence=0, + MobileAllocation_presence1=0, + CipherModeSetting_presence=0, + VgcsTargetModeIdentication_presence=0, + MultiRateConfiguration_presence=0): + """ASSIGNMENT COMMAND Section 9.1.2""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x2e) # 101110 + c = ChannelDescription2() + d = PowerCommand() + packet = a / b / c / d + if FrequencyList_presence is 1: + e = FrequencyListHdr(ieiFL=0x05, eightBitFL=0x0) + packet = packet / e + if CellChannelDescription_presence is 1: + f = CellChannelDescriptionHdr(ieiCCD=0x62, eightBitCCD=0x0) + packet = packet / f + if MultislotAllocation_presence is 1: + g = MultislotAllocationHdr(ieiMSA=0x10, eightBitMSA=0x0) + packet = packet / g + if ChannelMode_presence is 1: + h = ChannelModeHdr(ieiCM=0x63, eightBitCM=0x0) + packet = packet / h + if ChannelMode_presence1 is 1: + i = ChannelModeHdr(ieiCM=0x11, eightBitCM=0x0) + packet = packet / i + if ChannelMode_presence2 is 1: + j = ChannelModeHdr(ieiCM=0x13, eightBitCM=0x0) + packet = packet / j + if ChannelMode_presence3 is 1: + k = ChannelModeHdr(ieiCM=0x14, eightBitCM=0x0) + packet = packet / k + if ChannelMode_presence4 is 1: + l = ChannelModeHdr(ieiCM=0x15, eightBitCM=0x0) + packet = packet / l + if ChannelMode_presence5 is 1: + m = ChannelModeHdr(ieiCM=0x16, eightBitCM=0x0) + packet = packet / m + if ChannelMode_presence6 is 1: + n = ChannelModeHdr(ieiCM=0x17, eightBitCM=0x0) + packet = packet / n + if ChannelMode_presence7 is 1: + o = ChannelModeHdr(ieiCM=0x18, eightBitCM=0x0) + packet = packet / o + if ChannelDescription_presence is 1: + p = ChannelDescriptionHdr(ieiCD=0x64, eightBitCD=0x0) + packet = packet / p + if ChannelMode2_presence is 1: + q = ChannelMode2Hdr(ieiCM2=0x66, eightBitCM2=0x0) + packet = packet / q + if MobileAllocation_presence is 1: + r = MobileAllocationHdr(ieiMA=0x72, eightBitMA=0x0) + packet = packet / r + if StartingTime_presence is 1: + s = StartingTimeHdr(ieiST=0x7C, eightBitST=0x0) + packet = packet / s + if FrequencyList_presence1 is 1: + t = FrequencyListHdr(ieiFL=0x19, eightBitFL=0x0) + packet = packet / t + if ChannelDescription2_presence is 1: + u = ChannelDescription2Hdr(ieiCD2=0x1C, eightBitCD2=0x0) + packet = packet / u + if ChannelDescription_presence is 1: + v = ChannelDescriptionHdr(ieiCD=0x1D, eightBitCD=0x0) + packet = packet / v + if FrequencyChannelSequence_presence is 1: + w = FrequencyChannelSequenceHdr(ieiFCS=0x1E, eightBitFCS=0x0) + packet = packet / w + if MobileAllocation_presence1 is 1: + x = MobileAllocationHdr(ieiMA=0x21, eightBitMA=0x0) + packet = packet / x + if CipherModeSetting_presence is 1: + y = CipherModeSettingHdr(ieiCMS=0x9, eightBitCMS=0x0) + packet = packet / y + if VgcsTargetModeIdentication_presence is 1: + z = VgcsTargetModeIdenticationHdr(ieiVTMI=0x01, eightBitVTMI=0x0) + packet = packet / z + if MultiRateConfiguration_presence is 1: + aa = MultiRateConfigurationHdr(ieiMRC=0x03, eightBitMRC=0x0) + packet = packet / aa + return packet + + +# MS to Network +def assignmentComplete(): + """ASSIGNMENT COMPLETE Section 9.1.3""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x29) # 00101001 + c = RrCause() + packet = a / b / c + return packet + + +# MS to Network +def assignmentFailure(): + """ASSIGNMENT FAILURE Section 9.1.4""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x2F) # 00101111 + c = RrCause() + packet = a / b / c + return packet + + +# Network to MS +def channelModeModify(VgcsTargetModeIdentication_presence=0, + MultiRateConfiguration_presence=0): + """CHANNEL MODE MODIFY Section 9.1.5""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x8) # 0001000 + c = ChannelDescription2() + d = ChannelMode() + packet = a / b / c / d + if VgcsTargetModeIdentication is 1: + e = VgcsTargetModeIdenticationHdr(ieiVTMI=0x01, eightBitVTMI=0x0) + packet = packet / e + if MultiRateConfiguration is 1: + f = MultiRateConfigurationHdr(ieiMRC=0x03, eightBitMRC=0x0) + packet = packet / f + return packet + + +def channelModeModifyAcknowledge(): + """CHANNEL MODE MODIFY ACKNOWLEDGE Section 9.1.6""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x17) # 00010111 + c = ChannelDescription2() + d = ChannelMode() + packet = a / b / c / d + return packet + + +# Network to MS +def channelRelease(BaRange_presence=0, GroupChannelDescription_presence=0, + GroupCipherKeyNumber_presence=0, GprsResumption_presence=0, + BaListPref_presence=0): + """CHANNEL RELEASE Section 9.1.7""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0xD) # 00001101 + c = RrCause() + packet = a / b / c + if BaRange_presence is 1: + d = BaRangeHdr(ieiBR=0x73, eightBitBR=0x0) + packet = packet / d + if GroupChannelDescription_presence is 1: + e = GroupChannelDescriptionHdr(ieiGCD=0x74, eightBitGCD=0x0) + packet = packet / e + if GroupCipherKeyNumber_presence is 1: + f = GroupCipherKeyNumber(ieiGCKN=0x8) + packet = packet / f + if GprsResumption_presence is 1: + g = GprsResumptionHdr(ieiGR=0xC, eightBitGR=0x0) + packet = packet / g + if BaListPref_presence is 1: + h = BaListPrefHdr(ieiBLP=0x75, eightBitBLP=0x0) + packet = packet / h + return packet + + +class ChannelRequest(Packet): + """Channel request Section 9.1.8""" + name = "Channel Request" + fields_desc = [ + ByteField("estCause", 0x0) + ] + + +def channelRequest(): + return ChannelRequest() + + +# Network to MS +def cipheringModeCommand(): + """CIPHERING MODE COMMAND Section 9.1.9""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x35) # 00110101 + c = RrCause() + #d=cipherModeSetting() + #e=cipherResponse() + # FIX + d = CipherModeSettingAndcipherResponse() + packet = a / b / c / d + return packet + + +def cipheringModeComplete(MobileId_presence=0): + """CIPHERING MODE COMPLETE Section 9.1.10""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x32) # 00110010 + packet = a / b + if MobileId_presence is 1: + c = MobileIdHdr(ieiMI=0x17, eightBitMI=0x0) + packet = packet / c + return packet + + +# Network to MS +def classmarkChange(MobileStationClassmark3_presence=0): + """CLASSMARK CHANGE Section 9.1.11""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x16) # 00010110 + c = MobileStationClassmark2() + packet = a / b / c + if MobileStationClassmark3_presence is 1: + e = MobileStationClassmark3(ieiMSC3=0x20) + packet = packet / e + return packet + + +# Network to MS +def classmarkEnquiry(): + """CLASSMARK ENQUIRY Section 9.1.12""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x13) # 00010011 + packet = a / b + return packet +# 9.1.12a Spare + + +# Network to MS +def configurationChangeCommand(ChannelMode_presence=0, + ChannelMode_presence1=0, + ChannelMode_presence2=0, + ChannelMode_presence3=0, + ChannelMode_presence4=0, + ChannelMode_presence5=0, + ChannelMode_presence6=0, + ChannelMode_presence7=0): + """CONFIGURATION CHANGE COMMAND Section 9.1.12b""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x30) # 00110000 + c = MultislotAllocation() + packet = a / b / c + if ChannelMode_presence is 1: + d = ChannelModeHdr(ieiCM=0x63, eightBitCM=0x0) + packet = packet / d + if ChannelMode_presence1 is 1: + e = ChannelModeHdr(ieiCM=0x11, eightBitCM=0x0) + packet = packet / e + if ChannelMode_presence2 is 1: + f = ChannelModeHdr(ieiCM=0x13, eightBitCM=0x0) + packet = packet / f + if ChannelMode_presence3 is 1: + g = ChannelModeHdr(ieiCM=0x14, eightBitCM=0x0) + packet = packet / g + if ChannelMode_presence4 is 1: + h = ChannelModeHdr(ieiCM=0x15, eightBitCM=0x0) + packet = packet / h + if ChannelMode_presence5 is 1: + i = ChannelModeHdr(ieiCM=0x16, eightBitCM=0x0) + packet = packet / i + if ChannelMode_presence6 is 1: + j = ChannelModeHdr(ieiCM=0x17, eightBitCM=0x0) + packet = packet / j + if ChannelMode_presence7 is 1: + k = ChannelModeHdr(ieiCM=0x18, eightBitCM=0x0) + packet = packet / k + return packet + + +def configurationChangeAcknowledge(): + """CONFIGURATION CHANGE ACKNOWLEDGE Section 9.1.12c""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x31) # 00110001 + c = MobileId() + packet = a / b / c + return packet + + +def configurationChangeReject(): + """CONFIGURATION CHANGE REJECT Section 9.1.12d""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x33) # 00110011 + c = RrCause() + packet = a / b / c + return packet + + +# Network to MS +def frequencyRedefinition(CellChannelDescription_presence=0): + """Frequency redefinition Section 9.1.13""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x14) # 00010100 + c = ChannelDescription() + d = MobileAllocation() + e = StartingTime() + packet = a / b / c / d / e + if CellChannelDescription_presence is 1: + f = CellChannelDescriptionHdr(ieiCCD=0x62, eightBitCCD=0x0) + packet = packet / f + return packet + + +# Network to MS +def pdchAssignmentCommand(ChannelDescription_presence=0, + CellChannelDescription_presence=0, + MobileAllocation_presence=0, + StartingTime_presence=0, FrequencyList_presence=0, + ChannelDescription_presence1=0, + FrequencyChannelSequence_presence=0, + MobileAllocation_presence1=0, + PacketChannelDescription_presence=0, + DedicatedModeOrTBF_presence=0): + """PDCH ASSIGNMENT COMMAND Section 9.1.13a""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x23) # 00100011 + c = ChannelDescription() + packet = a / b / c + if ChannelDescription_presence is 1: + d = ChannelDescriptionHdr(ieiCD=0x62, eightBitCD=0x0) + packet = packet / d + if CellChannelDescription_presence is 1: + e = CellChannelDescriptionHdr(ieiCCD=0x05, eightBitCCD=0x0) + packet = packet / e + if MobileAllocation_presence is 1: + f = MobileAllocationHdr(ieiMA=0x72, eightBitMA=0x0) + packet = packet / f + if StartingTime_presence is 1: + g = StartingTimeHdr(ieiST=0x7C, eightBitST=0x0) + packet = packet / g + if FrequencyList_presence is 1: + h = FrequencyListHdr(ieiFL=0x19, eightBitFL=0x0) + packet = packet / h + if ChannelDescription_presence1 is 1: + i = ChannelDescriptionHdr(ieiCD=0x1C, eightBitCD=0x0) + packet = packet / i + if FrequencyChannelSequence_presence is 1: + j = FrequencyChannelSequenceHdr(ieiFCS=0x1E, eightBitFCS=0x0) + packet = packet / j + if MobileAllocation_presence1 is 1: + k = MobileAllocationHdr(ieiMA=0x21, eightBitMA=0x0) + packet = packet / k + if PacketChannelDescription_presence is 1: + l = PacketChannelDescription(ieiPCD=0x22) + packet = packet / l + if DedicatedModeOrTBF_presence is 1: + m = DedicatedModeOrTBFHdr(ieiDMOT=0x23, eightBitDMOT=0x0) + packet = packet / m + return packet + + +def gprsSuspensionRequest(): + """GPRS SUSPENSION REQUEST Section 9.1.13b""" + a = TpPd(pd=0x6) + b = MessageType() + c = Tlli() + d = RoutingAreaIdentification() + e = SuspensionCause() + packet = a / b / c / d / e + return packet + + +class HandoverAccess(Packet): + name = "Handover Access" # Section 9.1.14" + fields_desc = [ + ByteField("handover", None), + ] + + +# Network to MS +def handoverCommand(SynchronizationIndication_presence=0, + FrequencyShortList_presence=0, FrequencyList_presence=0, + CellChannelDescription_presence=0, + MultislotAllocation_presence=0, + ChannelMode_presence=0, ChannelMode_presence1=0, + ChannelMode_presence2=0, + ChannelMode_presence3=0, ChannelMode_presence4=0, + ChannelMode_presence5=0, + ChannelMode_presence6=0, ChannelMode_presence7=0, + ChannelDescription_presence1=0, ChannelMode2_presence=0, + FrequencyChannelSequence_presence=0, + MobileAllocation_presence=0, + StartingTime_presence=0, TimeDifference_presence=0, + TimingAdvance_presence=0, + FrequencyShortList_presence1=0, + FrequencyList_presence1=0, + ChannelDescription2_presence=0, + ChannelDescription_presence2=0, + FrequencyChannelSequence_presence1=0, + MobileAllocation_presence1=0, + CipherModeSetting_presence=0, + VgcsTargetModeIdentication_presence=0, + MultiRateConfiguration_presence=0): + """HANDOVER COMMAND Section 9.1.15""" + name = "Handover Command" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x2b) # 00101011 + c = CellDescription() + d = ChannelDescription2() + e = HandoverReference() + f = PowerCommandAndAccessType() + packet = a / b / c / d / e / f + if SynchronizationIndication_presence is 1: + g = SynchronizationIndicationHdr(ieiSI=0xD, eightBitSI=0x0) + packet = packet / g + if FrequencyShortList_presence is 1: + h = FrequencyShortListHdr(ieiFSL=0x02) + packet = packet / h + if FrequencyList_presence is 1: + i = FrequencyListHdr(ieiFL=0x05, eightBitFL=0x0) + packet = packet / i + if CellChannelDescription_presence is 1: + j = CellChannelDescriptionHdr(ieiCCD=0x62, eightBitCCD=0x0) + packet = packet / j + if MultislotAllocation_presence is 1: + k = MultislotAllocationHdr(ieiMSA=0x10, eightBitMSA=0x0) + packet = packet / k + if ChannelMode_presence is 1: + l = ChannelModeHdr(ieiCM=0x63, eightBitCM=0x0) + packet = packet / l + if ChannelMode_presence1 is 1: + m = ChannelModeHdr(ieiCM=0x11, eightBitCM=0x0) + packet = packet / m + if ChannelMode_presence2 is 1: + n = ChannelModeHdr(ieiCM=0x13, eightBitCM=0x0) + packet = packet / n + if ChannelMode_presence3 is 1: + o = ChannelModeHdr(ieiCM=0x14, eightBitCM=0x0) + packet = packet / o + if ChannelMode_presence4 is 1: + p = ChannelModeHdr(ieiCM=0x15, eightBitCM=0x0) + packet = packet / p + if ChannelMode_presence5 is 1: + q = ChannelModeHdr(ieiCM=0x16, eightBitCM=0x0) + packet = packet / q + if ChannelMode_presence6 is 1: + r = ChannelModeHdr(ieiCM=0x17, eightBitCM=0x0) + packet = packet / r + if ChannelMode_presence7 is 1: + s = ChannelModeHdr(ieiCM=0x18, eightBitCM=0x0) + packet = packet / s + if ChannelDescription_presence1 is 1: + s1 = ChannelDescriptionHdr(ieiCD=0x64, eightBitCD=0x0) + packet = packet / s1 + if ChannelMode2_presence is 1: + t = ChannelMode2Hdr(ieiCM2=0x66, eightBitCM2=0x0) + packet = packet / t + if FrequencyChannelSequence_presence is 1: + u = FrequencyChannelSequenceHdr(ieiFCS=0x69, eightBitFCS=0x0) + packet = packet / u + if MobileAllocation_presence is 1: + v = MobileAllocationHdr(ieiMA=0x72, eightBitMA=0x0) + packet = packet / v + if StartingTime_presence is 1: + w = StartingTimeHdr(ieiST=0x7C, eightBitST=0x0) + packet = packet / w + if TimeDifference_presence is 1: + x = TimeDifferenceHdr(ieiTD=0x7B, eightBitTD=0x0) + packet = packet / x + if TimingAdvance_presence is 1: + y = TimingAdvanceHdr(ieiTA=0x7D, eightBitTA=0x0) + packet = packet / y + if FrequencyShortList_presence1 is 1: + z = FrequencyShortListHdr(ieiFSL=0x12) + packet = packet / z + if FrequencyList_presence1 is 1: + aa = FrequencyListHdr(ieiFL=0x19, eightBitFL=0x0) + packet = packet / aa + if ChannelDescription2_presence is 1: + ab = ChannelDescription2Hdr(ieiCD2=0x1C, eightBitCD2=0x0) + packet = packet / ab + if ChannelDescription_presence2 is 1: + ac = ChannelDescriptionHdr(ieiCD=0x1D, eightBitCD=0x0) + packet = packet / ac + if FrequencyChannelSequence_presence1 is 1: + ad = FrequencyChannelSequenceHdr(ieiFCS=0x1E, eightBitFCS=0x0) + packet = packet / ad + if MobileAllocation_presence1 is 1: + ae = MobileAllocationHdr(ieiMA=0x21, eightBitMA=0x0) + packet = packet / ae + if CipherModeSetting_presence is 1: + af = CipherModeSettingHdr(ieiCMS=0x9, eightBitCMS=0x0) + packet = packet / af + if VgcsTargetModeIdentication_presence is 1: + ag = VgcsTargetModeIdenticationHdr(ieiVTMI=0x01, eightBitVTMI=0x0) + packet = packet / ag + if MultiRateConfiguration_presence is 1: + ah = MultiRateConfigurationHdr(ieiMRC=0x03, eightBitMRC=0x0) + packet = packet / ah + return packet + + +def handoverComplete(MobileTimeDifference_presence=0): + """HANDOVER COMPLETE Section 9.1.16""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x2c) # 00101100 + c = RrCause() + packet = a / b / c + if MobileTimeDifference_presence is 1: + d = MobileTimeDifferenceHdr(ieiMTD=0x77, eightBitMTD=0x0) + packet = packet / d + return packet + + +def handoverFailure(): + """HANDOVER FAILURE Section 9.1.17""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x28) # 00101000 + c = RrCause() + packet = a / b / c + return packet + + +#The L2 pseudo length of this message is the sum of lengths of all +#information elements present in the message except +#the IA Rest Octets and L2 Pseudo Length information elements. +# Network to MS +def immediateAssignment(ChannelDescription_presence=0, + PacketChannelDescription_presence=0, + StartingTime_presence=0): + """IMMEDIATE ASSIGNMENT Section 9.1.18""" + a = L2PseudoLength() + b = TpPd(pd=0x6) + c = MessageType(mesType=0x3F) # 00111111 + d = PageModeAndDedicatedModeOrTBF() + packet = a / b / c / d + if ChannelDescription_presence is 1: + f = ChannelDescription() + packet = packet / f + if PacketChannelDescription_presence is 1: + g = PacketChannelDescription() + packet = packet / g + h = RequestReference() + i = TimingAdvance() + j = MobileAllocation() + packet = packet / h / i / j + if StartingTime_presence is 1: + k = StartingTimeHdr(ieiST=0x7C, eightBitST=0x0) + packet = packet / k + l = IaRestOctets() + packet = packet / l + return packet + + +#The L2 pseudo length of this message is the sum of lengths of all +#information elements present in the message except +#the IAX Rest Octets and L2 Pseudo Length information elements. + +# Network to MS +def immediateAssignmentExtended(StartingTime_presence=0): + """IMMEDIATE ASSIGNMENT EXTENDED Section 9.1.19""" + a = L2PseudoLength() + b = TpPd(pd=0x6) + c = MessageType(mesType=0x39) # 00111001 + d = PageModeAndSpareHalfOctets() + f = ChannelDescription() + g = RequestReference() + h = TimingAdvance() + i = MobileAllocation() + packet = a / b / c / d / f / g / h / i + if StartingTime_presence is 1: + j = StartingTimeHdr(ieiST=0x7C, eightBitST=0x0) + packet = packet / j + k = IaxRestOctets() + packet = packet / k + return packet + + +# This message has L2 pseudo length 19 +# Network to MS +def immediateAssignmentReject(): + """IMMEDIATE ASSIGNMENT REJECT Section 9.1.20""" + a = L2PseudoLength(l2pLength=0x13) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x3a) # 00111010 + d = PageModeAndSpareHalfOctets() + f = RequestReference() + g = WaitIndication() + h = RequestReference() + i = WaitIndication() + j = RequestReference() + k = WaitIndication() + l = RequestReference() + m = WaitIndication() + n = IraRestOctets() + packet = a / b / c / d / f / g / h / i / j / k / l / m / n + return packet + + +def measurementReport(): + """MEASUREMENT REPORT Section 9.1.21""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x15) # 00010101 + c = MeasurementResults() + packet = a / b / c + return packet + + +# len max 20 +class NotificationFacch(): + """NOTIFICATION/FACCH Section 9.1.21a""" + name = "Notification/facch" + fields_desc = [ + BitField("rr", 0x0, 1), + BitField("msgTyoe", 0x0, 5), + BitField("layer2Header", 0x0, 2), + BitField("frChanDes", 0x0, 24) + ] + + +# The L2 pseudo length of this message has a value one +# Network to MS +def notificationNch(): + """NOTIFICATION/NCH Section 9.1.21b""" + a = L2PseudoLength(l2pLength=0x01) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x20) # 00100000 + d = NtNRestOctets() + packet = a / b / c / d + return packet + + +def notificationResponse(): + """NOTIFICATION RESPONSE Section 9.1.21d""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x26) # 00100110 + c = MobileStationClassmark2() + d = MobileId() + e = DescriptiveGroupOrBroadcastCallReference() + packet = a / b / c / d / e + return packet + + +# Network to MS +def rrCellChangeOrder(): + """RR-CELL CHANGE ORDER Section 9.1.21e""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x8) # 00001000 + c = CellDescription() + d = NcModeAndSpareHalfOctets() + packet = a / b / c / d + return packet + + +# Network to MS +def pagingRequestType1(MobileId_presence=0): + """PAGING REQUEST TYPE 1 Section 9.1.22""" + #The L2 pseudo length of this message is the sum of lengths of all + #information elements present in the message except + #the P1 Rest Octets and L2 Pseudo Length information elements. + a = L2PseudoLength() + b = TpPd(pd=0x6) + c = MessageType(mesType=0x21) # 00100001 + d = PageModeAndChannelNeeded() + f = MobileId() + packet = a / b / c / d / f + if MobileId_presence is 1: + g = MobileIdHdr(ieiMI=0x17, eightBitMI=0x0) + packet = packet / g + h = P1RestOctets() + packet = packet / h + return packet + + +# The L2 pseudo length of this message is the sum of lengths of all +# information elements present in the message except +# Network to MS +def pagingRequestType2(MobileId_presence=0): + """PAGING REQUEST TYPE 2 Section 9.1.23""" + a = L2PseudoLength() + b = TpPd(pd=0x6) + c = MessageType(mesType=0x22) # 00100010 + d = PageModeAndChannelNeeded() + f = MobileId() + g = MobileId() + packet = a / b / c / d / f / g + if MobileId_presence is 1: + h = MobileIdHdr(ieiMI=0x17, eightBitMI=0x0) + packet = packet / h + i = P2RestOctets() + packet = packet / i + return packet + + +# Network to MS +def pagingRequestType3(): + """PAGING REQUEST TYPE 3 Section 9.1.24""" +# This message has a L2 Pseudo Length of 19 + a = L2PseudoLength(l2pLength=0x13) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x24) # 00100100 + d = PageModeAndChannelNeeded() + e = TmsiPTmsi() + f = TmsiPTmsi() + g = TmsiPTmsi() + h = TmsiPTmsi() + i = P3RestOctets() + packet = a / b / c / d / e / f / g / h / i + return packet + + +def pagingResponse(): + """PAGING RESPONSE Section 9.1.25""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x27) # 00100111 + c = CiphKeySeqNrAndSpareHalfOctets() + d = MobileStationClassmark2() + e = MobileId() + packet = a / b / c / d / e + return packet + + +# Network to MS +def partialRelease(): + """PARTIAL RELEASE Section 9.1.26""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0xa) # 00001010 + c = ChannelDescription() + packet = a / b / c + return packet + + +def partialReleaseComplete(): + """PARTIAL RELEASE COMPLETE Section 9.1.27""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0xf) # 00001111 + packet = a / b + return packet + + +# Network to MS +def physicalInformation(): + """PHYSICAL INFORMATION Section 9.1.28""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x2d) # 00101101 + c = TimingAdvance() + packet = a / b / c + return packet + + +def rrInitialisationRequest(): + """RR Initialisation Request Section 9.1.28.a""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x3c) # 00111100 + c = CiphKeySeqNrAndMacModeAndChannelCodingRequest() + e = MobileStationClassmark2() + f = Tlli() + g = ChannelRequestDescription() + h = GprsMeasurementResults() + packet = a / b / c / e / f / g / h + return packet + + +def rrStatus(): + """RR STATUS Section 9.1.29""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x12) # 00010010 + c = RrCause() + packet = a / b / c + return packet + + +# It does not +# follow the basic format. Its length is _25_ bits. The +# order of bit transmission is defined in GSM 04.04. +# Network to MS +class SynchronizationChannelInformation(): + """SYNCHRONIZATION CHANNEL INFORMATION Section 9.1.30""" + name = "Synchronization Channel Information" + fields_desc = [ + BitField("bsic", 0x0, 5), + BitField("t1Hi", 0x0, 3), + ByteField("t1Mi", 0x0), + BitField("t1Lo", 0x0, 1), + BitField("t2", 0x0, 5), + BitField("t3Hi", 0x0, 2), + BitField("t3Lo", 0x0, 1) + ] + + +# This message has a L2 Pseudo Length of 21. +# Network to MS +def systemInformationType1(): + """SYSTEM INFORMATION TYPE 1 Section 9.1.31""" + a = L2PseudoLength(l2pLength=0x15) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x19) # 00011001 + d = CellChannelDescription() + e = RachControlParameters() + f = Si1RestOctets() + packet = a / b / c / d / e / f + return packet + + +# This message has a L2 Pseudo Length of 22. +# Network to MS +def systemInformationType2(): + """SYSTEM INFORMATION TYPE 2 Section 9.1.32""" + a = L2PseudoLength(l2pLength=0x16) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x1a) # 00011010 + d = NeighbourCellsDescription() + e = NccPermitted() + f = RachControlParameters() + packet = a / b / c / d / e / f + return packet + + +# This message has a L2 pseudo length of 21 +# Network to MS +def systemInformationType2bis(): + """SYSTEM INFORMATION TYPE 2bis Section 9.1.33""" + a = L2PseudoLength(l2pLength=0x15) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x2) # 00000010 + d = NeighbourCellsDescription() + e = RachControlParameters() + f = Si2bisRestOctets() + packet = a / b / c / d / e / f + return packet + + +# This message has a L2 pseudo length of 18 +# Network to MS +def systemInformationType2ter(): + """SYSTEM INFORMATION TYPE 2ter Section 9.1.34""" + a = L2PseudoLength(l2pLength=0x12) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x3) # 00000011 + d = NeighbourCellsDescription2() + e = Si2terRestOctets() + packet = a / b / c / d / e + return packet + + +# This message has a L2 Pseudo Length of 18 +# Network to MS +def systemInformationType3(): + """SYSTEM INFORMATION TYPE 3 Section 9.1.35""" + a = L2PseudoLength(l2pLength=0x12) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x1b) # 00011011 + d = CellIdentity() + e = LocalAreaId() + f = ControlChannelDescription() + g = CellOptionsBCCH() + h = CellSelectionParameters() + i = RachControlParameters() + j = Si3RestOctets() + packet = a / b / c / d / e / f / g / h / i / j + return packet + + +#The L2 pseudo length of this message is the +#sum of lengths of all information elements present in the message except +#the SI 4 Rest Octets and L2 Pseudo Length +# Network to MS +def systemInformationType4(ChannelDescription_presence=0, + MobileAllocation_presence=0): + """SYSTEM INFORMATION TYPE 4 Section 9.1.36""" + a = L2PseudoLength() + b = TpPd(pd=0x6) + c = MessageType(mesType=0x1C) # 000111100 + d = LocalAreaId() + e = CellSelectionParameters() + f = RachControlParameters() + packet = a / b / c / d / e / f + if ChannelDescription_presence is 1: + g = ChannelDescriptionHdr(ieiCD=0x64, eightBitCD=0x0) + packet = packet / g + if MobileAllocation_presence is 1: + h = MobileAllocationHdr(ieiMA=0x72, eightBitMA=0x0) + packet = packet / h + i = Si4RestOctets() + packet = packet / i + return packet + + +#This message has a L2 Pseudo Length of 18 +# Network to MS +def systemInformationType5(): + """SYSTEM INFORMATION TYPE 5 Section 9.1.37""" + a = L2PseudoLength(l2pLength=0x12) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x35) # 000110101 + d = NeighbourCellsDescription() + packet = a / b / c / d + return packet + + +#This message has a L2 Pseudo Length of 18 +# Network to MS +def systemInformationType5bis(): + """SYSTEM INFORMATION TYPE 5bis Section 9.1.38""" + a = L2PseudoLength(l2pLength=0x12) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x5) # 00000101 + d = NeighbourCellsDescription() + packet = a / b / c / d + return packet + + +# This message has a L2 Pseudo Length of 18 +# Network to MS +def systemInformationType5ter(): + """SYSTEM INFORMATION TYPE 5ter Section 9.1.39""" + a = L2PseudoLength(l2pLength=0x12) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x6) # 00000110 + d = NeighbourCellsDescription2() + packet = a / b / c / d + return packet + + +#This message has a L2 Pseudo Length of 11 +# Network to MS +def systemInformationType6(): + """SYSTEM INFORMATION TYPE 6 Section 9.1.40""" + a = L2PseudoLength(l2pLength=0x0b) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x1e) # 00011011 + d = CellIdentity() + e = LocalAreaId() + f = CellOptionsBCCH() + g = NccPermitted() + h = Si6RestOctets() + packet = a / b / c / d / e / f / g + return packet + + +# The L2 pseudo length of this message has the value 1 +# Network to MS +def systemInformationType7(): + """SYSTEM INFORMATION TYPE 7 Section 9.1.41""" + a = L2PseudoLength(l2pLength=0x01) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x37) # 000110111 + d = Si7RestOctets() + packet = a / b / c / d + return packet + + +# The L2 pseudo length of this message has the value 1 +# Network to MS +def systemInformationType8(): + """SYSTEM INFORMATION TYPE 8 Section 9.1.42""" + a = L2PseudoLength(l2pLength=0x01) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x18) # 00011000 + d = Si8RestOctets() + packet = a / b / c / d + return packet + + +# The L2 pseudo length of this message has the value 1 +# Network to MS +def systemInformationType9(): + """SYSTEM INFORMATION TYPE 9 Section 9.1.43""" + a = L2PseudoLength(l2pLength=0x01) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x4) # 00000100 + d = Si9RestOctets() + packet = a / b / c / d + return packet + + +# The L2 pseudo length of this message has the value 0 +# Network to MS +def systemInformationType13(): + """SYSTEM INFORMATION TYPE 13 Section 9.1.43a""" + a = L2PseudoLength(l2pLength=0x00) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x0) # 00000000 + d = Si13RestOctets() + packet = a / b / c / d + return packet +# +# 9.1.43b / c spare +# + + +# The L2 pseudo length of this message has the value 1 +# Network to MS +def systemInformationType16(): + """SYSTEM INFORMATION TYPE 16 Section 9.1.43d""" + a = L2PseudoLength(l2pLength=0x01) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x3d) # 00111101 + d = Si16RestOctets() + packet = a / b / c / d + return packet + + +# The L2 pseudo length of this message has the value 1 +# Network to MS +def systemInformationType17(): + """SYSTEM INFORMATION TYPE 17 Section 9.1.43e""" + a = L2PseudoLength(l2pLength=0x01) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x3e) # 00111110 + d = Si17RestOctets() + packet = a / b / c / d + return packet + + +def talkerIndication(): + """TALKER INDICATION Section 9.1.44""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x11) # 00010001 + c = MobileStationClassmark2() + d = MobileId() + packet = a / b / c / d + return packet + + +class UplinkAccess(): + """UPLINK ACCESS Section 9.1.45""" + name = "Uplink Access" + fields_desc = [ + ByteField("establishment", 0x0) + ] + + +# Network to MS +def uplinkBusy(): + """UPLINK BUSY Section 9.1.46""" + name = "Uplink Busy" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x2a) # 00101010 + packet = a / b + return packet + + +# Network to MS +class UplinkFree(): + """UPLINK FREE Section 9.1.47""" + name = "Uplink Free" + fields_desc = [ + BitField("pd", 0x0, 1), + BitField("msgType", 0x0, 5), + BitField("layer2Header", 0x0, 2), + BitField("uplinkAccess", 0x0, 1), + BitField("lOrH", 0x0, 1), # 0 for L, 1 for H + BitField("upIdCode", 0x0, 6), + ] + + +def uplinkRelease(): + """UPLINK RELEASE Section 9.1.48""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0xe) # 00001110 + c = RrCause() + packet = a / b / c + return packet + + +# Network to MS +def vgcsUplinkGrant(): + """VGCS UPLINK GRANT Section 9.1.49""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x9) # 00001001 + c = RrCause() + d = RequestReference() + e = TimingAdvance() + packet = a / b / c / d / e + return packet + + +# Network to MS +def systemInformationType10(): + """SYSTEM INFORMATION TYPE 10 Section 9.1.50""" + name = "SyStem Information Type 10" + fields_desc = [ + BitField("pd", 0x0, 1), + BitField("msgType", 0x0, 5), + BitField("layer2Header", 0x0, 2), + BitField("si10", 0x0, 160) + ] + + +# Network to MS +# The L2 pseudo length of this message has the value 18 +def extendedMeasurementOrder(): + """EXTENDED MEASUREMENT ORDER Section 9.1.51""" + a = L2PseudoLength(l2pLength=0x12) + b = TpPd(pd=0x6) + c = MessageType(mesType=0x37) # 00110111 + d = ExtendedMeasurementFrequencyList() + packet = a / b / c / d + return packet + + +def extendedMeasurementReport(): + """EXTENDED MEASUREMENT REPORT Section 9.1.52""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x36) # 00110110 + c = ExtendedMeasurementResults() + packet = a / b / c + return packet + + +def applicationInformation(): + """APPLICATION INFORMATION Section 9.1.53""" + a = TpPd(pd=0x6) + b = MessageType(mesType=0x38) # 00111000 + c = ApduIDAndApduFlags() + e = ApduData() + packet = a / b / c / e + return packet +# +# 9.2 Messages for mobility management +# + + +# Network to MS +def authenticationReject(): + """AUTHENTICATION REJECT Section 9.2.1""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x11) # 00010001 + packet = a / b + return packet + + +# Network to MS +def authenticationRequest(): + """AUTHENTICATION REQUEST Section 9.2.2""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x12) # 00010010 + c = CiphKeySeqNrAndSpareHalfOctets() + d = AuthenticationParameterRAND() + packet = a / b / c / d + return packet + + +def authenticationResponse(): + """AUTHENTICATION RESPONSE Section 9.2.3""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x14) # 00010100 + c = AuthenticationParameterSRES() + packet = a / b / c + return packet + + +def cmReestablishmentRequest(LocalAreaId_presence=0): + """CM RE-ESTABLISHMENT REQUEST Section 9.2.4""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x28) # 00101000 + c = CiphKeySeqNrAndSpareHalfOctets() + e = MobileStationClassmark2() + f = MobileId() + if LocalAreaId_presence is 1: + g = LocalAreaId(iei=0x13, eightbit=0x0) + packet = packet / g + packet = a / b / c / e / f + return packet + + +# Network to MS +def cmServiceAccept(): + """CM SERVICE ACCEPT Section 9.2.5""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x21) # 00100001 + packet = a / b + return packet + + +# Network to MS +def cmServicePrompt(): + """CM SERVICE PROMPT Section 9.2.5a""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x25) # 00100101 + c = PdAndSapi() + packet = a / b / c + return packet + + +# Network to MS +def cmServiceReject(): + """CM SERVICE REJECT Section 9.2.6""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x22) # 00100010 + c = RejectCause() + packet = a / b / c + return packet + + +def cmServiceAbort(): + """CM SERVICE ABORT Section 9.2.7""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x23) # 00100011 + packet = a / b + return packet + + +# Network to MS +def abort(): + """ABORT Section 9.2.8""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x29) # 00101001 + c = RejectCause() + packet = a / b / c + return packet + + +def cmServiceRequest(PriorityLevel_presence=0): + """CM SERVICE REQUEST Section 9.2.9""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x24) # 00100100 + c = CmServiceTypeAndCiphKeySeqNr() + e = MobileStationClassmark2() + f = MobileId() + packet = a / b / c / e / f + if PriorityLevel_presence is 1: + g = PriorityLevelHdr(ieiPL=0x8, eightBitPL=0x0) + packet = packet / g + return packet + + +# Network to MS +def identityRequest(): + """IDENTITY REQUEST Section 9.2.10""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x8) # 00001000 + c = IdentityTypeAndSpareHalfOctets() + packet = a / b / c + return packet + + +def identityResponse(): + """IDENTITY RESPONSE Section 9.2.11""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x9) # 00001001 + c = MobileId() + packet = a / b / c + return packet + + +def imsiDetachIndication(): + """IMSI DETACH INDICATION Section 9.2.12""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x1) # 00000001 + c = MobileStationClassmark1() + d = MobileId() + packet = a / b / c / d + return packet + + +# Network to MS +def locationUpdatingAccept(MobileId_presence=0, + FollowOnProceed_presence=0, + CtsPermission_presence=0): + """LOCATION UPDATING ACCEPT Section 9.2.13""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x02) # 00000010 + c = LocalAreaId() + packet = a / b / c + if MobileId_presence is 1: + d = MobileIdHdr(ieiMI=0x17, eightBitMI=0x0) + packet = packet / d + if FollowOnProceed_presence is 1: + e = FollowOnProceed(ieiFOP=0xA1) + packet = packet / e + if CtsPermission_presence is 1: + f = CtsPermissionHdr(ieiCP=0xA2, eightBitCP=0x0) + packet = packet / f + return packet + + +# Network to MS +def locationUpdatingReject(): + """LOCATION UPDATING REJECT Section 9.2.14""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x4) # 0x00000100 + c = RejectCause() + packet = a / b / c + return packet + + +def locationUpdatingRequest(): + """LOCATION UPDATING REQUEST Section 9.2.15""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x8) # 00001000 + c = LocationUpdatingTypeAndCiphKeySeqNr() + e = LocalAreaId() + f = MobileStationClassmark1() + g = MobileId() + packet = a / b / c / e / f / g + return packet + + +# Network to MS +def mmInformation(NetworkName_presence=0, NetworkName_presence1=0, + TimeZone_presence=0, TimeZoneAndTime_presence=0, + LsaIdentifier_presence=0): + """MM INFORMATION Section 9.2.15a""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x32) # 00110010 + packet = a / b + if NetworkName_presence is 1: + c = NetworkNameHdr(ieiNN=0x43, eightBitNN=0x0) + packet = packet / c + if NetworkName_presence1 is 1: + d = NetworkNameHdr(ieiNN=0x45, eightBitNN=0x0) + packet = packet / d + if TimeZone_presence is 1: + e = TimeZoneHdr(ieiTZ=0x46, eightBitTZ=0x0) + packet = packet / e + if TimeZoneAndTime_presence is 1: + f = TimeZoneAndTimeHdr(ieiTZAT=0x47, eightBitTZAT=0x0) + packet = packet / f + if LsaIdentifier_presence is 1: + g = LsaIdentifierHdr(ieiLI=0x48, eightBitLI=0x0) + packet = packet / g + return packet + + +def mmStatus(): + """MM STATUS Section 9.2.16""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x31) # 00110001 + c = RejectCause() + packet = a / b / c + return packet + + +# Network to MS +def tmsiReallocationCommand(): + """TMSI REALLOCATION COMMAND Section 9.2.17""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x1a) # 00011010 + c = LocalAreaId() + d = MobileId() + packet = a / b / c / d + return packet + + +def tmsiReallocationComplete(): + """TMSI REALLOCATION COMPLETE Section 9.2.18""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x1b) # 00011011 + packet = a / b + return packet + + +def mmNull(): + """MM NULL Section 9.2.19""" + a = TpPd(pd=0x5) + b = MessageType(mesType=0x30) # 00110000 + packet = a / b + return packet + +# +# 9.3 Messages for circuit-switched call control +# + + +# Network to MS +def alertingNetToMs(Facility_presence=0, ProgressIndicator_presence=0, + UserUser_presence=0): + """ALERTING Section 9.3.1.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1) # 00000001 + packet = a / b + if Facility_presence is 1: + c = FacilityHdr(ieiF=0x1C) + packet = packet / c + if ProgressIndicator_presence is 1: + d = ProgressIndicatorHdr(ieiPI=0x1E) + packet = packet / d + if UserUser_presence is 1: + e = UserUserHdr(ieiUU=0x7E) + packet = packet / e + return packet + + +def alertingMsToNet(Facility_presence=0, UserUser_presence=0, + SsVersionIndicator_presence=0): + """ALERTING Section 9.3.1.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1) # 00000001 + packet = a / b + if Facility_presence is 1: + c = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / c + if UserUser_presence is 1: + d = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / d + if SsVersionIndicator_presence is 1: + e = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / e + return packet + + +def callConfirmed(RepeatIndicator_presence=0, + BearerCapability_presence=0, BearerCapability_presence1=0, + Cause_presence=0, CallControlCapabilities_presence=0): + """CALL CONFIRMED Section 9.3.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x8) # 00001000 + packet = a / b + if RepeatIndicator_presence is 1: + c = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / c + if BearerCapability_presence is 1: + d = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / d + if BearerCapability_presence1 is 1: + e = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / e + if Cause_presence is 1: + f = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / f + if CallControlCapabilities_presence is 1: + g = CallControlCapabilitiesHdr(ieiCCC=0x15, eightBitCCC=0x0) + packet = packet / g + return packet + + +# Network to MS +def callProceeding(RepeatIndicator_presence=0, + BearerCapability_presence=0, + BearerCapability_presence1=0, + Facility_presence=0, ProgressIndicator_presence=0, + PriorityLevel_presence=0): + """CALL PROCEEDING Section 9.3.3""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x2) # 00000010 + packet = a / b + if RepeatIndicator_presence is 1: + c = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / c + if BearerCapability_presence is 1: + d = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / d + if BearerCapability_presence1 is 1: + e = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / e + if Facility_presence is 1: + f = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / f + if ProgressIndicator_presence is 1: + g = ProgressIndicatorHdr(ieiPI=0x1E, eightBitPI=0x0) + packet = packet / g + if PriorityLevel_presence is 1: + h = PriorityLevelHdr(ieiPL=0x80, eightBitPL=0x0) + packet = packet / h + return packet + + +# Network to MS +def congestionControl(Cause_presence=0): + """CONGESTION CONTROL Section 9.3.4""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x39) # 00111001 + c = CongestionLevelAndSpareHalfOctets() + packet = a / b / c + if Cause_presence is 1: + e = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / e + return packet + + +# Network to MS +def connectNetToMs(Facility_presence=0, ProgressIndicator_presence=0, + ConnectedNumber_presence=0, ConnectedSubaddress_presence=0, + UserUser_presence=0): + """CONNECT Section 9.3.5.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x7) # 00000111 + packet = a / b + if Facility_presence is 1: + c = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / c + if ProgressIndicator_presence is 1: + d = ProgressIndicatorHdr(ieiPI=0x1E, eightBitPI=0x0) + packet = packet / d + if ConnectedNumber_presence is 1: + e = ConnectedNumberHdr(ieiCN=0x4C, eightBitCN=0x0) + packet = packet / e + if ConnectedSubaddress_presence is 1: + f = ConnectedSubaddressHdr(ieiCS=0x4D, eightBitCS=0x0) + packet = packet / f + if UserUser_presence is 1: + g = UserUserHdr(ieiUU=0x7F, eightBitUU=0x0) + packet = packet / g + return packet + + +def connectMsToNet(Facility_presence=0, ConnectedSubaddress_presence=0, + UserUser_presence=0, SsVersionIndicator_presence=0): + """CONNECT Section 9.3.5.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x7) # 00000111 + packet = a / b + if Facility_presence is 1: + c = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / c + if ConnectedSubaddress_presence is 1: + d = ConnectedSubaddressHdr(ieiCS=0x4D, eightBitCS=0x0) + packet = packet / d + if UserUser_presence is 1: + e = UserUserHdr(ieiUU=0x7F, eightBitUU=0x0) + packet = packet / e + if SsVersionIndicator_presence is 1: + f = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / f + return packet + + +def connectAcknowledge(): + """CONNECT ACKNOWLEDGE Section 9.3.6""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0xf) # 00001111 + packet = a / b + return packet + + +# Network to MS +def disconnectNetToMs(Facility_presence=0, ProgressIndicator_presence=0, + UserUser_presence=0, AllowedActions_presence=0): + """DISCONNECT Section 9.3.7.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x25) # 00100101 + c = Cause() + packet = a / b / c + if Facility_presence is 1: + d = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / d + if ProgressIndicator_presence is 1: + e = ProgressIndicatorHdr(ieiPI=0x1E, eightBitPI=0x0) + packet = packet / e + if UserUser_presence is 1: + f = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / f + if AllowedActions_presence is 1: + g = AllowedActionsHdr(ieiAA=0x7B, eightBitAA=0x0) + packet = packet / g + return packet + + +def disconnectMsToNet(Facility_presence=0, UserUser_presence=0, + SsVersionIndicator_presence=0): + """Disconnect Section 9.3.7.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x25) # 00100101 + c = Cause() + packet = a / b / c + if Facility_presence is 1: + d = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / d + if UserUser_presence is 1: + e = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / e + if SsVersionIndicator_presence is 1: + f = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / f + return packet + + +def emergencySetup(BearerCapability_presence=0): + """EMERGENCY SETUP Section 9.3.8""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0xe) # 00001110 + packet = a / b + if BearerCapability_presence is 1: + c = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / c + return packet + + +# Network to MS +def facilityNetToMs(): + """FACILITY Section 9.3.9.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x3a) # 00111010 + c = Facility() + packet = a / b / c + return packet + + +def facilityMsToNet(SsVersionIndicator_presence=0): + """FACILITY Section 9.3.9.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x3a) # 00111010 + c = Facility() + packet = a / b / c + if SsVersionIndicator_presence is 1: + d = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / d + return packet + + +def hold(): + """HOLD Section 9.3.10""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x18) # 00011000 + packet = a / b + return packet + + +# Network to MS +def holdAcknowledge(): + """HOLD ACKNOWLEDGE Section 9.3.11""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x19) # 00011001 + packet = a / b + return packet + + +# Network to MS +def holdReject(): + """HOLD REJECT Section 9.3.12""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1a) # 00011010 + c = Cause() + packet = a / b / c + return packet + + +def modify(LowLayerCompatibility_presence=0, + HighLayerCompatibility_presence=0, + ReverseCallSetupDirection_presence=0): + """MODIFY Section 9.3.13""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x17) # 00010111 + c = BearerCapability() + packet = a / b / c + if LowLayerCompatibility_presence is 1: + d = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / d + if HighLayerCompatibility_presence is 1: + e = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / e + if ReverseCallSetupDirection_presence is 1: + f = ReverseCallSetupDirectionHdr(ieiRCSD=0xA3) + packet = packet / f + return packet + + +def modifyComplete(LowLayerCompatibility_presence=0, + HighLayerCompatibility_presence=0, + ReverseCallSetupDirection_presence=0): + """MODIFY COMPLETE Section 9.3.14""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1f) # 00011111 + c = BearerCapability() + packet = a / b / c + if LowLayerCompatibility_presence is 1: + d = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / d + if HighLayerCompatibility_presence is 1: + e = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / e + if ReverseCallSetupDirection_presence is 1: + f = ReverseCallSetupDirection(ieiRCSD=0xA3) + packet = packet / f + return packet + + +def modifyReject(LowLayerCompatibility_presence=0, + HighLayerCompatibility_presence=0): + """MODIFY REJECT Section 9.3.15""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x13) # 00010011 + c = BearerCapability() + d = Cause() + packet = a / b / c / d + if LowLayerCompatibility_presence is 1: + e = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / e + if HighLayerCompatibility_presence is 1: + f = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / f + return packet + + +def notify(): + """NOTIFY Section 9.3.16""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x3e) # 00111110 + c = NotificationIndicator() + packet = a / b / c + return packet + + +# Network to MS +def progress(UserUser_presence=0): + """PROGRESS Section 9.3.17""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x3) # 00000011 + c = ProgressIndicator() + packet = a / b / c + if UserUser_presence is 1: + d = UserUserHdr() + packet = packet / d + return packet + + +# Network to MS +def ccEstablishment(): + """CC-ESTABLISHMENT Section 9.3.17a""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x4) # 00000100 + c = SetupContainer() + packet = a / b / c + return packet + + +def ccEstablishmentConfirmed(RepeatIndicator_presence=0, + BearerCapability_presence=0, + BearerCapability_presence1=0, + Cause_presence=0): + """CC-ESTABLISHMENT CONFIRMED Section 9.3.17b""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x6) # 00000110 + packet = a / b + if RepeatIndicator_presence is 1: + c = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / c + if BearerCapability_presence is 1: + d = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / d + if BearerCapability_presence1 is 1: + e = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / e + if Cause_presence is 1: + f = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / f + return packet + + +# Network to MS +def releaseNetToMs(): + """RELEASE Section 9.3.18.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x2d) # 00101101 + c = CauseHdr(ieiC=0x08, eightBitC=0x0) + d = CauseHdr(ieiC=0x08, eightBitC=0x0) + e = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + f = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = a / b / c / d / e / f + return packet + + +def releaseMsToNet(Cause_presence=0, Cause_presence1=0, + Facility_presence=0, UserUser_presence=0, + SsVersionIndicator_presence=0): + """RELEASE Section 9.3.18.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x2d) # 00101101 + packet = a / b + if Cause_presence is 1: + c = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / c + if Cause_presence1 is 1: + d = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / d + if Facility_presence is 1: + e = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / e + if UserUser_presence is 1: + f = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / f + if SsVersionIndicator_presence is 1: + g = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / g + return packet + + +# Network to MS +def recall(): + """RECALL Section 9.3.18a""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0xb) # 00001011 + c = RecallType() + d = Facility() + packet = a / b / c / d + return packet + + +# Network to MS +def releaseCompleteNetToMs(Cause_presence=0, Facility_presence=0, + UserUser_presence=0): + """RELEASE COMPLETE Section 9.3.19.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x2a) # 00101010 + packet = a / b + if Cause_presence is 1: + c = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / c + if Facility_presence is 1: + d = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / d + if UserUser_presence is 1: + e = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / e + return packet + + +def releaseCompleteMsToNet(Cause_presence=0, Facility_presence=0, + UserUser_presence=0, SsVersionIndicator_presence=0): + """RELEASE COMPLETE Section 9.3.19.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x2a) # 00101010 + packet = a / b + if Cause_presence is 1: + c = CauseHdr(ieiC=0x08, eightBitC=0x0) + packet = packet / c + if Facility_presence is 1: + d = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / d + if UserUser_presence is 1: + e = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / e + if SsVersionIndicator_presence is 1: + f = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / f + return packet + + +def retrieve(): + """RETRIEVE Section 9.3.20""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1c) # 00011100 + packet = a / b + return packet + + +# Network to MS +def retrieveAcknowledge(): + """RETRIEVE ACKNOWLEDGE Section 9.3.21""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1d) # 00011101 + packet = a / b + return packet + + +# Network to MS +def retrieveReject(): + """RETRIEVE REJECT Section 9.3.22""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1e) # 00011110 + c = Cause() + packet = a / b / c + return packet + + +# Network to MS +def setupMobileTerminated(RepeatIndicator_presence=0, + BearerCapability_presence=0, + BearerCapability_presence1=0, + Facility_presence=0, ProgressIndicator_presence=0, + Signal_presence=0, + CallingPartyBcdNumber_presence=0, + CallingPartySubaddress_presence=0, + CalledPartyBcdNumber_presence=0, + CalledPartySubaddress_presence=0, +# RecallType_presence=0, + RedirectingPartyBcdNumber_presence=0, + RedirectingPartySubaddress_presence=0, + RepeatIndicator_presence1=0, + LowLayerCompatibility_presence=0, + LowLayerCompatibility_presence1=0, + RepeatIndicator_presence2=0, + HighLayerCompatibility_presence=0, + HighLayerCompatibility_presence1=0, + UserUser_presence=0, PriorityLevel_presence=0, + AlertingPattern_presence=0): + """SETUP Section 9.3.23.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x5) # 00000101 + packet = a / b + if RepeatIndicator_presence is 1: + c = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / c + if BearerCapability_presence is 1: + d = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / d + if BearerCapability_presence1 is 1: + e = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / e + if Facility_presence is 1: + f = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / f + if ProgressIndicator_presence is 1: + g = ProgressIndicatorHdr(ieiPI=0x1E, eightBitPI=0x0) + packet = packet / g + if Signal_presence is 1: + h = SignalHdr(ieiS=0x34, eightBitS=0x0) + packet = packet / h + if CallingPartyBcdNumber_presence is 1: + i = CallingPartyBcdNumberHdr(ieiCPBN=0x5C, eightBitCPBN=0x0) + packet = packet / i + if CallingPartySubaddress_presence is 1: + j = CallingPartySubaddressHdr(ieiCPS=0x5D, eightBitCPS=0x0) + packet = packet / j + if CalledPartyBcdNumber_presence is 1: + k = CalledPartyBcdNumberHdr(ieiCPBN=0x5E, eightBitCPBN=0x0) + packet = packet / k + if CalledPartySubaddress_presence is 1: + l = CalledPartySubaddressHdr(ieiCPS=0x6D, eightBitCPS=0x0) + packet = packet / l + if RedirectingPartyBcdNumber_presence is 1: + n = RedirectingPartyBcdNumberHdr(ieiRPBN=0x74, eightBitRPBN=0x0) + packet = packet / n + if RedirectingPartySubaddress_presence is 1: + m = RedirectingPartySubaddress_presence(ieiRPBN=0x75, eightBitRPBN=0x0) + packet = packet / m + if RepeatIndicator_presence1 is 1: + o = RepeatIndicatorHdr(ieiRI=0xD0, eightBitRI=0x0) + packet = packet / o + if LowLayerCompatibility_presence is 1: + p = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / p + if LowLayerCompatibility_presence1 is 1: + q = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / q + if RepeatIndicator_presence2 is 1: + r = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / r + if HighLayerCompatibility_presence is 1: + s = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / s + if HighLayerCompatibility_presence1 is 1: + t = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / t + if UserUser_presence is 1: + u = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / u + if PriorityLevel_presence is 1: + v = PriorityLevelHdr(ieiPL=0x8, eightBitPL=0x0) + packet = packet / v + if AlertingPattern_presence is 1: + w = AlertingPatternHdr(ieiAP=0x19, eightBitAP=0x0) + packet = packet / w + return packet + + +def setupMobileOriginated(RepeatIndicator_presence=0, + BearerCapability_presence=0, + BearerCapability_presence1=0, + Facility_presence=0, + CallingPartySubaddress_presence=0, + CalledPartyBcdNumber_presence=0, + CalledPartySubaddress_presence=0, + RepeatIndicator_presence1=0, + LowLayerCompatibility_presence=0, + LowLayerCompatibility_presence1=0, + RepeatIndicator_presence2=0, + HighLayerCompatibility_presence=0, + HighLayerCompatibility_presence1=0, + UserUser_presence=0, SsVersionIndicator_presence=0, + ClirSuppression_presence=0, + ClirInvocation_presence=0, + CallControlCapabilities_presence=0, + Facility_presence1=0, + Facility_presence2=0): + """SETUP Section 9.3.23.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x5) # 00000101 + packet = a / b + if RepeatIndicator_presence is 1: + c = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / c + if BearerCapability_presence is 1: + d = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / d + if BearerCapability_presence1 is 1: + e = BearerCapabilityHdr(ieiBC=0x04, eightBitBC=0x0) + packet = packet / e + if Facility_presence is 1: + f = FacilityHdr(ieiF=0x1C, eightBitF=0x0) + packet = packet / f + if CallingPartySubaddress_presence is 1: + g = CallingPartySubaddressHdr(ieiCPS=0x5D, eightBitCPS=0x0) + packet = packet / g + if CalledPartyBcdNumber_presence is 1: + h = CalledPartyBcdNumberHdr(ieiCPBN=0x5E, eightBitCPBN=0x0) + packet = packet / h + if CalledPartySubaddress_presence is 1: + i = CalledPartySubaddressHdr(ieiCPS=0x6D, eightBitCPS=0x0) + packet = packet / i + if RepeatIndicator_presence1 is 1: + j = RepeatIndicatorHdr(ieiRI=0xD0, eightBitRI=0x0) + packet = packet / j + if LowLayerCompatibility_presence is 1: + k = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / k + if LowLayerCompatibility_presence1 is 1: + l = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0) + packet = packet / l + if RepeatIndicator_presence2 is 1: + m = RepeatIndicatorHdr(ieiRI=0xD, eightBitRI=0x0) + packet = packet / m + if HighLayerCompatibility_presence is 1: + n = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / n + if HighLayerCompatibility_presence1 is 1: + o = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0) + packet = packet / o + if UserUser_presence is 1: + p = UserUserHdr(ieiUU=0x7E, eightBitUU=0x0) + packet = packet / p + if SsVersionIndicator_presence is 1: + q = SsVersionIndicatorHdr(ieiSVI=0x7F, eightBitSVI=0x0) + packet = packet / q + if ClirSuppression_presence is 1: + r = ClirSuppressionHdr(ieiCS=0xA1, eightBitCS=0x0) + packet = packet / r + if ClirInvocation_presence is 1: + s = ClirInvocationHdr(ieiCI=0xA2, eightBitCI=0x0) + packet = packet / s + if CallControlCapabilities_presence is 1: + t = CallControlCapabilitiesHdr(ieiCCC=0x15, eightBitCCC=0x0) + packet = packet / t + if Facility_presence1 is 1: + u = FacilityHdr(ieiF=0x1D, eightBitF=0x0) + packet = packet / u + if Facility_presence2 is 1: + v = FacilityHdr(ieiF=0x1B, eightBitF=0x0) + packet = packet / v + return packet + + +def startCc(CallControlCapabilities_presence=0): + """START CC Section 9.3.23a""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x9) # 00001001 + packet = a / b + if CallControlCapabilities_presence is 1: + c = CallControlCapabilitiesHdr(ieiCCC=0x15, eightBitCCC=0x0) + packet = paclet / c + return packet + + +def startDtmf(): + """START DTMF Section 9.3.24""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x35) # 00110101 + c = KeypadFacilityHdr(ieiKF=0x2C, eightBitKF=0x0) + packet = a / b / c + return packet + + +# Network to MS +def startDtmfAcknowledge(): + """START DTMF ACKNOWLEDGE Section 9.3.25""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x32) # 00110010 + c = KeypadFacilityHdr(ieiKF=0x2C, eightBitKF=0x0) + packet = a / b / c + return packet + + +# Network to MS +def startDtmfReject(): + """ START DTMF REJECT Section 9.3.26""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x37) # 00110111 + c = Cause() + packet = a / b / c + return packet + + +def status(AuxiliaryStates_presence=0): + """STATUS Section 9.3.27""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x3d) # 00111101 + c = Cause() + d = CallState() + packet = a / b / c / d + if AuxiliaryStates_presence is 1: + e = AuxiliaryStatesHdr(ieiAS=0x24, eightBitAS=0x0) + packet = packet / e + return packet + + +def statusEnquiry(): + """STATUS ENQUIRY Section 9.3.28""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x34) # 00110100 + packet = a / b + return packet + + +def stopDtmf(): + """STOP DTMF Section 9.3.29""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x31) # 00110001 + packet = a / b + return packet + + +# Network to MS +def stopDtmfAcknowledge(): + """STOP DTMF ACKNOWLEDGE Section 9.3.30""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x32) # 00110010 + packet = a / b + return packet + + +def userInformation(MoreData_presence=0): + """USER INFORMATION Section 9.3.31""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x20) # 000100000 + c = UserUser() + packet = a / b / c + if MoreData_presence is 1: + d = MoreDataHdr(ieiMD=0xA0, eightBitMD=0x0) + packet = packet / d + return packet + +# +# 9.4 GPRS Mobility Management Messages +# + + +def attachRequest(PTmsiSignature_presence=0, GprsTimer_presence=0, + TmsiStatus_presence=0): + """ATTACH REQUEST Section 9.4.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1) # 0000001 + c = MsNetworkCapability() + d = AttachTypeAndCiphKeySeqNr() + f = DrxParameter() + g = MobileId() + h = RoutingAreaIdentification() + i = MsRadioAccessCapability() + packet = a / b / c / d / f / g / h / i + if PTmsiSignature_presence is 1: + j = PTmsiSignature(ieiPTS=0x19) + packet = packet / j + if GprsTimer_presence is 1: + k = GprsTimer(ieiGT=0x17) + packet = packet / k + if TmsiStatus_presence is 1: + l = TmsiStatus(ieiTS=0x9) + packet = packet / l + return packet + + +def attachAccept(PTmsiSignature_presence=0, GprsTimer_presence=0, + MobileId_presence=0, MobileId_presence1=0, + GmmCause_presence=0): + """ATTACH ACCEPT Section 9.4.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x2) # 00000010 + c = AttachResult() + d = ForceToStandby() + e = GprsTimer() + f = RadioPriorityAndSpareHalfOctets() + h = RoutingAreaIdentification() + packet = a / b / c / d / e / f / h + if PTmsiSignature_presence is 1: + i = PTmsiSignature(ieiPTS=0x19) + packet = packet / i + if GprsTimer_presence is 1: + j = GprsTimer(ieiGT=0x17) + packet = packet / j + if MobileId_presence is 1: + k = MobileIdHdr(ieiMI=0x18, eightBitMI=0x0) + packet = packet / k + if MobileId_presence1 is 1: + l = MobileIdHdr(ieiMI=0x23, eightBitMI=0x0) + packet = packet / l + if GmmCause_presence is 1: + m = GmmCause(ieiGC=0x25) + packet = packet / m + return packet + + +def attachComplete(): + """ATTACH COMPLETE Section 9.4.3""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x3) # 00000011 + packet = a / b + return packet + + +def attachReject(): + """ATTACH REJECT Section 9.4.4""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x1) # 00000001 + c = GmmCause() + packet = a / b / c + return packet + + +def detachRequest(GmmCause_presence=0): + """DETACH REQUEST Section 9.4.5""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x5) # 00000101 + c = DetachTypeAndForceToStandby() + packet = a / b / c + if GmmCause_presence is 1: + e = GmmCause(ieiGC=0x25) + packet = packet / e + return packet + + +def detachRequestMsOriginating(): + """DETACH REQUEST Section 9.4.5.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x5) # 00000101 + c = DetachTypeAndSpareHalfOctets() + packet = a / b / c + return packet + + +def detachAcceptMsTerminated(): + """DETACH ACCEPT Section 9.4.6.1""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x6) # 00000110 + packet = a / b + return packet + + +def detachAcceptMsOriginating(): + """DETACH ACCEPT Section 9.4.6.2""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x6) # 00000110 + c = ForceToStandbyAndSpareHalfOctets() + packet = a / b / c + return packet + + +def ptmsiReallocationCommand(PTmsiSignature_presence=0): + """P-TMSI REALLOCATION COMMAND Section 9.4.7""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x10) # 00010000 + c = MobileId() + d = RoutingAreaIdentification() + e = ForceToStandbyAndSpareHalfOctets() + packet = a / b / c / d / e + if PTmsiSignature_presence is 1: + g = PTmsiSignature(ieiPTS=0x19) + packet = packet / g + return packet + + +def ptmsiReallocationComplete(): + """P-TMSI REALLOCATION COMPLETE Section 9.4.8""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x11) # 00010001 + packet = a / b + return packet + + +def authenticationAndCipheringRequest( + AuthenticationParameterRAND_presence=0, + CiphKeySeqNr_presence=0): + """AUTHENTICATION AND CIPHERING REQUEST Section 9.4.9""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x12) # 00010010 + d = CipheringAlgorithmAndImeisvRequest() + e = ForceToStandbyAndAcReferenceNumber() + packet = a / b / d / e + if AuthenticationParameterRAND_presence is 1: + g = AuthenticationParameterRAND(ieiAPR=0x21) + packet = packet / g + if CiphKeySeqNr_presence is 1: + h = CiphKeySeqNrHdr(ieiCKSN=0x08, eightBitCKSN=0x0) + packet = packet / h + return packet + + +def authenticationAndCipheringResponse( + AuthenticationParameterSRES_presence=0, + MobileId_presence=0): + """AUTHENTICATION AND CIPHERING RESPONSE Section 9.4.10""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x13) # 00010011 + c = AcReferenceNumberAndSpareHalfOctets() + packet = a / b / c + if AuthenticationParameterSRES_presence is 1: + e = AuthenticationParameterSRES(ieiAPS=0x22) + packet = packet / e + if MobileId_presence is 1: + f = MobileIdHdr(ieiMI=0x23, eightBitMI=0x0) + packet = packet / f + return packet + + +def authenticationAndCipheringReject(): + """AUTHENTICATION AND CIPHERING REJECT Section 9.4.11""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x14) # 00010100 + packet = a / b + return packet + + +def identityRequest(): + """IDENTITY REQUEST Section 9.4.12""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x15) # 00010101 + c = IdentityType2AndforceToStandby() + packet = a / b / c + return packet + + +def identityResponse(): + """IDENTITY RESPONSE Section 9.4.13""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x16) # 00010110 + c = MobileId() + packet = a / b / c + return packet + + +def routingAreaUpdateRequest(PTmsiSignature_presence=0, + GprsTimer_presence=0, + DrxParameter_presence=0, + TmsiStatus_presence=0): + """ROUTING AREA UPDATE REQUEST Section 9.4.14""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x8) # 00001000 + c = UpdateTypeAndCiphKeySeqNr() + e = RoutingAreaIdentification() + f = MsNetworkCapability() + packet = a / b / c / e / f + if PTmsiSignature_presence is 1: + g = PTmsiSignature(ieiPTS=0x19) + packet = packet / g + if GprsTimer_presence is 1: + h = GprsTimer(ieiGT=0x17) + packet = packet / h + if DrxParameter_presence is 1: + i = DrxParameter(ieiDP=0x27) + packet = packet / i + if TmsiStatus_presence is 1: + j = TmsiStatus(ieiTS=0x9) + packet = packet / j + return packet + + +def routingAreaUpdateAccept(PTmsiSignature_presence=0, + MobileId_presence=0, MobileId_presence1=0, + ReceiveNpduNumbersList_presence=0, + GprsTimer_presence=0, GmmCause_presence=0): + """ROUTING AREA UPDATE ACCEPT Section 9.4.15""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x9) # 00001001 + c = ForceToStandbyAndUpdateResult() + e = GprsTimer() + f = RoutingAreaIdentification() + packet = a / b / c / e / f + if PTmsiSignature_presence is 1: + g = PTmsiSignature(ieiPTS=0x19) + packet = packet / g + if MobileId_presence is 1: + h = MobileIdHdr(ieiMI=0x18, eightBitMI=0x0) + packet = packet / h + if MobileId_presence1 is 1: + i = MobileIdHdr(ieiMI=0x23, eightBitMI=0x0) + packet = packet / i + if ReceiveNpduNumbersList_presence is 1: + j = ReceiveNpduNumbersList(ieiRNNL=0x26) + packet = packet / j + if GprsTimer_presence is 1: + k = GprsTimer(ieiGT=0x17) + packet = packet / k + if GmmCause_presence is 1: + l = GmmCause(ieiGC=0x25) + packet = packet / l + return packet + + +def routingAreaUpdateComplete(ReceiveNpduNumbersList_presence=0): + """ROUTING AREA UPDATE COMPLETE Section 9.4.16""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0xa) # 00001010 + packet = a / b + if ReceiveNpduNumbersList_presence is 1: + c = ReceiveNpduNumbersList(ieiRNNL=0x26) + packet = packet / c + return packet + + +def routingAreaUpdateReject(): + """ROUTING AREA UPDATE REJECT Section 9.4.17""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0xb) # 00001011 + c = GmmCause() + d = ForceToStandbyAndSpareHalfOctets() + packet = a / b / c / d + return packet + + +def gmmStatus(): + """GMM STATUS Section 9.4.18""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x20) # 00100000 + c = GmmCause() + packet = a / b / c + return packet + + +def gmmInformation(NetworkName_presence=0, NetworkName_presence1=0, + TimeZone_presence=0, TimeZoneAndTime_presence=0, + LsaIdentifier_presence=0): + """GMM INFORMATION Section 9.4.19""" + a = TpPd(pd=0x3) + b = MessageType(mesType=0x21) # 00100001 + packet = a / b + if NetworkName_presence is 1: + c = NetworkNameHdr(ieiNN=0x43, eightBitNN=0x0) + packet = packet / c + if NetworkName_presence1 is 1: + d = NetworkNameHdr(ieiNN=0x45, eightBitNN=0x0) + packet = packet / d + if TimeZone_presence is 1: + e = TimeZoneHdr(ieiTZ=0x46, eightBitTZ=0x0) + packet = packet / e + if TimeZoneAndTime_presence is 1: + f = TimeZoneAndTimeHdr(ieiTZAT=0x47, eightBitTZAT=0x0) + packet = packet / f + if LsaIdentifier_presence is 1: + g = LsaIdentifierHdr(ieiLI=0x48, eightBitLI=0x0) + packet = packet / g + return packet + +# +# 9.5 GPRS Session Management Messages +# + + +def activatePdpContextRequest(AccessPointName_presence=0, + ProtocolConfigurationOptions_presence=0): + """ACTIVATE PDP CONTEXT REQUEST Section 9.5.1""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x41) # 01000001 + c = NetworkServiceAccessPointIdentifier() + d = LlcServiceAccessPointIdentifier() + e = QualityOfService() + f = PacketDataProtocolAddress() + packet = a / b / c / d / e / f + if AccessPointName_presence is 1: + g = AccessPointName(ieiAPN=0x28) + packet = packet / g + if ProtocolConfigurationOptions_presence is 1: + h = ProtocolConfigurationOptions(ieiPCO=0x27) + packet = packet / h + return packet + + +def activatePdpContextAccept(PacketDataProtocolAddress_presence=0, + ProtocolConfigurationOptions_presence=0): + """ACTIVATE PDP CONTEXT ACCEPT Section 9.5.2""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x42) # 01000010 + c = LlcServiceAccessPointIdentifier() + d = QualityOfService() + e = RadioPriorityAndSpareHalfOctets() + packet = a / b / c / d / e + if PacketDataProtocolAddress_presence is 1: + f = PacketDataProtocolAddress(ieiPDPA=0x2B) + packet = packet / f + if ProtocolConfigurationOptions_presence is 1: + g = ProtocolConfigurationOptions(ieiPCO=0x27) + packet = packet / g + return packet + + +def activatePdpContextReject(ProtocolConfigurationOptions_presence=0): + """ACTIVATE PDP CONTEXT REJECT Section 9.5.3""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x43) # 01000011 + c = SmCause() + packet = a / b / c + if ProtocolConfigurationOptions_presence is 1: + d = ProtocolConfigurationOptions(ieiPCO=0x27) + packet = packet / d + return packet + + +def requestPdpContextActivation(AccessPointName_presence=0): + """REQUEST PDP CONTEXT ACTIVATION Section 9.5.4""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x44) # 01000100 + c = PacketDataProtocolAddress() + packet = a / b / c + if AccessPointName_presence is 1: + d = AccessPointName(ieiAPN=0x28) + packet = packet / d + return packet + + +def requestPdpContextActivationReject(): + """REQUEST PDP CONTEXT ACTIVATION REJECT Section 9.5.5""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x45) # 01000101 + c = SmCause() + packet = a / b / c + return packet + + +def modifyPdpContextRequest(): + """MODIFY PDP CONTEXT REQUEST Section 9.5.6""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x48) # 01001000 + c = RadioPriorityAndSpareHalfOctets() + d = LlcServiceAccessPointIdentifier() + e = QualityOfService() + packet = a / b / c / d / e + return packet + + +def modifyPdpContextAccept(): + """MODIFY PDP CONTEXT ACCEPT Section 9.5.7""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x45) # 01000101 + packet = a / b + return packet + + +def deactivatePdpContextRequest(): + """DEACTIVATE PDP CONTEXT REQUEST Section 9.5.8""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x46) # 01000110 + c = SmCause() + packet = a / b / c + return packet + + +def deactivatePdpContextAccept(): + """DEACTIVATE PDP CONTEXT ACCEPT Section 9.5.9""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x47) # 01000111 + packet = a / b + return packet + + +def activateAaPdpContextRequest(AccessPointName_presence=0, + ProtocolConfigurationOptions_presence=0, + GprsTimer_presence=0): + """ACTIVATE AA PDP CONTEXT REQUEST Section 9.5.10""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x50) # 01010000 + c = NetworkServiceAccessPointIdentifier() + d = LlcServiceAccessPointIdentifier() + e = QualityOfService() + f = PacketDataProtocolAddress() + packet = a / b / c / d / e / f + if AccessPointName_presence is 1: + g = AccessPointName(ieiAPN=0x28) + packet = packet / g + if ProtocolConfigurationOptions_presence is 1: + h = ProtocolConfigurationOptions(ieiPCO=0x27) + packet = packet / h + if GprsTimer_presence is 1: + i = GprsTimer(ieiGT=0x29) + packet = packet / i + return packet + + +def activateAaPdpContextAccept(ProtocolConfigurationOptions_presence=0, + GprsTimer_presence=0): + """ACTIVATE AA PDP CONTEXT ACCEPT Section 9.5.11""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x51) # 01010001 + c = LlcServiceAccessPointIdentifier() + d = QualityOfService() + e = MobileId() + f = PacketDataProtocolAddress() + g = RadioPriorityAndSpareHalfOctets() + packet = a / b / c / d / e / f / g + if ProtocolConfigurationOptions_presence is 1: + i = ProtocolConfigurationOptions(ieiPCO=0x27) + packet = packet / i + if GprsTimer_presence is 1: + j = GprsTimer(ieiGT=0x29) + packet = packet / j + return packet + + +def activateAaPdpContextReject(ProtocolConfigurationOptions_presence=0): + """ACTIVATE AA PDP CONTEXT REJECT Section 9.5.12""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x52) # 01010010 + c = SmCause() + packet = a / b / c + if ProtocolConfigurationOptions_presence is 1: + d = ProtocolConfigurationOptions(ieiPCO=0x27) + packet = packet / d + return packet + + +def deactivateAaPdpContextRequest(): + """DEACTIVATE AA PDP CONTEXT REQUEST Section 9.5.13""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x53) # 01010011 + c = AaDeactivationCauseAndSpareHalfOctets() + packet = a / b / c + return packet + + +def deactivateAaPdpContextAccept(): + """DEACTIVATE AA PDP CONTEXT ACCEPT Section 9.5.14""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x54) # 01010100 + packet = a / b + return packet + + +def smStatus(): + """SM STATUS Section 9.5.15""" + a = TpPd(pd=0x8) + b = MessageType(mesType=0x55) # 01010101 + c = SmCause() + packet = a / b / c + return packet + + +# ============================================# +# Information Elements contents (Section 10) # +# =========================================== # + +#### +# This section contains the elements we need to build the messages +#### + +# +# Common information elements: +# +class CellIdentityHdr(Packet): + """ Cell identity Section 10.5.1.1 """ + name = "Cell Identity" + fields_desc = [ + BitField("eightBitCI", None, 1), + XBitField("ieiCI", None, 7), + ByteField("ciValue1", 0x0), + ByteField("ciValue2", 0x0) + ] + + +class CiphKeySeqNrHdr(Packet): + """ Ciphering Key Sequence Number Section 10.5.1.2 """ + name = "Cipher Key Sequence Number" + fields_desc = [ + XBitField("ieiCKSN", None, 4), + BitField("spare", 0x0, 1), + BitField("keySeq", 0x0, 3) + ] + + +# Fix 1/2 len problem +class CiphKeySeqNrAndSpareHalfOctets(Packet): + name = "Cipher Key Sequence Number and Spare Half Octets" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("keySeq", 0x0, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +# Fix 1/2 len problem +class CiphKeySeqNrAndMacModeAndChannelCodingRequest(Packet): + name = "Cipher Key Sequence Number and Mac Mode And Channel Coding Request" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("keySeq", 0x0, 3), + BitField("macMode", 0x0, 2), + BitField("cs", 0x0, 2) + ] + + +class LocalAreaIdHdr(Packet): + """ Local Area Identification Section 10.5.1.3 """ + name = "Location Area Identification" + fields_desc = [ + BitField("eightBitLAI", None, 1), + XBitField("ieiLAI", None, 7), + BitField("mccDigit2", 0x0, 4), + BitField("mccDigit1", 0x0, 4), + BitField("mncDigit3", 0x0, 4), + BitField("mccDigit3", 0x0, 4), + BitField("mncDigit2", 0x0, 4), + BitField("mncDigit1", 0x0, 4), + ByteField("lac1", 0x0), + ByteField("lac2", 0x0) + ] +# +# The Mobile Identity is a type 4 information element with a minimum +# length of 3 octet and 11 octets length maximal. +# + + +# len 3 - 11 +class MobileIdHdr(Packet): + """ Mobile Identity Section 10.5.1.4 """ + name = "Mobile Identity" + fields_desc = [ + BitField("eightBitMI", 0x0, 1), + XBitField("ieiMI", 0x0, 7), + + XByteField("lengthMI", None), + + BitField("idDigit1", 0x0, 4), + BitField("oddEven", 0x0, 1), + BitField("typeOfId", 0x0, 3), + + BitField("idDigit2_1", None, 4), # optional + BitField("idDigit2", None, 4), + + BitField("idDigit3_1", None, 4), + BitField("idDigit3", None, 4), + + BitField("idDigit4_1", None, 4), + BitField("idDigit4", None, 4), + + BitField("idDigit5_1", None, 4), + BitField("idDigit5", None, 4), + + BitField("idDigit6_1", None, 4), + BitField("idDigit6", None, 4), + BitField("idDigit7_1", None, 4), + BitField("idDigit7", None, 4), + BitField("idDigit8_1", None, 4), + BitField("idDigit8", None, 4), + BitField("idDigit9_1", None, 4), + BitField("idDigit9", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i, None)) # this list holds the values of +# the variables, the INTERESSTING value! + res = adapt(3, 11, a, self.fields_desc) + if self.lengthMI is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + print(repr(p)) + return p + pay + + +class MobileStationClassmark1Hdr(Packet): + """ Mobile Station Classmark 1 Section 10.5.1.5 """ + name = "Mobile Station Classmark 1" + fields_desc = [ + BitField("eightBitiMSC1", None, 1), + XBitField("ieiMSC1", None, 7), + BitField("spare", 0x0, 1), + BitField("revisionLvl", 0x0, 2), + BitField("esInd", 0x0, 1), + BitField("a51", 0x0, 1), + BitField("rfPowerCap", 0x0, 3) + ] + + +class MobileStationClassmark2Hdr(Packet): + """ Mobile Station Classmark 2 Section 10.5.1.6 """ + name = "Mobile Station Classmark 2" + fields_desc = [ + BitField("eightBitMSC2", None, 1), + XBitField("ieiMSC2", None, 7), + XByteField("lengthMSC2", 0x3), + BitField("spare", 0x0, 1), + BitField("revisionLvl", 0x0, 2), + BitField("esInd", 0x0, 1), + BitField("a51", 0x0, 1), + BitField("rfPowerCap", 0x0, 3), + BitField("spare1", 0x0, 1), + BitField("psCap", 0x0, 1), + BitField("ssScreenInd", 0x0, 2), + BitField("smCaPabi", 0x0, 1), + BitField("vbs", 0x0, 1), + BitField("vgcs", 0x0, 1), + BitField("fc", 0x0, 1), + BitField("cm3", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("lcsvaCap", 0x0, 1), + BitField("spare3", 0x0, 1), + BitField("soLsa", 0x0, 1), + BitField("cmsp", 0x0, 1), + BitField("a53", 0x0, 1), + BitField("a52", 0x0, 1) + ] + + +# len max 14 +class MobileStationClassmark3(Packet): + """ Mobile Station Classmark 3 Section 10.5.1.7 """ + name = "Mobile Station Classmark 3" + fields_desc = [ + # FIXME + ByteField("ieiMSC3", 0x0), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0) + ] + + +class SpareHalfOctets(Packet): + """ Spare Half Octet Section 10.5.1.8 """ + name = "Spare Half Octet" + fields_desc = [ + BitField("filler", None, 4), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class DescriptiveGroupOrBroadcastCallReferenceHdr(Packet): + """ Descriptive group or broadcast call reference Section 10.5.1.9 """ + name = "Descriptive Group or Broadcast Call Reference" + fields_desc = [ + BitField("eightBitDGOBCR", None, 1), + XBitField("ieiDGOBCR", None, 7), + BitField("binCallRef", 0x0, 27), + BitField("sf", 0x0, 1), + BitField("fa", 0x0, 1), + BitField("callPrio", 0x0, 3), + BitField("cipherInfo", 0x0, 4), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("spare3", 0x0, 1), + BitField("spare4", 0x0, 1) + ] + + +class GroupCipherKeyNumber(Packet): + """ Group Cipher Key Number reference Section 10.5.1.10 """ + name = "Group Cipher Key Number" + fields_desc = [ + XBitField("ieiGCKN", None, 4), + BitField("groupCipher", 0x0, 4) + ] + + +class PdAndSapiHdr(Packet): + """ PD and SAPI $(CCBS)$ Section 10.5.1.10a """ + name = "PD and SAPI $(CCBS)$" + fields_desc = [ + BitField("eightBitPAS", None, 1), + XBitField("ieiPAS", None, 7), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("sapi", 0x0, 2), + BitField("pd", 0x0, 4) + ] + + +class PriorityLevelHdr(Packet): + """ Priority Level Section 10.5.1.11 """ + name = "Priority Level" + fields_desc = [ + XBitField("ieiPL", None, 4), + BitField("spare", 0x0, 1), + BitField("callPrio", 0x0, 3) + ] + +# +# Radio Resource management information elements +# + + +# len 6 to max for L3 message (251) +class BaRangeHdr(Packet): + """ BA Range Section 10.5.2.1a """ + name = "BA Range" + fields_desc = [ + BitField("eightBitBR", None, 1), + XBitField("ieiBR", None, 7), + + XByteField("lengthBR", None), +#error: byte format requires -128 <= number <= 127 + ByteField("nrOfRanges", 0x0), +# # rX = range X +# # L o = Lower H i = higher +# # H p = high Part Lp = low Part + ByteField("r1LoHp", 0x0), + + BitField("r1LoLp", 0x0, 3), + BitField("r1HiHp", 0x0, 5), + + BitField("r1HiLp", 0x0, 4), + BitField("r2LoHp", 0x0, 4), + # optional + BitField("r2LoLp", None, 5), + BitField("r2HiHp", None, 3), + + ByteField("r2HiLp", None), + ByteField("r3LoHp", None), + + BitField("r3LoLp", None, 5), + BitField("r3HiHp", None, 3), + + ByteField("r3HiLp", None), + ByteField("r4LoHp", None), + + BitField("r4LoLp", None, 5), + BitField("r4HiHp", None, 3), + ByteField("r4HiLp", None), + ByteField("r5LoHp", None), + + BitField("r5LoLp", None, 5), + BitField("r5HiHp", None, 3), + ByteField("r5HiLp", None), + ByteField("r6LoHp", None), + + BitField("r6LoLp", None, 5), + BitField("r6HiHp", None, 3), + ByteField("r6HiLp", None), + ByteField("r7LoHp", None), + + BitField("r7LoLp", None, 5), + BitField("r7HiHp", None, 3), + ByteField("r7HiLp", None), + ByteField("r8LoHp", None), + + BitField("r8LoLp", None, 5), + BitField("r8HiHp", None, 3), + ByteField("r8HiLp", None), + ByteField("r9LoHp", None), + + BitField("r9LoLp", None, 5), + BitField("r9HiHp", None, 3), + ByteField("r9HiLp", None), + ByteField("r10LoHp", None), + + BitField("r10LoLp", None, 5), + BitField("r10HiHp", None, 3), + ByteField("r10HiLp", None), + ByteField("r11LoHp", None), + + BitField("r11LoLp", None, 5), + BitField("r11HiHp", None, 3), + ByteField("r11HiLp", None), + ByteField("r12LoHp", None), + + BitField("r12LoLp", None, 5), + BitField("r12HiHp", None, 3), + ByteField("r12HiLp", None), + ByteField("r13LoHp", None), + + BitField("r13LoLp", None, 5), + BitField("r13HiHp", None, 3), + ByteField("r13HiLp", None), + ByteField("r14LoHp", None), + + BitField("r14LoLp", None, 5), + BitField("r14HiHp", None, 3), + ByteField("r14HiLp", None), + ByteField("r15LoHp", None), + + BitField("r15LoLp", None, 5), + BitField("r15HiHp", None, 3), + ByteField("r15HiLp", None), + ByteField("r16LoHp", None), + + BitField("r16LoLp", None, 5), + BitField("r16HiHp", None, 3), + ByteField("r16HiLp", None), + ByteField("r17LoHp", None), + + BitField("r17LoLp", None, 5), + BitField("r17HiHp", None, 3), + ByteField("r17HiLp", None), + ByteField("r18LoHp", None), + + BitField("r18LoLp", None, 5), + BitField("r18HiHp", None, 3), + ByteField("r18HiLp", None), + ByteField("r19LoHp", None), + + BitField("r19LoLp", None, 5), + BitField("r19HiHp", None, 3), + ByteField("r19HiLp", None), + ByteField("r20LoHp", None), + + BitField("r20LoLp", None, 5), + BitField("r20HiHp", None, 3), + ByteField("r20HiLp", None), + ByteField("r21LoHp", None), + + BitField("r21LoLp", None, 5), + BitField("r21HiHp", None, 3), + ByteField("r21HiLp", None), + ByteField("r22LoHp", None), + + BitField("r22LoLp", None, 5), + BitField("r22HiHp", None, 3), + ByteField("r22HiLp", None), + ByteField("r23LoHp", None), + + BitField("r23LoLp", None, 5), + BitField("r23HiHp", None, 3), + ByteField("r23HiLp", None), + ByteField("r24LoHp", None), + + BitField("r24LoLp", None, 5), + BitField("r24HiHp", None, 3), + ByteField("r24HiLp", None), + ByteField("r25LoHp", None), + + BitField("r25LoLp", None, 5), + BitField("r25HiHp", None, 3), + ByteField("r25HiLp", None), + ByteField("r26LoHp", None), + + BitField("r26LoLp", None, 5), + BitField("r26HiHp", None, 3), + ByteField("r26HiLp", None), + ByteField("r27LoHp", None), + + BitField("r27LoLp", None, 5), + BitField("r27HiHp", None, 3), + ByteField("r27HiLp", None), + ByteField("r28LoHp", None), + + BitField("r28LoLp", None, 5), + BitField("r28HiHp", None, 3), + ByteField("r28HiLp", None), + ByteField("r29LoHp", None), + + BitField("r29LoLp", None, 5), + BitField("r29HiHp", None, 3), + ByteField("r29HiLp", None), + ByteField("r30LoHp", None), + + BitField("r30LoLp", None, 5), + BitField("r30HiHp", None, 3), + ByteField("r30HiLp", None), + ByteField("r31LoHp", None), + + BitField("r31LoLp", None, 5), + BitField("r31HiHp", None, 3), + ByteField("r31HiLp", None), + ByteField("r32LoHp", None), + + BitField("r32LoLp", None, 5), + BitField("r32HiHp", None, 3), + ByteField("r32HiLp", None), + ByteField("r33LoHp", None), + + BitField("r33LoLp", None, 5), + BitField("r33HiHp", None, 3), + ByteField("r33HiLp", None), + ByteField("r34LoHp", None), + + BitField("r34LoLp", None, 5), + BitField("r34HiHp", None, 3), + ByteField("r34HiLp", None), + ByteField("r35LoHp", None), + + BitField("r35LoLp", None, 5), + BitField("r35HiHp", None, 3), + ByteField("r35HiLp", None), + ByteField("r36LoHp", None), + + BitField("r36LoLp", None, 5), + BitField("r36HiHp", None, 3), + ByteField("r36HiLp", None), + ByteField("r37LoHp", None), + + BitField("r37LoLp", None, 5), + BitField("r37HiHp", None, 3), + ByteField("r37HiLp", None), + ByteField("r38LoHp", None), + + BitField("r38LoLp", None, 5), + BitField("r38HiHp", None, 3), + ByteField("r38HiLp", None), + ByteField("r39LoHp", None), + + BitField("r39LoLp", None, 5), + BitField("r39HiHp", None, 3), + ByteField("r39HiLp", None), + ByteField("r40LoHp", None), + + BitField("r40LoLp", None, 5), + BitField("r40HiHp", None, 3), + ByteField("r40HiLp", None), + ByteField("r41LoHp", None), + + BitField("r41LoLp", None, 5), + BitField("r41HiHp", None, 3), + ByteField("r41HiLp", None), + ByteField("r42LoHp", None), + + BitField("r42LoLp", None, 5), + BitField("r42HiHp", None, 3), + ByteField("r42HiLp", None), + ByteField("r43LoHp", None), + + BitField("r43LoLp", None, 5), + BitField("r43HiHp", None, 3), + ByteField("r43HiLp", None), + ByteField("r44LoHp", None), + + BitField("r44LoLp", None, 5), + BitField("r44HiHp", None, 3), + ByteField("r44HiLp", None), + ByteField("r45LoHp", None), + + BitField("r45LoLp", None, 5), + BitField("r45HiHp", None, 3), + ByteField("r45HiLp", None), + ByteField("r46LoHp", None), + + BitField("r46LoLp", None, 5), + BitField("r46HiHp", None, 3), + ByteField("r46HiLp", None), + ByteField("r47LoHp", None), + + BitField("r47LoLp", None, 5), + BitField("r47HiHp", None, 3), + ByteField("r47HiLp", None), + ByteField("r48LoHp", None), + + BitField("r48LoLp", None, 5), + BitField("r48HiHp", None, 3), + ByteField("r48HiLp", None), + ByteField("r49LoHp", None), + + BitField("r49LoLp", None, 5), + BitField("r49HiHp", None, 3), + ByteField("r49HiLp", None), + ByteField("r50LoHp", None), + + BitField("r50LoLp", None, 5), + BitField("r50HiHp", None, 3), + ByteField("r50HiLp", None), + ByteField("r51LoHp", None), + + BitField("r51LoLp", None, 5), + BitField("r51HiHp", None, 3), + ByteField("r51HiLp", None), + ByteField("r52LoHp", None), + + BitField("r52LoLp", None, 5), + BitField("r52HiHp", None, 3), + ByteField("r52HiLp", None), + ByteField("r53LoHp", None), + + BitField("r53LoLp", None, 5), + BitField("r53HiHp", None, 3), + ByteField("r53HiLp", None), + ByteField("r54LoHp", None), + + BitField("r54LoLp", None, 5), + BitField("r54HiHp", None, 3), + ByteField("r54HiLp", None), + ByteField("r55LoHp", None), + + BitField("r55LoLp", None, 5), + BitField("r55HiHp", None, 3), + ByteField("r55HiLp", None), + ByteField("r56LoHp", None), + + BitField("r56LoLp", None, 5), + BitField("r56HiHp", None, 3), + ByteField("r56HiLp", None), + ByteField("r57LoHp", None), + + BitField("r57LoLp", None, 5), + BitField("r57HiHp", None, 3), + ByteField("r57HiLp", None), + ByteField("r58LoHp", None), + + BitField("r58LoLp", None, 5), + BitField("r58HiHp", None, 3), + ByteField("r58HiLp", None), + ByteField("r59LoHp", None), + + BitField("r59LoLp", None, 5), + BitField("r59HiHp", None, 3), + ByteField("r59HiLp", None), + ByteField("r60LoHp", None), + + BitField("r60LoLp", None, 5), + BitField("r60HiHp", None, 3), + ByteField("r60HiLp", None), + ByteField("r61LoHp", None), + + BitField("r61LoLp", None, 5), + BitField("r61HiHp", None, 3), + ByteField("r61HiLp", None), + ByteField("r62LoHp", None), + + BitField("r62LoLp", None, 5), + BitField("r62HiHp", None, 3), + ByteField("r62HiLp", None), + ByteField("r63LoHp", None), + + BitField("r63LoLp", None, 5), + BitField("r63HiHp", None, 3), + ByteField("r63HiLp", None), + ByteField("r64LoHp", None), + + BitField("r64LoLp", None, 5), + BitField("r64HiHp", None, 3), + ByteField("r64HiLp", None), + ByteField("r65LoHp", None), + + BitField("r65LoLp", None, 5), + BitField("r65HiHp", None, 3), + ByteField("r65HiLp", None), + ByteField("r66LoHp", None), + + BitField("r66LoLp", None, 5), + BitField("r66HiHp", None, 3), + ByteField("r66HiLp", None), + ByteField("r67LoHp", None), + + BitField("r67LoLp", None, 5), + BitField("r67HiHp", None, 3), + ByteField("r67HiLp", None), + ByteField("r68LoHp", None), + + BitField("r68LoLp", None, 5), + BitField("r68HiHp", None, 3), + ByteField("r68HiLp", None), + ByteField("r69LoHp", None), + + BitField("r69LoLp", None, 5), + BitField("r69HiHp", None, 3), + ByteField("r69HiLp", None), + ByteField("r70LoHp", None), + + BitField("r70LoLp", None, 5), + BitField("r70HiHp", None, 3), + ByteField("r70HiLp", None), + ByteField("r71LoHp", None), + + BitField("r71LoLp", None, 5), + BitField("r71HiHp", None, 3), + ByteField("r71HiLp", None), + ByteField("r72LoHp", None), + + BitField("r72LoLp", None, 5), + BitField("r72HiHp", None, 3), + ByteField("r72HiLp", None), + ByteField("r73LoHp", None), + + BitField("r73LoLp", None, 5), + BitField("r73HiHp", None, 3), + ByteField("r73HiLp", None), + ByteField("r74LoHp", None), + + BitField("r74LoLp", None, 5), + BitField("r74HiHp", None, 3), + ByteField("r74HiLp", None), + ByteField("r75LoHp", None), + + BitField("r75LoLp", None, 5), + BitField("r75HiHp", None, 3), + ByteField("r75HiLp", None), + ByteField("r76LoHp", None), + + BitField("r76LoLp", None, 5), + BitField("r76HiHp", None, 3), + ByteField("r76HiLp", None), + ByteField("r77LoHp", None), + + BitField("r77LoLp", None, 5), + BitField("r77HiHp", None, 3), + ByteField("r77HiLp", None), + ByteField("r78LoHp", None), + + BitField("r78LoLp", None, 5), + BitField("r78HiHp", None, 3), + ByteField("r78HiLp", None), + ByteField("r79LoHp", None), + + BitField("r79LoLp", None, 5), + BitField("r79HiHp", None, 3), + ByteField("r79HiLp", None), + ByteField("r80LoHp", None), + + BitField("r80LoLp", None, 5), + BitField("r80HiHp", None, 3), + ByteField("r80HiLp", None), + ByteField("r81LoHp", None), + + BitField("r81LoLp", None, 5), + BitField("r81HiHp", None, 3), + ByteField("r81HiLp", None), + ByteField("r82LoHp", None), + + BitField("r82LoLp", None, 5), + BitField("r82HiHp", None, 3), + ByteField("r82HiLp", None), + ByteField("r83LoHp", None), + + BitField("r83LoLp", None, 5), + BitField("r83HiHp", None, 3), + ByteField("r83HiLp", None), + ByteField("r84LoHp", None), + + BitField("r84LoLp", None, 5), + BitField("r84HiHp", None, 3), + ByteField("r84HiLp", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + print("i is %s" % (i,)) + aList.append(self.fields_desc[i].name) + print("aList %s" % (len(aList))) + print("self.fields_desc %s" % (len(self.fields_desc))) + for i in aList: + a.append(getattr(self, i)) + res = adapt(6, 251, a, self.fields_desc) + if self.lengthBR is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 3 to max for L3 message (251) +class BaListPrefHdr(Packet): + """ BA List Pref Section 10.5.2.1c """ + name = "BA List Pref" + fields_desc = [ + # FIXME dynamic + BitField("eightBitBLP", None, 1), + XBitField("ieiBLP", None, 7), + + XByteField("lengthBLP", None), + + BitField("fixBit", 0x0, 1), + BitField("rangeLower", 0x0, 10), + BitField("fixBit2", 0x0, 1), + BitField("rangeUpper", 0x0, 10), + BitField("baFreq", 0x0, 10), + BitField("sparePad", 0x0, 8) + ] + + +# len 17 || Have a look at the specs for the field format +# Bit map 0 format +# Range 1024 format +# Range 512 format +# Range 256 format +# Range 128 format +# Variable bit map format +class CellChannelDescriptionHdr(Packet): + """ Cell Channel Description Section 10.5.2.1b """ + name = "Cell Channel Description " + fields_desc = [ + BitField("eightBitCCD", None, 1), + XBitField("ieiCCD", None, 7), + BitField("bit128", 0x0, 1), + BitField("bit127", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + ByteField("bit120", 0x0), + ByteField("bit112", 0x0), + ByteField("bit104", 0x0), + ByteField("bit96", 0x0), + ByteField("bit88", 0x0), + ByteField("bit80", 0x0), + ByteField("bit72", 0x0), + ByteField("bit64", 0x0), + ByteField("bit56", 0x0), + ByteField("bit48", 0x0), + ByteField("bit40", 0x0), + ByteField("bit32", 0x0), + ByteField("bit24", 0x0), + ByteField("bit16", 0x0), + ByteField("bit8", 0x0) + ] + + +class CellDescriptionHdr(Packet): + """ Cell Description Section 10.5.2.2 """ + name = "Cell Description" + fields_desc = [ + BitField("eightBitCD", None, 1), + XBitField("ieiCD", None, 7), + BitField("bcchHigh", 0x0, 2), + BitField("ncc", 0x0, 3), + BitField("bcc", 0x0, 3), + ByteField("bcchLow", 0x0) + ] + + +class CellOptionsBCCHHdr(Packet): + """ Cell Options (BCCH) Section 10.5.2.3 """ + name = "Cell Options (BCCH)" + fields_desc = [ + BitField("eightBitCOB", None, 1), + XBitField("ieiCOB", None, 7), + BitField("spare", 0x0, 1), + BitField("pwrc", 0x0, 1), + BitField("dtx", 0x0, 2), + BitField("rLinkTout", 0x0, 4) + ] + + +class CellOptionsSACCHHdr(Packet): + """ Cell Options (SACCH) Section 10.5.2.3a """ + name = "Cell Options (SACCH)" + fields_desc = [ + BitField("eightBitCOS", None, 1), + XBitField("ieiCOS", None, 7), + BitField("dtx", 0x0, 1), + BitField("pwrc", 0x0, 1), + BitField("dtx", 0x0, 1), + BitField("rLinkTout", 0x0, 4) + ] + + +class CellSelectionParametersHdr(Packet): + """ Cell Selection Parameters Section 10.5.2.4 """ + name = "Cell Selection Parameters" + fields_desc = [ + BitField("eightBitCSP", None, 1), + XBitField("ieiCSP", None, 7), + BitField("cellReselect", 0x0, 3), + BitField("msTxPwrMax", 0x0, 5), + BitField("acs", None, 1), + BitField("neci", None, 1), + BitField("rxlenAccMin", None, 6) + ] + + +class MacModeAndChannelCodingRequestHdr(Packet): + """ MAC Mode and Channel Coding Requested Section 10.5.2.4a """ + name = "MAC Mode and Channel Coding Requested" + fields_desc = [ + XBitField("ieiMMACCR", None, 4), + BitField("macMode", 0x0, 2), + BitField("cs", 0x0, 2) + ] + + +class ChannelDescriptionHdr(Packet): + """ Channel Description Section 10.5.2.5 """ + name = "Channel Description" + fields_desc = [ + BitField("eightBitCD", None, 1), + XBitField("ieiCD", None, 7), + + BitField("channelTyp", 0x0, 5), + BitField("tn", 0x0, 3), + + BitField("tsc", 0x0, 3), + BitField("h", 0x1, 1), + # if h=1 maybe we find a better solution here... + BitField("maioHi", 0x0, 4), + + BitField("maioLo", 0x0, 2), + BitField("hsn", 0x0, 6) + #BitField("spare", 0x0, 2), + #BitField("arfcnHigh", 0x0, 2), + #ByteField("arfcnLow", 0x0) + ] + + +class ChannelDescription2Hdr(Packet): + """ Channel Description 2 Section 10.5.2.5a """ + name = "Channel Description 2" + fields_desc = [ + BitField("eightBitCD2", None, 1), + XBitField("ieiCD2", None, 7), + BitField("channelTyp", 0x0, 5), + BitField("tn", 0x0, 3), + BitField("tsc", 0x0, 3), + BitField("h", 0x0, 1), + # if h=1 + # BitField("maioHi", 0x0, 4), + # BitField("maioLo", 0x0, 2), + # BitField("hsn", 0x0, 6) + BitField("spare", 0x0, 2), + BitField("arfcnHigh", 0x0, 2), + ByteField("arfcnLow", 0x0) + ] + + +class ChannelModeHdr(Packet): + """ Channel Mode Section 10.5.2.6 """ + name = "Channel Mode" + fields_desc = [ + BitField("eightBitCM", None, 1), + XBitField("ieiCM", None, 7), + ByteField("mode", 0x0) + ] + + +class ChannelMode2Hdr(Packet): + """ Channel Mode 2 Section 10.5.2.7 """ + name = "Channel Mode 2" + fields_desc = [ + BitField("eightBitCM2", None, 1), + XBitField("ieiCM2", None, 7), + ByteField("mode", 0x0) + ] + + +class ChannelNeededHdr(Packet): + """ Channel Needed Section 10.5.2.8 """ + name = "Channel Needed" + fields_desc = [ + XBitField("ieiCN", None, 4), + BitField("channel2", 0x0, 2), + BitField("channel1", 0x0, 2), + ] + + +class ChannelRequestDescriptionHdr(Packet): + """Channel Request Description Section 10.5.2.8a """ + name = "Channel Request Description" + fields_desc = [ + BitField("eightBitCRD", None, 1), + XBitField("ieiCRD", None, 7), + BitField("mt", 0x0, 1), + ConditionalField(BitField("spare", 0x0, 39), + lambda pkt: pkt.mt == 0), + ConditionalField(BitField("spare", 0x0, 3), + lambda pkt: pkt.mt == 1), + ConditionalField(BitField("priority", 0x0, 2), + lambda pkt: pkt.mt == 1), + ConditionalField(BitField("rlcMode", 0x0, 1), + lambda pkt: pkt.mt == 1), + ConditionalField(BitField("llcFrame", 0x1, 1), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("reqBandMsb", 0x0), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("reqBandLsb", 0x0), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("rlcMsb", 0x0), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("rlcLsb", 0x0), + lambda pkt: pkt.mt == 1) + ] + + +class CipherModeSettingHdr(Packet): + """Cipher Mode Setting Section 10.5.2.9 """ + name = "Cipher Mode Setting" + fields_desc = [ + XBitField("ieiCMS", None, 4), + BitField("algoId", 0x0, 3), + BitField("sc", 0x0, 1), + ] + + +class CipherResponseHdr(Packet): + """Cipher Response Section 10.5.2.10 """ + name = "Cipher Response" + fields_desc = [ + XBitField("ieiCR", None, 4), + BitField("spare", 0x0, 3), + BitField("cr", 0x0, 1), + ] + + +# This packet fixes the problem with the 1/2 Byte length. Concatenation +# of cipherModeSetting and cipherResponse +class CipherModeSettingAndcipherResponse(Packet): + name = "Cipher Mode Setting And Cipher Response" + fields_desc = [ + BitField("algoId", 0x0, 3), + BitField("sc", 0x0, 1), + BitField("spare", 0x0, 3), + BitField("cr", 0x0, 1) + ] + + +class ControlChannelDescriptionHdr(Packet): + """Control Channel Description Section 10.5.2.11 """ + name = "Control Channel Description" + fields_desc = [ + BitField("eightBitCCD", None, 1), + XBitField("ieiCCD", None, 7), + + BitField("spare", 0x0, 1), + BitField("att", 0x0, 1), + BitField("bsAgBlksRes", 0x0, 3), + BitField("ccchConf", 0x0, 3), + + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("spare3", 0x0, 1), + BitField("spare4", 0x0, 1), + BitField("bsPaMfrms", 0x0, 3), + + ByteField("t3212", 0x0) + ] + + +class FrequencyChannelSequenceHdr(Packet): + """Frequency Channel Sequence Section 10.5.2.12""" + name = "Frequency Channel Sequence" + fields_desc = [ + BitField("eightBitFCS", None, 1), + XBitField("ieiFCS", None, 7), + BitField("spare", 0x0, 1), + BitField("lowestArfcn", 0x0, 7), + BitField("skipArfcn01", 0x0, 4), + BitField("skipArfcn02", 0x0, 4), + BitField("skipArfcn03", 0x0, 4), + BitField("skipArfcn04", 0x0, 4), + BitField("skipArfcn05", 0x0, 4), + BitField("skipArfcn06", 0x0, 4), + BitField("skipArfcn07", 0x0, 4), + BitField("skipArfcn08", 0x0, 4), + BitField("skipArfcn09", 0x0, 4), + BitField("skipArfcn10", 0x0, 4), + BitField("skipArfcn11", 0x0, 4), + BitField("skipArfcn12", 0x0, 4), + BitField("skipArfcn13", 0x0, 4), + BitField("skipArfcn14", 0x0, 4), + BitField("skipArfcn15", 0x0, 4), + BitField("skipArfcn16", 0x0, 4) + ] + + +class FrequencyListHdr(Packet): + """Frequency List Section 10.5.2.13""" + name = "Frequency List" + # Problem: + # There are several formats for the Frequency List information + # element, distinguished by the "format indicator" subfield. + # Some formats are frequency bit maps, the others use a special encoding + # scheme. + fields_desc = [ + BitField("eightBitFL", None, 1), + XBitField("ieiFL", None, 7), + XByteField("lengthFL", None), + + BitField("formatID", 0x0, 2), + BitField("spare", 0x0, 2), + BitField("arfcn124", 0x0, 1), + BitField("arfcn123", 0x0, 1), + BitField("arfcn122", 0x0, 1), + BitField("arfcn121", 0x0, 1), + + ByteField("arfcn120", 0x0), + ByteField("arfcn112", 0x0), + ByteField("arfcn104", 0x0), + ByteField("arfcn96", 0x0), + ByteField("arfcn88", 0x0), + ByteField("arfcn80", 0x0), + ByteField("arfcn72", 0x0), + ByteField("arfcn64", 0x0), + ByteField("arfcn56", 0x0), + ByteField("arfcn48", 0x0), + ByteField("arfcn40", 0x0), + ByteField("arfcn32", 0x0), + ByteField("arfcn24", 0x0), + ByteField("arfcn16", 0x0), + ByteField("arfcn8", 0x0) + ] + + +class FrequencyShortListHdr(Packet): + """Frequency Short List Section 10.5.2.14""" + name = "Frequency Short List" +# len is 10 +#This element is encoded exactly as the Frequency List information element, +#except that it has a fixed length instead of a +#variable length and does not contain a length indicator and that it +#shall not be encoded in bitmap 0 format. + fields_desc = [ + ByteField("ieiFSL", 0x0), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0) + ] + + +class FrequencyShortListHdr2(Packet): + """Frequency Short List2 Section 10.5.2.14a""" + name = "Frequency Short List 2" + fields_desc = [ + ByteField("byte1", 0x0), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0) + ] + + +# len 4 to 13 +class GroupChannelDescriptionHdr(Packet): + """Group Channel Description Section 10.5.2.14b""" + name = "Group Channel Description" + fields_desc = [ + BitField("eightBitGCD", None, 1), + XBitField("ieiGCD", None, 7), + + XByteField("lengthGCD", None), + + BitField("channelType", 0x0, 5), + BitField("tn", 0x0, 3), + + BitField("tsc", 0x0, 3), + BitField("h", 0x0, 1), + # if h == 0 the packet looks the following way: + ConditionalField(BitField("spare", 0x0, 2), + lambda pkt: pkt. h == 0x0), + ConditionalField(BitField("arfcnHi", 0x0, 2), + lambda pkt: pkt. h == 0x0), + ConditionalField(ByteField("arfcnLo", None), + lambda pkt: pkt. h == 0x0), + # if h == 1 the packet looks the following way: + ConditionalField(BitField("maioHi", 0x0, 4), + lambda pkt: pkt. h == 0x1), + ConditionalField(BitField("maioLo", None, 2), + lambda pkt: pkt. h == 0x1), + ConditionalField(BitField("hsn", None, 6), + lambda pkt: pkt. h == 0x1), + # finished with conditional fields + ByteField("maC6", None), + ByteField("maC7", None), + ByteField("maC8", None), + ByteField("maC9", None), + ByteField("maC10", None), + ByteField("maC11", None), + ByteField("maC12", None), + ByteField("maC13", None), + ByteField("maC14", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 13, a, self.fields_desc) + if self.lengthGCD is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class GprsResumptionHdr(Packet): + """GPRS Resumption Section 10.5.2.14c""" + name = "GPRS Resumption" + fields_desc = [ + XBitField("ieiGR", None, 4), + BitField("spare", 0x0, 3), + BitField("ack", 0x0, 1) + ] + + +class HandoverReferenceHdr(Packet): + """Handover Reference Section 10.5.2.15""" + name = "Handover Reference" + fields_desc = [ + BitField("eightBitHR", None, 1), + XBitField("ieiHR", None, 7), + ByteField("handoverRef", 0x0) + ] + + +# len 1-12 +class IaRestOctets(Packet): + """IA Rest Octets Section 10.5.2.16""" + name = "IA Rest Octets" + fields_desc = [ + ByteField("ieiIRO", 0x0), + # FIXME brainfuck packet + XByteField("lengthIRO", None), + ByteField("byte2", None), + ByteField("byte3", None), + ByteField("byte4", None), + ByteField("byte5", None), + ByteField("byte6", None), + ByteField("byte7", None), + ByteField("byte8", None), + ByteField("byte9", None), + ByteField("byte10", None), + ByteField("byte11", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 12, a, self.fields_desc) + if self.lengthIRO is None: + if res[1] < 0: # FIXME better fix + res[1] = 0 + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class IraRestOctetsHdr(Packet): + """IAR Rest Octets Section 10.5.2.17""" + name = "IAR Rest Octets" + fields_desc = [ + BitField("eightBitIRO", None, 1), + XBitField("ieiIRO", None, 7), + BitField("spare01", 0x0, 1), + BitField("spare02", 0x0, 1), + BitField("spare03", 0x1, 1), + BitField("spare04", 0x0, 1), + BitField("spare05", 0x1, 1), + BitField("spare06", 0x0, 1), + BitField("spare07", 0x1, 1), + BitField("spare08", 0x1, 1), + BitField("spare09", 0x0, 1), + BitField("spare10", 0x0, 1), + BitField("spare11", 0x1, 1), + BitField("spare12", 0x0, 1), + BitField("spare13", 0x1, 1), + BitField("spare14", 0x0, 1), + BitField("spare15", 0x1, 1), + BitField("spare16", 0x1, 1), + BitField("spare17", 0x0, 1), + BitField("spare18", 0x0, 1), + BitField("spare19", 0x1, 1), + BitField("spare20", 0x0, 1), + BitField("spare21", 0x1, 1), + BitField("spare22", 0x0, 1), + BitField("spare23", 0x1, 1), + BitField("spare24", 0x1, 1) + ] + + +# len is 1 to 5 what do we do with the variable size? no lenght +# field?! WTF +class IaxRestOctetsHdr(Packet): + """IAX Rest Octets Section 10.5.2.18""" + name = "IAX Rest Octets" + fields_desc = [ + BitField("eightBitIRO", None, 1), + XBitField("ieiIRO", None, 7), + BitField("spare01", 0x0, 1), + BitField("spare02", 0x0, 1), + BitField("spare03", 0x1, 1), + BitField("spare04", 0x0, 1), + BitField("spare05", 0x1, 1), + BitField("spare06", 0x0, 1), + BitField("spare07", 0x1, 1), + BitField("spare08", 0x1, 1), + ByteField("spareB1", None), + ByteField("spareB2", None), + ByteField("spareB3", None) + ] + + +class L2PseudoLengthHdr(Packet): + """L2 Pseudo Length Section 10.5.2.19""" + name = "L2 Pseudo Length" + fields_desc = [ + BitField("eightBitPL", None, 1), + XBitField("ieiPL", None, 7), + BitField("l2pLength", None, 6), + BitField("bit2", 0x0, 1), + BitField("bit1", 0x1, 1) + ] + + +class MeasurementResultsHdr(Packet): + """Measurement Results Section 10.5.2.20""" + name = "Measurement Results" + fields_desc = [ + BitField("eightBitMR", None, 1), + XBitField("ieiMR", None, 7), + BitField("baUsed", 0x0, 1), + BitField("dtxUsed", 0x0, 1), + BitField("rxLevFull", 0x0, 6), + BitField("spare", 0x0, 1), + BitField("measValid", 0x0, 1), + BitField("rxLevSub", 0x0, 6), + BitField("spare0", 0x0, 1), + BitField("rxqualFull", 0x0, 3), + BitField("rxqualSub", 0x0, 3), + BitField("noNcellHi", 0x0, 1), + BitField("noNcellLo", 0x0, 2), + BitField("rxlevC1", 0x0, 6), + BitField("bcchC1", 0x0, 5), + BitField("bsicC1Hi", 0x0, 3), + BitField("bsicC1Lo", 0x0, 3), + BitField("rxlevC2", 0x0, 5), + BitField("rxlevC2Lo", 0x0, 1), + BitField("bcchC2", 0x0, 5), + BitField("bsicC1Hi", 0x0, 2), + BitField("bscicC2Lo", 0x0, 4), + BitField("bscicC2Hi", 0x0, 4), + + BitField("rxlevC3Lo", 0x0, 2), + BitField("bcchC3", 0x0, 5), + BitField("rxlevC3Hi", 0x0, 1), + + BitField("bsicC3Lo", 0x0, 5), + BitField("bsicC3Hi", 0x0, 3), + + BitField("rxlevC4Lo", 0x0, 3), + BitField("bcchC4", 0x0, 5), + + BitField("bsicC4", 0x0, 6), + BitField("rxlevC5Hi", 0x0, 2), + + BitField("rxlevC5Lo", 0x0, 4), + BitField("bcchC5Hi", 0x0, 4), + + BitField("bcchC5Lo", 0x0, 1), + BitField("bsicC5", 0x0, 6), + BitField("rxlevC6", 0x0, 1), + + BitField("rxlevC6Lo", 0x0, 5), + BitField("bcchC6Hi", 0x0, 3), + + BitField("bcchC6Lo", 0x0, 3), + BitField("bsicC6", 0x0, 5) + ] + + +class GprsMeasurementResultsHdr(Packet): + """GPRS Measurement Results Section 10.5.2.20a""" + name = "GPRS Measurement Results" + fields_desc = [ + BitField("eightBitGMR", None, 1), + XBitField("ieiGMR", None, 7), + BitField("cValue", 0x0, 6), + BitField("rxqualHi", 0x0, 2), + BitField("rxqL", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("signVar", 0x0, 6) + ] + + +# len 3 to 10 +class MobileAllocationHdr(Packet): + """Mobile Allocation Section 10.5.2.21""" + name = "Mobile Allocation" + fields_desc = [ + BitField("eightBitMA", None, 1), + XBitField("ieiMA", None, 7), + XByteField("lengthMA", None), + ByteField("maC64", 0x12), + ByteField("maC56", None), # optional fields start here + ByteField("maC48", None), + ByteField("maC40", None), + ByteField("maC32", None), + ByteField("maC24", None), + ByteField("maC16", None), + ByteField("maC8", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 10, a, self.fields_desc) + if self.lengthMA is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class MobileTimeDifferenceHdr(Packet): + """Mobile Time Difference Section 10.5.2.21a""" + name = "Mobile Time Difference" + fields_desc = [ + BitField("eightBitMTD", None, 1), + XBitField("ieiMTD", None, 7), + XByteField("lengthMTD", 0x5), + ByteField("valueHi", 0x0), + ByteField("valueCnt", 0x0), + BitField("valueLow", 0x0, 5), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1) + ] + + +# min 4 octets max 8 +class MultiRateConfigurationHdr(Packet): + """ MultiRate configuration Section 10.5.2.21aa""" + name = "MultiRate Configuration" + fields_desc = [ + BitField("eightBitMRC", None, 1), + XBitField("ieiMRC", None, 7), + + XByteField("lengthMRC", None), + + BitField("mrVersion", 0x0, 3), + BitField("spare", 0x0, 1), + BitField("icmi", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("startMode", 0x0, 2), + + ByteField("amrCodec", 0x0), + + BitField("spare", None, 2), + BitField("threshold1", None, 6), + + BitField("hysteresis1", None, 4), + BitField("threshold2", None, 4), + + BitField("threshold2cnt", None, 2), + BitField("hysteresis2", None, 4), + BitField("threshold3", None, 2), + + BitField("threshold3cnt", None, 4), + BitField("hysteresis3", None, 4) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 8, a, self.fields_desc) + if self.lengthMRC is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 3 to 12 +class MultislotAllocationHdr(Packet): + """Multislot Allocation Section 10.5.2.21b""" + name = "Multislot Allocation" + fields_desc = [ + BitField("eightBitMSA", None, 1), + XBitField("ieiMSA", None, 7), + XByteField("lengthMSA", None), + BitField("ext0", 0x1, 1), + BitField("da", 0x0, 7), + ConditionalField(BitField("ext1", 0x1, 1), # optional + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("ua", 0x0, 7), + lambda pkt: pkt.ext0 == 0), + ByteField("chan1", None), + ByteField("chan2", None), + ByteField("chan3", None), + ByteField("chan4", None), + ByteField("chan5", None), + ByteField("chan6", None), + ByteField("chan7", None), + ByteField("chan8", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 12, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthMSA is None: + p = p[:1] + struct.pack(">B", len(p)-2) + p[2:] + return p + pay + + +class NcModeHdr(Packet): + """NC mode Section 10.5.2.21c""" + name = "NC Mode" + fields_desc = [ + XBitField("ieiNM", None, 4), + BitField("spare", 0x0, 2), + BitField("ncMode", 0x0, 2) + ] + + +# Fix for len problem +# concatenation NC Mode And Spare Half Octets +class NcModeAndSpareHalfOctets(Packet): + name = "NC Mode And Spare Half Octets" + fields_desc = [ + BitField("spare", 0x0, 2), + BitField("ncMode", 0x0, 2), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class NeighbourCellsDescriptionHdr(Packet): + """Neighbour Cells Description Section 10.5.2.22""" + name = "Neighbour Cells Description" + fields_desc = [ + BitField("eightBitNCD", None, 1), + XBitField("ieiNCD", None, 7), + BitField("bit128", 0x0, 1), + BitField("bit127", 0x0, 1), + BitField("extInd", 0x0, 1), + BitField("baInd", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + BitField("120bits", 0x0, 120) + ] + + +class NeighbourCellsDescription2Hdr(Packet): + """Neighbour Cells Description 2 Section 10.5.2.22a""" + name = "Neighbour Cells Description 2" + fields_desc = [ + BitField("eightBitNCD2", None, 1), + XBitField("ieiNCD2", None, 7), + BitField("bit128", 0x0, 1), + BitField("multiband", 0x0, 2), + BitField("baInd", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + BitField("120bits", 0x0, 120) + ] + + +class NtNRestOctets(Packet): + """NT/N Rest Octets Section 10.5.2.22c""" + name = "NT/N Rest Octets" + fields_desc = [ + BitField("nln", 0x0, 2), + BitField("ncnInfo", 0x0, 4), + BitField("spare", 0x0, 2) + ] + + +# +# The following packet has no length info! +# +# len 1-18 +class P1RestOctets(Packet): + """P1 Rest Octets Section 10.5.2.23""" + name = "P1 Rest Octets" + fields_desc = [ + BitField("nln", 0x0, 2), + BitField("nlnStatus", 0x0, 1), + BitField("prio1", 0x0, 3), + BitField("prio2", 0x0, 3), + # optional + BitField("pageIndication1", 0x0, 1), + BitField("pageIndication2", 0x0, 1), + BitField("spare", 0x0, 5), + ByteField("spareB1", None), + ByteField("spareB2", None), + ByteField("spareB3", None), + ByteField("spareB4", None), + ByteField("spareB5", None), + ByteField("spareB6", None), + ByteField("spareB7", None), + ByteField("spareB8", None), + ByteField("spareB9", None), + ByteField("spareB10", None), + ByteField("spareB11", None), + ByteField("spareB12", None), + ByteField("spareB13", None), + ByteField("spareB14", None), + ByteField("spareB15", None), + ByteField("spareB16", None), + ] + + +# len 2-12 +class P2RestOctets(Packet): + """P2 Rest Octets Section 10.5.2.24""" + name = "P2 Rest Octets" + fields_desc = [ + BitField("cn3", 0x0, 2), + BitField("nln", 0x0, 2), + BitField("nlnStatus", 0x0, 1), + BitField("prio1", 0x0, 3), + + BitField("prio2", 0x0, 3), + BitField("prio3", 0x0, 3), + BitField("pageIndication3", 0x0, 1), + BitField("spare", 0x0, 1), + + # optinal (No length field!) + ByteField("spareB1", None), + ByteField("spareB2", None), + ByteField("spareB3", None), + ByteField("spareB4", None), + + ByteField("spareB5", None), + ByteField("spareB6", None), + ByteField("spareB7", None), + ByteField("spareB8", None), + + ByteField("spareB9", None), + ByteField("spareB10", None) + ] + + +# len 4 +class P3RestOctets(Packet): + """P3 Rest Octets Section 10.5.2.25""" + name = "P3 Rest Octets" + fields_desc = [ + BitField("cn3", 0x0, 2), + BitField("cn4", 0x0, 2), + BitField("nln", 0x0, 2), + BitField("nlnStatus", 0x0, 1), + BitField("prio1", 0x0, 3), + BitField("prio2", 0x0, 3), + BitField("prio3", 0x0, 3), + BitField("prio4", 0x0, 3), + BitField("spare", 0x0, 5) + ] + + +# len 4 +# strange packet, lots of valid formats + +# ideas for the dynamic packets: +# 1] for user interaction: Create an interactive "builder" based on a +# Q/A process (not very scapy like) +# 2] for usage in scripts, create an alternative packet for every +# possible packet layout +# + + +class PacketChannelDescription(Packet): + """Packet Channel Description Section 10.5.2.25a""" + name = "Packet Channel Description" + fields_desc = [ + ByteField("ieiPCD", None), + BitField("chanType", 0x0, 5), # This packet has multiple + # possible layouts. I moddeled the first one + BitField("tn", 0x0, 3), # maybe build an + #"interactive" builder. Like + # a Q/A then propose a + # packet? + BitField("tsc", 0x0, 3), + BitField("chooser1", 0x0, 1), + BitField("chooser2", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("arfcn", 0x0, 10), + ] + + +class DedicatedModeOrTBFHdr(Packet): + """Dedicated mode or TBF Section 10.5.2.25b""" + name = "Dedicated Mode or TBF" + fields_desc = [ + XBitField("ieiDMOT", None, 4), + BitField("spare", 0x0, 1), + BitField("tma", 0x0, 1), + BitField("downlink", 0x0, 1), + BitField("td", 0x0, 1) + ] + + +# FIXME add implementation +class RrPacketUplinkAssignment(Packet): + """RR Packet Uplink Assignment Section 10.5.2.25c""" + name = "RR Packet Uplink Assignment" + fields_desc = [ + # Fill me + ] + + +class PageModeHdr(Packet): + """Page Mode Section 10.5.2.26""" + name = "Page Mode" + fields_desc = [ + XBitField("ieiPM", None, 4), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("pm", 0x0, 2) + ] + + +# Fix for 1/2 len problem +# concatenation: pageMode and dedicatedModeOrTBF +class PageModeAndDedicatedModeOrTBF(Packet): + name = "Page Mode and Dedicated Mode Or TBF" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("pm", 0x0, 2), + BitField("spare", 0x0, 1), + BitField("tma", 0x0, 1), + BitField("downlink", 0x0, 1), + BitField("td", 0x0, 1) + ] + + +# Fix for 1/2 len problem +# concatenation: pageMode and spareHalfOctets +class PageModeAndSpareHalfOctets(Packet): + name = "Page Mode and Spare Half Octets" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("pm", 0x0, 2), + BitField("spareHalfOctets", 0x0, 4) + ] + + +# Fix for 1/2 len problem +# concatenation: pageMode and Channel Needed +class PageModeAndChannelNeeded(Packet): + name = "Page Mode and Channel Needed" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("pm", 0x0, 2), + BitField("channel2", 0x0, 2), + BitField("channel1", 0x0, 2) + ] + + +class NccPermittedHdr(Packet): + """NCC Permitted Section 10.5.2.27""" + name = "NCC Permited" + fields_desc = [ + BitField("eightBitNP", None, 1), + XBitField("ieiNP", None, 7), + ByteField("nccPerm", 0x0) + ] + + +class PowerCommandHdr(Packet): + """Power Command Section 10.5.2.28""" + name = "Power Command" + fields_desc = [ + BitField("eightBitPC", None, 1), + XBitField("ieiPC", None, 7), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("powerLvl", 0x0, 5) + ] + + +class PowerCommandAndAccessTypeHdr(Packet): + """Power Command and access type Section 10.5.2.28a""" + name = "Power Command and Access Type" + fields_desc = [ + BitField("eightBitPCAAT", None, 1), + XBitField("ieiPCAAT", None, 7), + BitField("atc", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("powerLvl", 0x0, 5) + ] + + +class RachControlParametersHdr(Packet): + """RACH Control Parameters Section 10.5.2.29""" + name = "RACH Control Parameters" + fields_desc = [ + BitField("eightBitRCP", None, 1), + XBitField("ieiRCP", None, 7), + BitField("maxRetrans", 0x0, 2), + BitField("txInteger", 0x0, 4), + BitField("cellBarrAccess", 0x0, 1), + BitField("re", 0x0, 1), + BitField("ACC15", 0x0, 1), + BitField("ACC14", 0x0, 1), + BitField("ACC13", 0x0, 1), + BitField("ACC12", 0x0, 1), + BitField("ACC11", 0x0, 1), + BitField("ACC10", 0x0, 1), + BitField("ACC09", 0x0, 1), + BitField("ACC08", 0x0, 1), + BitField("ACC07", 0x0, 1), + BitField("ACC06", 0x0, 1), + BitField("ACC05", 0x0, 1), + BitField("ACC04", 0x0, 1), + BitField("ACC03", 0x0, 1), + BitField("ACC02", 0x0, 1), + BitField("ACC01", 0x0, 1), + BitField("ACC00", 0x0, 1), + ] + + +class RequestReferenceHdr(Packet): + """Request Reference Section 10.5.2.30""" + name = "Request Reference" + fields_desc = [ + BitField("eightBitRR", None, 1), + XBitField("ieiRR", None, 7), + ByteField("ra", 0x0), + BitField("t1", 0x0, 5), + BitField("t3Hi", 0x0, 3), + BitField("t3Lo", 0x0, 3), + BitField("t2", 0x0, 5) + ] + + +class RrCauseHdr(Packet): + """RR Cause Section 10.5.2.31""" + name = "RR Cause" + fields_desc = [ + BitField("eightBitRC", None, 1), + XBitField("ieiRC", None, 7), + ByteField("rrCause", 0x0) + ] + + +class Si1RestOctets(Packet): + """SI 1 Rest Octets Section 10.5.2.32""" + name = "SI 1 Rest Octets" + fields_desc = [ + ByteField("nchPos", 0x0) + ] + + +class Si2bisRestOctets(Packet): + """SI 2bis Rest Octets Section 10.5.2.33""" + name = "SI 2bis Rest Octets" + fields_desc = [ + ByteField("spare", 0x0) + ] + + +class Si2terRestOctets(Packet): + """SI 2ter Rest Octets Section 10.5.2.33a""" + name = "SI 2ter Rest Octets" + fields_desc = [ + ByteField("spare1", 0x0), + ByteField("spare2", 0x0), + ByteField("spare3", 0x0), + ByteField("spare4", 0x0) + ] + + +# len 5 +class Si3RestOctets(Packet): + """SI 3 Rest Octets Section 10.5.2.34""" + name = "SI 3 Rest Octets" + fields_desc = [ + ByteField("byte1", 0x0), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0) + ] + + +# len 1 to 11 +class Si4RestOctets(Packet): + """SI 4 Rest Octets Section 10.5.2.35""" + name = "SI 4 Rest Octets" + fields_desc = [ + XByteField("lengthSI4", None), + ByteField("byte2", None), + ByteField("byte3", None), + ByteField("byte4", None), + ByteField("byte5", None), + ByteField("byte6", None), + ByteField("byte7", None), + ByteField("byte8", None), + ByteField("byte9", None), + ByteField("byte10", None), + ByteField("byte11", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 11, a, self.fields_desc, 1) + if self.lengthSI4 is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + if len(p) is 1: # length of this packet can be 0, but packet is + p = '' # but the IE is manadatory 0_o + return p + pay + + +class Si6RestOctets(Packet): + """SI 6 Rest Octets Section 10.5.2.35a""" + name = "SI 4 Rest Octets" + fields_desc = [ + # FIXME + ] + + +# len 21 +class Si7RestOctets(Packet): + """SI 7 Rest Octets Section 10.5.2.36""" + name = "SI 7 Rest Octets" + fields_desc = [ + # FIXME + XByteField("lengthSI7", 0x15), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0), + ByteField("byte15", 0x0), + ByteField("byte16", 0x0), + ByteField("byte17", 0x0), + ByteField("byte18", 0x0), + ByteField("byte19", 0x0), + ByteField("byte20", 0x0), + ByteField("byte21", 0x0) + ] + + +# len 21 +class Si8RestOctets(Packet): + """SI 8 Rest Octets Section 10.5.2.37""" + name = "SI 8 Rest Octets" + fields_desc = [ + # FIXME + XByteField("lengthSI8", 0x15), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0), + ByteField("byte15", 0x0), + ByteField("byte16", 0x0), + ByteField("byte17", 0x0), + ByteField("byte18", 0x0), + ByteField("byte19", 0x0), + ByteField("byte20", 0x0), + ByteField("byte21", 0x0) + ] + + +#len 17 +class Si9RestOctets(Packet): + """SI 9 Rest Octets Section 10.5.2.37a""" + name = "SI 9 Rest Octets" + fields_desc = [ + # FIXME + XByteField("lengthSI9", 0x11), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0), + ByteField("byte15", 0x0), + ByteField("byte16", 0x0), + ByteField("byte17", 0x0) + ] + + +# len 21 +class Si13RestOctets(Packet): + """SI 13 Rest Octets Section 10.5.2.37b""" + name = "SI 13 Rest Octets" + fields_desc = [ + # FIXME + XByteField("lengthSI3", 0x15), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0), + ByteField("byte15", 0x0), + ByteField("byte16", 0x0), + ByteField("byte17", 0x0), + ByteField("byte18", 0x0), + ByteField("byte19", 0x0), + ByteField("byte20", 0x0), + ByteField("byte21", 0x0) + ] + + +# 10.5.2.37c [spare] +# 10.5.2.37d [spare] + + +# len 21 +class Si16RestOctets(Packet): + """SI 16 Rest Octets Section 10.5.2.37e""" + name = "SI 16 Rest Octets" + fields_desc = [ + # FIXME + XByteField("lengthSI16", 0x15), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0), + ByteField("byte15", 0x0), + ByteField("byte16", 0x0), + ByteField("byte17", 0x0), + ByteField("byte18", 0x0), + ByteField("byte19", 0x0), + ByteField("byte20", 0x0), + ByteField("byte21", 0x0) + ] + + +# len 21 +class Si17RestOctets(Packet): + """SI 17 Rest Octets Section 10.5.2.37f""" + name = "SI 17 Rest Octets" + fields_desc = [ + # FIXME + XByteField("lengthSI17", 0x15), + ByteField("byte2", 0x0), + ByteField("byte3", 0x0), + ByteField("byte4", 0x0), + ByteField("byte5", 0x0), + ByteField("byte6", 0x0), + ByteField("byte7", 0x0), + ByteField("byte8", 0x0), + ByteField("byte9", 0x0), + ByteField("byte10", 0x0), + ByteField("byte11", 0x0), + ByteField("byte12", 0x0), + ByteField("byte13", 0x0), + ByteField("byte14", 0x0), + ByteField("byte15", 0x0), + ByteField("byte16", 0x0), + ByteField("byte17", 0x0), + ByteField("byte18", 0x0), + ByteField("byte19", 0x0), + ByteField("byte20", 0x0), + ByteField("byte21", 0x0) + ] + + +class StartingTimeHdr(Packet): + """Starting Time Section 10.5.2.38""" + name = "Starting Time" + fields_desc = [ + BitField("eightBitST", None, 1), + XBitField("ieiST", None, 7), + ByteField("ra", 0x0), + BitField("t1", 0x0, 5), + BitField("t3Hi", 0x0, 3), + BitField("t3Lo", 0x0, 3), + BitField("t2", 0x0, 5) + ] + + +class SynchronizationIndicationHdr(Packet): + """Synchronization Indication Section 10.5.2.39""" + name = "Synchronization Indication" + fields_desc = [ + XBitField("ieiSI", None, 4), + BitField("nci", 0x0, 1), + BitField("rot", 0x0, 1), + BitField("si", 0x0, 2) + ] + + +class TimingAdvanceHdr(Packet): + """Timing Advance Section 10.5.2.40""" + name = "Timing Advance" + fields_desc = [ + BitField("eightBitTA", None, 1), + XBitField("ieiTA", None, 7), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("timingVal", 0x0, 6) + ] + + +class TimeDifferenceHdr(Packet): + """ Time Difference Section 10.5.2.41""" + name = "Time Difference" + fields_desc = [ + BitField("eightBitTD", None, 1), + XBitField("ieiTD", None, 7), + XByteField("lengthTD", 0x3), + ByteField("timeValue", 0x0) + ] + + +class TlliHdr(Packet): + """ TLLI Section Section 10.5.2.41a""" + name = "TLLI" + fields_desc = [ + BitField("eightBitT", None, 1), + XBitField("ieiT", None, 7), + ByteField("value", 0x0), + ByteField("value1", 0x0), + ByteField("value2", 0x0), + ByteField("value3", 0x0) + ] + + +class TmsiPTmsiHdr(Packet): + """ TMSI/P-TMSI Section 10.5.2.42""" + name = "TMSI/P-TMSI" + fields_desc = [ + BitField("eightBitTPT", None, 1), + XBitField("ieiTPT", None, 7), + ByteField("value", 0x0), + ByteField("value1", 0x0), + ByteField("value2", 0x0), + ByteField("value3", 0x0) + ] + + +class VgcsTargetModeIdenticationHdr(Packet): + """ VGCS target Mode Indication 10.5.2.42a""" + name = "VGCS Target Mode Indication" + fields_desc = [ + BitField("eightBitVTMI", None, 1), + XBitField("ieiVTMI", None, 7), + XByteField("lengthVTMI", 0x2), + BitField("targerMode", 0x0, 2), + BitField("cipherKeyNb", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1) + ] + + +class WaitIndicationHdr(Packet): + """ Wait Indication Section 10.5.2.43""" + name = "Wait Indication" + fields_desc = [ # asciiart of specs strange + BitField("eightBitWI", None, 1), + XBitField("ieiWI", None, 7), + ByteField("timeoutVal", 0x0) + ] + + +# len 17 +class ExtendedMeasurementResultsHdr(Packet): + """EXTENDED MEASUREMENT RESULTS Section 10.5.2.45""" + name = "Extended Measurement Results" + fields_desc = [ + BitField("eightBitEMR", None, 1), + XBitField("ieiEMR", None, 7), + + BitField("scUsed", None, 1), + BitField("dtxUsed", None, 1), + BitField("rxLevC0", None, 6), + + BitField("rxLevC1", None, 6), + BitField("rxLevC2Hi", None, 2), + + BitField("rxLevC2Lo", None, 4), + BitField("rxLevC3Hi", None, 4), + + BitField("rxLevC3Lo", None, 3), + BitField("rxLevC4", None, 5), + + BitField("rxLevC5", None, 6), + BitField("rxLevC6Hi", None, 2), + + BitField("rxLevC6Lo", None, 4), + BitField("rxLevC7Hi", None, 4), + + BitField("rxLevC7Lo", None, 2), + BitField("rxLevC8", None, 6), + + BitField("rxLevC9", None, 6), + BitField("rxLevC10Hi", None, 2), + + BitField("rxLevC10Lo", None, 4), + BitField("rxLevC11Hi", None, 4), + + BitField("rxLevC13Lo", None, 2), + BitField("rxLevC12", None, 6), + + BitField("rxLevC13", None, 6), + BitField("rxLevC14Hi", None, 2), + + BitField("rxLevC14Lo", None, 4), + BitField("rxLevC15Hi", None, 4), + + BitField("rxLevC15Lo", None, 2), + BitField("rxLevC16", None, 6), + + + BitField("rxLevC17", None, 6), + BitField("rxLevC18Hi", None, 2), + + BitField("rxLevC18Lo", None, 4), + BitField("rxLevC19Hi", None, 4), + + BitField("rxLevC19Lo", None, 2), + BitField("rxLevC20", None, 6) + ] + + +# len 17 +class ExtendedMeasurementFrequencyListHdr(Packet): + """Extended Measurement Frequency List Section 10.5.2.46""" + name = "Extended Measurement Frequency List" + fields_desc = [ + BitField("eightBitEMFL", None, 1), + XBitField("ieiEMFL", None, 7), + + BitField("bit128", 0x0, 1), + BitField("bit127", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("seqCode", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + + BitField("bitsRest", 0x0, 128) + ] + + +class SuspensionCauseHdr(Packet): + """Suspension Cause Section 10.5.2.47""" + name = "Suspension Cause" + fields_desc = [ + BitField("eightBitSC", None, 1), + XBitField("ieiSC", None, 7), + ByteField("suspVal", 0x0) + ] + + +class ApduIDHdr(Packet): + """APDU Flags Section 10.5.2.48""" + name = "Apdu Id" + fields_desc = [ + XBitField("ieiAI", None, 4), + BitField("id", None, 4) + ] + + +class ApduFlagsHdr(Packet): + """APDU Flags Section 10.5.2.49""" + name = "Apdu Flags" + fields_desc = [ + XBitField("iei", None, 4), + BitField("spare", 0x0, 1), + BitField("cr", 0x0, 1), + BitField("firstSeg", 0x0, 1), + BitField("lastSeg", 0x0, 1) + ] + + +# Fix 1/2 len problem +class ApduIDAndApduFlags(Packet): + name = "Apu Id and Apdu Flags" + fields_desc = [ + BitField("id", None, 4), + BitField("spare", 0x0, 1), + BitField("cr", 0x0, 1), + BitField("firstSeg", 0x0, 1), + BitField("lastSeg", 0x0, 1) + ] + + +# len 2 to max L3 (251) (done) +class ApduDataHdr(Packet): + """APDU Data Section 10.5.2.50""" + name = "Apdu Data" + fields_desc = [ + BitField("eightBitAD", None, 1), + XBitField("ieiAD", None, 7), + XByteField("lengthAD", None), + #optional + ByteField("apuInfo1", None), + ByteField("apuInfo2", None), + ByteField("apuInfo3", None), + ByteField("apuInfo4", None), + ByteField("apuInfo5", None), + ByteField("apuInfo6", None), + ByteField("apuInfo7", None), + ByteField("apuInfo8", None), + ByteField("apuInfo9", None), + ByteField("apuInfo10", None), + ByteField("apuInfo11", None), + ByteField("apuInfo12", None), + ByteField("apuInfo13", None), + ByteField("apuInfo14", None), + ByteField("apuInfo15", None), + ByteField("apuInfo16", None), + ByteField("apuInfo17", None), + ByteField("apuInfo18", None), + ByteField("apuInfo19", None), + ByteField("apuInfo20", None), + ByteField("apuInfo21", None), + ByteField("apuInfo22", None), + ByteField("apuInfo23", None), + ByteField("apuInfo24", None), + ByteField("apuInfo25", None), + ByteField("apuInfo26", None), + ByteField("apuInfo27", None), + ByteField("apuInfo28", None), + ByteField("apuInfo29", None), + ByteField("apuInfo30", None), + ByteField("apuInfo31", None), + ByteField("apuInfo32", None), + ByteField("apuInfo33", None), + ByteField("apuInfo34", None), + ByteField("apuInfo35", None), + ByteField("apuInfo36", None), + ByteField("apuInfo37", None), + ByteField("apuInfo38", None), + ByteField("apuInfo39", None), + ByteField("apuInfo40", None), + ByteField("apuInfo41", None), + ByteField("apuInfo42", None), + ByteField("apuInfo43", None), + ByteField("apuInfo44", None), + ByteField("apuInfo45", None), + ByteField("apuInfo46", None), + ByteField("apuInfo47", None), + ByteField("apuInfo48", None), + ByteField("apuInfo49", None), + ByteField("apuInfo50", None), + ByteField("apuInfo51", None), + ByteField("apuInfo52", None), + ByteField("apuInfo53", None), + ByteField("apuInfo54", None), + ByteField("apuInfo55", None), + ByteField("apuInfo56", None), + ByteField("apuInfo57", None), + ByteField("apuInfo58", None), + ByteField("apuInfo59", None), + ByteField("apuInfo60", None), + ByteField("apuInfo61", None), + ByteField("apuInfo62", None), + ByteField("apuInfo63", None), + ByteField("apuInfo64", None), + ByteField("apuInfo65", None), + ByteField("apuInfo66", None), + ByteField("apuInfo67", None), + ByteField("apuInfo68", None), + ByteField("apuInfo69", None), + ByteField("apuInfo70", None), + ByteField("apuInfo71", None), + ByteField("apuInfo72", None), + ByteField("apuInfo73", None), + ByteField("apuInfo74", None), + ByteField("apuInfo75", None), + ByteField("apuInfo76", None), + ByteField("apuInfo77", None), + ByteField("apuInfo78", None), + ByteField("apuInfo79", None), + ByteField("apuInfo80", None), + ByteField("apuInfo81", None), + ByteField("apuInfo82", None), + ByteField("apuInfo83", None), + ByteField("apuInfo84", None), + ByteField("apuInfo85", None), + ByteField("apuInfo86", None), + ByteField("apuInfo87", None), + ByteField("apuInfo88", None), + ByteField("apuInfo89", None), + ByteField("apuInfo90", None), + ByteField("apuInfo91", None), + ByteField("apuInfo92", None), + ByteField("apuInfo93", None), + ByteField("apuInfo94", None), + ByteField("apuInfo95", None), + ByteField("apuInfo96", None), + ByteField("apuInfo97", None), + ByteField("apuInfo98", None), + ByteField("apuInfo99", None), + ByteField("apuInfo100", None), + ByteField("apuInfo101", None), + ByteField("apuInfo102", None), + ByteField("apuInfo103", None), + ByteField("apuInfo104", None), + ByteField("apuInfo105", None), + ByteField("apuInfo106", None), + ByteField("apuInfo107", None), + ByteField("apuInfo108", None), + ByteField("apuInfo109", None), + ByteField("apuInfo110", None), + ByteField("apuInfo111", None), + ByteField("apuInfo112", None), + ByteField("apuInfo113", None), + ByteField("apuInfo114", None), + ByteField("apuInfo115", None), + ByteField("apuInfo116", None), + ByteField("apuInfo117", None), + ByteField("apuInfo118", None), + ByteField("apuInfo119", None), + ByteField("apuInfo120", None), + ByteField("apuInfo121", None), + ByteField("apuInfo122", None), + ByteField("apuInfo123", None), + ByteField("apuInfo124", None), + ByteField("apuInfo125", None), + ByteField("apuInfo126", None), + ByteField("apuInfo127", None), + ByteField("apuInfo128", None), + ByteField("apuInfo129", None), + ByteField("apuInfo130", None), + ByteField("apuInfo131", None), + ByteField("apuInfo132", None), + ByteField("apuInfo133", None), + ByteField("apuInfo134", None), + ByteField("apuInfo135", None), + ByteField("apuInfo136", None), + ByteField("apuInfo137", None), + ByteField("apuInfo138", None), + ByteField("apuInfo139", None), + ByteField("apuInfo140", None), + ByteField("apuInfo141", None), + ByteField("apuInfo142", None), + ByteField("apuInfo143", None), + ByteField("apuInfo144", None), + ByteField("apuInfo145", None), + ByteField("apuInfo146", None), + ByteField("apuInfo147", None), + ByteField("apuInfo148", None), + ByteField("apuInfo149", None), + ByteField("apuInfo150", None), + ByteField("apuInfo151", None), + ByteField("apuInfo152", None), + ByteField("apuInfo153", None), + ByteField("apuInfo154", None), + ByteField("apuInfo155", None), + ByteField("apuInfo156", None), + ByteField("apuInfo157", None), + ByteField("apuInfo158", None), + ByteField("apuInfo159", None), + ByteField("apuInfo160", None), + ByteField("apuInfo161", None), + ByteField("apuInfo162", None), + ByteField("apuInfo163", None), + ByteField("apuInfo164", None), + ByteField("apuInfo165", None), + ByteField("apuInfo166", None), + ByteField("apuInfo167", None), + ByteField("apuInfo168", None), + ByteField("apuInfo169", None), + ByteField("apuInfo170", None), + ByteField("apuInfo171", None), + ByteField("apuInfo172", None), + ByteField("apuInfo173", None), + ByteField("apuInfo174", None), + ByteField("apuInfo175", None), + ByteField("apuInfo176", None), + ByteField("apuInfo177", None), + ByteField("apuInfo178", None), + ByteField("apuInfo179", None), + ByteField("apuInfo180", None), + ByteField("apuInfo181", None), + ByteField("apuInfo182", None), + ByteField("apuInfo183", None), + ByteField("apuInfo184", None), + ByteField("apuInfo185", None), + ByteField("apuInfo186", None), + ByteField("apuInfo187", None), + ByteField("apuInfo188", None), + ByteField("apuInfo189", None), + ByteField("apuInfo190", None), + ByteField("apuInfo191", None), + ByteField("apuInfo192", None), + ByteField("apuInfo193", None), + ByteField("apuInfo194", None), + ByteField("apuInfo195", None), + ByteField("apuInfo196", None), + ByteField("apuInfo197", None), + ByteField("apuInfo198", None), + ByteField("apuInfo199", None), + ByteField("apuInfo200", None), + ByteField("apuInfo201", None), + ByteField("apuInfo202", None), + ByteField("apuInfo203", None), + ByteField("apuInfo204", None), + ByteField("apuInfo205", None), + ByteField("apuInfo206", None), + ByteField("apuInfo207", None), + ByteField("apuInfo208", None), + ByteField("apuInfo209", None), + ByteField("apuInfo210", None), + ByteField("apuInfo211", None), + ByteField("apuInfo212", None), + ByteField("apuInfo213", None), + ByteField("apuInfo214", None), + ByteField("apuInfo215", None), + ByteField("apuInfo216", None), + ByteField("apuInfo217", None), + ByteField("apuInfo218", None), + ByteField("apuInfo219", None), + ByteField("apuInfo220", None), + ByteField("apuInfo221", None), + ByteField("apuInfo222", None), + ByteField("apuInfo223", None), + ByteField("apuInfo224", None), + ByteField("apuInfo225", None), + ByteField("apuInfo226", None), + ByteField("apuInfo227", None), + ByteField("apuInfo228", None), + ByteField("apuInfo229", None), + ByteField("apuInfo230", None), + ByteField("apuInfo231", None), + ByteField("apuInfo232", None), + ByteField("apuInfo233", None), + ByteField("apuInfo234", None), + ByteField("apuInfo235", None), + ByteField("apuInfo236", None), + ByteField("apuInfo237", None), + ByteField("apuInfo238", None), + ByteField("apuInfo239", None), + ByteField("apuInfo240", None), + ByteField("apuInfo241", None), + ByteField("apuInfo242", None), + ByteField("apuInfo243", None), + ByteField("apuInfo244", None), + ByteField("apuInfo245", None), + ByteField("apuInfo246", None), + ByteField("apuInfo247", None), + ByteField("apuInfo248", None), + ByteField("apuInfo249", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 251, a, self.fields_desc) + if self.lengthAD is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + +# +# 10.5.3 Mobility management information elements +# + + +class AuthenticationParameterRAND(Packet): + """Authentication parameter RAND Section 10.5.3.1""" + name = "Authentication Parameter Rand" + fields_desc = [ + ByteField("ieiAPR", None), + BitField("randValue", 0x0, 128) + ] + + +class AuthenticationParameterSRES(Packet): + """Authentication parameter SRES Section 10.5.3.2""" + name = "Authentication Parameter Sres" + fields_desc = [ + ByteField("ieiAPS", None), + BitField("sresValue", 0x0, 40) + ] + + +class CmServiceType(Packet): + """CM service type Section 10.5.3.3""" + name = "CM Service Type" + fields_desc = [ + XBitField("ieiCST", 0x0, 4), + BitField("serviceType", 0x0, 4) + ] + + +class CmServiceTypeAndCiphKeySeqNr(Packet): + name = "CM Service Type and Cipher Key Sequence Number" + fields_desc = [ + BitField("keySeq", 0x0, 3), + BitField("spare", 0x0, 1), + BitField("serviceType", 0x0, 4) + ] + + +class IdentityType(Packet): + """Identity type Section 10.5.3.4""" + name = "Identity Type" + fields_desc = [ + XBitField("ieiIT", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("idType", 0x1, 3) + ] + + +# Fix 1/2 len problem +class IdentityTypeAndSpareHalfOctet(Packet): + name = "Identity Type and Spare Half Octet" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("idType", 0x1, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class LocationUpdatingType(Packet): + """Location updating type Section 10.5.3.5""" + name = "Location Updating Type" + fields_desc = [ + XBitField("ieiLUT", 0x0, 4), + BitField("for", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("lut", 0x0, 2) + ] + + +class LocationUpdatingTypeAndCiphKeySeqNr(Packet): + name = "Location Updating Type and Cipher Key Sequence Number" + fields_desc = [ + BitField("for", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("lut", 0x0, 2), + BitField("spare", 0x0, 1), + BitField("keySeq", 0x0, 3) + ] + + +# len 3 to L3 max (251) (done) +class NetworkNameHdr(Packet): + """Network Name Section 10.5.3.5a""" + name = "Network Name" + fields_desc = [ + BitField("eightBitNN", None, 1), + XBitField("ieiNN", None, 7), + + XByteField("lengthNN", None), + + BitField("ext1", 0x1, 1), + BitField("codingScheme", 0x0, 3), + BitField("addCi", 0x0, 1), + BitField("nbSpare", 0x0, 3), + # optional + ByteField("txtString1", None), + ByteField("txtString2", None), + ByteField("txtString3", None), + ByteField("txtString4", None), + ByteField("txtString5", None), + ByteField("txtString6", None), + ByteField("txtString7", None), + ByteField("txtString8", None), + ByteField("txtString9", None), + ByteField("txtString10", None), + ByteField("txtString11", None), + ByteField("txtString12", None), + ByteField("txtString13", None), + ByteField("txtString14", None), + ByteField("txtString15", None), + ByteField("txtString16", None), + ByteField("txtString17", None), + ByteField("txtString18", None), + ByteField("txtString19", None), + ByteField("txtString20", None), + ByteField("txtString21", None), + ByteField("txtString22", None), + ByteField("txtString23", None), + ByteField("txtString24", None), + ByteField("txtString25", None), + ByteField("txtString26", None), + ByteField("txtString27", None), + ByteField("txtString28", None), + ByteField("txtString29", None), + ByteField("txtString30", None), + ByteField("txtString31", None), + ByteField("txtString32", None), + ByteField("txtString33", None), + ByteField("txtString34", None), + ByteField("txtString35", None), + ByteField("txtString36", None), + ByteField("txtString37", None), + ByteField("txtString38", None), + ByteField("txtString39", None), + ByteField("txtString40", None), + ByteField("txtString41", None), + ByteField("txtString42", None), + ByteField("txtString43", None), + ByteField("txtString44", None), + ByteField("txtString45", None), + ByteField("txtString46", None), + ByteField("txtString47", None), + ByteField("txtString48", None), + ByteField("txtString49", None), + ByteField("txtString50", None), + ByteField("txtString51", None), + ByteField("txtString52", None), + ByteField("txtString53", None), + ByteField("txtString54", None), + ByteField("txtString55", None), + ByteField("txtString56", None), + ByteField("txtString57", None), + ByteField("txtString58", None), + ByteField("txtString59", None), + ByteField("txtString60", None), + ByteField("txtString61", None), + ByteField("txtString62", None), + ByteField("txtString63", None), + ByteField("txtString64", None), + ByteField("txtString65", None), + ByteField("txtString66", None), + ByteField("txtString67", None), + ByteField("txtString68", None), + ByteField("txtString69", None), + ByteField("txtString70", None), + ByteField("txtString71", None), + ByteField("txtString72", None), + ByteField("txtString73", None), + ByteField("txtString74", None), + ByteField("txtString75", None), + ByteField("txtString76", None), + ByteField("txtString77", None), + ByteField("txtString78", None), + ByteField("txtString79", None), + ByteField("txtString80", None), + ByteField("txtString81", None), + ByteField("txtString82", None), + ByteField("txtString83", None), + ByteField("txtString84", None), + ByteField("txtString85", None), + ByteField("txtString86", None), + ByteField("txtString87", None), + ByteField("txtString88", None), + ByteField("txtString89", None), + ByteField("txtString90", None), + ByteField("txtString91", None), + ByteField("txtString92", None), + ByteField("txtString93", None), + ByteField("txtString94", None), + ByteField("txtString95", None), + ByteField("txtString96", None), + ByteField("txtString97", None), + ByteField("txtString98", None), + ByteField("txtString99", None), + ByteField("txtString100", None), + ByteField("txtString101", None), + ByteField("txtString102", None), + ByteField("txtString103", None), + ByteField("txtString104", None), + ByteField("txtString105", None), + ByteField("txtString106", None), + ByteField("txtString107", None), + ByteField("txtString108", None), + ByteField("txtString109", None), + ByteField("txtString110", None), + ByteField("txtString111", None), + ByteField("txtString112", None), + ByteField("txtString113", None), + ByteField("txtString114", None), + ByteField("txtString115", None), + ByteField("txtString116", None), + ByteField("txtString117", None), + ByteField("txtString118", None), + ByteField("txtString119", None), + ByteField("txtString120", None), + ByteField("txtString121", None), + ByteField("txtString122", None), + ByteField("txtString123", None), + ByteField("txtString124", None), + ByteField("txtString125", None), + ByteField("txtString126", None), + ByteField("txtString127", None), + ByteField("txtString128", None), + ByteField("txtString129", None), + ByteField("txtString130", None), + ByteField("txtString131", None), + ByteField("txtString132", None), + ByteField("txtString133", None), + ByteField("txtString134", None), + ByteField("txtString135", None), + ByteField("txtString136", None), + ByteField("txtString137", None), + ByteField("txtString138", None), + ByteField("txtString139", None), + ByteField("txtString140", None), + ByteField("txtString141", None), + ByteField("txtString142", None), + ByteField("txtString143", None), + ByteField("txtString144", None), + ByteField("txtString145", None), + ByteField("txtString146", None), + ByteField("txtString147", None), + ByteField("txtString148", None), + ByteField("txtString149", None), + ByteField("txtString150", None), + ByteField("txtString151", None), + ByteField("txtString152", None), + ByteField("txtString153", None), + ByteField("txtString154", None), + ByteField("txtString155", None), + ByteField("txtString156", None), + ByteField("txtString157", None), + ByteField("txtString158", None), + ByteField("txtString159", None), + ByteField("txtString160", None), + ByteField("txtString161", None), + ByteField("txtString162", None), + ByteField("txtString163", None), + ByteField("txtString164", None), + ByteField("txtString165", None), + ByteField("txtString166", None), + ByteField("txtString167", None), + ByteField("txtString168", None), + ByteField("txtString169", None), + ByteField("txtString170", None), + ByteField("txtString171", None), + ByteField("txtString172", None), + ByteField("txtString173", None), + ByteField("txtString174", None), + ByteField("txtString175", None), + ByteField("txtString176", None), + ByteField("txtString177", None), + ByteField("txtString178", None), + ByteField("txtString179", None), + ByteField("txtString180", None), + ByteField("txtString181", None), + ByteField("txtString182", None), + ByteField("txtString183", None), + ByteField("txtString184", None), + ByteField("txtString185", None), + ByteField("txtString186", None), + ByteField("txtString187", None), + ByteField("txtString188", None), + ByteField("txtString189", None), + ByteField("txtString190", None), + ByteField("txtString191", None), + ByteField("txtString192", None), + ByteField("txtString193", None), + ByteField("txtString194", None), + ByteField("txtString195", None), + ByteField("txtString196", None), + ByteField("txtString197", None), + ByteField("txtString198", None), + ByteField("txtString199", None), + ByteField("txtString200", None), + ByteField("txtString201", None), + ByteField("txtString202", None), + ByteField("txtString203", None), + ByteField("txtString204", None), + ByteField("txtString205", None), + ByteField("txtString206", None), + ByteField("txtString207", None), + ByteField("txtString208", None), + ByteField("txtString209", None), + ByteField("txtString210", None), + ByteField("txtString211", None), + ByteField("txtString212", None), + ByteField("txtString213", None), + ByteField("txtString214", None), + ByteField("txtString215", None), + ByteField("txtString216", None), + ByteField("txtString217", None), + ByteField("txtString218", None), + ByteField("txtString219", None), + ByteField("txtString220", None), + ByteField("txtString221", None), + ByteField("txtString222", None), + ByteField("txtString223", None), + ByteField("txtString224", None), + ByteField("txtString225", None), + ByteField("txtString226", None), + ByteField("txtString227", None), + ByteField("txtString228", None), + ByteField("txtString229", None), + ByteField("txtString230", None), + ByteField("txtString231", None), + ByteField("txtString232", None), + ByteField("txtString233", None), + ByteField("txtString234", None), + ByteField("txtString235", None), + ByteField("txtString236", None), + ByteField("txtString237", None), + ByteField("txtString238", None), + ByteField("txtString239", None), + ByteField("txtString240", None), + ByteField("txtString241", None), + ByteField("txtString242", None), + ByteField("txtString243", None), + ByteField("txtString244", None), + ByteField("txtString245", None), + ByteField("txtString246", None), + ByteField("txtString247", None), + ByteField("txtString248", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 251, a, self.fields_desc) + if self.lengthNN is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class RejectCause(Packet): + """Reject cause Section 10.5.3.6""" + name = "Reject Cause" + fields_desc = [ + ByteField("ieiRC", 0x0), + ByteField("rejCause", 0x0) + ] + + +class FollowOnProceed(Packet): + """Follow-on Proceed Section 10.5.3.7""" + name = "Follow-on Proceed" + fields_desc = [ + ByteField("ieiFOP", 0x0), + ] + + +class TimeZoneHdr(Packet): + """Time Zone Section 10.5.3.8""" + name = "Time Zone" + fields_desc = [ + BitField("eightBitTZ", None, 1), + XBitField("ieiTZ", None, 7), + ByteField("timeZone", 0x0), + ] + + +class TimeZoneAndTimeHdr(Packet): + """Time Zone and Time Section 10.5.3.9""" + name = "Time Zone and Time" + fields_desc = [ + BitField("eightBitTZAT", None, 1), + XBitField("ieiTZAT", None, 7), + ByteField("year", 0x0), + ByteField("month", 0x0), + ByteField("day", 0x0), + ByteField("hour", 0x0), + ByteField("minute", 0x0), + ByteField("second", 0x0), + ByteField("timeZone", 0x0) + ] + + +class CtsPermissionHdr(Packet): + """CTS permission Section 10.5.3.10""" + name = "Cts Permission" + fields_desc = [ + BitField("eightBitCP", None, 1), + XBitField("ieiCP", None, 7), + ] + + +class LsaIdentifierHdr(Packet): + """LSA Identifier Section 10.5.3.11""" + name = "Lsa Identifier" + fields_desc = [ + BitField("eightBitLI", None, 1), + XBitField("ieiLI", None, 7), + ByteField("lsaID", 0x0), + ByteField("lsaID1", 0x0), + ByteField("lsaID2", 0x0) + ] + + +# +# 10.5.4 Call control information elements +# + +#10.5.4.1 Extensions of codesets +# This is only text and no packet + +class LockingShiftProcedureHdr(Packet): + """Locking shift procedure Section 10.5.4.2""" + name = "Locking Shift Procedure" + fields_desc = [ + XBitField("ieiLSP", None, 4), + BitField("lockShift", 0x0, 1), + BitField("codesetId", 0x0, 3) + ] + + +class NonLockingShiftProcedureHdr(Packet): + """Non-locking shift procedure Section 10.5.4.3""" + name = "Non-locking Shift Procedure" + fields_desc = [ + XBitField("ieiNLSP", None, 4), + BitField("nonLockShift", 0x1, 1), + BitField("codesetId", 0x0, 3) + ] + + +class AuxiliaryStatesHdr(Packet): + """Auxiliary states Section 10.5.4.4""" + name = "Auxiliary States" + fields_desc = [ + BitField("eightBitAS", None, 1), + XBitField("ieiAS", None, 7), + XByteField("lengthAS", 0x3), + BitField("ext", 0x1, 1), + BitField("spare", 0x0, 3), + BitField("holdState", 0x0, 2), + BitField("mptyState", 0x0, 2) + ] + + +# len 3 to 15 +class BearerCapabilityHdr(Packet): + """Bearer capability Section 10.5.4.5""" + name = "Bearer Capability" + fields_desc = [ + BitField("eightBitBC", None, 1), + XBitField("ieiBC", None, 7), + + XByteField("lengthBC", None), + + BitField("ext0", 0x1, 1), + BitField("radioChReq", 0x1, 2), + BitField("codingStd", 0x0, 1), + BitField("transMode", 0x0, 1), + BitField("infoTransCa", 0x0, 3), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("coding", None, 1), + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("spare", None, 2), + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("speechVers", 0x0, 4), + lambda pkt: pkt.ext0 == 0), + + ConditionalField(BitField("ext2", 0x1, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("compress", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("structure", None, 2), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("dupMode", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("config", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("nirr", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("establi", 0x0, 1), + lambda pkt: pkt.ext1 == 0), + + BitField("ext3", None, 1), + BitField("accessId", None, 2), + BitField("rateAda", None, 2), + BitField("signaling", None, 3), + + ConditionalField(BitField("ext4", None, 1), + lambda pkt: pkt.ext3 == 0), + ConditionalField(BitField("otherITC", None, 2), + lambda pkt: pkt.ext3 == 0), + ConditionalField(BitField("otherRate", None, 2), + lambda pkt: pkt.ext3 == 0), + ConditionalField(BitField("spare1", 0x0, 3), + lambda pkt: pkt.ext3 == 0), + + ConditionalField(BitField("ext5", 0x1, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("hdr", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("multiFr", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("mode", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("lli", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("assig", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("inbNeg", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("spare2", 0x0, 1), + lambda pkt: pkt.ext4 == 0), + + BitField("ext6", None, 1), + BitField("layer1Id", None, 2), + BitField("userInf", None, 4), + BitField("sync", None, 1), + + ConditionalField(BitField("ext7", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("stopBit", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("negoc", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("nbDataBit", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("userRate", None, 4), + lambda pkt: pkt.ext6 == 0), + + ConditionalField(BitField("ext8", None, 1), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("interRate", None, 2), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("nicTX", None, 1), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("nicRX", None, 1), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("parity", None, 3), + lambda pkt: pkt.ext7 == 0), + + ConditionalField(BitField("ext9", None, 1), + lambda pkt: pkt.ext8 == 0), + ConditionalField(BitField("connEle", None, 2), + lambda pkt: pkt.ext8 == 0), + ConditionalField(BitField("modemType", None, 5), + lambda pkt: pkt.ext8 == 0), + + ConditionalField(BitField("ext10", None, 1), + lambda pkt: pkt.ext9 == 0), + ConditionalField(BitField("otherModemType", None, 2), + lambda pkt: pkt.ext9 == 0), + ConditionalField(BitField("netUserRate", None, 5), + lambda pkt: pkt.ext9 == 0), + + ConditionalField(BitField("ext11", None, 1), + lambda pkt: pkt.ext10 == 0), + ConditionalField(BitField("chanCoding", None, 4), + lambda pkt: pkt.ext10 == 0), + ConditionalField(BitField("maxTrafficChan", None, 3), + lambda pkt: pkt.ext10 == 0), + + ConditionalField(BitField("ext12", None, 1), + lambda pkt: pkt.ext11 == 0), + ConditionalField(BitField("uimi", None, 3), + lambda pkt: pkt.ext11 == 0), + ConditionalField(BitField("airInterfaceUserRate", None, 4), + lambda pkt: pkt.ext11 == 0), + + ConditionalField(BitField("ext13", 0x1, 1), + lambda pkt: pkt.ext12 == 0), + ConditionalField(BitField("layer2Ch", None, 2), + lambda pkt: pkt.ext12 == 0), + ConditionalField(BitField("userInfoL2", 0x0, 5), + lambda pkt: pkt.ext12 == 0) + ] + +# We have a bug here. packet is not working if used in message + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 15, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + # avoids a bug. find better way + if len(p) is 5: + p = p[:-2] + if self.lengthBC is None: + print("len von a %s" % (len(p),)) + p = p[:1] + struct.pack(">B", len(p)-3) + p[2:] + return p + pay + + +class CallControlCapabilitiesHdr(Packet): + """Call Control Capabilities Section 10.5.4.5a""" + name = "Call Control Capabilities" + fields_desc = [ + BitField("eightBitCCC", None, 1), + XBitField("ieiCCC", None, 7), + XByteField("lengthCCC", 0x3), + BitField("spare", 0x0, 6), + BitField("pcp", 0x0, 1), + BitField("dtmf", 0x0, 1) + ] + + +class CallStateHdr(Packet): + """Call State Section 10.5.4.6""" + name = "Call State" + fields_desc = [ + BitField("eightBitCS", None, 1), + XBitField("ieiCS", None, 7), + BitField("codingStd", 0x0, 2), + BitField("stateValue", 0x0, 6) + ] + + +# len 3 to 43 +class CalledPartyBcdNumberHdr(Packet): + """Called party BCD number Section 10.5.4.7""" + name = "Called Party BCD Number" + fields_desc = [ + BitField("eightBitCPBN", None, 1), + XBitField("ieiCPBN", None, 7), + XByteField("lengthCPBN", None), + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("nbPlanId", 0x0, 4), + # optional + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4), + + BitField("nbDigit22", None, 4), + BitField("nbDigit21", None, 4), + BitField("nbDigit24", None, 4), + BitField("nbDigit23", None, 4), + + BitField("nbDigit26", None, 4), + BitField("nbDigit25", None, 4), + BitField("nbDigit28", None, 4), + BitField("nbDigit27", None, 4), + + BitField("nbDigit30", None, 4), + BitField("nbDigit29", None, 4), + BitField("nbDigit32", None, 4), + BitField("nbDigit31", None, 4), + + BitField("nbDigit34", None, 4), + BitField("nbDigit33", None, 4), + BitField("nbDigit36", None, 4), + BitField("nbDigit35", None, 4), + + BitField("nbDigit38", None, 4), + BitField("nbDigit37", None, 4), + BitField("nbDigit40", None, 4), + BitField("nbDigit39", None, 4), +# ^^^^^^ 20 first optional bytes ^^^^^^^^^^^^^^^ + BitField("nbDigit42", None, 4), + BitField("nbDigit41", None, 4), + BitField("nbDigit44", None, 4), + BitField("nbDigit43", None, 4), + + BitField("nbDigit46", None, 4), + BitField("nbDigit45", None, 4), + BitField("nbDigit48", None, 4), + BitField("nbDigit47", None, 4), + + BitField("nbDigit50", None, 4), + BitField("nbDigit49", None, 4), + BitField("nbDigit52", None, 4), + BitField("nbDigit51", None, 4), + + BitField("nbDigit54", None, 4), + BitField("nbDigit53", None, 4), + BitField("nbDigit56", None, 4), + BitField("nbDigit55", None, 4), + + BitField("nbDigit58", None, 4), + BitField("nbDigit57", None, 4), + BitField("nbDigit60", None, 4), + BitField("nbDigit59", None, 4), + + BitField("nbDigit62", None, 4), + BitField("nbDigit61", None, 4), + BitField("nbDigit64", None, 4), + BitField("nbDigit63", None, 4), + + BitField("nbDigit66", None, 4), + BitField("nbDigit65", None, 4), + BitField("nbDigit68", None, 4), + BitField("nbDigit67", None, 4), + + BitField("nbDigit70", None, 4), + BitField("nbDigit69", None, 4), + BitField("nbDigit72", None, 4), + BitField("nbDigit71", None, 4), + + BitField("nbDigit74", None, 4), + BitField("nbDigit73", None, 4), + BitField("nbDigit76", None, 4), + BitField("nbDigit75", None, 4), + + BitField("nbDigit78", None, 4), + BitField("nbDigit77", None, 4), + BitField("nbDigit80", None, 4), + BitField("nbDigit79", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 43, a, self.fields_desc, 2) + if self.lengthCPBN is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 2 to 23 +class CalledPartySubaddressHdr(Packet): + """Called party subaddress Section 10.5.4.8""" + name = "Called Party Subaddress" + fields_desc = [ + BitField("eightBitCPS", None, 1), + XBitField("ieiCPS", None, 7), + XByteField("lengthCPS", None), + # optional + BitField("ext", None, 1), + BitField("subAddr", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 23, a, self.fields_desc) + if self.lengthCPS is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 3 to 14 +class CallingPartyBcdNumberHdr(Packet): + """Called party subaddress Section 10.5.4.9""" + name = "Called Party Subaddress" + fields_desc = [ + BitField("eightBitCPBN", None, 1), + XBitField("ieiCPBN", None, 7), + XByteField("lengthCPBN", None), + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("nbPlanId", 0x0, 4), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("presId", None, 2), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("spare", None, 3), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("screenId", 0x0, 2), + lambda pkt: pkt.ext == 0), + + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 14, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthCPBN is None: + p = p[:1] + struct.pack(">B", len(p)-2) + p[2:] + return p + pay + + +# len 2 to 23 +class CallingPartySubaddressHdr(Packet): + """Calling party subaddress Section 10.5.4.10""" + name = "Calling Party Subaddress" + fields_desc = [ + BitField("eightBitCPS", None, 1), + XBitField("ieiCPS", None, 7), + XByteField("lengthCPS", None), + # optional + BitField("ext1", None, 1), + BitField("typeAddr", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 23, a, self.fields_desc) + if self.lengthCPS is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 4 to 32 +class CauseHdr(Packet): + """Cause Section 10.5.4.11""" + name = "Cause" + fields_desc = [ + BitField("eightBitC", None, 1), + XBitField("ieiC", None, 7), + + XByteField("lengthC", None), + + BitField("ext", 0x1, 1), + BitField("codingStd", 0x0, 2), + BitField("spare", 0x0, 1), + BitField("location", 0x0, 4), + + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("recommendation", 0x0, 7), + lambda pkt: pkt.ext == 0), + # optional + BitField("ext2", None, 1), + BitField("causeValue", None, 7), + + ByteField("diagnositc0", None), + ByteField("diagnositc1", None), + ByteField("diagnositc2", None), + ByteField("diagnositc3", None), + ByteField("diagnositc4", None), + ByteField("diagnositc5", None), + ByteField("diagnositc6", None), + ByteField("diagnositc7", None), + ByteField("diagnositc8", None), + ByteField("diagnositc9", None), + ByteField("diagnositc10", None), + ByteField("diagnositc11", None), + ByteField("diagnositc12", None), + ByteField("diagnositc13", None), + ByteField("diagnositc14", None), + ByteField("diagnositc15", None), + ByteField("diagnositc16", None), + ByteField("diagnositc17", None), + ByteField("diagnositc18", None), + ByteField("diagnositc19", None), + ByteField("diagnositc20", None), + ByteField("diagnositc21", None), + ByteField("diagnositc22", None), + ByteField("diagnositc23", None), + ByteField("diagnositc24", None), + ByteField("diagnositc25", None), + ByteField("diagnositc26", None), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 32, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthC is None: + p = p[:1] + struct.pack(">B", len(p)-2) + p[2:] + return p + pay + + +class ClirSuppressionHdr(Packet): + """CLIR suppression Section 10.5.4.11a""" + name = "Clir Suppression" + fields_desc = [ + BitField("eightBitCS", None, 1), + XBitField("ieiCS", None, 7), + ] + + +class ClirInvocationHdr(Packet): + """CLIR invocation Section 10.5.4.11b""" + name = "Clir Invocation" + fields_desc = [ + BitField("eightBitCI", None, 1), + XBitField("ieiCI", None, 7), + ] + + +class CongestionLevelHdr(Packet): + """Congestion level Section 10.5.4.12""" + name = "Congestion Level" + fields_desc = [ + XBitField("ieiCL", None, 4), + BitField("notDef", 0x0, 4) + ] + + +# Fix 1/2 len problem +class CongestionLevelAndSpareHalfOctets(Packet): + name = "Congestion Level and Spare Half Octets" + fields_desc = [ + BitField("ieiCL", 0x0, 4), + BitField("spareHalfOctets", 0x0, 4) + ] + + +# len 3 to 14 +class ConnectedNumberHdr(Packet): + """Connected number Section 10.5.4.13""" + name = "Connected Number" + fields_desc = [ + BitField("eightBitCN", None, 1), + XBitField("ieiCN", None, 7), + + XByteField("lengthCN", None), + + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("typePlanId", 0x0, 4), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("presId", None, 2), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("spare", None, 3), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("screenId", None, 2), + lambda pkt: pkt.ext == 0), + + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + sum1 = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 14, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthCN is None: + p = p[:1] + struct.pack(">B", len(p)-2) + p[2:] + return p + pay + + +# len 2 to 23 +class ConnectedSubaddressHdr(Packet): + """Connected subaddress Section 10.5.4.14""" + name = "Connected Subaddress" + fields_desc = [ + BitField("eightBitCS", None, 1), + XBitField("ieiCS", None, 7), + + XByteField("lengthCS", None), + # optional + BitField("ext", None, 1), + BitField("typeOfSub", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 23, a, self.fields_desc) + if self.lengthCS is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 2 to L3 (251) (done) +class FacilityHdr(Packet): + """Facility Section 10.5.4.15""" + name = "Facility" + fields_desc = [ + BitField("eightBitF", None, 1), + XBitField("ieiF", None, 7), + XByteField("lengthF", None), + # optional + ByteField("facilityInfo1", None), + ByteField("facilityInfo2", None), + ByteField("facilityInfo3", None), + ByteField("facilityInfo4", None), + ByteField("facilityInfo5", None), + ByteField("facilityInfo6", None), + ByteField("facilityInfo7", None), + ByteField("facilityInfo8", None), + ByteField("facilityInfo9", None), + ByteField("facilityInfo10", None), + ByteField("facilityInfo11", None), + ByteField("facilityInfo12", None), + ByteField("facilityInfo13", None), + ByteField("facilityInfo14", None), + ByteField("facilityInfo15", None), + ByteField("facilityInfo16", None), + ByteField("facilityInfo17", None), + ByteField("facilityInfo18", None), + ByteField("facilityInfo19", None), + ByteField("facilityInfo20", None), + ByteField("facilityInfo21", None), + ByteField("facilityInfo22", None), + ByteField("facilityInfo23", None), + ByteField("facilityInfo24", None), + ByteField("facilityInfo25", None), + ByteField("facilityInfo26", None), + ByteField("facilityInfo27", None), + ByteField("facilityInfo28", None), + ByteField("facilityInfo29", None), + ByteField("facilityInfo30", None), + ByteField("facilityInfo31", None), + ByteField("facilityInfo32", None), + ByteField("facilityInfo33", None), + ByteField("facilityInfo34", None), + ByteField("facilityInfo35", None), + ByteField("facilityInfo36", None), + ByteField("facilityInfo37", None), + ByteField("facilityInfo38", None), + ByteField("facilityInfo39", None), + ByteField("facilityInfo40", None), + ByteField("facilityInfo41", None), + ByteField("facilityInfo42", None), + ByteField("facilityInfo43", None), + ByteField("facilityInfo44", None), + ByteField("facilityInfo45", None), + ByteField("facilityInfo46", None), + ByteField("facilityInfo47", None), + ByteField("facilityInfo48", None), + ByteField("facilityInfo49", None), + ByteField("facilityInfo50", None), + ByteField("facilityInfo51", None), + ByteField("facilityInfo52", None), + ByteField("facilityInfo53", None), + ByteField("facilityInfo54", None), + ByteField("facilityInfo55", None), + ByteField("facilityInfo56", None), + ByteField("facilityInfo57", None), + ByteField("facilityInfo58", None), + ByteField("facilityInfo59", None), + ByteField("facilityInfo60", None), + ByteField("facilityInfo61", None), + ByteField("facilityInfo62", None), + ByteField("facilityInfo63", None), + ByteField("facilityInfo64", None), + ByteField("facilityInfo65", None), + ByteField("facilityInfo66", None), + ByteField("facilityInfo67", None), + ByteField("facilityInfo68", None), + ByteField("facilityInfo69", None), + ByteField("facilityInfo70", None), + ByteField("facilityInfo71", None), + ByteField("facilityInfo72", None), + ByteField("facilityInfo73", None), + ByteField("facilityInfo74", None), + ByteField("facilityInfo75", None), + ByteField("facilityInfo76", None), + ByteField("facilityInfo77", None), + ByteField("facilityInfo78", None), + ByteField("facilityInfo79", None), + ByteField("facilityInfo80", None), + ByteField("facilityInfo81", None), + ByteField("facilityInfo82", None), + ByteField("facilityInfo83", None), + ByteField("facilityInfo84", None), + ByteField("facilityInfo85", None), + ByteField("facilityInfo86", None), + ByteField("facilityInfo87", None), + ByteField("facilityInfo88", None), + ByteField("facilityInfo89", None), + ByteField("facilityInfo90", None), + ByteField("facilityInfo91", None), + ByteField("facilityInfo92", None), + ByteField("facilityInfo93", None), + ByteField("facilityInfo94", None), + ByteField("facilityInfo95", None), + ByteField("facilityInfo96", None), + ByteField("facilityInfo97", None), + ByteField("facilityInfo98", None), + ByteField("facilityInfo99", None), + ByteField("facilityInfo100", None), + ByteField("facilityInfo101", None), + ByteField("facilityInfo102", None), + ByteField("facilityInfo103", None), + ByteField("facilityInfo104", None), + ByteField("facilityInfo105", None), + ByteField("facilityInfo106", None), + ByteField("facilityInfo107", None), + ByteField("facilityInfo108", None), + ByteField("facilityInfo109", None), + ByteField("facilityInfo110", None), + ByteField("facilityInfo111", None), + ByteField("facilityInfo112", None), + ByteField("facilityInfo113", None), + ByteField("facilityInfo114", None), + ByteField("facilityInfo115", None), + ByteField("facilityInfo116", None), + ByteField("facilityInfo117", None), + ByteField("facilityInfo118", None), + ByteField("facilityInfo119", None), + ByteField("facilityInfo120", None), + ByteField("facilityInfo121", None), + ByteField("facilityInfo122", None), + ByteField("facilityInfo123", None), + ByteField("facilityInfo124", None), + ByteField("facilityInfo125", None), + ByteField("facilityInfo126", None), + ByteField("facilityInfo127", None), + ByteField("facilityInfo128", None), + ByteField("facilityInfo129", None), + ByteField("facilityInfo130", None), + ByteField("facilityInfo131", None), + ByteField("facilityInfo132", None), + ByteField("facilityInfo133", None), + ByteField("facilityInfo134", None), + ByteField("facilityInfo135", None), + ByteField("facilityInfo136", None), + ByteField("facilityInfo137", None), + ByteField("facilityInfo138", None), + ByteField("facilityInfo139", None), + ByteField("facilityInfo140", None), + ByteField("facilityInfo141", None), + ByteField("facilityInfo142", None), + ByteField("facilityInfo143", None), + ByteField("facilityInfo144", None), + ByteField("facilityInfo145", None), + ByteField("facilityInfo146", None), + ByteField("facilityInfo147", None), + ByteField("facilityInfo148", None), + ByteField("facilityInfo149", None), + ByteField("facilityInfo150", None), + ByteField("facilityInfo151", None), + ByteField("facilityInfo152", None), + ByteField("facilityInfo153", None), + ByteField("facilityInfo154", None), + ByteField("facilityInfo155", None), + ByteField("facilityInfo156", None), + ByteField("facilityInfo157", None), + ByteField("facilityInfo158", None), + ByteField("facilityInfo159", None), + ByteField("facilityInfo160", None), + ByteField("facilityInfo161", None), + ByteField("facilityInfo162", None), + ByteField("facilityInfo163", None), + ByteField("facilityInfo164", None), + ByteField("facilityInfo165", None), + ByteField("facilityInfo166", None), + ByteField("facilityInfo167", None), + ByteField("facilityInfo168", None), + ByteField("facilityInfo169", None), + ByteField("facilityInfo170", None), + ByteField("facilityInfo171", None), + ByteField("facilityInfo172", None), + ByteField("facilityInfo173", None), + ByteField("facilityInfo174", None), + ByteField("facilityInfo175", None), + ByteField("facilityInfo176", None), + ByteField("facilityInfo177", None), + ByteField("facilityInfo178", None), + ByteField("facilityInfo179", None), + ByteField("facilityInfo180", None), + ByteField("facilityInfo181", None), + ByteField("facilityInfo182", None), + ByteField("facilityInfo183", None), + ByteField("facilityInfo184", None), + ByteField("facilityInfo185", None), + ByteField("facilityInfo186", None), + ByteField("facilityInfo187", None), + ByteField("facilityInfo188", None), + ByteField("facilityInfo189", None), + ByteField("facilityInfo190", None), + ByteField("facilityInfo191", None), + ByteField("facilityInfo192", None), + ByteField("facilityInfo193", None), + ByteField("facilityInfo194", None), + ByteField("facilityInfo195", None), + ByteField("facilityInfo196", None), + ByteField("facilityInfo197", None), + ByteField("facilityInfo198", None), + ByteField("facilityInfo199", None), + ByteField("facilityInfo200", None), + ByteField("facilityInfo201", None), + ByteField("facilityInfo202", None), + ByteField("facilityInfo203", None), + ByteField("facilityInfo204", None), + ByteField("facilityInfo205", None), + ByteField("facilityInfo206", None), + ByteField("facilityInfo207", None), + ByteField("facilityInfo208", None), + ByteField("facilityInfo209", None), + ByteField("facilityInfo210", None), + ByteField("facilityInfo211", None), + ByteField("facilityInfo212", None), + ByteField("facilityInfo213", None), + ByteField("facilityInfo214", None), + ByteField("facilityInfo215", None), + ByteField("facilityInfo216", None), + ByteField("facilityInfo217", None), + ByteField("facilityInfo218", None), + ByteField("facilityInfo219", None), + ByteField("facilityInfo220", None), + ByteField("facilityInfo221", None), + ByteField("facilityInfo222", None), + ByteField("facilityInfo223", None), + ByteField("facilityInfo224", None), + ByteField("facilityInfo225", None), + ByteField("facilityInfo226", None), + ByteField("facilityInfo227", None), + ByteField("facilityInfo228", None), + ByteField("facilityInfo229", None), + ByteField("facilityInfo230", None), + ByteField("facilityInfo231", None), + ByteField("facilityInfo232", None), + ByteField("facilityInfo233", None), + ByteField("facilityInfo234", None), + ByteField("facilityInfo235", None), + ByteField("facilityInfo236", None), + ByteField("facilityInfo237", None), + ByteField("facilityInfo238", None), + ByteField("facilityInfo239", None), + ByteField("facilityInfo240", None), + ByteField("facilityInfo241", None), + ByteField("facilityInfo242", None), + ByteField("facilityInfo243", None), + ByteField("facilityInfo244", None), + ByteField("facilityInfo245", None), + ByteField("facilityInfo246", None), + ByteField("facilityInfo247", None), + ByteField("facilityInfo248", None), + ByteField("facilityInfo249", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 251, a, self.fields_desc) + if self.lengthF is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +#len 2 to 5 +class HighLayerCompatibilityHdr(Packet): + """High layer compatibility Section 10.5.4.16""" + name = "High Layer Compatibility" + fields_desc = [ + BitField("eightBitHLC", None, 1), + XBitField("ieiHLC", None, 7), + + XByteField("lengthHLC", None), + # optional + BitField("ext", None, 1), + BitField("codingStd", None, 2), + BitField("interpret", None, 3), + BitField("presMeth", None, 2), + + BitField("ext1", None, 1), + BitField("highLayerId", None, 7), + + ConditionalField(BitField("ext2", 0x1, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("exHiLayerId", 0x0, 7), + lambda pkt: pkt.ext1 == 0) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 5, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthHLC is None: + p = p[:1] + struct.pack(">B", len(p)-2) + p[2:] + return p + pay +# +# 10.5.4.16.1 Static conditions for the high layer +# compatibility IE contents +# + + +class KeypadFacilityHdr(Packet): + """Keypad facility Section 10.5.4.17""" + name = "Keypad Facility" + fields_desc = [ + BitField("eightBitKF", None, 1), + XBitField("ieiKF", None, 7), + BitField("spare", 0x0, 1), + BitField("keyPadInfo", 0x0, 7) + ] + + +# len 2 to 15 +class LowLayerCompatibilityHdr(Packet): + """Low layer compatibility Section 10.5.4.18""" + name = "Low Layer Compatibility" + fields_desc = [ + BitField("eightBitLLC", None, 1), + XBitField("ieiLLC", None, 7), + + XByteField("lengthLLC", None), + # optional + ByteField("rest0", None), + ByteField("rest1", None), + ByteField("rest2", None), + ByteField("rest3", None), + ByteField("rest4", None), + ByteField("rest5", None), + ByteField("rest6", None), + ByteField("rest7", None), + ByteField("rest8", None), + ByteField("rest9", None), + ByteField("rest10", None), + ByteField("rest11", None), + ByteField("rest12", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 15, a, self.fields_desc) + if self.lengthLLC is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class MoreDataHdr(Packet): + """More data Section 10.5.4.19""" + name = "More Data" + fields_desc = [ + BitField("eightBitMD", None, 1), + XBitField("ieiMD", None, 7), + ] + + +class NotificationIndicatorHdr(Packet): + """Notification indicator Section 10.5.4.20""" + name = "Notification Indicator" + fields_desc = [ + BitField("eightBitNI", None, 1), + XBitField("ieiNI", None, 7), + BitField("ext", 0x1, 1), + BitField("notifDesc", 0x0, 7) + ] + + +class ProgressIndicatorHdr(Packet): + """Progress indicator Section 10.5.4.21""" + name = "Progress Indicator" + fields_desc = [ + BitField("eightBitPI", None, 1), + XBitField("ieiPI", None, 7), + XByteField("lengthPI", 0x2), + BitField("ext", 0x1, 1), + BitField("codingStd", 0x0, 2), + BitField("spare", 0x0, 1), + BitField("location", 0x0, 4), + BitField("ext1", 0x1, 1), + BitField("progressDesc", 0x0, 7) + ] + + +class RecallTypeHdr(Packet): + """Recall type $(CCBS)$ Section 10.5.4.21a""" + name = "Recall Type $(CCBS)$" + fields_desc = [ + BitField("eightBitRT", None, 1), + XBitField("ieiRT", None, 7), + BitField("spare", 0x0, 5), + BitField("recallType", 0x0, 3) + ] + + +# len 3 to 19 +class RedirectingPartyBcdNumberHdr(Packet): + """Redirecting party BCD number Section 10.5.4.21b""" + name = "Redirecting Party BCD Number" + fields_desc = [ + BitField("eightBitRPBN", None, 1), + XBitField("ieiRPBN", None, 7), + + XByteField("lengthRPBN", None), + + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("numberingPlan", 0x0, 4), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("presId", None, 2), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("spare", None, 3), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("screenId", None, 2), + lambda pkt: pkt.ext == 0), + + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4), + + BitField("nbDigit22", None, 4), + BitField("nbDigit21", None, 4), + + BitField("nbDigit24", None, 4), + BitField("nbDigit23", None, 4), + + BitField("nbDigit26", None, 4), + BitField("nbDigit25", None, 4), + + BitField("nbDigit28", None, 4), + BitField("nbDigit27", None, 4), + + BitField("nbDigit30", None, 4), + BitField("nbDigit29", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 19, a, self.fields_desc) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthRPBN is None: + p = p[:1] + struct.pack(">B", len(p)-2) + p[2:] + return p + pay + + +# length 2 to 23 +class RedirectingPartySubaddressHdr(Packet): + """Redirecting party subaddress Section 10.5.4.21c""" + name = "Redirecting Party BCD Number" + fields_desc = [ + BitField("eightBitRPS", None, 1), + XBitField("ieiRPS", None, 7), + + XByteField("lengthRPS", None), + # optional + BitField("ext", None, 1), + BitField("typeSub", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 23, a, self.fields_desc) + if self.lengthRPS is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class RepeatIndicatorHdr(Packet): + """Repeat indicator Section 10.5.4.22""" + name = "Repeat Indicator" + fields_desc = [ + XBitField("ieiRI", None, 4), + BitField("repeatIndic", 0x0, 4) + ] + + +class ReverseCallSetupDirectionHdr(Packet): + """Reverse call setup direction Section 10.5.4.22a""" + name = "Reverse Call Setup Direction" + fields_desc = [ + ByteField("ieiRCSD", 0x0) + ] + + +# no upper length min 2(max for L3) (251) +class SetupContainerHdr(Packet): + """SETUP Container $(CCBS)$ Section 10.5.4.22b""" + name = "Setup Container $(CCBS)$" + fields_desc = [ + BitField("eightBitSC", None, 1), + XBitField("ieiSC", None, 7), + XByteField("lengthSC", None), + # optional + ByteField("mess1", None), + ByteField("mess2", None), + ByteField("mess3", None), + ByteField("mess4", None), + ByteField("mess5", None), + ByteField("mess6", None), + ByteField("mess7", None), + ByteField("mess8", None), + ByteField("mess9", None), + ByteField("mess10", None), + ByteField("mess11", None), + ByteField("mess12", None), + ByteField("mess13", None), + ByteField("mess14", None), + ByteField("mess15", None), + ByteField("mess16", None), + ByteField("mess17", None), + ByteField("mess18", None), + ByteField("mess19", None), + ByteField("mess20", None), + ByteField("mess21", None), + ByteField("mess22", None), + ByteField("mess23", None), + ByteField("mess24", None), + ByteField("mess25", None), + ByteField("mess26", None), + ByteField("mess27", None), + ByteField("mess28", None), + ByteField("mess29", None), + ByteField("mess30", None), + ByteField("mess31", None), + ByteField("mess32", None), + ByteField("mess33", None), + ByteField("mess34", None), + ByteField("mess35", None), + ByteField("mess36", None), + ByteField("mess37", None), + ByteField("mess38", None), + ByteField("mess39", None), + ByteField("mess40", None), + ByteField("mess41", None), + ByteField("mess42", None), + ByteField("mess43", None), + ByteField("mess44", None), + ByteField("mess45", None), + ByteField("mess46", None), + ByteField("mess47", None), + ByteField("mess48", None), + ByteField("mess49", None), + ByteField("mess50", None), + ByteField("mess51", None), + ByteField("mess52", None), + ByteField("mess53", None), + ByteField("mess54", None), + ByteField("mess55", None), + ByteField("mess56", None), + ByteField("mess57", None), + ByteField("mess58", None), + ByteField("mess59", None), + ByteField("mess60", None), + ByteField("mess61", None), + ByteField("mess62", None), + ByteField("mess63", None), + ByteField("mess64", None), + ByteField("mess65", None), + ByteField("mess66", None), + ByteField("mess67", None), + ByteField("mess68", None), + ByteField("mess69", None), + ByteField("mess70", None), + ByteField("mess71", None), + ByteField("mess72", None), + ByteField("mess73", None), + ByteField("mess74", None), + ByteField("mess75", None), + ByteField("mess76", None), + ByteField("mess77", None), + ByteField("mess78", None), + ByteField("mess79", None), + ByteField("mess80", None), + ByteField("mess81", None), + ByteField("mess82", None), + ByteField("mess83", None), + ByteField("mess84", None), + ByteField("mess85", None), + ByteField("mess86", None), + ByteField("mess87", None), + ByteField("mess88", None), + ByteField("mess89", None), + ByteField("mess90", None), + ByteField("mess91", None), + ByteField("mess92", None), + ByteField("mess93", None), + ByteField("mess94", None), + ByteField("mess95", None), + ByteField("mess96", None), + ByteField("mess97", None), + ByteField("mess98", None), + ByteField("mess99", None), + ByteField("mess100", None), + ByteField("mess101", None), + ByteField("mess102", None), + ByteField("mess103", None), + ByteField("mess104", None), + ByteField("mess105", None), + ByteField("mess106", None), + ByteField("mess107", None), + ByteField("mess108", None), + ByteField("mess109", None), + ByteField("mess110", None), + ByteField("mess111", None), + ByteField("mess112", None), + ByteField("mess113", None), + ByteField("mess114", None), + ByteField("mess115", None), + ByteField("mess116", None), + ByteField("mess117", None), + ByteField("mess118", None), + ByteField("mess119", None), + ByteField("mess120", None), + ByteField("mess121", None), + ByteField("mess122", None), + ByteField("mess123", None), + ByteField("mess124", None), + ByteField("mess125", None), + ByteField("mess126", None), + ByteField("mess127", None), + ByteField("mess128", None), + ByteField("mess129", None), + ByteField("mess130", None), + ByteField("mess131", None), + ByteField("mess132", None), + ByteField("mess133", None), + ByteField("mess134", None), + ByteField("mess135", None), + ByteField("mess136", None), + ByteField("mess137", None), + ByteField("mess138", None), + ByteField("mess139", None), + ByteField("mess140", None), + ByteField("mess141", None), + ByteField("mess142", None), + ByteField("mess143", None), + ByteField("mess144", None), + ByteField("mess145", None), + ByteField("mess146", None), + ByteField("mess147", None), + ByteField("mess148", None), + ByteField("mess149", None), + ByteField("mess150", None), + ByteField("mess151", None), + ByteField("mess152", None), + ByteField("mess153", None), + ByteField("mess154", None), + ByteField("mess155", None), + ByteField("mess156", None), + ByteField("mess157", None), + ByteField("mess158", None), + ByteField("mess159", None), + ByteField("mess160", None), + ByteField("mess161", None), + ByteField("mess162", None), + ByteField("mess163", None), + ByteField("mess164", None), + ByteField("mess165", None), + ByteField("mess166", None), + ByteField("mess167", None), + ByteField("mess168", None), + ByteField("mess169", None), + ByteField("mess170", None), + ByteField("mess171", None), + ByteField("mess172", None), + ByteField("mess173", None), + ByteField("mess174", None), + ByteField("mess175", None), + ByteField("mess176", None), + ByteField("mess177", None), + ByteField("mess178", None), + ByteField("mess179", None), + ByteField("mess180", None), + ByteField("mess181", None), + ByteField("mess182", None), + ByteField("mess183", None), + ByteField("mess184", None), + ByteField("mess185", None), + ByteField("mess186", None), + ByteField("mess187", None), + ByteField("mess188", None), + ByteField("mess189", None), + ByteField("mess190", None), + ByteField("mess191", None), + ByteField("mess192", None), + ByteField("mess193", None), + ByteField("mess194", None), + ByteField("mess195", None), + ByteField("mess196", None), + ByteField("mess197", None), + ByteField("mess198", None), + ByteField("mess199", None), + ByteField("mess200", None), + ByteField("mess201", None), + ByteField("mess202", None), + ByteField("mess203", None), + ByteField("mess204", None), + ByteField("mess205", None), + ByteField("mess206", None), + ByteField("mess207", None), + ByteField("mess208", None), + ByteField("mess209", None), + ByteField("mess210", None), + ByteField("mess211", None), + ByteField("mess212", None), + ByteField("mess213", None), + ByteField("mess214", None), + ByteField("mess215", None), + ByteField("mess216", None), + ByteField("mess217", None), + ByteField("mess218", None), + ByteField("mess219", None), + ByteField("mess220", None), + ByteField("mess221", None), + ByteField("mess222", None), + ByteField("mess223", None), + ByteField("mess224", None), + ByteField("mess225", None), + ByteField("mess226", None), + ByteField("mess227", None), + ByteField("mess228", None), + ByteField("mess229", None), + ByteField("mess230", None), + ByteField("mess231", None), + ByteField("mess232", None), + ByteField("mess233", None), + ByteField("mess234", None), + ByteField("mess235", None), + ByteField("mess236", None), + ByteField("mess237", None), + ByteField("mess238", None), + ByteField("mess239", None), + ByteField("mess240", None), + ByteField("mess241", None), + ByteField("mess242", None), + ByteField("mess243", None), + ByteField("mess244", None), + ByteField("mess245", None), + ByteField("mess246", None), + ByteField("mess247", None), + ByteField("mess248", None), + ByteField("mess249", None), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 251, a, self.fields_desc) + if self.lengthSC is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class SignalHdr(Packet): + """Signal Section 10.5.4.23""" + name = "Signal" + fields_desc = [ + BitField("eightBitS", None, 1), + XBitField("ieiS", None, 7), + ByteField("sigValue", 0x0) + ] + + +# length 2 to max for L3 message (251) +class SsVersionIndicatorHdr(Packet): + """SS Version Indicator Section 10.5.4.24""" + name = "SS Version Indicator" + fields_desc = [ + BitField("eightBitSVI", None, 1), + XBitField("ieiSVI", None, 7), + XByteField("lengthSVI", None), + # optional + ByteField("info1", None), + ByteField("info2", None), + ByteField("info3", None), + ByteField("info4", None), + ByteField("info5", None), + ByteField("info6", None), + ByteField("info7", None), + ByteField("info8", None), + ByteField("info9", None), + ByteField("info10", None), + ByteField("info11", None), + ByteField("info12", None), + ByteField("info13", None), + ByteField("info14", None), + ByteField("info15", None), + ByteField("info16", None), + ByteField("info17", None), + ByteField("info18", None), + ByteField("info19", None), + ByteField("info20", None), + ByteField("info21", None), + ByteField("info22", None), + ByteField("info23", None), + ByteField("info24", None), + ByteField("info25", None), + ByteField("info26", None), + ByteField("info27", None), + ByteField("info28", None), + ByteField("info29", None), + ByteField("info30", None), + ByteField("info31", None), + ByteField("info32", None), + ByteField("info33", None), + ByteField("info34", None), + ByteField("info35", None), + ByteField("info36", None), + ByteField("info37", None), + ByteField("info38", None), + ByteField("info39", None), + ByteField("info40", None), + ByteField("info41", None), + ByteField("info42", None), + ByteField("info43", None), + ByteField("info44", None), + ByteField("info45", None), + ByteField("info46", None), + ByteField("info47", None), + ByteField("info48", None), + ByteField("info49", None), + ByteField("info50", None), + ByteField("info51", None), + ByteField("info52", None), + ByteField("info53", None), + ByteField("info54", None), + ByteField("info55", None), + ByteField("info56", None), + ByteField("info57", None), + ByteField("info58", None), + ByteField("info59", None), + ByteField("info60", None), + ByteField("info61", None), + ByteField("info62", None), + ByteField("info63", None), + ByteField("info64", None), + ByteField("info65", None), + ByteField("info66", None), + ByteField("info67", None), + ByteField("info68", None), + ByteField("info69", None), + ByteField("info70", None), + ByteField("info71", None), + ByteField("info72", None), + ByteField("info73", None), + ByteField("info74", None), + ByteField("info75", None), + ByteField("info76", None), + ByteField("info77", None), + ByteField("info78", None), + ByteField("info79", None), + ByteField("info80", None), + ByteField("info81", None), + ByteField("info82", None), + ByteField("info83", None), + ByteField("info84", None), + ByteField("info85", None), + ByteField("info86", None), + ByteField("info87", None), + ByteField("info88", None), + ByteField("info89", None), + ByteField("info90", None), + ByteField("info91", None), + ByteField("info92", None), + ByteField("info93", None), + ByteField("info94", None), + ByteField("info95", None), + ByteField("info96", None), + ByteField("info97", None), + ByteField("info98", None), + ByteField("info99", None), + ByteField("info100", None), + ByteField("info101", None), + ByteField("info102", None), + ByteField("info103", None), + ByteField("info104", None), + ByteField("info105", None), + ByteField("info106", None), + ByteField("info107", None), + ByteField("info108", None), + ByteField("info109", None), + ByteField("info110", None), + ByteField("info111", None), + ByteField("info112", None), + ByteField("info113", None), + ByteField("info114", None), + ByteField("info115", None), + ByteField("info116", None), + ByteField("info117", None), + ByteField("info118", None), + ByteField("info119", None), + ByteField("info120", None), + ByteField("info121", None), + ByteField("info122", None), + ByteField("info123", None), + ByteField("info124", None), + ByteField("info125", None), + ByteField("info126", None), + ByteField("info127", None), + ByteField("info128", None), + ByteField("info129", None), + ByteField("info130", None), + ByteField("info131", None), + ByteField("info132", None), + ByteField("info133", None), + ByteField("info134", None), + ByteField("info135", None), + ByteField("info136", None), + ByteField("info137", None), + ByteField("info138", None), + ByteField("info139", None), + ByteField("info140", None), + ByteField("info141", None), + ByteField("info142", None), + ByteField("info143", None), + ByteField("info144", None), + ByteField("info145", None), + ByteField("info146", None), + ByteField("info147", None), + ByteField("info148", None), + ByteField("info149", None), + ByteField("info150", None), + ByteField("info151", None), + ByteField("info152", None), + ByteField("info153", None), + ByteField("info154", None), + ByteField("info155", None), + ByteField("info156", None), + ByteField("info157", None), + ByteField("info158", None), + ByteField("info159", None), + ByteField("info160", None), + ByteField("info161", None), + ByteField("info162", None), + ByteField("info163", None), + ByteField("info164", None), + ByteField("info165", None), + ByteField("info166", None), + ByteField("info167", None), + ByteField("info168", None), + ByteField("info169", None), + ByteField("info170", None), + ByteField("info171", None), + ByteField("info172", None), + ByteField("info173", None), + ByteField("info174", None), + ByteField("info175", None), + ByteField("info176", None), + ByteField("info177", None), + ByteField("info178", None), + ByteField("info179", None), + ByteField("info180", None), + ByteField("info181", None), + ByteField("info182", None), + ByteField("info183", None), + ByteField("info184", None), + ByteField("info185", None), + ByteField("info186", None), + ByteField("info187", None), + ByteField("info188", None), + ByteField("info189", None), + ByteField("info190", None), + ByteField("info191", None), + ByteField("info192", None), + ByteField("info193", None), + ByteField("info194", None), + ByteField("info195", None), + ByteField("info196", None), + ByteField("info197", None), + ByteField("info198", None), + ByteField("info199", None), + ByteField("info200", None), + ByteField("info201", None), + ByteField("info202", None), + ByteField("info203", None), + ByteField("info204", None), + ByteField("info205", None), + ByteField("info206", None), + ByteField("info207", None), + ByteField("info208", None), + ByteField("info209", None), + ByteField("info210", None), + ByteField("info211", None), + ByteField("info212", None), + ByteField("info213", None), + ByteField("info214", None), + ByteField("info215", None), + ByteField("info216", None), + ByteField("info217", None), + ByteField("info218", None), + ByteField("info219", None), + ByteField("info220", None), + ByteField("info221", None), + ByteField("info222", None), + ByteField("info223", None), + ByteField("info224", None), + ByteField("info225", None), + ByteField("info226", None), + ByteField("info227", None), + ByteField("info228", None), + ByteField("info229", None), + ByteField("info230", None), + ByteField("info231", None), + ByteField("info232", None), + ByteField("info233", None), + ByteField("info234", None), + ByteField("info235", None), + ByteField("info236", None), + ByteField("info237", None), + ByteField("info238", None), + ByteField("info239", None), + ByteField("info240", None), + ByteField("info241", None), + ByteField("info242", None), + ByteField("info243", None), + ByteField("info244", None), + ByteField("info245", None), + ByteField("info246", None), + ByteField("info247", None), + ByteField("info248", None), + ByteField("info249", None), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 251, a, self.fields_desc) + if self.lengthSVI is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# length 3 to 35 or 131 +class UserUserHdr(Packet): + """User-user Section 10.5.4.25""" + name = "User-User" + fields_desc = [ + BitField("eightBitUU", None, 1), + XBitField("ieiUU", None, 7), + + XByteField("lengthUU", None), # dynamic length of field depending + # of the type of message + # let user decide which length he + # wants to take + # => more fuzzing options + ByteField("userUserPD", 0x0), + # optional + ByteField("userUserInfo1", None), + ByteField("userUserInfo2", None), + ByteField("userUserInfo3", None), + ByteField("userUserInfo4", None), + ByteField("userUserInfo5", None), + ByteField("userUserInfo6", None), + ByteField("userUserInfo7", None), + ByteField("userUserInfo8", None), + ByteField("userUserInfo9", None), + ByteField("userUserInfo10", None), + ByteField("userUserInfo11", None), + ByteField("userUserInfo12", None), + ByteField("userUserInfo13", None), + ByteField("userUserInfo14", None), + ByteField("userUserInfo15", None), + ByteField("userUserInfo16", None), + ByteField("userUserInfo17", None), + ByteField("userUserInfo18", None), + ByteField("userUserInfo19", None), + ByteField("userUserInfo20", None), + ByteField("userUserInfo21", None), + ByteField("userUserInfo22", None), + ByteField("userUserInfo23", None), + ByteField("userUserInfo24", None), + ByteField("userUserInfo25", None), + ByteField("userUserInfo26", None), + ByteField("userUserInfo27", None), + ByteField("userUserInfo28", None), + ByteField("userUserInfo29", None), + ByteField("userUserInfo30", None), + ByteField("userUserInfo31", None), + ByteField("userUserInfo32", None), + # long packet + ByteField("userUserInfo33", None), + ByteField("userUserInfo34", None), + ByteField("userUserInfo35", None), + ByteField("userUserInfo36", None), + ByteField("userUserInfo37", None), + ByteField("userUserInfo38", None), + ByteField("userUserInfo39", None), + ByteField("userUserInfo40", None), + ByteField("userUserInfo41", None), + ByteField("userUserInfo42", None), + ByteField("userUserInfo43", None), + ByteField("userUserInfo44", None), + ByteField("userUserInfo45", None), + ByteField("userUserInfo46", None), + ByteField("userUserInfo47", None), + ByteField("userUserInfo48", None), + ByteField("userUserInfo49", None), + ByteField("userUserInfo50", None), + ByteField("userUserInfo51", None), + ByteField("userUserInfo52", None), + ByteField("userUserInfo53", None), + ByteField("userUserInfo54", None), + ByteField("userUserInfo55", None), + ByteField("userUserInfo56", None), + ByteField("userUserInfo57", None), + ByteField("userUserInfo58", None), + ByteField("userUserInfo59", None), + ByteField("userUserInfo60", None), + ByteField("userUserInfo61", None), + ByteField("userUserInfo62", None), + ByteField("userUserInfo63", None), + ByteField("userUserInfo64", None), + ByteField("userUserInfo65", None), + ByteField("userUserInfo66", None), + ByteField("userUserInfo67", None), + ByteField("userUserInfo68", None), + ByteField("userUserInfo69", None), + ByteField("userUserInfo70", None), + ByteField("userUserInfo71", None), + ByteField("userUserInfo72", None), + ByteField("userUserInfo73", None), + ByteField("userUserInfo74", None), + ByteField("userUserInfo75", None), + ByteField("userUserInfo76", None), + ByteField("userUserInfo77", None), + ByteField("userUserInfo78", None), + ByteField("userUserInfo79", None), + ByteField("userUserInfo80", None), + ByteField("userUserInfo81", None), + ByteField("userUserInfo82", None), + ByteField("userUserInfo83", None), + ByteField("userUserInfo84", None), + ByteField("userUserInfo85", None), + ByteField("userUserInfo86", None), + ByteField("userUserInfo87", None), + ByteField("userUserInfo88", None), + ByteField("userUserInfo89", None), + ByteField("userUserInfo90", None), + ByteField("userUserInfo91", None), + ByteField("userUserInfo92", None), + ByteField("userUserInfo93", None), + ByteField("userUserInfo94", None), + ByteField("userUserInfo95", None), + ByteField("userUserInfo96", None), + ByteField("userUserInfo97", None), + ByteField("userUserInfo98", None), + ByteField("userUserInfo99", None), + ByteField("userUserInfo100", None), + ByteField("userUserInfo101", None), + ByteField("userUserInfo102", None), + ByteField("userUserInfo103", None), + ByteField("userUserInfo104", None), + ByteField("userUserInfo105", None), + ByteField("userUserInfo106", None), + ByteField("userUserInfo107", None), + ByteField("userUserInfo108", None), + ByteField("userUserInfo109", None), + ByteField("userUserInfo110", None), + ByteField("userUserInfo111", None), + ByteField("userUserInfo112", None), + ByteField("userUserInfo113", None), + ByteField("userUserInfo114", None), + ByteField("userUserInfo115", None), + ByteField("userUserInfo116", None), + ByteField("userUserInfo117", None), + ByteField("userUserInfo118", None), + ByteField("userUserInfo119", None), + ByteField("userUserInfo120", None), + ByteField("userUserInfo121", None), + ByteField("userUserInfo122", None), + ByteField("userUserInfo123", None), + ByteField("userUserInfo124", None), + ByteField("userUserInfo125", None), + ByteField("userUserInfo126", None), + ByteField("userUserInfo127", None), + ByteField("userUserInfo128", None), + ByteField("userUserInfo129", None), + ByteField("userUserInfo130", None), + ByteField("userUserInfo131", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 131, a, self.fields_desc) + if self.lengthUU is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class AlertingPatternHdr(Packet): + """Alerting Pattern 10.5.4.26""" + name = "Alerting Pattern" + fields_desc = [ + BitField("eightBitAP", None, 1), + XBitField("ieiAP", None, 7), + XByteField("lengthAP", 0x3), + BitField("spare", 0x0, 4), + BitField("alertingValue", 0x0, 4) + ] + + +class AllowedActionsHdr(Packet): + """Allowed actions $(CCBS)$ Section 10.5.4.26""" + name = "Allowed Actions $(CCBS)$" + fields_desc = [ + BitField("eightBitAA", None, 1), + XBitField("ieiAA", None, 7), + XByteField("lengthAP", 0x3), + BitField("CCBS", 0x0, 1), + BitField("spare", 0x0, 7) + ] + + +# +# 10.5.5 GPRS mobility management information elements +# + +class AttachResult(Packet): + """Attach result Section 10.5.5.1""" + name = "Attach Result" + fields_desc = [ + XBitField("ieiAR", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("result", 0x1, 3) + ] + + +class AttachTypeHdr(Packet): + """Attach type Section 10.5.5.2""" + name = "Attach Type" + fields_desc = [ + XBitField("ieiAT", None, 4), + BitField("spare", 0x0, 1), + BitField("type", 0x1, 3) + ] + + +# Fix 1/2 len problem +class AttachTypeAndCiphKeySeqNr(Packet): + name = "Attach Type and Cipher Key Sequence Number" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("type", 0x1, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class CipheringAlgorithm(Packet): + """Ciphering algorithm Section 10.5.5.3""" + name = "Ciphering Algorithm" + fields_desc = [ + XBitField("ieiCA", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("type", 0x1, 3) + ] + + +# Fix 1/2 len problem +class CipheringAlgorithmAndImeisvRequest(Packet): + name = "Ciphering Algorithm and Imeisv Request" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("type", 0x1, 3), + BitField("spare", 0x0, 1), + BitField("imeisvVal", 0x0, 3) + ] + + +# [Spare] +class TmsiStatus(Packet): + """[Spare] TMSI status Section 10.5.5.4""" + name = "[Spare] TMSI Status" + fields_desc = [ + XBitField("ieiTS", None, 4), + BitField("spare", 0x0, 3), + BitField("flag", 0x1, 1) + ] + + +class DetachType(Packet): + """Detach type Section 10.5.5.5""" + name = "Detach Type" + fields_desc = [ + XBitField("ieiDT", 0x0, 4), + BitField("poweroff", 0x0, 1), + BitField("type", 0x1, 3) + ] + + +# Fix 1/2 len problem +class DetachTypeAndForceToStandby(Packet): + name = "Detach Type and Force To Standby" + fields_desc = [ + BitField("poweroff", 0x0, 1), + BitField("type", 0x1, 3), + BitField("spare", 0x0, 1), + BitField("forceStandby", 0x0, 3) + ] + + +# Fix 1/2 len problem +class DetachTypeAndSpareHalfOctets(Packet): + name = "Detach Type and Spare Half Octets" + fields_desc = [ + BitField("poweroff", 0x0, 1), + BitField("type", 0x1, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class DrxParameter(Packet): + """DRX parameter Section 10.5.5.6""" + name = "DRX Parameter" + fields_desc = [ + ByteField("ieiDP", 0x0), + ByteField("splitPG", 0x0), + BitField("spare", 0x0, 4), + BitField("splitCCCH", 0x0, 1), + BitField("NonDrxTimer", 0x1, 3) + ] + + +class ForceToStandby(Packet): + """Force to standby Section 10.5.5.7""" + name = "Force To Standby" + fields_desc = [ + XBitField("ieiFTS", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("forceStandby", 0x0, 3) + ] + + +# Fix 1/2 len problem +class ForceToStandbyAndAcReferenceNumber(Packet): + name = "Force To Standby And Ac Reference Number" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("forceStandby", 0x0, 3), + BitField("acRefVal", 0x0, 4) + ] + + +# Fix 1/2 len problem +class ForceToStandbyAndUpdateResult(Packet): + name = "Force To Standby And Update Result" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("forceStandby", 0x0, 3), + BitField("spare", 0x0, 1), + BitField("updateResVal", 0x0, 3) + ] + + +# Fix 1/2 len problem +class ForceToStandbyAndSpareHalfOctets(Packet): + name = "Force To Standby And Spare Half Octets" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("forceStandby", 0x0, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class PTmsiSignature(Packet): + """P-TMSI signature Section 10.5.5.8""" + name = "P-TMSI Signature" + fields_desc = [ + ByteField("ieiPTS", 0x0), + BitField("sgnature", 0x0, 24) + ] + + +class IdentityType2(Packet): + """Identity type 2 Section 10.5.5.9""" + name = "Identity Type 2" + fields_desc = [ + XBitField("ieiIT2", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("typeOfIdentity", 0x0, 3) + ] + + +# Fix 1/2 len problem +class IdentityType2AndforceToStandby(Packet): + name = "Identity Type 2 and Force to Standby" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("typeOfIdentity", 0x0, 3), + BitField("spare", 0x0, 1), + BitField("forceStandby", 0x0, 3) + ] + + +class ImeisvRequest(Packet): + """IMEISV request Section 10.5.5.10""" + name = "IMEISV Request" + fields_desc = [ + XBitField("ieiIR", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("imeisvVal", 0x0, 3) + ] + + +# Fix 1/2 len problem +class ImeisvRequestAndForceToStandby(Packet): + name = "IMEISV Request and Force To Standby" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("imeisvVal", 0x0, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +# length 4 to 19 +class ReceiveNpduNumbersList(Packet): + """Receive N-PDU Numbers list Section 10.5.5.11""" + name = "Receive N-PDU Numbers list" + fields_desc = [ + ByteField("ieiRNNL", 0x0), + + XByteField("lengthRNNL", None), + + BitField("nbList0", 0x0, 16), + # optional + ByteField("nbList1", None), + ByteField("nbList2", None), + ByteField("nbList3", None), + ByteField("nbList4", None), + ByteField("nbList5", None), + ByteField("nbList6", None), + ByteField("nbList7", None), + ByteField("nbList8", None), + ByteField("nbList9", None), + ByteField("nbList10", None), + ByteField("nbList11", None), + ByteField("nbList12", None), + ByteField("nbList13", None), + ByteField("nbList14", None), + ByteField("nbList15", None), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 19, a, self.fields_desc) + if self.lengthRNNL is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class MsNetworkCapability(Packet): + """MS network capability Section 10.5.5.12""" + name = "MS Network Capability" + fields_desc = [ + ByteField("ieiMNC", 0x0), + XByteField("lengthMNC", 0x3), + ByteField("msNetValue", 0x0) + ] + + +# length 6 to 14 +class MsRadioAccessCapability(Packet): + """MS Radio Access capability Section 10.5.5.12a""" + name = "MS Radio Access Capability" + fields_desc = [ + ByteField("ieiMRAC", 0x24), + + XByteField("lengthMRAC", None), + + BitField("spare1", 0x0, 1), # ... + + BitField("accessCap", 0x0, 4), + BitField("accessTechType", 0x0, 4), + # access capability + BitField("bool", 0x0, 1), + BitField("lengthContent", 0x0, 7), + BitField("spare1", 0x0, 1), # ... + # content + BitField("pwrCap", 0x0, 3), + BitField("bool1", 0x0, 1), + BitField("a51", 0x0, 1), + BitField("a52", 0x0, 1), + BitField("a53", 0x0, 1), + BitField("a54", 0x0, 1), + + BitField("a55", 0x0, 1), + BitField("a56", 0x0, 1), + BitField("a57", 0x0, 1), + BitField("esInd", 0x0, 1), + BitField("ps", 0x0, 1), + BitField("vgcs", 0x0, 1), + BitField("vbs", 0x0, 1), + BitField("bool2", 0x0, 1), + # multislot + BitField("bool3", 0x0, 1), + BitField("hscsd", 0x0, 5), + + BitField("bool4", 0x0, 1), + BitField("gprs", 0x0, 5), + BitField("gprsExt", 0x0, 1), + BitField("bool5", 0x0, 1), + + BitField("smsVal", 0x0, 4), + BitField("smVal", 0x0, 4) + ] + + +# 10.5.5.13 Spare +# This is intentionally left spare. + +class GmmCause(Packet): + """GMM cause Section 10.5.5.14""" + name = "GMM Cause" + fields_desc = [ + ByteField("ieiGC", 0x0), + ByteField("causeValue", 0x0) + ] + + +class RoutingAreaIdentification(Packet): + """Routing area identification Section 10.5.5.15""" + name = "Routing Area Identification" + fields_desc = [ + ByteField("ieiRAI", 0x0), + BitField("mccDigit2", 0x0, 4), + BitField("mccDigit1", 0x0, 4), + BitField("mncDigit3", 0x0, 4), + BitField("mccDigit3", 0x0, 4), + BitField("mccDigit2", 0x0, 4), + BitField("mccDigit1", 0x0, 4), + ByteField("LAC", 0x0), + ByteField("LAC1", 0x0), + ByteField("LAC", 0x0) + ] +# 10.5.5.16 Spare +# This is intentionally left spare. + + +class UpdateResult(Packet): + """Update result Section 10.5.5.17""" + name = "Update Result" + fields_desc = [ + XBitField("ieiUR", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("updateResVal", 0x0, 3) + ] + + +class UpdateType(Packet): + """Update type Section 10.5.5.18""" + name = "Update Type" + fields_desc = [ + XBitField("ieiUT", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("updateTypeVal", 0x0, 3) + ] + + +# Fix 1/2 len problem +class UpdateTypeAndCiphKeySeqNr(Packet): + name = "Update Type and Cipher Key Sequence Number" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("updateTypeVal", 0x0, 3), + BitField("spare", 0x0, 1), + BitField("keySeq", 0x0, 3) + ] + + +class AcReferenceNumber(Packet): + """A&C reference number Section 10.5.5.19""" + name = "A&C Reference Number" + fields_desc = [ + XBitField("ieiARN", 0x0, 4), + BitField("acRefVal", 0x0, 4) + ] + + +# Fix 1/2 len problem +class AcReferenceNumberAndSpareHalfOctets(Packet): + name = "A&C Reference Number and Spare Half Octets" + fields_desc = [ + BitField("acRefVal", 0x0, 4), + BitField("spareHalfOctets", 0x0, 4) + ] +# +# 10.5.6 Session management information elements +# +# length 3 to 102 + + +class AccessPointName(Packet): + """Access Point Name Section 10.5.6.1""" + name = "Access Point Name" + fields_desc = [ + ByteField("ieiAPN", 0x0), + XByteField("lengthAPN", None), + ByteField("apName", 0x0), + # optional + ByteField("apName1", None), + ByteField("apName2", None), + ByteField("apName3", None), + ByteField("apName4", None), + ByteField("apName5", None), + ByteField("apName6", None), + ByteField("apName7", None), + ByteField("apName8", None), + ByteField("apName9", None), + ByteField("apName10", None), + ByteField("apName11", None), + ByteField("apName12", None), + ByteField("apName13", None), + ByteField("apName14", None), + ByteField("apName15", None), + ByteField("apName16", None), + ByteField("apName17", None), + ByteField("apName18", None), + ByteField("apName19", None), + ByteField("apName20", None), + ByteField("apName21", None), + ByteField("apName22", None), + ByteField("apName23", None), + ByteField("apName24", None), + ByteField("apName25", None), + ByteField("apName26", None), + ByteField("apName27", None), + ByteField("apName28", None), + ByteField("apName29", None), + ByteField("apName30", None), + ByteField("apName31", None), + ByteField("apName32", None), + ByteField("apName33", None), + ByteField("apName34", None), + ByteField("apName35", None), + ByteField("apName36", None), + ByteField("apName37", None), + ByteField("apName38", None), + ByteField("apName39", None), + ByteField("apName40", None), + ByteField("apName41", None), + ByteField("apName42", None), + ByteField("apName43", None), + ByteField("apName44", None), + ByteField("apName45", None), + ByteField("apName46", None), + ByteField("apName47", None), + ByteField("apName48", None), + ByteField("apName49", None), + ByteField("apName50", None), + ByteField("apName51", None), + ByteField("apName52", None), + ByteField("apName53", None), + ByteField("apName54", None), + ByteField("apName55", None), + ByteField("apName56", None), + ByteField("apName57", None), + ByteField("apName58", None), + ByteField("apName59", None), + ByteField("apName60", None), + ByteField("apName61", None), + ByteField("apName62", None), + ByteField("apName63", None), + ByteField("apName64", None), + ByteField("apName65", None), + ByteField("apName66", None), + ByteField("apName67", None), + ByteField("apName68", None), + ByteField("apName69", None), + ByteField("apName70", None), + ByteField("apName71", None), + ByteField("apName72", None), + ByteField("apName73", None), + ByteField("apName74", None), + ByteField("apName75", None), + ByteField("apName76", None), + ByteField("apName77", None), + ByteField("apName78", None), + ByteField("apName79", None), + ByteField("apName80", None), + ByteField("apName81", None), + ByteField("apName82", None), + ByteField("apName83", None), + ByteField("apName84", None), + ByteField("apName85", None), + ByteField("apName86", None), + ByteField("apName87", None), + ByteField("apName88", None), + ByteField("apName89", None), + ByteField("apName90", None), + ByteField("apName91", None), + ByteField("apName92", None), + ByteField("apName93", None), + ByteField("apName94", None), + ByteField("apName95", None), + ByteField("apName96", None), + ByteField("apName97", None), + ByteField("apName98", None), + ByteField("apName99", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 102, a, self.fields_desc) + if self.lengthAPN is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class NetworkServiceAccessPointIdentifier(Packet): + """Network service access point identifier Section 10.5.6.2""" + name = "Network Service Access Point Identifier" + fields_desc = [ + ByteField("ieiNSAPI", 0x0), + BitField("spare", 0x0, 4), + BitField("nsapiVal", 0x0, 4) + ] + + +# length 2 to 253 +class ProtocolConfigurationOptions(Packet): + """Protocol configuration options Section 10.5.6.3""" + name = "Protocol Configuration Options" + fields_desc = [ + ByteField("ieiPCO", 0x0), + + XByteField("lengthPCO", None), + # optional + BitField("ext", None, 1), + BitField("spare", None, 4), + BitField("configProto", None, 3), + + ByteField("protoId1", None), + ByteField("lenProto1", None), + ByteField("proto1Content", None), + + ByteField("protoId2", None), + ByteField("lenProto2", None), + ByteField("proto2Content", None), + + ByteField("protoId3", None), + ByteField("lenProto3", None), + ByteField("proto3Content", None), + + ByteField("protoId4", None), + ByteField("lenProto4", None), + ByteField("proto4Content", None), + + + ByteField("protoId5", None), + ByteField("lenProto5", None), + ByteField("proto5Content", None), + + ByteField("protoId6", None), + ByteField("lenProto6", None), + ByteField("proto6Content", None), + + ByteField("protoId7", None), + ByteField("lenProto7", None), + ByteField("proto7Content", None), + + ByteField("protoId8", None), + ByteField("lenProto8", None), + ByteField("proto8Content", None), + + ByteField("protoId9", None), + ByteField("lenProto9", None), + ByteField("proto9Content", None), + + ByteField("protoId10", None), + ByteField("lenProto10", None), + ByteField("proto10Content", None), + + ByteField("protoId11", None), + ByteField("lenProto11", None), + ByteField("proto11Content", None), + + ByteField("protoId12", None), + ByteField("lenProto12", None), + ByteField("proto12Content", None), + + ByteField("protoId13", None), + ByteField("lenProto13", None), + ByteField("proto13Content", None), + + ByteField("protoId14", None), + ByteField("lenProto14", None), + ByteField("proto14Content", None), + + ByteField("protoId15", None), + ByteField("lenProto15", None), + ByteField("proto15Content", None), + + ByteField("protoId16", None), + ByteField("lenProto16", None), + ByteField("proto16Content", None), + + ByteField("protoId17", None), + ByteField("lenProto17", None), + ByteField("proto17Content", None), + + ByteField("protoId18", None), + ByteField("lenProto18", None), + ByteField("proto18Content", None), + + ByteField("protoId19", None), + ByteField("lenProto19", None), + ByteField("proto19Content", None), + + ByteField("protoId20", None), + ByteField("lenProto20", None), + ByteField("proto20Content", None), + + ByteField("protoId21", None), + ByteField("lenProto21", None), + ByteField("proto21Content", None), + + ByteField("protoId22", None), + ByteField("lenProto22", None), + ByteField("proto22Content", None), + + ByteField("protoId23", None), + ByteField("lenProto23", None), + ByteField("proto23Content", None), + + ByteField("protoId24", None), + ByteField("lenProto24", None), + ByteField("proto24Content", None), + + ByteField("protoId25", None), + ByteField("lenProto25", None), + ByteField("proto25Content", None), + + ByteField("protoId26", None), + ByteField("lenProto26", None), + ByteField("proto26Content", None), + + ByteField("protoId27", None), + ByteField("lenProto27", None), + ByteField("proto27Content", None), + + ByteField("protoId28", None), + ByteField("lenProto28", None), + ByteField("proto28Content", None), + + ByteField("protoId29", None), + ByteField("lenProto29", None), + ByteField("proto29Content", None), + + ByteField("protoId30", None), + ByteField("lenProto30", None), + ByteField("proto30Content", None), + + ByteField("protoId31", None), + ByteField("lenProto31", None), + ByteField("proto31Content", None), + + ByteField("protoId32", None), + ByteField("lenProto32", None), + ByteField("proto32Content", None), + + ByteField("protoId33", None), + ByteField("lenProto33", None), + ByteField("proto33Content", None), + + ByteField("protoId34", None), + ByteField("lenProto34", None), + ByteField("proto34Content", None), + + ByteField("protoId35", None), + ByteField("lenProto35", None), + ByteField("proto35Content", None), + + ByteField("protoId36", None), + ByteField("lenProto36", None), + ByteField("proto36Content", None), + + ByteField("protoId37", None), + ByteField("lenProto37", None), + ByteField("proto37Content", None), + + ByteField("protoId38", None), + ByteField("lenProto38", None), + ByteField("proto38Content", None), + + ByteField("protoId39", None), + ByteField("lenProto39", None), + ByteField("proto39Content", None), + + ByteField("protoId40", None), + ByteField("lenProto40", None), + ByteField("proto40Content", None), + + ByteField("protoId41", None), + ByteField("lenProto41", None), + ByteField("proto41Content", None), + + ByteField("protoId42", None), + ByteField("lenProto42", None), + ByteField("proto42Content", None), + + ByteField("protoId43", None), + ByteField("lenProto43", None), + ByteField("proto43Content", None), + + ByteField("protoId44", None), + ByteField("lenProto44", None), + ByteField("proto44Content", None), + + ByteField("protoId45", None), + ByteField("lenProto45", None), + ByteField("proto45Content", None), + + ByteField("protoId46", None), + ByteField("lenProto46", None), + ByteField("proto46Content", None), + + ByteField("protoId47", None), + ByteField("lenProto47", None), + ByteField("proto47Content", None), + + ByteField("protoId48", None), + ByteField("lenProto48", None), + ByteField("proto48Content", None), + + ByteField("protoId49", None), + ByteField("lenProto49", None), + ByteField("proto49Content", None), + + ByteField("protoId50", None), + ByteField("lenProto50", None), + ByteField("proto50Content", None), + + ByteField("protoId51", None), + ByteField("lenProto51", None), + ByteField("proto51Content", None), + + ByteField("protoId52", None), + ByteField("lenProto52", None), + ByteField("proto52Content", None), + + ByteField("protoId53", None), + ByteField("lenProto53", None), + ByteField("proto53Content", None), + + ByteField("protoId54", None), + ByteField("lenProto54", None), + ByteField("proto54Content", None), + + ByteField("protoId55", None), + ByteField("lenProto55", None), + ByteField("proto55Content", None), + + ByteField("protoId56", None), + ByteField("lenProto56", None), + ByteField("proto56Content", None), + + ByteField("protoId57", None), + ByteField("lenProto57", None), + ByteField("proto57Content", None), + + ByteField("protoId58", None), + ByteField("lenProto58", None), + ByteField("proto58Content", None), + + ByteField("protoId59", None), + ByteField("lenProto59", None), + ByteField("proto59Content", None), + + ByteField("protoId60", None), + ByteField("lenProto60", None), + ByteField("proto60Content", None), + + ByteField("protoId61", None), + ByteField("lenProto61", None), + ByteField("proto61Content", None), + + ByteField("protoId62", None), + ByteField("lenProto62", None), + ByteField("proto62Content", None), + + ByteField("protoId63", None), + ByteField("lenProto63", None), + ByteField("proto63Content", None), + + ByteField("protoId64", None), + ByteField("lenProto64", None), + ByteField("proto64Content", None), + + ByteField("protoId65", None), + ByteField("lenProto65", None), + ByteField("proto65Content", None), + + ByteField("protoId66", None), + ByteField("lenProto66", None), + ByteField("proto66Content", None), + + ByteField("protoId67", None), + ByteField("lenProto67", None), + ByteField("proto67Content", None), + + ByteField("protoId68", None), + ByteField("lenProto68", None), + ByteField("proto68Content", None), + + ByteField("protoId69", None), + ByteField("lenProto69", None), + ByteField("proto69Content", None), + + ByteField("protoId70", None), + ByteField("lenProto70", None), + ByteField("proto70Content", None), + + ByteField("protoId71", None), + ByteField("lenProto71", None), + ByteField("proto71Content", None), + + ByteField("protoId72", None), + ByteField("lenProto72", None), + ByteField("proto72Content", None), + + ByteField("protoId73", None), + ByteField("lenProto73", None), + ByteField("proto73Content", None), + + ByteField("protoId74", None), + ByteField("lenProto74", None), + ByteField("proto74Content", None), + + ByteField("protoId75", None), + ByteField("lenProto75", None), + ByteField("proto75Content", None), + + ByteField("protoId76", None), + ByteField("lenProto76", None), + ByteField("proto76Content", None), + + ByteField("protoId77", None), + ByteField("lenProto77", None), + ByteField("proto77Content", None), + + ByteField("protoId78", None), + ByteField("lenProto78", None), + ByteField("proto78Content", None), + + ByteField("protoId79", None), + ByteField("lenProto79", None), + ByteField("proto79Content", None), + + ByteField("protoId80", None), + ByteField("lenProto80", None), + ByteField("proto80Content", None), + + ByteField("protoId81", None), + ByteField("lenProto81", None), + ByteField("proto81Content", None), + + ByteField("protoId82", None), + ByteField("lenProto82", None), + ByteField("proto82Content", None), + + ByteField("protoId83", None), + ByteField("lenProto83", None), + ByteField("proto83Content", None), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 253, a, self.fields_desc) + if self.lengthPCO is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 4 to 20 +class PacketDataProtocolAddress(Packet): + """Packet data protocol address Section 10.5.6.4""" + name = "Packet Data Protocol Address" + fields_desc = [ + ByteField("ieiPDPA", 0x0), + + XByteField("lengthPDPA", None), + + BitField("spare", 0x0, 4), + BitField("pdpTypeOrga", 0x0, 4), + + ByteField("pdpTypeNb", 0x0), + # optional + ByteField("addressInfo1", None), + ByteField("addressInfo2", None), + ByteField("addressInfo3", None), + ByteField("addressInfo4", None), + ByteField("addressInfo5", None), + ByteField("addressInfo6", None), + ByteField("addressInfo7", None), + ByteField("addressInfo8", None), + ByteField("addressInfo9", None), + ByteField("addressInfo10", None), + ByteField("addressInfo11", None), + ByteField("addressInfo12", None), + ByteField("addressInfo13", None), + ByteField("addressInfo14", None), + ByteField("addressInfo15", None), + ByteField("addressInfo16", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 20, a, self.fields_desc) + if self.lengthPDPA is None: + p = p[:1] + struct.pack(">B", res[1]) + p[2:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class QualityOfService(Packet): + """Quality of service Section 10.5.6.5""" + name = "Quality of Service" + fields_desc = [ + ByteField("ieiQOS", 0x0), + XByteField("lengthQOS", 0x5), + + BitField("spare", 0x0, 2), + BitField("delayClass", 0x0, 3), + BitField("reliaClass", 0x0, 3), + + BitField("peak", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("precedenceCl", 0x0, 3), + + BitField("spare", 0x0, 3), + BitField("mean", 0x0, 5) + ] + + +class SmCause(Packet): + """SM cause Section 10.5.6.6""" + name = "SM Cause" + fields_desc = [ + ByteField("ieiSC", 0x0), + ByteField("causeVal", 0x0) + ] + +# 10.5.6.7 Spare +# This is intentionally left spare. + + +class AaDeactivationCause(Packet): + """AA deactivation cause Section 10.5.6.8""" + name = "AA Deactivation Cause" + fields_desc = [ + XBitField("ieiADC", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("aaVal", 0x0, 3) + ] + + +# Fix 1/2 len problem +class AaDeactivationCauseAndSpareHalfOctets(Packet): + name = "AA Deactivation Cause and Spare Half Octets" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("aaVal", 0x0, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class LlcServiceAccessPointIdentifier(Packet): + """LLC service access point identifier Section 10.5.6.9""" + name = "LLC Service Access Point Identifier" + fields_desc = [ + ByteField("ieiLSAPI", None), + BitField("spare", 0x0, 4), + BitField("llcVal", 0x0, 4) + ] + + +# +# 10.5.7 GPRS Common information elements +# + +# 10.5.7.1 [Spare] + +class RadioPriority(Packet): + """Radio priority Section 10.5.7.2""" + name = "Radio Priority" + fields_desc = [ + XBitField("ieiRP", 0x0, 4), + BitField("spare", 0x1, 1), + BitField("rplv", 0x0, 3) + ] + + +# Fix 1/2 len problem +class RadioPriorityAndSpareHalfOctets(Packet): + name = "Radio Priority and Spare Half Octets" + fields_desc = [ + BitField("spare", 0x1, 1), + BitField("rplv", 0x0, 3), + BitField("spareHalfOctets", 0x0, 4) + ] + + +class GprsTimer(Packet): + """GPRS Timer Section 10.5.7.3""" + name = "GPRS Timer" + fields_desc = [ + ByteField("ieiGT", 0x0), + BitField("unit", 0x0, 3), + BitField("timerVal", 0x0, 5) + ] + + +class CellIdentity(Packet): + """ Cell identity Section 10.5.1.1 """ + name = "Cell Identity" + fields_desc = [ + ByteField("ciValue1", 0x0), + ByteField("ciValue2", 0x0) + ] + + +class CiphKeySeqNr(Packet): + """ Ciphering Key Sequence Number Section 10.5.1.2 """ + name = "Cipher Key Sequence Number" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("keySeq", 0x0, 3) + ] + + +class LocalAreaId(Packet): + """ Local Area Identification Section 10.5.1.3 """ + name = "Location Area Identification" + fields_desc = [ + BitField("mccDigit2", 0x0, 4), + BitField("mccDigit1", 0x0, 4), + BitField("mncDigit3", 0x0, 4), + BitField("mccDigit3", 0x0, 4), + BitField("mncDigit2", 0x0, 4), + BitField("mncDigit1", 0x0, 4), + ByteField("lac1", 0x0), + ByteField("lac2", 0x0) + ] +# +# The Mobile Identity is a type 4 information element with a minimum +# length of 3 octet and 11 octets length maximal. +# + + +# len 3 - 11 +class MobileId(Packet): + """ Mobile Identity Section 10.5.1.4 """ + name = "Mobile Identity" + fields_desc = [ + XByteField("lengthMI", None), + BitField("idDigit1", 0x0, 4), + BitField("oddEven", 0x0, 1), + BitField("typeOfId", 0x0, 3), + + BitField("idDigit2_1", None, 4), # optional + BitField("idDigit2", None, 4), + BitField("idDigit3_1", None, 4), + BitField("idDigit3", None, 4), + BitField("idDigit4_1", None, 4), + BitField("idDigit4", None, 4), + BitField("idDigit5_1", None, 4), + BitField("idDigit5", None, 4), + BitField("idDigit6_1", None, 4), + BitField("idDigit6", None, 4), + BitField("idDigit7_1", None, 4), + BitField("idDigit7", None, 4), + BitField("idDigit8_1", None, 4), + BitField("idDigit8", None, 4), + BitField("idDigit9_1", None, 4), + BitField("idDigit9", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 10, a, self.fields_desc, 1) + if self.lengthMI is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class MobileStationClassmark1(Packet): + """ Mobile Station Classmark 1 Section 10.5.1.5 """ + name = "Mobile Station Classmark 1" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("revisionLvl", 0x0, 2), + BitField("esInd", 0x0, 1), + BitField("a51", 0x0, 1), + BitField("rfPowerCap", 0x0, 3) + ] + + +class MobileStationClassmark2(Packet): + """ Mobile Station Classmark 2 Section 10.5.1.6 """ + name = "Mobile Station Classmark 2" + fields_desc = [ + XByteField("lengthMSC2", 0x3), + BitField("spare", 0x0, 1), + BitField("revisionLvl", 0x0, 2), + BitField("esInd", 0x0, 1), + BitField("a51", 0x0, 1), + BitField("rfPowerCap", 0x0, 3), + BitField("spare1", 0x0, 1), + BitField("psCap", 0x0, 1), + BitField("ssScreenInd", 0x0, 2), + BitField("smCaPabi", 0x0, 1), + BitField("vbs", 0x0, 1), + BitField("vgcs", 0x0, 1), + BitField("fc", 0x0, 1), + BitField("cm3", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("lcsvaCap", 0x0, 1), + BitField("spare3", 0x0, 1), + BitField("soLsa", 0x0, 1), + BitField("cmsp", 0x0, 1), + BitField("a53", 0x0, 1), + BitField("a52", 0x0, 1) + ] + + +class DescriptiveGroupOrBroadcastCallReference(Packet): + """ Descriptive group or broadcast call reference Section 10.5.1.9 """ + name = "Descriptive Group or Broadcast Call Reference" + fields_desc = [ + BitField("binCallRef", 0x0, 27), + BitField("sf", 0x0, 1), + BitField("fa", 0x0, 1), + BitField("callPrio", 0x0, 3), + BitField("cipherInfo", 0x0, 4), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("spare3", 0x0, 1), + BitField("spare4", 0x0, 1) + ] + + +class PdAndSapi(Packet): + """ PD and SAPI $(CCBS)$ Section 10.5.1.10a """ + name = "PD and SAPI $(CCBS)$" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("sapi", 0x0, 2), + BitField("pd", 0x0, 4) + ] + + +class PriorityLevel(Packet): + """ Priority Level Section 10.5.1.11 """ + name = "Priority Level" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("callPrio", 0x0, 3) + ] + +# +# Radio Resource management information elements +# + + +# len 6 to max for L3 message (251) +class BaRange(Packet): + """ BA Range Section 10.5.2.1a """ + name = "BA Range" + fields_desc = [ + + XByteField("lengthBR", None), +#error: byte format requires -128 <= number <= 127 + ByteField("nrOfRanges", 0x0), +# # rX = range X +# # L o = Lower H i = higher +# # H p = high Part Lp = low Part + ByteField("r1LoHp", 0x0), + + BitField("r1LoLp", 0x0, 3), + BitField("r1HiHp", 0x0, 5), + + BitField("r1HiLp", 0x0, 4), + BitField("r2LoHp", 0x0, 4), + # optional + BitField("r2LoLp", None, 5), + BitField("r2HiHp", None, 3), + + ByteField("r2HiLp", None), + ByteField("r3LoHp", None), + + BitField("r3LoLp", None, 5), + BitField("r3HiHp", None, 3), + + ByteField("r3HiLp", None), + ByteField("r4LoHp", None), + + BitField("r4LoLp", None, 5), + BitField("r4HiHp", None, 3), + ByteField("r4HiLp", None), + ByteField("r5LoHp", None), + + BitField("r5LoLp", None, 5), + BitField("r5HiHp", None, 3), + ByteField("r5HiLp", None), + ByteField("r6LoHp", None), + + BitField("r6LoLp", None, 5), + BitField("r6HiHp", None, 3), + ByteField("r6HiLp", None), + ByteField("r7LoHp", None), + + BitField("r7LoLp", None, 5), + BitField("r7HiHp", None, 3), + ByteField("r7HiLp", None), + ByteField("r8LoHp", None), + + BitField("r8LoLp", None, 5), + BitField("r8HiHp", None, 3), + ByteField("r8HiLp", None), + ByteField("r9LoHp", None), + + BitField("r9LoLp", None, 5), + BitField("r9HiHp", None, 3), + ByteField("r9HiLp", None), + ByteField("r10LoHp", None), + + BitField("r10LoLp", None, 5), + BitField("r10HiHp", None, 3), + ByteField("r10HiLp", None), + ByteField("r11LoHp", None), + + BitField("r11LoLp", None, 5), + BitField("r11HiHp", None, 3), + ByteField("r11HiLp", None), + ByteField("r12LoHp", None), + + BitField("r12LoLp", None, 5), + BitField("r12HiHp", None, 3), + ByteField("r12HiLp", None), + ByteField("r13LoHp", None), + + BitField("r13LoLp", None, 5), + BitField("r13HiHp", None, 3), + ByteField("r13HiLp", None), + ByteField("r14LoHp", None), + + BitField("r14LoLp", None, 5), + BitField("r14HiHp", None, 3), + ByteField("r14HiLp", None), + ByteField("r15LoHp", None), + + BitField("r15LoLp", None, 5), + BitField("r15HiHp", None, 3), + ByteField("r15HiLp", None), + ByteField("r16LoHp", None), + + BitField("r16LoLp", None, 5), + BitField("r16HiHp", None, 3), + ByteField("r16HiLp", None), + ByteField("r17LoHp", None), + + BitField("r17LoLp", None, 5), + BitField("r17HiHp", None, 3), + ByteField("r17HiLp", None), + ByteField("r18LoHp", None), + + BitField("r18LoLp", None, 5), + BitField("r18HiHp", None, 3), + ByteField("r18HiLp", None), + ByteField("r19LoHp", None), + + BitField("r19LoLp", None, 5), + BitField("r19HiHp", None, 3), + ByteField("r19HiLp", None), + ByteField("r20LoHp", None), + + BitField("r20LoLp", None, 5), + BitField("r20HiHp", None, 3), + ByteField("r20HiLp", None), + ByteField("r21LoHp", None), + + BitField("r21LoLp", None, 5), + BitField("r21HiHp", None, 3), + ByteField("r21HiLp", None), + ByteField("r22LoHp", None), + + BitField("r22LoLp", None, 5), + BitField("r22HiHp", None, 3), + ByteField("r22HiLp", None), + ByteField("r23LoHp", None), + + BitField("r23LoLp", None, 5), + BitField("r23HiHp", None, 3), + ByteField("r23HiLp", None), + ByteField("r24LoHp", None), + + BitField("r24LoLp", None, 5), + BitField("r24HiHp", None, 3), + ByteField("r24HiLp", None), + ByteField("r25LoHp", None), + + BitField("r25LoLp", None, 5), + BitField("r25HiHp", None, 3), + ByteField("r25HiLp", None), + ByteField("r26LoHp", None), + + BitField("r26LoLp", None, 5), + BitField("r26HiHp", None, 3), + ByteField("r26HiLp", None), + ByteField("r27LoHp", None), + + BitField("r27LoLp", None, 5), + BitField("r27HiHp", None, 3), + ByteField("r27HiLp", None), + ByteField("r28LoHp", None), + + BitField("r28LoLp", None, 5), + BitField("r28HiHp", None, 3), + ByteField("r28HiLp", None), + ByteField("r29LoHp", None), + + BitField("r29LoLp", None, 5), + BitField("r29HiHp", None, 3), + ByteField("r29HiLp", None), + ByteField("r30LoHp", None), + + BitField("r30LoLp", None, 5), + BitField("r30HiHp", None, 3), + ByteField("r30HiLp", None), + ByteField("r31LoHp", None), + + BitField("r31LoLp", None, 5), + BitField("r31HiHp", None, 3), + ByteField("r31HiLp", None), + ByteField("r32LoHp", None), + + BitField("r32LoLp", None, 5), + BitField("r32HiHp", None, 3), + ByteField("r32HiLp", None), + ByteField("r33LoHp", None), + + BitField("r33LoLp", None, 5), + BitField("r33HiHp", None, 3), + ByteField("r33HiLp", None), + ByteField("r34LoHp", None), + + BitField("r34LoLp", None, 5), + BitField("r34HiHp", None, 3), + ByteField("r34HiLp", None), + ByteField("r35LoHp", None), + + BitField("r35LoLp", None, 5), + BitField("r35HiHp", None, 3), + ByteField("r35HiLp", None), + ByteField("r36LoHp", None), + + BitField("r36LoLp", None, 5), + BitField("r36HiHp", None, 3), + ByteField("r36HiLp", None), + ByteField("r37LoHp", None), + + BitField("r37LoLp", None, 5), + BitField("r37HiHp", None, 3), + ByteField("r37HiLp", None), + ByteField("r38LoHp", None), + + BitField("r38LoLp", None, 5), + BitField("r38HiHp", None, 3), + ByteField("r38HiLp", None), + ByteField("r39LoHp", None), + + BitField("r39LoLp", None, 5), + BitField("r39HiHp", None, 3), + ByteField("r39HiLp", None), + ByteField("r40LoHp", None), + + BitField("r40LoLp", None, 5), + BitField("r40HiHp", None, 3), + ByteField("r40HiLp", None), + ByteField("r41LoHp", None), + + BitField("r41LoLp", None, 5), + BitField("r41HiHp", None, 3), + ByteField("r41HiLp", None), + ByteField("r42LoHp", None), + + BitField("r42LoLp", None, 5), + BitField("r42HiHp", None, 3), + ByteField("r42HiLp", None), + ByteField("r43LoHp", None), + + BitField("r43LoLp", None, 5), + BitField("r43HiHp", None, 3), + ByteField("r43HiLp", None), + ByteField("r44LoHp", None), + + BitField("r44LoLp", None, 5), + BitField("r44HiHp", None, 3), + ByteField("r44HiLp", None), + ByteField("r45LoHp", None), + + BitField("r45LoLp", None, 5), + BitField("r45HiHp", None, 3), + ByteField("r45HiLp", None), + ByteField("r46LoHp", None), + + BitField("r46LoLp", None, 5), + BitField("r46HiHp", None, 3), + ByteField("r46HiLp", None), + ByteField("r47LoHp", None), + + BitField("r47LoLp", None, 5), + BitField("r47HiHp", None, 3), + ByteField("r47HiLp", None), + ByteField("r48LoHp", None), + + BitField("r48LoLp", None, 5), + BitField("r48HiHp", None, 3), + ByteField("r48HiLp", None), + ByteField("r49LoHp", None), + + BitField("r49LoLp", None, 5), + BitField("r49HiHp", None, 3), + ByteField("r49HiLp", None), + ByteField("r50LoHp", None), + + BitField("r50LoLp", None, 5), + BitField("r50HiHp", None, 3), + ByteField("r50HiLp", None), + ByteField("r51LoHp", None), + + BitField("r51LoLp", None, 5), + BitField("r51HiHp", None, 3), + ByteField("r51HiLp", None), + ByteField("r52LoHp", None), + + BitField("r52LoLp", None, 5), + BitField("r52HiHp", None, 3), + ByteField("r52HiLp", None), + ByteField("r53LoHp", None), + + BitField("r53LoLp", None, 5), + BitField("r53HiHp", None, 3), + ByteField("r53HiLp", None), + ByteField("r54LoHp", None), + + BitField("r54LoLp", None, 5), + BitField("r54HiHp", None, 3), + ByteField("r54HiLp", None), + ByteField("r55LoHp", None), + + BitField("r55LoLp", None, 5), + BitField("r55HiHp", None, 3), + ByteField("r55HiLp", None), + ByteField("r56LoHp", None), + + BitField("r56LoLp", None, 5), + BitField("r56HiHp", None, 3), + ByteField("r56HiLp", None), + ByteField("r57LoHp", None), + + BitField("r57LoLp", None, 5), + BitField("r57HiHp", None, 3), + ByteField("r57HiLp", None), + ByteField("r58LoHp", None), + + BitField("r58LoLp", None, 5), + BitField("r58HiHp", None, 3), + ByteField("r58HiLp", None), + ByteField("r59LoHp", None), + + BitField("r59LoLp", None, 5), + BitField("r59HiHp", None, 3), + ByteField("r59HiLp", None), + ByteField("r60LoHp", None), + + BitField("r60LoLp", None, 5), + BitField("r60HiHp", None, 3), + ByteField("r60HiLp", None), + ByteField("r61LoHp", None), + + BitField("r61LoLp", None, 5), + BitField("r61HiHp", None, 3), + ByteField("r61HiLp", None), + ByteField("r62LoHp", None), + + BitField("r62LoLp", None, 5), + BitField("r62HiHp", None, 3), + ByteField("r62HiLp", None), + ByteField("r63LoHp", None), + + BitField("r63LoLp", None, 5), + BitField("r63HiHp", None, 3), + ByteField("r63HiLp", None), + ByteField("r64LoHp", None), + + BitField("r64LoLp", None, 5), + BitField("r64HiHp", None, 3), + ByteField("r64HiLp", None), + ByteField("r65LoHp", None), + + BitField("r65LoLp", None, 5), + BitField("r65HiHp", None, 3), + ByteField("r65HiLp", None), + ByteField("r66LoHp", None), + + BitField("r66LoLp", None, 5), + BitField("r66HiHp", None, 3), + ByteField("r66HiLp", None), + ByteField("r67LoHp", None), + + BitField("r67LoLp", None, 5), + BitField("r67HiHp", None, 3), + ByteField("r67HiLp", None), + ByteField("r68LoHp", None), + + BitField("r68LoLp", None, 5), + BitField("r68HiHp", None, 3), + ByteField("r68HiLp", None), + ByteField("r69LoHp", None), + + BitField("r69LoLp", None, 5), + BitField("r69HiHp", None, 3), + ByteField("r69HiLp", None), + ByteField("r70LoHp", None), + + BitField("r70LoLp", None, 5), + BitField("r70HiHp", None, 3), + ByteField("r70HiLp", None), + ByteField("r71LoHp", None), + + BitField("r71LoLp", None, 5), + BitField("r71HiHp", None, 3), + ByteField("r71HiLp", None), + ByteField("r72LoHp", None), + + BitField("r72LoLp", None, 5), + BitField("r72HiHp", None, 3), + ByteField("r72HiLp", None), + ByteField("r73LoHp", None), + + BitField("r73LoLp", None, 5), + BitField("r73HiHp", None, 3), + ByteField("r73HiLp", None), + ByteField("r74LoHp", None), + + BitField("r74LoLp", None, 5), + BitField("r74HiHp", None, 3), + ByteField("r74HiLp", None), + ByteField("r75LoHp", None), + + BitField("r75LoLp", None, 5), + BitField("r75HiHp", None, 3), + ByteField("r75HiLp", None), + ByteField("r76LoHp", None), + + BitField("r76LoLp", None, 5), + BitField("r76HiHp", None, 3), + ByteField("r76HiLp", None), + ByteField("r77LoHp", None), + + BitField("r77LoLp", None, 5), + BitField("r77HiHp", None, 3), + ByteField("r77HiLp", None), + ByteField("r78LoHp", None), + + BitField("r78LoLp", None, 5), + BitField("r78HiHp", None, 3), + ByteField("r78HiLp", None), + ByteField("r79LoHp", None), + + BitField("r79LoLp", None, 5), + BitField("r79HiHp", None, 3), + ByteField("r79HiLp", None), + ByteField("r80LoHp", None), + + BitField("r80LoLp", None, 5), + BitField("r80HiHp", None, 3), + ByteField("r80HiLp", None), + ByteField("r81LoHp", None), + + BitField("r81LoLp", None, 5), + BitField("r81HiHp", None, 3), + ByteField("r81HiLp", None), + ByteField("r82LoHp", None), + + BitField("r82LoLp", None, 5), + BitField("r82HiHp", None, 3), + ByteField("r82HiLp", None), + ByteField("r83LoHp", None), + + BitField("r83LoLp", None, 5), + BitField("r83HiHp", None, 3), + ByteField("r83HiLp", None), + ByteField("r84LoHp", None), + + BitField("r84LoLp", None, 5), + BitField("r84HiHp", None, 3), + ByteField("r84HiLp", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(5, 253, a, self.fields_desc, 1) + if self.lengthBR is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 3 to max for L3 message (251) +class BaListPref(Packet): + """ BA List Pref Section 10.5.2.1c """ + name = "BA List Pref" + fields_desc = [ + XByteField("lengthBLP", None), + + BitField("fixBit", 0x0, 1), + BitField("rangeLower", 0x0, 10), + BitField("fixBit2", 0x0, 1), + BitField("rangeUpper", 0x0, 10), + BitField("baFreq", 0x0, 10), + BitField("sparePad", 0x0, 8) + ] + + +# len 17 || Have a look at the specs for the field format +# Bit map 0 format +# Range 1024 format +# Range 512 format +# Range 256 format +# Range 128 format +# Variable bit map format +class CellChannelDescription(Packet): + """ Cell Channel Description Section 10.5.2.1b """ + name = "Cell Channel Description " + fields_desc = [ + BitField("bit128", 0x0, 1), + BitField("bit127", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + ByteField("bit120", 0x0), + ByteField("bit112", 0x0), + ByteField("bit104", 0x0), + ByteField("bit96", 0x0), + ByteField("bit88", 0x0), + ByteField("bit80", 0x0), + ByteField("bit72", 0x0), + ByteField("bit64", 0x0), + ByteField("bit56", 0x0), + ByteField("bit48", 0x0), + ByteField("bit40", 0x0), + ByteField("bit32", 0x0), + ByteField("bit24", 0x0), + ByteField("bit16", 0x0), + ByteField("bit8", 0x0) + ] + + +class CellDescription(Packet): + """ Cell Description Section 10.5.2.2 """ + name = "Cell Description" + fields_desc = [ + BitField("bcchHigh", 0x0, 2), + BitField("ncc", 0x0, 3), + BitField("bcc", 0x0, 3), + ByteField("bcchLow", 0x0) + ] + + +class CellOptionsBCCH(Packet): + """ Cell Options (BCCH) Section 10.5.2.3 """ + name = "Cell Options (BCCH)" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("pwrc", 0x0, 1), + BitField("dtx", 0x0, 2), + BitField("rLinkTout", 0x0, 4) + ] + + +class CellOptionsSACCH(Packet): + """ Cell Options (SACCH) Section 10.5.2.3a """ + name = "Cell Options (SACCH)" + fields_desc = [ + BitField("dtx", 0x0, 1), + BitField("pwrc", 0x0, 1), + BitField("dtx", 0x0, 1), + BitField("rLinkTout", 0x0, 4) + ] + + +class CellSelectionParameters(Packet): + """ Cell Selection Parameters Section 10.5.2.4 """ + name = "Cell Selection Parameters" + fields_desc = [ + BitField("cellReselect", 0x0, 3), + BitField("msTxPwrMax", 0x0, 5), + BitField("acs", None, 1), + BitField("neci", None, 1), + BitField("rxlenAccMin", None, 6) + ] + + +class MacModeAndChannelCodingRequest(Packet): + """ MAC Mode and Channel Coding Requested Section 10.5.2.4a """ + name = "MAC Mode and Channel Coding Requested" + fields_desc = [ + BitField("macMode", 0x0, 2), + BitField("cs", 0x0, 2) + ] + + +class ChannelDescription(Packet): + """ Channel Description Section 10.5.2.5 """ + name = "Channel Description" + fields_desc = [ + + BitField("channelTyp", 0x0, 5), + BitField("tn", 0x0, 3), + + BitField("tsc", 0x0, 3), + BitField("h", 0x1, 1), + BitField("maioHi", 0x0, 4), + + BitField("maioLo", 0x0, 2), + BitField("hsn", 0x0, 6) + ] + + +class ChannelDescription2(Packet): + """ Channel Description 2 Section 10.5.2.5a """ + name = "Channel Description 2" + fields_desc = [ + BitField("channelTyp", 0x0, 5), + BitField("tn", 0x0, 3), + BitField("tsc", 0x0, 3), + BitField("h", 0x0, 1), + # if h=1 + # BitField("maioHi", 0x0, 4), + # BitField("maioLo", 0x0, 2), + # BitField("hsn", 0x0, 6) + BitField("spare", 0x0, 2), + BitField("arfcnHigh", 0x0, 2), + ByteField("arfcnLow", 0x0) + ] + + +class ChannelMode(Packet): + """ Channel Mode Section 10.5.2.6 """ + name = "Channel Mode" + fields_desc = [ + ByteField("mode", 0x0) + ] + + +class ChannelMode2(Packet): + """ Channel Mode 2 Section 10.5.2.7 """ + name = "Channel Mode 2" + fields_desc = [ + ByteField("mode", 0x0) + ] + + +class ChannelNeeded(Packet): + """ Channel Needed Section 10.5.2.8 """ + name = "Channel Needed" + fields_desc = [ + BitField("channel2", 0x0, 2), + BitField("channel1", 0x0, 2), + ] + + +class ChannelRequestDescription(Packet): + """Channel Request Description Section 10.5.2.8a """ + name = "Channel Request Description" + fields_desc = [ + BitField("mt", 0x0, 1), + ConditionalField(BitField("spare", 0x0, 39), + lambda pkt: pkt.mt == 0), + ConditionalField(BitField("spare", 0x0, 3), + lambda pkt: pkt.mt == 1), + ConditionalField(BitField("priority", 0x0, 2), + lambda pkt: pkt.mt == 1), + ConditionalField(BitField("rlcMode", 0x0, 1), + lambda pkt: pkt.mt == 1), + ConditionalField(BitField("llcFrame", 0x1, 1), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("reqBandMsb", 0x0), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("reqBandLsb", 0x0), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("rlcMsb", 0x0), + lambda pkt: pkt.mt == 1), + ConditionalField(ByteField("rlcLsb", 0x0), + lambda pkt: pkt.mt == 1) + ] + + +class CipherModeSetting(Packet): + """Cipher Mode Setting Section 10.5.2.9 """ + name = "Cipher Mode Setting" + fields_desc = [ + BitField("algoId", 0x0, 3), + BitField("sc", 0x0, 1), + ] + + +class CipherResponse(Packet): + """Cipher Response Section 10.5.2.10 """ + name = "Cipher Response" + fields_desc = [ + BitField("spare", 0x0, 3), + BitField("cr", 0x0, 1), + ] + + +class ControlChannelDescription(Packet): + """Control Channel Description Section 10.5.2.11 """ + name = "Control Channel Description" + fields_desc = [ + + BitField("spare", 0x0, 1), + BitField("att", 0x0, 1), + BitField("bsAgBlksRes", 0x0, 3), + BitField("ccchConf", 0x0, 3), + + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("spare3", 0x0, 1), + BitField("spare4", 0x0, 1), + BitField("bsPaMfrms", 0x0, 3), + + ByteField("t3212", 0x0) + ] + + +class FrequencyChannelSequence(Packet): + """Frequency Channel Sequence Section 10.5.2.12""" + name = "Frequency Channel Sequence" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("lowestArfcn", 0x0, 7), + BitField("skipArfcn01", 0x0, 4), + BitField("skipArfcn02", 0x0, 4), + BitField("skipArfcn03", 0x0, 4), + BitField("skipArfcn04", 0x0, 4), + BitField("skipArfcn05", 0x0, 4), + BitField("skipArfcn06", 0x0, 4), + BitField("skipArfcn07", 0x0, 4), + BitField("skipArfcn08", 0x0, 4), + BitField("skipArfcn09", 0x0, 4), + BitField("skipArfcn10", 0x0, 4), + BitField("skipArfcn11", 0x0, 4), + BitField("skipArfcn12", 0x0, 4), + BitField("skipArfcn13", 0x0, 4), + BitField("skipArfcn14", 0x0, 4), + BitField("skipArfcn15", 0x0, 4), + BitField("skipArfcn16", 0x0, 4) + ] + + +class FrequencyList(Packet): + """Frequency List Section 10.5.2.13""" + name = "Frequency List" + # Problem: + # There are several formats for the Frequency List information + # element, distinguished by the "format indicator" subfield. + # Some formats are frequency bit maps, the others use a special encoding + # scheme. + fields_desc = [ + XByteField("lengthFL", None), + + BitField("formatID", 0x0, 2), + BitField("spare", 0x0, 2), + BitField("arfcn124", 0x0, 1), + BitField("arfcn123", 0x0, 1), + BitField("arfcn122", 0x0, 1), + BitField("arfcn121", 0x0, 1), + + ByteField("arfcn120", 0x0), + ByteField("arfcn112", 0x0), + ByteField("arfcn104", 0x0), + ByteField("arfcn96", 0x0), + ByteField("arfcn88", 0x0), + ByteField("arfcn80", 0x0), + ByteField("arfcn72", 0x0), + ByteField("arfcn64", 0x0), + ByteField("arfcn56", 0x0), + ByteField("arfcn48", 0x0), + ByteField("arfcn40", 0x0), + ByteField("arfcn32", 0x0), + ByteField("arfcn24", 0x0), + ByteField("arfcn16", 0x0), + ByteField("arfcn8", 0x0) + ] + + +# len 4 to 13 +class GroupChannelDescription(Packet): + """Group Channel Description Section 10.5.2.14b""" + name = "Group Channel Description" + fields_desc = [ + XByteField("lengthGCD", None), + + BitField("channelType", 0x0, 5), + BitField("tn", 0x0, 3), + + BitField("tsc", 0x0, 3), + BitField("h", 0x0, 1), + # if h == 0 the packet looks the following way: + ConditionalField(BitField("spare", 0x0, 2), + lambda pkt: pkt. h == 0x0), + ConditionalField(BitField("arfcnHi", 0x0, 2), + lambda pkt: pkt. h == 0x0), + ConditionalField(ByteField("arfcnLo", None), + lambda pkt: pkt. h == 0x0), + # if h == 1 the packet looks the following way: + ConditionalField(BitField("maioHi", 0x0, 4), + lambda pkt: pkt. h == 0x1), + ConditionalField(BitField("maioLo", None, 2), + lambda pkt: pkt. h == 0x1), + ConditionalField(BitField("hsn", None, 6), + lambda pkt: pkt. h == 0x1), + # finished with conditional fields + ByteField("maC6", None), + ByteField("maC7", None), + ByteField("maC8", None), + ByteField("maC9", None), + ByteField("maC10", None), + ByteField("maC11", None), + ByteField("maC12", None), + ByteField("maC13", None), + ByteField("maC14", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(4, 13, a, self.fields_desc, 1) + if self.lengthGCD is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class GprsResumption(Packet): + """GPRS Resumption Section 10.5.2.14c""" + name = "GPRS Resumption" + fields_desc = [ + BitField("spare", 0x0, 3), + BitField("ack", 0x0, 1) + ] + + +class HandoverReference(Packet): + """Handover Reference Section 10.5.2.15""" + name = "Handover Reference" + fields_desc = [ + ByteField("handoverRef", 0x0) + ] + + +class IraRestOctets(Packet): + """IAR Rest Octets Section 10.5.2.17""" + name = "IAR Rest Octets" + fields_desc = [ + BitField("spare01", 0x0, 1), + BitField("spare02", 0x0, 1), + BitField("spare03", 0x1, 1), + BitField("spare04", 0x0, 1), + BitField("spare05", 0x1, 1), + BitField("spare06", 0x0, 1), + BitField("spare07", 0x1, 1), + BitField("spare08", 0x1, 1), + BitField("spare09", 0x0, 1), + BitField("spare10", 0x0, 1), + BitField("spare11", 0x1, 1), + BitField("spare12", 0x0, 1), + BitField("spare13", 0x1, 1), + BitField("spare14", 0x0, 1), + BitField("spare15", 0x1, 1), + BitField("spare16", 0x1, 1), + BitField("spare17", 0x0, 1), + BitField("spare18", 0x0, 1), + BitField("spare19", 0x1, 1), + BitField("spare20", 0x0, 1), + BitField("spare21", 0x1, 1), + BitField("spare22", 0x0, 1), + BitField("spare23", 0x1, 1), + BitField("spare24", 0x1, 1) + ] + + +# len is 1 to 5 what do we do with the variable size? no lenght +# field?! WTF +class IaxRestOctets(Packet): + """IAX Rest Octets Section 10.5.2.18""" + name = "IAX Rest Octets" + fields_desc = [ + BitField("spare01", 0x0, 1), + BitField("spare02", 0x0, 1), + BitField("spare03", 0x1, 1), + BitField("spare04", 0x0, 1), + BitField("spare05", 0x1, 1), + BitField("spare06", 0x0, 1), + BitField("spare07", 0x1, 1), + BitField("spare08", 0x1, 1), + ByteField("spareB1", None), + ByteField("spareB2", None), + ByteField("spareB3", None) + ] + + +class L2PseudoLength(Packet): + """L2 Pseudo Length Section 10.5.2.19""" + name = "L2 Pseudo Length" + fields_desc = [ + BitField("l2pLength", None, 6), + BitField("bit2", 0x0, 1), + BitField("bit1", 0x1, 1) + ] + + +class MeasurementResults(Packet): + """Measurement Results Section 10.5.2.20""" + name = "Measurement Results" + fields_desc = [ + BitField("baUsed", 0x0, 1), + BitField("dtxUsed", 0x0, 1), + BitField("rxLevFull", 0x0, 6), + + BitField("spare", 0x0, 1), + BitField("measValid", 0x0, 1), + BitField("rxLevSub", 0x0, 6), + + BitField("spare0", 0x0, 1), + BitField("rxqualFull", 0x0, 3), + BitField("rxqualSub", 0x0, 3), + BitField("noNcellHi", 0x0, 1), + + BitField("noNcellLo", 0x0, 2), + BitField("rxlevC1", 0x0, 6), + + BitField("bcchC1", 0x0, 5), + BitField("bsicC1Hi", 0x0, 3), + + BitField("bsicC1Lo", 0x0, 3), + BitField("rxlevC2", 0x0, 5), + + BitField("rxlevC2Lo", 0x0, 1), + BitField("bcchC2", 0x0, 5), + BitField("bsicC2Hi", 0x0, 2), + + BitField("bscicC2Lo", 0x0, 4), + BitField("bscicC2Hi", 0x0, 4), + + BitField("rxlevC3Lo", 0x0, 2), + BitField("bcchC3", 0x0, 5), + BitField("rxlevC3Hi", 0x0, 1), + + BitField("bsicC3Lo", 0x0, 5), + BitField("bsicC3Hi", 0x0, 3), + + BitField("rxlevC4Lo", 0x0, 3), + BitField("bcchC4", 0x0, 5), + + BitField("bsicC4", 0x0, 6), + BitField("rxlevC5Hi", 0x0, 2), + + BitField("rxlevC5Lo", 0x0, 4), + BitField("bcchC5Hi", 0x0, 4), + + BitField("bcchC5Lo", 0x0, 1), + BitField("bsicC5", 0x0, 6), + BitField("rxlevC6", 0x0, 1), + + BitField("rxlevC6Lo", 0x0, 5), + BitField("bcchC6Hi", 0x0, 3), + + BitField("bcchC6Lo", 0x0, 3), + BitField("bsicC6", 0x0, 5) + ] + + +class GprsMeasurementResults(Packet): + """GPRS Measurement Results Section 10.5.2.20a""" + name = "GPRS Measurement Results" + fields_desc = [ + BitField("cValue", 0x0, 6), + BitField("rxqualHi", 0x0, 2), + BitField("rxqL", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("signVar", 0x0, 6) + ] + + +# len 3 to 10 +class MobileAllocation(Packet): + """Mobile Allocation Section 10.5.2.21""" + name = "Mobile Allocation" + fields_desc = [ + XByteField("lengthMA", None), + ByteField("maC64", 0x12), + ByteField("maC56", None), # optional fields start here + ByteField("maC48", None), + ByteField("maC40", None), + ByteField("maC32", None), + ByteField("maC24", None), + ByteField("maC16", None), + ByteField("maC8", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 9, a, self.fields_desc, 1) + if self.lengthMA is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class MobileTimeDifference(Packet): + """Mobile Time Difference Section 10.5.2.21a""" + name = "Mobile Time Difference" + fields_desc = [ + XByteField("lengthMTD", 0x5), + ByteField("valueHi", 0x0), + ByteField("valueCnt", 0x0), + BitField("valueLow", 0x0, 5), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1) + ] + + +# min 4 octets max 8 +class MultiRateConfiguration(Packet): + """ MultiRate configuration Section 10.5.2.21aa""" + name = "MultiRate Configuration" + # This packet has a variable length and hence structure. This packet + # implements the longuest possible packet. If you biuild a shorter + # packet, for example having only 6 bytes, the last 4 bytes are named + # "Spare" in the specs. Here they are named "threshold2" + fields_desc = [ + XByteField("lengthMRC", None), + + BitField("mrVersion", 0x0, 3), + BitField("spare", 0x0, 1), + BitField("icmi", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("startMode", 0x0, 2), + + ByteField("amrCodec", None), + + BitField("spare", None, 2), + BitField("threshold1", None, 6), + + BitField("hysteresis1", None, 4), + BitField("threshold2", None, 4), + + BitField("threshold2cnt", None, 2), + BitField("hysteresis2", None, 4), + BitField("threshold3", None, 2), + + BitField("threshold3cnt", None, 4), + BitField("hysteresis3", None, 4) + ] + + def post_build(self, p, pay): + # we set the length + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 7, a, self.fields_desc, 1) + if self.lengthMRC is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 2 to 11 +class MultislotAllocation(Packet): + """Multislot Allocation Section 10.5.2.21b""" + name = "Multislot Allocation" + fields_desc = [ + XByteField("lengthMSA", None), + BitField("ext0", 0x1, 1), + BitField("da", 0x0, 7), + ConditionalField(BitField("ext1", 0x1, 1), # optional + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("ua", 0x0, 7), + lambda pkt: pkt.ext0 == 0), + ByteField("chan1", None), + ByteField("chan2", None), + ByteField("chan3", None), + ByteField("chan4", None), + ByteField("chan5", None), + ByteField("chan6", None), + ByteField("chan7", None), + ByteField("chan8", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 11, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthMSA is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay + + +class NcMode(Packet): + """NC mode Section 10.5.2.21c""" + name = "NC Mode" + fields_desc = [ + BitField("spare", 0x0, 2), + BitField("ncMode", 0x0, 2) + ] + + +class NeighbourCellsDescription(Packet): + """Neighbour Cells Description Section 10.5.2.22""" + name = "Neighbour Cells Description" + fields_desc = [ + BitField("bit128", 0x0, 1), + BitField("bit127", 0x0, 1), + BitField("extInd", 0x0, 1), + BitField("baInd", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + BitField("120bits", 0x0, 120) + ] + + +class NeighbourCellsDescription2(Packet): + """Neighbour Cells Description 2 Section 10.5.2.22a""" + name = "Neighbour Cells Description 2" + fields_desc = [ + BitField("bit128", 0x0, 1), + BitField("multiband", 0x0, 2), + BitField("baInd", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + BitField("120bits", 0x0, 120) + ] + + +# len 4 +# strange packet, lots of valid formats + +# ideas for the dynamic packets: +# 1] for user interaction: Create an interactive "builder" based on a +# Q/A process (not very scapy like) +# 2] for usage in scripts, create an alternative packet for every +# possible packet layout +# + +class DedicatedModeOrTBF(Packet): + """Dedicated mode or TBF Section 10.5.2.25b""" + name = "Dedicated Mode or TBF" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("tma", 0x0, 1), + BitField("downlink", 0x0, 1), + BitField("td", 0x0, 1) + ] + + +class PageMode(Packet): + """Page Mode Section 10.5.2.26""" + name = "Page Mode" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("pm", 0x0, 2) + ] + + +class NccPermitted(Packet): + """NCC Permitted Section 10.5.2.27""" + name = "NCC Permited" + fields_desc = [ + ByteField("nccPerm", 0x0) + ] + + +class PowerCommand(Packet): + """Power Command Section 10.5.2.28""" + name = "Power Command" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("spare2", 0x0, 1), + BitField("powerLvl", 0x0, 5) + ] + + +class PowerCommandAndAccessType(Packet): + """Power Command and access type Section 10.5.2.28a""" + name = "Power Command and Access Type" + fields_desc = [ + BitField("atc", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("powerLvl", 0x0, 5) + ] + + +class RachControlParameters(Packet): + """RACH Control Parameters Section 10.5.2.29""" + name = "RACH Control Parameters" + fields_desc = [ + BitField("maxRetrans", 0x0, 2), + BitField("txInteger", 0x0, 4), + BitField("cellBarrAccess", 0x0, 1), + BitField("re", 0x0, 1), + BitField("ACC15", 0x0, 1), + BitField("ACC14", 0x0, 1), + BitField("ACC13", 0x0, 1), + BitField("ACC12", 0x0, 1), + BitField("ACC11", 0x0, 1), + BitField("ACC10", 0x0, 1), + BitField("ACC09", 0x0, 1), + BitField("ACC08", 0x0, 1), + BitField("ACC07", 0x0, 1), + BitField("ACC06", 0x0, 1), + BitField("ACC05", 0x0, 1), + BitField("ACC04", 0x0, 1), + BitField("ACC03", 0x0, 1), + BitField("ACC02", 0x0, 1), + BitField("ACC01", 0x0, 1), + BitField("ACC00", 0x0, 1), + ] + + +class RequestReference(Packet): + """Request Reference Section 10.5.2.30""" + name = "Request Reference" + fields_desc = [ + ByteField("ra", 0x0), + BitField("t1", 0x0, 5), + BitField("t3Hi", 0x0, 3), + BitField("t3Lo", 0x0, 3), + BitField("t2", 0x0, 5) + ] + + +class RrCause(Packet): + """RR Cause Section 10.5.2.31""" + name = "RR Cause" + fields_desc = [ + ByteField("rrCause", 0x0) + ] + + +class StartingTime(Packet): + """Starting Time Section 10.5.2.38""" + name = "Starting Time" + fields_desc = [ + ByteField("ra", 0x0), + BitField("t1", 0x0, 5), + BitField("t3Hi", 0x0, 3), + BitField("t3Lo", 0x0, 3), + BitField("t2", 0x0, 5) + ] + + +class SynchronizationIndication(Packet): + """Synchronization Indication Section 10.5.2.39""" + name = "Synchronization Indication" + fields_desc = [ + BitField("nci", 0x0, 1), + BitField("rot", 0x0, 1), + BitField("si", 0x0, 2) + ] + + +class TimingAdvance(Packet): + """Timing Advance Section 10.5.2.40""" + name = "Timing Advance" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1), + BitField("timingVal", 0x0, 6) + ] + + +class TimeDifference(Packet): + """ Time Difference Section 10.5.2.41""" + name = "Time Difference" + fields_desc = [ + XByteField("lengthTD", 0x3), + ByteField("timeValue", 0x0) + ] + + +class Tlli(Packet): + """ TLLI Section Section 10.5.2.41a""" + name = "TLLI" + fields_desc = [ + ByteField("value", 0x0), + ByteField("value1", 0x0), + ByteField("value2", 0x0), + ByteField("value3", 0x0) + ] + + +class TmsiPTmsi(Packet): + """ TMSI/P-TMSI Section 10.5.2.42""" + name = "TMSI/P-TMSI" + fields_desc = [ + ByteField("value", 0x0), + ByteField("value1", 0x0), + ByteField("value2", 0x0), + ByteField("value3", 0x0) + ] + + +class VgcsTargetModeIdentication(Packet): + """ VGCS target Mode Indication 10.5.2.42a""" + name = "VGCS Target Mode Indication" + fields_desc = [ + XByteField("lengthVTMI", 0x2), + BitField("targerMode", 0x0, 2), + BitField("cipherKeyNb", 0x0, 4), + BitField("spare", 0x0, 1), + BitField("spare1", 0x0, 1) + ] + + +class WaitIndication(Packet): + """ Wait Indication Section 10.5.2.43""" + name = "Wait Indication" + fields_desc = [ # asciiart of specs strange + ByteField("timeoutVal", 0x0) + ] + + +#class Si10RestOctets(Packet): +# """SI10 rest octets 10.5.2.44""" +# name = "SI10 rest octets" +# fields_desc = [ + + +# len 17 +class ExtendedMeasurementResults(Packet): + """EXTENDED MEASUREMENT RESULTS Section 10.5.2.45""" + name = "Extended Measurement Results" + fields_desc = [ + + BitField("scUsed", None, 1), + BitField("dtxUsed", None, 1), + BitField("rxLevC0", None, 6), + + BitField("rxLevC1", None, 6), + BitField("rxLevC2Hi", None, 2), + + BitField("rxLevC2Lo", None, 4), + BitField("rxLevC3Hi", None, 4), + + BitField("rxLevC3Lo", None, 3), + BitField("rxLevC4", None, 5), + + BitField("rxLevC5", None, 6), + BitField("rxLevC6Hi", None, 2), + + BitField("rxLevC6Lo", None, 4), + BitField("rxLevC7Hi", None, 4), + + BitField("rxLevC7Lo", None, 2), + BitField("rxLevC8", None, 6), + + BitField("rxLevC9", None, 6), + BitField("rxLevC10Hi", None, 2), + + BitField("rxLevC10Lo", None, 4), + BitField("rxLevC11Hi", None, 4), + + BitField("rxLevC13Lo", None, 2), + BitField("rxLevC12", None, 6), + + BitField("rxLevC13", None, 6), + BitField("rxLevC14Hi", None, 2), + + BitField("rxLevC14Lo", None, 4), + BitField("rxLevC15Hi", None, 4), + + BitField("rxLevC15Lo", None, 2), + BitField("rxLevC16", None, 6), + + + BitField("rxLevC17", None, 6), + BitField("rxLevC18Hi", None, 2), + + BitField("rxLevC18Lo", None, 4), + BitField("rxLevC19Hi", None, 4), + + BitField("rxLevC19Lo", None, 2), + BitField("rxLevC20", None, 6) + ] + + +# len 17 +class ExtendedMeasurementFrequencyList(Packet): + """Extended Measurement Frequency List Section 10.5.2.46""" + name = "Extended Measurement Frequency List" + fields_desc = [ + + BitField("bit128", 0x0, 1), + BitField("bit127", 0x0, 1), + BitField("spare", 0x0, 1), + BitField("seqCode", 0x0, 1), + BitField("bit124", 0x0, 1), + BitField("bit123", 0x0, 1), + BitField("bit122", 0x0, 1), + BitField("bit121", 0x0, 1), + + BitField("bitsRest", 0x0, 128) + ] + + +class SuspensionCause(Packet): + """Suspension Cause Section 10.5.2.47""" + name = "Suspension Cause" + fields_desc = [ + ByteField("suspVal", 0x0) + ] + + +class ApduID(Packet): + """APDU Flags Section 10.5.2.48""" + name = "Apdu Id" + fields_desc = [ + BitField("id", None, 4) + ] + + +class ApduFlags(Packet): + """APDU Flags Section 10.5.2.49""" + name = "Apdu Flags" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("cr", 0x0, 1), + BitField("firstSeg", 0x0, 1), + BitField("lastSeg", 0x0, 1) + ] + + +# len 1 to max L3 (251) (done) +class ApduData(Packet): + """APDU Data Section 10.5.2.50""" + name = "Apdu Data" + fields_desc = [ + XByteField("lengthAD", None), + #optional + ByteField("apuInfo1", None), + ByteField("apuInfo2", None), + ByteField("apuInfo3", None), + ByteField("apuInfo4", None), + ByteField("apuInfo5", None), + ByteField("apuInfo6", None), + ByteField("apuInfo7", None), + ByteField("apuInfo8", None), + ByteField("apuInfo9", None), + ByteField("apuInfo10", None), + ByteField("apuInfo11", None), + ByteField("apuInfo12", None), + ByteField("apuInfo13", None), + ByteField("apuInfo14", None), + ByteField("apuInfo15", None), + ByteField("apuInfo16", None), + ByteField("apuInfo17", None), + ByteField("apuInfo18", None), + ByteField("apuInfo19", None), + ByteField("apuInfo20", None), + ByteField("apuInfo21", None), + ByteField("apuInfo22", None), + ByteField("apuInfo23", None), + ByteField("apuInfo24", None), + ByteField("apuInfo25", None), + ByteField("apuInfo26", None), + ByteField("apuInfo27", None), + ByteField("apuInfo28", None), + ByteField("apuInfo29", None), + ByteField("apuInfo30", None), + ByteField("apuInfo31", None), + ByteField("apuInfo32", None), + ByteField("apuInfo33", None), + ByteField("apuInfo34", None), + ByteField("apuInfo35", None), + ByteField("apuInfo36", None), + ByteField("apuInfo37", None), + ByteField("apuInfo38", None), + ByteField("apuInfo39", None), + ByteField("apuInfo40", None), + ByteField("apuInfo41", None), + ByteField("apuInfo42", None), + ByteField("apuInfo43", None), + ByteField("apuInfo44", None), + ByteField("apuInfo45", None), + ByteField("apuInfo46", None), + ByteField("apuInfo47", None), + ByteField("apuInfo48", None), + ByteField("apuInfo49", None), + ByteField("apuInfo50", None), + ByteField("apuInfo51", None), + ByteField("apuInfo52", None), + ByteField("apuInfo53", None), + ByteField("apuInfo54", None), + ByteField("apuInfo55", None), + ByteField("apuInfo56", None), + ByteField("apuInfo57", None), + ByteField("apuInfo58", None), + ByteField("apuInfo59", None), + ByteField("apuInfo60", None), + ByteField("apuInfo61", None), + ByteField("apuInfo62", None), + ByteField("apuInfo63", None), + ByteField("apuInfo64", None), + ByteField("apuInfo65", None), + ByteField("apuInfo66", None), + ByteField("apuInfo67", None), + ByteField("apuInfo68", None), + ByteField("apuInfo69", None), + ByteField("apuInfo70", None), + ByteField("apuInfo71", None), + ByteField("apuInfo72", None), + ByteField("apuInfo73", None), + ByteField("apuInfo74", None), + ByteField("apuInfo75", None), + ByteField("apuInfo76", None), + ByteField("apuInfo77", None), + ByteField("apuInfo78", None), + ByteField("apuInfo79", None), + ByteField("apuInfo80", None), + ByteField("apuInfo81", None), + ByteField("apuInfo82", None), + ByteField("apuInfo83", None), + ByteField("apuInfo84", None), + ByteField("apuInfo85", None), + ByteField("apuInfo86", None), + ByteField("apuInfo87", None), + ByteField("apuInfo88", None), + ByteField("apuInfo89", None), + ByteField("apuInfo90", None), + ByteField("apuInfo91", None), + ByteField("apuInfo92", None), + ByteField("apuInfo93", None), + ByteField("apuInfo94", None), + ByteField("apuInfo95", None), + ByteField("apuInfo96", None), + ByteField("apuInfo97", None), + ByteField("apuInfo98", None), + ByteField("apuInfo99", None), + ByteField("apuInfo100", None), + ByteField("apuInfo101", None), + ByteField("apuInfo102", None), + ByteField("apuInfo103", None), + ByteField("apuInfo104", None), + ByteField("apuInfo105", None), + ByteField("apuInfo106", None), + ByteField("apuInfo107", None), + ByteField("apuInfo108", None), + ByteField("apuInfo109", None), + ByteField("apuInfo110", None), + ByteField("apuInfo111", None), + ByteField("apuInfo112", None), + ByteField("apuInfo113", None), + ByteField("apuInfo114", None), + ByteField("apuInfo115", None), + ByteField("apuInfo116", None), + ByteField("apuInfo117", None), + ByteField("apuInfo118", None), + ByteField("apuInfo119", None), + ByteField("apuInfo120", None), + ByteField("apuInfo121", None), + ByteField("apuInfo122", None), + ByteField("apuInfo123", None), + ByteField("apuInfo124", None), + ByteField("apuInfo125", None), + ByteField("apuInfo126", None), + ByteField("apuInfo127", None), + ByteField("apuInfo128", None), + ByteField("apuInfo129", None), + ByteField("apuInfo130", None), + ByteField("apuInfo131", None), + ByteField("apuInfo132", None), + ByteField("apuInfo133", None), + ByteField("apuInfo134", None), + ByteField("apuInfo135", None), + ByteField("apuInfo136", None), + ByteField("apuInfo137", None), + ByteField("apuInfo138", None), + ByteField("apuInfo139", None), + ByteField("apuInfo140", None), + ByteField("apuInfo141", None), + ByteField("apuInfo142", None), + ByteField("apuInfo143", None), + ByteField("apuInfo144", None), + ByteField("apuInfo145", None), + ByteField("apuInfo146", None), + ByteField("apuInfo147", None), + ByteField("apuInfo148", None), + ByteField("apuInfo149", None), + ByteField("apuInfo150", None), + ByteField("apuInfo151", None), + ByteField("apuInfo152", None), + ByteField("apuInfo153", None), + ByteField("apuInfo154", None), + ByteField("apuInfo155", None), + ByteField("apuInfo156", None), + ByteField("apuInfo157", None), + ByteField("apuInfo158", None), + ByteField("apuInfo159", None), + ByteField("apuInfo160", None), + ByteField("apuInfo161", None), + ByteField("apuInfo162", None), + ByteField("apuInfo163", None), + ByteField("apuInfo164", None), + ByteField("apuInfo165", None), + ByteField("apuInfo166", None), + ByteField("apuInfo167", None), + ByteField("apuInfo168", None), + ByteField("apuInfo169", None), + ByteField("apuInfo170", None), + ByteField("apuInfo171", None), + ByteField("apuInfo172", None), + ByteField("apuInfo173", None), + ByteField("apuInfo174", None), + ByteField("apuInfo175", None), + ByteField("apuInfo176", None), + ByteField("apuInfo177", None), + ByteField("apuInfo178", None), + ByteField("apuInfo179", None), + ByteField("apuInfo180", None), + ByteField("apuInfo181", None), + ByteField("apuInfo182", None), + ByteField("apuInfo183", None), + ByteField("apuInfo184", None), + ByteField("apuInfo185", None), + ByteField("apuInfo186", None), + ByteField("apuInfo187", None), + ByteField("apuInfo188", None), + ByteField("apuInfo189", None), + ByteField("apuInfo190", None), + ByteField("apuInfo191", None), + ByteField("apuInfo192", None), + ByteField("apuInfo193", None), + ByteField("apuInfo194", None), + ByteField("apuInfo195", None), + ByteField("apuInfo196", None), + ByteField("apuInfo197", None), + ByteField("apuInfo198", None), + ByteField("apuInfo199", None), + ByteField("apuInfo200", None), + ByteField("apuInfo201", None), + ByteField("apuInfo202", None), + ByteField("apuInfo203", None), + ByteField("apuInfo204", None), + ByteField("apuInfo205", None), + ByteField("apuInfo206", None), + ByteField("apuInfo207", None), + ByteField("apuInfo208", None), + ByteField("apuInfo209", None), + ByteField("apuInfo210", None), + ByteField("apuInfo211", None), + ByteField("apuInfo212", None), + ByteField("apuInfo213", None), + ByteField("apuInfo214", None), + ByteField("apuInfo215", None), + ByteField("apuInfo216", None), + ByteField("apuInfo217", None), + ByteField("apuInfo218", None), + ByteField("apuInfo219", None), + ByteField("apuInfo220", None), + ByteField("apuInfo221", None), + ByteField("apuInfo222", None), + ByteField("apuInfo223", None), + ByteField("apuInfo224", None), + ByteField("apuInfo225", None), + ByteField("apuInfo226", None), + ByteField("apuInfo227", None), + ByteField("apuInfo228", None), + ByteField("apuInfo229", None), + ByteField("apuInfo230", None), + ByteField("apuInfo231", None), + ByteField("apuInfo232", None), + ByteField("apuInfo233", None), + ByteField("apuInfo234", None), + ByteField("apuInfo235", None), + ByteField("apuInfo236", None), + ByteField("apuInfo237", None), + ByteField("apuInfo238", None), + ByteField("apuInfo239", None), + ByteField("apuInfo240", None), + ByteField("apuInfo241", None), + ByteField("apuInfo242", None), + ByteField("apuInfo243", None), + ByteField("apuInfo244", None), + ByteField("apuInfo245", None), + ByteField("apuInfo246", None), + ByteField("apuInfo247", None), + ByteField("apuInfo248", None), + ByteField("apuInfo249", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 250, a, self.fields_desc, 1) + if self.lengthAD is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay +# +# 10.5.3 Mobility management information elements +# + + +# len 3 to L3 max (251) (done) +class NetworkName(Packet): + """Network Name Section 10.5.3.5a""" + name = "Network Name" + fields_desc = [ + + XByteField("lengthNN", None), + + BitField("ext", 0x1, 1), + BitField("codingScheme", 0x0, 3), + BitField("addCi", 0x0, 1), + BitField("nbSpare", 0x0, 3), + # optional + ByteField("txtString1", None), + ByteField("txtString2", None), + ByteField("txtString3", None), + ByteField("txtString4", None), + ByteField("txtString5", None), + ByteField("txtString6", None), + ByteField("txtString7", None), + ByteField("txtString8", None), + ByteField("txtString9", None), + ByteField("txtString10", None), + ByteField("txtString11", None), + ByteField("txtString12", None), + ByteField("txtString13", None), + ByteField("txtString14", None), + ByteField("txtString15", None), + ByteField("txtString16", None), + ByteField("txtString17", None), + ByteField("txtString18", None), + ByteField("txtString19", None), + ByteField("txtString20", None), + ByteField("txtString21", None), + ByteField("txtString22", None), + ByteField("txtString23", None), + ByteField("txtString24", None), + ByteField("txtString25", None), + ByteField("txtString26", None), + ByteField("txtString27", None), + ByteField("txtString28", None), + ByteField("txtString29", None), + ByteField("txtString30", None), + ByteField("txtString31", None), + ByteField("txtString32", None), + ByteField("txtString33", None), + ByteField("txtString34", None), + ByteField("txtString35", None), + ByteField("txtString36", None), + ByteField("txtString37", None), + ByteField("txtString38", None), + ByteField("txtString39", None), + ByteField("txtString40", None), + ByteField("txtString41", None), + ByteField("txtString42", None), + ByteField("txtString43", None), + ByteField("txtString44", None), + ByteField("txtString45", None), + ByteField("txtString46", None), + ByteField("txtString47", None), + ByteField("txtString48", None), + ByteField("txtString49", None), + ByteField("txtString50", None), + ByteField("txtString51", None), + ByteField("txtString52", None), + ByteField("txtString53", None), + ByteField("txtString54", None), + ByteField("txtString55", None), + ByteField("txtString56", None), + ByteField("txtString57", None), + ByteField("txtString58", None), + ByteField("txtString59", None), + ByteField("txtString60", None), + ByteField("txtString61", None), + ByteField("txtString62", None), + ByteField("txtString63", None), + ByteField("txtString64", None), + ByteField("txtString65", None), + ByteField("txtString66", None), + ByteField("txtString67", None), + ByteField("txtString68", None), + ByteField("txtString69", None), + ByteField("txtString70", None), + ByteField("txtString71", None), + ByteField("txtString72", None), + ByteField("txtString73", None), + ByteField("txtString74", None), + ByteField("txtString75", None), + ByteField("txtString76", None), + ByteField("txtString77", None), + ByteField("txtString78", None), + ByteField("txtString79", None), + ByteField("txtString80", None), + ByteField("txtString81", None), + ByteField("txtString82", None), + ByteField("txtString83", None), + ByteField("txtString84", None), + ByteField("txtString85", None), + ByteField("txtString86", None), + ByteField("txtString87", None), + ByteField("txtString88", None), + ByteField("txtString89", None), + ByteField("txtString90", None), + ByteField("txtString91", None), + ByteField("txtString92", None), + ByteField("txtString93", None), + ByteField("txtString94", None), + ByteField("txtString95", None), + ByteField("txtString96", None), + ByteField("txtString97", None), + ByteField("txtString98", None), + ByteField("txtString99", None), + ByteField("txtString100", None), + ByteField("txtString101", None), + ByteField("txtString102", None), + ByteField("txtString103", None), + ByteField("txtString104", None), + ByteField("txtString105", None), + ByteField("txtString106", None), + ByteField("txtString107", None), + ByteField("txtString108", None), + ByteField("txtString109", None), + ByteField("txtString110", None), + ByteField("txtString111", None), + ByteField("txtString112", None), + ByteField("txtString113", None), + ByteField("txtString114", None), + ByteField("txtString115", None), + ByteField("txtString116", None), + ByteField("txtString117", None), + ByteField("txtString118", None), + ByteField("txtString119", None), + ByteField("txtString120", None), + ByteField("txtString121", None), + ByteField("txtString122", None), + ByteField("txtString123", None), + ByteField("txtString124", None), + ByteField("txtString125", None), + ByteField("txtString126", None), + ByteField("txtString127", None), + ByteField("txtString128", None), + ByteField("txtString129", None), + ByteField("txtString130", None), + ByteField("txtString131", None), + ByteField("txtString132", None), + ByteField("txtString133", None), + ByteField("txtString134", None), + ByteField("txtString135", None), + ByteField("txtString136", None), + ByteField("txtString137", None), + ByteField("txtString138", None), + ByteField("txtString139", None), + ByteField("txtString140", None), + ByteField("txtString141", None), + ByteField("txtString142", None), + ByteField("txtString143", None), + ByteField("txtString144", None), + ByteField("txtString145", None), + ByteField("txtString146", None), + ByteField("txtString147", None), + ByteField("txtString148", None), + ByteField("txtString149", None), + ByteField("txtString150", None), + ByteField("txtString151", None), + ByteField("txtString152", None), + ByteField("txtString153", None), + ByteField("txtString154", None), + ByteField("txtString155", None), + ByteField("txtString156", None), + ByteField("txtString157", None), + ByteField("txtString158", None), + ByteField("txtString159", None), + ByteField("txtString160", None), + ByteField("txtString161", None), + ByteField("txtString162", None), + ByteField("txtString163", None), + ByteField("txtString164", None), + ByteField("txtString165", None), + ByteField("txtString166", None), + ByteField("txtString167", None), + ByteField("txtString168", None), + ByteField("txtString169", None), + ByteField("txtString170", None), + ByteField("txtString171", None), + ByteField("txtString172", None), + ByteField("txtString173", None), + ByteField("txtString174", None), + ByteField("txtString175", None), + ByteField("txtString176", None), + ByteField("txtString177", None), + ByteField("txtString178", None), + ByteField("txtString179", None), + ByteField("txtString180", None), + ByteField("txtString181", None), + ByteField("txtString182", None), + ByteField("txtString183", None), + ByteField("txtString184", None), + ByteField("txtString185", None), + ByteField("txtString186", None), + ByteField("txtString187", None), + ByteField("txtString188", None), + ByteField("txtString189", None), + ByteField("txtString190", None), + ByteField("txtString191", None), + ByteField("txtString192", None), + ByteField("txtString193", None), + ByteField("txtString194", None), + ByteField("txtString195", None), + ByteField("txtString196", None), + ByteField("txtString197", None), + ByteField("txtString198", None), + ByteField("txtString199", None), + ByteField("txtString200", None), + ByteField("txtString201", None), + ByteField("txtString202", None), + ByteField("txtString203", None), + ByteField("txtString204", None), + ByteField("txtString205", None), + ByteField("txtString206", None), + ByteField("txtString207", None), + ByteField("txtString208", None), + ByteField("txtString209", None), + ByteField("txtString210", None), + ByteField("txtString211", None), + ByteField("txtString212", None), + ByteField("txtString213", None), + ByteField("txtString214", None), + ByteField("txtString215", None), + ByteField("txtString216", None), + ByteField("txtString217", None), + ByteField("txtString218", None), + ByteField("txtString219", None), + ByteField("txtString220", None), + ByteField("txtString221", None), + ByteField("txtString222", None), + ByteField("txtString223", None), + ByteField("txtString224", None), + ByteField("txtString225", None), + ByteField("txtString226", None), + ByteField("txtString227", None), + ByteField("txtString228", None), + ByteField("txtString229", None), + ByteField("txtString230", None), + ByteField("txtString231", None), + ByteField("txtString232", None), + ByteField("txtString233", None), + ByteField("txtString234", None), + ByteField("txtString235", None), + ByteField("txtString236", None), + ByteField("txtString237", None), + ByteField("txtString238", None), + ByteField("txtString239", None), + ByteField("txtString240", None), + ByteField("txtString241", None), + ByteField("txtString242", None), + ByteField("txtString243", None), + ByteField("txtString244", None), + ByteField("txtString245", None), + ByteField("txtString246", None), + ByteField("txtString247", None), + ByteField("txtString248", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 250, a, self.fields_desc, 1) + if self.lengthNN is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class TimeZone(Packet): + """Time Zone Section 10.5.3.8""" + name = "Time Zone" + fields_desc = [ + ByteField("timeZone", 0x0), + ] + + +class TimeZoneAndTime(Packet): + """Time Zone and Time Section 10.5.3.9""" + name = "Time Zone and Time" + fields_desc = [ + ByteField("year", 0x0), + ByteField("month", 0x0), + ByteField("day", 0x0), + ByteField("hour", 0x0), + ByteField("minute", 0x0), + ByteField("second", 0x0), + ByteField("timeZone", 0x0) + ] + + +class CtsPermission(Packet): + """CTS permission Section 10.5.3.10""" + name = "Cts Permission" + fields_desc = [ + ] + + +class LsaIdentifier(Packet): + """LSA Identifier Section 10.5.3.11""" + name = "Lsa Identifier" + fields_desc = [ + ByteField("lsaID", 0x0), + ByteField("lsaID1", 0x0), + ByteField("lsaID2", 0x0) + ] + + +# +# 10.5.4 Call control information elements +# + +#10.5.4.1 Extensions of codesets +# This is only text and no packet + +class LockingShiftProcedure(Packet): + """Locking shift procedure Section 10.5.4.2""" + name = "Locking Shift Procedure" + fields_desc = [ + BitField("lockShift", 0x0, 1), + BitField("codesetId", 0x0, 3) + ] + + +class NonLockingShiftProcedure(Packet): + """Non-locking shift procedure Section 10.5.4.3""" + name = "Non-locking Shift Procedure" + fields_desc = [ + BitField("nonLockShift", 0x1, 1), + BitField("codesetId", 0x0, 3) + ] + + +class AuxiliaryStates(Packet): + """Auxiliary states Section 10.5.4.4""" + name = "Auxiliary States" + fields_desc = [ + XByteField("lengthAS", 0x3), + BitField("ext", 0x1, 1), + BitField("spare", 0x0, 3), + BitField("holdState", 0x0, 2), + BitField("mptyState", 0x0, 2) + ] + + +# len 3 to 15 +class BearerCapability(Packet): + """Bearer capability Section 10.5.4.5""" + name = "Bearer Capability" + fields_desc = [ + + XByteField("lengthBC", None), + + BitField("ext0", 0x1, 1), + BitField("radioChReq", 0x1, 2), + BitField("codingStd", 0x0, 1), + BitField("transMode", 0x0, 1), + BitField("infoTransCa", 0x0, 3), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("coding", None, 1), + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("spare", None, 2), + lambda pkt: pkt.ext0 == 0), + ConditionalField(BitField("speechVers", 0x0, 4), + lambda pkt: pkt.ext0 == 0), + + ConditionalField(BitField("ext2", 0x1, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("compress", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("structure", None, 2), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("dupMode", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("config", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("nirr", None, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("establi", 0x0, 1), + lambda pkt: pkt.ext1 == 0), + + BitField("ext3", None, 1), + BitField("accessId", None, 2), + BitField("rateAda", None, 2), + BitField("signaling", None, 3), + + ConditionalField(BitField("ext4", None, 1), + lambda pkt: pkt.ext3 == 0), + ConditionalField(BitField("otherITC", None, 2), + lambda pkt: pkt.ext3 == 0), + ConditionalField(BitField("otherRate", None, 2), + lambda pkt: pkt.ext3 == 0), + ConditionalField(BitField("spare1", 0x0, 3), + lambda pkt: pkt.ext3 == 0), + + ConditionalField(BitField("ext5", 0x1, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("hdr", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("multiFr", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("mode", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("lli", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("assig", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("inbNeg", None, 1), + lambda pkt: pkt.ext4 == 0), + ConditionalField(BitField("spare2", 0x0, 1), + lambda pkt: pkt.ext4 == 0), + + BitField("ext6", None, 1), + BitField("layer1Id", None, 2), + BitField("userInf", None, 4), + BitField("sync", None, 1), + + ConditionalField(BitField("ext7", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("stopBit", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("negoc", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("nbDataBit", None, 1), + lambda pkt: pkt.ext6 == 0), + ConditionalField(BitField("userRate", None, 4), + lambda pkt: pkt.ext6 == 0), + + ConditionalField(BitField("ext8", None, 1), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("interRate", None, 2), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("nicTX", None, 1), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("nicRX", None, 1), + lambda pkt: pkt.ext7 == 0), + ConditionalField(BitField("parity", None, 3), + lambda pkt: pkt.ext7 == 0), + + ConditionalField(BitField("ext9", None, 1), + lambda pkt: pkt.ext8 == 0), + ConditionalField(BitField("connEle", None, 2), + lambda pkt: pkt.ext8 == 0), + ConditionalField(BitField("modemType", None, 5), + lambda pkt: pkt.ext8 == 0), + + ConditionalField(BitField("ext10", None, 1), + lambda pkt: pkt.ext9 == 0), + ConditionalField(BitField("otherModemType", None, 2), + lambda pkt: pkt.ext9 == 0), + ConditionalField(BitField("netUserRate", None, 5), + lambda pkt: pkt.ext9 == 0), + + ConditionalField(BitField("ext11", None, 1), + lambda pkt: pkt.ext10 == 0), + ConditionalField(BitField("chanCoding", None, 4), + lambda pkt: pkt.ext10 == 0), + ConditionalField(BitField("maxTrafficChan", None, 3), + lambda pkt: pkt.ext10 == 0), + + ConditionalField(BitField("ext12", None, 1), + lambda pkt: pkt.ext11 == 0), + ConditionalField(BitField("uimi", None, 3), + lambda pkt: pkt.ext11 == 0), + ConditionalField(BitField("airInterfaceUserRate", None, 4), + lambda pkt: pkt.ext11 == 0), + + ConditionalField(BitField("ext13", 0x1, 1), + lambda pkt: pkt.ext12 == 0), + ConditionalField(BitField("layer2Ch", None, 2), + lambda pkt: pkt.ext12 == 0), + ConditionalField(BitField("userInfoL2", 0x0, 5), + lambda pkt: pkt.ext12 == 0) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 15, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthBC is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay + + +class CallControlCapabilities(Packet): + """Call Control Capabilities Section 10.5.4.5a""" + name = "Call Control Capabilities" + fields_desc = [ + XByteField("lengthCCC", 0x3), + BitField("spare", 0x0, 6), + BitField("pcp", 0x0, 1), + BitField("dtmf", 0x0, 1) + ] + + +class CallState(Packet): + """Call State Section 10.5.4.6""" + name = "Call State" + fields_desc = [ + BitField("codingStd", 0x0, 2), + BitField("stateValue", 0x0, 6) + ] + + +# len 3 to 43 +class CalledPartyBcdNumber(Packet): + """Called party BCD number Section 10.5.4.7""" + name = "Called Party BCD Number" + fields_desc = [ + XByteField("lengthCPBN", None), + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("nbPlanId", 0x0, 4), + # optional + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4), + + BitField("nbDigit22", None, 4), + BitField("nbDigit21", None, 4), + BitField("nbDigit24", None, 4), + BitField("nbDigit23", None, 4), + + BitField("nbDigit26", None, 4), + BitField("nbDigit25", None, 4), + BitField("nbDigit28", None, 4), + BitField("nbDigit27", None, 4), + + BitField("nbDigit30", None, 4), + BitField("nbDigit29", None, 4), + BitField("nbDigit32", None, 4), + BitField("nbDigit31", None, 4), + + BitField("nbDigit34", None, 4), + BitField("nbDigit33", None, 4), + BitField("nbDigit36", None, 4), + BitField("nbDigit35", None, 4), + + BitField("nbDigit38", None, 4), + BitField("nbDigit37", None, 4), + BitField("nbDigit40", None, 4), + BitField("nbDigit39", None, 4), +# ^^^^^^ 20 first optional bytes ^^^^^^^^^^^^^^^ + BitField("nbDigit42", None, 4), + BitField("nbDigit41", None, 4), + BitField("nbDigit44", None, 4), + BitField("nbDigit43", None, 4), + + BitField("nbDigit46", None, 4), + BitField("nbDigit45", None, 4), + BitField("nbDigit48", None, 4), + BitField("nbDigit47", None, 4), + + BitField("nbDigit50", None, 4), + BitField("nbDigit49", None, 4), + BitField("nbDigit52", None, 4), + BitField("nbDigit51", None, 4), + + BitField("nbDigit54", None, 4), + BitField("nbDigit53", None, 4), + BitField("nbDigit56", None, 4), + BitField("nbDigit55", None, 4), + + BitField("nbDigit58", None, 4), + BitField("nbDigit57", None, 4), + BitField("nbDigit60", None, 4), + BitField("nbDigit59", None, 4), + + BitField("nbDigit62", None, 4), + BitField("nbDigit61", None, 4), + BitField("nbDigit64", None, 4), + BitField("nbDigit63", None, 4), + + BitField("nbDigit66", None, 4), + BitField("nbDigit65", None, 4), + BitField("nbDigit68", None, 4), + BitField("nbDigit67", None, 4), + + BitField("nbDigit70", None, 4), + BitField("nbDigit69", None, 4), + BitField("nbDigit72", None, 4), + BitField("nbDigit71", None, 4), + + BitField("nbDigit74", None, 4), + BitField("nbDigit73", None, 4), + BitField("nbDigit76", None, 4), + BitField("nbDigit75", None, 4), + + BitField("nbDigit78", None, 4), + BitField("nbDigit77", None, 4), + BitField("nbDigit80", None, 4), + BitField("nbDigit79", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 42, a, self.fields_desc, 1) + if self.lengthCPBN is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 2 to 23 +class CalledPartySubaddress(Packet): + """Called party subaddress Section 10.5.4.8""" + name = "Called Party Subaddress" + fields_desc = [ + XByteField("lengthCPS", None), + # optional + BitField("ext", None, 1), + BitField("subAddr", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 23, a, self.fields_desc, 1) + if self.lengthCPS is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 3 to 14 +class CallingPartyBcdNumber(Packet): + """Called party subaddress Section 10.5.4.9""" + name = "Called Party Subaddress" + fields_desc = [ + XByteField("lengthCPBN", None), + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("nbPlanId", 0x0, 4), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("presId", None, 2), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("spare", None, 3), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("screenId", 0x0, 2), + lambda pkt: pkt.ext == 0), + + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 13, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthCPBN is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay + + +# len 2 to 23 +class CallingPartySubaddress(Packet): + """Calling party subaddress Section 10.5.4.10""" + name = "Calling Party Subaddress" + fields_desc = [ + XByteField("lengthCPS", None), + # optional + BitField("ext1", None, 1), + BitField("typeAddr", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 22, a, self.fields_desc, 1) + if self.lengthCPS is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 4 to 32 +class Cause(Packet): + """Cause Section 10.5.4.11""" + name = "Cause" + fields_desc = [ + + XByteField("lengthC", None), + + BitField("ext", 0x1, 1), + BitField("codingStd", 0x0, 2), + BitField("spare", 0x0, 1), + BitField("location", 0x0, 4), + + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("recommendation", 0x1, 7), + lambda pkt: pkt.ext == 0), + # optional + BitField("ext2", None, 1), + BitField("causeValue", None, 7), + + ByteField("diagnositc0", None), + ByteField("diagnositc1", None), + ByteField("diagnositc2", None), + ByteField("diagnositc3", None), + ByteField("diagnositc4", None), + ByteField("diagnositc5", None), + ByteField("diagnositc6", None), + ByteField("diagnositc7", None), + ByteField("diagnositc8", None), + ByteField("diagnositc9", None), + ByteField("diagnositc10", None), + ByteField("diagnositc11", None), + ByteField("diagnositc12", None), + ByteField("diagnositc13", None), + ByteField("diagnositc14", None), + ByteField("diagnositc15", None), + ByteField("diagnositc16", None), + ByteField("diagnositc17", None), + ByteField("diagnositc18", None), + ByteField("diagnositc19", None), + ByteField("diagnositc20", None), + ByteField("diagnositc21", None), + ByteField("diagnositc22", None), + ByteField("diagnositc23", None), + ByteField("diagnositc24", None), + ByteField("diagnositc25", None), + ByteField("diagnositc26", None), + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(3, 31, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthC is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay + + +class ClirSuppression(Packet): + """CLIR suppression Section 10.5.4.11a""" + name = "Clir Suppression" + fields_desc = [ + ] + + +class ClirInvocation(Packet): + """CLIR invocation Section 10.5.4.11b""" + name = "Clir Invocation" + fields_desc = [ + ] + + +class CongestionLevel(Packet): + """Congestion level Section 10.5.4.12""" + name = "Congestion Level" + fields_desc = [ + BitField("notDef", 0x0, 4) # not defined by the std + ] + + +# len 3 to 14 +class ConnectedNumber(Packet): + """Connected number Section 10.5.4.13""" + name = "Connected Number" + fields_desc = [ + + XByteField("lengthCN", None), + + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("typePlanId", 0x0, 4), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("presId", None, 2), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("spare", None, 3), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("screenId", None, 2), + lambda pkt: pkt.ext == 0), + + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 13, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthCN is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay + + +# len 2 to 23 +class ConnectedSubaddress(Packet): + """Connected subaddress Section 10.5.4.14""" + name = "Connected Subaddress" + fields_desc = [ + + XByteField("lengthCS", None), + # optional + BitField("ext", None, 1), + BitField("typeOfSub", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + a = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 22, a, self.fields_desc, 1) + if self.lengthCS is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# len 2 to L3 (251) (done) +class Facility(Packet): + """Facility Section 10.5.4.15""" + name = "Facility" + fields_desc = [ + XByteField("lengthF", None), + # optional + ByteField("facilityInfo1", None), + ByteField("facilityInfo2", None), + ByteField("facilityInfo3", None), + ByteField("facilityInfo4", None), + ByteField("facilityInfo5", None), + ByteField("facilityInfo6", None), + ByteField("facilityInfo7", None), + ByteField("facilityInfo8", None), + ByteField("facilityInfo9", None), + ByteField("facilityInfo10", None), + ByteField("facilityInfo11", None), + ByteField("facilityInfo12", None), + ByteField("facilityInfo13", None), + ByteField("facilityInfo14", None), + ByteField("facilityInfo15", None), + ByteField("facilityInfo16", None), + ByteField("facilityInfo17", None), + ByteField("facilityInfo18", None), + ByteField("facilityInfo19", None), + ByteField("facilityInfo20", None), + ByteField("facilityInfo21", None), + ByteField("facilityInfo22", None), + ByteField("facilityInfo23", None), + ByteField("facilityInfo24", None), + ByteField("facilityInfo25", None), + ByteField("facilityInfo26", None), + ByteField("facilityInfo27", None), + ByteField("facilityInfo28", None), + ByteField("facilityInfo29", None), + ByteField("facilityInfo30", None), + ByteField("facilityInfo31", None), + ByteField("facilityInfo32", None), + ByteField("facilityInfo33", None), + ByteField("facilityInfo34", None), + ByteField("facilityInfo35", None), + ByteField("facilityInfo36", None), + ByteField("facilityInfo37", None), + ByteField("facilityInfo38", None), + ByteField("facilityInfo39", None), + ByteField("facilityInfo40", None), + ByteField("facilityInfo41", None), + ByteField("facilityInfo42", None), + ByteField("facilityInfo43", None), + ByteField("facilityInfo44", None), + ByteField("facilityInfo45", None), + ByteField("facilityInfo46", None), + ByteField("facilityInfo47", None), + ByteField("facilityInfo48", None), + ByteField("facilityInfo49", None), + ByteField("facilityInfo50", None), + ByteField("facilityInfo51", None), + ByteField("facilityInfo52", None), + ByteField("facilityInfo53", None), + ByteField("facilityInfo54", None), + ByteField("facilityInfo55", None), + ByteField("facilityInfo56", None), + ByteField("facilityInfo57", None), + ByteField("facilityInfo58", None), + ByteField("facilityInfo59", None), + ByteField("facilityInfo60", None), + ByteField("facilityInfo61", None), + ByteField("facilityInfo62", None), + ByteField("facilityInfo63", None), + ByteField("facilityInfo64", None), + ByteField("facilityInfo65", None), + ByteField("facilityInfo66", None), + ByteField("facilityInfo67", None), + ByteField("facilityInfo68", None), + ByteField("facilityInfo69", None), + ByteField("facilityInfo70", None), + ByteField("facilityInfo71", None), + ByteField("facilityInfo72", None), + ByteField("facilityInfo73", None), + ByteField("facilityInfo74", None), + ByteField("facilityInfo75", None), + ByteField("facilityInfo76", None), + ByteField("facilityInfo77", None), + ByteField("facilityInfo78", None), + ByteField("facilityInfo79", None), + ByteField("facilityInfo80", None), + ByteField("facilityInfo81", None), + ByteField("facilityInfo82", None), + ByteField("facilityInfo83", None), + ByteField("facilityInfo84", None), + ByteField("facilityInfo85", None), + ByteField("facilityInfo86", None), + ByteField("facilityInfo87", None), + ByteField("facilityInfo88", None), + ByteField("facilityInfo89", None), + ByteField("facilityInfo90", None), + ByteField("facilityInfo91", None), + ByteField("facilityInfo92", None), + ByteField("facilityInfo93", None), + ByteField("facilityInfo94", None), + ByteField("facilityInfo95", None), + ByteField("facilityInfo96", None), + ByteField("facilityInfo97", None), + ByteField("facilityInfo98", None), + ByteField("facilityInfo99", None), + ByteField("facilityInfo100", None), + ByteField("facilityInfo101", None), + ByteField("facilityInfo102", None), + ByteField("facilityInfo103", None), + ByteField("facilityInfo104", None), + ByteField("facilityInfo105", None), + ByteField("facilityInfo106", None), + ByteField("facilityInfo107", None), + ByteField("facilityInfo108", None), + ByteField("facilityInfo109", None), + ByteField("facilityInfo110", None), + ByteField("facilityInfo111", None), + ByteField("facilityInfo112", None), + ByteField("facilityInfo113", None), + ByteField("facilityInfo114", None), + ByteField("facilityInfo115", None), + ByteField("facilityInfo116", None), + ByteField("facilityInfo117", None), + ByteField("facilityInfo118", None), + ByteField("facilityInfo119", None), + ByteField("facilityInfo120", None), + ByteField("facilityInfo121", None), + ByteField("facilityInfo122", None), + ByteField("facilityInfo123", None), + ByteField("facilityInfo124", None), + ByteField("facilityInfo125", None), + ByteField("facilityInfo126", None), + ByteField("facilityInfo127", None), + ByteField("facilityInfo128", None), + ByteField("facilityInfo129", None), + ByteField("facilityInfo130", None), + ByteField("facilityInfo131", None), + ByteField("facilityInfo132", None), + ByteField("facilityInfo133", None), + ByteField("facilityInfo134", None), + ByteField("facilityInfo135", None), + ByteField("facilityInfo136", None), + ByteField("facilityInfo137", None), + ByteField("facilityInfo138", None), + ByteField("facilityInfo139", None), + ByteField("facilityInfo140", None), + ByteField("facilityInfo141", None), + ByteField("facilityInfo142", None), + ByteField("facilityInfo143", None), + ByteField("facilityInfo144", None), + ByteField("facilityInfo145", None), + ByteField("facilityInfo146", None), + ByteField("facilityInfo147", None), + ByteField("facilityInfo148", None), + ByteField("facilityInfo149", None), + ByteField("facilityInfo150", None), + ByteField("facilityInfo151", None), + ByteField("facilityInfo152", None), + ByteField("facilityInfo153", None), + ByteField("facilityInfo154", None), + ByteField("facilityInfo155", None), + ByteField("facilityInfo156", None), + ByteField("facilityInfo157", None), + ByteField("facilityInfo158", None), + ByteField("facilityInfo159", None), + ByteField("facilityInfo160", None), + ByteField("facilityInfo161", None), + ByteField("facilityInfo162", None), + ByteField("facilityInfo163", None), + ByteField("facilityInfo164", None), + ByteField("facilityInfo165", None), + ByteField("facilityInfo166", None), + ByteField("facilityInfo167", None), + ByteField("facilityInfo168", None), + ByteField("facilityInfo169", None), + ByteField("facilityInfo170", None), + ByteField("facilityInfo171", None), + ByteField("facilityInfo172", None), + ByteField("facilityInfo173", None), + ByteField("facilityInfo174", None), + ByteField("facilityInfo175", None), + ByteField("facilityInfo176", None), + ByteField("facilityInfo177", None), + ByteField("facilityInfo178", None), + ByteField("facilityInfo179", None), + ByteField("facilityInfo180", None), + ByteField("facilityInfo181", None), + ByteField("facilityInfo182", None), + ByteField("facilityInfo183", None), + ByteField("facilityInfo184", None), + ByteField("facilityInfo185", None), + ByteField("facilityInfo186", None), + ByteField("facilityInfo187", None), + ByteField("facilityInfo188", None), + ByteField("facilityInfo189", None), + ByteField("facilityInfo190", None), + ByteField("facilityInfo191", None), + ByteField("facilityInfo192", None), + ByteField("facilityInfo193", None), + ByteField("facilityInfo194", None), + ByteField("facilityInfo195", None), + ByteField("facilityInfo196", None), + ByteField("facilityInfo197", None), + ByteField("facilityInfo198", None), + ByteField("facilityInfo199", None), + ByteField("facilityInfo200", None), + ByteField("facilityInfo201", None), + ByteField("facilityInfo202", None), + ByteField("facilityInfo203", None), + ByteField("facilityInfo204", None), + ByteField("facilityInfo205", None), + ByteField("facilityInfo206", None), + ByteField("facilityInfo207", None), + ByteField("facilityInfo208", None), + ByteField("facilityInfo209", None), + ByteField("facilityInfo210", None), + ByteField("facilityInfo211", None), + ByteField("facilityInfo212", None), + ByteField("facilityInfo213", None), + ByteField("facilityInfo214", None), + ByteField("facilityInfo215", None), + ByteField("facilityInfo216", None), + ByteField("facilityInfo217", None), + ByteField("facilityInfo218", None), + ByteField("facilityInfo219", None), + ByteField("facilityInfo220", None), + ByteField("facilityInfo221", None), + ByteField("facilityInfo222", None), + ByteField("facilityInfo223", None), + ByteField("facilityInfo224", None), + ByteField("facilityInfo225", None), + ByteField("facilityInfo226", None), + ByteField("facilityInfo227", None), + ByteField("facilityInfo228", None), + ByteField("facilityInfo229", None), + ByteField("facilityInfo230", None), + ByteField("facilityInfo231", None), + ByteField("facilityInfo232", None), + ByteField("facilityInfo233", None), + ByteField("facilityInfo234", None), + ByteField("facilityInfo235", None), + ByteField("facilityInfo236", None), + ByteField("facilityInfo237", None), + ByteField("facilityInfo238", None), + ByteField("facilityInfo239", None), + ByteField("facilityInfo240", None), + ByteField("facilityInfo241", None), + ByteField("facilityInfo242", None), + ByteField("facilityInfo243", None), + ByteField("facilityInfo244", None), + ByteField("facilityInfo245", None), + ByteField("facilityInfo246", None), + ByteField("facilityInfo247", None), + ByteField("facilityInfo248", None), + ByteField("facilityInfo249", None) + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(7, 250, a, self.fields_desc, 1) + if self.lengthF is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +#len 2 to 5 +class HighLayerCompatibility(Packet): + """High layer compatibility Section 10.5.4.16""" + name = "High Layer Compatibility" + fields_desc = [ + + XByteField("lengthHLC", None), + # optional + BitField("ext", None, 1), + BitField("codingStd", None, 2), + BitField("interpret", None, 3), + BitField("presMeth", None, 2), + + BitField("ext1", None, 1), + BitField("highLayerId", None, 7), + + ConditionalField(BitField("ext2", 0x1, 1), + lambda pkt: pkt.ext1 == 0), + ConditionalField(BitField("exHiLayerId", 0x0, 7), + lambda pkt: pkt.ext1 == 0), + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 4, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthHLC is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay +# +# 10.5.4.16.1 Static conditions for the high layer +# compatibility IE contents +# + + +class KeypadFacility(Packet): + """Keypad facility Section 10.5.4.17""" + name = "Keypad Facility" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("keyPadInfo", 0x0, 7) + ] + + +# len 2 to 15 +class LowLayerCompatibility(Packet): + """Low layer compatibility Section 10.5.4.18""" + name = "Low Layer Compatibility" + fields_desc = [ + + XByteField("lengthLLC", None), + # optional + ByteField("rest0", None), + ByteField("rest1", None), + ByteField("rest2", None), + ByteField("rest3", None), + ByteField("rest4", None), + ByteField("rest5", None), + ByteField("rest6", None), + ByteField("rest7", None), + ByteField("rest8", None), + ByteField("rest9", None), + ByteField("rest10", None), + ByteField("rest11", None), + ByteField("rest12", None) + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 14, a, self.fields_desc, 1) + if self.lengthLLC is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class MoreData(Packet): + """More data Section 10.5.4.19""" + name = "More Data" + fields_desc = [ + ] + + +class NotificationIndicator(Packet): + """Notification indicator Section 10.5.4.20""" + name = "Notification Indicator" + fields_desc = [ + BitField("ext1", 0x1, 1), + BitField("notifDesc", 0x0, 7) + ] + + +class ProgressIndicator(Packet): + """Progress indicator Section 10.5.4.21""" + name = "Progress Indicator" + fields_desc = [ + XByteField("lengthPI", 0x2), + BitField("ext", 0x1, 1), + BitField("codingStd", 0x0, 2), + BitField("spare", 0x0, 1), + BitField("location", 0x0, 4), + BitField("ext1", 0x1, 1), + BitField("progressDesc", 0x0, 7) + ] + + +class RecallType(Packet): + """Recall type $(CCBS)$ Section 10.5.4.21a""" + name = "Recall Type $(CCBS)$" + fields_desc = [ + BitField("spare", 0x0, 5), + BitField("recallType", 0x0, 3) + ] + + +# len 3 to 19 +class RedirectingPartyBcdNumber(Packet): + """Redirecting party BCD number Section 10.5.4.21b""" + name = "Redirecting Party BCD Number" + fields_desc = [ + + XByteField("lengthRPBN", None), + + BitField("ext", 0x1, 1), + BitField("typeNb", 0x0, 3), + BitField("numberingPlan", 0x0, 4), + # optional + ConditionalField(BitField("ext1", 0x1, 1), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("presId", 0x0, 2), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("spare", 0x0, 3), + lambda pkt: pkt.ext == 0), + ConditionalField(BitField("screenId", 0x0, 2), + lambda pkt: pkt.ext == 0), + + BitField("nbDigit2", None, 4), + BitField("nbDigit1", None, 4), + + BitField("nbDigit4", None, 4), + BitField("nbDigit3", None, 4), + + BitField("nbDigit6", None, 4), + BitField("nbDigit5", None, 4), + + BitField("nbDigit8", None, 4), + BitField("nbDigit7", None, 4), + + BitField("nbDigit10", None, 4), + BitField("nbDigit9", None, 4), + + BitField("nbDigit12", None, 4), + BitField("nbDigit11", None, 4), + + BitField("nbDigit14", None, 4), + BitField("nbDigit13", None, 4), + + BitField("nbDigit16", None, 4), + BitField("nbDigit15", None, 4), + + BitField("nbDigit18", None, 4), + BitField("nbDigit17", None, 4), + + BitField("nbDigit20", None, 4), + BitField("nbDigit19", None, 4), + + BitField("nbDigit22", None, 4), + BitField("nbDigit21", None, 4), + + BitField("nbDigit24", None, 4), + BitField("nbDigit23", None, 4), + + BitField("nbDigit26", None, 4), + BitField("nbDigit25", None, 4), + + BitField("nbDigit28", None, 4), + BitField("nbDigit27", None, 4), + + BitField("nbDigit30", None, 4), + BitField("nbDigit29", None, 4), + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 18, a, self.fields_desc, 1) + if res[0] is not 0: + p = p[:-res[0]] + if self.lengthRPBN is None: + p = struct.pack(">B", len(p)-1) + p[1:] + return p + pay + + +# length 2 to 23 +class RedirectingPartySubaddress(Packet): + """Redirecting party subaddress Section 10.5.4.21c""" + name = "Redirecting Party BCD Number" + fields_desc = [ + + XByteField("lengthRPS", None), + # optional + BitField("ext", None, 1), + BitField("typeSub", None, 3), + BitField("oddEven", None, 1), + BitField("spare", None, 3), + + ByteField("subInfo0", None), + ByteField("subInfo1", None), + ByteField("subInfo2", None), + ByteField("subInfo3", None), + ByteField("subInfo4", None), + ByteField("subInfo5", None), + ByteField("subInfo6", None), + ByteField("subInfo7", None), + ByteField("subInfo8", None), + ByteField("subInfo9", None), + ByteField("subInfo10", None), + ByteField("subInfo11", None), + ByteField("subInfo12", None), + ByteField("subInfo13", None), + ByteField("subInfo14", None), + ByteField("subInfo15", None), + ByteField("subInfo16", None), + ByteField("subInfo17", None), + ByteField("subInfo18", None), + ByteField("subInfo19", None) + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 22, a, self.fields_desc, 1) + if self.lengthRPS is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class RepeatIndicator(Packet): + """Repeat indicator Section 10.5.4.22""" + name = "Repeat Indicator" + fields_desc = [ + BitField("repeatIndic", 0x0, 4) + ] + + +# no upper length min 2(max for L3) (251) +class SetupContainer(Packet): + """SETUP Container $(CCBS)$ Section 10.5.4.22b""" + name = "Setup Container $(CCBS)$" + fields_desc = [ + XByteField("lengthSC", None), + # optional + ByteField("mess1", None), + ByteField("mess2", None), + ByteField("mess3", None), + ByteField("mess4", None), + ByteField("mess5", None), + ByteField("mess6", None), + ByteField("mess7", None), + ByteField("mess8", None), + ByteField("mess9", None), + ByteField("mess10", None), + ByteField("mess11", None), + ByteField("mess12", None), + ByteField("mess13", None), + ByteField("mess14", None), + ByteField("mess15", None), + ByteField("mess16", None), + ByteField("mess17", None), + ByteField("mess18", None), + ByteField("mess19", None), + ByteField("mess20", None), + ByteField("mess21", None), + ByteField("mess22", None), + ByteField("mess23", None), + ByteField("mess24", None), + ByteField("mess25", None), + ByteField("mess26", None), + ByteField("mess27", None), + ByteField("mess28", None), + ByteField("mess29", None), + ByteField("mess30", None), + ByteField("mess31", None), + ByteField("mess32", None), + ByteField("mess33", None), + ByteField("mess34", None), + ByteField("mess35", None), + ByteField("mess36", None), + ByteField("mess37", None), + ByteField("mess38", None), + ByteField("mess39", None), + ByteField("mess40", None), + ByteField("mess41", None), + ByteField("mess42", None), + ByteField("mess43", None), + ByteField("mess44", None), + ByteField("mess45", None), + ByteField("mess46", None), + ByteField("mess47", None), + ByteField("mess48", None), + ByteField("mess49", None), + ByteField("mess50", None), + ByteField("mess51", None), + ByteField("mess52", None), + ByteField("mess53", None), + ByteField("mess54", None), + ByteField("mess55", None), + ByteField("mess56", None), + ByteField("mess57", None), + ByteField("mess58", None), + ByteField("mess59", None), + ByteField("mess60", None), + ByteField("mess61", None), + ByteField("mess62", None), + ByteField("mess63", None), + ByteField("mess64", None), + ByteField("mess65", None), + ByteField("mess66", None), + ByteField("mess67", None), + ByteField("mess68", None), + ByteField("mess69", None), + ByteField("mess70", None), + ByteField("mess71", None), + ByteField("mess72", None), + ByteField("mess73", None), + ByteField("mess74", None), + ByteField("mess75", None), + ByteField("mess76", None), + ByteField("mess77", None), + ByteField("mess78", None), + ByteField("mess79", None), + ByteField("mess80", None), + ByteField("mess81", None), + ByteField("mess82", None), + ByteField("mess83", None), + ByteField("mess84", None), + ByteField("mess85", None), + ByteField("mess86", None), + ByteField("mess87", None), + ByteField("mess88", None), + ByteField("mess89", None), + ByteField("mess90", None), + ByteField("mess91", None), + ByteField("mess92", None), + ByteField("mess93", None), + ByteField("mess94", None), + ByteField("mess95", None), + ByteField("mess96", None), + ByteField("mess97", None), + ByteField("mess98", None), + ByteField("mess99", None), + ByteField("mess100", None), + ByteField("mess101", None), + ByteField("mess102", None), + ByteField("mess103", None), + ByteField("mess104", None), + ByteField("mess105", None), + ByteField("mess106", None), + ByteField("mess107", None), + ByteField("mess108", None), + ByteField("mess109", None), + ByteField("mess110", None), + ByteField("mess111", None), + ByteField("mess112", None), + ByteField("mess113", None), + ByteField("mess114", None), + ByteField("mess115", None), + ByteField("mess116", None), + ByteField("mess117", None), + ByteField("mess118", None), + ByteField("mess119", None), + ByteField("mess120", None), + ByteField("mess121", None), + ByteField("mess122", None), + ByteField("mess123", None), + ByteField("mess124", None), + ByteField("mess125", None), + ByteField("mess126", None), + ByteField("mess127", None), + ByteField("mess128", None), + ByteField("mess129", None), + ByteField("mess130", None), + ByteField("mess131", None), + ByteField("mess132", None), + ByteField("mess133", None), + ByteField("mess134", None), + ByteField("mess135", None), + ByteField("mess136", None), + ByteField("mess137", None), + ByteField("mess138", None), + ByteField("mess139", None), + ByteField("mess140", None), + ByteField("mess141", None), + ByteField("mess142", None), + ByteField("mess143", None), + ByteField("mess144", None), + ByteField("mess145", None), + ByteField("mess146", None), + ByteField("mess147", None), + ByteField("mess148", None), + ByteField("mess149", None), + ByteField("mess150", None), + ByteField("mess151", None), + ByteField("mess152", None), + ByteField("mess153", None), + ByteField("mess154", None), + ByteField("mess155", None), + ByteField("mess156", None), + ByteField("mess157", None), + ByteField("mess158", None), + ByteField("mess159", None), + ByteField("mess160", None), + ByteField("mess161", None), + ByteField("mess162", None), + ByteField("mess163", None), + ByteField("mess164", None), + ByteField("mess165", None), + ByteField("mess166", None), + ByteField("mess167", None), + ByteField("mess168", None), + ByteField("mess169", None), + ByteField("mess170", None), + ByteField("mess171", None), + ByteField("mess172", None), + ByteField("mess173", None), + ByteField("mess174", None), + ByteField("mess175", None), + ByteField("mess176", None), + ByteField("mess177", None), + ByteField("mess178", None), + ByteField("mess179", None), + ByteField("mess180", None), + ByteField("mess181", None), + ByteField("mess182", None), + ByteField("mess183", None), + ByteField("mess184", None), + ByteField("mess185", None), + ByteField("mess186", None), + ByteField("mess187", None), + ByteField("mess188", None), + ByteField("mess189", None), + ByteField("mess190", None), + ByteField("mess191", None), + ByteField("mess192", None), + ByteField("mess193", None), + ByteField("mess194", None), + ByteField("mess195", None), + ByteField("mess196", None), + ByteField("mess197", None), + ByteField("mess198", None), + ByteField("mess199", None), + ByteField("mess200", None), + ByteField("mess201", None), + ByteField("mess202", None), + ByteField("mess203", None), + ByteField("mess204", None), + ByteField("mess205", None), + ByteField("mess206", None), + ByteField("mess207", None), + ByteField("mess208", None), + ByteField("mess209", None), + ByteField("mess210", None), + ByteField("mess211", None), + ByteField("mess212", None), + ByteField("mess213", None), + ByteField("mess214", None), + ByteField("mess215", None), + ByteField("mess216", None), + ByteField("mess217", None), + ByteField("mess218", None), + ByteField("mess219", None), + ByteField("mess220", None), + ByteField("mess221", None), + ByteField("mess222", None), + ByteField("mess223", None), + ByteField("mess224", None), + ByteField("mess225", None), + ByteField("mess226", None), + ByteField("mess227", None), + ByteField("mess228", None), + ByteField("mess229", None), + ByteField("mess230", None), + ByteField("mess231", None), + ByteField("mess232", None), + ByteField("mess233", None), + ByteField("mess234", None), + ByteField("mess235", None), + ByteField("mess236", None), + ByteField("mess237", None), + ByteField("mess238", None), + ByteField("mess239", None), + ByteField("mess240", None), + ByteField("mess241", None), + ByteField("mess242", None), + ByteField("mess243", None), + ByteField("mess244", None), + ByteField("mess245", None), + ByteField("mess246", None), + ByteField("mess247", None), + ByteField("mess248", None), + ByteField("mess249", None), + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 250, a, self.fields_desc, 1) + if self.lengthSC is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class Signal(Packet): + """Signal Section 10.5.4.23""" + name = "Signal" + fields_desc = [ + ByteField("sigValue", 0x0) + ] + + +# length 2 to max for L3 message (251) +class SsVersionIndicator(Packet): + """SS Version Indicator Section 10.5.4.24""" + name = "SS Version Indicator" + fields_desc = [ + XByteField("lengthSVI", None), + # optional + ByteField("info1", None), + ByteField("info2", None), + ByteField("info3", None), + ByteField("info4", None), + ByteField("info5", None), + ByteField("info6", None), + ByteField("info7", None), + ByteField("info8", None), + ByteField("info9", None), + ByteField("info10", None), + ByteField("info11", None), + ByteField("info12", None), + ByteField("info13", None), + ByteField("info14", None), + ByteField("info15", None), + ByteField("info16", None), + ByteField("info17", None), + ByteField("info18", None), + ByteField("info19", None), + ByteField("info20", None), + ByteField("info21", None), + ByteField("info22", None), + ByteField("info23", None), + ByteField("info24", None), + ByteField("info25", None), + ByteField("info26", None), + ByteField("info27", None), + ByteField("info28", None), + ByteField("info29", None), + ByteField("info30", None), + ByteField("info31", None), + ByteField("info32", None), + ByteField("info33", None), + ByteField("info34", None), + ByteField("info35", None), + ByteField("info36", None), + ByteField("info37", None), + ByteField("info38", None), + ByteField("info39", None), + ByteField("info40", None), + ByteField("info41", None), + ByteField("info42", None), + ByteField("info43", None), + ByteField("info44", None), + ByteField("info45", None), + ByteField("info46", None), + ByteField("info47", None), + ByteField("info48", None), + ByteField("info49", None), + ByteField("info50", None), + ByteField("info51", None), + ByteField("info52", None), + ByteField("info53", None), + ByteField("info54", None), + ByteField("info55", None), + ByteField("info56", None), + ByteField("info57", None), + ByteField("info58", None), + ByteField("info59", None), + ByteField("info60", None), + ByteField("info61", None), + ByteField("info62", None), + ByteField("info63", None), + ByteField("info64", None), + ByteField("info65", None), + ByteField("info66", None), + ByteField("info67", None), + ByteField("info68", None), + ByteField("info69", None), + ByteField("info70", None), + ByteField("info71", None), + ByteField("info72", None), + ByteField("info73", None), + ByteField("info74", None), + ByteField("info75", None), + ByteField("info76", None), + ByteField("info77", None), + ByteField("info78", None), + ByteField("info79", None), + ByteField("info80", None), + ByteField("info81", None), + ByteField("info82", None), + ByteField("info83", None), + ByteField("info84", None), + ByteField("info85", None), + ByteField("info86", None), + ByteField("info87", None), + ByteField("info88", None), + ByteField("info89", None), + ByteField("info90", None), + ByteField("info91", None), + ByteField("info92", None), + ByteField("info93", None), + ByteField("info94", None), + ByteField("info95", None), + ByteField("info96", None), + ByteField("info97", None), + ByteField("info98", None), + ByteField("info99", None), + ByteField("info100", None), + ByteField("info101", None), + ByteField("info102", None), + ByteField("info103", None), + ByteField("info104", None), + ByteField("info105", None), + ByteField("info106", None), + ByteField("info107", None), + ByteField("info108", None), + ByteField("info109", None), + ByteField("info110", None), + ByteField("info111", None), + ByteField("info112", None), + ByteField("info113", None), + ByteField("info114", None), + ByteField("info115", None), + ByteField("info116", None), + ByteField("info117", None), + ByteField("info118", None), + ByteField("info119", None), + ByteField("info120", None), + ByteField("info121", None), + ByteField("info122", None), + ByteField("info123", None), + ByteField("info124", None), + ByteField("info125", None), + ByteField("info126", None), + ByteField("info127", None), + ByteField("info128", None), + ByteField("info129", None), + ByteField("info130", None), + ByteField("info131", None), + ByteField("info132", None), + ByteField("info133", None), + ByteField("info134", None), + ByteField("info135", None), + ByteField("info136", None), + ByteField("info137", None), + ByteField("info138", None), + ByteField("info139", None), + ByteField("info140", None), + ByteField("info141", None), + ByteField("info142", None), + ByteField("info143", None), + ByteField("info144", None), + ByteField("info145", None), + ByteField("info146", None), + ByteField("info147", None), + ByteField("info148", None), + ByteField("info149", None), + ByteField("info150", None), + ByteField("info151", None), + ByteField("info152", None), + ByteField("info153", None), + ByteField("info154", None), + ByteField("info155", None), + ByteField("info156", None), + ByteField("info157", None), + ByteField("info158", None), + ByteField("info159", None), + ByteField("info160", None), + ByteField("info161", None), + ByteField("info162", None), + ByteField("info163", None), + ByteField("info164", None), + ByteField("info165", None), + ByteField("info166", None), + ByteField("info167", None), + ByteField("info168", None), + ByteField("info169", None), + ByteField("info170", None), + ByteField("info171", None), + ByteField("info172", None), + ByteField("info173", None), + ByteField("info174", None), + ByteField("info175", None), + ByteField("info176", None), + ByteField("info177", None), + ByteField("info178", None), + ByteField("info179", None), + ByteField("info180", None), + ByteField("info181", None), + ByteField("info182", None), + ByteField("info183", None), + ByteField("info184", None), + ByteField("info185", None), + ByteField("info186", None), + ByteField("info187", None), + ByteField("info188", None), + ByteField("info189", None), + ByteField("info190", None), + ByteField("info191", None), + ByteField("info192", None), + ByteField("info193", None), + ByteField("info194", None), + ByteField("info195", None), + ByteField("info196", None), + ByteField("info197", None), + ByteField("info198", None), + ByteField("info199", None), + ByteField("info200", None), + ByteField("info201", None), + ByteField("info202", None), + ByteField("info203", None), + ByteField("info204", None), + ByteField("info205", None), + ByteField("info206", None), + ByteField("info207", None), + ByteField("info208", None), + ByteField("info209", None), + ByteField("info210", None), + ByteField("info211", None), + ByteField("info212", None), + ByteField("info213", None), + ByteField("info214", None), + ByteField("info215", None), + ByteField("info216", None), + ByteField("info217", None), + ByteField("info218", None), + ByteField("info219", None), + ByteField("info220", None), + ByteField("info221", None), + ByteField("info222", None), + ByteField("info223", None), + ByteField("info224", None), + ByteField("info225", None), + ByteField("info226", None), + ByteField("info227", None), + ByteField("info228", None), + ByteField("info229", None), + ByteField("info230", None), + ByteField("info231", None), + ByteField("info232", None), + ByteField("info233", None), + ByteField("info234", None), + ByteField("info235", None), + ByteField("info236", None), + ByteField("info237", None), + ByteField("info238", None), + ByteField("info239", None), + ByteField("info240", None), + ByteField("info241", None), + ByteField("info242", None), + ByteField("info243", None), + ByteField("info244", None), + ByteField("info245", None), + ByteField("info246", None), + ByteField("info247", None), + ByteField("info248", None), + ByteField("info249", None), + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(1, 250, a, self.fields_desc, 1) + if self.lengthSVI is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +# length 3 to 35 or 131 +class UserUser(Packet): + """User-user Section 10.5.4.25""" + name = "User-User" + fields_desc = [ + + XByteField("lengthUU", None), # dynamic length of field depending + # of the type of message + # let user decide which length he + # wants to take + # => more fuzzing options + ByteField("userUserPD", 0x0), + # optional + ByteField("userUserInfo1", None), + ByteField("userUserInfo2", None), + ByteField("userUserInfo3", None), + ByteField("userUserInfo4", None), + ByteField("userUserInfo5", None), + ByteField("userUserInfo6", None), + ByteField("userUserInfo7", None), + ByteField("userUserInfo8", None), + ByteField("userUserInfo9", None), + ByteField("userUserInfo10", None), + ByteField("userUserInfo11", None), + ByteField("userUserInfo12", None), + ByteField("userUserInfo13", None), + ByteField("userUserInfo14", None), + ByteField("userUserInfo15", None), + ByteField("userUserInfo16", None), + ByteField("userUserInfo17", None), + ByteField("userUserInfo18", None), + ByteField("userUserInfo19", None), + ByteField("userUserInfo20", None), + ByteField("userUserInfo21", None), + ByteField("userUserInfo22", None), + ByteField("userUserInfo23", None), + ByteField("userUserInfo24", None), + ByteField("userUserInfo25", None), + ByteField("userUserInfo26", None), + ByteField("userUserInfo27", None), + ByteField("userUserInfo28", None), + ByteField("userUserInfo29", None), + ByteField("userUserInfo30", None), + ByteField("userUserInfo31", None), + ByteField("userUserInfo32", None), + # long packet + ByteField("userUserInfo33", None), + ByteField("userUserInfo34", None), + ByteField("userUserInfo35", None), + ByteField("userUserInfo36", None), + ByteField("userUserInfo37", None), + ByteField("userUserInfo38", None), + ByteField("userUserInfo39", None), + ByteField("userUserInfo40", None), + ByteField("userUserInfo41", None), + ByteField("userUserInfo42", None), + ByteField("userUserInfo43", None), + ByteField("userUserInfo44", None), + ByteField("userUserInfo45", None), + ByteField("userUserInfo46", None), + ByteField("userUserInfo47", None), + ByteField("userUserInfo48", None), + ByteField("userUserInfo49", None), + ByteField("userUserInfo50", None), + ByteField("userUserInfo51", None), + ByteField("userUserInfo52", None), + ByteField("userUserInfo53", None), + ByteField("userUserInfo54", None), + ByteField("userUserInfo55", None), + ByteField("userUserInfo56", None), + ByteField("userUserInfo57", None), + ByteField("userUserInfo58", None), + ByteField("userUserInfo59", None), + ByteField("userUserInfo60", None), + ByteField("userUserInfo61", None), + ByteField("userUserInfo62", None), + ByteField("userUserInfo63", None), + ByteField("userUserInfo64", None), + ByteField("userUserInfo65", None), + ByteField("userUserInfo66", None), + ByteField("userUserInfo67", None), + ByteField("userUserInfo68", None), + ByteField("userUserInfo69", None), + ByteField("userUserInfo70", None), + ByteField("userUserInfo71", None), + ByteField("userUserInfo72", None), + ByteField("userUserInfo73", None), + ByteField("userUserInfo74", None), + ByteField("userUserInfo75", None), + ByteField("userUserInfo76", None), + ByteField("userUserInfo77", None), + ByteField("userUserInfo78", None), + ByteField("userUserInfo79", None), + ByteField("userUserInfo80", None), + ByteField("userUserInfo81", None), + ByteField("userUserInfo82", None), + ByteField("userUserInfo83", None), + ByteField("userUserInfo84", None), + ByteField("userUserInfo85", None), + ByteField("userUserInfo86", None), + ByteField("userUserInfo87", None), + ByteField("userUserInfo88", None), + ByteField("userUserInfo89", None), + ByteField("userUserInfo90", None), + ByteField("userUserInfo91", None), + ByteField("userUserInfo92", None), + ByteField("userUserInfo93", None), + ByteField("userUserInfo94", None), + ByteField("userUserInfo95", None), + ByteField("userUserInfo96", None), + ByteField("userUserInfo97", None), + ByteField("userUserInfo98", None), + ByteField("userUserInfo99", None), + ByteField("userUserInfo100", None), + ByteField("userUserInfo101", None), + ByteField("userUserInfo102", None), + ByteField("userUserInfo103", None), + ByteField("userUserInfo104", None), + ByteField("userUserInfo105", None), + ByteField("userUserInfo106", None), + ByteField("userUserInfo107", None), + ByteField("userUserInfo108", None), + ByteField("userUserInfo109", None), + ByteField("userUserInfo110", None), + ByteField("userUserInfo111", None), + ByteField("userUserInfo112", None), + ByteField("userUserInfo113", None), + ByteField("userUserInfo114", None), + ByteField("userUserInfo115", None), + ByteField("userUserInfo116", None), + ByteField("userUserInfo117", None), + ByteField("userUserInfo118", None), + ByteField("userUserInfo119", None), + ByteField("userUserInfo120", None), + ByteField("userUserInfo121", None), + ByteField("userUserInfo122", None), + ByteField("userUserInfo123", None), + ByteField("userUserInfo124", None), + ByteField("userUserInfo125", None), + ByteField("userUserInfo126", None), + ByteField("userUserInfo127", None), + ByteField("userUserInfo128", None), + ByteField("userUserInfo129", None), + ByteField("userUserInfo130", None), + ByteField("userUserInfo131", None) + ] + + def post_build(self, p, pay): + aList = [] + i = 0 + for i in range(0, len(self.fields_desc)): + aList.append(self.fields_desc[i].name) + a = [] + for i in aList: + a.append(getattr(self, i)) + res = adapt(2, 133, a, self.fields_desc, 1) + if self.lengthUU is None: + p = struct.pack(">B", res[1]) + p[1:] + if res[0] is not 0: + p = p[:-res[0]] + return p + pay + + +class AlertingPattern(Packet): + """Alerting Pattern 10.5.4.26""" + name = "Alerting Pattern" + fields_desc = [ + XByteField("lengthAP", 0x3), + BitField("spare", 0x0, 4), + BitField("alertingValue", 0x0, 4) + ] + + +class AllowedActions(Packet): + """Allowed actions $(CCBS)$ Section 10.5.4.26""" + name = "Allowed Actions $(CCBS)$" + fields_desc = [ + XByteField("lengthAP", 0x3), + BitField("CCBS", 0x0, 1), + BitField("spare", 0x0, 7) + ] + + +# +# 10.5.5 GPRS mobility management information elements +# + + +class AttachType(Packet): + """Attach type Section 10.5.5.2""" + name = "Attach Type" + fields_desc = [ + BitField("spare", 0x0, 1), + BitField("type", 0x1, 3) + ] + + +if __name__ == "__main__": + interact(mydict=globals(), mybanner="Scapy GSM-UM (Air) Addon") diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/gtp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/gtp.py new file mode 100644 index 00000000..008a0200 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/gtp.py @@ -0,0 +1,546 @@ +#! /usr/bin/env python + +## Copyright (C) 2014 Guillaume Valadon <guillaume.valadon@ssi.gouv.fr> +## 2014 Alexis Sultan <alexis.sultan@sfr.com> +## 2012 ffranz <ffranz@iniqua.com> +## +## This program is published under a GPLv2 license + +# scapy.contrib.description = GTP +# scapy.contrib.status = loads + +import time +import logging + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import IP, UDP + +# GTP Data types + +GTPmessageType = { 1: "echo_request", + 2: "echo_response", + 16: "create_pdp_context_req", + 17: "create_pdp_context_res", + 20: "delete_pdp_context_req", + 21: "delete_pdp_context_res", + 26: "error_indication", + 27: "pdu_notification_req", + 255: "gtp_u_header" } + +IEType = { 1: "Cause", + 2: "IMSI", + 3: "RAI", + 4: "TLLI", + 5: "P_TMSI", + 14: "Recovery", + 15: "SelectionMode", + 16: "TEIDI", + 17: "TEICP", + 19: "TeardownInd", + 20: "NSAPI", + 26: "ChargingChrt", + 27: "TraceReference", + 28: "TraceType", + 128: "EndUserAddress", + 131: "AccessPointName", + 132: "ProtocolConfigurationOptions", + 133: "GSNAddress", + 134: "MSInternationalNumber", + 135: "QoS", + 148: "CommonFlags", + 151: "RatType", + 152: "UserLocationInformation", + 153: "MSTimeZone", + 154: "IMEI" } + +CauseValues = { 0: "Request IMSI", + 1: "Request IMEI", + 2: "Request IMSI and IMEI", + 3: "No identity needed", + 4: "MS Refuses", + 5: "MS is not GPRS Responding", + 128: "Request accepted", + 129: "New PDP type due to network preference", + 130: "New PDP type due to single address bearer only", + 192: "Non-existent", + 193: "Invalid message format", + 194: "IMSI not known", + 195: "MS is GPRS Detached", + 196: "MS is not GPRS Responding", + 197: "MS Refuses", + 198: "Version not supported", + 199: "No resources available", + 200: "Service not supported", + 201: "Mandatory IE incorrect", + 202: "Mandatory IE missing", + 203: "Optional IE incorrect", + 204: "System failure", + 205: "Roaming restriction", + 206: "P-TMSI Signature mismatch", + 207: "GPRS connection suspended", + 208: "Authentication failure", + 209: "User authentication failed", + 210: "Context not found", + 211: "All dynamic PDP addresses are occupied", + 212: "No memory is available", + 213: "Reallocation failure", + 214: "Unknown mandatory extension header", + 215: "Semantic error in the TFT operation", + 216: "Syntactic error in TFT operation", + 217: "Semantic errors in packet filter(s)", + 218: "Syntactic errors in packet filter(s)", + 219: "Missing or unknown APN", + 220: "Unknown PDP address or PDP type", + 221: "PDP context without TFT already activated", + 222: "APN access denied : no subscription", + 223: "APN Restriction type incompatibility with currently active PDP Contexts", + 224: "MS MBMS Capabilities Insufficient", + 225: "Invalid Correlation : ID", + 226: "MBMS Bearer Context Superseded", + 227: "Bearer Control Mode violation", + 228: "Collision with network initiated request" } + +Selection_Mode = { 11111100: "MS or APN", + 11111101: "MS", + 11111110: "NET", + 11111111: "FutureUse" } + +TeardownInd_value = { 254: "False", + 255: "True" } + +class TBCDByteField(StrFixedLenField): + + def i2h(self, pkt, val): + ret = [] + for i in range(len(val)): + byte = ord(val[i]) + left = byte >> 4 + right = byte & 0xF + if left == 0xF: + ret += [ "%d" % right ] + else: + ret += [ "%d" % right, "%d" % left ] + return "".join(ret) + + def i2repr(self, pkt, x): + return repr(self.i2h(pkt,x)) + + def i2m(self, pkt, val): + ret_string = "" + for i in range(0, len(val), 2): + tmp = val[i:i+2] + if len(tmp) == 2: + ret_string += chr(int(tmp[1] + tmp[0], 16)) + else: + ret_string += chr(int("F" + tmp[0], 16)) + return ret_string + +class GTPHeader(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Header" + fields_desc=[ BitField("version", 1, 3), + BitField("PT", 1, 1), + BitField("reserved", 0, 1), + BitField("E", 0, 1), + BitField("S", 1, 1), + BitField("PN", 0, 1), + ByteEnumField("gtp_type", None, GTPmessageType), + ShortField("length", None), + IntField("teid", 0) ] + + def post_build(self, p, pay): + p += pay + if self.length is None: + l = len(p)-8 + p = p[:2] + struct.pack("!H", l)+ p[4:] + return p + + def hashret(self): + return struct.pack("B", self.version) + self.payload.hashret() + + def answers(self, other): + return (isinstance(other, GTPHeader) and + self.version == other.version and + self.payload.answers(other.payload)) + +class GTPEchoRequest(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Echo Request" + fields_desc = [ XBitField("seq", 0, 16), + ByteField("npdu", 0), + ByteField("next_ex", 0),] + + def hashret(self): + return struct.pack("H", self.seq) + +class IE_Cause(Packet): + name = "Cause" + fields_desc = [ ByteEnumField("ietype", 1, IEType), + BitField("Response", None, 1), + BitField("Rejection", None, 1), + BitEnumField("CauseValue", None, 6, CauseValues) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_IMSI(Packet): + name = "IMSI - Subscriber identity of the MS" + fields_desc = [ ByteEnumField("ietype", 2, IEType), + TBCDByteField("imsi", str(RandNum(0, 999999999999999)), 8) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_Routing(Packet): + name = "Routing Area Identity" + fields_desc = [ ByteEnumField("ietype", 3, IEType), + TBCDByteField("MCC", "", 2), + # MNC: if the third digit of MCC is 0xf, then the length of MNC is 1 byte + TBCDByteField("MNC", "", 1), + ShortField("LAC", None), + ByteField("RAC", None) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_Recovery(Packet): + name = "Recovery" + fields_desc = [ ByteEnumField("ietype", 14, IEType), + ByteField("res-counter", 24) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_SelectionMode(Packet): + # Indicates the origin of the APN in the message + name = "Selection Mode" + fields_desc = [ ByteEnumField("ietype", 15, IEType), + BitEnumField("SelectionMode", "MS or APN", 8, Selection_Mode) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_TEIDI(Packet): + name = "Tunnel Endpoint Identifier Data" + fields_desc = [ ByteEnumField("ietype", 16, IEType), + XIntField("TEIDI", RandInt()) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_TEICP(Packet): + name = "Tunnel Endpoint Identifier Control Plane" + fields_desc = [ ByteEnumField("ietype", 17, IEType), + XIntField("TEICI", RandInt())] + def extract_padding(self, pkt): + return "",pkt + +class IE_Teardown(Packet): + name = "Teardown Indicator" + fields_desc = [ ByteEnumField("ietype", 19, IEType), + ByteEnumField("indicator", "True", TeardownInd_value) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_NSAPI(Packet): + # Identifies a PDP context in a mobility management context specified by TEICP + name = "NSAPI" + fields_desc = [ ByteEnumField("ietype", 20, IEType), + XBitField("sparebits", 0x0000, 4), + XBitField("NSAPI", RandNum(0, 15), 4) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_ChargingCharacteristics(Packet): + # Way of informing both the SGSN and GGSN of the rules for + name = "Charging Characteristics" + fields_desc = [ ByteEnumField("ietype", 26, IEType), + # producing charging information based on operator configured triggers. + # 0000 .... .... .... : spare + # .... 1... .... .... : normal charging + # .... .0.. .... .... : prepaid charging + # .... ..0. .... .... : flat rate charging + # .... ...0 .... .... : hot billing charging + # .... .... 0000 0000 : reserved + XBitField("Ch_ChSpare", None, 4), + XBitField("normal_charging", None, 1), + XBitField("prepaid_charging", None, 1), + XBitField("flat_rate_charging", None, 1), + XBitField("hot_billing_charging", None, 1), + XBitField("Ch_ChReserved", 0, 8) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_TraceReference(Packet): + # Identifies a record or a collection of records for a particular trace. + name = "Trace Reference" + fields_desc = [ ByteEnumField("ietype", 27, IEType), + XBitField("Trace_reference", None, 16) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_TraceType(Packet): + # Indicates the type of the trace + name = "Trace Type" + fields_desc = [ ByteEnumField("ietype", 28, IEType), + XBitField("Trace_type", None, 16) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_EndUserAddress(Packet): + # Supply protocol specific information of the external packet + name = "End User Addresss" + fields_desc = [ ByteEnumField("ietype", 128, IEType), + # data network accessed by the GGPRS subscribers. + # - Request + # 1 Type (1byte) + # 2-3 Length (2bytes) - value 2 + # 4 Spare + PDP Type Organization + # 5 PDP Type Number + # - Response + # 6-n PDP Address + BitField("EndUserAddressLength", 2, 16), + BitField("EndUserAddress", 1111, 4), + BitField("PDPTypeOrganization", 1, 4), + XByteField("PDPTypeNumber", None) ] + def extract_padding(self, pkt): + return "",pkt + +class APNStrLenField(StrLenField): + # Inspired by DNSStrField + def m2i(self, pkt, s): + ret_s = "" + tmp_s = s + while tmp_s: + tmp_len = struct.unpack("!B", tmp_s[0])[0] + 1 + if tmp_len > len(tmp_s): + warning("APN prematured end of character-string (size=%i, remaining bytes=%i)" % (tmp_len, len(tmp_s))) + ret_s += tmp_s[1:tmp_len] + tmp_s = tmp_s[tmp_len:] + if len(tmp_s) : + ret_s += "." + s = ret_s + return s + def i2m(self, pkt, s): + s = "".join(map(lambda x: chr(len(x))+x, s.split("."))) + return s + + +class IE_AccessPointName(Packet): + # Sent by SGSN or by GGSN as defined in 3GPP TS 23.060 + name = "Access Point Name" + fields_desc = [ ByteEnumField("ietype", 131, IEType), + ShortField("length", None), + APNStrLenField("APN", "nternet", length_from=lambda x: x.length) ] + def extract_padding(self, pkt): + return "",pkt + def post_build(self, p, pay): + if self.length is None: + l = len(p)-3 + p = p[:2] + struct.pack("!B", l)+ p[3:] + return p + +class IE_ProtocolConfigurationOptions(Packet): + name = "Protocol Configuration Options" + fields_desc = [ ByteEnumField("ietype", 132, IEType), + ShortField("length", 4), + StrLenField("Protocol Configuration", "", length_from=lambda x: x.length) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_GSNAddress(Packet): + name = "GSN Address" + fields_desc = [ ByteEnumField("ietype", 133, IEType), + ShortField("length", 4), + IPField("address", RandIP()) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_MSInternationalNumber(Packet): + name = "MS International Number" + fields_desc = [ ByteEnumField("ietype", 134, IEType), + ShortField("length", None), + FlagsField("flags", 0x91, 8, ["Extension","","","International Number","","","","ISDN numbering"]), + TBCDByteField("digits", "33607080910", length_from=lambda x: x.length-1) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_UserLocationInformation(Packet): + name = "User Location Information" + fields_desc = [ ByteEnumField("ietype", 152, IEType), + ShortField("length", None), + ByteField("type", 1), + # Only type 1 is currently supported + TBCDByteField("MCC", "", 2), + # MNC: if the third digit of MCC is 0xf, then the length of MNC is 1 byte + TBCDByteField("MNC", "", 1), + ShortField("LAC", None), + ShortField("SAC", None) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_IMEI(Packet): + name = "IMEI" + fields_desc = [ ByteEnumField("ietype", 154, IEType), + ShortField("length", None), + TBCDByteField("IMEI", "", length_from=lambda x: x.length) ] + def extract_padding(self, pkt): + return "",pkt + +class IE_NotImplementedTLV(Packet): + name = "IE not implemented" + fields_desc = [ ByteEnumField("ietype", 0, IEType), + ShortField("length", None), + StrLenField("data", "", length_from=lambda x: x.length) ] + def extract_padding(self, pkt): + return "",pkt + +ietypecls = { 1: IE_Cause, 2: IE_IMSI, 3: IE_Routing, 14: IE_Recovery, 15: IE_SelectionMode, 16: IE_TEIDI, + 17: IE_TEICP, 19: IE_Teardown, 20: IE_NSAPI, 26: IE_ChargingCharacteristics, + 27: IE_TraceReference, 28: IE_TraceType, + 128: IE_EndUserAddress, 131: IE_AccessPointName, 132: IE_ProtocolConfigurationOptions, + 133: IE_GSNAddress, 134: IE_MSInternationalNumber, 152: IE_UserLocationInformation, 154: IE_IMEI } + +def IE_Dispatcher(s): + """Choose the correct Information Element class.""" + + if len(s) < 1: + return Raw(s) + + # Get the IE type + ietype = ord(s[0]) + cls = ietypecls.get(ietype, Raw) + + # if ietype greater than 128 are TLVs + if cls == Raw and ietype & 128 == 128: + cls = IE_NotImplementedTLV + + return cls(s) + +class GTPEchoResponse(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Echo Response" + fields_desc = [ XBitField("seq", 0, 16), + ByteField("npdu", 0), + ByteField("next_ex", 0), + PacketListField("IE_list", [], IE_Dispatcher) ] + + def hashret(self): + return struct.pack("H", self.seq) + + def answers(self, other): + return self.seq == other.seq + + +class GTPCreatePDPContextRequest(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Create PDP Context Request" + fields_desc = [ ShortField("seq", RandShort()), + ByteField("npdu", 0), + ByteField("next_ex", 0), + PacketListField("IE_list", [ IE_TEIDI(), IE_NSAPI(), IE_GSNAddress(), + IE_GSNAddress(), + IE_NotImplementedTLV(ietype=135, length=15,data=RandString(15)) ], + IE_Dispatcher) ] + def hashret(self): + return struct.pack("H", self.seq) + +class GTPCreatePDPContextResponse(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Create PDP Context Response" + fields_desc = [ ShortField("seq", RandShort()), + ByteField("npdu", 0), + ByteField("next_ex", 0), + PacketListField("IE_list", [], IE_Dispatcher) ] + + def hashret(self): + return struct.pack("H", self.seq) + + def answers(self, other): + return self.seq == other.seq + +class GTPErrorIndication(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Error Indication" + fields_desc = [ XBitField("seq", 0, 16), + ByteField("npdu", 0), + ByteField("next_ex",0), + PacketListField("IE_list", [], IE_Dispatcher) ] + +class GTPDeletePDPContextRequest(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Delete PDP Context Request" + fields_desc = [ XBitField("seq", 0, 16), + ByteField("npdu", 0), + ByteField("next_ex", 0), + PacketListField("IE_list", [], IE_Dispatcher) ] + +class GTPDeletePDPContextResponse(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP Delete PDP Context Response" + fields_desc = [ XBitField("seq", 0, 16), + ByteField("npdu", 0), + ByteField("next_ex",0), + PacketListField("IE_list", [], IE_Dispatcher) ] + +class GTPPDUNotificationRequest(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP PDU Notification Request" + fields_desc = [ XBitField("seq", 0, 16), + ByteField("npdu", 0), + ByteField("next_ex", 0), + PacketListField("IE_list", [ IE_IMSI(), + IE_TEICP(TEICI=RandInt()), + IE_EndUserAddress(PDPTypeNumber=0x21), + IE_AccessPointName(), + IE_GSNAddress(address="127.0.0.1"), + ], IE_Dispatcher) ] + +class GTP_U_Header(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP-U Header" + # GTP-U protocol is used to transmit T-PDUs between GSN pairs (or between an SGSN and an RNC in UMTS), + # encapsulated in G-PDUs. A G-PDU is a packet including a GTP-U header and a T-PDU. The Path Protocol + # defines the path and the GTP-U header defines the tunnel. Several tunnels may be multiplexed on a single path. + fields_desc = [ BitField("version", 1,3), + BitField("PT", 1, 1), + BitField("Reserved", 0, 1), + BitField("E", 0,1), + BitField("S", 0, 1), + BitField("PN", 0, 1), + ByteEnumField("gtp_type", None, GTPmessageType), + BitField("length", None, 16), + XBitField("TEID", 0, 32), + ConditionalField(XBitField("seq", 0, 16), lambda pkt:pkt.E==1 or pkt.S==1 or pkt.PN==1), + ConditionalField(ByteField("npdu", 0), lambda pkt:pkt.E==1 or pkt.S==1 or pkt.PN==1), + ConditionalField(ByteField("next_ex", 0), lambda pkt:pkt.E==1 or pkt.S==1 or pkt.PN==1), + ] + + def post_build(self, p, pay): + p += pay + if self.length is None: + l = len(p)-8 + p = p[:2] + struct.pack("!H", l)+ p[4:] + return p + +class GTPmorethan1500(Packet): + # 3GPP TS 29.060 V9.1.0 (2009-12) + name = "GTP More than 1500" + fields_desc = [ ByteEnumField("IE_Cause", "Cause", IEType), + BitField("IE", 1, 12000),] + +# Bind GTP-C +bind_layers(UDP, GTPHeader, dport = 2123) +bind_layers(UDP, GTPHeader, sport = 2123) +bind_layers(GTPHeader, GTPEchoRequest, gtp_type = 1) +bind_layers(GTPHeader, GTPEchoResponse, gtp_type = 2) +bind_layers(GTPHeader, GTPCreatePDPContextRequest, gtp_type = 16) +bind_layers(GTPHeader, GTPCreatePDPContextResponse, gtp_type = 17) +bind_layers(GTPHeader, GTPDeletePDPContextRequest, gtp_type = 20) +bind_layers(GTPHeader, GTPDeletePDPContextResponse, gtp_type = 21) +bind_layers(GTPHeader, GTPPDUNotificationRequest, gtp_type = 27) + +# Bind GTP-U +bind_layers(UDP, GTP_U_Header, dport = 2152) +bind_layers(UDP, GTP_U_Header, sport = 2152) +bind_layers(GTP_U_Header, IP, gtp_type = 255) + +if __name__ == "__main__": + from scapy.all import * + interact(mydict=globals(), mybanner="GTPv1 add-on") + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/igmp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/igmp.py new file mode 100644 index 00000000..b3505810 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/igmp.py @@ -0,0 +1,171 @@ +#! /usr/bin/env python + +# scapy.contrib.description = IGMP/IGMPv2 +# scapy.contrib.status = loads + + +# TODO: scapy 2 has function getmacbyip, maybe it can replace igmpize +# at least from the MAC layer + +from scapy.all import * + +#-------------------------------------------------------------------------- +def isValidMCAddr(ip): + """convert dotted quad string to long and check the first octet""" + FirstOct=atol(ip)>>24 & 0xFF + return (FirstOct >= 224) and (FirstOct <= 239) + +#-------------------------------------------------------------------------- + +class IGMP(Packet): + """IGMP Message Class for v1 and v2. + +This class is derived from class Packet. You need to "igmpize" +the IP and Ethernet layers before a full packet is sent. +a=Ether(src="00:01:02:03:04:05") +b=IP(src="1.2.3.4") +c=IGMP(type=0x12, gaddr="224.2.3.4") +c.igmpize(b, a) +print("Joining IP " + c.gaddr + " MAC " + a.dst) +sendp(a/b/c, iface="en0") + + Parameters: + type IGMP type field, 0x11, 0x12, 0x16 or 0x17 + mrtime Maximum Response time (zero for v1) + gaddr Multicast Group Address 224.x.x.x/4 + +See RFC2236, Section 2. Introduction for definitions of proper +IGMPv2 message format http://www.faqs.org/rfcs/rfc2236.html + + """ + name = "IGMP" + + igmptypes = { 0x11 : "Group Membership Query", + 0x12 : "Version 1 - Membership Report", + 0x16 : "Version 2 - Membership Report", + 0x17 : "Leave Group"} + + fields_desc = [ ByteEnumField("type", 0x11, igmptypes), + ByteField("mrtime",20), + XShortField("chksum", None), + IPField("gaddr", "0.0.0.0")] + +#-------------------------------------------------------------------------- + def post_build(self, p, pay): + """Called implicitly before a packet is sent to compute and place IGMP checksum. + + Parameters: + self The instantiation of an IGMP class + p The IGMP message in hex in network byte order + pay Additional payload for the IGMP message + """ + p += pay + if self.chksum is None: + ck = checksum(p) + p = p[:2]+chr(ck>>8)+chr(ck&0xff)+p[4:] + return p + +#-------------------------------------------------------------------------- + def mysummary(self): + """Display a summary of the IGMP object.""" + + if isinstance(self.underlayer, IP): + return self.underlayer.sprintf("IGMP: %IP.src% > %IP.dst% %IGMP.type% %IGMP.gaddr%") + else: + return self.sprintf("IGMP %IGMP.type% %IGMP.gaddr%") + +#-------------------------------------------------------------------------- + def igmpize(self, ip=None, ether=None): + """Called to explicitely fixup associated IP and Ethernet headers + + Parameters: + self The instantiation of an IGMP class. + ip The instantiation of the associated IP class. + ether The instantiation of the associated Ethernet. + + Returns: + True The tuple ether/ip/self passed all check and represents + a proper IGMP packet. + False One of more validation checks failed and no fields + were adjusted. + + The function will examine the IGMP message to assure proper format. + Corrections will be attempted if possible. The IP header is then properly + adjusted to ensure correct formatting and assignment. The Ethernet header + is then adjusted to the proper IGMP packet format. + """ + +# The rules are: +# 1. the Max Response time is meaningful only in Membership Queries and should be zero +# otherwise (RFC 2236, section 2.2) + + if (self.type != 0x11): #rule 1 + self.mrtime = 0 + + if (self.adjust_ip(ip) == True): + if (self.adjust_ether(ip, ether) == True): return True + return False + +#-------------------------------------------------------------------------- + def adjust_ether (self, ip=None, ether=None): + """Called to explicitely fixup an associated Ethernet header + + The function adjusts the ethernet header destination MAC address based on + the destination IP address. + """ +# The rules are: +# 1. send to the group mac address address corresponding to the IP.dst + if ip != None and ip.haslayer(IP) and ether != None and ether.haslayer(Ether): + iplong = atol(ip.dst) + ether.dst = "01:00:5e:%02x:%02x:%02x" % ( (iplong>>16)&0x7F, (iplong>>8)&0xFF, (iplong)&0xFF ) + # print "igmpize ip " + ip.dst + " as mac " + ether.dst + return True + else: + return False + +#-------------------------------------------------------------------------- + def adjust_ip (self, ip=None): + """Called to explicitely fixup an associated IP header + + The function adjusts the IP header based on conformance rules + and the group address encoded in the IGMP message. + The rules are: + 1. Send General Group Query to 224.0.0.1 (all systems) + 2. Send Leave Group to 224.0.0.2 (all routers) + 3a.Otherwise send the packet to the group address + 3b.Send reports/joins to the group address + 4. ttl = 1 (RFC 2236, section 2) + 5. send the packet with the router alert IP option (RFC 2236, section 2) + """ + if ip != None and ip.haslayer(IP): + if (self.type == 0x11): + if (self.gaddr == "0.0.0.0"): + ip.dst = "224.0.0.1" # IP rule 1 + retCode = True + elif isValidMCAddr(self.gaddr): + ip.dst = self.gaddr # IP rule 3a + retCode = True + else: + print("Warning: Using invalid Group Address") + retCode = False + elif ((self.type == 0x17) and isValidMCAddr(self.gaddr)): + ip.dst = "224.0.0.2" # IP rule 2 + retCode = True + elif ((self.type == 0x12) or (self.type == 0x16)) and (isValidMCAddr(self.gaddr)): + ip.dst = self.gaddr # IP rule 3b + retCode = True + else: + print("Warning: Using invalid IGMP Type") + retCode = False + else: + print("Warning: No IGMP Group Address set") + retCode = False + if retCode == True: + ip.ttl=1 # IP Rule 4 + ip.options=[IPOption_Router_Alert()] # IP rule 5 + return retCode + + +bind_layers( IP, IGMP, frag=0, proto=2) + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/igmpv3.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/igmpv3.py new file mode 100644 index 00000000..8322c7a3 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/igmpv3.py @@ -0,0 +1,270 @@ +#! /usr/bin/env python + +# http://trac.secdev.org/scapy/ticket/31 + +# scapy.contrib.description = IGMPv3 +# scapy.contrib.status = loads + +from scapy.packet import * + +""" Based on the following references + http://www.iana.org/assignments/igmp-type-numbers + http://www.rfc-editor.org/rfc/pdfrfc/rfc3376.txt.pdf + +""" + +# TODO: Merge IGMPv3 packet Bindlayers correct for +# membership source/Group records +# ConditionalField parameters for IGMPv3 commented out +# +# See RFC3376, Section 4. Message Formats for definitions of proper IGMPv3 message format +# http://www.faqs.org/rfcs/rfc3376.html +# +# See RFC4286, For definitions of proper messages for Multicast Router Discovery. +# http://www.faqs.org/rfcs/rfc4286.html +# + +#import sys, socket, struct, time +from scapy.all import * +print("IGMPv3 is still under development - Nov 2010") + + +class IGMPv3gr(Packet): + """IGMP Group Record for IGMPv3 Membership Report + + This class is derived from class Packet and should be concatenated to an + instantiation of class IGMPv3. Within the IGMPv3 instantiation, the numgrp + element will need to be manipulated to indicate the proper number of + group records. + """ + name = "IGMPv3gr" + igmpv3grtypes = { 1 : "Mode Is Include", + 2 : "Mode Is Exclude", + 3 : "Change To Include Mode", + 4 : "Change To Exclude Mode", + 5 : "Allow New Sources", + 6 : "Block Old Sources"} + + fields_desc = [ ByteEnumField("rtype", 1, igmpv3grtypes), + ByteField("auxdlen",0), + FieldLenField("numsrc", None, "srcaddrs"), + IPField("maddr", "0.0.0.0"), + FieldListField("srcaddrs", None, IPField("sa", "0.0.0.0"), "numsrc") ] + #show_indent=0 +#-------------------------------------------------------------------------- + def post_build(self, p, pay): + """Called implicitly before a packet is sent. + """ + p += pay + if self.auxdlen != 0: + print("NOTICE: A properly formatted and complaint V3 Group Record should have an Auxiliary Data length of zero (0).") + print(" Subsequent Group Records are lost!") + return p +#-------------------------------------------------------------------------- + def mysummary(self): + """Display a summary of the IGMPv3 group record.""" + return self.sprintf("IGMPv3 Group Record %IGMPv3gr.type% %IGMPv3gr.maddr%") + + +class IGMPv3(Packet): + """IGMP Message Class for v3. + + This class is derived from class Packet. + The fields defined below are a + direct interpretation of the v3 Membership Query Message. + Fields 'type' through 'qqic' are directly assignable. + For 'numsrc', do not assign a value. + Instead add to the 'srcaddrs' list to auto-set 'numsrc'. To + assign values to 'srcaddrs', use the following methods: + c = IGMPv3() + c.srcaddrs = ['1.2.3.4', '5.6.7.8'] + c.srcaddrs += ['192.168.10.24'] + At this point, 'c.numsrc' is three (3) + + 'chksum' is automagically calculated before the packet is sent. + + 'mrcode' is also the Advertisement Interval field + + """ + name = "IGMPv3" + igmpv3types = { 0x11 : "Membership Query", + 0x22 : "Version 3 Membership Report", + 0x30 : "Multicast Router Advertisement", + 0x31 : "Multicast Router Solicitation", + 0x32 : "Multicast Router Termination"} + + fields_desc = [ ByteEnumField("type", 0x11, igmpv3types), + ByteField("mrcode",0), + XShortField("chksum", None), + IPField("gaddr", "0.0.0.0") + ] + # use float_encode() + + # if type = 0x11 (Membership Query), the next field is group address + # ConditionalField(IPField("gaddr", "0.0.0.0"), "type", lambda x:x==0x11), + # else if type = 0x22 (Membership Report), the next fields are + # reserved and number of group records + #ConditionalField(ShortField("rsvd2", 0), "type", lambda x:x==0x22), + #ConditionalField(ShortField("numgrp", 0), "type", lambda x:x==0x22), +# FieldLenField("numgrp", None, "grprecs")] + # else if type = 0x30 (Multicast Router Advertisement), the next fields are + # query interval and robustness + #ConditionalField(ShortField("qryIntvl", 0), "type", lambda x:x==0x30), + #ConditionalField(ShortField("robust", 0), "type", lambda x:x==0x30), +# The following are only present for membership queries + # ConditionalField(BitField("resv", 0, 4), "type", lambda x:x==0x11), + # ConditionalField(BitField("s", 0, 1), "type", lambda x:x==0x11), + # ConditionalField(BitField("qrv", 0, 3), "type", lambda x:x==0x11), + # ConditionalField(ByteField("qqic",0), "type", lambda x:x==0x11), + # ConditionalField(FieldLenField("numsrc", None, "srcaddrs"), "type", lambda x:x==0x11), + # ConditionalField(FieldListField("srcaddrs", None, IPField("sa", "0.0.0.0"), "numsrc"), "type", lambda x:x==0x11), + +#-------------------------------------------------------------------------- + def float_encode(self, value): + """Convert the integer value to its IGMPv3 encoded time value if needed. + + If value < 128, return the value specified. If >= 128, encode as a floating + point value. Value can be 0 - 31744. + """ + if value < 128: + code = value + elif value > 31743: + code = 255 + else: + exp=0 + value>>=3 + while(value>31): + exp+=1 + value>>=1 + exp<<=4 + code = 0x80 | exp | (value & 0x0F) + return code + +#-------------------------------------------------------------------------- + def post_build(self, p, pay): + """Called implicitly before a packet is sent to compute and place IGMPv3 checksum. + + Parameters: + self The instantiation of an IGMPv3 class + p The IGMPv3 message in hex in network byte order + pay Additional payload for the IGMPv3 message + """ + p += pay + if self.type in [0, 0x31, 0x32, 0x22]: # for these, field is reserved (0) + p = p[:1]+chr(0)+p[2:] + if self.chksum is None: + ck = checksum(p) + p = p[:2]+chr(ck>>8)+chr(ck&0xff)+p[4:] + return p + +#-------------------------------------------------------------------------- + def mysummary(self): + """Display a summary of the IGMPv3 object.""" + + if isinstance(self.underlayer, IP): + return self.underlayer.sprintf("IGMPv3: %IP.src% > %IP.dst% %IGMPv3.type% %IGMPv3.gaddr%") + else: + return self.sprintf("IGMPv3 %IGMPv3.type% %IGMPv3.gaddr%") + +#-------------------------------------------------------------------------- + def igmpize(self, ip=None, ether=None): + """Called to explicitely fixup associated IP and Ethernet headers + + Parameters: + self The instantiation of an IGMP class. + ip The instantiation of the associated IP class. + ether The instantiation of the associated Ethernet. + + Returns: + True The tuple ether/ip/self passed all check and represents + a proper IGMP packet. + False One of more validation checks failed and no fields + were adjusted. + + The function will examine the IGMP message to assure proper format. + Corrections will be attempted if possible. The IP header is then properly + adjusted to ensure correct formatting and assignment. The Ethernet header + is then adjusted to the proper IGMP packet format. + """ + +# The rules are: +# 1. ttl = 1 (RFC 2236, section 2) +# igmp_binds = [ (IP, IGMP, { "proto": 2 , "ttl": 1 }), +# 2. tos = 0xC0 (RFC 3376, section 4) +# (IP, IGMPv3, { "proto": 2 , "ttl": 1, "tos":0xc0 }), +# (IGMPv3, IGMPv3gr, { }) ] +# The rules are: +# 1. the Max Response time is meaningful only in Membership Queries and should be zero +# otherwise (RFC 2236, section 2.2) + + if (self.type != 0x11): #rule 1 + self.mrtime = 0 + + if (self.adjust_ip(ip) == True): + if (self.adjust_ether(ip, ether) == True): return True + return False + +#-------------------------------------------------------------------------- + def adjust_ether (self, ip=None, ether=None): + """Called to explicitely fixup an associated Ethernet header + + The function adjusts the ethernet header destination MAC address based on + the destination IP address. + """ +# The rules are: +# 1. send to the group mac address address corresponding to the IP.dst + if ip != None and ip.haslayer(IP) and ether != None and ether.haslayer(Ether): + iplong = atol(ip.dst) + ether.dst = "01:00:5e:%02x:%02x:%02x" % ( (iplong>>16)&0x7F, (iplong>>8)&0xFF, (iplong)&0xFF ) + # print "igmpize ip " + ip.dst + " as mac " + ether.dst + return True + else: + return False + +#-------------------------------------------------------------------------- + def adjust_ip (self, ip=None): + """Called to explicitely fixup an associated IP header + + The function adjusts the IP header based on conformance rules + and the group address encoded in the IGMP message. + The rules are: + 1. Send General Group Query to 224.0.0.1 (all systems) + 2. Send Leave Group to 224.0.0.2 (all routers) + 3a.Otherwise send the packet to the group address + 3b.Send reports/joins to the group address + 4. ttl = 1 (RFC 2236, section 2) + 5. send the packet with the router alert IP option (RFC 2236, section 2) + """ + if ip != None and ip.haslayer(IP): + if (self.type == 0x11): + if (self.gaddr == "0.0.0.0"): + ip.dst = "224.0.0.1" # IP rule 1 + retCode = True + elif isValidMCAddr(self.gaddr): + ip.dst = self.gaddr # IP rule 3a + retCode = True + else: + print("Warning: Using invalid Group Address") + retCode = False + elif ((self.type == 0x17) and isValidMCAddr(self.gaddr)): + ip.dst = "224.0.0.2" # IP rule 2 + retCode = True + elif ((self.type == 0x12) or (self.type == 0x16)) and (isValidMCAddr(self.gaddr)): + ip.dst = self.gaddr # IP rule 3b + retCode = True + else: + print("Warning: Using invalid IGMP Type") + retCode = False + else: + print("Warning: No IGMP Group Address set") + retCode = False + if retCode == True: + ip.ttl=1 # IP Rule 4 + ip.options=[IPOption_Router_Alert()] # IP rule 5 + return retCode + + +bind_layers( IP, IGMPv3, frag=0, proto=2, ttl=1, tos=0xc0) +bind_layers( IGMPv3, IGMPv3gr, frag=0, proto=2) +bind_layers( IGMPv3gr, IGMPv3gr, frag=0, proto=2) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ikev2.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ikev2.py new file mode 100644 index 00000000..fd38b80c --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ikev2.py @@ -0,0 +1,362 @@ +#!/usr/bin/env python + +# http://trac.secdev.org/scapy/ticket/353 + +# scapy.contrib.description = IKEv2 +# scapy.contrib.status = loads + +from scapy.all import * +import logging + + +## Modified from the original ISAKMP code by Yaron Sheffer <yaronf.ietf@gmail.com>, June 2010. + +import struct +from scapy.packet import * +from scapy.fields import * +from scapy.ansmachine import * +from scapy.layers.inet import IP,UDP +from scapy.sendrecv import sr + +# see http://www.iana.org/assignments/ikev2-parameters for details +IKEv2AttributeTypes= { "Encryption": (1, { "DES-IV64" : 1, + "DES" : 2, + "3DES" : 3, + "RC5" : 4, + "IDEA" : 5, + "CAST" : 6, + "Blowfish" : 7, + "3IDEA" : 8, + "DES-IV32" : 9, + "AES-CBC" : 12, + "AES-CTR" : 13, + "AES-CCM-8" : 14, + "AES-CCM-12" : 15, + "AES-CCM-16" : 16, + "AES-GCM-8ICV" : 18, + "AES-GCM-12ICV" : 19, + "AES-GCM-16ICV" : 20, + "Camellia-CBC" : 23, + "Camellia-CTR" : 24, + "Camellia-CCM-8ICV" : 25, + "Camellia-CCM-12ICV" : 26, + "Camellia-CCM-16ICV" : 27, + }, 0), + "PRF": (2, {"PRF_HMAC_MD5":1, + "PRF_HMAC_SHA1":2, + "PRF_HMAC_TIGER":3, + "PRF_AES128_XCBC":4, + "PRF_HMAC_SHA2_256":5, + "PRF_HMAC_SHA2_384":6, + "PRF_HMAC_SHA2_512":7, + "PRF_AES128_CMAC":8, + }, 0), + "Integrity": (3, { "HMAC-MD5-96": 1, + "HMAC-SHA1-96": 2, + "DES-MAC": 3, + "KPDK-MD5": 4, + "AES-XCBC-96": 5, + "HMAC-MD5-128": 6, + "HMAC-SHA1-160": 7, + "AES-CMAC-96": 8, + "AES-128-GMAC": 9, + "AES-192-GMAC": 10, + "AES-256-GMAC": 11, + "SHA2-256-128": 12, + "SHA2-384-192": 13, + "SHA2-512-256": 14, + }, 0), + "GroupDesc": (4, { "768MODPgr" : 1, + "1024MODPgr" : 2, + "1536MODPgr" : 5, + "2048MODPgr" : 14, + "3072MODPgr" : 15, + "4096MODPgr" : 16, + "6144MODPgr" : 17, + "8192MODPgr" : 18, + "256randECPgr" : 19, + "384randECPgr" : 20, + "521randECPgr" : 21, + "1024MODP160POSgr" : 22, + "2048MODP224POSgr" : 23, + "2048MODP256POSgr" : 24, + "192randECPgr" : 25, + "224randECPgr" : 26, + }, 0), + "Extended Sequence Number": (5, {"No ESN": 0, + "ESN": 1, }, 0), + } + +# the name 'IKEv2TransformTypes' is actually a misnomer (since the table +# holds info for all IKEv2 Attribute types, not just transforms, but we'll +# keep it for backwards compatibility... for now at least +IKEv2TransformTypes = IKEv2AttributeTypes + +IKEv2TransformNum = {} +for n in IKEv2TransformTypes: + val = IKEv2TransformTypes[n] + tmp = {} + for e in val[1]: + tmp[val[1][e]] = e + IKEv2TransformNum[val[0]] = (n,tmp, val[2]) + +IKEv2Transforms = {} +for n in IKEv2TransformTypes: + IKEv2Transforms[IKEv2TransformTypes[n][0]]=n + +del(n) +del(e) +del(tmp) +del(val) + +# Note: Transform and Proposal can only be used inside the SA payload +IKEv2_payload_type = ["None", "", "Proposal", "Transform"] + +IKEv2_payload_type.extend([""] * 29) +IKEv2_payload_type.extend(["SA","KE","IDi","IDr", "CERT","CERTREQ","AUTH","Nonce","Notify","Delete", + "VendorID","TSi","TSr","Encrypted","CP","EAP"]) + +IKEv2_exchange_type = [""] * 34 +IKEv2_exchange_type.extend(["IKE_SA_INIT","IKE_AUTH","CREATE_CHILD_SA", + "INFORMATIONAL", "IKE_SESSION_RESUME"]) + + +class IKEv2_class(Packet): + def guess_payload_class(self, payload): + np = self.next_payload + logging.debug("For IKEv2_class np=%d" % np) + if np == 0: + return conf.raw_layer + elif np < len(IKEv2_payload_type): + pt = IKEv2_payload_type[np] + logging.debug(globals().get("IKEv2_payload_%s" % pt, IKEv2_payload)) + return globals().get("IKEv2_payload_%s" % pt, IKEv2_payload) + else: + return IKEv2_payload + + +class IKEv2(IKEv2_class): # rfc4306 + name = "IKEv2" + fields_desc = [ + StrFixedLenField("init_SPI","",8), + StrFixedLenField("resp_SPI","",8), + ByteEnumField("next_payload",0,IKEv2_payload_type), + XByteField("version",0x20), # IKEv2, right? + ByteEnumField("exch_type",0,IKEv2_exchange_type), + FlagsField("flags",0, 8, ["res0","res1","res2","Initiator","Version","Response","res6","res7"]), + IntField("id",0), + IntField("length",None) + ] + + def guess_payload_class(self, payload): + if self.flags & 1: + return conf.raw_layer + return IKEv2_class.guess_payload_class(self, payload) + + def answers(self, other): + if isinstance(other, IKEv2): + if other.init_SPI == self.init_SPI: + return 1 + return 0 + def post_build(self, p, pay): + p += pay + if self.length is None: + p = p[:24]+struct.pack("!I",len(p))+p[28:] + return p + + +class IKEv2_Key_Length_Attribute(IntField): + # We only support the fixed-length Key Length attribute (the only one currently defined) + name="key length" + def __init__(self, name): + IntField.__init__(self, name, "0x800E0000") + + def i2h(self, pkt, x): + return IntField.i2h(self, pkt, x & 0xFFFF) + + def h2i(self, pkt, x): + return IntField.h2i(self, pkt, struct.pack("!I", 0x800E0000 | int(x, 0))) + + +class IKEv2_Transform_ID(ShortField): + def i2h(self, pkt, x): + if pkt == None: + return None + else: + map = IKEv2TransformNum[pkt.transform_type][1] + return map[x] + + def h2i(self, pkt, x): + if pkt == None: + return None + else: + map = IKEv2TransformNum[pkt.transform_type][1] + for k in keys(map): + if map[k] == x: + return k + return None + +class IKEv2_payload_Transform(IKEv2_class): + name = "IKE Transform" + fields_desc = [ + ByteEnumField("next_payload",None,{0:"last", 3:"Transform"}), + ByteField("res",0), + ShortField("length",8), + ByteEnumField("transform_type",None,IKEv2Transforms), + ByteField("res2",0), + IKEv2_Transform_ID("transform_id", 0), + ConditionalField(IKEv2_Key_Length_Attribute("key_length"), lambda pkt: pkt.length > 8), + ] + +class IKEv2_payload_Proposal(IKEv2_class): + name = "IKEv2 Proposal" + fields_desc = [ + ByteEnumField("next_payload",None,{0:"last", 2:"Proposal"}), + ByteField("res",0), + FieldLenField("length",None,"trans","H", adjust=lambda pkt,x:x+8), + ByteField("proposal",1), + ByteEnumField("proto",1,{1:"IKEv2"}), + FieldLenField("SPIsize",None,"SPI","B"), + ByteField("trans_nb",None), + StrLenField("SPI","",length_from=lambda x:x.SPIsize), + PacketLenField("trans",conf.raw_layer(),IKEv2_payload_Transform,length_from=lambda x:x.length-8), + ] + + +class IKEv2_payload(IKEv2_class): + name = "IKEv2 Payload" + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + FlagsField("flags",0, 8, ["critical","res1","res2","res3","res4","res5","res6","res7"]), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + + +class IKEv2_payload_VendorID(IKEv2_class): + name = "IKEv2 Vendor ID" + overload_fields = { IKEv2: { "next_payload":43 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"vendorID","H", adjust=lambda pkt,x:x+4), + StrLenField("vendorID","",length_from=lambda x:x.length-4), + ] + +class IKEv2_payload_Delete(IKEv2_class): + name = "IKEv2 Vendor ID" + overload_fields = { IKEv2: { "next_payload":42 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"vendorID","H", adjust=lambda pkt,x:x+4), + StrLenField("vendorID","",length_from=lambda x:x.length-4), + ] + +class IKEv2_payload_SA(IKEv2_class): + name = "IKEv2 SA" + overload_fields = { IKEv2: { "next_payload":33 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"prop","H", adjust=lambda pkt,x:x+4), + PacketLenField("prop",conf.raw_layer(),IKEv2_payload_Proposal,length_from=lambda x:x.length-4), + ] + +class IKEv2_payload_Nonce(IKEv2_class): + name = "IKEv2 Nonce" + overload_fields = { IKEv2: { "next_payload":40 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + +class IKEv2_payload_Notify(IKEv2_class): + name = "IKEv2 Notify" + overload_fields = { IKEv2: { "next_payload":41 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + +class IKEv2_payload_KE(IKEv2_class): + name = "IKEv2 Key Exchange" + overload_fields = { IKEv2: { "next_payload":34 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+6), + ShortEnumField("group", 0, IKEv2TransformTypes['GroupDesc'][1]), + StrLenField("load","",length_from=lambda x:x.length-6), + ] + +class IKEv2_payload_IDi(IKEv2_class): + name = "IKEv2 Identification - Initiator" + overload_fields = { IKEv2: { "next_payload":35 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H",adjust=lambda pkt,x:x+8), + ByteEnumField("IDtype",1,{1:"IPv4_addr", 11:"Key"}), + ByteEnumField("ProtoID",0,{0:"Unused"}), + ShortEnumField("Port",0,{0:"Unused"}), +# IPField("IdentData","127.0.0.1"), + StrLenField("load","",length_from=lambda x:x.length-8), + ] + +class IKEv2_payload_IDr(IKEv2_class): + name = "IKEv2 Identification - Responder" + overload_fields = { IKEv2: { "next_payload":36 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H",adjust=lambda pkt,x:x+8), + ByteEnumField("IDtype",1,{1:"IPv4_addr", 11:"Key"}), + ByteEnumField("ProtoID",0,{0:"Unused"}), + ShortEnumField("Port",0,{0:"Unused"}), +# IPField("IdentData","127.0.0.1"), + StrLenField("load","",length_from=lambda x:x.length-8), + ] + + + +class IKEv2_payload_Encrypted(IKEv2_class): + name = "IKEv2 Encrypted and Authenticated" + overload_fields = { IKEv2: { "next_payload":46 }} + fields_desc = [ + ByteEnumField("next_payload",None,IKEv2_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H",adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + + + +IKEv2_payload_type_overload = {} +for i in range(len(IKEv2_payload_type)): + name = "IKEv2_payload_%s" % IKEv2_payload_type[i] + if name in globals(): + IKEv2_payload_type_overload[globals()[name]] = {"next_payload":i} + +del(i) +del(name) +IKEv2_class.overload_fields = IKEv2_payload_type_overload.copy() + +split_layers(UDP, ISAKMP, sport=500) +split_layers(UDP, ISAKMP, dport=500) + +bind_layers( UDP, IKEv2, dport=500, sport=500) # TODO: distinguish IKEv1/IKEv2 +bind_layers( UDP, IKEv2, dport=4500, sport=4500) + +def ikev2scan(ip): + return sr(IP(dst=ip)/UDP()/IKEv2(init_SPI=RandString(8), + exch_type=34)/IKEv2_payload_SA(prop=IKEv2_payload_Proposal())) + +# conf.debug_dissector = 1 + +if __name__ == "__main__": + interact(mydict=globals(), mybanner="IKEv2 alpha-level protocol implementation") diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ldp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ldp.py new file mode 100644 index 00000000..bc2464ab --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ldp.py @@ -0,0 +1,475 @@ +# scapy.contrib.description = Label Distribution Protocol (LDP) +# scapy.contrib.status = loads + +# http://git.savannah.gnu.org/cgit/ldpscapy.git/snapshot/ldpscapy-5285b81d6e628043df2a83301b292f24a95f0ba1.tar.gz + +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# Copyright (C) 2010 Florian Duraffourg + +import struct + +from scapy.packet import * +from scapy.fields import * +from scapy.ansmachine import * +from scapy.layers.inet import UDP +from scapy.layers.inet import TCP +from scapy.base_classes import Net + + +# Guess payload +def guess_payload(p): + LDPTypes = { + 0x0001: LDPNotification, + 0x0100: LDPHello, + 0x0200: LDPInit, + 0x0201: LDPKeepAlive, + 0x0300: LDPAddress, + 0x0301: LDPAddressWM, + 0x0400: LDPLabelMM, + 0x0401: LDPLabelReqM, + 0x0404: LDPLabelARM, + 0x0402: LDPLabelWM, + 0x0403: LDPLabelRelM, + } + type = struct.unpack("!H",p[0:2])[0] + type = type & 0x7fff + if type == 0x0001 and struct.unpack("!H",p[2:4])[0] > 20: + return LDP + if type in LDPTypes: + return LDPTypes[type] + else: + return conf.raw_layer + +## Fields ## + +# 3.4.1. FEC TLV + +class FecTLVField(StrField): + islist=1 + def m2i(self, pkt, x): + nbr = struct.unpack("!H",x[2:4])[0] + used = 0 + x=x[4:] + list=[] + while x: + #if x[0] == 1: + # list.append('Wildcard') + #else: + #mask=ord(x[8*i+3]) + #add=inet_ntoa(x[8*i+4:8*i+8]) + mask=ord(x[3]) + nbroctets = mask / 8 + if mask % 8: + nbroctets += 1 + add=inet_ntoa(x[4:4+nbroctets]+"\x00"*(4-nbroctets)) + list.append( (add, mask) ) + used += 4 + nbroctets + x=x[4+nbroctets:] + return list + def i2m(self, pkt, x): + if type(x) is str: + return x + s = "\x01\x00" + l = 0 + fec = "" + for o in x: + fec += "\x02\x00\x01" + # mask length + fec += struct.pack("!B",o[1]) + # Prefix + fec += inet_aton(o[0]) + l += 8 + s += struct.pack("!H",l) + s += fec + return s + def size(self, s): + """Get the size of this field""" + l = 4 + struct.unpack("!H",s[2:4])[0] + return l + def getfield(self, pkt, s): + l = self.size(s) + return s[l:],self.m2i(pkt, s[:l]) + + +# 3.4.2.1. Generic Label TLV + +class LabelTLVField(StrField): + def m2i(self, pkt, x): + return struct.unpack("!I",x[4:8])[0] + def i2m(self, pkt, x): + if type(x) is str: + return x + s = "\x02\x00\x00\x04" + s += struct.pack("!I",x) + return s + def size(self, s): + """Get the size of this field""" + l = 4 + struct.unpack("!H",s[2:4])[0] + return l + def getfield(self, pkt, s): + l = self.size(s) + return s[l:],self.m2i(pkt, s[:l]) + + +# 3.4.3. Address List TLV + +class AddressTLVField(StrField): + islist=1 + def m2i(self, pkt, x): + nbr = struct.unpack("!H",x[2:4])[0] - 2 + nbr /= 4 + x=x[6:] + list=[] + for i in range(0,nbr): + add = x[4*i:4*i+4] + list.append(inet_ntoa(add)) + return list + def i2m(self, pkt, x): + if type(x) is str: + return x + l=2+len(x)*4 + s = "\x01\x01"+struct.pack("!H",l)+"\x00\x01" + for o in x: + s += inet_aton(o) + return s + def size(self, s): + """Get the size of this field""" + l = 4 + struct.unpack("!H",s[2:4])[0] + return l + def getfield(self, pkt, s): + l = self.size(s) + return s[l:],self.m2i(pkt, s[:l]) + + +# 3.4.6. Status TLV + +class StatusTLVField(StrField): + islist=1 + def m2i(self, pkt, x): + l = [] + statuscode = struct.unpack("!I",x[4:8])[0] + l.append( (statuscode & 2**31) >> 31) + l.append( (statuscode & 2**30) >> 30) + l.append( statuscode & 0x3FFFFFFF ) + l.append( struct.unpack("!I", x[8:12])[0] ) + l.append( struct.unpack("!H", x[12:14])[0] ) + return l + def i2m(self, pkt, x): + if type(x) is str: + return x + s = "\x03\x00" + struct.pack("!H",10) + statuscode = 0 + if x[0] != 0: + statuscode += 2**31 + if x[1] != 0: + statuscode += 2**30 + statuscode += x[2] + s += struct.pack("!I",statuscode) + if len(x) > 3: + s += struct.pack("!I",x[3]) + else: + s += "\x00\x00\x00\x00" + if len(x) > 4: + s += struct.pack("!H",x[4]) + else: + s += "\x00\x00" + return s + def getfield(self, pkt, s): + l = 14 + return s[l:],self.m2i(pkt, s[:l]) + + +# 3.5.2 Common Hello Parameters TLV +class CommonHelloTLVField(StrField): + islist = 1 + def m2i(self, pkt, x): + list = [] + v = struct.unpack("!H",x[4:6])[0] + list.append(v) + flags = struct.unpack("B",x[6])[0] + v = ( flags & 0x80 ) >> 7 + list.append(v) + v = ( flags & 0x40 ) >> 7 + list.append(v) + return list + def i2m(self, pkt, x): + if type(x) is str: + return x + s = "\x04\x00\x00\x04" + s += struct.pack("!H",x[0]) + byte = 0 + if x[1] == 1: + byte += 0x80 + if x[2] == 1: + byte += 0x40 + s += struct.pack("!B",byte) + s += "\x00" + return s + def getfield(self, pkt, s): + l = 8 + return s[l:],self.m2i(pkt, s[:l]) + + +# 3.5.3 Common Session Parameters TLV +class CommonSessionTLVField(StrField): + islist = 1 + def m2i(self, pkt, x): + l = [] + l.append(struct.unpack("!H",x[6:8])[0]) + octet = struct.unpack("B",x[8:9])[0] + l.append( (octet & 2**7 ) >> 7 ) + l.append( (octet & 2**6 ) >> 6 ) + l.append( struct.unpack("B",x[9:10])[0] ) + l.append( struct.unpack("!H",x[10:12])[0] ) + l.append( inet_ntoa(x[12:16]) ) + l.append( struct.unpack("!H",x[16:18])[0] ) + return l + def i2m(self, pkt, x): + if type(x) is str: + return x + s = "\x05\x00\x00\x0E\x00\x01" + s += struct.pack("!H",x[0]) + octet = 0 + if x[1] != 0: + octet += 2**7 + if x[2] != 0: + octet += 2**6 + s += struct.pack("!B",octet) + s += struct.pack("!B",x[3]) + s += struct.pack("!H",x[4]) + s += inet_aton(x[5]) + s += struct.pack("!H",x[6]) + return s + def getfield(self, pkt, s): + l = 18 + return s[l:],self.m2i(pkt, s[:l]) + + + +## Messages ## + +# 3.5.1. Notification Message +class LDPNotification(Packet): + name = "LDPNotification" + fields_desc = [ BitField("u",0,1), + BitField("type", 0x0001, 15), + ShortField("len", None), + IntField("id", 0) , + StatusTLVField("status",(0,0,0,0,0)) ] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.2. Hello Message +class LDPHello(Packet): + name = "LDPHello" + fields_desc = [ BitField("u",0,1), + BitField("type", 0x0100, 15), + ShortField("len", None), + IntField("id", 0) , + CommonHelloTLVField("params",[180,0,0]) ] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.3. Initialization Message +class LDPInit(Packet): + name = "LDPInit" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0200, 15), + ShortField("len", None), + IntField("id", 0), + CommonSessionTLVField("params",None)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.4. KeepAlive Message +class LDPKeepAlive(Packet): + name = "LDPKeepAlive" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0201, 15), + ShortField("len", None), + IntField("id", 0)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.5. Address Message + +class LDPAddress(Packet): + name = "LDPAddress" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0300, 15), + ShortField("len", None), + IntField("id", 0), + AddressTLVField("address",None) ] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.6. Address Withdraw Message + +class LDPAddressWM(Packet): + name = "LDPAddressWM" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0301, 15), + ShortField("len", None), + IntField("id", 0), + AddressTLVField("address",None) ] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.7. Label Mapping Message + +class LDPLabelMM(Packet): + name = "LDPLabelMM" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0400, 15), + ShortField("len", None), + IntField("id", 0), + FecTLVField("fec",None), + LabelTLVField("label",0)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + +# 3.5.8. Label Request Message + +class LDPLabelReqM(Packet): + name = "LDPLabelReqM" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0401, 15), + ShortField("len", None), + IntField("id", 0), + FecTLVField("fec",None)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.9. Label Abort Request Message + +class LDPLabelARM(Packet): + name = "LDPLabelARM" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0404, 15), + ShortField("len", None), + IntField("id", 0), + FecTLVField("fec",None), + IntField("labelRMid",0)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.10. Label Withdraw Message + +class LDPLabelWM(Packet): + name = "LDPLabelWM" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0402, 15), + ShortField("len", None), + IntField("id", 0), + FecTLVField("fec",None), + LabelTLVField("label",0)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.5.11. Label Release Message + +class LDPLabelRelM(Packet): + name = "LDPLabelRelM" + fields_desc = [ BitField("u",0,1), + XBitField("type", 0x0403, 15), + ShortField("len", None), + IntField("id", 0), + FecTLVField("fec",None), + LabelTLVField("label",0)] + def post_build(self, p, pay): + if self.len is None: + l = len(p) - 4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + + +# 3.1. LDP PDUs +class LDP(Packet): + name = "LDP" + fields_desc = [ ShortField("version",1), + ShortField("len", None), + IPField("id","127.0.0.1"), + ShortField("space",0) ] + def post_build(self, p, pay): + if self.len is None: + l = len(p)+len(pay)-4 + p = p[:2]+struct.pack("!H", l)+p[4:] + return p+pay + def guess_payload_class(self, p): + return guess_payload(p) + +bind_layers( TCP, LDP, sport=646, dport=646 ) +bind_layers( UDP, LDP, sport=646, dport=646 ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/mpls.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/mpls.py new file mode 100644 index 00000000..037278c5 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/mpls.py @@ -0,0 +1,17 @@ +# http://trac.secdev.org/scapy/ticket/31 + +# scapy.contrib.description = MPLS +# scapy.contrib.status = loads + +from scapy.packet import Packet,bind_layers +from scapy.fields import BitField,ByteField +from scapy.layers.l2 import Ether + +class MPLS(Packet): + name = "MPLS" + fields_desc = [ BitField("label", 3, 20), + BitField("cos", 0, 3), + BitField("s", 1, 1), + ByteField("ttl", 0) ] + +bind_layers(Ether, MPLS, type=0x8847) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ospf.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ospf.py new file mode 100644 index 00000000..a6422bd8 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ospf.py @@ -0,0 +1,833 @@ +#!/usr/bin/env python + +# scapy.contrib.description = OSPF +# scapy.contrib.status = loads + +""" +OSPF extension for Scapy <http://www.secdev.org/scapy> + +This module provides Scapy layers for the Open Shortest Path First +routing protocol as defined in RFC 2328 and RFC 5340. + +Copyright (c) 2008 Dirk Loss : mail dirk-loss de +Copyright (c) 2010 Jochen Bartl : jochen.bartl gmail com + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. +""" + + +from scapy.all import * + +EXT_VERSION = "v0.9.2" + + +class OSPFOptionsField(FlagsField): + + def __init__(self, name="options", default=0, size=8, + names=["MT", "E", "MC", "NP", "L", "DC", "O", "DN"]): + FlagsField.__init__(self, name, default, size, names) + + +_OSPF_types = {1: "Hello", + 2: "DBDesc", + 3: "LSReq", + 4: "LSUpd", + 5: "LSAck"} + + +class OSPF_Hdr(Packet): + name = "OSPF Header" + fields_desc = [ + ByteField("version", 2), + ByteEnumField("type", 1, _OSPF_types), + ShortField("len", None), + IPField("src", "1.1.1.1"), + IPField("area", "0.0.0.0"), # default: backbone + XShortField("chksum", None), + ShortEnumField("authtype", 0, {0:"Null", 1:"Simple", 2:"Crypto"}), + # Null or Simple Authentication + ConditionalField(XLongField("authdata", 0), lambda pkt:pkt.authtype != 2), + # Crypto Authentication + ConditionalField(XShortField("reserved", 0), lambda pkt:pkt.authtype == 2), + ConditionalField(ByteField("keyid", 1), lambda pkt:pkt.authtype == 2), + ConditionalField(ByteField("authdatalen", 0), lambda pkt:pkt.authtype == 2), + ConditionalField(XIntField("seq", 0), lambda pkt:pkt.authtype == 2), + # TODO: Support authdata (which is appended to the packets as if it were padding) + ] + + def post_build(self, p, pay): + # TODO: Remove LLS data from pay + # LLS data blocks may be attached to OSPF Hello and DD packets + # The length of the LLS block shall not be included into the length of OSPF packet + # See <http://tools.ietf.org/html/rfc5613> + p += pay + l = self.len + if l is None: + l = len(p) + p = p[:2] + struct.pack("!H", l) + p[4:] + if self.chksum is None: + if self.authtype == 2: + ck = 0 # Crypto, see RFC 2328, D.4.3 + else: + # Checksum is calculated without authentication data + # Algorithm is the same as in IP() + ck = checksum(p[:16] + p[24:]) + p = p[:12] + chr(ck >> 8) + chr(ck & 0xff) + p[14:] + # TODO: Handle Crypto: Add message digest (RFC 2328, D.4.3) + return p + + def hashret(self): + return struct.pack("H", self.area) + self.payload.hashret() + + def answers(self, other): + if (isinstance(other, OSPF_Hdr) and + self.area == other.area and + self.type == 5): # Only acknowledgements answer other packets + return self.payload.answers(other.payload) + return 0 + + +class OSPF_Hello(Packet): + name = "OSPF Hello" + fields_desc = [IPField("mask", "255.255.255.0"), + ShortField("hellointerval", 10), + OSPFOptionsField(), + ByteField("prio", 1), + IntField("deadinterval", 40), + IPField("router", "0.0.0.0"), + IPField("backup", "0.0.0.0"), + FieldListField("neighbors", [], IPField("", "0.0.0.0"), length_from=lambda pkt: (pkt.underlayer.len - 44))] + + def guess_payload_class(self, payload): + # check presence of LLS data block flag + if self.options & 0x10 == 0x10: + return OSPF_LLS_Hdr + else: + return Packet.guess_payload_class(self, payload) + + +class LLS_Generic_TLV(Packet): + name = "LLS Generic" + fields_desc = [ShortField("type", 1), + FieldLenField("len", None, length_of=lambda x: x.val), + StrLenField("val", "", length_from=lambda x: x.len)] + + def guess_payload_class(self, p): + return conf.padding_layer + + +class LLS_ExtendedOptionsField(FlagsField): + + def __init__(self, name="options", default=0, size=32, + names=["LR", "RS"]): + FlagsField.__init__(self, name, default, size, names) + + +class LLS_Extended_Options(LLS_Generic_TLV): + name = "LLS Extended Options and Flags" + fields_desc = [ShortField("type", 1), + ShortField("len", 4), + LLS_ExtendedOptionsField()] + + +class LLS_Crypto_Auth(LLS_Generic_TLV): + name = "LLS Cryptographic Authentication" + fields_desc = [ShortField("type", 2), + FieldLenField("len", 20, fmt="B", length_of=lambda x: x.authdata), + XIntField("sequence", "\x00\x00\x00\x00"), + StrLenField("authdata", "\x00" * 16, length_from=lambda x: x.len)] + + def post_build(self, p, pay): + p += pay + l = self.len + + if l is None: + # length = len(sequence) + len(authdata) + len(payload) + l = len(p[3:]) + p = p[:2] + struct.pack("!H", l) + p[3:] + + return p + +_OSPF_LLSclasses = {1: "LLS_Extended_Options", + 2: "LLS_Crypto_Auth"} + + +def _LLSGuessPayloadClass(p, **kargs): + """ Guess the correct LLS class for a given payload """ + + cls = conf.raw_layer + if len(p) >= 4: + typ = struct.unpack("!H", p[0:2])[0] + clsname = _OSPF_LLSclasses.get(typ, "LLS_Generic_TLV") + cls = globals()[clsname] + return cls(p, **kargs) + + +class OSPF_LLS_Hdr(Packet): + name = "OSPF Link-local signaling" + fields_desc = [XShortField("chksum", None), + # FIXME Length should be displayed in 32-bit words + ShortField("len", None), + PacketListField("llstlv", [], _LLSGuessPayloadClass)] + + def post_build(self, p, pay): + p += pay + l = self.len + if l is None: + # Length in 32-bit words + l = len(p) / 4 + p = p[:2] + struct.pack("!H", l) + p[4:] + if self.chksum is None: + c = checksum(p) + p = chr((c >> 8) & 0xff) + chr(c & 0xff) + p[2:] + return p + +_OSPF_LStypes = {1: "router", + 2: "network", + 3: "summaryIP", + 4: "summaryASBR", + 5: "external", + 7: "NSSAexternal"} + +_OSPF_LSclasses = {1: "OSPF_Router_LSA", + 2: "OSPF_Network_LSA", + 3: "OSPF_SummaryIP_LSA", + 4: "OSPF_SummaryASBR_LSA", + 5: "OSPF_External_LSA", + 7: "OSPF_NSSA_External_LSA"} + + +def ospf_lsa_checksum(lsa): + """ Fletcher checksum for OSPF LSAs, returned as a 2 byte string. + + Give the whole LSA packet as argument. + For details on the algorithm, see RFC 2328 chapter 12.1.7 and RFC 905 Annex B. + """ + # This is based on the GPLed C implementation in Zebra <http://www.zebra.org/> + + CHKSUM_OFFSET = 16 + + if len(lsa) < CHKSUM_OFFSET: + raise Exception("LSA Packet too short (%s bytes)" % len(lsa)) + + c0 = c1 = 0 + # Calculation is done with checksum set to zero + lsa = lsa[:CHKSUM_OFFSET] + "\x00\x00" + lsa[CHKSUM_OFFSET + 2:] + for char in lsa[2:]: # leave out age + c0 += ord(char) + c1 += c0 + + c0 %= 255 + c1 %= 255 + + x = ((len(lsa) - CHKSUM_OFFSET - 1) * c0 - c1) % 255 + + if (x <= 0): + x += 255 + + y = 510 - c0 - x + + if (y > 255): + y -= 255 + #checksum = (x << 8) + y + + return chr(x) + chr(y) + + +class OSPF_LSA_Hdr(Packet): + name = "OSPF LSA Header" + fields_desc = [ShortField("age", 1), + OSPFOptionsField(), + ByteEnumField("type", 1, _OSPF_LStypes), + IPField("id", "192.168.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", 0), + ShortField("len", 36)] + + def extract_padding(self, s): + return "", s + + +_OSPF_Router_LSA_types = {1: "p2p", + 2: "transit", + 3: "stub", + 4: "virtual"} + + +class OSPF_Link(Packet): + name = "OSPF Link" + fields_desc = [IPField("id", "192.168.0.0"), + IPField("data", "255.255.255.0"), + ByteEnumField("type", 3, _OSPF_Router_LSA_types), + ByteField("toscount", 0), + ShortField("metric", 10), + # TODO: define correct conditions + ConditionalField(ByteField("tos", 0), lambda pkt: False), + ConditionalField(ByteField("reserved", 0), lambda pkt: False), + ConditionalField(ShortField("tosmetric", 0), lambda pkt: False)] + + def extract_padding(self, s): + return "", s + + +def _LSAGuessPayloadClass(p, **kargs): + """ Guess the correct LSA class for a given payload """ + # This is heavily based on scapy-cdp.py by Nicolas Bareil and Arnaud Ebalard + # XXX: This only works if all payload + cls = conf.raw_layer + if len(p) >= 4: + typ = struct.unpack("!B", p[3])[0] + clsname = _OSPF_LSclasses.get(typ, "Raw") + cls = globals()[clsname] + return cls(p, **kargs) + + +class OSPF_BaseLSA(Packet): + """ An abstract base class for Link State Advertisements """ + + def post_build(self, p, pay): + length = self.len + if length is None: + length = len(p) + p = p[:18] + struct.pack("!H", length) + p[20:] + if self.chksum is None: + chksum = ospf_lsa_checksum(p) + p = p[:16] + chksum + p[18:] + return p # p+pay? + + def extract_padding(self, s): + length = self.len + return "", s + + +class OSPF_Router_LSA(OSPF_BaseLSA): + name = "OSPF Router LSA" + fields_desc = [ShortField("age", 1), + OSPFOptionsField(), + ByteField("type", 1), + IPField("id", "1.1.1.1"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + FlagsField("flags", 0, 8, ["B", "E", "V", "W", "Nt"]), + ByteField("reserved", 0), + FieldLenField("linkcount", None, count_of="linklist"), + PacketListField("linklist", [], OSPF_Link, + count_from=lambda pkt: pkt.linkcount, + length_from=lambda pkt: pkt.linkcount * 12)] + + +class OSPF_Network_LSA(OSPF_BaseLSA): + name = "OSPF Network LSA" + fields_desc = [ShortField("age", 1), + OSPFOptionsField(), + ByteField("type", 2), + IPField("id", "192.168.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + IPField("mask", "255.255.255.0"), + FieldListField("routerlist", [], IPField("", "1.1.1.1"), + length_from=lambda pkt: pkt.len - 24)] + + +class OSPF_SummaryIP_LSA(OSPF_BaseLSA): + name = "OSPF Summary LSA (IP Network)" + fields_desc = [ShortField("age", 1), + OSPFOptionsField(), + ByteField("type", 3), + IPField("id", "192.168.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + IPField("mask", "255.255.255.0"), + ByteField("reserved", 0), + X3BytesField("metric", 10), + # TODO: Define correct conditions + ConditionalField(ByteField("tos", 0), lambda pkt:False), + ConditionalField(X3BytesField("tosmetric", 0), lambda pkt:False)] + + +class OSPF_SummaryASBR_LSA(OSPF_SummaryIP_LSA): + name = "OSPF Summary LSA (AS Boundary Router)" + type = 4 + id = "2.2.2.2" + mask = "0.0.0.0" + metric = 20 + + +class OSPF_External_LSA(OSPF_BaseLSA): + name = "OSPF External LSA (ASBR)" + fields_desc = [ShortField("age", 1), + OSPFOptionsField(), + ByteField("type", 5), + IPField("id", "192.168.0.0"), + IPField("adrouter", "2.2.2.2"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + IPField("mask", "255.255.255.0"), + FlagsField("ebit", 0, 1, ["E"]), + BitField("reserved", 0, 7), + X3BytesField("metric", 20), + IPField("fwdaddr", "0.0.0.0"), + XIntField("tag", 0), + # TODO: Define correct conditions + ConditionalField(ByteField("tos", 0), lambda pkt:False), + ConditionalField(X3BytesField("tosmetric", 0), lambda pkt:False)] + + +class OSPF_NSSA_External_LSA(OSPF_External_LSA): + name = "OSPF NSSA External LSA" + type = 7 + + +class OSPF_DBDesc(Packet): + name = "OSPF Database Description" + fields_desc = [ShortField("mtu", 1500), + OSPFOptionsField(), + FlagsField("dbdescr", 0, 8, ["MS", "M", "I", "R", "4", "3", "2", "1"]), + IntField("ddseq", 1), + PacketListField("lsaheaders", None, OSPF_LSA_Hdr, + count_from = lambda pkt: None, + length_from = lambda pkt: pkt.underlayer.len - 24 - 8)] + + def guess_payload_class(self, payload): + # check presence of LLS data block flag + if self.options & 0x10 == 0x10: + return OSPF_LLS_Hdr + else: + return Packet.guess_payload_class(self, payload) + + +class OSPF_LSReq_Item(Packet): + name = "OSPF Link State Request (item)" + fields_desc = [IntEnumField("type", 1, _OSPF_LStypes), + IPField("id", "1.1.1.1"), + IPField("adrouter", "1.1.1.1")] + + def extract_padding(self, s): + return "", s + + +class OSPF_LSReq(Packet): + name = "OSPF Link State Request (container)" + fields_desc = [PacketListField("requests", None, OSPF_LSReq_Item, + count_from = lambda pkt:None, + length_from = lambda pkt:pkt.underlayer.len - 24)] + + +class OSPF_LSUpd(Packet): + name = "OSPF Link State Update" + fields_desc = [FieldLenField("lsacount", None, fmt="!I", count_of="lsalist"), + PacketListField("lsalist", [], _LSAGuessPayloadClass, + count_from = lambda pkt: pkt.lsacount, + length_from = lambda pkt: pkt.underlayer.len - 24)] + + +class OSPF_LSAck(Packet): + name = "OSPF Link State Acknowledgement" + fields_desc = [PacketListField("lsaheaders", None, OSPF_LSA_Hdr, + count_from = lambda pkt: None, + length_from = lambda pkt: pkt.underlayer.len - 24)] + + def answers(self, other): + if isinstance(other, OSPF_LSUpd): + for reqLSA in other.lsalist: + for ackLSA in self.lsaheaders: + if (reqLSA.type == ackLSA.type and + reqLSA.seq == ackLSA.seq): + return 1 + return 0 + + +#------------------------------------------------------------------------------ +# OSPFv3 +#------------------------------------------------------------------------------ +# TODO: Add length_from / adjust functionality to IP6Field and remove this class +class OspfIP6Field(StrField, IP6Field): + """ + Special IP6Field for prefix fields in OSPFv3 LSAs + """ + + def __init__(self, name, default, length=None, length_from=None): + StrField.__init__(self, name, default) + self.length_from = length_from + if length is not None: + self.length_from = lambda pkt, length = length: length + + def any2i(self, pkt, x): + return IP6Field.any2i(self, pkt, x) + + def i2repr(self, pkt, x): + return IP6Field.i2repr(self, pkt, x) + + def h2i(self, pkt, x): + return IP6Field.h2i(self, pkt, x) + + def i2m(self, pkt, x): + x = inet_pton(socket.AF_INET6, x) + l = self.length_from(pkt) + l = self.prefixlen_to_bytelen(l) + + return x[:l] + + def m2i(self, pkt, x): + l = self.length_from(pkt) + + prefixlen = self.prefixlen_to_bytelen(l) + if l > 128: + warning("OspfIP6Field: Prefix length is > 128. Dissection of this packet will fail") + else: + pad = "\x00" * (16 - prefixlen) + x += pad + + return inet_ntop(socket.AF_INET6, x) + + def prefixlen_to_bytelen(self, l): + if l <= 32: + return 4 + elif l <= 64: + return 8 + elif l <= 96: + return 12 + else: + return 16 + + def i2len(self, pkt, x): + l = self.length_from(pkt) + l = self.prefixlen_to_bytelen(l) + + return l + + def getfield(self, pkt, s): + l = self.length_from(pkt) + l = self.prefixlen_to_bytelen(l) + + return s[l:], self.m2i(pkt, s[:l]) + + +class OSPFv3_Hdr(Packet): + name = "OSPFv3 Header" + fields_desc = [ByteField("version", 3), + ByteEnumField("type", 1, _OSPF_types), + ShortField("len", None), + IPField("src", "1.1.1.1"), + IPField("area", "0.0.0.0"), + XShortField("chksum", None), + ByteField("instance", 0), + ByteField("reserved", 0)] + + def post_build(self, p, pay): + p += pay + l = self.len + + if l is None: + l = len(p) + p = p[:2] + struct.pack("!H", l) + p[4:] + + if self.chksum is None: + chksum = in6_chksum(89, self.underlayer, p) + p = p[:12] + chr(chksum >> 8) + chr(chksum & 0xff) + p[14:] + + return p + + +class OSPFv3OptionsField(FlagsField): + + def __init__(self, name="options", default=0, size=24, + names=["V6", "E", "MC", "N", "R", "DC", "AF", "L", "I", "F"]): + FlagsField.__init__(self, name, default, size, names) + + +class OSPFv3_Hello(Packet): + name = "OSPFv3 Hello" + fields_desc = [IntField("intid", 0), + ByteField("prio", 1), + OSPFv3OptionsField(), + ShortField("hellointerval", 10), + ShortField("deadinterval", 40), + IPField("router", "0.0.0.0"), + IPField("backup", "0.0.0.0"), + FieldListField("neighbors", [], IPField("", "0.0.0.0"), + length_from=lambda pkt: (pkt.underlayer.len - 36))] + + +_OSPFv3_LStypes = {0x2001: "router", + 0x2002: "network", + 0x2003: "interAreaPrefix", + 0x2004: "interAreaRouter", + 0x4005: "asExternal", + 0x2007: "type7", + 0x0008: "link", + 0x2009: "intraAreaPrefix"} + +_OSPFv3_LSclasses = {0x2001: "OSPFv3_Router_LSA", + 0x2002: "OSPFv3_Network_LSA", + 0x2003: "OSPFv3_Inter_Area_Prefix_LSA", + 0x2004: "OSPFv3_Inter_Area_Router_LSA", + 0x4005: "OSPFv3_AS_External_LSA", + 0x2007: "OSPFv3_Type_7_LSA", + 0x0008: "OSPFv3_Link_LSA", + 0x2009: "OSPFv3_Intra_Area_Prefix_LSA"} + + +class OSPFv3_LSA_Hdr(Packet): + name = "OSPFv3 LSA Header" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x2001, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", 0), + ShortField("len", 36)] + + def extract_padding(self, s): + return "", s + + +def _OSPFv3_LSAGuessPayloadClass(p, **kargs): + """ Guess the correct OSPFv3 LSA class for a given payload """ + + cls = conf.raw_layer + + if len(p) >= 6: + typ = struct.unpack("!H", p[2:4])[0] + clsname = _OSPFv3_LSclasses.get(typ, "Raw") + cls = globals()[clsname] + + return cls(p, **kargs) + + +_OSPFv3_Router_LSA_types = {1: "p2p", + 2: "transit", + 3: "reserved", + 4: "virtual"} + + +class OSPFv3_Link(Packet): + name = "OSPFv3 Link" + fields_desc = [ByteEnumField("type", 1, _OSPFv3_Router_LSA_types), + ByteField("reserved", 0), + ShortField("metric", 10), + IntField("intid", 0), + IntField("neighintid", 0), + IPField("neighbor", "2.2.2.2")] + + def extract_padding(self, s): + return "", s + + +class OSPFv3_Router_LSA(OSPF_BaseLSA): + name = "OSPFv3 Router LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x2001, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + FlagsField("flags", 0, 8, ["B", "E", "V", "W"]), + OSPFv3OptionsField(), + PacketListField("linklist", [], OSPFv3_Link, + length_from=lambda pkt:pkt.len - 24)] + + +class OSPFv3_Network_LSA(OSPF_BaseLSA): + name = "OSPFv3 Network LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x2002, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + ByteField("reserved", 0), + OSPFv3OptionsField(), + FieldListField("routerlist", [], IPField("", "0.0.0.1"), + length_from=lambda pkt: pkt.len - 24)] + + +class OSPFv3PrefixOptionsField(FlagsField): + + def __init__(self, name="prefixoptions", default=0, size=8, + names=["NU", "LA", "MC", "P"]): + FlagsField.__init__(self, name, default, size, names) + + +class OSPFv3_Inter_Area_Prefix_LSA(OSPF_BaseLSA): + name = "OSPFv3 Inter Area Prefix LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x2003, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + ByteField("reserved", 0), + X3BytesField("metric", 10), + ByteField("prefixlen", 64), + OSPFv3PrefixOptionsField(), + ShortField("reserved2", 0), + OspfIP6Field("prefix", "2001:db8:0:42::", length_from=lambda pkt: pkt.prefixlen)] + + +class OSPFv3_Inter_Area_Router_LSA(OSPF_BaseLSA): + name = "OSPFv3 Inter Area Router LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x2004, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + ByteField("reserved", 0), + X3BytesField("metric", 1), + IPField("router", "2.2.2.2")] + + +class OSPFv3_AS_External_LSA(OSPF_BaseLSA): + name = "OSPFv3 AS External LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x4005, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + FlagsField("flags", 0, 8, ["T", "F", "E"]), + X3BytesField("metric", 20), + ByteField("prefixlen", 64), + OSPFv3PrefixOptionsField(), + ShortEnumField("reflstype", 0, _OSPFv3_LStypes), + OspfIP6Field("prefix", "2001:db8:0:42::", length_from=lambda pkt: pkt.prefixlen), + ConditionalField(IP6Field("fwaddr", "::"), lambda pkt: pkt.flags & 0x02 == 0x02), + ConditionalField(IntField("tag", 0), lambda pkt: pkt.flags & 0x01 == 0x01), + ConditionalField(IPField("reflsid", 0), lambda pkt: pkt.reflstype != 0)] + + +class OSPFv3_Type_7_LSA(OSPFv3_AS_External_LSA): + name = "OSPFv3 Type 7 LSA" + type = 0x2007 + + +class OSPFv3_Prefix_Item(Packet): + name = "OSPFv3 Link Prefix Item" + fields_desc = [ByteField("prefixlen", 64), + OSPFv3PrefixOptionsField(), + ShortField("metric", 10), + OspfIP6Field("prefix", "2001:db8:0:42::", length_from=lambda pkt: pkt.prefixlen)] + + def extract_padding(self, s): + return "", s + + +class OSPFv3_Link_LSA(OSPF_BaseLSA): + name = "OSPFv3 Link LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x0008, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + ByteField("prio", 1), + OSPFv3OptionsField(), + IP6Field("lladdr", "fe80::"), + IntField("prefixes", 0), + PacketListField("prefixlist", None, OSPFv3_Prefix_Item, + count_from = lambda pkt: pkt.prefixes)] + + +class OSPFv3_Intra_Area_Prefix_LSA(OSPF_BaseLSA): + name = "OSPFv3 Intra Area Prefix LSA" + fields_desc = [ShortField("age", 1), + ShortEnumField("type", 0x2009, _OSPFv3_LStypes), + IPField("id", "0.0.0.0"), + IPField("adrouter", "1.1.1.1"), + XIntField("seq", 0x80000001), + XShortField("chksum", None), + ShortField("len", None), + ShortField("prefixes", 0), + ShortEnumField("reflstype", 0, _OSPFv3_LStypes), + IPField("reflsid", "0.0.0.0"), + IPField("refadrouter", "0.0.0.0"), + PacketListField("prefixlist", None, OSPFv3_Prefix_Item, + count_from = lambda pkt: pkt.prefixes)] + + +class OSPFv3_DBDesc(Packet): + name = "OSPFv3 Database Description" + fields_desc = [ByteField("reserved", 0), + OSPFv3OptionsField(), + ShortField("mtu", 1500), + ByteField("reserved2", 0), + FlagsField("dbdescr", 0, 8, ["MS", "M", "I", "R"]), + IntField("ddseq", 1), + PacketListField("lsaheaders", None, OSPFv3_LSA_Hdr, + count_from = lambda pkt:None, + length_from = lambda pkt:pkt.underlayer.len - 28)] + + +class OSPFv3_LSReq_Item(Packet): + name = "OSPFv3 Link State Request (item)" + fields_desc = [ShortField("reserved", 0), + ShortEnumField("type", 0x2001, _OSPFv3_LStypes), + IPField("id", "1.1.1.1"), + IPField("adrouter", "1.1.1.1")] + + def extract_padding(self, s): + return "", s + + +class OSPFv3_LSReq(Packet): + name = "OSPFv3 Link State Request (container)" + fields_desc = [PacketListField("requests", None, OSPFv3_LSReq_Item, + count_from = lambda pkt:None, + length_from = lambda pkt:pkt.underlayer.len - 16)] + + +class OSPFv3_LSUpd(Packet): + name = "OSPFv3 Link State Update" + fields_desc = [FieldLenField("lsacount", None, fmt="!I", count_of="lsalist"), + PacketListField("lsalist", [], _OSPFv3_LSAGuessPayloadClass, + count_from = lambda pkt:pkt.lsacount, + length_from = lambda pkt:pkt.underlayer.len - 16)] + + +class OSPFv3_LSAck(Packet): + name = "OSPFv3 Link State Acknowledgement" + fields_desc = [PacketListField("lsaheaders", None, OSPFv3_LSA_Hdr, + count_from = lambda pkt:None, + length_from = lambda pkt:pkt.underlayer.len - 16)] + + +bind_layers(IP, OSPF_Hdr, proto=89) +bind_layers(OSPF_Hdr, OSPF_Hello, type=1) +bind_layers(OSPF_Hdr, OSPF_DBDesc, type=2) +bind_layers(OSPF_Hdr, OSPF_LSReq, type=3) +bind_layers(OSPF_Hdr, OSPF_LSUpd, type=4) +bind_layers(OSPF_Hdr, OSPF_LSAck, type=5) + +bind_layers(IPv6, OSPFv3_Hdr, nh=89) +bind_layers(OSPFv3_Hdr, OSPFv3_Hello, type=1) +bind_layers(OSPFv3_Hdr, OSPFv3_DBDesc, type=2) +bind_layers(OSPFv3_Hdr, OSPFv3_LSReq, type=3) +bind_layers(OSPFv3_Hdr, OSPFv3_LSUpd, type=4) +bind_layers(OSPFv3_Hdr, OSPFv3_LSAck, type=5) + + +if __name__ == "__main__": + interact(mydict=globals(), mybanner="OSPF extension %s" % EXT_VERSION) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi.py new file mode 100644 index 00000000..f4364096 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi.py @@ -0,0 +1,86 @@ +## This file is (hopefully) part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## <jellch@harris.com> +## This program is published under a GPLv2 license + +# scapy.contrib.description = PPI +# scapy.contrib.status = loads + + +""" +PPI (Per-Packet Information). +""" +import logging,struct +from scapy.config import conf +from scapy.packet import * +from scapy.fields import * +from scapy.layers.l2 import Ether +from scapy.layers.dot11 import Dot11 + +# Dictionary to map the TLV type to the class name of a sub-packet +_ppi_types = {} +def addPPIType(id, value): + _ppi_types[id] = value +def getPPIType(id, default="default"): + return _ppi_types.get(id, _ppi_types.get(default, None)) + + +# Default PPI Field Header +class PPIGenericFldHdr(Packet): + name = "PPI Field Header" + fields_desc = [ LEShortField('pfh_type', 0), + FieldLenField('pfh_length', None, length_of="value", fmt='<H', adjust=lambda p,x:x+4), + StrLenField("value", "", length_from=lambda p:p.pfh_length) ] + + def extract_padding(self, p): + return "",p + +def _PPIGuessPayloadClass(p, **kargs): + """ This function tells the PacketListField how it should extract the + TLVs from the payload. We pass cls only the length string + pfh_len says it needs. If a payload is returned, that means + part of the sting was unused. This converts to a Raw layer, and + the remainder of p is added as Raw's payload. If there is no + payload, the remainder of p is added as out's payload. + """ + if len(p) >= 4: + t,pfh_len = struct.unpack("<HH", p[:4]) + # Find out if the value t is in the dict _ppi_types. + # If not, return the default TLV class + cls = getPPIType(t, "default") + pfh_len += 4 + out = cls(p[:pfh_len], **kargs) + if (out.payload): + out.payload = conf.raw_layer(out.payload.load) + if (len(p) > pfh_len): + out.payload.payload = conf.padding_layer(p[pfh_len:]) + elif (len(p) > pfh_len): + out.payload = conf.padding_layer(p[pfh_len:]) + + else: + out = conf.raw_layer(p, **kargs) + return out + + + + +class PPI(Packet): + name = "PPI Packet Header" + fields_desc = [ ByteField('pph_version', 0), + ByteField('pph_flags', 0), + FieldLenField('pph_len', None, length_of="PPIFieldHeaders", fmt="<H", adjust=lambda p,x:x+8 ), + LEIntField('dlt', None), + PacketListField("PPIFieldHeaders", [], _PPIGuessPayloadClass, length_from=lambda p:p.pph_len-8,) ] + def guess_payload_class(self,payload): + return conf.l2types.get(self.dlt, Packet.guess_payload_class(self, payload)) + +#Register PPI +addPPIType("default", PPIGenericFldHdr) + +conf.l2types.register(192, PPI) +conf.l2types.register_num2layer(192, PPI) + +bind_layers(PPI, Dot11, dlt=conf.l2types.get(Dot11)) +bind_layers(Dot11, PPI) +bind_layers(PPI, Ether, dlt=conf.l2types.get(Ether)) +bind_layers(Dot11, Ether) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi_cace.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi_cace.py new file mode 100644 index 00000000..ba2c4abf --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi_cace.py @@ -0,0 +1,87 @@ +## This file is (hopefully) part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## <jellch@harris.com> +## This program is published under a GPLv2 license + +# scapy.contrib.description = PPI CACE +# scapy.contrib.status = loads + +""" +CACE PPI types +""" +import logging,struct +from scapy.config import conf +from scapy.packet import * +from scapy.fields import * +from scapy.layers.l2 import Ether +from scapy.layers.dot11 import Dot11 +from scapy.contrib.ppi import * + +PPI_DOT11COMMON = 2 +PPI_DOT11NMAC = 3 +PPI_DOT11NMACPHY = 4 +PPI_SPECTRUMMAP = 5 +PPI_PROCESSINFO = 6 +PPI_CAPTUREINFO = 7 +PPI_AGGREGATION = 8 +PPI_DOT3 = 9 + +# PPI 802.11 Common Field Header Fields +class dBmByteField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "b") + def i2repr(self, pkt, val): + if (val != None): + val = "%4d dBm" % val + return val + +class PPITSFTField(LELongField): + def i2h(self, pkt, val): + flags = 0 + if (pkt): + flags = pkt.getfieldval("Pkt_Flags") + if not flags: + flags = 0 + if (flags & 0x02): + scale = 1e-3 + else: + scale = 1e-6 + tout = scale * float(val) + return tout + def h2i(self, pkt, val): + scale = 1e6 + if pkt: + flags = pkt.getfieldval("Pkt_Flags") + if flags: + if (flags & 0x02): + scale = 1e3 + tout = int((scale * val) + 0.5) + return tout + +_PPIDot11CommonChFlags = ['','','','','Turbo','CCK','OFDM','2GHz','5GHz', + 'PassiveOnly','Dynamic CCK-OFDM','GSFK'] + +_PPIDot11CommonPktFlags = ['FCS','TSFT_ms','FCS_Invalid','PHY_Error'] + +# PPI 802.11 Common Field Header +class Dot11Common(Packet): + name = "PPI 802.11-Common" + fields_desc = [ LEShortField('pfh_type',PPI_DOT11COMMON), + LEShortField('pfh_length', 20), + PPITSFTField('TSF_Timer', 0), + FlagsField('Pkt_Flags',0, -16, _PPIDot11CommonPktFlags), + LEShortField('Rate',0), + LEShortField('Ch_Freq',0), + FlagsField('Ch_Flags', 0, -16, _PPIDot11CommonChFlags), + ByteField('FHSS_Hop',0), + ByteField('FHSS_Pat',0), + dBmByteField('Antsignal',-128), + dBmByteField('Antnoise',-128)] + + def extract_padding(self, p): + return "",p +#Hopefully other CACE defined types will be added here. + +#Add the dot11common layer to the PPI array +addPPIType(PPI_DOT11COMMON, Dot11Common) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi_geotag.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi_geotag.py new file mode 100644 index 00000000..19371512 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ppi_geotag.py @@ -0,0 +1,464 @@ +## This file is (hopefully) part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## <jellch@harris.com> +## This program is published under a GPLv2 license + +# scapy.contrib.description = PPI GEOLOCATION +# scapy.contrib.status = loads + + +""" +PPI-GEOLOCATION tags +""" +import struct +from scapy.packet import * +from scapy.fields import * +from scapy.contrib.ppi import PPIGenericFldHdr,addPPIType + +CURR_GEOTAG_VER = 2 #Major revision of specification + +PPI_GPS = 30002 +PPI_VECTOR = 30003 +PPI_SENSOR = 30004 +PPI_ANTENNA = 30005 +#The FixedX_Y Fields are used to store fixed point numbers in a variety of fields in the GEOLOCATION-TAGS specification +class Fixed3_6Field(LEIntField): + def i2h(self, pkt, x): + if x is not None: + if (x < 0): + warning("Fixed3_6: Internal value too negative: %d" % x) + x = 0 + elif (x > 999999999): + warning("Fixed3_6: Internal value too positive: %d" % x) + x = 999999999 + x = x * 1e-6 + return x + def h2i(self, pkt, x): + if x is not None: + if (x <= -0.5e-6): + warning("Fixed3_6: Input value too negative: %.7f" % x) + x = 0 + elif (x >= 999.9999995): + warning("Fixed3_6: Input value too positive: %.7f" % x) + x = 999.999999 + x = int(round(x * 1e6)) + return x + def i2m(self, pkt, x): + """Convert internal value to machine value""" + if x is None: + #Try to return zero if undefined + x = self.h2i(pkt, 0) + return x + + def i2repr(self,pkt,x): + if x is None: + y=0 + else: + y=self.i2h(pkt,x) + return "%3.6f"%(y) +class Fixed3_7Field(LEIntField): + def i2h(self, pkt, x): + if x is not None: + if (x < 0): + warning("Fixed3_7: Internal value too negative: %d" % x) + x = 0 + elif (x > 3600000000): + warning("Fixed3_7: Internal value too positive: %d" % x) + x = 3600000000 + x = (x - 1800000000) * 1e-7 + return x + def h2i(self, pkt, x): + if x is not None: + if (x <= -180.00000005): + warning("Fixed3_7: Input value too negative: %.8f" % x) + x = -180.0 + elif (x >= 180.00000005): + warning("Fixed3_7: Input value too positive: %.8f" % x) + x = 180.0 + x = int(round((x + 180.0) * 1e7)) + return x + def i2m(self, pkt, x): + """Convert internal value to machine value""" + if x is None: + #Try to return zero if undefined + x = self.h2i(pkt, 0) + return x + def i2repr(self,pkt,x): + if x is None: + y=0 + else: + y=self.i2h(pkt,x) + return "%3.7f"%(y) + +class Fixed6_4Field(LEIntField): + def i2h(self, pkt, x): + if x is not None: + if (x < 0): + warning("Fixed6_4: Internal value too negative: %d" % x) + x = 0 + elif (x > 3600000000): + warning("Fixed6_4: Internal value too positive: %d" % x) + x = 3600000000 + x = (x - 1800000000) * 1e-4 + return x + def h2i(self, pkt, x): + if x is not None: + if (x <= -180000.00005): + warning("Fixed6_4: Input value too negative: %.5f" % x) + x = -180000.0 + elif (x >= 180000.00005): + warning("Fixed6_4: Input value too positive: %.5f" % x) + x = 180000.0 + x = int(round((x + 180000.0) * 1e4)) + return x + def i2m(self, pkt, x): + """Convert internal value to machine value""" + if x is None: + #Try to return zero if undefined + x = self.h2i(pkt, 0) + return x + def i2repr(self,pkt,x): + if x is None: + y=0 + else: + y=self.i2h(pkt,x) + return "%6.4f"%(y) +#The GPS timestamps fractional time counter is stored in a 32-bit unsigned ns counter. +#The ept field is as well, +class NSCounter_Field(LEIntField): + def i2h(self, pkt, x): #converts nano-seconds to seconds for output + if x is not None: + if (x < 0): + warning("NSCounter_Field: Internal value too negative: %d" % x) + x = 0 + elif (x >= 2**32): + warning("NSCounter_Field: Internal value too positive: %d" % x) + x = 2**32-1 + x = (x / 1e9) + return x + def h2i(self, pkt, x): #converts input in seconds into nano-seconds for storage + if x is not None: + if (x < 0): + warning("NSCounter_Field: Input value too negative: %.10f" % x) + x = 0 + elif (x >= (2**32) / 1e9): + warning("NSCounter_Field: Input value too positive: %.10f" % x) + x = (2**32-1) / 1e9 + x = int(round((x * 1e9))) + return x + def i2repr(self,pkt,x): + if x is None: + y=0 + else: + y=self.i2h(pkt,x) + return "%1.9f"%(y) + +class UTCTimeField(IntField): + def __init__(self, name, default, epoch=time.gmtime(0), strf="%a, %d %b %Y %H:%M:%S +0000"): + IntField.__init__(self, name, default) + self.epoch = epoch + self.delta = time.mktime(epoch) - time.mktime(time.gmtime(0)) + self.strf = strf + def i2repr(self, pkt, x): + if x is None: + x = 0 + x = int(x) + self.delta + t = time.strftime(self.strf, time.gmtime(x)) + return "%s (%d)" % (t, x) + +class LETimeField(UTCTimeField,LEIntField): + def __init__(self, name, default, epoch=time.gmtime(0), strf="%a, %d %b %Y %H:%M:%S +0000"): + LEIntField.__init__(self, name, default) + self.epoch = epoch + self.delta = time.mktime(epoch) - time.mktime(time.gmtime(0)) + self.strf = strf + +class SignedByteField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "b") + def randval(self): + return RandSByte() + +class XLEShortField(LEShortField,XShortField): + def i2repr(self, pkt, x): + return XShortField.i2repr(self, pkt, x) + +class XLEIntField(LEIntField,XIntField): + def i2repr(self, pkt, x): + return XIntField.i2repr(self, pkt, x) + +class GPSTime_Field(LETimeField): + def __init__(self, name, default): + return LETimeField.__init__(self, name, default, strf="%a, %d %b %Y %H:%M:%S UTC") + +class VectorFlags_Field(XLEIntField): + """Represents te VectorFlags field. Handles the RelativeTo:sub-field""" + _fwdstr = "DefinesForward" + _resmask = 0xfffffff8 + _relmask = 0x6 + _relnames = ["RelativeToForward", "RelativeToEarth", "RelativeToCurrent", "RelativeToReserved"] + _relvals = [0x00, 0x02, 0x04, 0x06] + def i2repr(self, pkt, x): + if x is None: + return str(x) + r = [] + if (x & 0x1): + r.append(self._fwdstr) + i = (x & self._relmask) >> 1 + r.append(self._relnames[i]) + i = x & self._resmask + if (i): + r.append("ReservedBits:%08X" % i) + sout = "+".join(r) + return sout + def any2i(self, pkt, x): + if type(x) is str: + r = x.split("+") + y = 0 + for value in r: + if (value == self._fwdstr): + y |= 0x1 + elif (value in self._relnames): + i = self._relnames.index(value) + y &= (~self._relmask) + y |= self._relvals[i] + else: + #logging.warning("Unknown VectorFlags Argument: %s" % value) + pass + else: + y = x + #print "any2i: %s --> %s" % (str(x), str(y)) + return y + +class HCSIFlagsField(FlagsField): + """ A FlagsField where each bit/flag turns a conditional field on or off. + If the value is None when building a packet, i2m() will check the value of + every field in self.names. If the field's value is not None, the corresponding + flag will be set. """ + def i2m(self, pkt, val): + if val is None: + val = 0 + if (pkt): + for i in range(len(self.names)): + name = self.names[i][0] + value = pkt.getfieldval(name) + if value is not None: + val |= 1 << i + return val + +class HCSINullField(StrFixedLenField): + def __init__(self, name, default): + return StrFixedLenField.__init__(self, name, default, length=0) + +class HCSIDescField(StrFixedLenField): + def __init__(self, name, default): + return StrFixedLenField.__init__(self, name, default, length=32) + +class HCSIAppField(StrFixedLenField): + def __init__(self, name, default): + return StrFixedLenField.__init__(self, name, default, length=60) + +def _FlagsList(myfields): + flags = [] + for i in range(32): + flags.append("Reserved%02d" % i) + for i in myfields.keys(): + flags[i] = myfields[i] + return flags + +# Define all geolocation-tag flags lists +_hcsi_gps_flags = _FlagsList({0:"No Fix Available", 1:"GPS", 2:"Differential GPS", + 3:"Pulse Per Second", 4:"Real Time Kinematic", + 5:"Float Real Time Kinematic", 6:"Estimated (Dead Reckoning)", + 7:"Manual Input", 8:"Simulation"}) + +#_hcsi_vector_flags = _FlagsList({0:"ForwardFrame", 1:"RotationsAbsoluteXYZ", 5:"OffsetFromGPS_XYZ"}) +#This has been replaced with the VectorFlags_Field class, in order to handle the RelativeTo:subfield + +_hcsi_vector_char_flags = _FlagsList({0:"Antenna", 1:"Direction of Travel", + 2:"Front of Vehicle", 3:"Angle of Arrival", 4:"Transmitter Position", + 8:"GPS Derived", 9:"INS Derived", 10:"Compass Derived", + 11:"Acclerometer Derived", 12:"Human Derived"}) + +_hcsi_antenna_flags = _FlagsList({ 1:"Horizontal Polarization", 2:"Vertical Polarization", + 3:"Circular Polarization Left", 4:"Circular Polarization Right", + 16:"Electronically Steerable", 17:"Mechanically Steerable"}) + +""" HCSI PPI Fields are similar to RadioTap. A mask field called "present" specifies if each field +is present. All other fields are conditional. When dissecting a packet, each field is present if +"present" has the corresponding bit set. When building a packet, if "present" is None, the mask is +set to include every field that does not have a value of None. Otherwise, if the mask field is +not None, only the fields specified by "present" will be added to the packet. + +To build each Packet type, build a list of the fields normally, excluding the present bitmask field. +The code will then construct conditional versions of each field and add the present field. +See GPS_Fields as an example. """ + +# Conditional test for all HCSI Fields +def _HCSITest(pkt, ibit, name): + if pkt.present is None: + return (pkt.getfieldval(name) is not None) + return pkt.present & ibit + +# Wrap optional fields in ConditionalField, add HCSIFlagsField +def _HCSIBuildFields(fields): + names = [f.name for f in fields] + cond_fields = [ HCSIFlagsField('present', None, -len(names), names)] + for i in range(len(names)): + ibit = 1 << i + seval = "lambda pkt:_HCSITest(pkt,%s,'%s')" % (ibit, names[i]) + test = eval(seval) + cond_fields.append(ConditionalField(fields[i], test)) + return cond_fields + +class HCSIPacket(Packet): + name = "PPI HCSI" + fields_desc = [ LEShortField('pfh_type', None), + LEShortField('pfh_length', None), + ByteField('geotag_ver', CURR_GEOTAG_VER), + ByteField('geotag_pad', 0), + LEShortField('geotag_len', None)] + def post_build(self, p, pay): + if self.pfh_length is None: + l = len(p) - 4 + sl = struct.pack('<H',l) + p = p[:2] + sl + p[4:] + if self.geotag_len is None: + l_g = len(p) - 4 + sl_g = struct.pack('<H',l_g) + p = p[:6] + sl_g + p[8:] + p += pay + return p + def extract_padding(self, p): + return "",p + +#GPS Fields +GPS_Fields = [FlagsField("GPSFlags", None, -32, _hcsi_gps_flags), + Fixed3_7Field("Latitude", None), + Fixed3_7Field("Longitude", None), Fixed6_4Field("Altitude", None), + Fixed6_4Field("Altitude_g", None), GPSTime_Field("GPSTime", None), + NSCounter_Field("FractionalTime", None), Fixed3_6Field("eph", None), + Fixed3_6Field("epv", None), NSCounter_Field("ept", None), + HCSINullField("Reserved10", None), HCSINullField("Reserved11", None), + HCSINullField("Reserved12", None), HCSINullField("Reserved13", None), + HCSINullField("Reserved14", None), HCSINullField("Reserved15", None), + HCSINullField("Reserved16", None), HCSINullField("Reserved17", None), + HCSINullField("Reserved18", None), HCSINullField("Reserved19", None), + HCSINullField("Reserved20", None), HCSINullField("Reserved21", None), + HCSINullField("Reserved22", None), HCSINullField("Reserved23", None), + HCSINullField("Reserved24", None), HCSINullField("Reserved25", None), + HCSINullField("Reserved26", None), HCSINullField("Reserved27", None), + HCSIDescField("DescString", None), XLEIntField("AppId", None), + HCSIAppField("AppData", None), HCSINullField("Extended", None)] + +class GPS(HCSIPacket): + name = "PPI GPS" + fields_desc = [ LEShortField('pfh_type', PPI_GPS), #pfh_type + LEShortField('pfh_length', None), #pfh_len + ByteField('geotag_ver', CURR_GEOTAG_VER), #base_geotag_header.ver + ByteField('geotag_pad', 0), #base_geotag_header.pad + LEShortField('geotag_len', None)] + _HCSIBuildFields(GPS_Fields) + + +#Vector Fields +VEC_Fields = [VectorFlags_Field("VectorFlags", None), + FlagsField("VectorChars", None, -32, _hcsi_vector_char_flags), + Fixed3_6Field("Pitch", None), Fixed3_6Field("Roll", None), + Fixed3_6Field("Heading", None), Fixed6_4Field("Off_X", None), + Fixed6_4Field("Off_Y", None), Fixed6_4Field("Off_Z", None), + HCSINullField("Reserved08", None), HCSINullField("Reserved09", None), + HCSINullField("Reserved10", None), HCSINullField("Reserved11", None), + HCSINullField("Reserved12", None), HCSINullField("Reserved13", None), + HCSINullField("Reserved14", None), HCSINullField("Reserved15", None), + Fixed3_6Field("Err_Rot", None), Fixed6_4Field("Err_Off", None), + HCSINullField("Reserved18", None), HCSINullField("Reserved19", None), + HCSINullField("Reserved20", None), HCSINullField("Reserved21", None), + HCSINullField("Reserved22", None), HCSINullField("Reserved23", None), + HCSINullField("Reserved24", None), HCSINullField("Reserved25", None), + HCSINullField("Reserved26", None), HCSINullField("Reserved27", None), + HCSIDescField("DescString", None), XLEIntField("AppId", None), + HCSIAppField("AppData", None), HCSINullField("Extended", None)] + +class Vector(HCSIPacket): + name = "PPI Vector" + fields_desc = [ LEShortField('pfh_type', PPI_VECTOR), #pfh_type + LEShortField('pfh_length', None), #pfh_len + ByteField('geotag_ver', CURR_GEOTAG_VER), #base_geotag_header.ver + ByteField('geotag_pad', 0), #base_geotag_header.pad + LEShortField('geotag_len', None)] + _HCSIBuildFields(VEC_Fields) + +#Sensor Fields +# http://www.iana.org/assignments/icmp-parameters +sensor_types= { 1 : "Velocity", + 2 : "Acceleration", + 3 : "Jerk", + 100 : "Rotation", + 101 : "Magnetic", + 1000: "Temperature", + 1001: "Barometer", + 1002: "Humidity", + 2000: "TDOA_Clock", + 2001: "Phase" + } +SENS_Fields = [ LEShortEnumField('SensorType', None, sensor_types), + SignedByteField('ScaleFactor', None), + Fixed6_4Field('Val_X', None), + Fixed6_4Field('Val_Y', None), + Fixed6_4Field('Val_Z', None), + Fixed6_4Field('Val_T', None), + Fixed6_4Field('Val_E', None), + HCSINullField("Reserved07", None), HCSINullField("Reserved08", None), + HCSINullField("Reserved09", None), HCSINullField("Reserved10", None), + HCSINullField("Reserved11", None), HCSINullField("Reserved12", None), + HCSINullField("Reserved13", None), HCSINullField("Reserved14", None), + HCSINullField("Reserved15", None), HCSINullField("Reserved16", None), + HCSINullField("Reserved17", None), HCSINullField("Reserved18", None), + HCSINullField("Reserved19", None), HCSINullField("Reserved20", None), + HCSINullField("Reserved21", None), HCSINullField("Reserved22", None), + HCSINullField("Reserved23", None), HCSINullField("Reserved24", None), + HCSINullField("Reserved25", None), HCSINullField("Reserved26", None), + HCSINullField("Reserved27", None), + HCSIDescField("DescString", None), XLEIntField("AppId", None), + HCSIAppField("AppData", None), HCSINullField("Extended", None)] + + + +class Sensor(HCSIPacket): + name = "PPI Sensor" + fields_desc = [ LEShortField('pfh_type', PPI_SENSOR), #pfh_type + LEShortField('pfh_length', None), #pfh_len + ByteField('geotag_ver', CURR_GEOTAG_VER ), #base_geotag_header.ver + ByteField('geotag_pad', 0), #base_geotag_header.pad + LEShortField('geotag_len', None)] + _HCSIBuildFields(SENS_Fields) + +# HCSIAntenna Fields +ANT_Fields = [FlagsField("AntennaFlags", None, -32, _hcsi_antenna_flags), + ByteField("Gain", None), + Fixed3_6Field("HorizBw", None), Fixed3_6Field("VertBw", None), + Fixed3_6Field("PrecisionGain",None), XLEShortField("BeamID", None), + HCSINullField("Reserved06", None), HCSINullField("Reserved07", None), + HCSINullField("Reserved08", None), HCSINullField("Reserved09", None), + HCSINullField("Reserved10", None), HCSINullField("Reserved11", None), + HCSINullField("Reserved12", None), HCSINullField("Reserved13", None), + HCSINullField("Reserved14", None), HCSINullField("Reserved15", None), + HCSINullField("Reserved16", None), HCSINullField("Reserved17", None), + HCSINullField("Reserved18", None), HCSINullField("Reserved19", None), + HCSINullField("Reserved20", None), HCSINullField("Reserved21", None), + HCSINullField("Reserved22", None), HCSINullField("Reserved23", None), + HCSINullField("Reserved24", None), HCSINullField("Reserved25", None), + HCSIDescField("SerialNumber", None), HCSIDescField("ModelName", None), + HCSIDescField("DescString", None), XLEIntField("AppId", None), + HCSIAppField("AppData", None), HCSINullField("Extended", None)] + +class Antenna(HCSIPacket): + name = "PPI Antenna" + fields_desc = [ LEShortField('pfh_type', PPI_ANTENNA), #pfh_type + LEShortField('pfh_length', None), #pfh_len + ByteField('geotag_ver', CURR_GEOTAG_VER), #base_geotag_header.ver + ByteField('geotag_pad', 0), #base_geotag_header.pad + LEShortField('geotag_len', None)] + _HCSIBuildFields(ANT_Fields) + +addPPIType(PPI_GPS, GPS) +addPPIType(PPI_VECTOR, Vector) +addPPIType(PPI_SENSOR, Sensor) +addPPIType(PPI_ANTENNA,Antenna) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ripng.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ripng.py new file mode 100644 index 00000000..47e17bc4 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ripng.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python + +# http://trac.secdev.org/scapy/ticket/301 + +# scapy.contrib.description = RIPng +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP +from scapy.layers.inet6 import * + +class RIPng(Packet): + name = "RIPng header" + fields_desc = [ + ByteEnumField("cmd", 1, {1 : "req", 2 : "resp"}), + ByteField("ver", 1), + ShortField("null", 0), + ] + +class RIPngEntry(Packet): + name = "RIPng entry" + fields_desc = [ + ConditionalField(IP6Field("prefix", "::"), + lambda pkt: pkt.metric != 255), + ConditionalField(IP6Field("nexthop", "::"), + lambda pkt: pkt.metric == 255), + ShortField("routetag", 0), + ByteField("prefixlen", 0), + ByteEnumField("metric", 1, {16 : "Unreach", + 255 : "next-hop entry"}) + ] + +bind_layers(UDP, RIPng, sport=521, dport=521) +bind_layers(RIPng, RIPngEntry) +bind_layers(RIPngEntry, RIPngEntry) + +if __name__ == "__main__": + from scapy.main import interact + interact(mydict=globals(), mybanner="RIPng") + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/rsvp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/rsvp.py new file mode 100644 index 00000000..c9d4ebee --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/rsvp.py @@ -0,0 +1,188 @@ +## RSVP layer + +# http://trac.secdev.org/scapy/ticket/197 + +# scapy.contrib.description = RSVP +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import IP + +rsvpmsgtypes = { 0x01 : "Path", + 0x02 : "Reservation request", + 0x03 : "Path error", + 0x04 : "Reservation request error", + 0x05 : "Path teardown", + 0x06 : "Reservation teardown", + 0x07 : "Reservation request acknowledgment" +} + +class RSVP(Packet): + name = "RSVP" + fields_desc = [ BitField("Version",1,4), + BitField("Flags",1,4), + ByteEnumField("Class",0x01, rsvpmsgtypes), + XShortField("chksum", None), + ByteField("TTL",1), + XByteField("dataofs", 0), + ShortField("Length",None)] + def post_build(self, p, pay): + p += pay + if self.Length is None: + l = len(p) + p = p[:6]+chr((l>>8)&0xff)+chr(l&0xff)+p[8:] + if self.chksum is None: + ck = checksum(p) + p = p[:2]+chr(ck>>8)+chr(ck&0xff)+p[4:] + return p + +rsvptypes = { 0x01 : "Session", + 0x03 : "HOP", + 0x04 : "INTEGRITY", + 0x05 : "TIME_VALUES", + 0x06 : "ERROR_SPEC", + 0x07 : "SCOPE", + 0x08 : "STYLE", + 0x09 : "FLOWSPEC", + 0x0A : "FILTER_SPEC", + 0x0B : "SENDER_TEMPLATE", + 0x0C : "SENDER_TSPEC", + 0x0D : "ADSPEC", + 0x0E : "POLICY_DATA", + 0x0F : "RESV_CONFIRM", + 0x10 : "RSVP_LABEL", + 0x11 : "HOP_COUNT", + 0x12 : "STRICT_SOURCE_ROUTE", + 0x13 : "LABEL_REQUEST", + 0x14 : "EXPLICIT_ROUTE", + 0x15 : "ROUTE_RECORD", + 0x16 : "HELLO", + 0x17 : "MESSAGE_ID", + 0x18 : "MESSAGE_ID_ACK", + 0x19 : "MESSAGE_ID_LIST", + 0x1E : "DIAGNOSTIC", + 0x1F : "ROUTE", + 0x20 : "DIAG_RESPONSE", + 0x21 : "DIAG_SELECT", + 0x22 : "RECOVERY_LABEL", + 0x23 : "UPSTREAM_LABEL", + 0x24 : "LABEL_SET", + 0x25 : "PROTECTION", + 0x26 : "PRIMARY PATH ROUTE", + 0x2A : "DSBM IP ADDRESS", + 0x2B : "SBM_PRIORITY", + 0x2C : "DSBM TIMER INTERVALS", + 0x2D : "SBM_INFO", + 0x32 : "S2L_SUB_LSP", + 0x3F : "DETOUR", + 0x40 : "CHALLENGE", + 0x41 : "DIFF-SERV", + 0x42 : "CLASSTYPE", + 0x43 : "LSP_REQUIRED_ATTRIBUTES", + 0x80 : "NODE_CHAR", + 0x81 : "SUGGESTED_LABEL", + 0x82 : "ACCEPTABLE_LABEL_SET", + 0x83 : "RESTART_CA", + 0x84 : "SESSION-OF-INTEREST", + 0x85 : "LINK_CAPABILITY", + 0x86 : "Capability Object", + 0xA1 : "RSVP_HOP_L2", + 0xA2 : "LAN_NHOP_L2", + 0xA3 : "LAN_NHOP_L3", + 0xA4 : "LAN_LOOPBACK", + 0xA5 : "TCLASS", + 0xC0 : "TUNNEL", + 0xC1 : "LSP_TUNNEL_INTERFACE_ID", + 0xC2 : "USER_ERROR_SPEC", + 0xC3 : "NOTIFY_REQUEST", + 0xC4 : "ADMIN-STATUS", + 0xC5 : "LSP_ATTRIBUTES", + 0xC6 : "ALARM_SPEC", + 0xC7 : "ASSOCIATION", + 0xC8 : "SECONDARY_EXPLICIT_ROUTE", + 0xC9 : "SECONDARY_RECORD_ROUTE", + 0xCD : "FAST_REROUTE", + 0xCF : "SESSION_ATTRIBUTE", + 0xE1 : "DCLASS", + 0xE2 : "PACKETCABLE EXTENSIONS", + 0xE3 : "ATM_SERVICECLASS", + 0xE4 : "CALL_OPS (ASON)", + 0xE5 : "GENERALIZED_UNI", + 0xE6 : "CALL_ID", + 0xE7 : "3GPP2_Object", + 0xE8 : "EXCLUDE_ROUTE" +} + +class RSVP_Object(Packet): + name = "RSVP_Object" + fields_desc = [ ShortField("Length",4), + ByteEnumField("Class",0x01, rsvptypes), + ByteField("C-Type",1)] + def guess_payload_class(self, payload): + if self.Class == 0x03: + return RSVP_HOP + elif self.Class == 0x05: + return RSVP_Time + elif self.Class == 0x0c: + return RSVP_SenderTSPEC + elif self.Class == 0x13: + return RSVP_LabelReq + elif self.Class == 0xCF: + return RSVP_SessionAttrb + else: + return RSVP_Data + + + +class RSVP_Data(Packet): + name = "Data" + fields_desc = [StrLenField("Data","",length_from= lambda pkt:pkt.underlayer.Length - 4)] + def default_payload_class(self, payload): + return RSVP_Object + +class RSVP_HOP(Packet): + name = "HOP" + fields_desc = [ IPField("neighbor","0.0.0.0"), + BitField("inface",1,32)] + def default_payload_class(self, payload): + return RSVP_Object + +class RSVP_Time(Packet): + name = "Time Val" + fields_desc = [ BitField("refresh",1,32)] + def default_payload_class(self, payload): + return RSVP_Object + +class RSVP_SenderTSPEC(Packet): + name = "Sender_TSPEC" + fields_desc = [ ByteField("Msg_Format",0), + ByteField("reserve",0), + ShortField("Data_Length",4), + ByteField("Srv_hdr",1), + ByteField("reserve2",0), + ShortField("Srv_Length",4), + StrLenField("Tokens","",length_from= lambda pkt:pkt.underlayer.Length - 12) ] + def default_payload_class(self, payload): + return RSVP_Object + +class RSVP_LabelReq(Packet): + name = "Lable Req" + fields_desc = [ ShortField("reserve",1), + ShortField("L3PID",1)] + def default_payload_class(self, payload): + return RSVP_Object + +class RSVP_SessionAttrb(Packet): + name = "Session_Attribute" + fields_desc = [ ByteField("Setup_priority",1), + ByteField("Hold_priority",1), + ByteField("flags",1), + ByteField("Name_length",1), + StrLenField("Name","",length_from= lambda pkt:pkt.underlayer.Length - 8), + ] + def default_payload_class(self, payload): + return RSVP_Object + +bind_layers( IP, RSVP, { "proto" : 46} ) +bind_layers( RSVP, RSVP_Object, {}) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/skinny.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/skinny.py new file mode 100644 index 00000000..47935c9e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/skinny.py @@ -0,0 +1,499 @@ +#! /usr/bin/env python + +# scapy.contrib.description = Skinny Call Control Protocol (SCCP) +# scapy.contrib.status = loads + + +############################################################################# +## ## +## scapy-skinny.py --- Skinny Call Control Protocol (SCCP) extension ## +## ## +## Copyright (C) 2006 Nicolas Bareil <nicolas.bareil@ eads.net> ## +## EADS/CRC security team ## +## ## +## This program is free software; you can redistribute it and/or modify it ## +## under the terms of the GNU General Public License version 2 as ## +## published by the Free Software Foundation; version 2. ## +## ## +## This program is distributed in the hope that it will be useful, but ## +## WITHOUT ANY WARRANTY; without even the implied warranty of ## +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ## +## General Public License for more details. ## +## ## +############################################################################# + +from scapy.all import * +import builtins + +##################################################################### +# Helpers and constants +##################################################################### + +skinny_messages_cls = { +# Station -> Callmanager + 0x0000: "SkinnyMessageKeepAlive", + 0x0001: "SkinnyMessageRegister", + 0x0002: "SkinnyMessageIpPort", + 0x0003: "SkinnyMessageKeypadButton", + 0x0004: "SkinnyMessageEnblocCall", + 0x0005: "SkinnyMessageStimulus", + 0x0006: "SkinnyMessageOffHook", + 0x0007: "SkinnyMessageOnHook", + 0x0008: "SkinnyMessageHookFlash", + 0x0009: "SkinnyMessageForwardStatReq", + 0x000A: "SkinnyMessageSpeedDialStatReq", + 0x000B: "SkinnyMessageLineStatReq", + 0x000C: "SkinnyMessageConfigStatReq", + 0x000D: "SkinnyMessageTimeDateReq", + 0x000E: "SkinnyMessageButtonTemplateReq", + 0x000F: "SkinnyMessageVersionReq", + 0x0010: "SkinnyMessageCapabilitiesRes", + 0x0011: "SkinnyMessageMediaPortList", + 0x0012: "SkinnyMessageServerReq", + 0x0020: "SkinnyMessageAlarm", + 0x0021: "SkinnyMessageMulticastMediaReceptionAck", + 0x0022: "SkinnyMessageOpenReceiveChannelAck", + 0x0023: "SkinnyMessageConnectionStatisticsRes", + 0x0024: "SkinnyMessageOffHookWithCgpn", + 0x0025: "SkinnyMessageSoftKeySetReq", + 0x0026: "SkinnyMessageSoftKeyEvent", + 0x0027: "SkinnyMessageUnregister", + 0x0028: "SkinnyMessageSoftKeyTemplateReq", + 0x0029: "SkinnyMessageRegisterTokenReq", + 0x002A: "SkinnyMessageMediaTransmissionFailure", + 0x002B: "SkinnyMessageHeadsetStatus", + 0x002C: "SkinnyMessageMediaResourceNotification", + 0x002D: "SkinnyMessageRegisterAvailableLines", + 0x002E: "SkinnyMessageDeviceToUserData", + 0x002F: "SkinnyMessageDeviceToUserDataResponse", + 0x0030: "SkinnyMessageUpdateCapabilities", + 0x0031: "SkinnyMessageOpenMultiMediaReceiveChannelAck", + 0x0032: "SkinnyMessageClearConference", + 0x0033: "SkinnyMessageServiceURLStatReq", + 0x0034: "SkinnyMessageFeatureStatReq", + 0x0035: "SkinnyMessageCreateConferenceRes", + 0x0036: "SkinnyMessageDeleteConferenceRes", + 0x0037: "SkinnyMessageModifyConferenceRes", + 0x0038: "SkinnyMessageAddParticipantRes", + 0x0039: "SkinnyMessageAuditConferenceRes", + 0x0040: "SkinnyMessageAuditParticipantRes", + 0x0041: "SkinnyMessageDeviceToUserDataVersion1", +# Callmanager -> Station */ + 0x0081: "SkinnyMessageRegisterAck", + 0x0082: "SkinnyMessageStartTone", + 0x0083: "SkinnyMessageStopTone", + 0x0085: "SkinnyMessageSetRinger", + 0x0086: "SkinnyMessageSetLamp", + 0x0087: "SkinnyMessageSetHkFDetect", + 0x0088: "SkinnyMessageSpeakerMode", + 0x0089: "SkinnyMessageSetMicroMode", + 0x008A: "SkinnyMessageStartMediaTransmission", + 0x008B: "SkinnyMessageStopMediaTransmission", + 0x008C: "SkinnyMessageStartMediaReception", + 0x008D: "SkinnyMessageStopMediaReception", + 0x008F: "SkinnyMessageCallInfo", + 0x0090: "SkinnyMessageForwardStat", + 0x0091: "SkinnyMessageSpeedDialStat", + 0x0092: "SkinnyMessageLineStat", + 0x0093: "SkinnyMessageConfigStat", + 0x0094: "SkinnyMessageTimeDate", + 0x0095: "SkinnyMessageStartSessionTransmission", + 0x0096: "SkinnyMessageStopSessionTransmission", + 0x0097: "SkinnyMessageButtonTemplate", + 0x0098: "SkinnyMessageVersion", + 0x0099: "SkinnyMessageDisplayText", + 0x009A: "SkinnyMessageClearDisplay", + 0x009B: "SkinnyMessageCapabilitiesReq", + 0x009C: "SkinnyMessageEnunciatorCommand", + 0x009D: "SkinnyMessageRegisterReject", + 0x009E: "SkinnyMessageServerRes", + 0x009F: "SkinnyMessageReset", + 0x0100: "SkinnyMessageKeepAliveAck", + 0x0101: "SkinnyMessageStartMulticastMediaReception", + 0x0102: "SkinnyMessageStartMulticastMediaTransmission", + 0x0103: "SkinnyMessageStopMulticastMediaReception", + 0x0104: "SkinnyMessageStopMulticastMediaTransmission", + 0x0105: "SkinnyMessageOpenReceiveChannel", + 0x0106: "SkinnyMessageCloseReceiveChannel", + 0x0107: "SkinnyMessageConnectionStatisticsReq", + 0x0108: "SkinnyMessageSoftKeyTemplateRes", + 0x0109: "SkinnyMessageSoftKeySetRes", + 0x0110: "SkinnyMessageSoftKeyEvent", + 0x0111: "SkinnyMessageCallState", + 0x0112: "SkinnyMessagePromptStatus", + 0x0113: "SkinnyMessageClearPromptStatus", + 0x0114: "SkinnyMessageDisplayNotify", + 0x0115: "SkinnyMessageClearNotify", + 0x0116: "SkinnyMessageCallPlane", + 0x0117: "SkinnyMessageCallPlane", + 0x0118: "SkinnyMessageUnregisterAck", + 0x0119: "SkinnyMessageBackSpaceReq", + 0x011A: "SkinnyMessageRegisterTokenAck", + 0x011B: "SkinnyMessageRegisterTokenReject", + 0x0042: "SkinnyMessageDeviceToUserDataResponseVersion1", + 0x011C: "SkinnyMessageStartMediaFailureDetection", + 0x011D: "SkinnyMessageDialedNumber", + 0x011E: "SkinnyMessageUserToDeviceData", + 0x011F: "SkinnyMessageFeatureStat", + 0x0120: "SkinnyMessageDisplayPriNotify", + 0x0121: "SkinnyMessageClearPriNotify", + 0x0122: "SkinnyMessageStartAnnouncement", + 0x0123: "SkinnyMessageStopAnnouncement", + 0x0124: "SkinnyMessageAnnouncementFinish", + 0x0127: "SkinnyMessageNotifyDtmfTone", + 0x0128: "SkinnyMessageSendDtmfTone", + 0x0129: "SkinnyMessageSubscribeDtmfPayloadReq", + 0x012A: "SkinnyMessageSubscribeDtmfPayloadRes", + 0x012B: "SkinnyMessageSubscribeDtmfPayloadErr", + 0x012C: "SkinnyMessageUnSubscribeDtmfPayloadReq", + 0x012D: "SkinnyMessageUnSubscribeDtmfPayloadRes", + 0x012E: "SkinnyMessageUnSubscribeDtmfPayloadErr", + 0x012F: "SkinnyMessageServiceURLStat", + 0x0130: "SkinnyMessageCallSelectStat", + 0x0131: "SkinnyMessageOpenMultiMediaChannel", + 0x0132: "SkinnyMessageStartMultiMediaTransmission", + 0x0133: "SkinnyMessageStopMultiMediaTransmission", + 0x0134: "SkinnyMessageMiscellaneousCommand", + 0x0135: "SkinnyMessageFlowControlCommand", + 0x0136: "SkinnyMessageCloseMultiMediaReceiveChannel", + 0x0137: "SkinnyMessageCreateConferenceReq", + 0x0138: "SkinnyMessageDeleteConferenceReq", + 0x0139: "SkinnyMessageModifyConferenceReq", + 0x013A: "SkinnyMessageAddParticipantReq", + 0x013B: "SkinnyMessageDropParticipantReq", + 0x013C: "SkinnyMessageAuditConferenceReq", + 0x013D: "SkinnyMessageAuditParticipantReq", + 0x013F: "SkinnyMessageUserToDeviceDataVersion1", + } + +skinny_callstates = { + 0x1: "Off Hook", + 0x2: "On Hook", + 0x3: "Ring out", + 0xc: "Proceeding", +} + + +skinny_ring_type = { + 0x1: "Ring off" +} + +skinny_speaker_modes = { + 0x1: "Speaker on", + 0x2: "Speaker off" +} + +skinny_lamp_mode = { + 0x1: "Off (?)", + 0x2: "On", +} + +skinny_stimulus = { + 0x9: "Line" +} + + +############ +## Fields ## +############ + +class SkinnyDateTimeField(StrFixedLenField): + def __init__(self, name, default): + StrFixedLenField.__init__(self, name, default, 32) + + def m2i(self, pkt, s): + year,month,dow,day,hour,min,sec,milisecond=struct.unpack('<8I', s) + return (year, month, day, hour, min, sec) + + def i2m(self, pkt, val): + if type(val) is str: + val = self.h2i(pkt, val) + l= val[:2] + (0,) + val[2:7] + (0,) + return struct.pack('<8I', *l) + + def i2h(self, pkt, x): + if type(x) is str: + return x + else: + return time.ctime(time.mktime(x+(0,0,0))) + + def i2repr(self, pkt, x): + return self.i2h(pkt, x) + + def h2i(self, pkt, s): + t = () + if type(s) is str: + t = time.strptime(s) + t = t[:2] + t[2:-3] + else: + if not s: + y,m,d,h,min,sec,rest,rest,rest = time.gmtime(time.time()) + t = (y,m,d,h,min,sec) + else: + t=s + return t + + +########################### +## Packet abstract class ## +########################### + +class SkinnyMessageGeneric(Packet): + name='Generic message' + +class SkinnyMessageKeepAlive(Packet): + name='keep alive' + +class SkinnyMessageKeepAliveAck(Packet): + name='keep alive ack' + +class SkinnyMessageOffHook(Packet): + name = 'Off Hook' + fields_desc = [ LEIntField("unknown1", 0), + LEIntField("unknown2", 0),] + +class SkinnyMessageOnHook(SkinnyMessageOffHook): + name = 'On Hook' + +class SkinnyMessageCallState(Packet): + name='Skinny Call state message' + fields_desc = [ LEIntEnumField("state", 1, skinny_callstates), + LEIntField("instance", 1), + LEIntField("callid", 0), + LEIntField("unknown1", 4), + LEIntField("unknown2", 0), + LEIntField("unknown3", 0) ] + +class SkinnyMessageSoftKeyEvent(Packet): + name='Soft Key Event' + fields_desc = [ LEIntField("key", 0), + LEIntField("instance", 1), + LEIntField("callid", 0)] + +class SkinnyMessageSetRinger(Packet): + name='Ring message' + fields_desc = [ LEIntEnumField("ring", 0x1, skinny_ring_type), + LEIntField("unknown1", 0), + LEIntField("unknown2", 0), + LEIntField("unknown3", 0) ] + +_skinny_tones = { + 0x21: 'Inside dial tone', + 0x22: 'xxx', + 0x23: 'xxx', + 0x24: 'Alerting tone', + 0x25: 'Reorder Tone' + } + +class SkinnyMessageStartTone(Packet): + name='Start tone' + fields_desc = [ LEIntEnumField("tone", 0x21, _skinny_tones), + LEIntField("unknown1", 0), + LEIntField("instance", 1), + LEIntField("callid", 0)] + +class SkinnyMessageStopTone(SkinnyMessageGeneric): + name='stop tone' + fields_desc = [ LEIntField("instance", 1), + LEIntField("callid", 0)] + + +class SkinnyMessageSpeakerMode(Packet): + name='Speaker mdoe' + fields_desc = [ LEIntEnumField("ring", 0x1, skinny_speaker_modes) ] + +class SkinnyMessageSetLamp(Packet): + name='Lamp message (light of the phone)' + fields_desc = [ LEIntEnumField("stimulus", 0x5, skinny_stimulus), + LEIntField("instance", 1), + LEIntEnumField("mode", 2, skinny_lamp_mode) ] + +class SkinnyMessageSoftKeyEvent(Packet): + name=' Call state message' + fields_desc = [ LEIntField("instance", 1), + LEIntField("callid", 0), + LEIntField("set", 0), + LEIntField("map", 0xffff)] + +class SkinnyMessagePromptStatus(Packet): + name='Prompt status' + fields_desc = [ LEIntField("timeout", 0), + StrFixedLenField("text", "\0"*32, 32), + LEIntField("instance", 1), + LEIntField("callid", 0)] + +class SkinnyMessageCallPlane(Packet): + name='Activate/Desactivate Call Plane Message' + fields_desc = [ LEIntField("instance", 1)] + +class SkinnyMessageTimeDate(Packet): + name='Setting date and time' + fields_desc = [ SkinnyDateTimeField("settime", None), + LEIntField("timestamp", 0) ] + +class SkinnyMessageClearPromptStatus(Packet): + name='clear prompt status' + fields_desc = [ LEIntField("instance", 1), + LEIntField("callid", 0)] + +class SkinnyMessageKeypadButton(Packet): + name='keypad button' + fields_desc = [ LEIntField("key", 0), + LEIntField("instance", 1), + LEIntField("callid", 0)] + +class SkinnyMessageDialedNumber(Packet): + name='dialed number' + fields_desc = [ StrFixedLenField("number", "1337", 24), + LEIntField("instance", 1), + LEIntField("callid", 0)] + +_skinny_message_callinfo_restrictions = ['CallerName' + , 'CallerNumber' + , 'CalledName' + , 'CalledNumber' + , 'OriginalCalledName' + , 'OriginalCalledNumber' + , 'LastRedirectName' + , 'LastRedirectNumber'] + ['Bit%d' % i for i in range(8,15)] +class SkinnyMessageCallInfo(Packet): + name='call information' + fields_desc = [ StrFixedLenField("callername", "Jean Valjean", 40), + StrFixedLenField("callernum", "1337", 24), + StrFixedLenField("calledname", "Causette", 40), + StrFixedLenField("callednum", "1034", 24), + LEIntField("lineinstance", 1), + LEIntField("callid", 0), + StrFixedLenField("originalcalledname", "Causette", 40), + StrFixedLenField("originalcallednum", "1034", 24), + StrFixedLenField("lastredirectingname", "Causette", 40), + StrFixedLenField("lastredirectingnum", "1034", 24), + LEIntField("originalredirectreason", 0), + LEIntField("lastredirectreason", 0), + StrFixedLenField('voicemailboxG', '\0'*24, 24), + StrFixedLenField('voicemailboxD', '\0'*24, 24), + StrFixedLenField('originalvoicemailboxD', '\0'*24, 24), + StrFixedLenField('lastvoicemailboxD', '\0'*24, 24), + LEIntField('security', 0), + FlagsField('restriction', 0, 16, _skinny_message_callinfo_restrictions), + LEIntField('unknown', 0)] + + +class SkinnyRateField(LEIntField): + def i2repr(self, pkt, x): + if x is None: + x=0 + return '%d ms/pkt' % x + +_skinny_codecs = { + 0x0: 'xxx', + 0x1: 'xxx', + 0x2: 'xxx', + 0x3: 'xxx', + 0x4: 'G711 ulaw 64k' + } + +_skinny_echo = { + 0x0: 'echo cancelation off', + 0x1: 'echo cancelation on' + } + +class SkinnyMessageOpenReceiveChannel(Packet): + name='open receive channel' + fields_desc = [LEIntField('conference', 0), + LEIntField('passthru', 0), + SkinnyRateField('rate', 20), + LEIntEnumField('codec', 4, _skinny_codecs), + LEIntEnumField('echo', 0, _skinny_echo), + LEIntField('unknown1', 0), + LEIntField('callid', 0)] + + def guess_payload_class(self, p): + return conf.padding_layer + +_skinny_receive_channel_status = { + 0x0: 'ok', + 0x1: 'ko' + } + +class SkinnyMessageOpenReceiveChannelAck(Packet): + name='open receive channel' + fields_desc = [LEIntEnumField('status', 0, _skinny_receive_channel_status), + IPField('remote', '0.0.0.0'), + LEIntField('port', RandShort()), + LEIntField('passthru', 0), + LEIntField('callid', 0)] + +_skinny_silence = { + 0x0: 'silence suppression off', + 0x1: 'silence suppression on', + } + +class SkinnyFramePerPacketField(LEIntField): + def i2repr(self, pkt, x): + if x is None: + x=0 + return '%d frames/pkt' % x + +class SkinnyMessageStartMediaTransmission(Packet): + name='start multimedia transmission' + fields_desc = [LEIntField('conference', 0), + LEIntField('passthru', 0), + IPField('remote', '0.0.0.0'), + LEIntField('port', RandShort()), + SkinnyRateField('rate', 20), + LEIntEnumField('codec', 4, _skinny_codecs), + LEIntField('precedence', 200), + LEIntEnumField('silence', 0, _skinny_silence), + SkinnyFramePerPacketField('maxframes', 0), + LEIntField('unknown1', 0), + LEIntField('callid', 0)] + + def guess_payload_class(self, p): + return conf.padding_layer + +class SkinnyMessageCloseReceiveChannel(Packet): + name='close receive channel' + fields_desc = [LEIntField('conference', 0), + LEIntField('passthru', 0), + IPField('remote', '0.0.0.0'), + LEIntField('port', RandShort()), + SkinnyRateField('rate', 20), + LEIntEnumField('codec', 4, _skinny_codecs), + LEIntField('precedence', 200), + LEIntEnumField('silence', 0, _skinny_silence), + LEIntField('callid', 0)] + +class SkinnyMessageStopMultiMediaTransmission(Packet): + name='stop multimedia transmission' + fields_desc = [LEIntField('conference', 0), + LEIntField('passthru', 0), + LEIntField('callid', 0)] + +class Skinny(Packet): + name="Skinny" + fields_desc = [ LEIntField("len", None), + LEIntField("res",0), + LEIntEnumField("msg",0, skinny_messages) ] + + def post_build(self, pkt, p): + if self.len is None: + l=len(p)+len(pkt)-8 # on compte pas les headers len et reserved + pkt=struct.pack('@I', l)+pkt[4:] + return pkt+p + +# An helper +def get_cls(name, fallback_cls): + return globals().get(name, fallback_cls) + #return builtins.__dict__.get(name, fallback_cls) + +for msgid,strcls in skinny_messages_cls.items(): + cls=get_cls(strcls, SkinnyMessageGeneric) + bind_layers(Skinny, cls, {"msg": msgid}) + +bind_layers(TCP, Skinny, { "dport": 2000 } ) +bind_layers(TCP, Skinny, { "sport": 2000 } ) + +if __name__ == "__main__": + interact(mydict=globals(),mybanner="Welcome to Skinny add-on") + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ubberlogger.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ubberlogger.py new file mode 100644 index 00000000..1c01db2f --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/ubberlogger.py @@ -0,0 +1,101 @@ +# Author: Sylvain SARMEJEANNE +# http://trac.secdev.org/scapy/ticket/1 + +# scapy.contrib.description = Ubberlogger dissectors +# scapy.contrib.status = untested + +from scapy.packet import * +from scapy.fields import * + +# Syscalls known by Uberlogger +uberlogger_sys_calls = {0:"READ_ID", + 1:"OPEN_ID", + 2:"WRITE_ID", + 3:"CHMOD_ID", + 4:"CHOWN_ID", + 5:"SETUID_ID", + 6:"CHROOT_ID", + 7:"CREATE_MODULE_ID", + 8:"INIT_MODULE_ID", + 9:"DELETE_MODULE_ID", + 10:"CAPSET_ID", + 11:"CAPGET_ID", + 12:"FORK_ID", + 13:"EXECVE_ID"} + +# First part of the header +class Uberlogger_honeypot_caract(Packet): + name = "Uberlogger honeypot_caract" + fields_desc = [ByteField("honeypot_id", 0), + ByteField("reserved", 0), + ByteField("os_type_and_version", 0)] + +# Second part of the header +class Uberlogger_uber_h(Packet): + name = "Uberlogger uber_h" + fields_desc = [ByteEnumField("syscall_type", 0, uberlogger_sys_calls), + IntField("time_sec", 0), + IntField("time_usec", 0), + IntField("pid", 0), + IntField("uid", 0), + IntField("euid", 0), + IntField("cap_effective", 0), + IntField("cap_inheritable", 0), + IntField("cap_permitted", 0), + IntField("res", 0), + IntField("length", 0)] + +# The 9 following classes are options depending on the syscall type +class Uberlogger_capget_data(Packet): + name = "Uberlogger capget_data" + fields_desc = [IntField("target_pid", 0)] + +class Uberlogger_capset_data(Packet): + name = "Uberlogger capset_data" + fields_desc = [IntField("target_pid", 0), + IntField("effective_cap", 0), + IntField("permitted_cap", 0), + IntField("inheritable_cap", 0)] + +class Uberlogger_chmod_data(Packet): + name = "Uberlogger chmod_data" + fields_desc = [ShortField("mode", 0)] + +class Uberlogger_chown_data(Packet): + name = "Uberlogger chown_data" + fields_desc = [IntField("uid", 0), + IntField("gid", 0)] + +class Uberlogger_open_data(Packet): + name = "Uberlogger open_data" + fields_desc = [IntField("flags", 0), + IntField("mode", 0)] + +class Uberlogger_read_data(Packet): + name = "Uberlogger read_data" + fields_desc = [IntField("fd", 0), + IntField("count", 0)] + +class Uberlogger_setuid_data(Packet): + name = "Uberlogger setuid_data" + fields_desc = [IntField("uid", 0)] + +class Uberlogger_create_module_data(Packet): + name = "Uberlogger create_module_data" + fields_desc = [IntField("size", 0)] + +class Uberlogger_execve_data(Packet): + name = "Uberlogger execve_data" + fields_desc = [IntField("nbarg", 0)] + +# Layer bounds for Uberlogger +bind_layers(Uberlogger_honeypot_caract,Uberlogger_uber_h) +bind_layers(Uberlogger_uber_h,Uberlogger_capget_data) +bind_layers(Uberlogger_uber_h,Uberlogger_capset_data) +bind_layers(Uberlogger_uber_h,Uberlogger_chmod_data) +bind_layers(Uberlogger_uber_h,Uberlogger_chown_data) +bind_layers(Uberlogger_uber_h,Uberlogger_open_data) +bind_layers(Uberlogger_uber_h,Uberlogger_read_data) +bind_layers(Uberlogger_uber_h,Uberlogger_setuid_data) +bind_layers(Uberlogger_uber_h,Uberlogger_create_module_data) +bind_layers(Uberlogger_uber_h,Uberlogger_execve_data) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/vqp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/vqp.py new file mode 100644 index 00000000..9328cea4 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/vqp.py @@ -0,0 +1,58 @@ + +# http://trac.secdev.org/scapy/ticket/147 + +# scapy.contrib.description = VLAN Query Protocol +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP + +class VQP(Packet): + name = "VQP" + fields_desc = [ + ByteField("const", 1), + ByteEnumField("type", 1, { + 1:"requestPort", 2:"responseVLAN", + 3:"requestReconfirm", 4:"responseReconfirm" + }), + ByteEnumField("errorcodeaction", 0, { + 0:"none",3:"accessDenied", + 4:"shutdownPort", 5:"wrongDomain" + }), + ByteEnumField("unknown", 2, { + 2:"inGoodResponse", 6:"inRequests" + }), + IntField("seq",0), + ] + +class VQPEntry(Packet): + name = "VQPEntry" + fields_desc = [ + IntEnumField("datatype", 0, { + 3073:"clientIPAddress", 3074:"portName", + 3075:"VLANName", 3076:"Domain", 3077:"ethernetPacket", + 3078:"ReqMACAddress", 3079:"unknown", + 3080:"ResMACAddress" + }), + FieldLenField("len", None), + ConditionalField(IPField("datatom", "0.0.0.0"), + lambda p:p.datatype==3073), + ConditionalField(MACField("data", "00:00:00:00:00:00"), + lambda p:p.datatype==3078), + ConditionalField(MACField("data", "00:00:00:00:00:00"), + lambda p:p.datatype==3080), + ConditionalField(StrLenField("data", None, + length_from=lambda p:p.len), + lambda p:p.datatype not in [3073, 3078, 3080]), + ] + def post_build(self, p, pay): + if self.len is None: + l = len(p.data) + p = p[:2]+struct.pack("!H",l)+p[4:] + return p + +bind_layers(UDP, VQP, sport=1589) +bind_layers(UDP, VQP, dport=1589) +bind_layers(VQP, VQPEntry, ) +bind_layers(VQPEntry, VQPEntry, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/vtp.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/vtp.py new file mode 100644 index 00000000..af5c2823 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/vtp.py @@ -0,0 +1,171 @@ +#!/usr/bin/env python + +# scapy.contrib.description = VLAN Trunking Protocol (VTP) +# scapy.contrib.status = loads + +""" + VTP Scapy Extension + ~~~~~~~~~~~~~~~~~~~~~ + + :version: 2009-02-15 + :copyright: 2009 by Jochen Bartl + :e-mail: lobo@c3a.de / jochen.bartl@gmail.com + :license: GPL v2 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + :TODO + + - Join messages + - RE MD5 hash calculation + - Have a closer look at 8 byte padding in summary adv. + "debug sw-vlan vtp packets" sais the TLV length is invalid, + when I change the values + '\x00\x00\x00\x01\x06\x01\x00\x02' + * \x00\x00 ? + * \x00\x01 tlvtype? + * \x06 length? + * \x00\x02 value? + - h2i function for VTPTimeStampField + + :References: + + - Understanding VLAN Trunk Protocol (VTP) + http://www.cisco.com/en/US/tech/tk389/tk689/technologies_tech_note09186a0080094c52.shtml +""" + +from scapy.all import * + +_VTP_VLAN_TYPE = { + 1 : 'Ethernet', + 2 : 'FDDI', + 3 : 'TrCRF', + 4 : 'FDDI-net', + 5 : 'TrBRF' + } + +_VTP_VLANINFO_TLV_TYPE = { + 0x01 : 'Source-Routing Ring Number', + 0x02 : 'Source-Routing Bridge Number', + 0x03 : 'Spanning-Tree Protocol Type', + 0x04 : 'Parent VLAN', + 0x05 : 'Translationally Bridged VLANs', + 0x06 : 'Pruning', + 0x07 : 'Bridge Type', + 0x08 : 'Max ARE Hop Count', + 0x09 : 'Max STE Hop Count', + 0x0A : 'Backup CRF Mode' + } + + +class VTPVlanInfoTlv(Packet): + name = "VTP VLAN Info TLV" + fields_desc = [ + ByteEnumField("type", 0, _VTP_VLANINFO_TLV_TYPE), + ByteField("length", 0), + StrLenField("value", None, length_from=lambda pkt : pkt.length + 1) + ] + + def guess_payload_class(self, p): + return conf.padding_layer + +class VTPVlanInfo(Packet): + name = "VTP VLAN Info" + fields_desc = [ + ByteField("len", None), # FIXME: compute length + ByteEnumField("status", 0, {0 : "active", 1 : "suspended"}), + ByteEnumField("type", 1, _VTP_VLAN_TYPE), + FieldLenField("vlannamelen", None, "vlanname", "B"), + ShortField("vlanid", 1), + ShortField("mtu", 1500), + XIntField("dot10index", None), + StrLenField("vlanname", "default", length_from=lambda pkt:4 * ((pkt.vlannamelen + 3) / 4)), + ConditionalField(PacketListField("tlvlist", [], VTPVlanInfoTlv, + length_from=lambda pkt:pkt.len - 12 - (4 * ((pkt.vlannamelen + 3) / 4))), + lambda pkt:pkt.type not in [1, 2]) + ] + + def post_build(self, p, pay): + vlannamelen = 4 * ((len(self.vlanname) + 3) / 4) + + if self.len == None: + l = vlannamelen + 12 + p = chr(l & 0xff) + p[1:] + + # Pad vlan name with zeros if vlannamelen > len(vlanname) + l = vlannamelen - len(self.vlanname) + if l != 0: + p += "\x00" * l + + p += pay + + return p + + def guess_payload_class(self, p): + return conf.padding_layer + +_VTP_Types = { + 1 : 'Summary Advertisement', + 2 : 'Subset Advertisements', + 3 : 'Advertisement Request', + 4 : 'Join' + } + +class VTPTimeStampField(StrFixedLenField): + def __init__(self, name, default): + StrFixedLenField.__init__(self, name, default, 12) + + def i2repr(self, pkt, x): + return "%s-%s-%s %s:%s:%s" % (x[:2], x[2:4], x[4:6], x[6:8], x[8:10], x[10:12]) + +class VTP(Packet): + name = "VTP" + fields_desc = [ + ByteField("ver", 2), + ByteEnumField("code", 1, _VTP_Types), + ConditionalField(ByteField("followers", 1), + lambda pkt:pkt.code == 1), + ConditionalField(ByteField("seq", 1), + lambda pkt:pkt.code == 2), + ConditionalField(ByteField("reserved", 0), + lambda pkt:pkt.code == 3), + ByteField("domnamelen", None), + StrFixedLenField("domname", "manbearpig", 32), + ConditionalField(SignedIntField("rev", 0), + lambda pkt:pkt.code == 1 or + pkt.code == 2), + # updater identity + ConditionalField(IPField("uid", "192.168.0.1"), + lambda pkt:pkt.code == 1), + ConditionalField(VTPTimeStampField("timestamp", '930301000000'), + lambda pkt:pkt.code == 1), + ConditionalField(StrFixedLenField("md5", "\x00" * 16, 16), + lambda pkt:pkt.code == 1), + ConditionalField( + PacketListField("vlaninfo", [], VTPVlanInfo), + lambda pkt: pkt.code == 2), + ConditionalField(ShortField("startvalue", 0), + lambda pkt:pkt.code == 3) + ] + + def post_build(self, p, pay): + if self.domnamelen == None: + domnamelen = len(self.domname.strip("\x00")) + p = p[:3] + chr(domnamelen & 0xff) + p[4:] + + p += pay + + return p + +bind_layers(SNAP, VTP, code=0x2003) + +if __name__ == '__main__': + interact(mydict=globals(), mybanner="VTP") diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/contrib/wpa_eapol.py b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/wpa_eapol.py new file mode 100644 index 00000000..084eedd8 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/contrib/wpa_eapol.py @@ -0,0 +1,35 @@ + +# http://trac.secdev.org/scapy/ticket/104 + +# scapy.contrib.description = WPA EAPOL dissector +# scapy.contrib.status = loads + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.l2 import * + +class WPA_key(Packet): + name = "WPA_key" + fields_desc = [ ByteField("descriptor_type", 1), + ShortField("key_info",0), + LenField("len", None, "H"), + StrFixedLenField("replay_counter", "", 8), + StrFixedLenField("nonce", "", 32), + StrFixedLenField("key_iv", "", 16), + StrFixedLenField("wpa_key_rsc", "", 8), + StrFixedLenField("wpa_key_id", "", 8), + StrFixedLenField("wpa_key_mic", "", 16), + LenField("wpa_key_length", None, "H"), + StrLenField("wpa_key", "", length_from=lambda pkt:pkt.wpa_key_length) ] + def extract_padding(self, s): + l = self.len + return s[:l],s[l:] + def hashret(self): + return chr(self.type)+self.payload.hashret() + def answers(self, other): + if isinstance(other,WPA_key): + return 1 + return 0 + + +bind_layers( EAPOL, WPA_key, type=3) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/crypto/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/crypto/__init__.py new file mode 100644 index 00000000..b441863e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/crypto/__init__.py @@ -0,0 +1,17 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Arnaud Ebalard <arno@natisbad.org> +## This program is published under a GPLv2 license + +""" +Tools for handling with digital certificates. +""" + +try: + import Crypto +except ImportError: + import logging + log_loading = logging.getLogger("scapy.loading") + log_loading.info("Can't import python Crypto lib. Disabled certificate manipulation tools") +else: + from scapy.crypto.cert import * diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/crypto/cert.py b/scripts/external_libs/scapy-python3-0.18/scapy/crypto/cert.py new file mode 100644 index 00000000..c4291059 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/crypto/cert.py @@ -0,0 +1,2486 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Arnaud Ebalard <arno@natisbad.org> +## This program is published under a GPLv2 license + +""" +Cryptographic certificates. +""" + +import os, sys, math, socket, struct, hmac, string, time, random, tempfile +from subprocess import Popen, PIPE +from scapy.utils import strxor +try: + HAS_HASHLIB=True + import hashlib +except: + HAS_HASHLIB=False + +from Crypto.PublicKey import * +from Crypto.Cipher import * +from Crypto.Hash import * +from Crypto.Util import number + +# Maximum allowed size in bytes for a certificate file, to avoid +# loading huge file when importing a cert +MAX_KEY_SIZE=50*1024 +MAX_CERT_SIZE=50*1024 +MAX_CRL_SIZE=10*1024*1024 # some are that big + +##################################################################### +# Some helpers +##################################################################### + +def popen3(cmd): + p = Popen(cmd, shell=False, stdin=PIPE, stdout=PIPE, stderr=PIPE, + close_fds=True) + return p.stdout, p.stdin, p.stderr + +def warning(m): + print("WARNING: %s" % m) + +def randstring(l): + """ + Returns a random string of length l (l >= 0) + """ + tmp = map(lambda x: struct.pack("B", random.randrange(0, 256, 1)), [""]*l) + return "".join(tmp) + +def zerofree_randstring(l): + """ + Returns a random string of length l (l >= 0) without zero in it. + """ + tmp = map(lambda x: struct.pack("B", random.randrange(1, 256, 1)), [""]*l) + return "".join(tmp) + +def strand(s1, s2): + """ + Returns the binary AND of the 2 provided strings s1 and s2. s1 and s2 + must be of same length. + """ + return "".join(map(lambda x,y:chr(ord(x)&ord(y)), s1, s2)) + +# OS2IP function defined in RFC 3447 for octet string to integer conversion +def pkcs_os2ip(x): + """ + Accepts a byte string as input parameter and return the associated long + value: + + Input : x octet string to be converted + + Output: x corresponding nonnegative integer + + Reverse function is pkcs_i2osp() + """ + return number.bytes_to_long(x) + +# IP2OS function defined in RFC 3447 for octet string to integer conversion +def pkcs_i2osp(x,xLen): + """ + Converts a long (the first parameter) to the associated byte string + representation of length l (second parameter). Basically, the length + parameters allow the function to perform the associated padding. + + Input : x nonnegative integer to be converted + xLen intended length of the resulting octet string + + Output: x corresponding nonnegative integer + + Reverse function is pkcs_os2ip(). + """ + z = number.long_to_bytes(x) + padlen = max(0, xLen-len(z)) + return '\x00'*padlen + z + +# for every hash function a tuple is provided, giving access to +# - hash output length in byte +# - associated hash function that take data to be hashed as parameter +# XXX I do not provide update() at the moment. +# - DER encoding of the leading bits of digestInfo (the hash value +# will be concatenated to create the complete digestInfo). +# +# Notes: +# - MD4 asn.1 value should be verified. Also, as stated in +# PKCS#1 v2.1, MD4 should not be used. +# - hashlib is available from http://code.krypto.org/python/hashlib/ +# - 'tls' one is the concatenation of both md5 and sha1 hashes used +# by SSL/TLS when signing/verifying things +_hashFuncParams = { + "md2" : (16, + lambda x: MD2.new(x).digest(), + '\x30\x20\x30\x0c\x06\x08\x2a\x86\x48\x86\xf7\x0d\x02\x02\x05\x00\x04\x10'), + "md4" : (16, + lambda x: MD4.new(x).digest(), + '\x30\x20\x30\x0c\x06\x08\x2a\x86\x48\x86\xf7\x0d\x02\x04\x05\x00\x04\x10'), # is that right ? + "md5" : (16, + lambda x: MD5.new(x).digest(), + '\x30\x20\x30\x0c\x06\x08\x2a\x86\x48\x86\xf7\x0d\x02\x05\x05\x00\x04\x10'), + "sha1" : (20, + lambda x: SHA.new(x).digest(), + '\x30\x21\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x04\x14'), + "tls" : (36, + lambda x: MD5.new(x).digest() + SHA.new(x).digest(), + '') } + +if HAS_HASHLIB: + _hashFuncParams["sha224"] = (28, + lambda x: hashlib.sha224(x).digest(), + '\x30\x2d\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x04\x05\x00\x04\x1c') + _hashFuncParams["sha256"] = (32, + lambda x: hashlib.sha256(x).digest(), + '\x30\x31\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01\x05\x00\x04\x20') + _hashFuncParams["sha384"] = (48, + lambda x: hashlib.sha384(x).digest(), + '\x30\x41\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x02\x05\x00\x04\x30') + _hashFuncParams["sha512"] = (64, + lambda x: hashlib.sha512(x).digest(), + '\x30\x51\x30\x0d\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x03\x05\x00\x04\x40') +else: + warning("hashlib support is not available. Consider installing it") + warning("if you need sha224, sha256, sha384 and sha512 algs.") + +def pkcs_mgf1(mgfSeed, maskLen, h): + """ + Implements generic MGF1 Mask Generation function as described in + Appendix B.2.1 of RFC 3447. The hash function is passed by name. + valid values are 'md2', 'md4', 'md5', 'sha1', 'tls, 'sha256', + 'sha384' and 'sha512'. Returns None on error. + + Input: + mgfSeed: seed from which mask is generated, an octet string + maskLen: intended length in octets of the mask, at most 2^32 * hLen + hLen (see below) + h : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). hLen denotes the length in octets of + the hash function output. + + Output: + an octet string of length maskLen + """ + + # steps are those of Appendix B.2.1 + if not h in _hashFuncParams: + warning("pkcs_mgf1: invalid hash (%s) provided") + return None + hLen = _hashFuncParams[h][0] + hFunc = _hashFuncParams[h][1] + if maskLen > 2**32 * hLen: # 1) + warning("pkcs_mgf1: maskLen > 2**32 * hLen") + return None + T = "" # 2) + maxCounter = math.ceil(float(maskLen) / float(hLen)) # 3) + counter = 0 + while counter < maxCounter: + C = pkcs_i2osp(counter, 4) + T += hFunc(mgfSeed + C) + counter += 1 + return T[:maskLen] + + +def pkcs_emsa_pss_encode(M, emBits, h, mgf, sLen): + """ + Implements EMSA-PSS-ENCODE() function described in Sect. 9.1.1 of RFC 3447 + + Input: + M : message to be encoded, an octet string + emBits: maximal bit length of the integer resulting of pkcs_os2ip(EM), + where EM is the encoded message, output of the function. + h : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). hLen denotes the length in octets of + the hash function output. + mgf : the mask generation function f : seed, maskLen -> mask + sLen : intended length in octets of the salt + + Output: + encoded message, an octet string of length emLen = ceil(emBits/8) + + On error, None is returned. + """ + + # 1) is not done + hLen = _hashFuncParams[h][0] # 2) + hFunc = _hashFuncParams[h][1] + mHash = hFunc(M) + emLen = int(math.ceil(emBits/8.)) + if emLen < hLen + sLen + 2: # 3) + warning("encoding error (emLen < hLen + sLen + 2)") + return None + salt = randstring(sLen) # 4) + MPrime = '\x00'*8 + mHash + salt # 5) + H = hFunc(MPrime) # 6) + PS = '\x00'*(emLen - sLen - hLen - 2) # 7) + DB = PS + '\x01' + salt # 8) + dbMask = mgf(H, emLen - hLen - 1) # 9) + maskedDB = strxor(DB, dbMask) # 10) + l = (8*emLen - emBits)/8 # 11) + rem = 8*emLen - emBits - 8*l # additionnal bits + andMask = l*'\x00' + if rem: + j = chr(reduce(lambda x,y: x+y, map(lambda x: 1<<x, range(8-rem)))) + andMask += j + l += 1 + maskedDB = strand(maskedDB[:l], andMask) + maskedDB[l:] + EM = maskedDB + H + '\xbc' # 12) + return EM # 13) + + +def pkcs_emsa_pss_verify(M, EM, emBits, h, mgf, sLen): + """ + Implements EMSA-PSS-VERIFY() function described in Sect. 9.1.2 of RFC 3447 + + Input: + M : message to be encoded, an octet string + EM : encoded message, an octet string of length emLen = ceil(emBits/8) + emBits: maximal bit length of the integer resulting of pkcs_os2ip(EM) + h : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). hLen denotes the length in octets of + the hash function output. + mgf : the mask generation function f : seed, maskLen -> mask + sLen : intended length in octets of the salt + + Output: + True if the verification is ok, False otherwise. + """ + + # 1) is not done + hLen = _hashFuncParams[h][0] # 2) + hFunc = _hashFuncParams[h][1] + mHash = hFunc(M) + emLen = int(math.ceil(emBits/8.)) # 3) + if emLen < hLen + sLen + 2: + return False + if EM[-1] != '\xbc': # 4) + return False + l = emLen - hLen - 1 # 5) + maskedDB = EM[:l] + H = EM[l:l+hLen] + l = (8*emLen - emBits)/8 # 6) + rem = 8*emLen - emBits - 8*l # additionnal bits + andMask = l*'\xff' + if rem: + val = reduce(lambda x,y: x+y, map(lambda x: 1<<x, range(8-rem))) + j = chr(~val & 0xff) + andMask += j + l += 1 + if strand(maskedDB[:l], andMask) != '\x00'*l: + return False + dbMask = mgf(H, emLen - hLen - 1) # 7) + DB = strxor(maskedDB, dbMask) # 8) + l = (8*emLen - emBits)/8 # 9) + rem = 8*emLen - emBits - 8*l # additionnal bits + andMask = l*'\x00' + if rem: + j = chr(reduce(lambda x,y: x+y, map(lambda x: 1<<x, range(8-rem)))) + andMask += j + l += 1 + DB = strand(DB[:l], andMask) + DB[l:] + l = emLen - hLen - sLen - 1 # 10) + if DB[:l] != '\x00'*(l-1) + '\x01': + return False + salt = DB[-sLen:] # 11) + MPrime = '\x00'*8 + mHash + salt # 12) + HPrime = hFunc(MPrime) # 13) + return H == HPrime # 14) + + +def pkcs_emsa_pkcs1_v1_5_encode(M, emLen, h): # section 9.2 of RFC 3447 + """ + Implements EMSA-PKCS1-V1_5-ENCODE() function described in Sect. + 9.2 of RFC 3447. + + Input: + M : message to be encode, an octet string + emLen: intended length in octets of the encoded message, at least + tLen + 11, where tLen is the octet length of the DER encoding + T of a certain value computed during the encoding operation. + h : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). hLen denotes the length in octets of + the hash function output. + + Output: + encoded message, an octet string of length emLen + + On error, None is returned. + """ + hLen = _hashFuncParams[h][0] # 1) + hFunc = _hashFuncParams[h][1] + H = hFunc(M) + hLeadingDigestInfo = _hashFuncParams[h][2] # 2) + T = hLeadingDigestInfo + H + tLen = len(T) + if emLen < tLen + 11: # 3) + warning("pkcs_emsa_pkcs1_v1_5_encode: intended encoded message length too short") + return None + PS = '\xff'*(emLen - tLen - 3) # 4) + EM = '\x00' + '\x01' + PS + '\x00' + T # 5) + return EM # 6) + + +# XXX should add other pgf1 instance in a better fashion. + +def create_ca_file(anchor_list, filename): + """ + Concatenate all the certificates (PEM format for the export) in + 'anchor_list' and write the result to file 'filename'. On success + 'filename' is returned, None otherwise. + + If you are used to OpenSSL tools, this function builds a CAfile + that can be used for certificate and CRL check. + + Also see create_temporary_ca_file(). + """ + try: + f = open(filename, "w") + for a in anchor_list: + s = a.output(fmt="PEM") + f.write(s) + f.close() + except: + return None + return filename + +def create_temporary_ca_file(anchor_list): + """ + Concatenate all the certificates (PEM format for the export) in + 'anchor_list' and write the result to file to a temporary file + using mkstemp() from tempfile module. On success 'filename' is + returned, None otherwise. + + If you are used to OpenSSL tools, this function builds a CAfile + that can be used for certificate and CRL check. + + Also see create_temporary_ca_file(). + """ + try: + f, fname = tempfile.mkstemp() + for a in anchor_list: + s = a.output(fmt="PEM") + l = os.write(f, s) + os.close(f) + except: + return None + return fname + +def create_temporary_ca_path(anchor_list, folder): + """ + Create a CA path folder as defined in OpenSSL terminology, by + storing all certificates in 'anchor_list' list in PEM format + under provided 'folder' and then creating the associated links + using the hash as usually done by c_rehash. + + Note that you can also include CRL in 'anchor_list'. In that + case, they will also be stored under 'folder' and associated + links will be created. + + In folder, the files are created with names of the form + 0...ZZ.pem. If you provide an empty list, folder will be created + if it does not already exist, but that's all. + + The number of certificates written to folder is returned on + success, None on error. + """ + # We should probably avoid writing duplicate anchors and also + # check if they are all certs. + try: + if not os.path.isdir(folder): + os.makedirs(folder) + except: + return None + + l = len(anchor_list) + if l == 0: + return None + fmtstr = "%%0%sd.pem" % math.ceil(math.log(l, 10)) + i = 0 + try: + for a in anchor_list: + fname = os.path.join(folder, fmtstr % i) + f = open(fname, "w") + s = a.output(fmt="PEM") + f.write(s) + f.close() + i += 1 + except: + return None + + r,w,e=popen3(["c_rehash", folder]) + r.close(); w.close(); e.close() + + return l + + +##################################################################### +# Public Key Cryptography related stuff +##################################################################### + +class OSSLHelper: + def _apply_ossl_cmd(self, osslcmd, rawdata): + r,w,e=popen3(osslcmd) + w.write(rawdata) + w.close() + res = r.read() + r.close() + e.close() + return res + +class _EncryptAndVerify: + ### Below are encryption methods + + def _rsaep(self, m): + """ + Internal method providing raw RSA encryption, i.e. simple modular + exponentiation of the given message representative 'm', a long + between 0 and n-1. + + This is the encryption primitive RSAEP described in PKCS#1 v2.1, + i.e. RFC 3447 Sect. 5.1.1. + + Input: + m: message representative, a long between 0 and n-1, where + n is the key modulus. + + Output: + ciphertext representative, a long between 0 and n-1 + + Not intended to be used directly. Please, see encrypt() method. + """ + + n = self.modulus + if type(m) is int: + m = long(m) + if type(m) is not long or m > n-1: + warning("Key._rsaep() expects a long between 0 and n-1") + return None + + return self.key.encrypt(m, "")[0] + + + def _rsaes_pkcs1_v1_5_encrypt(self, M): + """ + Implements RSAES-PKCS1-V1_5-ENCRYPT() function described in section + 7.2.1 of RFC 3447. + + Input: + M: message to be encrypted, an octet string of length mLen, where + mLen <= k - 11 (k denotes the length in octets of the key modulus) + + Output: + ciphertext, an octet string of length k + + On error, None is returned. + """ + + # 1) Length checking + mLen = len(M) + k = self.modulusLen / 8 + if mLen > k - 11: + warning("Key._rsaes_pkcs1_v1_5_encrypt(): message too " + "long (%d > %d - 11)" % (mLen, k)) + return None + + # 2) EME-PKCS1-v1_5 encoding + PS = zerofree_randstring(k - mLen - 3) # 2.a) + EM = '\x00' + '\x02' + PS + '\x00' + M # 2.b) + + # 3) RSA encryption + m = pkcs_os2ip(EM) # 3.a) + c = self._rsaep(m) # 3.b) + C = pkcs_i2osp(c, k) # 3.c) + + return C # 4) + + + def _rsaes_oaep_encrypt(self, M, h=None, mgf=None, L=None): + """ + Internal method providing RSAES-OAEP-ENCRYPT as defined in Sect. + 7.1.1 of RFC 3447. Not intended to be used directly. Please, see + encrypt() method for type "OAEP". + + + Input: + M : message to be encrypted, an octet string of length mLen + where mLen <= k - 2*hLen - 2 (k denotes the length in octets + of the RSA modulus and hLen the length in octets of the hash + function output) + h : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). hLen denotes the length in octets of + the hash function output. 'sha1' is used by default if not + provided. + mgf: the mask generation function f : seed, maskLen -> mask + L : optional label to be associated with the message; the default + value for L, if not provided is the empty string + + Output: + ciphertext, an octet string of length k + + On error, None is returned. + """ + # The steps below are the one described in Sect. 7.1.1 of RFC 3447. + # 1) Length Checking + # 1.a) is not done + mLen = len(M) + if h is None: + h = "sha1" + if not h in _hashFuncParams: + warning("Key._rsaes_oaep_encrypt(): unknown hash function %s.", h) + return None + hLen = _hashFuncParams[h][0] + hFun = _hashFuncParams[h][1] + k = self.modulusLen / 8 + if mLen > k - 2*hLen - 2: # 1.b) + warning("Key._rsaes_oaep_encrypt(): message too long.") + return None + + # 2) EME-OAEP encoding + if L is None: # 2.a) + L = "" + lHash = hFun(L) + PS = '\x00'*(k - mLen - 2*hLen - 2) # 2.b) + DB = lHash + PS + '\x01' + M # 2.c) + seed = randstring(hLen) # 2.d) + if mgf is None: # 2.e) + mgf = lambda x,y: pkcs_mgf1(x,y,h) + dbMask = mgf(seed, k - hLen - 1) + maskedDB = strxor(DB, dbMask) # 2.f) + seedMask = mgf(maskedDB, hLen) # 2.g) + maskedSeed = strxor(seed, seedMask) # 2.h) + EM = '\x00' + maskedSeed + maskedDB # 2.i) + + # 3) RSA Encryption + m = pkcs_os2ip(EM) # 3.a) + c = self._rsaep(m) # 3.b) + C = pkcs_i2osp(c, k) # 3.c) + + return C # 4) + + + def encrypt(self, m, t=None, h=None, mgf=None, L=None): + """ + Encrypt message 'm' using 't' encryption scheme where 't' can be: + + - None: the message 'm' is directly applied the RSAEP encryption + primitive, as described in PKCS#1 v2.1, i.e. RFC 3447 + Sect 5.1.1. Simply put, the message undergo a modular + exponentiation using the public key. Additionnal method + parameters are just ignored. + + - 'pkcs': the message 'm' is applied RSAES-PKCS1-V1_5-ENCRYPT encryption + scheme as described in section 7.2.1 of RFC 3447. In that + context, other parameters ('h', 'mgf', 'l') are not used. + + - 'oaep': the message 'm' is applied the RSAES-OAEP-ENCRYPT encryption + scheme, as described in PKCS#1 v2.1, i.e. RFC 3447 Sect + 7.1.1. In that context, + + o 'h' parameter provides the name of the hash method to use. + Possible values are "md2", "md4", "md5", "sha1", "tls", + "sha224", "sha256", "sha384" and "sha512". if none is provided, + sha1 is used. + + o 'mgf' is the mask generation function. By default, mgf + is derived from the provided hash function using the + generic MGF1 (see pkcs_mgf1() for details). + + o 'L' is the optional label to be associated with the + message. If not provided, the default value is used, i.e + the empty string. No check is done on the input limitation + of the hash function regarding the size of 'L' (for + instance, 2^61 - 1 for SHA-1). You have been warned. + """ + + if t is None: # Raw encryption + m = pkcs_os2ip(m) + c = self._rsaep(m) + return pkcs_i2osp(c, self.modulusLen/8) + + elif t == "pkcs": + return self._rsaes_pkcs1_v1_5_encrypt(m) + + elif t == "oaep": + return self._rsaes_oaep_encrypt(m, h, mgf, L) + + else: + warning("Key.encrypt(): Unknown encryption type (%s) provided" % t) + return None + + ### Below are verification related methods + + def _rsavp1(self, s): + """ + Internal method providing raw RSA verification, i.e. simple modular + exponentiation of the given signature representative 'c', an integer + between 0 and n-1. + + This is the signature verification primitive RSAVP1 described in + PKCS#1 v2.1, i.e. RFC 3447 Sect. 5.2.2. + + Input: + s: signature representative, an integer between 0 and n-1, + where n is the key modulus. + + Output: + message representative, an integer between 0 and n-1 + + Not intended to be used directly. Please, see verify() method. + """ + return self._rsaep(s) + + def _rsassa_pss_verify(self, M, S, h=None, mgf=None, sLen=None): + """ + Implements RSASSA-PSS-VERIFY() function described in Sect 8.1.2 + of RFC 3447 + + Input: + M: message whose signature is to be verified + S: signature to be verified, an octet string of length k, where k + is the length in octets of the RSA modulus n. + + Output: + True is the signature is valid. False otherwise. + """ + + # Set default parameters if not provided + if h is None: # By default, sha1 + h = "sha1" + if not h in _hashFuncParams: + warning("Key._rsassa_pss_verify(): unknown hash function " + "provided (%s)" % h) + return False + if mgf is None: # use mgf1 with underlying hash function + mgf = lambda x,y: pkcs_mgf1(x, y, h) + if sLen is None: # use Hash output length (A.2.3 of RFC 3447) + hLen = _hashFuncParams[h][0] + sLen = hLen + + # 1) Length checking + modBits = self.modulusLen + k = modBits / 8 + if len(S) != k: + return False + + # 2) RSA verification + s = pkcs_os2ip(S) # 2.a) + m = self._rsavp1(s) # 2.b) + emLen = math.ceil((modBits - 1) / 8.) # 2.c) + EM = pkcs_i2osp(m, emLen) + + # 3) EMSA-PSS verification + Result = pkcs_emsa_pss_verify(M, EM, modBits - 1, h, mgf, sLen) + + return Result # 4) + + + def _rsassa_pkcs1_v1_5_verify(self, M, S, h): + """ + Implements RSASSA-PKCS1-v1_5-VERIFY() function as described in + Sect. 8.2.2 of RFC 3447. + + Input: + M: message whose signature is to be verified, an octet string + S: signature to be verified, an octet string of length k, where + k is the length in octets of the RSA modulus n + h: hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). + + Output: + True if the signature is valid. False otherwise. + """ + + # 1) Length checking + k = self.modulusLen / 8 + if len(S) != k: + warning("invalid signature (len(S) != k)") + return False + + # 2) RSA verification + s = pkcs_os2ip(S) # 2.a) + m = self._rsavp1(s) # 2.b) + EM = pkcs_i2osp(m, k) # 2.c) + + # 3) EMSA-PKCS1-v1_5 encoding + EMPrime = pkcs_emsa_pkcs1_v1_5_encode(M, k, h) + if EMPrime is None: + warning("Key._rsassa_pkcs1_v1_5_verify(): unable to encode.") + return False + + # 4) Comparison + return EM == EMPrime + + + def verify(self, M, S, t=None, h=None, mgf=None, sLen=None): + """ + Verify alleged signature 'S' is indeed the signature of message 'M' using + 't' signature scheme where 't' can be: + + - None: the alleged signature 'S' is directly applied the RSAVP1 signature + primitive, as described in PKCS#1 v2.1, i.e. RFC 3447 Sect + 5.2.1. Simply put, the provided signature is applied a moular + exponentiation using the public key. Then, a comparison of the + result is done against 'M'. On match, True is returned. + Additionnal method parameters are just ignored. + + - 'pkcs': the alleged signature 'S' and message 'M' are applied + RSASSA-PKCS1-v1_5-VERIFY signature verification scheme as + described in Sect. 8.2.2 of RFC 3447. In that context, + the hash function name is passed using 'h'. Possible values are + "md2", "md4", "md5", "sha1", "tls", "sha224", "sha256", "sha384" + and "sha512". If none is provided, sha1 is used. Other additionnal + parameters are ignored. + + - 'pss': the alleged signature 'S' and message 'M' are applied + RSASSA-PSS-VERIFY signature scheme as described in Sect. 8.1.2. + of RFC 3447. In that context, + + o 'h' parameter provides the name of the hash method to use. + Possible values are "md2", "md4", "md5", "sha1", "tls", "sha224", + "sha256", "sha384" and "sha512". if none is provided, sha1 + is used. + + o 'mgf' is the mask generation function. By default, mgf + is derived from the provided hash function using the + generic MGF1 (see pkcs_mgf1() for details). + + o 'sLen' is the length in octet of the salt. You can overload the + default value (the octet length of the hash value for provided + algorithm) by providing another one with that parameter. + """ + if t is None: # RSAVP1 + S = pkcs_os2ip(S) + n = self.modulus + if S > n-1: + warning("Signature to be verified is too long for key modulus") + return False + m = self._rsavp1(S) + if m is None: + return False + l = int(math.ceil(math.log(m, 2) / 8.)) # Hack + m = pkcs_i2osp(m, l) + return M == m + + elif t == "pkcs": # RSASSA-PKCS1-v1_5-VERIFY + if h is None: + h = "sha1" + return self._rsassa_pkcs1_v1_5_verify(M, S, h) + + elif t == "pss": # RSASSA-PSS-VERIFY + return self._rsassa_pss_verify(M, S, h, mgf, sLen) + + else: + warning("Key.verify(): Unknown signature type (%s) provided" % t) + return None + +class _DecryptAndSignMethods(OSSLHelper): + ### Below are decryption related methods. Encryption ones are inherited + ### from PubKey + + def _rsadp(self, c): + """ + Internal method providing raw RSA decryption, i.e. simple modular + exponentiation of the given ciphertext representative 'c', a long + between 0 and n-1. + + This is the decryption primitive RSADP described in PKCS#1 v2.1, + i.e. RFC 3447 Sect. 5.1.2. + + Input: + c: ciphertest representative, a long between 0 and n-1, where + n is the key modulus. + + Output: + ciphertext representative, a long between 0 and n-1 + + Not intended to be used directly. Please, see encrypt() method. + """ + + n = self.modulus + if type(c) is int: + c = long(c) + if type(c) is not long or c > n-1: + warning("Key._rsaep() expects a long between 0 and n-1") + return None + + return self.key.decrypt(c) + + + def _rsaes_pkcs1_v1_5_decrypt(self, C): + """ + Implements RSAES-PKCS1-V1_5-DECRYPT() function described in section + 7.2.2 of RFC 3447. + + Input: + C: ciphertext to be decrypted, an octet string of length k, where + k is the length in octets of the RSA modulus n. + + Output: + an octet string of length k at most k - 11 + + on error, None is returned. + """ + + # 1) Length checking + cLen = len(C) + k = self.modulusLen / 8 + if cLen != k or k < 11: + warning("Key._rsaes_pkcs1_v1_5_decrypt() decryption error " + "(cLen != k or k < 11)") + return None + + # 2) RSA decryption + c = pkcs_os2ip(C) # 2.a) + m = self._rsadp(c) # 2.b) + EM = pkcs_i2osp(m, k) # 2.c) + + # 3) EME-PKCS1-v1_5 decoding + + # I am aware of the note at the end of 7.2.2 regarding error + # conditions reporting but the one provided below are for _local_ + # debugging purposes. --arno + + if EM[0] != '\x00': + warning("Key._rsaes_pkcs1_v1_5_decrypt(): decryption error " + "(first byte is not 0x00)") + return None + + if EM[1] != '\x02': + warning("Key._rsaes_pkcs1_v1_5_decrypt(): decryption error " + "(second byte is not 0x02)") + return None + + tmp = EM[2:].split('\x00', 1) + if len(tmp) != 2: + warning("Key._rsaes_pkcs1_v1_5_decrypt(): decryption error " + "(no 0x00 to separate PS from M)") + return None + + PS, M = tmp + if len(PS) < 8: + warning("Key._rsaes_pkcs1_v1_5_decrypt(): decryption error " + "(PS is less than 8 byte long)") + return None + + return M # 4) + + + def _rsaes_oaep_decrypt(self, C, h=None, mgf=None, L=None): + """ + Internal method providing RSAES-OAEP-DECRYPT as defined in Sect. + 7.1.2 of RFC 3447. Not intended to be used directly. Please, see + encrypt() method for type "OAEP". + + + Input: + C : ciphertext to be decrypted, an octet string of length k, where + k = 2*hLen + 2 (k denotes the length in octets of the RSA modulus + and hLen the length in octets of the hash function output) + h : hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls', + 'sha256', 'sha384'). 'sha1' is used if none is provided. + mgf: the mask generation function f : seed, maskLen -> mask + L : optional label whose association with the message is to be + verified; the default value for L, if not provided is the empty + string. + + Output: + message, an octet string of length k mLen, where mLen <= k - 2*hLen - 2 + + On error, None is returned. + """ + # The steps below are the one described in Sect. 7.1.2 of RFC 3447. + + # 1) Length Checking + # 1.a) is not done + if h is None: + h = "sha1" + if not h in _hashFuncParams: + warning("Key._rsaes_oaep_decrypt(): unknown hash function %s.", h) + return None + hLen = _hashFuncParams[h][0] + hFun = _hashFuncParams[h][1] + k = self.modulusLen / 8 + cLen = len(C) + if cLen != k: # 1.b) + warning("Key._rsaes_oaep_decrypt(): decryption error. " + "(cLen != k)") + return None + if k < 2*hLen + 2: + warning("Key._rsaes_oaep_decrypt(): decryption error. " + "(k < 2*hLen + 2)") + return None + + # 2) RSA decryption + c = pkcs_os2ip(C) # 2.a) + m = self._rsadp(c) # 2.b) + EM = pkcs_i2osp(m, k) # 2.c) + + # 3) EME-OAEP decoding + if L is None: # 3.a) + L = "" + lHash = hFun(L) + Y = EM[:1] # 3.b) + if Y != '\x00': + warning("Key._rsaes_oaep_decrypt(): decryption error. " + "(Y is not zero)") + return None + maskedSeed = EM[1:1+hLen] + maskedDB = EM[1+hLen:] + if mgf is None: + mgf = lambda x,y: pkcs_mgf1(x, y, h) + seedMask = mgf(maskedDB, hLen) # 3.c) + seed = strxor(maskedSeed, seedMask) # 3.d) + dbMask = mgf(seed, k - hLen - 1) # 3.e) + DB = strxor(maskedDB, dbMask) # 3.f) + + # I am aware of the note at the end of 7.1.2 regarding error + # conditions reporting but the one provided below are for _local_ + # debugging purposes. --arno + + lHashPrime = DB[:hLen] # 3.g) + tmp = DB[hLen:].split('\x01', 1) + if len(tmp) != 2: + warning("Key._rsaes_oaep_decrypt(): decryption error. " + "(0x01 separator not found)") + return None + PS, M = tmp + if PS != '\x00'*len(PS): + warning("Key._rsaes_oaep_decrypt(): decryption error. " + "(invalid padding string)") + return None + if lHash != lHashPrime: + warning("Key._rsaes_oaep_decrypt(): decryption error. " + "(invalid hash)") + return None + return M # 4) + + + def decrypt(self, C, t=None, h=None, mgf=None, L=None): + """ + Decrypt ciphertext 'C' using 't' decryption scheme where 't' can be: + + - None: the ciphertext 'C' is directly applied the RSADP decryption + primitive, as described in PKCS#1 v2.1, i.e. RFC 3447 + Sect 5.1.2. Simply, put the message undergo a modular + exponentiation using the private key. Additionnal method + parameters are just ignored. + + - 'pkcs': the ciphertext 'C' is applied RSAES-PKCS1-V1_5-DECRYPT + decryption scheme as described in section 7.2.2 of RFC 3447. + In that context, other parameters ('h', 'mgf', 'l') are not + used. + + - 'oaep': the ciphertext 'C' is applied the RSAES-OAEP-DECRYPT decryption + scheme, as described in PKCS#1 v2.1, i.e. RFC 3447 Sect + 7.1.2. In that context, + + o 'h' parameter provides the name of the hash method to use. + Possible values are "md2", "md4", "md5", "sha1", "tls", + "sha224", "sha256", "sha384" and "sha512". if none is provided, + sha1 is used by default. + + o 'mgf' is the mask generation function. By default, mgf + is derived from the provided hash function using the + generic MGF1 (see pkcs_mgf1() for details). + + o 'L' is the optional label to be associated with the + message. If not provided, the default value is used, i.e + the empty string. No check is done on the input limitation + of the hash function regarding the size of 'L' (for + instance, 2^61 - 1 for SHA-1). You have been warned. + """ + if t is None: + C = pkcs_os2ip(C) + c = self._rsadp(C) + l = int(math.ceil(math.log(c, 2) / 8.)) # Hack + return pkcs_i2osp(c, l) + + elif t == "pkcs": + return self._rsaes_pkcs1_v1_5_decrypt(C) + + elif t == "oaep": + return self._rsaes_oaep_decrypt(C, h, mgf, L) + + else: + warning("Key.decrypt(): Unknown decryption type (%s) provided" % t) + return None + + ### Below are signature related methods. Verification ones are inherited from + ### PubKey + + def _rsasp1(self, m): + """ + Internal method providing raw RSA signature, i.e. simple modular + exponentiation of the given message representative 'm', an integer + between 0 and n-1. + + This is the signature primitive RSASP1 described in PKCS#1 v2.1, + i.e. RFC 3447 Sect. 5.2.1. + + Input: + m: message representative, an integer between 0 and n-1, where + n is the key modulus. + + Output: + signature representative, an integer between 0 and n-1 + + Not intended to be used directly. Please, see sign() method. + """ + return self._rsadp(m) + + + def _rsassa_pss_sign(self, M, h=None, mgf=None, sLen=None): + """ + Implements RSASSA-PSS-SIGN() function described in Sect. 8.1.1 of + RFC 3447. + + Input: + M: message to be signed, an octet string + + Output: + signature, an octet string of length k, where k is the length in + octets of the RSA modulus n. + + On error, None is returned. + """ + + # Set default parameters if not provided + if h is None: # By default, sha1 + h = "sha1" + if not h in _hashFuncParams: + warning("Key._rsassa_pss_sign(): unknown hash function " + "provided (%s)" % h) + return None + if mgf is None: # use mgf1 with underlying hash function + mgf = lambda x,y: pkcs_mgf1(x, y, h) + if sLen is None: # use Hash output length (A.2.3 of RFC 3447) + hLen = _hashFuncParams[h][0] + sLen = hLen + + # 1) EMSA-PSS encoding + modBits = self.modulusLen + k = modBits / 8 + EM = pkcs_emsa_pss_encode(M, modBits - 1, h, mgf, sLen) + if EM is None: + warning("Key._rsassa_pss_sign(): unable to encode") + return None + + # 2) RSA signature + m = pkcs_os2ip(EM) # 2.a) + s = self._rsasp1(m) # 2.b) + S = pkcs_i2osp(s, k) # 2.c) + + return S # 3) + + + def _rsassa_pkcs1_v1_5_sign(self, M, h): + """ + Implements RSASSA-PKCS1-v1_5-SIGN() function as described in + Sect. 8.2.1 of RFC 3447. + + Input: + M: message to be signed, an octet string + h: hash function name (in 'md2', 'md4', 'md5', 'sha1', 'tls' + 'sha256', 'sha384'). + + Output: + the signature, an octet string. + """ + + # 1) EMSA-PKCS1-v1_5 encoding + k = self.modulusLen / 8 + EM = pkcs_emsa_pkcs1_v1_5_encode(M, k, h) + if EM is None: + warning("Key._rsassa_pkcs1_v1_5_sign(): unable to encode") + return None + + # 2) RSA signature + m = pkcs_os2ip(EM) # 2.a) + s = self._rsasp1(m) # 2.b) + S = pkcs_i2osp(s, k) # 2.c) + + return S # 3) + + + def sign(self, M, t=None, h=None, mgf=None, sLen=None): + """ + Sign message 'M' using 't' signature scheme where 't' can be: + + - None: the message 'M' is directly applied the RSASP1 signature + primitive, as described in PKCS#1 v2.1, i.e. RFC 3447 Sect + 5.2.1. Simply put, the message undergo a modular exponentiation + using the private key. Additionnal method parameters are just + ignored. + + - 'pkcs': the message 'M' is applied RSASSA-PKCS1-v1_5-SIGN signature + scheme as described in Sect. 8.2.1 of RFC 3447. In that context, + the hash function name is passed using 'h'. Possible values are + "md2", "md4", "md5", "sha1", "tls", "sha224", "sha256", "sha384" + and "sha512". If none is provided, sha1 is used. Other additionnal + parameters are ignored. + + - 'pss' : the message 'M' is applied RSASSA-PSS-SIGN signature scheme as + described in Sect. 8.1.1. of RFC 3447. In that context, + + o 'h' parameter provides the name of the hash method to use. + Possible values are "md2", "md4", "md5", "sha1", "tls", "sha224", + "sha256", "sha384" and "sha512". if none is provided, sha1 + is used. + + o 'mgf' is the mask generation function. By default, mgf + is derived from the provided hash function using the + generic MGF1 (see pkcs_mgf1() for details). + + o 'sLen' is the length in octet of the salt. You can overload the + default value (the octet length of the hash value for provided + algorithm) by providing another one with that parameter. + """ + + if t is None: # RSASP1 + M = pkcs_os2ip(M) + n = self.modulus + if M > n-1: + warning("Message to be signed is too long for key modulus") + return None + s = self._rsasp1(M) + if s is None: + return None + return pkcs_i2osp(s, self.modulusLen/8) + + elif t == "pkcs": # RSASSA-PKCS1-v1_5-SIGN + if h is None: + h = "sha1" + return self._rsassa_pkcs1_v1_5_sign(M, h) + + elif t == "pss": # RSASSA-PSS-SIGN + return self._rsassa_pss_sign(M, h, mgf, sLen) + + else: + warning("Key.sign(): Unknown signature type (%s) provided" % t) + return None + + +def openssl_parse_RSA(fmt="PEM"): + return popen3(['openssl', 'rsa', '-text', '-pubin', '-inform', fmt, '-noout']) +def openssl_convert_RSA(infmt="PEM", outfmt="DER"): + return ['openssl', 'rsa', '-pubin', '-inform', infmt, '-outform', outfmt] + +class PubKey(OSSLHelper, _EncryptAndVerify): + # Below are the fields we recognize in the -text output of openssl + # and from which we extract information. We expect them in that + # order. Number of spaces does matter. + possible_fields = [ "Modulus (", + "Exponent:" ] + possible_fields_count = len(possible_fields) + + def __init__(self, keypath): + error_msg = "Unable to import key." + + # XXX Temporary hack to use PubKey inside Cert + if type(keypath) is tuple: + e, m, mLen = keypath + self.modulus = m + self.modulusLen = mLen + self.pubExp = e + return + + fields_dict = {} + for k in self.possible_fields: + fields_dict[k] = None + + self.keypath = None + rawkey = None + + if (not '\x00' in keypath) and os.path.isfile(keypath): # file + self.keypath = keypath + key_size = os.path.getsize(keypath) + if key_size > MAX_KEY_SIZE: + raise Exception(error_msg) + try: + f = open(keypath) + rawkey = f.read() + f.close() + except: + raise Exception(error_msg) + else: + rawkey = keypath + + if rawkey is None: + raise Exception(error_msg) + + self.rawkey = rawkey + + key_header = "-----BEGIN PUBLIC KEY-----" + key_footer = "-----END PUBLIC KEY-----" + l = rawkey.split(key_header, 1) + if len(l) == 2: # looks like PEM + tmp = l[1] + l = tmp.split(key_footer, 1) + if len(l) == 2: + tmp = l[0] + rawkey = "%s%s%s\n" % (key_header, tmp, key_footer) + else: + raise Exception(error_msg) + r,w,e = openssl_parse_RSA("PEM") + w.write(rawkey) + w.close() + textkey = r.read() + r.close() + res = e.read() + e.close() + if res == '': + self.format = "PEM" + self.pemkey = rawkey + self.textkey = textkey + cmd = openssl_convert_RSA_cmd("PEM", "DER") + self.derkey = self._apply_ossl_cmd(cmd, rawkey) + else: + raise Exception(error_msg) + else: # not PEM, try DER + r,w,e = openssl_parse_RSA("DER") + w.write(rawkey) + w.close() + textkey = r.read() + r.close() + res = e.read() + if res == '': + self.format = "DER" + self.derkey = rawkey + self.textkey = textkey + cmd = openssl_convert_RSA_cmd("DER", "PEM") + self.pemkey = self._apply_ossl_cmd(cmd, rawkey) + cmd = openssl_convert_RSA_cmd("DER", "DER") + self.derkey = self._apply_ossl_cmd(cmd, rawkey) + else: + try: # Perhaps it is a cert + c = Cert(keypath) + except: + raise Exception(error_msg) + # TODO: + # Reconstruct a key (der and pem) and provide: + # self.format + # self.derkey + # self.pemkey + # self.textkey + # self.keypath + + self.osslcmdbase = ['openssl', 'rsa', '-pubin', '-inform', self.format] + + self.keypath = keypath + + # Parse the -text output of openssl to make things available + l = self.textkey.split('\n', 1) + if len(l) != 2: + raise Exception(error_msg) + cur, tmp = l + i = 0 + k = self.possible_fields[i] # Modulus ( + cur = cur[len(k):] + '\n' + while k: + l = tmp.split('\n', 1) + if len(l) != 2: # Over + fields_dict[k] = cur + break + l, tmp = l + + newkey = 0 + # skip fields we have already seen, this is the purpose of 'i' + for j in range(i, self.possible_fields_count): + f = self.possible_fields[j] + if l.startswith(f): + fields_dict[k] = cur + cur = l[len(f):] + '\n' + k = f + newkey = 1 + i = j+1 + break + if newkey == 1: + continue + cur += l + '\n' + + # modulus and modulus length + v = fields_dict["Modulus ("] + self.modulusLen = None + if v: + v, rem = v.split(' bit):', 1) + self.modulusLen = int(v) + rem = rem.replace('\n','').replace(' ','').replace(':','') + self.modulus = long(rem, 16) + if self.modulus is None: + raise Exception(error_msg) + + # public exponent + v = fields_dict["Exponent:"] + self.pubExp = None + if v: + self.pubExp = long(v.split('(', 1)[0]) + if self.pubExp is None: + raise Exception(error_msg) + + self.key = RSA.construct((self.modulus, self.pubExp, )) + + def __str__(self): + return self.derkey + + +class Key(_DecryptAndSignMethods, _EncryptAndVerify): + # Below are the fields we recognize in the -text output of openssl + # and from which we extract information. We expect them in that + # order. Number of spaces does matter. + possible_fields = [ "Private-Key: (", + "modulus:", + "publicExponent:", + "privateExponent:", + "prime1:", + "prime2:", + "exponent1:", + "exponent2:", + "coefficient:" ] + possible_fields_count = len(possible_fields) + + def __init__(self, keypath): + error_msg = "Unable to import key." + + fields_dict = {} + for k in self.possible_fields: + fields_dict[k] = None + + self.keypath = None + rawkey = None + + if (not '\x00' in keypath) and os.path.isfile(keypath): + self.keypath = keypath + key_size = os.path.getsize(keypath) + if key_size > MAX_KEY_SIZE: + raise Exception(error_msg) + try: + f = open(keypath) + rawkey = f.read() + f.close() + except: + raise Exception(error_msg) + else: + rawkey = keypath + + if rawkey is None: + raise Exception(error_msg) + + self.rawkey = rawkey + + # Let's try to get file format : PEM or DER. + fmtstr = 'openssl rsa -text -inform %s -noout' + convertstr = 'openssl rsa -inform %s -outform %s' + key_header = "-----BEGIN RSA PRIVATE KEY-----" + key_footer = "-----END RSA PRIVATE KEY-----" + l = rawkey.split(key_header, 1) + if len(l) == 2: # looks like PEM + tmp = l[1] + l = tmp.split(key_footer, 1) + if len(l) == 2: + tmp = l[0] + rawkey = "%s%s%s\n" % (key_header, tmp, key_footer) + else: + raise Exception(error_msg) + r,w,e = popen3((fmtstr % "PEM").split(" ")) + w.write(rawkey) + w.close() + textkey = r.read() + r.close() + res = e.read() + e.close() + if res == '': + self.format = "PEM" + self.pemkey = rawkey + self.textkey = textkey + cmd = (convertstr % ("PEM", "DER")).split(" ") + self.derkey = self._apply_ossl_cmd(cmd, rawkey) + else: + raise Exception(error_msg) + else: # not PEM, try DER + r,w,e = popen3((fmtstr % "DER").split(" ")) + w.write(rawkey) + w.close() + textkey = r.read() + r.close() + res = e.read() + if res == '': + self.format = "DER" + self.derkey = rawkey + self.textkey = textkey + cmd = (convertstr % ("DER", "PEM")).split(" ") + self.pemkey = self._apply_ossl_cmd(cmd, rawkey) + cmd = (convertstr % ("DER", "DER")).split(" ") + self.derkey = self._apply_ossl_cmd(cmd, rawkey) + else: + raise Exception(error_msg) + + self.osslcmdbase = ['openssl', 'rsa', '-inform', self.format] + + r,w,e = popen3(["openssl", "asn1parse", "-inform", "DER"]) + w.write(self.derkey) + w.close() + self.asn1parsekey = r.read() + r.close() + res = e.read() + e.close() + if res != '': + raise Exception(error_msg) + + self.keypath = keypath + + # Parse the -text output of openssl to make things available + l = self.textkey.split('\n', 1) + if len(l) != 2: + raise Exception(error_msg) + cur, tmp = l + i = 0 + k = self.possible_fields[i] # Private-Key: ( + cur = cur[len(k):] + '\n' + while k: + l = tmp.split('\n', 1) + if len(l) != 2: # Over + fields_dict[k] = cur + break + l, tmp = l + + newkey = 0 + # skip fields we have already seen, this is the purpose of 'i' + for j in range(i, self.possible_fields_count): + f = self.possible_fields[j] + if l.startswith(f): + fields_dict[k] = cur + cur = l[len(f):] + '\n' + k = f + newkey = 1 + i = j+1 + break + if newkey == 1: + continue + cur += l + '\n' + + # modulus length + v = fields_dict["Private-Key: ("] + self.modulusLen = None + if v: + self.modulusLen = int(v.split(' bit', 1)[0]) + if self.modulusLen is None: + raise Exception(error_msg) + + # public exponent + v = fields_dict["publicExponent:"] + self.pubExp = None + if v: + self.pubExp = long(v.split('(', 1)[0]) + if self.pubExp is None: + raise Exception(error_msg) + + tmp = {} + for k in ["modulus:", "privateExponent:", "prime1:", "prime2:", + "exponent1:", "exponent2:", "coefficient:"]: + v = fields_dict[k] + if v: + s = v.replace('\n', '').replace(' ', '').replace(':', '') + tmp[k] = long(s, 16) + else: + raise Exception(error_msg) + + self.modulus = tmp["modulus:"] + self.privExp = tmp["privateExponent:"] + self.prime1 = tmp["prime1:"] + self.prime2 = tmp["prime2:"] + self.exponent1 = tmp["exponent1:"] + self.exponent2 = tmp["exponent2:"] + self.coefficient = tmp["coefficient:"] + + self.key = RSA.construct((self.modulus, self.pubExp, self.privExp)) + + def __str__(self): + return self.derkey + + +# We inherit from PubKey to get access to all encryption and verification +# methods. To have that working, we simply need Cert to provide +# modulusLen and key attribute. +# XXX Yes, it is a hack. +class Cert(OSSLHelper, _EncryptAndVerify): + # Below are the fields we recognize in the -text output of openssl + # and from which we extract information. We expect them in that + # order. Number of spaces does matter. + possible_fields = [ " Version:", + " Serial Number:", + " Signature Algorithm:", + " Issuer:", + " Not Before:", + " Not After :", + " Subject:", + " Public Key Algorithm:", + " Modulus (", + " Exponent:", + " X509v3 Subject Key Identifier:", + " X509v3 Authority Key Identifier:", + " keyid:", + " DirName:", + " serial:", + " X509v3 Basic Constraints:", + " X509v3 Key Usage:", + " X509v3 Extended Key Usage:", + " X509v3 CRL Distribution Points:", + " Authority Information Access:", + " Signature Algorithm:" ] + possible_fields_count = len(possible_fields) + + def __init__(self, certpath): + error_msg = "Unable to import certificate." + + fields_dict = {} + for k in self.possible_fields: + fields_dict[k] = None + + self.certpath = None + rawcert = None + + if (not '\x00' in certpath) and os.path.isfile(certpath): # file + self.certpath = certpath + cert_size = os.path.getsize(certpath) + if cert_size > MAX_CERT_SIZE: + raise Exception(error_msg) + try: + f = open(certpath) + rawcert = f.read() + f.close() + except: + raise Exception(error_msg) + else: + rawcert = certpath + + if rawcert is None: + raise Exception(error_msg) + + self.rawcert = rawcert + + # Let's try to get file format : PEM or DER. + fmtstr = 'openssl x509 -text -inform %s -noout' + convertstr = 'openssl x509 -inform %s -outform %s' + cert_header = "-----BEGIN CERTIFICATE-----" + cert_footer = "-----END CERTIFICATE-----" + l = rawcert.split(cert_header, 1) + if len(l) == 2: # looks like PEM + tmp = l[1] + l = tmp.split(cert_footer, 1) + if len(l) == 2: + tmp = l[0] + rawcert = "%s%s%s\n" % (cert_header, tmp, cert_footer) + else: + raise Exception(error_msg) + r,w,e = popen3((fmtstr % "PEM").split(" ")) + w.write(rawcert) + w.close() + textcert = r.read() + r.close() + res = e.read() + e.close() + if res == '': + self.format = "PEM" + self.pemcert = rawcert + self.textcert = textcert + cmd = (convertstr % ("PEM", "DER")).split(" ") + self.dercert = self._apply_ossl_cmd(cmd, rawcert) + else: + raise Exception(error_msg) + else: # not PEM, try DER + r,w,e = popen3((fmtstr % "DER").split(" ")) + w.write(rawcert) + w.close() + textcert = r.read() + r.close() + res = e.read() + if res == '': + self.format = "DER" + self.dercert = rawcert + self.textcert = textcert + cmd = (convertstr % ("DER", "PEM")).split(" ") + self.pemcert = self._apply_ossl_cmd(cmd, rawcert) + cmd = (convertstr % ("DER", "DER")).split(" ") + self.dercert = self._apply_ossl_cmd(cmd, rawcert) + else: + raise Exception(error_msg) + + self.osslcmdbase = ['openssl', 'x509', '-inform', self.format] + + r,w,e = popen3('openssl asn1parse -inform DER'.split(' ')) + w.write(self.dercert) + w.close() + self.asn1parsecert = r.read() + r.close() + res = e.read() + e.close() + if res != '': + raise Exception(error_msg) + + # Grab _raw_ X509v3 Authority Key Identifier, if any. + tmp = self.asn1parsecert.split(":X509v3 Authority Key Identifier", 1) + self.authorityKeyID = None + if len(tmp) == 2: + tmp = tmp[1] + tmp = tmp.split("[HEX DUMP]:", 1)[1] + self.authorityKeyID=tmp.split('\n',1)[0] + + # Grab _raw_ X509v3 Subject Key Identifier, if any. + tmp = self.asn1parsecert.split(":X509v3 Subject Key Identifier", 1) + self.subjectKeyID = None + if len(tmp) == 2: + tmp = tmp[1] + tmp = tmp.split("[HEX DUMP]:", 1)[1] + self.subjectKeyID=tmp.split('\n',1)[0] + + # Get tbsCertificate using the worst hack. output of asn1parse + # looks like that: + # + # 0:d=0 hl=4 l=1298 cons: SEQUENCE + # 4:d=1 hl=4 l=1018 cons: SEQUENCE + # ... + # + l1,l2 = self.asn1parsecert.split('\n', 2)[:2] + hl1 = int(l1.split("hl=",1)[1].split("l=",1)[0]) + rem = l2.split("hl=",1)[1] + hl2, rem = rem.split("l=",1) + hl2 = int(hl2) + l = int(rem.split("cons",1)[0]) + self.tbsCertificate = self.dercert[hl1:hl1+hl2+l] + + # Parse the -text output of openssl to make things available + tmp = self.textcert.split('\n', 2)[2] + l = tmp.split('\n', 1) + if len(l) != 2: + raise Exception(error_msg) + cur, tmp = l + i = 0 + k = self.possible_fields[i] # Version: + cur = cur[len(k):] + '\n' + while k: + l = tmp.split('\n', 1) + if len(l) != 2: # Over + fields_dict[k] = cur + break + l, tmp = l + + newkey = 0 + # skip fields we have already seen, this is the purpose of 'i' + for j in range(i, self.possible_fields_count): + f = self.possible_fields[j] + if l.startswith(f): + fields_dict[k] = cur + cur = l[len(f):] + '\n' + k = f + newkey = 1 + i = j+1 + break + if newkey == 1: + continue + cur += l + '\n' + + # version + v = fields_dict[" Version:"] + self.version = None + if v: + self.version = int(v[1:2]) + if self.version is None: + raise Exception(error_msg) + + # serial number + v = fields_dict[" Serial Number:"] + self.serial = None + if v: + v = v.replace('\n', '').strip() + if "0x" in v: + v = v.split("0x", 1)[1].split(')', 1)[0] + v = v.replace(':', '').upper() + if len(v) % 2: + v = '0' + v + self.serial = v + if self.serial is None: + raise Exception(error_msg) + + # Signature Algorithm + v = fields_dict[" Signature Algorithm:"] + self.sigAlg = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.sigAlg = v + if self.sigAlg is None: + raise Exception(error_msg) + + # issuer + v = fields_dict[" Issuer:"] + self.issuer = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.issuer = v + if self.issuer is None: + raise Exception(error_msg) + + # not before + v = fields_dict[" Not Before:"] + self.notBefore_str = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.notBefore_str = v + if self.notBefore_str is None: + raise Exception(error_msg) + try: + self.notBefore = time.strptime(self.notBefore_str, + "%b %d %H:%M:%S %Y %Z") + except: + self.notBefore = time.strptime(self.notBefore_str, + "%b %d %H:%M:%S %Y") + self.notBefore_str_simple = time.strftime("%x", self.notBefore) + + # not after + v = fields_dict[" Not After :"] + self.notAfter_str = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.notAfter_str = v + if self.notAfter_str is None: + raise Exception(error_msg) + try: + self.notAfter = time.strptime(self.notAfter_str, + "%b %d %H:%M:%S %Y %Z") + except: + self.notAfter = time.strptime(self.notAfter_str, + "%b %d %H:%M:%S %Y") + self.notAfter_str_simple = time.strftime("%x", self.notAfter) + + # subject + v = fields_dict[" Subject:"] + self.subject = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.subject = v + if self.subject is None: + raise Exception(error_msg) + + # Public Key Algorithm + v = fields_dict[" Public Key Algorithm:"] + self.pubKeyAlg = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.pubKeyAlg = v + if self.pubKeyAlg is None: + raise Exception(error_msg) + + # Modulus + v = fields_dict[" Modulus ("] + self.modulus = None + if v: + v,t = v.split(' bit):',1) + self.modulusLen = int(v) + t = t.replace(' ', '').replace('\n', ''). replace(':', '') + self.modulus_hexdump = t + self.modulus = long(t, 16) + if self.modulus is None: + raise Exception(error_msg) + + # Exponent + v = fields_dict[" Exponent:"] + self.exponent = None + if v: + v = v.split('(',1)[0] + self.exponent = long(v) + if self.exponent is None: + raise Exception(error_msg) + + # Public Key instance + self.key = RSA.construct((self.modulus, self.exponent, )) + + # Subject Key Identifier + + # Authority Key Identifier: keyid, dirname and serial + self.authorityKeyID_keyid = None + self.authorityKeyID_dirname = None + self.authorityKeyID_serial = None + if self.authorityKeyID: # (hex version already done using asn1parse) + v = fields_dict[" keyid:"] + if v: + v = v.split('\n',1)[0] + v = v.strip().replace(':', '') + self.authorityKeyID_keyid = v + v = fields_dict[" DirName:"] + if v: + v = v.split('\n',1)[0] + self.authorityKeyID_dirname = v + v = fields_dict[" serial:"] + if v: + v = v.split('\n',1)[0] + v = v.strip().replace(':', '') + self.authorityKeyID_serial = v + + # Basic constraints + self.basicConstraintsCritical = False + self.basicConstraints=None + v = fields_dict[" X509v3 Basic Constraints:"] + if v: + self.basicConstraints = {} + v,t = v.split('\n',2)[:2] + if "critical" in v: + self.basicConstraintsCritical = True + if "CA:" in t: + self.basicConstraints["CA"] = t.split('CA:')[1][:4] == "TRUE" + if "pathlen:" in t: + self.basicConstraints["pathlen"] = int(t.split('pathlen:')[1]) + + # X509v3 Key Usage + self.keyUsage = [] + v = fields_dict[" X509v3 Key Usage:"] + if v: + # man 5 x509v3_config + ku_mapping = {"Digital Signature": "digitalSignature", + "Non Repudiation": "nonRepudiation", + "Key Encipherment": "keyEncipherment", + "Data Encipherment": "dataEncipherment", + "Key Agreement": "keyAgreement", + "Certificate Sign": "keyCertSign", + "CRL Sign": "cRLSign", + "Encipher Only": "encipherOnly", + "Decipher Only": "decipherOnly"} + v = v.split('\n',2)[1] + l = map(lambda x: x.strip(), v.split(',')) + while l: + c = l.pop() + if c in ku_mapping: + self.keyUsage.append(ku_mapping[c]) + else: + self.keyUsage.append(c) # Add it anyway + print("Found unknown X509v3 Key Usage: '%s'" % c) + print("Report it to arno (at) natisbad.org for addition") + + # X509v3 Extended Key Usage + self.extKeyUsage = [] + v = fields_dict[" X509v3 Extended Key Usage:"] + if v: + # man 5 x509v3_config: + eku_mapping = {"TLS Web Server Authentication": "serverAuth", + "TLS Web Client Authentication": "clientAuth", + "Code Signing": "codeSigning", + "E-mail Protection": "emailProtection", + "Time Stamping": "timeStamping", + "Microsoft Individual Code Signing": "msCodeInd", + "Microsoft Commercial Code Signing": "msCodeCom", + "Microsoft Trust List Signing": "msCTLSign", + "Microsoft Encrypted File System": "msEFS", + "Microsoft Server Gated Crypto": "msSGC", + "Netscape Server Gated Crypto": "nsSGC", + "IPSec End System": "iPsecEndSystem", + "IPSec Tunnel": "iPsecTunnel", + "IPSec User": "iPsecUser"} + v = v.split('\n',2)[1] + l = map(lambda x: x.strip(), v.split(',')) + while l: + c = l.pop() + if c in eku_mapping: + self.extKeyUsage.append(eku_mapping[c]) + else: + self.extKeyUsage.append(c) # Add it anyway + print("Found unknown X509v3 Extended Key Usage: '%s'" % c) + print("Report it to arno (at) natisbad.org for addition") + + # CRL Distribution points + self.cRLDistributionPoints = [] + v = fields_dict[" X509v3 CRL Distribution Points:"] + if v: + v = v.split("\n\n", 1)[0] + v = v.split("URI:")[1:] + self.CRLDistributionPoints = map(lambda x: x.strip(), v) + + # Authority Information Access: list of tuples ("method", "location") + self.authorityInfoAccess = [] + v = fields_dict[" Authority Information Access:"] + if v: + v = v.split("\n\n", 1)[0] + v = v.split("\n")[1:] + for e in v: + method, location = map(lambda x: x.strip(), e.split(" - ", 1)) + self.authorityInfoAccess.append((method, location)) + + # signature field + v = fields_dict[" Signature Algorithm:" ] + self.sig = None + if v: + v = v.split('\n',1)[1] + v = v.replace(' ', '').replace('\n', '') + self.sig = "".join(map(lambda x: chr(int(x, 16)), v.split(':'))) + self.sigLen = len(self.sig) + if self.sig is None: + raise Exception(error_msg) + + def isIssuerCert(self, other): + """ + True if 'other' issued 'self', i.e.: + - self.issuer == other.subject + - self is signed by other + """ + # XXX should be done on raw values, instead of their textual repr + if self.issuer != other.subject: + return False + + # Sanity check regarding modulus length and the + # signature length + keyLen = (other.modulusLen + 7)/8 + if keyLen != self.sigLen: + return False + + unenc = other.encrypt(self.sig) # public key encryption, i.e. decrypt + + # XXX Check block type (00 or 01 and type of padding) + unenc = unenc[1:] + if not '\x00' in unenc: + return False + pos = unenc.index('\x00') + unenc = unenc[pos+1:] + + found = None + for k in _hashFuncParams.keys(): + if self.sigAlg.startswith(k): + found = k + break + if not found: + return False + hlen, hfunc, digestInfo = _hashFuncParams[k] + + if len(unenc) != (hlen+len(digestInfo)): + return False + + if not unenc.startswith(digestInfo): + return False + + h = unenc[-hlen:] + myh = hfunc(self.tbsCertificate) + + return h == myh + + def chain(self, certlist): + """ + Construct the chain of certificates leading from 'self' to the + self signed root using the certificates in 'certlist'. If the + list does not provide all the required certs to go to the root + the function returns a incomplete chain starting with the + certificate. This fact can be tested by tchecking if the last + certificate of the returned chain is self signed (if c is the + result, c[-1].isSelfSigned()) + """ + d = {} + for c in certlist: + # XXX we should check if we have duplicate + d[c.subject] = c + res = [self] + cur = self + while not cur.isSelfSigned(): + if cur.issuer in d: + possible_issuer = d[cur.issuer] + if cur.isIssuerCert(possible_issuer): + res.append(possible_issuer) + cur = possible_issuer + else: + break + return res + + def remainingDays(self, now=None): + """ + Based on the value of notBefore field, returns the number of + days the certificate will still be valid. The date used for the + comparison is the current and local date, as returned by + time.localtime(), except if 'now' argument is provided another + one. 'now' argument can be given as either a time tuple or a string + representing the date. Accepted format for the string version + are: + + - '%b %d %H:%M:%S %Y %Z' e.g. 'Jan 30 07:38:59 2008 GMT' + - '%m/%d/%y' e.g. '01/30/08' (less precise) + + If the certificate is no more valid at the date considered, then, + a negative value is returned representing the number of days + since it has expired. + + The number of days is returned as a float to deal with the unlikely + case of certificates that are still just valid. + """ + if now is None: + now = time.localtime() + elif type(now) is str: + try: + if '/' in now: + now = time.strptime(now, '%m/%d/%y') + else: + now = time.strptime(now, '%b %d %H:%M:%S %Y %Z') + except: + warning("Bad time string provided '%s'. Using current time" % now) + now = time.localtime() + + now = time.mktime(now) + nft = time.mktime(self.notAfter) + diff = (nft - now)/(24.*3600) + return diff + + + # return SHA-1 hash of cert embedded public key + # !! At the moment, the trailing 0 is in the hashed string if any + def keyHash(self): + m = self.modulus_hexdump + res = [] + i = 0 + l = len(m) + while i<l: # get a string version of modulus + res.append(struct.pack("B", int(m[i:i+2], 16))) + i += 2 + return sha.new("".join(res)).digest() + + def output(self, fmt="DER"): + if fmt == "DER": + return self.dercert + elif fmt == "PEM": + return self.pemcert + elif fmt == "TXT": + return self.textcert + + def export(self, filename, fmt="DER"): + """ + Export certificate in 'fmt' format (PEM, DER or TXT) to file 'filename' + """ + f = open(filename, "wb") + f.write(self.output(fmt)) + f.close() + + def isSelfSigned(self): + """ + Return True if the certificate is self signed: + - issuer and subject are the same + - the signature of the certificate is valid. + """ + if self.issuer == self.subject: + return self.isIssuerCert(self) + return False + + # Print main informations stored in certificate + def show(self): + print("Serial: %s" % self.serial) + print("Issuer: " + self.issuer) + print("Subject: " + self.subject) + print("Validity: %s to %s" % (self.notBefore_str_simple, + self.notAfter_str_simple)) + + def __repr__(self): + return "[X.509 Cert. Subject:%s, Issuer:%s]" % (self.subject, self.issuer) + + def __str__(self): + return self.dercert + + def verifychain(self, anchors, untrusted=None): + """ + Perform verification of certificate chains for that certificate. The + behavior of verifychain method is mapped (and also based) on openssl + verify userland tool (man 1 verify). + A list of anchors is required. untrusted parameter can be provided + a list of untrusted certificates that can be used to reconstruct the + chain. + + If you have a lot of certificates to verify against the same + list of anchor, consider constructing this list as a cafile + and use .verifychain_from_cafile() instead. + """ + cafile = create_temporary_ca_file(anchors) + if not cafile: + return False + untrusted_file = None + if untrusted: + untrusted_file = create_temporary_ca_file(untrusted) # hack + if not untrusted_file: + os.unlink(cafile) + return False + res = self.verifychain_from_cafile(cafile, + untrusted_file=untrusted_file) + os.unlink(cafile) + if untrusted_file: + os.unlink(untrusted_file) + return res + + def verifychain_from_cafile(self, cafile, untrusted_file=None): + """ + Does the same job as .verifychain() but using the list of anchors + from the cafile. This is useful (because more efficient) if + you have a lot of certificates to verify do it that way: it + avoids the creation of a cafile from anchors at each call. + + As for .verifychain(), a list of untrusted certificates can be + passed (as a file, this time) + """ + cmd = ["openssl", "verify", "-CAfile", cafile] + if untrusted_file: + cmd += ["-untrusted", untrusted_file] + try: + pemcert = self.output(fmt="PEM") + cmdres = self._apply_ossl_cmd(cmd, pemcert) + except: + return False + return cmdres.endswith("\nOK\n") or cmdres.endswith(": OK\n") + + def verifychain_from_capath(self, capath, untrusted_file=None): + """ + Does the same job as .verifychain_from_cafile() but using the list + of anchors in capath directory. The directory should contain + certificates files in PEM format with associated links as + created using c_rehash utility (man c_rehash). + + As for .verifychain_from_cafile(), a list of untrusted certificates + can be passed as a file (concatenation of the certificates in + PEM format) + """ + cmd = ["openssl", "verify", "-CApath", capath] + if untrusted_file: + cmd += ["-untrusted", untrusted_file] + try: + pemcert = self.output(fmt="PEM") + cmdres = self._apply_ossl_cmd(cmd, pemcert) + except: + return False + return cmdres.endswith("\nOK\n") or cmdres.endswith(": OK\n") + + def is_revoked(self, crl_list): + """ + Given a list of trusted CRL (their signature has already been + verified with trusted anchors), this function returns True if + the certificate is marked as revoked by one of those CRL. + + Note that if the Certificate was on hold in a previous CRL and + is now valid again in a new CRL and bot are in the list, it + will be considered revoked: this is because _all_ CRLs are + checked (not only the freshest) and revocation status is not + handled. + + Also note that the check on the issuer is performed on the + Authority Key Identifier if available in _both_ the CRL and the + Cert. Otherwise, the issuers are simply compared. + """ + for c in crl_list: + if (self.authorityKeyID is not None and + c.authorityKeyID is not None and + self.authorityKeyID == c.authorityKeyID): + return self.serial in map(lambda x: x[0], c.revoked_cert_serials) + elif (self.issuer == c.issuer): + return self.serial in map(lambda x: x[0], c.revoked_cert_serials) + return False + +def print_chain(l): + llen = len(l) - 1 + if llen < 0: + return "" + c = l[llen] + llen -= 1 + s = "_ " + if not c.isSelfSigned(): + s = "_ ... [Missing Root]\n" + else: + s += "%s [Self Signed]\n" % c.subject + i = 1 + while (llen != -1): + c = l[llen] + s += "%s\_ %s" % (" "*i, c.subject) + if llen != 0: + s += "\n" + i += 2 + llen -= 1 + print(s) + +# import popen2 +# a=popen3("openssl crl -text -inform DER -noout ", capturestderr=True) +# a.tochild.write(open("samples/klasa1.crl").read()) +# a.tochild.close() +# a.poll() + +class CRL(OSSLHelper): + # Below are the fields we recognize in the -text output of openssl + # and from which we extract information. We expect them in that + # order. Number of spaces does matter. + possible_fields = [ " Version", + " Signature Algorithm:", + " Issuer:", + " Last Update:", + " Next Update:", + " CRL extensions:", + " X509v3 Issuer Alternative Name:", + " X509v3 Authority Key Identifier:", + " keyid:", + " DirName:", + " serial:", + " X509v3 CRL Number:", + "Revoked Certificates:", + "No Revoked Certificates.", + " Signature Algorithm:" ] + possible_fields_count = len(possible_fields) + + def __init__(self, crlpath): + error_msg = "Unable to import CRL." + + fields_dict = {} + for k in self.possible_fields: + fields_dict[k] = None + + self.crlpath = None + rawcrl = None + + if (not '\x00' in crlpath) and os.path.isfile(crlpath): + self.crlpath = crlpath + cert_size = os.path.getsize(crlpath) + if cert_size > MAX_CRL_SIZE: + raise Exception(error_msg) + try: + f = open(crlpath) + rawcrl = f.read() + f.close() + except: + raise Exception(error_msg) + else: + rawcrl = crlpath + + if rawcrl is None: + raise Exception(error_msg) + + self.rawcrl = rawcrl + + # Let's try to get file format : PEM or DER. + fmtstr = 'openssl crl -text -inform %s -noout' + convertstr = 'openssl crl -inform %s -outform %s' + crl_header = "-----BEGIN X509 CRL-----" + crl_footer = "-----END X509 CRL-----" + l = rawcrl.split(crl_header, 1) + if len(l) == 2: # looks like PEM + tmp = l[1] + l = tmp.split(crl_footer, 1) + if len(l) == 2: + tmp = l[0] + rawcrl = "%s%s%s\n" % (crl_header, tmp, crl_footer) + else: + raise Exception(error_msg) + r,w,e = popen3((fmtstr % "PEM").split(" ")) + w.write(rawcrl) + w.close() + textcrl = r.read() + r.close() + res = e.read() + e.close() + if res == '': + self.format = "PEM" + self.pemcrl = rawcrl + self.textcrl = textcrl + cmd = (convertstr % ("PEM", "DER")).split(" ") + self.dercrl = self._apply_ossl_cmd(cmd, rawcrl) + else: + raise Exception(error_msg) + else: # not PEM, try DER + r,w,e = popen3((fmtstr % "DER").split(' ')) + w.write(rawcrl) + w.close() + textcrl = r.read() + r.close() + res = e.read() + if res == '': + self.format = "DER" + self.dercrl = rawcrl + self.textcrl = textcrl + cmd = (convertstr % ("DER", "PEM")).split(" ") + self.pemcrl = self._apply_ossl_cmd(cmd, rawcrl) + cmd = (convertstr % ("DER", "DER")).split(" ") + self.dercrl = self._apply_ossl_cmd(cmd, rawcrl) + else: + raise Exception(error_msg) + + self.osslcmdbase = ['openssl', 'crl', '-inform', self.format] + + r,w,e = popen3(('openssl asn1parse -inform DER').split(" ")) + w.write(self.dercrl) + w.close() + self.asn1parsecrl = r.read() + r.close() + res = e.read() + e.close() + if res != '': + raise Exception(error_msg) + + # Grab _raw_ X509v3 Authority Key Identifier, if any. + tmp = self.asn1parsecrl.split(":X509v3 Authority Key Identifier", 1) + self.authorityKeyID = None + if len(tmp) == 2: + tmp = tmp[1] + tmp = tmp.split("[HEX DUMP]:", 1)[1] + self.authorityKeyID=tmp.split('\n',1)[0] + + # Parse the -text output of openssl to make things available + tmp = self.textcrl.split('\n', 1)[1] + l = tmp.split('\n', 1) + if len(l) != 2: + raise Exception(error_msg) + cur, tmp = l + i = 0 + k = self.possible_fields[i] # Version + cur = cur[len(k):] + '\n' + while k: + l = tmp.split('\n', 1) + if len(l) != 2: # Over + fields_dict[k] = cur + break + l, tmp = l + + newkey = 0 + # skip fields we have already seen, this is the purpose of 'i' + for j in range(i, self.possible_fields_count): + f = self.possible_fields[j] + if l.startswith(f): + fields_dict[k] = cur + cur = l[len(f):] + '\n' + k = f + newkey = 1 + i = j+1 + break + if newkey == 1: + continue + cur += l + '\n' + + # version + v = fields_dict[" Version"] + self.version = None + if v: + self.version = int(v[1:2]) + if self.version is None: + raise Exception(error_msg) + + # signature algorithm + v = fields_dict[" Signature Algorithm:"] + self.sigAlg = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.sigAlg = v + if self.sigAlg is None: + raise Exception(error_msg) + + # issuer + v = fields_dict[" Issuer:"] + self.issuer = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.issuer = v + if self.issuer is None: + raise Exception(error_msg) + + # last update + v = fields_dict[" Last Update:"] + self.lastUpdate_str = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.lastUpdate_str = v + if self.lastUpdate_str is None: + raise Exception(error_msg) + self.lastUpdate = time.strptime(self.lastUpdate_str, + "%b %d %H:%M:%S %Y %Z") + self.lastUpdate_str_simple = time.strftime("%x", self.lastUpdate) + + # next update + v = fields_dict[" Next Update:"] + self.nextUpdate_str = None + if v: + v = v.split('\n',1)[0] + v = v.strip() + self.nextUpdate_str = v + if self.nextUpdate_str is None: + raise Exception(error_msg) + self.nextUpdate = time.strptime(self.nextUpdate_str, + "%b %d %H:%M:%S %Y %Z") + self.nextUpdate_str_simple = time.strftime("%x", self.nextUpdate) + + # XXX Do something for Issuer Alternative Name + + # Authority Key Identifier: keyid, dirname and serial + self.authorityKeyID_keyid = None + self.authorityKeyID_dirname = None + self.authorityKeyID_serial = None + if self.authorityKeyID: # (hex version already done using asn1parse) + v = fields_dict[" keyid:"] + if v: + v = v.split('\n',1)[0] + v = v.strip().replace(':', '') + self.authorityKeyID_keyid = v + v = fields_dict[" DirName:"] + if v: + v = v.split('\n',1)[0] + self.authorityKeyID_dirname = v + v = fields_dict[" serial:"] + if v: + v = v.split('\n',1)[0] + v = v.strip().replace(':', '') + self.authorityKeyID_serial = v + + # number + v = fields_dict[" X509v3 CRL Number:"] + self.number = None + if v: + v = v.split('\n',2)[1] + v = v.strip() + self.number = int(v) + + # Get the list of serial numbers of revoked certificates + self.revoked_cert_serials = [] + v = fields_dict["Revoked Certificates:"] + t = fields_dict["No Revoked Certificates."] + if (t is None and v is not None): + v = v.split("Serial Number: ")[1:] + for r in v: + s,d = r.split('\n', 1) + s = s.split('\n', 1)[0] + d = d.split("Revocation Date:", 1)[1] + d = time.strptime(d.strip(), "%b %d %H:%M:%S %Y %Z") + self.revoked_cert_serials.append((s,d)) + + # signature field + v = fields_dict[" Signature Algorithm:" ] + self.sig = None + if v: + v = v.split('\n',1)[1] + v = v.replace(' ', '').replace('\n', '') + self.sig = "".join(map(lambda x: chr(int(x, 16)), v.split(':'))) + self.sigLen = len(self.sig) + if self.sig is None: + raise Exception(error_msg) + + def __str__(self): + return self.dercrl + + # Print main informations stored in CRL + def show(self): + print("Version: %d" % self.version) + print("sigAlg: " + self.sigAlg) + print("Issuer: " + self.issuer) + print("lastUpdate: %s" % self.lastUpdate_str_simple) + print("nextUpdate: %s" % self.nextUpdate_str_simple) + + def verify(self, anchors): + """ + Return True if the CRL is signed by one of the provided + anchors. False on error (invalid signature, missing anchorand, ...) + """ + cafile = create_temporary_ca_file(anchors) + if cafile is None: + return False + try: + cmd = self.osslcmdbase + ["-noout", "-CAfile", cafile] + cmdres = self._apply_ossl_cmd(cmd, self.rawcrl) + except: + os.unlink(cafile) + return False + os.unlink(cafile) + return "verify OK" in cmdres + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/dadict.py b/scripts/external_libs/scapy-python3-0.18/scapy/dadict.py new file mode 100644 index 00000000..0fdcc135 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/dadict.py @@ -0,0 +1,91 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Direct Access dictionary. +""" + +from .error import Scapy_Exception + +############################### +## Direct Access dictionnary ## +############################### + +def fixname(x): + if x and x[0] in "0123456789": + x = "n_"+x + return x.translate("________________________________________________0123456789_______ABCDEFGHIJKLMNOPQRSTUVWXYZ______abcdefghijklmnopqrstuvwxyz_____________________________________________________________________________________________________________________________________") + + +class DADict_Exception(Scapy_Exception): + pass + +class DADict: + def __init__(self, _name="DADict", **kargs): + self._name=_name + self.__dict__.update(kargs) + def fixname(self,val): + return fixname(val) + def __contains__(self, val): + return val in self.__dict__ + def __getitem__(self, attr): + return getattr(self, attr) + def __setitem__(self, attr, val): + return setattr(self, self.fixname(attr), val) + def __iter__(self): + #return iter(map(lambda (x,y):y,filter(lambda (x,y):x and x[0]!="_", self.__dict__.items()))) + #return iter(map(lambda a:a[1],filter(lambda a:a[0] and a[0][0]!="_", self.__dict__.items()))) + return iter([a[1] for a in self.__dict__.items() if a[0] and a[0][0]!=" "]) + def _show(self): + for k in self.__dict__.keys(): + if k and k[0] != "_": + print("%10s = %r" % (k,getattr(self,k))) + def __repr__(self): + #return "<%s/ %s>" % (self._name," ".join(filter(lambda x:x and x[0]!="_",self.__dict__.keys()))) + return "<%s/ %s>" % (self._name," ".join([ x for x in self.__dict__.keys() if x and x[0]!="_"])) + + def _branch(self, br, uniq=0): + if uniq and br._name in self: + raise DADict_Exception("DADict: [%s] already branched in [%s]" % (br._name, self._name)) + self[br._name] = br + + def _my_find(self, *args, **kargs): + if args and self._name not in args: + return False + for k in kargs: + if k not in self or self[k] != kargs[k]: + return False + return True + + def _find(self, *args, **kargs): + return self._recurs_find((), *args, **kargs) + def _recurs_find(self, path, *args, **kargs): + if self in path: + return None + if self._my_find(*args, **kargs): + return self + for o in self: + if isinstance(o, DADict): + p = o._recurs_find(path+(self,), *args, **kargs) + if p is not None: + return p + return None + def _find_all(self, *args, **kargs): + return self._recurs_find_all((), *args, **kargs) + def _recurs_find_all(self, path, *args, **kargs): + r = [] + if self in path: + return r + if self._my_find(*args, **kargs): + r.append(self) + for o in self: + if isinstance(o, DADict): + p = o._recurs_find_all(path+(self,), *args, **kargs) + r += p + return r + def keys(self): + #return filter(lambda x:x and x[0]!="_", self.__dict__.keys()) + return [ x for x in self.__dict__.keys() if x and x[0]!="_" ] + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/data.py b/scripts/external_libs/scapy-python3-0.18/scapy/data.py new file mode 100644 index 00000000..fc92ebe2 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/data.py @@ -0,0 +1,215 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Global variables and functions for handling external data sets. +""" + +import os,sys,re +from .dadict import DADict +from .error import log_loading + +############ +## Consts ## +############ + +ETHER_ANY = b"\x00"*6 +ETHER_BROADCAST = b"\xff"*6 + +ETH_P_ALL = 3 +ETH_P_IP = 0x800 +ETH_P_ARP = 0x806 +ETH_P_IPV6 = 0x86dd + +# From net/if_arp.h +ARPHDR_ETHER = 1 +ARPHDR_METRICOM = 23 +ARPHDR_PPP = 512 +ARPHDR_LOOPBACK = 772 +ARPHDR_TUN = 65534 + + +# From net/ipv6.h on Linux (+ Additions) +IPV6_ADDR_UNICAST = 0x01 +IPV6_ADDR_MULTICAST = 0x02 +IPV6_ADDR_CAST_MASK = 0x0F +IPV6_ADDR_LOOPBACK = 0x10 +IPV6_ADDR_GLOBAL = 0x00 +IPV6_ADDR_LINKLOCAL = 0x20 +IPV6_ADDR_SITELOCAL = 0x40 # deprecated since Sept. 2004 by RFC 3879 +IPV6_ADDR_SCOPE_MASK = 0xF0 +#IPV6_ADDR_COMPATv4 = 0x80 # deprecated; i.e. ::/96 +#IPV6_ADDR_MAPPED = 0x1000 # i.e.; ::ffff:0.0.0.0/96 +IPV6_ADDR_6TO4 = 0x0100 # Added to have more specific info (should be 0x0101 ?) +IPV6_ADDR_UNSPECIFIED = 0x10000 + + + + +MTU = 0x7fff # a.k.a give me all you have + +WINDOWS=sys.platform.startswith("win") + + +# file parsing to get some values : + +def load_protocols(filename): + spaces = re.compile("[ \t]+|\n") + dct = DADict(_name=filename) + try: + for l in open(filename): + try: + shrp = l.find("#") + if shrp >= 0: + l = l[:shrp] + l = l.strip() + if not l: + continue + lt = tuple(re.split(spaces, l)) + if len(lt) < 2 or not lt[0]: + continue + dct[lt[0]] = int(lt[1]) + except Exception as e: + log_loading.info("Couldn't parse file [%s]: line [%r] (%s)" % (filename,l,e)) + except IOError: + log_loading.info("Can't open %s file" % filename) + return dct + +def load_ethertypes(filename): + spaces = re.compile("[ \t]+|\n") + dct = DADict(_name=filename) + try: + f=open(filename) + for l in f: + try: + shrp = l.find("#") + if shrp >= 0: + l = l[:shrp] + l = l.strip() + if not l: + continue + lt = tuple(re.split(spaces, l)) + if len(lt) < 2 or not lt[0]: + continue + dct[lt[0]] = int(lt[1], 16) + except Exception as e: + log_loading.info("Couldn't parse file [%s]: line [%r] (%s)" % (filename,l,e)) + f.close() + except IOError as msg: + pass + return dct + +def load_services(filename): + spaces = re.compile("[ \t]+|\n") + tdct=DADict(_name="%s-tcp"%filename) + udct=DADict(_name="%s-udp"%filename) + try: + f=open(filename) + for l in f: + try: + shrp = l.find("#") + if shrp >= 0: + l = l[:shrp] + l = l.strip() + if not l: + continue + lt = tuple(re.split(spaces, l)) + if len(lt) < 2 or not lt[0]: + continue + if lt[1].endswith("/tcp"): + tdct[lt[0]] = int(lt[1].split('/')[0]) + elif lt[1].endswith("/udp"): + udct[lt[0]] = int(lt[1].split('/')[0]) + except Exception as e: + log_loading.warning("Couldn't file [%s]: line [%r] (%s)" % (filename,l,e)) + f.close() + except IOError: + log_loading.info("Can't open /etc/services file") + return tdct,udct + + +class ManufDA(DADict): + def fixname(self, val): + return val + def _get_manuf_couple(self, mac): + oui = ":".join(mac.split(":")[:3]).upper() + return self.__dict__.get(oui,(mac,mac)) + def _get_manuf(self, mac): + return self._get_manuf_couple(mac)[1] + def _get_short_manuf(self, mac): + return self._get_manuf_couple(mac)[0] + def _resolve_MAC(self, mac): + oui = ":".join(mac.split(":")[:3]).upper() + if oui in self: + return ":".join([self[oui][0]]+ mac.split(":")[3:]) + return mac + + + + +def load_manuf(filename): + try: + manufdb=ManufDA(_name=filename) + for l in open(filename, "r", encoding = 'utf-8'): + try: + l = l.strip() + if not l or l.startswith("#"): + continue + oui,shrt=l.split()[:2] + i = l.find("#") + if i < 0: + lng=shrt + else: + lng = l[i+2:] + manufdb[oui] = shrt,lng + except Exception as e: + log_loading.warning("Couldn't parse one line from [%s] [%r] (%s)" % (filename, l, e)) + except IOError: + #log_loading.warning("Couldn't open [%s] file" % filename) + pass + return manufdb + + + +if WINDOWS: + ETHER_TYPES=load_ethertypes("ethertypes") + IP_PROTOS=load_protocols(os.environ["SystemRoot"]+"\system32\drivers\etc\protocol") + TCP_SERVICES,UDP_SERVICES=load_services(os.environ["SystemRoot"] + "\system32\drivers\etc\services") + MANUFDB = load_manuf(os.environ["ProgramFiles"] + "\\wireshark\\manuf") +else: + IP_PROTOS=load_protocols("/etc/protocols") + ETHER_TYPES=load_ethertypes("/etc/ethertypes") + TCP_SERVICES,UDP_SERVICES=load_services("/etc/services") + MANUFDB = load_manuf("/usr/share/wireshark/manuf") + + + +##################### +## knowledge bases ## +##################### + +class KnowledgeBase: + def __init__(self, filename): + self.filename = filename + self.base = None + + def lazy_init(self): + self.base = "" + + def reload(self, filename = None): + if filename is not None: + self.filename = filename + oldbase = self.base + self.base = None + self.lazy_init() + if self.base is None: + self.base = oldbase + + def get_base(self): + if self.base is None: + self.lazy_init() + return self.base + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/error.py b/scripts/external_libs/scapy-python3-0.18/scapy/error.py new file mode 100644 index 00000000..1753d523 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/error.py @@ -0,0 +1,60 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Logging subsystem and basic exception class. +""" + +############################# +##### Logging subsystem ##### +############################# + +class Scapy_Exception(Exception): + pass + +import logging,traceback,time + +class ScapyFreqFilter(logging.Filter): + def __init__(self): + logging.Filter.__init__(self) + self.warning_table = {} + def filter(self, record): + from .config import conf + wt = conf.warning_threshold + if wt > 0: + stk = traceback.extract_stack() + caller=None + for f,l,n,c in stk: + if n == 'warning': + break + caller = l + tm,nb = self.warning_table.get(caller, (0,0)) + ltm = time.time() + if ltm-tm > wt: + tm = ltm + nb = 0 + else: + if nb < 2: + nb += 1 + if nb == 2: + record.msg = "more "+record.msg + else: + return 0 + self.warning_table[caller] = (tm,nb) + return 1 + +log_scapy = logging.getLogger("scapy") +console_handler = logging.StreamHandler() +console_handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s")) +log_scapy.addHandler(console_handler) +log_runtime = logging.getLogger("scapy.runtime") # logs at runtime +log_runtime.addFilter(ScapyFreqFilter()) +log_interactive = logging.getLogger("scapy.interactive") # logs in interactive functions +log_loading = logging.getLogger("scapy.loading") # logs when loading scapy + + +def warning(x): + log_runtime.warning(x) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/fields.py b/scripts/external_libs/scapy-python3-0.18/scapy/fields.py new file mode 100644 index 00000000..5482ce87 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/fields.py @@ -0,0 +1,935 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Fields: basic data structures that make up parts of packets. +""" + +import struct,copy,socket +from .config import conf +from .volatile import * +from .data import * +from .utils import * +from .base_classes import BasePacket,Gen,Net + + +############ +## Fields ## +############ + +class Field: + """For more informations on how this work, please refer to + http://www.secdev.org/projects/scapy/files/scapydoc.pdf + chapter ``Adding a New Field''""" + islist=0 + holds_packets=0 + def __init__(self, name, default, fmt="H"): + self.name = name + if fmt[0] in "@=<>!": + self.fmt = fmt + else: + self.fmt = "!"+fmt + self.default = self.any2i(None,default) + self.sz = struct.calcsize(self.fmt) + self.owners = [] + self.offset =0; + + + def get_size_bytes (self): + if hasattr(self, 'size'): + return 0; # bitfield + else: + return self.sz + + def register_owner(self, cls): + self.owners.append(cls) + + def i2len(self, pkt, x): + """Convert internal value to a length usable by a FieldLenField""" + return self.sz + def i2count(self, pkt, x): + """Convert internal value to a number of elements usable by a FieldLenField. + Always 1 except for list fields""" + return 1 + def i2b(self, pkt, x): + """Convert internal value to internal value""" + if type(x) is str: + x = bytes([ ord(i) for i in x ]) + return x + def h2i(self, pkt, x): + """Convert human value to internal value""" + if type(x) is str: + x = bytes([ ord(i) for i in x ]) + return x + def i2h(self, pkt, x): + """Convert internal value to human value""" + return x + def m2i(self, pkt, x): + """Convert machine value to internal value""" + return x + def i2m(self, pkt, x): + """Convert internal value to machine value""" + if x is None: + x = 0 + return x + def any2i(self, pkt, x): + """Try to understand the most input values possible and make an internal value from them""" + return self.h2i(pkt, x) + def i2repr(self, pkt, x): + """Convert internal value to a nice representation""" + return repr(self.i2h(pkt,x)) + def addfield(self, pkt, s, val): + """Add an internal value to a string""" + return s+struct.pack(self.fmt, self.i2m(pkt,val)) + def getfield(self, pkt, s): + """Extract an internal value from a string""" + return s[self.sz:], self.m2i(pkt, struct.unpack(self.fmt, s[:self.sz])[0]) + def do_copy(self, x): + if hasattr(x, "copy"): + return x.copy() + if type(x) is list: + x = x[:] + for i in range(len(x)): + if isinstance(x[i], BasePacket): + x[i] = x[i].copy() + return x + def __repr__(self): + return "<Field (%s).%s>" % (",".join(x.__name__ for x in self.owners),self.name) + def copy(self): + return copy.deepcopy(self) + def randval(self): + """Return a volatile object whose value is both random and suitable for this field""" + fmtt = self.fmt[-1] + if fmtt in "BHIQ": + return {"B":RandByte,"H":RandShort,"I":RandInt, "Q":RandLong}[fmtt]() + elif fmtt == "s": + if self.fmt[0] in "0123456789": + l = int(self.fmt[:-1]) + else: + l = int(self.fmt[1:-1]) + return RandBin(l) + else: + warning("no random class for [%s] (fmt=%s)." % (self.name, self.fmt)) + + + + +class Emph: + fld = b"" + def __init__(self, fld): + self.fld = fld + def __getattr__(self, attr): + return getattr(self.fld,attr) + def __hash__(self): + return hash(self.fld) + def __eq__(self, other): + return self.fld == other + + +class ActionField: + _fld = None + def __init__(self, fld, action_method, **kargs): + self._fld = fld + self._action_method = action_method + self._privdata = kargs + def any2i(self, pkt, val): + getattr(pkt, self._action_method)(val, self._fld, **self._privdata) + return getattr(self._fld, "any2i")(pkt, val) + def __getattr__(self, attr): + return getattr(self._fld,attr) + + +class ConditionalField: + fld = None + def __init__(self, fld, cond): + self.fld = fld + self.cond = cond + def _evalcond(self,pkt): + return self.cond(pkt) + + def getfield(self, pkt, s): + if self._evalcond(pkt): + return self.fld.getfield(pkt,s) + else: + return s,None + + def addfield(self, pkt, s, val): + if self._evalcond(pkt): + return self.fld.addfield(pkt,s,val) + else: + return s + def __getattr__(self, attr): + return getattr(self.fld,attr) + + +class PadField: + """Add bytes after the proxified field so that it ends at the specified + alignment from its begining""" + _fld = None + def __init__(self, fld, align, padwith=None): + self._fld = fld + self._align = align + self._padwith = padwith or b"" + + def padlen(self, flen): + return -flen%self._align + + def getfield(self, pkt, s): + remain,val = self._fld.getfield(pkt,s) + padlen = self.padlen(len(s)-len(remain)) + return remain[padlen:], val + + def addfield(self, pkt, s, val): + sval = self._fld.addfield(pkt, b"", val) + return s+sval+struct.pack("%is" % (self.padlen(len(sval))), self._padwith) + + def __getattr__(self, attr): + return getattr(self._fld,attr) + + +class MACField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "6s") + def i2m(self, pkt, x): + if x is None: + return b"\0\0\0\0\0\0" + return mac2str(x) + def m2i(self, pkt, x): + return str2mac(x) + def any2i(self, pkt, x): + if type(x) is bytes and len(x) is 6: + x = self.m2i(pkt, x) + return x + def i2repr(self, pkt, x): + x = self.i2h(pkt, x) + if self in conf.resolve: + x = conf.manufdb._resolve_MAC(x) + return x + def randval(self): + return RandMAC() + + +class IPField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "4s") + def h2i(self, pkt, x): + if type(x) is str: + try: + inet_aton(x) + except socket.error: + x = Net(x) + elif type(x) is list: + x = [self.h2i(pkt, n) for n in x] + return x + def resolve(self, x): + if self in conf.resolve: + try: + ret = socket.gethostbyaddr(x)[0] + except: + pass + else: + if ret: + return ret + return x + def i2m(self, pkt, x): + return inet_aton(x) + def m2i(self, pkt, x): + return inet_ntoa(x) + def any2i(self, pkt, x): + return self.h2i(pkt,x) + def i2repr(self, pkt, x): + return self.resolve(self.i2h(pkt, x)) + def randval(self): + return RandIP() + +class SourceIPField(IPField): + def __init__(self, name, dstname): + IPField.__init__(self, name, None) + self.dstname = dstname + def i2m(self, pkt, x): + if x is None: + iff,x,gw = pkt.route() + if x is None: + x = "0.0.0.0" + return IPField.i2m(self, pkt, x) + def i2h(self, pkt, x): + if x is None: + dst=getattr(pkt,self.dstname) + if isinstance(dst,Gen): + #r = map(conf.route.route, dst) + r = [ conf.route.route(i) for i in dst ] + r.sort() + if r[0] != r[-1]: + warning("More than one possible route for %s"%repr(dst)) + iff,x,gw = r[0] + else: + iff,x,gw = conf.route.route(dst) + return IPField.i2h(self, pkt, x) + + + + +class ByteField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "B") + +class XByteField(ByteField): + def i2repr(self, pkt, x): + return lhex(self.i2h(pkt, x)) + +class OByteField(ByteField): + def i2repr(self, pkt, x): + return "%03o"%self.i2h(pkt, x) + +class X3BytesField(XByteField): + def __init__(self, name, default): + Field.__init__(self, name, default, "!I") + def addfield(self, pkt, s, val): + return s+struct.pack(self.fmt, self.i2m(pkt,val))[1:4] + def getfield(self, pkt, s): + return s[3:], self.m2i(pkt, struct.unpack(self.fmt, b"\x00"+s[:3])[0]) + + +class ThreeBytesField(X3BytesField, ByteField): + def i2repr(self, pkt, x): + return ByteField.i2repr(self, pkt, x) + + +class ShortField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "H") + +class LEShortField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "<H") + +class XShortField(ShortField): + def i2repr(self, pkt, x): + return lhex(self.i2h(pkt, x)) + + +class IntField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "I") + +class SignedIntField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "i") + def randval(self): + return RandSInt() + +class LEIntField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "<I") + +class LESignedIntField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "<i") + def randval(self): + return RandSInt() + +class XIntField(IntField): + def i2repr(self, pkt, x): + return lhex(self.i2h(pkt, x)) + + +class LongField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "Q") + +class XLongField(LongField): + def i2repr(self, pkt, x): + return lhex(self.i2h(pkt, x)) + +class IEEEFloatField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "f") + +class IEEEDoubleField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "d") + + +class StrField(Field): + def __init__(self, name, default, fmt="H", remain=0): + Field.__init__(self,name,default,fmt) + self.remain = remain + #def i2h(self, pkt, x): + def i2repr(self, pkt, x): + try: + if type(x) is bytes: + x = x.decode('ascii') + except UnicodeDecodeError: + pass + return repr(x) + #def i2repr(self, pkt, x): + # return repr(self.i2h(pkt,x)) + def i2len(self, pkt, i): + return len(i) + def i2m(self, pkt, x): + if x is None: + x = b"" + elif type(x) is not bytes: + x=str(x).encode('ascii') + return x + def addfield(self, pkt, s, val): + return s+self.i2m(pkt, val) + def getfield(self, pkt, s): + if self.remain == 0: + return b"",self.m2i(pkt, s) + else: + return s[-self.remain:],self.m2i(pkt, s[:-self.remain]) + def randval(self): + return RandBin(RandNum(0,1200)) + +class PacketField(StrField): + holds_packets=1 + def __init__(self, name, default, cls, remain=0): #is remain used somewhere? + StrField.__init__(self, name, default, remain=remain) + self.cls = cls + def i2m(self, pkt, i): + return bytes(i) + def m2i(self, pkt, m): + return self.cls(m) + def getfield(self, pkt, s): + i = self.m2i(pkt, s) + remain = b"" + if conf.padding_layer in i: + r = i[conf.padding_layer] + del(r.underlayer.payload) + remain = r.load + return remain,i + +class PacketLenField(PacketField): + holds_packets=1 + def __init__(self, name, default, cls, length_from=None): + PacketField.__init__(self, name, default, cls) + self.length_from = length_from + def getfield(self, pkt, s): + l = self.length_from(pkt) + try: + i = self.m2i(pkt, s[:l]) + except Exception: + if conf.debug_dissector: + raise + i = conf.raw_layer(load=s[:l]) + return s[l:],i + + +class PacketListField(PacketField): + islist = 1 + holds_packets=1 + def __init__(self, name, default, cls, count_from=None, length_from=None): + if default is None: + default = [] # Create a new list for each instance + PacketField.__init__(self, name, default, cls) + self.count_from = count_from + self.length_from = length_from + + + def any2i(self, pkt, x): + if type(x) is not list: + return [x] + else: + return x + def i2count(self, pkt, val): + if type(val) is list: + return len(val) + return 1 + def i2len(self, pkt, val): + return sum( len(p) for p in val ) + def do_copy(self, x): + #return map(lambda p:p.copy(), x) + return [ i.copy() for i in x ] + def getfield(self, pkt, s): + c = l = None + if self.length_from is not None: + l = self.length_from(pkt) + elif self.count_from is not None: + c = self.count_from(pkt) + + lst = [] + ret = b"" + remain = s + if l is not None: + remain,ret = s[:l],s[l:] + while remain: + if c is not None: + if c <= 0: + break + c -= 1 + try: + p = self.m2i(pkt,remain) + except Exception: + if conf.debug_dissector: + raise + p = conf.raw_layer(load=remain) + remain = b"" + else: + if conf.padding_layer in p: + pad = p[conf.padding_layer] + remain = pad.load + del(pad.underlayer.payload) + else: + remain = b"" + lst.append(p) + return remain+ret,lst + def addfield(self, pkt, s, val): + return s+b"".join([ bytes(i) for i in val ]) + + +class StrFixedLenField(StrField): + def __init__(self, name, default, length=None, length_from=None): + StrField.__init__(self, name, default) + self.length_from = length_from + if length is not None: + self.length_from = lambda pkt,length=length: length + def i2repr(self, pkt, v): + if type(v) is bytes: + v = v.rstrip(b"\0") + return repr(v) + def getfield(self, pkt, s): + l = self.length_from(pkt) + return s[l:], self.m2i(pkt,s[:l]) + def addfield(self, pkt, s, val): + l = self.length_from(pkt) + return s+struct.pack("%is"%l,self.i2m(pkt, val)) + def randval(self): + try: + l = self.length_from(None) + except: + l = RandNum(0,200) + return RandBin(l) + +class StrFixedLenEnumField(StrFixedLenField): + def __init__(self, name, default, length=None, enum=None, length_from=None): + StrFixedLenField.__init__(self, name, default, length=length, length_from=length_from) + self.enum = enum + def i2repr(self, pkt, v): + r = v.rstrip("\0") + rr = repr(r) + if v in self.enum: + rr = "%s (%s)" % (rr, self.enum[v]) + elif r in self.enum: + rr = "%s (%s)" % (rr, self.enum[r]) + return rr + +class NetBIOSNameField(StrFixedLenField): + def __init__(self, name, default, length=31): + StrFixedLenField.__init__(self, name, default, length) + def i2m(self, pkt, x): + l = self.length_from(pkt)//2 + if x is None: + x = b"" + x += b" "*(l) + x = x[:l] + #x = b"".join(map(lambda x: chr(0x41+(ord(x)>>4))+chr(0x41+(ord(x)&0xf)), x)) + x = b"".join([ bytes([0x41+(i>>4),0x41+(i&0xf)]) for i in x ]) + x = b" "+x + return x + def m2i(self, pkt, x): + x = x.strip(b"\x00").strip(b" ") + #return b"".join(map(lambda x,y: chr((((ord(x)-1)&0xf)<<4)+((ord(y)-1)&0xf)), x[::2],x[1::2])) + return b"".join(map(lambda x,y: bytes([(((x-1)&0xf)<<4)+((y-1)&0xf)]), x[::2],x[1::2])) + +class StrLenField(StrField): + def __init__(self, name, default, fld=None, length_from=None): + StrField.__init__(self, name, default) + self.length_from = length_from + def getfield(self, pkt, s): + l = self.length_from(pkt) + return s[l:], self.m2i(pkt,s[:l]) + +class FieldListField(Field): + islist=1 + def __init__(self, name, default, field, length_from=None, count_from=None): + if default is None: + default = [] # Create a new list for each instance + Field.__init__(self, name, default) + self.count_from = count_from + self.length_from = length_from + self.field = field + + def i2count(self, pkt, val): + if type(val) is list: + return len(val) + return 1 + def i2len(self, pkt, val): + return sum( self.field.i2len(pkt,v) for v in val ) + + def i2m(self, pkt, val): + if val is None: + val = [] + return val + def any2i(self, pkt, x): + if type(x) is not list: + return [x] + else: + return x + def addfield(self, pkt, s, val): + val = self.i2m(pkt, val) + for v in val: + s = self.field.addfield(pkt, s, v) + return s + def getfield(self, pkt, s): + c = l = None + if self.length_from is not None: + l = self.length_from(pkt) + elif self.count_from is not None: + c = self.count_from(pkt) + + val = [] + ret=b"" + if l is not None: + s,ret = s[:l],s[l:] + + while s: + if c is not None: + if c <= 0: + break + c -= 1 + s,v = self.field.getfield(pkt, s) + val.append(v) + return s+ret, val + +class FieldLenField(Field): + def __init__(self, name, default, length_of=None, fmt = "H", count_of=None, adjust=lambda pkt,x:x, fld=None): + Field.__init__(self, name, default, fmt) + self.length_of=length_of + self.count_of=count_of + self.adjust=adjust + if fld is not None: + FIELD_LENGTH_MANAGEMENT_DEPRECATION(self.__class__.__name__) + self.length_of = fld + def i2m(self, pkt, x): + if x is None: + if self.length_of is not None: + fld,fval = pkt.getfield_and_val(self.length_of) + f = fld.i2len(pkt, fval) + else: + fld,fval = pkt.getfield_and_val(self.count_of) + f = fld.i2count(pkt, fval) + x = self.adjust(pkt,f) + return x + +class StrNullField(StrField): + def addfield(self, pkt, s, val): + return s+self.i2m(pkt, val)+b"\x00" + def getfield(self, pkt, s): + l = s.find(b"\x00") + if l < 0: + #XXX \x00 not found + return "",s + return s[l+1:],self.m2i(pkt, s[:l]) + def randval(self): + return RandTermString(RandNum(0,1200),b"\x00") + +class StrStopField(StrField): + def __init__(self, name, default, stop, additionnal=0): + Field.__init__(self, name, default) + self.stop=stop + self.additionnal=additionnal + def getfield(self, pkt, s): + l = s.find(self.stop) + if l < 0: + return b"",s +# raise Scapy_Exception,"StrStopField: stop value [%s] not found" %stop + l += len(self.stop)+self.additionnal + return s[l:],s[:l] + def randval(self): + return RandTermString(RandNum(0,1200),self.stop) + +class LenField(Field): + def i2m(self, pkt, x): + if x is None: + x = len(pkt.payload) + return x + +class BCDFloatField(Field): + def i2m(self, pkt, x): + return int(256*x) + def m2i(self, pkt, x): + return x/256.0 + +class BitField(Field): + def __init__(self, name, default, size): + Field.__init__(self, name, default) + self.rev = size < 0 + self.size = abs(size) + def reverse(self, val): + if self.size == 16: + val = socket.ntohs(val) + elif self.size == 32: + val = socket.ntohl(val) + return val + + def addfield(self, pkt, s, val): + val = self.i2m(pkt, val) + if type(s) is tuple: + s,bitsdone,v = s + else: + bitsdone = 0 + v = 0 + if self.rev: + val = self.reverse(val) + v <<= self.size + v |= val & ((1<<self.size) - 1) + bitsdone += self.size + while bitsdone >= 8: + bitsdone -= 8 + s = s+struct.pack("!B", v >> bitsdone) + v &= (1<<bitsdone)-1 + if bitsdone: + return s,bitsdone,v + else: + return s + def getfield(self, pkt, s): + if type(s) is tuple: + s,bn = s + else: + bn = 0 + # we don't want to process all the string + nb_bytes = (self.size+bn-1)//8 + 1 + w = s[:nb_bytes] + + # split the substring byte by byte + bs = struct.unpack('!%dB' % nb_bytes , w) + + b = 0 + for c in range(nb_bytes): + b |= int(bs[c]) << (nb_bytes-c-1)*8 + + # get rid of high order bits + b &= (1 << (nb_bytes*8-bn)) - 1 + + # remove low order bits + b = b >> (nb_bytes*8 - self.size - bn) + + if self.rev: + b = self.reverse(b) + + bn += self.size + s = s[bn//8:] + bn = bn%8 + b = self.m2i(pkt, b) + if bn: + return (s,bn),b + else: + return s,b + def randval(self): + return RandNum(0,2**self.size-1) + + +class BitFieldLenField(BitField): + def __init__(self, name, default, size, length_of=None, count_of=None, adjust=lambda pkt,x:x): + BitField.__init__(self, name, default, size) + self.length_of=length_of + self.count_of=count_of + self.adjust=adjust + def i2m(self, pkt, x): + #return FieldLenField.i2m.im_func(self, pkt, x) + return FieldLenField.i2m(self, pkt, x) + + +class XBitField(BitField): + def i2repr(self, pkt, x): + return lhex(self.i2h(pkt,x)) + + +class EnumField(Field): + def __init__(self, name, default, enum, fmt = "H"): + i2s = self.i2s = {} + s2i = self.s2i = {} + if type(enum) is list: + keys = range(len(enum)) + else: + keys = enum.keys() + if list(filter(lambda x: type(x) is str, keys)): + i2s,s2i = s2i,i2s + for k in keys: + i2s[k] = enum[k] + s2i[enum[k]] = k + Field.__init__(self, name, default, fmt) + def any2i_one(self, pkt, x): + if type(x) is str: + x = self.s2i[x] + return x + def i2repr_one(self, pkt, x): + if self not in conf.noenum and not isinstance(x,VolatileValue) and x in self.i2s: + return self.i2s[x] + return repr(x) + + def any2i(self, pkt, x): + if type(x) is list: + return list(map(lambda z,pkt=pkt:self.any2i_one(pkt,z), x)) + else: + return self.any2i_one(pkt,x) + def i2repr(self, pkt, x): + if type(x) is list: + return list(map(lambda z,pkt=pkt:self.i2repr_one(pkt,z), x)) + else: + return self.i2repr_one(pkt,x) + +class CharEnumField(EnumField): + def __init__(self, name, default, enum, fmt = "1s"): + EnumField.__init__(self, name, default, enum, fmt) + k = self.i2s.keys() + if k and len(k[0]) != 1: + self.i2s,self.s2i = self.s2i,self.i2s + def any2i_one(self, pkt, x): + if len(x) != 1: + x = self.s2i[x] + return x + +class BitEnumField(BitField,EnumField): + def __init__(self, name, default, size, enum): + EnumField.__init__(self, name, default, enum) + self.rev = size < 0 + self.size = abs(size) + def any2i(self, pkt, x): + return EnumField.any2i(self, pkt, x) + def i2repr(self, pkt, x): + return EnumField.i2repr(self, pkt, x) + +class ShortEnumField(EnumField): + def __init__(self, name, default, enum): + EnumField.__init__(self, name, default, enum, "H") + +class LEShortEnumField(EnumField): + def __init__(self, name, default, enum): + EnumField.__init__(self, name, default, enum, "<H") + +class ByteEnumField(EnumField): + def __init__(self, name, default, enum): + EnumField.__init__(self, name, default, enum, "B") + +class IntEnumField(EnumField): + def __init__(self, name, default, enum): + EnumField.__init__(self, name, default, enum, "I") + +class SignedIntEnumField(EnumField): + def __init__(self, name, default, enum): + EnumField.__init__(self, name, default, enum, "i") + def randval(self): + return RandSInt() + +class LEIntEnumField(EnumField): + def __init__(self, name, default, enum): + EnumField.__init__(self, name, default, enum, "<I") + +class XShortEnumField(ShortEnumField): + def i2repr_one(self, pkt, x): + if self not in conf.noenum and not isinstance(x,VolatileValue) and x in self.i2s: + return self.i2s[x] + return lhex(x) + +class MultiEnumField(EnumField): + def __init__(self, name, default, enum, depends_on, fmt = "H"): + + self.depends_on = depends_on + self.i2s_multi = enum + self.s2i_multi = {} + self.s2i_all = {} + for m in enum: + self.s2i_multi[m] = s2i = {} + for k,v in enum[m].items(): + s2i[v] = k + self.s2i_all[v] = k + Field.__init__(self, name, default, fmt) + def any2i_one(self, pkt, x): + if type (x) is str: + v = self.depends_on(pkt) + if v in self.s2i_multi: + s2i = self.s2i_multi[v] + if x in s2i: + return s2i[x] + return self.s2i_all[x] + return x + def i2repr_one(self, pkt, x): + v = self.depends_on(pkt) + if v in self.i2s_multi: + return self.i2s_multi[v].get(x,x) + return x + +class BitMultiEnumField(BitField,MultiEnumField): + def __init__(self, name, default, size, enum, depends_on): + MultiEnumField.__init__(self, name, default, enum) + self.rev = size < 0 + self.size = abs(size) + def any2i(self, pkt, x): + return MultiEnumField.any2i(self, pkt, x) + def i2repr(self, pkt, x): + return MultiEnumField.i2repr(self, pkt, x) + + +# Little endian long field +class LELongField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "<Q") + +# Little endian fixed length field +class LEFieldLenField(FieldLenField): + def __init__(self, name, default, length_of=None, fmt = "<H", count_of=None, adjust=lambda pkt,x:x, fld=None): + FieldLenField.__init__(self, name, default, length_of=length_of, fmt=fmt, fld=fld, adjust=adjust) + + +class FlagsField(BitField): + def __init__(self, name, default, size, names): + self.multi = type(names) is list + if self.multi: + #self.names = map(lambda x:[x], names) + self.names = [ [x] for x in names ] + else: + self.names = names + BitField.__init__(self, name, default, size) + def any2i(self, pkt, x): + if type(x) is str: + if self.multi: + #x = map(lambda y:[y], x.split("+")) + x = [ [y] for y in x.split("+") ] + y = 0 + for i in x: + y |= 1 << self.names.index(i) + x = y + return x + def i2repr(self, pkt, x): + if type(x) is list or type(x) is tuple: + return repr(x) + if self.multi: + r = [] + else: + r = "" + i=0 + while x: + if x & 1: + r += self.names[i] + i += 1 + x >>= 1 + if self.multi: + r = "+".join(r) + return r + + + + +class FixedPointField(BitField): + def __init__(self, name, default, size, frac_bits=16): + self.frac_bits = frac_bits + BitField.__init__(self, name, default, size) + + def any2i(self, pkt, val): + if val is None: + return val + ival = int(val) + fract = int( (val-ival) * 2**self.frac_bits ) + return (ival << self.frac_bits) | fract + + def i2h(self, pkt, val): + int_part = val >> self.frac_bits + frac_part = val & (1 << self.frac_bits) - 1 + frac_part /= 2.0**self.frac_bits + return int_part+frac_part + def i2repr(self, pkt, val): + return self.i2h(pkt, val) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/__init__.py new file mode 100644 index 00000000..a3f2afb9 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/__init__.py @@ -0,0 +1,8 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Layer package. +""" diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/all.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/all.py new file mode 100644 index 00000000..8104b6a2 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/all.py @@ -0,0 +1,45 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +All layers. Configurable with conf.load_layers. +""" + +import importlib +from scapy.config import conf +from scapy.error import log_loading +import logging +log = logging.getLogger("scapy.loading") + +#log_loading.info("Please, report issues to https://github.com/phaethon/scapy") + +def _import_star(m): + #mod = __import__("." + m, globals(), locals()) + mod = importlib.import_module("scapy.layers." + m) + for k,v in mod.__dict__.items(): + globals()[k] = v + + +for _l in ['l2','inet','inet6']: + log_loading.debug("Loading layer %s" % _l) + #print "load ",_l + _import_star(_l) + +#def _import_star(m): + #mod = __import__("." + m, globals(), locals()) +# mod = importlib.import_module("scapy.layers." + m) +# for k,v in mod.__dict__.items(): +# globals()[k] = v + +#for _l in conf.load_layers: +# log_loading.debug("Loading layer %s" % _l) +# try: +# _import_star(_l) +# except Exception as e: +# log.warning("can't import layer %s: %s" % (_l,e)) + + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/bluetooth.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/bluetooth.py new file mode 100644 index 00000000..5dd365a4 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/bluetooth.py @@ -0,0 +1,213 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Bluetooth layers, sockets and send/receive functions. +""" + +import socket,struct + +from scapy.config import conf +from scapy.packet import * +from scapy.fields import * +from scapy.supersocket import SuperSocket +from scapy.data import MTU + + +class HCI_Hdr(Packet): + name = "HCI header" + fields_desc = [ ByteEnumField("type",2,{1:"command",2:"ACLdata",3:"SCOdata",4:"event",5:"vendor"}),] + + def mysummary(self): + return self.sprintf("HCI %type%") + +class HCI_ACL_Hdr(Packet): + name = "HCI ACL header" + fields_desc = [ ByteField("handle",0), # Actually, handle is 12 bits and flags is 4. + ByteField("flags",0), # I wait to write a LEBitField + LEShortField("len",None), ] + def post_build(self, p, pay): + p += pay + if self.len is None: + l = len(p)-4 + #p = p[:2]+chr(l&0xff)+chr((l>>8)&0xff)+p[4:] + p = p[:2]+bytes([(l&0xff),((l>>8)&0xff)])+p[4:] + return p + + +class L2CAP_Hdr(Packet): + name = "L2CAP header" + fields_desc = [ LEShortField("len",None), + LEShortEnumField("cid",0,{1:"control"}),] + + def post_build(self, p, pay): + p += pay + if self.len is None: + l = len(p)-4 + #p = p[:2]+chr(l&0xff)+chr((l>>8)&0xff)+p[4:] + p = p[:2]+bytes([(l&0xff),((l>>8)&0xff)])+p[4:] + return p + + + +class L2CAP_CmdHdr(Packet): + name = "L2CAP command header" + fields_desc = [ + ByteEnumField("code",8,{1:"rej",2:"conn_req",3:"conn_resp", + 4:"conf_req",5:"conf_resp",6:"disconn_req", + 7:"disconn_resp",8:"echo_req",9:"echo_resp", + 10:"info_req",11:"info_resp"}), + ByteField("id",0), + LEShortField("len",None) ] + def post_build(self, p, pay): + p += pay + if self.len is None: + l = len(p)-4 + #p = p[:2]+chr(l&0xff)+chr((l>>8)&0xff)+p[4:] + p = p[:2]+bytes([(l&0xff),((l>>8)&0xff)])+p[4:] + return p + def answers(self, other): + if other.id == self.id: + if self.code == 1: + return 1 + if other.code in [2,4,6,8,10] and self.code == other.code+1: + if other.code == 8: + return 1 + return self.payload.answers(other.payload) + return 0 + +class L2CAP_ConnReq(Packet): + name = "L2CAP Conn Req" + fields_desc = [ LEShortEnumField("psm",0,{1:"SDP",3:"RFCOMM",5:"telephony control"}), + LEShortField("scid",0), + ] + +class L2CAP_ConnResp(Packet): + name = "L2CAP Conn Resp" + fields_desc = [ LEShortField("dcid",0), + LEShortField("scid",0), + LEShortEnumField("result",0,["no_info","authen_pend","author_pend"]), + LEShortEnumField("status",0,["success","pend","bad_psm", + "cr_sec_block","cr_no_mem"]), + ] + def answers(self, other): + return self.scid == other.scid + +class L2CAP_CmdRej(Packet): + name = "L2CAP Command Rej" + fields_desc = [ LEShortField("reason",0), + ] + + +class L2CAP_ConfReq(Packet): + name = "L2CAP Conf Req" + fields_desc = [ LEShortField("dcid",0), + LEShortField("flags",0), + ] + +class L2CAP_ConfResp(Packet): + name = "L2CAP Conf Resp" + fields_desc = [ LEShortField("scid",0), + LEShortField("flags",0), + LEShortEnumField("result",0,["success","unaccept","reject","unknown"]), + ] + def answers(self, other): + return self.scid == other.scid + + +class L2CAP_DisconnReq(Packet): + name = "L2CAP Disconn Req" + fields_desc = [ LEShortField("dcid",0), + LEShortField("scid",0), ] + +class L2CAP_DisconnResp(Packet): + name = "L2CAP Disconn Resp" + fields_desc = [ LEShortField("dcid",0), + LEShortField("scid",0), ] + def answers(self, other): + return self.scid == other.scid + + + +class L2CAP_InfoReq(Packet): + name = "L2CAP Info Req" + fields_desc = [ LEShortEnumField("type",0,{1:"CL_MTU",2:"FEAT_MASK"}), + StrField("data","") + ] + + +class L2CAP_InfoResp(Packet): + name = "L2CAP Info Resp" + fields_desc = [ LEShortField("type",0), + LEShortEnumField("result",0,["success","not_supp"]), + StrField("data",""), ] + def answers(self, other): + return self.type == other.type + + + +bind_layers( HCI_Hdr, HCI_ACL_Hdr, type=2) +bind_layers( HCI_Hdr, conf.raw_layer, ) +bind_layers( HCI_ACL_Hdr, L2CAP_Hdr, ) +bind_layers( L2CAP_Hdr, L2CAP_CmdHdr, cid=1) +bind_layers( L2CAP_CmdHdr, L2CAP_CmdRej, code=1) +bind_layers( L2CAP_CmdHdr, L2CAP_ConnReq, code=2) +bind_layers( L2CAP_CmdHdr, L2CAP_ConnResp, code=3) +bind_layers( L2CAP_CmdHdr, L2CAP_ConfReq, code=4) +bind_layers( L2CAP_CmdHdr, L2CAP_ConfResp, code=5) +bind_layers( L2CAP_CmdHdr, L2CAP_DisconnReq, code=6) +bind_layers( L2CAP_CmdHdr, L2CAP_DisconnResp, code=7) +bind_layers( L2CAP_CmdHdr, L2CAP_InfoReq, code=10) +bind_layers( L2CAP_CmdHdr, L2CAP_InfoResp, code=11) + +class BluetoothL2CAPSocket(SuperSocket): + desc = "read/write packets on a connected L2CAP socket" + def __init__(self, peer): + s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, + socket.BTPROTO_L2CAP) + s.connect((peer,0)) + + self.ins = self.outs = s + + def recv(self, x=MTU): + return L2CAP_CmdHdr(self.ins.recv(x)) + + +class BluetoothHCISocket(SuperSocket): + desc = "read/write on a BlueTooth HCI socket" + def __init__(self, iface=0x10000, type=None): + s = socket.socket(socket.AF_BLUETOOTH, socket.SOCK_RAW, socket.BTPROTO_HCI) + s.setsockopt(socket.SOL_HCI, socket.HCI_DATA_DIR,1) + s.setsockopt(socket.SOL_HCI, socket.HCI_TIME_STAMP,1) + s.setsockopt(socket.SOL_HCI, socket.HCI_FILTER, struct.pack("IIIh2x", 0xffffffff,0xffffffff,0xffffffff,0)) #type mask, event mask, event mask, opcode + s.bind((iface,)) + self.ins = self.outs = s +# s.connect((peer,0)) + + + def recv(self, x): + return HCI_Hdr(self.ins.recv(x)) + +## Bluetooth + + +@conf.commands.register +def srbt(peer, pkts, inter=0.1, *args, **kargs): + """send and receive using a bluetooth socket""" + s = conf.BTsocket(peer=peer) + a,b = sndrcv(s,pkts,inter=inter,*args,**kargs) + s.close() + return a,b + +@conf.commands.register +def srbt1(peer, pkts, *args, **kargs): + """send and receive 1 packet using a bluetooth socket""" + a,b = srbt(peer, pkts, *args, **kargs) + if len(a) > 0: + return a[0][1] + + + +conf.BTsocket = BluetoothL2CAPSocket diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/dhcp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dhcp.py new file mode 100644 index 00000000..e2b7c1f1 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dhcp.py @@ -0,0 +1,381 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +DHCP (Dynamic Host Configuration Protocol) d BOOTP +""" + +import struct + +from scapy.packet import * +from scapy.fields import * +from scapy.ansmachine import * +from scapy.layers.inet import UDP,IP +from scapy.layers.l2 import Ether +from scapy.base_classes import Net +from scapy.volatile import RandField + +from scapy.arch import get_if_raw_hwaddr +from scapy.sendrecv import srp1 +from scapy.utils import str2bytes + +dhcpmagic=b"c\x82Sc" + + +class BOOTP(Packet): + name = "BOOTP" + fields_desc = [ ByteEnumField("op",1, {1:"BOOTREQUEST", 2:"BOOTREPLY"}), + ByteField("htype",1), + ByteField("hlen",6), + ByteField("hops",0), + IntField("xid",0), + ShortField("secs",0), + FlagsField("flags", 0, 16, "???????????????B"), + IPField("ciaddr","0.0.0.0"), + IPField("yiaddr","0.0.0.0"), + IPField("siaddr","0.0.0.0"), + IPField("giaddr","0.0.0.0"), + Field("chaddr",b"", "16s"), + Field("sname",b"","64s"), + Field("file",b"","128s"), + StrField("options",b"") ] + def guess_payload_class(self, payload): + if self.options[:len(dhcpmagic)] == dhcpmagic: + return DHCP + else: + return Packet.guess_payload_class(self, payload) + def extract_padding(self,s): + if self.options[:len(dhcpmagic)] == dhcpmagic: + # set BOOTP options to DHCP magic cookie and make rest a payload of DHCP options + payload = self.options[len(dhcpmagic):] + self.options = self.options[:len(dhcpmagic)] + return payload, None + else: + return b"", None + def hashret(self): + return struct.pack("L", self.xid) + def answers(self, other): + if not isinstance(other, BOOTP): + return 0 + return self.xid == other.xid + + + +#DHCP_UNKNOWN, DHCP_IP, DHCP_IPLIST, DHCP_TYPE \ +#= range(4) +# + +DHCPTypes = { + 1: "discover", + 2: "offer", + 3: "request", + 4: "decline", + 5: "ack", + 6: "nak", + 7: "release", + 8: "inform", + 9: "force_renew", + 10:"lease_query", + 11:"lease_unassigned", + 12:"lease_unknown", + 13:"lease_active", + } + +DHCPOptions = { + 0: "pad", + 1: IPField("subnet_mask", "0.0.0.0"), + 2: "time_zone", + 3: IPField("router","0.0.0.0"), + 4: IPField("time_server","0.0.0.0"), + 5: IPField("IEN_name_server","0.0.0.0"), + 6: IPField("name_server","0.0.0.0"), + 7: IPField("log_server","0.0.0.0"), + 8: IPField("cookie_server","0.0.0.0"), + 9: IPField("lpr_server","0.0.0.0"), + 12: "hostname", + 14: "dump_path", + 15: "domain", + 17: "root_disk_path", + 22: "max_dgram_reass_size", + 23: "default_ttl", + 24: "pmtu_timeout", + 28: IPField("broadcast_address","0.0.0.0"), + 35: "arp_cache_timeout", + 36: "ether_or_dot3", + 37: "tcp_ttl", + 38: "tcp_keepalive_interval", + 39: "tcp_keepalive_garbage", + 40: "NIS_domain", + 41: IPField("NIS_server","0.0.0.0"), + 42: IPField("NTP_server","0.0.0.0"), + 43: "vendor_specific", + 44: IPField("NetBIOS_server","0.0.0.0"), + 45: IPField("NetBIOS_dist_server","0.0.0.0"), + 50: IPField("requested_addr","0.0.0.0"), + 51: IntField("lease_time", 43200), + 54: IPField("server_id","0.0.0.0"), + 55: "param_req_list", + 57: ShortField("max_dhcp_size", 1500), + 58: IntField("renewal_time", 21600), + 59: IntField("rebinding_time", 37800), + 60: "vendor_class_id", + 61: "client_id", + + 64: "NISplus_domain", + 65: IPField("NISplus_server","0.0.0.0"), + 69: IPField("SMTP_server","0.0.0.0"), + 70: IPField("POP3_server","0.0.0.0"), + 71: IPField("NNTP_server","0.0.0.0"), + 72: IPField("WWW_server","0.0.0.0"), + 73: IPField("Finger_server","0.0.0.0"), + 74: IPField("IRC_server","0.0.0.0"), + 75: IPField("StreetTalk_server","0.0.0.0"), + 76: "StreetTalk_Dir_Assistance", + 82: "relay_agent_Information", + 53: ByteEnumField("message-type", 1, DHCPTypes), + # 55: DHCPRequestListField("request-list"), + 255: "end" + } + +DHCPRevOptions = {} + +for k,v in DHCPOptions.items(): + if type(v) is str: + n = v + v = None + else: + n = v.name + DHCPRevOptions[n] = (k,v) +del(n) +del(v) +del(k) + + + + +class RandDHCPOptions(RandField): + def __init__(self, size=None, rndstr=None): + if size is None: + size = RandNumExpo(0.05) + self.size = size + if rndstr is None: + rndstr = RandBin(RandNum(0,255)) + self.rndstr=rndstr + self._opts = list(DHCPOptions.values()) + self._opts.remove("pad") + self._opts.remove("end") + def _fix(self): + op = [] + for k in range(self.size): + o = random.choice(self._opts) + if type(o) is str: + op.append((o,self.rndstr*1)) + else: + op.append((o.name, o.randval()._fix())) + return op + + +class DHCPOptionsField(StrField): + islist=1 + def i2repr(self,pkt,x): + s = [] + for v in x: + if type(v) is tuple and len(v) >= 2: + if v[0] in DHCPRevOptions and isinstance(DHCPRevOptions[v[0]][1],Field): + f = DHCPRevOptions[v[0]][1] + vv = ",".join(f.i2repr(pkt,val) for val in v[1:]) + else: + vv = ",".join(repr(val) for val in v[1:]) + r = "%s=%s" % (v[0],vv) + s.append(r) + else: + s.append(sane(v)) + return "[%s]" % (" ".join(s)) + + def getfield(self, pkt, s): + return b"", self.m2i(pkt, s) + + def m2i(self, pkt, x): + opt = [] + while x: + #o = ord(x[0]) + o = x[0] + if o == 255: + opt.append("end") + x = x[1:] + continue + if o == 0: + opt.append("pad") + x = x[1:] + continue + #if len(x) < 2 or len(x) < ord(x[1])+2: + if len(x) < 2 or len(x) < x[1]+2: + opt.append(x) + break + elif o in DHCPOptions: + f = DHCPOptions[o] + + if isinstance(f, str): + #olen = ord(x[1]) + olen = x[1] + opt.append( (f,x[2:olen+2]) ) + x = x[olen+2:] + else: + olen = x[1] + lval = [f.name] + try: + left = x[2:olen+2] + while left: + left, val = f.getfield(pkt,left) + lval.append(val) + except: + opt.append(x) + break + else: + otuple = tuple(lval) + opt.append(otuple) + x = x[olen+2:] + else: + #olen = ord(x[1]) + olen = x[1] + opt.append((o, x[2:olen+2])) + x = x[olen+2:] + return opt + def i2m(self, pkt, x): + if type(x) is str: + return x + s = b"" + for o in x: + if type(o) is tuple and len(o) >= 2: + name = o[0] + lval = o[1:] + + if isinstance(name, int): + onum, oval = name, b"".join(lval) + elif name in DHCPRevOptions: + onum, f = DHCPRevOptions[name] + if f is not None: + lval = [f.addfield(pkt,b"",f.any2i(pkt,val)) for val in lval] + oval = b"".join(lval) + else: + warning("Unknown field option %s" % name) + continue + + s += bytes([onum]) + s += bytes([len(oval)]) + s += oval + + elif (type(o) is str and o in DHCPRevOptions and + DHCPRevOptions[o][1] == None): + s += bytes([DHCPRevOptions[o][0]]) + elif type(o) is int: + s += chr(o)+b"\0" + elif type(o) is str: + s += str2bytes(o) + elif type(o) is bytes: + s += o + else: + warning("Malformed option %s" % o) + return s + + +class DHCP(Packet): + name = "DHCP options" + fields_desc = [ DHCPOptionsField("options",b"") ] + + +bind_layers( UDP, BOOTP, dport=67, sport=68) +bind_layers( UDP, BOOTP, dport=68, sport=67) +bind_bottom_up( UDP, BOOTP, dport=67, sport=67) +bind_layers( BOOTP, DHCP, options=b'c\x82Sc') + +def dhcp_request(iface=None,**kargs): + if conf.checkIPaddr != 0: + warning("conf.checkIPaddr is not 0, I may not be able to match the answer") + if iface is None: + iface = conf.iface + hw = get_if_raw_hwaddr(iface) + return srp1(Ether(dst="ff:ff:ff:ff:ff:ff")/IP(src="0.0.0.0",dst="255.255.255.255")/UDP(sport=68,dport=67) + /BOOTP(chaddr=hw)/DHCP(options=[("message-type","discover"),"end"]),iface=iface,**kargs) + + +class BOOTP_am(AnsweringMachine): + function_name = "bootpd" + filter = "udp and port 68 and port 67" + send_function = staticmethod(sendp) + def parse_options(self, pool=Net("192.168.1.128/25"), network="192.168.1.0/24",gw="192.168.1.1", + domain="localnet", renewal_time=60, lease_time=1800): + if type(pool) is str: + poom = Net(pool) + self.domain = domain + netw,msk = (network.split("/")+["32"])[:2] + msk = itom(int(msk)) + self.netmask = ltoa(msk) + self.network = ltoa(atol(netw)&msk) + self.broadcast = ltoa( atol(self.network) | (0xffffffff&~msk) ) + self.gw = gw + if isinstance(pool,Gen): + pool = [k for k in pool if k not in [gw, self.network, self.broadcast]] + pool.reverse() + if len(pool) == 1: + pool, = pool + self.pool = pool + self.lease_time = lease_time + self.renewal_time = renewal_time + self.leases = {} + + def is_request(self, req): + if not req.haslayer(BOOTP): + return 0 + reqb = req.getlayer(BOOTP) + if reqb.op != 1: + return 0 + return 1 + + def print_reply(self, req, reply): + print("Reply %s to %s" % (reply.getlayer(IP).dst,reply.dst)) + + def make_reply(self, req): + mac = req.src + if type(self.pool) is list: + if not mac in self.leases: + self.leases[mac] = self.pool.pop() + ip = self.leases[mac] + else: + ip = self.pool + + repb = req.getlayer(BOOTP).copy() + repb.op="BOOTREPLY" + repb.yiaddr = ip + repb.siaddr = self.gw + repb.ciaddr = self.gw + repb.giaddr = self.gw + del(repb.payload) + rep=Ether(dst=mac)/IP(dst=ip)/UDP(sport=req.dport,dport=req.sport)/repb + return rep + + +class DHCP_am(BOOTP_am): + function_name="dhcpd" + def make_reply(self, req): + resp = BOOTP_am.make_reply(self, req) + if DHCP in req: + dhcp_options = [(op[0],{1:2,3:5}.get(op[1],op[1])) + for op in req[DHCP].options + if type(op) is tuple and op[0] == "message-type"] + dhcp_options += [("server_id",self.gw), + ("domain", self.domain), + ("router", self.gw), + ("name_server", self.gw), + ("broadcast_address", self.broadcast), + ("subnet_mask", self.netmask), + ("renewal_time", self.renewal_time), + ("lease_time", self.lease_time), + "end" + ] + resp /= DHCP(options=dhcp_options) + return resp + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/dhcp6.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dhcp6.py new file mode 100644 index 00000000..a11a4149 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dhcp6.py @@ -0,0 +1,1718 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +## Copyright (C) 2005 Guillaume Valadon <guedou@hongo.wide.ad.jp> +## Arnaud Ebalard <arnaud.ebalard@eads.net> + +""" +DHCPv6: Dynamic Host Configuration Protocol for IPv6. [RFC 3315] +""" + +import socket +from scapy.packet import * +from scapy.fields import * +from scapy.utils6 import * +from scapy.layers.inet6 import * +from scapy.ansmachine import AnsweringMachine + +############################################################################# +# Helpers ## +############################################################################# + +def get_cls(name, fallback_cls): + return globals().get(name, fallback_cls) + + +############################################################################# +############################################################################# +### DHCPv6 ### +############################################################################# +############################################################################# + +All_DHCP_Relay_Agents_and_Servers = "ff02::1:2" +All_DHCP_Servers = "ff05::1:3" # Site-Local scope : deprecated by 3879 + +dhcp6opts = { 1: "CLIENTID", + 2: "SERVERID", + 3: "IA_NA", + 4: "IA_TA", + 5: "IAADDR", + 6: "ORO", + 7: "PREFERENCE", + 8: "ELAPSED_TIME", + 9: "RELAY_MSG", + 11: "AUTH", + 12: "UNICAST", + 13: "STATUS_CODE", + 14: "RAPID_COMMIT", + 15: "USER_CLASS", + 16: "VENDOR_CLASS", + 17: "VENDOR_OPTS", + 18: "INTERFACE_ID", + 19: "RECONF_MSG", + 20: "RECONF_ACCEPT", + 21: "SIP Servers Domain Name List", #RFC3319 + 22: "SIP Servers IPv6 Address List", #RFC3319 + 23: "DNS Recursive Name Server Option", #RFC3646 + 24: "Domain Search List option", #RFC3646 + 25: "OPTION_IA_PD", #RFC3633 + 26: "OPTION_IAPREFIX", #RFC3633 + 27: "OPTION_NIS_SERVERS", #RFC3898 + 28: "OPTION_NISP_SERVERS", #RFC3898 + 29: "OPTION_NIS_DOMAIN_NAME", #RFC3898 + 30: "OPTION_NISP_DOMAIN_NAME", #RFC3898 + 31: "OPTION_SNTP_SERVERS", #RFC4075 + 32: "OPTION_INFORMATION_REFRESH_TIME", #RFC4242 + 33: "OPTION_BCMCS_SERVER_D", #RFC4280 + 34: "OPTION_BCMCS_SERVER_A", #RFC4280 + 36: "OPTION_GEOCONF_CIVIC", #RFC-ietf-geopriv-dhcp-civil-09.txt + 37: "OPTION_REMOTE_ID", #RFC4649 + 38: "OPTION_SUBSCRIBER_ID", #RFC4580 + 39: "OPTION_CLIENT_FQDN" } #RFC4704 + +dhcp6opts_by_code = { 1: "DHCP6OptClientId", + 2: "DHCP6OptServerId", + 3: "DHCP6OptIA_NA", + 4: "DHCP6OptIA_TA", + 5: "DHCP6OptIAAddress", + 6: "DHCP6OptOptReq", + 7: "DHCP6OptPref", + 8: "DHCP6OptElapsedTime", + 9: "DHCP6OptRelayMsg", + 11: "DHCP6OptAuth", + 12: "DHCP6OptServerUnicast", + 13: "DHCP6OptStatusCode", + 14: "DHCP6OptRapidCommit", + 15: "DHCP6OptUserClass", + 16: "DHCP6OptVendorClass", + 17: "DHCP6OptVendorSpecificInfo", + 18: "DHCP6OptIfaceId", + 19: "DHCP6OptReconfMsg", + 20: "DHCP6OptReconfAccept", + 21: "DHCP6OptSIPDomains", #RFC3319 + 22: "DHCP6OptSIPServers", #RFC3319 + 23: "DHCP6OptDNSServers", #RFC3646 + 24: "DHCP6OptDNSDomains", #RFC3646 + 25: "DHCP6OptIA_PD", #RFC3633 + 26: "DHCP6OptIAPrefix", #RFC3633 + 27: "DHCP6OptNISServers", #RFC3898 + 28: "DHCP6OptNISPServers", #RFC3898 + 29: "DHCP6OptNISDomain", #RFC3898 + 30: "DHCP6OptNISPDomain", #RFC3898 + 31: "DHCP6OptSNTPServers", #RFC4075 + 32: "DHCP6OptInfoRefreshTime", #RFC4242 + 33: "DHCP6OptBCMCSDomains", #RFC4280 + 34: "DHCP6OptBCMCSServers", #RFC4280 + #36: "DHCP6OptGeoConf", #RFC-ietf-geopriv-dhcp-civil-09.txt + 37: "DHCP6OptRemoteID", #RFC4649 + 38: "DHCP6OptSubscriberID", #RFC4580 + 39: "DHCP6OptClientFQDN", #RFC4704 + #40: "DHCP6OptPANAAgent", #RFC-ietf-dhc-paa-option-05.txt + #41: "DHCP6OptNewPOSIXTimeZone, #RFC4833 + #42: "DHCP6OptNewTZDBTimeZone, #RFC4833 + 43: "DHCP6OptRelayAgentERO" #RFC4994 + #44: "DHCP6OptLQQuery", #RFC5007 + #45: "DHCP6OptLQClientData", #RFC5007 + #46: "DHCP6OptLQClientTime", #RFC5007 + #47: "DHCP6OptLQRelayData", #RFC5007 + #48: "DHCP6OptLQClientLink", #RFC5007 +} + + +# sect 5.3 RFC 3315 : DHCP6 Messages types +dhcp6types = { 1:"SOLICIT", + 2:"ADVERTISE", + 3:"REQUEST", + 4:"CONFIRM", + 5:"RENEW", + 6:"REBIND", + 7:"REPLY", + 8:"RELEASE", + 9:"DECLINE", + 10:"RECONFIGURE", + 11:"INFORMATION-REQUEST", + 12:"RELAY-FORW", + 13:"RELAY-REPL" } + + +##################################################################### +### DHCPv6 DUID related stuff ### +##################################################################### + +duidtypes = { 1: "Link-layer address plus time", + 2: "Vendor-assigned unique ID based on Enterprise Number", + 3: "Link-layer Address" } + +# DUID hardware types - RFC 826 - Extracted from +# http://www.iana.org/assignments/arp-parameters on 31/10/06 +# We should add the length of every kind of address. +duidhwtypes = { 0: "NET/ROM pseudo", # Not referenced by IANA + 1: "Ethernet (10Mb)", + 2: "Experimental Ethernet (3Mb)", + 3: "Amateur Radio AX.25", + 4: "Proteon ProNET Token Ring", + 5: "Chaos", + 6: "IEEE 802 Networks", + 7: "ARCNET", + 8: "Hyperchannel", + 9: "Lanstar", + 10: "Autonet Short Address", + 11: "LocalTalk", + 12: "LocalNet (IBM PCNet or SYTEK LocalNET)", + 13: "Ultra link", + 14: "SMDS", + 15: "Frame Relay", + 16: "Asynchronous Transmission Mode (ATM)", + 17: "HDLC", + 18: "Fibre Channel", + 19: "Asynchronous Transmission Mode (ATM)", + 20: "Serial Line", + 21: "Asynchronous Transmission Mode (ATM)", + 22: "MIL-STD-188-220", + 23: "Metricom", + 24: "IEEE 1394.1995", + 25: "MAPOS", + 26: "Twinaxial", + 27: "EUI-64", + 28: "HIPARP", + 29: "IP and ARP over ISO 7816-3", + 30: "ARPSec", + 31: "IPsec tunnel", + 32: "InfiniBand (TM)", + 33: "TIA-102 Project 25 Common Air Interface (CAI)" } + +class UTCTimeField(IntField): + epoch = (2000, 1, 1, 0, 0, 0, 5, 1, 0) # required Epoch + def i2repr(self, pkt, x): + x = self.i2h(pkt, x) + from time import gmtime, strftime, mktime + delta = mktime(self.epoch) - mktime(gmtime(0)) + x = x + delta + t = strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime(x)) + return "%s (%d)" % (t, x) + +class _LLAddrField(MACField): + pass + +# XXX We only support Ethernet addresses at the moment. _LLAddrField +# will be modified when needed. Ask us. --arno +class DUID_LLT(Packet): # sect 9.2 RFC 3315 + name = "DUID - Link-layer address plus time" + fields_desc = [ ShortEnumField("type", 1, duidtypes), + XShortEnumField("hwtype", 1, duidhwtypes), + UTCTimeField("timeval", 0), # i.e. 01 Jan 2000 + _LLAddrField("lladdr", ETHER_ANY) ] + +# In fact, IANA enterprise-numbers file available at +# http//www.iana.org/asignments/enterprise-numbers) +# is simply huge (more than 2Mo and 600Ko in bz2). I'll +# add only most common vendors, and encountered values. +# -- arno +iana_enterprise_num = { 9: "ciscoSystems", + 35: "Nortel Networks", + 43: "3Com", + 311: "Microsoft", + 2636: "Juniper Networks, Inc.", + 4526: "Netgear", + 5771: "Cisco Systems, Inc.", + 5842: "Cisco Systems", + 16885: "Nortel Networks" } + +class DUID_EN(Packet): # sect 9.3 RFC 3315 + name = "DUID - Assigned by Vendor Based on Enterprise Number" + fields_desc = [ ShortEnumField("type", 2, duidtypes), + IntEnumField("enterprisenum", 311, iana_enterprise_num), + StrField("id",b"") ] + +class DUID_LL(Packet): # sect 9.4 RFC 3315 + name = "DUID - Based on Link-layer Address" + fields_desc = [ ShortEnumField("type", 3, duidtypes), + XShortEnumField("hwtype", 1, duidhwtypes), + _LLAddrField("lladdr", ETHER_ANY) ] + +duid_cls = { 1: "DUID_LLT", + 2: "DUID_EN", + 3: "DUID_LL"} + +##################################################################### +### DHCPv6 Options classes ### +##################################################################### + +class _DHCP6OptGuessPayload(Packet): + def guess_payload_class(self, payload): + cls = conf.raw_layer + if len(payload) > 2 : + opt = struct.unpack("!H", payload[:2])[0] + cls = get_cls(dhcp6opts_by_code.get(opt, "DHCP6OptUnknown"), DHCP6OptUnknown) + return cls + +class DHCP6OptUnknown(_DHCP6OptGuessPayload): # A generic DHCPv6 Option + name = "Unknown DHCPv6 OPtion" + fields_desc = [ ShortEnumField("optcode", 0, dhcp6opts), + FieldLenField("optlen", None, length_of="data", fmt="!H"), + StrLenField("data", b"", + length_from = lambda pkt: pkt.optlen)] + +class _DUIDField(PacketField): + holds_packets=1 + def __init__(self, name, default, length_from=None): + StrField.__init__(self, name, default) + self.length_from = length_from + + def i2m(self, pkt, i): + return bytes(i) + + def m2i(self, pkt, x): + cls = conf.raw_layer + if len(x) > 4: + o = struct.unpack("!H", x[:2])[0] + cls = get_cls(duid_cls.get(o, conf.raw_layer), conf.raw_layer) + return cls(x) + + def getfield(self, pkt, s): + l = self.length_from(pkt) + return s[l:], self.m2i(pkt,s[:l]) + + +class DHCP6OptClientId(_DHCP6OptGuessPayload): # RFC sect 22.2 + name = "DHCP6 Client Identifier Option" + fields_desc = [ ShortEnumField("optcode", 1, dhcp6opts), + FieldLenField("optlen", None, length_of="duid", fmt="!H"), + _DUIDField("duid", "", + length_from = lambda pkt: pkt.optlen) ] + + +class DHCP6OptServerId(DHCP6OptClientId): # RFC sect 22.3 + name = "DHCP6 Server Identifier Option" + optcode = 2 + +# Should be encapsulated in the option field of IA_NA or IA_TA options +# Can only appear at that location. +# TODO : last field IAaddr-options is not defined in the reference document +class DHCP6OptIAAddress(_DHCP6OptGuessPayload): # RFC sect 22.6 + name = "DHCP6 IA Address Option (IA_TA or IA_NA suboption)" + fields_desc = [ ShortEnumField("optcode", 5, dhcp6opts), + FieldLenField("optlen", None, length_of="iaaddropts", + fmt="!H", adjust = lambda pkt,x: x+24), + IP6Field("addr", "::"), + IntField("preflft", 0), + IntField("validlft", 0), + XIntField("iaid", None), + StrLenField("iaaddropts", b"", + length_from = lambda pkt: pkt.optlen - 24) ] + def guess_payload_class(self, payload): + return conf.padding_layer + +class _IANAOptField(PacketListField): + def i2len(self, pkt, z): + if z is None or z == []: + return 0 + return sum(map(lambda x: len(bytes(x)) ,z)) + + def getfield(self, pkt, s): + l = self.length_from(pkt) + lst = [] + remain, payl = s[:l], s[l:] + while len(remain)>0: + p = self.m2i(pkt,remain) + if conf.padding_layer in p: + pad = p[conf.padding_layer] + remain = pad.load + del(pad.underlayer.payload) + else: + remain = "" + lst.append(p) + return payl,lst + +class DHCP6OptIA_NA(_DHCP6OptGuessPayload): # RFC sect 22.4 + name = "DHCP6 Identity Association for Non-temporary Addresses Option" + fields_desc = [ ShortEnumField("optcode", 3, dhcp6opts), + FieldLenField("optlen", None, length_of="ianaopts", + fmt="!H", adjust = lambda pkt,x: x+12), + XIntField("iaid", None), + IntField("T1", None), + IntField("T2", None), + _IANAOptField("ianaopts", [], DHCP6OptIAAddress, + length_from = lambda pkt: pkt.optlen-12) ] + +class _IATAOptField(_IANAOptField): + pass + +class DHCP6OptIA_TA(_DHCP6OptGuessPayload): # RFC sect 22.5 + name = "DHCP6 Identity Association for Temporary Addresses Option" + fields_desc = [ ShortEnumField("optcode", 4, dhcp6opts), + FieldLenField("optlen", None, length_of="iataopts", + fmt="!H", adjust = lambda pkt,x: x+4), + XIntField("iaid", None), + _IATAOptField("iataopts", [], DHCP6OptIAAddress, + length_from = lambda pkt: pkt.optlen-4) ] + + +#### DHCPv6 Option Request Option ################################### + +class _OptReqListField(StrLenField): + islist = 1 + def i2h(self, pkt, x): + if x is None: + return [] + return x + + def i2len(self, pkt, x): + return 2*len(x) + + def any2i(self, pkt, x): + return x + + def i2repr(self, pkt, x): + s = [] + for y in self.i2h(pkt, x): + if y in dhcp6opts: + s.append(dhcp6opts[y]) + else: + s.append("%d" % y) + return "[%s]" % ", ".join(s) + + def m2i(self, pkt, x): + r = [] + while len(x) != 0: + if len(x)<2: + warning("Odd length for requested option field. Rejecting last byte") + return r + r.append(struct.unpack("!H", x[:2])[0]) + x = x[2:] + return r + + def i2m(self, pkt, x): + return b"".join(map(lambda y: struct.pack("!H", y), x)) + +# A client may include an ORO in a solicit, Request, Renew, Rebind, +# Confirm or Information-request +class DHCP6OptOptReq(_DHCP6OptGuessPayload): # RFC sect 22.7 + name = "DHCP6 Option Request Option" + fields_desc = [ ShortEnumField("optcode", 6, dhcp6opts), + FieldLenField("optlen", None, length_of="reqopts", fmt="!H"), + _OptReqListField("reqopts", [23, 24], + length_from = lambda pkt: pkt.optlen) ] + + +#### DHCPv6 Preference Option ####################################### + +# emise par un serveur pour affecter le choix fait par le client. Dans +# les messages Advertise, a priori +class DHCP6OptPref(_DHCP6OptGuessPayload): # RFC sect 22.8 + name = "DHCP6 Preference Option" + fields_desc = [ ShortEnumField("optcode", 7, dhcp6opts), + ShortField("optlen", 1 ), + ByteField("prefval",255) ] + + +#### DHCPv6 Elapsed Time Option ##################################### + +class _ElapsedTimeField(ShortField): + def i2repr(self, pkt, x): + if x == 0xffff: + return "infinity (0xffff)" + return "%.2f sec" % (self.i2h(pkt, x)/100.) + +class DHCP6OptElapsedTime(_DHCP6OptGuessPayload):# RFC sect 22.9 + name = "DHCP6 Elapsed Time Option" + fields_desc = [ ShortEnumField("optcode", 8, dhcp6opts), + ShortField("optlen", 2), + _ElapsedTimeField("elapsedtime", 0) ] + + +#### DHCPv6 Relay Message Option #################################### + +# Relayed message is seen as a payload. +class DHCP6OptRelayMsg(_DHCP6OptGuessPayload):# RFC sect 22.10 + name = "DHCP6 Relay Message Option" + fields_desc = [ ShortEnumField("optcode", 9, dhcp6opts), + ShortField("optlen", None ) ] + def post_build(self, p, pay): + if self.optlen is None: + l = len(pay) + p = p[:2]+struct.pack("!H", l) + return p + pay + + +#### DHCPv6 Authentication Option ################################### + +# The following fields are set in an Authentication option for the +# Reconfigure Key Authentication Protocol: +# +# protocol 3 +# +# algorithm 1 +# +# RDM 0 +# +# The format of the Authentication information for the Reconfigure Key +# Authentication Protocol is: +# +# 0 1 2 3 +# 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +# +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +# | Type | Value (128 bits) | +# +-+-+-+-+-+-+-+-+ | +# . . +# . . +# . +-+-+-+-+-+-+-+-+ +# | | +# +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ +# +# Type Type of data in Value field carried in this option: +# +# 1 Reconfigure Key value (used in Reply message). +# +# 2 HMAC-MD5 digest of the message (used in Reconfigure +# message). +# +# Value Data as defined by field. + + +# TODO : Decoding only at the moment +class DHCP6OptAuth(_DHCP6OptGuessPayload): # RFC sect 22.11 + name = "DHCP6 Option - Authentication" + fields_desc = [ ShortEnumField("optcode", 11, dhcp6opts), + FieldLenField("optlen", None, length_of="authinfo", + adjust = lambda pkt,x: x+11), + ByteField("proto", 3), # TODO : XXX + ByteField("alg", 1), # TODO : XXX + ByteField("rdm", 0), # TODO : XXX + StrFixedLenField("replay", b"A"*8, 8), # TODO: XXX + StrLenField("authinfo", b"", + length_from = lambda pkt: pkt.optlen - 11) ] + +#### DHCPv6 Server Unicast Option ################################### + +class _SrvAddrField(IP6Field): + def i2h(self, pkt, x): + if x is None: + return "::" + return x + + def i2m(self, pkt, x): + return inet_pton(socket.AF_INET6, self.i2h(pkt,x)) + +class DHCP6OptServerUnicast(_DHCP6OptGuessPayload):# RFC sect 22.12 + name = "DHCP6 Server Unicast Option" + fields_desc = [ ShortEnumField("optcode", 12, dhcp6opts), + ShortField("optlen", 16 ), + _SrvAddrField("srvaddr",None) ] + + +#### DHCPv6 Status Code Option ###################################### + +dhcp6statuscodes = { 0:"Success", # sect 24.4 + 1:"UnspecFail", + 2:"NoAddrsAvail", + 3:"NoBinding", + 4:"NotOnLink", + 5:"UseMulticast", + 6:"NoPrefixAvail"} # From RFC3633 + +class DHCP6OptStatusCode(_DHCP6OptGuessPayload):# RFC sect 22.13 + name = "DHCP6 Status Code Option" + fields_desc = [ ShortEnumField("optcode", 13, dhcp6opts), + FieldLenField("optlen", None, length_of="statusmsg", + fmt="!H", adjust = lambda pkt,x:x+2), + ShortEnumField("statuscode",None,dhcp6statuscodes), + StrLenField("statusmsg", b"", + length_from = lambda pkt: pkt.optlen-2) ] + + +#### DHCPv6 Rapid Commit Option ##################################### + +class DHCP6OptRapidCommit(_DHCP6OptGuessPayload): # RFC sect 22.14 + name = "DHCP6 Rapid Commit Option" + fields_desc = [ ShortEnumField("optcode", 14, dhcp6opts), + ShortField("optlen", 0)] + + +#### DHCPv6 User Class Option ####################################### + +class _UserClassDataField(PacketListField): + def i2len(self, pkt, z): + if z is None or z == []: + return 0 + return sum(map(lambda x: len(bytes(x)) ,z)) + + def getfield(self, pkt, s): + l = self.length_from(pkt) + lst = [] + remain, payl = s[:l], s[l:] + while len(remain)>0: + p = self.m2i(pkt,remain) + if conf.padding_layer in p: + pad = p[conf.padding_layer] + remain = pad.load + del(pad.underlayer.payload) + else: + remain = b"" + lst.append(p) + return payl,lst + + +class USER_CLASS_DATA(Packet): + name = "user class data" + fields_desc = [ FieldLenField("len", None, length_of="data"), + StrLenField("data", b"", + length_from = lambda pkt: pkt.len) ] + def guess_payload_class(self, payload): + return conf.padding_layer + +class DHCP6OptUserClass(_DHCP6OptGuessPayload):# RFC sect 22.15 + name = "DHCP6 User Class Option" + fields_desc = [ ShortEnumField("optcode", 15, dhcp6opts), + FieldLenField("optlen", None, fmt="!H", + length_of="userclassdata"), + _UserClassDataField("userclassdata", [], USER_CLASS_DATA, + length_from = lambda pkt: pkt.optlen) ] + + +#### DHCPv6 Vendor Class Option ##################################### + +class _VendorClassDataField(_UserClassDataField): + pass + +class VENDOR_CLASS_DATA(USER_CLASS_DATA): + name = "vendor class data" + +class DHCP6OptVendorClass(_DHCP6OptGuessPayload):# RFC sect 22.16 + name = "DHCP6 Vendor Class Option" + fields_desc = [ ShortEnumField("optcode", 16, dhcp6opts), + FieldLenField("optlen", None, length_of="vcdata", fmt="!H", + adjust = lambda pkt,x: x+4), + IntEnumField("enterprisenum",None , iana_enterprise_num ), + _VendorClassDataField("vcdata", [], VENDOR_CLASS_DATA, + length_from = lambda pkt: pkt.optlen-4) ] + +#### DHCPv6 Vendor-Specific Information Option ###################### + +class VENDOR_SPECIFIC_OPTION(_DHCP6OptGuessPayload): + name = "vendor specific option data" + fields_desc = [ ShortField("optcode", None), + FieldLenField("optlen", None, length_of="optdata"), + StrLenField("optdata", b"", + length_from = lambda pkt: pkt.optlen) ] + def guess_payload_class(self, payload): + return conf.padding_layer + +# The third one that will be used for nothing interesting +class DHCP6OptVendorSpecificInfo(_DHCP6OptGuessPayload):# RFC sect 22.17 + name = "DHCP6 Vendor-specific Information Option" + fields_desc = [ ShortEnumField("optcode", 17, dhcp6opts), + FieldLenField("optlen", None, length_of="vso", fmt="!H", + adjust = lambda pkt,x: x+4), + IntEnumField("enterprisenum",None , iana_enterprise_num), + _VendorClassDataField("vso", [], VENDOR_SPECIFIC_OPTION, + length_from = lambda pkt: pkt.optlen-4) ] + +#### DHCPv6 Interface-ID Option ##################################### + +# Repasser sur cette option a la fin. Elle a pas l'air d'etre des +# masses critique. +class DHCP6OptIfaceId(_DHCP6OptGuessPayload):# RFC sect 22.18 + name = "DHCP6 Interface-Id Option" + fields_desc = [ ShortEnumField("optcode", 18, dhcp6opts), + FieldLenField("optlen", None, fmt="!H", + length_of="ifaceid"), + StrLenField("ifaceid", b"", + length_from = lambda pkt: pkt.optlen) ] + + +#### DHCPv6 Reconfigure Message Option ############################## + +# A server includes a Reconfigure Message option in a Reconfigure +# message to indicate to the client whether the client responds with a +# renew message or an Informatiion-request message. +class DHCP6OptReconfMsg(_DHCP6OptGuessPayload): # RFC sect 22.19 + name = "DHCP6 Reconfigure Message Option" + fields_desc = [ ShortEnumField("optcode", 19, dhcp6opts), + ShortField("optlen", 1 ), + ByteEnumField("msgtype", 11, { 5:"Renew Message", + 11:"Information Request"}) ] + + +#### DHCPv6 Reconfigure Accept Option ############################### + +# A client uses the Reconfigure Accept option to announce to the +# server whether the client is willing to accept Recoonfigure +# messages, and a server uses this option to tell the client whether +# or not to accept Reconfigure messages. The default behavior in the +# absence of this option, means unwillingness to accept reconfigure +# messages, or instruction not to accept Reconfigure messages, for the +# client and server messages, respectively. +class DHCP6OptReconfAccept(_DHCP6OptGuessPayload): # RFC sect 22.20 + name = "DHCP6 Reconfigure Accept Option" + fields_desc = [ ShortEnumField("optcode", 20, dhcp6opts), + ShortField("optlen", 0)] + +# As required in Sect 8. of RFC 3315, Domain Names must be encoded as +# described in section 3.1 of RFC 1035 +# XXX Label should be at most 63 octets in length : we do not enforce it +# Total length of domain should be 255 : we do not enforce it either +class DomainNameListField(StrLenField): + islist = 1 + + def i2len(self, pkt, x): + return len(self.i2m(pkt, x)) + + def m2i(self, pkt, x): + res = [] + while x: + cur = [] + #while x and x[0] != b'\x00': + while x and x[0] != 0: + l = (x[0]) + cur.append(x[1:l+1]) + x = x[l+1:] + res.append(b".".join(cur)) + if x and x[0] == 0: + x = x[1:] + return res + + def i2m(self, pkt, x): + def conditionalTrailingDot(z): + if z and z[-1] == 0: + return z + return z+b'\x00' + res = b"" + x = [ i.encode('ascii') for i in x if type(i) is str ] + tmp = map(lambda y: map((lambda z: chr(len(z)).encode('ascii')+z), y.split(b'.')), x) + return b"".join(map(lambda x: conditionalTrailingDot(b"".join(x)), tmp)) + +class DHCP6OptSIPDomains(_DHCP6OptGuessPayload): #RFC3319 + name = "DHCP6 Option - SIP Servers Domain Name List" + fields_desc = [ ShortEnumField("optcode", 21, dhcp6opts), + FieldLenField("optlen", None, length_of="sipdomains"), + DomainNameListField("sipdomains", [], + length_from = lambda pkt: pkt.optlen) ] + +class DHCP6OptSIPServers(_DHCP6OptGuessPayload): #RFC3319 + name = "DHCP6 Option - SIP Servers IPv6 Address List" + fields_desc = [ ShortEnumField("optcode", 22, dhcp6opts), + FieldLenField("optlen", None, length_of="sipservers"), + IP6ListField("sipservers", [], + length_from = lambda pkt: pkt.optlen) ] + +class DHCP6OptDNSServers(_DHCP6OptGuessPayload): #RFC3646 + name = "DHCP6 Option - DNS Recursive Name Server" + fields_desc = [ ShortEnumField("optcode", 23, dhcp6opts), + FieldLenField("optlen", None, length_of="dnsservers"), + IP6ListField("dnsservers", [], + length_from = lambda pkt: pkt.optlen) ] + +class DHCP6OptDNSDomains(_DHCP6OptGuessPayload): #RFC3646 + name = "DHCP6 Option - Domain Search List option" + fields_desc = [ ShortEnumField("optcode", 24, dhcp6opts), + FieldLenField("optlen", None, length_of="dnsdomains"), + DomainNameListField("dnsdomains", [], + length_from = lambda pkt: pkt.optlen) ] + +# TODO: Implement iaprefopts correctly when provided with more +# information about it. +class DHCP6OptIAPrefix(_DHCP6OptGuessPayload): #RFC3633 + name = "DHCP6 Option - IA_PD Prefix option" + fields_desc = [ ShortEnumField("optcode", 26, dhcp6opts), + FieldLenField("optlen", None, length_of="iaprefopts", + adjust = lambda pkt,x: x+26), + IntField("preflft", 0), + IntField("validlft", 0), + ByteField("plen", 48), # TODO: Challenge that default value + IP6Field("prefix", "2001:db8::"), # At least, global and won't hurt + StrLenField("iaprefopts", b"", + length_from = lambda pkt: pkt.optlen-26) ] + +class DHCP6OptIA_PD(_DHCP6OptGuessPayload): #RFC3633 + name = "DHCP6 Option - Identity Association for Prefix Delegation" + fields_desc = [ ShortEnumField("optcode", 25, dhcp6opts), + FieldLenField("optlen", None, length_of="iapdopt", + adjust = lambda pkt,x: x+12), + IntField("iaid", 0), + IntField("T1", 0), + IntField("T2", 0), + PacketListField("iapdopt", [], DHCP6OptIAPrefix, + length_from = lambda pkt: pkt.optlen-12) ] + +class DHCP6OptNISServers(_DHCP6OptGuessPayload): #RFC3898 + name = "DHCP6 Option - NIS Servers" + fields_desc = [ ShortEnumField("optcode", 27, dhcp6opts), + FieldLenField("optlen", None, length_of="nisservers"), + IP6ListField("nisservers", [], + length_from = lambda pkt: pkt.optlen) ] + +class DHCP6OptNISPServers(_DHCP6OptGuessPayload): #RFC3898 + name = "DHCP6 Option - NIS+ Servers" + fields_desc = [ ShortEnumField("optcode", 28, dhcp6opts), + FieldLenField("optlen", None, length_of="nispservers"), + IP6ListField("nispservers", [], + length_from = lambda pkt: pkt.optlen) ] + +class DomainNameField(StrLenField): + def getfield(self, pkt, s): + l = self.length_from(pkt) + return s[l:], self.m2i(pkt,s[:l]) + + def i2len(self, pkt, x): + return len(self.i2m(pkt, x)) + + def m2i(self, pkt, x): + cur = [] + while x: + l = (x[0]) + cur.append(x[1:1+l]) + x = x[l+1:] + ret_str = b".".join(cur) + return ret_str + + def i2m(self, pkt, x): + if not x: + return b"" + tmp = b"".join(map(lambda z: chr(len(z)).encode('ascii')+z, x.split(b'.'))) + return tmp + +class DHCP6OptNISDomain(_DHCP6OptGuessPayload): #RFC3898 + name = "DHCP6 Option - NIS Domain Name" + fields_desc = [ ShortEnumField("optcode", 29, dhcp6opts), + FieldLenField("optlen", None, length_of="nisdomain"), + DomainNameField("nisdomain", "", + length_from = lambda pkt: pkt.optlen) ] + +class DHCP6OptNISPDomain(_DHCP6OptGuessPayload): #RFC3898 + name = "DHCP6 Option - NIS+ Domain Name" + fields_desc = [ ShortEnumField("optcode", 30, dhcp6opts), + FieldLenField("optlen", None, length_of="nispdomain"), + DomainNameField("nispdomain", "", + length_from= lambda pkt: pkt.optlen) ] + +class DHCP6OptSNTPServers(_DHCP6OptGuessPayload): #RFC4075 + name = "DHCP6 option - SNTP Servers" + fields_desc = [ ShortEnumField("optcode", 31, dhcp6opts), + FieldLenField("optlen", None, length_of="sntpservers"), + IP6ListField("sntpservers", [], + length_from = lambda pkt: pkt.optlen) ] + +IRT_DEFAULT=86400 +IRT_MINIMUM=600 +class DHCP6OptInfoRefreshTime(_DHCP6OptGuessPayload): #RFC4242 + name = "DHCP6 Option - Information Refresh Time" + fields_desc = [ ShortEnumField("optcode", 32, dhcp6opts), + ShortField("optlen", 4), + IntField("reftime", IRT_DEFAULT)] # One day + +class DHCP6OptBCMCSDomains(_DHCP6OptGuessPayload): #RFC4280 + name = "DHCP6 Option - BCMCS Domain Name List" + fields_desc = [ ShortEnumField("optcode", 33, dhcp6opts), + FieldLenField("optlen", None, length_of="bcmcsdomains"), + DomainNameListField("bcmcsdomains", [], + length_from = lambda pkt: pkt.optlen) ] + +class DHCP6OptBCMCSServers(_DHCP6OptGuessPayload): #RFC4280 + name = "DHCP6 Option - BCMCS Addresses List" + fields_desc = [ ShortEnumField("optcode", 34, dhcp6opts), + FieldLenField("optlen", None, length_of="bcmcsservers"), + IP6ListField("bcmcsservers", [], + length_from= lambda pkt: pkt.optlen) ] + +# TODO : Does Nothing at the moment +class DHCP6OptGeoConf(_DHCP6OptGuessPayload): #RFC-ietf-geopriv-dhcp-civil-09.txt + name = "" + fields_desc = [ ShortEnumField("optcode", 36, dhcp6opts), + FieldLenField("optlen", None, length_of="optdata"), + StrLenField("optdata", "", + length_from = lambda pkt: pkt.optlen) ] + +# TODO: see if we encounter opaque values from vendor devices +class DHCP6OptRemoteID(_DHCP6OptGuessPayload): #RFC4649 + name = "DHCP6 Option - Relay Agent Remote-ID" + fields_desc = [ ShortEnumField("optcode", 37, dhcp6opts), + FieldLenField("optlen", None, length_of="remoteid", + adjust = lambda pkt,x: x+4), + IntEnumField("enterprisenum", None, iana_enterprise_num), + StrLenField("remoteid", b"", + length_from = lambda pkt: pkt.optlen-4) ] + +# TODO : 'subscriberid' default value should be at least 1 byte long +class DHCP6OptSubscriberID(_DHCP6OptGuessPayload): #RFC4580 + name = "DHCP6 Option - Subscriber ID" + fields_desc = [ ShortEnumField("optcode", 38, dhcp6opts), + FieldLenField("optlen", None, length_of="subscriberid"), + StrLenField("subscriberid", b"", + length_from = lambda pkt: pkt.optlen) ] + +# TODO : "The data in the Domain Name field MUST be encoded +# as described in Section 8 of [5]" +class DHCP6OptClientFQDN(_DHCP6OptGuessPayload): #RFC4704 + name = "DHCP6 Option - Client FQDN" + fields_desc = [ ShortEnumField("optcode", 39, dhcp6opts), + FieldLenField("optlen", None, length_of="fqdn", + adjust = lambda pkt,x: x+1), + BitField("res", 0, 5), + FlagsField("flags", 0, 3, "SON" ), + DomainNameField("fqdn", "", + length_from = lambda pkt: pkt.optlen-1) ] + +class DHCP6OptRelayAgentERO(_DHCP6OptGuessPayload): # RFC4994 + name = "DHCP6 Option - RelayRequest Option" + fields_desc = [ ShortEnumField("optcode", 43, dhcp6opts), + FieldLenField("optlen", None, length_of="reqopts", fmt="!H"), + _OptReqListField("reqopts", [23, 24], + length_from = lambda pkt: pkt.optlen) ] + +##################################################################### +### DHCPv6 messages ### +##################################################################### + +# Some state parameters of the protocols that should probably be +# useful to have in the configuration (and keep up-to-date) +DHCP6RelayAgentUnicastAddr="" +DHCP6RelayHopCount="" +DHCP6ServerUnicastAddr="" +DHCP6ClientUnicastAddr="" +DHCP6ClientIA_TA="" +DHCP6ClientIA_NA="" +DHCP6ClientIAID="" +T1="" # Voir 2462 +T2="" # Voir 2462 +DHCP6ServerDUID="" +DHCP6CurrentTransactionID="" # devrait etre utilise pour matcher une +# reponse et mis a jour en mode client par une valeur aleatoire pour +# laquelle on attend un retour de la part d'un serveur. +DHCP6PrefVal="" # la valeur de preference a utiliser dans +# les options preference + +# Emitted by : +# - server : ADVERTISE, REPLY, RECONFIGURE, RELAY-REPL (vers relay) +# - client : SOLICIT, REQUEST, CONFIRM, RENEW, REBIND, RELEASE, DECLINE, +# INFORMATION REQUEST +# - relay : RELAY-FORW (toward server) + +class _DHCP6GuessPayload(Packet): + def guess_payload_class(self, payload): + if len(payload) > 1 : + print((payload[0])) + return get_cls(dhcp6opts.get(ord(payload[0]),"DHCP6OptUnknown"), conf.raw_layer) + return conf.raw_layer + +##################################################################### +## DHCPv6 messages sent between Clients and Servers (types 1 to 11) +# Comme specifie en section 15.1 de la RFC 3315, les valeurs de +# transaction id sont selectionnees de maniere aleatoire par le client +# a chaque emission et doivent matcher dans les reponses faites par +# les clients +class DHCP6(_DHCP6OptGuessPayload): + name = "DHCPv6 Generic Message)" + fields_desc = [ ByteEnumField("msgtype",None,dhcp6types), + X3BytesField("trid",0x000000) ] + overload_fields = { UDP: {"sport": 546, "dport": 547} } + + def hashret(self): + return struct.pack("!I", self.trid)[1:4] + +##################################################################### +# Solicit Message : sect 17.1.1 RFC3315 +# - sent by client +# - must include a client identifier option +# - the client may include IA options for any IAs to which it wants the +# server to assign address +# - The client use IA_NA options to request the assignment of +# non-temporary addresses and uses IA_TA options to request the +# assignment of temporary addresses +# - The client should include an Option Request option to indicate the +# options the client is interested in receiving (eventually +# including hints) +# - The client includes a Reconfigure Accept option if is willing to +# accept Reconfigure messages from the server. +# Le cas du send and reply est assez particulier car suivant la +# presence d'une option rapid commit dans le solicit, l'attente +# s'arrete au premier message de reponse recu ou alors apres un +# timeout. De la meme maniere, si un message Advertise arrive avec une +# valeur de preference de 255, il arrete l'attente et envoie une +# Request. +# - The client announces its intention to use DHCP authentication by +# including an Authentication option in its solicit message. The +# server selects a key for the client based on the client's DUID. The +# client and server use that key to authenticate all DHCP messages +# exchanged during the session + +class DHCP6_Solicit(DHCP6): + name = "DHCPv6 Solicit Message" + msgtype = 1 + overload_fields = { UDP: {"sport": 546, "dport": 547} } + +##################################################################### +# Advertise Message +# - sent by server +# - Includes a server identifier option +# - Includes a client identifier option +# - the client identifier option must match the client's DUID +# - transaction ID must match + +class DHCP6_Advertise(DHCP6): + name = "DHCPv6 Advertise Message" + msgtype = 2 + overload_fields = { UDP: {"sport": 547, "dport": 546} } + + def answers(self, other): + return (isinstance(other,DHCP6_Solicit) and + other.msgtype == 1 and + self.trid == other.trid) + +##################################################################### +# Request Message +# - sent by clients +# - includes a server identifier option +# - the content of Server Identifier option must match server's DUID +# - includes a client identifier option +# - must include an ORO Option (even with hints) p40 +# - can includes a reconfigure Accept option indicating whether or +# not the client is willing to accept Reconfigure messages from +# the server (p40) +# - When the server receives a Request message via unicast from a +# client to which the server has not sent a unicast option, the server +# discards the Request message and responds with a Reply message +# containinig Status Code option with the value UseMulticast, a Server +# Identifier Option containing the server's DUID, the client +# Identifier option from the client message and no other option. + +class DHCP6_Request(DHCP6): + name = "DHCPv6 Request Message" + msgtype = 3 + +##################################################################### +# Confirm Message +# - sent by clients +# - must include a clien identifier option +# - When the server receives a Confirm Message, the server determines +# whether the addresses in the Confirm message are appropriate for the +# link to which the client is attached. cf p50 + +class DHCP6_Confirm(DHCP6): + name = "DHCPv6 Confirm Message" + msgtype = 4 + +##################################################################### +# Renew Message +# - sent by clients +# - must include a server identifier option +# - content of server identifier option must match the server's identifier +# - must include a client identifier option +# - the clients includes any IA assigned to the interface that may +# have moved to a new link, along with the addresses associated with +# those IAs in its confirm messages +# - When the server receives a Renew message that contains an IA +# option from a client, it locates the client's binding and verifies +# that the information in the IA from the client matches the +# information for that client. If the server cannot find a client +# entry for the IA the server returns the IA containing no addresses +# with a status code option est to NoBinding in the Reply message. cf +# p51 pour le reste. + +class DHCP6_Renew(DHCP6): + name = "DHCPv6 Renew Message" + msgtype = 5 + +##################################################################### +# Rebind Message +# - sent by clients +# - must include a client identifier option +# cf p52 + +class DHCP6_Rebind(DHCP6): + name = "DHCPv6 Rebind Message" + msgtype = 6 + +##################################################################### +# Reply Message +# - sent by servers +# - the message must include a server identifier option +# - transaction-id field must match the value of original message +# The server includes a Rapid Commit option in the Reply message to +# indicate that the reply is in response to a solicit message +# - if the client receives a reply message with a Status code option +# with the value UseMulticast, the client records the receipt of the +# message and sends subsequent messages to the server through the +# interface on which the message was received using multicast. The +# client resends the original message using multicast +# - When the client receives a NotOnLink status from the server in +# response to a Confirm message, the client performs DHCP server +# solicitation as described in section 17 and client-initiated +# configuration as descrribed in section 18 (RFC 3315) +# - when the client receives a NotOnLink status from the server in +# response to a Request, the client can either re-issue the Request +# without specifying any addresses or restart the DHCP server +# discovery process. +# - the server must include a server identifier option containing the +# server's DUID in the Reply message + +class DHCP6_Reply(DHCP6): + name = "DHCPv6 Reply Message" + msgtype = 7 + + overload_fields = { UDP: {"sport": 547, "dport": 546} } + + def answers(self, other): + + types = (DHCP6_InfoRequest, DHCP6_Confirm, DHCP6_Rebind, DHCP6_Decline, DHCP6_Request, DHCP6_Release, DHCP6_Renew) + + return (isinstance(other, types) and + self.trid == other.trid) + +##################################################################### +# Release Message +# - sent by clients +# - must include a server identifier option +# cf p53 + +class DHCP6_Release(DHCP6): + name = "DHCPv6 Release Message" + msgtype = 8 + +##################################################################### +# Decline Message +# - sent by clients +# - must include a client identifier option +# - Server identifier option must match server identifier +# - The addresses to be declined must be included in the IAs. Any +# addresses for the IAs the client wishes to continue to use should +# not be in added to the IAs. +# - cf p54 + +class DHCP6_Decline(DHCP6): + name = "DHCPv6 Decline Message" + msgtype = 9 + +##################################################################### +# Reconfigure Message +# - sent by servers +# - must be unicast to the client +# - must include a server identifier option +# - must include a client identifier option that contains the client DUID +# - must contain a Reconfigure Message Option and the message type +# must be a valid value +# - the server sets the transaction-id to 0 +# - The server must use DHCP Authentication in the Reconfigure +# message. Autant dire que ca va pas etre le type de message qu'on va +# voir le plus souvent. + +class DHCP6_Reconf(DHCP6): + name = "DHCPv6 Reconfigure Message" + msgtype = 10 + overload_fields = { UDP: { "sport": 547, "dport": 546 } } + + +##################################################################### +# Information-Request Message +# - sent by clients when needs configuration information but no +# addresses. +# - client should include a client identifier option to identify +# itself. If it doesn't the server is not able to return client +# specific options or the server can choose to not respond to the +# message at all. The client must include a client identifier option +# if the message will be authenticated. +# - client must include an ORO of option she's interested in receiving +# (can include hints) + +class DHCP6_InfoRequest(DHCP6): + name = "DHCPv6 Information Request Message" + msgtype = 11 + +##################################################################### +# sent between Relay Agents and Servers +# +# Normalement, doit inclure une option "Relay Message Option" +# peut en inclure d'autres. +# voir section 7.1 de la 3315 + +# Relay-Forward Message +# - sent by relay agents to servers +# If the relay agent relays messages to the All_DHCP_Servers multicast +# address or other multicast addresses, it sets the Hop Limit field to +# 32. + +class DHCP6_RelayForward(_DHCP6GuessPayload,Packet): + name = "DHCPv6 Relay Forward Message (Relay Agent/Server Message)" + fields_desc = [ ByteEnumField("msgtype", 12, dhcp6types), + ByteField("hopcount", None), + IP6Field("linkaddr", "::"), + IP6Field("peeraddr", "::") ] + def hashret(self): # we filter on peer address field + return inet_pton(socket.AF_INET6, self.peeraddr) + +##################################################################### +# sent between Relay Agents and Servers +# Normalement, doit inclure une option "Relay Message Option" +# peut en inclure d'autres. +# Les valeurs des champs hop-count, link-addr et peer-addr +# sont copiees du messsage Forward associe. POur le suivi de session. +# Pour le moment, comme decrit dans le commentaire, le hashret +# se limite au contenu du champ peer address. +# Voir section 7.2 de la 3315. + +# Relay-Reply Message +# - sent by servers to relay agents +# - if the solicit message was received in a Relay-Forward message, +# the server constructs a relay-reply message with the Advertise +# message in the payload of a relay-message. cf page 37/101. Envoie de +# ce message en unicast au relay-agent. utilisation de l'adresse ip +# presente en ip source du paquet recu + +class DHCP6_RelayReply(DHCP6_RelayForward): + name = "DHCPv6 Relay Reply Message (Relay Agent/Server Message)" + msgtype = 13 + def hashret(self): # We filter on peer address field. + return inet_pton(socket.AF_INET6, self.peeraddr) + def answers(self, other): + return (isinstance(other, DHCP6_RelayForward) and + self.hopcount == other.hopcount and + self.linkaddr == other.linkaddr and + self.peeraddr == other.peeraddr ) + + +dhcp6_cls_by_type = { 1: "DHCP6_Solicit", + 2: "DHCP6_Advertise", + 3: "DHCP6_Request", + 4: "DHCP6_Confirm", + 5: "DHCP6_Renew", + 6: "DHCP6_Rebind", + 7: "DHCP6_Reply", + 8: "DHCP6_Release", + 9: "DHCP6_Decline", + 10: "DHCP6_Reconf", + 11: "DHCP6_InfoRequest", + 12: "DHCP6_RelayForward", + 13: "DHCP6_RelayReply" } + +def _dhcp6_dispatcher(x, *args, **kargs): + cls = conf.raw_layer + if len(x) >= 2: + cls = get_cls(dhcp6_cls_by_type.get((x[0]), "Raw"), conf.raw_layer) + return cls(x, *args, **kargs) + +bind_bottom_up(UDP, _dhcp6_dispatcher, { "dport": 547 } ) +bind_bottom_up(UDP, _dhcp6_dispatcher, { "dport": 546 } ) + + + +class DHCPv6_am(AnsweringMachine): + function_name = "dhcp6d" + filter = "udp and port 546 and port 547" + send_function = staticmethod(send) + def usage(self): + msg = """ +dhcp6d( dns="2001:500::1035", domain="localdomain, local", duid=None) + iface=conf.iface6, advpref=255, sntpservers=None, + sipdomains=None, sipservers=None, + nisdomain=None, nisservers=None, + nispdomain=None, nispservers=None, + bcmcsdomain=None, bcmcsservers=None) + + debug : When set, additional debugging information is printed. + + duid : some DUID class (DUID_LLT, DUID_LL or DUID_EN). If none + is provided a DUID_LLT is constructed based on the MAC + address of the sending interface and launch time of dhcp6d + answering machine. + + iface : the interface to listen/reply on if you do not want to use + conf.iface6. + + advpref : Value in [0,255] given to Advertise preference field. + By default, 255 is used. Be aware that this specific + value makes clients stops waiting for further Advertise + messages from other servers. + + dns : list of recursive DNS servers addresses (as a string or list). + By default, it is set empty and the associated DHCP6OptDNSServers + option is inactive. See RFC 3646 for details. + domain : a list of DNS search domain (as a string or list). By default, + it is empty and the associated DHCP6OptDomains option is inactive. + See RFC 3646 for details. + + sntpservers : a list of SNTP servers IPv6 addresses. By default, + it is empty and the associated DHCP6OptSNTPServers option + is inactive. + + sipdomains : a list of SIP domains. By default, it is empty and the + associated DHCP6OptSIPDomains option is inactive. See RFC 3319 + for details. + sipservers : a list of SIP servers IPv6 addresses. By default, it is + empty and the associated DHCP6OptSIPDomains option is inactive. + See RFC 3319 for details. + + nisdomain : a list of NIS domains. By default, it is empty and the + associated DHCP6OptNISDomains option is inactive. See RFC 3898 + for details. See RFC 3646 for details. + nisservers : a list of NIS servers IPv6 addresses. By default, it is + empty and the associated DHCP6OptNISServers option is inactive. + See RFC 3646 for details. + + nispdomain : a list of NIS+ domains. By default, it is empty and the + associated DHCP6OptNISPDomains option is inactive. See RFC 3898 + for details. + nispservers : a list of NIS+ servers IPv6 addresses. By default, it is + empty and the associated DHCP6OptNISServers option is inactive. + See RFC 3898 for details. + + bcmcsdomain : a list of BCMCS domains. By default, it is empty and the + associated DHCP6OptBCMCSDomains option is inactive. See RFC 4280 + for details. + bcmcsservers : a list of BCMCS servers IPv6 addresses. By default, it is + empty and the associated DHCP6OptBCMCSServers option is inactive. + See RFC 4280 for details. + + If you have a need for others, just ask ... or provide a patch.""" + print(msg) + + def parse_options(self, dns="2001:500::1035", domain="localdomain, local", + startip="2001:db8::1", endip="2001:db8::20", duid=None, + sntpservers=None, sipdomains=None, sipservers=None, + nisdomain=None, nisservers=None, nispdomain=None, + nispservers=None, bcmcsservers=None, bcmcsdomains=None, + iface=None, debug=0, advpref=255): + def norm_list(val, param_name): + if val is None: + return None + if type(val) is list: + return val + elif type(val) is str: + l = val.split(',') + return map(lambda x: x.strip(), l) + else: + print("Bad '%s' parameter provided." % param_name) + self.usage() + return -1 + + if iface is None: + iface = conf.iface6 + + self.debug = debug + + # Dictionary of provided DHCPv6 options, keyed by option type + self.dhcpv6_options={} + + for o in [(dns, "dns", 23, lambda x: DHCP6OptDNSServers(dnsservers=x)), + (domain, "domain", 24, lambda x: DHCP6OptDNSDomains(dnsdomains=x)), + (sntpservers, "sntpservers", 31, lambda x: DHCP6OptSNTPServers(sntpservers=x)), + (sipservers, "sipservers", 22, lambda x: DHCP6OptSIPServers(sipservers=x)), + (sipdomains, "sipdomains", 21, lambda x: DHCP6OptSIPDomains(sipdomains=x)), + (nisservers, "nisservers", 27, lambda x: DHCP6OptNISServers(nisservers=x)), + (nisdomain, "nisdomain", 29, lambda x: DHCP6OptNISDomain(nisdomain=(x+[""])[0])), + (nispservers, "nispservers", 28, lambda x: DHCP6OptNISPServers(nispservers=x)), + (nispdomain, "nispdomain", 30, lambda x: DHCP6OptNISPDomain(nispdomain=(x+[""])[0])), + (bcmcsservers, "bcmcsservers", 33, lambda x: DHCP6OptBCMCSServers(bcmcsservers=x)), + (bcmcsdomains, "bcmcsdomains", 34, lambda x: DHCP6OptBCMCSDomains(bcmcsdomains=x))]: + + opt = norm_list(o[0], o[1]) + if opt == -1: # Usage() was triggered + return False + elif opt is None: # We won't return that option + pass + else: + self.dhcpv6_options[o[2]] = o[3](opt) + + if self.debug: + print("\n[+] List of active DHCPv6 options:") + opts = self.dhcpv6_options.keys() + opts.sort() + for i in opts: + print(" %d: %s" % (i, repr(self.dhcpv6_options[i]))) + + # Preference value used in Advertise. + self.advpref = advpref + + # IP Pool + self.startip = startip + self.endip = endip + # XXX TODO Check IPs are in same subnet + + #### + # The interface we are listening/replying on + self.iface = iface + + #### + # Generate a server DUID + if duid is not None: + self.duid = duid + else: + # Timeval + from time import gmtime, strftime, mktime + epoch = (2000, 1, 1, 0, 0, 0, 5, 1, 0) + delta = mktime(epoch) - mktime(gmtime(0)) + timeval = time.time() - delta + + # Mac Address + rawmac = get_if_raw_hwaddr(iface) + mac = ":".join(map(lambda x: "%.02x" % x, rawmac)) + + self.duid = DUID_LLT(timeval = timeval, lladdr = mac) + + if self.debug: + print("\n[+] Our server DUID:" ) + self.duid.show(label_lvl=" "*4) + + #### + # Find the source address we will use + #l = filter(lambda x: x[2] == iface and in6_islladdr(x[0]), in6_getifaddr()) + l = [ x for x in in6_getifaddr() if x[2] == iface and in6_islladdr(x[0]) ] + if not l: + warning("Unable to get a Link-Local address") + return + + self.src_addr = l[0][0] + + #### + # Our leases + self.leases = {} + + + if self.debug: + print("\n[+] Starting DHCPv6 service on %s:" % self.iface ) + + def is_request(self, p): + if not IPv6 in p: + return False + + src = p[IPv6].src + dst = p[IPv6].dst + + p = p[IPv6].payload + if not isinstance(p, UDP) or p.sport != 546 or p.dport != 547 : + return False + + p = p.payload + if not isinstance(p, DHCP6): + return False + + # Message we considered client messages : + # Solicit (1), Request (3), Confirm (4), Renew (5), Rebind (6) + # Decline (9), Release (8), Information-request (11), + if not (p.msgtype in [1, 3, 4, 5, 6, 8, 9, 11]): + return False + + # Message validation following section 15 of RFC 3315 + + if ((p.msgtype == 1) or # Solicit + (p.msgtype == 6) or # Rebind + (p.msgtype == 4)): # Confirm + if ((not DHCP6OptClientId in p) or + DHCP6OptServerId in p): + return False + + if (p.msgtype == 6 or # Rebind + p.msgtype == 4): # Confirm + # XXX We do not reply to Confirm or Rebind as we + # XXX do not support address assignment + return False + + elif (p.msgtype == 3 or # Request + p.msgtype == 5 or # Renew + p.msgtype == 8): # Release + + # Both options must be present + if ((not DHCP6OptServerId in p) or + (not DHCP6OptClientId in p)): + return False + # provided server DUID must match ours + duid = p[DHCP6OptServerId].duid + if (type(duid) != type(self.duid)): + return False + if bytes(duid) != bytes(self.duid): + return False + + if (p.msgtype == 5 or # Renew + p.msgtype == 8): # Release + # XXX We do not reply to Renew or Release as we + # XXX do not support address assignment + return False + + elif p.msgtype == 9: # Decline + # XXX We should check if we are tracking that client + if not self.debug: + return False + + bo = Color.bold + g = Color.green + bo + b = Color.blue + bo + n = Color.normal + r = Color.red + + vendor = in6_addrtovendor(src) + if (vendor and vendor != "UNKNOWN"): + vendor = " [" + b + vendor + n + "]" + else: + vendor = "" + src = bo + src + n + + it = p + addrs = [] + while it: + l = [] + if isinstance(it, DHCP6OptIA_NA): + l = it.ianaopts + elif isinstance(it, DHCP6OptIA_TA): + l = it.iataopts + + #opsaddr = filter(lambda x: isinstance(x, DHCP6OptIAAddress),l) + opsaddr = [ x for x in l if isinstance(x, DHCP6OptIAAddress) ] + a=map(lambda x: x.addr, opsaddr) + addrs += a + it = it.payload + + addrs = map(lambda x: bo + x + n, addrs) + if debug: + msg = r + "[DEBUG]" + n + " Received " + g + "Decline" + n + msg += " from " + bo + src + vendor + " for " + msg += ", ".join(addrs)+ n + print(msg) + + # See sect 18.1.7 + + # Sent by a client to warn us she has determined + # one or more addresses assigned to her is already + # used on the link. + # We should simply log that fact. No messaged should + # be sent in return. + + # - Message must include a Server identifier option + # - the content of the Server identifier option must + # match the server's identifier + # - the message must include a Client Identifier option + return False + + elif p.msgtype == 11: # Information-Request + if DHCP6OptServerId in p: + duid = p[DHCP6OptServerId].duid + if (type(duid) != type(self.duid)): + return False + if bytes(duid) != bytes(self.duid): + return False + if ((DHCP6OptIA_NA in p) or + (DHCP6OptIA_TA in p) or + (DHCP6OptIA_PD in p)): + return False + else: + return False + + return True + + def print_reply(self, req, reply): + def norm(s): + if s.startswith("DHCPv6 "): + s = s[7:] + if s.endswith(" Message"): + s = s[:-8] + return s + + if reply is None: + return + + bo = Color.bold + g = Color.green + bo + b = Color.blue + bo + n = Color.normal + reqtype = g + norm(req.getlayer(UDP).payload.name) + n + reqsrc = req.getlayer(IPv6).src + vendor = in6_addrtovendor(reqsrc) + if (vendor and vendor != "UNKNOWN"): + vendor = " [" + b + vendor + n + "]" + else: + vendor = "" + reqsrc = bo + reqsrc + n + reptype = g + norm(reply.getlayer(UDP).payload.name) + n + + print("Sent %s answering to %s from %s%s" % (reptype, reqtype, reqsrc, vendor)) + + def make_reply(self, req): + req_mac_src = req.src + req_mac_dst = req.dst + + p = req[IPv6] + req_src = p.src + req_dst = p.dst + + p = p.payload.payload + + msgtype = p.msgtype + trid = p.trid + + if msgtype == 1: # SOLICIT (See Sect 17.1 and 17.2 of RFC 3315) + + # XXX We don't support address or prefix assignment + # XXX We also do not support relay function --arno + + client_duid = p[DHCP6OptClientId].duid + resp = IPv6(src=self.src_addr, dst=req_src) + resp /= UDP(sport=547, dport=546) + + if p.haslayer(DHCP6OptRapidCommit): + # construct a Reply packet + resp /= DHCP6_Reply(trid=trid) + resp /= DHCP6OptRapidCommit() # See 17.1.2 + resp /= DHCP6OptServerId(duid = self.duid) + resp /= DHCP6OptClientId(duid = client_duid) + + else: # No Rapid Commit in the packet. Reply with an Advertise + + if (p.haslayer(DHCP6OptIA_NA) or + p.haslayer(DHCP6OptIA_TA)): + # XXX We don't assign addresses at the moment + msg = "Scapy6 dhcp6d does not support address assignment" + resp /= DHCP6_Advertise(trid = trid) + resp /= DHCP6OptStatusCode(statuscode=2, statusmsg=msg) + resp /= DHCP6OptServerId(duid = self.duid) + resp /= DHCP6OptClientId(duid = client_duid) + + elif p.haslayer(DHCP6OptIA_PD): + # XXX We don't assign prefixes at the moment + msg = "Scapy6 dhcp6d does not support prefix assignment" + resp /= DHCP6_Advertise(trid = trid) + resp /= DHCP6OptStatusCode(statuscode=6, statusmsg=msg) + resp /= DHCP6OptServerId(duid = self.duid) + resp /= DHCP6OptClientId(duid = client_duid) + + else: # Usual case, no request for prefixes or addresse + resp /= DHCP6_Advertise(trid = trid) + resp /= DHCP6OptPref(prefval = self.advpref) + resp /= DHCP6OptServerId(duid = self.duid) + resp /= DHCP6OptClientId(duid = client_duid) + resp /= DHCP6OptReconfAccept() + + # See which options should be included + reqopts = [] + if p.haslayer(DHCP6OptOptReq): # add only asked ones + reqopts = p[DHCP6OptOptReq].reqopts + for o in self.dhcpv6_options.keys(): + if o in reqopts: + resp /= self.dhcpv6_options[o] + else: # advertise everything we have available + for o in self.dhcpv6_options.keys(): + resp /= self.dhcpv6_options[o] + + return resp + + elif msgtype == 3: #REQUEST (INFO-REQUEST is further below) + client_duid = p[DHCP6OptClientId].duid + resp = IPv6(src=self.src_addr, dst=req_src) + resp /= UDP(sport=547, dport=546) + resp /= DHCP6_Solicit(trid=trid) + resp /= DHCP6OptServerId(duid = self.duid) + resp /= DHCP6OptClientId(duid = client_duid) + + # See which options should be included + reqopts = [] + if p.haslayer(DHCP6OptOptReq): # add only asked ones + reqopts = p[DHCP6OptOptReq].reqopts + for o in self.dhcpv6_options.keys(): + if o in reqopts: + resp /= self.dhcpv6_options[o] + else: + # advertise everything we have available. + # Should not happen has clients MUST include + # and ORO in requests (sec 18.1.1) -- arno + for o in self.dhcpv6_options.keys(): + resp /= self.dhcpv6_options[o] + + return resp + + elif msgtype == 4: # CONFIRM + # see Sect 18.1.2 + + # Client want to check if addresses it was assigned + # are still appropriate + + # Server must discard any Confirm messages that + # do not include a Client Identifier option OR + # THAT DO INCLUDE a Server Identifier Option + + # XXX we must discard the SOLICIT if it is received with + # a unicast destination address + + pass + + elif msgtype == 5: # RENEW + # see Sect 18.1.3 + + # Clients want to extend lifetime of assigned addresses + # and update configuration parameters. This message is sent + # specifically to the server that provided her the info + + # - Received message must include a Server Identifier + # option. + # - the content of server identifier option must match + # the server's identifier. + # - the message must include a Client identifier option + + pass + + elif msgtype == 6: # REBIND + # see Sect 18.1.4 + + # Same purpose as the Renew message but sent to any + # available server after he received no response + # to its previous Renew message. + + + # - Message must include a Client Identifier Option + # - Message can't include a Server identifier option + + # XXX we must discard the SOLICIT if it is received with + # a unicast destination address + + pass + + elif msgtype == 8: # RELEASE + # See section 18.1.6 + + # Message is sent to the server to indicate that + # she will no longer use the addresses that was assigned + # We should parse the message and verify our dictionary + # to log that fact. + + + # - The message must include a server identifier option + # - The content of the Server Identifier option must + # match the server's identifier + # - the message must include a Client Identifier option + + pass + + elif msgtype == 9: # DECLINE + # See section 18.1.7 + pass + + elif msgtype == 11: # INFO-REQUEST + client_duid = None + if not p.haslayer(DHCP6OptClientId): + if self.debug: + warning("Received Info Request message without Client Id option") + else: + client_duid = p[DHCP6OptClientId].duid + + resp = IPv6(src=self.src_addr, dst=req_src) + resp /= UDP(sport=547, dport=546) + resp /= DHCP6_Reply(trid=trid) + resp /= DHCP6OptServerId(duid = self.duid) + + if client_duid: + resp /= DHCP6OptClientId(duid = client_duid) + + # Stack requested options if available + reqopts = [] + if p.haslayer(DHCP6OptOptReq): + reqopts = p[DHCP6OptOptReq].reqopts + for o in self.dhcpv6_options.keys(): + resp /= self.dhcpv6_options[o] + + return resp + + else: + # what else ? + pass + + # - We won't support reemission + # - We won't support relay role, nor relay forwarded messages + # at the beginning diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/dns.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dns.py new file mode 100644 index 00000000..8a01e273 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dns.py @@ -0,0 +1,712 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +DNS: Domain Name System. +""" + +import socket,struct + +from scapy.packet import * +from scapy.fields import * +from scapy.ansmachine import * +from scapy.layers.inet import IP, UDP +from scapy.utils import str2bytes + +class DNSStrField(StrField): + + def h2i(self, pkt, x): + if type(x) == str: + x = x.encode('ascii') + if x == b"": + return b"." + return x + + def i2m(self, pkt, x): + if type(x) == str: + x = x.encode('ascii') + if x == b".": + return b"\x00" + + x = [k[:63] for k in x.split(b".")] # Truncate chunks that cannot be encoded (more than 63 bytes..) + x = map(lambda y: bytes([len(y)]) + y, x) + x = b"".join(x) + if x[-1] != 0: + x += b"\x00" + return x + + def getfield(self, pkt, s): + n = b"" + + #if ord(s[0]) == 0: + if (s[0]) == 0: + return s[1:], b"." + + while 1: + #l = ord(s[0]) + l = (s[0]) + s = s[1:] + if not l: + break + if l & 0xc0: + raise Scapy_Exception("DNS message can't be compressed at this point!") + else: + n += s[:l]+b"." + s = s[l:] + return s, n + + +class DNSRRCountField(ShortField): + holds_packets=1 + def __init__(self, name, default, rr): + ShortField.__init__(self, name, default) + self.rr = rr + def _countRR(self, pkt): + x = getattr(pkt,self.rr) + i = 0 + while isinstance(x, DNSRR) or isinstance(x, DNSQR) or isdnssecRR(x): + x = x.payload + i += 1 + return i + + def i2m(self, pkt, x): + if x is None: + x = self._countRR(pkt) + return x + def i2h(self, pkt, x): + if x is None: + x = self._countRR(pkt) + return x + + +def DNSgetstr(s,p): + name = b"" + q = 0 + jpath = [p] + while 1: + if p >= len(s): + warning("DNS RR prematured end (ofs=%i, len=%i)"%(p,len(s))) + break + #l = ord(s[p]) + l = s[p] + p += 1 + if l & 0xc0: + if not q: + q = p+1 + if p >= len(s): + warning("DNS incomplete jump token at (ofs=%i)" % p) + break + p = ((l & 0x3f) << 8) + s[p] - 12 + if p in jpath: + warning("DNS decompression loop detected") + break + jpath.append(p) + continue + elif l > 0: + name += s[p:p+l]+b"." + p += l + continue + break + if q: + p = q + return name,p + + +class DNSRRField(StrField): + holds_packets=1 + def __init__(self, name, countfld, passon=1): + StrField.__init__(self, name, None) + self.countfld = countfld + self.passon = passon + def i2m(self, pkt, x): + if x is None: + return b"" + return bytes(x) + def decodeRR(self, name, s, p): + ret = s[p:p+10] + type,cls,ttl,rdlen = struct.unpack("!HHIH", ret) + p += 10 + rr = DNSRR(b"\x00"+ret+s[p:p+rdlen]) + if type in [2, 3, 4, 5]: + rr.rdata = DNSgetstr(s,p)[0] + del(rr.rdlen) + elif type in dnsRRdispatcher.keys(): + rr = dnsRRdispatcher[type](b"\x00"+ret+s[p:p+rdlen]) + else: + del(rr.rdlen) + + p += rdlen + + rr.rrname = name + return rr,p + def getfield(self, pkt, s): + if type(s) is tuple : + s,p = s + else: + p = 0 + ret = None + c = getattr(pkt, self.countfld) + if c > len(s): + warning("wrong value: DNS.%s=%i" % (self.countfld,c)) + return s,b"" + while c: + c -= 1 + name,p = DNSgetstr(s,p) + rr,p = self.decodeRR(name, s, p) + if ret is None: + ret = rr + else: + ret.add_payload(rr) + if self.passon: + return (s,p),ret + else: + return s[p:],ret + + +class DNSQRField(DNSRRField): + holds_packets=1 + def decodeRR(self, name, s, p): + ret = s[p:p+4] + p += 4 + rr = DNSQR(b"\x00"+ret) + rr.qname = name + return rr,p + + + +class RDataField(StrLenField): + def m2i(self, pkt, s): + family = None + if pkt.type == 1: # A + family = socket.AF_INET + elif pkt.type == 12: # PTR + s = DNSgetstr(s, 0)[0] + elif pkt.type == 16: # TXT + ret_s = b"" + tmp_s = s + # RDATA contains a list of strings, each are prepended with + # a byte containing the size of the following string. + while tmp_s: + tmp_len = struct.unpack("!B", bytes([tmp_s[0]]))[0] + 1 + if tmp_len > len(tmp_s): + warning("DNS RR TXT prematured end of character-string (size=%i, remaining bytes=%i)" % (tmp_len, len(tmp_s))) + ret_s += tmp_s[1:tmp_len] + tmp_s = tmp_s[tmp_len:] + s = ret_s + elif pkt.type == 28: # AAAA + family = socket.AF_INET6 + if family is not None: + s = inet_ntop(family, s) + return s + def i2m(self, pkt, s): + if pkt.type == 1: # A + if s: + if type(s) is bytes: + s = s.decode('ascii') + s = inet_aton(s) + elif pkt.type in [2,3,4,5]: # NS, MD, MF, CNAME + s = b"".join(map(lambda x: bytes([len(x)]) + x, s.split(b"."))) + #if ord(s[-1]): + if s[-1]: + s += b"\x00" + elif pkt.type == 16: # TXT + if s: + ret_s = b"" + # The initial string must be splitted into a list of strings + # prepended with theirs sizes. + while len(s) >= 255: + ret_s += b"\xff" + s[:255] + s = s[255:] + # The remaining string is less than 255 bytes long + if len(s): + ret_s += struct.pack("!B", len(s)) + s + s = ret_s + elif pkt.type == 28: # AAAA + if s: + s = inet_pton(socket.AF_INET6, s) + return s + +class RDLenField(Field): + def __init__(self, name): + Field.__init__(self, name, None, "H") + def i2m(self, pkt, x): + if x is None: + rdataf = pkt.get_field("rdata") + x = len(rdataf.i2m(pkt, pkt.rdata)) + return x + def i2h(self, pkt, x): + if x is None: + rdataf = pkt.get_field("rdata") + x = len(rdataf.i2m(pkt, pkt.rdata)) + return x + + +class DNS(Packet): + name = "DNS" + fields_desc = [ ShortField("id", 0), + BitField("qr", 0, 1), + BitEnumField("opcode", 0, 4, {0:"QUERY",1:"IQUERY",2:"STATUS"}), + BitField("aa", 0, 1), + BitField("tc", 0, 1), + BitField("rd", 0, 1), + BitField("ra", 0, 1), + BitField("z", 0, 1), + # AD and CD bits are defined in RFC 2535 + BitField("ad", 0, 1), # Authentic Data + BitField("cd", 0, 1), # Checking Disabled + BitEnumField("rcode", 0, 4, {0:"ok", 1:"format-error", 2:"server-failure", 3:"name-error", 4:"not-implemented", 5:"refused"}), + DNSRRCountField("qdcount", None, "qd"), + DNSRRCountField("ancount", None, "an"), + DNSRRCountField("nscount", None, "ns"), + DNSRRCountField("arcount", None, "ar"), + DNSQRField("qd", "qdcount"), + DNSRRField("an", "ancount"), + DNSRRField("ns", "nscount"), + DNSRRField("ar", "arcount",0) ] + def answers(self, other): + return (isinstance(other, DNS) + and self.id == other.id + and self.qr == 1 + and other.qr == 0) + + def mysummary(self): + type = ["Qry","Ans"][self.qr] + name = "" + if self.qr: + type = "Ans" + if self.ancount > 0 and isinstance(self.an, DNSRR): + name = ' "%s"' % self.an.getstrval("rdata") + else: + type = "Qry" + if self.qdcount > 0 and isinstance(self.qd, DNSQR): + name = ' "%s"' % self.qd.getstrval("qname") + return 'DNS %s%s ' % (type, name) + +dnstypes = { 0:"ANY", 255:"ALL", + 1:"A", 2:"NS", 3:"MD", 4:"MF", 5:"CNAME", 6:"SOA", 7: "MB", 8:"MG", + 9:"MR",10:"NULL",11:"WKS",12:"PTR",13:"HINFO",14:"MINFO",15:"MX",16:"TXT", + 17:"RP",18:"AFSDB",28:"AAAA", 33:"SRV",38:"A6",39:"DNAME", + 41:"OPT", 43:"DS", 46:"RRSIG", 47:"NSEC", 48:"DNSKEY", + 50: "NSEC3", 51: "NSEC3PARAM", 32769:"DLV" } + +dnsqtypes = {251:"IXFR",252:"AXFR",253:"MAILB",254:"MAILA",255:"ALL"} +dnsqtypes.update(dnstypes) +dnsclasses = {1: 'IN', 2: 'CS', 3: 'CH', 4: 'HS', 255: 'ANY'} + + +class DNSQR(Packet): + name = "DNS Question Record" + show_indent=0 + fields_desc = [ DNSStrField("qname",b""), + ShortEnumField("qtype", 1, dnsqtypes), + ShortEnumField("qclass", 1, dnsclasses) ] + + + +# RFC 2671 - Extension Mechanisms for DNS (EDNS0) + +class EDNS0TLV(Packet): + name = "DNS EDNS0 TLV" + fields_desc = [ ShortEnumField("optcode", 0, { 0: "Reserved", 1: "LLQ", 2: "UL", 3: "NSID", 4: "Reserved", 5: "PING" }), + FieldLenField("optlen", None, "optdata", fmt="H"), + StrLenField("optdata", b"", length_from=lambda pkt: pkt.optlen) ] + + def extract_padding(self, p): + return b"", p + +class DNSRROPT(Packet): + name = "DNS OPT Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 41, dnstypes), + ShortField("rclass", 4096), + ByteField("extrcode", 0), + ByteField("version", 0), + # version 0 means EDNS0 + BitEnumField("z", 32768, 16, { 32768: "D0" }), + # D0 means DNSSEC OK from RFC 3225 + FieldLenField("rdlen", None, length_of="rdata", fmt="H"), + PacketListField("rdata", [], EDNS0TLV, length_from=lambda pkt: pkt.rdlen) ] + +# RFC 4034 - Resource Records for the DNS Security Extensions + +# 09/2013 from http://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml +dnssecalgotypes = { 0:"Reserved", 1:"RSA/MD5", 2:"Diffie-Hellman", 3:"DSA/SHA-1", + 4:"Reserved", 5:"RSA/SHA-1", 6:"DSA-NSEC3-SHA1", + 7:"RSASHA1-NSEC3-SHA1", 8:"RSA/SHA-256", 9:"Reserved", + 10:"RSA/SHA-512", 11:"Reserved", 12:"GOST R 34.10-2001", + 13:"ECDSA Curve P-256 with SHA-256", 14: "ECDSA Curve P-384 with SHA-384", + 252:"Reserved for Indirect Keys", 253:"Private algorithms - domain name", + 254:"Private algorithms - OID", 255:"Reserved" } + +# 09/2013 from http://www.iana.org/assignments/ds-rr-types/ds-rr-types.xhtml +dnssecdigesttypes = { 0:"Reserved", 1:"SHA-1", 2:"SHA-256", 3:"GOST R 34.11-94", 4:"SHA-384" } + + +class TimeField(IntField): + + def any2i(self, pkt, x): + if type(x) == str: + import time, calendar + t = time.strptime(x, "%Y%m%d%H%M%S") + return int(calendar.timegm(t)) + return x + + def i2repr(self, pkt, x): + import time + x = self.i2h(pkt, x) + t = time.strftime("%Y%m%d%H%M%S", time.gmtime(x)) + return "%s (%d)" % (t ,x) + + +def bitmap2RRlist(bitmap): + """ + Decode the 'Type Bit Maps' field of the NSEC Resource Record into an + integer list. + """ + # RFC 4034, 4.1.2. The Type Bit Maps Field + + RRlist = [] + + while bitmap: + + if len(bitmap) < 2: + warning("bitmap too short (%i)" % len(bitmap)) + return + + #window_block = ord(bitmap[0]) # window number + window_block = (bitmap[0]) # window number + offset = 256*window_block # offset of the Ressource Record + #bitmap_len = ord(bitmap[0]) # length of the bitmap in bytes + bitmap_len = (bitmap[1]) # length of the bitmap in bytes + + if bitmap_len <= 0 or bitmap_len > 32: + warning("bitmap length is no valid (%i)" % bitmap_len) + return + + tmp_bitmap = bitmap[2:2+bitmap_len] + + # Let's compare each bit of tmp_bitmap and compute the real RR value + for b in range(len(tmp_bitmap)): + v = 128 + for i in range(8): + #if ord(tmp_bitmap[b]) & v: + if (tmp_bitmap[b]) & v: + # each of the RR is encoded as a bit + RRlist += [ offset + b*8 + i ] + v = v >> 1 + +# Next block if any + bitmap = bitmap[2+bitmap_len:] + + return RRlist + + +def RRlist2bitmap(lst): + """ + Encode a list of integers representing Resource Records to a bitmap field + used in the NSEC Resource Record. + """ + # RFC 4034, 4.1.2. The Type Bit Maps Field + + import math + + bitmap = b"" + lst = list(set(lst)) + lst.sort() + + #lst = filter(lambda x: x <= 65535, lst) + #lst = map(lambda x: abs(x), lst) + lst = [ abs(x) for x in lst if x<= 65535 ] + + # number of window blocks + max_window_blocks = int(math.ceil(lst[-1] / 256.)) + min_window_blocks = int(math.floor(lst[0] / 256.)) + if min_window_blocks == max_window_blocks: + max_window_blocks += 1 + + for wb in range(min_window_blocks, max_window_blocks+1): + # First, filter out RR not encoded in the current window block + # i.e. keep everything between 256*wb <= 256*(wb+1) + #rrlist = filter(lambda x: 256*wb <= x and x < 256*(wb+1), lst) + rrlist = [ x for x in lst if 256*wb <= x and x < 256*(wb+1) ] + rrlist.sort() + if rrlist == []: + continue + + # Compute the number of bytes used to store the bitmap + if rrlist[-1] == 0: # only one element in the list + bs = 1 + else: + max = rrlist[-1] - 256*wb + #bs = int(math.ceil(max / 8)) + 1 # use at least 1 byte + bs = int(max // 8) + 1 # use at least 1 byte + if bs > 32: # Don't encode more than 256 bits / values + bs = 32 + + bitmap += struct.pack("B", wb) + bitmap += struct.pack("B", bs) + + # Generate the bitmap + for tmp in range(bs): + v = 0 + # Remove out of range Ressource Records + #tmp_rrlist = filter(lambda x: 256*wb+8*tmp <= x and x < 256*wb+8*tmp+8, rrlist) + tmp_rrlist = [ x for x in rrlist if 256*wb+8*tmp <= x and x < 256*wb+8*tmp+8 ] + if not tmp_rrlist == []: + # 1. rescale to fit into 8 bits + tmp_rrlist = map(lambda x: (x-256*wb)-(tmp*8), tmp_rrlist) + # 2. x gives the bit position ; compute the corresponding value + tmp_rrlist = map(lambda x: 2**(7-x) , tmp_rrlist) + # 3. sum everything + #v = reduce(lambda x,y: x+y, tmp_rrlist) + v = sum(tmp_rrlist) + bitmap += struct.pack("B", v) + + return bitmap + + +class RRlistField(StrField): + def h2i(self, pkt, x): + if type(x) == list: + return RRlist2bitmap(x) + return x + + def i2repr(self, pkt, x): + x = self.i2h(pkt, x) + rrlist = bitmap2RRlist(x) + return [ dnstypes.get(rr, rr) for rr in rrlist ] + + +class _DNSRRdummy(Packet): + name = "Dummy class that implements post_build() for Ressource Records" + def post_build(self, pkt, pay): + if not self.rdlen == None: + return pkt + + lrrname = len(self.fields_desc[0].i2m(b"", self.getfieldval("rrname"))) + l = len(pkt) - lrrname - 10 + pkt = pkt[:lrrname+8] + struct.pack("!H", l) + pkt[lrrname+8+2:] + + return pkt + +class DNSRRSOA(_DNSRRdummy): + name = "DNS SOA Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 6, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + DNSStrField("mname", b""), + DNSStrField("rname", b""), + IntField("serial", 0), + IntField("refresh", 0), + IntField("retry", 0), + IntField("expire", 0), + IntField("minimum", 0) + ] + +class DNSRRRSIG(_DNSRRdummy): + name = "DNS RRSIG Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 46, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + ShortEnumField("typecovered", 1, dnstypes), + ByteEnumField("algorithm", 5, dnssecalgotypes), + ByteField("labels", 0), + IntField("originalttl", 0), + TimeField("expiration", 0), + TimeField("inception", 0), + ShortField("keytag", 0), + DNSStrField("signersname", b""), + StrField("signature", b"") + ] + + +class DNSRRNSEC(_DNSRRdummy): + name = "DNS NSEC Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 47, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + DNSStrField("nextname", b""), + RRlistField("typebitmaps", b"") + ] + + +class DNSRRDNSKEY(_DNSRRdummy): + name = "DNS DNSKEY Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 48, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + FlagsField("flags", 256, 16, "S???????Z???????"), + # S: Secure Entry Point + # Z: Zone Key + ByteField("protocol", 3), + ByteEnumField("algorithm", 5, dnssecalgotypes), + StrField("publickey", b"") + ] + + +class DNSRRDS(_DNSRRdummy): + name = "DNS DS Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 43, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + ShortField("keytag", 0), + ByteEnumField("algorithm", 5, dnssecalgotypes), + ByteEnumField("digesttype", 5, dnssecdigesttypes), + StrField("digest", b"") + ] + + +# RFC 5074 - DNSSEC Lookaside Validation (DLV) +class DNSRRDLV(DNSRRDS): + name = "DNS DLV Resource Record" + def __init__(self, *args, **kargs): + DNSRRDS.__init__(self, *args, **kargs) + if not kargs.get('type', 0): + self.type = 32769 + +# RFC 5155 - DNS Security (DNSSEC) Hashed Authenticated Denial of Existence +class DNSRRNSEC3(_DNSRRdummy): + name = "DNS NSEC3 Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 50, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + ByteField("hashalg", 0), + BitEnumField("flags", 0, 8, {1:"Opt-Out"}), + ShortField("iterations", 0), + FieldLenField("saltlength", 0, fmt="!B", length_of="salt"), + StrLenField("salt", b"", length_from=lambda x: x.saltlength), + FieldLenField("hashlength", 0, fmt="!B", length_of="nexthashedownername"), + StrLenField("nexthashedownername", b"", length_from=lambda x: x.hashlength), + RRlistField("typebitmaps", b"") + ] + + +class DNSRRNSEC3PARAM(_DNSRRdummy): + name = "DNS NSEC3PARAM Resource Record" + fields_desc = [ DNSStrField("rrname",b""), + ShortEnumField("type", 51, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + ShortField("rdlen", None), + ByteField("hashalg", 0), + ByteField("flags", 0), + ShortField("iterations", 0), + FieldLenField("saltlength", 0, fmt="!B", length_of="salt"), + StrLenField("salt", b"", length_from=lambda pkt: pkt.saltlength) + ] + + +dnssecclasses = [ DNSRROPT, DNSRRRSIG, DNSRRDLV, DNSRRDNSKEY, DNSRRNSEC, DNSRRDS, DNSRRNSEC3, DNSRRNSEC3PARAM ] + +def isdnssecRR(obj): + list = [ isinstance (obj, cls) for cls in dnssecclasses ] + ret = False + for i in list: + ret = ret or i + return ret + +dnsRRdispatcher = { #6: DNSRRSOA, + 41: DNSRROPT, # RFC 1671 + 43: DNSRRDS, # RFC 4034 + 46: DNSRRRSIG, # RFC 4034 + 47: DNSRRNSEC, # RFC 4034 + 48: DNSRRDNSKEY, # RFC 4034 + 50: DNSRRNSEC3, # RFC 5155 + 51: DNSRRNSEC3PARAM, # RFC 5155 + 32769: DNSRRDLV # RFC 4431 + } + +class DNSRR(Packet): + name = "DNS Resource Record" + show_indent=0 + fields_desc = [ DNSStrField("rrname",""), + ShortEnumField("type", 1, dnstypes), + ShortEnumField("rclass", 1, dnsclasses), + IntField("ttl", 0), + RDLenField("rdlen"), + RDataField("rdata", "", length_from=lambda pkt:pkt.rdlen) ] + +bind_layers( UDP, DNS, dport=53) +bind_layers( UDP, DNS, sport=53) + + +@conf.commands.register +def dyndns_add(nameserver, name, rdata, type="A", ttl=10): + """Send a DNS add message to a nameserver for "name" to have a new "rdata" +dyndns_add(nameserver, name, rdata, type="A", ttl=10) -> result code (0=ok) + +example: dyndns_add("ns1.toto.com", "dyn.toto.com", "127.0.0.1") +RFC2136 +""" + zone = name[name.find(".")+1:] + r=sr1(IP(dst=nameserver)/UDP()/DNS(opcode=5, + qd=[DNSQR(qname=zone, qtype="SOA")], + ns=[DNSRR(rrname=name, type="A", + ttl=ttl, rdata=rdata)]), + verbose=0, timeout=5) + if r and r.haslayer(DNS): + return r.getlayer(DNS).rcode + else: + return -1 + + + + +@conf.commands.register +def dyndns_del(nameserver, name, type="ALL", ttl=10): + """Send a DNS delete message to a nameserver for "name" +dyndns_del(nameserver, name, type="ANY", ttl=10) -> result code (0=ok) + +example: dyndns_del("ns1.toto.com", "dyn.toto.com") +RFC2136 +""" + zone = name[name.find(".")+1:] + r=sr1(IP(dst=nameserver)/UDP()/DNS(opcode=5, + qd=[DNSQR(qname=zone, qtype="SOA")], + ns=[DNSRR(rrname=name, type=type, + rclass="ANY", ttl=0, rdata=b"")]), + verbose=0, timeout=5) + if r and r.haslayer(DNS): + return r.getlayer(DNS).rcode + else: + return -1 + + +class DNS_am(AnsweringMachine): + function_name="dns_spoof" + filter = "udp port 53" + + def parse_options(self, joker="192.168.1.1", match=None): + if match is None: + self.match = {} + else: + self.match = match + self.joker=joker + + def is_request(self, req): + return req.haslayer(DNS) and req.getlayer(DNS).qr == 0 + + def make_reply(self, req): + ip = req.getlayer(IP) + dns = req.getlayer(DNS) + resp = IP(dst=ip.src, src=ip.dst)/UDP(dport=ip.sport,sport=ip.dport) + rdata = self.match.get(dns.qd.qname, self.joker) + resp /= DNS(id=dns.id, qr=1, qd=dns.qd, + an=DNSRR(rrname=dns.qd.qname, ttl=10, rdata=rdata)) + return resp + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/dot11.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dot11.py new file mode 100644 index 00000000..417a470e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/dot11.py @@ -0,0 +1,560 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Wireless LAN according to IEEE 802.11. +""" + +import re,struct + +from scapy.packet import * +from scapy.fields import * +from scapy.plist import PacketList +from scapy.layers.l2 import * + + +try: + from Crypto.Cipher import ARC4 +except ImportError: + log_loading.info("Can't import python Crypto lib. Won't be able to decrypt WEP.") + + +### Fields + +class Dot11AddrMACField(MACField): + def is_applicable(self, pkt): + return 1 + def addfield(self, pkt, s, val): + if self.is_applicable(pkt): + return MACField.addfield(self, pkt, s, val) + else: + return s + def getfield(self, pkt, s): + if self.is_applicable(pkt): + return MACField.getfield(self, pkt, s) + else: + return s,None + +class Dot11Addr2MACField(Dot11AddrMACField): + def is_applicable(self, pkt): + if pkt.type == 1: + return pkt.subtype in [ 0xb, 0xa, 0xe, 0xf] # RTS, PS-Poll, CF-End, CF-End+CF-Ack + return 1 + +class Dot11Addr3MACField(Dot11AddrMACField): + def is_applicable(self, pkt): + if pkt.type in [0,2]: + return 1 + return 0 + +class Dot11Addr4MACField(Dot11AddrMACField): + def is_applicable(self, pkt): + if pkt.type == 2: + if pkt.FCfield & 0x3 == 0x3: # To-DS and From-DS are set + return 1 + return 0 + + +### Layers + + +class PrismHeader(Packet): + """ iwpriv wlan0 monitor 3 """ + name = "Prism header" + fields_desc = [ LEIntField("msgcode",68), + LEIntField("len",144), + StrFixedLenField("dev","",16), + LEIntField("hosttime_did",0), + LEShortField("hosttime_status",0), + LEShortField("hosttime_len",0), + LEIntField("hosttime",0), + LEIntField("mactime_did",0), + LEShortField("mactime_status",0), + LEShortField("mactime_len",0), + LEIntField("mactime",0), + LEIntField("channel_did",0), + LEShortField("channel_status",0), + LEShortField("channel_len",0), + LEIntField("channel",0), + LEIntField("rssi_did",0), + LEShortField("rssi_status",0), + LEShortField("rssi_len",0), + LEIntField("rssi",0), + LEIntField("sq_did",0), + LEShortField("sq_status",0), + LEShortField("sq_len",0), + LEIntField("sq",0), + LEIntField("signal_did",0), + LEShortField("signal_status",0), + LEShortField("signal_len",0), + LESignedIntField("signal",0), + LEIntField("noise_did",0), + LEShortField("noise_status",0), + LEShortField("noise_len",0), + LEIntField("noise",0), + LEIntField("rate_did",0), + LEShortField("rate_status",0), + LEShortField("rate_len",0), + LEIntField("rate",0), + LEIntField("istx_did",0), + LEShortField("istx_status",0), + LEShortField("istx_len",0), + LEIntField("istx",0), + LEIntField("frmlen_did",0), + LEShortField("frmlen_status",0), + LEShortField("frmlen_len",0), + LEIntField("frmlen",0), + ] + def answers(self, other): + if isinstance(other, PrismHeader): + return self.payload.answers(other.payload) + else: + return self.payload.answers(other) + +class RadioTap(Packet): + name = "RadioTap dummy" + fields_desc = [ ByteField('version', 0), + ByteField('pad', 0), + FieldLenField('len', None, 'notdecoded', '<H', adjust=lambda pkt,x:x+8), + FlagsField('present', None, -32, ['TSFT','Flags','Rate','Channel','FHSS','dBm_AntSignal', + 'dBm_AntNoise','Lock_Quality','TX_Attenuation','dB_TX_Attenuation', + 'dBm_TX_Power', 'Antenna', 'dB_AntSignal', 'dB_AntNoise', + 'b14', 'b15','b16','b17','b18','b19','b20','b21','b22','b23', + 'b24','b25','b26','b27','b28','b29','b30','Ext']), + StrLenField('notdecoded', "", length_from= lambda pkt:pkt.len-8) ] + +class PPI(Packet): + name = "Per-Packet Information header (partial)" + fields_desc = [ ByteField("version", 0), + ByteField("flags", 0), + FieldLenField("len", None, fmt="<H", length_of="fields", adjust=lambda pkt,x:x+8), + LEIntField("dlt", 0), + StrLenField("notdecoded", "", length_from = lambda pkt:pkt.len-8) + ] + + + +class Dot11SCField(LEShortField): + def is_applicable(self, pkt): + return pkt.type != 1 # control frame + def addfield(self, pkt, s, val): + if self.is_applicable(pkt): + return LEShortField.addfield(self, pkt, s, val) + else: + return s + def getfield(self, pkt, s): + if self.is_applicable(pkt): + return LEShortField.getfield(self, pkt, s) + else: + return s,None + +class Dot11(Packet): + name = "802.11" + fields_desc = [ + BitField("subtype", 0, 4), + BitEnumField("type", 0, 2, ["Management", "Control", "Data", "Reserved"]), + BitField("proto", 0, 2), + FlagsField("FCfield", 0, 8, ["to-DS", "from-DS", "MF", "retry", "pw-mgt", "MD", "wep", "order"]), + ShortField("ID",0), + MACField("addr1", ETHER_ANY), + Dot11Addr2MACField("addr2", ETHER_ANY), + Dot11Addr3MACField("addr3", ETHER_ANY), + Dot11SCField("SC", 0), + Dot11Addr4MACField("addr4", ETHER_ANY) + ] + def mysummary(self): + return self.sprintf("802.11 %Dot11.type% %Dot11.subtype% %Dot11.addr2% > %Dot11.addr1%") + def guess_payload_class(self, payload): + if self.type == 0x02 and (self.subtype >= 0x08 and self.subtype <=0xF and self.subtype != 0xD): + return Dot11QoS + elif self.FCfield & 0x40: + return Dot11WEP + else: + return Packet.guess_payload_class(self, payload) + def answers(self, other): + if isinstance(other,Dot11): + if self.type == 0: # management + if self.addr1.lower() != other.addr2.lower(): # check resp DA w/ req SA + return 0 + if (other.subtype,self.subtype) in [(0,1),(2,3),(4,5)]: + return 1 + if self.subtype == other.subtype == 11: # auth + return self.payload.answers(other.payload) + elif self.type == 1: # control + return 0 + elif self.type == 2: # data + return self.payload.answers(other.payload) + elif self.type == 3: # reserved + return 0 + return 0 + def unwep(self, key=None, warn=1): + if self.FCfield & 0x40 == 0: + if warn: + warning("No WEP to remove") + return + if isinstance(self.payload.payload, NoPayload): + if key or conf.wepkey: + self.payload.decrypt(key) + if isinstance(self.payload.payload, NoPayload): + if warn: + warning("Dot11 can't be decrypted. Check conf.wepkey.") + return + self.FCfield &= ~0x40 + self.payload=self.payload.payload + + +class Dot11QoS(Packet): + name = "802.11 QoS" + fields_desc = [ BitField("TID",None,4), + BitField("EOSP",None,1), + BitField("Ack Policy",None,2), + BitField("Reserved",None,1), + ByteField("TXOP",None) ] + def guess_payload_class(self, payload): + if isinstance(self.underlayer, Dot11): + if self.underlayer.FCfield & 0x40: + return Dot11WEP + return Packet.guess_payload_class(self, payload) + + +capability_list = [ "res8", "res9", "short-slot", "res11", + "res12", "DSSS-OFDM", "res14", "res15", + "ESS", "IBSS", "CFP", "CFP-req", + "privacy", "short-preamble", "PBCC", "agility"] + +reason_code = {0:"reserved",1:"unspec", 2:"auth-expired", + 3:"deauth-ST-leaving", + 4:"inactivity", 5:"AP-full", 6:"class2-from-nonauth", + 7:"class3-from-nonass", 8:"disas-ST-leaving", + 9:"ST-not-auth"} + +status_code = {0:"success", 1:"failure", 10:"cannot-support-all-cap", + 11:"inexist-asso", 12:"asso-denied", 13:"algo-unsupported", + 14:"bad-seq-num", 15:"challenge-failure", + 16:"timeout", 17:"AP-full",18:"rate-unsupported" } + +class Dot11Beacon(Packet): + name = "802.11 Beacon" + fields_desc = [ LELongField("timestamp", 0), + LEShortField("beacon_interval", 0x0064), + FlagsField("cap", 0, 16, capability_list) ] + + +class Dot11Elt(Packet): + name = "802.11 Information Element" + fields_desc = [ ByteEnumField("ID", 0, {0:"SSID", 1:"Rates", 2: "FHset", 3:"DSset", 4:"CFset", 5:"TIM", 6:"IBSSset", 16:"challenge", + 42:"ERPinfo", 46:"QoS Capability", 47:"ERPinfo", 48:"RSNinfo", 50:"ESRates",221:"vendor",68:"reserved"}), + FieldLenField("len", None, "info", "B"), + StrLenField("info", "", length_from=lambda x:x.len) ] + def mysummary(self): + if self.ID == 0: + return "SSID=%s"%repr(self.info),[Dot11] + else: + return "" + +class Dot11ATIM(Packet): + name = "802.11 ATIM" + +class Dot11Disas(Packet): + name = "802.11 Disassociation" + fields_desc = [ LEShortEnumField("reason", 1, reason_code) ] + +class Dot11AssoReq(Packet): + name = "802.11 Association Request" + fields_desc = [ FlagsField("cap", 0, 16, capability_list), + LEShortField("listen_interval", 0x00c8) ] + + +class Dot11AssoResp(Packet): + name = "802.11 Association Response" + fields_desc = [ FlagsField("cap", 0, 16, capability_list), + LEShortField("status", 0), + LEShortField("AID", 0) ] + +class Dot11ReassoReq(Packet): + name = "802.11 Reassociation Request" + fields_desc = [ FlagsField("cap", 0, 16, capability_list), + LEShortField("listen_interval", 0x00c8), + MACField("current_AP", ETHER_ANY) ] + + +class Dot11ReassoResp(Dot11AssoResp): + name = "802.11 Reassociation Response" + +class Dot11ProbeReq(Packet): + name = "802.11 Probe Request" + +class Dot11ProbeResp(Packet): + name = "802.11 Probe Response" + fields_desc = [ LELongField("timestamp", 0), + LEShortField("beacon_interval", 0x0064), + FlagsField("cap", 0, 16, capability_list) ] + +class Dot11Auth(Packet): + name = "802.11 Authentication" + fields_desc = [ LEShortEnumField("algo", 0, ["open", "sharedkey"]), + LEShortField("seqnum", 0), + LEShortEnumField("status", 0, status_code) ] + def answers(self, other): + if self.seqnum == other.seqnum+1: + return 1 + return 0 + +class Dot11Deauth(Packet): + name = "802.11 Deauthentication" + fields_desc = [ LEShortEnumField("reason", 1, reason_code) ] + + + +class Dot11WEP(Packet): + name = "802.11 WEP packet" + fields_desc = [ StrFixedLenField("iv", b"\0\0\0", 3), + ByteField("keyid", 0), + StrField("wepdata",None,remain=4), + IntField("icv",None) ] + + def post_dissect(self, s): +# self.icv, = struct.unpack("!I",self.wepdata[-4:]) +# self.wepdata = self.wepdata[:-4] + self.decrypt() + + def build_payload(self): + if self.wepdata is None: + return Packet.build_payload(self) + return b"" + + def post_build(self, p, pay): + if self.wepdata is None: + key = conf.wepkey + if key: + if self.icv is None: + pay += struct.pack("<I",crc32(pay)) + icv = b"" + else: + icv = p[4:8] + c = ARC4.new(self.iv+key) + p = p[:4]+c.encrypt(pay)+icv + else: + warning("No WEP key set (conf.wepkey).. strange results expected..") + return p + + + def decrypt(self,key=None): + if key is None: + key = conf.wepkey + if key: + c = ARC4.new(self.iv+key) + self.add_payload(LLC(c.decrypt(self.wepdata))) + + +bind_layers( PrismHeader, Dot11, ) +bind_layers( RadioTap, Dot11, ) +bind_layers( PPI, Dot11, dlt=105) +bind_layers( Dot11, LLC, type=2) +bind_layers( Dot11QoS, LLC, ) +bind_layers( Dot11, Dot11AssoReq, subtype=0, type=0) +bind_layers( Dot11, Dot11AssoResp, subtype=1, type=0) +bind_layers( Dot11, Dot11ReassoReq, subtype=2, type=0) +bind_layers( Dot11, Dot11ReassoResp, subtype=3, type=0) +bind_layers( Dot11, Dot11ProbeReq, subtype=4, type=0) +bind_layers( Dot11, Dot11ProbeResp, subtype=5, type=0) +bind_layers( Dot11, Dot11Beacon, subtype=8, type=0) +bind_layers( Dot11, Dot11ATIM, subtype=9, type=0) +bind_layers( Dot11, Dot11Disas, subtype=10, type=0) +bind_layers( Dot11, Dot11Auth, subtype=11, type=0) +bind_layers( Dot11, Dot11Deauth, subtype=12, type=0) +bind_layers( Dot11Beacon, Dot11Elt, ) +bind_layers( Dot11AssoReq, Dot11Elt, ) +bind_layers( Dot11AssoResp, Dot11Elt, ) +bind_layers( Dot11ReassoReq, Dot11Elt, ) +bind_layers( Dot11ReassoResp, Dot11Elt, ) +bind_layers( Dot11ProbeReq, Dot11Elt, ) +bind_layers( Dot11ProbeResp, Dot11Elt, ) +bind_layers( Dot11Auth, Dot11Elt, ) +bind_layers( Dot11Elt, Dot11Elt, ) + + +conf.l2types.register(105, Dot11) +conf.l2types.register_num2layer(801, Dot11) +conf.l2types.register(119, PrismHeader) +conf.l2types.register_num2layer(802, PrismHeader) +conf.l2types.register(127, RadioTap) +conf.l2types.register(0xc0, PPI) +conf.l2types.register_num2layer(803, RadioTap) + + +class WiFi_am(AnsweringMachine): + """Before using this, initialize "iffrom" and "ifto" interfaces: +iwconfig iffrom mode monitor +iwpriv orig_ifto hostapd 1 +ifconfig ifto up +note: if ifto=wlan0ap then orig_ifto=wlan0 +note: ifto and iffrom must be set on the same channel +ex: +ifconfig eth1 up +iwconfig eth1 mode monitor +iwconfig eth1 channel 11 +iwpriv wlan0 hostapd 1 +ifconfig wlan0ap up +iwconfig wlan0 channel 11 +iwconfig wlan0 essid dontexist +iwconfig wlan0 mode managed +""" + function_name = "airpwn" + filter = None + + def parse_options(self, iffrom, ifto, replace, pattern="", ignorepattern=""): + self.iffrom = iffrom + self.ifto = ifto + ptrn = re.compile(pattern) + iptrn = re.compile(ignorepattern) + + def is_request(self, pkt): + if not isinstance(pkt,Dot11): + return 0 + if not pkt.FCfield & 1: + return 0 + if not pkt.haslayer(TCP): + return 0 + ip = pkt.getlayer(IP) + tcp = pkt.getlayer(TCP) + pay = str(tcp.payload) + if not self.ptrn.match(pay): + return 0 + if self.iptrn.match(pay): + return 0 + + def make_reply(self, p): + ip = p.getlayer(IP) + tcp = p.getlayer(TCP) + pay = str(tcp.payload) + del(p.payload.payload.payload) + p.FCfield="from-DS" + p.addr1,p.addr2 = p.addr2,p.addr1 + p /= IP(src=ip.dst,dst=ip.src) + p /= TCP(sport=tcp.dport, dport=tcp.sport, + seq=tcp.ack, ack=tcp.seq+len(pay), + flags="PA") + q = p.copy() + p /= self.replace + q.ID += 1 + q.getlayer(TCP).flags="RA" + q.getlayer(TCP).seq+=len(replace) + return [p,q] + + def print_reply(self): + print(p.sprintf("Sent %IP.src%:%IP.sport% > %IP.dst%:%TCP.dport%")) + + def send_reply(self, reply): + sendp(reply, iface=self.ifto, **self.optsend) + + def sniff(self): + sniff(iface=self.iffrom, **self.optsniff) + + + +plst=[] +def get_toDS(): + global plst + while 1: + p,=sniff(iface="eth1",count=1) + if not isinstance(p,Dot11): + continue + if p.FCfield & 1: + plst.append(p) + print(".") + + +# if not ifto.endswith("ap"): +# print("iwpriv %s hostapd 1" % ifto) +# os.system("iwpriv %s hostapd 1" % ifto) +# ifto += "ap" +# +# os.system("iwconfig %s mode monitor" % iffrom) +# + +def airpwn(iffrom, ifto, replace, pattern="", ignorepattern=""): + """Before using this, initialize "iffrom" and "ifto" interfaces: +iwconfig iffrom mode monitor +iwpriv orig_ifto hostapd 1 +ifconfig ifto up +note: if ifto=wlan0ap then orig_ifto=wlan0 +note: ifto and iffrom must be set on the same channel +ex: +ifconfig eth1 up +iwconfig eth1 mode monitor +iwconfig eth1 channel 11 +iwpriv wlan0 hostapd 1 +ifconfig wlan0ap up +iwconfig wlan0 channel 11 +iwconfig wlan0 essid dontexist +iwconfig wlan0 mode managed +""" + + ptrn = re.compile(pattern) + iptrn = re.compile(ignorepattern) + def do_airpwn(p, ifto=ifto, replace=replace, ptrn=ptrn, iptrn=iptrn): + if not isinstance(p,Dot11): + return + if not p.FCfield & 1: + return + if not p.haslayer(TCP): + return + ip = p.getlayer(IP) + tcp = p.getlayer(TCP) + pay = str(tcp.payload) +# print "got tcp" + if not ptrn.match(pay): + return +# print "match 1" + if iptrn.match(pay): + return +# print "match 2" + del(p.payload.payload.payload) + p.FCfield="from-DS" + p.addr1,p.addr2 = p.addr2,p.addr1 + q = p.copy() + p /= IP(src=ip.dst,dst=ip.src) + p /= TCP(sport=tcp.dport, dport=tcp.sport, + seq=tcp.ack, ack=tcp.seq+len(pay), + flags="PA") + q = p.copy() + p /= replace + q.ID += 1 + q.getlayer(TCP).flags="RA" + q.getlayer(TCP).seq+=len(replace) + + sendp([p,q], iface=ifto, verbose=0) +# print "send",repr(p) +# print "send",repr(q) + print(p.sprintf("Sent %IP.src%:%IP.sport% > %IP.dst%:%TCP.dport%")) + + sniff(iface=iffrom,prn=do_airpwn) + + + +conf.stats_dot11_protocols += [Dot11WEP, Dot11Beacon, ] + + + + + +class Dot11PacketList(PacketList): + def __init__(self, res=None, name="Dot11List", stats=None): + if stats is None: + stats = conf.stats_dot11_protocols + + PacketList.__init__(self, res, name, stats) + def toEthernet(self): + #data = map(lambda x:x.getlayer(Dot11), filter(lambda x : x.haslayer(Dot11) and x.type == 2, self.res)) + data = [ x.getlayer(Dot11) for x in self.res if x.haslayer(Dot11) and x.type == 2 ] + r2 = [] + for p in data: + q = p.copy() + q.unwep() + r2.append(Ether()/q.payload.payload.payload) #Dot11/LLC/SNAP/IP + return PacketList(r2,name="Ether from %s"%self.listname) + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/gprs.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/gprs.py new file mode 100644 index 00000000..31a931fe --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/gprs.py @@ -0,0 +1,21 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +GPRS (General Packet Radio Service) for mobile data communication. +""" + +from scapy.fields import * +from scapy.packet import * +from scapy.layers.inet import IP + +class GPRS(Packet): + name = "GPRSdummy" + fields_desc = [ + StrStopField("dummy","","\x65\x00\x00",1) + ] + + +bind_layers( GPRS, IP, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/hsrp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/hsrp.py new file mode 100644 index 00000000..7193b97e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/hsrp.py @@ -0,0 +1,79 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +############################################################################# +## ## +## hsrp.py --- HSRP protocol support for Scapy ## +## ## +## Copyright (C) 2010 Mathieu RENARD mathieu.renard(at)gmail.com ## +## ## +## This program is free software; you can redistribute it and/or modify it ## +## under the terms of the GNU General Public License version 2 as ## +## published by the Free Software Foundation; version 2. ## +## ## +## This program is distributed in the hope that it will be useful, but ## +## WITHOUT ANY WARRANTY; without even the implied warranty of ## +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ## +## General Public License for more details. ## +## ## +############################################################################# +## HSRP Version 1 +## Ref. RFC 2281 +## HSRP Version 2 +## Ref. http://www.smartnetworks.jp/2006/02/hsrp_8_hsrp_version_2.html +## +## $Log: hsrp.py,v $ +## Revision 0.2 2011/05/01 15:23:34 mrenard +## Cleanup code + +""" +HSRP (Hot Standby Router Protocol): proprietary redundancy protocol for Cisco routers. +""" + +from scapy.fields import * +from scapy.packet import * +from scapy.layers.inet import UDP + + +class HSRP(Packet): + name = "HSRP" + fields_desc = [ + ByteField("version", 0), + ByteEnumField("opcode", 0, {0: "Hello", 1: "Coup", 2: "Resign", 3: "Advertise"}), + ByteEnumField("state", 16, {0: "Initial", 1: "Learn", 2: "Listen", 4: "Speak", 8: "Standby", 16: "Active"}), + ByteField("hellotime", 3), + ByteField("holdtime", 10), + ByteField("priority", 120), + ByteField("group", 1), + ByteField("reserved", 0), + StrFixedLenField("auth", "cisco" + "\00" * 3, 8), + IPField("virtualIP", "192.168.1.1")] + + def guess_payload_class(self, payload): + if self.underlayer.len > 28: + return HSRPmd5 + else: + return Packet.guess_payload_class(self, payload) + + +class HSRPmd5(Packet): + name = "HSRP MD5 Authentication" + fields_desc = [ + ByteEnumField("type", 4, {4: "MD5 authentication"}), + ByteField("len", None), + ByteEnumField("algo", 0, {1: "MD5"}), + ByteField("padding", 0x00), + XShortField("flags", 0x00), + IPField("sourceip", None), + XIntField("keyid", 0x00), + StrFixedLenField("authdigest", "\00" * 16, 16)] + + def post_build(self, p, pay): + if self.len is None and pay: + l = len(pay) + p = p[:1] + hex(l)[30:] + p[30:] + return p + +bind_layers(UDP, HSRP, dport=1985, sport=1985) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/inet.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/inet.py new file mode 100644 index 00000000..04b99e89 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/inet.py @@ -0,0 +1,1569 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +IPv4 (Internet Protocol v4). +""" + +import os,time,struct,re,socket,types +from select import select +from collections import defaultdict +from scapy.utils import checksum +from scapy.layers.l2 import * +from scapy.config import conf +from scapy.fields import * +from scapy.packet import * +from scapy.volatile import * +from scapy.sendrecv import sr,sr1,srp1 +from scapy.plist import PacketList,SndRcvList +from scapy.automaton import Automaton,ATMT + +import scapy.as_resolvers + + +#################### +## IP Tools class ## +#################### + +class IPTools: + """Add more powers to a class that have a "src" attribute.""" + def whois(self): + os.system("whois %s" % self.src) + def ottl(self): + t = [32,64,128,255]+[self.ttl] + t.sort() + return t[t.index(self.ttl)+1] + def hops(self): + return self.ottl()-self.ttl-1 + + +_ip_options_names = { 0: "end_of_list", + 1: "nop", + 2: "security", + 3: "loose_source_route", + 4: "timestamp", + 5: "extended_security", + 6: "commercial_security", + 7: "record_route", + 8: "stream_id", + 9: "strict_source_route", + 10: "experimental_measurement", + 11: "mtu_probe", + 12: "mtu_reply", + 13: "flow_control", + 14: "access_control", + 15: "encode", + 16: "imi_traffic_descriptor", + 17: "extended_IP", + 18: "traceroute", + 19: "address_extension", + 20: "router_alert", + 21: "selective_directed_broadcast_mode", + 23: "dynamic_packet_state", + 24: "upstream_multicast_packet", + 25: "quick_start", + 30: "rfc4727_experiment", + } + + +class _IPOption_HDR(Packet): + fields_desc = [ BitField("copy_flag",0, 1), + BitEnumField("optclass",0,2,{0:"control",2:"debug"}), + BitEnumField("option",0,5, _ip_options_names) ] + +class IPOption(Packet): + name = "IP Option" + fields_desc = [ _IPOption_HDR, + FieldLenField("length", None, fmt="B", # Only option 0 and 1 have no length and value + length_of="value", adjust=lambda pkt,l:l+2), + StrLenField("value", "",length_from=lambda pkt:pkt.length-2) ] + + def extract_padding(self, p): + return b"",p + + registered_ip_options = {} + @classmethod + def register_variant(cls): + cls.registered_ip_options[cls.option.default] = cls + @classmethod + def dispatch_hook(cls, pkt=None, *args, **kargs): + if pkt: + opt = pkt[0]&0x1f + if opt in cls.registered_ip_options: + return cls.registered_ip_options[opt] + return cls + +class IPOption_EOL(IPOption): + name = "IP Option End of Options List" + option = 0 + fields_desc = [ _IPOption_HDR ] + + +class IPOption_NOP(IPOption): + name = "IP Option No Operation" + option=1 + fields_desc = [ _IPOption_HDR ] + +class IPOption_Security(IPOption): + name = "IP Option Security" + copy_flag = 1 + option = 2 + fields_desc = [ _IPOption_HDR, + ByteField("length", 11), + ShortField("security",0), + ShortField("compartment",0), + ShortField("handling_restrictions",0), + StrFixedLenField("transmission_control_code","xxx",3), + ] + +class IPOption_LSRR(IPOption): + name = "IP Option Loose Source and Record Route" + copy_flag = 1 + option = 3 + fields_desc = [ _IPOption_HDR, + FieldLenField("length", None, fmt="B", + length_of="routers", adjust=lambda pkt,l:l+3), + ByteField("pointer",4), # 4 is first IP + FieldListField("routers",[],IPField("","0.0.0.0"), + length_from=lambda pkt:pkt.length-3) + ] + def get_current_router(self): + return self.routers[self.pointer//4-1] + +class IPOption_RR(IPOption_LSRR): + name = "IP Option Record Route" + option = 7 + +class IPOption_SSRR(IPOption_LSRR): + name = "IP Option Strict Source and Record Route" + option = 9 + +class IPOption_Stream_Id(IPOption): + name = "IP Option Stream ID" + option = 8 + fields_desc = [ _IPOption_HDR, + ByteField("length", 4), + ShortField("security",0), ] + +class IPOption_MTU_Probe(IPOption): + name = "IP Option MTU Probe" + option = 11 + fields_desc = [ _IPOption_HDR, + ByteField("length", 4), + ShortField("mtu",0), ] + +class IPOption_MTU_Reply(IPOption_MTU_Probe): + name = "IP Option MTU Reply" + option = 12 + +class IPOption_Traceroute(IPOption): + name = "IP Option Traceroute" + copy_flag = 1 + option = 18 + fields_desc = [ _IPOption_HDR, + ByteField("length", 12), + ShortField("id",0), + ShortField("outbound_hops",0), + ShortField("return_hops",0), + IPField("originator_ip","0.0.0.0") ] + +class IPOption_Address_Extension(IPOption): + name = "IP Option Address Extension" + copy_flag = 1 + option = 19 + fields_desc = [ _IPOption_HDR, + ByteField("length", 10), + IPField("src_ext","0.0.0.0"), + IPField("dst_ext","0.0.0.0") ] + +class IPOption_Router_Alert(IPOption): + name = "IP Option Router Alert" + copy_flag = 1 + option = 20 + fields_desc = [ _IPOption_HDR, + ByteField("length", 4), + ShortEnumField("alert",0, {0:"router_shall_examine_packet"}), ] + + +class IPOption_SDBM(IPOption): + name = "IP Option Selective Directed Broadcast Mode" + copy_flag = 1 + option = 21 + fields_desc = [ _IPOption_HDR, + FieldLenField("length", None, fmt="B", + length_of="addresses", adjust=lambda pkt,l:l+2), + FieldListField("addresses",[],IPField("","0.0.0.0"), + length_from=lambda pkt:pkt.length-2) + ] + + + +TCPOptions = ( + { 0 : ("EOL",None), + 1 : ("NOP",None), + 2 : ("MSS","!H"), + 3 : ("WScale","!B"), + 4 : ("SAckOK",None), + 5 : ("SAck","!"), + 8 : ("Timestamp","!II"), + 14 : ("AltChkSum","!BH"), + 15 : ("AltChkSumOpt",None), + 25 : ("Mood","!p") + }, + { "EOL":0, + "NOP":1, + "MSS":2, + "WScale":3, + "SAckOK":4, + "SAck":5, + "Timestamp":8, + "AltChkSum":14, + "AltChkSumOpt":15, + "Mood":25 + } ) + +class TCPOptionsField(StrField): + islist=1 + def getfield(self, pkt, s): + opsz = (pkt.dataofs-5)*4 + if opsz < 0: + warning("bad dataofs (%i). Assuming dataofs=5"%pkt.dataofs) + opsz = 0 + return s[opsz:],self.m2i(pkt,s[:opsz]) + def m2i(self, pkt, x): + opt = [] + while x: + onum = x[0] + if onum == 0: + opt.append(("EOL",None)) + x=x[1:] + break + if onum == 1: + opt.append(("NOP",None)) + x=x[1:] + continue + olen = x[1] + if olen < 2: + warning("Malformed TCP option (announced length is %i)" % olen) + olen = 2 + oval = x[2:olen] + if onum in TCPOptions[0]: + oname, ofmt = TCPOptions[0][onum] + if onum == 5: #SAck + ofmt += "%iI" % (len(oval)//4) + if ofmt and struct.calcsize(ofmt) == len(oval): + oval = struct.unpack(ofmt, oval) + if len(oval) == 1: + oval = oval[0] + opt.append((oname, oval)) + else: + opt.append((onum, oval)) + x = x[olen:] + return opt + + def i2m(self, pkt, x): + opt = b"" + for oname,oval in x: + if type(oname) is str: + if oname == "NOP": + opt += b"\x01" + continue + elif oname == "EOL": + opt += b"\x00" + continue + elif oname in TCPOptions[1]: + onum = TCPOptions[1][oname] + ofmt = TCPOptions[0][onum][1] + if onum == 5: #SAck + ofmt += b"%iI" % len(oval) + if ofmt is not None and (type(oval) is not str or "s" in ofmt): + if type(oval) is not tuple: + oval = (oval,) + oval = struct.pack(ofmt, *oval) + else: + warning("option [%s] unknown. Skipped."%oname) + continue + else: + onum = oname + if type(oval) is not str: + warning("option [%i] is not string."%onum) + continue + opt += bytes([(onum), (2+len(oval))]) + oval + return opt+b"\x00"*(3-((len(opt)+3)%4)) + def randval(self): + return [] # XXX + + +class ICMPTimeStampField(IntField): + re_hmsm = re.compile("([0-2]?[0-9])[Hh:](([0-5]?[0-9])([Mm:]([0-5]?[0-9])([sS:.]([0-9]{0,3}))?)?)?$") + def i2repr(self, pkt, val): + if val is None: + return "--" + else: + sec, milli = divmod(val, 1000) + min, sec = divmod(sec, 60) + hour, min = divmod(min, 60) + return "%d:%d:%d.%d" %(hour, min, sec, int(milli)) + def any2i(self, pkt, val): + if type(val) is str: + hmsms = self.re_hmsm.match(val) + if hmsms: + h,_,m,_,s,_,ms = hmsms = hmsms.groups() + ms = int(((ms or "")+"000")[:3]) + val = ((int(h)*60+int(m or 0))*60+int(s or 0))*1000+ms + else: + val = 0 + elif val is None: + val = int((time.time()%(24*60*60))*1000) + return val + + +class IP(Packet, IPTools): + name = "IP" + fields_desc = [ BitField("version" , 4 , 4), + BitField("ihl", None, 4), + XByteField("tos", 0), + ShortField("len", None), + ShortField("id", 1), + FlagsField("flags", 0, 3, ["MF","DF","evil"]), + BitField("frag", 0, 13), + ByteField("ttl", 64), + ByteEnumField("proto", 0, IP_PROTOS), + XShortField("chksum", None), + #IPField("src", "127.0.0.1"), + #Emph(SourceIPField("src","dst")), + #Emph(IPField("dst", "127.0.0.1")), + + Emph(IPField("src", "16.0.0.1")), + Emph(IPField("dst", "48.0.0.1")), + PacketListField("options", [], IPOption, length_from=lambda p:p.ihl*4-20) ] + def post_build(self, p, pay): + ihl = self.ihl + p += b"\0"*((-len(p))%4) # pad IP options if needed + if ihl is None: + ihl = len(p)//4 + p = bytes([((self.version&0xf)<<4) | ihl&0x0f])+p[1:] + if self.len is None: + l = len(p)+len(pay) + p = p[:2]+struct.pack("!H", l)+p[4:] + if self.chksum is None: + ck = checksum(p) + p = p[:10]+bytes([ck>>8])+bytes([ck&0xff])+p[12:] + return p+pay + + def extract_padding(self, s): + l = self.len - (self.ihl << 2) + return s[:l],s[l:] + + def send(self, s, slp=0): + for p in self: + try: + s.sendto(bytes(p), (p.dst,0)) + except socket.error as msg: + log_runtime.error(msg) + if slp: + time.sleep(slp) + def route(self): + dst = self.dst + if isinstance(dst,Gen): + dst = next(iter(dst)) + return conf.route.route(dst) + def hashret(self): + if ( (self.proto == socket.IPPROTO_ICMP) + and (isinstance(self.payload, ICMP)) + and (self.payload.type in [3,4,5,11,12]) ): + return self.payload.payload.hashret() + else: + if conf.checkIPsrc and conf.checkIPaddr: + return strxor(inet_aton(self.src),inet_aton(self.dst))+struct.pack("B",self.proto)+self.payload.hashret() + else: + return struct.pack("B", self.proto)+self.payload.hashret() + def answers(self, other): + if not isinstance(other,IP): + return 0 + if conf.checkIPaddr and (self.dst != other.src): + return 0 + if ( (self.proto == socket.IPPROTO_ICMP) and + (isinstance(self.payload, ICMP)) and + (self.payload.type in [3,4,5,11,12]) ): + # ICMP error message + return self.payload.payload.answers(other) + + else: + if ( (conf.checkIPaddr and (self.src != other.dst)) or + (self.proto != other.proto) ): + return 0 + return self.payload.answers(other.payload) + def mysummary(self): + s = self.sprintf("%IP.src% > %IP.dst% %IP.proto%") + if self.frag: + s += " frag:%i" % self.frag + return s + + def fragment(self, fragsize=1480): + """Fragment IP datagrams""" + fragsize = (fragsize+7)//8*8 + lst = [] + fnb = 0 + fl = self + while fl.underlayer is not None: + fnb += 1 + fl = fl.underlayer + + for p in fl: + s = bytes(p[fnb].payload) + nb = (len(s)+fragsize-1)//fragsize + for i in range(nb): + q = p.copy() + del(q[fnb].payload) + del(q[fnb].chksum) + del(q[fnb].len) + if i == nb-1: + q[IP].flags &= ~1 + else: + q[IP].flags |= 1 + q[IP].frag = i*fragsize//8 + r = conf.raw_layer(load=s[i*fragsize:(i+1)*fragsize]) + r.overload_fields = p[IP].payload.overload_fields.copy() + q.add_payload(r) + lst.append(q) + return lst + + +class TCP(Packet): + name = "TCP" + fields_desc = [ ShortEnumField("sport", 20, TCP_SERVICES), + ShortEnumField("dport", 80, TCP_SERVICES), + IntField("seq", 0), + IntField("ack", 0), + BitField("dataofs", None, 4), + BitField("reserved", 0, 4), + FlagsField("flags", 0x2, 8, "FSRPAUEC"), + ShortField("window", 8192), + XShortField("chksum", None), + ShortField("urgptr", 0), + TCPOptionsField("options", {}) ] + def post_build(self, p, pay): + p += pay + dataofs = self.dataofs + if dataofs is None: + dataofs = 5+((len(self.get_field("options").i2m(self,self.options))+3)//4) + p = p[:12]+bytes([(dataofs << 4) | (p[12])&0x0f])+p[13:] + if self.chksum is None: + if isinstance(self.underlayer, IP): + if self.underlayer.len is not None: + ln = self.underlayer.len-20 + else: + ln = len(p) + psdhdr = struct.pack("!4s4sHH", + inet_aton(self.underlayer.src), + inet_aton(self.underlayer.dst), + self.underlayer.proto, + ln) + ck=checksum(psdhdr+p) + p = p[:16]+struct.pack("!H", ck)+p[18:] + elif conf.ipv6_enabled and isinstance(self.underlayer, scapy.layers.inet6.IPv6) or isinstance(self.underlayer, scapy.layers.inet6._IPv6ExtHdr): + ck = scapy.layers.inet6.in6_chksum(socket.IPPROTO_TCP, self.underlayer, p) + p = p[:16]+struct.pack("!H", ck)+p[18:] + else: + warning("No IP underlayer to compute checksum. Leaving null.") + return p + def hashret(self): + if conf.checkIPsrc: + return struct.pack("H",self.sport ^ self.dport)+self.payload.hashret() + else: + return self.payload.hashret() + def answers(self, other): + if not isinstance(other, TCP): + return 0 + if conf.checkIPsrc: + if not ((self.sport == other.dport) and + (self.dport == other.sport)): + return 0 + if (abs(other.seq-self.ack) > 2+len(other.payload)): + return 0 + return 1 + def mysummary(self): + if isinstance(self.underlayer, IP): + return self.underlayer.sprintf("TCP %IP.src%:%TCP.sport% > %IP.dst%:%TCP.dport% %TCP.flags%") + elif conf.ipv6_enabled and isinstance(self.underlayer, scapy.layers.inet6.IPv6): + return self.underlayer.sprintf("TCP %IPv6.src%:%TCP.sport% > %IPv6.dst%:%TCP.dport% %TCP.flags%") + else: + return self.sprintf("TCP %TCP.sport% > %TCP.dport% %TCP.flags%") + +class UDP(Packet): + name = "UDP" + fields_desc = [ ShortEnumField("sport", 53, UDP_SERVICES), + ShortEnumField("dport", 53, UDP_SERVICES), + ShortField("len", None), + XShortField("chksum", None), ] + def post_build(self, p, pay): + p += pay + l = self.len + if l is None: + l = len(p) + p = p[:4]+struct.pack("!H",l)+p[6:] + if self.chksum is None: + if isinstance(self.underlayer, IP): + if self.underlayer.len is not None: + ln = self.underlayer.len-20 + else: + ln = len(p) + psdhdr = struct.pack("!4s4sHH", + inet_aton(self.underlayer.src), + inet_aton(self.underlayer.dst), + self.underlayer.proto, + ln) + ck=checksum(psdhdr+p) + p = p[:6]+struct.pack("!H", ck)+p[8:] + elif isinstance(self.underlayer, scapy.layers.inet6.IPv6) or isinstance(self.underlayer, scapy.layers.inet6._IPv6ExtHdr): + ck = scapy.layers.inet6.in6_chksum(socket.IPPROTO_UDP, self.underlayer, p) + p = p[:6]+struct.pack("!H", ck)+p[8:] + else: + warning("No IP underlayer to compute checksum. Leaving null.") + return p + def extract_padding(self, s): + l = self.len - 8 + return s[:l],s[l:] + def hashret(self): + return self.payload.hashret() + def answers(self, other): + if not isinstance(other, UDP): + return 0 + if conf.checkIPsrc: + if self.dport != other.sport: + return 0 + return self.payload.answers(other.payload) + def mysummary(self): + if isinstance(self.underlayer, IP): + return self.underlayer.sprintf("UDP %IP.src%:%UDP.sport% > %IP.dst%:%UDP.dport%") + elif isinstance(self.underlayer, scapy.layers.inet6.IPv6): + return self.underlayer.sprintf("UDP %IPv6.src%:%UDP.sport% > %IPv6.dst%:%UDP.dport%") + else: + return self.sprintf("UDP %UDP.sport% > %UDP.dport%") + +icmptypes = { 0 : "echo-reply", + 3 : "dest-unreach", + 4 : "source-quench", + 5 : "redirect", + 8 : "echo-request", + 9 : "router-advertisement", + 10 : "router-solicitation", + 11 : "time-exceeded", + 12 : "parameter-problem", + 13 : "timestamp-request", + 14 : "timestamp-reply", + 15 : "information-request", + 16 : "information-response", + 17 : "address-mask-request", + 18 : "address-mask-reply" } + +icmpcodes = { 3 : { 0 : "network-unreachable", + 1 : "host-unreachable", + 2 : "protocol-unreachable", + 3 : "port-unreachable", + 4 : "fragmentation-needed", + 5 : "source-route-failed", + 6 : "network-unknown", + 7 : "host-unknown", + 9 : "network-prohibited", + 10 : "host-prohibited", + 11 : "TOS-network-unreachable", + 12 : "TOS-host-unreachable", + 13 : "communication-prohibited", + 14 : "host-precedence-violation", + 15 : "precedence-cutoff", }, + 5 : { 0 : "network-redirect", + 1 : "host-redirect", + 2 : "TOS-network-redirect", + 3 : "TOS-host-redirect", }, + 11 : { 0 : "ttl-zero-during-transit", + 1 : "ttl-zero-during-reassembly", }, + 12 : { 0 : "ip-header-bad", + 1 : "required-option-missing", }, } + + + + +class ICMP(Packet): + name = "ICMP" + fields_desc = [ ByteEnumField("type",8, icmptypes), + MultiEnumField("code",0, icmpcodes, depends_on=lambda pkt:pkt.type,fmt="B"), + XShortField("chksum", None), + ConditionalField(XShortField("id",0), lambda pkt:pkt.type in [0,8,13,14,15,16,17,18]), + ConditionalField(XShortField("seq",0), lambda pkt:pkt.type in [0,8,13,14,15,16,17,18]), + ConditionalField(ICMPTimeStampField("ts_ori", None), lambda pkt:pkt.type in [13,14]), + ConditionalField(ICMPTimeStampField("ts_rx", None), lambda pkt:pkt.type in [13,14]), + ConditionalField(ICMPTimeStampField("ts_tx", None), lambda pkt:pkt.type in [13,14]), + ConditionalField(IPField("gw","0.0.0.0"), lambda pkt:pkt.type==5), + ConditionalField(ByteField("ptr",0), lambda pkt:pkt.type==12), + ConditionalField(X3BytesField("reserved",0), lambda pkt:pkt.type==12), + ConditionalField(IPField("addr_mask","0.0.0.0"), lambda pkt:pkt.type in [17,18]), + ConditionalField(IntField("unused",0), lambda pkt:pkt.type not in [0,5,8,12,13,14,15,16,17,18]), + + ] + def post_build(self, p, pay): + p += pay + if self.chksum is None: + ck = checksum(p) + p = p[:2]+bytes([ck>>8, ck&0xff])+p[4:] + return p + + def hashret(self): + if self.type in [0,8,13,14,15,16,17,18]: + return struct.pack("HH",self.id,self.seq)+self.payload.hashret() + return self.payload.hashret() + def answers(self, other): + if not isinstance(other,ICMP): + return 0 + if ( (other.type,self.type) in [(8,0),(13,14),(15,16),(17,18)] and + self.id == other.id and + self.seq == other.seq ): + return 1 + return 0 + + def guess_payload_class(self, payload): + if self.type in [3,4,5,11,12]: + return IPerror + else: + return None + def mysummary(self): + if isinstance(self.underlayer, IP): + return self.underlayer.sprintf("ICMP %IP.src% > %IP.dst% %ICMP.type% %ICMP.code%") + else: + return self.sprintf("ICMP %ICMP.type% %ICMP.code%") + + + + + +class IPerror(IP): + name = "IP in ICMP" + def answers(self, other): + if not isinstance(other, IP): + return 0 + if not ( ((conf.checkIPsrc == 0) or (self.dst == other.dst)) and + (self.src == other.src) and + ( ((conf.checkIPID == 0) + or (self.id == other.id) + or (conf.checkIPID == 1 and self.id == socket.htons(other.id)))) and + (self.proto == other.proto) ): + return 0 + return self.payload.answers(other.payload) + def mysummary(self): + return Packet.mysummary(self) + + +class TCPerror(TCP): + fields_desc = [ ShortEnumField("sport", 20, TCP_SERVICES), + ShortEnumField("dport", 80, TCP_SERVICES), + IntField("seq", 0) ] + name = "TCP in ICMP" + def post_build(self, p, pay): + p += pay + return p + def answers(self, other): + if not isinstance(other, TCP): + return 0 + if conf.checkIPsrc: + if not ((self.sport == other.sport) and + (self.dport == other.dport)): + return 0 + if conf.check_TCPerror_seqack: + if self.seq is not None: + if self.seq != other.seq: + return 0 + if self.ack is not None: + if self.ack != other.ack: + return 0 + return 1 + def mysummary(self): + return Packet.mysummary(self) + + +class UDPerror(UDP): + name = "UDP in ICMP" + def answers(self, other): + if not isinstance(other, UDP): + return 0 + if conf.checkIPsrc: + if not ((self.sport == other.sport) and + (self.dport == other.dport)): + return 0 + return 1 + def mysummary(self): + return Packet.mysummary(self) + + + +class ICMPerror(ICMP): + name = "ICMP in ICMP" + def answers(self, other): + if not isinstance(other,ICMP): + return 0 + if not ((self.type == other.type) and + (self.code == other.code)): + return 0 + if self.code in [0,8,13,14,17,18]: + if (self.id == other.id and + self.seq == other.seq): + return 1 + else: + return 0 + else: + return 1 + def mysummary(self): + return Packet.mysummary(self) + +bind_layers( Ether, IP, type=2048) +bind_layers( CookedLinux, IP, proto=2048) +bind_layers( GRE, IP, proto=2048) +bind_layers( SNAP, IP, code=2048) +bind_layers( IPerror, IPerror, frag=0, proto=4) +bind_layers( IPerror, ICMPerror, frag=0, proto=1) +bind_layers( IPerror, TCPerror, frag=0, proto=6) +bind_layers( IPerror, UDPerror, frag=0, proto=17) +bind_layers( IP, IP, frag=0, proto=4) +bind_layers( IP, ICMP, frag=0, proto=1) +bind_layers( IP, TCP, frag=0, proto=6) +bind_layers( IP, UDP, frag=0, proto=17) +bind_layers( IP, GRE, frag=0, proto=47) + +conf.l2types.register(101, IP) +conf.l2types.register_num2layer(12, IP) + +conf.l3types.register(ETH_P_IP, IP) +conf.l3types.register_num2layer(ETH_P_ALL, IP) + + +conf.neighbor.register_l3(Ether, IP, lambda l2,l3: getmacbyip(l3.dst)) +conf.neighbor.register_l3(Dot3, IP, lambda l2,l3: getmacbyip(l3.dst)) + + +################### +## Fragmentation ## +################### + +@conf.commands.register +def fragment(pkt, fragsize=1480): + """Fragment a big IP datagram""" + fragsize = (fragsize+7)//8*8 + lst = [] + for p in pkt: + s = bytes(p[IP].payload) + nb = (len(s)+fragsize-1)//fragsize + for i in range(nb): + q = p.copy() + del(q[IP].payload) + del(q[IP].chksum) + del(q[IP].len) + if i == nb-1: + q[IP].flags &= ~1 + else: + q[IP].flags |= 1 + q[IP].frag = i*fragsize//8 + r = conf.raw_layer(load=s[i*fragsize:(i+1)*fragsize]) + r.overload_fields = p[IP].payload.overload_fields.copy() + q.add_payload(r) + lst.append(q) + return lst + +def overlap_frag(p, overlap, fragsize=8, overlap_fragsize=None): + if overlap_fragsize is None: + overlap_fragsize = fragsize + q = p.copy() + del(q[IP].payload) + q[IP].add_payload(overlap) + + qfrag = fragment(q, overlap_fragsize) + qfrag[-1][IP].flags |= 1 + return qfrag+fragment(p, fragsize) + +@conf.commands.register +def defrag(plist): + """defrag(plist) -> ([not fragmented], [defragmented], + [ [bad fragments], [bad fragments], ... ])""" + frags = defaultdict(PacketList) + nofrag = PacketList() + for p in plist: + ip = p[IP] + if IP not in p: + nofrag.append(p) + continue + if ip.frag == 0 and ip.flags & 1 == 0: + nofrag.append(p) + continue + uniq = (ip.id,ip.src,ip.dst,ip.proto) + frags[uniq].append(p) + defrag = [] + missfrag = [] + for lst in frags.values(): + lst.sort(key=lambda x: x.frag) + p = lst[0] + lastp = lst[-1] + if p.frag > 0 or lastp.flags & 1 != 0: # first or last fragment missing + missfrag.append(lst) + continue + p = p.copy() + if conf.padding_layer in p: + del(p[conf.padding_layer].underlayer.payload) + ip = p[IP] + if ip.len is None or ip.ihl is None: + clen = len(ip.payload) + else: + clen = ip.len - (ip.ihl<<2) + txt = conf.raw_layer() + for q in lst[1:]: + if clen != q.frag<<3: # Wrong fragmentation offset + if clen > q.frag<<3: + warning("Fragment overlap (%i > %i) %r || %r || %r" % (clen, q.frag<<3, p,txt,q)) + missfrag.append(lst) + break + if q[IP].len is None or q[IP].ihl is None: + clen += len(q[IP].payload) + else: + clen += q[IP].len - (q[IP].ihl<<2) + if conf.padding_layer in q: + del(q[conf.padding_layer].underlayer.payload) + txt.add_payload(q[IP].payload.copy()) + else: + ip.flags &= ~1 # !MF + del(ip.chksum) + del(ip.len) + p = p/txt + defrag.append(p) + defrag2=PacketList() + for p in defrag: + defrag2.append(p.__class__(bytes(p))) + return nofrag,defrag2,missfrag + +@conf.commands.register +def defragment(plist): + """defragment(plist) -> plist defragmented as much as possible """ + frags = defaultdict(lambda:[]) + final = [] + + pos = 0 + for p in plist: + p._defrag_pos = pos + pos += 1 + if IP in p: + ip = p[IP] + if ip.frag != 0 or ip.flags & 1: + ip = p[IP] + uniq = (ip.id,ip.src,ip.dst,ip.proto) + frags[uniq].append(p) + continue + final.append(p) + + defrag = [] + missfrag = [] + for lst in frags.values(): + lst.sort(key=lambda x: x.frag) + p = lst[0] + lastp = lst[-1] + if p.frag > 0 or lastp.flags & 1 != 0: # first or last fragment missing + missfrag += lst + continue + p = p.copy() + if conf.padding_layer in p: + del(p[conf.padding_layer].underlayer.payload) + ip = p[IP] + if ip.len is None or ip.ihl is None: + clen = len(ip.payload) + else: + clen = ip.len - (ip.ihl<<2) + txt = conf.raw_layer() + for q in lst[1:]: + if clen != q.frag<<3: # Wrong fragmentation offset + if clen > q.frag<<3: + warning("Fragment overlap (%i > %i) %r || %r || %r" % (clen, q.frag<<3, p,txt,q)) + missfrag += lst + break + if q[IP].len is None or q[IP].ihl is None: + clen += len(q[IP].payload) + else: + clen += q[IP].len - (q[IP].ihl<<2) + if conf.padding_layer in q: + del(q[conf.padding_layer].underlayer.payload) + txt.add_payload(q[IP].payload.copy()) + else: + ip.flags &= ~1 # !MF + del(ip.chksum) + del(ip.len) + p = p/txt + p._defrag_pos = max(x._defrag_pos for x in lst) + defrag.append(p) + defrag2=[] + for p in defrag: + q = p.__class__(bytes(p)) + q._defrag_pos = p._defrag_pos + defrag2.append(q) + final += defrag2 + final += missfrag + final.sort(key=lambda x: x._defrag_pos) + for p in final: + del(p._defrag_pos) + + if hasattr(plist, "listname"): + name = "Defragmented %s" % plist.listname + else: + name = "Defragmented" + + return PacketList(final, name=name) + + + +### Add timeskew_graph() method to PacketList +def _packetlist_timeskew_graph(self, ip, **kargs): + """Tries to graph the timeskew between the timestamps and real time for a given ip""" + res = map(lambda x: self._elt2pkt(x), self.res) + b = filter(lambda x:x.haslayer(IP) and x.getlayer(IP).src == ip and x.haslayer(TCP), res) + c = [] + for p in b: + opts = p.getlayer(TCP).options + for o in opts: + if o[0] == "Timestamp": + c.append((p.time,o[1][0])) + if not c: + warning("No timestamps found in packet list") + return + #d = map(lambda (x,y): (x%2000,((x-c[0][0])-((y-c[0][1])/1000.0))),c) + d = map(lambda a: (a[0]%2000,((a[0]-c[0][0])-((a[1]-c[0][1])/1000.0))),c) + return plt.plot(d, **kargs) + +#PacketList.timeskew_graph = types.MethodType(_packetlist_timeskew_graph, None) + + +### Create a new packet list +class TracerouteResult(SndRcvList): + def __init__(self, res=None, name="Traceroute", stats=None): + PacketList.__init__(self, res, name, stats, vector_index = 1) + self.graphdef = None + self.graphASres = 0 + self.padding = 0 + self.hloc = None + self.nloc = None + + def show(self): + #return self.make_table(lambda (s,r): (s.sprintf("%IP.dst%:{TCP:tcp%ir,TCP.dport%}{UDP:udp%ir,UDP.dport%}{ICMP:ICMP}"), + return self.make_table(lambda s,r: (s.sprintf("%IP.dst%:{TCP:tcp%ir,TCP.dport%}{UDP:udp%ir,UDP.dport%}{ICMP:ICMP}"), + s.ttl, + r.sprintf("%-15s,IP.src% {TCP:%TCP.flags%}{ICMP:%ir,ICMP.type%}"))) + + + def get_trace(self): + raw_trace = {} + for s,r in self.res: + if IP not in s: + continue + d = s[IP].dst + if d not in raw_trace: + raw_trace[d] = {} + raw_trace[d][s[IP].ttl] = r[IP].src, ICMP not in r + + trace = {} + for k in raw_trace.keys(): + m = [ x for x in raw_trace[k].keys() if raw_trace[k][x][1] ] + if not m: + trace[k] = raw_trace[k] + else: + m = min(m) + trace[k] = {i: raw_trace[k][i] for i in raw_trace[k].keys() if not raw_trace[k][i][1] or i<=m} + + return trace + + def trace3D(self): + """Give a 3D representation of the traceroute. + right button: rotate the scene + middle button: zoom + left button: move the scene + left button on a ball: toggle IP displaying + ctrl-left button on a ball: scan ports 21,22,23,25,80 and 443 and display the result""" + trace = self.get_trace() + import visual + + class IPsphere(visual.sphere): + def __init__(self, ip, **kargs): + visual.sphere.__init__(self, **kargs) + self.ip=ip + self.label=None + self.setlabel(self.ip) + def setlabel(self, txt,visible=None): + if self.label is not None: + if visible is None: + visible = self.label.visible + self.label.visible = 0 + elif visible is None: + visible=0 + self.label=visual.label(text=txt, pos=self.pos, space=self.radius, xoffset=10, yoffset=20, visible=visible) + def action(self): + self.label.visible ^= 1 + + visual.scene = visual.display() + visual.scene.exit = True + start = visual.box() + rings={} + tr3d = {} + for i in trace: + tr = trace[i] + tr3d[i] = [] + ttl = tr.keys() + for t in range(1,max(ttl)+1): + if t not in rings: + rings[t] = [] + if t in tr: + if tr[t] not in rings[t]: + rings[t].append(tr[t]) + tr3d[i].append(rings[t].index(tr[t])) + else: + rings[t].append(("unk",-1)) + tr3d[i].append(len(rings[t])-1) + for t in rings: + r = rings[t] + l = len(r) + for i in range(l): + if r[i][1] == -1: + col = (0.75,0.75,0.75) + elif r[i][1]: + col = visual.color.green + else: + col = visual.color.blue + + s = IPsphere(pos=((l-1)*visual.cos(2*i*visual.pi/l),(l-1)*visual.sin(2*i*visual.pi/l),2*t), + ip = r[i][0], + color = col) + for trlst in tr3d.values(): + if t <= len(trlst): + if trlst[t-1] == i: + trlst[t-1] = s + forecol = colgen(0.625, 0.4375, 0.25, 0.125) + for trlst in tr3d.values(): + col = next(forecol) + start = (0,0,0) + for ip in trlst: + visual.cylinder(pos=start,axis=ip.pos-start,color=col,radius=0.2) + start = ip.pos + + movcenter=None + while 1: + visual.rate(50) + if visual.scene.kb.keys: + k = visual.scene.kb.getkey() + if k == "esc" or k == "q": + break + if visual.scene.mouse.events: + ev = visual.scene.mouse.getevent() + if ev.press == "left": + o = ev.pick + if o: + if ev.ctrl: + if o.ip == "unk": + continue + savcolor = o.color + o.color = (1,0,0) + a,b=sr(IP(dst=o.ip)/TCP(dport=[21,22,23,25,80,443]),timeout=2) + o.color = savcolor + if len(a) == 0: + txt = "%s:\nno results" % o.ip + else: + txt = "%s:\n" % o.ip + for s,r in a: + txt += r.sprintf("{TCP:%IP.src%:%TCP.sport% %TCP.flags%}{TCPerror:%IPerror.dst%:%TCPerror.dport% %IP.src% %ir,ICMP.type%}\n") + o.setlabel(txt, visible=1) + else: + if hasattr(o, "action"): + o.action() + elif ev.drag == "left": + movcenter = ev.pos + elif ev.drop == "left": + movcenter = None + if movcenter: + visual.scene.center -= visual.scene.mouse.pos-movcenter + movcenter = visual.scene.mouse.pos + +## world_trace needs to be reimplemented as gnuplot dependency is removed +# def world_trace(self): +# from modules.geo import locate_ip +# ips = {} +# rt = {} +# ports_done = {} +# for s,r in self.res: +# ips[r.src] = None +# if s.haslayer(TCP) or s.haslayer(UDP): +# trace_id = (s.src,s.dst,s.proto,s.dport) +# elif s.haslayer(ICMP): +# trace_id = (s.src,s.dst,s.proto,s.type) +# else: +# trace_id = (s.src,s.dst,s.proto,0) +# trace = rt.get(trace_id,{}) +# if not r.haslayer(ICMP) or r.type != 11: +# if trace_id in ports_done: +# continue +# ports_done[trace_id] = None +# trace[s.ttl] = r.src +# rt[trace_id] = trace +# +# trt = {} +# for trace_id in rt: +# trace = rt[trace_id] +# loctrace = [] +# for i in range(max(trace.keys())): +# ip = trace.get(i,None) +# if ip is None: +# continue +# loc = locate_ip(ip) +# if loc is None: +# continue +## loctrace.append((ip,loc)) # no labels yet +# loctrace.append(loc) +# if loctrace: +# trt[trace_id] = loctrace +# +# tr = map(lambda x: Gnuplot.Data(x,with_="lines"), trt.values()) +# g = Gnuplot.Gnuplot() +# world = Gnuplot.File(conf.gnuplot_world,with_="lines") +# g.plot(world,*tr) +# return g + + def make_graph(self,ASres=None,padding=0): + if ASres is None: + ASres = conf.AS_resolver + self.graphASres = ASres + self.graphpadding = padding + ips = {} + rt = {} + ports = {} + ports_done = {} + for s,r in self.res: + r = r.getlayer(IP) or (conf.ipv6_enabled and r[scapy.layers.inet6.IPv6]) or r + s = s.getlayer(IP) or (conf.ipv6_enabled and s[scapy.layers.inet6.IPv6]) or s + ips[r.src] = None + if TCP in s: + trace_id = (s.src,s.dst,6,s.dport) + elif UDP in s: + trace_id = (s.src,s.dst,17,s.dport) + elif ICMP in s: + trace_id = (s.src,s.dst,1,s.type) + else: + trace_id = (s.src,s.dst,s.proto,0) + trace = rt.get(trace_id,{}) + ttl = conf.ipv6_enabled and scapy.layers.inet6.IPv6 in s and s.hlim or s.ttl + if not (ICMP in r and r[ICMP].type == 11) and not (conf.ipv6_enabled and scapy.layers.inet6.IPv6 in r and scapy.layers.inet6.ICMPv6TimeExceeded in r): + if trace_id in ports_done: + continue + ports_done[trace_id] = None + p = ports.get(r.src,[]) + if TCP in r: + p.append(r.sprintf("<T%ir,TCP.sport%> %TCP.sport% %TCP.flags%")) + trace[ttl] = r.sprintf('"%r,src%":T%ir,TCP.sport%') + elif UDP in r: + p.append(r.sprintf("<U%ir,UDP.sport%> %UDP.sport%")) + trace[ttl] = r.sprintf('"%r,src%":U%ir,UDP.sport%') + elif ICMP in r: + p.append(r.sprintf("<I%ir,ICMP.type%> ICMP %ICMP.type%")) + trace[ttl] = r.sprintf('"%r,src%":I%ir,ICMP.type%') + else: + p.append(r.sprintf("{IP:<P%ir,proto%> IP %proto%}{IPv6:<P%ir,nh%> IPv6 %nh%}")) + trace[ttl] = r.sprintf('"%r,src%":{IP:P%ir,proto%}{IPv6:P%ir,nh%}') + ports[r.src] = p + else: + trace[ttl] = r.sprintf('"%r,src%"') + rt[trace_id] = trace + + # Fill holes with unk%i nodes + unknown_label = incremental_label("unk%i") + blackholes = [] + bhip = {} + for rtk in rt: + trace = rt[rtk] + k = trace.keys() + for n in range(min(k), max(k)): + if not n in trace: + trace[n] = next(unknown_label) + if not rtk in ports_done: + if rtk[2] == 1: #ICMP + bh = "%s %i/icmp" % (rtk[1],rtk[3]) + elif rtk[2] == 6: #TCP + bh = "%s %i/tcp" % (rtk[1],rtk[3]) + elif rtk[2] == 17: #UDP + bh = '%s %i/udp' % (rtk[1],rtk[3]) + else: + bh = '%s %i/proto' % (rtk[1],rtk[2]) + ips[bh] = None + bhip[rtk[1]] = bh + bh = '"%s"' % bh + trace[max(k)+1] = bh + blackholes.append(bh) + + # Find AS numbers + ASN_query_list = dict.fromkeys(map(lambda x:x.rsplit(" ",1)[0],ips)).keys() + if ASres is None: + ASNlist = [] + else: + ASNlist = ASres.resolve(*ASN_query_list) + + ASNs = {} + ASDs = {} + for ip,asn,desc, in ASNlist: + if asn is None: + continue + iplist = ASNs.get(asn,[]) + if ip in bhip: + if ip in ports: + iplist.append(ip) + iplist.append(bhip[ip]) + else: + iplist.append(ip) + ASNs[asn] = iplist + ASDs[asn] = desc + + + backcolorlist=colgen("60","86","ba","ff") + forecolorlist=colgen("a0","70","40","20") + + s = "digraph trace {\n" + + s += "\n\tnode [shape=ellipse,color=black,style=solid];\n\n" + + s += "\n#ASN clustering\n" + for asn in ASNs: + s += '\tsubgraph cluster_%s {\n' % asn + col = next(backcolorlist) + s += '\t\tcolor="#%s%s%s";' % col + s += '\t\tnode [fillcolor="#%s%s%s",style=filled];' % col + s += '\t\tfontsize = 10;' + s += '\t\tlabel = "%s\\n[%s]"\n' % (asn,ASDs[asn]) + for ip in ASNs[asn]: + + s += '\t\t"%s";\n'%ip + s += "\t}\n" + + + + + s += "#endpoints\n" + for p in ports: + s += '\t"%s" [shape=record,color=black,fillcolor=green,style=filled,label="%s|%s"];\n' % (p,p,"|".join(ports[p])) + + s += "\n#Blackholes\n" + for bh in blackholes: + s += '\t%s [shape=octagon,color=black,fillcolor=red,style=filled];\n' % bh + + if padding: + s += "\n#Padding\n" + pad={} + for snd,rcv in self.res: + if rcv.src not in ports and rcv.haslayer(conf.padding_layer): + p = rcv.getlayer(conf.padding_layer).load + if p != "\x00"*len(p): + pad[rcv.src]=None + for rcv in pad: + s += '\t"%s" [shape=triangle,color=black,fillcolor=red,style=filled];\n' % rcv + + + + s += "\n\tnode [shape=ellipse,color=black,style=solid];\n\n" + + + for rtk in rt: + s += "#---[%s\n" % repr(rtk) + s += '\t\tedge [color="#%s%s%s"];\n' % next(forecolorlist) + trace = rt[rtk] + k = trace.keys() + for n in range(min(k), max(k)): + s += '\t%s ->\n' % trace[n] + s += '\t%s;\n' % trace[max(k)] + + s += "}\n"; + self.graphdef = s + + def graph(self, ASres=None, padding=0, **kargs): + """x.graph(ASres=conf.AS_resolver, other args): + ASres=None : no AS resolver => no clustering + ASres=AS_resolver() : default whois AS resolver (riswhois.ripe.net) + ASres=AS_resolver_cymru(): use whois.cymru.com whois database + ASres=AS_resolver(server="whois.ra.net") + format: output type (svg, ps, gif, jpg, etc.), passed to dot's "-T" option + figsize: w,h tuple in inches. See matplotlib documentation + target: filename. If None uses matplotlib to display + prog: which graphviz program to use""" + if ASres is None: + ASres = conf.AS_resolver + if (self.graphdef is None or + self.graphASres != ASres or + self.graphpadding != padding): + self.make_graph(ASres,padding) + + return do_graph(self.graphdef, **kargs) + + + +@conf.commands.register +def traceroute(target, dport=80, minttl=1, maxttl=30, sport=RandShort(), l4 = None, filter=None, timeout=2, verbose=None, **kargs): + """Instant TCP traceroute +traceroute(target, [maxttl=30,] [dport=80,] [sport=80,] [verbose=conf.verb]) -> None +""" + if verbose is None: + verbose = conf.verb + if filter is None: + # we only consider ICMP error packets and TCP packets with at + # least the ACK flag set *and* either the SYN or the RST flag + # set + filter="(icmp and (icmp[0]=3 or icmp[0]=4 or icmp[0]=5 or icmp[0]=11 or icmp[0]=12)) or (tcp and (tcp[13] & 0x16 > 0x10))" + if l4 is None: + a,b = sr(IP(dst=target, id=RandShort(), ttl=(minttl,maxttl))/TCP(seq=RandInt(),sport=sport, dport=dport), + timeout=timeout, filter=filter, verbose=verbose, **kargs) + else: + # this should always work + filter="ip" + a,b = sr(IP(dst=target, id=RandShort(), ttl=(minttl,maxttl))/l4, + timeout=timeout, filter=filter, verbose=verbose, **kargs) + + a = TracerouteResult(a.res) + + if verbose: + a.show() + return a,b + + + +############################# +## Simple TCP client stack ## +############################# + +class TCP_client(Automaton): + + def parse_args(self, ip, port, *args, **kargs): + self.dst = next(iter(Net(ip))) + self.dport = port + self.sport = random.randrange(0,2**16) + self.l4 = IP(dst=ip)/TCP(sport=self.sport, dport=self.dport, flags=0, + seq=random.randrange(0,2**32)) + self.src = self.l4.src + self.swin=self.l4[TCP].window + self.dwin=1 + self.rcvbuf="" + bpf = "host %s and host %s and port %i and port %i" % (self.src, + self.dst, + self.sport, + self.dport) + +# bpf=None + Automaton.parse_args(self, filter=bpf, **kargs) + + + def master_filter(self, pkt): + return (IP in pkt and + pkt[IP].src == self.dst and + pkt[IP].dst == self.src and + TCP in pkt and + pkt[TCP].sport == self.dport and + pkt[TCP].dport == self.sport and + self.l4[TCP].seq >= pkt[TCP].ack and # XXX: seq/ack 2^32 wrap up + ((self.l4[TCP].ack == 0) or (self.l4[TCP].ack <= pkt[TCP].seq <= self.l4[TCP].ack+self.swin)) ) + + + @ATMT.state(initial=1) + def START(self): + pass + + @ATMT.state() + def SYN_SENT(self): + pass + + @ATMT.state() + def ESTABLISHED(self): + pass + + @ATMT.state() + def LAST_ACK(self): + pass + + @ATMT.state(final=1) + def CLOSED(self): + pass + + + @ATMT.condition(START) + def connect(self): + raise self.SYN_SENT() + @ATMT.action(connect) + def send_syn(self): + self.l4[TCP].flags = "S" + self.send(self.l4) + self.l4[TCP].seq += 1 + + + @ATMT.receive_condition(SYN_SENT) + def synack_received(self, pkt): + if pkt[TCP].flags & 0x3f == 0x12: + raise self.ESTABLISHED().action_parameters(pkt) + @ATMT.action(synack_received) + def send_ack_of_synack(self, pkt): + self.l4[TCP].ack = pkt[TCP].seq+1 + self.l4[TCP].flags = "A" + self.send(self.l4) + + @ATMT.receive_condition(ESTABLISHED) + def incoming_data_received(self, pkt): + if not isinstance(pkt[TCP].payload, NoPayload) and not isinstance(pkt[TCP].payload, conf.padding_layer): + raise self.ESTABLISHED().action_parameters(pkt) + @ATMT.action(incoming_data_received) + def receive_data(self,pkt): + data = (bytes(pkt[TCP].payload)) + if data and self.l4[TCP].ack == pkt[TCP].seq: + self.l4[TCP].ack += len(data) + self.l4[TCP].flags = "A" + self.send(self.l4) + self.rcvbuf += data + if pkt[TCP].flags & 8 != 0: #PUSH + self.oi.tcp.send(self.rcvbuf) + self.rcvbuf = "" + + @ATMT.ioevent(ESTABLISHED,name="tcp", as_supersocket="tcplink") + def outgoing_data_received(self, fd): + raise self.ESTABLISHED().action_parameters(fd.recv()) + @ATMT.action(outgoing_data_received) + def send_data(self, d): + self.l4[TCP].flags = "PA" + self.send(self.l4/d) + self.l4[TCP].seq += len(d) + + + @ATMT.receive_condition(ESTABLISHED) + def reset_received(self, pkt): + if pkt[TCP].flags & 4 != 0: + raise self.CLOSED() + + @ATMT.receive_condition(ESTABLISHED) + def fin_received(self, pkt): + if pkt[TCP].flags & 0x1 == 1: + raise self.LAST_ACK().action_parameters(pkt) + @ATMT.action(fin_received) + def send_finack(self, pkt): + self.l4[TCP].flags = "FA" + self.l4[TCP].ack = pkt[TCP].seq+1 + self.send(self.l4) + self.l4[TCP].seq += 1 + + @ATMT.receive_condition(LAST_ACK) + def ack_of_fin_received(self, pkt): + if pkt[TCP].flags & 0x3f == 0x10: + raise self.CLOSED() + + + + +##################### +## Reporting stuff ## +##################### + +def report_ports(target, ports): + """portscan a target and output a LaTeX table +report_ports(target, ports) -> string""" + ans,unans = sr(IP(dst=target)/TCP(dport=ports),timeout=5) + rep = "\\begin{tabular}{|r|l|l|}\n\\hline\n" + for s,r in ans: + if not r.haslayer(ICMP): + if r.payload.flags == 0x12: + rep += r.sprintf("%TCP.sport% & open & SA \\\\\n") + rep += "\\hline\n" + for s,r in ans: + if r.haslayer(ICMP): + rep += r.sprintf("%TCPerror.dport% & closed & ICMP type %ICMP.type%/%ICMP.code% from %IP.src% \\\\\n") + elif r.payload.flags != 0x12: + rep += r.sprintf("%TCP.sport% & closed & TCP %TCP.flags% \\\\\n") + rep += "\\hline\n" + for i in unans: + rep += i.sprintf("%TCP.dport% & ? & unanswered \\\\\n") + rep += "\\hline\n\\end{tabular}\n" + return rep + + + +def IPID_count(lst, funcID=lambda x:x[1].id, funcpres=lambda x:x[1].summary()): + idlst = map(funcID, lst) + idlst.sort() + #classes = [idlst[0]]+map(lambda x:x[1],filter(lambda (x,y): abs(x-y)>50, map(lambda x,y: (x,y),idlst[:-1], idlst[1:]))) + classes = [idlst[0]]+list(map(lambda x:x[1],filter(lambda a: abs(a[0]-a[1])>50, map(lambda x,y: (x,y),idlst[:-1], idlst[1:])))) + lst = map(lambda x:(funcID(x), funcpres(x)), lst) + lst.sort() + print("Probably %i classes:" % len(classes), classes) + for id,pr in lst: + print("%5i" % id, pr) + + +def fragleak(target,sport=123, dport=123, timeout=0.2, onlyasc=0): + load = "XXXXYYYYYYYYYY" +# getmacbyip(target) +# pkt = IP(dst=target, id=RandShort(), options="\x22"*40)/UDP()/load + pkt = IP(dst=target, id=RandShort(), options="\x00"*40, flags=1)/UDP(sport=sport, dport=sport)/load + s=conf.L3socket() + intr=0 + found={} + try: + while 1: + try: + if not intr: + s.send(pkt) + sin,sout,serr = select([s],[],[],timeout) + if not sin: + continue + ans=s.recv(1600) + if not isinstance(ans, IP): #TODO: IPv6 + continue + if not isinstance(ans.payload, ICMP): + continue + if not isinstance(ans.payload.payload, IPerror): + continue + if ans.payload.payload.dst != target: + continue + if ans.src != target: + print("leak from", ans.src,end=" ") + + +# print repr(ans) + if not ans.haslayer(conf.padding_layer): + continue + + +# print repr(ans.payload.payload.payload.payload) + +# if not isinstance(ans.payload.payload.payload.payload, conf.raw_layer): +# continue +# leak = ans.payload.payload.payload.payload.load[len(load):] + leak = ans.getlayer(conf.padding_layer).load + if leak not in found: + found[leak]=None + linehexdump(leak, onlyasc=onlyasc) + except KeyboardInterrupt: + if intr: + raise + intr=1 + except KeyboardInterrupt: + pass + +def fragleak2(target, timeout=0.4, onlyasc=0): + found={} + try: + while 1: + p = sr1(IP(dst=target, options="\x00"*40, proto=200)/"XXXXYYYYYYYYYYYY",timeout=timeout,verbose=0) + if not p: + continue + if conf.padding_layer in p: + leak = p[conf.padding_layer].load + if leak not in found: + found[leak]=None + linehexdump(leak,onlyasc=onlyasc) + except: + pass + + +conf.stats_classic_protocols += [TCP,UDP,ICMP] +conf.stats_dot11_protocols += [TCP,UDP,ICMP] + +if conf.ipv6_enabled: + import scapy.layers.inet6 diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/inet6.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/inet6.py new file mode 100644 index 00000000..c2e4a037 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/inet6.py @@ -0,0 +1,3047 @@ +#! /usr/bin/env python +############################################################################# +## ## +## inet6.py --- IPv6 support for Scapy ## +## see http://natisbad.org/IPv6/ ## +## for more informations ## +## ## +## Copyright (C) 2005 Guillaume Valadon <guedou@hongo.wide.ad.jp> ## +## Arnaud Ebalard <arnaud.ebalard@eads.net> ## +## ## +## This program is free software; you can redistribute it and/or modify it ## +## under the terms of the GNU General Public License version 2 as ## +## published by the Free Software Foundation. ## +## ## +## This program is distributed in the hope that it will be useful, but ## +## WITHOUT ANY WARRANTY; without even the implied warranty of ## +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ## +## General Public License for more details. ## +## ## +############################################################################# + +""" +IPv6 (Internet Protocol v6). +""" + + +import socket +if not socket.has_ipv6: + raise socket.error("can't use AF_INET6, IPv6 is disabled") +if not hasattr(socket, "IPPROTO_IPV6"): + # Workaround for http://bugs.python.org/issue6926 + socket.IPPROTO_IPV6 = 41 + +if not hasattr(socket, "IPPROTO_IPIP"): + socket.IPPROTO_IPIP = 4 + +if not ('IPPROTO_IPIP ' in globals()): + IPPROTO_IPIP=4 + + + +from scapy.config import conf +from scapy.layers.l2 import * +from scapy.layers.inet import * +from scapy.fields import * +from scapy.packet import * +from scapy.volatile import * +from scapy.sendrecv import sr,sr1,srp1 +from scapy.as_resolvers import AS_resolver_riswhois +from scapy.supersocket import SuperSocket,L3RawSocket +from scapy.arch import * +from scapy.utils6 import * + + +############################################################################# +# Helpers ## +############################################################################# + +def get_cls(name, fallback_cls): + return globals().get(name, fallback_cls) + + +########################## +## Neighbor cache stuff ## +########################## + +conf.netcache.new_cache("in6_neighbor", 120) + +def neighsol(addr, src, iface, timeout=1, chainCC=0): + """ + Sends an ICMPv6 Neighbor Solicitation message to get the MAC address + of the neighbor with specified IPv6 address addr. 'src' address is + used as source of the message. Message is sent on iface. By default, + timeout waiting for an answer is 1 second. + + If no answer is gathered, None is returned. Else, the answer is + returned (ethernet frame). + """ + + nsma = in6_getnsma(inet_pton(socket.AF_INET6, addr)) + d = inet_ntop(socket.AF_INET6, nsma) + dm = in6_getnsmac(nsma) + p = Ether(dst=dm)/IPv6(dst=d, src=src, hlim=255) + p /= ICMPv6ND_NS(tgt=addr) + p /= ICMPv6NDOptSrcLLAddr(lladdr=get_if_hwaddr(iface)) + res = srp1(p,type=ETH_P_IPV6, iface=iface, timeout=1, verbose=0, + chainCC=chainCC) + + return res + +def getmacbyip6(ip6, chainCC=0): + """ + Returns the mac address to be used for provided 'ip6' peer. + neighborCache.get() method is used on instantiated neighbor cache. + Resolution mechanism is described in associated doc string. + + (chainCC parameter value ends up being passed to sending function + used to perform the resolution, if needed) + """ + + if in6_ismaddr(ip6): # Multicast + mac = in6_getnsmac(inet_pton(socket.AF_INET6, ip6)) + return mac + + iff,a,nh = conf.route6.route(ip6, dev=conf.iface6) + + if iff == LOOPBACK_NAME: + return "ff:ff:ff:ff:ff:ff" + + if nh != '::': + ip6 = nh # Found next hop + + mac = conf.netcache.in6_neighbor.get(ip6) + if mac: + return mac + + res = neighsol(ip6, a, iff, chainCC=chainCC) + + if res is not None: + if ICMPv6NDOptDstLLAddr in res: + mac = res[ICMPv6NDOptDstLLAddr].lladdr + else: + mac = res.src + conf.netcache.in6_neighbor[ip6] = mac + return mac + + return None + + +############################################################################# +############################################################################# +### IPv6 addresses manipulation routines ### +############################################################################# +############################################################################# + +class Net6(Gen): # syntax ex. fec0::/126 + """Generate a list of IPv6s from a network address or a name""" + name = "ipv6" + ipaddress = re.compile(r"^([a-fA-F0-9:]+)(/[1]?[0-3]?[0-9])?$") + + def __init__(self, net): + self.repr = net + + tmp = net.split('/')+["128"] + if not self.ipaddress.match(net): + tmp[0]=socket.getaddrinfo(tmp[0], None, socket.AF_INET6)[0][-1][0] + + netmask = int(tmp[1]) + self.net = inet_pton(socket.AF_INET6, tmp[0]) + self.mask = in6_cidr2mask(netmask) + self.plen = netmask + + def __iter__(self): + def m8(i): + if i % 8 == 0: + return i + #tuple = filter(lambda x: m8(x), range(8, 129)) + tuple = [ x for x in range(8, 129) if m8(x) ] + + a = in6_and(self.net, self.mask) + tmp = map(lambda x: x, struct.unpack('16B', a)) + + def parse_digit(a, netmask): + netmask = min(8,max(netmask,0)) + a = (int(a) & (0xff<<netmask),(int(a) | (0xff>>(8-netmask)))+1) + return a + self.parsed = map(lambda x,y: parse_digit(x,y), tmp, map(lambda x,nm=self.plen: x-nm, tuple)) + + def rec(n, l): + if n and n % 2 == 0: + sep = ':' + else: + sep = '' + if n == 16: + return l + else: + ll = [] + for i in range(*self.parsed[n]): + for y in l: + ll += [y+sep+'%.2x'%i] + return rec(n+1, ll) + + return iter(rec(0, [''])) + + def __repr__(self): + return "<Net6 %s>" % self.repr + + + + + + +############################################################################# +############################################################################# +### IPv6 Class ### +############################################################################# +############################################################################# + +class IP6Field(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "16s") + def h2i(self, pkt, x): + if type(x) is str: + try: + x = in6_ptop(x) + except socket.error: + x = Net6(x) + elif type(x) is list: + x = map(Net6, x) + return x + def i2m(self, pkt, x): + return inet_pton(socket.AF_INET6, x) + def m2i(self, pkt, x): + return inet_ntop(socket.AF_INET6, x) + def any2i(self, pkt, x): + return self.h2i(pkt,x) + def i2repr(self, pkt, x): + if x is None: + return self.i2h(pkt,x) + elif not isinstance(x, Net6) and not type(x) is list: + if in6_isaddrTeredo(x): # print Teredo info + server, flag, maddr, mport = teredoAddrExtractInfo(x) + return "%s [Teredo srv: %s cli: %s:%s]" % (self.i2h(pkt, x), server, maddr,mport) + elif in6_isaddr6to4(x): # print encapsulated address + vaddr = in6_6to4ExtractAddr(x) + return "%s [6to4 GW: %s]" % (self.i2h(pkt, x), vaddr) + return self.i2h(pkt, x) # No specific information to return + def randval(self): + return RandIP6() + +class SourceIP6Field(IP6Field): + def __init__(self, name, dstname): + IP6Field.__init__(self, name, None) + self.dstname = dstname + def i2m(self, pkt, x): + if x is None: + dst=getattr(pkt,self.dstname) + iff,x,nh = conf.route6.route(dst) + return IP6Field.i2m(self, pkt, x) + def i2h(self, pkt, x): + if x is None: + dst=getattr(pkt,self.dstname) + if isinstance(dst,Gen): + r = map(conf.route6.route, dst) + r.sort() + if r[0] == r[-1]: + x=r[0][1] + else: + warning("More than one possible route for %s"%repr(dst)) + return None + else: + iff,x,nh = conf.route6.route(dst) + return IP6Field.i2h(self, pkt, x) + +ipv6nh = { 0:"Hop-by-Hop Option Header", + 4:"IP", + 6:"TCP", + 17:"UDP", + 41:"IPv6", + 43:"Routing Header", + 44:"Fragment Header", + 47:"GRE", + 50:"ESP Header", + 51:"AH Header", + 58:"ICMPv6", + 59:"No Next Header", + 60:"Destination Option Header", + 135:"Mobility Header"} + +ipv6nhcls = { 0: "IPv6ExtHdrHopByHop", + 4: "IP", + 6: "TCP", + 17: "UDP", + 43: "IPv6ExtHdrRouting", + 44: "IPv6ExtHdrFragment", + #50: "IPv6ExtHrESP", + #51: "IPv6ExtHdrAH", + 58: "ICMPv6Unknown", + 59: "Raw", + 60: "IPv6ExtHdrDestOpt" } + +class IP6ListField(StrField): + islist = 1 + def __init__(self, name, default, count_from=None, length_from=None): + if default is None: + default = [] + StrField.__init__(self, name, default) + self.count_from = count_from + self.length_from = length_from + + def i2len(self, pkt, i): + return 16*len(i) + + def i2count(self, pkt, i): + if type(i) is list: + return len(i) + return 0 + + def getfield(self, pkt, s): + c = l = None + if self.length_from is not None: + l = self.length_from(pkt) + elif self.count_from is not None: + c = self.count_from(pkt) + + lst = [] + ret = b"" + remain = s + if l is not None: + remain,ret = s[:l],s[l:] + while remain: + if c is not None: + if c <= 0: + break + c -= 1 + addr = inet_ntop(socket.AF_INET6, remain[:16]) + lst.append(addr) + remain = remain[16:] + return remain+ret,lst + + def i2m(self, pkt, x): + s = b'' + for y in x: + try: + y = inet_pton(socket.AF_INET6, y) + except: + y = socket.getaddrinfo(y, None, socket.AF_INET6)[0][-1][0] + y = inet_pton(socket.AF_INET6, y) + s += y + return s + + def i2repr(self,pkt,x): + s = [] + if x == None: + return "[]" + for y in x: + s.append('%s' % y) + return "[ %s ]" % (", ".join(s)) + +class _IPv6GuessPayload: + name = "Dummy class that implements guess_payload_class() for IPv6" + def default_payload_class(self,p): + if self.nh == 58: # ICMPv6 + #t = ord(p[0]) + t = p[0] + if len(p) > 2 and t == 139 or t == 140: # Node Info Query + return _niquery_guesser(p) + if len(p) >= icmp6typesminhdrlen.get(t, sys.maxsize): # Other ICMPv6 messages + return get_cls(icmp6typescls.get(t,"Raw"), "Raw") + return Raw + elif self.nh == 135 and len(p) > 3: # Mobile IPv6 + #return _mip6_mhtype2cls.get(ord(p[2]), MIP6MH_Generic) + return _mip6_mhtype2cls.get(p[2], MIP6MH_Generic) + else: + return get_cls(ipv6nhcls.get(self.nh,"Raw"), "Raw") + +class IPv6(_IPv6GuessPayload, Packet, IPTools): + name = "IPv6" + fields_desc = [ BitField("version" , 6 , 4), + BitField("tc", 0, 8), #TODO: IPv6, ByteField ? + BitField("fl", 0, 20), + ShortField("plen", None), + ByteEnumField("nh", 59, ipv6nh), + ByteField("hlim", 64), + IP6Field("src", "::2"), + #SourceIP6Field("src", "dst"), # dst is for src @ selection + IP6Field("dst", "::1") ] + + def route(self): + dst = self.dst + if isinstance(dst,Gen): + dst = next(iter(dst)) + return conf.route6.route(dst) + + def mysummary(self): + return "%s > %s (%i)" % (self.src,self.dst, self.nh) + + def post_build(self, p, pay): + p += pay + if self.plen is None: + l = len(p) - 40 + p = p[:4]+struct.pack("!H", l)+p[6:] + return p + + def extract_padding(self, s): + l = self.plen + return s[:l], s[l:] + + def hashret(self): + if self.nh == 58 and isinstance(self.payload, _ICMPv6): + if self.payload.type < 128: + return self.payload.payload.hashret() + elif (self.payload.type in [133,134,135,136,144,145]): + return struct.pack("B", self.nh)+self.payload.hashret() + + nh = self.nh + sd = self.dst + ss = self.src + if self.nh == 43 and isinstance(self.payload, IPv6ExtHdrRouting): + # With routing header, the destination is the last + # address of the IPv6 list if segleft > 0 + nh = self.payload.nh + try: + sd = self.addresses[-1] + except IndexError: + sd = '::1' + # TODO: big bug with ICMPv6 error messages as the destination of IPerror6 + # could be anything from the original list ... + if 1: + sd = inet_pton(socket.AF_INET6, sd) + for a in self.addresses: + a = inet_pton(socket.AF_INET6, a) + sd = strxor(sd, a) + sd = inet_ntop(socket.AF_INET6, sd) + + if self.nh == 44 and isinstance(self.payload, IPv6ExtHdrFragment): + nh = self.payload.nh + + if self.nh == 0 and isinstance(self.payload, IPv6ExtHdrHopByHop): + nh = self.payload.nh + + if self.nh == 60 and isinstance(self.payload, IPv6ExtHdrDestOpt): + foundhao = None + for o in self.payload.options: + if isinstance(o, HAO): + foundhao = o + if foundhao: + nh = self.payload.nh # XXX what if another extension follows ? + ss = foundhao.hoa + + if conf.checkIPsrc and conf.checkIPaddr: + sd = inet_pton(socket.AF_INET6, sd) + ss = inet_pton(socket.AF_INET6, self.src) + return struct.pack("B",nh)+self.payload.hashret() + else: + return struct.pack("B", nh)+self.payload.hashret() + + def answers(self, other): + if not isinstance(other, IPv6): # self is reply, other is request + return False + if conf.checkIPaddr: + ss = inet_pton(socket.AF_INET6, self.src) + sd = inet_pton(socket.AF_INET6, self.dst) + os = inet_pton(socket.AF_INET6, other.src) + od = inet_pton(socket.AF_INET6, other.dst) + # request was sent to a multicast address (other.dst) + # Check reply destination addr matches request source addr (i.e + # sd == os) except when reply is multicasted too + # XXX test mcast scope matching ? + if in6_ismaddr(other.dst): + if in6_ismaddr(self.dst): + if ((od == sd) or + (in6_isaddrllallnodes(self.dst) and in6_isaddrllallservers(other.dst))): + return self.payload.answers(other.payload) + return False + if (os == sd): + return self.payload.answers(other.payload) + return False + elif (sd != os): # or ss != od): <- removed for ICMP errors + return False + if self.nh == 58 and isinstance(self.payload, _ICMPv6) and self.payload.type < 128: + # ICMPv6 Error message -> generated by IPv6 packet + # Note : at the moment, we jump the ICMPv6 specific class + # to call answers() method of erroneous packet (over + # initial packet). There can be cases where an ICMPv6 error + # class could implement a specific answers method that perform + # a specific task. Currently, don't see any use ... + return self.payload.payload.answers(other) + elif other.nh == 0 and isinstance(other.payload, IPv6ExtHdrHopByHop): + return self.payload.answers(other.payload.payload) + elif other.nh == 44 and isinstance(other.payload, IPv6ExtHdrFragment): + return self.payload.answers(other.payload.payload) + elif other.nh == 43 and isinstance(other.payload, IPv6ExtHdrRouting): + return self.payload.answers(other.payload.payload) # Buggy if self.payload is a IPv6ExtHdrRouting + elif other.nh == 60 and isinstance(other.payload, IPv6ExtHdrDestOpt): + return self.payload.payload.answers(other.payload.payload) + elif self.nh == 60 and isinstance(self.payload, IPv6ExtHdrDestOpt): # BU in reply to BRR, for instance + return self.payload.payload.answers(other.payload) + else: + if (self.nh != other.nh): + return False + return self.payload.answers(other.payload) + + +conf.neighbor.register_l3(Ether, IPv6, lambda l2,l3: getmacbyip6(l3.dst)) + + +class IPerror6(IPv6): + name = "IPv6 in ICMPv6" + def answers(self, other): + if not isinstance(other, IPv6): + return False + sd = inet_pton(socket.AF_INET6, self.dst) + ss = inet_pton(socket.AF_INET6, self.src) + od = inet_pton(socket.AF_INET6, other.dst) + os = inet_pton(socket.AF_INET6, other.src) + + # Make sure that the ICMPv6 error is related to the packet scapy sent + if isinstance(self.underlayer, _ICMPv6) and self.underlayer.type < 128: + + # find upper layer for self (possible citation) + selfup = self.payload + while selfup is not None and isinstance(selfup, _IPv6ExtHdr): + selfup = selfup.payload + + # find upper layer for other (initial packet). Also look for RH + otherup = other.payload + request_has_rh = False + while otherup is not None and isinstance(otherup, _IPv6ExtHdr): + if isinstance(otherup, IPv6ExtHdrRouting): + request_has_rh = True + otherup = otherup.payload + + if ((ss == os and sd == od) or # <- Basic case + (ss == os and request_has_rh)): # <- Request has a RH : + # don't check dst address + + # Let's deal with possible MSS Clamping + if (isinstance(selfup, TCP) and + isinstance(otherup, TCP) and + selfup.options != otherup.options): # seems clamped + + # Save fields modified by MSS clamping + old_otherup_opts = otherup.options + old_otherup_cksum = otherup.chksum + old_otherup_dataofs = otherup.dataofs + old_selfup_opts = selfup.options + old_selfup_cksum = selfup.chksum + old_selfup_dataofs = selfup.dataofs + + # Nullify them + otherup.options = [] + otherup.chksum = 0 + otherup.dataofs = 0 + selfup.options = [] + selfup.chksum = 0 + selfup.dataofs = 0 + + # Test it and save result + s1 = bytes(selfup) + s2 = bytes(otherup) + l = min(len(s1), len(s2)) + res = s1[:l] == s2[:l] + + # recall saved values + otherup.options = old_otherup_opts + otherup.chksum = old_otherup_cksum + otherup.dataofs = old_otherup_dataofs + selfup.options = old_selfup_opts + selfup.chksum = old_selfup_cksum + selfup.dataofs = old_selfup_dataofs + + return res + + s1 = bytes(selfup) + s2 = bytes(otherup) + l = min(len(s1), len(s2)) + return s1[:l] == s2[:l] + + return False + + def mysummary(self): + return Packet.mysummary(self) + + +############################################################################# +############################################################################# +### Upper Layer Checksum computation ### +############################################################################# +############################################################################# + +class PseudoIPv6(Packet): # IPv6 Pseudo-header for checksum computation + name = "Pseudo IPv6 Header" + fields_desc = [ IP6Field("src", "::"), + IP6Field("dst", "::"), + ShortField("uplen", None), + BitField("zero", 0, 24), + ByteField("nh", 0) ] + +def in6_chksum(nh, u, p): + """ + Performs IPv6 Upper Layer checksum computation. Provided parameters are: + + - 'nh' : value of upper layer protocol + - 'u' : upper layer instance (TCP, UDP, ICMPv6*, ). Instance must be + provided with all under layers (IPv6 and all extension headers, + for example) + - 'p' : the payload of the upper layer provided as a string + + Functions operate by filling a pseudo header class instance (PseudoIPv6) + with + - Next Header value + - the address of _final_ destination (if some Routing Header with non + segleft field is present in underlayer classes, last address is used.) + - the address of _real_ source (basically the source address of an + IPv6 class instance available in the underlayer or the source address + in HAO option if some Destination Option header found in underlayer + includes this option). + - the length is the length of provided payload string ('p') + """ + + ph6 = PseudoIPv6() + ph6.nh = nh + rthdr = 0 + hahdr = 0 + final_dest_addr_found = 0 + while u != None and not isinstance(u, IPv6): + if (isinstance(u, IPv6ExtHdrRouting) and + u.segleft != 0 and len(u.addresses) != 0 and + final_dest_addr_found == 0): + rthdr = u.addresses[-1] + final_dest_addr_found = 1 + elif (isinstance(u, IPv6ExtHdrDestOpt) and (len(u.options) == 1) and + isinstance(u.options[0], HAO)): + hahdr = u.options[0].hoa + u = u.underlayer + if u is None: + warning("No IPv6 underlayer to compute checksum. Leaving null.") + return 0 + if hahdr: + ph6.src = hahdr + else: + ph6.src = u.src + if rthdr: + ph6.dst = rthdr + else: + ph6.dst = u.dst + ph6.uplen = len(p) + ph6s = bytes(ph6) + return checksum(ph6s+p) + + +############################################################################# +############################################################################# +### Extension Headers ### +############################################################################# +############################################################################# + + +# Inherited by all extension header classes +class _IPv6ExtHdr(_IPv6GuessPayload, Packet): + name = 'Abstract IPV6 Option Header' + aliastypes = [IPv6, IPerror6] # TODO ... + + +#################### IPv6 options for Extension Headers ##################### + +_hbhopts = { 0x00: "Pad1", + 0x01: "PadN", + 0x04: "Tunnel Encapsulation Limit", + 0x05: "Router Alert", + 0x06: "Quick-Start", + 0xc2: "Jumbo Payload", + 0xc9: "Home Address Option" } + +class _OTypeField(ByteEnumField): + """ + Modified BytEnumField that displays information regarding the IPv6 option + based on its option type value (What should be done by nodes that process + the option if they do not understand it ...) + + It is used by Jumbo, Pad1, PadN, RouterAlert, HAO options + """ + pol = {0x00: "00: skip", + 0x40: "01: discard", + 0x80: "10: discard+ICMP", + 0xC0: "11: discard+ICMP not mcast"} + + enroutechange = {0x00: "0: Don't change en-route", + 0x20: "1: May change en-route" } + + def i2repr(self, pkt, x): + s = self.i2s.get(x, repr(x)) + polstr = self.pol[(x & 0xC0)] + enroutechangestr = self.enroutechange[(x & 0x20)] + return "%s [%s, %s]" % (s, polstr, enroutechangestr) + +class HBHOptUnknown(Packet): # IPv6 Hop-By-Hop Option + name = "Scapy6 Unknown Option" + fields_desc = [_OTypeField("otype", 0x01, _hbhopts), + FieldLenField("optlen", None, length_of="optdata", fmt="B"), + StrLenField("optdata", "", + length_from = lambda pkt: pkt.optlen) ] + def alignment_delta(self, curpos): # By default, no alignment requirement + """ + As specified in section 4.2 of RFC 2460, every options has + an alignment requirement ususally expressed xn+y, meaning + the Option Type must appear at an integer multiple of x octest + from the start of the header, plus y octet. + + That function is provided the current position from the + start of the header and returns required padding length. + """ + return 0 + +class Pad1(Packet): # IPv6 Hop-By-Hop Option + name = "Pad1" + fields_desc = [ _OTypeField("otype", 0x00, _hbhopts) ] + def alignment_delta(self, curpos): # No alignment requirement + return 0 + +class PadN(Packet): # IPv6 Hop-By-Hop Option + name = "PadN" + fields_desc = [_OTypeField("otype", 0x01, _hbhopts), + FieldLenField("optlen", None, length_of="optdata", fmt="B"), + StrLenField("optdata", "", + length_from = lambda pkt: pkt.optlen)] + def alignment_delta(self, curpos): # No alignment requirement + return 0 + +class RouterAlert(Packet): # RFC 2711 - IPv6 Hop-By-Hop Option + name = "Router Alert" + fields_desc = [_OTypeField("otype", 0x05, _hbhopts), + ByteField("optlen", 2), + ShortEnumField("value", None, + { 0: "Datagram contains a MLD message", + 1: "Datagram contains RSVP message", + 2: "Datagram contains an Active Network message" }) ] + # TODO : Check IANA has not defined new values for value field of RouterAlertOption + # TODO : now that we have that option, we should do something in MLD class that need it + def alignment_delta(self, curpos): # alignment requirement : 2n+0 + x = 2 ; y = 0 + delta = x*((curpos - y + x - 1)//x) + y - curpos + return delta + +class Jumbo(Packet): # IPv6 Hop-By-Hop Option + name = "Jumbo Payload" + fields_desc = [_OTypeField("otype", 0xC2, _hbhopts), + ByteField("optlen", 4), + IntField("jumboplen", None) ] + def alignment_delta(self, curpos): # alignment requirement : 4n+2 + x = 4 ; y = 2 + delta = x*((curpos - y + x - 1)//x) + y - curpos + return delta + +class HAO(Packet): # IPv6 Destination Options Header Option + name = "Home Address Option" + fields_desc = [_OTypeField("otype", 0xC9, _hbhopts), + ByteField("optlen", 16), + IP6Field("hoa", "::") ] + def alignment_delta(self, curpos): # alignment requirement : 8n+6 + x = 8 ; y = 6 + delta = x*((curpos - y + x - 1)//x) + y - curpos + return delta + +_hbhoptcls = { 0x00: Pad1, + 0x01: PadN, + 0x05: RouterAlert, + 0xC2: Jumbo, + 0xC9: HAO } + + +######################## Hop-by-Hop Extension Header ######################## + +class _HopByHopOptionsField(PacketListField): + islist = 1 + holds_packet = 1 + def __init__(self, name, default, cls, curpos, count_from=None, length_from=None): + self.curpos = curpos + PacketListField.__init__(self, name, default, cls, count_from=count_from, length_from=length_from) + + def i2len(self, pkt, i): + l = len(self.i2m(pkt, i)) + return l + + def i2count(self, pkt, i): + if type(i) is list: + return len(i) + return 0 + + def getfield(self, pkt, s): + c = l = None + if self.length_from is not None: + l = self.length_from(pkt) + elif self.count_from is not None: + c = self.count_from(pkt) + + opt = [] + ret = b"" + x = s + if l is not None: + x,ret = s[:l],s[l:] + while x: + if c is not None: + if c <= 0: + break + c -= 1 + #o = ord(x[0]) # Option type + o = x[0] # Option type + cls = self.cls + if o in _hbhoptcls: + cls = _hbhoptcls[o] + try: + op = cls(x) + except: + op = self.cls(x) + opt.append(op) + if isinstance(op.payload, conf.raw_layer): + x = op.payload.load + del(op.payload) + else: + x = b"" + return x+ret,opt + + def i2m(self, pkt, x): + autopad = None + try: + autopad = getattr(pkt, "autopad") # Hack : 'autopad' phantom field + except: + autopad = 1 + + if not autopad: + return b"".join(map(bytes, x)) + + curpos = self.curpos + s = b"" + for p in x: + d = p.alignment_delta(curpos) + curpos += d + if d == 1: + s += bytes(Pad1()) + elif d != 0: + s += bytes(PadN(optdata=b'\x00'*(d-2))) + pstr = bytes(p) + curpos += len(pstr) + s += pstr + + # Let's make the class including our option field + # a multiple of 8 octets long + d = curpos % 8 + if d == 0: + return s + d = 8 - d + if d == 1: + s += bytes(Pad1()) + elif d != 0: + s += bytes(PadN(optdata=b'\x00'*(d-2))) + + return s + + def addfield(self, pkt, s, val): + return s+self.i2m(pkt, val) + +class _PhantomAutoPadField(ByteField): + def addfield(self, pkt, s, val): + return s + + def getfield(self, pkt, s): + return s, 1 + + def i2repr(self, pkt, x): + if x: + return "On" + return "Off" + + +class IPv6ExtHdrHopByHop(_IPv6ExtHdr): + name = "IPv6 Extension Header - Hop-by-Hop Options Header" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + FieldLenField("len", None, length_of="options", fmt="B", + adjust = lambda pkt,x: (x+2+7)//8 - 1), + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _HopByHopOptionsField("options", [], HBHOptUnknown, 2, + length_from = lambda pkt: (8*(pkt.len+1))-2) ] + overload_fields = {IPv6: { "nh": 0 }} + + +######################## Destination Option Header ########################## + +class IPv6ExtHdrDestOpt(_IPv6ExtHdr): + name = "IPv6 Extension Header - Destination Options Header" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + FieldLenField("len", None, length_of="options", fmt="B", + adjust = lambda pkt,x: (x+2+7)//8 - 1), + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _HopByHopOptionsField("options", [], HBHOptUnknown, 2, + length_from = lambda pkt: (8*(pkt.len+1))-2) ] + overload_fields = {IPv6: { "nh": 60 }} + + +############################# Routing Header ################################ + +class IPv6ExtHdrRouting(_IPv6ExtHdr): + name = "IPv6 Option Header Routing" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + FieldLenField("len", None, count_of="addresses", fmt="B", + adjust = lambda pkt,x:2*x), # in 8 bytes blocks + ByteField("type", 0), + ByteField("segleft", None), + BitField("reserved", 0, 32), # There is meaning in this field ... + IP6ListField("addresses", [], + length_from = lambda pkt: 8*pkt.len)] + overload_fields = {IPv6: { "nh": 43 }} + + def post_build(self, pkt, pay): + if self.segleft is None: + pkt = pkt[:3]+struct.pack("B", len(self.addresses))+pkt[4:] + return _IPv6ExtHdr.post_build(self, pkt, pay) + +########################### Fragmentation Header ############################ + +class IPv6ExtHdrFragment(_IPv6ExtHdr): + name = "IPv6 Extension Header - Fragmentation header" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + BitField("res1", 0, 8), + BitField("offset", 0, 13), + BitField("res2", 0, 2), + BitField("m", 0, 1), + IntField("id", None) ] + overload_fields = {IPv6: { "nh": 44 }} + + +def defragment6(pktlist): + """ + Performs defragmentation of a list of IPv6 packets. Packets are reordered. + Crap is dropped. What lacks is completed by 'X' characters. + """ + + l = [ x for x in pktlist if IPv6ExtHdrFragment in x ] # remove non fragments + if not l: + return [] + + id = l[0][IPv6ExtHdrFragment].id + + llen = len(l) + l = [ x for x in l if x[IPv6ExtHdrFragment].id == id ] + if len(l) != llen: + warning("defragment6: some fragmented packets have been removed from list") + llen = len(l) + + # reorder fragments + i = 0 + res = [] + while l: + min_pos = 0 + min_offset = l[0][IPv6ExtHdrFragment].offset + for p in l: + cur_offset = p[IPv6ExtHdrFragment].offset + if cur_offset < min_offset: + min_pos = 0 + min_offset = cur_offset + res.append(l[min_pos]) + del(l[min_pos]) + + # regenerate the fragmentable part + fragmentable = b"" + for p in res: + q=p[IPv6ExtHdrFragment] + offset = 8*q.offset + if offset != len(fragmentable): + warning("Expected an offset of %d. Found %d. Padding with XXXX" % (len(fragmentable), offset)) + fragmentable += b"X"*(offset - len(fragmentable)) + fragmentable += bytes(q.payload) + + # Regenerate the unfragmentable part. + q = res[0] + nh = q[IPv6ExtHdrFragment].nh + q[IPv6ExtHdrFragment].underlayer.nh = nh + q[IPv6ExtHdrFragment].underlayer.payload = None + q /= conf.raw_layer(load=fragmentable) + + return IPv6(bytes(q)) + + +def fragment6(pkt, fragSize): + """ + Performs fragmentation of an IPv6 packet. Provided packet ('pkt') must already + contain an IPv6ExtHdrFragment() class. 'fragSize' argument is the expected + maximum size of fragments (MTU). The list of packets is returned. + + If packet does not contain an IPv6ExtHdrFragment class, it is returned in + result list. + """ + + pkt = pkt.copy() + + if not IPv6ExtHdrFragment in pkt: + # TODO : automatically add a fragment before upper Layer + # at the moment, we do nothing and return initial packet + # as single element of a list + return [pkt] + + # If the payload is bigger than 65535, a Jumbo payload must be used, as + # an IPv6 packet can't be bigger than 65535 bytes. + if len(bytes(pkt[IPv6ExtHdrFragment])) > 65535: + warning("An IPv6 packet can'be bigger than 65535, please use a Jumbo payload.") + return [] + + s = bytes(pkt) # for instantiation to get upper layer checksum right + + if len(s) <= fragSize: + return [pkt] + + # Fragmentable part : fake IPv6 for Fragmentable part length computation + fragPart = pkt[IPv6ExtHdrFragment].payload + tmp = bytes(IPv6(src="::1", dst="::1")/fragPart) + fragPartLen = len(tmp) - 40 # basic IPv6 header length + fragPartStr = s[-fragPartLen:] + + # Grab Next Header for use in Fragment Header + nh = IPv6(tmp[:40]).nh + + # Keep fragment header + fragHeader = pkt[IPv6ExtHdrFragment] + fragHeader.payload = None # detach payload + + # Unfragmentable Part + unfragPartLen = len(s) - fragPartLen - 8 + unfragPart = pkt + pkt[IPv6ExtHdrFragment].underlayer.payload = None # detach payload + + # Cut the fragmentable part to fit fragSize. Inner fragments have + # a length that is an integer multiple of 8 octets. last Frag MTU + # can be anything below MTU + lastFragSize = fragSize - unfragPartLen - 8 + innerFragSize = lastFragSize - (lastFragSize % 8) + + if lastFragSize <= 0 or innerFragSize == 0: + warning("Provided fragment size value is too low. " + + "Should be more than %d" % (unfragPartLen + 8)) + return [unfragPart/fragHeader/fragPart] + + remain = fragPartStr + res = [] + fragOffset = 0 # offset, incremeted during creation + fragId = random.randint(0,0xffffffff) # random id ... + if fragHeader.id is not None: # ... except id provided by user + fragId = fragHeader.id + fragHeader.m = 1 + fragHeader.id = fragId + fragHeader.nh = nh + + # Main loop : cut, fit to FRAGSIZEs, fragOffset, Id ... + while True: + if (len(remain) > lastFragSize): + tmp = remain[:innerFragSize] + remain = remain[innerFragSize:] + fragHeader.offset = fragOffset # update offset + fragOffset += (innerFragSize // 8) # compute new one + if IPv6 in unfragPart: + unfragPart[IPv6].plen = None + tempo = unfragPart/fragHeader/conf.raw_layer(load=tmp) + res.append(tempo) + else: + fragHeader.offset = fragOffset # update offSet + fragHeader.m = 0 + if IPv6 in unfragPart: + unfragPart[IPv6].plen = None + tempo = unfragPart/fragHeader/conf.raw_layer(load=remain) + res.append(tempo) + break + return res + + +############################### AH Header ################################### + +# class _AHFieldLenField(FieldLenField): +# def getfield(self, pkt, s): +# l = getattr(pkt, self.fld) +# l = (l*8)-self.shift +# i = self.m2i(pkt, s[:l]) +# return s[l:],i + +# class _AHICVStrLenField(StrLenField): +# def i2len(self, pkt, x): + + + +# class IPv6ExtHdrAH(_IPv6ExtHdr): +# name = "IPv6 Extension Header - AH" +# fields_desc = [ ByteEnumField("nh", 59, ipv6nh), +# _AHFieldLenField("len", None, "icv"), +# ShortField("res", 0), +# IntField("spi", 0), +# IntField("sn", 0), +# _AHICVStrLenField("icv", None, "len", shift=2) ] +# overload_fields = {IPv6: { "nh": 51 }} + +# def post_build(self, pkt, pay): +# if self.len is None: +# pkt = pkt[0]+struct.pack("!B", 2*len(self.addresses))+pkt[2:] +# if self.segleft is None: +# pkt = pkt[:3]+struct.pack("!B", len(self.addresses))+pkt[4:] +# return _IPv6ExtHdr.post_build(self, pkt, pay) + + +############################### ESP Header ################################## + +# class IPv6ExtHdrESP(_IPv6extHdr): +# name = "IPv6 Extension Header - ESP" +# fields_desc = [ IntField("spi", 0), +# IntField("sn", 0), +# # there is things to extract from IKE work +# ] +# overloads_fields = {IPv6: { "nh": 50 }} + + + +############################################################################# +############################################################################# +### ICMPv6* Classes ### +############################################################################# +############################################################################# + +icmp6typescls = { 1: "ICMPv6DestUnreach", + 2: "ICMPv6PacketTooBig", + 3: "ICMPv6TimeExceeded", + 4: "ICMPv6ParamProblem", + 128: "ICMPv6EchoRequest", + 129: "ICMPv6EchoReply", + 130: "ICMPv6MLQuery", + 131: "ICMPv6MLReport", + 132: "ICMPv6MLDone", + 133: "ICMPv6ND_RS", + 134: "ICMPv6ND_RA", + 135: "ICMPv6ND_NS", + 136: "ICMPv6ND_NA", + 137: "ICMPv6ND_Redirect", + #138: Do Me - RFC 2894 - Seems painful + 139: "ICMPv6NIQuery", + 140: "ICMPv6NIReply", + 141: "ICMPv6ND_INDSol", + 142: "ICMPv6ND_INDAdv", + #143: Do Me - RFC 3810 + 144: "ICMPv6HAADRequest", + 145: "ICMPv6HAADReply", + 146: "ICMPv6MPSol", + 147: "ICMPv6MPAdv", + #148: Do Me - SEND related - RFC 3971 + #149: Do Me - SEND related - RFC 3971 + 151: "ICMPv6MRD_Advertisement", + 152: "ICMPv6MRD_Solicitation", + 153: "ICMPv6MRD_Termination", + } + +icmp6typesminhdrlen = { 1: 8, + 2: 8, + 3: 8, + 4: 8, + 128: 8, + 129: 8, + 130: 24, + 131: 24, + 132: 24, + 133: 8, + 134: 16, + 135: 24, + 136: 24, + 137: 40, + #139: + #140 + 141: 8, + 142: 8, + 144: 8, + 145: 8, + 146: 8, + 147: 8, + 151: 8, + 152: 4, + 153: 4 + } + +icmp6types = { 1 : "Destination unreachable", + 2 : "Packet too big", + 3 : "Time exceeded", + 4 : "Parameter problem", + 100 : "Private Experimentation", + 101 : "Private Experimentation", + 128 : "Echo Request", + 129 : "Echo Reply", + 130 : "MLD Query", + 131 : "MLD Report", + 132 : "MLD Done", + 133 : "Router Solicitation", + 134 : "Router Advertisement", + 135 : "Neighbor Solicitation", + 136 : "Neighbor Advertisement", + 137 : "Redirect Message", + 138 : "Router Renumbering", + 139 : "ICMP Node Information Query", + 140 : "ICMP Node Information Response", + 141 : "Inverse Neighbor Discovery Solicitation Message", + 142 : "Inverse Neighbor Discovery Advertisement Message", + 143 : "Version 2 Multicast Listener Report", + 144 : "Home Agent Address Discovery Request Message", + 145 : "Home Agent Address Discovery Reply Message", + 146 : "Mobile Prefix Solicitation", + 147 : "Mobile Prefix Advertisement", + 148 : "Certification Path Solicitation", + 149 : "Certification Path Advertisement", + 151 : "Multicast Router Advertisement", + 152 : "Multicast Router Solicitation", + 153 : "Multicast Router Termination", + 200 : "Private Experimentation", + 201 : "Private Experimentation" } + + +class _ICMPv6(Packet): + name = "ICMPv6 dummy class" + overload_fields = {IPv6: {"nh": 58}} + def post_build(self, p, pay): + p += pay + if self.cksum == None: + chksum = in6_chksum(58, self.underlayer, p) + p = p[:2]+struct.pack("!H", chksum)+p[4:] + return p + + def hashret(self): + return self.payload.hashret() + + def answers(self, other): + # isinstance(self.underlayer, _IPv6ExtHdr) may introduce a bug ... + if (isinstance(self.underlayer, IPerror6) or + isinstance(self.underlayer, _IPv6ExtHdr) and + isinstance(other, _ICMPv6)): + if not ((self.type == other.type) and + (self.code == other.code)): + return 0 + return 1 + return 0 + + +class _ICMPv6Error(_ICMPv6): + name = "ICMPv6 errors dummy class" + def guess_payload_class(self,p): + return IPerror6 + +class ICMPv6Unknown(_ICMPv6): + name = "Scapy6 ICMPv6 fallback class" + fields_desc = [ ByteEnumField("type",1, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + StrField("msgbody", "")] + + +################################## RFC 2460 ################################# + +class ICMPv6DestUnreach(_ICMPv6Error): + name = "ICMPv6 Destination Unreachable" + fields_desc = [ ByteEnumField("type",1, icmp6types), + ByteEnumField("code",0, { 0: "No route to destination", + 1: "Communication with destination administratively prohibited", + 2: "Beyond scope of source address", + 3: "Address unreachable", + 4: "Port unreachable" }), + XShortField("cksum", None), + XIntField("unused",0x00000000)] + +class ICMPv6PacketTooBig(_ICMPv6Error): + name = "ICMPv6 Packet Too Big" + fields_desc = [ ByteEnumField("type",2, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + IntField("mtu",1280)] + +class ICMPv6TimeExceeded(_ICMPv6Error): + name = "ICMPv6 Time Exceeded" + fields_desc = [ ByteEnumField("type",3, icmp6types), + ByteEnumField("code",0, { 0: "hop limit exceeded in transit", + 1: "fragment reassembly time exceeded"}), + XShortField("cksum", None), + XIntField("unused",0x00000000)] + +# The default pointer value is set to the next header field of +# the encapsulated IPv6 packet +class ICMPv6ParamProblem(_ICMPv6Error): + name = "ICMPv6 Parameter Problem" + fields_desc = [ ByteEnumField("type",4, icmp6types), + ByteEnumField("code",0, {0: "erroneous header field encountered", + 1: "unrecognized Next Header type encountered", + 2: "unrecognized IPv6 option encountered"}), + XShortField("cksum", None), + IntField("ptr",6)] + +class ICMPv6EchoRequest(_ICMPv6): + name = "ICMPv6 Echo Request" + fields_desc = [ ByteEnumField("type", 128, icmp6types), + ByteField("code", 0), + XShortField("cksum", None), + XShortField("id",0), + XShortField("seq",0), + StrField("data", "")] + def mysummary(self): + return self.sprintf("%name% (id: %id% seq: %seq%)") + def hashret(self): + return struct.pack("HH",self.id,self.seq)+self.payload.hashret() + + +class ICMPv6EchoReply(ICMPv6EchoRequest): + name = "ICMPv6 Echo Reply" + type = 129 + def answers(self, other): + # We could match data content between request and reply. + return (isinstance(other, ICMPv6EchoRequest) and + self.id == other.id and self.seq == other.seq and + self.data == other.data) + + +############ ICMPv6 Multicast Listener Discovery (RFC3810) ################## + +# tous les messages MLD sont emis avec une adresse source lien-locale +# -> Y veiller dans le post_build si aucune n'est specifiee +# La valeur de Hop-Limit doit etre de 1 +# "and an IPv6 Router Alert option in a Hop-by-Hop Options +# header. (The router alert option is necessary to cause routers to +# examine MLD messages sent to multicast addresses in which the router +# itself has no interest" +class _ICMPv6ML(_ICMPv6): + fields_desc = [ ByteEnumField("type", 130, icmp6types), + ByteField("code", 0), + XShortField("cksum", None), + ShortField("mrd", 0), + ShortField("reserved", 0), + IP6Field("mladdr","::")] + +# general queries are sent to the link-scope all-nodes multicast +# address ff02::1, with a multicast address field of 0 and a MRD of +# [Query Response Interval] +# Default value for mladdr is set to 0 for a General Query, and +# overloaded by the user for a Multicast Address specific query +# TODO : See what we can do to automatically include a Router Alert +# Option in a Destination Option Header. +class ICMPv6MLQuery(_ICMPv6ML): # RFC 2710 + name = "MLD - Multicast Listener Query" + type = 130 + mrd = 10000 + mladdr = "::" # 10s for mrd + overload_fields = {IPv6: { "dst": "ff02::1", "hlim": 1, "nh": 58 }} + def hashret(self): + if self.mladdr != "::": + return struct.pack("HH",self.mladdr)+self.payload.hashret() + else: + return self.payload.hashret() + + +# TODO : See what we can do to automatically include a Router Alert +# Option in a Destination Option Header. +class ICMPv6MLReport(_ICMPv6ML): # RFC 2710 + name = "MLD - Multicast Listener Report" + type = 131 + overload_fields = {IPv6: {"hlim": 1, "nh": 58}} + # implementer le hashret et le answers + +# When a node ceases to listen to a multicast address on an interface, +# it SHOULD send a single Done message to the link-scope all-routers +# multicast address (FF02::2), carrying in its multicast address field +# the address to which it is ceasing to listen +# TODO : See what we can do to automatically include a Router Alert +# Option in a Destination Option Header. +class ICMPv6MLDone(_ICMPv6ML): # RFC 2710 + name = "MLD - Multicast Listener Done" + type = 132 + overload_fields = {IPv6: { "dst": "ff02::2", "hlim": 1, "nh": 58}} + + +########## ICMPv6 MRD - Multicast Router Discovery (RFC 4286) ############### + +# TODO: +# - 04/09/06 troglocan : find a way to automatically add a router alert +# option for all MRD packets. This could be done in a specific +# way when IPv6 is the under layer with some specific keyword +# like 'exthdr'. This would allow to keep compatibility with +# providing IPv6 fields to be overloaded in fields_desc. +# +# At the moment, if user inserts an IPv6 Router alert option +# none of the IPv6 default values of IPv6 layer will be set. + +class ICMPv6MRD_Advertisement(_ICMPv6): + name = "ICMPv6 Multicast Router Discovery Advertisement" + fields_desc = [ByteEnumField("type", 151, icmp6types), + ByteField("advinter", 20), + XShortField("cksum", None), + ShortField("queryint", 0), + ShortField("robustness", 0)] + overload_fields = {IPv6: { "nh": 58, "hlim": 1, "dst": "ff02::2"}} + # IPv6 Router Alert requires manual inclusion + def extract_padding(self, s): + return s[:8], s[8:] + +class ICMPv6MRD_Solicitation(_ICMPv6): + name = "ICMPv6 Multicast Router Discovery Solicitation" + fields_desc = [ByteEnumField("type", 152, icmp6types), + ByteField("res", 0), + XShortField("cksum", None) ] + overload_fields = {IPv6: { "nh": 58, "hlim": 1, "dst": "ff02::2"}} + # IPv6 Router Alert requires manual inclusion + def extract_padding(self, s): + return s[:4], s[4:] + +class ICMPv6MRD_Termination(_ICMPv6): + name = "ICMPv6 Multicast Router Discovery Termination" + fields_desc = [ByteEnumField("type", 153, icmp6types), + ByteField("res", 0), + XShortField("cksum", None) ] + overload_fields = {IPv6: { "nh": 58, "hlim": 1, "dst": "ff02::6A"}} + # IPv6 Router Alert requires manual inclusion + def extract_padding(self, s): + return s[:4], s[4:] + + +################### ICMPv6 Neighbor Discovery (RFC 2461) #################### + +icmp6ndopts = { 1: "Source Link-Layer Address", + 2: "Target Link-Layer Address", + 3: "Prefix Information", + 4: "Redirected Header", + 5: "MTU", + 6: "NBMA Shortcut Limit Option", # RFC2491 + 7: "Advertisement Interval Option", + 8: "Home Agent Information Option", + 9: "Source Address List", + 10: "Target Address List", + 11: "CGA Option", # RFC 3971 + 12: "RSA Signature Option", # RFC 3971 + 13: "Timestamp Option", # RFC 3971 + 14: "Nonce option", # RFC 3971 + 15: "Trust Anchor Option", # RFC 3971 + 16: "Certificate Option", # RFC 3971 + 17: "IP Address Option", # RFC 4068 + 18: "New Router Prefix Information Option", # RFC 4068 + 19: "Link-layer Address Option", # RFC 4068 + 20: "Neighbor Advertisement Acknowledgement Option", + 21: "CARD Request Option", # RFC 4065/4066/4067 + 22: "CARD Reply Option", # RFC 4065/4066/4067 + 23: "MAP Option", # RFC 4140 + 24: "Route Information Option", # RFC 4191 + 25: "Recusive DNS Server Option", + 26: "IPv6 Router Advertisement Flags Option" + } + +icmp6ndoptscls = { 1: "ICMPv6NDOptSrcLLAddr", + 2: "ICMPv6NDOptDstLLAddr", + 3: "ICMPv6NDOptPrefixInfo", + 4: "ICMPv6NDOptRedirectedHdr", + 5: "ICMPv6NDOptMTU", + 6: "ICMPv6NDOptShortcutLimit", + 7: "ICMPv6NDOptAdvInterval", + 8: "ICMPv6NDOptHAInfo", + 9: "ICMPv6NDOptSrcAddrList", + 10: "ICMPv6NDOptTgtAddrList", + #11: Do Me, + #12: Do Me, + #13: Do Me, + #14: Do Me, + #15: Do Me, + #16: Do Me, + 17: "ICMPv6NDOptIPAddr", + 18: "ICMPv6NDOptNewRtrPrefix", + 19: "ICMPv6NDOptLLA", + #18: Do Me, + #19: Do Me, + #20: Do Me, + #21: Do Me, + #22: Do Me, + 23: "ICMPv6NDOptMAP", + 24: "ICMPv6NDOptRouteInfo", + 25: "ICMPv6NDOptRDNSS", + 26: "ICMPv6NDOptEFA" + } + +class _ICMPv6NDGuessPayload: + name = "Dummy ND class that implements guess_payload_class()" + def guess_payload_class(self,p): + if len(p) > 1: + #return get_cls(icmp6ndoptscls.get(ord(p[0]),"Raw"), "Raw") # s/Raw/ICMPv6NDOptUnknown/g ? + return get_cls(icmp6ndoptscls.get(p[0],"Raw"), "Raw") # s/Raw/ICMPv6NDOptUnknown/g ? + + +# Beginning of ICMPv6 Neighbor Discovery Options. + +class ICMPv6NDOptUnknown(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery Option - Scapy Unimplemented" + fields_desc = [ ByteField("type",None), + FieldLenField("len",None,length_of="data",fmt="B", + adjust = lambda pkt,x: x+2), + StrLenField("data","", + length_from = lambda pkt: pkt.len-2) ] + +# NOTE: len includes type and len field. Expressed in unit of 8 bytes +# TODO: Revoir le coup du ETHER_ANY +class ICMPv6NDOptSrcLLAddr(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery Option - Source Link-Layer Address" + fields_desc = [ ByteField("type", 1), + ByteField("len", 1), + MACField("lladdr", ETHER_ANY) ] + def mysummary(self): + return self.sprintf("%name% %lladdr%") + +class ICMPv6NDOptDstLLAddr(ICMPv6NDOptSrcLLAddr): + name = "ICMPv6 Neighbor Discovery Option - Destination Link-Layer Address" + type = 2 + +class ICMPv6NDOptPrefixInfo(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery Option - Prefix Information" + fields_desc = [ ByteField("type",3), + ByteField("len",4), + ByteField("prefixlen",None), + BitField("L",1,1), + BitField("A",1,1), + BitField("R",0,1), + BitField("res1",0,5), + XIntField("validlifetime",0xffffffff), + XIntField("preferredlifetime",0xffffffff), + XIntField("res2",0x00000000), + IP6Field("prefix","::") ] + def mysummary(self): + return self.sprintf("%name% %prefix%") + +# TODO: We should also limit the size of included packet to something +# like (initiallen - 40 - 2) +class TruncPktLenField(PacketLenField): + + def __init__(self, name, default, cls, cur_shift, length_from=None, shift=0): + PacketLenField.__init__(self, name, default, cls, length_from=length_from) + self.cur_shift = cur_shift + + def getfield(self, pkt, s): + l = self.length_from(pkt) + i = self.m2i(pkt, s[:l]) + return s[l:],i + + def m2i(self, pkt, m): + s = None + try: # It can happen we have sth shorter than 40 bytes + s = self.cls(m) + except: + return conf.raw_layer(m) + return s + + def i2m(self, pkt, x): + s = bytes(x) + l = len(s) + r = (l + self.cur_shift) % 8 + l = l - r + return s[:l] + + def i2len(self, pkt, i): + return len(self.i2m(pkt, i)) + + +# Faire un post_build pour le recalcul de la taille (en multiple de 8 octets) +class ICMPv6NDOptRedirectedHdr(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery Option - Redirected Header" + fields_desc = [ ByteField("type",4), + FieldLenField("len", None, length_of="pkt", fmt="B", + adjust = lambda pkt,x:(x+8)//8), + StrFixedLenField("res", b"\x00"*6, 6), + TruncPktLenField("pkt", b"", IPv6, 8, + length_from = lambda pkt: 8*pkt.len-8) ] + +# See which value should be used for default MTU instead of 1280 +class ICMPv6NDOptMTU(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery Option - MTU" + fields_desc = [ ByteField("type",5), + ByteField("len",1), + XShortField("res",0), + IntField("mtu",1280)] + +class ICMPv6NDOptShortcutLimit(_ICMPv6NDGuessPayload, Packet): # RFC 2491 + name = "ICMPv6 Neighbor Discovery Option - NBMA Shortcut Limit" + fields_desc = [ ByteField("type", 6), + ByteField("len", 1), + ByteField("shortcutlim", 40), # XXX + ByteField("res1", 0), + IntField("res2", 0) ] + +class ICMPv6NDOptAdvInterval(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery - Interval Advertisement" + fields_desc = [ ByteField("type",7), + ByteField("len",1), + ShortField("res", 0), + IntField("advint", 0) ] + def mysummary(self): + return self.sprintf("%name% %advint% milliseconds") + +class ICMPv6NDOptHAInfo(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Neighbor Discovery - Home Agent Information" + fields_desc = [ ByteField("type",8), + ByteField("len",1), + ShortField("res", 0), + ShortField("pref", 0), + ShortField("lifetime", 1)] + def mysummary(self): + return self.sprintf("%name% %pref% %lifetime% seconds") + +# type 9 : See ICMPv6NDOptSrcAddrList class below in IND (RFC 3122) support + +# type 10 : See ICMPv6NDOptTgtAddrList class below in IND (RFC 3122) support + +class ICMPv6NDOptIPAddr(_ICMPv6NDGuessPayload, Packet): # RFC 4068 + name = "ICMPv6 Neighbor Discovery - IP Address Option (FH for MIPv6)" + fields_desc = [ ByteField("type",17), + ByteField("len", 3), + ByteEnumField("optcode", 1, {1: "Old Care-Of Address", + 2: "New Care-Of Address", + 3: "NAR's IP address" }), + ByteField("plen", 64), + IntField("res", 0), + IP6Field("addr", "::") ] + +class ICMPv6NDOptNewRtrPrefix(_ICMPv6NDGuessPayload, Packet): # RFC 4068 + name = "ICMPv6 Neighbor Discovery - New Router Prefix Information Option (FH for MIPv6)" + fields_desc = [ ByteField("type",18), + ByteField("len", 3), + ByteField("optcode", 0), + ByteField("plen", 64), + IntField("res", 0), + IP6Field("prefix", "::") ] + +_rfc4068_lla_optcode = {0: "Wildcard requesting resolution for all nearby AP", + 1: "LLA for the new AP", + 2: "LLA of the MN", + 3: "LLA of the NAR", + 4: "LLA of the src of TrSolPr or PrRtAdv msg", + 5: "AP identified by LLA belongs to current iface of router", + 6: "No preifx info available for AP identified by the LLA", + 7: "No fast handovers support for AP identified by the LLA" } + +class ICMPv6NDOptLLA(_ICMPv6NDGuessPayload, Packet): # RFC 4068 + name = "ICMPv6 Neighbor Discovery - Link-Layer Address (LLA) Option (FH for MIPv6)" + fields_desc = [ ByteField("type", 19), + ByteField("len", 1), + ByteEnumField("optcode", 0, _rfc4068_lla_optcode), + MACField("lla", ETHER_ANY) ] # We only support ethernet + +class ICMPv6NDOptMAP(_ICMPv6NDGuessPayload, Packet): # RFC 4140 + name = "ICMPv6 Neighbor Discovery - MAP Option" + fields_desc = [ ByteField("type", 23), + ByteField("len", 3), + BitField("dist", 1, 4), + BitField("pref", 15, 4), # highest availability + BitField("R", 1, 1), + BitField("res", 0, 7), + IntField("validlifetime", 0xffffffff), + IP6Field("addr", "::") ] + + +class IP6PrefixField(IP6Field): + def __init__(self, name, default): + IP6Field.__init__(self, name, default) + self.length_from = lambda pkt: 8*(pkt.len - 1) + + def addfield(self, pkt, s, val): + return s + self.i2m(pkt, val) + + def getfield(self, pkt, s): + l = self.length_from(pkt) + p = s[:l] + if l < 16: + p += b'\x00'*(16-l) + return s[l:], self.m2i(pkt,p) + + def i2len(self, pkt, x): + return len(self.i2m(pkt, x)) + + def i2m(self, pkt, x): + l = pkt.len + + if x is None: + x = "::" + if l is None: + l = 1 + x = inet_pton(socket.AF_INET6, x) + + if l is None: + return x + if l in [0, 1]: + return b"" + if l in [2, 3]: + return x[:8*(l-1)] + + return x + b'\x00'*8*(l-3) + +class ICMPv6NDOptRouteInfo(_ICMPv6NDGuessPayload, Packet): # RFC 4191 + name = "ICMPv6 Neighbor Discovery Option - Route Information Option" + fields_desc = [ ByteField("type",24), + FieldLenField("len", None, length_of="prefix", fmt="B", + adjust = lambda pkt,x: x//8 + 1), + ByteField("plen", None), + BitField("res1",0,3), + BitField("prf",0,2), + BitField("res2",0,3), + IntField("rtlifetime", 0xffffffff), + IP6PrefixField("prefix", None) ] + +class ICMPv6NDOptRDNSS(_ICMPv6NDGuessPayload, Packet): # RFC 5006 + name = "ICMPv6 Neighbor Discovery Option - Recursive DNS Server Option" + fields_desc = [ ByteField("type", 25), + FieldLenField("len", None, count_of="dns", fmt="B", + adjust = lambda pkt,x: 2*x+1), + ShortField("res", None), + IntField("lifetime", 0xffffffff), + IP6ListField("dns", [], + length_from = lambda pkt: 8*(pkt.len-1)) ] + +class ICMPv6NDOptEFA(_ICMPv6NDGuessPayload, Packet): # RFC 5175 (prev. 5075) + name = "ICMPv6 Neighbor Discovery Option - Expanded Flags Option" + fields_desc = [ ByteField("type", 26), + ByteField("len", 1), + BitField("res", 0, 48) ] + +# End of ICMPv6 Neighbor Discovery Options. + +class ICMPv6ND_RS(_ICMPv6NDGuessPayload, _ICMPv6): + name = "ICMPv6 Neighbor Discovery - Router Solicitation" + fields_desc = [ ByteEnumField("type", 133, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + IntField("res",0) ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::2", "hlim": 255 }} + +class ICMPv6ND_RA(_ICMPv6NDGuessPayload, _ICMPv6): + name = "ICMPv6 Neighbor Discovery - Router Advertisement" + fields_desc = [ ByteEnumField("type", 134, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + ByteField("chlim",0), + BitField("M",0,1), + BitField("O",0,1), + BitField("H",0,1), + BitEnumField("prf",1,2, { 0: "Medium (default)", + 1: "High", + 2: "Reserved", + 3: "Low" } ), # RFC 4191 + BitField("P",0,1), + BitField("res",0,2), + ShortField("routerlifetime",1800), + IntField("reachabletime",0), + IntField("retranstimer",0) ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::1", "hlim": 255 }} + + def answers(self, other): + return isinstance(other, ICMPv6ND_RS) + +class ICMPv6ND_NS(_ICMPv6NDGuessPayload, _ICMPv6, Packet): + name = "ICMPv6 Neighbor Discovery - Neighbor Solicitation" + fields_desc = [ ByteEnumField("type",135, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + IntField("res", 0), + IP6Field("tgt","::") ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::1", "hlim": 255 }} + + def mysummary(self): + return self.sprintf("%name% (tgt: %tgt%)") + + def hashret(self): + return self.getbyteval("tgt")+self.payload.hashret() + +class ICMPv6ND_NA(_ICMPv6NDGuessPayload, _ICMPv6, Packet): + name = "ICMPv6 Neighbor Discovery - Neighbor Advertisement" + fields_desc = [ ByteEnumField("type",136, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + BitField("R",1,1), + BitField("S",0,1), + BitField("O",1,1), + XBitField("res",0,29), + IP6Field("tgt","::") ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::1", "hlim": 255 }} + + def mysummary(self): + return self.sprintf("%name% (tgt: %tgt%)") + + def hashret(self): + return self.getbyteval("tgt")+self.payload.hashret() + + def answers(self, other): + return isinstance(other, ICMPv6ND_NS) and self.tgt == other.tgt + +# associated possible options : target link-layer option, Redirected header +class ICMPv6ND_Redirect(_ICMPv6NDGuessPayload, _ICMPv6, Packet): + name = "ICMPv6 Neighbor Discovery - Redirect" + fields_desc = [ ByteEnumField("type",137, icmp6types), + ByteField("code",0), + XShortField("cksum", None), + XIntField("res",0), + IP6Field("tgt","::"), + IP6Field("dst","::") ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::1", "hlim": 255 }} + + + +################ ICMPv6 Inverse Neighbor Discovery (RFC 3122) ############### + +class ICMPv6NDOptSrcAddrList(_ICMPv6NDGuessPayload, Packet): + name = "ICMPv6 Inverse Neighbor Discovery Option - Source Address List" + fields_desc = [ ByteField("type",9), + FieldLenField("len", None, count_of="addrlist", fmt="B", + adjust = lambda pkt,x: 2*x+1), + StrFixedLenField("res", "\x00"*6, 6), + IP6ListField("addrlist", [], + length_from = lambda pkt: 8*(pkt.len-1)) ] + +class ICMPv6NDOptTgtAddrList(ICMPv6NDOptSrcAddrList): + name = "ICMPv6 Inverse Neighbor Discovery Option - Target Address List" + type = 10 + + +# RFC3122 +# Options requises : source lladdr et target lladdr +# Autres options valides : source address list, MTU +# - Comme precise dans le document, il serait bien de prendre l'adresse L2 +# demandee dans l'option requise target lladdr et l'utiliser au niveau +# de l'adresse destination ethernet si aucune adresse n'est precisee +# - ca semble pas forcement pratique si l'utilisateur doit preciser toutes +# les options. +# Ether() must use the target lladdr as destination +class ICMPv6ND_INDSol(_ICMPv6NDGuessPayload, _ICMPv6): + name = "ICMPv6 Inverse Neighbor Discovery Solicitation" + fields_desc = [ ByteEnumField("type",141, icmp6types), + ByteField("code",0), + XShortField("cksum",None), + XIntField("reserved",0) ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::1", "hlim": 255 }} + +# Options requises : target lladdr, target address list +# Autres options valides : MTU +class ICMPv6ND_INDAdv(_ICMPv6NDGuessPayload, _ICMPv6): + name = "ICMPv6 Inverse Neighbor Discovery Advertisement" + fields_desc = [ ByteEnumField("type",142, icmp6types), + ByteField("code",0), + XShortField("cksum",None), + XIntField("reserved",0) ] + overload_fields = {IPv6: { "nh": 58, "dst": "ff02::1", "hlim": 255 }} + + +############################################################################### +# ICMPv6 Node Information Queries (RFC 4620) +############################################################################### + +# [ ] Add automatic destination address computation using computeNIGroupAddr +# in IPv6 class (Scapy6 modification when integrated) if : +# - it is not provided +# - upper layer is ICMPv6NIQueryName() with a valid value +# [ ] Try to be liberal in what we accept as internal values for _explicit_ +# DNS elements provided by users. Any string should be considered +# valid and kept like it has been provided. At the moment, i2repr() will +# crash on many inputs +# [ ] Do the documentation +# [ ] Add regression tests +# [ ] Perform test against real machines (NOOP reply is proof of implementation). +# [ ] Check if there are differences between different stacks. Among *BSD, +# with others. +# [ ] Deal with flags in a consistent way. +# [ ] Implement compression in names2dnsrepr() and decompresiion in +# dnsrepr2names(). Should be deactivable. + +icmp6_niqtypes = { 0: "NOOP", + 2: "Node Name", + 3: "IPv6 Address", + 4: "IPv4 Address" } + + +class _ICMPv6NIHashret: + def hashret(self): + return self.nonce + +class _ICMPv6NIAnswers: + def answers(self, other): + return self.nonce == other.nonce + +# Buggy; always returns the same value during a session +class NonceField(StrFixedLenField): + def __init__(self, name, default=None): + StrFixedLenField.__init__(self, name, default, 8) + if default is None: + self.default = self.randval() + +# Compute the NI group Address. Can take a FQDN as input parameter +def computeNIGroupAddr(name): + import md5 + name = name.lower().split(".")[0] + record = chr(len(name))+name + h = md5.new(record) + h = h.digest() + addr = "ff02::2:%2x%2x:%2x%2x" % struct.unpack("BBBB", h[:4]) + return addr + + +# Here is the deal. First, that protocol is a piece of shit. Then, we +# provide 4 classes for the different kinds of Requests (one for every +# valid qtype: NOOP, Node Name, IPv6@, IPv4@). They all share the same +# data field class that is made to be smart by guessing the specifc +# type of value provided : +# +# - IPv6 if acceptable for inet_pton(AF_INET6, ): code is set to 0, +# if not overriden by user +# - IPv4 if acceptable for inet_pton(AF_INET, ): code is set to 2, +# if not overriden +# - Name in the other cases: code is set to 0, if not overriden by user +# +# Internal storage, is not only the value, but the a pair providing +# the type and the value (1 is IPv6@, 1 is Name or string, 2 is IPv4@) +# +# Note : I merged getfield() and m2i(). m2i() should not be called +# directly anyway. Same remark for addfield() and i2m() +# +# -- arno + +# "The type of information present in the Data field of a query is +# declared by the ICMP Code, whereas the type of information in a +# Reply is determined by the Qtype" + +def names2dnsrepr(x): + """ + Take as input a list of DNS names or a single DNS name + and encode it in DNS format (with possible compression) + If a string that is already a DNS name in DNS format + is passed, it is returned unmodified. Result is a string. + !!! At the moment, compression is not implemented !!! + """ + + if type(x) is str: + if x and x[-1] == '\x00': # stupid heuristic + return x.encode('ascii') + x = [x.encode('ascii')] + elif type(x) is bytes: + if x and x[-1] == 0: + return x + x = [x] + + res = [] + for n in x: + if type(n) is str: + n = n.encode('ascii') + termin = b"\x00" + if n.count(b'.') == 0: # single-component gets one more + termin += bytes([0]) + n = b"".join(map(lambda y: chr(len(y)).encode('ascii')+y, n.split(b"."))) + termin + res.append(n) + return b"".join(res) + + +def dnsrepr2names(x): + """ + Take as input a DNS encoded string (possibly compressed) + and returns a list of DNS names contained in it. + If provided string is already in printable format + (does not end with a null character, a one element list + is returned). Result is a list. + """ + res = [] + cur = b"" + if type(x) is str: + x = x.encode('ascii') + while x: + #l = ord(x[0]) + l = x[0] + x = x[1:] + if l == 0: + if cur and cur[-1] == ord('.'): + cur = cur[:-1] + res.append(cur) + cur = b"" + #if x and ord(x[0]) == 0: # single component + if x and x[0] == 0: # single component + x = x[1:] + continue + if l & 0xc0: # XXX TODO : work on that -- arno + raise Exception("DNS message can't be compressed at this point!") + else: + cur += x[:l]+b"." + x = x[l:] + return res + + +class NIQueryDataField(StrField): + def __init__(self, name, default): + StrField.__init__(self, name, default) + + def i2h(self, pkt, x): + if x is None: + return x + t,val = x + if t == 1: + val = dnsrepr2names(val)[0] + return val + + def h2i(self, pkt, x): + if x is tuple and type(x[0]) is int: + return x + + val = None + try: # Try IPv6 + inet_pton(socket.AF_INET6, x) + val = (0, x) + except: + try: # Try IPv4 + inet_pton(socket.AF_INET, x) + val = (2, x) + except: # Try DNS + if x is None: + x = b"" + x = names2dnsrepr(x) + val = (1, x) + return val + + def i2repr(self, pkt, x): + t,val = x + if t == 1: # DNS Name + # we don't use dnsrepr2names() to deal with + # possible weird data extracted info + res = [] + weird = None + while val: + #l = ord(val[0]) + l = val[0] + val = val[1:] + if l == 0: + if (len(res) > 1 and val): # fqdn with data behind + weird = val + elif len(val) > 1: # single label with data behind + weird = val[1:] + break + res.append(val[:l]+".") + val = val[l:] + tmp = "".join(res) + if tmp and tmp[-1] == '.': + tmp = tmp[:-1] + return tmp + return repr(val) + + def getfield(self, pkt, s): + qtype = getattr(pkt, "qtype") + if qtype == 0: # NOOP + return s, (0, b"") + else: + code = getattr(pkt, "code") + if code == 0: # IPv6 Addr + return s[16:], (0, inet_ntop(socket.AF_INET6, s[:16])) + elif code == 2: # IPv4 Addr + return s[4:], (2, inet_ntop(socket.AF_INET, s[:4])) + else: # Name or Unknown + return b"", (1, s) + + def addfield(self, pkt, s, val): + if ((type(val) is tuple and val[1] is None) or + val is None): + val = (1, b"") + t = val[0] + if t == 1: + if type(val[1]) is str: + tmp = val[1].encode('ascii') + else: + tmp = val[1] + return s + tmp + elif t == 0: + return s + inet_pton(socket.AF_INET6, val[1]) + else: + return s + inet_pton(socket.AF_INET, val[1]) + +class NIQueryCodeField(ByteEnumField): + def i2m(self, pkt, x): + if x is None: + d = pkt.getfieldval("data") + if d is None: + return 1 + elif d[0] == 0: # IPv6 address + return 0 + elif d[0] == 1: # Name + return 1 + elif d[0] == 2: # IPv4 address + return 2 + else: + return 1 + return x + + +_niquery_code = {0: "IPv6 Query", 1: "Name Query", 2: "IPv4 Query"} + +#_niquery_flags = { 2: "All unicast addresses", 4: "IPv4 addresses", +# 8: "Link-local addresses", 16: "Site-local addresses", +# 32: "Global addresses" } + +# "This NI type has no defined flags and never has a Data Field". Used +# to know if the destination is up and implements NI protocol. +class ICMPv6NIQueryNOOP(_ICMPv6NIHashret, _ICMPv6): + name = "ICMPv6 Node Information Query - NOOP Query" + fields_desc = [ ByteEnumField("type", 139, icmp6types), + NIQueryCodeField("code", None, _niquery_code), + XShortField("cksum", None), + ShortEnumField("qtype", 0, icmp6_niqtypes), + BitField("unused", 0, 10), + FlagsField("flags", 0, 6, "TACLSG"), + NonceField("nonce", None), + NIQueryDataField("data", None) ] + +class ICMPv6NIQueryName(ICMPv6NIQueryNOOP): + name = "ICMPv6 Node Information Query - IPv6 Name Query" + qtype = 2 + +# We ask for the IPv6 address of the peer +class ICMPv6NIQueryIPv6(ICMPv6NIQueryNOOP): + name = "ICMPv6 Node Information Query - IPv6 Address Query" + qtype = 3 + flags = 0x3E + +class ICMPv6NIQueryIPv4(ICMPv6NIQueryNOOP): + name = "ICMPv6 Node Information Query - IPv4 Address Query" + qtype = 4 + +_nireply_code = { 0: "Successful Reply", + 1: "Response Refusal", + 3: "Unknown query type" } + +_nireply_flags = { 1: "Reply set incomplete", + 2: "All unicast addresses", + 4: "IPv4 addresses", + 8: "Link-local addresses", + 16: "Site-local addresses", + 32: "Global addresses" } + +# Internal repr is one of those : +# (0, "some string") : unknow qtype value are mapped to that one +# (3, [ (ttl, ip6), ... ]) +# (4, [ (ttl, ip4), ... ]) +# (2, [ttl, dns_names]) : dns_names is one string that contains +# all the DNS names. Internally it is kept ready to be sent +# (undissected). i2repr() decode it for user. This is to +# make build after dissection bijective. +# +# I also merged getfield() and m2i(), and addfield() and i2m(). +class NIReplyDataField(StrField): + + def i2h(self, pkt, x): + if x is None: + return x + t,val = x + if t == 2: + ttl, dnsnames = val + val = [ttl] + dnsrepr2names(dnsnames) + return val + + def h2i(self, pkt, x): + qtype = 0 # We will decode it as string if not + # overridden through 'qtype' in pkt + + # No user hint, let's use 'qtype' value for that purpose + if type(x) is not tuple: + if pkt is not None: + qtype = getattr(pkt, "qtype") + else: + qtype = x[0] + x = x[1] + + # From that point on, x is the value (second element of the tuple) + + if qtype == 2: # DNS name + if type(x) is str: # listify the string + x = x.encode('ascii') + x = [x] + elif type(x) is bytes: + x = [x] + if type(x) is list and x and type(x[0]) is not int: # ttl was omitted : use 0 + x = [0] + x + ttl = x[0] + names = x[1:] + return (2, [ttl, names2dnsrepr(names)]) + + elif qtype in [3, 4]: # IPv4 or IPv6 addr + if type(x) is str or type(x) is bytes: + x = [x] # User directly provided an IP, instead of list + + # List elements are not tuples, user probably + # omitted ttl value : we will use 0 instead + def addttl(x): + if type(x) is str or type(x) is bytes: + return (0, x) + return x + + return (qtype, list(map(addttl, x))) + + return (qtype, x) + + + def addfield(self, pkt, s, val): + t,tmp = val + if tmp is None: + tmp = b"" + if t == 2: + ttl,dnsstr = tmp + return s+ struct.pack("!I", ttl) + dnsstr + elif t == 3: + #return s + "".join(map(lambda (x,y): struct.pack("!I", x)+inet_pton(socket.AF_INET6, y), tmp)) + return s + b"".join(map(lambda a: struct.pack("!I", a[0])+inet_pton(socket.AF_INET6, a[1]), tmp)) + elif t == 4: + #return s + "".join(map(lambda (x,y): struct.pack("!I", x)+inet_pton(socket.AF_INET, y), tmp)) + return s + b"".join(map(lambda a: struct.pack("!I", a[0])+inet_pton(socket.AF_INET, a[1]), tmp)) + else: + return s + tmp + + def getfield(self, pkt, s): + code = getattr(pkt, "code") + if code != 0: + return s, (0, b"") + + qtype = getattr(pkt, "qtype") + if qtype == 0: # NOOP + return s, (0, b"") + + elif qtype == 2: + if len(s) < 4: + return s, (0, b"") + ttl = struct.unpack("!I", s[:4])[0] + return b"", (2, [ttl, s[4:]]) + + elif qtype == 3: # IPv6 addresses with TTLs + # XXX TODO : get the real length + res = [] + while len(s) >= 20: # 4 + 16 + ttl = struct.unpack("!I", s[:4])[0] + ip = inet_ntop(socket.AF_INET6, s[4:20]) + res.append((ttl, ip)) + s = s[20:] + return s, (3, res) + + elif qtype == 4: # IPv4 addresses with TTLs + # XXX TODO : get the real length + res = [] + while len(s) >= 8: # 4 + 4 + ttl = struct.unpack("!I", s[:4])[0] + ip = inet_ntop(socket.AF_INET, s[4:8]) + res.append((ttl, ip)) + s = s[8:] + return s, (4, res) + else: + # XXX TODO : implement me and deal with real length + return b"", (0, s) + + def i2repr(self, pkt, x): + if x is None: + return "[]" + + if type(x) is tuple and len(x) == 2: + t, val = x + if t == 2: # DNS names + ttl,l = val + l = dnsrepr2names(l) + return "ttl:%d %s" % (ttl, ", ".join(l)) + elif t == 3 or t == 4: + #return "[ %s ]" % (", ".join(map(lambda (x,y): "(%d, %s)" % (x, y), val))) + return "[ %s ]" % (", ".join(map(lambda a: "(%d, %s)" % a, val))) + return repr(val) + return repr(x) # XXX should not happen + +# By default, sent responses have code set to 0 (successful) +class ICMPv6NIReplyNOOP(_ICMPv6NIAnswers, _ICMPv6NIHashret, _ICMPv6): + name = "ICMPv6 Node Information Reply - NOOP Reply" + fields_desc = [ ByteEnumField("type", 140, icmp6types), + ByteEnumField("code", 0, _nireply_code), + XShortField("cksum", None), + ShortEnumField("qtype", 0, icmp6_niqtypes), + BitField("unused", 0, 10), + FlagsField("flags", 0, 6, "TACLSG"), + NonceField("nonce", None), + NIReplyDataField("data", None)] + +class ICMPv6NIReplyName(ICMPv6NIReplyNOOP): + name = "ICMPv6 Node Information Reply - Node Names" + qtype = 2 + +class ICMPv6NIReplyIPv6(ICMPv6NIReplyNOOP): + name = "ICMPv6 Node Information Reply - IPv6 addresses" + qtype = 3 + +class ICMPv6NIReplyIPv4(ICMPv6NIReplyNOOP): + name = "ICMPv6 Node Information Reply - IPv4 addresses" + qtype = 4 + +class ICMPv6NIReplyRefuse(ICMPv6NIReplyNOOP): + name = "ICMPv6 Node Information Reply - Responder refuses to supply answer" + code = 1 + +class ICMPv6NIReplyUnknown(ICMPv6NIReplyNOOP): + name = "ICMPv6 Node Information Reply - Qtype unknown to the responder" + code = 2 + + +def _niquery_guesser(p): + cls = conf.raw_layer + #type = ord(p[0]) + type = p[0] + if type == 139: # Node Info Query specific stuff + if len(p) > 6: + qtype, = struct.unpack("!H", p[4:6]) + cls = { 0: ICMPv6NIQueryNOOP, + 2: ICMPv6NIQueryName, + 3: ICMPv6NIQueryIPv6, + 4: ICMPv6NIQueryIPv4 }.get(qtype, conf.raw_layer) + elif type == 140: # Node Info Reply specific stuff + #code = ord(p[1]) + code = p[1] + if code == 0: + if len(p) > 6: + qtype, = struct.unpack("!H", p[4:6]) + cls = { 2: ICMPv6NIReplyName, + 3: ICMPv6NIReplyIPv6, + 4: ICMPv6NIReplyIPv4 }.get(qtype, ICMPv6NIReplyNOOP) + elif code == 1: + cls = ICMPv6NIReplyRefuse + elif code == 2: + cls = ICMPv6NIReplyUnknown + return cls + + +############################################################################# +############################################################################# +### Mobile IPv6 (RFC 3775) and Nemo (RFC 3963) ### +############################################################################# +############################################################################# + +# Mobile IPv6 ICMPv6 related classes + +class ICMPv6HAADRequest(_ICMPv6): + name = 'ICMPv6 Home Agent Address Discovery Request' + fields_desc = [ ByteEnumField("type", 144, icmp6types), + ByteField("code", 0), + XShortField("cksum", None), + XShortField("id", None), + BitEnumField("R", 1, 1, {1: 'MR'}), + XBitField("res", 0, 15) ] + def hashret(self): + return struct.pack("!H",self.id)+self.payload.hashret() + +class ICMPv6HAADReply(_ICMPv6): + name = 'ICMPv6 Home Agent Address Discovery Reply' + fields_desc = [ ByteEnumField("type", 145, icmp6types), + ByteField("code", 0), + XShortField("cksum", None), + XShortField("id", None), + BitEnumField("R", 1, 1, {1: 'MR'}), + XBitField("res", 0, 15), + IP6ListField('addresses', None) ] + def hashret(self): + return struct.pack("!H",self.id)+self.payload.hashret() + + def answers(self, other): + if not isinstance(other, ICMPv6HAADRequest): + return 0 + return self.id == other.id + +class ICMPv6MPSol(_ICMPv6): + name = 'ICMPv6 Mobile Prefix Solicitation' + fields_desc = [ ByteEnumField("type", 146, icmp6types), + ByteField("code", 0), + XShortField("cksum", None), + XShortField("id", None), + XShortField("res", 0) ] + def _hashret(self): + return struct.pack("!H",self.id) + +class ICMPv6MPAdv(_ICMPv6NDGuessPayload, _ICMPv6): + name = 'ICMPv6 Mobile Prefix Advertisement' + fields_desc = [ ByteEnumField("type", 147, icmp6types), + ByteField("code", 0), + XShortField("cksum", None), + XShortField("id", None), + BitEnumField("flags", 2, 2, {2: 'M', 1:'O'}), + XBitField("res", 0, 14) ] + def hashret(self): + return struct.pack("!H",self.id) + + def answers(self, other): + return isinstance(other, ICMPv6MPSol) + +# Mobile IPv6 Options classes + + +_mobopttypes = { 2: "Binding Refresh Advice", + 3: "Alternate Care-of Address", + 4: "Nonce Indices", + 5: "Binding Authorization Data", + 6: "Mobile Network Prefix (RFC3963)", + 7: "Link-Layer Address (RFC4068)", + 8: "Mobile Node Identifier (RFC4283)", + 9: "Mobility Message Authentication (RFC4285)", + 10: "Replay Protection (RFC4285)", + 11: "CGA Parameters Request (RFC4866)", + 12: "CGA Parameters (RFC4866)", + 13: "Signature (RFC4866)", + 14: "Home Keygen Token (RFC4866)", + 15: "Care-of Test Init (RFC4866)", + 16: "Care-of Test (RFC4866)" } + + +class _MIP6OptAlign: + """ Mobile IPv6 options have alignment requirements of the form x*n+y. + This class is inherited by all MIPv6 options to help in computing the + required Padding for that option, i.e. the need for a Pad1 or PadN + option before it. They only need to provide x and y as class + parameters. (x=0 and y=0 are used when no alignment is required)""" + def alignment_delta(self, curpos): + x = self.x ; y = self.y + if x == 0 and y ==0: + return 0 + delta = x*((curpos - y + x - 1)//x) + y - curpos + return delta + + +class MIP6OptBRAdvice(_MIP6OptAlign, Packet): + name = 'Mobile IPv6 Option - Binding Refresh Advice' + fields_desc = [ ByteEnumField('otype', 2, _mobopttypes), + ByteField('olen', 2), + ShortField('rinter', 0) ] + x = 2 ; y = 0# alignment requirement: 2n + +class MIP6OptAltCoA(_MIP6OptAlign, Packet): + name = 'MIPv6 Option - Alternate Care-of Address' + fields_desc = [ ByteEnumField('otype', 3, _mobopttypes), + ByteField('olen', 16), + IP6Field("acoa", "::") ] + x = 8 ; y = 6 # alignment requirement: 8n+6 + +class MIP6OptNonceIndices(_MIP6OptAlign, Packet): + name = 'MIPv6 Option - Nonce Indices' + fields_desc = [ ByteEnumField('otype', 4, _mobopttypes), + ByteField('olen', 16), + ShortField('hni', 0), + ShortField('coni', 0) ] + x = 2 ; y = 0 # alignment requirement: 2n + +class MIP6OptBindingAuthData(_MIP6OptAlign, Packet): + name = 'MIPv6 Option - Binding Authorization Data' + fields_desc = [ ByteEnumField('otype', 5, _mobopttypes), + ByteField('olen', 16), + BitField('authenticator', 0, 96) ] + x = 8 ; y = 2 # alignment requirement: 8n+2 + +class MIP6OptMobNetPrefix(_MIP6OptAlign, Packet): # NEMO - RFC 3963 + name = 'NEMO Option - Mobile Network Prefix' + fields_desc = [ ByteEnumField("otype", 6, _mobopttypes), + ByteField("olen", 18), + ByteField("reserved", 0), + ByteField("plen", 64), + IP6Field("prefix", "::") ] + x = 8 ; y = 4 # alignment requirement: 8n+4 + +class MIP6OptLLAddr(_MIP6OptAlign, Packet): # Sect 6.4.4 of RFC 4068 + name = "MIPv6 Option - Link-Layer Address (MH-LLA)" + fields_desc = [ ByteEnumField("otype", 7, _mobopttypes), + ByteField("olen", 7), + ByteEnumField("ocode", 2, _rfc4068_lla_optcode), + ByteField("pad", 0), + MACField("lla", ETHER_ANY) ] # Only support ethernet + x = 0 ; y = 0 # alignment requirement: none + +class MIP6OptMNID(_MIP6OptAlign, Packet): # RFC 4283 + name = "MIPv6 Option - Mobile Node Identifier" + fields_desc = [ ByteEnumField("otype", 8, _mobopttypes), + FieldLenField("olen", None, length_of="id", fmt="B", + adjust = lambda pkt,x: x+1), + ByteEnumField("subtype", 1, {1: "NAI"}), + StrLenField("id", "", + length_from = lambda pkt: pkt.olen-1) ] + x = 0 ; y = 0 # alignment requirement: none + +# We only support decoding and basic build. Automatic HMAC computation is +# too much work for our current needs. It is left to the user (I mean ... +# you). --arno +class MIP6OptMsgAuth(_MIP6OptAlign, Packet): # RFC 4285 (Sect. 5) + name = "MIPv6 Option - Mobility Message Authentication" + fields_desc = [ ByteEnumField("otype", 9, _mobopttypes), + FieldLenField("olen", None, length_of="authdata", fmt="B", + adjust = lambda pkt,x: x+5), + ByteEnumField("subtype", 1, {1: "MN-HA authentication mobility option", + 2: "MN-AAA authentication mobility option"}), + IntField("mspi", None), + StrLenField("authdata", "A"*12, + length_from = lambda pkt: pkt.olen-5) ] + x = 4 ; y = 1 # alignment requirement: 4n+1 + +# Extracted from RFC 1305 (NTP) : +# NTP timestamps are represented as a 64-bit unsigned fixed-point number, +# in seconds relative to 0h on 1 January 1900. The integer part is in the +# first 32 bits and the fraction part in the last 32 bits. +class NTPTimestampField(LongField): + epoch = (1900, 1, 1, 0, 0, 0, 5, 1, 0) + def i2repr(self, pkt, x): + if x < ((50*31536000)<<32): + return "Some date a few decades ago (%d)" % x + + # delta from epoch (= (1900, 1, 1, 0, 0, 0, 5, 1, 0)) to + # January 1st 1970 : + delta = -2209075761 + i = int(x >> 32) + j = float(x & 0xffffffff) * 2.0**-32 + res = i + j + delta + from time import strftime + t = time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(res)) + + return "%s (%d)" % (t, x) + +class MIP6OptReplayProtection(_MIP6OptAlign, Packet): # RFC 4285 (Sect. 6) + name = "MIPv6 option - Replay Protection" + fields_desc = [ ByteEnumField("otype", 10, _mobopttypes), + ByteField("olen", 8), + NTPTimestampField("timestamp", 0) ] + x = 8 ; y = 2 # alignment requirement: 8n+2 + +class MIP6OptCGAParamsReq(_MIP6OptAlign, Packet): # RFC 4866 (Sect. 5.6) + name = "MIPv6 option - CGA Parameters Request" + fields_desc = [ ByteEnumField("otype", 11, _mobopttypes), + ByteField("olen", 0) ] + x = 0 ; y = 0 # alignment requirement: none + +# XXX TODO: deal with CGA param fragmentation and build of defragmented +# XXX version. Passing of a big CGAParam structure should be +# XXX simplified. Make it hold packets, by the way --arno +class MIP6OptCGAParams(_MIP6OptAlign, Packet): # RFC 4866 (Sect. 5.1) + name = "MIPv6 option - CGA Parameters" + fields_desc = [ ByteEnumField("otype", 12, _mobopttypes), + FieldLenField("olen", None, length_of="cgaparams", fmt="B"), + StrLenField("cgaparams", "", + length_from = lambda pkt: pkt.olen) ] + x = 0 ; y = 0 # alignment requirement: none + +class MIP6OptSignature(_MIP6OptAlign, Packet): # RFC 4866 (Sect. 5.2) + name = "MIPv6 option - Signature" + fields_desc = [ ByteEnumField("otype", 13, _mobopttypes), + FieldLenField("olen", None, length_of="sig", fmt="B"), + StrLenField("sig", "", + length_from = lambda pkt: pkt.olen) ] + x = 0 ; y = 0 # alignment requirement: none + +class MIP6OptHomeKeygenToken(_MIP6OptAlign, Packet): # RFC 4866 (Sect. 5.3) + name = "MIPv6 option - Home Keygen Token" + fields_desc = [ ByteEnumField("otype", 14, _mobopttypes), + FieldLenField("olen", None, length_of="hkt", fmt="B"), + StrLenField("hkt", "", + length_from = lambda pkt: pkt.olen) ] + x = 0 ; y = 0 # alignment requirement: none + +class MIP6OptCareOfTestInit(_MIP6OptAlign, Packet): # RFC 4866 (Sect. 5.4) + name = "MIPv6 option - Care-of Test Init" + fields_desc = [ ByteEnumField("otype", 15, _mobopttypes), + ByteField("olen", 0) ] + x = 0 ; y = 0 # alignment requirement: none + +class MIP6OptCareOfTest(_MIP6OptAlign, Packet): # RFC 4866 (Sect. 5.5) + name = "MIPv6 option - Care-of Test" + fields_desc = [ ByteEnumField("otype", 16, _mobopttypes), + FieldLenField("olen", None, length_of="cokt", fmt="B"), + StrLenField("cokt", '\x00'*8, + length_from = lambda pkt: pkt.olen) ] + x = 0 ; y = 0 # alignment requirement: none + +class MIP6OptUnknown(_MIP6OptAlign, Packet): + name = 'Scapy6 - Unknown Mobility Option' + fields_desc = [ ByteEnumField("otype", 6, _mobopttypes), + FieldLenField("olen", None, length_of="odata", fmt="B"), + StrLenField("odata", "", + length_from = lambda pkt: pkt.olen) ] + x = 0 ; y = 0 # alignment requirement: none + +moboptcls = { 0: Pad1, + 1: PadN, + 2: MIP6OptBRAdvice, + 3: MIP6OptAltCoA, + 4: MIP6OptNonceIndices, + 5: MIP6OptBindingAuthData, + 6: MIP6OptMobNetPrefix, + 7: MIP6OptLLAddr, + 8: MIP6OptMNID, + 9: MIP6OptMsgAuth, + 10: MIP6OptReplayProtection, + 11: MIP6OptCGAParamsReq, + 12: MIP6OptCGAParams, + 13: MIP6OptSignature, + 14: MIP6OptHomeKeygenToken, + 15: MIP6OptCareOfTestInit, + 16: MIP6OptCareOfTest } + + +# Main Mobile IPv6 Classes + +mhtypes = { 0: 'BRR', + 1: 'HoTI', + 2: 'CoTI', + 3: 'HoT', + 4: 'CoT', + 5: 'BU', + 6: 'BA', + 7: 'BE', + 8: 'Fast BU', + 9: 'Fast BA', + 10: 'Fast NA' } + +# From http://www.iana.org/assignments/mobility-parameters +bastatus = { 0: 'Binding Update accepted', + 1: 'Accepted but prefix discovery necessary', + 128: 'Reason unspecified', + 129: 'Administratively prohibited', + 130: 'Insufficient resources', + 131: 'Home registration not supported', + 132: 'Not home subnet', + 133: 'Not home agent for this mobile node', + 134: 'Duplicate Address Detection failed', + 135: 'Sequence number out of window', + 136: 'Expired home nonce index', + 137: 'Expired care-of nonce index', + 138: 'Expired nonces', + 139: 'Registration type change disallowed', + 140: 'Mobile Router Operation not permitted', + 141: 'Invalid Prefix', + 142: 'Not Authorized for Prefix', + 143: 'Forwarding Setup failed (prefixes missing)', + 144: 'MIPV6-ID-MISMATCH', + 145: 'MIPV6-MESG-ID-REQD', + 146: 'MIPV6-AUTH-FAIL', + 147: 'Permanent home keygen token unavailable', + 148: 'CGA and signature verification failed', + 149: 'Permanent home keygen token exists', + 150: 'Non-null home nonce index expected' } + + +class _MobilityHeader(Packet): + name = 'Dummy IPv6 Mobility Header' + overload_fields = { IPv6: { "nh": 135 }} + + def post_build(self, p, pay): + p += pay + l = self.len + if self.len is None: + l = (len(p)-8)//8 + p = bytes([p[0]]) + struct.pack("B", l) + p[2:] + if self.cksum is None: + cksum = in6_chksum(135, self.underlayer, p) + else: + cksum = self.cksum + p = p[:4]+struct.pack("!H", cksum)+p[6:] + return p + + +class MIP6MH_Generic(_MobilityHeader): # Mainly for decoding of unknown msg + name = "IPv6 Mobility Header - Generic Message" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), + ByteEnumField("mhtype", None, mhtypes), + ByteField("res", None), + XShortField("cksum", None), + StrLenField("msg", b"\x00"*2, + length_from = lambda pkt: 8*pkt.len-6) ] + + + +# TODO: make a generic _OptionsField +class _MobilityOptionsField(PacketListField): + islist = 1 + holds_packet = 1 + + def __init__(self, name, default, cls, curpos, count_from=None, length_from=None): + self.curpos = curpos + PacketListField.__init__(self, name, default, cls, count_from=count_from, length_from=length_from) + + def getfield(self, pkt, s): + l = self.length_from(pkt) + return s[l:],self.m2i(pkt, s[:l]) + + def i2len(self, pkt, i): + return len(self.i2m(pkt, i)) + + def m2i(self, pkt, x): + opt = [] + while x: + #o = ord(x[0]) # Option type + o = x[0] # Option type + cls = self.cls + if o in moboptcls: + cls = moboptcls[o] + try: + op = cls(x) + except: + op = self.cls(x) + opt.append(op) + if isinstance(op.payload, conf.raw_layer): + x = op.payload.load + del(op.payload) + else: + x = b"" + return opt + + def i2m(self, pkt, x): + autopad = None + try: + autopad = getattr(pkt, "autopad") # Hack : 'autopad' phantom field + except: + autopad = 1 + + if not autopad: + return b"".join(map(str, x)) + + curpos = self.curpos + s = b"" + for p in x: + d = p.alignment_delta(curpos) + curpos += d + if d == 1: + s += bytes(Pad1()) + elif d != 0: + s += bytes(PadN(optdata=b'\x00'*(d-2))) + pstr = bytes(p) + curpos += len(pstr) + s += pstr + + # Let's make the class including our option field + # a multiple of 8 octets long + d = curpos % 8 + if d == 0: + return s + d = 8 - d + if d == 1: + s +=bytes(Pad1()) + elif d != 0: + s += bytes(PadN(optdata=b'\x00'*(d-2))) + + return s + + def addfield(self, pkt, s, val): + return s+self.i2m(pkt, val) + +class MIP6MH_BRR(_MobilityHeader): + name = "IPv6 Mobility Header - Binding Refresh Request" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), + ByteEnumField("mhtype", 0, mhtypes), + ByteField("res", None), + XShortField("cksum", None), + ShortField("res2", None), + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _MobilityOptionsField("options", [], MIP6OptUnknown, 8, + length_from = lambda pkt: 8*pkt.len) ] + overload_fields = { IPv6: { "nh": 135 } } + def hashret(self): + # Hack: BRR, BU and BA have the same hashret that returns the same + # value "\x00\x08\x09" (concatenation of mhtypes). This is + # because we need match BA with BU and BU with BRR. --arno + return b"\x00\x08\x09" + +class MIP6MH_HoTI(_MobilityHeader): + name = "IPv6 Mobility Header - Home Test Init" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), + ByteEnumField("mhtype", 1, mhtypes), + ByteField("res", None), + XShortField("cksum", None), + StrFixedLenField("reserved", "\x00"*2, 2), + StrFixedLenField("cookie", "\x00"*8, 8), + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _MobilityOptionsField("options", [], MIP6OptUnknown, 16, + length_from = lambda pkt: 8*(pkt.len-1)) ] + overload_fields = { IPv6: { "nh": 135 } } + def hashret(self): + return self.cookie + +class MIP6MH_CoTI(MIP6MH_HoTI): + name = "IPv6 Mobility Header - Care-of Test Init" + mhtype = 2 + def hashret(self): + return self.cookie + +class MIP6MH_HoT(_MobilityHeader): + name = "IPv6 Mobility Header - Home Test" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), + ByteEnumField("mhtype", 3, mhtypes), + ByteField("res", None), + XShortField("cksum", None), + ShortField("index", None), + StrFixedLenField("cookie", "\x00"*8, 8), + StrFixedLenField("token", "\x00"*8, 8), + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _MobilityOptionsField("options", [], MIP6OptUnknown, 24, + length_from = lambda pkt: 8*(pkt.len-2)) ] + overload_fields = { IPv6: { "nh": 135 } } + def hashret(self): + return self.cookie + def answers(self): + if (isinstance(other, MIP6MH_HoTI) and + self.cookie == other.cookie): + return 1 + return 0 + +class MIP6MH_CoT(MIP6MH_HoT): + name = "IPv6 Mobility Header - Care-of Test" + mhtype = 4 + def hashret(self): + return self.cookie + + def answers(self): + if (isinstance(other, MIP6MH_CoTI) and + self.cookie == other.cookie): + return 1 + return 0 + +class LifetimeField(ShortField): + def i2repr(self, pkt, x): + return "%d sec" % (4*x) + +class MIP6MH_BU(_MobilityHeader): + name = "IPv6 Mobility Header - Binding Update" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), # unit == 8 bytes (excluding the first 8 bytes) + ByteEnumField("mhtype", 5, mhtypes), + ByteField("res", None), + XShortField("cksum", None), + XShortField("seq", None), # TODO: ShortNonceField + FlagsField("flags", "KHA", 7, "PRMKLHA"), + XBitField("reserved", 0, 9), + LifetimeField("mhtime", 3), # unit == 4 seconds + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _MobilityOptionsField("options", [], MIP6OptUnknown, 12, + length_from = lambda pkt: 8*pkt.len - 4) ] + overload_fields = { IPv6: { "nh": 135 } } + + def hashret(self): # Hack: see comment in MIP6MH_BRR.hashret() + return "\x00\x08\x09" + + def answers(self, other): + if isinstance(other, MIP6MH_BRR): + return 1 + return 0 + +class MIP6MH_BA(_MobilityHeader): + name = "IPv6 Mobility Header - Binding ACK" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), # unit == 8 bytes (excluding the first 8 bytes) + ByteEnumField("mhtype", 6, mhtypes), + ByteField("res", None), + XShortField("cksum", None), + ByteEnumField("status", 0, bastatus), + FlagsField("flags", "K", 3, "PRK"), + XBitField("res2", None, 5), + XShortField("seq", None), # TODO: ShortNonceField + XShortField("mhtime", 0), # unit == 4 seconds + _PhantomAutoPadField("autopad", 1), # autopad activated by default + _MobilityOptionsField("options", [], MIP6OptUnknown, 12, + length_from = lambda pkt: 8*pkt.len-4) ] + overload_fields = { IPv6: { "nh": 135 }} + + def hashret(self): # Hack: see comment in MIP6MH_BRR.hashret() + return "\x00\x08\x09" + + def answers(self, other): + if (isinstance(other, MIP6MH_BU) and + other.mhtype == 5 and + self.mhtype == 6 and + other.flags & 0x1 and # Ack request flags is set + self.seq == other.seq): + return 1 + return 0 + +_bestatus = { 1: 'Unknown binding for Home Address destination option', + 2: 'Unrecognized MH Type value' } + +# TODO: match Binding Error to its stimulus +class MIP6MH_BE(_MobilityHeader): + name = "IPv6 Mobility Header - Binding Error" + fields_desc = [ ByteEnumField("nh", 59, ipv6nh), + ByteField("len", None), # unit == 8 bytes (excluding the first 8 bytes) + ByteEnumField("mhtype", 7, mhtypes), + ByteField("res", 0), + XShortField("cksum", None), + ByteEnumField("status", 0, _bestatus), + ByteField("reserved", 0), + IP6Field("ha", "::"), + _MobilityOptionsField("options", [], MIP6OptUnknown, 24, + length_from = lambda pkt: 8*(pkt.len-2)) ] + overload_fields = { IPv6: { "nh": 135 }} + +_mip6_mhtype2cls = { 0: MIP6MH_BRR, + 1: MIP6MH_HoTI, + 2: MIP6MH_CoTI, + 3: MIP6MH_HoT, + 4: MIP6MH_CoT, + 5: MIP6MH_BU, + 6: MIP6MH_BA, + 7: MIP6MH_BE } + + +############################################################################# +############################################################################# +### Traceroute6 ### +############################################################################# +############################################################################# + +class AS_resolver6(AS_resolver_riswhois): + def _resolve_one(self, ip): + """ + overloaded version to provide a Whois resolution on the + embedded IPv4 address if the address is 6to4 or Teredo. + Otherwise, the native IPv6 address is passed. + """ + + if in6_isaddr6to4(ip): # for 6to4, use embedded @ + tmp = inet_pton(socket.AF_INET6, ip) + addr = inet_ntop(socket.AF_INET, tmp[2:6]) + elif in6_isaddrTeredo(ip): # for Teredo, use mapped address + addr = teredoAddrExtractInfo(ip)[2] + else: + addr = ip + + _, asn, desc = AS_resolver_riswhois._resolve_one(self, addr) + + return ip,asn,desc + +class TracerouteResult6(TracerouteResult): + def show(self): + #return self.make_table(lambda (s,r): (s.sprintf("%-42s,IPv6.dst%:{TCP:tcp%TCP.dport%}{UDP:udp%UDP.dport%}{ICMPv6EchoRequest:IER}"), # TODO: ICMPv6 ! + return self.make_table(lambda s,r: (s.sprintf("%-42s,IPv6.dst%:{TCP:tcp%TCP.dport%}{UDP:udp%UDP.dport%}{ICMPv6EchoRequest:IER}"), # TODO: ICMPv6 ! + s.hlim, + r.sprintf("%-42s,IPv6.src% {TCP:%TCP.flags%}"+ + "{ICMPv6DestUnreach:%ir,type%}{ICMPv6PacketTooBig:%ir,type%}"+ + "{ICMPv6TimeExceeded:%ir,type%}{ICMPv6ParamProblem:%ir,type%}"+ + "{ICMPv6EchoReply:%ir,type%}"))) + + def get_trace(self): + trace = {} + + for s,r in self.res: + if IPv6 not in s: + continue + d = s[IPv6].dst + if d not in trace: + trace[d] = {} + + t = not (ICMPv6TimeExceeded in r or + ICMPv6DestUnreach in r or + ICMPv6PacketTooBig in r or + ICMPv6ParamProblem in r) + + trace[d][s[IPv6].hlim] = r[IPv6].src, t + + for k in trace.values(): + #m = filter(lambda x: k[x][1], k.keys()) + m = [ x for x in k.keys() if k[x][1] ] + if not m: + continue + m = min(m) + for l in k.keys(): + if l > m: + del(k[l]) + + return trace + + def graph(self, ASres=AS_resolver6(), **kargs): + TracerouteResult.graph(self, ASres=ASres, **kargs) + +def traceroute6(target, dport=80, minttl=1, maxttl=30, sport=RandShort(), + l4 = None, timeout=2, verbose=None, **kargs): + """ + Instant TCP traceroute using IPv6 : + traceroute6(target, [maxttl=30], [dport=80], [sport=80]) -> None + """ + if verbose is None: + verbose = conf.verb + + if l4 is None: + a,b = sr(IPv6(dst=target, hlim=(minttl,maxttl))/TCP(seq=RandInt(),sport=sport, dport=dport), + timeout=timeout, filter="icmp6 or tcp", verbose=verbose, **kargs) + else: + a,b = sr(IPv6(dst=target, hlim=(minttl,maxttl))/l4, + timeout=timeout, verbose=verbose, **kargs) + + a = TracerouteResult6(a.res) + + if verbose: + a.display() + + return a,b + +############################################################################# +############################################################################# +### Sockets ### +############################################################################# +############################################################################# + +class L3RawSocket6(L3RawSocket): + def __init__(self, type = ETH_P_IPV6, filter=None, iface=None, promisc=None, nofilter=0): + L3RawSocket.__init__(self, type, filter, iface, promisc) + # NOTE: if fragmentation is needed, it will be done by the kernel (RFC 2292) + self.outs = socket.socket(socket.AF_INET6, socket.SOCK_RAW, socket.IPPROTO_RAW) + self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) + +def IPv6inIP(dst='203.178.135.36', src=None): + _IPv6inIP.dst = dst + _IPv6inIP.src = src + if not conf.L3socket == _IPv6inIP: + _IPv6inIP.cls = conf.L3socket + else: + del(conf.L3socket) + return _IPv6inIP + +class _IPv6inIP(SuperSocket): + dst = '127.0.0.1' + src = None + cls = None + + def __init__(self, family=socket.AF_INET6, type=socket.SOCK_STREAM, proto=0, **args): + SuperSocket.__init__(self, family, type, proto) + self.worker = self.cls(**args) + + def set(self, dst, src=None): + _IPv6inIP.src = src + _IPv6inIP.dst = dst + + def nonblock_recv(self): + p = self.worker.nonblock_recv() + return self._recv(p) + + def recv(self, x): + p = self.worker.recv(x) + return self._recv(p, x) + + def _recv(self, p, x=MTU): + if p is None: + return p + elif isinstance(p, IP): + # TODO: verify checksum + if p.src == self.dst and p.proto == socket.IPPROTO_IPV6: + if isinstance(p.payload, IPv6): + return p.payload + return p + + def send(self, x): + return self.worker.send(IP(dst=self.dst, src=self.src, proto=socket.IPPROTO_IPV6)/x) + + +############################################################################# +############################################################################# +### Layers binding ### +############################################################################# +############################################################################# + +conf.l3types.register(ETH_P_IPV6, IPv6) +conf.l2types.register(31, IPv6) + +bind_layers(Ether, IPv6, type = 0x86dd ) +bind_layers(CookedLinux, IPv6, proto = 0x86dd ) +bind_layers(IPerror6, TCPerror, nh = socket.IPPROTO_TCP ) +bind_layers(IPerror6, UDPerror, nh = socket.IPPROTO_UDP ) +bind_layers(IPv6, TCP, nh = socket.IPPROTO_TCP ) +bind_layers(IPv6, UDP, nh = socket.IPPROTO_UDP ) +bind_layers(IP, IPv6, proto = socket.IPPROTO_IPV6 ) +bind_layers(IPv6, IPv6, nh = socket.IPPROTO_IPV6 ) + +bind_layers(IPv6, IP, nh = IPPROTO_IPIP ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/ipsec.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ipsec.py new file mode 100644 index 00000000..a14925fb --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ipsec.py @@ -0,0 +1,995 @@ +############################################################################# +## ipsec.py --- IPSec support for Scapy ## +## ## +## Copyright (C) 2014 6WIND ## +## ## +## This program is free software; you can redistribute it and/or modify it ## +## under the terms of the GNU General Public License version 2 as ## +## published by the Free Software Foundation. ## +## ## +## This program is distributed in the hope that it will be useful, but ## +## WITHOUT ANY WARRANTY; without even the implied warranty of ## +## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ## +## General Public License for more details. ## +############################################################################# +""" +IPSec layer +=========== + +Example of use: + +>>> sa = SecurityAssociation(ESP, spi=0xdeadbeef, crypt_algo='AES-CBC', +... crypt_key='sixteenbytes key') +>>> p = IP(src='1.1.1.1', dst='2.2.2.2') +>>> p /= TCP(sport=45012, dport=80) +>>> p /= Raw(b'testdata') +>>> p = IP(bytes(p)) +>>> p +<IP version=4L ihl=5L tos=0x0 len=48 id=1 flags= frag=0L ttl=64 proto=tcp chksum=0x74c2 src=1.1.1.1 dst=2.2.2.2 options=[] |<TCP sport=45012 dport=http seq=0 ack=0 dataofs=5L reserved=0L flags=S window=8192 chksum=0x1914 urgptr=0 options=[] |<Raw load='testdata' |>>> +>>> +>>> e = sa.encrypt(p) +>>> e +<IP version=4L ihl=5L tos=0x0 len=76 id=1 flags= frag=0L ttl=64 proto=esp chksum=0x747a src=1.1.1.1 dst=2.2.2.2 |<ESP spi=0xdeadbeef seq=1 data='\xf8\xdb\x1e\x83[T\xab\\\xd2\x1b\xed\xd1\xe5\xc8Y\xc2\xa5d\x92\xc1\x05\x17\xa6\x92\x831\xe6\xc1]\x9a\xd6K}W\x8bFfd\xa5B*+\xde\xc8\x89\xbf{\xa9' |>> +>>> +>>> d = sa.decrypt(e) +>>> d +<IP version=4L ihl=5L tos=0x0 len=48 id=1 flags= frag=0L ttl=64 proto=tcp chksum=0x74c2 src=1.1.1.1 dst=2.2.2.2 |<TCP sport=45012 dport=http seq=0 ack=0 dataofs=5L reserved=0L flags=S window=8192 chksum=0x1914 urgptr=0 options=[] |<Raw load='testdata' |>>> +>>> +>>> d == p +True +""" + +import socket + +if not hasattr(socket, 'IPPROTO_AH'): + socket.IPPROTO_AH = 51 +if not hasattr(socket, 'IPPROTO_ESP'): + socket.IPPROTO_ESP = 50 + + +import fractions + +from scapy.data import IP_PROTOS + +from scapy.fields import ByteEnumField, ByteField, StrField, XIntField, IntField, \ + ShortField, PacketField + +from scapy.packet import Packet, bind_layers, Raw + +from scapy.layers.inet import IP, UDP +from scapy.layers.inet6 import IPv6, IPv6ExtHdrHopByHop, IPv6ExtHdrDestOpt, \ + IPv6ExtHdrRouting + + +#------------------------------------------------------------------------------ +class AH(Packet): + """ + Authentication Header + + See https://tools.ietf.org/rfc/rfc4302.txt + """ + + name = 'AH' + + fields_desc = [ + ByteEnumField('nh', None, IP_PROTOS), + ByteField('payloadlen', None), + ShortField('reserved', None), + XIntField('spi', 0x0), + IntField('seq', 0), + StrField('icv', None), + StrField('padding', None), + ] + + overload_fields = { + IP: {'proto': socket.IPPROTO_AH}, + IPv6: {'nh': socket.IPPROTO_AH}, + IPv6ExtHdrHopByHop: {'nh': socket.IPPROTO_AH}, + IPv6ExtHdrDestOpt: {'nh': socket.IPPROTO_AH}, + IPv6ExtHdrRouting: {'nh': socket.IPPROTO_AH}, + } + +bind_layers(IP, AH, proto=socket.IPPROTO_AH) +bind_layers(IPv6, AH, nh=socket.IPPROTO_AH) + +#------------------------------------------------------------------------------ +class ESP(Packet): + """ + Encapsulated Security Payload + + See https://tools.ietf.org/rfc/rfc4303.txt + """ + name = 'ESP' + + fields_desc = [ + XIntField('spi', 0x0), + IntField('seq', 0), + StrField('data', None), + ] + + overload_fields = { + IP: {'proto': socket.IPPROTO_ESP}, + IPv6: {'nh': socket.IPPROTO_ESP}, + IPv6ExtHdrHopByHop: {'nh': socket.IPPROTO_ESP}, + IPv6ExtHdrDestOpt: {'nh': socket.IPPROTO_ESP}, + IPv6ExtHdrRouting: {'nh': socket.IPPROTO_ESP}, + } + +bind_layers(IP, ESP, proto=socket.IPPROTO_ESP) +bind_layers(IPv6, ESP, nh=socket.IPPROTO_ESP) +bind_layers(UDP, ESP, dport=4500) # NAT-Traversal encapsulation +bind_layers(UDP, ESP, sport=4500) # NAT-Traversal encapsulation + +#------------------------------------------------------------------------------ +class _ESPPlain(Packet): + """ + Internal class to represent unencrypted ESP packets. + """ + name = 'ESP' + + fields_desc = [ + XIntField('spi', 0x0), + IntField('seq', 0), + + StrField('iv', ''), + PacketField('data', '', Raw), + StrField('padding', ''), + + ByteField('padlen', 0), + ByteEnumField('nh', 0, IP_PROTOS), + StrField('icv', ''), + ] + + def data_for_encryption(self): + return bytes(self.data) + self.padding + chr(self.padlen).encode('ascii') + chr(self.nh).encode('ascii') + +#------------------------------------------------------------------------------ +try: + from Crypto.Cipher import AES + from Crypto.Cipher import DES + from Crypto.Cipher import DES3 + from Crypto.Cipher import CAST + from Crypto.Cipher import Blowfish + from Crypto.Util import Counter + from Crypto import Random +except ImportError: + # no error if pycrypto is not available but encryption won't be supported + AES = None + DES = None + DES3 = None + CAST = None + Blowfish = None + Random = None + +#------------------------------------------------------------------------------ +def _lcm(a, b): + """ + Least Common Multiple between 2 integers. + """ + if a == 0 or b == 0: + return 0 + else: + return abs(a * b) // fractions.gcd(a, b) + +class CryptAlgo(object): + """ + IPSec encryption algorithm + """ + + def __init__(self, name, cipher, mode, block_size=None, iv_size=None, key_size=None): + """ + @param name: the name of this encryption algorithm + @param cipher: a Cipher module + @param mode: the mode used with the cipher module + @param block_size: the length a block for this algo. Defaults to the + `block_size` of the cipher. + @param iv_size: the length of the initialization vector of this algo. + Defaults to the `block_size` of the cipher. + @param key_size: an integer or list/tuple of integers. If specified, + force the secret keys length to one of the values. + Defaults to the `key_size` of the cipher. + """ + self.name = name + self.cipher = cipher + self.mode = mode + + if block_size is not None: + self.block_size = block_size + elif cipher is not None: + self.block_size = cipher.block_size + else: + self.block_size = 1 + + if iv_size is None: + self.iv_size = self.block_size + else: + self.iv_size = iv_size + + if key_size is not None: + self.key_size = key_size + elif cipher is not None: + self.key_size = cipher.key_size + else: + self.key_size = None + + def check_key(self, key): + """ + Check that the key length is valid. + + @param key: a byte string + """ + if self.key_size and not (len(key) == self.key_size or len(key) in self.key_size): + raise TypeError('invalid key size %s, must be %s' % + (len(key), self.key_size)) + + def generate_iv(self): + """ + Generate a random initialization vector. If pycrypto is not available, + return a buffer of the correct length filled with only '\x00'. + """ + if Random: + return Random.get_random_bytes(self.iv_size) + else: + return chr(0) * self.iv_size + + def new_cipher(self, key, iv): + """ + @param key: the secret key, a byte string + @param iv: the initialization vector, a byte string + @return: an initialized cipher object for this algo + """ + if type(key) is str: + key = key.encode('ascii') + if (hasattr(self.cipher, 'MODE_CTR') and self.mode == self.cipher.MODE_CTR + or hasattr(self.cipher, 'MODE_GCM') and self.mode == self.cipher.MODE_GCM): + # in counter mode, the "iv" must be incremented for each block + # it is calculated like this: + # +---------+------------------+---------+ + # | nonce | IV | counter | + # +---------+------------------+---------+ + # m bytes n bytes 4 bytes + # <--------------------------------------> + # block_size + nonce_size = self.cipher.block_size - self.iv_size - 4 + + # instead of asking for an extra parameter, we extract the last + # nonce_size bytes of the key and use them as the nonce. + # +----------------------------+---------+ + # | cipher key | nonce | + # +----------------------------+---------+ + # <---------> + # nonce_size + cipher_key, nonce = key[:-nonce_size], key[-nonce_size:] + + return self.cipher.new(cipher_key, self.mode, + counter=Counter.new(4 * 8, prefix=nonce + iv)) + else: + return self.cipher.new(key, self.mode, iv) + + def pad(self, esp): + """ + Add the correct amount of padding so that the data to encrypt is + exactly a multiple of the algorithm's block size. + + Also, make sure that the total ESP packet length is a multiple of 4 or + 8 bytes with IP or IPv6 respectively. + + @param esp: an unencrypted _ESPPlain packet + """ + # 2 extra bytes for padlen and nh + data_len = len(esp.data) + 2 + + # according to the RFC4303, section 2.4. Padding (for Encryption) + # the size of the ESP payload must be a multiple of 32 bits + align = _lcm(self.block_size, 4) + + # pad for block size + esp.padlen = -data_len % align + + # padding must be an array of bytes starting from 1 to padlen + esp.padding = '' + for b in range(1, esp.padlen + 1): + esp.padding += bytes([b]) + + # If the following test fails, it means that this algo does not comply + # with the RFC + payload_len = len(esp.iv) + len(esp.data) + len(esp.padding) + 2 + if payload_len % 4 != 0: + raise ValueError('The size of the ESP data is not aligned to 32 bits after padding.') + + return esp + + def encrypt(self, esp, key): + """ + Encrypt an ESP packet + + @param esp: an unencrypted _ESPPlain packet with valid padding + @param key: the secret key used for encryption + + @return: a valid ESP packet encrypted with this algorithm + """ + data = esp.data_for_encryption() + + if self.cipher: + self.check_key(key) + cipher = self.new_cipher(key, esp.iv) + data = cipher.encrypt(data) + + return ESP(spi=esp.spi, seq=esp.seq, data=esp.iv + data) + + def decrypt(self, esp, key, icv_size=0): + """ + Decrypt an ESP packet + + @param esp: an encrypted ESP packet + @param key: the secret key used for encryption + @param icv_size: the length of the icv used for integrity check + + @return: a valid ESP packet encrypted with this algorithm + """ + self.check_key(key) + + iv = esp.data[:self.iv_size] + data = esp.data[self.iv_size:len(esp.data) - icv_size] + icv = esp.data[len(esp.data) - icv_size:] + + if self.cipher: + cipher = self.new_cipher(key, iv) + data = cipher.decrypt(data) + + # extract padlen and nh + #padlen = ord(data[-2]) + padlen = (data[-2]) + #nh = ord(data[-1]) + nh = (data[-1]) + + # then use padlen to determine data and padding + data = data[:len(data) - padlen - 2] + padding = data[len(data) - padlen - 2: len(data) - 2] + + return _ESPPlain(spi=esp.spi, + seq=esp.seq, + iv=iv, + data=data, + padding=padding, + padlen=padlen, + nh=nh, + icv=icv) + +#------------------------------------------------------------------------------ +# The names of the encryption algorithms are the same than in scapy.contrib.ikev2 +# see http://www.iana.org/assignments/ikev2-parameters/ikev2-parameters.xhtml + +CRYPT_ALGOS = { + 'NULL': CryptAlgo('NULL', cipher=None, mode=None, iv_size=0), +} + +if AES: + CRYPT_ALGOS['AES-CBC'] = CryptAlgo('AES-CBC', + cipher=AES, + mode=AES.MODE_CBC) + # specific case for counter mode: + # the last 4 bytes of the key are used to carry the nonce of the counter + CRYPT_ALGOS['AES-CTR'] = CryptAlgo('AES-CTR', + cipher=AES, + mode=AES.MODE_CTR, + block_size=1, + iv_size=8, + key_size=(16 + 4, 24 + 4, 32 + 4)) +if DES: + CRYPT_ALGOS['DES'] = CryptAlgo('DES', + cipher=DES, + mode=DES.MODE_CBC) +if Blowfish: + CRYPT_ALGOS['Blowfish'] = CryptAlgo('Blowfish', + cipher=Blowfish, + mode=Blowfish.MODE_CBC) +if DES3: + CRYPT_ALGOS['3DES'] = CryptAlgo('3DES', + cipher=DES3, + mode=DES3.MODE_CBC) +if CAST: + CRYPT_ALGOS['CAST'] = CryptAlgo('CAST', + cipher=CAST, + mode=CAST.MODE_CBC) + +#------------------------------------------------------------------------------ +try: + from Crypto.Hash import HMAC + from Crypto.Hash import SHA + from Crypto.Hash import MD5 + from Crypto.Hash import SHA256 + from Crypto.Hash import SHA384 + from Crypto.Hash import SHA512 +except ImportError: + # no error if pycrypto is not available but authentication won't be supported + HMAC = None + SHA = None + MD5 = None + SHA256 = None + SHA384 = None +try: + from Crypto.Hash import XCBCMAC +except ImportError: + XCBCMAC = None + +#------------------------------------------------------------------------------ +class IPSecIntegrityError(Exception): + """ + Error risen when the integrity check fails. + """ + pass + +class AuthAlgo(object): + """ + IPSec integrity algorithm + """ + + def __init__(self, name, mac, digestmod, icv_size, key_size=None): + """ + @param name: the name of this integrity algorithm + @param mac: a Message Authentication Code module + @param digestmod: a Hash or Cipher module + @param icv_size: the length of the integrity check value of this algo + @param key_size: an integer or list/tuple of integers. If specified, + force the secret keys length to one of the values. + Defaults to the `key_size` of the cipher. + """ + self.name = name + self.mac = mac + self.digestmod = digestmod + self.icv_size = icv_size + self.key_size = key_size + + def check_key(self, key): + """ + Check that the key length is valid. + + @param key: a byte string + """ + if self.key_size and len(key) not in self.key_size: + raise TypeError('invalid key size %s, must be one of %s' % + (len(key), self.key_size)) + + def new_mac(self, key): + """ + @param key: a byte string + @return: an initialized mac object for this algo + """ + if type(key) is str: + key = key.encode('ascii') + if self.mac is XCBCMAC: + # specific case here, ciphermod instead of digestmod + return self.mac.new(key, ciphermod=self.digestmod) + else: + print(self.mac) + return self.mac.new(key, digestmod=self.digestmod) + + def sign(self, pkt, key): + """ + Sign an IPSec (ESP or AH) packet with this algo. + + @param pkt: a packet that contains a valid encrypted ESP or AH layer + @param key: the authentication key, a byte string + + @return: the signed packet + """ + if not self.mac: + return pkt + + self.check_key(key) + + mac = self.new_mac(key) + + if pkt.haslayer(ESP): + mac.update(bytes(pkt[ESP])) + pkt[ESP].data += mac.digest()[:self.icv_size] + + elif pkt.haslayer(AH): + clone = zero_mutable_fields(pkt.copy(), sending=True) + mac.update(bytes(clone)) + pkt[AH].icv = mac.digest()[:self.icv_size] + + return pkt + + def verify(self, pkt, key): + """ + Check that the integrity check value (icv) of a packet is valid. + + @param pkt: a packet that contains a valid encrypted ESP or AH layer + @param key: the authentication key, a byte string + + @raise IPSecIntegrityError: if the integrity check fails + """ + if not self.mac or self.icv_size == 0: + return + + self.check_key(key) + + mac = self.new_mac(key) + + pkt_icv = 'not found' + computed_icv = 'not computed' + + if isinstance(pkt, ESP): + pkt_icv = pkt.data[len(pkt.data) - self.icv_size:] + + pkt = pkt.copy() + pkt.data = pkt.data[:len(pkt.data) - self.icv_size] + mac.update(bytes(pkt)) + computed_icv = mac.digest()[:self.icv_size] + + elif pkt.haslayer(AH): + pkt_icv = pkt[AH].icv[:self.icv_size] + + clone = zero_mutable_fields(pkt.copy(), sending=False) + mac.update(bytes(clone)) + computed_icv = mac.digest()[:self.icv_size] + + if pkt_icv != computed_icv: + raise IPSecIntegrityError('pkt_icv=%r, computed_icv=%r' % + (pkt_icv, computed_icv)) + +#------------------------------------------------------------------------------ +# The names of the integrity algorithms are the same than in scapy.contrib.ikev2 +# see http://www.iana.org/assignments/ikev2-parameters/ikev2-parameters.xhtml + +AUTH_ALGOS = { + 'NULL': AuthAlgo('NULL', mac=None, digestmod=None, icv_size=0), +} + +if HMAC: + if SHA: + AUTH_ALGOS['HMAC-SHA1-96'] = AuthAlgo('HMAC-SHA1-96', + mac=HMAC, + digestmod=SHA, + icv_size=12) + if SHA256: + AUTH_ALGOS['SHA2-256-128'] = AuthAlgo('SHA2-256-128', + mac=HMAC, + digestmod=SHA256, + icv_size=16) + if SHA384: + AUTH_ALGOS['SHA2-384-192'] = AuthAlgo('SHA2-384-192', + mac=HMAC, + digestmod=SHA384, + icv_size=24) + if SHA512: + AUTH_ALGOS['SHA2-512-256'] = AuthAlgo('SHA2-512-256', + mac=HMAC, + digestmod=SHA512, + icv_size=32) + if MD5: + AUTH_ALGOS['HMAC-MD5-96'] = AuthAlgo('HMAC-MD5-96', + mac=HMAC, + digestmod=MD5, + icv_size=12) +if AES and XCBCMAC: + AUTH_ALGOS['AES-XCBC-96'] = AuthAlgo('AES-XCBC-96', + mac=XCBCMAC, + digestmod=AES, + icv_size=12, + key_size=(16,)) + +#------------------------------------------------------------------------------ + + +#------------------------------------------------------------------------------ +def split_for_transport(orig_pkt, transport_proto): + """ + Split an IP(v6) packet in the correct location to insert an ESP or AH + header. + + @param orig_pkt: the packet to split. Must be an IP or IPv6 packet + @param transport_proto: the IPSec protocol number that will be inserted + at the split position. + @return: a tuple (header, nh, payload) where nh is the protocol number of + payload. + """ + header = orig_pkt.copy() + next_hdr = header.payload + nh = None + + if header.version == 4: + nh = header.proto + header.proto = transport_proto + header.remove_payload() + del header.chksum + del header.len + + return header, nh, next_hdr + else: + found_rt_hdr = False + prev = header + + # Since the RFC 4302 is vague about where the ESP/AH headers should be + # inserted in IPv6, I chose to follow the linux implementation. + while isinstance(next_hdr, (IPv6ExtHdrHopByHop, IPv6ExtHdrRouting, IPv6ExtHdrDestOpt)): + if isinstance(next_hdr, IPv6ExtHdrHopByHop): + pass + if isinstance(next_hdr, IPv6ExtHdrRouting): + found_rt_hdr = True + elif isinstance(next_hdr, IPv6ExtHdrDestOpt) and found_rt_hdr: + break + + prev = next_hdr + next_hdr = next_hdr.payload + + nh = prev.nh + prev.nh = transport_proto + prev.remove_payload() + del header.plen + + return header, nh, next_hdr + +#------------------------------------------------------------------------------ +# see RFC 4302 - Appendix A. Mutability of IP Options/Extension Headers +IMMUTABLE_IPV4_OPTIONS = ( + 0, # End Of List + 1, # No OPeration + 2, # Security + 5, # Extended Security + 6, # Commercial Security + 20, # Router Alert + 21, # Sender Directed Multi-Destination Delivery +) +def zero_mutable_fields(pkt, sending=False): + """ + When using AH, all "mutable" fields must be "zeroed" before calculating + the ICV. See RFC 4302, Section 3.3.3.1. Handling Mutable Fields. + + @param pkt: an IP(v6) packet containing an AH layer. + NOTE: The packet will be modified + @param sending: if true, ipv6 routing headers will not be reordered + """ + + if pkt.haslayer(AH): + pkt[AH].icv = chr(0) * len(pkt[AH].icv) + else: + raise TypeError('no AH layer found') + + if pkt.version == 4: + # the tos field has been replaced by DSCP and ECN + # Routers may rewrite the DS field as needed to provide a + # desired local or end-to-end service + pkt.tos = 0 + # an intermediate router might set the DF bit, even if the source + # did not select it. + pkt.flags = 0 + # changed en route as a normal course of processing by routers + pkt.ttl = 0 + # will change if any of these other fields change + pkt.chksum = 0 + + immutable_opts = [] + for opt in pkt.options: + if opt.option in IMMUTABLE_IPV4_OPTIONS: + immutable_opts.append(opt) + else: + immutable_opts.append(Raw(chr(0) * len(opt))) + pkt.options = immutable_opts + + else: + # holds DSCP and ECN + pkt.tc = 0 + # The flow label described in AHv1 was mutable, and in RFC 2460 [DH98] + # was potentially mutable. To retain compatibility with existing AH + # implementations, the flow label is not included in the ICV in AHv2. + pkt.fl = 0 + # same as ttl + pkt.hlim = 0 + + next_hdr = pkt.payload + + while isinstance(next_hdr, (IPv6ExtHdrHopByHop, IPv6ExtHdrRouting, IPv6ExtHdrDestOpt)): + if isinstance(next_hdr, (IPv6ExtHdrHopByHop, IPv6ExtHdrDestOpt)): + for opt in next_hdr.options: + if opt.otype & 0x20: + # option data can change en-route and must be zeroed + opt.optdata = chr(0) * opt.optlen + elif isinstance(next_hdr, IPv6ExtHdrRouting) and sending: + # The sender must order the field so that it appears as it + # will at the receiver, prior to performing the ICV computation. + next_hdr.segleft = 0 + if next_hdr.addresses: + final = next_hdr.addresses.pop() + next_hdr.addresses.insert(0, pkt.dst) + pkt.dst = final + else: + break + + next_hdr = next_hdr.payload + + return pkt + +#------------------------------------------------------------------------------ +class SecurityAssociation(object): + """ + This class is responsible of "encryption" and "decryption" of IPSec packets. + """ + + SUPPORTED_PROTOS = (IP, IPv6) + + def __init__(self, proto, spi, seq_num=1, crypt_algo=None, crypt_key=None, + auth_algo=None, auth_key=None, tunnel_header=None, nat_t_header=None): + """ + @param proto: the IPSec proto to use (ESP or AH) + @param spi: the Security Parameters Index of this SA + @param seq_num: the initial value for the sequence number on encrypted + packets + @param crypt_algo: the encryption algorithm name (only used with ESP) + @param crypt_key: the encryption key (only used with ESP) + @param auth_algo: the integrity algorithm name + @param auth_key: the integrity key + @param tunnel_header: an instance of a IP(v6) header that will be used + to encapsulate the encrypted packets. + @param nat_t_header: an instance of a UDP header that will be used + for NAT-Traversal. + """ + + if proto not in (ESP, AH, ESP.name, AH.name): + raise ValueError("proto must be either ESP or AH") + if isinstance(proto, str): + self.proto = eval(proto) + else: + self.proto = proto + + self.spi = spi + self.seq_num = seq_num + + if crypt_algo: + if crypt_algo not in CRYPT_ALGOS: + raise TypeError('unsupported encryption algo %r, try %r' % + (crypt_algo, CRYPT_ALGOS.keys())) + self.crypt_algo = CRYPT_ALGOS[crypt_algo] + self.crypt_algo.check_key(crypt_key) + self.crypt_key = crypt_key + else: + self.crypt_algo = CRYPT_ALGOS['NULL'] + self.crypt_key = None + + if auth_algo: + if auth_algo not in AUTH_ALGOS: + raise TypeError('unsupported integrity algo %r, try %r' % + (auth_algo, AUTH_ALGOS.keys())) + self.auth_algo = AUTH_ALGOS[auth_algo] + self.auth_algo.check_key(auth_key) + self.auth_key = auth_key + else: + self.auth_algo = AUTH_ALGOS['NULL'] + self.auth_key = None + + if tunnel_header and not isinstance(tunnel_header, (IP, IPv6)): + raise TypeError('tunnel_header must be %s or %s' % (IP.name, IPv6.name)) + self.tunnel_header = tunnel_header + + if nat_t_header: + if proto is not ESP: + raise TypeError('nat_t_header is only allowed with ESP') + if not isinstance(nat_t_header, UDP): + raise TypeError('nat_t_header must be %s' % UDP.name) + self.nat_t_header = nat_t_header + + def check_spi(self, pkt): + if pkt.spi != self.spi: + raise TypeError('packet spi=0x%x does not match the SA spi=0x%x' % + (pkt.spi, self.spi)) + + def _encrypt_esp(self, pkt, seq_num=None, iv=None): + + if iv is None: + iv = self.crypt_algo.generate_iv() + else: + if len(iv) != self.crypt_algo.iv_size: + raise TypeError('iv length must be %s' % self.crypt_algo.iv_size) + + esp = _ESPPlain(spi=self.spi, seq=seq_num or self.seq_num, iv=iv) + + if self.tunnel_header: + tunnel = self.tunnel_header.copy() + + if tunnel.version == 4: + del tunnel.proto + del tunnel.len + del tunnel.chksum + else: + del tunnel.nh + del tunnel.plen + + pkt = tunnel.__class__(bytes(tunnel / pkt)) + + ip_header, nh, payload = split_for_transport(pkt, socket.IPPROTO_ESP) + esp.data = payload + esp.nh = nh + + esp = self.crypt_algo.pad(esp) + esp = self.crypt_algo.encrypt(esp, self.crypt_key) + + self.auth_algo.sign(esp, self.auth_key) + + if self.nat_t_header: + nat_t_header = self.nat_t_header.copy() + nat_t_header.chksum = 0 + del nat_t_header.len + if ip_header.version == 4: + del ip_header.proto + else: + del ip_header.nh + ip_header /= nat_t_header + + if ip_header.version == 4: + ip_header.len = len(ip_header) + len(esp) + del ip_header.chksum + ip_header = ip_header.__class__(bytes(ip_header)) + else: + ip_header.plen = len(ip_header.payload) + len(esp) + + # sequence number must always change, unless specified by the user + if seq_num is None: + self.seq_num += 1 + + return ip_header / esp + + def _encrypt_ah(self, pkt, seq_num=None): + + ah = AH(spi=self.spi, seq=seq_num or self.seq_num, + icv=chr(0) * self.auth_algo.icv_size) + + if self.tunnel_header: + tunnel = self.tunnel_header.copy() + + if tunnel.version == 4: + del tunnel.proto + del tunnel.len + del tunnel.chksum + else: + del tunnel.nh + del tunnel.plen + + pkt = tunnel.__class__(bytes(tunnel / pkt)) + + ip_header, nh, payload = split_for_transport(pkt, socket.IPPROTO_AH) + ah.nh = nh + + if ip_header.version == 6 and len(ah) % 8 != 0: + # For IPv6, the total length of the header must be a multiple of + # 8-octet units. + ah.padding = chr(0) * (-len(ah) % 8) + elif len(ah) % 4 != 0: + # For IPv4, the total length of the header must be a multiple of + # 4-octet units. + ah.padding = chr(0) * (-len(ah) % 4) + + # RFC 4302 - Section 2.2. Payload Length + # This 8-bit field specifies the length of AH in 32-bit words (4-byte + # units), minus "2". + ah.payloadlen = len(ah) // 4 - 2 + + if ip_header.version == 4: + ip_header.len = len(ip_header) + len(ah) + len(payload) + del ip_header.chksum + ip_header = ip_header.__class__(bytes(ip_header)) + else: + ip_header.plen = len(ip_header.payload) + len(ah) + len(payload) + + signed_pkt = self.auth_algo.sign(ip_header / ah / payload, self.auth_key) + + # sequence number must always change, unless specified by the user + if seq_num is None: + self.seq_num += 1 + + return signed_pkt + + def encrypt(self, pkt, seq_num=None, iv=None): + """ + Encrypt (and encapsulate) an IP(v6) packet with ESP or AH according + to this SecurityAssociation. + + @param pkt: the packet to encrypt + @param seq_num: if specified, use this sequence number instead of the + generated one + @param iv: if specified, use this initialization vector for + encryption instead of a random one. + + @return: the encrypted/encapsulated packet + """ + if not isinstance(pkt, self.SUPPORTED_PROTOS): + raise TypeError('cannot encrypt %s, supported protos are %s' + % (pkt.__class__, self.SUPPORTED_PROTOS)) + if self.proto is ESP: + return self._encrypt_esp(pkt, seq_num=seq_num, iv=iv) + else: + return self._encrypt_ah(pkt, seq_num=seq_num) + + def _decrypt_esp(self, pkt, verify=True): + + encrypted = pkt[ESP] + + if verify: + self.check_spi(pkt) + self.auth_algo.verify(encrypted, self.auth_key) + + esp = self.crypt_algo.decrypt(encrypted, self.crypt_key, + self.auth_algo.icv_size) + + if self.tunnel_header: + # drop the tunnel header and return the payload untouched + + pkt.remove_payload() + if pkt.version == 4: + pkt.proto = esp.nh + else: + pkt.nh = esp.nh + cls = pkt.guess_payload_class(esp.data) + + return cls(esp.data) + else: + ip_header = pkt + + if ip_header.version == 4: + ip_header.proto = esp.nh + del ip_header.chksum + ip_header.remove_payload() + ip_header.len = len(ip_header) + len(esp.data) + # recompute checksum + ip_header = ip_header.__class__(bytes(ip_header)) + else: + encrypted.underlayer.nh = esp.nh + encrypted.underlayer.remove_payload() + ip_header.plen = len(ip_header.payload) + len(esp.data) + + cls = ip_header.guess_payload_class(esp.data) + + # reassemble the ip_header with the ESP payload + return ip_header / cls(esp.data) + + def _decrypt_ah(self, pkt, verify=True): + + if verify: + self.check_spi(pkt) + self.auth_algo.verify(pkt, self.auth_key) + + ah = pkt[AH] + payload = ah.payload + payload.remove_underlayer(None) # useless argument... + + if self.tunnel_header: + return payload + else: + ip_header = pkt + + if ip_header.version == 4: + ip_header.proto = ah.nh + del ip_header.chksum + ip_header.remove_payload() + ip_header.len = len(ip_header) + len(payload) + # recompute checksum + ip_header = ip_header.__class__(bytes(ip_header)) + else: + ah.underlayer.nh = ah.nh + ah.underlayer.remove_payload() + ip_header.plen = len(ip_header.payload) + len(payload) + + # reassemble the ip_header with the AH payload + return ip_header / payload + + def decrypt(self, pkt, verify=True): + """ + Decrypt (and decapsulate) an IP(v6) packet containing ESP or AH. + + @param pkt: the packet to decrypt + @param verify: if False, do not perform the integrity check + + @return: the decrypted/decapsulated packet + @raise IPSecIntegrityError: if the integrity check fails + """ + if not isinstance(pkt, self.SUPPORTED_PROTOS): + raise TypeError('cannot decrypt %s, supported protos are %s' + % (pkt.__class__, self.SUPPORTED_PROTOS)) + + if self.proto is ESP and pkt.haslayer(ESP): + return self._decrypt_esp(pkt, verify=verify) + elif self.proto is AH and pkt.haslayer(AH): + return self._decrypt_ah(pkt, verify=verify) + else: + raise TypeError('%s has no %s layer' % (pkt, self.proto.name)) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/ir.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ir.py new file mode 100644 index 00000000..90935aa3 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ir.py @@ -0,0 +1,44 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +IrDA infrared data communication. +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.l2 import CookedLinux + + + +# IR + +class IrLAPHead(Packet): + name = "IrDA Link Access Protocol Header" + fields_desc = [ XBitField("Address", 0x7f, 7), + BitEnumField("Type", 1, 1, {"Response":0, + "Command":1})] + +class IrLAPCommand(Packet): + name = "IrDA Link Access Protocol Command" + fields_desc = [ XByteField("Control", 0), + XByteField("Format identifier", 0), + XIntField("Source address", 0), + XIntField("Destination address", 0xffffffff), + XByteField("Discovery flags", 0x1), + ByteEnumField("Slot number", 255, {"final":255}), + XByteField("Version", 0)] + + +class IrLMP(Packet): + name = "IrDA Link Management Protocol" + fields_desc = [ XShortField("Service hints", 0), + XByteField("Character set", 0), + StrField("Device name", "") ] + + +bind_layers( CookedLinux, IrLAPHead, proto=23) +bind_layers( IrLAPHead, IrLAPCommand, Type=1) +bind_layers( IrLAPCommand, IrLMP, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/isakmp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/isakmp.py new file mode 100644 index 00000000..97def8f5 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/isakmp.py @@ -0,0 +1,355 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +ISAKMP (Internet Security Association and Key Management Protocol). +""" + +import struct +from scapy.packet import * +from scapy.fields import * +from scapy.ansmachine import * +from scapy.layers.inet import IP,UDP +from scapy.sendrecv import sr + + +# see http://www.iana.org/assignments/ipsec-registry for details +ISAKMPAttributeTypes= { "Encryption": (1, { "DES-CBC" : 1, + "IDEA-CBC" : 2, + "Blowfish-CBC" : 3, + "RC5-R16-B64-CBC" : 4, + "3DES-CBC" : 5, + "CAST-CBC" : 6, + "AES-CBC" : 7, + "CAMELLIA-CBC" : 8, }, 0), + "Hash": (2, { "MD5": 1, + "SHA": 2, + "Tiger": 3, + "SHA2-256": 4, + "SHA2-384": 5, + "SHA2-512": 6,}, 0), + "Authentication":(3, { "PSK": 1, + "DSS": 2, + "RSA Sig": 3, + "RSA Encryption": 4, + "RSA Encryption Revised": 5, + "ElGamal Encryption": 6, + "ElGamal Encryption Revised": 7, + "ECDSA Sig": 8, + "HybridInitRSA": 64221, + "HybridRespRSA": 64222, + "HybridInitDSS": 64223, + "HybridRespDSS": 64224, + "XAUTHInitPreShared": 65001, + "XAUTHRespPreShared": 65002, + "XAUTHInitDSS": 65003, + "XAUTHRespDSS": 65004, + "XAUTHInitRSA": 65005, + "XAUTHRespRSA": 65006, + "XAUTHInitRSAEncryption": 65007, + "XAUTHRespRSAEncryption": 65008, + "XAUTHInitRSARevisedEncryption": 65009, + "XAUTHRespRSARevisedEncryptio": 65010, }, 0), + "GroupDesc": (4, { "768MODPgr" : 1, + "1024MODPgr" : 2, + "EC2Ngr155" : 3, + "EC2Ngr185" : 4, + "1536MODPgr" : 5, + "2048MODPgr" : 14, + "3072MODPgr" : 15, + "4096MODPgr" : 16, + "6144MODPgr" : 17, + "8192MODPgr" : 18, }, 0), + "GroupType": (5, {"MODP": 1, + "ECP": 2, + "EC2N": 3}, 0), + "GroupPrime": (6, {}, 1), + "GroupGenerator1":(7, {}, 1), + "GroupGenerator2":(8, {}, 1), + "GroupCurveA": (9, {}, 1), + "GroupCurveB": (10, {}, 1), + "LifeType": (11, {"Seconds": 1, + "Kilobytes": 2, }, 0), + "LifeDuration": (12, {}, 1), + "PRF": (13, {}, 0), + "KeyLength": (14, {}, 0), + "FieldSize": (15, {}, 0), + "GroupOrder": (16, {}, 1), + } + +# the name 'ISAKMPTransformTypes' is actually a misnomer (since the table +# holds info for all ISAKMP Attribute types, not just transforms, but we'll +# keep it for backwards compatibility... for now at least +ISAKMPTransformTypes = ISAKMPAttributeTypes + +ISAKMPTransformNum = {} +for n in ISAKMPTransformTypes: + val = ISAKMPTransformTypes[n] + tmp = {} + for e in val[1]: + tmp[val[1][e]] = e + ISAKMPTransformNum[val[0]] = (n,tmp, val[2]) +del(n) +del(e) +del(tmp) +del(val) + + +class ISAKMPTransformSetField(StrLenField): + islist=1 + #def type2num(self, (typ,val)): + def type2num(self, typval): + typ = typval[0] + val = typval[1] + type_val,enc_dict,tlv = ISAKMPTransformTypes.get(typval[0], (typval[0],{},0)) + val = enc_dict.get(val, val) + s = b"" + if (val & ~0xffff): + if not tlv: + warning("%r should not be TLV but is too big => using TLV encoding" % typval[0]) + n = 0 + while val: + s = bytes([(val&0xff)])+s + val >>= 8 + n += 1 + val = n + else: + type_val |= 0x8000 + return struct.pack("!HH",type_val, val)+s + def num2type(self, typ, enc): + val = ISAKMPTransformNum.get(typ,(typ,{})) + enc = val[1].get(enc,enc) + return (val[0],enc) + def i2m(self, pkt, i): + if i is None: + return b"" + i = map(self.type2num, i) + return b"".join(i) + def m2i(self, pkt, m): + # I try to ensure that we don't read off the end of our packet based + # on bad length fields we're provided in the packet. There are still + # conditions where struct.unpack() may not get enough packet data, but + # worst case that should result in broken attributes (which would + # be expected). (wam) + lst = [] + while len(m) >= 4: + trans_type, = struct.unpack("!H", m[:2]) + is_tlv = not (trans_type & 0x8000) + if is_tlv: + # We should probably check to make sure the attribute type we + # are looking at is allowed to have a TLV format and issue a + # warning if we're given an TLV on a basic attribute. + value_len, = struct.unpack("!H", m[2:4]) + if value_len+4 > len(m): + warning("Bad length for ISAKMP tranform type=%#6x" % trans_type) + value = m[4:4+value_len] + r = 0 + for i in struct.unpack("!%s" % ("B"*len(value),), value): + r = (r << 8) | i + value = r + #value = reduce(lambda x,y: (x<<8)|y, struct.unpack("!%s" % ("B"*len(value),), value),0) + else: + trans_type &= 0x7fff + value_len=0 + value, = struct.unpack("!H", m[2:4]) + m=m[4+value_len:] + lst.append(self.num2type(trans_type, value)) + if len(m) > 0: + warning("Extra bytes after ISAKMP transform dissection [%r]" % m) + return lst + + +ISAKMP_payload_type = ["None","SA","Proposal","Transform","KE","ID","CERT","CR","Hash", + "SIG","Nonce","Notification","Delete","VendorID"] + +ISAKMP_exchange_type = ["None","base","identity prot.", + "auth only", "aggressive", "info"] + + +class ISAKMP_class(Packet): + def guess_payload_class(self, payload): + np = self.next_payload + if np == 0: + return conf.raw_layer + elif np < len(ISAKMP_payload_type): + pt = ISAKMP_payload_type[np] + return globals().get("ISAKMP_payload_%s" % pt, ISAKMP_payload) + else: + return ISAKMP_payload + + +class ISAKMP(ISAKMP_class): # rfc2408 + name = "ISAKMP" + fields_desc = [ + StrFixedLenField("init_cookie","",8), + StrFixedLenField("resp_cookie","",8), + ByteEnumField("next_payload",0,ISAKMP_payload_type), + XByteField("version",0x10), + ByteEnumField("exch_type",0,ISAKMP_exchange_type), + FlagsField("flags",0, 8, ["encryption","commit","auth_only","res3","res4","res5","res6","res7"]), # XXX use a Flag field + IntField("id",0), + IntField("length",None) + ] + + def guess_payload_class(self, payload): + if self.flags & 1: + return conf.raw_layer + return ISAKMP_class.guess_payload_class(self, payload) + + def answers(self, other): + if isinstance(other, ISAKMP): + if other.init_cookie == self.init_cookie: + return 1 + return 0 + def post_build(self, p, pay): + p += pay + if self.length is None: + p = p[:24]+struct.pack("!I",len(p))+p[28:] + return p + + + + +class ISAKMP_payload_Transform(ISAKMP_class): + name = "IKE Transform" + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), +# ShortField("len",None), + ShortField("length",None), + ByteField("num",None), + ByteEnumField("id",1,{1:"KEY_IKE"}), + ShortField("res2",0), + ISAKMPTransformSetField("transforms",None,length_from=lambda x:x.length-8) +# XIntField("enc",0x80010005L), +# XIntField("hash",0x80020002L), +# XIntField("auth",0x80030001L), +# XIntField("group",0x80040002L), +# XIntField("life_type",0x800b0001L), +# XIntField("durationh",0x000c0004L), +# XIntField("durationl",0x00007080L), + ] + def post_build(self, p, pay): + if self.length is None: + l = len(p) + p = p[:2]+bytes([((l>>8)&0xff),(l&0xff)])+p[4:] + p += pay + return p + + + + +class ISAKMP_payload_Proposal(ISAKMP_class): + name = "IKE proposal" +# ISAKMP_payload_type = 0 + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"trans","H", adjust=lambda pkt,x:x+8), + ByteField("proposal",1), + ByteEnumField("proto",1,{1:"ISAKMP"}), + FieldLenField("SPIsize",None,"SPI","B"), + ByteField("trans_nb",None), + StrLenField("SPI","",length_from=lambda x:x.SPIsize), + PacketLenField("trans",conf.raw_layer(),ISAKMP_payload_Transform,length_from=lambda x:x.length-8), + ] + + +class ISAKMP_payload(ISAKMP_class): + name = "ISAKMP payload" + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + + +class ISAKMP_payload_VendorID(ISAKMP_class): + name = "ISAKMP Vendor ID" + overload_fields = { ISAKMP: { "next_payload":13 }} + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"vendorID","H", adjust=lambda pkt,x:x+4), + StrLenField("vendorID","",length_from=lambda x:x.length-4), + ] + +class ISAKMP_payload_SA(ISAKMP_class): + name = "ISAKMP SA" + overload_fields = { ISAKMP: { "next_payload":1 }} + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"prop","H", adjust=lambda pkt,x:x+12), + IntEnumField("DOI",1,{1:"IPSEC"}), + IntEnumField("situation",1,{1:"identity"}), + PacketLenField("prop",conf.raw_layer(),ISAKMP_payload_Proposal,length_from=lambda x:x.length-12), + ] + +class ISAKMP_payload_Nonce(ISAKMP_class): + name = "ISAKMP Nonce" + overload_fields = { ISAKMP: { "next_payload":10 }} + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + +class ISAKMP_payload_KE(ISAKMP_class): + name = "ISAKMP Key Exchange" + overload_fields = { ISAKMP: { "next_payload":4 }} + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H", adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + +class ISAKMP_payload_ID(ISAKMP_class): + name = "ISAKMP Identification" + overload_fields = { ISAKMP: { "next_payload":5 }} + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H",adjust=lambda pkt,x:x+8), + ByteEnumField("IDtype",1,{1:"IPv4_addr", 11:"Key"}), + ByteEnumField("ProtoID",0,{0:"Unused"}), + ShortEnumField("Port",0,{0:"Unused"}), +# IPField("IdentData","127.0.0.1"), + StrLenField("load","",length_from=lambda x:x.length-8), + ] + + + +class ISAKMP_payload_Hash(ISAKMP_class): + name = "ISAKMP Hash" + overload_fields = { ISAKMP: { "next_payload":8 }} + fields_desc = [ + ByteEnumField("next_payload",None,ISAKMP_payload_type), + ByteField("res",0), + FieldLenField("length",None,"load","H",adjust=lambda pkt,x:x+4), + StrLenField("load","",length_from=lambda x:x.length-4), + ] + + + +ISAKMP_payload_type_overload = {} +for i in range(len(ISAKMP_payload_type)): + name = "ISAKMP_payload_%s" % ISAKMP_payload_type[i] + if name in globals(): + ISAKMP_payload_type_overload[globals()[name]] = {"next_payload":i} + +del(i) +del(name) +ISAKMP_class.overload_fields = ISAKMP_payload_type_overload.copy() + + +bind_layers( UDP, ISAKMP, dport=500, sport=500) +def ikescan(ip): + return sr(IP(dst=ip)/UDP()/ISAKMP(init_cookie=RandString(8), + exch_type=2)/ISAKMP_payload_SA(prop=ISAKMP_payload_Proposal())) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/l2.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/l2.py new file mode 100644 index 00000000..0d0a1c78 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/l2.py @@ -0,0 +1,543 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Classes and functions for layer 2 protocols. +""" + +import os,struct,time +from scapy.base_classes import Net +from scapy.config import conf +from scapy.packet import * +from scapy.ansmachine import * +from scapy.plist import SndRcvList +from scapy.fields import * +from scapy.sendrecv import srp,srp1 +from scapy.arch import get_if_hwaddr + + + + +################# +## Tools ## +################# + + +class Neighbor: + def __init__(self): + self.resolvers = {} + + def register_l3(self, l2, l3, resolve_method): + self.resolvers[l2,l3]=resolve_method + + def resolve(self, l2inst, l3inst): + k = l2inst.__class__,l3inst.__class__ + if k in self.resolvers: + return self.resolvers[k](l2inst,l3inst) + + def __repr__(self): + return "\n".join("%-15s -> %-15s" % (l2.__name__, l3.__name__) for l2,l3 in self.resolvers) + +conf.neighbor = Neighbor() + +conf.netcache.new_cache("arp_cache", 120) # cache entries expire after 120s + + +@conf.commands.register +def getmacbyip(ip, chainCC=0): + """Return MAC address corresponding to a given IP address""" + if isinstance(ip,Net): + ip = next(iter(ip)) + ip = inet_ntoa(inet_aton(ip)) + tmp = inet_aton(ip) + if (tmp[0] & 0xf0) == 0xe0: # mcast @ + return "01:00:5e:%.2x:%.2x:%.2x" % (tmp[1]&0x7f,tmp[2],tmp[3]) + iff,a,gw = conf.route.route(ip) + if ( (iff == "lo") or (ip == conf.route.get_if_bcast(iff)) ): + return "ff:ff:ff:ff:ff:ff" + if gw != "0.0.0.0": + ip = gw + + mac = conf.netcache.arp_cache.get(ip) + if mac: + return mac + + res = srp1(Ether(dst=ETHER_BROADCAST)/ARP(op="who-has", pdst=ip), + type=ETH_P_ARP, + iface = iff, + timeout=2, + verbose=0, + chainCC=chainCC, + nofilter=1) + if res is not None: + mac = res.payload.hwsrc + conf.netcache.arp_cache[ip] = mac + return mac + return None + + + +### Fields + +class DestMACField(MACField): + def __init__(self, name): + MACField.__init__(self, name, None) + def i2h(self, pkt, x): + if x is None: + x = conf.neighbor.resolve(pkt,pkt.payload) + if x is None: + x = "ff:ff:ff:ff:ff:ff" + warning("Mac address to reach destination not found. Using broadcast.") + return MACField.i2h(self, pkt, x) + def i2m(self, pkt, x): + return MACField.i2m(self, pkt, self.i2h(pkt, x)) + +class SourceMACField(MACField): + def __init__(self, name): + MACField.__init__(self, name, None) + def i2h(self, pkt, x): + if x is None: + iff,a,gw = pkt.payload.route() + if iff: + try: + x = get_if_hwaddr(iff) + except: + pass + if x is None: + x = "00:00:00:00:00:00" + return MACField.i2h(self, pkt, x) + def i2m(self, pkt, x): + return MACField.i2m(self, pkt, self.i2h(pkt, x)) + +class ARPSourceMACField(MACField): + def __init__(self, name): + MACField.__init__(self, name, None) + def i2h(self, pkt, x): + if x is None: + iff,a,gw = pkt.route() + if iff: + try: + x = get_if_hwaddr(iff) + except: + pass + if x is None: + x = "00:00:00:00:00:00" + return MACField.i2h(self, pkt, x) + def i2m(self, pkt, x): + return MACField.i2m(self, pkt, self.i2h(pkt, x)) + + + +### Layers + + +class Ether(Packet): + name = "Ethernet" + fields_desc = [ MACField("dst","00:00:00:01:00:00"), + MACField("src","00:00:00:02:00:00"), + XShortEnumField("type", 0x9000, ETHER_TYPES) ] + def hashret(self): + return struct.pack("H",self.type)+self.payload.hashret() + def answers(self, other): + if isinstance(other,Ether): + if self.type == other.type: + return self.payload.answers(other.payload) + return 0 + def mysummary(self): + return self.sprintf("%src% > %dst% (%type%)") + @classmethod + def dispatch_hook(cls, _pkt=None, *args, **kargs): + if _pkt and len(_pkt) >= 14: + if struct.unpack("!H", _pkt[12:14])[0] <= 1500: + return Dot3 + return cls + + +class Dot3(Packet): + name = "802.3" + fields_desc = [ DestMACField("dst"), + MACField("src", ETHER_ANY), + LenField("len", None, "H") ] + def extract_padding(self,s): + l = self.len + return s[:l],s[l:] + def answers(self, other): + if isinstance(other,Dot3): + return self.payload.answers(other.payload) + return 0 + def mysummary(self): + return "802.3 %s > %s" % (self.src, self.dst) + @classmethod + def dispatch_hook(cls, _pkt=None, *args, **kargs): + if _pkt and len(_pkt) >= 14: + if struct.unpack("!H", _pkt[12:14])[0] > 1500: + return Ether + return cls + + +class LLC(Packet): + name = "LLC" + fields_desc = [ XByteField("dsap", 0x00), + XByteField("ssap", 0x00), + ByteField("ctrl", 0) ] + +conf.neighbor.register_l3(Ether, LLC, lambda l2,l3: conf.neighbor.resolve(l2,l3.payload)) +conf.neighbor.register_l3(Dot3, LLC, lambda l2,l3: conf.neighbor.resolve(l2,l3.payload)) + + +class CookedLinux(Packet): + name = "cooked linux" + fields_desc = [ ShortEnumField("pkttype",0, {0: "unicast", + 4:"sent-by-us"}), #XXX incomplete + XShortField("lladdrtype",512), + ShortField("lladdrlen",0), + StrFixedLenField("src","",8), + XShortEnumField("proto",0x800,ETHER_TYPES) ] + + + +class SNAP(Packet): + name = "SNAP" + fields_desc = [ X3BytesField("OUI",0x000000), + XShortEnumField("code", 0x000, ETHER_TYPES) ] + +conf.neighbor.register_l3(Dot3, SNAP, lambda l2,l3: conf.neighbor.resolve(l2,l3.payload)) + + +class Dot1Q(Packet): + name = "802.1Q" + aliastypes = [ Ether ] + fields_desc = [ BitField("prio", 0, 3), + BitField("id", 0, 1), + BitField("vlan", 1, 12), + XShortEnumField("type", 0x0000, ETHER_TYPES) ] + def answers(self, other): + if isinstance(other,Dot1Q): + if ( (self.type == other.type) and + (self.vlan == other.vlan) ): + return self.payload.answers(other.payload) + else: + return self.payload.answers(other) + return 0 + def default_payload_class(self, pay): + if self.type <= 1500: + return LLC + return conf.raw_layer + def extract_padding(self,s): + if self.type <= 1500: + return s[:self.type],s[self.type:] + return s,None + def mysummary(self): + if isinstance(self.underlayer, Ether): + return self.underlayer.sprintf("802.1q %Ether.src% > %Ether.dst% (%Dot1Q.type%) vlan %Dot1Q.vlan%") + else: + return self.sprintf("802.1q (%Dot1Q.type%) vlan %Dot1Q.vlan%") + + +conf.neighbor.register_l3(Ether, Dot1Q, lambda l2,l3: conf.neighbor.resolve(l2,l3.payload)) + +class STP(Packet): + name = "Spanning Tree Protocol" + fields_desc = [ ShortField("proto", 0), + ByteField("version", 0), + ByteField("bpdutype", 0), + ByteField("bpduflags", 0), + ShortField("rootid", 0), + MACField("rootmac", ETHER_ANY), + IntField("pathcost", 0), + ShortField("bridgeid", 0), + MACField("bridgemac", ETHER_ANY), + ShortField("portid", 0), + BCDFloatField("age", 1), + BCDFloatField("maxage", 20), + BCDFloatField("hellotime", 2), + BCDFloatField("fwddelay", 15) ] + + +class EAPOL(Packet): + name = "EAPOL" + fields_desc = [ ByteField("version", 1), + ByteEnumField("type", 0, ["EAP_PACKET", "START", "LOGOFF", "KEY", "ASF"]), + LenField("len", None, "H") ] + + EAP_PACKET= 0 + START = 1 + LOGOFF = 2 + KEY = 3 + ASF = 4 + def extract_padding(self, s): + l = self.len + return s[:l],s[l:] + def hashret(self): + #return chr(self.type)+self.payload.hashret() + return bytes([self.type])+self.payload.hashret() + def answers(self, other): + if isinstance(other,EAPOL): + if ( (self.type == self.EAP_PACKET) and + (other.type == self.EAP_PACKET) ): + return self.payload.answers(other.payload) + return 0 + def mysummary(self): + return self.sprintf("EAPOL %EAPOL.type%") + + +class EAP(Packet): + name = "EAP" + fields_desc = [ ByteEnumField("code", 4, {1:"REQUEST",2:"RESPONSE",3:"SUCCESS",4:"FAILURE"}), + ByteField("id", 0), + ShortField("len",None), + ConditionalField(ByteEnumField("type",0, {1:"ID",4:"MD5"}), lambda pkt:pkt.code not in [EAP.SUCCESS, EAP.FAILURE]) + + ] + + REQUEST = 1 + RESPONSE = 2 + SUCCESS = 3 + FAILURE = 4 + TYPE_ID = 1 + TYPE_MD5 = 4 + def answers(self, other): + if isinstance(other,EAP): + if self.code == self.REQUEST: + return 0 + elif self.code == self.RESPONSE: + if ( (other.code == self.REQUEST) and + (other.type == self.type) ): + return 1 + elif other.code == self.RESPONSE: + return 1 + return 0 + + def post_build(self, p, pay): + if self.len is None: + l = len(p)+len(pay) + p = p[:2]+bytes([((l>>8)&0xff),(l&0xff)])+p[4:] + return p+pay + + +class ARP(Packet): + name = "ARP" + fields_desc = [ XShortField("hwtype", 0x0001), + XShortEnumField("ptype", 0x0800, ETHER_TYPES), + ByteField("hwlen", 6), + ByteField("plen", 4), + ShortEnumField("op", 1, {"who-has":1, "is-at":2, "RARP-req":3, "RARP-rep":4, "Dyn-RARP-req":5, "Dyn-RAR-rep":6, "Dyn-RARP-err":7, "InARP-req":8, "InARP-rep":9}), + ARPSourceMACField("hwsrc"), + SourceIPField("psrc","pdst"), + MACField("hwdst", ETHER_ANY), + IPField("pdst", "0.0.0.0") ] + who_has = 1 + is_at = 2 + def answers(self, other): + if isinstance(other,ARP): + if ( (self.op == self.is_at) and + (other.op == self.who_has) and + (self.psrc == other.pdst) ): + return 1 + return 0 + def route(self): + dst = self.pdst + if isinstance(dst,Gen): + dst = next(iter(dst)) + return conf.route.route(dst) + def extract_padding(self, s): + return b"",s + def mysummary(self): + if self.op == self.is_at: + return self.sprintf("ARP is at %hwsrc% says %psrc%") + elif self.op == self.who_has: + return self.sprintf("ARP who has %pdst% says %psrc%") + else: + return self.sprintf("ARP %op% %psrc% > %pdst%") + +conf.neighbor.register_l3(Ether, ARP, lambda l2,l3: getmacbyip(l3.pdst)) + +class GRErouting(Packet): + name = "GRE routing informations" + fields_desc = [ ShortField("address_family",0), + ByteField("SRE_offset", 0), + FieldLenField("SRE_len", None, "routing_info", "B"), + StrLenField("routing_info", "", "SRE_len"), + ] + + +class GRE(Packet): + name = "GRE" + fields_desc = [ BitField("chksum_present",0,1), + BitField("routing_present",0,1), + BitField("key_present",0,1), + BitField("seqnum_present",0,1), + BitField("strict_route_source",0,1), + BitField("recursion_control",0,3), + BitField("flags",0,5), + BitField("version",0,3), + XShortEnumField("proto", 0x0000, ETHER_TYPES), + ConditionalField(XShortField("chksum",None), lambda pkt:pkt.chksum_present==1 or pkt.routing_present==1), + ConditionalField(XShortField("offset",None), lambda pkt:pkt.chksum_present==1 or pkt.routing_present==1), + ConditionalField(XIntField("key",None), lambda pkt:pkt.key_present==1), + ConditionalField(XIntField("seqence_number",None), lambda pkt:pkt.seqnum_present==1), + ] + def post_build(self, p, pay): + p += pay + if self.chksum_present and self.chksum is None: + c = checksum(p) + p = p[:4]+bytes([((c>>8)&0xff),(c&0xff)])+p[6:] + return p + + + + +bind_layers( Dot3, LLC, ) +bind_layers( Ether, LLC, type=122) +bind_layers( Ether, Dot1Q, type=33024) +bind_layers( Ether, Ether, type=1) +bind_layers( Ether, ARP, type=2054) +bind_layers( Ether, EAPOL, type=34958) +bind_layers( Ether, EAPOL, dst='01:80:c2:00:00:03', type=34958) +bind_layers( CookedLinux, LLC, proto=122) +bind_layers( CookedLinux, Dot1Q, proto=33024) +bind_layers( CookedLinux, Ether, proto=1) +bind_layers( CookedLinux, ARP, proto=2054) +bind_layers( CookedLinux, EAPOL, proto=34958) +bind_layers( GRE, LLC, proto=122) +bind_layers( GRE, Dot1Q, proto=33024) +bind_layers( GRE, Ether, proto=1) +bind_layers( GRE, ARP, proto=2054) +bind_layers( GRE, EAPOL, proto=34958) +bind_layers( GRE, GRErouting, { "routing_present" : 1 } ) +bind_layers( GRErouting, conf.raw_layer,{ "address_family" : 0, "SRE_len" : 0 }) +bind_layers( GRErouting, GRErouting, { } ) +bind_layers( EAPOL, EAP, type=0) +bind_layers( LLC, STP, dsap=66, ssap=66, ctrl=3) +bind_layers( LLC, SNAP, dsap=170, ssap=170, ctrl=3) +bind_layers( SNAP, Dot1Q, code=33024) +bind_layers( SNAP, Ether, code=1) +bind_layers( SNAP, ARP, code=2054) +bind_layers( SNAP, EAPOL, code=34958) +bind_layers( SNAP, STP, code=267) + +conf.l2types.register(ARPHDR_ETHER, Ether) +conf.l2types.register_num2layer(ARPHDR_METRICOM, Ether) +conf.l2types.register_num2layer(ARPHDR_LOOPBACK, Ether) +conf.l2types.register_layer2num(ARPHDR_ETHER, Dot3) +conf.l2types.register(144, CookedLinux) # called LINUX_IRDA, similar to CookedLinux +conf.l2types.register(113, CookedLinux) + +conf.l3types.register(ETH_P_ARP, ARP) + + + + +### Technics + + + +@conf.commands.register +def arpcachepoison(target, victim, interval=60): + """Poison target's cache with (your MAC,victim's IP) couple +arpcachepoison(target, victim, [interval=60]) -> None +""" + tmac = getmacbyip(target) + p = Ether(dst=tmac)/ARP(op="who-has", psrc=victim, pdst=target) + try: + while 1: + sendp(p, iface_hint=target) + if conf.verb > 1: + os.write(1,b".") + time.sleep(interval) + except KeyboardInterrupt: + pass + + +class ARPingResult(SndRcvList): + def __init__(self, res=None, name="ARPing", stats=None): + SndRcvList.__init__(self, res, name, stats) + + def show(self): + for s,r in self.res: + print(r.sprintf("%19s,Ether.src% %ARP.psrc%")) + + + +@conf.commands.register +def arping(net, timeout=2, cache=0, verbose=None, **kargs): + """Send ARP who-has requests to determine which hosts are up +arping(net, [cache=0,] [iface=conf.iface,] [verbose=conf.verb]) -> None +Set cache=True if you want arping to modify internal ARP-Cache""" + if verbose is None: + verbose = conf.verb + ans,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=net), verbose=verbose, + filter="arp and arp[7] = 2", timeout=timeout, iface_hint=net, **kargs) + ans = ARPingResult(ans.res) + + if cache and ans is not None: + for pair in ans: + conf.netcache.arp_cache[pair[1].psrc] = (pair[1].hwsrc, time.time()) + if verbose: + ans.show() + return ans,unans + +@conf.commands.register +def is_promisc(ip, fake_bcast="ff:ff:00:00:00:00",**kargs): + """Try to guess if target is in Promisc mode. The target is provided by its ip.""" + + responses = srp1(Ether(dst=fake_bcast) / ARP(op="who-has", pdst=ip),type=ETH_P_ARP, iface_hint=ip, timeout=1, verbose=0,**kargs) + + return responses is not None + +@conf.commands.register +def promiscping(net, timeout=2, fake_bcast="ff:ff:ff:ff:ff:fe", **kargs): + """Send ARP who-has requests to determine which hosts are in promiscuous mode + promiscping(net, iface=conf.iface)""" + ans,unans = srp(Ether(dst=fake_bcast)/ARP(pdst=net), + filter="arp and arp[7] = 2", timeout=timeout, iface_hint=net, **kargs) + ans = ARPingResult(ans.res, name="PROMISCPing") + + ans.display() + return ans,unans + + +class ARP_am(AnsweringMachine): + function_name="farpd" + filter = "arp" + send_function = staticmethod(sendp) + + def parse_options(self, IP_addr=None, iface=None, ARP_addr=None): + self.IP_addr=IP_addr + self.iface=iface + self.ARP_addr=ARP_addr + + def is_request(self, req): + return (req.haslayer(ARP) and + req.getlayer(ARP).op == 1 and + (self.IP_addr == None or self.IP_addr == req.getlayer(ARP).pdst)) + + def make_reply(self, req): + ether = req.getlayer(Ether) + arp = req.getlayer(ARP) + iff,a,gw = conf.route.route(arp.psrc) + if self.iface != None: + iff = iface + ARP_addr = self.ARP_addr + IP_addr = arp.pdst + resp = Ether(dst=ether.src, + src=ARP_addr)/ARP(op="is-at", + hwsrc=ARP_addr, + psrc=IP_addr, + hwdst=arp.hwsrc, + pdst=arp.pdst) + return resp + + def sniff(self): + sniff(iface=self.iface, **self.optsniff) + +@conf.commands.register +def etherleak(target, **kargs): + """Exploit Etherleak flaw""" + return srpflood(Ether()/ARP(pdst=target), + prn=lambda a: conf.padding_layer in a[1] and hexstr(a[1][conf.padding_layer].load), + filter="arp", **kargs) + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/l2tp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/l2tp.py new file mode 100644 index 00000000..0b56db21 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/l2tp.py @@ -0,0 +1,36 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +L2TP (Layer 2 Tunneling Protocol) for VPNs. + +[RFC 2661] +""" + +import struct + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP +from scapy.layers.ppp import PPP + +class L2TP(Packet): + fields_desc = [ ShortEnumField("pkt_type",2,{2:"data"}), + ShortField("len", None), + ShortField("tunnel_id", 0), + ShortField("session_id", 0), + ShortField("ns", 0), + ShortField("nr", 0), + ShortField("offset", 0) ] + + def post_build(self, pkt, pay): + if self.len is None: + l = len(pkt)+len(pay) + pkt = pkt[:2]+struct.pack("!H", l)+pkt[4:] + return pkt+pay + + +bind_layers( UDP, L2TP, sport=1701, dport=1701) +bind_layers( L2TP, PPP, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/llmnr.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/llmnr.py new file mode 100644 index 00000000..65ecad41 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/llmnr.py @@ -0,0 +1,65 @@ +from scapy.fields import * +from scapy.packet import * +from scapy.layers.inet import UDP +from scapy.layers.dns import DNSQRField, DNSRRField, DNSRRCountField + +""" +LLMNR (Link Local Multicast Node Resolution). + +[RFC 4795] +""" + +############################################################################# +### LLMNR (RFC4795) ### +############################################################################# +# LLMNR is based on the DNS packet format (RFC1035 Section 4) +# RFC also envisions LLMNR over TCP. Like vista, we don't support it -- arno + +_LLMNR_IPv6_mcast_Addr = "FF02:0:0:0:0:0:1:3" +_LLMNR_IPv4_mcast_addr = "224.0.0.252" + +class LLMNRQuery(Packet): + name = "Link Local Multicast Node Resolution - Query" + fields_desc = [ ShortField("id", 0), + BitField("qr", 0, 1), + BitEnumField("opcode", 0, 4, { 0:"QUERY" }), + BitField("c", 0, 1), + BitField("tc", 0, 2), + BitField("z", 0, 4), + BitEnumField("rcode", 0, 4, { 0:"ok" }), + DNSRRCountField("qdcount", None, "qd"), + DNSRRCountField("ancount", None, "an"), + DNSRRCountField("nscount", None, "ns"), + DNSRRCountField("arcount", None, "ar"), + DNSQRField("qd", "qdcount"), + DNSRRField("an", "ancount"), + DNSRRField("ns", "nscount"), + DNSRRField("ar", "arcount",0)] + overload_fields = {UDP: {"sport": 5355, "dport": 5355 }} + def hashret(self): + return struct.pack("!H", self.id) + +class LLMNRResponse(LLMNRQuery): + name = "Link Local Multicast Node Resolution - Response" + qr = 1 + def answers(self, other): + return (isinstance(other, LLMNRQuery) and + self.id == other.id and + self.qr == 1 and + other.qr == 0) + +def _llmnr_dispatcher(x, *args, **kargs): + cls = conf.raw_layer + if len(x) >= 3: + if (ord(x[4]) & 0x80): # Response + cls = LLMNRResponse + else: # Query + cls = LLMNRQuery + return cls(x, *args, **kargs) + +bind_bottom_up(UDP, _llmnr_dispatcher, { "dport": 5355 }) +bind_bottom_up(UDP, _llmnr_dispatcher, { "sport": 5355 }) + +# LLMNRQuery(id=RandShort(), qd=DNSQR(qname="vista."))) + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/mgcp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/mgcp.py new file mode 100644 index 00000000..5d8a064e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/mgcp.py @@ -0,0 +1,45 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +MGCP (Media Gateway Control Protocol) + +[RFC 2805] +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP + +class MGCP(Packet): + name = "MGCP" + longname = "Media Gateway Control Protocol" + fields_desc = [ StrStopField("verb","AUEP"," ", -1), + StrFixedLenField("sep1"," ",1), + StrStopField("transaction_id","1234567"," ", -1), + StrFixedLenField("sep2"," ",1), + StrStopField("endpoint","dummy@dummy.net"," ", -1), + StrFixedLenField("sep3"," ",1), + StrStopField("version","MGCP 1.0 NCS 1.0","\x0a", -1), + StrFixedLenField("sep4","\x0a",1), + ] + + +#class MGCP(Packet): +# name = "MGCP" +# longname = "Media Gateway Control Protocol" +# fields_desc = [ ByteEnumField("type",0, ["request","response","others"]), +# ByteField("code0",0), +# ByteField("code1",0), +# ByteField("code2",0), +# ByteField("code3",0), +# ByteField("code4",0), +# IntField("trasid",0), +# IntField("req_time",0), +# ByteField("is_duplicate",0), +# ByteField("req_available",0) ] +# +bind_layers( UDP, MGCP, dport=2727) +bind_layers( UDP, MGCP, sport=2727) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/mobileip.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/mobileip.py new file mode 100644 index 00000000..bbaa8ce7 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/mobileip.py @@ -0,0 +1,47 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Mobile IP. +""" + +from scapy.fields import * +from scapy.packet import * +from scapy.layers.inet import IP,UDP + + +class MobileIP(Packet): + name = "Mobile IP (RFC3344)" + fields_desc = [ ByteEnumField("type", 1, {1:"RRQ", 3:"RRP"}) ] + +class MobileIPRRQ(Packet): + name = "Mobile IP Registration Request (RFC3344)" + fields_desc = [ XByteField("flags", 0), + ShortField("lifetime", 180), + IPField("homeaddr", "0.0.0.0"), + IPField("haaddr", "0.0.0.0"), + IPField("coaddr", "0.0.0.0"), + LongField("id", 0), ] + +class MobileIPRRP(Packet): + name = "Mobile IP Registration Reply (RFC3344)" + fields_desc = [ ByteField("code", 0), + ShortField("lifetime", 180), + IPField("homeaddr", "0.0.0.0"), + IPField("haaddr", "0.0.0.0"), + LongField("id", 0), ] + +class MobileIPTunnelData(Packet): + name = "Mobile IP Tunnel Data Message (RFC3519)" + fields_desc = [ ByteField("nexthdr", 4), + ShortField("res", 0) ] + + +bind_layers( UDP, MobileIP, sport=434) +bind_layers( UDP, MobileIP, dport=434) +bind_layers( MobileIP, MobileIPRRQ, type=1) +bind_layers( MobileIP, MobileIPRRP, type=3) +bind_layers( MobileIP, MobileIPTunnelData, type=4) +bind_layers( MobileIPTunnelData, IP, nexthdr=4) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/netbios.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/netbios.py new file mode 100644 index 00000000..f06e9307 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/netbios.py @@ -0,0 +1,222 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +NetBIOS over TCP/IP + +[RFC 1001/1002] +""" + +import struct +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP,TCP +from scapy.layers.l2 import SourceMACField + +class NetBIOS_DS(Packet): + name = "NetBIOS datagram service" + fields_desc = [ + ByteEnumField("type",17, {17:"direct_group"}), + ByteField("flags",0), + XShortField("id",0), + IPField("src","127.0.0.1"), + ShortField("sport",138), + ShortField("len",None), + ShortField("ofs",0), + NetBIOSNameField("srcname",""), + NetBIOSNameField("dstname",""), + ] + def post_build(self, p, pay): + p += pay + if self.len is None: + l = len(p)-14 + p = p[:10]+struct.pack("!H", l)+p[12:] + return p + +# ShortField("length",0), +# ShortField("Delimitor",0), +# ByteField("command",0), +# ByteField("data1",0), +# ShortField("data2",0), +# ShortField("XMIt",0), +# ShortField("RSPCor",0), +# StrFixedLenField("dest","",16), +# StrFixedLenField("source","",16), +# +# ] +# + +#NetBIOS + + +# Name Query Request +# Node Status Request +class NBNSQueryRequest(Packet): + name="NBNS query request" + fields_desc = [ShortField("NAME_TRN_ID",0), + ShortField("FLAGS", 0x0110), + ShortField("QDCOUNT",1), + ShortField("ANCOUNT",0), + ShortField("NSCOUNT",0), + ShortField("ARCOUNT",0), + NetBIOSNameField("QUESTION_NAME","windows"), + ShortEnumField("SUFFIX",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + ShortEnumField("QUESTION_TYPE",0x20, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("QUESTION_CLASS",1,{1:"INTERNET"})] + +# Name Registration Request +# Name Refresh Request +# Name Release Request or Demand +class NBNSRequest(Packet): + name="NBNS request" + fields_desc = [ShortField("NAME_TRN_ID",0), + ShortField("FLAGS", 0x2910), + ShortField("QDCOUNT",1), + ShortField("ANCOUNT",0), + ShortField("NSCOUNT",0), + ShortField("ARCOUNT",1), + NetBIOSNameField("QUESTION_NAME","windows"), + ShortEnumField("SUFFIX",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + ShortEnumField("QUESTION_TYPE",0x20, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("QUESTION_CLASS",1,{1:"INTERNET"}), + ShortEnumField("RR_NAME",0xC00C,{0xC00C:"Label String Pointer to QUESTION_NAME"}), + ShortEnumField("RR_TYPE",0x20, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("RR_CLASS",1,{1:"INTERNET"}), + IntField("TTL", 0), + ShortField("RDLENGTH", 6), + BitEnumField("G",0,1,{0:"Unique name",1:"Group name"}), + BitEnumField("OWNER_NODE_TYPE",00,2,{0:"B node",1:"P node",2:"M node",3:"H node"}), + BitEnumField("UNUSED",0,13,{0:"Unused"}), + IPField("NB_ADDRESS", "127.0.0.1")] + +# Name Query Response +# Name Registration Response +class NBNSQueryResponse(Packet): + name="NBNS query response" + fields_desc = [ShortField("NAME_TRN_ID",0), + ShortField("FLAGS", 0x8500), + ShortField("QDCOUNT",0), + ShortField("ANCOUNT",1), + ShortField("NSCOUNT",0), + ShortField("ARCOUNT",0), + NetBIOSNameField("RR_NAME","windows"), + ShortEnumField("SUFFIX",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + ShortEnumField("QUESTION_TYPE",0x20, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("QUESTION_CLASS",1,{1:"INTERNET"}), + IntField("TTL", 0x493e0), + ShortField("RDLENGTH", 6), + ShortField("NB_FLAGS", 0), + IPField("NB_ADDRESS", "127.0.0.1")] + +# Name Query Response (negative) +# Name Release Response +class NBNSQueryResponseNegative(Packet): + name="NBNS query response (negative)" + fields_desc = [ShortField("NAME_TRN_ID",0), + ShortField("FLAGS", 0x8506), + ShortField("QDCOUNT",0), + ShortField("ANCOUNT",1), + ShortField("NSCOUNT",0), + ShortField("ARCOUNT",0), + NetBIOSNameField("RR_NAME","windows"), + ShortEnumField("SUFFIX",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + ShortEnumField("RR_TYPE",0x20, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("RR_CLASS",1,{1:"INTERNET"}), + IntField("TTL",0), + ShortField("RDLENGTH",6), + BitEnumField("G",0,1,{0:"Unique name",1:"Group name"}), + BitEnumField("OWNER_NODE_TYPE",00,2,{0:"B node",1:"P node",2:"M node",3:"H node"}), + BitEnumField("UNUSED",0,13,{0:"Unused"}), + IPField("NB_ADDRESS", "127.0.0.1")] + +# Node Status Response +class NBNSNodeStatusResponse(Packet): + name="NBNS Node Status Response" + fields_desc = [ShortField("NAME_TRN_ID",0), + ShortField("FLAGS", 0x8500), + ShortField("QDCOUNT",0), + ShortField("ANCOUNT",1), + ShortField("NSCOUNT",0), + ShortField("ARCOUNT",0), + NetBIOSNameField("RR_NAME","windows"), + ShortEnumField("SUFFIX",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + ShortEnumField("RR_TYPE",0x21, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("RR_CLASS",1,{1:"INTERNET"}), + IntField("TTL",0), + ShortField("RDLENGTH",83), + ByteField("NUM_NAMES",1)] + +# Service for Node Status Response +class NBNSNodeStatusResponseService(Packet): + name="NBNS Node Status Response Service" + fields_desc = [StrFixedLenField("NETBIOS_NAME","WINDOWS ",15), + ByteEnumField("SUFFIX",0,{0:"workstation",0x03:"messenger service",0x20:"file server service",0x1b:"domain master browser",0x1c:"domain controller", 0x1e:"browser election service"}), + ByteField("NAME_FLAGS",0x4), + ByteEnumField("UNUSED",0,{0:"unused"})] + +# End of Node Status Response packet +class NBNSNodeStatusResponseEnd(Packet): + name="NBNS Node Status Response" + fields_desc = [SourceMACField("MAC_ADDRESS"), + BitField("STATISTICS",0,57*8)] + +# Wait for Acknowledgement Response +class NBNSWackResponse(Packet): + name="NBNS Wait for Acknowledgement Response" + fields_desc = [ShortField("NAME_TRN_ID",0), + ShortField("FLAGS", 0xBC07), + ShortField("QDCOUNT",0), + ShortField("ANCOUNT",1), + ShortField("NSCOUNT",0), + ShortField("ARCOUNT",0), + NetBIOSNameField("RR_NAME","windows"), + ShortEnumField("SUFFIX",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + ShortEnumField("RR_TYPE",0x20, {0x20:"NB",0x21:"NBSTAT"}), + ShortEnumField("RR_CLASS",1,{1:"INTERNET"}), + IntField("TTL", 2), + ShortField("RDLENGTH",2), + BitField("RDATA",10512,16)] #10512=0010100100010000 + +class NBTDatagram(Packet): + name="NBT Datagram Packet" + fields_desc= [ByteField("Type", 0x10), + ByteField("Flags", 0x02), + ShortField("ID", 0), + IPField("SourceIP", "127.0.0.1"), + ShortField("SourcePort", 138), + ShortField("Length", 272), + ShortField("Offset", 0), + NetBIOSNameField("SourceName",b"windows"), + ShortEnumField("SUFFIX1",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0), + NetBIOSNameField("DestinationName",b"windows"), + ShortEnumField("SUFFIX2",0x4141,{0x4141:"workstation",0x4141+0x03:"messenger service",0x4141+0x200:"file server service",0x4141+0x10b:"domain master browser",0x4141+0x10c:"domain controller", 0x4141+0x10e:"browser election service"}), + ByteField("NULL",0)] + + +class NBTSession(Packet): + name="NBT Session Packet" + fields_desc= [ByteEnumField("TYPE",0,{0x00:"Session Message",0x81:"Session Request",0x82:"Positive Session Response",0x83:"Negative Session Response",0x84:"Retarget Session Response",0x85:"Session Keepalive"}), + BitField("RESERVED",0x00,7), + BitField("LENGTH",0,17)] + +bind_layers( UDP, NBNSQueryRequest, dport=137) +bind_layers( UDP, NBNSRequest, dport=137) +bind_layers( UDP, NBNSQueryResponse, sport=137) +bind_layers( UDP, NBNSQueryResponseNegative, sport=137) +bind_layers( UDP, NBNSNodeStatusResponse, sport=137) +bind_layers( NBNSNodeStatusResponse, NBNSNodeStatusResponseService, ) +bind_layers( NBNSNodeStatusResponse, NBNSNodeStatusResponseService, ) +bind_layers( NBNSNodeStatusResponseService, NBNSNodeStatusResponseService, ) +bind_layers( NBNSNodeStatusResponseService, NBNSNodeStatusResponseEnd, ) +bind_layers( UDP, NBNSWackResponse, sport=137) +bind_layers( UDP, NBTDatagram, dport=138) +bind_layers( TCP, NBTSession, dport=139) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/netflow.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/netflow.py new file mode 100644 index 00000000..44567737 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/netflow.py @@ -0,0 +1,48 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Cisco NetFlow protocol v1 +""" + + +from scapy.fields import * +from scapy.packet import * + +# Cisco Netflow Protocol version 1 +class NetflowHeader(Packet): + name = "Netflow Header" + fields_desc = [ ShortField("version", 1) ] + +class NetflowHeaderV1(Packet): + name = "Netflow Header V1" + fields_desc = [ ShortField("count", 0), + IntField("sysUptime", 0), + IntField("unixSecs", 0), + IntField("unixNanoSeconds", 0) ] + + +class NetflowRecordV1(Packet): + name = "Netflow Record" + fields_desc = [ IPField("ipsrc", "0.0.0.0"), + IPField("ipdst", "0.0.0.0"), + IPField("nexthop", "0.0.0.0"), + ShortField("inputIfIndex", 0), + ShortField("outpuIfIndex", 0), + IntField("dpkts", 0), + IntField("dbytes", 0), + IntField("starttime", 0), + IntField("endtime", 0), + ShortField("srcport", 0), + ShortField("dstport", 0), + ShortField("padding", 0), + ByteField("proto", 0), + ByteField("tos", 0), + IntField("padding1", 0), + IntField("padding2", 0) ] + + +bind_layers( NetflowHeader, NetflowHeaderV1, version=1) +bind_layers( NetflowHeaderV1, NetflowRecordV1, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/ntp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ntp.py new file mode 100644 index 00000000..6d11966c --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ntp.py @@ -0,0 +1,77 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +NTP (Network Time Protocol). +""" + +import time +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP + + +# seconds between 01-01-1900 and 01-01-1970 +_NTP_BASETIME = 2208988800 + +class TimeStampField(FixedPointField): + def __init__(self, name, default): + FixedPointField.__init__(self, name, default, 64, 32) + + def i2repr(self, pkt, val): + if val is None: + return "--" + val = self.i2h(pkt,val) + if val < _NTP_BASETIME: + return val + return time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(val-_NTP_BASETIME)) + + def any2i(self, pkt, val): + if type(val) is str: + return int(time.mktime(time.strptime(val))) + _NTP_BASETIME + 3600 # XXX + return FixedPointField.any2i(self,pkt,val) + + def i2m(self, pkt, val): + if val is None: + val = FixedPointField.any2i(self, pkt, time.time()+_NTP_BASETIME) + return FixedPointField.i2m(self, pkt, val) + + + +class NTP(Packet): + # RFC 1769 + name = "NTP" + fields_desc = [ + BitEnumField('leap', 0, 2, + { 0: 'nowarning', + 1: 'longminute', + 2: 'shortminute', + 3: 'notsync'}), + BitField('version', 3, 3), + BitEnumField('mode', 3, 3, + { 0: 'reserved', + 1: 'sym_active', + 2: 'sym_passive', + 3: 'client', + 4: 'server', + 5: 'broadcast', + 6: 'control', + 7: 'private'}), + BitField('stratum', 2, 8), + BitField('poll', 0xa, 8), ### XXX : it's a signed int + BitField('precision', 0, 8), ### XXX : it's a signed int + FixedPointField('delay', 0, size=32, frac_bits=16), + FixedPointField('dispersion', 0, size=32, frac_bits=16), + IPField('id', "127.0.0.1"), + TimeStampField('ref', 0), + TimeStampField('orig', None), # None means current time + TimeStampField('recv', 0), + TimeStampField('sent', None) + ] + def mysummary(self): + return self.sprintf("NTP v%ir,NTP.version%, %NTP.mode%") + + +bind_layers( UDP, NTP, dport=123, sport=123) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/pflog.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/pflog.py new file mode 100644 index 00000000..a8fc9fe0 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/pflog.py @@ -0,0 +1,59 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +PFLog: OpenBSD PF packet filter logging. +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import IP +if conf.ipv6_enabled: + from scapy.layers.inet6 import IPv6 +from scapy.config import conf + +class PFLog(Packet): + name = "PFLog" + # from OpenBSD src/sys/net/pfvar.h and src/sys/net/if_pflog.h + fields_desc = [ ByteField("hdrlen", 0), + ByteEnumField("addrfamily", 2, {socket.AF_INET: "IPv4", + socket.AF_INET6: "IPv6"}), + ByteEnumField("action", 1, {0: "pass", 1: "drop", + 2: "scrub", 3: "no-scrub", + 4: "nat", 5: "no-nat", + 6: "binat", 7: "no-binat", + 8: "rdr", 9: "no-rdr", + 10: "syn-proxy-drop" }), + ByteEnumField("reason", 0, {0: "match", 1: "bad-offset", + 2: "fragment", 3: "short", + 4: "normalize", 5: "memory", + 6: "bad-timestamp", + 7: "congestion", + 8: "ip-options", + 9: "proto-cksum", + 10: "state-mismatch", + 11: "state-insert", + 12: "state-limit", + 13: "src-limit", + 14: "syn-proxy" }), + StrFixedLenField("iface", "", 16), + StrFixedLenField("ruleset", "", 16), + SignedIntField("rulenumber", 0), + SignedIntField("subrulenumber", 0), + SignedIntField("uid", 0), + IntField("pid", 0), + SignedIntField("ruleuid", 0), + IntField("rulepid", 0), + ByteEnumField("direction", 255, {0: "inout", 1: "in", + 2:"out", 255: "unknown"}), + StrFixedLenField("pad", "\x00\x00\x00", 3 ) ] + def mysummary(self): + return self.sprintf("%PFLog.addrfamily% %PFLog.action% on %PFLog.iface% by rule %PFLog.rulenumber%") + +bind_layers(PFLog, IP, addrfamily=socket.AF_INET) +if conf.ipv6_enabled: + bind_layers(PFLog, IPv6, addrfamily=socket.AF_INET6) + +conf.l2types.register(117, PFLog) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/ppp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ppp.py new file mode 100644 index 00000000..08cf62cd --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/ppp.py @@ -0,0 +1,349 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +PPP (Point to Point Protocol) + +[RFC 1661] +""" + +import struct +from scapy.packet import * +from scapy.layers.l2 import * +from scapy.layers.inet import * +from scapy.fields import * + +class PPPoE(Packet): + name = "PPP over Ethernet" + fields_desc = [ BitField("version", 1, 4), + BitField("type", 1, 4), + ByteEnumField("code", 0, {0:"Session"}), + XShortField("sessionid", 0x0), + ShortField("len", None) ] + + def post_build(self, p, pay): + p += pay + if self.len is None: + l = len(p)-6 + p = p[:4]+struct.pack("!H", l)+p[6:] + return p + +class PPPoED(PPPoE): + name = "PPP over Ethernet Discovery" + fields_desc = [ BitField("version", 1, 4), + BitField("type", 1, 4), + ByteEnumField("code", 0x09, {0x09:"PADI",0x07:"PADO",0x19:"PADR",0x65:"PADS",0xa7:"PADT"}), + XShortField("sessionid", 0x0), + ShortField("len", None) ] + + +_PPP_proto = { 0x0001: "Padding Protocol", + 0x0003: "ROHC small-CID [RFC3095]", + 0x0005: "ROHC large-CID [RFC3095]", + 0x0021: "Internet Protocol version 4", + 0x0023: "OSI Network Layer", + 0x0025: "Xerox NS IDP", + 0x0027: "DECnet Phase IV", + 0x0029: "Appletalk", + 0x002b: "Novell IPX", + 0x002d: "Van Jacobson Compressed TCP/IP", + 0x002f: "Van Jacobson Uncompressed TCP/IP", + 0x0031: "Bridging PDU", + 0x0033: "Stream Protocol (ST-II)", + 0x0035: "Banyan Vines", + 0x0037: "reserved (until 1993) [Typo in RFC1172]", + 0x0039: "AppleTalk EDDP", + 0x003b: "AppleTalk SmartBuffered", + 0x003d: "Multi-Link [RFC1717]", + 0x003f: "NETBIOS Framing", + 0x0041: "Cisco Systems", + 0x0043: "Ascom Timeplex", + 0x0045: "Fujitsu Link Backup and Load Balancing (LBLB)", + 0x0047: "DCA Remote Lan", + 0x0049: "Serial Data Transport Protocol (PPP-SDTP)", + 0x004b: "SNA over 802.2", + 0x004d: "SNA", + 0x004f: "IPv6 Header Compression", + 0x0051: "KNX Bridging Data [ianp]", + 0x0053: "Encryption [Meyer]", + 0x0055: "Individual Link Encryption [Meyer]", + 0x0057: "Internet Protocol version 6 [Hinden]", + 0x0059: "PPP Muxing [RFC3153]", + 0x005b: "Vendor-Specific Network Protocol (VSNP) [RFC3772]", + 0x0061: "RTP IPHC Full Header [RFC3544]", + 0x0063: "RTP IPHC Compressed TCP [RFC3544]", + 0x0065: "RTP IPHC Compressed Non TCP [RFC3544]", + 0x0067: "RTP IPHC Compressed UDP 8 [RFC3544]", + 0x0069: "RTP IPHC Compressed RTP 8 [RFC3544]", + 0x006f: "Stampede Bridging", + 0x0071: "Reserved [Fox]", + 0x0073: "MP+ Protocol [Smith]", + 0x007d: "reserved (Control Escape) [RFC1661]", + 0x007f: "reserved (compression inefficient [RFC1662]", + 0x0081: "Reserved Until 20-Oct-2000 [IANA]", + 0x0083: "Reserved Until 20-Oct-2000 [IANA]", + 0x00c1: "NTCITS IPI [Ungar]", + 0x00cf: "reserved (PPP NLID)", + 0x00fb: "single link compression in multilink [RFC1962]", + 0x00fd: "compressed datagram [RFC1962]", + 0x00ff: "reserved (compression inefficient)", + 0x0201: "802.1d Hello Packets", + 0x0203: "IBM Source Routing BPDU", + 0x0205: "DEC LANBridge100 Spanning Tree", + 0x0207: "Cisco Discovery Protocol [Sastry]", + 0x0209: "Netcs Twin Routing [Korfmacher]", + 0x020b: "STP - Scheduled Transfer Protocol [Segal]", + 0x020d: "EDP - Extreme Discovery Protocol [Grosser]", + 0x0211: "Optical Supervisory Channel Protocol (OSCP)[Prasad]", + 0x0213: "Optical Supervisory Channel Protocol (OSCP)[Prasad]", + 0x0231: "Luxcom", + 0x0233: "Sigma Network Systems", + 0x0235: "Apple Client Server Protocol [Ridenour]", + 0x0281: "MPLS Unicast [RFC3032] ", + 0x0283: "MPLS Multicast [RFC3032]", + 0x0285: "IEEE p1284.4 standard - data packets [Batchelder]", + 0x0287: "ETSI TETRA Network Protocol Type 1 [Nieminen]", + 0x0289: "Multichannel Flow Treatment Protocol [McCann]", + 0x2063: "RTP IPHC Compressed TCP No Delta [RFC3544]", + 0x2065: "RTP IPHC Context State [RFC3544]", + 0x2067: "RTP IPHC Compressed UDP 16 [RFC3544]", + 0x2069: "RTP IPHC Compressed RTP 16 [RFC3544]", + 0x4001: "Cray Communications Control Protocol [Stage]", + 0x4003: "CDPD Mobile Network Registration Protocol [Quick]", + 0x4005: "Expand accelerator protocol [Rachmani]", + 0x4007: "ODSICP NCP [Arvind]", + 0x4009: "DOCSIS DLL [Gaedtke]", + 0x400B: "Cetacean Network Detection Protocol [Siller]", + 0x4021: "Stacker LZS [Simpson]", + 0x4023: "RefTek Protocol [Banfill]", + 0x4025: "Fibre Channel [Rajagopal]", + 0x4027: "EMIT Protocols [Eastham]", + 0x405b: "Vendor-Specific Protocol (VSP) [RFC3772]", + 0x8021: "Internet Protocol Control Protocol", + 0x8023: "OSI Network Layer Control Protocol", + 0x8025: "Xerox NS IDP Control Protocol", + 0x8027: "DECnet Phase IV Control Protocol", + 0x8029: "Appletalk Control Protocol", + 0x802b: "Novell IPX Control Protocol", + 0x802d: "reserved", + 0x802f: "reserved", + 0x8031: "Bridging NCP", + 0x8033: "Stream Protocol Control Protocol", + 0x8035: "Banyan Vines Control Protocol", + 0x8037: "reserved (until 1993)", + 0x8039: "reserved", + 0x803b: "reserved", + 0x803d: "Multi-Link Control Protocol", + 0x803f: "NETBIOS Framing Control Protocol", + 0x8041: "Cisco Systems Control Protocol", + 0x8043: "Ascom Timeplex", + 0x8045: "Fujitsu LBLB Control Protocol", + 0x8047: "DCA Remote Lan Network Control Protocol (RLNCP)", + 0x8049: "Serial Data Control Protocol (PPP-SDCP)", + 0x804b: "SNA over 802.2 Control Protocol", + 0x804d: "SNA Control Protocol", + 0x804f: "IP6 Header Compression Control Protocol", + 0x8051: "KNX Bridging Control Protocol [ianp]", + 0x8053: "Encryption Control Protocol [Meyer]", + 0x8055: "Individual Link Encryption Control Protocol [Meyer]", + 0x8057: "IPv6 Control Protovol [Hinden]", + 0x8059: "PPP Muxing Control Protocol [RFC3153]", + 0x805b: "Vendor-Specific Network Control Protocol (VSNCP) [RFC3772]", + 0x806f: "Stampede Bridging Control Protocol", + 0x8073: "MP+ Control Protocol [Smith]", + 0x8071: "Reserved [Fox]", + 0x807d: "Not Used - reserved [RFC1661]", + 0x8081: "Reserved Until 20-Oct-2000 [IANA]", + 0x8083: "Reserved Until 20-Oct-2000 [IANA]", + 0x80c1: "NTCITS IPI Control Protocol [Ungar]", + 0x80cf: "Not Used - reserved [RFC1661]", + 0x80fb: "single link compression in multilink control [RFC1962]", + 0x80fd: "Compression Control Protocol [RFC1962]", + 0x80ff: "Not Used - reserved [RFC1661]", + 0x8207: "Cisco Discovery Protocol Control [Sastry]", + 0x8209: "Netcs Twin Routing [Korfmacher]", + 0x820b: "STP - Control Protocol [Segal]", + 0x820d: "EDPCP - Extreme Discovery Protocol Ctrl Prtcl [Grosser]", + 0x8235: "Apple Client Server Protocol Control [Ridenour]", + 0x8281: "MPLSCP [RFC3032]", + 0x8285: "IEEE p1284.4 standard - Protocol Control [Batchelder]", + 0x8287: "ETSI TETRA TNP1 Control Protocol [Nieminen]", + 0x8289: "Multichannel Flow Treatment Protocol [McCann]", + 0xc021: "Link Control Protocol", + 0xc023: "Password Authentication Protocol", + 0xc025: "Link Quality Report", + 0xc027: "Shiva Password Authentication Protocol", + 0xc029: "CallBack Control Protocol (CBCP)", + 0xc02b: "BACP Bandwidth Allocation Control Protocol [RFC2125]", + 0xc02d: "BAP [RFC2125]", + 0xc05b: "Vendor-Specific Authentication Protocol (VSAP) [RFC3772]", + 0xc081: "Container Control Protocol [KEN]", + 0xc223: "Challenge Handshake Authentication Protocol", + 0xc225: "RSA Authentication Protocol [Narayana]", + 0xc227: "Extensible Authentication Protocol [RFC2284]", + 0xc229: "Mitsubishi Security Info Exch Ptcl (SIEP) [Seno]", + 0xc26f: "Stampede Bridging Authorization Protocol", + 0xc281: "Proprietary Authentication Protocol [KEN]", + 0xc283: "Proprietary Authentication Protocol [Tackabury]", + 0xc481: "Proprietary Node ID Authentication Protocol [KEN]"} + + +class HDLC(Packet): + fields_desc = [ XByteField("address",0xff), + XByteField("control",0x03) ] + +class PPP(Packet): + name = "PPP Link Layer" + fields_desc = [ ShortEnumField("proto", 0x0021, _PPP_proto) ] + @classmethod + def dispatch_hook(cls, _pkt=None, *args, **kargs): + if _pkt and _pkt[0] == 0xff: + cls = HDLC + return cls + +_PPP_conftypes = { 1:"Configure-Request", + 2:"Configure-Ack", + 3:"Configure-Nak", + 4:"Configure-Reject", + 5:"Terminate-Request", + 6:"Terminate-Ack", + 7:"Code-Reject", + 8:"Protocol-Reject", + 9:"Echo-Request", + 10:"Echo-Reply", + 11:"Discard-Request", + 14:"Reset-Request", + 15:"Reset-Ack", + } + + +### PPP IPCP stuff (RFC 1332) + +# All IPCP options are defined below (names and associated classes) +_PPP_ipcpopttypes = { 1:"IP-Addresses (Deprecated)", + 2:"IP-Compression-Protocol", + 3:"IP-Address", + 4:"Mobile-IPv4", # not implemented, present for completeness + 129:"Primary-DNS-Address", + 130:"Primary-NBNS-Address", + 131:"Secondary-DNS-Address", + 132:"Secondary-NBNS-Address"} + + +class PPP_IPCP_Option(Packet): + name = "PPP IPCP Option" + fields_desc = [ ByteEnumField("type" , None , _PPP_ipcpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + StrLenField("data", b"", length_from=lambda p:max(0,p.len-2)) ] + def extract_padding(self, pay): + return b"",pay + + registered_options = {} + @classmethod + def register_variant(cls): + cls.registered_options[cls.type.default] = cls + @classmethod + def dispatch_hook(cls, _pkt=None, *args, **kargs): + if _pkt: + #o = ord(_pkt[0]) + o = (_pkt[0]) + return cls.registered_options.get(o, cls) + return cls + + +class PPP_IPCP_Option_IPAddress(PPP_IPCP_Option): + name = "PPP IPCP Option: IP Address" + fields_desc = [ ByteEnumField("type" , 3 , _PPP_ipcpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + IPField("data","0.0.0.0"), + ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] + +class PPP_IPCP_Option_DNS1(PPP_IPCP_Option): + name = "PPP IPCP Option: DNS1 Address" + fields_desc = [ ByteEnumField("type" , 129 , _PPP_ipcpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + IPField("data","0.0.0.0"), + ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] + +class PPP_IPCP_Option_DNS2(PPP_IPCP_Option): + name = "PPP IPCP Option: DNS2 Address" + fields_desc = [ ByteEnumField("type" , 131 , _PPP_ipcpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + IPField("data","0.0.0.0"), + ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] + +class PPP_IPCP_Option_NBNS1(PPP_IPCP_Option): + name = "PPP IPCP Option: NBNS1 Address" + fields_desc = [ ByteEnumField("type" , 130 , _PPP_ipcpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + IPField("data","0.0.0.0"), + ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] + +class PPP_IPCP_Option_NBNS2(PPP_IPCP_Option): + name = "PPP IPCP Option: NBNS2 Address" + fields_desc = [ ByteEnumField("type" , 132 , _PPP_ipcpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + IPField("data","0.0.0.0"), + ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ] + + +class PPP_IPCP(Packet): + fields_desc = [ ByteEnumField("code" , 1, _PPP_conftypes), + XByteField("id", 0 ), + FieldLenField("len" , None, fmt="H", length_of="options", adjust=lambda p,x:x+4 ), + PacketListField("options", [], PPP_IPCP_Option, length_from=lambda p:p.len-4,) ] + + +### ECP + +_PPP_ecpopttypes = { 0:"OUI", + 1:"DESE", } + +class PPP_ECP_Option(Packet): + name = "PPP ECP Option" + fields_desc = [ ByteEnumField("type" , None , _PPP_ecpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2), + StrLenField("data", "", length_from=lambda p:max(0,p.len-2)) ] + def extract_padding(self, pay): + return b"",pay + + registered_options = {} + @classmethod + def register_variant(cls): + cls.registered_options[cls.type.default] = cls + @classmethod + def dispatch_hook(cls, _pkt=None, *args, **kargs): + if _pkt: + #o = ord(_pkt[0]) + o = (_pkt[0]) + return cls.registered_options.get(o, cls) + return cls + +class PPP_ECP_Option_OUI(PPP_ECP_Option): + fields_desc = [ ByteEnumField("type" , 0 , _PPP_ecpopttypes), + FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+6), + StrFixedLenField("oui","",3), + ByteField("subtype",0), + StrLenField("data", "", length_from=lambda p:p.len-6) ] + + + +class PPP_ECP(Packet): + fields_desc = [ ByteEnumField("code" , 1, _PPP_conftypes), + XByteField("id", 0 ), + FieldLenField("len" , None, fmt="H", length_of="options", adjust=lambda p,x:x+4 ), + PacketListField("options", [], PPP_ECP_Option, length_from=lambda p:p.len-4,) ] + +bind_layers( Ether, PPPoED, type=0x8863) +bind_layers( Ether, PPPoE, type=0x8864) +bind_layers( CookedLinux, PPPoED, proto=0x8863) +bind_layers( CookedLinux, PPPoE, proto=0x8864) +bind_layers( PPPoE, PPP, code=0) +bind_layers( HDLC, PPP, ) +bind_layers( PPP, IP, proto=33) +bind_layers( PPP, PPP_IPCP, proto=0x8021) +bind_layers( PPP, PPP_ECP, proto=0x8053) +bind_layers( Ether, PPP_IPCP, type=0x8021) +bind_layers( Ether, PPP_ECP, type=0x8053) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/radius.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/radius.py new file mode 100644 index 00000000..13239603 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/radius.py @@ -0,0 +1,65 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +RADIUS (Remote Authentication Dial In User Service) +""" + +import struct +from scapy.packet import * +from scapy.fields import * + +class Radius(Packet): + name = "Radius" + fields_desc = [ ByteEnumField("code", 1, {1: "Access-Request", + 2: "Access-Accept", + 3: "Access-Reject", + 4: "Accounting-Request", + 5: "Accounting-Accept", + 6: "Accounting-Status", + 7: "Password-Request", + 8: "Password-Ack", + 9: "Password-Reject", + 10: "Accounting-Message", + 11: "Access-Challenge", + 12: "Status-Server", + 13: "Status-Client", + 21: "Resource-Free-Request", + 22: "Resource-Free-Response", + 23: "Resource-Query-Request", + 24: "Resource-Query-Response", + 25: "Alternate-Resource-Reclaim-Request", + 26: "NAS-Reboot-Request", + 27: "NAS-Reboot-Response", + 29: "Next-Passcode", + 30: "New-Pin", + 31: "Terminate-Session", + 32: "Password-Expired", + 33: "Event-Request", + 34: "Event-Response", + 40: "Disconnect-Request", + 41: "Disconnect-ACK", + 42: "Disconnect-NAK", + 43: "CoA-Request", + 44: "CoA-ACK", + 45: "CoA-NAK", + 50: "IP-Address-Allocate", + 51: "IP-Address-Release", + 253: "Experimental-use", + 254: "Reserved", + 255: "Reserved"} ), + ByteField("id", 0), + ShortField("len", None), + StrFixedLenField("authenticator","",16) ] + def post_build(self, p, pay): + p += pay + l = self.len + if l is None: + l = len(p) + p = p[:2]+struct.pack("!H",l)+p[4:] + return p + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/rip.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/rip.py new file mode 100644 index 00000000..1507fe5c --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/rip.py @@ -0,0 +1,74 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +RIP (Routing Information Protocol). +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import UDP + +class RIP(Packet): + name = "RIP header" + fields_desc = [ + ByteEnumField("cmd", 1, {1:"req", 2:"resp", 3:"traceOn", 4:"traceOff", + 5:"sun", 6:"trigReq", 7:"trigResp", 8:"trigAck", + 9:"updateReq", 10:"updateResp", 11:"updateAck"}), + ByteField("version", 1), + ShortField("null", 0), + ] + + def guess_payload_class(self, payload): + if payload[:2] == "\xff\xff": + return RIPAuth + else: + return Packet.guess_payload_class(self, payload) + +class RIPEntry(RIP): + name = "RIP entry" + fields_desc = [ + ShortEnumField("AF", 2, {2:"IP"}), + ShortField("RouteTag", 0), + IPField("addr", "0.0.0.0"), + IPField("mask", "0.0.0.0"), + IPField("nextHop", "0.0.0.0"), + IntEnumField("metric", 1, {16:"Unreach"}), + ] + +class RIPAuth(Packet): + name = "RIP authentication" + fields_desc = [ + ShortEnumField("AF", 0xffff, {0xffff:"Auth"}), + ShortEnumField("authtype", 2, {1:"md5authdata", 2:"simple", 3:"md5"}), + ConditionalField(StrFixedLenField("password", None, 16), + lambda pkt: pkt.authtype == 2), + ConditionalField(ShortField("digestoffset", 0), + lambda pkt: pkt.authtype == 3), + ConditionalField(ByteField("keyid", 0), + lambda pkt: pkt.authtype == 3), + ConditionalField(ByteField("authdatalen", 0), + lambda pkt: pkt.authtype == 3), + ConditionalField(IntField("seqnum", 0), + lambda pkt: pkt.authtype == 3), + ConditionalField(StrFixedLenField("zeropad", None, 8), + lambda pkt: pkt.authtype == 3), + ConditionalField(StrLenField("authdata", None, + length_from=lambda pkt: pkt.md5datalen), + lambda pkt: pkt.authtype == 1) + ] + + def pre_dissect(self, s): + if s[2:4] == "\x00\x01": + self.md5datalen = len(s) - 4 + + return s + + +bind_layers( UDP, RIP, sport=520) +bind_layers( UDP, RIP, dport=520) +bind_layers( RIP, RIPEntry, ) +bind_layers( RIPEntry, RIPEntry, ) +bind_layers( RIPAuth, RIPEntry, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/rtp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/rtp.py new file mode 100644 index 00000000..629dccdd --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/rtp.py @@ -0,0 +1,40 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +RTP (Real-time Transport Protocol). +""" + +from scapy.packet import * +from scapy.fields import * + +_rtp_payload_types = { + # http://www.iana.org/assignments/rtp-parameters + 0: 'G.711 PCMU', 3: 'GSM', + 4: 'G723', 5: 'DVI4', + 6: 'DVI4', 7: 'LPC', + 8: 'PCMA', 9: 'G722', + 10: 'L16', 11: 'L16', + 12: 'QCELP', 13: 'CN', + 14: 'MPA', 15: 'G728', + 16: 'DVI4', 17: 'DVI4', + 18: 'G729', 25: 'CelB', + 26: 'JPEG', 28: 'nv', + 31: 'H261', 32: 'MPV', + 33: 'MP2T', 34: 'H263' } + +class RTP(Packet): + name="RTP" + fields_desc = [ BitField('version', 2, 2), + BitField('padding', 0, 1), + BitField('extension', 0, 1), + BitFieldLenField('numsync', None, 4, count_of='sync'), + BitField('marker', 0, 1), + BitEnumField('payload', 0, 7, _rtp_payload_types), + ShortField('sequence', 0), + IntField('timestamp', 0), + IntField('sourcesync', 0), + FieldListField('sync', [], IntField("id",0), count_from=lambda pkt:pkt.numsync) ] + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/sctp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/sctp.py new file mode 100644 index 00000000..57712112 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/sctp.py @@ -0,0 +1,439 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## Copyright (C) 6WIND <olivier.matz@6wind.com> +## This program is published under a GPLv2 license + +""" +SCTP (Stream Control Transmission Protocol). +""" + +import struct + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import IP +from scapy.layers.inet6 import IP6Field + +IPPROTO_SCTP=132 + +# crc32-c (Castagnoli) (crc32c_poly=0x1EDC6F41) +crc32c_table = [ + 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, + 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, + 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, + 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, + 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, + 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, + 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, + 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, + 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, + 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, + 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, + 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, + 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, + 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, + 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, + 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, + 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, + 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, + 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, + 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, + 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, + 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, + 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, + 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, + 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, + 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, + 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, + 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, + 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, + 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, + 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, + 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, + 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, + 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, + 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, + 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, + 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, + 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, + 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, + 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, + 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, + 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, + 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, + 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, + 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, + 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, + 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, + 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, + 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, + 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, + 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, + 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, + 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, + 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, + 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, + 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, + 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, + 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, + 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, + 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, + 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, + 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, + 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, + 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351, + ] + +def crc32c(buf): + crc = 0xffffffff + for c in buf: + #crc = (crc>>8) ^ crc32c_table[(crc^(ord(c))) & 0xFF] + crc = (crc>>8) ^ crc32c_table[(crc^(c)) & 0xFF] + crc = (~crc) & 0xffffffff + # reverse endianness + return struct.unpack(">I",struct.pack("<I", crc))[0] + +# old checksum (RFC2960) +""" +BASE = 65521 # largest prime smaller than 65536 +def update_adler32(adler, buf): + s1 = adler & 0xffff + s2 = (adler >> 16) & 0xffff + print(s1,s2) + + for c in buf: + print(ord(c)) + s1 = (s1 + ord(c)) % BASE + s2 = (s2 + s1) % BASE + print(s1,s2) + return (s2 << 16) + s1 + +def sctp_checksum(buf): + return update_adler32(1, buf) +""" + +sctpchunktypescls = { + 0 : "SCTPChunkData", + 1 : "SCTPChunkInit", + 2 : "SCTPChunkInitAck", + 3 : "SCTPChunkSACK", + 4 : "SCTPChunkHeartbeatReq", + 5 : "SCTPChunkHeartbeatAck", + 6 : "SCTPChunkAbort", + 7 : "SCTPChunkShutdown", + 8 : "SCTPChunkShutdownAck", + 9 : "SCTPChunkError", + 10 : "SCTPChunkCookieEcho", + 11 : "SCTPChunkCookieAck", + 14 : "SCTPChunkShutdownComplete", + } + +sctpchunktypes = { + 0 : "data", + 1 : "init", + 2 : "init-ack", + 3 : "sack", + 4 : "heartbeat-req", + 5 : "heartbeat-ack", + 6 : "abort", + 7 : "shutdown", + 8 : "shutdown-ack", + 9 : "error", + 10 : "cookie-echo", + 11 : "cookie-ack", + 14 : "shutdown-complete", + } + +sctpchunkparamtypescls = { + 1 : "SCTPChunkParamHearbeatInfo", + 5 : "SCTPChunkParamIPv4Addr", + 6 : "SCTPChunkParamIPv6Addr", + 7 : "SCTPChunkParamStateCookie", + 8 : "SCTPChunkParamUnrocognizedParam", + 9 : "SCTPChunkParamCookiePreservative", + 11 : "SCTPChunkParamHostname", + 12 : "SCTPChunkParamSupportedAddrTypes", + 32768 : "SCTPChunkParamECNCapable", + 49152 : "SCTPChunkParamFwdTSN", + 49158 : "SCTPChunkParamAdaptationLayer", + } + +sctpchunkparamtypes = { + 1 : "heartbeat-info", + 5 : "IPv4", + 6 : "IPv6", + 7 : "state-cookie", + 8 : "unrecognized-param", + 9 : "cookie-preservative", + 11 : "hostname", + 12 : "addrtypes", + 32768 : "ecn-capable", + 49152 : "fwd-tsn-supported", + 49158 : "adaptation-layer", + } + +############## SCTP header + +# Dummy class to guess payload type (variable parameters) +class _SCTPChunkGuessPayload: + def default_payload_class(self,p): + if len(p) < 4: + return conf.padding_layer + else: + t = p[0] + return globals().get(sctpchunktypescls.get(t, "Raw"), conf.raw_layer) + + +class SCTP(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ShortField("sport", None), + ShortField("dport", None), + XIntField("tag", None), + XIntField("chksum", None), ] + def answers(self, other): + if not isinstance(other, SCTP): + return 0 + if conf.checkIPsrc: + if not ((self.sport == other.dport) and + (self.dport == other.sport)): + return 0 + return 1 + def post_build(self, p, pay): + p += pay + if self.chksum is None: + crc = crc32c(str(p)) + p = p[:8]+struct.pack(">I", crc)+p[12:] + return p + +############## SCTP Chunk variable params + +class ChunkParamField(PacketListField): + islist = 1 + holds_packets=1 + def __init__(self, name, default, count_from=None, length_from=None): + PacketListField.__init__(self, name, default, conf.raw_layer, count_from=count_from, length_from=length_from) + def m2i(self, p, m): + cls = conf.raw_layer + if len(m) >= 4: + #t = ord(m[0]) * 256 + ord(m[1]) + t = (m[0]) * 256 + (m[1]) + cls = globals().get(sctpchunkparamtypescls.get(t, "Raw"), conf.raw_layer) + return cls(m) + +# dummy class to avoid Raw() after Chunk params +class _SCTPChunkParam: + def extract_padding(self, s): + return b"",s[:] + +class SCTPChunkParamHearbeatInfo(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 1, sctpchunkparamtypes), + FieldLenField("len", None, length_of="data", + adjust = lambda pkt,x:x+4), + PadField(StrLenField("data", b"", + length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"),] + +class SCTPChunkParamIPv4Addr(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 5, sctpchunkparamtypes), + ShortField("len", 8), + IPField("addr","127.0.0.1"), ] + +class SCTPChunkParamIPv6Addr(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 6, sctpchunkparamtypes), + ShortField("len", 20), + IP6Field("addr","::1"), ] + +class SCTPChunkParamStateCookie(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 7, sctpchunkparamtypes), + FieldLenField("len", None, length_of="cookie", + adjust = lambda pkt,x:x+4), + PadField(StrLenField("cookie", b"", + length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"),] + +class SCTPChunkParamUnrocognizedParam(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 8, sctpchunkparamtypes), + FieldLenField("len", None, length_of="param", + adjust = lambda pkt,x:x+4), + PadField(StrLenField("param", b"", + length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"),] + +class SCTPChunkParamCookiePreservative(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 9, sctpchunkparamtypes), + ShortField("len", 8), + XIntField("sug_cookie_inc", None), ] + +class SCTPChunkParamHostname(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 11, sctpchunkparamtypes), + FieldLenField("len", None, length_of="hostname", + adjust = lambda pkt,x:x+4), + PadField(StrLenField("hostname", b"", + length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"), ] + +class SCTPChunkParamSupportedAddrTypes(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 12, sctpchunkparamtypes), + FieldLenField("len", None, length_of="addr_type_list", + adjust = lambda pkt,x:x+4), + PadField(FieldListField("addr_type_list", [ "IPv4" ], + ShortEnumField("addr_type", 5, sctpchunkparamtypes), + length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"), ] + +class SCTPChunkParamECNCapable(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 32768, sctpchunkparamtypes), + ShortField("len", 4), ] + +class SCTPChunkParamFwdTSN(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 49152, sctpchunkparamtypes), + ShortField("len", 4), ] + +class SCTPChunkParamAdaptationLayer(_SCTPChunkParam, Packet): + fields_desc = [ ShortEnumField("type", 49158, sctpchunkparamtypes), + ShortField("len", 8), + XIntField("indication", None), ] + +############## SCTP Chunks + +class SCTPChunkData(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 0, sctpchunktypes), + BitField("reserved", None, 4), + BitField("delay_sack", 0, 1), + BitField("unordered", 0, 1), + BitField("beginning", 0, 1), + BitField("ending", 0, 1), + FieldLenField("len", None, length_of="data", adjust = lambda pkt,x:x+16), + XIntField("tsn", None), + XShortField("stream_id", None), + XShortField("stream_seq", None), + XIntField("proto_id", None), + PadField(StrLenField("data", None, length_from=lambda pkt: pkt.len-16), + 4, padwith=b"\x00"), + ] + +class SCTPChunkInit(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 1, sctpchunktypes), + XByteField("flags", None), + FieldLenField("len", None, length_of="params", adjust = lambda pkt,x:x+20), + XIntField("init_tag", None), + IntField("a_rwnd", None), + ShortField("n_out_streams", None), + ShortField("n_in_streams", None), + XIntField("init_tsn", None), + ChunkParamField("params", None, length_from=lambda pkt:pkt.len-20), + ] + +class SCTPChunkInitAck(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 2, sctpchunktypes), + XByteField("flags", None), + FieldLenField("len", None, length_of="params", adjust = lambda pkt,x:x+20), + XIntField("init_tag", None), + IntField("a_rwnd", None), + ShortField("n_out_streams", None), + ShortField("n_in_streams", None), + XIntField("init_tsn", None), + ChunkParamField("params", None, length_from=lambda pkt:pkt.len-20), + ] + +class GapAckField(Field): + def __init__(self, name, default): + Field.__init__(self, name, default, "4s") + def i2m(self, pkt, x): + if x is None: + return "\0\0\0\0" + sta, end = map(int, x.split(":")) + args = tuple([">HH", sta, end]) + return struct.pack(*args) + def m2i(self, pkt, x): + return "%d:%d"%(struct.unpack(">HH", x)) + def any2i(self, pkt, x): + if type(x) is tuple and len(x) == 2: + return "%d:%d"%(x) + return x + +class SCTPChunkSACK(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 3, sctpchunktypes), + XByteField("flags", None), + ShortField("len", None), + XIntField("cumul_tsn_ack", None), + IntField("a_rwnd", None), + FieldLenField("n_gap_ack", None, count_of="gap_ack_list"), + FieldLenField("n_dup_tsn", None, count_of="dup_tsn_list"), + FieldListField("gap_ack_list", [ ], GapAckField("gap_ack", None), count_from=lambda pkt:pkt.n_gap_ack), + FieldListField("dup_tsn_list", [ ], XIntField("dup_tsn", None), count_from=lambda pkt:pkt.n_dup_tsn), + ] + + def post_build(self, p, pay): + if self.len is None: + p = p[:2] + struct.pack(">H", len(p)) + p[4:] + return p+pay + + +class SCTPChunkHeartbeatReq(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 4, sctpchunktypes), + XByteField("flags", None), + FieldLenField("len", None, length_of="params", adjust = lambda pkt,x:x+4), + ChunkParamField("params", None, length_from=lambda pkt:pkt.len-4), + ] + +class SCTPChunkHeartbeatAck(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 5, sctpchunktypes), + XByteField("flags", None), + FieldLenField("len", None, length_of="params", adjust = lambda pkt,x:x+4), + ChunkParamField("params", None, length_from=lambda pkt:pkt.len-4), + ] + +class SCTPChunkAbort(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 6, sctpchunktypes), + BitField("reserved", None, 7), + BitField("TCB", 0, 1), + FieldLenField("len", None, length_of="error_causes", adjust = lambda pkt,x:x+4), + PadField(StrLenField("error_causes", b"", length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"), + ] + +class SCTPChunkShutdown(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 7, sctpchunktypes), + XByteField("flags", None), + ShortField("len", 8), + XIntField("cumul_tsn_ack", None), + ] + +class SCTPChunkShutdownAck(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 8, sctpchunktypes), + XByteField("flags", None), + ShortField("len", 4), + ] + +class SCTPChunkError(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 9, sctpchunktypes), + XByteField("flags", None), + FieldLenField("len", None, length_of="error_causes", adjust = lambda pkt,x:x+4), + PadField(StrLenField("error_causes", b"", length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"), + ] + +class SCTPChunkCookieEcho(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 10, sctpchunktypes), + XByteField("flags", None), + FieldLenField("len", None, length_of="cookie", adjust = lambda pkt,x:x+4), + PadField(StrLenField("cookie", b"", length_from=lambda pkt: pkt.len-4), + 4, padwith=b"\x00"), + ] + +class SCTPChunkCookieAck(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 11, sctpchunktypes), + XByteField("flags", None), + ShortField("len", 4), + ] + +class SCTPChunkShutdownComplete(_SCTPChunkGuessPayload, Packet): + fields_desc = [ ByteEnumField("type", 12, sctpchunktypes), + BitField("reserved", None, 7), + BitField("TCB", 0, 1), + ShortField("len", 4), + ] + +bind_layers( IP, SCTP, proto=IPPROTO_SCTP) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/sebek.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/sebek.py new file mode 100644 index 00000000..c54e6728 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/sebek.py @@ -0,0 +1,109 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Sebek: Linux kernel module for data collection on honeypots. +""" + +from scapy.fields import * +from scapy.packet import * +from scapy.layers.inet import UDP + + +### SEBEK + + +class SebekHead(Packet): + name = "Sebek header" + fields_desc = [ XIntField("magic", 0xd0d0d0), + ShortField("version", 1), + ShortEnumField("type", 0, {"read":0, "write":1, + "socket":2, "open":3}), + IntField("counter", 0), + IntField("time_sec", 0), + IntField("time_usec", 0) ] + def mysummary(self): + return self.sprintf("Sebek Header v%SebekHead.version% %SebekHead.type%") + +# we need this because Sebek headers differ between v1 and v3, and +# between v3 type socket and v3 others + +class SebekV1(Packet): + name = "Sebek v1" + fields_desc = [ IntField("pid", 0), + IntField("uid", 0), + IntField("fd", 0), + StrFixedLenField("command", "", 12), + FieldLenField("data_length", None, "data",fmt="I"), + StrLenField("data", "", length_from=lambda x:x.data_length) ] + def mysummary(self): + if isinstance(self.underlayer, SebekHead): + return self.underlayer.sprintf("Sebek v1 %SebekHead.type% (%SebekV1.command%)") + else: + return self.sprintf("Sebek v1 (%SebekV1.command%)") + +class SebekV3(Packet): + name = "Sebek v3" + fields_desc = [ IntField("parent_pid", 0), + IntField("pid", 0), + IntField("uid", 0), + IntField("fd", 0), + IntField("inode", 0), + StrFixedLenField("command", "", 12), + FieldLenField("data_length", None, "data",fmt="I"), + StrLenField("data", "", length_from=lambda x:x.data_length) ] + def mysummary(self): + if isinstance(self.underlayer, SebekHead): + return self.underlayer.sprintf("Sebek v%SebekHead.version% %SebekHead.type% (%SebekV3.command%)") + else: + return self.sprintf("Sebek v3 (%SebekV3.command%)") + +class SebekV2(SebekV3): + def mysummary(self): + if isinstance(self.underlayer, SebekHead): + return self.underlayer.sprintf("Sebek v%SebekHead.version% %SebekHead.type% (%SebekV2.command%)") + else: + return self.sprintf("Sebek v2 (%SebekV2.command%)") + +class SebekV3Sock(Packet): + name = "Sebek v2 socket" + fields_desc = [ IntField("parent_pid", 0), + IntField("pid", 0), + IntField("uid", 0), + IntField("fd", 0), + IntField("inode", 0), + StrFixedLenField("command", "", 12), + IntField("data_length", 15), + IPField("dip", "127.0.0.1"), + ShortField("dport", 0), + IPField("sip", "127.0.0.1"), + ShortField("sport", 0), + ShortEnumField("call", 0, { "bind":2, + "connect":3, "listen":4, + "accept":5, "sendmsg":16, + "recvmsg":17, "sendto":11, + "recvfrom":12}), + ByteEnumField("proto", 0, IP_PROTOS) ] + def mysummary(self): + if isinstance(self.underlayer, SebekHead): + return self.underlayer.sprintf("Sebek v%SebekHead.version% %SebekHead.type% (%SebekV3Sock.command%)") + else: + return self.sprintf("Sebek v3 socket (%SebekV3Sock.command%)") + +class SebekV2Sock(SebekV3Sock): + def mysummary(self): + if isinstance(self.underlayer, SebekHead): + return self.underlayer.sprintf("Sebek v%SebekHead.version% %SebekHead.type% (%SebekV2Sock.command%)") + else: + return self.sprintf("Sebek v2 socket (%SebekV2Sock.command%)") + +bind_layers( UDP, SebekHead, sport=1101) +bind_layers( UDP, SebekHead, dport=1101) +bind_layers( UDP, SebekHead, dport=1101, sport=1101) +bind_layers( SebekHead, SebekV1, version=1) +bind_layers( SebekHead, SebekV2Sock, version=2, type=2) +bind_layers( SebekHead, SebekV2, version=2) +bind_layers( SebekHead, SebekV3Sock, version=3, type=2) +bind_layers( SebekHead, SebekV3, version=3) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/skinny.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/skinny.py new file mode 100644 index 00000000..9fb6ac06 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/skinny.py @@ -0,0 +1,161 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Cisco Skinny protocol. +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import TCP + +# shamelessly ripped from Ethereal dissector +skinny_messages = { +# Station -> Callmanager + 0x0000: "KeepAliveMessage", + 0x0001: "RegisterMessage", + 0x0002: "IpPortMessage", + 0x0003: "KeypadButtonMessage", + 0x0004: "EnblocCallMessage", + 0x0005: "StimulusMessage", + 0x0006: "OffHookMessage", + 0x0007: "OnHookMessage", + 0x0008: "HookFlashMessage", + 0x0009: "ForwardStatReqMessage", + 0x000A: "SpeedDialStatReqMessage", + 0x000B: "LineStatReqMessage", + 0x000C: "ConfigStatReqMessage", + 0x000D: "TimeDateReqMessage", + 0x000E: "ButtonTemplateReqMessage", + 0x000F: "VersionReqMessage", + 0x0010: "CapabilitiesResMessage", + 0x0011: "MediaPortListMessage", + 0x0012: "ServerReqMessage", + 0x0020: "AlarmMessage", + 0x0021: "MulticastMediaReceptionAck", + 0x0022: "OpenReceiveChannelAck", + 0x0023: "ConnectionStatisticsRes", + 0x0024: "OffHookWithCgpnMessage", + 0x0025: "SoftKeySetReqMessage", + 0x0026: "SoftKeyEventMessage", + 0x0027: "UnregisterMessage", + 0x0028: "SoftKeyTemplateReqMessage", + 0x0029: "RegisterTokenReq", + 0x002A: "MediaTransmissionFailure", + 0x002B: "HeadsetStatusMessage", + 0x002C: "MediaResourceNotification", + 0x002D: "RegisterAvailableLinesMessage", + 0x002E: "DeviceToUserDataMessage", + 0x002F: "DeviceToUserDataResponseMessage", + 0x0030: "UpdateCapabilitiesMessage", + 0x0031: "OpenMultiMediaReceiveChannelAckMessage", + 0x0032: "ClearConferenceMessage", + 0x0033: "ServiceURLStatReqMessage", + 0x0034: "FeatureStatReqMessage", + 0x0035: "CreateConferenceResMessage", + 0x0036: "DeleteConferenceResMessage", + 0x0037: "ModifyConferenceResMessage", + 0x0038: "AddParticipantResMessage", + 0x0039: "AuditConferenceResMessage", + 0x0040: "AuditParticipantResMessage", + 0x0041: "DeviceToUserDataVersion1Message", +# Callmanager -> Station */ + 0x0081: "RegisterAckMessage", + 0x0082: "StartToneMessage", + 0x0083: "StopToneMessage", + 0x0085: "SetRingerMessage", + 0x0086: "SetLampMessage", + 0x0087: "SetHkFDetectMessage", + 0x0088: "SetSpeakerModeMessage", + 0x0089: "SetMicroModeMessage", + 0x008A: "StartMediaTransmission", + 0x008B: "StopMediaTransmission", + 0x008C: "StartMediaReception", + 0x008D: "StopMediaReception", + 0x008F: "CallInfoMessage", + 0x0090: "ForwardStatMessage", + 0x0091: "SpeedDialStatMessage", + 0x0092: "LineStatMessage", + 0x0093: "ConfigStatMessage", + 0x0094: "DefineTimeDate", + 0x0095: "StartSessionTransmission", + 0x0096: "StopSessionTransmission", + 0x0097: "ButtonTemplateMessage", + 0x0098: "VersionMessage", + 0x0099: "DisplayTextMessage", + 0x009A: "ClearDisplay", + 0x009B: "CapabilitiesReqMessage", + 0x009C: "EnunciatorCommandMessage", + 0x009D: "RegisterRejectMessage", + 0x009E: "ServerResMessage", + 0x009F: "Reset", + 0x0100: "KeepAliveAckMessage", + 0x0101: "StartMulticastMediaReception", + 0x0102: "StartMulticastMediaTransmission", + 0x0103: "StopMulticastMediaReception", + 0x0104: "StopMulticastMediaTransmission", + 0x0105: "OpenReceiveChannel", + 0x0106: "CloseReceiveChannel", + 0x0107: "ConnectionStatisticsReq", + 0x0108: "SoftKeyTemplateResMessage", + 0x0109: "SoftKeySetResMessage", + 0x0110: "SelectSoftKeysMessage", + 0x0111: "CallStateMessage", + 0x0112: "DisplayPromptStatusMessage", + 0x0113: "ClearPromptStatusMessage", + 0x0114: "DisplayNotifyMessage", + 0x0115: "ClearNotifyMessage", + 0x0116: "ActivateCallPlaneMessage", + 0x0117: "DeactivateCallPlaneMessage", + 0x0118: "UnregisterAckMessage", + 0x0119: "BackSpaceReqMessage", + 0x011A: "RegisterTokenAck", + 0x011B: "RegisterTokenReject", + 0x0042: "DeviceToUserDataResponseVersion1Message", + 0x011C: "StartMediaFailureDetection", + 0x011D: "DialedNumberMessage", + 0x011E: "UserToDeviceDataMessage", + 0x011F: "FeatureStatMessage", + 0x0120: "DisplayPriNotifyMessage", + 0x0121: "ClearPriNotifyMessage", + 0x0122: "StartAnnouncementMessage", + 0x0123: "StopAnnouncementMessage", + 0x0124: "AnnouncementFinishMessage", + 0x0127: "NotifyDtmfToneMessage", + 0x0128: "SendDtmfToneMessage", + 0x0129: "SubscribeDtmfPayloadReqMessage", + 0x012A: "SubscribeDtmfPayloadResMessage", + 0x012B: "SubscribeDtmfPayloadErrMessage", + 0x012C: "UnSubscribeDtmfPayloadReqMessage", + 0x012D: "UnSubscribeDtmfPayloadResMessage", + 0x012E: "UnSubscribeDtmfPayloadErrMessage", + 0x012F: "ServiceURLStatMessage", + 0x0130: "CallSelectStatMessage", + 0x0131: "OpenMultiMediaChannelMessage", + 0x0132: "StartMultiMediaTransmission", + 0x0133: "StopMultiMediaTransmission", + 0x0134: "MiscellaneousCommandMessage", + 0x0135: "FlowControlCommandMessage", + 0x0136: "CloseMultiMediaReceiveChannel", + 0x0137: "CreateConferenceReqMessage", + 0x0138: "DeleteConferenceReqMessage", + 0x0139: "ModifyConferenceReqMessage", + 0x013A: "AddParticipantReqMessage", + 0x013B: "DropParticipantReqMessage", + 0x013C: "AuditConferenceReqMessage", + 0x013D: "AuditParticipantReqMessage", + 0x013F: "UserToDeviceDataVersion1Message", + } + + + +class Skinny(Packet): + name="Skinny" + fields_desc = [ LEIntField("len",0), + LEIntField("res",0), + LEIntEnumField("msg",0,skinny_messages) ] + +bind_layers( TCP, Skinny, dport=2000) +bind_layers( TCP, Skinny, sport=2000) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/smb.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/smb.py new file mode 100644 index 00000000..f8e0da7a --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/smb.py @@ -0,0 +1,354 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +SMB (Server Message Block), also known as CIFS. +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.netbios import NBTSession + + +# SMB NetLogon Response Header +class SMBNetlogon_Protocol_Response_Header(Packet): + name="SMBNetlogon Protocol Response Header" + fields_desc = [StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x25,{0x25:"Trans"}), + ByteField("Error_Class",0x02), + ByteField("Reserved",0), + LEShortField("Error_code",4), + ByteField("Flags",0), + LEShortField("Flags2",0x0000), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",0), + LEShortField("UID",0), + LEShortField("MID",0), + ByteField("WordCount",17), + LEShortField("TotalParamCount",0), + LEShortField("TotalDataCount",112), + LEShortField("MaxParamCount",0), + LEShortField("MaxDataCount",0), + ByteField("MaxSetupCount",0), + ByteField("unused2",0), + LEShortField("Flags3",0), + ByteField("TimeOut1",0xe8), + ByteField("TimeOut2",0x03), + LEShortField("unused3",0), + LEShortField("unused4",0), + LEShortField("ParamCount2",0), + LEShortField("ParamOffset",0), + LEShortField("DataCount",112), + LEShortField("DataOffset",92), + ByteField("SetupCount", 3), + ByteField("unused5", 0)] + +# SMB MailSlot Protocol +class SMBMailSlot(Packet): + name = "SMB Mail Slot Protocol" + fields_desc = [LEShortField("opcode", 1), + LEShortField("priority", 1), + LEShortField("class", 2), + LEShortField("size", 135), + StrNullField("name","\\MAILSLOT\\NET\\GETDC660")] + +# SMB NetLogon Protocol Response Tail SAM +class SMBNetlogon_Protocol_Response_Tail_SAM(Packet): + name = "SMB Netlogon Protocol Response Tail SAM" + fields_desc = [ByteEnumField("Command", 0x17, {0x12:"SAM logon request", 0x17:"SAM Active directory Response"}), + ByteField("unused", 0), + ShortField("Data1", 0), + ShortField("Data2", 0xfd01), + ShortField("Data3", 0), + ShortField("Data4", 0xacde), + ShortField("Data5", 0x0fe5), + ShortField("Data6", 0xd10a), + ShortField("Data7", 0x374c), + ShortField("Data8", 0x83e2), + ShortField("Data9", 0x7dd9), + ShortField("Data10", 0x3a16), + ShortField("Data11", 0x73ff), + ByteField("Data12", 0x04), + StrFixedLenField("Data13", "rmff", 4), + ByteField("Data14", 0x0), + ShortField("Data16", 0xc018), + ByteField("Data18", 0x0a), + StrFixedLenField("Data20", "rmff-win2k", 10), + ByteField("Data21", 0xc0), + ShortField("Data22", 0x18c0), + ShortField("Data23", 0x180a), + StrFixedLenField("Data24", "RMFF-WIN2K", 10), + ShortField("Data25", 0), + ByteField("Data26", 0x17), + StrFixedLenField("Data27", "Default-First-Site-Name", 23), + ShortField("Data28", 0x00c0), + ShortField("Data29", 0x3c10), + ShortField("Data30", 0x00c0), + ShortField("Data31", 0x0200), + ShortField("Data32", 0x0), + ShortField("Data33", 0xac14), + ShortField("Data34", 0x0064), + ShortField("Data35", 0x0), + ShortField("Data36", 0x0), + ShortField("Data37", 0x0), + ShortField("Data38", 0x0), + ShortField("Data39", 0x0d00), + ShortField("Data40", 0x0), + ShortField("Data41", 0xffff)] + +# SMB NetLogon Protocol Response Tail LM2.0 +class SMBNetlogon_Protocol_Response_Tail_LM20(Packet): + name = "SMB Netlogon Protocol Response Tail LM20" + fields_desc = [ByteEnumField("Command",0x06,{0x06:"LM 2.0 Response to logon request"}), + ByteField("unused", 0), + StrFixedLenField("DblSlash", "\\\\", 2), + StrNullField("ServerName","WIN"), + LEShortField("LM20Token", 0xffff)] + +# SMBNegociate Protocol Request Header +class SMBNegociate_Protocol_Request_Header(Packet): + name="SMBNegociate Protocol Request Header" + fields_desc = [StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x72,{0x72:"SMB_COM_NEGOTIATE"}), + ByteField("Error_Class",0), + ByteField("Reserved",0), + LEShortField("Error_code",0), + ByteField("Flags",0x18), + LEShortField("Flags2",0x0000), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",1), + LEShortField("UID",0), + LEShortField("MID",2), + ByteField("WordCount",0), + LEShortField("ByteCount",12)] + +# SMB Negociate Protocol Request Tail +class SMBNegociate_Protocol_Request_Tail(Packet): + name="SMB Negociate Protocol Request Tail" + fields_desc=[ByteField("BufferFormat",0x02), + StrNullField("BufferData","NT LM 0.12")] + +# SMBNegociate Protocol Response Advanced Security +class SMBNegociate_Protocol_Response_Advanced_Security(Packet): + name="SMBNegociate Protocol Response Advanced Security" + fields_desc = [StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x72,{0x72:"SMB_COM_NEGOTIATE"}), + ByteField("Error_Class",0), + ByteField("Reserved",0), + LEShortField("Error_Code",0), + ByteField("Flags",0x98), + LEShortField("Flags2",0x0000), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",1), + LEShortField("UID",0), + LEShortField("MID",2), + ByteField("WordCount",17), + LEShortField("DialectIndex",7), + ByteField("SecurityMode",0x03), + LEShortField("MaxMpxCount",50), + LEShortField("MaxNumberVC",1), + LEIntField("MaxBufferSize",16144), + LEIntField("MaxRawSize",65536), + LEIntField("SessionKey",0x0000), + LEShortField("ServerCapabilities",0xf3f9), + BitField("UnixExtensions",0,1), + BitField("Reserved2",0,7), + BitField("ExtendedSecurity",1,1), + BitField("CompBulk",0,2), + BitField("Reserved3",0,5), +# There have been 127490112000000000 tenths of micro-seconds between 1st january 1601 and 1st january 2005. 127490112000000000=0x1C4EF94D6228000, so ServerTimeHigh=0xD6228000 and ServerTimeLow=0x1C4EF94. + LEIntField("ServerTimeHigh",0xD6228000), + LEIntField("ServerTimeLow",0x1C4EF94), + LEShortField("ServerTimeZone",0x3c), + ByteField("EncryptionKeyLength",0), + LEFieldLenField("ByteCount", None, "SecurityBlob", adjust=lambda pkt,x:x-16), + BitField("GUID",0,128), + StrLenField("SecurityBlob", "", length_from=lambda x:x.ByteCount+16)] + +# SMBNegociate Protocol Response No Security +# When using no security, with EncryptionKeyLength=8, you must have an EncryptionKey before the DomainName +class SMBNegociate_Protocol_Response_No_Security(Packet): + name="SMBNegociate Protocol Response No Security" + fields_desc = [StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x72,{0x72:"SMB_COM_NEGOTIATE"}), + ByteField("Error_Class",0), + ByteField("Reserved",0), + LEShortField("Error_Code",0), + ByteField("Flags",0x98), + LEShortField("Flags2",0x0000), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",1), + LEShortField("UID",0), + LEShortField("MID",2), + ByteField("WordCount",17), + LEShortField("DialectIndex",7), + ByteField("SecurityMode",0x03), + LEShortField("MaxMpxCount",50), + LEShortField("MaxNumberVC",1), + LEIntField("MaxBufferSize",16144), + LEIntField("MaxRawSize",65536), + LEIntField("SessionKey",0x0000), + LEShortField("ServerCapabilities",0xf3f9), + BitField("UnixExtensions",0,1), + BitField("Reserved2",0,7), + BitField("ExtendedSecurity",0,1), + FlagsField("CompBulk",0,2,"CB"), + BitField("Reserved3",0,5), + # There have been 127490112000000000 tenths of micro-seconds between 1st january 1601 and 1st january 2005. 127490112000000000=0x1C4EF94D6228000, so ServerTimeHigh=0xD6228000 and ServerTimeLow=0x1C4EF94. + LEIntField("ServerTimeHigh",0xD6228000), + LEIntField("ServerTimeLow",0x1C4EF94), + LEShortField("ServerTimeZone",0x3c), + ByteField("EncryptionKeyLength",8), + LEShortField("ByteCount",24), + BitField("EncryptionKey",0,64), + StrNullField("DomainName","WORKGROUP"), + StrNullField("ServerName","RMFF1")] + +# SMBNegociate Protocol Response No Security No Key +class SMBNegociate_Protocol_Response_No_Security_No_Key(Packet): + namez="SMBNegociate Protocol Response No Security No Key" + fields_desc = [StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x72,{0x72:"SMB_COM_NEGOTIATE"}), + ByteField("Error_Class",0), + ByteField("Reserved",0), + LEShortField("Error_Code",0), + ByteField("Flags",0x98), + LEShortField("Flags2",0x0000), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",1), + LEShortField("UID",0), + LEShortField("MID",2), + ByteField("WordCount",17), + LEShortField("DialectIndex",7), + ByteField("SecurityMode",0x03), + LEShortField("MaxMpxCount",50), + LEShortField("MaxNumberVC",1), + LEIntField("MaxBufferSize",16144), + LEIntField("MaxRawSize",65536), + LEIntField("SessionKey",0x0000), + LEShortField("ServerCapabilities",0xf3f9), + BitField("UnixExtensions",0,1), + BitField("Reserved2",0,7), + BitField("ExtendedSecurity",0,1), + FlagsField("CompBulk",0,2,"CB"), + BitField("Reserved3",0,5), + # There have been 127490112000000000 tenths of micro-seconds between 1st january 1601 and 1st january 2005. 127490112000000000=0x1C4EF94D6228000, so ServerTimeHigh=0xD6228000 and ServerTimeLow=0x1C4EF94. + LEIntField("ServerTimeHigh",0xD6228000), + LEIntField("ServerTimeLow",0x1C4EF94), + LEShortField("ServerTimeZone",0x3c), + ByteField("EncryptionKeyLength",0), + LEShortField("ByteCount",16), + StrNullField("DomainName","WORKGROUP"), + StrNullField("ServerName","RMFF1")] + +# Session Setup AndX Request +class SMBSession_Setup_AndX_Request(Packet): + name="Session Setup AndX Request" + fields_desc=[StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x73,{0x73:"SMB_COM_SESSION_SETUP_ANDX"}), + ByteField("Error_Class",0), + ByteField("Reserved",0), + LEShortField("Error_Code",0), + ByteField("Flags",0x18), + LEShortField("Flags2",0x0001), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",1), + LEShortField("UID",0), + LEShortField("MID",2), + ByteField("WordCount",13), + ByteEnumField("AndXCommand",0x75,{0x75:"SMB_COM_TREE_CONNECT_ANDX"}), + ByteField("Reserved2",0), + LEShortField("AndXOffset",96), + LEShortField("MaxBufferS",2920), + LEShortField("MaxMPXCount",50), + LEShortField("VCNumber",0), + LEIntField("SessionKey",0), + LEFieldLenField("ANSIPasswordLength",None,"ANSIPassword"), + LEShortField("UnicodePasswordLength",0), + LEIntField("Reserved3",0), + LEShortField("ServerCapabilities",0x05), + BitField("UnixExtensions",0,1), + BitField("Reserved4",0,7), + BitField("ExtendedSecurity",0,1), + BitField("CompBulk",0,2), + BitField("Reserved5",0,5), + LEShortField("ByteCount",35), + StrLenField("ANSIPassword", "Pass",length_from=lambda x:x.ANSIPasswordLength), + StrNullField("Account","GUEST"), + StrNullField("PrimaryDomain", ""), + StrNullField("NativeOS","Windows 4.0"), + StrNullField("NativeLanManager","Windows 4.0"), + ByteField("WordCount2",4), + ByteEnumField("AndXCommand2",0xFF,{0xFF:"SMB_COM_NONE"}), + ByteField("Reserved6",0), + LEShortField("AndXOffset2",0), + LEShortField("Flags3",0x2), + LEShortField("PasswordLength",0x1), + LEShortField("ByteCount2",18), + ByteField("Password",0), + StrNullField("Path","\\\\WIN2K\\IPC$"), + StrNullField("Service","IPC")] + +# Session Setup AndX Response +class SMBSession_Setup_AndX_Response(Packet): + name="Session Setup AndX Response" + fields_desc=[StrFixedLenField("Start","\xffSMB",4), + ByteEnumField("Command",0x73,{0x73:"SMB_COM_SESSION_SETUP_ANDX"}), + ByteField("Error_Class",0), + ByteField("Reserved",0), + LEShortField("Error_Code",0), + ByteField("Flags",0x90), + LEShortField("Flags2",0x1001), + LEShortField("PIDHigh",0x0000), + LELongField("Signature",0x0), + LEShortField("Unused",0x0), + LEShortField("TID",0), + LEShortField("PID",1), + LEShortField("UID",0), + LEShortField("MID",2), + ByteField("WordCount",3), + ByteEnumField("AndXCommand",0x75,{0x75:"SMB_COM_TREE_CONNECT_ANDX"}), + ByteField("Reserved2",0), + LEShortField("AndXOffset",66), + LEShortField("Action",0), + LEShortField("ByteCount",25), + StrNullField("NativeOS","Windows 4.0"), + StrNullField("NativeLanManager","Windows 4.0"), + StrNullField("PrimaryDomain",""), + ByteField("WordCount2",3), + ByteEnumField("AndXCommand2",0xFF,{0xFF:"SMB_COM_NONE"}), + ByteField("Reserved3",0), + LEShortField("AndXOffset2",80), + LEShortField("OptionalSupport",0x01), + LEShortField("ByteCount2",5), + StrNullField("Service","IPC"), + StrNullField("NativeFileSystem","")] + +bind_layers( NBTSession, SMBNegociate_Protocol_Request_Header, ) +bind_layers( NBTSession, SMBNegociate_Protocol_Response_Advanced_Security, ExtendedSecurity=1) +bind_layers( NBTSession, SMBNegociate_Protocol_Response_No_Security, ExtendedSecurity=0, EncryptionKeyLength=8) +bind_layers( NBTSession, SMBNegociate_Protocol_Response_No_Security_No_Key, ExtendedSecurity=0, EncryptionKeyLength=0) +bind_layers( NBTSession, SMBSession_Setup_AndX_Request, ) +bind_layers( NBTSession, SMBSession_Setup_AndX_Response, ) +bind_layers( SMBNegociate_Protocol_Request_Header, SMBNegociate_Protocol_Request_Tail, ) +bind_layers( SMBNegociate_Protocol_Request_Tail, SMBNegociate_Protocol_Request_Tail, ) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/snmp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/snmp.py new file mode 100644 index 00000000..dddd4e27 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/snmp.py @@ -0,0 +1,255 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +SNMP (Simple Network Management Protocol). +""" + +from scapy.asn1packet import * +from scapy.asn1fields import * +from scapy.layers.inet import UDP + +########## +## SNMP ## +########## + +######[ ASN1 class ]###### + +class ASN1_Class_SNMP(ASN1_Class_UNIVERSAL): + name="SNMP" + PDU_GET = 0xa0 + PDU_NEXT = 0xa1 + PDU_RESPONSE = 0xa2 + PDU_SET = 0xa3 + PDU_TRAPv1 = 0xa4 + PDU_BULK = 0xa5 + PDU_INFORM = 0xa6 + PDU_TRAPv2 = 0xa7 + + +class ASN1_SNMP_PDU_GET(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_GET + +class ASN1_SNMP_PDU_NEXT(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_NEXT + +class ASN1_SNMP_PDU_RESPONSE(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_RESPONSE + +class ASN1_SNMP_PDU_SET(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_SET + +class ASN1_SNMP_PDU_TRAPv1(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_TRAPv1 + +class ASN1_SNMP_PDU_BULK(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_BULK + +class ASN1_SNMP_PDU_INFORM(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_INFORM + +class ASN1_SNMP_PDU_TRAPv2(ASN1_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_TRAPv2 + + +######[ BER codecs ]####### + +class BERcodec_SNMP_PDU_GET(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_GET + +class BERcodec_SNMP_PDU_NEXT(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_NEXT + +class BERcodec_SNMP_PDU_RESPONSE(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_RESPONSE + +class BERcodec_SNMP_PDU_SET(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_SET + +class BERcodec_SNMP_PDU_TRAPv1(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_TRAPv1 + +class BERcodec_SNMP_PDU_BULK(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_BULK + +class BERcodec_SNMP_PDU_INFORM(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_INFORM + +class BERcodec_SNMP_PDU_TRAPv2(BERcodec_SEQUENCE): + tag = ASN1_Class_SNMP.PDU_TRAPv2 + + + +######[ ASN1 fields ]###### + +class ASN1F_SNMP_PDU_GET(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_GET + +class ASN1F_SNMP_PDU_NEXT(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_NEXT + +class ASN1F_SNMP_PDU_RESPONSE(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_RESPONSE + +class ASN1F_SNMP_PDU_SET(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_SET + +class ASN1F_SNMP_PDU_TRAPv1(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_TRAPv1 + +class ASN1F_SNMP_PDU_BULK(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_BULK + +class ASN1F_SNMP_PDU_INFORM(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_INFORM + +class ASN1F_SNMP_PDU_TRAPv2(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_SNMP.PDU_TRAPv2 + + + +######[ SNMP Packet ]###### + +SNMP_error = { 0: "no_error", + 1: "too_big", + 2: "no_such_name", + 3: "bad_value", + 4: "read_only", + 5: "generic_error", + 6: "no_access", + 7: "wrong_type", + 8: "wrong_length", + 9: "wrong_encoding", + 10: "wrong_value", + 11: "no_creation", + 12: "inconsistent_value", + 13: "ressource_unavailable", + 14: "commit_failed", + 15: "undo_failed", + 16: "authorization_error", + 17: "not_writable", + 18: "inconsistent_name", + } + +SNMP_trap_types = { 0: "cold_start", + 1: "warm_start", + 2: "link_down", + 3: "link_up", + 4: "auth_failure", + 5: "egp_neigh_loss", + 6: "enterprise_specific", + } + +class SNMPvarbind(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SEQUENCE( ASN1F_OID("oid","1.3"), + ASN1F_field("value",ASN1_NULL(0)) + ) + + +class SNMPget(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_GET( ASN1F_INTEGER("id",0), + ASN1F_enum_INTEGER("error",0, SNMP_error), + ASN1F_INTEGER("error_index",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPnext(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_NEXT( ASN1F_INTEGER("id",0), + ASN1F_enum_INTEGER("error",0, SNMP_error), + ASN1F_INTEGER("error_index",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPresponse(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_RESPONSE( ASN1F_INTEGER("id",0), + ASN1F_enum_INTEGER("error",0, SNMP_error), + ASN1F_INTEGER("error_index",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPset(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_SET( ASN1F_INTEGER("id",0), + ASN1F_enum_INTEGER("error",0, SNMP_error), + ASN1F_INTEGER("error_index",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPtrapv1(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_TRAPv1( ASN1F_OID("enterprise", "1.3"), + ASN1F_IPADDRESS("agent_addr","0.0.0.0"), + ASN1F_enum_INTEGER("generic_trap", 0, SNMP_trap_types), + ASN1F_INTEGER("specific_trap", 0), + ASN1F_TIME_TICKS("time_stamp", IntAutoTime()), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPbulk(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_BULK( ASN1F_INTEGER("id",0), + ASN1F_INTEGER("non_repeaters",0), + ASN1F_INTEGER("max_repetitions",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPinform(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_INFORM( ASN1F_INTEGER("id",0), + ASN1F_enum_INTEGER("error",0, SNMP_error), + ASN1F_INTEGER("error_index",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + +class SNMPtrapv2(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SNMP_PDU_TRAPv2( ASN1F_INTEGER("id",0), + ASN1F_enum_INTEGER("error",0, SNMP_error), + ASN1F_INTEGER("error_index",0), + ASN1F_SEQUENCE_OF("varbindlist", [], SNMPvarbind) + ) + + +class SNMP(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SEQUENCE( + ASN1F_enum_INTEGER("version", 1, {0:"v1", 1:"v2c", 2:"v2", 3:"v3"}), + ASN1F_STRING("community",b"public"), + ASN1F_CHOICE("PDU", SNMPget(), + SNMPget, SNMPnext, SNMPresponse, SNMPset, + SNMPtrapv1, SNMPbulk, SNMPinform, SNMPtrapv2) + ) + def answers(self, other): + return ( isinstance(self.PDU, SNMPresponse) and + ( isinstance(other.PDU, SNMPget) or + isinstance(other.PDU, SNMPnext) or + isinstance(other.PDU, SNMPset) ) and + self.PDU.id == other.PDU.id ) + +bind_layers( UDP, SNMP, sport=161) +bind_layers( UDP, SNMP, dport=161) +bind_layers( UDP, SNMP, sport=162) +bind_layers( UDP, SNMP, dport=162) + +def snmpwalk(dst, oid="1", community=b"public"): + try: + while 1: + r = sr1(IP(dst=dst)/UDP(sport=RandShort())/SNMP(community=community, PDU=SNMPnext(varbindlist=[SNMPvarbind(oid=oid)])),timeout=2, chainCC=1, verbose=0, retry=2) + if ICMP in r: + print(repr(r)) + break + if r is None: + print("No answers") + break + print("%-40s: %r" % (r[SNMPvarbind].oid.val,r[SNMPvarbind].value)) + oid = r[SNMPvarbind].oid + + except KeyboardInterrupt: + pass + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/tftp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/tftp.py new file mode 100644 index 00000000..1535e99c --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/tftp.py @@ -0,0 +1,477 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +TFTP (Trivial File Transfer Protocol). +""" + +import os,random +from scapy.packet import * +from scapy.fields import * +from scapy.automaton import * +from scapy.layers.inet import UDP + + + +TFTP_operations = { 1:"RRQ",2:"WRQ",3:"DATA",4:"ACK",5:"ERROR",6:"OACK" } + + +class TFTP(Packet): + name = "TFTP opcode" + fields_desc = [ ShortEnumField("op", 1, TFTP_operations), ] + + + +class TFTP_RRQ(Packet): + name = "TFTP Read Request" + fields_desc = [ StrNullField("filename", ""), + StrNullField("mode", "octet") ] + def answers(self, other): + return 0 + def mysummary(self): + return self.sprintf("RRQ %filename%"),[UDP] + + +class TFTP_WRQ(Packet): + name = "TFTP Write Request" + fields_desc = [ StrNullField("filename", ""), + StrNullField("mode", "octet") ] + def answers(self, other): + return 0 + def mysummary(self): + return self.sprintf("WRQ %filename%"),[UDP] + +class TFTP_DATA(Packet): + name = "TFTP Data" + fields_desc = [ ShortField("block", 0) ] + def answers(self, other): + return self.block == 1 and isinstance(other, TFTP_RRQ) + def mysummary(self): + return self.sprintf("DATA %block%"),[UDP] + +class TFTP_Option(Packet): + fields_desc = [ StrNullField("oname",""), + StrNullField("value","") ] + def extract_padding(self, pkt): + return "",pkt + +class TFTP_Options(Packet): + fields_desc = [ PacketListField("options", [], TFTP_Option, length_from=lambda x:None) ] + + +class TFTP_ACK(Packet): + name = "TFTP Ack" + fields_desc = [ ShortField("block", 0) ] + def answers(self, other): + if isinstance(other, TFTP_DATA): + return self.block == other.block + elif isinstance(other, TFTP_RRQ) or isinstance(other, TFTP_WRQ) or isinstance(other, TFTP_OACK): + return self.block == 0 + return 0 + def mysummary(self): + return self.sprintf("ACK %block%"),[UDP] + +TFTP_Error_Codes = { 0: "Not defined", + 1: "File not found", + 2: "Access violation", + 3: "Disk full or allocation exceeded", + 4: "Illegal TFTP operation", + 5: "Unknown transfer ID", + 6: "File already exists", + 7: "No such user", + 8: "Terminate transfer due to option negotiation", + } + +class TFTP_ERROR(Packet): + name = "TFTP Error" + fields_desc = [ ShortEnumField("errorcode", 0, TFTP_Error_Codes), + StrNullField("errormsg", "")] + def answers(self, other): + return (isinstance(other, TFTP_DATA) or + isinstance(other, TFTP_RRQ) or + isinstance(other, TFTP_WRQ) or + isinstance(other, TFTP_ACK)) + def mysummary(self): + return self.sprintf("ERROR %errorcode%: %errormsg%"),[UDP] + + +class TFTP_OACK(Packet): + name = "TFTP Option Ack" + fields_desc = [ ] + def answers(self, other): + return isinstance(other, TFTP_WRQ) or isinstance(other, TFTP_RRQ) + + +bind_layers(UDP, TFTP, dport=69) +bind_layers(TFTP, TFTP_RRQ, op=1) +bind_layers(TFTP, TFTP_WRQ, op=2) +bind_layers(TFTP, TFTP_DATA, op=3) +bind_layers(TFTP, TFTP_ACK, op=4) +bind_layers(TFTP, TFTP_ERROR, op=5) +bind_layers(TFTP, TFTP_OACK, op=6) +bind_layers(TFTP_RRQ, TFTP_Options) +bind_layers(TFTP_WRQ, TFTP_Options) +bind_layers(TFTP_OACK, TFTP_Options) + + +class TFTP_read(Automaton): + def parse_args(self, filename, server, sport = None, port=69, **kargs): + Automaton.parse_args(self, **kargs) + self.filename = filename + self.server = server + self.port = port + self.sport = sport + + + def master_filter(self, pkt): + return ( IP in pkt and pkt[IP].src == self.server and UDP in pkt + and pkt[UDP].dport == self.my_tid + and (self.server_tid is None or pkt[UDP].sport == self.server_tid) ) + + # BEGIN + @ATMT.state(initial=1) + def BEGIN(self): + self.blocksize=512 + self.my_tid = self.sport or RandShort()._fix() + bind_bottom_up(UDP, TFTP, dport=self.my_tid) + self.server_tid = None + self.res = "" + + self.l3 = IP(dst=self.server)/UDP(sport=self.my_tid, dport=self.port)/TFTP() + self.last_packet = self.l3/TFTP_RRQ(filename=self.filename, mode="octet") + self.send(self.last_packet) + self.awaiting=1 + + raise self.WAITING() + + # WAITING + @ATMT.state() + def WAITING(self): + pass + + + @ATMT.receive_condition(WAITING) + def receive_data(self, pkt): + if TFTP_DATA in pkt and pkt[TFTP_DATA].block == self.awaiting: + if self.server_tid is None: + self.server_tid = pkt[UDP].sport + self.l3[UDP].dport = self.server_tid + raise self.RECEIVING(pkt) + + @ATMT.receive_condition(WAITING, prio=1) + def receive_error(self, pkt): + if TFTP_ERROR in pkt: + raise self.ERROR(pkt) + + + @ATMT.timeout(WAITING, 3) + def timeout_waiting(self): + raise self.WAITING() + @ATMT.action(timeout_waiting) + def retransmit_last_packet(self): + self.send(self.last_packet) + + @ATMT.action(receive_data) +# @ATMT.action(receive_error) + def send_ack(self): + self.last_packet = self.l3 / TFTP_ACK(block = self.awaiting) + self.send(self.last_packet) + + + # RECEIVED + @ATMT.state() + def RECEIVING(self, pkt): + if conf.raw_layer in pkt: + recvd = pkt[conf.raw_layer].load + else: + recvd = "" + self.res += recvd + self.awaiting += 1 + if len(recvd) == self.blocksize: + raise self.WAITING() + raise self.END() + + # ERROR + @ATMT.state(error=1) + def ERROR(self,pkt): + split_bottom_up(UDP, TFTP, dport=self.my_tid) + return pkt[TFTP_ERROR].summary() + + #END + @ATMT.state(final=1) + def END(self): + split_bottom_up(UDP, TFTP, dport=self.my_tid) + return self.res + + + + +class TFTP_write(Automaton): + def parse_args(self, filename, data, server, sport=None, port=69,**kargs): + Automaton.parse_args(self, **kargs) + self.filename = filename + self.server = server + self.port = port + self.sport = sport + self.blocksize = 512 + self.origdata = data + + def master_filter(self, pkt): + return ( IP in pkt and pkt[IP].src == self.server and UDP in pkt + and pkt[UDP].dport == self.my_tid + and (self.server_tid is None or pkt[UDP].sport == self.server_tid) ) + + + # BEGIN + @ATMT.state(initial=1) + def BEGIN(self): + self.data = [ self.origdata[i*self.blocksize:(i+1)*self.blocksize] + for i in range( len(self.origdata)/self.blocksize+1) ] + self.my_tid = self.sport or RandShort()._fix() + bind_bottom_up(UDP, TFTP, dport=self.my_tid) + self.server_tid = None + + self.l3 = IP(dst=self.server)/UDP(sport=self.my_tid, dport=self.port)/TFTP() + self.last_packet = self.l3/TFTP_WRQ(filename=self.filename, mode="octet") + self.send(self.last_packet) + self.res = "" + self.awaiting=0 + + raise self.WAITING_ACK() + + # WAITING_ACK + @ATMT.state() + def WAITING_ACK(self): + pass + + @ATMT.receive_condition(WAITING_ACK) + def received_ack(self,pkt): + if TFTP_ACK in pkt and pkt[TFTP_ACK].block == self.awaiting: + if self.server_tid is None: + self.server_tid = pkt[UDP].sport + self.l3[UDP].dport = self.server_tid + raise self.SEND_DATA() + + @ATMT.receive_condition(WAITING_ACK) + def received_error(self, pkt): + if TFTP_ERROR in pkt: + raise self.ERROR(pkt) + + @ATMT.timeout(WAITING_ACK, 3) + def timeout_waiting(self): + raise self.WAITING_ACK() + @ATMT.action(timeout_waiting) + def retransmit_last_packet(self): + self.send(self.last_packet) + + # SEND_DATA + @ATMT.state() + def SEND_DATA(self): + self.awaiting += 1 + self.last_packet = self.l3/TFTP_DATA(block=self.awaiting)/self.data.pop(0) + self.send(self.last_packet) + if self.data: + raise self.WAITING_ACK() + raise self.END() + + + # ERROR + @ATMT.state(error=1) + def ERROR(self,pkt): + split_bottom_up(UDP, TFTP, dport=self.my_tid) + return pkt[TFTP_ERROR].summary() + + # END + @ATMT.state(final=1) + def END(self): + split_bottom_up(UDP, TFTP, dport=self.my_tid) + + +class TFTP_WRQ_server(Automaton): + + def parse_args(self, ip=None, sport=None, *args, **kargs): + Automaton.parse_args(self, *args, **kargs) + self.ip = ip + self.sport = sport + + def master_filter(self, pkt): + return TFTP in pkt and (not self.ip or pkt[IP].dst == self.ip) + + @ATMT.state(initial=1) + def BEGIN(self): + self.blksize=512 + self.blk=1 + self.filedata="" + self.my_tid = self.sport or random.randint(10000,65500) + bind_bottom_up(UDP, TFTP, dport=self.my_tid) + + @ATMT.receive_condition(BEGIN) + def receive_WRQ(self,pkt): + if TFTP_WRQ in pkt: + raise self.WAIT_DATA().action_parameters(pkt) + + @ATMT.action(receive_WRQ) + def ack_WRQ(self, pkt): + ip = pkt[IP] + self.ip = ip.dst + self.dst = ip.src + self.filename = pkt[TFTP_WRQ].filename + options = pkt[TFTP_Options] + self.l3 = IP(src=ip.dst, dst=ip.src)/UDP(sport=self.my_tid, dport=pkt.sport)/TFTP() + if options is None: + self.last_packet = self.l3/TFTP_ACK(block=0) + self.send(self.last_packet) + else: + opt = [x for x in options.options if x.oname.upper() == "BLKSIZE"] + if opt: + self.blksize = int(opt[0].value) + self.debug(2,"Negotiated new blksize at %i" % self.blksize) + self.last_packet = self.l3/TFTP_OACK()/TFTP_Options(options=opt) + self.send(self.last_packet) + + @ATMT.state() + def WAIT_DATA(self): + pass + + @ATMT.timeout(WAIT_DATA, 1) + def resend_ack(self): + self.send(self.last_packet) + raise self.WAIT_DATA() + + @ATMT.receive_condition(WAIT_DATA) + def receive_data(self, pkt): + if TFTP_DATA in pkt: + data = pkt[TFTP_DATA] + if data.block == self.blk: + raise self.DATA(data) + + @ATMT.action(receive_data) + def ack_data(self): + self.last_packet = self.l3/TFTP_ACK(block = self.blk) + self.send(self.last_packet) + + @ATMT.state() + def DATA(self, data): + self.filedata += data.load + if len(data.load) < self.blksize: + raise self.END() + self.blk += 1 + raise self.WAIT_DATA() + + @ATMT.state(final=1) + def END(self): + return self.filename,self.filedata + split_bottom_up(UDP, TFTP, dport=self.my_tid) + + +class TFTP_RRQ_server(Automaton): + def parse_args(self, store=None, joker=None, dir=None, ip=None, sport=None, serve_one=False, **kargs): + Automaton.parse_args(self,**kargs) + if store is None: + store = {} + if dir is not None: + self.dir = os.path.join(os.path.abspath(dir),"") + else: + self.dir = None + self.store = store + self.joker = joker + self.ip = ip + self.sport = sport + self.serve_one = serve_one + self.my_tid = self.sport or random.randint(10000,65500) + bind_bottom_up(UDP, TFTP, dport=self.my_tid) + + def master_filter(self, pkt): + return TFTP in pkt and (not self.ip or pkt[IP].dst == self.ip) + + @ATMT.state(initial=1) + def WAIT_RRQ(self): + self.blksize=512 + self.blk=0 + + @ATMT.receive_condition(WAIT_RRQ) + def receive_rrq(self, pkt): + if TFTP_RRQ in pkt: + raise self.RECEIVED_RRQ(pkt) + + + @ATMT.state() + def RECEIVED_RRQ(self, pkt): + ip = pkt[IP] + options = pkt[TFTP_Options] + self.l3 = IP(src=ip.dst, dst=ip.src)/UDP(sport=self.my_tid, dport=ip.sport)/TFTP() + self.filename = pkt[TFTP_RRQ].filename + self.blk=1 + self.data = None + if self.filename in self.store: + self.data = self.store[self.filename] + elif self.dir is not None: + fn = os.path.abspath(os.path.join(self.dir, self.filename)) + if fn.startswith(self.dir): # Check we're still in the server's directory + try: + self.data=open(fn).read() + except IOError: + pass + if self.data is None: + self.data = self.joker + + if options: + opt = [x for x in options.options if x.oname.upper() == "BLKSIZE"] + if opt: + self.blksize = int(opt[0].value) + self.debug(2,"Negotiated new blksize at %i" % self.blksize) + self.last_packet = self.l3/TFTP_OACK()/TFTP_Options(options=opt) + self.send(self.last_packet) + + + + + @ATMT.condition(RECEIVED_RRQ) + def file_in_store(self): + if self.data is not None: + self.blknb = len(self.data)/self.blksize+1 + raise self.SEND_FILE() + + @ATMT.condition(RECEIVED_RRQ) + def file_not_found(self): + if self.data is None: + raise self.WAIT_RRQ() + @ATMT.action(file_not_found) + def send_error(self): + self.send(self.l3/TFTP_ERROR(errorcode=1, errormsg=TFTP_Error_Codes[1])) + + @ATMT.state() + def SEND_FILE(self): + self.send(self.l3/TFTP_DATA(block=self.blk)/self.data[(self.blk-1)*self.blksize:self.blk*self.blksize]) + + @ATMT.timeout(SEND_FILE, 3) + def timeout_waiting_ack(self): + raise self.SEND_FILE() + + @ATMT.receive_condition(SEND_FILE) + def received_ack(self, pkt): + if TFTP_ACK in pkt and pkt[TFTP_ACK].block == self.blk: + raise self.RECEIVED_ACK() + @ATMT.state() + def RECEIVED_ACK(self): + self.blk += 1 + + @ATMT.condition(RECEIVED_ACK) + def no_more_data(self): + if self.blk > self.blknb: + if self.serve_one: + raise self.END() + raise self.WAIT_RRQ() + @ATMT.condition(RECEIVED_ACK, prio=2) + def data_remaining(self): + raise self.SEND_FILE() + + @ATMT.state(final=1) + def END(self): + split_bottom_up(UDP, TFTP, dport=self.my_tid) + + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/vrrp.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/vrrp.py new file mode 100644 index 00000000..e2818381 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/vrrp.py @@ -0,0 +1,39 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## Copyright (C) 6WIND <olivier.matz@6wind.com> +## This program is published under a GPLv2 license + +""" +VRRP (Virtual Router Redundancy Protocol). +""" + +from scapy.packet import * +from scapy.fields import * +from scapy.layers.inet import IP + +IPPROTO_VRRP=112 + +# RFC 3768 - Virtual Router Redundancy Protocol (VRRP) +class VRRP(Packet): + fields_desc = [ + BitField("version" , 2, 4), + BitField("type" , 1, 4), + ByteField("vrid", 1), + ByteField("priority", 100), + FieldLenField("ipcount", None, count_of="addrlist", fmt="B"), + ByteField("authtype", 0), + ByteField("adv", 1), + XShortField("chksum", None), + FieldListField("addrlist", [], IPField("", "0.0.0.0"), + count_from = lambda pkt: pkt.ipcount), + IntField("auth1", 0), + IntField("auth2", 0) ] + + def post_build(self, p, pay): + if self.chksum is None: + ck = checksum(p) + p = p[:6]+bytes([(ck>>8),(ck&0xff)])+p[8:] + return p + +bind_layers( IP, VRRP, proto=IPPROTO_VRRP) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/layers/x509.py b/scripts/external_libs/scapy-python3-0.18/scapy/layers/x509.py new file mode 100644 index 00000000..18aaa5e3 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/layers/x509.py @@ -0,0 +1,108 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +X.509 certificates. +""" + +from scapy.asn1packet import * +from scapy.asn1fields import * + +########## +## X509 ## +########## + +######[ ASN1 class ]###### + +class ASN1_Class_X509(ASN1_Class_UNIVERSAL): + name="X509" + CONT0 = 0xa0 + CONT1 = 0xa1 + CONT2 = 0xa2 + CONT3 = 0xa3 + +class ASN1_X509_CONT0(ASN1_SEQUENCE): + tag = ASN1_Class_X509.CONT0 + +class ASN1_X509_CONT1(ASN1_SEQUENCE): + tag = ASN1_Class_X509.CONT1 + +class ASN1_X509_CONT2(ASN1_SEQUENCE): + tag = ASN1_Class_X509.CONT2 + +class ASN1_X509_CONT3(ASN1_SEQUENCE): + tag = ASN1_Class_X509.CONT3 + +######[ BER codecs ]####### + +class BERcodec_X509_CONT0(BERcodec_SEQUENCE): + tag = ASN1_Class_X509.CONT0 + +class BERcodec_X509_CONT1(BERcodec_SEQUENCE): + tag = ASN1_Class_X509.CONT1 + +class BERcodec_X509_CONT2(BERcodec_SEQUENCE): + tag = ASN1_Class_X509.CONT2 + +class BERcodec_X509_CONT3(BERcodec_SEQUENCE): + tag = ASN1_Class_X509.CONT3 + +######[ ASN1 fields ]###### + +class ASN1F_X509_CONT0(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_X509.CONT0 + +class ASN1F_X509_CONT1(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_X509.CONT1 + +class ASN1F_X509_CONT2(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_X509.CONT2 + +class ASN1F_X509_CONT3(ASN1F_SEQUENCE): + ASN1_tag = ASN1_Class_X509.CONT3 + +######[ X509 packets ]###### + +class X509RDN(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SET( + ASN1F_SEQUENCE( ASN1F_OID("oid","2.5.4.6"), + ASN1F_PRINTABLE_STRING("value","") + ) + ) + +class X509v3Ext(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_field("val",ASN1_NULL(0)) + + +class X509Cert(ASN1_Packet): + ASN1_codec = ASN1_Codecs.BER + ASN1_root = ASN1F_SEQUENCE( + ASN1F_SEQUENCE( + ASN1F_optionnal(ASN1F_X509_CONT0(ASN1F_INTEGER("version",3))), + ASN1F_INTEGER("sn",1), + ASN1F_SEQUENCE(ASN1F_OID("sign_algo","1.2.840.113549.1.1.5"), + ASN1F_field("sa_value",ASN1_NULL(0))), + ASN1F_SEQUENCE_OF("issuer",[],X509RDN), + ASN1F_SEQUENCE(ASN1F_UTC_TIME("not_before",ZuluTime(-600)), # ten minutes ago + ASN1F_UTC_TIME("not_after",ZuluTime(+86400))), # for 24h + ASN1F_SEQUENCE_OF("subject",[],X509RDN), + ASN1F_SEQUENCE( + ASN1F_SEQUENCE(ASN1F_OID("pubkey_algo","1.2.840.113549.1.1.1"), + ASN1F_field("pk_value",ASN1_NULL(0))), + ASN1F_BIT_STRING("pubkey","") + ), + ASN1F_optionnal(ASN1F_X509_CONT3(ASN1F_SEQUENCE_OF("x509v3ext",[],X509v3Ext))), + + ), + ASN1F_SEQUENCE(ASN1F_OID("sign_algo2","1.2.840.113549.1.1.5"), + ASN1F_field("sa2_value",ASN1_NULL(0))), + ASN1F_BIT_STRING("signature","") + ) + + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/main.py b/scripts/external_libs/scapy-python3-0.18/scapy/main.py new file mode 100644 index 00000000..47805443 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/main.py @@ -0,0 +1,380 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Main module for interactive startup. +""" + +import os,sys,socket +import glob +import builtins +import types +import gzip +from .error import * +from . import utils + + +def _probe_config_file(cf): + cf_path = os.path.join(os.path.expanduser("~"), cf) + try: + os.stat(cf_path) + except OSError: + return None + else: + return cf_path + +def _read_config_file(cf): + log_loading.debug("Loading config file [%s]" % cf) + try: + exec(open(cf).read()) + except IOError as e: + log_loading.warning("Cannot read config file [%s] [%s]" % (cf,e)) + except Exception as e: + log_loading.exception("Error during evaluation of config file [%s]" % cf) + + +DEFAULT_PRESTART_FILE = _probe_config_file(".scapy_prestart.py") +DEFAULT_STARTUP_FILE = _probe_config_file(".scapy_startup.py") + +def _usage(): + print("""Usage: scapy.py [-s sessionfile] [-c new_startup_file] [-p new_prestart_file] [-C] [-P] + -C: do not read startup file + -P: do not read pre-startup file""") + sys.exit(0) + + +from .config import conf +from .themes import DefaultTheme + + +###################### +## Extension system ## +###################### + + +def _load(module): + try: + mod = __import__(module,globals(),locals(),".") + builtins.__dict__.update(mod.__dict__) + except Exception as e: + log_interactive.error(e) + +def load_module(name): + _load("scapy.modules."+name) + +def load_layer(name): + _load("scapy.layers."+name) + +def load_contrib(name): + _load("scapy.contrib."+name) + +def list_contrib(name=None): + if name is None: + name="*.py" + elif "*" not in name and "?" not in name and not name.endswith(".py"): + name += ".py" + name = os.path.join(os.path.dirname(__file__), "contrib", name) + for f in glob.glob(name): + mod = os.path.basename(f) + if mod.startswith("__"): + continue + if mod.endswith(".py"): + mod = mod[:-3] + desc = { "description":"-", "status":"?", "name":mod } + for l in open(f): + p = l.find("scapy.contrib.") + if p >= 0: + p += 14 + q = l.find("=", p) + key = l[p:q].strip() + value = l[q+1:].strip() + desc[key] = value + print("%(name)-20s: %(description)-40s status=%(status)s" % desc) + + + + + + +############################## +## Session saving/restoring ## +############################## + + +def save_session(fname=None, session=None, pickleProto=4): + import dill as pickle + + if fname is None: + fname = conf.session + if not fname: + conf.session = fname = utils.get_temp_file(keep=True) + log_interactive.info("Use [%s] as session file" % fname) + if session is None: + session = builtins.__dict__["scapy_session"] + + to_be_saved = session.copy() + + for k in list(to_be_saved.keys()): + if k in ["__builtins__", "In", "Out", "conf"] or k.startswith("_") or \ + (hasattr(to_be_saved[k], "__module__") and str(to_be_saved[k].__module__).startswith('IPython')): + del(to_be_saved[k]) + continue + if type(to_be_saved[k]) in [type, types.ModuleType, types.MethodType]: + log_interactive.info("[%s] (%s) can't be saved." % (k, type(to_be_saved[k]))) + del(to_be_saved[k]) + + try: + os.rename(fname, fname+".bak") + except OSError: + pass + f=gzip.open(fname,"wb") + for i in to_be_saved.keys(): + #d = {i: to_be_saved[i]} + #pickle.dump(d, f, pickleProto) + pickle.dump(to_be_saved, f, pickleProto) + f.close() + +def load_session(fname=None): + if conf.interactive_shell.lower() == "ipython": + log_interactive.error("There are issues with load_session in ipython. Use python for interactive shell, or use -s parameter to load session") + return + + import dill as pickle + + if fname is None: + fname = conf.session + try: + s = pickle.load(gzip.open(fname,"rb")) + except IOError: + s = pickle.load(open(fname,"rb")) + scapy_session = builtins.__dict__["scapy_session"] + scapy_session.clear() + scapy_session.update(s) + +def update_session(fname=None): + import dill as pickle + if fname is None: + fname = conf.session + try: + s = pickle.load(gzip.open(fname,"rb")) + except IOError: + s = pickle.load(open(fname,"rb")) + scapy_session = builtins.__dict__["scapy_session"] + scapy_session.update(s) + + +################ +##### Main ##### +################ + +def scapy_delete_temp_files(): + for f in conf.temp_files: + try: + os.unlink(f) + except: + pass + +def scapy_write_history_file(readline): + if conf.histfile: + try: + readline.write_history_file(conf.histfile) + except IOError as e: + try: + warning("Could not write history to [%s]\n\t (%s)" % (conf.histfile,e)) + tmp = utils.get_temp_file(keep=True) + readline.write_history_file(tmp) + warning("Wrote history to [%s]" % tmp) + except: + warning("Cound not write history to [%s]. Discarded" % tmp) + + +def interact(mydict=None,argv=None,mybanner=None,loglevel=20): + global session + import code,sys,pickle,os,getopt,re + from .config import conf + conf.interactive = True + if loglevel is not None: + conf.logLevel=loglevel + + the_banner = "Welcome to Scapy (%s)" + if mybanner is not None: + the_banner += "\n" + the_banner += mybanner + + if argv is None: + argv = sys.argv + + import atexit + try: + import rlcompleter,readline + except ImportError: + log_loading.info("Can't load Python libreadline or completer") + READLINE=0 + else: + READLINE=1 + class ScapyCompleter(rlcompleter.Completer): + def global_matches(self, text): + matches = [] + n = len(text) + for lst in [dir(builtins), session.keys()]: + for word in lst: + if word[:n] == text and word != "__builtins__": + matches.append(word) + return matches + + + def attr_matches(self, text): + m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text) + if not m: + return + expr, attr = m.group(1, 3) + try: + object = eval(expr) + except: + object = eval(expr, session) + if isinstance(object, Packet) or isinstance(object, Packet_metaclass): + #words = filter(lambda x: x[0]!="_",dir(object)) + words = [ x for x in dir(object) if x[0]!="_" ] + words += [x.name for x in object.fields_desc] + else: + words = dir(object) + if hasattr( object,"__class__" ): + words = words + rlcompleter.get_class_members(object.__class__) + matches = [] + n = len(attr) + for word in words: + if word[:n] == attr and word != "__builtins__": + matches.append("%s.%s" % (expr, word)) + return matches + + readline.set_completer(ScapyCompleter().complete) + readline.parse_and_bind("C-o: operate-and-get-next") + readline.parse_and_bind("tab: complete") + + + session=None + session_name="" + STARTUP_FILE = DEFAULT_STARTUP_FILE + PRESTART_FILE = DEFAULT_PRESTART_FILE + + + iface = None + try: + opts=getopt.getopt(argv[1:], "hs:Cc:Pp:d") + for opt, parm in opts[0]: + if opt == "-h": + _usage() + elif opt == "-s": + session_name = parm + elif opt == "-c": + STARTUP_FILE = parm + elif opt == "-C": + STARTUP_FILE = None + elif opt == "-p": + PRESTART_FILE = parm + elif opt == "-P": + PRESTART_FILE = None + elif opt == "-d": + conf.logLevel = max(1,conf.logLevel-10) + + if len(opts[1]) > 0: + raise getopt.GetoptError("Too many parameters : [%s]" % " ".join(opts[1])) + + + except getopt.GetoptError as msg: + log_loading.error(msg) + sys.exit(1) + + if PRESTART_FILE: + _read_config_file(PRESTART_FILE) + + scapy_builtins = __import__("scapy.all",globals(),locals(),".").__dict__ + builtins.__dict__.update(scapy_builtins) + globkeys = list(scapy_builtins.keys()) + globkeys.append("scapy_session") + scapy_builtins=None # XXX replace with "with" statement + if mydict is not None: + builtins.__dict__.update(mydict) + globkeys += mydict.keys() + + + conf.color_theme = DefaultTheme() + if STARTUP_FILE: + _read_config_file(STARTUP_FILE) + + if session_name: + try: + os.stat(session_name) + except OSError: + log_loading.info("New session [%s]" % session_name) + else: + try: + try: + session = pickle.load(gzip.open(session_name,"rb")) + except IOError: + session = pickle.load(open(session_name,"rb")) + log_loading.info("Using session [%s]" % session_name) + except EOFError: + log_loading.error("Error opening session [%s]" % session_name) + except AttributeError: + log_loading.error("Error opening session [%s]. Attribute missing" % session_name) + + if session: + if "conf" in session: + conf.configure(session["conf"]) + session["conf"] = conf + else: + conf.session = session_name + session={"conf":conf} + + else: + session={"conf": conf} + + builtins.__dict__["scapy_session"] = session + + + if READLINE: + if conf.histfile: + try: + readline.read_history_file(conf.histfile) + except IOError: + pass + atexit.register(scapy_write_history_file,readline) + + atexit.register(scapy_delete_temp_files) + + IPYTHON=False + if conf.interactive_shell.lower() == "ipython": + try: + import IPython + IPYTHON=True + except ImportError as e: + log_loading.warning("IPython not available. Using standard Python shell instead.") + IPYTHON=False + + if IPYTHON: + banner = the_banner % (conf.version) + " using IPython %s" % IPython.__version__ + + if conf.ipython_embedded: + IPython.embed(user_ns=session, banner2=banner) + else: + IPython.start_ipython(argv=[], user_ns=session) + + else: + code.interact(banner = the_banner % (conf.version), + local=session, readfunc=conf.readfunc) + + if conf.session: + save_session(conf.session, session) + + + for k in globkeys: + try: + del(builtins.__dict__[k]) + except: + pass + +if __name__ == "__main__": + interact() diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/modules/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/modules/__init__.py new file mode 100644 index 00000000..6303dad0 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/modules/__init__.py @@ -0,0 +1,8 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Package of extension modules that have to be loaded explicitly. +""" diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/modules/geoip.py b/scripts/external_libs/scapy-python3-0.18/scapy/modules/geoip.py new file mode 100644 index 00000000..7396fe96 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/modules/geoip.py @@ -0,0 +1,77 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +GeoIP: find out the geographical location of IP addresses +""" + +from scapy.data import KnowledgeBase +from scapy.config import conf + +conf.IPCountry_base = "GeoIPCountry4Scapy.gz" +conf.countryLoc_base = "countryLoc.csv" + +########################## +## IP location database ## +########################## + +class IPCountryKnowledgeBase(KnowledgeBase): + """ +How to generate the base : +db = [] +for l in open("GeoIPCountryWhois.csv").readlines(): + s,e,c = l.split(",")[2:5] + db.append((int(s[1:-1]),int(e[1:-1]),c[1:-1])) +cPickle.dump(gzip.open("xxx","w"),db) +""" + def lazy_init(self): + self.base = load_object(self.filename) + + +class CountryLocKnowledgeBase(KnowledgeBase): + def lazy_init(self): + f=open(self.filename) + self.base = {} + while 1: + l = f.readline() + if not l: + break + l = l.strip().split(",") + if len(l) != 3: + continue + c,lat,long = l + + self.base[c] = (float(long),float(lat)) + f.close() + + + +@conf.commands.register +def locate_ip(ip): + """Get geographic coordinates from IP using geoip database""" + ip=map(int,ip.split(".")) + ip = ip[3]+(ip[2]<<8)+(ip[1]<<16)+(ip[0]<<24) + + cloc = country_loc_kdb.get_base() + db = IP_country_kdb.get_base() + + d=0 + f=len(db)-1 + while (f-d) > 1: + guess = (d+f)/2 + if ip > db[guess][0]: + d = guess + else: + f = guess + s,e,c = db[guess] + if s <= ip and ip <= e: + return cloc.get(c,None) + + + + + +conf.IP_country_kdb = IPCountryKnowledgeBase(conf.IPCountry_base) +conf.country_loc_kdb = CountryLocKnowledgeBase(conf.countryLoc_base) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/modules/nmap.py b/scripts/external_libs/scapy-python3-0.18/scapy/modules/nmap.py new file mode 100644 index 00000000..07ec7a93 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/modules/nmap.py @@ -0,0 +1,215 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Clone of Nmap's first generation OS fingerprinting. +""" + +import os + +from scapy.data import KnowledgeBase +from scapy.config import conf +from scapy.arch import WINDOWS + + +if WINDOWS: + conf.nmap_base=os.environ["ProgramFiles"] + "\\nmap\\nmap-os-fingerprints" +else: + conf.nmap_base ="/usr/share/nmap/nmap-os-fingerprints" + + +###################### +## nmap OS fp stuff ## +###################### + + +class NmapKnowledgeBase(KnowledgeBase): + def lazy_init(self): + try: + f=open(self.filename) + except IOError: + return + + self.base = [] + name = None + try: + for l in f: + l = l.strip() + if not l or l[0] == "#": + continue + if l[:12] == "Fingerprint ": + if name is not None: + self.base.append((name,sig)) + name = l[12:].strip() + sig={} + p = self.base + continue + elif l[:6] == "Class ": + continue + op = l.find("(") + cl = l.find(")") + if op < 0 or cl < 0: + warning("error reading nmap os fp base file") + continue + test = l[:op] + s = map(lambda x: x.split("="), l[op+1:cl].split("%")) + si = {} + for n,v in s: + si[n] = v + sig[test]=si + if name is not None: + self.base.append((name,sig)) + except: + self.base = None + warning("Can't read nmap database [%s](new nmap version ?)" % self.filename) + f.close() + +nmap_kdb = NmapKnowledgeBase(conf.nmap_base) + +def TCPflags2str(f): + fl="FSRPAUEC" + s="" + for i in range(len(fl)): + if f & 1: + s = fl[i]+s + f >>= 1 + return s + +def nmap_tcppacket_sig(pkt): + r = {} + if pkt is not None: +# r["Resp"] = "Y" + r["DF"] = (pkt.flags & 2) and "Y" or "N" + r["W"] = "%X" % pkt.window + r["ACK"] = pkt.ack==2 and "S++" or pkt.ack==1 and "S" or "O" + r["Flags"] = TCPflags2str(pkt.payload.flags) + r["Ops"] = "".join(map(lambda x: x[0][0],pkt.payload.options)) + else: + r["Resp"] = "N" + return r + + +def nmap_udppacket_sig(S,T): + r={} + if T is None: + r["Resp"] = "N" + else: + r["DF"] = (T.flags & 2) and "Y" or "N" + r["TOS"] = "%X" % T.tos + r["IPLEN"] = "%X" % T.len + r["RIPTL"] = "%X" % T.payload.payload.len + r["RID"] = S.id == T.payload.payload.id and "E" or "F" + r["RIPCK"] = S.chksum == T.getlayer(IPerror).chksum and "E" or T.getlayer(IPerror).chksum == 0 and "0" or "F" + r["UCK"] = S.payload.chksum == T.getlayer(UDPerror).chksum and "E" or T.getlayer(UDPerror).chksum ==0 and "0" or "F" + r["ULEN"] = "%X" % T.getlayer(UDPerror).len + r["DAT"] = T.getlayer(conf.raw_layer) is None and "E" or S.getlayer(conf.raw_layer).load == T.getlayer(conf.raw_layer).load and "E" or "F" + return r + + + +def nmap_match_one_sig(seen, ref): + c = 0 + for k in seen.keys(): + if k in ref: + if seen[k] in ref[k].split("|"): + c += 1 + if c == 0 and seen.get("Resp") == "N": + return 0.7 + else: + return 1.0*c/len(seen.keys()) + + +def nmap_sig(target, oport=80, cport=81, ucport=1): + res = {} + + tcpopt = [ ("WScale", 10), + ("NOP",None), + ("MSS", 256), + ("Timestamp",(123,0)) ] + tests = [ IP(dst=target, id=1)/TCP(seq=1, sport=5001, dport=oport, options=tcpopt, flags="CS"), + IP(dst=target, id=1)/TCP(seq=1, sport=5002, dport=oport, options=tcpopt, flags=0), + IP(dst=target, id=1)/TCP(seq=1, sport=5003, dport=oport, options=tcpopt, flags="SFUP"), + IP(dst=target, id=1)/TCP(seq=1, sport=5004, dport=oport, options=tcpopt, flags="A"), + IP(dst=target, id=1)/TCP(seq=1, sport=5005, dport=cport, options=tcpopt, flags="S"), + IP(dst=target, id=1)/TCP(seq=1, sport=5006, dport=cport, options=tcpopt, flags="A"), + IP(dst=target, id=1)/TCP(seq=1, sport=5007, dport=cport, options=tcpopt, flags="FPU"), + IP(str(IP(dst=target)/UDP(sport=5008,dport=ucport)/(300*"i"))) ] + + ans, unans = sr(tests, timeout=2) + ans += map(lambda x: (x,None), unans) + + for S,T in ans: + if S.sport == 5008: + res["PU"] = nmap_udppacket_sig(S,T) + else: + t = "T%i" % (S.sport-5000) + if T is not None and T.haslayer(ICMP): + warning("Test %s answered by an ICMP" % t) + T=None + res[t] = nmap_tcppacket_sig(T) + + return res + +def nmap_probes2sig(tests): + tests=tests.copy() + res = {} + if "PU" in tests: + res["PU"] = nmap_udppacket_sig(*tests["PU"]) + del(tests["PU"]) + for k in tests: + res[k] = nmap_tcppacket_sig(tests[k]) + return res + + +def nmap_search(sigs): + guess = 0,[] + for os,fp in nmap_kdb.get_base(): + c = 0.0 + for t in sigs.keys(): + if t in fp: + c += nmap_match_one_sig(sigs[t], fp[t]) + c /= len(sigs.keys()) + if c > guess[0]: + guess = c,[ os ] + elif c == guess[0]: + guess[1].append(os) + return guess + + +@conf.commands.register +def nmap_fp(target, oport=80, cport=81): + """nmap fingerprinting +nmap_fp(target, [oport=80,] [cport=81,]) -> list of best guesses with accuracy +""" + sigs = nmap_sig(target, oport, cport) + return nmap_search(sigs) + + +@conf.commands.register +def nmap_sig2txt(sig): + torder = ["TSeq","T1","T2","T3","T4","T5","T6","T7","PU"] + korder = ["Class", "gcd", "SI", "IPID", "TS", + "Resp", "DF", "W", "ACK", "Flags", "Ops", + "TOS", "IPLEN", "RIPTL", "RID", "RIPCK", "UCK", "ULEN", "DAT" ] + txt=[] + for i in sig.keys(): + if i not in torder: + torder.append(i) + for t in torder: + sl = sig.get(t) + if sl is None: + continue + s = [] + for k in korder: + v = sl.get(k) + if v is None: + continue + s.append("%s=%s"%(k,v)) + txt.append("%s(%s)" % (t, "%".join(s))) + return "\n".join(txt) + + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/modules/p0f.py b/scripts/external_libs/scapy-python3-0.18/scapy/modules/p0f.py new file mode 100644 index 00000000..289ef531 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/modules/p0f.py @@ -0,0 +1,549 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Clone of p0f passive OS fingerprinting +""" + +from scapy.data import KnowledgeBase +from scapy.config import conf +from scapy.error import warning +from scapy.layers.inet import IP, TCP, TCPOptions +from scapy.packet import NoPayload + +conf.p0f_base ="/etc/p0f/p0f.fp" +conf.p0fa_base ="/etc/p0f/p0fa.fp" +conf.p0fr_base ="/etc/p0f/p0fr.fp" +#conf.p0fo_base ="/etc/p0f/p0fo.fp" + + +############### +## p0f stuff ## +############### + +# File format (according to p0f.fp) : +# +# wwww:ttt:D:ss:OOO...:QQ:OS:Details +# +# wwww - window size +# ttt - initial TTL +# D - don't fragment bit (0=unset, 1=set) +# ss - overall SYN packet size +# OOO - option value and order specification +# QQ - quirks list +# OS - OS genre +# details - OS description + +class p0fKnowledgeBase(KnowledgeBase): + def __init__(self, filename): + KnowledgeBase.__init__(self, filename) + #self.ttl_range=[255] + def lazy_init(self): + try: + f=open(self.filename) + except IOError: + warning("Can't open base %s" % self.filename) + return + try: + self.base = [] + for l in f: + if l[0] in ["#","\n"]: + continue + l = tuple(l.split(":")) + if len(l) < 8: + continue + def a2i(x): + if x.isdigit(): + return int(x) + return x + li = [ a2i(i) for i in l[1:4] ] + #if li[0] not in self.ttl_range: + # self.ttl_range.append(li[0]) + # self.ttl_range.sort() + self.base.append((l[0], li[0], li[1], li[2], l[4], l[5], l[6], l[7][:-1])) + except: + warning("Can't parse p0f database (new p0f version ?)") + self.base = None + f.close() + +p0f_kdb = p0fKnowledgeBase(conf.p0f_base) +p0fa_kdb = p0fKnowledgeBase(conf.p0fa_base) +p0fr_kdb = p0fKnowledgeBase(conf.p0fr_base) +#p0fo_kdb = p0fKnowledgeBase(conf.p0fo_base) + +def p0f_selectdb(flags): + # tested flags: S, R, A + if flags & 0x16 == 0x2: + # SYN + return p0f_kdb + elif flags & 0x16 == 0x12: + # SYN/ACK + return p0fa_kdb + elif flags & 0x16 in [ 0x4, 0x14 ]: + # RST RST/ACK + return p0fr_kdb +# elif flags & 0x16 == 0x10: + # ACK +# return p0fo_kdb + else: + return None + +def packet2p0f(pkt): + pkt = pkt.copy() + pkt = pkt.__class__(bytes(pkt)) + while pkt.haslayer(IP) and pkt.haslayer(TCP): + pkt = pkt.getlayer(IP) + if isinstance(pkt.payload, TCP): + break + pkt = pkt.payload + + if not isinstance(pkt, IP) or not isinstance(pkt.payload, TCP): + raise TypeError("Not a TCP/IP packet") + #if pkt.payload.flags & 0x7 != 0x02: #S,!F,!R + # raise TypeError("Not a SYN or SYN/ACK packet") + + db = p0f_selectdb(pkt.payload.flags) + + #t = p0f_kdb.ttl_range[:] + #t += [pkt.ttl] + #t.sort() + #ttl=t[t.index(pkt.ttl)+1] + ttl = pkt.ttl + + df = (pkt.flags & 2) / 2 + ss = len(pkt) + # from p0f/config.h : PACKET_BIG = 100 + if ss > 100: + if db == p0fr_kdb: + # p0fr.fp: "Packet size may be wildcarded. The meaning of + # wildcard is, however, hardcoded as 'size > + # PACKET_BIG'" + ss = '*' + else: + ss = 0 +# if db == p0fo_kdb: + # p0fo.fp: "Packet size MUST be wildcarded." +# ss = '*' + + ooo = "" + mss = -1 + qqT = False + qqP = False + #qqBroken = False + ilen = (pkt.payload.dataofs << 2) - 20 # from p0f.c + for option in pkt.payload.options: + ilen -= 1 + if option[0] == "MSS": + ooo += "M" + str(option[1]) + "," + mss = option[1] + # FIXME: qqBroken + ilen -= 3 + elif option[0] == "WScale": + ooo += "W" + str(option[1]) + "," + # FIXME: qqBroken + ilen -= 2 + elif option[0] == "Timestamp": + if option[1][0] == 0: + ooo += "T0," + else: + ooo += "T," + if option[1][1] != 0: + qqT = True + ilen -= 9 + elif option[0] == "SAckOK": + ooo += "S," + ilen -= 1 + elif option[0] == "NOP": + ooo += "N," + elif option[0] == "EOL": + ooo += "E," + if ilen > 0: + qqP = True + else: + if type(option[0]) is str: + ooo += "?%i," % TCPOptions[1][option[0]] + else: + ooo += "?%i," % option[0] + # FIXME: ilen + ooo = ooo[:-1] + if ooo == "": ooo = "." + + win = pkt.payload.window + if mss != -1: + if mss != 0 and win % mss == 0: + win = "S" + str(win/mss) + elif win % (mss + 40) == 0: + win = "T" + str(win/(mss+40)) + win = str(win) + + qq = "" + + if db == p0fr_kdb: + if pkt.payload.flags & 0x10 == 0x10: + # p0fr.fp: "A new quirk, 'K', is introduced to denote + # RST+ACK packets" + qq += "K" + # The two next cases should also be only for p0f*r*, but although + # it's not documented (or I have not noticed), p0f seems to + # support the '0' and 'Q' quirks on any databases (or at the least + # "classical" p0f.fp). + if pkt.payload.seq == pkt.payload.ack: + # p0fr.fp: "A new quirk, 'Q', is used to denote SEQ number + # equal to ACK number." + qq += "Q" + if pkt.payload.seq == 0: + # p0fr.fp: "A new quirk, '0', is used to denote packets + # with SEQ number set to 0." + qq += "0" + if qqP: + qq += "P" + if pkt.id == 0: + qq += "Z" + if pkt.options != []: + qq += "I" + if pkt.payload.urgptr != 0: + qq += "U" + if pkt.payload.reserved != 0: + qq += "X" + if pkt.payload.ack != 0: + qq += "A" + if qqT: + qq += "T" +# if db == p0fo_kdb: +# if pkt.payload.flags & 0x20 != 0: + # U + # p0fo.fp: "PUSH flag is excluded from 'F' quirk checks" +# qq += "F" +# else: +# if pkt.payload.flags & 0x28 != 0: + # U or P + qq += "F" + #if db != p0fo_kdb and not isinstance(pkt.payload.payload, NoPayload): + if not isinstance(pkt.payload.payload, NoPayload): + # p0fo.fp: "'D' quirk is not checked for." + qq += "D" + # FIXME : "!" - broken options segment: not handled yet + + if qq == "": + qq = "." + + return (db, (win, ttl, df, ss, ooo, qq)) + +def p0f_correl(x,y): + d = 0 + # wwww can be "*" or "%nn". "Tnn" and "Snn" should work fine with + # the x[0] == y[0] test. + d += (x[0] == y[0] or y[0] == "*" or (y[0][0] == "%" and x[0].isdigit() and (int(x[0]) % int(y[0][1:])) == 0)) + # ttl + d += (y[1] >= x[1] and y[1] - x[1] < 32) + for i in [2, 5]: + d += (x[i] == y[i] or y[i] == '*') + # '*' has a special meaning for ss + d += x[3] == y[3] + xopt = x[4].split(",") + yopt = y[4].split(",") + if len(xopt) == len(yopt): + same = True + for i in range(len(xopt)): + if not (xopt[i] == yopt[i] or + (len(yopt[i]) == 2 and len(xopt[i]) > 1 and + yopt[i][1] == "*" and xopt[i][0] == yopt[i][0]) or + (len(yopt[i]) > 2 and len(xopt[i]) > 1 and + yopt[i][1] == "%" and xopt[i][0] == yopt[i][0] and + int(xopt[i][1:]) % int(yopt[i][2:]) == 0)): + same = False + break + if same: + d += len(xopt) + return d + + +@conf.commands.register +def p0f(pkt): + """Passive OS fingerprinting: which OS emitted this TCP packet ? +p0f(packet) -> accuracy, [list of guesses] +""" + db, sig = packet2p0f(pkt) + if db: + pb = db.get_base() + else: + pb = [] + if not pb: + warning("p0f base empty.") + return [] + #s = len(pb[0][0]) + r = [] + max = len(sig[4].split(",")) + 5 + for b in pb: + d = p0f_correl(sig,b) + if d == max: + r.append((b[6], b[7], b[1] - pkt[IP].ttl)) + return r + +def prnp0f(pkt): + # we should print which DB we use + try: + r = p0f(pkt) + except: + return + if r == []: + r = ("UNKNOWN", "[" + ":".join([ str(i) for i in packet2p0f(pkt)[1]]) + ":?:?]", None) + else: + r = r[0] + uptime = None + try: + uptime = pkt2uptime(pkt) + except: + pass + if uptime == 0: + uptime = None + res = pkt.sprintf("%IP.src%:%TCP.sport% - " + r[0] + " " + r[1]) + if uptime is not None: + res += pkt.sprintf(" (up: " + str(uptime//3600) + " hrs)\n -> %IP.dst%:%TCP.dport% (%TCP.flags%)") + else: + res += pkt.sprintf("\n -> %IP.dst%:%TCP.dport% (%TCP.flags%)") + if r[2] is not None: + res += " (distance " + str(r[2]) + ")" + print(res) + +@conf.commands.register +def pkt2uptime(pkt, HZ=100): + """Calculate the date the machine which emitted the packet booted using TCP timestamp +pkt2uptime(pkt, [HZ=100])""" + if not isinstance(pkt, Packet): + raise TypeError("Not a TCP packet") + if isinstance(pkt,NoPayload): + raise TypeError("Not a TCP packet") + if not isinstance(pkt, TCP): + return pkt2uptime(pkt.payload) + for opt in pkt.options: + if opt[0] == "Timestamp": + #t = pkt.time - opt[1][0] * 1.0/HZ + #return time.ctime(t) + t = opt[1][0] / HZ + return t + raise TypeError("No timestamp option") + +def p0f_impersonate(pkt, osgenre=None, osdetails=None, signature=None, + extrahops=0, mtu=1500, uptime=None): + """Modifies pkt so that p0f will think it has been sent by a +specific OS. If osdetails is None, then we randomly pick up a +personality matching osgenre. If osgenre and signature are also None, +we use a local signature (using p0f_getlocalsigs). If signature is +specified (as a tuple), we use the signature. + +For now, only TCP Syn packets are supported. +Some specifications of the p0f.fp file are not (yet) implemented.""" + pkt = pkt.copy() + #pkt = pkt.__class__(str(pkt)) + while pkt.haslayer(IP) and pkt.haslayer(TCP): + pkt = pkt.getlayer(IP) + if isinstance(pkt.payload, TCP): + break + pkt = pkt.payload + + if not isinstance(pkt, IP) or not isinstance(pkt.payload, TCP): + raise TypeError("Not a TCP/IP packet") + + if uptime is None: + uptime = random.randint(120,100*60*60*24*365) + + db = p0f_selectdb(pkt.payload.flags) + if osgenre: + pb = db.get_base() + if pb is None: + pb = [] + #pb = filter(lambda x: x[6] == osgenre, pb) + pb = [ x for x in pb if x[6] == osgenre ] + if osdetails: + #pb = filter(lambda x: x[7] == osdetails, pb) + pb = [ x for x in pb if x[7] == osdetails ] + elif signature: + pb = [signature] + else: + pb = p0f_getlocalsigs()[db] + if db == p0fr_kdb: + # 'K' quirk <=> RST+ACK + if pkt.payload.flags & 0x4 == 0x4: + #pb = filter(lambda x: 'K' in x[5], pb) + pb = [ x for x in pb if 'K' in x[5] ] + else: + #pb = filter(lambda x: 'K' not in x[5], pb) + pb = [ x for x in pb if 'K' not in x[5] ] + if not pb: + raise Scapy_Exception("No match in the p0f database") + pers = pb[random.randint(0, len(pb) - 1)] + + # options (we start with options because of MSS) + ## TODO: let the options already set if they are valid + options = [] + if pers[4] != '.': + for opt in pers[4].split(','): + if opt[0] == 'M': + # MSS might have a maximum size because of window size + # specification + if pers[0][0] == 'S': + maxmss = (2**16-1) / int(pers[0][1:]) + else: + maxmss = (2**16-1) + # If we have to randomly pick up a value, we cannot use + # scapy RandXXX() functions, because the value has to be + # set in case we need it for the window size value. That's + # why we use random.randint() + if opt[1:] == '*': + options.append(('MSS', random.randint(1,maxmss))) + elif opt[1] == '%': + coef = int(opt[2:]) + options.append(('MSS', coef*random.randint(1,maxmss/coef))) + else: + options.append(('MSS', int(opt[1:]))) + elif opt[0] == 'W': + if opt[1:] == '*': + options.append(('WScale', RandByte())) + elif opt[1] == '%': + coef = int(opt[2:]) + options.append(('WScale', coef*RandNum(min=1, + max=(2**8-1)/coef))) + else: + options.append(('WScale', int(opt[1:]))) + elif opt == 'T0': + options.append(('Timestamp', (0, 0))) + elif opt == 'T': + if 'T' in pers[5]: + # FIXME: RandInt() here does not work (bug (?) in + # TCPOptionsField.m2i often raises "OverflowError: + # long int too large to convert to int" in: + # oval = struct.pack(ofmt, *oval)" + # Actually, this is enough to often raise the error: + # struct.pack('I', RandInt()) + options.append(('Timestamp', (uptime, random.randint(1,2**32-1)))) + else: + options.append(('Timestamp', (uptime, 0))) + elif opt == 'S': + options.append(('SAckOK', '')) + elif opt == 'N': + options.append(('NOP', None)) + elif opt == 'E': + options.append(('EOL', None)) + elif opt[0] == '?': + if int(opt[1:]) in TCPOptions[0]: + optname = TCPOptions[0][int(opt[1:])][0] + optstruct = TCPOptions[0][int(opt[1:])][1] + options.append((optname, + struct.unpack(optstruct, + RandString(struct.calcsize(optstruct))._fix()))) + else: + options.append((int(opt[1:]), '')) + ## FIXME: qqP not handled + else: + warning("unhandled TCP option " + opt) + pkt.payload.options = options + + # window size + if pers[0] == '*': + pkt.payload.window = RandShort() + elif pers[0].isdigit(): + pkt.payload.window = int(pers[0]) + elif pers[0][0] == '%': + coef = int(pers[0][1:]) + pkt.payload.window = coef * RandNum(min=1,max=(2**16-1)/coef) + elif pers[0][0] == 'T': + pkt.payload.window = mtu * int(pers[0][1:]) + elif pers[0][0] == 'S': + ## needs MSS set + #MSS = filter(lambda x: x[0] == 'MSS', options) + MSS = [ x for x in options if x[0] == 'MSS' ] + if not MSS: + raise Scapy_Exception("TCP window value requires MSS, and MSS option not set") + pkt.payload.window = MSS[0][1] * int(pers[0][1:]) + else: + raise Scapy_Exception('Unhandled window size specification') + + # ttl + pkt.ttl = pers[1]-extrahops + # DF flag + pkt.flags |= (2 * pers[2]) + ## FIXME: ss (packet size) not handled (how ? may be with D quirk + ## if present) + # Quirks + if pers[5] != '.': + for qq in pers[5]: + ## FIXME: not handled: P, I, X, ! + # T handled with the Timestamp option + if qq == 'Z': pkt.id = 0 + elif qq == 'U': pkt.payload.urgptr = RandShort() + elif qq == 'A': pkt.payload.ack = RandInt() + elif qq == 'F': + #if db == p0fo_kdb: + # pkt.payload.flags |= 0x20 # U + #else: + pkt.payload.flags |= RandChoice(8, 32, 40) #P / U / PU + elif qq == 'D' and db != p0fo_kdb: + pkt /= conf.raw_layer(load=RandString(random.randint(1, 10))) # XXX p0fo.fp + elif qq == 'Q': pkt.payload.seq = pkt.payload.ack + #elif qq == '0': pkt.payload.seq = 0 + #if db == p0fr_kdb: + # '0' quirk is actually not only for p0fr.fp (see + # packet2p0f()) + if '0' in pers[5]: + pkt.payload.seq = 0 + elif pkt.payload.seq == 0: + pkt.payload.seq = RandInt() + + while pkt.underlayer: + pkt = pkt.underlayer + return pkt + +def p0f_getlocalsigs(): + """This function returns a dictionary of signatures indexed by p0f +db (e.g., p0f_kdb, p0fa_kdb, ...) for the local TCP/IP stack. + +You need to have your firewall at least accepting the TCP packets +from/to a high port (30000 <= x <= 40000) on your loopback interface. + +Please note that the generated signatures come from the loopback +interface and may (are likely to) be different than those generated on +"normal" interfaces.""" + pid = os.fork() + port = random.randint(30000, 40000) + if pid > 0: + # parent: sniff + result = {} + def addresult(res): + # TODO: wildcard window size in some cases? and maybe some + # other values? + if res[0] not in result: + result[res[0]] = [res[1]] + else: + if res[1] not in result[res[0]]: + result[res[0]].append(res[1]) + # XXX could we try with a "normal" interface using other hosts + iface = conf.route.route('127.0.0.1')[0] + # each packet is seen twice: S + RA, S + SA + A + FA + A + # XXX are the packets also seen twice on non Linux systems ? + count=14 + pl = sniff(iface=iface, filter='tcp and port ' + str(port), count = count, timeout=3) + map(addresult, map(packet2p0f, pl)) + os.waitpid(pid,0) + elif pid < 0: + log_runtime.error("fork error") + else: + # child: send + # XXX erk + time.sleep(1) + s1 = socket.socket(socket.AF_INET, type = socket.SOCK_STREAM) + # S & RA + try: + s1.connect(('127.0.0.1', port)) + except socket.error: + pass + # S, SA, A, FA, A + s1.bind(('127.0.0.1', port)) + s1.connect(('127.0.0.1', port)) + # howto: get an RST w/o ACK packet + s1.close() + os._exit(0) + return result + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/modules/queso.py b/scripts/external_libs/scapy-python3-0.18/scapy/modules/queso.py new file mode 100644 index 00000000..fbc7d06b --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/modules/queso.py @@ -0,0 +1,113 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Clone of queso OS fingerprinting +""" + +from scapy.data import KnowledgeBase +from scapy.config import conf +from scapy.layers.inet import IP,TCP +#from + +conf.queso_base ="/etc/queso.conf" + + +################# +## Queso stuff ## +################# + + +def quesoTCPflags(flags): + if flags == "-": + return "-" + flv = "FSRPAUXY" + v = 0 + for i in flags: + v |= 2**flv.index(i) + return "%x" % v + +class QuesoKnowledgeBase(KnowledgeBase): + def lazy_init(self): + try: + f = open(self.filename) + except IOError: + return + self.base = {} + p = None + try: + for l in f: + l = l.strip() + if not l or l[0] == ';': + continue + if l[0] == '*': + if p is not None: + p[""] = name + name = l[1:].strip() + p = self.base + continue + if l[0] not in list("0123456"): + continue + res = l[2:].split() + res[-1] = quesoTCPflags(res[-1]) + res = " ".join(res) + if not res in p: + p[res] = {} + p = p[res] + if p is not None: + p[""] = name + except: + self.base = None + warning("Can't load queso base [%s]", self.filename) + f.close() + + +queso_kdb = QuesoKnowledgeBase(conf.queso_base) + + +def queso_sig(target, dport=80, timeout=3): + p = queso_kdb.get_base() + ret = [] + for flags in ["S", "SA", "F", "FA", "SF", "P", "SEC"]: + ans, unans = sr(IP(dst=target)/TCP(dport=dport,flags=flags,seq=RandInt()), + timeout=timeout, verbose=0) + if len(ans) == 0: + rs = "- - - -" + else: + s,r = ans[0] + rs = "%i" % (r.seq != 0) + if not r.ack: + r += " 0" + elif r.ack-s.seq > 666: + rs += " R" % 0 + else: + rs += " +%i" % (r.ack-s.seq) + rs += " %X" % r.window + rs += " %x" % r.payload.flags + ret.append(rs) + return ret + +def queso_search(sig): + p = queso_kdb.get_base() + sig.reverse() + ret = [] + try: + while sig: + s = sig.pop() + p = p[s] + if "" in p: + ret.append(p[""]) + except KeyError: + pass + return ret + + +@conf.commands.register +def queso(*args,**kargs): + """Queso OS fingerprinting +queso(target, dport=80, timeout=3)""" + return queso_search(queso_sig(*args, **kargs)) + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/modules/voip.py b/scripts/external_libs/scapy-python3-0.18/scapy/modules/voip.py new file mode 100644 index 00000000..70000a54 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/modules/voip.py @@ -0,0 +1,149 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +VoIP (Voice over IP) related functions +""" + +import os +################### +## Testing stuff ## +################### + +from fcntl import fcntl +from scapy.sendrecv import sniff +from scapy.layers.inet import IP,UDP +from scapy.layers.rtp import RTP +from scapy.utils import get_temp_file + + +def merge(x,y,sample_size=2): + if len(x) > len(y): + y += "\x00"*(len(x)-len(y)) + elif len(x) < len(y): + x += "\x00"*(len(y)-len(x)) + m = "" + ss=sample_size + for i in range(len(x)/ss): + m += x[ss*i:ss*(i+1)]+y[ss*i:ss*(i+1)] + return m +# return "".join(map(str.__add__, x, y)) + + +def voip_play(s1,list=None,**kargs): + FIFO=get_temp_file() + FIFO1=FIFO % 1 + FIFO2=FIFO % 2 + + os.mkfifo(FIFO1) + os.mkfifo(FIFO2) + try: + os.system("soxmix -t .ul %s -t .ul %s -t ossdsp /dev/dsp &" % (FIFO1,FIFO2)) + + c1=open(FIFO1,"w", 4096) + c2=open(FIFO2,"w", 4096) + fcntl.fcntl(c1.fileno(),fcntl.F_SETFL, os.O_NONBLOCK) + fcntl.fcntl(c2.fileno(),fcntl.F_SETFL, os.O_NONBLOCK) + + # dsp,rd = os.popen2("sox -t .ul -c 2 - -t ossdsp /dev/dsp") + def play(pkt,last=[]): + if not pkt: + return + if not pkt.haslayer(UDP): + return + ip=pkt.getlayer(IP) + if s1 in [ip.src, ip.dst]: + if not last: + last.append(pkt) + return + load=last.pop() + # x1 = load.load[12:] + c1.write(load.load[12:]) + if load.getlayer(IP).src == ip.src: + # x2 = "" + c2.write("\x00"*len(load.load[12:])) + last.append(pkt) + else: + # x2 = pkt.load[:12] + c2.write(pkt.load[12:]) + # dsp.write(merge(x1,x2)) + + if list is None: + sniff(store=0, prn=play, **kargs) + else: + for p in list: + play(p) + finally: + os.unlink(FIFO1) + os.unlink(FIFO2) + + + +def voip_play1(s1,list=None,**kargs): + + + dsp,rd = os.popen2("sox -t .ul - -t ossdsp /dev/dsp") + def play(pkt): + if not pkt: + return + if not pkt.haslayer(UDP): + return + ip=pkt.getlayer(IP) + if s1 in [ip.src, ip.dst]: + dsp.write(pkt.getlayer(conf.raw_layer).load[12:]) + try: + if list is None: + sniff(store=0, prn=play, **kargs) + else: + for p in list: + play(p) + finally: + dsp.close() + rd.close() + +def voip_play2(s1,**kargs): + dsp,rd = os.popen2("sox -t .ul -c 2 - -t ossdsp /dev/dsp") + def play(pkt,last=[]): + if not pkt: + return + if not pkt.haslayer(UDP): + return + ip=pkt.getlayer(IP) + if s1 in [ip.src, ip.dst]: + if not last: + last.append(pkt) + return + load=last.pop() + x1 = load.load[12:] +# c1.write(load.load[12:]) + if load.getlayer(IP).src == ip.src: + x2 = "" +# c2.write("\x00"*len(load.load[12:])) + last.append(pkt) + else: + x2 = pkt.load[:12] +# c2.write(pkt.load[12:]) + dsp.write(merge(x1,x2)) + + sniff(store=0, prn=play, **kargs) + +def voip_play3(lst=None,**kargs): + dsp,rd = os.popen2("sox -t .ul - -t ossdsp /dev/dsp") + try: + def play(pkt, dsp=dsp): + if pkt and pkt.haslayer(UDP) and pkt.haslayer(conf.raw_layer): + dsp.write(pkt.getlayer(RTP).load) + if lst is None: + sniff(store=0, prn=play, **kargs) + else: + for p in lst: + play(p) + finally: + try: + dsp.close() + rd.close() + except: + pass + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/packet.py b/scripts/external_libs/scapy-python3-0.18/scapy/packet.py new file mode 100644 index 00000000..c92a27b1 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/packet.py @@ -0,0 +1,1360 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Packet class. Binding mechanism. fuzz() method. +""" + +import time,itertools,os +import sys,traceback +import copy +from .fields import StrField,ConditionalField,Emph,PacketListField +from .config import conf +from .base_classes import BasePacket,Gen,SetGen,Packet_metaclass,NewDefaultValues +from .volatile import VolatileValue +from .utils import import_hexcap,tex_escape,colgen,get_temp_file +from .error import Scapy_Exception,log_runtime, warning +import subprocess +import pprint + +class CGlobal: + ONCE =False + +try: + import pyx +except ImportError: + pass + + +class RawVal: + def __init__(self, val=b""): + assert type(val) == bytes + self.val = val + def __str__(self): + return str(self.val) + def __repr__(self): + return "<RawVal [%r]>" % self.val + def bytes(self): + return self.val + + +class CPacketRes: + pass; + +class Packet(BasePacket, metaclass = Packet_metaclass): + name=None + + fields_desc = [] + + aliastypes = [] + overload_fields = {} + + underlayer = None + + sent_time = None + payload_guess = [] + initialized = 0 + show_indent=1 + explicit = 0 + raw_packet_cache = None + + @classmethod + def from_hexcap(cls): + return cls(import_hexcap()) + + @classmethod + def upper_bonds(self): + for fval,upper in self.payload_guess: + print("%-20s %s" % (upper.__name__, ", ".join("%-12s" % ("%s=%r"%i) for i in fval.items()))) + + @classmethod + def lower_bonds(self): + for lower,fval in self.overload_fields.items(): + print("%-20s %s" % (lower.__name__, ", ".join("%-12s" % ("%s=%r"%i) for i in fval.items()))) + + def __init__(self, _pkt=b"", post_transform=None, _internal=0, _underlayer=None, **fields): + self.time = time.time() + self.sent_time = 0 + if self.name is None: + self.name = self.__class__.__name__ + self.aliastypes = [ self.__class__ ] + self.aliastypes + self.default_fields = {} + self.offset=0; # offset of the object + self.offset_fields = {} # ofsset of each field + self.overloaded_fields = {} + self.fields={} + self.fieldtype={} + self.packetfields=[] + self.__dict__["payload"] = NoPayload() + self.init_fields() + self.underlayer = _underlayer + self.initialized = 1 + self.original = _pkt + if _pkt: + self.dissect(_pkt) + if not _internal: + self.dissection_done(self) + for f in fields.keys(): + self.fields[f] = self.get_field(f).any2i(self,fields[f]) + if type(post_transform) is list: + self.post_transforms = post_transform + elif post_transform is None: + self.post_transforms = [] + else: + self.post_transforms = [post_transform] + + def init_fields(self): + self.do_init_fields(self.fields_desc) + + def do_init_fields(self, flist): + for f in flist: + self.default_fields[f.name] = copy.deepcopy(f.default) + self.fieldtype[f.name] = f + if f.holds_packets: + self.packetfields.append(f) + + def dissection_done(self,pkt): + """DEV: will be called after a dissection is completed""" + self.post_dissection(pkt) + self.payload.dissection_done(pkt) + + def post_dissection(self, pkt): + """DEV: is called after the dissection of the whole packet""" + pass + + def get_field(self, fld): + """DEV: returns the field instance from the name of the field""" + return self.fieldtype[fld] + + def add_payload(self, payload): + if payload is None: + return + elif not isinstance(self.payload, NoPayload): + self.payload.add_payload(payload) + else: + if isinstance(payload, Packet): + self.__dict__["payload"] = payload + payload.add_underlayer(self) + for t in self.aliastypes: + if t in payload.overload_fields: + self.overloaded_fields = payload.overload_fields[t] + break + #elif type(payload) is str: + elif type(payload) is bytes: + self.__dict__["payload"] = conf.raw_layer(load=payload) + else: + raise TypeError("payload must be either 'Packet' or 'bytes', not [%s]" % repr(payload)) + def remove_payload(self): + self.payload.remove_underlayer(self) + self.__dict__["payload"] = NoPayload() + self.overloaded_fields = {} + def add_underlayer(self, underlayer): + self.underlayer = underlayer + def remove_underlayer(self,other): + self.underlayer = None + def copy(self): + """Returns a deep copy of the instance.""" + clone = self.__class__() + clone.fields = self.fields.copy() + for k in clone.fields: + clone.fields[k] = self.get_field(k).do_copy(clone.fields[k]) + clone.default_fields = self.default_fields.copy() + clone.overloaded_fields = self.overloaded_fields.copy() + clone.overload_fields = self.overload_fields.copy() + clone.offset=self.offset + clone.underlayer = self.underlayer + clone.explicit = self.explicit + clone.raw_packet_cache = self.raw_packet_cache + clone.post_transforms = self.post_transforms[:] + clone.__dict__["payload"] = self.payload.copy() + clone.payload.add_underlayer(clone) + return clone + + def dump_offsets (self): + print ("obj-id {0} {1} {2}".format(id(self),self.name ,self.offset)) + if self.payload: + self.payload.dump_offsets() + + def getfieldval(self, attr): + if attr in self.fields: + return self.fields[attr] + if attr in self.overloaded_fields: + return self.overloaded_fields[attr] + if attr in self.default_fields: + return self.default_fields[attr] + return self.payload.getfieldval(attr) + + def getbyteval(self, attr): + fld,v = self.getfield_and_val(attr) + return fld.i2b(self, v) + + def getstrval(self, attr): + fld,v = self.getfield_and_val(attr) + return fld.i2repr(self, v) + + def getfield_and_val(self, attr): + if attr in self.fields: + return self.get_field(attr),self.fields[attr] + if attr in self.overloaded_fields: + return self.get_field(attr),self.overloaded_fields[attr] + if attr in self.default_fields: + return self.get_field(attr),self.default_fields[attr] + return self.payload.getfield_and_val(attr) + + def __getattr__(self, attr): + if self.initialized: + fld,v = self.getfield_and_val(attr) + if fld is not None: + return fld.i2h(self, v) + return v + raise AttributeError(attr) + + def setfieldval(self, attr, val): + if attr in self.default_fields: + fld = self.get_field(attr) + if fld is None: + any2i = lambda x,y: y + else: + any2i = fld.any2i + self.fields[attr] = any2i(self, val) + self.explicit = 0 + self.raw_packet_cache = None + elif attr == "payload": + self.remove_payload() + self.add_payload(val) + else: + self.payload.setfieldval(attr,val) + + def __setattr__(self, attr, val): + if self.initialized: + try: + self.setfieldval(attr,val) + except AttributeError: + pass + else: + return + self.__dict__[attr] = val + + def delfieldval(self, attr): + if attr in self.fields: + del(self.fields[attr]) + self.explicit = 0 # in case a default value must be explicited + self.raw_packet_cache = None + elif attr in self.default_fields: + pass + elif attr == "payload": + self.remove_payload() + else: + self.payload.delfieldval(attr) + + def __delattr__(self, attr): + if self.initialized: + try: + self.delfieldval(attr) + except AttributeError: + pass + else: + return + if attr in self.__dict__: + del(self.__dict__[attr]) + else: + raise AttributeError(attr) + + def __repr__(self): + s = "" + ct = conf.color_theme + for f in self.fields_desc: + if isinstance(f, ConditionalField) and not f._evalcond(self): + continue + if f.name in self.fields: + val = f.i2repr(self, self.fields[f.name]) + elif f.name in self.overloaded_fields: + val = f.i2repr(self, self.overloaded_fields[f.name]) + else: + continue + if isinstance(f, Emph) or f in conf.emph: + ncol = ct.emph_field_name + vcol = ct.emph_field_value + else: + ncol = ct.field_name + vcol = ct.field_value + + + s += " %s%s%s" % (ncol(f.name), + ct.punct("="), + vcol(val)) + return "%s%s %s %s%s%s"% (ct.punct("<"), + ct.layer_name(self.__class__.__name__), + s, + ct.punct("|"), + repr(self.payload), + ct.punct(">")) + #def __str__(self): + #TODO3 FIX + def __str__(self): + warning("Unless called manually, this could indicate deprecated use. Should be changed to bytes(self)") + return repr(bytes(self)) + def __bytes__(self): + return self.build() + def __div__(self, other): + if isinstance(other, Packet): + cloneA = self.copy() + cloneB = other.copy() + cloneA.add_payload(cloneB) + return cloneA + elif type(other) is str: + return self/conf.raw_layer(load=other.encode('ascii')) + elif type(other) is bytes: + return self/conf.raw_layer(load=other) + else: + return other.__rdiv__(self) + __truediv__ = __div__ + def __rdiv__(self, other): + if type(other) is str: + return conf.raw_layer(load=other.encode('ascii'))/self + if type(other) is bytes: + return conf.raw_layer(load=other)/self + else: + raise TypeError + __rtruediv__ = __rdiv__ + def __mul__(self, other): + if type(other) is int: + return [self]*other + else: + raise TypeError + def __rmul__(self,other): + return self.__mul__(other) + + def __nonzero__(self): + return True + + def __len__(self): + return len(bytes(self)) + + def dump_fields_offsets (self): + for f in self.fields_desc: + print ("field %-40s %02d %02d" % (f.name, f.offset,f.get_size_bytes () ) ); + + def self_build(self, field_pos_list=None): + if self.raw_packet_cache is not None: + return self.raw_packet_cache + p=b"" + for f in self.fields_desc: + #print(f.name) + if type(p) is tuple : + f.offset=len(p[0]) + else: + assert(type(p)==bytes) + f.offset=len(p) + + val = self.getfieldval(f.name) + if isinstance(val, RawVal): + #sval = str(val) + sval = bytes(val) + p += sval + if field_pos_list is not None: + field_pos_list.append( (f.name, sval.encode("string_escape"), len(p), len(sval) ) ) + f.offset= val + else: + p = f.addfield(self, p, val) + return p + + def do_build_payload(self): + return self.payload.do_build(None) + + def do_update_payload_offset(self,pkt): + #print "obj-id ",id(self) + #print "current offset ",self.name," ",self.offset + #print "current header size ",len(pkt) + self.payload.offset = self.offset + len(pkt) + + def dump_layers_offset (self): + p=self; + while True: + print (p.name, "offset :",p.offset) + p=p.payload + if p ==None or isinstance(p,NoPayload): + break; + + + def do_build(self,result): + if not self.explicit: + self = next(self.__iter__()) + pkt = self.self_build() + for t in self.post_transforms: + pkt = t(pkt) + self.do_update_payload_offset(pkt) + pay = self.do_build_payload() + p = self.post_build(pkt,pay) + if result != None: + result.pkt = self; + return p + + def build_padding(self): + return self.payload.build_padding() + + def update_build_info (self,other): + p=self; + o=other; + while True: + assert(p.aliastypes==o.aliastypes) + assert(type(p) == type(o) ) + + #copy + p.offset=o.offset + + #next + p=p.payload + o=o.payload + if p ==None or isinstance(p,NoPayload): + break; + + def build(self): + result = CPacketRes; + p = self.do_build(result) + p += self.build_padding() + p = self.build_done(p) + self.update_build_info (result.pkt) + return p + + def post_build(self, pkt, pay): + """DEV: called right after the current layer is build.""" + return pkt+pay + + def build_done(self, p): + return self.payload.build_done(p) + + def do_build_ps(self): + p=b"" + pl = [] + q=b"" + for f in self.fields_desc: + if isinstance(f, ConditionalField) and not f._evalcond(self): + continue + p = f.addfield(self, p, self.getfieldval(f.name) ) + if type(p) is bytes: + r = p[len(q):] + q = p + else: + r = b"" + pl.append( (f, f.i2repr(self,self.getfieldval(f.name)), r) ) + + pkt,lst = self.payload.build_ps(internal=1) + p += pkt + lst.append( (self, pl) ) + + return p,lst + + def build_ps(self,internal=0): + p,lst = self.do_build_ps() +# if not internal: +# pkt = self +# while pkt.haslayer(conf.padding_layer): +# pkt = pkt.getlayer(conf.padding_layer) +# lst.append( (pkt, [ ("loakjkjd", pkt.load, pkt.load) ] ) ) +# p += pkt.load +# pkt = pkt.payload + return p,lst + + + def psdump(self, filename=None, **kargs): + """psdump(filename=None, layer_shift=0, rebuild=1) +Creates an EPS file describing a packet. If filename is not provided a temporary file is created and gs is called.""" + canvas = self.canvas_dump(**kargs) + if filename is None: + fname = get_temp_file(autoext=".eps") + canvas.writeEPSfile(fname) + subprocess.Popen([conf.prog.psreader, fname+".eps"]) + else: + canvas.writeEPSfile(filename) + + def pdfdump(self, filename=None, **kargs): + """pdfdump(filename=None, layer_shift=0, rebuild=1) + Creates a PDF file describing a packet. If filename is not provided a temporary file is created and xpdf is called.""" + canvas = self.canvas_dump(**kargs) + if filename is None: + fname = get_temp_file(autoext=".pdf") + canvas.writePDFfile(fname) + subprocess.Popen([conf.prog.pdfreader, fname+".pdf"]) + else: + canvas.writePDFfile(filename) + + + def canvas_dump(self, layer_shift=0, rebuild=1): + canvas = pyx.canvas.canvas() + if rebuild: + p,t = self.__class__(bytes(self)).build_ps() + else: + p,t = self.build_ps() + YTXT=len(t) + for n,l in t: + YTXT += len(l) + YTXT = float(YTXT) + YDUMP=YTXT + + XSTART = 1 + XDSTART = 10 + y = 0.0 + yd = 0.0 + xd = 0 + XMUL= 0.55 + YMUL = 0.4 + + backcolor=colgen(0.6, 0.8, 1.0, trans=pyx.color.rgb) + forecolor=colgen(0.2, 0.5, 0.8, trans=pyx.color.rgb) +# backcolor=makecol(0.376, 0.729, 0.525, 1.0) + + + def hexstr(x): + s = [] + for c in x: + s.append("%02x" % c) + return " ".join(s) + + + def make_dump_txt(x,y,txt): + return pyx.text.text(XDSTART+x*XMUL, (YDUMP-y)*YMUL, r"\tt{%s}"%hexstr(txt), [pyx.text.size.Large]) + + def make_box(o): + return pyx.box.rect(o.left(), o.bottom(), o.width(), o.height(), relcenter=(0.5,0.5)) + + def make_frame(lst): + if len(lst) == 1: + b = lst[0].bbox() + b.enlarge(pyx.unit.u_pt) + return b.path() + else: + fb = lst[0].bbox() + fb.enlarge(pyx.unit.u_pt) + lb = lst[-1].bbox() + lb.enlarge(pyx.unit.u_pt) + if len(lst) == 2 and fb.left() > lb.right(): + return pyx.path.path(pyx.path.moveto(fb.right(), fb.top()), + pyx.path.lineto(fb.left(), fb.top()), + pyx.path.lineto(fb.left(), fb.bottom()), + pyx.path.lineto(fb.right(), fb.bottom()), + pyx.path.moveto(lb.left(), lb.top()), + pyx.path.lineto(lb.right(), lb.top()), + pyx.path.lineto(lb.right(), lb.bottom()), + pyx.path.lineto(lb.left(), lb.bottom())) + else: + # XXX + gb = lst[1].bbox() + if gb != lb: + gb.enlarge(pyx.unit.u_pt) + kb = lst[-2].bbox() + if kb != gb and kb != lb: + kb.enlarge(pyx.unit.u_pt) + return pyx.path.path(pyx.path.moveto(fb.left(), fb.top()), + pyx.path.lineto(fb.right(), fb.top()), + pyx.path.lineto(fb.right(), kb.bottom()), + pyx.path.lineto(lb.right(), kb.bottom()), + pyx.path.lineto(lb.right(), lb.bottom()), + pyx.path.lineto(lb.left(), lb.bottom()), + pyx.path.lineto(lb.left(), gb.top()), + pyx.path.lineto(fb.left(), gb.top()), + pyx.path.closepath(),) + + + def make_dump(s, shift=0, y=0, col=None, bkcol=None, larg=16): + c = pyx.canvas.canvas() + tlist = [] + while s: + dmp,s = s[:larg-shift],s[larg-shift:] + txt = make_dump_txt(shift, y, dmp) + tlist.append(txt) + shift += len(dmp) + if shift >= 16: + shift = 0 + y += 1 + if col is None: + col = pyx.color.rgb.red + if bkcol is None: + col = pyx.color.rgb.white + c.stroke(make_frame(tlist),[col,pyx.deco.filled([bkcol]),pyx.style.linewidth.Thick]) + for txt in tlist: + c.insert(txt) + return c, tlist[-1].bbox(), shift, y + + + last_shift,last_y=0,0.0 + while t: + bkcol = next(backcolor) + proto,fields = t.pop() + y += 0.5 + pt = pyx.text.text(XSTART, (YTXT-y)*YMUL, r"\font\cmssfont=cmss10\cmssfont{%s}" % proto.name, [ pyx.text.size.Large]) + y += 1 + ptbb=pt.bbox() + ptbb.enlarge(pyx.unit.u_pt*2) + canvas.stroke(ptbb.path(),[pyx.color.rgb.black, pyx.deco.filled([bkcol])]) + canvas.insert(pt) + for fname, fval, fdump in fields: + col = next(forecolor) + ft = pyx.text.text(XSTART, (YTXT-y)*YMUL, r"\font\cmssfont=cmss10\cmssfont{%s}" % tex_escape(fname.name)) + if isinstance(fval, str): + if len(fval) > 18: + fval = fval[:18]+"[...]" + else: + fval="" + vt = pyx.text.text(XSTART+3, (YTXT-y)*YMUL, r"\font\cmssfont=cmss10\cmssfont{%s}" % tex_escape(fval)) + y += 1.0 + if fdump: + dt,target,last_shift,last_y = make_dump(fdump, last_shift, last_y, col, bkcol) + + dtb = dt.bbox() + dtb=target + vtb = vt.bbox() + bxvt = make_box(vtb) + bxdt = make_box(dtb) + dtb.enlarge(pyx.unit.u_pt) + try: + if yd < 0: + cnx = pyx.connector.curve(bxvt,bxdt,absangle1=0, absangle2=-90) + else: + cnx = pyx.connector.curve(bxvt,bxdt,absangle1=0, absangle2=90) + except: + pass + else: + canvas.stroke(cnx,[pyx.style.linewidth.thin,pyx.deco.earrow.small,col]) + + canvas.insert(dt) + + canvas.insert(ft) + canvas.insert(vt) + last_y += layer_shift + + return canvas + + + + def extract_padding(self, s): + """DEV: to be overloaded to extract current layer's padding. Return a couple of strings (actual layer, padding)""" + return s,None + + def post_dissect(self, s): + """DEV: is called right after the current layer has been dissected""" + return s + + def pre_dissect(self, s): + """DEV: is called right before the current layer is dissected""" + return s + + def do_dissect(self, s): + flist = self.fields_desc[:] + flist.reverse() + raw = s + while s and flist: + f = flist.pop() + #print(f, end = " = ") + s,fval = f.getfield(self, s) + #print('fval') + self.fields[f.name] = fval + assert(raw.endswith(s)) + if s: + self.raw_packet_cache = raw[:-len(s)] + else: + self.raw_packet_cache = raw + self.explicit = 1 + return s + + def do_dissect_payload(self, s): + if s: + cls = self.guess_payload_class(s) + try: + p = cls(s, _internal=1, _underlayer=self) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + if isinstance(cls,type) and issubclass(cls,Packet): + log_runtime.error("%s dissector failed" % cls.name) + else: + log_runtime.error("%s.guess_payload_class() returned [%s]" % (self.__class__.__name__,repr(cls))) + if cls is not None: + raise + p = conf.raw_layer(s, _internal=1, _underlayer=self) + self.add_payload(p) + + def dissect(self, s): + s = self.pre_dissect(s) + + s = self.do_dissect(s) + + s = self.post_dissect(s) + + payl,pad = self.extract_padding(s) + self.do_dissect_payload(payl) + if pad and conf.padding: + self.add_payload(conf.padding_layer(pad)) + + + def guess_payload_class(self, payload): + """DEV: Guesses the next payload class from layer bonds. Can be overloaded to use a different mechanism.""" + for t in self.aliastypes: + for fval, cls in t.payload_guess: + ok = 1 + for k in fval.keys(): + if not hasattr(self, k) or fval[k] != self.getfieldval(k): + ok = 0 + break + if ok: + return cls + return self.default_payload_class(payload) + + def default_payload_class(self, payload): + """DEV: Returns the default payload class if nothing has been found by the guess_payload_class() method.""" + return conf.raw_layer + + def hide_defaults(self): + """Removes fields' values that are the same as default values.""" + for k in list(self.fields.keys()): + if k in self.default_fields: + if self.default_fields[k] == self.fields[k]: + del(self.fields[k]) + self.payload.hide_defaults() + + def clone_with(self, payload=None, **kargs): + pkt = self.__class__() + pkt.explicit = 1 + pkt.fields = kargs + pkt.offset=self.offset + pkt.time = self.time + pkt.underlayer = self.underlayer + pkt.overload_fields = self.overload_fields.copy() + pkt.post_transforms = self.post_transforms + if payload is not None: + pkt.add_payload(payload) + return pkt + + + def __iter__(self): + def loop(todo, done, self=self): + if todo: + eltname = todo.pop() + elt = self.getfieldval(eltname) + if not isinstance(elt, Gen): + if self.get_field(eltname).islist: + elt = SetGen([elt]) + else: + elt = SetGen(elt) + for e in elt: + done[eltname]=e + for x in loop(todo[:], done): + yield x + else: + if isinstance(self.payload,NoPayload): + payloads = [None] + else: + payloads = self.payload + for payl in payloads: + done2=done.copy() + for k in done2: + if isinstance(done2[k], VolatileValue): + done2[k] = done2[k]._fix() + pkt = self.clone_with(payload=payl, **done2) + yield pkt + + if self.explicit: + todo = [] + done = self.fields + else: + todo = [ k for (k,v) in itertools.chain(self.default_fields.items(), + self.overloaded_fields.items()) + if isinstance(v, VolatileValue) ] + list(self.fields.keys()) + done = {} + return loop(todo, done) + + def __gt__(self, other): + """True if other is an answer from self (self ==> other).""" + if isinstance(other, Packet): + return other < self + elif type(other) is str: + return 1 + else: + raise TypeError((self, other)) + def __lt__(self, other): + """True if self is an answer from other (other ==> self).""" + if isinstance(other, Packet): + return self.answers(other) + elif type(other) is str: + return 1 + else: + raise TypeError((self, other)) + + def __eq__(self, other): + if not isinstance(other, self.__class__): + return False + for f in self.fields_desc: + if f not in other.fields_desc: + return False + if self.getfieldval(f.name) != other.getfieldval(f.name): + return False + return self.payload == other.payload + + def __ne__(self, other): + return not self.__eq__(other) + + def hashret(self): + """DEV: returns a string that has the same value for a request and its answer.""" + return self.payload.hashret() + def answers(self, other): + """DEV: true if self is an answer from other""" + if other.__class__ == self.__class__: + return self.payload.answers(other.payload) + return 0 + + def haslayer(self, cls): + """true if self has a layer that is an instance of cls. Superseded by "cls in self" syntax.""" + if self.__class__ == cls or self.__class__.__name__ == cls: + return 1 + for f in self.packetfields: + fvalue_gen = self.getfieldval(f.name) + if fvalue_gen is None: + continue + if not f.islist: + fvalue_gen = SetGen(fvalue_gen,_iterpacket=0) + for fvalue in fvalue_gen: + if isinstance(fvalue, Packet): + ret = fvalue.haslayer(cls) + if ret: + return ret + return self.payload.haslayer(cls) + def getlayer(self, cls, nb=1, _track=None): + """Return the nb^th layer that is an instance of cls.""" + if type(cls) is int: + nb = cls+1 + cls = None + if type(cls) is str and "." in cls: + ccls,fld = cls.split(".",1) + else: + ccls,fld = cls,None + if cls is None or self.__class__ == cls or self.__class__.name == ccls: + if nb == 1: + if fld is None: + return self + else: + return self.getfieldval(fld) + else: + nb -=1 + for f in self.packetfields: + fvalue_gen = self.getfieldval(f.name) + if fvalue_gen is None: + continue + if not f.islist: + fvalue_gen = SetGen(fvalue_gen,_iterpacket=0) + for fvalue in fvalue_gen: + if isinstance(fvalue, Packet): + track=[] + ret = fvalue.getlayer(cls, nb, _track=track) + if ret is not None: + return ret + nb = track[0] + return self.payload.getlayer(cls,nb,_track=_track) + + def firstlayer(self): + q = self + while q.underlayer is not None: + q = q.underlayer + return q + + def __getitem__(self, cls): + if type(cls) is slice: + lname = cls.start + if cls.stop: + ret = self.getlayer(cls.start, cls.stop) + else: + ret = self.getlayer(cls.start) + if ret is None and cls.step is not None: + ret = cls.step + else: + lname=cls + ret = self.getlayer(cls) + if ret is None: + if type(lname) is Packet_metaclass: + lname = lname.__name__ + elif type(lname) is not str: + lname = repr(lname) + raise IndexError("Layer [%s] not found" % lname) + return ret + + def __delitem__(self, cls): + del(self[cls].underlayer.payload) + + def __setitem__(self, cls, val): + self[cls].underlayer.payload = val + + def __contains__(self, cls): + """"cls in self" returns true if self has a layer which is an instance of cls.""" + return self.haslayer(cls) + + def route(self): + return (None,None,None) + + def fragment(self, *args, **kargs): + return self.payload.fragment(*args, **kargs) + + + def display(self,*args,**kargs): # Deprecated. Use show() + """Deprecated. Use show() method.""" + self.show(*args,**kargs) + def show(self, indent=3, lvl="", label_lvl=""): + """Prints a hierarchical view of the packet. "indent" gives the size of indentation for each layer.""" + ct = conf.color_theme + print("%s%s %s %s" % (label_lvl, + ct.punct("###["), + ct.layer_name(self.name), + ct.punct("]###"))) + for f in self.fields_desc: + if isinstance(f, ConditionalField) and not f._evalcond(self): + continue + if isinstance(f, Emph) or f in conf.emph: + ncol = ct.emph_field_name + vcol = ct.emph_field_value + else: + ncol = ct.field_name + vcol = ct.field_value + fvalue = self.getfieldval(f.name) + if isinstance(fvalue, Packet) or (f.islist and f.holds_packets and type(fvalue) is list): + print("%s \\%-10s\\" % (label_lvl+lvl, ncol(f.name))) + fvalue_gen = SetGen(fvalue,_iterpacket=0) + for fvalue in fvalue_gen: + fvalue.show(indent=indent, label_lvl=label_lvl+lvl+" |") + else: + begn = "%s %-10s%s " % (label_lvl+lvl, + ncol(f.name), + ct.punct("="),) + reprval = f.i2repr(self,fvalue) + if type(reprval) is str: + reprval = reprval.replace("\n", "\n"+" "*(len(label_lvl) + +len(lvl) + +len(f.name) + +4)) + print("%s%s" % (begn,vcol(reprval))) + self.payload.show(indent=indent, lvl=lvl+(" "*indent*self.show_indent), label_lvl=label_lvl) + def show2(self): + """Prints a hierarchical view of an assembled version of the packet, so that automatic fields are calculated (checksums, etc.)""" + self.__class__(bytes(self)).show() + + def sprintf(self, fmt, relax=1): + """sprintf(format, [relax=1]) -> str +where format is a string that can include directives. A directive begins and +ends by % and has the following format %[fmt[r],][cls[:nb].]field%. + +fmt is a classic printf directive, "r" can be appended for raw substitution +(ex: IP.flags=0x18 instead of SA), nb is the number of the layer we want +(ex: for IP/IP packets, IP:2.src is the src of the upper IP layer). +Special case : "%.time%" is the creation time. +Ex : p.sprintf("%.time% %-15s,IP.src% -> %-15s,IP.dst% %IP.chksum% " + "%03xr,IP.proto% %r,TCP.flags%") + +Moreover, the format string can include conditionnal statements. A conditionnal +statement looks like : {layer:string} where layer is a layer name, and string +is the string to insert in place of the condition if it is true, i.e. if layer +is present. If layer is preceded by a "!", the result si inverted. Conditions +can be imbricated. A valid statement can be : + p.sprintf("This is a{TCP: TCP}{UDP: UDP}{ICMP:n ICMP} packet") + p.sprintf("{IP:%IP.dst% {ICMP:%ICMP.type%}{TCP:%TCP.dport%}}") + +A side effect is that, to obtain "{" and "}" characters, you must use +"%(" and "%)". +""" + + escape = { "%": "%", + "(": "{", + ")": "}" } + + + # Evaluate conditions + while "{" in fmt: + i = fmt.rindex("{") + j = fmt[i+1:].index("}") + cond = fmt[i+1:i+j+1] + k = cond.find(":") + if k < 0: + raise Scapy_Exception("Bad condition in format string: [%s] (read sprintf doc!)"%cond) + cond,format = cond[:k],cond[k+1:] + res = False + if cond[0] == "!": + res = True + cond = cond[1:] + if self.haslayer(cond): + res = not res + if not res: + format = "" + fmt = fmt[:i]+format+fmt[i+j+2:] + + # Evaluate directives + s = "" + while "%" in fmt: + i = fmt.index("%") + s += fmt[:i] + fmt = fmt[i+1:] + if fmt and fmt[0] in escape: + s += escape[fmt[0]] + fmt = fmt[1:] + continue + try: + i = fmt.index("%") + sfclsfld = fmt[:i] + fclsfld = sfclsfld.split(",") + if len(fclsfld) == 1: + f = "s" + clsfld = fclsfld[0] + elif len(fclsfld) == 2: + f,clsfld = fclsfld + else: + raise Scapy_Exception + if "." in clsfld: + cls,fld = clsfld.split(".") + else: + cls = self.__class__.__name__ + fld = clsfld + num = 1 + if ":" in cls: + cls,num = cls.split(":") + num = int(num) + fmt = fmt[i+1:] + except: + raise Scapy_Exception("Bad format string [%%%s%s]" % (fmt[:25], fmt[25:] and "...")) + else: + if fld == "time": + val = time.strftime("%H:%M:%S.%%06i", time.localtime(self.time)) % int((self.time-int(self.time))*1000000) + elif cls == self.__class__.__name__ and hasattr(self, fld): + if num > 1: + val = self.payload.sprintf("%%%s,%s:%s.%s%%" % (f,cls,num-1,fld), relax) + f = "s" + elif f[-1] == "r": # Raw field value + val = getattr(self,fld) + f = f[:-1] + if not f: + f = "s" + else: + val = getattr(self,fld) + if fld in self.fieldtype: + val = self.fieldtype[fld].i2repr(self,val) + else: + val = self.payload.sprintf("%%%s%%" % sfclsfld, relax) + f = "s" + s += ("%"+f) % val + + s += fmt + return s + + def mysummary(self): + """DEV: can be overloaded to return a string that summarizes the layer. + Only one mysummary() is used in a whole packet summary: the one of the upper layer, + except if a mysummary() also returns (as a couple) a list of layers whose + mysummary() must be called if they are present.""" + return "" + + def _do_summary(self): + found,s,needed = self.payload._do_summary() + if s: + s = " / "+s + ret = "" + if not found or self.__class__ in needed: + ret = self.mysummary() + if type(ret) is tuple: + ret,n = ret + needed += n + if ret or needed: + found = 1 + if not ret: + ret = self.__class__.__name__ + if self.__class__ in conf.emph: + impf = [] + for f in self.fields_desc: + if f in conf.emph: + impf.append("%s=%s" % (f.name, f.i2repr(self, self.getfieldval(f.name)))) + ret = "%s [%s]" % (ret," ".join(impf)) + ret = "%s%s" % (ret,s) + return found,ret,needed + + def summary(self, intern=0): + """Prints a one line summary of a packet.""" + found,s,needed = self._do_summary() + return s + + + def lastlayer(self,layer=None): + """Returns the uppest layer of the packet""" + return self.payload.lastlayer(self) + + def decode_payload_as(self,cls): + """Reassembles the payload and decode it using another packet class""" + s = bytes(self.payload) + self.payload = cls(s, _internal=1, _underlayer=self) + pp = self + while pp.underlayer is not None: + pp = pp.underlayer + self.payload.dissection_done(pp) + + def libnet(self): + """Not ready yet. Should give the necessary C code that interfaces with libnet to recreate the packet""" + print("libnet_build_%s(" % self.__class__.name.lower()) + det = self.__class__(str(self)) + for f in self.fields_desc: + val = det.getfieldval(f.name) + if val is None: + val = 0 + elif type(val) is int: + val = str(val) + else: + val = '"%s"' % str(val) + print("\t%s, \t\t/* %s */" % (val,f.name)) + print(");") + def command(self): + """Returns a string representing the command you have to type to obtain the same packet""" + f = [] + for fn,fv in self.fields.items(): + fld = self.get_field(fn) + if isinstance(fv, Packet): + fv = fv.command() + elif fld.islist and fld.holds_packets and type(fv) is list: + #fv = "[%s]" % ",".join( map(Packet.command, fv)) + fv = "[%s]" % ",".join([ Packet.command(i) for i in fv ]) + else: + fv = repr(fv) + f.append("%s=%s" % (fn, fv)) + c = "%s(%s)" % (self.__class__.__name__, ", ".join(f)) + pc = self.payload.command() + if pc: + c += "/"+pc + return c + +class NoPayload(Packet): + def __new__(cls, *args, **kargs): + singl = cls.__dict__.get("__singl__") + if singl is None: + cls.__singl__ = singl = Packet.__new__(cls) + Packet.__init__(singl) + return singl + def __init__(self, *args, **kargs): + pass + def dissection_done(self,pkt): + return + def add_payload(self, payload): + raise Scapy_Exception("Can't add payload to NoPayload instance") + def remove_payload(self): + pass + def add_underlayer(self,underlayer): + pass + def remove_underlayer(self,other): + pass + def copy(self): + return self + def __repr__(self): + return "" + def __str__(self): + return "" + def __nonzero__(self): + return False + def do_build(self,result): + return b"" + def build(self): + return b"" + def build_padding(self): + return b"" + def build_done(self, p): + return p + def build_ps(self, internal=0): + return b"",[] + def getfieldval(self, attr): + raise AttributeError(attr) + def getfield_and_val(self, attr): + raise AttributeError(attr) + def setfieldval(self, attr, val): + raise AttributeError(attr) + def delfieldval(self, attr): + raise AttributeError(attr) + def __getattr__(self, attr): + if attr in self.__dict__: + return self.__dict__[attr] + elif attr in self.__class__.__dict__: + return self.__class__.__dict__[attr] + else: + raise AttributeError(attr) + def hide_defaults(self): + pass + def __iter__(self): + return iter([]) + def __eq__(self, other): + if isinstance(other, NoPayload): + return True + return False + def hashret(self): + return b"" + def answers(self, other): + return isinstance(other, NoPayload) or isinstance(other, conf.padding_layer) + def haslayer(self, cls): + return 0 + def getlayer(self, cls, nb=1, _track=None): + if _track is not None: + _track.append(nb) + return None + def fragment(self, *args, **kargs): + raise Scapy_Exception("cannot fragment this packet") + def show(self, indent=3, lvl="", label_lvl=""): + pass + def sprintf(self, fmt, relax): + if relax: + return "??" + else: + raise Scapy_Exception("Format not found [%s]"%fmt) + def _do_summary(self): + return 0,"",[] + def lastlayer(self,layer): + return layer + def command(self): + return "" + +#################### +## packet classes ## +#################### + + +class Raw(Packet): + name = "Raw" + fields_desc = [ StrField("load", b"") ] + def answers(self, other): + return 1 +# s = str(other) +# t = self.load +# l = min(len(s), len(t)) +# return s[:l] == t[:l] + def mysummary(self): + cs = conf.raw_summary + if cs: + if callable(cs): + return "Raw %s" % cs(self.load) + else: + return "Raw %r" % self.load + return Packet.mysummary(self) + +class Padding(Raw): + name = "Padding" + def self_build(self): + return b"" + def build_padding(self): + return (self.getbyteval("load") if self.raw_packet_cache is None + else self.raw_packet_cache) + self.payload.build_padding() + +conf.raw_layer = Raw +conf.padding_layer = Padding +if conf.default_l2 is None: + conf.default_l2 = Raw + +################# +## Bind layers ## +################# + + +def bind_bottom_up(lower, upper, __fval=None, **fval): + if __fval is not None: + fval.update(__fval) + lower.payload_guess = lower.payload_guess[:] + lower.payload_guess.append((fval, upper)) + + +def bind_top_down(lower, upper, __fval=None, **fval): + if __fval is not None: + fval.update(__fval) + upper.overload_fields = upper.overload_fields.copy() + upper.overload_fields[lower] = fval + +@conf.commands.register +def bind_layers(lower, upper, __fval=None, **fval): + """Bind 2 layers on some specific fields' values""" + if __fval is not None: + fval.update(__fval) + bind_top_down(lower, upper, **fval) + bind_bottom_up(lower, upper, **fval) + +def split_bottom_up(lower, upper, __fval=None, **fval): + if __fval is not None: + fval.update(__fval) + #def do_filter((f,u),upper=upper,fval=fval): + def do_filter(s,upper=upper,fval=fval): + if s[1] != upper: + return True + for k in fval: + if k not in s[0] or s[0][k] != fval[k]: + return True + return False + lower.payload_guess = list(filter(do_filter, lower.payload_guess)) + +def split_top_down(lower, upper, __fval=None, **fval): + if __fval is not None: + fval.update(__fval) + if lower in upper.overload_fields: + ofval = upper.overload_fields[lower] + for k in fval: + if k not in ofval or ofval[k] != fval[k]: + return + upper.overload_fields = upper.overload_fields.copy() + del(upper.overload_fields[lower]) + +@conf.commands.register +def split_layers(lower, upper, __fval=None, **fval): + """Split 2 layers previously bound""" + if __fval is not None: + fval.update(__fval) + split_bottom_up(lower, upper, **fval) + split_top_down(lower, upper, **fval) + + +@conf.commands.register +def ls(obj=None): + """List available layers, or infos on a given layer""" + if obj is None: + + import builtins + all = builtins.__dict__.copy() + all.update(globals()) + objlst = sorted(conf.layers, key=lambda x:x.__name__) + for o in objlst: + print("%-10s : %s" %(o.__name__,o.name)) + else: + if isinstance(obj, type) and issubclass(obj, Packet): + for f in obj.fields_desc: + print("%-10s : %-20s = (%s)" % (f.name, f.__class__.__name__, repr(f.default))) + elif isinstance(obj, Packet): + for f in obj.fields_desc: + print("%-10s : %-20s = %-15s (%s)" % (f.name, f.__class__.__name__, repr(getattr(obj,f.name)), repr(f.default))) + if not isinstance(obj.payload, NoPayload): + print("--") + ls(obj.payload) + + + else: + print("Not a packet class. Type 'ls()' to list packet classes.") + + + +############# +## Fuzzing ## +############# + +@conf.commands.register +def fuzz(p, _inplace=0): + """Transform a layer into a fuzzy layer by replacing some default values by random objects""" + if not _inplace: + p = p.copy() + q = p + while not isinstance(q, NoPayload): + for f in q.fields_desc: + if isinstance(f, PacketListField): + for r in getattr(q, f.name): + print("fuzzing", repr(r)) + fuzz(r, _inplace=1) + elif f.default is not None: + rnd = f.randval() + if rnd is not None: + q.default_fields[f.name] = rnd + q = q.payload + return p + + + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/pipetool.py b/scripts/external_libs/scapy-python3-0.18/scapy/pipetool.py new file mode 100644 index 00000000..2dc28cb5 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/pipetool.py @@ -0,0 +1,566 @@ +#! /usr/bin/env python + +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +from __future__ import with_statement + +import scapy.utils +from scapy.config import conf +import os,_thread,select +import subprocess +import itertools +import collections +import time +from scapy.error import log_interactive,warning +import queue + +class PipeEngine: + pipes = {} + @classmethod + def list_pipes(cls): + for pn,pc in sorted(cls.pipes.items()): + doc = pc.__doc__ or "" + if doc: + doc = doc.splitlines()[0] + print("%20s: %s" % (pn, doc)) + @classmethod + def list_pipes_detailed(cls): + for pn,pc in sorted(cls.pipes.items()): + if pc.__doc__: + print("###### %s\n %s" % (pn ,pc.__doc__)) + else: + print("###### %s" % pn) + + def __init__(self, *pipes): + self.active_pipes = set() + self.active_sources = set() + self.active_drains = set() + self.active_sinks = set() + self._add_pipes(*pipes) + self.thread_lock = _thread.allocate_lock() + self.command_lock = _thread.allocate_lock() + self.__fdr,self.__fdw = os.pipe() + self.threadid = None + def __getattr__(self, attr): + if attr.startswith("spawn_"): + dname = attr[6:] + if dname in self.pipes: + def f(*args, **kargs): + k = self.pipes[dname] + p = k(*args, **kargs) + self.add(p) + return p + return f + raise AttributeError(attr) + + def add_one_pipe(self, pipe): + self.active_pipes.add(pipe) + if isinstance(pipe, Source): + self.active_sources.add(pipe) + if isinstance(pipe, Drain): + self.active_drains.add(pipe) + if isinstance(pipe, Sink): + self.active_sinks.add(pipe) + + def get_pipe_list(self, pipe): + def flatten(p, l): + l.add(p) + for q in p.sources|p.sinks|p.high_sources|p.high_sinks: + if q not in l: + flatten(q, l) + pl = set() + flatten(pipe, pl) + return pl + + def _add_pipes(self, *pipes): + pl = set() + for p in pipes: + pl |= self.get_pipe_list(p) + pl -= self.active_pipes + for q in pl: + self.add_one_pipe(q) + return pl + + + def run(self): + log_interactive.info("Pipe engine thread started.") + try: + for p in self.active_pipes: + p.start() + sources = self.active_sources + sources.add(self.__fdr) + exhausted = set([]) + RUN=True + STOP_IF_EXHAUSTED = False + while RUN and (not STOP_IF_EXHAUSTED or len(sources) > 1): + fds,fdo,fde=select.select(sources,[],[]) + for fd in fds: + if fd is self.__fdr: + cmd = os.read(self.__fdr,1) + if cmd == "X": + RUN=False + break + elif cmd == "B": + STOP_IF_EXHAUSTED = True + elif cmd == "A": + sources = self.active_sources-exhausted + sources.add(self.__fdr) + else: + warning("Unknown internal pipe engine command: %r. Ignoring." % cmd) + elif fd in sources: + try: + fd.deliver() + except Exception as e: + log_interactive.exception("piping from %s failed: %s" % (fd.name, e)) + else: + if fd.exhausted(): + exhausted.add(fd) + sources.remove(fd) + except KeyboardInterrupt: + pass + finally: + try: + for p in self.active_pipes: + p.stop() + finally: + self.thread_lock.release() + log_interactive.info("Pipe engine thread stopped.") + + def start(self): + if self.thread_lock.acquire(0): + self.threadid = _thread.start_new_thread(self.run,()) + else: + warning("Pipe engine already running") + def wait_and_stop(self): + self.stop(_cmd="B") + def stop(self, _cmd="X"): + try: + with self.command_lock: + if self.threadid is not None: + os.write(self.__fdw, _cmd) + while not self.thread_lock.acquire(0): + time.sleep(0.01) # interruptible wait for thread to terminate + self.thread_lock.release() # (not using .join() because it needs 'threading' module) + else: + warning("Pipe engine thread not running") + except KeyboardInterrupt: + print("Interrupted by user.") + + def add(self, *pipes): + pipes = self._add_pipes(*pipes) + with self.command_lock: + if self.threadid is not None: + for p in pipes: + p.start() + os.write(self.__fdw, "A") + + def graph(self,**kargs): + g=['digraph "pipe" {',"\tnode [shape=rectangle];",] + for p in self.active_pipes: + g.append('\t"%i" [label="%s"];' % (id(p), p.name)) + g.append("") + g.append("\tedge [color=blue, arrowhead=vee];") + for p in self.active_pipes: + for q in p.sinks: + g.append('\t"%i" -> "%i";' % (id(p), id(q))) + g.append("") + g.append("\tedge [color=red, arrowhead=veevee];") + for p in self.active_pipes: + for q in p.high_sinks: + g.append('\t"%i" -> "%i" [color="red"];' % (id(p), id(q))) + g.append('}') + graph = "\n".join(g) + scapy.utils.do_graph(graph, **kargs) + + +class _ConnectorLogic(object): + def __init__(self): + self.sources = set() + self.sinks = set() + self.high_sources = set() + self.high_sinks = set() + + def __lt__(self, other): + other.sinks.add(self) + self.sources.add(other) + return other + def __gt__(self, other): + self.sinks.add(other) + other.sources.add(self) + return other + def __eq__(self, other): + self > other + other > self + return other + + def __lshift__(self, other): + self.high_sources.add(other) + other.high_sinks.add(self) + return other + def __rshift__(self, other): + self.high_sinks.add(other) + other.high_sources.add(self) + return other + def __floordiv__(self, other): + self >> other + other >> self + return other + + +class Pipe(_ConnectorLogic): + #TODO3 Move to new metaclass syntax + class __metaclass__(type): + def __new__(cls, name, bases, dct): + c = type.__new__(cls, name, bases, dct) + PipeEngine.pipes[name] = c + return c + def __init__(self, name=None): + _ConnectorLogic.__init__(self) + if name is None: + name = "%s" % (self.__class__.__name__) + self.name = name + def _send(self, msg): + for s in self.sinks: + s.push(msg) + def _high_send(self, msg): + for s in self.high_sinks: + s.high_push(msg) + + def __repr__(self): + ct = conf.color_theme + s = "%s%s" % (ct.punct("<"), ct.layer_name(self.name)) + if self.sources or self.sinks: + s+= " %s" % ct.punct("[") + if self.sources: + s+="%s%s" % (ct.punct(",").join(ct.field_name(s.name) for s in self.sources), + ct.field_value(">")) + s += ct.layer_name("#") + if self.sinks: + s+="%s%s" % (ct.field_value(">"), + ct.punct(",").join(ct.field_name(s.name) for s in self.sinks)) + s += ct.punct("]") + + if self.high_sources or self.high_sinks: + s+= " %s" % ct.punct("[") + if self.high_sources: + s+="%s%s" % (ct.punct(",").join(ct.field_name(s.name) for s in self.high_sources), + ct.field_value(">>")) + s += ct.layer_name("#") + if self.high_sinks: + s+="%s%s" % (ct.field_value(">>"), + ct.punct(",").join(ct.field_name(s.name) for s in self.high_sinks)) + s += ct.punct("]") + + + s += ct.punct(">") + return s + +class Source(Pipe): + def __init__(self, name=None): + Pipe.__init__(self, name=name) + self.is_exhausted = False + def _read_message(self): + return Message() + def deliver(self): + msg = self._read_message + self._send(msg) + def fileno(self): + return None + def exhausted(self): + return self.is_exhausted + def start(self): + pass + def stop(self): + pass + +class Drain(Pipe): + """Repeat messages from low/high entries to (resp.) low/high exits + +-------+ + >>-|-------|->> + | | + >-|-------|-> + +-------+ +""" + def push(self, msg): + self._send(msg) + def high_push(self, msg): + self._high_send(msg) + def start(self): + pass + def stop(self): + pass + +class Sink(Pipe): + def push(self, msg): + pass + def high_push(self, msg): + pass + def start(self): + pass + def stop(self): + pass + + +class AutoSource(Source): + def __init__(self, name=None): + Source.__init__(self, name=name) + self.__fdr,self.__fdw = os.pipe() + self._queue = collections.deque() + def fileno(self): + return self.__fdr + def _gen_data(self, msg): + self._queue.append((msg,False)) + self._wake_up() + def _gen_high_data(self, msg): + self._queue.append((msg,True)) + self._wake_up() + def _wake_up(self): + os.write(self.__fdw,"x") + def deliver(self): + os.read(self.__fdr,1) + try: + msg,high = self._queue.popleft() + except IndexError: #empty queue. Exhausted source + pass + else: + if high: + self._high_send(msg) + else: + self._send(msg) + +class ThreadGenSource(AutoSource): + def __init__(self, name=None): + AutoSource.__init__(self, name=name) + self.RUN = False + def generate(self): + pass + def start(self): + self.RUN = True + _thread.start_new_thread(self.generate,()) + def stop(self): + self.RUN = False + + + +class ConsoleSink(Sink): + """Print messages on low and high entries + +-------+ + >>-|--. |->> + | print | + >-|--' |-> + +-------+ +""" + def push(self, msg): + print(">%r" % msg) + def high_push(self, msg): + print(">>%r" % msg) + +class RawConsoleSink(Sink): + """Print messages on low and high entries + +-------+ + >>-|--. |->> + | write | + >-|--' |-> + +-------+ +""" + def __init__(self, name=None, newlines=True): + Sink.__init__(self, name=name) + self.newlines = newlines + def push(self, msg): + if self.newlines: + msg += "\n" + os.write(1, str(msg)) + def high_push(self, msg): + if self.newlines: + msg += "\n" + os.write(1, str(msg)) + +class CLIFeeder(AutoSource): + """Send messages from python command line + +--------+ + >>-| |->> + | send() | + >-| `----|-> + +--------+ +""" + def send(self, msg): + self._gen_data(msg) + def close(self): + self.is_exhausted = True + +class CLIHighFeeder(CLIFeeder): + """Send messages from python command line to high output + +--------+ + >>-| .----|->> + | send() | + >-| |-> + +--------+ +""" + def send(self, msg): + self._gen_high_data(msg) + + +class PeriodicSource(ThreadGenSource): + """Generage messages periodically on low exit + +-------+ + >>-| |->> + | msg,T | + >-| `----|-> + +-------+ +""" + def __init__(self, msg, period, period2=0, name=None): + ThreadGenSource.__init__(self,name=name) + if not hasattr(msg, "__iter__"): + msg=[msg] + self.msg = msg + self.period = period + self.period2 = period2 + def generate(self): + while self.RUN: + empty_gen = True + for m in self.msg: + empty_gen = False + self._gen_data(m) + time.sleep(self.period) + if empty_gen: + self.is_exhausted = True + self._wake_up() + time.sleep(self.period2) + +class TermSink(Sink): + """Print messages on low and high entries on a separate terminal + +-------+ + >>-|--. |->> + | print | + >-|--' |-> + +-------+ +""" + def __init__(self, name=None, keepterm=True, newlines=True, openearly=True): + Sink.__init__(self, name=name) + self.keepterm = keepterm + self.newlines = newlines + self.openearly = openearly + self.opened = False + if self.openearly: + self.start() + + def start(self): + if not self.opened: + self.opened = True + self.__r,self.__w = os.pipe() + cmd = ["xterm"] + if self.name is not None: + cmd.extend(["-title",self.name]) + if self.keepterm: + cmd.append("-hold") + cmd.extend(["-e", "cat 0<&%i" % self.__r]) + self.__p = subprocess.Popen(cmd) + os.close(self.__r) + def stop(self): + if not self.keepterm: + self.opened = False + os.close(self.__w) + self.__p.kill() + self.__p.wait() + def _print(self, s): + if self.newlines: + s+="\n" + os.write(self.__w, s) + + def push(self, msg): + self._print(str(msg)) + def high_push(self, msg): + self._print(str(msg)) + + +class QueueSink(Sink): + """Collect messages from high and low entries and queue them. Messages are unqueued with the .recv() method. + +-------+ + >>-|--. |->> + | queue | + >-|--' |-> + +-------+ +""" + def __init__(self, name=None): + Sink.__init__(self, name=name) + self.q = queue.Queue() + def push(self, msg): + self.q.put(msg) + def high_push(self, msg): + self.q.put(msg) + def recv(self): + while True: + try: + return self.q.get(True, timeout=0.1) + except queue.Empty: + pass + + +class TransformDrain(Drain): + """Apply a function to messages on low and high entry + +-------+ + >>-|--[f]--|->> + | | + >-|--[f]--|-> + +-------+ +""" + def __init__(self, f, name=None): + Drain.__init__(self, name=name) + self.f = f + def push(self, msg): + self._send(self.f(msg)) + def high_push(self, msg): + self._high_send(self.f(msg)) + +class UpDrain(Drain): + """Repeat messages from low entry to high exit + +-------+ + >>-| ,--|->> + | / | + >-|--' |-> + +-------+ +""" + def push(self, msg): + self._high_send(msg) + def high_push(self, msg): + pass + +class DownDrain(Drain): + """Repeat messages from high entry to low exit + +-------+ + >>-|--. |->> + | \ | + >-| `--|-> + +-------+ +""" + def push(self, msg): + pass + def high_push(self, msg): + self._send(msg) + + +def _testmain(): + s = PeriodicSource("hello", 1, name="src") + d1 = Drain(name="d1") + c = ConsoleSink(name="c") + tf = TransformDrain(lambda x:"Got %r" % x) + t = TermSink(name="t", keepterm=False) + + s > d1 > c + d1 > tf > t + + p = PipeEngine(s) + + p.graph(type="png",target="> /tmp/pipe.png") + + p.start() + print(p.threadid) + time.sleep(5) + p.stop() + + +if __name__ == "__main__": + _testmain() diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/plist.py b/scripts/external_libs/scapy-python3-0.18/scapy/plist.py new file mode 100644 index 00000000..bdf0b757 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/plist.py @@ -0,0 +1,517 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +PacketList: holds several packets and allows to do operations on them. +""" + + +import os,subprocess +from .config import conf +from .base_classes import BasePacket,BasePacketList +from collections import defaultdict + +from .utils import do_graph,hexdump,make_table,make_lined_table,make_tex_table,get_temp_file + +from scapy.arch import NETWORKX +if NETWORKX: + import networkx as nx + + +############# +## Results ## +############# + +class PacketList(BasePacketList): + res = [] + def __init__(self, res=None, name="PacketList", stats=None, vector_index = None): + """create a packet list from a list of packets + res: the list of packets + stats: a list of classes that will appear in the stats (defaults to [TCP,UDP,ICMP])""" + if stats is None: + stats = conf.stats_classic_protocols + self.stats = stats + if res is None: + res = [] + if isinstance(res, PacketList): + res = res.res + self.res = res + self.listname = name + self.vector_index = vector_index + def __len__(self): + return len(self.res) + def _elt2pkt(self, elt): + if self.vector_index == None: + return elt + else: + return elt[self.vector_index] + def _elt2sum(self, elt): + if self.vector_index == None: + return elt.summary() + else: + return "%s ==> %s" % (elt[0].summary(),elt[1].summary()) + + def _elt2show(self, elt): + return self._elt2sum(elt) + def __repr__(self): + stats=dict.fromkeys(self.stats,0) + other = 0 + for r in self.res: + f = 0 + for p in stats: + if self._elt2pkt(r).haslayer(p): + stats[p] += 1 + f = 1 + break + if not f: + other += 1 + s = "" + ct = conf.color_theme + for p in self.stats: + s += " %s%s%s" % (ct.packetlist_proto(p.name), + ct.punct(":"), + ct.packetlist_value(stats[p])) + s += " %s%s%s" % (ct.packetlist_proto("Other"), + ct.punct(":"), + ct.packetlist_value(other)) + return "%s%s%s%s%s" % (ct.punct("<"), + ct.packetlist_name(self.listname), + ct.punct(":"), + s, + ct.punct(">")) + def __getattr__(self, attr): + return getattr(self.res, attr) + def __getitem__(self, item): + if isinstance(item,type) and issubclass(item,BasePacket): + #return self.__class__(filter(lambda x: item in self._elt2pkt(x),self.res), + return self.__class__([ x for x in self.res if item in self._elt2pkt(x) ], + name="%s from %s"%(item.__name__,self.listname)) + if type(item) is slice: + return self.__class__(self.res.__getitem__(item), + name = "mod %s" % self.listname) + return self.res.__getitem__(item) + def __getslice__(self, *args, **kargs): + return self.__class__(self.res.__getslice__(*args, **kargs), + name="mod %s"%self.listname) + def __add__(self, other): + return self.__class__(self.res+other.res, + name="%s+%s"%(self.listname,other.listname)) + def summary(self, prn=None, lfilter=None): + """prints a summary of each packet +prn: function to apply to each packet instead of lambda x:x.summary() +lfilter: truth function to apply to each packet to decide whether it will be displayed""" + for r in self.res: + if lfilter is not None: + if not lfilter(r): + continue + if prn is None: + print(self._elt2sum(r)) + else: + print(prn(r)) + def nsummary(self,prn=None, lfilter=None): + """prints a summary of each packet with the packet's number +prn: function to apply to each packet instead of lambda x:x.summary() +lfilter: truth function to apply to each packet to decide whether it will be displayed""" + for i, p in enumerate(self.res): + if lfilter is not None: + if not lfilter(p): + continue + print(conf.color_theme.id(i,fmt="%04i"), end = " ") + if prn is None: + print(self._elt2sum(p)) + else: + print(prn(p)) + def display(self): # Deprecated. Use show() + """deprecated. is show()""" + self.show() + def show(self, *args, **kargs): + """Best way to display the packet list. Defaults to nsummary() method""" + return self.nsummary(*args, **kargs) + + def filter(self, func): + """Returns a packet list filtered by a truth function""" + return self.__class__(list(filter(func,self.res)), + name="filtered %s"%self.listname) + + def plot(self, f, lfilter=None,**kargs): + """Applies a function to each packet to get a value that will be plotted with matplotlib. A matplotlib object is returned + lfilter: a truth function that decides whether a packet must be ploted""" + + return plt.plot([ f(i) for i in self.res if not lfilter or lfilter(i) ], **kargs) + + def diffplot(self, f, delay=1, lfilter=None, **kargs): + """diffplot(f, delay=1, lfilter=None) + Applies a function to couples (l[i],l[i+delay])""" + + return plt.plot([ f(i, j) for i in self.res[:-delay] for j in self.res[delay:] if not lfilter or (lfilter(i) and lfilter(j))], + **kargs) + + def multiplot(self, f, lfilter=None, **kargs): + """Uses a function that returns a label and a value for this label, then plots all the values label by label""" + + d = defaultdict(list) + for i in self.res: + if lfilter and not lfilter(i): + continue + k, v = f(i) + d[k].append(v) + + figure = plt.figure() + ax = figure.add_axes(plt.axes()) + for i in d: + ax.plot(d[i], **kargs) + return figure + + + def rawhexdump(self): + """Prints an hexadecimal dump of each packet in the list""" + for p in self: + hexdump(self._elt2pkt(p)) + + def hexraw(self, lfilter=None): + """Same as nsummary(), except that if a packet has a Raw layer, it will be hexdumped + lfilter: a truth function that decides whether a packet must be displayed""" + for i,p in enumerate(self.res): + p1 = self._elt2pkt(p) + if lfilter is not None and not lfilter(p1): + continue + print("%s %s %s" % (conf.color_theme.id(i,fmt="%04i"), + p1.sprintf("%.time%"), + self._elt2sum(p))) + if p1.haslayer(conf.raw_layer): + hexdump(p1.getlayer(conf.raw_layer).load) + + def hexdump(self, lfilter=None): + """Same as nsummary(), except that packets are also hexdumped + lfilter: a truth function that decides whether a packet must be displayed""" + for i,p in enumerate(self.res): + p1 = self._elt2pkt(p) + if lfilter is not None and not lfilter(p1): + continue + print("%s %s %s" % (conf.color_theme.id(i,fmt="%04i"), + p1.sprintf("%.time%"), + self._elt2sum(p))) + hexdump(p1) + + def padding(self, lfilter=None): + """Same as hexraw(), for Padding layer""" + for i,p in enumerate(self.res): + p1 = self._elt2pkt(p) + if p1.haslayer(conf.padding_layer): + if lfilter is None or lfilter(p1): + print("%s %s %s" % (conf.color_theme.id(i,fmt="%04i"), + p1.sprintf("%.time%"), + self._elt2sum(p))) + hexdump(p1.getlayer(conf.padding_layer).load) + + def nzpadding(self, lfilter=None): + """Same as padding() but only non null padding""" + for i,p in enumerate(self.res): + p1 = self._elt2pkt(p) + if p1.haslayer(conf.padding_layer): + pad = p1.getlayer(conf.padding_layer).load + if pad == pad[0]*len(pad): + continue + if lfilter is None or lfilter(p1): + print("%s %s %s" % (conf.color_theme.id(i,fmt="%04i"), + p1.sprintf("%.time%"), + self._elt2sum(p))) + hexdump(p1.getlayer(conf.padding_layer).load) + + + def conversations(self, getsrcdst=None, draw = True, **kargs): + """Graphes a conversations between sources and destinations and display it + (using graphviz) + getsrcdst: a function that takes an element of the list and return the source and dest + by defaults, return source and destination IP + if networkx library is available returns a DiGraph, or draws it if draw = True otherwise graphviz is used + format: output type (svg, ps, gif, jpg, etc.), passed to dot's "-T" option + target: output filename. If None, matplotlib is used to display + prog: which graphviz program to use""" + if getsrcdst is None: + getsrcdst = lambda x:(x['IP'].src, x['IP'].dst) + conv = {} + for p in self.res: + p = self._elt2pkt(p) + try: + c = getsrcdst(p) + except: + #XXX warning() + continue + conv[c] = conv.get(c,0)+1 + + if NETWORKX: # networkx is available + gr = nx.DiGraph() + for s,d in conv: + if s not in gr: + gr.add_node(s) + if d not in gr: + gr.add_node(d) + gr.add_edge(s, d) + if draw: + return do_graph(gr, **kargs) + else: + return gr + else: + gr = 'digraph "conv" {\n' + for s,d in conv: + gr += '\t "%s" -> "%s"\n' % (s,d) + gr += "}\n" + return do_graph(gr, **kargs) + + def afterglow(self, src=None, event=None, dst=None, **kargs): + """Experimental clone attempt of http://sourceforge.net/projects/afterglow + each datum is reduced as src -> event -> dst and the data are graphed. + by default we have IP.src -> IP.dport -> IP.dst""" + if src is None: + src = lambda x: x['IP'].src + if event is None: + event = lambda x: x['IP'].dport + if dst is None: + dst = lambda x: x['IP'].dst + sl = {} + el = {} + dl = {} + for i in self.res: + try: + s,e,d = src(i),event(i),dst(i) + if s in sl: + n,l = sl[s] + n += 1 + if e not in l: + l.append(e) + sl[s] = (n,l) + else: + sl[s] = (1,[e]) + if e in el: + n,l = el[e] + n+=1 + if d not in l: + l.append(d) + el[e] = (n,l) + else: + el[e] = (1,[d]) + dl[d] = dl.get(d,0)+1 + except: + continue + + import math + def normalize(n): + return 2+math.log(n)/4.0 + + def minmax(x): + m,M = min(x),max(x) + if m == M: + m = 0 + if M == 0: + M = 1 + return m,M + + #mins,maxs = minmax(map(lambda (x,y): x, sl.values())) + mins,maxs = minmax([ a[0] for a in sl.values()]) + #mine,maxe = minmax(map(lambda (x,y): x, el.values())) + mine,maxe = minmax([ a[0] for a in el.values()]) + mind,maxd = minmax(dl.values()) + + gr = 'digraph "afterglow" {\n\tedge [len=2.5];\n' + + gr += "# src nodes\n" + for s in sl: + n,l = sl[s]; n = 1+(n-mins)/(maxs-mins) + gr += '"src.%s" [label = "%s", shape=box, fillcolor="#FF0000", style=filled, fixedsize=1, height=%.2f,width=%.2f];\n' % (repr(s),repr(s),n,n) + gr += "# event nodes\n" + for e in el: + n,l = el[e]; n = n = 1+(n-mine)/(maxe-mine) + gr += '"evt.%s" [label = "%s", shape=circle, fillcolor="#00FFFF", style=filled, fixedsize=1, height=%.2f, width=%.2f];\n' % (repr(e),repr(e),n,n) + for d in dl: + n = dl[d]; n = n = 1+(n-mind)/(maxd-mind) + gr += '"dst.%s" [label = "%s", shape=triangle, fillcolor="#0000ff", style=filled, fixedsize=1, height=%.2f, width=%.2f];\n' % (repr(d),repr(d),n,n) + + gr += "###\n" + for s in sl: + n,l = sl[s] + for e in l: + gr += ' "src.%s" -> "evt.%s";\n' % (repr(s),repr(e)) + for e in el: + n,l = el[e] + for d in l: + gr += ' "evt.%s" -> "dst.%s";\n' % (repr(e),repr(d)) + + gr += "}" + return do_graph(gr, **kargs) + + + def _dump_document(self, **kargs): + import pyx + d = pyx.document.document() + l = len(self.res) + for i in range(len(self.res)): + elt = self.res[i] + c = self._elt2pkt(elt).canvas_dump(**kargs) + cbb = c.bbox() + c.text(cbb.left(),cbb.top()+1,r"\font\cmssfont=cmss12\cmssfont{Frame %i/%i}" % (i,l),[pyx.text.size.LARGE]) + if conf.verb >= 2: + os.write(1,b".") + d.append(pyx.document.page(c, paperformat=pyx.document.paperformat.A4, + margin=1*pyx.unit.t_cm, + fittosize=1)) + return d + + + + def psdump(self, filename = None, **kargs): + """Creates a multipage poscript file with a psdump of every packet + filename: name of the file to write to. If empty, a temporary file is used and + conf.prog.psreader is called""" + d = self._dump_document(**kargs) + if filename is None: + filename = get_temp_file(autoext=".ps") + d.writePSfile(filename) + subprocess.Popen([conf.prog.psreader, filename+".ps"]) + else: + d.writePSfile(filename) + print + + def pdfdump(self, filename = None, **kargs): + """Creates a PDF file with a psdump of every packet + filename: name of the file to write to. If empty, a temporary file is used and + conf.prog.pdfreader is called""" + d = self._dump_document(**kargs) + if filename is None: + filename = get_temp_file(autoext=".pdf") + d.writePDFfile(filename) + subprocess.Popen([conf.prog.pdfreader, filename+".pdf"]) + else: + d.writePDFfile(filename) + print + + def sr(self,multi=0): + """sr([multi=1]) -> (SndRcvList, PacketList) + Matches packets in the list and return ( (matched couples), (unmatched packets) )""" + remain = self.res[:] + sr = [] + i = 0 + while i < len(remain): + s = remain[i] + j = i + while j < len(remain)-1: + j += 1 + r = remain[j] + if r.answers(s): + sr.append((s,r)) + if multi: + remain[i]._answered=1 + remain[j]._answered=2 + continue + del(remain[j]) + del(remain[i]) + i -= 1 + break + i += 1 + if multi: + remain = filter(lambda x:not hasattr(x,"_answered"), remain) + return SndRcvList(sr),PacketList(remain) + + def sessions(self, session_extractor=None): + if session_extractor is None: + def session_extractor(p): + sess = "Other" + if 'Ether' in p: + if 'IP' in p: + if 'TCP' in p: + sess = p.sprintf("TCP %IP.src%:%r,TCP.sport% > %IP.dst%:%r,TCP.dport%") + elif 'UDP' in p: + sess = p.sprintf("UDP %IP.src%:%r,UDP.sport% > %IP.dst%:%r,UDP.dport%") + elif 'ICMP' in p: + sess = p.sprintf("ICMP %IP.src% > %IP.dst% type=%r,ICMP.type% code=%r,ICMP.code% id=%ICMP.id%") + else: + sess = p.sprintf("IP %IP.src% > %IP.dst% proto=%IP.proto%") + elif 'ARP' in p: + sess = p.sprintf("ARP %ARP.psrc% > %ARP.pdst%") + else: + sess = p.sprintf("Ethernet type=%04xr,Ether.type%") + return sess + sessions = defaultdict(self.__class__) + for p in self.res: + sess = session_extractor(self._elt2pkt(p)) + sessions[sess].append(p) + return dict(sessions) + + def replace(self, *args, **kargs): + """ + lst.replace(<field>,[<oldvalue>,]<newvalue>) + lst.replace( (fld,[ov],nv),(fld,[ov,]nv),...) + if ov is None, all values are replaced + ex: + lst.replace( IP.src, "192.168.1.1", "10.0.0.1" ) + lst.replace( IP.ttl, 64 ) + lst.replace( (IP.ttl, 64), (TCP.sport, 666, 777), ) + """ + delete_checksums = kargs.get("delete_checksums",False) + x=PacketList(name="Replaced %s" % self.listname) + if type(args[0]) is not tuple: + args = (args,) + for p in self.res: + p = self._elt2pkt(p) + copied = False + for scheme in args: + fld = scheme[0] + old = scheme[1] # not used if len(scheme) == 2 + new = scheme[-1] + for o in fld.owners: + if o in p: + if len(scheme) == 2 or p[o].getfieldval(fld.name) == old: + if not copied: + p = p.copy() + if delete_checksums: + p.delete_checksums() + copied = True + setattr(p[o], fld.name, new) + x.append(p) + return x + + +class SndRcvList(PacketList): + def __init__(self, res=None, name="Results", stats=None): + PacketList.__init__(self, res, name, stats, vector_index = 1) + def summary(self, prn=None, lfilter=None): + """prints a summary of each SndRcv packet pair +prn: function to apply to each packet pair instead of lambda s, r: "%s ==> %s" % (s.summary(),r.summary()) +lfilter: truth function to apply to each packet pair to decide whether it will be displayed""" + for s, r in self.res: + if lfilter is not None: + if not lfilter(s, r): + continue + if prn is None: + print(self._elt2sum((s, r))) + else: + print(prn(s, r)) + def nsummary(self,prn=None, lfilter=None): + """prints a summary of each SndRcv packet pair with the pair's number +prn: function to apply to each packet pair instead of lambda s, r: "%s ==> %s" % (s.summary(),r.summary()) +lfilter: truth function to apply to each packet pair to decide whether it will be displayed""" + for i, (s, r) in enumerate(self.res): + if lfilter is not None: + if not lfilter(s, r): + continue + print(conf.color_theme.id(i,fmt="%04i"), end = " ") + if prn is None: + print(self._elt2sum((s, r))) + else: + print(prn(s, r)) + def filter(self, func): + """Returns a SndRcv list filtered by a truth function""" + return self.__class__( [ i for i in self.res if func(*i) ], name='filtered %s'%self.listname) + + def make_table(self, *args, **kargs): + """Prints a table using a function that returs for each packet its head column value, head row value and displayed value + ex: p.make_table(lambda s, r:(s[IP].dst, r[TCP].sport, s[TCP].sprintf("%flags%")) """ + return make_table(self.res, *args, **kargs) + def make_lined_table(self, *args, **kargs): + """Same as make_table, but print a table with lines""" + return make_lined_table(self.res, *args, **kargs) + def make_tex_table(self, *args, **kargs): + """Same as make_table, but print a table with LaTeX syntax""" + return make_tex_table(self.res, *args, **kargs) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/pton_ntop.py b/scripts/external_libs/scapy-python3-0.18/scapy/pton_ntop.py new file mode 100644 index 00000000..1629edee --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/pton_ntop.py @@ -0,0 +1,90 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Convert IPv6 addresses between textual representation and binary. + +These functions are missing when python is compiled +without IPv6 support, on Windows for instance. +""" + +import socket,struct + +def inet_pton(af, addr): + """Convert an IP address from text representation into binary form""" + print('hello') + if af == socket.AF_INET: + return inet_aton(addr) + elif af == socket.AF_INET6: + # IPv6: The use of "::" indicates one or more groups of 16 bits of zeros. + # We deal with this form of wildcard using a special marker. + JOKER = b"*" + while b"::" in addr: + addr = addr.replace(b"::", b":" + JOKER + b":") + joker_pos = None + + # The last part of an IPv6 address can be an IPv4 address + ipv4_addr = None + if b"." in addr: + ipv4_addr = addr.split(b":")[-1] + + result = b"" + parts = addr.split(b":") + for part in parts: + if part == JOKER: + # Wildcard is only allowed once + if joker_pos is None: + joker_pos = len(result) + else: + raise Exception("Illegal syntax for IP address") + elif part == ipv4_addr: # FIXME: Make sure IPv4 can only be last part + # FIXME: inet_aton allows IPv4 addresses with less than 4 octets + result += socket.inet_aton(ipv4_addr) + else: + # Each part must be 16bit. Add missing zeroes before decoding. + try: + result += part.rjust(4, b"0").decode("hex") + except TypeError: + raise Exception("Illegal syntax for IP address") + + # If there's a wildcard, fill up with zeros to reach 128bit (16 bytes) + if JOKER in addr: + result = (result[:joker_pos] + b"\x00" * (16 - len(result)) + + result[joker_pos:]) + + if len(result) != 16: + raise Exception("Illegal syntax for IP address") + return result + else: + raise Exception("Address family not supported") + + +def inet_ntop(af, addr): + """Convert an IP address from binary form into text represenation""" + if af == socket.AF_INET: + return inet_ntoa(addr) + elif af == socket.AF_INET6: + # IPv6 addresses have 128bits (16 bytes) + if len(addr) != 16: + raise Exception("Illegal syntax for IP address") + parts = [] + for left in [0, 2, 4, 6, 8, 10, 12, 14]: + try: + value = struct.unpack("!H", addr[left:left+2])[0] + hexstr = hex(value)[2:] + except TypeError: + raise Exception("Illegal syntax for IP address") + parts.append(hexstr.lstrip("0").lower()) + result = b":".join(parts) + while b":::" in result: + result = result.replace(b":::", b"::") + # Leaving out leading and trailing zeros is only allowed with :: + if result.endswith(b":") and not result.endswith(b"::"): + result = result + b"0" + if result.startswith(b":") and not result.startswith(b"::"): + result = b"0" + result + return result + else: + raise Exception("Address family not supported yet") diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/route.py b/scripts/external_libs/scapy-python3-0.18/scapy/route.py new file mode 100644 index 00000000..bccc43a2 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/route.py @@ -0,0 +1,175 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Routing and handling of network interfaces. +""" + +import socket +from scapy.arch import read_routes,get_if_addr,LOOPBACK_NAME +from scapy.utils import atol,ltoa,itom +from scapy.config import conf +from scapy.error import Scapy_Exception,warning + +############################## +## Routing/Interfaces stuff ## +############################## + +class Route: + def __init__(self): + self.resync() + self.s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + self.cache = {} + + def invalidate_cache(self): + self.cache = {} + + def resync(self): + self.invalidate_cache() + self.routes = read_routes() + + def __repr__(self): + rt = "Network Netmask Gateway Iface Output IP\n" + for net,msk,gw,iface,addr in self.routes: + rt += "%-15s %-15s %-15s %-15s %-15s\n" % (ltoa(net), + ltoa(msk), + gw, + iface, + addr) + return rt + + def make_route(self, host=None, net=None, gw=None, dev=None): + if host is not None: + thenet,msk = host,32 + elif net is not None: + thenet,msk = net.split("/") + msk = int(msk) + else: + raise Scapy_Exception("make_route: Incorrect parameters. You should specify a host or a net") + if gw is None: + gw="0.0.0.0" + if dev is None: + if gw: + nhop = gw + else: + nhop = thenet + dev,ifaddr,x = self.route(nhop) + else: + ifaddr = get_if_addr(dev) + return (atol(thenet), itom(msk), gw, dev, ifaddr) + + def add(self, *args, **kargs): + """Ex: + add(net="192.168.1.0/24",gw="1.2.3.4") + """ + self.invalidate_cache() + self.routes.append(self.make_route(*args,**kargs)) + + + def delt(self, *args, **kargs): + """delt(host|net, gw|dev)""" + self.invalidate_cache() + route = self.make_route(*args,**kargs) + try: + i=self.routes.index(route) + del(self.routes[i]) + except ValueError: + warning("no matching route found") + + def ifchange(self, iff, addr): + self.invalidate_cache() + the_addr,the_msk = (addr.split("/")+["32"])[:2] + the_msk = itom(int(the_msk)) + the_rawaddr = atol(the_addr) + the_net = the_rawaddr & the_msk + + + for i in range(len(self.routes)): + net,msk,gw,iface,addr = self.routes[i] + if iface != iff: + continue + if gw == '0.0.0.0': + self.routes[i] = (the_net,the_msk,gw,iface,the_addr) + else: + self.routes[i] = (net,msk,gw,iface,the_addr) + conf.netcache.flush() + + + + def ifdel(self, iff): + self.invalidate_cache() + new_routes=[] + for rt in self.routes: + if rt[3] != iff: + new_routes.append(rt) + self.routes=new_routes + + def ifadd(self, iff, addr): + self.invalidate_cache() + the_addr,the_msk = (addr.split("/")+["32"])[:2] + the_msk = itom(int(the_msk)) + the_rawaddr = atol(the_addr) + the_net = the_rawaddr & the_msk + self.routes.append((the_net,the_msk,'0.0.0.0',iff,the_addr)) + + + def route(self,dest,verbose=None): + if type(dest) is list and dest: + dest = dest[0] + if dest in self.cache: + return self.cache[dest] + if verbose is None: + verbose=conf.verb + # Transform "192.168.*.1-5" to one IP of the set + dst = dest.split("/")[0] + dst = dst.replace("*","0") + while True: + l = dst.find("-") + if l < 0: + break + m = (dst[l:]+".").find(".") + dst = dst[:l]+dst[l+m:] + + + dst = atol(dst) + pathes=[] + for d,m,gw,i,a in self.routes: + aa = atol(a) + #Commented out after issue with virtual network with local address 0.0.0.0 + #if aa == dst: + # pathes.append((0xffffffff,(LOOPBACK_NAME,a,"0.0.0.0"))) + if (dst & m) == (d & m): + pathes.append((m,(i,a,gw))) + if not pathes: + if verbose: + warning("No route found (no default route?)") + return LOOPBACK_NAME,"0.0.0.0","0.0.0.0" #XXX linux specific! + # Choose the more specific route (greatest netmask). + # XXX: we don't care about metrics + pathes.sort() + ret = pathes[-1][1] + self.cache[dest] = ret + return ret + + def get_if_bcast(self, iff): + for net, msk, gw, iface, addr in self.routes: + if (iff == iface and net != 0): + bcast = atol(addr)|(~msk&0xffffffff); # FIXME: check error in atol() + return ltoa(bcast); + warning("No broadcast address found for iface %s\n" % iff); + +#conf.route=Route() + +conf.route=None; +_betteriface = None + + + +#XXX use "with" +#_betteriface = conf.route.route("0.0.0.0", verbose=0)[0] + +if _betteriface != LOOPBACK_NAME: + conf.iface = _betteriface +del(_betteriface) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/route6.py b/scripts/external_libs/scapy-python3-0.18/scapy/route6.py new file mode 100644 index 00000000..44a66735 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/route6.py @@ -0,0 +1,288 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +## Copyright (C) 2005 Guillaume Valadon <guedou@hongo.wide.ad.jp> +## Arnaud Ebalard <arnaud.ebalard@eads.net> + +""" +Routing and network interface handling for IPv6. +""" + +############################################################################# +############################################################################# +### Routing/Interfaces stuff ### +############################################################################# +############################################################################# + +import socket +from .config import conf +from .utils6 import * +from .arch import * + + +class Route6: + + def __init__(self): + self.invalidate_cache() + self.resync() + + def invalidate_cache(self): + self.cache = {} + + def flush(self): + self.invalidate_cache() + self.routes = [] + + def resync(self): + # TODO : At the moment, resync will drop existing Teredo routes + # if any. Change that ... + self.invalidate_cache() + self.routes = read_routes6() + if self.routes == []: + log_loading.info("No IPv6 support in kernel") + + def __repr__(self): + rtlst = [('Destination', 'Next Hop', "iface", "src candidates")] + + for net,msk,gw,iface,cset in self.routes: + rtlst.append(('%s/%i'% (net,msk), gw, iface, ", ".join(cset))) + + #colwidth = map(lambda x: max(map(lambda y: len(y), x)), apply(zip, rtlst)) + rtlst = zip(rtlst) + colwidth = [ max([len(y) for y in x]) for x in rtlst] + fmt = " ".join(map(lambda x: "%%-%ds"%x, colwidth)) + rt = "\n".join([ fmt % x for x in rtlst]) + + return rt + + + # Unlike Scapy's Route.make_route() function, we do not have 'host' and 'net' + # parameters. We only have a 'dst' parameter that accepts 'prefix' and + # 'prefix/prefixlen' values. + # WARNING: Providing a specific device will at the moment not work correctly. + def make_route(self, dst, gw=None, dev=None): + """Internal function : create a route for 'dst' via 'gw'. + """ + prefix, plen = (dst.split("/")+["128"])[:2] + plen = int(plen) + + if gw is None: + gw = "::" + if dev is None: + dev, ifaddr, x = self.route(gw) + else: + # TODO: do better than that + # replace that unique address by the list of all addresses + lifaddr = in6_getifaddr() + #filter(lambda x: x[2] == dev, lifaddr) + devaddrs = [ i for i in lifaddr if i[2] == dev] + ifaddr = construct_source_candidate_set(prefix, plen, devaddrs, LOOPBACK_NAME) + + return (prefix, plen, gw, dev, ifaddr) + + + def add(self, *args, **kargs): + """Ex: + add(dst="2001:db8:cafe:f000::/56") + add(dst="2001:db8:cafe:f000::/56", gw="2001:db8:cafe::1") + add(dst="2001:db8:cafe:f000::/64", gw="2001:db8:cafe::1", dev="eth0") + """ + self.invalidate_cache() + self.routes.append(self.make_route(*args, **kargs)) + + + def delt(self, dst, gw=None): + """ Ex: + delt(dst="::/0") + delt(dst="2001:db8:cafe:f000::/56") + delt(dst="2001:db8:cafe:f000::/56", gw="2001:db8:deca::1") + """ + tmp = dst+b"/128" + dst, plen = tmp.split(b'/')[:2] + dst = in6_ptop(dst) + plen = int(plen) + #l = filter(lambda x: in6_ptop(x[0]) == dst and x[1] == plen, self.routes) + l = [ x for x in self.routes if in6_ptop(x[0]) == dst and x[1] == plen ] + if gw: + gw = in6_ptop(gw) + #l = filter(lambda x: in6_ptop(x[0]) == gw, self.routes) + l = [ x for x in self.routes if in6_ptop(x[0]) == gw ] + if len(l) == 0: + warning("No matching route found") + elif len(l) > 1: + warning("Found more than one match. Aborting.") + else: + i=self.routes.index(l[0]) + self.invalidate_cache() + del(self.routes[i]) + + def ifchange(self, iff, addr): + the_addr, the_plen = (addr.split("/")+["128"])[:2] + the_plen = int(the_plen) + + naddr = inet_pton(socket.AF_INET6, the_addr) + nmask = in6_cidr2mask(the_plen) + the_net = inet_ntop(socket.AF_INET6, in6_and(nmask,naddr)) + + for i in range(len(self.routes)): + net,plen,gw,iface,addr = self.routes[i] + if iface != iff: + continue + if gw == '::': + self.routes[i] = (the_net,the_plen,gw,iface,the_addr) + else: + self.routes[i] = (net,the_plen,gw,iface,the_addr) + self.invalidate_cache() + ip6_neigh_cache.flush() + + def ifdel(self, iff): + """ removes all route entries that uses 'iff' interface. """ + new_routes=[] + for rt in self.routes: + if rt[3] != iff: + new_routes.append(rt) + self.invalidate_cache() + self.routes = new_routes + + + def ifadd(self, iff, addr): + """ + Add an interface 'iff' with provided address into routing table. + + Ex: ifadd('eth0', '2001:bd8:cafe:1::1/64') will add following entry into + Scapy6 internal routing table: + + Destination Next Hop iface Def src @ + 2001:bd8:cafe:1::/64 :: eth0 2001:bd8:cafe:1::1 + + prefix length value can be omitted. In that case, a value of 128 + will be used. + """ + addr, plen = (addr.split(b"/")+[b"128"])[:2] + addr = in6_ptop(addr) + plen = int(plen) + naddr = inet_pton(socket.AF_INET6, addr) + nmask = in6_cidr2mask(plen) + prefix = inet_ntop(socket.AF_INET6, in6_and(nmask,naddr)) + self.invalidate_cache() + self.routes.append((prefix,plen,'::',iff,[addr])) + + def route(self, dst, dev=None): + """ + Provide best route to IPv6 destination address, based on Scapy6 + internal routing table content. + + When a set of address is passed (e.g. 2001:db8:cafe:*::1-5) an address + of the set is used. Be aware of that behavior when using wildcards in + upper parts of addresses ! + + If 'dst' parameter is a FQDN, name resolution is performed and result + is used. + + if optional 'dev' parameter is provided a specific interface, filtering + is performed to limit search to route associated to that interface. + """ + # Transform "2001:db8:cafe:*::1-5:0/120" to one IPv6 address of the set + dst = dst.split("/")[0] + savedst = dst # In case following inet_pton() fails + dst = dst.replace("*","0") + l = dst.find("-") + while l >= 0: + m = (dst[l:]+":").find(":") + dst = dst[:l]+dst[l+m:] + l = dst.find("-") + + try: + inet_pton(socket.AF_INET6, dst) + except socket.error: + dst = socket.getaddrinfo(savedst, None, socket.AF_INET6)[0][-1][0] + # TODO : Check if name resolution went well + + # Deal with dev-specific request for cache search + k = dst + if dev is not None: + k = dst + "%%" + dev + if k in self.cache: + return self.cache[k] + + pathes = [] + + # TODO : review all kinds of addresses (scope and *cast) to see + # if we are able to cope with everything possible. I'm convinced + # it's not the case. + # -- arnaud + for p, plen, gw, iface, cset in self.routes: + if dev is not None and iface != dev: + continue + if in6_isincluded(dst, p, plen): + pathes.append((plen, (iface, cset, gw))) + elif (in6_ismlladdr(dst) and in6_islladdr(p) and in6_islladdr(cset[0])): + pathes.append((plen, (iface, cset, gw))) + + if not pathes: + warning("No route found for IPv6 destination %s (no default route?). This affects only IPv6" % dst) + return (LOOPBACK_NAME, "::", "::") # XXX Linux specific + + # Sort with longest prefix first + pathes.sort(reverse=True) + + best_plen = pathes[0][0] + pathes = filter(lambda x: x[0] == best_plen, pathes) + + res = [] + for p in pathes: # Here we select best source address for every route + tmp = p[1] + srcaddr = get_source_addr_from_candidate_set(dst, p[1][1]) + if srcaddr is not None: + res.append((p[0], (tmp[0], srcaddr, tmp[2]))) + + if res == []: + warning("Found a route for IPv6 destination '%s', but no possible source address. This affects only IPv6" % dst) + return (LOOPBACK_NAME, b"::", b"::") # XXX Linux specific + + # Symptom : 2 routes with same weight (our weight is plen) + # Solution : + # - dst is unicast global. Check if it is 6to4 and we have a source + # 6to4 address in those available + # - dst is link local (unicast or multicast) and multiple output + # interfaces are available. Take main one (conf.iface6) + # - if none of the previous or ambiguity persists, be lazy and keep + # first one + # XXX TODO : in a _near_ future, include metric in the game + + if len(res) > 1: + tmp = [] + if in6_isgladdr(dst) and in6_isaddr6to4(dst): + # TODO : see if taking the longest match between dst and + # every source addresses would provide better results + #tmp = filter(lambda x: in6_isaddr6to4(x[1][1]), res) + tmp = [ x for x in res if in6_isaddr6to4(x[1][1]) ] + elif in6_ismaddr(dst) or in6_islladdr(dst): + # TODO : I'm sure we are not covering all addresses. Check that + #tmp = filter(lambda x: x[1][0] == conf.iface6, res) + tmp = [ x for x in res if x[1][0] == conf.iface6 ] + + if tmp: + res = tmp + + # Fill the cache (including dev-specific request) + k = dst + if dev is not None: + k = dst + "%%" + dev + self.cache[k] = res[0][1] + + return res[0][1] + +conf.route6 = Route6() + +#TBD-hhaim no need for that +#_res = conf.route6.route("::/0") +_res = None; + +if _res: + iff, gw, addr = _res + conf.iface6 = iff +del(_res) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/scapypipes.py b/scripts/external_libs/scapy-python3-0.18/scapy/scapypipes.py new file mode 100644 index 00000000..aa67277e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/scapypipes.py @@ -0,0 +1,123 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +from .pipetool import Source,Drain,Sink +from .config import conf + + +class SniffSource(Source): + """Read packets from an interface and send them to low exit. + +-----------+ + >>-| |->> + | | + >-| [iface]--|-> + +-----------+ +""" + def __init__(self, iface=None, filter=None, name=None): + Source.__init__(self, name=name) + self.iface = iface + self.filter = filter + def start(self): + self.s = conf.L2listen(iface=self.iface, filter=self.filter) + def stop(self): + self.s.close() + def fileno(self): + return self.s.fileno() + def deliver(self): + self._send(self.s.recv()) + +class RdpcapSource(Source): + """Read packets from a PCAP file send them to low exit. + +----------+ + >>-| |->> + | | + >-| [pcap]--|-> + +----------+ +""" + def __init__(self, fname, name=None): + Source.__init__(self, name=name) + self.fname = fname + self.f = PcapReader(self.fname) + def start(self): + print("start") + self.f = PcapReader(self.fname) + self.is_exhausted = False + def stop(self): + print("stop") + self.f.close() + def fileno(self): + return self.f.fileno() + def deliver(self): + p = self.f.recv() + print("deliver %r" % p) + if p is None: + self.is_exhausted = True + else: + self._send(p) + + +class InjectSink(Sink): + """Packets received on low input are injected to an interface + +-----------+ + >>-| |->> + | | + >-|--[iface] |-> + +-----------+ +""" + def __init__(self, iface=None, name=None): + Sink.__init__(self, name=name) + if iface == None: + iface = conf.iface + self.iface = iface + def start(self): + self.s = conf.L2socket(iface=self.iface) + def stop(self): + self.s.close() + def push(self, msg): + self.s.send(msg) + +class Inject3Sink(InjectSink): + def start(self): + self.s = conf.L3socket(iface=self.iface) + + +class WrpcapSink(Sink): + """Packets received on low input are written to PCA file + +----------+ + >>-| |->> + | | + >-|--[pcap] |-> + +----------+ +""" + def __init__(self, fname, name=None): + Sink.__init__(self, name=name) + self.f = PcapWriter(fname) + def stop(self): + self.f.flush() + def push(self, msg): + self.f.write(msg) + + +class UDPDrain(Drain): + """Apply a function to messages on low and high entry + +-------------+ + >>-|--[payload]--|->> + | X | + >-|----[UDP]----|-> + +-------------+ +""" + def __init__(self, ip="127.0.0.1", port=1234): + Drain.__init__(self) + self.ip = ip + self.port = port + + def push(self, msg): + if IP in msg and msg[IP].proto == 17 and UDP in msg: + payload = msg[UDP].payload + self._high_send(str(payload)) + def high_push(self, msg): + p = IP(dst=self.ip)/UDP(sport=1234,dport=self.port)/msg + self._send(p) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/sendrecv.py b/scripts/external_libs/scapy-python3-0.18/scapy/sendrecv.py new file mode 100644 index 00000000..8649c14d --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/sendrecv.py @@ -0,0 +1,678 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Functions to send and receive packets. +""" + +import pickle,os,sys,time,subprocess,itertools +from select import select +from .data import * +import scapy.arch +from .config import conf +from .packet import Gen +from .utils import warning,get_temp_file,PcapReader,wrpcap +from . import plist +from .error import log_runtime,log_interactive +from .base_classes import SetGen + +################# +## Debug class ## +################# + +class debug: + recv=[] + sent=[] + match=[] + + +#################### +## Send / Receive ## +#################### + + + + +def sndrcv(pks, pkt, timeout = None, inter = 0, verbose=None, chainCC=0, retry=0, multi=0): + if not isinstance(pkt, Gen): + pkt = SetGen(pkt) + + if verbose is None: + verbose = conf.verb + debug.recv = plist.PacketList([],"Unanswered") + debug.sent = plist.PacketList([],"Sent") + debug.match = plist.SndRcvList([]) + nbrecv=0 + ans = [] + # do it here to fix random fields, so that parent and child have the same + all_stimuli = tobesent = [p for p in pkt] + notans = len(tobesent) + + hsent={} + for i in tobesent: + h = i.hashret() + if h in hsent: + hsent[h].append(i) + else: + hsent[h] = [i] + if retry < 0: + retry = -retry + autostop=retry + else: + autostop=0 + + + while retry >= 0: + found=0 + + if timeout < 0: + timeout = None + + rdpipe,wrpipe = os.pipe() + rdpipe=os.fdopen(rdpipe, "rb") + wrpipe=os.fdopen(wrpipe,"wb") + + pid=1 + try: + pid = os.fork() + if pid == 0: + try: + sys.stdin.close() + rdpipe.close() + try: + i = 0 + if verbose: + print("Begin emission:") + for p in tobesent: + pks.send(p) + i += 1 + time.sleep(inter) + if verbose: + print("Finished to send %i packets." % i) + except SystemExit: + pass + except KeyboardInterrupt: + pass + except: + log_runtime.exception("--- Error in child %i" % os.getpid()) + log_runtime.info("--- Error in child %i" % os.getpid()) + finally: + try: + os.setpgrp() # Chance process group to avoid ctrl-C + sent_times = [p.sent_time for p in all_stimuli if p.sent_time] + pickle.dump( (conf.netcache,sent_times), wrpipe ) + wrpipe.close() + except: + pass + elif pid < 0: + log_runtime.error("fork error") + else: + wrpipe.close() + stoptime = 0 + remaintime = None + inmask = [rdpipe,pks] + try: + try: + while 1: + if stoptime: + remaintime = stoptime-time.time() + if remaintime <= 0: + break + r = None + if scapy.arch.FREEBSD or scapy.arch.DARWIN: + inp, out, err = select(inmask,[],[], 0.05) + if len(inp) == 0 or pks in inp: + r = pks.nonblock_recv() + else: + inp, out, err = select(inmask,[],[], remaintime) + if len(inp) == 0: + break + if pks in inp: + r = pks.recv(MTU) + if rdpipe in inp: + if timeout: + stoptime = time.time()+timeout + del(inmask[inmask.index(rdpipe)]) + if r is None: + continue + ok = 0 + h = r.hashret() + if h in hsent: + hlst = hsent[h] + for i in range(len(hlst)): + if r.answers(hlst[i]): + ans.append((hlst[i],r)) + if verbose > 1: + os.write(1, b"*") + ok = 1 + if not multi: + del(hlst[i]) + notans -= 1; + else: + if not hasattr(hlst[i], '_answered'): + notans -= 1; + hlst[i]._answered = 1; + break + if notans == 0 and not multi: + break + if not ok: + if verbose > 1: + os.write(1, b".") + nbrecv += 1 + if conf.debug_match: + debug.recv.append(r) + except KeyboardInterrupt: + if chainCC: + raise + finally: + try: + nc,sent_times = pickle.load(rdpipe) + except EOFError: + warning("Child died unexpectedly. Packets may have not been sent %i"%os.getpid()) + else: + conf.netcache.update(nc) + for p,t in zip(all_stimuli, sent_times): + p.sent_time = t + os.waitpid(pid,0) + finally: + if pid == 0: + os._exit(0) + + #remain = reduce(list.__add__, hsent.values(), []) + remain = list(itertools.chain(*[ i for i in hsent.values() ])) + if multi: + #remain = filter(lambda p: not hasattr(p, '_answered'), remain); + remain = [ p for p in remain if not hasattr(p, '_answered')] + + if autostop and len(remain) > 0 and len(remain) != len(tobesent): + retry = autostop + + tobesent = remain + if len(tobesent) == 0: + break + retry -= 1 + + if conf.debug_match: + debug.sent=plist.PacketList(remain[:],"Sent") + debug.match=plist.SndRcvList(ans[:]) + + #clean the ans list to delete the field _answered + if (multi): + for s,r in ans: + if hasattr(s, '_answered'): + del(s._answered) + + if verbose: + print("\nReceived %i packets, got %i answers, remaining %i packets" % (nbrecv+len(ans), len(ans), notans)) + return plist.SndRcvList(ans),plist.PacketList(remain,"Unanswered") + + +def __gen_send(s, x, inter=0, loop=0, count=None, verbose=None, realtime=None, *args, **kargs): + if type(x) is bytes: + x = conf.raw_layer(load=x) + if type(x) is str: + x = conf.raw_layer(load=x.encode('ascii')) + if not isinstance(x, Gen): + x = SetGen(x) + if verbose is None: + verbose = conf.verb + n = 0 + if count is not None: + loop = -count + elif not loop: + loop=-1 + try: + while loop: + dt0 = None + for p in x: + if realtime: + ct = time.time() + if dt0: + st = dt0+p.time-ct + if st > 0: + time.sleep(st) + else: + dt0 = ct-p.time + s.send(p) + n += 1 + if verbose: + os.write(1,b".") + time.sleep(inter) + if loop < 0: + loop += 1 + except KeyboardInterrupt: + pass + s.close() + if verbose: + print("\nSent %i packets." % n) + +@conf.commands.register +def send(x, inter=0, loop=0, count=None, verbose=None, realtime=None, *args, **kargs): + """Send packets at layer 3 +send(packets, [inter=0], [loop=0], [verbose=conf.verb]) -> None""" + __gen_send(conf.L3socket(*args, **kargs), x, inter=inter, loop=loop, count=count,verbose=verbose, realtime=realtime) + +@conf.commands.register +def sendp(x, inter=0, loop=0, iface=None, iface_hint=None, count=None, verbose=None, realtime=None, *args, **kargs): + """Send packets at layer 2 +sendp(packets, [inter=0], [loop=0], [verbose=conf.verb]) -> None""" + if iface is None and iface_hint is not None: + iface = conf.route.route(iface_hint)[0] + __gen_send(conf.L2socket(iface=iface, *args, **kargs), x, inter=inter, loop=loop, count=count, verbose=verbose, realtime=realtime) + +@conf.commands.register +def sendpfast(x, pps=None, mbps=None, realtime=None, loop=0, file_cache=False, iface=None, verbose=True): + """Send packets at layer 2 using tcpreplay for performance + pps: packets per second + mpbs: MBits per second + realtime: use packet's timestamp, bending time with realtime value + loop: number of times to process the packet list + file_cache: cache packets in RAM instead of reading from disk at each iteration + iface: output interface + verbose: if False, discard tcpreplay output """ + if iface is None: + iface = conf.iface + argv = [conf.prog.tcpreplay, "--intf1=%s" % iface ] + if pps is not None: + argv.append("--pps=%i" % pps) + elif mbps is not None: + argv.append("--mbps=%f" % mbps) + elif realtime is not None: + argv.append("--multiplier=%i" % realtime) + else: + argv.append("--topspeed") + if not verbose: + argv.append("-q") + if loop: + argv.append("--loop=%i" % loop) + if file_cache: + argv.append("--enable-file-cache") + + f = get_temp_file() + argv.append(f) + wrpcap(f, x) + with open(os.devnull, "wb") as null: + proc_output = null if not verbose else None + try: + subprocess.check_call(argv, + stdout=proc_output, + stderr=proc_output) + except KeyboardInterrupt: + log_interactive.info("Interrupted by user") + except Exception as e: + log_interactive.error("while trying to exec [%s]: %s" % (argv[0],e)) + finally: + os.unlink(f) + + + + + +@conf.commands.register +def sr(x,filter=None, iface=None, nofilter=0, *args,**kargs): + """Send and receive packets at layer 3 +nofilter: put 1 to avoid use of bpf filters +retry: if positive, how many times to resend unanswered packets + if negative, how many times to retry when no more packets are answered +timeout: how much time to wait after the last packet has been sent +verbose: set verbosity level +multi: whether to accept multiple answers for the same stimulus +filter: provide a BPF filter +iface: listen answers only on the given interface""" + if not "timeout" in kargs: + kargs["timeout"] = -1 + s = conf.L3socket(filter=filter, iface=iface, nofilter=nofilter) + a,b=sndrcv(s,x,*args,**kargs) + s.close() + return a,b + +@conf.commands.register +def sr1(x,filter=None,iface=None, nofilter=0, *args,**kargs): + """Send packets at layer 3 and return only the first answer +nofilter: put 1 to avoid use of bpf filters +retry: if positive, how many times to resend unanswered packets + if negative, how many times to retry when no more packets are answered +timeout: how much time to wait after the last packet has been sent +verbose: set verbosity level +multi: whether to accept multiple answers for the same stimulus +filter: provide a BPF filter +iface: listen answers only on the given interface""" + if not "timeout" in kargs: + kargs["timeout"] = -1 + s=conf.L3socket(filter=filter, nofilter=nofilter, iface=iface) + a,b=sndrcv(s,x,*args,**kargs) + s.close() + if len(a) > 0: + return a[0][1] + else: + return None + +@conf.commands.register +def srp(x,iface=None, iface_hint=None, filter=None, nofilter=0, type=ETH_P_ALL, *args,**kargs): + """Send and receive packets at layer 2 +nofilter: put 1 to avoid use of bpf filters +retry: if positive, how many times to resend unanswered packets + if negative, how many times to retry when no more packets are answered +timeout: how much time to wait after the last packet has been sent +verbose: set verbosity level +multi: whether to accept multiple answers for the same stimulus +filter: provide a BPF filter +iface: work only on the given interface""" + if not "timeout" in kargs: + kargs["timeout"] = -1 + if iface is None and iface_hint is not None: + iface = conf.route.route(iface_hint)[0] + s = conf.L2socket(iface=iface, filter=filter, nofilter=nofilter, type=type) + a,b=sndrcv(s ,x,*args,**kargs) + s.close() + return a,b + +@conf.commands.register +def srp1(*args,**kargs): + """Send and receive packets at layer 2 and return only the first answer +nofilter: put 1 to avoid use of bpf filters +retry: if positive, how many times to resend unanswered packets + if negative, how many times to retry when no more packets are answered +timeout: how much time to wait after the last packet has been sent +verbose: set verbosity level +multi: whether to accept multiple answers for the same stimulus +filter: provide a BPF filter +iface: work only on the given interface""" + if not "timeout" in kargs: + kargs["timeout"] = -1 + a,b=srp(*args,**kargs) + if len(a) > 0: + return a[0][1] + else: + return None + +def __sr_loop(srfunc, pkts, prn=lambda x:x[1].summary(), prnfail=lambda x:x.summary(), inter=1, timeout=None, count=None, verbose=None, store=1, *args, **kargs): + n = 0 + r = 0 + ct = conf.color_theme + if verbose is None: + verbose = conf.verb + parity = 0 + ans=[] + unans=[] + if timeout is None: + timeout = min(2*inter, 5) + try: + while 1: + parity ^= 1 + col = [ct.even,ct.odd][parity] + if count is not None: + if count == 0: + break + count -= 1 + start = time.time() + print("\rsend...\r", end = " ") + res = srfunc(pkts, timeout=timeout, verbose=0, chainCC=1, *args, **kargs) + n += len(res[0])+len(res[1]) + r += len(res[0]) + if verbose > 1 and prn and len(res[0]) > 0: + msg = "RECV %i:" % len(res[0]) + print( "\r"+ct.success(msg), end = " ") + for p in res[0]: + print(col(prn(p))) + print(" "*len(msg), end = " ") + if verbose > 1 and prnfail and len(res[1]) > 0: + msg = "fail %i:" % len(res[1]) + print("\r"+ct.fail(msg), end = " ") + for p in res[1]: + print(col(prnfail(p))) + print(" "*len(msg), end = " ") + if verbose > 1 and not (prn or prnfail): + print("recv:%i fail:%i" % tuple(map(len, res[:2]))) + if store: + ans += res[0] + unans += res[1] + end=time.time() + if end-start < inter: + time.sleep(inter+start-end) + except KeyboardInterrupt: + pass + + if verbose and n>0: + print(ct.normal("\nSent %i packets, received %i packets. %3.1f%% hits." % (n,r,100.0*r/n))) + return plist.SndRcvList(ans),plist.PacketList(unans) + +@conf.commands.register +def srloop(pkts, *args, **kargs): + """Send a packet at layer 3 in loop and print the answer each time +srloop(pkts, [prn], [inter], [count], ...) --> None""" + return __sr_loop(sr, pkts, *args, **kargs) + +@conf.commands.register +def srploop(pkts, *args, **kargs): + """Send a packet at layer 2 in loop and print the answer each time +srloop(pkts, [prn], [inter], [count], ...) --> None""" + return __sr_loop(srp, pkts, *args, **kargs) + + +#def sndrcvflood(pks, pkt, prn=lambda (s,r):r.summary(), chainCC=0, store=1, unique=0): +def sndrcvflood(pks, pkt, prn=lambda a:a[1].summary(), chainCC=0, store=1, unique=0): + if not isinstance(pkt, Gen): + pkt = SetGen(pkt) + tobesent = [p for p in pkt] + received = plist.SndRcvList() + seen = {} + + hsent={} + for i in tobesent: + h = i.hashret() + if h in hsent: + hsent[h].append(i) + else: + hsent[h] = [i] + + def send_in_loop(tobesent): + while 1: + for p in tobesent: + yield p + + packets_to_send = send_in_loop(tobesent) + + ssock = rsock = pks.fileno() + + try: + while 1: + readyr,readys,_ = select([rsock],[ssock],[]) + if ssock in readys: + pks.send(next(packets_to_send)) + + if rsock in readyr: + p = pks.recv(MTU) + if p is None: + continue + h = p.hashret() + if h in hsent: + hlst = hsent[h] + for i in hlst: + if p.answers(i): + res = prn((i,p)) + if unique: + if res in seen: + continue + seen[res] = None + if res is not None: + print(res) + if store: + received.append((i,p)) + except KeyboardInterrupt: + if chainCC: + raise + return received + +@conf.commands.register +def srflood(x,filter=None, iface=None, nofilter=None, *args,**kargs): + """Flood and receive packets at layer 3 +prn: function applied to packets received. Ret val is printed if not None +store: if 1 (default), store answers and return them +unique: only consider packets whose print +nofilter: put 1 to avoid use of bpf filters +filter: provide a BPF filter +iface: listen answers only on the given interface""" + s = conf.L3socket(filter=filter, iface=iface, nofilter=nofilter) + r=sndrcvflood(s,x,*args,**kargs) + s.close() + return r + +@conf.commands.register +def srpflood(x,filter=None, iface=None, iface_hint=None, nofilter=None, *args,**kargs): + """Flood and receive packets at layer 2 +prn: function applied to packets received. Ret val is printed if not None +store: if 1 (default), store answers and return them +unique: only consider packets whose print +nofilter: put 1 to avoid use of bpf filters +filter: provide a BPF filter +iface: listen answers only on the given interface""" + if iface is None and iface_hint is not None: + iface = conf.route.route(iface_hint)[0] + s = conf.L2socket(filter=filter, iface=iface, nofilter=nofilter) + r=sndrcvflood(s,x,*args,**kargs) + s.close() + return r + + + + +@conf.commands.register +def sniff(count=0, store=1, offline=None, prn = None, lfilter=None, L2socket=None, timeout=None, + opened_socket=None, stop_filter=None, *arg, **karg): + """Sniff packets +sniff([count=0,] [prn=None,] [store=1,] [offline=None,] [lfilter=None,] + L2ListenSocket args) -> list of packets + + count: number of packets to capture. 0 means infinity + store: wether to store sniffed packets or discard them + prn: function to apply to each packet. If something is returned, + it is displayed. Ex: + ex: prn = lambda x: x.summary() +lfilter: python function applied to each packet to determine + if further action may be done + ex: lfilter = lambda x: x.haslayer(Padding) +offline: pcap file to read packets from, instead of sniffing them +timeout: stop sniffing after a given time (default: None) +L2socket: use the provided L2socket +opened_socket: provide an object ready to use .recv() on +stop_filter: python function applied to each packet to determine + if we have to stop the capture after this packet + ex: stop_filter = lambda x: x.haslayer(TCP) + """ + c = 0 + + if opened_socket is not None: + s = opened_socket + else: + if offline is None: + if L2socket is None: + L2socket = conf.L2listen + s = L2socket(type=ETH_P_ALL, *arg, **karg) + else: + s = PcapReader(offline) + + lst = [] + if timeout is not None: + stoptime = time.time()+timeout + remain = None + try: + while 1: + if timeout is not None: + remain = stoptime-time.time() + if remain <= 0: + break + sel = select([s],[],[],remain) + if s in sel[0]: + p = s.recv(MTU) + if p is None: + break + if lfilter and not lfilter(p): + continue + if store: + lst.append(p) + c += 1 + if prn: + r = prn(p) + if r is not None: + print(r) + if stop_filter and stop_filter(p): + break + if count > 0 and c >= count: + break + except KeyboardInterrupt: + pass + if opened_socket is None: + s.close() + return plist.PacketList(lst,"Sniffed") + + +@conf.commands.register +def bridge_and_sniff(if1, if2, count=0, store=1, offline=None, prn = None, lfilter=None, L2socket=None, timeout=None, + stop_filter=None, *args, **kargs): + """Forward traffic between two interfaces and sniff packets exchanged +bridge_and_sniff([count=0,] [prn=None,] [store=1,] [offline=None,] [lfilter=None,] + L2Socket args) -> list of packets + + count: number of packets to capture. 0 means infinity + store: wether to store sniffed packets or discard them + prn: function to apply to each packet. If something is returned, + it is displayed. Ex: + ex: prn = lambda x: x.summary() +lfilter: python function applied to each packet to determine + if further action may be done + ex: lfilter = lambda x: x.haslayer(Padding) +timeout: stop sniffing after a given time (default: None) +L2socket: use the provided L2socket +stop_filter: python function applied to each packet to determine + if we have to stop the capture after this packet + ex: stop_filter = lambda x: x.haslayer(TCP) + """ + c = 0 + if L2socket is None: + L2socket = conf.L2socket + s1 = L2socket(iface=if1) + s2 = L2socket(iface=if2) + peerof={s1:s2,s2:s1} + label={s1:if1, s2:if2} + + lst = [] + if timeout is not None: + stoptime = time.time()+timeout + remain = None + try: + while True: + if timeout is not None: + remain = stoptime-time.time() + if remain <= 0: + break + ins,outs,errs = select([s1,s2],[],[], remain) + for s in ins: + p = s.recv() + if p is not None: + peerof[s].send(p.original) + if lfilter and not lfilter(p): + continue + if store: + p.sniffed_on = label[s] + lst.append(p) + c += 1 + if prn: + r = prn(p) + if r is not None: + print("%s: %s" % (label[s],r)) + if stop_filter and stop_filter(p): + break + if count > 0 and c >= count: + break + except KeyboardInterrupt: + pass + finally: + return plist.PacketList(lst,"Sniffed") + + +@conf.commands.register +def tshark(*args,**kargs): + """Sniff packets and print them calling pkt.show(), a bit like text wireshark""" + sniff(prn=lambda x: x.display(),*args,**kargs) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/supersocket.py b/scripts/external_libs/scapy-python3-0.18/scapy/supersocket.py new file mode 100644 index 00000000..b87f9c16 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/supersocket.py @@ -0,0 +1,141 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +SuperSocket. +""" + +import socket,time +from .config import conf +from .data import * +from scapy.error import warning, log_runtime + +class _SuperSocket_metaclass(type): + def __repr__(self): + if self.desc is not None: + return "<%s: %s>" % (self.__name__,self.desc) + else: + return "<%s>" % self.__name__ + + +class SuperSocket(metaclass = _SuperSocket_metaclass): + desc = None + closed=0 + def __init__(self, family=socket.AF_INET,type=socket.SOCK_STREAM, proto=0): + self.ins = socket.socket(family, type, proto) + self.outs = self.ins + self.promisc=None + def send(self, x): + sx = bytes(x) + if hasattr(x, "sent_time"): + x.sent_time = time.time() + return self.outs.send(sx) + def recv(self, x=MTU): + return conf.raw_layer(self.ins.recv(x)) + def fileno(self): + return self.ins.fileno() + def close(self): + if self.closed: + return + self.closed=1 + if self.ins != self.outs: + if self.outs and self.outs.fileno() != -1: + self.outs.close() + if self.ins and self.ins.fileno() != -1: + self.ins.close() + def sr(self, *args, **kargs): + return sendrecv.sndrcv(self, *args, **kargs) + def sr1(self, *args, **kargs): + a,b = sendrecv.sndrcv(self, *args, **kargs) + if len(a) > 0: + return a[0][1] + else: + return None + def sniff(self, *args, **kargs): + return sendrecv.sniff(opened_socket=self, *args, **kargs) + +class L3RawSocket(SuperSocket): + desc = "Layer 3 using Raw sockets (PF_INET/SOCK_RAW)" + def __init__(self, type = ETH_P_IP, filter=None, iface=None, promisc=None, nofilter=0): + self.outs = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_RAW) + self.outs.setsockopt(socket.SOL_IP, socket.IP_HDRINCL, 1) + self.ins = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(type)) + if iface is not None: + self.ins.bind((iface, type)) + def recv(self, x=MTU): + pkt, sa_ll = self.ins.recvfrom(x) + if sa_ll[2] == socket.PACKET_OUTGOING: + return None + if sa_ll[3] in conf.l2types: + cls = conf.l2types[sa_ll[3]] + lvl = 2 + elif sa_ll[1] in conf.l3types: + cls = conf.l3types[sa_ll[1]] + lvl = 3 + else: + cls = conf.default_l2 + warning("Unable to guess type (interface=%s protocol=%#x family=%i). Using %s" % (sa_ll[0],sa_ll[1],sa_ll[3],cls.name)) + lvl = 3 + + try: + pkt = cls(pkt) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + pkt = conf.raw_layer(pkt) + if lvl == 2: + pkt = pkt.payload + + if pkt is not None: + from arch import get_last_packet_timestamp + pkt.time = get_last_packet_timestamp(self.ins) + return pkt + def send(self, x): + try: + #sx = str(x) + sx = x + x.sent_time = time.time() + self.outs.sendto(sx,(x.dst,0)) + except socket.error as msg: + log_runtime.error(msg) + +class SimpleSocket(SuperSocket): + desc = "wrapper arround a classic socket" + def __init__(self, sock): + self.ins = sock + self.outs = sock + + +class StreamSocket(SimpleSocket): + desc = "transforms a stream socket into a layer 2" + def __init__(self, sock, basecls=None): + if basecls is None: + basecls = conf.raw_layer + SimpleSocket.__init__(self, sock) + self.basecls = basecls + + def recv(self, x=MTU): + pkt = self.ins.recv(x, socket.MSG_PEEK) + x = len(pkt) + if x == 0: + raise socket.error((100,"Underlying stream socket tore down")) + pkt = self.basecls(pkt) + pad = pkt.getlayer(conf.padding_layer) + if pad is not None and pad.underlayer is not None: + del(pad.underlayer.payload) + while pad is not None and not isinstance(pad, NoPayload): + x -= len(pad.load) + pad = pad.payload + self.ins.recv(x) + return pkt + + + +if conf.L3socket is None: + conf.L3socket = L3RawSocket + +import scapy.sendrecv diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/themes.py b/scripts/external_libs/scapy-python3-0.18/scapy/themes.py new file mode 100644 index 00000000..f519ad7e --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/themes.py @@ -0,0 +1,277 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Color themes for the interactive console. +""" + +################## +## Color themes ## +################## + +class Color: + normal = "\033[0m" + black = "\033[30m" + red = "\033[31m" + green = "\033[32m" + yellow = "\033[33m" + blue = "\033[34m" + purple = "\033[35m" + cyan = "\033[36m" + grey = "\033[37m" + + bold = "\033[1m" + uline = "\033[4m" + blink = "\033[5m" + invert = "\033[7m" + + +def create_styler(fmt=None, before="", after="", fmt2="%s"): + def do_style(val, fmt=fmt, before=before, after=after, fmt2=fmt2): + if fmt is None: + if type(val) is not str: + val = str(val) + else: + val = fmt % val + return fmt2 % (before+val+after) + return do_style + +class ColorTheme: + def __repr__(self): + return "<%s>" % self.__class__.__name__ + def __getattr__(self, attr): + return create_styler() + + +class NoTheme(ColorTheme): + pass + + +class AnsiColorTheme(ColorTheme): + def __getattr__(self, attr): + if attr.startswith("__"): + raise AttributeError(attr) + s = "style_%s" % attr + if s in self.__class__.__dict__: + before = getattr(self, s) + after = self.style_normal + else: + before = after = "" + + return create_styler(before=before, after=after) + + + style_normal = "" + style_prompt = "" + style_punct = "" + style_id = "" + style_not_printable = "" + style_layer_name = "" + style_field_name = "" + style_field_value = "" + style_emph_field_name = "" + style_emph_field_value = "" + style_packetlist_name = "" + style_packetlist_proto = "" + style_packetlist_value = "" + style_fail = "" + style_success = "" + style_odd = "" + style_even = "" + style_opening = "" + style_active = "" + style_closed = "" + style_left = "" + style_right = "" + +class BlackAndWhite(AnsiColorTheme): + pass + +class DefaultTheme(AnsiColorTheme): + style_normal = Color.normal + style_prompt = Color.blue+Color.bold + style_punct = Color.normal + style_id = Color.blue+Color.bold + style_not_printable = Color.grey + style_layer_name = Color.red+Color.bold + style_field_name = Color.blue + style_field_value = Color.purple + style_emph_field_name = Color.blue+Color.uline+Color.bold + style_emph_field_value = Color.purple+Color.uline+Color.bold + style_packetlist_name = Color.red+Color.bold + style_packetlist_proto = Color.blue + style_packetlist_value = Color.purple + style_fail = Color.red+Color.bold + style_success = Color.blue+Color.bold + style_even = Color.black+Color.bold + style_odd = Color.black + style_opening = Color.yellow + style_active = Color.black + style_closed = Color.grey + style_left = Color.blue+Color.invert + style_right = Color.red+Color.invert + +class BrightTheme(AnsiColorTheme): + style_normal = Color.normal + style_punct = Color.normal + style_id = Color.yellow+Color.bold + style_layer_name = Color.red+Color.bold + style_field_name = Color.yellow+Color.bold + style_field_value = Color.purple+Color.bold + style_emph_field_name = Color.yellow+Color.bold + style_emph_field_value = Color.green+Color.bold + style_packetlist_name = Color.red+Color.bold + style_packetlist_proto = Color.yellow+Color.bold + style_packetlist_value = Color.purple+Color.bold + style_fail = Color.red+Color.bold + style_success = Color.blue+Color.bold + style_even = Color.black+Color.bold + style_odd = Color.black + style_left = Color.cyan+Color.invert + style_right = Color.purple+Color.invert + + +class RastaTheme(AnsiColorTheme): + style_normal = Color.normal+Color.green+Color.bold + style_prompt = Color.yellow+Color.bold + style_punct = Color.red + style_id = Color.green+Color.bold + style_not_printable = Color.green + style_layer_name = Color.red+Color.bold + style_field_name = Color.yellow+Color.bold + style_field_value = Color.green+Color.bold + style_emph_field_name = Color.green + style_emph_field_value = Color.green + style_packetlist_name = Color.red+Color.bold + style_packetlist_proto = Color.yellow+Color.bold + style_packetlist_value = Color.green+Color.bold + style_fail = Color.red + style_success = Color.red+Color.bold + style_even = Color.yellow + style_odd = Color.green + style_left = Color.yellow+Color.invert + style_right = Color.red+Color.invert + +class ColorOnBlackTheme(AnsiColorTheme): + """Color theme for black backgrounds""" + style_normal = Color.normal + style_prompt = Color.green+Color.bold + style_punct = Color.normal + style_id = Color.green + style_not_printable = Color.black+Color.bold + style_layer_name = Color.yellow+Color.bold + style_field_name = Color.cyan + style_field_value = Color.purple+Color.bold + style_emph_field_name = Color.cyan+Color.bold + style_emph_field_value = Color.red+Color.bold + style_packetlist_name = Color.black+Color.bold + style_packetlist_proto = Color.yellow+Color.bold + style_packetlist_value = Color.purple+Color.bold + style_fail = Color.red+Color.bold + style_success = Color.green + style_even = Color.black+Color.bold + style_odd = Color.grey + style_opening = Color.yellow + style_active = Color.grey+Color.bold + style_closed = Color.black+Color.bold + style_left = Color.cyan+Color.bold + style_right = Color.red+Color.bold + + +class FormatTheme(ColorTheme): + def __getattr__(self, attr): + if attr.startswith("__"): + raise AttributeError(attr) + colfmt = self.__class__.__dict__.get("style_%s" % attr, "%s") + return create_styler(fmt2 = colfmt) + +class LatexTheme(FormatTheme): + style_prompt = r"\textcolor{blue}{%s}" + style_not_printable = r"\textcolor{gray}{%s}" + style_layer_name = r"\textcolor{red}{\bf %s}" + style_field_name = r"\textcolor{blue}{%s}" + style_field_value = r"\textcolor{purple}{%s}" + style_emph_field_name = r"\textcolor{blue}{\underline{%s}}" #ul + style_emph_field_value = r"\textcolor{purple}{\underline{%s}}" #ul + style_packetlist_name = r"\textcolor{red}{\bf %s}" + style_packetlist_proto = r"\textcolor{blue}{%s}" + style_packetlist_value = r"\textcolor{purple}{%s}" + style_fail = r"\textcolor{red}{\bf %s}" + style_success = r"\textcolor{blue}{\bf %s}" + style_left = r"\textcolor{blue}{%s}" + style_right = r"\textcolor{red}{%s}" +# style_even = r"}{\bf " +# style_odd = "" + +class LatexTheme2(FormatTheme): + style_prompt = r"@`@textcolor@[@blue@]@@[@%s@]@" + style_not_printable = r"@`@textcolor@[@gray@]@@[@%s@]@" + style_layer_name = r"@`@textcolor@[@red@]@@[@@`@bfseries@[@@]@%s@]@" + style_field_name = r"@`@textcolor@[@blue@]@@[@%s@]@" + style_field_value = r"@`@textcolor@[@purple@]@@[@%s@]@" + style_emph_field_name = r"@`@textcolor@[@blue@]@@[@@`@underline@[@%s@]@@]@" + style_emph_field_value = r"@`@textcolor@[@purple@]@@[@@`@underline@[@%s@]@@]@" + style_packetlist_name = r"@`@textcolor@[@red@]@@[@@`@bfseries@[@@]@%s@]@" + style_packetlist_proto = r"@`@textcolor@[@blue@]@@[@%s@]@" + style_packetlist_value = r"@`@textcolor@[@purple@]@@[@%s@]@" + style_fail = r"@`@textcolor@[@red@]@@[@@`@bfseries@[@@]@%s@]@" + style_success = r"@`@textcolor@[@blue@]@@[@@`@bfserices@[@@]@%s@]@" + style_even = r"@`@textcolor@[@gray@]@@[@@`@bfseries@[@@]@%s@]@" +# style_odd = r"@`@textcolor@[@black@]@@[@@`@bfseries@[@@]@%s@]@" + style_left = r"@`@textcolor@[@blue@]@@[@%s@]@" + style_right = r"@`@textcolor@[@red@]@@[@%s@]@" + +class HTMLTheme(FormatTheme): + style_prompt = "<span class=prompt>%s</span>" + style_not_printable = "<span class=not_printable>%s</span>" + style_layer_name = "<span class=layer_name>%s</span>" + style_field_name = "<span class=field_name>%s</span>" + style_field_value = "<span class=field_value>%s</span>" + style_emph_field_name = "<span class=emph_field_name>%s</span>" + style_emph_field_value = "<span class=emph_field_value>%s</span>" + style_packetlist_name = "<span class=packetlist_name>%s</span>" + style_packetlist_proto = "<span class=packetlist_proto>%s</span>" + style_packetlist_value = "<span class=packetlist_value>%s</span>" + style_fail = "<span class=fail>%s</span>" + style_success = "<span class=success>%s</span>" + style_even = "<span class=even>%s</span>" + style_odd = "<span class=odd>%s</span>" + style_left = "<span class=left>%s</span>" + style_right = "<span class=right>%s</span>" + +class HTMLTheme2(HTMLTheme): + style_prompt = "#[#span class=prompt#]#%s#[#/span#]#" + style_not_printable = "#[#span class=not_printable#]#%s#[#/span#]#" + style_layer_name = "#[#span class=layer_name#]#%s#[#/span#]#" + style_field_name = "#[#span class=field_name#]#%s#[#/span#]#" + style_field_value = "#[#span class=field_value#]#%s#[#/span#]#" + style_emph_field_name = "#[#span class=emph_field_name#]#%s#[#/span#]#" + style_emph_field_value = "#[#span class=emph_field_value#]#%s#[#/span#]#" + style_packetlist_name = "#[#span class=packetlist_name#]#%s#[#/span#]#" + style_packetlist_proto = "#[#span class=packetlist_proto#]#%s#[#/span#]#" + style_packetlist_value = "#[#span class=packetlist_value#]#%s#[#/span#]#" + style_fail = "#[#span class=fail#]#%s#[#/span#]#" + style_success = "#[#span class=success#]#%s#[#/span#]#" + style_even = "#[#span class=even#]#%s#[#/span#]#" + style_odd = "#[#span class=odd#]#%s#[#/span#]#" + style_left = "#[#span class=left#]#%s#[#/span#]#" + style_right = "#[#span class=right#]#%s#[#/span#]#" + + +class ColorPrompt: + __prompt = ">>> " + def __str__(self): + try: + ct = scapy.config.conf.color_theme + if isinstance(ct, AnsiColorTheme): + ## ^A and ^B delimit invisible caracters for readline to count right + return "\001%s\002" % ct.prompt("\002"+scapy.config.conf.prompt+"\001") + else: + return ct.prompt(scapy.config.conf.prompt) + except: + return self.__prompt + + +import scapy.config diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/tools/UTscapy.py b/scripts/external_libs/scapy-python3-0.18/scapy/tools/UTscapy.py new file mode 100644 index 00000000..212aa123 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/tools/UTscapy.py @@ -0,0 +1,677 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Unit testing infrastructure for Scapy +""" + +import sys,getopt,imp +import bz2, base64, os.path, time, traceback, zlib, hashlib + + +#### Import tool #### + +def import_module(name): + name = os.path.realpath(name) + thepath = os.path.dirname(name) + name = os.path.basename(name) + if name.endswith(".py"): + name = name[:-3] + f,path,desc = imp.find_module(name,[thepath]) + + try: + return imp.load_module(name, f, path, desc) + finally: + if f: + f.close() + + +#### INTERNAL/EXTERNAL FILE EMBEDDING #### + +class File: + def __init__(self, name, URL, local): + self.name = name + self.local = local + self.URL = URL + def get_local(self): + return bz2.decompress(base64.decodestring(self.local)) + def get_URL(self): + return URL + def write(self, dir): + if dir: + dir += "/" + open(dir+self.name,"w").write(self.get_local()) + + +# Embed a base64 encoded bziped version of js and css files +# to work if you can't reach Internet. +class External_Files: + UTscapy_js = File("UTscapy.js", "http://www.secdev.org/projects/UTscapy/UTscapy.js", +"""QlpoOTFBWSZTWWVijKQAAXxfgERUYOvAChIhBAC/79+qQAH8AFA0poANAMjQAAAG +ABo0NGEZNBo00BhgAaNDRhGTQaNNAYFURJinplGaKbRkJiekzSenqmpA0Gm1LFMp +RUklVQlK9WUTZYpNFI1IiEWEFT09Sfj5uO+qO6S5DQwKIxM92+Zku94wL6V/1KTK +an2c66Ug6SmVKy1ZIrgauxMVLF5xLH0lJRQuKlqLF10iatlTzqvw7S9eS3+h4lu3 +GZyMgoOude3NJ1pQy8eo+X96IYZw+ynehsiPj73m0rnvQ3QXZ9BJQiZQYQ5/uNcl +2WOlC5vyQqV/BWsnr2NZYLYXQLDs/Bffk4ZfR4/SH6GfA5Xlek4xHNHqbSsRbREO +gueXo3kcYi94K6hSO3ldD2O/qJXOFqJ8o3TE2aQahxtQpCVUKQMvODHwu2YkaORY +ZC6gihEallcHDIAtRPScBACAJnUggYhLDX6DEko7nC9GvAw5OcEkiyDUbLdiGCzD +aXWMC2DuQ2Y6sGf6NcRuON7QSbhHsPc4KKmZ/xdyRThQkGVijKQ=""") + UTscapy_css = File("UTscapy.css","http://www.secdev.org/projects/UTscapy/UTscapy.css", +"""QlpoOTFBWSZTWTbBCNEAAE7fgHxwSB//+Cpj2QC//9/6UAR+63dxbNzO3ccmtGEk +pM0m1I9E/Qp6g9Q09TNQ9QDR6gMgAkiBFG9U9TEGRkGgABoABoBmpJkRAaAxD1AN +Gh6gNADQBzAATJgATCYJhDAEYAEiQkwIyJk0n6qenpqeoaMUeo9RgIxp6pX78kfx +Jx4MUhDHKEb2pJAYAelG1cybiZBBDipH8ocxNyHDAqTUxiQmIAEDE3ApIBUUECAT +7Lvlf4xA/sVK0QHkSlYtT0JmErdOjx1v5NONPYSjrIhQnbl1MbG5m+InMYmVAWJp +uklD9cNdmQv2YigxbEtgUrsY2pDDV/qMT2SHnHsViu2rrp2LA01YJIHZqjYCGIQN +sGNobFxAYHLqqMOj9TI2Y4GRpRCUGu82PnMnXUBgDSkTY4EfmygaqvUwbGMbPwyE +220Q4G+sDvw7+6in3CAOS634pcOEAdREUW+QqMjvWvECrGISo1piv3vqubTGOL1c +ssrFnnSfU4T6KSCbPs98HJ2yjWN4i8Bk5WrM/JmELLNeZ4vgMkA4JVQInNnWTUTe +gmMSlJd/b7JuRwiM5RUzXOBTa0e3spO/rsNJiylu0rCxygdRo2koXdSJzmUVjJUm +BOFIkUKq8LrE+oT9h2qUqqUQ25fGV7e7OFkpmZopqUi0WeIBzlXdYY0Zz+WUJUTC +RC+CIPFIYh1RkopswMAop6ZjuZKRqR0WNuV+rfuF5aCXPpxAm0F14tPyhf42zFMT +GJUMxxowJnoauRq4xGQk+2lYFxbQ0FiC43WZSyYLHMuo5NTJ92QLAgs4FgOyZQqQ +xpsGKMA0cIisNeiootpnlWQvkPzNGUTPg8jqkwTvqQLguZLKJudha1hqfBib1IfO +LNChcU6OqF+3wyPKg5Y5oSbSJPAMcRDANwmS2i9oZm6vsD1pLkWtFGbAkEjjCuEU +W1ev1IsF2UVmWYFtJkqLT708ApUBK/ig3rbJWSq7RGQd3sSrOKu3lyKzTBdkXK2a +BGLV5dS1XURdKxaRkMplLLQxsimBYZEAa8KQkYyI+4EagMqycRR7RgwtZFxJSu0T +1q5wS2JG82iETHplbNj8DYo9IkmKzNAiw4FxK8bRfIYvwrbshbEagL11AQJFsqeZ +WeXDoWEx2FMyyZRAB5QyCFnwYtwtWAQmmITY8aIM2SZyRnHH9Wi8+Sr2qyCscFYo +vzM985aHXOHAxQN2UQZbQkUv3D4Vc+lyvalAffv3Tyg4ks3a22kPXiyeCGweviNX +0K8TKasyOhGsVamTUAZBXfQVw1zmdS4rHDnbHgtIjX3DcCt6UIr0BHTYjdV0JbPj +r1APYgXihjQwM2M83AKIhwQQJv/F3JFOFCQNsEI0QA==""") + def get_local_dict(cls): + #return dict(map(lambda (x,y): (x, y.name), filter(lambda (x,y): isinstance(y, File), cls.__dict__.items()))) + return dict(map(lambda a: (a[0], a[1].name), filter(lambda a: isinstance(a[1], File), cls.__dict__.items()))) + get_local_dict = classmethod(get_local_dict) + def get_URL_dict(cls): + #return dict(map(lambda (x,y): (x, y.URL), filter(lambda (x,y): isinstance(y, File), cls.__dict__.items()))) + return dict(map(lambda a: (a[0], a[1].URL), filter(lambda a: isinstance(a[1], File), cls.__dict__.items()))) + get_URL_dict = classmethod(get_URL_dict) + + +#### HELPER CLASSES FOR PARAMETRING OUTPUT FORMAT #### + +class EnumClass: + def from_string(cls,x): + return cls.__dict__[x.upper()] + from_string = classmethod(from_string) + +class Format(EnumClass): + TEXT = 1 + ANSI = 2 + HTML = 3 + LATEX = 4 + XUNIT = 5 + + +#### TEST CLASSES #### + +class TestClass: + def __getitem__(self, item): + return getattr(self, item) + def add_keywords(self, kw): + if kw is str: + self.keywords.append(kw) + else: + self.keywords += kw + +class TestCampaign(TestClass): + def __init__(self, title): + self.title = title + self.filename = None + self.headcomments = "" + self.campaign = [] + self.keywords = [] + self.crc = None + self.sha = None + self.preexec = None + self.preexec_output = None + def add_testset(self, testset): + self.campaign.append(testset) + def __iter__(self): + return self.campaign.__iter__() + def all_tests(self): + for ts in self: + for t in ts: + yield t + +class TestSet(TestClass): + def __init__(self, name): + self.name = name + self.set = [] + self.comments = "" + self.keywords = [] + self.crc = None + self.expand = 1 + def add_test(self, test): + self.set.append(test) + def __iter__(self): + return self.set.__iter__() + +class UnitTest(TestClass): + def __init__(self, name): + self.name = name + self.test = "" + self.comments = "" + self.result = "" + self.res = True # must be True at init to have a different truth value than None + self.output = "" + self.num = -1 + self.keywords = [] + self.crc = None + self.expand = 1 + def __nonzero__(self): + return self.res + + +#### PARSE CAMPAIGN #### + +def parse_campaign_file(campaign_file): + test_campaign = TestCampaign("Test campaign") + test_campaign.filename= campaign_file.name + testset = None + test = None + testnb = 0 + + for l in campaign_file.readlines(): + if l[0] == '#': + continue + if l[0] == "~": + (test or testset or campaign_file).add_keywords(l[1:].split()) + elif l[0] == "%": + test_campaign.title = l[1:].strip() + elif l[0] == "+": + testset = TestSet(l[1:].strip()) + test_campaign.add_testset(testset) + test = None + elif l[0] == "=": + test = UnitTest(l[1:].strip()) + test.num = testnb + testnb += 1 + testset.add_test(test) + elif l[0] == "*": + if test is not None: + + test.comments += l[1:] + elif testset is not None: + testset.comments += l[1:] + else: + test_campaign.headcomments += l[1:] + else: + if test is None: + if l.strip(): + print("Unknown content [%s]" % l.strip(), file = sys.stderr) + else: + test.test += l + return test_campaign + +def dump_campaign(test_campaign): + print("#"*(len(test_campaign.title)+6)) + print("## %(title)s ##" % test_campaign) + print("#"*(len(test_campaign.title)+6)) + if test_campaign.sha and test_campaign.crc: + print("CRC=[%(crc)s] SHA=[%(sha)s]" % test_campaign) + print("from file %(filename)s" % test_campaign) + print() + for ts in test_campaign: + if ts.crc: + print("+--[%s]%s(%s)--" % (ts.name,"-"*max(2,80-len(ts.name)-18),ts.crc)) + else: + print("+--[%s]%s" % (ts.name,"-"*max(2,80-len(ts.name)-6))) + if ts.keywords: + print(" kw=%s" % ",".join(ts.keywords)) + for t in ts: + print("%(num)03i %(name)s" % t) + c = k = "" + if t.keywords: + k = "kw=%s" % ",".join(t.keywords) + if t.crc: + c = "[%(crc)s] " % t + if c or k: + print(" %s%s" % (c,k) ) + +#### COMPUTE CAMPAIGN DIGESTS #### + +def crc32(x): + return "%08X" % (0xffffffff & zlib.crc32(x)) + +def sha1(x): + return hashlib.sha1(x).hexdigest().upper() + +def compute_campaign_digests(test_campaign): + dc = b"" + for ts in test_campaign: + dts = b"" + for t in ts: + dt = t.test.strip().encode('ascii') + t.crc = crc32(dt) + dts += b"\0"+dt + ts.crc = crc32(dts) + dc += b"\0\x01"+dts + test_campaign.crc = crc32(dc) + if type(test_campaign.filename) is str and test_campaign.filename != '<stdin>': + test = open(test_campaign.filename, 'rb').read() + elif test_campaign.filename == '<stdin>': + test = sys.stdin.read().encode('ascii') + else: + raise Exception("Unknown test source %s" % test_campaign.filename) + test_campaign.sha = sha1(test) + + +#### FILTER CAMPAIGN ##### + +def filter_tests_on_numbers(test_campaign, num): + if num: + for ts in test_campaign: + #ts.set = filter(lambda t: t.num in num, ts.set) + ts.set = [ t for t in ts.set if t.num in num ] + #test_campaign.campaign = filter(lambda ts: len(ts.set) > 0, test_campaign.campaign) + test_campaign.campaign = [ ts for ts in test_campaign.campaign if len(ts.set) > 0 ] + +def filter_tests_keep_on_keywords(test_campaign, kw): + def kw_match(lst, kw): + for k in lst: + if k in kw: + return True + return False + + if kw: + for ts in test_campaign: + #ts.set = filter(lambda t: kw_match(t.keywords, kw), ts.set) + ts.set = [ t for t in ts.set if kw_match(t.keywords, kw) ] + +def filter_tests_remove_on_keywords(test_campaign, kw): + def kw_match(lst, kw): + for k in kw: + if k not in lst: + return False + return True + + if kw: + for ts in test_campaign: + #ts.set = filter(lambda t: not kw_match(t.keywords, kw), ts.set) + ts.set = [ t for t in ts.set if not kw_match(t.keywords, kw) ] + + +def remove_empty_testsets(test_campaign): + #test_campaign.campaign = filter(lambda ts: len(ts.set) > 0, test_campaign.campaign) + test_campaign.campaign = [ ts for ts in test_campaign.campaign if len(ts.set) > 0 ] + + +#### RUN CAMPAIGN ##### + +def run_campaign(test_campaign, get_interactive_session, verb=2): + passed=failed=0 + if test_campaign.preexec: + test_campaign.preexec_output = get_interactive_session(test_campaign.preexec.strip())[0] + for testset in test_campaign: + for t in testset: + t.output,res = get_interactive_session(t.test.strip()) + the_res = False + try: + if res is None or res: + the_res= True + except Exception as msg: + t.output+="UTscapy: Error during result interpretation:\n" + t.output+="".join(traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback,)) + if the_res: + t.res = True + res = "passed" + passed += 1 + else: + t.res = False + res = "failed" + failed += 1 + t.result = res + if verb > 1: + print("%(result)6s %(crc)s %(name)s" % t, file = sys.stderr) + test_campaign.passed = passed + test_campaign.failed = failed + if verb: + print("Campaign CRC=%(crc)s SHA=%(sha)s" % test_campaign, file = sys.stderr) + print("PASSED=%i FAILED=%i" % (passed, failed), file = sys.stderr) + + +#### INFO LINES #### + +def info_line(test_campaign): + filename = test_campaign.filename + if filename is None: + return "Run %s by UTscapy" % time.ctime() + else: + return "Run %s from [%s] by UTscapy" % (time.ctime(), filename) + +def html_info_line(test_campaign): + filename = test_campaign.filename + if filename is None: + return """Run %s by <a href="http://www.secdev.org/projects/UTscapy/">UTscapy</a><br>""" % time.ctime() + else: + return """Run %s from [%s] by <a href="http://www.secdev.org/projects/UTscapy/">UTscapy</a><br>""" % (time.ctime(), filename) + + +#### CAMPAIGN TO something #### + +def campaign_to_TEXT(test_campaign): + output="%(title)s\n" % test_campaign + output += "-- "+info_line(test_campaign)+"\n\n" + output += "Passed=%(passed)i\nFailed=%(failed)i\n\n%(headcomments)s\n" % test_campaign + + for testset in test_campaign: + output += "######\n## %(name)s\n######\n%(comments)s\n\n" % testset + for t in testset: + if t.expand: + output += "###(%(num)03i)=[%(result)s] %(name)s\n%(comments)s\n%(output)s\n\n" % t + + return output + +def campaign_to_ANSI(test_campaign): + output="%(title)s\n" % test_campaign + output += "-- "+info_line(test_campaign)+"\n\n" + output += "Passed=%(passed)i\nFailed=%(failed)i\n\n%(headcomments)s\n" % test_campaign + + for testset in test_campaign: + output += "######\n## %(name)s\n######\n%(comments)s\n\n" % testset + for t in testset: + if t.expand: + output += "###(%(num)03i)=[%(result)s] %(name)s\n%(comments)s\n%(output)s\n\n" % t + + return output + +def campaign_to_xUNIT(test_campaign): + output='<?xml version="1.0" encoding="UTF-8" ?>\n<testsuite>\n' + for testset in test_campaign: + for t in testset: + output += ' <testcase classname="%s"\n' % testset.name.encode("string_escape").replace('"',' ') + output += ' name="%s"\n' % t.name.encode("string_escape").replace('"',' ') + output += ' duration="0">\n' % t + if not t.res: + output += '<error><![CDATA[%(output)s]]></error>\n' % t + output += "</testcase>\n" + output += '</testsuite>' + return output + + +def campaign_to_HTML(test_campaign, local=0): + output = """<html> +<head> +<title>%(title)s</title> +<link rel="stylesheet" href="%%(UTscapy_css)s" type="text/css"> +<script language="JavaScript" src="%%(UTscapy_js)s" type="text/javascript"></script> +</head> +<body> + +<h1>%(title)s</h1> + +<span class=button onClick="hide_all('tst')">Shrink All</span> +<span class=button onClick="show_all('tst')">Expand All</span> +<span class=button onClick="show_passed('tst')">Expand Passed</span> +<span class=button onClick="show_failed('tst')">Expand Failed</span> +<p> +""" % test_campaign + + if local: + External_Files.UTscapy_js.write(os.path.dirname(test_campaign.output_file.name)) + External_Files.UTscapy_css.write(os.path.dirname(test_campaign.output_file.name)) + output %= External_Files.get_local_dict() + else: + output %= External_Files.get_URL_dict() + + if test_campaign.crc is not None and test_campaign.sha is not None: + output += "CRC=<span class=crc>%(crc)s</span> SHA=<span class=crc>%(sha)s</span><br>" % test_campaign + output += "<small><em>"+html_info_line(test_campaign)+"</em></small>" + output += test_campaign.headcomments + "\n<p>PASSED=%(passed)i FAILED=%(failed)i<p>\n\n" % test_campaign + for ts in test_campaign: + for t in ts: + output += """<span class=button%(result)s onClick="goto_id('tst%(num)il')">%(num)03i</span>\n""" % t + output += "\n\n" + + for testset in test_campaign: + output += "<h2>" % testset + if testset.crc is not None: + output += "<span class=crc>%(crc)s</span> " % testset + output += "%(name)s</h2>\n%(comments)s\n<ul>\n" % testset + for t in testset: + output += """<li class=%(result)s id="tst%(num)il">\n""" % t + if t.expand == 2: + output +=""" +<span id="tst%(num)i+" class="button%(result)s" onClick="show('tst%(num)i')" style="POSITION: absolute; VISIBILITY: hidden;">+%(num)03i+</span> +<span id="tst%(num)i-" class="button%(result)s" onClick="hide('tst%(num)i')">-%(num)03i-</span> +""" % t + else: + output += """ +<span id="tst%(num)i+" class="button%(result)s" onClick="show('tst%(num)i')">+%(num)03i+</span> +<span id="tst%(num)i-" class="button%(result)s" onClick="hide('tst%(num)i')" style="POSITION: absolute; VISIBILITY: hidden;">-%(num)03i-</span> +""" % t + if t.crc is not None: + output += "<span class=crc>%(crc)s</span>\n" % t + output += """%(name)s\n<span class="comment %(result)s" id="tst%(num)i" """ % t + if t.expand < 2: + output += """ style="POSITION: absolute; VISIBILITY: hidden;" """ + output += """><br>%(comments)s +<pre> +%(output)s</pre></span> +""" % t + output += "\n</ul>\n\n" + + output += "</body></html>" + return output + +def campaign_to_LATEX(test_campaign): + output = r"""\documentclass{report} +\usepackage{alltt} +\usepackage{xcolor} +\usepackage{a4wide} +\usepackage{hyperref} + +\title{%(title)s} +\date{%%s} + +\begin{document} +\maketitle +\tableofcontents + +\begin{description} +\item[Passed:] %(passed)i +\item[Failed:] %(failed)i +\end{description} + +%(headcomments)s + +""" % test_campaign + output %= info_line(test_campaign) + + for testset in test_campaign: + output += "\\chapter{%(name)s}\n\n%(comments)s\n\n" % testset + for t in testset: + if t.expand: + output += r"""\section{%(name)s} + +[%(num)03i] [%(result)s] + +%(comments)s +\begin{alltt} +%(output)s +\end{alltt} + +""" % t + + output += "\\end{document}\n" + return output + + + +#### USAGE #### + +def usage(): + print("""Usage: UTscapy [-m module] [-f {text|ansi|HTML|LaTeX}] [-o output_file] + [-t testfile] [-k keywords [-k ...]] [-K keywords [-K ...]] + [-l] [-d|-D] [-F] [-q[q]] [-P preexecute_python_code] + [-s /path/to/scpay] +-l\t\t: generate local files +-F\t\t: expand only failed tests +-d\t\t: dump campaign +-D\t\t: dump campaign and stop +-C\t\t: don't calculate CRC and SHA +-s\t\t: path to scapy.py +-q\t\t: quiet mode +-qq\t\t: [silent mode] +-n <testnum>\t: only tests whose numbers are given (eg. 1,3-7,12) +-m <module>\t: additional module to put in the namespace +-k <kw1>,<kw2>,...\t: include only tests with one of those keywords (can be used many times) +-K <kw1>,<kw2>,...\t: remove tests with one of those keywords (can be used many times) +-P <preexecute_python_code> +""", file = sys.stderr) + raise SystemExit + + +#### MAIN #### + +def main(argv): + import builtins + + # Parse arguments + + FORMAT = Format.ANSI + TESTFILE = sys.stdin + OUTPUTFILE = sys.stdout + LOCAL = 0 + NUM=None + KW_OK = [] + KW_KO = [] + DUMP = 0 + CRC = 1 + ONLYFAILED = 0 + VERB=2 + PREEXEC="" + SCAPY="scapy" + MODULES = [] + try: + opts = getopt.getopt(argv, "o:t:f:hln:m:k:K:DdCFqP:s:") + for opt,optarg in opts[0]: + if opt == "-h": + usage() + elif opt == "-F": + ONLYFAILED = 1 + elif opt == "-q": + VERB -= 1 + elif opt == "-D": + DUMP = 2 + elif opt == "-d": + DUMP = 1 + elif opt == "-C": + CRC = 0 + elif opt == "-s": + SCAPY = optarg + elif opt == "-P": + PREEXEC += "\n"+optarg + elif opt == "-f": + try: + FORMAT = Format.from_string(optarg) + except KeyError as msg: + raise getopt.GetoptError("Unknown output format %s" % msg) + elif opt == "-t": + TESTFILE = open(optarg) + elif opt == "-o": + OUTPUTFILE = open(optarg, "w") + elif opt == "-l": + LOCAL = 1 + elif opt == "-n": + NUM = [] + for v in map( lambda x: x.strip(), optarg.split(",") ): + try: + NUM.append(int(v)) + except ValueError: + v1,v2 = map(int, v.split("-")) + for vv in range(v1,v2+1): + NUM.append(vv) + elif opt == "-m": + MODULES.append(optarg) + elif opt == "-k": + KW_OK.append(optarg.split(",")) + elif opt == "-K": + KW_KO.append(optarg.split(",")) + + + try: + from scapy import all as scapy + except ImportError as e: + raise getopt.GetoptError("cannot import [%s]: %s" % (SCAPY,e)) + + for m in MODULES: + try: + mod = import_module(m) + builtins.__dict__.update(mod.__dict__) + except ImportError as e: + raise getopt.GetoptError("cannot import [%s]: %s" % (m,e)) + + except getopt.GetoptError as msg: + print("ERROR:",msg, file = sys.stderr) + raise SystemExit + + autorun_func = { + Format.TEXT: scapy.autorun_get_text_interactive_session, + Format.ANSI: scapy.autorun_get_ansi_interactive_session, + Format.HTML: scapy.autorun_get_html_interactive_session, + Format.LATEX: scapy.autorun_get_latex_interactive_session, + Format.XUNIT: scapy.autorun_get_text_interactive_session, + } + + # Parse test file + test_campaign = parse_campaign_file(TESTFILE) + + # Report parameters + if PREEXEC: + test_campaign.preexec = PREEXEC + + + # Compute campaign CRC and SHA + if CRC: + compute_campaign_digests(test_campaign) + + # Filter out unwanted tests + filter_tests_on_numbers(test_campaign, NUM) + for k in KW_OK: + filter_tests_keep_on_keywords(test_campaign, k) + for k in KW_KO: + filter_tests_remove_on_keywords(test_campaign, k) + + remove_empty_testsets(test_campaign) + + + # Dump campaign + if DUMP: + dump_campaign(test_campaign) + if DUMP > 1: + sys.exit() + + # Run tests + test_campaign.output_file = OUTPUTFILE + run_campaign(test_campaign, autorun_func[FORMAT], verb=VERB) + + # Shrink passed + if ONLYFAILED: + for t in test_campaign.all_tests(): + if t: + t.expand = 0 + else: + t.expand = 2 + + # Generate report + if FORMAT == Format.TEXT: + output = campaign_to_TEXT(test_campaign) + elif FORMAT == Format.ANSI: + output = campaign_to_ANSI(test_campaign) + elif FORMAT == Format.HTML: + output = campaign_to_HTML(test_campaign, local=LOCAL) + elif FORMAT == Format.LATEX: + output = campaign_to_LATEX(test_campaign) + elif FORMAT == Format.XUNIT: + output = campaign_to_xUNIT(test_campaign) + + OUTPUTFILE.write(output) + OUTPUTFILE.close() + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/tools/__init__.py b/scripts/external_libs/scapy-python3-0.18/scapy/tools/__init__.py new file mode 100644 index 00000000..af6eec74 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/tools/__init__.py @@ -0,0 +1,8 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Additional tools to be run separately +""" diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/tools/check_asdis.py b/scripts/external_libs/scapy-python3-0.18/scapy/tools/check_asdis.py new file mode 100644 index 00000000..3e45007f --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/tools/check_asdis.py @@ -0,0 +1,103 @@ +#! /usr/bin/env python + +import getopt + +def usage(): + print("""Usage: check_asdis -i <pcap_file> [-o <wrong_packets.pcap>] + -v increase verbosity + -d hexdiff packets that differ + -z compress output pcap + -a open pcap file in append mode""", file = sys.stderr) + +def main(argv): + PCAP_IN = None + PCAP_OUT = None + COMPRESS=False + APPEND=False + DIFF=False + VERBOSE=0 + try: + opts=getopt.getopt(argv, "hi:o:azdv") + for opt, parm in opts[0]: + if opt == "-h": + usage() + raise SystemExit + elif opt == "-i": + PCAP_IN = parm + elif opt == "-o": + PCAP_OUT = parm + elif opt == "-v": + VERBOSE += 1 + elif opt == "-d": + DIFF = True + elif opt == "-a": + APPEND = True + elif opt == "-z": + COMPRESS = True + + + if PCAP_IN is None: + raise getopt.GetoptError("Missing pcap file (-i)") + + except getopt.GetoptError as e: + print("ERROR: %s" % e, file = sys.stderr) + raise SystemExit + + + + from scapy.config import conf + from scapy.utils import RawPcapReader,RawPcapWriter,hexdiff + from scapy.layers import all + + + pcap = RawPcapReader(PCAP_IN) + pcap_out = None + if PCAP_OUT: + pcap_out = RawPcapWriter(PCAP_OUT, append=APPEND, gz=COMPRESS, linktype=pcap.linktype) + pcap_out._write_header(None) + + LLcls = conf.l2types.get(pcap.linktype) + if LLcls is None: + print(" Unknown link type [%i]. Can't test anything!" % pcap.linktype, file = sys.stderr) + raise SystemExit + + + i=-1 + differ=0 + failed=0 + for p1,meta in pcap: + i += 1 + try: + p2d = LLcls(p1) + p2 = str(p2d) + except KeyboardInterrupt: + raise + except Exception as e: + print("Dissection error on packet %i" % i) + failed += 1 + else: + if p1 == p2: + if VERBOSE >= 2: + print("Packet %i ok" % i) + continue + else: + print("Packet %i differs" % i) + differ += 1 + if VERBOSE >= 1: + print(repr(p2d)) + if DIFF: + hexdiff(p1,p2) + if pcap_out is not None: + pcap_out.write(p1) + i+=1 + correct = i-differ-failed + print("%i total packets. %i ok, %i differed, %i failed. %.2f%% correct." % (i, correct, differ, + failed, i and 100.0*(correct)/i)) + + +if __name__ == "__main__": + import sys + try: + main(sys.argv[1:]) + except KeyboardInterrupt: + print("Interrupted by user.", file = sys.stderr) diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/utils.py b/scripts/external_libs/scapy-python3-0.18/scapy/utils.py new file mode 100644 index 00000000..252109bb --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/utils.py @@ -0,0 +1,1054 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +General utility functions. +""" + +import os,sys,socket,types +import random,time +import gzip,zlib +import re,struct,array,stat +import subprocess + +import warnings +warnings.filterwarnings("ignore","tempnam",RuntimeWarning, __name__) + +from .config import conf +from .data import MTU +from .error import log_runtime,log_loading,log_interactive, Scapy_Exception +from .base_classes import BasePacketList,BasePacket + + +WINDOWS=sys.platform.startswith("win32") + +########### +## Tools ## +########### + +def get_temp_file(keep=False, autoext=""): + import tempfile + fd, fname = tempfile.mkstemp(suffix = ".scapy" + autoext) + os.close(fd) + if not keep: + conf.temp_files.append(fname) + return fname + +def str2bytes(x): + """Convert input argument to bytes""" + if type(x) is bytes: + return x + elif type(x) is str: + return bytes([ ord(i) for i in x ]) + else: + return str2bytes(str(x)) + +def chb(x): + if type(x) is str: + return x + else: + return chr(x) + +def orb(x): + if type(x) is str: + return ord(x) + else: + return x + +def any2b(x): + if type(x) is not str and type(x) is not bytes: + try: + x=bytes(x) + except: + x = str(x) + if type(x) is str: + x = bytes([ ord(i) for i in x ]) + return x + +def sane_color(x): + r="" + for i in x: + j = orb(i) + if (j < 32) or (j >= 127): + r=r+conf.color_theme.not_printable(".") + else: + r=r+chb(i) + return r + +def sane(x): + r="" + for i in x: + if type(x) is str: + j = ord(i) + else: + j = i + if (j < 32) or (j >= 127): + r=r+"." + else: + r=r+chb(i) + return r + +def lhex(x): + if type(x) is int: + return hex(x) + elif type(x) is tuple: + return "(%s)" % ", ".join(map(lhex, x)) + elif type(x) is list: + return "[%s]" % ", ".join(map(lhex, x)) + else: + return x + +@conf.commands.register +def hexdump(x): + if type(x) is not str and type(x) is not bytes: + try: + x=bytes(x) + except: + x = str(x) + l = len(x) + i = 0 + while i < l: + print("%04x " % i,end = " ") + for j in range(16): + if i+j < l: + print("%02X" % orb(x[i+j]), end = " ") + else: + print(" ", end = " ") + if j%16 == 7: + print("", end = " ") + print(" ", end = " ") + print(sane_color(x[i:i+16])) + i += 16 + +@conf.commands.register +def linehexdump(x, onlyasc=0, onlyhex=0): + if type(x) is not str and type(x) is not bytes: + try: + x=bytes(x) + except: + x = str(x) + l = len(x) + if not onlyasc: + for i in range(l): + print("%02X" % orb(x[i]), end = " ") + print("", end = " ") + if not onlyhex: + print(sane_color(x)) + +def chexdump(x): + if type(x) is not str and type(x) is not bytes: + try: + x=bytes(x) + except: + x = str(x) + print(", ".join(map(lambda x: "%#04x"%orb(x), x))) + +def hexstr(x, onlyasc=0, onlyhex=0): + s = [] + if not onlyasc: + s.append(" ".join(map(lambda x:"%02x"%orb(x), x))) + if not onlyhex: + s.append(sane(x)) + return " ".join(s) + + +@conf.commands.register +def hexdiff(x,y): + """Show differences between 2 binary strings""" + x=any2b(x)[::-1] + y=any2b(y)[::-1] + SUBST=1 + INSERT=1 + d={} + d[-1,-1] = 0,(-1,-1) + for j in range(len(y)): + d[-1,j] = d[-1,j-1][0]+INSERT, (-1,j-1) + for i in range(len(x)): + d[i,-1] = d[i-1,-1][0]+INSERT, (i-1,-1) + + for j in range(len(y)): + for i in range(len(x)): + d[i,j] = min( ( d[i-1,j-1][0]+SUBST*(x[i] != y[j]), (i-1,j-1) ), + ( d[i-1,j][0]+INSERT, (i-1,j) ), + ( d[i,j-1][0]+INSERT, (i,j-1) ) ) + + + backtrackx = [] + backtracky = [] + i=len(x)-1 + j=len(y)-1 + while not (i == j == -1): + i2,j2 = d[i,j][1] + backtrackx.append(x[i2+1:i+1]) + backtracky.append(y[j2+1:j+1]) + i,j = i2,j2 + + + + x = y = i = 0 + colorize = { 0: lambda x:x, + -1: conf.color_theme.left, + 1: conf.color_theme.right } + + dox=1 + doy=0 + l = len(backtrackx) + while i < l: + separate=0 + linex = backtrackx[i:i+16] + liney = backtracky[i:i+16] + xx = sum(len(k) for k in linex) + yy = sum(len(k) for k in liney) + if dox and not xx: + dox = 0 + doy = 1 + if dox and linex == liney: + doy=1 + + if dox: + xd = y + j = 0 + while not linex[j]: + j += 1 + xd -= 1 + print(colorize[doy-dox]("%04x" % xd), end = " ") + x += xx + line=linex + else: + print(" ", end = " ") + if doy: + yd = y + j = 0 + while not liney[j]: + j += 1 + yd -= 1 + print(colorize[doy-dox]("%04x" % yd), end = " ") + y += yy + line=liney + else: + print(" ", end = " ") + + print(" ", end = " ") + + cl = "" + for j in range(16): + if i+j < l: + if line[j]: + col = colorize[(linex[j]!=liney[j])*(doy-dox)] + print(col("%02X" % line[j][0]), end = " ") + if linex[j]==liney[j]: + cl += sane_color(line[j]) + else: + cl += col(sane(line[j])) + else: + print(" ", end = " ") + cl += " " + else: + print(" ", end = " ") + if j == 7: + print("", end = " ") + + + print(" ",cl) + + if doy or not yy: + doy=0 + dox=1 + i += 16 + else: + if yy: + dox=0 + doy=1 + else: + i += 16 + + +crc32 = zlib.crc32 + +if struct.pack("H",1) == b"\x00\x01": # big endian + def checksum(pkt): + if len(pkt) % 2 == 1: + pkt += b"\0" + s = sum(array.array("H", pkt)) + s = (s >> 16) + (s & 0xffff) + s += s >> 16 + s = ~s + return s & 0xffff +else: + def checksum(pkt): + if len(pkt) % 2 == 1: + pkt += b"\0" + s = sum(array.array("H", pkt)) + s = (s >> 16) + (s & 0xffff) + s += s >> 16 + s = ~s + return (((s>>8)&0xff)|s<<8) & 0xffff + +def warning(x): + log_runtime.warning(x) + +def mac2str(mac): + #return "".join(map(lambda x: chr(int(x,16)), mac.split(":"))) + if type(mac) != str: + mac = mac.decode('ascii') + return b''.join([ bytes([int(i, 16)]) for i in mac.split(":") ]) + +def str2mac(s): + return ("%02x:"*6)[:-1] % tuple(s) + +def strxor(x,y): + #return "".join(map(lambda i,j:chr(ord(i)^ord(j)),x,y)) + return bytes([ i[0] ^ i[1] for i in zip(x,y) ] ) + +# Workarround bug 643005 : https://sourceforge.net/tracker/?func=detail&atid=105470&aid=643005&group_id=5470 +try: + socket.inet_aton("255.255.255.255") +except socket.error: + def inet_aton(x): + if x == "255.255.255.255": + return b"\xff"*4 + else: + return socket.inet_aton(x) +else: + inet_aton = socket.inet_aton + +inet_ntoa = socket.inet_ntoa +try: + inet_ntop = socket.inet_ntop + inet_pton = socket.inet_pton +except AttributeError: + from scapy.pton_ntop import * + log_loading.info("inet_ntop/pton functions not found. Python IPv6 support not present") + + +def atol(x): + try: + ip = inet_aton(x) + except socket.error: + ip = inet_aton(socket.gethostbyname(x)) + return struct.unpack("!I", ip)[0] +def ltoa(x): + return inet_ntoa(struct.pack("!I", x&0xffffffff)) + +def itom(x): + return (0xffffffff00000000>>x)&0xffffffff + +def do_graph(graph,prog=None,format='png',target=None,string=False,options=None, figsize = (12, 12), **kargs): + """do_graph(graph, prog=conf.prog.dot, format="png", + target=None, options=None, string=False): + if networkx library is available and graph is instance of Graph, use networkx.draw + + string: if not False, simply return the graph string + graph: GraphViz graph description + format: output type (svg, ps, gif, jpg, etc.), passed to dot's "-T" option. Ignored if target==None + target: filename. If None uses matplotlib to display + prog: which graphviz program to use + options: options to be passed to prog""" + + from scapy.arch import NETWORKX + if NETWORKX: + import networkx as nx + + if NETWORKX and isinstance(graph, nx.Graph): + nx.draw(graph, with_labels = True, edge_color = '0.75', **kargs) + else: # otherwise use dot as in scapy 2.x + if string: + return graph + if prog is None: + prog = conf.prog.dot + + if not target or not format: + format = 'png' + format = "-T %s" % format + + p = subprocess.Popen("%s %s %s" % (prog,options or "", format or ""), shell = True, stdin = subprocess.PIPE, stdout = subprocess.PIPE) + w, r = p.stdin, p.stdout + w.write(graph.encode('utf-8')) + w.close() + if target: + with open(target, 'wb') as f: + f.write(r.read()) + else: + try: + import matplotlib.image as mpimg + import matplotlib.pyplot as plt + plt.figure(figsize = figsize) + plt.axis('off') + return plt.imshow(mpimg.imread(r, format = format), **kargs) + + except ImportError: + warning('matplotlib.image required for interactive graph viewing. Use target option to write to a file') + +_TEX_TR = { + "{":"{\\tt\\char123}", + "}":"{\\tt\\char125}", + "\\":"{\\tt\\char92}", + "^":"\\^{}", + "$":"\\$", + "#":"\\#", + "~":"\\~", + "_":"\\_", + "&":"\\&", + "%":"\\%", + "|":"{\\tt\\char124}", + "~":"{\\tt\\char126}", + "<":"{\\tt\\char60}", + ">":"{\\tt\\char62}", + } + +def tex_escape(x): + s = "" + for c in x: + s += _TEX_TR.get(c,c) + return s + +def colgen(*lstcol,**kargs): + """Returns a generator that mixes provided quantities forever + trans: a function to convert the three arguments into a color. lambda x,y,z:(x,y,z) by default""" + if len(lstcol) < 2: + lstcol *= 2 + trans = kargs.get("trans", lambda x,y,z: (x,y,z)) + while 1: + for i in range(len(lstcol)): + for j in range(len(lstcol)): + for k in range(len(lstcol)): + if i != j or j != k or k != i: + yield trans(lstcol[(i+j)%len(lstcol)],lstcol[(j+k)%len(lstcol)],lstcol[(k+i)%len(lstcol)]) + +def incremental_label(label="tag%05i", start=0): + while True: + yield label % start + start += 1 + +######################### +#### Enum management #### +######################### + +class EnumElement: + _value=None + def __init__(self, key, value): + self._key = key + self._value = value + def __repr__(self): + return "<%s %s[%r]>" % (self.__dict__.get("_name", self.__class__.__name__), self._key, self._value) + def __getattr__(self, attr): + return getattr(self._value, attr) + def __str__(self): + return self._key + def __eq__(self, other): + #return self._value == int(other) + return self._value == hash(other) + def __hash__(self): + return self._value + + +class Enum_metaclass(type): + element_class = EnumElement + def __new__(cls, name, bases, dct): + rdict={} + for k,v in dct.items(): + if type(v) is int: + v = cls.element_class(k,v) + dct[k] = v + rdict[v] = k + dct["__rdict__"] = rdict + return super(Enum_metaclass, cls).__new__(cls, name, bases, dct) + def __getitem__(self, attr): + return self.__rdict__[attr] + def __contains__(self, val): + return val in self.__rdict__ + def get(self, attr, val=None): + return self._rdict__.get(attr, val) + def __repr__(self): + return "<%s>" % self.__dict__.get("name", self.__name__) + + + +################### +## Object saving ## +################### + + +def export_object(obj): + import dill as pickle + import base64 + return base64.b64encode(gzip.zlib.compress(pickle.dumps(obj,4),9)).decode('utf-8') + + +def import_object(obj): + import dill as pickle + import base64 +# if obj is None: +# obj = sys.stdin.read().strip().encode('utf-8') + if obj is str: + obj = obj.strip().encode('utf-8') + return pickle.loads(gzip.zlib.decompress(base64.b64decode(obj))) + + +def save_object(fname, obj): + import dill as pickle + pickle.dump(obj,gzip.open(fname,"wb")) + +def load_object(fname): + import dill as pickle + return pickle.load(gzip.open(fname,"rb")) + +@conf.commands.register +def corrupt_bytes(s, p=0.01, n=None): + """Corrupt a given percentage or number of bytes from bytes""" + s = str2bytes(s) + s = array.array("B",s) + l = len(s) + if n is None: + n = max(1,int(l*p)) + for i in random.sample(range(l), n): + s[i] = (s[i]+random.randint(1,255))%256 + return s.tobytes() + +@conf.commands.register +def corrupt_bits(s, p=0.01, n=None): + """Flip a given percentage or number of bits from bytes""" + s = str2bytes(s) + s = array.array("B",s) + l = len(s)*8 + if n is None: + n = max(1, int(l*p)) + for i in random.sample(range(l), n): + s[i//8] ^= 1 << (i%8) + return s.tobytes() + + +############################# +## pcap capture file stuff ## +############################# + +@conf.commands.register +def wrpcap(filename, pkt, *args, **kargs): + """Write a list of packets to a pcap file +gz: set to 1 to save a gzipped capture +linktype: force linktype value +endianness: "<" or ">", force endianness""" + with PcapWriter(filename, *args, **kargs) as pcap: + pcap.write(pkt) + +@conf.commands.register +def rdpcap(filename, count=-1): + """Read a pcap file and return a packet list +count: read only <count> packets""" + with PcapReader(filename) as pcap: + return pcap.read_all(count=count) + +class RawPcapReader: + """A stateful pcap reader. Each packet is returned as bytes""" + def __init__(self, filename): + self.filename = filename + try: + if not stat.S_ISREG(os.stat(filename).st_mode): + raise IOError("GZIP detection works only for regular files") + self.f = gzip.open(filename,"rb") + magic = self.f.read(4) + except IOError: + self.f = open(filename,"rb") + magic = self.f.read(4) + if magic == b"\xa1\xb2\xc3\xd4": #big endian + self.endian = ">" + self.reader = _RawPcapOldReader(self.f, self.endian) + elif magic == b"\xd4\xc3\xb2\xa1": #little endian + self.endian = "<" + self.reader = _RawPcapOldReader(self.f, self.endian) + elif magic == b"\x0a\x0d\x0d\x0a": #PcapNG + self.reader = _RawPcapNGReader(self.f) + else: + raise Scapy_Exception("Not a pcap capture file (bad magic)") + + def __enter__(self): + return self.reader + + def __exit__(self, exc_type, exc_value, tracback): + self.close() + + def __iter__(self): + return self.reader.__iter__() + + def dispatch(self, callback): + """call the specified callback routine for each packet read + + This is just a convienience function for the main loop + that allows for easy launching of packet processing in a + thread. + """ + for p in self: + callback(p) + + def read_all(self,count=-1): + """return a list of all packets in the pcap file + """ + res=[] + while count != 0: + count -= 1 + p = self.read_packet() + if p is None: + break + res.append(p) + return res + + def recv(self, size=MTU): + """ Emulate a socket + """ + return self.read_packet(size)[0] + + def fileno(self): + return self.f.fileno() + + def close(self): + return self.f.close() + + def read_packet(self, size = MTU): + return self.reader.read_packet(size) + +def align32(n): + return n + (4 - n % 4) % 4 + +class _RawPcapNGReader: + def __init__(self, filep): + self.filep = filep + self.filep.seek(0, 0) + self.endian = '<' + self.tsresol = 6 + self.linktype = None + + def __iter__(self): + return self + + def __next__(self): + """implement the iterator protocol on a set of packets in a pcapng file""" + pkt = self.read_packet() + if pkt == None: + raise StopIteration + return pkt + + def read_packet(self, size = MTU): + while True: + buf = self._read_bytes(4, check = False) + if len(buf) == 0: + return None + elif len(buf) != 4: + raise IOError("PacketNGReader: Premature end of file") + block_type, = struct.unpack(self.endian + 'i', buf) + if block_type == 168627466: #Section Header b'\x0a\x0d\x0d\x0a' + self.read_section_header() + elif block_type == 1: + self.read_interface_description() + elif block_type == 6: + return self.read_enhanced_packet(size) + else: + warning("PacketNGReader: Unparsed block type %d/#%x" % (block_type, block_type)) + self.read_generic_block() + + def _read_bytes(self, n, check = True): + buf = self.filep.read(n) + if check and len(buf) < n: + raise IOError("PacketNGReader: Premature end of file") + return buf + + def read_generic_block(self): + block_length, = struct.unpack(self.endian + 'I', self._read_bytes(4)) + self._read_bytes(block_length - 12) + self._check_length(block_length) + + def read_section_header(self): + buf = self._read_bytes(16) + if buf[4:8] == b'\x1a\x2b\x3c\x4d': + self.endian = '>' + elif buf[4:8] == b'\x4d\x3c\x2b\x1a': + self.endian = '<' + else: + raise Scapy_Exception('Cannot read byte order value') + block_length, _, major_version, minor_version, section_length = struct.unpack(self.endian + 'IIHHi', buf) + options = self._read_bytes(block_length - 24) + if options: + opt = self.parse_options(options) + for i in opt.keys(): + if not i & (0b1 << 15): + warning("PcapNGReader: Unparsed option %d/#%x in section header" % (i, i)) + self._check_length(block_length) + + def read_interface_description(self): + buf = self._read_bytes(12) + block_length, self.linktype, reserved, self.snaplen = struct.unpack(self.endian + 'IHHI', buf) + options = self._read_bytes(block_length - 20) + if options: + opt = self.parse_options(options) + for i in opt.keys(): + if 9 in opt: + self.tsresol = opt[9][0] + elif not i & (0b1 << 15): + warning("PcapNGReader: Unparsed option %d/#%x in enhanced packet block" % (i, i)) + try: + self.LLcls = conf.l2types[self.linktype] + except KeyError: + warning("RawPcapReader: unknown LL type [%i]/[%#x]. Using Raw packets" % (self.linktype,self.linktype)) + self.LLcls = conf.raw_layer + + self._check_length(block_length) + + def read_enhanced_packet(self, size = MTU): + buf = self._read_bytes(24) + block_length, interface, ts_high, ts_low, caplen, wirelen = struct.unpack(self.endian + 'IIIIII', buf) + timestamp = (ts_high << 32) + ts_low + + pkt = self._read_bytes(align32(caplen))[:caplen] + options = self._read_bytes(block_length - align32(caplen) - 32) + if options: + opt = self.parse_options(options) + for i in opt.keys(): + if not i & (0b1 << 15): + warning("PcapNGReader: Unparsed option %d/#%x in enhanced packet block" % (i, i)) + self._check_length(block_length) + return pkt[:MTU], (self.parse_sec(timestamp), self.parse_usec(timestamp), wirelen) + + def parse_sec(self, t): + if self.tsresol & 0b10000000: + return t >> self.tsresol + else: + return t // pow(10, self.tsresol) + + def parse_usec(self, t): + if self.tsresol & 0b10000000: + return t & (1 << self.tsresol) - 1 + else: + return t % pow(10, self.tsresol) + + def parse_options(self, opt): + buf = opt + options = {} + while buf: + opt_type, opt_len = struct.unpack(self.endian + 'HH', buf[:4]) + if opt_type == 0: + return options + options[opt_type] = buf[4:4 + opt_len] + buf = buf[ 4 + align32(opt_len):] + return options + + def _check_length(self, block_length): + check_length, = struct.unpack(self.endian + 'I', self._read_bytes(4)) + if check_length != block_length: + raise Scapy_Exception('Block length values are not equal') + +class _RawPcapOldReader: + def __init__(self, filep, endianness): + self.endian = endianness + self.f = filep + hdr = self.f.read(20) + if len(hdr)<20: + raise Scapy_Exception("Invalid pcap file (too short)") + vermaj,vermin,tz,sig,snaplen,linktype = struct.unpack(self.endian+"HHIIII",hdr) + + self.linktype = linktype + try: + self.LLcls = conf.l2types[self.linktype] + except KeyError: + warning("RawPcapReader: unknown LL type [%i]/[%#x]. Using Raw packets" % (self.linktype,self.linktype)) + self.LLcls = conf.raw_layer + + def __iter__(self): + return self + + def __next__(self): + """implement the iterator protocol on a set of packets in a pcap file""" + pkt = self.read_packet() + if pkt == None: + raise StopIteration + return pkt + + def read_packet(self, size=MTU): + """return a single packet read from the file + bytes, (sec, #timestamp seconds + usec, #timestamp microseconds + wirelen) #actual length of packet + returns None when no more packets are available + """ + hdr = self.f.read(16) + if len(hdr) < 16: + return None + sec,usec,caplen,wirelen = struct.unpack(self.endian+"IIII", hdr) + s = self.f.read(caplen)[:MTU] + return s,(sec,usec,wirelen) # caplen = len(s) + + +class PcapReader(RawPcapReader): + def __init__(self, filename): + RawPcapReader.__init__(self, filename) + def __enter__(self): + return self + def __iter__(self): + return self + def __next__(self): + """implement the iterator protocol on a set of packets in a pcap file""" + pkt = self.read_packet() + if pkt == None: + raise StopIteration + return pkt + def read_packet(self, size=MTU): + rp = RawPcapReader.read_packet(self,size) + if rp is None: + return None + s,(sec,usec,wirelen) = rp + + + try: + p = self.reader.LLcls(s) + except KeyboardInterrupt: + raise + except: + if conf.debug_dissector: + raise + p = conf.raw_layer(s) + p.time = sec+0.000001*usec + p.wirelen = wirelen + return p + + def read_all(self,count=-1): + res = RawPcapReader.read_all(self, count) + import scapy.plist + return scapy.plist.PacketList(res,name = os.path.basename(self.filename)) + def recv(self, size=MTU): + return self.read_packet(size) + + +class RawPcapWriter: + """A stream PCAP writer with more control than wrpcap()""" + def __init__(self, filename, linktype=None, gz=False, endianness="", append=False, sync=False): + """ + linktype: force linktype to a given value. If None, linktype is taken + from the first writter packet + gz: compress the capture on the fly + endianness: force an endianness (little:"<", big:">"). Default is native + append: append packets to the capture file instead of truncating it + sync: do not bufferize writes to the capture file + """ + + self.linktype = linktype + self.header_present = 0 + self.append=append + self.gz = gz + self.endian = endianness + self.filename=filename + self.sync=sync + bufsz=4096 + if sync: + bufsz=0 + + self.f = [open,gzip.open][gz](filename,append and "ab" or "wb", gz and 9 or bufsz) + + def fileno(self): + return self.f.fileno() + + def _write_header(self, pkt): + self.header_present=1 + + if self.append: + # Even if prone to race conditions, this seems to be + # safest way to tell whether the header is already present + # because we have to handle compressed streams that + # are not as flexible as basic files + g = [open,gzip.open][self.gz](self.filename,"rb") + if g.read(16): + return + + self.f.write(struct.pack(self.endian+"IHHIIII", 0xa1b2c3d4, + 2, 4, 0, 0, MTU, self.linktype)) + self.f.flush() + + + def write(self, pkt): + """accepts a either a single packet or a list of packets + to be written to the dumpfile + """ + if not self.header_present: + self._write_header(pkt) + if type(pkt) is bytes: + self._write_packet(pkt) + else: + for p in pkt: + self._write_packet(p) + + def _write_packet(self, packet, sec=None, usec=None, caplen=None, wirelen=None): + """writes a single packet to the pcap file + """ + if caplen is None: + caplen = len(packet) + if wirelen is None: + wirelen = caplen + if sec is None or usec is None: + t=time.time() + it = int(t) + if sec is None: + sec = it + if usec is None: + usec = int(round((t-it)*1000000)) + self.f.write(struct.pack(self.endian+"IIII", sec, usec, caplen, wirelen)) + self.f.write(packet) + if self.gz and self.sync: + self.f.flush() + + def flush(self): + return self.f.flush() + + def close(self): + return self.f.close() + + def __enter__(self): + return self + def __exit__(self, exc_type, exc_value, tracback): + self.flush() + self.close() + + +class PcapWriter(RawPcapWriter): + def _write_header(self, pkt): + if self.linktype == None: + if type(pkt) is list or type(pkt) is tuple or isinstance(pkt,BasePacketList): + pkt = pkt[0] + try: + self.linktype = conf.l2types[pkt.__class__] + except KeyError: + warning("PcapWriter: unknown LL type for %s. Using type 1 (Ethernet)" % pkt.__class__.__name__) + self.linktype = 1 + RawPcapWriter._write_header(self, pkt) + + def _write_packet(self, packet): + try: + sec = int(packet.time) + usec = int(round((packet.time-sec)*1000000)) + s = bytes(packet) + caplen = len(s) + RawPcapWriter._write_packet(self, s, sec, usec, caplen, caplen) + except Exception as e: + log_interactive.error(e) + def write(self, pkt): + """accepts a either a single packet or a list of packets + to be written to the dumpfile + """ + if not self.header_present: + self._write_header(pkt) + if isinstance(pkt, BasePacket): + self._write_packet(pkt) + else: + for p in pkt: + self._write_packet(p) + + +re_extract_hexcap = re.compile("^((0x)?[0-9a-fA-F]{2,}[ :\t]{,3}|) *(([0-9a-fA-F]{2} {,2}){,16})") + +def import_hexcap(): + p = "" + try: + while 1: + l = raw_input().strip() + try: + p += re_extract_hexcap.match(l).groups()[2] + except: + warning("Parsing error during hexcap") + continue + except EOFError: + pass + + p = p.replace(" ","") + return p.decode("hex") + + + +@conf.commands.register +def wireshark(pktlist, *args): + """Run wireshark on a list of packets""" + fname = get_temp_file() + wrpcap(fname, pktlist) + subprocess.Popen([conf.prog.wireshark, "-r", fname] + list(args)) + +@conf.commands.register +def tdecode(pkt, *args): + """Run tshark to decode and display the packet. If no args defined uses -V""" + if not args: + args = [ "-V" ] + fname = get_temp_file() + wrpcap(fname,[pkt]) + subprocess.call(["tshark", "-r", fname] + list(args)) + +@conf.commands.register +def hexedit(x): + """Run external hex editor on a packet or bytes. Set editor in conf.prog.hexedit""" + x = bytes(x) + fname = get_temp_file() + with open(fname,"wb") as f: + f.write(x) + subprocess.call([conf.prog.hexedit, fname]) + with open(fname, "rb") as f: + x = f.read() + return x + +def __make_table(yfmtfunc, fmtfunc, endline, items, fxyz, sortx=None, sorty=None, seplinefunc=None): + vx = {} + vy = {} + vz = {} + vxf = {} + vyf = {} + max_length = 0 + for record in items: + xx,yy,zz = map(str, fxyz(record[0], record[1])) + max_length = max(len(yy),max_length) + vx[xx] = max(vx.get(xx,0), len(xx), len(zz)) + vy[yy] = None + vz[(xx,yy)] = zz + + vxk = list(vx.keys()) + vyk = list(vy.keys()) + if sortx: + vxk.sort(sortx) + else: + try: + vxk.sort(key = lambda x: atol(x)) + except: + vxk.sort() + if sorty: + vyk.sort(sorty) + else: + try: + vyk.sort(key = lambda x: atol(x)) + except: + vyk.sort() + + + if seplinefunc: + sepline = seplinefunc(max_length, [vx[x] for x in vxk]) + print(sepline) + + fmt = yfmtfunc(max_length) + print(fmt % "", end = " ") + for x in vxk: + vxf[x] = fmtfunc(vx[x]) + print(vxf[x] % x, end = " ") + print(endline) + if seplinefunc: + print(sepline) + for y in vyk: + print(fmt % y, end = " ") + for x in vxk: + print(vxf[x] % vz.get((x,y), "-"), end = " ") + print(endline) + if seplinefunc: + print(sepline) + +def make_table(*args, **kargs): + __make_table(lambda l:"%%-%is" % l, lambda l:"%%-%is" % l, "", *args, **kargs) + +def make_lined_table(*args, **kargs): + __make_table(lambda l:"%%-%is |" % l, lambda l:"%%-%is |" % l, "", + seplinefunc=lambda max_length,x:"+".join([ "-"*(y+2) for y in [max_length-1]+x+[-2]]), + *args, **kargs) + +def make_tex_table(*args, **kargs): + __make_table(lambda l: "%s", lambda l: "& %s", "\\\\", seplinefunc=lambda a,x:"\\hline", *args, **kargs) + diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/utils6.py b/scripts/external_libs/scapy-python3-0.18/scapy/utils6.py new file mode 100644 index 00000000..d9112aa5 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/utils6.py @@ -0,0 +1,823 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +## Copyright (C) 2005 Guillaume Valadon <guedou@hongo.wide.ad.jp> +## Arnaud Ebalard <arnaud.ebalard@eads.net> + +""" +Utility functions for IPv6. +""" + +import itertools +from .config import conf +from .data import * +from .utils import * + +def cmp_to_key(mycmp): + 'Convert a cmp= function into a key= function' + class K(object): + def __init__(self, obj, *args): + self.obj = obj + def __lt__(self, other): + return mycmp(self.obj, other.obj) < 0 + def __gt__(self, other): + return mycmp(self.obj, other.obj) > 0 + def __eq__(self, other): + return mycmp(self.obj, other.obj) == 0 + def __le__(self, other): + return mycmp(self.obj, other.obj) <= 0 + def __ge__(self, other): + return mycmp(self.obj, other.obj) >= 0 + def __ne__(self, other): + return mycmp(self.obj, other.obj) != 0 + return K + + + +def construct_source_candidate_set(addr, plen, laddr, loname): + """ + Given all addresses assigned to a specific interface ('laddr' parameter), + this function returns the "candidate set" associated with 'addr/plen'. + + Basically, the function filters all interface addresses to keep only those + that have the same scope as provided prefix. + + This is on this list of addresses that the source selection mechanism + will then be performed to select the best source address associated + with some specific destination that uses this prefix. + """ + def cset_sort(x,y): + x_global = 0 + if in6_isgladdr(x): + x_global = 1 + y_global = 0 + if in6_isgladdr(y): + y_global = 1 + res = y_global - x_global + if res != 0 or y_global != 1: + return res + # two global addresses: if one is native, it wins. + if not in6_isaddr6to4(x): + return -1; + return -res + + cset = [] + if in6_isgladdr(addr) or in6_isuladdr(addr): + cset = [ x for x in laddr if x[1] == IPV6_ADDR_GLOBAL ] + elif in6_islladdr(addr): + cset = [ x for x in laddr if x[1] == IPV6_ADDR_LINKLOCAL ] + elif in6_issladdr(addr): + cset = [ x for x in laddr if x[1] == IPV6_ADDR_SITELOCAL ] + elif in6_ismaddr(addr): + if in6_ismnladdr(addr): + cset = [('::1', 16, loname)] + elif in6_ismgladdr(addr): + cset = [ x for x in laddr if x[1] == IPV6_ADDR_GLOBAL ] + elif in6_ismlladdr(addr): + cset = [ x for x in laddr if x[1] == IPV6_ADDR_LINKLOCAL ] + elif in6_ismsladdr(addr): + cset = [ x for x in laddr if x[1] == IPV6_ADDR_SITELOCAL ] + elif addr == '::' and plen == 0: + cset = [ x for x in laddr if x[1] == IPV6_ADDR_GLOBAL ] + cset = [ x[0] for x in cset ] + cset.sort(key = cmp_to_key(cset_sort)) # Sort with global addresses first + return cset + +def get_source_addr_from_candidate_set(dst, candidate_set): + """ + This function implement a limited version of source address selection + algorithm defined in section 5 of RFC 3484. The format is very different + from that described in the document because it operates on a set + of candidate source address for some specific route. + """ + + def scope_cmp(a, b): + """ + Given two addresses, returns -1, 0 or 1 based on comparison of + their scope + """ + scope_mapper = {IPV6_ADDR_GLOBAL: 4, + IPV6_ADDR_SITELOCAL: 3, + IPV6_ADDR_LINKLOCAL: 2, + IPV6_ADDR_LOOPBACK: 1} + sa = in6_getscope(a) + if sa == -1: + sa = IPV6_ADDR_LOOPBACK + sb = in6_getscope(b) + if sb == -1: + sb = IPV6_ADDR_LOOPBACK + + sa = scope_mapper[sa] + sb = scope_mapper[sb] + + if sa == sb: + return 0 + if sa > sb: + return 1 + return -1 + + def rfc3484_cmp(source_a, source_b): + """ + The function implements a limited version of the rules from Source + Address selection algorithm defined section of RFC 3484. + """ + + # Rule 1: Prefer same address + if source_a == dst: + return 1 + if source_b == dst: + return 1 + + # Rule 2: Prefer appropriate scope + tmp = scope_cmp(source_a, source_b) + if tmp == -1: + if scope_cmp(source_a, dst) == -1: + return 1 + else: + return -1 + elif tmp == 1: + if scope_cmp(source_b, dst) == -1: + return 1 + else: + return -1 + + # Rule 3: cannot be easily implemented + # Rule 4: cannot be easily implemented + # Rule 5: does not make sense here + # Rule 6: cannot be implemented + # Rule 7: cannot be implemented + + # Rule 8: Longest prefix match + tmp1 = in6_get_common_plen(source_a, dst) + tmp2 = in6_get_common_plen(source_b, dst) + if tmp1 > tmp2: + return 1 + elif tmp2 > tmp1: + return -1 + return 0 + + if not candidate_set: + # Should not happen + return None + + candidate_set.sort(key=cmp_to_key(rfc3484_cmp), reverse=True) + + return candidate_set[0] + + +def find_ifaddr2(addr, plen, laddr): + dstAddrType = in6_getAddrType(addr) + + if dstAddrType == IPV6_ADDR_UNSPECIFIED: # Shouldn't happen as dst addr + return None + + if dstAddrType == IPV6_ADDR_LOOPBACK: + return None + + #tmp = [[]] + map(lambda (x,y,z): (in6_getAddrType(x), x, y, z), laddr) + tmp = [[]] + map(lambda a: (in6_getAddrType(a[0]), a[0], a[1], a[2]), laddr) + #def filterSameScope(l, t): + # if (t[0] & dstAddrType & IPV6_ADDR_SCOPE_MASK) == 0: + # l.append(t) + # return l + #sameScope = reduce(filterSameScope, tmp) + sameScope = itertools.chain(*[ t for t in tmp if (t[0] & dstAddrType & IPV6_ADDR_SCOPE_MASK) == 0 ]) + + l = len(sameScope) + if l == 1: # Only one address for our scope + return sameScope[0][1] + + elif l > 1: # Muliple addresses for our scope + #stfAddr = filter(lambda x: x[0] & IPV6_ADDR_6TO4, sameScope) + stfAddr = [ x for x in sameScope if x[0] & IPV6_ADDR_6TO4 ] + #nativeAddr = filter(lambda x: not (x[0] & IPV6_ADDR_6TO4), sameScope) + nativeAddr = [ x for x in sameScope if not (x[0] & IPV6_ADDR_6TO4) ] + + if not (dstAddrType & IPV6_ADDR_6TO4): # destination is not 6to4 + if len(nativeAddr) != 0: + return nativeAddr[0][1] + return stfAddr[0][1] + + else: # Destination is 6to4, try to use source 6to4 addr if any + if len(stfAddr) != 0: + return stfAddr[0][1] + return nativeAddr[0][1] + else: + return None + +# Think before modify it : for instance, FE::1 does exist and is unicast +# there are many others like that. +# TODO : integrate Unique Local Addresses +def in6_getAddrType(addr): + naddr = inet_pton(socket.AF_INET6, addr) + paddr = inet_ntop(socket.AF_INET6, naddr) # normalize + addrType = 0 + # _Assignable_ Global Unicast Address space + # is defined in RFC 3513 as those in 2000::/3 + #if ((struct.unpack("B", naddr[0])[0] & 0xE0) == 0x20): + if (((naddr[0]) & 0xE0) == 0x20): + addrType = (IPV6_ADDR_UNICAST | IPV6_ADDR_GLOBAL) + if naddr[:2] == b' \x02': # Mark 6to4 @ + addrType |= IPV6_ADDR_6TO4 + elif naddr[0] == 0xff: # multicast + addrScope = paddr[3] + if addrScope == '2': + addrType = (IPV6_ADDR_LINKLOCAL | IPV6_ADDR_MULTICAST) + elif addrScope == 'e': + addrType = (IPV6_ADDR_GLOBAL | IPV6_ADDR_MULTICAST) + else: + addrType = (IPV6_ADDR_GLOBAL | IPV6_ADDR_MULTICAST) + elif ((naddr[0] == 0xfe) and ((int(paddr[2], 16) & 0xC) == 0x8)): + addrType = (IPV6_ADDR_UNICAST | IPV6_ADDR_LINKLOCAL) + elif paddr == "::1": + addrType = IPV6_ADDR_LOOPBACK + elif paddr == "::": + addrType = IPV6_ADDR_UNSPECIFIED + else: + # Everything else is global unicast (RFC 3513) + # Even old deprecated (RFC3879) Site-Local addresses + addrType = (IPV6_ADDR_GLOBAL | IPV6_ADDR_UNICAST) + + return addrType + +def in6_mactoifaceid(mac, ulbit=None): + """ + Compute the interface ID in modified EUI-64 format associated + to the Ethernet address provided as input. + value taken by U/L bit in the interface identifier is basically + the reversed value of that in given MAC address it can be forced + to a specific value by using optional 'ulbit' parameter. + """ + if len(mac) != 17: return None + m = "".join(mac.split(':')) + if len(m) != 12: return None + first = int(m[0:2], 16) + if ulbit is None or not (ulbit == 0 or ulbit == 1): + ulbit = [1,'-',0][first & 0x02] + ulbit *= 2 + first = "%.02x" % ((first & 0xFD) | ulbit) + eui64 = first + m[2:4] + ":" + m[4:6] + "FF:FE" + m[6:8] + ":" + m[8:12] + return eui64.upper() + +def in6_ifaceidtomac(ifaceid): # TODO: finish commenting function behavior + """ + Extract the mac address from provided iface ID. Iface ID is provided + in printable format ("XXXX:XXFF:FEXX:XXXX", eventually compressed). None + is returned on error. + """ + try: + ifaceid = inet_pton(socket.AF_INET6, "::"+ifaceid)[8:16] + except: + return None + if ifaceid[3:5] != b'\xff\xfe': + return None + first = struct.unpack("B", ifaceid[:1])[0] + ulbit = 2*[1,'-',0][first & 0x02] + first = struct.pack("B", ((first & 0xFD) | ulbit)) + oui = first + ifaceid[1:3] + end = ifaceid[5:] + #l = map(lambda x: "%.02x" % struct.unpack("B", x)[0], list(oui+end)) + l = map(lambda x: "%.02x" % x, list(oui+end)) + return ":".join(l) + +def in6_addrtomac(addr): + """ + Extract the mac address from provided address. None is returned + on error. + """ + mask = inet_pton(socket.AF_INET6, "::ffff:ffff:ffff:ffff") + x = in6_and(mask, inet_pton(socket.AF_INET6, addr)) + ifaceid = inet_ntop(socket.AF_INET6, x)[2:] + return in6_ifaceidtomac(ifaceid) + +def in6_addrtovendor(addr): + """ + Extract the MAC address from a modified EUI-64 constructed IPv6 + address provided and use the IANA oui.txt file to get the vendor. + The database used for the conversion is the one loaded by Scapy, + based on Wireshark (/usr/share/wireshark/wireshark/manuf) None + is returned on error, "UNKNOWN" if the vendor is unknown. + """ + mac = in6_addrtomac(addr) + if mac is None: + return None + + res = conf.manufdb._get_manuf(mac) + if len(res) == 17 and res.count(b':') != 5: # Mac address, i.e. unknown + res = "UNKNOWN" + + return res + +def in6_getLinkScopedMcastAddr(addr, grpid=None, scope=2): + """ + Generate a Link-Scoped Multicast Address as described in RFC 4489. + Returned value is in printable notation. + + 'addr' parameter specifies the link-local address to use for generating + Link-scoped multicast address IID. + + By default, the function returns a ::/96 prefix (aka last 32 bits of + returned address are null). If a group id is provided through 'grpid' + parameter, last 32 bits of the address are set to that value (accepted + formats : '\x12\x34\x56\x78' or '12345678' or 0x12345678 or 305419896). + + By default, generated address scope is Link-Local (2). That value can + be modified by passing a specific 'scope' value as an argument of the + function. RFC 4489 only authorizes scope values <= 2. Enforcement + is performed by the function (None will be returned). + + If no link-local address can be used to generate the Link-Scoped IPv6 + Multicast address, or if another error occurs, None is returned. + """ + if not scope in [0, 1, 2]: + return None + try: + if not in6_islladdr(addr): + return None + addr = inet_pton(socket.AF_INET6, addr) + except: + warning("in6_getLinkScopedMcastPrefix(): Invalid address provided") + return None + + iid = addr[8:] + + if grpid is None: + grpid = b'\x00\x00\x00\x00' + else: + if type(grpid) is str: + grpid = grpid.encode('ascii') + if type(grpid) is bytes: + if len(grpid) == 8: + try: + grpid = int(grpid, 16) & 0xffffffff + except: + warning("in6_getLinkScopedMcastPrefix(): Invalid group id provided") + return None + elif len(grpid) == 4: + try: + grpid = struct.unpack("!I", grpid)[0] + except: + warning("in6_getLinkScopedMcastPrefix(): Invalid group id provided") + return None + grpid = struct.pack("!I", grpid) + + flgscope = struct.pack("B", 0xff & ((0x3 << 4) | scope)) + plen = b'\xff' + res = b'\x00' + a = b'\xff' + flgscope + res + plen + iid + grpid + + return inet_ntop(socket.AF_INET6, a) + +def in6_get6to4Prefix(addr): + """ + Returns the /48 6to4 prefix associated with provided IPv4 address + On error, None is returned. No check is performed on public/private + status of the address + """ + try: + addr = inet_pton(socket.AF_INET, addr) + addr = inet_ntop(socket.AF_INET6, b'\x20\x02'+addr+b'\x00'*10) + except: + return None + return addr + +def in6_6to4ExtractAddr(addr): + """ + Extract IPv4 address embbeded in 6to4 address. Passed address must be + a 6to4 addrees. None is returned on error. + """ + try: + addr = inet_pton(socket.AF_INET6, addr) + except: + return None + if addr[:2] != b" \x02": + return None + return inet_ntop(socket.AF_INET, addr[2:6]) + + +def in6_getLocalUniquePrefix(): + """ + Returns a pseudo-randomly generated Local Unique prefix. Function + follows recommandation of Section 3.2.2 of RFC 4193 for prefix + generation. + """ + # Extracted from RFC 1305 (NTP) : + # NTP timestamps are represented as a 64-bit unsigned fixed-point number, + # in seconds relative to 0h on 1 January 1900. The integer part is in the + # first 32 bits and the fraction part in the last 32 bits. + + # epoch = (1900, 1, 1, 0, 0, 0, 5, 1, 0) + # x = time.time() + # from time import gmtime, strftime, gmtime, mktime + # delta = mktime(gmtime(0)) - mktime(self.epoch) + # x = x-delta + + tod = time.time() # time of day. Will bother with epoch later + i = int(tod) + j = int((tod - i)*(2**32)) + tod = struct.pack("!II", i,j) + # TODO: Add some check regarding system address gathering + rawmac = get_if_raw_hwaddr(conf.iface6) + mac = b":".join(map(lambda x: b"%.02x" % ord(x), list(rawmac))) + # construct modified EUI-64 ID + eui64 = inet_pton(socket.AF_INET6, '::' + in6_mactoifaceid(mac))[8:] + import sha + globalid = sha.new(tod+eui64).digest()[:5] + return inet_ntop(socket.AF_INET6, b'\xfd' + globalid + b'\x00'*10) + +def in6_getRandomizedIfaceId(ifaceid, previous=None): + """ + Implements the interface ID generation algorithm described in RFC 3041. + The function takes the Modified EUI-64 interface identifier generated + as described in RFC 4291 and an optional previous history value (the + first element of the output of this function). If no previous interface + identifier is provided, a random one is generated. The function returns + a tuple containing the randomized interface identifier and the history + value (for possible future use). Input and output values are provided in + a "printable" format as depicted below. + + ex: + + >>> in6_getRandomizedIfaceId('20b:93ff:feeb:2d3') + ('4c61:76ff:f46a:a5f3', 'd006:d540:db11:b092') + + >>> in6_getRandomizedIfaceId('20b:93ff:feeb:2d3', + previous='d006:d540:db11:b092') + ('fe97:46fe:9871:bd38', 'eeed:d79c:2e3f:62e') + """ + + s = [] + if previous is None: + #d = b"".join(map(chr, range(256))) + d = list(range(256)) + for i in range(8): + s.append(random.choice(d)) + s = bytes(s) + previous = s + s = inet_pton(socket.AF_INET6, "::"+ifaceid)[8:] + previous + import hashlib + s = hashlib.md5(s).digest() + s1,s2 = s[:8],s[8:] + s1 = bytes([(s1[0]) | 0x04]) + s1[1:] + s1 = inet_ntop(socket.AF_INET6, b"\xff"*8 + s1)[20:] + s2 = inet_ntop(socket.AF_INET6, b"\xff"*8 + s2)[20:] + return (s1, s2) + + +_rfc1924map = [ '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E', + 'F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T', + 'U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i', + 'j','k','l','m','n','o','p','q','r','s','t','u','v','w','x', + 'y','z','!','#','$','%','&','(',')','*','+','-',';','<','=', + '>','?','@','^','_','`','{','|','}','~' ] + +def in6_ctop(addr): + """ + Convert an IPv6 address in Compact Representation Notation + (RFC 1924) to printable representation ;-) + Returns None on error. + """ + #if len(addr) != 20 or not reduce(lambda x,y: x and y, map(lambda x: x in _rfc1924map, addr)): + if len(addr) != 20 or not all(map(lambda x: x in _rfc1924map, addr)): + return None + i = 0 + for c in addr: + j = _rfc1924map.index(c) + i = 85*i + j + res = [] + for j in range(4): + res.append(struct.pack("!I", i%2**32)) + i = i//(2**32) + res.reverse() + return inet_ntop(socket.AF_INET6, b"".join(res)) + +def in6_ptoc(addr): + """ + Converts an IPv6 address in printable representation to RFC + 1924 Compact Representation ;-) + Returns None on error. + """ + try: + d=struct.unpack("!IIII", inet_pton(socket.AF_INET6, addr)) + except: + return None + res = 0 + m = [2**96, 2**64, 2**32, 1] + for i in range(4): + res += d[i]*m[i] + rem = res + res = [] + while rem: + res.append(_rfc1924map[rem%85]) + rem = rem//85 + res.reverse() + return "".join(res) + + +def in6_isaddr6to4(x): + """ + Return True if provided address (in printable format) is a 6to4 + address (being in 2002::/16). + """ + x = inet_pton(socket.AF_INET6, x) + return x[:2] == ' \x02' + +conf.teredoPrefix = "2001::" # old one was 3ffe:831f (it is a /32) +conf.teredoServerPort = 3544 + +def in6_isaddrTeredo(x): + """ + Return True if provided address is a Teredo, meaning it is under + the /32 conf.teredoPrefix prefix value (by default, 2001::). + Otherwise, False is returned. Address must be passed in printable + format. + """ + our = inet_pton(socket.AF_INET6, x)[0:4] + teredoPrefix = inet_pton(socket.AF_INET6, conf.teredoPrefix)[0:4] + return teredoPrefix == our + +def teredoAddrExtractInfo(x): + """ + Extract information from a Teredo address. Return value is + a 4-tuple made of IPv4 address of Teredo server, flag value (int), + mapped address (non obfuscated) and mapped port (non obfuscated). + No specific checks are performed on passed address. + """ + addr = inet_pton(socket.AF_INET6, x) + server = inet_ntop(socket.AF_INET, addr[4:8]) + flag = struct.unpack("!H",addr[8:10])[0] + mappedport = struct.unpack("!H",strxor(addr[10:12],b'\xff'*2))[0] + mappedaddr = inet_ntop(socket.AF_INET, strxor(addr[12:16],b'\xff'*4)) + return server, flag, mappedaddr, mappedport + +def in6_iseui64(x): + """ + Return True if provided address has an interface identifier part + created in modified EUI-64 format (meaning it matches *::*:*ff:fe*:*). + Otherwise, False is returned. Address must be passed in printable + format. + """ + eui64 = inet_pton(socket.AF_INET6, '::ff:fe00:0') + x = in6_and(inet_pton(socket.AF_INET6, x), eui64) + return x == eui64 + +def in6_isanycast(x): # RFC 2526 + if in6_iseui64(x): + s = '::fdff:ffff:ffff:ff80' + packed_x = inet_pton(socket.AF_INET6, x) + packed_s = inet_pton(socket.AF_INET6, s) + x_and_s = in6_and(packed_x, packed_s) + return x_and_s == packed_s + else: + # not EUI-64 + #| n bits | 121-n bits | 7 bits | + #+---------------------------------+------------------+------------+ + #| subnet prefix | 1111111...111111 | anycast ID | + #+---------------------------------+------------------+------------+ + # | interface identifier field | + warning('in6_isanycast(): TODO not EUI-64') + return 0 + +def _in6_bitops(a1, a2, operator=0): + a1 = struct.unpack('4I', a1) + a2 = struct.unpack('4I', a2) + fop = [ lambda x,y: x | y, + lambda x,y: x & y, + lambda x,y: x ^ y + ] + ret = map(fop[operator%len(fop)], a1, a2) + t = b''.join(map(lambda x: struct.pack('I', x), ret)) + return t + +def in6_or(a1, a2): + """ + Provides a bit to bit OR of provided addresses. They must be + passed in network format. Return value is also an IPv6 address + in network format. + """ + return _in6_bitops(a1, a2, 0) + +def in6_and(a1, a2): + """ + Provides a bit to bit AND of provided addresses. They must be + passed in network format. Return value is also an IPv6 address + in network format. + """ + return _in6_bitops(a1, a2, 1) + +def in6_xor(a1, a2): + """ + Provides a bit to bit XOR of provided addresses. They must be + passed in network format. Return value is also an IPv6 address + in network format. + """ + return _in6_bitops(a1, a2, 2) + +def in6_cidr2mask(m): + """ + Return the mask (bitstring) associated with provided length + value. For instance if function is called on 48, return value is + '\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'. + + """ + if m > 128 or m < 0: + raise Scapy_Exception("value provided to in6_cidr2mask outside [0, 128] domain (%d)" % m) + + t = [] + for i in range(0, 4): + t.append(max(0, 2**32 - 2**(32-min(32, m)))) + m -= 32 + + return b"".join([ struct.pack('!I', i) for i in t ]) + +def in6_getnsma(a): + """ + Return link-local solicited-node multicast address for given + address. Passed address must be provided in network format. + Returned value is also in network format. + """ + + r = in6_and(a, inet_pton(socket.AF_INET6, '::ff:ffff')) + r = in6_or(inet_pton(socket.AF_INET6, 'ff02::1:ff00:0'), r) + return r + +def in6_getnsmac(a): # return multicast Ethernet address associated with multicast v6 destination + """ + Return the multicast mac address associated with provided + IPv6 address. Passed address must be in network format. + """ + + a = struct.unpack('16B', a)[-4:] + mac = '33:33:' + mac += (':'.join(map(lambda x: '%.2x' %x, a))) + return mac + +def in6_getha(prefix): + """ + Return the anycast address associated with all home agents on a given + subnet. + """ + r = in6_and(inet_pton(socket.AF_INET6, prefix), in6_cidr2mask(64)) + r = in6_or(r, inet_pton(socket.AF_INET6, '::fdff:ffff:ffff:fffe')) + return inet_ntop(socket.AF_INET6, r) + +def in6_ptop(s): + """ + Normalizes IPv6 addresses provided in printable format, returning the + same address in printable format. (2001:0db8:0:0::1 -> 2001:db8::1) + """ + return inet_ntop(socket.AF_INET6, inet_pton(socket.AF_INET6, s)) + +def in6_isincluded(addr, prefix, plen): + """ + Returns True when 'addr' belongs to prefix/plen. False otherwise. + """ + temp = inet_pton(socket.AF_INET6, addr) + pref = in6_cidr2mask(plen) + zero = inet_pton(socket.AF_INET6, prefix) + return zero == in6_and(temp, pref) + +def in6_isdocaddr(s): + """ + Returns True if provided address in printable format belongs to + 2001:db8::/32 address space reserved for documentation (as defined + in RFC 3849). + """ + return in6_isincluded(s, '2001:db8::', 32) + +def in6_islladdr(s): + """ + Returns True if provided address in printable format belongs to + _allocated_ link-local unicast address space (fe80::/10) + """ + return in6_isincluded(s, 'fe80::', 10) + +def in6_issladdr(s): + """ + Returns True if provided address in printable format belongs to + _allocated_ site-local address space (fec0::/10). This prefix has + been deprecated, address being now reserved by IANA. Function + will remain for historic reasons. + """ + return in6_isincluded(s, 'fec0::', 10) + +def in6_isuladdr(s): + """ + Returns True if provided address in printable format belongs to + Unique local address space (fc00::/7). + """ + return in6_isincluded(s, 'fc00::', 7) + +# TODO : we should see the status of Unique Local addresses against +# global address space. +# Up-to-date information is available through RFC 3587. +# We should review function behavior based on its content. +def in6_isgladdr(s): + """ + Returns True if provided address in printable format belongs to + _allocated_ global address space (2000::/3). Please note that, + Unique Local addresses (FC00::/7) are not part of global address + space, and won't match. + """ + return in6_isincluded(s, '2000::', 3) + +def in6_ismaddr(s): + """ + Returns True if provided address in printable format belongs to + allocated Multicast address space (ff00::/8). + """ + return in6_isincluded(s, 'ff00::', 8) + +def in6_ismnladdr(s): + """ + Returns True if address belongs to node-local multicast address + space (ff01::/16) as defined in RFC + """ + return in6_isincluded(s, 'ff01::', 16) + +def in6_ismgladdr(s): + """ + Returns True if address belongs to global multicast address + space (ff0e::/16). + """ + return in6_isincluded(s, 'ff0e::', 16) + +def in6_ismlladdr(s): + """ + Returns True if address belongs to link-local multicast address + space (ff02::/16) + """ + return in6_isincluded(s, 'ff02::', 16) + +def in6_ismsladdr(s): + """ + Returns True if address belongs to site-local multicast address + space (ff05::/16). Site local address space has been deprecated. + Function remains for historic reasons. + """ + return in6_isincluded(s, 'ff05::', 16) + +def in6_isaddrllallnodes(s): + """ + Returns True if address is the link-local all-nodes multicast + address (ff02::1). + """ + return (inet_pton(socket.AF_INET6, "ff02::1") == + inet_pton(socket.AF_INET6, s)) + +def in6_isaddrllallservers(s): + """ + Returns True if address is the link-local all-servers multicast + address (ff02::2). + """ + return (inet_pton(socket.AF_INET6, "ff02::2") == + inet_pton(socket.AF_INET6, s)) + +def in6_getscope(addr): + """ + Returns the scope of the address. + """ + if in6_isgladdr(addr) or in6_isuladdr(addr): + scope = IPV6_ADDR_GLOBAL + elif in6_islladdr(addr): + scope = IPV6_ADDR_LINKLOCAL + elif in6_issladdr(addr): + scope = IPV6_ADDR_SITELOCAL + elif in6_ismaddr(addr): + if in6_ismgladdr(addr): + scope = IPV6_ADDR_GLOBAL + elif in6_ismlladdr(addr): + scope = IPV6_ADDR_LINKLOCAL + elif in6_ismsladdr(addr): + scope = IPV6_ADDR_SITELOCAL + elif in6_ismnladdr(addr): + scope = IPV6_ADDR_LOOPBACK + else: + scope = -1 + elif addr == '::1': + scope = IPV6_ADDR_LOOPBACK + else: + scope = -1 + return scope + +def in6_get_common_plen(a, b): + """ + Return common prefix length of IPv6 addresses a and b. + """ + def matching_bits(byte1, byte2): + for i in range(8): + cur_mask = 0x80 >> i + if (byte1 & cur_mask) != (byte2 & cur_mask): + return i + return 8 + + tmpA = inet_pton(socket.AF_INET6, a) + tmpB = inet_pton(socket.AF_INET6, b) + for i in range(16): + #mbits = matching_bits(ord(tmpA[i]), ord(tmpB[i])) + mbits = matching_bits((tmpA[i]), (tmpB[i])) + if mbits != 8: + return 8*i + mbits + return 128 diff --git a/scripts/external_libs/scapy-python3-0.18/scapy/volatile.py b/scripts/external_libs/scapy-python3-0.18/scapy/volatile.py new file mode 100644 index 00000000..ed5c26e4 --- /dev/null +++ b/scripts/external_libs/scapy-python3-0.18/scapy/volatile.py @@ -0,0 +1,685 @@ +## This file is part of Scapy +## See http://www.secdev.org/projects/scapy for more informations +## Copyright (C) Philippe Biondi <phil@secdev.org> +## This program is published under a GPLv2 license + +""" +Fields that hold random numbers. +""" + +import random,time,math +from .base_classes import Net +from .utils import corrupt_bits,corrupt_bytes + +#################### +## Random numbers ## +#################### + + +class RandomEnumeration: + """iterate through a sequence in random order. + When all the values have been drawn, if forever=1, the drawing is done again. + If renewkeys=0, the draw will be in the same order, guaranteeing that the same + number will be drawn in not less than the number of integers of the sequence""" + def __init__(self, inf, sup, seed=None, forever=1, renewkeys=0): + self.forever = forever + self.renewkeys = renewkeys + self.inf = inf + self.rnd = random.Random(seed) + self.sbox_size = 256 + + self.top = sup-inf+1 + + n=0 + while (1<<n) < self.top: + n += 1 + self.n =n + + self.fs = min(3,(n+1)//2) + self.fsmask = 2**self.fs-1 + self.rounds = max(self.n,3) + self.turns = 0 + self.i = 0 + + def __iter__(self): + return self + def __next__(self): + while True: + if self.turns == 0 or (self.i == 0 and self.renewkeys): + self.cnt_key = self.rnd.randint(0,2**self.n-1) + self.sbox = [self.rnd.randint(0,self.fsmask) for k in range(self.sbox_size)] + self.turns += 1 + while self.i < 2**self.n: + ct = self.i^self.cnt_key + self.i += 1 + for k in range(self.rounds): # Unbalanced Feistel Network + lsb = ct & self.fsmask + ct >>= self.fs + lsb ^= self.sbox[ct%self.sbox_size] + ct |= lsb << (self.n-self.fs) + + if ct < self.top: + return self.inf+ct + self.i = 0 + if not self.forever: + raise StopIteration + +class _MetaVolatile(type): + def __init__(cls, name, bases, dct): + def special_gen(special_method): + def special_wrapper(self): + return getattr(getattr(self, "_fix")(), special_method) + return special_wrapper + + #This is from scapy2 code. Usage places should be identified and fixed as there is no more __cmp__ in python3 + # if attr == "__cmp__": + # x = self._fix() + # def cmp2(y,x=x): + # if type(x) != type(y): + # return -1 + # return x.__cmp__(y) + # return cmp2 + + type.__init__(cls, name, bases, dct) + for i in ["__int__", "__repr__", "__str__", "__index__", "__add__", "__radd__", "__bytes__","__mul__","__rmul__"]: + setattr(cls, i, property(special_gen(i))) + + +class VolatileValue(metaclass = _MetaVolatile): + def __repr__(self): + return "<%s>" % self.__class__.__name__ + def __getattr__(self, attr): + if attr == "__setstate__": + raise AttributeError("__setstate__") + return getattr(self._fix(),attr) + def _fix(self): + return None + + +class RandField(VolatileValue): + pass + +class RandNum(RandField): + """Instances evaluate to random integers in selected range""" + min = 0 + max = 0 + def __init__(self, min, max): + self.min = min + self.max = max + def _fix(self): + return random.randrange(self.min, self.max+1) + +class RandNumGamma(RandField): + def __init__(self, alpha, beta): + self.alpha = alpha + self.beta = beta + def _fix(self): + return int(round(random.gammavariate(self.alpha, self.beta))) + +class RandNumGauss(RandField): + def __init__(self, mu, sigma): + self.mu = mu + self.sigma = sigma + def _fix(self): + return int(round(random.gauss(self.mu, self.sigma))) + +class RandNumExpo(RandField): + def __init__(self, lambd, base=0): + self.lambd = lambd + self.base = base + def _fix(self): + return self.base+int(round(random.expovariate(self.lambd))) + +class RandEnum(RandNum): + """Instances evaluate to integer sampling without replacement from the given interval""" + def __init__(self, min, max): + self.seq = RandomEnumeration(min,max) + def _fix(self): + return next(self.seq) + +class RandByte(RandNum): + def __init__(self): + RandNum.__init__(self, 0, 2**8-1) + +class RandSByte(RandNum): + def __init__(self): + RandNum.__init__(self, -2**7, 2**7-1) + +class RandShort(RandNum): + def __init__(self): + RandNum.__init__(self, 0, 2**16-1) + +class RandSShort(RandNum): + def __init__(self): + RandNum.__init__(self, -2**15, 2**15-1) + +class RandInt(RandNum): + def __init__(self): + RandNum.__init__(self, 0, 2**32-1) + +class RandSInt(RandNum): + def __init__(self): + RandNum.__init__(self, -2**31, 2**31-1) + +class RandLong(RandNum): + def __init__(self): + RandNum.__init__(self, 0, 2**64-1) + +class RandSLong(RandNum): + def __init__(self): + RandNum.__init__(self, -2**63, 2**63-1) + +class RandEnumByte(RandEnum): + def __init__(self): + RandEnum.__init__(self, 0, 2**8-1) + +class RandEnumSByte(RandEnum): + def __init__(self): + RandEnum.__init__(self, -2**7, 2**7-1) + +class RandEnumShort(RandEnum): + def __init__(self): + RandEnum.__init__(self, 0, 2**16-1) + +class RandEnumSShort(RandEnum): + def __init__(self): + RandEnum.__init__(self, -2**15, 2**15-1) + +class RandEnumInt(RandEnum): + def __init__(self): + RandEnum.__init__(self, 0, 2**32-1) + +class RandEnumSInt(RandEnum): + def __init__(self): + RandEnum.__init__(self, -2**31, 2**31-1) + +class RandEnumLong(RandEnum): + def __init__(self): + RandEnum.__init__(self, 0, 2**64-1) + +class RandEnumSLong(RandEnum): + def __init__(self): + RandEnum.__init__(self, -2**63, 2**63-1) + +class RandChoice(RandField): + def __init__(self, *args): + if not args: + raise TypeError("RandChoice needs at least one choice") + self._choice = args + def _fix(self): + return random.choice(self._choice) + +class RandString(RandField): + def __init__(self, size=None, chars=b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"): + if size is None: + size = RandNumExpo(0.01) + self.size = size + self.chars = chars + def _fix(self): + s = [] + for i in range(self.size): + s.append(random.choice(self.chars)) + return bytes(s) + +class RandBin(RandString): + def __init__(self, size=None): + #RandString.__init__(self, size, b"".join(map(chr,range(256)))) + RandString.__init__(self, size, b"".join([bytes([i]) for i in range(256)])) + + +class RandTermString(RandString): + def __init__(self, size, term): + #RandString.__init__(self, size, b"".join(map(chr,range(1,256)))) + RandString.__init__(self, size, bytes([i for i in range(1,256)])) + self.term = term + def _fix(self): + return RandString._fix(self)+self.term + + +class RandIP(RandString): + def __init__(self, iptemplate="0.0.0.0/0"): + self.ip = Net(iptemplate) + def _fix(self): + return self.ip.choice() + +class RandMAC(RandString): + def __init__(self, template="*"): + template += ":*:*:*:*:*" + template = template.split(":") + self.mac = () + for i in range(6): + if template[i] == "*": + v = RandByte() + elif "-" in template[i]: + x,y = template[i].split("-") + v = RandNum(int(x,16), int(y,16)) + else: + v = int(template[i],16) + self.mac += (v,) + def _fix(self): + return "%02x:%02x:%02x:%02x:%02x:%02x" % self.mac + +class RandIP6(RandString): + def __init__(self, ip6template="**"): + self.tmpl = ip6template + self.sp = self.tmpl.split(":") + for i,v in enumerate(self.sp): + if not v or v == "**": + continue + if "-" in v: + a,b = v.split("-") + elif v == "*": + a=b="" + else: + a=b=v + + if not a: + a = "0" + if not b: + b = "ffff" + if a==b: + self.sp[i] = int(a,16) + else: + self.sp[i] = RandNum(int(a,16), int(b,16)) + self.variable = "" in self.sp + self.multi = self.sp.count("**") + def _fix(self): + done = 0 + nbm = self.multi + ip = [] + for i,n in enumerate(self.sp): + if n == "**": + nbm -= 1 + remain = 8-(len(self.sp)-i-1)-len(ip)+nbm + if "" in self.sp: + remain += 1 + if nbm or self.variable: + remain = random.randint(0,remain) + for j in range(remain): + ip.append("%04x" % random.randint(0,65535)) + elif n == 0: + ip.append("0") + elif not n: + ip.append("") + else: + ip.append("%04x" % n) + if len(ip) == 9: + ip.remove("") + if ip[-1] == "": + ip[-1] = 0 + return ":".join(ip) + +class RandOID(RandString): + def __init__(self, fmt=None, depth=RandNumExpo(0.1), idnum=RandNumExpo(0.01)): + self.ori_fmt = fmt + if fmt is not None: + fmt = fmt.split(".") + for i in range(len(fmt)): + if "-" in fmt[i]: + fmt[i] = tuple(map(int, fmt[i].split("-"))) + self.fmt = fmt + self.depth = depth + self.idnum = idnum + def __repr__(self): + if self.ori_fmt is None: + return "<%s>" % self.__class__.__name__ + else: + return "<%s [%s]>" % (self.__class__.__name__, self.ori_fmt) + def _fix(self): + if self.fmt is None: + return ".".join(map(str, [self.idnum for i in range(1+self.depth)])) + else: + oid = [] + for i in self.fmt: + if i == "*": + oid.append(str(self.idnum)) + elif i == "**": + oid += map(str, [self.idnum for i in range(1+self.depth)]) + elif type(i) is tuple: + oid.append(str(random.randrange(*i))) + else: + oid.append(i) + return ".".join(oid) + + +class RandRegExp(RandField): + def __init__(self, regexp, lambda_=0.3,): + self._regexp = regexp + self._lambda = lambda_ + + @staticmethod + def choice_expand(s): #XXX does not support special sets like (ex ':alnum:') + m = "" + invert = s and s[0] == "^" + while True: + p = s.find("-") + if p < 0: + break + if p == 0 or p == len(s)-1: + m = "-" + if p: + s = s[:-1] + else: + s = s[1:] + else: + c1 = s[p-1] + c2 = s[p+1] + rng = "".join(map(chr, range(ord(c1),ord(c2)+1))) + s = s[:p-1]+rng+s[p+1:] + res = m+s + if invert: + res = "".join([chr(x) for x in range(256) if chr(x) not in res]) + return res + + @staticmethod + def stack_fix(lst, index): + r = "" + mul = 1 + for e in lst: + if type(e) is list: + if mul != 1: + mul = mul-1 + r += RandRegExp.stack_fix(e[1:]*mul, index) + # only the last iteration should be kept for back reference + f = RandRegExp.stack_fix(e[1:], index) + for i,idx in enumerate(index): + if e is idx: + index[i] = f + r += f + mul = 1 + elif type(e) is tuple: + kind,val = e + if kind == "cite": + r += index[val-1] + elif kind == "repeat": + mul = val + + elif kind == "choice": + if mul == 1: + c = random.choice(val) + r += RandRegExp.stack_fix(c[1:], index) + else: + r += RandRegExp.stack_fix([e]*mul, index) + mul = 1 + else: + if mul != 1: + r += RandRegExp.stack_fix([e]*mul, index) + mul = 1 + else: + r += str(e) + return r + + def _fix(self): + stack = [None] + index = [] + current = stack + i = 0 + ln = len(self._regexp) + interp = True + while i < ln: + c = self._regexp[i] + i+=1 + + if c == '(': + current = [current] + current[0].append(current) + elif c == '|': + p = current[0] + ch = p[-1] + if type(ch) is not tuple: + ch = ("choice",[current]) + p[-1] = ch + else: + ch[1].append(current) + current = [p] + elif c == ')': + ch = current[0][-1] + if type(ch) is tuple: + ch[1].append(current) + index.append(current) + current = current[0] + elif c == '[' or c == '{': + current = [current] + current[0].append(current) + interp = False + elif c == ']': + current = current[0] + choice = RandRegExp.choice_expand("".join(current.pop()[1:])) + current.append(RandChoice(*list(choice))) + interp = True + elif c == '}': + current = current[0] + num = "".join(current.pop()[1:]) + e = current.pop() + if "," not in num: + n = int(num) + current.append([current]+[e]*n) + else: + num_min,num_max = num.split(",") + if not num_min: + num_min = "0" + if num_max: + n = RandNum(int(num_min),int(num_max)) + else: + n = RandNumExpo(self._lambda,base=int(num_min)) + current.append(("repeat",n)) + current.append(e) + interp = True + elif c == '\\': + c = self._regexp[i] + if c == "s": + c = RandChoice(" ","\t") + elif c in "0123456789": + c = ("cite",ord(c)-0x30) + current.append(c) + i += 1 + elif not interp: + current.append(c) + elif c == '+': + e = current.pop() + current.append([current]+[e]*(int(random.expovariate(self._lambda))+1)) + elif c == '*': + e = current.pop() + current.append([current]+[e]*int(random.expovariate(self._lambda))) + elif c == '?': + if random.randint(0,1): + current.pop() + elif c == '.': + current.append(RandChoice(*[chr(x) for x in range(256)])) + elif c == '$' or c == '^': + pass + else: + current.append(c) + + return RandRegExp.stack_fix(stack[1:], index) + def __repr__(self): + return "<%s [%r]>" % (self.__class__.__name__, self._regexp) + +class RandSingularity(RandChoice): + pass + +class RandSingNum(RandSingularity): + @staticmethod + def make_power_of_two(end): + sign = 1 + if end == 0: + end = 1 + if end < 0: + end = -end + sign = -1 + end_n = int(math.log(end)/math.log(2))+1 + return set([sign*2**i for i in range(end_n)]) + + def __init__(self, mn, mx): + sing = set([0, mn, mx, int((mn+mx)/2)]) + sing |= self.make_power_of_two(mn) + sing |= self.make_power_of_two(mx) + for i in sing.copy(): + sing.add(i+1) + sing.add(i-1) + for i in sing.copy(): + if not mn <= i <= mx: + sing.remove(i) + self._choice = list(sing) + + +class RandSingByte(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, 0, 2**8-1) + +class RandSingSByte(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, -2**7, 2**7-1) + +class RandSingShort(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, 0, 2**16-1) + +class RandSingSShort(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, -2**15, 2**15-1) + +class RandSingInt(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, 0, 2**32-1) + +class RandSingSInt(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, -2**31, 2**31-1) + +class RandSingLong(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, 0, 2**64-1) + +class RandSingSLong(RandSingNum): + def __init__(self): + RandSingNum.__init__(self, -2**63, 2**63-1) + +class RandSingString(RandSingularity): #TODO3 + def __init__(self): + self._choice = [ b"", + b"%x", + b"%%", + b"%s", + b"%i", + b"%n", + b"%x%x%x%x%x%x%x%x%x", + b"%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", + b"%", + b"%%%", + b"A"*4096, + b"\x00"*4096, + b"\xff"*4096, + b"\x7f"*4096, + b"\x80"*4096, + b" "*4096, + b"\\"*4096, + b"("*4096, + b"../"*1024, + b"/"*1024, + b"${HOME}"*512, + b" or 1=1 --", + b"' or 1=1 --", + b'" or 1=1 --', + b" or 1=1; #", + b"' or 1=1; #", + b'" or 1=1; #', + b";reboot;", + b"$(reboot)", + b"`reboot`", + b"index.php%00", + b"\x00", + b"%00", + b"\\", + b"../../../../../../../../../../../../../../../../../etc/passwd", + b"%2e%2e%2f" * 20 + b"etc/passwd", + b"%252e%252e%252f" * 20 + b"boot.ini", + b"..%c0%af" * 20 + b"etc/passwd", + b"..%c0%af" * 20 + b"boot.ini", + b"//etc/passwd", + br"..\..\..\..\..\..\..\..\..\..\..\..\..\..\..\..\..\boot.ini", + b"AUX:", + b"CLOCK$", + b"COM:", + b"CON:", + b"LPT:", + b"LST:", + b"NUL:", + b"CON:", + br"C:\CON\CON", + br"C:\boot.ini", + br"\\myserver\share", + b"foo.exe:", + b"foo.exe\\", ] + + +class RandPool(RandField): + def __init__(self, *args): + """Each parameter is a volatile object or a couple (volatile object, weight)""" + pool = [] + for p in args: + w = 1 + if type(p) is tuple: + p,w = p + pool += [p]*w + self._pool = pool + def _fix(self): + r = random.choice(self._pool) + return r._fix() + +# Automatic timestamp + +class AutoTime(VolatileValue): + def __init__(self, base=None): + if base == None: + self.diff = 0 + else: + self.diff = time.time()-base + def _fix(self): + return time.time()-self.diff + +class IntAutoTime(AutoTime): + def _fix(self): + return int(time.time()-self.diff) + + +class ZuluTime(AutoTime): + def __init__(self, diff=0): + self.diff=diff + def _fix(self): + return time.strftime("%y%m%d%H%M%SZ",time.gmtime(time.time()+self.diff)) + + +class DelayedEval(VolatileValue): + """ Example of usage: DelayedEval("time.time()") """ + def __init__(self, expr): + self.expr = expr + def _fix(self): + return eval(self.expr) + + +class IncrementalValue(VolatileValue): + def __init__(self, start=0, step=1, restart=-1): + self.start = self.val = start + self.step = step + self.restart = restart + def _fix(self): + v = self.val + if self.val == self.restart : + self.val = self.start + else: + self.val += self.step + return v + +class CorruptedBytes(VolatileValue): + def __init__(self, s, p=0.01, n=None): + self.s = s + self.p = p + self.n = n + def _fix(self): + return corrupt_bytes(self.s, p = self.p, n = self.n) + +class CorruptedBits(CorruptedBytes): + def _fix(self): + return corrupt_bits(self.s, p = self.p, n = self.n) + diff --git a/scripts/external_libs/scapy3-0.18-origin.rar b/scripts/external_libs/scapy3-0.18-origin.rar Binary files differnew file mode 100644 index 00000000..0fda86fa --- /dev/null +++ b/scripts/external_libs/scapy3-0.18-origin.rar |