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 */ | ||