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()