2 * Copyright 2019 The OpenSSL Project Authors. All Rights Reserved.
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
11 #include <openssl/x509v3.h>
12 #include <openssl/err.h>
13 #include <openssl/ess.h>
14 #include "crypto/ess.h"
16 static ESS_CERT_ID *ESS_CERT_ID_new_init(X509 *cert, int issuer_needed);
17 static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg,
18 X509 *cert, int issuer_needed);
20 ESS_SIGNING_CERT *ESS_SIGNING_CERT_new_init(X509 *signcert,
21 STACK_OF(X509) *certs,
24 ESS_CERT_ID *cid = NULL;
28 if ((sc = ESS_SIGNING_CERT_new()) == NULL)
30 if (sc->cert_ids == NULL
31 && (sc->cert_ids = sk_ESS_CERT_ID_new_null()) == NULL)
34 if ((cid = ESS_CERT_ID_new_init(signcert, issuer_needed)) == NULL
35 || !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
37 for (i = 0; i < sk_X509_num(certs); ++i) {
38 X509 *cert = sk_X509_value(certs, i);
39 if ((cid = ESS_CERT_ID_new_init(cert, 1)) == NULL
40 || !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
46 ESS_SIGNING_CERT_free(sc);
47 ESS_CERT_ID_free(cid);
48 ESSerr(ESS_F_ESS_SIGNING_CERT_NEW_INIT, ERR_R_MALLOC_FAILURE);
52 static ESS_CERT_ID *ESS_CERT_ID_new_init(X509 *cert, int issuer_needed)
54 ESS_CERT_ID *cid = NULL;
55 GENERAL_NAME *name = NULL;
56 unsigned char cert_sha1[SHA_DIGEST_LENGTH];
58 /* Call for side-effect of computing hash and caching extensions */
59 X509_check_purpose(cert, -1, 0);
60 if ((cid = ESS_CERT_ID_new()) == NULL)
62 X509_digest(cert, EVP_sha1(), cert_sha1, NULL);
63 if (!ASN1_OCTET_STRING_set(cid->hash, cert_sha1, SHA_DIGEST_LENGTH))
66 /* Setting the issuer/serial if requested. */
70 if (cid->issuer_serial == NULL
71 && (cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
73 if ((name = GENERAL_NAME_new()) == NULL)
75 name->type = GEN_DIRNAME;
76 if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
78 if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
80 name = NULL; /* Ownership is lost. */
81 ASN1_INTEGER_free(cid->issuer_serial->serial);
82 if (!(cid->issuer_serial->serial =
83 ASN1_INTEGER_dup(X509_get_serialNumber(cert))))
88 GENERAL_NAME_free(name);
89 ESS_CERT_ID_free(cid);
90 ESSerr(ESS_F_ESS_CERT_ID_NEW_INIT, ERR_R_MALLOC_FAILURE);
94 ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_new_init(const EVP_MD *hash_alg,
96 STACK_OF(X509) *certs,
99 ESS_CERT_ID_V2 *cid = NULL;
100 ESS_SIGNING_CERT_V2 *sc;
103 if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL)
105 if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, signcert, issuer_needed)) == NULL)
107 if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
111 for (i = 0; i < sk_X509_num(certs); ++i) {
112 X509 *cert = sk_X509_value(certs, i);
114 if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, cert, 1)) == NULL)
116 if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
123 ESS_SIGNING_CERT_V2_free(sc);
124 ESS_CERT_ID_V2_free(cid);
125 ESSerr(ESS_F_ESS_SIGNING_CERT_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
129 static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg,
130 X509 *cert, int issuer_needed)
133 GENERAL_NAME *name = NULL;
134 unsigned char hash[EVP_MAX_MD_SIZE];
135 unsigned int hash_len = sizeof(hash);
136 X509_ALGOR *alg = NULL;
138 memset(hash, 0, sizeof(hash));
140 if ((cid = ESS_CERT_ID_V2_new()) == NULL)
143 if (hash_alg != EVP_sha256()) {
144 alg = X509_ALGOR_new();
147 X509_ALGOR_set_md(alg, hash_alg);
148 if (alg->algorithm == NULL)
153 cid->hash_alg = NULL;
156 if (!X509_digest(cert, hash_alg, hash, &hash_len))
159 if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len))
165 if ((cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
167 if ((name = GENERAL_NAME_new()) == NULL)
169 name->type = GEN_DIRNAME;
170 if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
172 if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
174 name = NULL; /* Ownership is lost. */
175 ASN1_INTEGER_free(cid->issuer_serial->serial);
176 cid->issuer_serial->serial = ASN1_INTEGER_dup(X509_get_serialNumber(cert));
177 if (cid->issuer_serial->serial == NULL)
182 X509_ALGOR_free(alg);
183 GENERAL_NAME_free(name);
184 ESS_CERT_ID_V2_free(cid);
185 ESSerr(ESS_F_ESS_CERT_ID_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
189 ESS_SIGNING_CERT *ESS_SIGNING_CERT_get(PKCS7_SIGNER_INFO *si)
192 const unsigned char *p;
193 attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificate);
196 p = attr->value.sequence->data;
197 return d2i_ESS_SIGNING_CERT(NULL, &p, attr->value.sequence->length);
200 ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_get(PKCS7_SIGNER_INFO *si)
203 const unsigned char *p;
205 attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificateV2);
208 p = attr->value.sequence->data;
209 return d2i_ESS_SIGNING_CERT_V2(NULL, &p, attr->value.sequence->length);
212 int ESS_SIGNING_CERT_add(PKCS7_SIGNER_INFO *si, ESS_SIGNING_CERT *sc)
214 ASN1_STRING *seq = NULL;
215 unsigned char *p, *pp = NULL;
218 len = i2d_ESS_SIGNING_CERT(sc, NULL);
219 if ((pp = OPENSSL_malloc(len)) == NULL) {
220 ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
224 i2d_ESS_SIGNING_CERT(sc, &p);
225 if ((seq = ASN1_STRING_new()) == NULL || !ASN1_STRING_set(seq, pp, len)) {
226 ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
231 return PKCS7_add_signed_attribute(si,
232 NID_id_smime_aa_signingCertificate,
233 V_ASN1_SEQUENCE, seq);
235 ASN1_STRING_free(seq);
241 int ESS_SIGNING_CERT_V2_add(PKCS7_SIGNER_INFO *si,
242 ESS_SIGNING_CERT_V2 *sc)
244 ASN1_STRING *seq = NULL;
245 unsigned char *p, *pp = NULL;
246 int len = i2d_ESS_SIGNING_CERT_V2(sc, NULL);
248 if ((pp = OPENSSL_malloc(len)) == NULL) {
249 ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
254 i2d_ESS_SIGNING_CERT_V2(sc, &p);
255 if ((seq = ASN1_STRING_new()) == NULL || !ASN1_STRING_set(seq, pp, len)) {
256 ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
262 return PKCS7_add_signed_attribute(si,
263 NID_id_smime_aa_signingCertificateV2,
264 V_ASN1_SEQUENCE, seq);
266 ASN1_STRING_free(seq);