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