arm_uc_test_retval.cpp

00001 // ----------------------------------------------------------------------------
00002 // Copyright 2016-2017 ARM Ltd.
00003 //
00004 // SPDX-License-Identifier: Apache-2.0
00005 //
00006 // Licensed under the Apache License, Version 2.0 (the "License");
00007 // you may not use this file except in compliance with the License.
00008 // You may obtain a copy of the License at
00009 //
00010 //     http://www.apache.org/licenses/LICENSE-2.0
00011 //
00012 // Unless required by applicable law or agreed to in writing, software
00013 // distributed under the License is distributed on an "AS IS" BASIS,
00014 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00015 // See the License for the specific language governing permissions and
00016 // limitations under the License.
00017 // ----------------------------------------------------------------------------
00018 
00019 #include "test-utils/arm_uc_test_retval.h"
00020 
00021 #include "update-client-firmware-manager/arm_uc_firmware_manager.h"
00022 #include "update-client-paal/arm_uc_paal_update.h"
00023 
00024 #include "pal.h"
00025 #include "test-utils/arm_uc_test_alice.h"
00026 
00027 #include <mbedtls/sha256.h>
00028 
00029 #if defined(TARGET_LIKE_POSIX)
00030 #include <unistd.h>
00031 #define __WFI() usleep(100)
00032 #endif
00033 
00034 using namespace utest::v1;
00035 
00036 static uint8_t temp_nc[16];
00037 static arm_uc_buffer_t keyBuffer  = { .size_max = 32, .size = 32, .ptr = (uint8_t*) key };
00038 static arm_uc_buffer_t ivBuffer   = { .size_max = 16, .size = 16, .ptr = (uint8_t*) temp_nc };
00039 static arm_uc_buffer_t hashBuffer = { .size_max = 32, .size = 32, .ptr = (uint8_t*) hash };
00040 
00041 #define BUF_SIZE 1024
00042 static uint8_t buf[BUF_SIZE] = {0};
00043 static arm_uc_buffer_t fragment = {
00044     .size_max = BUF_SIZE,
00045     .size     = 0,
00046     .ptr      = buf
00047 };
00048 
00049 static uint8_t back_buf[BUF_SIZE] = {0};
00050 static arm_uc_buffer_t back_buffer = {
00051     .size_max = BUF_SIZE,
00052     .size     = 0,
00053     .ptr      = back_buf
00054 };
00055 
00056 static arm_uc_firmware_details_t firmware_details = { 0 };
00057 
00058 static bool FLAG_INIT_DONE = false;
00059 static bool FLAG_PREPARE_DONE = false;
00060 static bool FLAG_WRITE_DONE = false;
00061 static bool FLAG_WRITE_ERROR = false;
00062 static bool FLAG_FINALIZE_DONE = false;
00063 static bool FLAG_GET_FIRMWARE_DETAILS_DONE = false;
00064 static bool FLAG_GET_ACTIVE_FIRMWARE_DETAILS_DONE = false;
00065 static bool FLAG_FINALIZE_ERROR = false;
00066 
00067 static void event_handler(uint32_t event)
00068 {
00069     switch (event)
00070     {
00071         case UCFM_EVENT_INITIALIZE_DONE:
00072             FLAG_INIT_DONE = true;
00073             printf("UCFM_EVENT_INITIALIZE_DONE\r\n");
00074             break;
00075 
00076         case UCFM_EVENT_PREPARE_DONE:
00077             printf("UCFM_EVENT_PREPARE_DONE\r\n");
00078             FLAG_PREPARE_DONE = true;
00079             break;
00080 
00081         case UCFM_EVENT_WRITE_DONE:
00082             FLAG_WRITE_DONE = true;
00083             break;
00084 
00085         case UCFM_EVENT_WRITE_ERROR:
00086             printf("UCFM_EVENT_WRITE_ERROR\r\n");
00087             FLAG_WRITE_ERROR = true;
00088             break;
00089 
00090         case UCFM_EVENT_FINALIZE_DONE:
00091             printf("UCFM_EVENT_FINALIZE_DONE\r\n");
00092             FLAG_FINALIZE_DONE = true;
00093             break;
00094 
00095         case UCFM_EVENT_FINALIZE_ERROR:
00096             printf("UCFM_EVENT_FINALIZE_ERROR\r\n");
00097             FLAG_FINALIZE_ERROR = true;
00098             break;
00099 
00100         case UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE:
00101             printf("UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE\r\n");
00102             FLAG_GET_FIRMWARE_DETAILS_DONE = true;
00103             break;
00104 
00105         case UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_DONE:
00106             printf("UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE\r\n");
00107             FLAG_GET_ACTIVE_FIRMWARE_DETAILS_DONE = true;
00108             break;
00109 
00110         default:
00111             TEST_ASSERT_MESSAGE(false, "callback failed");
00112             break;
00113     }
00114 }
00115 
00116 control_t test_retval_sanity_check()
00117 {
00118     arm_uc_error_t result;
00119 
00120     /* Setup new firmware */
00121     memcpy(temp_nc, nc, sizeof(nc));
00122     ARM_UCFM_Setup_t setup;
00123     setup.mode = UCFM_MODE_AES_CTR_256_SHA_256;
00124     setup.key = &keyBuffer;
00125     setup.iv = &ivBuffer;
00126     setup.hash = &hashBuffer;
00127     setup.package_id = 0;
00128     setup.package_size = sizeof(ecila);
00129 
00130     /* temporary buffer */
00131     arm_uc_buffer_t buffer = {
00132         .size_max = BUF_SIZE,
00133         .size     = 0,
00134         .ptr      = buf
00135     };
00136 
00137     /* firmware details struct */
00138     arm_uc_firmware_details_t details = { 0 };
00139 
00140     memcpy(details.hash, hashBuffer.ptr, 32);
00141     details.version = 0;
00142     details.size = sizeof(ecila);
00143 
00144     printf("Initialize\r\n");
00145     result = ARM_UC_FirmwareManager.Initialize(NULL);
00146     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_INVALID_PARAMETER, result.code,
00147         "Initialize with null should return FIRM_ERR_INVALID_PARAMETER");
00148 
00149     result = ARM_UC_FirmwareManager.Prepare(&setup, &details, &buffer);
00150     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_UNINITIALIZED, result.code,
00151         "Calling setup before Initialize should return FIRM_ERR_UNINITIALIZED");
00152 
00153     fragment.size = 1;
00154     result = ARM_UC_FirmwareManager.Write(&fragment);
00155     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_UNINITIALIZED, result.code,
00156         "Calling Update before Initialize should return FIRM_ERR_UNINITIALIZED");
00157 
00158     fragment.size = 0;
00159     result = ARM_UC_FirmwareManager.GetActiveFirmwareDetails(&firmware_details);
00160     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_INVALID_PARAMETER, result.code,
00161         "Calling GetActiveHash before Initialize should return FIRM_ERR_INVALID_PARAMETER");
00162 
00163     result = ARM_UC_FirmwareManager.Finalize(NULL, NULL);
00164     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_UNINITIALIZED, result.code,
00165         "Calling Finish before Initialize should return FIRM_ERR_UNINITIALIZED");
00166 
00167     result = ARM_UC_FirmwareManager.Initialize(event_handler);
00168     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error,
00169         "Initialize should succeed");
00170     while(!FLAG_INIT_DONE)
00171     {
00172         ARM_UC_ProcessQueue();
00173         __WFI();
00174     }
00175 
00176     result = ARM_UC_FirmwareManager.Prepare(NULL, NULL, NULL);
00177     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_INVALID_PARAMETER, result.code,
00178         "Calling setup with NULL should return FIRM_ERR_INVALID_PARAMETER");
00179 
00180     fragment.size = 1;
00181     result = ARM_UC_FirmwareManager.Write(&fragment);
00182     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_UNINITIALIZED, result.code,
00183         "Calling Update before Setup should return FIRM_ERR_UNINITIALIZED");
00184 
00185     result = ARM_UC_FirmwareManager.Finalize(NULL, NULL);
00186     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_UNINITIALIZED, result.code,
00187         "Calling Finalize before setup should return FIRM_ERR_UNINITIALIZED");
00188 
00189     printf("setup\r\n");
00190     FLAG_PREPARE_DONE = false;
00191     result = ARM_UC_FirmwareManager.Prepare(&setup, &details, &buffer);
00192     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error,
00193         "setup should succeed");
00194     while(!FLAG_PREPARE_DONE)
00195     {
00196         ARM_UC_ProcessQueue();
00197         __WFI();
00198     }
00199 
00200     result = ARM_UC_FirmwareManager.Finalize(NULL, NULL);
00201     TEST_ASSERT_EQUAL_HEX_MESSAGE(FIRM_ERR_INVALID_PARAMETER, result.code,
00202         "Calling Finalize without parameters should fail");
00203 
00204     printf("setup\r\n");
00205     FLAG_PREPARE_DONE = false;
00206     result = ARM_UC_FirmwareManager.Prepare(&setup, &details, &buffer);
00207     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error,
00208         "setup should succeed");
00209 
00210     while(!FLAG_PREPARE_DONE)
00211     {
00212         ARM_UC_ProcessQueue();
00213         __WFI();
00214     }
00215 
00216     printf("write\r\n");
00217     uint32_t package_offset = 0;
00218     while(package_offset < setup.package_size)
00219     {
00220         uint32_t remaining = setup.package_size - package_offset;
00221 
00222         fragment.size = (remaining > fragment.size_max)? fragment.size_max:remaining;
00223         memcpy(fragment.ptr, ecila+package_offset, fragment.size);
00224 
00225         FLAG_WRITE_DONE = false;
00226         FLAG_WRITE_ERROR = false;
00227         result = ARM_UC_FirmwareManager.Write(&fragment);
00228         TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "Update");
00229         while(!FLAG_WRITE_DONE)
00230         {
00231             ARM_UC_ProcessQueue();
00232             TEST_ASSERT_EQUAL_HEX_MESSAGE(false, FLAG_WRITE_ERROR, "Write");
00233             __WFI();
00234         }
00235         package_offset += fragment.size;
00236     }
00237 
00238     TEST_ASSERT_EQUAL(package_offset, setup.package_size);
00239 
00240     FLAG_FINALIZE_DONE = false;
00241     FLAG_FINALIZE_ERROR = false;
00242     result = ARM_UC_FirmwareManager.Finalize(&fragment, &back_buffer);
00243     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "Finish");
00244     while(!FLAG_FINALIZE_DONE)
00245     {
00246         ARM_UC_ProcessQueue();
00247         TEST_ASSERT_EQUAL_HEX_MESSAGE(false, FLAG_FINALIZE_ERROR, "Finish");
00248         __WFI();
00249     }
00250 
00251     return CaseNext;
00252 }
00253