2 * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved.
3 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
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
12 #include <openssl/err.h>
13 #include <openssl/cryptoerr.h>
14 #include <openssl/params.h>
15 #include <openssl/types.h>
16 #include <openssl/safestack.h>
17 #include "internal/param_build_set.h"
20 * Special internal param type to indicate the end of an allocate OSSL_PARAM
34 * These fields are never directly addressed, but their sizes are
35 * imporant so that all native types can be copied here without overrun.
43 DEFINE_STACK_OF(OSSL_PARAM_BLD_DEF
)
45 struct ossl_param_bld_st
{
48 STACK_OF(OSSL_PARAM_BLD_DEF
) *params
;
51 static OSSL_PARAM_BLD_DEF
*param_push(OSSL_PARAM_BLD
*bld
, const char *key
,
52 int size
, size_t alloc
, int type
,
55 OSSL_PARAM_BLD_DEF
*pd
= OPENSSL_zalloc(sizeof(*pd
));
58 ERR_raise(ERR_LIB_CRYPTO
, ERR_R_MALLOC_FAILURE
);
64 pd
->alloc_blocks
= ossl_param_bytes_to_blocks(alloc
);
65 if ((pd
->secure
= secure
) != 0)
66 bld
->secure_blocks
+= pd
->alloc_blocks
;
68 bld
->total_blocks
+= pd
->alloc_blocks
;
69 if (sk_OSSL_PARAM_BLD_DEF_push(bld
->params
, pd
) <= 0) {
76 static int param_push_num(OSSL_PARAM_BLD
*bld
, const char *key
,
77 void *num
, size_t size
, int type
)
79 OSSL_PARAM_BLD_DEF
*pd
= param_push(bld
, key
, size
, size
, type
, 0);
83 if (size
> sizeof(pd
->num
)) {
84 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_TOO_MANY_BYTES
);
87 memcpy(&pd
->num
, num
, size
);
91 OSSL_PARAM_BLD
*OSSL_PARAM_BLD_new(void)
93 OSSL_PARAM_BLD
*r
= OPENSSL_zalloc(sizeof(OSSL_PARAM_BLD
));
96 r
->params
= sk_OSSL_PARAM_BLD_DEF_new_null();
97 if (r
->params
== NULL
) {
105 static void free_all_params(OSSL_PARAM_BLD
*bld
)
107 int i
, n
= sk_OSSL_PARAM_BLD_DEF_num(bld
->params
);
109 for (i
= 0; i
< n
; i
++)
110 OPENSSL_free(sk_OSSL_PARAM_BLD_DEF_pop(bld
->params
));
113 void OSSL_PARAM_BLD_free(OSSL_PARAM_BLD
*bld
)
117 free_all_params(bld
);
118 sk_OSSL_PARAM_BLD_DEF_free(bld
->params
);
122 int OSSL_PARAM_BLD_push_int(OSSL_PARAM_BLD
*bld
, const char *key
, int num
)
124 return param_push_num(bld
, key
, &num
, sizeof(num
), OSSL_PARAM_INTEGER
);
127 int OSSL_PARAM_BLD_push_uint(OSSL_PARAM_BLD
*bld
, const char *key
,
130 return param_push_num(bld
, key
, &num
, sizeof(num
),
131 OSSL_PARAM_UNSIGNED_INTEGER
);
134 int OSSL_PARAM_BLD_push_long(OSSL_PARAM_BLD
*bld
, const char *key
,
137 return param_push_num(bld
, key
, &num
, sizeof(num
), OSSL_PARAM_INTEGER
);
140 int OSSL_PARAM_BLD_push_ulong(OSSL_PARAM_BLD
*bld
, const char *key
,
141 unsigned long int num
)
143 return param_push_num(bld
, key
, &num
, sizeof(num
),
144 OSSL_PARAM_UNSIGNED_INTEGER
);
147 int OSSL_PARAM_BLD_push_int32(OSSL_PARAM_BLD
*bld
, const char *key
,
150 return param_push_num(bld
, key
, &num
, sizeof(num
), OSSL_PARAM_INTEGER
);
153 int OSSL_PARAM_BLD_push_uint32(OSSL_PARAM_BLD
*bld
, const char *key
,
156 return param_push_num(bld
, key
, &num
, sizeof(num
),
157 OSSL_PARAM_UNSIGNED_INTEGER
);
160 int OSSL_PARAM_BLD_push_int64(OSSL_PARAM_BLD
*bld
, const char *key
,
163 return param_push_num(bld
, key
, &num
, sizeof(num
), OSSL_PARAM_INTEGER
);
166 int OSSL_PARAM_BLD_push_uint64(OSSL_PARAM_BLD
*bld
, const char *key
,
169 return param_push_num(bld
, key
, &num
, sizeof(num
),
170 OSSL_PARAM_UNSIGNED_INTEGER
);
173 int OSSL_PARAM_BLD_push_size_t(OSSL_PARAM_BLD
*bld
, const char *key
,
176 return param_push_num(bld
, key
, &num
, sizeof(num
),
177 OSSL_PARAM_UNSIGNED_INTEGER
);
180 int OSSL_PARAM_BLD_push_time_t(OSSL_PARAM_BLD
*bld
, const char *key
,
183 return param_push_num(bld
, key
, &num
, sizeof(num
),
187 int OSSL_PARAM_BLD_push_double(OSSL_PARAM_BLD
*bld
, const char *key
,
190 return param_push_num(bld
, key
, &num
, sizeof(num
), OSSL_PARAM_REAL
);
193 int OSSL_PARAM_BLD_push_BN(OSSL_PARAM_BLD
*bld
, const char *key
,
196 return OSSL_PARAM_BLD_push_BN_pad(bld
, key
, bn
,
197 bn
== NULL
? 0 : BN_num_bytes(bn
));
200 int OSSL_PARAM_BLD_push_BN_pad(OSSL_PARAM_BLD
*bld
, const char *key
,
201 const BIGNUM
*bn
, size_t sz
)
204 OSSL_PARAM_BLD_DEF
*pd
;
207 n
= BN_num_bytes(bn
);
209 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_ZERO_LENGTH_NUMBER
);
212 if (sz
< (size_t)n
) {
213 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_TOO_SMALL_BUFFER
);
216 if (BN_get_flags(bn
, BN_FLG_SECURE
) == BN_FLG_SECURE
)
219 pd
= param_push(bld
, key
, sz
, sz
, OSSL_PARAM_UNSIGNED_INTEGER
, secure
);
226 int OSSL_PARAM_BLD_push_utf8_string(OSSL_PARAM_BLD
*bld
, const char *key
,
227 const char *buf
, size_t bsize
)
229 OSSL_PARAM_BLD_DEF
*pd
;
234 } else if (bsize
> INT_MAX
) {
235 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_STRING_TOO_LONG
);
238 secure
= CRYPTO_secure_allocated(buf
);
239 pd
= param_push(bld
, key
, bsize
, bsize
+ 1, OSSL_PARAM_UTF8_STRING
, secure
);
246 int OSSL_PARAM_BLD_push_utf8_ptr(OSSL_PARAM_BLD
*bld
, const char *key
,
247 char *buf
, size_t bsize
)
249 OSSL_PARAM_BLD_DEF
*pd
;
253 } else if (bsize
> INT_MAX
) {
254 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_STRING_TOO_LONG
);
257 pd
= param_push(bld
, key
, bsize
, sizeof(buf
), OSSL_PARAM_UTF8_PTR
, 0);
264 int OSSL_PARAM_BLD_push_octet_string(OSSL_PARAM_BLD
*bld
, const char *key
,
265 const void *buf
, size_t bsize
)
267 OSSL_PARAM_BLD_DEF
*pd
;
270 if (bsize
> INT_MAX
) {
271 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_STRING_TOO_LONG
);
274 secure
= CRYPTO_secure_allocated(buf
);
275 pd
= param_push(bld
, key
, bsize
, bsize
, OSSL_PARAM_OCTET_STRING
, secure
);
282 int OSSL_PARAM_BLD_push_octet_ptr(OSSL_PARAM_BLD
*bld
, const char *key
,
283 void *buf
, size_t bsize
)
285 OSSL_PARAM_BLD_DEF
*pd
;
287 if (bsize
> INT_MAX
) {
288 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_STRING_TOO_LONG
);
291 pd
= param_push(bld
, key
, bsize
, sizeof(buf
), OSSL_PARAM_OCTET_PTR
, 0);
298 static OSSL_PARAM
*param_bld_convert(OSSL_PARAM_BLD
*bld
, OSSL_PARAM
*param
,
299 OSSL_PARAM_ALIGNED_BLOCK
*blk
,
300 OSSL_PARAM_ALIGNED_BLOCK
*secure
)
302 int i
, num
= sk_OSSL_PARAM_BLD_DEF_num(bld
->params
);
303 OSSL_PARAM_BLD_DEF
*pd
;
306 for (i
= 0; i
< num
; i
++) {
307 pd
= sk_OSSL_PARAM_BLD_DEF_value(bld
->params
, i
);
308 param
[i
].key
= pd
->key
;
309 param
[i
].data_type
= pd
->type
;
310 param
[i
].data_size
= pd
->size
;
311 param
[i
].return_size
= OSSL_PARAM_UNMODIFIED
;
315 secure
+= pd
->alloc_blocks
;
318 blk
+= pd
->alloc_blocks
;
321 if (pd
->bn
!= NULL
) {
323 BN_bn2nativepad(pd
->bn
, (unsigned char *)p
, pd
->size
);
324 } else if (pd
->type
== OSSL_PARAM_OCTET_PTR
325 || pd
->type
== OSSL_PARAM_UTF8_PTR
) {
327 *(const void **)p
= pd
->string
;
328 } else if (pd
->type
== OSSL_PARAM_OCTET_STRING
329 || pd
->type
== OSSL_PARAM_UTF8_STRING
) {
330 if (pd
->string
!= NULL
)
331 memcpy(p
, pd
->string
, pd
->size
);
333 memset(p
, 0, pd
->size
);
334 if (pd
->type
== OSSL_PARAM_UTF8_STRING
)
335 ((char *)p
)[pd
->size
] = '\0';
337 /* Number, but could also be a NULL BIGNUM */
338 if (pd
->size
> sizeof(pd
->num
))
339 memset(p
, 0, pd
->size
);
340 else if (pd
->size
> 0)
341 memcpy(p
, &pd
->num
, pd
->size
);
344 param
[i
] = OSSL_PARAM_construct_end();
348 OSSL_PARAM
*OSSL_PARAM_BLD_to_param(OSSL_PARAM_BLD
*bld
)
350 OSSL_PARAM_ALIGNED_BLOCK
*blk
, *s
= NULL
;
351 OSSL_PARAM
*params
, *last
;
352 const int num
= sk_OSSL_PARAM_BLD_DEF_num(bld
->params
);
353 const size_t p_blks
= ossl_param_bytes_to_blocks((1 + num
) * sizeof(*params
));
354 const size_t total
= OSSL_PARAM_ALIGN_SIZE
* (p_blks
+ bld
->total_blocks
);
355 const size_t ss
= OSSL_PARAM_ALIGN_SIZE
* bld
->secure_blocks
;
358 s
= OPENSSL_secure_malloc(ss
);
360 ERR_raise(ERR_LIB_CRYPTO
, CRYPTO_R_SECURE_MALLOC_FAILURE
);
364 params
= OPENSSL_malloc(total
);
365 if (params
== NULL
) {
366 ERR_raise(ERR_LIB_CRYPTO
, ERR_R_MALLOC_FAILURE
);
367 OPENSSL_secure_free(s
);
370 blk
= p_blks
+ (OSSL_PARAM_ALIGNED_BLOCK
*)(params
);
371 last
= param_bld_convert(bld
, params
, blk
, s
);
372 ossl_param_set_secure_block(last
, s
, ss
);
374 /* Reset builder for reuse */
375 bld
->total_blocks
= 0;
376 bld
->secure_blocks
= 0;
377 free_all_params(bld
);