def yield_test_case(self, count, constraints=None): """ Is a Python generator which yields potential test cases to use. :param constraints: Dictionary of constraints to apply. Optionally takes an entry "check_valid"=False to disable checking to see if the produced frame makes sense to Scapy. :yield: A byte array generated as a possible test case. """ check_valid = constraints.get( 'check_valid', True) if constraints is not None else True #print("*** Validity check status {}".format(check_valid)) for i in range(count): pkt = Dot15d4FCS(seqnum=self.__start_seqnum, fcf_srcaddrmode=2, fcf_ackreq=True, fcf_destaddrmode=2, fcf_panidcompress=True) / \ Dot15d4Data(dest_panid=self.__target_pan_id, dest_addr=self.__target_short_addr, src_addr=self.__src_short_addr) base_pkt_length = len(pkt) pkt = pkt / fuzz( LengthRaw(max_length=MAX_DOT15D4_LENGTH - base_pkt_length)) self.__start_seqnum = (self.__start_seqnum + 1) % (0xFF + 1) #pkt.show2() if not check_valid: yield str(pkt) else: # Due to use of fuzz(), each call to str(pkt) produces different values, and some of these aren't # seen as valid by Scapy. Thus we optionally retry till we get a "good" one. pb = str(pkt) is_valid = Dot15d4FCS(pb).haslayer(Dot15d4Data) while not is_valid: print( "Trying again as initial packet didn't pass validity check." ) #print("Initial pkt that failed - formed:", pkt.summary()) #print("Initial pkt that failed - parsed:", Dot15d4FCS(pb).summary()) pb = str(pkt) is_valid = Dot15d4FCS(pb).haslayer(Dot15d4Data) #print("New pkt - parsed:", Dot15d4FCS(pb).summary()) yield pb
def yield_control_case(self, count=1): pkt = Dot15d4FCS(fcf_srcaddrmode=2, fcf_ackreq=True, fcf_destaddrmode=2, fcf_panidcompress=True) / \ Dot15d4Data(dest_panid=self.__target_pan_id, dest_addr=self.__target_short_addr, src_addr=self.__src_short_addr) for i in range(count): pkt.seqnum = self.__start_seqnum result = str(pkt) self.__start_seqnum = (self.__start_seqnum + 1) % (0xFF + 1) yield result
def yield_test_case(self, count, constraints=None): """ Is a Python generator which yields potential test cases to use. :param constraints: Dictionary of constraints to apply, which: Optionally have the key 'max_fill' set to an integer, indicating the maximum number of nibbles to turn to fill. Deafult=8. Optionally the key 'min_fill' to fix a minimum number of nibbles to turn to fill. Default=0. Optionally have the key 'fill_byte' to specify a byte (as a string) to fill with. Default="\xff" :yield: A byte array generated as a possible test case. """ if constraints is None: max_fill = 8 min_fill = 0 fill_byte = "\xff" else: max_fill = constraints.get('max_fill', 8) if type(max_fill) is not int or max_fill > 8: raise ValueError( "If provide a constraint with key 'preamb_len' set to an integer < 8." ) min_fill = constraints.get('min_fill', 0) if type(min_fill) is not int: raise ValueError( "If provide a constraint with key 'min_fill', it must be an integer." ) fill_byte = constraints.get('fill_byte', "\xff") if type(fill_byte) is not str or len(fill_byte) != 1: raise ValueError( "If provide a constraint with key 'fill_byte', it must be an single-byte string." ) for i in range(count): for f_len in range(min_fill, max_fill + 1): # Create a beacon request frame: pkt = Dot15d4FCS(seqnum=self.__start_seqnum, fcf_ackreq=True) / \ Dot15d4Cmd(dest_panid=self.__target_pan_id, dest_addr=self.__target_short_addr, cmd_id=7) self.__start_seqnum = (self.__start_seqnum + 1) % (0xFF + 1) # This will contain the FCS due to Dot15d4FCS: syncpkt = str(pkt) # As we are providing the PHY items, we add the SFD and length of the packet to the front: syncpkt = SFD + struct.pack('b', len(syncpkt)) + syncpkt #print("Beacon Request Formed: {}".format(syncpkt.encode('hex'))) #Dot15d4FCS(syncpkt).show() if (f_len % 2) != 0: fb = ord(fill_byte) fb = ( ((fb >> 4)) << 4 ) # move symbol to high nibble so sent last, clear low fb = struct.pack('B', fb) preamble = ("\x00" * ((8 - f_len - 1) / 2)) + fb + (fill_byte * (f_len / 2)) else: preamble = ("\x00" * ((8 - f_len) / 2)) + (fill_byte * (f_len / 2)) yield preamble + syncpkt
def _process_receive(self): length = self.serial.read() if len(length) > 0: intLength = int.from_bytes(length, "big") if intLength > 127: if intLength == 0xff: next_byte = self.serial.read() if len(next_byte) > 0: next_length = int.from_bytes(next_byte, "big") message = self.serial.read(next_length) print("DEBUG: " + str(message)) elif intLength == 0xf0: rssi = self.serial.read() next_length = self.serial.read() next_length_int = int.from_bytes(next_length, "big") packet = self.serial.read(next_length_int) if next_length_int < 2: return None if STATE_RX_WMETADATA: result = dict() result["rssi"] = rssi result["frame"] = Dot15d4FCS(packet) return result else: return None return None recv_start = time.time() packet = self.serial.read(intLength) recv_end = time.time() self.add_recv_time(recv_end - recv_start) if intLength <= 2: return None if self.state == STATE_RX_WMETADATA: return None return Dot15d4FCS(packet) else: return None
def recv(self): recv_start = time.time() try: raw_packet = self.kb.pnext() self.sniff = True except: return None recv_end = time.time() self.add_recv_time(recv_end - recv_start) if not raw_packet is None: return Dot15d4FCS(raw_packet['bytes'])
def yield_test_case(self, count, constraints=None): """ Is a Python generator which yields potential test cases to use. :param constraints: Dictionary of constraints to apply, which must have the key preamb_len set to an integer. Optionally the key 'min_preamb_len' to fix a minimum length of the preamble. :yield: A byte array generated as a possible test case. """ max_preamb_len = constraints.get('preamb_len') if constraints is not None else None if max_preamb_len is not None and type(max_preamb_len) is not int: raise ValueError("If provide a constraint with key 'preamb_len', it must be an integer.") elif max_preamb_len is None and self.get_default_constraint('preamb_len', int) is not None: max_preamb_len = self.get_default_constraint('preamb_len', int) if max_preamb_len is None: raise ValueError("Must provide constraints with key 'preamb_len' set to an integer.") min_preamb_len = constraints.get('min_preamb_len') if constraints is not None else None if min_preamb_len is not None and type(min_preamb_len) is not int: raise ValueError("If provide a constraint with key 'min_preamb_len', it must be an integer.") elif min_preamb_len is None and self.get_default_constraint('min_preamb_len', int) is not None: min_preamb_len = self.get_default_constraint('min_preamb_len', int) if min_preamb_len is None: min_preamb_len = 0 # default value for i in range(count): for preamb_len in range(min_preamb_len, max_preamb_len): # Create a beacon request frame: pkt = Dot15d4FCS(seqnum=self.__start_seqnum, fcf_ackreq=True) / \ Dot15d4Cmd(dest_panid=self.__target_pan_id, dest_addr=self.__target_short_addr, cmd_id=7) self.__start_seqnum = (self.__start_seqnum + 1) % (0xFF + 1) # This will contain the FCS due to Dot15d4FCS: syncpkt = str(pkt) # As we are providing the PHY items, we add the SFD and length of the packet to the front: syncpkt = SFD + struct.pack('b', len(syncpkt)) + syncpkt #print("Beacon Request Formed: {}".format(syncpkt.encode('hex'))) #Dot15d4FCS(syncpkt).show() if (preamb_len % 2) != 0: pkt_bytes = ("\x00" * (preamb_len / 2)) + NibbleTools.insert_first_last(syncpkt, "\x0f") else: pkt_bytes = ("\x00" * (preamb_len / 2)) + syncpkt yield pkt_bytes
def test(file, length, gain): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) BEACON = '\x03\x08\xf2\xff\xff\xff\xff\x07\xcd\xe1' sock_address = ('127.0.0.1', 52001) #os.system("rm /tmp/zig.pcap") #os.system("mkfifo /tmp/zig.pcap") #os.system("wireshark -k -i /tmp/zig.pcap") time.sleep(1) for trial in range(RUNS): # cmd_id 4- data 7-beacon request ... # addresses GE-0xed15 Osram-e852 Ikea-0003 Cree-c320 frame = Dot15d4FCS(fcf_ackreq=1, seqnum=gain) / Dot15d4Cmd( src_panid=0xFFFF, src_addr=0xFFFF, dest_addr=0xFFFF, cmd_id=7) #frame = Dot15d4(fcf_frametype=3, seqnum=offset, fcf_ackreq=1)/Dot15d4Beacon(src_addr=0xFFFF, src_panid=0xFFFF) #frame = Dot15d4FCS(fcf_ackreq=1, seqnum=offset) / Dot15d4Beacon(src_panid=0xFFFF, src_addr=0xFFFF) sock.sendto(bytes(frame), sock_address) time.sleep(1) #os.system("pkill -9 wireshark") time.sleep(1) #offset = offset + 1 os.system("mv /tmp/zig.pcap /tmp/zig_len_{}.pcap".format(gain)) subp = Popen([ 'python3', 'exp_post_zig_sense.py', '/tmp/zig_len_{}.pcap'.format(gain), '{}'.format(gain) ], stdout=PIPE, stderr=PIPE) #.format(length)]) stdout_text = subp.stdout.read() stderr_text = subp.stderr.read() file.write(stdout_text.decode('utf-8')) file.write(stderr_text.decode('utf-8')) sock.close()
def test(tb,file,length): sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock_offset = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock_offset.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock_len = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock_len.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) BEACON = '\x03\x08\xf2\xff\xff\xff\xff\x07\xcd\xe1' STEPHELLO = '\x03\x08' # soc = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # soc.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # soc.settimeout(1) # Bind the socket to the port sock_address = ('127.0.0.1', 52001) #server_address = ('127.0.0.1', 52002) sock_offset_addr = ('127.0.0.1', 52003) sock_len_addr = ('127.0.0.1', 52004) #soc.bind(server_address) # for i in range(10): # sock.sendto(bytes(BEACON), ("127.0.0.1", 52001)) # time.sleep(1) STEPS = int(1+abs(int(STOP)-int(START))/int(STEP)) STEPS = [x for x in range(STEPS)] DELAYS = range(min(int(START),int(STOP)),max(int(STOP),int(START))+int(STEP),int(STEP)) print(STEPS) print(DELAYS) # cureently no effect since acess_code_prefixer not implemented... sock_len.sendto(chr(length).encode('utf-8'), sock_len_addr) offset = 0 for step in STEPS: print(offset) print(str(offset).encode('utf-8')) #tb.lock() #tb.wait() #tb.stop() #tb.blocks.Offset.set_offset(DELAYS[step]) #tb.set_mctest(1) #tb.set_offset(DELAYS[step]) #print('Got offset: '+str(tb.get_offset())) # comment out until we fix pad2 implementation - ascii offset sock_offset.sendto(chr(offset+47).encode('utf-8'),sock_offset_addr) #tb.unlock() #tb.start() time.sleep(1) for trial in range(RUNS): # cmd_id 4- data 7-beacon request ... # addresses GE-0xed15 Osram-e852 Ikea-0003 Cree-c320 frame = Dot15d4FCS(fcf_ackreq=1, seqnum=offset) / Dot15d4Cmd(src_panid=0xFFFF, src_addr=0xFFFF, dest_addr=0xFFFF, cmd_id=7) #frame = Dot15d4(fcf_frametype=3, seqnum=offset, fcf_ackreq=1)/Dot15d4Beacon(src_addr=0xFFFF, src_panid=0xFFFF) #frame = Dot15d4FCS(fcf_ackreq=1, seqnum=offset) / Dot15d4Beacon(src_panid=0xFFFF, src_addr=0xFFFF) sock.sendto(bytes(frame), sock_address) # # #while True: # print('\nwaiting to receive message') # try: # data = soc.recv(200) # try to receive 100 bytes # rx_msg = [] # for i in data: # rx_msg.append(ord(i)) # #sys.stdout.write("\\x{:02x}".format(ord(i))) # print('') # #print(rx_msg) # try: # if rx_msg[0] == 0x00 and rx_msg[1] == 0x80: # #print('think i found beacon') # msg_num = msg_num + 1 # else: # pass # except IndexError as e: # pass # except socket.timeout: # fail after 1 second of no activity # print("Didn't receive data! [Timeout]") # finally: # pass time.sleep(0.2) #soc.close() #sock.close() #time.sleep(0.2) #PRR.append(msg_num) #sock.sendto(bytes(STEPHELLO+str(step)), ("127.0.0.1", 52001)) #time.sleep(2) offset = offset + 1 os.system("mv /tmp/zig.pcap /tmp/zig_len_{}.pcap".format(length)) subp = Popen(['python3','post_process_DOS_efr32.py','/tmp/zig_len_{}.pcap'.format(length)], stdout=PIPE, stderr=PIPE)#.format(length)]) stdout_text = subp.stdout.read() stderr_text = subp.stderr.read() print(stdout_text) print(stderr_text) # print(type(file)) # print(dir(file)) file.write(stdout_text.decode('utf-8')) file.write(stderr_text.decode('utf-8')) file.close() os.system("cat {}".format(results_file)) sock.close() sock_offset.close() sock_len.close()
def _process_receive(self): try: length = self.serial.read() #print("Receive Length:", length) if len(length) > 0: # intLength = int.from_bytes(length, "big") #length_bytes = bytes(str(length).encode('utf-8')) if (len(length) == 1): intLength = ord(length) else: intLength = struct.unpack('>i', length)[0] if intLength > 127: if intLength == 0xff: next_byte = self.serial.read() if len(next_byte) > 0: if (len(next_byte) == 1): # next_length = int.from_bytes(next_byte, "big") next_length = ord(next_byte) else: # next_length = int.from_bytes(next_byte, "big") next_length = struct.unpack('>i', next_byte)[0] message = self.serial.read(next_length) print("DEBUG: " + str(message)) elif intLength == 0xf0: rssi = self.serial.read() next_length = self.serial.read() # next_length_int = int.from_bytes(next_length, "big") if (len(next_length) == 1): # next_length = int.from_bytes(next_byte, "big") next_length_int = ord(next_length) else: # next_length = int.from_bytes(next_byte, "big") next_length_int = struct.unpack('>i', next_length)[0] packet = self.serial.read(next_length_int) if next_length_int < 2: return None if STATE_RX_WMETADATA: result = dict() result["rssi"]=rssi result["frame"]=Dot15d4FCS(packet) return result else: return None return None recv_start = time.time() packet = self.serial.read(intLength) recv_end = time.time() self.add_recv_time(recv_end - recv_start) if intLength <= 2: return None if self.state==STATE_RX_WMETADATA: return None return Dot15d4FCS(packet) else: return None except serial.serialutil.SerialException as se: pass