[proxmark3-svn] / client / fido / cbortools.c

//-----------------------------------------------------------------------------
// Copyright (C) 2018 Merlok
//
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Tools for work with CBOR format http://cbor.io/spec.html
// via Intel tinycbor (https://github.com/intel/tinycbor) library
//-----------------------------------------------------------------------------
//

#include "cbortools.h"
#include <stdlib.h>
#include "emv/emvjson.h"
#include "util.h"
#include "fidocore.h"

static void indent(int nestingLevel) {
	while (nestingLevel--)
		printf("  ");
}

static CborError dumpelm(CborValue *it, bool *got_next, int nestingLevel) {
	CborError err;
	*got_next = false;

	CborType type = cbor_value_get_type(it);
	indent(nestingLevel);
	switch (type) {
	case CborMapType: 
	case CborArrayType: {
		printf(type == CborArrayType ? "Array[" : "Map[");
		break;
	}

	case CborIntegerType: {
		int64_t val;
		cbor_value_get_int64(it, &val);     // can't fail
		printf("%lld", (long long)val);
		break;
	}

	case CborByteStringType: {
		uint8_t *buf;
		size_t n;
		err = cbor_value_dup_byte_string(it, &buf, &n, it);
		*got_next = true;
		if (err)
			return err;     // parse error
		printf("%s", sprint_hex(buf, n));
		free(buf);
		break;
	}

	case CborTextStringType: {
		char *buf;
		size_t n;
		err = cbor_value_dup_text_string(it, &buf, &n, it);
		*got_next = true;
		if (err)
			return err;     // parse error
		printf("%s", buf);
		free(buf);
		break;
	}

	case CborTagType: {
		CborTag tag;
		cbor_value_get_tag(it, &tag);     
		printf("Tag(%lld)", (long long)tag);
		break;
	}

	case CborSimpleType: {
		uint8_t type;
		cbor_value_get_simple_type(it, &type); 
		printf("simple(%u)", type);
		break;
	}

	case CborNullType:
		printf("null");
		break;

	case CborUndefinedType:
		printf("undefined");
		break;

	case CborBooleanType: {
		bool val;
		cbor_value_get_boolean(it, &val);       // can't fail
		printf("%s", val ? "true" : "false");
		break;
	}

	case CborDoubleType: {
		double val;
		if (false) {
			float f;
	case CborFloatType:
			cbor_value_get_float(it, &f);
			val = f;
		} else {
			cbor_value_get_double(it, &val);
		}
		printf("%g", val);
		break;
	}
	case CborHalfFloatType: {
		uint16_t val;
		cbor_value_get_half_float(it, &val);
		printf("__f16(%04x)", val);
		break;
	}

	case CborInvalidType:
		printf("CborInvalidType!!!");
		break;
	}
	
	return CborNoError;
}

static CborError dumprecursive(uint8_t cmdCode, bool isResponse, CborValue *it, bool isMapType, int nestingLevel) {
	int elmCount = 0;
	while (!cbor_value_at_end(it)) {
		CborError err;
		CborType type = cbor_value_get_type(it);
//printf("^%x^", type);
		bool got_next;

		switch (type) {
		case CborMapType: 
		case CborArrayType: {
			// recursive type
			CborValue recursed;
			assert(cbor_value_is_container(it));
			if (!(isMapType && (elmCount % 2)))
				indent(nestingLevel);
			printf(type == CborArrayType ? "Array[\n" : "Map[\n");
			err = cbor_value_enter_container(it, &recursed);
			if (err)
				return err;       // parse error
			err = dumprecursive(cmdCode, isResponse, &recursed, (type == CborMapType), nestingLevel + 1);
			if (err)
				return err;       // parse error
			err = cbor_value_leave_container(it, &recursed);
			if (err)
				return err;       // parse error
			indent(nestingLevel);
			printf("]");
			got_next = true;
			break;
		}

		default: {
			err = dumpelm(it, &got_next, (isMapType && (elmCount % 2)) ? 0 : nestingLevel);
			if (err)
				return err;
			if (cmdCode > 0 && nestingLevel == 1 && isMapType && !(elmCount % 2)) {
				int64_t val;
				cbor_value_get_int64(it, &val);
				char *desc = fido2GetCmdMemberDescription(cmdCode, isResponse, val);
				if (desc)
					printf(" (%s)", desc);
			}
			break;
		}
		}

		if (!got_next) {
			err = cbor_value_advance_fixed(it);
			if (err)
				return err;
		}
		if (isMapType && !(elmCount % 2)) {
			printf(": ");
		} else {
			printf("\n");
		}
		elmCount++;
	}
	return CborNoError;
}

