QuasarApp/openssl
4
0
Fork 0
mirror of https://github.com/QuasarApp/openssl.git synced 2025-05-19 21:09:41 +00:00
Code Issues Projects Releases Wiki Activity

Change OSSL_PARAM return size to not be a pointer.

Browse Source 
Instead of referencing the return size from the OSSL_PARAM structure, make the
size a field within the structure.

Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/9135)
This commit is contained in:
Pauli 2019-06-24 14:43:55 +10:00
parent 0ccff7a7ea
commit 4e7991b497
33 changed files with 359 additions and 498 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
crypto/evp/digest.c
View File

@ -365,8 +365,7 @@ int EVP_DigestFinalXOF(EVP_MD_CTX *ctx, unsigned char *md, size_t size)
return 0; return 0;
} }
params[i++] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, params[i++] = OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &size);
&size, NULL);
params[i++] = OSSL_PARAM_construct_end(); params[i++] = OSSL_PARAM_construct_end();
if (EVP_MD_CTX_set_params(ctx, params) > 0) if (EVP_MD_CTX_set_params(ctx, params) > 0)
@ -532,7 +531,7 @@ int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[])
return 0; return 0;
} }
int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]) int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[])
{ {
if (ctx->digest != NULL && ctx->digest->get_params != NULL) if (ctx->digest != NULL && ctx->digest->get_params != NULL)
return ctx->digest->get_params(ctx->provctx, params); return ctx->digest->get_params(ctx->provctx, params);
@ -545,7 +544,7 @@ int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)
if (ctx->digest != NULL) { if (ctx->digest != NULL) {
if (ctx->digest->prov != NULL) { if (ctx->digest->prov != NULL) {
OSSL_PARAM params[2]; OSSL_PARAM params[2];
size_t i, sz, n = 0; size_t i, n = 0;
switch (cmd) { switch (cmd) {
case EVP_MD_CTRL_XOF_LEN: case EVP_MD_CTRL_XOF_LEN:
@ -553,8 +552,7 @@ int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)
break; break;
i = (size_t)p1; i = (size_t)p1;
params[n++] = params[n++] =
OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &i, OSSL_PARAM_construct_size_t(OSSL_DIGEST_PARAM_XOFLEN, &i);
&sz);
params[n++] = OSSL_PARAM_construct_end(); params[n++] = OSSL_PARAM_construct_end();
return ctx->digest->set_params(ctx->provctx, params); return ctx->digest->set_params(ctx->provctx, params);
case EVP_MD_CTRL_MICALG: case EVP_MD_CTRL_MICALG:
@ -562,7 +560,7 @@ int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2)
break; break;
params[n++] = params[n++] =
OSSL_PARAM_construct_utf8_string(OSSL_DIGEST_PARAM_MICALG, OSSL_PARAM_construct_utf8_string(OSSL_DIGEST_PARAM_MICALG,
p2, p1 ? p1 : 9999, &sz); p2, p1 ? p1 : 9999);
params[n++] = OSSL_PARAM_construct_end(); params[n++] = OSSL_PARAM_construct_end();
return ctx->digest->get_params(ctx->provctx, params); return ctx->digest->get_params(ctx->provctx, params);
} }

207
crypto/params.c
View File

@ -12,11 +12,7 @@
#include <openssl/params.h> #include <openssl/params.h>
#include "internal/thread_once.h" #include "internal/thread_once.h"
#define SET_RETURN_SIZE(p, sz) \ OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key)
if ((p)->return_size != NULL) \
*(p)->return_size = (sz)
const OSSL_PARAM *OSSL_PARAM_locate(const OSSL_PARAM *p, const char *key)
{ {
if (p != NULL && key != NULL) if (p != NULL && key != NULL)
for (; p->key != NULL; p++) for (; p->key != NULL; p++)
@ -25,9 +21,13 @@ const OSSL_PARAM *OSSL_PARAM_locate(const OSSL_PARAM *p, const char *key)
return NULL; return NULL;
} }
const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key)
{
return OSSL_PARAM_locate((OSSL_PARAM *)p, key);
}
static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type, static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
void *data, size_t data_size, void *data, size_t data_size)
size_t *return_size)
{ {
OSSL_PARAM res; OSSL_PARAM res;
@ -35,7 +35,7 @@ static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
res.data_type = data_type; res.data_type = data_type;
res.data = data; res.data = data;
res.data_size = data_size; res.data_size = data_size;
res.return_size = return_size; res.return_size = 0;
return res; return res;
} }
@ -50,7 +50,7 @@ int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val)
return 0; return 0;
} }
int OSSL_PARAM_set_int(const OSSL_PARAM *p, int val) int OSSL_PARAM_set_int(OSSL_PARAM *p, int val)
{ {
switch (sizeof(int)) { switch (sizeof(int)) {
case sizeof(int32_t): case sizeof(int32_t):
@ -61,10 +61,9 @@ int OSSL_PARAM_set_int(const OSSL_PARAM *p, int val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf, size_t *rsize) OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
{ {
return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int), return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int));
rsize);
} }
int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val) int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
@ -78,7 +77,7 @@ int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
return 0; return 0;
} }
int OSSL_PARAM_set_uint(const OSSL_PARAM *p, unsigned int val) int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val)
{ {
switch (sizeof(unsigned int)) { switch (sizeof(unsigned int)) {
case sizeof(uint32_t): case sizeof(uint32_t):
@ -89,11 +88,10 @@ int OSSL_PARAM_set_uint(const OSSL_PARAM *p, unsigned int val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf, OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
sizeof(unsigned int), rsize); sizeof(unsigned int));
} }
int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val) int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
@ -107,7 +105,7 @@ int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
return 0; return 0;
} }
int OSSL_PARAM_set_long(const OSSL_PARAM *p, long int val) int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val)
{ {
switch (sizeof(long int)) { switch (sizeof(long int)) {
case sizeof(int32_t): case sizeof(int32_t):
@ -118,11 +116,9 @@ int OSSL_PARAM_set_long(const OSSL_PARAM *p, long int val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf, OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int), return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int));
rsize);
} }
int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val) int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
@ -136,7 +132,7 @@ int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
return 0; return 0;
} }
int OSSL_PARAM_set_ulong(const OSSL_PARAM *p, unsigned long int val) int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val)
{ {
switch (sizeof(unsigned long int)) { switch (sizeof(unsigned long int)) {
case sizeof(uint32_t): case sizeof(uint32_t):
@ -147,11 +143,10 @@ int OSSL_PARAM_set_ulong(const OSSL_PARAM *p, unsigned long int val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf, OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
sizeof(unsigned long int), rsize); sizeof(unsigned long int));
} }
int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val) int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
@ -208,35 +203,35 @@ int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
return 0; return 0;
} }
int OSSL_PARAM_set_int32(const OSSL_PARAM *p, int32_t val) int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (p->data_type == OSSL_PARAM_INTEGER) { if (p->data_type == OSSL_PARAM_INTEGER) {
SET_RETURN_SIZE(p, sizeof(int32_t)); /* Minimum expected size */ p->return_size = sizeof(int32_t); /* Minimum expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(int32_t): case sizeof(int32_t):
*(int32_t *)p->data = val; *(int32_t *)p->data = val;
return 1; return 1;
case sizeof(int64_t): case sizeof(int64_t):
SET_RETURN_SIZE(p, sizeof(int64_t)); p->return_size = sizeof(int64_t);
*(int64_t *)p->data = (int64_t)val; *(int64_t *)p->data = (int64_t)val;
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) { } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
SET_RETURN_SIZE(p, sizeof(uint32_t)); /* Minimum expected size */ p->return_size = sizeof(uint32_t); /* Minimum expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(uint32_t): case sizeof(uint32_t):
*(uint32_t *)p->data = (uint32_t)val; *(uint32_t *)p->data = (uint32_t)val;
return 1; return 1;
case sizeof(uint64_t): case sizeof(uint64_t):
SET_RETURN_SIZE(p, sizeof(uint64_t)); p->return_size = sizeof(uint64_t);
*(uint64_t *)p->data = (uint64_t)val; *(uint64_t *)p->data = (uint64_t)val;
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_REAL) { } else if (p->data_type == OSSL_PARAM_REAL) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(double): case sizeof(double):
*(double *)p->data = (double)val; *(double *)p->data = (double)val;
@ -246,11 +241,10 @@ int OSSL_PARAM_set_int32(const OSSL_PARAM *p, int32_t val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf, OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf,
sizeof(int32_t), rsize); sizeof(int32_t));
} }
int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val) int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
@ -307,25 +301,25 @@ int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
return 0; return 0;
} }
int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val) int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
SET_RETURN_SIZE(p, sizeof(uint32_t)); /* Minimum expected size */ p->return_size = sizeof(uint32_t); /* Minimum expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(uint32_t): case sizeof(uint32_t):
*(uint32_t *)p->data = val; *(uint32_t *)p->data = val;
return 1; return 1;
case sizeof(uint64_t): case sizeof(uint64_t):
SET_RETURN_SIZE(p, sizeof(uint64_t)); p->return_size = sizeof(uint64_t);
*(uint64_t *)p->data = val; *(uint64_t *)p->data = val;
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_INTEGER) { } else if (p->data_type == OSSL_PARAM_INTEGER) {
SET_RETURN_SIZE(p, sizeof(int32_t)); /* Minimum expected size */ p->return_size = sizeof(int32_t); /* Minimum expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(int32_t): case sizeof(int32_t):
if (val <= INT32_MAX) { if (val <= INT32_MAX) {
@ -334,12 +328,12 @@ int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val)
} }
break; break;
case sizeof(int64_t): case sizeof(int64_t):
SET_RETURN_SIZE(p, sizeof(int64_t)); p->return_size = sizeof(int64_t);
*(int64_t *)p->data = (int64_t)val; *(int64_t *)p->data = (int64_t)val;
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_REAL) { } else if (p->data_type == OSSL_PARAM_REAL) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(double): case sizeof(double):
*(double *)p->data = (double)val; *(double *)p->data = (double)val;
@ -349,11 +343,10 @@ int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf, OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
sizeof(uint32_t), rsize); sizeof(uint32_t));
} }
int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val) int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
@ -400,19 +393,19 @@ int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
return 0; return 0;
} }
int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val) int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
{ {
uint64_t u64; uint64_t u64;
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (p->data_type == OSSL_PARAM_INTEGER) { if (p->data_type == OSSL_PARAM_INTEGER) {
SET_RETURN_SIZE(p, sizeof(int64_t)); /* Expected size */ p->return_size = sizeof(int64_t); /* Expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(int32_t): case sizeof(int32_t):
if (val >= INT32_MIN && val <= INT32_MAX) { if (val >= INT32_MIN && val <= INT32_MAX) {
SET_RETURN_SIZE(p, sizeof(int32_t)); p->return_size = sizeof(int32_t);
*(int32_t *)p->data = (int32_t)val; *(int32_t *)p->data = (int32_t)val;
return 1; return 1;
} }
@ -422,11 +415,11 @@ int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) { } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
SET_RETURN_SIZE(p, sizeof(uint64_t)); /* Expected size */ p->return_size = sizeof(uint64_t); /* Expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(uint32_t): case sizeof(uint32_t):
if (val <= UINT32_MAX) { if (val <= UINT32_MAX) {
SET_RETURN_SIZE(p, sizeof(uint32_t)); p->return_size = sizeof(uint32_t);
*(uint32_t *)p->data = (uint32_t)val; *(uint32_t *)p->data = (uint32_t)val;
return 1; return 1;
} }
@ -436,7 +429,7 @@ int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_REAL) { } else if (p->data_type == OSSL_PARAM_REAL) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(double): case sizeof(double):
u64 = val < 0 ? -val : val; u64 = val < 0 ? -val : val;
@ -450,11 +443,9 @@ int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf, OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t), return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t));
rsize);
} }
int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val) int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
@ -506,18 +497,18 @@ int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
return 0; return 0;
} }
int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val) int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) { if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
SET_RETURN_SIZE(p, sizeof(uint64_t)); /* Expected size */ p->return_size = sizeof(uint64_t); /* Expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(uint32_t): case sizeof(uint32_t):
if (val <= UINT32_MAX) { if (val <= UINT32_MAX) {
SET_RETURN_SIZE(p, sizeof(uint32_t)); p->return_size = sizeof(uint32_t);
*(uint32_t *)p->data = (uint32_t)val; *(uint32_t *)p->data = (uint32_t)val;
return 1; return 1;
} }
@ -527,11 +518,11 @@ int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
return 1; return 1;
} }
} else if (p->data_type == OSSL_PARAM_INTEGER) { } else if (p->data_type == OSSL_PARAM_INTEGER) {
SET_RETURN_SIZE(p, sizeof(int64_t)); /* Expected size */ p->return_size = sizeof(int64_t); /* Expected size */
switch (p->data_size) { switch (p->data_size) {
case sizeof(int32_t): case sizeof(int32_t):
if (val <= INT32_MAX) { if (val <= INT32_MAX) {
SET_RETURN_SIZE(p, sizeof(int32_t)); p->return_size = sizeof(int32_t);
*(int32_t *)p->data = (int32_t)val; *(int32_t *)p->data = (int32_t)val;
return 1; return 1;
} }
@ -544,7 +535,7 @@ int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
break; break;
} }
} else if (p->data_type == OSSL_PARAM_REAL) { } else if (p->data_type == OSSL_PARAM_REAL) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(double): case sizeof(double):
if ((val >> 53) == 0) { /* 53 significant bits in the mantissa */ if ((val >> 53) == 0) { /* 53 significant bits in the mantissa */
@ -557,10 +548,10 @@ int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf, OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
size_t *rsize) { {
return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
sizeof(uint64_t), rsize); sizeof(uint64_t));
} }
int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val) int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
@ -574,7 +565,7 @@ int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
return 0; return 0;
} }
int OSSL_PARAM_set_size_t(const OSSL_PARAM *p, size_t val) int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
{ {
switch (sizeof(size_t)) { switch (sizeof(size_t)) {
case sizeof(uint32_t): case sizeof(uint32_t):
@ -585,11 +576,11 @@ int OSSL_PARAM_set_size_t(const OSSL_PARAM *p, size_t val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf, OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf, return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
sizeof(size_t), rsize); } sizeof(size_t));
}
#ifndef FIPS_MODE #ifndef FIPS_MODE
/* /*
@ -615,13 +606,13 @@ int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val)
return 0; return 0;
} }
int OSSL_PARAM_set_BN(const OSSL_PARAM *p, const BIGNUM *val) int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val)
{ {
size_t bytes; size_t bytes;
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER) if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
return 0; return 0;
@ -630,16 +621,16 @@ int OSSL_PARAM_set_BN(const OSSL_PARAM *p, const BIGNUM *val)
return 0; return 0;
bytes = (size_t)BN_num_bytes(val); bytes = (size_t)BN_num_bytes(val);
SET_RETURN_SIZE(p, bytes); p->return_size = bytes;
return p->data_size >= bytes return p->data_size >= bytes
&& BN_bn2nativepad(val, p->data, bytes) >= 0; && BN_bn2nativepad(val, p->data, bytes) >= 0;
} }
OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf, OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
size_t bsize, size_t *rsize) size_t bsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER,
buf, bsize, rsize); buf, bsize);
} }
#endif #endif
@ -688,14 +679,14 @@ int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val)
return 0; return 0;
} }
int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val) int OSSL_PARAM_set_double(OSSL_PARAM *p, double val)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (p->data_type == OSSL_PARAM_REAL) { if (p->data_type == OSSL_PARAM_REAL) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(double): case sizeof(double):
*(double *)p->data = val; *(double *)p->data = val;
@ -703,35 +694,35 @@ int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val)
} }
} else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER
&& val == (uintmax_t)val) { && val == (uintmax_t)val) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(uint32_t): case sizeof(uint32_t):
if (val >= 0 && val <= UINT32_MAX) { if (val >= 0 && val <= UINT32_MAX) {
SET_RETURN_SIZE(p, sizeof(uint32_t)); p->return_size = sizeof(uint32_t);
*(uint32_t *)p->data = (uint32_t)val; *(uint32_t *)p->data = (uint32_t)val;
return 1; return 1;
} }
break; break;
case sizeof(uint64_t): case sizeof(uint64_t):
if (val >= 0 && val <= UINT64_MAX) { if (val >= 0 && val <= UINT64_MAX) {
SET_RETURN_SIZE(p, sizeof(uint64_t)); p->return_size = sizeof(uint64_t);
*(uint64_t *)p->data = (uint64_t)val; *(uint64_t *)p->data = (uint64_t)val;
return 1; return 1;
} }
break; } break; }
} else if (p->data_type == OSSL_PARAM_INTEGER && val == (intmax_t)val) { } else if (p->data_type == OSSL_PARAM_INTEGER && val == (intmax_t)val) {
SET_RETURN_SIZE(p, sizeof(double)); p->return_size = sizeof(double);
switch (p->data_size) { switch (p->data_size) {
case sizeof(int32_t): case sizeof(int32_t):
if (val >= INT32_MIN && val <= INT32_MAX) { if (val >= INT32_MIN && val <= INT32_MAX) {
SET_RETURN_SIZE(p, sizeof(int32_t)); p->return_size = sizeof(int32_t);
*(int32_t *)p->data = (int32_t)val; *(int32_t *)p->data = (int32_t)val;
return 1; return 1;
} }
break; break;
case sizeof(int64_t): case sizeof(int64_t):
if (val >= INT64_MIN && val <= INT64_MAX) { if (val >= INT64_MIN && val <= INT64_MAX) {
SET_RETURN_SIZE(p, sizeof(int64_t)); p->return_size = sizeof(int64_t);
*(int64_t *)p->data = (int64_t)val; *(int64_t *)p->data = (int64_t)val;
return 1; return 1;
} }
@ -741,11 +732,9 @@ int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val)
return 0; return 0;
} }
OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf, OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf)
size_t *rsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double), return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double));
rsize);
} }
static int get_string_internal(const OSSL_PARAM *p, void **val, size_t max_len, static int get_string_internal(const OSSL_PARAM *p, void **val, size_t max_len,
@ -789,10 +778,10 @@ int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
OSSL_PARAM_OCTET_STRING); OSSL_PARAM_OCTET_STRING);
} }
static int set_string_internal(const OSSL_PARAM *p, const void *val, size_t len, static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
unsigned int type) unsigned int type)
{ {
SET_RETURN_SIZE(p, len); p->return_size = len;
if (p->data_type != type || p->data_size < len) if (p->data_type != type || p->data_size < len)
return 0; return 0;
@ -800,41 +789,39 @@ static int set_string_internal(const OSSL_PARAM *p, const void *val, size_t len,
return 1; return 1;
} }
int OSSL_PARAM_set_utf8_string(const OSSL_PARAM *p, const char *val) int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (val == NULL) if (val == NULL)
return 0; return 0;
return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING); return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING);
} }
int OSSL_PARAM_set_octet_string(const OSSL_PARAM *p, const void *val, int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
size_t len) size_t len)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (val == NULL) if (val == NULL)
return 0; return 0;
return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING); return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
} }
OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf, OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
size_t bsize, size_t *rsize) size_t bsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize, return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
rsize);
} }
OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf, OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
size_t bsize, size_t *rsize) size_t bsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize, return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
rsize);
} }
static int get_ptr_internal(const OSSL_PARAM *p, const void **val, static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
@ -859,47 +846,47 @@ int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR); return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
} }
static int set_ptr_internal(const OSSL_PARAM *p, const void *val, static int set_ptr_internal(OSSL_PARAM *p, const void *val,
unsigned int type, size_t len) unsigned int type, size_t len)
{ {
SET_RETURN_SIZE(p, len); p->return_size = len;
if (p->data_type != type) if (p->data_type != type)
return 0; return 0;
*(const void **)p->data = val; *(const void **)p->data = val;
return 1; return 1;
} }
int OSSL_PARAM_set_utf8_ptr(const OSSL_PARAM *p, const char *val) int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (val == NULL) if (val == NULL)
return 0; return 0;
return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1); return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1);
} }
int OSSL_PARAM_set_octet_ptr(const OSSL_PARAM *p, const void *val, int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
size_t used_len) size_t used_len)
{ {
if (p == NULL) if (p == NULL)
return 0; return 0;
SET_RETURN_SIZE(p, 0); p->return_size = 0;
if (val == NULL) if (val == NULL)
return 0; return 0;
return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len); return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len);
} }
OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf, OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
size_t bsize, size_t *rsize) size_t bsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize, rsize); return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize);
} }
OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf, OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
size_t bsize, size_t *rsize) size_t bsize)
{ {
return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize, rsize); return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize);
} }
OSSL_PARAM OSSL_PARAM_construct_end(void) OSSL_PARAM OSSL_PARAM_construct_end(void)

3
crypto/provider.c
View File

@ -40,8 +40,7 @@ const OSSL_ITEM *OSSL_PROVIDER_get_param_types(const OSSL_PROVIDER *prov)
return ossl_provider_get_param_types(prov); return ossl_provider_get_param_types(prov);
} }
int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
const OSSL_PARAM params[])
{ {
return ossl_provider_get_params(prov, params); return ossl_provider_get_params(prov, params);
} }

7
crypto/provider_core.c
View File

@ -603,8 +603,7 @@ const OSSL_ITEM *ossl_provider_get_param_types(const OSSL_PROVIDER *prov)
? NULL : prov->get_param_types(prov->provctx); ? NULL : prov->get_param_types(prov->provctx);
} }
int ossl_provider_get_params(const OSSL_PROVIDER *prov, int ossl_provider_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
const OSSL_PARAM params[])
{ {
return prov->get_params == NULL return prov->get_params == NULL
? 0 : prov->get_params(prov->provctx, params); ? 0 : prov->get_params(prov->provctx, params);
@ -641,10 +640,10 @@ static const OSSL_ITEM *core_get_param_types(const OSSL_PROVIDER *prov)
return param_types; return param_types;
} }
static int core_get_params(const OSSL_PROVIDER *prov, const OSSL_PARAM params[]) static int core_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
{ {
int i; int i;
const OSSL_PARAM *p; OSSL_PARAM *p;
if ((p = OSSL_PARAM_locate(params, "openssl-version")) != NULL) if ((p = OSSL_PARAM_locate(params, "openssl-version")) != NULL)
OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR); OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR);

3
doc/internal/man3/ossl_provider_new.pod
View File

@ -47,8 +47,7 @@ ossl_provider_get_params, ossl_provider_query_operation
/* Thin wrappers around calls to the provider */ /* Thin wrappers around calls to the provider */
void ossl_provider_teardown(const OSSL_PROVIDER *prov); void ossl_provider_teardown(const OSSL_PROVIDER *prov);
const OSSL_ITEM *ossl_provider_get_param_types(const OSSL_PROVIDER *prov); const OSSL_ITEM *ossl_provider_get_param_types(const OSSL_PROVIDER *prov);
int ossl_provider_get_params(const OSSL_PROVIDER *prov, int ossl_provider_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]);
const OSSL_PARAM params[]);
const OSSL_ALGORITHM *ossl_provider_query_operation(const OSSL_PROVIDER *prov, const OSSL_ALGORITHM *ossl_provider_query_operation(const OSSL_PROVIDER *prov,
int operation_id, int operation_id,
int *no_cache); int *no_cache);

