def connectionLost(self, reason):
"""
Fires on pre-authentication disconnects
"""
self.setTimeout(None)
TelnetTransport.connectionLost(self, reason)
# close transport on backend
if self.client and self.client.transport:
self.client.transport.loseConnection()
# signal that we're closing to the handler
self.telnetHandler.close()
if self.pool_interface:
# free VM from pool (VM was used if auth was performed successfully)
self.pool_interface.send_vm_free(self.telnetHandler.authDone)
# close transport connection to pool
self.pool_interface.transport.loseConnection()
if self.startTime is not None: # startTime is not set when auth fails
duration = time.time() - self.startTime
log.msg(eventid='cowrie.session.closed',
format='Connection lost after %(duration)d seconds',
duration=duration)
def connectionMade(self):
"""
"""
self.transportId = uuid.uuid4().hex[:12]
sessionno = self.transport.sessionno
self.startTime = time.time()
try:
self.setTimeout(CONFIG.getint('honeypot',
'authentication_timeout'))
except NoOptionError:
self.setTimeout(120)
log.msg(
eventid='cowrie.session.connect',
format=
'New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: %(session)s]',
src_ip=self.transport.getPeer().host,
src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host,
dst_port=self.transport.getHost().port,
session=self.transportId,
sessionno='T{0}'.format(str(sessionno)),
protocol='telnet')
TelnetTransport.connectionMade(self)
def connectionLost(self, reason):
"""
Fires on pre-authentication disconnects
"""
self.setTimeout(None)
TelnetTransport.connectionLost(self, reason)
duration = time.time() - self.startTime
log.msg(eventid='cowrie.session.closed',
format='Connection lost after %(duration)d seconds',
duration=duration)
def connectionLost(self, reason):
"""
Fires on pre-authentication disconnects
"""
self.setTimeout(None)
TelnetTransport.connectionLost(self, reason)
duration = time.time() - self.startTime
log.msg(eventid='cowrie.session.closed',
format='Connection lost after %(duration)d seconds',
duration=duration)
def connectionMade(self):
self.transportId = uuid.uuid4().hex[:8]
sessionno = self.transport.sessionno
self.startTime = time.time()
self.setTimeout(300)
log.msg(eventid='cowrie.session.connect',
format='New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: T%(sessionno)s]',
src_ip=self.transport.getPeer().host, src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host, dst_port=self.transport.getHost().port,
session=self.transportId, sessionno='T'+str(sessionno))
TelnetTransport.connectionMade(self)
def makeService(self, options):
backendServices = service.MultiService()
clientManager = core.EngineClientManager() #sessions
clientManager.setServiceParent(backendServices)
processManager = core.EngineProcessManager()
processManager.setServiceParent(backendServices)
backend = core.Backend(processManager, clientManager)
backend.updateEngineTypes()
backendEngineBus = core.EngineBus(backend)
eng_proxy_factory = server.Site(BackendRoot(backend, backendEngineBus))
internet.TCPServer(
options['port'], eng_proxy_factory,
interface=options['host']).setServiceParent(backendServices)
if options['devel_mode']:
from twisted.conch.manhole import ColoredManhole
from twisted.conch.insults import insults
from twisted.conch.telnet import TelnetTransport, TelnetBootstrapProtocol
from twisted.internet import protocol
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
ColoredManhole, globals())
telnet_manhole = internet.TCPServer(6024, f)
telnet_manhole.setServiceParent(backendServices)
return backendServices
def _makeService(args):
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(
admin="password")
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
tsvc = internet.TCPServer(args['telnet'], f)
def chainProtocolFactory():
return insults.ServerProtocol(args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chainProtocolFactory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
#csvc = internet.TCPServer(args['ssh'], f)
m = service.MultiService()
tsvc.setServiceParent(m)
#csvc.setServiceParent(m)
return m
def _buildProtocol(self):
return TelnetTransport(
TelnetBootstrapProtocol,
insults.ServerProtocol,
_ManholeShell,
dict(self.namespace),
)
def run_interface(config):
factory = ServerFactory()
factory.protocol = lambda: TelnetTransport(JunctionTelnetInterface)
port = int(config['App']['TelnetInterfacePort'])
logging.info("starting telnet cli interface on port %d" % port)
service = TCPServer(port, factory)
service.startService()
def makeService(self, options):
"""
This service is like the desktop, but is not responsible for
controlling the kernel server process.
"""
from codenode.frontend.search import search
search.create_index()
web_app_service = service.MultiService()
web_resource = webResourceFactory(settings.MEDIA_ROOT)
serverlog = options['server_log']
web_resource_factory = server.Site(web_resource, logPath=serverlog)
frontend_server = internet.TCPServer(options['port'],
web_resource_factory,
interface=options['host'])
frontend_server.setServiceParent(web_app_service)
if options['devel_mode']:
from twisted.conch.manhole import ColoredManhole
from twisted.conch.insults import insults
from twisted.conch.telnet import TelnetTransport, TelnetBootstrapProtocol
from twisted.internet import protocol
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
ColoredManhole, globals())
telnel_manhole = internet.TCPServer(6023, f)
telnel_manhole.setServiceParent(web_app_service)
return web_app_service
def make_service(args):
def chain_protocol_factory():
return insults.ServerProtocol(args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
m = service.MultiService()
# Telnet manhole
if True:
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
tsvc = internet.TCPServer(args['telnet'], f) # @UndefinedVariable
tsvc.setServiceParent(m)
# SSH manhole
if False:
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(
user="******")
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chain_protocol_factory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
csvc = internet.TCPServer(args['ssh'], f) # @UndefinedVariable
csvc.setServiceParent(m)
return m
def start(_settings, _backend, telnet_port=8023):
"""
Start telnet server
"""
global settings
global backend
backend = _backend
# Settings
settings = _settings()
# Thread sensitive interface for stdout/stdin
std.setup()
# Telnet
telnet_factory = ServerFactory()
telnet_factory.protocol = lambda: TelnetTransport(TelnetDeployer)
# Handle signals
def handle_sigint(signal, frame):
if active_sessions:
print 'Running, %i active session(s).' % len(active_sessions)
else:
print 'No active sessions, exiting'
reactor.stop()
signal.signal(signal.SIGINT, handle_sigint)
# Run the reactor!
print 'Listening telnet on localhost:%s...' % telnet_port
reactor.listenTCP(telnet_port, telnet_factory)
reactor.run()
def makeService(factory, port, *args, **kw):
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, factory, *args, **kw)
tsvc = internet.TCPServer(port, f)
return tsvc
def connectionMade(self):
self.transportId = uuid.uuid4().hex[:12]
sessionno = self.transport.sessionno
self.startTime = time.time()
self.setTimeout(CONFIG.getint('honeypot', 'authentication_timeout', fallback=120))
log.msg(eventid='cowrie.session.connect',
format='New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: %(session)s]',
src_ip=self.transport.getPeer().host,
src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host,
dst_port=self.transport.getHost().port,
session=self.transportId,
sessionno='T{0}'.format(str(sessionno)),
protocol='telnet')
TelnetTransport.connectionMade(self)
def main(reason, *args):
Log.w(main.listeningPort)
if main.listeningPort:
return
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, ColoredManhole)
main.listeningPort = reactor.listenTCP(8007, f, interface='localhost')
def connectionLost(self, reason):
"""
Fires on pre-authentication disconnects
"""
self.setTimeout(None)
TelnetTransport.connectionLost(self, reason)
# close transport on backend
self.client.transport.loseConnection()
# signal that we're closing to the handler
self.telnetHandler.close()
duration = time.time() - self.startTime
log.msg(eventid='cowrie.session.closed',
format='Connection lost after %(duration)d seconds',
duration=duration)
def getService(self):
r = Realm()
p = portal.Portal(r)
f = protocol.ServerFactory()
f.canaryservice = self
f.logger = self.logger
f.banner = self.banner
f.protocol = lambda: TelnetTransport(AlertAuthTelnetProtocol, p)
return internet.TCPServer(self.port, f, interface=self.listen_addr)
def connectionMade(self):
self.transportId = uuid.uuid4().hex[:12]
sessionno = self.transport.sessionno
self.peer_ip = self.transport.getPeer().host
self.peer_port = self.transport.getPeer().port + 1
self.local_ip = self.transport.getHost().host
self.local_port = self.transport.getHost().port
log.msg(
eventid="cowrie.session.connect",
format=
"New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: %(session)s]",
src_ip=self.transport.getPeer().host,
src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host,
dst_port=self.transport.getHost().port,
session=self.transportId,
sessionno="T{}".format(str(sessionno)),
protocol="telnet",
)
TelnetTransport.connectionMade(self)
# if we have a pool connect to it and later request a backend, else just connect to a simple backend
# when pool is set we can just test self.pool_interface to the same effect of getting the config
proxy_backend = CowrieConfig().get("proxy",
"backend",
fallback="simple")
if proxy_backend == "pool":
# request a backend
d = self.factory.pool_handler.request_interface()
d.addCallback(self.pool_connection_success)
d.addErrback(self.pool_connection_error)
else:
# simply a proxy, no pool
backend_ip = CowrieConfig().get("proxy", "backend_telnet_host")
backend_port = CowrieConfig().getint("proxy",
"backend_telnet_port")
self.connect_to_backend(backend_ip, backend_port)
def connectionMade(self):
self.transportId = uuid.uuid4().hex[:12]
sessionno = self.transport.sessionno
self.startTime = time.time()
self.setTimeout(CowrieConfig().getint('honeypot',
'authentication_timeout',
fallback=120))
log.msg(
eventid='cowrie.session.connect',
format=
'New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: %(session)s]',
src_ip=self.transport.getPeer().host,
src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host,
dst_port=self.transport.getHost().port,
session=self.transportId,
sessionno='T{}'.format(str(sessionno)),
protocol='telnet')
TelnetTransport.connectionMade(self)
def start(port=None, host=None, telnet_vars=None):
from twisted.internet import reactor
port = int(port) if port else 6023
host = host or '127.0.0.1'
telnet_vars = telnet_vars or {}
factory = protocol.ServerFactory()
factory.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults
.ServerProtocol, ColoredManhole,
telnet_vars)
return reactor.listenTCP(port, factory, interface=host)
def connectionMade(self):
self.transportId = uuid.uuid4().hex[:12]
sessionno = self.transport.sessionno
self.startTime = time.time()
self.setTimeout(
CowrieConfig.getint("honeypot", "authentication_timeout", fallback=120)
)
log.msg(
eventid="cowrie.session.connect",
format="New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: %(session)s]",
src_ip=self.transport.getPeer().host,
src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host,
dst_port=self.transport.getHost().port,
session=self.transportId,
sessionno="T{}".format(str(sessionno)),
protocol="telnet",
)
TelnetTransport.connectionMade(self)
def __init__(self):
print "Starting up network server.."
#self.protocol is the TYPE of protocol which gets created
#it's only the function which gets called, not the actual protocol
self.parent = 0
self.child = ServerFactory()
self.child.protocol = lambda: TelnetTransport(MyProtocol)
self.protocol = self.child.protocol
self.child.id = 1
self.child.clList = {}
self.child.parent = self
self.clList = self.child.clList
print "Factory, protocol and class initialisation done."
def makeDebugCLIService(self, args):
"""
This is dangerous, and should only ever be enabled by explicit user config and only for non-production use
:param args:
:return:
"""
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
return internet.TCPServer(args['telnet'], f)
def connectionMade(self):
self.transportId = uuid.uuid4().hex[:12]
sessionno = self.transport.sessionno
self.startTime = time.time()
self.setTimeout(CowrieConfig().getint('honeypot',
'authentication_timeout',
fallback=120))
self.peer_ip = self.transport.getPeer().host
self.peer_port = self.transport.getPeer().port + 1
self.local_ip = self.transport.getHost().host
self.local_port = self.transport.getHost().port
# connection to the backend starts here
client_factory = client_transport.BackendTelnetFactory()
client_factory.server = self
reactor.connectTCP(self.honey_ip,
self.honey_port,
client_factory,
bindAddress=('0.0.0.0', 0),
timeout=10)
log.msg(
eventid='cowrie.session.connect',
format=
'New connection: %(src_ip)s:%(src_port)s (%(dst_ip)s:%(dst_port)s) [session: %(session)s]',
src_ip=self.transport.getPeer().host,
src_port=self.transport.getPeer().port,
dst_ip=self.transport.getHost().host,
dst_port=self.transport.getHost().port,
session=self.transportId,
sessionno='T{0}'.format(str(sessionno)),
protocol='telnet')
TelnetTransport.connectionMade(self)
def start(root_node,
auth_backend=None,
port=8023,
logfile=None,
extra_loggers=None):
"""
Start telnet server
"""
# Set logging
if logfile:
logging.basicConfig(filename=logfile, level=logging.DEBUG)
else:
logging.basicConfig(filename='/dev/stdout', level=logging.DEBUG)
# Thread sensitive interface for stdout/stdin
std.setup()
# Telnet
factory = ServerFactory()
factory.connectionPool = set() # List of currently, active connections
factory.protocol = lambda: TelnetTransport(TelnetDeployer)
factory.root_node = root_node()
factory.auth_backend = auth_backend
factory.extra_loggers = extra_loggers or []
# Handle signals
def handle_sigint(signal, frame):
if factory.connectionPool:
logging.info('Running, %i active session(s).' %
len(factory.connectionPool))
else:
logging.info('No active sessions, exiting')
reactor.stop()
signal.signal(signal.SIGINT, handle_sigint)
# Run the reactor!
logging.info(
'Listening for incoming telnet connections on localhost:%s...' % port)
# Set process name
suffix = (' --log "%s"' % logfile if logfile else '')
setproctitle('deploy:%s telnet-server --port %i%s' %
(root_node.__class__.__name__, port, suffix))
# Run server
reactor.listenTCP(port, factory)
reactor.run()
def make_manhole (self, xmpp_message, room, nick, message):
"""
Open up a manhole and announce our currentl ip.
"""
# control args.
args = \
{
'protocolFactory' : ColoredManhole,
'protocolArgs' : (None,),
'telnet' : 6023,
'ssh' : 6022,
}
# protocol factory.
def chainProtocolFactory():
return insults.ServerProtocol(
args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
# server factory.
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
# checker, realms.
checker = checkers.InMemoryUsernamePasswordDatabaseDontUse(pedram="iampedram")
tsvc = internet.TCPServer(args['telnet'], f)
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chainProtocolFactory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
csvc = internet.TCPServer(args['ssh'], f)
m = service.MultiService()
application = service.Application("Interactive Python Interpreter")
# scaffold.
tsvc.setServiceParent(m)
csvc.setServiceParent(m)
m.setServiceParent(application)
# determine IP address and announce.
ipaddr = requests.get("http://ifconfig.me/all.json").json()['ip_addr']
return "(successful) manhole opened @ %s" % ipaddr
def run():
initialize_logger(logging.INFO)
factory = ServerFactory()
factory.protocol = lambda: TelnetTransport(MudTelnetProtocol)
endpoints.serverFromString(reactor, "tcp:8023").listen(factory)
round_timer = task.LoopingCall(game_loop.perform_round)
round_timer.start(game_loop.ROUND_TIME)
db_timer = task.LoopingCall(game_loop.save_databases)
db_timer.start(game_loop.DB_SAVE_TIME)
heal_timer = task.LoopingCall(game_loop.perform_heal)
heal_timer.start(game_loop.HEAL_TIME)
regen_timer = task.LoopingCall(game_loop.perform_regen)
regen_timer.start(game_loop.REGEN_TIME)
print "running on port 8023..."
reactor.run()
def genSSHProtocol(args):
checker = Auth.LDAPChecker(Settings.LDAPServer, Settings.LDAPManager,
Settings.LDAPPass, Settings.LDAPBase)
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(
TelnetBootstrapProtocol, insults.ServerProtocol, args[
'protocolFactory'], *args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
#tsvc = internet.TCPServer(args['telnet'], f)
def chainProtocolFactory():
return insults.ServerProtocol(args['protocolFactory'],
*args.get('protocolArgs', ()),
**args.get('protocolKwArgs', {}))
rlm = TerminalRealm()
rlm.chainedProtocolFactory = chainProtocolFactory
ptl = portal.Portal(rlm, [checker])
f = ConchFactory(ptl)
return f
def makeService(self, options):
"""
This service is like the desktop, but is not responsible for
controlling the kernel server process.
"""
from codenode.frontend.search import search
search.create_index()
web_app_service = service.MultiService()
if options['devel_mode']:
staticfiles = os.path.join(lib_path, 'frontend', 'static')
else:
staticfiles = options['static_files']
datafiles = options['env_path'] + "/data/plot_images" #XXX
#Temporary hack
if not os.path.exists(datafiles):
os.mkdir(datafiles)
web_resource = webResourceFactory(staticfiles, datafiles)
serverlog = options['server_log']
web_resource_factory = server.Site(web_resource, logPath=serverlog)
frontend_server = internet.TCPServer(options['port'],
web_resource_factory,
interface=options['host'])
frontend_server.setServiceParent(web_app_service)
if options['devel_mode']:
from twisted.conch.manhole import ColoredManhole
from twisted.conch.insults import insults
from twisted.conch.telnet import TelnetTransport, TelnetBootstrapProtocol
from twisted.internet import protocol
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol,
insults.ServerProtocol,
ColoredManhole, globals())
telnel_manhole = internet.TCPServer(6023, f)
telnel_manhole.setServiceParent(web_app_service)
return web_app_service
def connectionMade(self):
TelnetTransport.connectionMade(self)
self.factory.open_channels.append(self.protocol)
def connectionLost(self, reason):
self.factory.open_channels.remove(self.protocol)
TelnetTransport.connectionLost(self, reason)
def telent_server_main(self):
_q_s = self
class CustomTelnetProtocol(TelnetProtocol):
_state = None
_user = None
_pass = None
def connectionMade(self):
self._state = None
self._user = None
self._pass = None
self.transport.write(b'PC login: '******'server': 'telnet_server',
'action': 'connection',
'ip': self.transport.getPeer().host,
'port': self.transport.getPeer().port
}
])
def dataReceived(self, data):
data = data.strip()
if self._state == b'Username':
self._user = data
self._state = b"Password"
self.transport.write(b'Password: '******'Password':
self._pass = data
if self._user == _q_s.username and self._pass == _q_s.password:
_q_s.logs.info([
"servers", {
'server': 'telnet_server',
'action': 'login',
'status': 'success',
'ip': self.transport.getPeer().host,
'port': self.transport.getPeer().port,
'username': _q_s.username.decode('utf-8'),
'password': _q_s.password.decode('utf-8')
}
])
else:
_q_s.logs.info([
"servers", {
'server': 'telnet_server',
'action': 'login',
'status': 'failed',
'ip': self.transport.getPeer().host,
'port': self.transport.getPeer().port,
'username': self._user.decode('utf-8'),
'password': self._pass.decode('utf-8')
}
])
self.transport.loseConnection()
else:
self.transport.loseConnection()
def connectionLost(self, reason):
self._state = None
self._user = None
self._pass = None
factory = Factory()
factory.protocol = lambda: TelnetTransport(CustomTelnetProtocol)
reactor.listenTCP(port=self.port, factory=factory, interface=self.ip)
reactor.run()
def main(*args, **kwargs):
f = protocol.ServerFactory()
f.protocol = lambda: TelnetTransport(TelnetBootstrapProtocol, insults.
ServerProtocol, ColoredManhole)
reactor.listenTCP(8007, f, interface='localhost')
def buildProtocol(self, addr):
p = TelnetTransport(TelnetClient)
p.factory = self
return p
def protocol():
return TelnetTransport(self.protocol, self)
def buildProtocol(self, addr):
p = TelnetTransport(MaestroClientProtocol)
p.factory = self
return p