static OicSecCred_t *gCred = NULL;
static OCResourceHandle gCredHandle = NULL;
+static OicUuid_t gRownerId = { .id = { 0 } };
typedef enum CredCompareResult{
CRED_CMP_EQUAL = 0,
cbor_encoder_init(&encoder, outPayload, cborLen, 0);
- size_t credRootMapSize = (NULL == cred)? CRED_EMPTY_ROOT_MAP_SIZE : CRED_ROOT_MAP_SIZE;
+ size_t credRootMapSize = CRED_ROOT_MAP_SIZE;
// Create CRED Root Map (creds, rownerid)
cborEncoderResult = cbor_encoder_create_map(&encoder, &credRootMap, credRootMapSize);
cborEncoderResult = cbor_encode_text_string(&credRootMap, OIC_JSON_ROWNERID_NAME,
strlen(OIC_JSON_ROWNERID_NAME));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Adding rownerid Name.");
- OicUuid_t emptyUuid = { .id = { 0 } };
- const OicUuid_t* rownerID = (NULL == cred)? &emptyUuid : &cred->rownerID;
- ret = ConvertUuidToStr(rownerID, &rowner);
+ ret = ConvertUuidToStr(&gRownerId, &rowner);
VERIFY_SUCCESS(TAG, ret == OC_STACK_OK, ERROR);
cborEncoderResult = cbor_encode_text_string(&credRootMap, rowner, strlen(rowner));
VERIFY_CBOR_SUCCESS(TAG, cborEncoderResult, "Failed Addding rownerid Value.");
OICFree(rowner);
}
- if (cred != NULL)
{
//RT -- Mandatory
CborEncoder rtArray;
}
OCStackResult CBORPayloadToCred(const uint8_t *cborPayload, size_t size,
- OicSecCred_t **secCred)
+ OicSecCred_t **secCred, OicUuid_t **rownerid)
{
if (NULL == cborPayload || NULL == secCred || NULL != *secCred || 0 == size)
{
char *stRowner = NULL;
cborFindResult = cbor_value_dup_text_string(&CredRootMap, &stRowner, &len, NULL);
VERIFY_CBOR_SUCCESS(TAG, cborFindResult, "Failed Finding Rownerid Value.");
-
- ret = ConvertStrToUuid(stRowner, &headCred->rownerID);
+ *rownerid = (OicUuid_t *) OICCalloc(1, sizeof(OicUuid_t));
+ VERIFY_NOT_NULL(TAG, *rownerid, ERROR);
+ ret = ConvertStrToUuid(stRowner, *rownerid);
//Because cbor using malloc directly
//It is required to use free() instead of OICFree
free(stRowner);
VERIFY_SUCCESS(TAG, (ret == OC_STACK_OK), ERROR);
}
- else if (NULL != gCred)
- {
- memcpy(&(headCred->rownerID), &(gCred->rownerID), sizeof(OicUuid_t));
- }
//Because cbor using malloc directly
//It is required to use free() instead of OICFree
free(tagName);
{
OicSecCred_t* cred = NULL;
bool isValidCred = false;
+ OicUuid_t *rownerId = NULL;
OIC_LOG_BUFFER(DEBUG, TAG, cborPayload, size);
VERIFY_NOT_NULL(TAG, uuid, ERROR);
VERIFY_NOT_NULL(TAG, cborPayload, ERROR);
VERIFY_SUCCESS(TAG, 0 != size, ERROR);
- VERIFY_SUCCESS(TAG, OC_STACK_OK == CBORPayloadToCred(cborPayload, size, &cred), ERROR);
+ VERIFY_SUCCESS(TAG, OC_STACK_OK == CBORPayloadToCred(cborPayload, size, &cred, &rownerId), ERROR);
VERIFY_NOT_NULL(TAG, cred, ERROR);
VERIFY_NOT_NULL(TAG, cred->eownerID, ERROR);
+ VERIFY_NOT_NULL(TAG, rownerId, ERROR);
VERIFY_SUCCESS(TAG, (memcmp(cred->eownerID->id, uuid->id, sizeof(uuid->id)) == 0), ERROR);
isValidCred = true;
exit:
+ OICFree(rownerId);
DeleteCredList(cred);
return isValidCred;
{
OIC_LOG(DEBUG, TAG, "IN GenerateCredential");
+ OC_UNUSED(rownerID);
(void)publicData;
OCStackResult ret = OC_STACK_ERROR;
cred->privateData.encoding = privateData->encoding;
}
- VERIFY_NOT_NULL(TAG, rownerID, ERROR);
- memcpy(&cred->rownerID, rownerID, sizeof(OicUuid_t));
#ifdef MULTIPLE_OWNER
if(eownerID)
OIC_LOG(DEBUG, TAG, "Adding New Cred");
LL_APPEND(gCred, newCred);
- if (gCred != NULL)
- {
- OicUuid_t emptyOwner = { .id = {0} };
- if (memcmp(&(newCred->rownerID), &emptyOwner, sizeof(OicUuid_t)) != 0)
- {
- memcpy(&(gCred->rownerID), &(newCred->rownerID), sizeof(OicUuid_t));
- }
- }
saveToDB:
{
if(IsEmptyCred(cred))
{
- if(memcmp(cred->rownerID.id, emptyUuid.id, sizeof(emptyUuid.id)) != 0)
- {
- OIC_LOG(INFO, TAG, "CRED's rowner will be updated.");
- if (gCred != NULL)
- {
- memcpy(gCred->rownerID.id, cred->rownerID.id, sizeof(cred->rownerID.id));
if (UpdatePersistentStorage(gCred))
{
ret = OC_EH_CHANGED;
{
ret = OC_EH_ERROR;
}
- }
- }
- else
- {
- ret = OC_EH_ERROR;
- }
}
else
{
static uint16_t previousMsgId = 0;
// Get binary representation of cbor
OicSecCred_t *cred = NULL;
+ OicUuid_t *rownerId = NULL;
uint8_t *payload = (((OCSecurityPayload*)ehRequest->payload)->securityData);
size_t size = (((OCSecurityPayload*)ehRequest->payload)->payloadSize);
goto exit;
}
- res = CBORPayloadToCred(payload, size, &cred);
+ res = CBORPayloadToCred(payload, size, &cred, &rownerId);
if (OC_STACK_OK == res)
{
break;
}
}
+ if (OC_EH_CHANGED == ret && NULL != rownerId)
+ {
+ memcpy(&gRownerId, rownerId, sizeof(OicUuid_t));
+ }
}
exit:
+ OICFree(rownerId);
if (OC_EH_CHANGED != ret)
{
if (NULL != cred)
{
OCStackResult ret = OC_STACK_ERROR;
OicSecCred_t* cred = NULL;
+ OicUuid_t *rownerId = NULL;
//Read Cred resource from PS
uint8_t *data = NULL;
if ((ret == OC_STACK_OK) && data)
{
// Read Cred resource from PS
- ret = CBORPayloadToCred(data, size, &gCred);
+ ret = CBORPayloadToCred(data, size, &gCred, &rownerId);
#ifdef HAVE_WINDOWS_H
/* On Windows, if the credential payload isn't cleartext CBOR, it is encrypted. Decrypt and retry. */
CRYPTPROTECT_UI_FORBIDDEN,
&decryptedPayload))
{
- ret = CBORPayloadToCred(decryptedPayload.pbData, decryptedPayload.cbData, &gCred);
+ ret = CBORPayloadToCred(decryptedPayload.pbData, decryptedPayload.cbData, &gCred, &rownerId);
/* For the returned data from CryptUnprotectData, LocalFree must be used to free. Don't use OICFree. */
OICClearMemory(decryptedPayload.pbData, decryptedPayload.cbData);
}
}
- if (0 == memcmp(&gCred->rownerID, &emptyUuid, sizeof(OicUuid_t)))
+ if (NULL == rownerId || 0 == memcmp(rownerId, &emptyUuid, sizeof(OicUuid_t)))
{
- memcpy(&gCred->rownerID, &deviceID, sizeof(OicUuid_t));
+ memcpy(&gRownerId, &deviceID, sizeof(OicUuid_t));
+ }
+ else
+ {
+ memcpy(&gRownerId, rownerId, sizeof(OicUuid_t));
}
if (!UpdatePersistentStorage(gCred))
OIC_LOG(DEBUG, TAG, "OUT InitCredResource.");
OICClearMemory(data, size);
OICFree(data);
+ OICFree(rownerId);
return ret;
}
cred->credId = tmpCred->credId;
cred->credType = tmpCred->credType;
memcpy(cred->subject.id, tmpCred->subject.id , sizeof(cred->subject.id));
- memcpy(cred->rownerID.id, tmpCred->rownerID.id , sizeof(cred->rownerID.id));
if (tmpCred->period)
{
cred->period = OICStrdup(tmpCred->period);
{
ret = OC_STACK_INVALID_PARAM;
}
- if(NULL == gCred)
- {
- ret = OC_STACK_NO_RESOURCE;
- }
- if (newROwner && gCred)
+ if (newROwner)
{
- memcpy(prevId.id, gCred->rownerID.id, sizeof(prevId.id));
- memcpy(gCred->rownerID.id, newROwner->id, sizeof(newROwner->id));
+ memcpy(prevId.id, gRownerId.id, sizeof(prevId.id));
+ memcpy(gRownerId.id, newROwner->id, sizeof(newROwner->id));
VERIFY_SUCCESS(TAG, UpdatePersistentStorage(gCred), ERROR);
return ret;
exit:
- memcpy(gCred->rownerID.id, prevId.id, sizeof(prevId.id));
+ memcpy(gRownerId.id, prevId.id, sizeof(prevId.id));
return ret;
}
OCStackResult GetCredRownerId(OicUuid_t *rowneruuid)
{
- if (gCred && rowneruuid)
+ if (rowneruuid)
{
- memcpy(&(rowneruuid->id), &(gCred->rownerID.id), sizeof(rowneruuid->id));
+ memcpy(&(rowneruuid->id), &(gRownerId.id), sizeof(rowneruuid->id));
return OC_STACK_OK;
}
return OC_STACK_ERROR;
VERIFY_NOT_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_NOT_NULL(TAG, cred->next, ERROR);
cred->next->credId = 5678;
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;
OIC_LOG_V(INFO, TAG, "cred->publicData.data = %s", credTmp1->publicData.data);
}
#endif /* __WITH_DTLS__ */
- OIC_LOG_V(INFO, TAG, "cred->rownerID = %s", credTmp1->rownerID.id);
}
}
ASSERT_TRUE(NULL != payload);
OicSecCred_t *cred2 = NULL;
- EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
+ OicUuid_t *rownerId = NULL;
+ EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2, &rownerId));
OICFree(payload);
ASSERT_TRUE(cred2 != NULL);
+ ASSERT_TRUE(rownerId != NULL);
+ OICFree(rownerId);
DeleteCredList(cred2);
}
ASSERT_TRUE(NULL != payload);
OicSecCred_t *cred2 = NULL;
- EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2));
+ OicUuid_t *rownerId = NULL;
+ EXPECT_EQ(OC_STACK_OK, CBORPayloadToCred(payload, size, &cred2, &rownerId));
ASSERT_TRUE(cred2 != NULL);
ASSERT_TRUE(NULL == cred2->privateData.data);
ASSERT_TRUE(0 == cred2->privateData.len);
OICFree(payload);
+ OICFree(rownerId);
DeleteCredList(cred1);
DeleteCredList(cred2);
TEST(CredResourceTest, CBORPayloadToCredNULL)
{
OicSecCred_t *cred = NULL;
- EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
+ OicUuid_t *rownerId = NULL;
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL, 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));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, &cred, &rownerId));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, NULL, NULL));
cred = getCredList();
- EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(cborPayload, 0, &cred, &rownerId));
DeleteCredList(cred);
+ OICFree(rownerId);
OICFree(cborPayload);
}
#endif // __WITH_DTLS__ or __WITH_TLS__
TEST(CredCBORPayloadToCredTest, NullPayload)
{
- EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL));
+ EXPECT_EQ(OC_STACK_INVALID_PARAM, CBORPayloadToCred(NULL, 0, NULL, NULL));
}