1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*******************************************************************************
3 * Copyright 2018-2019, Fraunhofer SIT sponsored by Infineon Technologies AG
4 * All rights reserved.
5 ******************************************************************************/
6
7 #ifdef HAVE_CONFIG_H
8 #include <config.h>
9 #endif
10
11 #include <stdio.h>
12
13 #include "tpm_json_serialize.h"
14 #define LOGMODULE fapijson
15 #include "util/log.h"
16 #include "util/aux_util.h"
17
18 #define CHECK_IN_LIST(type, needle, ...) \
19 type tab[] = { __VA_ARGS__ }; \
20 size_t i; \
21 for(i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) \
22 if (needle == tab[i]) \
23 break; \
24 if (i == sizeof(tab) / sizeof(tab[0])) { \
25 LOG_ERROR("Bad value"); \
26 return TSS2_FAPI_RC_BAD_VALUE; \
27 }
28
29 /** Serialize a TPMS_EMPTY.
30 *
31 * @param[in] in not used.
32 * @param[in] jso not used.
33 * @retval TSS2_RC_SUCCESS is always returnde.
34 */
35 TSS2_RC
ifapi_json_TPMS_EMPTY_serialize(const TPMS_EMPTY * in,json_object ** jso)36 ifapi_json_TPMS_EMPTY_serialize(const TPMS_EMPTY *in, json_object **jso)
37 {
38 UNUSED(in);
39 UNUSED(jso);
40 return TSS2_RC_SUCCESS;
41 }
42
43 /** Serialize a pcr selection to json
44 *
45 * @param[in] sizeofSelect size of selection byte array.
46 * @param[in] pcrSelect selection array.
47 * @param[out] jso pointer to the json object.
48 * @retval TSS2_RC_SUCCESS if the function call was a success.
49 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
50 * @retval TSS2_FAPI_RC_BAD_VALUE if sizeofSelect is too big.
51 */
52 TSS2_RC
ifapi_json_pcr_select_serialize(const UINT8 sizeofSelect,const BYTE pcrSelect[],json_object ** jso)53 ifapi_json_pcr_select_serialize(
54 const UINT8 sizeofSelect,
55 const BYTE pcrSelect[],
56 json_object **jso)
57 {
58 if (*jso == NULL) {
59 *jso = json_object_new_array();
60 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
61 }
62 if (sizeofSelect > TPM2_PCR_SELECT_MAX) {
63 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_PCR_SELECT_MAX)",
64 (size_t)sizeofSelect, (size_t)TPM2_PCR_SELECT_MAX);
65 return TSS2_FAPI_RC_BAD_VALUE;
66 }
67 UINT32 i1, i2;
68 json_object *jso2;
69 for (i1 = 0; i1 < TPM2_PCR_LAST - TPM2_PCR_FIRST; i1++) {
70 i2 = i1 + TPM2_PCR_FIRST;
71 if (pcrSelect[i2 / 8] & (BYTE)(1 << (i2 % 8))) {
72 jso2 = json_object_new_int(i2);
73 return_if_null(jso2, "Out of memory.", TSS2_FAPI_RC_MEMORY);
74 json_object_array_add(*jso, jso2);
75 }
76 }
77 return TSS2_RC_SUCCESS;
78 }
79
80 /** Serialize a TPMS_PCR_SELECT structure to json.
81 *
82 * @param[in] in value to be serialized.
83 * @param[out] jso pointer to the json object.
84 * @retval TSS2_RC_SUCCESS if the function call was a success.
85 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
86 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_PCR_SELECTION.
87 */
88 TSS2_RC
ifapi_json_TPMS_PCR_SELECT_serialize(const TPMS_PCR_SELECT * in,json_object ** jso)89 ifapi_json_TPMS_PCR_SELECT_serialize(const TPMS_PCR_SELECT *in,
90 json_object **jso)
91 {
92 TSS2_RC r;
93
94 r = ifapi_json_pcr_select_serialize(in->sizeofSelect, &in->pcrSelect[0], jso);
95 return_if_error(r, "Serialize pcr selection");
96
97 return TSS2_RC_SUCCESS;
98 }
99
100
101 /** Serialize a TPMS_PCR_SELECTION structure to json.
102 *
103 * @param[in] in value to be serialized.
104 * @param[out] jso pointer to the json object.
105 * @retval TSS2_RC_SUCCESS if the function call was a success.
106 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
107 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_PCR_SELECTION.
108 */
109 TSS2_RC
ifapi_json_TPMS_PCR_SELECTION_serialize(const TPMS_PCR_SELECTION * in,json_object ** jso)110 ifapi_json_TPMS_PCR_SELECTION_serialize(const TPMS_PCR_SELECTION *in,
111 json_object **jso)
112 {
113 if (*jso == NULL) {
114 *jso = json_object_new_object();
115 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
116 }
117 TSS2_RC r;
118 json_object *jso2 = NULL;
119 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hash, &jso2);
120 return_if_error(r, "Serialize pcr selection");
121
122 json_object_object_add(*jso, "hash", jso2);
123 jso2 = NULL;
124 r = ifapi_json_pcr_select_serialize(in->sizeofSelect, &in->pcrSelect[0], &jso2);
125 return_if_error(r, "Serialize pcr selection");
126
127 json_object_object_add(*jso, "pcrSelect", jso2);
128 return TSS2_RC_SUCCESS;
129 }
130
131 /** Serialize a TPMS_TAGGED_PCR_SELECT structure to json.
132 *
133 * @param[in] in value to be serialized.
134 * @param[out] jso pointer to the json object.
135 * @retval TSS2_RC_SUCCESS if the function call was a success.
136 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
137 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TAGGED_PCR_SELECT.
138 */
139 TSS2_RC
ifapi_json_TPMS_TAGGED_PCR_SELECT_serialize(const TPMS_TAGGED_PCR_SELECT * in,json_object ** jso)140 ifapi_json_TPMS_TAGGED_PCR_SELECT_serialize(const TPMS_TAGGED_PCR_SELECT *in,
141 json_object **jso)
142 {
143 TSS2_RC r;
144 if (*jso == NULL)
145 *jso = json_object_new_object();
146 json_object *jso2 = NULL;
147 r = ifapi_json_TPM2_PT_PCR_serialize(in->tag, &jso2);
148 return_if_error(r, "Serialize pcr selection");
149
150 json_object_object_add(*jso, "tag", jso2);
151 jso2 = NULL;
152 r = ifapi_json_pcr_select_serialize(in->sizeofSelect, &in->pcrSelect[0], &jso2);
153 return_if_error(r, "Serialize pcr selection");
154
155 json_object_object_add(*jso, "pcrSelect", jso2);
156 return TSS2_RC_SUCCESS;
157 }
158
159 /** Serialize a base_type UINT16 to json.
160 *
161 * @param[in] in value to be serialized.
162 * @param[out] jso pointer to the json object.
163 * @retval TSS2_RC_SUCCESS if the function call was a success.
164 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
165 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type UINT16.
166 */
167 TSS2_RC
ifapi_json_UINT16_serialize(const UINT16 in,json_object ** jso)168 ifapi_json_UINT16_serialize(const UINT16 in, json_object **jso)
169 {
170 *jso = json_object_new_int64(in);
171 if (*jso == NULL) {
172 LOG_ERROR("Bad value %04"PRIx16"", in);
173 return TSS2_FAPI_RC_BAD_VALUE;
174 }
175 return TSS2_RC_SUCCESS;
176 }
177
178 /** Serialize a base_type UINT32 to json.
179 *
180 * @param[in] in value to be serialized.
181 * @param[out] jso pointer to the json object.
182 * @retval TSS2_RC_SUCCESS if the function call was a success.
183 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
184 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type UINT32.
185 */
186 TSS2_RC
ifapi_json_UINT32_serialize(const UINT32 in,json_object ** jso)187 ifapi_json_UINT32_serialize(const UINT32 in, json_object **jso)
188 {
189 *jso = json_object_new_int64(in);
190 if (*jso == NULL) {
191 LOG_ERROR("Bad value %"PRIx32 "", in);
192 return TSS2_FAPI_RC_BAD_VALUE;
193 }
194 return TSS2_RC_SUCCESS;
195 }
196
197 /** Serialize a base_type INT32 to json.
198 *
199 * @param[in] in value to be serialized.
200 * @param[out] jso pointer to the json object.
201 * @retval TSS2_RC_SUCCESS if the function call was a success.
202 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
203 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type INT32.
204 */
205 TSS2_RC
ifapi_json_INT32_serialize(const INT32 in,json_object ** jso)206 ifapi_json_INT32_serialize(const INT32 in, json_object **jso)
207 {
208 *jso = json_object_new_int64(in);
209 if (*jso == NULL) {
210 LOG_ERROR("Bad value %"PRIi32 "", in);
211 return TSS2_FAPI_RC_BAD_VALUE;
212 }
213 return TSS2_RC_SUCCESS;
214 }
215
216 /** Serialize a base_type UINT64 to json.
217 *
218 * @param[in] in variable to be serialized.
219 * @param[out] jso pointer to the json object.
220 * @retval TSS2_RC_SUCCESS if the function call was a success.
221 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
222 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type UINT64.
223 */
224 TSS2_RC
ifapi_json_UINT64_serialize(UINT64 in,json_object ** jso)225 ifapi_json_UINT64_serialize(UINT64 in, json_object **jso)
226 {
227 json_object *jso1 = NULL, *jso2 = NULL;
228 if (in < 0x1000000000000) {
229 *jso = json_object_new_int64(in);
230 if (*jso == NULL) {
231 LOG_ERROR("Bad value %"PRIu32 "", (uint32_t)in);
232 return TSS2_FAPI_RC_BAD_VALUE;
233 }
234 return TSS2_RC_SUCCESS;
235 }
236
237 jso1 = json_object_new_int64(in / 0x100000000);
238 return_if_null(jso1, "Out of memory.", TSS2_FAPI_RC_MEMORY);
239
240 in %= 0x100000000;
241
242 jso2 = json_object_new_int64(in);
243 if (!jso2) json_object_put(jso1);
244 return_if_null(jso2, "Out of memory.", TSS2_FAPI_RC_MEMORY);
245
246 *jso = json_object_new_array();
247 if (!*jso) json_object_put(jso1);
248 if (!*jso) json_object_put(jso2);
249 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
250
251 json_object_array_add(*jso, jso1);
252 json_object_array_add(*jso, jso2);
253
254 return TSS2_RC_SUCCESS;
255 }
256
257 /** Serialize TPM2_GENERATED to json.
258 *
259 * @param[in] in constant to be serialized.
260 * @param[out] jso pointer to the json object.
261 * @retval TSS2_RC_SUCCESS if the function call was a success.
262 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
263 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_GENERATED.
264 */
265 TSS2_RC
ifapi_json_TPM2_GENERATED_serialize(const TPM2_GENERATED in,json_object ** jso)266 ifapi_json_TPM2_GENERATED_serialize(const TPM2_GENERATED in, json_object **jso)
267 {
268 if (in != TPM2_GENERATED_VALUE) {
269 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
270 }
271
272 *jso = json_object_new_string("VALUE");
273 check_oom(*jso);
274
275 return TSS2_RC_SUCCESS;
276 }
277
278 /** Serialize TPM2_ALG_ID to json.
279 *
280 * @param[in] in constant to be serialized.
281 * @param[out] jso pointer to the json object.
282 * @retval TSS2_RC_SUCCESS if the function call was a success.
283 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
284 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_ALG_ID.
285 */
286 TSS2_RC
ifapi_json_TPM2_ALG_ID_serialize(const TPM2_ALG_ID in,json_object ** jso)287 ifapi_json_TPM2_ALG_ID_serialize(const TPM2_ALG_ID in, json_object **jso)
288 {
289 static const struct { TPM2_ALG_ID in; const char *name; } tab[] = {
290 { TPM2_ALG_ERROR, "ERROR" },
291 { TPM2_ALG_RSA, "RSA" },
292 { TPM2_ALG_TDES, "TDES" },
293 /* We prefer SHA1 as output over SHA */
294 /* { TPM2_ALG_SHA, "SHA" },*/
295 { TPM2_ALG_SHA1, "SHA1" },
296 { TPM2_ALG_CMAC, "CMAC" },
297 { TPM2_ALG_HMAC, "HMAC" },
298 { TPM2_ALG_AES, "AES" },
299 { TPM2_ALG_MGF1, "MGF1" },
300 { TPM2_ALG_KEYEDHASH, "KEYEDHASH" },
301 { TPM2_ALG_XOR, "XOR" },
302 { TPM2_ALG_SHA256, "SHA256" },
303 { TPM2_ALG_SHA384, "SHA384" },
304 { TPM2_ALG_SHA512, "SHA512" },
305 { TPM2_ALG_NULL, "NULL" },
306 { TPM2_ALG_SM3_256, "SM3_256" },
307 { TPM2_ALG_SM4, "SM4" },
308 { TPM2_ALG_RSASSA, "RSASSA" },
309 { TPM2_ALG_RSAES, "RSAES" },
310 { TPM2_ALG_RSAPSS, "RSAPSS" },
311 { TPM2_ALG_OAEP, "OAEP" },
312 { TPM2_ALG_ECDSA, "ECDSA" },
313 { TPM2_ALG_ECDH, "ECDH" },
314 { TPM2_ALG_ECDAA, "ECDAA" },
315 { TPM2_ALG_SM2, "SM2" },
316 { TPM2_ALG_ECSCHNORR, "ECSCHNORR" },
317 { TPM2_ALG_ECMQV, "ECMQV" },
318 { TPM2_ALG_KDF1_SP800_56A, "KDF1_SP800_56A" },
319 { TPM2_ALG_KDF2, "KDF2" },
320 { TPM2_ALG_KDF1_SP800_108, "KDF1_SP800_108" },
321 { TPM2_ALG_ECC, "ECC" },
322 { TPM2_ALG_SYMCIPHER, "SYMCIPHER" },
323 { TPM2_ALG_CAMELLIA, "CAMELLIA" },
324 { TPM2_ALG_CTR, "CTR" },
325 { TPM2_ALG_OFB, "OFB" },
326 { TPM2_ALG_CBC, "CBC" },
327 { TPM2_ALG_CFB, "CFB" },
328 { TPM2_ALG_ECB, "ECB" },
329 };
330
331 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
332 if (tab[i].in == in) {
333 *jso = json_object_new_string(tab[i].name);
334 check_oom(*jso);
335 return TSS2_RC_SUCCESS;
336 }
337 }
338 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
339 }
340
341 /** Serialize TPM2_ECC_CURVE to json.
342 *
343 * @param[in] in constant to be serialized.
344 * @param[out] jso pointer to the json object.
345 * @retval TSS2_RC_SUCCESS if the function call was a success.
346 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
347 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_ECC_CURVE.
348 */
349 TSS2_RC
ifapi_json_TPM2_ECC_CURVE_serialize(const TPM2_ECC_CURVE in,json_object ** jso)350 ifapi_json_TPM2_ECC_CURVE_serialize(const TPM2_ECC_CURVE in, json_object **jso)
351 {
352 static const struct { TPM2_ECC_CURVE in; char *name; } tab[] = {
353 { TPM2_ECC_NONE, "NONE" },
354 { TPM2_ECC_NIST_P192, "NIST_P192" },
355 { TPM2_ECC_NIST_P224, "NIST_P224" },
356 { TPM2_ECC_NIST_P256, "NIST_P256" },
357 { TPM2_ECC_NIST_P384, "NIST_P384" },
358 { TPM2_ECC_NIST_P521, "NIST_P521" },
359 { TPM2_ECC_BN_P256, "BN_P256" },
360 { TPM2_ECC_BN_P638, "BN_P638" },
361 { TPM2_ECC_SM2_P256, "SM2_P256" },
362 };
363
364 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
365 if (tab[i].in == in) {
366 *jso = json_object_new_string(tab[i].name);
367 check_oom(*jso);
368 return TSS2_RC_SUCCESS;
369 }
370 }
371 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
372 }
373
374 /** Serialize TPM2_CC to json.
375 *
376 * @param[in] in constant to be serialized.
377 * @param[out] jso pointer to the json object.
378 * @retval TSS2_RC_SUCCESS if the function call was a success.
379 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
380 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_CC.
381 */
382 TSS2_RC
ifapi_json_TPM2_CC_serialize(const TPM2_CC in,json_object ** jso)383 ifapi_json_TPM2_CC_serialize(const TPM2_CC in, json_object **jso)
384 {
385 static const struct { TPM2_CC in; char *name; } tab[] = {
386 /* We don't want to return FIRST but the actual value */
387 /* { TPM2_CC_FIRST, "FIRST" }, */
388 { TPM2_CC_NV_UndefineSpaceSpecial, "NV_UndefineSpaceSpecial" },
389 { TPM2_CC_EvictControl, "EvictControl" },
390 { TPM2_CC_HierarchyControl, "HierarchyControl" },
391 { TPM2_CC_NV_UndefineSpace, "NV_UndefineSpace" },
392 { TPM2_CC_ChangeEPS, "ChangeEPS" },
393 { TPM2_CC_ChangePPS, "ChangePPS" },
394 { TPM2_CC_Clear, "Clear" },
395 { TPM2_CC_ClearControl, "ClearControl" },
396 { TPM2_CC_ClockSet, "ClockSet" },
397 { TPM2_CC_HierarchyChangeAuth, "HierarchyChangeAuth" },
398 { TPM2_CC_NV_DefineSpace, "NV_DefineSpace" },
399 { TPM2_CC_PCR_Allocate, "PCR_Allocate" },
400 { TPM2_CC_PCR_SetAuthPolicy, "PCR_SetAuthPolicy" },
401 { TPM2_CC_PP_Commands, "PP_Commands" },
402 { TPM2_CC_SetPrimaryPolicy, "SetPrimaryPolicy" },
403 { TPM2_CC_FieldUpgradeStart, "FieldUpgradeStart" },
404 { TPM2_CC_ClockRateAdjust, "ClockRateAdjust" },
405 { TPM2_CC_CreatePrimary, "CreatePrimary" },
406 { TPM2_CC_NV_GlobalWriteLock, "NV_GlobalWriteLock" },
407 { TPM2_CC_GetCommandAuditDigest, "GetCommandAuditDigest" },
408 { TPM2_CC_NV_Increment, "NV_Increment" },
409 { TPM2_CC_NV_SetBits, "NV_SetBits" },
410 { TPM2_CC_NV_Extend, "NV_Extend" },
411 { TPM2_CC_NV_Write, "NV_Write" },
412 { TPM2_CC_NV_WriteLock, "NV_WriteLock" },
413 { TPM2_CC_DictionaryAttackLockReset, "DictionaryAttackLockReset" },
414 { TPM2_CC_DictionaryAttackParameters, "DictionaryAttackParameters" },
415 { TPM2_CC_NV_ChangeAuth, "NV_ChangeAuth" },
416 { TPM2_CC_PCR_Event, "PCR_Event" },
417 { TPM2_CC_PCR_Reset, "PCR_Reset" },
418 { TPM2_CC_SequenceComplete, "SequenceComplete" },
419 { TPM2_CC_SetAlgorithmSet, "SetAlgorithmSet" },
420 { TPM2_CC_SetCommandCodeAuditStatus, "SetCommandCodeAuditStatus" },
421 { TPM2_CC_FieldUpgradeData, "FieldUpgradeData" },
422 { TPM2_CC_IncrementalSelfTest, "IncrementalSelfTest" },
423 { TPM2_CC_SelfTest, "SelfTest" },
424 { TPM2_CC_Startup, "Startup" },
425 { TPM2_CC_Shutdown, "Shutdown" },
426 { TPM2_CC_StirRandom, "StirRandom" },
427 { TPM2_CC_ActivateCredential, "ActivateCredential" },
428 { TPM2_CC_Certify, "Certify" },
429 { TPM2_CC_PolicyNV, "PolicyNV" },
430 { TPM2_CC_CertifyCreation, "CertifyCreation" },
431 { TPM2_CC_Duplicate, "Duplicate" },
432 { TPM2_CC_GetTime, "GetTime" },
433 { TPM2_CC_GetSessionAuditDigest, "GetSessionAuditDigest" },
434 { TPM2_CC_NV_Read, "NV_Read" },
435 { TPM2_CC_NV_ReadLock, "NV_ReadLock" },
436 { TPM2_CC_ObjectChangeAuth, "ObjectChangeAuth" },
437 { TPM2_CC_PolicySecret, "PolicySecret" },
438 { TPM2_CC_Rewrap, "Rewrap" },
439 { TPM2_CC_Create, "Create" },
440 { TPM2_CC_ECDH_ZGen, "ECDH_ZGen" },
441 { TPM2_CC_HMAC, "HMAC" },
442 { TPM2_CC_Import, "Import" },
443 { TPM2_CC_Load, "Load" },
444 { TPM2_CC_Quote, "Quote" },
445 { TPM2_CC_RSA_Decrypt, "RSA_Decrypt" },
446 { TPM2_CC_HMAC_Start, "HMAC_Start" },
447 { TPM2_CC_SequenceUpdate, "SequenceUpdate" },
448 { TPM2_CC_Sign, "Sign" },
449 { TPM2_CC_Unseal, "Unseal" },
450 { TPM2_CC_PolicySigned, "PolicySigned" },
451 { TPM2_CC_ContextLoad, "ContextLoad" },
452 { TPM2_CC_ContextSave, "ContextSave" },
453 { TPM2_CC_ECDH_KeyGen, "ECDH_KeyGen" },
454 { TPM2_CC_EncryptDecrypt, "EncryptDecrypt" },
455 { TPM2_CC_FlushContext, "FlushContext" },
456 { TPM2_CC_LoadExternal, "LoadExternal" },
457 { TPM2_CC_MakeCredential, "MakeCredential" },
458 { TPM2_CC_NV_ReadPublic, "NV_ReadPublic" },
459 { TPM2_CC_PolicyAuthorize, "PolicyAuthorize" },
460 { TPM2_CC_PolicyAuthValue, "PolicyAuthValue" },
461 { TPM2_CC_PolicyCommandCode, "PolicyCommandCode" },
462 { TPM2_CC_PolicyCounterTimer, "PolicyCounterTimer" },
463 { TPM2_CC_PolicyCpHash, "PolicyCpHash" },
464 { TPM2_CC_PolicyLocality, "PolicyLocality" },
465 { TPM2_CC_PolicyNameHash, "PolicyNameHash" },
466 { TPM2_CC_PolicyOR, "PolicyOR" },
467 { TPM2_CC_PolicyTicket, "PolicyTicket" },
468 { TPM2_CC_ReadPublic, "ReadPublic" },
469 { TPM2_CC_RSA_Encrypt, "RSA_Encrypt" },
470 { TPM2_CC_StartAuthSession, "StartAuthSession" },
471 { TPM2_CC_VerifySignature, "VerifySignature" },
472 { TPM2_CC_ECC_Parameters, "ECC_Parameters" },
473 { TPM2_CC_FirmwareRead, "FirmwareRead" },
474 { TPM2_CC_GetCapability, "GetCapability" },
475 { TPM2_CC_GetRandom, "GetRandom" },
476 { TPM2_CC_GetTestResult, "GetTestResult" },
477 { TPM2_CC_Hash, "Hash" },
478 { TPM2_CC_PCR_Read, "PCR_Read" },
479 { TPM2_CC_PolicyPCR, "PolicyPCR" },
480 { TPM2_CC_PolicyRestart, "PolicyRestart" },
481 { TPM2_CC_ReadClock, "ReadClock" },
482 { TPM2_CC_PCR_Extend, "PCR_Extend" },
483 { TPM2_CC_PCR_SetAuthValue, "PCR_SetAuthValue" },
484 { TPM2_CC_NV_Certify, "NV_Certify" },
485 { TPM2_CC_EventSequenceComplete, "EventSequenceComplete" },
486 { TPM2_CC_HashSequenceStart, "HashSequenceStart" },
487 { TPM2_CC_PolicyPhysicalPresence, "PolicyPhysicalPresence" },
488 { TPM2_CC_PolicyDuplicationSelect, "PolicyDuplicationSelect" },
489 { TPM2_CC_PolicyGetDigest, "PolicyGetDigest" },
490 { TPM2_CC_TestParms, "TestParms" },
491 { TPM2_CC_Commit, "Commit" },
492 { TPM2_CC_PolicyPassword, "PolicyPassword" },
493 { TPM2_CC_ZGen_2Phase, "ZGen_2Phase" },
494 { TPM2_CC_EC_Ephemeral, "EC_Ephemeral" },
495 { TPM2_CC_PolicyNvWritten, "PolicyNvWritten" },
496 { TPM2_CC_PolicyTemplate, "PolicyTemplate" },
497 { TPM2_CC_CreateLoaded, "CreateLoaded" },
498 { TPM2_CC_PolicyAuthorizeNV, "PolicyAuthorizeNV" },
499 { TPM2_CC_EncryptDecrypt2, "EncryptDecrypt2" },
500 /* We don't want to return LAST but the actual value */
501 /* { TPM2_CC_LAST, "LAST" }, */
502 { TPM2_CC_Vendor_TCG_Test, "Vendor_TCG_Test" },
503 };
504
505 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
506 if (tab[i].in == in) {
507 *jso = json_object_new_string(tab[i].name);
508 check_oom(*jso);
509 return TSS2_RC_SUCCESS;
510 }
511 }
512 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
513 }
514
515 /** Serialize TPM2_EO to json.
516 *
517 * @param[in] in constant to be serialized.
518 * @param[out] jso pointer to the json object.
519 * @retval TSS2_RC_SUCCESS if the function call was a success.
520 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
521 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_EO.
522 */
523 TSS2_RC
ifapi_json_TPM2_EO_serialize(const TPM2_EO in,json_object ** jso)524 ifapi_json_TPM2_EO_serialize(const TPM2_EO in, json_object **jso)
525 {
526 static const struct { TPM2_EO in; char *name; } tab[] = {
527 { TPM2_EO_EQ, "EQ" },
528 { TPM2_EO_NEQ, "TPM2_EO_NEQ" },
529 { TPM2_EO_SIGNED_GT, "SIGNED_GT" },
530 { TPM2_EO_UNSIGNED_GT, "UNSIGNED_GT" },
531 { TPM2_EO_SIGNED_LT, "SIGNED_LT" },
532 { TPM2_EO_UNSIGNED_LT, "UNSIGNED_LT" },
533 { TPM2_EO_SIGNED_GE, "SIGNED_GE" },
534 { TPM2_EO_UNSIGNED_GE, "UNSIGNED_GE" },
535 { TPM2_EO_SIGNED_LE, "SIGNED_LE" },
536 { TPM2_EO_UNSIGNED_LE, "UNSIGNED_LE" },
537 { TPM2_EO_BITSET, "BITSET" },
538 { TPM2_EO_BITCLEAR, "BITCLEAR" },
539 };
540
541 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
542 if (tab[i].in == in) {
543 *jso = json_object_new_string(tab[i].name);
544 check_oom(*jso);
545 return TSS2_RC_SUCCESS;
546 }
547 }
548 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
549 }
550
551 /** Serialize TPM2_ST to json.
552 *
553 * @param[in] in constant to be serialized.
554 * @param[out] jso pointer to the json object.
555 * @retval TSS2_RC_SUCCESS if the function call was a success.
556 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
557 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_ST.
558 */
559 TSS2_RC
ifapi_json_TPM2_ST_serialize(const TPM2_ST in,json_object ** jso)560 ifapi_json_TPM2_ST_serialize(const TPM2_ST in, json_object **jso)
561 {
562 static const struct { TPM2_ST in; char *name; } tab[] = {
563 { TPM2_ST_RSP_COMMAND, "RSP_COMMAND" },
564 { TPM2_ST_NULL, "NULL" },
565 { TPM2_ST_NO_SESSIONS, "NO_SESSIONS" },
566 { TPM2_ST_SESSIONS, "SESSIONS" },
567 { TPM2_ST_ATTEST_NV, "ATTEST_NV" },
568 { TPM2_ST_ATTEST_COMMAND_AUDIT, "ATTEST_COMMAND_AUDIT" },
569 { TPM2_ST_ATTEST_SESSION_AUDIT, "ATTEST_SESSION_AUDIT" },
570 { TPM2_ST_ATTEST_CERTIFY, "ATTEST_CERTIFY" },
571 { TPM2_ST_ATTEST_QUOTE, "ATTEST_QUOTE" },
572 { TPM2_ST_ATTEST_TIME, "ATTEST_TIME" },
573 { TPM2_ST_ATTEST_CREATION, "ATTEST_CREATION" },
574 { TPM2_ST_CREATION, "CREATION" },
575 { TPM2_ST_VERIFIED, "VERIFIED" },
576 { TPM2_ST_AUTH_SECRET, "AUTH_SECRET" },
577 { TPM2_ST_HASHCHECK, "HASHCHECK" },
578 { TPM2_ST_AUTH_SIGNED, "AUTH_SIGNED" },
579 { TPM2_ST_FU_MANIFEST, "FU_MANIFEST" },
580 };
581
582 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
583 if (tab[i].in == in) {
584 *jso = json_object_new_string(tab[i].name);
585 check_oom(*jso);
586 return TSS2_RC_SUCCESS;
587 }
588 }
589 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
590 }
591
592 /** Serialize TPM2_CAP to json.
593 *
594 * @param[in] in constant to be serialized.
595 * @param[out] jso pointer to the json object.
596 * @retval TSS2_RC_SUCCESS if the function call was a success.
597 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
598 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_CAP.
599 */
600 TSS2_RC
ifapi_json_TPM2_CAP_serialize(const TPM2_CAP in,json_object ** jso)601 ifapi_json_TPM2_CAP_serialize(const TPM2_CAP in, json_object **jso)
602 {
603 static const struct { TPM2_CAP in; char *name; } tab[] = {
604 { TPM2_CAP_ALGS, "ALGS" },
605 { TPM2_CAP_HANDLES, "HANDLES" },
606 { TPM2_CAP_COMMANDS, "COMMANDS" },
607 { TPM2_CAP_PP_COMMANDS, "PP_COMMANDS" },
608 { TPM2_CAP_AUDIT_COMMANDS, "AUDIT_COMMANDS" },
609 { TPM2_CAP_PCRS, "PCRS" },
610 { TPM2_CAP_TPM_PROPERTIES, "TPM_PROPERTIES" },
611 { TPM2_CAP_PCR_PROPERTIES, "PCR_PROPERTIES" },
612 { TPM2_CAP_ECC_CURVES, "ECC_CURVES" },
613 { TPM2_CAP_LAST, "LAST" },
614 { TPM2_CAP_VENDOR_PROPERTY, "VENDOR_PROPERTY" },
615 };
616
617 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
618 if (tab[i].in == in) {
619 *jso = json_object_new_string(tab[i].name);
620 check_oom(*jso);
621 return TSS2_RC_SUCCESS;
622 }
623 }
624 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
625 }
626
627 /** Serialize TPM2_PT to json.
628 *
629 * @param[in] in constant to be serialized.
630 * @param[out] jso pointer to the json object.
631 * @retval TSS2_RC_SUCCESS if the function call was a success.
632 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
633 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_PT.
634 */
635 TSS2_RC
ifapi_json_TPM2_PT_serialize(const TPM2_PT in,json_object ** jso)636 ifapi_json_TPM2_PT_serialize(const TPM2_PT in, json_object **jso)
637 {
638 static const struct { TPM2_PT in; char *name; } tab[] = {
639 { TPM2_PT_NONE, "NONE" },
640 { TPM2_PT_GROUP, "GROUP" },
641 //{ TPM2_PT_FIXED, "FIXED" },
642 { TPM2_PT_FAMILY_INDICATOR, "FAMILY_INDICATOR" },
643 { TPM2_PT_LEVEL, "LEVEL" },
644 { TPM2_PT_REVISION, "REVISION" },
645 { TPM2_PT_DAY_OF_YEAR, "DAY_OF_YEAR" },
646 { TPM2_PT_YEAR, "YEAR" },
647 { TPM2_PT_MANUFACTURER, "MANUFACTURER" },
648 { TPM2_PT_VENDOR_STRING_1, "VENDOR_STRING_1" },
649 { TPM2_PT_VENDOR_STRING_2, "VENDOR_STRING_2" },
650 { TPM2_PT_VENDOR_STRING_3, "VENDOR_STRING_3" },
651 { TPM2_PT_VENDOR_STRING_4, "VENDOR_STRING_4" },
652 { TPM2_PT_VENDOR_TPM_TYPE, "VENDOR_TPM_TYPE" },
653 { TPM2_PT_FIRMWARE_VERSION_1, "FIRMWARE_VERSION_1" },
654 { TPM2_PT_FIRMWARE_VERSION_2, "FIRMWARE_VERSION_2" },
655 { TPM2_PT_INPUT_BUFFER, "INPUT_BUFFER" },
656 { TPM2_PT_HR_TRANSIENT_MIN, "HR_TRANSIENT_MIN" },
657 { TPM2_PT_HR_PERSISTENT_MIN, "HR_PERSISTENT_MIN" },
658 { TPM2_PT_HR_LOADED_MIN, "HR_LOADED_MIN" },
659 { TPM2_PT_ACTIVE_SESSIONS_MAX, "ACTIVE_SESSIONS_MAX" },
660 { TPM2_PT_PCR_COUNT, "PCR_COUNT" },
661 { TPM2_PT_PCR_SELECT_MIN, "PCR_SELECT_MIN" },
662 { TPM2_PT_CONTEXT_GAP_MAX, "CONTEXT_GAP_MAX" },
663 { TPM2_PT_NV_COUNTERS_MAX, "NV_COUNTERS_MAX" },
664 { TPM2_PT_NV_INDEX_MAX, "NV_INDEX_MAX" },
665 { TPM2_PT_MEMORY, "MEMORY" },
666 { TPM2_PT_CLOCK_UPDATE, "CLOCK_UPDATE" },
667 { TPM2_PT_CONTEXT_HASH, "CONTEXT_HASH" },
668 { TPM2_PT_CONTEXT_SYM, "CONTEXT_SYM" },
669 { TPM2_PT_CONTEXT_SYM_SIZE, "CONTEXT_SYM_SIZE" },
670 { TPM2_PT_ORDERLY_COUNT, "ORDERLY_COUNT" },
671 { TPM2_PT_MAX_COMMAND_SIZE, "MAX_COMMAND_SIZE" },
672 { TPM2_PT_MAX_RESPONSE_SIZE, "MAX_RESPONSE_SIZE" },
673 { TPM2_PT_MAX_DIGEST, "MAX_DIGEST" },
674 { TPM2_PT_MAX_OBJECT_CONTEXT, "MAX_OBJECT_CONTEXT" },
675 { TPM2_PT_MAX_SESSION_CONTEXT, "MAX_SESSION_CONTEXT" },
676 { TPM2_PT_PS_FAMILY_INDICATOR, "PS_FAMILY_INDICATOR" },
677 { TPM2_PT_PS_LEVEL, "PS_LEVEL" },
678 { TPM2_PT_PS_REVISION, "PS_REVISION" },
679 { TPM2_PT_PS_DAY_OF_YEAR, "PS_DAY_OF_YEAR" },
680 { TPM2_PT_PS_YEAR, "PS_YEAR" },
681 { TPM2_PT_SPLIT_MAX, "SPLIT_MAX" },
682 { TPM2_PT_TOTAL_COMMANDS, "TOTAL_COMMANDS" },
683 { TPM2_PT_LIBRARY_COMMANDS, "LIBRARY_COMMANDS" },
684 { TPM2_PT_VENDOR_COMMANDS, "VENDOR_COMMANDS" },
685 { TPM2_PT_NV_BUFFER_MAX, "NV_BUFFER_MAX" },
686 { TPM2_PT_MODES, "MODES" },
687 { TPM2_PT_MAX_CAP_BUFFER, "MAX_CAP_BUFFER" },
688 //{ TPM2_PT_VAR, "VAR" },
689 { TPM2_PT_PERMANENT, "PERMANENT" },
690 { TPM2_PT_STARTUP_CLEAR, "STARTUP_CLEAR" },
691 { TPM2_PT_HR_NV_INDEX, "HR_NV_INDEX" },
692 { TPM2_PT_HR_LOADED, "HR_LOADED" },
693 { TPM2_PT_HR_LOADED_AVAIL, "HR_LOADED_AVAIL" },
694 { TPM2_PT_HR_ACTIVE, "HR_ACTIVE" },
695 { TPM2_PT_HR_ACTIVE_AVAIL, "HR_ACTIVE_AVAIL" },
696 { TPM2_PT_HR_TRANSIENT_AVAIL, "HR_TRANSIENT_AVAIL" },
697 { TPM2_PT_HR_PERSISTENT, "HR_PERSISTENT" },
698 { TPM2_PT_HR_PERSISTENT_AVAIL, "HR_PERSISTENT_AVAIL" },
699 { TPM2_PT_NV_COUNTERS, "NV_COUNTERS" },
700 { TPM2_PT_NV_COUNTERS_AVAIL, "NV_COUNTERS_AVAIL" },
701 { TPM2_PT_ALGORITHM_SET, "ALGORITHM_SET" },
702 { TPM2_PT_LOADED_CURVES, "LOADED_CURVES" },
703 { TPM2_PT_LOCKOUT_COUNTER, "LOCKOUT_COUNTER" },
704 { TPM2_PT_MAX_AUTH_FAIL, "MAX_AUTH_FAIL" },
705 { TPM2_PT_LOCKOUT_INTERVAL, "LOCKOUT_INTERVAL" },
706 { TPM2_PT_LOCKOUT_RECOVERY, "LOCKOUT_RECOVERY" },
707 { TPM2_PT_NV_WRITE_RECOVERY, "NV_WRITE_RECOVERY" },
708 { TPM2_PT_AUDIT_COUNTER_0, "AUDIT_COUNTER_0" },
709 { TPM2_PT_AUDIT_COUNTER_1, "AUDIT_COUNTER_1" },
710 };
711
712 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
713 if (tab[i].in == in) {
714 *jso = json_object_new_string(tab[i].name);
715 check_oom(*jso);
716 return TSS2_RC_SUCCESS;
717 }
718 }
719 return_error2(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant: %"PRIx32, in);
720 }
721
722 /** Serialize TPM2_PT_PCR to json.
723 *
724 * @param[in] in constant to be serialized.
725 * @param[out] jso pointer to the json object.
726 * @retval TSS2_RC_SUCCESS if the function call was a success.
727 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
728 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_PT_PCR.
729 */
730 TSS2_RC
ifapi_json_TPM2_PT_PCR_serialize(const TPM2_PT_PCR in,json_object ** jso)731 ifapi_json_TPM2_PT_PCR_serialize(const TPM2_PT_PCR in, json_object **jso)
732 {
733 static const struct { TPM2_PT_PCR in; char *name; } tab[] = {
734 { TPM2_PT_PCR_SAVE, "SAVE" },
735 { TPM2_PT_PCR_EXTEND_L0, "EXTEND_L0" },
736 { TPM2_PT_PCR_RESET_L0, "RESET_L0" },
737 { TPM2_PT_PCR_EXTEND_L1, "EXTEND_L1" },
738 { TPM2_PT_PCR_RESET_L1, "RESET_L1" },
739 { TPM2_PT_PCR_EXTEND_L2, "EXTEND_L2" },
740 { TPM2_PT_PCR_RESET_L2, "RESET_L2" },
741 { TPM2_PT_PCR_EXTEND_L3, "EXTEND_L3" },
742 { TPM2_PT_PCR_RESET_L3, "RESET_L3" },
743 { TPM2_PT_PCR_EXTEND_L4, "EXTEND_L4" },
744 { TPM2_PT_PCR_RESET_L4, "RESET_L4" },
745 { TPM2_PT_PCR_NO_INCREMENT, "NO_INCREMENT" },
746 { TPM2_PT_PCR_DRTM_RESET, "DRTM_RESET" },
747 { TPM2_PT_PCR_POLICY, "POLICY" },
748 { TPM2_PT_PCR_AUTH, "AUTH" },
749 };
750
751 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
752 if (tab[i].in == in) {
753 *jso = json_object_new_string(tab[i].name);
754 check_oom(*jso);
755 return TSS2_RC_SUCCESS;
756 }
757 }
758 return_error2(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant: %"PRIx32, in);
759 }
760
761 /** Serialize value of type TPM2_HANDLE to json.
762 *
763 * @param[in] in value to be serialized.
764 * @param[out] jso pointer to the json object.
765 * @retval TSS2_RC_SUCCESS if the function call was a success.
766 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
767 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2_HANDLE.
768 */
769 TSS2_RC
ifapi_json_TPM2_HANDLE_serialize(const TPM2_HANDLE in,json_object ** jso)770 ifapi_json_TPM2_HANDLE_serialize(const TPM2_HANDLE in, json_object **jso)
771 {
772 *jso = json_object_new_int(in);
773 if (*jso == NULL) {
774 LOG_ERROR("Bad value %"PRIx32 "", in);
775 return TSS2_FAPI_RC_BAD_VALUE;
776 }
777 return TSS2_RC_SUCCESS;
778 }
779 /** Serialize a TPMA_ALGORITHM to json.
780 *
781 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
782 *
783 * @param[in] in value to be serialized.
784 * @param[out] jso pointer to the json object.
785 * @retval TSS2_RC_SUCCESS if the function call was a success.
786 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
787 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_ALGORITHM.
788 */
789 TSS2_RC
ifapi_json_TPMA_ALGORITHM_serialize(const TPMA_ALGORITHM in,json_object ** jso)790 ifapi_json_TPMA_ALGORITHM_serialize(const TPMA_ALGORITHM in, json_object **jso)
791 {
792 static const struct { TPMA_ALGORITHM in; char *name; } tab[] = {
793 { TPMA_ALGORITHM_ASYMMETRIC, "asymmetric" },
794 { TPMA_ALGORITHM_SYMMETRIC, "symmetric" },
795 { TPMA_ALGORITHM_HASH, "hash" },
796 { TPMA_ALGORITHM_OBJECT, "object" },
797 { TPMA_ALGORITHM_SIGNING, "signing" },
798 { TPMA_ALGORITHM_ENCRYPTING, "encrypting" },
799 { TPMA_ALGORITHM_METHOD, "method" },
800 };
801
802 UINT32 input;
803 input = (UINT32) in;
804 json_object *jso_bit;
805 if (*jso == NULL) {
806 *jso = json_object_new_object();
807 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
808 }
809 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
810 if (tab[i].in & input)
811 jso_bit = json_object_new_int(1);
812 else
813 jso_bit = json_object_new_int(0);
814 return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY);
815
816 json_object_object_add(*jso, tab[i].name, jso_bit);
817 }
818 return TSS2_RC_SUCCESS;
819 }
820
821 /** Serialize a TPMA_OBJECT to json.
822 *
823 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
824 *
825 * @param[in] in value to be serialized.
826 * @param[out] jso pointer to the json object.
827 * @retval TSS2_RC_SUCCESS if the function call was a success.
828 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
829 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_OBJECT.
830 */
831 TSS2_RC
ifapi_json_TPMA_OBJECT_serialize(const TPMA_OBJECT in,json_object ** jso)832 ifapi_json_TPMA_OBJECT_serialize(const TPMA_OBJECT in, json_object **jso)
833 {
834 static const struct { TPMA_OBJECT in; char *name; } tab[] = {
835 { TPMA_OBJECT_FIXEDTPM, "fixedTPM" },
836 { TPMA_OBJECT_STCLEAR, "stClear" },
837 { TPMA_OBJECT_FIXEDPARENT, "fixedParent" },
838 { TPMA_OBJECT_SENSITIVEDATAORIGIN, "sensitiveDataOrigin" },
839 { TPMA_OBJECT_USERWITHAUTH, "userWithAuth" },
840 { TPMA_OBJECT_ADMINWITHPOLICY, "adminWithPolicy" },
841 { TPMA_OBJECT_NODA, "noDA" },
842 { TPMA_OBJECT_ENCRYPTEDDUPLICATION, "encryptedDuplication" },
843 { TPMA_OBJECT_RESTRICTED, "restricted" },
844 { TPMA_OBJECT_DECRYPT, "decrypt" },
845 { TPMA_OBJECT_SIGN_ENCRYPT, "sign" },
846 };
847 UINT32 input;
848 input = (UINT32) in;
849 json_object *jso_bit;
850 if (*jso == NULL) {
851 *jso = json_object_new_object();
852 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
853 }
854 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
855 if (tab[i].in & input)
856 jso_bit = json_object_new_int(1);
857 else
858 jso_bit = json_object_new_int(0);
859 return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY);
860
861 json_object_object_add(*jso, tab[i].name, jso_bit);
862 }
863 return TSS2_RC_SUCCESS;
864 }
865
866 /** Serialize a TPMA_LOCALITY to json.
867 *
868 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
869 *
870 * @param[in] in value to be serialized.
871 * @param[out] jso pointer to the json object.
872 * @retval TSS2_RC_SUCCESS if the function call was a success.
873 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
874 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_LOCALITY.
875 */
876 TSS2_RC
ifapi_json_TPMA_LOCALITY_serialize(const TPMA_LOCALITY in,json_object ** jso)877 ifapi_json_TPMA_LOCALITY_serialize(const TPMA_LOCALITY in, json_object **jso)
878 {
879 static const struct { TPMA_LOCALITY in; char *name; } tab[] = {
880 { TPMA_LOCALITY_TPM2_LOC_ZERO, "ZERO" },
881 { TPMA_LOCALITY_TPM2_LOC_ONE, "ONE" },
882 { TPMA_LOCALITY_TPM2_LOC_TWO, "TWO" },
883 { TPMA_LOCALITY_TPM2_LOC_THREE, "THREE" },
884 { TPMA_LOCALITY_TPM2_LOC_FOUR, "FOUR" },
885 };
886
887 UINT8 input;
888 input = (UINT8) in;
889 json_object *jso_bit;
890 json_object *jso_bit_idx;
891 if (*jso == NULL) {
892 *jso = json_object_new_object();
893 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
894 }
895 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
896 if (tab[i].in & input)
897 jso_bit = json_object_new_int(1);
898 else
899 jso_bit = json_object_new_int(0);
900 return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY);
901
902 json_object_object_add(*jso, tab[i].name, jso_bit);
903 }
904 jso_bit_idx = json_object_new_int64((TPMA_LOCALITY_EXTENDED_MASK & input) >>
905 5);
906 return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY);
907
908 json_object_object_add(*jso, "Extended", jso_bit_idx);
909
910 return TSS2_RC_SUCCESS;
911 }
912
913 /** Serialize a TPMA_CC to json.
914 *
915 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
916 *
917 * @param[in] in value to be serialized.
918 * @param[out] jso pointer to the json object.
919 * @retval TSS2_RC_SUCCESS if the function call was a success.
920 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
921 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_CC.
922 */
923 TSS2_RC
ifapi_json_TPMA_CC_serialize(const TPMA_CC in,json_object ** jso)924 ifapi_json_TPMA_CC_serialize(const TPMA_CC in, json_object **jso)
925 {
926 static const struct { TPMA_CC in; char *name; } tab[] = {
927 { TPMA_CC_NV, "nv" },
928 { TPMA_CC_EXTENSIVE, "extensive" },
929 { TPMA_CC_FLUSHED, "flushed" },
930 { TPMA_CC_RHANDLE, "rHandle" },
931 { TPMA_CC_V, "V" },
932 };
933 TPM2_CC input;
934 input = (TPM2_CC) in;
935 json_object *jso_bit;
936 json_object *jso_bit_idx;
937 if (*jso == NULL) {
938 *jso = json_object_new_object();
939 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
940 }
941 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
942 if (tab[i].in & input)
943 jso_bit = json_object_new_int(1);
944 else
945 jso_bit = json_object_new_int(0);
946 return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY);
947
948 json_object_object_add(*jso, tab[i].name, jso_bit);
949 }
950 jso_bit_idx = json_object_new_int64((TPMA_CC_COMMANDINDEX_MASK & input) >> 0);
951 return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY);
952
953 json_object_object_add(*jso, "commandIndex", jso_bit_idx);
954
955 jso_bit_idx = json_object_new_int64((TPMA_CC_CHANDLES_MASK & input) >> 25);
956 return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY);
957
958 json_object_object_add(*jso, "cHandles", jso_bit_idx);
959
960 jso_bit_idx = json_object_new_int64((TPMA_CC_RES_MASK & input) >> 30);
961 return_if_null(jso_bit_idx, "Out of memory.", TSS2_FAPI_RC_MEMORY);
962
963 json_object_object_add(*jso, "Res", jso_bit_idx);
964
965 return TSS2_RC_SUCCESS;
966 }
967
968 /** Serialize TPMI_YES_NO to json.
969 *
970 * @param[in] in variable to be serialized.
971 * @param[out] jso pointer to the json object.
972 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
973 * the function.
974 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
975 */
976 TSS2_RC
ifapi_json_TPMI_YES_NO_serialize(const TPMI_YES_NO in,json_object ** jso)977 ifapi_json_TPMI_YES_NO_serialize(const TPMI_YES_NO in, json_object **jso)
978 {
979 if (in == YES) {
980 *jso = json_object_new_string("YES");
981 } else if (in == NO) {
982 *jso = json_object_new_string("NO");
983 } else {
984 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
985 }
986 check_oom(*jso);
987 return TSS2_RC_SUCCESS;
988 }
989
990 /** Serialize TPMI_RH_HIERARCHY to json.
991 *
992 * @param[in] in variable to be serialized.
993 * @param[out] jso pointer to the json object.
994 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
995 * the function.
996 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
997 */
998 TSS2_RC
ifapi_json_TPMI_RH_HIERARCHY_serialize(const TPMI_RH_HIERARCHY in,json_object ** jso)999 ifapi_json_TPMI_RH_HIERARCHY_serialize(const TPMI_RH_HIERARCHY in,
1000 json_object **jso)
1001 {
1002 static const struct { TPMI_RH_HIERARCHY in; char *name; } tab[] = {
1003 { TPM2_RH_OWNER, "OWNER" },
1004 { TPM2_RH_PLATFORM, "PLATFORM" },
1005 { TPM2_RH_ENDORSEMENT, "ENDORSEMENT" },
1006 { TPM2_RH_NULL, "NULL" },
1007 };
1008
1009 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
1010 if (tab[i].in == in) {
1011 *jso = json_object_new_string(tab[i].name);
1012 check_oom(*jso);
1013 return TSS2_RC_SUCCESS;
1014 }
1015 }
1016 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
1017 }
1018
1019 /** Serialize value of type TPMI_RH_NV_INDEX to json.
1020 *
1021 * @param[in] in value to be serialized.
1022 * @param[out] jso pointer to the json object.
1023 * @retval TSS2_RC_SUCCESS if the function call was a success.
1024 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1025 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_RH_NV_INDEX.
1026 *
1027 */
1028 TSS2_RC
ifapi_json_TPMI_RH_NV_INDEX_serialize(const TPMI_RH_NV_INDEX in,json_object ** jso)1029 ifapi_json_TPMI_RH_NV_INDEX_serialize(const TPMI_RH_NV_INDEX in,
1030 json_object **jso)
1031 {
1032 if (in >= TPM2_NV_INDEX_FIRST && in <= TPM2_NV_INDEX_LAST) {
1033 *jso = json_object_new_int64(in);
1034 } else {
1035 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
1036 }
1037 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1038
1039 return TSS2_RC_SUCCESS;
1040 }
1041
1042 /** Serialize TPMI_ALG_HASH to json.
1043 *
1044 * @param[in] in variable to be serialized.
1045 * @param[out] jso pointer to the json object.
1046 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
1047 * the function.
1048 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
1049 */
1050 TSS2_RC
ifapi_json_TPMI_ALG_HASH_serialize(const TPMI_ALG_HASH in,json_object ** jso)1051 ifapi_json_TPMI_ALG_HASH_serialize(const TPMI_ALG_HASH in, json_object **jso)
1052 {
1053 CHECK_IN_LIST(TPMI_ALG_HASH, in, TPM2_ALG_SHA1, TPM2_ALG_SHA256, TPM2_ALG_SHA384,
1054 TPM2_ALG_SHA512, TPM2_ALG_NULL);
1055 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
1056 }
1057
1058 /** Serialize TPMI_ALG_SYM_OBJECT to json.
1059 *
1060 * @param[in] in variable to be serialized.
1061 * @param[out] jso pointer to the json object.
1062 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
1063 * the function.
1064 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
1065 */
1066 TSS2_RC
ifapi_json_TPMI_ALG_SYM_OBJECT_serialize(const TPMI_ALG_SYM_OBJECT in,json_object ** jso)1067 ifapi_json_TPMI_ALG_SYM_OBJECT_serialize(const TPMI_ALG_SYM_OBJECT in,
1068 json_object **jso)
1069 {
1070 CHECK_IN_LIST(TPMI_ALG_SYM_OBJECT, in, TPM2_ALG_AES, TPM2_ALG_NULL);
1071 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
1072 }
1073
1074 /** Serialize TPMI_ALG_SYM_MODE to json.
1075 *
1076 * @param[in] in variable to be serialized.
1077 * @param[out] jso pointer to the json object.
1078 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
1079 * the function.
1080 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
1081 */
1082 TSS2_RC
ifapi_json_TPMI_ALG_SYM_MODE_serialize(const TPMI_ALG_SYM_MODE in,json_object ** jso)1083 ifapi_json_TPMI_ALG_SYM_MODE_serialize(const TPMI_ALG_SYM_MODE in,
1084 json_object **jso)
1085 {
1086 CHECK_IN_LIST(TPMI_ALG_SYM_MODE, in, TPM2_ALG_CTR, TPM2_ALG_OFB,
1087 TPM2_ALG_CBC, TPM2_ALG_CFB, TPM2_ALG_ECB, TPM2_ALG_NULL);
1088 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
1089 }
1090
1091 /** Serialize TPMI_ALG_CIPHER_MODE to json.
1092 *
1093 * @param[in] in variable to be serialized.
1094 * @param[out] jso pointer to the json object.
1095 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
1096 * the function.
1097 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
1098 */
1099 TSS2_RC
ifapi_json_TPMI_ALG_CIPHER_MODE_serialize(const TPMI_ALG_CIPHER_MODE in,json_object ** jso)1100 ifapi_json_TPMI_ALG_CIPHER_MODE_serialize(const TPMI_ALG_CIPHER_MODE in,
1101 json_object **jso)
1102 {
1103 CHECK_IN_LIST(TPMI_ALG_CIPHER_MODE, in, TPM2_ALG_CTR, TPM2_ALG_OFB,
1104 TPM2_ALG_CBC, TPM2_ALG_CFB, TPM2_ALG_ECB, TPM2_ALG_NULL);
1105 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
1106 }
1107
1108 /** Serialize TPMI_ALG_KDF to json.
1109 *
1110 * @param[in] in variable to be serialized.
1111 * @param[out] jso pointer to the json object.
1112 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
1113 * the function.
1114 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
1115 */
1116 TSS2_RC
ifapi_json_TPMI_ALG_KDF_serialize(const TPMI_ALG_KDF in,json_object ** jso)1117 ifapi_json_TPMI_ALG_KDF_serialize(const TPMI_ALG_KDF in, json_object **jso)
1118 {
1119 CHECK_IN_LIST(TPMI_ALG_KDF, in, TPM2_ALG_MGF1, TPM2_ALG_KDF1_SP800_56A,
1120 TPM2_ALG_KDF1_SP800_108, TPM2_ALG_NULL);
1121 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
1122 }
1123
1124 /** Serialize TPMI_ALG_SIG_SCHEME to json.
1125 *
1126 * @param[in] in variable to be serialized.
1127 * @param[out] jso pointer to the json object.
1128 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
1129 * the function.
1130 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
1131 */
1132 TSS2_RC
ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(const TPMI_ALG_SIG_SCHEME in,json_object ** jso)1133 ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(const TPMI_ALG_SIG_SCHEME in,
1134 json_object **jso)
1135 {
1136 CHECK_IN_LIST(TPMI_ALG_SIG_SCHEME, in, TPM2_ALG_RSASSA, TPM2_ALG_RSAPSS,
1137 TPM2_ALG_ECDSA, TPM2_ALG_ECDAA, TPM2_ALG_SM2, TPM2_ALG_ECSCHNORR,
1138 TPM2_ALG_HMAC, TPM2_ALG_NULL);
1139 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
1140 }
1141
1142 /** Serialize a TPMU_HA to json.
1143 *
1144 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
1145 * @param[in] in the value to be serialized.
1146 * @param[in] selector the type of the HA object.
1147 * @param[out] jso pointer to the json object.
1148 * @retval TSS2_RC_SUCCESS if the function call was a success.
1149 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1150 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_HA.
1151 */
1152 TSS2_RC
ifapi_json_TPMU_HA_serialize(const TPMU_HA * in,UINT32 selector,json_object ** jso)1153 ifapi_json_TPMU_HA_serialize(const TPMU_HA *in, UINT32 selector,
1154 json_object **jso)
1155 {
1156 size_t size;
1157 const uint8_t *buffer;
1158
1159 switch (selector) {
1160 case TPM2_ALG_SHA1:
1161 size = TPM2_SHA1_DIGEST_SIZE;
1162 buffer = &in->sha1[0];
1163 break;
1164 case TPM2_ALG_SHA256:
1165 size = TPM2_SHA256_DIGEST_SIZE;
1166 buffer = &in->sha256[0];
1167 break;
1168 case TPM2_ALG_SHA384:
1169 size = TPM2_SHA384_DIGEST_SIZE;
1170 buffer = &in->sha384[0];
1171 break;
1172 case TPM2_ALG_SHA512:
1173 size = TPM2_SHA512_DIGEST_SIZE;
1174 buffer = &in->sha512[0];
1175 break;
1176 default:
1177 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
1178 return TSS2_FAPI_RC_BAD_VALUE;
1179 };
1180 char hex_string[(size) * 2 + 1];
1181 for (size_t i = 0, off = 0; i < size; i++, off += 2)
1182 sprintf(&hex_string[off], "%02x", buffer[i]);
1183 hex_string[(size) * 2] = '\0';
1184 *jso = json_object_new_string(hex_string);
1185 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1186
1187 return TSS2_RC_SUCCESS;
1188 }
1189
1190 /** Serialize value of type TPMT_HA to json.
1191 *
1192 * @param[in] in value to be serialized.
1193 * @param[out] jso pointer to the json object.
1194 * @retval TSS2_RC_SUCCESS if the function call was a success.
1195 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1196 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_HA.
1197 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1198 */
1199 TSS2_RC
ifapi_json_TPMT_HA_serialize(const TPMT_HA * in,json_object ** jso)1200 ifapi_json_TPMT_HA_serialize(const TPMT_HA *in, json_object **jso)
1201 {
1202 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1203
1204 TSS2_RC r;
1205 json_object *jso2;
1206 if (*jso == NULL)
1207 *jso = json_object_new_object();
1208 jso2 = NULL;
1209 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2);
1210 return_if_error(r, "Serialize TPMI_ALG_HASH");
1211
1212 json_object_object_add(*jso, "hashAlg", jso2);
1213 if (in->hashAlg != TPM2_ALG_NULL) {
1214 json_object *jso2 = NULL;
1215 r = ifapi_json_TPMU_HA_serialize(&in->digest, in->hashAlg, &jso2);
1216 return_if_error(r, "Serialize TPMU_HA");
1217
1218 json_object_object_add(*jso, "digest", jso2);
1219 }
1220 return TSS2_RC_SUCCESS;
1221 }
1222
1223 /** Serialize value of type TPM2B_DIGEST to json.
1224 *
1225 * @param[in] in value to be serialized.
1226 * @param[out] jso pointer to the json object.
1227 * @retval TSS2_RC_SUCCESS if the function call was a success.
1228 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1229 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_DIGEST.
1230 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1231 */
1232 TSS2_RC
ifapi_json_TPM2B_DIGEST_serialize(const TPM2B_DIGEST * in,json_object ** jso)1233 ifapi_json_TPM2B_DIGEST_serialize(const TPM2B_DIGEST *in, json_object **jso)
1234 {
1235 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1236
1237 if (in->size > sizeof(TPMU_HA)) {
1238 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMU_HA))",
1239 (size_t)in->size, (size_t)sizeof(TPMU_HA));
1240 return TSS2_FAPI_RC_BAD_VALUE;
1241 }
1242 char hex_string[((size_t)in->size)*2+1];
1243
1244 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
1245 sprintf(&hex_string[off], "%02x", in->buffer[i]);
1246 hex_string[(in->size)*2] = '\0';
1247 *jso = json_object_new_string (hex_string);
1248 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1249
1250 return TSS2_RC_SUCCESS;
1251 }
1252
1253 /** Serialize value of type TPM2B_DATA to json.
1254 *
1255 * @param[in] in value to be serialized.
1256 * @param[out] jso pointer to the json object.
1257 * @retval TSS2_RC_SUCCESS if the function call was a success.
1258 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1259 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_DATA.
1260 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1261 */
1262 TSS2_RC
ifapi_json_TPM2B_DATA_serialize(const TPM2B_DATA * in,json_object ** jso)1263 ifapi_json_TPM2B_DATA_serialize(const TPM2B_DATA *in, json_object **jso)
1264 {
1265 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1266
1267 if (in->size > sizeof(TPMU_HA)) {
1268 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMT_HA))",
1269 (size_t)in->size, (size_t)sizeof(TPMT_HA));
1270 return TSS2_FAPI_RC_BAD_VALUE;
1271 }
1272 char hex_string[sizeof(TPMT_HA)*2+1];
1273
1274 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
1275 sprintf(&hex_string[off], "%02x", in->buffer[i]);
1276 hex_string[(in->size)*2] = '\0';
1277 *jso = json_object_new_string (hex_string);
1278 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1279
1280 return TSS2_RC_SUCCESS;
1281 }
1282
1283 /** Serialize a TPM2B_NONCE to json.
1284 *
1285 * @param[in] in value of type TPM2B_NONCE to be serialized.
1286 * @param[out] jso pointer to the json object.
1287 * @retval TSS2_RC_SUCCESS if the function call was a success.
1288 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1289 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_NONCE.
1290 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1291 */
1292 TSS2_RC
ifapi_json_TPM2B_NONCE_serialize(const TPM2B_NONCE * in,json_object ** jso)1293 ifapi_json_TPM2B_NONCE_serialize(const TPM2B_NONCE *in, json_object **jso)
1294 {
1295 return ifapi_json_TPM2B_DIGEST_serialize(in, jso);
1296 }
1297
1298 /** Serialize a TPM2B_OPERAND to json.
1299 *
1300 * @param[in] in value of type TPM2B_OPERAND to be serialized.
1301 * @param[out] jso pointer to the json object.
1302 * @retval TSS2_RC_SUCCESS if the function call was a success.
1303 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1304 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_OPERAND.
1305 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1306 */
1307 TSS2_RC
ifapi_json_TPM2B_OPERAND_serialize(const TPM2B_OPERAND * in,json_object ** jso)1308 ifapi_json_TPM2B_OPERAND_serialize(const TPM2B_OPERAND *in, json_object **jso)
1309 {
1310 return ifapi_json_TPM2B_DIGEST_serialize(in, jso);
1311 }
1312
1313 /** Serialize value of type TPM2B_EVENT to json.
1314 *
1315 * @param[in] in value to be serialized.
1316 * @param[out] jso pointer to the json object.
1317 * @retval TSS2_RC_SUCCESS if the function call was a success.
1318 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1319 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_EVENT.
1320 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1321 */
1322 TSS2_RC
ifapi_json_TPM2B_EVENT_serialize(const TPM2B_EVENT * in,json_object ** jso)1323 ifapi_json_TPM2B_EVENT_serialize(const TPM2B_EVENT *in, json_object **jso)
1324 {
1325 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1326
1327 if (in->size > 1024) {
1328 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = 1024)",
1329 (size_t)in->size, (size_t)1024);
1330 return TSS2_FAPI_RC_BAD_VALUE;
1331 }
1332 char hex_string[((size_t)in->size)*2+1];
1333
1334 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
1335 sprintf(&hex_string[off], "%02x", in->buffer[i]);
1336 hex_string[(in->size)*2] = '\0';
1337 *jso = json_object_new_string (hex_string);
1338 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1339
1340 return TSS2_RC_SUCCESS;
1341 }
1342
1343 /** Serialize value of type TPM2B_MAX_NV_BUFFER to json.
1344 *
1345 * @param[in] in value to be serialized.
1346 * @param[out] jso pointer to the json object.
1347 * @retval TSS2_RC_SUCCESS if the function call was a success.
1348 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1349 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_MAX_NV_BUFFER.
1350 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1351 */
1352 TSS2_RC
ifapi_json_TPM2B_MAX_NV_BUFFER_serialize(const TPM2B_MAX_NV_BUFFER * in,json_object ** jso)1353 ifapi_json_TPM2B_MAX_NV_BUFFER_serialize(const TPM2B_MAX_NV_BUFFER *in, json_object **jso)
1354 {
1355 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1356
1357 if (in->size > TPM2_MAX_NV_BUFFER_SIZE) {
1358 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_NV_BUFFER_SIZE)",
1359 (size_t)in->size, (size_t)TPM2_MAX_NV_BUFFER_SIZE);
1360 return TSS2_FAPI_RC_BAD_VALUE;
1361 }
1362 char hex_string[((size_t)in->size)*2+1];
1363
1364 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
1365 sprintf(&hex_string[off], "%02x", in->buffer[i]);
1366 hex_string[(in->size)*2] = '\0';
1367 *jso = json_object_new_string (hex_string);
1368 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1369
1370 return TSS2_RC_SUCCESS;
1371 }
1372
1373 /** Serialize value of type TPM2B_NAME to json.
1374 *
1375 * @param[in] in value to be serialized.
1376 * @param[out] jso pointer to the json object.
1377 * @retval TSS2_RC_SUCCESS if the function call was a success.
1378 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1379 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_NAME.
1380 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1381 */
1382 TSS2_RC
ifapi_json_TPM2B_NAME_serialize(const TPM2B_NAME * in,json_object ** jso)1383 ifapi_json_TPM2B_NAME_serialize(const TPM2B_NAME *in, json_object **jso)
1384 {
1385 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1386
1387 if (in->size > sizeof(TPMU_NAME)) {
1388 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMU_NAME))",
1389 (size_t)in->size, (size_t)sizeof(TPMU_NAME));
1390 return TSS2_FAPI_RC_BAD_VALUE;
1391 }
1392 char hex_string[((size_t)in->size)*2+1];
1393
1394 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
1395 sprintf(&hex_string[off], "%02x", in->name[i]);
1396 hex_string[(in->size)*2] = '\0';
1397 *jso = json_object_new_string (hex_string);
1398 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1399
1400 return TSS2_RC_SUCCESS;
1401 }
1402
1403 /** Serialize value of type TPMT_TK_CREATION to json.
1404 *
1405 * @param[in] in value to be serialized.
1406 * @param[out] jso pointer to the json object.
1407 * @retval TSS2_RC_SUCCESS if the function call was a success.
1408 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1409 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_TK_CREATION.
1410 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1411 */
1412 TSS2_RC
ifapi_json_TPMT_TK_CREATION_serialize(const TPMT_TK_CREATION * in,json_object ** jso)1413 ifapi_json_TPMT_TK_CREATION_serialize(const TPMT_TK_CREATION *in, json_object **jso)
1414 {
1415 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1416
1417 TSS2_RC r;
1418 json_object *jso2;
1419 if (*jso == NULL)
1420 *jso = json_object_new_object ();
1421 if (in != NULL && in->tag != TPM2_ST_CREATION) {
1422 LOG_ERROR("BAD VALUE %"PRIuPTR" != %"PRIuPTR,(size_t)in->tag,(size_t)TPM2_ST_CREATION);
1423 return TSS2_FAPI_RC_BAD_VALUE;
1424 }
1425 jso2 = NULL;
1426 r = ifapi_json_TPM2_ST_serialize(in->tag, &jso2);
1427 return_if_error(r, "Serialize TPM2_ST");
1428
1429 json_object_object_add(*jso, "tag", jso2);
1430 jso2 = NULL;
1431 r = ifapi_json_TPMI_RH_HIERARCHY_serialize(in->hierarchy, &jso2);
1432 return_if_error(r, "Serialize TPMI_RH_HIERARCHY");
1433
1434 json_object_object_add(*jso, "hierarchy", jso2);
1435 jso2 = NULL;
1436 r = ifapi_json_TPM2B_DIGEST_serialize(&in->digest, &jso2);
1437 return_if_error(r, "Serialize TPM2B_DIGEST");
1438
1439 json_object_object_add(*jso, "digest", jso2);
1440 return TSS2_RC_SUCCESS;
1441 }
1442
1443 /** Serialize value of type TPMS_ALG_PROPERTY to json.
1444 *
1445 * @param[in] in value to be serialized.
1446 * @param[out] jso pointer to the json object.
1447 * @retval TSS2_RC_SUCCESS if the function call was a success.
1448 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1449 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ALG_PROPERTY.
1450 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1451 */
1452 TSS2_RC
ifapi_json_TPMS_ALG_PROPERTY_serialize(const TPMS_ALG_PROPERTY * in,json_object ** jso)1453 ifapi_json_TPMS_ALG_PROPERTY_serialize(const TPMS_ALG_PROPERTY *in, json_object **jso)
1454 {
1455 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1456
1457 TSS2_RC r;
1458 json_object *jso2;
1459 if (*jso == NULL)
1460 *jso = json_object_new_object ();
1461 jso2 = NULL;
1462 r = ifapi_json_TPM2_ALG_ID_serialize(in->alg, &jso2);
1463 return_if_error(r, "Serialize TPM2_ALG_ID");
1464
1465 json_object_object_add(*jso, "alg", jso2);
1466 jso2 = NULL;
1467 r = ifapi_json_TPMA_ALGORITHM_serialize(in->algProperties, &jso2);
1468 return_if_error(r, "Serialize TPMA_ALGORITHM");
1469
1470 json_object_object_add(*jso, "algProperties", jso2);
1471 return TSS2_RC_SUCCESS;
1472 }
1473
1474 /** Serialize value of type TPMS_TAGGED_PROPERTY to json.
1475 *
1476 * @param[in] in value to be serialized.
1477 * @param[out] jso pointer to the json object.
1478 * @retval TSS2_RC_SUCCESS if the function call was a success.
1479 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1480 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TAGGED_PROPERTY.
1481 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1482 */
1483 TSS2_RC
ifapi_json_TPMS_TAGGED_PROPERTY_serialize(const TPMS_TAGGED_PROPERTY * in,json_object ** jso)1484 ifapi_json_TPMS_TAGGED_PROPERTY_serialize(const TPMS_TAGGED_PROPERTY *in, json_object **jso)
1485 {
1486 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1487
1488 TSS2_RC r;
1489 json_object *jso2;
1490 if (*jso == NULL)
1491 *jso = json_object_new_object ();
1492 jso2 = NULL;
1493 r = ifapi_json_TPM2_PT_serialize(in->property, &jso2);
1494 return_if_error(r, "Serialize TPM2_PT");
1495
1496 json_object_object_add(*jso, "property", jso2);
1497 jso2 = NULL;
1498 r = ifapi_json_UINT32_serialize(in->value, &jso2);
1499 return_if_error(r, "Serialize UINT32");
1500
1501 json_object_object_add(*jso, "value", jso2);
1502 return TSS2_RC_SUCCESS;
1503 }
1504
1505 /** Serialize value of type TPML_CC to json.
1506 *
1507 * @param[in] in value to be serialized.
1508 * @param[out] jso pointer to the json object.
1509 * @retval TSS2_RC_SUCCESS if the function call was a success.
1510 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1511 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_CC.
1512 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1513 */
1514 TSS2_RC
ifapi_json_TPML_CC_serialize(const TPML_CC * in,json_object ** jso)1515 ifapi_json_TPML_CC_serialize(const TPML_CC *in, json_object **jso)
1516 {
1517 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1518
1519 TSS2_RC r;
1520 if (in->count > TPM2_MAX_CAP_CC) {
1521 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_CC)",
1522 (size_t)in->count, (size_t)TPM2_MAX_CAP_CC);
1523 return TSS2_FAPI_RC_BAD_VALUE;
1524 }
1525 *jso = json_object_new_array();
1526 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1527
1528 for (size_t i=0; i < in->count; i++) {
1529 json_object *jso2 = NULL;
1530 r = ifapi_json_TPM2_CC_serialize (in->commandCodes[i], &jso2);
1531 return_if_error(r, "Serialize TPM2_CC");
1532
1533 json_object_array_add(*jso, jso2);
1534 }
1535 return TSS2_RC_SUCCESS;
1536 }
1537
1538 /** Serialize value of type TPML_CCA to json.
1539 *
1540 * @param[in] in value to be serialized.
1541 * @param[out] jso pointer to the json object.
1542 * @retval TSS2_RC_SUCCESS if the function call was a success.
1543 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1544 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_CCA.
1545 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1546 */
1547 TSS2_RC
ifapi_json_TPML_CCA_serialize(const TPML_CCA * in,json_object ** jso)1548 ifapi_json_TPML_CCA_serialize(const TPML_CCA *in, json_object **jso)
1549 {
1550 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1551
1552 TSS2_RC r;
1553 if (in->count > TPM2_MAX_CAP_CC) {
1554 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_CC)",
1555 (size_t)in->count, (size_t)TPM2_MAX_CAP_CC);
1556 return TSS2_FAPI_RC_BAD_VALUE;
1557 }
1558 *jso = json_object_new_array();
1559 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1560
1561 for (size_t i=0; i < in->count; i++) {
1562 json_object *jso2 = NULL;
1563 r = ifapi_json_TPMA_CC_serialize (in->commandAttributes[i], &jso2);
1564 return_if_error(r, "Serialize TPMA_CC");
1565
1566 json_object_array_add(*jso, jso2);
1567 }
1568 return TSS2_RC_SUCCESS;
1569 }
1570
1571 /** Serialize value of type TPML_HANDLE to json.
1572 *
1573 * @param[in] in value to be serialized.
1574 * @param[out] jso pointer to the json object.
1575 * @retval TSS2_RC_SUCCESS if the function call was a success.
1576 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1577 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_HANDLE.
1578 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1579 */
1580 TSS2_RC
ifapi_json_TPML_HANDLE_serialize(const TPML_HANDLE * in,json_object ** jso)1581 ifapi_json_TPML_HANDLE_serialize(const TPML_HANDLE *in, json_object **jso)
1582 {
1583 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1584
1585 TSS2_RC r;
1586 if (in->count > TPM2_MAX_CAP_HANDLES) {
1587 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_HANDLES)",
1588 (size_t)in->count, (size_t)TPM2_MAX_CAP_HANDLES);
1589 return TSS2_FAPI_RC_BAD_VALUE;
1590 }
1591 *jso = json_object_new_array();
1592 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1593
1594 for (size_t i=0; i < in->count; i++) {
1595 json_object *jso2 = NULL;
1596 r = ifapi_json_TPM2_HANDLE_serialize (in->handle[i], &jso2);
1597 return_if_error(r, "Serialize TPM2_HANDLE");
1598
1599 json_object_array_add(*jso, jso2);
1600 }
1601 return TSS2_RC_SUCCESS;
1602 }
1603
1604 /** Serialize value of type TPML_DIGEST_VALUES to json.
1605 *
1606 * @param[in] in value to be serialized.
1607 * @param[out] jso pointer to the json object.
1608 * @retval TSS2_RC_SUCCESS if the function call was a success.
1609 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1610 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_DIGEST_VALUES.
1611 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1612 */
1613 TSS2_RC
ifapi_json_TPML_DIGEST_VALUES_serialize(const TPML_DIGEST_VALUES * in,json_object ** jso)1614 ifapi_json_TPML_DIGEST_VALUES_serialize(const TPML_DIGEST_VALUES *in, json_object **jso)
1615 {
1616 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1617
1618 TSS2_RC r;
1619 if (in->count > TPM2_NUM_PCR_BANKS) {
1620 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_NUM_PCR_BANKS)",
1621 (size_t)in->count, (size_t)TPM2_NUM_PCR_BANKS);
1622 return TSS2_FAPI_RC_BAD_VALUE;
1623 }
1624 *jso = json_object_new_array();
1625 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1626
1627 for (size_t i=0; i < in->count; i++) {
1628 json_object *jso2 = NULL;
1629 r = ifapi_json_TPMT_HA_serialize (&in->digests[i], &jso2);
1630 return_if_error(r, "Serialize TPMT_HA");
1631
1632 json_object_array_add(*jso, jso2);
1633 }
1634 return TSS2_RC_SUCCESS;
1635 }
1636
1637 /** Serialize value of type TPML_PCR_SELECTION to json.
1638 *
1639 * @param[in] in value to be serialized.
1640 * @param[out] jso pointer to the json object.
1641 * @retval TSS2_RC_SUCCESS if the function call was a success.
1642 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1643 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_PCR_SELECTION.
1644 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1645 */
1646 TSS2_RC
ifapi_json_TPML_PCR_SELECTION_serialize(const TPML_PCR_SELECTION * in,json_object ** jso)1647 ifapi_json_TPML_PCR_SELECTION_serialize(const TPML_PCR_SELECTION *in, json_object **jso)
1648 {
1649 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1650
1651 TSS2_RC r;
1652 if (in->count > TPM2_NUM_PCR_BANKS) {
1653 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_NUM_PCR_BANKS)",
1654 (size_t)in->count, (size_t)TPM2_NUM_PCR_BANKS);
1655 return TSS2_FAPI_RC_BAD_VALUE;
1656 }
1657 *jso = json_object_new_array();
1658 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1659
1660 for (size_t i=0; i < in->count; i++) {
1661 json_object *jso2 = NULL;
1662 r = ifapi_json_TPMS_PCR_SELECTION_serialize (&in->pcrSelections[i], &jso2);
1663 return_if_error(r, "Serialize TPMS_PCR_SELECTION");
1664
1665 json_object_array_add(*jso, jso2);
1666 }
1667 return TSS2_RC_SUCCESS;
1668 }
1669
1670 /** Serialize value of type TPML_ALG_PROPERTY to json.
1671 *
1672 * @param[in] in value to be serialized.
1673 * @param[out] jso pointer to the json object.
1674 * @retval TSS2_RC_SUCCESS if the function call was a success.
1675 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1676 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_ALG_PROPERTY.
1677 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1678 */
1679 TSS2_RC
ifapi_json_TPML_ALG_PROPERTY_serialize(const TPML_ALG_PROPERTY * in,json_object ** jso)1680 ifapi_json_TPML_ALG_PROPERTY_serialize(const TPML_ALG_PROPERTY *in, json_object **jso)
1681 {
1682 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1683
1684 TSS2_RC r;
1685 if (in->count > TPM2_MAX_CAP_ALGS) {
1686 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_CAP_ALGS)",
1687 (size_t)in->count, (size_t)TPM2_MAX_CAP_ALGS);
1688 return TSS2_FAPI_RC_BAD_VALUE;
1689 }
1690 *jso = json_object_new_array();
1691 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1692
1693 for (size_t i=0; i < in->count; i++) {
1694 json_object *jso2 = NULL;
1695 r = ifapi_json_TPMS_ALG_PROPERTY_serialize (&in->algProperties[i], &jso2);
1696 return_if_error(r, "Serialize TPMS_ALG_PROPERTY");
1697
1698 json_object_array_add(*jso, jso2);
1699 }
1700 return TSS2_RC_SUCCESS;
1701 }
1702
1703 /** Serialize value of type TPML_TAGGED_TPM_PROPERTY to json.
1704 *
1705 * @param[in] in value to be serialized.
1706 * @param[out] jso pointer to the json object.
1707 * @retval TSS2_RC_SUCCESS if the function call was a success.
1708 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1709 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_TAGGED_TPM_PROPERTY.
1710 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1711 */
1712 TSS2_RC
ifapi_json_TPML_TAGGED_TPM_PROPERTY_serialize(const TPML_TAGGED_TPM_PROPERTY * in,json_object ** jso)1713 ifapi_json_TPML_TAGGED_TPM_PROPERTY_serialize(const TPML_TAGGED_TPM_PROPERTY *in, json_object **jso)
1714 {
1715 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1716
1717 TSS2_RC r;
1718 if (in->count > TPM2_MAX_TPM_PROPERTIES) {
1719 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_TPM_PROPERTIES)",
1720 (size_t)in->count, (size_t)TPM2_MAX_TPM_PROPERTIES);
1721 return TSS2_FAPI_RC_BAD_VALUE;
1722 }
1723 *jso = json_object_new_array();
1724 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1725
1726 for (size_t i=0; i < in->count; i++) {
1727 json_object *jso2 = NULL;
1728 r = ifapi_json_TPMS_TAGGED_PROPERTY_serialize (&in->tpmProperty[i], &jso2);
1729 return_if_error(r, "Serialize TPMS_TAGGED_PROPERTY");
1730
1731 json_object_array_add(*jso, jso2);
1732 }
1733 return TSS2_RC_SUCCESS;
1734 }
1735
1736 /** Serialize value of type TPML_TAGGED_PCR_PROPERTY to json.
1737 *
1738 * @param[in] in value to be serialized.
1739 * @param[out] jso pointer to the json object.
1740 * @retval TSS2_RC_SUCCESS if the function call was a success.
1741 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1742 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_TAGGED_PCR_PROPERTY.
1743 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1744 */
1745 TSS2_RC
ifapi_json_TPML_TAGGED_PCR_PROPERTY_serialize(const TPML_TAGGED_PCR_PROPERTY * in,json_object ** jso)1746 ifapi_json_TPML_TAGGED_PCR_PROPERTY_serialize(const TPML_TAGGED_PCR_PROPERTY *in, json_object **jso)
1747 {
1748 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1749
1750 TSS2_RC r;
1751 if (in->count > TPM2_MAX_PCR_PROPERTIES) {
1752 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_PCR_PROPERTIES)",
1753 (size_t)in->count, (size_t)TPM2_MAX_PCR_PROPERTIES);
1754 return TSS2_FAPI_RC_BAD_VALUE;
1755 }
1756 *jso = json_object_new_array();
1757 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1758
1759 for (size_t i=0; i < in->count; i++) {
1760 json_object *jso2 = NULL;
1761 r = ifapi_json_TPMS_TAGGED_PCR_SELECT_serialize (&in->pcrProperty[i], &jso2);
1762 return_if_error(r, "Serialize TPMS_TAGGED_PCR_SELECT");
1763
1764 json_object_array_add(*jso, jso2);
1765 }
1766 return TSS2_RC_SUCCESS;
1767 }
1768
1769 /** Serialize value of type TPML_ECC_CURVE to json.
1770 *
1771 * @param[in] in value to be serialized.
1772 * @param[out] jso pointer to the json object.
1773 * @retval TSS2_RC_SUCCESS if the function call was a success.
1774 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1775 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPML_ECC_CURVE.
1776 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1777 */
1778 TSS2_RC
ifapi_json_TPML_ECC_CURVE_serialize(const TPML_ECC_CURVE * in,json_object ** jso)1779 ifapi_json_TPML_ECC_CURVE_serialize(const TPML_ECC_CURVE *in, json_object **jso)
1780 {
1781 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1782
1783 TSS2_RC r;
1784 if (in->count > TPM2_MAX_ECC_CURVES) {
1785 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_ECC_CURVES)",
1786 (size_t)in->count, (size_t)TPM2_MAX_ECC_CURVES);
1787 return TSS2_FAPI_RC_BAD_VALUE;
1788 }
1789 *jso = json_object_new_array();
1790 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
1791
1792 for (size_t i=0; i < in->count; i++) {
1793 json_object *jso2 = NULL;
1794 r = ifapi_json_TPM2_ECC_CURVE_serialize (in->eccCurves[i], &jso2);
1795 return_if_error(r, "Serialize TPM2_ECC_CURVE");
1796
1797 json_object_array_add(*jso, jso2);
1798 }
1799 return TSS2_RC_SUCCESS;
1800 }
1801
1802 /** Serialize a TPMU_CAPABILITIES to json.
1803 *
1804 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
1805 * @param[in] in the value to be serialized.
1806 * @param[in] selector the type of the capabilities.
1807 * @param[out] jso pointer to the json object.
1808 * @retval TSS2_RC_SUCCESS if the function call was a success.
1809 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1810 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_CAPABILITIES.
1811 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1812 */
1813 TSS2_RC
ifapi_json_TPMU_CAPABILITIES_serialize(const TPMU_CAPABILITIES * in,UINT32 selector,json_object ** jso)1814 ifapi_json_TPMU_CAPABILITIES_serialize(const TPMU_CAPABILITIES *in, UINT32 selector, json_object **jso)
1815 {
1816 switch (selector) {
1817 case TPM2_CAP_ALGS:
1818 return ifapi_json_TPML_ALG_PROPERTY_serialize(&in->algorithms, jso);
1819 case TPM2_CAP_HANDLES:
1820 return ifapi_json_TPML_HANDLE_serialize(&in->handles, jso);
1821 case TPM2_CAP_COMMANDS:
1822 return ifapi_json_TPML_CCA_serialize(&in->command, jso);
1823 case TPM2_CAP_PP_COMMANDS:
1824 return ifapi_json_TPML_CC_serialize(&in->ppCommands, jso);
1825 case TPM2_CAP_AUDIT_COMMANDS:
1826 return ifapi_json_TPML_CC_serialize(&in->auditCommands, jso);
1827 case TPM2_CAP_PCRS:
1828 return ifapi_json_TPML_PCR_SELECTION_serialize(&in->assignedPCR, jso);
1829 case TPM2_CAP_TPM_PROPERTIES:
1830 return ifapi_json_TPML_TAGGED_TPM_PROPERTY_serialize(&in->tpmProperties, jso);
1831 case TPM2_CAP_PCR_PROPERTIES:
1832 return ifapi_json_TPML_TAGGED_PCR_PROPERTY_serialize(&in->pcrProperties, jso);
1833 case TPM2_CAP_ECC_CURVES:
1834 return ifapi_json_TPML_ECC_CURVE_serialize(&in->eccCurves, jso);
1835 default:
1836 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
1837 return TSS2_FAPI_RC_BAD_VALUE;
1838 };
1839 return TSS2_RC_SUCCESS;
1840 }
1841
1842 /** Serialize value of type TPMS_CAPABILITY_DATA to json.
1843 *
1844 * @param[in] in value to be serialized.
1845 * @param[out] jso pointer to the json object.
1846 * @retval TSS2_RC_SUCCESS if the function call was a success.
1847 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1848 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CAPABILITY_DATA.
1849 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1850 */
1851 TSS2_RC
ifapi_json_TPMS_CAPABILITY_DATA_serialize(const TPMS_CAPABILITY_DATA * in,json_object ** jso)1852 ifapi_json_TPMS_CAPABILITY_DATA_serialize(const TPMS_CAPABILITY_DATA *in, json_object **jso)
1853 {
1854 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1855
1856 TSS2_RC r;
1857 json_object *jso2;
1858 if (*jso == NULL)
1859 *jso = json_object_new_object ();
1860 jso2 = NULL;
1861 r = ifapi_json_TPM2_CAP_serialize(in->capability, &jso2);
1862 return_if_error(r, "Serialize TPM2_CAP");
1863
1864 json_object_object_add(*jso, "capability", jso2);
1865 jso2 = NULL;
1866 r = ifapi_json_TPMU_CAPABILITIES_serialize(&in->data, in->capability, &jso2);
1867 return_if_error(r,"Serialize TPMU_CAPABILITIES");
1868
1869 json_object_object_add(*jso, "data", jso2);
1870 return TSS2_RC_SUCCESS;
1871 }
1872
1873 /** Serialize value of type TPMS_CLOCK_INFO to json.
1874 *
1875 * @param[in] in value to be serialized.
1876 * @param[out] jso pointer to the json object.
1877 * @retval TSS2_RC_SUCCESS if the function call was a success.
1878 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1879 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CLOCK_INFO.
1880 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1881 */
1882 TSS2_RC
ifapi_json_TPMS_CLOCK_INFO_serialize(const TPMS_CLOCK_INFO * in,json_object ** jso)1883 ifapi_json_TPMS_CLOCK_INFO_serialize(const TPMS_CLOCK_INFO *in, json_object **jso)
1884 {
1885 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1886
1887 TSS2_RC r;
1888 json_object *jso2;
1889 if (*jso == NULL)
1890 *jso = json_object_new_object ();
1891 jso2 = NULL;
1892 r = ifapi_json_UINT64_serialize(in->clock, &jso2);
1893 return_if_error(r, "Serialize UINT64");
1894
1895 json_object_object_add(*jso, "clock", jso2);
1896 jso2 = NULL;
1897 r = ifapi_json_UINT32_serialize(in->resetCount, &jso2);
1898 return_if_error(r, "Serialize UINT32");
1899
1900 json_object_object_add(*jso, "resetCount", jso2);
1901 jso2 = NULL;
1902 r = ifapi_json_UINT32_serialize(in->restartCount, &jso2);
1903 return_if_error(r, "Serialize UINT32");
1904
1905 json_object_object_add(*jso, "restartCount", jso2);
1906 jso2 = NULL;
1907 r = ifapi_json_TPMI_YES_NO_serialize(in->safe, &jso2);
1908 return_if_error(r, "Serialize TPMI_YES_NO");
1909
1910 json_object_object_add(*jso, "safe", jso2);
1911 return TSS2_RC_SUCCESS;
1912 }
1913
1914 /** Serialize value of type TPMS_TIME_INFO to json.
1915 *
1916 * @param[in] in value to be serialized.
1917 * @param[out] jso pointer to the json object.
1918 * @retval TSS2_RC_SUCCESS if the function call was a success.
1919 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1920 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TIME_INFO.
1921 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1922 */
1923 TSS2_RC
ifapi_json_TPMS_TIME_INFO_serialize(const TPMS_TIME_INFO * in,json_object ** jso)1924 ifapi_json_TPMS_TIME_INFO_serialize(const TPMS_TIME_INFO *in, json_object **jso)
1925 {
1926 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1927
1928 TSS2_RC r;
1929 json_object *jso2;
1930 if (*jso == NULL)
1931 *jso = json_object_new_object ();
1932 jso2 = NULL;
1933 r = ifapi_json_UINT64_serialize(in->time, &jso2);
1934 return_if_error(r, "Serialize UINT64");
1935
1936 json_object_object_add(*jso, "time", jso2);
1937 jso2 = NULL;
1938 r = ifapi_json_TPMS_CLOCK_INFO_serialize(&in->clockInfo, &jso2);
1939 return_if_error(r, "Serialize TPMS_CLOCK_INFO");
1940
1941 json_object_object_add(*jso, "clockInfo", jso2);
1942 return TSS2_RC_SUCCESS;
1943 }
1944
1945 /** Serialize value of type TPMS_TIME_ATTEST_INFO to json.
1946 *
1947 * @param[in] in value to be serialized.
1948 * @param[out] jso pointer to the json object.
1949 * @retval TSS2_RC_SUCCESS if the function call was a success.
1950 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1951 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_TIME_ATTEST_INFO.
1952 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1953 */
1954 TSS2_RC
ifapi_json_TPMS_TIME_ATTEST_INFO_serialize(const TPMS_TIME_ATTEST_INFO * in,json_object ** jso)1955 ifapi_json_TPMS_TIME_ATTEST_INFO_serialize(const TPMS_TIME_ATTEST_INFO *in, json_object **jso)
1956 {
1957 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1958
1959 TSS2_RC r;
1960 json_object *jso2;
1961 if (*jso == NULL)
1962 *jso = json_object_new_object ();
1963 jso2 = NULL;
1964 r = ifapi_json_TPMS_TIME_INFO_serialize(&in->time, &jso2);
1965 return_if_error(r, "Serialize TPMS_TIME_INFO");
1966
1967 json_object_object_add(*jso, "time", jso2);
1968 jso2 = NULL;
1969 r = ifapi_json_UINT64_serialize(in->firmwareVersion, &jso2);
1970 return_if_error(r, "Serialize UINT64");
1971
1972 json_object_object_add(*jso, "firmwareVersion", jso2);
1973 return TSS2_RC_SUCCESS;
1974 }
1975
1976 /** Serialize value of type TPMS_CERTIFY_INFO to json.
1977 *
1978 * @param[in] in value to be serialized.
1979 * @param[out] jso pointer to the json object.
1980 * @retval TSS2_RC_SUCCESS if the function call was a success.
1981 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
1982 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CERTIFY_INFO.
1983 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
1984 */
1985 TSS2_RC
ifapi_json_TPMS_CERTIFY_INFO_serialize(const TPMS_CERTIFY_INFO * in,json_object ** jso)1986 ifapi_json_TPMS_CERTIFY_INFO_serialize(const TPMS_CERTIFY_INFO *in, json_object **jso)
1987 {
1988 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
1989
1990 TSS2_RC r;
1991 json_object *jso2;
1992 if (*jso == NULL)
1993 *jso = json_object_new_object ();
1994 jso2 = NULL;
1995 r = ifapi_json_TPM2B_NAME_serialize(&in->name, &jso2);
1996 return_if_error(r, "Serialize TPM2B_NAME");
1997
1998 json_object_object_add(*jso, "name", jso2);
1999 jso2 = NULL;
2000 r = ifapi_json_TPM2B_NAME_serialize(&in->qualifiedName, &jso2);
2001 return_if_error(r, "Serialize TPM2B_NAME");
2002
2003 json_object_object_add(*jso, "qualifiedName", jso2);
2004 return TSS2_RC_SUCCESS;
2005 }
2006
2007 /** Serialize value of type TPMS_QUOTE_INFO to json.
2008 *
2009 * @param[in] in value to be serialized.
2010 * @param[out] jso pointer to the json object.
2011 * @retval TSS2_RC_SUCCESS if the function call was a success.
2012 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2013 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_QUOTE_INFO.
2014 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2015 */
2016 TSS2_RC
ifapi_json_TPMS_QUOTE_INFO_serialize(const TPMS_QUOTE_INFO * in,json_object ** jso)2017 ifapi_json_TPMS_QUOTE_INFO_serialize(const TPMS_QUOTE_INFO *in, json_object **jso)
2018 {
2019 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2020
2021 TSS2_RC r;
2022 json_object *jso2;
2023 if (*jso == NULL)
2024 *jso = json_object_new_object ();
2025 jso2 = NULL;
2026 r = ifapi_json_TPML_PCR_SELECTION_serialize(&in->pcrSelect, &jso2);
2027 return_if_error(r, "Serialize TPML_PCR_SELECTION");
2028
2029 json_object_object_add(*jso, "pcrSelect", jso2);
2030 jso2 = NULL;
2031 r = ifapi_json_TPM2B_DIGEST_serialize(&in->pcrDigest, &jso2);
2032 return_if_error(r, "Serialize TPM2B_DIGEST");
2033
2034 json_object_object_add(*jso, "pcrDigest", jso2);
2035 return TSS2_RC_SUCCESS;
2036 }
2037
2038 /** Serialize value of type TPMS_COMMAND_AUDIT_INFO to json.
2039 *
2040 * @param[in] in value to be serialized.
2041 * @param[out] jso pointer to the json object.
2042 * @retval TSS2_RC_SUCCESS if the function call was a success.
2043 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2044 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_COMMAND_AUDIT_INFO.
2045 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2046 */
2047 TSS2_RC
ifapi_json_TPMS_COMMAND_AUDIT_INFO_serialize(const TPMS_COMMAND_AUDIT_INFO * in,json_object ** jso)2048 ifapi_json_TPMS_COMMAND_AUDIT_INFO_serialize(const TPMS_COMMAND_AUDIT_INFO *in, json_object **jso)
2049 {
2050 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2051
2052 TSS2_RC r;
2053 json_object *jso2;
2054 if (*jso == NULL)
2055 *jso = json_object_new_object ();
2056 jso2 = NULL;
2057 r = ifapi_json_UINT64_serialize(in->auditCounter, &jso2);
2058 return_if_error(r, "Serialize UINT64");
2059
2060 json_object_object_add(*jso, "auditCounter", jso2);
2061 jso2 = NULL;
2062 r = ifapi_json_TPM2_ALG_ID_serialize(in->digestAlg, &jso2);
2063 return_if_error(r, "Serialize TPM2_ALG_ID");
2064
2065 json_object_object_add(*jso, "digestAlg", jso2);
2066 jso2 = NULL;
2067 r = ifapi_json_TPM2B_DIGEST_serialize(&in->auditDigest, &jso2);
2068 return_if_error(r, "Serialize TPM2B_DIGEST");
2069
2070 json_object_object_add(*jso, "auditDigest", jso2);
2071 jso2 = NULL;
2072 r = ifapi_json_TPM2B_DIGEST_serialize(&in->commandDigest, &jso2);
2073 return_if_error(r, "Serialize TPM2B_DIGEST");
2074
2075 json_object_object_add(*jso, "commandDigest", jso2);
2076 return TSS2_RC_SUCCESS;
2077 }
2078
2079 /** Serialize value of type TPMS_SESSION_AUDIT_INFO to json.
2080 *
2081 * @param[in] in value to be serialized.
2082 * @param[out] jso pointer to the json object.
2083 * @retval TSS2_RC_SUCCESS if the function call was a success.
2084 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2085 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SESSION_AUDIT_INFO.
2086 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2087 */
2088 TSS2_RC
ifapi_json_TPMS_SESSION_AUDIT_INFO_serialize(const TPMS_SESSION_AUDIT_INFO * in,json_object ** jso)2089 ifapi_json_TPMS_SESSION_AUDIT_INFO_serialize(const TPMS_SESSION_AUDIT_INFO *in, json_object **jso)
2090 {
2091 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2092
2093 TSS2_RC r;
2094 json_object *jso2;
2095 if (*jso == NULL)
2096 *jso = json_object_new_object ();
2097 jso2 = NULL;
2098 r = ifapi_json_TPMI_YES_NO_serialize(in->exclusiveSession, &jso2);
2099 return_if_error(r, "Serialize TPMI_YES_NO");
2100
2101 json_object_object_add(*jso, "exclusiveSession", jso2);
2102 jso2 = NULL;
2103 r = ifapi_json_TPM2B_DIGEST_serialize(&in->sessionDigest, &jso2);
2104 return_if_error(r, "Serialize TPM2B_DIGEST");
2105
2106 json_object_object_add(*jso, "sessionDigest", jso2);
2107 return TSS2_RC_SUCCESS;
2108 }
2109
2110 /** Serialize value of type TPMS_CREATION_INFO to json.
2111 *
2112 * @param[in] in value to be serialized.
2113 * @param[out] jso pointer to the json object.
2114 * @retval TSS2_RC_SUCCESS if the function call was a success.
2115 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2116 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CREATION_INFO.
2117 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2118 */
2119 TSS2_RC
ifapi_json_TPMS_CREATION_INFO_serialize(const TPMS_CREATION_INFO * in,json_object ** jso)2120 ifapi_json_TPMS_CREATION_INFO_serialize(const TPMS_CREATION_INFO *in, json_object **jso)
2121 {
2122 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2123
2124 TSS2_RC r;
2125 json_object *jso2;
2126 if (*jso == NULL)
2127 *jso = json_object_new_object ();
2128 jso2 = NULL;
2129 r = ifapi_json_TPM2B_NAME_serialize(&in->objectName, &jso2);
2130 return_if_error(r, "Serialize TPM2B_NAME");
2131
2132 json_object_object_add(*jso, "objectName", jso2);
2133 jso2 = NULL;
2134 r = ifapi_json_TPM2B_DIGEST_serialize(&in->creationHash, &jso2);
2135 return_if_error(r, "Serialize TPM2B_DIGEST");
2136
2137 json_object_object_add(*jso, "creationHash", jso2);
2138 return TSS2_RC_SUCCESS;
2139 }
2140
2141 /** Serialize value of type TPMS_NV_CERTIFY_INFO to json.
2142 *
2143 * @param[in] in value to be serialized.
2144 * @param[out] jso pointer to the json object.
2145 * @retval TSS2_RC_SUCCESS if the function call was a success.
2146 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2147 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_NV_CERTIFY_INFO.
2148 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2149 */
2150 TSS2_RC
ifapi_json_TPMS_NV_CERTIFY_INFO_serialize(const TPMS_NV_CERTIFY_INFO * in,json_object ** jso)2151 ifapi_json_TPMS_NV_CERTIFY_INFO_serialize(const TPMS_NV_CERTIFY_INFO *in, json_object **jso)
2152 {
2153 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2154
2155 TSS2_RC r;
2156 json_object *jso2;
2157 if (*jso == NULL)
2158 *jso = json_object_new_object ();
2159 jso2 = NULL;
2160 r = ifapi_json_TPM2B_NAME_serialize(&in->indexName, &jso2);
2161 return_if_error(r, "Serialize TPM2B_NAME");
2162
2163 json_object_object_add(*jso, "indexName", jso2);
2164 jso2 = NULL;
2165 r = ifapi_json_UINT16_serialize(in->offset, &jso2);
2166 return_if_error(r, "Serialize UINT16");
2167
2168 json_object_object_add(*jso, "offset", jso2);
2169 jso2 = NULL;
2170 r = ifapi_json_TPM2B_MAX_NV_BUFFER_serialize(&in->nvContents, &jso2);
2171 return_if_error(r, "Serialize TPM2B_MAX_NV_BUFFER");
2172
2173 json_object_object_add(*jso, "nvContents", jso2);
2174 return TSS2_RC_SUCCESS;
2175 }
2176
2177 /** Serialize TPMI_ST_ATTEST to json.
2178 *
2179 * @param[in] in variable to be serialized.
2180 * @param[out] jso pointer to the json object.
2181 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
2182 * the function.
2183 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
2184 */
2185 TSS2_RC
ifapi_json_TPMI_ST_ATTEST_serialize(const TPMI_ST_ATTEST in,json_object ** jso)2186 ifapi_json_TPMI_ST_ATTEST_serialize(const TPMI_ST_ATTEST in, json_object **jso)
2187 {
2188 CHECK_IN_LIST(TPMI_ALG_HASH, in, TPM2_ST_ATTEST_CERTIFY, TPM2_ST_ATTEST_QUOTE,
2189 TPM2_ST_ATTEST_SESSION_AUDIT, TPM2_ST_ATTEST_COMMAND_AUDIT,
2190 TPM2_ST_ATTEST_TIME, TPM2_ST_ATTEST_CREATION, TPM2_ST_ATTEST_NV);
2191 return ifapi_json_TPM2_ST_serialize(in, jso);
2192 }
2193
2194 /** Serialize a TPMU_ATTEST to json.
2195 *
2196 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2197 * @param[in] in the value to be serialized.
2198 * @param[in] selector the type of the attest.
2199 * @param[out] jso pointer to the json object.
2200 * @retval TSS2_RC_SUCCESS if the function call was a success.
2201 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2202 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_ATTEST.
2203 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2204 */
2205 TSS2_RC
ifapi_json_TPMU_ATTEST_serialize(const TPMU_ATTEST * in,UINT32 selector,json_object ** jso)2206 ifapi_json_TPMU_ATTEST_serialize(const TPMU_ATTEST *in, UINT32 selector, json_object **jso)
2207 {
2208 switch (selector) {
2209 case TPM2_ST_ATTEST_CERTIFY:
2210 return ifapi_json_TPMS_CERTIFY_INFO_serialize(&in->certify, jso);
2211 case TPM2_ST_ATTEST_CREATION:
2212 return ifapi_json_TPMS_CREATION_INFO_serialize(&in->creation, jso);
2213 case TPM2_ST_ATTEST_QUOTE:
2214 return ifapi_json_TPMS_QUOTE_INFO_serialize(&in->quote, jso);
2215 case TPM2_ST_ATTEST_COMMAND_AUDIT:
2216 return ifapi_json_TPMS_COMMAND_AUDIT_INFO_serialize(&in->commandAudit, jso);
2217 case TPM2_ST_ATTEST_SESSION_AUDIT:
2218 return ifapi_json_TPMS_SESSION_AUDIT_INFO_serialize(&in->sessionAudit, jso);
2219 case TPM2_ST_ATTEST_TIME:
2220 return ifapi_json_TPMS_TIME_ATTEST_INFO_serialize(&in->time, jso);
2221 case TPM2_ST_ATTEST_NV:
2222 return ifapi_json_TPMS_NV_CERTIFY_INFO_serialize(&in->nv, jso);
2223 default:
2224 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2225 return TSS2_FAPI_RC_BAD_VALUE;
2226 };
2227 return TSS2_RC_SUCCESS;
2228 }
2229
2230 /** Serialize value of type TPMS_ATTEST to json.
2231 *
2232 * @param[in] in value to be serialized.
2233 * @param[out] jso pointer to the json object.
2234 * @retval TSS2_RC_SUCCESS if the function call was a success.
2235 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2236 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ATTEST.
2237 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2238 */
2239 TSS2_RC
ifapi_json_TPMS_ATTEST_serialize(const TPMS_ATTEST * in,json_object ** jso)2240 ifapi_json_TPMS_ATTEST_serialize(const TPMS_ATTEST *in, json_object **jso)
2241 {
2242 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2243
2244 TSS2_RC r;
2245 json_object *jso2;
2246 if (*jso == NULL)
2247 *jso = json_object_new_object ();
2248 jso2 = NULL;
2249 r = ifapi_json_TPM2_GENERATED_serialize(in->magic, &jso2);
2250 return_if_error(r, "Serialize TPM2_GENERATED");
2251
2252 json_object_object_add(*jso, "magic", jso2);
2253 jso2 = NULL;
2254 r = ifapi_json_TPMI_ST_ATTEST_serialize(in->type, &jso2);
2255 return_if_error(r, "Serialize TPMI_ST_ATTEST");
2256
2257 json_object_object_add(*jso, "type", jso2);
2258 jso2 = NULL;
2259 r = ifapi_json_TPM2B_NAME_serialize(&in->qualifiedSigner, &jso2);
2260 return_if_error(r, "Serialize TPM2B_NAME");
2261
2262 json_object_object_add(*jso, "qualifiedSigner", jso2);
2263 jso2 = NULL;
2264 r = ifapi_json_TPM2B_DATA_serialize(&in->extraData, &jso2);
2265 return_if_error(r, "Serialize TPM2B_DATA");
2266
2267 json_object_object_add(*jso, "extraData", jso2);
2268 jso2 = NULL;
2269 r = ifapi_json_TPMS_CLOCK_INFO_serialize(&in->clockInfo, &jso2);
2270 return_if_error(r, "Serialize TPMS_CLOCK_INFO");
2271
2272 json_object_object_add(*jso, "clockInfo", jso2);
2273 jso2 = NULL;
2274 r = ifapi_json_UINT64_serialize(in->firmwareVersion, &jso2);
2275 return_if_error(r, "Serialize UINT64");
2276
2277 json_object_object_add(*jso, "firmwareVersion", jso2);
2278 jso2 = NULL;
2279 r = ifapi_json_TPMU_ATTEST_serialize(&in->attested, in->type, &jso2);
2280 return_if_error(r,"Serialize TPMU_ATTEST");
2281
2282 json_object_object_add(*jso, "attested", jso2);
2283 return TSS2_RC_SUCCESS;
2284 }
2285
2286 /** Serialize value of type TPMI_AES_KEY_BITS to json.
2287 *
2288 * @param[in] in value to be serialized.
2289 * @param[out] jso pointer to the json object.
2290 * @retval TSS2_RC_SUCCESS if the function call was a success.
2291 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2292 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_AES_KEY_BITS.
2293 *
2294 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2295 */
2296 TSS2_RC
ifapi_json_TPMI_AES_KEY_BITS_serialize(const TPMI_AES_KEY_BITS in,json_object ** jso)2297 ifapi_json_TPMI_AES_KEY_BITS_serialize(const TPMI_AES_KEY_BITS in, json_object **jso)
2298 {
2299 CHECK_IN_LIST(UINT16, in, 128, 192, 256);
2300 return ifapi_json_UINT16_serialize(in, jso);
2301 }
2302
2303 /** Serialize a TPMU_SYM_KEY_BITS to json.
2304 *
2305 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2306 * @param[in] in the value to be serialized.
2307 * @param[in] selector the type of the symmetric algorithm.
2308 * @param[out] jso pointer to the json object.
2309 * @retval TSS2_RC_SUCCESS if the function call was a success.
2310 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2311 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SYM_KEY_BITS.
2312 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2313 */
2314 TSS2_RC
ifapi_json_TPMU_SYM_KEY_BITS_serialize(const TPMU_SYM_KEY_BITS * in,UINT32 selector,json_object ** jso)2315 ifapi_json_TPMU_SYM_KEY_BITS_serialize(const TPMU_SYM_KEY_BITS *in, UINT32 selector, json_object **jso)
2316 {
2317 switch (selector) {
2318 case TPM2_ALG_AES:
2319 return ifapi_json_TPMI_AES_KEY_BITS_serialize(in->aes, jso);
2320 case TPM2_ALG_XOR:
2321 return ifapi_json_TPMI_ALG_HASH_serialize(in->exclusiveOr, jso);
2322 default:
2323 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2324 return TSS2_FAPI_RC_BAD_VALUE;
2325 };
2326 return TSS2_RC_SUCCESS;
2327 }
2328
2329 /** Serialize a TPMU_SYM_MODE to json.
2330 *
2331 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2332 * @param[in] in the value to be serialized.
2333 * @param[in] selector the type of the symmetric mode.
2334 * @param[out] jso pointer to the json object.
2335 * @retval TSS2_RC_SUCCESS if the function call was a success.
2336 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2337 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SYM_MODE.
2338 */
2339 TSS2_RC
ifapi_json_TPMU_SYM_MODE_serialize(const TPMU_SYM_MODE * in,UINT32 selector,json_object ** jso)2340 ifapi_json_TPMU_SYM_MODE_serialize(const TPMU_SYM_MODE *in, UINT32 selector, json_object **jso)
2341 {
2342 switch (selector) {
2343 case TPM2_ALG_AES:
2344 return ifapi_json_TPMI_ALG_SYM_MODE_serialize(in->aes, jso);
2345 default:
2346 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2347 return TSS2_FAPI_RC_BAD_VALUE;
2348 };
2349 return TSS2_RC_SUCCESS;
2350 }
2351
2352 /** Serialize value of type TPMT_SYM_DEF_OBJECT to json.
2353 *
2354 * @param[in] in value to be serialized.
2355 * @param[out] jso pointer to the json object.
2356 * @retval TSS2_RC_SUCCESS if the function call was a success.
2357 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2358 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_SYM_DEF_OBJECT.
2359 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2360 */
2361 TSS2_RC
ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(const TPMT_SYM_DEF_OBJECT * in,json_object ** jso)2362 ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(const TPMT_SYM_DEF_OBJECT *in, json_object **jso)
2363 {
2364 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2365
2366 TSS2_RC r;
2367 json_object *jso2;
2368 if (*jso == NULL)
2369 *jso = json_object_new_object ();
2370 jso2 = NULL;
2371 r = ifapi_json_TPMI_ALG_SYM_OBJECT_serialize(in->algorithm, &jso2);
2372 return_if_error(r, "Serialize TPMI_ALG_SYM_OBJECT");
2373
2374 json_object_object_add(*jso, "algorithm", jso2);
2375 if (in->algorithm != TPM2_ALG_NULL) {
2376 json_object *jso2 = NULL;
2377 r = ifapi_json_TPMU_SYM_KEY_BITS_serialize(&in->keyBits, in->algorithm, &jso2);
2378 return_if_error(r,"Serialize TPMU_SYM_KEY_BITS");
2379
2380 json_object_object_add(*jso, "keyBits", jso2);
2381 }
2382 if (in->algorithm != TPM2_ALG_NULL) {
2383 json_object *jso2 = NULL;
2384 r = ifapi_json_TPMU_SYM_MODE_serialize(&in->mode, in->algorithm, &jso2);
2385 return_if_error(r,"Serialize TPMU_SYM_MODE");
2386
2387 json_object_object_add(*jso, "mode", jso2);
2388 }
2389 return TSS2_RC_SUCCESS;
2390 }
2391
2392 /** Serialize value of type TPMS_SYMCIPHER_PARMS to json.
2393 *
2394 * @param[in] in value to be serialized.
2395 * @param[out] jso pointer to the json object.
2396 * @retval TSS2_RC_SUCCESS if the function call was a success.
2397 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2398 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SYMCIPHER_PARMS.
2399 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2400 */
2401 TSS2_RC
ifapi_json_TPMS_SYMCIPHER_PARMS_serialize(const TPMS_SYMCIPHER_PARMS * in,json_object ** jso)2402 ifapi_json_TPMS_SYMCIPHER_PARMS_serialize(const TPMS_SYMCIPHER_PARMS *in, json_object **jso)
2403 {
2404 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2405
2406 TSS2_RC r;
2407 json_object *jso2;
2408 if (*jso == NULL)
2409 *jso = json_object_new_object ();
2410 jso2 = NULL;
2411 r = ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(&in->sym, &jso2);
2412 return_if_error(r, "Serialize TPMT_SYM_DEF_OBJECT");
2413
2414 json_object_object_add(*jso, "sym", jso2);
2415 return TSS2_RC_SUCCESS;
2416 }
2417
2418 /** Serialize value of type TPMS_SCHEME_HASH to json.
2419 *
2420 * @param[in] in value to be serialized.
2421 * @param[out] jso pointer to the json object.
2422 * @retval TSS2_RC_SUCCESS if the function call was a success.
2423 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2424 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_HASH.
2425 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2426 */
2427 TSS2_RC
ifapi_json_TPMS_SCHEME_HASH_serialize(const TPMS_SCHEME_HASH * in,json_object ** jso)2428 ifapi_json_TPMS_SCHEME_HASH_serialize(const TPMS_SCHEME_HASH *in, json_object **jso)
2429 {
2430 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2431
2432 TSS2_RC r;
2433 json_object *jso2;
2434 if (*jso == NULL)
2435 *jso = json_object_new_object ();
2436 jso2 = NULL;
2437 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2);
2438 return_if_error(r, "Serialize TPMI_ALG_HASH");
2439
2440 json_object_object_add(*jso, "hashAlg", jso2);
2441 return TSS2_RC_SUCCESS;
2442 }
2443
2444 /** Serialize value of type TPMS_SCHEME_ECDAA to json.
2445 *
2446 * @param[in] in value to be serialized.
2447 * @param[out] jso pointer to the json object.
2448 * @retval TSS2_RC_SUCCESS if the function call was a success.
2449 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2450 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_ECDAA.
2451 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2452 */
2453 TSS2_RC
ifapi_json_TPMS_SCHEME_ECDAA_serialize(const TPMS_SCHEME_ECDAA * in,json_object ** jso)2454 ifapi_json_TPMS_SCHEME_ECDAA_serialize(const TPMS_SCHEME_ECDAA *in, json_object **jso)
2455 {
2456 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2457
2458 TSS2_RC r;
2459 json_object *jso2;
2460 if (*jso == NULL)
2461 *jso = json_object_new_object ();
2462 jso2 = NULL;
2463 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2);
2464 return_if_error(r, "Serialize TPMI_ALG_HASH");
2465
2466 json_object_object_add(*jso, "hashAlg", jso2);
2467 jso2 = NULL;
2468 r = ifapi_json_UINT16_serialize(in->count, &jso2);
2469 return_if_error(r, "Serialize UINT16");
2470
2471 json_object_object_add(*jso, "count", jso2);
2472 return TSS2_RC_SUCCESS;
2473 }
2474
2475 /** Serialize TPMI_ALG_KEYEDHASH_SCHEME to json.
2476 *
2477 * @param[in] in variable to be serialized.
2478 * @param[out] jso pointer to the json object.
2479 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
2480 * the function.
2481 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
2482 */
2483 TSS2_RC
ifapi_json_TPMI_ALG_KEYEDHASH_SCHEME_serialize(const TPMI_ALG_KEYEDHASH_SCHEME in,json_object ** jso)2484 ifapi_json_TPMI_ALG_KEYEDHASH_SCHEME_serialize(const TPMI_ALG_KEYEDHASH_SCHEME in, json_object **jso)
2485 {
2486 CHECK_IN_LIST(TPMI_ALG_HASH, in, TPM2_ALG_HMAC, TPM2_ALG_XOR, TPM2_ALG_NULL);
2487 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
2488 }
2489
2490 /** Serialize a TPMS_SCHEME_HMAC to json.
2491 *
2492 * @param[in] in value of type TPMS_SCHEME_HMAC to be serialized.
2493 * @param[out] jso pointer to the json object.
2494 * @retval TSS2_RC_SUCCESS if the function call was a success.
2495 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2496 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_HMAC.
2497 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2498 */
2499 TSS2_RC
ifapi_json_TPMS_SCHEME_HMAC_serialize(const TPMS_SCHEME_HMAC * in,json_object ** jso)2500 ifapi_json_TPMS_SCHEME_HMAC_serialize(const TPMS_SCHEME_HMAC *in, json_object **jso)
2501 {
2502 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2503 }
2504
2505 /** Serialize value of type TPMS_SCHEME_XOR to json.
2506 *
2507 * @param[in] in value to be serialized.
2508 * @param[out] jso pointer to the json object.
2509 * @retval TSS2_RC_SUCCESS if the function call was a success.
2510 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2511 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_XOR.
2512 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2513 */
2514 TSS2_RC
ifapi_json_TPMS_SCHEME_XOR_serialize(const TPMS_SCHEME_XOR * in,json_object ** jso)2515 ifapi_json_TPMS_SCHEME_XOR_serialize(const TPMS_SCHEME_XOR *in, json_object **jso)
2516 {
2517 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2518
2519 TSS2_RC r;
2520 json_object *jso2;
2521 if (*jso == NULL)
2522 *jso = json_object_new_object ();
2523 jso2 = NULL;
2524 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hashAlg, &jso2);
2525 return_if_error(r, "Serialize TPMI_ALG_HASH");
2526
2527 json_object_object_add(*jso, "hashAlg", jso2);
2528 jso2 = NULL;
2529 r = ifapi_json_TPMI_ALG_KDF_serialize(in->kdf, &jso2);
2530 return_if_error(r, "Serialize TPMI_ALG_KDF");
2531
2532 json_object_object_add(*jso, "kdf", jso2);
2533 return TSS2_RC_SUCCESS;
2534 }
2535
2536 /** Serialize a TPMU_SCHEME_KEYEDHASH to json.
2537 *
2538 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2539 * @param[in] in the value to be serialized.
2540 * @param[in] selector the type of the keyedhash scheme.
2541 * @param[out] jso pointer to the json object.
2542 * @retval TSS2_RC_SUCCESS if the function call was a success.
2543 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2544 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SCHEME_KEYEDHASH.
2545 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2546 */
2547 TSS2_RC
ifapi_json_TPMU_SCHEME_KEYEDHASH_serialize(const TPMU_SCHEME_KEYEDHASH * in,UINT32 selector,json_object ** jso)2548 ifapi_json_TPMU_SCHEME_KEYEDHASH_serialize(const TPMU_SCHEME_KEYEDHASH *in, UINT32 selector, json_object **jso)
2549 {
2550 switch (selector) {
2551 case TPM2_ALG_HMAC:
2552 return ifapi_json_TPMS_SCHEME_HMAC_serialize(&in->hmac, jso);
2553 case TPM2_ALG_XOR:
2554 return ifapi_json_TPMS_SCHEME_XOR_serialize(&in->exclusiveOr, jso);
2555 default:
2556 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2557 return TSS2_FAPI_RC_BAD_VALUE;
2558 };
2559 return TSS2_RC_SUCCESS;
2560 }
2561
2562 /** Serialize value of type TPMT_KEYEDHASH_SCHEME to json.
2563 *
2564 * @param[in] in value to be serialized.
2565 * @param[out] jso pointer to the json object.
2566 * @retval TSS2_RC_SUCCESS if the function call was a success.
2567 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2568 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_KEYEDHASH_SCHEME.
2569 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2570 */
2571 TSS2_RC
ifapi_json_TPMT_KEYEDHASH_SCHEME_serialize(const TPMT_KEYEDHASH_SCHEME * in,json_object ** jso)2572 ifapi_json_TPMT_KEYEDHASH_SCHEME_serialize(const TPMT_KEYEDHASH_SCHEME *in, json_object **jso)
2573 {
2574 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2575
2576 TSS2_RC r;
2577 json_object *jso2;
2578 if (*jso == NULL)
2579 *jso = json_object_new_object ();
2580 jso2 = NULL;
2581 r = ifapi_json_TPMI_ALG_KEYEDHASH_SCHEME_serialize(in->scheme, &jso2);
2582 return_if_error(r, "Serialize TPMI_ALG_KEYEDHASH_SCHEME");
2583
2584 json_object_object_add(*jso, "scheme", jso2);
2585 if (in->scheme != TPM2_ALG_NULL) {
2586 json_object *jso2 = NULL;
2587 r = ifapi_json_TPMU_SCHEME_KEYEDHASH_serialize(&in->details, in->scheme, &jso2);
2588 return_if_error(r,"Serialize TPMU_SCHEME_KEYEDHASH");
2589
2590 json_object_object_add(*jso, "details", jso2);
2591 }
2592 return TSS2_RC_SUCCESS;
2593 }
2594
2595 /** Serialize a TPMS_SIG_SCHEME_RSASSA to json.
2596 *
2597 * @param[in] in value of type TPMS_SIG_SCHEME_RSASSA to be serialized.
2598 * @param[out] jso pointer to the json object.
2599 * @retval TSS2_RC_SUCCESS if the function call was a success.
2600 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2601 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_RSASSA.
2602 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2603 */
2604 TSS2_RC
ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(const TPMS_SIG_SCHEME_RSASSA * in,json_object ** jso)2605 ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(const TPMS_SIG_SCHEME_RSASSA *in, json_object **jso)
2606 {
2607 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2608 }
2609
2610 /** Serialize a TPMS_SIG_SCHEME_RSAPSS to json.
2611 *
2612 * @param[in] in value of type TPMS_SIG_SCHEME_RSAPSS to be serialized.
2613 * @param[out] jso pointer to the json object.
2614 * @retval TSS2_RC_SUCCESS if the function call was a success.
2615 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2616 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_RSAPSS.
2617 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2618 */
2619 TSS2_RC
ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(const TPMS_SIG_SCHEME_RSAPSS * in,json_object ** jso)2620 ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(const TPMS_SIG_SCHEME_RSAPSS *in, json_object **jso)
2621 {
2622 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2623 }
2624
2625 /** Serialize a TPMS_SIG_SCHEME_ECDSA to json.
2626 *
2627 * @param[in] in value of type TPMS_SIG_SCHEME_ECDSA to be serialized.
2628 * @param[out] jso pointer to the json object.
2629 * @retval TSS2_RC_SUCCESS if the function call was a success.
2630 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2631 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_ECDSA.
2632 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2633 */
2634 TSS2_RC
ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(const TPMS_SIG_SCHEME_ECDSA * in,json_object ** jso)2635 ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(const TPMS_SIG_SCHEME_ECDSA *in, json_object **jso)
2636 {
2637 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2638 }
2639
2640 /** Serialize a TPMS_SIG_SCHEME_SM2 to json.
2641 *
2642 * @param[in] in value of type TPMS_SIG_SCHEME_SM2 to be serialized.
2643 * @param[out] jso pointer to the json object.
2644 * @retval TSS2_RC_SUCCESS if the function call was a success.
2645 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2646 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_SM2.
2647 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2648 */
2649 TSS2_RC
ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(const TPMS_SIG_SCHEME_SM2 * in,json_object ** jso)2650 ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(const TPMS_SIG_SCHEME_SM2 *in, json_object **jso)
2651 {
2652 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2653 }
2654
2655 /** Serialize a TPMS_SIG_SCHEME_ECSCHNORR to json.
2656 *
2657 * @param[in] in value of type TPMS_SIG_SCHEME_ECSCHNORR to be serialized.
2658 * @param[out] jso pointer to the json object.
2659 * @retval TSS2_RC_SUCCESS if the function call was a success.
2660 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2661 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_ECSCHNORR.
2662 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2663 */
2664 TSS2_RC
ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(const TPMS_SIG_SCHEME_ECSCHNORR * in,json_object ** jso)2665 ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(const TPMS_SIG_SCHEME_ECSCHNORR *in, json_object **jso)
2666 {
2667 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2668 }
2669
2670 /** Serialize a TPMS_SIG_SCHEME_ECDAA to json.
2671 *
2672 * @param[in] in value of type TPMS_SIG_SCHEME_ECDAA to be serialized.
2673 * @param[out] jso pointer to the json object.
2674 * @retval TSS2_RC_SUCCESS if the function call was a success.
2675 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2676 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIG_SCHEME_ECDAA.
2677 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2678 */
2679 TSS2_RC
ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(const TPMS_SIG_SCHEME_ECDAA * in,json_object ** jso)2680 ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(const TPMS_SIG_SCHEME_ECDAA *in, json_object **jso)
2681 {
2682 return ifapi_json_TPMS_SCHEME_ECDAA_serialize(in, jso);
2683 }
2684
2685 /** Serialize a TPMU_SIG_SCHEME to json.
2686 *
2687 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2688 * @param[in] in the value to be serialized.
2689 * @param[in] selector the type of the signature scheme.
2690 * @param[out] jso pointer to the json object.
2691 * @retval TSS2_RC_SUCCESS if the function call was a success.
2692 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2693 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SIG_SCHEME.
2694 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2695 */
2696 TSS2_RC
ifapi_json_TPMU_SIG_SCHEME_serialize(const TPMU_SIG_SCHEME * in,UINT32 selector,json_object ** jso)2697 ifapi_json_TPMU_SIG_SCHEME_serialize(const TPMU_SIG_SCHEME *in, UINT32 selector, json_object **jso)
2698 {
2699 switch (selector) {
2700 case TPM2_ALG_RSASSA:
2701 return ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(&in->rsassa, jso);
2702 case TPM2_ALG_RSAPSS:
2703 return ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(&in->rsapss, jso);
2704 case TPM2_ALG_ECDSA:
2705 return ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(&in->ecdsa, jso);
2706 case TPM2_ALG_ECDAA:
2707 return ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(&in->ecdaa, jso);
2708 case TPM2_ALG_SM2:
2709 return ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(&in->sm2, jso);
2710 case TPM2_ALG_ECSCHNORR:
2711 return ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(&in->ecschnorr, jso);
2712 case TPM2_ALG_HMAC:
2713 return ifapi_json_TPMS_SCHEME_HMAC_serialize(&in->hmac, jso);
2714 default:
2715 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2716 return TSS2_FAPI_RC_BAD_VALUE;
2717 };
2718 return TSS2_RC_SUCCESS;
2719 }
2720
2721 /** Serialize value of type TPMT_SIG_SCHEME to json.
2722 *
2723 * @param[in] in value to be serialized.
2724 * @param[out] jso pointer to the json object.
2725 * @retval TSS2_RC_SUCCESS if the function call was a success.
2726 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2727 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_SIG_SCHEME.
2728 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2729 */
2730 TSS2_RC
ifapi_json_TPMT_SIG_SCHEME_serialize(const TPMT_SIG_SCHEME * in,json_object ** jso)2731 ifapi_json_TPMT_SIG_SCHEME_serialize(const TPMT_SIG_SCHEME *in, json_object **jso)
2732 {
2733 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2734
2735 TSS2_RC r;
2736 json_object *jso2;
2737 if (*jso == NULL)
2738 *jso = json_object_new_object ();
2739 jso2 = NULL;
2740 r = ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(in->scheme, &jso2);
2741 return_if_error(r, "Serialize TPMI_ALG_SIG_SCHEME");
2742
2743 json_object_object_add(*jso, "scheme", jso2);
2744 if (in->scheme != TPM2_ALG_NULL) {
2745 json_object *jso2 = NULL;
2746 r = ifapi_json_TPMU_SIG_SCHEME_serialize(&in->details, in->scheme, &jso2);
2747 return_if_error(r,"Serialize TPMU_SIG_SCHEME");
2748
2749 json_object_object_add(*jso, "details", jso2);
2750 }
2751 return TSS2_RC_SUCCESS;
2752 }
2753
2754 /** Serialize a TPMS_ENC_SCHEME_OAEP to json.
2755 *
2756 * @param[in] in value of type TPMS_ENC_SCHEME_OAEP to be serialized.
2757 * @param[out] jso pointer to the json object.
2758 * @retval TSS2_RC_SUCCESS if the function call was a success.
2759 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2760 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ENC_SCHEME_OAEP.
2761 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2762 */
2763 TSS2_RC
ifapi_json_TPMS_ENC_SCHEME_OAEP_serialize(const TPMS_ENC_SCHEME_OAEP * in,json_object ** jso)2764 ifapi_json_TPMS_ENC_SCHEME_OAEP_serialize(const TPMS_ENC_SCHEME_OAEP *in, json_object **jso)
2765 {
2766 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2767 }
2768
2769 /** Serialize a TPMS_ENC_SCHEME_RSAES to json.
2770 *
2771 * @param[in] in value of type TPMS_ENC_SCHEME_RSAES to be serialized.
2772 * @param[out] jso pointer to the json object.
2773 * @retval TSS2_RC_SUCCESS if the function call was a success.
2774 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2775 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ENC_SCHEME_RSAES.
2776 */
2777 TSS2_RC
ifapi_json_TPMS_ENC_SCHEME_RSAES_serialize(const TPMS_ENC_SCHEME_RSAES * in,json_object ** jso)2778 ifapi_json_TPMS_ENC_SCHEME_RSAES_serialize(const TPMS_ENC_SCHEME_RSAES *in, json_object **jso)
2779 {
2780 return ifapi_json_TPMS_EMPTY_serialize(in, jso);
2781 }
2782
2783 /** Serialize a TPMS_KEY_SCHEME_ECDH to json.
2784 *
2785 * @param[in] in value of type TPMS_KEY_SCHEME_ECDH to be serialized.
2786 * @param[out] jso pointer to the json object.
2787 * @retval TSS2_RC_SUCCESS if the function call was a success.
2788 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2789 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_KEY_SCHEME_ECDH.
2790 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2791 */
2792 TSS2_RC
ifapi_json_TPMS_KEY_SCHEME_ECDH_serialize(const TPMS_KEY_SCHEME_ECDH * in,json_object ** jso)2793 ifapi_json_TPMS_KEY_SCHEME_ECDH_serialize(const TPMS_KEY_SCHEME_ECDH *in, json_object **jso)
2794 {
2795 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2796 }
2797
2798 /** Serialize a TPMS_SCHEME_MGF1 to json.
2799 *
2800 * @param[in] in value of type TPMS_SCHEME_MGF1 to be serialized.
2801 * @param[out] jso pointer to the json object.
2802 * @retval TSS2_RC_SUCCESS if the function call was a success.
2803 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2804 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_MGF1.
2805 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2806 */
2807 TSS2_RC
ifapi_json_TPMS_SCHEME_MGF1_serialize(const TPMS_SCHEME_MGF1 * in,json_object ** jso)2808 ifapi_json_TPMS_SCHEME_MGF1_serialize(const TPMS_SCHEME_MGF1 *in, json_object **jso)
2809 {
2810 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2811 }
2812
2813 /** Serialize a TPMS_SCHEME_KDF1_SP800_56A to json.
2814 *
2815 * @param[in] in value of type TPMS_SCHEME_KDF1_SP800_56A to be serialized.
2816 * @param[out] jso pointer to the json object.
2817 * @retval TSS2_RC_SUCCESS if the function call was a success.
2818 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2819 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_KDF1_SP800_56A.
2820 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2821 */
2822 TSS2_RC
ifapi_json_TPMS_SCHEME_KDF1_SP800_56A_serialize(const TPMS_SCHEME_KDF1_SP800_56A * in,json_object ** jso)2823 ifapi_json_TPMS_SCHEME_KDF1_SP800_56A_serialize(const TPMS_SCHEME_KDF1_SP800_56A *in, json_object **jso)
2824 {
2825 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2826 }
2827
2828 /** Serialize a TPMS_SCHEME_KDF1_SP800_108 to json.
2829 *
2830 * @param[in] in value of type TPMS_SCHEME_KDF1_SP800_108 to be serialized.
2831 * @param[out] jso pointer to the json object.
2832 * @retval TSS2_RC_SUCCESS if the function call was a success.
2833 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2834 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SCHEME_KDF1_SP800_108.
2835 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2836 */
2837 TSS2_RC
ifapi_json_TPMS_SCHEME_KDF1_SP800_108_serialize(const TPMS_SCHEME_KDF1_SP800_108 * in,json_object ** jso)2838 ifapi_json_TPMS_SCHEME_KDF1_SP800_108_serialize(const TPMS_SCHEME_KDF1_SP800_108 *in, json_object **jso)
2839 {
2840 return ifapi_json_TPMS_SCHEME_HASH_serialize(in, jso);
2841 }
2842
2843 /** Serialize a TPMU_KDF_SCHEME to json.
2844 *
2845 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2846 * @param[in] in the value to be serialized.
2847 * @param[in] selector the type of the KDF scheme.
2848 * @param[out] jso pointer to the json object.
2849 * @retval TSS2_RC_SUCCESS if the function call was a success.
2850 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2851 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_KDF_SCHEME.
2852 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2853 */
2854 TSS2_RC
ifapi_json_TPMU_KDF_SCHEME_serialize(const TPMU_KDF_SCHEME * in,UINT32 selector,json_object ** jso)2855 ifapi_json_TPMU_KDF_SCHEME_serialize(const TPMU_KDF_SCHEME *in, UINT32 selector, json_object **jso)
2856 {
2857 switch (selector) {
2858 case TPM2_ALG_MGF1:
2859 return ifapi_json_TPMS_SCHEME_MGF1_serialize(&in->mgf1, jso);
2860 case TPM2_ALG_KDF1_SP800_56A:
2861 return ifapi_json_TPMS_SCHEME_KDF1_SP800_56A_serialize(&in->kdf1_sp800_56a, jso);
2862 case TPM2_ALG_KDF1_SP800_108:
2863 return ifapi_json_TPMS_SCHEME_KDF1_SP800_108_serialize(&in->kdf1_sp800_108, jso);
2864 default:
2865 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2866 return TSS2_FAPI_RC_BAD_VALUE;
2867 };
2868 return TSS2_RC_SUCCESS;
2869 }
2870
2871 /** Serialize value of type TPMT_KDF_SCHEME to json.
2872 *
2873 * @param[in] in value to be serialized.
2874 * @param[out] jso pointer to the json object.
2875 * @retval TSS2_RC_SUCCESS if the function call was a success.
2876 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2877 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_KDF_SCHEME.
2878 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2879 */
2880 TSS2_RC
ifapi_json_TPMT_KDF_SCHEME_serialize(const TPMT_KDF_SCHEME * in,json_object ** jso)2881 ifapi_json_TPMT_KDF_SCHEME_serialize(const TPMT_KDF_SCHEME *in, json_object **jso)
2882 {
2883 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2884
2885 TSS2_RC r;
2886 json_object *jso2;
2887 if (*jso == NULL)
2888 *jso = json_object_new_object ();
2889 jso2 = NULL;
2890 r = ifapi_json_TPMI_ALG_KDF_serialize(in->scheme, &jso2);
2891 return_if_error(r, "Serialize TPMI_ALG_KDF");
2892
2893 json_object_object_add(*jso, "scheme", jso2);
2894 if (in->scheme != TPM2_ALG_NULL) {
2895 json_object *jso2 = NULL;
2896 r = ifapi_json_TPMU_KDF_SCHEME_serialize(&in->details, in->scheme, &jso2);
2897 return_if_error(r,"Serialize TPMU_KDF_SCHEME");
2898
2899 json_object_object_add(*jso, "details", jso2);
2900 }
2901 return TSS2_RC_SUCCESS;
2902 }
2903
2904 /** Serialize TPMI_ALG_ASYM_SCHEME to json.
2905 *
2906 * @param[in] in variable to be serialized.
2907 * @param[out] jso pointer to the json object.
2908 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
2909 * the function.
2910 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
2911 */
2912 TSS2_RC
ifapi_json_TPMI_ALG_ASYM_SCHEME_serialize(const TPMI_ALG_ASYM_SCHEME in,json_object ** jso)2913 ifapi_json_TPMI_ALG_ASYM_SCHEME_serialize(const TPMI_ALG_ASYM_SCHEME in, json_object **jso)
2914 {
2915 CHECK_IN_LIST(TPMI_ALG_ASYM_SCHEME, in, TPM2_ALG_ECDH, TPM2_ALG_RSASSA, TPM2_ALG_RSAPSS,
2916 TPM2_ALG_ECDSA, TPM2_ALG_ECDAA, TPM2_ALG_SM2, TPM2_ALG_ECSCHNORR,
2917 TPM2_ALG_RSAES, TPM2_ALG_OAEP, TPM2_ALG_NULL);
2918 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
2919 }
2920
2921 /** Serialize a TPMU_ASYM_SCHEME to json.
2922 *
2923 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
2924 * @param[in] in the value to be serialized.
2925 * @param[in] selector the type of the scheme.
2926 * @param[out] jso pointer to the json object.
2927 * @retval TSS2_RC_SUCCESS if the function call was a success.
2928 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2929 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_ASYM_SCHEME.
2930 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2931 */
2932 TSS2_RC
ifapi_json_TPMU_ASYM_SCHEME_serialize(const TPMU_ASYM_SCHEME * in,UINT32 selector,json_object ** jso)2933 ifapi_json_TPMU_ASYM_SCHEME_serialize(const TPMU_ASYM_SCHEME *in, UINT32 selector, json_object **jso)
2934 {
2935 switch (selector) {
2936 case TPM2_ALG_ECDH:
2937 return ifapi_json_TPMS_KEY_SCHEME_ECDH_serialize(&in->ecdh, jso);
2938 case TPM2_ALG_RSASSA:
2939 return ifapi_json_TPMS_SIG_SCHEME_RSASSA_serialize(&in->rsassa, jso);
2940 case TPM2_ALG_RSAPSS:
2941 return ifapi_json_TPMS_SIG_SCHEME_RSAPSS_serialize(&in->rsapss, jso);
2942 case TPM2_ALG_ECDSA:
2943 return ifapi_json_TPMS_SIG_SCHEME_ECDSA_serialize(&in->ecdsa, jso);
2944 case TPM2_ALG_ECDAA:
2945 return ifapi_json_TPMS_SIG_SCHEME_ECDAA_serialize(&in->ecdaa, jso);
2946 case TPM2_ALG_SM2:
2947 return ifapi_json_TPMS_SIG_SCHEME_SM2_serialize(&in->sm2, jso);
2948 case TPM2_ALG_ECSCHNORR:
2949 return ifapi_json_TPMS_SIG_SCHEME_ECSCHNORR_serialize(&in->ecschnorr, jso);
2950 case TPM2_ALG_RSAES:
2951 return ifapi_json_TPMS_ENC_SCHEME_RSAES_serialize(&in->rsaes, jso);
2952 case TPM2_ALG_OAEP:
2953 return ifapi_json_TPMS_ENC_SCHEME_OAEP_serialize(&in->oaep, jso);
2954 default:
2955 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
2956 return TSS2_FAPI_RC_BAD_VALUE;
2957 };
2958 return TSS2_RC_SUCCESS;
2959 }
2960
2961 /** Serialize TPMI_ALG_RSA_SCHEME to json.
2962 *
2963 * @param[in] in variable to be serialized.
2964 * @param[out] jso pointer to the json object.
2965 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
2966 * the function.
2967 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
2968 */
2969 TSS2_RC
ifapi_json_TPMI_ALG_RSA_SCHEME_serialize(const TPMI_ALG_RSA_SCHEME in,json_object ** jso)2970 ifapi_json_TPMI_ALG_RSA_SCHEME_serialize(const TPMI_ALG_RSA_SCHEME in, json_object **jso)
2971 {
2972 CHECK_IN_LIST(TPMI_ALG_RSA_SCHEME, in, TPM2_ALG_RSAES, TPM2_ALG_OAEP, TPM2_ALG_RSASSA,
2973 TPM2_ALG_RSAPSS, TPM2_ALG_NULL);
2974 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
2975 }
2976
2977 /** Serialize value of type TPMT_RSA_SCHEME to json.
2978 *
2979 * @param[in] in value to be serialized.
2980 * @param[out] jso pointer to the json object.
2981 * @retval TSS2_RC_SUCCESS if the function call was a success.
2982 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
2983 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_RSA_SCHEME.
2984 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
2985 */
2986 TSS2_RC
ifapi_json_TPMT_RSA_SCHEME_serialize(const TPMT_RSA_SCHEME * in,json_object ** jso)2987 ifapi_json_TPMT_RSA_SCHEME_serialize(const TPMT_RSA_SCHEME *in, json_object **jso)
2988 {
2989 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
2990
2991 TSS2_RC r;
2992 json_object *jso2;
2993 if (*jso == NULL)
2994 *jso = json_object_new_object ();
2995 jso2 = NULL;
2996 r = ifapi_json_TPMI_ALG_RSA_SCHEME_serialize(in->scheme, &jso2);
2997 return_if_error(r, "Serialize TPMI_ALG_RSA_SCHEME");
2998
2999 json_object_object_add(*jso, "scheme", jso2);
3000 if (in->scheme != TPM2_ALG_NULL) {
3001 json_object *jso2 = NULL;
3002 r = ifapi_json_TPMU_ASYM_SCHEME_serialize(&in->details, in->scheme, &jso2);
3003 return_if_error(r,"Serialize TPMU_ASYM_SCHEME");
3004
3005 json_object_object_add(*jso, "details", jso2);
3006 }
3007 return TSS2_RC_SUCCESS;
3008 }
3009
3010 /** Serialize value of type TPM2B_PUBLIC_KEY_RSA to json.
3011 *
3012 * @param[in] in value to be serialized.
3013 * @param[out] jso pointer to the json object.
3014 * @retval TSS2_RC_SUCCESS if the function call was a success.
3015 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3016 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_PUBLIC_KEY_RSA.
3017 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3018 */
3019 TSS2_RC
ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(const TPM2B_PUBLIC_KEY_RSA * in,json_object ** jso)3020 ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(const TPM2B_PUBLIC_KEY_RSA *in, json_object **jso)
3021 {
3022 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3023
3024 if (in->size > TPM2_MAX_RSA_KEY_BYTES) {
3025 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_RSA_KEY_BYTES)",
3026 (size_t)in->size, (size_t)TPM2_MAX_RSA_KEY_BYTES);
3027 return TSS2_FAPI_RC_BAD_VALUE;
3028 }
3029 char hex_string[((size_t)in->size)*2+1];
3030
3031 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
3032 sprintf(&hex_string[off], "%02x", in->buffer[i]);
3033 hex_string[(in->size)*2] = '\0';
3034 *jso = json_object_new_string (hex_string);
3035 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3036
3037 return TSS2_RC_SUCCESS;
3038 }
3039
3040 /** Serialize value of type TPMI_RSA_KEY_BITS to json.
3041 *
3042 * @param[in] in value to be serialized.
3043 * @param[out] jso pointer to the json object.
3044 * @retval TSS2_RC_SUCCESS if the function call was a success.
3045 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3046 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_RSA_KEY_BITS.
3047 *
3048 */
3049 TSS2_RC
ifapi_json_TPMI_RSA_KEY_BITS_serialize(const TPMI_RSA_KEY_BITS in,json_object ** jso)3050 ifapi_json_TPMI_RSA_KEY_BITS_serialize(const TPMI_RSA_KEY_BITS in, json_object **jso)
3051 {
3052 CHECK_IN_LIST(TPMI_RSA_KEY_BITS, in, 1024, 2048);
3053 return ifapi_json_UINT16_serialize(in, jso);
3054 }
3055
3056 /** Serialize value of type TPM2B_ECC_PARAMETER to json.
3057 *
3058 * @param[in] in value to be serialized.
3059 * @param[out] jso pointer to the json object.
3060 * @retval TSS2_RC_SUCCESS if the function call was a success.
3061 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3062 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_ECC_PARAMETER.
3063 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3064 */
3065 TSS2_RC
ifapi_json_TPM2B_ECC_PARAMETER_serialize(const TPM2B_ECC_PARAMETER * in,json_object ** jso)3066 ifapi_json_TPM2B_ECC_PARAMETER_serialize(const TPM2B_ECC_PARAMETER *in, json_object **jso)
3067 {
3068 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3069
3070 if (in->size > TPM2_MAX_ECC_KEY_BYTES) {
3071 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = TPM2_MAX_ECC_KEY_BYTES)",
3072 (size_t)in->size, (size_t)TPM2_MAX_ECC_KEY_BYTES);
3073 return TSS2_FAPI_RC_BAD_VALUE;
3074 }
3075 char hex_string[((size_t)in->size)*2+1];
3076
3077 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
3078 sprintf(&hex_string[off], "%02x", in->buffer[i]);
3079 hex_string[(in->size)*2] = '\0';
3080 *jso = json_object_new_string (hex_string);
3081 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3082
3083 return TSS2_RC_SUCCESS;
3084 }
3085
3086 /** Serialize value of type TPMS_ECC_POINT to json.
3087 *
3088 * @param[in] in value to be serialized.
3089 * @param[out] jso pointer to the json object.
3090 * @retval TSS2_RC_SUCCESS if the function call was a success.
3091 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3092 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ECC_POINT.
3093 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3094 */
3095 TSS2_RC
ifapi_json_TPMS_ECC_POINT_serialize(const TPMS_ECC_POINT * in,json_object ** jso)3096 ifapi_json_TPMS_ECC_POINT_serialize(const TPMS_ECC_POINT *in, json_object **jso)
3097 {
3098 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3099
3100 TSS2_RC r;
3101 json_object *jso2;
3102 if (*jso == NULL)
3103 *jso = json_object_new_object ();
3104 jso2 = NULL;
3105 r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->x, &jso2);
3106 return_if_error(r, "Serialize TPM2B_ECC_PARAMETER");
3107
3108 json_object_object_add(*jso, "x", jso2);
3109 jso2 = NULL;
3110 r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->y, &jso2);
3111 return_if_error(r, "Serialize TPM2B_ECC_PARAMETER");
3112
3113 json_object_object_add(*jso, "y", jso2);
3114 return TSS2_RC_SUCCESS;
3115 }
3116
3117 /** Serialize TPMI_ALG_ECC_SCHEME to json.
3118 *
3119 * @param[in] in variable to be serialized.
3120 * @param[out] jso pointer to the json object.
3121 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
3122 * the function.
3123 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
3124 */
3125 TSS2_RC
ifapi_json_TPMI_ALG_ECC_SCHEME_serialize(const TPMI_ALG_ECC_SCHEME in,json_object ** jso)3126 ifapi_json_TPMI_ALG_ECC_SCHEME_serialize(const TPMI_ALG_ECC_SCHEME in, json_object **jso)
3127 {
3128 CHECK_IN_LIST(TPMI_ALG_ECC_SCHEME, in, TPM2_ALG_ECDSA, TPM2_ALG_ECDAA,
3129 TPM2_ALG_SM2, TPM2_ALG_ECSCHNORR, TPM2_ALG_ECDH, TPM2_ALG_NULL);
3130 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
3131 }
3132
3133 /** Serialize value of type TPMI_ECC_CURVE to json.
3134 *
3135 * @param[in] in value to be serialized.
3136 * @param[out] jso pointer to the json object.
3137 * @retval TSS2_RC_SUCCESS if the function call was a success.
3138 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3139 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMI_ECC_CURVE.
3140 *
3141 */
3142 TSS2_RC
ifapi_json_TPMI_ECC_CURVE_serialize(const TPMI_ECC_CURVE in,json_object ** jso)3143 ifapi_json_TPMI_ECC_CURVE_serialize(const TPMI_ECC_CURVE in, json_object **jso)
3144 {
3145 return ifapi_json_TPM2_ECC_CURVE_serialize(in, jso);
3146 }
3147
3148 /** Serialize value of type TPMT_ECC_SCHEME to json.
3149 *
3150 * @param[in] in value to be serialized.
3151 * @param[out] jso pointer to the json object.
3152 * @retval TSS2_RC_SUCCESS if the function call was a success.
3153 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3154 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_ECC_SCHEME.
3155 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3156 */
3157 TSS2_RC
ifapi_json_TPMT_ECC_SCHEME_serialize(const TPMT_ECC_SCHEME * in,json_object ** jso)3158 ifapi_json_TPMT_ECC_SCHEME_serialize(const TPMT_ECC_SCHEME *in, json_object **jso)
3159 {
3160 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3161
3162 TSS2_RC r;
3163 json_object *jso2;
3164 if (*jso == NULL)
3165 *jso = json_object_new_object ();
3166 jso2 = NULL;
3167 r = ifapi_json_TPMI_ALG_ECC_SCHEME_serialize(in->scheme, &jso2);
3168 return_if_error(r, "Serialize TPMI_ALG_ECC_SCHEME");
3169
3170 json_object_object_add(*jso, "scheme", jso2);
3171 if (in->scheme != TPM2_ALG_NULL) {
3172 json_object *jso2 = NULL;
3173 r = ifapi_json_TPMU_ASYM_SCHEME_serialize(&in->details, in->scheme, &jso2);
3174 return_if_error(r,"Serialize TPMU_ASYM_SCHEME");
3175
3176 json_object_object_add(*jso, "details", jso2);
3177 }
3178 return TSS2_RC_SUCCESS;
3179 }
3180
3181 /** Serialize value of type TPMS_SIGNATURE_RSA to json.
3182 *
3183 * @param[in] in value to be serialized.
3184 * @param[out] jso pointer to the json object.
3185 * @retval TSS2_RC_SUCCESS if the function call was a success.
3186 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3187 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_RSA.
3188 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3189 */
3190 TSS2_RC
ifapi_json_TPMS_SIGNATURE_RSA_serialize(const TPMS_SIGNATURE_RSA * in,json_object ** jso)3191 ifapi_json_TPMS_SIGNATURE_RSA_serialize(const TPMS_SIGNATURE_RSA *in, json_object **jso)
3192 {
3193 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3194
3195 TSS2_RC r;
3196 json_object *jso2;
3197 if (*jso == NULL)
3198 *jso = json_object_new_object ();
3199 jso2 = NULL;
3200 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hash, &jso2);
3201 return_if_error(r, "Serialize TPMI_ALG_HASH");
3202
3203 json_object_object_add(*jso, "hash", jso2);
3204 jso2 = NULL;
3205 r = ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(&in->sig, &jso2);
3206 return_if_error(r, "Serialize TPM2B_PUBLIC_KEY_RSA");
3207
3208 json_object_object_add(*jso, "sig", jso2);
3209 return TSS2_RC_SUCCESS;
3210 }
3211
3212 /** Serialize a TPMS_SIGNATURE_RSASSA to json.
3213 *
3214 * @param[in] in value of type TPMS_SIGNATURE_RSASSA to be serialized.
3215 * @param[out] jso pointer to the json object.
3216 * @retval TSS2_RC_SUCCESS if the function call was a success.
3217 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3218 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_RSASSA.
3219 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3220 */
3221 TSS2_RC
ifapi_json_TPMS_SIGNATURE_RSASSA_serialize(const TPMS_SIGNATURE_RSASSA * in,json_object ** jso)3222 ifapi_json_TPMS_SIGNATURE_RSASSA_serialize(const TPMS_SIGNATURE_RSASSA *in, json_object **jso)
3223 {
3224 return ifapi_json_TPMS_SIGNATURE_RSA_serialize(in, jso);
3225 }
3226
3227 /** Serialize a TPMS_SIGNATURE_RSAPSS to json.
3228 *
3229 * @param[in] in value of type TPMS_SIGNATURE_RSAPSS to be serialized.
3230 * @param[out] jso pointer to the json object.
3231 * @retval TSS2_RC_SUCCESS if the function call was a success.
3232 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3233 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_RSAPSS.
3234 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3235 */
3236 TSS2_RC
ifapi_json_TPMS_SIGNATURE_RSAPSS_serialize(const TPMS_SIGNATURE_RSAPSS * in,json_object ** jso)3237 ifapi_json_TPMS_SIGNATURE_RSAPSS_serialize(const TPMS_SIGNATURE_RSAPSS *in, json_object **jso)
3238 {
3239 return ifapi_json_TPMS_SIGNATURE_RSA_serialize(in, jso);
3240 }
3241
3242 /** Serialize value of type TPMS_SIGNATURE_ECC to json.
3243 *
3244 * @param[in] in value to be serialized.
3245 * @param[out] jso pointer to the json object.
3246 * @retval TSS2_RC_SUCCESS if the function call was a success.
3247 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3248 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECC.
3249 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3250 */
3251 TSS2_RC
ifapi_json_TPMS_SIGNATURE_ECC_serialize(const TPMS_SIGNATURE_ECC * in,json_object ** jso)3252 ifapi_json_TPMS_SIGNATURE_ECC_serialize(const TPMS_SIGNATURE_ECC *in, json_object **jso)
3253 {
3254 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3255
3256 TSS2_RC r;
3257 json_object *jso2;
3258 if (*jso == NULL)
3259 *jso = json_object_new_object ();
3260 jso2 = NULL;
3261 r = ifapi_json_TPMI_ALG_HASH_serialize(in->hash, &jso2);
3262 return_if_error(r, "Serialize TPMI_ALG_HASH");
3263
3264 json_object_object_add(*jso, "hash", jso2);
3265 jso2 = NULL;
3266 r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->signatureR, &jso2);
3267 return_if_error(r, "Serialize TPM2B_ECC_PARAMETER");
3268
3269 json_object_object_add(*jso, "signatureR", jso2);
3270 jso2 = NULL;
3271 r = ifapi_json_TPM2B_ECC_PARAMETER_serialize(&in->signatureS, &jso2);
3272 return_if_error(r, "Serialize TPM2B_ECC_PARAMETER");
3273
3274 json_object_object_add(*jso, "signatureS", jso2);
3275 return TSS2_RC_SUCCESS;
3276 }
3277
3278 /** Serialize a TPMS_SIGNATURE_ECDSA to json.
3279 *
3280 * @param[in] in value of type TPMS_SIGNATURE_ECDSA to be serialized.
3281 * @param[out] jso pointer to the json object.
3282 * @retval TSS2_RC_SUCCESS if the function call was a success.
3283 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3284 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECDSA.
3285 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3286 */
3287 TSS2_RC
ifapi_json_TPMS_SIGNATURE_ECDSA_serialize(const TPMS_SIGNATURE_ECDSA * in,json_object ** jso)3288 ifapi_json_TPMS_SIGNATURE_ECDSA_serialize(const TPMS_SIGNATURE_ECDSA *in, json_object **jso)
3289 {
3290 return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso);
3291 }
3292
3293 /** Serialize a TPMS_SIGNATURE_ECDAA to json.
3294 *
3295 * @param[in] in value of type TPMS_SIGNATURE_ECDAA to be serialized.
3296 * @param[out] jso pointer to the json object.
3297 * @retval TSS2_RC_SUCCESS if the function call was a success.
3298 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3299 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECDAA.
3300 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3301 */
3302 TSS2_RC
ifapi_json_TPMS_SIGNATURE_ECDAA_serialize(const TPMS_SIGNATURE_ECDAA * in,json_object ** jso)3303 ifapi_json_TPMS_SIGNATURE_ECDAA_serialize(const TPMS_SIGNATURE_ECDAA *in, json_object **jso)
3304 {
3305 return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso);
3306 }
3307
3308 /** Serialize a TPMS_SIGNATURE_SM2 to json.
3309 *
3310 * @param[in] in value of type TPMS_SIGNATURE_SM2 to be serialized.
3311 * @param[out] jso pointer to the json object.
3312 * @retval TSS2_RC_SUCCESS if the function call was a success.
3313 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3314 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_SM2.
3315 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3316 */
3317 TSS2_RC
ifapi_json_TPMS_SIGNATURE_SM2_serialize(const TPMS_SIGNATURE_SM2 * in,json_object ** jso)3318 ifapi_json_TPMS_SIGNATURE_SM2_serialize(const TPMS_SIGNATURE_SM2 *in, json_object **jso)
3319 {
3320 return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso);
3321 }
3322
3323 /** Serialize a TPMS_SIGNATURE_ECSCHNORR to json.
3324 *
3325 * @param[in] in value of type TPMS_SIGNATURE_ECSCHNORR to be serialized.
3326 * @param[out] jso pointer to the json object.
3327 * @retval TSS2_RC_SUCCESS if the function call was a success.
3328 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3329 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_SIGNATURE_ECSCHNORR.
3330 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3331 */
3332 TSS2_RC
ifapi_json_TPMS_SIGNATURE_ECSCHNORR_serialize(const TPMS_SIGNATURE_ECSCHNORR * in,json_object ** jso)3333 ifapi_json_TPMS_SIGNATURE_ECSCHNORR_serialize(const TPMS_SIGNATURE_ECSCHNORR *in, json_object **jso)
3334 {
3335 return ifapi_json_TPMS_SIGNATURE_ECC_serialize(in, jso);
3336 }
3337
3338 /** Serialize a TPMU_SIGNATURE to json.
3339 *
3340 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
3341 * @param[in] in the value to be serialized.
3342 * @param[in] selector the type of the signature.
3343 * @param[out] jso pointer to the json object.
3344 * @retval TSS2_RC_SUCCESS if the function call was a success.
3345 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3346 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_SIGNATURE.
3347 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3348 */
3349 TSS2_RC
ifapi_json_TPMU_SIGNATURE_serialize(const TPMU_SIGNATURE * in,UINT32 selector,json_object ** jso)3350 ifapi_json_TPMU_SIGNATURE_serialize(const TPMU_SIGNATURE *in, UINT32 selector, json_object **jso)
3351 {
3352 switch (selector) {
3353 case TPM2_ALG_RSASSA:
3354 return ifapi_json_TPMS_SIGNATURE_RSASSA_serialize(&in->rsassa, jso);
3355 case TPM2_ALG_RSAPSS:
3356 return ifapi_json_TPMS_SIGNATURE_RSAPSS_serialize(&in->rsapss, jso);
3357 case TPM2_ALG_ECDSA:
3358 return ifapi_json_TPMS_SIGNATURE_ECDSA_serialize(&in->ecdsa, jso);
3359 case TPM2_ALG_ECDAA:
3360 return ifapi_json_TPMS_SIGNATURE_ECDAA_serialize(&in->ecdaa, jso);
3361 case TPM2_ALG_SM2:
3362 return ifapi_json_TPMS_SIGNATURE_SM2_serialize(&in->sm2, jso);
3363 case TPM2_ALG_ECSCHNORR:
3364 return ifapi_json_TPMS_SIGNATURE_ECSCHNORR_serialize(&in->ecschnorr, jso);
3365 case TPM2_ALG_HMAC:
3366 return ifapi_json_TPMT_HA_serialize(&in->hmac, jso);
3367 default:
3368 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
3369 return TSS2_FAPI_RC_BAD_VALUE;
3370 };
3371 return TSS2_RC_SUCCESS;
3372 }
3373
3374 /** Serialize value of type TPMT_SIGNATURE to json.
3375 *
3376 * @param[in] in value to be serialized.
3377 * @param[out] jso pointer to the json object.
3378 * @retval TSS2_RC_SUCCESS if the function call was a success.
3379 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3380 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_SIGNATURE.
3381 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3382 */
3383 TSS2_RC
ifapi_json_TPMT_SIGNATURE_serialize(const TPMT_SIGNATURE * in,json_object ** jso)3384 ifapi_json_TPMT_SIGNATURE_serialize(const TPMT_SIGNATURE *in, json_object **jso)
3385 {
3386 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3387
3388 TSS2_RC r;
3389 json_object *jso2;
3390 if (*jso == NULL)
3391 *jso = json_object_new_object ();
3392 jso2 = NULL;
3393 r = ifapi_json_TPMI_ALG_SIG_SCHEME_serialize(in->sigAlg, &jso2);
3394 return_if_error(r, "Serialize TPMI_ALG_SIG_SCHEME");
3395
3396 json_object_object_add(*jso, "sigAlg", jso2);
3397 if (in->sigAlg != TPM2_ALG_NULL) {
3398 json_object *jso2 = NULL;
3399 r = ifapi_json_TPMU_SIGNATURE_serialize(&in->signature, in->sigAlg, &jso2);
3400 return_if_error(r,"Serialize TPMU_SIGNATURE");
3401
3402 json_object_object_add(*jso, "signature", jso2);
3403 }
3404 return TSS2_RC_SUCCESS;
3405 }
3406
3407 /** Serialize value of type TPM2B_ENCRYPTED_SECRET to json.
3408 *
3409 * @param[in] in value to be serialized.
3410 * @param[out] jso pointer to the json object.
3411 * @retval TSS2_RC_SUCCESS if the function call was a success.
3412 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3413 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_ENCRYPTED_SECRET.
3414 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3415 */
3416 TSS2_RC
ifapi_json_TPM2B_ENCRYPTED_SECRET_serialize(const TPM2B_ENCRYPTED_SECRET * in,json_object ** jso)3417 ifapi_json_TPM2B_ENCRYPTED_SECRET_serialize(const TPM2B_ENCRYPTED_SECRET *in, json_object **jso)
3418 {
3419 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3420
3421 if (in->size > sizeof(TPMU_ENCRYPTED_SECRET)) {
3422 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(TPMU_ENCRYPTED_SECRET))",
3423 (size_t)in->size, (size_t)sizeof(TPMU_ENCRYPTED_SECRET));
3424 return TSS2_FAPI_RC_BAD_VALUE;
3425 }
3426 char hex_string[((size_t)in->size)*2+1];
3427
3428 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
3429 sprintf(&hex_string[off], "%02x", in->secret[i]);
3430 hex_string[(in->size)*2] = '\0';
3431 *jso = json_object_new_string (hex_string);
3432 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3433
3434 return TSS2_RC_SUCCESS;
3435 }
3436
3437 /** Serialize TPMI_ALG_PUBLIC to json.
3438 *
3439 * @param[in] in variable to be serialized.
3440 * @param[out] jso pointer to the json object.
3441 * @retval TSS2_FAPI_RC_BAD_VALUE if an invalid value was passed into
3442 * the function.
3443 * @retval TSS2_FAPI_RC_MEMORY if not enough memory can be allocated.
3444 */
3445 TSS2_RC
ifapi_json_TPMI_ALG_PUBLIC_serialize(const TPMI_ALG_PUBLIC in,json_object ** jso)3446 ifapi_json_TPMI_ALG_PUBLIC_serialize(const TPMI_ALG_PUBLIC in, json_object **jso)
3447 {
3448 CHECK_IN_LIST(TPMI_ALG_PUBLIC, in, TPM2_ALG_RSA, TPM2_ALG_KEYEDHASH,
3449 TPM2_ALG_ECC, TPM2_ALG_SYMCIPHER, TPM2_ALG_NULL);
3450 return ifapi_json_TPM2_ALG_ID_serialize(in, jso);
3451 }
3452
3453 /** Serialize a TPMU_PUBLIC_ID to json.
3454 *
3455 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
3456 * @param[in] in the value to be serialized.
3457 * @param[in] selector the type of the public ID.
3458 * @param[out] jso pointer to the json object.
3459 * @retval TSS2_RC_SUCCESS if the function call was a success.
3460 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3461 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_PUBLIC_ID.
3462 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3463 */
3464 TSS2_RC
ifapi_json_TPMU_PUBLIC_ID_serialize(const TPMU_PUBLIC_ID * in,UINT32 selector,json_object ** jso)3465 ifapi_json_TPMU_PUBLIC_ID_serialize(const TPMU_PUBLIC_ID *in, UINT32 selector, json_object **jso)
3466 {
3467 switch (selector) {
3468 case TPM2_ALG_KEYEDHASH:
3469 return ifapi_json_TPM2B_DIGEST_serialize(&in->keyedHash, jso);
3470 case TPM2_ALG_SYMCIPHER:
3471 return ifapi_json_TPM2B_DIGEST_serialize(&in->sym, jso);
3472 case TPM2_ALG_RSA:
3473 return ifapi_json_TPM2B_PUBLIC_KEY_RSA_serialize(&in->rsa, jso);
3474 case TPM2_ALG_ECC:
3475 return ifapi_json_TPMS_ECC_POINT_serialize(&in->ecc, jso);
3476 default:
3477 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
3478 return TSS2_FAPI_RC_BAD_VALUE;
3479 };
3480 return TSS2_RC_SUCCESS;
3481 }
3482
3483 /** Serialize value of type TPMS_KEYEDHASH_PARMS to json.
3484 *
3485 * @param[in] in value to be serialized.
3486 * @param[out] jso pointer to the json object.
3487 * @retval TSS2_RC_SUCCESS if the function call was a success.
3488 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3489 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_KEYEDHASH_PARMS.
3490 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3491 */
3492 TSS2_RC
ifapi_json_TPMS_KEYEDHASH_PARMS_serialize(const TPMS_KEYEDHASH_PARMS * in,json_object ** jso)3493 ifapi_json_TPMS_KEYEDHASH_PARMS_serialize(const TPMS_KEYEDHASH_PARMS *in, json_object **jso)
3494 {
3495 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3496
3497 TSS2_RC r;
3498 json_object *jso2;
3499 if (*jso == NULL)
3500 *jso = json_object_new_object ();
3501 jso2 = NULL;
3502 r = ifapi_json_TPMT_KEYEDHASH_SCHEME_serialize(&in->scheme, &jso2);
3503 return_if_error(r, "Serialize TPMT_KEYEDHASH_SCHEME");
3504
3505 json_object_object_add(*jso, "scheme", jso2);
3506 return TSS2_RC_SUCCESS;
3507 }
3508
3509 /** Serialize value of type TPMS_RSA_PARMS to json.
3510 *
3511 * @param[in] in value to be serialized.
3512 * @param[out] jso pointer to the json object.
3513 * @retval TSS2_RC_SUCCESS if the function call was a success.
3514 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3515 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_RSA_PARMS.
3516 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3517 */
3518 TSS2_RC
ifapi_json_TPMS_RSA_PARMS_serialize(const TPMS_RSA_PARMS * in,json_object ** jso)3519 ifapi_json_TPMS_RSA_PARMS_serialize(const TPMS_RSA_PARMS *in, json_object **jso)
3520 {
3521 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3522
3523 TSS2_RC r;
3524 json_object *jso2;
3525 if (*jso == NULL)
3526 *jso = json_object_new_object ();
3527 jso2 = NULL;
3528 r = ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(&in->symmetric, &jso2);
3529 return_if_error(r, "Serialize TPMT_SYM_DEF_OBJECT");
3530
3531 json_object_object_add(*jso, "symmetric", jso2);
3532 jso2 = NULL;
3533 r = ifapi_json_TPMT_RSA_SCHEME_serialize(&in->scheme, &jso2);
3534 return_if_error(r, "Serialize TPMT_RSA_SCHEME");
3535
3536 json_object_object_add(*jso, "scheme", jso2);
3537 jso2 = NULL;
3538 r = ifapi_json_TPMI_RSA_KEY_BITS_serialize(in->keyBits, &jso2);
3539 return_if_error(r, "Serialize TPMI_RSA_KEY_BITS");
3540
3541 json_object_object_add(*jso, "keyBits", jso2);
3542 jso2 = NULL;
3543 r = ifapi_json_UINT32_serialize(in->exponent, &jso2);
3544 return_if_error(r, "Serialize UINT32");
3545
3546 json_object_object_add(*jso, "exponent", jso2);
3547 return TSS2_RC_SUCCESS;
3548 }
3549
3550 /** Serialize value of type TPMS_ECC_PARMS to json.
3551 *
3552 * @param[in] in value to be serialized.
3553 * @param[out] jso pointer to the json object.
3554 * @retval TSS2_RC_SUCCESS if the function call was a success.
3555 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3556 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_ECC_PARMS.
3557 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3558 */
3559 TSS2_RC
ifapi_json_TPMS_ECC_PARMS_serialize(const TPMS_ECC_PARMS * in,json_object ** jso)3560 ifapi_json_TPMS_ECC_PARMS_serialize(const TPMS_ECC_PARMS *in, json_object **jso)
3561 {
3562 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3563
3564 TSS2_RC r;
3565 json_object *jso2;
3566 if (*jso == NULL)
3567 *jso = json_object_new_object ();
3568 jso2 = NULL;
3569 r = ifapi_json_TPMT_SYM_DEF_OBJECT_serialize(&in->symmetric, &jso2);
3570 return_if_error(r, "Serialize TPMT_SYM_DEF_OBJECT");
3571
3572 json_object_object_add(*jso, "symmetric", jso2);
3573 jso2 = NULL;
3574 r = ifapi_json_TPMT_ECC_SCHEME_serialize(&in->scheme, &jso2);
3575 return_if_error(r, "Serialize TPMT_ECC_SCHEME");
3576
3577 json_object_object_add(*jso, "scheme", jso2);
3578 jso2 = NULL;
3579 r = ifapi_json_TPMI_ECC_CURVE_serialize(in->curveID, &jso2);
3580 return_if_error(r, "Serialize TPMI_ECC_CURVE");
3581
3582 json_object_object_add(*jso, "curveID", jso2);
3583 jso2 = NULL;
3584 r = ifapi_json_TPMT_KDF_SCHEME_serialize(&in->kdf, &jso2);
3585 return_if_error(r, "Serialize TPMT_KDF_SCHEME");
3586
3587 json_object_object_add(*jso, "kdf", jso2);
3588 return TSS2_RC_SUCCESS;
3589 }
3590
3591 /** Serialize a TPMU_PUBLIC_PARMS to json.
3592 *
3593 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
3594 * @param[in] in the value to be serialized.
3595 * @param[in] selector the type of the public parameters.
3596 * @param[out] jso pointer to the json object.
3597 * @retval TSS2_RC_SUCCESS if the function call was a success.
3598 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3599 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMU_PUBLIC_PARMS.
3600 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3601 */
3602 TSS2_RC
ifapi_json_TPMU_PUBLIC_PARMS_serialize(const TPMU_PUBLIC_PARMS * in,UINT32 selector,json_object ** jso)3603 ifapi_json_TPMU_PUBLIC_PARMS_serialize(const TPMU_PUBLIC_PARMS *in, UINT32 selector, json_object **jso)
3604 {
3605 switch (selector) {
3606 case TPM2_ALG_KEYEDHASH:
3607 return ifapi_json_TPMS_KEYEDHASH_PARMS_serialize(&in->keyedHashDetail, jso);
3608 case TPM2_ALG_SYMCIPHER:
3609 return ifapi_json_TPMS_SYMCIPHER_PARMS_serialize(&in->symDetail, jso);
3610 case TPM2_ALG_RSA:
3611 return ifapi_json_TPMS_RSA_PARMS_serialize(&in->rsaDetail, jso);
3612 case TPM2_ALG_ECC:
3613 return ifapi_json_TPMS_ECC_PARMS_serialize(&in->eccDetail, jso);
3614 default:
3615 LOG_ERROR("\nSelector %"PRIx32 " did not match", selector);
3616 return TSS2_FAPI_RC_BAD_VALUE;
3617 };
3618 return TSS2_RC_SUCCESS;
3619 }
3620
3621 /** Serialize value of type TPMT_PUBLIC to json.
3622 *
3623 * @param[in] in value to be serialized.
3624 * @param[out] jso pointer to the json object.
3625 * @retval TSS2_RC_SUCCESS if the function call was a success.
3626 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3627 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMT_PUBLIC.
3628 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3629 */
3630 TSS2_RC
ifapi_json_TPMT_PUBLIC_serialize(const TPMT_PUBLIC * in,json_object ** jso)3631 ifapi_json_TPMT_PUBLIC_serialize(const TPMT_PUBLIC *in, json_object **jso)
3632 {
3633 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3634
3635 TSS2_RC r;
3636 json_object *jso2;
3637 if (*jso == NULL)
3638 *jso = json_object_new_object ();
3639 jso2 = NULL;
3640 r = ifapi_json_TPMI_ALG_PUBLIC_serialize(in->type, &jso2);
3641 return_if_error(r, "Serialize TPMI_ALG_PUBLIC");
3642
3643 json_object_object_add(*jso, "type", jso2);
3644 jso2 = NULL;
3645 r = ifapi_json_TPMI_ALG_HASH_serialize(in->nameAlg, &jso2);
3646 return_if_error(r, "Serialize TPMI_ALG_HASH");
3647
3648 json_object_object_add(*jso, "nameAlg", jso2);
3649 jso2 = NULL;
3650 r = ifapi_json_TPMA_OBJECT_serialize(in->objectAttributes, &jso2);
3651 return_if_error(r, "Serialize TPMA_OBJECT");
3652
3653 json_object_object_add(*jso, "objectAttributes", jso2);
3654 jso2 = NULL;
3655 r = ifapi_json_TPM2B_DIGEST_serialize(&in->authPolicy, &jso2);
3656 return_if_error(r, "Serialize TPM2B_DIGEST");
3657
3658 json_object_object_add(*jso, "authPolicy", jso2);
3659 jso2 = NULL;
3660 r = ifapi_json_TPMU_PUBLIC_PARMS_serialize(&in->parameters, in->type, &jso2);
3661 return_if_error(r,"Serialize TPMU_PUBLIC_PARMS");
3662
3663 json_object_object_add(*jso, "parameters", jso2);
3664 jso2 = NULL;
3665 r = ifapi_json_TPMU_PUBLIC_ID_serialize(&in->unique, in->type, &jso2);
3666 return_if_error(r,"Serialize TPMU_PUBLIC_ID");
3667
3668 json_object_object_add(*jso, "unique", jso2);
3669 return TSS2_RC_SUCCESS;
3670 }
3671
3672 /** Serialize a TPM2B_PUBLIC to json.
3673 *
3674 * @param[in] in value to be serialized.
3675 * @param[out] jso pointer to the json object.
3676 * @retval TSS2_RC_SUCCESS if the function call was a success.
3677 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3678 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_PUBLIC.
3679 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3680 */
3681 TSS2_RC
ifapi_json_TPM2B_PUBLIC_serialize(const TPM2B_PUBLIC * in,json_object ** jso)3682 ifapi_json_TPM2B_PUBLIC_serialize(const TPM2B_PUBLIC *in, json_object **jso)
3683 {
3684 if (*jso == NULL)
3685 *jso = json_object_new_object ();
3686 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3687
3688 json_object *jso2;
3689
3690 jso2 = NULL;
3691 if (ifapi_json_UINT16_serialize(in->size, &jso2))
3692 return TSS2_FAPI_RC_BAD_VALUE;
3693
3694 json_object_object_add(*jso, "size", jso2);
3695
3696 jso2 = NULL;
3697 if (ifapi_json_TPMT_PUBLIC_serialize(&in->publicArea, &jso2))
3698 return TSS2_FAPI_RC_BAD_VALUE;
3699
3700 json_object_object_add(*jso, "publicArea", jso2);
3701
3702 return TSS2_RC_SUCCESS;
3703 }
3704
3705 /** Serialize value of type TPM2B_PRIVATE to json.
3706 *
3707 * @param[in] in value to be serialized.
3708 * @param[out] jso pointer to the json object.
3709 * @retval TSS2_RC_SUCCESS if the function call was a success.
3710 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3711 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_PRIVATE.
3712 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3713 */
3714 TSS2_RC
ifapi_json_TPM2B_PRIVATE_serialize(const TPM2B_PRIVATE * in,json_object ** jso)3715 ifapi_json_TPM2B_PRIVATE_serialize(const TPM2B_PRIVATE *in, json_object **jso)
3716 {
3717 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3718
3719 if (in->size > sizeof(_PRIVATE)) {
3720 LOG_ERROR("Too many bytes for array (%"PRIuPTR" > %"PRIuPTR" = sizeof(_PRIVATE))",
3721 (size_t)in->size, (size_t)sizeof(_PRIVATE));
3722 return TSS2_FAPI_RC_BAD_VALUE;
3723 }
3724 char hex_string[((size_t)in->size)*2+1];
3725
3726 for (size_t i = 0, off = 0; i < in->size; i++, off+=2)
3727 sprintf(&hex_string[off], "%02x", in->buffer[i]);
3728 hex_string[(in->size)*2] = '\0';
3729 *jso = json_object_new_string (hex_string);
3730 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3731
3732 return TSS2_RC_SUCCESS;
3733 }
3734
3735 /** Serialize TPM2_NT to json.
3736 *
3737 * @param[in] in constant to be serialized.
3738 * @param[out] jso pointer to the json object.
3739 * @retval TSS2_RC_SUCCESS if the function call was a success.
3740 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3741 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPM2_NT.
3742 */
3743 TSS2_RC
ifapi_json_TPM2_NT_serialize(const TPM2_NT in,json_object ** jso)3744 ifapi_json_TPM2_NT_serialize(const TPM2_NT in, json_object **jso)
3745 {
3746 static const struct { TPM2_NT in; char *name; } tab[] = {
3747 { TPM2_NT_ORDINARY, "ORDINARY" },
3748 { TPM2_NT_COUNTER, "COUNTER" },
3749 { TPM2_NT_BITS, "BITS" },
3750 { TPM2_NT_EXTEND, "EXTEND" },
3751 { TPM2_NT_PIN_FAIL, "PIN_FAIL" },
3752 { TPM2_NT_PIN_PASS, "PIN_PASS" },
3753 };
3754
3755 for (size_t i = 0; i < sizeof(tab) / sizeof(tab[0]); i++) {
3756 if (tab[i].in == in) {
3757 *jso = json_object_new_string(tab[i].name);
3758 check_oom(*jso);
3759 return TSS2_RC_SUCCESS;
3760 }
3761 }
3762 return_error(TSS2_FAPI_RC_BAD_VALUE, "Undefined constant.");
3763 }
3764
3765 /** Serialize a TPMA_NV to json.
3766 *
3767 * This function expects the Bitfield to be encoded as unsigned int in host-endianess.
3768 *
3769 * @param[in] in value to be serialized.
3770 * @param[out] jso pointer to the json object.
3771 * @retval TSS2_RC_SUCCESS if the function call was a success.
3772 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3773 * @retval TSS2_FAPI_RC_BAD_VALUE if the constant is not of type TPMA_NV.
3774 */
3775 TSS2_RC
ifapi_json_TPMA_NV_serialize(const TPMA_NV in,json_object ** jso)3776 ifapi_json_TPMA_NV_serialize(const TPMA_NV in, json_object **jso)
3777 {
3778 struct { TPMA_NV in; char *name; } tab[] = {
3779 { TPMA_NV_PPWRITE, "PPWRITE" },
3780 { TPMA_NV_OWNERWRITE, "OWNERWRITE" },
3781 { TPMA_NV_AUTHWRITE, "AUTHWRITE" },
3782 { TPMA_NV_POLICYWRITE, "POLICYWRITE" },
3783 { TPMA_NV_POLICY_DELETE, "POLICY_DELETE" },
3784 { TPMA_NV_WRITELOCKED, "WRITELOCKED" },
3785 { TPMA_NV_WRITEALL, "WRITEALL" },
3786 { TPMA_NV_WRITEDEFINE, "WRITEDEFINE" },
3787 { TPMA_NV_WRITE_STCLEAR, "WRITE_STCLEAR" },
3788 { TPMA_NV_GLOBALLOCK, "GLOBALLOCK" },
3789 { TPMA_NV_PPREAD, "PPREAD" },
3790 { TPMA_NV_OWNERREAD, "OWNERREAD" },
3791 { TPMA_NV_AUTHREAD, "AUTHREAD" },
3792 { TPMA_NV_POLICYREAD, "POLICYREAD" },
3793 { TPMA_NV_NO_DA, "NO_DA" },
3794 { TPMA_NV_ORDERLY, "ORDERLY" },
3795 { TPMA_NV_CLEAR_STCLEAR, "CLEAR_STCLEAR" },
3796 { TPMA_NV_READLOCKED, "READLOCKED" },
3797 { TPMA_NV_WRITTEN, "WRITTEN" },
3798 { TPMA_NV_PLATFORMCREATE, "PLATFORMCREATE" },
3799 { TPMA_NV_READ_STCLEAR, "READ_STCLEAR" },
3800 };
3801
3802 UINT32 input;
3803 input = (UINT32) in;
3804 json_object *jso_bit;
3805 if (*jso == NULL) {
3806 *jso = json_object_new_object();
3807 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3808 }
3809 size_t n = sizeof(tab) / sizeof(tab[0]);
3810 size_t i;
3811 for (i = 0; i < n; i++) {
3812 if (tab[i].in & input)
3813 jso_bit = json_object_new_int(1);
3814 else
3815 jso_bit = json_object_new_int(0);
3816 return_if_null(jso_bit, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3817
3818 json_object_object_add(*jso, tab[i].name, jso_bit);
3819 }
3820 TPM2_NT input2 = (TPMA_NV_TPM2_NT_MASK & input)>>4;
3821 json_object *jso2 = NULL;
3822 TSS2_RC r = ifapi_json_TPM2_NT_serialize(input2, &jso2);
3823 return_if_error(r, "Bad value");
3824
3825 json_object_object_add(*jso, "TPM2_NT", jso2);
3826
3827 return TSS2_RC_SUCCESS;
3828 }
3829
3830 /** Serialize value of type TPMS_NV_PUBLIC to json.
3831 *
3832 * @param[in] in value to be serialized.
3833 * @param[out] jso pointer to the json object.
3834 * @retval TSS2_RC_SUCCESS if the function call was a success.
3835 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3836 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_NV_PUBLIC.
3837 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3838 */
3839 TSS2_RC
ifapi_json_TPMS_NV_PUBLIC_serialize(const TPMS_NV_PUBLIC * in,json_object ** jso)3840 ifapi_json_TPMS_NV_PUBLIC_serialize(const TPMS_NV_PUBLIC *in, json_object **jso)
3841 {
3842 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3843
3844 TSS2_RC r;
3845 json_object *jso2;
3846 if (*jso == NULL)
3847 *jso = json_object_new_object ();
3848 jso2 = NULL;
3849 r = ifapi_json_TPMI_RH_NV_INDEX_serialize(in->nvIndex, &jso2);
3850 return_if_error(r, "Serialize TPMI_RH_NV_INDEX");
3851
3852 json_object_object_add(*jso, "nvIndex", jso2);
3853 jso2 = NULL;
3854 r = ifapi_json_TPMI_ALG_HASH_serialize(in->nameAlg, &jso2);
3855 return_if_error(r, "Serialize TPMI_ALG_HASH");
3856
3857 json_object_object_add(*jso, "nameAlg", jso2);
3858 jso2 = NULL;
3859 r = ifapi_json_TPMA_NV_serialize(in->attributes, &jso2);
3860 return_if_error(r, "Serialize TPMA_NV");
3861
3862 json_object_object_add(*jso, "attributes", jso2);
3863 jso2 = NULL;
3864 r = ifapi_json_TPM2B_DIGEST_serialize(&in->authPolicy, &jso2);
3865 return_if_error(r, "Serialize TPM2B_DIGEST");
3866
3867 json_object_object_add(*jso, "authPolicy", jso2);
3868 jso2 = NULL;
3869 r = ifapi_json_UINT16_serialize(in->dataSize, &jso2);
3870 return_if_error(r, "Serialize UINT16");
3871
3872 json_object_object_add(*jso, "dataSize", jso2);
3873 return TSS2_RC_SUCCESS;
3874 }
3875
3876 /** Serialize a TPM2B_NV_PUBLIC to json.
3877 *
3878 * @param[in] in value to be serialized.
3879 * @param[out] jso pointer to the json object.
3880 * @retval TSS2_RC_SUCCESS if the function call was a success.
3881 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3882 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_NV_PUBLIC.
3883 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3884 */
3885 TSS2_RC
ifapi_json_TPM2B_NV_PUBLIC_serialize(const TPM2B_NV_PUBLIC * in,json_object ** jso)3886 ifapi_json_TPM2B_NV_PUBLIC_serialize(const TPM2B_NV_PUBLIC *in, json_object **jso)
3887 {
3888 if (*jso == NULL)
3889 *jso = json_object_new_object ();
3890 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3891
3892 json_object *jso2;
3893
3894 jso2 = NULL;
3895 if (ifapi_json_UINT16_serialize(in->size, &jso2))
3896 return TSS2_FAPI_RC_BAD_VALUE;
3897
3898 json_object_object_add(*jso, "size", jso2);
3899
3900 jso2 = NULL;
3901 if (ifapi_json_TPMS_NV_PUBLIC_serialize(&in->nvPublic, &jso2))
3902 return TSS2_FAPI_RC_BAD_VALUE;
3903
3904 json_object_object_add(*jso, "nvPublic", jso2);
3905
3906 return TSS2_RC_SUCCESS;
3907 }
3908
3909 /** Serialize value of type TPMS_CREATION_DATA to json.
3910 *
3911 * @param[in] in value to be serialized.
3912 * @param[out] jso pointer to the json object.
3913 * @retval TSS2_RC_SUCCESS if the function call was a success.
3914 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3915 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPMS_CREATION_DATA.
3916 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3917 */
3918 TSS2_RC
ifapi_json_TPMS_CREATION_DATA_serialize(const TPMS_CREATION_DATA * in,json_object ** jso)3919 ifapi_json_TPMS_CREATION_DATA_serialize(const TPMS_CREATION_DATA *in, json_object **jso)
3920 {
3921 return_if_null(in, "Bad reference.", TSS2_FAPI_RC_BAD_REFERENCE);
3922
3923 TSS2_RC r;
3924 json_object *jso2;
3925 if (*jso == NULL)
3926 *jso = json_object_new_object ();
3927 jso2 = NULL;
3928 r = ifapi_json_TPML_PCR_SELECTION_serialize(&in->pcrSelect, &jso2);
3929 return_if_error(r, "Serialize TPML_PCR_SELECTION");
3930
3931 json_object_object_add(*jso, "pcrSelect", jso2);
3932 jso2 = NULL;
3933 r = ifapi_json_TPM2B_DIGEST_serialize(&in->pcrDigest, &jso2);
3934 return_if_error(r, "Serialize TPM2B_DIGEST");
3935
3936 json_object_object_add(*jso, "pcrDigest", jso2);
3937 jso2 = NULL;
3938 r = ifapi_json_TPMA_LOCALITY_serialize(in->locality, &jso2);
3939 return_if_error(r, "Serialize TPMA_LOCALITY");
3940
3941 json_object_object_add(*jso, "locality", jso2);
3942 jso2 = NULL;
3943 r = ifapi_json_TPM2_ALG_ID_serialize(in->parentNameAlg, &jso2);
3944 return_if_error(r, "Serialize TPM2_ALG_ID");
3945
3946 json_object_object_add(*jso, "parentNameAlg", jso2);
3947 jso2 = NULL;
3948 r = ifapi_json_TPM2B_NAME_serialize(&in->parentName, &jso2);
3949 return_if_error(r, "Serialize TPM2B_NAME");
3950
3951 json_object_object_add(*jso, "parentName", jso2);
3952 jso2 = NULL;
3953 r = ifapi_json_TPM2B_NAME_serialize(&in->parentQualifiedName, &jso2);
3954 return_if_error(r, "Serialize TPM2B_NAME");
3955
3956 json_object_object_add(*jso, "parentQualifiedName", jso2);
3957 jso2 = NULL;
3958 r = ifapi_json_TPM2B_DATA_serialize(&in->outsideInfo, &jso2);
3959 return_if_error(r, "Serialize TPM2B_DATA");
3960
3961 json_object_object_add(*jso, "outsideInfo", jso2);
3962 return TSS2_RC_SUCCESS;
3963 }
3964
3965 /** Serialize a TPM2B_CREATION_DATA to json.
3966 *
3967 * @param[in] in value to be serialized.
3968 * @param[out] jso pointer to the json object.
3969 * @retval TSS2_RC_SUCCESS if the function call was a success.
3970 * @retval TSS2_FAPI_RC_MEMORY: if the FAPI cannot allocate enough memory.
3971 * @retval TSS2_FAPI_RC_BAD_VALUE if the value is not of type TPM2B_CREATION_DATA.
3972 * @retval TSS2_FAPI_RC_BAD_REFERENCE a invalid null pointer is passed.
3973 */
3974 TSS2_RC
ifapi_json_TPM2B_CREATION_DATA_serialize(const TPM2B_CREATION_DATA * in,json_object ** jso)3975 ifapi_json_TPM2B_CREATION_DATA_serialize(const TPM2B_CREATION_DATA *in, json_object **jso)
3976 {
3977 if (*jso == NULL)
3978 *jso = json_object_new_object ();
3979 return_if_null(*jso, "Out of memory.", TSS2_FAPI_RC_MEMORY);
3980
3981 json_object *jso2;
3982
3983 jso2 = NULL;
3984 if (ifapi_json_UINT16_serialize(in->size, &jso2))
3985 return TSS2_FAPI_RC_BAD_VALUE;
3986
3987 json_object_object_add(*jso, "size", jso2);
3988
3989 jso2 = NULL;
3990 if (ifapi_json_TPMS_CREATION_DATA_serialize(&in->creationData, &jso2))
3991 return TSS2_FAPI_RC_BAD_VALUE;
3992
3993 json_object_object_add(*jso, "creationData", jso2);
3994
3995 return TSS2_RC_SUCCESS;
3996 }
3997