WolfSSL
/
wolfBoot
mirror of https://github.com/wolfSSL/wolfBoot.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Removed deprecate libcheck API

pull/481/head
Daniele Lacamera 2024-09-06 13:51:14 +02:00
parent a1a7601314
commit 29729988a8
11 changed files with 253 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tools/unit-tests/unit-common.c
View File

@ -94,12 +94,12 @@ int ext_flash_erase(uintptr_t address, int len) {
void ext_flash_unlock(void)
{
fail_unless(elocked, "Double ext unlock detected\n");
ck_assert_msg(elocked, "Double ext unlock detected\n");
elocked--;
}
void ext_flash_lock(void)
{
fail_if(elocked, "Double ext lock detected\n");
ck_assert_msg(!elocked, "Double ext lock detected\n");
elocked++;
}

98
tools/unit-tests/unit-enc-nvm.c
View File

@ -57,53 +57,53 @@ START_TEST (test_nvm_update_with_encryption)
ret = mmap_file("/tmp/wolfboot-unit-file.bin", (void *)MOCK_ADDRESS,
WOLFBOOT_PARTITION_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
#ifdef FLAGS_HOME
ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)MOCK_ADDRESS_BOOT,
WOLFBOOT_PARTITION_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
part = PART_BOOT;
base_addr = WOLFBOOT_PARTITION_BOOT_ADDRESS;
home_off = PART_BOOT_ENDFLAGS - PART_UPDATE_ENDFLAGS;
#endif
ret = mmap_file("/tmp/wolfboot-unit-swap.bin", (void *)MOCK_ADDRESS_SWAP,
WOLFBOOT_SECTOR_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
/* Sanity */
fail_if(home_off > WOLFBOOT_SECTOR_SIZE);
ck_assert(home_off <= WOLFBOOT_SECTOR_SIZE);
/* unlock the flash to allow operations */
hal_flash_unlock();
/* Check swap erase */
wolfBoot_erase_partition(PART_SWAP);
fail_if(erased_swap != 1);
ck_assert(erased_swap == 1);
for (i = 0; i < WOLFBOOT_SECTOR_SIZE; i+=4) {
uint32_t *word = ((uint32_t *)((uintptr_t)WOLFBOOT_PARTITION_SWAP_ADDRESS + i));
fail_if(*word != 0xFFFFFFFF);
ck_assert(*word == 0xFFFFFFFF);
}
erased_update = 0;
wolfBoot_erase_partition(part);
#ifndef FLAGS_HOME
fail_if(erased_update != 1);
ck_assert(erased_update == 1);
#else
fail_if(erased_boot != 1);
ck_assert(erased_boot == 1);
#endif
/* Erased flag sectors: select '0' by default */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select default fresh sector\n");
ck_assert_msg(ret == 0, "Failed to select default fresh sector\n");
/* Force a good 'magic' at the end of sector 1 by setting the magic word */
wolfBoot_set_partition_state(PART_UPDATE, IMG_STATE_NEW);
magic = get_partition_magic(PART_UPDATE);
fail_if(*magic != *boot_word,
ck_assert_msg(*magic == *boot_word,
"Failed to read back 'BOOT' trailer at the end of the partition");
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select good fresh sector\n");
ck_assert_msg(ret == 1, "Failed to select good fresh sector\n");
erased_nvm_bank1 = 0;
erased_nvm_bank0 = 0;
@ -113,37 +113,37 @@ START_TEST (test_nvm_update_with_encryption)
/* Current selected should now be 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank");
erased_nvm_bank1 = 0;
erased_nvm_bank0 = 0;
/* Check state is read back correctly */
ret = wolfBoot_get_partition_state(PART_UPDATE, &st);
fail_if(ret != 0, "Failed to read back state\n");
fail_if(st != IMG_STATE_UPDATING, "Bootloader in the wrong state\n");
ck_assert_msg(ret == 0, "Failed to read back state\n");
ck_assert_msg(st == IMG_STATE_UPDATING, "Bootloader in the wrong state\n");
/* Check that reading did not change the current sector */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select right sector after reading\n");
ck_assert_msg(ret == 0, "Failed to select right sector after reading\n");
/* Update one sector flag, it should change nvm sector */
wolfBoot_set_update_sector_flag(0, SECT_FLAG_SWAPPING);
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank0 != 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
ret = wolfBoot_get_update_sector_flag(0, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (1) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n");
/* Update sector flag, again. it should change nvm sector */
erased_nvm_bank1 = 0;
@ -152,17 +152,17 @@ START_TEST (test_nvm_update_with_encryption)
/* Current selected should now be 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank1 != 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
ret = wolfBoot_get_update_sector_flag(0, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (0) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n");
/* Update sector flag, again. it should change nvm sector */
erased_nvm_bank1 = 0;
@ -171,17 +171,17 @@ START_TEST (test_nvm_update_with_encryption)
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
ret = wolfBoot_get_update_sector_flag(1, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (1) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n");
/* Update sector flag, again. it should change nvm sector */
erased_nvm_bank1 = 0;
@ -202,7 +202,7 @@ START_TEST (test_nvm_update_with_encryption)
/* This should fall back to 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select most recent sector after deleting flags\n");
ck_assert_msg(ret == 1, "Failed to select most recent sector after deleting flags\n");
/* Start over, update some sector flags */
wolfBoot_erase_partition(PART_UPDATE);
@ -216,23 +216,23 @@ START_TEST (test_nvm_update_with_encryption)
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
for (i = 0; i < 4; i++) {
ret = wolfBoot_get_update_sector_flag(i, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n");
}
ret = wolfBoot_get_update_sector_flag(4, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (1) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n");
/* Copy flags from 1 to 0 */
src = (uint8_t *)((uintptr_t)base_addr + WOLFBOOT_PARTITION_SIZE - (2 * WOLFBOOT_SECTOR_SIZE));
@ -247,12 +247,12 @@ START_TEST (test_nvm_update_with_encryption)
/* Check if still there */
ret = wolfBoot_get_update_sector_flag(4, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n");
/* This should fall back to 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select most recent sector after deleting flags\n");
ck_assert_msg(ret == 0, "Failed to select most recent sector after deleting flags\n");
/* Erase partition and start over */
@ -260,13 +260,13 @@ START_TEST (test_nvm_update_with_encryption)
erased_boot = 0;
wolfBoot_erase_partition(part);
#ifndef FLAGS_HOME
fail_if(erased_update != 1);
ck_assert(erased_update == 1);
#else
fail_if(erased_boot != 1);
ck_assert(erased_boot == 1);
#endif
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n");
/* re-lock the flash: update_trigger implies unlocking/locking */
hal_flash_lock();
@ -276,15 +276,15 @@ START_TEST (test_nvm_update_with_encryption)
/* Current selected should now be 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank1 != 0, "Did not erase the non-selected bank");
magic = get_partition_magic(PART_UPDATE);
fail_if(*magic != *boot_word,
ck_assert_msg(*magic == *boot_word,
"Failed to read back 'BOOT' trailer at the end of the partition");
/* Sanity check at the end of the operations. */
fail_unless(locked, "The FLASH was left unlocked.\n");
ck_assert_msg(locked, "The FLASH was left unlocked.\n");
}

4
tools/unit-tests/unit-extflash.c
View File

@ -75,12 +75,12 @@ int hal_flash_erase(haladdr_t address, int len)
}
void hal_flash_unlock(void)
{
fail_unless(locked, "Double unlock detected\n");
ck_assert_msg(locked, "Double unlock detected\n");
locked--;
}
void hal_flash_lock(void)
{
fail_if(locked, "Double lock detected\n");
ck_assert_msg(!locked, "Double lock detected\n");
locked++;
}

14
tools/unit-tests/unit-mock-flash.c
View File

@ -42,7 +42,7 @@ int hal_flash_write(haladdr_t address, const uint8_t *data, int len)
{
int i;
uint8_t *a = (uint8_t *)(uintptr_t)address;
fail_if(locked, "Attempting to write to a locked FLASH");
ck_assert_msg(!locked, "Attempting to write to a locked FLASH");
if ((address >= WOLFBOOT_PARTITION_SWAP_ADDRESS) &&
(address < WOLFBOOT_PARTITION_UPDATE_ADDRESS + WOLFBOOT_SECTOR_SIZE)) {
for (i = 0; i < len; i++) {
@ -72,7 +72,7 @@ int hal_flash_write(haladdr_t address, const uint8_t *data, int len)
}
int hal_flash_erase(haladdr_t address, int len)
{
fail_if(locked, "Attempting to erase a locked FLASH");
ck_assert_msg(!locked, "Attempting to erase a locked FLASH");
if ((address >= WOLFBOOT_PARTITION_BOOT_ADDRESS) &&
(address < WOLFBOOT_PARTITION_BOOT_ADDRESS + WOLFBOOT_PARTITION_SIZE)) {
erased_boot++;
@ -109,12 +109,12 @@ int hal_flash_erase(haladdr_t address, int len)
}
void hal_flash_unlock(void)
{
fail_unless(locked, "Double unlock detected\n");
ck_assert_msg(locked, "Double unlock detected\n");
locked--;
}
void hal_flash_lock(void)
{
fail_if(locked, "Double lock detected\n");
ck_assert_msg(!locked, "Double lock detected\n");
locked++;
}
@ -160,7 +160,7 @@ int ext_flash_write(uintptr_t address, const uint8_t *data, int len)
{
int i;
uint8_t *a = (uint8_t *)address;
fail_if(ext_locked, "Attempting to write to a locked FLASH");
ck_assert_msg(!ext_locked, "Attempting to write to a locked FLASH");
for (i = 0; i < len; i++) {
a[i] = data[i];
}
@ -179,12 +179,12 @@ int ext_flash_read(uintptr_t address, uint8_t *data, int len)
void ext_flash_unlock(void)
{
fail_unless(ext_locked, "Double ext unlock detected\n");
ck_assert_msg(ext_locked, "Double ext unlock detected\n");
ext_locked--;
}
void ext_flash_lock(void)
{
fail_if(ext_locked, "Double ext lock detected\n");
ck_assert_msg(!ext_locked, "Double ext lock detected\n");
ext_locked++;
}

5
tools/unit-tests/unit-mock-state.c
View File

@ -47,6 +47,7 @@
#include <string.h>
#include "user_settings.h"
#include "wolfboot/wolfboot.h"
static uint8_t* get_trailer_at(uint8_t part, uint32_t at);
static void set_trailer_at(uint8_t part, uint32_t at, uint8_t val);
static void set_partition_magic(uint8_t part);
@ -185,12 +186,12 @@ int ext_flash_erase(uintptr_t address, int len)
}
void ext_flash_unlock(void)
{
fail_unless(ext_locked, "Double unlock detected (ext)\n");
ck_assert_msg(ext_locked, "Double unlock detected (ext)\n");
ext_locked--;
}
void ext_flash_lock(void)
{
fail_if(ext_locked, "Double lock detected(ext)\n");
ck_assert_msg(!ext_locked, "Double lock detected(ext)\n");
ext_locked++;
}

98
tools/unit-tests/unit-nvm.c
View File

@ -54,53 +54,53 @@ START_TEST (test_nvm_select_fresh_sector)
ret = mmap_file("/tmp/wolfboot-unit-file.bin", (void *)MOCK_ADDRESS,
WOLFBOOT_PARTITION_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
#ifdef FLAGS_HOME
ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)MOCK_ADDRESS_BOOT,
WOLFBOOT_PARTITION_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
part = PART_BOOT;
base_addr = WOLFBOOT_PARTITION_BOOT_ADDRESS;
home_off = PART_BOOT_ENDFLAGS - PART_UPDATE_ENDFLAGS;
#endif
ret = mmap_file("/tmp/wolfboot-unit-swap.bin", (void *)MOCK_ADDRESS_SWAP,
WOLFBOOT_SECTOR_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
/* Sanity */
fail_if(home_off > WOLFBOOT_SECTOR_SIZE);
ck_assert(home_off <= WOLFBOOT_SECTOR_SIZE);
/* unlock the flash to allow operations */
hal_flash_unlock();
/* Check swap erase */
wolfBoot_erase_partition(PART_SWAP);
fail_if(erased_swap != 1);
ck_assert(erased_swap == 1);
for (i = 0; i < WOLFBOOT_SECTOR_SIZE; i+=4) {
uint32_t *word = ((uint32_t *)((uintptr_t)WOLFBOOT_PARTITION_SWAP_ADDRESS + i));
fail_if(*word != 0xFFFFFFFF);
ck_assert(*word == 0xFFFFFFFF);
}
erased_update = 0;
wolfBoot_erase_partition(part);
#ifndef FLAGS_HOME
fail_if(erased_update != 1);
ck_assert(erased_update == 1);
#else
fail_if(erased_boot != 1);
ck_assert(erased_boot == 1);
#endif
/* Erased flag sectors: select '0' by default */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select default fresh sector\n");
ck_assert_msg(ret == 0, "Failed to select default fresh sector\n");
/* Force a good 'magic' at the end of sector 1 by setting the magic word */
wolfBoot_set_partition_state(PART_UPDATE, IMG_STATE_NEW);
magic = get_partition_magic(PART_UPDATE);
fail_if(*magic != *boot_word,
ck_assert_msg(*magic == *boot_word,
"Failed to read back 'BOOT' trailer at the end of the partition");
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select good fresh sector\n");
ck_assert_msg(ret == 1, "Failed to select good fresh sector\n");
erased_nvm_bank1 = 0;
erased_nvm_bank0 = 0;
@ -110,37 +110,37 @@ START_TEST (test_nvm_select_fresh_sector)
/* Current selected should now be 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank");
erased_nvm_bank1 = 0;
erased_nvm_bank0 = 0;
/* Check state is read back correctly */
ret = wolfBoot_get_partition_state(PART_UPDATE, &st);
fail_if(ret != 0, "Failed to read back state\n");
fail_if(st != IMG_STATE_UPDATING, "Bootloader in the wrong state\n");
ck_assert_msg(ret == 0, "Failed to read back state\n");
ck_assert_msg(st == IMG_STATE_UPDATING, "Bootloader in the wrong state\n");
/* Check that reading did not change the current sector */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select right sector after reading\n");
ck_assert_msg(ret == 0, "Failed to select right sector after reading\n");
/* Update one sector flag, it should change nvm sector */
wolfBoot_set_update_sector_flag(0, SECT_FLAG_SWAPPING);
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
ret = wolfBoot_get_update_sector_flag(0, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (1) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n");
/* Update sector flag, again. it should change nvm sector */
erased_nvm_bank1 = 0;
@ -149,17 +149,17 @@ START_TEST (test_nvm_select_fresh_sector)
/* Current selected should now be 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
ret = wolfBoot_get_update_sector_flag(0, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (0) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n");
/* Update sector flag, again. it should change nvm sector */
erased_nvm_bank1 = 0;
@ -168,17 +168,17 @@ START_TEST (test_nvm_select_fresh_sector)
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
ret = wolfBoot_get_update_sector_flag(1, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (1) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n");
/* Update sector flag, again. it should change nvm sector */
erased_nvm_bank1 = 0;
@ -198,7 +198,7 @@ START_TEST (test_nvm_select_fresh_sector)
/* This should fall back to 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select most recent sector after deleting flags\n");
ck_assert_msg(ret == 1, "Failed to select most recent sector after deleting flags\n");
/* Start over, update some sector flags */
wolfBoot_erase_partition(PART_UPDATE);
@ -212,23 +212,23 @@ START_TEST (test_nvm_select_fresh_sector)
/* Current selected should now be 1 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank0 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 1, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank0 > 0, "Did not erase the non-selected bank");
/* Check sector state is read back correctly */
for (i = 0; i < 4; i++) {
ret = wolfBoot_get_update_sector_flag(i, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n");
}
ret = wolfBoot_get_update_sector_flag(4, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_SWAPPING, "Wrong sector flag state\n");
/* Check that reading did not change the current sector (1) */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 1, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 1, "Failed to select right sector after reading sector state\n");
/* Copy flags from 1 to 0 */
src = (uint8_t *)((uintptr_t)base_addr + WOLFBOOT_PARTITION_SIZE - (8 + home_off + WOLFBOOT_SECTOR_SIZE));
@ -242,12 +242,12 @@ START_TEST (test_nvm_select_fresh_sector)
/* Check if still there */
ret = wolfBoot_get_update_sector_flag(4, &st);
fail_if (ret != 0, "Failed to read sector flag state\n");
fail_if (st != SECT_FLAG_UPDATED, "Wrong sector flag state\n");
ck_assert_msg(ret == 0, "Failed to read sector flag state\n");
ck_assert_msg(st == SECT_FLAG_UPDATED, "Wrong sector flag state\n");
/* This should fall back to 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select most recent sector after deleting flags\n");
ck_assert_msg(ret == 0, "Failed to select most recent sector after deleting flags\n");
/* Erase partition and start over */
@ -255,13 +255,13 @@ START_TEST (test_nvm_select_fresh_sector)
erased_boot = 0;
wolfBoot_erase_partition(part);
#ifndef FLAGS_HOME
fail_if(erased_update != 1);
ck_assert(erased_update == 1);
#else
fail_if(erased_boot != 1);
ck_assert(erased_boot == 1);
#endif
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select right sector after reading sector state\n");
ck_assert_msg(ret == 0, "Failed to select right sector after reading sector state\n");
/* re-lock the flash: update_trigger implies unlocking/locking */
hal_flash_lock();
@ -271,15 +271,15 @@ START_TEST (test_nvm_select_fresh_sector)
/* Current selected should now be 0 */
ret = nvm_select_fresh_sector(PART_UPDATE);
fail_if(ret != 0, "Failed to select updating fresh sector\n");
fail_if(erased_nvm_bank1 == 0, "Did not erase the non-selected bank");
ck_assert_msg(ret == 0, "Failed to select updating fresh sector\n");
ck_assert_msg(erased_nvm_bank1 > 0, "Did not erase the non-selected bank");
magic = get_partition_magic(PART_UPDATE);
fail_if(*magic != *boot_word,
ck_assert_msg(*magic == *boot_word,
"Failed to read back 'BOOT' trailer at the end of the partition");
/* Sanity check at the end of the operations. */
fail_unless(locked, "The FLASH was left unlocked.\n");
ck_assert_msg(locked, "The FLASH was left unlocked.\n");
}

38
tools/unit-tests/unit-parser.c
View File

@ -47,12 +47,12 @@ int hal_flash_erase(haladdr_t address, int len)
}
void hal_flash_unlock(void)
{
fail_unless(locked, "Double unlock detected\n");
ck_assert_msg(locked, "Double unlock detected\n");
locked--;
}
void hal_flash_lock(void)
{
fail_if(locked, "Double lock detected\n");
ck_assert_msg(!locked, "Double lock detected\n");
locked++;
}
@ -181,21 +181,21 @@ START_TEST (test_parser_sunny)
int i;
/* Check version */
fail_if(wolfBoot_find_header(test_buffer + 8, HDR_VERSION, &p) != 4, "Parser error: cannot locate version");
fail_if((p[0] != 0x0d) || (p[1] != 0x0c) || (p[2] != 0x0b) || (p[3] != 0x0a), "Parser error: version doesn't match");
ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_VERSION, &p) == 4, "Parser error: cannot locate version");
ck_assert_msg((p[0] == 0x0d) && (p[1] == 0x0c) && (p[2] == 0x0b) && (p[3] == 0x0a), "Parser error: version doesn't match");
/* Check timestamp */
fail_if(wolfBoot_find_header(test_buffer + 8, HDR_TIMESTAMP, &p) != 8, "Parser error: cannot locate timestamp");
fail_if((p[0] != 0x07) || (p[1] != 0x06) || (p[2] != 0x05) || (p[3] != 0x04), "Parser error: timestamp doesn't match");
fail_if((p[4] != 0x03) || (p[5] != 0x02) || (p[6] != 0x01) || (p[7] != 0x00), "Parser error: timestamp doesn't match");
ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_TIMESTAMP, &p) == 8, "Parser error: cannot locate timestamp");
ck_assert_msg((p[0] == 0x07) && (p[1] == 0x06) && (p[2] == 0x05) && (p[3] == 0x04), "Parser error: timestamp doesn't match");
ck_assert_msg((p[4] == 0x03) && (p[5] == 0x02) && (p[6] == 0x01) && (p[7] == 0x00), "Parser error: timestamp doesn't match");
/* Check sha256 field */
fail_if(wolfBoot_find_header(test_buffer + 8, HDR_SHA256, &p) != 32, "Parser error: cannot locate hash");
ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_SHA256, &p) == 32, "Parser error: cannot locate hash");
for (i = 0; i < 32; i++)
fail_unless(p[i] == i, "Parser error: hash does not match");
ck_assert_msg(p[i] == i, "Parser error: hash does not match");
/* Check non-existing field */
fail_if(wolfBoot_find_header(test_buffer + 8, HDR_SHA3_384, &p) != 0, "Parser error: found a non-existing field");
ck_assert_msg(wolfBoot_find_header(test_buffer + 8, HDR_SHA3_384, &p) == 0, "Parser error: found a non-existing field");
}
END_TEST
@ -211,14 +211,14 @@ START_TEST (test_parser_borders)
bad_buff[257] = 0x00;
bad_buff[258] = 0x04;
bad_buff[259] = 0x00;
fail_if(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) != 0, "Parser error: accessing version field out of bounds");
ck_assert_msg(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) == 0, "Parser error: accessing version field out of bounds");
/* Single field too large */
bad_buff[8] = 0x02;
bad_buff[9] = 0x00;
bad_buff[10] = 0xF8;
bad_buff[11] = 0x00;
fail_if(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) != 0, "Parser error: accessing version field out of bounds");
ck_assert_msg(wolfBoot_find_header(bad_buff + 8, HDR_VERSION, &p) == 0, "Parser error: accessing version field out of bounds");
/* Second field too large */
bad_buff[8] = 0x01;
@ -233,11 +233,11 @@ START_TEST (test_parser_borders)
bad_buff[17] = 0x00;
bad_buff[18] = 0xf0; /** Timestamp field too large **/
bad_buff[19] = 0x00;
fail_if(wolfBoot_find_header(bad_buff + 8, HDR_TIMESTAMP, &p) != 0, "Parser error: accessing version field out of bounds");
ck_assert_msg(wolfBoot_find_header(bad_buff + 8, HDR_TIMESTAMP, &p) == 0, "Parser error: accessing version field out of bounds");
/* High memory access */
fail_if(wolfBoot_find_header(((void *)(0 - 0xF8)), HDR_VERSION, &p) != 0);
fail_if(wolfBoot_find_header(((void *)(0 - 0x10)), HDR_VERSION, &p) != 0);
ck_assert(!wolfBoot_find_header(((void *)(0 - 0xF8)), HDR_VERSION, &p) != 0);
ck_assert(!wolfBoot_find_header(((void *)(0 - 0x10)), HDR_VERSION, &p) != 0);
}
END_TEST
@ -247,15 +247,15 @@ START_TEST (test_parser_blobs)
uint32_t ver;
uint16_t type;
ver = wolfBoot_get_blob_version(test_buffer);
fail_unless(ver == 0x0a0b0c0d, "Parser error: version does not match");
ck_assert_msg(ver == 0x0a0b0c0d, "Parser error: version does not match");
type = wolfBoot_get_blob_type(test_buffer_with_type);
fail_unless(type == 0xDDEE, "Wrong image type");
ck_assert_msg(type == 0xDDEE, "Wrong image type");
type = wolfBoot_get_blob_type(test_buffer);
fail_unless(type == 0, "Reading non-existing version: failed to report error");
ck_assert_msg(type == 0, "Reading non-existing version: failed to report error");
ver = wolfBoot_get_blob_diffbase_version(test_buffer_with_diffbase);
fail_unless(ver == 0x01020304, "Wrong delta base version parsed");
ck_assert_msg(ver == 0x01020304, "Wrong delta base version parsed");
}
END_TEST

