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 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 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 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 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 hasReceivedIcmpError(self, timeout=1.0): """ Waits to receive "icmp error" event until the end of the timeout @param timeout: time max to wait to receive event in second (default=1s) @type timeout: float @return: an event matching with the template or None otherwise @rtype: templatemessage """ TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout) # prepare the expected template expected = TestTemplatesLib.TemplateMessage() 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']) expected.addLayer(layer_agent) expected.addLayer(layer=templates.udp(more=templates.icmp_error())) # wait evt = self.received(expected=expected, timeout=timeout) if evt is None: return None return evt
def onIcmpError(self, error): """ """ ## TODO: version IP icmp = error.get('ICMP4') icmp_type = icmp.get('type') icmp_type_str = icmp_type.get('string') if icmp_type_str is None: icmp_type_str = 'Unknown' icmp_code = icmp.get('code') icmp_code_str = icmp_code.get('string') if icmp_code_str is None: icmp_code_str = 'Unknown' icmp_data = icmp.get('data') if isinstance(icmp_data, TestTemplatesLib.TemplateLayer): icmp_data = icmp_data.getName() # check if the response is for me ? if icmp_data[:64] == self.ip.getLast64bSent(): tpl = TestTemplatesLib.TemplateMessage() tpl.addLayer(layer=templates.udp(more=templates.icmp_error( error=icmp_type_str, details=icmp_code_str))) if self.logEventReceived: self.logRecvEvent(shortEvt='icmp error', tplEvt=tpl)
def hasReceivedIcmpError(self, timeout=1.0): """ Waits to receive "icmp error" event until the end of the timeout @param timeout: time max to wait to receive event in second (default=1s) @type timeout: float @return: an event matching with the template or None otherwise @rtype: templatemessage """ if not (isinstance(timeout, int) or isinstance(timeout, float)) or isinstance(timeout, bool): raise TestAdapterLib.ValueException( TestAdapterLib.caller(), "timeout argument is not a float or integer (%s)" % type(timeout)) # prepare the expected template expected = TestTemplatesLib.TemplateMessage() 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']) expected.addLayer(layer_agent) expected.addLayer(layer=templates.udp(more=templates.icmp_error())) # wait evt = self.received(expected=expected, timeout=timeout) if evt is None: return None return evt
def decode(self, udp, ipSrc, ipDst): """ """ udp_hdr = struct.unpack('!4H', udp[:UDP_LEN]) ## source: 2 bytes src_port = udp_hdr[0] ## destination: 2 bytes dst_port = udp_hdr[1] ## length: 2 bytes lgth = udp_hdr[2] ## checksum: 2 bytes udp_sum = udp_hdr[3] udp_sum_hex = "0x%0.4X" % udp_sum ## extract data data_upper = udp[UDP_LEN:] # checksum is correct ? optional for udp # An all zero transmitted checksum value means that the transmitter generated no checksum (for # debugging or for higher level protocols that don't care). if udp_sum != 0: speudo_hdr = self.speudoHeader(ipSrc=ipSrc, ipDst=ipDst, udpLength=lgth) sum_computed = self.checksum.compute( data=''.join([speudo_hdr, udp]), checksum_offset=OFFSET_CHECKSUM_WITH_SPEUDO_HDR) sum_status = 'incorrect, should be 0x%0.4X' % sum_computed if udp_sum == sum_computed: sum_status = 'correct' self.debug('udp checksum computed') else: sum_status = "don't care" # Decode OK, create template udp_tpl = templates.udp(source=str(src_port), destination=str(dst_port), length=str(lgth), sum=udp_sum_hex, sum_status=sum_status, sum_int=str(udp_sum), data=data_upper, data_size=len(data_upper)) # add the raw data to the layer udp_tpl.addRaw(udp[:UDP_LEN]) # set summary summary = 'Port=%s>%s, Len=%s' % (src_port, dst_port, len(data_upper)) # if dst_port == self.srcPort: # summary = 'Port=%s<%s, Len=%s' % (dst_port, src_port, len(data_upper)) return udp_tpl, summary, data_upper
def hasReceivedData(self, timeout=1.0, dstIp=None, srcIp=None, srcPort=None, dstPort=None, data=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 @return: an event matching with the template or None otherwise @rtype: templatemessage """ if not (isinstance(timeout, int) or isinstance(timeout, float)) or isinstance(timeout, bool): raise TestAdapterLib.ValueException( TestAdapterLib.caller(), "timeout argument is not a float or integer (%s)" % type(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) udp_tpl = templates.udp(source=srcPort, destination=dstPort, data=None) expected.addLayer(udp_tpl) # wait evt = self.received(expected=expected, timeout=timeout) if evt is None: return None return evt
def sendData(self, data, destIp=None, destPort=0, srcPort=0, totalLength=None, checksum=None, destMac=None): """ Send data to the ip/port passed as argument @param data: data to send over udp @type data: string @param destIp: destination ip address @type destIp: none/integer @param destMac: destination mac address @type destMac: none/integer @param destPort: destination port @type destPort: integer @param srcPort: source port @type srcPort: integer @param totalLength: total length, auto computed if not provided @type totalLength: none/integer @param checksum: checksum, auto computed if not provided @type checksum: integer """ try: if self.port2sniff == codec.ALL: src_port = int(srcPort) else: src_port = int(self.port2sniff) # add the separator data = self.addSeparator(data=data) layer_udp = templates.udp(source=src_port, destination=int(destPort), length=totalLength, sum=checksum, data=data) except Exception as e: raise TestAdapterLib.AdapterException( TestAdapterLib.caller(), 'Cannot prepare udp template: %s' % str(e)) else: # encode the template udp try: udp_pkt, summary = self.udpCodec.encode( udp_tpl=layer_udp, ipSrc=self.ip.getSourceIP(), ipDst=destIp) except Exception as e: raise TestAdapterLib.AdapterException( TestAdapterLib.caller(), "Cannot encode udp data: %s" % str(e)) else: # Send packet try: lower = self.ip.sendDatagram(dstMac=destMac, dstIp=destIp, data=udp_pkt, protocol=AdapterIP.UDP) except Exception as e: raise TestAdapterLib.AdapterException( TestAdapterLib.caller(), "Unable to send udp data: %s" % str(e)) else: lower.addLayer(layer_udp) if self.logEventSent: layer_udp.addRaw(raw=udp_pkt) else: layer_udp.addRaw(raw=udp_pkt[:codec.UDP_LEN]) if self.logEventSent: self.logSentEvent(shortEvt=summary, tplEvt=lower) return lower
def onReceiving(self, data, fromAddr, toAddr, lower): """ Function to overwrite Called on incoming data @param data: data received @type data: string @param lower: template data received @type lower: templatemessage """ # extract transport info self.lastActivity = time.time() srcIp, srcPort = fromAddr dstIp, dstPort = toAddr # the separator feature is disabled, to nothing if self.cfg['sep-disabled']: try: self.handleIncomingData(data=data, lower=lower) except Exception as e: self.error( "on handle incoming udp data, upper layer problem: %s" % str(e)) else: # bufferize data if self.buf.has_key(fromAddr): self.buf[fromAddr] = ''.join([self.buf[fromAddr], data]) else: self.buf[fromAddr] = data # split data with the separator datas = self.buf[fromAddr].split(self.cfg['sep-in']) for d in datas[:-1]: udp_data = d + self.cfg['sep-in'] udp_data_size = len(udp_data) # construct high template and log it tpl = TestTemplatesLib.TemplateMessage() tpl.addLayer( layer=AdapterIP.ip(source=srcIp, destination=dstIp, more=AdapterIP.received(), version=self.cfg['ip-version'])) if self.logEventReceived: udp_layer = templates.udp( source=srcPort, destination=dstPort, more=templates.received( data=udp_data, data_length=str(udp_data_size))) else: udp_layer = templates.udp( source=srcPort, destination=dstPort, more=templates.received( data_length=str(udp_data_size))) tpl.addLayer(layer=udp_layer) if self.logEventReceived: tpl.addRaw(raw=udp_data) self.logRecvEvent(shortEvt='data reassembled', tplEvt=tpl) # handle data self.handleIncomingData(udp_data, lower=tpl) self.buf[fromAddr] = datas[-1]