def run(self):
"""
Negotiate a connecting session.
In the case of telnet and ssh, for example, negotiates and
inquires about terminal type, telnet options, window size,
and tcp socket options before spawning a new session.
"""
try:
self._set_socket_opts()
self.banner()
if self.client.is_active():
return spawn_client_session(client=self.client)
except (Disconnected, socket.error) as err:
self.log.debug('Connection closed: %s', err)
finally:
self.stopped = True
self.client.deactivate()
def run(self):
"""
Negotiate a connecting session.
In the case of telnet and ssh, for example, negotiates and
inquires about terminal type, telnet options, window size,
and tcp socket options before spawning a new session.
"""
try:
self._set_socket_opts()
self.banner()
if self.client.is_active():
return spawn_client_session(client=self.client)
except (Disconnected, socket.error) as err:
self.log.debug("Connection closed: %s", err)
finally:
self.stopped = True
self.client.deactivate()
def run(self):
"""
Perform rfc1282 (rlogin) connection establishment.
Determine terminal type, telnet options, window size,
and tcp socket options before spawning a new session.
"""
try:
self._set_socket_opts()
self.banner()
# Receive on-connect data-value pairs, may raise ValueError.
data = self.get_connect_data()
# parse into dict,
parsed = self.parse_connect_data(data)
for key, value in parsed.items():
if value:
self.log.debug('{client.addrport}: {key}={value}'
.format(client=self.client,
key=key, value=value))
# and apply to session-local self.client.env.
self.apply_environment(parsed)
# The server returns a zero byte to indicate that it has received
# these strings and is now in data transfer mode.
if self.client.is_active():
self.client.send_str(bytes('\x00'))
# The remote server indicates to the client that it can accept
# window size change information by requesting a window size
# message (as out of band data) just after connection
# establishment and user identification exchange. The client
# should reply to this request with the current window size.
#
# Disabled: neither SyncTERM or BSD rlogin honors this, and
# we haven't got any code to parse it. Its in the RFC but ..
self.client.send_urgent_str(bytes('\x80'))
matrix_kwargs = {}
username = parsed.get('server-user-name', 'new')
if check_new_user(username):
# new@ login may be allowed
matrix_kwargs['new'] = True
if check_bye_user(username):
# rlogin as 'bye', 'logoff', etc. not allowed
raise ValueError('Bye user {0!r} used by rlogin'
.format(username))
if check_anonymous_user(username):
# anonymous@ login may be allowed
matrix_kwargs['anonymous'] = True
if self.client.is_active():
return spawn_client_session(client=self.client,
matrix_kwargs=matrix_kwargs)
except socket.error as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
except EOFError:
self.log.debug('{client.addrport}: EOF from client'
.format(client=self.client))
except Exception as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
finally:
self.stopped = True
self.client.deactivate()
def run(self):
""" Accept new Ssh connect in thread. """
try:
self.client.transport = paramiko.Transport(self.client.sock)
self.client.transport.load_server_moduli()
self.client.transport.add_server_key(self.server_host_key)
ssh_session = SshSessionServer(client=self.client)
from x84.bbs import get_ini
if get_ini(section='sftp', key='enabled', getter='getboolean'):
self.client.transport.set_subsystem_handler(
'sftp', paramiko.SFTPServer, X84SFTPServer,
ssh_session=ssh_session)
def detected():
""" Whether shell or SFTP session has been detected. """
return (ssh_session.shell_requested.isSet() or
ssh_session.sftp_requested.isSet())
self.client.transport.start_server(server=ssh_session)
st_time = time.time()
while self._timeleft(st_time):
self.client.channel = self.client.transport.accept(1)
if self.client.channel is not None:
break
if not self.client.transport.is_active():
self.log.debug('{client.addrport}: transport closed.'
.format(client=self.client))
self.client.deactivate()
return
else:
self.log.debug('{client.addrport}: no channel requested'
.format(client=self.client))
self.client.deactivate()
return
first_log = False
while not detected() and self._timeleft(st_time):
if not first_log:
self.log.debug('{client.addrport}: waiting for '
'shell or subsystem request.'
.format(client=self.client))
first_log = True
if not self.client.is_active():
self.log.debug('{client.addrport}: transport closed '
'while waiting for shell or subsystem '
'request.'
.format(client=self.client))
self.client.deactivate()
return
time.sleep(self.TIME_POLL)
if detected():
matrix_kwargs = {attr: getattr(ssh_session, attr)
for attr in ('anonymous', 'new', 'username',)}
return spawn_client_session(client=self.client,
matrix_kwargs=matrix_kwargs)
except (paramiko.SSHException, socket.error) as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
except EOFError:
self.log.debug('{client.addrport}: EOF from client'
.format(client=self.client))
except Exception as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
else:
self.log.debug('{client.addrport}: shell not requested'
.format(client=self.client))
finally:
self.stopped = True
self.client.deactivate()
def run(self):
"""
Perform rfc1282 (rlogin) connection establishment.
Determine terminal type, telnet options, window size,
and tcp socket options before spawning a new session.
"""
try:
self._set_socket_opts()
self.banner()
# Receive on-connect data-value pairs, may raise ValueError.
data = self.get_connect_data()
# parse into dict,
parsed = self.parse_connect_data(data)
for key, value in parsed.items():
if value:
self.log.debug('{client.addrport}: {key}={value}'.format(
client=self.client, key=key, value=value))
# and apply to session-local self.client.env.
self.apply_environment(parsed)
# The server returns a zero byte to indicate that it has received
# these strings and is now in data transfer mode.
if self.client.is_active():
self.client.send_str(bytes('\x00'))
# The remote server indicates to the client that it can accept
# window size change information by requesting a window size
# message (as out of band data) just after connection
# establishment and user identification exchange. The client
# should reply to this request with the current window size.
#
# Disabled: neither SyncTERM or BSD rlogin honors this, and
# we haven't got any code to parse it. Its in the RFC but ..
self.client.send_urgent_str(bytes('\x80'))
matrix_kwargs = {}
username = parsed.get('server-user-name', 'new')
if check_new_user(username):
# new@ login may be allowed
matrix_kwargs['new'] = True
if check_bye_user(username):
# rlogin as 'bye', 'logoff', etc. not allowed
raise ValueError(
'Bye user {0!r} used by rlogin'.format(username))
if check_anonymous_user(username):
# anonymous@ login may be allowed
matrix_kwargs['anonymous'] = True
if self.client.is_active():
return spawn_client_session(client=self.client,
matrix_kwargs=matrix_kwargs)
except socket.error as err:
self.log.debug(
'{client.addrport}: connection closed: {err}'.format(
client=self.client, err=err))
except EOFError:
self.log.debug('{client.addrport}: EOF from client'.format(
client=self.client))
except Exception as err:
self.log.debug(
'{client.addrport}: connection closed: {err}'.format(
client=self.client, err=err))
finally:
self.stopped = True
self.client.deactivate()
def run(self):
""" Accept new Ssh connect in thread. """
try:
self.client.transport = paramiko.Transport(self.client.sock)
self.client.transport.load_server_moduli()
self.client.transport.add_server_key(self.server_host_key)
ssh_session = SshSessionServer(client=self.client)
from x84.bbs import get_ini
if get_ini(section='sftp', key='enabled', getter='getboolean'):
self.client.transport.set_subsystem_handler(
'sftp', paramiko.SFTPServer, X84SFTPServer,
ssh_session=ssh_session)
def detected():
""" Whether shell or SFTP session has been detected. """
return (ssh_session.shell_requested.isSet() or
ssh_session.sftp_requested.isSet())
self.client.transport.start_server(server=ssh_session)
st_time = time.time()
while self._timeleft(st_time):
self.client.channel = self.client.transport.accept(1)
if self.client.channel is not None:
break
if not self.client.transport.is_active():
self.log.debug('{client.addrport}: transport closed.'
.format(client=self.client))
self.client.deactivate()
return
else:
self.log.debug('{client.addrport}: no channel requested'
.format(client=self.client))
self.client.deactivate()
return
first_log = False
while not detected() and self._timeleft(st_time):
if not first_log:
self.log.debug('{client.addrport}: waiting for '
'shell or subsystem request.'
.format(client=self.client))
first_log = True
if not self.client.is_active():
self.log.debug('{client.addrport}: transport closed '
'while waiting for shell or subsystem '
'request.'
.format(client=self.client))
self.client.deactivate()
return
time.sleep(self.TIME_POLL)
if detected():
matrix_kwargs = {attr: getattr(ssh_session, attr)
for attr in ('anonymous', 'new', 'username',)}
return spawn_client_session(client=self.client,
matrix_kwargs=matrix_kwargs)
except (paramiko.SSHException, socket.error) as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
except EOFError:
self.log.debug('{client.addrport}: EOF from client'
.format(client=self.client))
except Exception as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
else:
self.log.debug('{client.addrport}: shell not requested'
.format(client=self.client))
finally:
self.stopped = True
self.client.deactivate()
def run(self):
"""
Accept new Ssh connect in thread.
"""
try:
self.client.transport = paramiko.Transport(self.client.sock)
self.client.transport.load_server_moduli()
self.client.transport.add_server_key(self.server_host_key)
ssh_session = SshSessionServer(client=self.client)
def detected():
return ssh_session.shell_requested.isSet()
self.client.transport.start_server(server=ssh_session)
st_time = time.time()
while self._timeleft(st_time):
self.client.channel = self.client.transport.accept(1)
if self.client.channel is not None:
break
if not self.client.transport.is_active():
self.log.debug('{client.addrport}: transport closed.'
.format(client=self.client))
self.client.deactivate()
return
else:
self.log.debug('{client.addrport}: no channel requested'
.format(client=self.client))
self.client.deactivate()
return
self.log.debug('{client.addrport}: waiting for shell request'
.format(client=self.client))
while not detected() and self._timeleft(st_time):
if not self.client.is_active():
self.client.deactivate()
return
time.sleep(self.TIME_POLL)
if detected():
matrix_kwargs = {attr: getattr(ssh_session, attr)
for attr in ('anonymous', 'new', 'username')}
return spawn_client_session(client=self.client,
matrix_kwargs=matrix_kwargs)
except (paramiko.SSHException, socket.error) as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
except EOFError:
self.log.debug('{client.addrport}: EOF from client'
.format(client=self.client))
except Exception as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
else:
self.log.debug('{client.addrport}: shell not requested'
.format(client=self.client))
finally:
self.stopped = True
self.client.deactivate()
def run(self):
"""
Accept new Ssh connect in thread.
"""
try:
self.client.transport = paramiko.Transport(self.client.sock)
self.client.transport.load_server_moduli()
self.client.transport.add_server_key(self.server_host_key)
ssh_session = SshSessionServer(client=self.client)
def detected():
return ssh_session.shell_requested.isSet()
self.client.transport.start_server(server=ssh_session)
st_time = time.time()
while self._timeleft(st_time):
self.client.channel = self.client.transport.accept(1)
if self.client.channel is not None:
break
if not self.client.transport.is_active():
self.log.debug('{client.addrport}: transport closed.'
.format(client=self.client))
self.client.deactivate()
return
else:
self.log.debug('{client.addrport}: no channel requested'
.format(client=self.client))
self.client.deactivate()
return
self.log.debug('{client.addrport}: waiting for shell request'
.format(client=self.client))
while not detected() and self._timeleft(st_time):
if not self.client.is_active():
self.client.deactivate()
return
time.sleep(self.TIME_POLL)
if detected():
matrix_kwargs = {attr: getattr(ssh_session, attr)
for attr in ('anonymous', 'new', 'username')}
return spawn_client_session(client=self.client,
matrix_kwargs=matrix_kwargs)
except (paramiko.SSHException, socket.error) as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
except EOFError:
self.log.debug('{client.addrport}: EOF from client'
.format(client=self.client))
except Exception as err:
self.log.debug('{client.addrport}: connection closed: {err}'
.format(client=self.client, err=err))
else:
self.log.debug('{client.addrport}: shell not requested'
.format(client=self.client))
finally:
self.stopped = True
self.client.deactivate()
