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
prepare_from_text(const OSSL_PARAM * paramdefs,const char * key,const char * value,size_t value_n,const OSSL_PARAM ** paramdef,int * ishex,size_t * buf_n,BIGNUM ** tmpbn,int * found)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
construct_from_text(OSSL_PARAM * to,const OSSL_PARAM * paramdef,const char * value,size_t value_n,int ishex,void * buf,size_t buf_n,BIGNUM * tmpbn)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
OSSL_PARAM_allocate_from_text(OSSL_PARAM * to,const OSSL_PARAM * paramdefs,const char * key,const char * value,size_t value_n,int * found)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 ¶mdef, &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 }
232
