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