src/rxkad/v5der.c

   1 #include "asn1_err.h"
   2 #include <errno.h>
   3 /*
   4  * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
   5  * (Royal Institute of Technology, Stockholm, Sweden).
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * 3. Neither the name of the Institute nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36
  37 /* RCSID("Heimdal: der_get.c,v 1.33 2002/09/03 16:21:49 nectar Exp $"); */
  38
  39
  40 /*
  41  * All decoding functions take a pointer `p' to first position in
  42  * which to read, from the left, `len' which means the maximum number
  43  * of characters we are able to read, `ret' were the value will be
  44  * returned and `size' where the number of used bytes is stored.
  45  * Either 0 or an error code is returned.
  46  */
  47
  48 static int
  49 der_get_unsigned (const unsigned char *p, size_t len,
  50                   unsigned *ret, size_t *size)
  51 {
  52     unsigned val = 0;
  53     size_t oldlen = len;
  54
  55     while (len--)
  56         val = val * 256 + *p++;
  57     *ret = val;
  58     if(size) *size = oldlen;
  59     return 0;
  60 }
  61
  62 int
  63 der_get_int (const unsigned char *p, size_t len,
  64              int *ret, size_t *size)
  65 {
  66     int val = 0;
  67     size_t oldlen = len;
  68
  69     if (len > 0) {
  70         val = (signed char)*p++;
  71         while (--len)
  72             val = val * 256 + *p++;
  73     }
  74     *ret = val;
  75     if(size) *size = oldlen;
  76     return 0;
  77 }
  78
  79 int
  80 der_get_length (const unsigned char *p, size_t len,
  81                 size_t *val, size_t *size)
  82 {
  83     size_t v;
  84
  85     if (len <= 0)
  86         return ASN1_OVERRUN;
  87     --len;
  88     v = *p++;
  89     if (v < 128) {
  90         *val = v;
  91         if(size) *size = 1;
  92     } else {
  93         int e;
  94         size_t l;
  95         unsigned tmp;
  96
  97         if(v == 0x80){
  98             *val = ASN1_INDEFINITE;
  99             if(size) *size = 1;
 100             return 0;
 101         }
 102         v &= 0x7F;
 103         if (len < v)
 104             return ASN1_OVERRUN;
 105         e = der_get_unsigned (p, v, &tmp, &l);
 106         if(e) return e;
 107         *val = tmp;
 108         if(size) *size = l + 1;
 109     }
 110     return 0;
 111 }
 112
 113 int
 114 der_get_general_string (const unsigned char *p, size_t len,
 115                         general_string *str, size_t *size)
 116 {
 117     char *s;
 118
 119     s = malloc (len + 1);
 120     if (s == NULL)
 121         return ENOMEM;
 122     memcpy (s, p, len);
 123     s[len] = '\0';
 124     *str = s;
 125     if(size) *size = len;
 126     return 0;
 127 }
 128
 129 int
 130 der_get_octet_string (const unsigned char *p, size_t len,
 131                       octet_string *data, size_t *size)
 132 {
 133     data->length = len;
 134     data->data = malloc(len);
 135     if (data->data == NULL && data->length != 0)
 136         return ENOMEM;
 137     memcpy (data->data, p, len);
 138     if(size) *size = len;
 139     return 0;
 140 }
 141
 142 int
 143 der_get_oid (const unsigned char *p, size_t len,
 144              oid *data, size_t *size)
 145 {
 146     int n;
 147     size_t oldlen = len;
 148
 149     if (len < 1)
 150         return ASN1_OVERRUN;
 151
 152     data->components = malloc(len * sizeof(*data->components));
 153     if (data->components == NULL && len != 0)
 154         return ENOMEM;
 155     data->components[0] = (*p) / 40;
 156     data->components[1] = (*p) % 40;
 157     --len;
 158     ++p;
 159     for (n = 2; len > 0; ++n) {
 160         unsigned u = 0;
 161
 162         do {
 163             --len;
 164             u = u * 128 + (*p++ % 128);
 165         } while (len > 0 && p[-1] & 0x80);
 166         data->components[n] = u;
 167     }
 168     if (p[-1] & 0x80) {
 169         free_oid (data);
 170         return ASN1_OVERRUN;
 171     }
 172     data->length = n;
 173     if (size)
 174         *size = oldlen;
 175     return 0;
 176 }
 177
 178 int
 179 der_get_tag (const unsigned char *p, size_t len,
 180              Der_class *class, Der_type *type,
 181              int *tag, size_t *size)
 182 {
 183     if (len < 1)
 184         return ASN1_OVERRUN;
 185     *class = (Der_class)(((*p) >> 6) & 0x03);
 186     *type = (Der_type)(((*p) >> 5) & 0x01);
 187     *tag = (*p) & 0x1F;
 188     if(size) *size = 1;
 189     return 0;
 190 }
 191
 192 int
 193 der_match_tag (const unsigned char *p, size_t len,
 194                Der_class class, Der_type type,
 195                int tag, size_t *size)
 196 {
 197     size_t l;
 198     Der_class thisclass;
 199     Der_type thistype;
 200     int thistag;
 201     int e;
 202
 203     e = der_get_tag (p, len, &thisclass, &thistype, &thistag, &l);
 204     if (e) return e;
 205     if (class != thisclass || type != thistype)
 206         return ASN1_BAD_ID;
 207     if(tag > thistag)
 208         return ASN1_MISPLACED_FIELD;
 209     if(tag < thistag)
 210         return ASN1_MISSING_FIELD;
 211     if(size) *size = l;
 212     return 0;
 213 }
 214
 215 int
 216 der_match_tag_and_length (const unsigned char *p, size_t len,
 217                           Der_class class, Der_type type, int tag,
 218                           size_t *length_ret, size_t *size)
 219 {
 220     size_t l, ret = 0;
 221     int e;
 222
 223     e = der_match_tag (p, len, class, type, tag, &l);
 224     if (e) return e;
 225     p += l;
 226     len -= l;
 227     ret += l;
 228     e = der_get_length (p, len, length_ret, &l);
 229     if (e) return e;
 230     p += l;
 231     len -= l;
 232     ret += l;
 233     if(size) *size = ret;
 234     return 0;
 235 }
 236
 237 int
 238 decode_integer (const unsigned char *p, size_t len,
 239                 int *num, size_t *size)
 240 {
 241     size_t ret = 0;
 242     size_t l, reallen;
 243     int e;
 244
 245     e = der_match_tag (p, len, UNIV, PRIM, UT_Integer, &l);
 246     if (e) return e;
 247     p += l;
 248     len -= l;
 249     ret += l;
 250     e = der_get_length (p, len, &reallen, &l);
 251     if (e) return e;
 252     p += l;
 253     len -= l;
 254     ret += l;
 255     if (reallen > len)
 256         return ASN1_OVERRUN;
 257     e = der_get_int (p, reallen, num, &l);
 258     if (e) return e;
 259     p += l;
 260     len -= l;
 261     ret += l;
 262     if(size) *size = ret;
 263     return 0;
 264 }
 265
 266 int
 267 decode_unsigned (const unsigned char *p, size_t len,
 268                  unsigned *num, size_t *size)
 269 {
 270     size_t ret = 0;
 271     size_t l, reallen;
 272     int e;
 273
 274     e = der_match_tag (p, len, UNIV, PRIM, UT_Integer, &l);
 275     if (e) return e;
 276     p += l;
 277     len -= l;
 278     ret += l;
 279     e = der_get_length (p, len, &reallen, &l);
 280     if (e) return e;
 281     p += l;
 282     len -= l;
 283     ret += l;
 284     if (reallen > len)
 285         return ASN1_OVERRUN;
 286     e = der_get_unsigned (p, reallen, num, &l);
 287     if (e) return e;
 288     p += l;
 289     len -= l;
 290     ret += l;
 291     if(size) *size = ret;
 292     return 0;
 293 }
 294
 295 int
 296 decode_enumerated (const unsigned char *p, size_t len,
 297                    unsigned *num, size_t *size)
 298 {
 299     size_t ret = 0;
 300     size_t l, reallen;
 301     int e;
 302
 303     e = der_match_tag (p, len, UNIV, PRIM, UT_Enumerated, &l);
 304     if (e) return e;
 305     p += l;
 306     len -= l;
 307     ret += l;
 308     e = der_get_length (p, len, &reallen, &l);
 309     if (e) return e;
 310     p += l;
 311     len -= l;
 312     ret += l;
 313     e = der_get_int (p, reallen, num, &l);
 314     if (e) return e;
 315     p += l;
 316     len -= l;
 317     ret += l;
 318     if(size) *size = ret;
 319     return 0;
 320 }
 321
 322 int
 323 decode_general_string (const unsigned char *p, size_t len,
 324                        general_string *str, size_t *size)
 325 {
 326     size_t ret = 0;
 327     size_t l;
 328     int e;
 329     size_t slen;
 330
 331     e = der_match_tag (p, len, UNIV, PRIM, UT_GeneralString, &l);
 332     if (e) return e;
 333     p += l;
 334     len -= l;
 335     ret += l;
 336
 337     e = der_get_length (p, len, &slen, &l);
 338     if (e) return e;
 339     p += l;
 340     len -= l;
 341     ret += l;
 342     if (len < slen)
 343         return ASN1_OVERRUN;
 344
 345     e = der_get_general_string (p, slen, str, &l);
 346     if (e) return e;
 347     p += l;
 348     len -= l;
 349     ret += l;
 350     if(size) *size = ret;
 351     return 0;
 352 }
 353
 354 int
 355 decode_octet_string (const unsigned char *p, size_t len,
 356                      octet_string *k, size_t *size)
 357 {
 358     size_t ret = 0;
 359     size_t l;
 360     int e;
 361     size_t slen;
 362
 363     e = der_match_tag (p, len, UNIV, PRIM, UT_OctetString, &l);
 364     if (e) return e;
 365     p += l;
 366     len -= l;
 367     ret += l;
 368
 369     e = der_get_length (p, len, &slen, &l);
 370     if (e) return e;
 371     p += l;
 372     len -= l;
 373     ret += l;
 374     if (len < slen)
 375         return ASN1_OVERRUN;
 376
 377     e = der_get_octet_string (p, slen, k, &l);
 378     if (e) return e;
 379     p += l;
 380     len -= l;
 381     ret += l;
 382     if(size) *size = ret;
 383     return 0;
 384 }
 385
 386 int
 387 decode_oid (const unsigned char *p, size_t len,
 388             oid *k, size_t *size)
 389 {
 390     size_t ret = 0;
 391     size_t l;
 392     int e;
 393     size_t slen;
 394
 395     e = der_match_tag (p, len, UNIV, PRIM, UT_OID, &l);
 396     if (e) return e;
 397     p += l;
 398     len -= l;
 399     ret += l;
 400
 401     e = der_get_length (p, len, &slen, &l);
 402     if (e) return e;
 403     p += l;
 404     len -= l;
 405     ret += l;
 406     if (len < slen)
 407         return ASN1_OVERRUN;
 408
 409     e = der_get_oid (p, slen, k, &l);
 410     if (e) return e;
 411     p += l;
 412     len -= l;
 413     ret += l;
 414     if(size) *size = ret;
 415     return 0;
 416 }
 417
 418 static void
 419 generalizedtime2time (const char *s, time_t *t)
 420 {
 421     struct tm tm;
 422
 423     memset(&tm, 0, sizeof(tm));
 424     sscanf (s, "%04d%02d%02d%02d%02d%02dZ",
 425             &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour,
 426             &tm.tm_min, &tm.tm_sec);
 427     tm.tm_year -= 1900;
 428     tm.tm_mon -= 1;
 429     *t = timegm (&tm);
 430 }
 431
 432 int
 433 decode_generalized_time (const unsigned char *p, size_t len,
 434                          time_t *t, size_t *size)
 435 {
 436     octet_string k;
 437     char *times;
 438     size_t ret = 0;
 439     size_t l;
 440     int e;
 441     size_t slen;
 442
 443     e = der_match_tag (p, len, UNIV, PRIM, UT_GeneralizedTime, &l);
 444     if (e) return e;
 445     p += l;
 446     len -= l;
 447     ret += l;
 448
 449     e = der_get_length (p, len, &slen, &l);
 450     if (e) return e;
 451     p += l;
 452     len -= l;
 453     ret += l;
 454     if (len < slen)
 455         return ASN1_OVERRUN;
 456     e = der_get_octet_string (p, slen, &k, &l);
 457     if (e) return e;
 458     p += l;
 459     len -= l;
 460     ret += l;
 461     times = realloc(k.data, k.length + 1);
 462     if (times == NULL){
 463         free(k.data);
 464         return ENOMEM;
 465     }
 466     times[k.length] = 0;
 467     generalizedtime2time (times, t);
 468     free (times);
 469     if(size) *size = ret;
 470     return 0;
 471 }
 472
 473
 474 int
 475 fix_dce(size_t reallen, size_t *len)
 476 {
 477     if(reallen == ASN1_INDEFINITE)
 478         return 1;
 479     if(*len < reallen)
 480         return -1;
 481     *len = reallen;
 482     return 0;
 483 }
 484 /*
 485  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
 486  * (Royal Institute of Technology, Stockholm, Sweden).
 487  * All rights reserved.
 488  *
 489  * Redistribution and use in source and binary forms, with or without
 490  * modification, are permitted provided that the following conditions
 491  * are met:
 492  *
 493  * 1. Redistributions of source code must retain the above copyright
 494  *    notice, this list of conditions and the following disclaimer.
 495  *
 496  * 2. Redistributions in binary form must reproduce the above copyright
 497  *    notice, this list of conditions and the following disclaimer in the
 498  *    documentation and/or other materials provided with the distribution.
 499  *
 500  * 3. Neither the name of the Institute nor the names of its contributors
 501  *    may be used to endorse or promote products derived from this software
 502  *    without specific prior written permission.
 503  *
 504  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 505  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 506  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 507  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 508  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 509  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 510  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 511  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 512  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 513  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 514  * SUCH DAMAGE.
 515  */
 516
 517
 518 /* RCSID("Heimdal: der_put.c,v 1.27 2001/09/25 23:37:25 assar Exp $"); */
 519
 520 /*
 521  * All encoding functions take a pointer `p' to first position in
 522  * which to write, from the right, `len' which means the maximum
 523  * number of characters we are able to write.  The function returns
 524  * the number of characters written in `size' (if non-NULL).
 525  * The return value is 0 or an error.
 526  */
 527
 528 static int
 529 der_put_unsigned (unsigned char *p, size_t len, unsigned val, size_t *size)
 530 {
 531     unsigned char *base = p;
 532
 533     if (val) {
 534         while (len > 0 && val) {
 535             *p-- = val % 256;
 536             val /= 256;
 537             --len;
 538         }
 539         if (val != 0)
 540             return ASN1_OVERFLOW;
 541         else {
 542             *size = base - p;
 543             return 0;
 544         }
 545     } else if (len < 1)
 546         return ASN1_OVERFLOW;
 547     else {
 548         *p    = 0;
 549         *size = 1;
 550         return 0;
 551     }
 552 }
 553
 554 int
 555 der_put_int (unsigned char *p, size_t len, int val, size_t *size)
 556 {
 557     unsigned char *base = p;
 558
 559     if(val >= 0) {
 560         do {
 561             if(len < 1)
 562                 return ASN1_OVERFLOW;
 563             *p-- = val % 256;
 564             len--;
 565             val /= 256;
 566         } while(val);
 567         if(p[1] >= 128) {
 568             if(len < 1)
 569                 return ASN1_OVERFLOW;
 570             *p-- = 0;
 571             len--;
 572         }
 573     } else {
 574         val = ~val;
 575         do {
 576             if(len < 1)
 577                 return ASN1_OVERFLOW;
 578             *p-- = ~(val % 256);
 579             len--;
 580             val /= 256;
 581         } while(val);
 582         if(p[1] < 128) {
 583             if(len < 1)
 584                 return ASN1_OVERFLOW;
 585             *p-- = 0xff;
 586             len--;
 587         }
 588     }
 589     *size = base - p;
 590     return 0;
 591 }
 592
 593
 594 int
 595 der_put_length (unsigned char *p, size_t len, size_t val, size_t *size)
 596 {
 597     if (len < 1)
 598         return ASN1_OVERFLOW;
 599     if (val < 128) {
 600         *p = val;
 601         *size = 1;
 602         return 0;
 603     } else {
 604         size_t l;
 605         int e;
 606
 607         e = der_put_unsigned (p, len - 1, val, &l);
 608         if (e)
 609             return e;
 610         p -= l;
 611         *p = 0x80 | l;
 612         *size = l + 1;
 613         return 0;
 614     }
 615 }
 616
 617 int
 618 der_put_general_string (unsigned char *p, size_t len,
 619                         const general_string *str, size_t *size)
 620 {
 621     size_t slen = strlen(*str);
 622
 623     if (len < slen)
 624         return ASN1_OVERFLOW;
 625     p -= slen;
 626     len -= slen;
 627     memcpy (p+1, *str, slen);
 628     *size = slen;
 629     return 0;
 630 }
 631
 632 int
 633 der_put_octet_string (unsigned char *p, size_t len,
 634                       const octet_string *data, size_t *size)
 635 {
 636     if (len < data->length)
 637         return ASN1_OVERFLOW;
 638     p -= data->length;
 639     len -= data->length;
 640     memcpy (p+1, data->data, data->length);
 641     *size = data->length;
 642     return 0;
 643 }
 644
 645 int
 646 der_put_oid (unsigned char *p, size_t len,
 647              const oid *data, size_t *size)
 648 {
 649     unsigned char *base = p;
 650     int n;
 651
 652     for (n = data->length - 1; n >= 2; --n) {
 653         unsigned u = data->components[n];
 654
 655         if (len < 1)
 656             return ASN1_OVERFLOW;
 657         *p-- = u % 128;
 658         u /= 128;
 659         --len;
 660         while (u > 0) {
 661             if (len < 1)
 662                 return ASN1_OVERFLOW;
 663             *p-- = 128 + u % 128;
 664             u /= 128;
 665             --len;
 666         }
 667     }
 668     if (len < 1)
 669         return ASN1_OVERFLOW;
 670     *p-- = 40 * data->components[0] + data->components[1];
 671     *size = base - p;
 672     return 0;
 673 }
 674
 675 int
 676 der_put_tag (unsigned char *p, size_t len, Der_class class, Der_type type,
 677              int tag, size_t *size)
 678 {
 679     if (len < 1)
 680         return ASN1_OVERFLOW;
 681     *p = (class << 6) | (type << 5) | tag; /* XXX */
 682     *size = 1;
 683     return 0;
 684 }
 685
 686 int
 687 der_put_length_and_tag (unsigned char *p, size_t len, size_t len_val,
 688                         Der_class class, Der_type type, int tag, size_t *size)
 689 {
 690     size_t ret = 0;
 691     size_t l;
 692     int e;
 693
 694     e = der_put_length (p, len, len_val, &l);
 695     if(e)
 696         return e;
 697     p -= l;
 698     len -= l;
 699     ret += l;
 700     e = der_put_tag (p, len, class, type, tag, &l);
 701     if(e)
 702         return e;
 703     p -= l;
 704     len -= l;
 705     ret += l;
 706     *size = ret;
 707     return 0;
 708 }
 709
 710 int
 711 encode_integer (unsigned char *p, size_t len, const int *data, size_t *size)
 712 {
 713     int num = *data;
 714     size_t ret = 0;
 715     size_t l;
 716     int e;
 717
 718     e = der_put_int (p, len, num, &l);
 719     if(e)
 720         return e;
 721     p -= l;
 722     len -= l;
 723     ret += l;
 724     e = der_put_length_and_tag (p, len, l, UNIV, PRIM, UT_Integer, &l);
 725     if (e)
 726         return e;
 727     p -= l;
 728     len -= l;
 729     ret += l;
 730     *size = ret;
 731     return 0;
 732 }
 733
 734 int
 735 encode_unsigned (unsigned char *p, size_t len, const unsigned *data,
 736                  size_t *size)
 737 {
 738     unsigned num = *data;
 739     size_t ret = 0;
 740     size_t l;
 741     int e;
 742
 743     e = der_put_unsigned (p, len, num, &l);
 744     if(e)
 745         return e;
 746     p -= l;
 747     len -= l;
 748     ret += l;
 749     e = der_put_length_and_tag (p, len, l, UNIV, PRIM, UT_Integer, &l);
 750     if (e)
 751         return e;
 752     p -= l;
 753     len -= l;
 754     ret += l;
 755     *size = ret;
 756     return 0;
 757 }
 758
 759 int
 760 encode_enumerated (unsigned char *p, size_t len, const unsigned *data,
 761                    size_t *size)
 762 {
 763     unsigned num = *data;
 764     size_t ret = 0;
 765     size_t l;
 766     int e;
 767
 768     e = der_put_int (p, len, num, &l);
 769     if(e)
 770         return e;
 771     p -= l;
 772     len -= l;
 773     ret += l;
 774     e = der_put_length_and_tag (p, len, l, UNIV, PRIM, UT_Enumerated, &l);
 775     if (e)
 776         return e;
 777     p -= l;
 778     len -= l;
 779     ret += l;
 780     *size = ret;
 781     return 0;
 782 }
 783
 784 int
 785 encode_general_string (unsigned char *p, size_t len,
 786                        const general_string *data, size_t *size)
 787 {
 788     size_t ret = 0;
 789     size_t l;
 790     int e;
 791
 792     e = der_put_general_string (p, len, data, &l);
 793     if (e)
 794         return e;
 795     p -= l;
 796     len -= l;
 797     ret += l;
 798     e = der_put_length_and_tag (p, len, l, UNIV, PRIM, UT_GeneralString, &l);
 799     if (e)
 800         return e;
 801     p -= l;
 802     len -= l;
 803     ret += l;
 804     *size = ret;
 805     return 0;
 806 }
 807
 808 int
 809 encode_octet_string (unsigned char *p, size_t len,
 810                      const octet_string *k, size_t *size)
 811 {
 812     size_t ret = 0;
 813     size_t l;
 814     int e;
 815
 816     e = der_put_octet_string (p, len, k, &l);
 817     if (e)
 818         return e;
 819     p -= l;
 820     len -= l;
 821     ret += l;
 822     e = der_put_length_and_tag (p, len, l, UNIV, PRIM, UT_OctetString, &l);
 823     if (e)
 824         return e;
 825     p -= l;
 826     len -= l;
 827     ret += l;
 828     *size = ret;
 829     return 0;
 830 }
 831
 832 int
 833 encode_oid(unsigned char *p, size_t len,
 834            const oid *k, size_t *size)
 835 {
 836     size_t ret = 0;
 837     size_t l;
 838     int e;
 839
 840     e = der_put_oid (p, len, k, &l);
 841     if (e)
 842         return e;
 843     p -= l;
 844     len -= l;
 845     ret += l;
 846     e = der_put_length_and_tag (p, len, l, UNIV, PRIM, UT_OID, &l);
 847     if (e)
 848         return e;
 849     p -= l;
 850     len -= l;
 851     ret += l;
 852     *size = ret;
 853     return 0;
 854 }
 855
 856 int
 857 time2generalizedtime (time_t t, octet_string *s)
 858 {
 859      struct tm *tm;
 860
 861      s->data = malloc(16);
 862      if (s->data == NULL)
 863          return ENOMEM;
 864      s->length = 15;
 865      tm = gmtime (&t);
 866      sprintf (s->data, "%04d%02d%02d%02d%02d%02dZ", tm->tm_year + 1900,
 867               tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min,
 868               tm->tm_sec);
 869      return 0;
 870 }
 871
 872 int
 873 encode_generalized_time (unsigned char *p, size_t len,
 874                          const time_t *t, size_t *size)
 875 {
 876     size_t ret = 0;
 877     size_t l;
 878     octet_string k;
 879     int e;
 880
 881     e = time2generalizedtime (*t, &k);
 882     if (e)
 883         return e;
 884     e = der_put_octet_string (p, len, &k, &l);
 885     free (k.data);
 886     if (e)
 887         return e;
 888     p -= l;
 889     len -= l;
 890     ret += l;
 891     e = der_put_length_and_tag (p, len, k.length, UNIV, PRIM,
 892                                 UT_GeneralizedTime, &l);
 893     if (e)
 894         return e;
 895     p -= l;
 896     len -= l;
 897     ret += l;
 898     *size = ret;
 899     return 0;
 900 }
 901 /*
 902  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
 903  * (Royal Institute of Technology, Stockholm, Sweden).
 904  * All rights reserved.
 905  *
 906  * Redistribution and use in source and binary forms, with or without
 907  * modification, are permitted provided that the following conditions
 908  * are met:
 909  *
 910  * 1. Redistributions of source code must retain the above copyright
 911  *    notice, this list of conditions and the following disclaimer.
 912  *
 913  * 2. Redistributions in binary form must reproduce the above copyright
 914  *    notice, this list of conditions and the following disclaimer in the
 915  *    documentation and/or other materials provided with the distribution.
 916  *
 917  * 3. Neither the name of the Institute nor the names of its contributors
 918  *    may be used to endorse or promote products derived from this software
 919  *    without specific prior written permission.
 920  *
 921  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 922  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 923  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 924  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 925  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 926  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 927  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 928  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 929  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 930  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 931  * SUCH DAMAGE.
 932  */
 933
 934
 935 /* RCSID("Heimdal: der_free.c,v 1.8 2001/09/25 13:39:26 assar Exp $"); */
 936
 937 void
 938 free_general_string (general_string *str)
 939 {
 940     free(*str);
 941 }
 942
 943 void
 944 free_octet_string (octet_string *k)
 945 {
 946     free(k->data);
 947 }
 948
 949 void
 950 free_oid (oid *k)
 951 {
 952     free(k->components);
 953 }
 954 /*
 955  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
 956  * (Royal Institute of Technology, Stockholm, Sweden).
 957  * All rights reserved.
 958  *
 959  * Redistribution and use in source and binary forms, with or without
 960  * modification, are permitted provided that the following conditions
 961  * are met:
 962  *
 963  * 1. Redistributions of source code must retain the above copyright
 964  *    notice, this list of conditions and the following disclaimer.
 965  *
 966  * 2. Redistributions in binary form must reproduce the above copyright
 967  *    notice, this list of conditions and the following disclaimer in the
 968  *    documentation and/or other materials provided with the distribution.
 969  *
 970  * 3. Neither the name of the Institute nor the names of its contributors
 971  *    may be used to endorse or promote products derived from this software
 972  *    without specific prior written permission.
 973  *
 974  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
 975  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 976  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 977  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
 978  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 979  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 980  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 981  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 982  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 983  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 984  * SUCH DAMAGE.
 985  */
 986
 987
 988 /* RCSID("Heimdal: der_length.c,v 1.12 2001/09/25 13:39:26 assar Exp $"); */
 989
 990 static size_t
 991 len_unsigned (unsigned val)
 992 {
 993   size_t ret = 0;
 994
 995   do {
 996     ++ret;
 997     val /= 256;
 998   } while (val);
 999   return ret;
1000 }
1001
1002 static size_t
1003 len_int (int val)
1004 {
1005   size_t ret = 0;
1006
1007   if (val == 0)
1008     return 1;
1009   while (val > 255 || val < -255) {
1010     ++ret;
1011     val /= 256;
1012   }
1013   if (val != 0) {
1014     ++ret;
1015     if ((signed char)val != val)
1016       ++ret;
1017     val /= 256;
1018   }
1019   return ret;
1020 }
1021
1022 static size_t
1023 len_oid (const oid *oid)
1024 {
1025     size_t ret = 1;
1026     int n;
1027
1028     for (n = 2; n < oid->length; ++n) {
1029         unsigned u = oid->components[n];
1030
1031         ++ret;
1032         u /= 128;
1033         while (u > 0) {
1034             ++ret;
1035             u /= 128;
1036         }
1037     }
1038     return ret;
1039 }
1040
1041 size_t
1042 length_len (size_t len)
1043 {
1044   if (len < 128)
1045     return 1;
1046   else
1047     return len_unsigned (len) + 1;
1048 }
1049
1050 size_t
1051 length_integer (const int *data)
1052 {
1053   size_t len = len_int (*data);
1054
1055   return 1 + length_len(len) + len;
1056 }
1057
1058 size_t
1059 length_unsigned (const unsigned *data)
1060 {
1061   size_t len = len_unsigned (*data);
1062
1063   return 1 + length_len(len) + len;
1064 }
1065
1066 size_t
1067 length_enumerated (const unsigned *data)
1068 {
1069   size_t len = len_int (*data);
1070
1071   return 1 + length_len(len) + len;
1072 }
1073
1074 size_t
1075 length_general_string (const general_string *data)
1076 {
1077   char *str = *data;
1078   size_t len = strlen(str);
1079   return 1 + length_len(len) + len;
1080 }
1081
1082 size_t
1083 length_octet_string (const octet_string *k)
1084 {
1085   return 1 + length_len(k->length) + k->length;
1086 }
1087
1088 size_t
1089 length_oid (const oid *k)
1090 {
1091   size_t len = len_oid (k);
1092
1093   return 1 + length_len(len) + len;
1094 }
1095
1096 size_t
1097 length_generalized_time (const time_t *t)
1098 {
1099   octet_string k;
1100   size_t ret;
1101
1102   time2generalizedtime (*t, &k);
1103   ret = 1 + length_len(k.length) + k.length;
1104   free (k.data);
1105   return ret;
1106 }
1107 /*
1108  * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan
1109  * (Royal Institute of Technology, Stockholm, Sweden).
1110  * All rights reserved.
1111  *
1112  * Redistribution and use in source and binary forms, with or without
1113  * modification, are permitted provided that the following conditions
1114  * are met:
1115  *
1116  * 1. Redistributions of source code must retain the above copyright
1117  *    notice, this list of conditions and the following disclaimer.
1118  *
1119  * 2. Redistributions in binary form must reproduce the above copyright
1120  *    notice, this list of conditions and the following disclaimer in the
1121  *    documentation and/or other materials provided with the distribution.
1122  *
1123  * 3. Neither the name of the Institute nor the names of its contributors
1124  *    may be used to endorse or promote products derived from this software
1125  *    without specific prior written permission.
1126  *
1127  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
1128  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1129  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1130  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
1131  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1132  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1133  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1134  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1135  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1136  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1137  * SUCH DAMAGE.
1138  */
1139
1140
1141 /* RCSID("Heimdal: der_copy.c,v 1.9 2001/09/25 13:39:25 assar Exp $"); */
1142
1143 int
1144 copy_general_string (const general_string *from, general_string *to)
1145 {
1146     *to = malloc(strlen(*from) + 1);
1147     if(*to == NULL)
1148         return ENOMEM;
1149     strcpy(*to, *from);
1150     return 0;
1151 }
1152
1153 int
1154 copy_octet_string (const octet_string *from, octet_string *to)
1155 {
1156     to->length = from->length;
1157     to->data   = malloc(to->length);
1158     if(to->length != 0 && to->data == NULL)
1159         return ENOMEM;
1160     memcpy(to->data, from->data, to->length);
1161     return 0;
1162 }
1163
1164 int
1165 copy_oid (const oid *from, oid *to)
1166 {
1167     to->length     = from->length;
1168     to->components = malloc(to->length * sizeof(*to->components));
1169     if (to->length != 0 && to->components == NULL)
1170         return ENOMEM;
1171     memcpy(to->components, from->components, to->length);
1172     return 0;
1173 }
1174 /*
1175  * Copyright (c) 1997 Kungliga Tekniska Högskolan
1176  * (Royal Institute of Technology, Stockholm, Sweden).
1177  * All rights reserved.
1178  *
1179  * Redistribution and use in source and binary forms, with or without
1180  * modification, are permitted provided that the following conditions
1181  * are met:
1182  *
1183  * 1. Redistributions of source code must retain the above copyright
1184  *    notice, this list of conditions and the following disclaimer.
1185  *
1186  * 2. Redistributions in binary form must reproduce the above copyright
1187  *    notice, this list of conditions and the following disclaimer in the
1188  *    documentation and/or other materials provided with the distribution.
1189  *
1190  * 3. Neither the name of the Institute nor the names of its contributors
1191  *    may be used to endorse or promote products derived from this software
1192  *    without specific prior written permission.
1193  *
1194  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
1195  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1196  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1197  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
1198  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1199  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1200  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1201  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1202  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1203  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1204  * SUCH DAMAGE.
1205  */
1206
1207
1208 /* RCSID("Heimdal: timegm.c,v 1.7 1999/12/02 17:05:02 joda Exp $"); */
1209
1210 #ifndef HAVE_TIMEGM
1211
1212 static int
1213 is_leap(unsigned y)
1214 {
1215     y += 1900;
1216     return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
1217 }
1218
1219 time_t
1220 timegm (struct tm *tm)
1221 {
1222   static const unsigned ndays[2][12] ={
1223     {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
1224     {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
1225   time_t res = 0;
1226   unsigned i;
1227
1228   for (i = 70; i < tm->tm_year; ++i)
1229     res += is_leap(i) ? 366 : 365;
1230
1231   for (i = 0; i < tm->tm_mon; ++i)
1232     res += ndays[is_leap(tm->tm_year)][i];
1233   res += tm->tm_mday - 1;
1234   res *= 24;
1235   res += tm->tm_hour;
1236   res *= 60;
1237   res += tm->tm_min;
1238   res *= 60;
1239   res += tm->tm_sec;
1240   return res;
1241 }
1242
1243 #endif /* HAVE_TIMEGM */