1 /* $OpenBSD: bs_cbs.c,v 1.16 2015/06/23 05:58:28 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 #include <assert.h> 18 #include <stdlib.h> 19 #include <string.h> 20 21 #include <openssl/opensslconf.h> 22 #include <openssl/buffer.h> 23 #include <openssl/crypto.h> 24 25 #include "bytestring.h" 26 27 void 28 CBS_init(CBS *cbs, const uint8_t *data, size_t len) 29 { 30 cbs->data = data; 31 cbs->initial_len = len; 32 cbs->len = len; 33 } 34 35 void 36 CBS_dup(const CBS *cbs, CBS *out) 37 { 38 CBS_init(out, CBS_data(cbs), CBS_len(cbs)); 39 out->initial_len = cbs->initial_len; 40 } 41 42 static int 43 cbs_get(CBS *cbs, const uint8_t **p, size_t n) 44 { 45 if (cbs->len < n) 46 return 0; 47 48 *p = cbs->data; 49 cbs->data += n; 50 cbs->len -= n; 51 return 1; 52 } 53 54 size_t 55 CBS_offset(const CBS *cbs) 56 { 57 return cbs->initial_len - cbs->len; 58 } 59 60 int 61 CBS_skip(CBS *cbs, size_t len) 62 { 63 const uint8_t *dummy; 64 return cbs_get(cbs, &dummy, len); 65 } 66 67 const uint8_t * 68 CBS_data(const CBS *cbs) 69 { 70 return cbs->data; 71 } 72 73 size_t 74 CBS_len(const CBS *cbs) 75 { 76 return cbs->len; 77 } 78 79 int 80 CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len) 81 { 82 free(*out_ptr); 83 *out_ptr = NULL; 84 *out_len = 0; 85 86 if (cbs->len == 0) 87 return 1; 88 89 if ((*out_ptr = malloc(cbs->len)) == NULL) 90 return 0; 91 92 memcpy(*out_ptr, cbs->data, cbs->len); 93 94 *out_len = cbs->len; 95 return 1; 96 } 97 98 int 99 CBS_strdup(const CBS *cbs, char **out_ptr) 100 { 101 free(*out_ptr); 102 *out_ptr = strndup((const char *)cbs->data, cbs->len); 103 return (*out_ptr != NULL); 104 } 105 106 int 107 CBS_write_bytes(const CBS *cbs, uint8_t *dst, size_t dst_len, size_t *copied) 108 { 109 if (dst_len < cbs->len) 110 return 0; 111 112 memmove(dst, cbs->data, cbs->len); 113 114 if (copied != NULL) 115 *copied = cbs->len; 116 117 return 1; 118 } 119 120 int 121 CBS_contains_zero_byte(const CBS *cbs) 122 { 123 return memchr(cbs->data, 0, cbs->len) != NULL; 124 } 125 126 int 127 CBS_mem_equal(const CBS *cbs, const uint8_t *data, size_t len) 128 { 129 if (len != cbs->len) 130 return 0; 131 132 return timingsafe_memcmp(cbs->data, data, len) == 0; 133 } 134 135 static int 136 cbs_get_u(CBS *cbs, uint32_t *out, size_t len) 137 { 138 uint32_t result = 0; 139 size_t i; 140 const uint8_t *data; 141 142 if (len < 1 || len > 4) 143 return 0; 144 145 if (!cbs_get(cbs, &data, len)) 146 return 0; 147 148 for (i = 0; i < len; i++) { 149 result <<= 8; 150 result |= data[i]; 151 } 152 *out = result; 153 return 1; 154 } 155 156 int 157 CBS_get_u8(CBS *cbs, uint8_t *out) 158 { 159 const uint8_t *v; 160 161 if (!cbs_get(cbs, &v, 1)) 162 return 0; 163 164 *out = *v; 165 return 1; 166 } 167 168 int 169 CBS_get_u16(CBS *cbs, uint16_t *out) 170 { 171 uint32_t v; 172 173 if (!cbs_get_u(cbs, &v, 2)) 174 return 0; 175 176 *out = v; 177 return 1; 178 } 179 180 int 181 CBS_get_u24(CBS *cbs, uint32_t *out) 182 { 183 return cbs_get_u(cbs, out, 3); 184 } 185 186 int 187 CBS_get_u32(CBS *cbs, uint32_t *out) 188 { 189 return cbs_get_u(cbs, out, 4); 190 } 191 192 int 193 CBS_get_bytes(CBS *cbs, CBS *out, size_t len) 194 { 195 const uint8_t *v; 196 197 if (!cbs_get(cbs, &v, len)) 198 return 0; 199 200 CBS_init(out, v, len); 201 return 1; 202 } 203 204 static int 205 cbs_get_length_prefixed(CBS *cbs, CBS *out, size_t len_len) 206 { 207 uint32_t len; 208 209 if (!cbs_get_u(cbs, &len, len_len)) 210 return 0; 211 212 return CBS_get_bytes(cbs, out, len); 213 } 214 215 int 216 CBS_get_u8_length_prefixed(CBS *cbs, CBS *out) 217 { 218 return cbs_get_length_prefixed(cbs, out, 1); 219 } 220 221 int 222 CBS_get_u16_length_prefixed(CBS *cbs, CBS *out) 223 { 224 return cbs_get_length_prefixed(cbs, out, 2); 225 } 226 227 int 228 CBS_get_u24_length_prefixed(CBS *cbs, CBS *out) 229 { 230 return cbs_get_length_prefixed(cbs, out, 3); 231 } 232 233 int 234 CBS_get_any_asn1_element(CBS *cbs, CBS *out, unsigned int *out_tag, 235 size_t *out_header_len) 236 { 237 return cbs_get_any_asn1_element_internal(cbs, out, out_tag, 238 out_header_len, 1); 239 } 240 241 /* 242 * Review X.690 for details on ASN.1 DER encoding. 243 * 244 * If non-strict mode is enabled, then DER rules are relaxed 245 * for indefinite constructs (violates DER but a little closer to BER). 246 * Non-strict mode should only be used by bs_ber.c 247 * 248 * Sections 8, 10 and 11 for DER encoding 249 */ 250 int 251 cbs_get_any_asn1_element_internal(CBS *cbs, CBS *out, unsigned int *out_tag, 252 size_t *out_header_len, int strict) 253 { 254 uint8_t tag, length_byte; 255 CBS header = *cbs; 256 CBS throwaway; 257 size_t len; 258 259 if (out == NULL) 260 out = &throwaway; 261 262 /* 263 * Get identifier octet and length octet. Only 1 octet for each 264 * is a CBS limitation. 265 */ 266 if (!CBS_get_u8(&header, &tag) || !CBS_get_u8(&header, &length_byte)) 267 return 0; 268 269 /* CBS limitation: long form tags are not supported. */ 270 if ((tag & 0x1f) == 0x1f) 271 return 0; 272 273 if (out_tag != NULL) 274 *out_tag = tag; 275 276 if ((length_byte & 0x80) == 0) { 277 /* Short form length. */ 278 len = ((size_t) length_byte) + 2; 279 if (out_header_len != NULL) 280 *out_header_len = 2; 281 282 } else { 283 /* Long form length. */ 284 const size_t num_bytes = length_byte & 0x7f; 285 uint32_t len32; 286 287 /* ASN.1 reserved value for future extensions */ 288 if (num_bytes == 0x7f) 289 return 0; 290 291 /* Handle indefinite form length */ 292 if (num_bytes == 0) { 293 /* DER encoding doesn't allow for indefinite form. */ 294 if (strict) 295 return 0; 296 297 /* Primitive cannot use indefinite in BER or DER. */ 298 if ((tag & CBS_ASN1_CONSTRUCTED) == 0) 299 return 0; 300 301 /* Constructed, indefinite length allowed in BER. */ 302 if (out_header_len != NULL) 303 *out_header_len = 2; 304 return CBS_get_bytes(cbs, out, 2); 305 } 306 307 /* CBS limitation. */ 308 if (num_bytes > 4) 309 return 0; 310 311 if (!cbs_get_u(&header, &len32, num_bytes)) 312 return 0; 313 314 /* DER has a minimum length octet requirement. */ 315 if (len32 < 128) 316 /* Should have used short form instead */ 317 return 0; 318 319 if ((len32 >> ((num_bytes - 1) * 8)) == 0) 320 /* Length should have been at least one byte shorter. */ 321 return 0; 322 323 len = len32; 324 if (len + 2 + num_bytes < len) 325 /* Overflow. */ 326 return 0; 327 328 len += 2 + num_bytes; 329 if (out_header_len != NULL) 330 *out_header_len = 2 + num_bytes; 331 } 332 333 return CBS_get_bytes(cbs, out, len); 334 } 335 336 static int 337 cbs_get_asn1(CBS *cbs, CBS *out, unsigned int tag_value, int skip_header) 338 { 339 size_t header_len; 340 unsigned int tag; 341 CBS throwaway; 342 343 if (out == NULL) 344 out = &throwaway; 345 346 if (!CBS_get_any_asn1_element(cbs, out, &tag, &header_len) || 347 tag != tag_value) 348 return 0; 349 350 if (skip_header && !CBS_skip(out, header_len)) { 351 assert(0); 352 return 0; 353 } 354 355 return 1; 356 } 357 358 int 359 CBS_get_asn1(CBS *cbs, CBS *out, unsigned int tag_value) 360 { 361 return cbs_get_asn1(cbs, out, tag_value, 1 /* skip header */); 362 } 363 364 int 365 CBS_get_asn1_element(CBS *cbs, CBS *out, unsigned int tag_value) 366 { 367 return cbs_get_asn1(cbs, out, tag_value, 0 /* include header */); 368 } 369 370 int 371 CBS_peek_asn1_tag(const CBS *cbs, unsigned int tag_value) 372 { 373 if (CBS_len(cbs) < 1) 374 return 0; 375 376 /* 377 * Tag number 31 indicates the start of a long form number. 378 * This is valid in ASN.1, but CBS only supports short form. 379 */ 380 if ((tag_value & 0x1f) == 0x1f) 381 return 0; 382 383 return CBS_data(cbs)[0] == tag_value; 384 } 385 386 /* Encoding details are in ASN.1: X.690 section 8.3 */ 387 int 388 CBS_get_asn1_uint64(CBS *cbs, uint64_t *out) 389 { 390 CBS bytes; 391 const uint8_t *data; 392 size_t i, len; 393 394 if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_INTEGER)) 395 return 0; 396 397 *out = 0; 398 data = CBS_data(&bytes); 399 len = CBS_len(&bytes); 400 401 if (len == 0) 402 /* An INTEGER is encoded with at least one content octet. */ 403 return 0; 404 405 if ((data[0] & 0x80) != 0) 406 /* Negative number. */ 407 return 0; 408 409 if (data[0] == 0 && len > 1 && (data[1] & 0x80) == 0) 410 /* Violates smallest encoding rule: excessive leading zeros. */ 411 return 0; 412 413 for (i = 0; i < len; i++) { 414 if ((*out >> 56) != 0) 415 /* Too large to represent as a uint64_t. */ 416 return 0; 417 418 *out <<= 8; 419 *out |= data[i]; 420 } 421 422 return 1; 423 } 424 425 int 426 CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, unsigned int tag) 427 { 428 if (CBS_peek_asn1_tag(cbs, tag)) { 429 if (!CBS_get_asn1(cbs, out, tag)) 430 return 0; 431 432 *out_present = 1; 433 } else { 434 *out_present = 0; 435 } 436 return 1; 437 } 438 439 int 440 CBS_get_optional_asn1_octet_string(CBS *cbs, CBS *out, int *out_present, 441 unsigned int tag) 442 { 443 CBS child; 444 int present; 445 446 if (!CBS_get_optional_asn1(cbs, &child, &present, tag)) 447 return 0; 448 449 if (present) { 450 if (!CBS_get_asn1(&child, out, CBS_ASN1_OCTETSTRING) || 451 CBS_len(&child) != 0) 452 return 0; 453 } else { 454 CBS_init(out, NULL, 0); 455 } 456 if (out_present) 457 *out_present = present; 458 459 return 1; 460 } 461 462 int 463 CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, unsigned int tag, 464 uint64_t default_value) 465 { 466 CBS child; 467 int present; 468 469 if (!CBS_get_optional_asn1(cbs, &child, &present, tag)) 470 return 0; 471 472 if (present) { 473 if (!CBS_get_asn1_uint64(&child, out) || 474 CBS_len(&child) != 0) 475 return 0; 476 } else { 477 *out = default_value; 478 } 479 return 1; 480 } 481 482 int 483 CBS_get_optional_asn1_bool(CBS *cbs, int *out, unsigned int tag, 484 int default_value) 485 { 486 CBS child, child2; 487 int present; 488 489 if (!CBS_get_optional_asn1(cbs, &child, &present, tag)) 490 return 0; 491 492 if (present) { 493 uint8_t boolean; 494 495 if (!CBS_get_asn1(&child, &child2, CBS_ASN1_BOOLEAN) || 496 CBS_len(&child2) != 1 || CBS_len(&child) != 0) 497 return 0; 498 499 boolean = CBS_data(&child2)[0]; 500 if (boolean == 0) 501 *out = 0; 502 else if (boolean == 0xff) 503 *out = 1; 504 else 505 return 0; 506 507 } else { 508 *out = default_value; 509 } 510 return 1; 511 } 512