PROV & SERIALIZER: Adapt the RSA serializers for PSS-parameters
[openssl.git] / providers / implementations / serializers / serializer_rsa_priv.c
1 /*
2  * Copyright 2019-2020 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  * RSA 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/core_numbers.h>
17 #include <openssl/core_names.h>
18 #include <openssl/err.h>
19 #include <openssl/pem.h>
20 #include <openssl/rsa.h>
21 #include <openssl/types.h>
22 #include <openssl/params.h>
23 #include <openssl/safestack.h>
24 #include "crypto/rsa.h"
25 #include "prov/bio.h"
26 #include "prov/implementations.h"
27 #include "prov/providercommonerr.h"
28 #include "serializer_local.h"
29
30 static OSSL_OP_serializer_newctx_fn rsa_priv_newctx;
31 static OSSL_OP_serializer_freectx_fn rsa_priv_freectx;
32 static OSSL_OP_serializer_set_ctx_params_fn rsa_priv_set_ctx_params;
33 static OSSL_OP_serializer_settable_ctx_params_fn rsa_priv_settable_ctx_params;
34 static OSSL_OP_serializer_serialize_data_fn rsa_priv_der_data;
35 static OSSL_OP_serializer_serialize_object_fn rsa_priv_der;
36 static OSSL_OP_serializer_serialize_data_fn rsa_pem_priv_data;
37 static OSSL_OP_serializer_serialize_object_fn rsa_pem_priv;
38
39 static OSSL_OP_serializer_newctx_fn rsa_print_newctx;
40 static OSSL_OP_serializer_freectx_fn rsa_print_freectx;
41 static OSSL_OP_serializer_serialize_data_fn rsa_priv_print_data;
42 static OSSL_OP_serializer_serialize_object_fn rsa_priv_print;
43
44  /*
45  * Context used for private key serialization.
46  */
47 struct rsa_priv_ctx_st {
48     void *provctx;
49
50     struct pkcs8_encrypt_ctx_st sc;
51 };
52
53 /* Private key : context */
54 static void *rsa_priv_newctx(void *provctx)
55 {
56     struct rsa_priv_ctx_st *ctx = OPENSSL_zalloc(sizeof(*ctx));
57
58     if (ctx != NULL) {
59         ctx->provctx = provctx;
60         /* -1 is the "whatever" indicator, i.e. the PKCS8 library default PBE */
61         ctx->sc.pbe_nid = -1;
62     }
63     return ctx;
64 }
65
66 static void rsa_priv_freectx(void *vctx)
67 {
68     struct rsa_priv_ctx_st *ctx = vctx;
69
70     EVP_CIPHER_free(ctx->sc.cipher);
71     OPENSSL_free(ctx->sc.cipher_pass);
72     OPENSSL_free(ctx);
73 }
74
75 static const OSSL_PARAM *rsa_priv_settable_ctx_params(void)
76 {
77     static const OSSL_PARAM settables[] = {
78         OSSL_PARAM_utf8_string(OSSL_SERIALIZER_PARAM_CIPHER, NULL, 0),
79         OSSL_PARAM_octet_string(OSSL_SERIALIZER_PARAM_PASS, NULL, 0),
80         OSSL_PARAM_END,
81     };
82
83     return settables;
84 }
85
86 static int rsa_priv_set_ctx_params(void *vctx, const OSSL_PARAM params[])
87 {
88     struct rsa_priv_ctx_st *ctx = vctx;
89     const OSSL_PARAM *p;
90
91     if ((p = OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_CIPHER))
92         != NULL) {
93         const OSSL_PARAM *propsp =
94             OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_PROPERTIES);
95         const char *props = NULL;
96
97         if (p->data_type != OSSL_PARAM_UTF8_STRING)
98             return 0;
99         if (propsp != NULL && propsp->data_type != OSSL_PARAM_UTF8_STRING)
100             return 0;
101         props = (propsp != NULL ? propsp->data : NULL);
102
103         EVP_CIPHER_free(ctx->sc.cipher);
104         ctx->sc.cipher_intent = p->data != NULL;
105         if (p->data != NULL
106             && ((ctx->sc.cipher = EVP_CIPHER_fetch(NULL, p->data, props))
107                 == NULL))
108             return 0;
109     }
110     if ((p = OSSL_PARAM_locate_const(params, OSSL_SERIALIZER_PARAM_PASS))
111         != NULL) {
112         OPENSSL_free(ctx->sc.cipher_pass);
113         ctx->sc.cipher_pass = NULL;
114         if (!OSSL_PARAM_get_octet_string(p, &ctx->sc.cipher_pass, 0,
115                                          &ctx->sc.cipher_pass_length))
116             return 0;
117     }
118     return 1;
119 }
120
121 /* Private key : DER */
122 static int rsa_priv_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
123                              OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
124 {
125     struct rsa_priv_ctx_st *ctx = vctx;
126     OSSL_OP_keymgmt_new_fn *rsa_new = ossl_prov_get_keymgmt_rsa_new();
127     OSSL_OP_keymgmt_free_fn *rsa_free = ossl_prov_get_keymgmt_rsa_free();
128     OSSL_OP_keymgmt_import_fn *rsa_import = ossl_prov_get_keymgmt_rsa_import();
129     int ok = 0;
130
131     if (rsa_import != NULL) {
132         RSA *rsa;
133
134         if ((rsa = rsa_new(ctx->provctx)) != NULL
135             && rsa_import(rsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
136             && rsa_priv_der(ctx, rsa, out, cb, cbarg))
137             ok = 1;
138         rsa_free(rsa);
139     }
140     return ok;
141 }
142
143 static int rsa_priv_der(void *vctx, void *rsa, BIO *out,
144                         OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
145 {
146     struct rsa_priv_ctx_st *ctx = vctx;
147     int ret;
148
149     ctx->sc.cb = cb;
150     ctx->sc.cbarg = cbarg;
151
152     ret = ossl_prov_write_priv_der_from_obj(out, rsa,
153                                             ossl_prov_rsa_type_to_evp(rsa),
154                                             ossl_prov_prepare_rsa_params,
155                                             (i2d_of_void *)i2d_RSAPrivateKey,
156                                             &ctx->sc);
157
158     return ret;
159 }
160
161 /* Private key : PEM */
162 static int rsa_pem_priv_data(void *vctx, const OSSL_PARAM params[], BIO *out,
163                              OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
164 {
165     struct rsa_priv_ctx_st *ctx = vctx;
166     OSSL_OP_keymgmt_new_fn *rsa_new = ossl_prov_get_keymgmt_rsa_new();
167     OSSL_OP_keymgmt_free_fn *rsa_free = ossl_prov_get_keymgmt_rsa_free();
168     OSSL_OP_keymgmt_import_fn *rsa_import = ossl_prov_get_keymgmt_rsa_import();
169     int ok = 0;
170
171     if (rsa_import != NULL) {
172         RSA *rsa;
173
174         if ((rsa = rsa_new(ctx->provctx)) != NULL
175             && rsa_import(rsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
176             && rsa_pem_priv(ctx, rsa, out, cb, cbarg))
177             ok = 1;
178         rsa_free(rsa);
179     }
180     return ok;
181 }
182
183 static int rsa_pem_priv(void *vctx, void *rsa, BIO *out,
184                         OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
185 {
186     struct rsa_priv_ctx_st *ctx = vctx;
187     int ret;
188
189     ctx->sc.cb = cb;
190     ctx->sc.cbarg = cbarg;
191
192     ret = ossl_prov_write_priv_pem_from_obj(out, rsa,
193                                             ossl_prov_rsa_type_to_evp(rsa),
194                                             ossl_prov_prepare_rsa_params,
195                                             (i2d_of_void *)i2d_RSAPrivateKey,
196                                             &ctx->sc);
197
198     return ret;
199 }
200
201 /*
202  * There's no specific print context, so we use the provider context
203  */
204 static void *rsa_print_newctx(void *provctx)
205 {
206     return provctx;
207 }
208
209 static void rsa_print_freectx(void *ctx)
210 {
211 }
212
213 static int rsa_priv_print_data(void *vctx, const OSSL_PARAM params[],
214                                BIO *out,
215                                OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
216 {
217     struct rsa_priv_ctx_st *ctx = vctx;
218     OSSL_OP_keymgmt_new_fn *rsa_new = ossl_prov_get_keymgmt_rsa_new();
219     OSSL_OP_keymgmt_free_fn *rsa_free = ossl_prov_get_keymgmt_rsa_free();
220     OSSL_OP_keymgmt_import_fn *rsa_import = ossl_prov_get_keymgmt_rsa_import();
221     int ok = 0;
222
223     if (rsa_import != NULL) {
224         RSA *rsa;
225
226         if ((rsa = rsa_new(ctx->provctx)) != NULL
227             && rsa_import(rsa, OSSL_KEYMGMT_SELECT_KEYPAIR, params)
228             && rsa_priv_print(ctx, rsa, out, cb, cbarg))
229             ok = 1;
230         rsa_free(rsa);
231     }
232     return ok;
233 }
234
235 static int rsa_priv_print(void *ctx, void *rsa, BIO *out,
236                           OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
237 {
238     return ossl_prov_print_rsa(out, rsa, 1);
239 }
240
241 const OSSL_DISPATCH rsa_priv_der_serializer_functions[] = {
242     { OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))rsa_priv_newctx },
243     { OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))rsa_priv_freectx },
244     { OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS,
245       (void (*)(void))rsa_priv_set_ctx_params },
246     { OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS,
247       (void (*)(void))rsa_priv_settable_ctx_params },
248     { OSSL_FUNC_SERIALIZER_SERIALIZE_DATA, (void (*)(void))rsa_priv_der_data },
249     { OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))rsa_priv_der },
250     { 0, NULL }
251 };
252
253 const OSSL_DISPATCH rsa_priv_pem_serializer_functions[] = {
254     { OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))rsa_priv_newctx },
255     { OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))rsa_priv_freectx },
256     { OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS,
257       (void (*)(void))rsa_priv_set_ctx_params },
258     { OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS,
259       (void (*)(void))rsa_priv_settable_ctx_params },
260     { OSSL_FUNC_SERIALIZER_SERIALIZE_DATA, (void (*)(void))rsa_pem_priv_data },
261     { OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))rsa_pem_priv },
262     { 0, NULL }
263 };
264
265 const OSSL_DISPATCH rsa_priv_text_serializer_functions[] = {
266     { OSSL_FUNC_SERIALIZER_NEWCTX, (void (*)(void))rsa_print_newctx },
267     { OSSL_FUNC_SERIALIZER_FREECTX, (void (*)(void))rsa_print_freectx },
268     { OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT, (void (*)(void))rsa_priv_print },
269     { OSSL_FUNC_SERIALIZER_SERIALIZE_DATA,
270       (void (*)(void))rsa_priv_print_data },
271     { 0, NULL }
272 };