int TinyCborInit(uint8_t *data, size_t length, CborValue *cb) {
	CborParser parser;
	CborError err = cbor_parser_init(data, length, 0, &parser, cb);
    if (err)
		return err;
	
	return 0;
}

int TinyCborPrintFIDOPackage(uint8_t cmdCode, bool isResponse, uint8_t *data, size_t length) {
	CborValue cb;
	int res;
	res = TinyCborInit(data, length, &cb);
	if (res)
		return res;
		
    CborError err = dumprecursive(cmdCode, isResponse, &cb, false, 0);

	if (err) {
		fprintf(stderr,
#if __WORDSIZE == 64		
		"CBOR parsing failure at offset %" PRId64 " : %s\n",
#else
		"CBOR parsing failure at offset %" PRId32 " : %s\n",	
#endif
		cb.ptr - data, cbor_error_string(err));
		return 1;
	}	
	
	return 0;
}

int JsonObjElmCount(json_t *elm) {
	int res = 0;
	const char *key;
	json_t *value;
	
	if (!json_is_object(elm))
		return 0;
	
	json_object_foreach(elm, key, value) {
		if (strlen(key) > 0 && key[0] != '.')
			res++;		
	}
	
	return res;
}

int JsonToCbor(json_t *elm, CborEncoder *encoder) {
	if (!elm || !encoder)
		return 1;

	int res;
	
	// CBOR map == JSON object
	if (json_is_object(elm)) {
		CborEncoder map;
		const char *key;
		json_t *value;

		res = cbor_encoder_create_map(encoder, &map, JsonObjElmCount(elm));
		cbor_check(res);
		
		json_object_foreach(elm, key, value) {
			if (strlen(key) > 0 && key[0] != '.') {
				res = cbor_encode_text_stringz(&map, key);		
				cbor_check(res);
				
				// RECURSION!
				JsonToCbor(value, &map);
			}
		}
		
		res = cbor_encoder_close_container(encoder, &map);
		cbor_check(res);
	}

	// CBOR array == JSON array
	if (json_is_array(elm)) {
		size_t index;
		json_t *value;
		CborEncoder array;
		
		res = cbor_encoder_create_array(encoder, &array, json_array_size(elm));
		cbor_check(res);
		
		json_array_foreach(elm, index, value) {
			// RECURSION!
			JsonToCbor(value, &array);
		}
		
		res = cbor_encoder_close_container(encoder, &array);
		cbor_check(res);
	}

	if (json_is_boolean(elm)) {
		res = cbor_encode_boolean(encoder, json_is_true(elm));
		cbor_check(res);
	}

	if (json_is_integer(elm)) {
		res = cbor_encode_int(encoder, json_integer_value(elm));
		cbor_check(res);
	}

	if (json_is_real(elm)) {
		res = cbor_encode_float(encoder, json_real_value(elm));
		cbor_check(res);
	}

	if (json_is_string(elm)) {
		const char * val = json_string_value(elm);
		if (CheckStringIsHEXValue(val)) {
			size_t datalen = 0;
			uint8_t data[4096] = {0};
			res = JsonLoadBufAsHex(elm, "$", data, sizeof(data), &datalen);
			if (res)
				return 100;

			res = cbor_encode_byte_string(encoder, data, datalen);
			cbor_check(res);			
		} else {
			res = cbor_encode_text_stringz(encoder, val);
			cbor_check(res);
		}
	}
	
	
	
	return 0;
}

