1 //******************************************************************
3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #include "gtest/gtest.h"
24 #include "ocpayload.h"
26 #include "oic_malloc.h"
27 #include "oic_string.h"
28 #include "resourcemanager.h"
29 #include "credresource.h"
30 #include "securevirtualresourcetypes.h"
31 #include "srmtestcommon.h"
32 #include "srmutility.h"
33 #include "psinterface.h"
34 #include "security_internals.h"
35 #include "secureresourcemanager.h"
37 #define TAG "SRM-CRED-UT"
39 const char *SRP_TEST_FILE_NAME = "secureresourceprovider.dat";
40 static OCPersistentStorage ps;
42 OicSecCred_t * getCredList()
45 OicSecCred_t *cred = (OicSecCred_t *)OICCalloc(1, sizeof(*cred));
46 VERIFY_NON_NULL(TAG, cred, ERROR);
48 // use |memcpy| for copying full-lengthed UUID without null termination
49 memcpy(cred->subject.id, "1111111111111111", sizeof(cred->subject.id));
53 cred->roleIds = (OicSecRole_t *)OICCalloc(cred->roleIdsLen, sizeof(OicSecRole_t));
54 VERIFY_NON_NULL(TAG, cred->roleIds, ERROR);
55 OICStrcpy((char *)cred->roleIds[0].id, sizeof(cred->roleIds[0].id), "role11");
56 OICStrcpy((char *)cred->roleIds[1].id, sizeof(cred->roleIds[1].id), "role12");
59 cred->credType = SYMMETRIC_PAIR_WISE_KEY;
60 cred->privateData.encoding = OIC_ENCODING_RAW;
61 cred->privateData.data = (uint8_t *)OICCalloc(1, strlen("My private Key11") + 1);
62 cred->privateData.len = strlen("My private Key11");
63 VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
64 OICStrcpy((char *)cred->privateData.data, strlen("My private Key11")+1,"My private Key11");
65 // use |memcpy| for copying full-lengthed UUID without null termination
66 memcpy(cred->rownerID.id, "aaaaaaaaaaaaaaaa", sizeof(cred->rownerID.id));
67 cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(*cred->next));
68 VERIFY_NON_NULL(TAG, cred->next, ERROR);
69 cred->next->credId = 5678;
70 // use |memcpy| for copying full-lengthed UUID without null termination
71 memcpy(cred->next->subject.id, "2222222222222222", sizeof(cred->next->subject.id));
73 cred->next->roleIdsLen = 0;
75 cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
76 cred->next->privateData.encoding = OIC_ENCODING_RAW;
77 cred->next->privateData.len = strlen("My private Key21");
78 sz = cred->next->privateData.len + 1;
79 cred->next->privateData.data = (uint8_t *)OICCalloc(1, sz);
80 VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
81 OICStrcpy((char *)cred->next->privateData.data, sz, "My private Key21");
83 sz = strlen("My Public Key123") + 1;
84 cred->next->publicData.data = (char *)OICCalloc(1, sz);
85 VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
86 OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
88 // use |memcpy| for copying full-lengthed UUID without null termination
89 memcpy(cred->next->rownerID.id, "bbbbbbbbbbbbbbbb", sizeof(cred->next->rownerID.id));
102 static void printCred(const OicSecCred_t * cred)
104 EXPECT_TRUE(NULL != cred);
106 const OicSecCred_t *credTmp1 = NULL;
107 for (credTmp1 = cred; credTmp1; credTmp1 = credTmp1->next)
109 OIC_LOG_V(INFO, TAG, "\ncred->credId = %d", credTmp1->credId);
110 OIC_LOG_V(INFO, TAG, "cred->subject.id = %s", credTmp1->subject.id);
111 OIC_LOG_V(INFO, TAG, "cred->credType = %d", credTmp1->credType);
112 if(credTmp1->privateData.data)
114 OIC_LOG_V(INFO, TAG, "cred->privateData.data = %s", credTmp1->privateData.data);
117 if(credTmp1->publicData.data)
119 OIC_LOG_V(INFO, TAG, "cred->publicData.data = %s", credTmp1->publicData.data);
121 #endif /* __WITH_DTLS__ */
122 OIC_LOG_V(INFO, TAG, "cred->rownerID = %s", credTmp1->rownerID.id);
126 FILE *fOpenCustom(const char *path, const char *mode)
129 FILE *fp = fopen(SRP_TEST_FILE_NAME, mode);
134 TEST(CredResourceTest,initDb)
136 ps.open = fOpenCustom;
142 SRMRegisterPersistentStorageHandler(&ps);
144 InitPersistentStorageInterface();
147 //InitCredResource Tests
148 TEST(CredResourceTest, InitCredResource)
150 EXPECT_EQ(OC_STACK_INVALID_PARAM, InitCredResource());
153 //DeInitCredResource Tests
154 TEST(CredResourceTest, DeInitCredResource)
156 EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitCredResource());
159 //CreateCredResource Tests
160 TEST(CredResourceTest, CreateCredResource)
162 EXPECT_EQ(OC_STACK_INVALID_PARAM, CreateCredResource());
165 //CredEntityHandler Tests
166 TEST(CredResourceTest, CredEntityHandlerWithDummyRequest)
168 OCEntityHandlerRequest req = OCEntityHandlerRequest();
169 EXPECT_EQ(OC_EH_ERROR,
170 CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
173 TEST(CredResourceTest, CredEntityHandlerWithNULLRequest)
175 EXPECT_EQ(OC_EH_ERROR,
176 CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, NULL, NULL));
179 TEST(CredResourceTest, CredEntityHandlerInvalidFlag)
181 OCEntityHandlerRequest req = OCEntityHandlerRequest();
182 EXPECT_EQ(OC_EH_ERROR,
183 CredEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, &req, NULL));
186 //Cred DELETE request
188 TEST(CredResourceTest, CredEntityHandlerDeleteTest)
190 OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
191 const OicSecCred_t* subjectCred1 = NULL;
192 const OicSecCred_t* subjectCred2 = NULL;
193 OCEntityHandlerResult ehRet = OC_EH_ERROR;
194 char query[] = "subjectuuid=31313131-3131-3131-3131-313131313131"; //canonical uuid of subject1
196 OicSecCred_t *cred = getCredList();
197 ASSERT_TRUE(NULL != cred);
198 uint8_t *payload = NULL;
201 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size, secureFlag));
204 DeleteCredList(cred);
206 ASSERT_TRUE(NULL != payload);
208 // Create Entity Handler POST request payload
209 ehReq.method = OC_REST_POST;
210 ehReq.payload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
214 DeleteCredList(cred);
216 ASSERT_TRUE( NULL != ehReq.payload);
217 EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
219 // Verify if SRM contains Credential for the subject
220 subjectCred1 = GetCredResourceData(&cred->subject);
221 EXPECT_TRUE(NULL != subjectCred1);
223 // Create Entity Handler DELETE request
224 ehReq.method = OC_REST_DELETE;
225 ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
229 DeleteCredList(cred);
231 ASSERT_TRUE(NULL != ehReq.query);
232 OICStrcpy(ehReq.query, strlen(query)+1, query);
234 ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
235 EXPECT_EQ(OC_EH_ERROR, ehRet);
237 // Verify if SRM has deleted ACE for the subject
238 subjectCred2 = GetCredResourceData(&cred->subject);
239 EXPECT_TRUE(NULL == subjectCred2);
242 OICFree(ehReq.query);
244 DeInitCredResource();
245 DeleteCredList(cred);
246 OCPayloadDestroy((OCPayload *)ehReq.payload);
250 TEST(CredResourceTest, CredToCBORPayloadNULL)
253 OicSecCred_t *cred = getCredList();
254 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, NULL, 0, secureFlag));
256 uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
259 DeleteCredList(cred);
261 ASSERT_TRUE(NULL != cborPayload);
262 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, &size, secureFlag));
263 OICFree(cborPayload);
265 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, &cborPayload, &size,secureFlag));
266 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, 0, secureFlag));
267 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, NULL, &size, secureFlag));
268 DeleteCredList(cred);
271 TEST(CredResourceTest, CredToCBORPayloadVALID)
273 uint8_t* payload = NULL;
276 OicSecCred_t *cred = getCredList();
278 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size, secureFlag));
281 DeleteCredList(cred);
283 ASSERT_TRUE(NULL != payload);
285 DeleteCredList(cred);
289 TEST(CredResourceTest, CBORPayloadToCredVALID)
291 OicSecCred_t *cred1 = getCredList();
293 uint8_t *payload = NULL;
296 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size, secureFlag));
297 DeleteCredList(cred1);
298 ASSERT_TRUE(NULL != payload);
300 OicSecCred_t *cred2 = NULL;
301 EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
303 ASSERT_TRUE(cred2 != NULL);
304 DeleteCredList(cred2);
307 TEST(CredResourceTest, CBORPayloadToCredSecureVALID)
309 OicSecCred_t *cred1 = getCredList();
310 ASSERT_TRUE(NULL != cred1);
311 cred1->privateData.data = (uint8_t *)OICCalloc(1, OWNER_PSK_LENGTH_128);
312 ASSERT_TRUE(NULL != cred1->privateData.data);
313 cred1->privateData.len = OWNER_PSK_LENGTH_128;
315 uint8_t *payload = NULL;
318 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size, secureFlag));
320 ASSERT_TRUE(NULL != payload);
322 OicSecCred_t *cred2 = NULL;
323 EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
324 ASSERT_TRUE(cred2 != NULL);
325 ASSERT_TRUE(NULL == cred2->privateData.data);
326 ASSERT_TRUE(0 == cred2->privateData.len);
330 DeleteCredList(cred1);
331 DeleteCredList(cred2);
334 TEST(CredResourceTest, CBORPayloadToCredNULL)
336 OicSecCred_t *cred = NULL;
337 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
338 uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
339 ASSERT_TRUE(NULL != cborPayload);
340 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred));
341 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL));
342 cred = getCredList();
343 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
344 DeleteCredList(cred);
345 OICFree(cborPayload);
348 //GetCredResourceData Test
349 TEST(CredResourceTest, GetCredResourceDataNULLSubject)
351 EXPECT_EQ(NULL, GetCredResourceData(NULL));
354 TEST(CredResourceTest, GenerateCredentialValidInput)
356 OicUuid_t rownerID = {{0}};
357 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId21");
359 OicUuid_t subject = {{0}};
360 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
362 uint8_t privateKey[] = "My private Key11";
363 OicSecKey_t key = {privateKey, sizeof(privateKey)};
365 OicSecCred_t * cred = NULL;
366 cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
367 &key, &rownerID, NULL);
370 ASSERT_TRUE(NULL != cred);
371 DeleteCredList(cred);
375 TEST(CredResourceTest, GenerateAndAddCredentialValidInput)
377 OicUuid_t rownerID = {{0}};
378 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId11");
380 OicUuid_t subject = {{0}};
381 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
383 uint8_t privateKey[] = "My private Key11";
384 OicSecKey_t key = {privateKey, sizeof(privateKey)};
386 OicSecCred_t *cred1 = NULL;
387 OicSecCred_t *headCred = NULL;
389 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
390 &key, &rownerID, NULL);
392 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
395 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId22");
396 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
397 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
398 &key, &rownerID, NULL);
399 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
401 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId33");
402 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
403 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
404 &key, &rownerID, NULL);
405 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
407 const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
411 DeleteCredList(headCred);
416 TEST(CredGetResourceDataTest, GetCredResourceDataValidSubject)
418 OicSecCred_t* cred = getCredList();
419 EXPECT_TRUE(NULL != GetCredResourceData(cred->subject));
423 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
424 TEST(CredGetDtlsPskCredentialsTest, NullResult)
426 EXPECT_EQ(-1, GetDtlsPskCredentials(CA_DTLS_PSK_KEY, NULL, 0, NULL, 0));
429 TEST(CredAddTmpPskWithPINTest, NullSubject)
431 EXPECT_EQ(OC_STACK_INVALID_PARAM, AddTmpPskWithPIN(NULL, SYMMETRIC_PAIR_WISE_KEY,
432 NULL, 0, NULL, NULL));
434 #endif // __WITH_DTLS__ or __WITH_TLS__
435 TEST(CredCBORPayloadToCredTest, NullPayload)
437 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));