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 #include <openssl/buf.h> 16 #include <openssl/mem.h> 17 #include <openssl/bytestring.h> 18 19 #include <assert.h> 20 #include <string.h> 21 22 #include "internal.h" 23 #include "../internal.h" 24 25 26 void CBS_init(CBS *cbs, const uint8_t *data, size_t len) { 27 cbs->data = data; 28 cbs->len = len; 29 } 30 31 static int cbs_get(CBS *cbs, const uint8_t **p, size_t n) { 32 if (cbs->len < n) { 33 return 0; 34 } 35 36 *p = cbs->data; 37 cbs->data += n; 38 cbs->len -= n; 39 return 1; 40 } 41 42 int CBS_skip(CBS *cbs, size_t len) { 43 const uint8_t *dummy; 44 return cbs_get(cbs, &dummy, len); 45 } 46 47 const uint8_t *CBS_data(const CBS *cbs) { 48 return cbs->data; 49 } 50 51 size_t CBS_len(const CBS *cbs) { 52 return cbs->len; 53 } 54 55 int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len) { 56 OPENSSL_free(*out_ptr); 57 *out_ptr = NULL; 58 *out_len = 0; 59 60 if (cbs->len == 0) { 61 return 1; 62 } 63 *out_ptr = BUF_memdup(cbs->data, cbs->len); 64 if (*out_ptr == NULL) { 65 return 0; 66 } 67 *out_len = cbs->len; 68 return 1; 69 } 70 71 int CBS_strdup(const CBS *cbs, char **out_ptr) { 72 if (*out_ptr != NULL) { 73 OPENSSL_free(*out_ptr); 74 } 75 *out_ptr = BUF_strndup((const char*)cbs->data, cbs->len); 76 return (*out_ptr != NULL); 77 } 78 79 int CBS_contains_zero_byte(const CBS *cbs) { 80 return OPENSSL_memchr(cbs->data, 0, cbs->len) != NULL; 81 } 82 83 int CBS_mem_equal(const CBS *cbs, const uint8_t *data, size_t len) { 84 if (len != cbs->len) { 85 return 0; 86 } 87 return CRYPTO_memcmp(cbs->data, data, len) == 0; 88 } 89 90 static int cbs_get_u(CBS *cbs, uint32_t *out, size_t len) { 91 uint32_t result = 0; 92 const uint8_t *data; 93 94 if (!cbs_get(cbs, &data, len)) { 95 return 0; 96 } 97 for (size_t i = 0; i < len; i++) { 98 result <<= 8; 99 result |= data[i]; 100 } 101 *out = result; 102 return 1; 103 } 104 105 int CBS_get_u8(CBS *cbs, uint8_t *out) { 106 const uint8_t *v; 107 if (!cbs_get(cbs, &v, 1)) { 108 return 0; 109 } 110 *out = *v; 111 return 1; 112 } 113 114 int CBS_get_u16(CBS *cbs, uint16_t *out) { 115 uint32_t v; 116 if (!cbs_get_u(cbs, &v, 2)) { 117 return 0; 118 } 119 *out = v; 120 return 1; 121 } 122 123 int CBS_get_u24(CBS *cbs, uint32_t *out) { 124 return cbs_get_u(cbs, out, 3); 125 } 126 127 int CBS_get_u32(CBS *cbs, uint32_t *out) { 128 return cbs_get_u(cbs, out, 4); 129 } 130 131 int CBS_get_last_u8(CBS *cbs, uint8_t *out) { 132 if (cbs->len == 0) { 133 return 0; 134 } 135 *out = cbs->data[cbs->len - 1]; 136 cbs->len--; 137 return 1; 138 } 139 140 int CBS_get_bytes(CBS *cbs, CBS *out, size_t len) { 141 const uint8_t *v; 142 if (!cbs_get(cbs, &v, len)) { 143 return 0; 144 } 145 CBS_init(out, v, len); 146 return 1; 147 } 148 149 int CBS_copy_bytes(CBS *cbs, uint8_t *out, size_t len) { 150 const uint8_t *v; 151 if (!cbs_get(cbs, &v, len)) { 152 return 0; 153 } 154 OPENSSL_memcpy(out, v, len); 155 return 1; 156 } 157 158 static int cbs_get_length_prefixed(CBS *cbs, CBS *out, size_t len_len) { 159 uint32_t len; 160 if (!cbs_get_u(cbs, &len, len_len)) { 161 return 0; 162 } 163 return CBS_get_bytes(cbs, out, len); 164 } 165 166 int CBS_get_u8_length_prefixed(CBS *cbs, CBS *out) { 167 return cbs_get_length_prefixed(cbs, out, 1); 168 } 169 170 int CBS_get_u16_length_prefixed(CBS *cbs, CBS *out) { 171 return cbs_get_length_prefixed(cbs, out, 2); 172 } 173 174 int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out) { 175 return cbs_get_length_prefixed(cbs, out, 3); 176 } 177 178 static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag, 179 size_t *out_header_len, int ber_ok) { 180 uint8_t tag, length_byte; 181 CBS header = *cbs; 182 CBS throwaway; 183 184 if (out == NULL) { 185 out = &throwaway; 186 } 187 188 if (!CBS_get_u8(&header, &tag) || 189 !CBS_get_u8(&header, &length_byte)) { 190 return 0; 191 } 192 193 /* ITU-T X.690 section 8.1.2.3 specifies the format for identifiers with a tag 194 * number no greater than 30. 195 * 196 * If the number portion is 31 (0x1f, the largest value that fits in the 197 * allotted bits), then the tag is more than one byte long and the 198 * continuation bytes contain the tag number. This parser only supports tag 199 * numbers less than 31 (and thus single-byte tags). */ 200 if ((tag & 0x1f) == 0x1f) { 201 return 0; 202 } 203 204 if (out_tag != NULL) { 205 *out_tag = tag; 206 } 207 208 size_t len; 209 /* The format for the length encoding is specified in ITU-T X.690 section 210 * 8.1.3. */ 211 if ((length_byte & 0x80) == 0) { 212 /* Short form length. */ 213 len = ((size_t) length_byte) + 2; 214 if (out_header_len != NULL) { 215 *out_header_len = 2; 216 } 217 } else { 218 /* The high bit indicate that this is the long form, while the next 7 bits 219 * encode the number of subsequent octets used to encode the length (ITU-T 220 * X.690 clause 8.1.3.5.b). */ 221 const size_t num_bytes = length_byte & 0x7f; 222 uint32_t len32; 223 224 if (ber_ok && (tag & CBS_ASN1_CONSTRUCTED) != 0 && num_bytes == 0) { 225 /* indefinite length */ 226 if (out_header_len != NULL) { 227 *out_header_len = 2; 228 } 229 return CBS_get_bytes(cbs, out, 2); 230 } 231 232 /* ITU-T X.690 clause 8.1.3.5.c specifies that the value 0xff shall not be 233 * used as the first byte of the length. If this parser encounters that 234 * value, num_bytes will be parsed as 127, which will fail the check below. 235 */ 236 if (num_bytes == 0 || num_bytes > 4) { 237 return 0; 238 } 239 if (!cbs_get_u(&header, &len32, num_bytes)) { 240 return 0; 241 } 242 /* ITU-T X.690 section 10.1 (DER length forms) requires encoding the length 243 * with the minimum number of octets. */ 244 if (len32 < 128) { 245 /* Length should have used short-form encoding. */ 246 return 0; 247 } 248 if ((len32 >> ((num_bytes-1)*8)) == 0) { 249 /* Length should have been at least one byte shorter. */ 250 return 0; 251 } 252 len = len32; 253 if (len + 2 + num_bytes < len) { 254 /* Overflow. */ 255 return 0; 256 } 257 len += 2 + num_bytes; 258 if (out_header_len != NULL) { 259 *out_header_len = 2 + num_bytes; 260 } 261 } 262 263 return CBS_get_bytes(cbs, out, len); 264 } 265 266 int CBS_get_any_asn1(CBS *cbs, CBS *out, unsigned *out_tag) { 267 size_t header_len; 268 if (!CBS_get_any_asn1_element(cbs, out, out_tag, &header_len)) { 269 return 0; 270 } 271 272 if (!CBS_skip(out, header_len)) { 273 assert(0); 274 return 0; 275 } 276 277 return 1; 278 } 279 280 int CBS_get_any_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag, 281 size_t *out_header_len) { 282 return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, 283 0 /* DER only */); 284 } 285 286 int CBS_get_any_ber_asn1_element(CBS *cbs, CBS *out, unsigned *out_tag, 287 size_t *out_header_len) { 288 return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, 289 1 /* BER allowed */); 290 } 291 292 static int cbs_get_asn1(CBS *cbs, CBS *out, unsigned tag_value, 293 int skip_header) { 294 size_t header_len; 295 unsigned tag; 296 CBS throwaway; 297 298 if (out == NULL) { 299 out = &throwaway; 300 } 301 302 if (!CBS_get_any_asn1_element(cbs, out, &tag, &header_len) || 303 tag != tag_value) { 304 return 0; 305 } 306 307 if (skip_header && !CBS_skip(out, header_len)) { 308 assert(0); 309 return 0; 310 } 311 312 return 1; 313 } 314 315 int CBS_get_asn1(CBS *cbs, CBS *out, unsigned tag_value) { 316 return cbs_get_asn1(cbs, out, tag_value, 1 /* skip header */); 317 } 318 319 int CBS_get_asn1_element(CBS *cbs, CBS *out, unsigned tag_value) { 320 return cbs_get_asn1(cbs, out, tag_value, 0 /* include header */); 321 } 322 323 int CBS_peek_asn1_tag(const CBS *cbs, unsigned tag_value) { 324 if (CBS_len(cbs) < 1) { 325 return 0; 326 } 327 return CBS_data(cbs)[0] == tag_value; 328 } 329 330 int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out) { 331 CBS bytes; 332 const uint8_t *data; 333 size_t i, len; 334 335 if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER)) { 336 return 0; 337 } 338 339 *out = 0; 340 data = CBS_data(&bytes); 341 len = CBS_len(&bytes); 342 343 if (len == 0) { 344 /* An INTEGER is encoded with at least one octet. */ 345 return 0; 346 } 347 348 if ((data[0] & 0x80) != 0) { 349 /* Negative number. */ 350 return 0; 351 } 352 353 if (data[0] == 0 && len > 1 && (data[1] & 0x80) == 0) { 354 /* Extra leading zeros. */ 355 return 0; 356 } 357 358 for (i = 0; i < len; i++) { 359 if ((*out >> 56) != 0) { 360 /* Too large to represent as a uint64_t. */ 361 return 0; 362 } 363 *out <<= 8; 364 *out |= data[i]; 365 } 366 367 return 1; 368 } 369 370 int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, unsigned tag) { 371 int present = 0; 372 373 if (CBS_peek_asn1_tag(cbs, tag)) { 374 if (!CBS_get_asn1(cbs, out, tag)) { 375 return 0; 376 } 377 present = 1; 378 } 379 380 if (out_present != NULL) { 381 *out_present = present; 382 } 383 384 return 1; 385 } 386 387 int CBS_get_optional_asn1_octet_string(CBS *cbs, CBS *out, int *out_present, 388 unsigned tag) { 389 CBS child; 390 int present; 391 if (!CBS_get_optional_asn1(cbs, &child, &present, tag)) { 392 return 0; 393 } 394 if (present) { 395 if (!CBS_get_asn1(&child, out, CBS_ASN1_OCTETSTRING) || 396 CBS_len(&child) != 0) { 397 return 0; 398 } 399 } else { 400 CBS_init(out, NULL, 0); 401 } 402 if (out_present) { 403 *out_present = present; 404 } 405 return 1; 406 } 407 408 int CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, unsigned tag, 409 uint64_t default_value) { 410 CBS child; 411 int present; 412 if (!CBS_get_optional_asn1(cbs, &child, &present, tag)) { 413 return 0; 414 } 415 if (present) { 416 if (!CBS_get_asn1_uint64(&child, out) || 417 CBS_len(&child) != 0) { 418 return 0; 419 } 420 } else { 421 *out = default_value; 422 } 423 return 1; 424 } 425 426 int CBS_get_optional_asn1_bool(CBS *cbs, int *out, unsigned tag, 427 int default_value) { 428 CBS child, child2; 429 int present; 430 if (!CBS_get_optional_asn1(cbs, &child, &present, tag)) { 431 return 0; 432 } 433 if (present) { 434 uint8_t boolean; 435 436 if (!CBS_get_asn1(&child, &child2, CBS_ASN1_BOOLEAN) || 437 CBS_len(&child2) != 1 || 438 CBS_len(&child) != 0) { 439 return 0; 440 } 441 442 boolean = CBS_data(&child2)[0]; 443 if (boolean == 0) { 444 *out = 0; 445 } else if (boolean == 0xff) { 446 *out = 1; 447 } else { 448 return 0; 449 } 450 } else { 451 *out = default_value; 452 } 453 return 1; 454 } 455 456 int CBS_is_valid_asn1_bitstring(const CBS *cbs) { 457 CBS in = *cbs; 458 uint8_t num_unused_bits; 459 if (!CBS_get_u8(&in, &num_unused_bits) || 460 num_unused_bits > 7) { 461 return 0; 462 } 463 464 if (num_unused_bits == 0) { 465 return 1; 466 } 467 468 /* All num_unused_bits bits must exist and be zeros. */ 469 uint8_t last; 470 if (!CBS_get_last_u8(&in, &last) || 471 (last & ((1 << num_unused_bits) - 1)) != 0) { 472 return 0; 473 } 474 475 return 1; 476 } 477 478 int CBS_asn1_bitstring_has_bit(const CBS *cbs, unsigned bit) { 479 if (!CBS_is_valid_asn1_bitstring(cbs)) { 480 return 0; 481 } 482 483 const unsigned byte_num = (bit >> 3) + 1; 484 const unsigned bit_num = 7 - (bit & 7); 485 486 /* Unused bits are zero, and this function does not distinguish between 487 * missing and unset bits. Thus it is sufficient to do a byte-level length 488 * check. */ 489 return byte_num < CBS_len(cbs) && 490 (CBS_data(cbs)[byte_num] & (1 << bit_num)) != 0; 491 } 492