diff options
Diffstat (limited to 'src/lib/libssl/bytestring.h')
| -rw-r--r-- | src/lib/libssl/bytestring.h | 511 |
1 files changed, 0 insertions, 511 deletions
diff --git a/src/lib/libssl/bytestring.h b/src/lib/libssl/bytestring.h deleted file mode 100644 index 8ea84005b4..0000000000 --- a/src/lib/libssl/bytestring.h +++ /dev/null | |||
| @@ -1,511 +0,0 @@ | |||
| 1 | /* $OpenBSD: bytestring.h,v 1.14 2015/06/19 00:23:36 doug Exp $ */ | ||
| 2 | /* | ||
| 3 | * Copyright (c) 2014, Google Inc. | ||
| 4 | * | ||
| 5 | * Permission to use, copy, modify, and/or distribute this software for any | ||
| 6 | * purpose with or without fee is hereby granted, provided that the above | ||
| 7 | * copyright notice and this permission notice appear in all copies. | ||
| 8 | * | ||
| 9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | ||
| 10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | ||
| 11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY | ||
| 12 | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | ||
| 13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION | ||
| 14 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN | ||
| 15 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ | ||
| 16 | |||
| 17 | #ifndef OPENSSL_HEADER_BYTESTRING_H | ||
| 18 | #define OPENSSL_HEADER_BYTESTRING_H | ||
| 19 | |||
| 20 | #if defined(__cplusplus) | ||
| 21 | extern "C" { | ||
| 22 | #endif | ||
| 23 | |||
| 24 | #include <sys/types.h> | ||
| 25 | #include <stdint.h> | ||
| 26 | |||
| 27 | #include <openssl/opensslconf.h> | ||
| 28 | |||
| 29 | /* | ||
| 30 | * Bytestrings are used for parsing and building TLS and ASN.1 messages. | ||
| 31 | * | ||
| 32 | * A "CBS" (CRYPTO ByteString) represents a string of bytes in memory and | ||
| 33 | * provides utility functions for safely parsing length-prefixed structures | ||
| 34 | * like TLS and ASN.1 from it. | ||
| 35 | * | ||
| 36 | * A "CBB" (CRYPTO ByteBuilder) is a memory buffer that grows as needed and | ||
| 37 | * provides utility functions for building length-prefixed messages. | ||
| 38 | */ | ||
| 39 | |||
| 40 | /* CRYPTO ByteString */ | ||
| 41 | typedef struct cbs_st { | ||
| 42 | const uint8_t *data; | ||
| 43 | size_t initial_len; | ||
| 44 | size_t len; | ||
| 45 | } CBS; | ||
| 46 | |||
| 47 | /* | ||
| 48 | * CBS_init sets |cbs| to point to |data|. It does not take ownership of | ||
| 49 | * |data|. | ||
| 50 | */ | ||
| 51 | void CBS_init(CBS *cbs, const uint8_t *data, size_t len); | ||
| 52 | |||
| 53 | /* | ||
| 54 | * CBS_skip advances |cbs| by |len| bytes. It returns one on success and zero | ||
| 55 | * otherwise. | ||
| 56 | */ | ||
| 57 | int CBS_skip(CBS *cbs, size_t len); | ||
| 58 | |||
| 59 | /* | ||
| 60 | * CBS_data returns a pointer to the contents of |cbs|. | ||
| 61 | */ | ||
| 62 | const uint8_t *CBS_data(const CBS *cbs); | ||
| 63 | |||
| 64 | /* | ||
| 65 | * CBS_len returns the number of bytes remaining in |cbs|. | ||
| 66 | */ | ||
| 67 | size_t CBS_len(const CBS *cbs); | ||
| 68 | |||
| 69 | /* | ||
| 70 | * CBS_offset returns the current offset into the original data of |cbs|. | ||
| 71 | */ | ||
| 72 | size_t CBS_offset(const CBS *cbs); | ||
| 73 | |||
| 74 | /* | ||
| 75 | * CBS_stow copies the current contents of |cbs| into |*out_ptr| and | ||
| 76 | * |*out_len|. If |*out_ptr| is not NULL, the contents are freed with | ||
| 77 | * free. It returns one on success and zero on allocation failure. On | ||
| 78 | * success, |*out_ptr| should be freed with free. If |cbs| is empty, | ||
| 79 | * |*out_ptr| will be NULL. | ||
| 80 | */ | ||
| 81 | int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len); | ||
| 82 | |||
| 83 | /* | ||
| 84 | * CBS_strdup copies the current contents of |cbs| into |*out_ptr| as a | ||
| 85 | * NUL-terminated C string. If |*out_ptr| is not NULL, the contents are freed | ||
| 86 | * with free. It returns one on success and zero on allocation | ||
| 87 | * failure. On success, |*out_ptr| should be freed with free. | ||
| 88 | * | ||
| 89 | * NOTE: If |cbs| contains NUL bytes, the string will be truncated. Call | ||
| 90 | * |CBS_contains_zero_byte(cbs)| to check for NUL bytes. | ||
| 91 | */ | ||
| 92 | int CBS_strdup(const CBS *cbs, char **out_ptr); | ||
| 93 | |||
| 94 | /* | ||
| 95 | * CBS_write_bytes writes all of the remaining data from |cbs| into |dst| | ||
| 96 | * if it is at most |dst_len| bytes. If |copied| is not NULL, it will be set | ||
| 97 | * to the amount copied. It returns one on success and zero otherwise. | ||
| 98 | */ | ||
| 99 | int CBS_write_bytes(const CBS *cbs, uint8_t *dst, size_t dst_len, | ||
| 100 | size_t *copied); | ||
| 101 | |||
| 102 | /* | ||
| 103 | * CBS_contains_zero_byte returns one if the current contents of |cbs| contains | ||
| 104 | * a NUL byte and zero otherwise. | ||
| 105 | */ | ||
| 106 | int CBS_contains_zero_byte(const CBS *cbs); | ||
| 107 | |||
| 108 | /* | ||
| 109 | * CBS_mem_equal compares the current contents of |cbs| with the |len| bytes | ||
| 110 | * starting at |data|. If they're equal, it returns one, otherwise zero. If the | ||
| 111 | * lengths match, it uses a constant-time comparison. | ||
| 112 | */ | ||
| 113 | int CBS_mem_equal(const CBS *cbs, const uint8_t *data, size_t len); | ||
| 114 | |||
| 115 | /* | ||
| 116 | * CBS_get_u8 sets |*out| to the next uint8_t from |cbs| and advances |cbs|. It | ||
| 117 | * returns one on success and zero on error. | ||
| 118 | */ | ||
| 119 | int CBS_get_u8(CBS *cbs, uint8_t *out); | ||
| 120 | |||
| 121 | /* | ||
| 122 | * CBS_get_u16 sets |*out| to the next, big-endian uint16_t from |cbs| and | ||
| 123 | * advances |cbs|. It returns one on success and zero on error. | ||
| 124 | */ | ||
| 125 | int CBS_get_u16(CBS *cbs, uint16_t *out); | ||
| 126 | |||
| 127 | /* | ||
| 128 | * CBS_get_u24 sets |*out| to the next, big-endian 24-bit value from |cbs| and | ||
| 129 | * advances |cbs|. It returns one on success and zero on error. | ||
| 130 | */ | ||
| 131 | int CBS_get_u24(CBS *cbs, uint32_t *out); | ||
| 132 | |||
| 133 | /* | ||
| 134 | * CBS_get_u32 sets |*out| to the next, big-endian uint32_t value from |cbs| | ||
| 135 | * and advances |cbs|. It returns one on success and zero on error. | ||
| 136 | */ | ||
| 137 | int CBS_get_u32(CBS *cbs, uint32_t *out); | ||
| 138 | |||
| 139 | /* | ||
| 140 | * CBS_get_bytes sets |*out| to the next |len| bytes from |cbs| and advances | ||
| 141 | * |cbs|. It returns one on success and zero on error. | ||
| 142 | */ | ||
| 143 | int CBS_get_bytes(CBS *cbs, CBS *out, size_t len); | ||
| 144 | |||
| 145 | /* | ||
| 146 | * CBS_get_u8_length_prefixed sets |*out| to the contents of an 8-bit, | ||
| 147 | * length-prefixed value from |cbs| and advances |cbs| over it. It returns one | ||
| 148 | * on success and zero on error. | ||
| 149 | */ | ||
| 150 | int CBS_get_u8_length_prefixed(CBS *cbs, CBS *out); | ||
| 151 | |||
| 152 | /* | ||
| 153 | * CBS_get_u16_length_prefixed sets |*out| to the contents of a 16-bit, | ||
| 154 | * big-endian, length-prefixed value from |cbs| and advances |cbs| over it. It | ||
| 155 | * returns one on success and zero on error. | ||
| 156 | */ | ||
| 157 | int CBS_get_u16_length_prefixed(CBS *cbs, CBS *out); | ||
| 158 | |||
| 159 | /* | ||
| 160 | * CBS_get_u24_length_prefixed sets |*out| to the contents of a 24-bit, | ||
| 161 | * big-endian, length-prefixed value from |cbs| and advances |cbs| over it. It | ||
| 162 | * returns one on success and zero on error. | ||
| 163 | */ | ||
| 164 | int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out); | ||
| 165 | |||
| 166 | |||
| 167 | /* Parsing ASN.1 */ | ||
| 168 | |||
| 169 | /* | ||
| 170 | * While an identifier can be multiple octets, this library only handles the | ||
| 171 | * single octet variety currently. This limits support up to tag number 30 | ||
| 172 | * since tag number 31 is a reserved value to indicate multiple octets. | ||
| 173 | */ | ||
| 174 | |||
| 175 | /* Bits 8 and 7: class tag type: See X.690 section 8.1.2.2. */ | ||
| 176 | #define CBS_ASN1_UNIVERSAL 0x00 | ||
| 177 | #define CBS_ASN1_APPLICATION 0x40 | ||
| 178 | #define CBS_ASN1_CONTEXT_SPECIFIC 0x80 | ||
| 179 | #define CBS_ASN1_PRIVATE 0xc0 | ||
| 180 | |||
| 181 | /* Bit 6: Primitive or constructed: See X.690 section 8.1.2.3. */ | ||
| 182 | #define CBS_ASN1_PRIMITIVE 0x00 | ||
| 183 | #define CBS_ASN1_CONSTRUCTED 0x20 | ||
| 184 | |||
| 185 | /* | ||
| 186 | * Bits 5 to 1 are the tag number. See X.680 section 8.6 for tag numbers of | ||
| 187 | * the universal class. | ||
| 188 | */ | ||
| 189 | |||
| 190 | /* | ||
| 191 | * Common universal identifier octets. | ||
| 192 | * See X.690 section 8.1 and X.680 section 8.6 for universal tag numbers. | ||
| 193 | * | ||
| 194 | * Note: These definitions are the cause of some of the strange behavior in | ||
| 195 | * CBS's bs_ber.c. | ||
| 196 | * | ||
| 197 | * In BER, it is the sender's option to use primitive or constructed for | ||
| 198 | * bitstring (X.690 section 8.6.1) and octetstring (X.690 section 8.7.1). | ||
| 199 | * | ||
| 200 | * In DER, bitstring and octetstring are required to be primitive | ||
| 201 | * (X.690 section 10.2). | ||
| 202 | */ | ||
| 203 | #define CBS_ASN1_BOOLEAN (CBS_ASN1_UNIVERSAL | CBS_ASN1_PRIMITIVE | 0x1) | ||
| 204 | #define CBS_ASN1_INTEGER (CBS_ASN1_UNIVERSAL | CBS_ASN1_PRIMITIVE | 0x2) | ||
| 205 | #define CBS_ASN1_BITSTRING (CBS_ASN1_UNIVERSAL | CBS_ASN1_PRIMITIVE | 0x3) | ||
| 206 | #define CBS_ASN1_OCTETSTRING (CBS_ASN1_UNIVERSAL | CBS_ASN1_PRIMITIVE | 0x4) | ||
| 207 | #define CBS_ASN1_OBJECT (CBS_ASN1_UNIVERSAL | CBS_ASN1_PRIMITIVE | 0x6) | ||
| 208 | #define CBS_ASN1_ENUMERATED (CBS_ASN1_UNIVERSAL | CBS_ASN1_PRIMITIVE | 0xa) | ||
| 209 | #define CBS_ASN1_SEQUENCE (CBS_ASN1_UNIVERSAL | CBS_ASN1_CONSTRUCTED | 0x10) | ||
| 210 | #define CBS_ASN1_SET (CBS_ASN1_UNIVERSAL | CBS_ASN1_CONSTRUCTED | 0x11) | ||
| 211 | |||
| 212 | /* | ||
| 213 | * CBS_get_asn1 sets |*out| to the contents of DER-encoded, ASN.1 element (not | ||
| 214 | * including tag and length bytes) and advances |cbs| over it. The ASN.1 | ||
| 215 | * element must match |tag_value|. It returns one on success and zero | ||
| 216 | * on error. | ||
| 217 | * | ||
| 218 | * Tag numbers greater than 30 are not supported (i.e. short form only). | ||
| 219 | */ | ||
| 220 | int CBS_get_asn1(CBS *cbs, CBS *out, unsigned int tag_value); | ||
| 221 | |||
| 222 | /* | ||
| 223 | * CBS_get_asn1_element acts like |CBS_get_asn1| but |out| will include the | ||
| 224 | * ASN.1 header bytes too. | ||
| 225 | */ | ||
| 226 | int CBS_get_asn1_element(CBS *cbs, CBS *out, unsigned int tag_value); | ||
| 227 | |||
| 228 | /* | ||
| 229 | * CBS_peek_asn1_tag looks ahead at the next ASN.1 tag and returns one | ||
| 230 | * if the next ASN.1 element on |cbs| would have tag |tag_value|. If | ||
| 231 | * |cbs| is empty or the tag does not match, it returns zero. Note: if | ||
| 232 | * it returns one, CBS_get_asn1 may still fail if the rest of the | ||
| 233 | * element is malformed. | ||
| 234 | */ | ||
| 235 | int CBS_peek_asn1_tag(const CBS *cbs, unsigned int tag_value); | ||
| 236 | |||
| 237 | /* | ||
| 238 | * CBS_get_any_asn1_element sets |*out| to contain the next ASN.1 element from | ||
| 239 | * |*cbs| (including header bytes) and advances |*cbs|. It sets |*out_tag| to | ||
| 240 | * the tag number and |*out_header_len| to the length of the ASN.1 header. | ||
| 241 | * Each of |out|, |out_tag|, and |out_header_len| may be NULL to ignore | ||
| 242 | * the value. | ||
| 243 | * | ||
| 244 | * Tag numbers greater than 30 are not supported (i.e. short form only). | ||
| 245 | */ | ||
| 246 | int CBS_get_any_asn1_element(CBS *cbs, CBS *out, unsigned int *out_tag, | ||
| 247 | size_t *out_header_len); | ||
| 248 | |||
| 249 | /* | ||
| 250 | * CBS_get_asn1_uint64 gets an ASN.1 INTEGER from |cbs| using |CBS_get_asn1| | ||
| 251 | * and sets |*out| to its value. It returns one on success and zero on error, | ||
| 252 | * where error includes the integer being negative, or too large to represent | ||
| 253 | * in 64 bits. | ||
| 254 | */ | ||
| 255 | int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out); | ||
| 256 | |||
| 257 | /* | ||
| 258 | * CBS_get_optional_asn1 gets an optional explicitly-tagged element | ||
| 259 | * from |cbs| tagged with |tag| and sets |*out| to its contents. If | ||
| 260 | * present, it sets |*out_present| to one, otherwise zero. It returns | ||
| 261 | * one on success, whether or not the element was present, and zero on | ||
| 262 | * decode failure. | ||
| 263 | */ | ||
| 264 | int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, | ||
| 265 | unsigned int tag); | ||
| 266 | |||
| 267 | /* | ||
| 268 | * CBS_get_optional_asn1_octet_string gets an optional | ||
| 269 | * explicitly-tagged OCTET STRING from |cbs|. If present, it sets | ||
| 270 | * |*out| to the string and |*out_present| to one. Otherwise, it sets | ||
| 271 | * |*out| to empty and |*out_present| to zero. |out_present| may be | ||
| 272 | * NULL. It returns one on success, whether or not the element was | ||
| 273 | * present, and zero on decode failure. | ||
| 274 | */ | ||
| 275 | int CBS_get_optional_asn1_octet_string(CBS *cbs, CBS *out, int *out_present, | ||
| 276 | unsigned int tag); | ||
| 277 | |||
| 278 | /* | ||
| 279 | * CBS_get_optional_asn1_uint64 gets an optional explicitly-tagged | ||
| 280 | * INTEGER from |cbs|. If present, it sets |*out| to the | ||
| 281 | * value. Otherwise, it sets |*out| to |default_value|. It returns one | ||
| 282 | * on success, whether or not the element was present, and zero on | ||
| 283 | * decode failure. | ||
| 284 | */ | ||
| 285 | int CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, unsigned int tag, | ||
| 286 | uint64_t default_value); | ||
| 287 | |||
| 288 | /* | ||
| 289 | * CBS_get_optional_asn1_bool gets an optional, explicitly-tagged BOOLEAN from | ||
| 290 | * |cbs|. If present, it sets |*out| to either zero or one, based on the | ||
| 291 | * boolean. Otherwise, it sets |*out| to |default_value|. It returns one on | ||
| 292 | * success, whether or not the element was present, and zero on decode | ||
| 293 | * failure. | ||
| 294 | */ | ||
| 295 | int CBS_get_optional_asn1_bool(CBS *cbs, int *out, unsigned int tag, | ||
| 296 | int default_value); | ||
| 297 | |||
| 298 | |||
| 299 | /* | ||
| 300 | * CRYPTO ByteBuilder. | ||
| 301 | * | ||
| 302 | * |CBB| objects allow one to build length-prefixed serialisations. A |CBB| | ||
| 303 | * object is associated with a buffer and new buffers are created with | ||
| 304 | * |CBB_init|. Several |CBB| objects can point at the same buffer when a | ||
| 305 | * length-prefix is pending, however only a single |CBB| can be 'current' at | ||
| 306 | * any one time. For example, if one calls |CBB_add_u8_length_prefixed| then | ||
| 307 | * the new |CBB| points at the same buffer as the original. But if the original | ||
| 308 | * |CBB| is used then the length prefix is written out and the new |CBB| must | ||
| 309 | * not be used again. | ||
| 310 | * | ||
| 311 | * If one needs to force a length prefix to be written out because a |CBB| is | ||
| 312 | * going out of scope, use |CBB_flush|. | ||
| 313 | */ | ||
| 314 | |||
| 315 | struct cbb_buffer_st { | ||
| 316 | uint8_t *buf; | ||
| 317 | |||
| 318 | /* The number of valid bytes. */ | ||
| 319 | size_t len; | ||
| 320 | |||
| 321 | /* The size of buf. */ | ||
| 322 | size_t cap; | ||
| 323 | |||
| 324 | /* | ||
| 325 | * One iff |buf| is owned by this object. If not then |buf| cannot be | ||
| 326 | * resized. | ||
| 327 | */ | ||
| 328 | char can_resize; | ||
| 329 | }; | ||
| 330 | |||
| 331 | typedef struct cbb_st { | ||
| 332 | struct cbb_buffer_st *base; | ||
| 333 | |||
| 334 | /* | ||
| 335 | * offset is the offset from the start of |base->buf| to the position of any | ||
| 336 | * pending length-prefix. | ||
| 337 | */ | ||
| 338 | size_t offset; | ||
| 339 | |||
| 340 | /* child points to a child CBB if a length-prefix is pending. */ | ||
| 341 | struct cbb_st *child; | ||
| 342 | |||
| 343 | /* | ||
| 344 | * pending_len_len contains the number of bytes in a pending length-prefix, | ||
| 345 | * or zero if no length-prefix is pending. | ||
| 346 | */ | ||
| 347 | uint8_t pending_len_len; | ||
| 348 | |||
| 349 | char pending_is_asn1; | ||
| 350 | |||
| 351 | /* | ||
| 352 | * is_top_level is true iff this is a top-level |CBB| (as opposed to a child | ||
| 353 | * |CBB|). Top-level objects are valid arguments for |CBB_finish|. | ||
| 354 | */ | ||
| 355 | char is_top_level; | ||
| 356 | } CBB; | ||
| 357 | |||
| 358 | /* | ||
| 359 | * CBB_init initialises |cbb| with |initial_capacity|. Since a |CBB| grows as | ||
| 360 | * needed, the |initial_capacity| is just a hint. It returns one on success or | ||
| 361 | * zero on error. | ||
| 362 | */ | ||
| 363 | int CBB_init(CBB *cbb, size_t initial_capacity); | ||
| 364 | |||
| 365 | /* | ||
| 366 | * CBB_init_fixed initialises |cbb| to write to |len| bytes at |buf|. Since | ||
| 367 | * |buf| cannot grow, trying to write more than |len| bytes will cause CBB | ||
| 368 | * functions to fail. It returns one on success or zero on error. | ||
| 369 | */ | ||
| 370 | int CBB_init_fixed(CBB *cbb, uint8_t *buf, size_t len); | ||
| 371 | |||
| 372 | /* | ||
| 373 | * CBB_cleanup frees all resources owned by |cbb| and other |CBB| objects | ||
| 374 | * writing to the same buffer. This should be used in an error case where a | ||
| 375 | * serialisation is abandoned. | ||
| 376 | */ | ||
| 377 | void CBB_cleanup(CBB *cbb); | ||
| 378 | |||
| 379 | /* | ||
| 380 | * CBB_finish completes any pending length prefix and sets |*out_data| to a | ||
| 381 | * malloced buffer and |*out_len| to the length of that buffer. The caller | ||
| 382 | * takes ownership of the buffer and, unless the buffer was fixed with | ||
| 383 | * |CBB_init_fixed|, must call |free| when done. | ||
| 384 | * | ||
| 385 | * It can only be called on a "top level" |CBB|, i.e. one initialised with | ||
| 386 | * |CBB_init| or |CBB_init_fixed|. It returns one on success and zero on | ||
| 387 | * error. | ||
| 388 | */ | ||
| 389 | int CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len); | ||
| 390 | |||
| 391 | /* | ||
| 392 | * CBB_flush causes any pending length prefixes to be written out and any child | ||
| 393 | * |CBB| objects of |cbb| to be invalidated. It returns one on success or zero | ||
| 394 | * on error. | ||
| 395 | */ | ||
| 396 | int CBB_flush(CBB *cbb); | ||
| 397 | |||
| 398 | /* | ||
| 399 | * CBB_add_u8_length_prefixed sets |*out_contents| to a new child of |cbb|. The | ||
| 400 | * data written to |*out_contents| will be prefixed in |cbb| with an 8-bit | ||
| 401 | * length. It returns one on success or zero on error. | ||
| 402 | */ | ||
| 403 | int CBB_add_u8_length_prefixed(CBB *cbb, CBB *out_contents); | ||
| 404 | |||
| 405 | /* | ||
| 406 | * CBB_add_u16_length_prefixed sets |*out_contents| to a new child of |cbb|. | ||
| 407 | * The data written to |*out_contents| will be prefixed in |cbb| with a 16-bit, | ||
| 408 | * big-endian length. It returns one on success or zero on error. | ||
| 409 | */ | ||
| 410 | int CBB_add_u16_length_prefixed(CBB *cbb, CBB *out_contents); | ||
| 411 | |||
| 412 | /* | ||
| 413 | * CBB_add_u24_length_prefixed sets |*out_contents| to a new child of |cbb|. | ||
| 414 | * The data written to |*out_contents| will be prefixed in |cbb| with a 24-bit, | ||
| 415 | * big-endian length. It returns one on success or zero on error. | ||
| 416 | */ | ||
| 417 | int CBB_add_u24_length_prefixed(CBB *cbb, CBB *out_contents); | ||
| 418 | |||
| 419 | /* | ||
| 420 | * CBB_add_asn sets |*out_contents| to a |CBB| into which the contents of an | ||
| 421 | * ASN.1 object can be written. The |tag| argument will be used as the tag for | ||
| 422 | * the object. Passing in |tag| number 31 will return in an error since only | ||
| 423 | * single octet identifiers are supported. It returns one on success or zero | ||
| 424 | * on error. | ||
| 425 | */ | ||
| 426 | int CBB_add_asn1(CBB *cbb, CBB *out_contents, unsigned int tag); | ||
| 427 | |||
| 428 | /* | ||
| 429 | * CBB_add_bytes appends |len| bytes from |data| to |cbb|. It returns one on | ||
| 430 | * success and zero otherwise. | ||
| 431 | */ | ||
| 432 | int CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len); | ||
| 433 | |||
| 434 | /* | ||
| 435 | * CBB_add_space appends |len| bytes to |cbb| and sets |*out_data| to point to | ||
| 436 | * the beginning of that space. The caller must then write |len| bytes of | ||
| 437 | * actual contents to |*out_data|. It returns one on success and zero | ||
| 438 | * otherwise. | ||
| 439 | */ | ||
| 440 | int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len); | ||
| 441 | |||
| 442 | /* | ||
| 443 | * CBB_add_u8 appends an 8-bit number from |value| to |cbb|. It returns one on | ||
| 444 | * success and zero otherwise. | ||
| 445 | */ | ||
| 446 | int CBB_add_u8(CBB *cbb, size_t value); | ||
| 447 | |||
| 448 | /* | ||
| 449 | * CBB_add_u8 appends a 16-bit, big-endian number from |value| to |cbb|. It | ||
| 450 | * returns one on success and zero otherwise. | ||
| 451 | */ | ||
| 452 | int CBB_add_u16(CBB *cbb, size_t value); | ||
| 453 | |||
| 454 | /* | ||
| 455 | * CBB_add_u24 appends a 24-bit, big-endian number from |value| to |cbb|. It | ||
| 456 | * returns one on success and zero otherwise. | ||
| 457 | */ | ||
| 458 | int CBB_add_u24(CBB *cbb, size_t value); | ||
| 459 | |||
| 460 | /* | ||
| 461 | * CBB_add_asn1_uint64 writes an ASN.1 INTEGER into |cbb| using |CBB_add_asn1| | ||
| 462 | * and writes |value| in its contents. It returns one on success and zero on | ||
| 463 | * error. | ||
| 464 | */ | ||
| 465 | int CBB_add_asn1_uint64(CBB *cbb, uint64_t value); | ||
| 466 | |||
| 467 | #ifdef LIBRESSL_INTERNAL | ||
| 468 | /* | ||
| 469 | * CBS_dup sets |out| to point to cbs's |data| and |len|. It results in two | ||
| 470 | * CBS that point to the same buffer. | ||
| 471 | */ | ||
| 472 | void CBS_dup(const CBS *cbs, CBS *out); | ||
| 473 | |||
| 474 | /* | ||
| 475 | * cbs_get_any_asn1_element sets |*out| to contain the next ASN.1 element from | ||
| 476 | * |*cbs| (including header bytes) and advances |*cbs|. It sets |*out_tag| to | ||
| 477 | * the tag number and |*out_header_len| to the length of the ASN.1 header. If | ||
| 478 | * strict mode is disabled and the element has indefinite length then |*out| | ||
| 479 | * will only contain the header. Each of |out|, |out_tag|, and | ||
| 480 | * |out_header_len| may be NULL to ignore the value. | ||
| 481 | * | ||
| 482 | * Tag numbers greater than 30 are not supported (i.e. short form only). | ||
| 483 | */ | ||
| 484 | int cbs_get_any_asn1_element_internal(CBS *cbs, CBS *out, unsigned int *out_tag, | ||
| 485 | size_t *out_header_len, int strict); | ||
| 486 | |||
| 487 | /* | ||
| 488 | * CBS_asn1_indefinite_to_definite reads an ASN.1 structure from |in|. If it | ||
| 489 | * finds indefinite-length elements that otherwise appear to be valid DER, it | ||
| 490 | * attempts to convert the DER-like data to DER and sets |*out| and | ||
| 491 | * |*out_length| to describe a malloced buffer containing the DER data. | ||
| 492 | * Additionally, |*in| will be advanced over the ASN.1 data. | ||
| 493 | * | ||
| 494 | * If it doesn't find any indefinite-length elements then it sets |*out| to | ||
| 495 | * NULL and |*in| is unmodified. | ||
| 496 | * | ||
| 497 | * This is NOT a conversion from BER to DER. There are many restrictions when | ||
| 498 | * dealing with DER data. This is only concerned with one: indefinite vs. | ||
| 499 | * definite form. However, this suffices to handle the PKCS#7 and PKCS#12 output | ||
| 500 | * from NSS. | ||
| 501 | * | ||
| 502 | * It returns one on success and zero otherwise. | ||
| 503 | */ | ||
| 504 | int CBS_asn1_indefinite_to_definite(CBS *in, uint8_t **out, size_t *out_len); | ||
| 505 | #endif /* LIBRESSL_INTERNAL */ | ||
| 506 | |||
| 507 | #if defined(__cplusplus) | ||
| 508 | } /* extern C */ | ||
| 509 | #endif | ||
| 510 | |||
| 511 | #endif /* OPENSSL_HEADER_BYTESTRING_H */ | ||
