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"
23 #include "ocpayload.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"
35 #define TAG "SRM-CRED-UT"
37 OicSecCred_t * getCredList()
40 OicSecCred_t *cred = (OicSecCred_t *)OICCalloc(1, sizeof(*cred));
41 VERIFY_NON_NULL(TAG, cred, ERROR);
43 // use |memcpy| for copying full-lengthed UUID without null termination
44 memcpy(cred->subject.id, "1111111111111111", sizeof(cred->subject.id));
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");
54 cred->credType = SYMMETRIC_PAIR_WISE_KEY;
55 cred->privateData.encoding = OIC_ENCODING_RAW;
56 cred->privateData.data = (uint8_t *)OICCalloc(1, strlen("My private Key11") + 1);
57 VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
58 OICStrcpy((char *)cred->privateData.data, strlen("My private Key11")+1,"My private Key11");
59 // use |memcpy| for copying full-lengthed UUID without null termination
60 memcpy(cred->rownerID.id, "aaaaaaaaaaaaaaaa", sizeof(cred->rownerID.id));
61 cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(*cred->next));
62 VERIFY_NON_NULL(TAG, cred->next, ERROR);
63 cred->next->credId = 5678;
64 // use |memcpy| for copying full-lengthed UUID without null termination
65 memcpy(cred->next->subject.id, "2222222222222222", sizeof(cred->next->subject.id));
67 cred->next->roleIdsLen = 0;
69 cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
70 cred->next->privateData.encoding = OIC_ENCODING_RAW;
71 sz = strlen("My private Key21") + 1;
72 cred->next->privateData.data = (uint8_t *)OICCalloc(1, sz);
73 VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
74 OICStrcpy((char *)cred->next->privateData.data, sz, "My private Key21");
76 sz = strlen("My Public Key123") + 1;
77 cred->next->publicData.data = (char *)OICCalloc(1, sz);
78 VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
79 OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
81 // use |memcpy| for copying full-lengthed UUID without null termination
82 memcpy(cred->next->rownerID.id, "bbbbbbbbbbbbbbbb", sizeof(cred->next->rownerID.id));
95 static void printCred(const OicSecCred_t * cred)
97 EXPECT_TRUE(NULL != cred);
99 const OicSecCred_t *credTmp1 = NULL;
100 for (credTmp1 = cred; credTmp1; credTmp1 = credTmp1->next)
102 OIC_LOG_V(INFO, TAG, "\ncred->credId = %d", credTmp1->credId);
103 OIC_LOG_V(INFO, TAG, "cred->subject.id = %s", credTmp1->subject.id);
104 OIC_LOG_V(INFO, TAG, "cred->credType = %d", credTmp1->credType);
105 if(credTmp1->privateData.data)
107 OIC_LOG_V(INFO, TAG, "cred->privateData.data = %s", credTmp1->privateData.data);
110 if(credTmp1->publicData.data)
112 OIC_LOG_V(INFO, TAG, "cred->publicData.data = %s", credTmp1->publicData.data);
114 #endif /* __WITH_DTLS__ */
115 OIC_LOG_V(INFO, TAG, "cred->rownerID = %s", credTmp1->rownerID.id);
119 //InitCredResource Tests
120 TEST(CredResourceTest, InitCredResource)
122 EXPECT_EQ(OC_STACK_INVALID_PARAM, InitCredResource());
125 //DeInitCredResource Tests
126 TEST(CredResourceTest, DeInitCredResource)
128 EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitCredResource());
131 //CreateCredResource Tests
132 TEST(CredResourceTest, CreateCredResource)
134 EXPECT_EQ(OC_STACK_INVALID_PARAM, CreateCredResource());
137 //CredEntityHandler Tests
138 TEST(CredResourceTest, CredEntityHandlerWithDummyRequest)
140 OCEntityHandlerRequest req = OCEntityHandlerRequest();
141 EXPECT_EQ(OC_EH_ERROR,
142 CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
145 TEST(CredResourceTest, CredEntityHandlerWithNULLRequest)
147 EXPECT_EQ(OC_EH_ERROR,
148 CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, NULL, NULL));
151 TEST(CredResourceTest, CredEntityHandlerInvalidFlag)
153 OCEntityHandlerRequest req = OCEntityHandlerRequest();
154 EXPECT_EQ(OC_EH_ERROR,
155 CredEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, &req, NULL));
158 //Cred DELETE request
159 TEST(CredResourceTest, CredEntityHandlerDeleteTest)
161 OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
162 static OCPersistentStorage ps = OCPersistentStorage();
163 const OicSecCred_t* subjectCred1 = NULL;
164 const OicSecCred_t* subjectCred2 = NULL;
165 OCEntityHandlerResult ehRet = OC_EH_ERROR;
166 char query[] = "subjectuuid=31313131-3131-3131-3131-313131313131"; //canonical uuid of subject1
168 SetPersistentHandler(&ps, true);
170 OicSecCred_t *cred = getCredList();
171 ASSERT_TRUE(NULL != cred);
172 uint8_t *payload = NULL;
175 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size, secureFlag));
178 DeleteCredList(cred);
180 ASSERT_TRUE(NULL != payload);
182 // Create Entity Handler POST request payload
183 ehReq.method = OC_REST_POST;
184 ehReq.payload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
188 DeleteCredList(cred);
190 ASSERT_TRUE( NULL != ehReq.payload);
191 EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
193 // Verify if SRM contains Credential for the subject
194 subjectCred1 = GetCredResourceData(&cred->subject);
195 EXPECT_TRUE(NULL != subjectCred1);
197 // Create Entity Handler DELETE request
198 ehReq.method = OC_REST_DELETE;
199 ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
203 DeleteCredList(cred);
205 ASSERT_TRUE(NULL != ehReq.query);
206 OICStrcpy(ehReq.query, strlen(query)+1, query);
208 ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
209 EXPECT_EQ(OC_EH_ERROR, ehRet);
211 // Verify if SRM has deleted ACE for the subject
212 subjectCred2 = GetCredResourceData(&cred->subject);
213 EXPECT_TRUE(NULL == subjectCred2);
216 OICFree(ehReq.query);
218 DeInitCredResource();
219 DeleteCredList(cred);
220 OCPayloadDestroy((OCPayload *)ehReq.payload);
223 TEST(CredResourceTest, CredToCBORPayloadNULL)
226 OicSecCred_t *cred = getCredList();
227 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, NULL, 0, secureFlag));
229 uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
232 DeleteCredList(cred);
234 ASSERT_TRUE(NULL != cborPayload);
235 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, &size, secureFlag));
236 OICFree(cborPayload);
238 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, &cborPayload, &size,secureFlag));
239 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, 0, secureFlag));
240 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, NULL, &size, secureFlag));
241 DeleteCredList(cred);
244 TEST(CredResourceTest, CredToCBORPayloadVALID)
246 uint8_t* payload = NULL;
249 OicSecCred_t *cred = getCredList();
251 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size, secureFlag));
254 DeleteCredList(cred);
256 ASSERT_TRUE(NULL != payload);
258 DeleteCredList(cred);
262 TEST(CredResourceTest, CBORPayloadToCredVALID)
264 OicSecCred_t *cred1 = getCredList();
266 uint8_t *payload = NULL;
269 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size, secureFlag));
270 DeleteCredList(cred1);
271 ASSERT_TRUE(NULL != payload);
273 OicSecCred_t *cred2 = NULL;
274 EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
276 ASSERT_TRUE(cred2 != NULL);
277 DeleteCredList(cred2);
280 TEST(CredResourceTest, CBORPayloadToCredSecureVALID)
282 OicSecCred_t *cred1 = getCredList();
283 ASSERT_TRUE(NULL != cred1);
284 cred1->privateData.data = (uint8_t *)OICCalloc(1, OWNER_PSK_LENGTH_128);
285 ASSERT_TRUE(NULL != cred1->privateData.data);
286 cred1->privateData.len = OWNER_PSK_LENGTH_128;
288 uint8_t *payload = NULL;
291 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size, secureFlag));
293 ASSERT_TRUE(NULL != payload);
295 OicSecCred_t *cred2 = NULL;
296 EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
297 ASSERT_TRUE(cred2 != NULL);
298 ASSERT_TRUE(NULL == cred2->privateData.data);
299 ASSERT_TRUE(0 == cred2->privateData.len);
303 DeleteCredList(cred1);
304 DeleteCredList(cred2);
307 TEST(CredResourceTest, CBORPayloadToCredNULL)
309 OicSecCred_t *cred = NULL;
310 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
311 uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
312 ASSERT_TRUE(NULL != cborPayload);
313 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred));
314 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL));
315 cred = getCredList();
316 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
317 DeleteCredList(cred);
318 OICFree(cborPayload);
321 //GetCredResourceData Test
322 TEST(CredResourceTest, GetCredResourceDataNULLSubject)
324 EXPECT_EQ(NULL, GetCredResourceData(NULL));
327 TEST(CredResourceTest, GenerateCredentialValidInput)
329 OicUuid_t rownerID = {{0}};
330 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId21");
332 OicUuid_t subject = {{0}};
333 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
335 uint8_t privateKey[] = "My private Key11";
336 OicSecKey_t key = {privateKey, sizeof(privateKey)};
338 OicSecCred_t * cred = NULL;
339 cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
340 &key, &rownerID, NULL);
343 ASSERT_TRUE(NULL != cred);
344 DeleteCredList(cred);
347 TEST(CredResourceTest, GenerateAndAddCredentialValidInput)
349 OicUuid_t rownerID = {{0}};
350 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId11");
352 OicUuid_t subject = {{0}};
353 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
355 uint8_t privateKey[] = "My private Key11";
356 OicSecKey_t key = {privateKey, sizeof(privateKey)};
358 OicSecCred_t *cred1 = NULL;
359 OicSecCred_t *headCred = NULL;
361 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
362 &key, &rownerID, NULL);
364 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
367 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId22");
368 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
369 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
370 &key, &rownerID, NULL);
371 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
373 OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId33");
374 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
375 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
376 &key, &rownerID, NULL);
377 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
379 const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
383 DeleteCredList(headCred);
387 TEST(CredGetResourceDataTest, GetCredResourceDataValidSubject)
389 OicSecCred_t* cred = getCredList();
390 EXPECT_TRUE(NULL != GetCredResourceData(cred->subject));
394 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
395 TEST(CredGetDtlsPskCredentialsTest, NullResult)
397 EXPECT_EQ(-1, GetDtlsPskCredentials(CA_DTLS_PSK_KEY, NULL, 0, NULL, 0));
400 TEST(CredAddTmpPskWithPINTest, NullSubject)
402 EXPECT_EQ(OC_STACK_INVALID_PARAM, AddTmpPskWithPIN(NULL, SYMMETRIC_PAIR_WISE_KEY,
403 NULL, 0, NULL, NULL));
405 #endif // __WITH_DTLS__ or __WITH_TLS__
406 TEST(CredCBORPayloadToCredTest, NullPayload)
408 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));