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