mirror of
https://github.com/openssl/openssl.git
synced 2024-11-27 05:21:51 +08:00
params: allow more variations in integer conversions.
Allow any sized integer to be converted to any other size integer via the helpers. Support for converting reals to/from integers remains restricted. Fixes: #13429 Reviewed-by: Richard Levitte <levitte@openssl.org> (Merged from https://github.com/openssl/openssl/pull/13663)
This commit is contained in:
Pauli
parent
19ad83f6c8
commit
e9c5e64278
304
crypto/params.c
304
crypto/params.c
@ -12,6 +12,7 @@
|
||||
#include <openssl/params.h>
|
||||
#include "internal/thread_once.h"
|
||||
#include "internal/numbers.h"
|
||||
#include "internal/endian.h"
|
||||
|
||||
/*
|
||||
* Return the number of bits in the mantissa of a double. This is used to
|
||||
@ -62,26 +63,181 @@ void OSSL_PARAM_set_all_unmodified(OSSL_PARAM *p)
|
||||
p++->return_size = OSSL_PARAM_UNMODIFIED;
|
||||
}
|
||||
|
||||
/* Return non-zero if the signed number is negative */
|
||||
static int is_negative(const void *number, size_t s)
|
||||
{
|
||||
const unsigned char *n = number;
|
||||
DECLARE_IS_ENDIAN;
|
||||
|
||||
return 0x80 & (IS_BIG_ENDIAN ? n[0] : n[s - 1]);
|
||||
}
|
||||
|
||||
/* Check that all the bytes specified match the expected sign byte */
|
||||
static int check_sign_bytes(const unsigned char *p, size_t n, unsigned char s)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < n; i++)
|
||||
if (p[i] != s)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Copy an integer to another integer.
|
||||
* Handle different length integers and signed and unsigned integers.
|
||||
* Both integers are in native byte ordering.
|
||||
*/
|
||||
static int copy_integer(unsigned char *dest, size_t dest_len,
|
||||
const unsigned char *src, size_t src_len,
|
||||
unsigned char pad, int signed_int)
|
||||
{
|
||||
size_t n;
|
||||
DECLARE_IS_ENDIAN;
|
||||
|
||||
if (IS_BIG_ENDIAN) {
|
||||
if (src_len < dest_len) {
|
||||
n = dest_len - src_len;
|
||||
memset(dest, pad, n);
|
||||
memcpy(dest + n, src, src_len);
|
||||
} else {
|
||||
n = src_len - dest_len;
|
||||
if (!check_sign_bytes(src, n, pad)
|
||||
/*
|
||||
* Shortening a signed value must retain the correct sign.
|
||||
* Avoiding this kind of thing: -253 = 0xff03 -> 0x03 = 3
|
||||
*/
|
||||
|| (signed_int && ((pad ^ src[n]) & 0x80) != 0))
|
||||
return 0;
|
||||
memcpy(dest, src + n, dest_len);
|
||||
}
|
||||
} else /* IS_LITTLE_ENDIAN */ {
|
||||
if (src_len < dest_len) {
|
||||
n = dest_len - src_len;
|
||||
memset(dest + src_len, pad, n);
|
||||
memcpy(dest, src, src_len);
|
||||
} else {
|
||||
n = src_len - dest_len;
|
||||
if (!check_sign_bytes(src + dest_len, n, pad)
|
||||
/*
|
||||
* Shortening a signed value must retain the correct sign.
|
||||
* Avoiding this kind of thing: 130 = 0x0082 -> 0x82 = -126
|
||||
*/
|
||||
|| (signed_int && ((pad ^ src[dest_len - 1]) & 0x80) != 0))
|
||||
return 0;
|
||||
memcpy(dest, src, dest_len);
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Copy a signed number to a signed number of possibly different length */
|
||||
static int signed_from_signed(void *dest, size_t dest_len,
|
||||
const void *src, size_t src_len)
|
||||
{
|
||||
return copy_integer(dest, dest_len, src, src_len,
|
||||
is_negative(src, src_len) ? 0xff : 0, 1);
|
||||
}
|
||||
|
||||
/* Copy an unsigned number to a signed number of possibly different length */
|
||||
static int signed_from_unsigned(void *dest, size_t dest_len,
|
||||
const void *src, size_t src_len)
|
||||
{
|
||||
return copy_integer(dest, dest_len, src, src_len, 0, 1);
|
||||
}
|
||||
|
||||
/* Copy a signed number to an unsigned number of possibly different length */
|
||||
static int unsigned_from_signed(void *dest, size_t dest_len,
|
||||
const void *src, size_t src_len)
|
||||
{
|
||||
if (is_negative(src, src_len))
|
||||
return 0;
|
||||
return copy_integer(dest, dest_len, src, src_len, 0, 0);
|
||||
}
|
||||
|
||||
/* Copy an unsigned number to an unsigned number of possibly different length */
|
||||
static int unsigned_from_unsigned(void *dest, size_t dest_len,
|
||||
const void *src, size_t src_len)
|
||||
{
|
||||
return copy_integer(dest, dest_len, src, src_len, 0, 0);
|
||||
}
|
||||
|
||||
/* General purpose get integer parameter call that handles odd sizes */
|
||||
static int general_get_int(const OSSL_PARAM *p, void *val, size_t val_size)
|
||||
{
|
||||
if (p->data_type == OSSL_PARAM_INTEGER)
|
||||
return signed_from_signed(val, val_size, p->data, p->data_size);
|
||||
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
|
||||
return signed_from_unsigned(val, val_size, p->data, p->data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* General purpose set integer parameter call that handles odd sizes */
|
||||
static int general_set_int(OSSL_PARAM *p, void *val, size_t val_size)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
p->return_size = val_size; /* Expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
if (p->data_type == OSSL_PARAM_INTEGER)
|
||||
r = signed_from_signed(p->data, p->data_size, val, val_size);
|
||||
else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
|
||||
r = unsigned_from_signed(p->data, p->data_size, val, val_size);
|
||||
p->return_size = r ? p->data_size : val_size;
|
||||
return r;
|
||||
}
|
||||
|
||||
/* General purpose get unsigned integer parameter call that handles odd sizes */
|
||||
static int general_get_uint(const OSSL_PARAM *p, void *val, size_t val_size)
|
||||
{
|
||||
if (p->data_type == OSSL_PARAM_INTEGER)
|
||||
return unsigned_from_signed(val, val_size, p->data, p->data_size);
|
||||
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
|
||||
return unsigned_from_unsigned(val, val_size, p->data, p->data_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* General purpose set unsigned integer parameter call that handles odd sizes */
|
||||
static int general_set_uint(OSSL_PARAM *p, void *val, size_t val_size)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
p->return_size = val_size; /* Expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
if (p->data_type == OSSL_PARAM_INTEGER)
|
||||
r = signed_from_unsigned(p->data, p->data_size, val, val_size);
|
||||
else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER)
|
||||
r = unsigned_from_unsigned(p->data, p->data_size, val, val_size);
|
||||
p->return_size = r ? p->data_size : val_size;
|
||||
return r;
|
||||
}
|
||||
|
||||
int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(int)) {
|
||||
case sizeof(int32_t):
|
||||
return OSSL_PARAM_get_int32(p, (int32_t *)val);
|
||||
case sizeof(int64_t):
|
||||
return OSSL_PARAM_get_int64(p, (int64_t *)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
}
|
||||
|
||||
int OSSL_PARAM_set_int(OSSL_PARAM *p, int val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(int)) {
|
||||
case sizeof(int32_t):
|
||||
return OSSL_PARAM_set_int32(p, (int32_t)val);
|
||||
case sizeof(int64_t):
|
||||
return OSSL_PARAM_set_int64(p, (int64_t)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
}
|
||||
|
||||
OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
|
||||
@ -91,24 +247,28 @@ OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
|
||||
|
||||
int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(unsigned int)) {
|
||||
case sizeof(uint32_t):
|
||||
return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
|
||||
case sizeof(uint64_t):
|
||||
return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
}
|
||||
|
||||
int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(unsigned int)) {
|
||||
case sizeof(uint32_t):
|
||||
return OSSL_PARAM_set_uint32(p, (uint32_t)val);
|
||||
case sizeof(uint64_t):
|
||||
return OSSL_PARAM_set_uint64(p, (uint64_t)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
}
|
||||
|
||||
OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
|
||||
@ -119,24 +279,28 @@ OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
|
||||
|
||||
int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(long int)) {
|
||||
case sizeof(int32_t):
|
||||
return OSSL_PARAM_get_int32(p, (int32_t *)val);
|
||||
case sizeof(int64_t):
|
||||
return OSSL_PARAM_get_int64(p, (int64_t *)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
}
|
||||
|
||||
int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(long int)) {
|
||||
case sizeof(int32_t):
|
||||
return OSSL_PARAM_set_int32(p, (int32_t)val);
|
||||
case sizeof(int64_t):
|
||||
return OSSL_PARAM_set_int64(p, (int64_t)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
}
|
||||
|
||||
OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
|
||||
@ -146,24 +310,28 @@ OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
|
||||
|
||||
int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(unsigned long int)) {
|
||||
case sizeof(uint32_t):
|
||||
return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
|
||||
case sizeof(uint64_t):
|
||||
return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
}
|
||||
|
||||
int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(unsigned long int)) {
|
||||
case sizeof(uint32_t):
|
||||
return OSSL_PARAM_set_uint32(p, (uint32_t)val);
|
||||
case sizeof(uint64_t):
|
||||
return OSSL_PARAM_set_uint64(p, (uint64_t)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
}
|
||||
|
||||
OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
|
||||
@ -174,15 +342,15 @@ OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
|
||||
|
||||
int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
|
||||
{
|
||||
int64_t i64;
|
||||
uint32_t u32;
|
||||
uint64_t u64;
|
||||
double d;
|
||||
|
||||
if (val == NULL || p == NULL )
|
||||
return 0;
|
||||
|
||||
if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
int64_t i64;
|
||||
|
||||
switch (p->data_size) {
|
||||
case sizeof(int32_t):
|
||||
*val = *(const int32_t *)p->data;
|
||||
@ -193,9 +361,16 @@ int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
|
||||
*val = (int32_t)i64;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
|
||||
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
uint32_t u32;
|
||||
uint64_t u64;
|
||||
|
||||
switch (p->data_size) {
|
||||
case sizeof(uint32_t):
|
||||
u32 = *(const uint32_t *)p->data;
|
||||
@ -203,15 +378,18 @@ int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
|
||||
*val = (int32_t)u32;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(uint64_t):
|
||||
u64 = *(const uint64_t *)p->data;
|
||||
if (u64 <= INT32_MAX) {
|
||||
*val = (int32_t)u64;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
switch (p->data_size) {
|
||||
case sizeof(double):
|
||||
@ -232,6 +410,7 @@ int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
|
||||
return 0;
|
||||
p->return_size = 0;
|
||||
if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(int32_t); /* Minimum expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -244,7 +423,10 @@ int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
|
||||
*(int64_t *)p->data = (int64_t)val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(uint32_t); /* Minimum expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -257,6 +439,8 @@ int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
|
||||
*(uint64_t *)p->data = (uint64_t)val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
p->return_size = sizeof(double);
|
||||
if (p->data == NULL)
|
||||
@ -278,15 +462,15 @@ OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
|
||||
|
||||
int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
|
||||
{
|
||||
int32_t i32;
|
||||
int64_t i64;
|
||||
uint64_t u64;
|
||||
double d;
|
||||
|
||||
if (val == NULL || p == NULL)
|
||||
return 0;
|
||||
|
||||
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
uint64_t u64;
|
||||
|
||||
switch (p->data_size) {
|
||||
case sizeof(uint32_t):
|
||||
*val = *(const uint32_t *)p->data;
|
||||
@ -297,9 +481,15 @@ int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
|
||||
*val = (uint32_t)u64;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
} else if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
int32_t i32;
|
||||
int64_t i64;
|
||||
|
||||
switch (p->data_size) {
|
||||
case sizeof(int32_t):
|
||||
i32 = *(const int32_t *)p->data;
|
||||
@ -307,15 +497,17 @@ int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
|
||||
*val = i32;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(int64_t):
|
||||
i64 = *(const int64_t *)p->data;
|
||||
if (i64 >= 0 && i64 <= UINT32_MAX) {
|
||||
*val = (uint32_t)i64;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
switch (p->data_size) {
|
||||
case sizeof(double):
|
||||
@ -337,6 +529,7 @@ int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
|
||||
p->return_size = 0;
|
||||
|
||||
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(uint32_t); /* Minimum expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -349,7 +542,10 @@ int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
|
||||
*(uint64_t *)p->data = val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(int32_t); /* Minimum expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -359,12 +555,14 @@ int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
|
||||
*(int32_t *)p->data = (int32_t)val;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(int64_t):
|
||||
p->return_size = sizeof(int64_t);
|
||||
*(int64_t *)p->data = (int64_t)val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
p->return_size = sizeof(double);
|
||||
if (p->data == NULL)
|
||||
@ -386,13 +584,13 @@ OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
|
||||
|
||||
int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
|
||||
{
|
||||
uint64_t u64;
|
||||
double d;
|
||||
|
||||
if (val == NULL || p == NULL )
|
||||
return 0;
|
||||
|
||||
if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (p->data_size) {
|
||||
case sizeof(int32_t):
|
||||
*val = *(const int32_t *)p->data;
|
||||
@ -401,7 +599,12 @@ int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
|
||||
*val = *(const int64_t *)p->data;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
uint64_t u64;
|
||||
|
||||
switch (p->data_size) {
|
||||
case sizeof(uint32_t):
|
||||
*val = *(const uint32_t *)p->data;
|
||||
@ -412,8 +615,10 @@ int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
|
||||
*val = (int64_t)u64;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
switch (p->data_size) {
|
||||
case sizeof(double):
|
||||
@ -443,6 +648,7 @@ int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
|
||||
return 0;
|
||||
p->return_size = 0;
|
||||
if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(int64_t); /* Expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -453,12 +659,15 @@ int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
|
||||
*(int32_t *)p->data = (int32_t)val;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(int64_t):
|
||||
*(int64_t *)p->data = val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(uint64_t); /* Expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -469,11 +678,13 @@ int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
|
||||
*(uint32_t *)p->data = (uint32_t)val;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(uint64_t):
|
||||
*(uint64_t *)p->data = (uint64_t)val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
p->return_size = sizeof(double);
|
||||
if (p->data == NULL)
|
||||
@ -498,14 +709,13 @@ OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
|
||||
|
||||
int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
|
||||
{
|
||||
int32_t i32;
|
||||
int64_t i64;
|
||||
double d;
|
||||
|
||||
if (val == NULL || p == NULL)
|
||||
return 0;
|
||||
|
||||
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (p->data_size) {
|
||||
case sizeof(uint32_t):
|
||||
*val = *(const uint32_t *)p->data;
|
||||
@ -514,7 +724,13 @@ int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
|
||||
*val = *(const uint64_t *)p->data;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
} else if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
int32_t i32;
|
||||
int64_t i64;
|
||||
|
||||
switch (p->data_size) {
|
||||
case sizeof(int32_t):
|
||||
i32 = *(const int32_t *)p->data;
|
||||
@ -522,15 +738,17 @@ int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
|
||||
*val = (uint64_t)i32;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(int64_t):
|
||||
i64 = *(const int64_t *)p->data;
|
||||
if (i64 >= 0) {
|
||||
*val = (uint64_t)i64;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
switch (p->data_size) {
|
||||
case sizeof(double):
|
||||
@ -559,6 +777,7 @@ int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
|
||||
p->return_size = 0;
|
||||
|
||||
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(uint64_t); /* Expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -569,12 +788,15 @@ int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
|
||||
*(uint32_t *)p->data = (uint32_t)val;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(uint64_t):
|
||||
*(uint64_t *)p->data = val;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_INTEGER) {
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
p->return_size = sizeof(int64_t); /* Expected size */
|
||||
if (p->data == NULL)
|
||||
return 1;
|
||||
@ -585,14 +807,16 @@ int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
|
||||
*(int32_t *)p->data = (int32_t)val;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
case sizeof(int64_t):
|
||||
if (val <= INT64_MAX) {
|
||||
*(int64_t *)p->data = (int64_t)val;
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
} else if (p->data_type == OSSL_PARAM_REAL) {
|
||||
p->return_size = sizeof(double);
|
||||
switch (p->data_size) {
|
||||
@ -615,24 +839,28 @@ OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
|
||||
|
||||
int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(size_t)) {
|
||||
case sizeof(uint32_t):
|
||||
return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
|
||||
case sizeof(uint64_t):
|
||||
return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_get_uint(p, val, sizeof(*val));
|
||||
}
|
||||
|
||||
int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(size_t)) {
|
||||
case sizeof(uint32_t):
|
||||
return OSSL_PARAM_set_uint32(p, (uint32_t)val);
|
||||
case sizeof(uint64_t):
|
||||
return OSSL_PARAM_set_uint64(p, (uint64_t)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_set_uint(p, &val, sizeof(val));
|
||||
}
|
||||
|
||||
OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
|
||||
@ -643,24 +871,28 @@ OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
|
||||
|
||||
int OSSL_PARAM_get_time_t(const OSSL_PARAM *p, time_t *val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(time_t)) {
|
||||
case sizeof(int32_t):
|
||||
return OSSL_PARAM_get_int32(p, (int32_t *)val);
|
||||
case sizeof(int64_t):
|
||||
return OSSL_PARAM_get_int64(p, (int64_t *)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_get_int(p, val, sizeof(*val));
|
||||
}
|
||||
|
||||
int OSSL_PARAM_set_time_t(OSSL_PARAM *p, time_t val)
|
||||
{
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
switch (sizeof(time_t)) {
|
||||
case sizeof(int32_t):
|
||||
return OSSL_PARAM_set_int32(p, (int32_t)val);
|
||||
case sizeof(int64_t):
|
||||
return OSSL_PARAM_set_int64(p, (int64_t)val);
|
||||
}
|
||||
return 0;
|
||||
#endif
|
||||
return general_set_int(p, &val, sizeof(val));
|
||||
}
|
||||
|
||||
OSSL_PARAM OSSL_PARAM_construct_time_t(const char *key, time_t *buf)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user