2
doc/man3/EVP_DigestInit.pod
View File

@ -22,7 +22,7 @@ EVP_MD_CTX_pkey_ctx, EVP_MD_CTX_set_pkey_ctx - EVP digest routines
int EVP_MD_CTX_reset(EVP_MD_CTX *ctx); int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);
void EVP_MD_CTX_free(EVP_MD_CTX *ctx); void EVP_MD_CTX_free(EVP_MD_CTX *ctx);
void EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void* p2); void EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void* p2);
int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]); int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[]);
int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]); int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]);
void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags); void EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags);
void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags); void EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags);

33
doc/man3/OSSL_PARAM.pod
View File

@ -14,7 +14,7 @@ OSSL_PARAM - a structure to pass or request object parameters
unsigned char data_type; /* declare what kind of content is in data */ unsigned char data_type; /* declare what kind of content is in data */
void *data; /* value being passed in or out */ void *data; /* value being passed in or out */
size_t data_size; /* data size */ size_t data_size; /* data size */
size_t *return_size; /* OPTIONAL: address to content size */ size_t return_size; /* returned size */
}; };
=head1 DESCRIPTION =head1 DESCRIPTION
@ -143,7 +143,7 @@ C<data_size> must be set to the size of the data, not the size of the
pointer to the data. pointer to the data.
If this is used in a parameter request, If this is used in a parameter request,
C<data_size> is not relevant. However, the I<responder> will set C<data_size> is not relevant. However, the I<responder> will set
C<*return_size> to the size of the data. C<return_size> to the size of the data.
Note that the use of this type is B<fragile> and can only be safely Note that the use of this type is B<fragile> and can only be safely
used for data that remains constant and in a constant location for a used for data that remains constant and in a constant location for a
@ -166,7 +166,7 @@ C<data_size> must be set to the size of the data, not the size of the
pointer to the data. pointer to the data.
If this is used in a parameter request, If this is used in a parameter request,
C<data_size> is not relevant. However, the I<responder> will set C<data_size> is not relevant. However, the I<responder> will set
C<*return_size> to the size of the data. C<return_size> to the size of the data.
Note that the use of this type is B<fragile> and can only be safely Note that the use of this type is B<fragile> and can only be safely
used for data that remains constant and in a constant location for a used for data that remains constant and in a constant location for a
@ -196,9 +196,10 @@ enough set of data, that call should succeed.
=item * =item *
A I<responder> must never change the fields of an C<OSSL_PARAM>, it Apart from the C<return_size>, a I<responder> must never change the fields
may only change the contents of the memory that C<data> and of an C<OSSL_PARAM>.
C<return_size> point at. To return a value, it should change the contents of the memory that
C<data> points at.
=item * =item *
@ -214,7 +215,7 @@ C<OSSL_PARAM_OCTET_STRING>), but this is in no way mandatory.
=item * =item *
If a I<responder> finds that some data sizes are too small for the If a I<responder> finds that some data sizes are too small for the
requested data, it must set C<*return_size> for each such requested data, it must set C<return_size> for each such
C<OSSL_PARAM> item to the required size, and eventually return an C<OSSL_PARAM> item to the required size, and eventually return an
error. error.
@ -244,9 +245,9 @@ This example is for setting parameters on some object:
const char *foo = "some string"; const char *foo = "some string";
size_t foo_l = strlen(foo) + 1; size_t foo_l = strlen(foo) + 1;
const char bar[] = "some other string"; const char bar[] = "some other string";
const OSSL_PARAM set[] = { OSSL_PARAM set[] = {
{ "foo", OSSL_PARAM_UTF8_STRING_PTR, &foo, foo_l, NULL }, { "foo", OSSL_PARAM_UTF8_STRING_PTR, &foo, foo_l, 0 },
{ "bar", OSSL_PARAM_UTF8_STRING, &bar, sizeof(bar), NULL }, { "bar", OSSL_PARAM_UTF8_STRING, &bar, sizeof(bar), 0 },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, NULL }
}; };
@ -258,26 +259,26 @@ This example is for requesting parameters on some object:
size_t foo_l; size_t foo_l;
char bar[1024]; char bar[1024];
size_t bar_l; size_t bar_l;
const OSSL_PARAM request[] = { OSSL_PARAM request[] = {
{ "foo", OSSL_PARAM_UTF8_STRING_PTR, &foo, 0 /*irrelevant*/, &foo_l }, { "foo", OSSL_PARAM_UTF8_STRING_PTR, &foo, 0 /*irrelevant*/, 0 },
{ "bar", OSSL_PARAM_UTF8_STRING, &bar, sizeof(bar), &bar_l }, { "bar", OSSL_PARAM_UTF8_STRING, &bar, sizeof(bar), 0 },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, NULL }
}; };
A I<responder> that receives this array (as C<params> in this example) A I<responder> that receives this array (as C<params> in this example)
could fill in the parameters like this: could fill in the parameters like this:
/* const OSSL_PARAM *params */ /* OSSL_PARAM *params */
int i; int i;
for (i = 0; params[i].key != NULL; i++) { for (i = 0; params[i].key != NULL; i++) {
if (strcmp(params[i].key, "foo") == 0) { if (strcmp(params[i].key, "foo") == 0) {
*(char **)params[i].data = "foo value"; *(char **)params[i].data = "foo value";
*params[i].return_size = 10; /* size of "foo value" */ params[i].return_size = 10; /* size of "foo value" */
} else if (strcmp(params[i].key, "bar") == 0) { } else if (strcmp(params[i].key, "bar") == 0) {
memcpy(params[i].data, "bar value", 10); memcpy(params[i].data, "bar value", 10);
*params[i].return_size = 10; /* size of "bar value" */ params[i].return_size = 10; /* size of "bar value" */
} }
/* Ignore stuff we don't know */ /* Ignore stuff we don't know */
} }

