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
