crypto/ct/ct_vfy.c

   1 /*
   2  * Written by Rob Stradling (rob@comodo.com) and Stephen Henson
   3  * (steve@openssl.org) for the OpenSSL project 2014.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 2014 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    licensing@OpenSSL.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58
  59 #include <string.h>
  60
  61 #include <openssl/ct.h>
  62 #include <openssl/err.h>
  63 #include <openssl/evp.h>
  64 #include <openssl/x509.h>
  65
  66 #include "ct_locl.h"
  67
  68 #define n2s(c,s)        ((s=(((unsigned int)((c)[0]))<< 8)| \
  69                             (((unsigned int)((c)[1]))    )),c+=2)
  70
  71 #define s2n(s,c)        ((c[0]=(unsigned char)(((s)>> 8)&0xff), \
  72                           c[1]=(unsigned char)(((s)    )&0xff)),c+=2)
  73
  74 #define l2n3(l,c)       ((c[0]=(unsigned char)(((l)>>16)&0xff), \
  75                           c[1]=(unsigned char)(((l)>> 8)&0xff), \
  76                           c[2]=(unsigned char)(((l)    )&0xff)),c+=3)
  77
  78 #define n2l8(c,l)       (l =((uint64_t)(*((c)++)))<<56, \
  79                          l|=((uint64_t)(*((c)++)))<<48, \
  80                          l|=((uint64_t)(*((c)++)))<<40, \
  81                          l|=((uint64_t)(*((c)++)))<<32, \
  82                          l|=((uint64_t)(*((c)++)))<<24, \
  83                          l|=((uint64_t)(*((c)++)))<<16, \
  84                          l|=((uint64_t)(*((c)++)))<< 8, \
  85                          l|=((uint64_t)(*((c)++))))
  86
  87 #define l2n8(l,c)       (*((c)++)=(unsigned char)(((l)>>56)&0xff), \
  88                          *((c)++)=(unsigned char)(((l)>>48)&0xff), \
  89                          *((c)++)=(unsigned char)(((l)>>40)&0xff), \
  90                          *((c)++)=(unsigned char)(((l)>>32)&0xff), \
  91                          *((c)++)=(unsigned char)(((l)>>24)&0xff), \
  92                          *((c)++)=(unsigned char)(((l)>>16)&0xff), \
  93                          *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
  94                          *((c)++)=(unsigned char)(((l)    )&0xff))
  95
  96 typedef enum sct_signature_type_t {
  97     SIGNATURE_TYPE_NOT_SET = -1,
  98     SIGNATURE_TYPE_CERT_TIMESTAMP,
  99     SIGNATURE_TYPE_TREE_HASH
 100 } SCT_SIGNATURE_TYPE;
 101
 102 /*
 103  * Update encoding for SCT signature verification/generation to supplied
 104  * EVP_MD_CTX.
 105  */
 106 static int sct_ctx_update(EVP_MD_CTX *ctx, const SCT_CTX *sctx, const SCT *sct)
 107 {
 108     unsigned char tmpbuf[12];
 109     unsigned char *p, *der;
 110     size_t derlen;
 111     /*+
 112      * digitally-signed struct {
 113      *   (1 byte) Version sct_version;
 114      *   (1 byte) SignatureType signature_type = certificate_timestamp;
 115      *   (8 bytes) uint64 timestamp;
 116      *   (2 bytes) LogEntryType entry_type;
 117      *   (? bytes) select(entry_type) {
 118      *     case x509_entry: ASN.1Cert;
 119      *     case precert_entry: PreCert;
 120      *   } signed_entry;
 121      *   (2 bytes + sct->ext_len) CtExtensions extensions;
 122      * }
 123      */
 124     if (sct->entry_type == CT_LOG_ENTRY_TYPE_NOT_SET)
 125         return 0;
 126     if (sct->entry_type == CT_LOG_ENTRY_TYPE_PRECERT && sctx->ihash == NULL)
 127         return 0;
 128
 129     p = tmpbuf;
 130     *p++ = sct->version;
 131     *p++ = SIGNATURE_TYPE_CERT_TIMESTAMP;
 132     l2n8(sct->timestamp, p);
 133     s2n(sct->entry_type, p);
 134
 135     if (!EVP_DigestUpdate(ctx, tmpbuf, p - tmpbuf))
 136         return 0;
 137
 138     if (sct->entry_type == CT_LOG_ENTRY_TYPE_X509) {
 139         der = sctx->certder;
 140         derlen = sctx->certderlen;
 141     } else {
 142         if (!EVP_DigestUpdate(ctx, sctx->ihash, sctx->ihashlen))
 143             return 0;
 144         der = sctx->preder;
 145         derlen = sctx->prederlen;
 146     }
 147
 148     /* If no encoding available, fatal error */
 149     if (der == NULL)
 150         return 0;
 151
 152     /* Include length first */
 153     p = tmpbuf;
 154     l2n3(derlen, p);
 155
 156     if (!EVP_DigestUpdate(ctx, tmpbuf, 3))
 157         return 0;
 158     if (!EVP_DigestUpdate(ctx, der, derlen))
 159         return 0;
 160
 161     /* Add any extensions */
 162     p = tmpbuf;
 163     s2n(sct->ext_len, p);
 164     if (!EVP_DigestUpdate(ctx, tmpbuf, 2))
 165         return 0;
 166
 167     if (sct->ext_len && !EVP_DigestUpdate(ctx, sct->ext, sct->ext_len))
 168         return 0;
 169
 170     return 1;
 171 }
 172
 173 int SCT_verify(const SCT_CTX *sctx, const SCT *sct)
 174 {
 175     EVP_MD_CTX *ctx = NULL;
 176     int ret = -1;
 177
 178     if (!SCT_is_complete(sct) || sctx->pkey == NULL ||
 179         sct->entry_type == CT_LOG_ENTRY_TYPE_NOT_SET ||
 180         (sct->entry_type == CT_LOG_ENTRY_TYPE_PRECERT && sctx->ihash == NULL)) {
 181         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_NOT_SET);
 182         return -1;
 183     }
 184     if (sct->version != SCT_VERSION_V1) {
 185         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_UNSUPPORTED_VERSION);
 186         return 0;
 187     }
 188     if (sct->log_id_len != sctx->pkeyhashlen ||
 189         memcmp(sct->log_id, sctx->pkeyhash, sctx->pkeyhashlen) != 0) {
 190         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_LOG_ID_MISMATCH);
 191         return 0;
 192     }
 193
 194     ctx = EVP_MD_CTX_new();
 195     if (ctx == NULL)
 196         goto end;
 197
 198     if (!EVP_DigestVerifyInit(ctx, NULL, EVP_sha256(), NULL, sctx->pkey))
 199         goto end;
 200
 201     if (!sct_ctx_update(ctx, sctx, sct))
 202         goto end;
 203
 204     /* Verify signature */
 205     ret = EVP_DigestVerifyFinal(ctx, sct->sig, sct->sig_len);
 206     /* If ret < 0 some other error: fall through without setting error */
 207     if (ret == 0)
 208         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_INVALID_SIGNATURE);
 209
 210 end:
 211     EVP_MD_CTX_free(ctx);
 212     return ret;
 213 }
 214
 215 int SCT_verify_v1(SCT *sct, X509 *cert, X509 *preissuer,
 216                   X509_PUBKEY *log_pubkey, X509 *issuer_cert)
 217 {
 218     int ret = 0;
 219     SCT_CTX *sctx = NULL;
 220
 221     if (!SCT_is_complete(sct)) {
 222         CTerr(CT_F_SCT_VERIFY_V1, CT_R_SCT_NOT_SET);
 223         return -1;
 224     }
 225
 226     if (sct->version != 0) {
 227         CTerr(CT_F_SCT_VERIFY_V1, CT_R_SCT_UNSUPPORTED_VERSION);
 228         return 0;
 229     }
 230
 231     sctx = SCT_CTX_new();
 232     if (sctx == NULL)
 233         goto done;
 234
 235     ret = SCT_CTX_set1_pubkey(sctx, log_pubkey);
 236     if (ret <= 0)
 237         goto done;
 238
 239     ret = SCT_CTX_set1_cert(sctx, cert, preissuer);
 240     if (ret <= 0)
 241         goto done;
 242
 243     if (sct->entry_type == CT_LOG_ENTRY_TYPE_PRECERT) {
 244         ret = SCT_CTX_set1_issuer(sctx, issuer_cert);
 245         if (ret <= 0)
 246             goto done;
 247     }
 248
 249     ret = SCT_verify(sctx, sct);
 250
 251 done:
 252     SCT_CTX_free(sctx);
 253     return ret;
 254 }