76
tools/unit-tests/unit-pkcs11_store.c
View File

@ -89,14 +89,14 @@ START_TEST (test_store_and_load_objs) {
readonly = 0;
ret = mmap_file("/tmp/wolfboot-unit-keyvault.bin", vault_base,
keyvault_size, NULL);
fail_if(ret != 0);
ck_assert(ret == 0);
memset(vault_base, 0xEE, keyvault_size);
/* Open the vault, create the object */
fprintf(stderr, "Opening the vault\n");
printf("Flash Keyvault: %p\n", vault_base);
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_unless(ret == 0, "Failed to open the vault: %d", ret);
fail_if(store == NULL, "Did not receive a store address");
ck_assert_msg(ret == 0, "Failed to open the vault: %d", ret);
ck_assert_msg(store != NULL, "Did not receive a store address");
fprintf(stderr, "open successful\n");
/* Test two subsequent writes */
@ -110,13 +110,13 @@ START_TEST (test_store_and_load_objs) {
/* Reopen for reading */
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret);
/* Read out the content */
ret = wolfPKCS11_Store_Read(store, secret_rd, 128);
fail_if(ret != strlen(secret1) + strlen(secret2) + 2);
fail_if(strcmp(secret1, secret_rd) != 0);
fail_if(strcmp(secret2, secret_rd + 1 + strlen(secret1)) != 0);
ck_assert(ret == strlen(secret1) + strlen(secret2) + 2);
ck_assert(strcmp(secret1, secret_rd) == 0);
ck_assert(strcmp(secret2, secret_rd + 1 + strlen(secret1)) == 0);
wolfPKCS11_Store_Close(store);
/* Create a second object with same Ids, different type*/
@ -125,8 +125,8 @@ START_TEST (test_store_and_load_objs) {
fprintf(stderr, "Opening the second vault\n");
printf("Flash Keyvault: %p\n", vault_base);
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_unless(ret == 0, "Failed to open the 2nd vault: %d", ret);
fail_if(store == NULL, "Did not receive a store address for 2nd vault");
ck_assert_msg(ret == 0, "Failed to open the 2nd vault: %d", ret);
ck_assert_msg(store != NULL, "Did not receive a store address for 2nd vault");
fprintf(stderr, "open 2 successful\n");
ret = wolfPKCS11_Store_Write(store, secret2, strlen(secret2) + 1);
wolfPKCS11_Store_Close(store);
@ -134,11 +134,11 @@ START_TEST (test_store_and_load_objs) {
/* Reopen for reading */
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret);
/* Read out the content */
ret = wolfPKCS11_Store_Read(store, secret_rd, 128);
fail_if(ret != strlen(secret2) + 1);
fail_if(strcmp(secret2, secret_rd) != 0);
ck_assert(ret == strlen(secret2) + 1);
ck_assert(strcmp(secret2, secret_rd) == 0);
wolfPKCS11_Store_Close(store);
/* Create more similar objects, different secret */
@ -148,8 +148,8 @@ START_TEST (test_store_and_load_objs) {
readonly = 0;
fprintf(stderr, "Creating one more vault\n");
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_unless(ret == 0, "Failed to create vault: %d", ret);
fail_if(store == NULL, "Did not receive a store address for vault");
ck_assert_msg(ret == 0, "Failed to create vault: %d", ret);
ck_assert_msg(store != NULL, "Did not receive a store address for vault");
fprintf(stderr, "open 2 successful\n");
ret = wolfPKCS11_Store_Write(store, secret1, strlen(secret1) + 1);
@ -158,8 +158,8 @@ START_TEST (test_store_and_load_objs) {
readonly = 0;
fprintf(stderr, "Creating one more vault\n");
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_unless(ret == 0, "Failed to create vault: %d", ret);
fail_if(store == NULL, "Did not receive a store address for vault");
ck_assert_msg(ret == 0, "Failed to create vault: %d", ret);
ck_assert_msg(store != NULL, "Did not receive a store address for vault");
fprintf(stderr, "open 2 successful\n");
ret = wolfPKCS11_Store_Write(store, secret1, strlen(secret1) + 1);
wolfPKCS11_Store_Close(store);
@ -169,27 +169,27 @@ START_TEST (test_store_and_load_objs) {
id_obj = 12;
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret);
/* Read out the content */
ret = wolfPKCS11_Store_Read(store, secret_rd, 128);
fail_if(ret != strlen(secret2) + 1);
fail_if(strcmp(secret2, secret_rd) != 0);
ck_assert(ret == strlen(secret2) + 1);
ck_assert(strcmp(secret2, secret_rd) == 0);
wolfPKCS11_Store_Close(store);
/* Open non-existing vaults */
id_tok = 5;
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret == 0, "Returned with success with invalid id_tok %d", id_tok);
ck_assert_msg(ret != 0, "Returned with success with invalid id_tok %d", id_tok);
id_tok = 2;
id_obj = 0;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret == 0, "Returned with success with invalid id_obj %d", id_obj);
ck_assert_msg(ret != 0, "Returned with success with invalid id_obj %d", id_obj);
type = 0xFF;
id_tok = 2;
id_obj = 23;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret == 0, "Returned with success with invalid type %d", type);
ck_assert_msg(ret != 0, "Returned with success with invalid type %d", type);
/* Test backup recovery for allocation table */
memset(vault_base, 0xEE, WOLFBOOT_SECTOR_SIZE);
@ -198,11 +198,11 @@ START_TEST (test_store_and_load_objs) {
id_obj = 12;
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault recovering from alloc table backup: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault recovering from alloc table backup: %d", ret);
/* Read out the content */
ret = wolfPKCS11_Store_Read(store, secret_rd, 128);
fail_if(ret != strlen(secret2) + 1);
fail_if(strcmp(secret2, secret_rd) != 0);
ck_assert(ret == strlen(secret2) + 1);
ck_assert(strcmp(secret2, secret_rd) == 0);
wolfPKCS11_Store_Close(store);
/* Test backup recovery for object sector */
@ -214,11 +214,11 @@ START_TEST (test_store_and_load_objs) {
id_obj = 12;
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault recovering from object sector backup: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault recovering from object sector backup: %d", ret);
/* Read out the content */
ret = wolfPKCS11_Store_Read(store, secret_rd, 128);
fail_if(ret != strlen(secret2) + 1);
fail_if(strcmp(secret2, secret_rd) != 0);
ck_assert(ret == strlen(secret2) + 1);
ck_assert(strcmp(secret2, secret_rd) == 0);
wolfPKCS11_Store_Close(store);
/* Test with very large payload */
@ -228,8 +228,8 @@ START_TEST (test_store_and_load_objs) {
readonly = 0;
fprintf(stderr, "Creating one BIG vault\n");
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_unless(ret == 0, "Failed to create vault: %d", ret);
fail_if(store == NULL, "Did not receive a store address for vault");
ck_assert_msg(ret == 0, "Failed to create vault: %d", ret);
ck_assert_msg(store != NULL, "Did not receive a store address for vault");
fprintf(stderr, "open 3.33 successful\n");
ret = wolfPKCS11_Store_Write(store, dante_filler, strlen(dante_filler) + 1);
wolfPKCS11_Store_Close(store);
@ -237,19 +237,19 @@ START_TEST (test_store_and_load_objs) {
/* Reopen for reading */
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret);
/* Read out the content */
memset(secret_rd, 0, KEYVAULT_OBJ_SIZE);
ret = wolfPKCS11_Store_Read(store, secret_rd, KEYVAULT_OBJ_SIZE);
fail_if(ret != KEYVAULT_OBJ_SIZE - 8);
fail_if(strncmp(dante_filler, secret_rd, KEYVAULT_OBJ_SIZE - 8) != 0);
ck_assert(ret == KEYVAULT_OBJ_SIZE - 8);
ck_assert(strncmp(dante_filler, secret_rd, KEYVAULT_OBJ_SIZE - 8) == 0);
wolfPKCS11_Store_Close(store);
/* Reopen for writing, test truncate */
readonly = 0;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_unless(ret == 0, "Failed to create vault: %d", ret);
fail_if(store == NULL, "Did not receive a store address for vault");
ck_assert_msg(ret == 0, "Failed to create vault: %d", ret);
ck_assert_msg(store != NULL, "Did not receive a store address for vault");
fprintf(stderr, "open 3.33 successful\n");
ret = wolfPKCS11_Store_Write(store, short_string, strlen(short_string) + 1);
wolfPKCS11_Store_Close(store);
@ -257,12 +257,12 @@ START_TEST (test_store_and_load_objs) {
/* Reopen for reading */
readonly = 1;
ret = wolfPKCS11_Store_Open(type, id_tok, id_obj, readonly, &store);
fail_if(ret != 0, "Failed to reopen the vault in read-only mode: %d", ret);
ck_assert_msg(ret == 0, "Failed to reopen the vault in read-only mode: %d", ret);
/* Read out the content */
memset(secret_rd, 0, KEYVAULT_OBJ_SIZE);
ret = wolfPKCS11_Store_Read(store, secret_rd, KEYVAULT_OBJ_SIZE);
fail_if(ret != strlen(short_string) + 1);
fail_if(strcmp(short_string, secret_rd) != 0);
ck_assert(ret == strlen(short_string) + 1);
ck_assert(strcmp(short_string, secret_rd) == 0);
wolfPKCS11_Store_Close(store);
}
END_TEST

8
tools/unit-tests/unit-sectorflags.c
View File

@ -59,23 +59,23 @@ int hal_flash_erase(uint32_t address, int len)
}
void hal_flash_unlock(void)
{
fail_unless(locked, "Double unlock detected\n");
ck_assert_msg(locked, "Double unlock detected\n");
locked--;
}
void hal_flash_lock(void)
{
fail_if(locked, "Double lock detected\n");
ck_assert_msg(!locked, "Double lock detected\n");
locked++;
}
void ext_flash_unlock(void)
{
//fail_unless(ext_locked, "Double unlock detected\n");
//ck_assert_msg(ext_locked, "Double unlock detected\n");
ext_locked--;
}
void ext_flash_lock(void)
{
//fail_if(ext_locked, "Double lock detected\n");
//ck_assert_msg(!ext_locked, "Double lock detected\n");
ext_locked++;
}

96
tools/unit-tests/unit-update-flash.c
View File

@ -75,13 +75,13 @@ static void prepare_flash(void)
int ret;
ret = mmap_file("/tmp/wolfboot-unit-ext-file.bin", (void *)MOCK_ADDRESS_UPDATE,
WOLFBOOT_PARTITION_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)MOCK_ADDRESS_BOOT,
WOLFBOOT_PARTITION_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
ret = mmap_file("/tmp/wolfboot-unit-swap.bin", (void *)MOCK_ADDRESS_SWAP,
WOLFBOOT_SECTOR_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
hal_flash_unlock();
hal_flash_erase(WOLFBOOT_PARTITION_BOOT_ADDRESS, WOLFBOOT_PARTITION_SIZE);
hal_flash_erase(WOLFBOOT_PARTITION_UPDATE_ADDRESS, WOLFBOOT_PARTITION_SIZE);
@ -180,8 +180,8 @@ START_TEST (test_empty_panic)
reset_mock_stats();
prepare_flash();
wolfBoot_start();
fail_if(wolfBoot_staged_ok);
fail_unless(wolfBoot_panicked);
ck_assert(!wolfBoot_staged_ok);
ck_assert(wolfBoot_panicked);
cleanup_flash();
}
@ -194,9 +194,9 @@ START_TEST (test_sunnyday_noupdate)
prepare_flash();
add_payload(PART_BOOT, 1, TEST_SIZE_SMALL);
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
cleanup_flash();
}
@ -208,9 +208,9 @@ START_TEST (test_forward_update_samesize_notrigger) {
add_payload(PART_BOOT, 1, TEST_SIZE_SMALL);
add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL);
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
cleanup_flash();
}
END_TEST
@ -222,9 +222,9 @@ START_TEST (test_forward_update_samesize) {
add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL);
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 2);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 2);
cleanup_flash();
}
END_TEST
@ -236,9 +236,9 @@ START_TEST (test_forward_update_tolarger) {
add_payload(PART_UPDATE, 2, TEST_SIZE_LARGE);
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 2);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 2);
cleanup_flash();
}
END_TEST
@ -250,9 +250,9 @@ START_TEST (test_forward_update_tosmaller) {
add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL);
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 2);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 2);
cleanup_flash();
}
END_TEST
@ -264,10 +264,10 @@ START_TEST (test_forward_update_sameversion_denied) {
add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE);
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL);
cleanup_flash();
}
END_TEST
@ -279,10 +279,10 @@ START_TEST (test_update_oldversion_denied) {
add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE);
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 2);
fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 2);
ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL);
cleanup_flash();
}
@ -297,9 +297,9 @@ START_TEST (test_invalid_update_type) {
ext_flash_lock();
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
cleanup_flash();
}
@ -316,9 +316,9 @@ START_TEST (test_update_toolarge) {
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
cleanup_flash();
}
@ -335,9 +335,9 @@ START_TEST (test_invalid_sha) {
ext_flash_lock();
wolfBoot_update_trigger();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
cleanup_flash();
}
@ -354,9 +354,9 @@ START_TEST (test_emergency_rollback) {
hal_flash_lock();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 1);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 1);
cleanup_flash();
}
@ -379,9 +379,9 @@ START_TEST (test_emergency_rollback_failure_due_to_bad_update) {
ext_flash_lock();
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 2);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 2);
cleanup_flash();
}
@ -390,9 +390,9 @@ START_TEST (test_empty_boot_partition_update) {
prepare_flash();
add_payload(PART_UPDATE, 5, TEST_SIZE_SMALL);
wolfBoot_start();
fail_if(wolfBoot_panicked);
fail_unless(wolfBoot_staged_ok);
fail_if(wolfBoot_current_firmware_version() != 5);
ck_assert(!wolfBoot_panicked);
ck_assert(wolfBoot_staged_ok);
ck_assert(wolfBoot_current_firmware_version() == 5);
cleanup_flash();
}
@ -407,8 +407,8 @@ START_TEST (test_empty_boot_but_update_sha_corrupted_denied) {
ext_flash_lock();
wolfBoot_start();
/* We expect to panic */
fail_unless(wolfBoot_panicked);
fail_if(wolfBoot_staged_ok);
ck_assert(wolfBoot_panicked);
ck_assert(!wolfBoot_staged_ok);
cleanup_flash();
}

