openssl fipsinstall: fix cosmetic wart
[openssl.git] / crypto / packet.c
1 /*
2  * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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 #include "internal/cryptlib.h"
11 #include "internal/packet.h"
12 #include <openssl/sslerr.h>
13
14 #define DEFAULT_BUF_SIZE    256
15
16 int WPACKET_allocate_bytes(WPACKET *pkt, size_t len, unsigned char **allocbytes)
17 {
18     if (!WPACKET_reserve_bytes(pkt, len, allocbytes))
19         return 0;
20
21     pkt->written += len;
22     pkt->curr += len;
23     return 1;
24 }
25
26 int WPACKET_sub_allocate_bytes__(WPACKET *pkt, size_t len,
27                                  unsigned char **allocbytes, size_t lenbytes)
28 {
29     if (!WPACKET_start_sub_packet_len__(pkt, lenbytes)
30             || !WPACKET_allocate_bytes(pkt, len, allocbytes)
31             || !WPACKET_close(pkt))
32         return 0;
33
34     return 1;
35 }
36
37 #define GETBUF(p)   (((p)->staticbuf != NULL) \
38                      ? (p)->staticbuf \
39                      : ((p)->buf != NULL \
40                         ? (unsigned char *)(p)->buf->data \
41                         : NULL))
42
43 int WPACKET_reserve_bytes(WPACKET *pkt, size_t len, unsigned char **allocbytes)
44 {
45     /* Internal API, so should not fail */
46     if (!ossl_assert(pkt->subs != NULL && len != 0))
47         return 0;
48
49     if (pkt->maxsize - pkt->written < len)
50         return 0;
51
52     if (pkt->buf != NULL && (pkt->buf->length - pkt->written < len)) {
53         size_t newlen;
54         size_t reflen;
55
56         reflen = (len > pkt->buf->length) ? len : pkt->buf->length;
57
58         if (reflen > SIZE_MAX / 2) {
59             newlen = SIZE_MAX;
60         } else {
61             newlen = reflen * 2;
62             if (newlen < DEFAULT_BUF_SIZE)
63                 newlen = DEFAULT_BUF_SIZE;
64         }
65         if (BUF_MEM_grow(pkt->buf, newlen) == 0)
66             return 0;
67     }
68     if (allocbytes != NULL) {
69         *allocbytes = WPACKET_get_curr(pkt);
70         if (pkt->endfirst && *allocbytes != NULL)
71             *allocbytes -= len;
72     }
73
74     return 1;
75 }
76
77 int WPACKET_sub_reserve_bytes__(WPACKET *pkt, size_t len,
78                                 unsigned char **allocbytes, size_t lenbytes)
79 {
80     if (pkt->endfirst && lenbytes > 0)
81         return 0;
82
83     if (!WPACKET_reserve_bytes(pkt, lenbytes + len, allocbytes))
84         return 0;
85
86     if (*allocbytes != NULL)
87         *allocbytes += lenbytes;
88
89     return 1;
90 }
91
92 static size_t maxmaxsize(size_t lenbytes)
93 {
94     if (lenbytes >= sizeof(size_t) || lenbytes == 0)
95         return SIZE_MAX;
96
97     return ((size_t)1 << (lenbytes * 8)) - 1 + lenbytes;
98 }
99
100 static int wpacket_intern_init_len(WPACKET *pkt, size_t lenbytes)
101 {
102     unsigned char *lenchars;
103
104     pkt->curr = 0;
105     pkt->written = 0;
106
107     if ((pkt->subs = OPENSSL_zalloc(sizeof(*pkt->subs))) == NULL) {
108         SSLerr(SSL_F_WPACKET_INTERN_INIT_LEN, ERR_R_MALLOC_FAILURE);
109         return 0;
110     }
111
112     if (lenbytes == 0)
113         return 1;
114
115     pkt->subs->pwritten = lenbytes;
116     pkt->subs->lenbytes = lenbytes;
117
118     if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars)) {
119         OPENSSL_free(pkt->subs);
120         pkt->subs = NULL;
121         return 0;
122     }
123     pkt->subs->packet_len = 0;
124
125     return 1;
126 }
127
128 int WPACKET_init_static_len(WPACKET *pkt, unsigned char *buf, size_t len,
129                             size_t lenbytes)
130 {
131     size_t max = maxmaxsize(lenbytes);
132
133     /* Internal API, so should not fail */
134     if (!ossl_assert(buf != NULL && len > 0))
135         return 0;
136
137     pkt->staticbuf = buf;
138     pkt->buf = NULL;
139     pkt->maxsize = (max < len) ? max : len;
140     pkt->endfirst = 0;
141
142     return wpacket_intern_init_len(pkt, lenbytes);
143 }
144
145 int WPACKET_init_der(WPACKET *pkt, unsigned char *buf, size_t len)
146 {
147     /* Internal API, so should not fail */
148     if (!ossl_assert(buf != NULL && len > 0))
149         return 0;
150
151     pkt->staticbuf = buf;
152     pkt->buf = NULL;
153     pkt->maxsize = len;
154     pkt->endfirst = 1;
155
156     return wpacket_intern_init_len(pkt, 0);
157 }
158
159 int WPACKET_init_len(WPACKET *pkt, BUF_MEM *buf, size_t lenbytes)
160 {
161     /* Internal API, so should not fail */
162     if (!ossl_assert(buf != NULL))
163         return 0;
164
165     pkt->staticbuf = NULL;
166     pkt->buf = buf;
167     pkt->maxsize = maxmaxsize(lenbytes);
168     pkt->endfirst = 0;
169
170     return wpacket_intern_init_len(pkt, lenbytes);
171 }
172
173 int WPACKET_init(WPACKET *pkt, BUF_MEM *buf)
174 {
175     return WPACKET_init_len(pkt, buf, 0);
176 }
177
178 int WPACKET_init_null(WPACKET *pkt, size_t lenbytes)
179 {
180     pkt->staticbuf = NULL;
181     pkt->buf = NULL;
182     pkt->maxsize = maxmaxsize(lenbytes);
183     pkt->endfirst = 0;
184
185     return wpacket_intern_init_len(pkt, 0);
186 }
187
188 int WPACKET_init_null_der(WPACKET *pkt)
189 {
190     pkt->staticbuf = NULL;
191     pkt->buf = NULL;
192     pkt->maxsize = SIZE_MAX;
193     pkt->endfirst = 1;
194
195     return wpacket_intern_init_len(pkt, 0);
196 }
197
198 int WPACKET_set_flags(WPACKET *pkt, unsigned int flags)
199 {
200     /* Internal API, so should not fail */
201     if (!ossl_assert(pkt->subs != NULL))
202         return 0;
203
204     pkt->subs->flags = flags;
205
206     return 1;
207 }
208
209 /* Store the |value| of length |len| at location |data| */
210 static int put_value(unsigned char *data, size_t value, size_t len)
211 {
212     if (data == NULL)
213         return 1;
214
215     for (data += len - 1; len > 0; len--) {
216         *data = (unsigned char)(value & 0xff);
217         data--;
218         value >>= 8;
219     }
220
221     /* Check whether we could fit the value in the assigned number of bytes */
222     if (value > 0)
223         return 0;
224
225     return 1;
226 }
227
228
229 /*
230  * Internal helper function used by WPACKET_close(), WPACKET_finish() and
231  * WPACKET_fill_lengths() to close a sub-packet and write out its length if
232  * necessary. If |doclose| is 0 then it goes through the motions of closing
233  * (i.e. it fills in all the lengths), but doesn't actually close anything.
234  */
235 static int wpacket_intern_close(WPACKET *pkt, WPACKET_SUB *sub, int doclose)
236 {
237     size_t packlen = pkt->written - sub->pwritten;
238
239     if (packlen == 0
240             && (sub->flags & WPACKET_FLAGS_NON_ZERO_LENGTH) != 0)
241         return 0;
242
243     if (packlen == 0
244             && sub->flags & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
245         /* We can't handle this case. Return an error */
246         if (!doclose)
247             return 0;
248
249         /* Deallocate any bytes allocated for the length of the WPACKET */
250         if ((pkt->curr - sub->lenbytes) == sub->packet_len) {
251             pkt->written -= sub->lenbytes;
252             pkt->curr -= sub->lenbytes;
253         }
254
255         /* Don't write out the packet length */
256         sub->packet_len = 0;
257         sub->lenbytes = 0;
258     }
259
260     /* Write out the WPACKET length if needed */
261     if (sub->lenbytes > 0) {
262         unsigned char *buf = GETBUF(pkt);
263
264         if (buf != NULL
265                 && !put_value(&buf[sub->packet_len], packlen,
266                               sub->lenbytes))
267             return 0;
268     } else if (pkt->endfirst && sub->parent != NULL
269                && (packlen != 0
270                    || (sub->flags
271                        & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) == 0)) {
272         size_t tmplen = packlen;
273         size_t numlenbytes = 1;
274
275         while ((tmplen = tmplen >> 8) > 0)
276             numlenbytes++;
277         if (!WPACKET_put_bytes__(pkt, packlen, numlenbytes))
278             return 0;
279         if (packlen > 0x7f) {
280             numlenbytes |= 0x80;
281             if (!WPACKET_put_bytes_u8(pkt, numlenbytes))
282                 return 0;
283         }
284     }
285
286     if (doclose) {
287         pkt->subs = sub->parent;
288         OPENSSL_free(sub);
289     }
290
291     return 1;
292 }
293
294 int WPACKET_fill_lengths(WPACKET *pkt)
295 {
296     WPACKET_SUB *sub;
297
298     if (!ossl_assert(pkt->subs != NULL))
299         return 0;
300
301     for (sub = pkt->subs; sub != NULL; sub = sub->parent) {
302         if (!wpacket_intern_close(pkt, sub, 0))
303             return 0;
304     }
305
306     return 1;
307 }
308
309 int WPACKET_close(WPACKET *pkt)
310 {
311     /*
312      * Internal API, so should not fail - but we do negative testing of this
313      * so no assert (otherwise the tests fail)
314      */
315     if (pkt->subs == NULL || pkt->subs->parent == NULL)
316         return 0;
317
318     return wpacket_intern_close(pkt, pkt->subs, 1);
319 }
320
321 int WPACKET_finish(WPACKET *pkt)
322 {
323     int ret;
324
325     /*
326      * Internal API, so should not fail - but we do negative testing of this
327      * so no assert (otherwise the tests fail)
328      */
329     if (pkt->subs == NULL || pkt->subs->parent != NULL)
330         return 0;
331
332     ret = wpacket_intern_close(pkt, pkt->subs, 1);
333     if (ret) {
334         OPENSSL_free(pkt->subs);
335         pkt->subs = NULL;
336     }
337
338     return ret;
339 }
340
341 int WPACKET_start_sub_packet_len__(WPACKET *pkt, size_t lenbytes)
342 {
343     WPACKET_SUB *sub;
344     unsigned char *lenchars;
345
346     /* Internal API, so should not fail */
347     if (!ossl_assert(pkt->subs != NULL))
348         return 0;
349
350     /* We don't support lenbytes greater than 0 when doing endfirst writing */
351     if (lenbytes > 0 && pkt->endfirst)
352         return 0;
353
354     if ((sub = OPENSSL_zalloc(sizeof(*sub))) == NULL) {
355         SSLerr(SSL_F_WPACKET_START_SUB_PACKET_LEN__, ERR_R_MALLOC_FAILURE);
356         return 0;
357     }
358
359     sub->parent = pkt->subs;
360     pkt->subs = sub;
361     sub->pwritten = pkt->written + lenbytes;
362     sub->lenbytes = lenbytes;
363
364     if (lenbytes == 0) {
365         sub->packet_len = 0;
366         return 1;
367     }
368
369     sub->packet_len = pkt->written;
370
371     if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars))
372         return 0;
373
374     return 1;
375 }
376
377 int WPACKET_start_sub_packet(WPACKET *pkt)
378 {
379     return WPACKET_start_sub_packet_len__(pkt, 0);
380 }
381
382 int WPACKET_put_bytes__(WPACKET *pkt, unsigned int val, size_t size)
383 {
384     unsigned char *data;
385
386     /* Internal API, so should not fail */
387     if (!ossl_assert(size <= sizeof(unsigned int))
388             || !WPACKET_allocate_bytes(pkt, size, &data)
389             || !put_value(data, val, size))
390         return 0;
391
392     return 1;
393 }
394
395 int WPACKET_set_max_size(WPACKET *pkt, size_t maxsize)
396 {
397     WPACKET_SUB *sub;
398     size_t lenbytes;
399
400     /* Internal API, so should not fail */
401     if (!ossl_assert(pkt->subs != NULL))
402         return 0;
403
404     /* Find the WPACKET_SUB for the top level */
405     for (sub = pkt->subs; sub->parent != NULL; sub = sub->parent)
406         continue;
407
408     lenbytes = sub->lenbytes;
409     if (lenbytes == 0)
410         lenbytes = sizeof(pkt->maxsize);
411
412     if (maxmaxsize(lenbytes) < maxsize || maxsize < pkt->written)
413         return 0;
414
415     pkt->maxsize = maxsize;
416
417     return 1;
418 }
419
420 int WPACKET_memset(WPACKET *pkt, int ch, size_t len)
421 {
422     unsigned char *dest;
423
424     if (len == 0)
425         return 1;
426
427     if (!WPACKET_allocate_bytes(pkt, len, &dest))
428         return 0;
429
430     if (dest != NULL)
431         memset(dest, ch, len);
432
433     return 1;
434 }
435
436 int WPACKET_memcpy(WPACKET *pkt, const void *src, size_t len)
437 {
438     unsigned char *dest;
439
440     if (len == 0)
441         return 1;
442
443     if (!WPACKET_allocate_bytes(pkt, len, &dest))
444         return 0;
445
446     if (dest != NULL)
447         memcpy(dest, src, len);
448
449     return 1;
450 }
451
452 int WPACKET_sub_memcpy__(WPACKET *pkt, const void *src, size_t len,
453                          size_t lenbytes)
454 {
455     if (!WPACKET_start_sub_packet_len__(pkt, lenbytes)
456             || !WPACKET_memcpy(pkt, src, len)
457             || !WPACKET_close(pkt))
458         return 0;
459
460     return 1;
461 }
462
463 int WPACKET_get_total_written(WPACKET *pkt, size_t *written)
464 {
465     /* Internal API, so should not fail */
466     if (!ossl_assert(written != NULL))
467         return 0;
468
469     *written = pkt->written;
470
471     return 1;
472 }
473
474 int WPACKET_get_length(WPACKET *pkt, size_t *len)
475 {
476     /* Internal API, so should not fail */
477     if (!ossl_assert(pkt->subs != NULL && len != NULL))
478         return 0;
479
480     *len = pkt->written - pkt->subs->pwritten;
481
482     return 1;
483 }
484
485 unsigned char *WPACKET_get_curr(WPACKET *pkt)
486 {
487     unsigned char *buf = GETBUF(pkt);
488
489     if (buf == NULL)
490         return NULL;
491
492     if (pkt->endfirst)
493         return buf + pkt->maxsize - pkt->curr;
494
495     return buf + pkt->curr;
496 }
497
498 int WPACKET_is_null_buf(WPACKET *pkt)
499 {
500     return pkt->buf == NULL && pkt->staticbuf == NULL;
501 }
502
503 void WPACKET_cleanup(WPACKET *pkt)
504 {
505     WPACKET_SUB *sub, *parent;
506
507     for (sub = pkt->subs; sub != NULL; sub = parent) {
508         parent = sub->parent;
509         OPENSSL_free(sub);
510     }
511     pkt->subs = NULL;
512 }