101
doc/man3/OSSL_PARAM_int.pod
View File

@ -4,14 +4,9 @@
OSSL_PARAM_double, OSSL_PARAM_int, OSSL_PARAM_int32, OSSL_PARAM_int64, OSSL_PARAM_double, OSSL_PARAM_int, OSSL_PARAM_int32, OSSL_PARAM_int64,
OSSL_PARAM_long, OSSL_PARAM_size_t, OSSL_PARAM_uint, OSSL_PARAM_uint32, OSSL_PARAM_long, OSSL_PARAM_size_t, OSSL_PARAM_uint, OSSL_PARAM_uint32,
OSSL_PARAM_uint64, OSSL_PARAM_ulong, OSSL_PARAM_utf8_string, OSSL_PARAM_uint64, OSSL_PARAM_ulong, OSSL_PARAM_BN, OSSL_PARAM_utf8_string,
OSSL_PARAM_octet_string, OSSL_PARAM_utf8_ptr, OSSL_PARAM_octet_ptr, OSSL_PARAM_octet_string, OSSL_PARAM_utf8_ptr, OSSL_PARAM_octet_ptr,
OSSL_PARAM_SIZED_double, OSSL_PARAM_SIZED_int, OSSL_PARAM_SIZED_int32, OSSL_PARAM_END, OSSL_PARAM_construct_BN, OSSL_PARAM_construct_double,
OSSL_PARAM_SIZED_int64, OSSL_PARAM_SIZED_long, OSSL_PARAM_SIZED_size_t,
OSSL_PARAM_SIZED_uint, OSSL_PARAM_SIZED_uint32, OSSL_PARAM_SIZED_uint64,
OSSL_PARAM_SIZED_ulong, OSSL_PARAM_SIZED_BN, OSSL_PARAM_SIZED_utf8_string,
OSSL_PARAM_SIZED_octet_string, OSSL_PARAM_SIZED_utf8_ptr,
OSSL_PARAM_SIZED_octet_ptr, OSSL_PARAM_END, OSSL_PARAM_construct_double,
OSSL_PARAM_construct_int, OSSL_PARAM_construct_int32, OSSL_PARAM_construct_int, OSSL_PARAM_construct_int32,
OSSL_PARAM_construct_int64, OSSL_PARAM_construct_long, OSSL_PARAM_construct_int64, OSSL_PARAM_construct_long,
OSSL_PARAM_construct_size_t, OSSL_PARAM_construct_uint, OSSL_PARAM_construct_size_t, OSSL_PARAM_construct_uint,
@ -19,15 +14,15 @@ OSSL_PARAM_construct_uint32, OSSL_PARAM_construct_uint64,
OSSL_PARAM_construct_ulong, OSSL_PARAM_END, OSSL_PARAM_construct_BN, OSSL_PARAM_construct_ulong, OSSL_PARAM_END, OSSL_PARAM_construct_BN,
OSSL_PARAM_construct_utf8_string, OSSL_PARAM_construct_utf8_ptr, OSSL_PARAM_construct_utf8_string, OSSL_PARAM_construct_utf8_ptr,
OSSL_PARAM_construct_octet_string, OSSL_PARAM_construct_octet_ptr, OSSL_PARAM_construct_octet_string, OSSL_PARAM_construct_octet_ptr,
OSSL_PARAM_construct_end, OSSL_PARAM_locate, OSSL_PARAM_get_double, OSSL_PARAM_construct_end, OSSL_PARAM_locate, OSSL_PARAM_locate_const,
OSSL_PARAM_get_int, OSSL_PARAM_get_int32, OSSL_PARAM_get_int64, OSSL_PARAM_get_double, OSSL_PARAM_get_int, OSSL_PARAM_get_int32,
OSSL_PARAM_get_long, OSSL_PARAM_get_size_t, OSSL_PARAM_get_uint, OSSL_PARAM_get_int64, OSSL_PARAM_get_long, OSSL_PARAM_get_size_t,
OSSL_PARAM_get_uint32, OSSL_PARAM_get_uint64, OSSL_PARAM_get_ulong, OSSL_PARAM_get_uint, OSSL_PARAM_get_uint32, OSSL_PARAM_get_uint64,
OSSL_PARAM_set_double, OSSL_PARAM_set_int, OSSL_PARAM_set_int32, OSSL_PARAM_get_ulong, OSSL_PARAM_set_double, OSSL_PARAM_set_int,
OSSL_PARAM_set_int64, OSSL_PARAM_set_long, OSSL_PARAM_set_size_t, OSSL_PARAM_set_int32, OSSL_PARAM_set_int64, OSSL_PARAM_set_long,
OSSL_PARAM_set_uint, OSSL_PARAM_set_uint32, OSSL_PARAM_set_uint64, OSSL_PARAM_set_size_t, OSSL_PARAM_set_uint, OSSL_PARAM_set_uint32,
OSSL_PARAM_set_ulong, OSSL_PARAM_get_BN, OSSL_PARAM_set_BN, OSSL_PARAM_set_uint64, OSSL_PARAM_set_ulong, OSSL_PARAM_get_BN,
OSSL_PARAM_get_utf8_string, OSSL_PARAM_set_utf8_string, OSSL_PARAM_set_BN, OSSL_PARAM_get_utf8_string, OSSL_PARAM_set_utf8_string,
OSSL_PARAM_get_octet_string, OSSL_PARAM_set_octet_string, OSSL_PARAM_get_octet_string, OSSL_PARAM_set_octet_string,
OSSL_PARAM_get_utf8_ptr, OSSL_PARAM_set_utf8_ptr, OSSL_PARAM_get_octet_ptr, OSSL_PARAM_get_utf8_ptr, OSSL_PARAM_set_utf8_ptr, OSSL_PARAM_get_octet_ptr,
OSSL_PARAM_set_octet_ptr OSSL_PARAM_set_octet_ptr
@ -44,52 +39,46 @@ OSSL_PARAM_set_octet_ptr
#define OSSL_PARAM_octet_string(key, address, size) #define OSSL_PARAM_octet_string(key, address, size)
#define OSSL_PARAM_utf8_ptr(key, address, size) #define OSSL_PARAM_utf8_ptr(key, address, size)
#define OSSL_PARAM_octet_ptr(key, address, size) #define OSSL_PARAM_octet_ptr(key, address, size)
#define OSSL_PARAM_BN(key, address, size)
#define OSSL_PARAM_SIZED_TYPE(key, address, return_size)
#define OSSL_PARAM_SIZED_BN(key, address, size, return_size)
#define OSSL_PARAM_SIZED_utf8_string(key, address, size, return_size)
#define OSSL_PARAM_SIZED_octet_string(key, address, size, return_size)
#define OSSL_PARAM_SIZED_utf8_ptr(key, address, size, return_size)
#define OSSL_PARAM_SIZED_octet_ptr(key, address, size, return_size)
#define OSSL_PARAM_END #define OSSL_PARAM_END
OSSL_PARAM OSSL_PARAM_construct_TYPE(const char *key, TYPE *buf, size_t *ret); OSSL_PARAM OSSL_PARAM_construct_TYPE(const char *key, TYPE *buf, size_t *ret);
OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf, OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf, OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf, OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf, OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf, OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_end(void); OSSL_PARAM OSSL_PARAM_construct_end(void);
OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *array, const char *key); OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *array, const char *key);
const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *array,
const char *key);
int OSSL_PARAM_get_TYPE(const OSSL_PARAM *p, const char *key, TYPE *val); int OSSL_PARAM_get_TYPE(const OSSL_PARAM *p, const char *key, TYPE *val);
int OSSL_PARAM_set_TYPE(const OSSL_PARAM *p, const char *key, TYPE val); int OSSL_PARAM_set_TYPE(OSSL_PARAM *p, const char *key, TYPE val);
int OSSL_PARAM_get_BN(const OSSL_PARAM *p, const char *key, BIGNUM **val); int OSSL_PARAM_get_BN(const OSSL_PARAM *p, const char *key, BIGNUM **val);
int OSSL_PARAM_set_BN(const OSSL_PARAM *p, const char *key, const BIGNUM *val); int OSSL_PARAM_set_BN(OSSL_PARAM *p, const char *key, const BIGNUM *val);
int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val,
size_t max_len); size_t max_len);
int OSSL_PARAM_set_utf8_string(const OSSL_PARAM *p, const char *val); int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val);
int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val,
size_t max_len, size_t *used_len); size_t max_len, size_t *used_len);
int OSSL_PARAM_set_octet_string(const OSSL_PARAM *p, const void *val, int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, size_t len);
size_t len);
int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, char **val); int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, char **val);
int OSSL_PARAM_set_utf8_ptr(const OSSL_PARAM *p, char *val); int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, char *val);
int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, void **val, int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, void **val,
size_t *used_len); size_t *used_len);
int OSSL_PARAM_set_octet_ptr(const OSSL_PARAM *p, void *val, size_t used_len); int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, void *val, size_t used_len);
=head1 DESCRIPTION =head1 DESCRIPTION
@ -146,26 +135,11 @@ Each of these macros defines a parameter of the specified B<TYPE> with the
provided B<key> and parameter variable B<address>. provided B<key> and parameter variable B<address>.
OSSL_PARAM_utf8_string(), OSSL_PARAM_octet_string(), OSSL_PARAM_utf8_ptr(), OSSL_PARAM_utf8_string(), OSSL_PARAM_octet_string(), OSSL_PARAM_utf8_ptr(),
OSSL_PARAM_octet_ptr() are macros that provide support for defining UTF8 OSSL_PARAM_octet_ptr(), OSSL_PARAM_BN() are macros that provide support
strings and OCTET strings. for defining UTF8 strings, OCTET strings and big numbers.
A parameter with name B<key> is defined. A parameter with name B<key> is defined.
The storage for this parameter is at B<address> and is of B<size> bytes. The storage for this parameter is at B<address> and is of B<size> bytes.
OSSL_PARAM_SIZED_TYPE() are a second series of macros designed to assist with
the initialisation of OSSL_PARAM structures.
They are similar to the OSSL_PARAM_TYPE() macros but also include a
B<return_size> argument which contains the address of a size_t variable which
will be populated with the actual size of the parameter upon return from a
OSSL_PARAM_set_TYPE() call.
OSSL_PARAM_SIZED_BN(), OSSL_PARAM_SIZED_utf8_string(),
OSSL_PARAM_SIZED_octet_string(), OSSL_PARAM_SIZED_utf8_ptr(),
OSSL_PARAM_SIZED_octet_ptr() are macros that provide support for defining large
integers, UTF8 string and OCTET strings in an OSSL_PARAM array.
A parameter with name B<key> is defined.
The storage for this parameter is at B<address> and is of B<size> bytes.
The size used by the parameter value, in bytes, is written to B<return_size>.
OSSL_PARAM_END provides an end of parameter list marker. OSSL_PARAM_END provides an end of parameter list marker.
This should terminate all OSSL_PARAM arrays. This should terminate all OSSL_PARAM arrays.
@ -205,6 +179,9 @@ OSSL_PARAM structure.
OSSL_PARAM_locate() is a function that searches an B<array> of parameters for OSSL_PARAM_locate() is a function that searches an B<array> of parameters for
the one matching the B<key> name. the one matching the B<key> name.
OSSL_PARAM_locate_const() behaves exactly like OSSL_PARAM_locate() except for
the presence of I<const> for the B<array> argument and its return value.
OSSL_PARAM_get_TYPE() retrieves a value of type B<TYPE> from the parameter B<p>. OSSL_PARAM_get_TYPE() retrieves a value of type B<TYPE> from the parameter B<p>.
The value is copied to the address B<val>. The value is copied to the address B<val>.
Type coercion takes place as discussed in the NOTES section. Type coercion takes place as discussed in the NOTES section.
@ -260,9 +237,9 @@ OSSL_PARAM_construct_utf8_string(), OSSL_PARAM_construct_octet_string(),
OSSL_PARAM_construct_utf8_ptr() and OSSL_PARAM_construct_octet_ptr() OSSL_PARAM_construct_utf8_ptr() and OSSL_PARAM_construct_octet_ptr()
return a populated OSSL_PARAM structure. return a populated OSSL_PARAM structure.
OSSL_PARAM_locate() returns a pointer to the matching OSSL_PARAM object. OSSL_PARAM_locate() and OSSL_PARAM_locate_const() return a pointer to
It returns B<NULL> on error or when no object matching B<key> exists in the matching OSSL_PARAM object. They return B<NULL> on error or when
the B<array>. no object matching B<key> exists in the B<array>.
All other functions return B<1> on success and B<0> on failure. All other functions return B<1> on success and B<0> on failure.
@ -308,21 +285,19 @@ demonstrates that the requestor isn't obligated to request all
available parameters: available parameters:
const char *foo = NULL; const char *foo = NULL;
size_t foo_l;
char bar[1024]; char bar[1024];
size_t bar_l; OSSL_PARAM request[] = {
const OSSL_PARAM request[] = { OSSL_PARAM_utf8_ptr("foo", foo, 0),
OSSL_PARAM_UTF8_PTR("foo", foo, 0, foo_l), OSSL_PARAM_utf8_string("bar", bar, sizeof(bar)),
OSSL_PARAM_UTF8_STRING("bar", bar, sizeof(bar), bar_l),
OSSL_PARAM_END OSSL_PARAM_END
}; };
A I<responder> that receives this array (as C<params> in this example) A I<responder> that receives this array (as C<params> in this example)
could fill in the parameters like this: could fill in the parameters like this:
/* const OSSL_PARAM *params */ /* OSSL_PARAM *params */
const OSSL_PARAM *p; OSSL_PARAM *p;
if ((p = OSSL_PARAM_locate(params, "foo")) == NULL) if ((p = OSSL_PARAM_locate(params, "foo")) == NULL)
OSSL_PARAM_set_utf8_ptr(p, "foo value"); OSSL_PARAM_set_utf8_ptr(p, "foo value");

