src/crypto/asn1.c

   1 /*
   2  * Copyright (C) 2007 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdint.h>
  27 #include <stddef.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <time.h>
  33 #include <ipxe/tables.h>
  34 #include <ipxe/image.h>
  35 #include <ipxe/asn1.h>
  36
  37 /** @file
  38  *
  39  * ASN.1 encoding
  40  *
  41  */
  42
  43 /* Disambiguate the various error causes */
  44 #define EINVAL_ASN1_EMPTY \
  45         __einfo_error ( EINFO_EINVAL_ASN1_EMPTY )
  46 #define EINFO_EINVAL_ASN1_EMPTY \
  47         __einfo_uniqify ( EINFO_EINVAL, 0x01, "Empty or underlength cursor" )
  48 #define EINVAL_ASN1_LEN_LEN \
  49         __einfo_error ( EINFO_EINVAL_ASN1_LEN_LEN )
  50 #define EINFO_EINVAL_ASN1_LEN_LEN \
  51         __einfo_uniqify ( EINFO_EINVAL, 0x02, "Length field overruns cursor" )
  52 #define EINVAL_ASN1_LEN \
  53         __einfo_error ( EINFO_EINVAL_ASN1_LEN )
  54 #define EINFO_EINVAL_ASN1_LEN \
  55         __einfo_uniqify ( EINFO_EINVAL, 0x03, "Field overruns cursor" )
  56 #define EINVAL_ASN1_BOOLEAN \
  57         __einfo_error ( EINFO_EINVAL_ASN1_BOOLEAN )
  58 #define EINFO_EINVAL_ASN1_BOOLEAN \
  59         __einfo_uniqify ( EINFO_EINVAL, 0x04, "Invalid boolean" )
  60 #define EINVAL_ASN1_INTEGER \
  61         __einfo_error ( EINFO_EINVAL_ASN1_INTEGER )
  62 #define EINFO_EINVAL_ASN1_INTEGER \
  63         __einfo_uniqify ( EINFO_EINVAL, 0x04, "Invalid integer" )
  64 #define EINVAL_ASN1_TIME \
  65         __einfo_error ( EINFO_EINVAL_ASN1_TIME )
  66 #define EINFO_EINVAL_ASN1_TIME \
  67         __einfo_uniqify ( EINFO_EINVAL, 0x05, "Invalid time" )
  68 #define EINVAL_ASN1_ALGORITHM \
  69         __einfo_error ( EINFO_EINVAL_ASN1_ALGORITHM )
  70 #define EINFO_EINVAL_ASN1_ALGORITHM \
  71         __einfo_uniqify ( EINFO_EINVAL, 0x06, "Invalid algorithm" )
  72 #define EINVAL_BIT_STRING \
  73         __einfo_error ( EINFO_EINVAL_BIT_STRING )
  74 #define EINFO_EINVAL_BIT_STRING \
  75         __einfo_uniqify ( EINFO_EINVAL, 0x07, "Invalid bit string" )
  76 #define ENOTSUP_ALGORITHM \
  77         __einfo_error ( EINFO_ENOTSUP_ALGORITHM )
  78 #define EINFO_ENOTSUP_ALGORITHM \
  79         __einfo_uniqify ( EINFO_ENOTSUP, 0x01, "Unsupported algorithm" )
  80 #define ENOTTY_ALGORITHM \
  81         __einfo_error ( EINFO_ENOTTY_ALGORITHM )
  82 #define EINFO_ENOTTY_ALGORITHM \
  83         __einfo_uniqify ( EINFO_ENOTTY, 0x01, "Inappropriate algorithm" )
  84
  85 /**
  86  * Start parsing ASN.1 object
  87  *
  88  * @v cursor            ASN.1 object cursor
  89  * @v type              Expected type, or ASN1_ANY
  90  * @v extra             Additional length not present within partial cursor
  91  * @ret len             Length of object body, or negative error
  92  *
  93  * The object cursor will be updated to point to the start of the
  94  * object body (i.e. the first byte following the length byte(s)), and
  95  * the length of the object body (i.e. the number of bytes until the
  96  * following object tag, if any) is returned.
  97  */
  98 int asn1_start ( struct asn1_cursor *cursor, unsigned int type, size_t extra ) {
  99         unsigned int len_len;
 100         unsigned int len;
 101
 102         /* Sanity check */
 103         if ( cursor->len < 2 /* Tag byte and first length byte */ ) {
 104                 if ( cursor->len )
 105                         DBGC ( cursor, "ASN1 %p too short\n", cursor );
 106                 return -EINVAL_ASN1_EMPTY;
 107         }
 108
 109         /* Check the tag byte */
 110         if ( ( type != ASN1_ANY ) && ( type != asn1_type ( cursor ) ) ) {
 111                 DBGC ( cursor, "ASN1 %p type mismatch (expected %d, got %d)\n",
 112                        cursor, type, *( ( uint8_t * ) cursor->data ) );
 113                 return -ENXIO;
 114         }
 115         cursor->data++;
 116         cursor->len--;
 117
 118         /* Extract length of the length field and sanity check */
 119         len_len = *( ( uint8_t * ) cursor->data );
 120         if ( len_len & 0x80 ) {
 121                 len_len = ( len_len & 0x7f );
 122                 cursor->data++;
 123                 cursor->len--;
 124         } else {
 125                 len_len = 1;
 126         }
 127         if ( cursor->len < len_len ) {
 128                 DBGC ( cursor, "ASN1 %p bad length field length %d (max "
 129                        "%zd)\n", cursor, len_len, cursor->len );
 130                 return -EINVAL_ASN1_LEN_LEN;
 131         }
 132
 133         /* Extract the length and sanity check */
 134         for ( len = 0 ; len_len ; len_len-- ) {
 135                 len <<= 8;
 136                 len |= *( ( uint8_t * ) cursor->data );
 137                 cursor->data++;
 138                 cursor->len--;
 139         }
 140         if ( ( cursor->len + extra ) < len ) {
 141                 DBGC ( cursor, "ASN1 %p bad length %d (max %zd)\n",
 142                        cursor, len, ( cursor->len + extra ) );
 143                 return -EINVAL_ASN1_LEN;
 144         }
 145
 146         return len;
 147 }
 148
 149 /**
 150  * Enter ASN.1 object
 151  *
 152  * @v cursor            ASN.1 object cursor
 153  * @v type              Expected type, or ASN1_ANY
 154  * @ret rc              Return status code
 155  *
 156  * The object cursor will be updated to point to the body of the
 157  * current ASN.1 object.  If any error occurs, the object cursor will
 158  * be invalidated.
 159  */
 160 int asn1_enter ( struct asn1_cursor *cursor, unsigned int type ) {
 161         int len;
 162
 163         len = asn1_start ( cursor, type, 0 );
 164         if ( len < 0 ) {
 165                 asn1_invalidate_cursor ( cursor );
 166                 return len;
 167         }
 168
 169         cursor->len = len;
 170         DBGC ( cursor, "ASN1 %p entered object type %02x (len %x)\n",
 171                cursor, type, len );
 172
 173         return 0;
 174 }
 175
 176 /**
 177  * Skip ASN.1 object if present
 178  *
 179  * @v cursor            ASN.1 object cursor
 180  * @v type              Expected type, or ASN1_ANY
 181  * @ret rc              Return status code
 182  *
 183  * The object cursor will be updated to point to the next ASN.1
 184  * object.  If any error occurs, the object cursor will not be
 185  * modified.
 186  */
 187 int asn1_skip_if_exists ( struct asn1_cursor *cursor, unsigned int type ) {
 188         int len;
 189
 190         len = asn1_start ( cursor, type, 0 );
 191         if ( len < 0 )
 192                 return len;
 193
 194         cursor->data += len;
 195         cursor->len -= len;
 196         DBGC ( cursor, "ASN1 %p skipped object type %02x (len %x)\n",
 197                cursor, type, len );
 198
 199         if ( ! cursor->len ) {
 200                 DBGC ( cursor, "ASN1 %p reached end of object\n", cursor );
 201                 return -ENOENT;
 202         }
 203
 204         return 0;
 205 }
 206
 207 /**
 208  * Skip ASN.1 object
 209  *
 210  * @v cursor            ASN.1 object cursor
 211  * @v type              Expected type, or ASN1_ANY
 212  * @ret rc              Return status code
 213  *
 214  * The object cursor will be updated to point to the next ASN.1
 215  * object.  If any error occurs, the object cursor will be
 216  * invalidated.
 217  */
 218 int asn1_skip ( struct asn1_cursor *cursor, unsigned int type ) {
 219         int rc;
 220
 221         if ( ( rc = asn1_skip_if_exists ( cursor, type ) ) != 0 ) {
 222                 asn1_invalidate_cursor ( cursor );
 223                 return rc;
 224         }
 225
 226         return 0;
 227 }
 228
 229 /**
 230  * Shrink ASN.1 cursor to fit object
 231  *
 232  * @v cursor            ASN.1 object cursor
 233  * @v type              Expected type, or ASN1_ANY
 234  * @ret rc              Return status code
 235  *
 236  * The object cursor will be shrunk to contain only the current ASN.1
 237  * object.  If any error occurs, the object cursor will be
 238  * invalidated.
 239  */
 240 int asn1_shrink ( struct asn1_cursor *cursor, unsigned int type ) {
 241         struct asn1_cursor temp;
 242         const void *end;
 243         int len;
 244
 245         /* Find end of object */
 246         memcpy ( &temp, cursor, sizeof ( temp ) );
 247         len = asn1_start ( &temp, type, 0 );
 248         if ( len < 0 ) {
 249                 asn1_invalidate_cursor ( cursor );
 250                 return len;
 251         }
 252         end = ( temp.data + len );
 253
 254         /* Shrink original cursor to contain only its first object */
 255         cursor->len = ( end - cursor->data );
 256
 257         return 0;
 258 }
 259
 260 /**
 261  * Enter ASN.1 object of any type
 262  *
 263  * @v cursor            ASN.1 object cursor
 264  * @ret rc              Return status code
 265  */
 266 int asn1_enter_any ( struct asn1_cursor *cursor ) {
 267         return asn1_enter ( cursor, ASN1_ANY );
 268 }
 269
 270 /**
 271  * Skip ASN.1 object of any type
 272  *
 273  * @v cursor            ASN.1 object cursor
 274  * @ret rc              Return status code
 275  */
 276 int asn1_skip_any ( struct asn1_cursor *cursor ) {
 277         return asn1_skip ( cursor, ASN1_ANY );
 278 }
 279
 280 /**
 281  * Shrink ASN.1 object of any type
 282  *
 283  * @v cursor            ASN.1 object cursor
 284  * @ret rc              Return status code
 285  */
 286 int asn1_shrink_any ( struct asn1_cursor *cursor ) {
 287         return asn1_shrink ( cursor, ASN1_ANY );
 288 }
 289
 290 /**
 291  * Parse value of ASN.1 boolean
 292  *
 293  * @v cursor            ASN.1 object cursor
 294  * @ret value           Value, or negative error
 295  */
 296 int asn1_boolean ( const struct asn1_cursor *cursor ) {
 297         struct asn1_cursor contents;
 298         const struct {
 299                 uint8_t value;
 300         } __attribute__ (( packed )) *boolean;
 301
 302         /* Enter boolean */
 303         memcpy ( &contents, cursor, sizeof ( contents ) );
 304         asn1_enter ( &contents, ASN1_BOOLEAN );
 305         if ( contents.len != sizeof ( *boolean ) )
 306                 return -EINVAL_ASN1_BOOLEAN;
 307
 308         /* Extract value */
 309         boolean = contents.data;
 310         return boolean->value;
 311 }
 312
 313 /**
 314  * Parse value of ASN.1 integer
 315  *
 316  * @v cursor            ASN.1 object cursor
 317  * @v value             Value to fill in
 318  * @ret rc              Return status code
 319  */
 320 int asn1_integer ( const struct asn1_cursor *cursor, int *value ) {
 321         struct asn1_cursor contents;
 322         uint8_t high_byte;
 323         int rc;
 324
 325         /* Enter integer */
 326         memcpy ( &contents, cursor, sizeof ( contents ) );
 327         if ( ( rc = asn1_enter ( &contents, ASN1_INTEGER ) ) != 0 )
 328                 return rc;
 329         if ( contents.len < 1 )
 330                 return -EINVAL_ASN1_INTEGER;
 331
 332         /* Initialise value according to sign byte */
 333         *value = *( ( int8_t * ) contents.data );
 334         contents.data++;
 335         contents.len--;
 336
 337         /* Process value */
 338         while ( contents.len ) {
 339                 high_byte = ( (*value) >> ( 8 * ( sizeof ( *value ) - 1 ) ) );
 340                 if ( ( high_byte != 0x00 ) && ( high_byte != 0xff ) ) {
 341                         DBGC ( cursor, "ASN1 %p integer overflow\n", cursor );
 342                         return -EINVAL_ASN1_INTEGER;
 343                 }
 344                 *value = ( ( *value << 8 ) | *( ( uint8_t * ) contents.data ) );
 345                 contents.data++;
 346                 contents.len--;
 347         }
 348
 349         return 0;
 350 }
 351
 352 /**
 353  * Parse ASN.1 bit string
 354  *
 355  * @v cursor            ASN.1 cursor
 356  * @v bits              Bit string to fill in
 357  * @ret rc              Return status code
 358  */
 359 int asn1_bit_string ( const struct asn1_cursor *cursor,
 360                       struct asn1_bit_string *bits ) {
 361         struct asn1_cursor contents;
 362         const struct {
 363                 uint8_t unused;
 364                 uint8_t data[0];
 365         } __attribute__ (( packed )) *bit_string;
 366         size_t len;
 367         unsigned int unused;
 368         uint8_t unused_mask;
 369         const uint8_t *last;
 370         int rc;
 371
 372         /* Enter bit string */
 373         memcpy ( &contents, cursor, sizeof ( contents ) );
 374         if ( ( rc = asn1_enter ( &contents, ASN1_BIT_STRING ) ) != 0 ) {
 375                 DBGC ( cursor, "ASN1 %p cannot locate bit string:\n", cursor );
 376                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 377                 return rc;
 378         }
 379
 380         /* Validity checks */
 381         if ( contents.len < sizeof ( *bit_string ) ) {
 382                 DBGC ( cursor, "ASN1 %p invalid bit string:\n", cursor );
 383                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 384                 return -EINVAL_BIT_STRING;
 385         }
 386         bit_string = contents.data;
 387         len = ( contents.len - offsetof ( typeof ( *bit_string ), data ) );
 388         unused = bit_string->unused;
 389         unused_mask = ( 0xff >> ( 8 - unused ) );
 390         last = ( bit_string->data + len - 1 );
 391         if ( ( unused >= 8 ) ||
 392              ( ( unused > 0 ) && ( len == 0 ) ) ||
 393              ( ( *last & unused_mask ) != 0 ) ) {
 394                 DBGC ( cursor, "ASN1 %p invalid bit string:\n", cursor );
 395                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 396                 return -EINVAL_BIT_STRING;
 397         }
 398
 399         /* Populate bit string */
 400         bits->data = &bit_string->data;
 401         bits->len = len;
 402         bits->unused = unused;
 403
 404         return 0;
 405 }
 406
 407 /**
 408  * Parse ASN.1 bit string that must be an integral number of bytes
 409  *
 410  * @v cursor            ASN.1 cursor
 411  * @v bits              Bit string to fill in
 412  * @ret rc              Return status code
 413  */
 414 int asn1_integral_bit_string ( const struct asn1_cursor *cursor,
 415                                struct asn1_bit_string *bits ) {
 416         int rc;
 417
 418         /* Parse bit string */
 419         if ( ( rc = asn1_bit_string ( cursor, bits ) ) != 0 )
 420                 return rc;
 421
 422         /* Check that there are no unused bits at end of string */
 423         if ( bits->unused ) {
 424                 DBGC ( cursor, "ASN1 %p invalid integral bit string:\n",
 425                        cursor );
 426                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 427                 return -EINVAL_BIT_STRING;
 428         }
 429
 430         return 0;
 431 }
 432
 433 /**
 434  * Compare two ASN.1 objects
 435  *
 436  * @v cursor1           ASN.1 object cursor
 437  * @v cursor2           ASN.1 object cursor
 438  * @ret difference      Difference as returned by memcmp()
 439  *
 440  * Note that invalid and empty cursors will compare as equal with each
 441  * other.
 442  */
 443 int asn1_compare ( const struct asn1_cursor *cursor1,
 444                    const struct asn1_cursor *cursor2 ) {
 445         int difference;
 446
 447         difference = ( cursor2->len - cursor1->len );
 448         return ( difference ? difference :
 449                  memcmp ( cursor1->data, cursor2->data, cursor1->len ) );
 450 }
 451
 452 /**
 453  * Identify ASN.1 algorithm by OID
 454  *
 455  * @v cursor            ASN.1 object cursor
 456
 457  * @ret algorithm       Algorithm, or NULL
 458  */
 459 static struct asn1_algorithm *
 460 asn1_find_algorithm ( const struct asn1_cursor *cursor ) {
 461         struct asn1_algorithm *algorithm;
 462
 463         for_each_table_entry ( algorithm, ASN1_ALGORITHMS ) {
 464                 if ( asn1_compare ( &algorithm->oid, cursor ) == 0 )
 465                         return algorithm;
 466         }
 467
 468         return NULL;
 469 }
 470
 471 /**
 472  * Parse ASN.1 OID-identified algorithm
 473  *
 474  * @v cursor            ASN.1 object cursor
 475  * @ret algorithm       Algorithm
 476  * @ret rc              Return status code
 477  */
 478 int asn1_algorithm ( const struct asn1_cursor *cursor,
 479                      struct asn1_algorithm **algorithm ) {
 480         struct asn1_cursor contents;
 481         int rc;
 482
 483         /* Enter signatureAlgorithm */
 484         memcpy ( &contents, cursor, sizeof ( contents ) );
 485         asn1_enter ( &contents, ASN1_SEQUENCE );
 486
 487         /* Enter algorithm */
 488         if ( ( rc = asn1_enter ( &contents, ASN1_OID ) ) != 0 ) {
 489                 DBGC ( cursor, "ASN1 %p cannot locate algorithm OID:\n",
 490                        cursor );
 491                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 492                 return -EINVAL_ASN1_ALGORITHM;
 493         }
 494
 495         /* Identify algorithm */
 496         *algorithm = asn1_find_algorithm ( &contents );
 497         if ( ! *algorithm ) {
 498                 DBGC ( cursor, "ASN1 %p unrecognised algorithm:\n", cursor );
 499                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 500                 return -ENOTSUP_ALGORITHM;
 501         }
 502
 503         return 0;
 504 }
 505
 506 /**
 507  * Parse ASN.1 OID-identified public-key algorithm
 508  *
 509  * @v cursor            ASN.1 object cursor
 510  * @ret algorithm       Algorithm
 511  * @ret rc              Return status code
 512  */
 513 int asn1_pubkey_algorithm ( const struct asn1_cursor *cursor,
 514                             struct asn1_algorithm **algorithm ) {
 515         int rc;
 516
 517         /* Parse algorithm */
 518         if ( ( rc = asn1_algorithm ( cursor, algorithm ) ) != 0 )
 519                 return rc;
 520
 521         /* Check algorithm has a public key */
 522         if ( ! (*algorithm)->pubkey ) {
 523                 DBGC ( cursor, "ASN1 %p algorithm %s is not a public-key "
 524                        "algorithm:\n", cursor, (*algorithm)->name );
 525                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 526                 return -ENOTTY_ALGORITHM;
 527         }
 528
 529         return 0;
 530 }
 531
 532 /**
 533  * Parse ASN.1 OID-identified digest algorithm
 534  *
 535  * @v cursor            ASN.1 object cursor
 536  * @ret algorithm       Algorithm
 537  * @ret rc              Return status code
 538  */
 539 int asn1_digest_algorithm ( const struct asn1_cursor *cursor,
 540                             struct asn1_algorithm **algorithm ) {
 541         int rc;
 542
 543         /* Parse algorithm */
 544         if ( ( rc = asn1_algorithm ( cursor, algorithm ) ) != 0 )
 545                 return rc;
 546
 547         /* Check algorithm has a digest */
 548         if ( ! (*algorithm)->digest ) {
 549                 DBGC ( cursor, "ASN1 %p algorithm %s is not a digest "
 550                        "algorithm:\n", cursor, (*algorithm)->name );
 551                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 552                 return -ENOTTY_ALGORITHM;
 553         }
 554
 555         return 0;
 556 }
 557
 558 /**
 559  * Parse ASN.1 OID-identified signature algorithm
 560  *
 561  * @v cursor            ASN.1 object cursor
 562  * @ret algorithm       Algorithm
 563  * @ret rc              Return status code
 564  */
 565 int asn1_signature_algorithm ( const struct asn1_cursor *cursor,
 566                                struct asn1_algorithm **algorithm ) {
 567         int rc;
 568
 569         /* Parse algorithm */
 570         if ( ( rc = asn1_algorithm ( cursor, algorithm ) ) != 0 )
 571                 return rc;
 572
 573         /* Check algorithm has a public key */
 574         if ( ! (*algorithm)->pubkey ) {
 575                 DBGC ( cursor, "ASN1 %p algorithm %s is not a signature "
 576                        "algorithm:\n", cursor, (*algorithm)->name );
 577                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 578                 return -ENOTTY_ALGORITHM;
 579         }
 580
 581         /* Check algorithm has a digest */
 582         if ( ! (*algorithm)->digest ) {
 583                 DBGC ( cursor, "ASN1 %p algorithm %s is not a signature "
 584                        "algorithm:\n", cursor, (*algorithm)->name );
 585                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 586                 return -ENOTTY_ALGORITHM;
 587         }
 588
 589         return 0;
 590 }
 591
 592 /**
 593  * Parse ASN.1 GeneralizedTime
 594  *
 595  * @v cursor            ASN.1 cursor
 596  * @v time              Time to fill in
 597  * @ret rc              Return status code
 598  *
 599  * RFC 5280 section 4.1.2.5 places several restrictions on the allowed
 600  * formats for UTCTime and GeneralizedTime, and mandates the
 601  * interpretation of centuryless year values.
 602  */
 603 int asn1_generalized_time ( const struct asn1_cursor *cursor, time_t *time ) {
 604         struct asn1_cursor contents;
 605         unsigned int have_century;
 606         unsigned int type;
 607         union {
 608                 struct {
 609                         uint8_t century;
 610                         uint8_t year;
 611                         uint8_t month;
 612                         uint8_t day;
 613                         uint8_t hour;
 614                         uint8_t minute;
 615                         uint8_t second;
 616                 } __attribute__ (( packed )) named;
 617                 uint8_t raw[7];
 618         } pairs;
 619         struct tm tm;
 620         const uint8_t *data;
 621         size_t remaining;
 622         unsigned int tens;
 623         unsigned int units;
 624         unsigned int i;
 625         int rc;
 626
 627         /* Determine time format utcTime/generalizedTime */
 628         memcpy ( &contents, cursor, sizeof ( contents ) );
 629         type = asn1_type ( &contents );
 630         switch ( type ) {
 631         case ASN1_UTC_TIME:
 632                 have_century = 0;
 633                 break;
 634         case ASN1_GENERALIZED_TIME:
 635                 have_century = 1;
 636                 break;
 637         default:
 638                 DBGC ( cursor, "ASN1 %p invalid time type %02x\n",
 639                        cursor, type );
 640                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 641                 return -EINVAL_ASN1_TIME;
 642         }
 643
 644         /* Enter utcTime/generalizedTime */
 645         if ( ( rc = asn1_enter ( &contents, type ) ) != 0 ) {
 646                 DBGC ( cursor, "ASN1 %p cannot locate %s time:\n", cursor,
 647                        ( ( type == ASN1_UTC_TIME ) ? "UTC" : "generalized" ) );
 648                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 649                 return rc;
 650         }
 651
 652         /* Parse digit string a pair at a time */
 653         memset ( &pairs, 0, sizeof ( pairs ) );
 654         data = contents.data;
 655         remaining = contents.len;
 656         for ( i = ( have_century ? 0 : 1 ) ; i < sizeof ( pairs.raw ) ; i++ ) {
 657                 if ( remaining < 2 ) {
 658                         /* Some certificates violate the X.509 RFC by
 659                          * omitting the "seconds" value.
 660                          */
 661                         if ( i == ( sizeof ( pairs.raw ) - 1 ) )
 662                                 break;
 663                         DBGC ( cursor, "ASN1 %p invalid time:\n", cursor );
 664                         DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 665                         return -EINVAL_ASN1_TIME;
 666                 }
 667                 tens = data[0];
 668                 units = data[1];
 669                 if ( ! ( isdigit ( tens ) && isdigit ( units ) ) ) {
 670                         DBGC ( cursor, "ASN1 %p invalid time:\n", cursor );
 671                         DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 672                         return -EINVAL_ASN1_TIME;
 673                 }
 674                 pairs.raw[i] = ( ( 10 * ( tens - '0' ) ) + ( units - '0' ) );
 675                 data += 2;
 676                 remaining -= 2;
 677         }
 678
 679         /* Determine century if applicable */
 680         if ( ! have_century )
 681                 pairs.named.century = ( ( pairs.named.year >= 50 ) ? 19 : 20 );
 682
 683         /* Check for trailing "Z" */
 684         if ( ( remaining != 1 ) || ( data[0] != 'Z' ) ) {
 685                 DBGC ( cursor, "ASN1 %p invalid time:\n", cursor );
 686                 DBGC_HDA ( cursor, 0, cursor->data, cursor->len );
 687                 return -EINVAL_ASN1_TIME;
 688         }
 689
 690         /* Fill in time */
 691         tm.tm_year = ( ( ( pairs.named.century - 19 ) * 100 ) +
 692                        pairs.named.year );
 693         tm.tm_mon = ( pairs.named.month - 1 );
 694         tm.tm_mday = pairs.named.day;
 695         tm.tm_hour = pairs.named.hour;
 696         tm.tm_min = pairs.named.minute;
 697         tm.tm_sec = pairs.named.second;
 698
 699         /* Convert to seconds since the Epoch */
 700         *time = mktime ( &tm );
 701
 702         return 0;
 703 }
 704
 705 /**
 706  * Construct ASN.1 header
 707  *
 708  * @v header            ASN.1 builder header
 709  * @v type              Type
 710  * @v len               Content length
 711  * @ret header_len      Header length
 712  */
 713 static size_t asn1_header ( struct asn1_builder_header *header,
 714                             unsigned int type, size_t len ) {
 715         unsigned int header_len = 2;
 716         unsigned int len_len = 0;
 717         size_t temp;
 718
 719         /* Construct header */
 720         header->type = type;
 721         if ( len < 0x80 ) {
 722                 header->length[0] = len;
 723         } else {
 724                 for ( temp = len ; temp ; temp >>= 8 )
 725                         len_len++;
 726                 header->length[0] = ( 0x80 | len_len );
 727                 header_len += len_len;
 728                 for ( temp = len ; temp ; temp >>= 8 )
 729                         header->length[len_len--] = ( temp & 0xff );
 730         }
 731
 732         return header_len;
 733 }
 734
 735 /**
 736  * Grow ASN.1 builder
 737  *
 738  * @v builder           ASN.1 builder
 739  * @v extra             Extra space to prepend
 740  * @ret rc              Return status code
 741  */
 742 int asn1_grow ( struct asn1_builder *builder, size_t extra ) {
 743         size_t new_len;
 744         void *new;
 745
 746         /* As with the ASN1 parsing functions, make errors permanent */
 747         if ( builder->len && ! builder->data )
 748                 return -ENOMEM;
 749
 750         /* Reallocate data buffer */
 751         new_len = ( builder->len + extra );
 752         new = realloc ( builder->data, new_len );
 753         if ( ! new ) {
 754                 free ( builder->data );
 755                 builder->data = NULL;
 756                 return -ENOMEM;
 757         }
 758         builder->data = new;
 759
 760         /* Move existing data to end of buffer */
 761         memmove ( ( builder->data + extra ), builder->data, builder->len );
 762         builder->len = new_len;
 763
 764         return 0;
 765 }
 766
 767 /**
 768  * Prepend raw data to ASN.1 builder
 769  *
 770  * @v builder           ASN.1 builder
 771  * @v data              Data to prepend
 772  * @v len               Length of data to prepend
 773  * @ret rc              Return status code
 774  */
 775 int asn1_prepend_raw ( struct asn1_builder *builder, const void *data,
 776                        size_t len ) {
 777         int rc;
 778
 779         /* Grow buffer */
 780         if ( ( rc = asn1_grow ( builder, len ) ) != 0 )
 781                 return rc;
 782
 783         /* Populate data buffer */
 784         memcpy ( builder->data, data, len );
 785
 786         return 0;
 787 }
 788
 789 /**
 790  * Prepend data to ASN.1 builder
 791  *
 792  * @v builder           ASN.1 builder
 793  * @v type              Type
 794  * @v data              Data to prepend
 795  * @v len               Length of data to prepend
 796  * @ret rc              Return status code
 797  */
 798 int asn1_prepend ( struct asn1_builder *builder, unsigned int type,
 799                    const void *data, size_t len ) {
 800         struct asn1_builder_header header;
 801         size_t header_len;
 802         int rc;
 803
 804         /* Construct header */
 805         header_len = asn1_header ( &header, type, len );
 806
 807         /* Grow buffer */
 808         if ( ( rc = asn1_grow ( builder, header_len + len ) ) != 0 )
 809                 return rc;
 810
 811         /* Populate data buffer */
 812         memcpy ( builder->data, &header, header_len );
 813         memcpy ( ( builder->data + header_len ), data, len );
 814
 815         return 0;
 816 }
 817
 818 /**
 819  * Wrap ASN.1 builder
 820  *
 821  * @v builder           ASN.1 builder
 822  * @v type              Type
 823  * @ret rc              Return status code
 824  */
 825 int asn1_wrap ( struct asn1_builder *builder, unsigned int type ) {
 826         struct asn1_builder_header header;
 827         size_t header_len;
 828         int rc;
 829
 830         /* Construct header */
 831         header_len = asn1_header ( &header, type, builder->len );
 832
 833         /* Grow buffer */
 834         if ( ( rc = asn1_grow ( builder, header_len ) ) != 0 )
 835                 return rc;
 836
 837         /* Populate data buffer */
 838         memcpy ( builder->data, &header, header_len );
 839
 840         return 0;
 841 }
 842
 843 /**
 844  * Extract ASN.1 object from image
 845  *
 846  * @v image             Image
 847  * @v offset            Offset within image
 848  * @v cursor            ASN.1 cursor to fill in
 849  * @ret next            Offset to next image, or negative error
 850  *
 851  * The caller is responsible for eventually calling free() on the
 852  * allocated ASN.1 cursor.
 853  */
 854 int image_asn1 ( struct image *image, size_t offset,
 855                  struct asn1_cursor **cursor ) {
 856         int next;
 857         int rc;
 858
 859         /* Sanity check */
 860         assert ( offset <= image->len );
 861
 862         /* Check that this image can be used to extract an ASN.1 object */
 863         if ( ! ( image->type && image->type->asn1 ) )
 864                 return -ENOTSUP;
 865
 866         /* Try creating ASN.1 cursor */
 867         next = image->type->asn1 ( image, offset, cursor );
 868         if ( next < 0 ) {
 869                 rc = next;
 870                 DBGC ( image, "IMAGE %s could not extract ASN.1 object: %s\n",
 871                        image->name, strerror ( rc ) );
 872                 return rc;
 873         }
 874
 875         return next;
 876 }
 877
 878 /* Drag in objects via image_asn1() */
 879 REQUIRING_SYMBOL ( image_asn1 );
 880
 881 /* Drag in ASN.1 image formats */
 882 REQUIRE_OBJECT ( config_asn1 );