int CborMapGetKeyById(CborParser *parser, CborValue *map, uint8_t *data, size_t dataLen, int key) {
	CborValue cb;

	CborError err = cbor_parser_init(data, dataLen, 0, parser, &cb);
	cbor_check(err);

	if (cbor_value_get_type(&cb) != CborMapType)
		return 1;
		
	err = cbor_value_enter_container(&cb, map);
	cbor_check(err);

	int64_t indx;
	while (!cbor_value_at_end(map)) {
		// check number
		if (cbor_value_get_type(map) != CborIntegerType)
			return 1;

		cbor_value_get_int64(map, &indx);
		
		err = cbor_value_advance(map);
		cbor_check(err);
		
		if (indx == key)
			return 0;

		// pass value
		err = cbor_value_advance(map);
		cbor_check(err);
	}

	err = cbor_value_leave_container(&cb, map);
	cbor_check(err);

	return 2;
}

CborError CborGetArrayBinStringValue(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen) {
	return CborGetArrayBinStringValueEx(elm, data, maxdatalen, datalen, NULL, 0);
}

CborError CborGetArrayBinStringValueEx(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen, uint8_t *delimeter, size_t delimeterlen) {
	CborValue array;
	if (datalen)
		*datalen = 0;
	
	size_t slen = maxdatalen;
	size_t totallen = 0;

	CborError res = cbor_value_enter_container(elm, &array);
	cbor_check(res);
	
	while (!cbor_value_at_end(&array)) {
		res = cbor_value_copy_byte_string(&array, &data[totallen], &slen, &array);
		cbor_check(res);
		
		totallen += slen;
		if (delimeter) {
			memcpy(&data[totallen], delimeter, delimeterlen);
			totallen += delimeterlen;
		}
		slen = maxdatalen - totallen;
	}

	res = cbor_value_leave_container(elm, &array);
	cbor_check(res);

	if (datalen)
		*datalen = totallen;

	return CborNoError;	
};

CborError CborGetBinStringValue(CborValue *elm, uint8_t *data, size_t maxdatalen, size_t *datalen) {
	if (datalen)
		*datalen = 0;
	
	size_t slen = maxdatalen;

	CborError res = cbor_value_copy_byte_string(elm, data, &slen, elm);
	cbor_check(res);

	if (datalen)
		*datalen = slen;

	return CborNoError;	
};

CborError CborGetArrayStringValue(CborValue *elm, char *data, size_t maxdatalen, size_t *datalen, char *delimeter) {
	CborValue array;
	if (datalen)
		*datalen = 0;
	
	size_t slen = maxdatalen;
	size_t totallen = 0;

	CborError res = cbor_value_enter_container(elm, &array);
	cbor_check(res);
	
	while (!cbor_value_at_end(&array)) {
		res = cbor_value_copy_text_string(&array, &data[totallen], &slen, &array);
		cbor_check(res);
		
		totallen += slen;
		if (delimeter) {
			strcat(data, delimeter);
			totallen += strlen(delimeter);
		}
		slen = maxdatalen - totallen;
		data[totallen] = 0x00;
	}

	res = cbor_value_leave_container(elm, &array);
	cbor_check(res);

	if (datalen)
		*datalen = totallen;

	return CborNoError;	
};

CborError CborGetStringValue(CborValue *elm, char *data, size_t maxdatalen, size_t *datalen) {
	if (datalen)
		*datalen = 0;
	
	size_t slen = maxdatalen;

	CborError res = cbor_value_copy_text_string(elm, data, &slen, elm);
	cbor_check(res);

	if (datalen)
		*datalen = slen;

	return CborNoError;	
};

