crypto/params_from_text.c

   1 /*
   2  * Copyright 2019-2024 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2019, Oracle and/or its affiliates.  All rights reserved.
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 #include "internal/common.h" /* for HAS_PREFIX */
  12 #include <openssl/ebcdic.h>
  13 #include <openssl/err.h>
  14 #include <openssl/params.h>
  15
  16 /*
  17  * When processing text to params, we're trying to be smart with numbers.
  18  * Instead of handling each specific separate integer type, we use a bignum
  19  * and ensure that it isn't larger than the expected size, and we then make
  20  * sure it is the expected size...  if there is one given.
  21  * (if the size can be arbitrary, then we give whatever we have)
  22  */
  23
  24 static int prepare_from_text(const OSSL_PARAM *paramdefs, const char *key,
  25                              const char *value, size_t value_n,
  26                              /* Output parameters */
  27                              const OSSL_PARAM **paramdef, int *ishex,
  28                              size_t *buf_n, BIGNUM **tmpbn, int *found)
  29 {
  30     const OSSL_PARAM *p;
  31     size_t buf_bits;
  32     int r;
  33
  34     /*
  35      * ishex is used to translate legacy style string controls in hex format
  36      * to octet string parameters.
  37      */
  38     *ishex = CHECK_AND_SKIP_PREFIX(key, "hex");
  39
  40     p = *paramdef = OSSL_PARAM_locate_const(paramdefs, key);
  41     if (found != NULL)
  42         *found = p != NULL;
  43     if (p == NULL)
  44         return 0;
  45
  46     switch (p->data_type) {
  47     case OSSL_PARAM_INTEGER:
  48     case OSSL_PARAM_UNSIGNED_INTEGER:
  49         if (*ishex)
  50             r = BN_hex2bn(tmpbn, value);
  51         else
  52             r = BN_asc2bn(tmpbn, value);
  53
  54         if (r == 0 || *tmpbn == NULL)
  55             return 0;
  56
  57         if (p->data_type == OSSL_PARAM_UNSIGNED_INTEGER
  58             && BN_is_negative(*tmpbn)) {
  59             ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_INVALID_NEGATIVE_VALUE);
  60             return 0;
  61         }
  62
  63         /*
  64          * 2's complement negate, part 1
  65          *
  66          * BN_bn2nativepad puts the absolute value of the number in the
  67          * buffer, i.e. if it's negative, we need to deal with it.  We do
  68          * it by subtracting 1 here and inverting the bytes in
  69          * construct_from_text() below.
  70          * To subtract 1 from an absolute value of a negative number we
  71          * actually have to add 1: -3 - 1 = -4, |-3| = 3 + 1 = 4.
  72          */
  73         if (p->data_type == OSSL_PARAM_INTEGER && BN_is_negative(*tmpbn)
  74             && !BN_add_word(*tmpbn, 1)) {
  75             return 0;
  76         }
  77
  78         buf_bits = (size_t)BN_num_bits(*tmpbn);
  79
  80         /*
  81          * Compensate for cases where the most significant bit in
  82          * the resulting OSSL_PARAM buffer will be set after the
  83          * BN_bn2nativepad() call, as the implied sign may not be
  84          * correct after the second part of the 2's complement
  85          * negation has been performed.
  86          * We fix these cases by extending the buffer by one byte
  87          * (8 bits), which will give some padding.  The second part
  88          * of the 2's complement negation will do the rest.
  89          */
  90         if (p->data_type == OSSL_PARAM_INTEGER && buf_bits % 8 == 0)
  91             buf_bits += 8;
  92
  93         *buf_n = (buf_bits + 7) / 8;
  94
  95         /*
  96          * A zero data size means "arbitrary size", so only do the
  97          * range checking if a size is specified.
  98          */
  99         if (p->data_size > 0) {
 100             if (buf_bits > p->data_size * 8) {
 101                 ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_TOO_SMALL_BUFFER);
 102                 /* Since this is a different error, we don't break */
 103                 return 0;
 104             }
 105             /* Change actual size to become the desired size. */
 106             *buf_n = p->data_size;
 107         }
 108         break;
 109     case OSSL_PARAM_UTF8_STRING:
 110         if (*ishex) {
 111             ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT);
 112             return 0;
 113         }
 114         *buf_n = strlen(value) + 1;
 115         break;
 116     case OSSL_PARAM_OCTET_STRING:
 117         if (*ishex) {
 118             size_t hexdigits = strlen(value);
 119             if ((hexdigits % 2) != 0) {
 120                 /* We don't accept an odd number of hex digits */
 121                 ERR_raise(ERR_LIB_CRYPTO, CRYPTO_R_ODD_NUMBER_OF_DIGITS);
 122                 return 0;
 123             }
 124             *buf_n = hexdigits >> 1;
 125         } else {
 126             *buf_n = value_n;
 127         }
 128         break;
 129     }
 130
 131     return 1;
 132 }
 133
 134 static int construct_from_text(OSSL_PARAM *to, const OSSL_PARAM *paramdef,
 135                                const char *value, size_t value_n, int ishex,
 136                                void *buf, size_t buf_n, BIGNUM *tmpbn)
 137 {
 138     if (buf == NULL)
 139         return 0;
 140
 141     if (buf_n > 0) {
 142         switch (paramdef->data_type) {
 143         case OSSL_PARAM_INTEGER:
 144         case OSSL_PARAM_UNSIGNED_INTEGER:
 145             /*
 146             {
 147                 if ((new_value = OPENSSL_malloc(new_value_n)) == NULL) {
 148                     BN_free(a);
 149                     break;
 150                 }
 151             */
 152
 153             BN_bn2nativepad(tmpbn, buf, buf_n);
 154
 155             /*
 156              * 2's complement negation, part two.
 157              *
 158              * Because we did the first part on the BIGNUM itself, we can just
 159              * invert all the bytes here and be done with it.
 160              */
 161             if (paramdef->data_type == OSSL_PARAM_INTEGER
 162                 && BN_is_negative(tmpbn)) {
 163                 unsigned char *cp;
 164                 size_t i = buf_n;
 165
 166                 for (cp = buf; i-- > 0; cp++)
 167                     *cp ^= 0xFF;
 168             }
 169             break;
 170         case OSSL_PARAM_UTF8_STRING:
 171 #ifdef CHARSET_EBCDIC
 172             ebcdic2ascii(buf, value, buf_n);
 173 #else
 174             strncpy(buf, value, buf_n);
 175 #endif
 176             /* Don't count the terminating NUL byte as data */
 177             buf_n--;
 178             break;
 179         case OSSL_PARAM_OCTET_STRING:
 180             if (ishex) {
 181                 size_t l = 0;
 182
 183                 if (!OPENSSL_hexstr2buf_ex(buf, buf_n, &l, value, ':'))
 184                     return 0;
 185             } else {
 186                 memcpy(buf, value, buf_n);
 187             }
 188             break;
 189         }
 190     }
 191
 192     *to = *paramdef;
 193     to->data = buf;
 194     to->data_size = buf_n;
 195     to->return_size = OSSL_PARAM_UNMODIFIED;
 196
 197     return 1;
 198 }
 199
 200 int OSSL_PARAM_allocate_from_text(OSSL_PARAM *to,
 201                                   const OSSL_PARAM *paramdefs,
 202                                   const char *key, const char *value,
 203                                   size_t value_n, int *found)
 204 {
 205     const OSSL_PARAM *paramdef = NULL;
 206     int ishex = 0;
 207     void *buf = NULL;
 208     size_t buf_n = 0;
 209     BIGNUM *tmpbn = NULL;
 210     int ok = 0;
 211
 212     if (to == NULL || paramdefs == NULL)
 213         return 0;
 214
 215     if (!prepare_from_text(paramdefs, key, value, value_n,
 216                            &paramdef, &ishex, &buf_n, &tmpbn, found))
 217         goto err;
 218
 219     if ((buf = OPENSSL_zalloc(buf_n > 0 ? buf_n : 1)) == NULL)
 220         goto err;
 221
 222     ok = construct_from_text(to, paramdef, value, value_n, ishex,
 223                              buf, buf_n, tmpbn);
 224     BN_free(tmpbn);
 225     if (!ok)
 226         OPENSSL_free(buf);
 227     return ok;
 228  err:
 229     BN_free(tmpbn);
 230     return 0;
 231 }