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