1*9234d803Sjsing /* $OpenBSD: bs_cbb.c,v 1.17 2017/08/12 02:50:05 jsing Exp $ */ 2c4905cd3Sdoug /* 3c4905cd3Sdoug * Copyright (c) 2014, Google Inc. 4c4905cd3Sdoug * 5c4905cd3Sdoug * Permission to use, copy, modify, and/or distribute this software for any 6c4905cd3Sdoug * purpose with or without fee is hereby granted, provided that the above 7c4905cd3Sdoug * copyright notice and this permission notice appear in all copies. 8c4905cd3Sdoug * 9c4905cd3Sdoug * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10c4905cd3Sdoug * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11c4905cd3Sdoug * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY 12c4905cd3Sdoug * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13c4905cd3Sdoug * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION 14c4905cd3Sdoug * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN 15c4905cd3Sdoug * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ 16c4905cd3Sdoug 17c4905cd3Sdoug #include <assert.h> 18c4905cd3Sdoug #include <stdlib.h> 19c4905cd3Sdoug #include <string.h> 20c4905cd3Sdoug 21c4905cd3Sdoug #include <openssl/opensslconf.h> 22c4905cd3Sdoug 23c4905cd3Sdoug #include "bytestring.h" 24c4905cd3Sdoug 25c99575daSjsing #define CBB_INITIAL_SIZE 64 26c99575daSjsing 27732f1cb2Sdoug static int 28732f1cb2Sdoug cbb_init(CBB *cbb, uint8_t *buf, size_t cap) 29732f1cb2Sdoug { 30c4905cd3Sdoug struct cbb_buffer_st *base; 31c4905cd3Sdoug 32c4905cd3Sdoug base = malloc(sizeof(struct cbb_buffer_st)); 33d7a08d8fSdoug if (base == NULL) 34c4905cd3Sdoug return 0; 35c4905cd3Sdoug 36c4905cd3Sdoug base->buf = buf; 37c4905cd3Sdoug base->len = 0; 38c4905cd3Sdoug base->cap = cap; 39c4905cd3Sdoug base->can_resize = 1; 40c4905cd3Sdoug 41c4905cd3Sdoug cbb->base = base; 42c4905cd3Sdoug cbb->is_top_level = 1; 4328a1f398Sjsing 44c4905cd3Sdoug return 1; 45c4905cd3Sdoug } 46c4905cd3Sdoug 47732f1cb2Sdoug int 48732f1cb2Sdoug CBB_init(CBB *cbb, size_t initial_capacity) 49732f1cb2Sdoug { 503a0c64b9Sdoug uint8_t *buf = NULL; 51c4905cd3Sdoug 5228a1f398Sjsing memset(cbb, 0, sizeof(*cbb)); 5328a1f398Sjsing 54c99575daSjsing if (initial_capacity == 0) 55c99575daSjsing initial_capacity = CBB_INITIAL_SIZE; 56c99575daSjsing 573a0c64b9Sdoug if ((buf = malloc(initial_capacity)) == NULL) 58c4905cd3Sdoug return 0; 59c4905cd3Sdoug 6041724196Sdoug if (!cbb_init(cbb, buf, initial_capacity)) { 6141724196Sdoug free(buf); 6241724196Sdoug return 0; 6341724196Sdoug } 6428a1f398Sjsing 6541724196Sdoug return 1; 66c4905cd3Sdoug } 67c4905cd3Sdoug 68732f1cb2Sdoug int 69732f1cb2Sdoug CBB_init_fixed(CBB *cbb, uint8_t *buf, size_t len) 70732f1cb2Sdoug { 7128a1f398Sjsing memset(cbb, 0, sizeof(*cbb)); 7228a1f398Sjsing 73732f1cb2Sdoug if (!cbb_init(cbb, buf, len)) 74c4905cd3Sdoug return 0; 75c4905cd3Sdoug 76c4905cd3Sdoug cbb->base->can_resize = 0; 7728a1f398Sjsing 78c4905cd3Sdoug return 1; 79c4905cd3Sdoug } 80c4905cd3Sdoug 81732f1cb2Sdoug void 82732f1cb2Sdoug CBB_cleanup(CBB *cbb) 83732f1cb2Sdoug { 84c4905cd3Sdoug if (cbb->base) { 853a0c64b9Sdoug if (cbb->base->can_resize) 862a6b7f1dSjsing freezero(cbb->base->buf, cbb->base->cap); 87c4905cd3Sdoug free(cbb->base); 88c4905cd3Sdoug } 89c4905cd3Sdoug cbb->base = NULL; 90*9234d803Sjsing cbb->child = NULL; 91c4905cd3Sdoug } 92c4905cd3Sdoug 93732f1cb2Sdoug static int 94732f1cb2Sdoug cbb_buffer_add(struct cbb_buffer_st *base, uint8_t **out, size_t len) 95732f1cb2Sdoug { 96c4905cd3Sdoug size_t newlen; 97c4905cd3Sdoug 98732f1cb2Sdoug if (base == NULL) 99c4905cd3Sdoug return 0; 100c4905cd3Sdoug 101c4905cd3Sdoug newlen = base->len + len; 102732f1cb2Sdoug if (newlen < base->len) 103c4905cd3Sdoug /* Overflow */ 104c4905cd3Sdoug return 0; 105c4905cd3Sdoug 106c4905cd3Sdoug if (newlen > base->cap) { 107c4905cd3Sdoug size_t newcap = base->cap * 2; 108c4905cd3Sdoug uint8_t *newbuf; 109c4905cd3Sdoug 110732f1cb2Sdoug if (!base->can_resize) 111c4905cd3Sdoug return 0; 112c4905cd3Sdoug 113732f1cb2Sdoug if (newcap < base->cap || newcap < newlen) 114c4905cd3Sdoug newcap = newlen; 115732f1cb2Sdoug 11642ccf58dSjsing newbuf = recallocarray(base->buf, base->cap, newcap, 1); 117732f1cb2Sdoug if (newbuf == NULL) 118c4905cd3Sdoug return 0; 119c4905cd3Sdoug 120c4905cd3Sdoug base->buf = newbuf; 121c4905cd3Sdoug base->cap = newcap; 122c4905cd3Sdoug } 123c4905cd3Sdoug 124732f1cb2Sdoug if (out) 125c4905cd3Sdoug *out = base->buf + base->len; 126732f1cb2Sdoug 127c4905cd3Sdoug base->len = newlen; 128c4905cd3Sdoug return 1; 129c4905cd3Sdoug } 130c4905cd3Sdoug 131732f1cb2Sdoug static int 132f49f1317Sdoug cbb_add_u(CBB *cbb, uint32_t v, size_t len_len) 133732f1cb2Sdoug { 134c4905cd3Sdoug uint8_t *buf; 135c4905cd3Sdoug size_t i; 136c4905cd3Sdoug 137732f1cb2Sdoug if (len_len == 0) 138c4905cd3Sdoug return 1; 139732f1cb2Sdoug 140c2c0b151Sdoug if (len_len > 4) 141c2c0b151Sdoug return 0; 142c2c0b151Sdoug 143f49f1317Sdoug if (!CBB_flush(cbb) || !cbb_buffer_add(cbb->base, &buf, len_len)) 144c4905cd3Sdoug return 0; 145c4905cd3Sdoug 146c4905cd3Sdoug for (i = len_len - 1; i < len_len; i--) { 147c4905cd3Sdoug buf[i] = v; 148c4905cd3Sdoug v >>= 8; 149c4905cd3Sdoug } 150c4905cd3Sdoug return 1; 151c4905cd3Sdoug } 152c4905cd3Sdoug 153732f1cb2Sdoug int 154732f1cb2Sdoug CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len) 155732f1cb2Sdoug { 156732f1cb2Sdoug if (!cbb->is_top_level) 157c4905cd3Sdoug return 0; 158c4905cd3Sdoug 159732f1cb2Sdoug if (!CBB_flush(cbb)) 160c4905cd3Sdoug return 0; 161c4905cd3Sdoug 162732f1cb2Sdoug if (cbb->base->can_resize && (out_data == NULL || out_len == NULL)) 163d7a08d8fSdoug /* 164d7a08d8fSdoug * |out_data| and |out_len| can only be NULL if the CBB is 165d7a08d8fSdoug * fixed. 166d7a08d8fSdoug */ 167c4905cd3Sdoug return 0; 168c4905cd3Sdoug 169732f1cb2Sdoug if (out_data != NULL) 170c4905cd3Sdoug *out_data = cbb->base->buf; 171732f1cb2Sdoug 172732f1cb2Sdoug if (out_len != NULL) 173c4905cd3Sdoug *out_len = cbb->base->len; 174732f1cb2Sdoug 175c4905cd3Sdoug cbb->base->buf = NULL; 176c4905cd3Sdoug CBB_cleanup(cbb); 177c4905cd3Sdoug return 1; 178c4905cd3Sdoug } 179c4905cd3Sdoug 180732f1cb2Sdoug /* 181732f1cb2Sdoug * CBB_flush recurses and then writes out any pending length prefix. The current 182732f1cb2Sdoug * length of the underlying base is taken to be the length of the 183732f1cb2Sdoug * length-prefixed data. 184732f1cb2Sdoug */ 185732f1cb2Sdoug int 186732f1cb2Sdoug CBB_flush(CBB *cbb) 187732f1cb2Sdoug { 188c4905cd3Sdoug size_t child_start, i, len; 189c4905cd3Sdoug 190732f1cb2Sdoug if (cbb->base == NULL) 191c4905cd3Sdoug return 0; 192c4905cd3Sdoug 193732f1cb2Sdoug if (cbb->child == NULL || cbb->pending_len_len == 0) 194c4905cd3Sdoug return 1; 195c4905cd3Sdoug 196c4905cd3Sdoug child_start = cbb->offset + cbb->pending_len_len; 197c4905cd3Sdoug 198732f1cb2Sdoug if (!CBB_flush(cbb->child) || child_start < cbb->offset || 199732f1cb2Sdoug cbb->base->len < child_start) 200c4905cd3Sdoug return 0; 201c4905cd3Sdoug 202c4905cd3Sdoug len = cbb->base->len - child_start; 203c4905cd3Sdoug 204c4905cd3Sdoug if (cbb->pending_is_asn1) { 205d7a08d8fSdoug /* 2066ea8e45cSdoug * For ASN.1, we assumed that we were using short form which 2076ea8e45cSdoug * only requires a single byte for the length octet. 2086ea8e45cSdoug * 2096ea8e45cSdoug * If it turns out that we need long form, we have to move 2106ea8e45cSdoug * the contents along in order to make space for more length 2116ea8e45cSdoug * octets. 212d7a08d8fSdoug */ 2136ea8e45cSdoug size_t len_len = 1; /* total number of length octets */ 214c4905cd3Sdoug uint8_t initial_length_byte; 215c4905cd3Sdoug 2166ea8e45cSdoug /* We already wrote 1 byte for the length. */ 217c4905cd3Sdoug assert (cbb->pending_len_len == 1); 218c4905cd3Sdoug 2196ea8e45cSdoug /* Check for long form */ 2206ea8e45cSdoug if (len > 0xfffffffe) 2216ea8e45cSdoug return 0; /* 0xffffffff is reserved */ 2226ea8e45cSdoug else if (len > 0xffffff) 223c4905cd3Sdoug len_len = 5; 2246ea8e45cSdoug else if (len > 0xffff) 225c4905cd3Sdoug len_len = 4; 2266ea8e45cSdoug else if (len > 0xff) 227c4905cd3Sdoug len_len = 3; 2286ea8e45cSdoug else if (len > 0x7f) 229c4905cd3Sdoug len_len = 2; 2306ea8e45cSdoug 2316ea8e45cSdoug if (len_len == 1) { 2326ea8e45cSdoug /* For short form, the initial byte is the length. */ 233c4905cd3Sdoug initial_length_byte = len; 234c4905cd3Sdoug len = 0; 235c4905cd3Sdoug 2366ea8e45cSdoug } else { 2376ea8e45cSdoug /* 2386ea8e45cSdoug * For long form, the initial byte is the number of 2396ea8e45cSdoug * subsequent length octets (plus bit 8 set). 2406ea8e45cSdoug */ 2416ea8e45cSdoug initial_length_byte = 0x80 | (len_len - 1); 2426ea8e45cSdoug 243d7a08d8fSdoug /* 244d7a08d8fSdoug * We need to move the contents along in order to make 2456ea8e45cSdoug * space for the long form length octets. 246d7a08d8fSdoug */ 247c4905cd3Sdoug size_t extra_bytes = len_len - 1; 248732f1cb2Sdoug if (!cbb_buffer_add(cbb->base, NULL, extra_bytes)) 249c4905cd3Sdoug return 0; 250732f1cb2Sdoug 251c4905cd3Sdoug memmove(cbb->base->buf + child_start + extra_bytes, 252c4905cd3Sdoug cbb->base->buf + child_start, len); 253c4905cd3Sdoug } 254c4905cd3Sdoug cbb->base->buf[cbb->offset++] = initial_length_byte; 255c4905cd3Sdoug cbb->pending_len_len = len_len - 1; 256c4905cd3Sdoug } 257c4905cd3Sdoug 258c4905cd3Sdoug for (i = cbb->pending_len_len - 1; i < cbb->pending_len_len; i--) { 259c4905cd3Sdoug cbb->base->buf[cbb->offset + i] = len; 260c4905cd3Sdoug len >>= 8; 261c4905cd3Sdoug } 262732f1cb2Sdoug if (len != 0) 263c4905cd3Sdoug return 0; 264c4905cd3Sdoug 265c4905cd3Sdoug cbb->child->base = NULL; 266c4905cd3Sdoug cbb->child = NULL; 267c4905cd3Sdoug cbb->pending_len_len = 0; 268c4905cd3Sdoug cbb->pending_is_asn1 = 0; 269c4905cd3Sdoug cbb->offset = 0; 270c4905cd3Sdoug 271c4905cd3Sdoug return 1; 272c4905cd3Sdoug } 273c4905cd3Sdoug 274c4905cd3Sdoug 275732f1cb2Sdoug static int 276732f1cb2Sdoug cbb_add_length_prefixed(CBB *cbb, CBB *out_contents, size_t len_len) 277732f1cb2Sdoug { 278c4905cd3Sdoug uint8_t *prefix_bytes; 279c4905cd3Sdoug 280732f1cb2Sdoug if (!CBB_flush(cbb)) 281c4905cd3Sdoug return 0; 282c4905cd3Sdoug 283c4905cd3Sdoug cbb->offset = cbb->base->len; 284732f1cb2Sdoug if (!cbb_buffer_add(cbb->base, &prefix_bytes, len_len)) 285c4905cd3Sdoug return 0; 286c4905cd3Sdoug 287c4905cd3Sdoug memset(prefix_bytes, 0, len_len); 288c4905cd3Sdoug memset(out_contents, 0, sizeof(CBB)); 289c4905cd3Sdoug out_contents->base = cbb->base; 290c4905cd3Sdoug cbb->child = out_contents; 291c4905cd3Sdoug cbb->pending_len_len = len_len; 292c4905cd3Sdoug cbb->pending_is_asn1 = 0; 293c4905cd3Sdoug 294c4905cd3Sdoug return 1; 295c4905cd3Sdoug } 296c4905cd3Sdoug 297732f1cb2Sdoug int 298732f1cb2Sdoug CBB_add_u8_length_prefixed(CBB *cbb, CBB *out_contents) 299732f1cb2Sdoug { 300c4905cd3Sdoug return cbb_add_length_prefixed(cbb, out_contents, 1); 301c4905cd3Sdoug } 302c4905cd3Sdoug 303732f1cb2Sdoug int 304732f1cb2Sdoug CBB_add_u16_length_prefixed(CBB *cbb, CBB *out_contents) 305732f1cb2Sdoug { 306c4905cd3Sdoug return cbb_add_length_prefixed(cbb, out_contents, 2); 307c4905cd3Sdoug } 308c4905cd3Sdoug 309732f1cb2Sdoug int 310732f1cb2Sdoug CBB_add_u24_length_prefixed(CBB *cbb, CBB *out_contents) 311732f1cb2Sdoug { 312c4905cd3Sdoug return cbb_add_length_prefixed(cbb, out_contents, 3); 313c4905cd3Sdoug } 314c4905cd3Sdoug 315732f1cb2Sdoug int 3169d4b5ca7Sdoug CBB_add_asn1(CBB *cbb, CBB *out_contents, unsigned int tag) 317732f1cb2Sdoug { 3189d4b5ca7Sdoug if (tag > UINT8_MAX) 3199d4b5ca7Sdoug return 0; 3209d4b5ca7Sdoug 321d7a08d8fSdoug /* Long form identifier octets are not supported. */ 322d7a08d8fSdoug if ((tag & 0x1f) == 0x1f) 323d7a08d8fSdoug return 0; 324d7a08d8fSdoug 3256ea8e45cSdoug /* Short-form identifier octet only needs a single byte */ 326732f1cb2Sdoug if (!CBB_flush(cbb) || !CBB_add_u8(cbb, tag)) 327c4905cd3Sdoug return 0; 328c4905cd3Sdoug 3296ea8e45cSdoug /* 3306ea8e45cSdoug * Add 1 byte to cover the short-form length octet case. If it turns 3316ea8e45cSdoug * out we need long-form, it will be extended later. 3326ea8e45cSdoug */ 333c4905cd3Sdoug cbb->offset = cbb->base->len; 334732f1cb2Sdoug if (!CBB_add_u8(cbb, 0)) 335c4905cd3Sdoug return 0; 336c4905cd3Sdoug 337c4905cd3Sdoug memset(out_contents, 0, sizeof(CBB)); 338c4905cd3Sdoug out_contents->base = cbb->base; 339c4905cd3Sdoug cbb->child = out_contents; 340c4905cd3Sdoug cbb->pending_len_len = 1; 341c4905cd3Sdoug cbb->pending_is_asn1 = 1; 342c4905cd3Sdoug 343c4905cd3Sdoug return 1; 344c4905cd3Sdoug } 345c4905cd3Sdoug 346732f1cb2Sdoug int 347732f1cb2Sdoug CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len) 348732f1cb2Sdoug { 349c4905cd3Sdoug uint8_t *dest; 350c4905cd3Sdoug 35118f8c184Sdoug if (!CBB_add_space(cbb, &dest, len)) 352c4905cd3Sdoug return 0; 353732f1cb2Sdoug 354c4905cd3Sdoug memcpy(dest, data, len); 355c4905cd3Sdoug return 1; 356c4905cd3Sdoug } 357c4905cd3Sdoug 358732f1cb2Sdoug int 359732f1cb2Sdoug CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) 360732f1cb2Sdoug { 361732f1cb2Sdoug if (!CBB_flush(cbb) || !cbb_buffer_add(cbb->base, out_data, len)) 362c4905cd3Sdoug return 0; 363732f1cb2Sdoug 364c4905cd3Sdoug return 1; 365c4905cd3Sdoug } 366c4905cd3Sdoug 367732f1cb2Sdoug int 3689d4b5ca7Sdoug CBB_add_u8(CBB *cbb, size_t value) 369732f1cb2Sdoug { 3709d4b5ca7Sdoug if (value > UINT8_MAX) 3719d4b5ca7Sdoug return 0; 3729d4b5ca7Sdoug 3739d4b5ca7Sdoug return cbb_add_u(cbb, (uint32_t)value, 1); 374c4905cd3Sdoug } 375c4905cd3Sdoug 376732f1cb2Sdoug int 3779d4b5ca7Sdoug CBB_add_u16(CBB *cbb, size_t value) 378732f1cb2Sdoug { 3799d4b5ca7Sdoug if (value > UINT16_MAX) 3809d4b5ca7Sdoug return 0; 3819d4b5ca7Sdoug 3829d4b5ca7Sdoug return cbb_add_u(cbb, (uint32_t)value, 2); 383c4905cd3Sdoug } 384c4905cd3Sdoug 385732f1cb2Sdoug int 3869d4b5ca7Sdoug CBB_add_u24(CBB *cbb, size_t value) 387732f1cb2Sdoug { 3889d4b5ca7Sdoug if (value > 0xffffffUL) 3899d4b5ca7Sdoug return 0; 3909d4b5ca7Sdoug 3919d4b5ca7Sdoug return cbb_add_u(cbb, (uint32_t)value, 3); 392c4905cd3Sdoug } 393c4905cd3Sdoug 394732f1cb2Sdoug int 395732f1cb2Sdoug CBB_add_asn1_uint64(CBB *cbb, uint64_t value) 396732f1cb2Sdoug { 397c4905cd3Sdoug CBB child; 398c4905cd3Sdoug size_t i; 399c4905cd3Sdoug int started = 0; 400c4905cd3Sdoug 401732f1cb2Sdoug if (!CBB_add_asn1(cbb, &child, CBS_ASN1_INTEGER)) 402c4905cd3Sdoug return 0; 403c4905cd3Sdoug 404c4905cd3Sdoug for (i = 0; i < 8; i++) { 405c4905cd3Sdoug uint8_t byte = (value >> 8 * (7 - i)) & 0xff; 406debb3ac7Sdoug 407debb3ac7Sdoug /* 408debb3ac7Sdoug * ASN.1 restriction: first 9 bits cannot be all zeroes or 409debb3ac7Sdoug * all ones. Since this function only encodes unsigned 410debb3ac7Sdoug * integers, the only concerns are not encoding leading 411debb3ac7Sdoug * zeros and adding a padding byte if necessary. 412debb3ac7Sdoug * 413debb3ac7Sdoug * In practice, this means: 414debb3ac7Sdoug * 1) Skip leading octets of all zero bits in the value 415debb3ac7Sdoug * 2) After skipping the leading zero octets, if the next 9 416debb3ac7Sdoug * bits are all ones, add an all zero prefix octet (and 417debb3ac7Sdoug * set the high bit of the prefix octet if negative). 418debb3ac7Sdoug * 419debb3ac7Sdoug * Additionally, for an unsigned value, add an all zero 420debb3ac7Sdoug * prefix if the high bit of the first octet would be one. 421debb3ac7Sdoug */ 422c4905cd3Sdoug if (!started) { 423732f1cb2Sdoug if (byte == 0) 424c4905cd3Sdoug /* Don't encode leading zeros. */ 425c4905cd3Sdoug continue; 426732f1cb2Sdoug 427d7a08d8fSdoug /* 428d7a08d8fSdoug * If the high bit is set, add a padding byte to make it 429d7a08d8fSdoug * unsigned. 430d7a08d8fSdoug */ 431732f1cb2Sdoug if ((byte & 0x80) && !CBB_add_u8(&child, 0)) 432c4905cd3Sdoug return 0; 433732f1cb2Sdoug 434c4905cd3Sdoug started = 1; 435c4905cd3Sdoug } 436732f1cb2Sdoug if (!CBB_add_u8(&child, byte)) 437c4905cd3Sdoug return 0; 438c4905cd3Sdoug } 439c4905cd3Sdoug 440c4905cd3Sdoug /* 0 is encoded as a single 0, not the empty string. */ 441732f1cb2Sdoug if (!started && !CBB_add_u8(&child, 0)) 442c4905cd3Sdoug return 0; 443c4905cd3Sdoug 444c4905cd3Sdoug return CBB_flush(cbb); 445c4905cd3Sdoug } 446