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)
780 char *const q = OPENSSL_malloc(sz);
785 memcpy(q, p->data, sz);
790 memcpy(*val, p->data, sz);
794 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len)
796 return get_string_internal(p, (void **)val, max_len, NULL,
797 OSSL_PARAM_UTF8_STRING);
800 int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
803 return get_string_internal(p, val, max_len, used_len,
804 OSSL_PARAM_OCTET_STRING);
807 static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
810 p->return_size = len;
813 if (p->data_type != type || p->data_size < len)
816 memcpy(p->data, val, len);
820 int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
828 return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING);
831 int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
840 return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
843 OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
846 if (buf != NULL && bsize == 0)
847 bsize = strlen(buf) + 1;
848 return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
851 OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
854 return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
857 static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
858 size_t *used_len, unsigned int type)
860 if (val == NULL || p == NULL || p->data_type != type)
862 if (used_len != NULL)
863 *used_len = p->data_size;
864 *val = *(const void **)p->data;
868 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val)
870 return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR);
873 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
876 return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
879 static int set_ptr_internal(OSSL_PARAM *p, const void *val,
880 unsigned int type, size_t len)
882 p->return_size = len;
883 if (p->data_type != type)
886 *(const void **)p->data = val;
890 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
897 return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1);
900 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;