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 extern "C" {
  23 #include "logger.h"
  24 #include "ocpayload.h"
  25 #include "ocstack.h"
  26 #include "oic_malloc.h"
  27 #include "oic_string.h"
  28 #include "resourcemanager.h"
  29 #include "credresource.h"
  30 #include "securevirtualresourcetypes.h"
  31 #include "srmtestcommon.h"
  32 #include "srmutility.h"
  33 #include "psinterface.h"
  34 #include "security_internals.h"
  35 #include "secureresourcemanager.h"
  36 }
  37 #define TAG "SRM-CRED-UT"
  38
  39 const char *SRP_TEST_FILE_NAME = "secureresourceprovider.dat";
  40 static OCPersistentStorage ps;
  41
  42 OicSecCred_t * getCredList()
  43 {
  44     size_t sz = 0;
  45     OicSecCred_t *cred = (OicSecCred_t *)OICCalloc(1, sizeof(*cred));
  46     VERIFY_NON_NULL(TAG, cred, ERROR);
  47     cred->credId = 1234;
  48     // use |memcpy| for copying full-lengthed UUID without null termination
  49     memcpy(cred->subject.id, "1111111111111111", sizeof(cred->subject.id));
  50
  51 #if 0
  52     cred->roleIdsLen = 2;
  53     cred->roleIds = (OicSecRole_t *)OICCalloc(cred->roleIdsLen, sizeof(OicSecRole_t));
  54     VERIFY_NON_NULL(TAG, cred->roleIds, ERROR);
  55     OICStrcpy((char *)cred->roleIds[0].id, sizeof(cred->roleIds[0].id), "role11");
  56     OICStrcpy((char *)cred->roleIds[1].id, sizeof(cred->roleIds[1].id), "role12");
  57 #endif
  58
  59     cred->credType = SYMMETRIC_PAIR_WISE_KEY;
  60     cred->privateData.encoding = OIC_ENCODING_RAW;
  61     cred->privateData.data = (uint8_t *)OICCalloc(1, strlen("My private Key11") + 1);
  62     cred->privateData.len = strlen("My private Key11");
  63     VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
  64     OICStrcpy((char *)cred->privateData.data, strlen("My private Key11")+1,"My private Key11");
  65     // use |memcpy| for copying full-lengthed UUID without null termination
  66     memcpy(cred->rownerID.id, "aaaaaaaaaaaaaaaa", sizeof(cred->rownerID.id));
  67     cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(*cred->next));
  68     VERIFY_NON_NULL(TAG, cred->next, ERROR);
  69     cred->next->credId = 5678;
  70     // use |memcpy| for copying full-lengthed UUID without null termination
  71     memcpy(cred->next->subject.id, "2222222222222222", sizeof(cred->next->subject.id));
  72 #if 0
  73     cred->next->roleIdsLen = 0;
  74 #endif
  75     cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
  76     cred->next->privateData.encoding = OIC_ENCODING_RAW;
  77     cred->next->privateData.len = strlen("My private Key21");
  78     sz = cred->next->privateData.len + 1;
  79     cred->next->privateData.data = (uint8_t *)OICCalloc(1, sz);
  80     VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
  81     OICStrcpy((char *)cred->next->privateData.data, sz, "My private Key21");
  82 #if 0
  83     sz = strlen("My Public Key123") + 1;
  84     cred->next->publicData.data = (char *)OICCalloc(1, sz);
  85     VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
  86     OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
  87 #endif
  88     // use |memcpy| for copying full-lengthed UUID without null termination
  89     memcpy(cred->next->rownerID.id, "bbbbbbbbbbbbbbbb", sizeof(cred->next->rownerID.id));
  90
  91     return cred;
  92
  93 exit:
  94     if(cred)
  95     {
  96         DeleteCredList(cred);
  97         cred = NULL;
  98     }
  99     return cred;
 100 }
 101
 102 static void printCred(const OicSecCred_t * cred)
 103 {
 104     EXPECT_TRUE(NULL != cred);
 105
 106     const OicSecCred_t *credTmp1 = NULL;
 107     for (credTmp1 = cred; credTmp1; credTmp1 = credTmp1->next)
 108     {
 109         OIC_LOG_V(INFO, TAG, "\ncred->credId = %d", credTmp1->credId);
 110         OIC_LOG_V(INFO, TAG, "cred->subject.id = %s", credTmp1->subject.id);
 111         OIC_LOG_V(INFO, TAG, "cred->credType = %d", credTmp1->credType);
 112         if(credTmp1->privateData.data)
 113         {
 114             OIC_LOG_V(INFO, TAG, "cred->privateData.data = %s", credTmp1->privateData.data);
 115         }
 116 #ifdef __WITH_DTLS__
 117         if(credTmp1->publicData.data)
 118         {
 119            OIC_LOG_V(INFO, TAG, "cred->publicData.data = %s", credTmp1->publicData.data);
 120         }
 121 #endif /* __WITH_DTLS__ */
 122     OIC_LOG_V(INFO, TAG, "cred->rownerID = %s", credTmp1->rownerID.id);
 123     }
 124 }
 125
 126 FILE *fOpenCustom(const char *path, const char *mode)
 127 {
 128     (void)path;
 129     FILE *fp = fopen(SRP_TEST_FILE_NAME, mode);
 130     return fp;
 131 }
 132
 133 //init db
 134 TEST(CredResourceTest,initDb)
 135 {
 136     ps.open = fOpenCustom;
 137     ps.read = fread;
 138     ps.write = fwrite;
 139     ps.close = fclose;
 140     ps.unlink = unlink;
 141
 142     SRMRegisterPersistentStorageHandler(&ps);
 143
 144     InitPersistentStorageInterface();
 145 }
 146
 147  //InitCredResource Tests
 148 TEST(CredResourceTest, InitCredResource)
 149 {
 150     EXPECT_EQ(OC_STACK_INVALID_PARAM, InitCredResource());
 151 }
 152
 153 //DeInitCredResource Tests
 154 TEST(CredResourceTest, DeInitCredResource)
 155 {
 156     EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitCredResource());
 157 }
 158
 159 //CreateCredResource Tests
 160 TEST(CredResourceTest, CreateCredResource)
 161 {
 162     EXPECT_EQ(OC_STACK_INVALID_PARAM, CreateCredResource());
 163 }
 164
 165  //CredEntityHandler Tests
 166 TEST(CredResourceTest, CredEntityHandlerWithDummyRequest)
 167 {
 168     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 169     EXPECT_EQ(OC_EH_ERROR,
 170             CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
 171 }
 172
 173 TEST(CredResourceTest, CredEntityHandlerWithNULLRequest)
 174 {
 175     EXPECT_EQ(OC_EH_ERROR,
 176             CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, NULL, NULL));
 177 }
 178
 179 TEST(CredResourceTest, CredEntityHandlerInvalidFlag)
 180 {
 181     OCEntityHandlerRequest req = OCEntityHandlerRequest();
 182     EXPECT_EQ(OC_EH_ERROR,
 183             CredEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, &req, NULL));
 184 }
 185
 186 //Cred DELETE request
 187 /*
 188 TEST(CredResourceTest, CredEntityHandlerDeleteTest)
 189 {
 190     OCEntityHandlerRequest ehReq =  OCEntityHandlerRequest();
 191     const OicSecCred_t* subjectCred1 = NULL;
 192     const OicSecCred_t* subjectCred2 = NULL;
 193     OCEntityHandlerResult ehRet = OC_EH_ERROR;
 194     char query[] = "subjectuuid=31313131-3131-3131-3131-313131313131"; //canonical uuid of subject1
 195
 196     OicSecCred_t *cred = getCredList();
 197     ASSERT_TRUE(NULL != cred);
 198     uint8_t *payload = NULL;
 199     size_t size = 0;
 200     int secureFlag = 0;
 201     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size, secureFlag));
 202     if (!payload)
 203     {
 204         DeleteCredList(cred);
 205     }
 206     ASSERT_TRUE(NULL != payload);
 207
 208     // Create Entity Handler POST request payload
 209     ehReq.method = OC_REST_POST;
 210     ehReq.payload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
 211     if (!ehReq.payload)
 212     {
 213         OICFree(payload);
 214         DeleteCredList(cred);
 215     }
 216     ASSERT_TRUE( NULL != ehReq.payload);
 217     EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
 218
 219     // Verify if SRM contains Credential for the subject
 220     subjectCred1 = GetCredResourceData(&cred->subject);
 221     EXPECT_TRUE(NULL != subjectCred1);
 222
 223     // Create Entity Handler DELETE request
 224     ehReq.method = OC_REST_DELETE;
 225     ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
 226     if (!ehReq.query)
 227     {
 228         OICFree(payload);
 229         DeleteCredList(cred);
 230     }
 231     ASSERT_TRUE(NULL != ehReq.query);
 232     OICStrcpy(ehReq.query, strlen(query)+1, query);
 233
 234     ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
 235     EXPECT_EQ(OC_EH_ERROR, ehRet);
 236
 237     // Verify if SRM has deleted ACE for the subject
 238     subjectCred2 = GetCredResourceData(&cred->subject);
 239     EXPECT_TRUE(NULL == subjectCred2);
 240
 241     // Perform cleanup
 242     OICFree(ehReq.query);
 243     OICFree(payload);
 244     DeInitCredResource();
 245     DeleteCredList(cred);
 246     OCPayloadDestroy((OCPayload *)ehReq.payload);
 247 }
 248 */
 249
 250 TEST(CredResourceTest, CredToCBORPayloadNULL)
 251 {
 252     int secureFlag = 0;
 253     OicSecCred_t *cred = getCredList();
 254     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, NULL, 0, secureFlag));
 255     size_t size = 0;
 256     uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
 257     if (!cborPayload)
 258     {
 259         DeleteCredList(cred);
 260     }
 261     ASSERT_TRUE(NULL != cborPayload);
 262     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, &size, secureFlag));
 263     OICFree(cborPayload);
 264     cborPayload = NULL;
 265     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, &cborPayload, &size,secureFlag));
 266     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, 0, secureFlag));
 267     EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, NULL, &size, secureFlag));
 268     DeleteCredList(cred);
 269 }
 270
 271 TEST(CredResourceTest, CredToCBORPayloadVALID)
 272 {
 273     uint8_t* payload = NULL;
 274     size_t size = 0;
 275     int secureFlag = 0;
 276     OicSecCred_t *cred = getCredList();
 277
 278     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size, secureFlag));
 279     if (!payload)
 280     {
 281         DeleteCredList(cred);
 282     }
 283     ASSERT_TRUE(NULL != payload);
 284
 285     DeleteCredList(cred);
 286     OICFree(payload);
 287 }
 288
 289 TEST(CredResourceTest, CBORPayloadToCredVALID)
 290 {
 291     OicSecCred_t *cred1 = getCredList();
 292
 293     uint8_t *payload = NULL;
 294     size_t size = 0;
 295     int secureFlag = 0;
 296     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size, secureFlag));
 297     DeleteCredList(cred1);
 298     ASSERT_TRUE(NULL != payload);
 299
 300     OicSecCred_t *cred2 = NULL;
 301     EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
 302     OICFree(payload);
 303     ASSERT_TRUE(cred2 != NULL);
 304     DeleteCredList(cred2);
 305 }
 306
 307 TEST(CredResourceTest, CBORPayloadToCredSecureVALID)
 308 {
 309     OicSecCred_t *cred1 = getCredList();
 310     ASSERT_TRUE(NULL != cred1);
 311     cred1->privateData.data = (uint8_t *)OICCalloc(1, OWNER_PSK_LENGTH_128);
 312     ASSERT_TRUE(NULL != cred1->privateData.data);
 313     cred1->privateData.len = OWNER_PSK_LENGTH_128;
 314
 315     uint8_t *payload = NULL;
 316     size_t size = 0;
 317     int secureFlag = 1;
 318     EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size, secureFlag));
 319
 320     ASSERT_TRUE(NULL != payload);
 321
 322     OicSecCred_t *cred2 = NULL;
 323     EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
 324     ASSERT_TRUE(cred2 != NULL);
 325     ASSERT_TRUE(NULL == cred2->privateData.data);
 326     ASSERT_TRUE(0 == cred2->privateData.len);
 327
 328     OICFree(payload);
 329
 330     DeleteCredList(cred1);
 331     DeleteCredList(cred2);
 332 }
 333
 334 TEST(CredResourceTest, CBORPayloadToCredNULL)
 335 {
 336     OicSecCred_t *cred = NULL;
 337     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
 338     uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
 339     ASSERT_TRUE(NULL != cborPayload);
 340     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred));
 341     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL));
 342     cred = getCredList();
 343     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
 344     DeleteCredList(cred);
 345     OICFree(cborPayload);
 346 }
 347
 348 //GetCredResourceData Test
 349 TEST(CredResourceTest, GetCredResourceDataNULLSubject)
 350 {
 351     EXPECT_EQ(NULL, GetCredResourceData(NULL));
 352 }
 353
 354 TEST(CredResourceTest, GenerateCredentialValidInput)
 355 {
 356     OicUuid_t rownerID = {{0}};
 357     OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId21");
 358
 359     OicUuid_t subject = {{0}};
 360     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
 361
 362     uint8_t privateKey[] = "My private Key11";
 363     OicSecKey_t key = {privateKey, sizeof(privateKey)};
 364
 365     OicSecCred_t * cred  = NULL;
 366     cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 367                               &key, &rownerID, NULL);
 368     printCred(cred);
 369
 370     ASSERT_TRUE(NULL != cred);
 371     DeleteCredList(cred);
 372 }
 373
 374 /*
 375 TEST(CredResourceTest, GenerateAndAddCredentialValidInput)
 376 {
 377     OicUuid_t rownerID = {{0}};
 378     OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId11");
 379
 380     OicUuid_t subject = {{0}};
 381     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
 382
 383     uint8_t privateKey[] = "My private Key11";
 384     OicSecKey_t key = {privateKey, sizeof(privateKey)};
 385
 386     OicSecCred_t *cred1  = NULL;
 387     OicSecCred_t *headCred = NULL;
 388
 389     cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 390                                &key, &rownerID, NULL);
 391
 392     EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
 393     headCred = cred1;
 394
 395     OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId22");
 396     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
 397     cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 398                                &key, &rownerID, NULL);
 399     EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
 400
 401     OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId33");
 402     OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
 403     cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
 404                                &key, &rownerID, NULL);
 405     EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
 406
 407     const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
 408
 409     printCred(credList);
 410
 411     DeleteCredList(headCred);
 412 }
 413 */
 414
 415 #if 0
 416 TEST(CredGetResourceDataTest, GetCredResourceDataValidSubject)
 417 {
 418     OicSecCred_t* cred = getCredList();
 419     EXPECT_TRUE(NULL != GetCredResourceData(cred->subject));
 420 }
 421 #endif
 422
 423 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 424 TEST(CredGetDtlsPskCredentialsTest, NullResult)
 425 {
 426     EXPECT_EQ(-1, GetDtlsPskCredentials(CA_DTLS_PSK_KEY, NULL, 0, NULL, 0));
 427 }
 428
 429 TEST(CredAddTmpPskWithPINTest, NullSubject)
 430 {
 431     EXPECT_EQ(OC_STACK_INVALID_PARAM, AddTmpPskWithPIN(NULL, SYMMETRIC_PAIR_WISE_KEY,
 432               NULL, 0, NULL, NULL));
 433 }
 434 #endif // __WITH_DTLS__ or __WITH_TLS__
 435 TEST(CredCBORPayloadToCredTest, NullPayload)
 436 {
 437     EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
 438 }