| /* SPDX-License-Identifier: BSD-2-Clause */ |
| /******************************************************************************* |
| * Copyright 2018-2019, Fraunhofer SIT sponsored by Infineon Technologies AG |
| * All rights reserved. |
| ******************************************************************************/ |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #include <stdio.h> |
| |
| #include "tpm_json_serialize.h" |
| #define LOGMODULE fapijson |
| #include "util/log.h" |
| #include "util/aux_util.h" |
| |
| #define CHECK_IN_LIST(type, needle, ...) \ |
| type tab[] = { __VA_ARGS__ }; \ |
| size_t i; \ |
| for(i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) \ |
| if (needle == tab[i]) \ |
| break; \ |
| if (i == sizeof(tab) / sizeof(tab[0])) { \ |
| LOG_ERROR("Bad value"); \ |
| return TSS2_FAPI_RC_BAD_VALUE; \ |
| } |
| |
| /** Serialize a TPMS_EMPTY. |
| * |
| * @param[in] in not used. |
| * @param[in] jso not used. |
| * @retval TSS2_RC_SUCCESS is always returnde. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_EMPTY_serialize(const TPMS_EMPTY *in, json_object **jso) |
| { |
| (void)(in); |
| (void)(jso); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a pcr selection to json |
| * |
| * @param[in] sizeofSelect size of selection byte array. |
| * @param[in] pcrSelect selection array. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if sizeofSelect is too big. |
| */ |
| TSS2_RC |
| ifapi_json_pcr_select_serialize( |
| const UINT8 sizeofSelect, |
| const BYTE pcrSelect[], |
| json_object **jso) |
| { |
| if (*jso == NULL) { |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| if (sizeofSelect > TPM2_PCR_SELECT_MAX) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_PCR_SELECT_MAX)", |
| (size_t)sizeofSelect, (size_t)TPM2_PCR_SELECT_MAX); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| UINT32 i1, i2; |
| json_object *jso2; |
| for (i1 = 0; i1 < TPM2_PCR_LAST - TPM2_PCR_FIRST; i1++) { |
| i2 = i1 + TPM2_PCR_FIRST; |
| if (pcrSelect[i2 / 8] & (BYTE)(1 << (i2 % 8))) { |
| jso2 = json_object_new_int(i2); |
| return_if_null(jso2, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| json_object_array_add(*jso, jso2); |
| } |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMS_PCR_SELECT structure to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_PCR_SELECTION. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_PCR_SELECT_serialize(const TPMS_PCR_SELECT *in, |
| json_object **jso) |
| { |
| TSS2_RC r; |
| |
| r = ifapi_json_pcr_select_serialize(in->sizeofSelect, &in->pcrSelect[0], jso); |
| return_if_error(r, "Serialize pcr selection"); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| |
| /** Serialize a TPMS_PCR_SELECTION structure to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_PCR_SELECTION. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_PCR_SELECTION_serialize(const TPMS_PCR_SELECTION *in, |
| json_object **jso) |
| { |
| if (*jso == NULL) { |
| *jso = json_object_new_object(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| TSS2_RC r; |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hash, &jso2); |
| return_if_error(r, "Serialize pcr selection"); |
| |
| json_object_object_add(*jso, "hash", jso2); |
| jso2 = NULL; |
| r = ifapi_json_pcr_select_serialize(in->sizeofSelect, &in->pcrSelect[0], &jso2); |
| return_if_error(r, "Serialize pcr selection"); |
| |
| json_object_object_add(*jso, "pcrSelect", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMS_TAGGED_PCR_SELECT structure to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TAGGED_PCR_SELECT. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_TAGGED_PCR_SELECT_serialize(const TPMS_TAGGED_PCR_SELECT *in, |
| json_object **jso) |
| { |
| TSS2_RC r; |
| if (*jso == NULL) |
| *jso = json_object_new_object(); |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPM2_PT_PCR_serialize(in->tag, &jso2); |
| return_if_error(r, "Serialize pcr selection"); |
| |
| json_object_object_add(*jso, "tag", jso2); |
| jso2 = NULL; |
| r = ifapi_json_pcr_select_serialize(in->sizeofSelect, &in->pcrSelect[0], &jso2); |
| return_if_error(r, "Serialize pcr selection"); |
| |
| json_object_object_add(*jso, "pcrSelect", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a base_type UINT16 to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type UINT16. |
| */ |
| TSS2_RC |
| ifapi_json_UINT16_serialize(const UINT16 in, json_object **jso) |
| { |
| *jso = json_object_new_int64(in); |
| if (*jso == NULL) { |
| LOG_ERROR("Bad value %04"PRIx16"", in); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a base_type UINT32 to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type UINT32. |
| */ |
| TSS2_RC |
| ifapi_json_UINT32_serialize(const UINT32 in, json_object **jso) |
| { |
| *jso = json_object_new_int64(in); |
| if (*jso == NULL) { |
| LOG_ERROR("Bad value %"PRIx32 "", in); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a base_type INT32 to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type INT32. |
| */ |
| TSS2_RC |
| ifapi_json_INT32_serialize(const INT32 in, json_object **jso) |
| { |
| *jso = json_object_new_int64(in); |
| if (*jso == NULL) { |
| LOG_ERROR("Bad value %"PRIi32 "", in); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a base_type UINT64 to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type UINT64. |
| */ |
| TSS2_RC |
| ifapi_json_UINT64_serialize(UINT64 in, json_object **jso) |
| { |
| json_object *jso1 = NULL, *jso2 = NULL; |
| if (in < 0x1000000000000) { |
| *jso = json_object_new_int64(in); |
| if (*jso == NULL) { |
| LOG_ERROR("Bad value %"PRIu32 "", (uint32_t)in); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| jso1 = json_object_new_int64(in / 0x100000000); |
| return_if_null(jso1, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| in %= 0x100000000; |
| |
| jso2 = json_object_new_int64(in); |
| if (!jso2) json_object_put(jso1); |
| return_if_null(jso2, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| *jso = json_object_new_array(); |
| if (!*jso) json_object_put(jso1); |
| if (!*jso) json_object_put(jso2); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_array_add(*jso, jso1); |
| json_object_array_add(*jso, jso2); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPM2_GENERATED to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_GENERATED. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_GENERATED_serialize(const TPM2_GENERATED in, json_object **jso) |
| { |
| if (in != TPM2_GENERATED_VALUE) { |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| *jso = json_object_new_string("VALUE"); |
| check_oom(*jso); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPM2_ALG_ID to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_ALG_ID. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_ALG_ID_serialize(const TPM2_ALG_ID in, json_object **jso) |
| { |
| static const struct { TPM2_ALG_ID in; const char *name; } tab[] = { |
| { TPM2_ALG_ERROR, "ERROR" }, |
| { TPM2_ALG_RSA, "RSA" }, |
| { TPM2_ALG_TDES, "TDES" }, |
| /* We prefer SHA1 as output over SHA */ |
| /* { TPM2_ALG_SHA, "SHA" },*/ |
| { TPM2_ALG_SHA1, "SHA1" }, |
| { TPM2_ALG_CMAC, "CMAC" }, |
| { TPM2_ALG_HMAC, "HMAC" }, |
| { TPM2_ALG_AES, "AES" }, |
| { TPM2_ALG_MGF1, "MGF1" }, |
| { TPM2_ALG_KEYEDHASH, "KEYEDHASH" }, |
| { TPM2_ALG_XOR, "XOR" }, |
| { TPM2_ALG_SHA256, "SHA256" }, |
| { TPM2_ALG_SHA384, "SHA384" }, |
| { TPM2_ALG_SHA512, "SHA512" }, |
| { TPM2_ALG_NULL, "NULL" }, |
| { TPM2_ALG_SM3_256, "SM3_256" }, |
| { TPM2_ALG_SM4, "SM4" }, |
| { TPM2_ALG_RSASSA, "RSASSA" }, |
| { TPM2_ALG_RSAES, "RSAES" }, |
| { TPM2_ALG_RSAPSS, "RSAPSS" }, |
| { TPM2_ALG_OAEP, "OAEP" }, |
| { TPM2_ALG_ECDSA, "ECDSA" }, |
| { TPM2_ALG_ECDH, "ECDH" }, |
| { TPM2_ALG_ECDAA, "ECDAA" }, |
| { TPM2_ALG_SM2, "SM2" }, |
| { TPM2_ALG_ECSCHNORR, "ECSCHNORR" }, |
| { TPM2_ALG_ECMQV, "ECMQV" }, |
| { TPM2_ALG_KDF1_SP800_56A, "KDF1_SP800_56A" }, |
| { TPM2_ALG_KDF2, "KDF2" }, |
| { TPM2_ALG_KDF1_SP800_108, "KDF1_SP800_108" }, |
| { TPM2_ALG_ECC, "ECC" }, |
| { TPM2_ALG_SYMCIPHER, "SYMCIPHER" }, |
| { TPM2_ALG_CAMELLIA, "CAMELLIA" }, |
| { TPM2_ALG_CTR, "CTR" }, |
| { TPM2_ALG_OFB, "OFB" }, |
| { TPM2_ALG_CBC, "CBC" }, |
| { TPM2_ALG_CFB, "CFB" }, |
| { TPM2_ALG_ECB, "ECB" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize TPM2_ECC_CURVE to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_ECC_CURVE. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_ECC_CURVE_serialize(const TPM2_ECC_CURVE in, json_object **jso) |
| { |
| static const struct { TPM2_ECC_CURVE in; char *name; } tab[] = { |
| { TPM2_ECC_NONE, "NONE" }, |
| { TPM2_ECC_NIST_P192, "NIST_P192" }, |
| { TPM2_ECC_NIST_P224, "NIST_P224" }, |
| { TPM2_ECC_NIST_P256, "NIST_P256" }, |
| { TPM2_ECC_NIST_P384, "NIST_P384" }, |
| { TPM2_ECC_NIST_P521, "NIST_P521" }, |
| { TPM2_ECC_BN_P256, "BN_P256" }, |
| { TPM2_ECC_BN_P638, "BN_P638" }, |
| { TPM2_ECC_SM2_P256, "SM2_P256" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize TPM2_CC to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_CC. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_CC_serialize(const TPM2_CC in, json_object **jso) |
| { |
| static const struct { TPM2_CC in; char *name; } tab[] = { |
| /* We don't want to return FIRST but the actual value */ |
| /* { TPM2_CC_FIRST, "FIRST" }, */ |
| { TPM2_CC_NV_UndefineSpaceSpecial, "NV_UndefineSpaceSpecial" }, |
| { TPM2_CC_EvictControl, "EvictControl" }, |
| { TPM2_CC_HierarchyControl, "HierarchyControl" }, |
| { TPM2_CC_NV_UndefineSpace, "NV_UndefineSpace" }, |
| { TPM2_CC_ChangeEPS, "ChangeEPS" }, |
| { TPM2_CC_ChangePPS, "ChangePPS" }, |
| { TPM2_CC_Clear, "Clear" }, |
| { TPM2_CC_ClearControl, "ClearControl" }, |
| { TPM2_CC_ClockSet, "ClockSet" }, |
| { TPM2_CC_HierarchyChangeAuth, "HierarchyChangeAuth" }, |
| { TPM2_CC_NV_DefineSpace, "NV_DefineSpace" }, |
| { TPM2_CC_PCR_Allocate, "PCR_Allocate" }, |
| { TPM2_CC_PCR_SetAuthPolicy, "PCR_SetAuthPolicy" }, |
| { TPM2_CC_PP_Commands, "PP_Commands" }, |
| { TPM2_CC_SetPrimaryPolicy, "SetPrimaryPolicy" }, |
| { TPM2_CC_FieldUpgradeStart, "FieldUpgradeStart" }, |
| { TPM2_CC_ClockRateAdjust, "ClockRateAdjust" }, |
| { TPM2_CC_CreatePrimary, "CreatePrimary" }, |
| { TPM2_CC_NV_GlobalWriteLock, "NV_GlobalWriteLock" }, |
| { TPM2_CC_GetCommandAuditDigest, "GetCommandAuditDigest" }, |
| { TPM2_CC_NV_Increment, "NV_Increment" }, |
| { TPM2_CC_NV_SetBits, "NV_SetBits" }, |
| { TPM2_CC_NV_Extend, "NV_Extend" }, |
| { TPM2_CC_NV_Write, "NV_Write" }, |
| { TPM2_CC_NV_WriteLock, "NV_WriteLock" }, |
| { TPM2_CC_DictionaryAttackLockReset, "DictionaryAttackLockReset" }, |
| { TPM2_CC_DictionaryAttackParameters, "DictionaryAttackParameters" }, |
| { TPM2_CC_NV_ChangeAuth, "NV_ChangeAuth" }, |
| { TPM2_CC_PCR_Event, "PCR_Event" }, |
| { TPM2_CC_PCR_Reset, "PCR_Reset" }, |
| { TPM2_CC_SequenceComplete, "SequenceComplete" }, |
| { TPM2_CC_SetAlgorithmSet, "SetAlgorithmSet" }, |
| { TPM2_CC_SetCommandCodeAuditStatus, "SetCommandCodeAuditStatus" }, |
| { TPM2_CC_FieldUpgradeData, "FieldUpgradeData" }, |
| { TPM2_CC_IncrementalSelfTest, "IncrementalSelfTest" }, |
| { TPM2_CC_SelfTest, "SelfTest" }, |
| { TPM2_CC_Startup, "Startup" }, |
| { TPM2_CC_Shutdown, "Shutdown" }, |
| { TPM2_CC_StirRandom, "StirRandom" }, |
| { TPM2_CC_ActivateCredential, "ActivateCredential" }, |
| { TPM2_CC_Certify, "Certify" }, |
| { TPM2_CC_PolicyNV, "PolicyNV" }, |
| { TPM2_CC_CertifyCreation, "CertifyCreation" }, |
| { TPM2_CC_Duplicate, "Duplicate" }, |
| { TPM2_CC_GetTime, "GetTime" }, |
| { TPM2_CC_GetSessionAuditDigest, "GetSessionAuditDigest" }, |
| { TPM2_CC_NV_Read, "NV_Read" }, |
| { TPM2_CC_NV_ReadLock, "NV_ReadLock" }, |
| { TPM2_CC_ObjectChangeAuth, "ObjectChangeAuth" }, |
| { TPM2_CC_PolicySecret, "PolicySecret" }, |
| { TPM2_CC_Rewrap, "Rewrap" }, |
| { TPM2_CC_Create, "Create" }, |
| { TPM2_CC_ECDH_ZGen, "ECDH_ZGen" }, |
| { TPM2_CC_HMAC, "HMAC" }, |
| { TPM2_CC_Import, "Import" }, |
| { TPM2_CC_Load, "Load" }, |
| { TPM2_CC_Quote, "Quote" }, |
| { TPM2_CC_RSA_Decrypt, "RSA_Decrypt" }, |
| { TPM2_CC_HMAC_Start, "HMAC_Start" }, |
| { TPM2_CC_SequenceUpdate, "SequenceUpdate" }, |
| { TPM2_CC_Sign, "Sign" }, |
| { TPM2_CC_Unseal, "Unseal" }, |
| { TPM2_CC_PolicySigned, "PolicySigned" }, |
| { TPM2_CC_ContextLoad, "ContextLoad" }, |
| { TPM2_CC_ContextSave, "ContextSave" }, |
| { TPM2_CC_ECDH_KeyGen, "ECDH_KeyGen" }, |
| { TPM2_CC_EncryptDecrypt, "EncryptDecrypt" }, |
| { TPM2_CC_FlushContext, "FlushContext" }, |
| { TPM2_CC_LoadExternal, "LoadExternal" }, |
| { TPM2_CC_MakeCredential, "MakeCredential" }, |
| { TPM2_CC_NV_ReadPublic, "NV_ReadPublic" }, |
| { TPM2_CC_PolicyAuthorize, "PolicyAuthorize" }, |
| { TPM2_CC_PolicyAuthValue, "PolicyAuthValue" }, |
| { TPM2_CC_PolicyCommandCode, "PolicyCommandCode" }, |
| { TPM2_CC_PolicyCounterTimer, "PolicyCounterTimer" }, |
| { TPM2_CC_PolicyCpHash, "PolicyCpHash" }, |
| { TPM2_CC_PolicyLocality, "PolicyLocality" }, |
| { TPM2_CC_PolicyNameHash, "PolicyNameHash" }, |
| { TPM2_CC_PolicyOR, "PolicyOR" }, |
| { TPM2_CC_PolicyTicket, "PolicyTicket" }, |
| { TPM2_CC_ReadPublic, "ReadPublic" }, |
| { TPM2_CC_RSA_Encrypt, "RSA_Encrypt" }, |
| { TPM2_CC_StartAuthSession, "StartAuthSession" }, |
| { TPM2_CC_VerifySignature, "VerifySignature" }, |
| { TPM2_CC_ECC_Parameters, "ECC_Parameters" }, |
| { TPM2_CC_FirmwareRead, "FirmwareRead" }, |
| { TPM2_CC_GetCapability, "GetCapability" }, |
| { TPM2_CC_GetRandom, "GetRandom" }, |
| { TPM2_CC_GetTestResult, "GetTestResult" }, |
| { TPM2_CC_Hash, "Hash" }, |
| { TPM2_CC_PCR_Read, "PCR_Read" }, |
| { TPM2_CC_PolicyPCR, "PolicyPCR" }, |
| { TPM2_CC_PolicyRestart, "PolicyRestart" }, |
| { TPM2_CC_ReadClock, "ReadClock" }, |
| { TPM2_CC_PCR_Extend, "PCR_Extend" }, |
| { TPM2_CC_PCR_SetAuthValue, "PCR_SetAuthValue" }, |
| { TPM2_CC_NV_Certify, "NV_Certify" }, |
| { TPM2_CC_EventSequenceComplete, "EventSequenceComplete" }, |
| { TPM2_CC_HashSequenceStart, "HashSequenceStart" }, |
| { TPM2_CC_PolicyPhysicalPresence, "PolicyPhysicalPresence" }, |
| { TPM2_CC_PolicyDuplicationSelect, "PolicyDuplicationSelect" }, |
| { TPM2_CC_PolicyGetDigest, "PolicyGetDigest" }, |
| { TPM2_CC_TestParms, "TestParms" }, |
| { TPM2_CC_Commit, "Commit" }, |
| { TPM2_CC_PolicyPassword, "PolicyPassword" }, |
| { TPM2_CC_ZGen_2Phase, "ZGen_2Phase" }, |
| { TPM2_CC_EC_Ephemeral, "EC_Ephemeral" }, |
| { TPM2_CC_PolicyNvWritten, "PolicyNvWritten" }, |
| { TPM2_CC_PolicyTemplate, "PolicyTemplate" }, |
| { TPM2_CC_CreateLoaded, "CreateLoaded" }, |
| { TPM2_CC_PolicyAuthorizeNV, "PolicyAuthorizeNV" }, |
| { TPM2_CC_EncryptDecrypt2, "EncryptDecrypt2" }, |
| /* We don't want to return LAST but the actual value */ |
| /* { TPM2_CC_LAST, "LAST" }, */ |
| { TPM2_CC_Vendor_TCG_Test, "Vendor_TCG_Test" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize TPM2_EO to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_EO. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_EO_serialize(const TPM2_EO in, json_object **jso) |
| { |
| static const struct { TPM2_EO in; char *name; } tab[] = { |
| { TPM2_EO_EQ, "EQ" }, |
| { TPM2_EO_NEQ, "TPM2_EO_NEQ" }, |
| { TPM2_EO_SIGNED_GT, "SIGNED_GT" }, |
| { TPM2_EO_UNSIGNED_GT, "UNSIGNED_GT" }, |
| { TPM2_EO_SIGNED_LT, "SIGNED_LT" }, |
| { TPM2_EO_UNSIGNED_LT, "UNSIGNED_LT" }, |
| { TPM2_EO_SIGNED_GE, "SIGNED_GE" }, |
| { TPM2_EO_UNSIGNED_GE, "UNSIGNED_GE" }, |
| { TPM2_EO_SIGNED_LE, "SIGNED_LE" }, |
| { TPM2_EO_UNSIGNED_LE, "UNSIGNED_LE" }, |
| { TPM2_EO_BITSET, "BITSET" }, |
| { TPM2_EO_BITCLEAR, "BITCLEAR" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize TPM2_ST to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_ST. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_ST_serialize(const TPM2_ST in, json_object **jso) |
| { |
| static const struct { TPM2_ST in; char *name; } tab[] = { |
| { TPM2_ST_RSP_COMMAND, "RSP_COMMAND" }, |
| { TPM2_ST_NULL, "NULL" }, |
| { TPM2_ST_NO_SESSIONS, "NO_SESSIONS" }, |
| { TPM2_ST_SESSIONS, "SESSIONS" }, |
| { TPM2_ST_ATTEST_NV, "ATTEST_NV" }, |
| { TPM2_ST_ATTEST_COMMAND_AUDIT, "ATTEST_COMMAND_AUDIT" }, |
| { TPM2_ST_ATTEST_SESSION_AUDIT, "ATTEST_SESSION_AUDIT" }, |
| { TPM2_ST_ATTEST_CERTIFY, "ATTEST_CERTIFY" }, |
| { TPM2_ST_ATTEST_QUOTE, "ATTEST_QUOTE" }, |
| { TPM2_ST_ATTEST_TIME, "ATTEST_TIME" }, |
| { TPM2_ST_ATTEST_CREATION, "ATTEST_CREATION" }, |
| { TPM2_ST_CREATION, "CREATION" }, |
| { TPM2_ST_VERIFIED, "VERIFIED" }, |
| { TPM2_ST_AUTH_SECRET, "AUTH_SECRET" }, |
| { TPM2_ST_HASHCHECK, "HASHCHECK" }, |
| { TPM2_ST_AUTH_SIGNED, "AUTH_SIGNED" }, |
| { TPM2_ST_FU_MANIFEST, "FU_MANIFEST" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize TPM2_CAP to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_CAP. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_CAP_serialize(const TPM2_CAP in, json_object **jso) |
| { |
| static const struct { TPM2_CAP in; char *name; } tab[] = { |
| { TPM2_CAP_ALGS, "ALGS" }, |
| { TPM2_CAP_HANDLES, "HANDLES" }, |
| { TPM2_CAP_COMMANDS, "COMMANDS" }, |
| { TPM2_CAP_PP_COMMANDS, "PP_COMMANDS" }, |
| { TPM2_CAP_AUDIT_COMMANDS, "AUDIT_COMMANDS" }, |
| { TPM2_CAP_PCRS, "PCRS" }, |
| { TPM2_CAP_TPM_PROPERTIES, "TPM_PROPERTIES" }, |
| { TPM2_CAP_PCR_PROPERTIES, "PCR_PROPERTIES" }, |
| { TPM2_CAP_ECC_CURVES, "ECC_CURVES" }, |
| { TPM2_CAP_LAST, "LAST" }, |
| { TPM2_CAP_VENDOR_PROPERTY, "VENDOR_PROPERTY" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize TPM2_PT to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_PT. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_PT_serialize(const TPM2_PT in, json_object **jso) |
| { |
| static const struct { TPM2_PT in; char *name; } tab[] = { |
| { TPM2_PT_NONE, "NONE" }, |
| { TPM2_PT_GROUP, "GROUP" }, |
| //{ TPM2_PT_FIXED, "FIXED" }, |
| { TPM2_PT_FAMILY_INDICATOR, "FAMILY_INDICATOR" }, |
| { TPM2_PT_LEVEL, "LEVEL" }, |
| { TPM2_PT_REVISION, "REVISION" }, |
| { TPM2_PT_DAY_OF_YEAR, "DAY_OF_YEAR" }, |
| { TPM2_PT_YEAR, "YEAR" }, |
| { TPM2_PT_MANUFACTURER, "MANUFACTURER" }, |
| { TPM2_PT_VENDOR_STRING_1, "VENDOR_STRING_1" }, |
| { TPM2_PT_VENDOR_STRING_2, "VENDOR_STRING_2" }, |
| { TPM2_PT_VENDOR_STRING_3, "VENDOR_STRING_3" }, |
| { TPM2_PT_VENDOR_STRING_4, "VENDOR_STRING_4" }, |
| { TPM2_PT_VENDOR_TPM_TYPE, "VENDOR_TPM_TYPE" }, |
| { TPM2_PT_FIRMWARE_VERSION_1, "FIRMWARE_VERSION_1" }, |
| { TPM2_PT_FIRMWARE_VERSION_2, "FIRMWARE_VERSION_2" }, |
| { TPM2_PT_INPUT_BUFFER, "INPUT_BUFFER" }, |
| { TPM2_PT_HR_TRANSIENT_MIN, "HR_TRANSIENT_MIN" }, |
| { TPM2_PT_HR_PERSISTENT_MIN, "HR_PERSISTENT_MIN" }, |
| { TPM2_PT_HR_LOADED_MIN, "HR_LOADED_MIN" }, |
| { TPM2_PT_ACTIVE_SESSIONS_MAX, "ACTIVE_SESSIONS_MAX" }, |
| { TPM2_PT_PCR_COUNT, "PCR_COUNT" }, |
| { TPM2_PT_PCR_SELECT_MIN, "PCR_SELECT_MIN" }, |
| { TPM2_PT_CONTEXT_GAP_MAX, "CONTEXT_GAP_MAX" }, |
| { TPM2_PT_NV_COUNTERS_MAX, "NV_COUNTERS_MAX" }, |
| { TPM2_PT_NV_INDEX_MAX, "NV_INDEX_MAX" }, |
| { TPM2_PT_MEMORY, "MEMORY" }, |
| { TPM2_PT_CLOCK_UPDATE, "CLOCK_UPDATE" }, |
| { TPM2_PT_CONTEXT_HASH, "CONTEXT_HASH" }, |
| { TPM2_PT_CONTEXT_SYM, "CONTEXT_SYM" }, |
| { TPM2_PT_CONTEXT_SYM_SIZE, "CONTEXT_SYM_SIZE" }, |
| { TPM2_PT_ORDERLY_COUNT, "ORDERLY_COUNT" }, |
| { TPM2_PT_MAX_COMMAND_SIZE, "MAX_COMMAND_SIZE" }, |
| { TPM2_PT_MAX_RESPONSE_SIZE, "MAX_RESPONSE_SIZE" }, |
| { TPM2_PT_MAX_DIGEST, "MAX_DIGEST" }, |
| { TPM2_PT_MAX_OBJECT_CONTEXT, "MAX_OBJECT_CONTEXT" }, |
| { TPM2_PT_MAX_SESSION_CONTEXT, "MAX_SESSION_CONTEXT" }, |
| { TPM2_PT_PS_FAMILY_INDICATOR, "PS_FAMILY_INDICATOR" }, |
| { TPM2_PT_PS_LEVEL, "PS_LEVEL" }, |
| { TPM2_PT_PS_REVISION, "PS_REVISION" }, |
| { TPM2_PT_PS_DAY_OF_YEAR, "PS_DAY_OF_YEAR" }, |
| { TPM2_PT_PS_YEAR, "PS_YEAR" }, |
| { TPM2_PT_SPLIT_MAX, "SPLIT_MAX" }, |
| { TPM2_PT_TOTAL_COMMANDS, "TOTAL_COMMANDS" }, |
| { TPM2_PT_LIBRARY_COMMANDS, "LIBRARY_COMMANDS" }, |
| { TPM2_PT_VENDOR_COMMANDS, "VENDOR_COMMANDS" }, |
| { TPM2_PT_NV_BUFFER_MAX, "NV_BUFFER_MAX" }, |
| { TPM2_PT_MODES, "MODES" }, |
| { TPM2_PT_MAX_CAP_BUFFER, "MAX_CAP_BUFFER" }, |
| //{ TPM2_PT_VAR, "VAR" }, |
| { TPM2_PT_PERMANENT, "PERMANENT" }, |
| { TPM2_PT_STARTUP_CLEAR, "STARTUP_CLEAR" }, |
| { TPM2_PT_HR_NV_INDEX, "HR_NV_INDEX" }, |
| { TPM2_PT_HR_LOADED, "HR_LOADED" }, |
| { TPM2_PT_HR_LOADED_AVAIL, "HR_LOADED_AVAIL" }, |
| { TPM2_PT_HR_ACTIVE, "HR_ACTIVE" }, |
| { TPM2_PT_HR_ACTIVE_AVAIL, "HR_ACTIVE_AVAIL" }, |
| { TPM2_PT_HR_TRANSIENT_AVAIL, "HR_TRANSIENT_AVAIL" }, |
| { TPM2_PT_HR_PERSISTENT, "HR_PERSISTENT" }, |
| { TPM2_PT_HR_PERSISTENT_AVAIL, "HR_PERSISTENT_AVAIL" }, |
| { TPM2_PT_NV_COUNTERS, "NV_COUNTERS" }, |
| { TPM2_PT_NV_COUNTERS_AVAIL, "NV_COUNTERS_AVAIL" }, |
| { TPM2_PT_ALGORITHM_SET, "ALGORITHM_SET" }, |
| { TPM2_PT_LOADED_CURVES, "LOADED_CURVES" }, |
| { TPM2_PT_LOCKOUT_COUNTER, "LOCKOUT_COUNTER" }, |
| { TPM2_PT_MAX_AUTH_FAIL, "MAX_AUTH_FAIL" }, |
| { TPM2_PT_LOCKOUT_INTERVAL, "LOCKOUT_INTERVAL" }, |
| { TPM2_PT_LOCKOUT_RECOVERY, "LOCKOUT_RECOVERY" }, |
| { TPM2_PT_NV_WRITE_RECOVERY, "NV_WRITE_RECOVERY" }, |
| { TPM2_PT_AUDIT_COUNTER_0, "AUDIT_COUNTER_0" }, |
| { TPM2_PT_AUDIT_COUNTER_1, "AUDIT_COUNTER_1" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error2(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant: %"PRIx32, in); |
| } |
| |
| /** Serialize TPM2_PT_PCR to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_PT_PCR. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_PT_PCR_serialize(const TPM2_PT_PCR in, json_object **jso) |
| { |
| static const struct { TPM2_PT_PCR in; char *name; } tab[] = { |
| { TPM2_PT_PCR_SAVE, "SAVE" }, |
| { TPM2_PT_PCR_EXTEND_L0, "EXTEND_L0" }, |
| { TPM2_PT_PCR_RESET_L0, "RESET_L0" }, |
| { TPM2_PT_PCR_EXTEND_L1, "EXTEND_L1" }, |
| { TPM2_PT_PCR_RESET_L1, "RESET_L1" }, |
| { TPM2_PT_PCR_EXTEND_L2, "EXTEND_L2" }, |
| { TPM2_PT_PCR_RESET_L2, "RESET_L2" }, |
| { TPM2_PT_PCR_EXTEND_L3, "EXTEND_L3" }, |
| { TPM2_PT_PCR_RESET_L3, "RESET_L3" }, |
| { TPM2_PT_PCR_EXTEND_L4, "EXTEND_L4" }, |
| { TPM2_PT_PCR_RESET_L4, "RESET_L4" }, |
| { TPM2_PT_PCR_NO_INCREMENT, "NO_INCREMENT" }, |
| { TPM2_PT_PCR_DRTM_RESET, "DRTM_RESET" }, |
| { TPM2_PT_PCR_POLICY, "POLICY" }, |
| { TPM2_PT_PCR_AUTH, "AUTH" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error2(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant: %"PRIx32, in); |
| } |
| |
| /** Serialize value of type TPM2_HANDLE to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2_HANDLE. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_HANDLE_serialize(const TPM2_HANDLE in, json_object **jso) |
| { |
| *jso = json_object_new_int(in); |
| if (*jso == NULL) { |
| LOG_ERROR("Bad value %"PRIx32 "", in); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| /** Serialize a TPMA_ALGORITHM to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_ALGORITHM. |
| */ |
| TSS2_RC |
| ifapi_json_TPMA_ALGORITHM_serialize(const TPMA_ALGORITHM in, json_object **jso) |
| { |
| static const struct { TPMA_ALGORITHM in; char *name; } tab[] = { |
| { TPMA_ALGORITHM_ASYMMETRIC, "asymmetric" }, |
| { TPMA_ALGORITHM_SYMMETRIC, "symmetric" }, |
| { TPMA_ALGORITHM_HASH, "hash" }, |
| { TPMA_ALGORITHM_OBJECT, "object" }, |
| { TPMA_ALGORITHM_SIGNING, "signing" }, |
| { TPMA_ALGORITHM_ENCRYPTING, "encrypting" }, |
| { TPMA_ALGORITHM_METHOD, "method" }, |
| }; |
| |
| UINT32 input; |
| input = (UINT32) in; |
| json_object *jso_bit; |
| if (*jso == NULL) { |
| *jso = json_object_new_object(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in & input) |
| jso_bit = json_object_new_int(1); |
| else |
| jso_bit = json_object_new_int(0); |
| return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, tab[i].name, jso_bit); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMA_OBJECT to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_OBJECT. |
| */ |
| TSS2_RC |
| ifapi_json_TPMA_OBJECT_serialize(const TPMA_OBJECT in, json_object **jso) |
| { |
| static const struct { TPMA_OBJECT in; char *name; } tab[] = { |
| { TPMA_OBJECT_FIXEDTPM, "fixedTPM" }, |
| { TPMA_OBJECT_STCLEAR, "stClear" }, |
| { TPMA_OBJECT_FIXEDPARENT, "fixedParent" }, |
| { TPMA_OBJECT_SENSITIVEDATAORIGIN, "sensitiveDataOrigin" }, |
| { TPMA_OBJECT_USERWITHAUTH, "userWithAuth" }, |
| { TPMA_OBJECT_ADMINWITHPOLICY, "adminWithPolicy" }, |
| { TPMA_OBJECT_NODA, "noDA" }, |
| { TPMA_OBJECT_ENCRYPTEDDUPLICATION, "encryptedDuplication" }, |
| { TPMA_OBJECT_RESTRICTED, "restricted" }, |
| { TPMA_OBJECT_DECRYPT, "decrypt" }, |
| { TPMA_OBJECT_SIGN_ENCRYPT, "sign" }, |
| }; |
| UINT32 input; |
| input = (UINT32) in; |
| json_object *jso_bit; |
| if (*jso == NULL) { |
| *jso = json_object_new_object(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in & input) |
| jso_bit = json_object_new_int(1); |
| else |
| jso_bit = json_object_new_int(0); |
| return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, tab[i].name, jso_bit); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMA_LOCALITY to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_LOCALITY. |
| */ |
| TSS2_RC |
| ifapi_json_TPMA_LOCALITY_serialize(const TPMA_LOCALITY in, json_object **jso) |
| { |
| static const struct { TPMA_LOCALITY in; char *name; } tab[] = { |
| { TPMA_LOCALITY_TPM2_LOC_ZERO, "ZERO" }, |
| { TPMA_LOCALITY_TPM2_LOC_ONE, "ONE" }, |
| { TPMA_LOCALITY_TPM2_LOC_TWO, "TWO" }, |
| { TPMA_LOCALITY_TPM2_LOC_THREE, "THREE" }, |
| { TPMA_LOCALITY_TPM2_LOC_FOUR, "FOUR" }, |
| }; |
| |
| UINT8 input; |
| input = (UINT8) in; |
| json_object *jso_bit; |
| json_object *jso_bit_idx; |
| if (*jso == NULL) { |
| *jso = json_object_new_object(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in & input) |
| jso_bit = json_object_new_int(1); |
| else |
| jso_bit = json_object_new_int(0); |
| return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, tab[i].name, jso_bit); |
| } |
| jso_bit_idx = json_object_new_int64((TPMA_LOCALITY_EXTENDED_MASK & input) >> |
| 5); |
| return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, "Extended", jso_bit_idx); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMA_CC to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_CC. |
| */ |
| TSS2_RC |
| ifapi_json_TPMA_CC_serialize(const TPMA_CC in, json_object **jso) |
| { |
| static const struct { TPMA_CC in; char *name; } tab[] = { |
| { TPMA_CC_NV, "nv" }, |
| { TPMA_CC_EXTENSIVE, "extensive" }, |
| { TPMA_CC_FLUSHED, "flushed" }, |
| { TPMA_CC_RHANDLE, "rHandle" }, |
| { TPMA_CC_V, "V" }, |
| }; |
| TPM2_CC input; |
| input = (TPM2_CC) in; |
| json_object *jso_bit; |
| json_object *jso_bit_idx; |
| if (*jso == NULL) { |
| *jso = json_object_new_object(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in & input) |
| jso_bit = json_object_new_int(1); |
| else |
| jso_bit = json_object_new_int(0); |
| return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, tab[i].name, jso_bit); |
| } |
| jso_bit_idx = json_object_new_int64((TPMA_CC_COMMANDINDEX_MASK & input) >> 0); |
| return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, "commandIndex", jso_bit_idx); |
| |
| jso_bit_idx = json_object_new_int64((TPMA_CC_CHANDLES_MASK & input) >> 25); |
| return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, "cHandles", jso_bit_idx); |
| |
| jso_bit_idx = json_object_new_int64((TPMA_CC_RES_MASK & input) >> 30); |
| return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, "Res", jso_bit_idx); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_YES_NO to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_YES_NO_serialize(const TPMI_YES_NO in, json_object **jso) |
| { |
| if (in == YES) { |
| *jso = json_object_new_string("YES"); |
| } else if (in == NO) { |
| *jso = json_object_new_string("NO"); |
| } else { |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_RH_HIERARCHY to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_RH_HIERARCHY_serialize(const TPMI_RH_HIERARCHY in, |
| json_object **jso) |
| { |
| static const struct { TPMI_RH_HIERARCHY in; char *name; } tab[] = { |
| { TPM2_RH_OWNER, "OWNER" }, |
| { TPM2_RH_PLATFORM, "PLATFORM" }, |
| { TPM2_RH_ENDORSEMENT, "ENDORSEMENT" }, |
| { TPM2_RH_NULL, "NULL" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize value of type TPMI_RH_NV_INDEX to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_RH_NV_INDEX. |
| * |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_RH_NV_INDEX_serialize(const TPMI_RH_NV_INDEX in, |
| json_object **jso) |
| { |
| if (in >= TPM2_NV_INDEX_FIRST && in <= TPM2_NV_INDEX_LAST) { |
| *jso = json_object_new_int64(in); |
| } else { |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ALG_HASH to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_HASH_serialize(const TPMI_ALG_HASH in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_HASH, in, TPM2_ALG_SHA1, TPM2_ALG_SHA256, TPM2_ALG_SHA384, |
| TPM2_ALG_SHA512, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize TPMI_ALG_SYM_OBJECT to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_SYM_OBJECT_serialize(const TPMI_ALG_SYM_OBJECT in, |
| json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_SYM_OBJECT, in, TPM2_ALG_AES, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize TPMI_ALG_SYM_MODE to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_SYM_MODE_serialize(const TPMI_ALG_SYM_MODE in, |
| json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_SYM_MODE, in, TPM2_ALG_CTR, TPM2_ALG_OFB, |
| TPM2_ALG_CBC, TPM2_ALG_CFB, TPM2_ALG_ECB, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize TPMI_ALG_KDF to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_KDF_serialize(const TPMI_ALG_KDF in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_KDF, in, TPM2_ALG_MGF1, TPM2_ALG_KDF1_SP800_56A, |
| TPM2_ALG_KDF1_SP800_108, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize TPMI_ALG_SIG_SCHEME to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(const TPMI_ALG_SIG_SCHEME in, |
| json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_SIG_SCHEME, in, TPM2_ALG_RSASSA, TPM2_ALG_RSAPSS, |
| TPM2_ALG_ECDSA, TPM2_ALG_ECDAA, TPM2_ALG_SM2, TPM2_ALG_ECSCHNORR, |
| TPM2_ALG_HMAC, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_HA to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the HA object. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_HA. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_HA_serialize(const TPMU_HA *in, UINT32 selector, |
| json_object **jso) |
| { |
| size_t size; |
| const uint8_t *buffer; |
| |
| switch (selector) { |
| case TPM2_ALG_SHA1: |
| size = TPM2_SHA1_DIGEST_SIZE; |
| buffer = &in->sha1[0]; |
| break; |
| case TPM2_ALG_SHA256: |
| size = TPM2_SHA256_DIGEST_SIZE; |
| buffer = &in->sha256[0]; |
| break; |
| case TPM2_ALG_SHA384: |
| size = TPM2_SHA384_DIGEST_SIZE; |
| buffer = &in->sha384[0]; |
| break; |
| case TPM2_ALG_SHA512: |
| size = TPM2_SHA512_DIGEST_SIZE; |
| buffer = &in->sha512[0]; |
| break; |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| char hex_string[(size) * 2 + 1]; |
| for (size_t i = 0, off = 0; i < size; i++, off += 2) |
| sprintf(&hex_string[off], "%02x", buffer[i]); |
| hex_string[(size) * 2] = '\0'; |
| *jso = json_object_new_string(hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_HA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_HA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_HA_serialize(const TPMT_HA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object(); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "hashAlg", jso2); |
| if (in->hashAlg != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_HA_serialize(&in->digest, in->hashAlg, &jso2); |
| return_if_error(r, "Serialize TPMU_HA"); |
| |
| json_object_object_add(*jso, "digest", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_DIGEST to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_DIGEST. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_DIGEST_serialize(const TPM2B_DIGEST *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > sizeof(TPMU_HA)) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMU_HA))", |
| (size_t)in->size, (size_t)sizeof(TPMU_HA)); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_DATA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_DATA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_DATA_serialize(const TPM2B_DATA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > sizeof(TPMU_HA)) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMT_HA))", |
| (size_t)in->size, (size_t)sizeof(TPMT_HA)); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[sizeof(TPMT_HA)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPM2B_NONCE to json. |
| * |
| * @param[in] in value of type TPM2B_NONCE to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_NONCE. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_NONCE_serialize(const TPM2B_NONCE *in, json_object **jso) |
| { |
| return ifapi_json_TPM2B_DIGEST_serialize(in, jso); |
| } |
| |
| /** Serialize a TPM2B_OPERAND to json. |
| * |
| * @param[in] in value of type TPM2B_OPERAND to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_OPERAND. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_OPERAND_serialize(const TPM2B_OPERAND *in, json_object **jso) |
| { |
| return ifapi_json_TPM2B_DIGEST_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPM2B_EVENT to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_EVENT. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_EVENT_serialize(const TPM2B_EVENT *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > 1024) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = 1024)", |
| (size_t)in->size, (size_t)1024); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_MAX_NV_BUFFER to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_MAX_NV_BUFFER. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_MAX_NV_BUFFER_serialize(const TPM2B_MAX_NV_BUFFER *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > TPM2_MAX_NV_BUFFER_SIZE) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_NV_BUFFER_SIZE)", |
| (size_t)in->size, (size_t)TPM2_MAX_NV_BUFFER_SIZE); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_NAME to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_NAME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_NAME_serialize(const TPM2B_NAME *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > sizeof(TPMU_NAME)) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMU_NAME))", |
| (size_t)in->size, (size_t)sizeof(TPMU_NAME)); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->name[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_TK_CREATION to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_TK_CREATION. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_TK_CREATION_serialize(const TPMT_TK_CREATION *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| if (in != NULL && in->tag != TPM2_ST_CREATION) { |
| LOG_ERROR("BAD VALUE %"PRIuPTR" != %"PRIuPTR,(size_t)in->tag,(size_t)TPM2_ST_CREATION); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| jso2 = NULL; |
| r = ifapi_json_TPM2_ST_serialize(in->tag, &jso2); |
| return_if_error(r, "Serialize TPM2_ST"); |
| |
| json_object_object_add(*jso, "tag", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_RH_HIERARCHY_serialize(in->hierarchy, &jso2); |
| return_if_error(r, "Serialize TPMI_RH_HIERARCHY"); |
| |
| json_object_object_add(*jso, "hierarchy", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->digest, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "digest", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_ALG_PROPERTY to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ALG_PROPERTY. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_ALG_PROPERTY_serialize(const TPMS_ALG_PROPERTY *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2_ALG_ID_serialize(in->alg, &jso2); |
| return_if_error(r, "Serialize TPM2_ALG_ID"); |
| |
| json_object_object_add(*jso, "alg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMA_ALGORITHM_serialize(in->algProperties, &jso2); |
| return_if_error(r, "Serialize TPMA_ALGORITHM"); |
| |
| json_object_object_add(*jso, "algProperties", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_TAGGED_PROPERTY to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TAGGED_PROPERTY. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_TAGGED_PROPERTY_serialize(const TPMS_TAGGED_PROPERTY *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2_PT_serialize(in->property, &jso2); |
| return_if_error(r, "Serialize TPM2_PT"); |
| |
| json_object_object_add(*jso, "property", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT32_serialize(in->value, &jso2); |
| return_if_error(r, "Serialize UINT32"); |
| |
| json_object_object_add(*jso, "value", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_CC to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_CC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_CC_serialize(const TPML_CC *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_CAP_CC) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_CC)", |
| (size_t)in->count, (size_t)TPM2_MAX_CAP_CC); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPM2_CC_serialize (in->commandCodes[i], &jso2); |
| return_if_error(r, "Serialize TPM2_CC"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_CCA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_CCA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_CCA_serialize(const TPML_CCA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_CAP_CC) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_CC)", |
| (size_t)in->count, (size_t)TPM2_MAX_CAP_CC); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMA_CC_serialize (in->commandAttributes[i], &jso2); |
| return_if_error(r, "Serialize TPMA_CC"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_HANDLE to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_HANDLE. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_HANDLE_serialize(const TPML_HANDLE *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_CAP_HANDLES) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_HANDLES)", |
| (size_t)in->count, (size_t)TPM2_MAX_CAP_HANDLES); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPM2_HANDLE_serialize (in->handle[i], &jso2); |
| return_if_error(r, "Serialize TPM2_HANDLE"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_DIGEST_VALUES to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_DIGEST_VALUES. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_DIGEST_VALUES_serialize(const TPML_DIGEST_VALUES *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_NUM_PCR_BANKS) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_NUM_PCR_BANKS)", |
| (size_t)in->count, (size_t)TPM2_NUM_PCR_BANKS); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMT_HA_serialize (&in->digests[i], &jso2); |
| return_if_error(r, "Serialize TPMT_HA"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_PCR_SELECTION to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_PCR_SELECTION. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_PCR_SELECTION_serialize(const TPML_PCR_SELECTION *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_NUM_PCR_BANKS) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_NUM_PCR_BANKS)", |
| (size_t)in->count, (size_t)TPM2_NUM_PCR_BANKS); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMS_PCR_SELECTION_serialize (&in->pcrSelections[i], &jso2); |
| return_if_error(r, "Serialize TPMS_PCR_SELECTION"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_ALG_PROPERTY to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_ALG_PROPERTY. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_ALG_PROPERTY_serialize(const TPML_ALG_PROPERTY *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_CAP_ALGS) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_ALGS)", |
| (size_t)in->count, (size_t)TPM2_MAX_CAP_ALGS); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMS_ALG_PROPERTY_serialize (&in->algProperties[i], &jso2); |
| return_if_error(r, "Serialize TPMS_ALG_PROPERTY"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_TAGGED_TPM_PROPERTY to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_TAGGED_TPM_PROPERTY. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_TAGGED_TPM_PROPERTY_serialize(const TPML_TAGGED_TPM_PROPERTY *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_TPM_PROPERTIES) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_TPM_PROPERTIES)", |
| (size_t)in->count, (size_t)TPM2_MAX_TPM_PROPERTIES); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMS_TAGGED_PROPERTY_serialize (&in->tpmProperty[i], &jso2); |
| return_if_error(r, "Serialize TPMS_TAGGED_PROPERTY"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_TAGGED_PCR_PROPERTY to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_TAGGED_PCR_PROPERTY. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_TAGGED_PCR_PROPERTY_serialize(const TPML_TAGGED_PCR_PROPERTY *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_PCR_PROPERTIES) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_PCR_PROPERTIES)", |
| (size_t)in->count, (size_t)TPM2_MAX_PCR_PROPERTIES); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMS_TAGGED_PCR_SELECT_serialize (&in->pcrProperty[i], &jso2); |
| return_if_error(r, "Serialize TPMS_TAGGED_PCR_SELECT"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPML_ECC_CURVE to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_ECC_CURVE. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPML_ECC_CURVE_serialize(const TPML_ECC_CURVE *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| if (in->count > TPM2_MAX_ECC_CURVES) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_ECC_CURVES)", |
| (size_t)in->count, (size_t)TPM2_MAX_ECC_CURVES); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| *jso = json_object_new_array(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| for (size_t i=0; i < in->count; i++) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPM2_ECC_CURVE_serialize (in->eccCurves[i], &jso2); |
| return_if_error(r, "Serialize TPM2_ECC_CURVE"); |
| |
| json_object_array_add(*jso, jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMU_CAPABILITIES to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the capabilities. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_CAPABILITIES. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_CAPABILITIES_serialize(const TPMU_CAPABILITIES *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_CAP_ALGS: |
| return ifapi_json_TPML_ALG_PROPERTY_serialize(&in->algorithms, jso); |
| case TPM2_CAP_HANDLES: |
| return ifapi_json_TPML_HANDLE_serialize(&in->handles, jso); |
| case TPM2_CAP_COMMANDS: |
| return ifapi_json_TPML_CCA_serialize(&in->command, jso); |
| case TPM2_CAP_PP_COMMANDS: |
| return ifapi_json_TPML_CC_serialize(&in->ppCommands, jso); |
| case TPM2_CAP_AUDIT_COMMANDS: |
| return ifapi_json_TPML_CC_serialize(&in->auditCommands, jso); |
| case TPM2_CAP_PCRS: |
| return ifapi_json_TPML_PCR_SELECTION_serialize(&in->assignedPCR, jso); |
| case TPM2_CAP_TPM_PROPERTIES: |
| return ifapi_json_TPML_TAGGED_TPM_PROPERTY_serialize(&in->tpmProperties, jso); |
| case TPM2_CAP_PCR_PROPERTIES: |
| return ifapi_json_TPML_TAGGED_PCR_PROPERTY_serialize(&in->pcrProperties, jso); |
| case TPM2_CAP_ECC_CURVES: |
| return ifapi_json_TPML_ECC_CURVE_serialize(&in->eccCurves, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_CAPABILITY_DATA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CAPABILITY_DATA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_CAPABILITY_DATA_serialize(const TPMS_CAPABILITY_DATA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2_CAP_serialize(in->capability, &jso2); |
| return_if_error(r, "Serialize TPM2_CAP"); |
| |
| json_object_object_add(*jso, "capability", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMU_CAPABILITIES_serialize(&in->data, in->capability, &jso2); |
| return_if_error(r,"Serialize TPMU_CAPABILITIES"); |
| |
| json_object_object_add(*jso, "data", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_CLOCK_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CLOCK_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_CLOCK_INFO_serialize(const TPMS_CLOCK_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_UINT64_serialize(in->clock, &jso2); |
| return_if_error(r, "Serialize UINT64"); |
| |
| json_object_object_add(*jso, "clock", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT32_serialize(in->resetCount, &jso2); |
| return_if_error(r, "Serialize UINT32"); |
| |
| json_object_object_add(*jso, "resetCount", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT32_serialize(in->restartCount, &jso2); |
| return_if_error(r, "Serialize UINT32"); |
| |
| json_object_object_add(*jso, "restartCount", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_YES_NO_serialize(in->safe, &jso2); |
| return_if_error(r, "Serialize TPMI_YES_NO"); |
| |
| json_object_object_add(*jso, "safe", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_TIME_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TIME_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_TIME_INFO_serialize(const TPMS_TIME_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_UINT64_serialize(in->time, &jso2); |
| return_if_error(r, "Serialize UINT64"); |
| |
| json_object_object_add(*jso, "time", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMS_CLOCK_INFO_serialize(&in->clockInfo, &jso2); |
| return_if_error(r, "Serialize TPMS_CLOCK_INFO"); |
| |
| json_object_object_add(*jso, "clockInfo", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_TIME_ATTEST_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TIME_ATTEST_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_TIME_ATTEST_INFO_serialize(const TPMS_TIME_ATTEST_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMS_TIME_INFO_serialize(&in->time, &jso2); |
| return_if_error(r, "Serialize TPMS_TIME_INFO"); |
| |
| json_object_object_add(*jso, "time", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT64_serialize(in->firmwareVersion, &jso2); |
| return_if_error(r, "Serialize UINT64"); |
| |
| json_object_object_add(*jso, "firmwareVersion", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_CERTIFY_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CERTIFY_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_CERTIFY_INFO_serialize(const TPMS_CERTIFY_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->name, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "name", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->qualifiedName, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "qualifiedName", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_QUOTE_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_QUOTE_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_QUOTE_INFO_serialize(const TPMS_QUOTE_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPML_PCR_SELECTION_serialize(&in->pcrSelect, &jso2); |
| return_if_error(r, "Serialize TPML_PCR_SELECTION"); |
| |
| json_object_object_add(*jso, "pcrSelect", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->pcrDigest, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "pcrDigest", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_COMMAND_AUDIT_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_COMMAND_AUDIT_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_COMMAND_AUDIT_INFO_serialize(const TPMS_COMMAND_AUDIT_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_UINT64_serialize(in->auditCounter, &jso2); |
| return_if_error(r, "Serialize UINT64"); |
| |
| json_object_object_add(*jso, "auditCounter", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2_ALG_ID_serialize(in->digestAlg, &jso2); |
| return_if_error(r, "Serialize TPM2_ALG_ID"); |
| |
| json_object_object_add(*jso, "digestAlg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->auditDigest, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "auditDigest", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->commandDigest, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "commandDigest", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_SESSION_AUDIT_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SESSION_AUDIT_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SESSION_AUDIT_INFO_serialize(const TPMS_SESSION_AUDIT_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_YES_NO_serialize(in->exclusiveSession, &jso2); |
| return_if_error(r, "Serialize TPMI_YES_NO"); |
| |
| json_object_object_add(*jso, "exclusiveSession", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->sessionDigest, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "sessionDigest", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_CREATION_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CREATION_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_CREATION_INFO_serialize(const TPMS_CREATION_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->objectName, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "objectName", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->creationHash, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "creationHash", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_NV_CERTIFY_INFO to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_NV_CERTIFY_INFO. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_NV_CERTIFY_INFO_serialize(const TPMS_NV_CERTIFY_INFO *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->indexName, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "indexName", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT16_serialize(in->offset, &jso2); |
| return_if_error(r, "Serialize UINT16"); |
| |
| json_object_object_add(*jso, "offset", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_MAX_NV_BUFFER_serialize(&in->nvContents, &jso2); |
| return_if_error(r, "Serialize TPM2B_MAX_NV_BUFFER"); |
| |
| json_object_object_add(*jso, "nvContents", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ST_ATTEST to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ST_ATTEST_serialize(const TPMI_ST_ATTEST in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_HASH, in, TPM2_ST_ATTEST_CERTIFY, TPM2_ST_ATTEST_QUOTE, |
| TPM2_ST_ATTEST_SESSION_AUDIT, TPM2_ST_ATTEST_COMMAND_AUDIT, |
| TPM2_ST_ATTEST_TIME, TPM2_ST_ATTEST_CREATION, TPM2_ST_ATTEST_NV); |
| return ifapi_json_TPM2_ST_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_ATTEST to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the attest. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_ATTEST. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_ATTEST_serialize(const TPMU_ATTEST *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ST_ATTEST_CERTIFY: |
| return ifapi_json_TPMS_CERTIFY_INFO_serialize(&in->certify, jso); |
| case TPM2_ST_ATTEST_CREATION: |
| return ifapi_json_TPMS_CREATION_INFO_serialize(&in->creation, jso); |
| case TPM2_ST_ATTEST_QUOTE: |
| return ifapi_json_TPMS_QUOTE_INFO_serialize(&in->quote, jso); |
| case TPM2_ST_ATTEST_COMMAND_AUDIT: |
| return ifapi_json_TPMS_COMMAND_AUDIT_INFO_serialize(&in->commandAudit, jso); |
| case TPM2_ST_ATTEST_SESSION_AUDIT: |
| return ifapi_json_TPMS_SESSION_AUDIT_INFO_serialize(&in->sessionAudit, jso); |
| case TPM2_ST_ATTEST_TIME: |
| return ifapi_json_TPMS_TIME_ATTEST_INFO_serialize(&in->time, jso); |
| case TPM2_ST_ATTEST_NV: |
| return ifapi_json_TPMS_NV_CERTIFY_INFO_serialize(&in->nv, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_ATTEST to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ATTEST. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_ATTEST_serialize(const TPMS_ATTEST *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2_GENERATED_serialize(in->magic, &jso2); |
| return_if_error(r, "Serialize TPM2_GENERATED"); |
| |
| json_object_object_add(*jso, "magic", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ST_ATTEST_serialize(in->type, &jso2); |
| return_if_error(r, "Serialize TPMI_ST_ATTEST"); |
| |
| json_object_object_add(*jso, "type", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->qualifiedSigner, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "qualifiedSigner", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DATA_serialize(&in->extraData, &jso2); |
| return_if_error(r, "Serialize TPM2B_DATA"); |
| |
| json_object_object_add(*jso, "extraData", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMS_CLOCK_INFO_serialize(&in->clockInfo, &jso2); |
| return_if_error(r, "Serialize TPMS_CLOCK_INFO"); |
| |
| json_object_object_add(*jso, "clockInfo", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT64_serialize(in->firmwareVersion, &jso2); |
| return_if_error(r, "Serialize UINT64"); |
| |
| json_object_object_add(*jso, "firmwareVersion", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMU_ATTEST_serialize(&in->attested, in->type, &jso2); |
| return_if_error(r,"Serialize TPMU_ATTEST"); |
| |
| json_object_object_add(*jso, "attested", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMI_AES_KEY_BITS to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_AES_KEY_BITS. |
| * |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_AES_KEY_BITS_serialize(const TPMI_AES_KEY_BITS in, json_object **jso) |
| { |
| CHECK_IN_LIST(UINT16, in, 128, 192, 256); |
| return ifapi_json_UINT16_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_SYM_KEY_BITS to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the symmetric algorithm. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SYM_KEY_BITS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_SYM_KEY_BITS_serialize(const TPMU_SYM_KEY_BITS *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_AES: |
| return ifapi_json_TPMI_AES_KEY_BITS_serialize(in->aes, jso); |
| case TPM2_ALG_XOR: |
| return ifapi_json_TPMI_ALG_HASH_serialize(in->exclusiveOr, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMU_SYM_MODE to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the symmetric mode. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SYM_MODE. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_SYM_MODE_serialize(const TPMU_SYM_MODE *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_AES: |
| return ifapi_json_TPMI_ALG_SYM_MODE_serialize(in->aes, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_SYM_DEF_OBJECT to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_SYM_DEF_OBJECT. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(const TPMT_SYM_DEF_OBJECT *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_SYM_OBJECT_serialize(in->algorithm, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_SYM_OBJECT"); |
| |
| json_object_object_add(*jso, "algorithm", jso2); |
| if (in->algorithm != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_SYM_KEY_BITS_serialize(&in->keyBits, in->algorithm, &jso2); |
| return_if_error(r,"Serialize TPMU_SYM_KEY_BITS"); |
| |
| json_object_object_add(*jso, "keyBits", jso2); |
| } |
| if (in->algorithm != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_SYM_MODE_serialize(&in->mode, in->algorithm, &jso2); |
| return_if_error(r,"Serialize TPMU_SYM_MODE"); |
| |
| json_object_object_add(*jso, "mode", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_SYMCIPHER_PARMS to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SYMCIPHER_PARMS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SYMCIPHER_PARMS_serialize(const TPMS_SYMCIPHER_PARMS *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(&in->sym, &jso2); |
| return_if_error(r, "Serialize TPMT_SYM_DEF_OBJECT"); |
| |
| json_object_object_add(*jso, "sym", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_SCHEME_HASH to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_HASH. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_HASH_serialize(const TPMS_SCHEME_HASH *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "hashAlg", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_SCHEME_ECDAA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_ECDAA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_ECDAA_serialize(const TPMS_SCHEME_ECDAA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "hashAlg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT16_serialize(in->count, &jso2); |
| return_if_error(r, "Serialize UINT16"); |
| |
| json_object_object_add(*jso, "count", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ALG_KEYEDHASH_SCHEME to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_KEYEDHASH_SCHEME_serialize(const TPMI_ALG_KEYEDHASH_SCHEME in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_HASH, in, TPM2_ALG_HMAC, TPM2_ALG_XOR, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SCHEME_HMAC to json. |
| * |
| * @param[in] in value of type TPMS_SCHEME_HMAC to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_HMAC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_HMAC_serialize(const TPMS_SCHEME_HMAC *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPMS_SCHEME_XOR to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_XOR. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_XOR_serialize(const TPMS_SCHEME_XOR *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "hashAlg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_KDF_serialize(in->kdf, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_KDF"); |
| |
| json_object_object_add(*jso, "kdf", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMU_SCHEME_KEYEDHASH to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the keyedhash scheme. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SCHEME_KEYEDHASH. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_SCHEME_KEYEDHASH_serialize(const TPMU_SCHEME_KEYEDHASH *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_HMAC: |
| return ifapi_json_TPMS_SCHEME_HMAC_serialize(&in->hmac, jso); |
| case TPM2_ALG_XOR: |
| return ifapi_json_TPMS_SCHEME_XOR_serialize(&in->exclusiveOr, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_KEYEDHASH_SCHEME to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_KEYEDHASH_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_KEYEDHASH_SCHEME_serialize(const TPMT_KEYEDHASH_SCHEME *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_KEYEDHASH_SCHEME_serialize(in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_KEYEDHASH_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| if (in->scheme != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_SCHEME_KEYEDHASH_serialize(&in->details, in->scheme, &jso2); |
| return_if_error(r,"Serialize TPMU_SCHEME_KEYEDHASH"); |
| |
| json_object_object_add(*jso, "details", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMS_SIG_SCHEME_RSASSA to json. |
| * |
| * @param[in] in value of type TPMS_SIG_SCHEME_RSASSA to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_RSASSA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(const TPMS_SIG_SCHEME_RSASSA *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIG_SCHEME_RSAPSS to json. |
| * |
| * @param[in] in value of type TPMS_SIG_SCHEME_RSAPSS to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_RSAPSS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(const TPMS_SIG_SCHEME_RSAPSS *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIG_SCHEME_ECDSA to json. |
| * |
| * @param[in] in value of type TPMS_SIG_SCHEME_ECDSA to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_ECDSA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(const TPMS_SIG_SCHEME_ECDSA *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIG_SCHEME_SM2 to json. |
| * |
| * @param[in] in value of type TPMS_SIG_SCHEME_SM2 to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_SM2. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(const TPMS_SIG_SCHEME_SM2 *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIG_SCHEME_ECSCHNORR to json. |
| * |
| * @param[in] in value of type TPMS_SIG_SCHEME_ECSCHNORR to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_ECSCHNORR. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(const TPMS_SIG_SCHEME_ECSCHNORR *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIG_SCHEME_ECDAA to json. |
| * |
| * @param[in] in value of type TPMS_SIG_SCHEME_ECDAA to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_ECDAA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(const TPMS_SIG_SCHEME_ECDAA *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_ECDAA_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_SIG_SCHEME to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the signature scheme. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SIG_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_SIG_SCHEME_serialize(const TPMU_SIG_SCHEME *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_RSASSA: |
| return ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(&in->rsassa, jso); |
| case TPM2_ALG_RSAPSS: |
| return ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(&in->rsapss, jso); |
| case TPM2_ALG_ECDSA: |
| return ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(&in->ecdsa, jso); |
| case TPM2_ALG_ECDAA: |
| return ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(&in->ecdaa, jso); |
| case TPM2_ALG_SM2: |
| return ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(&in->sm2, jso); |
| case TPM2_ALG_ECSCHNORR: |
| return ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(&in->ecschnorr, jso); |
| case TPM2_ALG_HMAC: |
| return ifapi_json_TPMS_SCHEME_HMAC_serialize(&in->hmac, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_SIG_SCHEME to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_SIG_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_SIG_SCHEME_serialize(const TPMT_SIG_SCHEME *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_SIG_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| if (in->scheme != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_SIG_SCHEME_serialize(&in->details, in->scheme, &jso2); |
| return_if_error(r,"Serialize TPMU_SIG_SCHEME"); |
| |
| json_object_object_add(*jso, "details", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMS_ENC_SCHEME_OAEP to json. |
| * |
| * @param[in] in value of type TPMS_ENC_SCHEME_OAEP to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ENC_SCHEME_OAEP. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_ENC_SCHEME_OAEP_serialize(const TPMS_ENC_SCHEME_OAEP *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_ENC_SCHEME_RSAES to json. |
| * |
| * @param[in] in value of type TPMS_ENC_SCHEME_RSAES to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ENC_SCHEME_RSAES. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_ENC_SCHEME_RSAES_serialize(const TPMS_ENC_SCHEME_RSAES *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_EMPTY_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_KEY_SCHEME_ECDH to json. |
| * |
| * @param[in] in value of type TPMS_KEY_SCHEME_ECDH to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_KEY_SCHEME_ECDH. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_KEY_SCHEME_ECDH_serialize(const TPMS_KEY_SCHEME_ECDH *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SCHEME_MGF1 to json. |
| * |
| * @param[in] in value of type TPMS_SCHEME_MGF1 to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_MGF1. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_MGF1_serialize(const TPMS_SCHEME_MGF1 *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SCHEME_KDF1_SP800_56A to json. |
| * |
| * @param[in] in value of type TPMS_SCHEME_KDF1_SP800_56A to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_KDF1_SP800_56A. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_KDF1_SP800_56A_serialize(const TPMS_SCHEME_KDF1_SP800_56A *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SCHEME_KDF1_SP800_108 to json. |
| * |
| * @param[in] in value of type TPMS_SCHEME_KDF1_SP800_108 to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_KDF1_SP800_108. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SCHEME_KDF1_SP800_108_serialize(const TPMS_SCHEME_KDF1_SP800_108 *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_KDF_SCHEME to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the KDF scheme. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_KDF_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_KDF_SCHEME_serialize(const TPMU_KDF_SCHEME *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_MGF1: |
| return ifapi_json_TPMS_SCHEME_MGF1_serialize(&in->mgf1, jso); |
| case TPM2_ALG_KDF1_SP800_56A: |
| return ifapi_json_TPMS_SCHEME_KDF1_SP800_56A_serialize(&in->kdf1_sp800_56a, jso); |
| case TPM2_ALG_KDF1_SP800_108: |
| return ifapi_json_TPMS_SCHEME_KDF1_SP800_108_serialize(&in->kdf1_sp800_108, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_KDF_SCHEME to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_KDF_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_KDF_SCHEME_serialize(const TPMT_KDF_SCHEME *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_KDF_serialize(in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_KDF"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| if (in->scheme != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_KDF_SCHEME_serialize(&in->details, in->scheme, &jso2); |
| return_if_error(r,"Serialize TPMU_KDF_SCHEME"); |
| |
| json_object_object_add(*jso, "details", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ALG_ASYM_SCHEME to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_ASYM_SCHEME_serialize(const TPMI_ALG_ASYM_SCHEME in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_ASYM_SCHEME, in, TPM2_ALG_ECDH, TPM2_ALG_RSASSA, TPM2_ALG_RSAPSS, |
| TPM2_ALG_ECDSA, TPM2_ALG_ECDAA, TPM2_ALG_SM2, TPM2_ALG_ECSCHNORR, |
| TPM2_ALG_RSAES, TPM2_ALG_OAEP, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_ASYM_SCHEME to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the scheme. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_ASYM_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_ASYM_SCHEME_serialize(const TPMU_ASYM_SCHEME *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_ECDH: |
| return ifapi_json_TPMS_KEY_SCHEME_ECDH_serialize(&in->ecdh, jso); |
| case TPM2_ALG_RSASSA: |
| return ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(&in->rsassa, jso); |
| case TPM2_ALG_RSAPSS: |
| return ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(&in->rsapss, jso); |
| case TPM2_ALG_ECDSA: |
| return ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(&in->ecdsa, jso); |
| case TPM2_ALG_ECDAA: |
| return ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(&in->ecdaa, jso); |
| case TPM2_ALG_SM2: |
| return ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(&in->sm2, jso); |
| case TPM2_ALG_ECSCHNORR: |
| return ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(&in->ecschnorr, jso); |
| case TPM2_ALG_RSAES: |
| return ifapi_json_TPMS_ENC_SCHEME_RSAES_serialize(&in->rsaes, jso); |
| case TPM2_ALG_OAEP: |
| return ifapi_json_TPMS_ENC_SCHEME_OAEP_serialize(&in->oaep, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ALG_RSA_SCHEME to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_RSA_SCHEME_serialize(const TPMI_ALG_RSA_SCHEME in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_RSA_SCHEME, in, TPM2_ALG_RSAES, TPM2_ALG_OAEP, TPM2_ALG_RSASSA, |
| TPM2_ALG_RSAPSS, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPMT_RSA_SCHEME to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_RSA_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_RSA_SCHEME_serialize(const TPMT_RSA_SCHEME *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_RSA_SCHEME_serialize(in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_RSA_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| if (in->scheme != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_ASYM_SCHEME_serialize(&in->details, in->scheme, &jso2); |
| return_if_error(r,"Serialize TPMU_ASYM_SCHEME"); |
| |
| json_object_object_add(*jso, "details", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_PUBLIC_KEY_RSA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_PUBLIC_KEY_RSA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(const TPM2B_PUBLIC_KEY_RSA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > TPM2_MAX_RSA_KEY_BYTES) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_RSA_KEY_BYTES)", |
| (size_t)in->size, (size_t)TPM2_MAX_RSA_KEY_BYTES); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMI_RSA_KEY_BITS to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_RSA_KEY_BITS. |
| * |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_RSA_KEY_BITS_serialize(const TPMI_RSA_KEY_BITS in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_RSA_KEY_BITS, in, 1024, 2048); |
| return ifapi_json_UINT16_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPM2B_ECC_PARAMETER to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_ECC_PARAMETER. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_ECC_PARAMETER_serialize(const TPM2B_ECC_PARAMETER *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > TPM2_MAX_ECC_KEY_BYTES) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_ECC_KEY_BYTES)", |
| (size_t)in->size, (size_t)TPM2_MAX_ECC_KEY_BYTES); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_ECC_POINT to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ECC_POINT. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_ECC_POINT_serialize(const TPMS_ECC_POINT *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->x, &jso2); |
| return_if_error(r, "Serialize TPM2B_ECC_PARAMETER"); |
| |
| json_object_object_add(*jso, "x", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->y, &jso2); |
| return_if_error(r, "Serialize TPM2B_ECC_PARAMETER"); |
| |
| json_object_object_add(*jso, "y", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ALG_ECC_SCHEME to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_ECC_SCHEME_serialize(const TPMI_ALG_ECC_SCHEME in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_ECC_SCHEME, in, TPM2_ALG_ECDSA, TPM2_ALG_ECDAA, |
| TPM2_ALG_SM2, TPM2_ALG_ECSCHNORR, TPM2_ALG_ECDH, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPMI_ECC_CURVE to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_ECC_CURVE. |
| * |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ECC_CURVE_serialize(const TPMI_ECC_CURVE in, json_object **jso) |
| { |
| return ifapi_json_TPM2_ECC_CURVE_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPMT_ECC_SCHEME to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_ECC_SCHEME. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_ECC_SCHEME_serialize(const TPMT_ECC_SCHEME *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_ECC_SCHEME_serialize(in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_ECC_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| if (in->scheme != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_ASYM_SCHEME_serialize(&in->details, in->scheme, &jso2); |
| return_if_error(r,"Serialize TPMU_ASYM_SCHEME"); |
| |
| json_object_object_add(*jso, "details", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_SIGNATURE_RSA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_RSA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_RSA_serialize(const TPMS_SIGNATURE_RSA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hash, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "hash", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(&in->sig, &jso2); |
| return_if_error(r, "Serialize TPM2B_PUBLIC_KEY_RSA"); |
| |
| json_object_object_add(*jso, "sig", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMS_SIGNATURE_RSASSA to json. |
| * |
| * @param[in] in value of type TPMS_SIGNATURE_RSASSA to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_RSASSA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_RSASSA_serialize(const TPMS_SIGNATURE_RSASSA *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SIGNATURE_RSA_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIGNATURE_RSAPSS to json. |
| * |
| * @param[in] in value of type TPMS_SIGNATURE_RSAPSS to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_RSAPSS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_RSAPSS_serialize(const TPMS_SIGNATURE_RSAPSS *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SIGNATURE_RSA_serialize(in, jso); |
| } |
| |
| /** Serialize value of type TPMS_SIGNATURE_ECC to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_ECC_serialize(const TPMS_SIGNATURE_ECC *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->hash, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "hash", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->signatureR, &jso2); |
| return_if_error(r, "Serialize TPM2B_ECC_PARAMETER"); |
| |
| json_object_object_add(*jso, "signatureR", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->signatureS, &jso2); |
| return_if_error(r, "Serialize TPM2B_ECC_PARAMETER"); |
| |
| json_object_object_add(*jso, "signatureS", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMS_SIGNATURE_ECDSA to json. |
| * |
| * @param[in] in value of type TPMS_SIGNATURE_ECDSA to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECDSA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_ECDSA_serialize(const TPMS_SIGNATURE_ECDSA *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIGNATURE_ECDAA to json. |
| * |
| * @param[in] in value of type TPMS_SIGNATURE_ECDAA to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECDAA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_ECDAA_serialize(const TPMS_SIGNATURE_ECDAA *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIGNATURE_SM2 to json. |
| * |
| * @param[in] in value of type TPMS_SIGNATURE_SM2 to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_SM2. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_SM2_serialize(const TPMS_SIGNATURE_SM2 *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMS_SIGNATURE_ECSCHNORR to json. |
| * |
| * @param[in] in value of type TPMS_SIGNATURE_ECSCHNORR to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECSCHNORR. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_SIGNATURE_ECSCHNORR_serialize(const TPMS_SIGNATURE_ECSCHNORR *in, json_object **jso) |
| { |
| return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_SIGNATURE to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the signature. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SIGNATURE. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_SIGNATURE_serialize(const TPMU_SIGNATURE *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_RSASSA: |
| return ifapi_json_TPMS_SIGNATURE_RSASSA_serialize(&in->rsassa, jso); |
| case TPM2_ALG_RSAPSS: |
| return ifapi_json_TPMS_SIGNATURE_RSAPSS_serialize(&in->rsapss, jso); |
| case TPM2_ALG_ECDSA: |
| return ifapi_json_TPMS_SIGNATURE_ECDSA_serialize(&in->ecdsa, jso); |
| case TPM2_ALG_ECDAA: |
| return ifapi_json_TPMS_SIGNATURE_ECDAA_serialize(&in->ecdaa, jso); |
| case TPM2_ALG_SM2: |
| return ifapi_json_TPMS_SIGNATURE_SM2_serialize(&in->sm2, jso); |
| case TPM2_ALG_ECSCHNORR: |
| return ifapi_json_TPMS_SIGNATURE_ECSCHNORR_serialize(&in->ecschnorr, jso); |
| case TPM2_ALG_HMAC: |
| return ifapi_json_TPMT_HA_serialize(&in->hmac, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_SIGNATURE to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_SIGNATURE. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_SIGNATURE_serialize(const TPMT_SIGNATURE *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(in->sigAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_SIG_SCHEME"); |
| |
| json_object_object_add(*jso, "sigAlg", jso2); |
| if (in->sigAlg != TPM2_ALG_NULL) { |
| json_object *jso2 = NULL; |
| r = ifapi_json_TPMU_SIGNATURE_serialize(&in->signature, in->sigAlg, &jso2); |
| return_if_error(r,"Serialize TPMU_SIGNATURE"); |
| |
| json_object_object_add(*jso, "signature", jso2); |
| } |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_ENCRYPTED_SECRET to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_ENCRYPTED_SECRET. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_ENCRYPTED_SECRET_serialize(const TPM2B_ENCRYPTED_SECRET *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > sizeof(TPMU_ENCRYPTED_SECRET)) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMU_ENCRYPTED_SECRET))", |
| (size_t)in->size, (size_t)sizeof(TPMU_ENCRYPTED_SECRET)); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->secret[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPMI_ALG_PUBLIC to json. |
| * |
| * @param[in] in variable to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into |
| * the function. |
| * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated. |
| */ |
| TSS2_RC |
| ifapi_json_TPMI_ALG_PUBLIC_serialize(const TPMI_ALG_PUBLIC in, json_object **jso) |
| { |
| CHECK_IN_LIST(TPMI_ALG_PUBLIC, in, TPM2_ALG_RSA, TPM2_ALG_KEYEDHASH, |
| TPM2_ALG_ECC, TPM2_ALG_SYMCIPHER, TPM2_ALG_NULL); |
| return ifapi_json_TPM2_ALG_ID_serialize(in, jso); |
| } |
| |
| /** Serialize a TPMU_PUBLIC_ID to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the public ID. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_PUBLIC_ID. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_PUBLIC_ID_serialize(const TPMU_PUBLIC_ID *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_KEYEDHASH: |
| return ifapi_json_TPM2B_DIGEST_serialize(&in->keyedHash, jso); |
| case TPM2_ALG_SYMCIPHER: |
| return ifapi_json_TPM2B_DIGEST_serialize(&in->sym, jso); |
| case TPM2_ALG_RSA: |
| return ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(&in->rsa, jso); |
| case TPM2_ALG_ECC: |
| return ifapi_json_TPMS_ECC_POINT_serialize(&in->ecc, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_KEYEDHASH_PARMS to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_KEYEDHASH_PARMS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_KEYEDHASH_PARMS_serialize(const TPMS_KEYEDHASH_PARMS *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_KEYEDHASH_SCHEME_serialize(&in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMT_KEYEDHASH_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_RSA_PARMS to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_RSA_PARMS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_RSA_PARMS_serialize(const TPMS_RSA_PARMS *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(&in->symmetric, &jso2); |
| return_if_error(r, "Serialize TPMT_SYM_DEF_OBJECT"); |
| |
| json_object_object_add(*jso, "symmetric", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_RSA_SCHEME_serialize(&in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMT_RSA_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_RSA_KEY_BITS_serialize(in->keyBits, &jso2); |
| return_if_error(r, "Serialize TPMI_RSA_KEY_BITS"); |
| |
| json_object_object_add(*jso, "keyBits", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT32_serialize(in->exponent, &jso2); |
| return_if_error(r, "Serialize UINT32"); |
| |
| json_object_object_add(*jso, "exponent", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_ECC_PARMS to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ECC_PARMS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_ECC_PARMS_serialize(const TPMS_ECC_PARMS *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(&in->symmetric, &jso2); |
| return_if_error(r, "Serialize TPMT_SYM_DEF_OBJECT"); |
| |
| json_object_object_add(*jso, "symmetric", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_ECC_SCHEME_serialize(&in->scheme, &jso2); |
| return_if_error(r, "Serialize TPMT_ECC_SCHEME"); |
| |
| json_object_object_add(*jso, "scheme", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ECC_CURVE_serialize(in->curveID, &jso2); |
| return_if_error(r, "Serialize TPMI_ECC_CURVE"); |
| |
| json_object_object_add(*jso, "curveID", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMT_KDF_SCHEME_serialize(&in->kdf, &jso2); |
| return_if_error(r, "Serialize TPMT_KDF_SCHEME"); |
| |
| json_object_object_add(*jso, "kdf", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPMU_PUBLIC_PARMS to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * @param[in] in the value to be serialized. |
| * @param[in] selector the type of the public parameters. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_PUBLIC_PARMS. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMU_PUBLIC_PARMS_serialize(const TPMU_PUBLIC_PARMS *in, UINT32 selector, json_object **jso) |
| { |
| switch (selector) { |
| case TPM2_ALG_KEYEDHASH: |
| return ifapi_json_TPMS_KEYEDHASH_PARMS_serialize(&in->keyedHashDetail, jso); |
| case TPM2_ALG_SYMCIPHER: |
| return ifapi_json_TPMS_SYMCIPHER_PARMS_serialize(&in->symDetail, jso); |
| case TPM2_ALG_RSA: |
| return ifapi_json_TPMS_RSA_PARMS_serialize(&in->rsaDetail, jso); |
| case TPM2_ALG_ECC: |
| return ifapi_json_TPMS_ECC_PARMS_serialize(&in->eccDetail, jso); |
| default: |
| LOG_ERROR("\nSelector %"PRIx32 " did not match", selector); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| }; |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMT_PUBLIC to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_PUBLIC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMT_PUBLIC_serialize(const TPMT_PUBLIC *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_PUBLIC_serialize(in->type, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_PUBLIC"); |
| |
| json_object_object_add(*jso, "type", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->nameAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "nameAlg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMA_OBJECT_serialize(in->objectAttributes, &jso2); |
| return_if_error(r, "Serialize TPMA_OBJECT"); |
| |
| json_object_object_add(*jso, "objectAttributes", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->authPolicy, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "authPolicy", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMU_PUBLIC_PARMS_serialize(&in->parameters, in->type, &jso2); |
| return_if_error(r,"Serialize TPMU_PUBLIC_PARMS"); |
| |
| json_object_object_add(*jso, "parameters", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMU_PUBLIC_ID_serialize(&in->unique, in->type, &jso2); |
| return_if_error(r,"Serialize TPMU_PUBLIC_ID"); |
| |
| json_object_object_add(*jso, "unique", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPM2B_PUBLIC to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_PUBLIC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_PUBLIC_serialize(const TPM2B_PUBLIC *in, json_object **jso) |
| { |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object *jso2; |
| |
| jso2 = NULL; |
| if (ifapi_json_UINT16_serialize(in->size, &jso2)) |
| return TSS2_FAPI_RC_BAD_VALUE; |
| |
| json_object_object_add(*jso, "size", jso2); |
| |
| jso2 = NULL; |
| if (ifapi_json_TPMT_PUBLIC_serialize(&in->publicArea, &jso2)) |
| return TSS2_FAPI_RC_BAD_VALUE; |
| |
| json_object_object_add(*jso, "publicArea", jso2); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPM2B_PRIVATE to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_PRIVATE. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_PRIVATE_serialize(const TPM2B_PRIVATE *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| if (in->size > sizeof(_PRIVATE)) { |
| LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(_PRIVATE))", |
| (size_t)in->size, (size_t)sizeof(_PRIVATE)); |
| return TSS2_FAPI_RC_BAD_VALUE; |
| } |
| char hex_string[((size_t)in->size)*2+1]; |
| |
| for (size_t i = 0, off = 0; i < in->size; i++, off+=2) |
| sprintf(&hex_string[off], "%02x", in->buffer[i]); |
| hex_string[(in->size)*2] = '\0'; |
| *jso = json_object_new_string (hex_string); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize TPM2_NT to json. |
| * |
| * @param[in] in constant to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_NT. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2_NT_serialize(const TPM2_NT in, json_object **jso) |
| { |
| static const struct { TPM2_NT in; char *name; } tab[] = { |
| { TPM2_NT_ORDINARY, "ORDINARY" }, |
| { TPM2_NT_COUNTER, "COUNTER" }, |
| { TPM2_NT_BITS, "BITS" }, |
| { TPM2_NT_EXTEND, "EXTEND" }, |
| { TPM2_NT_PIN_FAIL, "PIN_FAIL" }, |
| { TPM2_NT_PIN_PASS, "PIN_PASS" }, |
| }; |
| |
| for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) { |
| if (tab[i].in == in) { |
| *jso = json_object_new_string(tab[i].name); |
| check_oom(*jso); |
| return TSS2_RC_SUCCESS; |
| } |
| } |
| return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant."); |
| } |
| |
| /** Serialize a TPMA_NV to json. |
| * |
| * This function expects the Bitfield to be encoded as unsigned int in host-endianess. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_NV. |
| */ |
| TSS2_RC |
| ifapi_json_TPMA_NV_serialize(const TPMA_NV in, json_object **jso) |
| { |
| struct { TPMA_NV in; char *name; } tab[] = { |
| { TPMA_NV_PPWRITE, "PPWRITE" }, |
| { TPMA_NV_OWNERWRITE, "OWNERWRITE" }, |
| { TPMA_NV_AUTHWRITE, "AUTHWRITE" }, |
| { TPMA_NV_POLICYWRITE, "POLICYWRITE" }, |
| { TPMA_NV_POLICY_DELETE, "POLICY_DELETE" }, |
| { TPMA_NV_WRITELOCKED, "WRITELOCKED" }, |
| { TPMA_NV_WRITEALL, "WRITEALL" }, |
| { TPMA_NV_WRITEDEFINE, "WRITEDEFINE" }, |
| { TPMA_NV_WRITE_STCLEAR, "WRITE_STCLEAR" }, |
| { TPMA_NV_GLOBALLOCK, "GLOBALLOCK" }, |
| { TPMA_NV_PPREAD, "PPREAD" }, |
| { TPMA_NV_OWNERREAD, "OWNERREAD" }, |
| { TPMA_NV_AUTHREAD, "AUTHREAD" }, |
| { TPMA_NV_POLICYREAD, "POLICYREAD" }, |
| { TPMA_NV_NO_DA, "NO_DA" }, |
| { TPMA_NV_ORDERLY, "ORDERLY" }, |
| { TPMA_NV_CLEAR_STCLEAR, "CLEAR_STCLEAR" }, |
| { TPMA_NV_READLOCKED, "READLOCKED" }, |
| { TPMA_NV_WRITTEN, "WRITTEN" }, |
| { TPMA_NV_PLATFORMCREATE, "PLATFORMCREATE" }, |
| { TPMA_NV_READ_STCLEAR, "READ_STCLEAR" }, |
| }; |
| |
| UINT32 input; |
| input = (UINT32) in; |
| json_object *jso_bit; |
| if (*jso == NULL) { |
| *jso = json_object_new_object(); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| } |
| size_t n = sizeof(tab) / sizeof(tab[0]); |
| size_t i; |
| for (i = 0; i < n; i++) { |
| if (tab[i].in & input) |
| jso_bit = json_object_new_int(1); |
| else |
| jso_bit = json_object_new_int(0); |
| return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object_object_add(*jso, tab[i].name, jso_bit); |
| } |
| TPM2_NT input2 = (TPMA_NV_TPM2_NT_MASK & input)>>4; |
| json_object *jso2 = NULL; |
| TSS2_RC r = ifapi_json_TPM2_NT_serialize(input2, &jso2); |
| return_if_error(r, "Bad value"); |
| |
| json_object_object_add(*jso, "TPM2_NT", jso2); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_NV_PUBLIC to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_NV_PUBLIC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_NV_PUBLIC_serialize(const TPMS_NV_PUBLIC *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_RH_NV_INDEX_serialize(in->nvIndex, &jso2); |
| return_if_error(r, "Serialize TPMI_RH_NV_INDEX"); |
| |
| json_object_object_add(*jso, "nvIndex", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMI_ALG_HASH_serialize(in->nameAlg, &jso2); |
| return_if_error(r, "Serialize TPMI_ALG_HASH"); |
| |
| json_object_object_add(*jso, "nameAlg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMA_NV_serialize(in->attributes, &jso2); |
| return_if_error(r, "Serialize TPMA_NV"); |
| |
| json_object_object_add(*jso, "attributes", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->authPolicy, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "authPolicy", jso2); |
| jso2 = NULL; |
| r = ifapi_json_UINT16_serialize(in->dataSize, &jso2); |
| return_if_error(r, "Serialize UINT16"); |
| |
| json_object_object_add(*jso, "dataSize", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPM2B_NV_PUBLIC to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_NV_PUBLIC. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_NV_PUBLIC_serialize(const TPM2B_NV_PUBLIC *in, json_object **jso) |
| { |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object *jso2; |
| |
| jso2 = NULL; |
| if (ifapi_json_UINT16_serialize(in->size, &jso2)) |
| return TSS2_FAPI_RC_BAD_VALUE; |
| |
| json_object_object_add(*jso, "size", jso2); |
| |
| jso2 = NULL; |
| if (ifapi_json_TPMS_NV_PUBLIC_serialize(&in->nvPublic, &jso2)) |
| return TSS2_FAPI_RC_BAD_VALUE; |
| |
| json_object_object_add(*jso, "nvPublic", jso2); |
| |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize value of type TPMS_CREATION_DATA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CREATION_DATA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPMS_CREATION_DATA_serialize(const TPMS_CREATION_DATA *in, json_object **jso) |
| { |
| return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE); |
| |
| TSS2_RC r; |
| json_object *jso2; |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| jso2 = NULL; |
| r = ifapi_json_TPML_PCR_SELECTION_serialize(&in->pcrSelect, &jso2); |
| return_if_error(r, "Serialize TPML_PCR_SELECTION"); |
| |
| json_object_object_add(*jso, "pcrSelect", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DIGEST_serialize(&in->pcrDigest, &jso2); |
| return_if_error(r, "Serialize TPM2B_DIGEST"); |
| |
| json_object_object_add(*jso, "pcrDigest", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPMA_LOCALITY_serialize(in->locality, &jso2); |
| return_if_error(r, "Serialize TPMA_LOCALITY"); |
| |
| json_object_object_add(*jso, "locality", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2_ALG_ID_serialize(in->parentNameAlg, &jso2); |
| return_if_error(r, "Serialize TPM2_ALG_ID"); |
| |
| json_object_object_add(*jso, "parentNameAlg", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->parentName, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "parentName", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_NAME_serialize(&in->parentQualifiedName, &jso2); |
| return_if_error(r, "Serialize TPM2B_NAME"); |
| |
| json_object_object_add(*jso, "parentQualifiedName", jso2); |
| jso2 = NULL; |
| r = ifapi_json_TPM2B_DATA_serialize(&in->outsideInfo, &jso2); |
| return_if_error(r, "Serialize TPM2B_DATA"); |
| |
| json_object_object_add(*jso, "outsideInfo", jso2); |
| return TSS2_RC_SUCCESS; |
| } |
| |
| /** Serialize a TPM2B_CREATION_DATA to json. |
| * |
| * @param[in] in value to be serialized. |
| * @param[out] jso pointer to the json object. |
| * @retval TSS2_RC_SUCCESS if the function call was a success. |
| * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory. |
| * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_CREATION_DATA. |
| * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed. |
| */ |
| TSS2_RC |
| ifapi_json_TPM2B_CREATION_DATA_serialize(const TPM2B_CREATION_DATA *in, json_object **jso) |
| { |
| if (*jso == NULL) |
| *jso = json_object_new_object (); |
| return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY); |
| |
| json_object *jso2; |
| |
| jso2 = NULL; |
| if (ifapi_json_UINT16_serialize(in->size, &jso2)) |
| return TSS2_FAPI_RC_BAD_VALUE; |
| |
| json_object_object_add(*jso, "size", jso2); |
| |
| jso2 = NULL; |
| if (ifapi_json_TPMS_CREATION_DATA_serialize(&in->creationData, &jso2)) |
| return TSS2_FAPI_RC_BAD_VALUE; |
| |
| json_object_object_add(*jso, "creationData", jso2); |
| |
| return TSS2_RC_SUCCESS; |
| } |