[thirdparty/openssl.git] / crypto / ess / ess_lib.c

/*
 * Copyright 2019-2020 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 "crypto/ess.h"

DEFINE_STACK_OF(ESS_CERT_ID)
DEFINE_STACK_OF(ESS_CERT_ID_V2)
DEFINE_STACK_OF(GENERAL_NAME)
DEFINE_STACK_OF(X509)

static ESS_CERT_ID *ESS_CERT_ID_new_init(X509 *cert, int issuer_needed);
static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg,
                                               X509 *cert, int issuer_needed);

ESS_SIGNING_CERT *ESS_SIGNING_CERT_new_init(X509 *signcert,
                                            STACK_OF(X509) *certs,
                                            int issuer_needed)
{
    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, issuer_needed)) == 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);
    ESSerr(ESS_F_ESS_SIGNING_CERT_NEW_INIT, ERR_R_MALLOC_FAILURE);
    return NULL;
}

static ESS_CERT_ID *ESS_CERT_ID_new_init(X509 *cert, int issuer_needed)
{
    ESS_CERT_ID *cid = NULL;
    GENERAL_NAME *name = NULL;
    unsigned char cert_sha1[SHA_DIGEST_LENGTH];

    /* Call for side-effect of computing hash and caching extensions */
    if (!X509v3_cache_extensions(cert, NULL, NULL))
        return NULL;

    if ((cid = ESS_CERT_ID_new()) == NULL)
        goto err;
    /* TODO(3.0): fetch sha1 algorithm from providers */
    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 (!issuer_needed)
        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_get_serialNumber(cert))) == NULL)
        goto err;

    return cid;
 err:
    GENERAL_NAME_free(name);
    ESS_CERT_ID_free(cid);
    ESSerr(ESS_F_ESS_CERT_ID_NEW_INIT, ERR_R_MALLOC_FAILURE);
    return NULL;
}

ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_new_init(const EVP_MD *hash_alg,
                                                  X509 *signcert,
                                                  STACK_OF(X509) *certs,
                                                  int issuer_needed)
{
    ESS_CERT_ID_V2 *cid = NULL;
    ESS_SIGNING_CERT_V2 *sc;
    int i;

    if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL)
        goto err;
    if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, signcert, issuer_needed)) == 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);
    ESSerr(ESS_F_ESS_SIGNING_CERT_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
    return NULL;
}

static ESS_CERT_ID_V2 *ESS_CERT_ID_V2_new_init(const EVP_MD *hash_alg,
                                               X509 *cert, int issuer_needed)
{
    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 (hash_alg != EVP_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;
    }

    /* TODO(3.0): fetch sha1 algorithm from providers */
    if (!X509_digest(cert, hash_alg, hash, &hash_len))
        goto err;

    if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len))
        goto err;

    if (!issuer_needed)
        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_get_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);
    ESSerr(ESS_F_ESS_CERT_ID_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
    return NULL;
}

ESS_SIGNING_CERT *ESS_SIGNING_CERT_get(PKCS7_SIGNER_INFO *si)
{
    ASN1_TYPE *attr;
    const unsigned char *p;

    attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificate);
    if (attr == NULL)
        return NULL;
    p = attr->value.sequence->data;
    return d2i_ESS_SIGNING_CERT(NULL, &p, attr->value.sequence->length);
}

ESS_SIGNING_CERT_V2 *ESS_SIGNING_CERT_V2_get(PKCS7_SIGNER_INFO *si)
{
    ASN1_TYPE *attr;
    const unsigned char *p;

    attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificateV2);
    if (attr == NULL)
        return NULL;
    p = attr->value.sequence->data;
    return d2i_ESS_SIGNING_CERT_V2(NULL, &p, attr->value.sequence->length);
}

