Add X509_CHECK_FLAG_NEVER_CHECK_SUBJECT flag
[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 typedef enum sct_signature_type_t {
69     SIGNATURE_TYPE_NOT_SET = -1,
70     SIGNATURE_TYPE_CERT_TIMESTAMP,
71     SIGNATURE_TYPE_TREE_HASH
72 } SCT_SIGNATURE_TYPE;
73
74 int CT_verify_no_bad_scts(const CT_POLICY_EVAL_CTX *ctx,
75                           const STACK_OF(SCT) *scts, void *arg)
76 {
77     int sct_count = scts != NULL ? sk_SCT_num(scts) : 0;
78     int i;
79
80     for (i = 0; i < sct_count; ++i) {
81         SCT *sct = sk_SCT_value(scts, i);
82
83         switch (SCT_get_validation_status(sct)) {
84             case SCT_VALIDATION_STATUS_INVALID:
85                 return 0;
86             case SCT_VALIDATION_STATUS_NOT_SET:
87                 CTerr(CT_F_CT_VERIFY_NO_BAD_SCTS,
88                       CT_R_SCT_VALIDATION_STATUS_NOT_SET);
89                 return -1;
90             default:
91                 /* Ignore other validation statuses. */
92                 break;
93         }
94     }
95
96     return 1;
97 }
98
99 int CT_verify_at_least_one_good_sct(const CT_POLICY_EVAL_CTX *ctx,
100                                     const STACK_OF(SCT) *scts, void *arg)
101 {
102     int sct_count = scts != NULL ? sk_SCT_num(scts) : 0;
103     int valid_scts = 0;
104     int i;
105
106     for (i = 0; i < sct_count; ++i) {
107         SCT *sct = sk_SCT_value(scts, i);
108
109         switch (SCT_get_validation_status(sct)) {
110             case SCT_VALIDATION_STATUS_VALID:
111                 ++valid_scts;
112                 break;
113             case SCT_VALIDATION_STATUS_INVALID:
114                 return 0;
115             case SCT_VALIDATION_STATUS_NOT_SET:
116                 CTerr(CT_F_CT_VERIFY_AT_LEAST_ONE_GOOD_SCT,
117                       CT_R_SCT_VALIDATION_STATUS_NOT_SET);
118                 return -1;
119             default:
120                 /* Ignore other validation statuses. */
121                 break;
122         }
123     }
124
125     if (valid_scts == 0) {
126         CTerr(CT_F_CT_VERIFY_AT_LEAST_ONE_GOOD_SCT, CT_R_NOT_ENOUGH_SCTS);
127         return 0;
128     }
129
130     return 1;
131 }
132
133 /*
134  * Update encoding for SCT signature verification/generation to supplied
135  * EVP_MD_CTX.
136  */
137 static int sct_ctx_update(EVP_MD_CTX *ctx, const SCT_CTX *sctx, const SCT *sct)
138 {
139     unsigned char tmpbuf[12];
140     unsigned char *p, *der;
141     size_t derlen;
142     /*+
143      * digitally-signed struct {
144      *   (1 byte) Version sct_version;
145      *   (1 byte) SignatureType signature_type = certificate_timestamp;
146      *   (8 bytes) uint64 timestamp;
147      *   (2 bytes) LogEntryType entry_type;
148      *   (? bytes) select(entry_type) {
149      *     case x509_entry: ASN.1Cert;
150      *     case precert_entry: PreCert;
151      *   } signed_entry;
152      *   (2 bytes + sct->ext_len) CtExtensions extensions;
153      * }
154      */
155     if (sct->entry_type == CT_LOG_ENTRY_TYPE_NOT_SET)
156         return 0;
157     if (sct->entry_type == CT_LOG_ENTRY_TYPE_PRECERT && sctx->ihash == NULL)
158         return 0;
159
160     p = tmpbuf;
161     *p++ = sct->version;
162     *p++ = SIGNATURE_TYPE_CERT_TIMESTAMP;
163     l2n8(sct->timestamp, p);
164     s2n(sct->entry_type, p);
165
166     if (!EVP_DigestUpdate(ctx, tmpbuf, p - tmpbuf))
167         return 0;
168
169     if (sct->entry_type == CT_LOG_ENTRY_TYPE_X509) {
170         der = sctx->certder;
171         derlen = sctx->certderlen;
172     } else {
173         if (!EVP_DigestUpdate(ctx, sctx->ihash, sctx->ihashlen))
174             return 0;
175         der = sctx->preder;
176         derlen = sctx->prederlen;
177     }
178
179     /* If no encoding available, fatal error */
180     if (der == NULL)
181         return 0;
182
183     /* Include length first */
184     p = tmpbuf;
185     l2n3(derlen, p);
186
187     if (!EVP_DigestUpdate(ctx, tmpbuf, 3))
188         return 0;
189     if (!EVP_DigestUpdate(ctx, der, derlen))
190         return 0;
191
192     /* Add any extensions */
193     p = tmpbuf;
194     s2n(sct->ext_len, p);
195     if (!EVP_DigestUpdate(ctx, tmpbuf, 2))
196         return 0;
197
198     if (sct->ext_len && !EVP_DigestUpdate(ctx, sct->ext, sct->ext_len))
199         return 0;
200
201     return 1;
202 }
203
204 int SCT_verify(const SCT_CTX *sctx, const SCT *sct)
205 {
206     EVP_MD_CTX *ctx = NULL;
207     int ret = 0;
208
209     if (!SCT_is_complete(sct) || sctx->pkey == NULL ||
210         sct->entry_type == CT_LOG_ENTRY_TYPE_NOT_SET ||
211         (sct->entry_type == CT_LOG_ENTRY_TYPE_PRECERT && sctx->ihash == NULL)) {
212         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_NOT_SET);
213         return 0;
214     }
215     if (sct->version != SCT_VERSION_V1) {
216         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_UNSUPPORTED_VERSION);
217         return 0;
218     }
219     if (sct->log_id_len != sctx->pkeyhashlen ||
220         memcmp(sct->log_id, sctx->pkeyhash, sctx->pkeyhashlen) != 0) {
221         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_LOG_ID_MISMATCH);
222         return 0;
223     }
224
225     ctx = EVP_MD_CTX_new();
226     if (ctx == NULL)
227         goto end;
228
229     if (!EVP_DigestVerifyInit(ctx, NULL, EVP_sha256(), NULL, sctx->pkey))
230         goto end;
231
232     if (!sct_ctx_update(ctx, sctx, sct))
233         goto end;
234
235     /* Verify signature */
236     ret = EVP_DigestVerifyFinal(ctx, sct->sig, sct->sig_len);
237     /* If ret < 0 some other error: fall through without setting error */
238     if (ret == 0)
239         CTerr(CT_F_SCT_VERIFY, CT_R_SCT_INVALID_SIGNATURE);
240
241 end:
242     EVP_MD_CTX_free(ctx);
243     return ret;
244 }
245
246 int SCT_verify_v1(SCT *sct, X509 *cert, X509 *preissuer,
247                   X509_PUBKEY *log_pubkey, X509 *issuer_cert)
248 {
249     int ret = 0;
250     SCT_CTX *sctx = NULL;
251
252     if (!SCT_is_complete(sct)) {
253         CTerr(CT_F_SCT_VERIFY_V1, CT_R_SCT_NOT_SET);
254         return 0;
255     }
256
257     if (sct->version != 0) {
258         CTerr(CT_F_SCT_VERIFY_V1, CT_R_SCT_UNSUPPORTED_VERSION);
259         return 0;
260     }
261
262     sctx = SCT_CTX_new();
263     if (sctx == NULL)
264         goto done;
265
266     if (!SCT_CTX_set1_pubkey(sctx, log_pubkey))
267         goto done;
268
269     if (!SCT_CTX_set1_cert(sctx, cert, preissuer))
270         goto done;
271
272     if (sct->entry_type == CT_LOG_ENTRY_TYPE_PRECERT &&
273         !SCT_CTX_set1_issuer(sctx, issuer_cert))
274         goto done;
275
276     ret = SCT_verify(sctx, sct);
277 done:
278     SCT_CTX_free(sctx);
279     return ret;
280 }