303 lines
9.7 KiB
Python
303 lines
9.7 KiB
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
|
|
|
|
"""
|
|
SuperSocket.
|
|
"""
|
|
|
|
from __future__ import absolute_import
|
|
import os
|
|
import socket
|
|
import subprocess
|
|
import struct
|
|
import time
|
|
|
|
from scapy.config import conf
|
|
from scapy.consts import LINUX, OPENBSD, BSD, DARWIN, WINDOWS
|
|
from scapy.data import *
|
|
from scapy.compat import *
|
|
from scapy.error import warning, log_runtime
|
|
import scapy.modules.six as six
|
|
import scapy.packet
|
|
from scapy.utils import PcapReader, tcpdump
|
|
|
|
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(six.with_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 = raw(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 = True
|
|
if hasattr(self, "outs"):
|
|
if not hasattr(self, "ins") or self.ins != self.outs:
|
|
if self.outs and self.outs.fileno() != -1:
|
|
self.outs.close()
|
|
if hasattr(self, "ins"):
|
|
if self.ins and self.ins.fileno() != -1:
|
|
self.ins.close()
|
|
def sr(self, *args, **kargs):
|
|
from scapy import sendrecv
|
|
return sendrecv.sndrcv(self, *args, **kargs)
|
|
def sr1(self, *args, **kargs):
|
|
from scapy import sendrecv
|
|
a,b = sendrecv.sndrcv(self, *args, **kargs)
|
|
if len(a) > 0:
|
|
return a[0][1]
|
|
else:
|
|
return None
|
|
def sniff(self, *args, **kargs):
|
|
from scapy import sendrecv
|
|
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 scapy.arch import get_last_packet_timestamp
|
|
pkt.time = get_last_packet_timestamp(self.ins)
|
|
return pkt
|
|
def send(self, x):
|
|
try:
|
|
sx = raw(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 around 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)
|
|
from scapy.packet import NoPayload
|
|
while pad is not None and not isinstance(pad, NoPayload):
|
|
x -= len(pad.load)
|
|
pad = pad.payload
|
|
self.ins.recv(x)
|
|
return pkt
|
|
|
|
class SSLStreamSocket(StreamSocket):
|
|
desc = "similar usage than StreamSocket but specialized for handling SSL-wrapped sockets"
|
|
|
|
def __init__(self, sock, basecls=None):
|
|
self._buf = b""
|
|
super(SSLStreamSocket, self).__init__(sock, basecls)
|
|
|
|
#65535, the default value of x is the maximum length of a TLS record
|
|
def recv(self, x=65535):
|
|
pkt = None
|
|
if self._buf != b"":
|
|
try:
|
|
pkt = self.basecls(self._buf)
|
|
except:
|
|
# We assume that the exception is generated by a buffer underflow
|
|
pass
|
|
|
|
if not pkt:
|
|
buf = self.ins.recv(x)
|
|
if len(buf) == 0:
|
|
raise socket.error((100,"Underlying stream socket tore down"))
|
|
self._buf += buf
|
|
|
|
x = len(self._buf)
|
|
pkt = self.basecls(self._buf)
|
|
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, scapy.packet.NoPayload):
|
|
x -= len(pad.load)
|
|
pad = pad.payload
|
|
self._buf = self._buf[x:]
|
|
return pkt
|
|
|
|
|
|
class L2ListenTcpdump(SuperSocket):
|
|
desc = "read packets at layer 2 using tcpdump"
|
|
|
|
def __init__(self, iface=None, promisc=None, filter=None, nofilter=False,
|
|
prog=None, *arg, **karg):
|
|
self.outs = None
|
|
args = ['-w', '-', '-s', '65535']
|
|
if iface is not None:
|
|
if WINDOWS:
|
|
try:
|
|
args.extend(['-i', iface.pcap_name])
|
|
except AttributeError:
|
|
args.extend(['-i', iface])
|
|
else:
|
|
args.extend(['-i', iface])
|
|
elif WINDOWS or DARWIN:
|
|
args.extend(['-i', conf.iface.pcap_name if WINDOWS else conf.iface])
|
|
if not promisc:
|
|
args.append('-p')
|
|
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:
|
|
args.append(filter)
|
|
self.tcpdump_proc = tcpdump(None, prog=prog, args=args, getproc=True)
|
|
self.ins = PcapReader(self.tcpdump_proc.stdout)
|
|
def recv(self, x=MTU):
|
|
return self.ins.recv(x)
|
|
def close(self):
|
|
SuperSocket.close(self)
|
|
self.tcpdump_proc.kill()
|
|
|
|
|
|
class TunTapInterface(SuperSocket):
|
|
"""A socket to act as the host's peer of a tun / tap interface.
|
|
|
|
"""
|
|
desc = "Act as the host's peer of a tun / tap interface"
|
|
|
|
def __init__(self, iface=None, mode_tun=None, *arg, **karg):
|
|
self.iface = conf.iface if iface is None else iface
|
|
self.mode_tun = ("tun" in iface) if mode_tun is None else mode_tun
|
|
self.closed = True
|
|
self.open()
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __del__(self):
|
|
self.close()
|
|
|
|
def __exit__(self, *_):
|
|
self.close()
|
|
|
|
def open(self):
|
|
"""Open the TUN or TAP device."""
|
|
if not self.closed:
|
|
return
|
|
self.outs = self.ins = open(
|
|
"/dev/net/tun" if LINUX else ("/dev/%s" % self.iface), "r+b",
|
|
buffering=0
|
|
)
|
|
if LINUX:
|
|
from fcntl import ioctl
|
|
# TUNSETIFF = 0x400454ca
|
|
# IFF_TUN = 0x0001
|
|
# IFF_TAP = 0x0002
|
|
# IFF_NO_PI = 0x1000
|
|
ioctl(self.ins, 0x400454ca, struct.pack(
|
|
"16sH", raw(self.iface), 0x0001 if self.mode_tun else 0x1002,
|
|
))
|
|
self.closed = False
|
|
|
|
def __call__(self, *arg, **karg):
|
|
"""Needed when using an instantiated TunTapInterface object for
|
|
conf.L2listen, conf.L2socket or conf.L3socket.
|
|
|
|
"""
|
|
return self
|
|
|
|
def recv(self, x=MTU):
|
|
if self.mode_tun:
|
|
data = os.read(self.ins.fileno(), x + 4)
|
|
proto = struct.unpack('!H', data[2:4])[0]
|
|
return conf.l3types.get(proto, conf.raw_layer)(data[4:])
|
|
return conf.l2types.get(1, conf.raw_layer)(
|
|
os.read(self.ins.fileno(), x)
|
|
)
|
|
|
|
def send(self, x):
|
|
sx = raw(x)
|
|
if hasattr(x, "sent_time"):
|
|
x.sent_time = time.time()
|
|
if self.mode_tun:
|
|
try:
|
|
proto = conf.l3types[type(x)]
|
|
except KeyError:
|
|
log_runtime.warning(
|
|
"Cannot find layer 3 protocol value to send %s in "
|
|
"conf.l3types, using 0",
|
|
x.name if hasattr(x, "name") else type(x).__name__
|
|
)
|
|
proto = 0
|
|
sx = struct.pack('!HH', 0, proto) + sx
|
|
try:
|
|
os.write(self.outs.fileno(), sx)
|
|
except socket.error:
|
|
log_runtime.error("%s send", self.__class__.__name__, exc_info=True)
|
|
|
|
|
|
if conf.L3socket is None:
|
|
conf.L3socket = L3RawSocket
|