int ESS_SIGNING_CERT_add(PKCS7_SIGNER_INFO *si, ESS_SIGNING_CERT *sc)
{
    ASN1_STRING *seq = NULL;
    unsigned char *p, *pp = NULL;
    int len;

    len = i2d_ESS_SIGNING_CERT(sc, NULL);
    if ((pp = OPENSSL_malloc(len)) == NULL) {
        ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
        goto err;
    }
    p = pp;
    i2d_ESS_SIGNING_CERT(sc, &p);
    if ((seq = ASN1_STRING_new()) == NULL || !ASN1_STRING_set(seq, pp, len)) {
        ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
        goto err;
    }
    OPENSSL_free(pp);
    pp = NULL;
    return PKCS7_add_signed_attribute(si,
                                      NID_id_smime_aa_signingCertificate,
                                      V_ASN1_SEQUENCE, seq);
 err:
    ASN1_STRING_free(seq);
    OPENSSL_free(pp);

    return 0;
}

int ESS_SIGNING_CERT_V2_add(PKCS7_SIGNER_INFO *si,
                            ESS_SIGNING_CERT_V2 *sc)
{
    ASN1_STRING *seq = NULL;
    unsigned char *p, *pp = NULL;
    int len = i2d_ESS_SIGNING_CERT_V2(sc, NULL);

    if ((pp = OPENSSL_malloc(len)) == NULL) {
        ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
        goto err;
    }

    p = pp;
    i2d_ESS_SIGNING_CERT_V2(sc, &p);
    if ((seq = ASN1_STRING_new()) == NULL || !ASN1_STRING_set(seq, pp, len)) {
        ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
        goto err;
    }

    OPENSSL_free(pp);
    pp = NULL;
    return PKCS7_add_signed_attribute(si,
                                      NID_id_smime_aa_signingCertificateV2,
                                      V_ASN1_SEQUENCE, seq);
 err:
    ASN1_STRING_free(seq);
    OPENSSL_free(pp);
    return 0;
}

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));
}

/* Returns < 0 if certificate is not found, certificate index otherwise. */
int ess_find_cert(const STACK_OF(ESS_CERT_ID) *cert_ids, X509 *cert)
{
    int i;
    unsigned char cert_sha1[SHA_DIGEST_LENGTH];

    if (cert_ids == NULL || cert == NULL)
        return -1;

    /* Recompute SHA1 hash of certificate if necessary (side effect). */
    if (!X509v3_cache_extensions(cert, NULL, NULL))
        return -1;

    /* TODO(3.0): fetch sha1 algorithm from providers */
    if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
        return -1;

    /* Look for cert in the cert_ids vector. */
    for (i = 0; i < sk_ESS_CERT_ID_num(cert_ids); ++i) {
        const ESS_CERT_ID *cid = sk_ESS_CERT_ID_value(cert_ids, i);

        if (cid->hash->length == SHA_DIGEST_LENGTH
            && memcmp(cid->hash->data, cert_sha1, SHA_DIGEST_LENGTH) == 0) {
            const ESS_ISSUER_SERIAL *is = cid->issuer_serial;

            if (is == NULL || ess_issuer_serial_cmp(is, cert) == 0)
                return i;
        }
    }

    return -1;
}

