resource/csdk/security/unittest/credentialresource.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 // http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "gtest/gtest.h"
  22 #include "logger.h"
  23 #include "ocpayload.h"
  24 #include "ocstack.h"
  25 #include "oic_malloc.h"
  26 #include "oic_string.h"
  27 #include "resourcemanager.h"
  28 #include "credresource.h"
  29 #include "securevirtualresourcetypes.h"
  30 #include "srmtestcommon.h"
  31 #include "srmutility.h"
  32 #include "psinterface.h"
  33 #include "security_internals.h"
  34
  35 #define TAG "SRM-CRED-UT"
  36
  37 OicSecCred_t * getCredList()
  38 {
  39     size_t sz = 0;
  40     OicSecCred_t *cred = (OicSecCred_t *)OICCalloc(1, sizeof(*cred));
  41     VERIFY_NON_NULL(TAG, cred, ERROR);
  42     cred->credId = 1234;
  43     OICStrcpy((char *)cred->subject.id, sizeof(cred->subject.id)+1, "1111111111111111");
  44
  45 #if 0
  46     cred->roleIdsLen = 2;
  47     cred->roleIds = (OicSecRole_t *)OICCalloc(cred->roleIdsLen, sizeof(OicSecRole_t));
  48     VERIFY_NON_NULL(TAG, cred->roleIds, ERROR);
  49     OICStrcpy((char *)cred->roleIds[0].id, sizeof(cred->roleIds[0].id), "role11");
  50     OICStrcpy((char *)cred->roleIds[1].id, sizeof(cred->roleIds[1].id), "role12");
  51
  52 #endif
  53
  54     cred->credType = SYMMETRIC_PAIR_WISE_KEY;
  55     cred->privateData.data = (uint8_t *)OICCalloc(1, strlen("My private Key11") + 1);
  56     VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
  57     OICStrcpy((char *)cred->privateData.data, strlen("My private Key11")+1,"My private Key11");
  58     cred->ownersLen = 1;
  59     cred->owners = (OicUuid_t *)OICCalloc(cred->ownersLen, sizeof(*cred->owners));
  60     VERIFY_NON_NULL(TAG, cred->owners, ERROR);
  61     OICStrcpy((char *)cred->owners[0].id, sizeof(cred->owners[0].id), "aaaaaaaaaaaaaaaa");
  62     cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(*cred->next));
  63     VERIFY_NON_NULL(TAG, cred->next, ERROR);
  64     cred->next->credId = 5678;
  65     OICStrcpy((char *)cred->next->subject.id, sizeof(cred->next->subject.id)+1, "2222222222222222");
  66 #if 0
  67     cred->next->roleIdsLen = 0;
  68 #endif
  69     cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
  70     sz = strlen("My private Key21") + 1;
  71     cred->next->privateData.data = (uint8_t *)OICCalloc(1, sz);
  72     VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
  73     OICStrcpy((char *)cred->next->privateData.data, sz, "My private Key21");
  74 #if 0
  75     sz = strlen("My Public Key123") + 1
  76     cred->next->publicData.data = (char *)OICCalloc(1, sz);
  77     VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
  78     OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
  79 #endif
  80     cred->next->ownersLen = 2;
  81     cred->next->owners = (OicUuid_t *)OICCalloc(cred->next->ownersLen, sizeof(*cred->next->owners));
  82     VERIFY_NON_NULL(TAG, cred->next->owners, ERROR);
  83     OICStrcpy((char *)cred->next->owners[0].id, sizeof(cred->next->owners[0].id), "bbbbbbbbbbbbbbbb");
  84     OICStrcpy((char *)cred->next->owners[1].id, sizeof(cred->next->owners[1].id), "cccccccccccccccc");
  85
  86     return cred;
  87
  88 exit:
  89     if(cred)
  90     {
  91         DeleteCredList(cred);
  92         cred = NULL;
  93     }
  94     return cred;
  95 }
  96
  97 static void printCred(const OicSecCred_t * cred)
  98 {
  99     EXPECT_TRUE(NULL != cred);
 100
 101     const OicSecCred_t *credTmp1 = NULL;
 102     for (credTmp1 = cred; credTmp1; credTmp1 = credTmp1->next)
 103     {
 104         OIC_LOG_V(INFO, TAG, "\ncred->credId = %d", credTmp1->credId);
 105         OIC_LOG_V(INFO, TAG, "cred->subject.id = %s", credTmp1->subject.id);
 106         OIC_LOG_V(INFO, TAG, "cred->credType = %d", credTmp1->credType);
 107         if(credTmp1->privateData.data)
 108         {
 109             OIC_LOG_V(INFO, TAG, "cred->privateData.data = %s", credTmp1->privateData.data);
 110         }
 111 #ifdef __WITH_X509__
 112         if(credTmp1->publicData.data)
 113         {
 114            OIC_LOG_V(INFO, TAG, "cred->publicData.data = %s", credTmp1->publicData.data);
 115         }
 116 #endif /* __WITH_X509__ */
 117         OIC_LOG_V(INFO, TAG, "cred->ownersLen = %zu", credTmp1->ownersLen);
 118         for(size_t i = 0; i < cred->ownersLen; i++)
 119         {
 120             OIC_LOG_V(INFO, TAG, "cred->owners[%zu].id = %s", i, credTmp1->owners[i].id);
 121         }
 122     }
 123 }
 124
 125  //InitCredResource Tests
 126 TEST(CredResourceTest, InitCredResource)
 127 {
 128     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitCredResource());
 129 }
 130
 131 //DeInitCredResource Tests
 132 TEST(CredResourceTest, DeInitCredResource)
 133 {
 134     EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitCredResource());
 135 }
 136
 137 //CreateCredResource Tests
 138 TEST(CredResourceTest, CreateCredResource)
 139 {
 140     EXPECT_EQ(OC_STACK_INVALID_PARAM, CreateCredResource());
 141 }
 142
 143  //CredEntityHandler Tests
 144 TEST(CredResourceTest, CredEntityHandlerWithDummyRequest)
 145 {
 146     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 147     EXPECT_EQ(OC_EH_ERROR,
 148             CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
 149 }
 150
 151 TEST(CredResourceTest, CredEntityHandlerWithNULLRequest)
 152 {
 153     EXPECT_EQ(OC_EH_ERROR,
 154             CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, NULL, NULL));
 155 }
 156
 157 TEST(CredResourceTest, CredEntityHandlerInvalidFlag)
 158 {
 159     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 160     EXPECT_EQ(OC_EH_ERROR,
 161             CredEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, &req, NULL));
 162 }
 163
 164 //Cred DELETE request
 165 TEST(CredResourceTest, CredEntityHandlerDeleteTest)
 166 {
 167     OCEntityHandlerRequest ehReq =  OCEntityHandlerRequest();
 168     static OCPersistentStorage ps =  OCPersistentStorage();
 169     const OicSecCred_t* subjectCred1 = NULL;
 170     const OicSecCred_t* subjectCred2 = NULL;
 171     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 172     char query[] = "subjectuuid=31313131-3131-3131-3131-313131313131"; //canonical uuid of subject1
 173
 174     SetPersistentHandler(&ps, true);
 175
 176     OicSecCred_t *cred = getCredList();
 177     ASSERT_TRUE(NULL != cred);
 178     uint8_t *payload = NULL;
 179     size_t size = 0;
 180     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
 181     if (!payload)
 182     {
 183         DeleteCredList(cred);
 184     }
 185     ASSERT_TRUE(NULL != payload);
 186
 187     // Create Entity Handler POST request payload
 188     ehReq.method = OC_REST_POST;
 189     ehReq.payload = (OCPayload *)OCSecurityPayloadCBORCreate(payload, size);
 190     if (!ehReq.payload)
 191     {
 192         OICFree(payload);
 193         DeleteCredList(cred);
 194     }
 195     ASSERT_TRUE( NULL != ehReq.payload);
 196     EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
 197
 198     // Verify if SRM contains Credential for the subject
 199     subjectCred1 = GetCredResourceData(&cred->subject);
 200     EXPECT_TRUE(NULL != subjectCred1);
 201
 202     // Create Entity Handler DELETE request
 203     ehReq.method = OC_REST_DELETE;
 204     ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
 205     if (!ehReq.query)
 206     {
 207         OICFree(payload);
 208         DeleteCredList(cred);
 209     }
 210     ASSERT_TRUE(NULL != ehReq.query);
 211     OICStrcpy(ehReq.query, strlen(query)+1, query);
 212
 213     ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
 214     EXPECT_EQ(OC_EH_ERROR, ehRet);
 215
 216     // Verify if SRM has deleted ACE for the subject
 217     subjectCred2 = GetCredResourceData(&cred->subject);
 218     EXPECT_TRUE(NULL == subjectCred2);
 219
 220     // Perform cleanup
 221     OICFree(ehReq.query);
 222     OICFree(payload);
 223     DeInitCredResource();
 224     DeleteCredList(cred);
 225     OCPayloadDestroy((OCPayload *)ehReq.payload);
 226 }
 227
 228 TEST(CredResourceTest, CredToCBORPayloadNULL)
 229 {
 230     OicSecCred_t *cred = getCredList();
 231     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, NULL, 0));
 232     size_t size = 0;
 233     uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
 234     if (!cborPayload)
 235     {
 236         DeleteCredList(cred);
 237     }
 238     ASSERT_TRUE(NULL != cborPayload);
 239     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, &size));
 240     OICFree(cborPayload);
 241     cborPayload = NULL;
 242     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, &cborPayload, &size));
 243     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, 0));
 244     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, NULL, &size));
 245     DeleteCredList(cred);
 246 }
 247
 248 TEST(CredResourceTest, CredToCBORPayloadVALID)
 249 {
 250     uint8_t* payload = NULL;
 251     size_t size = 0;
 252     OicSecCred_t *cred = getCredList();
 253
 254     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
 255     if (!payload)
 256     {
 257         DeleteCredList(cred);
 258     }
 259     ASSERT_TRUE(NULL != payload);
 260
 261     DeleteCredList(cred);
 262     OICFree(payload);
 263 }
 264
 265 TEST(CredResourceTest, CBORPayloadToCredVALID)
 266 {
 267     OicSecCred_t *cred1 = getCredList();
 268
 269     uint8_t *payload = NULL;
 270     size_t size = 0;
 271     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size));
 272     DeleteCredList(cred1);
 273     ASSERT_TRUE(NULL != payload);
 274
 275     OicSecCred_t *cred2 = NULL;
 276     EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
 277     OICFree(payload);
 278     ASSERT_TRUE(cred2 != NULL);
 279     DeleteCredList(cred2);
 280 }
 281
 282 TEST(CredResourceTest, CBORPayloadToCredNULL)
 283 {
 284     OicSecCred_t *cred = NULL;
 285     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
 286     uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
 287     ASSERT_TRUE(NULL != cborPayload);
 288     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred));
 289     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL));
 290     cred = getCredList();
 291     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
 292     DeleteCredList(cred);
 293     OICFree(cborPayload);
 294 }
 295
 296 //GetCredResourceData Test
 297 TEST(CredResourceTest, GetCredResourceDataNULLSubject)
 298 {
 299     EXPECT_EQ(NULL, GetCredResourceData(NULL));
 300 }
 301
 302 TEST(CredResourceTest, GenerateCredentialValidInput)
 303 {
 304     OicUuid_t owners[1];
 305     OICStrcpy((char *)owners[0].id, strlen("ownersId21"), "ownersId21");
 306
 307     OicUuid_t subject = {{0}};
 308     OICStrcpy((char *)subject.id, strlen("subject11"), "subject11");
 309
 310     uint8_t privateKey[] = "My private Key11";
 311     OicSecKey_t key = {privateKey, sizeof(privateKey)};
 312
 313     OicSecCred_t * cred  = NULL;
 314
 315     cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 316                               &key, 1, owners);
 317     printCred(cred);
 318
 319     ASSERT_TRUE(NULL != cred);
 320     DeleteCredList(cred);
 321 }
 322
 323 TEST(CredResourceTest, GenerateAndAddCredentialValidInput)
 324 {
 325     OicUuid_t owners[1];
 326     OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId11");
 327
 328     OicUuid_t subject = {{0}};
 329     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
 330
 331     uint8_t privateKey[] = "My private Key11";
 332     OicSecKey_t key = {privateKey, sizeof(privateKey)};
 333
 334     OicSecCred_t *cred1  = NULL;
 335     OicSecCred_t *headCred = NULL;
 336
 337     cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 338                                &key, 1, owners);
 339
 340     EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
 341     headCred = cred1;
 342
 343     OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId22");
 344     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
 345     cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 346                                &key, 1, owners);
 347     EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
 348
 349     OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId33");
 350     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
 351     cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 352                                &key, 1, owners);
 353     EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
 354
 355     const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
 356
 357     printCred(credList);
 358
 359     DeleteCredList(headCred);
 360 }
 361
 362 #if 0
 363 TEST(CredGetResourceDataTest, GetCredResourceDataValidSubject)
 364 {
 365     OicSecCred_t* cred = getCredList();
 366     EXPECT_TRUE(NULL != GetCredResourceData(cred->subject));
 367 }
 368 #endif