def test_get_endpoints_from_section(self): cfg = get_config(b""" [ssh] listen_addr = 1.1.1.1 """) self.assertEqual(["tcp:2223:interface=1.1.1.1"], get_endpoints_from_section(cfg, "ssh", 2223)) cfg = get_config(b""" [ssh] listen_addr = 1.1.1.1 """) self.assertEqual(["tcp:2224:interface=1.1.1.1"], get_endpoints_from_section(cfg, "ssh", 2224)) cfg = get_config(b""" [ssh] listen_addr = 1.1.1.1 2.2.2.2 """) self.assertEqual(["tcp:2223:interface=1.1.1.1", "tcp:2223:interface=2.2.2.2"], get_endpoints_from_section(cfg, "ssh", 2223)) cfg = get_config(b""" [ssh] listen_addr = 1.1.1.1 2.2.2.2 listen_port = 23 """) self.assertEqual(["tcp:23:interface=1.1.1.1", "tcp:23:interface=2.2.2.2"], get_endpoints_from_section(cfg, "ssh", 2223)) cfg = get_config(b""" [ssh] listen_endpoints = tcp:23:interface=1.1.1.1 tcp:2323:interface=1.1.1.1 """) self.assertEqual(["tcp:23:interface=1.1.1.1", "tcp:2323:interface=1.1.1.1"], get_endpoints_from_section(cfg, "ssh", 2223))
def pool_ready(self) -> None: backend: str = CowrieConfig.get("honeypot", "backend", fallback="shell") # this method is never called if self.pool_only is False, # since we do not start the pool handler that would call it if self.enableSSH: factory = cowrie.ssh.factory.CowrieSSHFactory(backend, self.pool_handler) factory.tac = self # type: ignore factory.portal = portal.Portal(core.realm.HoneyPotRealm()) factory.portal.registerChecker(core.checkers.HoneypotPublicKeyChecker()) factory.portal.registerChecker(core.checkers.HoneypotPasswordChecker()) if CowrieConfig.getboolean("ssh", "auth_none_enabled", fallback=False): factory.portal.registerChecker(core.checkers.HoneypotNoneChecker()) if CowrieConfig.has_section("ssh"): listen_endpoints = get_endpoints_from_section(CowrieConfig, "ssh", 2222) else: listen_endpoints = get_endpoints_from_section( CowrieConfig, "honeypot", 2222 ) create_endpoint_services( reactor, self.topService, listen_endpoints, factory ) if self.enableTelnet: f = cowrie.telnet.factory.HoneyPotTelnetFactory(backend, self.pool_handler) f.tac = self # type: ignore f.portal = portal.Portal(core.realm.HoneyPotRealm()) f.portal.registerChecker(core.checkers.HoneypotPasswordChecker()) listen_endpoints = get_endpoints_from_section(CowrieConfig, "telnet", 2223) create_endpoint_services(reactor, self.topService, listen_endpoints, f)
def pool_ready(self): backend = CowrieConfig().get('honeypot', 'backend', fallback='shell') # this method is never called if self.pool_only is False, # since we do not start the pool handler that would call it if self.enableSSH: factory = cowrie.ssh.factory.CowrieSSHFactory(backend, self.pool_handler) factory.tac = self factory.portal = portal.Portal(core.realm.HoneyPotRealm()) factory.portal.registerChecker( core.checkers.HoneypotPublicKeyChecker()) factory.portal.registerChecker( core.checkers.HoneypotPasswordChecker()) if CowrieConfig().getboolean('ssh', 'auth_none_enabled', fallback=False): factory.portal.registerChecker( core.checkers.HoneypotNoneChecker()) if CowrieConfig().has_section('ssh'): listen_endpoints = get_endpoints_from_section(CowrieConfig(), 'ssh', 2222) else: listen_endpoints = get_endpoints_from_section(CowrieConfig(), 'honeypot', 2222) create_endpoint_services(reactor, self.topService, listen_endpoints, factory) if self.enableTelnet: f = cowrie.telnet.factory.HoneyPotTelnetFactory(backend, self.pool_handler) f.tac = self f.portal = portal.Portal(core.realm.HoneyPotRealm()) f.portal.registerChecker(core.checkers.HoneypotPasswordChecker()) listen_endpoints = get_endpoints_from_section(CowrieConfig(), 'telnet', 2223) create_endpoint_services(reactor, self.topService, listen_endpoints, f)
def test_get_endpoints_from_section(self): cfg = get_config(""" [ssh] listen_addr = 1.1.1.1 """) self.assertEqual(["tcp:2223:interface=1.1.1.1"], get_endpoints_from_section(cfg, "ssh", 2223)) cfg = get_config(""" [ssh] listen_addr = 1.1.1.1 """) self.assertEqual(["tcp:2224:interface=1.1.1.1"], get_endpoints_from_section(cfg, "ssh", 2224)) cfg = get_config(""" [ssh] listen_addr = 1.1.1.1 2.2.2.2 """) self.assertEqual( ["tcp:2223:interface=1.1.1.1", "tcp:2223:interface=2.2.2.2"], get_endpoints_from_section(cfg, "ssh", 2223), ) cfg = get_config(""" [ssh] listen_addr = 1.1.1.1 2.2.2.2 listen_port = 23 """) self.assertEqual( ["tcp:23:interface=1.1.1.1", "tcp:23:interface=2.2.2.2"], get_endpoints_from_section(cfg, "ssh", 2223), ) cfg = get_config(""" [ssh] listen_endpoints = tcp:23:interface=1.1.1.1 tcp:2323:interface=1.1.1.1 """) self.assertEqual( ["tcp:23:interface=1.1.1.1", "tcp:2323:interface=1.1.1.1"], get_endpoints_from_section(cfg, "ssh", 2223), )
def makeService(self, options): """ Construct a TCPServer from a factory defined in Cowrie. """ if options["help"] is True: print("""Usage: twistd [options] cowrie [-h] Options: -h, --help print this help message. Makes a Cowrie SSH/Telnet honeypot. """) sys.exit(1) if os.name == 'posix' and os.getuid() == 0: print('ERROR: You must not run cowrie as root!') sys.exit(1) tz = CowrieConfig().get('honeypot', 'timezone', fallback='UTC') # `system` means use the system time zone if tz != 'system': os.environ['TZ'] = tz log.msg("Python Version {}".format(str(sys.version).replace('\n', ''))) log.msg("Twisted Version {}.{}.{}".format(__twisted_version__.major, __twisted_version__.minor, __twisted_version__.micro)) log.msg("Cowrie Version {}.{}.{}".format(__cowrie_version__.major, __cowrie_version__.minor, __cowrie_version__.micro)) # check configurations if not self.enableTelnet and not self.enableSSH and not self.pool_only: print( 'ERROR: You must at least enable SSH or Telnet, or run the backend pool' ) sys.exit(1) # Load output modules self.output_plugins = [] for x in CowrieConfig().sections(): if not x.startswith('output_'): continue if CowrieConfig().getboolean(x, 'enabled') is False: continue engine = x.split('_')[1] try: output = __import__('cowrie.output.{}'.format(engine), globals(), locals(), ['output']).Output() log.addObserver(output.emit) self.output_plugins.append(output) log.msg("Loaded output engine: {}".format(engine)) except ImportError as e: log.err( "Failed to load output engine: {} due to ImportError: {}". format(engine, e)) log.msg( "Please install the dependencies for {} listed in requirements-output.txt" .format(engine)) except Exception: log.err() log.msg("Failed to load output engine: {}".format(engine)) self.topService = service.MultiService() application = service.Application('cowrie') self.topService.setServiceParent(application) # initialise VM pool handling - only if proxy AND pool set to enabled, and pool is to be deployed here # or also enabled if pool_only is true backend_type = CowrieConfig().get('honeypot', 'backend', fallback='shell') proxy_backend = CowrieConfig().get('proxy', 'backend', fallback='simple') if (backend_type == 'proxy' and proxy_backend == 'pool') or self.pool_only: # in this case we need to set some kind of pool connection local_pool = CowrieConfig().get('proxy', 'pool', fallback='local') == 'local' pool_host = CowrieConfig().get('proxy', 'pool_host', fallback='127.0.0.1') pool_port = CowrieConfig().getint('proxy', 'pool_port', fallback=6415) if local_pool or self.pool_only: # start a pool locally f = PoolServerFactory() f.tac = self listen_endpoints = get_endpoints_from_section( CowrieConfig(), 'backend_pool', 6415) create_endpoint_services(reactor, self.topService, listen_endpoints, f) pool_host = '127.0.0.1' # force use of local interface # either way (local or remote) we set up a client to the pool # unless this instance has no SSH and Telnet (pool only) if (self.enableTelnet or self.enableSSH) and not self.pool_only: self.pool_handler = PoolHandler(pool_host, pool_port, self) else: # we initialise the services directly self.pool_ready() return self.topService
def makeService(self, options: Dict) -> service.Service: """ Construct a TCPServer from a factory defined in Cowrie. """ if options["help"] is True: print("""Usage: twistd [options] cowrie [-h] Options: -h, --help print this help message. Makes a Cowrie SSH/Telnet honeypot. """) sys.exit(1) if os.name == "posix" and os.getuid() == 0: print("ERROR: You must not run cowrie as root!") sys.exit(1) tz: str = CowrieConfig.get("honeypot", "timezone", fallback="UTC") # `system` means use the system time zone if tz != "system": os.environ["TZ"] = tz log.msg("Python Version {}".format(str(sys.version).replace("\n", ""))) log.msg("Twisted Version {}.{}.{}".format( __twisted_version__.major, __twisted_version__.minor, __twisted_version__.micro, )) log.msg("Cowrie Version {}.{}.{}".format( __cowrie_version__.major, __cowrie_version__.minor, __cowrie_version__.micro, )) # check configurations if not self.enableTelnet and not self.enableSSH and not self.pool_only: print( "ERROR: You must at least enable SSH or Telnet, or run the backend pool" ) sys.exit(1) # Load output modules self.output_plugins = [] for x in CowrieConfig.sections(): if not x.startswith("output_"): continue if CowrieConfig.getboolean(x, "enabled") is False: continue engine: str = x.split("_")[1] try: output = __import__(f"cowrie.output.{engine}", globals(), locals(), ["output"]).Output() log.addObserver(output.emit) self.output_plugins.append(output) log.msg(f"Loaded output engine: {engine}") except ImportError as e: log.err( f"Failed to load output engine: {engine} due to ImportError: {e}" ) log.msg( f"Please install the dependencies for {engine} listed in requirements-output.txt" ) except Exception: log.err() log.msg(f"Failed to load output engine: {engine}") self.topService = service.MultiService() application = service.Application("cowrie") self.topService.setServiceParent(application) # initialise VM pool handling - only if proxy AND pool set to enabled, and pool is to be deployed here # or also enabled if pool_only is true backend_type: str = CowrieConfig.get("honeypot", "backend", fallback="shell") proxy_backend: str = CowrieConfig.get("proxy", "backend", fallback="simple") if (backend_type == "proxy" and proxy_backend == "pool") or self.pool_only: # in this case we need to set some kind of pool connection local_pool: bool = (CowrieConfig.get("proxy", "pool", fallback="local") == "local") pool_host: str = CowrieConfig.get("proxy", "pool_host", fallback="127.0.0.1") pool_port: int = CowrieConfig.getint("proxy", "pool_port", fallback=6415) if local_pool or self.pool_only: # start a pool locally f = PoolServerFactory() f.tac = self listen_endpoints = get_endpoints_from_section( CowrieConfig, "backend_pool", 6415) create_endpoint_services(reactor, self.topService, listen_endpoints, f) pool_host = "127.0.0.1" # force use of local interface # either way (local or remote) we set up a client to the pool # unless this instance has no SSH and Telnet (pool only) if (self.enableTelnet or self.enableSSH) and not self.pool_only: self.pool_handler = PoolHandler(pool_host, pool_port, self) # type: ignore else: # we initialise the services directly self.pool_ready() return self.topService
def makeService(self, options): """ Construct a TCPServer from a factory defined in Cowrie. """ if options["help"] is True: print("""Usage: twistd [options] cowrie [-h] Options: -h, --help print this help message. Makes a Cowrie SSH/Telnet honeypot. """) sys.exit(1) if os.name == 'posix' and os.getuid() == 0: print('ERROR: You must not run cowrie as root!') sys.exit(1) tz = CONFIG.get('honeypot', 'timezone', fallback='UTC') # `system` means use the system time zone if tz != 'system': os.environ['TZ'] = tz log.msg("Python Version {}".format(str(sys.version).replace('\n', ''))) log.msg("Twisted Version {}.{}.{}".format(__version__.major, __version__.minor, __version__.micro)) # ssh is enabled by default enableSSH = CONFIG.getboolean('ssh', 'enabled', fallback=True) # telnet is disabled by default enableTelnet = CONFIG.getboolean('telnet', 'enabled', fallback=False) if enableTelnet is False and enableSSH is False: print('ERROR: You must at least enable SSH or Telnet') sys.exit(1) # Load output modules self.output_plugins = [] for x in CONFIG.sections(): if not x.startswith('output_'): continue if CONFIG.getboolean(x, 'enabled') is False: continue engine = x.split('_')[1] try: output = __import__('cowrie.output.{}'.format(engine), globals(), locals(), ['output']).Output() log.addObserver(output.emit) self.output_plugins.append(output) log.msg("Loaded output engine: {}".format(engine)) except ImportError as e: log.err("Failed to load output engine: {} due to ImportError: {}".format(engine, e)) log.msg("Please install the dependencies for {} listed in requirements-output.txt".format(engine)) except Exception: log.err() log.msg("Failed to load output engine: {}".format(engine)) topService = service.MultiService() application = service.Application('cowrie') topService.setServiceParent(application) if enableSSH: factory = cowrie.ssh.factory.CowrieSSHFactory() factory.tac = self factory.portal = portal.Portal(core.realm.HoneyPotRealm()) factory.portal.registerChecker( core.checkers.HoneypotPublicKeyChecker()) factory.portal.registerChecker( core.checkers.HoneypotPasswordChecker()) if CONFIG.getboolean('honeypot', 'auth_none_enabled', fallback=False) is True: factory.portal.registerChecker( core.checkers.HoneypotNoneChecker()) if CONFIG.has_section('ssh'): listen_endpoints = get_endpoints_from_section(CONFIG, 'ssh', 2222) else: listen_endpoints = get_endpoints_from_section(CONFIG, 'honeypot', 2222) create_endpoint_services(reactor, topService, listen_endpoints, factory) if enableTelnet: f = cowrie.telnet.transport.HoneyPotTelnetFactory() f.tac = self f.portal = portal.Portal(core.realm.HoneyPotRealm()) f.portal.registerChecker(core.checkers.HoneypotPasswordChecker()) listen_endpoints = get_endpoints_from_section(CONFIG, 'telnet', 2223) create_endpoint_services(reactor, topService, listen_endpoints, f) return topService
def makeService(self, options): """ Construct a TCPServer from a factory defined in Cowrie. """ if options["help"] == True: self.printHelp() sys.exit(1) if os.name == 'posix' and os.getuid() == 0: print('ERROR: You must not run cowrie as root!') sys.exit(1) cfg = readConfigFile( ("cowrie.cfg.dist", "etc/cowrie.cfg", "cowrie.cfg")) # ssh is enabled by default if cfg.has_option('ssh', 'enabled') == False or \ (cfg.has_option('ssh', 'enabled') and \ cfg.getboolean('ssh', 'enabled') == True): enableSSH = True else: enableSSH = False # telnet is disabled by default if cfg.has_option('telnet', 'enabled') and \ cfg.getboolean('telnet', 'enabled') == True: enableTelnet = True else: enableTelnet = False if enableTelnet == False and enableSSH == False: print('ERROR: You must at least enable SSH or Telnet') sys.exit(1) # Load db loggers self.dbloggers = [] for x in cfg.sections(): if not x.startswith('database_'): continue engine = x.split('_')[1] try: dblogger = __import__('cowrie.dblog.{}'.format(engine), globals(), locals(), ['dblog']).DBLogger(cfg) log.addObserver(dblogger.emit) self.dbloggers.append(dblogger) log.msg("Loaded dblog engine: {}".format(engine)) except: log.err() log.msg("Failed to load dblog engine: {}".format(engine)) # Load output modules self.output_plugins = [] for x in cfg.sections(): if not x.startswith('output_'): continue engine = x.split('_')[1] try: output = __import__('cowrie.output.{}'.format(engine), globals(), locals(), ['output']).Output(cfg) log.addObserver(output.emit) self.output_plugins.append(output) log.msg("Loaded output engine: {}".format(engine)) except ImportError as e: log.err( "Failed to load output engine: {} due to ImportError: {}". format(engine, e)) log.msg( "Please install the dependencies for {} listed in requirements-output.txt" .format(engine)) except Exception: log.err() log.msg("Failed to load output engine: {}".format(engine)) topService = service.MultiService() application = service.Application('cowrie') topService.setServiceParent(application) if enableSSH: factory = cowrie.ssh.factory.CowrieSSHFactory(cfg) factory.tac = self factory.portal = portal.Portal(core.realm.HoneyPotRealm(cfg)) factory.portal.registerChecker( core.checkers.HoneypotPublicKeyChecker()) factory.portal.registerChecker( core.checkers.HoneypotPasswordChecker(cfg)) if cfg.has_option('honeypot', 'auth_none_enabled') and \ cfg.getboolean('honeypot', 'auth_none_enabled') == True: factory.portal.registerChecker( core.checkers.HoneypotNoneChecker()) if cfg.has_section('ssh'): listen_endpoints = get_endpoints_from_section(cfg, 'ssh', 22) else: listen_endpoints = get_endpoints_from_section( cfg, 'honeypot', 22) create_endpoint_services(reactor, topService, listen_endpoints, factory) if enableTelnet: f = cowrie.telnet.transport.HoneyPotTelnetFactory(cfg) f.tac = self f.portal = portal.Portal(core.realm.HoneyPotRealm(cfg)) f.portal.registerChecker( core.checkers.HoneypotPasswordChecker(cfg)) listen_endpoints = get_endpoints_from_section(cfg, 'telnet', 23) create_endpoint_services(reactor, topService, listen_endpoints, f) return topService
def makeService(self, options): """ Construct a TCPServer from a factory defined in Cowrie. """ if options["help"] is True: print("""Usage: twistd [options] cowrie [-h] Options: -h, --help print this help message. Makes a Cowrie SSH/Telnet honeypot. """) sys.exit(1) if os.name == 'posix' and os.getuid() == 0: print('ERROR: You must not run cowrie as root!') sys.exit(1) log.msg("Python Version {}".format(str(sys.version).replace('\n', ''))) log.msg("Twisted Version {}.{}.{}".format(__version__.major, __version__.minor, __version__.micro)) # ssh is enabled by default try: enableSSH = CONFIG.getboolean('ssh', 'enabled') except (configparser.NoSectionError, configparser.NoOptionError): enableSSH = True # telnet is disabled by default try: enableTelnet = CONFIG.getboolean('telnet', 'enabled') except (configparser.NoSectionError, configparser.NoOptionError): enableTelnet = False if enableTelnet is False and enableSSH is False: print('ERROR: You must at least enable SSH or Telnet') sys.exit(1) # Load db loggers self.dbloggers = [] for x in CONFIG.sections(): if not x.startswith('database_'): continue engine = x.split('_')[1] try: dblogger = __import__('cowrie.dblog.{}'.format(engine), globals(), locals(), ['dblog']).DBLogger() log.addObserver(dblogger.emit) self.dbloggers.append(dblogger) log.msg("Loaded dblog engine: {}".format(engine)) except Exception: log.err() log.msg("Failed to load dblog engine: {}".format(engine)) # Load output modules self.output_plugins = [] for x in CONFIG.sections(): if not x.startswith('output_'): continue if CONFIG.getboolean(x, 'enabled') is False: continue engine = x.split('_')[1] try: output = __import__('cowrie.output.{}'.format(engine), globals(), locals(), ['output']).Output() log.addObserver(output.emit) self.output_plugins.append(output) log.msg("Loaded output engine: {}".format(engine)) except ImportError as e: log.err( "Failed to load output engine: {} due to ImportError: {}". format(engine, e)) log.msg( "Please install the dependencies for {} listed in requirements-output.txt" .format(engine)) except Exception: log.err() log.msg("Failed to load output engine: {}".format(engine)) topService = service.MultiService() application = service.Application('cowrie') topService.setServiceParent(application) if enableSSH: factory = cowrie.ssh.factory.CowrieSSHFactory() factory.tac = self factory.portal = portal.Portal(core.realm.HoneyPotRealm()) factory.portal.registerChecker( core.checkers.HoneypotPublicKeyChecker()) factory.portal.registerChecker( core.checkers.HoneypotPasswordChecker()) if CONFIG.has_option('honeypot', 'auth_none_enabled') and \ CONFIG.getboolean('honeypot', 'auth_none_enabled') is True: factory.portal.registerChecker( core.checkers.HoneypotNoneChecker()) if CONFIG.has_section('ssh'): listen_endpoints = get_endpoints_from_section( CONFIG, 'ssh', 2222) else: listen_endpoints = get_endpoints_from_section( CONFIG, 'honeypot', 2222) create_endpoint_services(reactor, topService, listen_endpoints, factory) if enableTelnet: f = cowrie.telnet.transport.HoneyPotTelnetFactory() f.tac = self f.portal = portal.Portal(core.realm.HoneyPotRealm()) f.portal.registerChecker(core.checkers.HoneypotPasswordChecker()) listen_endpoints = get_endpoints_from_section( CONFIG, 'telnet', 2223) create_endpoint_services(reactor, topService, listen_endpoints, f) return topService
def makeService(self, options): """ Construct a TCPServer from a factory defined in Cowrie. """ if options["help"] == True: self.printHelp() sys.exit(1) if os.name == 'posix' and os.getuid() == 0: print('ERROR: You must not run cowrie as root!') sys.exit(1) cfg = readConfigFile(("cowrie.cfg.dist", "etc/cowrie.cfg", "cowrie.cfg")) # ssh is enabled by default if cfg.has_option('ssh', 'enabled') == False or \ (cfg.has_option('ssh', 'enabled') and \ cfg.getboolean('ssh', 'enabled') == True): enableSSH = True else: enableSSH = False # telnet is disabled by default if cfg.has_option('telnet', 'enabled') and \ cfg.getboolean('telnet', 'enabled') == True: enableTelnet = True else: enableTelnet = False # coap is enabled by default if cfg.has_option('coap', 'enabled') == False or \ (cfg.has_option('coap', 'enabled') and \ cfg.getboolean('coap', 'enabled') == True): enableCoAP = True else: enableCoAP = False if enableTelnet == False and enableSSH == False and enableCoAP == False: print('ERROR: You must at least enable SSH or Telnet or CoAP') sys.exit(1) # Load db loggers self.dbloggers = [] for x in cfg.sections(): if not x.startswith('database_'): continue engine = x.split('_')[1] try: dblogger = __import__( 'cowrie.dblog.{}'.format(engine), globals(), locals(), ['dblog']).DBLogger(cfg) log.addObserver(dblogger.emit) self.dbloggers.append(dblogger) log.msg("Loaded dblog engine: {}".format(engine)) except: log.err() log.msg("Failed to load dblog engine: {}".format(engine)) # Load output modules self.output_plugins = [] for x in cfg.sections(): if not x.startswith('output_'): continue engine = x.split('_')[1] try: output = __import__( 'cowrie.output.{}'.format(engine), globals(), locals(), ['output']).Output(cfg) log.addObserver(output.emit) self.output_plugins.append(output) log.msg("Loaded output engine: {}".format(engine)) except ImportError as e: log.err("Failed to load output engine: {} due to ImportError: {}".format(engine, e)) log.msg("Please install the dependencies for {} listed in requirements-output.txt".format(engine)) except Exception: log.err() log.msg("Failed to load output engine: {}".format(engine)) topService = service.MultiService() application = service.Application('cowrie') topService.setServiceParent(application) if enableSSH: factory = cowrie.ssh.factory.CowrieSSHFactory(cfg) factory.tac = self factory.portal = portal.Portal(core.realm.HoneyPotRealm(cfg)) factory.portal.registerChecker( core.checkers.HoneypotPublicKeyChecker()) factory.portal.registerChecker( core.checkers.HoneypotPasswordChecker(cfg)) if cfg.has_option('honeypot', 'auth_none_enabled') and \ cfg.getboolean('honeypot', 'auth_none_enabled') == True: factory.portal.registerChecker( core.checkers.HoneypotNoneChecker()) if cfg.has_section('ssh'): listen_endpoints = get_endpoints_from_section(cfg, 'ssh', 2222) else: listen_endpoints = get_endpoints_from_section(cfg, 'honeypot', 2222) create_endpoint_services(reactor, topService, listen_endpoints, factory) if enableTelnet: f = cowrie.telnet.transport.HoneyPotTelnetFactory(cfg) f.tac = self f.portal = portal.Portal(core.realm.HoneyPotRealm(cfg)) f.portal.registerChecker(core.checkers.HoneypotPasswordChecker(cfg)) listen_endpoints = get_endpoints_from_section(cfg, 'telnet', 2223) create_endpoint_services(reactor, topService, listen_endpoints, f) if enableCoAP: # fact = cowrie.coap.factory.CowrieCoAPFactory(cfg) # factory.tac = self # fact.portal = portal.Portal(core.realm.HoneyPotRealm(cfg)) # fact.portal.registerChecker(core.checkers.HoneypotPasswordChecker(cfg)) listen_endpoints = get_endpoints_from_section(cfg, 'coap', 5683) # print (listen_endpoints[0].split(':')[1]) # create_endpoint_services(reactor, topService, listen_endpoints, fact) root = resource.CoAPResource() well_known = resource.CoAPResource() root.putChild('.well-known', well_known) coreCoAP = CoreResource(root) well_known.putChild('core', coreCoAP) counter = CounterResource(5000) root.putChild('counter', counter) time = TimeResource() root.putChild('time', time) other = resource.CoAPResource() root.putChild('other', other) block = BlockResource() other.putChild('block', block) separate = SeparateLargeResource() other.putChild('separate', separate) endpoint = resource.Endpoint(root) reactor.listenUDP(int(listen_endpoints[0].split(':')[1]), coap.Coap(endpoint)) #, interface="::") log.msg(eventid='cowrie.coap.connected', protocol='CoAP') # internet.StreamServerEndpointService(endpoint, factory).setServiceParent(topService) # endpoint = resource.Endpoint(root) # service_object = reactor.listenUDP(int(port), coap.Coap(endpoint)) return topService