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
