CloudClientStorage.c

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 <string.h>
00020 #include "key_config_manager.h"
00021 #include "CloudClientStorage.h"
00022 #include "mbed-trace/mbed_trace.h"
00023 
00024 #define TRACE_GROUP "mClt"
00025 
00026 ccs_status_e uninitialize_storage(void)
00027 {
00028     tr_debug("CloudClientStorage::uninitialize_storage");
00029 
00030     kcm_status_e status = kcm_finalize();
00031     if(status != KCM_STATUS_SUCCESS) {
00032         tr_error("CloudClientStorage::uninitialize_storage - error %d", status);
00033         return CCS_STATUS_ERROR;
00034     }
00035     return CCS_STATUS_SUCCESS;
00036 }
00037 
00038 ccs_status_e initialize_storage(void)
00039 {
00040     tr_debug("CloudClientStorage::initialize_storage");
00041     kcm_status_e status = kcm_init();
00042     if(status != KCM_STATUS_SUCCESS) {
00043         tr_error("CloudClientStorage::::initialize_storage - error %d", status);
00044         return CCS_STATUS_ERROR;
00045     }
00046     return CCS_STATUS_SUCCESS;
00047 }
00048 
00049 ccs_status_e get_config_parameter(const char* key, uint8_t *buffer, const size_t buffer_size, size_t *value_length)
00050 {
00051     if (key == NULL || buffer == NULL || buffer_size == 0) {
00052         tr_error("CloudClientStorage::get_config_parameter error, invalid parameters");
00053         return CCS_STATUS_ERROR;
00054     }
00055 
00056     tr_debug("CloudClientStorage::get_config_parameter [%s]", key);
00057 
00058     // Get parameter value to buffer
00059     kcm_status_e kcm_status = kcm_item_get_data((const uint8_t*)key,
00060                                     strlen(key),
00061                                     KCM_CONFIG_ITEM,
00062                                     buffer,
00063                                     buffer_size,
00064                                     value_length);
00065 
00066     if (kcm_status != KCM_STATUS_SUCCESS) {
00067         tr_debug("CloudClientStorage::get_config_parameter [%s] kcm get error %d", key, kcm_status);
00068         return CCS_STATUS_ERROR;
00069     }
00070 
00071     return CCS_STATUS_SUCCESS;
00072 }
00073 
00074 ccs_status_e get_config_parameter_string(const char* key, uint8_t *buffer, const size_t buffer_size)
00075 {
00076     size_t len = 0;
00077     ccs_status_e status = get_config_parameter(key, buffer, buffer_size - 1, &len);
00078 
00079     if (status == CCS_STATUS_SUCCESS) {
00080         // Null terminate after buffer value
00081         buffer[len] = 0;
00082     }
00083 
00084     return status;
00085 }
00086 
00087 
00088 ccs_status_e set_config_parameter(const char* key, const uint8_t *buffer, const size_t buffer_size)
00089 {
00090     if (key == NULL || buffer == NULL || buffer_size == 0) {
00091         tr_error("CloudClientStorage::set_config_parameter error, invalid parameters");
00092         return CCS_STATUS_ERROR;
00093     }
00094 
00095     tr_debug("CloudClientStorage::set_config_parameter [%s]", key);
00096 
00097     // Set parameter to storage
00098     kcm_status_e kcm_status = kcm_item_store((const uint8_t*)key,
00099                                  strlen(key),
00100                                  KCM_CONFIG_ITEM,
00101                                  false,
00102                                  buffer,
00103                                  buffer_size,
00104                                  NULL);
00105 
00106     if (kcm_status != KCM_STATUS_SUCCESS) {
00107         tr_debug("CloudClientStorage::set_config_parameter [%s] kcm get error %d", key, kcm_status);
00108         return CCS_STATUS_ERROR;
00109     }
00110 
00111     return CCS_STATUS_SUCCESS;
00112 }
00113 
00114 ccs_status_e delete_config_parameter(const char* key)
00115 {
00116     if (key == NULL) {
00117         tr_error("CloudClientStorage::delete_config_parameter error, invalid parameters");
00118         return CCS_STATUS_ERROR;
00119     }
00120 
00121     tr_debug("CloudClientStorage::delete_config_parameter [%s]", key);
00122 
00123     // Delete parameter from storage
00124     kcm_status_e kcm_status = kcm_item_delete((const uint8_t*)key,
00125                                   strlen(key),
00126                                   KCM_CONFIG_ITEM);
00127 
00128     if (kcm_status != KCM_STATUS_SUCCESS) {
00129         tr_debug("CloudClientStorage::delete_config_parameter [%s] kcm get error %d", key, kcm_status);
00130         return CCS_STATUS_ERROR;
00131     }
00132 
00133     return CCS_STATUS_SUCCESS;
00134 }
00135 
00136 ccs_status_e size_config_parameter(const char* key, size_t* size_out)
00137 {
00138     if (key == NULL) {
00139         tr_error("CloudClientStorage::size_config_parameter error, invalid parameters");
00140         return CCS_STATUS_ERROR;
00141     }
00142 
00143     tr_debug("CloudClientStorage::size_config_parameter [%s]", key);
00144 
00145     // Delete parameter from storage
00146     kcm_status_e kcm_status = kcm_item_get_data_size((const uint8_t*)key,
00147                                          strlen(key),
00148                                          KCM_CONFIG_ITEM,
00149                                          size_out);
00150 
00151     if (kcm_status != KCM_STATUS_SUCCESS) {
00152         tr_debug("CloudClientStorage::size_config_parameter [%s] kcm get error %d", key, kcm_status);
00153         return CCS_STATUS_ERROR;
00154     }
00155 
00156     return CCS_STATUS_SUCCESS;
00157 }
00158 
00159 ccs_status_e get_config_private_key(const char* key, uint8_t *buffer, const size_t buffer_size, size_t *value_length)
00160 {
00161     if (key == NULL || buffer == NULL || buffer_size == 0) {
00162         tr_error("CloudClientStorage::get_connector_private_key error, invalid parameters");
00163         return CCS_STATUS_ERROR;
00164     }
00165 
00166     tr_debug("CloudClientStorage::get_connector_private_key [%s]", key);
00167 
00168     // Get private key from storage
00169     kcm_status_e kcm_status = kcm_item_get_data((const uint8_t*)key,
00170                                     strlen(key),
00171                                     KCM_PRIVATE_KEY_ITEM,
00172                                     buffer,
00173                                     buffer_size,
00174                                     value_length);
00175 
00176     if (kcm_status != KCM_STATUS_SUCCESS) {
00177         tr_debug("CloudClientStorage::get_connector_private_key [%s] kcm get error %d", key, kcm_status);
00178         return CCS_STATUS_ERROR;
00179     }
00180 
00181     return CCS_STATUS_SUCCESS;
00182 }
00183 
00184 ccs_status_e set_config_private_key(const char* key, const uint8_t *buffer, const size_t buffer_size)
00185 {
00186     if (key == NULL || buffer == NULL || buffer_size == 0) {
00187         tr_error("CloudClientStorage::set_connector_private_key error, invalid parameters");
00188         return CCS_STATUS_ERROR;
00189     }
00190 
00191     tr_debug("CloudClientStorage::set_connector_private_key kcm [%s]", key);
00192 
00193     // Set private key to storage
00194     kcm_status_e kcm_status = kcm_item_store((const uint8_t*)key,
00195                                  strlen(key),
00196                                  KCM_PRIVATE_KEY_ITEM,
00197                                  false,
00198                                  buffer,
00199                                  buffer_size,
00200                                  NULL);
00201 
00202     if (kcm_status == KCM_CRYPTO_STATUS_PRIVATE_KEY_VERIFICATION_FAILED) {
00203         tr_error("CloudClientStorage::set_connector_private_key kcm validation error");
00204         return CCS_STATUS_VALIDATION_FAIL;
00205     }
00206     else if (kcm_status != KCM_STATUS_SUCCESS) {
00207         tr_debug("CloudClientStorage::set_connector_private_key kcm [%s] get error %d", key, kcm_status);
00208         return CCS_STATUS_ERROR;
00209     }
00210 
00211     return CCS_STATUS_SUCCESS;
00212 }
00213 
00214 ccs_status_e delete_config_private_key(const char* key)
00215 {
00216     if (key == NULL) {
00217         tr_error("CloudClientStorage::delete_config_private_key error, invalid parameters");
00218         return CCS_STATUS_ERROR;
00219     }
00220 
00221     tr_debug("CloudClientStorage::delete_config_private_key [%s]", key);
00222 
00223     // Delete private key from storage
00224     kcm_status_e kcm_status = kcm_item_delete((const uint8_t*)key,
00225                                   strlen(key),
00226                                   KCM_PRIVATE_KEY_ITEM);
00227 
00228     if (kcm_status != KCM_STATUS_SUCCESS) {
00229         tr_debug("CloudClientStorage::delete_config_private_key [%s] kcm get error %d", key, kcm_status);
00230         return CCS_STATUS_ERROR;
00231     }
00232 
00233     return CCS_STATUS_SUCCESS;
00234 }
00235 
00236 ccs_status_e get_config_public_key(const char* key, uint8_t *buffer, const size_t buffer_size, size_t *value_length)
00237 {
00238     if (key == NULL || buffer == NULL || buffer_size == 0) {
00239         tr_error("CloudClientStorage::get_config_public_key error, invalid parameters");
00240         return CCS_STATUS_ERROR;
00241     }
00242 
00243     tr_debug("CloudClientStorage::get_config_public_key [%s]", key);
00244 
00245     // Get parameter value to buffer
00246     kcm_status_e kcm_status = kcm_item_get_data((const uint8_t*)key,
00247                                     strlen(key),
00248                                     KCM_PUBLIC_KEY_ITEM,
00249                                     buffer,
00250                                     buffer_size,
00251                                     value_length);
00252 
00253     if (kcm_status != KCM_STATUS_SUCCESS) {
00254         tr_debug("CloudClientStorage::get_config_public_key [%s] kcm get error %d", key, kcm_status);
00255         return CCS_STATUS_ERROR;
00256     }
00257 
00258     return CCS_STATUS_SUCCESS;
00259 }
00260 
00261 ccs_status_e set_config_public_key(const char* key, const uint8_t *buffer, const size_t buffer_size)
00262 {
00263     if (key == NULL || buffer == NULL || buffer_size == 0) {
00264         tr_error("CloudClientStorage::set_config_public_key error, invalid parameters");
00265         return CCS_STATUS_ERROR;
00266     }
00267 
00268     tr_debug("CloudClientStorage::set_config_public_key - kcm [%s]", key);
00269 
00270     // Set public key to storage
00271     kcm_status_e kcm_status = kcm_item_store((const uint8_t*)key,
00272                                  strlen(key),
00273                                  KCM_PUBLIC_KEY_ITEM,
00274                                  false,
00275                                  buffer,
00276                                  buffer_size,
00277                                  NULL);
00278 
00279     if (kcm_status == KCM_CRYPTO_STATUS_PUBLIC_KEY_VERIFICATION_FAILED) {
00280         tr_error("CloudClientStorage::set_config_public_key - kcm validation error");
00281         return CCS_STATUS_VALIDATION_FAIL;
00282     }
00283     else if (kcm_status != KCM_STATUS_SUCCESS) {
00284         tr_debug("CloudClientStorage::set_config_public_key - kcm [%s] get error %d", key, kcm_status);
00285         return CCS_STATUS_ERROR;
00286     }
00287 
00288     return CCS_STATUS_SUCCESS;
00289 }
00290 
00291 ccs_status_e delete_config_public_key(const char* key)
00292 {
00293     if (key == NULL) {
00294         tr_error("CloudClientStorage::delete_config_public_key error, invalid parameters");
00295         return CCS_STATUS_ERROR;
00296     }
00297 
00298     tr_debug("CloudClientStorage::delete_config_public_key [%s]", key);
00299 
00300     // Delete the public key
00301     kcm_status_e kcm_status = kcm_item_delete((const uint8_t*)key,
00302                                   strlen(key),
00303                                   KCM_PUBLIC_KEY_ITEM);
00304 
00305     if (kcm_status != KCM_STATUS_SUCCESS) {
00306         tr_debug("CloudClientStorage::delete_config_public_key [%s] kcm get error %d", key, kcm_status);
00307         return CCS_STATUS_ERROR;
00308     }
00309 
00310     return CCS_STATUS_SUCCESS;
00311 }
00312 
00313 ccs_status_e get_config_certificate(const char* key, uint8_t *buffer, const size_t buffer_size, size_t *value_length)
00314 {
00315     if (key == NULL || buffer == NULL || buffer_size == 0) {
00316         tr_error("CloudClientStorage::get_config_certificate error, invalid parameters");
00317         return CCS_STATUS_ERROR;
00318     }
00319 
00320     tr_debug("CloudClientStorage::get_config_certificate kcm [%s]", key);
00321 
00322     // Get parameter value to buffer
00323     kcm_status_e kcm_status = kcm_item_get_data((const uint8_t*)key,
00324                                     strlen(key),
00325                                     KCM_CERTIFICATE_ITEM,
00326                                     buffer,
00327                                     buffer_size,
00328                                     value_length);
00329 
00330     if (kcm_status != KCM_STATUS_SUCCESS) {
00331         tr_debug("CloudClientStorage::get_config_certificate kcm [%s] get error %d", key, kcm_status);
00332         return CCS_STATUS_ERROR;
00333     }
00334 
00335     return CCS_STATUS_SUCCESS;
00336 }
00337 
00338 ccs_status_e set_config_certificate(const char* key, const uint8_t *buffer, const size_t buffer_size)
00339 {
00340     if (key == NULL || buffer == NULL || buffer_size == 0) {
00341         tr_error("CloudClientStorage::set_config_certificate error, invalid parameters");
00342         return CCS_STATUS_ERROR;
00343     }
00344 
00345     tr_debug("CloudClientStorage::set_config_certificate kcm [%s]", key);
00346 
00347     // Get parameter value to buffer
00348     kcm_status_e kcm_status = kcm_item_store((const uint8_t*)key,
00349                                  strlen(key),
00350                                  KCM_CERTIFICATE_ITEM,
00351                                  false,
00352                                  buffer,
00353                                  buffer_size,
00354                                  NULL);
00355 
00356     if (kcm_status != KCM_STATUS_SUCCESS) {
00357         tr_debug("CloudClientStorage::set_config_certificate kcm [%s] get error %d", key, kcm_status);
00358         return CCS_STATUS_ERROR;
00359     }
00360 
00361     return CCS_STATUS_SUCCESS;
00362 }
00363 
00364 ccs_status_e delete_config_certificate(const char* key)
00365 {
00366     if (key == NULL) {
00367         tr_error("CloudClientStorage::delete_config_certificate error, invalid parameters");
00368         return CCS_STATUS_ERROR;
00369     }
00370 
00371     tr_debug("CloudClientStorage::delete_config_certificate kcm [%s]", key);
00372 
00373     // Get parameter value to buffer
00374     kcm_status_e kcm_status = kcm_item_delete((const uint8_t*)key,
00375                                   strlen(key),
00376                                   KCM_CERTIFICATE_ITEM);
00377 
00378     if (kcm_status != KCM_STATUS_SUCCESS) {
00379         tr_debug("CloudClientStorage::delete_config_certificate kcm [%s] get error %d", key, kcm_status);
00380         return CCS_STATUS_ERROR;
00381     }
00382 
00383     return CCS_STATUS_SUCCESS;
00384 }