4
doc/man3/OSSL_PROVIDER.pod
View File

@ -16,7 +16,7 @@ OSSL_PROVIDER_add_builtin - provider routines
int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov); int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov);
const OSSL_ITEM *OSSL_PROVIDER_get_param_types(OSSL_PROVIDER *prov); const OSSL_ITEM *OSSL_PROVIDER_get_param_types(OSSL_PROVIDER *prov);
int OSSL_PROVIDER_get_params(OSSL_PROVIDER *prov, const OSSL_PARAM params[]); int OSSL_PROVIDER_get_params(OSSL_PROVIDER *prov, OSSL_PARAM params[]);
int OSSL_PROVIDER_add_builtin(OPENSSL_CTX *, const char *name, int OSSL_PROVIDER_add_builtin(OPENSSL_CTX *, const char *name,
ossl_provider_init_fn *init_fn); ossl_provider_init_fn *init_fn);
@ -81,7 +81,7 @@ its build number.
OSSL_PROVIDER *prov = NULL; OSSL_PROVIDER *prov = NULL;
const char *build = NULL; const char *build = NULL;
size_t built_l = 0; size_t built_l = 0;
const OSSL_PARAM request[] = { OSSL_PARAM request[] = {
{ "build", OSSL_PARAM_UTF8_STRING_PTR, &build, 0, &build_l }, { "build", OSSL_PARAM_UTF8_STRING_PTR, &build, 0, &build_l },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, NULL }
}; };

3
include/internal/provider.h
View File

@ -63,8 +63,7 @@ const char *ossl_provider_module_path(const OSSL_PROVIDER *prov);
/* Thin wrappers around calls to the provider */ /* Thin wrappers around calls to the provider */
void ossl_provider_teardown(const OSSL_PROVIDER *prov); void ossl_provider_teardown(const OSSL_PROVIDER *prov);
const OSSL_ITEM *ossl_provider_get_param_types(const OSSL_PROVIDER *prov); const OSSL_ITEM *ossl_provider_get_param_types(const OSSL_PROVIDER *prov);
int ossl_provider_get_params(const OSSL_PROVIDER *prov, int ossl_provider_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]);
const OSSL_PARAM params[]);
const OSSL_ALGORITHM *ossl_provider_query_operation(const OSSL_PROVIDER *prov, const OSSL_ALGORITHM *ossl_provider_query_operation(const OSSL_PROVIDER *prov,
int operation_id, int operation_id,
int *no_cache); int *no_cache);

2
include/openssl/core.h
View File

@ -77,7 +77,7 @@ struct ossl_param_st {
unsigned int data_type; /* declare what kind of content is in buffer */ unsigned int data_type; /* declare what kind of content is in buffer */
void *data; /* value being passed in or out */ void *data; /* value being passed in or out */
size_t data_size; /* data size */ size_t data_size; /* data size */
size_t *return_size; /* OPTIONAL: address to content size */ size_t return_size; /* returned content size */
}; };
/* Currently supported OSSL_PARAM data types */ /* Currently supported OSSL_PARAM data types */

10
include/openssl/core_numbers.h
View File

@ -57,7 +57,7 @@ OSSL_CORE_MAKE_FUNC(const OSSL_ITEM *,
core_get_param_types,(const OSSL_PROVIDER *prov)) core_get_param_types,(const OSSL_PROVIDER *prov))
# define OSSL_FUNC_CORE_GET_PARAMS 2 # define OSSL_FUNC_CORE_GET_PARAMS 2
OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_PROVIDER *prov, OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_PROVIDER *prov,
const OSSL_PARAM params[])) OSSL_PARAM params[]))
# define OSSL_FUNC_CORE_THREAD_START 3 # define OSSL_FUNC_CORE_THREAD_START 3
OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_PROVIDER *prov, OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_PROVIDER *prov,
OSSL_thread_stop_handler_fn handfn)) OSSL_thread_stop_handler_fn handfn))
@ -79,7 +79,7 @@ OSSL_CORE_MAKE_FUNC(const OSSL_ITEM *,
provider_get_param_types,(void *provctx)) provider_get_param_types,(void *provctx))
# define OSSL_FUNC_PROVIDER_GET_PARAMS 1026 # define OSSL_FUNC_PROVIDER_GET_PARAMS 1026
OSSL_CORE_MAKE_FUNC(int,provider_get_params,(void *provctx, OSSL_CORE_MAKE_FUNC(int,provider_get_params,(void *provctx,
const OSSL_PARAM params[])) OSSL_PARAM params[]))
# define OSSL_FUNC_PROVIDER_QUERY_OPERATION 1027 # define OSSL_FUNC_PROVIDER_QUERY_OPERATION 1027
OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM *,provider_query_operation, OSSL_CORE_MAKE_FUNC(const OSSL_ALGORITHM *,provider_query_operation,
(void *provctx, int operation_id, const int *no_store)) (void *provctx, int operation_id, const int *no_store))
@ -120,7 +120,7 @@ OSSL_CORE_MAKE_FUNC(size_t, OP_digest_block_size, (void))
OSSL_CORE_MAKE_FUNC(int, OP_digest_set_params, OSSL_CORE_MAKE_FUNC(int, OP_digest_set_params,
(void *vctx, const OSSL_PARAM params[])) (void *vctx, const OSSL_PARAM params[]))
OSSL_CORE_MAKE_FUNC(int, OP_digest_get_params, OSSL_CORE_MAKE_FUNC(int, OP_digest_get_params,
(void *vctx, const OSSL_PARAM params[])) (void *vctx, OSSL_PARAM params[]))
/* Symmetric Ciphers */ /* Symmetric Ciphers */
@ -168,9 +168,9 @@ OSSL_CORE_MAKE_FUNC(void *, OP_cipher_dupctx, (void *cctx))
OSSL_CORE_MAKE_FUNC(size_t, OP_cipher_key_length, (void)) OSSL_CORE_MAKE_FUNC(size_t, OP_cipher_key_length, (void))
OSSL_CORE_MAKE_FUNC(size_t, OP_cipher_iv_length, (void)) OSSL_CORE_MAKE_FUNC(size_t, OP_cipher_iv_length, (void))
OSSL_CORE_MAKE_FUNC(size_t, OP_cipher_block_size, (void)) OSSL_CORE_MAKE_FUNC(size_t, OP_cipher_block_size, (void))
OSSL_CORE_MAKE_FUNC(int, OP_cipher_get_params, (const OSSL_PARAM params[])) OSSL_CORE_MAKE_FUNC(int, OP_cipher_get_params, (OSSL_PARAM params[]))
OSSL_CORE_MAKE_FUNC(int, OP_cipher_ctx_get_params, (void *cctx, OSSL_CORE_MAKE_FUNC(int, OP_cipher_ctx_get_params, (void *cctx,
const OSSL_PARAM params[])) OSSL_PARAM params[]))
OSSL_CORE_MAKE_FUNC(int, OP_cipher_ctx_set_params, (void *cctx, OSSL_CORE_MAKE_FUNC(int, OP_cipher_ctx_set_params, (void *cctx,
const OSSL_PARAM params[])) const OSSL_PARAM params[]))

2
include/openssl/evp.h
View File

@ -541,7 +541,7 @@ void BIO_set_md(BIO *, const EVP_MD *md);
OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS); OBJ_NAME_remove(alias,OBJ_NAME_TYPE_MD_METH|OBJ_NAME_ALIAS);
int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]); int EVP_MD_CTX_set_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]);
int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, const OSSL_PARAM params[]); int EVP_MD_CTX_get_params(EVP_MD_CTX *ctx, OSSL_PARAM params[]);
int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2); int EVP_MD_CTX_ctrl(EVP_MD_CTX *ctx, int cmd, int p1, void *p2);
EVP_MD_CTX *EVP_MD_CTX_new(void); EVP_MD_CTX *EVP_MD_CTX_new(void);
int EVP_MD_CTX_reset(EVP_MD_CTX *ctx); int EVP_MD_CTX_reset(EVP_MD_CTX *ctx);

153
include/openssl/params.h
View File

@ -19,124 +19,74 @@ extern "C" {
# endif # endif
# define OSSL_PARAM_END \ # define OSSL_PARAM_END \
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, 0 }
# define OSSL_PARAM_DEFN(key, type, addr, sz, rsz) \ # define OSSL_PARAM_DEFN(key, type, addr, sz) \
{ (key), (type), (addr), (sz), (rsz) } { (key), (type), (addr), (sz), 0 }
/* Basic parameter types without return sizes */ /* Basic parameter types without return sizes */
# define OSSL_PARAM_int(key, addr) \ # define OSSL_PARAM_int(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int), NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int))
# define OSSL_PARAM_uint(key, addr) \ # define OSSL_PARAM_uint(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \ OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(unsigned int), NULL) sizeof(unsigned int))
# define OSSL_PARAM_long(key, addr) \ # define OSSL_PARAM_long(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(long int), \ OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(long int))
NULL)
# define OSSL_PARAM_ulong(key, addr) \ # define OSSL_PARAM_ulong(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \ OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(unsigned long int), NULL) sizeof(unsigned long int))
# define OSSL_PARAM_int32(key, addr) \ # define OSSL_PARAM_int32(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int32_t), NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int32_t))
# define OSSL_PARAM_uint32(key, addr) \ # define OSSL_PARAM_uint32(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \ OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(uint32_t), NULL) sizeof(uint32_t))
# define OSSL_PARAM_int64(key, addr) \ # define OSSL_PARAM_int64(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int64_t), NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int64_t))
# define OSSL_PARAM_uint64(key, addr) \ # define OSSL_PARAM_uint64(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \ OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(uint64_t), NULL) sizeof(uint64_t))
# define OSSL_PARAM_size_t(key, addr) \ # define OSSL_PARAM_size_t(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(size_t), \ OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sizeof(size_t))
NULL)
# define OSSL_PARAM_double(key, addr) \ # define OSSL_PARAM_double(key, addr) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_REAL, (addr), sizeof(double), NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_REAL, (addr), sizeof(double))
# define OSSL_PARAM_BN(key, bn, sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (bn), (sz))
# define OSSL_PARAM_utf8_string(key, addr, sz) \ # define OSSL_PARAM_utf8_string(key, addr, sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_STRING, (addr), sz, NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_STRING, (addr), sz)
# define OSSL_PARAM_octet_string(key, addr, sz) \ # define OSSL_PARAM_octet_string(key, addr, sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_STRING, (addr), sz, NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_STRING, (addr), sz)
# define OSSL_PARAM_utf8_ptr(key, addr, sz) \ # define OSSL_PARAM_utf8_ptr(key, addr, sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_PTR, &(addr), sz, NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_PTR, &(addr), sz)
# define OSSL_PARAM_octet_ptr(key, addr, sz) \ # define OSSL_PARAM_octet_ptr(key, addr, sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_PTR, &(addr), sz, NULL) OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_PTR, &(addr), sz)
/* Basic parameter types including return sizes */
# define OSSL_PARAM_SIZED_int(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int), &(r_sz))
# define OSSL_PARAM_SIZED_uint(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(unsigned int), &(r_sz))
# define OSSL_PARAM_SIZED_long(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(long int), \
&(r_sz))
# define OSSL_PARAM_SIZED_ulong(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(unsigned long int), &(r_sz))
# define OSSL_PARAM_SIZED_int32(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int32_t), &(r_sz))
# define OSSL_PARAM_SIZED_uint32(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(uint32_t), &(r_sz))
# define OSSL_PARAM_SIZED_int64(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_INTEGER, (addr), sizeof(int64_t), &(r_sz))
# define OSSL_PARAM_SIZED_uint64(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(uint64_t), &(r_sz))
# define OSSL_PARAM_SIZED_size_t(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), \
sizeof(size_t), &(r_sz))
# define OSSL_PARAM_SIZED_double(key, addr, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_REAL, (addr), sizeof(double), &(r_sz))
# define OSSL_PARAM_SIZED_BN(key, addr, sz, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UNSIGNED_INTEGER, (addr), sz, \
&(r_sz))
# define OSSL_PARAM_SIZED_utf8_string(key, addr, sz, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_STRING, (addr), sz, &(r_sz))
# define OSSL_PARAM_SIZED_octet_string(key, addr, sz, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_STRING, (addr), sz, &(r_sz))
# define OSSL_PARAM_SIZED_utf8_ptr(key, addr, sz, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_UTF8_PTR, &(addr), sz, &(r_sz))
# define OSSL_PARAM_SIZED_octet_ptr(key, addr, sz, r_sz) \
OSSL_PARAM_DEFN((key), OSSL_PARAM_OCTET_PTR, &(addr), sz, &(r_sz))
/* Search an OSSL_PARAM array for a matching name */ /* Search an OSSL_PARAM array for a matching name */
const OSSL_PARAM *OSSL_PARAM_locate(const OSSL_PARAM *p, const char *key); OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key);
const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key);
/* Basic parameter type run-time construction */ /* Basic parameter type run-time construction */
OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf, size_t *ret); OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf);
OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf, OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf);
size_t *ret); OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf);
OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf, OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf);
size_t *ret); OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf);
OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf, OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf);
size_t *ret); OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf);
OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf, OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf);
size_t *ret); OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf);
OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf,
size_t *ret);
OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf,
size_t *ret);
OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf,
size_t *ret);
OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf,
size_t *ret);
OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf, OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf, OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf);
size_t *rsize);
OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf, OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf, OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf, OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf, OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
size_t bsize, size_t *rsize); size_t bsize);
OSSL_PARAM OSSL_PARAM_construct_end(void); OSSL_PARAM OSSL_PARAM_construct_end(void);
int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val); int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val);
@ -149,36 +99,35 @@ int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val);
int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val); int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val);
int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val); int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val);
int OSSL_PARAM_set_int(const OSSL_PARAM *p, int val); int OSSL_PARAM_set_int(OSSL_PARAM *p, int val);
int OSSL_PARAM_set_uint(const OSSL_PARAM *p, unsigned int val); int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val);
int OSSL_PARAM_set_long(const OSSL_PARAM *p, long int val); int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val);
int OSSL_PARAM_set_ulong(const OSSL_PARAM *p, unsigned long int val); int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val);
int OSSL_PARAM_set_int32(const OSSL_PARAM *p, int32_t val); int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val);
int OSSL_PARAM_set_uint32(const OSSL_PARAM *p, uint32_t val); int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val);
int OSSL_PARAM_set_int64(const OSSL_PARAM *p, int64_t val); int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val);
int OSSL_PARAM_set_uint64(const OSSL_PARAM *p, uint64_t val); int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val);
int OSSL_PARAM_set_size_t(const OSSL_PARAM *p, size_t val); int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val);
int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val); int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val);
int OSSL_PARAM_set_double(const OSSL_PARAM *p, double val); int OSSL_PARAM_set_double(OSSL_PARAM *p, double val);
int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val); int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val);
int OSSL_PARAM_set_BN(const OSSL_PARAM *p, const BIGNUM *val); int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val);
int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len); int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len);
int OSSL_PARAM_set_utf8_string(const OSSL_PARAM *p, const char *val); int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val);
int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len, int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
size_t *used_len); size_t *used_len);
int OSSL_PARAM_set_octet_string(const OSSL_PARAM *p, const void *val, int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val, size_t len);
size_t len);
int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val); int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val);
int OSSL_PARAM_set_utf8_ptr(const OSSL_PARAM *p, const char *val); int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val);
int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val, int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
size_t *used_len); size_t *used_len);
int OSSL_PARAM_set_octet_ptr(const OSSL_PARAM *p, const void *val, int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
size_t used_len); size_t used_len);
# ifdef __cplusplus # ifdef __cplusplus

