/src/openssl/crypto/pem/pem_pk8.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 1995-2022 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 | | #include <stdio.h> |
11 | | #include "internal/cryptlib.h" |
12 | | #include <openssl/core_dispatch.h> |
13 | | #include <openssl/buffer.h> |
14 | | #include <openssl/objects.h> |
15 | | #include <openssl/evp.h> |
16 | | #include <openssl/x509.h> |
17 | | #include <openssl/pkcs12.h> |
18 | | #include <openssl/pem.h> |
19 | | #include <openssl/encoder.h> |
20 | | |
21 | | static int do_pk8pkey(BIO *bp, const EVP_PKEY *x, int isder, |
22 | | int nid, const EVP_CIPHER *enc, |
23 | | const char *kstr, int klen, |
24 | | pem_password_cb *cb, void *u, |
25 | | const char *propq); |
26 | | |
27 | | #ifndef OPENSSL_NO_STDIO |
28 | | static int do_pk8pkey_fp(FILE *bp, const EVP_PKEY *x, int isder, |
29 | | int nid, const EVP_CIPHER *enc, |
30 | | const char *kstr, int klen, |
31 | | pem_password_cb *cb, void *u, |
32 | | const char *propq); |
33 | | #endif |
34 | | /* |
35 | | * These functions write a private key in PKCS#8 format: it is a "drop in" |
36 | | * replacement for PEM_write_bio_PrivateKey() and friends. As usual if 'enc' |
37 | | * is NULL then it uses the unencrypted private key form. The 'nid' versions |
38 | | * uses PKCS#5 v1.5 PBE algorithms whereas the others use PKCS#5 v2.0. |
39 | | */ |
40 | | |
41 | | int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, const EVP_PKEY *x, int nid, |
42 | | const char *kstr, int klen, |
43 | | pem_password_cb *cb, void *u) |
44 | 0 | { |
45 | 0 | return do_pk8pkey(bp, x, 0, nid, NULL, kstr, klen, cb, u, NULL); |
46 | 0 | } |
47 | | |
48 | | int PEM_write_bio_PKCS8PrivateKey(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc, |
49 | | const char *kstr, int klen, |
50 | | pem_password_cb *cb, void *u) |
51 | 0 | { |
52 | 0 | return do_pk8pkey(bp, x, 0, -1, enc, kstr, klen, cb, u, NULL); |
53 | 0 | } |
54 | | |
55 | | int i2d_PKCS8PrivateKey_bio(BIO *bp, const EVP_PKEY *x, const EVP_CIPHER *enc, |
56 | | const char *kstr, int klen, |
57 | | pem_password_cb *cb, void *u) |
58 | 0 | { |
59 | 0 | return do_pk8pkey(bp, x, 1, -1, enc, kstr, klen, cb, u, NULL); |
60 | 0 | } |
61 | | |
62 | | int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, const EVP_PKEY *x, int nid, |
63 | | const char *kstr, int klen, |
64 | | pem_password_cb *cb, void *u) |
65 | 0 | { |
66 | 0 | return do_pk8pkey(bp, x, 1, nid, NULL, kstr, klen, cb, u, NULL); |
67 | 0 | } |
68 | | |
69 | | static int do_pk8pkey(BIO *bp, const EVP_PKEY *x, int isder, int nid, |
70 | | const EVP_CIPHER *enc, const char *kstr, int klen, |
71 | | pem_password_cb *cb, void *u, const char *propq) |
72 | 0 | { |
73 | 0 | int ret = 0; |
74 | 0 | const char *outtype = isder ? "DER" : "PEM"; |
75 | 0 | OSSL_ENCODER_CTX *ctx = |
76 | 0 | OSSL_ENCODER_CTX_new_for_pkey(x, OSSL_KEYMGMT_SELECT_ALL, |
77 | 0 | outtype, "PrivateKeyInfo", propq); |
78 | |
|
79 | 0 | if (ctx == NULL) |
80 | 0 | return 0; |
81 | | |
82 | | /* |
83 | | * If no keystring or callback is set, OpenSSL traditionally uses the |
84 | | * user's cb argument as a password string, or if that's NULL, it falls |
85 | | * back on PEM_def_callback(). |
86 | | */ |
87 | 0 | if (kstr == NULL && cb == NULL) { |
88 | 0 | if (u != NULL) { |
89 | 0 | kstr = u; |
90 | 0 | klen = strlen(u); |
91 | 0 | } else { |
92 | 0 | cb = PEM_def_callback; |
93 | 0 | } |
94 | 0 | } |
95 | | |
96 | | /* |
97 | | * NOTE: There is no attempt to do a EVP_CIPHER_fetch() using the nid, |
98 | | * since the nid is a PBE algorithm which can't be fetched currently. |
99 | | * (e.g. NID_pbe_WithSHA1And2_Key_TripleDES_CBC). Just use the legacy |
100 | | * path if the NID is passed. |
101 | | */ |
102 | 0 | if (nid == -1 && OSSL_ENCODER_CTX_get_num_encoders(ctx) != 0) { |
103 | 0 | ret = 1; |
104 | 0 | if (enc != NULL) { |
105 | 0 | ret = 0; |
106 | 0 | if (OSSL_ENCODER_CTX_set_cipher(ctx, EVP_CIPHER_get0_name(enc), |
107 | 0 | NULL)) { |
108 | 0 | const unsigned char *ukstr = (const unsigned char *)kstr; |
109 | | |
110 | | /* |
111 | | * Try to pass the passphrase if one was given, or the |
112 | | * passphrase callback if one was given. If none of them |
113 | | * are given and that's wrong, we rely on the _to_bio() |
114 | | * call to generate errors. |
115 | | */ |
116 | 0 | ret = 1; |
117 | 0 | if (kstr != NULL |
118 | 0 | && !OSSL_ENCODER_CTX_set_passphrase(ctx, ukstr, klen)) |
119 | 0 | ret = 0; |
120 | 0 | else if (cb != NULL |
121 | 0 | && !OSSL_ENCODER_CTX_set_pem_password_cb(ctx, cb, u)) |
122 | 0 | ret = 0; |
123 | 0 | } |
124 | 0 | } |
125 | 0 | ret = ret && OSSL_ENCODER_to_bio(ctx, bp); |
126 | 0 | } else { |
127 | 0 | X509_SIG *p8; |
128 | 0 | PKCS8_PRIV_KEY_INFO *p8inf; |
129 | 0 | char buf[PEM_BUFSIZE]; |
130 | |
|
131 | 0 | ret = 0; |
132 | 0 | if ((p8inf = EVP_PKEY2PKCS8(x)) == NULL) { |
133 | 0 | ERR_raise(ERR_LIB_PEM, PEM_R_ERROR_CONVERTING_PRIVATE_KEY); |
134 | 0 | goto legacy_end; |
135 | 0 | } |
136 | 0 | if (enc || (nid != -1)) { |
137 | 0 | if (kstr == NULL) { |
138 | 0 | klen = cb(buf, PEM_BUFSIZE, 1, u); |
139 | 0 | if (klen < 0) { |
140 | 0 | ERR_raise(ERR_LIB_PEM, PEM_R_READ_KEY); |
141 | 0 | goto legacy_end; |
142 | 0 | } |
143 | | |
144 | 0 | kstr = buf; |
145 | 0 | } |
146 | 0 | p8 = PKCS8_encrypt(nid, enc, kstr, klen, NULL, 0, 0, p8inf); |
147 | 0 | if (kstr == buf) |
148 | 0 | OPENSSL_cleanse(buf, klen); |
149 | 0 | if (p8 == NULL) |
150 | 0 | goto legacy_end; |
151 | 0 | if (isder) |
152 | 0 | ret = i2d_PKCS8_bio(bp, p8); |
153 | 0 | else |
154 | 0 | ret = PEM_write_bio_PKCS8(bp, p8); |
155 | 0 | X509_SIG_free(p8); |
156 | 0 | } else { |
157 | 0 | if (isder) |
158 | 0 | ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf); |
159 | 0 | else |
160 | 0 | ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(bp, p8inf); |
161 | 0 | } |
162 | 0 | legacy_end: |
163 | 0 | PKCS8_PRIV_KEY_INFO_free(p8inf); |
164 | 0 | } |
165 | 0 | OSSL_ENCODER_CTX_free(ctx); |
166 | 0 | return ret; |
167 | 0 | } |
168 | | |
169 | | EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, |
170 | | void *u) |
171 | 0 | { |
172 | 0 | PKCS8_PRIV_KEY_INFO *p8inf = NULL; |
173 | 0 | X509_SIG *p8 = NULL; |
174 | 0 | int klen; |
175 | 0 | EVP_PKEY *ret; |
176 | 0 | char psbuf[PEM_BUFSIZE + 1]; /* reserve one byte at the end */ |
177 | |
|
178 | 0 | p8 = d2i_PKCS8_bio(bp, NULL); |
179 | 0 | if (p8 == NULL) |
180 | 0 | return NULL; |
181 | 0 | if (cb != NULL) |
182 | 0 | klen = cb(psbuf, PEM_BUFSIZE, 0, u); |
183 | 0 | else |
184 | 0 | klen = PEM_def_callback(psbuf, PEM_BUFSIZE, 0, u); |
185 | 0 | if (klen < 0 || klen > PEM_BUFSIZE) { |
186 | 0 | ERR_raise(ERR_LIB_PEM, PEM_R_BAD_PASSWORD_READ); |
187 | 0 | X509_SIG_free(p8); |
188 | 0 | return NULL; |
189 | 0 | } |
190 | 0 | p8inf = PKCS8_decrypt(p8, psbuf, klen); |
191 | 0 | X509_SIG_free(p8); |
192 | 0 | OPENSSL_cleanse(psbuf, klen); |
193 | 0 | if (p8inf == NULL) |
194 | 0 | return NULL; |
195 | 0 | ret = EVP_PKCS82PKEY(p8inf); |
196 | 0 | PKCS8_PRIV_KEY_INFO_free(p8inf); |
197 | 0 | if (!ret) |
198 | 0 | return NULL; |
199 | 0 | if (x != NULL) { |
200 | 0 | EVP_PKEY_free(*x); |
201 | 0 | *x = ret; |
202 | 0 | } |
203 | 0 | return ret; |
204 | 0 | } |
205 | | |
206 | | #ifndef OPENSSL_NO_STDIO |
207 | | |
208 | | int i2d_PKCS8PrivateKey_fp(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc, |
209 | | const char *kstr, int klen, |
210 | | pem_password_cb *cb, void *u) |
211 | 0 | { |
212 | 0 | return do_pk8pkey_fp(fp, x, 1, -1, enc, kstr, klen, cb, u, NULL); |
213 | 0 | } |
214 | | |
215 | | int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, const EVP_PKEY *x, int nid, |
216 | | const char *kstr, int klen, |
217 | | pem_password_cb *cb, void *u) |
218 | 0 | { |
219 | 0 | return do_pk8pkey_fp(fp, x, 1, nid, NULL, kstr, klen, cb, u, NULL); |
220 | 0 | } |
221 | | |
222 | | int PEM_write_PKCS8PrivateKey_nid(FILE *fp, const EVP_PKEY *x, int nid, |
223 | | const char *kstr, int klen, |
224 | | pem_password_cb *cb, void *u) |
225 | 0 | { |
226 | 0 | return do_pk8pkey_fp(fp, x, 0, nid, NULL, kstr, klen, cb, u, NULL); |
227 | 0 | } |
228 | | |
229 | | int PEM_write_PKCS8PrivateKey(FILE *fp, const EVP_PKEY *x, const EVP_CIPHER *enc, |
230 | | const char *kstr, int klen, |
231 | | pem_password_cb *cb, void *u) |
232 | 0 | { |
233 | 0 | return do_pk8pkey_fp(fp, x, 0, -1, enc, kstr, klen, cb, u, NULL); |
234 | 0 | } |
235 | | |
236 | | static int do_pk8pkey_fp(FILE *fp, const EVP_PKEY *x, int isder, int nid, |
237 | | const EVP_CIPHER *enc, const char *kstr, int klen, |
238 | | pem_password_cb *cb, void *u, const char *propq) |
239 | 0 | { |
240 | 0 | BIO *bp; |
241 | 0 | int ret; |
242 | |
|
243 | 0 | if ((bp = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) { |
244 | 0 | ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB); |
245 | 0 | return 0; |
246 | 0 | } |
247 | 0 | ret = do_pk8pkey(bp, x, isder, nid, enc, kstr, klen, cb, u, propq); |
248 | 0 | BIO_free(bp); |
249 | 0 | return ret; |
250 | 0 | } |
251 | | |
252 | | EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, |
253 | | void *u) |
254 | 0 | { |
255 | 0 | BIO *bp; |
256 | 0 | EVP_PKEY *ret; |
257 | |
|
258 | 0 | if ((bp = BIO_new_fp(fp, BIO_NOCLOSE)) == NULL) { |
259 | 0 | ERR_raise(ERR_LIB_PEM, ERR_R_BUF_LIB); |
260 | 0 | return NULL; |
261 | 0 | } |
262 | 0 | ret = d2i_PKCS8PrivateKey_bio(bp, x, cb, u); |
263 | 0 | BIO_free(bp); |
264 | 0 | return ret; |
265 | 0 | } |
266 | | |
267 | | #endif |
268 | | |
269 | | IMPLEMENT_PEM_rw(PKCS8, X509_SIG, PEM_STRING_PKCS8, X509_SIG) |
270 | | |
271 | | |
272 | | IMPLEMENT_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF, |
273 | | PKCS8_PRIV_KEY_INFO) |