m2msecurity.cpp

00001 /*
00002  * Copyright (c) 2015 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * 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, WITHOUT
00012  * 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 #include <cstdio>
00017 #include "mbed-client/m2msecurity.h"
00018 #include "mbed-client/m2mconstants.h"
00019 #include "mbed-client/m2mobject.h"
00020 #include "mbed-client/m2mobjectinstance.h"
00021 #include "mbed-client/m2mresource.h"
00022 
00023 
00024 M2MSecurity::M2MSecurity(ServerType ser_type)
00025 : M2MObject(M2M_SECURITY_ID),
00026  _server_type(ser_type),
00027  _server_instance(NULL)
00028 {
00029      _server_instance  = M2MObject::create_object_instance();
00030 
00031     if(_server_instance) {
00032 
00033         M2MResource* res = _server_instance->create_dynamic_resource(SECURITY_M2M_SERVER_URI,
00034                                                                      OMA_RESOURCE_TYPE,
00035                                                                      M2MResourceInstance::STRING,
00036                                                                      false);
00037         if(res) {
00038             res->set_operation(M2MBase::NOT_ALLOWED);
00039         }
00040         res = _server_instance->create_dynamic_resource(SECURITY_BOOTSTRAP_SERVER,
00041                                                         OMA_RESOURCE_TYPE,
00042                                                         M2MResourceInstance::BOOLEAN,
00043                                                         false);
00044         if(res) {
00045             res->set_operation(M2MBase::NOT_ALLOWED);
00046         }
00047         res = _server_instance->create_dynamic_resource(SECURITY_SECURITY_MODE,
00048                                                         OMA_RESOURCE_TYPE,
00049                                                         M2MResourceInstance::INTEGER,
00050                                                         false);
00051         if(res) {
00052             res->set_operation(M2MBase::NOT_ALLOWED);
00053         }
00054         res = _server_instance->create_dynamic_resource(SECURITY_PUBLIC_KEY,
00055                                                         OMA_RESOURCE_TYPE,
00056                                                         M2MResourceInstance::OPAQUE,
00057                                                         false);
00058         if(res) {
00059             res->set_operation(M2MBase::NOT_ALLOWED);
00060         }
00061         res = _server_instance->create_dynamic_resource(SECURITY_SERVER_PUBLIC_KEY,
00062                                                         OMA_RESOURCE_TYPE,
00063                                                         M2MResourceInstance::OPAQUE,
00064                                                         false);
00065         if(res) {
00066             res->set_operation(M2MBase::NOT_ALLOWED);
00067         }
00068         res = _server_instance->create_dynamic_resource(SECURITY_SECRET_KEY,
00069                                                         OMA_RESOURCE_TYPE,
00070                                                         M2MResourceInstance::OPAQUE,
00071                                                         false);
00072         if(res) {
00073             res->set_operation(M2MBase::NOT_ALLOWED);
00074         }
00075         if(M2MSecurity::M2MServer == ser_type) {
00076             res = _server_instance->create_dynamic_resource(SECURITY_SHORT_SERVER_ID,
00077                                                             OMA_RESOURCE_TYPE,
00078                                                             M2MResourceInstance::INTEGER,
00079                                                             false);
00080             if(res) {
00081                 res->set_operation(M2MBase::NOT_ALLOWED);
00082             }
00083         }
00084     }
00085 }
00086 
00087 M2MSecurity::~M2MSecurity()
00088 {
00089     _server_instance = NULL;
00090 }
00091 
00092 M2MResource* M2MSecurity::create_resource(SecurityResource resource, uint32_t value)
00093 {
00094     M2MResource* res = NULL;
00095     String security_id = "";
00096     if(!is_resource_present(resource)) {
00097         switch(resource) {
00098             case SMSSecurityMode:
00099                security_id = SECURITY_SMS_SECURITY_MODE;
00100                break;
00101             case M2MServerSMSNumber:
00102                 security_id = SECURITY_M2M_SERVER_SMS_NUMBER;
00103                 break;
00104             case ShortServerID:
00105                 security_id = SECURITY_SHORT_SERVER_ID;
00106                 break;
00107             case ClientHoldOffTime:
00108                 security_id = SECURITY_CLIENT_HOLD_OFF_TIME;
00109                 break;
00110             default:
00111                 break;
00112         }
00113     }
00114     if(!security_id.empty()) {
00115         if(_server_instance) {
00116 
00117             res = _server_instance->create_dynamic_resource(security_id,OMA_RESOURCE_TYPE,
00118                                                             M2MResourceInstance::INTEGER,
00119                                                             false);
00120 
00121             if(res) {
00122                 char *buffer = (char*)malloc(20);
00123                 if(buffer) {
00124                     int size = snprintf(buffer, 20,"%ld",(long int)value);
00125                     res->set_operation(M2MBase::NOT_ALLOWED);
00126                     res->set_value((const uint8_t*)buffer,
00127                                    (uint32_t)size);
00128                     free(buffer);
00129                 }
00130             }
00131         }
00132     }
00133     return res;
00134 }
00135 
00136 bool M2MSecurity::delete_resource(SecurityResource resource)
00137 {
00138     bool success = false;
00139     String security_id = "";
00140     switch(resource) {
00141         case SMSSecurityMode:
00142            security_id = SECURITY_SMS_SECURITY_MODE;
00143            break;
00144         case M2MServerSMSNumber:
00145             security_id = SECURITY_M2M_SERVER_SMS_NUMBER;
00146             break;
00147         case ShortServerID:
00148             if(M2MSecurity::Bootstrap == _server_type) {
00149                 security_id = SECURITY_SHORT_SERVER_ID;
00150             }
00151             break;
00152         case ClientHoldOffTime:
00153             security_id = SECURITY_CLIENT_HOLD_OFF_TIME;
00154             break;
00155         default:
00156             // Others are mandatory resources hence cannot be deleted.
00157             break;
00158     }
00159     if(!security_id.empty()) {
00160         if(_server_instance) {
00161             success = _server_instance->remove_resource(security_id);
00162         }
00163     }
00164     return success;
00165 }
00166 
00167 bool M2MSecurity::set_resource_value(SecurityResource resource,
00168                                      const String &value)
00169 {
00170     bool success = false;
00171     if(M2MSecurity::M2MServerUri == resource) {
00172         M2MResource* res = get_resource(resource);
00173         if(res) {
00174             success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length());
00175         }
00176     }
00177     return success;
00178 }
00179 
00180 bool M2MSecurity::set_resource_value(SecurityResource resource,
00181                                      uint32_t value)
00182 {
00183     bool success = false;
00184     M2MResource* res = get_resource(resource);
00185     if(res) {
00186         if(M2MSecurity::SecurityMode == resource        ||
00187            M2MSecurity::SMSSecurityMode == resource     ||
00188            M2MSecurity::M2MServerSMSNumber == resource  ||
00189            M2MSecurity::ShortServerID == resource       ||
00190            M2MSecurity::ClientHoldOffTime == resource) {
00191             // If it is any of the above resource
00192             // set the value of the resource.
00193             char *buffer = (char*)malloc(20);
00194             if(buffer) {
00195                 int size = snprintf(buffer, 20,"%ld",(long int)value);
00196                 success = res->set_value((const uint8_t*)buffer,
00197                                          (uint32_t)size);
00198                 free(buffer);
00199             }
00200         }
00201     }
00202     return success;
00203 }
00204 
00205 bool M2MSecurity::set_resource_value(SecurityResource resource,
00206                                      const uint8_t *value,
00207                                      const uint16_t length)
00208 {
00209     bool success = false;
00210     M2MResource* res = get_resource(resource);
00211     if(res) {
00212         if(M2MSecurity::PublicKey == resource           ||
00213            M2MSecurity::ServerPublicKey == resource     ||
00214            M2MSecurity::Secretkey == resource) {
00215             success = res->set_value(value,length);
00216         }
00217     }
00218     return success;
00219 }
00220 
00221 String M2MSecurity::resource_value_string(SecurityResource resource) const
00222 {
00223     String value = "";
00224     M2MResource* res = get_resource(resource);
00225     if(res) {
00226         if(M2MSecurity::M2MServerUri == resource) {
00227             uint8_t* buffer = NULL;
00228             uint32_t length = 0;
00229             res->get_value(buffer,length);
00230 
00231             char *char_buffer = (char*)malloc(length+1);
00232             if(char_buffer) {
00233                 memset(char_buffer,0,length+1);
00234                 if(buffer) {
00235                     memcpy(char_buffer,(char*)buffer,length);                    
00236                 }
00237                 String s_name(char_buffer);
00238                 value = s_name;
00239                 free(char_buffer);
00240             }
00241             if(buffer) {
00242                 free(buffer);
00243             }
00244         }
00245     }
00246     return value;
00247 }
00248 
00249 uint32_t M2MSecurity::resource_value_buffer(SecurityResource resource,
00250                                uint8_t *&data) const
00251 {
00252     uint32_t size = 0;
00253     M2MResource* res = get_resource(resource);
00254     if(res) {
00255         if(M2MSecurity::PublicKey == resource        ||
00256            M2MSecurity::ServerPublicKey == resource  ||
00257            M2MSecurity::Secretkey == resource) {
00258             res->get_value(data,size);
00259         }
00260     }
00261     return size;
00262 }
00263 
00264 
00265 uint32_t M2MSecurity::resource_value_int(SecurityResource resource) const
00266 {
00267     uint32_t value = 0;
00268     M2MResource* res = get_resource(resource);
00269     if(res) {
00270         if(M2MSecurity::SecurityMode == resource        ||
00271            M2MSecurity::SMSSecurityMode == resource     ||
00272            M2MSecurity::M2MServerSMSNumber == resource  ||
00273            M2MSecurity::ShortServerID == resource       ||
00274            M2MSecurity::ClientHoldOffTime == resource) {
00275             // Get the value and convert it into integer
00276             uint8_t* buffer = NULL;
00277             uint32_t length = 0;
00278             res->get_value(buffer,length);
00279             if(buffer) {
00280                 value = atoi((const char*)buffer);
00281                 free(buffer);
00282             }
00283         }
00284     }
00285     return value;
00286 }
00287 
00288 bool M2MSecurity::is_resource_present(SecurityResource resource) const
00289 {
00290     bool success = false;
00291     M2MResource *res = get_resource(resource);
00292     if(res) {
00293         success = true;
00294     }
00295     return success;
00296 }
00297 
00298 uint16_t M2MSecurity::total_resource_count() const
00299 {
00300     uint16_t count = 0;
00301     if(_server_instance) {
00302         count = _server_instance->resources().size();
00303     }
00304     return count;
00305 }
00306 
00307 M2MSecurity::ServerType M2MSecurity::server_type() const
00308 {
00309     return _server_type;
00310 }
00311 
00312 M2MResource* M2MSecurity::get_resource(SecurityResource res) const
00313 {
00314     M2MResource* res_object = NULL;
00315     if(_server_instance) {
00316         String res_name = "";
00317         switch(res) {
00318             case M2MServerUri:
00319                 res_name = SECURITY_M2M_SERVER_URI;
00320                 break;
00321             case BootstrapServer:
00322                 res_name = SECURITY_BOOTSTRAP_SERVER;
00323                 break;
00324             case SecurityMode:
00325                 res_name = SECURITY_SECURITY_MODE;
00326                 break;
00327             case PublicKey:
00328                 res_name = SECURITY_PUBLIC_KEY;
00329                 break;
00330             case ServerPublicKey:
00331                 res_name = SECURITY_SERVER_PUBLIC_KEY;
00332                 break;
00333             case Secretkey:
00334                 res_name = SECURITY_SECRET_KEY;
00335                 break;
00336             case SMSSecurityMode:
00337                 res_name = SECURITY_SMS_SECURITY_MODE;
00338                 break;
00339             case SMSBindingKey:
00340                 res_name = SECURITY_SMS_BINDING_KEY;
00341                 break;
00342             case SMSBindingSecretKey:
00343                 res_name = SECURITY_SMS_BINDING_SECRET_KEY;
00344                 break;
00345             case M2MServerSMSNumber:
00346                 res_name = SECURITY_M2M_SERVER_SMS_NUMBER;
00347                 break;
00348             case ShortServerID:
00349                 res_name = SECURITY_SHORT_SERVER_ID;
00350                 break;
00351             case ClientHoldOffTime:
00352                 res_name = SECURITY_CLIENT_HOLD_OFF_TIME;
00353                 break;
00354         }
00355         res_object = _server_instance->resource(res_name);
00356     }
00357     return res_object;
00358 }