| Line | Count | Source (jump to first uncovered line) | 
| 1 |  | /* | 
| 2 |  |  * Copyright (c) 2018 Yubico AB. All rights reserved. | 
| 3 |  |  * Use of this source code is governed by a BSD-style | 
| 4 |  |  * license that can be found in the LICENSE file. | 
| 5 |  |  * SPDX-License-Identifier: BSD-2-Clause | 
| 6 |  |  */ | 
| 7 |  |  | 
| 8 |  | #include "fido.h" | 
| 9 |  |  | 
| 10 |  | fido_blob_t * | 
| 11 |  | fido_blob_new(void) | 
| 12 | 44.9k | { | 
| 13 | 44.9k |         return calloc(1, sizeof(fido_blob_t)); | 
| 14 | 44.9k | } | 
| 15 |  |  | 
| 16 |  | void | 
| 17 |  | fido_blob_reset(fido_blob_t *b) | 
| 18 | 2.18M | { | 
| 19 | 2.18M |         freezero(b->ptr, b->len); | 
| 20 | 2.18M |         explicit_bzero(b, sizeof(*b)); | 
| 21 | 2.18M | } | 
| 22 |  |  | 
| 23 |  | int | 
| 24 |  | fido_blob_set(fido_blob_t *b, const u_char *ptr, size_t len) | 
| 25 | 365k | { | 
| 26 | 365k |         fido_blob_reset(b); | 
| 27 |  |  | 
| 28 | 365k |         if (ptr == NULL || len == 0) { | 
| 29 | 22.6k |                 fido_log_debug("%s: ptr=%p, len=%zu", __func__, | 
| 30 | 22.6k |                     (const void *)ptr, len); | 
| 31 | 22.6k |                 return -1; | 
| 32 | 22.6k |         } | 
| 33 |  |  | 
| 34 | 343k |         if ((b->ptr = malloc(len)) == NULL) { | 
| 35 | 905 |                 fido_log_debug("%s: malloc", __func__); | 
| 36 | 905 |                 return -1; | 
| 37 | 905 |         } | 
| 38 |  |  | 
| 39 | 342k |         memcpy(b->ptr, ptr, len); | 
| 40 | 342k |         b->len = len; | 
| 41 |  |  | 
| 42 | 342k |         return 0; | 
| 43 | 343k | } | 
| 44 |  |  | 
| 45 |  | int | 
| 46 |  | fido_blob_append(fido_blob_t *b, const u_char *ptr, size_t len) | 
| 47 | 987 | { | 
| 48 | 987 |         u_char *tmp; | 
| 49 |  |  | 
| 50 | 987 |         if (ptr == NULL || len == 0) { | 
| 51 | 20 |                 fido_log_debug("%s: ptr=%p, len=%zu", __func__, | 
| 52 | 20 |                     (const void *)ptr, len); | 
| 53 | 20 |                 return -1; | 
| 54 | 20 |         } | 
| 55 | 967 |         if (SIZE_MAX - b->len < len) { | 
| 56 | 0 |                 fido_log_debug("%s: overflow", __func__); | 
| 57 | 0 |                 return -1; | 
| 58 | 0 |         } | 
| 59 | 967 |         if ((tmp = realloc(b->ptr, b->len + len)) == NULL) { | 
| 60 | 3 |                 fido_log_debug("%s: realloc", __func__); | 
| 61 | 3 |                 return -1; | 
| 62 | 3 |         } | 
| 63 | 964 |         b->ptr = tmp; | 
| 64 | 964 |         memcpy(&b->ptr[b->len], ptr, len); | 
| 65 | 964 |         b->len += len; | 
| 66 |  |  | 
| 67 | 964 |         return 0; | 
| 68 | 967 | } | 
| 69 |  |  | 
| 70 |  | void | 
| 71 |  | fido_blob_free(fido_blob_t **bp) | 
| 72 | 85.3k | { | 
| 73 | 85.3k |         fido_blob_t *b; | 
| 74 |  |  | 
| 75 | 85.3k |         if (bp == NULL || (b = *bp) == NULL) | 
| 76 | 40.5k |                 return; | 
| 77 |  |  | 
| 78 | 44.7k |         fido_blob_reset(b); | 
| 79 | 44.7k |         free(b); | 
| 80 | 44.7k |         *bp = NULL; | 
| 81 | 44.7k | } | 
| 82 |  |  | 
| 83 |  | void | 
| 84 |  | fido_free_blob_array(fido_blob_array_t *array) | 
| 85 | 150k | { | 
| 86 | 150k |         if (array->ptr == NULL) | 
| 87 | 142k |                 return; | 
| 88 |  |  | 
| 89 | 236k |         for (size_t i = 0; i < array->len; i++) { | 
| 90 | 228k |                 fido_blob_t *b = &array->ptr[i]; | 
| 91 | 228k |                 freezero(b->ptr, b->len); | 
| 92 | 228k |                 b->ptr = NULL; | 
| 93 | 228k |         } | 
| 94 |  |  | 
| 95 | 7.74k |         free(array->ptr); | 
| 96 | 7.74k |         array->ptr = NULL; | 
| 97 | 7.74k |         array->len = 0; | 
| 98 | 7.74k | } | 
| 99 |  |  | 
| 100 |  | cbor_item_t * | 
| 101 |  | fido_blob_encode(const fido_blob_t *b) | 
| 102 | 12.7k | { | 
| 103 | 12.7k |         if (b == NULL || b->ptr == NULL) | 
| 104 | 33 |                 return NULL; | 
| 105 |  |  | 
| 106 | 12.7k |         return cbor_build_bytestring(b->ptr, b->len); | 
| 107 | 12.7k | } | 
| 108 |  |  | 
| 109 |  | int | 
| 110 |  | fido_blob_decode(const cbor_item_t *item, fido_blob_t *b) | 
| 111 | 25.6k | { | 
| 112 | 25.6k |         return cbor_bytestring_copy(item, &b->ptr, &b->len); | 
| 113 | 25.6k | } | 
| 114 |  |  | 
| 115 |  | int | 
| 116 |  | fido_blob_is_empty(const fido_blob_t *b) | 
| 117 | 81.3k | { | 
| 118 | 81.3k |         return b->ptr == NULL || b->len == 0; | 
| 119 | 81.3k | } | 
| 120 |  |  | 
| 121 |  | int | 
| 122 |  | fido_blob_serialise(fido_blob_t *b, const cbor_item_t *item) | 
| 123 | 1.62k | { | 
| 124 | 1.62k |         size_t alloc; | 
| 125 |  |  | 
| 126 | 1.62k |         if (!fido_blob_is_empty(b)) | 
| 127 | 0 |                 return -1; | 
| 128 | 1.62k |         if ((b->len = cbor_serialize_alloc(item, &b->ptr, &alloc)) == 0) { | 
| 129 | 7 |                 b->ptr = NULL; | 
| 130 | 7 |                 return -1; | 
| 131 | 7 |         } | 
| 132 |  |  | 
| 133 | 1.61k |         return 0; | 
| 134 | 1.62k | } |