Fix sr() on multiple interfaces

Author: gpotter2

scapy/arch/bpf/supersocket.py

@@ -115,7 +115,7 @@ def __init__(self,
             )
 
         self.fd_flags = None  # type: Optional[int]
-        self.assigned_interface = None
+        self.type = type
 
         # SuperSocket mandatory variables
         if promisc is None:
@@ -155,7 +155,6 @@ def __init__(self,
             )
         except IOError:
             raise Scapy_Exception("BIOCSETIF failed on %s" % self.iface)
-        self.assigned_interface = self.iface
 
         # Set the interface into promiscuous
         if self.promisc:
@@ -466,6 +465,25 @@ def nonblock_recv(self):
 
 class L3bpfSocket(L2bpfSocket):
 
+    def __init__(self,
+                 iface=None,  # type: Optional[_GlobInterfaceType]
+                 type=ETH_P_ALL,  # type: int
+                 promisc=None,  # type: Optional[bool]
+                 filter=None,  # type: Optional[str]
+                 nofilter=0,  # type: int
+                 monitor=False,  # type: bool
+                 ):
+        super(L3bpfSocket, self).__init__(
+            iface=iface,
+            type=type,
+            promisc=promisc,
+            filter=filter,
+            nofilter=nofilter,
+            monitor=monitor,
+        )
+        self.filter = filter
+        self.send_socks = {network_name(self.iface): self}
+
     def recv(self, x: int = BPF_BUFFER_LENGTH, **kwargs: Any) -> Optional['Packet']:
         """Receive on layer 3"""
         r = SuperSocket.recv(self, x, **kwargs)
@@ -485,12 +503,14 @@ def send(self, pkt):
             iff = network_name(conf.iface)
 
         # Assign the network interface to the BPF handle
-        if self.assigned_interface != iff:
-            try:
-                fcntl.ioctl(self.bpf_fd, BIOCSETIF, struct.pack("16s16x", iff.encode()))  # noqa: E501
-            except IOError:
-                raise Scapy_Exception("BIOCSETIF failed on %s" % iff)
-            self.assigned_interface = iff
+        if iff not in self.send_socks:
+            self.send_socks[iff] = L3bpfSocket(
+                iface=iff,
+                type=self.type,
+                filter=self.filter,
+                promisc=self.promisc,
+            )
+        fd = self.send_socks[iff]
 
         # Build the frame
         #
@@ -529,12 +549,23 @@ def send(self, pkt):
             warning("Cannot write to %s according to the documentation!", iff)
             return
         else:
-            frame = self.guessed_cls() / pkt
+            frame = fd.guessed_cls() / pkt
 
         pkt.sent_time = time.time()
 
         # Send the frame
-        return L2bpfSocket.send(self, frame)
+        return L2bpfSocket.send(fd, frame)
+
+    @staticmethod
+    def select(sockets, remain=None):
+        # type: (List[SuperSocket], Optional[float]) -> List[SuperSocket]
+        socks = []  # type: List[SuperSocket]
+        for sock in sockets:
+            if isinstance(sock, L3bpfSocket):
+                socks += sock.send_socks.values()
+            else:
+                socks.append(sock)
+        return L2bpfSocket.select(socks, remain=remain)
 
 
 # Sockets manipulation functions

scapy/arch/libpcap.py

