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