Parse non-v1 SCTs less awkwardly.
[openssl.git] / crypto / x509v3 / v3_scts.c
1 /* v3_scts.c */
2 /* Written by Rob Stradling (rob@comodo.com) for the OpenSSL project 2014.
3  */
4 /* ====================================================================
5  * Copyright (c) 2014 The OpenSSL Project.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer. 
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in
16  *    the documentation and/or other materials provided with the
17  *    distribution.
18  *
19  * 3. All advertising materials mentioning features or use of this
20  *    software must display the following acknowledgment:
21  *    "This product includes software developed by the OpenSSL Project
22  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
23  *
24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
25  *    endorse or promote products derived from this software without
26  *    prior written permission. For written permission, please contact
27  *    licensing@OpenSSL.org.
28  *
29  * 5. Products derived from this software may not be called "OpenSSL"
30  *    nor may "OpenSSL" appear in their names without prior written
31  *    permission of the OpenSSL Project.
32  *
33  * 6. Redistributions of any form whatsoever must retain the following
34  *    acknowledgment:
35  *    "This product includes software developed by the OpenSSL Project
36  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
37  *
38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
49  * OF THE POSSIBILITY OF SUCH DAMAGE.
50  * ====================================================================
51  *
52  * This product includes cryptographic software written by Eric Young
53  * (eay@cryptsoft.com).  This product includes software written by Tim
54  * Hudson (tjh@cryptsoft.com).
55  *
56  */
57
58
59 #include <stdio.h>
60 #include "cryptlib.h"
61 #include <openssl/asn1.h>
62 #include <openssl/x509v3.h>
63 #include <openssl/bn.h>
64 #include "../ssl/ssl_locl.h"
65
66 static int i2r_scts(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *oct, BIO *out, int indent);
67
68 const X509V3_EXT_METHOD v3_ct_scts[] = {
69 { NID_ct_precert_scts, 0, ASN1_ITEM_ref(ASN1_OCTET_STRING),
70 0,0,0,0,
71 0,0,0,0,
72 (X509V3_EXT_I2R)i2r_scts, NULL,
73 NULL},
74
75 { NID_ct_cert_scts, 0, ASN1_ITEM_ref(ASN1_OCTET_STRING),
76 0,0,0,0,
77 0,0,0,0,
78 (X509V3_EXT_I2R)i2r_scts, NULL,
79 NULL},
80 };
81
82 static void tls12_signature_print(BIO *out, const unsigned char *data)
83         {
84         int nid = NID_undef;
85         /* RFC6962 only permits two signature algorithms */
86         if (data[0] == TLSEXT_hash_sha256)
87                 {
88                 if (data[1] == TLSEXT_signature_rsa)
89                         nid = NID_sha256WithRSAEncryption;
90                 else if (data[1] == TLSEXT_signature_ecdsa)
91                         nid = NID_ecdsa_with_SHA256;
92                 }
93         if (nid == NID_undef)
94                 BIO_printf(out, "%02X%02X", data[0], data[1]);
95         else
96                 BIO_printf(out, "%s", OBJ_nid2ln(nid));
97         }
98
99 static void timestamp_print(BIO *out, BN_ULLONG timestamp)
100         {
101         ASN1_GENERALIZEDTIME *gen;
102         char genstr[20];
103         gen = ASN1_GENERALIZEDTIME_new();
104         ASN1_GENERALIZEDTIME_adj(gen, (time_t)0,
105                                         (int)(timestamp / 86400000),
106                                         (timestamp % 86400000) / 1000);
107         /* Note GeneralizedTime from ASN1_GENERALIZETIME_adj is always 15
108          * characters long with a final Z. Update it with fractional seconds.
109          */
110         BIO_snprintf(genstr, sizeof(genstr), "%.14s.%03dZ",
111                                 ASN1_STRING_data(gen),
112                                 (unsigned int)(timestamp % 1000));
113         ASN1_GENERALIZEDTIME_set_string(gen, genstr);
114         ASN1_GENERALIZEDTIME_print(out, gen);
115         ASN1_GENERALIZEDTIME_free(gen);
116         }
117
118 static int i2r_scts(X509V3_EXT_METHOD *method, ASN1_OCTET_STRING *oct,
119                        BIO *out, int indent)
120         {
121         BN_ULLONG timestamp;
122         unsigned char* data = oct->data;
123         unsigned short listlen, sctlen = 0, fieldlen;
124
125         if (oct->length < 2)
126                 return 0;
127         n2s(data, listlen);
128         if (listlen != oct->length - 2)
129                 return 0;
130
131         while (listlen > 0)
132                 {
133                 if (listlen < 2)
134                         return 0;
135                 n2s(data, sctlen);
136                 listlen -= 2;
137
138                 if ((sctlen < 1) || (sctlen > listlen))
139                         return 0;
140                 listlen -= sctlen;
141
142                 BIO_printf(out, "%*sSigned Certificate Timestamp:", indent,
143                            "");
144                 BIO_printf(out, "\n%*sVersion   : ", indent + 4, "");
145
146                 if (*data == 0)         /* SCT v1 */
147                         {
148                         BIO_printf(out, "v1(0)");
149
150                         /* Fixed-length header:
151                          *              struct {
152                          * (1 byte)       Version sct_version;
153                          * (32 bytes)     LogID id;
154                          * (8 bytes)      uint64 timestamp;
155                          * (2 bytes + ?)  CtExtensions extensions;
156                          */
157                         if (sctlen < 43)
158                                 return 0;
159                         sctlen -= 43;
160
161                         BIO_printf(out, "\n%*sLog ID    : ", indent + 4, "");
162                         BIO_hex_string(out, indent + 16, 16, data + 1, 32);
163
164                         data += 33;
165                         n2l8(data, timestamp);
166                         BIO_printf(out, "\n%*sTimestamp : ", indent + 4, "");
167                         timestamp_print(out, timestamp);
168
169                         n2s(data, fieldlen);
170                         if (sctlen < fieldlen)
171                                 return 0;
172                         sctlen -= fieldlen;
173                         BIO_printf(out, "\n%*sExtensions: ", indent + 4, "");
174                         if (fieldlen == 0)
175                                 BIO_printf(out, "none");
176                         else
177                                 BIO_hex_string(out, indent + 16, 16, data,
178                                                fieldlen);
179                         data += fieldlen;
180
181                         /* digitally-signed struct header:
182                          * (1 byte) Hash algorithm
183                          * (1 byte) Signature algorithm
184                          * (2 bytes + ?) Signature
185                          */
186                         if (sctlen < 4)
187                                 return 0;
188                         sctlen -= 4;
189
190                         BIO_printf(out, "\n%*sSignature : ", indent + 4, "");
191                         tls12_signature_print(out, data);
192                         data += 2;
193                         n2s(data, fieldlen);
194                         if (sctlen != fieldlen)
195                                 return 0;
196                         BIO_printf(out, "\n%*s            ", indent + 4, "");
197                         BIO_hex_string(out, indent + 16, 16, data, fieldlen);
198                         data += fieldlen;
199                         }
200                 else                    /* Unknown version */
201                         {
202                         BIO_printf(out, "unknown\n%*s", indent + 16, "");
203                         BIO_hex_string(out, indent + 16, 16, data, sctlen);
204                         data += sctlen;
205                         }
206
207                 if (listlen > 0) BIO_printf(out, "\n");
208                 }
209
210         return 1;
211         }