summaryrefslogtreecommitdiff
path: root/src/lib/libcrypto/pem
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/libcrypto/pem')
-rw-r--r--src/lib/libcrypto/pem/message16
-rw-r--r--src/lib/libcrypto/pem/pem.h782
-rw-r--r--src/lib/libcrypto/pem/pem2.h70
-rw-r--r--src/lib/libcrypto/pem/pem_all.c482
-rw-r--r--src/lib/libcrypto/pem/pem_err.c135
-rw-r--r--src/lib/libcrypto/pem/pem_info.c397
-rw-r--r--src/lib/libcrypto/pem/pem_lib.c784
-rw-r--r--src/lib/libcrypto/pem/pem_oth.c86
-rw-r--r--src/lib/libcrypto/pem/pem_pk8.c242
-rw-r--r--src/lib/libcrypto/pem/pem_pkey.c149
-rw-r--r--src/lib/libcrypto/pem/pem_seal.c189
-rw-r--r--src/lib/libcrypto/pem/pem_sign.c102
-rw-r--r--src/lib/libcrypto/pem/pem_x509.c69
-rw-r--r--src/lib/libcrypto/pem/pem_xaux.c69
-rw-r--r--src/lib/libcrypto/pem/pkcs7.lis22
15 files changed, 0 insertions, 3594 deletions
diff --git a/src/lib/libcrypto/pem/message b/src/lib/libcrypto/pem/message
deleted file mode 100644
index e8bf9d7592..0000000000
--- a/src/lib/libcrypto/pem/message
+++ /dev/null
@@ -1,16 +0,0 @@
1-----BEGIN PRIVACY-ENHANCED MESSAGE-----
2Proc-Type: 4,ENCRYPTED
3Proc-Type: 4,MIC-ONLY
4Proc-Type: 4,MIC-CLEAR
5Content-Domain: RFC822
6DEK-Info: DES-CBC,0123456789abcdef
7Originator-Certificate
8 xxxx
9Issuer-Certificate
10 xxxx
11MIC-Info: RSA-MD5,RSA,
12 xxxx
13
14
15-----END PRIVACY-ENHANCED MESSAGE-----
16
diff --git a/src/lib/libcrypto/pem/pem.h b/src/lib/libcrypto/pem/pem.h
deleted file mode 100644
index 6c193f1cbf..0000000000
--- a/src/lib/libcrypto/pem/pem.h
+++ /dev/null
@@ -1,782 +0,0 @@
1/* crypto/pem/pem.h */
2/* Copyright (C) 1995-1997 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#ifndef HEADER_PEM_H
60#define HEADER_PEM_H
61
62#include <openssl/e_os2.h>
63#ifndef OPENSSL_NO_BIO
64#include <openssl/bio.h>
65#endif
66#ifndef OPENSSL_NO_STACK
67#include <openssl/stack.h>
68#endif
69#include <openssl/evp.h>
70#include <openssl/x509.h>
71#include <openssl/pem2.h>
72
73#ifdef __cplusplus
74extern "C" {
75#endif
76
77#define PEM_BUFSIZE 1024
78
79#define PEM_OBJ_UNDEF 0
80#define PEM_OBJ_X509 1
81#define PEM_OBJ_X509_REQ 2
82#define PEM_OBJ_CRL 3
83#define PEM_OBJ_SSL_SESSION 4
84#define PEM_OBJ_PRIV_KEY 10
85#define PEM_OBJ_PRIV_RSA 11
86#define PEM_OBJ_PRIV_DSA 12
87#define PEM_OBJ_PRIV_DH 13
88#define PEM_OBJ_PUB_RSA 14
89#define PEM_OBJ_PUB_DSA 15
90#define PEM_OBJ_PUB_DH 16
91#define PEM_OBJ_DHPARAMS 17
92#define PEM_OBJ_DSAPARAMS 18
93#define PEM_OBJ_PRIV_RSA_PUBLIC 19
94#define PEM_OBJ_PRIV_ECDSA 20
95#define PEM_OBJ_PUB_ECDSA 21
96#define PEM_OBJ_ECPARAMETERS 22
97
98#define PEM_ERROR 30
99#define PEM_DEK_DES_CBC 40
100#define PEM_DEK_IDEA_CBC 45
101#define PEM_DEK_DES_EDE 50
102#define PEM_DEK_DES_ECB 60
103#define PEM_DEK_RSA 70
104#define PEM_DEK_RSA_MD2 80
105#define PEM_DEK_RSA_MD5 90
106
107#define PEM_MD_MD2 NID_md2
108#define PEM_MD_MD5 NID_md5
109#define PEM_MD_SHA NID_sha
110#define PEM_MD_MD2_RSA NID_md2WithRSAEncryption
111#define PEM_MD_MD5_RSA NID_md5WithRSAEncryption
112#define PEM_MD_SHA_RSA NID_sha1WithRSAEncryption
113
114#define PEM_STRING_X509_OLD "X509 CERTIFICATE"
115#define PEM_STRING_X509 "CERTIFICATE"
116#define PEM_STRING_X509_PAIR "CERTIFICATE PAIR"
117#define PEM_STRING_X509_TRUSTED "TRUSTED CERTIFICATE"
118#define PEM_STRING_X509_REQ_OLD "NEW CERTIFICATE REQUEST"
119#define PEM_STRING_X509_REQ "CERTIFICATE REQUEST"
120#define PEM_STRING_X509_CRL "X509 CRL"
121#define PEM_STRING_EVP_PKEY "ANY PRIVATE KEY"
122#define PEM_STRING_PUBLIC "PUBLIC KEY"
123#define PEM_STRING_RSA "RSA PRIVATE KEY"
124#define PEM_STRING_RSA_PUBLIC "RSA PUBLIC KEY"
125#define PEM_STRING_DSA "DSA PRIVATE KEY"
126#define PEM_STRING_DSA_PUBLIC "DSA PUBLIC KEY"
127#define PEM_STRING_PKCS7 "PKCS7"
128#define PEM_STRING_PKCS7_SIGNED "PKCS #7 SIGNED DATA"
129#define PEM_STRING_PKCS8 "ENCRYPTED PRIVATE KEY"
130#define PEM_STRING_PKCS8INF "PRIVATE KEY"
131#define PEM_STRING_DHPARAMS "DH PARAMETERS"
132#define PEM_STRING_SSL_SESSION "SSL SESSION PARAMETERS"
133#define PEM_STRING_DSAPARAMS "DSA PARAMETERS"
134#define PEM_STRING_ECDSA_PUBLIC "ECDSA PUBLIC KEY"
135#define PEM_STRING_ECPARAMETERS "EC PARAMETERS"
136#define PEM_STRING_ECPRIVATEKEY "EC PRIVATE KEY"
137#define PEM_STRING_CMS "CMS"
138
139 /* Note that this structure is initialised by PEM_SealInit and cleaned up
140 by PEM_SealFinal (at least for now) */
141typedef struct PEM_Encode_Seal_st
142 {
143 EVP_ENCODE_CTX encode;
144 EVP_MD_CTX md;
145 EVP_CIPHER_CTX cipher;
146 } PEM_ENCODE_SEAL_CTX;
147
148/* enc_type is one off */
149#define PEM_TYPE_ENCRYPTED 10
150#define PEM_TYPE_MIC_ONLY 20
151#define PEM_TYPE_MIC_CLEAR 30
152#define PEM_TYPE_CLEAR 40
153
154typedef struct pem_recip_st
155 {
156 char *name;
157 X509_NAME *dn;
158
159 int cipher;
160 int key_enc;
161 /* char iv[8]; unused and wrong size */
162 } PEM_USER;
163
164typedef struct pem_ctx_st
165 {
166 int type; /* what type of object */
167
168 struct {
169 int version;
170 int mode;
171 } proc_type;
172
173 char *domain;
174
175 struct {
176 int cipher;
177 /* unused, and wrong size
178 unsigned char iv[8]; */
179 } DEK_info;
180
181 PEM_USER *originator;
182
183 int num_recipient;
184 PEM_USER **recipient;
185
186#ifndef OPENSSL_NO_STACK
187 STACK *x509_chain; /* certificate chain */
188#else
189 char *x509_chain; /* certificate chain */
190#endif
191 EVP_MD *md; /* signature type */
192
193 int md_enc; /* is the md encrypted or not? */
194 int md_len; /* length of md_data */
195 char *md_data; /* message digest, could be pkey encrypted */
196
197 EVP_CIPHER *dec; /* date encryption cipher */
198 int key_len; /* key length */
199 unsigned char *key; /* key */
200 /* unused, and wrong size
201 unsigned char iv[8]; */
202
203
204 int data_enc; /* is the data encrypted */
205 int data_len;
206 unsigned char *data;
207 } PEM_CTX;
208
209/* These macros make the PEM_read/PEM_write functions easier to maintain and
210 * write. Now they are all implemented with either:
211 * IMPLEMENT_PEM_rw(...) or IMPLEMENT_PEM_rw_cb(...)
212 */
213
214#ifdef OPENSSL_NO_FP_API
215
216#define IMPLEMENT_PEM_read_fp(name, type, str, asn1) /**/
217#define IMPLEMENT_PEM_write_fp(name, type, str, asn1) /**/
218#define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) /**/
219#define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) /**/
220#define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) /**/
221
222#else
223
224#define IMPLEMENT_PEM_read_fp(name, type, str, asn1) \
225type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u)\
226{ \
227 return (type*)PEM_ASN1_read(CHECKED_D2I_OF(type, d2i_##asn1), \
228 str, fp, \
229 CHECKED_PPTR_OF(type, x), \
230 cb, u); \
231}
232
233#define IMPLEMENT_PEM_write_fp(name, type, str, asn1) \
234int PEM_write_##name(FILE *fp, type *x) \
235{ \
236 return PEM_ASN1_write(CHECKED_I2D_OF(type, i2d_##asn1), \
237 str, fp, \
238 CHECKED_PTR_OF(type, x), \
239 NULL, NULL, 0, NULL, NULL); \
240}
241
242#define IMPLEMENT_PEM_write_fp_const(name, type, str, asn1) \
243int PEM_write_##name(FILE *fp, const type *x) \
244{ \
245 return PEM_ASN1_write(CHECKED_I2D_OF(const type, i2d_##asn1), \
246 str, fp, \
247 CHECKED_PTR_OF(const type, x), \
248 NULL, NULL, 0, NULL, NULL); \
249}
250
251#define IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1) \
252int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
253 unsigned char *kstr, int klen, pem_password_cb *cb, \
254 void *u) \
255 { \
256 return PEM_ASN1_write(CHECKED_I2D_OF(type, i2d_##asn1), \
257 str, fp, \
258 CHECKED_PTR_OF(type, x), \
259 enc, kstr, klen, cb, u); \
260 }
261
262#define IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1) \
263int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
264 unsigned char *kstr, int klen, pem_password_cb *cb, \
265 void *u) \
266 { \
267 return PEM_ASN1_write(CHECKED_I2D_OF(const type, i2d_##asn1), \
268 str, fp, \
269 CHECKED_PTR_OF(const type, x), \
270 enc, kstr, klen, cb, u); \
271 }
272
273#endif
274
275#define IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
276type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u)\
277{ \
278 return (type*)PEM_ASN1_read_bio(CHECKED_D2I_OF(type, d2i_##asn1), \
279 str, bp, \
280 CHECKED_PPTR_OF(type, x), \
281 cb, u); \
282}
283
284#define IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
285int PEM_write_bio_##name(BIO *bp, type *x) \
286{ \
287 return PEM_ASN1_write_bio(CHECKED_I2D_OF(type, i2d_##asn1), \
288 str, bp, \
289 CHECKED_PTR_OF(type, x), \
290 NULL, NULL, 0, NULL, NULL); \
291}
292
293#define IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
294int PEM_write_bio_##name(BIO *bp, const type *x) \
295{ \
296 return PEM_ASN1_write_bio(CHECKED_I2D_OF(const type, i2d_##asn1), \
297 str, bp, \
298 CHECKED_PTR_OF(const type, x), \
299 NULL, NULL, 0, NULL, NULL); \
300}
301
302#define IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
303int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
304 unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
305 { \
306 return PEM_ASN1_write_bio(CHECKED_I2D_OF(type, i2d_##asn1), \
307 str, bp, \
308 CHECKED_PTR_OF(type, x), \
309 enc, kstr, klen, cb, u); \
310 }
311
312#define IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
313int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
314 unsigned char *kstr, int klen, pem_password_cb *cb, void *u) \
315 { \
316 return PEM_ASN1_write_bio(CHECKED_I2D_OF(const type, i2d_##asn1), \
317 str, bp, \
318 CHECKED_PTR_OF(const type, x), \
319 enc, kstr, klen, cb, u); \
320 }
321
322#define IMPLEMENT_PEM_write(name, type, str, asn1) \
323 IMPLEMENT_PEM_write_bio(name, type, str, asn1) \
324 IMPLEMENT_PEM_write_fp(name, type, str, asn1)
325
326#define IMPLEMENT_PEM_write_const(name, type, str, asn1) \
327 IMPLEMENT_PEM_write_bio_const(name, type, str, asn1) \
328 IMPLEMENT_PEM_write_fp_const(name, type, str, asn1)
329
330#define IMPLEMENT_PEM_write_cb(name, type, str, asn1) \
331 IMPLEMENT_PEM_write_cb_bio(name, type, str, asn1) \
332 IMPLEMENT_PEM_write_cb_fp(name, type, str, asn1)
333
334#define IMPLEMENT_PEM_write_cb_const(name, type, str, asn1) \
335 IMPLEMENT_PEM_write_cb_bio_const(name, type, str, asn1) \
336 IMPLEMENT_PEM_write_cb_fp_const(name, type, str, asn1)
337
338#define IMPLEMENT_PEM_read(name, type, str, asn1) \
339 IMPLEMENT_PEM_read_bio(name, type, str, asn1) \
340 IMPLEMENT_PEM_read_fp(name, type, str, asn1)
341
342#define IMPLEMENT_PEM_rw(name, type, str, asn1) \
343 IMPLEMENT_PEM_read(name, type, str, asn1) \
344 IMPLEMENT_PEM_write(name, type, str, asn1)
345
346#define IMPLEMENT_PEM_rw_const(name, type, str, asn1) \
347 IMPLEMENT_PEM_read(name, type, str, asn1) \
348 IMPLEMENT_PEM_write_const(name, type, str, asn1)
349
350#define IMPLEMENT_PEM_rw_cb(name, type, str, asn1) \
351 IMPLEMENT_PEM_read(name, type, str, asn1) \
352 IMPLEMENT_PEM_write_cb(name, type, str, asn1)
353
354/* These are the same except they are for the declarations */
355
356#if defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_NO_FP_API)
357
358#define DECLARE_PEM_read_fp(name, type) /**/
359#define DECLARE_PEM_write_fp(name, type) /**/
360#define DECLARE_PEM_write_fp_const(name, type) /**/
361#define DECLARE_PEM_write_cb_fp(name, type) /**/
362
363#else
364
365#define DECLARE_PEM_read_fp(name, type) \
366 type *PEM_read_##name(FILE *fp, type **x, pem_password_cb *cb, void *u);
367
368#define DECLARE_PEM_write_fp(name, type) \
369 int PEM_write_##name(FILE *fp, type *x);
370
371#define DECLARE_PEM_write_fp_const(name, type) \
372 int PEM_write_##name(FILE *fp, const type *x);
373
374#define DECLARE_PEM_write_cb_fp(name, type) \
375 int PEM_write_##name(FILE *fp, type *x, const EVP_CIPHER *enc, \
376 unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
377
378#endif
379
380#ifndef OPENSSL_NO_BIO
381#define DECLARE_PEM_read_bio(name, type) \
382 type *PEM_read_bio_##name(BIO *bp, type **x, pem_password_cb *cb, void *u);
383
384#define DECLARE_PEM_write_bio(name, type) \
385 int PEM_write_bio_##name(BIO *bp, type *x);
386
387#define DECLARE_PEM_write_bio_const(name, type) \
388 int PEM_write_bio_##name(BIO *bp, const type *x);
389
390#define DECLARE_PEM_write_cb_bio(name, type) \
391 int PEM_write_bio_##name(BIO *bp, type *x, const EVP_CIPHER *enc, \
392 unsigned char *kstr, int klen, pem_password_cb *cb, void *u);
393
394#else
395
396#define DECLARE_PEM_read_bio(name, type) /**/
397#define DECLARE_PEM_write_bio(name, type) /**/
398#define DECLARE_PEM_write_bio_const(name, type) /**/
399#define DECLARE_PEM_write_cb_bio(name, type) /**/
400
401#endif
402
403#define DECLARE_PEM_write(name, type) \
404 DECLARE_PEM_write_bio(name, type) \
405 DECLARE_PEM_write_fp(name, type)
406
407#define DECLARE_PEM_write_const(name, type) \
408 DECLARE_PEM_write_bio_const(name, type) \
409 DECLARE_PEM_write_fp_const(name, type)
410
411#define DECLARE_PEM_write_cb(name, type) \
412 DECLARE_PEM_write_cb_bio(name, type) \
413 DECLARE_PEM_write_cb_fp(name, type)
414
415#define DECLARE_PEM_read(name, type) \
416 DECLARE_PEM_read_bio(name, type) \
417 DECLARE_PEM_read_fp(name, type)
418
419#define DECLARE_PEM_rw(name, type) \
420 DECLARE_PEM_read(name, type) \
421 DECLARE_PEM_write(name, type)
422
423#define DECLARE_PEM_rw_const(name, type) \
424 DECLARE_PEM_read(name, type) \
425 DECLARE_PEM_write_const(name, type)
426
427#define DECLARE_PEM_rw_cb(name, type) \
428 DECLARE_PEM_read(name, type) \
429 DECLARE_PEM_write_cb(name, type)
430
431#ifdef SSLEAY_MACROS
432
433#define PEM_write_SSL_SESSION(fp,x) \
434 PEM_ASN1_write((int (*)())i2d_SSL_SESSION, \
435 PEM_STRING_SSL_SESSION,fp, (char *)x, NULL,NULL,0,NULL,NULL)
436#define PEM_write_X509(fp,x) \
437 PEM_ASN1_write((int (*)())i2d_X509,PEM_STRING_X509,fp, \
438 (char *)x, NULL,NULL,0,NULL,NULL)
439#define PEM_write_X509_REQ(fp,x) PEM_ASN1_write( \
440 (int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,fp,(char *)x, \
441 NULL,NULL,0,NULL,NULL)
442#define PEM_write_X509_CRL(fp,x) \
443 PEM_ASN1_write((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL, \
444 fp,(char *)x, NULL,NULL,0,NULL,NULL)
445#define PEM_write_RSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \
446 PEM_ASN1_write((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,fp,\
447 (char *)x,enc,kstr,klen,cb,u)
448#define PEM_write_RSAPublicKey(fp,x) \
449 PEM_ASN1_write((int (*)())i2d_RSAPublicKey,\
450 PEM_STRING_RSA_PUBLIC,fp,(char *)x,NULL,NULL,0,NULL,NULL)
451#define PEM_write_DSAPrivateKey(fp,x,enc,kstr,klen,cb,u) \
452 PEM_ASN1_write((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,fp,\
453 (char *)x,enc,kstr,klen,cb,u)
454#define PEM_write_PrivateKey(bp,x,enc,kstr,klen,cb,u) \
455 PEM_ASN1_write((int (*)())i2d_PrivateKey,\
456 (((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\
457 bp,(char *)x,enc,kstr,klen,cb,u)
458#define PEM_write_PKCS7(fp,x) \
459 PEM_ASN1_write((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,fp, \
460 (char *)x, NULL,NULL,0,NULL,NULL)
461#define PEM_write_DHparams(fp,x) \
462 PEM_ASN1_write((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,fp,\
463 (char *)x,NULL,NULL,0,NULL,NULL)
464
465#define PEM_write_NETSCAPE_CERT_SEQUENCE(fp,x) \
466 PEM_ASN1_write((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \
467 PEM_STRING_X509,fp, \
468 (char *)x, NULL,NULL,0,NULL,NULL)
469
470#define PEM_read_SSL_SESSION(fp,x,cb,u) (SSL_SESSION *)PEM_ASN1_read( \
471 (char *(*)())d2i_SSL_SESSION,PEM_STRING_SSL_SESSION,fp,(char **)x,cb,u)
472#define PEM_read_X509(fp,x,cb,u) (X509 *)PEM_ASN1_read( \
473 (char *(*)())d2i_X509,PEM_STRING_X509,fp,(char **)x,cb,u)
474#define PEM_read_X509_REQ(fp,x,cb,u) (X509_REQ *)PEM_ASN1_read( \
475 (char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,fp,(char **)x,cb,u)
476#define PEM_read_X509_CRL(fp,x,cb,u) (X509_CRL *)PEM_ASN1_read( \
477 (char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,fp,(char **)x,cb,u)
478#define PEM_read_RSAPrivateKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \
479 (char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,fp,(char **)x,cb,u)
480#define PEM_read_RSAPublicKey(fp,x,cb,u) (RSA *)PEM_ASN1_read( \
481 (char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,fp,(char **)x,cb,u)
482#define PEM_read_DSAPrivateKey(fp,x,cb,u) (DSA *)PEM_ASN1_read( \
483 (char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,fp,(char **)x,cb,u)
484#define PEM_read_PrivateKey(fp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read( \
485 (char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,fp,(char **)x,cb,u)
486#define PEM_read_PKCS7(fp,x,cb,u) (PKCS7 *)PEM_ASN1_read( \
487 (char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,fp,(char **)x,cb,u)
488#define PEM_read_DHparams(fp,x,cb,u) (DH *)PEM_ASN1_read( \
489 (char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,fp,(char **)x,cb,u)
490
491#define PEM_read_NETSCAPE_CERT_SEQUENCE(fp,x,cb,u) \
492 (NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read( \
493 (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,fp,\
494 (char **)x,cb,u)
495
496#define PEM_write_bio_X509(bp,x) \
497 PEM_ASN1_write_bio((int (*)())i2d_X509,PEM_STRING_X509,bp, \
498 (char *)x, NULL,NULL,0,NULL,NULL)
499#define PEM_write_bio_X509_REQ(bp,x) PEM_ASN1_write_bio( \
500 (int (*)())i2d_X509_REQ,PEM_STRING_X509_REQ,bp,(char *)x, \
501 NULL,NULL,0,NULL,NULL)
502#define PEM_write_bio_X509_CRL(bp,x) \
503 PEM_ASN1_write_bio((int (*)())i2d_X509_CRL,PEM_STRING_X509_CRL,\
504 bp,(char *)x, NULL,NULL,0,NULL,NULL)
505#define PEM_write_bio_RSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \
506 PEM_ASN1_write_bio((int (*)())i2d_RSAPrivateKey,PEM_STRING_RSA,\
507 bp,(char *)x,enc,kstr,klen,cb,u)
508#define PEM_write_bio_RSAPublicKey(bp,x) \
509 PEM_ASN1_write_bio((int (*)())i2d_RSAPublicKey, \
510 PEM_STRING_RSA_PUBLIC,\
511 bp,(char *)x,NULL,NULL,0,NULL,NULL)
512#define PEM_write_bio_DSAPrivateKey(bp,x,enc,kstr,klen,cb,u) \
513 PEM_ASN1_write_bio((int (*)())i2d_DSAPrivateKey,PEM_STRING_DSA,\
514 bp,(char *)x,enc,kstr,klen,cb,u)
515#define PEM_write_bio_PrivateKey(bp,x,enc,kstr,klen,cb,u) \
516 PEM_ASN1_write_bio((int (*)())i2d_PrivateKey,\
517 (((x)->type == EVP_PKEY_DSA)?PEM_STRING_DSA:PEM_STRING_RSA),\
518 bp,(char *)x,enc,kstr,klen,cb,u)
519#define PEM_write_bio_PKCS7(bp,x) \
520 PEM_ASN1_write_bio((int (*)())i2d_PKCS7,PEM_STRING_PKCS7,bp, \
521 (char *)x, NULL,NULL,0,NULL,NULL)
522#define PEM_write_bio_DHparams(bp,x) \
523 PEM_ASN1_write_bio((int (*)())i2d_DHparams,PEM_STRING_DHPARAMS,\
524 bp,(char *)x,NULL,NULL,0,NULL,NULL)
525#define PEM_write_bio_DSAparams(bp,x) \
526 PEM_ASN1_write_bio((int (*)())i2d_DSAparams, \
527 PEM_STRING_DSAPARAMS,bp,(char *)x,NULL,NULL,0,NULL,NULL)
528
529#define PEM_write_bio_NETSCAPE_CERT_SEQUENCE(bp,x) \
530 PEM_ASN1_write_bio((int (*)())i2d_NETSCAPE_CERT_SEQUENCE, \
531 PEM_STRING_X509,bp, \
532 (char *)x, NULL,NULL,0,NULL,NULL)
533
534#define PEM_read_bio_X509(bp,x,cb,u) (X509 *)PEM_ASN1_read_bio( \
535 (char *(*)())d2i_X509,PEM_STRING_X509,bp,(char **)x,cb,u)
536#define PEM_read_bio_X509_REQ(bp,x,cb,u) (X509_REQ *)PEM_ASN1_read_bio( \
537 (char *(*)())d2i_X509_REQ,PEM_STRING_X509_REQ,bp,(char **)x,cb,u)
538#define PEM_read_bio_X509_CRL(bp,x,cb,u) (X509_CRL *)PEM_ASN1_read_bio( \
539 (char *(*)())d2i_X509_CRL,PEM_STRING_X509_CRL,bp,(char **)x,cb,u)
540#define PEM_read_bio_RSAPrivateKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \
541 (char *(*)())d2i_RSAPrivateKey,PEM_STRING_RSA,bp,(char **)x,cb,u)
542#define PEM_read_bio_RSAPublicKey(bp,x,cb,u) (RSA *)PEM_ASN1_read_bio( \
543 (char *(*)())d2i_RSAPublicKey,PEM_STRING_RSA_PUBLIC,bp,(char **)x,cb,u)
544#define PEM_read_bio_DSAPrivateKey(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
545 (char *(*)())d2i_DSAPrivateKey,PEM_STRING_DSA,bp,(char **)x,cb,u)
546#define PEM_read_bio_PrivateKey(bp,x,cb,u) (EVP_PKEY *)PEM_ASN1_read_bio( \
547 (char *(*)())d2i_PrivateKey,PEM_STRING_EVP_PKEY,bp,(char **)x,cb,u)
548
549#define PEM_read_bio_PKCS7(bp,x,cb,u) (PKCS7 *)PEM_ASN1_read_bio( \
550 (char *(*)())d2i_PKCS7,PEM_STRING_PKCS7,bp,(char **)x,cb,u)
551#define PEM_read_bio_DHparams(bp,x,cb,u) (DH *)PEM_ASN1_read_bio( \
552 (char *(*)())d2i_DHparams,PEM_STRING_DHPARAMS,bp,(char **)x,cb,u)
553#define PEM_read_bio_DSAparams(bp,x,cb,u) (DSA *)PEM_ASN1_read_bio( \
554 (char *(*)())d2i_DSAparams,PEM_STRING_DSAPARAMS,bp,(char **)x,cb,u)
555
556#define PEM_read_bio_NETSCAPE_CERT_SEQUENCE(bp,x,cb,u) \
557 (NETSCAPE_CERT_SEQUENCE *)PEM_ASN1_read_bio( \
558 (char *(*)())d2i_NETSCAPE_CERT_SEQUENCE,PEM_STRING_X509,bp,\
559 (char **)x,cb,u)
560
561#endif
562
563#if 1
564/* "userdata": new with OpenSSL 0.9.4 */
565typedef int pem_password_cb(char *buf, int size, int rwflag, void *userdata);
566#else
567/* OpenSSL 0.9.3, 0.9.3a */
568typedef int pem_password_cb(char *buf, int size, int rwflag);
569#endif
570
571int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher);
572int PEM_do_header (EVP_CIPHER_INFO *cipher, unsigned char *data,long *len,
573 pem_password_cb *callback,void *u);
574
575#ifndef OPENSSL_NO_BIO
576int PEM_read_bio(BIO *bp, char **name, char **header,
577 unsigned char **data,long *len);
578int PEM_write_bio(BIO *bp,const char *name,char *hdr,unsigned char *data,
579 long len);
580int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
581 pem_password_cb *cb, void *u);
582void * PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp,
583 void **x, pem_password_cb *cb, void *u);
584
585#define PEM_ASN1_read_bio_of(type,d2i,name,bp,x,cb,u) \
586 ((type*)PEM_ASN1_read_bio(CHECKED_D2I_OF(type, d2i), \
587 name, bp, \
588 CHECKED_PPTR_OF(type, x), \
589 cb, u))
590
591int PEM_ASN1_write_bio(i2d_of_void *i2d,const char *name,BIO *bp,char *x,
592 const EVP_CIPHER *enc,unsigned char *kstr,int klen,
593 pem_password_cb *cb, void *u);
594
595#define PEM_ASN1_write_bio_of(type,i2d,name,bp,x,enc,kstr,klen,cb,u) \
596 (PEM_ASN1_write_bio(CHECKED_I2D_OF(type, i2d), \
597 name, bp, \
598 CHECKED_PTR_OF(type, x), \
599 enc, kstr, klen, cb, u))
600
601STACK_OF(X509_INFO) * PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u);
602int PEM_X509_INFO_write_bio(BIO *bp,X509_INFO *xi, EVP_CIPHER *enc,
603 unsigned char *kstr, int klen, pem_password_cb *cd, void *u);
604#endif
605
606#ifndef OPENSSL_SYS_WIN16
607int PEM_read(FILE *fp, char **name, char **header,
608 unsigned char **data,long *len);
609int PEM_write(FILE *fp,char *name,char *hdr,unsigned char *data,long len);
610void * PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
611 pem_password_cb *cb, void *u);
612int PEM_ASN1_write(i2d_of_void *i2d,const char *name,FILE *fp,
613 char *x,const EVP_CIPHER *enc,unsigned char *kstr,
614 int klen,pem_password_cb *callback, void *u);
615STACK_OF(X509_INFO) * PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk,
616 pem_password_cb *cb, void *u);
617#endif
618
619int PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type,
620 EVP_MD *md_type, unsigned char **ek, int *ekl,
621 unsigned char *iv, EVP_PKEY **pubk, int npubk);
622void PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl,
623 unsigned char *in, int inl);
624int PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig,int *sigl,
625 unsigned char *out, int *outl, EVP_PKEY *priv);
626
627void PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type);
628void PEM_SignUpdate(EVP_MD_CTX *ctx,unsigned char *d,unsigned int cnt);
629int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret,
630 unsigned int *siglen, EVP_PKEY *pkey);
631
632int PEM_def_callback(char *buf, int num, int w, void *key);
633void PEM_proc_type(char *buf, int type);
634void PEM_dek_info(char *buf, const char *type, int len, char *str);
635
636#ifndef SSLEAY_MACROS
637
638#include <openssl/symhacks.h>
639
640DECLARE_PEM_rw(X509, X509)
641
642DECLARE_PEM_rw(X509_AUX, X509)
643
644DECLARE_PEM_rw(X509_CERT_PAIR, X509_CERT_PAIR)
645
646DECLARE_PEM_rw(X509_REQ, X509_REQ)
647DECLARE_PEM_write(X509_REQ_NEW, X509_REQ)
648
649DECLARE_PEM_rw(X509_CRL, X509_CRL)
650
651DECLARE_PEM_rw(PKCS7, PKCS7)
652
653DECLARE_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE)
654
655DECLARE_PEM_rw(PKCS8, X509_SIG)
656
657DECLARE_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO)
658
659#ifndef OPENSSL_NO_RSA
660
661DECLARE_PEM_rw_cb(RSAPrivateKey, RSA)
662
663DECLARE_PEM_rw_const(RSAPublicKey, RSA)
664DECLARE_PEM_rw(RSA_PUBKEY, RSA)
665
666#endif
667
668#ifndef OPENSSL_NO_DSA
669
670DECLARE_PEM_rw_cb(DSAPrivateKey, DSA)
671
672DECLARE_PEM_rw(DSA_PUBKEY, DSA)
673
674DECLARE_PEM_rw_const(DSAparams, DSA)
675
676#endif
677
678#ifndef OPENSSL_NO_EC
679DECLARE_PEM_rw_const(ECPKParameters, EC_GROUP)
680DECLARE_PEM_rw_cb(ECPrivateKey, EC_KEY)
681DECLARE_PEM_rw(EC_PUBKEY, EC_KEY)
682#endif
683
684#ifndef OPENSSL_NO_DH
685
686DECLARE_PEM_rw_const(DHparams, DH)
687
688#endif
689
690DECLARE_PEM_rw_cb(PrivateKey, EVP_PKEY)
691
692DECLARE_PEM_rw(PUBKEY, EVP_PKEY)
693
694int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
695 char *kstr, int klen,
696 pem_password_cb *cb, void *u);
697int PEM_write_bio_PKCS8PrivateKey(BIO *, EVP_PKEY *, const EVP_CIPHER *,
698 char *, int, pem_password_cb *, void *);
699int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
700 char *kstr, int klen,
701 pem_password_cb *cb, void *u);
702int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
703 char *kstr, int klen,
704 pem_password_cb *cb, void *u);
705EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u);
706
707int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
708 char *kstr, int klen,
709 pem_password_cb *cb, void *u);
710int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,
711 char *kstr, int klen,
712 pem_password_cb *cb, void *u);
713int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
714 char *kstr, int klen,
715 pem_password_cb *cb, void *u);
716
717EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u);
718
719int PEM_write_PKCS8PrivateKey(FILE *fp,EVP_PKEY *x,const EVP_CIPHER *enc,
720 char *kstr,int klen, pem_password_cb *cd, void *u);
721
722#endif /* SSLEAY_MACROS */
723
724
725/* BEGIN ERROR CODES */
726/* The following lines are auto generated by the script mkerr.pl. Any changes
727 * made after this point may be overwritten when the script is next run.
728 */
729void ERR_load_PEM_strings(void);
730
731/* Error codes for the PEM functions. */
732
733/* Function codes. */
734#define PEM_F_D2I_PKCS8PRIVATEKEY_BIO 120
735#define PEM_F_D2I_PKCS8PRIVATEKEY_FP 121
736#define PEM_F_DO_PK8PKEY 126
737#define PEM_F_DO_PK8PKEY_FP 125
738#define PEM_F_LOAD_IV 101
739#define PEM_F_PEM_ASN1_READ 102
740#define PEM_F_PEM_ASN1_READ_BIO 103
741#define PEM_F_PEM_ASN1_WRITE 104
742#define PEM_F_PEM_ASN1_WRITE_BIO 105
743#define PEM_F_PEM_DEF_CALLBACK 100
744#define PEM_F_PEM_DO_HEADER 106
745#define PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY 118
746#define PEM_F_PEM_GET_EVP_CIPHER_INFO 107
747#define PEM_F_PEM_PK8PKEY 119
748#define PEM_F_PEM_READ 108
749#define PEM_F_PEM_READ_BIO 109
750#define PEM_F_PEM_READ_BIO_PRIVATEKEY 123
751#define PEM_F_PEM_READ_PRIVATEKEY 124
752#define PEM_F_PEM_SEALFINAL 110
753#define PEM_F_PEM_SEALINIT 111
754#define PEM_F_PEM_SIGNFINAL 112
755#define PEM_F_PEM_WRITE 113
756#define PEM_F_PEM_WRITE_BIO 114
757#define PEM_F_PEM_X509_INFO_READ 115
758#define PEM_F_PEM_X509_INFO_READ_BIO 116
759#define PEM_F_PEM_X509_INFO_WRITE_BIO 117
760
761/* Reason codes. */
762#define PEM_R_BAD_BASE64_DECODE 100
763#define PEM_R_BAD_DECRYPT 101
764#define PEM_R_BAD_END_LINE 102
765#define PEM_R_BAD_IV_CHARS 103
766#define PEM_R_BAD_PASSWORD_READ 104
767#define PEM_R_ERROR_CONVERTING_PRIVATE_KEY 115
768#define PEM_R_NOT_DEK_INFO 105
769#define PEM_R_NOT_ENCRYPTED 106
770#define PEM_R_NOT_PROC_TYPE 107
771#define PEM_R_NO_START_LINE 108
772#define PEM_R_PROBLEMS_GETTING_PASSWORD 109
773#define PEM_R_PUBLIC_KEY_NO_RSA 110
774#define PEM_R_READ_KEY 111
775#define PEM_R_SHORT_HEADER 112
776#define PEM_R_UNSUPPORTED_CIPHER 113
777#define PEM_R_UNSUPPORTED_ENCRYPTION 114
778
779#ifdef __cplusplus
780}
781#endif
782#endif
diff --git a/src/lib/libcrypto/pem/pem2.h b/src/lib/libcrypto/pem/pem2.h
deleted file mode 100644
index f31790d69c..0000000000
--- a/src/lib/libcrypto/pem/pem2.h
+++ /dev/null
@@ -1,70 +0,0 @@
1/* ====================================================================
2 * Copyright (c) 1999 The OpenSSL Project. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in
13 * the documentation and/or other materials provided with the
14 * distribution.
15 *
16 * 3. All advertising materials mentioning features or use of this
17 * software must display the following acknowledgment:
18 * "This product includes software developed by the OpenSSL Project
19 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
20 *
21 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22 * endorse or promote products derived from this software without
23 * prior written permission. For written permission, please contact
24 * licensing@OpenSSL.org.
25 *
26 * 5. Products derived from this software may not be called "OpenSSL"
27 * nor may "OpenSSL" appear in their names without prior written
28 * permission of the OpenSSL Project.
29 *
30 * 6. Redistributions of any form whatsoever must retain the following
31 * acknowledgment:
32 * "This product includes software developed by the OpenSSL Project
33 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
34 *
35 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
39 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46 * OF THE POSSIBILITY OF SUCH DAMAGE.
47 * ====================================================================
48 *
49 * This product includes cryptographic software written by Eric Young
50 * (eay@cryptsoft.com). This product includes software written by Tim
51 * Hudson (tjh@cryptsoft.com).
52 *
53 */
54
55/*
56 * This header only exists to break a circular dependency between pem and err
57 * Ben 30 Jan 1999.
58 */
59
60#ifdef __cplusplus
61extern "C" {
62#endif
63
64#ifndef HEADER_PEM_H
65void ERR_load_PEM_strings(void);
66#endif
67
68#ifdef __cplusplus
69}
70#endif
diff --git a/src/lib/libcrypto/pem/pem_all.c b/src/lib/libcrypto/pem/pem_all.c
deleted file mode 100644
index 69dd19bf2e..0000000000
--- a/src/lib/libcrypto/pem/pem_all.c
+++ /dev/null
@@ -1,482 +0,0 @@
1/* crypto/pem/pem_all.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 * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
60 *
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
63 * are met:
64 *
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
67 *
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
71 * distribution.
72 *
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
77 *
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
82 *
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
86 *
87 * 6. Redistributions of any form whatsoever must retain the following
88 * acknowledgment:
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91 *
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
105 *
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
109 *
110 */
111
112#include <stdio.h>
113#undef SSLEAY_MACROS
114#include "cryptlib.h"
115#include <openssl/bio.h>
116#include <openssl/evp.h>
117#include <openssl/x509.h>
118#include <openssl/pkcs7.h>
119#include <openssl/pem.h>
120#ifndef OPENSSL_NO_RSA
121#include <openssl/rsa.h>
122#endif
123#ifndef OPENSSL_NO_DSA
124#include <openssl/dsa.h>
125#endif
126#ifndef OPENSSL_NO_DH
127#include <openssl/dh.h>
128#endif
129
130#ifndef OPENSSL_NO_RSA
131static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa);
132#endif
133#ifndef OPENSSL_NO_DSA
134static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa);
135#endif
136
137#ifndef OPENSSL_NO_EC
138static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey);
139#endif
140
141IMPLEMENT_PEM_rw(X509_REQ, X509_REQ, PEM_STRING_X509_REQ, X509_REQ)
142
143IMPLEMENT_PEM_write(X509_REQ_NEW, X509_REQ, PEM_STRING_X509_REQ_OLD, X509_REQ)
144
145IMPLEMENT_PEM_rw(X509_CRL, X509_CRL, PEM_STRING_X509_CRL, X509_CRL)
146
147IMPLEMENT_PEM_rw(PKCS7, PKCS7, PEM_STRING_PKCS7, PKCS7)
148
149IMPLEMENT_PEM_rw(NETSCAPE_CERT_SEQUENCE, NETSCAPE_CERT_SEQUENCE,
150 PEM_STRING_X509, NETSCAPE_CERT_SEQUENCE)
151
152
153#ifndef OPENSSL_NO_RSA
154
155/* We treat RSA or DSA private keys as a special case.
156 *
157 * For private keys we read in an EVP_PKEY structure with
158 * PEM_read_bio_PrivateKey() and extract the relevant private
159 * key: this means can handle "traditional" and PKCS#8 formats
160 * transparently.
161 */
162
163static RSA *pkey_get_rsa(EVP_PKEY *key, RSA **rsa)
164{
165 RSA *rtmp;
166 if(!key) return NULL;
167 rtmp = EVP_PKEY_get1_RSA(key);
168 EVP_PKEY_free(key);
169 if(!rtmp) return NULL;
170 if(rsa) {
171 RSA_free(*rsa);
172 *rsa = rtmp;
173 }
174 return rtmp;
175}
176
177RSA *PEM_read_bio_RSAPrivateKey(BIO *bp, RSA **rsa, pem_password_cb *cb,
178 void *u)
179{
180 EVP_PKEY *pktmp;
181 pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
182 return pkey_get_rsa(pktmp, rsa);
183}
184
185#ifndef OPENSSL_NO_FP_API
186
187RSA *PEM_read_RSAPrivateKey(FILE *fp, RSA **rsa, pem_password_cb *cb,
188 void *u)
189{
190 EVP_PKEY *pktmp;
191 pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
192 return pkey_get_rsa(pktmp, rsa);
193}
194
195#endif
196
197#ifdef OPENSSL_FIPS
198
199int PEM_write_bio_RSAPrivateKey(BIO *bp, RSA *x, const EVP_CIPHER *enc,
200 unsigned char *kstr, int klen,
201 pem_password_cb *cb, void *u)
202{
203 EVP_PKEY *k;
204 int ret;
205 k = EVP_PKEY_new();
206 if (!k)
207 return 0;
208 EVP_PKEY_set1_RSA(k, x);
209
210 ret = PEM_write_bio_PrivateKey(bp, k, enc, kstr, klen, cb, u);
211 EVP_PKEY_free(k);
212 return ret;
213}
214
215#ifndef OPENSSL_NO_FP_API
216int PEM_write_RSAPrivateKey(FILE *fp, RSA *x, const EVP_CIPHER *enc,
217 unsigned char *kstr, int klen,
218 pem_password_cb *cb, void *u)
219{
220 EVP_PKEY *k;
221 int ret;
222 k = EVP_PKEY_new();
223 if (!k)
224 return 0;
225
226 EVP_PKEY_set1_RSA(k, x);
227
228 ret = PEM_write_PrivateKey(fp, k, enc, kstr, klen, cb, u);
229 EVP_PKEY_free(k);
230 return ret;
231}
232#endif
233
234#else
235
236IMPLEMENT_PEM_write_cb_const(RSAPrivateKey, RSA, PEM_STRING_RSA, RSAPrivateKey)
237
238#endif
239
240IMPLEMENT_PEM_rw_const(RSAPublicKey, RSA, PEM_STRING_RSA_PUBLIC, RSAPublicKey)
241IMPLEMENT_PEM_rw(RSA_PUBKEY, RSA, PEM_STRING_PUBLIC, RSA_PUBKEY)
242
243#endif
244
245#ifndef OPENSSL_NO_DSA
246
247static DSA *pkey_get_dsa(EVP_PKEY *key, DSA **dsa)
248{
249 DSA *dtmp;
250 if(!key) return NULL;
251 dtmp = EVP_PKEY_get1_DSA(key);
252 EVP_PKEY_free(key);
253 if(!dtmp) return NULL;
254 if(dsa) {
255 DSA_free(*dsa);
256 *dsa = dtmp;
257 }
258 return dtmp;
259}
260
261DSA *PEM_read_bio_DSAPrivateKey(BIO *bp, DSA **dsa, pem_password_cb *cb,
262 void *u)
263{
264 EVP_PKEY *pktmp;
265 pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
266 return pkey_get_dsa(pktmp, dsa);
267}
268
269#ifdef OPENSSL_FIPS
270
271int PEM_write_bio_DSAPrivateKey(BIO *bp, DSA *x, const EVP_CIPHER *enc,
272 unsigned char *kstr, int klen,
273 pem_password_cb *cb, void *u)
274{
275 EVP_PKEY *k;
276 int ret;
277 k = EVP_PKEY_new();
278 if (!k)
279 return 0;
280 EVP_PKEY_set1_DSA(k, x);
281
282 ret = PEM_write_bio_PrivateKey(bp, k, enc, kstr, klen, cb, u);
283 EVP_PKEY_free(k);
284 return ret;
285}
286
287#ifndef OPENSSL_NO_FP_API
288int PEM_write_DSAPrivateKey(FILE *fp, DSA *x, const EVP_CIPHER *enc,
289 unsigned char *kstr, int klen,
290 pem_password_cb *cb, void *u)
291{
292 EVP_PKEY *k;
293 int ret;
294 k = EVP_PKEY_new();
295 if (!k)
296 return 0;
297 EVP_PKEY_set1_DSA(k, x);
298 ret = PEM_write_PrivateKey(fp, k, enc, kstr, klen, cb, u);
299 EVP_PKEY_free(k);
300 return ret;
301}
302#endif
303
304#else
305
306IMPLEMENT_PEM_write_cb_const(DSAPrivateKey, DSA, PEM_STRING_DSA, DSAPrivateKey)
307
308#endif
309
310IMPLEMENT_PEM_rw(DSA_PUBKEY, DSA, PEM_STRING_PUBLIC, DSA_PUBKEY)
311
312#ifndef OPENSSL_NO_FP_API
313
314DSA *PEM_read_DSAPrivateKey(FILE *fp, DSA **dsa, pem_password_cb *cb,
315 void *u)
316{
317 EVP_PKEY *pktmp;
318 pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
319 return pkey_get_dsa(pktmp, dsa);
320}
321
322#endif
323
324IMPLEMENT_PEM_rw_const(DSAparams, DSA, PEM_STRING_DSAPARAMS, DSAparams)
325
326#endif
327
328
329#ifndef OPENSSL_NO_EC
330static EC_KEY *pkey_get_eckey(EVP_PKEY *key, EC_KEY **eckey)
331{
332 EC_KEY *dtmp;
333 if(!key) return NULL;
334 dtmp = EVP_PKEY_get1_EC_KEY(key);
335 EVP_PKEY_free(key);
336 if(!dtmp) return NULL;
337 if(eckey)
338 {
339 EC_KEY_free(*eckey);
340 *eckey = dtmp;
341 }
342 return dtmp;
343}
344
345EC_KEY *PEM_read_bio_ECPrivateKey(BIO *bp, EC_KEY **key, pem_password_cb *cb,
346 void *u)
347{
348 EVP_PKEY *pktmp;
349 pktmp = PEM_read_bio_PrivateKey(bp, NULL, cb, u);
350 return pkey_get_eckey(pktmp, key);
351}
352
353IMPLEMENT_PEM_rw_const(ECPKParameters, EC_GROUP, PEM_STRING_ECPARAMETERS, ECPKParameters)
354
355
356
357#ifdef OPENSSL_FIPS
358
359int PEM_write_bio_ECPrivateKey(BIO *bp, EC_KEY *x, const EVP_CIPHER *enc,
360 unsigned char *kstr, int klen,
361 pem_password_cb *cb, void *u)
362{
363 EVP_PKEY *k;
364 int ret;
365 k = EVP_PKEY_new();
366 if (!k)
367 return 0;
368 EVP_PKEY_set1_EC_KEY(k, x);
369
370 ret = PEM_write_bio_PrivateKey(bp, k, enc, kstr, klen, cb, u);
371 EVP_PKEY_free(k);
372 return ret;
373}
374
375#ifndef OPENSSL_NO_FP_API
376int PEM_write_ECPrivateKey(FILE *fp, EC_KEY *x, const EVP_CIPHER *enc,
377 unsigned char *kstr, int klen,
378 pem_password_cb *cb, void *u)
379{
380 EVP_PKEY *k;
381 int ret;
382 k = EVP_PKEY_new();
383 if (!k)
384 return 0;
385 EVP_PKEY_set1_EC_KEY(k, x);
386 ret = PEM_write_PrivateKey(fp, k, enc, kstr, klen, cb, u);
387 EVP_PKEY_free(k);
388 return ret;
389}
390#endif
391
392#else
393
394IMPLEMENT_PEM_write_cb(ECPrivateKey, EC_KEY, PEM_STRING_ECPRIVATEKEY, ECPrivateKey)
395
396#endif
397
398IMPLEMENT_PEM_rw(EC_PUBKEY, EC_KEY, PEM_STRING_PUBLIC, EC_PUBKEY)
399
400#ifndef OPENSSL_NO_FP_API
401
402EC_KEY *PEM_read_ECPrivateKey(FILE *fp, EC_KEY **eckey, pem_password_cb *cb,
403 void *u)
404{
405 EVP_PKEY *pktmp;
406 pktmp = PEM_read_PrivateKey(fp, NULL, cb, u);
407 return pkey_get_eckey(pktmp, eckey);
408}
409
410#endif
411
412#endif
413
414#ifndef OPENSSL_NO_DH
415
416IMPLEMENT_PEM_rw_const(DHparams, DH, PEM_STRING_DHPARAMS, DHparams)
417
418#endif
419
420
421/* The PrivateKey case is not that straightforward.
422 * IMPLEMENT_PEM_rw_cb(PrivateKey, EVP_PKEY, PEM_STRING_EVP_PKEY, PrivateKey)
423 * does not work, RSA and DSA keys have specific strings.
424 * (When reading, parameter PEM_STRING_EVP_PKEY is a wildcard for anything
425 * appropriate.)
426 */
427
428#ifdef OPENSSL_FIPS
429
430static const char *pkey_str(EVP_PKEY *x)
431 {
432 switch (x->type)
433 {
434 case EVP_PKEY_RSA:
435 return PEM_STRING_RSA;
436
437 case EVP_PKEY_DSA:
438 return PEM_STRING_DSA;
439
440 case EVP_PKEY_EC:
441 return PEM_STRING_ECPRIVATEKEY;
442
443 default:
444 return NULL;
445 }
446 }
447
448
449int PEM_write_bio_PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
450 unsigned char *kstr, int klen,
451 pem_password_cb *cb, void *u)
452 {
453 if (FIPS_mode())
454 return PEM_write_bio_PKCS8PrivateKey(bp, x, enc,
455 (char *)kstr, klen, cb, u);
456 else
457 return PEM_ASN1_write_bio((i2d_of_void *)i2d_PrivateKey,
458 pkey_str(x), bp,(char *)x,enc,kstr,klen,cb,u);
459 }
460
461#ifndef OPENSSL_NO_FP_API
462int PEM_write_PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
463 unsigned char *kstr, int klen,
464 pem_password_cb *cb, void *u)
465 {
466 if (FIPS_mode())
467 return PEM_write_PKCS8PrivateKey(fp, x, enc,
468 (char *)kstr, klen, cb, u);
469 else
470 return PEM_ASN1_write((i2d_of_void *)i2d_PrivateKey,
471 pkey_str(x), fp,(char *)x,enc,kstr,klen,cb,u);
472 }
473#endif
474
475#else
476IMPLEMENT_PEM_write_cb(PrivateKey, EVP_PKEY, ((x->type == EVP_PKEY_DSA)?PEM_STRING_DSA:\
477 (x->type == EVP_PKEY_RSA)?PEM_STRING_RSA:PEM_STRING_ECPRIVATEKEY), PrivateKey)
478
479#endif
480
481IMPLEMENT_PEM_rw(PUBKEY, EVP_PKEY, PEM_STRING_PUBLIC, PUBKEY)
482
diff --git a/src/lib/libcrypto/pem/pem_err.c b/src/lib/libcrypto/pem/pem_err.c
deleted file mode 100644
index 3133563d77..0000000000
--- a/src/lib/libcrypto/pem/pem_err.c
+++ /dev/null
@@ -1,135 +0,0 @@
1/* crypto/pem/pem_err.c */
2/* ====================================================================
3 * Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
15 * distribution.
16 *
17 * 3. All advertising materials mentioning features or use of this
18 * software must display the following acknowledgment:
19 * "This product includes software developed by the OpenSSL Project
20 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
21 *
22 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
23 * endorse or promote products derived from this software without
24 * prior written permission. For written permission, please contact
25 * openssl-core@OpenSSL.org.
26 *
27 * 5. Products derived from this software may not be called "OpenSSL"
28 * nor may "OpenSSL" appear in their names without prior written
29 * permission of the OpenSSL Project.
30 *
31 * 6. Redistributions of any form whatsoever must retain the following
32 * acknowledgment:
33 * "This product includes software developed by the OpenSSL Project
34 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
35 *
36 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
37 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
38 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
39 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
40 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
42 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
43 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
45 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
46 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
47 * OF THE POSSIBILITY OF SUCH DAMAGE.
48 * ====================================================================
49 *
50 * This product includes cryptographic software written by Eric Young
51 * (eay@cryptsoft.com). This product includes software written by Tim
52 * Hudson (tjh@cryptsoft.com).
53 *
54 */
55
56/* NOTE: this file was auto generated by the mkerr.pl script: any changes
57 * made to it will be overwritten when the script next updates this file,
58 * only reason strings will be preserved.
59 */
60
61#include <stdio.h>
62#include <openssl/err.h>
63#include <openssl/pem.h>
64
65/* BEGIN ERROR CODES */
66#ifndef OPENSSL_NO_ERR
67
68#define ERR_FUNC(func) ERR_PACK(ERR_LIB_PEM,func,0)
69#define ERR_REASON(reason) ERR_PACK(ERR_LIB_PEM,0,reason)
70
71static ERR_STRING_DATA PEM_str_functs[]=
72 {
73{ERR_FUNC(PEM_F_D2I_PKCS8PRIVATEKEY_BIO), "d2i_PKCS8PrivateKey_bio"},
74{ERR_FUNC(PEM_F_D2I_PKCS8PRIVATEKEY_FP), "d2i_PKCS8PrivateKey_fp"},
75{ERR_FUNC(PEM_F_DO_PK8PKEY), "DO_PK8PKEY"},
76{ERR_FUNC(PEM_F_DO_PK8PKEY_FP), "DO_PK8PKEY_FP"},
77{ERR_FUNC(PEM_F_LOAD_IV), "LOAD_IV"},
78{ERR_FUNC(PEM_F_PEM_ASN1_READ), "PEM_ASN1_read"},
79{ERR_FUNC(PEM_F_PEM_ASN1_READ_BIO), "PEM_ASN1_read_bio"},
80{ERR_FUNC(PEM_F_PEM_ASN1_WRITE), "PEM_ASN1_write"},
81{ERR_FUNC(PEM_F_PEM_ASN1_WRITE_BIO), "PEM_ASN1_write_bio"},
82{ERR_FUNC(PEM_F_PEM_DEF_CALLBACK), "PEM_def_callback"},
83{ERR_FUNC(PEM_F_PEM_DO_HEADER), "PEM_do_header"},
84{ERR_FUNC(PEM_F_PEM_F_PEM_WRITE_PKCS8PRIVATEKEY), "PEM_F_PEM_WRITE_PKCS8PRIVATEKEY"},
85{ERR_FUNC(PEM_F_PEM_GET_EVP_CIPHER_INFO), "PEM_get_EVP_CIPHER_INFO"},
86{ERR_FUNC(PEM_F_PEM_PK8PKEY), "PEM_PK8PKEY"},
87{ERR_FUNC(PEM_F_PEM_READ), "PEM_read"},
88{ERR_FUNC(PEM_F_PEM_READ_BIO), "PEM_read_bio"},
89{ERR_FUNC(PEM_F_PEM_READ_BIO_PRIVATEKEY), "PEM_READ_BIO_PRIVATEKEY"},
90{ERR_FUNC(PEM_F_PEM_READ_PRIVATEKEY), "PEM_READ_PRIVATEKEY"},
91{ERR_FUNC(PEM_F_PEM_SEALFINAL), "PEM_SealFinal"},
92{ERR_FUNC(PEM_F_PEM_SEALINIT), "PEM_SealInit"},
93{ERR_FUNC(PEM_F_PEM_SIGNFINAL), "PEM_SignFinal"},
94{ERR_FUNC(PEM_F_PEM_WRITE), "PEM_write"},
95{ERR_FUNC(PEM_F_PEM_WRITE_BIO), "PEM_write_bio"},
96{ERR_FUNC(PEM_F_PEM_X509_INFO_READ), "PEM_X509_INFO_read"},
97{ERR_FUNC(PEM_F_PEM_X509_INFO_READ_BIO), "PEM_X509_INFO_read_bio"},
98{ERR_FUNC(PEM_F_PEM_X509_INFO_WRITE_BIO), "PEM_X509_INFO_write_bio"},
99{0,NULL}
100 };
101
102static ERR_STRING_DATA PEM_str_reasons[]=
103 {
104{ERR_REASON(PEM_R_BAD_BASE64_DECODE) ,"bad base64 decode"},
105{ERR_REASON(PEM_R_BAD_DECRYPT) ,"bad decrypt"},
106{ERR_REASON(PEM_R_BAD_END_LINE) ,"bad end line"},
107{ERR_REASON(PEM_R_BAD_IV_CHARS) ,"bad iv chars"},
108{ERR_REASON(PEM_R_BAD_PASSWORD_READ) ,"bad password read"},
109{ERR_REASON(PEM_R_ERROR_CONVERTING_PRIVATE_KEY),"error converting private key"},
110{ERR_REASON(PEM_R_NOT_DEK_INFO) ,"not dek info"},
111{ERR_REASON(PEM_R_NOT_ENCRYPTED) ,"not encrypted"},
112{ERR_REASON(PEM_R_NOT_PROC_TYPE) ,"not proc type"},
113{ERR_REASON(PEM_R_NO_START_LINE) ,"no start line"},
114{ERR_REASON(PEM_R_PROBLEMS_GETTING_PASSWORD),"problems getting password"},
115{ERR_REASON(PEM_R_PUBLIC_KEY_NO_RSA) ,"public key no rsa"},
116{ERR_REASON(PEM_R_READ_KEY) ,"read key"},
117{ERR_REASON(PEM_R_SHORT_HEADER) ,"short header"},
118{ERR_REASON(PEM_R_UNSUPPORTED_CIPHER) ,"unsupported cipher"},
119{ERR_REASON(PEM_R_UNSUPPORTED_ENCRYPTION),"unsupported encryption"},
120{0,NULL}
121 };
122
123#endif
124
125void ERR_load_PEM_strings(void)
126 {
127#ifndef OPENSSL_NO_ERR
128
129 if (ERR_func_error_string(PEM_str_functs[0].error) == NULL)
130 {
131 ERR_load_strings(0,PEM_str_functs);
132 ERR_load_strings(0,PEM_str_reasons);
133 }
134#endif
135 }
diff --git a/src/lib/libcrypto/pem/pem_info.c b/src/lib/libcrypto/pem/pem_info.c
deleted file mode 100644
index 3a273f6f70..0000000000
--- a/src/lib/libcrypto/pem/pem_info.c
+++ /dev/null
@@ -1,397 +0,0 @@
1/* crypto/pem/pem_info.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 "cryptlib.h"
61#include <openssl/buffer.h>
62#include <openssl/objects.h>
63#include <openssl/evp.h>
64#include <openssl/x509.h>
65#include <openssl/pem.h>
66#ifndef OPENSSL_NO_RSA
67#include <openssl/rsa.h>
68#endif
69#ifndef OPENSSL_NO_DSA
70#include <openssl/dsa.h>
71#endif
72
73#ifndef OPENSSL_NO_FP_API
74STACK_OF(X509_INFO) *PEM_X509_INFO_read(FILE *fp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u)
75 {
76 BIO *b;
77 STACK_OF(X509_INFO) *ret;
78
79 if ((b=BIO_new(BIO_s_file())) == NULL)
80 {
81 PEMerr(PEM_F_PEM_X509_INFO_READ,ERR_R_BUF_LIB);
82 return(0);
83 }
84 BIO_set_fp(b,fp,BIO_NOCLOSE);
85 ret=PEM_X509_INFO_read_bio(b,sk,cb,u);
86 BIO_free(b);
87 return(ret);
88 }
89#endif
90
91STACK_OF(X509_INFO) *PEM_X509_INFO_read_bio(BIO *bp, STACK_OF(X509_INFO) *sk, pem_password_cb *cb, void *u)
92 {
93 X509_INFO *xi=NULL;
94 char *name=NULL,*header=NULL;
95 void *pp;
96 unsigned char *data=NULL;
97 const unsigned char *p;
98 long len,error=0;
99 int ok=0;
100 STACK_OF(X509_INFO) *ret=NULL;
101 unsigned int i,raw;
102 d2i_of_void *d2i;
103
104 if (sk == NULL)
105 {
106 if ((ret=sk_X509_INFO_new_null()) == NULL)
107 {
108 PEMerr(PEM_F_PEM_X509_INFO_READ_BIO,ERR_R_MALLOC_FAILURE);
109 goto err;
110 }
111 }
112 else
113 ret=sk;
114
115 if ((xi=X509_INFO_new()) == NULL) goto err;
116 for (;;)
117 {
118 raw=0;
119 i=PEM_read_bio(bp,&name,&header,&data,&len);
120 if (i == 0)
121 {
122 error=ERR_GET_REASON(ERR_peek_last_error());
123 if (error == PEM_R_NO_START_LINE)
124 {
125 ERR_clear_error();
126 break;
127 }
128 goto err;
129 }
130start:
131 if ( (strcmp(name,PEM_STRING_X509) == 0) ||
132 (strcmp(name,PEM_STRING_X509_OLD) == 0))
133 {
134 d2i=(D2I_OF(void))d2i_X509;
135 if (xi->x509 != NULL)
136 {
137 if (!sk_X509_INFO_push(ret,xi)) goto err;
138 if ((xi=X509_INFO_new()) == NULL) goto err;
139 goto start;
140 }
141 pp=&(xi->x509);
142 }
143 else if ((strcmp(name,PEM_STRING_X509_TRUSTED) == 0))
144 {
145 d2i=(D2I_OF(void))d2i_X509_AUX;
146 if (xi->x509 != NULL)
147 {
148 if (!sk_X509_INFO_push(ret,xi)) goto err;
149 if ((xi=X509_INFO_new()) == NULL) goto err;
150 goto start;
151 }
152 pp=&(xi->x509);
153 }
154 else if (strcmp(name,PEM_STRING_X509_CRL) == 0)
155 {
156 d2i=(D2I_OF(void))d2i_X509_CRL;
157 if (xi->crl != NULL)
158 {
159 if (!sk_X509_INFO_push(ret,xi)) goto err;
160 if ((xi=X509_INFO_new()) == NULL) goto err;
161 goto start;
162 }
163 pp=&(xi->crl);
164 }
165 else
166#ifndef OPENSSL_NO_RSA
167 if (strcmp(name,PEM_STRING_RSA) == 0)
168 {
169 d2i=(D2I_OF(void))d2i_RSAPrivateKey;
170 if (xi->x_pkey != NULL)
171 {
172 if (!sk_X509_INFO_push(ret,xi)) goto err;
173 if ((xi=X509_INFO_new()) == NULL) goto err;
174 goto start;
175 }
176
177 xi->enc_data=NULL;
178 xi->enc_len=0;
179
180 xi->x_pkey=X509_PKEY_new();
181 if ((xi->x_pkey->dec_pkey=EVP_PKEY_new()) == NULL)
182 goto err;
183 xi->x_pkey->dec_pkey->type=EVP_PKEY_RSA;
184 pp=&(xi->x_pkey->dec_pkey->pkey.rsa);
185 if ((int)strlen(header) > 10) /* assume encrypted */
186 raw=1;
187 }
188 else
189#endif
190#ifndef OPENSSL_NO_DSA
191 if (strcmp(name,PEM_STRING_DSA) == 0)
192 {
193 d2i=(D2I_OF(void))d2i_DSAPrivateKey;
194 if (xi->x_pkey != NULL)
195 {
196 if (!sk_X509_INFO_push(ret,xi)) goto err;
197 if ((xi=X509_INFO_new()) == NULL) goto err;
198 goto start;
199 }
200
201 xi->enc_data=NULL;
202 xi->enc_len=0;
203
204 xi->x_pkey=X509_PKEY_new();
205 if ((xi->x_pkey->dec_pkey=EVP_PKEY_new()) == NULL)
206 goto err;
207 xi->x_pkey->dec_pkey->type=EVP_PKEY_DSA;
208 pp=&xi->x_pkey->dec_pkey->pkey.dsa;
209 if ((int)strlen(header) > 10) /* assume encrypted */
210 raw=1;
211 }
212 else
213#endif
214#ifndef OPENSSL_NO_EC
215 if (strcmp(name,PEM_STRING_ECPRIVATEKEY) == 0)
216 {
217 d2i=(D2I_OF(void))d2i_ECPrivateKey;
218 if (xi->x_pkey != NULL)
219 {
220 if (!sk_X509_INFO_push(ret,xi)) goto err;
221 if ((xi=X509_INFO_new()) == NULL) goto err;
222 goto start;
223 }
224
225 xi->enc_data=NULL;
226 xi->enc_len=0;
227
228 xi->x_pkey=X509_PKEY_new();
229 if ((xi->x_pkey->dec_pkey=EVP_PKEY_new()) == NULL)
230 goto err;
231 xi->x_pkey->dec_pkey->type=EVP_PKEY_EC;
232 pp=&(xi->x_pkey->dec_pkey->pkey.ec);
233 if ((int)strlen(header) > 10) /* assume encrypted */
234 raw=1;
235 }
236 else
237#endif
238 {
239 d2i=NULL;
240 pp=NULL;
241 }
242
243 if (d2i != NULL)
244 {
245 if (!raw)
246 {
247 EVP_CIPHER_INFO cipher;
248
249 if (!PEM_get_EVP_CIPHER_INFO(header,&cipher))
250 goto err;
251 if (!PEM_do_header(&cipher,data,&len,cb,u))
252 goto err;
253 p=data;
254 if (d2i(pp,&p,len) == NULL)
255 {
256 PEMerr(PEM_F_PEM_X509_INFO_READ_BIO,ERR_R_ASN1_LIB);
257 goto err;
258 }
259 }
260 else
261 { /* encrypted RSA data */
262 if (!PEM_get_EVP_CIPHER_INFO(header,
263 &xi->enc_cipher)) goto err;
264 xi->enc_data=(char *)data;
265 xi->enc_len=(int)len;
266 data=NULL;
267 }
268 }
269 else {
270 /* unknown */
271 }
272 if (name != NULL) OPENSSL_free(name);
273 if (header != NULL) OPENSSL_free(header);
274 if (data != NULL) OPENSSL_free(data);
275 name=NULL;
276 header=NULL;
277 data=NULL;
278 }
279
280 /* if the last one hasn't been pushed yet and there is anything
281 * in it then add it to the stack ...
282 */
283 if ((xi->x509 != NULL) || (xi->crl != NULL) ||
284 (xi->x_pkey != NULL) || (xi->enc_data != NULL))
285 {
286 if (!sk_X509_INFO_push(ret,xi)) goto err;
287 xi=NULL;
288 }
289 ok=1;
290err:
291 if (xi != NULL) X509_INFO_free(xi);
292 if (!ok)
293 {
294 for (i=0; ((int)i)<sk_X509_INFO_num(ret); i++)
295 {
296 xi=sk_X509_INFO_value(ret,i);
297 X509_INFO_free(xi);
298 }
299 if (ret != sk) sk_X509_INFO_free(ret);
300 ret=NULL;
301 }
302
303 if (name != NULL) OPENSSL_free(name);
304 if (header != NULL) OPENSSL_free(header);
305 if (data != NULL) OPENSSL_free(data);
306 return(ret);
307 }
308
309
310/* A TJH addition */
311int PEM_X509_INFO_write_bio(BIO *bp, X509_INFO *xi, EVP_CIPHER *enc,
312 unsigned char *kstr, int klen, pem_password_cb *cb, void *u)
313 {
314 EVP_CIPHER_CTX ctx;
315 int i,ret=0;
316 unsigned char *data=NULL;
317 const char *objstr=NULL;
318 char buf[PEM_BUFSIZE];
319 unsigned char *iv=NULL;
320
321 if (enc != NULL)
322 {
323 objstr=OBJ_nid2sn(EVP_CIPHER_nid(enc));
324 if (objstr == NULL)
325 {
326 PEMerr(PEM_F_PEM_X509_INFO_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
327 goto err;
328 }
329 }
330
331 /* now for the fun part ... if we have a private key then
332 * we have to be able to handle a not-yet-decrypted key
333 * being written out correctly ... if it is decrypted or
334 * it is non-encrypted then we use the base code
335 */
336 if (xi->x_pkey!=NULL)
337 {
338 if ( (xi->enc_data!=NULL) && (xi->enc_len>0) )
339 {
340 /* copy from weirdo names into more normal things */
341 iv=xi->enc_cipher.iv;
342 data=(unsigned char *)xi->enc_data;
343 i=xi->enc_len;
344
345 /* we take the encryption data from the
346 * internal stuff rather than what the
347 * user has passed us ... as we have to
348 * match exactly for some strange reason
349 */
350 objstr=OBJ_nid2sn(
351 EVP_CIPHER_nid(xi->enc_cipher.cipher));
352 if (objstr == NULL)
353 {
354 PEMerr(PEM_F_PEM_X509_INFO_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
355 goto err;
356 }
357
358 /* create the right magic header stuff */
359 OPENSSL_assert(strlen(objstr)+23+2*enc->iv_len+13 <= sizeof buf);
360 buf[0]='\0';
361 PEM_proc_type(buf,PEM_TYPE_ENCRYPTED);
362 PEM_dek_info(buf,objstr,enc->iv_len,(char *)iv);
363
364 /* use the normal code to write things out */
365 i=PEM_write_bio(bp,PEM_STRING_RSA,buf,data,i);
366 if (i <= 0) goto err;
367 }
368 else
369 {
370 /* Add DSA/DH */
371#ifndef OPENSSL_NO_RSA
372 /* normal optionally encrypted stuff */
373 if (PEM_write_bio_RSAPrivateKey(bp,
374 xi->x_pkey->dec_pkey->pkey.rsa,
375 enc,kstr,klen,cb,u)<=0)
376 goto err;
377#endif
378 }
379 }
380
381 /* if we have a certificate then write it out now */
382 if ((xi->x509 != NULL) && (PEM_write_bio_X509(bp,xi->x509) <= 0))
383 goto err;
384
385 /* we are ignoring anything else that is loaded into the X509_INFO
386 * structure for the moment ... as I don't need it so I'm not
387 * coding it here and Eric can do it when this makes it into the
388 * base library --tjh
389 */
390
391 ret=1;
392
393err:
394 OPENSSL_cleanse((char *)&ctx,sizeof(ctx));
395 OPENSSL_cleanse(buf,PEM_BUFSIZE);
396 return(ret);
397 }
diff --git a/src/lib/libcrypto/pem/pem_lib.c b/src/lib/libcrypto/pem/pem_lib.c
deleted file mode 100644
index cbafefe416..0000000000
--- a/src/lib/libcrypto/pem/pem_lib.c
+++ /dev/null
@@ -1,784 +0,0 @@
1/* crypto/pem/pem_lib.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 "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/pem.h>
67#include <openssl/pkcs12.h>
68#ifndef OPENSSL_NO_DES
69#include <openssl/des.h>
70#endif
71
72const char PEM_version[]="PEM" OPENSSL_VERSION_PTEXT;
73
74#define MIN_LENGTH 4
75
76static int load_iv(char **fromp,unsigned char *to, int num);
77static int check_pem(const char *nm, const char *name);
78
79int PEM_def_callback(char *buf, int num, int w, void *key)
80 {
81#ifdef OPENSSL_NO_FP_API
82 /* We should not ever call the default callback routine from
83 * windows. */
84 PEMerr(PEM_F_PEM_DEF_CALLBACK,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
85 return(-1);
86#else
87 int i,j;
88 const char *prompt;
89 if(key) {
90 i=strlen(key);
91 i=(i > num)?num:i;
92 memcpy(buf,key,i);
93 return(i);
94 }
95
96 prompt=EVP_get_pw_prompt();
97 if (prompt == NULL)
98 prompt="Enter PEM pass phrase:";
99
100 for (;;)
101 {
102 i=EVP_read_pw_string(buf,num,prompt,w);
103 if (i != 0)
104 {
105 PEMerr(PEM_F_PEM_DEF_CALLBACK,PEM_R_PROBLEMS_GETTING_PASSWORD);
106 memset(buf,0,(unsigned int)num);
107 return(-1);
108 }
109 j=strlen(buf);
110 if (j < MIN_LENGTH)
111 {
112 fprintf(stderr,"phrase is too short, needs to be at least %d chars\n",MIN_LENGTH);
113 }
114 else
115 break;
116 }
117 return(j);
118#endif
119 }
120
121void PEM_proc_type(char *buf, int type)
122 {
123 const char *str;
124
125 if (type == PEM_TYPE_ENCRYPTED)
126 str="ENCRYPTED";
127 else if (type == PEM_TYPE_MIC_CLEAR)
128 str="MIC-CLEAR";
129 else if (type == PEM_TYPE_MIC_ONLY)
130 str="MIC-ONLY";
131 else
132 str="BAD-TYPE";
133
134 BUF_strlcat(buf,"Proc-Type: 4,",PEM_BUFSIZE);
135 BUF_strlcat(buf,str,PEM_BUFSIZE);
136 BUF_strlcat(buf,"\n",PEM_BUFSIZE);
137 }
138
139void PEM_dek_info(char *buf, const char *type, int len, char *str)
140 {
141 static const unsigned char map[17]="0123456789ABCDEF";
142 long i;
143 int j;
144
145 BUF_strlcat(buf,"DEK-Info: ",PEM_BUFSIZE);
146 BUF_strlcat(buf,type,PEM_BUFSIZE);
147 BUF_strlcat(buf,",",PEM_BUFSIZE);
148 j=strlen(buf);
149 if (j + (len * 2) + 1 > PEM_BUFSIZE)
150 return;
151 for (i=0; i<len; i++)
152 {
153 buf[j+i*2] =map[(str[i]>>4)&0x0f];
154 buf[j+i*2+1]=map[(str[i] )&0x0f];
155 }
156 buf[j+i*2]='\n';
157 buf[j+i*2+1]='\0';
158 }
159
160#ifndef OPENSSL_NO_FP_API
161void *PEM_ASN1_read(d2i_of_void *d2i, const char *name, FILE *fp, void **x,
162 pem_password_cb *cb, void *u)
163 {
164 BIO *b;
165 void *ret;
166
167 if ((b=BIO_new(BIO_s_file())) == NULL)
168 {
169 PEMerr(PEM_F_PEM_ASN1_READ,ERR_R_BUF_LIB);
170 return(0);
171 }
172 BIO_set_fp(b,fp,BIO_NOCLOSE);
173 ret=PEM_ASN1_read_bio(d2i,name,b,x,cb,u);
174 BIO_free(b);
175 return(ret);
176 }
177#endif
178
179static int check_pem(const char *nm, const char *name)
180{
181 /* Normal matching nm and name */
182 if (!strcmp(nm,name)) return 1;
183
184 /* Make PEM_STRING_EVP_PKEY match any private key */
185
186 if(!strcmp(nm,PEM_STRING_PKCS8) &&
187 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
188
189 if(!strcmp(nm,PEM_STRING_PKCS8INF) &&
190 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
191
192 if(!strcmp(nm,PEM_STRING_RSA) &&
193 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
194
195 if(!strcmp(nm,PEM_STRING_DSA) &&
196 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
197
198 if(!strcmp(nm,PEM_STRING_ECPRIVATEKEY) &&
199 !strcmp(name,PEM_STRING_EVP_PKEY)) return 1;
200 /* Permit older strings */
201
202 if(!strcmp(nm,PEM_STRING_X509_OLD) &&
203 !strcmp(name,PEM_STRING_X509)) return 1;
204
205 if(!strcmp(nm,PEM_STRING_X509_REQ_OLD) &&
206 !strcmp(name,PEM_STRING_X509_REQ)) return 1;
207
208 /* Allow normal certs to be read as trusted certs */
209 if(!strcmp(nm,PEM_STRING_X509) &&
210 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
211
212 if(!strcmp(nm,PEM_STRING_X509_OLD) &&
213 !strcmp(name,PEM_STRING_X509_TRUSTED)) return 1;
214
215 /* Some CAs use PKCS#7 with CERTIFICATE headers */
216 if(!strcmp(nm, PEM_STRING_X509) &&
217 !strcmp(name, PEM_STRING_PKCS7)) return 1;
218
219 if(!strcmp(nm, PEM_STRING_PKCS7_SIGNED) &&
220 !strcmp(name, PEM_STRING_PKCS7)) return 1;
221
222 return 0;
223}
224
225int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm, const char *name, BIO *bp,
226 pem_password_cb *cb, void *u)
227 {
228 EVP_CIPHER_INFO cipher;
229 char *nm=NULL,*header=NULL;
230 unsigned char *data=NULL;
231 long len;
232 int ret = 0;
233
234 for (;;)
235 {
236 if (!PEM_read_bio(bp,&nm,&header,&data,&len)) {
237 if(ERR_GET_REASON(ERR_peek_error()) ==
238 PEM_R_NO_START_LINE)
239 ERR_add_error_data(2, "Expecting: ", name);
240 return 0;
241 }
242 if(check_pem(nm, name)) break;
243 OPENSSL_free(nm);
244 OPENSSL_free(header);
245 OPENSSL_free(data);
246 }
247 if (!PEM_get_EVP_CIPHER_INFO(header,&cipher)) goto err;
248 if (!PEM_do_header(&cipher,data,&len,cb,u)) goto err;
249
250 *pdata = data;
251 *plen = len;
252
253 if (pnm)
254 *pnm = nm;
255
256 ret = 1;
257
258err:
259 if (!ret || !pnm) OPENSSL_free(nm);
260 OPENSSL_free(header);
261 if (!ret) OPENSSL_free(data);
262 return ret;
263 }
264
265#ifndef OPENSSL_NO_FP_API
266int PEM_ASN1_write(i2d_of_void *i2d, const char *name, FILE *fp,
267 char *x, const EVP_CIPHER *enc, unsigned char *kstr,
268 int klen, pem_password_cb *callback, void *u)
269 {
270 BIO *b;
271 int ret;
272
273 if ((b=BIO_new(BIO_s_file())) == NULL)
274 {
275 PEMerr(PEM_F_PEM_ASN1_WRITE,ERR_R_BUF_LIB);
276 return(0);
277 }
278 BIO_set_fp(b,fp,BIO_NOCLOSE);
279 ret=PEM_ASN1_write_bio(i2d,name,b,x,enc,kstr,klen,callback,u);
280 BIO_free(b);
281 return(ret);
282 }
283#endif
284
285int PEM_ASN1_write_bio(i2d_of_void *i2d, const char *name, BIO *bp,
286 char *x, const EVP_CIPHER *enc, unsigned char *kstr,
287 int klen, pem_password_cb *callback, void *u)
288 {
289 EVP_CIPHER_CTX ctx;
290 int dsize=0,i,j,ret=0;
291 unsigned char *p,*data=NULL;
292 const char *objstr=NULL;
293 char buf[PEM_BUFSIZE];
294 unsigned char key[EVP_MAX_KEY_LENGTH];
295 unsigned char iv[EVP_MAX_IV_LENGTH];
296
297 if (enc != NULL)
298 {
299 objstr=OBJ_nid2sn(EVP_CIPHER_nid(enc));
300 if (objstr == NULL)
301 {
302 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_UNSUPPORTED_CIPHER);
303 goto err;
304 }
305 }
306
307 if ((dsize=i2d(x,NULL)) < 0)
308 {
309 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_ASN1_LIB);
310 dsize=0;
311 goto err;
312 }
313 /* dzise + 8 bytes are needed */
314 /* actually it needs the cipher block size extra... */
315 data=(unsigned char *)OPENSSL_malloc((unsigned int)dsize+20);
316 if (data == NULL)
317 {
318 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,ERR_R_MALLOC_FAILURE);
319 goto err;
320 }
321 p=data;
322 i=i2d(x,&p);
323
324 if (enc != NULL)
325 {
326 if (kstr == NULL)
327 {
328 if (callback == NULL)
329 klen=PEM_def_callback(buf,PEM_BUFSIZE,1,u);
330 else
331 klen=(*callback)(buf,PEM_BUFSIZE,1,u);
332 if (klen <= 0)
333 {
334 PEMerr(PEM_F_PEM_ASN1_WRITE_BIO,PEM_R_READ_KEY);
335 goto err;
336 }
337#ifdef CHARSET_EBCDIC
338 /* Convert the pass phrase from EBCDIC */
339 ebcdic2ascii(buf, buf, klen);
340#endif
341 kstr=(unsigned char *)buf;
342 }
343 RAND_add(data,i,0);/* put in the RSA key. */
344 OPENSSL_assert(enc->iv_len <= (int)sizeof(iv));
345 if (RAND_pseudo_bytes(iv,enc->iv_len) < 0) /* Generate a salt */
346 goto err;
347 /* The 'iv' is used as the iv and as a salt. It is
348 * NOT taken from the BytesToKey function */
349 EVP_BytesToKey(enc,EVP_md5(),iv,kstr,klen,1,key,NULL);
350
351 if (kstr == (unsigned char *)buf) OPENSSL_cleanse(buf,PEM_BUFSIZE);
352
353 OPENSSL_assert(strlen(objstr)+23+2*enc->iv_len+13 <= sizeof buf);
354
355 buf[0]='\0';
356 PEM_proc_type(buf,PEM_TYPE_ENCRYPTED);
357 PEM_dek_info(buf,objstr,enc->iv_len,(char *)iv);
358 /* k=strlen(buf); */
359
360 EVP_CIPHER_CTX_init(&ctx);
361 EVP_EncryptInit_ex(&ctx,enc,NULL,key,iv);
362 EVP_EncryptUpdate(&ctx,data,&j,data,i);
363 EVP_EncryptFinal_ex(&ctx,&(data[j]),&i);
364 EVP_CIPHER_CTX_cleanup(&ctx);
365 i+=j;
366 ret=1;
367 }
368 else
369 {
370 ret=1;
371 buf[0]='\0';
372 }
373 i=PEM_write_bio(bp,name,buf,data,i);
374 if (i <= 0) ret=0;
375err:
376 OPENSSL_cleanse(key,sizeof(key));
377 OPENSSL_cleanse(iv,sizeof(iv));
378 OPENSSL_cleanse((char *)&ctx,sizeof(ctx));
379 OPENSSL_cleanse(buf,PEM_BUFSIZE);
380 if (data != NULL)
381 {
382 OPENSSL_cleanse(data,(unsigned int)dsize);
383 OPENSSL_free(data);
384 }
385 return(ret);
386 }
387
388int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *plen,
389 pem_password_cb *callback,void *u)
390 {
391 int i,j,o,klen;
392 long len;
393 EVP_CIPHER_CTX ctx;
394 unsigned char key[EVP_MAX_KEY_LENGTH];
395 char buf[PEM_BUFSIZE];
396
397 len= *plen;
398
399 if (cipher->cipher == NULL) return(1);
400 if (callback == NULL)
401 klen=PEM_def_callback(buf,PEM_BUFSIZE,0,u);
402 else
403 klen=callback(buf,PEM_BUFSIZE,0,u);
404 if (klen <= 0)
405 {
406 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_PASSWORD_READ);
407 return(0);
408 }
409#ifdef CHARSET_EBCDIC
410 /* Convert the pass phrase from EBCDIC */
411 ebcdic2ascii(buf, buf, klen);
412#endif
413
414 EVP_BytesToKey(cipher->cipher,EVP_md5(),&(cipher->iv[0]),
415 (unsigned char *)buf,klen,1,key,NULL);
416
417 j=(int)len;
418 EVP_CIPHER_CTX_init(&ctx);
419 EVP_DecryptInit_ex(&ctx,cipher->cipher,NULL, key,&(cipher->iv[0]));
420 EVP_DecryptUpdate(&ctx,data,&i,data,j);
421 o=EVP_DecryptFinal_ex(&ctx,&(data[i]),&j);
422 EVP_CIPHER_CTX_cleanup(&ctx);
423 OPENSSL_cleanse((char *)buf,sizeof(buf));
424 OPENSSL_cleanse((char *)key,sizeof(key));
425 j+=i;
426 if (!o)
427 {
428 PEMerr(PEM_F_PEM_DO_HEADER,PEM_R_BAD_DECRYPT);
429 return(0);
430 }
431 *plen=j;
432 return(1);
433 }
434
435int PEM_get_EVP_CIPHER_INFO(char *header, EVP_CIPHER_INFO *cipher)
436 {
437 int o;
438 const EVP_CIPHER *enc=NULL;
439 char *p,c;
440 char **header_pp = &header;
441
442 cipher->cipher=NULL;
443 if ((header == NULL) || (*header == '\0') || (*header == '\n'))
444 return(1);
445 if (strncmp(header,"Proc-Type: ",11) != 0)
446 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_PROC_TYPE); return(0); }
447 header+=11;
448 if (*header != '4') return(0); header++;
449 if (*header != ',') return(0); header++;
450 if (strncmp(header,"ENCRYPTED",9) != 0)
451 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_ENCRYPTED); return(0); }
452 for (; (*header != '\n') && (*header != '\0'); header++)
453 ;
454 if (*header == '\0')
455 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_SHORT_HEADER); return(0); }
456 header++;
457 if (strncmp(header,"DEK-Info: ",10) != 0)
458 { PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_NOT_DEK_INFO); return(0); }
459 header+=10;
460
461 p=header;
462 for (;;)
463 {
464 c= *header;
465#ifndef CHARSET_EBCDIC
466 if (!( ((c >= 'A') && (c <= 'Z')) || (c == '-') ||
467 ((c >= '0') && (c <= '9'))))
468 break;
469#else
470 if (!( isupper(c) || (c == '-') ||
471 isdigit(c)))
472 break;
473#endif
474 header++;
475 }
476 *header='\0';
477 o=OBJ_sn2nid(p);
478 cipher->cipher=enc=EVP_get_cipherbyname(p);
479 *header=c;
480 header++;
481
482 if (enc == NULL)
483 {
484 PEMerr(PEM_F_PEM_GET_EVP_CIPHER_INFO,PEM_R_UNSUPPORTED_ENCRYPTION);
485 return(0);
486 }
487 if (!load_iv(header_pp,&(cipher->iv[0]),enc->iv_len))
488 return(0);
489
490 return(1);
491 }
492
493static int load_iv(char **fromp, unsigned char *to, int num)
494 {
495 int v,i;
496 char *from;
497
498 from= *fromp;
499 for (i=0; i<num; i++) to[i]=0;
500 num*=2;
501 for (i=0; i<num; i++)
502 {
503 if ((*from >= '0') && (*from <= '9'))
504 v= *from-'0';
505 else if ((*from >= 'A') && (*from <= 'F'))
506 v= *from-'A'+10;
507 else if ((*from >= 'a') && (*from <= 'f'))
508 v= *from-'a'+10;
509 else
510 {
511 PEMerr(PEM_F_LOAD_IV,PEM_R_BAD_IV_CHARS);
512 return(0);
513 }
514 from++;
515 to[i/2]|=v<<(long)((!(i&1))*4);
516 }
517
518 *fromp=from;
519 return(1);
520 }
521
522#ifndef OPENSSL_NO_FP_API
523int PEM_write(FILE *fp, char *name, char *header, unsigned char *data,
524 long len)
525 {
526 BIO *b;
527 int ret;
528
529 if ((b=BIO_new(BIO_s_file())) == NULL)
530 {
531 PEMerr(PEM_F_PEM_WRITE,ERR_R_BUF_LIB);
532 return(0);
533 }
534 BIO_set_fp(b,fp,BIO_NOCLOSE);
535 ret=PEM_write_bio(b, name, header, data,len);
536 BIO_free(b);
537 return(ret);
538 }
539#endif
540
541int PEM_write_bio(BIO *bp, const char *name, char *header, unsigned char *data,
542 long len)
543 {
544 int nlen,n,i,j,outl;
545 unsigned char *buf = NULL;
546 EVP_ENCODE_CTX ctx;
547 int reason=ERR_R_BUF_LIB;
548
549 EVP_EncodeInit(&ctx);
550 nlen=strlen(name);
551
552 if ( (BIO_write(bp,"-----BEGIN ",11) != 11) ||
553 (BIO_write(bp,name,nlen) != nlen) ||
554 (BIO_write(bp,"-----\n",6) != 6))
555 goto err;
556
557 i=strlen(header);
558 if (i > 0)
559 {
560 if ( (BIO_write(bp,header,i) != i) ||
561 (BIO_write(bp,"\n",1) != 1))
562 goto err;
563 }
564
565 buf = OPENSSL_malloc(PEM_BUFSIZE*8);
566 if (buf == NULL)
567 {
568 reason=ERR_R_MALLOC_FAILURE;
569 goto err;
570 }
571
572 i=j=0;
573 while (len > 0)
574 {
575 n=(int)((len>(PEM_BUFSIZE*5))?(PEM_BUFSIZE*5):len);
576 EVP_EncodeUpdate(&ctx,buf,&outl,&(data[j]),n);
577 if ((outl) && (BIO_write(bp,(char *)buf,outl) != outl))
578 goto err;
579 i+=outl;
580 len-=n;
581 j+=n;
582 }
583 EVP_EncodeFinal(&ctx,buf,&outl);
584 if ((outl > 0) && (BIO_write(bp,(char *)buf,outl) != outl)) goto err;
585 OPENSSL_cleanse(buf, PEM_BUFSIZE*8);
586 OPENSSL_free(buf);
587 buf = NULL;
588 if ( (BIO_write(bp,"-----END ",9) != 9) ||
589 (BIO_write(bp,name,nlen) != nlen) ||
590 (BIO_write(bp,"-----\n",6) != 6))
591 goto err;
592 return(i+outl);
593err:
594 if (buf) {
595 OPENSSL_cleanse(buf, PEM_BUFSIZE*8);
596 OPENSSL_free(buf);
597 }
598 PEMerr(PEM_F_PEM_WRITE_BIO,reason);
599 return(0);
600 }
601
602#ifndef OPENSSL_NO_FP_API
603int PEM_read(FILE *fp, char **name, char **header, unsigned char **data,
604 long *len)
605 {
606 BIO *b;
607 int ret;
608
609 if ((b=BIO_new(BIO_s_file())) == NULL)
610 {
611 PEMerr(PEM_F_PEM_READ,ERR_R_BUF_LIB);
612 return(0);
613 }
614 BIO_set_fp(b,fp,BIO_NOCLOSE);
615 ret=PEM_read_bio(b, name, header, data,len);
616 BIO_free(b);
617 return(ret);
618 }
619#endif
620
621int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,
622 long *len)
623 {
624 EVP_ENCODE_CTX ctx;
625 int end=0,i,k,bl=0,hl=0,nohead=0;
626 char buf[256];
627 BUF_MEM *nameB;
628 BUF_MEM *headerB;
629 BUF_MEM *dataB,*tmpB;
630
631 nameB=BUF_MEM_new();
632 headerB=BUF_MEM_new();
633 dataB=BUF_MEM_new();
634 if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL))
635 {
636 BUF_MEM_free(nameB);
637 BUF_MEM_free(headerB);
638 BUF_MEM_free(dataB);
639 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
640 return(0);
641 }
642
643 buf[254]='\0';
644 for (;;)
645 {
646 i=BIO_gets(bp,buf,254);
647
648 if (i <= 0)
649 {
650 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_NO_START_LINE);
651 goto err;
652 }
653
654 while ((i >= 0) && (buf[i] <= ' ')) i--;
655 buf[++i]='\n'; buf[++i]='\0';
656
657 if (strncmp(buf,"-----BEGIN ",11) == 0)
658 {
659 i=strlen(&(buf[11]));
660
661 if (strncmp(&(buf[11+i-6]),"-----\n",6) != 0)
662 continue;
663 if (!BUF_MEM_grow(nameB,i+9))
664 {
665 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
666 goto err;
667 }
668 memcpy(nameB->data,&(buf[11]),i-6);
669 nameB->data[i-6]='\0';
670 break;
671 }
672 }
673 hl=0;
674 if (!BUF_MEM_grow(headerB,256))
675 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
676 headerB->data[0]='\0';
677 for (;;)
678 {
679 i=BIO_gets(bp,buf,254);
680 if (i <= 0) break;
681
682 while ((i >= 0) && (buf[i] <= ' ')) i--;
683 buf[++i]='\n'; buf[++i]='\0';
684
685 if (buf[0] == '\n') break;
686 if (!BUF_MEM_grow(headerB,hl+i+9))
687 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
688 if (strncmp(buf,"-----END ",9) == 0)
689 {
690 nohead=1;
691 break;
692 }
693 memcpy(&(headerB->data[hl]),buf,i);
694 headerB->data[hl+i]='\0';
695 hl+=i;
696 }
697
698 bl=0;
699 if (!BUF_MEM_grow(dataB,1024))
700 { PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE); goto err; }
701 dataB->data[0]='\0';
702 if (!nohead)
703 {
704 for (;;)
705 {
706 i=BIO_gets(bp,buf,254);
707 if (i <= 0) break;
708
709 while ((i >= 0) && (buf[i] <= ' ')) i--;
710 buf[++i]='\n'; buf[++i]='\0';
711
712 if (i != 65) end=1;
713 if (strncmp(buf,"-----END ",9) == 0)
714 break;
715 if (i > 65) break;
716 if (!BUF_MEM_grow_clean(dataB,i+bl+9))
717 {
718 PEMerr(PEM_F_PEM_READ_BIO,ERR_R_MALLOC_FAILURE);
719 goto err;
720 }
721 memcpy(&(dataB->data[bl]),buf,i);
722 dataB->data[bl+i]='\0';
723 bl+=i;
724 if (end)
725 {
726 buf[0]='\0';
727 i=BIO_gets(bp,buf,254);
728 if (i <= 0) break;
729
730 while ((i >= 0) && (buf[i] <= ' ')) i--;
731 buf[++i]='\n'; buf[++i]='\0';
732
733 break;
734 }
735 }
736 }
737 else
738 {
739 tmpB=headerB;
740 headerB=dataB;
741 dataB=tmpB;
742 bl=hl;
743 }
744 i=strlen(nameB->data);
745 if ( (strncmp(buf,"-----END ",9) != 0) ||
746 (strncmp(nameB->data,&(buf[9]),i) != 0) ||
747 (strncmp(&(buf[9+i]),"-----\n",6) != 0))
748 {
749 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_END_LINE);
750 goto err;
751 }
752
753 EVP_DecodeInit(&ctx);
754 i=EVP_DecodeUpdate(&ctx,
755 (unsigned char *)dataB->data,&bl,
756 (unsigned char *)dataB->data,bl);
757 if (i < 0)
758 {
759 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
760 goto err;
761 }
762 i=EVP_DecodeFinal(&ctx,(unsigned char *)&(dataB->data[bl]),&k);
763 if (i < 0)
764 {
765 PEMerr(PEM_F_PEM_READ_BIO,PEM_R_BAD_BASE64_DECODE);
766 goto err;
767 }
768 bl+=k;
769
770 if (bl == 0) goto err;
771 *name=nameB->data;
772 *header=headerB->data;
773 *data=(unsigned char *)dataB->data;
774 *len=bl;
775 OPENSSL_free(nameB);
776 OPENSSL_free(headerB);
777 OPENSSL_free(dataB);
778 return(1);
779err:
780 BUF_MEM_free(nameB);
781 BUF_MEM_free(headerB);
782 BUF_MEM_free(dataB);
783 return(0);
784 }
diff --git a/src/lib/libcrypto/pem/pem_oth.c b/src/lib/libcrypto/pem/pem_oth.c
deleted file mode 100644
index b33868d25a..0000000000
--- a/src/lib/libcrypto/pem/pem_oth.c
+++ /dev/null
@@ -1,86 +0,0 @@
1/* crypto/pem/pem_oth.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 "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/pem.h>
67
68/* Handle 'other' PEMs: not private keys */
69
70void *PEM_ASN1_read_bio(d2i_of_void *d2i, const char *name, BIO *bp, void **x,
71 pem_password_cb *cb, void *u)
72 {
73 const unsigned char *p=NULL;
74 unsigned char *data=NULL;
75 long len;
76 char *ret=NULL;
77
78 if (!PEM_bytes_read_bio(&data, &len, NULL, name, bp, cb, u))
79 return NULL;
80 p = data;
81 ret=d2i(x,&p,len);
82 if (ret == NULL)
83 PEMerr(PEM_F_PEM_ASN1_READ_BIO,ERR_R_ASN1_LIB);
84 OPENSSL_free(data);
85 return(ret);
86 }
diff --git a/src/lib/libcrypto/pem/pem_pk8.c b/src/lib/libcrypto/pem/pem_pk8.c
deleted file mode 100644
index 6deab8c338..0000000000
--- a/src/lib/libcrypto/pem/pem_pk8.c
+++ /dev/null
@@ -1,242 +0,0 @@
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 "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
69static int do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder,
70 int nid, const EVP_CIPHER *enc,
71 char *kstr, int klen,
72 pem_password_cb *cb, void *u);
73static int do_pk8pkey_fp(FILE *bp, EVP_PKEY *x, int isder,
74 int nid, const EVP_CIPHER *enc,
75 char *kstr, int klen,
76 pem_password_cb *cb, void *u);
77
78/* These functions write a private key in PKCS#8 format: it is a "drop in"
79 * replacement for PEM_write_bio_PrivateKey() and friends. As usual if 'enc'
80 * is NULL then it uses the unencrypted private key form. The 'nid' versions
81 * uses PKCS#5 v1.5 PBE algorithms whereas the others use PKCS#5 v2.0.
82 */
83
84int PEM_write_bio_PKCS8PrivateKey_nid(BIO *bp, EVP_PKEY *x, int nid,
85 char *kstr, int klen,
86 pem_password_cb *cb, void *u)
87{
88 return do_pk8pkey(bp, x, 0, nid, NULL, kstr, klen, cb, u);
89}
90
91int PEM_write_bio_PKCS8PrivateKey(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
92 char *kstr, int klen,
93 pem_password_cb *cb, void *u)
94{
95 return do_pk8pkey(bp, x, 0, -1, enc, kstr, klen, cb, u);
96}
97
98int i2d_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY *x, const EVP_CIPHER *enc,
99 char *kstr, int klen,
100 pem_password_cb *cb, void *u)
101{
102 return do_pk8pkey(bp, x, 1, -1, enc, kstr, klen, cb, u);
103}
104
105int i2d_PKCS8PrivateKey_nid_bio(BIO *bp, EVP_PKEY *x, int nid,
106 char *kstr, int klen,
107 pem_password_cb *cb, void *u)
108{
109 return do_pk8pkey(bp, x, 1, nid, NULL, kstr, klen, cb, u);
110}
111
112static int do_pk8pkey(BIO *bp, EVP_PKEY *x, int isder, int nid, const EVP_CIPHER *enc,
113 char *kstr, int klen,
114 pem_password_cb *cb, void *u)
115{
116 X509_SIG *p8;
117 PKCS8_PRIV_KEY_INFO *p8inf;
118 char buf[PEM_BUFSIZE];
119 int ret;
120 if(!(p8inf = EVP_PKEY2PKCS8(x))) {
121 PEMerr(PEM_F_DO_PK8PKEY,
122 PEM_R_ERROR_CONVERTING_PRIVATE_KEY);
123 return 0;
124 }
125 if(enc || (nid != -1)) {
126 if(!kstr) {
127 if(!cb) klen = PEM_def_callback(buf, PEM_BUFSIZE, 1, u);
128 else klen = cb(buf, PEM_BUFSIZE, 1, u);
129 if(klen <= 0) {
130 PEMerr(PEM_F_DO_PK8PKEY,PEM_R_READ_KEY);
131 PKCS8_PRIV_KEY_INFO_free(p8inf);
132 return 0;
133 }
134
135 kstr = buf;
136 }
137 p8 = PKCS8_encrypt(nid, enc, kstr, klen, NULL, 0, 0, p8inf);
138 if(kstr == buf) OPENSSL_cleanse(buf, klen);
139 PKCS8_PRIV_KEY_INFO_free(p8inf);
140 if(isder) ret = i2d_PKCS8_bio(bp, p8);
141 else ret = PEM_write_bio_PKCS8(bp, p8);
142 X509_SIG_free(p8);
143 return ret;
144 } else {
145 if(isder) ret = i2d_PKCS8_PRIV_KEY_INFO_bio(bp, p8inf);
146 else ret = PEM_write_bio_PKCS8_PRIV_KEY_INFO(bp, p8inf);
147 PKCS8_PRIV_KEY_INFO_free(p8inf);
148 return ret;
149 }
150}
151
152EVP_PKEY *d2i_PKCS8PrivateKey_bio(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u)
153{
154 PKCS8_PRIV_KEY_INFO *p8inf = NULL;
155 X509_SIG *p8 = NULL;
156 int klen;
157 EVP_PKEY *ret;
158 char psbuf[PEM_BUFSIZE];
159 p8 = d2i_PKCS8_bio(bp, NULL);
160 if(!p8) return NULL;
161 if (cb) klen=cb(psbuf,PEM_BUFSIZE,0,u);
162 else klen=PEM_def_callback(psbuf,PEM_BUFSIZE,0,u);
163 if (klen <= 0) {
164 PEMerr(PEM_F_D2I_PKCS8PRIVATEKEY_BIO, PEM_R_BAD_PASSWORD_READ);
165 X509_SIG_free(p8);
166 return NULL;
167 }
168 p8inf = PKCS8_decrypt(p8, psbuf, klen);
169 X509_SIG_free(p8);
170 if(!p8inf) return NULL;
171 ret = EVP_PKCS82PKEY(p8inf);
172 PKCS8_PRIV_KEY_INFO_free(p8inf);
173 if(!ret) return NULL;
174 if(x) {
175 if(*x) EVP_PKEY_free(*x);
176 *x = ret;
177 }
178 return ret;
179}
180
181#ifndef OPENSSL_NO_FP_API
182
183int i2d_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
184 char *kstr, int klen,
185 pem_password_cb *cb, void *u)
186{
187 return do_pk8pkey_fp(fp, x, 1, -1, enc, kstr, klen, cb, u);
188}
189
190int i2d_PKCS8PrivateKey_nid_fp(FILE *fp, EVP_PKEY *x, int nid,
191 char *kstr, int klen,
192 pem_password_cb *cb, void *u)
193{
194 return do_pk8pkey_fp(fp, x, 1, nid, NULL, kstr, klen, cb, u);
195}
196
197int PEM_write_PKCS8PrivateKey_nid(FILE *fp, EVP_PKEY *x, int nid,
198 char *kstr, int klen,
199 pem_password_cb *cb, void *u)
200{
201 return do_pk8pkey_fp(fp, x, 0, nid, NULL, kstr, klen, cb, u);
202}
203
204int PEM_write_PKCS8PrivateKey(FILE *fp, EVP_PKEY *x, const EVP_CIPHER *enc,
205 char *kstr, int klen, pem_password_cb *cb, void *u)
206{
207 return do_pk8pkey_fp(fp, x, 0, -1, enc, kstr, klen, cb, u);
208}
209
210static int do_pk8pkey_fp(FILE *fp, EVP_PKEY *x, int isder, int nid, const EVP_CIPHER *enc,
211 char *kstr, int klen,
212 pem_password_cb *cb, void *u)
213{
214 BIO *bp;
215 int ret;
216 if(!(bp = BIO_new_fp(fp, BIO_NOCLOSE))) {
217 PEMerr(PEM_F_DO_PK8PKEY_FP,ERR_R_BUF_LIB);
218 return(0);
219 }
220 ret = do_pk8pkey(bp, x, isder, nid, enc, kstr, klen, cb, u);
221 BIO_free(bp);
222 return ret;
223}
224
225EVP_PKEY *d2i_PKCS8PrivateKey_fp(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u)
226{
227 BIO *bp;
228 EVP_PKEY *ret;
229 if(!(bp = BIO_new_fp(fp, BIO_NOCLOSE))) {
230 PEMerr(PEM_F_D2I_PKCS8PRIVATEKEY_FP,ERR_R_BUF_LIB);
231 return NULL;
232 }
233 ret = d2i_PKCS8PrivateKey_bio(bp, x, cb, u);
234 BIO_free(bp);
235 return ret;
236}
237
238#endif
239
240IMPLEMENT_PEM_rw(PKCS8, X509_SIG, PEM_STRING_PKCS8, X509_SIG)
241IMPLEMENT_PEM_rw(PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO, PEM_STRING_PKCS8INF,
242 PKCS8_PRIV_KEY_INFO)
diff --git a/src/lib/libcrypto/pem/pem_pkey.c b/src/lib/libcrypto/pem/pem_pkey.c
deleted file mode 100644
index 4da4c31ce5..0000000000
--- a/src/lib/libcrypto/pem/pem_pkey.c
+++ /dev/null
@@ -1,149 +0,0 @@
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 "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
69
70EVP_PKEY *PEM_read_bio_PrivateKey(BIO *bp, EVP_PKEY **x, pem_password_cb *cb, void *u)
71 {
72 char *nm=NULL;
73 const unsigned char *p=NULL;
74 unsigned char *data=NULL;
75 long len;
76 EVP_PKEY *ret=NULL;
77
78 if (!PEM_bytes_read_bio(&data, &len, &nm, PEM_STRING_EVP_PKEY, bp, cb, u))
79 return NULL;
80 p = data;
81
82 if (strcmp(nm,PEM_STRING_RSA) == 0)
83 ret=d2i_PrivateKey(EVP_PKEY_RSA,x,&p,len);
84 else if (strcmp(nm,PEM_STRING_DSA) == 0)
85 ret=d2i_PrivateKey(EVP_PKEY_DSA,x,&p,len);
86 else if (strcmp(nm,PEM_STRING_ECPRIVATEKEY) == 0)
87 ret=d2i_PrivateKey(EVP_PKEY_EC,x,&p,len);
88 else if (strcmp(nm,PEM_STRING_PKCS8INF) == 0) {
89 PKCS8_PRIV_KEY_INFO *p8inf;
90 p8inf=d2i_PKCS8_PRIV_KEY_INFO(NULL, &p, len);
91 if(!p8inf) goto p8err;
92 ret = EVP_PKCS82PKEY(p8inf);
93 if(x) {
94 if(*x) EVP_PKEY_free((EVP_PKEY *)*x);
95 *x = ret;
96 }
97 PKCS8_PRIV_KEY_INFO_free(p8inf);
98 } else if (strcmp(nm,PEM_STRING_PKCS8) == 0) {
99 PKCS8_PRIV_KEY_INFO *p8inf;
100 X509_SIG *p8;
101 int klen;
102 char psbuf[PEM_BUFSIZE];
103 p8 = d2i_X509_SIG(NULL, &p, len);
104 if(!p8) goto p8err;
105 if (cb) klen=cb(psbuf,PEM_BUFSIZE,0,u);
106 else klen=PEM_def_callback(psbuf,PEM_BUFSIZE,0,u);
107 if (klen <= 0) {
108 PEMerr(PEM_F_PEM_READ_BIO_PRIVATEKEY,
109 PEM_R_BAD_PASSWORD_READ);
110 X509_SIG_free(p8);
111 goto err;
112 }
113 p8inf = PKCS8_decrypt(p8, psbuf, klen);
114 X509_SIG_free(p8);
115 if(!p8inf) goto p8err;
116 ret = EVP_PKCS82PKEY(p8inf);
117 if(x) {
118 if(*x) EVP_PKEY_free((EVP_PKEY *)*x);
119 *x = ret;
120 }
121 PKCS8_PRIV_KEY_INFO_free(p8inf);
122 }
123p8err:
124 if (ret == NULL)
125 PEMerr(PEM_F_PEM_READ_BIO_PRIVATEKEY,ERR_R_ASN1_LIB);
126err:
127 OPENSSL_free(nm);
128 OPENSSL_cleanse(data, len);
129 OPENSSL_free(data);
130 return(ret);
131 }
132
133#ifndef OPENSSL_NO_FP_API
134EVP_PKEY *PEM_read_PrivateKey(FILE *fp, EVP_PKEY **x, pem_password_cb *cb, void *u)
135 {
136 BIO *b;
137 EVP_PKEY *ret;
138
139 if ((b=BIO_new(BIO_s_file())) == NULL)
140 {
141 PEMerr(PEM_F_PEM_READ_PRIVATEKEY,ERR_R_BUF_LIB);
142 return(0);
143 }
144 BIO_set_fp(b,fp,BIO_NOCLOSE);
145 ret=PEM_read_bio_PrivateKey(b,x,cb,u);
146 BIO_free(b);
147 return(ret);
148 }
149#endif
diff --git a/src/lib/libcrypto/pem/pem_seal.c b/src/lib/libcrypto/pem/pem_seal.c
deleted file mode 100644
index 4e554e5481..0000000000
--- a/src/lib/libcrypto/pem/pem_seal.c
+++ /dev/null
@@ -1,189 +0,0 @@
1/* crypto/pem/pem_seal.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 <openssl/opensslconf.h> /* for OPENSSL_NO_RSA */
60#ifndef OPENSSL_NO_RSA
61#include <stdio.h>
62#include "cryptlib.h"
63#include <openssl/evp.h>
64#include <openssl/rand.h>
65#include <openssl/objects.h>
66#include <openssl/x509.h>
67#include <openssl/pem.h>
68#include <openssl/rsa.h>
69
70int PEM_SealInit(PEM_ENCODE_SEAL_CTX *ctx, EVP_CIPHER *type, EVP_MD *md_type,
71 unsigned char **ek, int *ekl, unsigned char *iv, EVP_PKEY **pubk,
72 int npubk)
73 {
74 unsigned char key[EVP_MAX_KEY_LENGTH];
75 int ret= -1;
76 int i,j,max=0;
77 char *s=NULL;
78
79 for (i=0; i<npubk; i++)
80 {
81 if (pubk[i]->type != EVP_PKEY_RSA)
82 {
83 PEMerr(PEM_F_PEM_SEALINIT,PEM_R_PUBLIC_KEY_NO_RSA);
84 goto err;
85 }
86 j=RSA_size(pubk[i]->pkey.rsa);
87 if (j > max) max=j;
88 }
89 s=(char *)OPENSSL_malloc(max*2);
90 if (s == NULL)
91 {
92 PEMerr(PEM_F_PEM_SEALINIT,ERR_R_MALLOC_FAILURE);
93 goto err;
94 }
95
96 EVP_EncodeInit(&ctx->encode);
97
98 EVP_MD_CTX_init(&ctx->md);
99 EVP_SignInit(&ctx->md,md_type);
100
101 EVP_CIPHER_CTX_init(&ctx->cipher);
102 ret=EVP_SealInit(&ctx->cipher,type,ek,ekl,iv,pubk,npubk);
103 if (!ret) goto err;
104
105 /* base64 encode the keys */
106 for (i=0; i<npubk; i++)
107 {
108 j=EVP_EncodeBlock((unsigned char *)s,ek[i],
109 RSA_size(pubk[i]->pkey.rsa));
110 ekl[i]=j;
111 memcpy(ek[i],s,j+1);
112 }
113
114 ret=npubk;
115err:
116 if (s != NULL) OPENSSL_free(s);
117 OPENSSL_cleanse(key,EVP_MAX_KEY_LENGTH);
118 return(ret);
119 }
120
121void PEM_SealUpdate(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *out, int *outl,
122 unsigned char *in, int inl)
123 {
124 unsigned char buffer[1600];
125 int i,j;
126
127 *outl=0;
128 EVP_SignUpdate(&ctx->md,in,inl);
129 for (;;)
130 {
131 if (inl <= 0) break;
132 if (inl > 1200)
133 i=1200;
134 else
135 i=inl;
136 EVP_EncryptUpdate(&ctx->cipher,buffer,&j,in,i);
137 EVP_EncodeUpdate(&ctx->encode,out,&j,buffer,j);
138 *outl+=j;
139 out+=j;
140 in+=i;
141 inl-=i;
142 }
143 }
144
145int PEM_SealFinal(PEM_ENCODE_SEAL_CTX *ctx, unsigned char *sig, int *sigl,
146 unsigned char *out, int *outl, EVP_PKEY *priv)
147 {
148 unsigned char *s=NULL;
149 int ret=0,j;
150 unsigned int i;
151
152 if (priv->type != EVP_PKEY_RSA)
153 {
154 PEMerr(PEM_F_PEM_SEALFINAL,PEM_R_PUBLIC_KEY_NO_RSA);
155 goto err;
156 }
157 i=RSA_size(priv->pkey.rsa);
158 if (i < 100) i=100;
159 s=(unsigned char *)OPENSSL_malloc(i*2);
160 if (s == NULL)
161 {
162 PEMerr(PEM_F_PEM_SEALFINAL,ERR_R_MALLOC_FAILURE);
163 goto err;
164 }
165
166 EVP_EncryptFinal_ex(&ctx->cipher,s,(int *)&i);
167 EVP_EncodeUpdate(&ctx->encode,out,&j,s,i);
168 *outl=j;
169 out+=j;
170 EVP_EncodeFinal(&ctx->encode,out,&j);
171 *outl+=j;
172
173 if (!EVP_SignFinal(&ctx->md,s,&i,priv)) goto err;
174 *sigl=EVP_EncodeBlock(sig,s,i);
175
176 ret=1;
177err:
178 EVP_MD_CTX_cleanup(&ctx->md);
179 EVP_CIPHER_CTX_cleanup(&ctx->cipher);
180 if (s != NULL) OPENSSL_free(s);
181 return(ret);
182 }
183#else /* !OPENSSL_NO_RSA */
184
185# if PEDANTIC
186static void *dummy=&dummy;
187# endif
188
189#endif
diff --git a/src/lib/libcrypto/pem/pem_sign.c b/src/lib/libcrypto/pem/pem_sign.c
deleted file mode 100644
index c3b9808cb2..0000000000
--- a/src/lib/libcrypto/pem/pem_sign.c
+++ /dev/null
@@ -1,102 +0,0 @@
1/* crypto/pem/pem_sign.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 "cryptlib.h"
61#include <openssl/rand.h>
62#include <openssl/evp.h>
63#include <openssl/objects.h>
64#include <openssl/x509.h>
65#include <openssl/pem.h>
66
67void PEM_SignInit(EVP_MD_CTX *ctx, EVP_MD *type)
68 {
69 EVP_DigestInit_ex(ctx, type, NULL);
70 }
71
72void PEM_SignUpdate(EVP_MD_CTX *ctx, unsigned char *data,
73 unsigned int count)
74 {
75 EVP_DigestUpdate(ctx,data,count);
76 }
77
78int PEM_SignFinal(EVP_MD_CTX *ctx, unsigned char *sigret, unsigned int *siglen,
79 EVP_PKEY *pkey)
80 {
81 unsigned char *m;
82 int i,ret=0;
83 unsigned int m_len;
84
85 m=(unsigned char *)OPENSSL_malloc(EVP_PKEY_size(pkey)+2);
86 if (m == NULL)
87 {
88 PEMerr(PEM_F_PEM_SIGNFINAL,ERR_R_MALLOC_FAILURE);
89 goto err;
90 }
91
92 if (EVP_SignFinal(ctx,m,&m_len,pkey) <= 0) goto err;
93
94 i=EVP_EncodeBlock(sigret,m,m_len);
95 *siglen=i;
96 ret=1;
97err:
98 /* ctx has been zeroed by EVP_SignFinal() */
99 if (m != NULL) OPENSSL_free(m);
100 return(ret);
101 }
102
diff --git a/src/lib/libcrypto/pem/pem_x509.c b/src/lib/libcrypto/pem/pem_x509.c
deleted file mode 100644
index 3f709f13e6..0000000000
--- a/src/lib/libcrypto/pem/pem_x509.c
+++ /dev/null
@@ -1,69 +0,0 @@
1/* pem_x509.c */
2/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 * project 2001.
4 */
5/* ====================================================================
6 * Copyright (c) 2001 The OpenSSL Project. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 *
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * licensing@OpenSSL.org.
29 *
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
33 *
34 * 6. Redistributions of any form whatsoever must retain the following
35 * acknowledgment:
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 *
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
52 *
53 * This product includes cryptographic software written by Eric Young
54 * (eay@cryptsoft.com). This product includes software written by Tim
55 * Hudson (tjh@cryptsoft.com).
56 *
57 */
58
59#include <stdio.h>
60#undef SSLEAY_MACROS
61#include "cryptlib.h"
62#include <openssl/bio.h>
63#include <openssl/evp.h>
64#include <openssl/x509.h>
65#include <openssl/pkcs7.h>
66#include <openssl/pem.h>
67
68IMPLEMENT_PEM_rw(X509, X509, PEM_STRING_X509, X509)
69
diff --git a/src/lib/libcrypto/pem/pem_xaux.c b/src/lib/libcrypto/pem/pem_xaux.c
deleted file mode 100644
index 7cc7491009..0000000000
--- a/src/lib/libcrypto/pem/pem_xaux.c
+++ /dev/null
@@ -1,69 +0,0 @@
1/* pem_xaux.c */
2/* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
3 * project 2001.
4 */
5/* ====================================================================
6 * Copyright (c) 2001 The OpenSSL Project. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in
17 * the documentation and/or other materials provided with the
18 * distribution.
19 *
20 * 3. All advertising materials mentioning features or use of this
21 * software must display the following acknowledgment:
22 * "This product includes software developed by the OpenSSL Project
23 * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
24 *
25 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
26 * endorse or promote products derived from this software without
27 * prior written permission. For written permission, please contact
28 * licensing@OpenSSL.org.
29 *
30 * 5. Products derived from this software may not be called "OpenSSL"
31 * nor may "OpenSSL" appear in their names without prior written
32 * permission of the OpenSSL Project.
33 *
34 * 6. Redistributions of any form whatsoever must retain the following
35 * acknowledgment:
36 * "This product includes software developed by the OpenSSL Project
37 * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
38 *
39 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
40 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
41 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
42 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
43 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
44 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
45 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
46 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
48 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
49 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
50 * OF THE POSSIBILITY OF SUCH DAMAGE.
51 * ====================================================================
52 *
53 * This product includes cryptographic software written by Eric Young
54 * (eay@cryptsoft.com). This product includes software written by Tim
55 * Hudson (tjh@cryptsoft.com).
56 *
57 */
58
59#include <stdio.h>
60#undef SSLEAY_MACROS
61#include "cryptlib.h"
62#include <openssl/bio.h>
63#include <openssl/evp.h>
64#include <openssl/x509.h>
65#include <openssl/pkcs7.h>
66#include <openssl/pem.h>
67
68IMPLEMENT_PEM_rw(X509_AUX, X509, PEM_STRING_X509_TRUSTED, X509_AUX)
69IMPLEMENT_PEM_rw(X509_CERT_PAIR, X509_CERT_PAIR, PEM_STRING_X509_PAIR, X509_CERT_PAIR)
diff --git a/src/lib/libcrypto/pem/pkcs7.lis b/src/lib/libcrypto/pem/pkcs7.lis
deleted file mode 100644
index be90c5d87f..0000000000
--- a/src/lib/libcrypto/pem/pkcs7.lis
+++ /dev/null
@@ -1,22 +0,0 @@
121 0:d=0 hl=2 l= 0 cons: univ: SEQUENCE
2 00 2:d=0 hl=2 l= 9 prim: univ: OBJECT_IDENTIFIER :pkcs-7-signedData
3 21 13:d=0 hl=2 l= 0 cons: cont: 00 # explicit tag
4 21 15:d=0 hl=2 l= 0 cons: univ: SEQUENCE
5 00 17:d=0 hl=2 l= 1 prim: univ: INTEGER # version
6 20 20:d=0 hl=2 l= 0 cons: univ: SET
7 21 22:d=0 hl=2 l= 0 cons: univ: SEQUENCE
8 00 24:d=0 hl=2 l= 9 prim: univ: OBJECT_IDENTIFIER :pkcs-7-data
9 00 35:d=0 hl=2 l= 0 prim: univ: EOC
10 21 37:d=0 hl=2 l= 0 cons: cont: 00 # cert tag
11 20 39:d=0 hl=4 l=545 cons: univ: SEQUENCE
12 20 588:d=0 hl=4 l=524 cons: univ: SEQUENCE
13 00 1116:d=0 hl=2 l= 0 prim: univ: EOC
14 21 1118:d=0 hl=2 l= 0 cons: cont: 01 # crl tag
15 20 1120:d=0 hl=4 l=653 cons: univ: SEQUENCE
16 20 1777:d=0 hl=4 l=285 cons: univ: SEQUENCE
17 00 2066:d=0 hl=2 l= 0 prim: univ: EOC
18 21 2068:d=0 hl=2 l= 0 cons: univ: SET # signers
19 00 2070:d=0 hl=2 l= 0 prim: univ: EOC
20 00 2072:d=0 hl=2 l= 0 prim: univ: EOC
21 00 2074:d=0 hl=2 l= 0 prim: univ: EOC
2200 2076:d=0 hl=2 l= 0 prim: univ: EOC
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-04 21:39:37 +0000