crypto/params.c

   1 /*
   2  * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include <string.h>
  12 #include <openssl/params.h>
  13 #include "internal/thread_once.h"
  14 #include "internal/numbers.h"
  15
  16 OSSL_PARAM *OSSL_PARAM_locate(OSSL_PARAM *p, const char *key)
  17 {
  18     if (p != NULL && key != NULL)
  19         for (; p->key != NULL; p++)
  20             if (strcmp(key, p->key) == 0)
  21                 return p;
  22     return NULL;
  23 }
  24
  25 const OSSL_PARAM *OSSL_PARAM_locate_const(const OSSL_PARAM *p, const char *key)
  26 {
  27     return OSSL_PARAM_locate((OSSL_PARAM *)p, key);
  28 }
  29
  30 static OSSL_PARAM ossl_param_construct(const char *key, unsigned int data_type,
  31                                        void *data, size_t data_size)
  32 {
  33     OSSL_PARAM res;
  34
  35     res.key = key;
  36     res.data_type = data_type;
  37     res.data = data;
  38     res.data_size = data_size;
  39     res.return_size = 0;
  40     return res;
  41 }
  42
  43 int OSSL_PARAM_get_int(const OSSL_PARAM *p, int *val)
  44 {
  45     switch (sizeof(int)) {
  46     case sizeof(int32_t):
  47         return OSSL_PARAM_get_int32(p, (int32_t *)val);
  48     case sizeof(int64_t):
  49         return OSSL_PARAM_get_int64(p, (int64_t *)val);
  50     }
  51     return 0;
  52 }
  53
  54 int OSSL_PARAM_set_int(OSSL_PARAM *p, int val)
  55 {
  56     switch (sizeof(int)) {
  57     case sizeof(int32_t):
  58         return OSSL_PARAM_set_int32(p, (int32_t)val);
  59     case sizeof(int64_t):
  60         return OSSL_PARAM_set_int64(p, (int64_t)val);
  61     }
  62     return 0;
  63 }
  64
  65 OSSL_PARAM OSSL_PARAM_construct_int(const char *key, int *buf)
  66 {
  67     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int));
  68 }
  69
  70 int OSSL_PARAM_get_uint(const OSSL_PARAM *p, unsigned int *val)
  71 {
  72     switch (sizeof(unsigned int)) {
  73     case sizeof(uint32_t):
  74         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
  75     case sizeof(uint64_t):
  76         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
  77     }
  78     return 0;
  79 }
  80
  81 int OSSL_PARAM_set_uint(OSSL_PARAM *p, unsigned int val)
  82 {
  83     switch (sizeof(unsigned int)) {
  84     case sizeof(uint32_t):
  85         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
  86     case sizeof(uint64_t):
  87         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
  88     }
  89     return 0;
  90 }
  91
  92 OSSL_PARAM OSSL_PARAM_construct_uint(const char *key, unsigned int *buf)
  93 {
  94     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
  95                                 sizeof(unsigned int));
  96 }
  97
  98 int OSSL_PARAM_get_long(const OSSL_PARAM *p, long int *val)
  99 {
 100     switch (sizeof(long int)) {
 101     case sizeof(int32_t):
 102         return OSSL_PARAM_get_int32(p, (int32_t *)val);
 103     case sizeof(int64_t):
 104         return OSSL_PARAM_get_int64(p, (int64_t *)val);
 105     }
 106     return 0;
 107 }
 108
 109 int OSSL_PARAM_set_long(OSSL_PARAM *p, long int val)
 110 {
 111     switch (sizeof(long int)) {
 112     case sizeof(int32_t):
 113         return OSSL_PARAM_set_int32(p, (int32_t)val);
 114     case sizeof(int64_t):
 115         return OSSL_PARAM_set_int64(p, (int64_t)val);
 116     }
 117     return 0;
 118 }
 119
 120 OSSL_PARAM OSSL_PARAM_construct_long(const char *key, long int *buf)
 121 {
 122     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(long int));
 123 }
 124
 125 int OSSL_PARAM_get_ulong(const OSSL_PARAM *p, unsigned long int *val)
 126 {
 127     switch (sizeof(unsigned long int)) {
 128     case sizeof(uint32_t):
 129         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
 130     case sizeof(uint64_t):
 131         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
 132     }
 133     return 0;
 134 }
 135
 136 int OSSL_PARAM_set_ulong(OSSL_PARAM *p, unsigned long int val)
 137 {
 138     switch (sizeof(unsigned long int)) {
 139     case sizeof(uint32_t):
 140         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
 141     case sizeof(uint64_t):
 142         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
 143     }
 144     return 0;
 145 }
 146
 147 OSSL_PARAM OSSL_PARAM_construct_ulong(const char *key, unsigned long int *buf)
 148 {
 149     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
 150                                 sizeof(unsigned long int));
 151 }
 152
 153 int OSSL_PARAM_get_int32(const OSSL_PARAM *p, int32_t *val)
 154 {
 155     int64_t i64;
 156     uint32_t u32;
 157     uint64_t u64;
 158     double d;
 159
 160     if (val == NULL || p == NULL )
 161         return 0;
 162
 163     if (p->data_type == OSSL_PARAM_INTEGER) {
 164         switch (p->data_size) {
 165         case sizeof(int32_t):
 166             *val = *(const int32_t *)p->data;
 167             return 1;
 168         case sizeof(int64_t):
 169             i64 = *(const int64_t *)p->data;
 170             if (i64 >= INT32_MIN && i64 <= INT32_MAX) {
 171                 *val = (int32_t)i64;
 172                 return 1;
 173             }
 174             break;
 175         }
 176     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 177         switch (p->data_size) {
 178         case sizeof(uint32_t):
 179             u32 = *(const uint32_t *)p->data;
 180             if (u32 <= INT32_MAX) {
 181                 *val = (int32_t)u32;
 182                 return 1;
 183             }
 184             break;
 185         case sizeof(uint64_t):
 186             u64 = *(const uint64_t *)p->data;
 187             if (u64 <= INT32_MAX) {
 188                 *val = (int32_t)u64;
 189                 return 1;
 190             }
 191             break;
 192         }
 193     } else if (p->data_type == OSSL_PARAM_REAL) {
 194         switch (p->data_size) {
 195         case sizeof(double):
 196             d = *(const double *)p->data;
 197             if (d >= INT32_MIN && d <= INT32_MAX && d == (int32_t)d) {
 198                 *val = (int32_t)d;
 199                 return 1;
 200             }
 201             break;
 202         }
 203     }
 204     return 0;
 205 }
 206
 207 int OSSL_PARAM_set_int32(OSSL_PARAM *p, int32_t val)
 208 {
 209     if (p == NULL)
 210         return 0;
 211     p->return_size = 0;
 212     if (p->data_type == OSSL_PARAM_INTEGER) {
 213         p->return_size = sizeof(int32_t); /* Minimum expected size */
 214         switch (p->data_size) {
 215         case sizeof(int32_t):
 216             *(int32_t *)p->data = val;
 217             return 1;
 218         case sizeof(int64_t):
 219             p->return_size = sizeof(int64_t);
 220             *(int64_t *)p->data = (int64_t)val;
 221             return 1;
 222         }
 223     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
 224         p->return_size = sizeof(uint32_t); /* Minimum expected size */
 225         switch (p->data_size) {
 226         case sizeof(uint32_t):
 227             *(uint32_t *)p->data = (uint32_t)val;
 228             return 1;
 229         case sizeof(uint64_t):
 230             p->return_size = sizeof(uint64_t);
 231             *(uint64_t *)p->data = (uint64_t)val;
 232             return 1;
 233         }
 234     } else if (p->data_type == OSSL_PARAM_REAL) {
 235         p->return_size = sizeof(double);
 236         switch (p->data_size) {
 237         case sizeof(double):
 238             *(double *)p->data = (double)val;
 239             return 1;
 240         }
 241     }
 242     return 0;
 243 }
 244
 245 OSSL_PARAM OSSL_PARAM_construct_int32(const char *key, int32_t *buf)
 246 {
 247     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf,
 248                                 sizeof(int32_t));
 249 }
 250
 251 int OSSL_PARAM_get_uint32(const OSSL_PARAM *p, uint32_t *val)
 252 {
 253     int32_t i32;
 254     int64_t i64;
 255     uint64_t u64;
 256     double d;
 257
 258     if (val == NULL || p == NULL)
 259         return 0;
 260
 261     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 262         switch (p->data_size) {
 263         case sizeof(uint32_t):
 264             *val = *(const uint32_t *)p->data;
 265             return 1;
 266         case sizeof(uint64_t):
 267             u64 = *(const uint64_t *)p->data;
 268             if (u64 <= UINT32_MAX) {
 269                 *val = (uint32_t)u64;
 270                 return 1;
 271             }
 272             break;
 273         }
 274     } else if (p->data_type == OSSL_PARAM_INTEGER) {
 275         switch (p->data_size) {
 276         case sizeof(int32_t):
 277             i32 = *(const int32_t *)p->data;
 278             if (i32 >= 0) {
 279                 *val = i32;
 280                 return 1;
 281             }
 282             break;
 283         case sizeof(int64_t):
 284             i64 = *(const int64_t *)p->data;
 285             if (i64 >= 0 && i64 <= UINT32_MAX) {
 286                 *val = (uint32_t)i64;
 287                 return 1;
 288             }
 289             break;
 290         }
 291     } else if (p->data_type == OSSL_PARAM_REAL) {
 292         switch (p->data_size) {
 293         case sizeof(double):
 294             d = *(const double *)p->data;
 295             if (d >= 0 && d <= UINT32_MAX && d == (uint32_t)d) {
 296                 *val = (uint32_t)d;
 297                 return 1;
 298             }
 299             break;
 300         }
 301     }
 302     return 0;
 303 }
 304
 305 int OSSL_PARAM_set_uint32(OSSL_PARAM *p, uint32_t val)
 306 {
 307     if (p == NULL)
 308         return 0;
 309     p->return_size = 0;
 310
 311     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 312         p->return_size = sizeof(uint32_t); /* Minimum expected size */
 313         switch (p->data_size) {
 314         case sizeof(uint32_t):
 315             *(uint32_t *)p->data = val;
 316             return 1;
 317         case sizeof(uint64_t):
 318             p->return_size = sizeof(uint64_t);
 319             *(uint64_t *)p->data = val;
 320             return 1;
 321         }
 322     } else if (p->data_type == OSSL_PARAM_INTEGER) {
 323         p->return_size = sizeof(int32_t); /* Minimum expected size */
 324         switch (p->data_size) {
 325         case sizeof(int32_t):
 326             if (val <= INT32_MAX) {
 327                 *(int32_t *)p->data = (int32_t)val;
 328                 return 1;
 329             }
 330             break;
 331         case sizeof(int64_t):
 332             p->return_size = sizeof(int64_t);
 333             *(int64_t *)p->data = (int64_t)val;
 334             return 1;
 335         }
 336     } else if (p->data_type == OSSL_PARAM_REAL) {
 337         p->return_size = sizeof(double);
 338         switch (p->data_size) {
 339         case sizeof(double):
 340             *(double *)p->data = (double)val;
 341             return 1;
 342         }
 343     }
 344     return 0;
 345 }
 346
 347 OSSL_PARAM OSSL_PARAM_construct_uint32(const char *key, uint32_t *buf)
 348 {
 349     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
 350                                 sizeof(uint32_t));
 351 }
 352
 353 int OSSL_PARAM_get_int64(const OSSL_PARAM *p, int64_t *val)
 354 {
 355     uint64_t u64;
 356     double d;
 357
 358     if (val == NULL || p == NULL )
 359         return 0;
 360
 361     if (p->data_type == OSSL_PARAM_INTEGER) {
 362         switch (p->data_size) {
 363         case sizeof(int32_t):
 364             *val = *(const int32_t *)p->data;
 365             return 1;
 366         case sizeof(int64_t):
 367             *val = *(const int64_t *)p->data;
 368             return 1;
 369         }
 370     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 371         switch (p->data_size) {
 372         case sizeof(uint32_t):
 373             *val = *(const uint32_t *)p->data;
 374             return 1;
 375         case sizeof(uint64_t):
 376             u64 = *(const uint64_t *)p->data;
 377             if (u64 <= INT64_MAX) {
 378                 *val = (int64_t)u64;
 379                 return 1;
 380             }
 381             break;
 382         }
 383     } else if (p->data_type == OSSL_PARAM_REAL) {
 384         switch (p->data_size) {
 385         case sizeof(double):
 386             d = *(const double *)p->data;
 387             if (d >= INT64_MIN && d <= INT64_MAX && d == (int64_t)d) {
 388                 *val = (int64_t)d;
 389                 return 1;
 390             }
 391             break;
 392         }
 393     }
 394     return 0;
 395 }
 396
 397 int OSSL_PARAM_set_int64(OSSL_PARAM *p, int64_t val)
 398 {
 399     uint64_t u64;
 400
 401     if (p == NULL)
 402         return 0;
 403     p->return_size = 0;
 404     if (p->data_type == OSSL_PARAM_INTEGER) {
 405         p->return_size = sizeof(int64_t); /* Expected size */
 406         switch (p->data_size) {
 407         case sizeof(int32_t):
 408             if (val >= INT32_MIN && val <= INT32_MAX) {
 409                 p->return_size = sizeof(int32_t);
 410                 *(int32_t *)p->data = (int32_t)val;
 411                 return 1;
 412             }
 413             break;
 414         case sizeof(int64_t):
 415             *(int64_t *)p->data = val;
 416             return 1;
 417         }
 418     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER && val >= 0) {
 419         p->return_size = sizeof(uint64_t); /* Expected size */
 420         switch (p->data_size) {
 421         case sizeof(uint32_t):
 422             if (val <= UINT32_MAX) {
 423                 p->return_size = sizeof(uint32_t);
 424                 *(uint32_t *)p->data = (uint32_t)val;
 425                 return 1;
 426             }
 427             break;
 428         case sizeof(uint64_t):
 429             *(uint64_t *)p->data = (uint64_t)val;
 430             return 1;
 431         }
 432     } else if (p->data_type == OSSL_PARAM_REAL) {
 433         p->return_size = sizeof(double);
 434         switch (p->data_size) {
 435         case sizeof(double):
 436             u64 = val < 0 ? -val : val;
 437             if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
 438                 *(double *)p->data = (double)val;
 439                 return 1;
 440             }
 441             break;
 442         }
 443     }
 444     return 0;
 445 }
 446
 447 OSSL_PARAM OSSL_PARAM_construct_int64(const char *key, int64_t *buf)
 448 {
 449     return ossl_param_construct(key, OSSL_PARAM_INTEGER, buf, sizeof(int64_t));
 450 }
 451
 452 int OSSL_PARAM_get_uint64(const OSSL_PARAM *p, uint64_t *val)
 453 {
 454     int32_t i32;
 455     int64_t i64;
 456     double d;
 457
 458     if (val == NULL || p == NULL)
 459         return 0;
 460
 461     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 462         switch (p->data_size) {
 463         case sizeof(uint32_t):
 464             *val = *(const uint32_t *)p->data;
 465             return 1;
 466         case sizeof(uint64_t):
 467             *val = *(const uint64_t *)p->data;
 468             return 1;
 469         }
 470     } else if (p->data_type == OSSL_PARAM_INTEGER) {
 471         switch (p->data_size) {
 472         case sizeof(int32_t):
 473             i32 = *(const int32_t *)p->data;
 474             if (i32 >= 0) {
 475                 *val = (uint64_t)i32;
 476                 return 1;
 477             }
 478             break;
 479         case sizeof(int64_t):
 480             i64 = *(const int64_t *)p->data;
 481             if (i64 >= 0) {
 482                 *val = (uint64_t)i64;
 483                 return 1;
 484             }
 485             break;
 486         }
 487     } else if (p->data_type == OSSL_PARAM_REAL) {
 488         switch (p->data_size) {
 489         case sizeof(double):
 490             d = *(const double *)p->data;
 491             if (d >= 0 && d <= INT64_MAX && d == (uint64_t)d) {
 492                 *val = (uint64_t)d;
 493                 return 1;
 494             }
 495             break;
 496         }
 497     }
 498     return 0;
 499 }
 500
 501 int OSSL_PARAM_set_uint64(OSSL_PARAM *p, uint64_t val)
 502 {
 503     if (p == NULL)
 504         return 0;
 505     p->return_size = 0;
 506
 507     if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 508         p->return_size = sizeof(uint64_t); /* Expected size */
 509         switch (p->data_size) {
 510         case sizeof(uint32_t):
 511             if (val <= UINT32_MAX) {
 512                 p->return_size = sizeof(uint32_t);
 513                 *(uint32_t *)p->data = (uint32_t)val;
 514                 return 1;
 515             }
 516             break;
 517         case sizeof(uint64_t):
 518             *(uint64_t *)p->data = val;
 519             return 1;
 520         }
 521     } else if (p->data_type == OSSL_PARAM_INTEGER) {
 522         p->return_size = sizeof(int64_t); /* Expected size */
 523         switch (p->data_size) {
 524         case sizeof(int32_t):
 525             if (val <= INT32_MAX) {
 526                 p->return_size = sizeof(int32_t);
 527                 *(int32_t *)p->data = (int32_t)val;
 528                 return 1;
 529             }
 530             break;
 531         case sizeof(int64_t):
 532             if (val <= INT64_MAX) {
 533                 *(int64_t *)p->data = (int64_t)val;
 534                 return 1;
 535             }
 536             break;
 537         }
 538     } else if (p->data_type == OSSL_PARAM_REAL) {
 539         p->return_size = sizeof(double);
 540         switch (p->data_size) {
 541         case sizeof(double):
 542             if ((val >> 53) == 0) { /* 53 significant bits in the mantissa */
 543                 *(double *)p->data = (double)val;
 544                 return 1;
 545             }
 546             break;
 547         }
 548     }
 549     return 0;
 550 }
 551
 552 OSSL_PARAM OSSL_PARAM_construct_uint64(const char *key, uint64_t *buf)
 553 {
 554     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
 555                                 sizeof(uint64_t));
 556 }
 557
 558 int OSSL_PARAM_get_size_t(const OSSL_PARAM *p, size_t *val)
 559 {
 560     switch (sizeof(size_t)) {
 561     case sizeof(uint32_t):
 562         return OSSL_PARAM_get_uint32(p, (uint32_t *)val);
 563     case sizeof(uint64_t):
 564         return OSSL_PARAM_get_uint64(p, (uint64_t *)val);
 565     }
 566     return 0;
 567 }
 568
 569 int OSSL_PARAM_set_size_t(OSSL_PARAM *p, size_t val)
 570 {
 571     switch (sizeof(size_t)) {
 572     case sizeof(uint32_t):
 573         return OSSL_PARAM_set_uint32(p, (uint32_t)val);
 574     case sizeof(uint64_t):
 575         return OSSL_PARAM_set_uint64(p, (uint64_t)val);
 576     }
 577     return 0;
 578 }
 579
 580 OSSL_PARAM OSSL_PARAM_construct_size_t(const char *key, size_t *buf)
 581 {
 582     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER, buf,
 583                                 sizeof(size_t));
 584 }
 585
 586 int OSSL_PARAM_get_BN(const OSSL_PARAM *p, BIGNUM **val)
 587 {
 588     BIGNUM *b;
 589
 590     if (val == NULL
 591         || p == NULL
 592         || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
 593         return 0;
 594
 595     b = BN_native2bn(p->data, (int)p->data_size, *val);
 596     if (b != NULL) {
 597         *val = b;
 598         return 1;
 599     }
 600     return 0;
 601 }
 602
 603 int OSSL_PARAM_set_BN(OSSL_PARAM *p, const BIGNUM *val)
 604 {
 605     size_t bytes;
 606
 607     if (p == NULL)
 608         return 0;
 609     p->return_size = 0;
 610     if (val == NULL || p->data_type != OSSL_PARAM_UNSIGNED_INTEGER)
 611         return 0;
 612
 613     /* For the moment, only positive values are permitted */
 614     if (BN_is_negative(val))
 615         return 0;
 616
 617     bytes = (size_t)BN_num_bytes(val);
 618     p->return_size = bytes;
 619     return p->data_size >= bytes
 620         && BN_bn2nativepad(val, p->data, bytes) >= 0;
 621 }
 622
 623 OSSL_PARAM OSSL_PARAM_construct_BN(const char *key, unsigned char *buf,
 624                                    size_t bsize)
 625 {
 626     return ossl_param_construct(key, OSSL_PARAM_UNSIGNED_INTEGER,
 627                                 buf, bsize);
 628 }
 629
 630 int OSSL_PARAM_get_double(const OSSL_PARAM *p, double *val)
 631 {
 632     int64_t i64;
 633     uint64_t u64;
 634
 635     if (val == NULL || p == NULL)
 636         return 0;
 637
 638     if (p->data_type == OSSL_PARAM_REAL) {
 639         switch (p->data_size) {
 640         case sizeof(double):
 641             *val = *(const double *)p->data;
 642             return 1;
 643         }
 644     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER) {
 645         switch (p->data_size) {
 646         case sizeof(uint32_t):
 647             *val = *(const uint32_t *)p->data;
 648             return 1;
 649         case sizeof(uint64_t):
 650             u64 = *(const uint64_t *)p->data;
 651             if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
 652                 *val = (double)u64;
 653                 return 1;
 654             }
 655             break;
 656         }
 657     } else if (p->data_type == OSSL_PARAM_INTEGER) {
 658         switch (p->data_size) {
 659         case sizeof(int32_t):
 660             *val = *(const int32_t *)p->data;
 661             return 1;
 662         case sizeof(int64_t):
 663             i64 = *(const int64_t *)p->data;
 664             u64 = i64 < 0 ? -i64 : i64;
 665             if ((u64 >> 53) == 0) { /* 53 significant bits in the mantissa */
 666                 *val = 0.0 + i64;
 667                 return 1;
 668             }
 669             break;
 670         }
 671     }
 672     return 0;
 673 }
 674
 675 int OSSL_PARAM_set_double(OSSL_PARAM *p, double val)
 676 {
 677     if (p == NULL)
 678         return 0;
 679     p->return_size = 0;
 680
 681     if (p->data_type == OSSL_PARAM_REAL) {
 682         p->return_size = sizeof(double);
 683         switch (p->data_size) {
 684         case sizeof(double):
 685             *(double *)p->data = val;
 686             return 1;
 687         }
 688     } else if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER
 689                && val == (ossl_uintmax_t)val) {
 690         p->return_size = sizeof(double);
 691         switch (p->data_size) {
 692         case sizeof(uint32_t):
 693             if (val >= 0 && val <= UINT32_MAX) {
 694                 p->return_size = sizeof(uint32_t);
 695                 *(uint32_t *)p->data = (uint32_t)val;
 696                 return 1;
 697             }
 698             break;
 699         case sizeof(uint64_t):
 700             if (val >= 0 && val <= UINT64_MAX) {
 701                 p->return_size = sizeof(uint64_t);
 702                 *(uint64_t *)p->data = (uint64_t)val;
 703                 return 1;
 704             }
 705             break;            }
 706     } else if (p->data_type == OSSL_PARAM_INTEGER && val == (ossl_intmax_t)val) {
 707         p->return_size = sizeof(double);
 708         switch (p->data_size) {
 709         case sizeof(int32_t):
 710             if (val >= INT32_MIN && val <= INT32_MAX) {
 711                 p->return_size = sizeof(int32_t);
 712                 *(int32_t *)p->data = (int32_t)val;
 713                 return 1;
 714             }
 715             break;
 716         case sizeof(int64_t):
 717             if (val >= INT64_MIN && val <= INT64_MAX) {
 718                 p->return_size = sizeof(int64_t);
 719                 *(int64_t *)p->data = (int64_t)val;
 720                 return 1;
 721             }
 722             break;
 723         }
 724     }
 725     return 0;
 726 }
 727
 728 OSSL_PARAM OSSL_PARAM_construct_double(const char *key, double *buf)
 729 {
 730     return ossl_param_construct(key, OSSL_PARAM_REAL, buf, sizeof(double));
 731 }
 732
 733 static int get_string_internal(const OSSL_PARAM *p, void **val, size_t max_len,
 734                                size_t *used_len, unsigned int type)
 735 {
 736     size_t sz;
 737
 738     if (val == NULL || p == NULL || p->data_type != type)
 739         return 0;
 740
 741     sz = p->data_size;
 742
 743     if (used_len != NULL)
 744         *used_len = sz;
 745
 746     if (*val == NULL) {
 747         char *const q = OPENSSL_malloc(sz);
 748
 749         if (q == NULL)
 750             return 0;
 751         *val = q;
 752         memcpy(q, p->data, sz);
 753         return 1;
 754     }
 755     if (max_len < sz)
 756         return 0;
 757     memcpy(*val, p->data, sz);
 758     return 1;
 759 }
 760
 761 int OSSL_PARAM_get_utf8_string(const OSSL_PARAM *p, char **val, size_t max_len)
 762 {
 763     return get_string_internal(p, (void **)val, max_len, NULL,
 764                                OSSL_PARAM_UTF8_STRING);
 765 }
 766
 767 int OSSL_PARAM_get_octet_string(const OSSL_PARAM *p, void **val, size_t max_len,
 768                                 size_t *used_len)
 769 {
 770     return get_string_internal(p, val, max_len, used_len,
 771                                OSSL_PARAM_OCTET_STRING);
 772 }
 773
 774 static int set_string_internal(OSSL_PARAM *p, const void *val, size_t len,
 775                                unsigned int type)
 776 {
 777     p->return_size = len;
 778     if (p->data_type != type || p->data_size < len)
 779         return 0;
 780
 781     memcpy(p->data, val, len);
 782     return 1;
 783 }
 784
 785 int OSSL_PARAM_set_utf8_string(OSSL_PARAM *p, const char *val)
 786 {
 787     if (p == NULL)
 788         return 0;
 789
 790     p->return_size = 0;
 791     if (val == NULL)
 792         return 0;
 793     return set_string_internal(p, val, strlen(val) + 1, OSSL_PARAM_UTF8_STRING);
 794 }
 795
 796 int OSSL_PARAM_set_octet_string(OSSL_PARAM *p, const void *val,
 797                                 size_t len)
 798 {
 799     if (p == NULL)
 800         return 0;
 801
 802     p->return_size = 0;
 803     if (val == NULL)
 804         return 0;
 805     return set_string_internal(p, val, len, OSSL_PARAM_OCTET_STRING);
 806 }
 807
 808 OSSL_PARAM OSSL_PARAM_construct_utf8_string(const char *key, char *buf,
 809                                             size_t bsize)
 810 {
 811     return ossl_param_construct(key, OSSL_PARAM_UTF8_STRING, buf, bsize);
 812 }
 813
 814 OSSL_PARAM OSSL_PARAM_construct_octet_string(const char *key, void *buf,
 815                                              size_t bsize)
 816 {
 817     return ossl_param_construct(key, OSSL_PARAM_OCTET_STRING, buf, bsize);
 818 }
 819
 820 static int get_ptr_internal(const OSSL_PARAM *p, const void **val,
 821                             size_t *used_len, unsigned int type)
 822 {
 823     if (val == NULL || p == NULL || p->data_type != type)
 824         return 0;
 825     if (used_len != NULL)
 826         *used_len = p->data_size;
 827     *val = *(const void **)p->data;
 828     return 1;
 829 }
 830
 831 int OSSL_PARAM_get_utf8_ptr(const OSSL_PARAM *p, const char **val)
 832 {
 833     return get_ptr_internal(p, (const void **)val, NULL, OSSL_PARAM_UTF8_PTR);
 834 }
 835
 836 int OSSL_PARAM_get_octet_ptr(const OSSL_PARAM *p, const void **val,
 837                              size_t *used_len)
 838 {
 839     return get_ptr_internal(p, val, used_len, OSSL_PARAM_OCTET_PTR);
 840 }
 841
 842 static int set_ptr_internal(OSSL_PARAM *p, const void *val,
 843                             unsigned int type, size_t len)
 844 {
 845     p->return_size = len;
 846     if (p->data_type != type)
 847         return 0;
 848     *(const void **)p->data = val;
 849     return 1;
 850 }
 851
 852 int OSSL_PARAM_set_utf8_ptr(OSSL_PARAM *p, const char *val)
 853 {
 854     if (p == NULL)
 855         return 0;
 856     p->return_size = 0;
 857     if (val == NULL)
 858         return 0;
 859     return set_ptr_internal(p, val, OSSL_PARAM_UTF8_PTR, strlen(val) + 1);
 860 }
 861
 862 int OSSL_PARAM_set_octet_ptr(OSSL_PARAM *p, const void *val,
 863                              size_t used_len)
 864 {
 865     if (p == NULL)
 866         return 0;
 867     p->return_size = 0;
 868     if (val == NULL)
 869         return 0;
 870     return set_ptr_internal(p, val, OSSL_PARAM_OCTET_PTR, used_len);
 871 }
 872
 873 OSSL_PARAM OSSL_PARAM_construct_utf8_ptr(const char *key, char **buf,
 874                                          size_t bsize)
 875 {
 876     return ossl_param_construct(key, OSSL_PARAM_UTF8_PTR, buf, bsize);
 877 }
 878
 879 OSSL_PARAM OSSL_PARAM_construct_octet_ptr(const char *key, void **buf,
 880                                           size_t bsize)
 881 {
 882     return ossl_param_construct(key, OSSL_PARAM_OCTET_PTR, buf, bsize);
 883 }
 884
 885 OSSL_PARAM OSSL_PARAM_construct_end(void)
 886 {
 887     OSSL_PARAM end = OSSL_PARAM_END;
 888
 889     return end;
 890 }