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