| /* |
| * Copyright 2019-2021 The OpenSSL Project Authors. All Rights Reserved. |
| * |
| * Licensed under the Apache License 2.0 (the "License"). You may not use |
| * this file except in compliance with the License. You can obtain a copy |
| * in the file LICENSE in the source distribution or at |
| * https://www.openssl.org/source/license.html |
| */ |
| |
| #include <string.h> |
| #include <openssl/x509v3.h> |
| #include <openssl/err.h> |
| #include <openssl/ess.h> |
| #include "internal/sizes.h" |
| #include "crypto/ess.h" |
| #include "crypto/x509.h" |
| |
| static ESS_CERT_ID *ESS_CERT_ID_new_init(const X509 *cert, |
| int set_issuer_serial); |
| static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg, |
| const X509 *cert, |
| int set_issuer_serial); |
| |
| ESS_SIGNING_CERT *OSSL_ESS_signing_cert_new_init(const X509 *signcert, |
| const STACK_OF(X509) *certs, |
| int set_issuer_serial) |
| { |
| ESS_CERT_ID *cid = NULL; |
| ESS_SIGNING_CERT *sc; |
| int i; |
| |
| if ((sc = ESS_SIGNING_CERT_new()) == NULL) |
| goto err; |
| if (sc->cert_ids == NULL |
| && (sc->cert_ids = sk_ESS_CERT_ID_new_null()) == NULL) |
| goto err; |
| |
| if ((cid = ESS_CERT_ID_new_init(signcert, set_issuer_serial)) == NULL |
| || !sk_ESS_CERT_ID_push(sc->cert_ids, cid)) |
| goto err; |
| for (i = 0; i < sk_X509_num(certs); ++i) { |
| X509 *cert = sk_X509_value(certs, i); |
| |
| if ((cid = ESS_CERT_ID_new_init(cert, 1)) == NULL |
| || !sk_ESS_CERT_ID_push(sc->cert_ids, cid)) |
| goto err; |
| } |
| |
| return sc; |
| err: |
| ESS_SIGNING_CERT_free(sc); |
| ESS_CERT_ID_free(cid); |
| ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE); |
| return NULL; |
| } |
| |
| static ESS_CERT_ID *ESS_CERT_ID_new_init(const X509 *cert, |
| int set_issuer_serial) |
| { |
| ESS_CERT_ID *cid = NULL; |
| GENERAL_NAME *name = NULL; |
| unsigned char cert_sha1[SHA_DIGEST_LENGTH]; |
| |
| if ((cid = ESS_CERT_ID_new()) == NULL) |
| goto err; |
| if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL)) |
| goto err; |
| if (!ASN1_OCTET_STRING_set(cid->hash, cert_sha1, SHA_DIGEST_LENGTH)) |
| goto err; |
| |
| /* Setting the issuer/serial if requested. */ |
| if (!set_issuer_serial) |
| return cid; |
| |
| if (cid->issuer_serial == NULL |
| && (cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL) |
| goto err; |
| if ((name = GENERAL_NAME_new()) == NULL) |
| goto err; |
| name->type = GEN_DIRNAME; |
| if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL) |
| goto err; |
| if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name)) |
| goto err; |
| name = NULL; /* Ownership is lost. */ |
| ASN1_INTEGER_free(cid->issuer_serial->serial); |
| if ((cid->issuer_serial->serial = |
| ASN1_INTEGER_dup(X509_get0_serialNumber(cert))) == NULL) |
| goto err; |
| |
| return cid; |
| err: |
| GENERAL_NAME_free(name); |
| ESS_CERT_ID_free(cid); |
| ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE); |
| return NULL; |
| } |
| |
| ESS_SIGNING_CERT_V2 *OSSL_ESS_signing_cert_v2_new_init(const EVP_MD *hash_alg, |
| const X509 *signcert, |
| const |
| STACK_OF(X509) *certs, |
| int set_issuer_serial) |
| { |
| ESS_CERT_ID_V2 *cid = NULL; |
| ESS_SIGNING_CERT_V2 *sc; |
| int i; |
| |
| if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL) |
| goto err; |
| cid = ESS_CERT_ID_V2_new_init(hash_alg, signcert, set_issuer_serial); |
| if (cid == NULL) |
| goto err; |
| if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid)) |
| goto err; |
| cid = NULL; |
| |
| for (i = 0; i < sk_X509_num(certs); ++i) { |
| X509 *cert = sk_X509_value(certs, i); |
| |
| if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, cert, 1)) == NULL) |
| goto err; |
| if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid)) |
| goto err; |
| cid = NULL; |
| } |
| |
| return sc; |
| err: |
| ESS_SIGNING_CERT_V2_free(sc); |
| ESS_CERT_ID_V2_free(cid); |
| ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE); |
| return NULL; |
| } |
| |
| static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg, |
| const X509 *cert, |
| int set_issuer_serial) |
| { |
| ESS_CERT_ID_V2 *cid; |
| GENERAL_NAME *name = NULL; |
| unsigned char hash[EVP_MAX_MD_SIZE]; |
| unsigned int hash_len = sizeof(hash); |
| X509_ALGOR *alg = NULL; |
| |
| memset(hash, 0, sizeof(hash)); |
| |
| if ((cid = ESS_CERT_ID_V2_new()) == NULL) |
| goto err; |
| |
| if (!EVP_MD_is_a(hash_alg, SN_sha256)) { |
| alg = X509_ALGOR_new(); |
| if (alg == NULL) |
| goto err; |
| X509_ALGOR_set_md(alg, hash_alg); |
| if (alg->algorithm == NULL) |
| goto err; |
| cid->hash_alg = alg; |
| alg = NULL; |
| } else { |
| cid->hash_alg = NULL; |
| } |
| |
| if (!X509_digest(cert, hash_alg, hash, &hash_len)) |
| goto err; |
| |
| if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len)) |
| goto err; |
| |
| if (!set_issuer_serial) |
| return cid; |
| |
| if ((cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL) |
| goto err; |
| if ((name = GENERAL_NAME_new()) == NULL) |
| goto err; |
| name->type = GEN_DIRNAME; |
| if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL) |
| goto err; |
| if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name)) |
| goto err; |
| name = NULL; /* Ownership is lost. */ |
| ASN1_INTEGER_free(cid->issuer_serial->serial); |
| cid->issuer_serial->serial = ASN1_INTEGER_dup(X509_get0_serialNumber(cert)); |
| if (cid->issuer_serial->serial == NULL) |
| goto err; |
| |
| return cid; |
| err: |
| X509_ALGOR_free(alg); |
| GENERAL_NAME_free(name); |
| ESS_CERT_ID_V2_free(cid); |
| ERR_raise(ERR_LIB_ESS, ERR_R_MALLOC_FAILURE); |
| return NULL; |
| } |
| |
| static int ess_issuer_serial_cmp(const ESS_ISSUER_SERIAL *is, const X509 *cert) |
| { |
| GENERAL_NAME *issuer; |
| |
| if (is == NULL || cert == NULL || sk_GENERAL_NAME_num(is->issuer) != 1) |
| return -1; |
| |
| issuer = sk_GENERAL_NAME_value(is->issuer, 0); |
| if (issuer->type != GEN_DIRNAME |
| || X509_NAME_cmp(issuer->d.dirn, X509_get_issuer_name(cert)) != 0) |
| return -1; |
| |
| return ASN1_INTEGER_cmp(is->serial, X509_get0_serialNumber(cert)); |
| } |
| |
| /* |
| * Find the cert in |certs| referenced by |cid| if not NULL, else by |cid_v2|. |
| * The cert must be the first one in |certs| if and only if |index| is 0. |
| * Return 0 on not found, -1 on error, else 1 + the position in |certs|. |
| */ |
| static int find(const ESS_CERT_ID *cid, const ESS_CERT_ID_V2 *cid_v2, |
| int index, const STACK_OF(X509) *certs) |
| { |
| const X509 *cert; |
| EVP_MD *md = NULL; |
| char name[OSSL_MAX_NAME_SIZE]; |
| unsigned char cert_digest[EVP_MAX_MD_SIZE]; |
| unsigned int len, cid_hash_len; |
| const ESS_ISSUER_SERIAL *is; |
| int i; |
| int ret = -1; |
| |
| if (cid == NULL && cid_v2 == NULL) { |
| ERR_raise(ERR_LIB_ESS, ERR_R_PASSED_INVALID_ARGUMENT); |
| return -1; |
| } |
| |
| if (cid != NULL) |
| strcpy(name, "SHA1"); |
| else if (cid_v2->hash_alg == NULL) |
| strcpy(name, "SHA256"); |
| else |
| OBJ_obj2txt(name, sizeof(name), cid_v2->hash_alg->algorithm, 0); |
| |
| (void)ERR_set_mark(); |
| md = EVP_MD_fetch(NULL, name, NULL); |
| |
| if (md == NULL) |
| md = (EVP_MD *)EVP_get_digestbyname(name); |
| |
| if (md == NULL) { |
| (void)ERR_clear_last_mark(); |
| ERR_raise(ERR_LIB_ESS, ESS_R_ESS_DIGEST_ALG_UNKNOWN); |
| goto end; |
| } |
| (void)ERR_pop_to_mark(); |
| |
| for (i = 0; i < sk_X509_num(certs); ++i) { |
| cert = sk_X509_value(certs, i); |
| |
| cid_hash_len = cid != NULL ? cid->hash->length : cid_v2->hash->length; |
| if (!X509_digest(cert, md, cert_digest, &len) |
| || cid_hash_len != len) { |
| ERR_raise(ERR_LIB_ESS, ESS_R_ESS_CERT_DIGEST_ERROR); |
| goto end; |
| } |
| |
| if (memcmp(cid != NULL ? cid->hash->data : cid_v2->hash->data, |
| cert_digest, len) == 0) { |
| is = cid != NULL ? cid->issuer_serial : cid_v2->issuer_serial; |
| /* Well, it's not really required to match the serial numbers. */ |
| if (is == NULL || ess_issuer_serial_cmp(is, cert) == 0) { |
| if ((i == 0) == (index == 0)) { |
| ret = i + 1; |
| goto end; |
| } |
| ERR_raise(ERR_LIB_ESS, ESS_R_ESS_CERT_ID_WRONG_ORDER); |
| goto end; |
| } |
| } |
| } |
| |
| ret = 0; |
| ERR_raise(ERR_LIB_ESS, ESS_R_ESS_CERT_ID_NOT_FOUND); |
| end: |
| EVP_MD_free(md); |
| return ret; |
| } |
| |
| int OSSL_ESS_check_signing_certs(const ESS_SIGNING_CERT *ss, |
| const ESS_SIGNING_CERT_V2 *ssv2, |
| const STACK_OF(X509) *chain, |
| int require_signing_cert) |
| { |
| int n_v1 = ss == NULL ? -1 : sk_ESS_CERT_ID_num(ss->cert_ids); |
| int n_v2 = ssv2 == NULL ? -1 : sk_ESS_CERT_ID_V2_num(ssv2->cert_ids); |
| int i, ret; |
| |
| if (require_signing_cert && ss == NULL && ssv2 == NULL) { |
| ERR_raise(ERR_LIB_CMS, ESS_R_MISSING_SIGNING_CERTIFICATE_ATTRIBUTE); |
| return -1; |
| } |
| if (n_v1 == 0 || n_v2 == 0) { |
| ERR_raise(ERR_LIB_ESS, ESS_R_EMPTY_ESS_CERT_ID_LIST); |
| return -1; |
| } |
| /* If both ss and ssv2 exist, as required evaluate them independently. */ |
| for (i = 0; i < n_v1; i++) { |
| ret = find(sk_ESS_CERT_ID_value(ss->cert_ids, i), NULL, i, chain); |
| if (ret <= 0) |
| return ret; |
| } |
| for (i = 0; i < n_v2; i++) { |
| ret = find(NULL, sk_ESS_CERT_ID_V2_value(ssv2->cert_ids, i), i, chain); |
| if (ret <= 0) |
| return ret; |
| } |
| return 1; |
| } |
