1 /*
2  * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9 
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include "internal/refcount.h"
13 #include <openssl/asn1.h>
14 #include <openssl/objects.h>
15 #include <openssl/evp.h>
16 #include <openssl/x509.h>
17 #include <openssl/x509v3.h>
18 #include "crypto/asn1.h"
19 #include "crypto/x509.h"
20 #include "x509_local.h"
21 
X509_set_version(X509 * x,long version)22 int X509_set_version(X509 *x, long version)
23 {
24     if (x == NULL)
25         return 0;
26     if (version == 0) {
27         ASN1_INTEGER_free(x->cert_info.version);
28         x->cert_info.version = NULL;
29         return 1;
30     }
31     if (x->cert_info.version == NULL) {
32         if ((x->cert_info.version = ASN1_INTEGER_new()) == NULL)
33             return 0;
34     }
35     return ASN1_INTEGER_set(x->cert_info.version, version);
36 }
37 
X509_set_serialNumber(X509 * x,ASN1_INTEGER * serial)38 int X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
39 {
40     ASN1_INTEGER *in;
41 
42     if (x == NULL)
43         return 0;
44     in = &x->cert_info.serialNumber;
45     if (in != serial)
46         return ASN1_STRING_copy(in, serial);
47     return 1;
48 }
49 
X509_set_issuer_name(X509 * x,const X509_NAME * name)50 int X509_set_issuer_name(X509 *x, const X509_NAME *name)
51 {
52     if (x == NULL)
53         return 0;
54     return X509_NAME_set(&x->cert_info.issuer, name);
55 }
56 
X509_set_subject_name(X509 * x,const X509_NAME * name)57 int X509_set_subject_name(X509 *x, const X509_NAME *name)
58 {
59     if (x == NULL)
60         return 0;
61     return X509_NAME_set(&x->cert_info.subject, name);
62 }
63 
ossl_x509_set1_time(ASN1_TIME ** ptm,const ASN1_TIME * tm)64 int ossl_x509_set1_time(ASN1_TIME **ptm, const ASN1_TIME *tm)
65 {
66     ASN1_TIME *in;
67     in = *ptm;
68     if (in != tm) {
69         in = ASN1_STRING_dup(tm);
70         if (in != NULL) {
71             ASN1_TIME_free(*ptm);
72             *ptm = in;
73         }
74     }
75     return (in != NULL);
76 }
77 
X509_set1_notBefore(X509 * x,const ASN1_TIME * tm)78 int X509_set1_notBefore(X509 *x, const ASN1_TIME *tm)
79 {
80     if (x == NULL)
81         return 0;
82     return ossl_x509_set1_time(&x->cert_info.validity.notBefore, tm);
83 }
84 
X509_set1_notAfter(X509 * x,const ASN1_TIME * tm)85 int X509_set1_notAfter(X509 *x, const ASN1_TIME *tm)
86 {
87     if (x == NULL)
88         return 0;
89     return ossl_x509_set1_time(&x->cert_info.validity.notAfter, tm);
90 }
91 
X509_set_pubkey(X509 * x,EVP_PKEY * pkey)92 int X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
93 {
94     if (x == NULL)
95         return 0;
96     return X509_PUBKEY_set(&(x->cert_info.key), pkey);
97 }
98 
X509_up_ref(X509 * x)99 int X509_up_ref(X509 *x)
100 {
101     int i;
102 
103     if (CRYPTO_UP_REF(&x->references, &i, x->lock) <= 0)
104         return 0;
105 
106     REF_PRINT_COUNT("X509", x);
107     REF_ASSERT_ISNT(i < 2);
108     return ((i > 1) ? 1 : 0);
109 }
110 
X509_get_version(const X509 * x)111 long X509_get_version(const X509 *x)
112 {
113     return ASN1_INTEGER_get(x->cert_info.version);
114 }
115 
X509_get0_notBefore(const X509 * x)116 const ASN1_TIME *X509_get0_notBefore(const X509 *x)
117 {
118     return x->cert_info.validity.notBefore;
119 }
120 
X509_get0_notAfter(const X509 * x)121 const ASN1_TIME *X509_get0_notAfter(const X509 *x)
122 {
123     return x->cert_info.validity.notAfter;
124 }
125 
X509_getm_notBefore(const X509 * x)126 ASN1_TIME *X509_getm_notBefore(const X509 *x)
127 {
128     return x->cert_info.validity.notBefore;
129 }
130 
X509_getm_notAfter(const X509 * x)131 ASN1_TIME *X509_getm_notAfter(const X509 *x)
132 {
133     return x->cert_info.validity.notAfter;
134 }
135 
X509_get_signature_type(const X509 * x)136 int X509_get_signature_type(const X509 *x)
137 {
138     return EVP_PKEY_type(OBJ_obj2nid(x->sig_alg.algorithm));
139 }
140 
X509_get_X509_PUBKEY(const X509 * x)141 X509_PUBKEY *X509_get_X509_PUBKEY(const X509 *x)
142 {
143     return x->cert_info.key;
144 }
145 
STACK_OF(X509_EXTENSION)146 const STACK_OF(X509_EXTENSION) *X509_get0_extensions(const X509 *x)
147 {
148     return x->cert_info.extensions;
149 }
150 
X509_get0_uids(const X509 * x,const ASN1_BIT_STRING ** piuid,const ASN1_BIT_STRING ** psuid)151 void X509_get0_uids(const X509 *x, const ASN1_BIT_STRING **piuid,
152                     const ASN1_BIT_STRING **psuid)
153 {
154     if (piuid != NULL)
155         *piuid = x->cert_info.issuerUID;
156     if (psuid != NULL)
157         *psuid = x->cert_info.subjectUID;
158 }
159 
X509_get0_tbs_sigalg(const X509 * x)160 const X509_ALGOR *X509_get0_tbs_sigalg(const X509 *x)
161 {
162     return &x->cert_info.signature;
163 }
164 
X509_SIG_INFO_get(const X509_SIG_INFO * siginf,int * mdnid,int * pknid,int * secbits,uint32_t * flags)165 int X509_SIG_INFO_get(const X509_SIG_INFO *siginf, int *mdnid, int *pknid,
166                       int *secbits, uint32_t *flags)
167 {
168     if (mdnid != NULL)
169         *mdnid = siginf->mdnid;
170     if (pknid != NULL)
171         *pknid = siginf->pknid;
172     if (secbits != NULL)
173         *secbits = siginf->secbits;
174     if (flags != NULL)
175         *flags = siginf->flags;
176     return (siginf->flags & X509_SIG_INFO_VALID) != 0;
177 }
178 
X509_SIG_INFO_set(X509_SIG_INFO * siginf,int mdnid,int pknid,int secbits,uint32_t flags)179 void X509_SIG_INFO_set(X509_SIG_INFO *siginf, int mdnid, int pknid,
180                        int secbits, uint32_t flags)
181 {
182     siginf->mdnid = mdnid;
183     siginf->pknid = pknid;
184     siginf->secbits = secbits;
185     siginf->flags = flags;
186 }
187 
X509_get_signature_info(X509 * x,int * mdnid,int * pknid,int * secbits,uint32_t * flags)188 int X509_get_signature_info(X509 *x, int *mdnid, int *pknid, int *secbits,
189                             uint32_t *flags)
190 {
191     X509_check_purpose(x, -1, -1);
192     return X509_SIG_INFO_get(&x->siginf, mdnid, pknid, secbits, flags);
193 }
194 
195 /* Modify *siginf according to alg and sig. Return 1 on success, else 0. */
x509_sig_info_init(X509_SIG_INFO * siginf,const X509_ALGOR * alg,const ASN1_STRING * sig)196 static int x509_sig_info_init(X509_SIG_INFO *siginf, const X509_ALGOR *alg,
197                               const ASN1_STRING *sig)
198 {
199     int pknid, mdnid;
200     const EVP_MD *md;
201     const EVP_PKEY_ASN1_METHOD *ameth;
202 
203     siginf->mdnid = NID_undef;
204     siginf->pknid = NID_undef;
205     siginf->secbits = -1;
206     siginf->flags = 0;
207     if (!OBJ_find_sigid_algs(OBJ_obj2nid(alg->algorithm), &mdnid, &pknid)
208             || pknid == NID_undef) {
209         ERR_raise(ERR_LIB_X509, X509_R_UNKNOWN_SIGID_ALGS);
210         return 0;
211     }
212     siginf->mdnid = mdnid;
213     siginf->pknid = pknid;
214 
215     switch (mdnid) {
216     case NID_undef:
217         /* If we have one, use a custom handler for this algorithm */
218         ameth = EVP_PKEY_asn1_find(NULL, pknid);
219         if (ameth == NULL || ameth->siginf_set == NULL
220                 || !ameth->siginf_set(siginf, alg, sig)) {
221             ERR_raise(ERR_LIB_X509, X509_R_ERROR_USING_SIGINF_SET);
222             return 0;
223         }
224         break;
225         /*
226          * SHA1 and MD5 are known to be broken. Reduce security bits so that
227          * they're no longer accepted at security level 1.
228          * The real values don't really matter as long as they're lower than 80,
229          * which is our security level 1.
230          */
231     case NID_sha1:
232         /*
233          * https://eprint.iacr.org/2020/014 puts a chosen-prefix attack
234          * for SHA1 at2^63.4
235          */
236         siginf->secbits = 63;
237         break;
238     case NID_md5:
239         /*
240          * https://documents.epfl.ch/users/l/le/lenstra/public/papers/lat.pdf
241          * puts a chosen-prefix attack for MD5 at 2^39.
242          */
243         siginf->secbits = 39;
244         break;
245     case NID_id_GostR3411_94:
246         /*
247          * There is a collision attack on GOST R 34.11-94 at 2^105, see
248          * https://link.springer.com/chapter/10.1007%2F978-3-540-85174-5_10
249          */
250         siginf->secbits = 105;
251         break;
252     default:
253         /* Security bits: half number of bits in digest */
254         if ((md = EVP_get_digestbynid(mdnid)) == NULL) {
255             ERR_raise(ERR_LIB_X509, X509_R_ERROR_GETTING_MD_BY_NID);
256             return 0;
257         }
258         siginf->secbits = EVP_MD_get_size(md) * 4;
259         break;
260     }
261     switch (mdnid) {
262     case NID_sha1:
263     case NID_sha256:
264     case NID_sha384:
265     case NID_sha512:
266         siginf->flags |= X509_SIG_INFO_TLS;
267     }
268     siginf->flags |= X509_SIG_INFO_VALID;
269     return 1;
270 }
271 
272 /* Returns 1 on success, 0 on failure */
ossl_x509_init_sig_info(X509 * x)273 int ossl_x509_init_sig_info(X509 *x)
274 {
275     return x509_sig_info_init(&x->siginf, &x->sig_alg, &x->signature);
276 }
277