def __init__(self, ipdb: IPDB, nsp_name: str):
"""
Creats a namespace for a specific vlan_iface
:param nsp_name:
:param ipdb: IPDB is a transactional database, containing records, representing network stack objects.
Any change in the database is not reflected immidiately in OS, but waits until commit() is called.
"""
logging.debug("%sCreate Namespace ...", LoggerSetup.get_log_deep(2))
self.ipdb = ipdb if ipdb else IPDB()
self.ipdb_netns = None
self.nsp_name = nsp_name
try:
self.ipdb_netns = IPDB(nl=NetNS(nsp_name))
self.ipdb_netns.interfaces['lo'].up().commit()
logging.debug(
"%s[+] Namespace(" + nsp_name + ") successfully created",
LoggerSetup.get_log_deep(3))
# self.encapsulate_interface()
except Exception as e:
logging.debug("%s[-] Couldn't create Namespace(" + nsp_name + ")",
LoggerSetup.get_log_deep(3))
for tb in traceback.format_tb(sys.exc_info()[2]):
logging.error("%s" + tb, LoggerSetup.get_log_deep(3))
logging.error("%s" + str(e), LoggerSetup.get_log_deep(3))
self.remove()
def __init__(self, nsp_name: str, ipdb: IPDB):
"""
Creats a namespace for a specific vlan_iface
:param nsp_name:
:param vlan_iface_name:
:param ipdb: IPDB is a transactional database, containing records, representing network stack objects.
Any change in the database is not reflected immidiately in OS, but waits until commit() is called.
"""
Logger().debug("Create Namespace ...", 2)
self.nsp_name = nsp_name
self.id = id
self.vlan_iface_name = ""
self.vlan_iface_ip = "0.0.0.0"
self.ipdb = ipdb
self.ipdb_netns = None
try:
self.ipdb_netns = IPDB(nl=NetNS(nsp_name))
netns.setns(nsp_name)
self.ipdb_netns.interfaces['lo'].up().commit()
Logger().debug("[+] Namespace(" + nsp_name + ") successfully created", 3)
# self.encapsulate_interface()
except Exception as e:
Logger().debug("[-] Couldn't create Namespace(" + nsp_name + ")", 3)
for tb in traceback.format_tb(sys.exc_info()[2]):
Logger().error(tb, 3)
Logger().error(str(e), 3)
self.remove()
def test_create_namespace(self):
router = self._create_router()
# Create VLAN
ipdb = IPDB()
vlan = Vlan(ipdb, router, "eth0")
assert isinstance(vlan, Vlan)
vlan.create_interface()
# Create Namespace
namespace = Namespace(ipdb, router.namespace_name)
assert isinstance(namespace, Namespace)
# encapsulate VLAN
namespace.encapsulate_interface(vlan.vlan_iface_name)
# Test if the namespace now exists
process = Popen(["ip", "netns"], stdout=PIPE, stderr=PIPE)
stdout, sterr = process.communicate()
assert sterr.decode('utf-8') == ""
assert namespace.nsp_name in stdout.decode('utf-8')
# Remove the Namespace
vlan.delete_interface(close_ipdb=True)
namespace.remove()
ipdb.release()
process = Popen(["ip", "netns"], stdout=PIPE, stderr=PIPE)
stdout, sterr = process.communicate()
assert stdout.decode('utf-8') == ""
def __init__(self,
ipdb: IPDB,
veth_iface_name1: str,
veth_iface_name2: str,
veth_iface_ip1: str = None,
veth_iface_ip_mask1: int = None,
veth_iface_ip2: str = None,
veth_iface_ip_mask2: int = None):
"""
Represents a 'veth'-interface.
:param ipdb: IPDB is a transactional database, containing records, representing network stack objects.
Any change in the database is not reflected immidiately in OS, but waits until commit() is called.
:param veth_iface_name1: like veth00
:param veth_iface_name2: like veth0
:param veth_iface_ip1:
:param veth_iface_ip_mask1:
:param veth_iface_ip2:
:param veth_iface_ip_mask2:
"""
self.ipdb = ipdb if ipdb else IPDB()
self.veth_iface_name1 = veth_iface_name1
self.veth_iface_name2 = veth_iface_name2
self.veth_iface_ip1 = veth_iface_ip1
self.veth_iface_ip_mask1 = veth_iface_ip_mask1
self.veth_iface_ip2 = veth_iface_ip2
self.veth_iface_ip_mask2 = veth_iface_ip_mask2
def test_timeout(self):
print("Test Dhclient: timeout")
router = self._create_router()
# Set VLAN that doesn't exist, so no response occur.
router._vlan_iface_id = 99
router._vlan_iface_name = "vlan99"
ipdb = IPDB()
try:
print("Get link-interface ...")
# Get the real link interface
link_iface = ipdb.interfaces["eth0"]
# Create a Vlan
print("Create VLAN ...")
with ipdb.create(kind="vlan",
ifname=router.vlan_iface_name,
link=link_iface,
vlan_id=router.vlan_iface_id).commit() as iface:
print("Update IP with Dhclient ...")
Dhclient.update_ip(router.vlan_iface_name, timeout=10)
iface.mtu = 1400
except TimeoutError:
print("[+] Test was successful")
except Exception as e:
print("Error: " + str(e))
raise e
finally:
print("Delete VLAN ...")
ipdb.interfaces[router.vlan_iface_name].remove().commit()
ipdb.release()
def test_create_vlan(self):
print("Test if a VLAN can be created")
router = self._create_router()
# Create VLAN
ipdb = IPDB()
vlan = Vlan(ipdb, router, "eth0")
vlan.create_interface()
assert isinstance(vlan, Vlan)
# Test if the VLAN now exists
process = Popen(["ip", "link", "show", "dev", vlan.vlan_iface_name],
stdout=PIPE,
stderr=PIPE)
stdout, sterr = process.communicate()
assert sterr.decode('utf-8') == ""
assert vlan.vlan_iface_name in stdout.decode('utf-8')
# Remove the VLAN
vlan.delete_interface(close_ipdb=True)
process = Popen(["ip", "link", "show", "dev", vlan.vlan_iface_name],
stdout=PIPE,
stderr=PIPE)
stdout, sterr = process.communicate()
assert stdout.decode('utf-8') == ""
def __init__(self, link_iface_name: str):
"""
:param link_iface_name: 'physical'-interface like 'eth0' to which the VLAN is connected to
"""
self.ipdb = IPDB()
self.link_iface_name = link_iface_name
self.vlan_dict = dict()
self.nsp_dict = dict()
def __init__(self, ipdb: IPDB, remote_system: RemoteSystem, link_iface_name):
"""
:param ipdb: IPDB is a transactional database, containing records, representing network stack objects.
Any change in the database is not reflected immidiately in OS, but waits until commit() is called.
:param link_iface_name: name of the existing interface (eth0, wlan0, ...)
"""
self.ipdb = ipdb if ipdb else IPDB()
self.remote_system = remote_system
self.link_iface_name = link_iface_name
self.vlan_iface_name = str(remote_system.vlan_iface_name)
self.vlan_iface_id = int(remote_system.vlan_iface_id)
def __init__(self, link_iface_name: str):
"""
Initialize the IPDB for the interfaces and creates a Bridge (virtual switch).
:param link_iface_name: 'physical'-interface like 'eth0'
"""
self.ipdb = IPDB()
self.link_iface_name = link_iface_name
self.vlan_dict = dict()
self.veth_dict = dict()
self.nsp_dict = dict()
def __init__(self, link_iface_name: str, vlan_iface_name: str, vlan_iface_id: int, vlan_iface_ip: str=None,
vlan_iface_ip_mask: int=None):
"""
Creats a virtual interface on a existing interface (like eth0).
It uses IPDB: IPDB is a transactional database, containing records, representing network stack objects.
Any change in the database is not reflected immidiately in OS, but waits until commit() is called.
:param link_iface_name: name of the existing interface (eth0, wlan0, ...)
:param vlan_iface_name: name of the vlan
:param vlan_iface_id: the id of the vlan
:param vlan_iface_ip: ip of the virtual interface
:param vlan_iface_ip_mask: network-mask of the virtual interface
"""
self.link_iface_name = link_iface_name
self.vlan_iface_name = vlan_iface_name
self.vlan_iface_id = vlan_iface_id
self.ipdb = IPDB()
def __init__(self,
ipdb: IPDB,
bridge_name: str = 'br0',
link_iface_name: str = 'eth0'):
"""
Creates a 'bridge'-interface.
:param ipdb: IPDB is a transactional database, containing records, representing network stack objects.
Any change in the database is not reflected immidiately in OS, but waits until commit() is called.
:param bridge_name: like 'br0'
:param link_iface_name: like 'eth0'
"""
self.ipdb = ipdb if ipdb else IPDB()
self.bridge_name = bridge_name
self.ipdb.create(kind='bridge', ifname=self.bridge_name).commit()
# self.ipdb.interfaces[self.bridge_name].up()
self.add_iface(link_iface_name)
self.set_new_ip(dhcp=True)
def test_normal_functionality(self):
print("Test Dhclient: update_ip")
router = self._create_router()
ipdb = IPDB()
try:
print("Get link-interface ...")
# Get the real link interface
link_iface = ipdb.interfaces["eth0"]
# Create a Vlan
print("Create VLAN ...")
with ipdb.create(kind="vlan",
ifname=router.vlan_iface_name,
link=link_iface,
vlan_id=router.vlan_iface_id).commit() as iface:
print("Update IP with Dhclient ...")
Dhclient.update_ip(router.vlan_iface_name)
iface.mtu = 1400
# Because the IPDB need some time to update the given IP
sleep(10)
process = Popen(
["ping", "-c", "1", "-I", router.vlan_iface_name, router.ip],
stdout=PIPE,
stderr=PIPE)
stdout, sterr = process.communicate()
if not (sterr.decode('utf-8') == ""
and "Unreachable" not in stdout.decode('utf-8')):
raise Exception(str(sterr.decode('utf-8')))
print("[+] Test was successful")
except Exception as e:
print("Error: " + str(e))
raise e
finally:
print("Delete VLAN ...")
ipdb.interfaces[router.vlan_iface_name].remove().commit()
ipdb.release()
import logging
log = logging.getLogger(__name__)
__virtual_name__ = 'network_settings'
ATTRS = [
'family', 'txqlen', 'ipdb_scope', 'index', 'operstate', 'group',
'carrier_changes', 'ipaddr', 'neighbours', 'ifname', 'promiscuity',
'linkmode', 'broadcast', 'address', 'num_tx_queues', 'ipdb_priority',
'change', 'kind', 'qdisc', 'mtu', 'num_rx_queues', 'carrier', 'flags',
'ifi_type', 'ports'
]
LAST_STATS = {}
IP = IPDB()
class Hashabledict(dict):
'''
Helper class that implements a hash function for a dictionary
'''
def __hash__(self):
return hash(tuple(sorted(self.items())))
def __virtual__():
if HAS_PYROUTE2:
return __virtual_name__
return False