/* Returns < 0 if certificate is not found, certificate index otherwise. */
int ess_find_cert_v2(const STACK_OF(ESS_CERT_ID_V2) *cert_ids, const X509 *cert)
{
    int i;
    unsigned char cert_digest[EVP_MAX_MD_SIZE];
    unsigned int len;

    /* Look for cert in the cert_ids vector. */
    for (i = 0; i < sk_ESS_CERT_ID_V2_num(cert_ids); ++i) {
        const ESS_CERT_ID_V2 *cid = sk_ESS_CERT_ID_V2_value(cert_ids, i);
        const EVP_MD *md;

        if (cid != NULL && cid->hash_alg != NULL)
            md = EVP_get_digestbyobj(cid->hash_alg->algorithm);
        else
            md = EVP_sha256();

        /* TODO(3.0): fetch sha1 algorithm from providers */
        if (!X509_digest(cert, md, cert_digest, &len))
            return -1;

        if (cid->hash->length != (int)len)
            return -1;

        if (memcmp(cid->hash->data, cert_digest, cid->hash->length) == 0) {
            const ESS_ISSUER_SERIAL *is = cid->issuer_serial;

            if (is == NULL || ess_issuer_serial_cmp(is, cert) == 0)
                return i;
        }
    }

    return -1;
}
Commit	Line	Data
e85d19c6	1	/*
7e06a675	2	* Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
e85d19c6 AI	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 <string.h>
	11	#include <openssl/x509v3.h>
	12	#include <openssl/err.h>
	13	#include <openssl/ess.h>
25f2138b	14	#include "crypto/ess.h"
e85d19c6	15
852c2ed2 RS	16	DEFINE_STACK_OF(ESS_CERT_ID)
852c2ed2 RS	17	DEFINE_STACK_OF(ESS_CERT_ID_V2)
852c2ed2	18	DEFINE_STACK_OF(GENERAL_NAME)
9e3c510b	19	DEFINE_STACK_OF(X509)
852c2ed2	20
e85d19c6 AI	21	static ESS_CERT_ID ESS_CERT_ID_new_init(X509 cert, int issuer_needed);
	22	static ESS_CERT_ID_V2 ESS_CERT_ID_V2_new_init(const EVP_MD hash_alg,
	23	X509 *cert, int issuer_needed);
	24
	25	ESS_SIGNING_CERT ESS_SIGNING_CERT_new_init(X509 signcert,
	26	STACK_OF(X509) *certs,
	27	int issuer_needed)
	28	{
	29	ESS_CERT_ID *cid = NULL;
	30	ESS_SIGNING_CERT *sc;
	31	int i;
	32
	33	if ((sc = ESS_SIGNING_CERT_new()) == NULL)
	34	goto err;
	35	if (sc->cert_ids == NULL
	36	&& (sc->cert_ids = sk_ESS_CERT_ID_new_null()) == NULL)
	37	goto err;
	38
	39	if ((cid = ESS_CERT_ID_new_init(signcert, issuer_needed)) == NULL
	40	\|\| !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
	41	goto err;
	42	for (i = 0; i < sk_X509_num(certs); ++i) {
	43	X509 *cert = sk_X509_value(certs, i);
	44	if ((cid = ESS_CERT_ID_new_init(cert, 1)) == NULL
	45	\|\| !sk_ESS_CERT_ID_push(sc->cert_ids, cid))
	46	goto err;
	47	}
	48
	49	return sc;
	50	err:
	51	ESS_SIGNING_CERT_free(sc);
	52	ESS_CERT_ID_free(cid);
	53	ESSerr(ESS_F_ESS_SIGNING_CERT_NEW_INIT, ERR_R_MALLOC_FAILURE);
	54	return NULL;
	55	}
	56
	57	static ESS_CERT_ID ESS_CERT_ID_new_init(X509 cert, int issuer_needed)
	58	{
	59	ESS_CERT_ID *cid = NULL;
	60	GENERAL_NAME *name = NULL;
	61	unsigned char cert_sha1[SHA_DIGEST_LENGTH];
	62
	63	/* Call for side-effect of computing hash and caching extensions */
9e3c510b F	64	if (!X509v3_cache_extensions(cert, NULL, NULL))
	65	return NULL;
	66
