]>
Commit | Line | Data |
---|---|---|
3c93fbac | 1 | /* |
8020d79b | 2 | * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. |
3c93fbac P |
3 | * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved. |
4 | * | |
5 | * Licensed under the Apache License 2.0 (the "License"). You may not use | |
6 | * this file except in compliance with the License. You can obtain a copy | |
7 | * in the file LICENSE in the source distribution or at | |
8 | * https://www.openssl.org/source/license.html | |
9 | */ | |
10 | ||
11 | #include <string.h> | |
12 | #include <openssl/err.h> | |
13 | #include <openssl/cryptoerr.h> | |
14 | #include <openssl/params.h> | |
6d4e6009 | 15 | #include <openssl/types.h> |
20c98cd4 | 16 | #include <openssl/safestack.h> |
884314ca | 17 | #include "internal/param_build_set.h" |
3c93fbac | 18 | |
6d4e6009 P |
19 | /* |
20 | * Special internal param type to indicate the end of an allocate OSSL_PARAM | |
21 | * array. | |
22 | */ | |
7312ef3f | 23 | |
6d4e6009 P |
24 | typedef struct { |
25 | const char *key; | |
26 | int type; | |
27 | int secure; | |
28 | size_t size; | |
29 | size_t alloc_blocks; | |
30 | const BIGNUM *bn; | |
31 | const void *string; | |
32 | union { | |
33 | /* | |
34 | * These fields are never directly addressed, but their sizes are | |
35 | * imporant so that all native types can be copied here without overrun. | |
36 | */ | |
37 | ossl_intmax_t i; | |
38 | ossl_uintmax_t u; | |
39 | double d; | |
40 | } num; | |
41 | } OSSL_PARAM_BLD_DEF; | |
42 | ||
20c98cd4 P |
43 | DEFINE_STACK_OF(OSSL_PARAM_BLD_DEF) |
44 | ||
6d4e6009 | 45 | struct ossl_param_bld_st { |
6d4e6009 P |
46 | size_t total_blocks; |
47 | size_t secure_blocks; | |
20c98cd4 | 48 | STACK_OF(OSSL_PARAM_BLD_DEF) *params; |
6d4e6009 P |
49 | }; |
50 | ||
3c93fbac P |
51 | static OSSL_PARAM_BLD_DEF *param_push(OSSL_PARAM_BLD *bld, const char *key, |
52 | int size, size_t alloc, int type, | |
53 | int secure) | |
54 | { | |
20c98cd4 | 55 | OSSL_PARAM_BLD_DEF *pd = OPENSSL_zalloc(sizeof(*pd)); |
3c93fbac | 56 | |
20c98cd4 | 57 | if (pd == NULL) { |
9311d0c4 | 58 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE); |
3c93fbac P |
59 | return NULL; |
60 | } | |
3c93fbac P |
61 | pd->key = key; |
62 | pd->type = type; | |
63 | pd->size = size; | |
884314ca | 64 | pd->alloc_blocks = ossl_param_bytes_to_blocks(alloc); |
3c93fbac P |
65 | if ((pd->secure = secure) != 0) |
66 | bld->secure_blocks += pd->alloc_blocks; | |
67 | else | |
68 | bld->total_blocks += pd->alloc_blocks; | |
20c98cd4 P |
69 | if (sk_OSSL_PARAM_BLD_DEF_push(bld->params, pd) <= 0) { |
70 | OPENSSL_free(pd); | |
71 | pd = NULL; | |
72 | } | |
3c93fbac P |
73 | return pd; |
74 | } | |
75 | ||
76 | static int param_push_num(OSSL_PARAM_BLD *bld, const char *key, | |
77 | void *num, size_t size, int type) | |
78 | { | |
79 | OSSL_PARAM_BLD_DEF *pd = param_push(bld, key, size, size, type, 0); | |
80 | ||
3831351d P |
81 | if (pd == NULL) { |
82 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER); | |
3c93fbac | 83 | return 0; |
3831351d | 84 | } |
3c93fbac | 85 | if (size > sizeof(pd->num)) { |
9311d0c4 | 86 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_MANY_BYTES); |
3c93fbac P |
87 | return 0; |
88 | } | |
89 | memcpy(&pd->num, num, size); | |
90 | return 1; | |
91 | } | |
92 | ||
6d4e6009 | 93 | OSSL_PARAM_BLD *OSSL_PARAM_BLD_new(void) |
3c93fbac | 94 | { |
20c98cd4 P |
95 | OSSL_PARAM_BLD *r = OPENSSL_zalloc(sizeof(OSSL_PARAM_BLD)); |
96 | ||
97 | if (r != NULL) { | |
98 | r->params = sk_OSSL_PARAM_BLD_DEF_new_null(); | |
99 | if (r->params == NULL) { | |
100 | OPENSSL_free(r); | |
101 | r = NULL; | |
102 | } | |
103 | } | |
104 | return r; | |
105 | } | |
106 | ||
107 | static void free_all_params(OSSL_PARAM_BLD *bld) | |
108 | { | |
109 | int i, n = sk_OSSL_PARAM_BLD_DEF_num(bld->params); | |
110 | ||
111 | for (i = 0; i < n; i++) | |
112 | OPENSSL_free(sk_OSSL_PARAM_BLD_DEF_pop(bld->params)); | |
6d4e6009 P |
113 | } |
114 | ||
115 | void OSSL_PARAM_BLD_free(OSSL_PARAM_BLD *bld) | |
116 | { | |
a6f8a834 MC |
117 | if (bld == NULL) |
118 | return; | |
20c98cd4 P |
119 | free_all_params(bld); |
120 | sk_OSSL_PARAM_BLD_DEF_free(bld->params); | |
6d4e6009 | 121 | OPENSSL_free(bld); |
3c93fbac P |
122 | } |
123 | ||
110bff61 | 124 | int OSSL_PARAM_BLD_push_int(OSSL_PARAM_BLD *bld, const char *key, int num) |
3c93fbac P |
125 | { |
126 | return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER); | |
127 | } | |
128 | ||
110bff61 | 129 | int OSSL_PARAM_BLD_push_uint(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
130 | unsigned int num) |
131 | { | |
132 | return param_push_num(bld, key, &num, sizeof(num), | |
133 | OSSL_PARAM_UNSIGNED_INTEGER); | |
134 | } | |
135 | ||
110bff61 | 136 | int OSSL_PARAM_BLD_push_long(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
137 | long int num) |
138 | { | |
139 | return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER); | |
140 | } | |
141 | ||
110bff61 | 142 | int OSSL_PARAM_BLD_push_ulong(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
143 | unsigned long int num) |
144 | { | |
145 | return param_push_num(bld, key, &num, sizeof(num), | |
146 | OSSL_PARAM_UNSIGNED_INTEGER); | |
147 | } | |
148 | ||
110bff61 | 149 | int OSSL_PARAM_BLD_push_int32(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
150 | int32_t num) |
151 | { | |
152 | return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER); | |
153 | } | |
154 | ||
110bff61 | 155 | int OSSL_PARAM_BLD_push_uint32(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
156 | uint32_t num) |
157 | { | |
158 | return param_push_num(bld, key, &num, sizeof(num), | |
159 | OSSL_PARAM_UNSIGNED_INTEGER); | |
160 | } | |
161 | ||
110bff61 | 162 | int OSSL_PARAM_BLD_push_int64(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
163 | int64_t num) |
164 | { | |
165 | return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_INTEGER); | |
166 | } | |
167 | ||
110bff61 | 168 | int OSSL_PARAM_BLD_push_uint64(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
169 | uint64_t num) |
170 | { | |
171 | return param_push_num(bld, key, &num, sizeof(num), | |
172 | OSSL_PARAM_UNSIGNED_INTEGER); | |
173 | } | |
174 | ||
110bff61 | 175 | int OSSL_PARAM_BLD_push_size_t(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
176 | size_t num) |
177 | { | |
178 | return param_push_num(bld, key, &num, sizeof(num), | |
179 | OSSL_PARAM_UNSIGNED_INTEGER); | |
180 | } | |
181 | ||
5fdaa38f P |
182 | int OSSL_PARAM_BLD_push_time_t(OSSL_PARAM_BLD *bld, const char *key, |
183 | time_t num) | |
184 | { | |
185 | return param_push_num(bld, key, &num, sizeof(num), | |
186 | OSSL_PARAM_INTEGER); | |
187 | } | |
188 | ||
110bff61 | 189 | int OSSL_PARAM_BLD_push_double(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
190 | double num) |
191 | { | |
192 | return param_push_num(bld, key, &num, sizeof(num), OSSL_PARAM_REAL); | |
193 | } | |
194 | ||
110bff61 | 195 | int OSSL_PARAM_BLD_push_BN(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
196 | const BIGNUM *bn) |
197 | { | |
110bff61 | 198 | return OSSL_PARAM_BLD_push_BN_pad(bld, key, bn, |
ac23078b P |
199 | bn == NULL ? 0 : BN_num_bytes(bn)); |
200 | } | |
201 | ||
110bff61 | 202 | int OSSL_PARAM_BLD_push_BN_pad(OSSL_PARAM_BLD *bld, const char *key, |
ac23078b P |
203 | const BIGNUM *bn, size_t sz) |
204 | { | |
205 | int n, secure = 0; | |
3c93fbac P |
206 | OSSL_PARAM_BLD_DEF *pd; |
207 | ||
208 | if (bn != NULL) { | |
db65eabe RL |
209 | if (BN_is_negative(bn)) { |
210 | ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_UNSUPPORTED, | |
211 | "Negative big numbers are unsupported for OSSL_PARAM"); | |
212 | return 0; | |
213 | } | |
214 | ||
ac23078b P |
215 | n = BN_num_bytes(bn); |
216 | if (n < 0) { | |
9311d0c4 | 217 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_ZERO_LENGTH_NUMBER); |
ac23078b P |
218 | return 0; |
219 | } | |
220 | if (sz < (size_t)n) { | |
9311d0c4 | 221 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_SMALL_BUFFER); |
3c93fbac P |
222 | return 0; |
223 | } | |
224 | if (BN_get_flags(bn, BN_FLG_SECURE) == BN_FLG_SECURE) | |
225 | secure = 1; | |
226 | } | |
ac23078b | 227 | pd = param_push(bld, key, sz, sz, OSSL_PARAM_UNSIGNED_INTEGER, secure); |
3c93fbac P |
228 | if (pd == NULL) |
229 | return 0; | |
230 | pd->bn = bn; | |
231 | return 1; | |
232 | } | |
233 | ||
110bff61 | 234 | int OSSL_PARAM_BLD_push_utf8_string(OSSL_PARAM_BLD *bld, const char *key, |
5fa7789f | 235 | const char *buf, size_t bsize) |
3c93fbac P |
236 | { |
237 | OSSL_PARAM_BLD_DEF *pd; | |
b6b55ad9 | 238 | int secure; |
3c93fbac P |
239 | |
240 | if (bsize == 0) { | |
6be27456 | 241 | bsize = strlen(buf); |
3c93fbac | 242 | } else if (bsize > INT_MAX) { |
9311d0c4 | 243 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_STRING_TOO_LONG); |
3c93fbac P |
244 | return 0; |
245 | } | |
b6b55ad9 P |
246 | secure = CRYPTO_secure_allocated(buf); |
247 | pd = param_push(bld, key, bsize, bsize + 1, OSSL_PARAM_UTF8_STRING, secure); | |
3c93fbac P |
248 | if (pd == NULL) |
249 | return 0; | |
250 | pd->string = buf; | |
251 | return 1; | |
252 | } | |
253 | ||
110bff61 | 254 | int OSSL_PARAM_BLD_push_utf8_ptr(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
255 | char *buf, size_t bsize) |
256 | { | |
257 | OSSL_PARAM_BLD_DEF *pd; | |
258 | ||
259 | if (bsize == 0) { | |
6be27456 | 260 | bsize = strlen(buf); |
3c93fbac | 261 | } else if (bsize > INT_MAX) { |
9311d0c4 | 262 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_STRING_TOO_LONG); |
3c93fbac P |
263 | return 0; |
264 | } | |
265 | pd = param_push(bld, key, bsize, sizeof(buf), OSSL_PARAM_UTF8_PTR, 0); | |
266 | if (pd == NULL) | |
267 | return 0; | |
268 | pd->string = buf; | |
269 | return 1; | |
270 | } | |
271 | ||
110bff61 | 272 | int OSSL_PARAM_BLD_push_octet_string(OSSL_PARAM_BLD *bld, const char *key, |
5fa7789f | 273 | const void *buf, size_t bsize) |
3c93fbac P |
274 | { |
275 | OSSL_PARAM_BLD_DEF *pd; | |
b6b55ad9 | 276 | int secure; |
3c93fbac P |
277 | |
278 | if (bsize > INT_MAX) { | |
9311d0c4 | 279 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_STRING_TOO_LONG); |
3c93fbac P |
280 | return 0; |
281 | } | |
b6b55ad9 P |
282 | secure = CRYPTO_secure_allocated(buf); |
283 | pd = param_push(bld, key, bsize, bsize, OSSL_PARAM_OCTET_STRING, secure); | |
3c93fbac P |
284 | if (pd == NULL) |
285 | return 0; | |
286 | pd->string = buf; | |
287 | return 1; | |
288 | } | |
289 | ||
110bff61 | 290 | int OSSL_PARAM_BLD_push_octet_ptr(OSSL_PARAM_BLD *bld, const char *key, |
3c93fbac P |
291 | void *buf, size_t bsize) |
292 | { | |
293 | OSSL_PARAM_BLD_DEF *pd; | |
294 | ||
295 | if (bsize > INT_MAX) { | |
9311d0c4 | 296 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_STRING_TOO_LONG); |
3c93fbac P |
297 | return 0; |
298 | } | |
299 | pd = param_push(bld, key, bsize, sizeof(buf), OSSL_PARAM_OCTET_PTR, 0); | |
300 | if (pd == NULL) | |
301 | return 0; | |
302 | pd->string = buf; | |
303 | return 1; | |
304 | } | |
305 | ||
306 | static OSSL_PARAM *param_bld_convert(OSSL_PARAM_BLD *bld, OSSL_PARAM *param, | |
884314ca SL |
307 | OSSL_PARAM_ALIGNED_BLOCK *blk, |
308 | OSSL_PARAM_ALIGNED_BLOCK *secure) | |
3c93fbac | 309 | { |
20c98cd4 | 310 | int i, num = sk_OSSL_PARAM_BLD_DEF_num(bld->params); |
3c93fbac P |
311 | OSSL_PARAM_BLD_DEF *pd; |
312 | void *p; | |
313 | ||
20c98cd4 P |
314 | for (i = 0; i < num; i++) { |
315 | pd = sk_OSSL_PARAM_BLD_DEF_value(bld->params, i); | |
3c93fbac P |
316 | param[i].key = pd->key; |
317 | param[i].data_type = pd->type; | |
318 | param[i].data_size = pd->size; | |
2baf2d81 | 319 | param[i].return_size = OSSL_PARAM_UNMODIFIED; |
3c93fbac P |
320 | |
321 | if (pd->secure) { | |
322 | p = secure; | |
323 | secure += pd->alloc_blocks; | |
324 | } else { | |
325 | p = blk; | |
326 | blk += pd->alloc_blocks; | |
327 | } | |
328 | param[i].data = p; | |
329 | if (pd->bn != NULL) { | |
330 | /* BIGNUM */ | |
331 | BN_bn2nativepad(pd->bn, (unsigned char *)p, pd->size); | |
332 | } else if (pd->type == OSSL_PARAM_OCTET_PTR | |
333 | || pd->type == OSSL_PARAM_UTF8_PTR) { | |
334 | /* PTR */ | |
d32d3048 | 335 | *(const void **)p = pd->string; |
3c93fbac P |
336 | } else if (pd->type == OSSL_PARAM_OCTET_STRING |
337 | || pd->type == OSSL_PARAM_UTF8_STRING) { | |
338 | if (pd->string != NULL) | |
339 | memcpy(p, pd->string, pd->size); | |
340 | else | |
341 | memset(p, 0, pd->size); | |
6be27456 RL |
342 | if (pd->type == OSSL_PARAM_UTF8_STRING) |
343 | ((char *)p)[pd->size] = '\0'; | |
3c93fbac P |
344 | } else { |
345 | /* Number, but could also be a NULL BIGNUM */ | |
346 | if (pd->size > sizeof(pd->num)) | |
347 | memset(p, 0, pd->size); | |
348 | else if (pd->size > 0) | |
349 | memcpy(p, &pd->num, pd->size); | |
350 | } | |
351 | } | |
352 | param[i] = OSSL_PARAM_construct_end(); | |
7312ef3f | 353 | return param + i; |
3c93fbac P |
354 | } |
355 | ||
110bff61 | 356 | OSSL_PARAM *OSSL_PARAM_BLD_to_param(OSSL_PARAM_BLD *bld) |
3c93fbac | 357 | { |
884314ca | 358 | OSSL_PARAM_ALIGNED_BLOCK *blk, *s = NULL; |
7312ef3f | 359 | OSSL_PARAM *params, *last; |
20c98cd4 | 360 | const int num = sk_OSSL_PARAM_BLD_DEF_num(bld->params); |
884314ca SL |
361 | const size_t p_blks = ossl_param_bytes_to_blocks((1 + num) * sizeof(*params)); |
362 | const size_t total = OSSL_PARAM_ALIGN_SIZE * (p_blks + bld->total_blocks); | |
363 | const size_t ss = OSSL_PARAM_ALIGN_SIZE * bld->secure_blocks; | |
3c93fbac | 364 | |
7312ef3f P |
365 | if (ss > 0) { |
366 | s = OPENSSL_secure_malloc(ss); | |
3c93fbac | 367 | if (s == NULL) { |
9311d0c4 | 368 | ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_SECURE_MALLOC_FAILURE); |
3c93fbac P |
369 | return NULL; |
370 | } | |
371 | } | |
7312ef3f P |
372 | params = OPENSSL_malloc(total); |
373 | if (params == NULL) { | |
9311d0c4 | 374 | ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE); |
3c93fbac P |
375 | OPENSSL_secure_free(s); |
376 | return NULL; | |
377 | } | |
884314ca | 378 | blk = p_blks + (OSSL_PARAM_ALIGNED_BLOCK *)(params); |
7312ef3f | 379 | last = param_bld_convert(bld, params, blk, s); |
884314ca | 380 | ossl_param_set_secure_block(last, s, ss); |
6d4e6009 | 381 | |
20c98cd4 P |
382 | /* Reset builder for reuse */ |
383 | bld->total_blocks = 0; | |
384 | bld->secure_blocks = 0; | |
385 | free_all_params(bld); | |
7312ef3f P |
386 | return params; |
387 | } |