def manhole_server(portnum=None, username=None, password=None): from twisted.internet import reactor from twisted.manhole import telnet f = telnet.ShellFactory() f.username = defaults.MANHOLE_USERNAME if username is None else username f.password = defaults.MANHOLE_PASSWORD if password is None else password portnum = defaults.MANHOLE_PORT if portnum is None else portnum reactor.listenTCP(portnum, f)
def create_shell_server(): logging.debug('Creating shell server instance') factory = telnet.ShellFactory() port = reactor.listenTCP(7984, factory) factory.namespace = construct_namespace() factory.username = '******' factory.password = '******' logging.debug('Listening on port 7984') return port
def createShellServer(): manhole_port = self.port factory = telnet.ShellFactory() port = reactor.listenTCP(manhole_port, factory) factory.username = '******' factory.password = self.password factory.namespace['objgraph'] = objgraph factory.namespace['memory_util'] = self print "Manhole listening on port %s", manhole_port return port
def run(proxyport, serverport, detached=[]): # import os # if os.path.exists(DB_FILENAME): # os.remove(DB_FILENAME) engine = create_engine(DB_URL) #engine.raw_connection().connection.text_factory = str metadata = MetaData(engine) global tbl_packets global tbl_session_counter tbl_packets = Table('packets', metadata, *packets_columns) tbl_session_counter = Table('session_counter', metadata, *session_counter_columns) metadata.create_all() global db_worker db_worker = DBWorker() db_worker.start() proxy_factory = LoggingProxyFactory('localhost', serverport, db_worker, detached=detached) reactor.listenTCP(proxyport, proxy_factory) factory = telnet.ShellFactory() port = reactor.listenTCP(8787, factory) factory.namespace['proxy'] = proxy_factory def injectMsg(addr, message): from network import sccpclientprotocol framed = sccpclientprotocol.to_frame(message.pack()) proxy_factory.inject(addr, framed) factory.namespace['injectMsg'] = injectMsg factory.namespace['injectHex'] = proxy_factory.injectHex import pkgutil for imp, name, flag in pkgutil.iter_modules(sccp.__path__): mod = imp.find_module(name).load_module(name) factory.namespace[name] = mod factory.username = '******' factory.password = '******' reactor.run() db_worker.stop()
def run(filter=None, inject=False, debug=False): engine = create_engine(DB_URL) metadata = MetaData(engine) global tbl_packets global tbl_session_counter tbl_packets = Table('messages', metadata, *model.messages_columns) tbl_session_counter = Table('session_counter', metadata, *model.session_counter_columns) metadata.create_all() packets = get_packets(tbl_packets, filter) packets = append_delta(packets) packets_by_session = group_packets_by_session(packets) ip_gen = localhost_ip_gen() for session, packets in packets_by_session: packets = list(packets) packet_first = packets[0] srcaddr = packet_first['srcaddr'] srcport = packet_first['srcport'] dstaddr = packet_first['dstaddr'] dstport = packet_first['dstport'] factory = EchoFactory(packets, srcaddr, srcport, inject=inject, debug=debug) client_ip = ip_gen.next() bindAddress = (client_ip, 0) reactor.connectTCP(dstaddr, dstport, factory, bindAddress=bindAddress) factory = telnet.ShellFactory() port = reactor.listenTCP(8989, factory) factory.namespace['injections'] = injections factory.namespace['step'] = step factory.username = '******' factory.password = '******' reactor.run()
def createShellServer(self, user='******', password='******', port=2000, instances={}): print 'Creating shell server instance' factory = telnet.ShellFactory() listen_port = reactor.listenTCP(port, factory) # for instance_id, instance_detail in get_instances_detail().iteritems(): for instance_id, instance_detail in instances.iteritems(): name = re.sub('[\s]', '_', instance_detail['name'].lower()) factory.namespace.update({ name: instance_detail['instance'], instance_id: instance_detail['instance'] }) factory.username = user factory.password = password print 'Listening on port ' + str(port) return listen_port
def makeService(configuration): settings = Config(['']) settings.load(configuration) if not settings.header: sys.exit(1) serviceCollection = service.MultiService() poker_service = PokerService(settings) poker_service.setServiceParent(serviceCollection) poker_factory = IPokerFactory(poker_service) # # Poker protocol (with or without SSL) # tcp_port = settings.headerGetInt("/server/listen/@tcp") internet.TCPServer(tcp_port, poker_factory).setServiceParent(serviceCollection) tcp_ssl_port = settings.headerGetInt("/server/listen/@tcp_ssl") if HAS_OPENSSL and tcp_ssl_port: internet.SSLServer( tcp_ssl_port, poker_factory, SSLContextFactory(settings)).setServiceParent(serviceCollection) rest_site = PokerSite(settings, PokerRestTree(poker_service)) # # HTTP (with or without SLL) that implements REST # rest_port = settings.headerGetInt("/server/listen/@rest") if rest_port: internet.TCPServer(rest_port, rest_site).setServiceParent(serviceCollection) rest_ssl_port = settings.headerGetInt("/server/listen/@rest_ssl") if HAS_OPENSSL and rest_ssl_port: internet.SSLServer( rest_ssl_port, rest_site, SSLContextFactory(settings)).setServiceParent(serviceCollection) http_site = server.Site(PokerTree(poker_service)) # # HTTP (with or without SLL) that implements XML-RPC and SOAP # http_port = settings.headerGetInt("/server/listen/@http") if http_port: internet.TCPServer(http_port, http_site).setServiceParent(serviceCollection) http_ssl_port = settings.headerGetInt("/server/listen/@http_ssl") if HAS_OPENSSL and http_ssl_port: internet.SSLServer( http_ssl_port, http_site, SSLContextFactory(settings)).setServiceParent(serviceCollection) # # TELNET twisted.manhole (without SSL) # manhole_port = settings.headerGetInt("/server/listen/@manhole") if manhole_port: manhole_factory = telnet.ShellFactory() manhole_factory.namespace['poker_service'] = poker_service manhole_factory.namespace['poker_site'] = rest_site manhole_service = internet.TCPServer(manhole_port, manhole_factory, interface='127.0.0.1') manhole_service.setName("manhole") manhole_service.setServiceParent(serviceCollection) if settings.headerGetInt("/server/@verbose") > 0: print "PokerManhole: manhole is useful for debugging, use with telnet admin/admin, however, it can be a security risk and should be used only during debugging" return serviceCollection
def makeService(config): t = telnet.ShellFactory() t.username, t.password = config['username'], config['password'] s = strports.service(config['port'], t) t.setService(s) return s
val = soft break log.msg('%s file descriptors available (system max is %s)' % (val, hard)) except: log.msg('Error setting fd limit!') traceback.print_exc() # Check memory usage check_memory(int(config.get('memory_limit', 1000))) # Start request handler event loop try: import handler factory = handler.RequestHandler(config) reactor.listenTCP(int(config['port']), factory) except: mail.error('Error starting handler!\n%s' % traceback.format_exc()) shell = telnet.ShellFactory() shell.username = '******' shell.password = '******' try: reactor.listenTCP(4040, shell) log.msg('Telnet server running on port 4040.') except: log.msg('Telnet server not running.') # Run reactor.run()
import random import string import sys from twisted.internet import reactor from twisted.manhole import telnet from twisted.python import log alphabet = string.ascii_letters + string.digits + "?!.;:*+" length = random.randrange(10, 20) password = "".join(random.choice(alphabet) for _ in xrange(length)) factory = telnet.ShellFactory() factory.password = password log.startLogging(sys.stdout) log.msg("Password: {}".format(password)) reactor.listenTCP(9999, factory) reactor.run()