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