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 OICStrcpy((char *)cred->subject.id, sizeof(cred->subject.id), "subject1");
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");
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");
59 cred->owners = (OicUuid_t *)OICCalloc(cred->ownersLen, sizeof(*cred->owners));
60 VERIFY_NON_NULL(TAG, cred->owners, ERROR);
61 OICStrcpy((char *)cred->owners[0].id, sizeof(cred->owners[0].id), "ownersId11");
62 cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(*cred->next));
63 VERIFY_NON_NULL(TAG, cred->next, ERROR);
64 cred->next->credId = 5678;
65 OICStrcpy((char *)cred->next->subject.id, sizeof(cred->next->subject.id), "subject2");
67 cred->next->roleIdsLen = 0;
69 cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
70 sz = strlen("My private Key21") + 1;
71 cred->next->privateData.data = (uint8_t *)OICCalloc(1, sz);
72 VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
73 OICStrcpy((char *)cred->next->privateData.data, sz, "My private Key21");
75 sz = strlen("My Public Key123") + 1
76 cred->next->publicData.data = (char *)OICCalloc(1, sz);
77 VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
78 OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
80 cred->next->ownersLen = 2;
81 cred->next->owners = (OicUuid_t *)OICCalloc(cred->next->ownersLen, sizeof(*cred->next->owners));
82 VERIFY_NON_NULL(TAG, cred->next->owners, ERROR);
83 OICStrcpy((char *)cred->next->owners[0].id, sizeof(cred->next->owners[0].id), "ownersId21");
84 OICStrcpy((char *)cred->next->owners[1].id, sizeof(cred->next->owners[1].id), "ownersId22");
97 static void printCred(const OicSecCred_t * cred)
99 EXPECT_TRUE(NULL != cred);
101 const OicSecCred_t *credTmp1 = NULL;
102 for (credTmp1 = cred; credTmp1; credTmp1 = credTmp1->next)
104 OIC_LOG_V(INFO, TAG, "\ncred->credId = %d", credTmp1->credId);
105 OIC_LOG_V(INFO, TAG, "cred->subject.id = %s", credTmp1->subject.id);
106 OIC_LOG_V(INFO, TAG, "cred->credType = %d", credTmp1->credType);
107 if(credTmp1->privateData.data)
109 OIC_LOG_V(INFO, TAG, "cred->privateData.data = %s", credTmp1->privateData.data);
111 if(credTmp1->publicData.data)
113 OIC_LOG_V(INFO, TAG, "cred->publicData.data = %s", credTmp1->publicData.data);
115 OIC_LOG_V(INFO, TAG, "cred->ownersLen = %zu", credTmp1->ownersLen);
116 for(size_t i = 0; i < cred->ownersLen; i++)
118 OIC_LOG_V(INFO, TAG, "cred->owners[%zu].id = %s", i, credTmp1->owners[i].id);
123 //InitCredResource Tests
124 TEST(CredResourceTest, InitCredResource)
126 EXPECT_EQ(OC_STACK_INVALID_PARAM, InitCredResource());
129 //DeInitCredResource Tests
130 TEST(CredResourceTest, DeInitCredResource)
132 EXPECT_EQ(OC_STACK_INVALID_PARAM, DeInitCredResource());
135 //CreateCredResource Tests
136 TEST(CredResourceTest, CreateCredResource)
138 EXPECT_EQ(OC_STACK_INVALID_PARAM, CreateCredResource());
141 //CredEntityHandler Tests
142 TEST(CredResourceTest, CredEntityHandlerWithDummyRequest)
144 OCEntityHandlerRequest req;
145 EXPECT_EQ(OC_EH_ERROR,
146 CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, &req, NULL));
149 TEST(CredResourceTest, CredEntityHandlerWithNULLRequest)
151 EXPECT_EQ(OC_EH_ERROR,
152 CredEntityHandler(OCEntityHandlerFlag::OC_REQUEST_FLAG, NULL, NULL));
155 TEST(CredResourceTest, CredEntityHandlerInvalidFlag)
157 OCEntityHandlerRequest req;
158 EXPECT_EQ(OC_EH_ERROR,
159 CredEntityHandler(OCEntityHandlerFlag::OC_OBSERVE_FLAG, &req, NULL));
162 //Cred DELETE request
163 TEST(CredResourceTest, CredEntityHandlerDeleteTest)
165 OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
166 static OCPersistentStorage ps = OCPersistentStorage();
167 const OicSecCred_t* subjectCred1 = NULL;
168 const OicSecCred_t* subjectCred2 = NULL;
169 OCEntityHandlerResult ehRet = OC_EH_ERROR;
170 char query[] = "sub=subject1";
172 SetPersistentHandler(&ps, true);
174 OicSecCred_t *cred = getCredList();
175 ASSERT_TRUE(NULL != cred);
177 uint8_t *payload = NULL;
179 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
182 DeleteCredList(cred);
184 ASSERT_TRUE(NULL != payload);
186 // Create Entity Handler POST request payload
187 ehReq.method = OC_REST_POST;
188 ehReq.payload = (OCPayload *)OCSecurityPayloadCBORCreate(payload);
192 DeleteCredList(cred);
194 ASSERT_TRUE( NULL != ehReq.payload);
195 EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
197 // Verify if SRM contains Credential for the subject
198 subjectCred1 = GetCredResourceData(&cred->subject);
199 EXPECT_TRUE(NULL != subjectCred1);
201 // Create Entity Handler DELETE request
202 ehReq.method = OC_REST_DELETE;
203 ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
207 DeleteCredList(cred);
209 ASSERT_TRUE(NULL != ehReq.query);
210 OICStrcpy(ehReq.query, strlen(query)+1, query);
212 ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
213 EXPECT_EQ(OC_EH_ERROR, ehRet);
215 // Verify if SRM has deleted ACE for the subject
216 subjectCred2 = GetCredResourceData(&cred->subject);
217 EXPECT_TRUE(NULL == subjectCred2);
220 OICFree(ehReq.query);
224 DeInitCredResource();
225 DeleteCredList(cred);
229 TEST(CredResourceTest, CredToCBORPayloadNULL)
231 OicSecCred_t *cred = getCredList();
232 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, NULL, 0));
234 uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
237 DeleteCredList(cred);
239 ASSERT_TRUE(NULL != cborPayload);
240 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, &size));
241 OICFree(cborPayload);
243 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, &cborPayload, &size));
244 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, 0));
245 EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, NULL, &size));
246 DeleteCredList(cred);
249 TEST(CredResourceTest, CredToCBORPayloadVALID)
251 uint8_t* payload = NULL;
253 OicSecCred_t *cred = getCredList();
255 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
258 DeleteCredList(cred);
260 ASSERT_TRUE(NULL != payload);
262 DeleteCredList(cred);
266 TEST(CredResourceTest, CBORPayloadToCredVALID)
268 OicSecCred_t *cred1 = getCredList();
270 uint8_t *payload = NULL;
272 EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size));
273 DeleteCredList(cred1);
274 ASSERT_TRUE(NULL != payload);
276 OicSecCred_t *cred2 = NULL;
277 EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
279 ASSERT_TRUE(cred2 != NULL);
282 TEST(CredResourceTest, CBORPayloadToCredNULL)
284 OicSecCred_t *cred = NULL;
285 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
286 uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
287 ASSERT_TRUE(NULL != cborPayload);
288 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred));
289 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL));
290 cred = getCredList();
291 EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
292 DeleteCredList(cred);
293 OICFree(cborPayload);
296 //GetCredResourceData Test
297 TEST(CredResourceTest, GetCredResourceDataNULLSubject)
299 EXPECT_EQ(NULL, GetCredResourceData(NULL));
302 TEST(CredResourceTest, GenerateCredentialValidInput)
305 OICStrcpy((char *)owners[0].id, strlen("ownersId21"), "ownersId21");
307 OicUuid_t subject = {{0}};
308 OICStrcpy((char *)subject.id, strlen("subject11"), "subject11");
310 char privateKey[] = "My private Key11";
311 uint8_t *pk = (uint8_t *)OICCalloc(1, strlen(privateKey));
312 OICStrcpy((char *)pk, sizeof(pk), privateKey);
314 OicSecCred_t * cred = NULL;
316 cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
320 ASSERT_TRUE(NULL != cred);
321 DeleteCredList(cred);
325 TEST(CredResourceTest, GenerateAndAddCredentialValidInput)
328 OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId11");
330 OicUuid_t subject = {{0}};
331 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
333 char privateKey[] = "My private Key11";
334 uint8_t *pk = (uint8_t *)OICCalloc(1, strlen(privateKey));
335 OICStrcpy((char *)pk, sizeof(pk), privateKey);
337 OicSecCred_t *cred1 = NULL;
338 OicSecCred_t *headCred = NULL;
340 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
343 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
346 OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId22");
347 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
348 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
350 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
352 OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId33");
353 OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
354 cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
356 EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
358 const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
362 DeleteCredList(headCred);
367 TEST(CredGetResourceDataTest, GetCredResourceDataValidSubject)
369 OicSecCred_t* cred = getCredList();
370 EXPECT_TRUE(NULL != GetCredResourceData(cred->subject));