3
include/openssl/provider.h
View File

@ -21,8 +21,7 @@ OSSL_PROVIDER *OSSL_PROVIDER_load(OPENSSL_CTX *, const char *name);
int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov); int OSSL_PROVIDER_unload(OSSL_PROVIDER *prov);
const OSSL_ITEM *OSSL_PROVIDER_get_param_types(const OSSL_PROVIDER *prov); const OSSL_ITEM *OSSL_PROVIDER_get_param_types(const OSSL_PROVIDER *prov);
int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, int OSSL_PROVIDER_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[]);
const OSSL_PARAM params[]);
/* Add a built in providers */ /* Add a built in providers */
int OSSL_PROVIDER_add_builtin(OPENSSL_CTX *, const char *name, int OSSL_PROVIDER_add_builtin(OPENSSL_CTX *, const char *name,

10
providers/common/ciphers/aes.c
View File

@ -257,9 +257,9 @@ static int aes_cipher(void *vctx,
#define IMPLEMENT_new_params(lcmode, UCMODE) \ #define IMPLEMENT_new_params(lcmode, UCMODE) \
static OSSL_OP_cipher_get_params_fn aes_##lcmode##_get_params; \ static OSSL_OP_cipher_get_params_fn aes_##lcmode##_get_params; \
static int aes_##lcmode##_get_params(const OSSL_PARAM params[]) \ static int aes_##lcmode##_get_params(OSSL_PARAM params[]) \
{ \ { \
const OSSL_PARAM *p; \ OSSL_PARAM *p; \
\ \
p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE); \ p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_MODE); \
if (p != NULL && !OSSL_PARAM_set_int(p, EVP_CIPH_##UCMODE##_MODE)) \ if (p != NULL && !OSSL_PARAM_set_int(p, EVP_CIPH_##UCMODE##_MODE)) \
@ -375,10 +375,10 @@ static size_t block_size_1(void)
return 1; return 1;
} }
static int aes_ctx_get_params(void *vctx, const OSSL_PARAM params[]) static int aes_ctx_get_params(void *vctx, OSSL_PARAM params[])
{ {
PROV_AES_KEY *ctx = (PROV_AES_KEY *)vctx; PROV_AES_KEY *ctx = (PROV_AES_KEY *)vctx;
const OSSL_PARAM *p; OSSL_PARAM *p;
p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING); p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING);
if (p != NULL && !OSSL_PARAM_set_int(p, ctx->pad)) { if (p != NULL && !OSSL_PARAM_set_int(p, ctx->pad)) {
@ -394,7 +394,7 @@ static int aes_ctx_set_params(void *vctx, const OSSL_PARAM params[])
PROV_AES_KEY *ctx = (PROV_AES_KEY *)vctx; PROV_AES_KEY *ctx = (PROV_AES_KEY *)vctx;
const OSSL_PARAM *p; const OSSL_PARAM *p;
p = OSSL_PARAM_locate(params, OSSL_CIPHER_PARAM_PADDING); p = OSSL_PARAM_locate_const(params, OSSL_CIPHER_PARAM_PADDING);
if (p != NULL) { if (p != NULL) {
int pad; int pad;

2
providers/common/digests/sha2_prov.c
View File

@ -26,7 +26,7 @@ static int sha1_set_params(void *vctx, const OSSL_PARAM params[])
SHA_CTX *ctx = (SHA_CTX *)vctx; SHA_CTX *ctx = (SHA_CTX *)vctx;
if (ctx != NULL && params != NULL) { if (ctx != NULL && params != NULL) {
p = OSSL_PARAM_locate(params, OSSL_DIGEST_PARAM_SSL3_MS); p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_SSL3_MS);
if (p != NULL && p->data_type == OSSL_PARAM_OCTET_STRING) if (p != NULL && p->data_type == OSSL_PARAM_OCTET_STRING)
return sha1_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET, p->data_size, return sha1_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET, p->data_size,
p->data); p->data);

2
providers/common/digests/sha3_prov.c
View File

@ -246,7 +246,7 @@ static int shake_set_params(void *vctx, const OSSL_PARAM params[])
KECCAK1600_CTX *ctx = (KECCAK1600_CTX *)vctx; KECCAK1600_CTX *ctx = (KECCAK1600_CTX *)vctx;
if (ctx != NULL && params != NULL) { if (ctx != NULL && params != NULL) {
p = OSSL_PARAM_locate(params, OSSL_DIGEST_PARAM_XOFLEN); p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_XOFLEN);
if (p != NULL && !OSSL_PARAM_get_size_t(p, &ctx->md_size)) if (p != NULL && !OSSL_PARAM_get_size_t(p, &ctx->md_size))
return 0; return 0;
return 1; return 1;

5
providers/default/defltprov.c
View File

@ -32,10 +32,9 @@ static const OSSL_ITEM *deflt_get_param_types(const OSSL_PROVIDER *prov)
return deflt_param_types; return deflt_param_types;
} }
static int deflt_get_params(const OSSL_PROVIDER *prov, static int deflt_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
const OSSL_PARAM params[])
{ {
const OSSL_PARAM *p; OSSL_PARAM *p;
p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME); p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL Default Provider")) if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL Default Provider"))

2
providers/default/digests/md5_sha1_prov.c
View File

@ -26,7 +26,7 @@ static int md5_sha1_set_params(void *vctx, const OSSL_PARAM params[])
MD5_SHA1_CTX *ctx = (MD5_SHA1_CTX *)vctx; MD5_SHA1_CTX *ctx = (MD5_SHA1_CTX *)vctx;
if (ctx != NULL && params != NULL) { if (ctx != NULL && params != NULL) {
p = OSSL_PARAM_locate(params, OSSL_DIGEST_PARAM_SSL3_MS); p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_SSL3_MS);
if (p != NULL && p->data_type == OSSL_PARAM_OCTET_STRING) if (p != NULL && p->data_type == OSSL_PARAM_OCTET_STRING)
return md5_sha1_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET, p->data_size, return md5_sha1_ctrl(ctx, EVP_CTRL_SSL3_MASTER_SECRET, p->data_size,
p->data); p->data);

5
providers/fips/fipsprov.c
View File

@ -127,10 +127,9 @@ static const OSSL_ITEM *fips_get_param_types(const OSSL_PROVIDER *prov)
return fips_param_types; return fips_param_types;
} }
static int fips_get_params(const OSSL_PROVIDER *prov, static int fips_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
const OSSL_PARAM params[])
{ {
const OSSL_PARAM *p; OSSL_PARAM *p;
p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME); p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider")) if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL FIPS Provider"))

2
providers/legacy/digests/mdc2_prov.c
View File

@ -23,7 +23,7 @@ static int mdc2_set_params(void *vctx, const OSSL_PARAM params[])
MDC2_CTX *ctx = (MDC2_CTX *)vctx; MDC2_CTX *ctx = (MDC2_CTX *)vctx;
if (ctx != NULL && params != NULL) { if (ctx != NULL && params != NULL) {
p = OSSL_PARAM_locate(params, OSSL_DIGEST_PARAM_PAD_TYPE); p = OSSL_PARAM_locate_const(params, OSSL_DIGEST_PARAM_PAD_TYPE);
if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->pad_type)) if (p != NULL && !OSSL_PARAM_get_int(p, &ctx->pad_type))
return 0; return 0;
return 1; return 1;

5
providers/legacy/legacyprov.c
View File

@ -32,10 +32,9 @@ static const OSSL_ITEM *legacy_get_param_types(const OSSL_PROVIDER *prov)
return legacy_param_types; return legacy_param_types;
} }
static int legacy_get_params(const OSSL_PROVIDER *prov, static int legacy_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
const OSSL_PARAM params[])
{ {
const OSSL_PARAM *p; OSSL_PARAM *p;
p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME); p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME);
if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL Legacy Provider")) if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL Legacy Provider"))

3
ssl/s3_enc.c
View File

@ -417,8 +417,7 @@ void ssl3_digest_master_key_set_params(const SSL_SESSION *session,
int n = 0; int n = 0;
params[n++] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS, params[n++] = OSSL_PARAM_construct_octet_string(OSSL_DIGEST_PARAM_SSL3_MS,
(void *)session->master_key, (void *)session->master_key,
session->master_key_length, session->master_key_length);
NULL);
params[n++] = OSSL_PARAM_construct_end(); params[n++] = OSSL_PARAM_construct_end();
} }

2
test/mdc2test.c
View File

@ -48,7 +48,7 @@ static int test_mdc2(void)
OSSL_PARAM params[2]; OSSL_PARAM params[2];
params[i++] = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_PAD_TYPE, params[i++] = OSSL_PARAM_construct_int(OSSL_DIGEST_PARAM_PAD_TYPE,
&pad_type, NULL), &pad_type),
params[i++] = OSSL_PARAM_construct_end(); params[i++] = OSSL_PARAM_construct_end();
prov = OSSL_PROVIDER_load(NULL, "legacy"); prov = OSSL_PROVIDER_load(NULL, "legacy");

16
test/p_test.c
View File

