| ## 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. |
| """ |
| |
| |
| from __future__ import absolute_import |
| |
| |
| import scapy.consts |
| from scapy.config import conf |
| from scapy.error import Scapy_Exception, warning |
| from scapy.modules import six |
| from scapy.utils import atol, ltoa, itom, pretty_list |
| |
| |
| ############################## |
| ## Routing/Interfaces stuff ## |
| ############################## |
| |
| class Route: |
| def __init__(self): |
| self.resync() |
| self.invalidate_cache() |
| |
| def invalidate_cache(self): |
| self.cache = {} |
| |
| def resync(self): |
| from scapy.arch import read_routes |
| self.invalidate_cache() |
| self.routes = read_routes() |
| |
| def __repr__(self): |
| rtlst = [] |
| for net, msk, gw, iface, addr, metric in self.routes: |
| rtlst.append((ltoa(net), |
| ltoa(msk), |
| gw, |
| (iface.name if not isinstance(iface, six.string_types) else iface), |
| addr, |
| str(metric))) |
| |
| return pretty_list(rtlst, |
| [("Network", "Netmask", "Gateway", "Iface", "Output IP", "Metric")]) |
| |
| def make_route(self, host=None, net=None, gw=None, dev=None, metric=1): |
| from scapy.arch import get_if_addr |
| 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, _ = self.route(nhop) |
| else: |
| ifaddr = get_if_addr(dev) |
| return (atol(thenet), itom(msk), gw, dev, ifaddr, metric) |
| |
| 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, route in enumerate(self.routes): |
| net, msk, gw, iface, addr, metric = route |
| if scapy.consts.WINDOWS: |
| if iff.guid != iface.guid: |
| continue |
| elif iff != iface: |
| continue |
| if gw == '0.0.0.0': |
| self.routes[i] = (the_net,the_msk,gw,iface,the_addr,metric) |
| else: |
| self.routes[i] = (net,msk,gw,iface,the_addr,metric) |
| conf.netcache.flush() |
| |
| |
| |
| def ifdel(self, iff): |
| self.invalidate_cache() |
| new_routes=[] |
| for rt in self.routes: |
| if scapy.consts.WINDOWS: |
| if iff.guid == rt[3].guid: |
| continue |
| elif iff == rt[3]: |
| continue |
| 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,1)) |
| |
| |
| def route(self,dest,verbose=None): |
| if isinstance(dest, 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,me in self.routes: |
| if not a: # some interfaces may not currently be connected |
| continue |
| aa = atol(a) |
| if aa == dst: |
| pathes.append( |
| (0xffffffff, 1, (scapy.consts.LOOPBACK_INTERFACE, a, "0.0.0.0")) |
| ) |
| if (dst & m) == (d & m): |
| pathes.append((m, me, (i,a,gw))) |
| if not pathes: |
| if verbose: |
| warning("No route found (no default route?)") |
| return scapy.consts.LOOPBACK_INTERFACE, "0.0.0.0", "0.0.0.0" |
| # Choose the more specific route |
| # Sort by greatest netmask |
| pathes.sort(key=lambda x: x[0], reverse=True) |
| # Get all pathes having the (same) greatest mask |
| pathes = [i for i in pathes if i[0] == pathes[0][0]] |
| # Tie-breaker: Metrics |
| pathes.sort(key=lambda x: x[1]) |
| # Return interface |
| ret = pathes[0][2] |
| self.cache[dest] = ret |
| return ret |
| |
| def get_if_bcast(self, iff): |
| for net, msk, gw, iface, addr, metric in self.routes: |
| if net == 0: |
| continue |
| if scapy.consts.WINDOWS: |
| if iff.guid != iface.guid: |
| continue |
| elif iff != iface: |
| continue |
| 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() |
| |
| iface = conf.route.route("0.0.0.0", verbose=0)[0] |
| |
| # Warning: scapy.consts.LOOPBACK_INTERFACE must always be used statically, because it |
| # may be changed by scapy/arch/windows during execution |
| |
| if (iface.name if hasattr(iface, "name") else iface) == scapy.consts.LOOPBACK_INTERFACE: |
| from scapy.arch import get_working_if |
| conf.iface = get_working_if() |
| else: |
| conf.iface = iface |
| |
| del iface |
