1 /* crypto/asn1/x_x509.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 *
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
22 *
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
25 * are met:
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 *
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.] */
57
58 #include <assert.h>
59 #include <limits.h>
60 #include <stdio.h>
61
62 #include <openssl/asn1t.h>
63 #include <openssl/evp.h>
64 #include <openssl/mem.h>
65 #include <openssl/obj.h>
66 #include <openssl/pool.h>
67 #include <openssl/thread.h>
68 #include <openssl/x509.h>
69 #include <openssl/x509v3.h>
70
71 #include "../internal.h"
72 #include "internal.h"
73
74 static CRYPTO_EX_DATA_CLASS g_ex_data_class = CRYPTO_EX_DATA_CLASS_INIT;
75
76 ASN1_SEQUENCE_enc(X509_CINF, enc, 0) = {
77 ASN1_EXP_OPT(X509_CINF, version, ASN1_INTEGER, 0),
78 ASN1_SIMPLE(X509_CINF, serialNumber, ASN1_INTEGER),
79 ASN1_SIMPLE(X509_CINF, signature, X509_ALGOR),
80 ASN1_SIMPLE(X509_CINF, issuer, X509_NAME),
81 ASN1_SIMPLE(X509_CINF, validity, X509_VAL),
82 ASN1_SIMPLE(X509_CINF, subject, X509_NAME),
83 ASN1_SIMPLE(X509_CINF, key, X509_PUBKEY),
84 ASN1_IMP_OPT(X509_CINF, issuerUID, ASN1_BIT_STRING, 1),
85 ASN1_IMP_OPT(X509_CINF, subjectUID, ASN1_BIT_STRING, 2),
86 ASN1_EXP_SEQUENCE_OF_OPT(X509_CINF, extensions, X509_EXTENSION, 3)
87 } ASN1_SEQUENCE_END_enc(X509_CINF, X509_CINF)
88
89 IMPLEMENT_ASN1_FUNCTIONS(X509_CINF)
90 /* X509 top level structure needs a bit of customisation */
91
92 extern void policy_cache_free(X509_POLICY_CACHE *cache);
93
x509_cb(int operation,ASN1_VALUE ** pval,const ASN1_ITEM * it,void * exarg)94 static int x509_cb(int operation, ASN1_VALUE **pval, const ASN1_ITEM *it,
95 void *exarg)
96 {
97 X509 *ret = (X509 *)*pval;
98
99 switch (operation) {
100
101 case ASN1_OP_NEW_POST:
102 ret->ex_flags = 0;
103 ret->ex_pathlen = -1;
104 ret->skid = NULL;
105 ret->akid = NULL;
106 ret->aux = NULL;
107 ret->crldp = NULL;
108 ret->buf = NULL;
109 CRYPTO_new_ex_data(&ret->ex_data);
110 CRYPTO_MUTEX_init(&ret->lock);
111 break;
112
113 case ASN1_OP_D2I_PRE:
114 CRYPTO_BUFFER_free(ret->buf);
115 ret->buf = NULL;
116 break;
117
118 case ASN1_OP_D2I_POST: {
119 /* The version must be one of v1(0), v2(1), or v3(2). */
120 long version = 0;
121 if (ret->cert_info->version != NULL) {
122 version = ASN1_INTEGER_get(ret->cert_info->version);
123 /* TODO(https://crbug.com/boringssl/364): |version| = 0 should also
124 * be rejected. This means an explicitly-encoded X.509v1 version.
125 * v1 is DEFAULT, so DER requires it be omitted. */
126 if (version < 0 || version > 2) {
127 OPENSSL_PUT_ERROR(X509, X509_R_INVALID_VERSION);
128 return 0;
129 }
130 }
131
132 /* Per RFC 5280, section 4.1.2.8, these fields require v2 or v3. */
133 if (version == 0 && (ret->cert_info->issuerUID != NULL ||
134 ret->cert_info->subjectUID != NULL)) {
135 OPENSSL_PUT_ERROR(X509, X509_R_INVALID_FIELD_FOR_VERSION);
136 return 0;
137 }
138
139 /* Per RFC 5280, section 4.1.2.9, extensions require v3. */
140 if (version != 2 && ret->cert_info->extensions != NULL) {
141 OPENSSL_PUT_ERROR(X509, X509_R_INVALID_FIELD_FOR_VERSION);
142 return 0;
143 }
144
145 break;
146 }
147
148 case ASN1_OP_FREE_POST:
149 CRYPTO_MUTEX_cleanup(&ret->lock);
150 CRYPTO_free_ex_data(&g_ex_data_class, ret, &ret->ex_data);
151 X509_CERT_AUX_free(ret->aux);
152 ASN1_OCTET_STRING_free(ret->skid);
153 AUTHORITY_KEYID_free(ret->akid);
154 CRL_DIST_POINTS_free(ret->crldp);
155 policy_cache_free(ret->policy_cache);
156 GENERAL_NAMES_free(ret->altname);
157 NAME_CONSTRAINTS_free(ret->nc);
158 CRYPTO_BUFFER_free(ret->buf);
159 break;
160
161 }
162
163 return 1;
164
165 }
166
167 ASN1_SEQUENCE_ref(X509, x509_cb) = {
168 ASN1_SIMPLE(X509, cert_info, X509_CINF),
169 ASN1_SIMPLE(X509, sig_alg, X509_ALGOR),
170 ASN1_SIMPLE(X509, signature, ASN1_BIT_STRING)
171 } ASN1_SEQUENCE_END_ref(X509, X509)
172
173 IMPLEMENT_ASN1_FUNCTIONS(X509)
174
175 IMPLEMENT_ASN1_DUP_FUNCTION(X509)
176
177 X509 *X509_parse_from_buffer(CRYPTO_BUFFER *buf) {
178 if (CRYPTO_BUFFER_len(buf) > LONG_MAX) {
179 OPENSSL_PUT_ERROR(SSL, ERR_R_OVERFLOW);
180 return 0;
181 }
182
183 X509 *x509 = X509_new();
184 if (x509 == NULL) {
185 return NULL;
186 }
187
188 x509->cert_info->enc.alias_only_on_next_parse = 1;
189
190 const uint8_t *inp = CRYPTO_BUFFER_data(buf);
191 X509 *x509p = x509;
192 X509 *ret = d2i_X509(&x509p, &inp, CRYPTO_BUFFER_len(buf));
193 if (ret == NULL ||
194 inp - CRYPTO_BUFFER_data(buf) != (ptrdiff_t)CRYPTO_BUFFER_len(buf)) {
195 X509_free(x509p);
196 return NULL;
197 }
198 assert(x509p == x509);
199 assert(ret == x509);
200
201 CRYPTO_BUFFER_up_ref(buf);
202 ret->buf = buf;
203
204 return ret;
205 }
206
X509_up_ref(X509 * x)207 int X509_up_ref(X509 *x)
208 {
209 CRYPTO_refcount_inc(&x->references);
210 return 1;
211 }
212
X509_get_ex_new_index(long argl,void * argp,CRYPTO_EX_unused * unused,CRYPTO_EX_dup * dup_unused,CRYPTO_EX_free * free_func)213 int X509_get_ex_new_index(long argl, void *argp, CRYPTO_EX_unused * unused,
214 CRYPTO_EX_dup *dup_unused, CRYPTO_EX_free *free_func)
215 {
216 int index;
217 if (!CRYPTO_get_ex_new_index(&g_ex_data_class, &index, argl, argp,
218 free_func)) {
219 return -1;
220 }
221 return index;
222 }
223
X509_set_ex_data(X509 * r,int idx,void * arg)224 int X509_set_ex_data(X509 *r, int idx, void *arg)
225 {
226 return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
227 }
228
X509_get_ex_data(X509 * r,int idx)229 void *X509_get_ex_data(X509 *r, int idx)
230 {
231 return (CRYPTO_get_ex_data(&r->ex_data, idx));
232 }
233
234 /*
235 * X509_AUX ASN1 routines. X509_AUX is the name given to a certificate with
236 * extra info tagged on the end. Since these functions set how a certificate
237 * is trusted they should only be used when the certificate comes from a
238 * reliable source such as local storage.
239 */
240
d2i_X509_AUX(X509 ** a,const unsigned char ** pp,long length)241 X509 *d2i_X509_AUX(X509 **a, const unsigned char **pp, long length)
242 {
243 const unsigned char *q = *pp;
244 X509 *ret;
245 int freeret = 0;
246
247 if (!a || *a == NULL)
248 freeret = 1;
249 ret = d2i_X509(a, &q, length);
250 /* If certificate unreadable then forget it */
251 if (!ret)
252 return NULL;
253 /* update length */
254 length -= q - *pp;
255 /* Parse auxiliary information if there is any. */
256 if (length > 0 && !d2i_X509_CERT_AUX(&ret->aux, &q, length))
257 goto err;
258 *pp = q;
259 return ret;
260 err:
261 if (freeret) {
262 X509_free(ret);
263 if (a)
264 *a = NULL;
265 }
266 return NULL;
267 }
268
269 /*
270 * Serialize trusted certificate to *pp or just return the required buffer
271 * length if pp == NULL. We ultimately want to avoid modifying *pp in the
272 * error path, but that depends on similar hygiene in lower-level functions.
273 * Here we avoid compounding the problem.
274 */
i2d_x509_aux_internal(X509 * a,unsigned char ** pp)275 static int i2d_x509_aux_internal(X509 *a, unsigned char **pp)
276 {
277 int length, tmplen;
278 unsigned char *start = pp != NULL ? *pp : NULL;
279
280 assert(pp == NULL || *pp != NULL);
281
282 /*
283 * This might perturb *pp on error, but fixing that belongs in i2d_X509()
284 * not here. It should be that if a == NULL length is zero, but we check
285 * both just in case.
286 */
287 length = i2d_X509(a, pp);
288 if (length <= 0 || a == NULL) {
289 return length;
290 }
291
292 tmplen = i2d_X509_CERT_AUX(a->aux, pp);
293 if (tmplen < 0) {
294 if (start != NULL)
295 *pp = start;
296 return tmplen;
297 }
298 length += tmplen;
299
300 return length;
301 }
302
303 /*
304 * Serialize trusted certificate to *pp, or just return the required buffer
305 * length if pp == NULL.
306 *
307 * When pp is not NULL, but *pp == NULL, we allocate the buffer, but since
308 * we're writing two ASN.1 objects back to back, we can't have i2d_X509() do
309 * the allocation, nor can we allow i2d_X509_CERT_AUX() to increment the
310 * allocated buffer.
311 */
i2d_X509_AUX(X509 * a,unsigned char ** pp)312 int i2d_X509_AUX(X509 *a, unsigned char **pp)
313 {
314 int length;
315 unsigned char *tmp;
316
317 /* Buffer provided by caller */
318 if (pp == NULL || *pp != NULL)
319 return i2d_x509_aux_internal(a, pp);
320
321 /* Obtain the combined length */
322 if ((length = i2d_x509_aux_internal(a, NULL)) <= 0)
323 return length;
324
325 /* Allocate requisite combined storage */
326 *pp = tmp = OPENSSL_malloc(length);
327 if (tmp == NULL)
328 return -1; /* Push error onto error stack? */
329
330 /* Encode, but keep *pp at the originally malloced pointer */
331 length = i2d_x509_aux_internal(a, &tmp);
332 if (length <= 0) {
333 OPENSSL_free(*pp);
334 *pp = NULL;
335 }
336 return length;
337 }
338
i2d_re_X509_tbs(X509 * x509,unsigned char ** outp)339 int i2d_re_X509_tbs(X509 *x509, unsigned char **outp)
340 {
341 x509->cert_info->enc.modified = 1;
342 return i2d_X509_CINF(x509->cert_info, outp);
343 }
344
i2d_X509_tbs(X509 * x509,unsigned char ** outp)345 int i2d_X509_tbs(X509 *x509, unsigned char **outp)
346 {
347 return i2d_X509_CINF(x509->cert_info, outp);
348 }
349
X509_set1_signature_algo(X509 * x509,const X509_ALGOR * algo)350 int X509_set1_signature_algo(X509 *x509, const X509_ALGOR *algo)
351 {
352 /* TODO(davidben): Const-correct generated ASN.1 dup functions.
353 * Alternatively, when the types are hidden and we can embed required fields
354 * directly in structs, import |X509_ALGOR_copy| from upstream. */
355 X509_ALGOR *copy1 = X509_ALGOR_dup((X509_ALGOR *)algo);
356 X509_ALGOR *copy2 = X509_ALGOR_dup((X509_ALGOR *)algo);
357 if (copy1 == NULL || copy2 == NULL) {
358 X509_ALGOR_free(copy1);
359 X509_ALGOR_free(copy2);
360 return 0;
361 }
362
363 X509_ALGOR_free(x509->sig_alg);
364 x509->sig_alg = copy1;
365 X509_ALGOR_free(x509->cert_info->signature);
366 x509->cert_info->signature = copy2;
367 return 1;
368 }
369
X509_set1_signature_value(X509 * x509,const uint8_t * sig,size_t sig_len)370 int X509_set1_signature_value(X509 *x509, const uint8_t *sig, size_t sig_len)
371 {
372 if (!ASN1_STRING_set(x509->signature, sig, sig_len)) {
373 return 0;
374 }
375 x509->signature->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
376 x509->signature->flags |= ASN1_STRING_FLAG_BITS_LEFT;
377 return 1;
378 }
379
X509_get0_signature(const ASN1_BIT_STRING ** psig,const X509_ALGOR ** palg,const X509 * x)380 void X509_get0_signature(const ASN1_BIT_STRING **psig, const X509_ALGOR **palg,
381 const X509 *x)
382 {
383 if (psig)
384 *psig = x->signature;
385 if (palg)
386 *palg = x->sig_alg;
387 }
388
X509_get_signature_nid(const X509 * x)389 int X509_get_signature_nid(const X509 *x)
390 {
391 return OBJ_obj2nid(x->sig_alg->algorithm);
392 }
393