xref: /openssl/crypto/params.c (revision 7bc10f6c)
1 /*
2  * Copyright 2019-2024 The OpenSSL Project Authors. All Rights Reserved.
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/params.h>
13 #include <openssl/err.h>
14 #include "internal/thread_once.h"
15 #include "internal/numbers.h"
16 #include "internal/endian.h"
17 #include "internal/params.h"
18 #include "internal/packet.h"
19 
20 /* Shortcuts for raising errors that are widely used */
21 #define err_unsigned_negative \
22     ERR_raise(ERR_LIB_CRYPTO, \
23               CRYPTO_R_PARAM_UNSIGNED_INTEGER_NEGATIVE_VALUE_UNSUPPORTED)
24 #define err_out_of_range      \
25     ERR_raise(ERR_LIB_CRYPTO, \
26               CRYPTO_R_PARAM_VALUE_TOO_LARGE_FOR_DESTINATION)
27 #define err_inexact           \
28     ERR_raise(ERR_LIB_CRYPTO, \
29               CRYPTO_R_PARAM_CANNOT_BE_REPRESENTED_EXACTLY)
30 #define err_not_integer       \
31     ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_PARAM_NOT_INTEGER_TYPE)
32 #define err_too_small         \
33     ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_SMALL_BUFFER)
34 #define err_bad_type          \
35     ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_PARAM_OF_INCOMPATIBLE_TYPE)
36 #define err_null_argument     \
37     ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_NULL_PARAMETER)
38 #define err_unsupported_real  \
39     ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_PARAM_UNSUPPORTED_FLOATING_POINT_FORMAT)
40 
41 #ifndef OPENSSL_SYS_UEFI
42 /*
43  * Return the number of bits in the mantissa of a double.  This is used to
44  * shift a larger integral value to determine if it will exactly fit into a
45  * double.
46  */
real_shift(void)47 static unsigned int real_shift(void)
48 {
49     return sizeof(double) == 4 ? 24 : 53;
50 }
51 #endif
52 
OSSL_PARAM_locate(OSSL_PARAM * p,const char * key)53 OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key)
54 {
55     if (p != NULL && key != NULL)
56         for (; p->key != NULL; p++)
57             if (strcmp(key, p->key) == 0)
58                 return p;
59     return NULL;
60 }
61 
OSSL_PARAM_locate_const(const OSSL_PARAM * p,const char * key)62 const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key)
63 {
64     return OSSL_PARAM_locate((OSSL_PARAM *)p, key);
65 }
66 
ossl_param_construct(const char * key,unsigned int data_type,void * data,size_t data_size)67 static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
68                                        void *data, size_t data_size)
69 {
70     OSSL_PARAM res;
71 
72     res.key = key;
73     res.data_type = data_type;
74     res.data = data;
75     res.data_size = data_size;
76     res.return_size = OSSL_PARAM_UNMODIFIED;
77     return res;
78 }
79 
OSSL_PARAM_modified(const OSSL_PARAM * p)80 int OSSL_PARAM_modified(const OSSL_PARAM *p)
81 {
82     return p != NULL && p->return_size != OSSL_PARAM_UNMODIFIED;
83 }
84 
OSSL_PARAM_set_all_unmodified(OSSL_PARAM * p)85 void OSSL_PARAM_set_all_unmodified(OSSL_PARAM *p)
86 {
87     if (p != NULL)
88         while (p->key != NULL)
89             p++->return_size = OSSL_PARAM_UNMODIFIED;
90 }
91 
92 /* Return non-zero if the signed number is negative */
is_negative(const void * number,size_t s)93 static int is_negative(const void *number, size_t s)
94 {
95     const unsigned char *n = number;
96     DECLARE_IS_ENDIAN;
97 
98     return 0x80 & (IS_BIG_ENDIAN ? n[0] : n[s - 1]);
99 }
100 
101 /* Check that all the bytes specified match the expected sign byte */
check_sign_bytes(const unsigned char * p,size_t n,unsigned char s)102 static int check_sign_bytes(const unsigned char *p, size_t n, unsigned char s)
103 {
104     size_t i;
105 
106     for (i = 0; i < n; i++)
107         if (p[i] != s)
108             return 0;
109     return 1;
110 }
111 
112 /*
113  * Copy an integer to another integer.
114  * Handle different length integers and signed and unsigned integers.
115  * Both integers are in native byte ordering.
116  */
copy_integer(unsigned char * dest,size_t dest_len,const unsigned char * src,size_t src_len,unsigned char pad,int signed_int)117 static int copy_integer(unsigned char *dest, size_t dest_len,
118                         const unsigned char *src, size_t src_len,
119                         unsigned char pad, int signed_int)
120 {
121     size_t n;
122     DECLARE_IS_ENDIAN;
123 
124     if (IS_BIG_ENDIAN) {
125         if (src_len < dest_len) {
126             n = dest_len - src_len;
127             memset(dest, pad, n);
128             memcpy(dest + n, src, src_len);
129         } else {
130             n = src_len - dest_len;
131             if (!check_sign_bytes(src, n, pad)
132                     /*
133                      * Shortening a signed value must retain the correct sign.
134                      * Avoiding this kind of thing: -253 = 0xff03 -> 0x03 = 3
135                      */
136                     || (signed_int && ((pad ^ src[n]) & 0x80) != 0)) {
137                 err_out_of_range;
138                 return 0;
139             }
140             memcpy(dest, src + n, dest_len);
141         }
142     } else /* IS_LITTLE_ENDIAN */ {
143         if (src_len < dest_len) {
144             n = dest_len - src_len;
145             memset(dest + src_len, pad, n);
146             memcpy(dest, src, src_len);
147         } else {
148             n = src_len - dest_len;
149             if (!check_sign_bytes(src + dest_len, n, pad)
150                     /*
151                      * Shortening a signed value must retain the correct sign.
152                      * Avoiding this kind of thing: 130 = 0x0082 -> 0x82 = -126
153                      */
154                     || (signed_int && ((pad ^ src[dest_len - 1]) & 0x80) != 0)) {
155                 err_out_of_range;
156                 return 0;
157             }
158             memcpy(dest, src, dest_len);
159         }
160     }
161     return 1;
162 }
163 
164 /* Copy a signed number to a signed number of possibly different length */
signed_from_signed(void * dest,size_t dest_len,const void * src,size_t src_len)165 static int signed_from_signed(void *dest, size_t dest_len,
166                               const void *src, size_t src_len)
167 {
168     return copy_integer(dest, dest_len, src, src_len,
169                         is_negative(src, src_len) ? 0xff : 0, 1);
170 }
171 
172 /* Copy an unsigned number to a signed number of possibly different length */
signed_from_unsigned(void * dest,size_t dest_len,const void * src,size_t src_len)173 static int signed_from_unsigned(void *dest, size_t dest_len,
174                                 const void *src, size_t src_len)
175 {
176     return copy_integer(dest, dest_len, src, src_len, 0, 1);
177 }
178 
179 /* Copy a signed number to an unsigned number of possibly different length */
unsigned_from_signed(void * dest,size_t dest_len,const void * src,size_t src_len)180 static int unsigned_from_signed(void *dest, size_t dest_len,
181                                 const void *src, size_t src_len)
182 {
183     if (is_negative(src, src_len)) {
184         err_unsigned_negative;
185         return 0;
186     }
187     return copy_integer(dest, dest_len, src, src_len, 0, 0);
188 }
189 
190 /* Copy an unsigned number to an unsigned number of possibly different length */
unsigned_from_unsigned(void * dest,size_t dest_len,const void * src,size_t src_len)191 static int unsigned_from_unsigned(void *dest, size_t dest_len,
192                                   const void *src, size_t src_len)
193 {
194     return copy_integer(dest, dest_len, src, src_len, 0, 0);
195 }
196 
197 /* General purpose get integer parameter call that handles odd sizes */
general_get_int(const OSSL_PARAM * p,void * val,size_t val_size)198 static int general_get_int(const OSSL_PARAM *p, void *val, size_t val_size)
199 {
200     if (p->data == NULL) {
201         err_null_argument;
202         return 0;
203     }
204     if (p->data_type == OSSL_PARAM_INTEGER)
205         return signed_from_signed(val, val_size, p->data, p->data_size);
206     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
207         return signed_from_unsigned(val, val_size, p->data, p->data_size);
208     err_not_integer;
209     return 0;
210 }
211 
212 /* General purpose set integer parameter call that handles odd sizes */
general_set_int(OSSL_PARAM * p,void * val,size_t val_size)213 static int general_set_int(OSSL_PARAM *p, void *val, size_t val_size)
214 {
215     int r = 0;
216 
217     p->return_size = val_size; /* Expected size */
218     if (p->data == NULL)
219         return 1;
220     if (p->data_type == OSSL_PARAM_INTEGER)
221         r = signed_from_signed(p->data, p->data_size, val, val_size);
222     else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
223         r = unsigned_from_signed(p->data, p->data_size, val, val_size);
224     else
225         err_not_integer;
226     p->return_size = r ? p->data_size : val_size;
227     return r;
228 }
229 
230 /* General purpose get unsigned integer parameter call that handles odd sizes */
general_get_uint(const OSSL_PARAM * p,void * val,size_t val_size)231 static int general_get_uint(const OSSL_PARAM *p, void *val, size_t val_size)
232 {
233 
234     if (p->data == NULL) {
235         err_null_argument;
236         return 0;
237     }
238     if (p->data_type == OSSL_PARAM_INTEGER)
239         return unsigned_from_signed(val, val_size, p->data, p->data_size);
240     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
241         return unsigned_from_unsigned(val, val_size, p->data, p->data_size);
242     err_not_integer;
243     return 0;
244 }
245 
246 /* General purpose set unsigned integer parameter call that handles odd sizes */
general_set_uint(OSSL_PARAM * p,void * val,size_t val_size)247 static int general_set_uint(OSSL_PARAM *p, void *val, size_t val_size)
248 {
249     int r = 0;
250 
251     p->return_size = val_size; /* Expected size */
252     if (p->data == NULL)
253         return 1;
254     if (p->data_type == OSSL_PARAM_INTEGER)
255         r = signed_from_unsigned(p->data, p->data_size, val, val_size);
256     else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
257         r = unsigned_from_unsigned(p->data, p->data_size, val, val_size);
258     else
259         err_not_integer;
260     p->return_size = r ? p->data_size : val_size;
261     return r;
262 }
263 
OSSL_PARAM_get_int(const OSSL_PARAM * p,int * val)264 int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val)
265 {
266 #ifndef OPENSSL_SMALL_FOOTPRINT
267     switch (sizeof(int)) {
268     case sizeof(int32_t):
269         return OSSL_PARAM_get_int32(p, (int32_t *)val);
270     case sizeof(int64_t):
271         return OSSL_PARAM_get_int64(p, (int64_t *)val);
272     }
273 #endif
274     return general_get_int(p, val, sizeof(*val));
275 }
276 
OSSL_PARAM_set_int(OSSL_PARAM * p,int val)277 int OSSL_PARAM_set_int(OSSL_PARAM *p, int val)
278 {
279 #ifndef OPENSSL_SMALL_FOOTPRINT
280     switch (sizeof(int)) {
281     case sizeof(int32_t):
282         return OSSL_PARAM_set_int32(p, (int32_t)val);
283     case sizeof(int64_t):
284         return OSSL_PARAM_set_int64(p, (int64_t)val);
285     }
286 #endif
287     return general_set_int(p, &val, sizeof(val));
288 }
289 
OSSL_PARAM_construct_int(const char * key,int * buf)290 OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
291 {
292     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int));
293 }
294 
OSSL_PARAM_get_uint(const OSSL_PARAM * p,unsigned int * val)295 int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
296 {
297 #ifndef OPENSSL_SMALL_FOOTPRINT
298     switch (sizeof(unsigned int)) {
299     case sizeof(uint32_t):
300         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
301     case sizeof(uint64_t):
302         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
303     }
304 #endif
305     return general_get_uint(p, val, sizeof(*val));
306 }
307 
OSSL_PARAM_set_uint(OSSL_PARAM * p,unsigned int val)308 int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val)
309 {
310 #ifndef OPENSSL_SMALL_FOOTPRINT
311     switch (sizeof(unsigned int)) {
312     case sizeof(uint32_t):
313         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
314     case sizeof(uint64_t):
315         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
316     }
317 #endif
318     return general_set_uint(p, &val, sizeof(val));
319 }
320 
OSSL_PARAM_construct_uint(const char * key,unsigned int * buf)321 OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
322 {
323     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
324                                 sizeof(unsigned int));
325 }
326 
OSSL_PARAM_get_long(const OSSL_PARAM * p,long int * val)327 int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
328 {
329 #ifndef OPENSSL_SMALL_FOOTPRINT
330     switch (sizeof(long int)) {
331     case sizeof(int32_t):
332         return OSSL_PARAM_get_int32(p, (int32_t *)val);
333     case sizeof(int64_t):
334         return OSSL_PARAM_get_int64(p, (int64_t *)val);
335     }
336 #endif
337     return general_get_int(p, val, sizeof(*val));
338 }
339 
OSSL_PARAM_set_long(OSSL_PARAM * p,long int val)340 int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val)
341 {
342 #ifndef OPENSSL_SMALL_FOOTPRINT
343     switch (sizeof(long int)) {
344     case sizeof(int32_t):
345         return OSSL_PARAM_set_int32(p, (int32_t)val);
346     case sizeof(int64_t):
347         return OSSL_PARAM_set_int64(p, (int64_t)val);
348     }
349 #endif
350     return general_set_int(p, &val, sizeof(val));
351 }
352 
OSSL_PARAM_construct_long(const char * key,long int * buf)353 OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
354 {
355     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int));
356 }
357 
OSSL_PARAM_get_ulong(const OSSL_PARAM * p,unsigned long int * val)358 int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
359 {
360 #ifndef OPENSSL_SMALL_FOOTPRINT
361     switch (sizeof(unsigned long int)) {
362     case sizeof(uint32_t):
363         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
364     case sizeof(uint64_t):
365         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
366     }
367 #endif
368     return general_get_uint(p, val, sizeof(*val));
369 }
370 
OSSL_PARAM_set_ulong(OSSL_PARAM * p,unsigned long int val)371 int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val)
372 {
373 #ifndef OPENSSL_SMALL_FOOTPRINT
374     switch (sizeof(unsigned long int)) {
375     case sizeof(uint32_t):
376         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
377     case sizeof(uint64_t):
378         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
379     }
380 #endif
381     return general_set_uint(p, &val, sizeof(val));
382 }
383 
OSSL_PARAM_construct_ulong(const char * key,unsigned long int * buf)384 OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
385 {
386     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
387                                 sizeof(unsigned long int));
388 }
389 
OSSL_PARAM_get_int32(const OSSL_PARAM * p,int32_t * val)390 int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
391 {
392     if (val == NULL || p == NULL) {
393         err_null_argument;
394         return 0;
395     }
396 
397     if (p->data == NULL) {
398         err_null_argument;
399         return 0;
400     }
401 
402     if (p->data_type == OSSL_PARAM_INTEGER) {
403 #ifndef OPENSSL_SMALL_FOOTPRINT
404         int64_t i64;
405 
406         switch (p->data_size) {
407         case sizeof(int32_t):
408             *val = *(const int32_t *)p->data;
409             return 1;
410         case sizeof(int64_t):
411             i64 = *(const int64_t *)p->data;
412             if (i64 >= INT32_MIN && i64 <= INT32_MAX) {
413                 *val = (int32_t)i64;
414                 return 1;
415             }
416             err_out_of_range;
417             return 0;
418         }
419 #endif
420         return general_get_int(p, val, sizeof(*val));
421 
422     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
423 #ifndef OPENSSL_SMALL_FOOTPRINT
424         uint32_t u32;
425         uint64_t u64;
426 
427         switch (p->data_size) {
428         case sizeof(uint32_t):
429             u32 = *(const uint32_t *)p->data;
430             if (u32 <= INT32_MAX) {
431                 *val = (int32_t)u32;
432                 return 1;
433             }
434             err_out_of_range;
435             return 0;
436         case sizeof(uint64_t):
437             u64 = *(const uint64_t *)p->data;
438             if (u64 <= INT32_MAX) {
439                 *val = (int32_t)u64;
440                 return 1;
441             }
442             err_out_of_range;
443             return 0;
444         }
445 #endif
446         return general_get_int(p, val, sizeof(*val));
447 
448     } else if (p->data_type == OSSL_PARAM_REAL) {
449 #ifndef OPENSSL_SYS_UEFI
450         double d;
451 
452         switch (p->data_size) {
453         case sizeof(double):
454             d = *(const double *)p->data;
455             if (d >= INT32_MIN && d <= INT32_MAX && d == (int32_t)d) {
456                 *val = (int32_t)d;
457                 return 1;
458             }
459             err_out_of_range;
460             return 0;
461         }
462         err_unsupported_real;
463         return 0;
464 #endif
465     }
466     err_bad_type;
467     return 0;
468 }
469 
OSSL_PARAM_set_int32(OSSL_PARAM * p,int32_t val)470 int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
471 {
472     if (p == NULL) {
473         err_null_argument;
474         return 0;
475     }
476     p->return_size = 0;
477     if (p->data_type == OSSL_PARAM_INTEGER) {
478 #ifndef OPENSSL_SMALL_FOOTPRINT
479         p->return_size = sizeof(int32_t); /* Minimum expected size */
480         if (p->data == NULL)
481             return 1;
482         switch (p->data_size) {
483         case sizeof(int32_t):
484             *(int32_t *)p->data = val;
485             return 1;
486         case sizeof(int64_t):
487             p->return_size = sizeof(int64_t);
488             *(int64_t *)p->data = (int64_t)val;
489             return 1;
490         }
491 #endif
492         return general_set_int(p, &val, sizeof(val));
493     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
494 #ifndef OPENSSL_SMALL_FOOTPRINT
495         p->return_size = sizeof(uint32_t); /* Minimum expected size */
496         if (p->data == NULL)
497             return 1;
498         switch (p->data_size) {
499         case sizeof(uint32_t):
500             *(uint32_t *)p->data = (uint32_t)val;
501             return 1;
502         case sizeof(uint64_t):
503             p->return_size = sizeof(uint64_t);
504             *(uint64_t *)p->data = (uint64_t)val;
505             return 1;
506         }
507 #endif
508         return general_set_int(p, &val, sizeof(val));
509     } else if (p->data_type == OSSL_PARAM_REAL) {
510 #ifndef OPENSSL_SYS_UEFI
511         uint32_t u32;
512         unsigned int shift;
513 
514         p->return_size = sizeof(double);
515         if (p->data == NULL)
516             return 1;
517         switch (p->data_size) {
518         case sizeof(double):
519             shift = real_shift();
520             if (shift < 8 * sizeof(val) - 1) {
521                 u32 = val < 0 ? -val : val;
522                 if ((u32 >> shift) != 0) {
523                     err_inexact;
524                     return 0;
525                 }
526             }
527             *(double *)p->data = (double)val;
528             return 1;
529         }
530         err_unsupported_real;
531         return 0;
532 #endif
533     }
534     err_bad_type;
535     return 0;
536 }
537 
OSSL_PARAM_construct_int32(const char * key,int32_t * buf)538 OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
539 {
540     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf,
541                                 sizeof(int32_t));
542 }
543 
OSSL_PARAM_get_uint32(const OSSL_PARAM * p,uint32_t * val)544 int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
545 {
546     if (val == NULL || p == NULL) {
547         err_null_argument;
548         return 0;
549     }
550 
551     if (p->data == NULL) {
552         err_null_argument;
553         return 0;
554     }
555 
556     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
557 #ifndef OPENSSL_SMALL_FOOTPRINT
558         uint64_t u64;
559 
560         switch (p->data_size) {
561         case sizeof(uint32_t):
562             *val = *(const uint32_t *)p->data;
563             return 1;
564         case sizeof(uint64_t):
565             u64 = *(const uint64_t *)p->data;
566             if (u64 <= UINT32_MAX) {
567                 *val = (uint32_t)u64;
568                 return 1;
569             }
570             err_out_of_range;
571             return 0;
572         }
573 #endif
574         return general_get_uint(p, val, sizeof(*val));
575     } else if (p->data_type == OSSL_PARAM_INTEGER) {
576 #ifndef OPENSSL_SMALL_FOOTPRINT
577         int32_t i32;
578         int64_t i64;
579 
580         switch (p->data_size) {
581         case sizeof(int32_t):
582             i32 = *(const int32_t *)p->data;
583             if (i32 >= 0) {
584                 *val = i32;
585                 return 1;
586             }
587             err_unsigned_negative;
588             return 0;
589         case sizeof(int64_t):
590             i64 = *(const int64_t *)p->data;
591             if (i64 >= 0 && i64 <= UINT32_MAX) {
592                 *val = (uint32_t)i64;
593                 return 1;
594             }
595             if (i64 < 0)
596                 err_unsigned_negative;
597             else
598                 err_out_of_range;
599             return 0;
600         }
601 #endif
602         return general_get_uint(p, val, sizeof(*val));
603     } else if (p->data_type == OSSL_PARAM_REAL) {
604 #ifndef OPENSSL_SYS_UEFI
605         double d;
606 
607         switch (p->data_size) {
608         case sizeof(double):
609             d = *(const double *)p->data;
610             if (d >= 0 && d <= UINT32_MAX && d == (uint32_t)d) {
611                 *val = (uint32_t)d;
612                 return 1;
613             }
614             err_inexact;
615             return 0;
616         }
617         err_unsupported_real;
618         return 0;
619 #endif
620     }
621     err_bad_type;
622     return 0;
623 }
624 
OSSL_PARAM_set_uint32(OSSL_PARAM * p,uint32_t val)625 int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
626 {
627     if (p == NULL) {
628         err_null_argument;
629         return 0;
630     }
631     p->return_size = 0;
632 
633     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
634 #ifndef OPENSSL_SMALL_FOOTPRINT
635         p->return_size = sizeof(uint32_t); /* Minimum expected size */
636         if (p->data == NULL)
637             return 1;
638         switch (p->data_size) {
639         case sizeof(uint32_t):
640             *(uint32_t *)p->data = val;
641             return 1;
642         case sizeof(uint64_t):
643             p->return_size = sizeof(uint64_t);
644             *(uint64_t *)p->data = val;
645             return 1;
646         }
647 #endif
648         return general_set_uint(p, &val, sizeof(val));
649     } else if (p->data_type == OSSL_PARAM_INTEGER) {
650 #ifndef OPENSSL_SMALL_FOOTPRINT
651         p->return_size = sizeof(int32_t); /* Minimum expected size */
652         if (p->data == NULL)
653             return 1;
654         switch (p->data_size) {
655         case sizeof(int32_t):
656             if (val <= INT32_MAX) {
657                 *(int32_t *)p->data = (int32_t)val;
658                 return 1;
659             }
660             err_out_of_range;
661             return 0;
662         case sizeof(int64_t):
663             p->return_size = sizeof(int64_t);
664             *(int64_t *)p->data = (int64_t)val;
665             return 1;
666         }
667 #endif
668         return general_set_uint(p, &val, sizeof(val));
669     } else if (p->data_type == OSSL_PARAM_REAL) {
670 #ifndef OPENSSL_SYS_UEFI
671         unsigned int shift;
672 
673         p->return_size = sizeof(double);
674         if (p->data == NULL)
675             return 1;
676         switch (p->data_size) {
677         case sizeof(double):
678             shift = real_shift();
679             if (shift < 8 * sizeof(val) && (val >> shift) != 0) {
680                 err_inexact;
681                 return 0;
682             }
683             *(double *)p->data = (double)val;
684             return 1;
685         }
686         err_unsupported_real;
687         return 0;
688 #endif
689     }
690     err_bad_type;
691     return 0;
692 }
693 
OSSL_PARAM_construct_uint32(const char * key,uint32_t * buf)694 OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
695 {
696     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
697                                 sizeof(uint32_t));
698 }
699 
OSSL_PARAM_get_int64(const OSSL_PARAM * p,int64_t * val)700 int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
701 {
702     if (val == NULL || p == NULL) {
703         err_null_argument;
704         return 0;
705     }
706 
707     if (p->data == NULL) {
708         err_null_argument;
709         return 0;
710     }
711 
712     if (p->data_type == OSSL_PARAM_INTEGER) {
713 #ifndef OPENSSL_SMALL_FOOTPRINT
714         switch (p->data_size) {
715         case sizeof(int32_t):
716             *val = *(const int32_t *)p->data;
717             return 1;
718         case sizeof(int64_t):
719             *val = *(const int64_t *)p->data;
720             return 1;
721         }
722 #endif
723         return general_get_int(p, val, sizeof(*val));
724     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
725 #ifndef OPENSSL_SMALL_FOOTPRINT
726         uint64_t u64;
727 
728         switch (p->data_size) {
729         case sizeof(uint32_t):
730             *val = *(const uint32_t *)p->data;
731             return 1;
732         case sizeof(uint64_t):
733             u64 = *(const uint64_t *)p->data;
734             if (u64 <= INT64_MAX) {
735                 *val = (int64_t)u64;
736                 return 1;
737             }
738             err_out_of_range;
739             return 0;
740         }
741 #endif
742         return general_get_int(p, val, sizeof(*val));
743     } else if (p->data_type == OSSL_PARAM_REAL) {
744 #ifndef OPENSSL_SYS_UEFI
745         double d;
746 
747         switch (p->data_size) {
748         case sizeof(double):
749             d = *(const double *)p->data;
750             if (d >= INT64_MIN
751                     /*
752                      * By subtracting 65535 (2^16-1) we cancel the low order
753                      * 15 bits of INT64_MAX to avoid using imprecise floating
754                      * point values.
755                      */
756                     && d < (double)(INT64_MAX - 65535) + 65536.0
757                     && d == (int64_t)d) {
758                 *val = (int64_t)d;
759                 return 1;
760             }
761             err_inexact;
762             return 0;
763         }
764         err_unsupported_real;
765         return 0;
766 #endif
767     }
768     err_bad_type;
769     return 0;
770 }
771 
OSSL_PARAM_set_int64(OSSL_PARAM * p,int64_t val)772 int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
773 {
774     if (p == NULL) {
775         err_null_argument;
776         return 0;
777     }
778     p->return_size = 0;
779     if (p->data_type == OSSL_PARAM_INTEGER) {
780 #ifndef OPENSSL_SMALL_FOOTPRINT
781         p->return_size = sizeof(int64_t); /* Expected size */
782         if (p->data == NULL)
783             return 1;
784         switch (p->data_size) {
785         case sizeof(int32_t):
786             if (val >= INT32_MIN && val <= INT32_MAX) {
787                 p->return_size = sizeof(int32_t);
788                 *(int32_t *)p->data = (int32_t)val;
789                 return 1;
790             }
791             err_out_of_range;
792             return 0;
793         case sizeof(int64_t):
794             *(int64_t *)p->data = val;
795             return 1;
796         }
797 #endif
798         return general_set_int(p, &val, sizeof(val));
799     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
800 #ifndef OPENSSL_SMALL_FOOTPRINT
801         p->return_size = sizeof(uint64_t); /* Expected size */
802         if (p->data == NULL)
803             return 1;
804         switch (p->data_size) {
805         case sizeof(uint32_t):
806             if (val <= UINT32_MAX) {
807                 p->return_size = sizeof(uint32_t);
808                 *(uint32_t *)p->data = (uint32_t)val;
809                 return 1;
810             }
811             err_out_of_range;
812             return 0;
813         case sizeof(uint64_t):
814             *(uint64_t *)p->data = (uint64_t)val;
815             return 1;
816         }
817 #endif
818         return general_set_int(p, &val, sizeof(val));
819     } else if (p->data_type == OSSL_PARAM_REAL) {
820 #ifndef OPENSSL_SYS_UEFI
821         uint64_t u64;
822 
823         p->return_size = sizeof(double);
824         if (p->data == NULL)
825             return 1;
826         switch (p->data_size) {
827         case sizeof(double):
828             u64 = val < 0 ? -val : val;
829             if ((u64 >> real_shift()) == 0) {
830                 *(double *)p->data = (double)val;
831                 return 1;
832             }
833             err_inexact;
834             return 0;
835         }
836         err_unsupported_real;
837         return 0;
838 #endif
839     }
840     err_bad_type;
841     return 0;
842 }
843 
OSSL_PARAM_construct_int64(const char * key,int64_t * buf)844 OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
845 {
846     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t));
847 }
848 
OSSL_PARAM_get_uint64(const OSSL_PARAM * p,uint64_t * val)849 int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
850 {
851     if (val == NULL || p == NULL) {
852         err_null_argument;
853         return 0;
854     }
855 
856     if (p->data == NULL) {
857         err_null_argument;
858         return 0;
859     }
860 
861     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
862 #ifndef OPENSSL_SMALL_FOOTPRINT
863         switch (p->data_size) {
864         case sizeof(uint32_t):
865             *val = *(const uint32_t *)p->data;
866             return 1;
867         case sizeof(uint64_t):
868             *val = *(const uint64_t *)p->data;
869             return 1;
870         }
871 #endif
872         return general_get_uint(p, val, sizeof(*val));
873     } else if (p->data_type == OSSL_PARAM_INTEGER) {
874 #ifndef OPENSSL_SMALL_FOOTPRINT
875         int32_t i32;
876         int64_t i64;
877 
878         switch (p->data_size) {
879         case sizeof(int32_t):
880             i32 = *(const int32_t *)p->data;
881             if (i32 >= 0) {
882                 *val = (uint64_t)i32;
883                 return 1;
884             }
885             err_unsigned_negative;
886             return 0;
887         case sizeof(int64_t):
888             i64 = *(const int64_t *)p->data;
889             if (i64 >= 0) {
890                 *val = (uint64_t)i64;
891                 return 1;
892             }
893             err_unsigned_negative;
894             return 0;
895         }
896 #endif
897         return general_get_uint(p, val, sizeof(*val));
898     } else if (p->data_type == OSSL_PARAM_REAL) {
899 #ifndef OPENSSL_SYS_UEFI
900         double d;
901 
902         switch (p->data_size) {
903         case sizeof(double):
904             d = *(const double *)p->data;
905             if (d >= 0
906                     /*
907                      * By subtracting 65535 (2^16-1) we cancel the low order
908                      * 15 bits of UINT64_MAX to avoid using imprecise floating
909                      * point values.
910                      */
911                     && d < (double)(UINT64_MAX - 65535) + 65536.0
912                     && d == (uint64_t)d) {
913                 *val = (uint64_t)d;
914                 return 1;
915             }
916             err_inexact;
917             return 0;
918         }
919         err_unsupported_real;
920         return 0;
921 #endif
922     }
923     err_bad_type;
924     return 0;
925 }
926 
OSSL_PARAM_set_uint64(OSSL_PARAM * p,uint64_t val)927 int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
928 {
929     if (p == NULL) {
930         err_null_argument;
931         return 0;
932     }
933     p->return_size = 0;
934 
935     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
936 #ifndef OPENSSL_SMALL_FOOTPRINT
937         p->return_size = sizeof(uint64_t); /* Expected size */
938         if (p->data == NULL)
939             return 1;
940         switch (p->data_size) {
941         case sizeof(uint32_t):
942             if (val <= UINT32_MAX) {
943                 p->return_size = sizeof(uint32_t);
944                 *(uint32_t *)p->data = (uint32_t)val;
945                 return 1;
946             }
947             err_out_of_range;
948             return 0;
949         case sizeof(uint64_t):
950             *(uint64_t *)p->data = val;
951             return 1;
952         }
953 #endif
954         return general_set_uint(p, &val, sizeof(val));
955     } else if (p->data_type == OSSL_PARAM_INTEGER) {
956 #ifndef OPENSSL_SMALL_FOOTPRINT
957         p->return_size = sizeof(int64_t); /* Expected size */
958         if (p->data == NULL)
959             return 1;
960         switch (p->data_size) {
961         case sizeof(int32_t):
962             if (val <= INT32_MAX) {
963                 p->return_size = sizeof(int32_t);
964                 *(int32_t *)p->data = (int32_t)val;
965                 return 1;
966             }
967             err_out_of_range;
968             return 0;
969         case sizeof(int64_t):
970             if (val <= INT64_MAX) {
971                 *(int64_t *)p->data = (int64_t)val;
972                 return 1;
973             }
974             err_out_of_range;
975             return 0;
976         }
977 #endif
978         return general_set_uint(p, &val, sizeof(val));
979     } else if (p->data_type == OSSL_PARAM_REAL) {
980 #ifndef OPENSSL_SYS_UEFI
981         p->return_size = sizeof(double);
982         switch (p->data_size) {
983         case sizeof(double):
984             if ((val >> real_shift()) == 0) {
985                 *(double *)p->data = (double)val;
986                 return 1;
987             }
988             err_inexact;
989             return 0;
990         }
991         err_unsupported_real;
992         return 0;
993 #endif
994     }
995     err_bad_type;
996     return 0;
997 }
998 
OSSL_PARAM_construct_uint64(const char * key,uint64_t * buf)999 OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
1000 {
1001     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
1002                                 sizeof(uint64_t));
1003 }
1004 
OSSL_PARAM_get_size_t(const OSSL_PARAM * p,size_t * val)1005 int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
1006 {
1007 #ifndef OPENSSL_SMALL_FOOTPRINT
1008     switch (sizeof(size_t)) {
1009     case sizeof(uint32_t):
1010         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
1011     case sizeof(uint64_t):
1012         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
1013     }
1014 #endif
1015     return general_get_uint(p, val, sizeof(*val));
1016 }
1017 
OSSL_PARAM_set_size_t(OSSL_PARAM * p,size_t val)1018 int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
1019 {
1020 #ifndef OPENSSL_SMALL_FOOTPRINT
1021     switch (sizeof(size_t)) {
1022     case sizeof(uint32_t):
1023         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
1024     case sizeof(uint64_t):
1025         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
1026     }
1027 #endif
1028     return general_set_uint(p, &val, sizeof(val));
1029 }
1030 
OSSL_PARAM_construct_size_t(const char * key,size_t * buf)1031 OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
1032 {
1033     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
1034                                 sizeof(size_t));
1035 }
1036 
OSSL_PARAM_get_time_t(const OSSL_PARAM * p,time_t * val)1037 int OSSL_PARAM_get_time_t(const OSSL_PARAM *p, time_t *val)
1038 {
1039 #ifndef OPENSSL_SMALL_FOOTPRINT
1040     switch (sizeof(time_t)) {
1041     case sizeof(int32_t):
1042         return OSSL_PARAM_get_int32(p, (int32_t *)val);
1043     case sizeof(int64_t):
1044         return OSSL_PARAM_get_int64(p, (int64_t *)val);
1045     }
1046 #endif
1047     return general_get_int(p, val, sizeof(*val));
1048 }
1049 
OSSL_PARAM_set_time_t(OSSL_PARAM * p,time_t val)1050 int OSSL_PARAM_set_time_t(OSSL_PARAM *p, time_t val)
1051 {
1052 #ifndef OPENSSL_SMALL_FOOTPRINT
1053     switch (sizeof(time_t)) {
1054     case sizeof(int32_t):
1055         return OSSL_PARAM_set_int32(p, (int32_t)val);
1056     case sizeof(int64_t):
1057         return OSSL_PARAM_set_int64(p, (int64_t)val);
1058     }
1059 #endif
1060     return general_set_int(p, &val, sizeof(val));
1061 }
1062 
OSSL_PARAM_construct_time_t(const char * key,time_t * buf)1063 OSSL_PARAM OSSL_PARAM_construct_time_t(const char *key, time_t *buf)
1064 {
1065     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(time_t));
1066 }
1067 
OSSL_PARAM_get_BN(const OSSL_PARAM * p,BIGNUM ** val)1068 int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val)
1069 {
1070     BIGNUM *b = NULL;
1071 
1072     if (val == NULL || p == NULL || p->data == NULL) {
1073         err_null_argument;
1074         return 0;
1075     }
1076 
1077     switch (p->data_type) {
1078     case OSSL_PARAM_UNSIGNED_INTEGER:
1079         b = BN_native2bn(p->data, (int)p->data_size, *val);
1080         break;
1081     case OSSL_PARAM_INTEGER:
1082         b = BN_signed_native2bn(p->data, (int)p->data_size, *val);
1083         break;
1084     default:
1085         err_bad_type;
1086         break;
1087     }
1088 
1089     if (b == NULL) {
1090         ERR_raise(ERR_LIB_CRYPTO, ERR_R_BN_LIB);
1091         return 0;
1092     }
1093 
1094     *val = b;
1095     return 1;
1096 }
1097 
OSSL_PARAM_set_BN(OSSL_PARAM * p,const BIGNUM * val)1098 int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val)
1099 {
1100     size_t bytes;
1101 
1102     if (p == NULL) {
1103         err_null_argument;
1104         return 0;
1105     }
1106     p->return_size = 0;
1107     if (val == NULL) {
1108         err_null_argument;
1109         return 0;
1110     }
1111     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && BN_is_negative(val)) {
1112         err_bad_type;
1113         return 0;
1114     }
1115 
1116     bytes = (size_t)BN_num_bytes(val);
1117     /* We add 1 byte for signed numbers, to make space for a sign extension */
1118     if (p->data_type == OSSL_PARAM_INTEGER)
1119         bytes++;
1120     /* We make sure that at least one byte is used, so zero is properly set */
1121     if (bytes == 0)
1122         bytes++;
1123 
1124     p->return_size = bytes;
1125     if (p->data == NULL)
1126         return 1;
1127     if (p->data_size >= bytes) {
1128         p->return_size = p->data_size;
1129 
1130         switch (p->data_type) {
1131         case OSSL_PARAM_UNSIGNED_INTEGER:
1132             if (BN_bn2nativepad(val, p->data, p->data_size) >= 0)
1133                 return 1;
1134             ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_INTEGER_OVERFLOW);
1135             break;
1136         case OSSL_PARAM_INTEGER:
1137             if (BN_signed_bn2native(val, p->data, p->data_size) >= 0)
1138                 return 1;
1139             ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_INTEGER_OVERFLOW);
1140             break;
1141         default:
1142             err_bad_type;
1143             break;
1144         }
1145         return 0;
1146     }
1147     err_too_small;
1148     return 0;
1149 }
1150 
OSSL_PARAM_construct_BN(const char * key,unsigned char * buf,size_t bsize)1151 OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
1152                                    size_t bsize)
1153 {
1154     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER,
1155                                 buf, bsize);
1156 }
1157 
1158 #ifndef OPENSSL_SYS_UEFI
OSSL_PARAM_get_double(const OSSL_PARAM * p,double * val)1159 int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val)
1160 {
1161     int64_t i64;
1162     uint64_t u64;
1163 
1164     if (val == NULL || p == NULL || p->data == NULL) {
1165         err_null_argument;
1166         return 0;
1167     }
1168 
1169     if (p->data_type == OSSL_PARAM_REAL) {
1170         switch (p->data_size) {
1171         case sizeof(double):
1172             *val = *(const double *)p->data;
1173             return 1;
1174         }
1175         err_unsupported_real;
1176         return 0;
1177     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
1178         switch (p->data_size) {
1179         case sizeof(uint32_t):
1180             *val = *(const uint32_t *)p->data;
1181             return 1;
1182         case sizeof(uint64_t):
1183             u64 = *(const uint64_t *)p->data;
1184             if ((u64 >> real_shift()) == 0) {
1185                 *val = (double)u64;
1186                 return 1;
1187             }
1188             err_inexact;
1189             return 0;
1190         }
1191     } else if (p->data_type == OSSL_PARAM_INTEGER) {
1192         switch (p->data_size) {
1193         case sizeof(int32_t):
1194             *val = *(const int32_t *)p->data;
1195             return 1;
1196         case sizeof(int64_t):
1197             i64 = *(const int64_t *)p->data;
1198             u64 = i64 < 0 ? -i64 : i64;
1199             if ((u64 >> real_shift()) == 0) {
1200                 *val = 0.0 + i64;
1201                 return 1;
1202             }
1203             err_inexact;
1204             return 0;
1205         }
1206     }
1207     err_bad_type;
1208     return 0;
1209 }
1210 
OSSL_PARAM_set_double(OSSL_PARAM * p,double val)1211 int OSSL_PARAM_set_double(OSSL_PARAM *p, double val)
1212 {
1213     if (p == NULL) {
1214         err_null_argument;
1215         return 0;
1216     }
1217     p->return_size = 0;
1218 
1219     if (p->data_type == OSSL_PARAM_REAL) {
1220         p->return_size = sizeof(double);
1221         if (p->data == NULL)
1222             return 1;
1223         switch (p->data_size) {
1224         case sizeof(double):
1225             *(double *)p->data = val;
1226             return 1;
1227         }
1228         err_unsupported_real;
1229         return 0;
1230     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
1231         p->return_size = sizeof(double);
1232         if (p->data == NULL)
1233             return 1;
1234         if (val != (uint64_t)val) {
1235             err_inexact;
1236             return 0;
1237         }
1238         switch (p->data_size) {
1239         case sizeof(uint32_t):
1240             if (val >= 0 && val <= UINT32_MAX) {
1241                 p->return_size = sizeof(uint32_t);
1242                 *(uint32_t *)p->data = (uint32_t)val;
1243                 return 1;
1244             }
1245             err_out_of_range;
1246             return 0;
1247         case sizeof(uint64_t):
1248             if (val >= 0
1249                     /*
1250                      * By subtracting 65535 (2^16-1) we cancel the low order
1251                      * 15 bits of UINT64_MAX to avoid using imprecise floating
1252                      * point values.
1253                      */
1254                     && val < (double)(UINT64_MAX - 65535) + 65536.0) {
1255                 p->return_size = sizeof(uint64_t);
1256                 *(uint64_t *)p->data = (uint64_t)val;
1257                 return 1;
1258             }
1259             err_out_of_range;
1260             return 0;
1261         }
1262     } else if (p->data_type == OSSL_PARAM_INTEGER) {
1263         p->return_size = sizeof(double);
1264         if (p->data == NULL)
1265             return 1;
1266         if (val != (int64_t)val) {
1267             err_inexact;
1268             return 0;
1269         }
1270         switch (p->data_size) {
1271         case sizeof(int32_t):
1272             if (val >= INT32_MIN && val <= INT32_MAX) {
1273                 p->return_size = sizeof(int32_t);
1274                 *(int32_t *)p->data = (int32_t)val;
1275                 return 1;
1276             }
1277             err_out_of_range;
1278             return 0;
1279         case sizeof(int64_t):
1280             if (val >= INT64_MIN
1281                     /*
1282                      * By subtracting 65535 (2^16-1) we cancel the low order
1283                      * 15 bits of INT64_MAX to avoid using imprecise floating
1284                      * point values.
1285                      */
1286                     && val < (double)(INT64_MAX - 65535) + 65536.0) {
1287                 p->return_size = sizeof(int64_t);
1288                 *(int64_t *)p->data = (int64_t)val;
1289                 return 1;
1290             }
1291             err_out_of_range;
1292             return 0;
1293         }
1294     }
1295     err_bad_type;
1296     return 0;
1297 }
1298 
OSSL_PARAM_construct_double(const char * key,double * buf)1299 OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf)
1300 {
1301     return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double));
1302 }
1303 #endif
1304 
get_string_internal(const OSSL_PARAM * p,void ** val,size_t * max_len,size_t * used_len,unsigned int type)1305 static int get_string_internal(const OSSL_PARAM *p, void **val,
1306                                size_t *max_len, size_t *used_len,
1307                                unsigned int type)
1308 {
1309     size_t sz, alloc_sz;
1310 
1311     if ((val == NULL && used_len == NULL) || p == NULL) {
1312         err_null_argument;
1313         return 0;
1314     }
1315     if (p->data_type != type) {
1316         err_bad_type;
1317         return 0;
1318     }
1319 
1320     sz = p->data_size;
1321     /*
1322      * If the input size is 0, or the input string needs NUL byte
1323      * termination, allocate an extra byte.
1324      */
1325     alloc_sz = sz + (type == OSSL_PARAM_UTF8_STRING || sz == 0);
1326 
1327     if (used_len != NULL)
1328         *used_len = sz;
1329 
1330     if (p->data == NULL) {
1331         err_null_argument;
1332         return 0;
1333     }
1334 
1335     if (val == NULL)
1336         return 1;
1337 
1338     if (*val == NULL) {
1339         char *const q = OPENSSL_malloc(alloc_sz);
1340 
1341         if (q == NULL)
1342             return 0;
1343         *val = q;
1344         *max_len = alloc_sz;
1345     }
1346 
1347     if (*max_len < sz) {
1348         err_too_small;
1349         return 0;
1350     }
1351     memcpy(*val, p->data, sz);
1352     return 1;
1353 }
1354 
OSSL_PARAM_get_utf8_string(const OSSL_PARAM * p,char ** val,size_t max_len)1355 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len)
1356 {
1357     int ret = get_string_internal(p, (void **)val, &max_len, NULL,
1358                                   OSSL_PARAM_UTF8_STRING);
1359 
1360     /*
1361      * We try to ensure that the copied string is terminated with a
1362      * NUL byte.  That should be easy, just place a NUL byte at
1363      * |((char*)*val)[p->data_size]|.
1364      * Unfortunately, we have seen cases where |p->data_size| doesn't
1365      * correctly reflect the length of the string, and just happens
1366      * to be out of bounds according to |max_len|, so in that case, we
1367      * make the extra step of trying to find the true length of the
1368      * string that |p->data| points at, and use that as an index to
1369      * place the NUL byte in |*val|.
1370      */
1371     size_t data_length = p->data_size;
1372 
1373     if (ret == 0)
1374         return 0;
1375     if (data_length >= max_len)
1376         data_length = OPENSSL_strnlen(p->data, data_length);
1377     if (data_length >= max_len) {
1378         ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_NO_SPACE_FOR_TERMINATING_NULL);
1379         return 0;            /* No space for a terminating NUL byte */
1380     }
1381     (*val)[data_length] = '\0';
1382 
1383     return ret;
1384 }
1385 
OSSL_PARAM_get_octet_string(const OSSL_PARAM * p,void ** val,size_t max_len,size_t * used_len)1386 int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
1387                                 size_t *used_len)
1388 {
1389     return get_string_internal(p, val, &max_len, used_len,
1390                                OSSL_PARAM_OCTET_STRING);
1391 }
1392 
set_string_internal(OSSL_PARAM * p,const void * val,size_t len,unsigned int type)1393 static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
1394                                unsigned int type)
1395 {
1396     p->return_size = len;
1397     if (p->data == NULL)
1398         return 1;
1399     if (p->data_type != type) {
1400         err_bad_type;
1401         return 0;
1402     }
1403     if (p->data_size < len) {
1404         err_too_small;
1405         return 0;
1406     }
1407 
1408     memcpy(p->data, val, len);
1409     /* If possible within the size of p->data, add a NUL terminator byte */
1410     if (type == OSSL_PARAM_UTF8_STRING && p->data_size > len)
1411         ((char *)p->data)[len] = '\0';
1412     return 1;
1413 }
1414 
OSSL_PARAM_set_utf8_string(OSSL_PARAM * p,const char * val)1415 int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
1416 {
1417     if (p == NULL) {
1418         err_null_argument;
1419         return 0;
1420     }
1421 
1422     p->return_size = 0;
1423     if (val == NULL) {
1424         err_null_argument;
1425         return 0;
1426     }
1427     return set_string_internal(p, val, strlen(val), OSSL_PARAM_UTF8_STRING);
1428 }
1429 
OSSL_PARAM_set_octet_string(OSSL_PARAM * p,const void * val,size_t len)1430 int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
1431                                 size_t len)
1432 {
1433     if (p == NULL) {
1434         err_null_argument;
1435         return 0;
1436     }
1437 
1438     p->return_size = 0;
1439     if (val == NULL) {
1440         err_null_argument;
1441         return 0;
1442     }
1443     return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
1444 }
1445 
OSSL_PARAM_construct_utf8_string(const char * key,char * buf,size_t bsize)1446 OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
1447                                             size_t bsize)
1448 {
1449     if (buf != NULL && bsize == 0)
1450         bsize = strlen(buf);
1451     return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
1452 }
1453 
OSSL_PARAM_construct_octet_string(const char * key,void * buf,size_t bsize)1454 OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
1455                                              size_t bsize)
1456 {
1457     return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
1458 }
1459 
get_ptr_internal(const OSSL_PARAM * p,const void ** val,size_t * used_len,unsigned int type)1460 static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
1461                             size_t *used_len, unsigned int type)
1462 {
1463     if (val == NULL || p == NULL) {
1464         err_null_argument;
1465         return 0;
1466     }
1467     if (p->data_type != type) {
1468         err_bad_type;
1469         return 0;
1470     }
1471     if (used_len != NULL)
1472         *used_len = p->data_size;
1473     *val = *(const void **)p->data;
1474     return 1;
1475 }
1476 
OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM * p,const char ** val)1477 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val)
1478 {
1479     return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR);
1480 }
1481 
OSSL_PARAM_get_octet_ptr(const OSSL_PARAM * p,const void ** val,size_t * used_len)1482 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
1483                              size_t *used_len)
1484 {
1485     return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
1486 }
1487 
set_ptr_internal(OSSL_PARAM * p,const void * val,unsigned int type,size_t len)1488 static int set_ptr_internal(OSSL_PARAM *p, const void *val,
1489                             unsigned int type, size_t len)
1490 {
1491     p->return_size = len;
1492     if (p->data_type != type) {
1493         err_bad_type;
1494         return 0;
1495     }
1496     if (p->data != NULL)
1497         *(const void **)p->data = val;
1498     return 1;
1499 }
1500 
OSSL_PARAM_set_utf8_ptr(OSSL_PARAM * p,const char * val)1501 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
1502 {
1503     if (p == NULL) {
1504         err_null_argument;
1505         return 0;
1506     }
1507     p->return_size = 0;
1508     return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR,
1509                             val == NULL ? 0 : strlen(val));
1510 }
1511 
OSSL_PARAM_set_octet_ptr(OSSL_PARAM * p,const void * val,size_t used_len)1512 int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
1513                              size_t used_len)
1514 {
1515     if (p == NULL) {
1516         err_null_argument;
1517         return 0;
1518     }
1519     p->return_size = 0;
1520     return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len);
1521 }
1522 
OSSL_PARAM_construct_utf8_ptr(const char * key,char ** buf,size_t bsize)1523 OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
1524                                          size_t bsize)
1525 {
1526     return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize);
1527 }
1528 
OSSL_PARAM_construct_octet_ptr(const char * key,void ** buf,size_t bsize)1529 OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
1530                                           size_t bsize)
1531 {
1532     return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize);
1533 }
1534 
1535 /*
1536  * Extract the parameter into an allocated buffer.
1537  * Any existing allocation in *out is cleared and freed.
1538  *
1539  * Returns 1 on success, 0 on failure and -1 if there are no matching params.
1540  *
1541  * *out and *out_len are guaranteed to be untouched if this function
1542  * doesn't return success.
1543  */
ossl_param_get1_octet_string(const OSSL_PARAM * params,const char * name,unsigned char ** out,size_t * out_len)1544 int ossl_param_get1_octet_string(const OSSL_PARAM *params, const char *name,
1545                                  unsigned char **out, size_t *out_len)
1546 {
1547     const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, name);
1548     void *buf = NULL;
1549     size_t len = 0;
1550 
1551     if (p == NULL)
1552         return -1;
1553 
1554     if (p->data != NULL
1555             && p->data_size > 0
1556             && !OSSL_PARAM_get_octet_string(p, &buf, 0, &len))
1557         return 0;
1558 
1559     OPENSSL_clear_free(*out, *out_len);
1560     *out = buf;
1561     *out_len = len;
1562     return 1;
1563 }
1564 
setbuf_fromparams(const OSSL_PARAM * p,const char * name,unsigned char * out,size_t * outlen)1565 static int setbuf_fromparams(const OSSL_PARAM *p, const char *name,
1566                              unsigned char *out, size_t *outlen)
1567 {
1568     int ret = 0;
1569     WPACKET pkt;
1570 
1571     if (out == NULL) {
1572         if (!WPACKET_init_null(&pkt, 0))
1573             return 0;
1574     } else {
1575         if (!WPACKET_init_static_len(&pkt, out, *outlen, 0))
1576             return 0;
1577     }
1578 
1579     for (; p != NULL; p = OSSL_PARAM_locate_const(p + 1, name)) {
1580         if (p->data_type != OSSL_PARAM_OCTET_STRING)
1581             goto err;
1582         if (p->data != NULL
1583                 && p->data_size != 0
1584                 && !WPACKET_memcpy(&pkt, p->data, p->data_size))
1585             goto err;
1586     }
1587     if (!WPACKET_get_total_written(&pkt, outlen)
1588             || !WPACKET_finish(&pkt))
1589         goto err;
1590     ret = 1;
1591 err:
1592     WPACKET_cleanup(&pkt);
1593     return ret;
1594 }
1595 
ossl_param_get1_concat_octet_string(const OSSL_PARAM * params,const char * name,unsigned char ** out,size_t * out_len,size_t maxsize)1596 int ossl_param_get1_concat_octet_string(const OSSL_PARAM *params, const char *name,
1597                                         unsigned char **out,
1598                                         size_t *out_len, size_t maxsize)
1599 {
1600     const OSSL_PARAM *p = OSSL_PARAM_locate_const(params, name);
1601     unsigned char *res;
1602     size_t sz = 0;
1603 
1604     if (p == NULL)
1605         return -1;
1606 
1607     /* Calculate the total size */
1608     if (!setbuf_fromparams(p, name, NULL, &sz))
1609         return 0;
1610 
1611     /* Check that it's not oversized */
1612     if (maxsize > 0 && sz > maxsize)
1613         return 0;
1614 
1615     /* Special case zero length */
1616     if (sz == 0) {
1617         if ((res = OPENSSL_zalloc(1)) == NULL)
1618             return 0;
1619         goto fin;
1620     }
1621 
1622     /* Allocate the buffer */
1623     res = OPENSSL_malloc(sz);
1624     if (res == NULL)
1625         return 0;
1626 
1627     /* Concat one or more OSSL_KDF_PARAM_INFO fields */
1628     if (!setbuf_fromparams(p, name, res, &sz)) {
1629         OPENSSL_clear_free(res, sz);
1630         return 0;
1631     }
1632 
1633  fin:
1634     OPENSSL_clear_free(*out, *out_len);
1635     *out = res;
1636     *out_len = sz;
1637     return 1;
1638 }
1639 
OSSL_PARAM_construct_end(void)1640 OSSL_PARAM OSSL_PARAM_construct_end(void)
1641 {
1642     OSSL_PARAM end = OSSL_PARAM_END;
1643 
1644     return end;
1645 }
1646 
get_string_ptr_internal(const OSSL_PARAM * p,const void ** val,size_t * used_len,unsigned int type)1647 static int get_string_ptr_internal(const OSSL_PARAM *p, const void **val,
1648                                    size_t *used_len, unsigned int type)
1649 {
1650     if (val == NULL || p == NULL) {
1651         err_null_argument;
1652         return 0;
1653     }
1654     if (p->data_type != type) {
1655         err_bad_type;
1656         return 0;
1657     }
1658     if (used_len != NULL)
1659         *used_len = p->data_size;
1660     *val = p->data;
1661     return 1;
1662 }
1663 
OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM * p,const char ** val)1664 int OSSL_PARAM_get_utf8_string_ptr(const OSSL_PARAM *p, const char **val)
1665 {
1666     int rv;
1667 
1668     ERR_set_mark();
1669     rv = OSSL_PARAM_get_utf8_ptr(p, val);
1670     ERR_pop_to_mark();
1671 
1672     return rv || get_string_ptr_internal(p, (const void **)val, NULL,
1673                                          OSSL_PARAM_UTF8_STRING);
1674 }
1675 
OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM * p,const void ** val,size_t * used_len)1676 int OSSL_PARAM_get_octet_string_ptr(const OSSL_PARAM *p, const void **val,
1677                                     size_t *used_len)
1678 {
1679     int rv;
1680 
1681     ERR_set_mark();
1682     rv = OSSL_PARAM_get_octet_ptr(p, val, used_len);
1683     ERR_pop_to_mark();
1684 
1685     return rv || get_string_ptr_internal(p, val, used_len,
1686                                          OSSL_PARAM_OCTET_STRING);
1687 }
1688