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