/**
* Callback handler for handling callback of provisioning device 1.
*
* @param[in] ctx ctx value passed to callback from calling function.
* @param[in] UNUSED handle to an invocation
* @param[in] clientResponse Response from queries to remote servers.
* @return OC_STACK_DELETE_TRANSACTION to delete the transaction
* and OC_STACK_KEEP_TRANSACTION to keep it.
*/
static OCStackApplicationResult provisionCredentialCB1(void *ctx, OCDoHandle UNUSED,
OCClientResponse *clientResponse)
{
VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
(void)UNUSED;
CredentialData_t* credData = (CredentialData_t*) ctx;
OICFree(credData->credInfoFirst);
const OCProvisionDev_t *deviceInfo = credData->deviceInfo2;
OicSecCred_t *credInfo = credData->credInfo;
const OCProvisionResultCB resultCallback = credData->resultCallback;
if (clientResponse)
{
if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
{
// send credentials to second device
registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED,1);
OCStackResult res = provisionCredentials(credInfo, deviceInfo, credData,
provisionCredentialCB2);
DeleteCredList(credInfo);
if (OC_STACK_OK != res)
{
registerResultForCredProvisioning(credData, res,2);
((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
credData->resArr,
true);
OICFree(credData->resArr);
OICFree(credData);
credData = NULL;
}
}
else
{
registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
credData->resArr,
true);
OICFree(credData->resArr);
OICFree(credData);
credData = NULL;
}
}
else
{
OC_LOG(INFO, TAG, "provisionCredentialCB received Null clientResponse for first device");
registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
credData->resArr,
true);
DeleteCredList(credInfo);
OICFree(credData->resArr);
OICFree(credData);
credData = NULL;
}
return OC_STACK_DELETE_TRANSACTION;
}
//JSONToCredBin Tests
TEST(JSONToCredBinTest, JSONToCredBinValidJSON)
{
OicSecCred_t* cred1 = getCredList();
char* json = BinToCredJSON(cred1);
EXPECT_TRUE(json != NULL);
OicSecCred_t *cred2 = JSONToCredBin(json);
EXPECT_TRUE(cred2 != NULL);
DeleteCredList(cred1);
DeleteCredList(cred2);
OICFree(json);
}
TEST(CredResourceTest, CredToCBORPayloadVALID)
{
uint8_t* payload = NULL;
size_t size = 0;
OicSecCred_t *cred = getCredList();
EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
if (!payload)
{
DeleteCredList(cred);
}
ASSERT_TRUE(NULL != payload);
DeleteCredList(cred);
OICFree(payload);
}
TEST(CredResourceTest, CBORPayloadToCredVALID)
{
OicSecCred_t *cred1 = getCredList();
uint8_t *payload = NULL;
size_t size = 0;
EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred1, &payload, &size));
DeleteCredList(cred1);
ASSERT_TRUE(NULL != payload);
OicSecCred_t *cred2 = NULL;
EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
OICFree(payload);
ASSERT_TRUE(cred2 != NULL);
DeleteCredList(cred2);
}
TEST(CredResourceTest, CredToCBORPayloadNULL)
{
OicSecCred_t *cred = getCredList();
EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, NULL, 0));
size_t size = 0;
uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
if (!cborPayload)
{
DeleteCredList(cred);
}
ASSERT_TRUE(NULL != cborPayload);
EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, &size));
OICFree(cborPayload);
cborPayload = NULL;
EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(NULL, &cborPayload, &size));
EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, &cborPayload, 0));
EXPECT_EQ(OC_STACK_INVALID_PARAM, CredToCBORPayload(cred, NULL, &size));
DeleteCredList(cred);
}
OicSecCred_t * getCredList()
{
size_t sz = 0;
OicSecCred_t *cred = (OicSecCred_t *)OICCalloc(1, sizeof(*cred));
VERIFY_NON_NULL(TAG, cred, ERROR);
cred->credId = 1234;
// use |memcpy| for copying full-lengthed UUID without null termination
memcpy(cred->subject.id, "1111111111111111", sizeof(cred->subject.id));
#if 0
cred->roleIdsLen = 2;
cred->roleIds = (OicSecRole_t *)OICCalloc(cred->roleIdsLen, sizeof(OicSecRole_t));
VERIFY_NON_NULL(TAG, cred->roleIds, ERROR);
OICStrcpy((char *)cred->roleIds[0].id, sizeof(cred->roleIds[0].id), "role11");
OICStrcpy((char *)cred->roleIds[1].id, sizeof(cred->roleIds[1].id), "role12");
#endif
cred->credType = SYMMETRIC_PAIR_WISE_KEY;
cred->privateData.data = (uint8_t *)OICCalloc(1, strlen("My private Key11") + 1);
VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
OICStrcpy((char *)cred->privateData.data, strlen("My private Key11")+1,"My private Key11");
// use |memcpy| for copying full-lengthed UUID without null termination
memcpy(cred->rownerID.id, "aaaaaaaaaaaaaaaa", sizeof(cred->rownerID.id));
cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(*cred->next));
VERIFY_NON_NULL(TAG, cred->next, ERROR);
cred->next->credId = 5678;
// use |memcpy| for copying full-lengthed UUID without null termination
memcpy(cred->next->subject.id, "2222222222222222", sizeof(cred->next->subject.id));
#if 0
cred->next->roleIdsLen = 0;
#endif
cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
sz = strlen("My private Key21") + 1;
cred->next->privateData.data = (uint8_t *)OICCalloc(1, sz);
VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
OICStrcpy((char *)cred->next->privateData.data, sz, "My private Key21");
#if 0
sz = strlen("My Public Key123") + 1;
cred->next->publicData.data = (char *)OICCalloc(1, sz);
VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
#endif
// use |memcpy| for copying full-lengthed UUID without null termination
memcpy(cred->next->rownerID.id, "bbbbbbbbbbbbbbbb", sizeof(cred->next->rownerID.id));
return cred;
exit:
if(cred)
{
DeleteCredList(cred);
cred = NULL;
}
return cred;
}
TEST(BinToCredJSONTest, BinToCredJSONValidCred)
{
char* json = NULL;
OicSecCred_t * cred = getCredList();
json = BinToCredJSON(cred);
OIC_LOG_V(INFO, TAG, "BinToCredJSON:%s\n", json);
EXPECT_TRUE(json != NULL);
DeleteCredList(cred);
OICFree(json);
}
//Cred DELETE request
TEST(CredEntityHandlerTest, CredEntityHandlerDeleteTest)
{
OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
static OCPersistentStorage ps = OCPersistentStorage();
const OicSecCred_t* subjectCred1 = NULL;
const OicSecCred_t* subjectCred2 = NULL;
char *jsonStr = NULL;
OCEntityHandlerResult ehRet = OC_EH_ERROR;
char query[] = "sub=c3ViamVjdDE=";
SetPersistentHandler(&ps, true);
OicSecCred_t *cred = getCredList();
VERIFY_NON_NULL(TAG, cred, ERROR);
jsonStr = BinToCredJSON(cred);
VERIFY_NON_NULL(TAG, jsonStr, ERROR);
// Create Entity Handler POST request payload
ehReq.method = OC_REST_POST;
ehReq.payload = (OCPayload*)OCSecurityPayloadCreate(jsonStr);
ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq);
EXPECT_TRUE(OC_EH_ERROR == ehRet);
// Verify if SRM contains Credential for the subject
subjectCred1 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL != subjectCred1);
// Create Entity Handler DELETE request
ehReq.method = OC_REST_DELETE;
ehReq.query = (char*)OICMalloc(strlen(query)+1);
VERIFY_NON_NULL(TAG, ehReq.query, ERROR);
OICStrcpy(ehReq.query, strlen(query)+1, query);
ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq);
EXPECT_TRUE(OC_EH_ERROR == ehRet);
// Verify if SRM has deleted ACE for the subject
subjectCred2 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL == subjectCred2);
exit:
// Perform cleanup
OICFree(ehReq.query);
OICFree(jsonStr);
OCPayloadDestroy(ehReq.payload);
if(NULL != cred)
{
DeInitCredResource();
DeleteCredList(cred);
}
}
TEST(CredResourceTest, CBORPayloadToCredNULL)
{
OicSecCred_t *cred = NULL;
EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
uint8_t *cborPayload = (uint8_t *) OICCalloc(1, 10);
ASSERT_TRUE(NULL != cborPayload);
EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred));
EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL));
cred = getCredList();
EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
DeleteCredList(cred);
OICFree(cborPayload);
}
TEST(CredGenerateCredentialTest, GenerateCredentialValidInput)
{
OicUuid_t owners[1];
OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId21");
OicUuid_t subject = {{0}};
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
char privateKey[] = "My private Key11";
OicSecCred_t * cred = NULL;
cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
privateKey, 1, owners);
printCred(cred);
EXPECT_TRUE(NULL != cred);
DeleteCredList(cred);
}
TEST(CredResourceTest, GenerateCredentialValidInput)
{
OicUuid_t rownerID = {{0}};
OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId21");
OicUuid_t subject = {{0}};
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
uint8_t privateKey[] = "My private Key11";
OicSecKey_t key = {privateKey, sizeof(privateKey)};
OicSecCred_t * cred = NULL;
cred = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
&key, &rownerID);
printCred(cred);
ASSERT_TRUE(NULL != cred);
DeleteCredList(cred);
}
TEST(GenerateAndAddCredentialTest, GenerateAndAddCredentialValidInput)
{
OicUuid_t owners[1];
OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId11");
OicUuid_t subject = {{0}};
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
char privateKey[] = "My private Key11";
OicSecCred_t * cred1 = NULL;
OicSecCred_t * headCred = NULL;
cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
privateKey, 1, owners);
EXPECT_EQ(OC_STACK_ERROR, AddCredential(cred1));
headCred = cred1;
OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId22");
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
privateKey, 1, owners);
EXPECT_EQ(OC_STACK_ERROR, AddCredential(cred1));
OICStrcpy((char *)owners[0].id, sizeof(owners[0].id), "ownersId33");
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
privateKey, 1, owners);
EXPECT_EQ(OC_STACK_ERROR, AddCredential(cred1));
const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
printCred(credList);
DeleteCredList(headCred);
}
TEST(CredResourceTest, GenerateAndAddCredentialValidInput)
{
OicUuid_t rownerID = {{0}};
OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId11");
OicUuid_t subject = {{0}};
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject11");
uint8_t privateKey[] = "My private Key11";
OicSecKey_t key = {privateKey, sizeof(privateKey)};
OicSecCred_t *cred1 = NULL;
OicSecCred_t *headCred = NULL;
cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
&key, &rownerID);
EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
headCred = cred1;
OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId22");
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject22");
cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
&key, &rownerID);
EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
OICStrcpy((char *)rownerID.id, sizeof(rownerID.id), "ownersId33");
OICStrcpy((char *)subject.id, sizeof(subject.id), "subject33");
cred1 = GenerateCredential(&subject, SYMMETRIC_PAIR_WISE_KEY, NULL,
&key, &rownerID);
EXPECT_EQ(OC_STACK_OK, AddCredential(cred1));
const OicSecCred_t* credList = GetCredResourceData(&headCred->subject);
printCred(credList);
DeleteCredList(headCred);
}
static void ConvertJsonToCBOR(const char *jsonFileName, const char *cborFileName)
{
char *jsonStr = NULL;
FILE *fp = NULL;
FILE *fp1 = NULL;
uint8_t *aclCbor = NULL;
uint8_t *pstatCbor = NULL;
uint8_t *doxmCbor = NULL;
uint8_t *amaclCbor = NULL;
uint8_t *svcCbor = NULL;
uint8_t *credCbor = NULL;
cJSON *jsonRoot = NULL;
OCStackResult ret = OC_STACK_ERROR;
size_t size = GetJSONFileSize(jsonFileName);
if (0 == size)
{
OIC_LOG (ERROR, TAG, "Failed converting to JSON");
return;
}
jsonStr = (char *)OICMalloc(size + 1);
VERIFY_NON_NULL(TAG, jsonStr, FATAL);
fp = fopen(jsonFileName, "r");
if (fp)
{
size_t bytesRead = fread(jsonStr, 1, size, fp);
jsonStr[bytesRead] = '\0';
OIC_LOG_V(DEBUG, TAG, "Read %zu bytes", bytesRead);
fclose(fp);
fp = NULL;
}
else
{
OIC_LOG (ERROR, TAG, "Unable to open JSON file!!");
goto exit;
}
jsonRoot = cJSON_Parse(jsonStr);
cJSON *value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_ACL_NAME);
//printf("ACL json : \n%s\n", cJSON_PrintUnformatted(value));
size_t aclCborSize = 0;
if (NULL != value)
{
OicSecAcl_t *acl = JSONToAclBin(jsonStr);
VERIFY_NON_NULL(TAG, acl, FATAL);
ret = AclToCBORPayload(acl, &aclCbor, &aclCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Acl to Cbor Payload");
DeleteACLList(acl);
goto exit;
}
printf("ACL Cbor Size: %zd\n", aclCborSize);
DeleteACLList(acl);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_PSTAT_NAME);
size_t pstatCborSize = 0;
if (NULL != value)
{
OicSecPstat_t *pstat = JSONToPstatBin(jsonStr);
VERIFY_NON_NULL(TAG, pstat, FATAL);
ret = PstatToCBORPayload(pstat, &pstatCbor, &pstatCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Pstat to Cbor Payload");
DeletePstatBinData(pstat);
goto exit;
}
printf("PSTAT Cbor Size: %zd\n", pstatCborSize);
DeletePstatBinData(pstat);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_DOXM_NAME);
size_t doxmCborSize = 0;
if (NULL != value)
{
OicSecDoxm_t *doxm = JSONToDoxmBin(jsonStr);
VERIFY_NON_NULL(TAG, doxm, FATAL);
ret = DoxmToCBORPayload(doxm, &doxmCbor, &doxmCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Doxm to Cbor Payload");
DeleteDoxmBinData(doxm);
goto exit;
}
printf("DOXM Cbor Size: %zd\n", doxmCborSize);
DeleteDoxmBinData(doxm);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_AMACL_NAME);
size_t amaclCborSize = 0;
if (NULL != value)
{
OicSecAmacl_t *amacl = JSONToAmaclBin(jsonStr);
VERIFY_NON_NULL(TAG, amacl, FATAL);
ret = AmaclToCBORPayload(amacl, &amaclCbor, &amaclCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Amacl to Cbor Payload");
DeleteAmaclList(amacl);
goto exit;
}
printf("AMACL Cbor Size: %zd\n", amaclCborSize);
DeleteAmaclList(amacl);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_SVC_NAME);
size_t svcCborSize = 0;
if (NULL != value)
{
OicSecSvc_t *svc = JSONToSvcBin(jsonStr);
VERIFY_NON_NULL(TAG, svc, FATAL);
ret = SVCToCBORPayload(svc, &svcCbor, &svcCborSize);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Svc to Cbor Payload");
DeleteSVCList(svc);
goto exit;
}
printf("SVC Cbor Size: %zd\n", svcCborSize);
DeleteSVCList(svc);
}
value = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
//printf("CRED json : \n%s\n", cJSON_PrintUnformatted(value));
size_t credCborSize = 0;
int secureFlag = 0;
if (NULL != value)
{
OicSecCred_t *cred = JSONToCredBin(jsonStr);
VERIFY_NON_NULL(TAG, cred, FATAL);
ret = CredToCBORPayload(cred, &credCbor, &credCborSize, secureFlag);
if(OC_STACK_OK != ret)
{
OIC_LOG (ERROR, TAG, "Failed converting Cred to Cbor Payload");
DeleteCredList(cred);
goto exit;
}
printf("CRED Cbor Size: %zd\n", credCborSize);
DeleteCredList(cred);
}
CborEncoder encoder;
size_t cborSize = aclCborSize + pstatCborSize + doxmCborSize + svcCborSize + credCborSize + amaclCborSize;
printf("Total Cbor Size : %zd\n", cborSize);
cborSize += 255; // buffer margin for adding map and byte string
uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborSize);
VERIFY_NON_NULL(TAG, outPayload, ERROR);
cbor_encoder_init(&encoder, outPayload, cborSize, 0);
CborEncoder map;
CborError cborEncoderResult = cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Creating Main Map.");
if (aclCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_ACL_NAME, strlen(OIC_JSON_ACL_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Name.");
cborEncoderResult = cbor_encode_byte_string(&map, aclCbor, aclCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding ACL Value.");
}
if (pstatCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_PSTAT_NAME, strlen(OIC_JSON_PSTAT_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Name.");
cborEncoderResult = cbor_encode_byte_string(&map, pstatCbor, pstatCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding PSTAT Value.");
}
if (doxmCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_DOXM_NAME, strlen(OIC_JSON_DOXM_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Name.");
cborEncoderResult = cbor_encode_byte_string(&map, doxmCbor, doxmCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding DOXM Value.");
}
if (amaclCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_AMACL_NAME, strlen(OIC_JSON_AMACL_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Name.");
cborEncoderResult = cbor_encode_byte_string(&map, amaclCbor, amaclCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding AMACL Value.");
}
if (svcCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_SVC_NAME, strlen(OIC_JSON_SVC_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Name.");
cborEncoderResult = cbor_encode_byte_string(&map, svcCbor, svcCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding SVC Value.");
}
if (credCborSize > 0)
{
cborEncoderResult = cbor_encode_text_string(&map, OIC_JSON_CRED_NAME, strlen(OIC_JSON_CRED_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Name.");
cborEncoderResult = cbor_encode_byte_string(&map, credCbor, credCborSize);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding CRED Value.");
}
cborEncoderResult = cbor_encoder_close_container(&encoder, &map);
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Closing Container.");
size_t s = encoder.ptr - outPayload;
OIC_LOG_V(DEBUG, TAG, "Payload size %zu", s);
fp1 = fopen(cborFileName, "w");
if (fp1)
{
size_t bytesWritten = fwrite(outPayload, 1, s, fp1);
if (bytesWritten == s)
{
OIC_LOG_V(DEBUG, TAG, "Written %zu bytes", bytesWritten);
}
else
{
OIC_LOG_V(ERROR, TAG, "Failed writing %zu bytes", s);
}
fclose(fp1);
fp1 = NULL;
}
exit:
cJSON_Delete(jsonRoot);
OICFree(aclCbor);
OICFree(doxmCbor);
OICFree(pstatCbor);
OICFree(amaclCbor);
OICFree(svcCbor);
OICFree(credCbor);
OICFree(jsonStr);
return ;
}
OicSecCred_t * JSONToCredBin(const char * jsonStr)
{
if (NULL == jsonStr)
{
OIC_LOG(ERROR, TAG,"JSONToCredBin jsonStr in NULL");
return NULL;
}
OicSecCred_t *headCred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
OCStackResult ret = OC_STACK_ERROR;
cJSON *jsonRoot = NULL;
VERIFY_NON_NULL(TAG, headCred, ERROR);
jsonRoot = cJSON_Parse(jsonStr);
VERIFY_NON_NULL(TAG, jsonRoot, ERROR);
cJSON *jsonCredMap = cJSON_GetObjectItem(jsonRoot, OIC_JSON_CRED_NAME);
VERIFY_NON_NULL(TAG, jsonCredMap, ERROR);
// creds
cJSON *jsonCredArray = NULL;
jsonCredArray = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_CREDS_NAME);
VERIFY_NON_NULL(TAG, jsonCredArray, ERROR);
if (cJSON_Array == jsonCredArray->type)
{
int numCred = cJSON_GetArraySize(jsonCredArray);
VERIFY_SUCCESS(TAG, numCred > 0, ERROR);
int idx = 0;
do
{
cJSON *jsonCred = cJSON_GetArrayItem(jsonCredArray, idx);
VERIFY_NON_NULL(TAG, jsonCred, ERROR);
OicSecCred_t *cred = NULL;
if(idx == 0)
{
cred = headCred;
}
else
{
cred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
OicSecCred_t *temp = headCred;
while (temp->next)
{
temp = temp->next;
}
temp->next = cred;
}
VERIFY_NON_NULL(TAG, cred, ERROR);
size_t jsonObjLen = 0;
cJSON *jsonObj = NULL;
//CredId -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDID_NAME);
if(jsonObj)
{
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
cred->credId = jsonObj->valueint;
}
//subject -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_SUBJECTID_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonObj->type, ERROR);
ret = ConvertStrToUuid(jsonObj->valuestring, &cred->subject);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
//CredType -- Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_CREDTYPE_NAME);
VERIFY_NON_NULL(TAG, jsonObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_Number == jsonObj->type, ERROR);
cred->credType = (OicSecCredType_t)jsonObj->valueint;
//PrivateData is mandatory for some of the credential types listed below.
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PRIVATEDATA_NAME);
if (NULL != jsonObj)
{
cJSON *jsonPriv = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
VERIFY_NON_NULL(TAG, jsonPriv, ERROR);
jsonObjLen = strlen(jsonPriv->valuestring);
cred->privateData.data = (uint8_t *)OICCalloc(1, jsonObjLen);
VERIFY_NON_NULL(TAG, (cred->privateData.data), ERROR);
memcpy(cred->privateData.data, jsonPriv->valuestring, jsonObjLen);
cred->privateData.len = jsonObjLen;
cJSON *jsonEncoding = cJSON_GetObjectItem(jsonObj, OIC_JSON_ENCODING_NAME);
VERIFY_NON_NULL(TAG, jsonEncoding, ERROR);
if(strcmp(OIC_SEC_ENCODING_RAW, jsonEncoding->valuestring) == 0)
{
cred->privateData.encoding = OIC_ENCODING_RAW;
}
else if(strcmp(OIC_SEC_ENCODING_BASE64, jsonEncoding->valuestring) == 0)
{
cred->privateData.encoding = OIC_ENCODING_BASE64;
}
else
{
printf("Unknow encoding type dectected!\n");
printf("json2cbor will use \"oic.sec.encoding.raw\" as default encoding type.\n");
cred->privateData.encoding = OIC_ENCODING_RAW;
}
}
#ifdef __WITH_X509__
//PublicData is mandatory only for SIGNED_ASYMMETRIC_KEY credentials type.
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PUBLICDATA_NAME);
if (NULL != jsonObj)
{
cJSON *jsonPub = cJSON_GetObjectItem(jsonObj, OIC_JSON_DATA_NAME);
VERIFY_NON_NULL(TAG, jsonPub, ERROR);
jsonObjLen = strlen(jsonPub->valuestring);
cred->publicData.data = (uint8_t *)OICCalloc(1, jsonObjLen);
VERIFY_NON_NULL(TAG, (cred->publicData.data), ERROR);
memcpy(cred->publicData.data, jsonPub->valuestring, jsonObjLen);
cred->publicData.len = jsonObjLen;
}
#endif // __WITH_X509__
//Period -- Not Mandatory
jsonObj = cJSON_GetObjectItem(jsonCred, OIC_JSON_PERIOD_NAME);
if(jsonObj && cJSON_String == jsonObj->type)
{
jsonObjLen = strlen(jsonObj->valuestring) + 1;
cred->period = (char *)OICMalloc(jsonObjLen);
VERIFY_NON_NULL(TAG, cred->period, ERROR);
strncpy(cred->period, jsonObj->valuestring, jsonObjLen);
}
cred->next = NULL;
} while( ++idx < numCred);
}
// rownerid
cJSON *jsonCredObj = cJSON_GetObjectItem(jsonCredMap, OIC_JSON_ROWNERID_NAME);
VERIFY_NON_NULL(TAG, jsonCredObj, ERROR);
VERIFY_SUCCESS(TAG, cJSON_String == jsonCredObj->type, ERROR);
ret = ConvertStrToUuid(jsonCredObj->valuestring, &headCred->rownerID);
VERIFY_SUCCESS(TAG, OC_STACK_OK == ret, ERROR);
ret = OC_STACK_OK;
exit:
if (OC_STACK_OK != ret)
{
DeleteCredList(headCred);
headCred = NULL;
}
return headCred;
}
/**
* Function to save ownerPSK at provisioning tool end.
*
* @param[in] selectedDeviceInfo selected device information to performing provisioning.
* @return OC_STACK_OK on success
*/
static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo)
{
OC_LOG(DEBUG, TAG, "IN SaveOwnerPSK");
OCStackResult res = OC_STACK_ERROR;
CAEndpoint_t endpoint;
memset(&endpoint, 0x00, sizeof(CAEndpoint_t));
OICStrcpy(endpoint.addr, MAX_ADDR_STR_SIZE_CA, selectedDeviceInfo->endpoint.addr);
endpoint.addr[MAX_ADDR_STR_SIZE_CA - 1] = '\0';
endpoint.port = selectedDeviceInfo->securePort;
OicUuid_t ptDeviceID = {.id={0}};
if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID))
{
OC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
return res;
}
uint8_t ownerPSK[OWNER_PSK_LENGTH_128] = {0};
//Generating OwnerPSK
CAResult_t pskRet = CAGenerateOwnerPSK(&endpoint,
(uint8_t *)GetOxmString(selectedDeviceInfo->doxm->oxmSel),
strlen(GetOxmString(selectedDeviceInfo->doxm->oxmSel)), ptDeviceID.id,
sizeof(ptDeviceID.id), selectedDeviceInfo->doxm->deviceID.id,
sizeof(selectedDeviceInfo->doxm->deviceID.id), ownerPSK,
OWNER_PSK_LENGTH_128);
if (CA_STATUS_OK == pskRet)
{
OC_LOG(INFO, TAG,"ownerPSK dump:\n");
OC_LOG_BUFFER(INFO, TAG,ownerPSK, OWNER_PSK_LENGTH_128);
//Generating new credential for provisioning tool
size_t ownLen = 1;
uint32_t outLen = 0;
char base64Buff[B64ENCODE_OUT_SAFESIZE(sizeof(ownerPSK)) + 1] = {};
B64Result b64Ret = b64Encode(ownerPSK, sizeof(ownerPSK), base64Buff, sizeof(base64Buff),
&outLen);
VERIFY_SUCCESS(TAG, B64_OK == b64Ret, ERROR);
OicSecCred_t *cred = GenerateCredential(&selectedDeviceInfo->doxm->deviceID,
SYMMETRIC_PAIR_WISE_KEY, NULL,
base64Buff, ownLen, &ptDeviceID);
VERIFY_NON_NULL(TAG, cred, ERROR);
res = AddCredential(cred);
if(res != OC_STACK_OK)
{
DeleteCredList(cred);
return res;
}
}
else
{
OC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed");
}
OC_LOG(DEBUG, TAG, "OUT SaveOwnerPSK");
exit:
return res;
}
OicSecCred_t * getCredList()
{
OicSecCred_t * cred = NULL;
size_t sz = 0;
cred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
VERIFY_NON_NULL(TAG, cred, ERROR);
cred->credId = 1234;
OICStrcpy((char *)cred->subject.id, sizeof(cred->subject.id), "subject1");
#if 0
cred->roleIdsLen = 2;
cred->roleIds = (OicSecRole_t *)OICCalloc(cred->roleIdsLen, sizeof(OicSecRole_t));
VERIFY_NON_NULL(TAG, cred->roleIds, ERROR);
OICStrcpy((char *)cred->roleIds[0].id, sizeof(cred->roleIds[0].id), "role11");
OICStrcpy((char *)cred->roleIds[1].id, sizeof(cred->roleIds[1].id), "role12");
#endif
cred->credType = SYMMETRIC_PAIR_WISE_KEY;
cred->privateData.data = (char *)OICCalloc(1, strlen("My private Key11") + 1);
VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR);
OICStrcpy(cred->privateData.data, strlen("My private Key11")+1,"My private Key11");
cred->ownersLen = 1;
cred->owners = (OicUuid_t*)OICCalloc(cred->ownersLen, sizeof(OicUuid_t));
VERIFY_NON_NULL(TAG, cred->owners, ERROR);
OICStrcpy((char *)cred->owners[0].id, sizeof(cred->owners[0].id), "ownersId11");
cred->next = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
VERIFY_NON_NULL(TAG, cred->next, ERROR);
cred->next->credId = 5678;
OICStrcpy((char *)cred->next->subject.id, sizeof(cred->next->subject.id), "subject2");
#if 0
cred->next->roleIdsLen = 0;
#endif
cred->next->credType = SYMMETRIC_PAIR_WISE_KEY;
sz = strlen("My private Key21") + 1;
cred->next->privateData.data = (char *)OICCalloc(1, sz);
VERIFY_NON_NULL(TAG, cred->next->privateData.data, ERROR);
OICStrcpy(cred->next->privateData.data, sz,"My private Key21");
#if 0
sz = strlen("My Public Key123") + 1
cred->next->publicData.data = (char *)OICCalloc(1, sz);
VERIFY_NON_NULL(TAG, cred->next->publicData.data, ERROR);
OICStrcpy(cred->next->publicData.data, sz,"My Public Key123");
#endif
cred->next->ownersLen = 2;
cred->next->owners = (OicUuid_t*)OICCalloc(cred->next->ownersLen, sizeof(OicUuid_t));
VERIFY_NON_NULL(TAG, cred->next->owners, ERROR);
OICStrcpy((char *)cred->next->owners[0].id, sizeof(cred->next->owners[0].id), "ownersId21");
OICStrcpy((char *)cred->next->owners[1].id, sizeof(cred->next->owners[1].id), "ownersId22");
return cred;
exit:
if(cred)
{
DeleteCredList(cred);
cred = NULL;
}
return cred;
}
//Cred DELETE request
TEST(CredResourceTest, CredEntityHandlerDeleteTest)
{
OCEntityHandlerRequest ehReq = OCEntityHandlerRequest();
static OCPersistentStorage ps = OCPersistentStorage();
const OicSecCred_t* subjectCred1 = NULL;
const OicSecCred_t* subjectCred2 = NULL;
OCEntityHandlerResult ehRet = OC_EH_ERROR;
char query[] = "subjectuuid=31313131-3131-3131-3131-313131313131"; //canonical uuid of subject1
SetPersistentHandler(&ps, true);
OicSecCred_t *cred = getCredList();
ASSERT_TRUE(NULL != cred);
uint8_t *payload = NULL;
size_t size = 0;
EXPECT_EQ(OC_STACK_OK, CredToCBORPayload(cred, &payload, &size));
if (!payload)
{
DeleteCredList(cred);
}
ASSERT_TRUE(NULL != payload);
// Create Entity Handler POST request payload
ehReq.method = OC_REST_POST;
ehReq.payload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
if (!ehReq.payload)
{
OICFree(payload);
DeleteCredList(cred);
}
ASSERT_TRUE( NULL != ehReq.payload);
EXPECT_EQ(OC_EH_ERROR, CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL));
// Verify if SRM contains Credential for the subject
subjectCred1 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL != subjectCred1);
// Create Entity Handler DELETE request
ehReq.method = OC_REST_DELETE;
ehReq.query = (char *)OICCalloc(1, strlen(query)+1);
if (!ehReq.query)
{
OICFree(payload);
DeleteCredList(cred);
}
ASSERT_TRUE(NULL != ehReq.query);
OICStrcpy(ehReq.query, strlen(query)+1, query);
ehRet = CredEntityHandler(OC_REQUEST_FLAG, &ehReq, NULL);
EXPECT_EQ(OC_EH_ERROR, ehRet);
// Verify if SRM has deleted ACE for the subject
subjectCred2 = GetCredResourceData(&cred->subject);
EXPECT_TRUE(NULL == subjectCred2);
// Perform cleanup
OICFree(ehReq.query);
OICFree(payload);
DeInitCredResource();
DeleteCredList(cred);
OCPayloadDestroy((OCPayload *)ehReq.payload);
}
OCStackResult SRPProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
const OCProvisionDev_t *pDev1,
const OCProvisionDev_t *pDev2,
OCProvisionResultCB resultCallback)
{
VERIFY_NON_NULL(TAG, pDev1, ERROR, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(TAG, pDev2, ERROR, OC_STACK_INVALID_PARAM);
VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
if (!(keySize == OWNER_PSK_LENGTH_128 || keySize == OWNER_PSK_LENGTH_256))
{
OC_LOG(INFO, TAG, "Invalid key size");
return OC_STACK_INVALID_PARAM;
}
OC_LOG(INFO, TAG, "In SRPProvisionCredentials");
OicUuid_t provTooldeviceID = {{0,}};
if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
{
OC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
return OC_STACK_ERROR;
}
OC_LOG(INFO, TAG, "retrieved deviceid");
switch (type)
{
case SYMMETRIC_PAIR_WISE_KEY:
{
const OCProvisionDev_t *firstDevice = pDev1;
const OCProvisionDev_t *secondDevice = pDev2;
OicSecCred_t *firstCred = NULL;
OicSecCred_t *secondCred = NULL;
OCStackResult res = PMGeneratePairWiseCredentials(type, keySize, &provTooldeviceID,
&firstDevice->doxm->deviceID, &secondDevice->doxm->deviceID,
&firstCred, &secondCred);
VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
OC_LOG(INFO, TAG, "Credentials generated successfully");
CredentialData_t *credData = (CredentialData_t *) OICMalloc(sizeof(CredentialData_t));
if (NULL == credData)
{
OC_LOG(ERROR, TAG, "Memory allocation problem");
return OC_STACK_NO_MEMORY;
}
memset(credData, 0x00, sizeof(CredentialData_t));
credData->deviceInfo1 = firstDevice;
credData->deviceInfo2 = secondDevice;
credData->credInfo = secondCred;
credData->ctx = ctx;
credData->credInfoFirst = firstCred;
credData->numOfResults = 0;
credData->resultCallback = resultCallback;
// first call to provision creds to device1.
// second call to provision creds to device2.
int noOfRiCalls = 2;
credData->resArr =
(OCProvisionResult_t*)OICMalloc(sizeof(OCProvisionResult_t) * noOfRiCalls);
if (NULL == credData->resArr)
{
OC_LOG(ERROR, TAG, "Memory allocation problem");
return OC_STACK_NO_MEMORY;
}
memset(credData->resArr, 0x00, sizeof(sizeof(OCProvisionResult_t)*noOfRiCalls));
res = provisionCredentials(firstCred, firstDevice, credData, &provisionCredentialCB1);
if (OC_STACK_OK != res)
{
DeleteCredList(firstCred);
DeleteCredList(secondCred);
OICFree(credData->resArr);
OICFree(credData);
}
OC_LOG_V(INFO, TAG, "provisionCredentials returned: %d",res);
VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
return res;
}
default:
{
OC_LOG(ERROR, TAG, "Invalid option.");
return OC_STACK_INVALID_PARAM;
}
}
return OC_STACK_ERROR;
}
