arm_uc_test_gethash.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 // fixup the compilation on ARMCC for PRIu32
00020 #define __STDC_FORMAT_MACROS
00021 #include <inttypes.h>
00022 
00023 #include "test-utils/arm_uc_test_gethash.h"
00024 
00025 #include "update-client-firmware-manager/arm_uc_firmware_manager.h"
00026 #include "update-client-paal/arm_uc_paal_update.h"
00027 
00028 #include "pal.h"
00029 #include "test-utils/arm_uc_test_alice.h"
00030 
00031 #include <mbedtls/sha256.h>
00032 
00033 #if defined(TARGET_LIKE_POSIX)
00034 #include <unistd.h>
00035 #define __WFI() usleep(100)
00036 #endif
00037 
00038 using namespace utest::v1;
00039 
00040 static uint8_t temp_nc[16];
00041 static arm_uc_buffer_t keyBuffer  = { .size_max = 32, .size = 32, .ptr = (uint8_t*) key };
00042 static arm_uc_buffer_t ivBuffer   = { .size_max = 16, .size = 16, .ptr = (uint8_t*) temp_nc };
00043 static arm_uc_buffer_t hashBuffer = { .size_max = 32, .size = 32, .ptr = (uint8_t*) hash };
00044 
00045 #define BUF_SIZE 1024
00046 static uint8_t buf[BUF_SIZE] = {0};
00047 static arm_uc_buffer_t fragment = {
00048     .size_max = BUF_SIZE,
00049     .size     = 0,
00050     .ptr      = buf
00051 };
00052 static uint8_t buf_back[BUF_SIZE] = {0};
00053 static arm_uc_buffer_t back_buffer = {
00054     .size_max = BUF_SIZE,
00055     .size     = 0,
00056     .ptr      = buf_back
00057 };
00058 static arm_uc_firmware_details_t firmware_details = { 0 };
00059 
00060 static bool FLAG_INITIALIZE_DONE = false;
00061 static bool FLAG_PREPARE_DONE = false;
00062 static bool FLAG_WRITE_DONE = false;
00063 static bool FLAG_FINALIZE_DONE = false;
00064 static bool FLAG_GET_FIRMWARE_DETAILS_DONE = false;
00065 static bool FLAG_GET_ACTIVE_FIRMWARE_DETAILS_DONE = false;
00066 
00067 static void event_handler(uint32_t event)
00068 {
00069     switch (event)
00070     {
00071         case UCFM_EVENT_INITIALIZE_DONE:
00072             printf("UCFM_EVENT_INITIALIZE_DONE\r\n");
00073             FLAG_INITIALIZE_DONE = true;
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_FINALIZE_DONE:
00086             printf("UCFM_EVENT_FINALIZE_DONE\r\n");
00087             FLAG_FINALIZE_DONE = true;
00088             break;
00089 
00090         case UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE:
00091             printf("UCFM_EVENT_GET_FIRMWARE_DETAILS_DONE\r\n");
00092             FLAG_GET_FIRMWARE_DETAILS_DONE = true;
00093             break;
00094 
00095         case UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_DONE:
00096             printf("UCFM_EVENT_GET_ACTIVE_FIRMWARE_DETAILS_DONE\r\n");
00097             FLAG_GET_ACTIVE_FIRMWARE_DETAILS_DONE = true;
00098             break;
00099 
00100         default:
00101             printf("unexpected event: %" PRIu32 "\r\n", event);
00102             TEST_ASSERT_MESSAGE(false, "call failed");
00103             break;
00104     }
00105 }
00106 
00107 control_t test_get_stored_hash_generic(arm_uc_buffer_t *front, arm_uc_buffer_t *back)
00108 {
00109     arm_uc_error_t result;
00110 
00111     /* Setup new firmware */
00112     memcpy(temp_nc, nc, sizeof(nc));
00113     ARM_UCFM_Setup_t setup;
00114     setup.mode = UCFM_MODE_AES_CTR_256_SHA_256;
00115     setup.key = &keyBuffer;
00116     setup.iv = &ivBuffer;
00117     setup.hash = &hashBuffer;
00118     setup.package_id = 0;
00119     setup.package_size = sizeof(ecila);
00120 
00121     /* temporary buffer */
00122     arm_uc_buffer_t buffer = {
00123         .size_max = BUF_SIZE,
00124         .size     = 0,
00125         .ptr      = buf
00126     };
00127 
00128     /* firmware details struct */
00129     arm_uc_firmware_details_t details = { 0 };
00130 
00131     memcpy(details.hash, hashBuffer.ptr, 32);
00132     details.version = 0;
00133     details.size = sizeof(ecila);
00134 
00135     printf("Initialize\r\n");
00136     FLAG_INITIALIZE_DONE = false;
00137     result = ARM_UC_FirmwareManager.Initialize(event_handler);
00138     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "Initialize");
00139     while(!FLAG_INITIALIZE_DONE)
00140     {
00141         ARM_UC_ProcessQueue();
00142         __WFI();
00143     }
00144 
00145     printf("Prepare\r\n");
00146     FLAG_PREPARE_DONE = false;
00147     result = ARM_UC_FirmwareManager.Prepare(&setup, &details, &buffer);
00148     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "setup");
00149     while(!FLAG_PREPARE_DONE)
00150     {
00151         ARM_UC_ProcessQueue();
00152         __WFI();
00153     }
00154 
00155     uint32_t package_offset = 0;
00156     printf("Write\r\n");
00157     while(package_offset < setup.package_size)
00158     {
00159         uint32_t remaining = setup.package_size - package_offset;
00160 
00161         fragment.size = (remaining > fragment.size_max)? fragment.size_max:remaining;
00162         memcpy(fragment.ptr, ecila+package_offset, fragment.size);
00163 
00164         FLAG_WRITE_DONE = false;
00165         result = ARM_UC_FirmwareManager.Write(&fragment);
00166         TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "Write");
00167         while(!FLAG_WRITE_DONE)
00168         {
00169             ARM_UC_ProcessQueue();
00170             __WFI();
00171         }
00172         package_offset += fragment.size;
00173     }
00174     printf("\r\n");
00175 
00176     TEST_ASSERT_EQUAL(package_offset, setup.package_size);
00177 
00178     FLAG_FINALIZE_DONE = false;
00179     printf("Finish\r\n");
00180     result = ARM_UC_FirmwareManager.Finalize(front, back);
00181     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "Finish");
00182     while(!FLAG_FINALIZE_DONE)
00183     {
00184         ARM_UC_ProcessQueue();
00185         __WFI();
00186     }
00187 
00188     FLAG_GET_FIRMWARE_DETAILS_DONE = false;
00189 
00190     printf("GetFirmwareDetails\r\n");
00191     result = ARM_UC_FirmwareManager.GetFirmwareDetails(setup.package_id,
00192                                                        &firmware_details);
00193     TEST_ASSERT_EQUAL_HEX_MESSAGE(ERR_NONE, result.error, "GetFirmwareDetails");
00194     while(!FLAG_GET_FIRMWARE_DETAILS_DONE)
00195     {
00196         ARM_UC_ProcessQueue();
00197         __WFI();
00198     }
00199 
00200     printf("\r\n");
00201 
00202     printf("expected hash  : ");
00203     for (size_t index = 0; index < 256/8; index++)
00204     {
00205         printf("%02X", hashBuffer.ptr[index]);
00206     }
00207     printf("\r\n");
00208 
00209     printf("read hash: ");
00210     for (size_t index = 0; index < 256/8; index++)
00211     {
00212         printf("%02X", firmware_details.hash[index]);
00213     }
00214     printf("\r\n");
00215 
00216     TEST_ASSERT_EQUAL_HEX8_ARRAY(firmware_details.hash,
00217                                  hashBuffer.ptr,
00218                                  hashBuffer.size);
00219 
00220     return CaseNext;
00221 }
00222 
00223 control_t test_get_stored_hash_single_buffer()
00224 {
00225     return test_get_stored_hash_generic(&fragment, NULL);
00226 }
00227 
00228 control_t test_get_stored_hash_double_buffering()
00229 {
00230     return test_get_stored_hash_generic(&fragment, &back_buffer);
00231 }
00232