64
tools/unit-tests/unit-update-ram.c
View File

@ -95,10 +95,10 @@ static void prepare_flash(void)
int ret;
ret = mmap_file("/tmp/wolfboot-unit-ext-file.bin", (void *)(uintptr_t)MOCK_ADDRESS_UPDATE,
WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
ret = mmap_file("/tmp/wolfboot-unit-int-file.bin", (void *)(uintptr_t)MOCK_ADDRESS_BOOT,
WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE, NULL);
fail_if(ret < 0);
ck_assert(ret >= 0);
ext_flash_unlock();
ext_flash_erase(WOLFBOOT_PARTITION_BOOT_ADDRESS, WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE);
ext_flash_erase(WOLFBOOT_PARTITION_UPDATE_ADDRESS, WOLFBOOT_PARTITION_SIZE + IMAGE_HEADER_SIZE);
@ -196,7 +196,7 @@ START_TEST (test_empty_panic)
reset_mock_stats();
prepare_flash();
wolfBoot_start();
fail_if(wolfBoot_staged_ok);
ck_assert(!wolfBoot_staged_ok);
cleanup_flash();
}
@ -211,8 +211,8 @@ START_TEST (test_sunnyday_noupdate)
printf("*** MEM: %p\n", WOLFBOOT_LOAD_ADDRESS);
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
cleanup_flash();
}
@ -224,8 +224,8 @@ START_TEST (test_forward_update_samesize_notrigger) {
add_payload(PART_BOOT, 1, TEST_SIZE_SMALL);
add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL);
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
cleanup_flash();
}
END_TEST
@ -237,8 +237,8 @@ START_TEST (test_forward_update_samesize) {
add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL);
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 2);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 2);
cleanup_flash();
}
END_TEST
@ -250,8 +250,8 @@ START_TEST (test_forward_update_tolarger) {
add_payload(PART_UPDATE, 2, TEST_SIZE_LARGE);
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 2);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 2);
cleanup_flash();
}
END_TEST
@ -263,8 +263,8 @@ START_TEST (test_forward_update_tosmaller) {
add_payload(PART_UPDATE, 2, TEST_SIZE_SMALL);
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 2);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 2);
cleanup_flash();
}
END_TEST
@ -276,9 +276,9 @@ START_TEST (test_forward_update_sameversion_denied) {
add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE);
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL);
cleanup_flash();
}
END_TEST
@ -290,9 +290,9 @@ START_TEST (test_update_oldversion_denied) {
add_payload(PART_UPDATE, 1, TEST_SIZE_LARGE);
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 2);
fail_if(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) != TEST_SIZE_SMALL);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 2);
ck_assert(*(uint32_t *)(WOLFBOOT_PARTITION_BOOT_ADDRESS + 4) == TEST_SIZE_SMALL);
cleanup_flash();
}
@ -307,8 +307,8 @@ START_TEST (test_invalid_update_type) {
ext_flash_lock();
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
cleanup_flash();
}
@ -325,8 +325,8 @@ START_TEST (test_update_toolarge) {
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
cleanup_flash();
}
@ -343,8 +343,8 @@ START_TEST (test_invalid_sha) {
ext_flash_lock();
wolfBoot_update_trigger();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
cleanup_flash();
}
@ -361,8 +361,8 @@ START_TEST (test_emergency_rollback) {
ext_flash_lock();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 1);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 1);
cleanup_flash();
}
@ -385,8 +385,8 @@ START_TEST (test_emergency_rollback_failure_due_to_bad_update) {
ext_flash_lock();
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 2);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 2);
cleanup_flash();
}
@ -395,8 +395,8 @@ START_TEST (test_empty_boot_partition_update) {
prepare_flash();
add_payload(PART_UPDATE, 5, TEST_SIZE_SMALL);
wolfBoot_start();
fail_unless(wolfBoot_staged_ok);
fail_if(get_version_ramloaded() != 5);
ck_assert(wolfBoot_staged_ok);
ck_assert(get_version_ramloaded() == 5);
cleanup_flash();
}
@ -411,7 +411,7 @@ START_TEST (test_empty_boot_but_update_sha_corrupted_denied) {
ext_flash_lock();
wolfBoot_start();
/* We expect to panic */
fail_if(wolfBoot_staged_ok);
ck_assert(!wolfBoot_staged_ok);
cleanup_flash();
}