lib/asn1.c

   1 /* asn1.c       utilities to manipulate RFC 1510 ASN.1 types
   2  * Copyright (C) 2002, 2003  Simon Josefsson
   3  *
   4  * This file is part of Shishi.
   5  *
   6  * Shishi 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 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Shishi 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 Shishi; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include <libtasn1.h>
  23 #define _SHISHI_HAS_LIBTASN1_H 1
  24 #include "internal.h"
  25
  26 /* Defined in kerberos5.c, generated from kerberos5.asn1. */
  27 extern const ASN1_ARRAY_TYPE shishi_asn1_tab[];
  28
  29 int
  30 _shishi_asn1_init (Shishi * handle)
  31 {
  32   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE] = "";
  33   int asn1_result;
  34
  35   if (!asn1_check_version (LIBTASN1_VERSION))
  36     {
  37       shishi_warn (handle, "asn1_check-version(%s) failed: %s",
  38                    LIBTASN1_VERSION, asn1_check_version (NULL));
  39       return SHISHI_ASN1_ERROR;
  40     }
  41
  42   if (!asn1_check_version ("0.2.5"))
  43     shishi_warn (handle, "libtasn1 >= 0.2.5 preferred, you may see bugs.");
  44
  45   asn1_result = asn1_array2tree (shishi_asn1_tab,
  46                                  &handle->asn1, errorDescription);
  47   if (asn1_result != ASN1_SUCCESS)
  48     {
  49       shishi_warn (handle, "asn1_array2tree() failed: %s\n",
  50                    libtasn1_strerror (asn1_result));
  51       shishi_warn (handle, "%s", errorDescription);
  52       return SHISHI_ASN1_ERROR;
  53     }
  54
  55   return SHISHI_OK;
  56 }
  57
  58 int
  59 shishi_asn1_number_of_elements (Shishi * handle, Shishi_asn1 node,
  60                                 const char *field, size_t * n)
  61 {
  62   int rc;
  63
  64   rc = asn1_number_of_elements (node, field, (int *) n);
  65   if (rc != ASN1_SUCCESS)
  66     {
  67       if (rc == ASN1_ELEMENT_NOT_FOUND)
  68         return SHISHI_ASN1_NO_ELEMENT;
  69       else
  70         return SHISHI_ASN1_ERROR;
  71     }
  72
  73   return SHISHI_OK;
  74 }
  75
  76 int
  77 shishi_asn1_empty_p (Shishi * handle, Shishi_asn1 node, const char *field)
  78 {
  79   int rc;
  80   int datalen;
  81
  82   datalen = 0;
  83   rc = asn1_read_value (node, field, NULL, &datalen);
  84   if (rc == ASN1_VALUE_NOT_FOUND)
  85     return 1;
  86
  87   return 0;
  88 }
  89
  90 /* XXX obsolete */
  91 int
  92 shishi_asn1_read (Shishi * handle, Shishi_asn1 node,
  93                   const char *field, char *data, size_t * datalen)
  94 {
  95   int rc;
  96
  97   rc = asn1_read_value (node, field, (unsigned char *) data, (int *) datalen);
  98   if (rc != ASN1_SUCCESS)
  99     {
 100       shishi_error_set (handle, libtasn1_strerror (rc));
 101       if (rc == ASN1_ELEMENT_NOT_FOUND)
 102         return SHISHI_ASN1_NO_ELEMENT;
 103       else if (rc == ASN1_VALUE_NOT_FOUND)
 104         return SHISHI_ASN1_NO_VALUE;
 105       else
 106         return SHISHI_ASN1_ERROR;
 107     }
 108
 109   return SHISHI_OK;
 110 }
 111
 112 /* XXX rename and document */
 113 int
 114 shishi_asn1_read2 (Shishi * handle,
 115                    Shishi_asn1 node, const char *field,
 116                    char **data, size_t * datalen)
 117 {
 118   int rc;
 119
 120   *datalen = 0;
 121   rc = asn1_read_value (node, field, NULL, (int *) datalen);
 122   if (rc != ASN1_MEM_ERROR)
 123     {
 124       shishi_error_set (handle, libtasn1_strerror (rc));
 125       if (rc == ASN1_ELEMENT_NOT_FOUND)
 126         return SHISHI_ASN1_NO_ELEMENT;
 127       else if (rc == ASN1_VALUE_NOT_FOUND)
 128         return SHISHI_ASN1_NO_VALUE;
 129       else
 130         return SHISHI_ASN1_ERROR;
 131     }
 132
 133   *data = xmalloc (*datalen);
 134
 135   rc = shishi_asn1_read (handle, node, field, *data, datalen);
 136   if (rc != SHISHI_OK)
 137     return rc;
 138
 139   return SHISHI_OK;
 140 }
 141
 142 int
 143 shishi_asn1_read_int32 (Shishi * handle, Shishi_asn1 node,
 144                         const char *field, int32_t * i)
 145 {
 146   unsigned char buf[4];
 147   int buflen;
 148   int rc;
 149
 150   memset (buf, 0, sizeof (buf));
 151   buflen = sizeof (buf);
 152   rc = shishi_asn1_read (handle, node, field, buf, &buflen);
 153   if (rc != SHISHI_OK)
 154     return rc;
 155
 156   if (buflen < 4)
 157     {
 158       memset (buf, 0, sizeof (buf));
 159       rc = shishi_asn1_read (handle, node, field, &buf[4 - buflen], &buflen);
 160       if (rc != SHISHI_OK)
 161         return rc;
 162     }
 163   *i = buf[3] | (buf[2] << 8) | (buf[1] << 16) | (buf[0] << 24);
 164
 165   return SHISHI_OK;
 166 }
 167
 168 int
 169 shishi_asn1_read_uint32 (Shishi * handle, Shishi_asn1 node,
 170                          const char *field, uint32_t * i)
 171 {
 172   return shishi_asn1_read_int32 (handle, node, field, (int32_t *) i);
 173 }
 174
 175 int
 176 shishi_asn1_read_integer (Shishi * handle, Shishi_asn1 node,
 177                           const char *field, int *i)
 178 {
 179   return shishi_asn1_read_int32 (handle, node, field, (int32_t *) i);
 180 }
 181
 182 int
 183 shishi_asn1_read_bitstring (Shishi * handle, Shishi_asn1 node,
 184                             const char *field, uint32_t * flags)
 185 {
 186   char *buf;
 187   size_t buflen;
 188   size_t i;
 189   int res;
 190
 191   res = shishi_asn1_read2 (handle, node, field, &buf, &buflen);
 192   if (res != SHISHI_OK)
 193     return res;
 194
 195   if (buflen < 4)
 196     return SHISHI_ASN1_ERROR;
 197
 198   *flags = 0;
 199   for (i = 0; i < 4; i++)
 200     {
 201       *flags |= (((buf[i] >> 7) & 0x01) |
 202                  ((buf[i] >> 5) & 0x02) |
 203                  ((buf[i] >> 3) & 0x04) |
 204                  ((buf[i] >> 1) & 0x08) |
 205                  ((buf[i] << 1) & 0x10) |
 206                  ((buf[i] << 3) & 0x20) |
 207                  ((buf[i] << 5) & 0x40) | ((buf[i] << 7) & 0x80)) << (8 * i);
 208     }
 209
 210   return SHISHI_OK;
 211 }
 212
 213 int
 214 shishi_asn1_read_optional (Shishi * handle,
 215                            Shishi_asn1 node, const char *field,
 216                            char *data, size_t * datalen)
 217 {
 218   int rc;
 219
 220   rc = asn1_read_value (node, field, (unsigned char *) data, (int *) datalen);
 221   if (rc != ASN1_SUCCESS && rc != ASN1_ELEMENT_NOT_FOUND)
 222     {
 223       shishi_error_set (handle, libtasn1_strerror (rc));
 224       return SHISHI_ASN1_ERROR;
 225     }
 226
 227   if (rc == ASN1_ELEMENT_NOT_FOUND)
 228     *datalen = 0;
 229
 230   return SHISHI_OK;
 231 }
 232
 233 int
 234 shishi_asn1_write (Shishi * handle, Shishi_asn1 node,
 235                    const char *field, const char *data, size_t datalen)
 236 {
 237   int rc;
 238
 239   rc = asn1_write_value (node, field,
 240                          (const unsigned char *) data, (int) datalen);
 241   if (rc != ASN1_SUCCESS)
 242     {
 243       shishi_error_set (handle, libtasn1_strerror (rc));
 244       return SHISHI_ASN1_ERROR;
 245     }
 246
 247   return SHISHI_OK;
 248 }
 249
 250 int
 251 shishi_asn1_write_uint32 (Shishi * handle, Shishi_asn1 node,
 252                           const char *field, uint32_t n)
 253 {
 254   char *buf;
 255   int res;
 256
 257   asprintf (&buf, "%ud", n);
 258   res = shishi_asn1_write (handle, node, field, buf, 0);
 259   free (buf);
 260   if (res != SHISHI_OK)
 261     return res;
 262
 263   return SHISHI_OK;
 264 }
 265
 266 int
 267 shishi_asn1_write_int32 (Shishi * handle, Shishi_asn1 node,
 268                          const char *field, int32_t n)
 269 {
 270   char *buf;
 271   int res;
 272
 273   asprintf (&buf, "%d", n);
 274   res = shishi_asn1_write (handle, node, field, buf, 0);
 275   free (buf);
 276   if (res != SHISHI_OK)
 277     return res;
 278
 279   return SHISHI_OK;
 280 }
 281
 282 int
 283 shishi_asn1_write_integer (Shishi * handle, Shishi_asn1 node,
 284                            const char *field, int n)
 285 {
 286   return shishi_asn1_write_int32 (handle, node, field, (int32_t) n);
 287 }
 288
 289 int
 290 shishi_asn1_write_bitstring (Shishi * handle, Shishi_asn1 node,
 291                              const char *field, uint32_t flags)
 292 {
 293   unsigned char buf[4];
 294   size_t i;
 295   int res;
 296
 297   /* XXX
 298      Cannot handle bit strings longer than 32 bits.
 299      Currently not needed though. */
 300
 301   for (i = 0; i < 4; i++)
 302     {
 303       buf[i] = ((((flags >> (8 * i)) >> 7) & 0x01) |
 304                 (((flags >> (8 * i)) >> 5) & 0x02) |
 305                 (((flags >> (8 * i)) >> 3) & 0x04) |
 306                 (((flags >> (8 * i)) >> 1) & 0x08) |
 307                 (((flags >> (8 * i)) << 1) & 0x10) |
 308                 (((flags >> (8 * i)) << 3) & 0x20) |
 309                 (((flags >> (8 * i)) << 5) & 0x40) |
 310                 (((flags >> (8 * i)) << 7) & 0x80));
 311     }
 312
 313   res = shishi_asn1_write (handle, node, field, buf, 32);
 314   if (res != SHISHI_OK)
 315     return res;
 316
 317   return SHISHI_OK;
 318 }
 319
 320 /**
 321  * shishi_asn1_done:
 322  * @handle: shishi handle as allocated by shishi_init().
 323  * @node: ASN.1 node to dellocate.
 324  *
 325  * Deallocate resources associated with ASN.1 structure.  Note that
 326  * the node must not be used after this call.
 327  **/
 328 void
 329 shishi_asn1_done (Shishi * handle, Shishi_asn1 node)
 330 {
 331
 332   int rc;
 333
 334   rc = asn1_delete_structure (&node);
 335   if (rc != ASN1_SUCCESS)
 336     shishi_error_printf (handle, "Cannot dellocate ASN.1 structure: %s",
 337                          libtasn1_strerror (rc));
 338 }
 339
 340 static Shishi_asn1
 341 shishi_asn1_new (Shishi * handle, const char *field, const char *name)
 342 {
 343   ASN1_TYPE node = ASN1_TYPE_EMPTY;
 344   int res;
 345
 346   res = asn1_create_element (handle->asn1, field, &node);
 347   if (res != ASN1_SUCCESS)
 348     {
 349       shishi_error_set (handle, libtasn1_strerror (res));
 350       return NULL;
 351     }
 352
 353   return (Shishi_asn1) node;
 354 }
 355
 356 /**
 357  * shishi_asn1_asreq:
 358  * @handle: shishi handle as allocated by shishi_init().
 359  *
 360  * Create new ASN.1 structure for AS-REQ.
 361  *
 362  * Return value: Returns ASN.1 structure.
 363  **/
 364 Shishi_asn1
 365 shishi_asn1_asreq (Shishi * handle)
 366 {
 367   return shishi_asn1_new (handle, "Kerberos5.AS-REQ", "KDC-REQ");
 368 }
 369
 370 /**
 371  * shishi_asn1_asrep:
 372  * @handle: shishi handle as allocated by shishi_init().
 373  *
 374  * Create new ASN.1 structure for AS-REP.
 375  *
 376  * Return value: Returns ASN.1 structure.
 377  **/
 378 Shishi_asn1
 379 shishi_asn1_asrep (Shishi * handle)
 380 {
 381   return shishi_asn1_new (handle, "Kerberos5.AS-REP", "KDC-REP");
 382 }
 383
 384 /**
 385  * shishi_asn1_tgsreq:
 386  * @handle: shishi handle as allocated by shishi_init().
 387  *
 388  * Create new ASN.1 structure for TGS-REQ.
 389  *
 390  * Return value: Returns ASN.1 structure.
 391  **/
 392 Shishi_asn1
 393 shishi_asn1_tgsreq (Shishi * handle)
 394 {
 395   return shishi_asn1_new (handle, "Kerberos5.TGS-REQ", "KDC-REQ");
 396 }
 397
 398 /**
 399  * shishi_asn1_tgsrep:
 400  * @handle: shishi handle as allocated by shishi_init().
 401  *
 402  * Create new ASN.1 structure for TGS-REP.
 403  *
 404  * Return value: Returns ASN.1 structure.
 405  **/
 406 Shishi_asn1
 407 shishi_asn1_tgsrep (Shishi * handle)
 408 {
 409   return shishi_asn1_new (handle, "Kerberos5.TGS-REP", "KDC-REP");
 410 }
 411
 412 /**
 413  * shishi_asn1_apreq:
 414  * @handle: shishi handle as allocated by shishi_init().
 415  *
 416  * Create new ASN.1 structure for AP-REQ.
 417  *
 418  * Return value: Returns ASN.1 structure.
 419  **/
 420 Shishi_asn1
 421 shishi_asn1_apreq (Shishi * handle)
 422 {
 423   return shishi_asn1_new (handle, "Kerberos5.AP-REQ", "AP-REQ");
 424 }
 425
 426 /**
 427  * shishi_asn1_aprep:
 428  * @handle: shishi handle as allocated by shishi_init().
 429  *
 430  * Create new ASN.1 structure for AP-REP.
 431  *
 432  * Return value: Returns ASN.1 structure.
 433  **/
 434 Shishi_asn1
 435 shishi_asn1_aprep (Shishi * handle)
 436 {
 437   return shishi_asn1_new (handle, "Kerberos5.AP-REP", "AP-REP");
 438 }
 439
 440 /**
 441  * shishi_asn1_encapreppart:
 442  * @handle: shishi handle as allocated by shishi_init().
 443  *
 444  * Create new ASN.1 structure for AP-REP.
 445  *
 446  * Return value: Returns ASN.1 structure.
 447  **/
 448 Shishi_asn1
 449 shishi_asn1_encapreppart (Shishi * handle)
 450 {
 451   return shishi_asn1_new (handle, "Kerberos5.EncAPRepPart", "EncAPRepPart");
 452 }
 453
 454 #define SHISHI_TICKET_DEFAULT_TKTVNO "5"
 455 #define SHISHI_TICKET_DEFAULT_TKTVNO_LEN 0
 456
 457 /**
 458  * shishi_asn1_ticket:
 459  * @handle: shishi handle as allocated by shishi_init().
 460  *
 461  * Create new ASN.1 structure for Ticket.
 462  *
 463  * Return value: Returns ASN.1 structure.
 464  **/
 465 Shishi_asn1
 466 shishi_asn1_ticket (Shishi * handle)
 467 {
 468   int res = ASN1_SUCCESS;
 469   ASN1_TYPE node = ASN1_TYPE_EMPTY;
 470
 471   res = asn1_create_element (handle->asn1, "Kerberos5.Ticket", &node);
 472   if (res != ASN1_SUCCESS)
 473     goto error;
 474
 475 #if 1
 476   res = asn1_write_value (node, "tkt-vno",
 477                           (const unsigned char *)
 478                           SHISHI_TICKET_DEFAULT_TKTVNO,
 479                           SHISHI_TICKET_DEFAULT_TKTVNO_LEN);
 480   if (res != ASN1_SUCCESS)
 481     goto error;
 482 #endif
 483
 484   return (Shishi_asn1) node;
 485
 486 error:
 487   shishi_error_set (handle, libtasn1_strerror (res));
 488   if (node != NULL)
 489     asn1_delete_structure (&node);
 490   return NULL;
 491 }
 492
 493 /**
 494  * shishi_asn1_encticketpart:
 495  * @handle: shishi handle as allocated by shishi_init().
 496  *
 497  * Create new ASN.1 structure for EncTicketPart.
 498  *
 499  * Return value: Returns ASN.1 structure.
 500  **/
 501 Shishi_asn1
 502 shishi_asn1_encticketpart (Shishi * handle)
 503 {
 504   return shishi_asn1_new (handle, "Kerberos5.EncTicketPart", "EncTicketPart");
 505 }
 506
 507 /**
 508  * shishi_asn1_authenticator:
 509  * @handle: shishi handle as allocated by shishi_init().
 510  *
 511  * Create new ASN.1 structure for Authenticator.
 512  *
 513  * Return value: Returns ASN.1 structure.
 514  **/
 515 Shishi_asn1
 516 shishi_asn1_authenticator (Shishi * handle)
 517 {
 518   return shishi_asn1_new (handle, "Kerberos5.Authenticator", "Authenticator");
 519 }
 520
 521 /**
 522  * shishi_asn1_enckdcreppart:
 523  * @handle: shishi handle as allocated by shishi_init().
 524  *
 525  * Create new ASN.1 structure for EncKDCRepPart.
 526  *
 527  * Return value: Returns ASN.1 structure.
 528  **/
 529 Shishi_asn1
 530 shishi_asn1_enckdcreppart (Shishi * handle)
 531 {
 532   return shishi_asn1_new (handle, "Kerberos5.EncKDCRepPart", "EncKDCRepPart");
 533 }
 534
 535 /**
 536  * shishi_asn1_encasreppart:
 537  * @handle: shishi handle as allocated by shishi_init().
 538  *
 539  * Create new ASN.1 structure for EncASRepPart.
 540  *
 541  * Return value: Returns ASN.1 structure.
 542  **/
 543 Shishi_asn1
 544 shishi_asn1_encasreppart (Shishi * handle)
 545 {
 546   return shishi_asn1_new (handle, "Kerberos5.EncASRepPart", "EncKDCRepPart");
 547 }
 548
 549 /**
 550  * shishi_asn1_krberror:
 551  * @handle: shishi handle as allocated by shishi_init().
 552  *
 553  * Create new ASN.1 structure for KRB-ERROR.
 554  *
 555  * Return value: Returns ASN.1 structure.
 556  **/
 557 Shishi_asn1
 558 shishi_asn1_krberror (Shishi * handle)
 559 {
 560   return shishi_asn1_new (handle, "Kerberos5.KRB-ERROR", "KRB-ERROR");
 561 }
 562
 563 /**
 564  * shishi_asn1_krbsafe:
 565  * @handle: shishi handle as allocated by shishi_init().
 566  *
 567  * Create new ASN.1 structure for KRB-SAFE.
 568  *
 569  * Return value: Returns ASN.1 structure.
 570  **/
 571 Shishi_asn1
 572 shishi_asn1_krbsafe (Shishi * handle)
 573 {
 574   return shishi_asn1_new (handle, "Kerberos5.KRB-SAFE", "KRB-SAFE");
 575 }
 576
 577 /**
 578  * shishi_asn1_priv:
 579  * @handle: shishi handle as allocated by shishi_init().
 580  *
 581  * Create new ASN.1 structure for KRB-PRIV.
 582  *
 583  * Return value: Returns ASN.1 structure.
 584  **/
 585 Shishi_asn1
 586 shishi_asn1_priv (Shishi * handle)
 587 {
 588   return shishi_asn1_new (handle, "Kerberos5.KRB-PRIV", "KRB-PRIV");
 589 }
 590
 591 /**
 592  * shishi_asn1_encprivpart:
 593  * @handle: shishi handle as allocated by shishi_init().
 594  *
 595  * Create new ASN.1 structure for EncKrbPrivPart.
 596  *
 597  * Return value: Returns ASN.1 structure.
 598  **/
 599 Shishi_asn1
 600 shishi_asn1_encprivpart (Shishi * handle)
 601 {
 602   return shishi_asn1_new (handle, "Kerberos5.EncKrbPrivPart",
 603                           "EncKrbPrivPart");
 604 }
 605
 606 /* XXX obsolete */
 607 int
 608 shishi_a2d_field (Shishi * handle,
 609                   Shishi_asn1 node, const char *field,
 610                   char *der, size_t * len)
 611 {
 612   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE] = "";
 613   int rc;
 614
 615   rc = asn1_der_coding (node, field, (unsigned char *) der, len,
 616                         errorDescription);
 617   if (rc != ASN1_SUCCESS)
 618     {
 619       shishi_error_set (handle, errorDescription);
 620       return SHISHI_ASN1_ERROR;
 621     }
 622
 623   return SHISHI_OK;
 624 }
 625
 626 /* XXX obsolete */
 627 int
 628 shishi_a2d (Shishi * handle, Shishi_asn1 node, char *der, size_t * len)
 629 {
 630   return shishi_a2d_field (handle, node, "", der, len);
 631 }
 632
 633 /* XXX rename and docuemnt */
 634 int
 635 shishi_a2d_new_field (Shishi * handle, Shishi_asn1 node,
 636                       const char *field, char **der, size_t * len)
 637 {
 638   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE] = "";
 639   int rc;
 640
 641   *len = 0;
 642   rc = asn1_der_coding (node, field, NULL, len, errorDescription);
 643   if (rc != ASN1_MEM_ERROR)
 644     {
 645       shishi_error_set (handle, errorDescription);
 646       return SHISHI_ASN1_ERROR;
 647     }
 648
 649   *der = xmalloc (*len);
 650
 651   rc = asn1_der_coding (node, field, *der, len, errorDescription);
 652   if (rc != ASN1_SUCCESS)
 653     {
 654       shishi_error_set (handle, errorDescription);
 655       return SHISHI_ASN1_ERROR;
 656     }
 657
 658   return SHISHI_OK;
 659 }
 660
 661 /* XXX rename and docuemnt */
 662 int
 663 shishi_new_a2d (Shishi * handle, Shishi_asn1 node, char **der, size_t * len)
 664 {
 665   return shishi_a2d_new_field (handle, node, "", der, len);
 666 }
 667
 668 static Shishi_asn1
 669 der2asn1 (Shishi * handle,
 670           const char *fieldname,
 671           const char *nodename, const char *der, size_t derlen)
 672 {
 673   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE] = "";
 674   Shishi_asn1 structure = NULL;
 675   int asn1_result = ASN1_SUCCESS;
 676
 677   asn1_result = asn1_create_element (handle->asn1, fieldname, &structure);
 678   if (asn1_result != ASN1_SUCCESS)
 679     {
 680       shishi_error_set (handle, libtasn1_strerror (asn1_result));
 681       return NULL;
 682     }
 683
 684   asn1_result = asn1_der_decoding (&structure, (const unsigned char *) der,
 685                                    (int) derlen, errorDescription);
 686   if (asn1_result != ASN1_SUCCESS)
 687     {
 688       asn1_delete_structure (&structure);
 689       shishi_error_set (handle, errorDescription);
 690       return NULL;
 691     }
 692
 693   return structure;
 694 }
 695
 696 /**
 697  * shishi_asn1_msgtype:
 698  * @handle: shishi handle as allocated by shishi_init().
 699  * @node: ASN.1 type to get msg type for.
 700  *
 701  * Determine msg-type of ASN.1 type of a Kerberos Protocol
 702  * packet. Currently this uses the msg-type field instead of the
 703  * APPLICATION tag, but this may be changed in the future.
 704  *
 705  * Return value: Returns msg-type of ASN.1 type, 0 on failure.
 706  **/
 707 Shishi_msgtype
 708 shishi_asn1_msgtype (Shishi * handle, Shishi_asn1 node)
 709 {
 710   asn1_retCode rc;
 711   uint32_t msgtype;
 712
 713   /* XXX Use APPLICATION tag instead. */
 714   rc = shishi_asn1_read_uint32 (handle, node, "msg-type", &msgtype);
 715   if (rc != SHISHI_OK)
 716     return 0;
 717
 718   return msgtype;
 719 }
 720
 721 /**
 722  * shishi_der_msgtype:
 723  * @handle: shishi handle as allocated by shishi_init().
 724  * @der: input character array with DER encoding.
 725  * @derlen: length of input character array with DER encoding.
 726  *
 727  * Determine msg-type of DER coded data of a Kerberos Protocol packet.
 728  *
 729  * Return value: Returns msg-type of DER data, 0 on failure.
 730  **/
 731 Shishi_msgtype
 732 shishi_der_msgtype (Shishi * handle, const char *der, size_t derlen)
 733 {
 734   /* XXX Doesn't handle APPLICATION TAGS > 31. */
 735   if (derlen > 1 && *der >= 0x60 && (unsigned char) *der <= 0x7F)
 736     return *der - 0x60;
 737   else
 738     return 0;
 739 }
 740
 741 /**
 742  * shishi_der2asn1:
 743  * @handle: shishi handle as allocated by shishi_init().
 744  * @der: input character array with DER encoding.
 745  * @derlen: length of input character array with DER encoding.
 746  *
 747  * Convert arbitrary DER data of a Kerberos Protocol packet to a
 748  * Kerberos ASN.1 type.
 749  *
 750  * Return value: Returns newly allocate ASN.1 corresponding to DER
 751  *   data, or %NULL on failure.
 752  **/
 753 Shishi_asn1
 754 shishi_der2asn1 (Shishi * handle, const char *der, size_t derlen)
 755 {
 756   Shishi_asn1 node;
 757
 758   switch (shishi_der_msgtype (handle, der, derlen))
 759     {
 760     case SHISHI_MSGTYPE_AS_REQ:
 761       node = shishi_der2asn1_asreq (handle, der, derlen);
 762       break;
 763
 764     case SHISHI_MSGTYPE_AS_REP:
 765       node = shishi_der2asn1_asrep (handle, der, derlen);
 766       break;
 767
 768     case SHISHI_MSGTYPE_TGS_REQ:
 769       node = shishi_der2asn1_tgsreq (handle, der, derlen);
 770       break;
 771
 772     case SHISHI_MSGTYPE_TGS_REP:
 773       node = shishi_der2asn1_tgsrep (handle, der, derlen);
 774       break;
 775
 776     case SHISHI_MSGTYPE_AP_REQ:
 777       node = shishi_der2asn1_apreq (handle, der, derlen);
 778       break;
 779
 780     case SHISHI_MSGTYPE_AP_REP:
 781       node = shishi_der2asn1_aprep (handle, der, derlen);
 782       break;
 783
 784     case SHISHI_MSGTYPE_SAFE:
 785       node = shishi_der2asn1_krbsafe (handle, der, derlen);
 786       break;
 787
 788     case SHISHI_MSGTYPE_PRIV:
 789       node = shishi_der2asn1_priv (handle, der, derlen);
 790       break;
 791
 792     case SHISHI_MSGTYPE_CRED:
 793       /* node = shishi_der2asn1_cred (handle, der, derlen); */
 794       break;
 795
 796     case SHISHI_MSGTYPE_ERROR:
 797       node = shishi_der2asn1_krberror (handle, der, derlen);
 798       break;
 799
 800     default:
 801       node = NULL;
 802       break;
 803     }
 804
 805   return node;
 806 }
 807
 808 /**
 809  * shishi_der2asn1_ticket:
 810  * @handle: shishi handle as allocated by shishi_init().
 811  * @der: input character array with DER encoding.
 812  * @derlen: length of input character array with DER encoding.
 813  *
 814  * Decode DER encoding of Ticket and create a ASN.1 structure.
 815  *
 816  * Return value: Returns ASN.1 structure corresponding to DER data.
 817  **/
 818 Shishi_asn1
 819 shishi_der2asn1_ticket (Shishi * handle, const char *der, size_t derlen)
 820 {
 821   return der2asn1 (handle, "Kerberos5.Ticket", "Ticket", der, derlen);
 822 }
 823
 824 /**
 825  * shishi_der2asn1_encticketpart:
 826  * @handle: shishi handle as allocated by shishi_init().
 827  * @der: input character array with DER encoding.
 828  * @derlen: length of input character array with DER encoding.
 829  *
 830  * Decode DER encoding of EncTicketPart and create a ASN.1 structure.
 831  *
 832  * Return value: Returns ASN.1 structure corresponding to DER data.
 833  **/
 834 Shishi_asn1
 835 shishi_der2asn1_encticketpart (Shishi * handle, const char *der,
 836                                size_t derlen)
 837 {
 838   return der2asn1 (handle, "Kerberos5.EncTicketPart", "EncTicketPart",
 839                    der, derlen);
 840 }
 841
 842 /**
 843  * shishi_der2asn1_asreq:
 844  * @handle: shishi handle as allocated by shishi_init().
 845  * @der: input character array with DER encoding.
 846  * @derlen: length of input character array with DER encoding.
 847  *
 848  * Decode DER encoding of AS-REQ and create a ASN.1 structure.
 849  *
 850  * Return value: Returns ASN.1 structure corresponding to DER data.
 851  **/
 852 Shishi_asn1
 853 shishi_der2asn1_asreq (Shishi * handle, const char *der, size_t derlen)
 854 {
 855   return der2asn1 (handle, "Kerberos5.AS-REQ", "KDC-REQ", der, derlen);
 856 }
 857
 858 /**
 859  * shishi_der2asn1_tgsreq:
 860  * @handle: shishi handle as allocated by shishi_init().
 861  * @der: input character array with DER encoding.
 862  * @derlen: length of input character array with DER encoding.
 863  *
 864  * Decode DER encoding of TGS-REQ and create a ASN.1 structure.
 865  *
 866  * Return value: Returns ASN.1 structure corresponding to DER data.
 867  **/
 868 Shishi_asn1
 869 shishi_der2asn1_tgsreq (Shishi * handle, const char *der, size_t derlen)
 870 {
 871   return der2asn1 (handle, "Kerberos5.TGS-REQ", "KDC-REQ", der, derlen);
 872 }
 873
 874 /**
 875  * shishi_der2asn1_asrep:
 876  * @handle: shishi handle as allocated by shishi_init().
 877  * @der: input character array with DER encoding.
 878  * @derlen: length of input character array with DER encoding.
 879  *
 880  * Decode DER encoding of AS-REP and create a ASN.1 structure.
 881  *
 882  * Return value: Returns ASN.1 structure corresponding to DER data.
 883  **/
 884 Shishi_asn1
 885 shishi_der2asn1_asrep (Shishi * handle, const char *der, size_t derlen)
 886 {
 887   return der2asn1 (handle, "Kerberos5.AS-REP", "KDC-REP", der, derlen);
 888 }
 889
 890 /**
 891  * shishi_der2asn1_tgsrep:
 892  * @handle: shishi handle as allocated by shishi_init().
 893  * @der: input character array with DER encoding.
 894  * @derlen: length of input character array with DER encoding.
 895  *
 896  * Decode DER encoding of TGS-REP and create a ASN.1 structure.
 897  *
 898  * Return value: Returns ASN.1 structure corresponding to DER data.
 899  **/
 900 Shishi_asn1
 901 shishi_der2asn1_tgsrep (Shishi * handle, const char *der, size_t derlen)
 902 {
 903   return der2asn1 (handle, "Kerberos5.TGS-REP", "KDC-REP", der, derlen);
 904 }
 905
 906 /**
 907  * shishi_der2asn1_kdcrep:
 908  * @handle: shishi handle as allocated by shishi_init().
 909  * @der: input character array with DER encoding.
 910  * @derlen: length of input character array with DER encoding.
 911  *
 912  * Decode DER encoding of KDC-REP and create a ASN.1 structure.
 913  *
 914  * Return value: Returns ASN.1 structure corresponding to DER data.
 915  **/
 916 Shishi_asn1
 917 shishi_der2asn1_kdcrep (Shishi * handle, const char *der, size_t derlen)
 918 {
 919   return der2asn1 (handle, "Kerberos5.KDC-REP", "KDC-REP", der, derlen);
 920 }
 921
 922 /**
 923  * shishi_der2asn1_encasreppart:
 924  * @handle: shishi handle as allocated by shishi_init().
 925  * @der: input character array with DER encoding.
 926  * @derlen: length of input character array with DER encoding.
 927  *
 928  * Decode DER encoding of EncASRepPart and create a ASN.1 structure.
 929  *
 930  * Return value: Returns ASN.1 structure corresponding to DER data.
 931  **/
 932 Shishi_asn1
 933 shishi_der2asn1_encasreppart (Shishi * handle, const char *der, size_t derlen)
 934 {
 935   return der2asn1 (handle, "Kerberos5.EncASRepPart", "EncKDCRepPart",
 936                    der, derlen);
 937 }
 938
 939 /**
 940  * shishi_der2asn1_enctgsreppart:
 941  * @handle: shishi handle as allocated by shishi_init().
 942  * @der: input character array with DER encoding.
 943  * @derlen: length of input character array with DER encoding.
 944  *
 945  * Decode DER encoding of EncTGSRepPart and create a ASN.1 structure.
 946  *
 947  * Return value: Returns ASN.1 structure corresponding to DER data.
 948  **/
 949 Shishi_asn1
 950 shishi_der2asn1_enctgsreppart (Shishi * handle, const char *der,
 951                                size_t derlen)
 952 {
 953   return der2asn1 (handle, "Kerberos5.EncTGSRepPart", "EncKDCRepPart",
 954                    der, derlen);
 955 }
 956
 957 /**
 958  * shishi_der2asn1_enckdcreppart:
 959  * @handle: shishi handle as allocated by shishi_init().
 960  * @der: input character array with DER encoding.
 961  * @derlen: length of input character array with DER encoding.
 962  *
 963  * Decode DER encoding of EncKDCRepPart and create a ASN.1 structure.
 964  *
 965  * Return value: Returns ASN.1 structure corresponding to DER data.
 966  **/
 967 Shishi_asn1
 968 shishi_der2asn1_enckdcreppart (Shishi * handle, const char *der,
 969                                size_t derlen)
 970 {
 971   return der2asn1 (handle, "Kerberos5.EncKDCRepPart", "EncKDCRepPart",
 972                    der, derlen);
 973 }
 974
 975 /**
 976  * shishi_der2asn1_authenticator:
 977  * @handle: shishi handle as allocated by shishi_init().
 978  * @der: input character array with DER encoding.
 979  * @derlen: length of input character array with DER encoding.
 980  *
 981  * Decode DER encoding of Authenticator and create a ASN.1 structure.
 982  *
 983  * Return value: Returns ASN.1 structure corresponding to DER data.
 984  **/
 985 Shishi_asn1
 986 shishi_der2asn1_authenticator (Shishi * handle, const char *der,
 987                                size_t derlen)
 988 {
 989   return der2asn1 (handle, "Kerberos5.Authenticator", "Authenticator",
 990                    der, derlen);
 991 }
 992
 993 /**
 994  * shishi_der2asn1_krberror:
 995  * @handle: shishi handle as allocated by shishi_init().
 996  * @der: input character array with DER encoding.
 997  * @derlen: length of input character array with DER encoding.
 998  *
 999  * Decode DER encoding of KRB-ERROR and create a ASN.1 structure.
1000  *
1001  * Return value: Returns ASN.1 structure corresponding to DER data.
1002  **/
1003 Shishi_asn1
1004 shishi_der2asn1_krberror (Shishi * handle, const char *der, size_t derlen)
1005 {
1006   return der2asn1 (handle, "Kerberos5.KRB-ERROR", "KRB-ERROR", der, derlen);
1007 }
1008
1009 /**
1010  * shishi_der2asn1_krbsafe:
1011  * @handle: shishi handle as allocated by shishi_init().
1012  * @der: input character array with DER encoding.
1013  * @derlen: length of input character array with DER encoding.
1014  *
1015  * Decode DER encoding of KRB-SAFE and create a ASN.1 structure.
1016  *
1017  * Return value: Returns ASN.1 structure corresponding to DER data.
1018  **/
1019 Shishi_asn1
1020 shishi_der2asn1_krbsafe (Shishi * handle, const char *der, size_t derlen)
1021 {
1022   return der2asn1 (handle, "Kerberos5.KRB-SAFE", "KRB-SAFE", der, derlen);
1023 }
1024
1025 /**
1026  * shishi_der2asn1_priv:
1027  * @handle: shishi handle as allocated by shishi_init().
1028  * @der: input character array with DER encoding.
1029  * @derlen: length of input character array with DER encoding.
1030  *
1031  * Decode DER encoding of KRB-PRIV and create a ASN.1 structure.
1032  *
1033  * Return value: Returns ASN.1 structure corresponding to DER data.
1034  **/
1035 Shishi_asn1
1036 shishi_der2asn1_priv (Shishi * handle, const char *der, size_t derlen)
1037 {
1038   return der2asn1 (handle, "Kerberos5.KRB-PRIV", "KRB-PRIV", der, derlen);
1039 }
1040
1041 /**
1042  * shishi_der2asn1_encprivpart:
1043  * @handle: shishi handle as allocated by shishi_init().
1044  * @der: input character array with DER encoding.
1045  * @derlen: length of input character array with DER encoding.
1046  *
1047  * Decode DER encoding of EncKrbPrivPart and create a ASN.1 structure.
1048  *
1049  * Return value: Returns ASN.1 structure corresponding to DER data.
1050  **/
1051 Shishi_asn1
1052 shishi_der2asn1_encprivpart (Shishi * handle, const char *der, size_t derlen)
1053 {
1054   return der2asn1 (handle, "Kerberos5.EncKrbPrivPart", "EncKrbPrivPart",
1055                    der, derlen);
1056 }
1057
1058 /**
1059  * shishi_der2asn1_apreq:
1060  * @handle: shishi handle as allocated by shishi_init().
1061  * @der: input character array with DER encoding.
1062  * @derlen: length of input character array with DER encoding.
1063  *
1064  * Decode DER encoding of AP-REQ and create a ASN.1 structure.
1065  *
1066  * Return value: Returns ASN.1 structure corresponding to DER data.
1067  **/
1068 Shishi_asn1
1069 shishi_der2asn1_apreq (Shishi * handle, const char *der, size_t derlen)
1070 {
1071   return der2asn1 (handle, "Kerberos5.AP-REQ", "AP-REQ", der, derlen);
1072 }
1073
1074 /**
1075  * shishi_der2asn1_aprep:
1076  * @handle: shishi handle as allocated by shishi_init().
1077  * @der: input character array with DER encoding.
1078  * @derlen: length of input character array with DER encoding.
1079  *
1080  * Decode DER encoding of AP-REP and create a ASN.1 structure.
1081  *
1082  * Return value: Returns ASN.1 structure corresponding to DER data.
1083  **/
1084 Shishi_asn1
1085 shishi_der2asn1_aprep (Shishi * handle, const char *der, size_t derlen)
1086 {
1087   return der2asn1 (handle, "Kerberos5.AP-REP", "AP-REP", der, derlen);
1088 }
1089
1090 /**
1091  * shishi_der2asn1_encapreppart:
1092  * @handle: shishi handle as allocated by shishi_init().
1093  * @der: input character array with DER encoding.
1094  * @derlen: length of input character array with DER encoding.
1095  *
1096  * Decode DER encoding of EncAPRepPart and create a ASN.1 structure.
1097  *
1098  * Return value: Returns ASN.1 structure corresponding to DER data.
1099  **/
1100 Shishi_asn1
1101 shishi_der2asn1_encapreppart (Shishi * handle, const char *der, size_t derlen)
1102 {
1103   return der2asn1 (handle, "Kerberos5.EncAPRepPart", "EncAPRepPart",
1104                    der, derlen);
1105 }
1106
1107 /**
1108  * shishi_der2asn1_kdcreq:
1109  * @handle: shishi handle as allocated by shishi_init().
1110  * @der: input character array with DER encoding.
1111  * @derlen: length of input character array with DER encoding.
1112  *
1113  * Decode DER encoding of AS-REQ, TGS-REQ or KDC-REQ and create a
1114  * ASN.1 structure.
1115  *
1116  * Return value: Returns ASN.1 structure corresponding to DER data.
1117  **/
1118 Shishi_asn1
1119 shishi_der2asn1_kdcreq (Shishi * handle, const char *der, size_t derlen)
1120 {
1121   Shishi_asn1 structure = NULL;
1122
1123   structure = shishi_der2asn1_asreq (handle, der, derlen);
1124   if (structure == NULL)
1125     {
1126       printf ("der2asn1_kdcreq: not asreq\n");
1127       shishi_error_printf (handle, "Could not DER decode AS-REQ\n");
1128
1129       structure = shishi_der2asn1_tgsreq (handle, der, derlen);
1130       if (structure == NULL)
1131         {
1132           printf ("der2asn1_kdcreq: not tgsreq\n");
1133           shishi_error_printf (handle, "Could not DER decode TGS-REQ\n");
1134
1135           structure = shishi_der2asn1_kdcreq (handle, der, derlen);
1136           if (structure == NULL)
1137             {
1138               printf ("der2asn1_kdcreq: not kdcreq\n");
1139               shishi_error_printf (handle, "Could not DER decode KDC-REQ\n");
1140
1141               return NULL;
1142             }
1143           else
1144             printf ("der2asn1_kdcreq: kdcreq!!\n");
1145         }
1146     }
1147
1148   return structure;
1149 }