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