sm3: fix function names after the big ossl_ prefix addition.
[openssl.git] / crypto / dh / dh_backend.c
1 /*
2  * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * DH low level APIs are deprecated for public use, but still ok for
12  * internal use.
13  */
14 #include "internal/deprecated.h"
15
16 #include <openssl/err.h>
17 #include <openssl/core_names.h>
18 #include "internal/param_build_set.h"
19 #include "crypto/dh.h"
20 #include "dh_local.h"
21
22 /*
23  * The intention with the "backend" source file is to offer backend functions
24  * for legacy backends (EVP_PKEY_ASN1_METHOD and EVP_PKEY_METHOD) and provider
25  * implementations alike.
26  */
27
28 static int dh_ffc_params_fromdata(DH *dh, const OSSL_PARAM params[])
29 {
30     int ret;
31     FFC_PARAMS *ffc;
32
33     if (dh == NULL)
34         return 0;
35     ffc = ossl_dh_get0_params(dh);
36     if (ffc == NULL)
37         return 0;
38
39     ret = ossl_ffc_params_fromdata(ffc, params);
40     if (ret)
41         ossl_dh_cache_named_group(dh); /* This increments dh->dirty_cnt */
42     return ret;
43 }
44
45 int ossl_dh_params_fromdata(DH *dh, const OSSL_PARAM params[])
46 {
47     const OSSL_PARAM *param_priv_len;
48     long priv_len;
49
50     if (!dh_ffc_params_fromdata(dh, params))
51         return 0;
52
53     param_priv_len =
54         OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_DH_PRIV_LEN);
55     if (param_priv_len != NULL
56         && (!OSSL_PARAM_get_long(param_priv_len, &priv_len)
57             || !DH_set_length(dh, priv_len)))
58         return 0;
59
60     return 1;
61 }
62
63 int ossl_dh_key_fromdata(DH *dh, const OSSL_PARAM params[])
64 {
65     const OSSL_PARAM *param_priv_key, *param_pub_key;
66     BIGNUM *priv_key = NULL, *pub_key = NULL;
67
68     if (dh == NULL)
69         return 0;
70
71     param_priv_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
72     param_pub_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
73
74     if ((param_priv_key != NULL
75          && !OSSL_PARAM_get_BN(param_priv_key, &priv_key))
76         || (param_pub_key != NULL
77             && !OSSL_PARAM_get_BN(param_pub_key, &pub_key)))
78         goto err;
79
80     if (!DH_set0_key(dh, pub_key, priv_key))
81         goto err;
82
83     return 1;
84
85  err:
86     BN_clear_free(priv_key);
87     BN_free(pub_key);
88     return 0;
89 }
90
91 int ossl_dh_params_todata(DH *dh, OSSL_PARAM_BLD *bld, OSSL_PARAM params[])
92 {
93     long l = DH_get_length(dh);
94
95     if (!ossl_ffc_params_todata(ossl_dh_get0_params(dh), bld, params))
96         return 0;
97     if (l > 0
98         && !ossl_param_build_set_long(bld, params, OSSL_PKEY_PARAM_DH_PRIV_LEN, l))
99         return 0;
100     return 1;
101 }
102
103 int ossl_dh_key_todata(DH *dh, OSSL_PARAM_BLD *bld, OSSL_PARAM params[])
104 {
105     const BIGNUM *priv = NULL, *pub = NULL;
106
107     if (dh == NULL)
108         return 0;
109
110     DH_get0_key(dh, &pub, &priv);
111     if (priv != NULL
112         && !ossl_param_build_set_bn(bld, params, OSSL_PKEY_PARAM_PRIV_KEY, priv))
113         return 0;
114     if (pub != NULL
115         && !ossl_param_build_set_bn(bld, params, OSSL_PKEY_PARAM_PUB_KEY, pub))
116         return 0;
117
118     return 1;
119 }
120
121 int ossl_dh_is_foreign(const DH *dh)
122 {
123 #ifndef FIPS_MODULE
124     if (dh->engine != NULL || ossl_dh_get_method(dh) != DH_OpenSSL())
125         return 1;
126 #endif
127     return 0;
128 }
129
130 static ossl_inline int dh_bn_dup_check(BIGNUM **out, const BIGNUM *f)
131 {
132     if (f != NULL && (*out = BN_dup(f)) == NULL)
133         return 0;
134     return 1;
135 }
136
137 DH *ossl_dh_dup(const DH *dh, int selection)
138 {
139     DH *dupkey = NULL;
140
141     /* Do not try to duplicate foreign DH keys */
142     if (ossl_dh_is_foreign(dh))
143         return NULL;
144
145     if ((dupkey = ossl_dh_new_ex(dh->libctx)) == NULL)
146         return NULL;
147
148     dupkey->length = DH_get_length(dh);
149     if ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0
150         && !ossl_ffc_params_copy(&dupkey->params, &dh->params))
151         goto err;
152
153     dupkey->flags = dh->flags;
154
155     if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0
156         && ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) == 0
157             || !dh_bn_dup_check(&dupkey->pub_key, dh->pub_key)))
158         goto err;
159
160     if ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0
161         && ((selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) == 0
162             || !dh_bn_dup_check(&dupkey->priv_key, dh->priv_key)))
163         goto err;
164
165 #ifndef FIPS_MODULE
166     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_DH,
167                             &dupkey->ex_data, &dh->ex_data))
168         goto err;
169 #endif
170
171     return dupkey;
172
173  err:
174     DH_free(dupkey);
175     return NULL;
176 }
177
178 #ifndef FIPS_MODULE
179 DH *ossl_dh_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO *p8inf,
180                            OSSL_LIB_CTX *libctx, const char *propq)
181 {
182     const unsigned char *p, *pm;
183     int pklen, pmlen;
184     int ptype;
185     const void *pval;
186     const ASN1_STRING *pstr;
187     const X509_ALGOR *palg;
188     BIGNUM *privkey_bn = NULL;
189     ASN1_INTEGER *privkey = NULL;
190     DH *dh = NULL;
191
192     if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8inf))
193         return 0;
194
195     X509_ALGOR_get0(NULL, &ptype, &pval, palg);
196
197     if (ptype != V_ASN1_SEQUENCE)
198         goto decerr;
199     if ((privkey = d2i_ASN1_INTEGER(NULL, &p, pklen)) == NULL)
200         goto decerr;
201
202     pstr = pval;
203     pm = pstr->data;
204     pmlen = pstr->length;
205     switch (OBJ_obj2nid(palg->algorithm)) {
206     case NID_dhKeyAgreement:
207         dh = d2i_DHparams(NULL, &pm, pmlen);
208         break;
209     case NID_dhpublicnumber:
210         dh = d2i_DHxparams(NULL, &pm, pmlen);
211         break;
212     default:
213         goto decerr;
214     }
215     if (dh == NULL)
216         goto decerr;
217
218     /* We have parameters now set private key */
219     if ((privkey_bn = BN_secure_new()) == NULL
220         || !ASN1_INTEGER_to_BN(privkey, privkey_bn)) {
221         ERR_raise(ERR_LIB_DH, DH_R_BN_ERROR);
222         BN_clear_free(privkey_bn);
223         goto dherr;
224     }
225     if (!DH_set0_key(dh, NULL, privkey_bn))
226         goto dherr;
227     /* Calculate public key, increments dirty_cnt */
228     if (!DH_generate_key(dh))
229         goto dherr;
230
231     goto done;
232
233  decerr:
234     ERR_raise(ERR_LIB_DH, EVP_R_DECODE_ERROR);
235  dherr:
236     DH_free(dh);
237     dh = NULL;
238  done:
239     ASN1_STRING_clear_free(privkey);
240     return dh;
241 }
242 #endif