Coverage Report

Created: 2024-06-03 09:43

/libfido2/src/blob.c
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
}