59cee5f1159bd2c6c1366ae3322d742c7c18b2d3
[openssl.git] / crypto / params_from_text.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/err.h>
13 #include <openssl/params.h>
14
15 /*
16  * When processing text to params, we're trying to be smart with numbers.
17  * Instead of handling each specific separate integer type, we use a bignum
18  * and ensure that it isn't larger than the expected size, and we then make
19  * sure it is the expected size...  if there is one given.
20  * (if the size can be arbitrary, then we give whatever we have)
21  */
22
23 static int prepare_from_text(const OSSL_PARAM *paramdefs, const char *key,
24                              const char *value, size_t value_n,
25                              /* Output parameters */
26                              const OSSL_PARAM **paramdef, int *ishex,
27                              size_t *buf_n, BIGNUM **tmpbn)
28 {
29     const OSSL_PARAM *p;
30
31     /*
32      * ishex is used to translate legacy style string controls in hex format
33      * to octet string parameters.
34      */
35     *ishex = strncmp(key, "hex", 3) == 0;
36
37     if (*ishex)
38         key += 3;
39
40     p = *paramdef = OSSL_PARAM_locate_const(paramdefs, key);
41     if (p == NULL)
42         return 0;
43
44     switch (p->data_type) {
45     case OSSL_PARAM_INTEGER:
46     case OSSL_PARAM_UNSIGNED_INTEGER:
47         if (*ishex)
48             BN_hex2bn(tmpbn, value);
49         else
50             BN_dec2bn(tmpbn, value);
51
52         if (*tmpbn == NULL)
53             return 0;
54
55         /*
56          * 2s complement negate, part 1
57          *
58          * BN_bn2nativepad puts the absolute value of the number in the
59          * buffer, i.e. if it's negative, we need to deal with it.  We do
60          * it by subtracting 1 here and inverting the bytes in
61          * construct_from_text() below.
62          */
63         if (p->data_type == OSSL_PARAM_INTEGER && BN_is_negative(*tmpbn)
64             && !BN_sub_word(*tmpbn, 1)) {
65             return 0;
66         }
67
68         *buf_n = BN_num_bytes(*tmpbn);
69
70         /*
71          * TODO(v3.0) is this the right way to do this?  This code expects
72          * a zero data size to simply mean "arbitrary size".
73          */
74         if (p->data_size > 0) {
75             if (*buf_n >= p->data_size) {
76                 CRYPTOerr(0, CRYPTO_R_TOO_SMALL_BUFFER);
77                 /* Since this is a different error, we don't break */
78                 return 0;
79             }
80             /* Change actual size to become the desired size. */
81             *buf_n = p->data_size;
82         }
83         break;
84     case OSSL_PARAM_UTF8_STRING:
85         if (*ishex) {
86             CRYPTOerr(0, ERR_R_PASSED_INVALID_ARGUMENT);
87             return 0;
88         }
89         *buf_n = strlen(value) + 1;
90         break;
91     case OSSL_PARAM_OCTET_STRING:
92         if (*ishex) {
93             *buf_n = strlen(value) >> 1;
94         } else {
95             *buf_n = value_n;
96         }
97         break;
98     }
99
100     return 1;
101 }
102
103 static int construct_from_text(OSSL_PARAM *to, const OSSL_PARAM *paramdef,
104                                const char *value, size_t value_n, int ishex,
105                                void *buf, size_t buf_n, BIGNUM *tmpbn)
106 {
107     if (buf == NULL)
108         return 0;
109
110     if (buf_n > 0) {
111         switch (paramdef->data_type) {
112         case OSSL_PARAM_INTEGER:
113         case OSSL_PARAM_UNSIGNED_INTEGER:
114             /*
115             {
116                 if ((new_value = OPENSSL_malloc(new_value_n)) == NULL) {
117                     BN_free(a);
118                     break;
119                 }
120             */
121
122             BN_bn2nativepad(tmpbn, buf, buf_n);
123
124             /*
125              * 2s complement negate, part two.
126              *
127              * Because we did the first part on the BIGNUM itself, we can just
128              * invert all the bytes here and be done with it.
129              */
130             if (paramdef->data_type == OSSL_PARAM_INTEGER
131                 && BN_is_negative(tmpbn)) {
132                 unsigned char *cp;
133                 size_t i = buf_n;
134
135                 for (cp = buf; i-- > 0; cp++)
136                     *cp ^= 0xFF;
137             }
138             break;
139         case OSSL_PARAM_UTF8_STRING:
140             strncpy(buf, value, buf_n);
141             break;
142         case OSSL_PARAM_OCTET_STRING:
143             if (ishex) {
144                 size_t l = 0;
145
146                 if (!OPENSSL_hexstr2buf_ex(buf, buf_n, &l, value))
147                     return 0;
148             } else {
149                 memcpy(buf, value, buf_n);
150             }
151             break;
152         }
153     }
154
155     *to = *paramdef;
156     to->data = buf;
157     to->data_size = buf_n;
158     to->return_size = 0;
159
160     return 1;
161 }
162
163 int OSSL_PARAM_allocate_from_text(OSSL_PARAM *to,
164                                   const OSSL_PARAM *paramdefs,
165                                   const char *key, const char *value,
166                                   size_t value_n)
167 {
168     const OSSL_PARAM *paramdef = NULL;
169     int ishex = 0;
170     void *buf = NULL;
171     size_t buf_n = 0;
172     BIGNUM *tmpbn = NULL;
173     int ok = 0;
174
175     if (to == NULL || paramdefs == NULL)
176         return 0;
177
178     if (!prepare_from_text(paramdefs, key, value, value_n,
179                            &paramdef, &ishex, &buf_n, &tmpbn))
180         return 0;
181
182     if ((buf = OPENSSL_zalloc(buf_n > 0 ? buf_n : 1)) == NULL) {
183         CRYPTOerr(0, ERR_R_MALLOC_FAILURE);
184         return 0;
185     }
186
187     ok = construct_from_text(to, paramdef, value, value_n, ishex,
188                              buf, buf_n, tmpbn);
189     BN_free(tmpbn);
190     if (!ok)
191         OPENSSL_free(buf);
192     return ok;
193 }