2 * Copyright 2019 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/params.h>
13 #include "internal/thread_once.h"
14 #include "internal/numbers.h"
16 OSSL_PARAM
*OSSL_PARAM_locate(OSSL_PARAM
*p
, const char *key
)
18 if (p
!= NULL
&& key
!= NULL
)
19 for (; p
->key
!= NULL
; p
++)
20 if (strcmp(key
, p
->key
) == 0)
25 const OSSL_PARAM
*OSSL_PARAM_locate_const(const OSSL_PARAM
*p
, const char *key
)
27 return OSSL_PARAM_locate((OSSL_PARAM
*)p
, key
);
30 static OSSL_PARAM
ossl_param_construct(const char *key
, unsigned int data_type
,
31 void *data
, size_t data_size
)
36 res
.data_type
= data_type
;
38 res
.data_size
= data_size
;
43 int OSSL_PARAM_get_int(const OSSL_PARAM
*p
, int *val
)
45 switch (sizeof(int)) {
47 return OSSL_PARAM_get_int32(p
, (int32_t *)val
);
49 return OSSL_PARAM_get_int64(p
, (int64_t *)val
);
54 int OSSL_PARAM_set_int(OSSL_PARAM
*p
, int val
)
56 switch (sizeof(int)) {
58 return OSSL_PARAM_set_int32(p
, (int32_t)val
);
60 return OSSL_PARAM_set_int64(p
, (int64_t)val
);
65 OSSL_PARAM
OSSL_PARAM_construct_int(const char *key
, int *buf
)
67 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
, sizeof(int));
70 int OSSL_PARAM_get_uint(const OSSL_PARAM
*p
, unsigned int *val
)
72 switch (sizeof(unsigned int)) {
73 case sizeof(uint32_t):
74 return OSSL_PARAM_get_uint32(p
, (uint32_t *)val
);
75 case sizeof(uint64_t):
76 return OSSL_PARAM_get_uint64(p
, (uint64_t *)val
);
81 int OSSL_PARAM_set_uint(OSSL_PARAM
*p
, unsigned int val
)
83 switch (sizeof(unsigned int)) {
84 case sizeof(uint32_t):
85 return OSSL_PARAM_set_uint32(p
, (uint32_t)val
);
86 case sizeof(uint64_t):
87 return OSSL_PARAM_set_uint64(p
, (uint64_t)val
);
92 OSSL_PARAM
OSSL_PARAM_construct_uint(const char *key
, unsigned int *buf
)
94 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
95 sizeof(unsigned int));
98 int OSSL_PARAM_get_long(const OSSL_PARAM
*p
, long int *val
)
100 switch (sizeof(long int)) {
101 case sizeof(int32_t):
102 return OSSL_PARAM_get_int32(p
, (int32_t *)val
);
103 case sizeof(int64_t):
104 return OSSL_PARAM_get_int64(p
, (int64_t *)val
);
109 int OSSL_PARAM_set_long(OSSL_PARAM
*p
, long int val
)
111 switch (sizeof(long int)) {
112 case sizeof(int32_t):
113 return OSSL_PARAM_set_int32(p
, (int32_t)val
);
114 case sizeof(int64_t):
115 return OSSL_PARAM_set_int64(p
, (int64_t)val
);
120 OSSL_PARAM
OSSL_PARAM_construct_long(const char *key
, long int *buf
)
122 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
, sizeof(long int));
125 int OSSL_PARAM_get_ulong(const OSSL_PARAM
*p
, unsigned long int *val
)
127 switch (sizeof(unsigned long int)) {
128 case sizeof(uint32_t):
129 return OSSL_PARAM_get_uint32(p
, (uint32_t *)val
);
130 case sizeof(uint64_t):
131 return OSSL_PARAM_get_uint64(p
, (uint64_t *)val
);
136 int OSSL_PARAM_set_ulong(OSSL_PARAM
*p
, unsigned long int val
)
138 switch (sizeof(unsigned long int)) {
139 case sizeof(uint32_t):
140 return OSSL_PARAM_set_uint32(p
, (uint32_t)val
);
141 case sizeof(uint64_t):
142 return OSSL_PARAM_set_uint64(p
, (uint64_t)val
);
147 OSSL_PARAM
OSSL_PARAM_construct_ulong(const char *key
, unsigned long int *buf
)
149 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
150 sizeof(unsigned long int));
153 int OSSL_PARAM_get_int32(const OSSL_PARAM
*p
, int32_t *val
)
160 if (val
== NULL
|| p
== NULL
)
163 if (p
->data_type
== OSSL_PARAM_INTEGER
) {
164 switch (p
->data_size
) {
165 case sizeof(int32_t):
166 *val
= *(const int32_t *)p
->data
;
168 case sizeof(int64_t):
169 i64
= *(const int64_t *)p
->data
;
170 if (i64
>= INT32_MIN
&& i64
<= INT32_MAX
) {
176 } else if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
177 switch (p
->data_size
) {
178 case sizeof(uint32_t):
179 u32
= *(const uint32_t *)p
->data
;
180 if (u32
<= INT32_MAX
) {
185 case sizeof(uint64_t):
186 u64
= *(const uint64_t *)p
->data
;
187 if (u64
<= INT32_MAX
) {
193 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
194 switch (p
->data_size
) {
196 d
= *(const double *)p
->data
;
197 if (d
>= INT32_MIN
&& d
<= INT32_MAX
&& d
== (int32_t)d
) {
207 int OSSL_PARAM_set_int32(OSSL_PARAM
*p
, int32_t val
)
212 if (p
->data_type
== OSSL_PARAM_INTEGER
) {
213 p
->return_size
= sizeof(int32_t); /* Minimum expected size */
216 switch (p
->data_size
) {
217 case sizeof(int32_t):
218 *(int32_t *)p
->data
= val
;
220 case sizeof(int64_t):
221 p
->return_size
= sizeof(int64_t);
222 *(int64_t *)p
->data
= (int64_t)val
;
225 } else if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
&& val
>= 0) {
226 p
->return_size
= sizeof(uint32_t); /* Minimum expected size */
229 switch (p
->data_size
) {
230 case sizeof(uint32_t):
231 *(uint32_t *)p
->data
= (uint32_t)val
;
233 case sizeof(uint64_t):
234 p
->return_size
= sizeof(uint64_t);
235 *(uint64_t *)p
->data
= (uint64_t)val
;
238 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
239 p
->return_size
= sizeof(double);
242 switch (p
->data_size
) {
244 *(double *)p
->data
= (double)val
;
251 OSSL_PARAM
OSSL_PARAM_construct_int32(const char *key
, int32_t *buf
)
253 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
,
257 int OSSL_PARAM_get_uint32(const OSSL_PARAM
*p
, uint32_t *val
)
264 if (val
== NULL
|| p
== NULL
)
267 if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
268 switch (p
->data_size
) {
269 case sizeof(uint32_t):
270 *val
= *(const uint32_t *)p
->data
;
272 case sizeof(uint64_t):
273 u64
= *(const uint64_t *)p
->data
;
274 if (u64
<= UINT32_MAX
) {
275 *val
= (uint32_t)u64
;
280 } else if (p
->data_type
== OSSL_PARAM_INTEGER
) {
281 switch (p
->data_size
) {
282 case sizeof(int32_t):
283 i32
= *(const int32_t *)p
->data
;
289 case sizeof(int64_t):
290 i64
= *(const int64_t *)p
->data
;
291 if (i64
>= 0 && i64
<= UINT32_MAX
) {
292 *val
= (uint32_t)i64
;
297 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
298 switch (p
->data_size
) {
300 d
= *(const double *)p
->data
;
301 if (d
>= 0 && d
<= UINT32_MAX
&& d
== (uint32_t)d
) {
311 int OSSL_PARAM_set_uint32(OSSL_PARAM
*p
, uint32_t val
)
317 if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
318 p
->return_size
= sizeof(uint32_t); /* Minimum expected size */
321 switch (p
->data_size
) {
322 case sizeof(uint32_t):
323 *(uint32_t *)p
->data
= val
;
325 case sizeof(uint64_t):
326 p
->return_size
= sizeof(uint64_t);
327 *(uint64_t *)p
->data
= val
;
330 } else if (p
->data_type
== OSSL_PARAM_INTEGER
) {
331 p
->return_size
= sizeof(int32_t); /* Minimum expected size */
334 switch (p
->data_size
) {
335 case sizeof(int32_t):
336 if (val
<= INT32_MAX
) {
337 *(int32_t *)p
->data
= (int32_t)val
;
341 case sizeof(int64_t):
342 p
->return_size
= sizeof(int64_t);
343 *(int64_t *)p
->data
= (int64_t)val
;
346 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
347 p
->return_size
= sizeof(double);
350 switch (p
->data_size
) {
352 *(double *)p
->data
= (double)val
;
359 OSSL_PARAM
OSSL_PARAM_construct_uint32(const char *key
, uint32_t *buf
)
361 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
365 int OSSL_PARAM_get_int64(const OSSL_PARAM
*p
, int64_t *val
)
370 if (val
== NULL
|| p
== NULL
)
373 if (p
->data_type
== OSSL_PARAM_INTEGER
) {
374 switch (p
->data_size
) {
375 case sizeof(int32_t):
376 *val
= *(const int32_t *)p
->data
;
378 case sizeof(int64_t):
379 *val
= *(const int64_t *)p
->data
;
382 } else if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
383 switch (p
->data_size
) {
384 case sizeof(uint32_t):
385 *val
= *(const uint32_t *)p
->data
;
387 case sizeof(uint64_t):
388 u64
= *(const uint64_t *)p
->data
;
389 if (u64
<= INT64_MAX
) {
395 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
396 switch (p
->data_size
) {
398 d
= *(const double *)p
->data
;
399 if (d
>= INT64_MIN
&& d
<= INT64_MAX
&& d
== (int64_t)d
) {
409 int OSSL_PARAM_set_int64(OSSL_PARAM
*p
, int64_t val
)
416 if (p
->data_type
== OSSL_PARAM_INTEGER
) {
417 p
->return_size
= sizeof(int64_t); /* Expected size */
420 switch (p
->data_size
) {
421 case sizeof(int32_t):
422 if (val
>= INT32_MIN
&& val
<= INT32_MAX
) {
423 p
->return_size
= sizeof(int32_t);
424 *(int32_t *)p
->data
= (int32_t)val
;
428 case sizeof(int64_t):
429 *(int64_t *)p
->data
= val
;
432 } else if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
&& val
>= 0) {
433 p
->return_size
= sizeof(uint64_t); /* Expected size */
436 switch (p
->data_size
) {
437 case sizeof(uint32_t):
438 if (val
<= UINT32_MAX
) {
439 p
->return_size
= sizeof(uint32_t);
440 *(uint32_t *)p
->data
= (uint32_t)val
;
444 case sizeof(uint64_t):
445 *(uint64_t *)p
->data
= (uint64_t)val
;
448 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
449 p
->return_size
= sizeof(double);
452 switch (p
->data_size
) {
454 u64
= val
< 0 ? -val
: val
;
455 if ((u64
>> 53) == 0) { /* 53 significant bits in the mantissa */
456 *(double *)p
->data
= (double)val
;
465 OSSL_PARAM
OSSL_PARAM_construct_int64(const char *key
, int64_t *buf
)
467 return ossl_param_construct(key
, OSSL_PARAM_INTEGER
, buf
, sizeof(int64_t));
470 int OSSL_PARAM_get_uint64(const OSSL_PARAM
*p
, uint64_t *val
)
476 if (val
== NULL
|| p
== NULL
)
479 if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
480 switch (p
->data_size
) {
481 case sizeof(uint32_t):
482 *val
= *(const uint32_t *)p
->data
;
484 case sizeof(uint64_t):
485 *val
= *(const uint64_t *)p
->data
;
488 } else if (p
->data_type
== OSSL_PARAM_INTEGER
) {
489 switch (p
->data_size
) {
490 case sizeof(int32_t):
491 i32
= *(const int32_t *)p
->data
;
493 *val
= (uint64_t)i32
;
497 case sizeof(int64_t):
498 i64
= *(const int64_t *)p
->data
;
500 *val
= (uint64_t)i64
;
505 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
506 switch (p
->data_size
) {
508 d
= *(const double *)p
->data
;
509 if (d
>= 0 && d
<= INT64_MAX
&& d
== (uint64_t)d
) {
519 int OSSL_PARAM_set_uint64(OSSL_PARAM
*p
, uint64_t val
)
525 if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
526 p
->return_size
= sizeof(uint64_t); /* Expected size */
529 switch (p
->data_size
) {
530 case sizeof(uint32_t):
531 if (val
<= UINT32_MAX
) {
532 p
->return_size
= sizeof(uint32_t);
533 *(uint32_t *)p
->data
= (uint32_t)val
;
537 case sizeof(uint64_t):
538 *(uint64_t *)p
->data
= val
;
541 } else if (p
->data_type
== OSSL_PARAM_INTEGER
) {
542 p
->return_size
= sizeof(int64_t); /* Expected size */
545 switch (p
->data_size
) {
546 case sizeof(int32_t):
547 if (val
<= INT32_MAX
) {
548 p
->return_size
= sizeof(int32_t);
549 *(int32_t *)p
->data
= (int32_t)val
;
553 case sizeof(int64_t):
554 if (val
<= INT64_MAX
) {
555 *(int64_t *)p
->data
= (int64_t)val
;
560 } else if (p
->data_type
== OSSL_PARAM_REAL
) {
561 p
->return_size
= sizeof(double);
562 switch (p
->data_size
) {
564 if ((val
>> 53) == 0) { /* 53 significant bits in the mantissa */
565 *(double *)p
->data
= (double)val
;
574 OSSL_PARAM
OSSL_PARAM_construct_uint64(const char *key
, uint64_t *buf
)
576 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
580 int OSSL_PARAM_get_size_t(const OSSL_PARAM
*p
, size_t *val
)
582 switch (sizeof(size_t)) {
583 case sizeof(uint32_t):
584 return OSSL_PARAM_get_uint32(p
, (uint32_t *)val
);
585 case sizeof(uint64_t):
586 return OSSL_PARAM_get_uint64(p
, (uint64_t *)val
);
591 int OSSL_PARAM_set_size_t(OSSL_PARAM
*p
, size_t val
)
593 switch (sizeof(size_t)) {
594 case sizeof(uint32_t):
595 return OSSL_PARAM_set_uint32(p
, (uint32_t)val
);
596 case sizeof(uint64_t):
597 return OSSL_PARAM_set_uint64(p
, (uint64_t)val
);
602 OSSL_PARAM
OSSL_PARAM_construct_size_t(const char *key
, size_t *buf
)
604 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
, buf
,
608 int OSSL_PARAM_get_BN(const OSSL_PARAM
*p
, BIGNUM
**val
)
614 || p
->data_type
!= OSSL_PARAM_UNSIGNED_INTEGER
)
617 b
= BN_native2bn(p
->data
, (int)p
->data_size
, *val
);
625 int OSSL_PARAM_set_BN(OSSL_PARAM
*p
, const BIGNUM
*val
)
632 if (val
== NULL
|| p
->data_type
!= OSSL_PARAM_UNSIGNED_INTEGER
)
635 /* For the moment, only positive values are permitted */
636 if (BN_is_negative(val
))
639 bytes
= (size_t)BN_num_bytes(val
);
640 p
->return_size
= bytes
;
643 if (p
->data_size
>= bytes
) {
644 p
->return_size
= p
->data_size
;
645 return BN_bn2nativepad(val
, p
->data
, p
->data_size
) >= 0;
650 OSSL_PARAM
OSSL_PARAM_construct_BN(const char *key
, unsigned char *buf
,
653 return ossl_param_construct(key
, OSSL_PARAM_UNSIGNED_INTEGER
,
657 int OSSL_PARAM_get_double(const OSSL_PARAM
*p
, double *val
)
662 if (val
== NULL
|| p
== NULL
)
665 if (p
->data_type
== OSSL_PARAM_REAL
) {
666 switch (p
->data_size
) {
668 *val
= *(const double *)p
->data
;
671 } else if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
) {
672 switch (p
->data_size
) {
673 case sizeof(uint32_t):
674 *val
= *(const uint32_t *)p
->data
;
676 case sizeof(uint64_t):
677 u64
= *(const uint64_t *)p
->data
;
678 if ((u64
>> 53) == 0) { /* 53 significant bits in the mantissa */
684 } else if (p
->data_type
== OSSL_PARAM_INTEGER
) {
685 switch (p
->data_size
) {
686 case sizeof(int32_t):
687 *val
= *(const int32_t *)p
->data
;
689 case sizeof(int64_t):
690 i64
= *(const int64_t *)p
->data
;
691 u64
= i64
< 0 ? -i64
: i64
;
692 if ((u64
>> 53) == 0) { /* 53 significant bits in the mantissa */
702 int OSSL_PARAM_set_double(OSSL_PARAM
*p
, double val
)
708 if (p
->data_type
== OSSL_PARAM_REAL
) {
709 p
->return_size
= sizeof(double);
712 switch (p
->data_size
) {
714 *(double *)p
->data
= val
;
717 } else if (p
->data_type
== OSSL_PARAM_UNSIGNED_INTEGER
718 && val
== (ossl_uintmax_t
)val
) {
719 p
->return_size
= sizeof(double);
722 switch (p
->data_size
) {
723 case sizeof(uint32_t):
724 if (val
>= 0 && val
<= UINT32_MAX
) {
725 p
->return_size
= sizeof(uint32_t);
726 *(uint32_t *)p
->data
= (uint32_t)val
;
730 case sizeof(uint64_t):
731 if (val
>= 0 && val
<= UINT64_MAX
) {
732 p
->return_size
= sizeof(uint64_t);
733 *(uint64_t *)p
->data
= (uint64_t)val
;
737 } else if (p
->data_type
== OSSL_PARAM_INTEGER
&& val
== (ossl_intmax_t
)val
) {
738 p
->return_size
= sizeof(double);
741 switch (p
->data_size
) {
742 case sizeof(int32_t):
743 if (val
>= INT32_MIN
&& val
<= INT32_MAX
) {
744 p
->return_size
= sizeof(int32_t);
745 *(int32_t *)p
->data
= (int32_t)val
;
749 case sizeof(int64_t):
750 if (val
>= INT64_MIN
&& val
<= INT64_MAX
) {
751 p
->return_size
= sizeof(int64_t);
752 *(int64_t *)p
->data
= (int64_t)val
;
761 OSSL_PARAM
OSSL_PARAM_construct_double(const char *key
, double *buf
)
763 return ossl_param_construct(key
, OSSL_PARAM_REAL
, buf
, sizeof(double));
766 static int get_string_internal(const OSSL_PARAM
*p
, void **val
, size_t max_len
,
767 size_t *used_len
, unsigned int type
)
771 if (val
== NULL
|| p
== NULL
|| p
->data_type
!= type
)
776 if (used_len
!= NULL
)
783 char *const q
= OPENSSL_malloc(sz
);
788 memcpy(q
, p
->data
, sz
);
793 memcpy(*val
, p
->data
, sz
);
797 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM
*p
, char **val
, size_t max_len
)
799 return get_string_internal(p
, (void **)val
, max_len
, NULL
,
800 OSSL_PARAM_UTF8_STRING
);
803 int OSSL_PARAM_get_octet_string(const OSSL_PARAM
*p
, void **val
, size_t max_len
,
806 return get_string_internal(p
, val
, max_len
, used_len
,
807 OSSL_PARAM_OCTET_STRING
);
810 static int set_string_internal(OSSL_PARAM
*p
, const void *val
, size_t len
,
813 p
->return_size
= len
;
816 if (p
->data_type
!= type
|| p
->data_size
< len
)
819 memcpy(p
->data
, val
, len
);
823 int OSSL_PARAM_set_utf8_string(OSSL_PARAM
*p
, const char *val
)
831 return set_string_internal(p
, val
, strlen(val
) + 1, OSSL_PARAM_UTF8_STRING
);
834 int OSSL_PARAM_set_octet_string(OSSL_PARAM
*p
, const void *val
,
843 return set_string_internal(p
, val
, len
, OSSL_PARAM_OCTET_STRING
);
846 OSSL_PARAM
OSSL_PARAM_construct_utf8_string(const char *key
, char *buf
,
849 if (buf
!= NULL
&& bsize
== 0)
850 bsize
= strlen(buf
) + 1;
851 return ossl_param_construct(key
, OSSL_PARAM_UTF8_STRING
, buf
, bsize
);
854 OSSL_PARAM
OSSL_PARAM_construct_octet_string(const char *key
, void *buf
,
857 return ossl_param_construct(key
, OSSL_PARAM_OCTET_STRING
, buf
, bsize
);
860 static int get_ptr_internal(const OSSL_PARAM
*p
, const void **val
,
861 size_t *used_len
, unsigned int type
)
863 if (val
== NULL
|| p
== NULL
|| p
->data_type
!= type
)
865 if (used_len
!= NULL
)
866 *used_len
= p
->data_size
;
867 *val
= *(const void **)p
->data
;
871 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM
*p
, const char **val
)
873 return get_ptr_internal(p
, (const void **)val
, NULL
, OSSL_PARAM_UTF8_PTR
);
876 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM
*p
, const void **val
,
879 return get_ptr_internal(p
, val
, used_len
, OSSL_PARAM_OCTET_PTR
);
882 static int set_ptr_internal(OSSL_PARAM
*p
, const void *val
,
883 unsigned int type
, size_t len
)
885 p
->return_size
= len
;
886 if (p
->data_type
!= type
)
889 *(const void **)p
->data
= val
;
893 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM
*p
, const char *val
)
898 return set_ptr_internal(p
, val
, OSSL_PARAM_UTF8_PTR
,
899 val
== NULL
? 0 : strlen(val
) + 1);
902 int OSSL_PARAM_set_octet_ptr(OSSL_PARAM
*p
, const void *val
,
908 return set_ptr_internal(p
, val
, OSSL_PARAM_OCTET_PTR
, used_len
);
911 OSSL_PARAM
OSSL_PARAM_construct_utf8_ptr(const char *key
, char **buf
,
914 return ossl_param_construct(key
, OSSL_PARAM_UTF8_PTR
, buf
, bsize
);
917 OSSL_PARAM
OSSL_PARAM_construct_octet_ptr(const char *key
, void **buf
,
920 return ossl_param_construct(key
, OSSL_PARAM_OCTET_PTR
, buf
, bsize
);
923 OSSL_PARAM
OSSL_PARAM_construct_end(void)
925 OSSL_PARAM end
= OSSL_PARAM_END
;