lib/util/asn1.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    simple ASN1 routines
   4    Copyright (C) Andrew Tridgell 2001
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "../lib/util/asn1.h"
  22
  23 /* allocate an asn1 structure */
  24 struct asn1_data *asn1_init(TALLOC_CTX *mem_ctx)
  25 {
  26         struct asn1_data *ret = talloc_zero(mem_ctx, struct asn1_data);
  27         if (ret == NULL) {
  28                 DEBUG(0,("asn1_init failed! out of memory\n"));
  29         }
  30         return ret;
  31 }
  32
  33 /* free an asn1 structure */
  34 void asn1_free(struct asn1_data *data)
  35 {
  36         talloc_free(data);
  37 }
  38
  39 /* write to the ASN1 buffer, advancing the buffer pointer */
  40 bool asn1_write(struct asn1_data *data, const void *p, int len)
  41 {
  42         if (data->has_error) return false;
  43
  44         if ((len < 0) || (data->ofs + (size_t)len < data->ofs)) {
  45                 data->has_error = true;
  46                 return false;
  47         }
  48
  49         if (data->length < data->ofs+len) {
  50                 uint8_t *newp;
  51                 newp = talloc_realloc(data, data->data, uint8_t, data->ofs+len);
  52                 if (!newp) {
  53                         data->has_error = true;
  54                         return false;
  55                 }
  56                 data->data = newp;
  57                 data->length = data->ofs+len;
  58         }
  59         memcpy(data->data + data->ofs, p, len);
  60         data->ofs += len;
  61         return true;
  62 }
  63
  64 /* useful fn for writing a uint8_t */
  65 bool asn1_write_uint8(struct asn1_data *data, uint8_t v)
  66 {
  67         return asn1_write(data, &v, 1);
  68 }
  69
  70 /* push a tag onto the asn1 data buffer. Used for nested structures */
  71 bool asn1_push_tag(struct asn1_data *data, uint8_t tag)
  72 {
  73         struct nesting *nesting;
  74
  75         asn1_write_uint8(data, tag);
  76         nesting = talloc(data, struct nesting);
  77         if (!nesting) {
  78                 data->has_error = true;
  79                 return false;
  80         }
  81
  82         nesting->start = data->ofs;
  83         nesting->next = data->nesting;
  84         data->nesting = nesting;
  85         return asn1_write_uint8(data, 0xff);
  86 }
  87
  88 /* pop a tag */
  89 bool asn1_pop_tag(struct asn1_data *data)
  90 {
  91         struct nesting *nesting;
  92         size_t len;
  93
  94         nesting = data->nesting;
  95
  96         if (!nesting) {
  97                 data->has_error = true;
  98                 return false;
  99         }
 100         len = data->ofs - (nesting->start+1);
 101         /* yes, this is ugly. We don't know in advance how many bytes the length
 102            of a tag will take, so we assumed 1 byte. If we were wrong then we
 103            need to correct our mistake */
 104         if (len > 0xFFFFFF) {
 105                 data->data[nesting->start] = 0x84;
 106                 if (!asn1_write_uint8(data, 0)) return false;
 107                 if (!asn1_write_uint8(data, 0)) return false;
 108                 if (!asn1_write_uint8(data, 0)) return false;
 109                 if (!asn1_write_uint8(data, 0)) return false;
 110                 memmove(data->data+nesting->start+5, data->data+nesting->start+1, len);
 111                 data->data[nesting->start+1] = (len>>24) & 0xFF;
 112                 data->data[nesting->start+2] = (len>>16) & 0xFF;
 113                 data->data[nesting->start+3] = (len>>8) & 0xFF;
 114                 data->data[nesting->start+4] = len&0xff;
 115         } else if (len > 0xFFFF) {
 116                 data->data[nesting->start] = 0x83;
 117                 if (!asn1_write_uint8(data, 0)) return false;
 118                 if (!asn1_write_uint8(data, 0)) return false;
 119                 if (!asn1_write_uint8(data, 0)) return false;
 120                 memmove(data->data+nesting->start+4, data->data+nesting->start+1, len);
 121                 data->data[nesting->start+1] = (len>>16) & 0xFF;
 122                 data->data[nesting->start+2] = (len>>8) & 0xFF;
 123                 data->data[nesting->start+3] = len&0xff;
 124         } else if (len > 255) {
 125                 data->data[nesting->start] = 0x82;
 126                 if (!asn1_write_uint8(data, 0)) return false;
 127                 if (!asn1_write_uint8(data, 0)) return false;
 128                 memmove(data->data+nesting->start+3, data->data+nesting->start+1, len);
 129                 data->data[nesting->start+1] = len>>8;
 130                 data->data[nesting->start+2] = len&0xff;
 131         } else if (len > 127) {
 132                 data->data[nesting->start] = 0x81;
 133                 if (!asn1_write_uint8(data, 0)) return false;
 134                 memmove(data->data+nesting->start+2, data->data+nesting->start+1, len);
 135                 data->data[nesting->start+1] = len;
 136         } else {
 137                 data->data[nesting->start] = len;
 138         }
 139
 140         data->nesting = nesting->next;
 141         talloc_free(nesting);
 142         return true;
 143 }
 144
 145 /* "i" is the one's complement representation, as is the normal result of an
 146  * implicit signed->unsigned conversion */
 147
 148 static bool push_int_bigendian(struct asn1_data *data, unsigned int i, bool negative)
 149 {
 150         uint8_t lowest = i & 0xFF;
 151
 152         i = i >> 8;
 153         if (i != 0)
 154                 if (!push_int_bigendian(data, i, negative))
 155                         return false;
 156
 157         if (data->nesting->start+1 == data->ofs) {
 158
 159                 /* We did not write anything yet, looking at the highest
 160                  * valued byte */
 161
 162                 if (negative) {
 163                         /* Don't write leading 0xff's */
 164                         if (lowest == 0xFF)
 165                                 return true;
 166
 167                         if ((lowest & 0x80) == 0) {
 168                                 /* The only exception for a leading 0xff is if
 169                                  * the highest bit is 0, which would indicate
 170                                  * a positive value */
 171                                 if (!asn1_write_uint8(data, 0xff))
 172                                         return false;
 173                         }
 174                 } else {
 175                         if (lowest & 0x80) {
 176                                 /* The highest bit of a positive integer is 1,
 177                                  * this would indicate a negative number. Push
 178                                  * a 0 to indicate a positive one */
 179                                 if (!asn1_write_uint8(data, 0))
 180                                         return false;
 181                         }
 182                 }
 183         }
 184
 185         return asn1_write_uint8(data, lowest);
 186 }
 187
 188 /* write an Integer without the tag framing. Needed for example for the LDAP
 189  * Abandon Operation */
 190
 191 bool asn1_write_implicit_Integer(struct asn1_data *data, int i)
 192 {
 193         if (i == -1) {
 194                 /* -1 is special as it consists of all-0xff bytes. In
 195                     push_int_bigendian this is the only case that is not
 196                     properly handled, as all 0xff bytes would be handled as
 197                     leading ones to be ignored. */
 198                 return asn1_write_uint8(data, 0xff);
 199         } else {
 200                 return push_int_bigendian(data, i, i<0);
 201         }
 202 }
 203
 204
 205 /* write an integer */
 206 bool asn1_write_Integer(struct asn1_data *data, int i)
 207 {
 208         if (!asn1_push_tag(data, ASN1_INTEGER)) return false;
 209         if (!asn1_write_implicit_Integer(data, i)) return false;
 210         return asn1_pop_tag(data);
 211 }
 212
 213 /* write a BIT STRING */
 214 bool asn1_write_BitString(struct asn1_data *data, const void *p, size_t length, uint8_t padding)
 215 {
 216         if (!asn1_push_tag(data, ASN1_BIT_STRING)) return false;
 217         if (!asn1_write_uint8(data, padding)) return false;
 218         if (!asn1_write(data, p, length)) return false;
 219         return asn1_pop_tag(data);
 220 }
 221
 222 bool ber_write_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *OID)
 223 {
 224         unsigned int v, v2;
 225         const char *p = (const char *)OID;
 226         char *newp;
 227         int i;
 228
 229         if (!isdigit(*p)) return false;
 230         v = strtoul(p, &newp, 10);
 231         if (newp[0] != '.') return false;
 232         p = newp + 1;
 233
 234         if (!isdigit(*p)) return false;
 235         v2 = strtoul(p, &newp, 10);
 236         if (newp[0] != '.') return false;
 237         p = newp + 1;
 238
 239         /*the ber representation can't use more space then the string one */
 240         *blob = data_blob_talloc(mem_ctx, NULL, strlen(OID));
 241         if (!blob->data) return false;
 242
 243         blob->data[0] = 40*v + v2;
 244
 245         i = 1;
 246         while (*p) {
 247                 if (!isdigit(*p)) return false;
 248                 v = strtoul(p, &newp, 10);
 249                 if (newp[0] == '.') {
 250                         p = newp + 1;
 251                         /* check for empty last component */
 252                         if (!*p) return false;
 253                 } else if (newp[0] == '\0') {
 254                         p = newp;
 255                 } else {
 256                         data_blob_free(blob);
 257                         return false;
 258                 }
 259                 if (v >= (1<<28)) blob->data[i++] = (0x80 | ((v>>28)&0x7f));
 260                 if (v >= (1<<21)) blob->data[i++] = (0x80 | ((v>>21)&0x7f));
 261                 if (v >= (1<<14)) blob->data[i++] = (0x80 | ((v>>14)&0x7f));
 262                 if (v >= (1<<7)) blob->data[i++] = (0x80 | ((v>>7)&0x7f));
 263                 blob->data[i++] = (v&0x7f);
 264         }
 265
 266         blob->length = i;
 267
 268         return true;
 269 }
 270
 271 /**
 272  * Serialize partial OID string.
 273  * Partial OIDs are in the form:
 274  *   1:2.5.6:0x81
 275  *   1:2.5.6:0x8182
 276  */
 277 bool ber_write_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *partial_oid)
 278 {
 279         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
 280         char *oid = talloc_strdup(tmp_ctx, partial_oid);
 281         char *p;
 282
 283         /* truncate partial part so ber_write_OID_String() works */
 284         p = strchr(oid, ':');
 285         if (p) {
 286                 *p = '\0';
 287                 p++;
 288         }
 289
 290         if (!ber_write_OID_String(mem_ctx, blob, oid)) {
 291                 talloc_free(tmp_ctx);
 292                 return false;
 293         }
 294
 295         /* Add partially encoded sub-identifier */
 296         if (p) {
 297                 DATA_BLOB tmp_blob = strhex_to_data_blob(tmp_ctx, p);
 298                 if (!data_blob_append(mem_ctx, blob, tmp_blob.data,
 299                                       tmp_blob.length)) {
 300                         talloc_free(tmp_ctx);
 301                         return false;
 302                 }
 303         }
 304
 305         talloc_free(tmp_ctx);
 306
 307         return true;
 308 }
 309
 310 /* write an object ID to a ASN1 buffer */
 311 bool asn1_write_OID(struct asn1_data *data, const char *OID)
 312 {
 313         DATA_BLOB blob;
 314
 315         if (!asn1_push_tag(data, ASN1_OID)) return false;
 316
 317         if (!ber_write_OID_String(NULL, &blob, OID)) {
 318                 data->has_error = true;
 319                 return false;
 320         }
 321
 322         if (!asn1_write(data, blob.data, blob.length)) {
 323                 data_blob_free(&blob);
 324                 data->has_error = true;
 325                 return false;
 326         }
 327         data_blob_free(&blob);
 328         return asn1_pop_tag(data);
 329 }
 330
 331 /* write an octet string */
 332 bool asn1_write_OctetString(struct asn1_data *data, const void *p, size_t length)
 333 {
 334         if (!asn1_push_tag(data, ASN1_OCTET_STRING)) return false;
 335         if (!asn1_write(data, p, length)) return false;
 336         return asn1_pop_tag(data);
 337 }
 338
 339 /* write a LDAP string */
 340 bool asn1_write_LDAPString(struct asn1_data *data, const char *s)
 341 {
 342         return asn1_write(data, s, strlen(s));
 343 }
 344
 345 /* write a LDAP string from a DATA_BLOB */
 346 bool asn1_write_DATA_BLOB_LDAPString(struct asn1_data *data, const DATA_BLOB *s)
 347 {
 348         return asn1_write(data, s->data, s->length);
 349 }
 350
 351 /* write a general string */
 352 bool asn1_write_GeneralString(struct asn1_data *data, const char *s)
 353 {
 354         if (!asn1_push_tag(data, ASN1_GENERAL_STRING)) return false;
 355         if (!asn1_write_LDAPString(data, s)) return false;
 356         return asn1_pop_tag(data);
 357 }
 358
 359 bool asn1_write_ContextSimple(struct asn1_data *data, uint8_t num, DATA_BLOB *blob)
 360 {
 361         if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(num))) return false;
 362         if (!asn1_write(data, blob->data, blob->length)) return false;
 363         return asn1_pop_tag(data);
 364 }
 365
 366 /* write a BOOLEAN */
 367 bool asn1_write_BOOLEAN(struct asn1_data *data, bool v)
 368 {
 369         if (!asn1_push_tag(data, ASN1_BOOLEAN)) return false;
 370         if (!asn1_write_uint8(data, v ? 0xFF : 0)) return false;
 371         return asn1_pop_tag(data);
 372 }
 373
 374 bool asn1_read_BOOLEAN(struct asn1_data *data, bool *v)
 375 {
 376         uint8_t tmp = 0;
 377         if (!asn1_start_tag(data, ASN1_BOOLEAN)) return false;
 378         *v = false;
 379         if (!asn1_read_uint8(data, &tmp)) return false;
 380         if (tmp == 0xFF) {
 381                 *v = true;
 382         }
 383         return asn1_end_tag(data);
 384 }
 385
 386 /* write a BOOLEAN in a simple context */
 387 bool asn1_write_BOOLEAN_context(struct asn1_data *data, bool v, int context)
 388 {
 389         if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(context))) return false;
 390         if (!asn1_write_uint8(data, v ? 0xFF : 0)) return false;
 391         return asn1_pop_tag(data);
 392 }
 393
 394 bool asn1_read_BOOLEAN_context(struct asn1_data *data, bool *v, int context)
 395 {
 396         uint8_t tmp = 0;
 397         if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(context))) return false;
 398         *v = false;
 399         if (!asn1_read_uint8(data, &tmp)) return false;
 400         if (tmp == 0xFF) {
 401                 *v = true;
 402         }
 403         return asn1_end_tag(data);
 404 }
 405
 406 /* check a BOOLEAN */
 407 bool asn1_check_BOOLEAN(struct asn1_data *data, bool v)
 408 {
 409         uint8_t b = 0;
 410
 411         if (!asn1_read_uint8(data, &b)) return false;
 412         if (b != ASN1_BOOLEAN) {
 413                 data->has_error = true;
 414                 return false;
 415         }
 416         if (!asn1_read_uint8(data, &b)) return false;
 417         if (b != v) {
 418                 data->has_error = true;
 419                 return false;
 420         }
 421         return !data->has_error;
 422 }
 423
 424
 425 /* load a struct asn1_data structure with a lump of data, ready to be parsed */
 426 bool asn1_load(struct asn1_data *data, DATA_BLOB blob)
 427 {
 428         ZERO_STRUCTP(data);
 429         data->data = (uint8_t *)talloc_memdup(data, blob.data, blob.length);
 430         if (!data->data) {
 431                 data->has_error = true;
 432                 return false;
 433         }
 434         data->length = blob.length;
 435         return true;
 436 }
 437
 438 /* Peek into an ASN1 buffer, not advancing the pointer */
 439 bool asn1_peek(struct asn1_data *data, void *p, int len)
 440 {
 441         if (data->has_error)
 442                 return false;
 443
 444         if (len < 0 || data->ofs + len < data->ofs || data->ofs + len < len)
 445                 return false;
 446
 447         if (data->ofs + len > data->length) {
 448                 /* we need to mark the buffer as consumed, so the caller knows
 449                    this was an out of data error, and not a decode error */
 450                 data->ofs = data->length;
 451                 return false;
 452         }
 453
 454         memcpy(p, data->data + data->ofs, len);
 455         return true;
 456 }
 457
 458 /* read from a ASN1 buffer, advancing the buffer pointer */
 459 bool asn1_read(struct asn1_data *data, void *p, int len)
 460 {
 461         if (!asn1_peek(data, p, len)) {
 462                 data->has_error = true;
 463                 return false;
 464         }
 465
 466         data->ofs += len;
 467         return true;
 468 }
 469
 470 /* read a uint8_t from a ASN1 buffer */
 471 bool asn1_read_uint8(struct asn1_data *data, uint8_t *v)
 472 {
 473         return asn1_read(data, v, 1);
 474 }
 475
 476 bool asn1_peek_uint8(struct asn1_data *data, uint8_t *v)
 477 {
 478         return asn1_peek(data, v, 1);
 479 }
 480
 481 bool asn1_peek_tag(struct asn1_data *data, uint8_t tag)
 482 {
 483         uint8_t b;
 484
 485         if (asn1_tag_remaining(data) <= 0) {
 486                 return false;
 487         }
 488
 489         if (!asn1_peek_uint8(data, &b))
 490                 return false;
 491
 492         return (b == tag);
 493 }
 494
 495 /*
 496  * just get the needed size the tag would consume
 497  */
 498 bool asn1_peek_tag_needed_size(struct asn1_data *data, uint8_t tag, size_t *size)
 499 {
 500         off_t start_ofs = data->ofs;
 501         uint8_t b;
 502         size_t taglen = 0;
 503
 504         if (data->has_error) {
 505                 return false;
 506         }
 507
 508         if (!asn1_read_uint8(data, &b)) {
 509                 data->ofs = start_ofs;
 510                 data->has_error = false;
 511                 return false;
 512         }
 513
 514         if (b != tag) {
 515                 data->ofs = start_ofs;
 516                 data->has_error = false;
 517                 return false;
 518         }
 519
 520         if (!asn1_read_uint8(data, &b)) {
 521                 data->ofs = start_ofs;
 522                 data->has_error = false;
 523                 return false;
 524         }
 525
 526         if (b & 0x80) {
 527                 int n = b & 0x7f;
 528                 if (!asn1_read_uint8(data, &b)) {
 529                         data->ofs = start_ofs;
 530                         data->has_error = false;
 531                         return false;
 532                 }
 533                 if (n > 4) {
 534                         /*
 535                          * We should not allow more than 4 bytes
 536                          * for the encoding of the tag length.
 537                          *
 538                          * Otherwise we'd overflow the taglen
 539                          * variable on 32 bit systems.
 540                          */
 541                         data->ofs = start_ofs;
 542                         data->has_error = false;
 543                         return false;
 544                 }
 545                 taglen = b;
 546                 while (n > 1) {
 547                         if (!asn1_read_uint8(data, &b)) {
 548                                 data->ofs = start_ofs;
 549                                 data->has_error = false;
 550                                 return false;
 551                         }
 552                         taglen = (taglen << 8) | b;
 553                         n--;
 554                 }
 555         } else {
 556                 taglen = b;
 557         }
 558
 559         *size = (data->ofs - start_ofs) + taglen;
 560
 561         data->ofs = start_ofs;
 562         data->has_error = false;
 563         return true;
 564 }
 565
 566 /* start reading a nested asn1 structure */
 567 bool asn1_start_tag(struct asn1_data *data, uint8_t tag)
 568 {
 569         uint8_t b;
 570         struct nesting *nesting;
 571
 572         if (!asn1_read_uint8(data, &b))
 573                 return false;
 574
 575         if (b != tag) {
 576                 data->has_error = true;
 577                 return false;
 578         }
 579         nesting = talloc(data, struct nesting);
 580         if (!nesting) {
 581                 data->has_error = true;
 582                 return false;
 583         }
 584
 585         if (!asn1_read_uint8(data, &b)) {
 586                 return false;
 587         }
 588
 589         if (b & 0x80) {
 590                 int n = b & 0x7f;
 591                 if (!asn1_read_uint8(data, &b))
 592                         return false;
 593                 nesting->taglen = b;
 594                 while (n > 1) {
 595                         if (!asn1_read_uint8(data, &b))
 596                                 return false;
 597                         nesting->taglen = (nesting->taglen << 8) | b;
 598                         n--;
 599                 }
 600         } else {
 601                 nesting->taglen = b;
 602         }
 603         nesting->start = data->ofs;
 604         nesting->next = data->nesting;
 605         data->nesting = nesting;
 606         if (asn1_tag_remaining(data) == -1) {
 607                 return false;
 608         }
 609         return !data->has_error;
 610 }
 611
 612 /* stop reading a tag */
 613 bool asn1_end_tag(struct asn1_data *data)
 614 {
 615         struct nesting *nesting;
 616
 617         /* make sure we read it all */
 618         if (asn1_tag_remaining(data) != 0) {
 619                 data->has_error = true;
 620                 return false;
 621         }
 622
 623         nesting = data->nesting;
 624
 625         if (!nesting) {
 626                 data->has_error = true;
 627                 return false;
 628         }
 629
 630         data->nesting = nesting->next;
 631         talloc_free(nesting);
 632         return true;
 633 }
 634
 635 /* work out how many bytes are left in this nested tag */
 636 int asn1_tag_remaining(struct asn1_data *data)
 637 {
 638         int remaining;
 639         if (data->has_error) {
 640                 return -1;
 641         }
 642
 643         if (!data->nesting) {
 644                 data->has_error = true;
 645                 return -1;
 646         }
 647         remaining = data->nesting->taglen - (data->ofs - data->nesting->start);
 648         if (remaining > (data->length - data->ofs)) {
 649                 data->has_error = true;
 650                 return -1;
 651         }
 652         return remaining;
 653 }
 654
 655 /**
 656  * Internal implementation for reading binary OIDs
 657  * Reading is done as far in the buffer as valid OID
 658  * till buffer ends or not valid sub-identifier is found.
 659  */
 660 static bool _ber_read_OID_String_impl(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
 661                                       char **OID, size_t *bytes_eaten)
 662 {
 663         int i;
 664         uint8_t *b;
 665         unsigned int v;
 666         char *tmp_oid = NULL;
 667
 668         if (blob.length < 2) return false;
 669
 670         b = blob.data;
 671
 672         tmp_oid = talloc_asprintf(mem_ctx, "%u",  b[0]/40);
 673         if (!tmp_oid) goto nomem;
 674         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  b[0]%40);
 675         if (!tmp_oid) goto nomem;
 676
 677         if (bytes_eaten != NULL) {
 678                 *bytes_eaten = 0;
 679         }
 680
 681         for(i = 1, v = 0; i < blob.length; i++) {
 682                 v = (v<<7) | (b[i]&0x7f);
 683                 if ( ! (b[i] & 0x80)) {
 684                         tmp_oid = talloc_asprintf_append_buffer(tmp_oid, ".%u",  v);
 685                         v = 0;
 686                         if (bytes_eaten)
 687                                 *bytes_eaten = i+1;
 688                 }
 689                 if (!tmp_oid) goto nomem;
 690         }
 691
 692         *OID = tmp_oid;
 693         return true;
 694
 695 nomem:
 696         return false;
 697 }
 698
 699 /* read an object ID from a data blob */
 700 bool ber_read_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob, char **OID)
 701 {
 702         size_t bytes_eaten;
 703
 704         if (!_ber_read_OID_String_impl(mem_ctx, blob, OID, &bytes_eaten))
 705                 return false;
 706
 707         return (bytes_eaten == blob.length);
 708 }
 709
 710 /**
 711  * Deserialize partial OID string.
 712  * Partial OIDs are in the form:
 713  *   1:2.5.6:0x81
 714  *   1:2.5.6:0x8182
 715  */
 716 bool ber_read_partial_OID_String(TALLOC_CTX *mem_ctx, DATA_BLOB blob,
 717                                  char **partial_oid)
 718 {
 719         size_t bytes_left;
 720         size_t bytes_eaten;
 721         char *identifier = NULL;
 722         char *tmp_oid = NULL;
 723
 724         if (!_ber_read_OID_String_impl(mem_ctx, blob, &tmp_oid, &bytes_eaten))
 725                 return false;
 726
 727         if (bytes_eaten < blob.length) {
 728                 bytes_left = blob.length - bytes_eaten;
 729                 identifier = hex_encode_talloc(mem_ctx, &blob.data[bytes_eaten], bytes_left);
 730                 if (!identifier)        goto nomem;
 731
 732                 *partial_oid = talloc_asprintf_append_buffer(tmp_oid, ":0x%s", identifier);
 733                 if (!*partial_oid)      goto nomem;
 734                 TALLOC_FREE(identifier);
 735         } else {
 736                 *partial_oid = tmp_oid;
 737         }
 738
 739         return true;
 740
 741 nomem:
 742         TALLOC_FREE(identifier);
 743         TALLOC_FREE(tmp_oid);
 744         return false;
 745 }
 746
 747 /* read an object ID from a ASN1 buffer */
 748 bool asn1_read_OID(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **OID)
 749 {
 750         DATA_BLOB blob;
 751         int len;
 752
 753         if (!asn1_start_tag(data, ASN1_OID)) return false;
 754
 755         len = asn1_tag_remaining(data);
 756         if (len < 0) {
 757                 data->has_error = true;
 758                 return false;
 759         }
 760
 761         blob = data_blob(NULL, len);
 762         if (!blob.data) {
 763                 data->has_error = true;
 764                 return false;
 765         }
 766
 767         if (!asn1_read(data, blob.data, len)) return false;
 768         if (!asn1_end_tag(data)) {
 769                 data_blob_free(&blob);
 770                 return false;
 771         }
 772
 773         if (!ber_read_OID_String(mem_ctx, blob, OID)) {
 774                 data->has_error = true;
 775                 data_blob_free(&blob);
 776                 return false;
 777         }
 778
 779         data_blob_free(&blob);
 780         return true;
 781 }
 782
 783 /* check that the next object ID is correct */
 784 bool asn1_check_OID(struct asn1_data *data, const char *OID)
 785 {
 786         char *id;
 787
 788         if (!asn1_read_OID(data, data, &id)) return false;
 789
 790         if (strcmp(id, OID) != 0) {
 791                 talloc_free(id);
 792                 data->has_error = true;
 793                 return false;
 794         }
 795         talloc_free(id);
 796         return true;
 797 }
 798
 799 /* read a LDAPString from a ASN1 buffer */
 800 bool asn1_read_LDAPString(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **s)
 801 {
 802         int len;
 803         len = asn1_tag_remaining(data);
 804         if (len < 0) {
 805                 data->has_error = true;
 806                 return false;
 807         }
 808         *s = talloc_array(mem_ctx, char, len+1);
 809         if (! *s) {
 810                 data->has_error = true;
 811                 return false;
 812         }
 813         (*s)[len] = 0;
 814         return asn1_read(data, *s, len);
 815 }
 816
 817
 818 /* read a GeneralString from a ASN1 buffer */
 819 bool asn1_read_GeneralString(struct asn1_data *data, TALLOC_CTX *mem_ctx, char **s)
 820 {
 821         if (!asn1_start_tag(data, ASN1_GENERAL_STRING)) return false;
 822         if (!asn1_read_LDAPString(data, mem_ctx, s)) return false;
 823         return asn1_end_tag(data);
 824 }
 825
 826
 827 /* read a octet string blob */
 828 bool asn1_read_OctetString(struct asn1_data *data, TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
 829 {
 830         int len;
 831         ZERO_STRUCTP(blob);
 832         if (!asn1_start_tag(data, ASN1_OCTET_STRING)) return false;
 833         len = asn1_tag_remaining(data);
 834         if (len < 0) {
 835                 data->has_error = true;
 836                 return false;
 837         }
 838         *blob = data_blob_talloc(mem_ctx, NULL, len+1);
 839         if (!blob->data || blob->length < len) {
 840                 data->has_error = true;
 841                 return false;
 842         }
 843         if (!asn1_read(data, blob->data, len)) goto err;
 844         if (!asn1_end_tag(data)) goto err;
 845         blob->length--;
 846         blob->data[len] = 0;
 847         return true;
 848
 849   err:
 850
 851         data_blob_free(blob);
 852         *blob = data_blob_null;
 853         return false;
 854 }
 855
 856 bool asn1_read_ContextSimple(struct asn1_data *data, uint8_t num, DATA_BLOB *blob)
 857 {
 858         int len;
 859         ZERO_STRUCTP(blob);
 860         if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(num))) return false;
 861         len = asn1_tag_remaining(data);
 862         if (len < 0) {
 863                 data->has_error = true;
 864                 return false;
 865         }
 866         *blob = data_blob(NULL, len);
 867         if ((len != 0) && (!blob->data)) {
 868                 data->has_error = true;
 869                 return false;
 870         }
 871         if (!asn1_read(data, blob->data, len)) return false;
 872         return asn1_end_tag(data);
 873 }
 874
 875 /* read an integer without tag*/
 876 bool asn1_read_implicit_Integer(struct asn1_data *data, int *i)
 877 {
 878         uint8_t b;
 879         bool first_byte = true;
 880         *i = 0;
 881
 882         while (!data->has_error && asn1_tag_remaining(data)>0) {
 883                 if (!asn1_read_uint8(data, &b)) return false;
 884                 if (first_byte) {
 885                         if (b & 0x80) {
 886                                 /* Number is negative.
 887                                    Set i to -1 for sign extend. */
 888                                 *i = -1;
 889                         }
 890                         first_byte = false;
 891                 }
 892                 *i = (*i << 8) + b;
 893         }
 894         return !data->has_error;
 895
 896 }
 897
 898 /* read an integer */
 899 bool asn1_read_Integer(struct asn1_data *data, int *i)
 900 {
 901         *i = 0;
 902
 903         if (!asn1_start_tag(data, ASN1_INTEGER)) return false;
 904         if (!asn1_read_implicit_Integer(data, i)) return false;
 905         return asn1_end_tag(data);
 906 }
 907
 908 /* read a BIT STRING */
 909 bool asn1_read_BitString(struct asn1_data *data, TALLOC_CTX *mem_ctx, DATA_BLOB *blob, uint8_t *padding)
 910 {
 911         int len;
 912         ZERO_STRUCTP(blob);
 913         if (!asn1_start_tag(data, ASN1_BIT_STRING)) return false;
 914         len = asn1_tag_remaining(data);
 915         if (len < 0) {
 916                 data->has_error = true;
 917                 return false;
 918         }
 919         if (!asn1_read_uint8(data, padding)) return false;
 920
 921         *blob = data_blob_talloc(mem_ctx, NULL, len+1);
 922         if (!blob->data || blob->length < len) {
 923                 data->has_error = true;
 924                 return false;
 925         }
 926         if (asn1_read(data, blob->data, len - 1)) {
 927                 blob->length--;
 928                 blob->data[len] = 0;
 929                 asn1_end_tag(data);
 930         }
 931
 932         if (data->has_error) {
 933                 data_blob_free(blob);
 934                 *blob = data_blob_null;
 935                 *padding = 0;
 936                 return false;
 937         }
 938         return true;
 939 }
 940
 941 /* read an integer */
 942 bool asn1_read_enumerated(struct asn1_data *data, int *v)
 943 {
 944         *v = 0;
 945
 946         if (!asn1_start_tag(data, ASN1_ENUMERATED)) return false;
 947         while (!data->has_error && asn1_tag_remaining(data)>0) {
 948                 uint8_t b;
 949                 if (!asn1_read_uint8(data, &b)) {
 950                         return false;
 951                 }
 952                 *v = (*v << 8) + b;
 953         }
 954         return asn1_end_tag(data);
 955 }
 956
 957 /* check a enumerated value is correct */
 958 bool asn1_check_enumerated(struct asn1_data *data, int v)
 959 {
 960         uint8_t b;
 961         if (!asn1_start_tag(data, ASN1_ENUMERATED)) return false;
 962         if (!asn1_read_uint8(data, &b)) return false;
 963         if (!asn1_end_tag(data)) return false;
 964
 965         if (v != b)
 966                 data->has_error = false;
 967
 968         return !data->has_error;
 969 }
 970
 971 /* write an enumerated value to the stream */
 972 bool asn1_write_enumerated(struct asn1_data *data, uint8_t v)
 973 {
 974         if (!asn1_push_tag(data, ASN1_ENUMERATED)) return false;
 975         if (!asn1_write_uint8(data, v)) return false;
 976         return asn1_pop_tag(data);
 977 }
 978
 979 /*
 980   Get us the data just written without copying
 981 */
 982 bool asn1_blob(const struct asn1_data *asn1, DATA_BLOB *blob)
 983 {
 984         if (asn1->has_error) {
 985                 return false;
 986         }
 987         if (asn1->nesting != NULL) {
 988                 return false;
 989         }
 990         blob->data = asn1->data;
 991         blob->length = asn1->length;
 992         return true;
 993 }
 994
 995 /*
 996   Fill in an asn1 struct without making a copy
 997 */
 998 void asn1_load_nocopy(struct asn1_data *data, uint8_t *buf, size_t len)
 999 {
1000         ZERO_STRUCTP(data);
1001         data->data = buf;
1002         data->length = len;
1003 }
1004
1005 int asn1_peek_full_tag(DATA_BLOB blob, uint8_t tag, size_t *packet_size)
1006 {
1007         struct asn1_data asn1;
1008         size_t size;
1009         bool ok;
1010
1011         ZERO_STRUCT(asn1);
1012         asn1.data = blob.data;
1013         asn1.length = blob.length;
1014
1015         ok = asn1_peek_tag_needed_size(&asn1, tag, &size);
1016         if (!ok) {
1017                 return EMSGSIZE;
1018         }
1019
1020         if (size > blob.length) {
1021                 *packet_size = size;
1022                 return EAGAIN;
1023         }
1024
1025         *packet_size = size;
1026         return 0;
1027 }