Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 1 | /* Copyright (c) 2014, Google Inc. |
| 2 | * |
| 3 | * Permission to use, copy, modify, and/or distribute this software for any |
| 4 | * purpose with or without fee is hereby granted, provided that the above |
| 5 | * copyright notice and this permission notice appear in all copies. |
| 6 | * |
| 7 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 8 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 9 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| 10 | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 11 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 12 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 13 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| 14 | |
| 15 | #ifndef OPENSSL_HEADER_BYTESTRING_H |
| 16 | #define OPENSSL_HEADER_BYTESTRING_H |
| 17 | |
| 18 | #include <openssl/base.h> |
| 19 | |
Robert Sloan | 4562e9d | 2017-10-02 10:26:51 -0700 | [diff] [blame] | 20 | #include <openssl/span.h> |
| 21 | |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 22 | #if defined(__cplusplus) |
| 23 | extern "C" { |
| 24 | #endif |
| 25 | |
| 26 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 27 | // Bytestrings are used for parsing and building TLS and ASN.1 messages. |
| 28 | // |
| 29 | // A "CBS" (CRYPTO ByteString) represents a string of bytes in memory and |
| 30 | // provides utility functions for safely parsing length-prefixed structures |
| 31 | // like TLS and ASN.1 from it. |
| 32 | // |
| 33 | // A "CBB" (CRYPTO ByteBuilder) is a memory buffer that grows as needed and |
| 34 | // provides utility functions for building length-prefixed messages. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 35 | |
| 36 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 37 | // CRYPTO ByteString |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 38 | |
| 39 | struct cbs_st { |
| 40 | const uint8_t *data; |
| 41 | size_t len; |
Robert Sloan | 4562e9d | 2017-10-02 10:26:51 -0700 | [diff] [blame] | 42 | |
| 43 | #if !defined(BORINGSSL_NO_CXX) |
Robert Sloan | 921ef2c | 2017-10-17 09:02:20 -0700 | [diff] [blame] | 44 | // Allow implicit conversions to and from bssl::Span<const uint8_t>. |
| 45 | cbs_st(bssl::Span<const uint8_t> span) |
| 46 | : data(span.data()), len(span.size()) {} |
Robert Sloan | 4562e9d | 2017-10-02 10:26:51 -0700 | [diff] [blame] | 47 | operator bssl::Span<const uint8_t>() const { |
| 48 | return bssl::MakeConstSpan(data, len); |
| 49 | } |
Robert Sloan | 921ef2c | 2017-10-17 09:02:20 -0700 | [diff] [blame] | 50 | |
| 51 | // Defining any constructors requires we explicitly default the others. |
| 52 | cbs_st() = default; |
| 53 | cbs_st(const cbs_st &) = default; |
Robert Sloan | 4562e9d | 2017-10-02 10:26:51 -0700 | [diff] [blame] | 54 | #endif |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 55 | }; |
| 56 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 57 | // CBS_init sets |cbs| to point to |data|. It does not take ownership of |
| 58 | // |data|. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 59 | OPENSSL_EXPORT void CBS_init(CBS *cbs, const uint8_t *data, size_t len); |
| 60 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 61 | // CBS_skip advances |cbs| by |len| bytes. It returns one on success and zero |
| 62 | // otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 63 | OPENSSL_EXPORT int CBS_skip(CBS *cbs, size_t len); |
| 64 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 65 | // CBS_data returns a pointer to the contents of |cbs|. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 66 | OPENSSL_EXPORT const uint8_t *CBS_data(const CBS *cbs); |
| 67 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 68 | // CBS_len returns the number of bytes remaining in |cbs|. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 69 | OPENSSL_EXPORT size_t CBS_len(const CBS *cbs); |
| 70 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 71 | // CBS_stow copies the current contents of |cbs| into |*out_ptr| and |
| 72 | // |*out_len|. If |*out_ptr| is not NULL, the contents are freed with |
| 73 | // OPENSSL_free. It returns one on success and zero on allocation failure. On |
| 74 | // success, |*out_ptr| should be freed with OPENSSL_free. If |cbs| is empty, |
| 75 | // |*out_ptr| will be NULL. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 76 | OPENSSL_EXPORT int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len); |
| 77 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 78 | // CBS_strdup copies the current contents of |cbs| into |*out_ptr| as a |
| 79 | // NUL-terminated C string. If |*out_ptr| is not NULL, the contents are freed |
| 80 | // with OPENSSL_free. It returns one on success and zero on allocation |
| 81 | // failure. On success, |*out_ptr| should be freed with OPENSSL_free. |
| 82 | // |
| 83 | // NOTE: If |cbs| contains NUL bytes, the string will be truncated. Call |
| 84 | // |CBS_contains_zero_byte(cbs)| to check for NUL bytes. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 85 | OPENSSL_EXPORT int CBS_strdup(const CBS *cbs, char **out_ptr); |
| 86 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 87 | // CBS_contains_zero_byte returns one if the current contents of |cbs| contains |
| 88 | // a NUL byte and zero otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 89 | OPENSSL_EXPORT int CBS_contains_zero_byte(const CBS *cbs); |
| 90 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 91 | // CBS_mem_equal compares the current contents of |cbs| with the |len| bytes |
| 92 | // starting at |data|. If they're equal, it returns one, otherwise zero. If the |
| 93 | // lengths match, it uses a constant-time comparison. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 94 | OPENSSL_EXPORT int CBS_mem_equal(const CBS *cbs, const uint8_t *data, |
| 95 | size_t len); |
| 96 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 97 | // CBS_get_u8 sets |*out| to the next uint8_t from |cbs| and advances |cbs|. It |
| 98 | // returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 99 | OPENSSL_EXPORT int CBS_get_u8(CBS *cbs, uint8_t *out); |
| 100 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 101 | // CBS_get_u16 sets |*out| to the next, big-endian uint16_t from |cbs| and |
| 102 | // advances |cbs|. It returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 103 | OPENSSL_EXPORT int CBS_get_u16(CBS *cbs, uint16_t *out); |
| 104 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 105 | // CBS_get_u24 sets |*out| to the next, big-endian 24-bit value from |cbs| and |
| 106 | // advances |cbs|. It returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 107 | OPENSSL_EXPORT int CBS_get_u24(CBS *cbs, uint32_t *out); |
| 108 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 109 | // CBS_get_u32 sets |*out| to the next, big-endian uint32_t value from |cbs| |
| 110 | // and advances |cbs|. It returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 111 | OPENSSL_EXPORT int CBS_get_u32(CBS *cbs, uint32_t *out); |
| 112 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 113 | // CBS_get_last_u8 sets |*out| to the last uint8_t from |cbs| and shortens |
| 114 | // |cbs|. It returns one on success and zero on error. |
David Benjamin | 6e899c7 | 2016-06-09 18:02:18 -0400 | [diff] [blame] | 115 | OPENSSL_EXPORT int CBS_get_last_u8(CBS *cbs, uint8_t *out); |
| 116 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 117 | // CBS_get_bytes sets |*out| to the next |len| bytes from |cbs| and advances |
| 118 | // |cbs|. It returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 119 | OPENSSL_EXPORT int CBS_get_bytes(CBS *cbs, CBS *out, size_t len); |
| 120 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 121 | // CBS_copy_bytes copies the next |len| bytes from |cbs| to |out| and advances |
| 122 | // |cbs|. It returns one on success and zero on error. |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 123 | OPENSSL_EXPORT int CBS_copy_bytes(CBS *cbs, uint8_t *out, size_t len); |
| 124 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 125 | // CBS_get_u8_length_prefixed sets |*out| to the contents of an 8-bit, |
| 126 | // length-prefixed value from |cbs| and advances |cbs| over it. It returns one |
| 127 | // on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 128 | OPENSSL_EXPORT int CBS_get_u8_length_prefixed(CBS *cbs, CBS *out); |
| 129 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 130 | // CBS_get_u16_length_prefixed sets |*out| to the contents of a 16-bit, |
| 131 | // big-endian, length-prefixed value from |cbs| and advances |cbs| over it. It |
| 132 | // returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 133 | OPENSSL_EXPORT int CBS_get_u16_length_prefixed(CBS *cbs, CBS *out); |
| 134 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 135 | // CBS_get_u24_length_prefixed sets |*out| to the contents of a 24-bit, |
| 136 | // big-endian, length-prefixed value from |cbs| and advances |cbs| over it. It |
| 137 | // returns one on success and zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 138 | OPENSSL_EXPORT int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out); |
| 139 | |
| 140 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 141 | // Parsing ASN.1 |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 142 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 143 | // The following values are tag numbers for UNIVERSAL elements. |
Robert Sloan | 572a4e2 | 2017-04-17 10:52:19 -0700 | [diff] [blame] | 144 | #define CBS_ASN1_BOOLEAN 0x1u |
| 145 | #define CBS_ASN1_INTEGER 0x2u |
| 146 | #define CBS_ASN1_BITSTRING 0x3u |
| 147 | #define CBS_ASN1_OCTETSTRING 0x4u |
| 148 | #define CBS_ASN1_NULL 0x5u |
| 149 | #define CBS_ASN1_OBJECT 0x6u |
| 150 | #define CBS_ASN1_ENUMERATED 0xau |
| 151 | #define CBS_ASN1_UTF8STRING 0xcu |
| 152 | #define CBS_ASN1_SEQUENCE (0x10u | CBS_ASN1_CONSTRUCTED) |
| 153 | #define CBS_ASN1_SET (0x11u | CBS_ASN1_CONSTRUCTED) |
| 154 | #define CBS_ASN1_NUMERICSTRING 0x12u |
| 155 | #define CBS_ASN1_PRINTABLESTRING 0x13u |
| 156 | #define CBS_ASN1_T61STRING 0x14u |
| 157 | #define CBS_ASN1_VIDEOTEXSTRING 0x15u |
| 158 | #define CBS_ASN1_IA5STRING 0x16u |
| 159 | #define CBS_ASN1_UTCTIME 0x17u |
| 160 | #define CBS_ASN1_GENERALIZEDTIME 0x18u |
| 161 | #define CBS_ASN1_GRAPHICSTRING 0x19u |
| 162 | #define CBS_ASN1_VISIBLESTRING 0x1au |
| 163 | #define CBS_ASN1_GENERALSTRING 0x1bu |
| 164 | #define CBS_ASN1_UNIVERSALSTRING 0x1cu |
| 165 | #define CBS_ASN1_BMPSTRING 0x1eu |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 166 | |
Robert Sloan | 0da4395 | 2018-01-03 15:13:14 -0800 | [diff] [blame] | 167 | // CBS_ASN1_TAG_SHIFT is how much the in-memory representation shifts the class |
| 168 | // and constructed bits from the DER serialization. This allows representing tag |
| 169 | // numbers beyond 31. |
| 170 | // |
| 171 | // Consumers must use the following constants to decompose or assemble tags. |
| 172 | #define CBS_ASN1_TAG_SHIFT 24 |
| 173 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 174 | // CBS_ASN1_CONSTRUCTED may be ORed into a tag to toggle the constructed |
| 175 | // bit. |CBS| and |CBB| APIs consider the constructed bit to be part of the |
| 176 | // tag. |
Robert Sloan | 0da4395 | 2018-01-03 15:13:14 -0800 | [diff] [blame] | 177 | #define CBS_ASN1_CONSTRUCTED (0x20u << CBS_ASN1_TAG_SHIFT) |
David Benjamin | f0c4a6c | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 178 | |
Robert Sloan | 0da4395 | 2018-01-03 15:13:14 -0800 | [diff] [blame] | 179 | // The following values specify the tag class and may be ORed into a tag number |
| 180 | // to produce the final tag. If none is used, the tag will be UNIVERSAL. |
| 181 | #define CBS_ASN1_UNIVERSAL (0u << CBS_ASN1_TAG_SHIFT) |
| 182 | #define CBS_ASN1_APPLICATION (0x40u << CBS_ASN1_TAG_SHIFT) |
| 183 | #define CBS_ASN1_CONTEXT_SPECIFIC (0x80u << CBS_ASN1_TAG_SHIFT) |
| 184 | #define CBS_ASN1_PRIVATE (0xc0u << CBS_ASN1_TAG_SHIFT) |
David Benjamin | f0c4a6c | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 185 | |
Robert Sloan | 0da4395 | 2018-01-03 15:13:14 -0800 | [diff] [blame] | 186 | // CBS_ASN1_CLASS_MASK may be ANDed with a tag to query its class. This will |
| 187 | // give one of the four values above. |
| 188 | #define CBS_ASN1_CLASS_MASK (0xc0u << CBS_ASN1_TAG_SHIFT) |
David Benjamin | f0c4a6c | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 189 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 190 | // CBS_ASN1_TAG_NUMBER_MASK may be ANDed with a tag to query its number. |
Robert Sloan | 0da4395 | 2018-01-03 15:13:14 -0800 | [diff] [blame] | 191 | #define CBS_ASN1_TAG_NUMBER_MASK ((1u << (5 + CBS_ASN1_TAG_SHIFT)) - 1) |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 192 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 193 | // CBS_get_asn1 sets |*out| to the contents of DER-encoded, ASN.1 element (not |
| 194 | // including tag and length bytes) and advances |cbs| over it. The ASN.1 |
| 195 | // element must match |tag_value|. It returns one on success and zero |
| 196 | // on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 197 | OPENSSL_EXPORT int CBS_get_asn1(CBS *cbs, CBS *out, unsigned tag_value); |
| 198 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 199 | // CBS_get_asn1_element acts like |CBS_get_asn1| but |out| will include the |
| 200 | // ASN.1 header bytes too. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 201 | OPENSSL_EXPORT int CBS_get_asn1_element(CBS *cbs, CBS *out, unsigned tag_value); |
| 202 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 203 | // CBS_peek_asn1_tag looks ahead at the next ASN.1 tag and returns one |
| 204 | // if the next ASN.1 element on |cbs| would have tag |tag_value|. If |
| 205 | // |cbs| is empty or the tag does not match, it returns zero. Note: if |
| 206 | // it returns one, CBS_get_asn1 may still fail if the rest of the |
| 207 | // element is malformed. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 208 | OPENSSL_EXPORT int CBS_peek_asn1_tag(const CBS *cbs, unsigned tag_value); |
| 209 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 210 | // CBS_get_any_asn1 sets |*out| to contain the next ASN.1 element from |*cbs| |
| 211 | // (not including tag and length bytes), sets |*out_tag| to the tag number, and |
| 212 | // advances |*cbs|. It returns one on success and zero on error. Either of |out| |
| 213 | // and |out_tag| may be NULL to ignore the value. |
Steven Valdez | bb1ceac | 2016-10-07 10:34:51 -0400 | [diff] [blame] | 214 | OPENSSL_EXPORT int CBS_get_any_asn1(CBS *cbs, CBS *out, unsigned *out_tag); |
| 215 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 216 | // CBS_get_any_asn1_element sets |*out| to contain the next ASN.1 element from |
| 217 | // |*cbs| (including header bytes) and advances |*cbs|. It sets |*out_tag| to |
| 218 | // the tag number and |*out_header_len| to the length of the ASN.1 header. Each |
| 219 | // of |out|, |out_tag|, and |out_header_len| may be NULL to ignore the value. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 220 | OPENSSL_EXPORT int CBS_get_any_asn1_element(CBS *cbs, CBS *out, |
| 221 | unsigned *out_tag, |
| 222 | size_t *out_header_len); |
| 223 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 224 | // CBS_get_any_ber_asn1_element acts the same as |CBS_get_any_asn1_element| but |
| 225 | // also allows indefinite-length elements to be returned. In that case, |
| 226 | // |*out_header_len| and |CBS_len(out)| will both be two as only the header is |
| 227 | // returned, otherwise it behaves the same as the previous function. |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 228 | OPENSSL_EXPORT int CBS_get_any_ber_asn1_element(CBS *cbs, CBS *out, |
| 229 | unsigned *out_tag, |
| 230 | size_t *out_header_len); |
| 231 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 232 | // CBS_get_asn1_uint64 gets an ASN.1 INTEGER from |cbs| using |CBS_get_asn1| |
| 233 | // and sets |*out| to its value. It returns one on success and zero on error, |
| 234 | // where error includes the integer being negative, or too large to represent |
| 235 | // in 64 bits. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 236 | OPENSSL_EXPORT int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out); |
| 237 | |
Robert Sloan | 309a31e | 2018-01-29 10:22:47 -0800 | [diff] [blame] | 238 | // CBS_get_asn1_bool gets an ASN.1 BOOLEAN from |cbs| and sets |*out| to zero |
| 239 | // or one based on its value. It returns one on success or zero on error. |
| 240 | OPENSSL_EXPORT int CBS_get_asn1_bool(CBS *cbs, int *out); |
| 241 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 242 | // CBS_get_optional_asn1 gets an optional explicitly-tagged element from |cbs| |
Robert Sloan | ab8b888 | 2018-03-26 11:39:51 -0700 | [diff] [blame^] | 243 | // tagged with |tag| and sets |*out| to its contents, or ignores it if |out| is |
| 244 | // NULL. If present and if |out_present| is not NULL, it sets |*out_present| to |
| 245 | // one, otherwise zero. It returns one on success, whether or not the element |
| 246 | // was present, and zero on decode failure. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 247 | OPENSSL_EXPORT int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, |
| 248 | unsigned tag); |
| 249 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 250 | // CBS_get_optional_asn1_octet_string gets an optional |
| 251 | // explicitly-tagged OCTET STRING from |cbs|. If present, it sets |
| 252 | // |*out| to the string and |*out_present| to one. Otherwise, it sets |
| 253 | // |*out| to empty and |*out_present| to zero. |out_present| may be |
| 254 | // NULL. It returns one on success, whether or not the element was |
| 255 | // present, and zero on decode failure. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 256 | OPENSSL_EXPORT int CBS_get_optional_asn1_octet_string(CBS *cbs, CBS *out, |
| 257 | int *out_present, |
| 258 | unsigned tag); |
| 259 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 260 | // CBS_get_optional_asn1_uint64 gets an optional explicitly-tagged |
| 261 | // INTEGER from |cbs|. If present, it sets |*out| to the |
| 262 | // value. Otherwise, it sets |*out| to |default_value|. It returns one |
| 263 | // on success, whether or not the element was present, and zero on |
| 264 | // decode failure. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 265 | OPENSSL_EXPORT int CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, |
| 266 | unsigned tag, |
| 267 | uint64_t default_value); |
| 268 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 269 | // CBS_get_optional_asn1_bool gets an optional, explicitly-tagged BOOLEAN from |
| 270 | // |cbs|. If present, it sets |*out| to either zero or one, based on the |
| 271 | // boolean. Otherwise, it sets |*out| to |default_value|. It returns one on |
| 272 | // success, whether or not the element was present, and zero on decode |
| 273 | // failure. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 274 | OPENSSL_EXPORT int CBS_get_optional_asn1_bool(CBS *cbs, int *out, unsigned tag, |
| 275 | int default_value); |
| 276 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 277 | // CBS_is_valid_asn1_bitstring returns one if |cbs| is a valid ASN.1 BIT STRING |
| 278 | // and zero otherwise. |
Steven Valdez | e7531f0 | 2016-12-14 13:29:57 -0500 | [diff] [blame] | 279 | OPENSSL_EXPORT int CBS_is_valid_asn1_bitstring(const CBS *cbs); |
| 280 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 281 | // CBS_asn1_bitstring_has_bit returns one if |cbs| is a valid ASN.1 BIT STRING |
| 282 | // and the specified bit is present and set. Otherwise, it returns zero. |bit| |
| 283 | // is indexed starting from zero. |
Steven Valdez | e7531f0 | 2016-12-14 13:29:57 -0500 | [diff] [blame] | 284 | OPENSSL_EXPORT int CBS_asn1_bitstring_has_bit(const CBS *cbs, unsigned bit); |
| 285 | |
Robert Sloan | a815d5a | 2017-12-04 11:49:16 -0800 | [diff] [blame] | 286 | // CBS_asn1_oid_to_text interprets |cbs| as DER-encoded ASN.1 OBJECT IDENTIFIER |
| 287 | // contents (not including the element framing) and returns the ASCII |
| 288 | // representation (e.g., "1.2.840.113554.4.1.72585") in a newly-allocated |
| 289 | // string, or NULL on failure. The caller must release the result with |
| 290 | // |OPENSSL_free|. |
| 291 | OPENSSL_EXPORT char *CBS_asn1_oid_to_text(const CBS *cbs); |
| 292 | |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 293 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 294 | // CRYPTO ByteBuilder. |
| 295 | // |
| 296 | // |CBB| objects allow one to build length-prefixed serialisations. A |CBB| |
| 297 | // object is associated with a buffer and new buffers are created with |
| 298 | // |CBB_init|. Several |CBB| objects can point at the same buffer when a |
| 299 | // length-prefix is pending, however only a single |CBB| can be 'current' at |
| 300 | // any one time. For example, if one calls |CBB_add_u8_length_prefixed| then |
| 301 | // the new |CBB| points at the same buffer as the original. But if the original |
| 302 | // |CBB| is used then the length prefix is written out and the new |CBB| must |
| 303 | // not be used again. |
| 304 | // |
| 305 | // If one needs to force a length prefix to be written out because a |CBB| is |
| 306 | // going out of scope, use |CBB_flush|. If an operation on a |CBB| fails, it is |
| 307 | // in an undefined state and must not be used except to call |CBB_cleanup|. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 308 | |
| 309 | struct cbb_buffer_st { |
| 310 | uint8_t *buf; |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 311 | size_t len; // The number of valid bytes. |
| 312 | size_t cap; // The size of buf. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 313 | char can_resize; /* One iff |buf| is owned by this object. If not then |buf| |
| 314 | cannot be resized. */ |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 315 | char error; /* One iff there was an error writing to this CBB. All future |
| 316 | operations will fail. */ |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 317 | }; |
| 318 | |
| 319 | struct cbb_st { |
| 320 | struct cbb_buffer_st *base; |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 321 | // child points to a child CBB if a length-prefix is pending. |
Adam Langley | fad6327 | 2015-11-12 12:15:39 -0800 | [diff] [blame] | 322 | CBB *child; |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 323 | // offset is the number of bytes from the start of |base->buf| to this |CBB|'s |
| 324 | // pending length prefix. |
Adam Langley | 4139edb | 2016-01-13 15:00:54 -0800 | [diff] [blame] | 325 | size_t offset; |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 326 | // pending_len_len contains the number of bytes in this |CBB|'s pending |
| 327 | // length-prefix, or zero if no length-prefix is pending. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 328 | uint8_t pending_len_len; |
| 329 | char pending_is_asn1; |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 330 | // is_top_level is true iff this is a top-level |CBB| (as opposed to a child |
| 331 | // |CBB|). Top-level objects are valid arguments for |CBB_finish|. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 332 | char is_top_level; |
| 333 | }; |
| 334 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 335 | // CBB_zero sets an uninitialised |cbb| to the zero state. It must be |
| 336 | // initialised with |CBB_init| or |CBB_init_fixed| before use, but it is safe to |
| 337 | // call |CBB_cleanup| without a successful |CBB_init|. This may be used for more |
| 338 | // uniform cleanup of a |CBB|. |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 339 | OPENSSL_EXPORT void CBB_zero(CBB *cbb); |
| 340 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 341 | // CBB_init initialises |cbb| with |initial_capacity|. Since a |CBB| grows as |
| 342 | // needed, the |initial_capacity| is just a hint. It returns one on success or |
| 343 | // zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 344 | OPENSSL_EXPORT int CBB_init(CBB *cbb, size_t initial_capacity); |
| 345 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 346 | // CBB_init_fixed initialises |cbb| to write to |len| bytes at |buf|. Since |
| 347 | // |buf| cannot grow, trying to write more than |len| bytes will cause CBB |
| 348 | // functions to fail. It returns one on success or zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 349 | OPENSSL_EXPORT int CBB_init_fixed(CBB *cbb, uint8_t *buf, size_t len); |
| 350 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 351 | // CBB_cleanup frees all resources owned by |cbb| and other |CBB| objects |
| 352 | // writing to the same buffer. This should be used in an error case where a |
| 353 | // serialisation is abandoned. |
| 354 | // |
| 355 | // This function can only be called on a "top level" |CBB|, i.e. one initialised |
| 356 | // with |CBB_init| or |CBB_init_fixed|, or a |CBB| set to the zero state with |
| 357 | // |CBB_zero|. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 358 | OPENSSL_EXPORT void CBB_cleanup(CBB *cbb); |
| 359 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 360 | // CBB_finish completes any pending length prefix and sets |*out_data| to a |
| 361 | // malloced buffer and |*out_len| to the length of that buffer. The caller |
| 362 | // takes ownership of the buffer and, unless the buffer was fixed with |
| 363 | // |CBB_init_fixed|, must call |OPENSSL_free| when done. |
| 364 | // |
| 365 | // It can only be called on a "top level" |CBB|, i.e. one initialised with |
| 366 | // |CBB_init| or |CBB_init_fixed|. It returns one on success and zero on |
| 367 | // error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 368 | OPENSSL_EXPORT int CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len); |
| 369 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 370 | // CBB_flush causes any pending length prefixes to be written out and any child |
| 371 | // |CBB| objects of |cbb| to be invalidated. This allows |cbb| to continue to be |
| 372 | // used after the children go out of scope, e.g. when local |CBB| objects are |
| 373 | // added as children to a |CBB| that persists after a function returns. This |
| 374 | // function returns one on success or zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 375 | OPENSSL_EXPORT int CBB_flush(CBB *cbb); |
| 376 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 377 | // CBB_data returns a pointer to the bytes written to |cbb|. It does not flush |
| 378 | // |cbb|. The pointer is valid until the next operation to |cbb|. |
| 379 | // |
| 380 | // To avoid unfinalized length prefixes, it is a fatal error to call this on a |
| 381 | // CBB with any active children. |
Adam Langley | 4139edb | 2016-01-13 15:00:54 -0800 | [diff] [blame] | 382 | OPENSSL_EXPORT const uint8_t *CBB_data(const CBB *cbb); |
| 383 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 384 | // CBB_len returns the number of bytes written to |cbb|. It does not flush |
| 385 | // |cbb|. |
| 386 | // |
| 387 | // To avoid unfinalized length prefixes, it is a fatal error to call this on a |
| 388 | // CBB with any active children. |
Kenny Root | b849459 | 2015-09-25 02:29:14 +0000 | [diff] [blame] | 389 | OPENSSL_EXPORT size_t CBB_len(const CBB *cbb); |
| 390 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 391 | // CBB_add_u8_length_prefixed sets |*out_contents| to a new child of |cbb|. The |
| 392 | // data written to |*out_contents| will be prefixed in |cbb| with an 8-bit |
| 393 | // length. It returns one on success or zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 394 | OPENSSL_EXPORT int CBB_add_u8_length_prefixed(CBB *cbb, CBB *out_contents); |
| 395 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 396 | // CBB_add_u16_length_prefixed sets |*out_contents| to a new child of |cbb|. |
| 397 | // The data written to |*out_contents| will be prefixed in |cbb| with a 16-bit, |
| 398 | // big-endian length. It returns one on success or zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 399 | OPENSSL_EXPORT int CBB_add_u16_length_prefixed(CBB *cbb, CBB *out_contents); |
| 400 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 401 | // CBB_add_u24_length_prefixed sets |*out_contents| to a new child of |cbb|. |
| 402 | // The data written to |*out_contents| will be prefixed in |cbb| with a 24-bit, |
| 403 | // big-endian length. It returns one on success or zero on error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 404 | OPENSSL_EXPORT int CBB_add_u24_length_prefixed(CBB *cbb, CBB *out_contents); |
| 405 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 406 | // CBB_add_asn1 sets |*out_contents| to a |CBB| into which the contents of an |
| 407 | // ASN.1 object can be written. The |tag| argument will be used as the tag for |
Robert Sloan | 0da4395 | 2018-01-03 15:13:14 -0800 | [diff] [blame] | 408 | // the object. It returns one on success or zero on error. |
David Benjamin | f0c4a6c | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 409 | OPENSSL_EXPORT int CBB_add_asn1(CBB *cbb, CBB *out_contents, unsigned tag); |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 410 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 411 | // CBB_add_bytes appends |len| bytes from |data| to |cbb|. It returns one on |
| 412 | // success and zero otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 413 | OPENSSL_EXPORT int CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len); |
| 414 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 415 | // CBB_add_space appends |len| bytes to |cbb| and sets |*out_data| to point to |
| 416 | // the beginning of that space. The caller must then write |len| bytes of |
| 417 | // actual contents to |*out_data|. It returns one on success and zero |
| 418 | // otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 419 | OPENSSL_EXPORT int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len); |
| 420 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 421 | // CBB_reserve ensures |cbb| has room for |len| additional bytes and sets |
| 422 | // |*out_data| to point to the beginning of that space. It returns one on |
| 423 | // success and zero otherwise. The caller may write up to |len| bytes to |
| 424 | // |*out_data| and call |CBB_did_write| to complete the write. |*out_data| is |
| 425 | // valid until the next operation on |cbb| or an ancestor |CBB|. |
Adam Langley | 4139edb | 2016-01-13 15:00:54 -0800 | [diff] [blame] | 426 | OPENSSL_EXPORT int CBB_reserve(CBB *cbb, uint8_t **out_data, size_t len); |
| 427 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 428 | // CBB_did_write advances |cbb| by |len| bytes, assuming the space has been |
| 429 | // written to by the caller. It returns one on success and zero on error. |
Adam Langley | 4139edb | 2016-01-13 15:00:54 -0800 | [diff] [blame] | 430 | OPENSSL_EXPORT int CBB_did_write(CBB *cbb, size_t len); |
| 431 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 432 | // CBB_add_u8 appends an 8-bit number from |value| to |cbb|. It returns one on |
| 433 | // success and zero otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 434 | OPENSSL_EXPORT int CBB_add_u8(CBB *cbb, uint8_t value); |
| 435 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 436 | // CBB_add_u16 appends a 16-bit, big-endian number from |value| to |cbb|. It |
| 437 | // returns one on success and zero otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 438 | OPENSSL_EXPORT int CBB_add_u16(CBB *cbb, uint16_t value); |
| 439 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 440 | // CBB_add_u24 appends a 24-bit, big-endian number from |value| to |cbb|. It |
| 441 | // returns one on success and zero otherwise. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 442 | OPENSSL_EXPORT int CBB_add_u24(CBB *cbb, uint32_t value); |
| 443 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 444 | // CBB_add_u32 appends a 32-bit, big-endian number from |value| to |cbb|. It |
| 445 | // returns one on success and zero otherwise. |
David Benjamin | c895d6b | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 446 | OPENSSL_EXPORT int CBB_add_u32(CBB *cbb, uint32_t value); |
| 447 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 448 | // CBB_discard_child discards the current unflushed child of |cbb|. Neither the |
| 449 | // child's contents nor the length prefix will be included in the output. |
Kenny Root | e99801b | 2015-11-06 15:31:15 -0800 | [diff] [blame] | 450 | OPENSSL_EXPORT void CBB_discard_child(CBB *cbb); |
| 451 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 452 | // CBB_add_asn1_uint64 writes an ASN.1 INTEGER into |cbb| using |CBB_add_asn1| |
| 453 | // and writes |value| in its contents. It returns one on success and zero on |
| 454 | // error. |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 455 | OPENSSL_EXPORT int CBB_add_asn1_uint64(CBB *cbb, uint64_t value); |
| 456 | |
Robert Sloan | 309a31e | 2018-01-29 10:22:47 -0800 | [diff] [blame] | 457 | // CBB_add_asn1_octet_string writes an ASN.1 OCTET STRING into |cbb| with the |
| 458 | // given contents. It returns one on success and zero on error. |
| 459 | OPENSSL_EXPORT int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, |
| 460 | size_t data_len); |
| 461 | |
| 462 | // CBB_add_asn1_bool writes an ASN.1 BOOLEAN into |cbb| which is true iff |
| 463 | // |value| is non-zero. It returns one on success and zero on error. |
| 464 | OPENSSL_EXPORT int CBB_add_asn1_bool(CBB *cbb, int value); |
| 465 | |
Robert Sloan | a815d5a | 2017-12-04 11:49:16 -0800 | [diff] [blame] | 466 | // CBB_add_asn1_oid_from_text decodes |len| bytes from |text| as an ASCII OID |
| 467 | // representation, e.g. "1.2.840.113554.4.1.72585", and writes the DER-encoded |
| 468 | // contents to |cbb|. It returns one on success and zero on malloc failure or if |
| 469 | // |text| was invalid. It does not include the OBJECT IDENTIFER framing, only |
| 470 | // the element's contents. |
| 471 | // |
| 472 | // This function considers OID strings with components which do not fit in a |
| 473 | // |uint64_t| to be invalid. |
| 474 | OPENSSL_EXPORT int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, |
| 475 | size_t len); |
| 476 | |
Robert Sloan | a450c92 | 2018-01-08 10:35:32 -0800 | [diff] [blame] | 477 | // CBB_flush_asn1_set_of calls |CBB_flush| on |cbb| and then reorders the |
| 478 | // contents for a DER-encoded ASN.1 SET OF type. It returns one on success and |
| 479 | // zero on failure. DER canonicalizes SET OF contents by sorting |
| 480 | // lexicographically by encoding. Call this function when encoding a SET OF |
| 481 | // type in an order that is not already known to be canonical. |
| 482 | // |
| 483 | // Note a SET type has a slightly different ordering than a SET OF. |
| 484 | OPENSSL_EXPORT int CBB_flush_asn1_set_of(CBB *cbb); |
| 485 | |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 486 | |
| 487 | #if defined(__cplusplus) |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 488 | } // extern C |
David Benjamin | f0c4a6c | 2016-08-11 13:26:41 -0400 | [diff] [blame] | 489 | |
| 490 | |
| 491 | #if !defined(BORINGSSL_NO_CXX) |
| 492 | extern "C++" { |
| 493 | |
| 494 | namespace bssl { |
| 495 | |
| 496 | using ScopedCBB = internal::StackAllocated<CBB, void, CBB_zero, CBB_cleanup>; |
| 497 | |
| 498 | } // namespace bssl |
| 499 | |
| 500 | } // extern C++ |
| 501 | #endif |
| 502 | |
Adam Langley | d9e397b | 2015-01-22 14:27:53 -0800 | [diff] [blame] | 503 | #endif |
| 504 | |
Robert Sloan | 8f860b1 | 2017-08-28 07:37:06 -0700 | [diff] [blame] | 505 | #endif // OPENSSL_HEADER_BYTESTRING_H |