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 */
214 switch (p->data_size) {
215 case sizeof(int32_t):
216 *(int32_t *)p->data = val;
218 case sizeof(int64_t):
219 p->return_size = sizeof(int64_t);
220 *(int64_t *)p->data = (int64_t)val;
223 } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
224 p->return_size = sizeof(uint32_t); /* Minimum expected size */
225 switch (p->data_size) {
226 case sizeof(uint32_t):
227 *(uint32_t *)p->data = (uint32_t)val;
229 case sizeof(uint64_t):
230 p->return_size = sizeof(uint64_t);
231 *(uint64_t *)p->data = (uint64_t)val;
234 } else if (p->data_type == OSSL_PARAM_REAL) {
235 p->return_size = sizeof(double);
236 switch (p->data_size) {
238 *(double *)p->data = (double)val;
245 OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
247 return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf,
251 int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
258 if (val == NULL || p == NULL)
261 if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
262 switch (p->data_size) {
263 case sizeof(uint32_t):
264 *val = *(const uint32_t *)p->data;
266 case sizeof(uint64_t):
267 u64 = *(const uint64_t *)p->data;
268 if (u64 <= UINT32_MAX) {
269 *val = (uint32_t)u64;
274 } else if (p->data_type == OSSL_PARAM_INTEGER) {
275 switch (p->data_size) {
276 case sizeof(int32_t):
277 i32 = *(const int32_t *)p->data;
283 case sizeof(int64_t):
284 i64 = *(const int64_t *)p->data;
285 if (i64 >= 0 && i64 <= UINT32_MAX) {
286 *val = (uint32_t)i64;
291 } else if (p->data_type == OSSL_PARAM_REAL) {
292 switch (p->data_size) {
294 d = *(const double *)p->data;
295 if (d >= 0 && d <= UINT32_MAX && d == (uint32_t)d) {
305 int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
311 if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
312 p->return_size = sizeof(uint32_t); /* Minimum expected size */
313 switch (p->data_size) {
314 case sizeof(uint32_t):
315 *(uint32_t *)p->data = val;
317 case sizeof(uint64_t):
318 p->return_size = sizeof(uint64_t);
319 *(uint64_t *)p->data = val;
322 } else if (p->data_type == OSSL_PARAM_INTEGER) {
323 p->return_size = sizeof(int32_t); /* Minimum expected size */
324 switch (p->data_size) {
325 case sizeof(int32_t):
326 if (val <= INT32_MAX) {
327 *(int32_t *)p->data = (int32_t)val;
331 case sizeof(int64_t):
332 p->return_size = sizeof(int64_t);
333 *(int64_t *)p->data = (int64_t)val;
336 } else if (p->data_type == OSSL_PARAM_REAL) {
337 p->return_size = sizeof(double);
338 switch (p->data_size) {
340 *(double *)p->data = (double)val;
347 OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
349 return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
353 int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
358 if (val == NULL || p == NULL )
361 if (p->data_type == OSSL_PARAM_INTEGER) {
362 switch (p->data_size) {
363 case sizeof(int32_t):
364 *val = *(const int32_t *)p->data;
366 case sizeof(int64_t):
367 *val = *(const int64_t *)p->data;
370 } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
371 switch (p->data_size) {
372 case sizeof(uint32_t):
373 *val = *(const uint32_t *)p->data;
375 case sizeof(uint64_t):
376 u64 = *(const uint64_t *)p->data;
377 if (u64 <= INT64_MAX) {
383 } else if (p->data_type == OSSL_PARAM_REAL) {
384 switch (p->data_size) {
386 d = *(const double *)p->data;
387 if (d >= INT64_MIN && d <= INT64_MAX && d == (int64_t)d) {
397 int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
404 if (p->data_type == OSSL_PARAM_INTEGER) {
405 p->return_size = sizeof(int64_t); /* Expected size */
406 switch (p->data_size) {
407 case sizeof(int32_t):
408 if (val >= INT32_MIN && val <= INT32_MAX) {
409 p->return_size = sizeof(int32_t);
410 *(int32_t *)p->data = (int32_t)val;
414 case sizeof(int64_t):
415 *(int64_t *)p->data = val;
418 } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
419 p->return_size = sizeof(uint64_t); /* Expected size */
420 switch (p->data_size) {
421 case sizeof(uint32_t):
422 if (val <= UINT32_MAX) {
423 p->return_size = sizeof(uint32_t);
424 *(uint32_t *)p->data = (uint32_t)val;
428 case sizeof(uint64_t):
429 *(uint64_t *)p->data = (uint64_t)val;
432 } else if (p->data_type == OSSL_PARAM_REAL) {
433 p->return_size = sizeof(double);
434 switch (p->data_size) {
436 u64 = val < 0 ? -val : val;
437 if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
438 *(double *)p->data = (double)val;
447 OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
449 return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t));
452 int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
458 if (val == NULL || p == NULL)
461 if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
462 switch (p->data_size) {
463 case sizeof(uint32_t):
464 *val = *(const uint32_t *)p->data;
466 case sizeof(uint64_t):
467 *val = *(const uint64_t *)p->data;
470 } else if (p->data_type == OSSL_PARAM_INTEGER) {
471 switch (p->data_size) {
472 case sizeof(int32_t):
473 i32 = *(const int32_t *)p->data;
475 *val = (uint64_t)i32;
479 case sizeof(int64_t):
480 i64 = *(const int64_t *)p->data;
482 *val = (uint64_t)i64;
487 } else if (p->data_type == OSSL_PARAM_REAL) {
488 switch (p->data_size) {
490 d = *(const double *)p->data;
491 if (d >= 0 && d <= INT64_MAX && d == (uint64_t)d) {
501 int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
507 if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
508 p->return_size = sizeof(uint64_t); /* Expected size */
509 switch (p->data_size) {
510 case sizeof(uint32_t):
511 if (val <= UINT32_MAX) {
512 p->return_size = sizeof(uint32_t);
513 *(uint32_t *)p->data = (uint32_t)val;
517 case sizeof(uint64_t):
518 *(uint64_t *)p->data = val;
521 } else if (p->data_type == OSSL_PARAM_INTEGER) {
522 p->return_size = sizeof(int64_t); /* Expected size */
523 switch (p->data_size) {
524 case sizeof(int32_t):
525 if (val <= INT32_MAX) {
526 p->return_size = sizeof(int32_t);
527 *(int32_t *)p->data = (int32_t)val;
531 case sizeof(int64_t):
532 if (val <= INT64_MAX) {
533 *(int64_t *)p->data = (int64_t)val;
538 } else if (p->data_type == OSSL_PARAM_REAL) {
539 p->return_size = sizeof(double);
540 switch (p->data_size) {
542 if ((val >> 53) == 0) { /* 53 significant bits in the mantissa */
543 *(double *)p->data = (double)val;
552 OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
554 return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
558 int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
560 switch (sizeof(size_t)) {
561 case sizeof(uint32_t):
562 return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
563 case sizeof(uint64_t):
564 return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
569 int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
571 switch (sizeof(size_t)) {
572 case sizeof(uint32_t):
573 return OSSL_PARAM_set_uint32(p, (uint32_t)val);
574 case sizeof(uint64_t):
575 return OSSL_PARAM_set_uint64(p, (uint64_t)val);
580 OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
582 return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
586 int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val)
592 || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
595 b = BN_native2bn(p->data, (int)p->data_size, *val);
603 int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val)
610 if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
613 /* For the moment, only positive values are permitted */
614 if (BN_is_negative(val))
617 bytes = (size_t)BN_num_bytes(val);
618 p->return_size = bytes;
619 return p->data_size >= bytes
620 && BN_bn2nativepad(val, p->data, bytes) >= 0;
623 OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
626 return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER,
630 int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val)
635 if (val == NULL || p == NULL)
638 if (p->data_type == OSSL_PARAM_REAL) {
639 switch (p->data_size) {
641 *val = *(const double *)p->data;
644 } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
645 switch (p->data_size) {
646 case sizeof(uint32_t):
647 *val = *(const uint32_t *)p->data;
649 case sizeof(uint64_t):
650 u64 = *(const uint64_t *)p->data;
651 if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
657 } else if (p->data_type == OSSL_PARAM_INTEGER) {
658 switch (p->data_size) {
659 case sizeof(int32_t):
660 *val = *(const int32_t *)p->data;
662 case sizeof(int64_t):
663 i64 = *(const int64_t *)p->data;
664 u64 = i64 < 0 ? -i64 : i64;
665 if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
675 int OSSL_PARAM_set_double(OSSL_PARAM *p, double val)
681 if (p->data_type == OSSL_PARAM_REAL) {
682 p->return_size = sizeof(double);
683 switch (p->data_size) {
685 *(double *)p->data = val;
688 } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER
689 && val == (ossl_uintmax_t)val) {
690 p->return_size = sizeof(double);
691 switch (p->data_size) {
692 case sizeof(uint32_t):
693 if (val >= 0 && val <= UINT32_MAX) {
694 p->return_size = sizeof(uint32_t);
695 *(uint32_t *)p->data = (uint32_t)val;
699 case sizeof(uint64_t):
700 if (val >= 0 && val <= UINT64_MAX) {
701 p->return_size = sizeof(uint64_t);
702 *(uint64_t *)p->data = (uint64_t)val;
706 } else if (p->data_type == OSSL_PARAM_INTEGER && val == (ossl_intmax_t)val) {
707 p->return_size = sizeof(double);
708 switch (p->data_size) {
709 case sizeof(int32_t):
710 if (val >= INT32_MIN && val <= INT32_MAX) {
711 p->return_size = sizeof(int32_t);
712 *(int32_t *)p->data = (int32_t)val;
716 case sizeof(int64_t):
717 if (val >= INT64_MIN && val <= INT64_MAX) {
718 p->return_size = sizeof(int64_t);
719 *(int64_t *)p->data = (int64_t)val;
728 OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf)
730 return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double));
733 static int get_string_internal(const OSSL_PARAM *p, void **val, size_t max_len,
734 size_t *used_len, unsigned int type)
738 if (val == NULL || p == NULL || p->data_type != type)
743 if (used_len != NULL)
747 char *const q = OPENSSL_malloc(sz);
752 memcpy(q, p->data, sz);
757 memcpy(*val, p->data, sz);
761 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len)
763 return get_string_internal(p, (void **)val, max_len, NULL,
764 OSSL_PARAM_UTF8_STRING);
767 int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
770 return get_string_internal(p, val, max_len, used_len,
771 OSSL_PARAM_OCTET_STRING);
774 static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
777 p->return_size = len;
778 if (p->data_type != type || p->data_size < len)
781 memcpy(p->data, val, len);
785 int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
793 return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING);
796 int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
805 return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
808 OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
811 if (buf != NULL && bsize == 0)
812 bsize = strlen(buf) + 1;
813 return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
816 OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
819 return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
822 static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
823 size_t *used_len, unsigned int type)
825 if (val == NULL || p == NULL || p->data_type != type)
827 if (used_len != NULL)
828 *used_len = p->data_size;
829 *val = *(const void **)p->data;
833 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val)
835 return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR);
838 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
841 return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
844 static int set_ptr_internal(OSSL_PARAM *p, const void *val,
845 unsigned int type, size_t len)
847 p->return_size = len;
848 if (p->data_type != type)
850 *(const void **)p->data = val;
854 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
861 return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1);
864 int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
872 return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len);
875 OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
878 return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize);
881 OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
884 return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize);
887 OSSL_PARAM OSSL_PARAM_construct_end(void)
889 OSSL_PARAM end = OSSL_PARAM_END;