CborError CborGetStringValueBuf(CborValue *elm) {
	static char stringBuf[2048];
	memset(stringBuf, 0x00, sizeof(stringBuf));
	
	return CborGetStringValue(elm, stringBuf, sizeof(stringBuf), NULL);
};

int CBOREncodeElm(json_t *root, char *rootElmId, CborEncoder *encoder) {
	json_t *elm = NULL;
	if (rootElmId && strlen(rootElmId) && rootElmId[0] == '$')
		elm = json_path_get(root, rootElmId);
	else
		elm = json_object_get(root, rootElmId);
	
	if (!elm)
		return 1;
	
	int res = JsonToCbor(elm, encoder);

	return res;
}

CborError CBOREncodeClientDataHash(json_t *root, CborEncoder *encoder) {
	uint8_t buf[100] = {0};
	size_t jlen;

	JsonLoadBufAsHex(root, "$.ClientDataHash", buf, sizeof(buf), &jlen);
	
	// fill with 0x00 if not found
	if (!jlen)
		jlen = 32;
	
	int res = cbor_encode_byte_string(encoder, buf, jlen);
	cbor_check(res);

	return 0;
}
Commit	Line	Data
0bb51450 OM	1	//-----------------------------------------------------------------------------
	2	// Copyright (C) 2018 Merlok
	3	//
	4	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	5	// at your option, any later version. See the LICENSE.txt file for the text of
	6	// the license.
	7	//-----------------------------------------------------------------------------
	8	// Tools for work with CBOR format http://cbor.io/spec.html
	9	// via Intel tinycbor (https://github.com/intel/tinycbor) library
	10	//-----------------------------------------------------------------------------
	11	//
	12
	13	#include "cbortools.h"
	14	#include <stdlib.h>
	15	#include "emv/emvjson.h"
	16	#include "util.h"
	17	#include "fidocore.h"
	18
	19	static void indent(int nestingLevel) {
	20	while (nestingLevel--)
	21	printf(" ");
	22	}
	23
	24	static CborError dumpelm(CborValue it, bool got_next, int nestingLevel) {
	25	CborError err;
	26	*got_next = false;
	27
	28	CborType type = cbor_value_get_type(it);
	29	indent(nestingLevel);
	30	switch (type) {
	31	case CborMapType:
	32	case CborArrayType: {
	33	printf(type == CborArrayType ? "Array[" : "Map[");
	34	break;
	35	}
	36
	37	case CborIntegerType: {
	38	int64_t val;
	39	cbor_value_get_int64(it, &val); // can't fail
	40	printf("%lld", (long long)val);
	41	break;
	42	}
	43
	44	case CborByteStringType: {
	45	uint8_t *buf;
	46	size_t n;
	47	err = cbor_value_dup_byte_string(it, &buf, &n, it);
	48	*got_next = true;
	49	if (err)
	50	return err; // parse error
	51	printf("%s", sprint_hex(buf, n));
	52	free(buf);
	53	break;
	54	}
	55
	56	case CborTextStringType: {
	57	char *buf;
	58	size_t n;
	59	err = cbor_value_dup_text_string(it, &buf, &n, it);
	60	*got_next = true;
	61	if (err)
	62	return err; // parse error
	63	printf("%s", buf);
	64	free(buf);
65	break;
66	}
67
68	case CborTagType: {
69	CborTag tag;
70	cbor_value_get_tag(it, &tag);
71	printf("Tag(%lld)", (long long)tag);
72	break;
73	}
74
75	case CborSimpleType: {
76	uint8_t type;
77	cbor_value_get_simple_type(it, &type);
78	printf("simple(%u)", type);
79	break;
80	}
81
82	case CborNullType:
83	printf("null");
84	break;
85
86	case CborUndefinedType:
87	printf("undefined");
88	break;
89
90	case CborBooleanType: {
91	bool val;
92	cbor_value_get_boolean(it, &val); // can't fail
93	printf("%s", val ? "true" : "false");
94	break;
95	}
96
97	case CborDoubleType: {
98	double val;
99	if (false) {
100	float f;
101	case CborFloatType:
102	cbor_value_get_float(it, &f);
103	val = f;
104	} else {
105	cbor_value_get_double(it, &val);
106	}
107	printf("%g", val);
108	break;
109	}
110	case CborHalfFloatType: {
111	uint16_t val;
112	cbor_value_get_half_float(it, &val);
113	printf("__f16(%04x)", val);
114	break;
115	}
116
117	case CborInvalidType:
118	printf("CborInvalidType!!!");
119	break;
120	}
121
122	return CborNoError;
123	}
124
125	static CborError dumprecursive(uint8_t cmdCode, bool isResponse, CborValue *it, bool isMapType, int nestingLevel) {
126	int elmCount = 0;
127	while (!cbor_value_at_end(it)) {
128	CborError err;
129	CborType type = cbor_value_get_type(it);
130	//printf("^%x^", type);
131	bool got_next;
132
133	switch (type) {
134	case CborMapType:
135	case CborArrayType: {
136	// recursive type
137	CborValue recursed;
138	assert(cbor_value_is_container(it));
139	if (!(isMapType && (elmCount % 2)))
140	indent(nestingLevel);
141	printf(type == CborArrayType ? "Array[\n" : "Map[\n");
142	err = cbor_value_enter_container(it, &recursed);
143	if (err)
144	return err; // parse error
145	err = dumprecursive(cmdCode, isResponse, &recursed, (type == CborMapType), nestingLevel + 1);
146	if (err)
147	return err; // parse error
148	err = cbor_value_leave_container(it, &recursed);
149	if (err)
150	return err; // parse error
151	indent(nestingLevel);
152	printf("]");
153	got_next = true;
154	break;
155	}
156
157	default: {
158	err = dumpelm(it, &got_next, (isMapType && (elmCount % 2)) ? 0 : nestingLevel);
159	if (err)
160	return err;
161	if (cmdCode > 0 && nestingLevel == 1 && isMapType && !(elmCount % 2)) {
162	int64_t val;
163	cbor_value_get_int64(it, &val);
164	char *desc = fido2GetCmdMemberDescription(cmdCode, isResponse, val);
165	if (desc)
166	printf(" (%s)", desc);
167	}
168	break;
169	}
170	}
171
172	if (!got_next) {
173	err = cbor_value_advance_fixed(it);
174	if (err)
175	return err;
176	}
177	if (isMapType && !(elmCount % 2)) {
178	printf(": ");
179	} else {
180	printf("\n");
181	}
182	elmCount++;
183	}
184	return CborNoError;
185	}
186
187	int TinyCborInit(uint8_t data, size_t length, CborValue cb) {
188	CborParser parser;
189	CborError err = cbor_parser_init(data, length, 0, &parser, cb);
190	if (err)
191	return err;
192
193	return 0;
194	}
195
196	int TinyCborPrintFIDOPackage(uint8_t cmdCode, bool isResponse, uint8_t *data, size_t length) {
197	CborValue cb;
198	int res;
199	res = TinyCborInit(data, length, &cb);
200	if (res)
201	return res;
202
203	CborError err = dumprecursive(cmdCode, isResponse, &cb, false, 0);
204
205	if (err) {
206	fprintf(stderr,
207	#if __WORDSIZE == 64
208	"CBOR parsing failure at offset %" PRId64 " : %s\n",
209	#else
210	"CBOR parsing failure at offset %" PRId32 " : %s\n",
211	#endif
212	cb.ptr - data, cbor_error_string(err));
213	return 1;
214	}
215
216	return 0;
217	}
218
219	int JsonObjElmCount(json_t *elm) {
220	int res = 0;
221	const char *key;
222	json_t *value;
223
224	if (!json_is_object(elm))
225	return 0;
226
227	json_object_foreach(elm, key, value) {
228	if (strlen(key) > 0 && key[0] != '.')
229	res++;
230	}
231
232	return res;
233	}
234
235	int JsonToCbor(json_t elm, CborEncoder encoder) {
236	if (!elm \|\| !encoder)
237	return 1;
238
239	int res;
240
241	// CBOR map == JSON object
242	if (json_is_object(elm)) {
243	CborEncoder map;
244	const char *key;
245	json_t *value;
246
247	res = cbor_encoder_create_map(encoder, &map, JsonObjElmCount(elm));
248	cbor_check(res);
249
250	json_object_foreach(elm, key, value) {
251	if (strlen(key) > 0 && key[0] != '.') {
252	res = cbor_encode_text_stringz(&map, key);
253	cbor_check(res);
254
255	// RECURSION!
256	JsonToCbor(value, &map);
257	}
258	}
259
260	res = cbor_encoder_close_container(encoder, &map);
261	cbor_check(res);
262	}
263
264	// CBOR array == JSON array
265	if (json_is_array(elm)) {
266	size_t index;
267	json_t *value;
268	CborEncoder array;
269
270	res = cbor_encoder_create_array(encoder, &array, json_array_size(elm));
271	cbor_check(res);
272
273	json_array_foreach(elm, index, value) {
274	// RECURSION!
275	JsonToCbor(value, &array);
276	}
277
278	res = cbor_encoder_close_container(encoder, &array);
279	cbor_check(res);
280	}
281
282	if (json_is_boolean(elm)) {
283	res = cbor_encode_boolean(encoder, json_is_true(elm));
284	cbor_check(res);
285	}
286
287	if (json_is_integer(elm)) {
288	res = cbor_encode_int(encoder, json_integer_value(elm));
289	cbor_check(res);
290	}
291
292	if (json_is_real(elm)) {
293	res = cbor_encode_float(encoder, json_real_value(elm));
294	cbor_check(res);
295	}
296
297	if (json_is_string(elm)) {
298	const char * val = json_string_value(elm);
299	if (CheckStringIsHEXValue(val)) {
300	size_t datalen = 0;
301	uint8_t data[4096] = {0};
302	res = JsonLoadBufAsHex(elm, "$", data, sizeof(data), &datalen);
303	if (res)
304	return 100;
305
306	res = cbor_encode_byte_string(encoder, data, datalen);
307	cbor_check(res);
308	} else {
309	res = cbor_encode_text_stringz(encoder, val);
310	cbor_check(res);
311	}
312	}
313
314
315
316	return 0;
317	}
318
319	int CborMapGetKeyById(CborParser parser, CborValue map, uint8_t *data, size_t dataLen, int key) {
320	CborValue cb;
321
322	CborError err = cbor_parser_init(data, dataLen, 0, parser, &cb);
323	cbor_check(err);
324
325	if (cbor_value_get_type(&cb) != CborMapType)
326	return 1;
327
328	err = cbor_value_enter_container(&cb, map);
329	cbor_check(err);
330
331	int64_t indx;
332	while (!cbor_value_at_end(map)) {
333	// check number
334	if (cbor_value_get_type(map) != CborIntegerType)
335	return 1;
336
337	cbor_value_get_int64(map, &indx);
338
339	err = cbor_value_advance(map);
340	cbor_check(err);
341
342	if (indx == key)
343	return 0;
344
345	// pass value
346	err = cbor_value_advance(map);
347	cbor_check(err);
348	}
349
350	err = cbor_value_leave_container(&cb, map);
351	cbor_check(err);
352
353	return 2;
354	}
355
356	CborError CborGetArrayBinStringValue(CborValue elm, uint8_t data, size_t maxdatalen, size_t *datalen) {
357	return CborGetArrayBinStringValueEx(elm, data, maxdatalen, datalen, NULL, 0);
358	}
359
360	CborError CborGetArrayBinStringValueEx(CborValue elm, uint8_t data, size_t maxdatalen, size_t datalen, uint8_t delimeter, size_t delimeterlen) {
361	CborValue array;
362	if (datalen)
363	*datalen = 0;
364
365	size_t slen = maxdatalen;
366	size_t totallen = 0;
367
368	CborError res = cbor_value_enter_container(elm, &array);
369	cbor_check(res);
370
371	while (!cbor_value_at_end(&array)) {
372	res = cbor_value_copy_byte_string(&array, &data[totallen], &slen, &array);
373	cbor_check(res);
374
375	totallen += slen;
376	if (delimeter) {
377	memcpy(&data[totallen], delimeter, delimeterlen);
378	totallen += delimeterlen;
379	}
380	slen = maxdatalen - totallen;
381	}
382
383	res = cbor_value_leave_container(elm, &array);
384	cbor_check(res);
385
386	if (datalen)
387	*datalen = totallen;
388
389	return CborNoError;
390	};
391
392	CborError CborGetBinStringValue(CborValue elm, uint8_t data, size_t maxdatalen, size_t *datalen) {
393	if (datalen)
394	*datalen = 0;
395
396	size_t slen = maxdatalen;
397
398	CborError res = cbor_value_copy_byte_string(elm, data, &slen, elm);
399	cbor_check(res);
400
401	if (datalen)
402	*datalen = slen;
403
404	return CborNoError;
405	};
406
407	CborError CborGetArrayStringValue(CborValue elm, char data, size_t maxdatalen, size_t datalen, char delimeter) {
408	CborValue array;
409	if (datalen)
410	*datalen = 0;
411
412	size_t slen = maxdatalen;
413	size_t totallen = 0;
414
415	CborError res = cbor_value_enter_container(elm, &array);
416	cbor_check(res);
417
418	while (!cbor_value_at_end(&array)) {
419	res = cbor_value_copy_text_string(&array, &data[totallen], &slen, &array);
420	cbor_check(res);
421
422	totallen += slen;
423	if (delimeter) {
424	strcat(data, delimeter);
425	totallen += strlen(delimeter);
426	}
427	slen = maxdatalen - totallen;
428	data[totallen] = 0x00;
429	}
430
431	res = cbor_value_leave_container(elm, &array);
432	cbor_check(res);
433
434	if (datalen)
435	*datalen = totallen;
436
437	return CborNoError;
438	};
439
440	CborError CborGetStringValue(CborValue elm, char data, size_t maxdatalen, size_t *datalen) {
441	if (datalen)
442	*datalen = 0;
443
444	size_t slen = maxdatalen;
445
446	CborError res = cbor_value_copy_text_string(elm, data, &slen, elm);
447	cbor_check(res);
448
449	if (datalen)
450	*datalen = slen;
451
452	return CborNoError;
453	};
454
455	CborError CborGetStringValueBuf(CborValue *elm) {
456	static char stringBuf[2048];
457	memset(stringBuf, 0x00, sizeof(stringBuf));
458
459	return CborGetStringValue(elm, stringBuf, sizeof(stringBuf), NULL);
460	};
461
462	int CBOREncodeElm(json_t root, char rootElmId, CborEncoder *encoder) {
463	json_t *elm = NULL;
464	if (rootElmId && strlen(rootElmId) && rootElmId[0] == '$')
465	elm = json_path_get(root, rootElmId);
466	else
467	elm = json_object_get(root, rootElmId);
468
469	if (!elm)
470	return 1;
471
472	int res = JsonToCbor(elm, encoder);
473
474	return res;
475	}
476
477	CborError CBOREncodeClientDataHash(json_t root, CborEncoder encoder) {
478	uint8_t buf[100] = {0};
479	size_t jlen;
480
481	JsonLoadBufAsHex(root, "$.ClientDataHash", buf, sizeof(buf), &jlen);
482
483	// fill with 0x00 if not found
484	if (!jlen)
485	jlen = 32;
486
487	int res = cbor_encode_byte_string(encoder, buf, jlen);
488	cbor_check(res);
489
490	return 0;
491	}