1*c99575daSjsing /* $OpenBSD: bs_cbb.c,v 1.16 2017/05/07 05:03:41 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 25*c99575daSjsing #define CBB_INITIAL_SIZE 64 26*c99575daSjsing 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 54*c99575daSjsing if (initial_capacity == 0) 55*c99575daSjsing initial_capacity = CBB_INITIAL_SIZE; 56*c99575daSjsing 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; 90c4905cd3Sdoug } 91c4905cd3Sdoug 92732f1cb2Sdoug static int 93732f1cb2Sdoug cbb_buffer_add(struct cbb_buffer_st *base, uint8_t **out, size_t len) 94732f1cb2Sdoug { 95c4905cd3Sdoug size_t newlen; 96c4905cd3Sdoug 97732f1cb2Sdoug if (base == NULL) 98c4905cd3Sdoug return 0; 99c4905cd3Sdoug 100c4905cd3Sdoug newlen = base->len + len; 101732f1cb2Sdoug if (newlen < base->len) 102c4905cd3Sdoug /* Overflow */ 103c4905cd3Sdoug return 0; 104c4905cd3Sdoug 105c4905cd3Sdoug if (newlen > base->cap) { 106c4905cd3Sdoug size_t newcap = base->cap * 2; 107c4905cd3Sdoug uint8_t *newbuf; 108c4905cd3Sdoug 109732f1cb2Sdoug if (!base->can_resize) 110c4905cd3Sdoug return 0; 111c4905cd3Sdoug 112732f1cb2Sdoug if (newcap < base->cap || newcap < newlen) 113c4905cd3Sdoug newcap = newlen; 114732f1cb2Sdoug 11542ccf58dSjsing newbuf = recallocarray(base->buf, base->cap, newcap, 1); 116732f1cb2Sdoug if (newbuf == NULL) 117c4905cd3Sdoug return 0; 118c4905cd3Sdoug 119c4905cd3Sdoug base->buf = newbuf; 120c4905cd3Sdoug base->cap = newcap; 121c4905cd3Sdoug } 122c4905cd3Sdoug 123732f1cb2Sdoug if (out) 124c4905cd3Sdoug *out = base->buf + base->len; 125732f1cb2Sdoug 126c4905cd3Sdoug base->len = newlen; 127c4905cd3Sdoug return 1; 128c4905cd3Sdoug } 129c4905cd3Sdoug 130732f1cb2Sdoug static int 131f49f1317Sdoug cbb_add_u(CBB *cbb, uint32_t v, size_t len_len) 132732f1cb2Sdoug { 133c4905cd3Sdoug uint8_t *buf; 134c4905cd3Sdoug size_t i; 135c4905cd3Sdoug 136732f1cb2Sdoug if (len_len == 0) 137c4905cd3Sdoug return 1; 138732f1cb2Sdoug 139c2c0b151Sdoug if (len_len > 4) 140c2c0b151Sdoug return 0; 141c2c0b151Sdoug 142f49f1317Sdoug if (!CBB_flush(cbb) || !cbb_buffer_add(cbb->base, &buf, len_len)) 143c4905cd3Sdoug return 0; 144c4905cd3Sdoug 145c4905cd3Sdoug for (i = len_len - 1; i < len_len; i--) { 146c4905cd3Sdoug buf[i] = v; 147c4905cd3Sdoug v >>= 8; 148c4905cd3Sdoug } 149c4905cd3Sdoug return 1; 150c4905cd3Sdoug } 151c4905cd3Sdoug 152732f1cb2Sdoug int 153732f1cb2Sdoug CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len) 154732f1cb2Sdoug { 155732f1cb2Sdoug if (!cbb->is_top_level) 156c4905cd3Sdoug return 0; 157c4905cd3Sdoug 158732f1cb2Sdoug if (!CBB_flush(cbb)) 159c4905cd3Sdoug return 0; 160c4905cd3Sdoug 161732f1cb2Sdoug if (cbb->base->can_resize && (out_data == NULL || out_len == NULL)) 162d7a08d8fSdoug /* 163d7a08d8fSdoug * |out_data| and |out_len| can only be NULL if the CBB is 164d7a08d8fSdoug * fixed. 165d7a08d8fSdoug */ 166c4905cd3Sdoug return 0; 167c4905cd3Sdoug 168732f1cb2Sdoug if (out_data != NULL) 169c4905cd3Sdoug *out_data = cbb->base->buf; 170732f1cb2Sdoug 171732f1cb2Sdoug if (out_len != NULL) 172c4905cd3Sdoug *out_len = cbb->base->len; 173732f1cb2Sdoug 174c4905cd3Sdoug cbb->base->buf = NULL; 175c4905cd3Sdoug CBB_cleanup(cbb); 176c4905cd3Sdoug return 1; 177c4905cd3Sdoug } 178c4905cd3Sdoug 179732f1cb2Sdoug /* 180732f1cb2Sdoug * CBB_flush recurses and then writes out any pending length prefix. The current 181732f1cb2Sdoug * length of the underlying base is taken to be the length of the 182732f1cb2Sdoug * length-prefixed data. 183732f1cb2Sdoug */ 184732f1cb2Sdoug int 185732f1cb2Sdoug CBB_flush(CBB *cbb) 186732f1cb2Sdoug { 187c4905cd3Sdoug size_t child_start, i, len; 188c4905cd3Sdoug 189732f1cb2Sdoug if (cbb->base == NULL) 190c4905cd3Sdoug return 0; 191c4905cd3Sdoug 192732f1cb2Sdoug if (cbb->child == NULL || cbb->pending_len_len == 0) 193c4905cd3Sdoug return 1; 194c4905cd3Sdoug 195c4905cd3Sdoug child_start = cbb->offset + cbb->pending_len_len; 196c4905cd3Sdoug 197732f1cb2Sdoug if (!CBB_flush(cbb->child) || child_start < cbb->offset || 198732f1cb2Sdoug cbb->base->len < child_start) 199c4905cd3Sdoug return 0; 200c4905cd3Sdoug 201c4905cd3Sdoug len = cbb->base->len - child_start; 202c4905cd3Sdoug 203c4905cd3Sdoug if (cbb->pending_is_asn1) { 204d7a08d8fSdoug /* 2056ea8e45cSdoug * For ASN.1, we assumed that we were using short form which 2066ea8e45cSdoug * only requires a single byte for the length octet. 2076ea8e45cSdoug * 2086ea8e45cSdoug * If it turns out that we need long form, we have to move 2096ea8e45cSdoug * the contents along in order to make space for more length 2106ea8e45cSdoug * octets. 211d7a08d8fSdoug */ 2126ea8e45cSdoug size_t len_len = 1; /* total number of length octets */ 213c4905cd3Sdoug uint8_t initial_length_byte; 214c4905cd3Sdoug 2156ea8e45cSdoug /* We already wrote 1 byte for the length. */ 216c4905cd3Sdoug assert (cbb->pending_len_len == 1); 217c4905cd3Sdoug 2186ea8e45cSdoug /* Check for long form */ 2196ea8e45cSdoug if (len > 0xfffffffe) 2206ea8e45cSdoug return 0; /* 0xffffffff is reserved */ 2216ea8e45cSdoug else if (len > 0xffffff) 222c4905cd3Sdoug len_len = 5; 2236ea8e45cSdoug else if (len > 0xffff) 224c4905cd3Sdoug len_len = 4; 2256ea8e45cSdoug else if (len > 0xff) 226c4905cd3Sdoug len_len = 3; 2276ea8e45cSdoug else if (len > 0x7f) 228c4905cd3Sdoug len_len = 2; 2296ea8e45cSdoug 2306ea8e45cSdoug if (len_len == 1) { 2316ea8e45cSdoug /* For short form, the initial byte is the length. */ 232c4905cd3Sdoug initial_length_byte = len; 233c4905cd3Sdoug len = 0; 234c4905cd3Sdoug 2356ea8e45cSdoug } else { 2366ea8e45cSdoug /* 2376ea8e45cSdoug * For long form, the initial byte is the number of 2386ea8e45cSdoug * subsequent length octets (plus bit 8 set). 2396ea8e45cSdoug */ 2406ea8e45cSdoug initial_length_byte = 0x80 | (len_len - 1); 2416ea8e45cSdoug 242d7a08d8fSdoug /* 243d7a08d8fSdoug * We need to move the contents along in order to make 2446ea8e45cSdoug * space for the long form length octets. 245d7a08d8fSdoug */ 246c4905cd3Sdoug size_t extra_bytes = len_len - 1; 247732f1cb2Sdoug if (!cbb_buffer_add(cbb->base, NULL, extra_bytes)) 248c4905cd3Sdoug return 0; 249732f1cb2Sdoug 250c4905cd3Sdoug memmove(cbb->base->buf + child_start + extra_bytes, 251c4905cd3Sdoug cbb->base->buf + child_start, len); 252c4905cd3Sdoug } 253c4905cd3Sdoug cbb->base->buf[cbb->offset++] = initial_length_byte; 254c4905cd3Sdoug cbb->pending_len_len = len_len - 1; 255c4905cd3Sdoug } 256c4905cd3Sdoug 257c4905cd3Sdoug for (i = cbb->pending_len_len - 1; i < cbb->pending_len_len; i--) { 258c4905cd3Sdoug cbb->base->buf[cbb->offset + i] = len; 259c4905cd3Sdoug len >>= 8; 260c4905cd3Sdoug } 261732f1cb2Sdoug if (len != 0) 262c4905cd3Sdoug return 0; 263c4905cd3Sdoug 264c4905cd3Sdoug cbb->child->base = NULL; 265c4905cd3Sdoug cbb->child = NULL; 266c4905cd3Sdoug cbb->pending_len_len = 0; 267c4905cd3Sdoug cbb->pending_is_asn1 = 0; 268c4905cd3Sdoug cbb->offset = 0; 269c4905cd3Sdoug 270c4905cd3Sdoug return 1; 271c4905cd3Sdoug } 272c4905cd3Sdoug 273c4905cd3Sdoug 274732f1cb2Sdoug static int 275732f1cb2Sdoug cbb_add_length_prefixed(CBB *cbb, CBB *out_contents, size_t len_len) 276732f1cb2Sdoug { 277c4905cd3Sdoug uint8_t *prefix_bytes; 278c4905cd3Sdoug 279732f1cb2Sdoug if (!CBB_flush(cbb)) 280c4905cd3Sdoug return 0; 281c4905cd3Sdoug 282c4905cd3Sdoug cbb->offset = cbb->base->len; 283732f1cb2Sdoug if (!cbb_buffer_add(cbb->base, &prefix_bytes, len_len)) 284c4905cd3Sdoug return 0; 285c4905cd3Sdoug 286c4905cd3Sdoug memset(prefix_bytes, 0, len_len); 287c4905cd3Sdoug memset(out_contents, 0, sizeof(CBB)); 288c4905cd3Sdoug out_contents->base = cbb->base; 289c4905cd3Sdoug cbb->child = out_contents; 290c4905cd3Sdoug cbb->pending_len_len = len_len; 291c4905cd3Sdoug cbb->pending_is_asn1 = 0; 292c4905cd3Sdoug 293c4905cd3Sdoug return 1; 294c4905cd3Sdoug } 295c4905cd3Sdoug 296732f1cb2Sdoug int 297732f1cb2Sdoug CBB_add_u8_length_prefixed(CBB *cbb, CBB *out_contents) 298732f1cb2Sdoug { 299c4905cd3Sdoug return cbb_add_length_prefixed(cbb, out_contents, 1); 300c4905cd3Sdoug } 301c4905cd3Sdoug 302732f1cb2Sdoug int 303732f1cb2Sdoug CBB_add_u16_length_prefixed(CBB *cbb, CBB *out_contents) 304732f1cb2Sdoug { 305c4905cd3Sdoug return cbb_add_length_prefixed(cbb, out_contents, 2); 306c4905cd3Sdoug } 307c4905cd3Sdoug 308732f1cb2Sdoug int 309732f1cb2Sdoug CBB_add_u24_length_prefixed(CBB *cbb, CBB *out_contents) 310732f1cb2Sdoug { 311c4905cd3Sdoug return cbb_add_length_prefixed(cbb, out_contents, 3); 312c4905cd3Sdoug } 313c4905cd3Sdoug 314732f1cb2Sdoug int 3159d4b5ca7Sdoug CBB_add_asn1(CBB *cbb, CBB *out_contents, unsigned int tag) 316732f1cb2Sdoug { 3179d4b5ca7Sdoug if (tag > UINT8_MAX) 3189d4b5ca7Sdoug return 0; 3199d4b5ca7Sdoug 320d7a08d8fSdoug /* Long form identifier octets are not supported. */ 321d7a08d8fSdoug if ((tag & 0x1f) == 0x1f) 322d7a08d8fSdoug return 0; 323d7a08d8fSdoug 3246ea8e45cSdoug /* Short-form identifier octet only needs a single byte */ 325732f1cb2Sdoug if (!CBB_flush(cbb) || !CBB_add_u8(cbb, tag)) 326c4905cd3Sdoug return 0; 327c4905cd3Sdoug 3286ea8e45cSdoug /* 3296ea8e45cSdoug * Add 1 byte to cover the short-form length octet case. If it turns 3306ea8e45cSdoug * out we need long-form, it will be extended later. 3316ea8e45cSdoug */ 332c4905cd3Sdoug cbb->offset = cbb->base->len; 333732f1cb2Sdoug if (!CBB_add_u8(cbb, 0)) 334c4905cd3Sdoug return 0; 335c4905cd3Sdoug 336c4905cd3Sdoug memset(out_contents, 0, sizeof(CBB)); 337c4905cd3Sdoug out_contents->base = cbb->base; 338c4905cd3Sdoug cbb->child = out_contents; 339c4905cd3Sdoug cbb->pending_len_len = 1; 340c4905cd3Sdoug cbb->pending_is_asn1 = 1; 341c4905cd3Sdoug 342c4905cd3Sdoug return 1; 343c4905cd3Sdoug } 344c4905cd3Sdoug 345732f1cb2Sdoug int 346732f1cb2Sdoug CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len) 347732f1cb2Sdoug { 348c4905cd3Sdoug uint8_t *dest; 349c4905cd3Sdoug 35018f8c184Sdoug if (!CBB_add_space(cbb, &dest, len)) 351c4905cd3Sdoug return 0; 352732f1cb2Sdoug 353c4905cd3Sdoug memcpy(dest, data, len); 354c4905cd3Sdoug return 1; 355c4905cd3Sdoug } 356c4905cd3Sdoug 357732f1cb2Sdoug int 358732f1cb2Sdoug CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) 359732f1cb2Sdoug { 360732f1cb2Sdoug if (!CBB_flush(cbb) || !cbb_buffer_add(cbb->base, out_data, len)) 361c4905cd3Sdoug return 0; 362732f1cb2Sdoug 363c4905cd3Sdoug return 1; 364c4905cd3Sdoug } 365c4905cd3Sdoug 366732f1cb2Sdoug int 3679d4b5ca7Sdoug CBB_add_u8(CBB *cbb, size_t value) 368732f1cb2Sdoug { 3699d4b5ca7Sdoug if (value > UINT8_MAX) 3709d4b5ca7Sdoug return 0; 3719d4b5ca7Sdoug 3729d4b5ca7Sdoug return cbb_add_u(cbb, (uint32_t)value, 1); 373c4905cd3Sdoug } 374c4905cd3Sdoug 375732f1cb2Sdoug int 3769d4b5ca7Sdoug CBB_add_u16(CBB *cbb, size_t value) 377732f1cb2Sdoug { 3789d4b5ca7Sdoug if (value > UINT16_MAX) 3799d4b5ca7Sdoug return 0; 3809d4b5ca7Sdoug 3819d4b5ca7Sdoug return cbb_add_u(cbb, (uint32_t)value, 2); 382c4905cd3Sdoug } 383c4905cd3Sdoug 384732f1cb2Sdoug int 3859d4b5ca7Sdoug CBB_add_u24(CBB *cbb, size_t value) 386732f1cb2Sdoug { 3879d4b5ca7Sdoug if (value > 0xffffffUL) 3889d4b5ca7Sdoug return 0; 3899d4b5ca7Sdoug 3909d4b5ca7Sdoug return cbb_add_u(cbb, (uint32_t)value, 3); 391c4905cd3Sdoug } 392c4905cd3Sdoug 393732f1cb2Sdoug int 394732f1cb2Sdoug CBB_add_asn1_uint64(CBB *cbb, uint64_t value) 395732f1cb2Sdoug { 396c4905cd3Sdoug CBB child; 397c4905cd3Sdoug size_t i; 398c4905cd3Sdoug int started = 0; 399c4905cd3Sdoug 400732f1cb2Sdoug if (!CBB_add_asn1(cbb, &child, CBS_ASN1_INTEGER)) 401c4905cd3Sdoug return 0; 402c4905cd3Sdoug 403c4905cd3Sdoug for (i = 0; i < 8; i++) { 404c4905cd3Sdoug uint8_t byte = (value >> 8 * (7 - i)) & 0xff; 405debb3ac7Sdoug 406debb3ac7Sdoug /* 407debb3ac7Sdoug * ASN.1 restriction: first 9 bits cannot be all zeroes or 408debb3ac7Sdoug * all ones. Since this function only encodes unsigned 409debb3ac7Sdoug * integers, the only concerns are not encoding leading 410debb3ac7Sdoug * zeros and adding a padding byte if necessary. 411debb3ac7Sdoug * 412debb3ac7Sdoug * In practice, this means: 413debb3ac7Sdoug * 1) Skip leading octets of all zero bits in the value 414debb3ac7Sdoug * 2) After skipping the leading zero octets, if the next 9 415debb3ac7Sdoug * bits are all ones, add an all zero prefix octet (and 416debb3ac7Sdoug * set the high bit of the prefix octet if negative). 417debb3ac7Sdoug * 418debb3ac7Sdoug * Additionally, for an unsigned value, add an all zero 419debb3ac7Sdoug * prefix if the high bit of the first octet would be one. 420debb3ac7Sdoug */ 421c4905cd3Sdoug if (!started) { 422732f1cb2Sdoug if (byte == 0) 423c4905cd3Sdoug /* Don't encode leading zeros. */ 424c4905cd3Sdoug continue; 425732f1cb2Sdoug 426d7a08d8fSdoug /* 427d7a08d8fSdoug * If the high bit is set, add a padding byte to make it 428d7a08d8fSdoug * unsigned. 429d7a08d8fSdoug */ 430732f1cb2Sdoug if ((byte & 0x80) && !CBB_add_u8(&child, 0)) 431c4905cd3Sdoug return 0; 432732f1cb2Sdoug 433c4905cd3Sdoug started = 1; 434c4905cd3Sdoug } 435732f1cb2Sdoug if (!CBB_add_u8(&child, byte)) 436c4905cd3Sdoug return 0; 437c4905cd3Sdoug } 438c4905cd3Sdoug 439c4905cd3Sdoug /* 0 is encoded as a single 0, not the empty string. */ 440732f1cb2Sdoug if (!started && !CBB_add_u8(&child, 0)) 441c4905cd3Sdoug return 0; 442c4905cd3Sdoug 443c4905cd3Sdoug return CBB_flush(cbb); 444c4905cd3Sdoug } 445