make EVP_PKEY opaque
[openssl.git] / crypto / pem / pem_pkey.c
1 /* crypto/pem/pem_pkey.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include "internal/cryptlib.h"
61 #include <openssl/buffer.h>
62 #include <openssl/objects.h>
63 #include <openssl/evp.h>
64 #include <openssl/rand.h>
65 #include <openssl/x509.h>
66 #include <openssl/pkcs12.h>
67 #include <openssl/pem.h>
68 #ifndef OPENSSL_NO_ENGINE
69 # include <openssl/engine.h>
70 #endif
71 #ifndef OPENSSL_NO_DH
72 # include <openssl/dh.h>
73 #endif
74 #include "internal/asn1_int.h"
75 #include "internal/evp_int.h"
76
77 int pem_check_suffix(const char *pem_str, const char *suffix);
78
79 EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb,
80                                   void *u)
81 {
82     char *nm = NULL;
83     const unsigned char *p = NULL;
84     unsigned char *data = NULL;
85     long len;
86     int slen;
87     EVP_PKEY *ret = NULL;
88
89     if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))
90         return NULL;
91     p = data;
92
93     if (strcmp(nm, PEM_STRING_PKCS8INF) == 0) {
94         PKCS8_PRIV_KEY_INFO *p8inf;
95         p8inf = d2i_PKCS8_PRIV_KEY_INFO(NULL, &p, len);
96         if (!p8inf)
97             goto p8err;
98         ret = EVP_PKCS82PKEY(p8inf);
99         if (x) {
100             EVP_PKEY_free((EVP_PKEY *)*x);
101             *x = ret;
102         }
103         PKCS8_PRIV_KEY_INFO_free(p8inf);
104     } else if (strcmp(nm, PEM_STRING_PKCS8) == 0) {
105         PKCS8_PRIV_KEY_INFO *p8inf;
106         X509_SIG *p8;
107         int klen;
108         char psbuf[PEM_BUFSIZE];
109         p8 = d2i_X509_SIG(NULL, &p, len);
110         if (!p8)
111             goto p8err;
112         if (cb)
113             klen = cb(psbuf, PEM_BUFSIZE, 0, u);
114         else
115             klen = PEM_def_callback(psbuf, PEM_BUFSIZE, 0, u);
116         if (klen <= 0) {
117             PEMerr(PEM_F_PEM_READ_BIO_PRIVATEKEY, PEM_R_BAD_PASSWORD_READ);
118             X509_SIG_free(p8);
119             goto err;
120         }
121         p8inf = PKCS8_decrypt(p8, psbuf, klen);
122         X509_SIG_free(p8);
123         if (!p8inf)
124             goto p8err;
125         ret = EVP_PKCS82PKEY(p8inf);
126         if (x) {
127             EVP_PKEY_free((EVP_PKEY *)*x);
128             *x = ret;
129         }
130         PKCS8_PRIV_KEY_INFO_free(p8inf);
131     } else if ((slen = pem_check_suffix(nm, "PRIVATE KEY")) > 0) {
132         const EVP_PKEY_ASN1_METHOD *ameth;
133         ameth = EVP_PKEY_asn1_find_str(NULL, nm, slen);
134         if (!ameth || !ameth->old_priv_decode)
135             goto p8err;
136         ret = d2i_PrivateKey(ameth->pkey_id, x, &p, len);
137     }
138  p8err:
139     if (ret == NULL)
140         PEMerr(PEM_F_PEM_READ_BIO_PRIVATEKEY, ERR_R_ASN1_LIB);
141  err:
142     OPENSSL_free(nm);
143     OPENSSL_clear_free(data, len);
144     return (ret);
145 }
146
147 int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
148                              unsigned char *kstr, int klen,
149                              pem_password_cb *cb, void *u)
150 {
151     char pem_str[80];
152     if (!x->ameth || x->ameth->priv_encode)
153         return PEM_write_bio_PKCS8PrivateKey(bp, x, enc,
154                                              (char *)kstr, klen, cb, u);
155
156     BIO_snprintf(pem_str, 80, "%s PRIVATE KEY", x->ameth->pem_str);
157     return PEM_ASN1_write_bio((i2d_of_void *)i2d_PrivateKey,
158                               pem_str, bp, x, enc, kstr, klen, cb, u);
159 }
160
161 EVP_PKEY *PEM_read_bio_Parameters(BIO *bp, EVP_PKEY **x)
162 {
163     char *nm = NULL;
164     const unsigned char *p = NULL;
165     unsigned char *data = NULL;
166     long len;
167     int slen;
168     EVP_PKEY *ret = NULL;
169
170     if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_PARAMETERS,
171                             bp, 0, NULL))
172         return NULL;
173     p = data;
174
175     if ((slen = pem_check_suffix(nm, "PARAMETERS")) > 0) {
176         ret = EVP_PKEY_new();
177         if (ret == NULL)
178             goto err;
179         if (!EVP_PKEY_set_type_str(ret, nm, slen)
180             || !ret->ameth->param_decode
181             || !ret->ameth->param_decode(ret, &p, len)) {
182             EVP_PKEY_free(ret);
183             ret = NULL;
184             goto err;
185         }
186         if (x) {
187             EVP_PKEY_free((EVP_PKEY *)*x);
188             *x = ret;
189         }
190     }
191  err:
192     if (ret == NULL)
193         PEMerr(PEM_F_PEM_READ_BIO_PARAMETERS, ERR_R_ASN1_LIB);
194     OPENSSL_free(nm);
195     OPENSSL_free(data);
196     return (ret);
197 }
198
199 int PEM_write_bio_Parameters(BIO *bp, EVP_PKEY *x)
200 {
201     char pem_str[80];
202     if (!x->ameth || !x->ameth->param_encode)
203         return 0;
204
205     BIO_snprintf(pem_str, 80, "%s PARAMETERS", x->ameth->pem_str);
206     return PEM_ASN1_write_bio((i2d_of_void *)x->ameth->param_encode,
207                               pem_str, bp, x, NULL, NULL, 0, 0, NULL);
208 }
209
210 #ifndef OPENSSL_NO_STDIO
211 EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, pem_password_cb *cb,
212                               void *u)
213 {
214     BIO *b;
215     EVP_PKEY *ret;
216
217     if ((b = BIO_new(BIO_s_file())) == NULL) {
218         PEMerr(PEM_F_PEM_READ_PRIVATEKEY, ERR_R_BUF_LIB);
219         return (0);
220     }
221     BIO_set_fp(b, fp, BIO_NOCLOSE);
222     ret = PEM_read_bio_PrivateKey(b, x, cb, u);
223     BIO_free(b);
224     return (ret);
225 }
226
227 int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
228                          unsigned char *kstr, int klen,
229                          pem_password_cb *cb, void *u)
230 {
231     BIO *b;
232     int ret;
233
234     if ((b = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) {
235         PEMerr(PEM_F_PEM_WRITE_PRIVATEKEY, ERR_R_BUF_LIB);
236         return 0;
237     }
238     ret = PEM_write_bio_PrivateKey(b, x, enc, kstr, klen, cb, u);
239     BIO_free(b);
240     return ret;
241 }
242
243 #endif
244
245 #ifndef OPENSSL_NO_DH
246
247 /* Transparently read in PKCS#3 or X9.42 DH parameters */
248
249 DH *PEM_read_bio_DHparams(BIO *bp, DH **x, pem_password_cb *cb, void *u)
250 {
251     char *nm = NULL;
252     const unsigned char *p = NULL;
253     unsigned char *data = NULL;
254     long len;
255     DH *ret = NULL;
256
257     if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_DHPARAMS, bp, cb, u))
258         return NULL;
259     p = data;
260
261     if (strcmp(nm, PEM_STRING_DHXPARAMS) == 0)
262         ret = d2i_DHxparams(x, &p, len);
263     else
264         ret = d2i_DHparams(x, &p, len);
265
266     if (ret == NULL)
267         PEMerr(PEM_F_PEM_READ_BIO_DHPARAMS, ERR_R_ASN1_LIB);
268     OPENSSL_free(nm);
269     OPENSSL_free(data);
270     return ret;
271 }
272
273 # ifndef OPENSSL_NO_STDIO
274 DH *PEM_read_DHparams(FILE *fp, DH **x, pem_password_cb *cb, void *u)
275 {
276     BIO *b;
277     DH *ret;
278
279     if ((b = BIO_new(BIO_s_file())) == NULL) {
280         PEMerr(PEM_F_PEM_READ_DHPARAMS, ERR_R_BUF_LIB);
281         return (0);
282     }
283     BIO_set_fp(b, fp, BIO_NOCLOSE);
284     ret = PEM_read_bio_DHparams(b, x, cb, u);
285     BIO_free(b);
286     return (ret);
287 }
288 # endif
289
290 #endif