crypto/ess/ess_lib.c

   1 /*
   2  * Copyright 2019-2020 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 <string.h>
  11 #include <openssl/x509v3.h>
  12 #include <openssl/err.h>
  13 #include <openssl/ess.h>
  14 #include "crypto/ess.h"
  15
  16 DEFINE_STACK_OF(ESS_CERT_ID)
  17 DEFINE_STACK_OF(ESS_CERT_ID_V2)
  18 DEFINE_STACK_OF(GENERAL_NAME)
  19 DEFINE_STACK_OF(X509)
  20
  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 */
  64     if (!X509v3_cache_extensions(cert, NULL, NULL))
  65         return NULL;
  66
  67     if ((cid = ESS_CERT_ID_new()) == NULL)
  68         goto err;
  69     /* TODO(3.0): fetch sha1 algorithm from providers */
  70     if (!X509_digest(cert, EVP_sha1(), cert_sha1, NULL))
  71         goto err;
  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);
  91     if ((cid->issuer_serial->serial =
  92           ASN1_INTEGER_dup(X509_get0_serialNumber(cert))) == NULL)
  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
 165     /* TODO(3.0): fetch sha1 algorithm from providers */
 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_get0_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;
 203
 204     attr = PKCS7_get_signed_attribute(si, NID_id_smime_aa_signingCertificate);
 205     if (attr == NULL)
 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 }
 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)
 343             return -1;
 344         if (cid->hash_alg != NULL)
 345             md = EVP_get_digestbyobj(cid->hash_alg->algorithm);
 346         else
 347             md = EVP_sha256();
 348
 349         /* TODO(3.0): fetch sha1 algorithm from providers */
 350         if (!X509_digest(cert, md, cert_digest, &len))
 351             return -1;
 352
 353         if (cid->hash->length != (int)len)
 354             return -1;
 355
 356         if (memcmp(cid->hash->data, cert_digest, cid->hash->length) == 0) {
 357             const ESS_ISSUER_SERIAL *is = cid->issuer_serial;
 358
 359             if (is == NULL || ess_issuer_serial_cmp(is, cert) == 0)
 360                 return i;
 361         }
 362     }
 363
 364     return -1;
 365 }