]>
Commit | Line | Data |
---|---|---|
884314ca | 1 | /* |
fecb3aae | 2 | * Copyright 2021-2022 The OpenSSL Project Authors. All Rights Reserved. |
884314ca SL |
3 | * |
4 | * Licensed under the Apache License 2.0 (the "License"). You may not use | |
5 | * this file except in compliance with the License. You can obtain a copy | |
6 | * in the file LICENSE in the source distribution or at | |
7 | * https://www.openssl.org/source/license.html | |
8 | */ | |
9 | ||
10 | #include <string.h> | |
11 | #include <openssl/params.h> | |
12 | #include <openssl/param_build.h> | |
13 | #include "internal/param_build_set.h" | |
884314ca SL |
14 | |
15 | #define OSSL_PARAM_ALLOCATED_END 127 | |
16 | #define OSSL_PARAM_MERGE_LIST_MAX 128 | |
17 | ||
18 | #define OSSL_PARAM_BUF_PUBLIC 0 | |
19 | #define OSSL_PARAM_BUF_SECURE 1 | |
20 | #define OSSL_PARAM_BUF_MAX (OSSL_PARAM_BUF_SECURE + 1) | |
21 | ||
22 | typedef struct { | |
23 | OSSL_PARAM_ALIGNED_BLOCK *alloc; /* The allocated buffer */ | |
24 | OSSL_PARAM_ALIGNED_BLOCK *cur; /* Current position in the allocated buf */ | |
25 | size_t blocks; /* Number of aligned blocks */ | |
26 | size_t alloc_sz; /* The size of the allocated buffer (in bytes) */ | |
27 | } OSSL_PARAM_BUF; | |
28 | ||
29 | size_t ossl_param_bytes_to_blocks(size_t bytes) | |
30 | { | |
31 | return (bytes + OSSL_PARAM_ALIGN_SIZE - 1) / OSSL_PARAM_ALIGN_SIZE; | |
32 | } | |
33 | ||
34 | static int ossl_param_buf_alloc(OSSL_PARAM_BUF *out, size_t extra_blocks, | |
35 | int is_secure) | |
36 | { | |
37 | size_t sz = OSSL_PARAM_ALIGN_SIZE * (extra_blocks + out->blocks); | |
38 | ||
39 | out->alloc = is_secure ? OPENSSL_secure_zalloc(sz) : OPENSSL_zalloc(sz); | |
e077455e | 40 | if (out->alloc == NULL) |
884314ca | 41 | return 0; |
884314ca SL |
42 | out->alloc_sz = sz; |
43 | out->cur = out->alloc + extra_blocks; | |
44 | return 1; | |
45 | } | |
46 | ||
47 | void ossl_param_set_secure_block(OSSL_PARAM *last, void *secure_buffer, | |
48 | size_t secure_buffer_sz) | |
49 | { | |
50 | last->key = NULL; | |
51 | last->data_size = secure_buffer_sz; | |
52 | last->data = secure_buffer; | |
53 | last->data_type = OSSL_PARAM_ALLOCATED_END; | |
54 | } | |
55 | ||
56 | static OSSL_PARAM *ossl_param_dup(const OSSL_PARAM *src, OSSL_PARAM *dst, | |
57 | OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX], | |
58 | int *param_count) | |
59 | { | |
60 | const OSSL_PARAM *in; | |
61 | int has_dst = (dst != NULL); | |
62 | int is_secure; | |
63 | size_t param_sz, blks; | |
64 | ||
65 | for (in = src; in->key != NULL; in++) { | |
66 | is_secure = CRYPTO_secure_allocated(in->data); | |
67 | if (has_dst) { | |
68 | *dst = *in; | |
69 | dst->data = buf[is_secure].cur; | |
70 | } | |
71 | ||
72 | if (in->data_type == OSSL_PARAM_OCTET_PTR | |
73 | || in->data_type == OSSL_PARAM_UTF8_PTR) { | |
74 | param_sz = sizeof(in->data); | |
75 | if (has_dst) | |
76 | *((const void **)dst->data) = *(const void **)in->data; | |
77 | } else { | |
78 | param_sz = in->data_size; | |
79 | if (has_dst) | |
80 | memcpy(dst->data, in->data, param_sz); | |
81 | } | |
82 | if (in->data_type == OSSL_PARAM_UTF8_STRING) | |
83 | param_sz++; /* NULL terminator */ | |
84 | blks = ossl_param_bytes_to_blocks(param_sz); | |
85 | ||
86 | if (has_dst) { | |
87 | dst++; | |
88 | buf[is_secure].cur += blks; | |
89 | } else { | |
90 | buf[is_secure].blocks += blks; | |
91 | } | |
92 | if (param_count != NULL) | |
93 | ++*param_count; | |
94 | } | |
95 | return dst; | |
96 | } | |
97 | ||
98 | OSSL_PARAM *OSSL_PARAM_dup(const OSSL_PARAM *src) | |
99 | { | |
100 | size_t param_blocks; | |
101 | OSSL_PARAM_BUF buf[OSSL_PARAM_BUF_MAX]; | |
102 | OSSL_PARAM *last, *dst; | |
103 | int param_count = 1; /* Include terminator in the count */ | |
104 | ||
a10a5760 P |
105 | if (src == NULL) { |
106 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER); | |
884314ca | 107 | return NULL; |
a10a5760 | 108 | } |
884314ca SL |
109 | |
110 | memset(buf, 0, sizeof(buf)); | |
111 | ||
112 | /* First Pass: get the param_count and block sizes required */ | |
113 | (void)ossl_param_dup(src, NULL, buf, ¶m_count); | |
114 | ||
115 | param_blocks = ossl_param_bytes_to_blocks(param_count * sizeof(*src)); | |
116 | /* | |
117 | * The allocated buffer consists of an array of OSSL_PARAM followed by | |
118 | * aligned data bytes that the array elements will point to. | |
119 | */ | |
120 | if (!ossl_param_buf_alloc(&buf[OSSL_PARAM_BUF_PUBLIC], param_blocks, 0)) | |
121 | return NULL; | |
122 | ||
123 | /* Allocate a secure memory buffer if required */ | |
124 | if (buf[OSSL_PARAM_BUF_SECURE].blocks > 0 | |
125 | && !ossl_param_buf_alloc(&buf[OSSL_PARAM_BUF_SECURE], 0, 1)) { | |
126 | OPENSSL_free(buf[OSSL_PARAM_BUF_PUBLIC].alloc); | |
127 | return NULL; | |
128 | } | |
129 | ||
130 | dst = (OSSL_PARAM *)buf[OSSL_PARAM_BUF_PUBLIC].alloc; | |
131 | last = ossl_param_dup(src, dst, buf, NULL); | |
132 | /* Store the allocated secure memory buffer in the last param block */ | |
133 | ossl_param_set_secure_block(last, buf[OSSL_PARAM_BUF_SECURE].alloc, | |
134 | buf[OSSL_PARAM_BUF_SECURE].alloc_sz); | |
135 | return dst; | |
136 | } | |
137 | ||
138 | static int compare_params(const void *left, const void *right) | |
139 | { | |
140 | const OSSL_PARAM *l = *(const OSSL_PARAM **)left; | |
141 | const OSSL_PARAM *r = *(const OSSL_PARAM **)right; | |
142 | ||
fba140c7 | 143 | return OPENSSL_strcasecmp(l->key, r->key); |
884314ca SL |
144 | } |
145 | ||
146 | OSSL_PARAM *OSSL_PARAM_merge(const OSSL_PARAM *p1, const OSSL_PARAM *p2) | |
147 | { | |
4ecb19d1 P |
148 | const OSSL_PARAM *list1[OSSL_PARAM_MERGE_LIST_MAX + 1]; |
149 | const OSSL_PARAM *list2[OSSL_PARAM_MERGE_LIST_MAX + 1]; | |
884314ca SL |
150 | const OSSL_PARAM *p = NULL; |
151 | const OSSL_PARAM **p1cur, **p2cur; | |
152 | OSSL_PARAM *params, *dst; | |
153 | size_t list1_sz = 0, list2_sz = 0; | |
154 | int diff; | |
155 | ||
a10a5760 P |
156 | if (p1 == NULL && p2 == NULL) { |
157 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER); | |
884314ca | 158 | return NULL; |
a10a5760 | 159 | } |
884314ca SL |
160 | |
161 | /* Copy p1 to list1 */ | |
162 | if (p1 != NULL) { | |
163 | for (p = p1; p->key != NULL && list1_sz < OSSL_PARAM_MERGE_LIST_MAX; p++) | |
164 | list1[list1_sz++] = p; | |
165 | } | |
166 | list1[list1_sz] = NULL; | |
167 | ||
168 | /* copy p2 to a list2 */ | |
169 | if (p2 != NULL) { | |
170 | for (p = p2; p->key != NULL && list2_sz < OSSL_PARAM_MERGE_LIST_MAX; p++) | |
171 | list2[list2_sz++] = p; | |
172 | } | |
173 | list2[list2_sz] = NULL; | |
a10a5760 P |
174 | if (list1_sz == 0 && list2_sz == 0) { |
175 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_NO_PARAMS_TO_MERGE); | |
884314ca | 176 | return NULL; |
a10a5760 | 177 | } |
884314ca SL |
178 | |
179 | /* Sort the 2 lists */ | |
180 | qsort(list1, list1_sz, sizeof(OSSL_PARAM *), compare_params); | |
181 | qsort(list2, list2_sz, sizeof(OSSL_PARAM *), compare_params); | |
182 | ||
183 | /* Allocate enough space to store the merged parameters */ | |
184 | params = OPENSSL_zalloc((list1_sz + list2_sz + 1) * sizeof(*p1)); | |
e077455e | 185 | if (params == NULL) |
884314ca | 186 | return NULL; |
884314ca SL |
187 | dst = params; |
188 | p1cur = list1; | |
189 | p2cur = list2; | |
190 | while (1) { | |
191 | /* If list1 is finished just tack list2 onto the end */ | |
192 | if (*p1cur == NULL) { | |
193 | do { | |
194 | *dst++ = **p2cur; | |
195 | p2cur++; | |
196 | } while (*p2cur != NULL); | |
197 | break; | |
198 | } | |
199 | /* If list2 is finished just tack list1 onto the end */ | |
200 | if (*p2cur == NULL) { | |
201 | do { | |
202 | *dst++ = **p1cur; | |
203 | p1cur++; | |
204 | } while (*p1cur != NULL); | |
205 | break; | |
206 | } | |
207 | /* consume the list element with the smaller key */ | |
fba140c7 | 208 | diff = OPENSSL_strcasecmp((*p1cur)->key, (*p2cur)->key); |
884314ca SL |
209 | if (diff == 0) { |
210 | /* If the keys are the same then throw away the list1 element */ | |
211 | *dst++ = **p2cur; | |
212 | p2cur++; | |
213 | p1cur++; | |
214 | } else if (diff > 0) { | |
215 | *dst++ = **p2cur; | |
216 | p2cur++; | |
217 | } else { | |
218 | *dst++ = **p1cur; | |
219 | p1cur++; | |
220 | } | |
221 | } | |
222 | return params; | |
223 | } | |
224 | ||
225 | void OSSL_PARAM_free(OSSL_PARAM *params) | |
226 | { | |
227 | if (params != NULL) { | |
228 | OSSL_PARAM *p; | |
229 | ||
230 | for (p = params; p->key != NULL; p++) | |
231 | ; | |
232 | if (p->data_type == OSSL_PARAM_ALLOCATED_END) | |
233 | OPENSSL_secure_clear_free(p->data, p->data_size); | |
234 | OPENSSL_free(params); | |
235 | } | |
236 | } |