Fido2 (#727)
[proxmark3-svn] / client / tinycbor / cborpretty.c
1 /****************************************************************************
2 **
3 ** Copyright (C) 2018 Intel Corporation
4 **
5 ** Permission is hereby granted, free of charge, to any person obtaining a copy
6 ** of this software and associated documentation files (the "Software"), to deal
7 ** in the Software without restriction, including without limitation the rights
8 ** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 ** copies of the Software, and to permit persons to whom the Software is
10 ** furnished to do so, subject to the following conditions:
11 **
12 ** The above copyright notice and this permission notice shall be included in
13 ** all copies or substantial portions of the Software.
14 **
15 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 ** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 ** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 ** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 ** THE SOFTWARE.
22 **
23 ****************************************************************************/
24
25 #define _BSD_SOURCE 1
26 #define _DEFAULT_SOURCE 1
27 #ifndef __STDC_LIMIT_MACROS
28 # define __STDC_LIMIT_MACROS 1
29 #endif
30
31 #include "cbor.h"
32 #include "cborinternal_p.h"
33 #include "compilersupport_p.h"
34 #include "utf8_p.h"
35
36 #include <inttypes.h>
37 #include <string.h>
38
39 /**
40 * \defgroup CborPretty Converting CBOR to text
41 * \brief Group of functions used to convert CBOR to text form.
42 *
43 * This group contains two functions that can be used to convert a \ref
44 * CborValue object to a text representation. This module attempts to follow
45 * the recommendations from RFC 7049 section 6 "Diagnostic Notation", though it
46 * has a few differences. They are noted below.
47 *
48 * TinyCBOR does not provide a way to convert from the text representation back
49 * to encoded form. To produce a text form meant to be parsed, CborToJson is
50 * recommended instead.
51 *
52 * Either of the functions in this section will attempt to convert exactly one
53 * CborValue object to text. Those functions may return any error documented
54 * for the functions for CborParsing. In addition, if the C standard library
55 * stream functions return with error, the text conversion will return with
56 * error CborErrorIO.
57 *
58 * These functions also perform UTF-8 validation in CBOR text strings. If they
59 * encounter a sequence of bytes that is not permitted in UTF-8, they will return
60 * CborErrorInvalidUtf8TextString. That includes encoding of surrogate points
61 * in UTF-8.
62 *
63 * \warning The output type produced by these functions is not guaranteed to
64 * remain stable. A future update of TinyCBOR may produce different output for
65 * the same input and parsers may be unable to handle it.
66 *
67 * \sa CborParsing, CborToJson, cbor_parser_init()
68 */
69
70 /**
71 * \addtogroup CborPretty
72 * @{
73 * <h2 class="groupheader">Text format</h2>
74 *
75 * As described in RFC 7049 section 6 "Diagnostic Notation", the format is
76 * largely borrowed from JSON, but modified to suit CBOR's different data
77 * types. TinyCBOR makes further modifications to distinguish different, but
78 * similar values.
79 *
80 * CBOR values are currently encoded as follows:
81 * \par Integrals (unsigned and negative)
82 * Base-10 (decimal) text representation of the value
83 * \par Byte strings:
84 * <tt>"h'"</tt> followed by the Base16 (hex) representation of the binary data, followed by an ending quote (')
85 * \par Text strings:
86 * C-style escaped string in quotes, with C11/C++11 escaping of Unicode codepoints above U+007F.
87 * \par Tags:
88 * Tag value, with the tagged value in parentheses. No special encoding of the tagged value is performed.
89 * \par Simple types:
90 * <tt>"simple(nn)"</tt> where \c nn is the simple value
91 * \par Null:
92 * \c null
93 * \par Undefined:
94 * \c undefined
95 * \par Booleans:
96 * \c true or \c false
97 * \par Floating point:
98 * If NaN or infinite, the actual words \c NaN or \c infinite.
99 * Otherwise, the decimal representation with as many digits as necessary to ensure no loss of information.
100 * By default, float values are suffixed by "f" and half-float values suffixed by "f16" (doubles have no suffix).
101 * If the CborPrettyNumericEncodingIndicators flag is active, the values instead are encoded following the
102 * Section 6 recommended encoding indicators: float values are suffixed with "_2" and half-float with "_1".
103 * A decimal point is always present.
104 * \par Arrays:
105 * Comma-separated list of elements, enclosed in square brackets ("[" and "]").
106 * \par Maps:
107 * Comma-separated list of key-value pairs, with the key and value separated
108 * by a colon (":"), enclosed in curly braces ("{" and "}").
109 *
110 * The CborPrettyFlags enumerator contains flags to control some aspects of the
111 * encoding:
112 * \par String fragmentation
113 * When the CborPrettyShowStringFragments option is active, text and byte
114 * strings that are transmitted in fragments are shown instead inside
115 * parentheses ("(" and ")") with no preceding number and each fragment is
116 * displayed individually. If a tag precedes the string, then the output
117 * will contain a double set of parentheses. If the option is not active,
118 * the fragments are merged together and the display will not show any
119 * difference from a string transmitted with determinate length.
120 * \par Encoding indicators
121 * Numbers and lengths in CBOR can be encoded in multiple representations.
122 * If the CborPrettyIndicateOverlongNumbers option is active, numbers
123 * and lengths that are transmitted in a longer encoding than necessary
124 * will be indicated, by appending an underscore ("_") to either the
125 * number or the opening bracket or brace, followed by a number
126 * indicating the CBOR additional information: 0 for 1 byte, 1 for 2
127 * bytes, 2 for 4 bytes and 3 for 8 bytes.
128 * If the CborPrettyIndicateIndeterminateLength option is active, maps,
129 * arrays and strings encoded with indeterminate length will be marked by
130 * an underscore after the opening bracket or brace or the string (if not
131 * showing fragments), without a number after it.
132 */
133
134 /**
135 * \enum CborPrettyFlags
136 * The CborPrettyFlags enum contains flags that control the conversion of CBOR to text format.
137 *
138 * \value CborPrettyNumericEncodingIndicators Use numeric encoding indicators instead of textual for float and half-float.
139 * \value CborPrettyTextualEncodingIndicators Use textual encoding indicators for float ("f") and half-float ("f16").
140 * \value CborPrettyIndicateIndeterminateLength (default) Indicate when a map or array has indeterminate length.
141 * \value CborPrettyIndicateOverlongNumbers Indicate when a number or length was encoded with more bytes than needed.
142 * \value CborPrettyShowStringFragments If the byte or text string is transmitted in chunks, show each individually.
143 * \value CborPrettyMergeStringFragment Merge all chunked byte or text strings and display them in a single entry.
144 * \value CborPrettyDefaultFlags Default conversion flags.
145 */
146
147 #ifndef CBOR_NO_FLOATING_POINT
148 static inline bool convertToUint64(double v, uint64_t *absolute)
149 {
150 double supremum;
151 v = fabs(v);
152
153 /* C11 standard section 6.3.1.4 "Real floating and integer" says:
154 *
155 * 1 When a finite value of real floating type is converted to an integer
156 * type other than _Bool, the fractional part is discarded (i.e., the
157 * value is truncated toward zero). If the value of the integral part
158 * cannot be represented by the integer type, the behavior is undefined.
159 *
160 * So we must perform a range check that v <= UINT64_MAX, but we can't use
161 * UINT64_MAX + 1.0 because the standard continues:
162 *
163 * 2 When a value of integer type is converted to a real floating type, if
164 * the value being converted can be represented exactly in the new type,
165 * it is unchanged. If the value being converted is in the range of
166 * values that can be represented but cannot be represented exactly, the
167 * result is either the nearest higher or nearest lower representable
168 * value, chosen in an implementation-defined manner.
169 */
170 supremum = -2.0 * INT64_MIN; /* -2 * (- 2^63) == 2^64 */
171 if (v >= supremum)
172 return false;
173
174 /* Now we can convert, these two conversions cannot be UB */
175 *absolute = v;
176 return *absolute == v;
177 }
178 #endif
179
180 static void printRecursionLimit(CborStreamFunction stream, void *out)
181 {
182 stream(out, "<nesting too deep, recursion stopped>");
183 }
184
185 static CborError hexDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)
186 {
187 const uint8_t *buffer = (const uint8_t *)ptr;
188 CborError err = CborNoError;
189 while (n-- && !err)
190 err = stream(out, "%02" PRIx8, *buffer++);
191
192 return err;
193 }
194
195 /* This function decodes buffer as UTF-8 and prints as escaped UTF-16.
196 * On UTF-8 decoding error, it returns CborErrorInvalidUtf8TextString */
197 static CborError utf8EscapedDump(CborStreamFunction stream, void *out, const void *ptr, size_t n)
198 {
199 const uint8_t *buffer = (const uint8_t *)ptr;
200 const uint8_t * const end = buffer + n;
201 CborError err = CborNoError;
202
203 while (buffer < end && !err) {
204 uint32_t uc = get_utf8(&buffer, end);
205 if (uc == ~0U)
206 return CborErrorInvalidUtf8TextString;
207
208 if (uc < 0x80) {
209 /* single-byte UTF-8 */
210 unsigned char escaped = (unsigned char)uc;
211 if (uc < 0x7f && uc >= 0x20 && uc != '\\' && uc != '"') {
212 err = stream(out, "%c", (char)uc);
213 continue;
214 }
215
216 /* print as an escape sequence */
217 switch (uc) {
218 case '"':
219 case '\\':
220 break;
221 case '\b':
222 escaped = 'b';
223 break;
224 case '\f':
225 escaped = 'f';
226 break;
227 case '\n':
228 escaped = 'n';
229 break;
230 case '\r':
231 escaped = 'r';
232 break;
233 case '\t':
234 escaped = 't';
235 break;
236 default:
237 goto print_utf16;
238 }
239 err = stream(out, "\\%c", escaped);
240 continue;
241 }
242
243 /* now print the sequence */
244 if (uc > 0xffffU) {
245 /* needs surrogate pairs */
246 err = stream(out, "\\u%04" PRIX32 "\\u%04" PRIX32,
247 (uc >> 10) + 0xd7c0, /* high surrogate */
248 (uc % 0x0400) + 0xdc00);
249 } else {
250 print_utf16:
251 /* no surrogate pair needed */
252 err = stream(out, "\\u%04" PRIX32, uc);
253 }
254 }
255 return err;
256 }
257
258 static const char *resolve_indicator(const uint8_t *ptr, const uint8_t *end, int flags)
259 {
260 static const char indicators[8][3] = {
261 "_0", "_1", "_2", "_3",
262 "", "", "", /* these are not possible */
263 "_"
264 };
265 const char *no_indicator = indicators[5]; /* empty string */
266 uint8_t additional_information;
267 uint8_t expected_information;
268 uint64_t value;
269 CborError err;
270
271 if (ptr == end)
272 return NULL; /* CborErrorUnexpectedEOF */
273
274 additional_information = (*ptr & SmallValueMask);
275 if (additional_information < Value8Bit)
276 return no_indicator;
277
278 /* determine whether to show anything */
279 if ((flags & CborPrettyIndicateIndeterminateLength) &&
280 additional_information == IndefiniteLength)
281 return indicators[IndefiniteLength - Value8Bit];
282 if ((flags & CborPrettyIndicateOverlongNumbers) == 0)
283 return no_indicator;
284
285 err = _cbor_value_extract_number(&ptr, end, &value);
286 if (err)
287 return NULL; /* CborErrorUnexpectedEOF */
288
289 expected_information = Value8Bit - 1;
290 if (value >= Value8Bit)
291 ++expected_information;
292 if (value > 0xffU)
293 ++expected_information;
294 if (value > 0xffffU)
295 ++expected_information;
296 if (value > 0xffffffffU)
297 ++expected_information;
298 return expected_information == additional_information ?
299 no_indicator :
300 indicators[additional_information - Value8Bit];
301 }
302
303 static const char *get_indicator(const CborValue *it, int flags)
304 {
305 return resolve_indicator(it->ptr, it->parser->end, flags);
306 }
307
308 static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft);
309 static CborError container_to_pretty(CborStreamFunction stream, void *out, CborValue *it, CborType containerType,
310 int flags, int recursionsLeft)
311 {
312 const char *comma = "";
313 CborError err = CborNoError;
314
315 if (!recursionsLeft) {
316 printRecursionLimit(stream, out);
317 return err; /* do allow the dumping to continue */
318 }
319
320 while (!cbor_value_at_end(it) && !err) {
321 err = stream(out, "%s", comma);
322 comma = ", ";
323
324 if (!err)
325 err = value_to_pretty(stream, out, it, flags, recursionsLeft);
326
327 if (containerType == CborArrayType)
328 continue;
329
330 /* map: that was the key, so get the value */
331 if (!err)
332 err = stream(out, ": ");
333 if (!err)
334 err = value_to_pretty(stream, out, it, flags, recursionsLeft);
335 }
336 return err;
337 }
338
339 static CborError value_to_pretty(CborStreamFunction stream, void *out, CborValue *it, int flags, int recursionsLeft)
340 {
341 CborError err = CborNoError;
342 CborType type = cbor_value_get_type(it);
343 switch (type) {
344 case CborArrayType:
345 case CborMapType: {
346 /* recursive type */
347 CborValue recursed;
348 const char *indicator = get_indicator(it, flags);
349 const char *space = *indicator ? " " : indicator;
350
351 err = stream(out, "%c%s%s", type == CborArrayType ? '[' : '{', indicator, space);
352 if (err)
353 return err;
354
355 err = cbor_value_enter_container(it, &recursed);
356 if (err) {
357 it->ptr = recursed.ptr;
358 return err; /* parse error */
359 }
360 err = container_to_pretty(stream, out, &recursed, type, flags, recursionsLeft - 1);
361 if (err) {
362 it->ptr = recursed.ptr;
363 return err; /* parse error */
364 }
365 err = cbor_value_leave_container(it, &recursed);
366 if (err)
367 return err; /* parse error */
368
369 return stream(out, type == CborArrayType ? "]" : "}");
370 }
371
372 case CborIntegerType: {
373 uint64_t val;
374 cbor_value_get_raw_integer(it, &val); /* can't fail */
375
376 if (cbor_value_is_unsigned_integer(it)) {
377 err = stream(out, "%" PRIu64, val);
378 } else {
379 /* CBOR stores the negative number X as -1 - X
380 * (that is, -1 is stored as 0, -2 as 1 and so forth) */
381 if (++val) { /* unsigned overflow may happen */
382 err = stream(out, "-%" PRIu64, val);
383 } else {
384 /* overflown
385 * 0xffff`ffff`ffff`ffff + 1 =
386 * 0x1`0000`0000`0000`0000 = 18446744073709551616 (2^64) */
387 err = stream(out, "-18446744073709551616");
388 }
389 }
390 if (!err)
391 err = stream(out, "%s", get_indicator(it, flags));
392 break;
393 }
394
395 case CborByteStringType:
396 case CborTextStringType: {
397 size_t n = 0;
398 const void *ptr;
399 bool showingFragments = (flags & CborPrettyShowStringFragments) && !cbor_value_is_length_known(it);
400 const char *separator = "";
401 char close = '\'';
402 char open[3] = "h'";
403 const char *indicator = NULL;
404
405 if (type == CborTextStringType) {
406 close = open[0] = '"';
407 open[1] = '\0';
408 }
409
410 if (showingFragments) {
411 err = stream(out, "(_ ");
412 if (!err)
413 err = _cbor_value_prepare_string_iteration(it);
414 } else {
415 err = stream(out, "%s", open);
416 }
417
418 while (!err) {
419 if (showingFragments || indicator == NULL) {
420 /* any iteration, except the second for a non-chunked string */
421 indicator = resolve_indicator(it->ptr, it->parser->end, flags);
422 }
423
424 err = _cbor_value_get_string_chunk(it, &ptr, &n, it);
425 if (!ptr)
426 break;
427
428 if (!err && showingFragments)
429 err = stream(out, "%s%s", separator, open);
430 if (!err)
431 err = (type == CborByteStringType ?
432 hexDump(stream, out, ptr, n) :
433 utf8EscapedDump(stream, out, ptr, n));
434 if (!err && showingFragments) {
435 err = stream(out, "%c%s", close, indicator);
436 separator = ", ";
437 }
438 }
439
440 if (!err) {
441 if (showingFragments)
442 err = stream(out, ")");
443 else
444 err = stream(out, "%c%s", close, indicator);
445 }
446 return err;
447 }
448
449 case CborTagType: {
450 CborTag tag;
451 cbor_value_get_tag(it, &tag); /* can't fail */
452 err = stream(out, "%" PRIu64 "%s(", tag, get_indicator(it, flags));
453 if (!err)
454 err = cbor_value_advance_fixed(it);
455 if (!err && recursionsLeft)
456 err = value_to_pretty(stream, out, it, flags, recursionsLeft - 1);
457 else if (!err)
458 printRecursionLimit(stream, out);
459 if (!err)
460 err = stream(out, ")");
461 return err;
462 }
463
464 case CborSimpleType: {
465 /* simple types can't fail and can't have overlong encoding */
466 uint8_t simple_type;
467 cbor_value_get_simple_type(it, &simple_type);
468 err = stream(out, "simple(%" PRIu8 ")", simple_type);
469 break;
470 }
471
472 case CborNullType:
473 err = stream(out, "null");
474 break;
475
476 case CborUndefinedType:
477 err = stream(out, "undefined");
478 break;
479
480 case CborBooleanType: {
481 bool val;
482 cbor_value_get_boolean(it, &val); /* can't fail */
483 err = stream(out, val ? "true" : "false");
484 break;
485 }
486
487 #ifndef CBOR_NO_FLOATING_POINT
488 case CborDoubleType: {
489 const char *suffix;
490 double val;
491 int r;
492 uint64_t ival;
493
494 if (false) {
495 float f;
496 case CborFloatType:
497 cbor_value_get_float(it, &f);
498 val = f;
499 suffix = flags & CborPrettyNumericEncodingIndicators ? "_2" : "f";
500 } else if (false) {
501 uint16_t f16;
502 case CborHalfFloatType:
503 #ifndef CBOR_NO_HALF_FLOAT_TYPE
504 cbor_value_get_half_float(it, &f16);
505 val = decode_half(f16);
506 suffix = flags & CborPrettyNumericEncodingIndicators ? "_1" : "f16";
507 #else
508 (void)f16;
509 err = CborErrorUnsupportedType;
510 break;
511 #endif
512 } else {
513 cbor_value_get_double(it, &val);
514 suffix = "";
515 }
516
517 if ((flags & CborPrettyNumericEncodingIndicators) == 0) {
518 r = fpclassify(val);
519 if (r == FP_NAN || r == FP_INFINITE)
520 suffix = "";
521 }
522
523 if (convertToUint64(val, &ival)) {
524 /* this double value fits in a 64-bit integer, so show it as such
525 * (followed by a floating point suffix, to disambiguate) */
526 err = stream(out, "%s%" PRIu64 ".%s", val < 0 ? "-" : "", ival, suffix);
527 } else {
528 /* this number is definitely not a 64-bit integer */
529 err = stream(out, "%." DBL_DECIMAL_DIG_STR "g%s", val, suffix);
530 }
531 break;
532 }
533 #else
534 case CborDoubleType:
535 case CborFloatType:
536 case CborHalfFloatType:
537 err = CborErrorUnsupportedType;
538 break;
539 #endif /* !CBOR_NO_FLOATING_POINT */
540
541 case CborInvalidType:
542 err = stream(out, "invalid");
543 if (err)
544 return err;
545 return CborErrorUnknownType;
546 }
547
548 if (!err)
549 err = cbor_value_advance_fixed(it);
550 return err;
551 }
552
553 /**
554 * Converts the current CBOR type pointed by \a value to its textual
555 * representation and writes it to the stream by calling the \a streamFunction.
556 * If an error occurs, this function returns an error code similar to
557 * \ref CborParsing.
558 *
559 * The textual representation can be controlled by the \a flags parameter (see
560 * \ref CborPrettyFlags for more information).
561 *
562 * If no error ocurred, this function advances \a value to the next element.
563 * Often, concatenating the text representation of multiple elements can be
564 * done by appending a comma to the output stream in between calls to this
565 * function.
566 *
567 * The \a streamFunction function will be called with the \a token value as the
568 * first parameter and a printf-style format string as the second, with a variable
569 * number of further parameters.
570 *
571 * \sa cbor_value_to_pretty(), cbor_value_to_json_advance()
572 */
573 CborError cbor_value_to_pretty_stream(CborStreamFunction streamFunction, void *token, CborValue *value, int flags)
574 {
575 return value_to_pretty(streamFunction, token, value, flags, CBOR_PARSER_MAX_RECURSIONS);
576 }
577
578 /** @} */
Impressum, Datenschutz