def onInactivityTimeout(self):
"""
"""
tpl = TestTemplatesLib.TemplateMessage()
tpl.addLayer(layer=AdapterIP.ip(more=AdapterIP.received()))
tpl.addLayer(layer=templates.udp(more=templates.received()))
self.onInactivity(lower=tpl)
def sendData(self, tpl=None, dataRaw=None):
"""
Send ssh data
@param tpl: ssh template data (default=None)
@type tpl: templatelayer/none
@param dataRaw: ssh data (default=None)
@type dataRaw: string/none
@return: an event matching with the template or None otherwise
@rtype: templatemessage
"""
if self.sshTranport is None:
return
if not self.sshTranport.is_authenticated():
self.debug( 'not authenticated' )
return
if not self.connected:
self.debug( "not connected" )
return
# log event
if self.logEventSent:
if dataRaw is not None:
ssh_tpl = templates.data_sent(data=dataRaw)
else:
ssh_tpl = tpl
tpl_final = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=ssh_tpl )
else:
tpl_final = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.data_sent() )
data = dataRaw
if dataRaw is None:
data = tpl.get('data')
self.debug( data )
if data is None:
return
if self.logEventSent:
tpl_final.addRaw(raw=data)
self.logSentEvent( shortEvt = "data", tplEvt = tpl_final )
if self.cfg['agent-support']:
remote_cfg = { 'cmd': 'send-data', 'data': data }
self.sendNotifyToAgent(data=remote_cfg)
else:
try:
self.sshChannel.send(data)
except Exception as e:
self.error("unable to send data through ssh: %s" % str(e) )
return tpl_final
def sendData(self, data, to=None):
"""
Send data over the udp protocol
@param data: data to send over udp
@type data: string
@param to: address of destination (ip,port)
@type to: tuple/none
@return: udp layer encapsulate in ip, return False on error
@rtype: templatemessage
"""
try:
#self.debug( "data to sent (bytes %s) to %s" % (len(data), to) )
if not self.islistening:
self.debug( "not listening" )
return False
# prepare destination address
addr = (self.cfg['dst-ip'], self.cfg['dst-port'])
if to is not None:
addr = to
self.cfg['dst-ip'] = addr[0]
self.cfg['dst-port'] = addr[1]
# add the separator to the end of the data, if the feature is enabled
pdu = self.addSeparator( data=data )
# log event
pdu_size = len(pdu)
if self.logEventSent:
tpl = self.encapsule( ip_event=AdapterIP.sent(), udp_event=templates.sent(data=pdu, data_length=str(pdu_size)) )
else:
tpl = self.encapsule( ip_event=AdapterIP.sent(), udp_event=templates.sent( data_length=str(pdu_size) ) )
if self.logEventSent:
tpl.addRaw(raw=pdu)
self.logSentEvent( shortEvt = "data", tplEvt = tpl )
if self.cfg['agent-support']:
data = { 'cmd': 'send-data', 'pdu': pdu, 'addr': addr}
self.sendNotifyToAgent(data=data)
else:
# send the packet
self.socket.sendto(pdu, addr)
self.debug( "data sent (bytes %s)" % len(pdu) )
return tpl
except Exception as e:
self.error('Unable to send data: %s' % str(e))
return False
def encapsule(self, ip_event, udp_event, src_ip=None, src_port=None):
"""
"""
# prepare layers
src = self.sourceIp
srcP = self.sourcePort
dst = ''
dstP = ''
if src_ip is not None:
src = src_ip
dst = self.sourceIp
if src_port is not None:
srcP = src_port
dstP = self.sourcePort
layer_ip = AdapterIP.ip(source=src,
destination=dst,
version=self.cfg['sock-family'],
more=ip_event)
layer_udp = templates.udp(source=srcP, destination=dstP)
layer_udp.addMore(more=udp_event)
# prepare template
tpl = TestTemplatesLib.TemplateMessage()
tpl.addLayer(layer=layer_ip)
tpl.addLayer(layer=layer_udp)
return tpl
def getExpectedTemplate(self,
tpl,
versionIp=None,
sourceIp=None,
destinationIp=None,
sourcePort=None,
destinationPort=None):
"""
Return an expected template with ip and udp layers
"""
# prepare layers
defaultVer = self.cfg['sock-family']
if versionIp is not None:
defaultVer = versionIp
layer_ip = AdapterIP.ip(source=sourceIp,
destination=destinationIp,
version=defaultVer)
layer_udp = templates.udp(source=sourcePort,
destination=destinationPort)
layer_udp.addMore(more=tpl)
# prepare template
tpl = TestTemplatesLib.TemplateMessage()
tpl.addLayer(layer=layer_ip)
tpl.addLayer(layer=layer_udp)
return tpl
def handleIncomingData(self, data, lower=None):
"""
Called on incoming data
@param data: tcp data received
@type data: string
@param lower: template tcp data received
@type lower: templatemessage
"""
if lower is not None:
layer_app = lower.get('SSH')
app_data = layer_app.get('data')
self.buf += app_data
try:
self.privateAppendFile(destname="ssh_dump", data=data)
decoded_msgs, left = self.codec.decode(data=self.buf, delimiter = self.delimiter)
self.buf = left
for d in decoded_msgs:
summary = d.replace("\r","")
new_tpl = self.encapsule(ip_event=AdapterIP.received(), ssh_event=templates.data_received(data=summary))
new_tpl.addRaw(summary)
self.logRecvEvent( shortEvt = "ssh", tplEvt = new_tpl )
except Exception as e:
self.error('Error while waiting on incoming data: %s' % str(e))
self.info("buffer = " + self.buf)
def encapsule(self, ip_event, udp_event, src_ip=None, src_port=None):
"""
"""
# prepare layers
src = self.sourceIp
dst = self.cfg['dst-ip']
srcP = self.sourcePort
dstP = self.cfg['dst-port']
if src_ip is not None:
src = src_ip
dst = self.sourceIp
if src_port is not None:
srcP = src_port
dstP = self.sourcePort
layer_ip = AdapterIP.ip( source=src, destination=dst, version= "%s" % self.cfg['sock-family'], more=ip_event )
layer_udp = templates.udp(source=srcP, destination=dstP)
layer_udp.addMore(more=udp_event)
# prepare template
if self.cfg['agent-support']:
layer_agent= TestTemplatesLib.TemplateLayer('AGENT')
layer_agent.addKey(name='name', data=self.cfg['agent']['name'] )
layer_agent.addKey(name='type', data=self.cfg['agent']['type'] )
tpl = TestTemplatesLib.TemplateMessage()
if self.cfg['agent-support']:
tpl.addLayer(layer=layer_agent)
tpl.addLayer(layer=layer_ip)
tpl.addLayer(layer=layer_udp)
return tpl
def stopListening(self):
"""
Stop listening
"""
self.__mutex__.acquire()
if self.islistening:
self.debug( 'stopping to listen' )
# log event
self.islistening = False
tpl = self.encapsule( ip_event=AdapterIP.sent(), udp_event=templates.stopping() )
self.logSentEvent( shortEvt = "stopping", tplEvt = tpl )
if self.cfg['agent-support']:
self.cleanSocket()
# cleanup remote agent
#self.resetAgent()
remote_cfg = {'cmd': 'disconnect'}
self.sendNotifyToAgent(data=remote_cfg)
else:
# clean socket
self.cleanSocket()
# dispatch
self.onStopListening()
self.__mutex__.release()
def onStartListeningFailed(self, e): """ """ self.debug( e ) # log event tpl = self.encapsule( ip_event=AdapterIP.received(), udp_event=templates.listening_failed() ) self.logRecvEvent( shortEvt = "listening failed", tplEvt = tpl )
def getExpectedTemplate(self, tpl, versionIp=None, sourceIp=None, destinationIp=None,
sourcePort=None, destinationPort=None):
"""
Return an expected template with ip and udp layers
"""
# prepare layers
defaultVer = "%s" % self.cfg['sock-family']
if versionIp is not None:
defaultVer = versionIp
layer_ip = AdapterIP.ip( source=sourceIp, destination=destinationIp, version=defaultVer )
layer_udp = templates.udp(source=sourcePort, destination=destinationPort)
layer_udp.addMore(more=tpl)
# prepare template
if self.cfg['agent-support']:
layer_agent= TestTemplatesLib.TemplateLayer('AGENT')
layer_agent.addKey(name='name', data=self.cfg['agent']['name'] )
layer_agent.addKey(name='type', data=self.cfg['agent']['type'] )
tpl = TestTemplatesLib.TemplateMessage()
if self.cfg['agent-support']:
tpl.addLayer(layer=layer_agent)
tpl.addLayer(layer=layer_ip)
tpl.addLayer(layer=layer_udp)
return tpl
def openSession(self):
"""
Open a ssh session
"""
if self.sshTranport is None:
return
if not self.sshTranport.is_authenticated():
self.debug( 'not authenticated' )
return
# log event
if self.sftpSupport:
tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.open_channel() )
self.logSentEvent( shortEvt = "open sftp channel", tplEvt = tpl )
else:
if self.logEventSent:
tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.open_channel() )
self.logSentEvent( shortEvt = "open channel", tplEvt = tpl )
if self.cfg['agent-support']:
remote_cfg = { 'cmd': 'open-session', 'sftp-support': self.sftpSupport, 'terminal-type': self.cfg['terminal-type'],
'terminal-width': self.cfg['terminal-width'] , 'terminal-height': self.cfg['terminal-height']}
self.sendNotifyToAgent(data=remote_cfg)
else:
try:
if self.sftpSupport:
self.sshChannel = self.sshTranport.open_sftp_client()
else:
self.sshChannel = self.sshTranport.open_session()
self.sshChannel.get_pty(term=self.cfg['terminal-type'],
width=self.cfg['terminal-width'] , height =self.cfg['terminal-height'] )
self.sshChannel.invoke_shell()
self.sshChannel.settimeout(0.0)
except Exception as e:
#self.debug( e )
if self.sftpSupport:
self.__onSftpFailed(err="%s" % e )
else:
self.onChannelOpeningFailed(err="%s" % e)
# channel opened
else:
if self.sftpSupport:
self.__onSftpOpened()
else:
self.onChannelOpened()
def onStopListening(self): """ """ self.debug( 'on stop listening called' ) # log event tpl = self.encapsule( ip_event=AdapterIP.received(), udp_event=templates.stopped() ) self.logRecvEvent( shortEvt = "stopped", tplEvt = tpl )
def __init__(self,
parent,
debug=False,
lowerIpVersion=AdapterIP.IPv4,
version=ICMPv4,
errorsOnly=False,
logEventSent=True,
logEventReceived=True,
agentSupport=False,
agent=None,
shared=False,
name=None):
"""
"""
# init adapter
if version == ICMPv4:
__NAME__ = __NAMEV4__
if version == ICMPv6:
__NAME__ = __NAMEV6__
TestAdapterLib.Adapter.__init__(self,
name=__NAME__,
parent=parent,
realname=name,
debug=debug,
shared=shared,
agentSupport=agentSupport,
agent=agent,
caller=TestAdapterLib.caller(),
agentType=AGENT_TYPE_EXPECTED)
self.logEventSent = logEventSent
self.logEventReceived = logEventReceived
# init icmp
self.icmpCodec = codec4.Codec(parent=self,
testcase=parent,
debug=debug)
# init ip layer
self.ip = AdapterIP.SnifferV4(parent=parent,
debug=debug,
protocol2sniff=AdapterIP.ICMP,
logEventSent=False,
logEventReceived=False,
disableArp=errorsOnly,
parentName=__NAME__,
agentSupport=agentSupport,
agent=agent,
shared=shared)
self.ip.onReceiving = self.onDecodeData
self.cfg = {}
self.cfg['listen-errors-only'] = errorsOnly
self.cfg['agent-support'] = agentSupport
if agentSupport:
self.cfg['agent'] = agent
self.cfg['agent-name'] = agent['name']
self.__checkConfig()
def onNegotiationOk(self): """ On negotiation ok """ # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.negotiation_ok() ) self.logRecvEvent( shortEvt = "negotiated", tplEvt = tpl ) # auth with password self.authentication()
def onSocketError(self, e): """ """ self.error( "generic error: %s" % str(e) ) # log event tpl = self.encapsule( ip_event=AdapterIP.received(), udp_event=templates.generic_error() ) self.logRecvEvent( shortEvt = "error", tplEvt = tpl ) # clean the socket self.cleanSocket()
def __onSftpOpened(self): """ to reimplement """ self.sftpOpened = True # log event tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.open_channel_ok() ) self.logRecvEvent( shortEvt = "sftp channel opened", tplEvt = tpl ) self.onSftpOpened()
def authentication(self):
"""
authentication ssh with login and password
"""
if self.sshTranport is None:
self.debug( 'negotiation todo before' )
return
# log event
if self.logEventSent:
tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.authentication() )
self.logSentEvent( shortEvt = "authentication", tplEvt = tpl )
if self.cfg['agent-support']:
remote_cfg = { 'cmd': 'authentication', 'login': self.cfg['login'], 'password': self.cfg['password'] }
if self.cfg['private-key'] is not None:
remote_cfg['private-key'] = self.cfg['private-key']
else:
remote_cfg['private-key'] = ''
self.sendNotifyToAgent(data=remote_cfg)
else:
try:
if self.cfg['private-key'] is not None or self.cfg['private-key-path'] is not None :
key = self.sshTranport.get_remote_server_key()
if self.cfg['private-key-path'] is not None:
f = open(self.cfg['private-key-path'], 'r')
self.cfg['private-key'] = f.read()
f.close()
# read first line of the private key to detect the type
key_head=self.cfg['private-key'].splitlines()[0]
if 'DSA' in key_head:
keytype=paramiko.DSSKey
elif 'RSA' in key_head:
keytype=paramiko.RSAKey
else:
raise Exception("Invalid key type: %s" % key_head)
# construct the key
keyfile = io.StringIO( unicode(self.cfg['private-key']) )
pkey=keytype.from_private_key(keyfile)
# try to make the authen
self.sshTranport.auth_publickey(self.cfg['login'], pkey)
else:
self.sshTranport.auth_password(self.cfg['login'], self.cfg['password'])
except Exception as e:
#self.debug( e )
self.onAuthenticationFailed(err="%s" % e )
# authen ok
else:
self.onAuthenticationOk()
def hasReceivedPacket(self,
timeout=1.0,
dstIp=None,
srcIp=None,
srcPort=None,
dstPort=None,
data=None,
controlBits=None):
"""
Waits to receive "data" event until the end of the timeout
@param timeout: time max to wait to receive event in second (default=1s)
@type timeout: float
@param dstIp: destination ip
@type dstIp: none/string/operators
@param srcIp: source ip
@type srcIp: none/string/operators
@param srcPort: source port
@type srcPort: none/integer/operators
@param dstPort: destination port
@type dstPort: none/integer/operators
@param data: upper data
@type data: none/string/operators
@param controlBits: control bits
@type controlBits: none/string/operators
@return: an event matching with the template or None otherwise
@rtype: templatemessage
"""
TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(),
timeout=timeout)
# prepare the expected template
ether_tpl = AdapterEthernet.ethernet()
expected = self.encapsule(layer=ether_tpl)
ip_tpl = AdapterIP.ip(source=srcIp, destination=dstIp)
expected.addLayer(ip_tpl)
tcp_tpl = templates.tcp(source=srcPort,
destination=dstPort,
control_bits=controlBits)
expected.addLayer(tcp_tpl)
# wait
evt = self.received(expected=expected, timeout=timeout)
if evt is None:
return None
return evt
def onIncomingData(self, data=None, noMoreData=False): """ On incoming data """ try: if noMoreData: lower = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.data_received() ) self.handleNoMoreData(lower=lower) else: lower = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.data_received(data=data) ) # log event if self.logEventReceived: lower.addRaw(raw=data) self.logRecvEvent( shortEvt = 'data', tplEvt = lower ) # handle data self.handleIncomingData( data, lower=lower ) except Exception as e: self.error( "on incoming ssh data: %s" % e )
def onStartListening(self): """ """ self.debug( 'on start listening called' ) if self.cfg['agent-support']: self.islistening = True # log event tpl = self.encapsule( ip_event=AdapterIP.received(), udp_event=templates.listening() ) self.logRecvEvent( shortEvt = "listening", tplEvt = tpl )
def onAuthenticationOk(self): """ On authentication ok """ # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.authentication_ok() ) self.logRecvEvent( shortEvt = "authenticated", tplEvt = tpl ) # open session self.openSession()
def encapsule(self, ip_event, ssh_event):
"""
encapsule template
"""
# prepare layers
# ip
src = self.sourceIp
dst = self.cfg['dst-ip']
srcP = self.sourcePort
dstP = self.cfg['dst-port']
if ip_event == AdapterIP.received():
src = self.cfg['dst-ip']
dst = self.sourceIp
srcP = self.cfg['dst-port']
dstP = self.sourcePort
layer_ip = AdapterIP.ip( source=src, destination=dst, version=self.cfg['sock-family'], more=ip_event )
# tcp
if ip_event == AdapterIP.received():
moreTcp = AdapterTCP.received()
else:
moreTcp = AdapterTCP.sent()
layer_tcp = AdapterTCP.tcp(source=srcP, destination=dstP, more=moreTcp)
# ssh
layer_ssh = templates.ssh()
layer_ssh.addMore(more=ssh_event)
# prepare template
if self.cfg['agent-support']:
layer_agent= TestTemplatesLib.TemplateLayer('AGENT')
layer_agent.addKey(name='name', data=self.cfg['agent']['name'] )
layer_agent.addKey(name='type', data=self.cfg['agent']['type'] )
tpl = TestTemplatesLib.TemplateMessage()
if self.cfg['agent-support']:
tpl.addLayer(layer=layer_agent)
tpl.addLayer(layer=layer_ip)
tpl.addLayer(layer=layer_tcp)
tpl.addLayer(layer=layer_ssh)
return tpl
def onDisconnectionByPeer(self, e):
"""
On disconnection by peer
"""
self.debug("disconnected by the server: %s" % str(e) )
# log event
if self.logEventReceived:
tpl = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.disconnected_by_server() )
self.logRecvEvent( shortEvt = "disconnected by peer", tplEvt = tpl )
self.cleanSocket()
def onSocketError(self, e): """ On socket error """ self.error( "socket error: %s" % str(e) ) # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.generic_error() ) self.logRecvEvent( shortEvt = "error", tplEvt = tpl ) self.cleanSocket()
def stopSending(self):
"""
Stop sending rtp.
"""
self.debug('stop sending rtp')
if self.sendingThread:
if self.sendingThread.isSending():
self.sendingThread.unsetSending()
self.sendingThread.stop()
lower = self.udp.encapsule(ip_event=AdapterIP.sent(),
udp_event=AdapterUDP.sent())
self.onStopSending(lower=lower)
def onConnectionFailed(self, errno, errstr): """ On connection failed """ self.debug( "connection failed" ) # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.connection_failed(errno=str(errno), errstr=errstr) ) self.logRecvEvent( shortEvt = "connection failed", tplEvt = tpl ) self.cleanSocket()
def onChannelOpened(self): """ On channel opened """ self.channelOpened = True # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.sent(), ssh_event=templates.open_channel_ok() ) self.logRecvEvent( shortEvt = "channel opened", tplEvt = tpl ) # begin to run self.setRunning()
def onConnectionRefused(self): """ On connection refused """ self.__setSource() self.debug( "connection refused" ) # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.connection_refused() ) self.logRecvEvent( shortEvt = "connection refused", tplEvt = tpl ) self.cleanSocket()
def onConnectionTimeout(self, e): """ On connection timeout """ self.__setSource() self.debug( "connection timeout: %s" % str(e) ) # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.connection_timeout() ) self.logRecvEvent( shortEvt = "connection timeout", tplEvt = tpl ) self.cleanSocket()
def onConnection(self): """ On connection """ self.debug( "connected" ) # log event if self.logEventReceived: tpl = self.encapsule( ip_event=AdapterIP.received(), ssh_event=templates.connected() ) self.logRecvEvent( shortEvt = "connected", tplEvt = tpl ) # start ssh negotation self.negotiation()
