resource/csdk/security/unittest/credentialresource.cpp

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