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