@ -47,10 +47,10 @@ static const OSSL_ITEM *p_get_param_types(void *_)
return p_param_types; return p_param_types;
} }
static int p_get_params(void *vprov, const OSSL_PARAM params[]) static int p_get_params(void *vprov, OSSL_PARAM params[])
{ {
const OSSL_PROVIDER *prov = vprov; const OSSL_PROVIDER *prov = vprov;
const OSSL_PARAM *p = params; OSSL_PARAM *p = params;
int ok = 1; int ok = 1;
for (; ok && p->key != NULL; p++) { for (; ok && p->key != NULL; p++) {
@ -58,18 +58,18 @@ static int p_get_params(void *vprov, const OSSL_PARAM params[])
static char *opensslv; static char *opensslv;
static char *provname; static char *provname;
static char *greeting; static char *greeting;
static const OSSL_PARAM counter_request[] = { static OSSL_PARAM counter_request[] = {
/* Known libcrypto provided parameters */ /* Known libcrypto provided parameters */
{ "openssl-version", OSSL_PARAM_UTF8_PTR, { "openssl-version", OSSL_PARAM_UTF8_PTR,
&opensslv, sizeof(&opensslv), NULL }, &opensslv, sizeof(&opensslv), 0 },
{ "provider-name", OSSL_PARAM_UTF8_PTR, { "provider-name", OSSL_PARAM_UTF8_PTR,
&provname, sizeof(&provname), NULL}, &provname, sizeof(&provname), 0},
/* This might be present, if there's such a configuration */ /* This might be present, if there's such a configuration */
{ "greeting", OSSL_PARAM_UTF8_PTR, { "greeting", OSSL_PARAM_UTF8_PTR,
&greeting, sizeof(&greeting), NULL }, &greeting, sizeof(&greeting), 0 },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, 0 }
}; };
char buf[256]; char buf[256];
size_t buf_l; size_t buf_l;
@ -90,7 +90,7 @@ static int p_get_params(void *vprov, const OSSL_PARAM params[])
sprintf(buf, "Howdy stranger..."); sprintf(buf, "Howdy stranger...");
} }
*p->return_size = buf_l = strlen(buf) + 1; p->return_size = buf_l = strlen(buf) + 1;
if (p->data_size >= buf_l) if (p->data_size >= buf_l)
strncpy(p->data, buf, buf_l); strncpy(p->data, buf, buf_l);
else else

110
test/params_api_test.c
View File

@ -58,8 +58,8 @@ static const struct {
0x89, 0x67, 0xf2, 0x68, 0x33, 0xa0, 0x14, 0xb0 } }, 0x89, 0x67, 0xf2, 0x68, 0x33, 0xa0, 0x14, 0xb0 } },
}; };
static int test_param_type_extra(const OSSL_PARAM *param, static int test_param_type_extra(OSSL_PARAM *param, const unsigned char *cmp,
const unsigned char *cmp, size_t width) size_t width)
{ {
int32_t i32; int32_t i32;
int64_t i64; int64_t i64;
@ -374,24 +374,22 @@ static int test_param_bignum(int n)
{ {
unsigned char buf[MAX_LEN], bnbuf[MAX_LEN]; unsigned char buf[MAX_LEN], bnbuf[MAX_LEN];
const size_t len = raw_values[n].len; const size_t len = raw_values[n].len;
size_t bnsize;
BIGNUM *b = NULL, *c = NULL; BIGNUM *b = NULL, *c = NULL;
OSSL_PARAM param = OSSL_PARAM_DEFN("bn", OSSL_PARAM_UNSIGNED_INTEGER, OSSL_PARAM param = OSSL_PARAM_DEFN("bn", OSSL_PARAM_UNSIGNED_INTEGER,
NULL, 0, NULL); NULL, 0);
int ret = 0; int ret = 0;
param.data = bnbuf; param.data = bnbuf;
param.data_size = len; param.data_size = len;
param.return_size = &bnsize;
le_copy(buf, raw_values[n].value, len); le_copy(buf, raw_values[n].value, len);
if (!TEST_ptr(b = BN_lebin2bn(raw_values[n].value, (int)len, NULL))) if (!TEST_ptr(b = BN_lebin2bn(raw_values[n].value, (int)len, NULL)))
goto err; goto err;
if (!TEST_true(OSSL_PARAM_set_BN(&param, b)) if (!TEST_true(OSSL_PARAM_set_BN(&param, b))
|| !TEST_mem_eq(bnbuf, bnsize, buf, bnsize)) || !TEST_mem_eq(bnbuf, param.return_size, buf, param.return_size))
goto err; goto err;
param.data_size = *param.return_size; param.data_size = param.return_size;
if (!TEST_true(OSSL_PARAM_get_BN(&param, &c)) if (!TEST_true(OSSL_PARAM_get_BN(&param, &c))
|| !TEST_BN_eq(b, c)) || !TEST_BN_eq(b, c))
goto err; goto err;
@ -413,23 +411,6 @@ static int test_param_real(void)
&& TEST_double_eq(p, 3.14159); && TEST_double_eq(p, 3.14159);
} }
/*
* The tests are a bit special in that they are trying to do both sides
* of the param passing. This means that the OSSL_PARAM structure needs to
* be updated so that a get call matches size with the corresponding set call.
* This is not a problem in normal usage because the owner of the OSSL_PARAM
* "knows" the size of what it wants to put in and gets the size back via the
* return_size pointer when it needs to get data out. That is, the owner
* does not need to call these APIs since it has direct access.
*
* The result is that the tests need the locate call to return a non-const
* pointer at times. Hence the cast here.
*/
static OSSL_PARAM *locate(OSSL_PARAM *p, const char *name)
{
return (OSSL_PARAM *)OSSL_PARAM_locate(p, name);
}
static int test_param_construct(void) static int test_param_construct(void)
{ {
static const char *int_names[] = { static const char *int_names[] = {
@ -446,8 +427,7 @@ static int test_param_construct(void)
char buf[100], buf2[100], *bufp, *bufp2; char buf[100], buf2[100], *bufp, *bufp2;
unsigned char ubuf[100]; unsigned char ubuf[100];
void *vp, *vpn = NULL, *vp2; void *vp, *vpn = NULL, *vp2;
OSSL_PARAM *p; OSSL_PARAM *cp;
const OSSL_PARAM *cp;
int i, n = 0, ret = 0; int i, n = 0, ret = 0;
unsigned int u; unsigned int u;
long int l; long int l;
@ -456,27 +436,25 @@ static int test_param_construct(void)
uint32_t u32; uint32_t u32;
int64_t i64; int64_t i64;
uint64_t u64; uint64_t u64;
size_t j, k, s, sz; size_t j, k, s;
double d, d2; double d, d2;
BIGNUM *bn = NULL, *bn2 = NULL; BIGNUM *bn = NULL, *bn2 = NULL;
params[n++] = OSSL_PARAM_construct_int("int", &i, &sz); params[n++] = OSSL_PARAM_construct_int("int", &i);
params[n++] = OSSL_PARAM_construct_uint("uint", &u, &sz); params[n++] = OSSL_PARAM_construct_uint("uint", &u);
params[n++] = OSSL_PARAM_construct_long("long", &l, &sz); params[n++] = OSSL_PARAM_construct_long("long", &l);
params[n++] = OSSL_PARAM_construct_ulong("ulong", &ul, &sz); params[n++] = OSSL_PARAM_construct_ulong("ulong", &ul);
params[n++] = OSSL_PARAM_construct_int32("int32", &i32, &sz); params[n++] = OSSL_PARAM_construct_int32("int32", &i32);
params[n++] = OSSL_PARAM_construct_int64("int64", &i64, &sz); params[n++] = OSSL_PARAM_construct_int64("int64", &i64);
params[n++] = OSSL_PARAM_construct_uint32("uint32", &u32, &sz); params[n++] = OSSL_PARAM_construct_uint32("uint32", &u32);
params[n++] = OSSL_PARAM_construct_uint64("uint64", &u64, &sz); params[n++] = OSSL_PARAM_construct_uint64("uint64", &u64);
params[n++] = OSSL_PARAM_construct_size_t("size_t", &s, &sz); params[n++] = OSSL_PARAM_construct_size_t("size_t", &s);
params[n++] = OSSL_PARAM_construct_double("double", &d, &sz); params[n++] = OSSL_PARAM_construct_double("double", &d);
params[n++] = OSSL_PARAM_construct_BN("bignum", ubuf, sizeof(ubuf), &sz); params[n++] = OSSL_PARAM_construct_BN("bignum", ubuf, sizeof(ubuf));
params[n++] = OSSL_PARAM_construct_utf8_string("utf8str", buf, sizeof(buf), params[n++] = OSSL_PARAM_construct_utf8_string("utf8str", buf, sizeof(buf));
&sz); params[n++] = OSSL_PARAM_construct_octet_string("octstr", buf, sizeof(buf));
params[n++] = OSSL_PARAM_construct_octet_string("octstr", buf, sizeof(buf), params[n++] = OSSL_PARAM_construct_utf8_ptr("utf8ptr", &bufp, 0);
&sz); params[n++] = OSSL_PARAM_construct_octet_ptr("octptr", &vp, 0);
params[n++] = OSSL_PARAM_construct_utf8_ptr("utf8ptr", &bufp, 0, &sz);
params[n++] = OSSL_PARAM_construct_octet_ptr("octptr", &vp, 0, &sz);
params[n] = OSSL_PARAM_construct_end(); params[n] = OSSL_PARAM_construct_end();
/* Search failure */ /* Search failure */
@ -488,7 +466,7 @@ static int test_param_construct(void)
if (!TEST_ptr(cp = OSSL_PARAM_locate(params, int_names[j])) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, int_names[j]))
|| !TEST_true(OSSL_PARAM_set_int32(cp, (int32_t)(3 + j))) || !TEST_true(OSSL_PARAM_set_int32(cp, (int32_t)(3 + j)))
|| !TEST_true(OSSL_PARAM_get_int64(cp, &i64)) || !TEST_true(OSSL_PARAM_get_int64(cp, &i64))
|| !TEST_size_t_eq(cp->data_size, sz) || !TEST_size_t_eq(cp->data_size, cp->return_size)
|| !TEST_size_t_eq((size_t)i64, 3 + j)) { || !TEST_size_t_eq((size_t)i64, 3 + j)) {
TEST_note("iteration %zu var %s", j + 1, int_names[j]); TEST_note("iteration %zu var %s", j + 1, int_names[j]);
goto err; goto err;
@ -499,7 +477,7 @@ static int test_param_construct(void)
if (!TEST_ptr(cp = OSSL_PARAM_locate(params, uint_names[j])) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, uint_names[j]))
|| !TEST_true(OSSL_PARAM_set_uint32(cp, (uint32_t)(3 + j))) || !TEST_true(OSSL_PARAM_set_uint32(cp, (uint32_t)(3 + j)))
|| !TEST_true(OSSL_PARAM_get_uint64(cp, &u64)) || !TEST_true(OSSL_PARAM_get_uint64(cp, &u64))
|| !TEST_size_t_eq(cp->data_size, sz) || !TEST_size_t_eq(cp->data_size, cp->return_size)
|| !TEST_size_t_eq((size_t)u64, 3 + j)) { || !TEST_size_t_eq((size_t)u64, 3 + j)) {
TEST_note("iteration %zu var %s", j + 1, uint_names[j]); TEST_note("iteration %zu var %s", j + 1, uint_names[j]);
goto err; goto err;
@ -509,14 +487,14 @@ static int test_param_construct(void)
if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "double")) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "double"))
|| !TEST_true(OSSL_PARAM_set_double(cp, 3.14)) || !TEST_true(OSSL_PARAM_set_double(cp, 3.14))
|| !TEST_true(OSSL_PARAM_get_double(cp, &d2)) || !TEST_true(OSSL_PARAM_get_double(cp, &d2))
|| !TEST_size_t_eq(sz, sizeof(double)) || !TEST_size_t_eq(cp->return_size, sizeof(double))
|| !TEST_double_eq(d, d2)) || !TEST_double_eq(d, d2))
goto err; goto err;
/* UTF8 string */ /* UTF8 string */
bufp = NULL; bufp = NULL;
if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "utf8str")) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "utf8str"))
|| !TEST_true(OSSL_PARAM_set_utf8_string(cp, "abcdef")) || !TEST_true(OSSL_PARAM_set_utf8_string(cp, "abcdef"))
|| !TEST_size_t_eq(sz, sizeof("abcdef")) || !TEST_size_t_eq(cp->return_size, sizeof("abcdef"))
|| !TEST_true(OSSL_PARAM_get_utf8_string(cp, &bufp, 0)) || !TEST_true(OSSL_PARAM_get_utf8_string(cp, &bufp, 0))
|| !TEST_str_eq(bufp, "abcdef")) || !TEST_str_eq(bufp, "abcdef"))
goto err; goto err;
@ -527,56 +505,54 @@ static int test_param_construct(void)
goto err; goto err;
/* UTF8 pointer */ /* UTF8 pointer */
bufp = buf; bufp = buf;
sz = 0;
if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "utf8ptr")) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "utf8ptr"))
|| !TEST_true(OSSL_PARAM_set_utf8_ptr(cp, "tuvwxyz")) || !TEST_true(OSSL_PARAM_set_utf8_ptr(cp, "tuvwxyz"))
|| !TEST_size_t_eq(sz, sizeof("tuvwxyz")) || !TEST_size_t_eq(cp->return_size, sizeof("tuvwxyz"))
|| !TEST_str_eq(bufp, "tuvwxyz") || !TEST_str_eq(bufp, "tuvwxyz")
|| !TEST_true(OSSL_PARAM_get_utf8_ptr(cp, (const char **)&bufp2)) || !TEST_true(OSSL_PARAM_get_utf8_ptr(cp, (const char **)&bufp2))
|| !TEST_ptr_eq(bufp2, bufp)) || !TEST_ptr_eq(bufp2, bufp))
goto err; goto err;
/* OCTET string */ /* OCTET string */
if (!TEST_ptr(p = locate(params, "octstr")) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "octstr"))
|| !TEST_true(OSSL_PARAM_set_octet_string(p, "abcdefghi", || !TEST_true(OSSL_PARAM_set_octet_string(cp, "abcdefghi",
sizeof("abcdefghi"))) sizeof("abcdefghi")))
|| !TEST_size_t_eq(sz, sizeof("abcdefghi"))) || !TEST_size_t_eq(cp->return_size, sizeof("abcdefghi")))
goto err; goto err;
/* Match the return size to avoid trailing garbage bytes */ /* Match the return size to avoid trailing garbage bytes */
p->data_size = *p->return_size; cp->data_size = cp->return_size;
if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vpn, 0, &s)) if (!TEST_true(OSSL_PARAM_get_octet_string(cp, &vpn, 0, &s))
|| !TEST_size_t_eq(s, sizeof("abcdefghi")) || !TEST_size_t_eq(s, sizeof("abcdefghi"))
|| !TEST_mem_eq(vpn, sizeof("abcdefghi"), || !TEST_mem_eq(vpn, sizeof("abcdefghi"),
"abcdefghi", sizeof("abcdefghi"))) "abcdefghi", sizeof("abcdefghi")))
goto err; goto err;
vp = buf2; vp = buf2;
if (!TEST_true(OSSL_PARAM_get_octet_string(p, &vp, sizeof(buf2), &s)) if (!TEST_true(OSSL_PARAM_get_octet_string(cp, &vp, sizeof(buf2), &s))
|| !TEST_size_t_eq(s, sizeof("abcdefghi")) || !TEST_size_t_eq(s, sizeof("abcdefghi"))
|| !TEST_mem_eq(vp, sizeof("abcdefghi"), || !TEST_mem_eq(vp, sizeof("abcdefghi"),
"abcdefghi", sizeof("abcdefghi"))) "abcdefghi", sizeof("abcdefghi")))
goto err; goto err;
/* OCTET pointer */ /* OCTET pointer */
vp = &l; vp = &l;
sz = 0; if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "octptr"))
if (!TEST_ptr(p = locate(params, "octptr")) || !TEST_true(OSSL_PARAM_set_octet_ptr(cp, &ul, sizeof(ul)))
|| !TEST_true(OSSL_PARAM_set_octet_ptr(p, &ul, sizeof(ul))) || !TEST_size_t_eq(cp->return_size, sizeof(ul))
|| !TEST_size_t_eq(sz, sizeof(ul))
|| !TEST_ptr_eq(vp, &ul)) || !TEST_ptr_eq(vp, &ul))
goto err; goto err;
/* Match the return size to avoid trailing garbage bytes */ /* Match the return size to avoid trailing garbage bytes */
p->data_size = *p->return_size; cp->data_size = cp->return_size;
if (!TEST_true(OSSL_PARAM_get_octet_ptr(p, (const void **)&vp2, &k)) if (!TEST_true(OSSL_PARAM_get_octet_ptr(cp, (const void **)&vp2, &k))
|| !TEST_size_t_eq(k, sizeof(ul)) || !TEST_size_t_eq(k, sizeof(ul))
|| !TEST_ptr_eq(vp2, vp)) || !TEST_ptr_eq(vp2, vp))
goto err; goto err;
/* BIGNUM */ /* BIGNUM */
if (!TEST_ptr(p = locate(params, "bignum")) if (!TEST_ptr(cp = OSSL_PARAM_locate(params, "bignum"))
|| !TEST_ptr(bn = BN_lebin2bn(bn_val, (int)sizeof(bn_val), NULL)) || !TEST_ptr(bn = BN_lebin2bn(bn_val, (int)sizeof(bn_val), NULL))
|| !TEST_true(OSSL_PARAM_set_BN(p, bn)) || !TEST_true(OSSL_PARAM_set_BN(cp, bn))
|| !TEST_size_t_eq(sz, sizeof(bn_val))) || !TEST_size_t_eq(cp->return_size, sizeof(bn_val)))
goto err; goto err;
/* Match the return size to avoid trailing garbage bytes */ /* Match the return size to avoid trailing garbage bytes */
p->data_size = *p->return_size; cp->data_size = cp->return_size;
if(!TEST_true(OSSL_PARAM_get_BN(p, &bn2)) if(!TEST_true(OSSL_PARAM_get_BN(cp, &bn2))
|| !TEST_BN_eq(bn, bn2)) || !TEST_BN_eq(bn, bn2))
goto err; goto err;
ret = 1; ret = 1;

