crypto/libressl/ssl/bs_cbs.c

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