Commit 4fa05cc7 by Sebastian Renner

Mergerino

parents 12fe513c 3a376339
......@@ -5,7 +5,6 @@ import sys
import stat
import argparse
import shutil
import random
import subprocess
import shutil
......@@ -15,7 +14,7 @@ def build(algo_dir, template_dir, build_dir):
return None
print("Building in %s" % build_dir)
# copy all the files from the submitted algorithm into the build directory
shutil.copytree(algo_dir, build_dir)
......@@ -68,7 +67,6 @@ def build(algo_dir, template_dir, build_dir):
p.wait()
assert p.returncode == 0
finally:
sys.stdout.flush()
sys.stderr.flush()
......@@ -122,7 +120,8 @@ def main(argv):
# get all the submissions by looking for files named "api.h"
subfiles = []
for submission in subs:
implementations_dir = os.path.join(submissions_dir, submission, "Implementations", "crypto_aead")
implementations_dir = os.path.join(
submissions_dir, submission, "Implementations", "crypto_aead")
if not os.path.isdir(implementations_dir):
continue
......@@ -164,19 +163,17 @@ def main(argv):
pieces = f.split(os.sep)
n = pieces[1] + "." + ".".join(pieces[4:-1])
print(n)
# if include_list was provided, skip elements not in the list
if include_list is not None:
if not n in include_list:
if n not in include_list:
continue
# Put all in a tuple and count
files.append((t, d, n))
# For testing, we only do the first 1
#files = files[:1]
# files = files[:1]
print("%d algorithms will be compiled" % len(files))
if not os.path.isdir(build_root_dir):
......@@ -198,8 +195,10 @@ def main(argv):
b = build(d, template_dir, build_dir)
if b is None:
continue
test_script.write("\n\necho \"TEST NUMBER %03d: TESTING %s\"\n" % (i, d))
test_script.write("python3 -u ./test.py %s %s 2> %s | tee %s\n" % (
test_script.write(
"\n\necho \"TEST NUMBER %03d: TESTING %s\"\n" % (i, d))
test_script.write(
"python3 -u ./test.py %s %s 2> %s | tee %s\n" % (
t,
os.path.join(b, 'test'),
os.path.join(b, 'test_stderr.log'),
......
......@@ -21,6 +21,6 @@ source [find target/stm32f1x.cfg]
#tpiu config internal swodump.stm32f103-generic.log uart off 72000000
#reset_config srst_only srst_push_pull srst_nogate connect_assert_srst
reset_config none srst_push_pull srst_nogate
reset_config srst_only srst_push_pull srst_nogate connect_assert_srst
#reset_config none srst_push_pull srst_nogate
......@@ -2,197 +2,126 @@
import os
import sys
import time
import struct
import serial
import subprocess
import serial.tools.list_ports
from test_common import (
LogicMultiplexerTimeMeasurements,
parse_nist_aead_test_vectors,
DeviceUnderTestAeadUARTP,
compare_dumps,
eprint,
run_nist_aead_test_line,
)
def get_serial():
ports = serial.tools.list_ports.comports()
devices = [
p.device
for p in ports
if p.serial_number == 'FT2XCRZ1'
]
devices.sort()
return serial.Serial(
devices[0],
baudrate=115200,
timeout=5)
class BluePill(DeviceUnderTestAeadUARTP):
RAM_SIZE = 0x5000
def __init__(self, build_dir):
DeviceUnderTestAeadUARTP.__init__(self, get_serial())
self.firmware_path = os.path.join(
build_dir, '.pio/build/bluepill_f103c8/firmware.elf')
self.ram_pattern_path = os.path.join(
build_dir, 'empty_ram.bin')
self.ram_dump_path = os.path.join(
build_dir, 'ram_dump.bin')
self.openocd_cfg_path = os.path.join(
build_dir, 'openocd.cfg')
def flash(self):
# pipe = subprocess.PIPE
cmd = [
'openocd', '-f', 'openocd.cfg', '-c',
'program %s verify reset exit' % self.firmware_path]
p = subprocess.Popen(
cmd, stdout=sys.stderr, stdin=sys.stdout)
stdout, stderr = p.communicate("")
eprint("Firmware flashed.")
cmd = [
'openocd', '-f', self.openocd_cfg_path, '-c',
'program %s reset exit 0x20000000' % self.ram_pattern_path]
p = subprocess.Popen(
cmd, stdout=sys.stderr, stdin=sys.stdout)
stdout, stderr = p.communicate("")
eprint("RAM flashed.")
def dump_ram(self):
cmd = [
'openocd', '-f', self.openocd_cfg_path,
'-c', 'init',
'-c', 'halt',
'-c', 'dump_image %s 0x20000000 0x%x' % (
self.ram_dump_path, BluePill.RAM_SIZE),
'-c', 'resume',
'-c', 'exit']
p = subprocess.Popen(
cmd, stdout=sys.stderr, stdin=sys.stdout)
stdout, stderr = p.communicate("")
eprint("RAM dumped.")
with open(self.ram_dump_path, 'rb') as ram:
ram = ram.read()
if len(ram) != BluePill.RAM_SIZE:
raise Exception(
"RAM dump was %d bytes instead of %d" %
(len(ram), BluePill.RAM_SIZE))
return ram
def eprint(*args, **kargs):
print(*args, file=sys.stderr, **kargs)
def main(argv):
if len(argv) != 3:
print("Usage: test LWC_AEAD_KAT.txt build_dir")
return 1
def flash():
pipe = subprocess.PIPE
cmd = ['openocd', '-f', 'openocd.cfg', '-c' 'program ' +
'.pio/build/bluepill_f103c8/firmware.elf verify reset exit']
p = subprocess.Popen(cmd,
stdout=sys.stderr, stdin=sys.stdout)
stdout, stderr = p.communicate("")
kat = list(parse_nist_aead_test_vectors(argv[1]))
build_dir = argv[2]
dut = BluePill(build_dir)
def fill_ram():
pipe = subprocess.PIPE
cmd = ['openocd', '-f', 'openocd.cfg', '-c' 'program ' +
'empty_ram.bin reset exit 0x20000000']
p = subprocess.Popen(cmd,
stdout=sys.stderr, stdin=sys.stdout)
stdout, stderr = p.communicate("")
try:
tool = LogicMultiplexerTimeMeasurements(0x0003)
tool.begin_measurement()
dut.flash()
dut.prepare()
sys.stdout.write("Board prepared\n")
sys.stdout.flush()
def get_serial():
import serial.tools.list_ports
ports = serial.tools.list_ports.comports()
devices = [ p.device for p in ports ]
devices.sort()
return devices[-1]
class UARTP:
def __init__(self, ser):
UARTP.SYN = 0xf9
UARTP.FIN = 0xf3
self.ser = ser
def uart_read(self):
r = self.ser.read(1)
if len(r) != 1:
raise Exception("Serial read error")
return r[0]
def uart_write(self, c):
b = struct.pack("B", c)
r = self.ser.write(b)
if r != len(b):
raise Exception("Serial write error")
return r
def send(self, buf):
self.uart_write(UARTP.SYN)
len_ind_0 = 0xff & len(buf)
len_ind_1 = 0xff & (len(buf) >> 7)
if len(buf) < 128:
self.uart_write(len_ind_0)
else:
self.uart_write(len_ind_0 | 0x80)
self.uart_write(len_ind_1)
fcs = 0
for i in range(len(buf)):
info = buf[i]
fcs = (fcs + info) & 0xff
self.uart_write(buf[i])
fcs = (0xff - fcs) & 0xff
self.uart_write(fcs)
self.uart_write(UARTP.FIN)
eprint("sent frame '%s'" % buf.hex())
def recv(self):
tag_old = UARTP.FIN
while 1:
tag = tag_old
while 1:
if tag_old == UARTP.FIN:
if tag == UARTP.SYN:
break
tag_old = tag
tag = self.uart_read()
tag_old = tag
l = self.uart_read()
if l & 0x80:
l &= 0x7f
l |= self.uart_read() << 7
fcs = 0
buf = []
for i in range(l):
info = self.uart_read()
buf.append(info)
fcs = (fcs + info) & 0xff
fcs = (fcs + self.uart_read()) & 0xff
tag = self.uart_read()
if fcs == 0xff:
if tag == UARTP.FIN:
buf = bytes(buf)
eprint("rcvd frame '%s'" % buf.hex())
if len(buf) >= 1 and buf[0] == 0xde:
sys.stderr.buffer.write(buf[1:])
sys.stderr.flush()
else:
return buf
dump_a = dut.dump_ram()
def main(argv):
eprint(argv[0])
script_dir = os.path.split(argv[0])[0]
if len(script_dir) > 0:
os.chdir(script_dir)
dev = get_serial()
ser = serial.Serial(dev, baudrate=115200, timeout=5)
uartp = UARTP(ser)
flash()
fill_ram()
eprint("Flashed")
time.sleep(0.1)
ser.setDTR(False) # IO0=HIGH
ser.setRTS(True) # EN=LOW, chip in reset
time.sleep(0.1)
ser.setDTR(False) # IO0=HIGH
ser.setRTS(False) # EN=HIGH, chip out of reset
time.sleep(1)
def stdin_read(n):
b = sys.stdin.buffer.read(n)
if len(b) != n:
sys.exit(1)
return b
def stdin_readvar():
l = stdin_read(4)
(l, ) = struct.unpack("<I", l)
v = stdin_read(l)
return v
exp_hello = b"Hello, World!"
hello = ser.read(ser.in_waiting)
if hello[-13:] != exp_hello:
eprint("Improper board initialization message: %s" % hello)
return 1
eprint("Board initialized properly")
sys.stdout.write("Hello, World!\n")
sys.stdout.flush()
while 1:
action = stdin_read(1)[0]
eprint("Command %c from stdin" % action)
if action in b"ackmps":
v = stdin_readvar()
uartp.send(struct.pack("B", action) + v)
ack = uartp.recv()
if len(ack) != 1 or ack[0] != action:
raise Exception("Unacknowledged variable transfer")
eprint("Var %c successfully sent to board" % action)
elif action in b"ACKMPS":
c = struct.pack("B", action)
uartp.send(c)
v = uartp.recv()
if len(v) < 1 or v[0] != action:
raise Exception("Could not obtain variable from board")
v = v[1:]
eprint("Var %c received from board: %s" % (action, v.hex()))
l = struct.pack("<I", len(v))
sys.stdout.buffer.write(l + v)
sys.stdout.flush()
elif action in b"ed":
c = struct.pack("B", action)
uartp.send(c)
ack = uartp.recv()
if len(ack) != 1 or ack[0] != action:
raise Exception("Unacknowledged variable transfer")
eprint("Operation %c completed successfully" % action)
else:
raise Exception("Unknown action %c" % action)
return 0
for i, m, ad, k, npub, c in kat:
tool.arm()
run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
tool.unarm()
if i == 1:
dump_b = dut.dump_ram()
longest = compare_dumps(dump_a, dump_b)
print(" longest chunk of untouched memory = %d" % longest)
except Exception as ex:
print("TEST FAILED")
raise ex
finally:
tool.end_measurement()
sys.stdout.flush()
sys.stderr.flush()
if __name__ == "__main__":
......
......@@ -3,186 +3,99 @@
import os
import sys
import time
import struct
import serial
import subprocess
import serial.tools.list_ports
from test_common import (
LogicMultiplexerTimeMeasurements,
parse_nist_aead_test_vectors,
DeviceUnderTestAeadUARTP,
eprint,
run_nist_aead_test_line,
)
def get_serial():
ports = serial.tools.list_ports.comports()
devices = [
p.device
for p in ports
if (p.vid == 4292 and p.pid == 60000)
]
devices.sort()
return devices[0]
def eprint(*args, **kargs):
print(*args, file=sys.stderr, **kargs)
class ESP32(DeviceUnderTestAeadUARTP):
def flash(tty=None):
pipe = subprocess.PIPE
cmd = ['platformio', 'run', '-e', 'esp32dev', '--target', 'upload']
if tty is not None:
cmd.extend(['--upload-port', tty])
p = subprocess.Popen(cmd,
stdout=sys.stderr, stdin=pipe)
stdout, stderr = p.communicate("")
def __init__(self, build_dir):
DeviceUnderTestAeadUARTP.__init__(self)
self.build_dir = build_dir
def flash(self):
pipe = subprocess.PIPE
previous_dir = os.path.abspath(os.curdir)
os.chdir(self.build_dir)
cmd = ['platformio', 'run', '-e', 'esp32dev', '--target', 'upload']
cmd.extend(['--upload-port', get_serial()])
cmd.extend(['--upload-port', get_serial()])
p = subprocess.Popen(
cmd, stdout=sys.stderr, stdin=pipe)
stdout, stderr = p.communicate("")
eprint("Firmware flashed.")
os.chdir(previous_dir)
def dump_ram(self):
return None
def get_serial():
import serial.tools.list_ports
ports = serial.tools.list_ports.comports()
devices = [ p.device for p in ports ]
devices.sort()
return devices[-1]
class UARTP:
def __init__(self, ser):
UARTP.SYN = 0xf9
UARTP.FIN = 0xf3
self.ser = ser
def uart_read(self):
r = self.ser.read(1)
if len(r) != 1:
raise Exception("Serial read error")
return r[0]
def uart_write(self, c):
b = struct.pack("B", c)
r = self.ser.write(b)
if r != len(b):
raise Exception("Serial write error")
return r
def send(self, buf):
self.uart_write(UARTP.SYN)
len_ind_0 = 0xff & len(buf)
len_ind_1 = 0xff & (len(buf) >> 7)
if len(buf) < 128:
self.uart_write(len_ind_0)
else:
self.uart_write(len_ind_0 | 0x80)
self.uart_write(len_ind_1)
fcs = 0
for i in range(len(buf)):
info = buf[i]
fcs = (fcs + info) & 0xff
self.uart_write(buf[i])
fcs = (0xff - fcs) & 0xff
self.uart_write(fcs)
self.uart_write(UARTP.FIN)
eprint("sent frame '%s'" % buf.hex())
def recv(self):
tag_old = UARTP.FIN
while 1:
tag = tag_old
while 1:
if tag_old == UARTP.FIN:
if tag == UARTP.SYN:
break
tag_old = tag
tag = self.uart_read()
tag_old = tag
l = self.uart_read()
if l & 0x80:
l &= 0x7f
l |= self.uart_read() << 7
fcs = 0
buf = []
for i in range(l):
info = self.uart_read()
buf.append(info)
fcs = (fcs + info) & 0xff
fcs = (fcs + self.uart_read()) & 0xff
tag = self.uart_read()
if fcs == 0xff:
if tag == UARTP.FIN:
buf = bytes(buf)
eprint("rcvd frame '%s'" % buf.hex())
if len(buf) >= 1 and buf[0] == 0xde:
sys.stderr.buffer.write(buf[1:])
sys.stderr.flush()
else:
return buf
def main(argv):
eprint(argv[0])
script_dir = os.path.split(argv[0])[0]
if len(script_dir) > 0:
os.chdir(script_dir)
dev = get_serial()
flash(dev)
eprint("Flashed")
time.sleep(0.1)
ser = serial.Serial(dev, baudrate=500000, timeout=5)
uartp = UARTP(ser)
ser.setDTR(False) # IO0=HIGH
ser.setRTS(True) # EN=LOW, chip in reset
time.sleep(0.1)
ser.setDTR(False) # IO0=HIGH
ser.setRTS(False) # EN=HIGH, chip out of reset
time.sleep(1)
def stdin_read(n):
b = sys.stdin.buffer.read(n)
if len(b) != n:
sys.exit(1)
return b
def stdin_readvar():
l = stdin_read(4)
(l, ) = struct.unpack("<I", l)
v = stdin_read(l)
return v
exp_hello = b"Hello, World!"
hello = ser.read(ser.in_waiting)
if hello[-13:] != exp_hello:
eprint("Improper board initialization message: %s" % hello)
if len(argv) != 3:
print("Usage: test LWC_AEAD_KAT.txt build_dir")
return 1
eprint("Board initialized properly")
sys.stdout.write("Hello, World!\n")
sys.stdout.flush()
while 1:
action = stdin_read(1)[0]
eprint("Command %c from stdin" % action)
if action in b"ackmps":
v = stdin_readvar()
uartp.send(struct.pack("B", action) + v)
ack = uartp.recv()
if len(ack) != 1 or ack[0] != action:
raise Exception("Unacknowledged variable transfer")
eprint("Var %c successfully sent to board" % action)
elif action in b"ACKMPS":
c = struct.pack("B", action)
uartp.send(c)
v = uartp.recv()
if len(v) < 1 or v[0] != action:
raise Exception("Could not obtain variable from board")
v = v[1:]
eprint("Var %c received from board: %s" % (action, v.hex()))
l = struct.pack("<I", len(v))
sys.stdout.buffer.write(l + v)
sys.stdout.flush()
elif action in b"ed":
c = struct.pack("B", action)
uartp.send(c)
ack = uartp.recv()
if len(ack) != 1 or ack[0] != action:
raise Exception("Unacknowledged variable transfer")
eprint("Operation %c completed successfully" % action)
else:
raise Exception("Unknown action %c" % action)
return 0
kat = list(parse_nist_aead_test_vectors(argv[1]))
build_dir = argv[2]
dut = ESP32(build_dir)
try:
tool = LogicMultiplexerTimeMeasurements(0x0030)
tool.begin_measurement()
dut.flash()
ser = serial.Serial(
get_serial(),
baudrate=500000,
timeout=5)
ser.setDTR(False) # IO0=HIGH
ser.setRTS(True) # EN=LOW, chip in reset
time.sleep(0.1)
ser.setDTR(False) # IO0=HIGH
ser.setRTS(False) # EN=HIGH, chip out of reset
time.sleep(1)
dut.ser = ser
dut.prepare()
sys.stdout.write("Board prepared\n")
sys.stdout.flush()
for i, m, ad, k, npub, c in kat:
tool.arm()
run_nist_aead_test_line(dut, i, m, ad, k, npub, c)
tool.unarm()
except Exception as ex:
print("TEST FAILED")
raise ex
finally:
tool.end_measurement()
sys.stdout.flush()
sys.stderr.flush()
if __name__ == "__main__":
......
......@@ -2,245 +2,98 @@
import os
import sys
import time
import struct
import serial
import subprocess
import pylink
import serial.tools.list_ports
from test_common import (
LogicMultiplexerTimeMeasurements,
parse_nist_aead_test_vectors,
DeviceUnderTestAeadUARTP,
compare_dumps,
eprint,
run_nist_aead_test_line,
)
RAM_SIZE = 0x50000
def get_serial():
ports = serial.tools.list_ports.comports()
devices = [
p.device
for p in ports
if p.serial_number == 'FT2XA9MY'
]
devices.sort()
return serial.Serial(
devices[0],
baudrate=115200,
timeout=5)
def eprint(*args, **kargs):
print(*args, file=sys.stderr, **kargs)
class F7(DeviceUnderTestAeadUARTP):
RAM_SIZE = 0x50000
def popen_jlink():
pipe = subprocess.PIPE
cmd = ['JLinkExe']
cmd.extend(['-autoconnect', '1'])
cmd.extend(['-device', 'STM32F746ZG'])
cmd.extend(['-if', 'swd'])
cmd.extend(['-speed', '4000'])
return subprocess.Popen(cmd, stdout=sys.stderr, stdin=pipe)
def __init__(self, firmware_path, ram_pattern_path):
DeviceUnderTestAeadUARTP.__init__(self, get_serial())
self.jlink = pylink.JLink()
self.jlink.open(779340002)
self.firmware_path = firmware_path
self.ram_pattern_path = ram_pattern_path
def flash(self):
jlink = self.jlink
jlink.connect('STM32F746ZG')
jlink.flash_file(self.firmware_path, 0x8000000)
eprint("Firmware flashed.")
jlink.flash_file(self.ram_pattern_path, 0x20000000)
eprint("RAM flashed.")
jlink.reset()
jlink.restart()
def flash():
p = popen_jlink()
return p.communicate(("""
loadbin build/f7.bin 0x8000000
r
g
exit
""").encode('ascii'))
def dump_ram(self):
jlink = self.jlink
return bytes(jlink.memory_read8(0x20000000, F7.RAM_SIZE))
def fill_ram():
p = popen_jlink()
return p.communicate(("""
h
loadbin ram_pattern.bin 0x20000000
savebin ram_copy.bin 0x20000000 0x%x
r
g
exit
""" % RAM_SIZE).encode('ascii'))
def main(argv):
if len(argv) != 3:
print("Usage: test LWC_AEAD_KAT.txt build_dir")
return 1
kat = list(parse_nist_aead_test_vectors(argv[1]))
build_dir = argv[2]
def dump_ram