def serverStart(host:str,port:int):
# Create new socket that will be passed to reactor later.
portSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Make the port non-blocking and start it listening.
portSocket.setblocking(False)
portSocket.bind((host, port))
reactor.adoptDatagramPort(portSocket.fileno(), socket.AF_INET, Server( int(port)))
def main():
global config
parser = argparse.ArgumentParser(description='mitm6 - pwning IPv4 via IPv6\nFor help or reporting issues, visit https://github.com/fox-it/mitm6', formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("-i", "--interface", type=str, metavar='INTERFACE', help="Interface to use (default: autodetect)")
parser.add_argument("-l", "--localdomain", type=str, metavar='LOCALDOMAIN', help="Domain name to use as DNS search domain (default: use first DNS domain)")
parser.add_argument("-4", "--ipv4", type=str, metavar='ADDRESS', help="IPv4 address to send packets from (default: autodetect)")
parser.add_argument("-6", "--ipv6", type=str, metavar='ADDRESS', help="IPv6 link-local address to send packets from (default: autodetect)")
parser.add_argument("-m", "--mac", type=str, metavar='ADDRESS', help="Custom mac address - probably breaks stuff (default: mac of selected interface)")
parser.add_argument("-a", "--no-ra", action='store_true', help="Do not advertise ourselves (useful for networks which detect rogue Router Advertisements)")
parser.add_argument("-v", "--verbose", action='store_true', help="Show verbose information")
parser.add_argument("--debug", action='store_true', help="Show debug information")
filtergroup = parser.add_argument_group("Filtering options")
filtergroup.add_argument("-d", "--domain", action='append', default=[], metavar='DOMAIN', help="Domain name to filter DNS queries on (Whitelist principle, multiple can be specified.)")
filtergroup.add_argument("-b", "--blacklist", action='append', default=[], metavar='DOMAIN', help="Domain name to filter DNS queries on (Blacklist principle, multiple can be specified.)")
filtergroup.add_argument("-hw", "--host-whitelist", action='append', default=[], metavar='DOMAIN', help="Hostname (FQDN) to filter DHCPv6 queries on (Whitelist principle, multiple can be specified.)")
filtergroup.add_argument("-hb", "--host-blacklist", action='append', default=[], metavar='DOMAIN', help="Hostname (FQDN) to filter DHCPv6 queries on (Blacklist principle, multiple can be specified.)")
filtergroup.add_argument("--ignore-nofqdn", action='store_true', help="Ignore DHCPv6 queries that do not contain the Fully Qualified Domain Name (FQDN) option.")
args = parser.parse_args()
config = Config(args)
print('Starting mitm6 using the following configuration:')
print('Primary adapter: %s [%s]' % (config.default_if, config.selfmac))
print('IPv4 address: %s' % config.selfipv4)
print('IPv6 address: %s' % config.selfaddr)
if config.localdomain is not None:
print('DNS local search domain: %s' % config.localdomain)
if not config.dns_whitelist and not config.dns_blacklist:
print('Warning: Not filtering on any domain, mitm6 will reply to all DNS queries.\nUnless this is what you want, specify at least one domain with -d')
else:
if not config.dns_whitelist:
print('DNS whitelist: *')
else:
print('DNS whitelist: %s' % ', '.join(config.dns_whitelist))
if config.dns_blacklist:
print('DNS blacklist: %s' % ', '.join(config.dns_blacklist))
if config.host_whitelist:
print('Hostname whitelist: %s' % ', '.join(config.host_whitelist))
if config.host_blacklist:
print('Hostname blacklist: %s' % ', '.join(config.host_blacklist))
#Main packet capture thread
d = threads.deferToThread(sniff, iface=config.default_if, filter="ip6 proto \\udp or arp or udp port 53", prn=lambda x: reactor.callFromThread(parsepacket, x), stop_filter=should_stop)
d.addErrback(print_err)
#RA loop
if not args.no_ra:
loop = task.LoopingCall(send_ra)
d = loop.start(30.0)
d.addErrback(print_err)
# Set up DNS
dnssock = setupFakeDns()
reactor.adoptDatagramPort(dnssock.fileno(), socket.AF_INET6, DatagramProtocol())
reactor.addSystemEventTrigger('before', 'shutdown', shutdownnotice)
reactor.run()
def main(fd=None):
if fd is None:
port = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Make the port non-blocking and start it listening.
port.setblocking(False)
port.bind((ip, myport))
for i in range(3):
arglist = [executable, __file__, str(port.fileno())]
#arglist = [executable,str(port.fileno())]
reactor.spawnProcess(None, executable, arglist,
childFDs={0: 0, 1: 1, 2: 2, port.fileno(): port.fileno()},env=environ)
# pass the port file descriptor to the reactor
port = reactor.adoptDatagramPort(port.fileno(), socket.AF_INET, SipProxy())
else:
# start listening on already created port
port = reactor.adoptDatagramPort(fd, AF_INET, SipProxy())
reactor.run()
def main():
port = 1001
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setblocking(False)
s.bind(("0.0.0.0", port))
port = reactor.adoptDatagramPort(s.fileno(), socket.AF_INET, Echo())
s.close()
reactor.run()
def register_pathway(self, capnproto_struct, handlers):
if not issubclass(capnproto_struct, Struct):
raise ValueError("capnproto_struct must be a capnpy Struct")
if len(handlers) == 0:
raise ValueError("Must specify at least one handler")
for handler in handlers:
if not callable(handler):
raise ValueError("Handler must be callable")
handlers = tuple(handlers)
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setblocking(False)
sock.bind(('', 0))
port = sock.getsockname()[1]
reactor.adoptDatagramPort(
sock.fileno(), socket.AF_INET,
DataPathwayProtocol(capnproto_struct, handlers))
sock.close()
data_pathway = StructHandlerInfo(
struct_name=bytes(capnproto_struct.__name__, 'UTF-8'),
handlers=[
bytes(underscore_to_camelcase(handler.__name__), 'UTF-8')
for handler in handlers
])
self.zeroconf_info = ServiceInfo(
self.zeroconf_type, "{0}._sub.{1}".format(self.zeroconf_sub_type,
self.zeroconf_type),
socket.inet_aton(self.zeroconf_service_address), port, 0, 0,
{b"struct-handler-info": data_pathway.dumps()},
self.zeroconf_server)
self.zeroconf.register_service(self.zeroconf_info,
allow_name_change=True)
def __init__(self, ip_, port_, ceilColl_, log_):
self.logger = log_
self.collector = ceilColl_
HOST, PORT = ip_, int(port_)
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setblocking(False)
server = (HOST, PORT)
sock.bind(server)
global pks
pks = 0
print("Listening on " + HOST + ":" + str(PORT))
count = 0
port = reactor.adoptDatagramPort(
sock.fileno(), socket.AF_INET,
Echo(ceilColl_=self.collector, log_=self.logger))
sock.close()
reactor.run()
def startService(self):
# use socket creation from twisted to use the same options as before
if hasattr(self.protocol, 'datagramReceived'):
tmp_port = udp.Port(None, None, interface=self.interface)
else:
tmp_port = tcp.Port(None, None, interface=self.interface)
carbon_sock = tmp_port.createInternetSocket()
if hasattr(socket, 'SO_REUSEPORT'):
carbon_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
carbon_sock.bind((self.interface, self.port))
if hasattr(self.protocol, 'datagramReceived'):
self._port = reactor.adoptDatagramPort(
carbon_sock.fileno(), socket.AF_INET, self.protocol())
else:
carbon_sock.listen(tmp_port.backlog)
self._port = reactor.adoptStreamPort(
carbon_sock.fileno(), socket.AF_INET, self.factory)
carbon_sock.close()
import socket
from twisted.internet import reactor
from twisted.internet.protocol import DatagramProtocol
class Echo(DatagramProtocol):
def datagramReceived(self, data, addr):
print(f"received {data!r} from {addr}")
self.transport.write(data, addr)
# Create new socket that will be passed to reactor later.
portSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Make the port non-blocking and start it listening.
portSocket.setblocking(False)
portSocket.bind(("127.0.0.1", 9999))
# Now pass the port file descriptor to the reactor.
port = reactor.adoptDatagramPort(portSocket.fileno(), socket.AF_INET, Echo())
# The portSocket should be cleaned up by the process that creates it.
portSocket.close()
reactor.run()
def datagramReceived(self, data, (host, port)):
rpt = KETIGram(data=data, data_length=len(data))
readings = rpt.get_readings()
motetype = rpt.get_type()
moteid = host.split('::')[-1]
print 'Raw readings', readings
print 'From', host
try:
if motetype == 0x64:
print 'Temperatures', map(temp, readings[2::3])
print 'Relative Humidity', map(humidity, readings[::3])
print 'Illumination', readings[1::3]
elif motetype == 0x65:
print 'CO2 ppm', readings
elif motetype == 0x66:
print 'Occupancy', readings
else:
print motetype
except Exception as e:
print e
if __name__ == '__main__':
s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
s.setblocking(False)
s.bind(('', port))
port = reactor.adoptDatagramPort(s.fileno(), socket.AF_INET6, Monitor())
s.close()
reactor.run()
def myListenUDP(self, port, proto, host, isloc):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM|socket.SOCK_NONBLOCK, udpprotocol(isloc))
sock.bind((host, port))
return sock, reactor.adoptDatagramPort(sock.fileno(), socket.AF_INET, proto) # @UndefinedVariable
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from twisted.internet.protocol import DatagramProtocol
import socket
from twisted.internet import reactor
class Echo(DatagramProtocol):
def datagramReceived(self, data, address):
print(data.decode('utf8'))
address = ("127.0.0.1", 8008)
recvSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
recvSocket.setblocking(False) # 设为阻塞模式
recvSocket.bind(address)
reactor.adoptDatagramPort(recvSocket.fileno(), socket.AF_INET, Echo())
recvSocket.close()
# 新建一个socket作为发送端
sendSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sendSocket.sendto("Hello my friend!".encode('utf-8'), address)
reactor.run()
# the proper one that works with wxwidgets.
import sys
if 'twisted.internet.reactor' in sys.modules:
del sys.modules['twisted.internet.reactor']
from twisted.internet import wxreactor
wxreactor.install()
from twisted.internet import reactor
import wx
from ssdrframe import SsdrFdvClientFrame
from ssdrdiscovery import SsdrDiscoveryClient
import socket
if __name__ == '__main__':
app = wx.App(False)
reactor.registerWxApp(app)
frame = SsdrFdvClientFrame()
frame.Show(True)
discovery_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
discovery_socket.setblocking(False)
discovery_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
discovery_socket.bind(('0.0.0.0', 4992))
reactor.adoptDatagramPort(discovery_socket.fileno(), socket.AF_INET,
SsdrDiscoveryClient(frame))
reactor.run()
def main():
global config
parser = argparse.ArgumentParser(
description='mitm6 - pwning IPv4 via IPv6')
parser.add_argument(
"-d",
"--domain",
action='append',
metavar='DOMAIN',
help=
"Interal domain name to filter DNS queries on (Whitelist principle, multiple can be specified. Note that the first will be used as DNS search domain)"
)
parser.add_argument("-i",
"--interface",
type=str,
metavar='INTERFACE',
help="Interface to use (default: autodetect)")
parser.add_argument(
"-4",
"--ipv4",
type=str,
metavar='ADDRESS',
help="IPv4 address to send packets from (default: autodetect)")
parser.add_argument(
"-6",
"--ipv6",
type=str,
metavar='ADDRESS',
help=
"IPv6 link-local address to send packets from (default: autodetect)")
parser.add_argument(
"-m",
"--mac",
type=str,
metavar='ADDRESS',
help=
"Custom mac address - probably breaks stuff (default: mac of selected interface)"
)
parser.add_argument(
"-a",
"--no-ra",
action='store_true',
help=
"Do not advertise ourselves (useful for networks which detect rogue Router Advertisements)"
)
parser.add_argument("-v",
"--verbose",
action='store_true',
help="Show verbose information")
parser.add_argument("--debug",
action='store_true',
help="Show debug information")
args = parser.parse_args()
config = Config(args)
print('Starting mitm6 using the following configuration:')
print('Primary adapter: %s [%s]' % (config.default_if, config.selfmac))
print('IPv4 address: %s' % config.selfipv4)
print('IPv6 address: %s' % config.selfaddr)
if config.dnsdomain is None:
print(
'Warning: Not filtering on any domain, mitm6 will reply to all DNS queries.\nUnless this is what you want, specify a domain with -d'
)
config.dnsdomain = []
else:
print('DNS domains: %s' % ', '.join(config.dnsdomain))
#Main packet capture thread
d = threads.deferToThread(
sniff,
filter="ip6 proto \\udp or arp or udp port 53",
prn=lambda x: reactor.callFromThread(parsepacket, x, config),
stop_filter=should_stop)
d.addErrback(print_err)
#RA loop
if not args.no_ra:
loop = task.LoopingCall(send_ra)
d = loop.start(30.0)
d.addErrback(print_err)
# Set up DNS
dnssock = setupFakeDns()
reactor.adoptDatagramPort(dnssock.fileno(), socket.AF_INET6,
DatagramProtocol())
reactor.addSystemEventTrigger('before', 'shutdown', shutdownnotice)
reactor.run()
def start(self):
self.monitor = Monitor(self)
self.socket = reactor.adoptDatagramPort(self.s.fileno(), socket.AF_INET6, self.monitor)
self.s.close()
def lookupText(self, name, timeout = None):
print(name)
if name.endswith(FAKE_SUFFIX):
if name.endswith(SOCK_FAKE_SUFFIX):
free_port = self._get_free_port()
while True:
portSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
portSocket.setblocking(False)
try:
portSocket.bind(('127.0.0.1', free_port))
except:
pass
else:
self.ports[free_port] = portSocket
receiver = RecvFromUdp()
self.receivers[free_port] = receiver
self.udpObjects[free_port] = reactor.adoptDatagramPort(portSocket.fileno(), socket.AF_INET, receiver)
print("Gave port ", free_port)
break
free_port = self._get_free_port()
return defer.succeed([
[dns.RRHeader(name, dns.TXT, dns.IN, self.ttl, dns.Record_TXT(str(free_port)),)], (), ()])
elif name.endswith(SND_FAKE_SUFFIX):
useful = name[:-len(SND_FAKE_SUFFIX)-1]
parts = useful.split(".")
local_port = int(parts[-1])
print("Local port: ", local_port)
if not local_port in self.ports:
print("Local port is closed...")
return defer.succeed([
[dns.RRHeader(name, dns.TXT, dns.IN, self.ttl, dns.Record_TXT(PORT_NOT_OPEN),)],
(), ()])
print("Local port is open!")
remote_port = socket.ntohs(int(parts[-2]))
remote_packed_addr_dec = socket.ntohl(int(parts[-3]))
remote_packed_addr = ""
for i in range(0, 4):
digit = remote_packed_addr_dec % 256
remote_packed_addr = chr(digit) + remote_packed_addr
remote_packed_addr_dec = remote_packed_addr_dec / 256
remote_addr = socket.inet_ntop(socket.AF_INET, remote_packed_addr)
conn_id = (remote_addr, remote_port, local_port)
if not conn_id in self.dataObjectsToSend:
self.dataObjectsToSend[conn_id] = ""
data = "".join(parts[0:-3])
eot = False
if data[-1] == '=':
eot = True
data = data[:-1]
total_data = self.dataObjectsToSend[conn_id] + data
self.dataObjectsToSend[conn_id] = total_data
print(data)
print(total_data)
if eot: # End of transmission
padded_data = self._pad_base32(total_data)
my_socket = self.ports[local_port]
raw_data = base64.b32decode(padded_data)
print("Sending: ", raw_data)
print("Socket: ", my_socket)
print("TO: ", remote_addr, remote_port)
my_socket.sendto(raw_data, (remote_addr, remote_port))
del self.dataObjectsToSend[conn_id]
return defer.succeed([
[dns.RRHeader(name, dns.TXT, dns.IN, self.ttl, dns.Record_TXT(PARTOK),)], (), ()])
elif name.endswith(RECV_FAKE_SUFFIX):
port_str = name[:-len(RECV_FAKE_SUFFIX)-1]
port_int = int(port_str)
print("Recv from:", port_int)
if not port_int in self.udpObjects:
return self._empty_txt_record_deferred(name)
datagramObject = self.receivers[port_int]
def firstCallback(dt):
data_not_encoded = dt[0]
data_encoded = base64.b32encode(data_not_encoded)
data_encoded = data_encoded.translate(None, '=')
print(data_not_encoded)
print(data_encoded)
chunk_list = list(self._chunks(data_encoded, MAX_TXT_RECORD_SIZE))
print(chunk_list)
responses = list(map(lambda x: dns.RRHeader(name, dns.TXT, dns.IN, self.ttl, dns.Record_TXT(x),), chunk_list))
print(responses)
return responses
def secondCallback(resp):
return [resp, (), ()]
if datagramObject.empty(): # Data has not yet arrived; Should wait
print("Recv is empty")
defd = defer.Deferred()
defd.addCallback(firstCallback)
defd.addCallback(secondCallback)
datagramObject.addDeferred(defd)
return defd
#return self._empty_txt_record_deferred()
return defer.succeed([
firstCallback(datagramObject.getData()), (), ()])
elif name.endswith(CLS_FAKE_SUFFIX):
port_str = name[:-len(CLS_FAKE_SUFFIX)-1]
port_int = int(port_str)
if not port_int in self.ports:
return defer.succeed([
[dns.RRHeader(name, dns.TXT, dns.IN, self.ttl, dns.Record_TXT(PORT_NOT_OPEN)),], (), ()])
portSocket = self.ports[port_int]
portSocket.close()
del self.ports[port_int]
del self.udpObjects[port_int]
del self.receivers[port_int]
return defer.succeed([
[dns.RRHeader(name, dns.TXT, dns.IN, self.ttl, dns.Record_TXT(self._getSampleText(name)),),
], (), ()])
else:
return super(client.Resolver, self).lookupText(self, name, timeout)
import socket
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class Echo(DatagramProtocol):
def datagramReceived(self, data, (host, port)):
print "received %r from %s:%d" % (data, host, port)
self.transport.write(data, (host, port))
portSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Make the port non-blocking and start it listening.
portSocket.setblocking(False)
portSocket.bind(('127.0.0.1', 9999))
# Now pass the port file descriptor to the reactor
port = reactor.adoptDatagramPort(
portSocket.fileno(), socket.AF_INET, Echo())
# The portSocket should be cleaned up by the process that creates it.
portSocket.close()
reactor.run()
