Pass a temporary pointer to o2i_SCT_signature from SCT_new_from_base64
[openssl.git] / crypto / ct / ct_oct.c
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 #ifdef OPENSSL_NO_CT
11 # error "CT is disabled"
12 #endif
13
14 #include <limits.h>
15 #include <string.h>
16
17 #include <openssl/asn1.h>
18 #include <openssl/buffer.h>
19 #include <openssl/ct.h>
20 #include <openssl/err.h>
21
22 #include "ct_locl.h"
23
24 int o2i_SCT_signature(SCT *sct, const unsigned char **in, size_t len)
25 {
26     size_t siglen;
27     size_t len_remaining = len;
28     const unsigned char *p;
29
30     if (sct->version != SCT_VERSION_V1) {
31         CTerr(CT_F_O2I_SCT_SIGNATURE, CT_R_UNSUPPORTED_VERSION);
32         return -1;
33     }
34     /*
35      * digitally-signed struct header: (1 byte) Hash algorithm (1 byte)
36      * Signature algorithm (2 bytes + ?) Signature
37      *
38      * This explicitly rejects empty signatures: they're invalid for
39      * all supported algorithms.
40      */
41     if (len <= 4) {
42         CTerr(CT_F_O2I_SCT_SIGNATURE, CT_R_SCT_INVALID_SIGNATURE);
43         return -1;
44     }
45
46     p = *in;
47     /* Get hash and signature algorithm */
48     sct->hash_alg = *p++;
49     sct->sig_alg = *p++;
50     if (SCT_get_signature_nid(sct) == NID_undef) {
51         CTerr(CT_F_O2I_SCT_SIGNATURE, CT_R_SCT_INVALID_SIGNATURE);
52         return -1;
53     }
54     /* Retrieve signature and check it is consistent with the buffer length */
55     n2s(p, siglen);
56     len_remaining -= (p - *in);
57     if (siglen > len_remaining) {
58         CTerr(CT_F_O2I_SCT_SIGNATURE, CT_R_SCT_INVALID_SIGNATURE);
59         return -1;
60     }
61
62     if (SCT_set1_signature(sct, p, siglen) != 1)
63         return -1;
64     len_remaining -= siglen;
65     *in = p + siglen;
66
67     return len - len_remaining;
68 }
69
70 SCT *o2i_SCT(SCT **psct, const unsigned char **in, size_t len)
71 {
72     SCT *sct = NULL;
73     const unsigned char *p;
74
75     if (len == 0 || len > MAX_SCT_SIZE) {
76         CTerr(CT_F_O2I_SCT, CT_R_SCT_INVALID);
77         goto err;
78     }
79
80     if ((sct = SCT_new()) == NULL)
81         goto err;
82
83     p = *in;
84
85     sct->version = *p;
86     if (sct->version == SCT_VERSION_V1) {
87         int sig_len;
88         size_t len2;
89         /*-
90          * Fixed-length header:
91          *   struct {
92          *     Version sct_version;     (1 byte)
93          *     log_id id;               (32 bytes)
94          *     uint64 timestamp;        (8 bytes)
95          *     CtExtensions extensions; (2 bytes + ?)
96          *   }
97          */
98         if (len < 43) {
99             CTerr(CT_F_O2I_SCT, CT_R_SCT_INVALID);
100             goto err;
101         }
102         len -= 43;
103         p++;
104         sct->log_id = BUF_memdup(p, CT_V1_HASHLEN);
105         if (sct->log_id == NULL)
106             goto err;
107         sct->log_id_len = CT_V1_HASHLEN;
108         p += CT_V1_HASHLEN;
109
110         n2l8(p, sct->timestamp);
111
112         n2s(p, len2);
113         if (len < len2) {
114             CTerr(CT_F_O2I_SCT, CT_R_SCT_INVALID);
115             goto err;
116         }
117         if (len2 > 0) {
118             sct->ext = BUF_memdup(p, len2);
119             if (sct->ext == NULL)
120                 goto err;
121         }
122         sct->ext_len = len2;
123         p += len2;
124         len -= len2;
125
126         sig_len = o2i_SCT_signature(sct, &p, len);
127         if (sig_len <= 0) {
128             CTerr(CT_F_O2I_SCT, CT_R_SCT_INVALID);
129             goto err;
130         }
131         len -= sig_len;
132         *in = p + len;
133     } else {
134         /* If not V1 just cache encoding */
135         sct->sct = BUF_memdup(p, len);
136         if (sct->sct == NULL)
137             goto err;
138         sct->sct_len = len;
139         *in = p + len;
140     }
141
142     if (psct != NULL) {
143         SCT_free(*psct);
144         *psct = sct;
145     }
146
147     return sct;
148 err:
149     SCT_free(sct);
150     return NULL;
151 }
152
153 int i2o_SCT_signature(const SCT *sct, unsigned char **out)
154 {
155     size_t len;
156     unsigned char *p = NULL;
157
158     if (!SCT_signature_is_complete(sct)) {
159         CTerr(CT_F_I2O_SCT_SIGNATURE, CT_R_SCT_INVALID_SIGNATURE);
160         goto err;
161     }
162
163     if (sct->version != SCT_VERSION_V1) {
164         CTerr(CT_F_I2O_SCT_SIGNATURE, CT_R_UNSUPPORTED_VERSION);
165         goto err;
166     }
167
168     /*
169     * (1 byte) Hash algorithm
170     * (1 byte) Signature algorithm
171     * (2 bytes + ?) Signature
172     */
173     len = 4 + sct->sig_len;
174
175     if (out != NULL) {
176         if (*out != NULL) {
177             p = *out;
178             *out += len;
179         } else {
180             p = OPENSSL_malloc(len);
181             if (p == NULL) {
182                 CTerr(CT_F_I2O_SCT_SIGNATURE, ERR_R_MALLOC_FAILURE);
183                 goto err;
184             }
185             *out = p;
186         }
187
188         *p++ = sct->hash_alg;
189         *p++ = sct->sig_alg;
190         s2n(sct->sig_len, p);
191         memcpy(p, sct->sig, sct->sig_len);
192     }
193
194     return len;
195 err:
196     OPENSSL_free(p);
197     return -1;
198 }
199
200 int i2o_SCT(const SCT *sct, unsigned char **out)
201 {
202     size_t len;
203     unsigned char *p = NULL;
204
205     if (!SCT_is_complete(sct)) {
206         CTerr(CT_F_I2O_SCT, CT_R_SCT_NOT_SET);
207         goto err;
208     }
209     /*
210      * Fixed-length header: struct { (1 byte) Version sct_version; (32 bytes)
211      * log_id id; (8 bytes) uint64 timestamp; (2 bytes + ?) CtExtensions
212      * extensions; (1 byte) Hash algorithm (1 byte) Signature algorithm (2
213      * bytes + ?) Signature
214      */
215     if (sct->version == SCT_VERSION_V1)
216         len = 43 + sct->ext_len + 4 + sct->sig_len;
217     else
218         len = sct->sct_len;
219
220     if (out == NULL)
221         return len;
222
223     if (*out != NULL) {
224         p = *out;
225         *out += len;
226     } else {
227         p = OPENSSL_malloc(len);
228         if (p == NULL) {
229             CTerr(CT_F_I2O_SCT, ERR_R_MALLOC_FAILURE);
230             goto err;
231         }
232         *out = p;
233     }
234
235     if (sct->version == SCT_VERSION_V1) {
236         *p++ = sct->version;
237         memcpy(p, sct->log_id, CT_V1_HASHLEN);
238         p += CT_V1_HASHLEN;
239         l2n8(sct->timestamp, p);
240         s2n(sct->ext_len, p);
241         if (sct->ext_len > 0) {
242             memcpy(p, sct->ext, sct->ext_len);
243             p += sct->ext_len;
244         }
245         if (i2o_SCT_signature(sct, &p) <= 0)
246             goto err;
247     } else {
248         memcpy(p, sct->sct, len);
249     }
250
251     return len;
252 err:
253     OPENSSL_free(p);
254     return -1;
255 }
256
257 void SCT_LIST_free(STACK_OF(SCT) *a)
258 {
259     sk_SCT_pop_free(a, SCT_free);
260 }
261
262 STACK_OF(SCT) *o2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
263                             size_t len)
264 {
265     STACK_OF(SCT) *sk = NULL;
266     size_t list_len, sct_len;
267
268     if (len < 2 || len > MAX_SCT_LIST_SIZE) {
269         CTerr(CT_F_O2I_SCT_LIST, CT_R_SCT_LIST_INVALID);
270         return NULL;
271     }
272
273     n2s(*pp, list_len);
274     if (list_len != len - 2) {
275         CTerr(CT_F_O2I_SCT_LIST, CT_R_SCT_LIST_INVALID);
276         return NULL;
277     }
278
279     if (a == NULL || *a == NULL) {
280         sk = sk_SCT_new_null();
281         if (sk == NULL)
282             return NULL;
283     } else {
284         SCT *sct;
285
286         /* Use the given stack, but empty it first. */
287         sk = *a;
288         while ((sct = sk_SCT_pop(sk)) != NULL)
289             SCT_free(sct);
290     }
291
292     while (list_len > 0) {
293         SCT *sct;
294
295         if (list_len < 2) {
296             CTerr(CT_F_O2I_SCT_LIST, CT_R_SCT_LIST_INVALID);
297             goto err;
298         }
299         n2s(*pp, sct_len);
300         list_len -= 2;
301
302         if (sct_len == 0 || sct_len > list_len) {
303             CTerr(CT_F_O2I_SCT_LIST, CT_R_SCT_LIST_INVALID);
304             goto err;
305         }
306         list_len -= sct_len;
307
308         if ((sct = o2i_SCT(NULL, pp, sct_len)) == NULL)
309             goto err;
310         if (!sk_SCT_push(sk, sct)) {
311             SCT_free(sct);
312             goto err;
313         }
314     }
315
316     if (a != NULL && *a == NULL)
317         *a = sk;
318     return sk;
319
320  err:
321     if (a == NULL || *a == NULL)
322         SCT_LIST_free(sk);
323     return NULL;
324 }
325
326 int i2o_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **pp)
327 {
328     int len, sct_len, i, is_pp_new = 0;
329     size_t len2;
330     unsigned char *p = NULL, *p2;
331
332     if (pp != NULL) {
333         if (*pp == NULL) {
334             if ((len = i2o_SCT_LIST(a, NULL)) == -1) {
335                 CTerr(CT_F_I2O_SCT_LIST, CT_R_SCT_LIST_INVALID);
336                 return -1;
337             }
338             if ((*pp = OPENSSL_malloc(len)) == NULL) {
339                 CTerr(CT_F_I2O_SCT_LIST, ERR_R_MALLOC_FAILURE);
340                 return -1;
341             }
342             is_pp_new = 1;
343         }
344         p = *pp + 2;
345     }
346
347     len2 = 2;
348     for (i = 0; i < sk_SCT_num(a); i++) {
349         if (pp != NULL) {
350             p2 = p;
351             p += 2;
352             if ((sct_len = i2o_SCT(sk_SCT_value(a, i), &p)) == -1)
353                 goto err;
354             s2n(sct_len, p2);
355         } else {
356           if ((sct_len = i2o_SCT(sk_SCT_value(a, i), NULL)) == -1)
357               goto err;
358         }
359         len2 += 2 + sct_len;
360     }
361
362     if (len2 > MAX_SCT_LIST_SIZE)
363         goto err;
364
365     if (pp != NULL) {
366         p = *pp;
367         s2n(len2 - 2, p);
368         if (!is_pp_new)
369             *pp += len2;
370     }
371     return len2;
372
373  err:
374     if (is_pp_new) {
375         OPENSSL_free(*pp);
376         *pp = NULL;
377     }
378     return -1;
379 }
380
381 STACK_OF(SCT) *d2i_SCT_LIST(STACK_OF(SCT) **a, const unsigned char **pp,
382                             long len)
383 {
384     ASN1_OCTET_STRING *oct = NULL;
385     STACK_OF(SCT) *sk = NULL;
386     const unsigned char *p;
387
388     p = *pp;
389     if (d2i_ASN1_OCTET_STRING(&oct, &p, len) == NULL)
390         return NULL;
391
392     p = oct->data;
393     if ((sk = o2i_SCT_LIST(a, &p, oct->length)) != NULL)
394         *pp += len;
395
396     ASN1_OCTET_STRING_free(oct);
397     return sk;
398 }
399
400 int i2d_SCT_LIST(const STACK_OF(SCT) *a, unsigned char **out)
401 {
402     ASN1_OCTET_STRING oct;
403     int len;
404
405     oct.data = NULL;
406     if ((oct.length = i2o_SCT_LIST(a, &oct.data)) == -1)
407         return -1;
408
409     len = i2d_ASN1_OCTET_STRING(&oct, out);
410     OPENSSL_free(oct.data);
411     return len;
412 }