e85d19c6 AI	67	if ((cid = ESS_CERT_ID_new()) == NULL)
e85d19c6 AI	68	goto err;
9e3c510b	69	/* TODO(3.0): fetch sha1 algorithm from providers */
7e06a675 BE	70	if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
7e06a675 BE	71	goto err;
e85d19c6 AI	72	if (!ASN1_OCTET_STRING_set(cid->hash, cert_sha1, SHA_DIGEST_LENGTH))
	73	goto err;
	74
	75	/* Setting the issuer/serial if requested. */
	76	if (!issuer_needed)
	77	return cid;
	78
	79	if (cid->issuer_serial == NULL
	80	&& (cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
	81	goto err;
	82	if ((name = GENERAL_NAME_new()) == NULL)
	83	goto err;
	84	name->type = GEN_DIRNAME;
	85	if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
	86	goto err;
	87	if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
	88	goto err;
	89	name = NULL; /* Ownership is lost. */
	90	ASN1_INTEGER_free(cid->issuer_serial->serial);
9e3c510b F	91	if ((cid->issuer_serial->serial =
9e3c510b F	92	ASN1_INTEGER_dup(X509_get_serialNumber(cert))) == NULL)
e85d19c6 AI	93	goto err;
	94
	95	return cid;
	96	err:
	97	GENERAL_NAME_free(name);
	98	ESS_CERT_ID_free(cid);
	99	ESSerr(ESS_F_ESS_CERT_ID_NEW_INIT, ERR_R_MALLOC_FAILURE);
	100	return NULL;
	101	}
	102
	103	ESS_SIGNING_CERT_V2 ESS_SIGNING_CERT_V2_new_init(const EVP_MD hash_alg,
	104	X509 *signcert,
	105	STACK_OF(X509) *certs,
	106	int issuer_needed)
	107	{
	108	ESS_CERT_ID_V2 *cid = NULL;
	109	ESS_SIGNING_CERT_V2 *sc;
	110	int i;
	111
	112	if ((sc = ESS_SIGNING_CERT_V2_new()) == NULL)
	113	goto err;
	114	if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, signcert, issuer_needed)) == NULL)
	115	goto err;
	116	if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
	117	goto err;
	118	cid = NULL;
	119
	120	for (i = 0; i < sk_X509_num(certs); ++i) {
	121	X509 *cert = sk_X509_value(certs, i);
	122
	123	if ((cid = ESS_CERT_ID_V2_new_init(hash_alg, cert, 1)) == NULL)
	124	goto err;
	125	if (!sk_ESS_CERT_ID_V2_push(sc->cert_ids, cid))
	126	goto err;
	127	cid = NULL;
	128	}
	129
	130	return sc;
	131	err:
	132	ESS_SIGNING_CERT_V2_free(sc);
	133	ESS_CERT_ID_V2_free(cid);
	134	ESSerr(ESS_F_ESS_SIGNING_CERT_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
	135	return NULL;
	136	}
	137
	138	static ESS_CERT_ID_V2 ESS_CERT_ID_V2_new_init(const EVP_MD hash_alg,
	139	X509 *cert, int issuer_needed)
	140	{
	141	ESS_CERT_ID_V2 *cid;
	142	GENERAL_NAME *name = NULL;
	143	unsigned char hash[EVP_MAX_MD_SIZE];
	144	unsigned int hash_len = sizeof(hash);
	145	X509_ALGOR *alg = NULL;
	146
	147	memset(hash, 0, sizeof(hash));
	148
	149	if ((cid = ESS_CERT_ID_V2_new()) == NULL)
	150	goto err;
	151
	152	if (hash_alg != EVP_sha256()) {
	153	alg = X509_ALGOR_new();
	154	if (alg == NULL)
	155	goto err;
	156	X509_ALGOR_set_md(alg, hash_alg);
157	if (alg->algorithm == NULL)
158	goto err;
159	cid->hash_alg = alg;
160	alg = NULL;
161	} else {
162	cid->hash_alg = NULL;
163	}
164
9e3c510b	165	/* TODO(3.0): fetch sha1 algorithm from providers */
e85d19c6 AI	166	if (!X509_digest(cert, hash_alg, hash, &hash_len))
	167	goto err;
	168
	169	if (!ASN1_OCTET_STRING_set(cid->hash, hash, hash_len))
	170	goto err;
	171
	172	if (!issuer_needed)
	173	return cid;
	174
	175	if ((cid->issuer_serial = ESS_ISSUER_SERIAL_new()) == NULL)
	176	goto err;
	177	if ((name = GENERAL_NAME_new()) == NULL)
	178	goto err;
	179	name->type = GEN_DIRNAME;
	180	if ((name->d.dirn = X509_NAME_dup(X509_get_issuer_name(cert))) == NULL)
	181	goto err;
	182	if (!sk_GENERAL_NAME_push(cid->issuer_serial->issuer, name))
	183	goto err;
	184	name = NULL; /* Ownership is lost. */
	185	ASN1_INTEGER_free(cid->issuer_serial->serial);
	186	cid->issuer_serial->serial = ASN1_INTEGER_dup(X509_get_serialNumber(cert));
	187	if (cid->issuer_serial->serial == NULL)
	188	goto err;
	189
	190	return cid;
	191	err:
	192	X509_ALGOR_free(alg);
	193	GENERAL_NAME_free(name);
	194	ESS_CERT_ID_V2_free(cid);
	195	ESSerr(ESS_F_ESS_CERT_ID_V2_NEW_INIT, ERR_R_MALLOC_FAILURE);
	196	return NULL;
	197	}
	198
	199	ESS_SIGNING_CERT ESS_SIGNING_CERT_get(PKCS7_SIGNER_INFO si)
	200	{
	201	ASN1_TYPE *attr;
	202	const unsigned char *p;
9e3c510b	203
e85d19c6	204	attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificate);
9e3c510b	205	if (attr == NULL)
e85d19c6 AI	206	return NULL;
	207	p = attr->value.sequence->data;
	208	return d2i_ESS_SIGNING_CERT(NULL, &p, attr->value.sequence->length);
	209	}
	210
	211	ESS_SIGNING_CERT_V2 ESS_SIGNING_CERT_V2_get(PKCS7_SIGNER_INFO si)
	212	{
	213	ASN1_TYPE *attr;
	214	const unsigned char *p;
	215
	216	attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificateV2);
	217	if (attr == NULL)
	218	return NULL;
	219	p = attr->value.sequence->data;
	220	return d2i_ESS_SIGNING_CERT_V2(NULL, &p, attr->value.sequence->length);
	221	}
	222
	223	int ESS_SIGNING_CERT_add(PKCS7_SIGNER_INFO si, ESS_SIGNING_CERT sc)
	224	{
	225	ASN1_STRING *seq = NULL;
	226	unsigned char p, pp = NULL;
	227	int len;
	228
	229	len = i2d_ESS_SIGNING_CERT(sc, NULL);
	230	if ((pp = OPENSSL_malloc(len)) == NULL) {
	231	ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
	232	goto err;
	233	}
	234	p = pp;
	235	i2d_ESS_SIGNING_CERT(sc, &p);
	236	if ((seq = ASN1_STRING_new()) == NULL \|\| !ASN1_STRING_set(seq, pp, len)) {
	237	ESSerr(ESS_F_ESS_SIGNING_CERT_ADD, ERR_R_MALLOC_FAILURE);
	238	goto err;
	239	}
	240	OPENSSL_free(pp);
	241	pp = NULL;
	242	return PKCS7_add_signed_attribute(si,
	243	NID_id_smime_aa_signingCertificate,
	244	V_ASN1_SEQUENCE, seq);
	245	err:
	246	ASN1_STRING_free(seq);
	247	OPENSSL_free(pp);
	248
	249	return 0;
	250	}
	251
	252	int ESS_SIGNING_CERT_V2_add(PKCS7_SIGNER_INFO *si,
	253	ESS_SIGNING_CERT_V2 *sc)
	254	{
	255	ASN1_STRING *seq = NULL;
	256	unsigned char p, pp = NULL;
	257	int len = i2d_ESS_SIGNING_CERT_V2(sc, NULL);
	258
	259	if ((pp = OPENSSL_malloc(len)) == NULL) {
	260	ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
	261	goto err;
	262	}
	263
	264	p = pp;
	265	i2d_ESS_SIGNING_CERT_V2(sc, &p);
	266	if ((seq = ASN1_STRING_new()) == NULL \|\| !ASN1_STRING_set(seq, pp, len)) {
	267	ESSerr(ESS_F_ESS_SIGNING_CERT_V2_ADD, ERR_R_MALLOC_FAILURE);
	268	goto err;
	269	}
270
271	OPENSSL_free(pp);
272	pp = NULL;
273	return PKCS7_add_signed_attribute(si,
274	NID_id_smime_aa_signingCertificateV2,
275	V_ASN1_SEQUENCE, seq);
276	err:
277	ASN1_STRING_free(seq);
278	OPENSSL_free(pp);
279	return 0;
280	}
9e3c510b F	281
	282	static int ess_issuer_serial_cmp(const ESS_ISSUER_SERIAL is, const X509 cert)
	283	{
	284	GENERAL_NAME *issuer;
	285
	286	if (is == NULL \|\| cert == NULL \|\| sk_GENERAL_NAME_num(is->issuer) != 1)
	287	return -1;
	288
	289	issuer = sk_GENERAL_NAME_value(is->issuer, 0);
	290	if (issuer->type != GEN_DIRNAME
	291	\|\| X509_NAME_cmp(issuer->d.dirn, X509_get_issuer_name(cert)) != 0)
	292	return -1;
	293
	294	return ASN1_INTEGER_cmp(is->serial, X509_get0_serialNumber(cert));
	295	}
	296
	297	/* Returns < 0 if certificate is not found, certificate index otherwise. */
	298	int ess_find_cert(const STACK_OF(ESS_CERT_ID) cert_ids, X509 cert)
	299	{
	300	int i;
	301	unsigned char cert_sha1[SHA_DIGEST_LENGTH];
	302
	303	if (cert_ids == NULL \|\| cert == NULL)
	304	return -1;
	305
	306	/* Recompute SHA1 hash of certificate if necessary (side effect). */
	307	if (!X509v3_cache_extensions(cert, NULL, NULL))
	308	return -1;
	309
	310	/* TODO(3.0): fetch sha1 algorithm from providers */
	311	if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
	312	return -1;
	313
	314	/* Look for cert in the cert_ids vector. */
	315	for (i = 0; i < sk_ESS_CERT_ID_num(cert_ids); ++i) {
	316	const ESS_CERT_ID *cid = sk_ESS_CERT_ID_value(cert_ids, i);
	317
	318	if (cid->hash->length == SHA_DIGEST_LENGTH
	319	&& memcmp(cid->hash->data, cert_sha1, SHA_DIGEST_LENGTH) == 0) {
	320	const ESS_ISSUER_SERIAL *is = cid->issuer_serial;
	321
	322	if (is == NULL \|\| ess_issuer_serial_cmp(is, cert) == 0)
	323	return i;
	324	}
	325	}
	326
	327	return -1;
	328	}
	329
	330	/* Returns < 0 if certificate is not found, certificate index otherwise. */
	331	int ess_find_cert_v2(const STACK_OF(ESS_CERT_ID_V2) cert_ids, const X509 cert)
	332	{
	333	int i;
	334	unsigned char cert_digest[EVP_MAX_MD_SIZE];
	335	unsigned int len;
	336
	337	/* Look for cert in the cert_ids vector. */
	338	for (i = 0; i < sk_ESS_CERT_ID_V2_num(cert_ids); ++i) {
	339	const ESS_CERT_ID_V2 *cid = sk_ESS_CERT_ID_V2_value(cert_ids, i);
	340	const EVP_MD *md;
	341
	342	if (cid != NULL && cid->hash_alg != NULL)
	343	md = EVP_get_digestbyobj(cid->hash_alg->algorithm);
	344	else
345	md = EVP_sha256();
346
347	/* TODO(3.0): fetch sha1 algorithm from providers */
348	if (!X509_digest(cert, md, cert_digest, &len))
349	return -1;
350
351	if (cid->hash->length != (int)len)
352	return -1;
353
354	if (memcmp(cid->hash->data, cert_digest, cid->hash->length) == 0) {
355	const ESS_ISSUER_SERIAL *is = cid->issuer_serial;
356
357	if (is == NULL \|\| ess_issuer_serial_cmp(is, cert) == 0)
358	return i;
359	}
360	}
361
362	return -1;
363	}