xref: /dragonfly/crypto/libressl/apps/openssl/ca.c (revision f5b1c8a1)
1f5b1c8a1SJohn Marino /* $OpenBSD: ca.c,v 1.19 2015/10/17 15:00:11 doug Exp $ */
2f5b1c8a1SJohn Marino /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3f5b1c8a1SJohn Marino  * All rights reserved.
4f5b1c8a1SJohn Marino  *
5f5b1c8a1SJohn Marino  * This package is an SSL implementation written
6f5b1c8a1SJohn Marino  * by Eric Young (eay@cryptsoft.com).
7f5b1c8a1SJohn Marino  * The implementation was written so as to conform with Netscapes SSL.
8f5b1c8a1SJohn Marino  *
9f5b1c8a1SJohn Marino  * This library is free for commercial and non-commercial use as long as
10f5b1c8a1SJohn Marino  * the following conditions are aheared to.  The following conditions
11f5b1c8a1SJohn Marino  * apply to all code found in this distribution, be it the RC4, RSA,
12f5b1c8a1SJohn Marino  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13f5b1c8a1SJohn Marino  * included with this distribution is covered by the same copyright terms
14f5b1c8a1SJohn Marino  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15f5b1c8a1SJohn Marino  *
16f5b1c8a1SJohn Marino  * Copyright remains Eric Young's, and as such any Copyright notices in
17f5b1c8a1SJohn Marino  * the code are not to be removed.
18f5b1c8a1SJohn Marino  * If this package is used in a product, Eric Young should be given attribution
19f5b1c8a1SJohn Marino  * as the author of the parts of the library used.
20f5b1c8a1SJohn Marino  * This can be in the form of a textual message at program startup or
21f5b1c8a1SJohn Marino  * in documentation (online or textual) provided with the package.
22f5b1c8a1SJohn Marino  *
23f5b1c8a1SJohn Marino  * Redistribution and use in source and binary forms, with or without
24f5b1c8a1SJohn Marino  * modification, are permitted provided that the following conditions
25f5b1c8a1SJohn Marino  * are met:
26f5b1c8a1SJohn Marino  * 1. Redistributions of source code must retain the copyright
27f5b1c8a1SJohn Marino  *    notice, this list of conditions and the following disclaimer.
28f5b1c8a1SJohn Marino  * 2. Redistributions in binary form must reproduce the above copyright
29f5b1c8a1SJohn Marino  *    notice, this list of conditions and the following disclaimer in the
30f5b1c8a1SJohn Marino  *    documentation and/or other materials provided with the distribution.
31f5b1c8a1SJohn Marino  * 3. All advertising materials mentioning features or use of this software
32f5b1c8a1SJohn Marino  *    must display the following acknowledgement:
33f5b1c8a1SJohn Marino  *    "This product includes cryptographic software written by
34f5b1c8a1SJohn Marino  *     Eric Young (eay@cryptsoft.com)"
35f5b1c8a1SJohn Marino  *    The word 'cryptographic' can be left out if the rouines from the library
36f5b1c8a1SJohn Marino  *    being used are not cryptographic related :-).
37f5b1c8a1SJohn Marino  * 4. If you include any Windows specific code (or a derivative thereof) from
38f5b1c8a1SJohn Marino  *    the apps directory (application code) you must include an acknowledgement:
39f5b1c8a1SJohn Marino  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40f5b1c8a1SJohn Marino  *
41f5b1c8a1SJohn Marino  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42f5b1c8a1SJohn Marino  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43f5b1c8a1SJohn Marino  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44f5b1c8a1SJohn Marino  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45f5b1c8a1SJohn Marino  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46f5b1c8a1SJohn Marino  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47f5b1c8a1SJohn Marino  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48f5b1c8a1SJohn Marino  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49f5b1c8a1SJohn Marino  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50f5b1c8a1SJohn Marino  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51f5b1c8a1SJohn Marino  * SUCH DAMAGE.
52f5b1c8a1SJohn Marino  *
53f5b1c8a1SJohn Marino  * The licence and distribution terms for any publically available version or
54f5b1c8a1SJohn Marino  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55f5b1c8a1SJohn Marino  * copied and put under another distribution licence
56f5b1c8a1SJohn Marino  * [including the GNU Public Licence.]
57f5b1c8a1SJohn Marino  */
58f5b1c8a1SJohn Marino 
59f5b1c8a1SJohn Marino /* The PPKI stuff has been donated by Jeff Barber <jeffb@issl.atl.hp.com> */
60f5b1c8a1SJohn Marino 
61f5b1c8a1SJohn Marino #include <sys/types.h>
62f5b1c8a1SJohn Marino 
63f5b1c8a1SJohn Marino #include <ctype.h>
64f5b1c8a1SJohn Marino #include <stdio.h>
65f5b1c8a1SJohn Marino #include <stdlib.h>
66f5b1c8a1SJohn Marino #include <limits.h>
67f5b1c8a1SJohn Marino #include <string.h>
68f5b1c8a1SJohn Marino #include <unistd.h>
69f5b1c8a1SJohn Marino 
70f5b1c8a1SJohn Marino #include "apps.h"
71f5b1c8a1SJohn Marino 
72f5b1c8a1SJohn Marino #include <openssl/bio.h>
73f5b1c8a1SJohn Marino #include <openssl/bn.h>
74f5b1c8a1SJohn Marino #include <openssl/conf.h>
75f5b1c8a1SJohn Marino #include <openssl/err.h>
76f5b1c8a1SJohn Marino #include <openssl/evp.h>
77f5b1c8a1SJohn Marino #include <openssl/objects.h>
78f5b1c8a1SJohn Marino #include <openssl/ocsp.h>
79f5b1c8a1SJohn Marino #include <openssl/pem.h>
80f5b1c8a1SJohn Marino #include <openssl/txt_db.h>
81f5b1c8a1SJohn Marino #include <openssl/x509.h>
82f5b1c8a1SJohn Marino #include <openssl/x509v3.h>
83f5b1c8a1SJohn Marino 
84f5b1c8a1SJohn Marino #define BASE_SECTION		"ca"
85f5b1c8a1SJohn Marino 
86f5b1c8a1SJohn Marino #define ENV_DEFAULT_CA		"default_ca"
87f5b1c8a1SJohn Marino 
88f5b1c8a1SJohn Marino #define STRING_MASK		"string_mask"
89f5b1c8a1SJohn Marino #define UTF8_IN			"utf8"
90f5b1c8a1SJohn Marino 
91f5b1c8a1SJohn Marino #define ENV_NEW_CERTS_DIR	"new_certs_dir"
92f5b1c8a1SJohn Marino #define ENV_CERTIFICATE 	"certificate"
93f5b1c8a1SJohn Marino #define ENV_SERIAL		"serial"
94f5b1c8a1SJohn Marino #define ENV_CRLNUMBER		"crlnumber"
95f5b1c8a1SJohn Marino #define ENV_PRIVATE_KEY		"private_key"
96f5b1c8a1SJohn Marino #define ENV_DEFAULT_DAYS 	"default_days"
97f5b1c8a1SJohn Marino #define ENV_DEFAULT_STARTDATE 	"default_startdate"
98f5b1c8a1SJohn Marino #define ENV_DEFAULT_ENDDATE 	"default_enddate"
99f5b1c8a1SJohn Marino #define ENV_DEFAULT_CRL_DAYS 	"default_crl_days"
100f5b1c8a1SJohn Marino #define ENV_DEFAULT_CRL_HOURS 	"default_crl_hours"
101f5b1c8a1SJohn Marino #define ENV_DEFAULT_MD		"default_md"
102f5b1c8a1SJohn Marino #define ENV_DEFAULT_EMAIL_DN	"email_in_dn"
103f5b1c8a1SJohn Marino #define ENV_PRESERVE		"preserve"
104f5b1c8a1SJohn Marino #define ENV_POLICY      	"policy"
105f5b1c8a1SJohn Marino #define ENV_EXTENSIONS      	"x509_extensions"
106f5b1c8a1SJohn Marino #define ENV_CRLEXT      	"crl_extensions"
107f5b1c8a1SJohn Marino #define ENV_MSIE_HACK		"msie_hack"
108f5b1c8a1SJohn Marino #define ENV_NAMEOPT		"name_opt"
109f5b1c8a1SJohn Marino #define ENV_CERTOPT		"cert_opt"
110f5b1c8a1SJohn Marino #define ENV_EXTCOPY		"copy_extensions"
111f5b1c8a1SJohn Marino #define ENV_UNIQUE_SUBJECT	"unique_subject"
112f5b1c8a1SJohn Marino 
113f5b1c8a1SJohn Marino #define ENV_DATABASE		"database"
114f5b1c8a1SJohn Marino 
115f5b1c8a1SJohn Marino /* Additional revocation information types */
116f5b1c8a1SJohn Marino 
117f5b1c8a1SJohn Marino #define REV_NONE		0	/* No addditional information */
118f5b1c8a1SJohn Marino #define REV_CRL_REASON		1	/* Value is CRL reason code */
119f5b1c8a1SJohn Marino #define REV_HOLD		2	/* Value is hold instruction */
120f5b1c8a1SJohn Marino #define REV_KEY_COMPROMISE	3	/* Value is cert key compromise time */
121f5b1c8a1SJohn Marino #define REV_CA_COMPROMISE	4	/* Value is CA key compromise time */
122f5b1c8a1SJohn Marino 
123f5b1c8a1SJohn Marino static const char *ca_usage[] = {
124f5b1c8a1SJohn Marino 	"usage: ca args\n",
125f5b1c8a1SJohn Marino 	"\n",
126f5b1c8a1SJohn Marino 	" -verbose        - Talk a lot while doing things\n",
127f5b1c8a1SJohn Marino 	" -config file    - A config file\n",
128f5b1c8a1SJohn Marino 	" -name arg       - The particular CA definition to use\n",
129f5b1c8a1SJohn Marino 	" -gencrl         - Generate a new CRL\n",
130f5b1c8a1SJohn Marino 	" -crldays days   - Days is when the next CRL is due\n",
131f5b1c8a1SJohn Marino 	" -crlhours hours - Hours is when the next CRL is due\n",
132f5b1c8a1SJohn Marino 	" -startdate YYMMDDHHMMSSZ  - certificate validity notBefore\n",
133f5b1c8a1SJohn Marino 	" -enddate YYMMDDHHMMSSZ    - certificate validity notAfter (overrides -days)\n",
134f5b1c8a1SJohn Marino 	" -days arg       - number of days to certify the certificate for\n",
135f5b1c8a1SJohn Marino 	" -md arg         - md to use, one of md5 or sha1\n",
136f5b1c8a1SJohn Marino 	" -policy arg     - The CA 'policy' to support\n",
137f5b1c8a1SJohn Marino 	" -keyfile arg    - private key file\n",
138f5b1c8a1SJohn Marino 	" -keyform arg    - private key file format (PEM)\n",
139f5b1c8a1SJohn Marino 	" -key arg        - key to decode the private key if it is encrypted\n",
140f5b1c8a1SJohn Marino 	" -cert file      - The CA certificate\n",
141f5b1c8a1SJohn Marino 	" -selfsign       - sign a certificate with the key associated with it\n",
142f5b1c8a1SJohn Marino 	" -in file        - The input PEM encoded certificate request(s)\n",
143f5b1c8a1SJohn Marino 	" -out file       - Where to put the output file(s)\n",
144f5b1c8a1SJohn Marino 	" -outdir dir     - Where to put output certificates\n",
145f5b1c8a1SJohn Marino 	" -infiles ....   - The last argument, requests to process\n",
146f5b1c8a1SJohn Marino 	" -spkac file     - File contains DN and signed public key and challenge\n",
147f5b1c8a1SJohn Marino 	" -ss_cert file   - File contains a self signed cert to sign\n",
148f5b1c8a1SJohn Marino 	" -preserveDN     - Don't re-order the DN\n",
149f5b1c8a1SJohn Marino 	" -noemailDN      - Don't add the EMAIL field into certificate' subject\n",
150f5b1c8a1SJohn Marino 	" -batch          - Don't ask questions\n",
151f5b1c8a1SJohn Marino 	" -msie_hack      - msie modifications to handle all those universal strings\n",
152f5b1c8a1SJohn Marino 	" -revoke file    - Revoke a certificate (given in file)\n",
153f5b1c8a1SJohn Marino 	" -subj arg       - Use arg instead of request's subject\n",
154f5b1c8a1SJohn Marino 	" -utf8           - input characters are UTF8 (default ASCII)\n",
155f5b1c8a1SJohn Marino 	" -multivalue-rdn - enable support for multivalued RDNs\n",
156f5b1c8a1SJohn Marino 	" -extensions ..  - Extension section (override value in config file)\n",
157f5b1c8a1SJohn Marino 	" -extfile file   - Configuration file with X509v3 extentions to add\n",
158f5b1c8a1SJohn Marino 	" -crlexts ..     - CRL extension section (override value in config file)\n",
159f5b1c8a1SJohn Marino 	" -status serial  - Shows certificate status given the serial number\n",
160f5b1c8a1SJohn Marino 	" -updatedb       - Updates db for expired certificates\n",
161f5b1c8a1SJohn Marino 	NULL
162f5b1c8a1SJohn Marino };
163f5b1c8a1SJohn Marino 
164f5b1c8a1SJohn Marino static void lookup_fail(const char *name, const char *tag);
165f5b1c8a1SJohn Marino static int certify(X509 ** xret, char *infile, EVP_PKEY * pkey, X509 * x509,
166f5b1c8a1SJohn Marino     const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
167f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
168f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
169f5b1c8a1SJohn Marino     char *enddate, long days, int batch, char *ext_sect, CONF * conf,
170f5b1c8a1SJohn Marino     int verbose, unsigned long certopt, unsigned long nameopt,
171f5b1c8a1SJohn Marino     int default_op, int ext_copy, int selfsign);
172f5b1c8a1SJohn Marino static int certify_cert(X509 ** xret, char *infile, EVP_PKEY * pkey,
173f5b1c8a1SJohn Marino     X509 * x509, const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
174f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
175f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
176f5b1c8a1SJohn Marino     char *enddate, long days, int batch, char *ext_sect, CONF * conf,
177f5b1c8a1SJohn Marino     int verbose, unsigned long certopt, unsigned long nameopt, int default_op,
178f5b1c8a1SJohn Marino     int ext_copy);
179f5b1c8a1SJohn Marino static int certify_spkac(X509 ** xret, char *infile, EVP_PKEY * pkey,
180f5b1c8a1SJohn Marino     X509 * x509, const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
181f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
182f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
183f5b1c8a1SJohn Marino     char *enddate, long days, char *ext_sect, CONF * conf, int verbose,
184f5b1c8a1SJohn Marino     unsigned long certopt, unsigned long nameopt, int default_op, int ext_copy);
185f5b1c8a1SJohn Marino static void write_new_certificate(BIO * bp, X509 * x, int output_der,
186f5b1c8a1SJohn Marino     int notext);
187f5b1c8a1SJohn Marino static int do_body(X509 ** xret, EVP_PKEY * pkey, X509 * x509,
188f5b1c8a1SJohn Marino     const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
189f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
190f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
191f5b1c8a1SJohn Marino     char *enddate, long days, int batch, int verbose, X509_REQ * req,
192f5b1c8a1SJohn Marino     char *ext_sect, CONF * conf, unsigned long certopt, unsigned long nameopt,
193f5b1c8a1SJohn Marino     int default_op, int ext_copy, int selfsign);
194f5b1c8a1SJohn Marino static int do_revoke(X509 * x509, CA_DB * db, int ext, char *extval);
195f5b1c8a1SJohn Marino static int get_certificate_status(const char *ser_status, CA_DB * db);
196f5b1c8a1SJohn Marino static int do_updatedb(CA_DB * db);
197f5b1c8a1SJohn Marino static int check_time_format(const char *str);
198f5b1c8a1SJohn Marino static char * bin2hex(unsigned char *, size_t);
199f5b1c8a1SJohn Marino char *make_revocation_str(int rev_type, char *rev_arg);
200f5b1c8a1SJohn Marino int make_revoked(X509_REVOKED * rev, const char *str);
201f5b1c8a1SJohn Marino int old_entry_print(BIO * bp, ASN1_OBJECT * obj, ASN1_STRING * str);
202f5b1c8a1SJohn Marino static CONF *conf = NULL;
203f5b1c8a1SJohn Marino static CONF *extconf = NULL;
204f5b1c8a1SJohn Marino static char *section = NULL;
205f5b1c8a1SJohn Marino 
206f5b1c8a1SJohn Marino static int preserve = 0;
207f5b1c8a1SJohn Marino static int msie_hack = 0;
208f5b1c8a1SJohn Marino 
209f5b1c8a1SJohn Marino 
210f5b1c8a1SJohn Marino int
211f5b1c8a1SJohn Marino ca_main(int argc, char **argv)
212f5b1c8a1SJohn Marino {
213f5b1c8a1SJohn Marino 	char *key = NULL, *passargin = NULL;
214f5b1c8a1SJohn Marino 	int create_ser = 0;
215f5b1c8a1SJohn Marino 	int free_key = 0;
216f5b1c8a1SJohn Marino 	int total = 0;
217f5b1c8a1SJohn Marino 	int total_done = 0;
218f5b1c8a1SJohn Marino 	int badops = 0;
219f5b1c8a1SJohn Marino 	int ret = 1;
220f5b1c8a1SJohn Marino 	int email_dn = 1;
221f5b1c8a1SJohn Marino 	int req = 0;
222f5b1c8a1SJohn Marino 	int verbose = 0;
223f5b1c8a1SJohn Marino 	int gencrl = 0;
224f5b1c8a1SJohn Marino 	int dorevoke = 0;
225f5b1c8a1SJohn Marino 	int doupdatedb = 0;
226f5b1c8a1SJohn Marino 	long crldays = 0;
227f5b1c8a1SJohn Marino 	long crlhours = 0;
228f5b1c8a1SJohn Marino 	long crlsec = 0;
229f5b1c8a1SJohn Marino 	long errorline = -1;
230f5b1c8a1SJohn Marino 	char *configfile = NULL;
231f5b1c8a1SJohn Marino 	char *md = NULL;
232f5b1c8a1SJohn Marino 	char *policy = NULL;
233f5b1c8a1SJohn Marino 	char *keyfile = NULL;
234f5b1c8a1SJohn Marino 	char *certfile = NULL;
235f5b1c8a1SJohn Marino 	int keyform = FORMAT_PEM;
236f5b1c8a1SJohn Marino 	char *infile = NULL;
237f5b1c8a1SJohn Marino 	char *spkac_file = NULL;
238f5b1c8a1SJohn Marino 	char *ss_cert_file = NULL;
239f5b1c8a1SJohn Marino 	char *ser_status = NULL;
240f5b1c8a1SJohn Marino 	EVP_PKEY *pkey = NULL;
241f5b1c8a1SJohn Marino 	int output_der = 0;
242f5b1c8a1SJohn Marino 	char *outfile = NULL;
243f5b1c8a1SJohn Marino 	char *outdir = NULL;
244f5b1c8a1SJohn Marino 	char *serialfile = NULL;
245f5b1c8a1SJohn Marino 	char *crlnumberfile = NULL;
246f5b1c8a1SJohn Marino 	char *extensions = NULL;
247f5b1c8a1SJohn Marino 	char *extfile = NULL;
248f5b1c8a1SJohn Marino 	char *subj = NULL;
249f5b1c8a1SJohn Marino 	unsigned long chtype = MBSTRING_ASC;
250f5b1c8a1SJohn Marino 	int multirdn = 0;
251f5b1c8a1SJohn Marino 	char *tmp_email_dn = NULL;
252f5b1c8a1SJohn Marino 	char *crl_ext = NULL;
253f5b1c8a1SJohn Marino 	int rev_type = REV_NONE;
254f5b1c8a1SJohn Marino 	char *rev_arg = NULL;
255f5b1c8a1SJohn Marino 	BIGNUM *serial = NULL;
256f5b1c8a1SJohn Marino 	BIGNUM *crlnumber = NULL;
257f5b1c8a1SJohn Marino 	char *startdate = NULL;
258f5b1c8a1SJohn Marino 	char *enddate = NULL;
259f5b1c8a1SJohn Marino 	long days = 0;
260f5b1c8a1SJohn Marino 	int batch = 0;
261f5b1c8a1SJohn Marino 	int notext = 0;
262f5b1c8a1SJohn Marino 	unsigned long nameopt = 0, certopt = 0;
263f5b1c8a1SJohn Marino 	int default_op = 1;
264f5b1c8a1SJohn Marino 	int ext_copy = EXT_COPY_NONE;
265f5b1c8a1SJohn Marino 	int selfsign = 0;
266f5b1c8a1SJohn Marino 	X509 *x509 = NULL, *x509p = NULL;
267f5b1c8a1SJohn Marino 	X509 *x = NULL;
268f5b1c8a1SJohn Marino 	BIO *in = NULL, *out = NULL, *Sout = NULL, *Cout = NULL;
269f5b1c8a1SJohn Marino 	char *dbfile = NULL;
270f5b1c8a1SJohn Marino 	CA_DB *db = NULL;
271f5b1c8a1SJohn Marino 	X509_CRL *crl = NULL;
272f5b1c8a1SJohn Marino 	X509_REVOKED *r = NULL;
273f5b1c8a1SJohn Marino 	ASN1_TIME *tmptm;
274f5b1c8a1SJohn Marino 	ASN1_INTEGER *tmpser;
275f5b1c8a1SJohn Marino 	char *f;
276f5b1c8a1SJohn Marino 	const char *p;
277f5b1c8a1SJohn Marino 	char *const * pp;
278f5b1c8a1SJohn Marino 	int i, j;
279f5b1c8a1SJohn Marino 	const EVP_MD *dgst = NULL;
280f5b1c8a1SJohn Marino 	STACK_OF(CONF_VALUE) * attribs = NULL;
281f5b1c8a1SJohn Marino 	STACK_OF(X509) * cert_sk = NULL;
282f5b1c8a1SJohn Marino 	STACK_OF(OPENSSL_STRING) * sigopts = NULL;
283f5b1c8a1SJohn Marino #define BUFLEN 256
284f5b1c8a1SJohn Marino 	char buf[3][BUFLEN];
285f5b1c8a1SJohn Marino 	char *tofree = NULL;
286f5b1c8a1SJohn Marino 	const char *errstr = NULL;
287f5b1c8a1SJohn Marino 	DB_ATTR db_attr;
288f5b1c8a1SJohn Marino 
289f5b1c8a1SJohn Marino 	if (single_execution) {
290f5b1c8a1SJohn Marino 		if (pledge("stdio rpath wpath cpath tty", NULL) == -1) {
291f5b1c8a1SJohn Marino 			perror("pledge");
292f5b1c8a1SJohn Marino 			exit(1);
293f5b1c8a1SJohn Marino 		}
294f5b1c8a1SJohn Marino 	}
295f5b1c8a1SJohn Marino 
296f5b1c8a1SJohn Marino 	conf = NULL;
297f5b1c8a1SJohn Marino 	key = NULL;
298f5b1c8a1SJohn Marino 	section = NULL;
299f5b1c8a1SJohn Marino 
300f5b1c8a1SJohn Marino 	preserve = 0;
301f5b1c8a1SJohn Marino 	msie_hack = 0;
302f5b1c8a1SJohn Marino 
303f5b1c8a1SJohn Marino 	argc--;
304f5b1c8a1SJohn Marino 	argv++;
305f5b1c8a1SJohn Marino 	while (argc >= 1) {
306f5b1c8a1SJohn Marino 		if (strcmp(*argv, "-verbose") == 0)
307f5b1c8a1SJohn Marino 			verbose = 1;
308f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-config") == 0) {
309f5b1c8a1SJohn Marino 			if (--argc < 1)
310f5b1c8a1SJohn Marino 				goto bad;
311f5b1c8a1SJohn Marino 			configfile = *(++argv);
312f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-name") == 0) {
313f5b1c8a1SJohn Marino 			if (--argc < 1)
314f5b1c8a1SJohn Marino 				goto bad;
315f5b1c8a1SJohn Marino 			section = *(++argv);
316f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-subj") == 0) {
317f5b1c8a1SJohn Marino 			if (--argc < 1)
318f5b1c8a1SJohn Marino 				goto bad;
319f5b1c8a1SJohn Marino 			subj = *(++argv);
320f5b1c8a1SJohn Marino 			/* preserve=1; */
321f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-utf8") == 0)
322f5b1c8a1SJohn Marino 			chtype = MBSTRING_UTF8;
323f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-create_serial") == 0)
324f5b1c8a1SJohn Marino 			create_ser = 1;
325f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-multivalue-rdn") == 0)
326f5b1c8a1SJohn Marino 			multirdn = 1;
327f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-startdate") == 0) {
328f5b1c8a1SJohn Marino 			if (--argc < 1)
329f5b1c8a1SJohn Marino 				goto bad;
330f5b1c8a1SJohn Marino 			startdate = *(++argv);
331f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-enddate") == 0) {
332f5b1c8a1SJohn Marino 			if (--argc < 1)
333f5b1c8a1SJohn Marino 				goto bad;
334f5b1c8a1SJohn Marino 			enddate = *(++argv);
335f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-days") == 0) {
336f5b1c8a1SJohn Marino 			if (--argc < 1)
337f5b1c8a1SJohn Marino 				goto bad;
338f5b1c8a1SJohn Marino 			days = strtonum(*(++argv), 0, LONG_MAX, &errstr);
339f5b1c8a1SJohn Marino 			if (errstr)
340f5b1c8a1SJohn Marino 				goto bad;
341f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-md") == 0) {
342f5b1c8a1SJohn Marino 			if (--argc < 1)
343f5b1c8a1SJohn Marino 				goto bad;
344f5b1c8a1SJohn Marino 			md = *(++argv);
345f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-policy") == 0) {
346f5b1c8a1SJohn Marino 			if (--argc < 1)
347f5b1c8a1SJohn Marino 				goto bad;
348f5b1c8a1SJohn Marino 			policy = *(++argv);
349f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-keyfile") == 0) {
350f5b1c8a1SJohn Marino 			if (--argc < 1)
351f5b1c8a1SJohn Marino 				goto bad;
352f5b1c8a1SJohn Marino 			keyfile = *(++argv);
353f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-keyform") == 0) {
354f5b1c8a1SJohn Marino 			if (--argc < 1)
355f5b1c8a1SJohn Marino 				goto bad;
356f5b1c8a1SJohn Marino 			keyform = str2fmt(*(++argv));
357f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-passin") == 0) {
358f5b1c8a1SJohn Marino 			if (--argc < 1)
359f5b1c8a1SJohn Marino 				goto bad;
360f5b1c8a1SJohn Marino 			passargin = *(++argv);
361f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-key") == 0) {
362f5b1c8a1SJohn Marino 			if (--argc < 1)
363f5b1c8a1SJohn Marino 				goto bad;
364f5b1c8a1SJohn Marino 			key = *(++argv);
365f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-cert") == 0) {
366f5b1c8a1SJohn Marino 			if (--argc < 1)
367f5b1c8a1SJohn Marino 				goto bad;
368f5b1c8a1SJohn Marino 			certfile = *(++argv);
369f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-selfsign") == 0)
370f5b1c8a1SJohn Marino 			selfsign = 1;
371f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-in") == 0) {
372f5b1c8a1SJohn Marino 			if (--argc < 1)
373f5b1c8a1SJohn Marino 				goto bad;
374f5b1c8a1SJohn Marino 			infile = *(++argv);
375f5b1c8a1SJohn Marino 			req = 1;
376f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-out") == 0) {
377f5b1c8a1SJohn Marino 			if (--argc < 1)
378f5b1c8a1SJohn Marino 				goto bad;
379f5b1c8a1SJohn Marino 			outfile = *(++argv);
380f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-outdir") == 0) {
381f5b1c8a1SJohn Marino 			if (--argc < 1)
382f5b1c8a1SJohn Marino 				goto bad;
383f5b1c8a1SJohn Marino 			outdir = *(++argv);
384f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-sigopt") == 0) {
385f5b1c8a1SJohn Marino 			if (--argc < 1)
386f5b1c8a1SJohn Marino 				goto bad;
387f5b1c8a1SJohn Marino 			if (!sigopts)
388f5b1c8a1SJohn Marino 				sigopts = sk_OPENSSL_STRING_new_null();
389f5b1c8a1SJohn Marino 			if (!sigopts ||
390f5b1c8a1SJohn Marino 			    !sk_OPENSSL_STRING_push(sigopts, *(++argv)))
391f5b1c8a1SJohn Marino 				goto bad;
392f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-notext") == 0)
393f5b1c8a1SJohn Marino 			notext = 1;
394f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-batch") == 0)
395f5b1c8a1SJohn Marino 			batch = 1;
396f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-preserveDN") == 0)
397f5b1c8a1SJohn Marino 			preserve = 1;
398f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-noemailDN") == 0)
399f5b1c8a1SJohn Marino 			email_dn = 0;
400f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-gencrl") == 0)
401f5b1c8a1SJohn Marino 			gencrl = 1;
402f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-msie_hack") == 0)
403f5b1c8a1SJohn Marino 			msie_hack = 1;
404f5b1c8a1SJohn Marino 		else if (strcmp(*argv, "-crldays") == 0) {
405f5b1c8a1SJohn Marino 			if (--argc < 1)
406f5b1c8a1SJohn Marino 				goto bad;
407f5b1c8a1SJohn Marino 			crldays = strtonum(*(++argv), 0, LONG_MAX, &errstr);
408f5b1c8a1SJohn Marino 			if (errstr)
409f5b1c8a1SJohn Marino 				goto bad;
410f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crlhours") == 0) {
411f5b1c8a1SJohn Marino 			if (--argc < 1)
412f5b1c8a1SJohn Marino 				goto bad;
413f5b1c8a1SJohn Marino 			crlhours = strtonum(*(++argv), 0, LONG_MAX, &errstr);
414f5b1c8a1SJohn Marino 			if (errstr)
415f5b1c8a1SJohn Marino 				goto bad;
416f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crlsec") == 0) {
417f5b1c8a1SJohn Marino 			if (--argc < 1)
418f5b1c8a1SJohn Marino 				goto bad;
419f5b1c8a1SJohn Marino 			crlsec = strtonum(*(++argv), 0, LONG_MAX, &errstr);
420f5b1c8a1SJohn Marino 			if (errstr)
421f5b1c8a1SJohn Marino 				goto bad;
422f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-infiles") == 0) {
423f5b1c8a1SJohn Marino 			argc--;
424f5b1c8a1SJohn Marino 			argv++;
425f5b1c8a1SJohn Marino 			req = 1;
426f5b1c8a1SJohn Marino 			break;
427f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-ss_cert") == 0) {
428f5b1c8a1SJohn Marino 			if (--argc < 1)
429f5b1c8a1SJohn Marino 				goto bad;
430f5b1c8a1SJohn Marino 			ss_cert_file = *(++argv);
431f5b1c8a1SJohn Marino 			req = 1;
432f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-spkac") == 0) {
433f5b1c8a1SJohn Marino 			if (--argc < 1)
434f5b1c8a1SJohn Marino 				goto bad;
435f5b1c8a1SJohn Marino 			spkac_file = *(++argv);
436f5b1c8a1SJohn Marino 			req = 1;
437f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-revoke") == 0) {
438f5b1c8a1SJohn Marino 			if (--argc < 1)
439f5b1c8a1SJohn Marino 				goto bad;
440f5b1c8a1SJohn Marino 			infile = *(++argv);
441f5b1c8a1SJohn Marino 			dorevoke = 1;
442f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-extensions") == 0) {
443f5b1c8a1SJohn Marino 			if (--argc < 1)
444f5b1c8a1SJohn Marino 				goto bad;
445f5b1c8a1SJohn Marino 			extensions = *(++argv);
446f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-extfile") == 0) {
447f5b1c8a1SJohn Marino 			if (--argc < 1)
448f5b1c8a1SJohn Marino 				goto bad;
449f5b1c8a1SJohn Marino 			extfile = *(++argv);
450f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-status") == 0) {
451f5b1c8a1SJohn Marino 			if (--argc < 1)
452f5b1c8a1SJohn Marino 				goto bad;
453f5b1c8a1SJohn Marino 			ser_status = *(++argv);
454f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-updatedb") == 0) {
455f5b1c8a1SJohn Marino 			doupdatedb = 1;
456f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crlexts") == 0) {
457f5b1c8a1SJohn Marino 			if (--argc < 1)
458f5b1c8a1SJohn Marino 				goto bad;
459f5b1c8a1SJohn Marino 			crl_ext = *(++argv);
460f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crl_reason") == 0) {
461f5b1c8a1SJohn Marino 			if (--argc < 1)
462f5b1c8a1SJohn Marino 				goto bad;
463f5b1c8a1SJohn Marino 			rev_arg = *(++argv);
464f5b1c8a1SJohn Marino 			rev_type = REV_CRL_REASON;
465f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crl_hold") == 0) {
466f5b1c8a1SJohn Marino 			if (--argc < 1)
467f5b1c8a1SJohn Marino 				goto bad;
468f5b1c8a1SJohn Marino 			rev_arg = *(++argv);
469f5b1c8a1SJohn Marino 			rev_type = REV_HOLD;
470f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crl_compromise") == 0) {
471f5b1c8a1SJohn Marino 			if (--argc < 1)
472f5b1c8a1SJohn Marino 				goto bad;
473f5b1c8a1SJohn Marino 			rev_arg = *(++argv);
474f5b1c8a1SJohn Marino 			rev_type = REV_KEY_COMPROMISE;
475f5b1c8a1SJohn Marino 		} else if (strcmp(*argv, "-crl_CA_compromise") == 0) {
476f5b1c8a1SJohn Marino 			if (--argc < 1)
477f5b1c8a1SJohn Marino 				goto bad;
478f5b1c8a1SJohn Marino 			rev_arg = *(++argv);
479f5b1c8a1SJohn Marino 			rev_type = REV_CA_COMPROMISE;
480f5b1c8a1SJohn Marino 		}
481f5b1c8a1SJohn Marino 		else {
482f5b1c8a1SJohn Marino bad:
483f5b1c8a1SJohn Marino 			if (errstr)
484f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "invalid argument %s: %s\n",
485f5b1c8a1SJohn Marino 				    *argv, errstr);
486f5b1c8a1SJohn Marino 			else
487f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "unknown option %s\n", *argv);
488f5b1c8a1SJohn Marino 			badops = 1;
489f5b1c8a1SJohn Marino 			break;
490f5b1c8a1SJohn Marino 		}
491f5b1c8a1SJohn Marino 		argc--;
492f5b1c8a1SJohn Marino 		argv++;
493f5b1c8a1SJohn Marino 	}
494f5b1c8a1SJohn Marino 
495f5b1c8a1SJohn Marino 	if (badops) {
496f5b1c8a1SJohn Marino 		const char **pp2;
497f5b1c8a1SJohn Marino 
498f5b1c8a1SJohn Marino 		for (pp2 = ca_usage; (*pp2 != NULL); pp2++)
499f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "%s", *pp2);
500f5b1c8a1SJohn Marino 		goto err;
501f5b1c8a1SJohn Marino 	}
502f5b1c8a1SJohn Marino 
503f5b1c8a1SJohn Marino 	/*****************************************************************/
504f5b1c8a1SJohn Marino 	tofree = NULL;
505f5b1c8a1SJohn Marino 	if (configfile == NULL)
506f5b1c8a1SJohn Marino 		configfile = getenv("OPENSSL_CONF");
507f5b1c8a1SJohn Marino 	if (configfile == NULL) {
508f5b1c8a1SJohn Marino 		if ((tofree = make_config_name()) == NULL) {
509f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "error making config file name\n");
510f5b1c8a1SJohn Marino 			goto err;
511f5b1c8a1SJohn Marino 		}
512f5b1c8a1SJohn Marino 		configfile = tofree;
513f5b1c8a1SJohn Marino 	}
514f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "Using configuration from %s\n", configfile);
515f5b1c8a1SJohn Marino 	conf = NCONF_new(NULL);
516f5b1c8a1SJohn Marino 	if (NCONF_load(conf, configfile, &errorline) <= 0) {
517f5b1c8a1SJohn Marino 		if (errorline <= 0)
518f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
519f5b1c8a1SJohn Marino 			    "error loading the config file '%s'\n",
520f5b1c8a1SJohn Marino 			    configfile);
521f5b1c8a1SJohn Marino 		else
522f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
523f5b1c8a1SJohn Marino 			    "error on line %ld of config file '%s'\n",
524f5b1c8a1SJohn Marino 			    errorline, configfile);
525f5b1c8a1SJohn Marino 		goto err;
526f5b1c8a1SJohn Marino 	}
527f5b1c8a1SJohn Marino 	free(tofree);
528f5b1c8a1SJohn Marino 	tofree = NULL;
529f5b1c8a1SJohn Marino 
530f5b1c8a1SJohn Marino 	/* Lets get the config section we are using */
531f5b1c8a1SJohn Marino 	if (section == NULL) {
532f5b1c8a1SJohn Marino 		section = NCONF_get_string(conf, BASE_SECTION, ENV_DEFAULT_CA);
533f5b1c8a1SJohn Marino 		if (section == NULL) {
534f5b1c8a1SJohn Marino 			lookup_fail(BASE_SECTION, ENV_DEFAULT_CA);
535f5b1c8a1SJohn Marino 			goto err;
536f5b1c8a1SJohn Marino 		}
537f5b1c8a1SJohn Marino 	}
538f5b1c8a1SJohn Marino 	if (conf != NULL) {
539f5b1c8a1SJohn Marino 		p = NCONF_get_string(conf, NULL, "oid_file");
540f5b1c8a1SJohn Marino 		if (p == NULL)
541f5b1c8a1SJohn Marino 			ERR_clear_error();
542f5b1c8a1SJohn Marino 		if (p != NULL) {
543f5b1c8a1SJohn Marino 			BIO *oid_bio;
544f5b1c8a1SJohn Marino 
545f5b1c8a1SJohn Marino 			oid_bio = BIO_new_file(p, "r");
546f5b1c8a1SJohn Marino 			if (oid_bio == NULL) {
547f5b1c8a1SJohn Marino 				/*
548f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
549f5b1c8a1SJohn Marino 				    "problems opening %s for extra oid's\n", p);
550f5b1c8a1SJohn Marino 				ERR_print_errors(bio_err);
551f5b1c8a1SJohn Marino 				*/
552f5b1c8a1SJohn Marino 				ERR_clear_error();
553f5b1c8a1SJohn Marino 			} else {
554f5b1c8a1SJohn Marino 				OBJ_create_objects(oid_bio);
555f5b1c8a1SJohn Marino 				BIO_free(oid_bio);
556f5b1c8a1SJohn Marino 			}
557f5b1c8a1SJohn Marino 		}
558f5b1c8a1SJohn Marino 		if (!add_oid_section(bio_err, conf)) {
559f5b1c8a1SJohn Marino 			ERR_print_errors(bio_err);
560f5b1c8a1SJohn Marino 			goto err;
561f5b1c8a1SJohn Marino 		}
562f5b1c8a1SJohn Marino 	}
563f5b1c8a1SJohn Marino 	f = NCONF_get_string(conf, section, STRING_MASK);
564f5b1c8a1SJohn Marino 	if (!f)
565f5b1c8a1SJohn Marino 		ERR_clear_error();
566f5b1c8a1SJohn Marino 
567f5b1c8a1SJohn Marino 	if (f && !ASN1_STRING_set_default_mask_asc(f)) {
568f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
569f5b1c8a1SJohn Marino 		    "Invalid global string mask setting %s\n", f);
570f5b1c8a1SJohn Marino 		goto err;
571f5b1c8a1SJohn Marino 	}
572f5b1c8a1SJohn Marino 	if (chtype != MBSTRING_UTF8) {
573f5b1c8a1SJohn Marino 		f = NCONF_get_string(conf, section, UTF8_IN);
574f5b1c8a1SJohn Marino 		if (!f)
575f5b1c8a1SJohn Marino 			ERR_clear_error();
576f5b1c8a1SJohn Marino 		else if (!strcmp(f, "yes"))
577f5b1c8a1SJohn Marino 			chtype = MBSTRING_UTF8;
578f5b1c8a1SJohn Marino 	}
579f5b1c8a1SJohn Marino 	db_attr.unique_subject = 1;
580f5b1c8a1SJohn Marino 	p = NCONF_get_string(conf, section, ENV_UNIQUE_SUBJECT);
581f5b1c8a1SJohn Marino 	if (p) {
582f5b1c8a1SJohn Marino 		db_attr.unique_subject = parse_yesno(p, 1);
583f5b1c8a1SJohn Marino 	} else
584f5b1c8a1SJohn Marino 		ERR_clear_error();
585f5b1c8a1SJohn Marino 
586f5b1c8a1SJohn Marino 	in = BIO_new(BIO_s_file());
587f5b1c8a1SJohn Marino 	out = BIO_new(BIO_s_file());
588f5b1c8a1SJohn Marino 	Sout = BIO_new(BIO_s_file());
589f5b1c8a1SJohn Marino 	Cout = BIO_new(BIO_s_file());
590f5b1c8a1SJohn Marino 	if ((in == NULL) || (out == NULL) || (Sout == NULL) || (Cout == NULL)) {
591f5b1c8a1SJohn Marino 		ERR_print_errors(bio_err);
592f5b1c8a1SJohn Marino 		goto err;
593f5b1c8a1SJohn Marino 	}
594f5b1c8a1SJohn Marino 	/*****************************************************************/
595f5b1c8a1SJohn Marino 	/* report status of cert with serial number given on command line */
596f5b1c8a1SJohn Marino 	if (ser_status) {
597f5b1c8a1SJohn Marino 		if ((dbfile = NCONF_get_string(conf, section,
598f5b1c8a1SJohn Marino 		    ENV_DATABASE)) == NULL) {
599f5b1c8a1SJohn Marino 			lookup_fail(section, ENV_DATABASE);
600f5b1c8a1SJohn Marino 			goto err;
601f5b1c8a1SJohn Marino 		}
602f5b1c8a1SJohn Marino 		db = load_index(dbfile, &db_attr);
603f5b1c8a1SJohn Marino 		if (db == NULL)
604f5b1c8a1SJohn Marino 			goto err;
605f5b1c8a1SJohn Marino 
606f5b1c8a1SJohn Marino 		if (!index_index(db))
607f5b1c8a1SJohn Marino 			goto err;
608f5b1c8a1SJohn Marino 
609f5b1c8a1SJohn Marino 		if (get_certificate_status(ser_status, db) != 1)
610f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Error verifying serial %s!\n",
611f5b1c8a1SJohn Marino 			    ser_status);
612f5b1c8a1SJohn Marino 		goto err;
613f5b1c8a1SJohn Marino 	}
614f5b1c8a1SJohn Marino 	/*****************************************************************/
615f5b1c8a1SJohn Marino 	/* we definitely need a private key, so let's get it */
616f5b1c8a1SJohn Marino 
617f5b1c8a1SJohn Marino 	if ((keyfile == NULL) && ((keyfile = NCONF_get_string(conf,
618f5b1c8a1SJohn Marino 	    section, ENV_PRIVATE_KEY)) == NULL)) {
619f5b1c8a1SJohn Marino 		lookup_fail(section, ENV_PRIVATE_KEY);
620f5b1c8a1SJohn Marino 		goto err;
621f5b1c8a1SJohn Marino 	}
622f5b1c8a1SJohn Marino 	if (!key) {
623f5b1c8a1SJohn Marino 		free_key = 1;
624f5b1c8a1SJohn Marino 		if (!app_passwd(bio_err, passargin, NULL, &key, NULL)) {
625f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Error getting password\n");
626f5b1c8a1SJohn Marino 			goto err;
627f5b1c8a1SJohn Marino 		}
628f5b1c8a1SJohn Marino 	}
629f5b1c8a1SJohn Marino 	pkey = load_key(bio_err, keyfile, keyform, 0, key, "CA private key");
630f5b1c8a1SJohn Marino 	if (key)
631f5b1c8a1SJohn Marino 		explicit_bzero(key, strlen(key));
632f5b1c8a1SJohn Marino 	if (pkey == NULL) {
633f5b1c8a1SJohn Marino 		/* load_key() has already printed an appropriate message */
634f5b1c8a1SJohn Marino 		goto err;
635f5b1c8a1SJohn Marino 	}
636f5b1c8a1SJohn Marino 	/*****************************************************************/
637f5b1c8a1SJohn Marino 	/* we need a certificate */
638f5b1c8a1SJohn Marino 	if (!selfsign || spkac_file || ss_cert_file || gencrl) {
639f5b1c8a1SJohn Marino 		if ((certfile == NULL) &&
640f5b1c8a1SJohn Marino 		    ((certfile = NCONF_get_string(conf,
641f5b1c8a1SJohn Marino 		    section, ENV_CERTIFICATE)) == NULL)) {
642f5b1c8a1SJohn Marino 			lookup_fail(section, ENV_CERTIFICATE);
643f5b1c8a1SJohn Marino 			goto err;
644f5b1c8a1SJohn Marino 		}
645f5b1c8a1SJohn Marino 		x509 = load_cert(bio_err, certfile, FORMAT_PEM, NULL,
646f5b1c8a1SJohn Marino 		    "CA certificate");
647f5b1c8a1SJohn Marino 		if (x509 == NULL)
648f5b1c8a1SJohn Marino 			goto err;
649f5b1c8a1SJohn Marino 
650f5b1c8a1SJohn Marino 		if (!X509_check_private_key(x509, pkey)) {
651f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
652f5b1c8a1SJohn Marino 			    "CA certificate and CA private key do not match\n");
653f5b1c8a1SJohn Marino 			goto err;
654f5b1c8a1SJohn Marino 		}
655f5b1c8a1SJohn Marino 	}
656f5b1c8a1SJohn Marino 	if (!selfsign)
657f5b1c8a1SJohn Marino 		x509p = x509;
658f5b1c8a1SJohn Marino 
659f5b1c8a1SJohn Marino 	f = NCONF_get_string(conf, BASE_SECTION, ENV_PRESERVE);
660f5b1c8a1SJohn Marino 	if (f == NULL)
661f5b1c8a1SJohn Marino 		ERR_clear_error();
662f5b1c8a1SJohn Marino 	if ((f != NULL) && ((*f == 'y') || (*f == 'Y')))
663f5b1c8a1SJohn Marino 		preserve = 1;
664f5b1c8a1SJohn Marino 	f = NCONF_get_string(conf, BASE_SECTION, ENV_MSIE_HACK);
665f5b1c8a1SJohn Marino 	if (f == NULL)
666f5b1c8a1SJohn Marino 		ERR_clear_error();
667f5b1c8a1SJohn Marino 	if ((f != NULL) && ((*f == 'y') || (*f == 'Y')))
668f5b1c8a1SJohn Marino 		msie_hack = 1;
669f5b1c8a1SJohn Marino 
670f5b1c8a1SJohn Marino 	f = NCONF_get_string(conf, section, ENV_NAMEOPT);
671f5b1c8a1SJohn Marino 
672f5b1c8a1SJohn Marino 	if (f) {
673f5b1c8a1SJohn Marino 		if (!set_name_ex(&nameopt, f)) {
674f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
675f5b1c8a1SJohn Marino 			    "Invalid name options: \"%s\"\n", f);
676f5b1c8a1SJohn Marino 			goto err;
677f5b1c8a1SJohn Marino 		}
678f5b1c8a1SJohn Marino 		default_op = 0;
679f5b1c8a1SJohn Marino 	} else
680f5b1c8a1SJohn Marino 		ERR_clear_error();
681f5b1c8a1SJohn Marino 
682f5b1c8a1SJohn Marino 	f = NCONF_get_string(conf, section, ENV_CERTOPT);
683f5b1c8a1SJohn Marino 
684f5b1c8a1SJohn Marino 	if (f) {
685f5b1c8a1SJohn Marino 		if (!set_cert_ex(&certopt, f)) {
686f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
687f5b1c8a1SJohn Marino 			    "Invalid certificate options: \"%s\"\n", f);
688f5b1c8a1SJohn Marino 			goto err;
689f5b1c8a1SJohn Marino 		}
690f5b1c8a1SJohn Marino 		default_op = 0;
691f5b1c8a1SJohn Marino 	} else
692f5b1c8a1SJohn Marino 		ERR_clear_error();
693f5b1c8a1SJohn Marino 
694f5b1c8a1SJohn Marino 	f = NCONF_get_string(conf, section, ENV_EXTCOPY);
695f5b1c8a1SJohn Marino 
696f5b1c8a1SJohn Marino 	if (f) {
697f5b1c8a1SJohn Marino 		if (!set_ext_copy(&ext_copy, f)) {
698f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
699f5b1c8a1SJohn Marino 			    "Invalid extension copy option: \"%s\"\n", f);
700f5b1c8a1SJohn Marino 			goto err;
701f5b1c8a1SJohn Marino 		}
702f5b1c8a1SJohn Marino 	} else
703f5b1c8a1SJohn Marino 		ERR_clear_error();
704f5b1c8a1SJohn Marino 
705f5b1c8a1SJohn Marino 	/*****************************************************************/
706f5b1c8a1SJohn Marino 	/* lookup where to write new certificates */
707f5b1c8a1SJohn Marino 	if ((outdir == NULL) && (req)) {
708f5b1c8a1SJohn Marino 
709f5b1c8a1SJohn Marino 		if ((outdir = NCONF_get_string(conf, section,
710f5b1c8a1SJohn Marino 		    ENV_NEW_CERTS_DIR)) == NULL) {
711f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "there needs to be defined a directory for new certificate to be placed in\n");
712f5b1c8a1SJohn Marino 			goto err;
713f5b1c8a1SJohn Marino 		}
714f5b1c8a1SJohn Marino 		/*
715f5b1c8a1SJohn Marino 		 * outdir is a directory spec, but access() for VMS demands a
716f5b1c8a1SJohn Marino 		 * filename.  In any case, stat(), below, will catch the
717f5b1c8a1SJohn Marino 		 * problem if outdir is not a directory spec, and the fopen()
718f5b1c8a1SJohn Marino 		 * or open() will catch an error if there is no write access.
719f5b1c8a1SJohn Marino 		 *
720f5b1c8a1SJohn Marino 		 * Presumably, this problem could also be solved by using the
721f5b1c8a1SJohn Marino 		 * DEC C routines to convert the directory syntax to Unixly,
722f5b1c8a1SJohn Marino 		 * and give that to access().  However, time's too short to
723f5b1c8a1SJohn Marino 		 * do that just now.
724f5b1c8a1SJohn Marino 		 */
725f5b1c8a1SJohn Marino 		if (access(outdir, R_OK | W_OK | X_OK) != 0) {
726f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
727f5b1c8a1SJohn Marino 			    "I am unable to access the %s directory\n", outdir);
728f5b1c8a1SJohn Marino 			perror(outdir);
729f5b1c8a1SJohn Marino 			goto err;
730f5b1c8a1SJohn Marino 		}
731f5b1c8a1SJohn Marino 		if (app_isdir(outdir) <= 0) {
732f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
733f5b1c8a1SJohn Marino 			    "%s need to be a directory\n", outdir);
734f5b1c8a1SJohn Marino 			perror(outdir);
735f5b1c8a1SJohn Marino 			goto err;
736f5b1c8a1SJohn Marino 		}
737f5b1c8a1SJohn Marino 	}
738f5b1c8a1SJohn Marino 	/*****************************************************************/
739f5b1c8a1SJohn Marino 	/* we need to load the database file */
740f5b1c8a1SJohn Marino 	if ((dbfile = NCONF_get_string(conf, section, ENV_DATABASE)) == NULL) {
741f5b1c8a1SJohn Marino 		lookup_fail(section, ENV_DATABASE);
742f5b1c8a1SJohn Marino 		goto err;
743f5b1c8a1SJohn Marino 	}
744f5b1c8a1SJohn Marino 	db = load_index(dbfile, &db_attr);
745f5b1c8a1SJohn Marino 	if (db == NULL)
746f5b1c8a1SJohn Marino 		goto err;
747f5b1c8a1SJohn Marino 
748f5b1c8a1SJohn Marino 	/* Lets check some fields */
749f5b1c8a1SJohn Marino 	for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
750f5b1c8a1SJohn Marino 		pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
751f5b1c8a1SJohn Marino 		if ((pp[DB_type][0] != DB_TYPE_REV) &&
752f5b1c8a1SJohn Marino 		    (pp[DB_rev_date][0] != '\0')) {
753f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "entry %d: not revoked yet, but has a revocation date\n", i + 1);
754f5b1c8a1SJohn Marino 			goto err;
755f5b1c8a1SJohn Marino 		}
756f5b1c8a1SJohn Marino 		if ((pp[DB_type][0] == DB_TYPE_REV) &&
757f5b1c8a1SJohn Marino 		    !make_revoked(NULL, pp[DB_rev_date])) {
758f5b1c8a1SJohn Marino 			BIO_printf(bio_err, " in entry %d\n", i + 1);
759f5b1c8a1SJohn Marino 			goto err;
760f5b1c8a1SJohn Marino 		}
761f5b1c8a1SJohn Marino 		if (!check_time_format((char *) pp[DB_exp_date])) {
762f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "entry %d: invalid expiry date\n",
763f5b1c8a1SJohn Marino 			    i + 1);
764f5b1c8a1SJohn Marino 			goto err;
765f5b1c8a1SJohn Marino 		}
766f5b1c8a1SJohn Marino 		p = pp[DB_serial];
767f5b1c8a1SJohn Marino 		j = strlen(p);
768f5b1c8a1SJohn Marino 		if (*p == '-') {
769f5b1c8a1SJohn Marino 			p++;
770f5b1c8a1SJohn Marino 			j--;
771f5b1c8a1SJohn Marino 		}
772f5b1c8a1SJohn Marino 		if ((j & 1) || (j < 2)) {
773f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
774f5b1c8a1SJohn Marino 			    "entry %d: bad serial number length (%d)\n",
775f5b1c8a1SJohn Marino 			    i + 1, j);
776f5b1c8a1SJohn Marino 			goto err;
777f5b1c8a1SJohn Marino 		}
778f5b1c8a1SJohn Marino 		while (*p) {
779f5b1c8a1SJohn Marino 			if (!(((*p >= '0') && (*p <= '9')) ||
780f5b1c8a1SJohn Marino 			    ((*p >= 'A') && (*p <= 'F')) ||
781f5b1c8a1SJohn Marino 			    ((*p >= 'a') && (*p <= 'f')))) {
782f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "entry %d: bad serial number characters, char pos %ld, char is '%c'\n", i + 1, (long) (p - pp[DB_serial]), *p);
783f5b1c8a1SJohn Marino 				goto err;
784f5b1c8a1SJohn Marino 			}
785f5b1c8a1SJohn Marino 			p++;
786f5b1c8a1SJohn Marino 		}
787f5b1c8a1SJohn Marino 	}
788f5b1c8a1SJohn Marino 	if (verbose) {
789f5b1c8a1SJohn Marino 		BIO_set_fp(out, stdout, BIO_NOCLOSE | BIO_FP_TEXT);	/* cannot fail */
790f5b1c8a1SJohn Marino 		TXT_DB_write(out, db->db);
791f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "%d entries loaded from the database\n",
792f5b1c8a1SJohn Marino 		    sk_OPENSSL_PSTRING_num(db->db->data));
793f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "generating index\n");
794f5b1c8a1SJohn Marino 	}
795f5b1c8a1SJohn Marino 	if (!index_index(db))
796f5b1c8a1SJohn Marino 		goto err;
797f5b1c8a1SJohn Marino 
798f5b1c8a1SJohn Marino 	/*****************************************************************/
799f5b1c8a1SJohn Marino 	/* Update the db file for expired certificates */
800f5b1c8a1SJohn Marino 	if (doupdatedb) {
801f5b1c8a1SJohn Marino 		if (verbose)
802f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Updating %s ...\n", dbfile);
803f5b1c8a1SJohn Marino 
804f5b1c8a1SJohn Marino 		i = do_updatedb(db);
805f5b1c8a1SJohn Marino 		if (i == -1) {
806f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Malloc failure\n");
807f5b1c8a1SJohn Marino 			goto err;
808f5b1c8a1SJohn Marino 		} else if (i == 0) {
809f5b1c8a1SJohn Marino 			if (verbose)
810f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
811f5b1c8a1SJohn Marino 				    "No entries found to mark expired\n");
812f5b1c8a1SJohn Marino 		} else {
813f5b1c8a1SJohn Marino 			if (!save_index(dbfile, "new", db))
814f5b1c8a1SJohn Marino 				goto err;
815f5b1c8a1SJohn Marino 
816f5b1c8a1SJohn Marino 			if (!rotate_index(dbfile, "new", "old"))
817f5b1c8a1SJohn Marino 				goto err;
818f5b1c8a1SJohn Marino 
819f5b1c8a1SJohn Marino 			if (verbose)
820f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
821f5b1c8a1SJohn Marino 				    "Done. %d entries marked as expired\n", i);
822f5b1c8a1SJohn Marino 		}
823f5b1c8a1SJohn Marino 	}
824f5b1c8a1SJohn Marino 	/*****************************************************************/
825f5b1c8a1SJohn Marino 	/* Read extentions config file                                   */
826f5b1c8a1SJohn Marino 	if (extfile) {
827f5b1c8a1SJohn Marino 		extconf = NCONF_new(NULL);
828f5b1c8a1SJohn Marino 		if (NCONF_load(extconf, extfile, &errorline) <= 0) {
829f5b1c8a1SJohn Marino 			if (errorline <= 0)
830f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
831f5b1c8a1SJohn Marino 				    "ERROR: loading the config file '%s'\n",
832f5b1c8a1SJohn Marino 				    extfile);
833f5b1c8a1SJohn Marino 			else
834f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
835f5b1c8a1SJohn Marino 				    "ERROR: on line %ld of config file '%s'\n",
836f5b1c8a1SJohn Marino 				    errorline, extfile);
837f5b1c8a1SJohn Marino 			ret = 1;
838f5b1c8a1SJohn Marino 			goto err;
839f5b1c8a1SJohn Marino 		}
840f5b1c8a1SJohn Marino 		if (verbose)
841f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
842f5b1c8a1SJohn Marino 			    "Successfully loaded extensions file %s\n",
843f5b1c8a1SJohn Marino 			    extfile);
844f5b1c8a1SJohn Marino 
845f5b1c8a1SJohn Marino 		/* We can have sections in the ext file */
846f5b1c8a1SJohn Marino 		if (!extensions && !(extensions = NCONF_get_string(extconf,
847f5b1c8a1SJohn Marino 		    "default", "extensions")))
848f5b1c8a1SJohn Marino 			extensions = "default";
849f5b1c8a1SJohn Marino 	}
850f5b1c8a1SJohn Marino 	/*****************************************************************/
851f5b1c8a1SJohn Marino 	if (req || gencrl) {
852f5b1c8a1SJohn Marino 		if (outfile != NULL) {
853f5b1c8a1SJohn Marino 			if (BIO_write_filename(Sout, outfile) <= 0) {
854f5b1c8a1SJohn Marino 				perror(outfile);
855f5b1c8a1SJohn Marino 				goto err;
856f5b1c8a1SJohn Marino 			}
857f5b1c8a1SJohn Marino 		} else {
858f5b1c8a1SJohn Marino 			BIO_set_fp(Sout, stdout, BIO_NOCLOSE | BIO_FP_TEXT);
859f5b1c8a1SJohn Marino 		}
860f5b1c8a1SJohn Marino 	}
861f5b1c8a1SJohn Marino 	if ((md == NULL) && ((md = NCONF_get_string(conf, section,
862f5b1c8a1SJohn Marino 	    ENV_DEFAULT_MD)) == NULL)) {
863f5b1c8a1SJohn Marino 		lookup_fail(section, ENV_DEFAULT_MD);
864f5b1c8a1SJohn Marino 		goto err;
865f5b1c8a1SJohn Marino 	}
866f5b1c8a1SJohn Marino 	if (!strcmp(md, "default")) {
867f5b1c8a1SJohn Marino 		int def_nid;
868f5b1c8a1SJohn Marino 		if (EVP_PKEY_get_default_digest_nid(pkey, &def_nid) <= 0) {
869f5b1c8a1SJohn Marino 			BIO_puts(bio_err, "no default digest\n");
870f5b1c8a1SJohn Marino 			goto err;
871f5b1c8a1SJohn Marino 		}
872f5b1c8a1SJohn Marino 		md = (char *) OBJ_nid2sn(def_nid);
873f5b1c8a1SJohn Marino 	}
874f5b1c8a1SJohn Marino 	if ((dgst = EVP_get_digestbyname(md)) == NULL) {
875f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
876f5b1c8a1SJohn Marino 		    "%s is an unsupported message digest type\n", md);
877f5b1c8a1SJohn Marino 		goto err;
878f5b1c8a1SJohn Marino 	}
879f5b1c8a1SJohn Marino 	if (req) {
880f5b1c8a1SJohn Marino 		if ((email_dn == 1) && ((tmp_email_dn = NCONF_get_string(conf,
881f5b1c8a1SJohn Marino 		    section, ENV_DEFAULT_EMAIL_DN)) != NULL)) {
882f5b1c8a1SJohn Marino 			if (strcmp(tmp_email_dn, "no") == 0)
883f5b1c8a1SJohn Marino 				email_dn = 0;
884f5b1c8a1SJohn Marino 		}
885f5b1c8a1SJohn Marino 		if (verbose)
886f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "message digest is %s\n",
887f5b1c8a1SJohn Marino 			    OBJ_nid2ln(dgst->type));
888f5b1c8a1SJohn Marino 		if ((policy == NULL) && ((policy = NCONF_get_string(conf,
889f5b1c8a1SJohn Marino 		    section, ENV_POLICY)) == NULL)) {
890f5b1c8a1SJohn Marino 			lookup_fail(section, ENV_POLICY);
891f5b1c8a1SJohn Marino 			goto err;
892f5b1c8a1SJohn Marino 		}
893f5b1c8a1SJohn Marino 		if (verbose)
894f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "policy is %s\n", policy);
895f5b1c8a1SJohn Marino 
896f5b1c8a1SJohn Marino 		if ((serialfile = NCONF_get_string(conf, section,
897f5b1c8a1SJohn Marino 		    ENV_SERIAL)) == NULL) {
898f5b1c8a1SJohn Marino 			lookup_fail(section, ENV_SERIAL);
899f5b1c8a1SJohn Marino 			goto err;
900f5b1c8a1SJohn Marino 		}
901f5b1c8a1SJohn Marino 		if (!extconf) {
902f5b1c8a1SJohn Marino 			/*
903f5b1c8a1SJohn Marino 			 * no '-extfile' option, so we look for extensions in
904f5b1c8a1SJohn Marino 			 * the main configuration file
905f5b1c8a1SJohn Marino 			 */
906f5b1c8a1SJohn Marino 			if (!extensions) {
907f5b1c8a1SJohn Marino 				extensions = NCONF_get_string(conf, section,
908f5b1c8a1SJohn Marino 				    ENV_EXTENSIONS);
909f5b1c8a1SJohn Marino 				if (!extensions)
910f5b1c8a1SJohn Marino 					ERR_clear_error();
911f5b1c8a1SJohn Marino 			}
912f5b1c8a1SJohn Marino 			if (extensions) {
913f5b1c8a1SJohn Marino 				/* Check syntax of file */
914f5b1c8a1SJohn Marino 				X509V3_CTX ctx;
915f5b1c8a1SJohn Marino 				X509V3_set_ctx_test(&ctx);
916f5b1c8a1SJohn Marino 				X509V3_set_nconf(&ctx, conf);
917f5b1c8a1SJohn Marino 				if (!X509V3_EXT_add_nconf(conf, &ctx,
918f5b1c8a1SJohn Marino 				    extensions, NULL)) {
919f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
920f5b1c8a1SJohn Marino 					    "Error Loading extension section %s\n",
921f5b1c8a1SJohn Marino 					    extensions);
922f5b1c8a1SJohn Marino 					ret = 1;
923f5b1c8a1SJohn Marino 					goto err;
924f5b1c8a1SJohn Marino 				}
925f5b1c8a1SJohn Marino 			}
926f5b1c8a1SJohn Marino 		}
927f5b1c8a1SJohn Marino 		if (startdate == NULL) {
928f5b1c8a1SJohn Marino 			startdate = NCONF_get_string(conf, section,
929f5b1c8a1SJohn Marino 			    ENV_DEFAULT_STARTDATE);
930f5b1c8a1SJohn Marino 			if (startdate == NULL)
931f5b1c8a1SJohn Marino 				ERR_clear_error();
932f5b1c8a1SJohn Marino 		}
933f5b1c8a1SJohn Marino 		if (startdate && !ASN1_TIME_set_string(NULL, startdate)) {
934f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "start date is invalid, it should be YYMMDDHHMMSSZ or YYYYMMDDHHMMSSZ\n");
935f5b1c8a1SJohn Marino 			goto err;
936f5b1c8a1SJohn Marino 		}
937f5b1c8a1SJohn Marino 		if (startdate == NULL)
938f5b1c8a1SJohn Marino 			startdate = "today";
939f5b1c8a1SJohn Marino 
940f5b1c8a1SJohn Marino 		if (enddate == NULL) {
941f5b1c8a1SJohn Marino 			enddate = NCONF_get_string(conf, section,
942f5b1c8a1SJohn Marino 			    ENV_DEFAULT_ENDDATE);
943f5b1c8a1SJohn Marino 			if (enddate == NULL)
944f5b1c8a1SJohn Marino 				ERR_clear_error();
945f5b1c8a1SJohn Marino 		}
946f5b1c8a1SJohn Marino 		if (enddate && !ASN1_TIME_set_string(NULL, enddate)) {
947f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "end date is invalid, it should be YYMMDDHHMMSSZ or YYYYMMDDHHMMSSZ\n");
948f5b1c8a1SJohn Marino 			goto err;
949f5b1c8a1SJohn Marino 		}
950f5b1c8a1SJohn Marino 		if (days == 0) {
951f5b1c8a1SJohn Marino 			if (!NCONF_get_number(conf, section,
952f5b1c8a1SJohn Marino 			    ENV_DEFAULT_DAYS, &days))
953f5b1c8a1SJohn Marino 				days = 0;
954f5b1c8a1SJohn Marino 		}
955f5b1c8a1SJohn Marino 		if (!enddate && (days == 0)) {
956f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
957f5b1c8a1SJohn Marino 			    "cannot lookup how many days to certify for\n");
958f5b1c8a1SJohn Marino 			goto err;
959f5b1c8a1SJohn Marino 		}
960f5b1c8a1SJohn Marino 		if ((serial = load_serial(serialfile, create_ser, NULL)) ==
961f5b1c8a1SJohn Marino 		    NULL) {
962f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
963f5b1c8a1SJohn Marino 			    "error while loading serial number\n");
964f5b1c8a1SJohn Marino 			goto err;
965f5b1c8a1SJohn Marino 		}
966f5b1c8a1SJohn Marino 		if (verbose) {
967f5b1c8a1SJohn Marino 			if (BN_is_zero(serial))
968f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
969f5b1c8a1SJohn Marino 				    "next serial number is 00\n");
970f5b1c8a1SJohn Marino 			else {
971f5b1c8a1SJohn Marino 				if ((f = BN_bn2hex(serial)) == NULL)
972f5b1c8a1SJohn Marino 					goto err;
973f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
974f5b1c8a1SJohn Marino 				    "next serial number is %s\n", f);
975f5b1c8a1SJohn Marino 				free(f);
976f5b1c8a1SJohn Marino 			}
977f5b1c8a1SJohn Marino 		}
978f5b1c8a1SJohn Marino 		if ((attribs = NCONF_get_section(conf, policy)) == NULL) {
979f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
980f5b1c8a1SJohn Marino 			    "unable to find 'section' for %s\n", policy);
981f5b1c8a1SJohn Marino 			goto err;
982f5b1c8a1SJohn Marino 		}
983f5b1c8a1SJohn Marino 		if ((cert_sk = sk_X509_new_null()) == NULL) {
984f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Memory allocation failure\n");
985f5b1c8a1SJohn Marino 			goto err;
986f5b1c8a1SJohn Marino 		}
987f5b1c8a1SJohn Marino 		if (spkac_file != NULL) {
988f5b1c8a1SJohn Marino 			total++;
989f5b1c8a1SJohn Marino 			j = certify_spkac(&x, spkac_file, pkey, x509, dgst,
990f5b1c8a1SJohn Marino 			    sigopts, attribs, db, serial, subj, chtype,
991f5b1c8a1SJohn Marino 			    multirdn, email_dn, startdate, enddate, days,
992f5b1c8a1SJohn Marino 			    extensions, conf, verbose, certopt, nameopt,
993f5b1c8a1SJohn Marino 			    default_op, ext_copy);
994f5b1c8a1SJohn Marino 			if (j < 0)
995f5b1c8a1SJohn Marino 				goto err;
996f5b1c8a1SJohn Marino 			if (j > 0) {
997f5b1c8a1SJohn Marino 				total_done++;
998f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "\n");
999f5b1c8a1SJohn Marino 				if (!BN_add_word(serial, 1))
1000f5b1c8a1SJohn Marino 					goto err;
1001f5b1c8a1SJohn Marino 				if (!sk_X509_push(cert_sk, x)) {
1002f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
1003f5b1c8a1SJohn Marino 					    "Memory allocation failure\n");
1004f5b1c8a1SJohn Marino 					goto err;
1005f5b1c8a1SJohn Marino 				}
1006f5b1c8a1SJohn Marino 				if (outfile) {
1007f5b1c8a1SJohn Marino 					output_der = 1;
1008f5b1c8a1SJohn Marino 					batch = 1;
1009f5b1c8a1SJohn Marino 				}
1010f5b1c8a1SJohn Marino 			}
1011f5b1c8a1SJohn Marino 		}
1012f5b1c8a1SJohn Marino 		if (ss_cert_file != NULL) {
1013f5b1c8a1SJohn Marino 			total++;
1014f5b1c8a1SJohn Marino 			j = certify_cert(&x, ss_cert_file, pkey, x509, dgst,
1015f5b1c8a1SJohn Marino 			    sigopts, attribs, db, serial, subj, chtype,
1016f5b1c8a1SJohn Marino 			    multirdn, email_dn, startdate, enddate, days, batch,
1017f5b1c8a1SJohn Marino 			    extensions, conf, verbose, certopt, nameopt,
1018f5b1c8a1SJohn Marino 			    default_op, ext_copy);
1019f5b1c8a1SJohn Marino 			if (j < 0)
1020f5b1c8a1SJohn Marino 				goto err;
1021f5b1c8a1SJohn Marino 			if (j > 0) {
1022f5b1c8a1SJohn Marino 				total_done++;
1023f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "\n");
1024f5b1c8a1SJohn Marino 				if (!BN_add_word(serial, 1))
1025f5b1c8a1SJohn Marino 					goto err;
1026f5b1c8a1SJohn Marino 				if (!sk_X509_push(cert_sk, x)) {
1027f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
1028f5b1c8a1SJohn Marino 					    "Memory allocation failure\n");
1029f5b1c8a1SJohn Marino 					goto err;
1030f5b1c8a1SJohn Marino 				}
1031f5b1c8a1SJohn Marino 			}
1032f5b1c8a1SJohn Marino 		}
1033f5b1c8a1SJohn Marino 		if (infile != NULL) {
1034f5b1c8a1SJohn Marino 			total++;
1035f5b1c8a1SJohn Marino 			j = certify(&x, infile, pkey, x509p, dgst, sigopts,
1036f5b1c8a1SJohn Marino 			    attribs, db, serial, subj, chtype, multirdn,
1037f5b1c8a1SJohn Marino 			    email_dn, startdate, enddate, days, batch,
1038f5b1c8a1SJohn Marino 			    extensions, conf, verbose, certopt, nameopt,
1039f5b1c8a1SJohn Marino 			    default_op, ext_copy, selfsign);
1040f5b1c8a1SJohn Marino 			if (j < 0)
1041f5b1c8a1SJohn Marino 				goto err;
1042f5b1c8a1SJohn Marino 			if (j > 0) {
1043f5b1c8a1SJohn Marino 				total_done++;
1044f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "\n");
1045f5b1c8a1SJohn Marino 				if (!BN_add_word(serial, 1))
1046f5b1c8a1SJohn Marino 					goto err;
1047f5b1c8a1SJohn Marino 				if (!sk_X509_push(cert_sk, x)) {
1048f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
1049f5b1c8a1SJohn Marino 					    "Memory allocation failure\n");
1050f5b1c8a1SJohn Marino 					goto err;
1051f5b1c8a1SJohn Marino 				}
1052f5b1c8a1SJohn Marino 			}
1053f5b1c8a1SJohn Marino 		}
1054f5b1c8a1SJohn Marino 		for (i = 0; i < argc; i++) {
1055f5b1c8a1SJohn Marino 			total++;
1056f5b1c8a1SJohn Marino 			j = certify(&x, argv[i], pkey, x509p, dgst, sigopts,
1057f5b1c8a1SJohn Marino 			    attribs, db, serial, subj, chtype, multirdn,
1058f5b1c8a1SJohn Marino 			    email_dn, startdate, enddate, days, batch,
1059f5b1c8a1SJohn Marino 			    extensions, conf, verbose, certopt, nameopt,
1060f5b1c8a1SJohn Marino 			    default_op, ext_copy, selfsign);
1061f5b1c8a1SJohn Marino 			if (j < 0)
1062f5b1c8a1SJohn Marino 				goto err;
1063f5b1c8a1SJohn Marino 			if (j > 0) {
1064f5b1c8a1SJohn Marino 				total_done++;
1065f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "\n");
1066f5b1c8a1SJohn Marino 				if (!BN_add_word(serial, 1))
1067f5b1c8a1SJohn Marino 					goto err;
1068f5b1c8a1SJohn Marino 				if (!sk_X509_push(cert_sk, x)) {
1069f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
1070f5b1c8a1SJohn Marino 					    "Memory allocation failure\n");
1071f5b1c8a1SJohn Marino 					goto err;
1072f5b1c8a1SJohn Marino 				}
1073f5b1c8a1SJohn Marino 			}
1074f5b1c8a1SJohn Marino 		}
1075f5b1c8a1SJohn Marino 		/*
1076f5b1c8a1SJohn Marino 		 * we have a stack of newly certified certificates and a data
1077f5b1c8a1SJohn Marino 		 * base and serial number that need updating
1078f5b1c8a1SJohn Marino 		 */
1079f5b1c8a1SJohn Marino 
1080f5b1c8a1SJohn Marino 		if (sk_X509_num(cert_sk) > 0) {
1081f5b1c8a1SJohn Marino 			if (!batch) {
1082f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "\n%d out of %d certificate requests certified, commit? [y/n]", total_done, total);
1083f5b1c8a1SJohn Marino 				(void) BIO_flush(bio_err);
1084f5b1c8a1SJohn Marino 				buf[0][0] = '\0';
1085f5b1c8a1SJohn Marino 				if (!fgets(buf[0], 10, stdin)) {
1086f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "CERTIFICATION CANCELED: I/O error\n");
1087f5b1c8a1SJohn Marino 					ret = 0;
1088f5b1c8a1SJohn Marino 					goto err;
1089f5b1c8a1SJohn Marino 				}
1090f5b1c8a1SJohn Marino 				if ((buf[0][0] != 'y') && (buf[0][0] != 'Y')) {
1091f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "CERTIFICATION CANCELED\n");
1092f5b1c8a1SJohn Marino 					ret = 0;
1093f5b1c8a1SJohn Marino 					goto err;
1094f5b1c8a1SJohn Marino 				}
1095f5b1c8a1SJohn Marino 			}
1096f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Write out database with %d new entries\n", sk_X509_num(cert_sk));
1097f5b1c8a1SJohn Marino 
1098f5b1c8a1SJohn Marino 			if (!save_serial(serialfile, "new", serial, NULL))
1099f5b1c8a1SJohn Marino 				goto err;
1100f5b1c8a1SJohn Marino 
1101f5b1c8a1SJohn Marino 			if (!save_index(dbfile, "new", db))
1102f5b1c8a1SJohn Marino 				goto err;
1103f5b1c8a1SJohn Marino 		}
1104f5b1c8a1SJohn Marino 		if (verbose)
1105f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "writing new certificates\n");
1106f5b1c8a1SJohn Marino 		for (i = 0; i < sk_X509_num(cert_sk); i++) {
1107f5b1c8a1SJohn Marino 			int k;
1108f5b1c8a1SJohn Marino 			char *serialstr;
1109f5b1c8a1SJohn Marino 			unsigned char *data;
1110f5b1c8a1SJohn Marino 
1111f5b1c8a1SJohn Marino 			x = sk_X509_value(cert_sk, i);
1112f5b1c8a1SJohn Marino 
1113f5b1c8a1SJohn Marino 			j = x->cert_info->serialNumber->length;
1114f5b1c8a1SJohn Marino 			data = (unsigned char *)x->cert_info->serialNumber->data;
1115f5b1c8a1SJohn Marino 			if (j > 0)
1116f5b1c8a1SJohn Marino 				serialstr = bin2hex(data, j);
1117f5b1c8a1SJohn Marino 			else
1118f5b1c8a1SJohn Marino 				serialstr = strdup("00");
1119f5b1c8a1SJohn Marino 			if (serialstr) {
1120f5b1c8a1SJohn Marino 				k = snprintf(buf[2], sizeof(buf[2]),
1121f5b1c8a1SJohn Marino 				    "%s/%s.pem", outdir, serialstr);
1122f5b1c8a1SJohn Marino 				free(serialstr);
1123f5b1c8a1SJohn Marino 				if (k == -1 || k >= sizeof(buf[2])) {
1124f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
1125f5b1c8a1SJohn Marino 					    "certificate file name too long\n");
1126f5b1c8a1SJohn Marino 					goto err;
1127f5b1c8a1SJohn Marino 				}
1128f5b1c8a1SJohn Marino 			} else {
1129f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
1130f5b1c8a1SJohn Marino 				    "memory allocation failed\n");
1131f5b1c8a1SJohn Marino 				goto err;
1132f5b1c8a1SJohn Marino 			}
1133f5b1c8a1SJohn Marino 			if (verbose)
1134f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "writing %s\n", buf[2]);
1135f5b1c8a1SJohn Marino 
1136f5b1c8a1SJohn Marino 			if (BIO_write_filename(Cout, buf[2]) <= 0) {
1137f5b1c8a1SJohn Marino 				perror(buf[2]);
1138f5b1c8a1SJohn Marino 				goto err;
1139f5b1c8a1SJohn Marino 			}
1140f5b1c8a1SJohn Marino 			write_new_certificate(Cout, x, 0, notext);
1141f5b1c8a1SJohn Marino 			write_new_certificate(Sout, x, output_der, notext);
1142f5b1c8a1SJohn Marino 		}
1143f5b1c8a1SJohn Marino 
1144f5b1c8a1SJohn Marino 		if (sk_X509_num(cert_sk)) {
1145f5b1c8a1SJohn Marino 			/* Rename the database and the serial file */
1146f5b1c8a1SJohn Marino 			if (!rotate_serial(serialfile, "new", "old"))
1147f5b1c8a1SJohn Marino 				goto err;
1148f5b1c8a1SJohn Marino 
1149f5b1c8a1SJohn Marino 			if (!rotate_index(dbfile, "new", "old"))
1150f5b1c8a1SJohn Marino 				goto err;
1151f5b1c8a1SJohn Marino 
1152f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Data Base Updated\n");
1153f5b1c8a1SJohn Marino 		}
1154f5b1c8a1SJohn Marino 	}
1155f5b1c8a1SJohn Marino 	/*****************************************************************/
1156f5b1c8a1SJohn Marino 	if (gencrl) {
1157f5b1c8a1SJohn Marino 		int crl_v2 = 0;
1158f5b1c8a1SJohn Marino 		if (!crl_ext) {
1159f5b1c8a1SJohn Marino 			crl_ext = NCONF_get_string(conf, section, ENV_CRLEXT);
1160f5b1c8a1SJohn Marino 			if (!crl_ext)
1161f5b1c8a1SJohn Marino 				ERR_clear_error();
1162f5b1c8a1SJohn Marino 		}
1163f5b1c8a1SJohn Marino 		if (crl_ext) {
1164f5b1c8a1SJohn Marino 			/* Check syntax of file */
1165f5b1c8a1SJohn Marino 			X509V3_CTX ctx;
1166f5b1c8a1SJohn Marino 			X509V3_set_ctx_test(&ctx);
1167f5b1c8a1SJohn Marino 			X509V3_set_nconf(&ctx, conf);
1168f5b1c8a1SJohn Marino 			if (!X509V3_EXT_add_nconf(conf, &ctx, crl_ext, NULL)) {
1169f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
1170f5b1c8a1SJohn Marino 				    "Error Loading CRL extension section %s\n",
1171f5b1c8a1SJohn Marino 				    crl_ext);
1172f5b1c8a1SJohn Marino 				ret = 1;
1173f5b1c8a1SJohn Marino 				goto err;
1174f5b1c8a1SJohn Marino 			}
1175f5b1c8a1SJohn Marino 		}
1176f5b1c8a1SJohn Marino 		if ((crlnumberfile = NCONF_get_string(conf, section,
1177f5b1c8a1SJohn Marino 		    ENV_CRLNUMBER)) != NULL)
1178f5b1c8a1SJohn Marino 			if ((crlnumber = load_serial(crlnumberfile, 0,
1179f5b1c8a1SJohn Marino 			    NULL)) == NULL) {
1180f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
1181f5b1c8a1SJohn Marino 				    "error while loading CRL number\n");
1182f5b1c8a1SJohn Marino 				goto err;
1183f5b1c8a1SJohn Marino 			}
1184f5b1c8a1SJohn Marino 		if (!crldays && !crlhours && !crlsec) {
1185f5b1c8a1SJohn Marino 			if (!NCONF_get_number(conf, section,
1186f5b1c8a1SJohn Marino 			    ENV_DEFAULT_CRL_DAYS, &crldays))
1187f5b1c8a1SJohn Marino 				crldays = 0;
1188f5b1c8a1SJohn Marino 			if (!NCONF_get_number(conf, section,
1189f5b1c8a1SJohn Marino 			    ENV_DEFAULT_CRL_HOURS, &crlhours))
1190f5b1c8a1SJohn Marino 				crlhours = 0;
1191f5b1c8a1SJohn Marino 			ERR_clear_error();
1192f5b1c8a1SJohn Marino 		}
1193f5b1c8a1SJohn Marino 		if ((crldays == 0) && (crlhours == 0) && (crlsec == 0)) {
1194f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "cannot lookup how long until the next CRL is issued\n");
1195f5b1c8a1SJohn Marino 			goto err;
1196f5b1c8a1SJohn Marino 		}
1197f5b1c8a1SJohn Marino 		if (verbose)
1198f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "making CRL\n");
1199f5b1c8a1SJohn Marino 		if ((crl = X509_CRL_new()) == NULL)
1200f5b1c8a1SJohn Marino 			goto err;
1201f5b1c8a1SJohn Marino 		if (!X509_CRL_set_issuer_name(crl, X509_get_subject_name(x509)))
1202f5b1c8a1SJohn Marino 			goto err;
1203f5b1c8a1SJohn Marino 
1204f5b1c8a1SJohn Marino 		tmptm = ASN1_TIME_new();
1205f5b1c8a1SJohn Marino 		if (!tmptm)
1206f5b1c8a1SJohn Marino 			goto err;
1207f5b1c8a1SJohn Marino 		X509_gmtime_adj(tmptm, 0);
1208f5b1c8a1SJohn Marino 		X509_CRL_set_lastUpdate(crl, tmptm);
1209f5b1c8a1SJohn Marino 		if (!X509_time_adj_ex(tmptm, crldays,
1210f5b1c8a1SJohn Marino 		    crlhours * 60 * 60 + crlsec, NULL)) {
1211f5b1c8a1SJohn Marino 			BIO_puts(bio_err, "error setting CRL nextUpdate\n");
1212f5b1c8a1SJohn Marino 			goto err;
1213f5b1c8a1SJohn Marino 		}
1214f5b1c8a1SJohn Marino 		X509_CRL_set_nextUpdate(crl, tmptm);
1215f5b1c8a1SJohn Marino 
1216f5b1c8a1SJohn Marino 		ASN1_TIME_free(tmptm);
1217f5b1c8a1SJohn Marino 
1218f5b1c8a1SJohn Marino 		for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
1219f5b1c8a1SJohn Marino 			pp = sk_OPENSSL_PSTRING_value(db->db->data, i);
1220f5b1c8a1SJohn Marino 			if (pp[DB_type][0] == DB_TYPE_REV) {
1221f5b1c8a1SJohn Marino 				if ((r = X509_REVOKED_new()) == NULL)
1222f5b1c8a1SJohn Marino 					goto err;
1223f5b1c8a1SJohn Marino 				j = make_revoked(r, pp[DB_rev_date]);
1224f5b1c8a1SJohn Marino 				if (!j)
1225f5b1c8a1SJohn Marino 					goto err;
1226f5b1c8a1SJohn Marino 				if (j == 2)
1227f5b1c8a1SJohn Marino 					crl_v2 = 1;
1228f5b1c8a1SJohn Marino 				if (!BN_hex2bn(&serial, pp[DB_serial]))
1229f5b1c8a1SJohn Marino 					goto err;
1230f5b1c8a1SJohn Marino 				tmpser = BN_to_ASN1_INTEGER(serial, NULL);
1231f5b1c8a1SJohn Marino 				BN_free(serial);
1232f5b1c8a1SJohn Marino 				serial = NULL;
1233f5b1c8a1SJohn Marino 				if (!tmpser)
1234f5b1c8a1SJohn Marino 					goto err;
1235f5b1c8a1SJohn Marino 				X509_REVOKED_set_serialNumber(r, tmpser);
1236f5b1c8a1SJohn Marino 				ASN1_INTEGER_free(tmpser);
1237f5b1c8a1SJohn Marino 				X509_CRL_add0_revoked(crl, r);
1238f5b1c8a1SJohn Marino 			}
1239f5b1c8a1SJohn Marino 		}
1240f5b1c8a1SJohn Marino 
1241f5b1c8a1SJohn Marino 		/*
1242f5b1c8a1SJohn Marino 		 * sort the data so it will be written in serial number order
1243f5b1c8a1SJohn Marino 		 */
1244f5b1c8a1SJohn Marino 		X509_CRL_sort(crl);
1245f5b1c8a1SJohn Marino 
1246f5b1c8a1SJohn Marino 		/* we now have a CRL */
1247f5b1c8a1SJohn Marino 		if (verbose)
1248f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "signing CRL\n");
1249f5b1c8a1SJohn Marino 
1250f5b1c8a1SJohn Marino 		/* Add any extensions asked for */
1251f5b1c8a1SJohn Marino 
1252f5b1c8a1SJohn Marino 		if (crl_ext || crlnumberfile != NULL) {
1253f5b1c8a1SJohn Marino 			X509V3_CTX crlctx;
1254f5b1c8a1SJohn Marino 			X509V3_set_ctx(&crlctx, x509, NULL, NULL, crl, 0);
1255f5b1c8a1SJohn Marino 			X509V3_set_nconf(&crlctx, conf);
1256f5b1c8a1SJohn Marino 
1257f5b1c8a1SJohn Marino 			if (crl_ext)
1258f5b1c8a1SJohn Marino 				if (!X509V3_EXT_CRL_add_nconf(conf, &crlctx,
1259f5b1c8a1SJohn Marino 				    crl_ext, crl))
1260f5b1c8a1SJohn Marino 					goto err;
1261f5b1c8a1SJohn Marino 			if (crlnumberfile != NULL) {
1262f5b1c8a1SJohn Marino 				tmpser = BN_to_ASN1_INTEGER(crlnumber, NULL);
1263f5b1c8a1SJohn Marino 				if (!tmpser)
1264f5b1c8a1SJohn Marino 					goto err;
1265f5b1c8a1SJohn Marino 				X509_CRL_add1_ext_i2d(crl, NID_crl_number,
1266f5b1c8a1SJohn Marino 				    tmpser, 0, 0);
1267f5b1c8a1SJohn Marino 				ASN1_INTEGER_free(tmpser);
1268f5b1c8a1SJohn Marino 				crl_v2 = 1;
1269f5b1c8a1SJohn Marino 				if (!BN_add_word(crlnumber, 1))
1270f5b1c8a1SJohn Marino 					goto err;
1271f5b1c8a1SJohn Marino 			}
1272f5b1c8a1SJohn Marino 		}
1273f5b1c8a1SJohn Marino 		if (crl_ext || crl_v2) {
1274f5b1c8a1SJohn Marino 			if (!X509_CRL_set_version(crl, 1))
1275f5b1c8a1SJohn Marino 				goto err;	/* version 2 CRL */
1276f5b1c8a1SJohn Marino 		}
1277f5b1c8a1SJohn Marino 		if (crlnumberfile != NULL)	/* we have a CRL number that
1278f5b1c8a1SJohn Marino 						 * need updating */
1279f5b1c8a1SJohn Marino 			if (!save_serial(crlnumberfile, "new", crlnumber, NULL))
1280f5b1c8a1SJohn Marino 				goto err;
1281f5b1c8a1SJohn Marino 
1282f5b1c8a1SJohn Marino 		if (crlnumber) {
1283f5b1c8a1SJohn Marino 			BN_free(crlnumber);
1284f5b1c8a1SJohn Marino 			crlnumber = NULL;
1285f5b1c8a1SJohn Marino 		}
1286f5b1c8a1SJohn Marino 		if (!do_X509_CRL_sign(bio_err, crl, pkey, dgst, sigopts))
1287f5b1c8a1SJohn Marino 			goto err;
1288f5b1c8a1SJohn Marino 
1289f5b1c8a1SJohn Marino 		PEM_write_bio_X509_CRL(Sout, crl);
1290f5b1c8a1SJohn Marino 
1291f5b1c8a1SJohn Marino 		if (crlnumberfile != NULL)	/* Rename the crlnumber file */
1292f5b1c8a1SJohn Marino 			if (!rotate_serial(crlnumberfile, "new", "old"))
1293f5b1c8a1SJohn Marino 				goto err;
1294f5b1c8a1SJohn Marino 
1295f5b1c8a1SJohn Marino 	}
1296f5b1c8a1SJohn Marino 	/*****************************************************************/
1297f5b1c8a1SJohn Marino 	if (dorevoke) {
1298f5b1c8a1SJohn Marino 		if (infile == NULL) {
1299f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "no input files\n");
1300f5b1c8a1SJohn Marino 			goto err;
1301f5b1c8a1SJohn Marino 		} else {
1302f5b1c8a1SJohn Marino 			X509 *revcert;
1303f5b1c8a1SJohn Marino 			revcert = load_cert(bio_err, infile, FORMAT_PEM,
1304f5b1c8a1SJohn Marino 			    NULL, infile);
1305f5b1c8a1SJohn Marino 			if (revcert == NULL)
1306f5b1c8a1SJohn Marino 				goto err;
1307f5b1c8a1SJohn Marino 			j = do_revoke(revcert, db, rev_type, rev_arg);
1308f5b1c8a1SJohn Marino 			if (j <= 0)
1309f5b1c8a1SJohn Marino 				goto err;
1310f5b1c8a1SJohn Marino 			X509_free(revcert);
1311f5b1c8a1SJohn Marino 
1312f5b1c8a1SJohn Marino 			if (!save_index(dbfile, "new", db))
1313f5b1c8a1SJohn Marino 				goto err;
1314f5b1c8a1SJohn Marino 
1315f5b1c8a1SJohn Marino 			if (!rotate_index(dbfile, "new", "old"))
1316f5b1c8a1SJohn Marino 				goto err;
1317f5b1c8a1SJohn Marino 
1318f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Data Base Updated\n");
1319f5b1c8a1SJohn Marino 		}
1320f5b1c8a1SJohn Marino 	}
1321f5b1c8a1SJohn Marino 	/*****************************************************************/
1322f5b1c8a1SJohn Marino 	ret = 0;
1323f5b1c8a1SJohn Marino 
1324f5b1c8a1SJohn Marino err:
1325f5b1c8a1SJohn Marino 	free(tofree);
1326f5b1c8a1SJohn Marino 
1327f5b1c8a1SJohn Marino 	BIO_free_all(Cout);
1328f5b1c8a1SJohn Marino 	BIO_free_all(Sout);
1329f5b1c8a1SJohn Marino 	BIO_free_all(out);
1330f5b1c8a1SJohn Marino 	BIO_free_all(in);
1331f5b1c8a1SJohn Marino 
1332f5b1c8a1SJohn Marino 	if (cert_sk)
1333f5b1c8a1SJohn Marino 		sk_X509_pop_free(cert_sk, X509_free);
1334f5b1c8a1SJohn Marino 
1335f5b1c8a1SJohn Marino 	if (ret)
1336f5b1c8a1SJohn Marino 		ERR_print_errors(bio_err);
1337f5b1c8a1SJohn Marino 	if (free_key && key)
1338f5b1c8a1SJohn Marino 		free(key);
1339f5b1c8a1SJohn Marino 	BN_free(serial);
1340f5b1c8a1SJohn Marino 	BN_free(crlnumber);
1341f5b1c8a1SJohn Marino 	free_index(db);
1342f5b1c8a1SJohn Marino 	if (sigopts)
1343f5b1c8a1SJohn Marino 		sk_OPENSSL_STRING_free(sigopts);
1344f5b1c8a1SJohn Marino 	EVP_PKEY_free(pkey);
1345f5b1c8a1SJohn Marino 	if (x509)
1346f5b1c8a1SJohn Marino 		X509_free(x509);
1347f5b1c8a1SJohn Marino 	X509_CRL_free(crl);
1348f5b1c8a1SJohn Marino 	NCONF_free(conf);
1349f5b1c8a1SJohn Marino 	NCONF_free(extconf);
1350f5b1c8a1SJohn Marino 	OBJ_cleanup();
1351f5b1c8a1SJohn Marino 
1352f5b1c8a1SJohn Marino 	return (ret);
1353f5b1c8a1SJohn Marino }
1354f5b1c8a1SJohn Marino 
1355f5b1c8a1SJohn Marino static void
1356f5b1c8a1SJohn Marino lookup_fail(const char *name, const char *tag)
1357f5b1c8a1SJohn Marino {
1358f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "variable lookup failed for %s::%s\n", name, tag);
1359f5b1c8a1SJohn Marino }
1360f5b1c8a1SJohn Marino 
1361f5b1c8a1SJohn Marino static int
1362f5b1c8a1SJohn Marino certify(X509 ** xret, char *infile, EVP_PKEY * pkey, X509 * x509,
1363f5b1c8a1SJohn Marino     const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
1364f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
1365f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
1366f5b1c8a1SJohn Marino     char *enddate, long days, int batch, char *ext_sect, CONF * lconf,
1367f5b1c8a1SJohn Marino     int verbose, unsigned long certopt, unsigned long nameopt, int default_op,
1368f5b1c8a1SJohn Marino     int ext_copy, int selfsign)
1369f5b1c8a1SJohn Marino {
1370f5b1c8a1SJohn Marino 	X509_REQ *req = NULL;
1371f5b1c8a1SJohn Marino 	BIO *in = NULL;
1372f5b1c8a1SJohn Marino 	EVP_PKEY *pktmp = NULL;
1373f5b1c8a1SJohn Marino 	int ok = -1, i;
1374f5b1c8a1SJohn Marino 
1375f5b1c8a1SJohn Marino 	in = BIO_new(BIO_s_file());
1376f5b1c8a1SJohn Marino 
1377f5b1c8a1SJohn Marino 	if (BIO_read_filename(in, infile) <= 0) {
1378f5b1c8a1SJohn Marino 		perror(infile);
1379f5b1c8a1SJohn Marino 		goto err;
1380f5b1c8a1SJohn Marino 	}
1381f5b1c8a1SJohn Marino 	if ((req = PEM_read_bio_X509_REQ(in, NULL, NULL, NULL)) == NULL) {
1382f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Error reading certificate request in %s\n",
1383f5b1c8a1SJohn Marino 		    infile);
1384f5b1c8a1SJohn Marino 		goto err;
1385f5b1c8a1SJohn Marino 	}
1386f5b1c8a1SJohn Marino 	if (verbose)
1387f5b1c8a1SJohn Marino 		X509_REQ_print(bio_err, req);
1388f5b1c8a1SJohn Marino 
1389f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "Check that the request matches the signature\n");
1390f5b1c8a1SJohn Marino 
1391f5b1c8a1SJohn Marino 	if (selfsign && !X509_REQ_check_private_key(req, pkey)) {
1392f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
1393f5b1c8a1SJohn Marino 		    "Certificate request and CA private key do not match\n");
1394f5b1c8a1SJohn Marino 		ok = 0;
1395f5b1c8a1SJohn Marino 		goto err;
1396f5b1c8a1SJohn Marino 	}
1397f5b1c8a1SJohn Marino 	if ((pktmp = X509_REQ_get_pubkey(req)) == NULL) {
1398f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "error unpacking public key\n");
1399f5b1c8a1SJohn Marino 		goto err;
1400f5b1c8a1SJohn Marino 	}
1401f5b1c8a1SJohn Marino 	i = X509_REQ_verify(req, pktmp);
1402f5b1c8a1SJohn Marino 	EVP_PKEY_free(pktmp);
1403f5b1c8a1SJohn Marino 	if (i < 0) {
1404f5b1c8a1SJohn Marino 		ok = 0;
1405f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Signature verification problems....\n");
1406f5b1c8a1SJohn Marino 		goto err;
1407f5b1c8a1SJohn Marino 	}
1408f5b1c8a1SJohn Marino 	if (i == 0) {
1409f5b1c8a1SJohn Marino 		ok = 0;
1410f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
1411f5b1c8a1SJohn Marino 		    "Signature did not match the certificate request\n");
1412f5b1c8a1SJohn Marino 		goto err;
1413f5b1c8a1SJohn Marino 	} else
1414f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Signature ok\n");
1415f5b1c8a1SJohn Marino 
1416f5b1c8a1SJohn Marino 	ok = do_body(xret, pkey, x509, dgst, sigopts, policy, db, serial,
1417f5b1c8a1SJohn Marino 	    subj, chtype, multirdn, email_dn, startdate, enddate, days, batch,
1418f5b1c8a1SJohn Marino 	    verbose, req, ext_sect, lconf, certopt, nameopt, default_op,
1419f5b1c8a1SJohn Marino 	    ext_copy, selfsign);
1420f5b1c8a1SJohn Marino 
1421f5b1c8a1SJohn Marino err:
1422f5b1c8a1SJohn Marino 	if (req != NULL)
1423f5b1c8a1SJohn Marino 		X509_REQ_free(req);
1424f5b1c8a1SJohn Marino 	if (in != NULL)
1425f5b1c8a1SJohn Marino 		BIO_free(in);
1426f5b1c8a1SJohn Marino 	return (ok);
1427f5b1c8a1SJohn Marino }
1428f5b1c8a1SJohn Marino 
1429f5b1c8a1SJohn Marino static int
1430f5b1c8a1SJohn Marino certify_cert(X509 ** xret, char *infile, EVP_PKEY * pkey, X509 * x509,
1431f5b1c8a1SJohn Marino     const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
1432f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
1433f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
1434f5b1c8a1SJohn Marino     char *enddate, long days, int batch, char *ext_sect, CONF * lconf,
1435f5b1c8a1SJohn Marino     int verbose, unsigned long certopt, unsigned long nameopt, int default_op,
1436f5b1c8a1SJohn Marino     int ext_copy)
1437f5b1c8a1SJohn Marino {
1438f5b1c8a1SJohn Marino 	X509 *req = NULL;
1439f5b1c8a1SJohn Marino 	X509_REQ *rreq = NULL;
1440f5b1c8a1SJohn Marino 	EVP_PKEY *pktmp = NULL;
1441f5b1c8a1SJohn Marino 	int ok = -1, i;
1442f5b1c8a1SJohn Marino 
1443f5b1c8a1SJohn Marino 	if ((req = load_cert(bio_err, infile, FORMAT_PEM, NULL,
1444f5b1c8a1SJohn Marino 	    infile)) == NULL)
1445f5b1c8a1SJohn Marino 		goto err;
1446f5b1c8a1SJohn Marino 	if (verbose)
1447f5b1c8a1SJohn Marino 		X509_print(bio_err, req);
1448f5b1c8a1SJohn Marino 
1449f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "Check that the request matches the signature\n");
1450f5b1c8a1SJohn Marino 
1451f5b1c8a1SJohn Marino 	if ((pktmp = X509_get_pubkey(req)) == NULL) {
1452f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "error unpacking public key\n");
1453f5b1c8a1SJohn Marino 		goto err;
1454f5b1c8a1SJohn Marino 	}
1455f5b1c8a1SJohn Marino 	i = X509_verify(req, pktmp);
1456f5b1c8a1SJohn Marino 	EVP_PKEY_free(pktmp);
1457f5b1c8a1SJohn Marino 	if (i < 0) {
1458f5b1c8a1SJohn Marino 		ok = 0;
1459f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Signature verification problems....\n");
1460f5b1c8a1SJohn Marino 		goto err;
1461f5b1c8a1SJohn Marino 	}
1462f5b1c8a1SJohn Marino 	if (i == 0) {
1463f5b1c8a1SJohn Marino 		ok = 0;
1464f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
1465f5b1c8a1SJohn Marino 		    "Signature did not match the certificate\n");
1466f5b1c8a1SJohn Marino 		goto err;
1467f5b1c8a1SJohn Marino 	} else
1468f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Signature ok\n");
1469f5b1c8a1SJohn Marino 
1470f5b1c8a1SJohn Marino 	if ((rreq = X509_to_X509_REQ(req, NULL, EVP_md5())) == NULL)
1471f5b1c8a1SJohn Marino 		goto err;
1472f5b1c8a1SJohn Marino 
1473f5b1c8a1SJohn Marino 	ok = do_body(xret, pkey, x509, dgst, sigopts, policy, db, serial,
1474f5b1c8a1SJohn Marino 	    subj, chtype, multirdn, email_dn, startdate, enddate, days, batch,
1475f5b1c8a1SJohn Marino 	    verbose, rreq, ext_sect, lconf, certopt, nameopt, default_op,
1476f5b1c8a1SJohn Marino 	    ext_copy, 0);
1477f5b1c8a1SJohn Marino 
1478f5b1c8a1SJohn Marino err:
1479f5b1c8a1SJohn Marino 	if (rreq != NULL)
1480f5b1c8a1SJohn Marino 		X509_REQ_free(rreq);
1481f5b1c8a1SJohn Marino 	if (req != NULL)
1482f5b1c8a1SJohn Marino 		X509_free(req);
1483f5b1c8a1SJohn Marino 	return (ok);
1484f5b1c8a1SJohn Marino }
1485f5b1c8a1SJohn Marino 
1486f5b1c8a1SJohn Marino static int
1487f5b1c8a1SJohn Marino do_body(X509 ** xret, EVP_PKEY * pkey, X509 * x509, const EVP_MD * dgst,
1488f5b1c8a1SJohn Marino     STACK_OF(OPENSSL_STRING) * sigopts, STACK_OF(CONF_VALUE) * policy,
1489f5b1c8a1SJohn Marino     CA_DB * db, BIGNUM * serial, char *subj, unsigned long chtype, int multirdn,
1490f5b1c8a1SJohn Marino     int email_dn, char *startdate, char *enddate, long days, int batch,
1491f5b1c8a1SJohn Marino     int verbose, X509_REQ * req, char *ext_sect, CONF * lconf,
1492f5b1c8a1SJohn Marino     unsigned long certopt, unsigned long nameopt, int default_op,
1493f5b1c8a1SJohn Marino     int ext_copy, int selfsign)
1494f5b1c8a1SJohn Marino {
1495f5b1c8a1SJohn Marino 	X509_NAME *name = NULL, *CAname = NULL, *subject = NULL, *dn_subject = NULL;
1496f5b1c8a1SJohn Marino 	ASN1_UTCTIME *tm, *tmptm;
1497f5b1c8a1SJohn Marino 	ASN1_STRING *str, *str2;
1498f5b1c8a1SJohn Marino 	ASN1_OBJECT *obj;
1499f5b1c8a1SJohn Marino 	X509 *ret = NULL;
1500f5b1c8a1SJohn Marino 	X509_CINF *ci;
1501f5b1c8a1SJohn Marino 	X509_NAME_ENTRY *ne;
1502f5b1c8a1SJohn Marino 	X509_NAME_ENTRY *tne, *push;
1503f5b1c8a1SJohn Marino 	EVP_PKEY *pktmp;
1504f5b1c8a1SJohn Marino 	int ok = -1, i, j, last, nid;
1505f5b1c8a1SJohn Marino 	const char *p;
1506f5b1c8a1SJohn Marino 	CONF_VALUE *cv;
1507f5b1c8a1SJohn Marino 	OPENSSL_STRING row[DB_NUMBER];
1508f5b1c8a1SJohn Marino 	OPENSSL_STRING *irow = NULL;
1509f5b1c8a1SJohn Marino 	OPENSSL_STRING *rrow = NULL;
1510f5b1c8a1SJohn Marino 	char buf[25];
1511f5b1c8a1SJohn Marino 
1512f5b1c8a1SJohn Marino 	tmptm = ASN1_UTCTIME_new();
1513f5b1c8a1SJohn Marino 	if (tmptm == NULL) {
1514f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "malloc error\n");
1515f5b1c8a1SJohn Marino 		return (0);
1516f5b1c8a1SJohn Marino 	}
1517f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++)
1518f5b1c8a1SJohn Marino 		row[i] = NULL;
1519f5b1c8a1SJohn Marino 
1520f5b1c8a1SJohn Marino 	if (subj) {
1521f5b1c8a1SJohn Marino 		X509_NAME *n = parse_name(subj, chtype, multirdn);
1522f5b1c8a1SJohn Marino 
1523f5b1c8a1SJohn Marino 		if (!n) {
1524f5b1c8a1SJohn Marino 			ERR_print_errors(bio_err);
1525f5b1c8a1SJohn Marino 			goto err;
1526f5b1c8a1SJohn Marino 		}
1527f5b1c8a1SJohn Marino 		X509_REQ_set_subject_name(req, n);
1528f5b1c8a1SJohn Marino 		req->req_info->enc.modified = 1;
1529f5b1c8a1SJohn Marino 		X509_NAME_free(n);
1530f5b1c8a1SJohn Marino 	}
1531f5b1c8a1SJohn Marino 	if (default_op)
1532f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
1533f5b1c8a1SJohn Marino 		    "The Subject's Distinguished Name is as follows\n");
1534f5b1c8a1SJohn Marino 
1535f5b1c8a1SJohn Marino 	name = X509_REQ_get_subject_name(req);
1536f5b1c8a1SJohn Marino 	for (i = 0; i < X509_NAME_entry_count(name); i++) {
1537f5b1c8a1SJohn Marino 		ne = X509_NAME_get_entry(name, i);
1538f5b1c8a1SJohn Marino 		str = X509_NAME_ENTRY_get_data(ne);
1539f5b1c8a1SJohn Marino 		obj = X509_NAME_ENTRY_get_object(ne);
1540f5b1c8a1SJohn Marino 
1541f5b1c8a1SJohn Marino 		if (msie_hack) {
1542f5b1c8a1SJohn Marino 			/* assume all type should be strings */
1543f5b1c8a1SJohn Marino 			nid = OBJ_obj2nid(ne->object);
1544f5b1c8a1SJohn Marino 
1545f5b1c8a1SJohn Marino 			if (str->type == V_ASN1_UNIVERSALSTRING)
1546f5b1c8a1SJohn Marino 				ASN1_UNIVERSALSTRING_to_string(str);
1547f5b1c8a1SJohn Marino 
1548f5b1c8a1SJohn Marino 			if ((str->type == V_ASN1_IA5STRING) &&
1549f5b1c8a1SJohn Marino 			    (nid != NID_pkcs9_emailAddress))
1550f5b1c8a1SJohn Marino 				str->type = V_ASN1_T61STRING;
1551f5b1c8a1SJohn Marino 
1552f5b1c8a1SJohn Marino 			if ((nid == NID_pkcs9_emailAddress) &&
1553f5b1c8a1SJohn Marino 			    (str->type == V_ASN1_PRINTABLESTRING))
1554f5b1c8a1SJohn Marino 				str->type = V_ASN1_IA5STRING;
1555f5b1c8a1SJohn Marino 		}
1556f5b1c8a1SJohn Marino 		/* If no EMAIL is wanted in the subject */
1557f5b1c8a1SJohn Marino 		if ((OBJ_obj2nid(obj) == NID_pkcs9_emailAddress) && (!email_dn))
1558f5b1c8a1SJohn Marino 			continue;
1559f5b1c8a1SJohn Marino 
1560f5b1c8a1SJohn Marino 		/* check some things */
1561f5b1c8a1SJohn Marino 		if ((OBJ_obj2nid(obj) == NID_pkcs9_emailAddress) &&
1562f5b1c8a1SJohn Marino 		    (str->type != V_ASN1_IA5STRING)) {
1563f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "\nemailAddress type needs to be of type IA5STRING\n");
1564f5b1c8a1SJohn Marino 			goto err;
1565f5b1c8a1SJohn Marino 		}
1566f5b1c8a1SJohn Marino 		if ((str->type != V_ASN1_BMPSTRING) &&
1567f5b1c8a1SJohn Marino 		    (str->type != V_ASN1_UTF8STRING)) {
1568f5b1c8a1SJohn Marino 			j = ASN1_PRINTABLE_type(str->data, str->length);
1569f5b1c8a1SJohn Marino 			if (((j == V_ASN1_T61STRING) &&
1570f5b1c8a1SJohn Marino 			    (str->type != V_ASN1_T61STRING)) ||
1571f5b1c8a1SJohn Marino 			    ((j == V_ASN1_IA5STRING) &&
1572f5b1c8a1SJohn Marino 			    (str->type == V_ASN1_PRINTABLESTRING))) {
1573f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "\nThe string contains characters that are illegal for the ASN.1 type\n");
1574f5b1c8a1SJohn Marino 				goto err;
1575f5b1c8a1SJohn Marino 			}
1576f5b1c8a1SJohn Marino 		}
1577f5b1c8a1SJohn Marino 		if (default_op)
1578f5b1c8a1SJohn Marino 			old_entry_print(bio_err, obj, str);
1579f5b1c8a1SJohn Marino 	}
1580f5b1c8a1SJohn Marino 
1581f5b1c8a1SJohn Marino 	/* Ok, now we check the 'policy' stuff. */
1582f5b1c8a1SJohn Marino 	if ((subject = X509_NAME_new()) == NULL) {
1583f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Memory allocation failure\n");
1584f5b1c8a1SJohn Marino 		goto err;
1585f5b1c8a1SJohn Marino 	}
1586f5b1c8a1SJohn Marino 	/* take a copy of the issuer name before we mess with it. */
1587f5b1c8a1SJohn Marino 	if (selfsign)
1588f5b1c8a1SJohn Marino 		CAname = X509_NAME_dup(name);
1589f5b1c8a1SJohn Marino 	else
1590f5b1c8a1SJohn Marino 		CAname = X509_NAME_dup(x509->cert_info->subject);
1591f5b1c8a1SJohn Marino 	if (CAname == NULL)
1592f5b1c8a1SJohn Marino 		goto err;
1593f5b1c8a1SJohn Marino 	str = str2 = NULL;
1594f5b1c8a1SJohn Marino 
1595f5b1c8a1SJohn Marino 	for (i = 0; i < sk_CONF_VALUE_num(policy); i++) {
1596f5b1c8a1SJohn Marino 		cv = sk_CONF_VALUE_value(policy, i);	/* get the object id */
1597f5b1c8a1SJohn Marino 		if ((j = OBJ_txt2nid(cv->name)) == NID_undef) {
1598f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "%s:unknown object type in 'policy' configuration\n", cv->name);
1599f5b1c8a1SJohn Marino 			goto err;
1600f5b1c8a1SJohn Marino 		}
1601f5b1c8a1SJohn Marino 		obj = OBJ_nid2obj(j);
1602f5b1c8a1SJohn Marino 
1603f5b1c8a1SJohn Marino 		last = -1;
1604f5b1c8a1SJohn Marino 		for (;;) {
1605f5b1c8a1SJohn Marino 			/* lookup the object in the supplied name list */
1606f5b1c8a1SJohn Marino 			j = X509_NAME_get_index_by_OBJ(name, obj, last);
1607f5b1c8a1SJohn Marino 			if (j < 0) {
1608f5b1c8a1SJohn Marino 				if (last != -1)
1609f5b1c8a1SJohn Marino 					break;
1610f5b1c8a1SJohn Marino 				tne = NULL;
1611f5b1c8a1SJohn Marino 			} else {
1612f5b1c8a1SJohn Marino 				tne = X509_NAME_get_entry(name, j);
1613f5b1c8a1SJohn Marino 			}
1614f5b1c8a1SJohn Marino 			last = j;
1615f5b1c8a1SJohn Marino 
1616f5b1c8a1SJohn Marino 			/* depending on the 'policy', decide what to do. */
1617f5b1c8a1SJohn Marino 			push = NULL;
1618f5b1c8a1SJohn Marino 			if (strcmp(cv->value, "optional") == 0) {
1619f5b1c8a1SJohn Marino 				if (tne != NULL)
1620f5b1c8a1SJohn Marino 					push = tne;
1621f5b1c8a1SJohn Marino 			} else if (strcmp(cv->value, "supplied") == 0) {
1622f5b1c8a1SJohn Marino 				if (tne == NULL) {
1623f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "The %s field needed to be supplied and was missing\n", cv->name);
1624f5b1c8a1SJohn Marino 					goto err;
1625f5b1c8a1SJohn Marino 				} else
1626f5b1c8a1SJohn Marino 					push = tne;
1627f5b1c8a1SJohn Marino 			} else if (strcmp(cv->value, "match") == 0) {
1628f5b1c8a1SJohn Marino 				int last2;
1629f5b1c8a1SJohn Marino 
1630f5b1c8a1SJohn Marino 				if (tne == NULL) {
1631f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "The mandatory %s field was missing\n", cv->name);
1632f5b1c8a1SJohn Marino 					goto err;
1633f5b1c8a1SJohn Marino 				}
1634f5b1c8a1SJohn Marino 				last2 = -1;
1635f5b1c8a1SJohn Marino 
1636f5b1c8a1SJohn Marino again2:
1637f5b1c8a1SJohn Marino 				j = X509_NAME_get_index_by_OBJ(CAname, obj, last2);
1638f5b1c8a1SJohn Marino 				if ((j < 0) && (last2 == -1)) {
1639f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "The %s field does not exist in the CA certificate,\nthe 'policy' is misconfigured\n", cv->name);
1640f5b1c8a1SJohn Marino 					goto err;
1641f5b1c8a1SJohn Marino 				}
1642f5b1c8a1SJohn Marino 				if (j >= 0) {
1643f5b1c8a1SJohn Marino 					push = X509_NAME_get_entry(CAname, j);
1644f5b1c8a1SJohn Marino 					str = X509_NAME_ENTRY_get_data(tne);
1645f5b1c8a1SJohn Marino 					str2 = X509_NAME_ENTRY_get_data(push);
1646f5b1c8a1SJohn Marino 					last2 = j;
1647f5b1c8a1SJohn Marino 					if (ASN1_STRING_cmp(str, str2) != 0)
1648f5b1c8a1SJohn Marino 						goto again2;
1649f5b1c8a1SJohn Marino 				}
1650f5b1c8a1SJohn Marino 				if (j < 0) {
1651f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "The %s field needed to be the same in the\nCA certificate (%s) and the request (%s)\n", cv->name, ((str2 == NULL) ? "NULL" : (char *) str2->data), ((str == NULL) ? "NULL" : (char *) str->data));
1652f5b1c8a1SJohn Marino 					goto err;
1653f5b1c8a1SJohn Marino 				}
1654f5b1c8a1SJohn Marino 			} else {
1655f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "%s:invalid type in 'policy' configuration\n", cv->value);
1656f5b1c8a1SJohn Marino 				goto err;
1657f5b1c8a1SJohn Marino 			}
1658f5b1c8a1SJohn Marino 
1659f5b1c8a1SJohn Marino 			if (push != NULL) {
1660f5b1c8a1SJohn Marino 				if (!X509_NAME_add_entry(subject, push,
1661f5b1c8a1SJohn Marino 				    -1, 0)) {
1662f5b1c8a1SJohn Marino 					if (push != NULL)
1663f5b1c8a1SJohn Marino 						X509_NAME_ENTRY_free(push);
1664f5b1c8a1SJohn Marino 					BIO_printf(bio_err,
1665f5b1c8a1SJohn Marino 					    "Memory allocation failure\n");
1666f5b1c8a1SJohn Marino 					goto err;
1667f5b1c8a1SJohn Marino 				}
1668f5b1c8a1SJohn Marino 			}
1669f5b1c8a1SJohn Marino 			if (j < 0)
1670f5b1c8a1SJohn Marino 				break;
1671f5b1c8a1SJohn Marino 		}
1672f5b1c8a1SJohn Marino 	}
1673f5b1c8a1SJohn Marino 
1674f5b1c8a1SJohn Marino 	if (preserve) {
1675f5b1c8a1SJohn Marino 		X509_NAME_free(subject);
1676f5b1c8a1SJohn Marino 		/* subject=X509_NAME_dup(X509_REQ_get_subject_name(req)); */
1677f5b1c8a1SJohn Marino 		subject = X509_NAME_dup(name);
1678f5b1c8a1SJohn Marino 		if (subject == NULL)
1679f5b1c8a1SJohn Marino 			goto err;
1680f5b1c8a1SJohn Marino 	}
1681f5b1c8a1SJohn Marino 	if (verbose)
1682f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "The subject name appears to be ok, checking data base for clashes\n");
1683f5b1c8a1SJohn Marino 
1684f5b1c8a1SJohn Marino 	/* Build the correct Subject if no email is wanted in the subject */
1685f5b1c8a1SJohn Marino 	/*
1686f5b1c8a1SJohn Marino 	 * and add it later on because of the method extensions are added
1687f5b1c8a1SJohn Marino 	 * (altName)
1688f5b1c8a1SJohn Marino 	 */
1689f5b1c8a1SJohn Marino 
1690f5b1c8a1SJohn Marino 	if (email_dn)
1691f5b1c8a1SJohn Marino 		dn_subject = subject;
1692f5b1c8a1SJohn Marino 	else {
1693f5b1c8a1SJohn Marino 		X509_NAME_ENTRY *tmpne;
1694f5b1c8a1SJohn Marino 		/*
1695f5b1c8a1SJohn Marino 		 * Its best to dup the subject DN and then delete any email
1696f5b1c8a1SJohn Marino 		 * addresses because this retains its structure.
1697f5b1c8a1SJohn Marino 		 */
1698f5b1c8a1SJohn Marino 		if (!(dn_subject = X509_NAME_dup(subject))) {
1699f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Memory allocation failure\n");
1700f5b1c8a1SJohn Marino 			goto err;
1701f5b1c8a1SJohn Marino 		}
1702f5b1c8a1SJohn Marino 		while ((i = X509_NAME_get_index_by_NID(dn_subject,
1703f5b1c8a1SJohn Marino 		    NID_pkcs9_emailAddress, -1)) >= 0) {
1704f5b1c8a1SJohn Marino 			tmpne = X509_NAME_get_entry(dn_subject, i);
1705f5b1c8a1SJohn Marino 			X509_NAME_delete_entry(dn_subject, i);
1706f5b1c8a1SJohn Marino 			X509_NAME_ENTRY_free(tmpne);
1707f5b1c8a1SJohn Marino 		}
1708f5b1c8a1SJohn Marino 	}
1709f5b1c8a1SJohn Marino 
1710f5b1c8a1SJohn Marino 	if (BN_is_zero(serial))
1711f5b1c8a1SJohn Marino 		row[DB_serial] = strdup("00");
1712f5b1c8a1SJohn Marino 	else
1713f5b1c8a1SJohn Marino 		row[DB_serial] = BN_bn2hex(serial);
1714f5b1c8a1SJohn Marino 	if (row[DB_serial] == NULL) {
1715f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Memory allocation failure\n");
1716f5b1c8a1SJohn Marino 		goto err;
1717f5b1c8a1SJohn Marino 	}
1718f5b1c8a1SJohn Marino 	if (db->attributes.unique_subject) {
1719f5b1c8a1SJohn Marino 		OPENSSL_STRING *crow = row;
1720f5b1c8a1SJohn Marino 
1721f5b1c8a1SJohn Marino 		rrow = TXT_DB_get_by_index(db->db, DB_name, crow);
1722f5b1c8a1SJohn Marino 		if (rrow != NULL) {
1723f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
1724f5b1c8a1SJohn Marino 			    "ERROR:There is already a certificate for %s\n",
1725f5b1c8a1SJohn Marino 			    row[DB_name]);
1726f5b1c8a1SJohn Marino 		}
1727f5b1c8a1SJohn Marino 	}
1728f5b1c8a1SJohn Marino 	if (rrow == NULL) {
1729f5b1c8a1SJohn Marino 		rrow = TXT_DB_get_by_index(db->db, DB_serial, row);
1730f5b1c8a1SJohn Marino 		if (rrow != NULL) {
1731f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
1732f5b1c8a1SJohn Marino 			    "ERROR:Serial number %s has already been issued,\n",
1733f5b1c8a1SJohn Marino 			    row[DB_serial]);
1734f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "      check the database/serial_file for corruption\n");
1735f5b1c8a1SJohn Marino 		}
1736f5b1c8a1SJohn Marino 	}
1737f5b1c8a1SJohn Marino 	if (rrow != NULL) {
1738f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
1739f5b1c8a1SJohn Marino 		    "The matching entry has the following details\n");
1740f5b1c8a1SJohn Marino 		if (rrow[DB_type][0] == 'E')
1741f5b1c8a1SJohn Marino 			p = "Expired";
1742f5b1c8a1SJohn Marino 		else if (rrow[DB_type][0] == 'R')
1743f5b1c8a1SJohn Marino 			p = "Revoked";
1744f5b1c8a1SJohn Marino 		else if (rrow[DB_type][0] == 'V')
1745f5b1c8a1SJohn Marino 			p = "Valid";
1746f5b1c8a1SJohn Marino 		else
1747f5b1c8a1SJohn Marino 			p = "\ninvalid type, Data base error\n";
1748f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Type	  :%s\n", p);
1749f5b1c8a1SJohn Marino 		if (rrow[DB_type][0] == 'R') {
1750f5b1c8a1SJohn Marino 			p = rrow[DB_exp_date];
1751f5b1c8a1SJohn Marino 			if (p == NULL)
1752f5b1c8a1SJohn Marino 				p = "undef";
1753f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Was revoked on:%s\n", p);
1754f5b1c8a1SJohn Marino 		}
1755f5b1c8a1SJohn Marino 		p = rrow[DB_exp_date];
1756f5b1c8a1SJohn Marino 		if (p == NULL)
1757f5b1c8a1SJohn Marino 			p = "undef";
1758f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Expires on    :%s\n", p);
1759f5b1c8a1SJohn Marino 		p = rrow[DB_serial];
1760f5b1c8a1SJohn Marino 		if (p == NULL)
1761f5b1c8a1SJohn Marino 			p = "undef";
1762f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Serial Number :%s\n", p);
1763f5b1c8a1SJohn Marino 		p = rrow[DB_file];
1764f5b1c8a1SJohn Marino 		if (p == NULL)
1765f5b1c8a1SJohn Marino 			p = "undef";
1766f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "File name     :%s\n", p);
1767f5b1c8a1SJohn Marino 		p = rrow[DB_name];
1768f5b1c8a1SJohn Marino 		if (p == NULL)
1769f5b1c8a1SJohn Marino 			p = "undef";
1770f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Subject Name  :%s\n", p);
1771f5b1c8a1SJohn Marino 		ok = -1;	/* This is now a 'bad' error. */
1772f5b1c8a1SJohn Marino 		goto err;
1773f5b1c8a1SJohn Marino 	}
1774f5b1c8a1SJohn Marino 	/* We are now totally happy, lets make and sign the certificate */
1775f5b1c8a1SJohn Marino 	if (verbose)
1776f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Everything appears to be ok, creating and signing the certificate\n");
1777f5b1c8a1SJohn Marino 
1778f5b1c8a1SJohn Marino 	if ((ret = X509_new()) == NULL)
1779f5b1c8a1SJohn Marino 		goto err;
1780f5b1c8a1SJohn Marino 	ci = ret->cert_info;
1781f5b1c8a1SJohn Marino 
1782f5b1c8a1SJohn Marino #ifdef X509_V3
1783f5b1c8a1SJohn Marino 	/* Make it an X509 v3 certificate. */
1784f5b1c8a1SJohn Marino 	if (!X509_set_version(ret, 2))
1785f5b1c8a1SJohn Marino 		goto err;
1786f5b1c8a1SJohn Marino #endif
1787f5b1c8a1SJohn Marino 	if (ci->serialNumber == NULL)
1788f5b1c8a1SJohn Marino 		goto err;
1789f5b1c8a1SJohn Marino 	if (BN_to_ASN1_INTEGER(serial, ci->serialNumber) == NULL)
1790f5b1c8a1SJohn Marino 		goto err;
1791f5b1c8a1SJohn Marino 	if (selfsign) {
1792f5b1c8a1SJohn Marino 		if (!X509_set_issuer_name(ret, subject))
1793f5b1c8a1SJohn Marino 			goto err;
1794f5b1c8a1SJohn Marino 	} else {
1795f5b1c8a1SJohn Marino 		if (!X509_set_issuer_name(ret, X509_get_subject_name(x509)))
1796f5b1c8a1SJohn Marino 			goto err;
1797f5b1c8a1SJohn Marino 	}
1798f5b1c8a1SJohn Marino 
1799f5b1c8a1SJohn Marino 	if (strcmp(startdate, "today") == 0)
1800f5b1c8a1SJohn Marino 		X509_gmtime_adj(X509_get_notBefore(ret), 0);
1801f5b1c8a1SJohn Marino 	else
1802f5b1c8a1SJohn Marino 		ASN1_TIME_set_string(X509_get_notBefore(ret), startdate);
1803f5b1c8a1SJohn Marino 
1804f5b1c8a1SJohn Marino 	if (enddate == NULL)
1805f5b1c8a1SJohn Marino 		X509_time_adj_ex(X509_get_notAfter(ret), days, 0, NULL);
1806f5b1c8a1SJohn Marino 	else
1807f5b1c8a1SJohn Marino 		ASN1_TIME_set_string(X509_get_notAfter(ret), enddate);
1808f5b1c8a1SJohn Marino 
1809f5b1c8a1SJohn Marino 	if (!X509_set_subject_name(ret, subject))
1810f5b1c8a1SJohn Marino 		goto err;
1811f5b1c8a1SJohn Marino 
1812f5b1c8a1SJohn Marino 	pktmp = X509_REQ_get_pubkey(req);
1813f5b1c8a1SJohn Marino 	i = X509_set_pubkey(ret, pktmp);
1814f5b1c8a1SJohn Marino 	EVP_PKEY_free(pktmp);
1815f5b1c8a1SJohn Marino 	if (!i)
1816f5b1c8a1SJohn Marino 		goto err;
1817f5b1c8a1SJohn Marino 
1818f5b1c8a1SJohn Marino 	/* Lets add the extensions, if there are any */
1819f5b1c8a1SJohn Marino 	if (ext_sect) {
1820f5b1c8a1SJohn Marino 		X509V3_CTX ctx;
1821f5b1c8a1SJohn Marino 		if (ci->version == NULL)
1822f5b1c8a1SJohn Marino 			if ((ci->version = ASN1_INTEGER_new()) == NULL)
1823f5b1c8a1SJohn Marino 				goto err;
1824f5b1c8a1SJohn Marino 		ASN1_INTEGER_set(ci->version, 2);	/* version 3 certificate */
1825f5b1c8a1SJohn Marino 
1826f5b1c8a1SJohn Marino 		/*
1827f5b1c8a1SJohn Marino 		 * Free the current entries if any, there should not be any I
1828f5b1c8a1SJohn Marino 		 * believe
1829f5b1c8a1SJohn Marino 		 */
1830f5b1c8a1SJohn Marino 		if (ci->extensions != NULL)
1831f5b1c8a1SJohn Marino 			sk_X509_EXTENSION_pop_free(ci->extensions,
1832f5b1c8a1SJohn Marino 			    X509_EXTENSION_free);
1833f5b1c8a1SJohn Marino 
1834f5b1c8a1SJohn Marino 		ci->extensions = NULL;
1835f5b1c8a1SJohn Marino 
1836f5b1c8a1SJohn Marino 		/* Initialize the context structure */
1837f5b1c8a1SJohn Marino 		if (selfsign)
1838f5b1c8a1SJohn Marino 			X509V3_set_ctx(&ctx, ret, ret, req, NULL, 0);
1839f5b1c8a1SJohn Marino 		else
1840f5b1c8a1SJohn Marino 			X509V3_set_ctx(&ctx, x509, ret, req, NULL, 0);
1841f5b1c8a1SJohn Marino 
1842f5b1c8a1SJohn Marino 		if (extconf) {
1843f5b1c8a1SJohn Marino 			if (verbose)
1844f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
1845f5b1c8a1SJohn Marino 				    "Extra configuration file found\n");
1846f5b1c8a1SJohn Marino 
1847f5b1c8a1SJohn Marino 			/* Use the extconf configuration db LHASH */
1848f5b1c8a1SJohn Marino 			X509V3_set_nconf(&ctx, extconf);
1849f5b1c8a1SJohn Marino 
1850f5b1c8a1SJohn Marino 			/* Test the structure (needed?) */
1851f5b1c8a1SJohn Marino 			/* X509V3_set_ctx_test(&ctx); */
1852f5b1c8a1SJohn Marino 
1853f5b1c8a1SJohn Marino 			/* Adds exts contained in the configuration file */
1854f5b1c8a1SJohn Marino 			if (!X509V3_EXT_add_nconf(extconf, &ctx,
1855f5b1c8a1SJohn Marino 			    ext_sect, ret)) {
1856f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
1857f5b1c8a1SJohn Marino 				    "ERROR: adding extensions in section %s\n",
1858f5b1c8a1SJohn Marino 				    ext_sect);
1859f5b1c8a1SJohn Marino 				ERR_print_errors(bio_err);
1860f5b1c8a1SJohn Marino 				goto err;
1861f5b1c8a1SJohn Marino 			}
1862f5b1c8a1SJohn Marino 			if (verbose)
1863f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "Successfully added extensions from file.\n");
1864f5b1c8a1SJohn Marino 		} else if (ext_sect) {
1865f5b1c8a1SJohn Marino 			/* We found extensions to be set from config file */
1866f5b1c8a1SJohn Marino 			X509V3_set_nconf(&ctx, lconf);
1867f5b1c8a1SJohn Marino 
1868f5b1c8a1SJohn Marino 			if (!X509V3_EXT_add_nconf(lconf, &ctx, ext_sect, ret)) {
1869f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
1870f5b1c8a1SJohn Marino 				    "ERROR: adding extensions in section %s\n",
1871f5b1c8a1SJohn Marino 				    ext_sect);
1872f5b1c8a1SJohn Marino 				ERR_print_errors(bio_err);
1873f5b1c8a1SJohn Marino 				goto err;
1874f5b1c8a1SJohn Marino 			}
1875f5b1c8a1SJohn Marino 			if (verbose)
1876f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "Successfully added extensions from config\n");
1877f5b1c8a1SJohn Marino 		}
1878f5b1c8a1SJohn Marino 	}
1879f5b1c8a1SJohn Marino 	/* Copy extensions from request (if any) */
1880f5b1c8a1SJohn Marino 
1881f5b1c8a1SJohn Marino 	if (!copy_extensions(ret, req, ext_copy)) {
1882f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "ERROR: adding extensions from request\n");
1883f5b1c8a1SJohn Marino 		ERR_print_errors(bio_err);
1884f5b1c8a1SJohn Marino 		goto err;
1885f5b1c8a1SJohn Marino 	}
1886f5b1c8a1SJohn Marino 	/* Set the right value for the noemailDN option */
1887f5b1c8a1SJohn Marino 	if (email_dn == 0) {
1888f5b1c8a1SJohn Marino 		if (!X509_set_subject_name(ret, dn_subject))
1889f5b1c8a1SJohn Marino 			goto err;
1890f5b1c8a1SJohn Marino 	}
1891f5b1c8a1SJohn Marino 	if (!default_op) {
1892f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Certificate Details:\n");
1893f5b1c8a1SJohn Marino 		/*
1894f5b1c8a1SJohn Marino 		 * Never print signature details because signature not
1895f5b1c8a1SJohn Marino 		 * present
1896f5b1c8a1SJohn Marino 		 */
1897f5b1c8a1SJohn Marino 		certopt |= X509_FLAG_NO_SIGDUMP | X509_FLAG_NO_SIGNAME;
1898f5b1c8a1SJohn Marino 		X509_print_ex(bio_err, ret, nameopt, certopt);
1899f5b1c8a1SJohn Marino 	}
1900f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "Certificate is to be certified until ");
1901f5b1c8a1SJohn Marino 	ASN1_TIME_print(bio_err, X509_get_notAfter(ret));
1902f5b1c8a1SJohn Marino 	if (days)
1903f5b1c8a1SJohn Marino 		BIO_printf(bio_err, " (%ld days)", days);
1904f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "\n");
1905f5b1c8a1SJohn Marino 
1906f5b1c8a1SJohn Marino 	if (!batch) {
1907f5b1c8a1SJohn Marino 
1908f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Sign the certificate? [y/n]:");
1909f5b1c8a1SJohn Marino 		(void) BIO_flush(bio_err);
1910f5b1c8a1SJohn Marino 		buf[0] = '\0';
1911f5b1c8a1SJohn Marino 		if (!fgets(buf, sizeof(buf) - 1, stdin)) {
1912f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
1913f5b1c8a1SJohn Marino 			    "CERTIFICATE WILL NOT BE CERTIFIED: I/O error\n");
1914f5b1c8a1SJohn Marino 			ok = 0;
1915f5b1c8a1SJohn Marino 			goto err;
1916f5b1c8a1SJohn Marino 		}
1917f5b1c8a1SJohn Marino 		if (!((buf[0] == 'y') || (buf[0] == 'Y'))) {
1918f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
1919f5b1c8a1SJohn Marino 			    "CERTIFICATE WILL NOT BE CERTIFIED\n");
1920f5b1c8a1SJohn Marino 			ok = 0;
1921f5b1c8a1SJohn Marino 			goto err;
1922f5b1c8a1SJohn Marino 		}
1923f5b1c8a1SJohn Marino 	}
1924f5b1c8a1SJohn Marino 	pktmp = X509_get_pubkey(ret);
1925f5b1c8a1SJohn Marino 	if (EVP_PKEY_missing_parameters(pktmp) &&
1926f5b1c8a1SJohn Marino 	    !EVP_PKEY_missing_parameters(pkey))
1927f5b1c8a1SJohn Marino 		EVP_PKEY_copy_parameters(pktmp, pkey);
1928f5b1c8a1SJohn Marino 	EVP_PKEY_free(pktmp);
1929f5b1c8a1SJohn Marino 
1930f5b1c8a1SJohn Marino 	if (!do_X509_sign(bio_err, ret, pkey, dgst, sigopts))
1931f5b1c8a1SJohn Marino 		goto err;
1932f5b1c8a1SJohn Marino 
1933f5b1c8a1SJohn Marino 	/* We now just add it to the database */
1934f5b1c8a1SJohn Marino 	row[DB_type] = malloc(2);
1935f5b1c8a1SJohn Marino 
1936f5b1c8a1SJohn Marino 	tm = X509_get_notAfter(ret);
1937f5b1c8a1SJohn Marino 	row[DB_exp_date] = malloc(tm->length + 1);
1938f5b1c8a1SJohn Marino 	if (row[DB_type] == NULL || row[DB_exp_date] == NULL) {
1939f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Memory allocation failure\n");
1940f5b1c8a1SJohn Marino 		goto err;
1941f5b1c8a1SJohn Marino 	}
1942f5b1c8a1SJohn Marino 
1943f5b1c8a1SJohn Marino 	memcpy(row[DB_exp_date], tm->data, tm->length);
1944f5b1c8a1SJohn Marino 	row[DB_exp_date][tm->length] = '\0';
1945f5b1c8a1SJohn Marino 
1946f5b1c8a1SJohn Marino 	row[DB_rev_date] = NULL;
1947f5b1c8a1SJohn Marino 
1948f5b1c8a1SJohn Marino 	/* row[DB_serial] done already */
1949f5b1c8a1SJohn Marino 	row[DB_file] = malloc(8);
1950f5b1c8a1SJohn Marino 	row[DB_name] = X509_NAME_oneline(X509_get_subject_name(ret), NULL, 0);
1951f5b1c8a1SJohn Marino 
1952f5b1c8a1SJohn Marino 	if ((row[DB_type] == NULL) || (row[DB_file] == NULL) ||
1953f5b1c8a1SJohn Marino 	    (row[DB_name] == NULL)) {
1954f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Memory allocation failure\n");
1955f5b1c8a1SJohn Marino 		goto err;
1956f5b1c8a1SJohn Marino 	}
1957f5b1c8a1SJohn Marino 	(void) strlcpy(row[DB_file], "unknown", 8);
1958f5b1c8a1SJohn Marino 	row[DB_type][0] = 'V';
1959f5b1c8a1SJohn Marino 	row[DB_type][1] = '\0';
1960f5b1c8a1SJohn Marino 
1961f5b1c8a1SJohn Marino 	if ((irow = reallocarray(NULL, DB_NUMBER + 1, sizeof(char *))) ==
1962f5b1c8a1SJohn Marino 	    NULL) {
1963f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Memory allocation failure\n");
1964f5b1c8a1SJohn Marino 		goto err;
1965f5b1c8a1SJohn Marino 	}
1966f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++) {
1967f5b1c8a1SJohn Marino 		irow[i] = row[i];
1968f5b1c8a1SJohn Marino 		row[i] = NULL;
1969f5b1c8a1SJohn Marino 	}
1970f5b1c8a1SJohn Marino 	irow[DB_NUMBER] = NULL;
1971f5b1c8a1SJohn Marino 
1972f5b1c8a1SJohn Marino 	if (!TXT_DB_insert(db->db, irow)) {
1973f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "failed to update database\n");
1974f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "TXT_DB error number %ld\n", db->db->error);
1975f5b1c8a1SJohn Marino 		goto err;
1976f5b1c8a1SJohn Marino 	}
1977f5b1c8a1SJohn Marino 	ok = 1;
1978f5b1c8a1SJohn Marino err:
1979f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++)
1980f5b1c8a1SJohn Marino 		free(row[i]);
1981f5b1c8a1SJohn Marino 
1982f5b1c8a1SJohn Marino 	if (CAname != NULL)
1983f5b1c8a1SJohn Marino 		X509_NAME_free(CAname);
1984f5b1c8a1SJohn Marino 	if (subject != NULL)
1985f5b1c8a1SJohn Marino 		X509_NAME_free(subject);
1986f5b1c8a1SJohn Marino 	if ((dn_subject != NULL) && !email_dn)
1987f5b1c8a1SJohn Marino 		X509_NAME_free(dn_subject);
1988f5b1c8a1SJohn Marino 	if (tmptm != NULL)
1989f5b1c8a1SJohn Marino 		ASN1_UTCTIME_free(tmptm);
1990f5b1c8a1SJohn Marino 	if (ok <= 0) {
1991f5b1c8a1SJohn Marino 		if (ret != NULL)
1992f5b1c8a1SJohn Marino 			X509_free(ret);
1993f5b1c8a1SJohn Marino 		ret = NULL;
1994f5b1c8a1SJohn Marino 	} else
1995f5b1c8a1SJohn Marino 		*xret = ret;
1996f5b1c8a1SJohn Marino 	return (ok);
1997f5b1c8a1SJohn Marino }
1998f5b1c8a1SJohn Marino 
1999f5b1c8a1SJohn Marino static void
2000f5b1c8a1SJohn Marino write_new_certificate(BIO * bp, X509 * x, int output_der, int notext)
2001f5b1c8a1SJohn Marino {
2002f5b1c8a1SJohn Marino 	if (output_der) {
2003f5b1c8a1SJohn Marino 		(void) i2d_X509_bio(bp, x);
2004f5b1c8a1SJohn Marino 		return;
2005f5b1c8a1SJohn Marino 	}
2006f5b1c8a1SJohn Marino 	if (!notext)
2007f5b1c8a1SJohn Marino 		X509_print(bp, x);
2008f5b1c8a1SJohn Marino 	PEM_write_bio_X509(bp, x);
2009f5b1c8a1SJohn Marino }
2010f5b1c8a1SJohn Marino 
2011f5b1c8a1SJohn Marino static int
2012f5b1c8a1SJohn Marino certify_spkac(X509 ** xret, char *infile, EVP_PKEY * pkey, X509 * x509,
2013f5b1c8a1SJohn Marino     const EVP_MD * dgst, STACK_OF(OPENSSL_STRING) * sigopts,
2014f5b1c8a1SJohn Marino     STACK_OF(CONF_VALUE) * policy, CA_DB * db, BIGNUM * serial, char *subj,
2015f5b1c8a1SJohn Marino     unsigned long chtype, int multirdn, int email_dn, char *startdate,
2016f5b1c8a1SJohn Marino     char *enddate, long days, char *ext_sect, CONF * lconf, int verbose,
2017f5b1c8a1SJohn Marino     unsigned long certopt, unsigned long nameopt, int default_op, int ext_copy)
2018f5b1c8a1SJohn Marino {
2019f5b1c8a1SJohn Marino 	STACK_OF(CONF_VALUE) * sk = NULL;
2020f5b1c8a1SJohn Marino 	LHASH_OF(CONF_VALUE) * parms = NULL;
2021f5b1c8a1SJohn Marino 	X509_REQ *req = NULL;
2022f5b1c8a1SJohn Marino 	CONF_VALUE *cv = NULL;
2023f5b1c8a1SJohn Marino 	NETSCAPE_SPKI *spki = NULL;
2024f5b1c8a1SJohn Marino 	X509_REQ_INFO *ri;
2025f5b1c8a1SJohn Marino 	char *type, *buf;
2026f5b1c8a1SJohn Marino 	EVP_PKEY *pktmp = NULL;
2027f5b1c8a1SJohn Marino 	X509_NAME *n = NULL;
2028f5b1c8a1SJohn Marino 	int ok = -1, i, j;
2029f5b1c8a1SJohn Marino 	long errline;
2030f5b1c8a1SJohn Marino 	int nid;
2031f5b1c8a1SJohn Marino 
2032f5b1c8a1SJohn Marino 	/*
2033f5b1c8a1SJohn Marino 	 * Load input file into a hash table.  (This is just an easy
2034f5b1c8a1SJohn Marino 	 * way to read and parse the file, then put it into a convenient
2035f5b1c8a1SJohn Marino 	 * STACK format).
2036f5b1c8a1SJohn Marino 	 */
2037f5b1c8a1SJohn Marino 	parms = CONF_load(NULL, infile, &errline);
2038f5b1c8a1SJohn Marino 	if (parms == NULL) {
2039f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "error on line %ld of %s\n",
2040f5b1c8a1SJohn Marino 		    errline, infile);
2041f5b1c8a1SJohn Marino 		ERR_print_errors(bio_err);
2042f5b1c8a1SJohn Marino 		goto err;
2043f5b1c8a1SJohn Marino 	}
2044f5b1c8a1SJohn Marino 	sk = CONF_get_section(parms, "default");
2045f5b1c8a1SJohn Marino 	if (sk_CONF_VALUE_num(sk) == 0) {
2046f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "no name/value pairs found in %s\n",
2047f5b1c8a1SJohn Marino 		    infile);
2048f5b1c8a1SJohn Marino 		CONF_free(parms);
2049f5b1c8a1SJohn Marino 		goto err;
2050f5b1c8a1SJohn Marino 	}
2051f5b1c8a1SJohn Marino 	/*
2052f5b1c8a1SJohn Marino 	 * Now create a dummy X509 request structure.  We don't actually
2053f5b1c8a1SJohn Marino 	 * have an X509 request, but we have many of the components
2054f5b1c8a1SJohn Marino 	 * (a public key, various DN components).  The idea is that we
2055f5b1c8a1SJohn Marino 	 * put these components into the right X509 request structure
2056f5b1c8a1SJohn Marino 	 * and we can use the same code as if you had a real X509 request.
2057f5b1c8a1SJohn Marino 	 */
2058f5b1c8a1SJohn Marino 	req = X509_REQ_new();
2059f5b1c8a1SJohn Marino 	if (req == NULL) {
2060f5b1c8a1SJohn Marino 		ERR_print_errors(bio_err);
2061f5b1c8a1SJohn Marino 		goto err;
2062f5b1c8a1SJohn Marino 	}
2063f5b1c8a1SJohn Marino 	/*
2064f5b1c8a1SJohn Marino 	 * Build up the subject name set.
2065f5b1c8a1SJohn Marino 	 */
2066f5b1c8a1SJohn Marino 	ri = req->req_info;
2067f5b1c8a1SJohn Marino 	n = ri->subject;
2068f5b1c8a1SJohn Marino 
2069f5b1c8a1SJohn Marino 	for (i = 0;; i++) {
2070f5b1c8a1SJohn Marino 		if (sk_CONF_VALUE_num(sk) <= i)
2071f5b1c8a1SJohn Marino 			break;
2072f5b1c8a1SJohn Marino 
2073f5b1c8a1SJohn Marino 		cv = sk_CONF_VALUE_value(sk, i);
2074f5b1c8a1SJohn Marino 		type = cv->name;
2075f5b1c8a1SJohn Marino 		/*
2076f5b1c8a1SJohn Marino 		 * Skip past any leading X. X: X, etc to allow for multiple
2077f5b1c8a1SJohn Marino 		 * instances
2078f5b1c8a1SJohn Marino 		 */
2079f5b1c8a1SJohn Marino 		for (buf = cv->name; *buf; buf++) {
2080f5b1c8a1SJohn Marino 			if ((*buf == ':') || (*buf == ',') || (*buf == '.')) {
2081f5b1c8a1SJohn Marino 				buf++;
2082f5b1c8a1SJohn Marino 				if (*buf)
2083f5b1c8a1SJohn Marino 					type = buf;
2084f5b1c8a1SJohn Marino 				break;
2085f5b1c8a1SJohn Marino 			}
2086f5b1c8a1SJohn Marino 		}
2087f5b1c8a1SJohn Marino 
2088f5b1c8a1SJohn Marino 		buf = cv->value;
2089f5b1c8a1SJohn Marino 		if ((nid = OBJ_txt2nid(type)) == NID_undef) {
2090f5b1c8a1SJohn Marino 			if (strcmp(type, "SPKAC") == 0) {
2091f5b1c8a1SJohn Marino 				spki = NETSCAPE_SPKI_b64_decode(cv->value, -1);
2092f5b1c8a1SJohn Marino 				if (spki == NULL) {
2093f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "unable to load Netscape SPKAC structure\n");
2094f5b1c8a1SJohn Marino 					ERR_print_errors(bio_err);
2095f5b1c8a1SJohn Marino 					goto err;
2096f5b1c8a1SJohn Marino 				}
2097f5b1c8a1SJohn Marino 			}
2098f5b1c8a1SJohn Marino 			continue;
2099f5b1c8a1SJohn Marino 		}
2100f5b1c8a1SJohn Marino 		if (!X509_NAME_add_entry_by_NID(n, nid, chtype,
2101f5b1c8a1SJohn Marino 		    (unsigned char *)buf, -1, -1, 0))
2102f5b1c8a1SJohn Marino 			goto err;
2103f5b1c8a1SJohn Marino 	}
2104f5b1c8a1SJohn Marino 	if (spki == NULL) {
2105f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
2106f5b1c8a1SJohn Marino 		    "Netscape SPKAC structure not found in %s\n", infile);
2107f5b1c8a1SJohn Marino 		goto err;
2108f5b1c8a1SJohn Marino 	}
2109f5b1c8a1SJohn Marino 	/*
2110f5b1c8a1SJohn Marino 	 * Now extract the key from the SPKI structure.
2111f5b1c8a1SJohn Marino 	 */
2112f5b1c8a1SJohn Marino 
2113f5b1c8a1SJohn Marino 	BIO_printf(bio_err,
2114f5b1c8a1SJohn Marino 	    "Check that the SPKAC request matches the signature\n");
2115f5b1c8a1SJohn Marino 
2116f5b1c8a1SJohn Marino 	if ((pktmp = NETSCAPE_SPKI_get_pubkey(spki)) == NULL) {
2117f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "error unpacking SPKAC public key\n");
2118f5b1c8a1SJohn Marino 		goto err;
2119f5b1c8a1SJohn Marino 	}
2120f5b1c8a1SJohn Marino 	j = NETSCAPE_SPKI_verify(spki, pktmp);
2121f5b1c8a1SJohn Marino 	if (j <= 0) {
2122f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
2123f5b1c8a1SJohn Marino 		    "signature verification failed on SPKAC public key\n");
2124f5b1c8a1SJohn Marino 		goto err;
2125f5b1c8a1SJohn Marino 	}
2126f5b1c8a1SJohn Marino 	BIO_printf(bio_err, "Signature ok\n");
2127f5b1c8a1SJohn Marino 
2128f5b1c8a1SJohn Marino 	X509_REQ_set_pubkey(req, pktmp);
2129f5b1c8a1SJohn Marino 	EVP_PKEY_free(pktmp);
2130f5b1c8a1SJohn Marino 	ok = do_body(xret, pkey, x509, dgst, sigopts, policy, db, serial,
2131f5b1c8a1SJohn Marino 	    subj, chtype, multirdn, email_dn, startdate, enddate, days, 1,
2132f5b1c8a1SJohn Marino 	    verbose, req, ext_sect, lconf, certopt, nameopt, default_op,
2133f5b1c8a1SJohn Marino 	    ext_copy, 0);
2134f5b1c8a1SJohn Marino 
2135f5b1c8a1SJohn Marino err:
2136f5b1c8a1SJohn Marino 	if (req != NULL)
2137f5b1c8a1SJohn Marino 		X509_REQ_free(req);
2138f5b1c8a1SJohn Marino 	if (parms != NULL)
2139f5b1c8a1SJohn Marino 		CONF_free(parms);
2140f5b1c8a1SJohn Marino 	if (spki != NULL)
2141f5b1c8a1SJohn Marino 		NETSCAPE_SPKI_free(spki);
2142f5b1c8a1SJohn Marino 
2143f5b1c8a1SJohn Marino 	return (ok);
2144f5b1c8a1SJohn Marino }
2145f5b1c8a1SJohn Marino 
2146f5b1c8a1SJohn Marino static int
2147f5b1c8a1SJohn Marino check_time_format(const char *str)
2148f5b1c8a1SJohn Marino {
2149f5b1c8a1SJohn Marino 	return ASN1_TIME_set_string(NULL, str);
2150f5b1c8a1SJohn Marino }
2151f5b1c8a1SJohn Marino 
2152f5b1c8a1SJohn Marino static int
2153f5b1c8a1SJohn Marino do_revoke(X509 * x509, CA_DB * db, int type, char *value)
2154f5b1c8a1SJohn Marino {
2155f5b1c8a1SJohn Marino 	ASN1_UTCTIME *tm = NULL;
2156f5b1c8a1SJohn Marino 	char *row[DB_NUMBER], **rrow, **irow;
2157f5b1c8a1SJohn Marino 	char *rev_str = NULL;
2158f5b1c8a1SJohn Marino 	BIGNUM *bn = NULL;
2159f5b1c8a1SJohn Marino 	int ok = -1, i;
2160f5b1c8a1SJohn Marino 
2161f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++)
2162f5b1c8a1SJohn Marino 		row[i] = NULL;
2163f5b1c8a1SJohn Marino 	row[DB_name] = X509_NAME_oneline(X509_get_subject_name(x509), NULL, 0);
2164f5b1c8a1SJohn Marino 	bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(x509), NULL);
2165f5b1c8a1SJohn Marino 	if (!bn)
2166f5b1c8a1SJohn Marino 		goto err;
2167f5b1c8a1SJohn Marino 	if (BN_is_zero(bn))
2168f5b1c8a1SJohn Marino 		row[DB_serial] = strdup("00");
2169f5b1c8a1SJohn Marino 	else
2170f5b1c8a1SJohn Marino 		row[DB_serial] = BN_bn2hex(bn);
2171f5b1c8a1SJohn Marino 	BN_free(bn);
2172f5b1c8a1SJohn Marino 	if ((row[DB_name] == NULL) || (row[DB_serial] == NULL)) {
2173f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Memory allocation failure\n");
2174f5b1c8a1SJohn Marino 		goto err;
2175f5b1c8a1SJohn Marino 	}
2176f5b1c8a1SJohn Marino 	/*
2177f5b1c8a1SJohn Marino 	 * We have to lookup by serial number because name lookup skips
2178f5b1c8a1SJohn Marino 	 * revoked certs
2179f5b1c8a1SJohn Marino 	 */
2180f5b1c8a1SJohn Marino 	rrow = TXT_DB_get_by_index(db->db, DB_serial, row);
2181f5b1c8a1SJohn Marino 	if (rrow == NULL) {
2182f5b1c8a1SJohn Marino 		BIO_printf(bio_err,
2183f5b1c8a1SJohn Marino 		    "Adding Entry with serial number %s to DB for %s\n",
2184f5b1c8a1SJohn Marino 		    row[DB_serial], row[DB_name]);
2185f5b1c8a1SJohn Marino 
2186f5b1c8a1SJohn Marino 		/* We now just add it to the database */
2187f5b1c8a1SJohn Marino 		row[DB_type] = malloc(2);
2188f5b1c8a1SJohn Marino 
2189f5b1c8a1SJohn Marino 		tm = X509_get_notAfter(x509);
2190f5b1c8a1SJohn Marino 		row[DB_exp_date] = malloc(tm->length + 1);
2191f5b1c8a1SJohn Marino 		if (row[DB_type] == NULL || row[DB_exp_date] == NULL) {
2192f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Memory allocation failure\n");
2193f5b1c8a1SJohn Marino 			goto err;
2194f5b1c8a1SJohn Marino 		}
2195f5b1c8a1SJohn Marino 		memcpy(row[DB_exp_date], tm->data, tm->length);
2196f5b1c8a1SJohn Marino 		row[DB_exp_date][tm->length] = '\0';
2197f5b1c8a1SJohn Marino 
2198f5b1c8a1SJohn Marino 		row[DB_rev_date] = NULL;
2199f5b1c8a1SJohn Marino 
2200f5b1c8a1SJohn Marino 		/* row[DB_serial] done already */
2201f5b1c8a1SJohn Marino 		row[DB_file] = malloc(8);
2202f5b1c8a1SJohn Marino 
2203f5b1c8a1SJohn Marino 		/* row[DB_name] done already */
2204f5b1c8a1SJohn Marino 
2205f5b1c8a1SJohn Marino 		if ((row[DB_type] == NULL) || (row[DB_file] == NULL)) {
2206f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Memory allocation failure\n");
2207f5b1c8a1SJohn Marino 			goto err;
2208f5b1c8a1SJohn Marino 		}
2209f5b1c8a1SJohn Marino 		(void) strlcpy(row[DB_file], "unknown", 8);
2210f5b1c8a1SJohn Marino 		row[DB_type][0] = 'V';
2211f5b1c8a1SJohn Marino 		row[DB_type][1] = '\0';
2212f5b1c8a1SJohn Marino 
2213f5b1c8a1SJohn Marino 		if ((irow = reallocarray(NULL, sizeof(char *),
2214f5b1c8a1SJohn Marino 		    (DB_NUMBER + 1))) == NULL) {
2215f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Memory allocation failure\n");
2216f5b1c8a1SJohn Marino 			goto err;
2217f5b1c8a1SJohn Marino 		}
2218f5b1c8a1SJohn Marino 		for (i = 0; i < DB_NUMBER; i++) {
2219f5b1c8a1SJohn Marino 			irow[i] = row[i];
2220f5b1c8a1SJohn Marino 			row[i] = NULL;
2221f5b1c8a1SJohn Marino 		}
2222f5b1c8a1SJohn Marino 		irow[DB_NUMBER] = NULL;
2223f5b1c8a1SJohn Marino 
2224f5b1c8a1SJohn Marino 		if (!TXT_DB_insert(db->db, irow)) {
2225f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "failed to update database\n");
2226f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "TXT_DB error number %ld\n",
2227f5b1c8a1SJohn Marino 			    db->db->error);
2228f5b1c8a1SJohn Marino 			goto err;
2229f5b1c8a1SJohn Marino 		}
2230f5b1c8a1SJohn Marino 		/* Revoke Certificate */
2231f5b1c8a1SJohn Marino 		ok = do_revoke(x509, db, type, value);
2232f5b1c8a1SJohn Marino 
2233f5b1c8a1SJohn Marino 		goto err;
2234f5b1c8a1SJohn Marino 
2235f5b1c8a1SJohn Marino 	} else if (index_name_cmp_noconst(row, rrow)) {
2236f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "ERROR:name does not match %s\n",
2237f5b1c8a1SJohn Marino 		    row[DB_name]);
2238f5b1c8a1SJohn Marino 		goto err;
2239f5b1c8a1SJohn Marino 	} else if (rrow[DB_type][0] == 'R') {
2240f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "ERROR:Already revoked, serial number %s\n",
2241f5b1c8a1SJohn Marino 		    row[DB_serial]);
2242f5b1c8a1SJohn Marino 		goto err;
2243f5b1c8a1SJohn Marino 	} else {
2244f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Revoking Certificate %s.\n",
2245f5b1c8a1SJohn Marino 		    rrow[DB_serial]);
2246f5b1c8a1SJohn Marino 		rev_str = make_revocation_str(type, value);
2247f5b1c8a1SJohn Marino 		if (!rev_str) {
2248f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Error in revocation arguments\n");
2249f5b1c8a1SJohn Marino 			goto err;
2250f5b1c8a1SJohn Marino 		}
2251f5b1c8a1SJohn Marino 		rrow[DB_type][0] = 'R';
2252f5b1c8a1SJohn Marino 		rrow[DB_type][1] = '\0';
2253f5b1c8a1SJohn Marino 		rrow[DB_rev_date] = rev_str;
2254f5b1c8a1SJohn Marino 	}
2255f5b1c8a1SJohn Marino 	ok = 1;
2256f5b1c8a1SJohn Marino 
2257f5b1c8a1SJohn Marino err:
2258f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++)
2259f5b1c8a1SJohn Marino 		free(row[i]);
2260f5b1c8a1SJohn Marino 
2261f5b1c8a1SJohn Marino 	return (ok);
2262f5b1c8a1SJohn Marino }
2263f5b1c8a1SJohn Marino 
2264f5b1c8a1SJohn Marino static int
2265f5b1c8a1SJohn Marino get_certificate_status(const char *serial, CA_DB * db)
2266f5b1c8a1SJohn Marino {
2267f5b1c8a1SJohn Marino 	char *row[DB_NUMBER], **rrow;
2268f5b1c8a1SJohn Marino 	int ok = -1, i;
2269f5b1c8a1SJohn Marino 
2270f5b1c8a1SJohn Marino 	/* Free Resources */
2271f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++)
2272f5b1c8a1SJohn Marino 		row[i] = NULL;
2273f5b1c8a1SJohn Marino 
2274f5b1c8a1SJohn Marino 	/* Malloc needed char spaces */
2275f5b1c8a1SJohn Marino 	row[DB_serial] = malloc(strlen(serial) + 2);
2276f5b1c8a1SJohn Marino 	if (row[DB_serial] == NULL) {
2277f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Malloc failure\n");
2278f5b1c8a1SJohn Marino 		goto err;
2279f5b1c8a1SJohn Marino 	}
2280f5b1c8a1SJohn Marino 	if (strlen(serial) % 2) {
2281f5b1c8a1SJohn Marino 		/* Set the first char to 0 */ ;
2282f5b1c8a1SJohn Marino 		row[DB_serial][0] = '0';
2283f5b1c8a1SJohn Marino 
2284f5b1c8a1SJohn Marino 		/* Copy String from serial to row[DB_serial] */
2285f5b1c8a1SJohn Marino 		memcpy(row[DB_serial] + 1, serial, strlen(serial));
2286f5b1c8a1SJohn Marino 		row[DB_serial][strlen(serial) + 1] = '\0';
2287f5b1c8a1SJohn Marino 	} else {
2288f5b1c8a1SJohn Marino 		/* Copy String from serial to row[DB_serial] */
2289f5b1c8a1SJohn Marino 		memcpy(row[DB_serial], serial, strlen(serial));
2290f5b1c8a1SJohn Marino 		row[DB_serial][strlen(serial)] = '\0';
2291f5b1c8a1SJohn Marino 	}
2292f5b1c8a1SJohn Marino 
2293f5b1c8a1SJohn Marino 	/* Make it Upper Case */
2294f5b1c8a1SJohn Marino 	for (i = 0; row[DB_serial][i] != '\0'; i++)
2295f5b1c8a1SJohn Marino 		row[DB_serial][i] = toupper((unsigned char) row[DB_serial][i]);
2296f5b1c8a1SJohn Marino 
2297f5b1c8a1SJohn Marino 
2298f5b1c8a1SJohn Marino 	ok = 1;
2299f5b1c8a1SJohn Marino 
2300f5b1c8a1SJohn Marino 	/* Search for the certificate */
2301f5b1c8a1SJohn Marino 	rrow = TXT_DB_get_by_index(db->db, DB_serial, row);
2302f5b1c8a1SJohn Marino 	if (rrow == NULL) {
2303f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "Serial %s not present in db.\n",
2304f5b1c8a1SJohn Marino 		    row[DB_serial]);
2305f5b1c8a1SJohn Marino 		ok = -1;
2306f5b1c8a1SJohn Marino 		goto err;
2307f5b1c8a1SJohn Marino 	} else if (rrow[DB_type][0] == 'V') {
2308f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "%s=Valid (%c)\n",
2309f5b1c8a1SJohn Marino 		    row[DB_serial], rrow[DB_type][0]);
2310f5b1c8a1SJohn Marino 		goto err;
2311f5b1c8a1SJohn Marino 	} else if (rrow[DB_type][0] == 'R') {
2312f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "%s=Revoked (%c)\n",
2313f5b1c8a1SJohn Marino 		    row[DB_serial], rrow[DB_type][0]);
2314f5b1c8a1SJohn Marino 		goto err;
2315f5b1c8a1SJohn Marino 	} else if (rrow[DB_type][0] == 'E') {
2316f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "%s=Expired (%c)\n",
2317f5b1c8a1SJohn Marino 		    row[DB_serial], rrow[DB_type][0]);
2318f5b1c8a1SJohn Marino 		goto err;
2319f5b1c8a1SJohn Marino 	} else if (rrow[DB_type][0] == 'S') {
2320f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "%s=Suspended (%c)\n",
2321f5b1c8a1SJohn Marino 		    row[DB_serial], rrow[DB_type][0]);
2322f5b1c8a1SJohn Marino 		goto err;
2323f5b1c8a1SJohn Marino 	} else {
2324f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "%s=Unknown (%c).\n",
2325f5b1c8a1SJohn Marino 		    row[DB_serial], rrow[DB_type][0]);
2326f5b1c8a1SJohn Marino 		ok = -1;
2327f5b1c8a1SJohn Marino 	}
2328f5b1c8a1SJohn Marino 
2329f5b1c8a1SJohn Marino err:
2330f5b1c8a1SJohn Marino 	for (i = 0; i < DB_NUMBER; i++)
2331f5b1c8a1SJohn Marino 		free(row[i]);
2332f5b1c8a1SJohn Marino 
2333f5b1c8a1SJohn Marino 	return (ok);
2334f5b1c8a1SJohn Marino }
2335f5b1c8a1SJohn Marino 
2336f5b1c8a1SJohn Marino static int
2337f5b1c8a1SJohn Marino do_updatedb(CA_DB * db)
2338f5b1c8a1SJohn Marino {
2339f5b1c8a1SJohn Marino 	ASN1_UTCTIME *a_tm = NULL;
2340f5b1c8a1SJohn Marino 	int i, cnt = 0;
2341f5b1c8a1SJohn Marino 	int db_y2k, a_y2k;	/* flags = 1 if y >= 2000 */
2342f5b1c8a1SJohn Marino 	char **rrow, *a_tm_s;
2343f5b1c8a1SJohn Marino 
2344f5b1c8a1SJohn Marino 	a_tm = ASN1_UTCTIME_new();
2345f5b1c8a1SJohn Marino 
2346f5b1c8a1SJohn Marino 	/* get actual time and make a string */
2347f5b1c8a1SJohn Marino 	a_tm = X509_gmtime_adj(a_tm, 0);
2348f5b1c8a1SJohn Marino 	a_tm_s = malloc(a_tm->length + 1);
2349f5b1c8a1SJohn Marino 	if (a_tm_s == NULL) {
2350f5b1c8a1SJohn Marino 		cnt = -1;
2351f5b1c8a1SJohn Marino 		goto err;
2352f5b1c8a1SJohn Marino 	}
2353f5b1c8a1SJohn Marino 	memcpy(a_tm_s, a_tm->data, a_tm->length);
2354f5b1c8a1SJohn Marino 	a_tm_s[a_tm->length] = '\0';
2355f5b1c8a1SJohn Marino 
2356f5b1c8a1SJohn Marino 	if (strncmp(a_tm_s, "49", 2) <= 0)
2357f5b1c8a1SJohn Marino 		a_y2k = 1;
2358f5b1c8a1SJohn Marino 	else
2359f5b1c8a1SJohn Marino 		a_y2k = 0;
2360f5b1c8a1SJohn Marino 
2361f5b1c8a1SJohn Marino 	for (i = 0; i < sk_OPENSSL_PSTRING_num(db->db->data); i++) {
2362f5b1c8a1SJohn Marino 		rrow = sk_OPENSSL_PSTRING_value(db->db->data, i);
2363f5b1c8a1SJohn Marino 
2364f5b1c8a1SJohn Marino 		if (rrow[DB_type][0] == 'V') {
2365f5b1c8a1SJohn Marino 			/* ignore entries that are not valid */
2366f5b1c8a1SJohn Marino 			if (strncmp(rrow[DB_exp_date], "49", 2) <= 0)
2367f5b1c8a1SJohn Marino 				db_y2k = 1;
2368f5b1c8a1SJohn Marino 			else
2369f5b1c8a1SJohn Marino 				db_y2k = 0;
2370f5b1c8a1SJohn Marino 
2371f5b1c8a1SJohn Marino 			if (db_y2k == a_y2k) {
2372f5b1c8a1SJohn Marino 				/* all on the same y2k side */
2373f5b1c8a1SJohn Marino 				if (strcmp(rrow[DB_exp_date], a_tm_s) <= 0) {
2374f5b1c8a1SJohn Marino 					rrow[DB_type][0] = 'E';
2375f5b1c8a1SJohn Marino 					rrow[DB_type][1] = '\0';
2376f5b1c8a1SJohn Marino 					cnt++;
2377f5b1c8a1SJohn Marino 
2378f5b1c8a1SJohn Marino 					BIO_printf(bio_err, "%s=Expired\n",
2379f5b1c8a1SJohn Marino 					    rrow[DB_serial]);
2380f5b1c8a1SJohn Marino 				}
2381f5b1c8a1SJohn Marino 			} else if (db_y2k < a_y2k) {
2382f5b1c8a1SJohn Marino 				rrow[DB_type][0] = 'E';
2383f5b1c8a1SJohn Marino 				rrow[DB_type][1] = '\0';
2384f5b1c8a1SJohn Marino 				cnt++;
2385f5b1c8a1SJohn Marino 
2386f5b1c8a1SJohn Marino 				BIO_printf(bio_err, "%s=Expired\n",
2387f5b1c8a1SJohn Marino 				    rrow[DB_serial]);
2388f5b1c8a1SJohn Marino 			}
2389f5b1c8a1SJohn Marino 		}
2390f5b1c8a1SJohn Marino 	}
2391f5b1c8a1SJohn Marino 
2392f5b1c8a1SJohn Marino err:
2393f5b1c8a1SJohn Marino 	ASN1_UTCTIME_free(a_tm);
2394f5b1c8a1SJohn Marino 	free(a_tm_s);
2395f5b1c8a1SJohn Marino 
2396f5b1c8a1SJohn Marino 	return (cnt);
2397f5b1c8a1SJohn Marino }
2398f5b1c8a1SJohn Marino 
2399f5b1c8a1SJohn Marino static const char *crl_reasons[] = {
2400f5b1c8a1SJohn Marino 	/* CRL reason strings */
2401f5b1c8a1SJohn Marino 	"unspecified",
2402f5b1c8a1SJohn Marino 	"keyCompromise",
2403f5b1c8a1SJohn Marino 	"CACompromise",
2404f5b1c8a1SJohn Marino 	"affiliationChanged",
2405f5b1c8a1SJohn Marino 	"superseded",
2406f5b1c8a1SJohn Marino 	"cessationOfOperation",
2407f5b1c8a1SJohn Marino 	"certificateHold",
2408f5b1c8a1SJohn Marino 	"removeFromCRL",
2409f5b1c8a1SJohn Marino 	/* Additional pseudo reasons */
2410f5b1c8a1SJohn Marino 	"holdInstruction",
2411f5b1c8a1SJohn Marino 	"keyTime",
2412f5b1c8a1SJohn Marino 	"CAkeyTime"
2413f5b1c8a1SJohn Marino };
2414f5b1c8a1SJohn Marino 
2415f5b1c8a1SJohn Marino #define NUM_REASONS (sizeof(crl_reasons) / sizeof(char *))
2416f5b1c8a1SJohn Marino 
2417f5b1c8a1SJohn Marino /* Given revocation information convert to a DB string.
2418f5b1c8a1SJohn Marino  * The format of the string is:
2419f5b1c8a1SJohn Marino  * revtime[,reason,extra]. Where 'revtime' is the
2420f5b1c8a1SJohn Marino  * revocation time (the current time). 'reason' is the
2421f5b1c8a1SJohn Marino  * optional CRL reason and 'extra' is any additional
2422f5b1c8a1SJohn Marino  * argument
2423f5b1c8a1SJohn Marino  */
2424f5b1c8a1SJohn Marino 
2425f5b1c8a1SJohn Marino char *
2426f5b1c8a1SJohn Marino make_revocation_str(int rev_type, char *rev_arg)
2427f5b1c8a1SJohn Marino {
2428f5b1c8a1SJohn Marino 	char *other = NULL, *str;
2429f5b1c8a1SJohn Marino 	const char *reason = NULL;
2430f5b1c8a1SJohn Marino 	ASN1_OBJECT *otmp;
2431f5b1c8a1SJohn Marino 	ASN1_UTCTIME *revtm = NULL;
2432f5b1c8a1SJohn Marino 	int i;
2433f5b1c8a1SJohn Marino 	switch (rev_type) {
2434f5b1c8a1SJohn Marino 	case REV_NONE:
2435f5b1c8a1SJohn Marino 		break;
2436f5b1c8a1SJohn Marino 
2437f5b1c8a1SJohn Marino 	case REV_CRL_REASON:
2438f5b1c8a1SJohn Marino 		for (i = 0; i < 8; i++) {
2439f5b1c8a1SJohn Marino 			if (!strcasecmp(rev_arg, crl_reasons[i])) {
2440f5b1c8a1SJohn Marino 				reason = crl_reasons[i];
2441f5b1c8a1SJohn Marino 				break;
2442f5b1c8a1SJohn Marino 			}
2443f5b1c8a1SJohn Marino 		}
2444f5b1c8a1SJohn Marino 		if (reason == NULL) {
2445f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "Unknown CRL reason %s\n", rev_arg);
2446f5b1c8a1SJohn Marino 			return NULL;
2447f5b1c8a1SJohn Marino 		}
2448f5b1c8a1SJohn Marino 		break;
2449f5b1c8a1SJohn Marino 
2450f5b1c8a1SJohn Marino 	case REV_HOLD:
2451f5b1c8a1SJohn Marino 		/* Argument is an OID */
2452f5b1c8a1SJohn Marino 
2453f5b1c8a1SJohn Marino 		otmp = OBJ_txt2obj(rev_arg, 0);
2454f5b1c8a1SJohn Marino 		ASN1_OBJECT_free(otmp);
2455f5b1c8a1SJohn Marino 
2456f5b1c8a1SJohn Marino 		if (otmp == NULL) {
2457f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
2458f5b1c8a1SJohn Marino 			    "Invalid object identifier %s\n", rev_arg);
2459f5b1c8a1SJohn Marino 			return NULL;
2460f5b1c8a1SJohn Marino 		}
2461f5b1c8a1SJohn Marino 		reason = "holdInstruction";
2462f5b1c8a1SJohn Marino 		other = rev_arg;
2463f5b1c8a1SJohn Marino 		break;
2464f5b1c8a1SJohn Marino 
2465f5b1c8a1SJohn Marino 	case REV_KEY_COMPROMISE:
2466f5b1c8a1SJohn Marino 	case REV_CA_COMPROMISE:
2467f5b1c8a1SJohn Marino 
2468f5b1c8a1SJohn Marino 		/* Argument is the key compromise time  */
2469f5b1c8a1SJohn Marino 		if (!ASN1_GENERALIZEDTIME_set_string(NULL, rev_arg)) {
2470f5b1c8a1SJohn Marino 			BIO_printf(bio_err,
2471f5b1c8a1SJohn Marino 			    "Invalid time format %s. Need YYYYMMDDHHMMSSZ\n",
2472f5b1c8a1SJohn Marino 			    rev_arg);
2473f5b1c8a1SJohn Marino 			return NULL;
2474f5b1c8a1SJohn Marino 		}
2475f5b1c8a1SJohn Marino 		other = rev_arg;
2476f5b1c8a1SJohn Marino 		if (rev_type == REV_KEY_COMPROMISE)
2477f5b1c8a1SJohn Marino 			reason = "keyTime";
2478f5b1c8a1SJohn Marino 		else
2479f5b1c8a1SJohn Marino 			reason = "CAkeyTime";
2480f5b1c8a1SJohn Marino 
2481f5b1c8a1SJohn Marino 		break;
2482f5b1c8a1SJohn Marino 
2483f5b1c8a1SJohn Marino 	}
2484f5b1c8a1SJohn Marino 
2485f5b1c8a1SJohn Marino 	revtm = X509_gmtime_adj(NULL, 0);
2486f5b1c8a1SJohn Marino 	if (asprintf(&str, "%s%s%s%s%s", revtm->data,
2487f5b1c8a1SJohn Marino 	    reason ? "," : "", reason ? reason : "",
2488f5b1c8a1SJohn Marino 	    other ? "," : "", other ? other : "") == -1)
2489f5b1c8a1SJohn Marino 		str = NULL;
2490f5b1c8a1SJohn Marino 	ASN1_UTCTIME_free(revtm);
2491f5b1c8a1SJohn Marino 	return str;
2492f5b1c8a1SJohn Marino }
2493f5b1c8a1SJohn Marino 
2494f5b1c8a1SJohn Marino /* Convert revocation field to X509_REVOKED entry
2495f5b1c8a1SJohn Marino  * return code:
2496f5b1c8a1SJohn Marino  * 0 error
2497f5b1c8a1SJohn Marino  * 1 OK
2498f5b1c8a1SJohn Marino  * 2 OK and some extensions added (i.e. V2 CRL)
2499f5b1c8a1SJohn Marino  */
2500f5b1c8a1SJohn Marino 
2501f5b1c8a1SJohn Marino int
2502f5b1c8a1SJohn Marino make_revoked(X509_REVOKED * rev, const char *str)
2503f5b1c8a1SJohn Marino {
2504f5b1c8a1SJohn Marino 	char *tmp = NULL;
2505f5b1c8a1SJohn Marino 	int reason_code = -1;
2506f5b1c8a1SJohn Marino 	int i, ret = 0;
2507f5b1c8a1SJohn Marino 	ASN1_OBJECT *hold = NULL;
2508f5b1c8a1SJohn Marino 	ASN1_GENERALIZEDTIME *comp_time = NULL;
2509f5b1c8a1SJohn Marino 	ASN1_ENUMERATED *rtmp = NULL;
2510f5b1c8a1SJohn Marino 
2511f5b1c8a1SJohn Marino 	ASN1_TIME *revDate = NULL;
2512f5b1c8a1SJohn Marino 
2513f5b1c8a1SJohn Marino 	i = unpack_revinfo(&revDate, &reason_code, &hold, &comp_time, str);
2514f5b1c8a1SJohn Marino 
2515f5b1c8a1SJohn Marino 	if (i == 0)
2516f5b1c8a1SJohn Marino 		goto err;
2517f5b1c8a1SJohn Marino 
2518f5b1c8a1SJohn Marino 	if (rev && !X509_REVOKED_set_revocationDate(rev, revDate))
2519f5b1c8a1SJohn Marino 		goto err;
2520f5b1c8a1SJohn Marino 
2521f5b1c8a1SJohn Marino 	if (rev && (reason_code != OCSP_REVOKED_STATUS_NOSTATUS)) {
2522f5b1c8a1SJohn Marino 		rtmp = ASN1_ENUMERATED_new();
2523f5b1c8a1SJohn Marino 		if (!rtmp || !ASN1_ENUMERATED_set(rtmp, reason_code))
2524f5b1c8a1SJohn Marino 			goto err;
2525f5b1c8a1SJohn Marino 		if (!X509_REVOKED_add1_ext_i2d(rev, NID_crl_reason, rtmp, 0, 0))
2526f5b1c8a1SJohn Marino 			goto err;
2527f5b1c8a1SJohn Marino 	}
2528f5b1c8a1SJohn Marino 	if (rev && comp_time) {
2529f5b1c8a1SJohn Marino 		if (!X509_REVOKED_add1_ext_i2d(rev, NID_invalidity_date,
2530f5b1c8a1SJohn Marino 		    comp_time, 0, 0))
2531f5b1c8a1SJohn Marino 			goto err;
2532f5b1c8a1SJohn Marino 	}
2533f5b1c8a1SJohn Marino 	if (rev && hold) {
2534f5b1c8a1SJohn Marino 		if (!X509_REVOKED_add1_ext_i2d(rev, NID_hold_instruction_code,
2535f5b1c8a1SJohn Marino 		    hold, 0, 0))
2536f5b1c8a1SJohn Marino 			goto err;
2537f5b1c8a1SJohn Marino 	}
2538f5b1c8a1SJohn Marino 	if (reason_code != OCSP_REVOKED_STATUS_NOSTATUS)
2539f5b1c8a1SJohn Marino 		ret = 2;
2540f5b1c8a1SJohn Marino 	else
2541f5b1c8a1SJohn Marino 		ret = 1;
2542f5b1c8a1SJohn Marino 
2543f5b1c8a1SJohn Marino err:
2544f5b1c8a1SJohn Marino 	free(tmp);
2545f5b1c8a1SJohn Marino 
2546f5b1c8a1SJohn Marino 	ASN1_OBJECT_free(hold);
2547f5b1c8a1SJohn Marino 	ASN1_GENERALIZEDTIME_free(comp_time);
2548f5b1c8a1SJohn Marino 	ASN1_ENUMERATED_free(rtmp);
2549f5b1c8a1SJohn Marino 	ASN1_TIME_free(revDate);
2550f5b1c8a1SJohn Marino 
2551f5b1c8a1SJohn Marino 	return ret;
2552f5b1c8a1SJohn Marino }
2553f5b1c8a1SJohn Marino 
2554f5b1c8a1SJohn Marino int
2555f5b1c8a1SJohn Marino old_entry_print(BIO * bp, ASN1_OBJECT * obj, ASN1_STRING * str)
2556f5b1c8a1SJohn Marino {
2557f5b1c8a1SJohn Marino 	char buf[25], *pbuf, *p;
2558f5b1c8a1SJohn Marino 	int j;
2559f5b1c8a1SJohn Marino 
2560f5b1c8a1SJohn Marino 	j = i2a_ASN1_OBJECT(bp, obj);
2561f5b1c8a1SJohn Marino 	pbuf = buf;
2562f5b1c8a1SJohn Marino 	for (j = 22 - j; j > 0; j--)
2563f5b1c8a1SJohn Marino 		*(pbuf++) = ' ';
2564f5b1c8a1SJohn Marino 	*(pbuf++) = ':';
2565f5b1c8a1SJohn Marino 	*(pbuf++) = '\0';
2566f5b1c8a1SJohn Marino 	BIO_puts(bp, buf);
2567f5b1c8a1SJohn Marino 
2568f5b1c8a1SJohn Marino 	if (str->type == V_ASN1_PRINTABLESTRING)
2569f5b1c8a1SJohn Marino 		BIO_printf(bp, "PRINTABLE:'");
2570f5b1c8a1SJohn Marino 	else if (str->type == V_ASN1_T61STRING)
2571f5b1c8a1SJohn Marino 		BIO_printf(bp, "T61STRING:'");
2572f5b1c8a1SJohn Marino 	else if (str->type == V_ASN1_IA5STRING)
2573f5b1c8a1SJohn Marino 		BIO_printf(bp, "IA5STRING:'");
2574f5b1c8a1SJohn Marino 	else if (str->type == V_ASN1_UNIVERSALSTRING)
2575f5b1c8a1SJohn Marino 		BIO_printf(bp, "UNIVERSALSTRING:'");
2576f5b1c8a1SJohn Marino 	else
2577f5b1c8a1SJohn Marino 		BIO_printf(bp, "ASN.1 %2d:'", str->type);
2578f5b1c8a1SJohn Marino 
2579f5b1c8a1SJohn Marino 	p = (char *) str->data;
2580f5b1c8a1SJohn Marino 	for (j = str->length; j > 0; j--) {
2581f5b1c8a1SJohn Marino 		if ((*p >= ' ') && (*p <= '~'))
2582f5b1c8a1SJohn Marino 			BIO_printf(bp, "%c", *p);
2583f5b1c8a1SJohn Marino 		else if (*p & 0x80)
2584f5b1c8a1SJohn Marino 			BIO_printf(bp, "\\0x%02X", *p);
2585f5b1c8a1SJohn Marino 		else if ((unsigned char) *p == 0xf7)
2586f5b1c8a1SJohn Marino 			BIO_printf(bp, "^?");
2587f5b1c8a1SJohn Marino 		else
2588f5b1c8a1SJohn Marino 			BIO_printf(bp, "^%c", *p + '@');
2589f5b1c8a1SJohn Marino 		p++;
2590f5b1c8a1SJohn Marino 	}
2591f5b1c8a1SJohn Marino 	BIO_printf(bp, "'\n");
2592f5b1c8a1SJohn Marino 	return 1;
2593f5b1c8a1SJohn Marino }
2594f5b1c8a1SJohn Marino 
2595f5b1c8a1SJohn Marino int
2596f5b1c8a1SJohn Marino unpack_revinfo(ASN1_TIME ** prevtm, int *preason, ASN1_OBJECT ** phold,
2597f5b1c8a1SJohn Marino     ASN1_GENERALIZEDTIME ** pinvtm, const char *str)
2598f5b1c8a1SJohn Marino {
2599f5b1c8a1SJohn Marino 	char *tmp = NULL;
2600f5b1c8a1SJohn Marino 	char *rtime_str, *reason_str = NULL, *arg_str = NULL, *p;
2601f5b1c8a1SJohn Marino 	int reason_code = -1;
2602f5b1c8a1SJohn Marino 	int ret = 0;
2603f5b1c8a1SJohn Marino 	unsigned int i;
2604f5b1c8a1SJohn Marino 	ASN1_OBJECT *hold = NULL;
2605f5b1c8a1SJohn Marino 	ASN1_GENERALIZEDTIME *comp_time = NULL;
2606f5b1c8a1SJohn Marino 
2607f5b1c8a1SJohn Marino 	if ((tmp = strdup(str)) == NULL) {
2608f5b1c8a1SJohn Marino 		BIO_printf(bio_err, "malloc failed\n");
2609f5b1c8a1SJohn Marino 		goto err;
2610f5b1c8a1SJohn Marino 	}
2611f5b1c8a1SJohn Marino 	p = strchr(tmp, ',');
2612f5b1c8a1SJohn Marino 	rtime_str = tmp;
2613f5b1c8a1SJohn Marino 
2614f5b1c8a1SJohn Marino 	if (p) {
2615f5b1c8a1SJohn Marino 		*p = '\0';
2616f5b1c8a1SJohn Marino 		p++;
2617f5b1c8a1SJohn Marino 		reason_str = p;
2618f5b1c8a1SJohn Marino 		p = strchr(p, ',');
2619f5b1c8a1SJohn Marino 		if (p) {
2620f5b1c8a1SJohn Marino 			*p = '\0';
2621f5b1c8a1SJohn Marino 			arg_str = p + 1;
2622f5b1c8a1SJohn Marino 		}
2623f5b1c8a1SJohn Marino 	}
2624f5b1c8a1SJohn Marino 	if (prevtm) {
2625f5b1c8a1SJohn Marino 		*prevtm = ASN1_UTCTIME_new();
2626f5b1c8a1SJohn Marino 		if (!ASN1_UTCTIME_set_string(*prevtm, rtime_str)) {
2627f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "invalid revocation date %s\n",
2628f5b1c8a1SJohn Marino 			    rtime_str);
2629f5b1c8a1SJohn Marino 			goto err;
2630f5b1c8a1SJohn Marino 		}
2631f5b1c8a1SJohn Marino 	}
2632f5b1c8a1SJohn Marino 	if (reason_str) {
2633f5b1c8a1SJohn Marino 		for (i = 0; i < NUM_REASONS; i++) {
2634f5b1c8a1SJohn Marino 			if (!strcasecmp(reason_str, crl_reasons[i])) {
2635f5b1c8a1SJohn Marino 				reason_code = i;
2636f5b1c8a1SJohn Marino 				break;
2637f5b1c8a1SJohn Marino 			}
2638f5b1c8a1SJohn Marino 		}
2639f5b1c8a1SJohn Marino 		if (reason_code == OCSP_REVOKED_STATUS_NOSTATUS) {
2640f5b1c8a1SJohn Marino 			BIO_printf(bio_err, "invalid reason code %s\n",
2641f5b1c8a1SJohn Marino 			    reason_str);
2642f5b1c8a1SJohn Marino 			goto err;
2643f5b1c8a1SJohn Marino 		}
2644f5b1c8a1SJohn Marino 		if (reason_code == 7)
2645f5b1c8a1SJohn Marino 			reason_code = OCSP_REVOKED_STATUS_REMOVEFROMCRL;
2646f5b1c8a1SJohn Marino 		else if (reason_code == 8) {	/* Hold instruction */
2647f5b1c8a1SJohn Marino 			if (!arg_str) {
2648f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
2649f5b1c8a1SJohn Marino 				    "missing hold instruction\n");
2650f5b1c8a1SJohn Marino 				goto err;
2651f5b1c8a1SJohn Marino 			}
2652f5b1c8a1SJohn Marino 			reason_code = OCSP_REVOKED_STATUS_CERTIFICATEHOLD;
2653f5b1c8a1SJohn Marino 			hold = OBJ_txt2obj(arg_str, 0);
2654f5b1c8a1SJohn Marino 
2655f5b1c8a1SJohn Marino 			if (!hold) {
2656f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
2657f5b1c8a1SJohn Marino 				    "invalid object identifier %s\n", arg_str);
2658f5b1c8a1SJohn Marino 				goto err;
2659f5b1c8a1SJohn Marino 			}
2660f5b1c8a1SJohn Marino 			if (phold)
2661f5b1c8a1SJohn Marino 				*phold = hold;
2662f5b1c8a1SJohn Marino 		} else if ((reason_code == 9) || (reason_code == 10)) {
2663f5b1c8a1SJohn Marino 			if (!arg_str) {
2664f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
2665f5b1c8a1SJohn Marino 				    "missing compromised time\n");
2666f5b1c8a1SJohn Marino 				goto err;
2667f5b1c8a1SJohn Marino 			}
2668f5b1c8a1SJohn Marino 			comp_time = ASN1_GENERALIZEDTIME_new();
2669f5b1c8a1SJohn Marino 			if (!ASN1_GENERALIZEDTIME_set_string(comp_time,
2670f5b1c8a1SJohn Marino 			    arg_str)) {
2671f5b1c8a1SJohn Marino 				BIO_printf(bio_err,
2672f5b1c8a1SJohn Marino 				    "invalid compromised time %s\n", arg_str);
2673f5b1c8a1SJohn Marino 				goto err;
2674f5b1c8a1SJohn Marino 			}
2675f5b1c8a1SJohn Marino 			if (reason_code == 9)
2676f5b1c8a1SJohn Marino 				reason_code = OCSP_REVOKED_STATUS_KEYCOMPROMISE;
2677f5b1c8a1SJohn Marino 			else
2678f5b1c8a1SJohn Marino 				reason_code = OCSP_REVOKED_STATUS_CACOMPROMISE;
2679f5b1c8a1SJohn Marino 		}
2680f5b1c8a1SJohn Marino 	}
2681f5b1c8a1SJohn Marino 	if (preason)
2682f5b1c8a1SJohn Marino 		*preason = reason_code;
2683f5b1c8a1SJohn Marino 	if (pinvtm)
2684f5b1c8a1SJohn Marino 		*pinvtm = comp_time;
2685f5b1c8a1SJohn Marino 	else
2686f5b1c8a1SJohn Marino 		ASN1_GENERALIZEDTIME_free(comp_time);
2687f5b1c8a1SJohn Marino 
2688f5b1c8a1SJohn Marino 	ret = 1;
2689f5b1c8a1SJohn Marino 
2690f5b1c8a1SJohn Marino err:
2691f5b1c8a1SJohn Marino 	free(tmp);
2692f5b1c8a1SJohn Marino 
2693f5b1c8a1SJohn Marino 	if (!phold)
2694f5b1c8a1SJohn Marino 		ASN1_OBJECT_free(hold);
2695f5b1c8a1SJohn Marino 	if (!pinvtm)
2696f5b1c8a1SJohn Marino 		ASN1_GENERALIZEDTIME_free(comp_time);
2697f5b1c8a1SJohn Marino 
2698f5b1c8a1SJohn Marino 	return ret;
2699f5b1c8a1SJohn Marino }
2700f5b1c8a1SJohn Marino 
2701f5b1c8a1SJohn Marino static char *
2702f5b1c8a1SJohn Marino bin2hex(unsigned char * data, size_t len)
2703f5b1c8a1SJohn Marino {
2704f5b1c8a1SJohn Marino 	char *ret = NULL;
2705f5b1c8a1SJohn Marino 	char hex[] = "0123456789ABCDEF";
2706f5b1c8a1SJohn Marino 	int i;
2707f5b1c8a1SJohn Marino 
2708f5b1c8a1SJohn Marino 	if ((ret = malloc(len * 2 + 1))) {
2709f5b1c8a1SJohn Marino 		for (i = 0; i < len; i++) {
2710f5b1c8a1SJohn Marino 			ret[i * 2 + 0] = hex[data[i] >> 4];
2711f5b1c8a1SJohn Marino 			ret[i * 2 + 1] = hex[data[i] & 0x0F];
2712f5b1c8a1SJohn Marino 		}
2713f5b1c8a1SJohn Marino 		ret[len * 2] = '\0';
2714f5b1c8a1SJohn Marino 	}
2715f5b1c8a1SJohn Marino 	return ret;
2716f5b1c8a1SJohn Marino }
2717