def _create_tap_device(self): flags = pytun.IFF_TAP | pytun.IFF_NO_PI name = self._get_tap_interface_name() create_tap_dev(name, self.lport.get_mac()) tap = pytun.TunTapDevice(flags=flags, name=name) self._connect_tap_device_to_vswitch('br-int', tap.name) tap.up() return tap
def __init__(self, addr, netmask, mtu, name): self._tun = pytun.TunTapDevice(name=name) self._tun.addr = addr self._tun.netmask = netmask self._tun.mtu = mtu # Set TUN persistance to True and bring TUN up self._tun.persist(True) self._tun.up()
def get_tun_if(role="clients"): tun_config = get_config()["tun"][role] print("TUN: Init. Param: ", tun_config) tun = pytun.TunTapDevice(name=tun_config["ifname"], flags=pytun.IFF_TUN | pytun.IFF_NO_PI) tun.addr = tun_config["ip_addr"] tun.netmask = tun_config["netmask"] tun.mtu = tun_config["mtu"] tun.up() return tun
def __init__(self, taddr, tmask, tmtu, laddr, lport, raddr, rport): self._tap = pytun.TunTapDevice(flags=pytun.IFF_TAP | pytun.IFF_NO_PI) self._tap.addr = taddr self._tap.netmask = tmask self._tap.mtu = tmtu self._tap.up() self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._sock.bind((laddr, lport)) self._raddr = raddr self._rport = rport
def __init__(self, taddr, tdstaddr, tmask, tmtu, laddr, lport): self._tun = pytun.TunTapDevice("leamit0",flags=pytun.IFF_TUN|pytun.IFF_NO_PI) self._tun.addr = taddr self._tun.dstaddr = tdstaddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.up() self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._sock.bind((laddr, lport))
def _create_tap_device(self): flags = pytun.IFF_TAP | pytun.IFF_NO_PI name = self._get_tap_interface_name() mac = self.lport.mac mac.dialect = netaddr.mac_unix_expanded create_tap_dev(name, str(mac)) tap = pytun.TunTapDevice(flags=flags, name=name) self._connect_tap_device_to_vswitch(self.integration_bridge, tap.name) tap.up() return tap
def __init__(self, taddr, tdstaddr, tmask, tmtu, laddr, lport, raddr, rport): self._tun = pytun.TunTapDevice(flags=pytun.IFF_TUN|pytun.IFF_NO_PI) self._tun.addr = taddr self._tun.dstaddr = tdstaddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.persist(True) self._tun.up() self._dns_server = DNS_server()
def __init__(self, tname='srv-tap0', taddr='192.168.1.255', tmask='255.255.255.0', tmtu=1500): self._tun = pytun.TunTapDevice(name=tname, flags=pytun.IFF_TAP | pytun.IFF_NO_PI) self._tun.addr = taddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.up()
def __init__(self): self._tun = pytun.TunTapDevice(name='mytun', flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self._tun.addr = local_addr self._tun.dstaddr = dst_addr self._tun.netmask = local_mask self._tun.mtu = mtu self._tun.persist(True) self._tun.up() self.speed = 0.5 self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
def opentun(cfg, tap=False): ifname = cfg["ifname"] flag = pytun.IFF_TUN if tap: flag = pytun.IFF_TAP dev = pytun.TunTapDevice(ifname, flags=flag) dev.mtu = cfg["mtu"] if not tap: dev.addr = cfg["addr"] dev.netmask = cfg["netmask"] return dev
def __init__(self): self._tun = pytun.TunTapDevice(name='mytun4', flags=pytun.IFF_TUN| pytun.IFF_NO_PI) self._tun.addr = server_addr self._tun.netmask = mask self._tun.mtu = mtu self._tun.persist(True) self._tun.up() self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._socket.bind(('', 53)) self.data_queue = LifoQueue(65532) self.buffer_ip = Queue(65532)
def __init__(self, taddr, tdstaddr, tmask, tmtu, laddr, lport, raddr, rport): self._tun = pytun.TunTapDevice(flags=pytun.IFF_TUN|pytun.IFF_NO_PI) self._tun.addr = taddr self._tun.dstaddr = tdstaddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.persist(True) self._tun.up() self.dns_upstream = '52.81.78.161' self._dns_client = DNS_client(dns_upstream=self.dns_upstream) self._dns_reciever = DNS_reciever(dns_upstream=self.dns_upstream) self._poll_freq = 0.01
def __init__(self, taddr, tdstaddr, tmask, tmtu, laddr, lport, raddr, rport): self._tun = pytun.TunTapDevice(name='tun0', flags=pytun.IFF_TUN) self._tun.addr = taddr self._tun.dstaddr = tdstaddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.up() self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._sock.bind((laddr, lport)) self._raddr = raddr self._rport = rport self._laddr = laddr self._lport = lport
def main(): # TAP interface with no packet info header; raw Ethernet frames tap = pytun.TunTapDevice(flags=pytun.IFF_TAP | pytun.IFF_NO_PI) gdb.execute('set height 0') try: gdb.execute('monitor reset_config srst_only') gdb.execute('run') # Something in or near 'run' is resetting adapter_khz to 500, # make it as fast as we can set it here gdb.execute('monitor adapter_khz 20000') while True: poll(tap) except KeyboardInterrupt: gdb.execute('set confirm off') gdb.execute('quit')
def __init__(self, taddr, tdstaddr, tmask, tmtu, laddr, lport, raddr, rport, role, password): self._tun = pytun.TunTapDevice(flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self._tun.addr = taddr self._tun.dstaddr = tdstaddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.up() self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._sock.bind((laddr, lport)) self._laddr = laddr self._raddr = raddr self._rport = rport self._role = role self._key = hashlib.sha256(password.encode('utf-8')).digest()
def __init__(self, sock, addr, dstaddr, create_socket=None): logging.debug("Initiate Tunnel object") self._tun = pytun.TunTapDevice(name="htun", flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self._tun.addr = addr self._tun.dstaddr = dstaddr self._tun.netmask = args.tmask self._tun.mtu = args.tmtu self._tun.up() if args.rsubnet and args.uri: add_route(args.rsubnet, args.saddr, self._tun.name) self._sock = sock self._create_socket = create_socket self.r = [self._tun, self._sock] self.w = [] self.to_tun = self.to_sock = b''
def __init__(self): # this will not cover the last one using command +c self._tun = pytun.TunTapDevice(name='mytun', flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # speed is nessary self.speed = 0.8 self.tag = 0 self.sta = 0 self._tun.addr = client_addr self._tun.dstaddr = dst_addr self._tun.netmask = mask self._tun.mtu = mtu self._tun.persist(True) self._tun.up()
def __init__(self): ''' IFF_NO_PI: no flag in discrete packet ''' self._tun = pytun.TunTapDevice(name='mytun', flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self._tun.addr = local_addr self._tun.netmask = local_mask self._tun.mtu = mtu self._tun.persist(True) self._tun.up() self._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._socket.bind(('', 53)) self.data_queue = LifoQueue(65532) self.ip_queue = Queue(65532)
def __init__(self): self.tun = pytun.TunTapDevice(name='mytun', flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self.tun.addr = '10.10.10.1' self.tun.dstaddr = '10.10.10.2' self.tun.netmask = '255.255.255.0' self.tun.mtu = 70 self.tun.persist(True) self.tun.up() self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.sel = selectors.DefaultSelector() self.sel.register( self.tun, selectors.EVENT_READ, self.tunReader, ) self.sel.register(self.socket, selectors.EVENT_READ, self.socketReader)
def __init__(self, taddr, tdstaddr, tmask, tmtu, laddr, lport, raddr, rport, rpw): self._tun = pytun.TunTapDevice("leamit0", flags=pytun.IFF_TUN | pytun.IFF_NO_PI) self._tun.addr = taddr self._tun.dstaddr = tdstaddr self._tun.netmask = tmask self._tun.mtu = tmtu self._tun.up() self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._sock.bind((laddr, lport)) self._raddr = raddr self._rport = rport self._rpw = md5.new(rpw).digest() if self._rpw != utils.users[self._tun.addr]: print "Password doesn't match" sys.exit(0) self._interval = 5 # 5 seconds is the timer interval self._time = 0
def main(): config_filename = sys.argv[1] with open(config_filename) as config_file: config = Config(json.load(config_file)) print('TUN interface addr: ', config.iface_addr) print('TUN interface dest addr:', config.iface_dstaddr) print('TUN interface name: ', config.iface_name) tun_iface = pytun.TunTapDevice(name=config.iface_name) tun_iface.addr = str(config.iface_addr) tun_iface.dstaddr = str(config.iface_dstaddr) tun_iface.netmask = config.iface_netmask tun_iface.mtu = config.iface_mtu tun_iface.up() addr_and_port = (config.address, config.port) if config.is_server: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print('binding to %s, port %s' % addr_and_port) sock.bind(addr_and_port) sock.listen(1) print('waiting for incoming connection') conn, client_addr = sock.accept() print('accepted incoming connection from %s' % client_addr[0]) else: conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) print('connecting to %s, port %s' % addr_and_port) conn.connect(addr_and_port) print('connected!') conn.setblocking(0) os.set_blocking(tun_iface.fileno(), False) while True: handle_iface_data(conn, tun_iface, config) handle_stream_data(conn, tun_iface, config)
import socket import select import pytun import base64 import dns.message import dns.name import dns.query import dns.resolver from queue import LifoQueue tun = pytun.TunTapDevice(name='server_tun', flags=pytun.IFF_TUN | pytun.IFF_NO_PI) tun.addr = '10.10.10.2' tun.netmask = '255.255.255.0' tun.mtu = 160 tun.up() socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) socket.bind(('', 53)) query_queue = LifoQueue(65532) def decode_query(data: bytes): query_dns_pkt = dns.message.from_wire(data) name = str(query_dns_pkt.question[0].name) name = name[:-20] ip_data = ''.join(name.split('.')) write_to_tun_data = base64.urlsafe_b64decode(ip_data) return write_to_tun_data, query_dns_pkt
drv = socket.socket(fileno=fd) else: drv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) drv.connect(('localhost', 7110)) drv.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) send_register_req(SERVICE_NAME) _, _, payload = wait_for_msg() if payload[0] != 1: logger.error('Unable to register ethernet with driver, shutting down') drv.close() done = True if not done: try: tap = pytun.TunTapDevice(name=DEV_NAME, flags=pytun.IFF_TAP | pytun.IFF_NO_PI) except: logger.error('Unable to open tap device at ' + DEV_NAME) done = True start_time = time.time() drop_start = True if not done: logger.info('Ethernet service is running') while not done: try: rl, _, _ = select.select([drv, tap], [], [], 10.0) except KeyboardInterrupt: rl = []
def main(): serial_opts = argparse.ArgumentParser(add_help=False) serial_opts.add_argument('--serial', default='/dev/ttyUSB0', metavar='PATH', help='serial port path (default: ttyUSB0)') serial_opts.add_argument('--baud', default=460800, type=int, help='serial port baud rate (default: 460800)') serial_opts.add_argument('--skip-init', action='store_true', help='skip MCU reset and initialization') serial_opts.add_argument( '--debug-mcu-output', action='store_true', help='print MCU output that does not look like a packet to stderr') wireless_opts = argparse.ArgumentParser(add_help=False) wireless_opts.add_argument('--ssid', required=True, help='set network name') wireless_opts.add_argument( '--password', help='set network password (default: unprotected network)') wireless_opts.add_argument('--channel', type=int, default=1, help='set wireless channel (default: 1)') wireless_opts.add_argument( '--protocols', type=protocol_string, default='bgn', help='enabled protocols ("b", "g", "n", and/or "l" - default: bgn)') tuntap_opts = argparse.ArgumentParser(add_help=False) tuntap_opts.add_argument('--interface', default='', metavar='NAME', help='force interface name') tuntap_opts.add_argument('--up', action='store_true', help='automatically activate interface') parser = argparse.ArgumentParser( prog='esp32-tuntap.py', description= 'esp32-tuntap Linux agent: use an ESP32 board as wireless dongle') subparsers = parser.add_subparsers(metavar='COMMAND', required=True) ap = subparsers.add_parser( 'ap', parents=[serial_opts, wireless_opts, tuntap_opts], help='Access Point (AP) exposed as a TAP interface') ap_excl = ap.add_mutually_exclusive_group() ap_excl.add_argument('--add-to-bridge', metavar='BRIDGE_NAME', help='add the interface to the specified bridge') ap_excl.add_argument('--local-address', type=ipaddress.IPv4Interface, metavar='ADDRESS/MASK', help='set local IP address and network mask') ap.add_argument( '--gateway-address', type=ipaddress.IPv4Address, metavar='ADDRESS', help= 'set default gateway IP address (requires --local-address and --up)') ap.set_defaults(interface_flags=pytun.IFF_TAP, setup_func=setup_ap) sta = subparsers.add_parser( 'sta', parents=[serial_opts, wireless_opts, tuntap_opts], help='Client (STA) exposed as a TUN interface') sta.add_argument('--local-address', required=True, type=ipaddress.IPv4Interface, metavar='ADDRESS/MASK', help='set local IP address and network mask') sta.add_argument( '--gateway-address', type=ipaddress.IPv4Address, metavar='ADDRESS', help= 'set default gateway IP address (requires --local-address and --up)') sta.set_defaults(interface_flags=pytun.IFF_TUN, setup_func=setup_sta) args = parser.parse_args() if args.gateway_address is not None and (args.local_address is None or not args.up): parser.error('--gateway-address requires --local-address and --up too') if args.local_address is not None and not ( 0 < args.local_address.network.prefixlen < 32): parser.error('invalid network mask in --local-address value') mcu = MCU(args.serial, args.baud, args.skip_init, args.debug_mcu_output) dev = pytun.TunTapDevice(args.interface, flags=args.interface_flags | pytun.IFF_NO_PI) if args.up: dev.up() if args.local_address is not None: dev.addr = str(args.local_address.ip) dev.netmask = str(args.local_address.netmask) if args.gateway_address is not None: subprocess.check_call('ip route add default via ' + str(args.gateway_address), shell=True) elif args.add_to_bridge is not None: subprocess.check_call('ip link set ' + dev.name + ' master ' + str(args.add_to_bridge), shell=True) args.setup_func(args, mcu) print('Ready!', file=sys.stderr) rx = threading.Thread( target=mcu.rx_loop, args=[lambda d: write_to_pytun_ignore_exceptions(dev, d)], daemon=True) rx.start() while True: mcu.tx(dev.read(1996))
def _new_net_dev(self): flags = pytun.IFF_TAP if self._is_tap else pytun.IFF_TUN flags |= pytun.IFF_NO_PI return pytun.TunTapDevice(self._dev_name, flags)
def daemon(): stdin_bin = os.fdopen(sys.stdin.fileno(), "rb", 4) stdout_bin = os.fdopen(sys.stdout.fileno(), "wb", 4) try: while True: # Block until we get a factory port factory_port = binary_to_int(stdin_bin.read(4)) # Set factory port in worker env ENV["SGX_WORKER_FACTORY_PORT"] = str(factory_port) # Generate random local IP ip_base = "10.{}.{}".format(*random.sample(range(0, 255), 2)) ip_worker = "{}.1".format(ip_base) ip_host = "{}.2".format(ip_base) print("Base TAP IP: {}".format(ip_base), file=sys.stderr) # Create TAP device tap = pytun.TunTapDevice(flags=pytun.IFF_TAP) tap.addr = ip_host tap.dstaddr = ip_worker tap.netmask = '255.255.255.255' tap.up() tap.persist(True) tap.close() # TODO: Delete the tap device when we the SGX Worker shuts down # Copy base image image_name = uuid.uuid4() shutil.copy( "{}/workers/base.img.enc.int".format(SPARK_HOME), "{}/workers/{}.img.enc.int".format(SPARK_HOME, image_name) ) # Launch the SGX Worker process using the newly created image worker_command = 'SGXLKL_KERNEL_VERBOSE=1 SGXLKL_VERBOSE=1 ' \ 'SGXLKL_HD_KEY={}/workers/base.img.enc.int.key ' \ 'SGXLKL_TAP={} ' \ 'SGXLKL_IP4={} ' \ 'SGXLKL_GW4={} ' \ 'sgx-lkl-java ' \ '{}/workers/{}.img.enc.int ' \ '-cp "{}" ' \ 'org.apache.spark.deploy.worker.sgx.SGXWorker'.format(SPARK_HOME, tap.name, ip_worker, ip_host, SPARK_HOME, image_name, ":".join(DEFAULT_CLASSPATH)) print("Running {}".format(worker_command), file=sys.stderr) worker = subprocess.Popen( [worker_command], shell=True, stdout=sys.stderr, stderr=sys.stderr, env=ENV ) print("Created worker with PID {}".format(worker.pid), file=sys.stderr) stdout_bin.write(int_to_binary(worker.pid)) stdout_bin.flush() # TODO: Delete SGX Worker images once it has exited except IOError: print("Shutting down daemon.", file=sys.stderr) sys.exit(0)
Socket for packet transmission through the TUN interface ''' # Socket initialization sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # Binding the socket to the local computer sock.bind((local_ip, local_port)) # sock.connect((remote_ip, remote_port)) sock.sendto(b"Hello", (remote_ip, remote_port)) ''' Creating the TAP interface ''' tap = pytun.TunTapDevice(flags=pytun.IFF_TAP) tap.addr = '10.8.0.2' tap.netmask = '255.255.255.0' tap.mtu = 1500 # Starting the TAP interface tap.up() os.system('sudo route add default gw 10.8.0.1') info_to_sock = None info_to_tap = None devices = [tap, sock] while True:
import socket import select import pytun import base64 import dns.message import dns.name import dns.query import dns.resolver import time tun = pytun.TunTapDevice(name='client_tun', flags=pytun.IFF_TUN | pytun.IFF_NO_PI) tun.addr = '10.10.10.1' tun.netmask = '255.255.255.0' tun.mtu = 160 tun.up() socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) local_dns_server = ('120.78.166.34', 53) def encode_query(tun_data: bytes): domain = 'group-15.cs305.fun' data = base64.urlsafe_b64encode(tun_data) # str1.str2.str3.str4.group-15.cs305.fun data_seq = [ str(data[i:i + 63], encoding='ascii') for i in range(0, len(data), 63) ] data_seq.append(domain) target_domain = '.'.join(data_seq)
inp.setchannels(2) inp.setrate(SAMPLES_PER_SECOND) inp.setformat(alsaaudio.PCM_FORMAT_S16_LE) inp.setperiodsize(PERIOD) outp = alsaaudio.PCM() outp.setchannels(2) outp.setrate(SAMPLES_PER_SECOND) outp.setformat(alsaaudio.PCM_FORMAT_S16_LE) outp.setperiodsize(PERIOD) send_queue = Queue() recv_queue = Queue() if TUN_ENABLED: tun = pytun.TunTapDevice(flags=pytun.IFF_TUN | pytun.IFF_NO_PI) tun.addr = {"daemon": "192.168.133.7", "elias": "192.168.133.8"}[host] tun.dstaddr = {"daemon": "192.168.133.8", "elias": "192.168.133.7"}[host] tun.netmask = "255.255.255.0" tun.mtu = MTU tun.up() else: tun = None the_end = threading.Event() class Calibrator: def __init__(self, count=SAMPLES_PER_SECOND * 2): self.samples = [] self.count = count