@@ -540,6 +540,7 @@ def __init__(self,
             if iface is None:
                 iface = conf.iface
             self.iface = iface
+            self.type = type
             if promisc is not None:
                 self.promisc = promisc
             else:
@@ -580,6 +581,7 @@ def __init__(self,
                         filter = "(ether proto %i) and (%s)" % (type, filter)
                     else:
                         filter = "ether proto %i" % type
+            self.filter = filter
             if filter:
                 self.pcap_fd.setfilter(filter)
 
@@ -598,7 +600,7 @@ class L3pcapSocket(L2pcapSocket):
         def __init__(self, *args, **kwargs):
             # type: (*Any, **Any) -> None
             super(L3pcapSocket, self).__init__(*args, **kwargs)
-            self.send_pcap_fds = {network_name(self.iface): self.pcap_fd}
+            self.send_socks = {network_name(self.iface): self}
 
         def recv(self, x=MTU, **kwargs):
             # type: (int, **Any) -> Optional[Packet]
@@ -614,15 +616,15 @@ def send(self, x):
             iff = x.route()[0]
             if iff is None:
                 iff = network_name(conf.iface)
-            if iff not in self.send_pcap_fds:
-                self.send_pcap_fds[iff] = fd = open_pcap(
-                    device=iff,
-                    snaplen=0,
-                    promisc=False,
-                    to_ms=0,
+            if iff not in self.send_socks:
+                self.send_socks[iff] = L3pcapSocket(
+                    iface=iff,
+                    type=self.type,
+                    filter=self.filter,
+                    promisc=self.promisc,
+                    monitor=self.monitor,
                 )
-            else:
-                fd = self.send_pcap_fds[iff]
+            fd = self.send_socks[iff].pcap_fd
             # Now send.
             sx = raw(self.cls() / x)
             try:
@@ -631,11 +633,22 @@ def send(self, x):
                 pass
             return fd.send(sx)
 
+        @staticmethod
+        def select(sockets, remain=None):
+            # type: (List[SuperSocket], Optional[float]) -> List[SuperSocket]
+            socks = []  # type: List[SuperSocket]
+            for sock in sockets:
+                if isinstance(sock, L3pcapSocket):
+                    socks += sock.send_socks.values()
+                else:
+                    socks.append(sock)
+            return L2pcapSocket.select(socks, remain=remain)
+
         def close(self):
             # type: () -> None
             if self.closed:
                 return
             super(L3pcapSocket, self).close()
-            for fd in self.send_pcap_fds.values():
-                if fd is not self.pcap_fd:
+            for fd in self.send_socks.values():
+                if fd is not self:
                     fd.close()

scapy/arch/linux/__init__.py

@@ -57,8 +57,8 @@
 # Typing imports
 from typing import (
     Any,
-    Callable,
     Dict,
+    List,
     NoReturn,
     Optional,
     Tuple,
@@ -322,6 +322,26 @@ def send(self, x):
 class L3PacketSocket(L2Socket):
     desc = "read/write packets at layer 3 using Linux PF_PACKET sockets"
 
+    def __init__(self,
+                 iface=None,  # type: Optional[Union[str, NetworkInterface]]
+                 type=ETH_P_ALL,  # type: int
+                 promisc=None,  # type: Optional[Any]
+                 filter=None,  # type: Optional[Any]
+                 nofilter=0,  # type: int
+                 monitor=None,  # type: Optional[Any]
+                 ):
+        self.send_socks = {}
+        super(L3PacketSocket, self).__init__(
+            iface=iface,
+            type=type,
+            promisc=promisc,
+            filter=filter,
+            nofilter=nofilter,
+            monitor=monitor,
+        )
+        self.filter = filter
+        self.send_socks = {network_name(self.iface): self}
+
     def recv(self, x=MTU, **kwargs):
         # type: (int, **Any) -> Optional[Packet]
         pkt = SuperSocket.recv(self, x, **kwargs)
@@ -332,39 +352,68 @@ def recv(self, x=MTU, **kwargs):
 
     def send(self, x):
         # type: (Packet) -> int
+        # Select the file descriptor to send the packet on.
         iff = x.route()[0]
         if iff is None:
             iff = network_name(conf.iface)
-        sdto = (iff, self.type)
-        self.outs.bind(sdto)
-        sn = self.outs.getsockname()
-        ll = lambda x: x  # type: Callable[[Packet], Packet]
         type_x = type(x)
-        if type_x in conf.l3types:
-            sdto = (iff, conf.l3types.layer2num[type_x])
-        if sn[3] in conf.l2types:
-            ll = lambda x: conf.l2types.num2layer[sn[3]]() / x
-        if self.lvl == 3 and not issubclass(self.LL, type_x):
-            warning("Incompatible L3 types detected using %s instead of %s !",
-                    type_x, self.LL)
-            self.LL = type_x
-        sx = raw(ll(x))
-        x.sent_time = time.time()
+        if iff not in self.send_socks:
+            self.send_socks[iff] = L3PacketSocket(
+                iface=iff,
+                type=conf.l3types.layer2num.get(type_x, self.type),
+                filter=self.filter,
+                promisc=self.promisc,
+            )
+        fd = self.send_socks[iff].outs
+        if self.lvl == 3:
+            if not issubclass(self.LL, type_x):
+                warning("Incompatible L3 types detected using %s instead of %s !",
+                        type_x, self.LL)
+                self.LL = type_x
+        if self.lvl == 2:
+            sx = bytes(self.LL() / x)
+        else:
+            sx = bytes(x)
+        # Now send.
+        try:
+            x.sent_time = time.time()
+        except AttributeError:
+            pass
         try:
-            return self.outs.sendto(sx, sdto)
+            return fd.send(sx)
         except socket.error as msg:
             if msg.errno == 22 and len(sx) < conf.min_pkt_size:
-                return self.outs.send(
+                return fd.send(
                     sx + b"\x00" * (conf.min_pkt_size - len(sx))
                 )
             elif conf.auto_fragment and msg.errno == 90:
                 i = 0
                 for p in x.fragment():
-                    i += self.outs.sendto(raw(ll(p)), sdto)
+                    i += fd.send(bytes(self.LL() / p))
                 return i
             else:
                 raise
 
+    @staticmethod
+    def select(sockets, remain=None):
+        # type: (List[SuperSocket], Optional[float]) -> List[SuperSocket]
+        socks = []  # type: List[SuperSocket]
+        for sock in sockets:
+            if isinstance(sock, L3PacketSocket):
+                socks += sock.send_socks.values()
+            else:
+                socks.append(sock)
+        return L2Socket.select(socks, remain=remain)
+
+    def close(self):
+        # type: () -> None
+        if self.closed:
+            return
+        super(L3PacketSocket, self).close()
+        for fd in self.send_socks.values():
+            if fd is not self:
+                fd.close()
+
 
 class VEthPair(object):
     """

scapy/sendrecv.py

@@ -1285,7 +1285,7 @@ def stop_cb():
                         for p in packets:
                             if lfilter and not lfilter(p):
                                 continue
-                            p.sniffed_on = sniff_sockets[s]
+                            p.sniffed_on = sniff_sockets.get(s, None)
                             # post-processing
                             self.count += 1
                             if store:

test/sendsniff.uts

@@ -359,3 +359,39 @@ if conf.use_pypy:
     tap0.close()
 else:
     del tap0
+
+#####
+#####
++ Test sr() on multiple interfaces
+
+= Setup multiple linux interfaces and ranges
+~ linux needs_root dbg
+
+import os
+exit_status = os.system("ip netns add blob0")
+exit_status |= os.system("ip netns add blob1")
+exit_status |= os.system("ip link add name scapy0.0 type veth peer name scapy0.1")
+exit_status |= os.system("ip link add name scapy1.0 type veth peer name scapy1.1")
+exit_status |= os.system("ip link set scapy0.1 netns blob0 up")
+exit_status |= os.system("ip link set scapy1.1 netns blob1 up")
+exit_status |= os.system("ip addr add 100.64.2.1/24 dev scapy0.0")
+exit_status |= os.system("ip addr add 100.64.3.1/24 dev scapy1.0")
+exit_status |= os.system("ip --netns blob0 addr add 100.64.2.2/24 dev scapy0.1")
+exit_status |= os.system("ip --netns blob1 addr add 100.64.3.2/24 dev scapy1.1")
+exit_status |= os.system("ip link set scapy0.0 up")
+exit_status |= os.system("ip link set scapy1.0 up")
+assert exit_status == 0
+
+conf.ifaces.reload()
+conf.route.resync()
+
+try:
+    pkts = sr(IP(dst=["100.64.2.2", "100.64.3.2"])/ICMP(), timeout=1)[0]
+    assert len(pkts) == 2
+    assert pkts[0].answer.src in ["100.64.2.2", "100.64.3.2"]
+    assert pkts[1].answer.src in ["100.64.2.2", "100.64.3.2"]
+finally:
+    e = os.system("ip netns del blob0")
+    e = os.system("ip netns del blob1")
+    conf.ifaces.reload()
+    conf.route.resync()