factory_configurator_client.c

00001 // ----------------------------------------------------------------------------
00002 // Copyright 2016-2017 ARM Ltd.
00003 //
00004 // Licensed under the Apache License, Version 2.0 (the "License");
00005 // you may not use this file except in compliance with the License.
00006 // You may obtain a copy of the License at
00007 //
00008 //     http://www.apache.org/licenses/LICENSE-2.0
00009 //
00010 // Unless required by applicable law or agreed to in writing, software
00011 // distributed under the License is distributed on an "AS IS" BASIS,
00012 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 // See the License for the specific language governing permissions and
00014 // limitations under the License.
00015 // ----------------------------------------------------------------------------
00016 
00017 #include "factory_configurator_client.h"
00018 #include "fcc_sotp.h"
00019 #include "key_config_manager.h"
00020 #include "pv_error_handling.h"
00021 #include "fcc_verification.h"
00022 #include "storage.h"
00023 #include "fcc_defs.h"
00024 
00025 /**
00026 * Device general info
00027 */
00028 const char g_fcc_use_bootstrap_parameter_name[] = "mbed.UseBootstrap";
00029 const char g_fcc_endpoint_parameter_name[] = "mbed.EndpointName";
00030 const char g_fcc_account_id_parameter_name[] = "mbed.AccountID";
00031 const char g_fcc_first_to_claim_parameter_name[] = "mbed.FirstToClaim";
00032 
00033 /**
00034 * Device meta data
00035 */
00036 const char g_fcc_manufacturer_parameter_name[] = "mbed.Manufacturer";
00037 const char g_fcc_model_number_parameter_name[] = "mbed.ModelNumber";
00038 const char g_fcc_device_type_parameter_name[] = "mbed.DeviceType";
00039 const char g_fcc_hardware_version_parameter_name[] = "mbed.HardwareVersion";
00040 const char g_fcc_memory_size_parameter_name[] = "mbed.MemoryTotalKB";
00041 const char g_fcc_device_serial_number_parameter_name[] = "mbed.SerialNumber";
00042 /**
00043 * Time Synchronization
00044 */
00045 const char g_fcc_current_time_parameter_name[] = "mbed.CurrentTime";
00046 const char g_fcc_device_time_zone_parameter_name[] = "mbed.Timezone";
00047 const char g_fcc_offset_from_utc_parameter_name[] = "mbed.UTCOffset";
00048 /**
00049 * Bootstrap configuration
00050 */
00051 const char g_fcc_bootstrap_server_ca_certificate_name[] = "mbed.BootstrapServerCACert";
00052 const char g_fcc_bootstrap_server_crl_name[] = "mbed.BootstrapServerCRL";
00053 const char g_fcc_bootstrap_server_uri_name[] = "mbed.BootstrapServerURI";
00054 const char g_fcc_bootstrap_device_certificate_name[] = "mbed.BootstrapDeviceCert";
00055 const char g_fcc_bootstrap_device_private_key_name[] = "mbed.BootstrapDevicePrivateKey";
00056 /**
00057 * LWm2m configuration
00058 */
00059 const char g_fcc_lwm2m_server_ca_certificate_name[] = "mbed.LwM2MServerCACert";
00060 const char g_fcc_lwm2m_server_crl_name[] = "mbed.LwM2MServerCRL";
00061 const char g_fcc_lwm2m_server_uri_name[] = "mbed.LwM2MServerURI";
00062 const char g_fcc_lwm2m_device_certificate_name[] = "mbed.LwM2MDeviceCert";
00063 const char g_fcc_lwm2m_device_private_key_name[] = "mbed.LwM2MDevicePrivateKey";
00064 /**
00065 * Firmware update
00066 */
00067 const char g_fcc_update_authentication_certificate_name[] = "mbed.UpdateAuthCert";
00068 
00069 static bool g_is_fcc_initialized = false;
00070 
00071 
00072 fcc_status_e fcc_init(void)
00073 {
00074 
00075     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00076 
00077     if (g_is_fcc_initialized) {
00078         // No need for second initialization
00079         return FCC_STATUS_SUCCESS;
00080     }
00081 
00082     //Initialize output info handler
00083     fcc_init_output_info_handler();
00084 
00085     g_is_fcc_initialized = true;
00086 
00087     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00088 
00089     return FCC_STATUS_SUCCESS;
00090 }
00091 
00092 fcc_status_e fcc_finalize(void)
00093 {
00094     kcm_status_e status;
00095 
00096     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00097 
00098     SA_PV_ERR_RECOVERABLE_RETURN_IF((!g_is_fcc_initialized), FCC_STATUS_NOT_INITIALIZED, "FCC not initialized");
00099 
00100     //FIXME: add relevant error handling - general task for all APIs.
00101     status = kcm_finalize();
00102     SA_PV_ERR_RECOVERABLE_RETURN_IF((status == KCM_STATUS_NOT_INITIALIZED), FCC_STATUS_NOT_INITIALIZED, "Failed finalize KCM\n");
00103     SA_PV_ERR_RECOVERABLE_RETURN_IF((status != KCM_STATUS_SUCCESS), FCC_STATUS_ERROR, "Failed finalize KCM");
00104 
00105     //Finalize output info handler
00106     fcc_clean_output_info_handler();
00107 
00108     g_is_fcc_initialized = false;
00109 
00110     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00111 
00112     return FCC_STATUS_SUCCESS;
00113 }
00114 
00115 fcc_status_e fcc_storage_delete()
00116 {
00117     kcm_status_e status = KCM_STATUS_SUCCESS;
00118 
00119     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00120 
00121     SA_PV_ERR_RECOVERABLE_RETURN_IF((!g_is_fcc_initialized), FCC_STATUS_NOT_INITIALIZED, "FCC not initialized");
00122 
00123     status = storage_reset();
00124     SA_PV_ERR_RECOVERABLE_RETURN_IF((status == KCM_STATUS_ESFS_ERROR), FCC_STATUS_KCM_STORAGE_ERROR, "Failed init KCM. got ESFS error");
00125     SA_PV_ERR_RECOVERABLE_RETURN_IF((status != KCM_STATUS_SUCCESS), FCC_STATUS_ERROR, "Failed storage reset");
00126 
00127     // FIXME: remove this TestOnly function when SOTP will be implemented
00128     // The storage_reset() should reset also the SOTP
00129     SOTP_TestOnly_reset();
00130     
00131     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00132     return FCC_STATUS_SUCCESS;
00133 }
00134 
00135 fcc_output_info_s* fcc_get_error_and_warning_data(void)
00136 {
00137     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00138 
00139     SA_PV_ERR_RECOVERABLE_RETURN_IF((!g_is_fcc_initialized), NULL, "FCC not initialized");
00140 
00141     return get_output_info();
00142 }
00143 
00144 fcc_status_e fcc_verify_device_configured_4mbed_cloud(void)
00145 {
00146     fcc_status_e  fcc_status =  FCC_STATUS_SUCCESS;
00147     bool use_bootstrap = false;
00148     bool success = false;
00149 
00150     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00151 
00152     SA_PV_ERR_RECOVERABLE_RETURN_IF((!g_is_fcc_initialized), FCC_STATUS_NOT_INITIALIZED, "FCC not initialized");
00153 
00154     /*Initialize fcc_output_info_s structure.
00155     In case output indo struct is not empty in the beginning of the verify process we will clean it.*/
00156     fcc_clean_output_info_handler();
00157 
00158     //Check entropy initialization
00159     success = fcc_is_entropy_initialized();
00160     SA_PV_ERR_RECOVERABLE_RETURN_IF((success != true), fcc_status = FCC_STATUS_ENTROPY_ERROR, "Entropy is not initialized");
00161 
00162     //Check time synchronization
00163     fcc_status = fcc_check_time_synchronization();
00164     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to check time synhronization");
00165 
00166     //Get bootstrap mode
00167     fcc_status = fcc_get_bootstrap_mode(&use_bootstrap);
00168     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to get bootstrap mode");
00169 
00170     // Check general info
00171     fcc_status = fcc_check_device_general_info();
00172     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to check general info");
00173 
00174     //Check device meta-data
00175     fcc_status = fcc_check_device_meta_data();
00176     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to check configuration parameters");
00177 
00178     //Check device security objects
00179     fcc_status = fcc_check_device_security_objects(use_bootstrap);
00180     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to check device security objects");
00181 
00182     //Check firmware integrity
00183     fcc_status = fcc_check_firmware_update_integrity();
00184     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to check device security objects");
00185 
00186     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00187 
00188     return fcc_status;
00189 }
00190 
00191 fcc_status_e fcc_entropy_set(const uint8_t *buf, size_t buf_size)
00192 {
00193     fcc_status_e fcc_status;
00194     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00195 
00196     fcc_status = fcc_sotp_data_store(buf, buf_size, FCC_SOTP_TYPE_ENTROPY);
00197     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to set entropy");
00198 
00199     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00200     return FCC_STATUS_SUCCESS;
00201 }
00202 
00203 fcc_status_e fcc_rot_set(const uint8_t *buf, size_t buf_size)
00204 {
00205     fcc_status_e fcc_status;
00206     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00207 
00208     fcc_status = fcc_sotp_data_store(buf, buf_size, FCC_SOTP_TYPE_ROT);
00209     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed to set RoT");
00210 
00211     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00212     return FCC_STATUS_SUCCESS;
00213 }
00214 
00215 fcc_status_e fcc_secure_time_set(uint64_t time)
00216 {
00217     palStatus_t pal_status;
00218 
00219     //FIXME: Should be replaced by some other ESFS API that will handle situations where time is already set
00220     pal_status = pal_osSetTime(time);
00221     SA_PV_ERR_RECOVERABLE_RETURN_IF((pal_status != PAL_SUCCESS), FCC_STATUS_ERROR, "Failed to set new EPOCH time (pal_status = %" PRIu32 ")", pal_status);
00222 
00223     return FCC_STATUS_SUCCESS;
00224 }
00225 
00226 fcc_status_e fcc_factory_disable(void)
00227 {
00228     fcc_status_e fcc_status;
00229     int64_t factory_disable_flag = 1;
00230 
00231     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00232 
00233     fcc_status = fcc_sotp_data_store((uint8_t *)(&factory_disable_flag), sizeof(factory_disable_flag), FCC_SOTP_TYPE_FACTORY_DISABLE);
00234     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed for fcc_sotp_buffer_store");
00235 
00236     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00237     return FCC_STATUS_SUCCESS;
00238 }
00239 
00240 fcc_status_e fcc_is_factory_disabled(bool *is_factory_disabled)
00241 {
00242     fcc_status_e fcc_status;
00243     int64_t factory_disable_flag = 0;
00244     size_t data_actual_size_out = 0;
00245 
00246     SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS();
00247 
00248     SA_PV_ERR_RECOVERABLE_RETURN_IF((is_factory_disabled == NULL), FCC_STATUS_INVALID_PARAMETER, "Invalid param is_factory_disabled");
00249 
00250     fcc_status = fcc_sotp_data_retrieve((uint8_t *)(&factory_disable_flag), sizeof(factory_disable_flag), &data_actual_size_out, FCC_SOTP_TYPE_FACTORY_DISABLE);
00251     SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status, "Failed for fcc_sotp_buffer_retrieve");
00252     SA_PV_ERR_RECOVERABLE_RETURN_IF(((factory_disable_flag != 0) && (factory_disable_flag != 1)), FCC_STATUS_FACTORY_DISABLED_ERROR, "Failed for fcc_sotp_buffer_retrieve");
00253 
00254     // If we get here - it must be either "0" or "1"
00255     *is_factory_disabled = (factory_disable_flag == 1) ? true : false;
00256 
00257     SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS();
00258     return FCC_STATUS_SUCCESS;
00259 }