4
test/params_conversion_test.c
View File

@ -20,7 +20,7 @@
# endif # endif
typedef struct { typedef struct {
const OSSL_PARAM *param; OSSL_PARAM *param;
int32_t i32; int32_t i32;
int64_t i64; int64_t i64;
uint32_t u32; uint32_t u32;
@ -39,7 +39,7 @@ static int param_conversion_load_stanza(PARAM_CONVERSION *pc, const STANZA *s)
static uint32_t datum_u32, ref_u32; static uint32_t datum_u32, ref_u32;
static uint64_t datum_u64, ref_u64; static uint64_t datum_u64, ref_u64;
static double datum_d, ref_d; static double datum_d, ref_d;
static const OSSL_PARAM params[] = { static OSSL_PARAM params[] = {
OSSL_PARAM_int32("int32", &datum_i32), OSSL_PARAM_int32("int32", &datum_i32),
OSSL_PARAM_int64("int64", &datum_i64), OSSL_PARAM_int64("int64", &datum_i64),
OSSL_PARAM_uint32("uint32", &datum_u32), OSSL_PARAM_uint32("uint32", &datum_u32),

120
test/params_test.c
View File

@ -152,40 +152,35 @@ static int raw_set_params(void *vobj, const OSSL_PARAM *params)
return 1; return 1;
} }
static int raw_get_params(void *vobj, const OSSL_PARAM *params) static int raw_get_params(void *vobj, OSSL_PARAM *params)
{ {
struct object_st *obj = vobj; struct object_st *obj = vobj;
for (; params->key != NULL; params++) for (; params->key != NULL; params++)
if (strcmp(params->key, "p1") == 0) { if (strcmp(params->key, "p1") == 0) {
if (params->return_size != NULL) params->return_size = sizeof(obj->p1);
*params->return_size = sizeof(obj->p1);
*(int *)params->data = obj->p1; *(int *)params->data = obj->p1;
} else if (strcmp(params->key, "p2") == 0) { } else if (strcmp(params->key, "p2") == 0) {
if (params->return_size != NULL) params->return_size = sizeof(obj->p2);
*params->return_size = sizeof(obj->p2);
*(double *)params->data = obj->p2; *(double *)params->data = obj->p2;
} else if (strcmp(params->key, "p3") == 0) { } else if (strcmp(params->key, "p3") == 0) {
size_t bytes = BN_num_bytes(obj->p3); size_t bytes = BN_num_bytes(obj->p3);
if (params->return_size != NULL) params->return_size = bytes;
*params->return_size = bytes;
if (!TEST_size_t_ge(params->data_size, bytes)) if (!TEST_size_t_ge(params->data_size, bytes))
return 0; return 0;
BN_bn2nativepad(obj->p3, params->data, bytes); BN_bn2nativepad(obj->p3, params->data, bytes);
} else if (strcmp(params->key, "p4") == 0) { } else if (strcmp(params->key, "p4") == 0) {
size_t bytes = strlen(obj->p4) + 1; size_t bytes = strlen(obj->p4) + 1;
if (params->return_size != NULL) params->return_size = bytes;
*params->return_size = bytes;
if (!TEST_size_t_ge(params->data_size, bytes)) if (!TEST_size_t_ge(params->data_size, bytes))
return 0; return 0;
strcpy(params->data, obj->p4); strcpy(params->data, obj->p4);
} else if (strcmp(params->key, "p5") == 0) { } else if (strcmp(params->key, "p5") == 0) {
size_t bytes = strlen(obj->p5) + 1; size_t bytes = strlen(obj->p5) + 1;
if (params->return_size != NULL) params->return_size = bytes;
*params->return_size = bytes;
if (!TEST_size_t_ge(params->data_size, bytes)) if (!TEST_size_t_ge(params->data_size, bytes))
return 0; return 0;
strcpy(params->data, obj->p5); strcpy(params->data, obj->p5);
@ -198,8 +193,7 @@ static int raw_get_params(void *vobj, const OSSL_PARAM *params)
*/ */
size_t bytes = strlen(obj->p6) + 1; size_t bytes = strlen(obj->p6) + 1;
if (params->return_size != NULL) params->return_size = bytes;
*params->return_size = bytes;
*(const char **)params->data = obj->p6; *(const char **)params->data = obj->p6;
} }
@ -215,29 +209,29 @@ static int api_set_params(void *vobj, const OSSL_PARAM *params)
struct object_st *obj = vobj; struct object_st *obj = vobj;
const OSSL_PARAM *p = NULL; const OSSL_PARAM *p = NULL;
if ((p = OSSL_PARAM_locate(params, "p1")) != NULL if ((p = OSSL_PARAM_locate_const(params, "p1")) != NULL
&& !TEST_true(OSSL_PARAM_get_int(p, &obj->p1))) && !TEST_true(OSSL_PARAM_get_int(p, &obj->p1)))
return 0; return 0;
if ((p = OSSL_PARAM_locate(params, "p2")) != NULL if ((p = OSSL_PARAM_locate_const(params, "p2")) != NULL
&& !TEST_true(OSSL_PARAM_get_double(p, &obj->p2))) && !TEST_true(OSSL_PARAM_get_double(p, &obj->p2)))
return 0; return 0;
if ((p = OSSL_PARAM_locate(params, "p3")) != NULL if ((p = OSSL_PARAM_locate_const(params, "p3")) != NULL
&& !TEST_true(OSSL_PARAM_get_BN(p, &obj->p3))) && !TEST_true(OSSL_PARAM_get_BN(p, &obj->p3)))
return 0; return 0;
if ((p = OSSL_PARAM_locate(params, "p4")) != NULL) { if ((p = OSSL_PARAM_locate_const(params, "p4")) != NULL) {
OPENSSL_free(obj->p4); OPENSSL_free(obj->p4);
obj->p4 = NULL; obj->p4 = NULL;
/* If the value pointer is NULL, we get it automatically allocated */ /* If the value pointer is NULL, we get it automatically allocated */
if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &obj->p4, 0))) if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &obj->p4, 0)))
return 0; return 0;
} }
if ((p = OSSL_PARAM_locate(params, "p5")) != NULL) { if ((p = OSSL_PARAM_locate_const(params, "p5")) != NULL) {
char *p5_ptr = obj->p5; char *p5_ptr = obj->p5;
if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &p5_ptr, sizeof(obj->p5)))) if (!TEST_true(OSSL_PARAM_get_utf8_string(p, &p5_ptr, sizeof(obj->p5))))
return 0; return 0;
obj->p5_l = strlen(obj->p5) + 1; obj->p5_l = strlen(obj->p5) + 1;
} }
if ((p = OSSL_PARAM_locate(params, "p6")) != NULL) { if ((p = OSSL_PARAM_locate_const(params, "p6")) != NULL) {
if (!TEST_true(OSSL_PARAM_get_utf8_ptr(p, &obj->p6))) if (!TEST_true(OSSL_PARAM_get_utf8_ptr(p, &obj->p6)))
return 0; return 0;
obj->p6_l = strlen(obj->p6) + 1; obj->p6_l = strlen(obj->p6) + 1;
@ -246,10 +240,10 @@ static int api_set_params(void *vobj, const OSSL_PARAM *params)
return 1; return 1;
} }
static int api_get_params(void *vobj, const OSSL_PARAM *params) static int api_get_params(void *vobj, OSSL_PARAM *params)
{ {
struct object_st *obj = vobj; struct object_st *obj = vobj;
const OSSL_PARAM *p = NULL; OSSL_PARAM *p = NULL;
if ((p = OSSL_PARAM_locate(params, "p1")) != NULL if ((p = OSSL_PARAM_locate(params, "p1")) != NULL
&& !TEST_true(OSSL_PARAM_set_int(p, obj->p1))) && !TEST_true(OSSL_PARAM_set_int(p, obj->p1)))
@ -279,7 +273,7 @@ static int api_get_params(void *vobj, const OSSL_PARAM *params)
*/ */
struct provider_dispatch_st { struct provider_dispatch_st {
int (*set_params)(void *obj, const OSSL_PARAM *params); int (*set_params)(void *obj, const OSSL_PARAM *params);
int (*get_params)(void *obj, const OSSL_PARAM *params); int (*get_params)(void *obj, OSSL_PARAM *params);
}; };
/* "raw" provider */ /* "raw" provider */
@ -312,13 +306,9 @@ static BIGNUM *app_p3 = NULL; /* "p3" */
static unsigned char bignumbin[4096]; /* "p3" */ static unsigned char bignumbin[4096]; /* "p3" */
static size_t bignumbin_l; /* "p3" */ static size_t bignumbin_l; /* "p3" */
static char app_p4[256]; /* "p4" */ static char app_p4[256]; /* "p4" */
static size_t app_p4_l; /* "p4" */
static char app_p5[256]; /* "p5" */ static char app_p5[256]; /* "p5" */
static size_t app_p5_l; /* "p5" */
static const char *app_p6 = NULL; /* "p6" */ static const char *app_p6 = NULL; /* "p6" */
static size_t app_p6_l; /* "p6" */
static unsigned char foo[1]; /* "foo" */ static unsigned char foo[1]; /* "foo" */
static size_t foo_l; /* "foo" */
#define app_p1_init 17 /* A random number */ #define app_p1_init 17 /* A random number */
#define app_p2_init 47.11 /* Another random number */ #define app_p2_init 47.11 /* Another random number */
@ -348,12 +338,9 @@ static int init_app_variables(void)
return 0; return 0;
bignumbin_l = (size_t)l; bignumbin_l = (size_t)l;
strcpy(app_p4, app_p4_init); strcpy(app_p4, app_p4_init);
app_p4_l = sizeof(app_p4_init);
strcpy(app_p5, app_p5_init); strcpy(app_p5, app_p5_init);
app_p5_l = sizeof(app_p5_init);
app_p6 = app_p6_init; app_p6 = app_p6_init;
foo[0] = app_foo_init; foo[0] = app_foo_init;
foo_l = sizeof(app_foo_init);
return 1; return 1;
} }
@ -363,30 +350,26 @@ static int init_app_variables(void)
*/ */
/* An array of OSSL_PARAM, specific in the most raw manner possible */ /* An array of OSSL_PARAM, specific in the most raw manner possible */
static const OSSL_PARAM static_raw_params[] = { static OSSL_PARAM static_raw_params[] = {
{ "p1", OSSL_PARAM_INTEGER, &app_p1, sizeof(app_p1), NULL }, { "p1", OSSL_PARAM_INTEGER, &app_p1, sizeof(app_p1), 0 },
{ "p3", OSSL_PARAM_UNSIGNED_INTEGER, &bignumbin, sizeof(bignumbin), { "p3", OSSL_PARAM_UNSIGNED_INTEGER, &bignumbin, sizeof(bignumbin), 0 },
&bignumbin_l }, { "p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4), 0 },
{ "p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4), &app_p4_l }, { "p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5), 0 },
{ "p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5), &app_p5_l },
/* sizeof(app_p6_init), because we know that's what we're using */ /* sizeof(app_p6_init), because we know that's what we're using */
{ "p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6_init), &app_p6_l }, { "p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6_init), 0 },
{ "foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), &foo_l }, { "foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), 0 },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, 0 }
}; };
/* The same array of OSSL_PARAM, specified with the macros from params.h */ /* The same array of OSSL_PARAM, specified with the macros from params.h */
static const OSSL_PARAM static_api_params[] = { static OSSL_PARAM static_api_params[] = {
OSSL_PARAM_int("p1", &app_p1), OSSL_PARAM_int("p1", &app_p1),
OSSL_PARAM_SIZED_BN("p3", &bignumbin, sizeof(bignumbin), bignumbin_l), OSSL_PARAM_BN("p3", &bignumbin, sizeof(bignumbin)),
OSSL_PARAM_DEFN("p4", OSSL_PARAM_UTF8_STRING, OSSL_PARAM_DEFN("p4", OSSL_PARAM_UTF8_STRING, &app_p4, sizeof(app_p4)),
&app_p4, sizeof(app_p4), &app_p4_l), OSSL_PARAM_DEFN("p5", OSSL_PARAM_UTF8_STRING, &app_p5, sizeof(app_p5)),
OSSL_PARAM_DEFN("p5", OSSL_PARAM_UTF8_STRING,
&app_p5, sizeof(app_p5), &app_p5_l),
/* sizeof(app_p6_init), because we know that's what we're using */ /* sizeof(app_p6_init), because we know that's what we're using */
OSSL_PARAM_DEFN("p6", OSSL_PARAM_UTF8_PTR, OSSL_PARAM_DEFN("p6", OSSL_PARAM_UTF8_PTR, &app_p6, sizeof(app_p6_init)),
&app_p6, sizeof(app_p6_init), &app_p6_l), OSSL_PARAM_DEFN("foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo)),
OSSL_PARAM_DEFN("foo", OSSL_PARAM_OCTET_STRING, &foo, sizeof(foo), &foo_l),
OSSL_PARAM_END OSSL_PARAM_END
}; };
@ -399,25 +382,23 @@ static OSSL_PARAM *construct_api_params(void)
size_t n = 0; size_t n = 0;
static OSSL_PARAM params[10]; static OSSL_PARAM params[10];
params[n++] = OSSL_PARAM_construct_int("p1", &app_p1, NULL); params[n++] = OSSL_PARAM_construct_int("p1", &app_p1);
params[n++] = OSSL_PARAM_construct_BN("p3", bignumbin, sizeof(bignumbin), params[n++] = OSSL_PARAM_construct_BN("p3", bignumbin, sizeof(bignumbin));
&bignumbin_l); params[n++] = OSSL_PARAM_construct_utf8_string("p4", app_p4,
params[n++] = OSSL_PARAM_construct_utf8_string("p4", app_p4, sizeof(app_p4), sizeof(app_p4));
&app_p4_l);
params[n++] = OSSL_PARAM_construct_utf8_string("p5", app_p5, params[n++] = OSSL_PARAM_construct_utf8_string("p5", app_p5,
sizeof(app_p5), &app_p5_l); sizeof(app_p5));
/* sizeof(app_p6_init), because we know that's what we're using */ /* sizeof(app_p6_init), because we know that's what we're using */
params[n++] = OSSL_PARAM_construct_utf8_ptr("p6", (char **)&app_p6, params[n++] = OSSL_PARAM_construct_utf8_ptr("p6", (char **)&app_p6,
sizeof(app_p6_init), &app_p6_l); sizeof(app_p6_init));
params[n++] = OSSL_PARAM_construct_octet_string("foo", &foo, sizeof(foo), params[n++] = OSSL_PARAM_construct_octet_string("foo", &foo, sizeof(foo));
&foo_l);
params[n++] = OSSL_PARAM_construct_end(); params[n++] = OSSL_PARAM_construct_end();
return params; return params;
} }
struct param_owner_st { struct param_owner_st {
const OSSL_PARAM *static_params; OSSL_PARAM *static_params;
OSSL_PARAM *(*constructed_params)(void); OSSL_PARAM *(*constructed_params)(void);
}; };
@ -452,12 +433,12 @@ static struct {
}; };
/* Generic tester of combinations of "providers" and params */ /* Generic tester of combinations of "providers" and params */
static int test_case_variant(const OSSL_PARAM *params, static int test_case_variant(OSSL_PARAM *params, const struct provider_dispatch_st *prov)
const struct provider_dispatch_st *prov)
{ {
BIGNUM *verify_p3 = NULL; BIGNUM *verify_p3 = NULL;
void *obj = NULL; void *obj = NULL;
int errcnt = 0; int errcnt = 0;
OSSL_PARAM *p;
/* /*
* Initialize * Initialize
@ -480,12 +461,15 @@ static int test_case_variant(const OSSL_PARAM *params,
|| !TEST_ptr(BN_native2bn(bignumbin, bignumbin_l, app_p3)) || !TEST_ptr(BN_native2bn(bignumbin, bignumbin_l, app_p3))
|| !TEST_BN_eq(app_p3, verify_p3) /* "provider" value */ || !TEST_BN_eq(app_p3, verify_p3) /* "provider" value */
|| !TEST_str_eq(app_p4, p4_init) /* "provider" value */ || !TEST_str_eq(app_p4, p4_init) /* "provider" value */
|| !TEST_size_t_eq(app_p5_l, sizeof(p5_init)) /* "provider" value */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p5"))
|| !TEST_size_t_eq(p->return_size, sizeof(p5_init)) /* "provider" value */
|| !TEST_str_eq(app_p5, p5_init) /* "provider" value */ || !TEST_str_eq(app_p5, p5_init) /* "provider" value */
|| !TEST_size_t_eq(app_p6_l, sizeof(p6_init)) /* "provider" value */ || !TEST_ptr(p = OSSL_PARAM_locate(params, "p6"))
|| !TEST_size_t_eq(p->return_size, sizeof(p6_init)) /* "provider" value */
|| !TEST_str_eq(app_p6, p6_init) /* "provider" value */ || !TEST_str_eq(app_p6, p6_init) /* "provider" value */
|| !TEST_char_eq(foo[0], app_foo_init) /* Should remain untouched */ || !TEST_char_eq(foo[0], app_foo_init) /* Should remain untouched */
|| !TEST_int_eq(foo_l, sizeof(app_foo_init))) || !TEST_ptr(p = OSSL_PARAM_locate(params, "foo"))
|| !TEST_int_eq(p->return_size, 0))
errcnt++; errcnt++;
/* /*
@ -503,10 +487,7 @@ static int test_case_variant(const OSSL_PARAM *params,
|| !TEST_double_eq(sneakpeek->p2, p2_init) /* Should remain untouched */ || !TEST_double_eq(sneakpeek->p2, p2_init) /* Should remain untouched */
|| !TEST_BN_eq(sneakpeek->p3, app_p3) /* app value set */ || !TEST_BN_eq(sneakpeek->p3, app_p3) /* app value set */
|| !TEST_str_eq(sneakpeek->p4, app_p4) /* app value set */ || !TEST_str_eq(sneakpeek->p4, app_p4) /* app value set */
|| !TEST_size_t_eq(sneakpeek->p5_l, app_p5_l) /* app value set */
|| !TEST_str_eq(sneakpeek->p5, app_p5) /* app value set */ || !TEST_str_eq(sneakpeek->p5, app_p5) /* app value set */
|| !TEST_size_t_eq(sneakpeek->p6_l,
sizeof(app_p6_init)) /* app value set */
|| !TEST_str_eq(sneakpeek->p6, app_p6)) /* app value set */ || !TEST_str_eq(sneakpeek->p6, app_p6)) /* app value set */
errcnt++; errcnt++;
} }
@ -529,14 +510,17 @@ static int test_case_variant(const OSSL_PARAM *params,
|| !TEST_ptr(BN_native2bn(bignumbin, bignumbin_l, app_p3)) || !TEST_ptr(BN_native2bn(bignumbin, bignumbin_l, app_p3))
|| !TEST_BN_eq(app_p3, verify_p3) /* app value */ || !TEST_BN_eq(app_p3, verify_p3) /* app value */
|| !TEST_str_eq(app_p4, app_p4_init) /* app value */ || !TEST_str_eq(app_p4, app_p4_init) /* app value */
|| !TEST_size_t_eq(app_p5_l, || !TEST_ptr(p = OSSL_PARAM_locate(params, "p5"))
|| !TEST_size_t_eq(p->return_size,
sizeof(app_p5_init)) /* app value */ sizeof(app_p5_init)) /* app value */
|| !TEST_str_eq(app_p5, app_p5_init) /* app value */ || !TEST_str_eq(app_p5, app_p5_init) /* app value */
|| !TEST_size_t_eq(app_p6_l, || !TEST_ptr(p = OSSL_PARAM_locate(params, "p6"))
|| !TEST_size_t_eq(p->return_size,
sizeof(app_p6_init)) /* app value */ sizeof(app_p6_init)) /* app value */
|| !TEST_str_eq(app_p6, app_p6_init) /* app value */ || !TEST_str_eq(app_p6, app_p6_init) /* app value */
|| !TEST_char_eq(foo[0], app_foo_init) /* Should remain untouched */ || !TEST_char_eq(foo[0], app_foo_init) /* Should remain untouched */
|| !TEST_int_eq(foo_l, sizeof(app_foo_init))) || !TEST_ptr(p = OSSL_PARAM_locate(params, "foo"))
|| !TEST_int_eq(p->return_size, 0))
errcnt++; errcnt++;
fin: fin:

