def test_flexspi_conf_block_fcb(data_dir) -> None: # default object created fcb = FlexSPIConfBlockFCB() assert fcb.info() assert fcb.export() assert fcb == FlexSPIConfBlockFCB.parse(fcb.export()) fcb.padding_len = 10 assert len(fcb.export()) == fcb.space # FCB from RT105x EVK fcb_path = os.path.join(data_dir, 'rt105x_flex_spi.fcb') fcb = FlexSPIConfBlockFCB.parse(load_binary(fcb_path)) assert fcb.info() fcb.padding_len = 0 compare_bin_files(fcb_path, fcb.export()) fcb.enabled = False assert fcb.size == 0 assert fcb.export() == b'' # invalid tag with pytest.raises(ValueError): FlexSPIConfBlockFCB.parse(b'\x00' * 512) # invalid version with pytest.raises(ValueError): FlexSPIConfBlockFCB.parse(FlexSPIConfBlockFCB.TAG + b'\x00' * 512) # insufficient length with pytest.raises(ValueError): FlexSPIConfBlockFCB.parse(FlexSPIConfBlockFCB.TAG + FlexSPIConfBlockFCB.VERSION[::-1])
def write_sb(cpu_params: CpuParams, image_file_name: str, img: SecureBootV1) -> None: """Write SB image to the external flash The method behaviour depends on TEST_IMG_CONTENT: - if True (TEST MODE), the method generates the image and compare with previous version - if False (PRODUCTION), the method generates the image and burn into FLASH :param cpu_params: processor specific parameters of the test :param image_file_name: of the image to be written (including file extension) :param img: image instance to be written """ path = os.path.join(cpu_params.data_dir, OUTPUT_IMAGES_SUBDIR, image_file_name) dbg_info = DebugInfo() img_data = img.export(dbg_info=dbg_info, # use the following parameters only for unit test header_padding8=b'\xdb\x00\x76\x7a\xf4\x81\x0b\x86', auth_padding=b'\x36\x72\xf4\x99\x92\x05\x34\xd2\xd5\x17\xa0\xf7') write_dbg_log(cpu_params.data_dir, image_file_name, dbg_info.lines, TEST_IMG_CONTENT) if TEST_IMG_CONTENT: assert img.info() # quick check info prints non-empty output compare_bin_files(path, img_data) img = SecureBootV1.parse(b'0' + img_data, 1) dbg_info2 = DebugInfo() img_data2 = img.export(dbg_info=dbg_info2, header_padding8=b'\xdb\x00\x76\x7a\xf4\x81\x0b\x86', auth_padding=b'\x36\x72\xf4\x99\x92\x05\x34\xd2\xd5\x17\xa0\xf7') assert dbg_info.lines == dbg_info2.lines assert img_data == img_data2 else: with open(path, 'wb') as f: f.write(img_data) mboot = init_flashloader(cpu_params) assert mboot.receive_sb_file(img_data) mboot.close()
def write_sb(data_dir: str, sb_file_name: str, bin_data: bytes, key_store: KeyStore) -> None: """ In production mode, this function should write SB file to the disk and burn info external FLASH. In test mode, the function just compare existing content with provided content. :param data_dir: absolute path of the data directory :param sb_file_name: of the output SB file on the disk :param bin_data: binary content of the SB file :param key_store: key-store used for SB file """ path = os.path.join(data_dir, OUTPUT_IMAGES_SUBDIR, sb_file_name) if TEST_IMG_CONTENT: compare_bin_files(path, bin_data) else: with open(path, 'wb') as f: f.write(bin_data) send_sb_via_usb_into_processor(bin_data, key_store)
def write_image(data_dir: str, image_file_name: str, bin_data: bytes) -> None: """In production mode, this function should write image to the disk and burn info external FLASH. In test mode, the function just compare existing image with provided image. :param data_dir: absolute path of the data directory :param image_file_name: of the output image on the disk :param bin_data: binary content of the image """ path = os.path.join(data_dir, OUTPUT_IMAGES_SUBDIR, image_file_name) if TEST_IMG_CONTENT: compare_bin_files(path, bin_data) else: with open(path, "wb") as f: f.write(bin_data) # burn info external flash; processor must be connected using USB mboot = burn_img_via_usb_into_flexspi_flash(data_dir, bin_data) mboot.close()
def test_srk_table(cpu_params: CpuParams) -> None: """Test creation of SRK table and SRK fuses""" srk_table = srk_table4(cpu_params) srk_table_path = os.path.join(cpu_params.srk_data_dir, 'SRK_hash_table.bin') srk_fuses_path = os.path.join(cpu_params.srk_data_dir, 'SRK_fuses.bin') # test valid fuse value assert srk_table.get_fuse(0) == 0x3B86E63F assert srk_table.get_fuse(7) == 0xc542ab47 # if TEST_IMG_CONTENT: compare_bin_files(srk_table_path, srk_table.export()) compare_bin_files(srk_fuses_path, srk_table.export_fuses()) else: with open(srk_table_path, 'wb') as f: f.write(srk_table.export()) with open(srk_fuses_path, 'wb') as f: f.write(srk_table.export_fuses())
def write_image( cpu_params: CpuParams, image_file_name: str, img: BootImgRT, otpmk_bee_regions: Tuple[BeeFacRegion, ...] = tuple(), ) -> None: """Write image to the external flash The method behaviour depends on TEST_IMG_CONTENT: - if True (TEST MODE), the method generates the image and compare with previous version - if False (PRODUCTION), the method generates the image and burn into FLASH :param cpu_params: processor specific parameters of the test :param image_file_name: of the image to be written (including file extension) :param img: image instance to be written :param otpmk_bee_regions: optional list of BEE regions for BEE OTPMK encryption """ path = os.path.join(cpu_params.data_dir, OUTPUT_IMAGES_SUBDIR, image_file_name) debug_info = DebugInfo() # use zulu datetime for test purposes only, to produce stable output; remove the parameter for production zulu = datetime(year=2020, month=4, day=8, hour=5, minute=54, second=33, tzinfo=timezone.utc) img_data = img.export(dbg_info=debug_info, zulu=zulu) assert len(img_data) == img.size write_dbg_log(cpu_params.data_dir, image_file_name, debug_info.lines, TEST_IMG_CONTENT) if TEST_IMG_CONTENT: assert img.info() # quick check info prints non-empty output compare_bin_files(path, img_data) # compare no-padding if (NO_PADDING and img.fcb.enabled and isinstance(img.fcb, PaddingFCB) and not img.bee_encrypted): img.fcb.enabled = False compare_bin_files(path.replace(".bin", "_nopadding.bin"), img.export(zulu=zulu)) img.fcb.enabled = False # test that parse image will return same content if img.fcb.enabled and not img.bee_encrypted: compare_bin_files(path, BootImgRT.parse(img_data).export()) # test that size matches len of exported data assert img.size == len(img_data) else: with open(path, "wb") as f: f.write(img_data) if (NO_PADDING and img.fcb.enabled and isinstance(img.fcb, PaddingFCB) and not img.bee_encrypted): with open(path.replace(".bin", "_nopadding.bin"), "wb") as f: f.write(img_data[img.ivt_offset:]) if img.ivt_offset == BootImgRT.IVT_OFFSET_NOR_FLASH: _burn_image_to_flash(cpu_params, img, img_data, otpmk_bee_regions) else: assert len(otpmk_bee_regions) == 0 _burn_image_to_sd(cpu_params, img, img_data)