def run(self): self.logger.info("Starting sequence 1") if len(self.output_ports) == 0: self.logger.info("There are no ports in the ICD satisfying the " \ "scripts criteria") return self.sendRSET() for port in self.output_ports: if port.port_characteristic == PORT_SAP: cmd = ESAP(port) setattr(port, "ip_dst", get("TE_IP")) setattr(port, "udp_dst", int(get("TE_UDP"))) else: #cmd = EIPC(port) cmd = ESAP(port) command_size = cmd.command_size message = "Short message" messages = [] messages.append(buildShortMessage(port, message, command_size)) messages.append(buildMessage(port, (int(port.buffer_size)/2) - command_size, message)) messages.append(buildMessage(port, int(port.buffer_size) - command_size, message)) for message in messages: command = cmd.buildCommand(command = 'SEND', message = message) self.send(command, Factory.GET_TX_Port()) if not pollForResponse(("OK", "ERR")): self.logger.info("The ES did not respond to EIPC command")
def start(self): if not os.path.exists(CAPTURES_PARENT_DIRECTORY): self.logger.error("The directory %s does not exist" % \ CAPTURES_PARENT_DIRECTORY) return count = 0 for file in glob.glob(os.path.join(CAPTURES_PARENT_DIRECTORY, "*.cap")): self.logger.info("%s Starting analysis for capture %s %s" % ("=" * 5, file, "=" * 5)) self.reader = PcapReader(file) self.src_ip = get("TE_IP") self.dst_ip = get("TR_IP") global APPLICATION_CODES packets = self.reader.read_all() fragd, defragd, _ = defrag(packets) packets = fragd + defragd for packet in packets: if packet.haslayer(Raw): for code in APPLICATION_CODES: if code in str(packet[Raw]): self.printPacketDetails(packet, code) count += 1 if count == 0: self.logger.warn("There are no capture files in directory : %s" % \ CAPTURES_PARENT_DIRECTORY) else: self.logger.info("Successfully analyzed %d capture%s" % \ (count, "s" if count > 1 else "")) print "Please check the log file %s at %s for the analyzer report" \ % (self.log_filename, LOGGER_PARENT_DIRECTORY)
def filter(port): if str(port.vl_id) == get('TE_TX_VL') and \ port.port_characteristic != PORT_SAMPLING and \ port.network_id != NETWORK_B: port.ip_dst = get('TR_IP') return True return False
def __addEthernetDetails(self): eth = Ether() src_mac_padding = '%04x' % self.__port.vl_id eth.dst = "%s:%s:%s" % (get("MAC_PREFIX_RX"), src_mac_padding[:2], src_mac_padding[2:]) eth.src = get("MAC_PREFIX_TX") + ":20" eth.type = 0x800 self.__packet = eth
def sequence1(self): self.captureForSequence(1) msg_8kb = buildStaticMessage(8192, "Message size = 8192") msg_64kb = buildStaticMessage(64 * 1024, "Message size = 65536") msg = "ping test" msgs = [msg_8kb, msg_64kb, msg] for port in self.icmp_ports: setattr(port, 'ip_src', get("NMF_IP")) self.logger.info("Sending an ICMP from NMF ip : %s" % get("NMF_IP")) for msg in msgs: self.sendICMP(port, msg, False)
def transmit_packets(self, packets, network): for packet in packets: packet = self.__addPadding(packet) if NETWORK_A in network: packet[Ether].src = get("MAC_PREFIX_TX") + ":20" sendp(packet, iface = get("NETWORK_INTERFACE_A"), verbose = False) if NETWORK_B in network: packet[Ether].src = get("MAC_PREFIX_TX") + ":40" sendp(packet, iface = get("NETWORK_INTERFACE_B"), verbose = False) time.sleep( 0.6 )
def sequence5(self): self.captureForSequence(5) self.sendRSET() for port in self.input_ports: if port.port_characteristic != PORT_SAP: continue message = buildShortMessage(port, "PortId = %s" % \ port.RX_AFDX_port_id) setattr(port, "ip_dst", get("TE_IP")) setattr(port, "udp_dst", int(get("TE_UDP"))) esap = ESAP(port) self.send(esap.buildCommand(message = message)) pollForResponse('ESAP')
def sequence3(self): self.captureForSequence(3) msg_small = buildStaticMessage(63, "small message") for port in self.icmp_ports: setattr(port, 'ip_src', get("NMF_IP")) self.logger.info("Sending an ICMP from NMF ip : %s with "\ "small message" % get("NMF_IP")) self.sendICMP(port, msg_small, False) msg_big = buildStaticMessage(65, "big message") for port in self.icmp_ports: setattr(port, 'ip_src', get("NMF_IP")) self.logger.info("Sending an ICMP from NMF ip : %s with "\ "big message" % get("NMF_IP")) self.sendICMP(port, msg_big, False)
def run(self): dummy_port = None if len(self.snmp_ports) == 0: self.logger.error("The ICD has no ports satisfying the sequence" \ " criteria. Hence sending from a dummy SNMP port") dummy_port = (Factory.GET_SNMP_DummyPort(),) self.snmp_ports = dummy_port self.sendRSET() for rxPort in self.snmp_ports: oid_1 = getMIBOID('afdxEquipmentStatus') oids_4kb = getMIBOIDBySize(220) oids_8kb = getMIBOIDBySize(452) self.logger.info("Sending an SNMP get request") self.sendSNMP(rxPort, [oid_1]) self.logger.info("Sending an SNMP get request of " \ "size ~4Ko") self.sendSNMP(rxPort, oids_4kb) self.logger.info("Sending an SNMP get request of " \ "size ~8Ko") self.sendSNMP(rxPort, oids_8kb) if dummy_port: Factory.REM_Port(dummy_port[0]) if get('SNMP_TRAPS_ENABLED').lower() == 'true': self.logger.info("Listening for traps. Duration : 10 seconds") time.sleep(10)
def __init__(self, application): self.application = application self.network = application.network super(Script024, self).__init__("ITR-ES-024") self.snmp_ports = self.getPorts({'port_characteristic' : PORT_SAP, 'udp_dst' : int(get('SNMP_UDP_PORT'))}, ICD_INPUT_VL)
def __addIpDetails(self): port = self.__port ip_layer = IP() ip_layer.src = port.ip_src if hasattr(port, 'ip_src') else \ get("TE_IP") if hasattr(port, 'dest_ip'): port.ip_dst = port.dest_ip elif port.ip_dst in ('', None): port.ip_dst = get("TR_IP") ip_layer.dst = port.ip_dst ip_layer.id = self._sn_handler.nextIpId() ip_layer.ttl = 1 #ip_layer.prot = 0x17 self.__packet = self.__packet/ip_layer
def __init__(self, application): self.application = application self.network = NETWORK_A super(Script017, self).__init__("ITR-ES-017", has_sequences=True) self.icmp_ports = self.getPorts({}, ICD_ICMP) self.snmp_ports = self.getPorts({"udp_dst": int(get("SNMP_UDP_PORT"))}, ICD_INPUT_VL) map(lambda port: setattr(port, "buffer_size", port.rx_vl_buff_size), self.icmp_ports)
def WRITE_ICMP(vlId, message): port = __get_port(vlId, ICD_ICMP) setattr(port, 'payload', message) setattr(port, 'ip_dst', get('TR_IP')) setattr(port, 'vl_id', int(port.rx_vl_id)) setattr(port, 'proto', 'ICMP') __set_port(port, vlId, ICD_ICMP) return port
def __fillRxPorts(self, ports): for port in ports: if port.udp_dst == int(get("TE_UDP")): continue message = "Port Id = %s" % port.RX_AFDX_port_id self.logger.info("Filling the Rx port %s" % port.RX_AFDX_port_id) self.send(message, port)
def __addUDPDetails(self): port = self.__port udp_layer = UDP() udp_layer.sport = port.udp_src if hasattr(port, 'udp_src') else \ int(get("TE_UDP")) udp_layer.dport = port.udp_dst udp_layer.chksum = 0x00 #udp_layer.len = len(port.payload) self.__packet = self.__packet/udp_layer
def __init__(self, application): self.application = application self.network = NETWORK_A super(Script019, self).__init__("ITR-ES-019", has_sequences=True) self.output_ports = self.getPorts({}, ICD_OUTPUT_VL) self.input_ports = self.getPorts({"port_characteristic": PORT_QUEUING}, ICD_INPUT_VL) self.snmp_ports = self.getPorts({"udp_dst": int(get("SNMP_UDP_PORT"))}, ICD_INPUT_VL) self.output_ports = self.remove_common_ports(self.output_ports) self.input_ports = self.remove_common_ports(self.input_ports)
def transmit(self, port, network): self.__port = port self.__createPacket() time.sleep(0.5) # to be removed, only for testing redundancy management network = 'A' for packet in self.__packet: packet = self.__addPadding(packet) if NETWORK_A in network: packet[Ether].src = get("MAC_PREFIX_TX") + ":20" sendp(packet, iface = get("NETWORK_INTERFACE_A"), verbose = False) if NETWORK_B in network: packet[Ether].src = get("MAC_PREFIX_TX") + ":40" sendp(packet, iface = get("NETWORK_INTERFACE_B"), verbose = False)
def __init__(self, application): self.application = application self.network = NETWORK_A super(Script023, self).__init__("ITR-ES-023", has_sequences = True) self.sap_ports = self.getPorts({'port_characteristic' : PORT_SAP, 'udp_dst' : int(get('SNMP_UDP_PORT')), 'network_id' : NETWORK_A}, ICD_INPUT_VL) self.input_ports = self.getPorts({}, ICD_INPUT_VL) self.input_ports = self.remove_common_ports(self.input_ports)
def __init__(self, network): self._integrity_check_result = False self._redundancy_check_result = False self.__network = network self.__hooks = eval(get("HOOKS")) if self.__hooks == None or type(self.__hooks) != dict: self.__hooks = dict() else: for key in self.__hooks.keys(): target = self.__hooks[key] self.__hooks[key] = target
def transmit_low(packet, network): packet = self.__addPadding(packet) packets = [] try: if NETWORK_A in network: packet[Ether].src = get("MAC_PREFIX_TX") + ":20" if send: sendp(packet, iface = get("NETWORK_INTERFACE_A"), verbose = False) else: packets.append(packet) if NETWORK_B in network: packet[Ether].src = get("MAC_PREFIX_TX") + ":40" if send: sendp(packet, iface = get("NETWORK_INTERFACE_B"), verbose = False) else: packets.append(packet) except Exception, ex: general_logger.exception(str(ex))
def run(self): try: filter_text = get("RECEIVER_NETWORK_FILTER_" + self.__network) while True: sniff(iface = self.__iface, prn = self.callback, filter = filter_text, store = 0, timeout = 10) if self.__stop: break except ThreadExit: pass except Exception, ex: print 'Failed', str(ex)
def run(self): try: filter_text = get("RECEIVER_NETWORK_FILTER_" + self.__network) while True: #sniff(iface = self.__iface, prn = self.callback, # filter = filter_text, timeout = 10, # store = 0) if self.__stop: raise ThreadExit() except ThreadExit: general_logger.info("Thread on network " + self.__network + " stopped") except Exception, ex: general_logger.error("Exception occured at receiver for network " +\ self.__network + " : " + str(ex)) general_logger.info("The application will not listen for packets" +\ " coming on network : " + self.__network) traceback.print_exc(file=sys.stdout) general_logger.error("Crash", exc_info = 1)
from com.afdxsuite.application.properties import get from com.afdxsuite.core.network.scapy import load_mib, conf oid_value_mapping = {} load_mib(get("AFDXES_MIB")) for oidname in conf.mib.keys(): val = conf.mib[oidname] val = str(val).replace("enterprises", "1.3.6.1.4.1") oid_value_mapping[val] = 0 print 'Loaded AFDX end system MIB objects' SNMP_IP_MIB_CODE = "afdxProtocolInError" SNMP_FRAG_MIB_CODE = "iPreassemblyInError" SNMP_UDP_MIB_CODE = "afdxUDPCoherencyError"
def GET_SNMP_DummyPort(): dummy_data = "AFDX_INPUT_VL;port1;100;10;;A;BP;35854;VL_TestSCI_NMF_ADIS_SwitchN;A&B;128;8192;Active;yes;65500;26038;SNMP;SAP;SAP;yes;%s;161;8192;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" % (get('TR_IP')) port = ICD_AFDX_INPUT_VL(dummy_data.split(';')) CONFIG_ENTRIES[ICD_INPUT_VL].append(port) return port
from com.afdxsuite.config.parsers.icdparser import parseICD from com.afdxsuite.application.properties import get from com.afdxsuite.logging import afdxLogger from com.afdxsuite.config.parsers import ICD_INPUT_VL afdxLogger.info("Loading the ICD file") parseICD(get("ICD_FILE"))
def __init__(self, network): self.__network = network self.__iface = get("NETWORK_INTERFACE_" + network) self.listeners = Listeners() super(ReceiverThread, self).__init__()
from com.afdxsuite.config.parsers.icdparser import parseICD from com.afdxsuite.application.properties import get from com.afdxsuite.logger import general_logger from com.afdxsuite.config.parsers import ICD_INPUT_VL from com.afdxsuite.core.network.scapy import load_mib from com.afdxsuite.application import PARENT_PATH general_logger.info("Loading the ICD file") parseICD(get("ICD_FILE")) load_mib(PARENT_PATH + "conf/" + get("ES_MIB")) print "loaded mib file", PARENT_PATH + "conf/" + get("ES_MIB")
def __init__(self, application): self.application = application self.network = NETWORK_A super(Script018, self).__init__("ITR-ES-018") self.snmp_ports = self.getPorts({'udp_dst' : int(get("SNMP_UDP_PORT"))}, ICD_INPUT_VL)