File: | src/lib/libcrypto/pem/pem_lib.c |
Warning: | line 570, column 13 The left expression of the compound assignment is an uninitialized value. The computed value will also be garbage |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: pem_lib.c,v 1.50 2021/12/12 21:30:14 tb Exp $ */ | |||
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 <ctype.h> | |||
60 | #include <stdio.h> | |||
61 | #include <stdlib.h> | |||
62 | #include <string.h> | |||
63 | ||||
64 | #include <openssl/opensslconf.h> | |||
65 | ||||
66 | #include <openssl/buffer.h> | |||
67 | #include <openssl/err.h> | |||
68 | #include <openssl/evp.h> | |||
69 | #include <openssl/objects.h> | |||
70 | #include <openssl/pem.h> | |||
71 | #include <openssl/pkcs12.h> | |||
72 | #include <openssl/x509.h> | |||
73 | ||||
74 | #ifndef OPENSSL_NO_DES | |||
75 | #include <openssl/des.h> | |||
76 | #endif | |||
77 | #ifndef OPENSSL_NO_ENGINE | |||
78 | #include <openssl/engine.h> | |||
79 | #endif | |||
80 | ||||
81 | #include "asn1_locl.h" | |||
82 | #include "evp_locl.h" | |||
83 | ||||
84 | #define MIN_LENGTH4 4 | |||
85 | ||||
86 | static int load_iv(char **fromp, unsigned char *to, int num); | |||
87 | static int check_pem(const char *nm, const char *name); | |||
88 | int pem_check_suffix(const char *pem_str, const char *suffix); | |||
89 | ||||
90 | /* XXX LSSL ABI XXX return value and `num' ought to be size_t */ | |||
91 | int | |||
92 | PEM_def_callback(char *buf, int num, int w, void *key) | |||
93 | { | |||
94 | size_t l; | |||
95 | int i; | |||
96 | const char *prompt; | |||
97 | ||||
98 | if (num < 0) | |||
99 | return -1; | |||
100 | ||||
101 | if (key) { | |||
102 | l = strlen(key); | |||
103 | if (l > (size_t)num) | |||
104 | l = (size_t)num; | |||
105 | memcpy(buf, key, l); | |||
106 | return (int)l; | |||
107 | } | |||
108 | ||||
109 | prompt = EVP_get_pw_prompt(); | |||
110 | if (prompt == NULL((void*)0)) | |||
111 | prompt = "Enter PEM pass phrase:"; | |||
112 | ||||
113 | for (;;) { | |||
114 | i = EVP_read_pw_string_min(buf, MIN_LENGTH4, num, prompt, w); | |||
115 | if (i != 0) { | |||
116 | PEMerror(PEM_R_PROBLEMS_GETTING_PASSWORD)ERR_put_error(9,(0xfff),(109),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,116); | |||
117 | memset(buf, 0, num); | |||
118 | return (-1); | |||
119 | } | |||
120 | l = strlen(buf); | |||
121 | if (l < MIN_LENGTH4) { | |||
122 | fprintf(stderr(&__sF[2]), "phrase is too short, " | |||
123 | "needs to be at least %zu chars\n", | |||
124 | (size_t)MIN_LENGTH4); | |||
125 | } else | |||
126 | break; | |||
127 | } | |||
128 | return (int)l; | |||
129 | } | |||
130 | ||||
131 | void | |||
132 | PEM_proc_type(char *buf, int type) | |||
133 | { | |||
134 | const char *str; | |||
135 | ||||
136 | if (type == PEM_TYPE_ENCRYPTED10) | |||
137 | str = "ENCRYPTED"; | |||
138 | else if (type == PEM_TYPE_MIC_CLEAR30) | |||
139 | str = "MIC-CLEAR"; | |||
140 | else if (type == PEM_TYPE_MIC_ONLY20) | |||
141 | str = "MIC-ONLY"; | |||
142 | else | |||
143 | str = "BAD-TYPE"; | |||
144 | ||||
145 | strlcat(buf, "Proc-Type: 4,", PEM_BUFSIZE1024); | |||
146 | strlcat(buf, str, PEM_BUFSIZE1024); | |||
147 | strlcat(buf, "\n", PEM_BUFSIZE1024); | |||
148 | } | |||
149 | ||||
150 | void | |||
151 | PEM_dek_info(char *buf, const char *type, int len, char *str) | |||
152 | { | |||
153 | static const unsigned char map[17] = "0123456789ABCDEF"; | |||
154 | long i; | |||
155 | int j; | |||
156 | ||||
157 | strlcat(buf, "DEK-Info: ", PEM_BUFSIZE1024); | |||
158 | strlcat(buf, type, PEM_BUFSIZE1024); | |||
159 | strlcat(buf, ",", PEM_BUFSIZE1024); | |||
160 | j = strlen(buf); | |||
161 | if (j + (len * 2) + 1 > PEM_BUFSIZE1024) | |||
162 | return; | |||
163 | for (i = 0; i < len; i++) { | |||
164 | buf[j + i * 2] = map[(str[i] >> 4) & 0x0f]; | |||
165 | buf[j + i * 2 + 1] = map[(str[i]) & 0x0f]; | |||
166 | } | |||
167 | buf[j + i * 2] = '\n'; | |||
168 | buf[j + i * 2 + 1] = '\0'; | |||
169 | } | |||
170 | ||||
171 | void * | |||
172 | PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x, | |||
173 | pem_password_cb *cb, void *u) | |||
174 | { | |||
175 | BIO *b; | |||
176 | void *ret; | |||
177 | ||||
178 | if ((b = BIO_new(BIO_s_file())) == NULL((void*)0)) { | |||
179 | PEMerror(ERR_R_BUF_LIB)ERR_put_error(9,(0xfff),(7),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,179); | |||
180 | return (0); | |||
181 | } | |||
182 | BIO_set_fp(b, fp, BIO_NOCLOSE)BIO_ctrl(b,106,0x00,(char *)fp); | |||
183 | ret = PEM_ASN1_read_bio(d2i, name, b, x, cb, u); | |||
184 | BIO_free(b); | |||
185 | return (ret); | |||
186 | } | |||
187 | ||||
188 | static int | |||
189 | check_pem(const char *nm, const char *name) | |||
190 | { | |||
191 | /* Normal matching nm and name */ | |||
192 | if (!strcmp(nm, name)) | |||
193 | return 1; | |||
194 | ||||
195 | /* Make PEM_STRING_EVP_PKEY match any private key */ | |||
196 | ||||
197 | if (!strcmp(name, PEM_STRING_EVP_PKEY"ANY PRIVATE KEY")) { | |||
198 | int slen; | |||
199 | const EVP_PKEY_ASN1_METHOD *ameth; | |||
200 | if (!strcmp(nm, PEM_STRING_PKCS8"ENCRYPTED PRIVATE KEY")) | |||
201 | return 1; | |||
202 | if (!strcmp(nm, PEM_STRING_PKCS8INF"PRIVATE KEY")) | |||
203 | return 1; | |||
204 | slen = pem_check_suffix(nm, "PRIVATE KEY"); | |||
205 | if (slen > 0) { | |||
206 | /* NB: ENGINE implementations wont contain | |||
207 | * a deprecated old private key decode function | |||
208 | * so don't look for them. | |||
209 | */ | |||
210 | ameth = EVP_PKEY_asn1_find_str(NULL((void*)0), nm, slen); | |||
211 | if (ameth && ameth->old_priv_decode) | |||
212 | return 1; | |||
213 | } | |||
214 | return 0; | |||
215 | } | |||
216 | ||||
217 | if (!strcmp(name, PEM_STRING_PARAMETERS"PARAMETERS")) { | |||
218 | int slen; | |||
219 | const EVP_PKEY_ASN1_METHOD *ameth; | |||
220 | slen = pem_check_suffix(nm, "PARAMETERS"); | |||
221 | if (slen > 0) { | |||
222 | ENGINE *e; | |||
223 | ameth = EVP_PKEY_asn1_find_str(&e, nm, slen); | |||
224 | if (ameth) { | |||
225 | int r; | |||
226 | if (ameth->param_decode) | |||
227 | r = 1; | |||
228 | else | |||
229 | r = 0; | |||
230 | #ifndef OPENSSL_NO_ENGINE | |||
231 | ENGINE_finish(e); | |||
232 | #endif | |||
233 | return r; | |||
234 | } | |||
235 | } | |||
236 | return 0; | |||
237 | } | |||
238 | ||||
239 | /* Permit older strings */ | |||
240 | ||||
241 | if (!strcmp(nm, PEM_STRING_X509_OLD"X509 CERTIFICATE") && | |||
242 | !strcmp(name, PEM_STRING_X509"CERTIFICATE")) | |||
243 | return 1; | |||
244 | ||||
245 | if (!strcmp(nm, PEM_STRING_X509_REQ_OLD"NEW CERTIFICATE REQUEST") && | |||
246 | !strcmp(name, PEM_STRING_X509_REQ"CERTIFICATE REQUEST")) | |||
247 | return 1; | |||
248 | ||||
249 | /* Allow normal certs to be read as trusted certs */ | |||
250 | if (!strcmp(nm, PEM_STRING_X509"CERTIFICATE") && | |||
251 | !strcmp(name, PEM_STRING_X509_TRUSTED"TRUSTED CERTIFICATE")) | |||
252 | return 1; | |||
253 | ||||
254 | if (!strcmp(nm, PEM_STRING_X509_OLD"X509 CERTIFICATE") && | |||
255 | !strcmp(name, PEM_STRING_X509_TRUSTED"TRUSTED CERTIFICATE")) | |||
256 | return 1; | |||
257 | ||||
258 | /* Some CAs use PKCS#7 with CERTIFICATE headers */ | |||
259 | if (!strcmp(nm, PEM_STRING_X509"CERTIFICATE") && | |||
260 | !strcmp(name, PEM_STRING_PKCS7"PKCS7")) | |||
261 | return 1; | |||
262 | ||||
263 | if (!strcmp(nm, PEM_STRING_PKCS7_SIGNED"PKCS #7 SIGNED DATA") && | |||
264 | !strcmp(name, PEM_STRING_PKCS7"PKCS7")) | |||
265 | return 1; | |||
266 | ||||
267 | #ifndef OPENSSL_NO_CMS | |||
268 | if (strcmp(nm, PEM_STRING_X509"CERTIFICATE") == 0 && | |||
269 | strcmp(name, PEM_STRING_CMS"CMS") == 0) | |||
270 | return 1; | |||
271 | ||||
272 | /* Allow CMS to be read from PKCS#7 headers */ | |||
273 | if (strcmp(nm, PEM_STRING_PKCS7"PKCS7") == 0 && | |||
274 | strcmp(name, PEM_STRING_CMS"CMS") == 0) | |||
275 | return 1; | |||
276 | #endif | |||
277 | ||||
278 | return 0; | |||
279 | } | |||
280 | ||||
281 | int | |||
282 | PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, | |||
283 | const char *name, BIO *bp, pem_password_cb *cb, void *u) | |||
284 | { | |||
285 | EVP_CIPHER_INFO cipher; | |||
286 | char *nm = NULL((void*)0), *header = NULL((void*)0); | |||
287 | unsigned char *data = NULL((void*)0); | |||
288 | long len; | |||
289 | int ret = 0; | |||
290 | ||||
291 | for (;;) { | |||
| ||||
292 | if (!PEM_read_bio(bp, &nm, &header, &data, &len)) { | |||
293 | if (ERR_GET_REASON(ERR_peek_error())(int)((ERR_peek_error())&0xfffL) == | |||
294 | PEM_R_NO_START_LINE108) | |||
295 | ERR_asprintf_error_data("Expecting: %s", name); | |||
296 | return 0; | |||
297 | } | |||
298 | if (check_pem(nm, name)) | |||
299 | break; | |||
300 | free(nm); | |||
301 | free(header); | |||
302 | free(data); | |||
303 | } | |||
304 | if (!PEM_get_EVP_CIPHER_INFO(header, &cipher)) | |||
305 | goto err; | |||
306 | if (!PEM_do_header(&cipher, data, &len, cb, u)) | |||
307 | goto err; | |||
308 | ||||
309 | *pdata = data; | |||
310 | *plen = len; | |||
311 | ||||
312 | if (pnm) | |||
313 | *pnm = nm; | |||
314 | ||||
315 | ret = 1; | |||
316 | ||||
317 | err: | |||
318 | if (!ret || !pnm) | |||
319 | free(nm); | |||
320 | free(header); | |||
321 | if (!ret) | |||
322 | free(data); | |||
323 | return ret; | |||
324 | } | |||
325 | ||||
326 | int | |||
327 | PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp, void *x, | |||
328 | const EVP_CIPHER *enc, unsigned char *kstr, int klen, | |||
329 | pem_password_cb *callback, void *u) | |||
330 | { | |||
331 | BIO *b; | |||
332 | int ret; | |||
333 | ||||
334 | if ((b = BIO_new(BIO_s_file())) == NULL((void*)0)) { | |||
335 | PEMerror(ERR_R_BUF_LIB)ERR_put_error(9,(0xfff),(7),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,335); | |||
336 | return (0); | |||
337 | } | |||
338 | BIO_set_fp(b, fp, BIO_NOCLOSE)BIO_ctrl(b,106,0x00,(char *)fp); | |||
339 | ret = PEM_ASN1_write_bio(i2d, name, b, x, enc, kstr, klen, callback, u); | |||
340 | BIO_free(b); | |||
341 | return (ret); | |||
342 | } | |||
343 | ||||
344 | int | |||
345 | PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp, void *x, | |||
346 | const EVP_CIPHER *enc, unsigned char *kstr, int klen, | |||
347 | pem_password_cb *callback, void *u) | |||
348 | { | |||
349 | EVP_CIPHER_CTX ctx; | |||
350 | int dsize = 0, i, j, ret = 0; | |||
351 | unsigned char *p, *data = NULL((void*)0); | |||
352 | const char *objstr = NULL((void*)0); | |||
353 | char buf[PEM_BUFSIZE1024]; | |||
354 | unsigned char key[EVP_MAX_KEY_LENGTH64]; | |||
355 | unsigned char iv[EVP_MAX_IV_LENGTH16]; | |||
356 | ||||
357 | if (enc != NULL((void*)0)) { | |||
358 | objstr = OBJ_nid2sn(EVP_CIPHER_nid(enc)); | |||
359 | if (objstr == NULL((void*)0)) { | |||
360 | PEMerror(PEM_R_UNSUPPORTED_CIPHER)ERR_put_error(9,(0xfff),(113),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,360); | |||
361 | goto err; | |||
362 | } | |||
363 | } | |||
364 | ||||
365 | if ((dsize = i2d(x, NULL((void*)0))) < 0) { | |||
366 | PEMerror(ERR_R_ASN1_LIB)ERR_put_error(9,(0xfff),(13),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,366); | |||
367 | dsize = 0; | |||
368 | goto err; | |||
369 | } | |||
370 | /* dzise + 8 bytes are needed */ | |||
371 | /* actually it needs the cipher block size extra... */ | |||
372 | data = malloc(dsize + 20); | |||
373 | if (data == NULL((void*)0)) { | |||
374 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,374); | |||
375 | goto err; | |||
376 | } | |||
377 | p = data; | |||
378 | i = i2d(x, &p); | |||
379 | ||||
380 | if (enc != NULL((void*)0)) { | |||
381 | if (kstr == NULL((void*)0)) { | |||
382 | if (callback == NULL((void*)0)) | |||
383 | klen = PEM_def_callback(buf, PEM_BUFSIZE1024, 1, u); | |||
384 | else | |||
385 | klen = (*callback)(buf, PEM_BUFSIZE1024, 1, u); | |||
386 | if (klen <= 0) { | |||
387 | PEMerror(PEM_R_READ_KEY)ERR_put_error(9,(0xfff),(111),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,387); | |||
388 | goto err; | |||
389 | } | |||
390 | kstr = (unsigned char *)buf; | |||
391 | } | |||
392 | if ((size_t)enc->iv_len > sizeof(iv)) { | |||
393 | PEMerror(EVP_R_IV_TOO_LARGE)ERR_put_error(9,(0xfff),(102),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,393); | |||
394 | goto err; | |||
395 | } | |||
396 | arc4random_buf(iv, enc->iv_len); /* Generate a salt */ | |||
397 | /* The 'iv' is used as the iv and as a salt. It is | |||
398 | * NOT taken from the BytesToKey function */ | |||
399 | if (!EVP_BytesToKey(enc, EVP_md5(), iv, kstr, klen, 1, | |||
400 | key, NULL((void*)0))) | |||
401 | goto err; | |||
402 | ||||
403 | if (kstr == (unsigned char *)buf) | |||
404 | explicit_bzero(buf, PEM_BUFSIZE1024); | |||
405 | ||||
406 | if (strlen(objstr) + 23 + 2 * enc->iv_len + 13 > sizeof buf) { | |||
407 | PEMerror(ASN1_R_BUFFER_TOO_SMALL)ERR_put_error(9,(0xfff),(107),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,407); | |||
408 | goto err; | |||
409 | } | |||
410 | ||||
411 | buf[0] = '\0'; | |||
412 | PEM_proc_type(buf, PEM_TYPE_ENCRYPTED10); | |||
413 | PEM_dek_info(buf, objstr, enc->iv_len, (char *)iv); | |||
414 | /* k=strlen(buf); */ | |||
415 | ||||
416 | EVP_CIPHER_CTX_init(&ctx); | |||
417 | ret = 1; | |||
418 | if (!EVP_EncryptInit_ex(&ctx, enc, NULL((void*)0), key, iv) || | |||
419 | !EVP_EncryptUpdate(&ctx, data, &j, data, i) || | |||
420 | !EVP_EncryptFinal_ex(&ctx, &(data[j]), &i)) | |||
421 | ret = 0; | |||
422 | EVP_CIPHER_CTX_cleanup(&ctx); | |||
423 | if (ret == 0) | |||
424 | goto err; | |||
425 | i += j; | |||
426 | } else { | |||
427 | ret = 1; | |||
428 | buf[0] = '\0'; | |||
429 | } | |||
430 | i = PEM_write_bio(bp, name, buf, data, i); | |||
431 | if (i <= 0) | |||
432 | ret = 0; | |||
433 | err: | |||
434 | explicit_bzero(key, sizeof(key)); | |||
435 | explicit_bzero(iv, sizeof(iv)); | |||
436 | explicit_bzero((char *)&ctx, sizeof(ctx)); | |||
437 | explicit_bzero(buf, PEM_BUFSIZE1024); | |||
438 | freezero(data, (unsigned int)dsize); | |||
439 | return (ret); | |||
440 | } | |||
441 | ||||
442 | int | |||
443 | PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen, | |||
444 | pem_password_cb *callback, void *u) | |||
445 | { | |||
446 | int i, j, o, klen; | |||
447 | long len; | |||
448 | EVP_CIPHER_CTX ctx; | |||
449 | unsigned char key[EVP_MAX_KEY_LENGTH64]; | |||
450 | char buf[PEM_BUFSIZE1024]; | |||
451 | ||||
452 | len = *plen; | |||
453 | ||||
454 | if (cipher->cipher == NULL((void*)0)) | |||
455 | return (1); | |||
456 | if (callback == NULL((void*)0)) | |||
457 | klen = PEM_def_callback(buf, PEM_BUFSIZE1024, 0, u); | |||
458 | else | |||
459 | klen = callback(buf, PEM_BUFSIZE1024, 0, u); | |||
460 | if (klen <= 0) { | |||
461 | PEMerror(PEM_R_BAD_PASSWORD_READ)ERR_put_error(9,(0xfff),(104),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,461); | |||
462 | return (0); | |||
463 | } | |||
464 | if (!EVP_BytesToKey(cipher->cipher, EVP_md5(), &(cipher->iv[0]), | |||
465 | (unsigned char *)buf, klen, 1, key, NULL((void*)0))) | |||
466 | return 0; | |||
467 | ||||
468 | j = (int)len; | |||
469 | EVP_CIPHER_CTX_init(&ctx); | |||
470 | o = EVP_DecryptInit_ex(&ctx, cipher->cipher, NULL((void*)0), key, | |||
471 | &(cipher->iv[0])); | |||
472 | if (o) | |||
473 | o = EVP_DecryptUpdate(&ctx, data, &i, data, j); | |||
474 | if (o) | |||
475 | o = EVP_DecryptFinal_ex(&ctx, &(data[i]), &j); | |||
476 | EVP_CIPHER_CTX_cleanup(&ctx); | |||
477 | explicit_bzero((char *)buf, sizeof(buf)); | |||
478 | explicit_bzero((char *)key, sizeof(key)); | |||
479 | if (!o) { | |||
480 | PEMerror(PEM_R_BAD_DECRYPT)ERR_put_error(9,(0xfff),(101),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,480); | |||
481 | return (0); | |||
482 | } | |||
483 | *plen = j + i; | |||
484 | return (1); | |||
485 | } | |||
486 | ||||
487 | int | |||
488 | PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher) | |||
489 | { | |||
490 | const EVP_CIPHER *enc = NULL((void*)0); | |||
491 | char *p, c; | |||
492 | char **header_pp = &header; | |||
493 | ||||
494 | cipher->cipher = NULL((void*)0); | |||
495 | if ((header == NULL((void*)0)) || (*header == '\0') || (*header == '\n')) | |||
496 | return (1); | |||
497 | if (strncmp(header, "Proc-Type: ", 11) != 0) { | |||
498 | PEMerror(PEM_R_NOT_PROC_TYPE)ERR_put_error(9,(0xfff),(107),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,498); | |||
499 | return (0); | |||
500 | } | |||
501 | header += 11; | |||
502 | if (*header != '4') | |||
503 | return (0); | |||
504 | header++; | |||
505 | if (*header != ',') | |||
506 | return (0); | |||
507 | header++; | |||
508 | if (strncmp(header, "ENCRYPTED", 9) != 0) { | |||
509 | PEMerror(PEM_R_NOT_ENCRYPTED)ERR_put_error(9,(0xfff),(106),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,509); | |||
510 | return (0); | |||
511 | } | |||
512 | for (; (*header != '\n') && (*header != '\0'); header++) | |||
513 | ; | |||
514 | if (*header == '\0') { | |||
515 | PEMerror(PEM_R_SHORT_HEADER)ERR_put_error(9,(0xfff),(112),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,515); | |||
516 | return (0); | |||
517 | } | |||
518 | header++; | |||
519 | if (strncmp(header, "DEK-Info: ", 10) != 0) { | |||
520 | PEMerror(PEM_R_NOT_DEK_INFO)ERR_put_error(9,(0xfff),(105),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,520); | |||
521 | return (0); | |||
522 | } | |||
523 | header += 10; | |||
524 | ||||
525 | p = header; | |||
526 | for (;;) { | |||
527 | c= *header; | |||
528 | if (!( ((c >= 'A') && (c <= 'Z')) || (c == '-') || | |||
529 | ((c >= '0') && (c <= '9')))) | |||
530 | break; | |||
531 | header++; | |||
532 | } | |||
533 | *header = '\0'; | |||
534 | cipher->cipher = enc = EVP_get_cipherbyname(p); | |||
535 | *header = c; | |||
536 | header++; | |||
537 | ||||
538 | if (enc == NULL((void*)0)) { | |||
539 | PEMerror(PEM_R_UNSUPPORTED_ENCRYPTION)ERR_put_error(9,(0xfff),(114),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,539); | |||
540 | return (0); | |||
541 | } | |||
542 | if (!load_iv(header_pp, &(cipher->iv[0]), enc->iv_len)) | |||
543 | return (0); | |||
544 | ||||
545 | return (1); | |||
546 | } | |||
547 | ||||
548 | static int | |||
549 | load_iv(char **fromp, unsigned char *to, int num) | |||
550 | { | |||
551 | int v, i; | |||
552 | char *from; | |||
553 | ||||
554 | from= *fromp; | |||
555 | for (i = 0; i < num; i++) | |||
556 | to[i] = 0; | |||
557 | num *= 2; | |||
558 | for (i = 0; i < num; i++) { | |||
559 | if ((*from >= '0') && (*from <= '9')) | |||
560 | v = *from - '0'; | |||
561 | else if ((*from >= 'A') && (*from <= 'F')) | |||
562 | v = *from - 'A' + 10; | |||
563 | else if ((*from >= 'a') && (*from <= 'f')) | |||
564 | v = *from - 'a' + 10; | |||
565 | else { | |||
566 | PEMerror(PEM_R_BAD_IV_CHARS)ERR_put_error(9,(0xfff),(103),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,566); | |||
567 | return (0); | |||
568 | } | |||
569 | from++; | |||
570 | to[i / 2] |= v << (long)((!(i & 1)) * 4); | |||
| ||||
571 | } | |||
572 | ||||
573 | *fromp = from; | |||
574 | return (1); | |||
575 | } | |||
576 | ||||
577 | int | |||
578 | PEM_write(FILE *fp, const char *name, const char *header, | |||
579 | const unsigned char *data, long len) | |||
580 | { | |||
581 | BIO *b; | |||
582 | int ret; | |||
583 | ||||
584 | if ((b = BIO_new(BIO_s_file())) == NULL((void*)0)) { | |||
585 | PEMerror(ERR_R_BUF_LIB)ERR_put_error(9,(0xfff),(7),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,585); | |||
586 | return (0); | |||
587 | } | |||
588 | BIO_set_fp(b, fp, BIO_NOCLOSE)BIO_ctrl(b,106,0x00,(char *)fp); | |||
589 | ret = PEM_write_bio(b, name, header, data, len); | |||
590 | BIO_free(b); | |||
591 | return (ret); | |||
592 | } | |||
593 | ||||
594 | int | |||
595 | PEM_write_bio(BIO *bp, const char *name, const char *header, | |||
596 | const unsigned char *data, long len) | |||
597 | { | |||
598 | int nlen, n, i, j, outl; | |||
599 | unsigned char *buf = NULL((void*)0); | |||
600 | EVP_ENCODE_CTX ctx; | |||
601 | int reason = ERR_R_BUF_LIB7; | |||
602 | ||||
603 | EVP_EncodeInit(&ctx); | |||
604 | nlen = strlen(name); | |||
605 | ||||
606 | if ((BIO_write(bp, "-----BEGIN ", 11) != 11) || | |||
607 | (BIO_write(bp, name, nlen) != nlen) || | |||
608 | (BIO_write(bp, "-----\n", 6) != 6)) | |||
609 | goto err; | |||
610 | ||||
611 | i = strlen(header); | |||
612 | if (i > 0) { | |||
613 | if ((BIO_write(bp, header, i) != i) || | |||
614 | (BIO_write(bp, "\n", 1) != 1)) | |||
615 | goto err; | |||
616 | } | |||
617 | ||||
618 | buf = reallocarray(NULL((void*)0), PEM_BUFSIZE1024, 8); | |||
619 | if (buf == NULL((void*)0)) { | |||
620 | reason = ERR_R_MALLOC_FAILURE(1|64); | |||
621 | goto err; | |||
622 | } | |||
623 | ||||
624 | i = j = 0; | |||
625 | while (len > 0) { | |||
626 | n = (int)((len > (PEM_BUFSIZE1024 * 5)) ? (PEM_BUFSIZE1024 * 5) : len); | |||
627 | if (!EVP_EncodeUpdate(&ctx, buf, &outl, &(data[j]), n)) | |||
628 | goto err; | |||
629 | if ((outl) && (BIO_write(bp, (char *)buf, outl) != outl)) | |||
630 | goto err; | |||
631 | i += outl; | |||
632 | len -= n; | |||
633 | j += n; | |||
634 | } | |||
635 | EVP_EncodeFinal(&ctx, buf, &outl); | |||
636 | if ((outl > 0) && (BIO_write(bp, (char *)buf, outl) != outl)) | |||
637 | goto err; | |||
638 | freezero(buf, PEM_BUFSIZE1024 * 8); | |||
639 | buf = NULL((void*)0); | |||
640 | if ((BIO_write(bp, "-----END ", 9) != 9) || | |||
641 | (BIO_write(bp, name, nlen) != nlen) || | |||
642 | (BIO_write(bp, "-----\n", 6) != 6)) | |||
643 | goto err; | |||
644 | return (i + outl); | |||
645 | ||||
646 | err: | |||
647 | freezero(buf, PEM_BUFSIZE1024 * 8); | |||
648 | PEMerror(reason)ERR_put_error(9,(0xfff),(reason),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,648); | |||
649 | return (0); | |||
650 | } | |||
651 | ||||
652 | int | |||
653 | PEM_read(FILE *fp, char **name, char **header, unsigned char **data, long *len) | |||
654 | { | |||
655 | BIO *b; | |||
656 | int ret; | |||
657 | ||||
658 | if ((b = BIO_new(BIO_s_file())) == NULL((void*)0)) { | |||
659 | PEMerror(ERR_R_BUF_LIB)ERR_put_error(9,(0xfff),(7),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,659); | |||
660 | return (0); | |||
661 | } | |||
662 | BIO_set_fp(b, fp, BIO_NOCLOSE)BIO_ctrl(b,106,0x00,(char *)fp); | |||
663 | ret = PEM_read_bio(b, name, header, data, len); | |||
664 | BIO_free(b); | |||
665 | return (ret); | |||
666 | } | |||
667 | ||||
668 | int | |||
669 | PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data, | |||
670 | long *len) | |||
671 | { | |||
672 | EVP_ENCODE_CTX ctx; | |||
673 | int end = 0, i, k, bl = 0, hl = 0, nohead = 0; | |||
674 | char buf[256]; | |||
675 | BUF_MEM *nameB; | |||
676 | BUF_MEM *headerB; | |||
677 | BUF_MEM *dataB, *tmpB; | |||
678 | ||||
679 | nameB = BUF_MEM_new(); | |||
680 | headerB = BUF_MEM_new(); | |||
681 | dataB = BUF_MEM_new(); | |||
682 | if ((nameB == NULL((void*)0)) || (headerB == NULL((void*)0)) || (dataB == NULL((void*)0))) { | |||
683 | BUF_MEM_free(nameB); | |||
684 | BUF_MEM_free(headerB); | |||
685 | BUF_MEM_free(dataB); | |||
686 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,686); | |||
687 | return (0); | |||
688 | } | |||
689 | ||||
690 | buf[254] = '\0'; | |||
691 | for (;;) { | |||
692 | i = BIO_gets(bp, buf, 254); | |||
693 | ||||
694 | if (i <= 0) { | |||
695 | PEMerror(PEM_R_NO_START_LINE)ERR_put_error(9,(0xfff),(108),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,695); | |||
696 | goto err; | |||
697 | } | |||
698 | ||||
699 | while ((i >= 0) && (buf[i] <= ' ')) | |||
700 | i--; | |||
701 | buf[++i] = '\n'; | |||
702 | buf[++i] = '\0'; | |||
703 | ||||
704 | if (strncmp(buf, "-----BEGIN ", 11) == 0) { | |||
705 | i = strlen(&(buf[11])); | |||
706 | ||||
707 | if (strncmp(&(buf[11 + i - 6]), "-----\n", 6) != 0) | |||
708 | continue; | |||
709 | if (!BUF_MEM_grow(nameB, i + 9)) { | |||
710 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,710); | |||
711 | goto err; | |||
712 | } | |||
713 | memcpy(nameB->data, &(buf[11]), i - 6); | |||
714 | nameB->data[i - 6] = '\0'; | |||
715 | break; | |||
716 | } | |||
717 | } | |||
718 | hl = 0; | |||
719 | if (!BUF_MEM_grow(headerB, 256)) { | |||
720 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,720); | |||
721 | goto err; | |||
722 | } | |||
723 | headerB->data[0] = '\0'; | |||
724 | for (;;) { | |||
725 | i = BIO_gets(bp, buf, 254); | |||
726 | if (i <= 0) | |||
727 | break; | |||
728 | ||||
729 | while ((i >= 0) && (buf[i] <= ' ')) | |||
730 | i--; | |||
731 | buf[++i] = '\n'; | |||
732 | buf[++i] = '\0'; | |||
733 | ||||
734 | if (buf[0] == '\n') | |||
735 | break; | |||
736 | if (!BUF_MEM_grow(headerB, hl + i + 9)) { | |||
737 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,737); | |||
738 | goto err; | |||
739 | } | |||
740 | if (strncmp(buf, "-----END ", 9) == 0) { | |||
741 | nohead = 1; | |||
742 | break; | |||
743 | } | |||
744 | memcpy(&(headerB->data[hl]), buf, i); | |||
745 | headerB->data[hl + i] = '\0'; | |||
746 | hl += i; | |||
747 | } | |||
748 | ||||
749 | bl = 0; | |||
750 | if (!BUF_MEM_grow(dataB, 1024)) { | |||
751 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,751); | |||
752 | goto err; | |||
753 | } | |||
754 | dataB->data[0] = '\0'; | |||
755 | if (!nohead) { | |||
756 | for (;;) { | |||
757 | i = BIO_gets(bp, buf, 254); | |||
758 | if (i <= 0) | |||
759 | break; | |||
760 | ||||
761 | while ((i >= 0) && (buf[i] <= ' ')) | |||
762 | i--; | |||
763 | buf[++i] = '\n'; | |||
764 | buf[++i] = '\0'; | |||
765 | ||||
766 | if (i != 65) | |||
767 | end = 1; | |||
768 | if (strncmp(buf, "-----END ", 9) == 0) | |||
769 | break; | |||
770 | if (i > 65) | |||
771 | break; | |||
772 | if (!BUF_MEM_grow_clean(dataB, i + bl + 9)) { | |||
773 | PEMerror(ERR_R_MALLOC_FAILURE)ERR_put_error(9,(0xfff),((1|64)),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,773); | |||
774 | goto err; | |||
775 | } | |||
776 | memcpy(&(dataB->data[bl]), buf, i); | |||
777 | dataB->data[bl + i] = '\0'; | |||
778 | bl += i; | |||
779 | if (end) { | |||
780 | buf[0] = '\0'; | |||
781 | i = BIO_gets(bp, buf, 254); | |||
782 | if (i <= 0) | |||
783 | break; | |||
784 | ||||
785 | while ((i >= 0) && (buf[i] <= ' ')) | |||
786 | i--; | |||
787 | buf[++i] = '\n'; | |||
788 | buf[++i] = '\0'; | |||
789 | ||||
790 | break; | |||
791 | } | |||
792 | } | |||
793 | } else { | |||
794 | tmpB = headerB; | |||
795 | headerB = dataB; | |||
796 | dataB = tmpB; | |||
797 | bl = hl; | |||
798 | } | |||
799 | i = strlen(nameB->data); | |||
800 | if ((strncmp(buf, "-----END ", 9) != 0) || | |||
801 | (strncmp(nameB->data, &(buf[9]), i) != 0) || | |||
802 | (strncmp(&(buf[9 + i]), "-----\n", 6) != 0)) { | |||
803 | PEMerror(PEM_R_BAD_END_LINE)ERR_put_error(9,(0xfff),(102),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,803); | |||
804 | goto err; | |||
805 | } | |||
806 | ||||
807 | EVP_DecodeInit(&ctx); | |||
808 | i = EVP_DecodeUpdate(&ctx, | |||
809 | (unsigned char *)dataB->data, &bl, | |||
810 | (unsigned char *)dataB->data, bl); | |||
811 | if (i < 0) { | |||
812 | PEMerror(PEM_R_BAD_BASE64_DECODE)ERR_put_error(9,(0xfff),(100),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,812); | |||
813 | goto err; | |||
814 | } | |||
815 | i = EVP_DecodeFinal(&ctx, (unsigned char *)&(dataB->data[bl]), &k); | |||
816 | if (i < 0) { | |||
817 | PEMerror(PEM_R_BAD_BASE64_DECODE)ERR_put_error(9,(0xfff),(100),"/usr/src/lib/libcrypto/pem/pem_lib.c" ,817); | |||
818 | goto err; | |||
819 | } | |||
820 | bl += k; | |||
821 | ||||
822 | if (bl == 0) | |||
823 | goto err; | |||
824 | *name = nameB->data; | |||
825 | *header = headerB->data; | |||
826 | *data = (unsigned char *)dataB->data; | |||
827 | *len = bl; | |||
828 | free(nameB); | |||
829 | free(headerB); | |||
830 | free(dataB); | |||
831 | return (1); | |||
832 | ||||
833 | err: | |||
834 | BUF_MEM_free(nameB); | |||
835 | BUF_MEM_free(headerB); | |||
836 | BUF_MEM_free(dataB); | |||
837 | return (0); | |||
838 | } | |||
839 | ||||
840 | /* Check pem string and return prefix length. | |||
841 | * If for example the pem_str == "RSA PRIVATE KEY" and suffix = "PRIVATE KEY" | |||
842 | * the return value is 3 for the string "RSA". | |||
843 | */ | |||
844 | ||||
845 | int | |||
846 | pem_check_suffix(const char *pem_str, const char *suffix) | |||
847 | { | |||
848 | int pem_len = strlen(pem_str); | |||
849 | int suffix_len = strlen(suffix); | |||
850 | const char *p; | |||
851 | ||||
852 | if (suffix_len + 1 >= pem_len) | |||
853 | return 0; | |||
854 | p = pem_str + pem_len - suffix_len; | |||
855 | if (strcmp(p, suffix)) | |||
856 | return 0; | |||
857 | p--; | |||
858 | if (*p != ' ') | |||
859 | return 0; | |||
860 | return p - pem_str; | |||
861 | } |