5
test/provider_internal_test.c
View File

@ -15,10 +15,9 @@
extern OSSL_provider_init_fn PROVIDER_INIT_FUNCTION_NAME; extern OSSL_provider_init_fn PROVIDER_INIT_FUNCTION_NAME;
static char buf[256]; static char buf[256];
static size_t buf_l = 0;
static OSSL_PARAM greeting_request[] = { static OSSL_PARAM greeting_request[] = {
{ "greeting", OSSL_PARAM_UTF8_STRING, buf, sizeof(buf), &buf_l }, { "greeting", OSSL_PARAM_UTF8_STRING, buf, sizeof(buf), 0 },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, 0 }
}; };
static int test_provider(OSSL_PROVIDER *prov, const char *expected_greeting) static int test_provider(OSSL_PROVIDER *prov, const char *expected_greeting)

5
test/provider_test.c
View File

@ -14,10 +14,9 @@
extern OSSL_provider_init_fn PROVIDER_INIT_FUNCTION_NAME; extern OSSL_provider_init_fn PROVIDER_INIT_FUNCTION_NAME;
static char buf[256]; static char buf[256];
static size_t buf_l = 0;
static OSSL_PARAM greeting_request[] = { static OSSL_PARAM greeting_request[] = {
{ "greeting", OSSL_PARAM_UTF8_STRING, buf, sizeof(buf), &buf_l }, { "greeting", OSSL_PARAM_UTF8_STRING, buf, sizeof(buf) },
{ NULL, 0, NULL, 0, NULL } { NULL, 0, NULL, 0, 0 }
}; };
static int test_provider(const char *name) static int test_provider(const char *name)

1
util/libcrypto.num
View File

@ -4832,3 +4832,4 @@ OPENSSL_CTX_get0_private_drbg 4776 3_0_0 EXIST::FUNCTION:
BN_CTX_new_ex 4777 3_0_0 EXIST::FUNCTION: BN_CTX_new_ex 4777 3_0_0 EXIST::FUNCTION:
BN_CTX_secure_new_ex 4778 3_0_0 EXIST::FUNCTION: BN_CTX_secure_new_ex 4778 3_0_0 EXIST::FUNCTION:
OPENSSL_thread_stop_ex 4779 3_0_0 EXIST::FUNCTION: OPENSSL_thread_stop_ex 4779 3_0_0 EXIST::FUNCTION:
OSSL_PARAM_locate_const 4780 3_0_0 EXIST::FUNCTION:

13
util/private.num
View File

@ -332,14 +332,15 @@ OSSL_PARAM_TYPE define
OSSL_PARAM_octet_ptr define OSSL_PARAM_octet_ptr define
OSSL_PARAM_octet_string define OSSL_PARAM_octet_string define
OSSL_PARAM_utf8_ptr define OSSL_PARAM_utf8_ptr define
OSSL_PARAM_BN define
OSSL_PARAM_TYPE generic
OSSL_PARAM_construct_TYPE generic
OSSL_PARAM_octet_string define
OSSL_PARAM_utf8_string define OSSL_PARAM_utf8_string define
OSSL_PARAM_SIZED_BN define OSSL_PARAM_octet_ptr define
OSSL_PARAM_SIZED_TYPE define OSSL_PARAM_get_TYPE generic
OSSL_PARAM_SIZED_octet_ptr define
OSSL_PARAM_SIZED_octet_string define
OSSL_PARAM_SIZED_utf8_ptr define
OSSL_PARAM_SIZED_utf8_string define
OSSL_PARAM_END define OSSL_PARAM_END define
OSSL_PARAM_set_TYPE generic
PEM_FLAG_EAY_COMPATIBLE define PEM_FLAG_EAY_COMPATIBLE define
PEM_FLAG_ONLY_B64 define PEM_FLAG_ONLY_B64 define
PEM_FLAG_SECURE define PEM_FLAG_SECURE define