2 * Copyright 2015-2021 The OpenSSL Project Authors. All Rights Reserved.
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
10 #include "internal/cryptlib.h"
11 #include "internal/packet.h"
12 #include <openssl/err.h>
14 #define DEFAULT_BUF_SIZE 256
16 int WPACKET_allocate_bytes(WPACKET
*pkt
, size_t len
, unsigned char **allocbytes
)
18 if (!WPACKET_reserve_bytes(pkt
, len
, allocbytes
))
26 int WPACKET_sub_allocate_bytes__(WPACKET
*pkt
, size_t len
,
27 unsigned char **allocbytes
, size_t lenbytes
)
29 if (!WPACKET_start_sub_packet_len__(pkt
, lenbytes
)
30 || !WPACKET_allocate_bytes(pkt
, len
, allocbytes
)
31 || !WPACKET_close(pkt
))
37 #define GETBUF(p) (((p)->staticbuf != NULL) \
40 ? (unsigned char *)(p)->buf->data \
43 int WPACKET_reserve_bytes(WPACKET
*pkt
, size_t len
, unsigned char **allocbytes
)
45 /* Internal API, so should not fail */
46 if (!ossl_assert(pkt
->subs
!= NULL
&& len
!= 0))
49 if (pkt
->maxsize
- pkt
->written
< len
)
52 if (pkt
->buf
!= NULL
&& (pkt
->buf
->length
- pkt
->written
< len
)) {
56 reflen
= (len
> pkt
->buf
->length
) ? len
: pkt
->buf
->length
;
58 if (reflen
> SIZE_MAX
/ 2) {
62 if (newlen
< DEFAULT_BUF_SIZE
)
63 newlen
= DEFAULT_BUF_SIZE
;
65 if (BUF_MEM_grow(pkt
->buf
, newlen
) == 0)
68 if (allocbytes
!= NULL
) {
69 *allocbytes
= WPACKET_get_curr(pkt
);
70 if (pkt
->endfirst
&& *allocbytes
!= NULL
)
77 int WPACKET_sub_reserve_bytes__(WPACKET
*pkt
, size_t len
,
78 unsigned char **allocbytes
, size_t lenbytes
)
80 if (pkt
->endfirst
&& lenbytes
> 0)
83 if (!WPACKET_reserve_bytes(pkt
, lenbytes
+ len
, allocbytes
))
86 if (*allocbytes
!= NULL
)
87 *allocbytes
+= lenbytes
;
92 static size_t maxmaxsize(size_t lenbytes
)
94 if (lenbytes
>= sizeof(size_t) || lenbytes
== 0)
97 return ((size_t)1 << (lenbytes
* 8)) - 1 + lenbytes
;
100 static int wpacket_intern_init_len(WPACKET
*pkt
, size_t lenbytes
)
102 unsigned char *lenchars
;
107 if ((pkt
->subs
= OPENSSL_zalloc(sizeof(*pkt
->subs
))) == NULL
) {
108 ERR_raise(ERR_LIB_CRYPTO
, ERR_R_MALLOC_FAILURE
);
115 pkt
->subs
->pwritten
= lenbytes
;
116 pkt
->subs
->lenbytes
= lenbytes
;
118 if (!WPACKET_allocate_bytes(pkt
, lenbytes
, &lenchars
)) {
119 OPENSSL_free(pkt
->subs
);
123 pkt
->subs
->packet_len
= 0;
128 int WPACKET_init_static_len(WPACKET
*pkt
, unsigned char *buf
, size_t len
,
131 size_t max
= maxmaxsize(lenbytes
);
133 /* Internal API, so should not fail */
134 if (!ossl_assert(buf
!= NULL
&& len
> 0))
137 pkt
->staticbuf
= buf
;
139 pkt
->maxsize
= (max
< len
) ? max
: len
;
142 return wpacket_intern_init_len(pkt
, lenbytes
);
145 int WPACKET_init_der(WPACKET
*pkt
, unsigned char *buf
, size_t len
)
147 /* Internal API, so should not fail */
148 if (!ossl_assert(buf
!= NULL
&& len
> 0))
151 pkt
->staticbuf
= buf
;
156 return wpacket_intern_init_len(pkt
, 0);
159 int WPACKET_init_len(WPACKET
*pkt
, BUF_MEM
*buf
, size_t lenbytes
)
161 /* Internal API, so should not fail */
162 if (!ossl_assert(buf
!= NULL
))
165 pkt
->staticbuf
= NULL
;
167 pkt
->maxsize
= maxmaxsize(lenbytes
);
170 return wpacket_intern_init_len(pkt
, lenbytes
);
173 int WPACKET_init(WPACKET
*pkt
, BUF_MEM
*buf
)
175 return WPACKET_init_len(pkt
, buf
, 0);
178 int WPACKET_init_null(WPACKET
*pkt
, size_t lenbytes
)
180 pkt
->staticbuf
= NULL
;
182 pkt
->maxsize
= maxmaxsize(lenbytes
);
185 return wpacket_intern_init_len(pkt
, 0);
188 int WPACKET_init_null_der(WPACKET
*pkt
)
190 pkt
->staticbuf
= NULL
;
192 pkt
->maxsize
= SIZE_MAX
;
195 return wpacket_intern_init_len(pkt
, 0);
198 int WPACKET_set_flags(WPACKET
*pkt
, unsigned int flags
)
200 /* Internal API, so should not fail */
201 if (!ossl_assert(pkt
->subs
!= NULL
))
204 pkt
->subs
->flags
= flags
;
209 /* Store the |value| of length |len| at location |data| */
210 static int put_value(unsigned char *data
, uint64_t value
, size_t len
)
215 for (data
+= len
- 1; len
> 0; len
--) {
216 *data
= (unsigned char)(value
& 0xff);
221 /* Check whether we could fit the value in the assigned number of bytes */
228 static int put_quic_value(unsigned char *data
, size_t value
, size_t len
)
233 /* Value too large for field. */
234 if (ossl_quic_vlint_encode_len(value
) > len
)
237 ossl_quic_vlint_encode_n(data
, value
, len
);
242 * Internal helper function used by WPACKET_close(), WPACKET_finish() and
243 * WPACKET_fill_lengths() to close a sub-packet and write out its length if
244 * necessary. If |doclose| is 0 then it goes through the motions of closing
245 * (i.e. it fills in all the lengths), but doesn't actually close anything.
247 static int wpacket_intern_close(WPACKET
*pkt
, WPACKET_SUB
*sub
, int doclose
)
249 size_t packlen
= pkt
->written
- sub
->pwritten
;
252 && (sub
->flags
& WPACKET_FLAGS_NON_ZERO_LENGTH
) != 0)
256 && sub
->flags
& WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH
) {
257 /* We can't handle this case. Return an error */
261 /* Deallocate any bytes allocated for the length of the WPACKET */
262 if ((pkt
->curr
- sub
->lenbytes
) == sub
->packet_len
) {
263 pkt
->written
-= sub
->lenbytes
;
264 pkt
->curr
-= sub
->lenbytes
;
267 /* Don't write out the packet length */
272 /* Write out the WPACKET length if needed */
273 if (sub
->lenbytes
> 0) {
274 unsigned char *buf
= GETBUF(pkt
);
277 if ((sub
->flags
& WPACKET_FLAGS_QUIC_VLINT
) == 0) {
278 if (!put_value(&buf
[sub
->packet_len
], packlen
, sub
->lenbytes
))
281 if (!put_quic_value(&buf
[sub
->packet_len
], packlen
, sub
->lenbytes
))
285 } else if (pkt
->endfirst
&& sub
->parent
!= NULL
288 & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH
) == 0)) {
289 size_t tmplen
= packlen
;
290 size_t numlenbytes
= 1;
292 while ((tmplen
= tmplen
>> 8) > 0)
294 if (!WPACKET_put_bytes__(pkt
, packlen
, numlenbytes
))
296 if (packlen
> 0x7f) {
298 if (!WPACKET_put_bytes_u8(pkt
, numlenbytes
))
304 pkt
->subs
= sub
->parent
;
311 int WPACKET_fill_lengths(WPACKET
*pkt
)
315 if (!ossl_assert(pkt
->subs
!= NULL
))
318 for (sub
= pkt
->subs
; sub
!= NULL
; sub
= sub
->parent
) {
319 if (!wpacket_intern_close(pkt
, sub
, 0))
326 int WPACKET_close(WPACKET
*pkt
)
329 * Internal API, so should not fail - but we do negative testing of this
330 * so no assert (otherwise the tests fail)
332 if (pkt
->subs
== NULL
|| pkt
->subs
->parent
== NULL
)
335 return wpacket_intern_close(pkt
, pkt
->subs
, 1);
338 int WPACKET_finish(WPACKET
*pkt
)
343 * Internal API, so should not fail - but we do negative testing of this
344 * so no assert (otherwise the tests fail)
346 if (pkt
->subs
== NULL
|| pkt
->subs
->parent
!= NULL
)
349 ret
= wpacket_intern_close(pkt
, pkt
->subs
, 1);
351 OPENSSL_free(pkt
->subs
);
358 int WPACKET_start_sub_packet_len__(WPACKET
*pkt
, size_t lenbytes
)
361 unsigned char *lenchars
;
363 /* Internal API, so should not fail */
364 if (!ossl_assert(pkt
->subs
!= NULL
))
367 /* We don't support lenbytes greater than 0 when doing endfirst writing */
368 if (lenbytes
> 0 && pkt
->endfirst
)
371 if ((sub
= OPENSSL_zalloc(sizeof(*sub
))) == NULL
) {
372 ERR_raise(ERR_LIB_CRYPTO
, ERR_R_MALLOC_FAILURE
);
376 sub
->parent
= pkt
->subs
;
378 sub
->pwritten
= pkt
->written
+ lenbytes
;
379 sub
->lenbytes
= lenbytes
;
386 sub
->packet_len
= pkt
->written
;
388 if (!WPACKET_allocate_bytes(pkt
, lenbytes
, &lenchars
))
394 int WPACKET_start_sub_packet(WPACKET
*pkt
)
396 return WPACKET_start_sub_packet_len__(pkt
, 0);
399 int WPACKET_put_bytes__(WPACKET
*pkt
, uint64_t val
, size_t size
)
403 /* Internal API, so should not fail */
404 if (!ossl_assert(size
<= sizeof(uint64_t))
405 || !WPACKET_allocate_bytes(pkt
, size
, &data
)
406 || !put_value(data
, val
, size
))
412 int WPACKET_set_max_size(WPACKET
*pkt
, size_t maxsize
)
417 /* Internal API, so should not fail */
418 if (!ossl_assert(pkt
->subs
!= NULL
))
421 /* Find the WPACKET_SUB for the top level */
422 for (sub
= pkt
->subs
; sub
->parent
!= NULL
; sub
= sub
->parent
)
425 lenbytes
= sub
->lenbytes
;
427 lenbytes
= sizeof(pkt
->maxsize
);
429 if (maxmaxsize(lenbytes
) < maxsize
|| maxsize
< pkt
->written
)
432 pkt
->maxsize
= maxsize
;
437 int WPACKET_memset(WPACKET
*pkt
, int ch
, size_t len
)
444 if (!WPACKET_allocate_bytes(pkt
, len
, &dest
))
448 memset(dest
, ch
, len
);
453 int WPACKET_memcpy(WPACKET
*pkt
, const void *src
, size_t len
)
460 if (!WPACKET_allocate_bytes(pkt
, len
, &dest
))
464 memcpy(dest
, src
, len
);
469 int WPACKET_sub_memcpy__(WPACKET
*pkt
, const void *src
, size_t len
,
472 if (!WPACKET_start_sub_packet_len__(pkt
, lenbytes
)
473 || !WPACKET_memcpy(pkt
, src
, len
)
474 || !WPACKET_close(pkt
))
480 int WPACKET_get_total_written(WPACKET
*pkt
, size_t *written
)
482 /* Internal API, so should not fail */
483 if (!ossl_assert(written
!= NULL
))
486 *written
= pkt
->written
;
491 int WPACKET_get_length(WPACKET
*pkt
, size_t *len
)
493 /* Internal API, so should not fail */
494 if (!ossl_assert(pkt
->subs
!= NULL
&& len
!= NULL
))
497 *len
= pkt
->written
- pkt
->subs
->pwritten
;
502 unsigned char *WPACKET_get_curr(WPACKET
*pkt
)
504 unsigned char *buf
= GETBUF(pkt
);
510 return buf
+ pkt
->maxsize
- pkt
->curr
;
512 return buf
+ pkt
->curr
;
515 int WPACKET_is_null_buf(WPACKET
*pkt
)
517 return pkt
->buf
== NULL
&& pkt
->staticbuf
== NULL
;
520 void WPACKET_cleanup(WPACKET
*pkt
)
522 WPACKET_SUB
*sub
, *parent
;
524 for (sub
= pkt
->subs
; sub
!= NULL
; sub
= parent
) {
525 parent
= sub
->parent
;
531 int WPACKET_start_quic_sub_packet_bound(WPACKET
*pkt
, size_t max_len
)
533 size_t enclen
= ossl_quic_vlint_encode_len(max_len
);
538 if (WPACKET_start_sub_packet_len__(pkt
, enclen
) == 0)
541 pkt
->subs
->flags
|= WPACKET_FLAGS_QUIC_VLINT
;
545 int WPACKET_start_quic_sub_packet(WPACKET
*pkt
)
548 * Assume no (sub)packet will exceed 4GiB, thus the 8-byte encoding need not
551 return WPACKET_start_quic_sub_packet_bound(pkt
, OSSL_QUIC_VLINT_4B_MIN
);
554 int WPACKET_quic_sub_allocate_bytes(WPACKET
*pkt
, size_t len
, unsigned char **allocbytes
)
556 if (!WPACKET_start_quic_sub_packet_bound(pkt
, len
)
557 || !WPACKET_allocate_bytes(pkt
, len
, allocbytes
)
558 || !WPACKET_close(pkt
))
565 * Write a QUIC variable-length integer to the packet.
567 int WPACKET_quic_write_vlint(WPACKET
*pkt
, uint64_t v
)
569 unsigned char *b
= NULL
;
570 size_t enclen
= ossl_quic_vlint_encode_len(v
);
575 if (WPACKET_allocate_bytes(pkt
, enclen
, &b
) == 0)
578 ossl_quic_vlint_encode(b
, v
);