test_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 "CppUTest/TestHarness.h"
00017 #include "test_m2msecurity.h"
00018 #include "m2mobject_stub.h"
00019 #include "m2mobjectinstance_stub.h"
00020 #include "m2mresource_stub.h"
00021 #include "m2mresourceinstance_stub.h"
00022 #include "m2mbase_stub.h"
00023 #include "nsdlaccesshelper_stub.h"
00024 
00025 Test_M2MSecurity::Test_M2MSecurity()
00026 {
00027     M2MObject* obj = new M2MObject("name", "name");
00028     m2mobject_stub::inst = new M2MObjectInstance(*obj,"name","type", "name");
00029     m2mresource_stub::bool_value = true;
00030     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00031                                                               "name",
00032                                                               "type",
00033                                                               M2MResourceInstance::STRING,
00034                                                               false,
00035                                                               "name");
00036     security = new M2MSecurity(M2MSecurity::Bootstrap);
00037 
00038     delete m2mobjectinstance_stub::create_resource;
00039     m2mobjectinstance_stub::create_resource = NULL;
00040 
00041     delete obj;
00042 }
00043 
00044 Test_M2MSecurity::~Test_M2MSecurity()
00045 {
00046     delete m2mobject_stub::inst;
00047     m2mobject_stub::inst = NULL;
00048     m2mobject_stub::clear();
00049     m2mobjectinstance_stub::clear();
00050     m2mresource_stub::clear();
00051     m2mbase_stub::clear();
00052     delete security;
00053 }
00054 
00055 void Test_M2MSecurity::test_create_resource_int()
00056 {
00057     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00058                                                               "name",
00059                                                               "type",
00060                                                               M2MResourceInstance::STRING,
00061                                                               false,
00062                                                               "name");
00063 
00064     CHECK(security->create_resource(M2MSecurity::M2MServerUri,10) == NULL);
00065     CHECK(security->create_resource(M2MSecurity::BootstrapServer,10) == NULL);
00066     CHECK(security->create_resource(M2MSecurity::SecurityMode,10) == NULL);
00067     CHECK(security->create_resource(M2MSecurity::PublicKey,10) == NULL);
00068     CHECK(security->create_resource(M2MSecurity::ServerPublicKey,10) == NULL);
00069     CHECK(security->create_resource(M2MSecurity::Secretkey,10) == NULL);
00070     CHECK(security->create_resource(M2MSecurity::SMSBindingKey,10) == NULL);
00071     CHECK(security->create_resource(M2MSecurity::SMSBindingSecretKey,10) == NULL);
00072 
00073     CHECK(security->create_resource(M2MSecurity::M2MServerSMSNumber,10) != NULL);
00074     CHECK(security->create_resource(M2MSecurity::ShortServerID,10) != NULL);
00075     CHECK(security->create_resource(M2MSecurity::ClientHoldOffTime,10) != NULL);
00076     CHECK(security->create_resource(M2MSecurity::SMSSecurityMode,10) != NULL);
00077 
00078     delete m2mobjectinstance_stub::create_resource;
00079     m2mobjectinstance_stub::create_resource = NULL;
00080 }
00081 
00082 void Test_M2MSecurity::test_delete_resource()
00083 {
00084     m2mresourceinstance_stub::bool_value = true;
00085     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00086                                                       "name",
00087                                                       "type",
00088                                                       M2MResourceInstance::STRING,
00089                                                       false,
00090                                                       "name");
00091 
00092     CHECK(security->delete_resource(M2MSecurity::SMSBindingSecretKey) == false);
00093     CHECK(security->delete_resource(M2MSecurity::SMSBindingKey) == false);
00094     CHECK(security->delete_resource(M2MSecurity::M2MServerUri) == false);
00095     CHECK(security->delete_resource(M2MSecurity::Secretkey) == false);
00096     CHECK(security->delete_resource(M2MSecurity::ServerPublicKey) == false);
00097     CHECK(security->delete_resource(M2MSecurity::BootstrapServer) == false);
00098     CHECK(security->delete_resource(M2MSecurity::PublicKey) == false);
00099     CHECK(security->delete_resource(M2MSecurity::SecurityMode) == false);
00100 
00101     m2mobjectinstance_stub::bool_value = true;
00102 
00103     CHECK(security->delete_resource(M2MSecurity::M2MServerSMSNumber) == true);
00104     CHECK(security->delete_resource(M2MSecurity::ShortServerID) == true);
00105     CHECK(security->delete_resource(M2MSecurity::ClientHoldOffTime) == true);
00106     CHECK(security->delete_resource(M2MSecurity::SMSSecurityMode) == true);
00107 
00108     delete m2mobjectinstance_stub::resource;
00109     m2mobjectinstance_stub::resource = NULL;
00110 }
00111 
00112 void Test_M2MSecurity::test_set_resource_value_string()
00113 {
00114     m2mresourceinstance_stub::bool_value = true;
00115     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00116                                                        "name",
00117                                                        "type",
00118                                                        M2MResourceInstance::STRING,
00119                                                        false,
00120                                                        "name");
00121 
00122     CHECK(security->set_resource_value(M2MSecurity::M2MServerUri,"test") == true);
00123 
00124     CHECK(security->set_resource_value(M2MSecurity::M2MServerSMSNumber,"test") == false);
00125     CHECK(security->set_resource_value(M2MSecurity::ShortServerID,"test") == false);
00126     CHECK(security->set_resource_value(M2MSecurity::SMSBindingKey,"test") == false);
00127     CHECK(security->set_resource_value(M2MSecurity::SMSBindingSecretKey,"test") == false);
00128     CHECK(security->set_resource_value(M2MSecurity::ClientHoldOffTime,"test") == false);
00129     CHECK(security->set_resource_value(M2MSecurity::SMSSecurityMode,"test") == false);
00130     CHECK(security->set_resource_value(M2MSecurity::Secretkey,"test") == false);
00131     CHECK(security->set_resource_value(M2MSecurity::ServerPublicKey,"test") == false);
00132     CHECK(security->set_resource_value(M2MSecurity::PublicKey,"test") == false);
00133     CHECK(security->set_resource_value(M2MSecurity::BootstrapServer,"test") == false);
00134     CHECK(security->set_resource_value(M2MSecurity::SecurityMode,"test") == false);
00135 
00136     delete m2mobjectinstance_stub::resource;
00137     m2mobjectinstance_stub::resource = NULL;
00138 }
00139 
00140 void Test_M2MSecurity::test_set_resource_value_int()
00141 {
00142     m2mresourceinstance_stub::bool_value = true;
00143     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00144                                                        "name",
00145                                                        "type",
00146                                                        M2MResourceInstance::STRING,
00147                                                        false,
00148                                                        "name");
00149 
00150     CHECK(security->set_resource_value(M2MSecurity::M2MServerUri,10) == false);
00151     CHECK(security->set_resource_value(M2MSecurity::SMSBindingKey,10) == false);
00152     CHECK(security->set_resource_value(M2MSecurity::SMSBindingSecretKey,10) == false);
00153     CHECK(security->set_resource_value(M2MSecurity::Secretkey,10) == false);
00154     CHECK(security->set_resource_value(M2MSecurity::ServerPublicKey,10) == false);
00155     CHECK(security->set_resource_value(M2MSecurity::PublicKey,10) == false);
00156     CHECK(security->set_resource_value(M2MSecurity::BootstrapServer,10) == false);
00157 
00158     CHECK(security->set_resource_value(M2MSecurity::SecurityMode,10) == true);
00159     CHECK(security->set_resource_value(M2MSecurity::SMSSecurityMode,10) == true);
00160     CHECK(security->set_resource_value(M2MSecurity::M2MServerSMSNumber,10) == true);
00161     CHECK(security->set_resource_value(M2MSecurity::ShortServerID,10) == true);
00162     CHECK(security->set_resource_value(M2MSecurity::ClientHoldOffTime,10) == true);
00163 
00164     delete m2mobjectinstance_stub::resource;
00165     m2mobjectinstance_stub::resource = NULL;
00166 }
00167 
00168 void Test_M2MSecurity::test_set_resource_value_buffer()
00169 {
00170     m2mresourceinstance_stub::bool_value = true;
00171 
00172     uint8_t value[] = {"value"};
00173     uint16_t length = (uint16_t)sizeof(value);
00174 
00175     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00176                                                        "name",
00177                                                        "type",
00178                                                        M2MResourceInstance::STRING,
00179                                                        false,
00180                                                        "name");
00181 
00182     CHECK(security->set_resource_value(M2MSecurity::Secretkey,value,length) == true);
00183     CHECK(security->set_resource_value(M2MSecurity::ServerPublicKey,value,length) == true);
00184     CHECK(security->set_resource_value(M2MSecurity::PublicKey,value,length) == true);
00185 
00186     CHECK(security->set_resource_value(M2MSecurity::M2MServerUri,value,length) == false);
00187     CHECK(security->set_resource_value(M2MSecurity::SMSBindingKey,value,length) == false);
00188     CHECK(security->set_resource_value(M2MSecurity::SMSBindingSecretKey,value,length) == false);
00189     CHECK(security->set_resource_value(M2MSecurity::BootstrapServer,value,length) == false);
00190 
00191     CHECK(security->set_resource_value(M2MSecurity::SecurityMode,value,length) == false);
00192     CHECK(security->set_resource_value(M2MSecurity::SMSSecurityMode,value,length) == false);
00193     CHECK(security->set_resource_value(M2MSecurity::M2MServerSMSNumber,value,length) == false);
00194     CHECK(security->set_resource_value(M2MSecurity::ShortServerID,value,length) == false);
00195     CHECK(security->set_resource_value(M2MSecurity::ClientHoldOffTime,value,length) == false);
00196 
00197     delete m2mobjectinstance_stub::resource;
00198     m2mobjectinstance_stub::resource = NULL;
00199 }
00200 
00201 void Test_M2MSecurity::test_resource_value_int()
00202 {
00203     m2mresourceinstance_stub::bool_value = true;
00204 
00205     uint8_t value[] = {"10"};
00206     //m2mresourceinstance_stub::value = (uint8_t*)malloc((uint32_t)sizeof(value));
00207     uint8_t size = 0;
00208     m2mresourceinstance_stub::value = String::convert_integer_to_array(10,size);
00209     /*memset(m2mresourceinstance_stub::value,0,(uint32_t)size);
00210     memcpy(m2mresourceinstance_stub::value, 10, size);*/
00211     m2mresourceinstance_stub::int_value = (uint16_t)size;
00212 
00213     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00214                                                        "name",
00215                                                        "type",
00216                                                        M2MResourceInstance::STRING,
00217                                                        false,
00218                                                        "name");
00219 
00220     CHECK(security->resource_value_int(M2MSecurity::SecurityMode) == 10);
00221     CHECK(security->resource_value_int(M2MSecurity::SMSSecurityMode) == 10);
00222     CHECK(security->resource_value_int(M2MSecurity::M2MServerSMSNumber) == 10);
00223     CHECK(security->resource_value_int(M2MSecurity::ShortServerID) == 10);
00224     CHECK(security->resource_value_int(M2MSecurity::ClientHoldOffTime) == 10);
00225     CHECK(security->resource_value_int(M2MSecurity::BootstrapServer) == 0);
00226     CHECK(security->resource_value_int(M2MSecurity::PublicKey) == 0);
00227     CHECK(security->resource_value_int(M2MSecurity::ServerPublicKey) == 0);
00228     CHECK(security->resource_value_int(M2MSecurity::Secretkey) == 0);
00229     CHECK(security->resource_value_int(M2MSecurity::SMSBindingSecretKey) == 0);
00230     CHECK(security->resource_value_int(M2MSecurity::SMSBindingKey) == 0);
00231     CHECK(security->resource_value_int(M2MSecurity::M2MServerUri) == 0);
00232 
00233     security->clear_resources();
00234     CHECK(security->resource_value_int(M2MSecurity::SecurityMode) == 0);
00235     CHECK(security->resource_value_int(M2MSecurity::SMSSecurityMode) == 0);
00236     CHECK(security->resource_value_int(M2MSecurity::M2MServerSMSNumber) == 0);
00237     CHECK(security->resource_value_int(M2MSecurity::ShortServerID) == 0);
00238     CHECK(security->resource_value_int(M2MSecurity::ClientHoldOffTime) == 0);
00239     CHECK(security->resource_value_int(M2MSecurity::BootstrapServer) == 0);
00240     CHECK(security->resource_value_int(M2MSecurity::PublicKey) == 0);
00241     CHECK(security->resource_value_int(M2MSecurity::ServerPublicKey) == 0);
00242     CHECK(security->resource_value_int(M2MSecurity::Secretkey) == 0);
00243     CHECK(security->resource_value_int(M2MSecurity::SMSBindingSecretKey) == 0);
00244     CHECK(security->resource_value_int(M2MSecurity::SMSBindingKey) == 0);
00245     CHECK(security->resource_value_int(M2MSecurity::M2MServerUri) == 0);
00246 
00247     delete m2mobjectinstance_stub::resource;
00248     m2mobjectinstance_stub::resource = NULL;
00249 
00250     free(m2mresourceinstance_stub::value);
00251     m2mresourceinstance_stub::value = NULL;
00252 }
00253 
00254 void Test_M2MSecurity::test_resource_value_string()
00255 {
00256     m2mresourceinstance_stub::bool_value = true;
00257     String test = "string";
00258     uint8_t value[] = {"string"};
00259     m2mresourceinstance_stub::value = (uint8_t*)malloc((uint32_t)sizeof(value));
00260     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00261     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
00262     m2mresourceinstance_stub::int_value = (uint16_t)sizeof(value);
00263 
00264     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00265                                                        "name",
00266                                                        "type",
00267                                                        M2MResourceInstance::STRING,
00268                                                        false,
00269                                                        "name");
00270 
00271     CHECK(security->resource_value_string(M2MSecurity::M2MServerUri) == test);
00272 
00273     CHECK(security->resource_value_string(M2MSecurity::SMSBindingKey) == "");
00274     CHECK(security->resource_value_string(M2MSecurity::SMSBindingSecretKey) == "");
00275     CHECK(security->resource_value_string(M2MSecurity::Secretkey) == "");
00276     CHECK(security->resource_value_string(M2MSecurity::ServerPublicKey) == "");
00277     CHECK(security->resource_value_string(M2MSecurity::PublicKey) == "");
00278     CHECK(security->resource_value_string(M2MSecurity::BootstrapServer) == "");
00279     CHECK(security->resource_value_string(M2MSecurity::ClientHoldOffTime) == "");
00280     CHECK(security->resource_value_string(M2MSecurity::ShortServerID) == "");
00281     CHECK(security->resource_value_string(M2MSecurity::M2MServerSMSNumber) == "");
00282     CHECK(security->resource_value_string(M2MSecurity::SMSSecurityMode) == "");
00283     CHECK(security->resource_value_string(M2MSecurity::SecurityMode) == "");
00284 
00285     delete m2mobjectinstance_stub::resource;
00286     m2mobjectinstance_stub::resource = NULL;
00287 
00288     free(m2mresourceinstance_stub::value);
00289     m2mresourceinstance_stub::value = NULL;
00290 }
00291 
00292 void Test_M2MSecurity::test_resource_value_buffer()
00293 {
00294     m2mresourceinstance_stub::bool_value = true;
00295 
00296     uint8_t value[] = {"buffer"};
00297     uint8_t *out_value = NULL;
00298 
00299     m2mresourceinstance_stub::value = (uint8_t*)malloc((uint32_t)sizeof(value));
00300     memset(m2mresourceinstance_stub::value,0,(uint32_t)sizeof(value));
00301     memcpy(m2mresourceinstance_stub::value,value,sizeof(value));
00302     m2mresourceinstance_stub::int_value = (uint16_t)sizeof(value);
00303 
00304     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00305                                                        "name",
00306                                                        "type",
00307                                                        M2MResourceInstance::STRING,
00308                                                        false,
00309                                                        "name");
00310 
00311     CHECK(security->resource_value_buffer(M2MSecurity::Secretkey,out_value) != 0);
00312     CHECK(security->resource_value_buffer(M2MSecurity::ServerPublicKey,out_value) != 0);
00313     CHECK(security->resource_value_buffer(M2MSecurity::PublicKey,out_value) != 0);
00314 
00315     CHECK(security->resource_value_buffer(M2MSecurity::M2MServerUri,out_value) == 0);
00316 
00317     CHECK(security->resource_value_buffer(M2MSecurity::SMSBindingKey,out_value) == 0);
00318     CHECK(security->resource_value_buffer(M2MSecurity::SMSBindingSecretKey,out_value) == 0);
00319     CHECK(security->resource_value_buffer(M2MSecurity::BootstrapServer,out_value) == 0);
00320     CHECK(security->resource_value_buffer(M2MSecurity::ClientHoldOffTime,out_value) == 0);
00321     CHECK(security->resource_value_buffer(M2MSecurity::ShortServerID,out_value) == 0);
00322     CHECK(security->resource_value_buffer(M2MSecurity::M2MServerSMSNumber,out_value) == 0);
00323     CHECK(security->resource_value_buffer(M2MSecurity::SMSSecurityMode,out_value) == 0);
00324     CHECK(security->resource_value_buffer(M2MSecurity::SecurityMode,out_value) == 0);
00325 
00326     const uint8_t *outvalue = NULL;
00327     CHECK(security->resource_value_buffer(M2MSecurity::Secretkey,outvalue) != 0);
00328     CHECK(security->resource_value_buffer(M2MSecurity::ServerPublicKey,outvalue) != 0);
00329     CHECK(security->resource_value_buffer(M2MSecurity::PublicKey,outvalue) != 0);
00330 
00331     free(out_value);
00332     out_value = NULL;
00333 
00334     delete m2mobjectinstance_stub::resource;
00335     m2mobjectinstance_stub::resource = NULL;
00336 
00337     free(m2mresourceinstance_stub::value);
00338     m2mresourceinstance_stub::value = NULL;
00339 }
00340 
00341 void Test_M2MSecurity::test_is_resource_present()
00342 {
00343     m2mobjectinstance_stub::resource = new M2MResource(*m2mobject_stub::inst,
00344                                                        "name",
00345                                                        "type",
00346                                                        M2MResourceInstance::STRING,
00347                                                        false,
00348                                                        "name");
00349 
00350     CHECK(security->is_resource_present(M2MSecurity::M2MServerUri) == true);
00351 
00352     delete m2mobjectinstance_stub::resource;
00353     m2mobjectinstance_stub::resource = NULL;
00354 
00355     CHECK(security->is_resource_present(M2MSecurity::ClientHoldOffTime) == false);
00356 }
00357 
00358 void Test_M2MSecurity::test_total_resource_count()
00359 {
00360     M2MResource *res = new M2MResource(*m2mobject_stub::inst,
00361                                        "name",
00362                                        "type",
00363                                        M2MResourceInstance::STRING,
00364                                        false,
00365                                        "name");
00366 
00367     m2mobjectinstance_stub::resource_list.push_back(res);
00368     M2MResource *res2 = new M2MResource(*m2mobject_stub::inst,
00369                                         "name",
00370                                         "type",
00371                                         M2MResourceInstance::STRING,
00372                                         false,
00373                                         "name");
00374 
00375     m2mobjectinstance_stub::resource_list.push_back(res2);
00376 
00377     CHECK(security->total_resource_count() == 2);
00378 
00379     m2mobjectinstance_stub::resource_list.clear();
00380 
00381     delete res2;
00382     delete res;
00383 }
00384 
00385 void Test_M2MSecurity::test_m2m_server_constructor()
00386 {
00387     m2mobjectinstance_stub::create_resource = new M2MResource(*m2mobject_stub::inst,
00388                                                               "name",
00389                                                               "type",
00390                                                               M2MResourceInstance::STRING,
00391                                                               false,
00392                                                               "name");
00393 
00394     M2MSecurity* sec = new M2MSecurity(M2MSecurity::M2MServer);
00395     CHECK(M2MSecurity::M2MServer == sec->server_type());
00396 
00397     delete sec;
00398     delete m2mobjectinstance_stub::create_resource;
00399     m2mobjectinstance_stub::create_resource = NULL;
00400 }
00401 
00402 void Test_M2MSecurity::test_server_type()
00403 {
00404     CHECK(M2MSecurity::Bootstrap ==security->server_type());
00405 }