27f9e23a8d3d75640488c3e2ed5763ce8a785de6
[openssl.git] / 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 }