LCOV - code coverage report
Current view: top level - src - cert.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 1093 0.0 %
Date: 2016-12-15 12:55:14 Functions: 0 36 0.0 %

          Line data    Source code
       1             : /* cert.c - main function for the certificate handling
       2             :  *      Copyright (C) 2001, 2002, 2003, 2004, 2005, 2012 g10 Code GmbH
       3             :  *
       4             :  * This file is part of KSBA.
       5             :  *
       6             :  * KSBA is free software; you can redistribute it and/or modify
       7             :  * it under the terms of either
       8             :  *
       9             :  *   - the GNU Lesser General Public License as published by the Free
      10             :  *     Software Foundation; either version 3 of the License, or (at
      11             :  *     your option) any later version.
      12             :  *
      13             :  * or
      14             :  *
      15             :  *   - the GNU General Public License as published by the Free
      16             :  *     Software Foundation; either version 2 of the License, or (at
      17             :  *     your option) any later version.
      18             :  *
      19             :  * or both in parallel, as here.
      20             :  *
      21             :  * KSBA is distributed in the hope that it will be useful, but WITHOUT
      22             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      23             :  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      24             :  * License for more details.
      25             :  *
      26             :  * You should have received a copies of the GNU General Public License
      27             :  * and the GNU Lesser General Public License along with this program;
      28             :  * if not, see <http://www.gnu.org/licenses/>.
      29             :  */
      30             : 
      31             : #include <config.h>
      32             : #include <stdio.h>
      33             : #include <stdlib.h>
      34             : #include <string.h>
      35             : #include <assert.h>
      36             : #include <errno.h>
      37             : 
      38             : #include "util.h"
      39             : #include "ber-decoder.h"
      40             : #include "ber-help.h"
      41             : #include "convert.h"
      42             : #include "keyinfo.h"
      43             : #include "sexp-parse.h"
      44             : #include "cert.h"
      45             : 
      46             : 
      47             : static const char oidstr_subjectKeyIdentifier[] = "2.5.29.14";
      48             : static const char oidstr_keyUsage[]         = "2.5.29.15";
      49             : static const char oidstr_subjectAltName[]   = "2.5.29.17";
      50             : static const char oidstr_issuerAltName[]    = "2.5.29.18";
      51             : static const char oidstr_basicConstraints[] = "2.5.29.19";
      52             : static const char oidstr_crlDistributionPoints[] = "2.5.29.31";
      53             : static const char oidstr_certificatePolicies[] = "2.5.29.32";
      54             : static const char oidstr_authorityKeyIdentifier[] = "2.5.29.35";
      55             : static const char oidstr_extKeyUsage[] = "2.5.29.37";
      56             : static const char oidstr_authorityInfoAccess[] = "1.3.6.1.5.5.7.1.1";
      57             : static const char oidstr_subjectInfoAccess[]   = "1.3.6.1.5.5.7.1.11";
      58             : 
      59             : 
      60             : /**
      61             :  * ksba_cert_new:
      62             :  *
      63             :  * Create a new and empty certificate object
      64             :  *
      65             :  * Return value: 0 on success or error code.  For a successful
      66             :  * operation, ACERT is set to the new certifixate obbject, otherwise
      67             :  * it is set to NULL.
      68             :  **/
      69             : gpg_error_t
      70           0 : ksba_cert_new (ksba_cert_t *acert)
      71             : {
      72           0 :   *acert = xtrycalloc (1, sizeof **acert);
      73           0 :   if (!*acert)
      74           0 :     return gpg_error_from_errno (errno);
      75           0 :   (*acert)->ref_count++;
      76             : 
      77           0 :   return 0;
      78             : }
      79             : 
      80             : void
      81           0 : ksba_cert_ref (ksba_cert_t cert)
      82             : {
      83           0 :   if (!cert)
      84           0 :     fprintf (stderr, "BUG: ksba_cert_ref for NULL\n");
      85             :   else
      86           0 :     ++cert->ref_count;
      87           0 : }
      88             : 
      89             : /**
      90             :  * ksba_cert_release:
      91             :  * @cert: A certificate object
      92             :  *
      93             :  * Release a certificate object.
      94             :  **/
      95             : void
      96           0 : ksba_cert_release (ksba_cert_t cert)
      97             : {
      98             :   int i;
      99             : 
     100           0 :   if (!cert)
     101           0 :     return;
     102           0 :   if (cert->ref_count < 1)
     103             :     {
     104           0 :       fprintf (stderr, "BUG: trying to release an already released cert\n");
     105           0 :       return;
     106             :     }
     107           0 :   if (--cert->ref_count)
     108           0 :     return;
     109             : 
     110           0 :   if (cert->udata)
     111             :     {
     112           0 :       struct cert_user_data *ud = cert->udata;
     113           0 :       cert->udata = NULL;
     114             :       do
     115             :         {
     116           0 :           struct cert_user_data *ud2 = ud->next;
     117           0 :           if (ud->data && ud->data != ud->databuf)
     118           0 :             xfree (ud->data);
     119           0 :           xfree (ud);
     120           0 :           ud = ud2;
     121             :         }
     122           0 :       while (ud);
     123             :     }
     124             : 
     125           0 :   xfree (cert->cache.digest_algo);
     126           0 :   if (cert->cache.extns_valid)
     127             :     {
     128           0 :       for (i=0; i < cert->cache.n_extns; i++)
     129           0 :         xfree (cert->cache.extns[i].oid);
     130           0 :       xfree (cert->cache.extns);
     131             :     }
     132             : 
     133           0 :   _ksba_asn_release_nodes (cert->root);
     134           0 :   ksba_asn_tree_release (cert->asn_tree);
     135             : 
     136           0 :   xfree (cert->image);
     137             : 
     138           0 :   xfree (cert);
     139             : }
     140             : 
     141             : 
     142             : /* Store arbitrary data along with a certificate.  The DATA of length
     143             :    DATALEN will be stored under the string KEY.  If some data is
     144             :    already stored under this key it will be replaced by the new data.
     145             :    Using NULL for DATA will effectivly delete the data.
     146             : 
     147             :    On error (i.e. out or memory) an already existing data object
     148             :    stored under KEY may get deleted.
     149             : 
     150             :    This function is not thread safe because we don't employ any
     151             :    locking. */
     152             : gpg_error_t
     153           0 : ksba_cert_set_user_data (ksba_cert_t cert,
     154             :                          const char *key, const void *data, size_t datalen)
     155             : {
     156             :   struct cert_user_data *ud;
     157             : 
     158           0 :   if (!cert || !key || !*key)
     159           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     160             : 
     161           0 :   for (ud=cert->udata; ud; ud = ud->next)
     162           0 :     if (!strcmp (ud->key, key))
     163           0 :       break;
     164           0 :   if (ud)  /* Update the data stored under this key or reuse this item. */
     165             :     {
     166           0 :       if (ud->data && ud->data != ud->databuf)
     167           0 :         xfree (ud->data);
     168           0 :       ud->data = NULL;
     169           0 :       if (data && datalen <= sizeof ud->databuf)
     170             :         {
     171           0 :           memcpy (ud->databuf, data, datalen);
     172           0 :           ud->data = ud->databuf;
     173           0 :           ud->datalen = datalen;
     174             :         }
     175           0 :       else if (data)
     176             :         {
     177           0 :           ud->data = xtrymalloc (datalen);
     178           0 :           if (!ud->data)
     179           0 :             return gpg_error_from_errno (errno);
     180           0 :           memcpy (ud->data, data, datalen);
     181           0 :           ud->datalen = datalen;
     182             :         }
     183             :     }
     184           0 :   else if (data) /* Insert as a new item. */
     185             :     {
     186           0 :       ud = xtrycalloc (1, sizeof *ud + strlen (key));
     187           0 :       if (!ud)
     188           0 :         return gpg_error_from_errno (errno);
     189           0 :       strcpy (ud->key, key);
     190           0 :       if (datalen <= sizeof ud->databuf)
     191             :         {
     192           0 :           memcpy (ud->databuf, data, datalen);
     193           0 :           ud->data = ud->databuf;
     194           0 :           ud->datalen = datalen;
     195             :         }
     196             :       else
     197             :         {
     198           0 :           ud->data = xtrymalloc (datalen);
     199           0 :           if (!ud->data)
     200             :             {
     201           0 :               xfree (ud);
     202           0 :               return gpg_error_from_errno (errno);
     203             :             }
     204           0 :           memcpy (ud->data, data, datalen);
     205           0 :           ud->datalen = datalen;
     206             :         }
     207           0 :       ud->next = cert->udata;
     208           0 :       cert->udata = ud;
     209             :     }
     210             : 
     211           0 :   return 0;
     212             : }
     213             : 
     214             : 
     215             : 
     216             : /* Return user data for certificate CERT stored under the string
     217             :    KEY. The caller needs to provide a suitable large BUFFER and pass
     218             :    the usable length of the buffer in BUFFERLEN.  If DATALEN is not
     219             :    NULL, the length of the data stored at BUFFER will be stored there.
     220             : 
     221             :    If BUFFER is NULL, BUFFERLEN will be ignored and the required
     222             :    length of the buffer will be returned at DATALEN.
     223             : 
     224             :    On success 0 is returned.  If no data is stored under KEY
     225             :    GPG_ERR_NOT_FOUND is returned.  If the provided buffer is too
     226             :    short, GPG_ERR_BUFFER_TOO_SHORT will be returned (note, that this
     227             :    is not the case if BUFFER is NULL).
     228             : */
     229             : gpg_error_t
     230           0 : ksba_cert_get_user_data (ksba_cert_t cert, const char *key,
     231             :                          void *buffer, size_t bufferlen, size_t *datalen)
     232             : {
     233             :   struct cert_user_data *ud;
     234             : 
     235           0 :   if (!cert || !key || !*key)
     236           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     237             : 
     238           0 :   for (ud=cert->udata; ud; ud = ud->next)
     239           0 :     if (!strcmp (ud->key, key))
     240           0 :       break;
     241           0 :   if (!ud || !ud->data)
     242           0 :     return gpg_error (GPG_ERR_NOT_FOUND);
     243           0 :   if (datalen)
     244           0 :     *datalen = ud->datalen;
     245           0 :   if (buffer)
     246             :     {
     247           0 :       if (ud->datalen > bufferlen)
     248           0 :         return gpg_error (GPG_ERR_BUFFER_TOO_SHORT);
     249           0 :       memcpy (buffer, ud->data, ud->datalen);
     250             :     }
     251           0 :   return 0;
     252             : }
     253             : 
     254             : 
     255             : /**
     256             :  * ksba_cert_read_der:
     257             :  * @cert: An unitialized certificate object
     258             :  * @reader: A KSBA Reader object
     259             :  *
     260             :  * Read the next certificate from the reader and store it in the
     261             :  * certificate object for future access.  The certificate is parsed
     262             :  * and rejected if it has any syntactical or semantical error
     263             :  * (i.e. does not match the ASN.1 description).
     264             :  *
     265             :  * Return value: 0 on success or an error value
     266             :  **/
     267             : gpg_error_t
     268           0 : ksba_cert_read_der (ksba_cert_t cert, ksba_reader_t reader)
     269             : {
     270           0 :   gpg_error_t err = 0;
     271           0 :   BerDecoder decoder = NULL;
     272             : 
     273           0 :   if (!cert || !reader)
     274           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     275           0 :   if (cert->initialized)
     276           0 :     return gpg_error (GPG_ERR_CONFLICT); /* Fixme: should remove the old one */
     277             : 
     278           0 :   _ksba_asn_release_nodes (cert->root);
     279           0 :   ksba_asn_tree_release (cert->asn_tree);
     280           0 :   cert->root = NULL;
     281           0 :   cert->asn_tree = NULL;
     282             : 
     283           0 :   err = ksba_asn_create_tree ("tmttv2", &cert->asn_tree);
     284           0 :   if (err)
     285           0 :     goto leave;
     286             : 
     287           0 :   decoder = _ksba_ber_decoder_new ();
     288           0 :   if (!decoder)
     289             :     {
     290           0 :       err = gpg_error (GPG_ERR_ENOMEM);
     291           0 :       goto leave;
     292             :     }
     293             : 
     294           0 :   err = _ksba_ber_decoder_set_reader (decoder, reader);
     295           0 :   if (err)
     296           0 :     goto leave;
     297             : 
     298           0 :   err = _ksba_ber_decoder_set_module (decoder, cert->asn_tree);
     299           0 :   if (err)
     300           0 :      goto leave;
     301             : 
     302           0 :   err = _ksba_ber_decoder_decode (decoder, "TMTTv2.Certificate", 0,
     303             :                                   &cert->root, &cert->image, &cert->imagelen);
     304           0 :   if (!err)
     305           0 :       cert->initialized = 1;
     306             : 
     307             :  leave:
     308           0 :   _ksba_ber_decoder_release (decoder);
     309             : 
     310           0 :   return err;
     311             : }
     312             : 
     313             : 
     314             : gpg_error_t
     315           0 : ksba_cert_init_from_mem (ksba_cert_t cert, const void *buffer, size_t length)
     316             : {
     317             :   gpg_error_t err;
     318             :   ksba_reader_t reader;
     319             : 
     320           0 :   err = ksba_reader_new (&reader);
     321           0 :   if (err)
     322           0 :     return err;
     323           0 :   err = ksba_reader_set_mem (reader, buffer, length);
     324           0 :   if (err)
     325             :     {
     326           0 :       ksba_reader_release (reader);
     327           0 :       return err;
     328             :     }
     329           0 :   err = ksba_cert_read_der (cert, reader);
     330           0 :   ksba_reader_release (reader);
     331           0 :   return err;
     332             : }
     333             : 
     334             : 
     335             : 
     336             : const unsigned char *
     337           0 : ksba_cert_get_image (ksba_cert_t cert, size_t *r_length )
     338             : {
     339             :   AsnNode n;
     340             : 
     341           0 :   if (!cert)
     342           0 :     return NULL;
     343           0 :   if (!cert->initialized)
     344           0 :     return NULL;
     345             : 
     346           0 :   n = _ksba_asn_find_node (cert->root, "Certificate");
     347           0 :   if (!n)
     348           0 :     return NULL;
     349             : 
     350           0 :   if (n->off == -1)
     351             :     {
     352             : /*        fputs ("ksba_cert_get_image problem at node:\n", stderr); */
     353             : /*        _ksba_asn_node_dump_all (n, stderr); */
     354           0 :       return NULL;
     355             :     }
     356             : 
     357             :   /* Due to minor problems in our parser we might hit the assertion
     358             :      below.  Thus we better return a error, proper. */
     359           0 :   if ( !(n->nhdr + n->len + n->off <= cert->imagelen) )
     360             :     {
     361           0 :       fprintf (stderr,"\nOops, ksba_cert_get_image failed: "
     362             :                "imagelen=%lu  hdr=%d len=%d off=%d\n",
     363           0 :                (unsigned long)cert->imagelen, n->nhdr, (int)n->len, n->off);
     364           0 :       return NULL;
     365             :     }
     366             :   /*assert (n->nhdr + n->len + n->off <= cert->imagelen);*/
     367             : 
     368           0 :   if (r_length)
     369           0 :     *r_length = n->nhdr + n->len;
     370           0 :   return cert->image + n->off;
     371             : }
     372             : 
     373             : /* Check whether certificates A and B are identical and return o in
     374             :    this case. */
     375             : int
     376           0 : _ksba_cert_cmp (ksba_cert_t a, ksba_cert_t b)
     377             : {
     378             :   const unsigned char *img_a, *img_b;
     379             :   size_t len_a, len_b;
     380             : 
     381           0 :   img_a = ksba_cert_get_image (a, &len_a);
     382           0 :   if (!img_a)
     383           0 :     return 1;
     384           0 :   img_b = ksba_cert_get_image (b, &len_b);
     385           0 :   if (!img_b)
     386           0 :     return 1;
     387           0 :   return !(len_a == len_b && !memcmp (img_a, img_b, len_a));
     388             : }
     389             : 
     390             : 
     391             : 
     392             : 
     393             : gpg_error_t
     394           0 : ksba_cert_hash (ksba_cert_t cert, int what,
     395             :                 void (*hasher)(void *, const void *, size_t length),
     396             :                 void *hasher_arg)
     397             : {
     398             :   AsnNode n;
     399             : 
     400           0 :   if (!cert /*|| !hasher*/)
     401           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     402           0 :   if (!cert->initialized)
     403           0 :     return gpg_error (GPG_ERR_NO_DATA);
     404             : 
     405           0 :   n = _ksba_asn_find_node (cert->root,
     406             :                            what == 1? "Certificate.tbsCertificate"
     407             :                                     : "Certificate");
     408           0 :   if (!n)
     409           0 :     return gpg_error (GPG_ERR_NO_VALUE); /* oops - should be there */
     410           0 :   if (n->off == -1)
     411             :     {
     412             : /*        fputs ("ksba_cert_hash problem at node:\n", stderr); */
     413             : /*        _ksba_asn_node_dump_all (n, stderr); */
     414           0 :       return gpg_error (GPG_ERR_NO_VALUE);
     415             :     }
     416             : 
     417           0 :   hasher (hasher_arg, cert->image + n->off,  n->nhdr + n->len);
     418             : 
     419             : 
     420           0 :   return 0;
     421             : }
     422             : 
     423             : 
     424             : 
     425             : /**
     426             :  * ksba_cert_get_digest_algo:
     427             :  * @cert: Initialized certificate object
     428             :  *
     429             :  * Figure out the the digest algorithm used for the signature and
     430             :  * return its OID
     431             :  *
     432             :  * This function is intended as a helper for the ksba_cert_hash().
     433             :  *
     434             :  * Return value: NULL for error otherwise a constant string with the OID.
     435             :  * This string is valid as long the certificate object is valid.
     436             :  **/
     437             : const char *
     438           0 : ksba_cert_get_digest_algo (ksba_cert_t cert)
     439             : {
     440             :   gpg_error_t err;
     441             :   AsnNode n;
     442             :   char *algo;
     443             :   size_t nread;
     444             : 
     445           0 :   if (!cert)
     446           0 :     return NULL;  /* Ooops (can't set cert->last_error :-().  */
     447             : 
     448           0 :   if (!cert->initialized)
     449             :     {
     450           0 :        cert->last_error = gpg_error (GPG_ERR_NO_DATA);
     451           0 :        return NULL;
     452             :     }
     453             : 
     454           0 :   if (cert->cache.digest_algo)
     455           0 :     return cert->cache.digest_algo;
     456             : 
     457             : /*   n = _ksba_asn_find_node (cert->root, */
     458             : /*                            "Certificate.signatureAlgorithm.algorithm"); */
     459             : /*   algo = _ksba_oid_node_to_str (cert->image, n); */
     460             : /*   if (!algo) */
     461             : /*     cert->last_error = gpg_error (GPG_ERR_UNKNOWN_ALGORITHM); */
     462             : /*   else  */
     463             : /*     cert->cache.digest_algo = algo; */
     464             : 
     465           0 :   n = _ksba_asn_find_node (cert->root, "Certificate.signatureAlgorithm");
     466           0 :   if (!n || n->off == -1)
     467             :     {
     468           0 :       algo = NULL;
     469           0 :       err = gpg_error (GPG_ERR_UNKNOWN_ALGORITHM);
     470             :     }
     471             :   else
     472           0 :     err = _ksba_parse_algorithm_identifier (cert->image + n->off,
     473           0 :                                             n->nhdr + n->len, &nread, &algo);
     474           0 :   if (err)
     475           0 :     cert->last_error = err;
     476             :   else
     477           0 :     cert->cache.digest_algo = algo;
     478             : 
     479           0 :   return algo;
     480             : }
     481             : 
     482             : 
     483             : 
     484             : 
     485             : /**
     486             :  * ksba_cert_get_serial:
     487             :  * @cert: certificate object
     488             :  *
     489             :  * This function returnes the serial number of the certificate.  The
     490             :  * serial number is an integer returned as an canonical encoded
     491             :  * S-expression with just one element.
     492             :  *
     493             :  * Return value: An allocated S-Exp or NULL for no value.
     494             :  **/
     495             : ksba_sexp_t
     496           0 : ksba_cert_get_serial (ksba_cert_t cert)
     497             : {
     498             :   AsnNode n;
     499             :   char *p;
     500             :   char numbuf[22];
     501             :   int numbuflen;
     502             : 
     503           0 :   if (!cert || !cert->initialized)
     504           0 :     return NULL;
     505             : 
     506           0 :   n = _ksba_asn_find_node (cert->root,
     507             :                            "Certificate.tbsCertificate.serialNumber");
     508           0 :   if (!n)
     509           0 :     return NULL; /* oops - should be there */
     510             : 
     511           0 :   if (n->off == -1)
     512             :     {
     513             : /*        fputs ("get_serial problem at node:\n", stderr); */
     514             : /*        _ksba_asn_node_dump_all (n, stderr); */
     515           0 :       return NULL;
     516             :     }
     517             : 
     518           0 :   sprintf (numbuf,"(%u:", (unsigned int)n->len);
     519           0 :   numbuflen = strlen (numbuf);
     520           0 :   p = xtrymalloc (numbuflen + n->len + 2);
     521           0 :   if (!p)
     522           0 :     return NULL;
     523           0 :   strcpy (p, numbuf);
     524           0 :   memcpy (p+numbuflen, cert->image + n->off + n->nhdr, n->len);
     525           0 :   p[numbuflen + n->len] = ')';
     526           0 :   p[numbuflen + n->len + 1] = 0;
     527           0 :   return p;
     528             : }
     529             : 
     530             : 
     531             : /* Return a pointer to the DER encoding of the serial number in CERT in
     532             :    PTR and the length of that field in LENGTH.  */
     533             : gpg_error_t
     534           0 : _ksba_cert_get_serial_ptr (ksba_cert_t cert,
     535             :                            unsigned char const **ptr, size_t *length)
     536             : {
     537             :   asn_node_t n;
     538             : 
     539           0 :   if (!cert || !cert->initialized || !ptr || !length)
     540           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     541           0 :   n = _ksba_asn_find_node (cert->root,
     542             :                            "Certificate.tbsCertificate.serialNumber");
     543           0 :   if (!n || n->off == -1)
     544           0 :     return gpg_error (GPG_ERR_NO_VALUE);
     545             : 
     546           0 :   *ptr = cert->image + n->off + n->nhdr;
     547           0 :   *length = n->len;
     548           0 :   return 0;
     549             : }
     550             : 
     551             : 
     552             : 
     553             : /* Return a pointer to the DER encoding of the subject's DN in CERT in
     554             :    PTR and the length of that object in LENGTH.  */
     555             : gpg_error_t
     556           0 : _ksba_cert_get_subject_dn_ptr (ksba_cert_t cert,
     557             :                                unsigned char const **ptr, size_t *length)
     558             : {
     559             :   asn_node_t n;
     560             : 
     561           0 :   if (!cert || !cert->initialized || !ptr || !length)
     562           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     563             : 
     564           0 :   n = _ksba_asn_find_node (cert->root, "Certificate.tbsCertificate.subject");
     565           0 :   if (!n || !n->down)
     566           0 :     return gpg_error (GPG_ERR_NO_VALUE); /* oops - should be there */
     567           0 :   n = n->down; /* dereference the choice node */
     568           0 :   if (n->off == -1)
     569           0 :     return gpg_error (GPG_ERR_NO_VALUE);
     570           0 :   *ptr = cert->image + n->off;
     571           0 :   *length = n->nhdr + n->len;
     572           0 :   return 0;
     573             : }
     574             : 
     575             : 
     576             : 
     577             : /* Worker function for get_isssuer and get_subject. */
     578             : static gpg_error_t
     579           0 : get_name (ksba_cert_t cert, int idx, int use_subject, char **result)
     580             : {
     581             :   gpg_error_t err;
     582             :   char *p;
     583             :   int i;
     584             :   const char *oid;
     585             :   struct tag_info ti;
     586             :   const unsigned char *der;
     587             :   size_t off, derlen, seqlen;
     588             : 
     589           0 :   if (!cert || !cert->initialized || !result)
     590           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     591           0 :   if (idx < 0)
     592           0 :     return gpg_error (GPG_ERR_INV_INDEX);
     593             : 
     594           0 :   *result = NULL;
     595           0 :   if (!idx)
     596             :     { /* Get the required DN */
     597             :       AsnNode n;
     598             : 
     599           0 :       n = _ksba_asn_find_node (cert->root,
     600             :                                (use_subject?
     601             :                                 "Certificate.tbsCertificate.subject":
     602             :                                 "Certificate.tbsCertificate.issuer") );
     603           0 :       if (!n || !n->down)
     604           0 :         return gpg_error (GPG_ERR_NO_VALUE); /* oops - should be there */
     605           0 :       n = n->down; /* dereference the choice node */
     606           0 :       if (n->off == -1)
     607           0 :         return gpg_error (GPG_ERR_NO_VALUE);
     608             : 
     609           0 :       err = _ksba_dn_to_str (cert->image, n, &p);
     610           0 :       if (err)
     611           0 :         return err;
     612           0 :       *result = p;
     613           0 :       return 0;
     614             :     }
     615             : 
     616             :   /* get {issuer,subject}AltName */
     617           0 :   for (i=0; !(err=ksba_cert_get_extension (cert, i, &oid, NULL,
     618           0 :                                            &off, &derlen)); i++)
     619             :     {
     620           0 :       if (!strcmp (oid, (use_subject?
     621             :                          oidstr_subjectAltName:oidstr_issuerAltName)))
     622           0 :         break;
     623             :     }
     624           0 :   if (err)
     625           0 :       return err; /* no alt name or error*/
     626             : 
     627           0 :   der = cert->image + off;
     628             : 
     629             : 
     630             :   /* FIXME: We should use _ksba_name_new_from_der and ksba_name_enum here */
     631             : 
     632           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
     633           0 :   if (err)
     634           0 :     return err;
     635           0 :   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
     636           0 :          && ti.is_constructed) )
     637           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
     638           0 :   if (ti.ndef)
     639           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
     640           0 :   seqlen = ti.length;
     641           0 :   if (seqlen > derlen)
     642           0 :     return gpg_error (GPG_ERR_BAD_BER);
     643           0 :   if (!seqlen)
     644           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ); /* empty sequence is not allowed */
     645             : 
     646           0 :   while (seqlen)
     647             :     {
     648           0 :       err = _ksba_ber_parse_tl (&der, &derlen, &ti);
     649           0 :       if (err)
     650           0 :         return err;
     651           0 :       if (ti.class != CLASS_CONTEXT)
     652           0 :         return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
     653           0 :       if (ti.ndef)
     654           0 :         return gpg_error (GPG_ERR_NOT_DER_ENCODED);
     655           0 :       if (seqlen < ti.nhdr)
     656           0 :         return gpg_error (GPG_ERR_BAD_BER);
     657           0 :       seqlen -= ti.nhdr;
     658           0 :       if (seqlen < ti.length)
     659           0 :         return gpg_error (GPG_ERR_BAD_BER);
     660           0 :       seqlen -= ti.length;
     661           0 :       if (derlen < ti.length)
     662           0 :         return gpg_error (GPG_ERR_BAD_BER);
     663           0 :       if (!(ti.tag == 1 || ti.tag == 2 || ti.tag == 6))
     664             :         ; /* Not a supported tag: Do not change IDX. */
     665           0 :       else if (--idx)
     666             :         ; /* not yet at the desired index */
     667           0 :       else if (ti.tag == 1)
     668             :         { /* rfc822Name - this is an implicit IA5_STRING */
     669           0 :           p = xtrymalloc (ti.length+3);
     670           0 :           if (!p)
     671           0 :             return gpg_error (GPG_ERR_ENOMEM);
     672           0 :           *p = '<';
     673           0 :           memcpy (p+1, der, ti.length);
     674           0 :           p[ti.length+1] = '>';
     675           0 :           p[ti.length+2] = 0;
     676           0 :           *result = p;
     677           0 :           return 0;
     678             :         }
     679           0 :       else if (ti.tag == 2 || ti.tag == 6)
     680             :         { /* dNSName or URI - this are implicit IA5_STRINGs */
     681             :           char numbuf[20], *numbufp;
     682             :           size_t numbuflen;
     683             : 
     684           0 :           numbufp = smklen (numbuf, DIM(numbuf), ti.length, &numbuflen);
     685           0 :           p = xtrymalloc (11 + numbuflen + ti.length + 3);
     686           0 :           if (!p)
     687           0 :             return gpg_error (GPG_ERR_ENOMEM);
     688           0 :           *result = p;
     689           0 :           p = stpcpy (p, ti.tag == 2? "(8:dns-name" : "(3:uri");
     690           0 :           p = stpcpy (p, numbufp);
     691           0 :           memcpy (p, der, ti.length);
     692           0 :           p += ti.length;
     693           0 :           *p++ = ')';
     694           0 :           *p = 0;
     695           0 :           return 0;
     696             :         }
     697             : 
     698             :       /* advance pointer */
     699           0 :       der += ti.length;
     700           0 :       derlen -= ti.length;
     701             :     }
     702             : 
     703           0 :   return gpg_error (GPG_ERR_EOF);
     704             : }
     705             : 
     706             : 
     707             : 
     708             : /**
     709             :  * ksba_cert_get_issuer:
     710             :  * @cert: certificate object
     711             :  *
     712             :  * With @idx == 0 this function returns the Distinguished Name (DN) of
     713             :  * the certificate issuer which in most cases is a CA.  The format of
     714             :  * the returned string is in accordance with RFC-2253.  NULL is
     715             :  * returned if the DN is not available which is an error and should
     716             :  * have been catched by the certificate reading function.
     717             :  *
     718             :  * With @idx > 0 the function may be used to enumerate alternate
     719             :  * issuer names. The function returns NULL if there are no more
     720             :  * alternate names.  The function does only return alternate names
     721             :  * which are recognized by libksba and ignores others.  The format of
     722             :  * the returned name is either a RFC-2253 formated one which can be
     723             :  * detected by checking whether the first character is letter or
     724             :  * digit.  rfc-2822 conform email addresses are returned enclosed in
     725             :  * angle brackets, the opening angle bracket should be used to
     726             :  * indicate this.  Other formats are returned as an S-Expression in
     727             :  * canonical format, so a opening parenthesis may be used to detect
     728             :  * this encoding, the name may include binary null characters, so
     729             :  * strlen may return a length shorther than actually used, the real
     730             :  * length is implictly given by the structure of the S-Exp, an extra
     731             :  * null is appended for safety reasons.
     732             :  *
     733             :  * The caller must free the returned string using ksba_free() or the
     734             :  * function he has registered as a replacement.
     735             :  *
     736             :  * Return value: An allocated string or NULL for error.
     737             :  **/
     738             : char *
     739           0 : ksba_cert_get_issuer (ksba_cert_t cert, int idx)
     740             : {
     741             :   gpg_error_t err;
     742             :   char *name;
     743             : 
     744           0 :   err = get_name (cert, idx, 0, &name);
     745           0 :   if (err)
     746             :     {
     747           0 :       cert->last_error = err;
     748           0 :       return NULL;
     749             :     }
     750           0 :   return name;
     751             : }
     752             : 
     753             : /* See ..get_issuer */
     754             : char *
     755           0 : ksba_cert_get_subject (ksba_cert_t cert, int idx)
     756             : {
     757             :   gpg_error_t err;
     758             :   char *name;
     759             : 
     760           0 :   err = get_name (cert, idx, 1, &name);
     761           0 :   if (err)
     762             :     {
     763           0 :       cert->last_error = err;
     764           0 :       return NULL;
     765             :     }
     766           0 :   return name;
     767             : }
     768             : 
     769             : 
     770             : 
     771             : /**
     772             :  * ksba_cert_get_valididy:
     773             :  * @cert: certificate object
     774             :  * @what: 0 for notBefore, 1 for notAfter
     775             :  * @timebuf: Returns the time.
     776             :  *
     777             :  * Return the validity object from the certificate.  If no value is
     778             :  * available 0 is returned because we can safely assume that this is
     779             :  * not a valid date.
     780             :  *
     781             :  * Return value: The time value an 0 or an error code.
     782             :  **/
     783             : gpg_error_t
     784           0 : ksba_cert_get_validity (ksba_cert_t cert, int what, ksba_isotime_t timebuf)
     785             : {
     786             :   AsnNode n, n2;
     787             : 
     788           0 :   if (!cert || what < 0 || what > 1)
     789           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     790           0 :   *timebuf = 0;
     791           0 :   if (!cert->initialized)
     792           0 :     return gpg_error (GPG_ERR_NO_DATA);
     793             : 
     794           0 :   n = _ksba_asn_find_node (cert->root,
     795             :         what == 0? "Certificate.tbsCertificate.validity.notBefore"
     796             :                  : "Certificate.tbsCertificate.validity.notAfter");
     797           0 :   if (!n)
     798           0 :     return 0; /* no value available */
     799             : 
     800             :   /* Fixme: We should remove the choice node and don't use this ugly hack */
     801           0 :   for (n2=n->down; n2; n2 = n2->right)
     802             :     {
     803           0 :       if ((n2->type == TYPE_UTC_TIME || n2->type == TYPE_GENERALIZED_TIME)
     804           0 :           && n2->off != -1)
     805           0 :         break;
     806             :     }
     807           0 :   n = n2;
     808           0 :   if (!n)
     809           0 :     return 0; /* no value available */
     810             : 
     811           0 :   return_val_if_fail (n->off != -1, gpg_error (GPG_ERR_BUG));
     812             : 
     813           0 :   return _ksba_asntime_to_iso (cert->image + n->off + n->nhdr, n->len,
     814           0 :                                n->type == TYPE_UTC_TIME, timebuf);
     815             : }
     816             : 
     817             : 
     818             : 
     819             : ksba_sexp_t
     820           0 : ksba_cert_get_public_key (ksba_cert_t cert)
     821             : {
     822             :   AsnNode n;
     823             :   gpg_error_t err;
     824             :   ksba_sexp_t string;
     825             : 
     826           0 :   if (!cert)
     827           0 :     return NULL;
     828           0 :   if (!cert->initialized)
     829           0 :     return NULL;
     830             : 
     831           0 :   n = _ksba_asn_find_node (cert->root,
     832             :                            "Certificate"
     833             :                            ".tbsCertificate.subjectPublicKeyInfo");
     834           0 :   if (!n)
     835             :     {
     836           0 :       cert->last_error = gpg_error (GPG_ERR_NO_VALUE);
     837           0 :       return NULL;
     838             :     }
     839             : 
     840           0 :   err = _ksba_keyinfo_to_sexp (cert->image + n->off, n->nhdr + n->len,
     841             :                                &string);
     842           0 :   if (err)
     843             :     {
     844           0 :       cert->last_error = err;
     845           0 :       return NULL;
     846             :     }
     847             : 
     848           0 :   return string;
     849             : }
     850             : 
     851             : /* Return a pointer to the DER encoding of the actual public key
     852             :    (i.e. the bit string) in PTR and the length of that object in
     853             :    LENGTH.  */
     854             : gpg_error_t
     855           0 : _ksba_cert_get_public_key_ptr (ksba_cert_t cert,
     856             :                                unsigned char const **ptr, size_t *length)
     857             : {
     858             :   asn_node_t n;
     859             : 
     860           0 :   if (!cert || !cert->initialized || !ptr || !length)
     861           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     862             : 
     863           0 :   n = _ksba_asn_find_node (cert->root,
     864             :                            "Certificate.tbsCertificate.subjectPublicKeyInfo");
     865           0 :   if (!n || !n->down || !n->down->right)
     866           0 :     return gpg_error (GPG_ERR_NO_VALUE); /* oops - should be there */
     867           0 :   n = n->down->right;
     868           0 :   if (n->off == -1)
     869           0 :     return gpg_error (GPG_ERR_NO_VALUE);
     870           0 :   *ptr = cert->image + n->off + n->nhdr;
     871           0 :   *length = n->len;
     872             :   /* Somehow we end up at the preceding NULL value, and not at a
     873             :      sequence, we hack it way here. */
     874           0 :   if (*length && !**ptr)
     875             :     {
     876           0 :       (*length)--;
     877           0 :       (*ptr)++;
     878             :     }
     879             : 
     880           0 :   return 0;
     881             : }
     882             : 
     883             : 
     884             : 
     885             : ksba_sexp_t
     886           0 : ksba_cert_get_sig_val (ksba_cert_t cert)
     887             : {
     888             :   AsnNode n, n2;
     889             :   gpg_error_t err;
     890             :   ksba_sexp_t string;
     891             : 
     892           0 :   if (!cert)
     893           0 :     return NULL;
     894           0 :   if (!cert->initialized)
     895           0 :     return NULL;
     896             : 
     897           0 :   n = _ksba_asn_find_node (cert->root,
     898             :                            "Certificate.signatureAlgorithm");
     899           0 :   if (!n)
     900             :     {
     901           0 :       cert->last_error = gpg_error (GPG_ERR_NO_VALUE);
     902           0 :       return NULL;
     903             :     }
     904           0 :   if (n->off == -1)
     905             :     {
     906             : /*        fputs ("ksba_cert_get_sig_val problem at node:\n", stderr); */
     907             : /*        _ksba_asn_node_dump_all (n, stderr); */
     908           0 :       cert->last_error = gpg_error (GPG_ERR_NO_VALUE);
     909           0 :       return NULL;
     910             :     }
     911             : 
     912           0 :   n2 = n->right;
     913           0 :   err = _ksba_sigval_to_sexp (cert->image + n->off,
     914           0 :                               n->nhdr + n->len
     915           0 :                               + ((!n2||n2->off == -1)? 0:(n2->nhdr+n2->len)),
     916             :                               &string);
     917           0 :   if (err)
     918             :     {
     919           0 :       cert->last_error = err;
     920           0 :       return NULL;
     921             :     }
     922             : 
     923           0 :   return string;
     924             : }
     925             : 
     926             : 
     927             : /* Read all extensions into the cache */
     928             : static gpg_error_t
     929           0 : read_extensions (ksba_cert_t cert)
     930             : {
     931             :   AsnNode start, n;
     932             :   int count;
     933             : 
     934           0 :   assert (!cert->cache.extns_valid);
     935           0 :   assert (!cert->cache.extns);
     936             : 
     937           0 :   start = _ksba_asn_find_node (cert->root,
     938             :                                "Certificate.tbsCertificate.extensions..");
     939           0 :   for (count=0, n=start; n; n = n->right)
     940           0 :     count++;
     941           0 :   if (!count)
     942             :     {
     943           0 :       cert->cache.n_extns = 0;
     944           0 :       cert->cache.extns_valid = 1;
     945           0 :       return 0; /* no extensions at all */
     946             :     }
     947           0 :   cert->cache.extns = xtrycalloc (count, sizeof *cert->cache.extns);
     948           0 :   if (!cert->cache.extns)
     949           0 :     return gpg_error (GPG_ERR_ENOMEM);
     950           0 :   cert->cache.n_extns = count;
     951             : 
     952             :   {
     953           0 :     for (count=0; start; start = start->right, count++)
     954             :       {
     955           0 :         n = start->down;
     956           0 :         if (!n || n->type != TYPE_OBJECT_ID)
     957             :           goto no_value;
     958             : 
     959           0 :         cert->cache.extns[count].oid = _ksba_oid_node_to_str (cert->image, n);
     960           0 :         if (!cert->cache.extns[count].oid)
     961           0 :           goto no_value;
     962             : 
     963           0 :         n = n->right;
     964           0 :         if (n && n->type == TYPE_BOOLEAN)
     965             :           {
     966           0 :             if (n->off != -1 && n->len && cert->image[n->off + n->nhdr])
     967           0 :               cert->cache.extns[count].crit = 1;
     968           0 :             n = n->right;
     969             :           }
     970             : 
     971           0 :         if (!n || n->type != TYPE_OCTET_STRING || n->off == -1)
     972             :           goto no_value;
     973             : 
     974           0 :         cert->cache.extns[count].off = n->off + n->nhdr;
     975           0 :         cert->cache.extns[count].len = n->len;
     976             :       }
     977             : 
     978           0 :     assert (count == cert->cache.n_extns);
     979           0 :     cert->cache.extns_valid = 1;
     980           0 :     return 0;
     981             : 
     982             :   no_value:
     983           0 :     for (count=0; count < cert->cache.n_extns; count++)
     984           0 :       xfree (cert->cache.extns[count].oid);
     985           0 :     xfree (cert->cache.extns);
     986           0 :     cert->cache.extns = NULL;
     987           0 :     return gpg_error (GPG_ERR_NO_VALUE);
     988             :   }
     989             : }
     990             : 
     991             : 
     992             : /* Return information about the IDX nth extension */
     993             : gpg_error_t
     994           0 : ksba_cert_get_extension (ksba_cert_t cert, int idx,
     995             :                          char const **r_oid, int *r_crit,
     996             :                          size_t *r_deroff, size_t *r_derlen)
     997             : {
     998             :   gpg_error_t err;
     999             : 
    1000           0 :   if (!cert)
    1001           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    1002           0 :   if (!cert->initialized)
    1003           0 :     return gpg_error (GPG_ERR_NO_DATA);
    1004             : 
    1005           0 :   if (!cert->cache.extns_valid)
    1006             :     {
    1007           0 :       err = read_extensions (cert);
    1008           0 :       if (err)
    1009           0 :         return err;
    1010           0 :       assert (cert->cache.extns_valid);
    1011             :     }
    1012             : 
    1013           0 :   if (idx == cert->cache.n_extns)
    1014           0 :     return gpg_error (GPG_ERR_EOF); /* No more extensions. */
    1015             : 
    1016           0 :   if (idx < 0 || idx >= cert->cache.n_extns)
    1017           0 :     return gpg_error (GPG_ERR_INV_INDEX);
    1018             : 
    1019           0 :   if (r_oid)
    1020           0 :     *r_oid = cert->cache.extns[idx].oid;
    1021           0 :   if (r_crit)
    1022           0 :     *r_crit = cert->cache.extns[idx].crit;
    1023           0 :   if (r_deroff)
    1024           0 :     *r_deroff = cert->cache.extns[idx].off;
    1025           0 :   if (r_derlen)
    1026           0 :     *r_derlen = cert->cache.extns[idx].len;
    1027           0 :   return 0;
    1028             : }
    1029             : 
    1030             : 
    1031             : 
    1032             : /* Return information on the basicConstraint (2.5.19.19) of CERT.
    1033             :    R_CA receives true if this is a CA and only in that case R_PATHLEN
    1034             :    is set to the maximim certification path length or -1 if there is
    1035             :    nosuch limitation */
    1036             : gpg_error_t
    1037           0 : ksba_cert_is_ca (ksba_cert_t cert, int *r_ca, int *r_pathlen)
    1038             : {
    1039             :   gpg_error_t err;
    1040             :   const char *oid;
    1041             :   int idx, crit;
    1042             :   size_t off, derlen, seqlen;
    1043             :   const unsigned char *der;
    1044             :   struct tag_info ti;
    1045             :   unsigned long value;
    1046             : 
    1047             :   /* set default values */
    1048           0 :   if (r_ca)
    1049           0 :     *r_ca = 0;
    1050           0 :   if (r_pathlen)
    1051           0 :     *r_pathlen = -1;
    1052           0 :   for (idx=0; !(err=ksba_cert_get_extension (cert, idx, &oid, &crit,
    1053           0 :                                              &off, &derlen)); idx++)
    1054             :     {
    1055           0 :       if (!strcmp (oid, oidstr_basicConstraints))
    1056           0 :         break;
    1057             :     }
    1058           0 :   if (gpg_err_code (err) == GPG_ERR_EOF)
    1059           0 :       return 0; /* no such constraint */
    1060           0 :   if (err)
    1061           0 :     return err;
    1062             : 
    1063             :   /* check that there is only one */
    1064           0 :   for (idx++; !(err=ksba_cert_get_extension (cert, idx, &oid, NULL,
    1065           0 :                                              NULL, NULL)); idx++)
    1066             :     {
    1067           0 :       if (!strcmp (oid, oidstr_basicConstraints))
    1068           0 :         return gpg_error (GPG_ERR_DUP_VALUE);
    1069             :     }
    1070             : 
    1071           0 :   der = cert->image + off;
    1072             : 
    1073           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1074           0 :   if (err)
    1075           0 :     return err;
    1076           0 :   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1077           0 :          && ti.is_constructed) )
    1078           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1079           0 :   if (ti.ndef)
    1080           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1081           0 :   seqlen = ti.length;
    1082           0 :   if (seqlen > derlen)
    1083           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1084           0 :   if (!seqlen)
    1085           0 :     return 0; /* an empty sequence is allowed because both elements
    1086             :                  are optional */
    1087             : 
    1088           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1089           0 :   if (err)
    1090           0 :     return err;
    1091           0 :   if (seqlen < ti.nhdr)
    1092           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1093           0 :   seqlen -= ti.nhdr;
    1094           0 :   if (seqlen < ti.length)
    1095           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1096           0 :   seqlen -= ti.length;
    1097             : 
    1098           0 :   if (ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_BOOLEAN)
    1099             :     {
    1100           0 :       if (ti.length != 1)
    1101           0 :         return gpg_error (GPG_ERR_ENCODING_PROBLEM);
    1102           0 :       if (r_ca)
    1103           0 :         *r_ca = !!*der;
    1104           0 :       der++; derlen--;
    1105           0 :       if (!seqlen)
    1106           0 :         return 0; /* ready (no pathlength) */
    1107             : 
    1108           0 :       err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1109           0 :       if (err)
    1110           0 :         return err;
    1111           0 :       if (seqlen < ti.nhdr)
    1112           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1113           0 :       seqlen -= ti.nhdr;
    1114           0 :       if (seqlen < ti.length)
    1115           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1116           0 :       seqlen -= ti.length;
    1117             :     }
    1118             : 
    1119           0 :   if (!(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_INTEGER))
    1120           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1121             : 
    1122           0 :   for (value=0; ti.length; ti.length--)
    1123             :     {
    1124           0 :       value <<= 8;
    1125           0 :       value |= (*der++) & 0xff;
    1126           0 :       derlen--;
    1127             :     }
    1128           0 :   if (r_pathlen)
    1129           0 :     *r_pathlen = value;
    1130             : 
    1131             :   /* if the extension is marked as critical and any stuff is still
    1132             :      left we better return an error */
    1133           0 :   if (crit && seqlen)
    1134           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1135             : 
    1136           0 :   return 0;
    1137             : }
    1138             : 
    1139             : 
    1140             : 
    1141             : /* Get the key usage flags. The function returns Ksba_No_Data if no
    1142             :    key usage is specified. */
    1143             : gpg_error_t
    1144           0 : ksba_cert_get_key_usage (ksba_cert_t cert, unsigned int *r_flags)
    1145             : {
    1146             :   gpg_error_t err;
    1147             :   const char *oid;
    1148             :   int idx, crit;
    1149             :   size_t off, derlen;
    1150             :   const unsigned char *der;
    1151             :   struct tag_info ti;
    1152             :   unsigned int bits, mask;
    1153             :   int i, unused, full;
    1154             : 
    1155           0 :   if (!r_flags)
    1156           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    1157           0 :   *r_flags = 0;
    1158           0 :   for (idx=0; !(err=ksba_cert_get_extension (cert, idx, &oid, &crit,
    1159           0 :                                              &off, &derlen)); idx++)
    1160             :     {
    1161           0 :       if (!strcmp (oid, oidstr_keyUsage))
    1162           0 :         break;
    1163             :     }
    1164           0 :   if (gpg_err_code (err) == GPG_ERR_EOF
    1165           0 :       || gpg_err_code (err) == GPG_ERR_NO_VALUE)
    1166           0 :       return gpg_error (GPG_ERR_NO_DATA); /* no key usage */
    1167           0 :   if (err)
    1168           0 :     return err;
    1169             : 
    1170             :   /* check that there is only one */
    1171           0 :   for (idx++; !(err=ksba_cert_get_extension (cert, idx, &oid, NULL,
    1172           0 :                                              NULL, NULL)); idx++)
    1173             :     {
    1174           0 :       if (!strcmp (oid, oidstr_keyUsage))
    1175           0 :         return gpg_error (GPG_ERR_DUP_VALUE);
    1176             :     }
    1177             : 
    1178           0 :   der = cert->image + off;
    1179             : 
    1180           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1181           0 :   if (err)
    1182           0 :     return err;
    1183           0 :   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_BIT_STRING
    1184           0 :          && !ti.is_constructed) )
    1185           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1186           0 :   if (ti.ndef)
    1187           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1188           0 :   if (!ti.length || ti.length > derlen)
    1189           0 :     return gpg_error (GPG_ERR_ENCODING_PROBLEM); /* number of unused bits missing */
    1190           0 :   unused = *der++; derlen--;
    1191           0 :   ti.length--;
    1192           0 :   if ((!ti.length && unused) || unused/8 > ti.length)
    1193           0 :     return gpg_error (GPG_ERR_ENCODING_PROBLEM);
    1194             : 
    1195           0 :   full = ti.length - (unused+7)/8;
    1196           0 :   unused %= 8;
    1197           0 :   mask = 0;
    1198           0 :   for (i=1; unused; i <<= 1, unused--)
    1199           0 :     mask |= i;
    1200             : 
    1201             :   /* the first octet */
    1202           0 :   if (!ti.length)
    1203           0 :     return 0; /* no bits set */
    1204           0 :   bits = *der++; derlen--; ti.length--;
    1205           0 :   if (full)
    1206           0 :     full--;
    1207             :   else {
    1208           0 :     bits &= ~mask;
    1209           0 :     mask = 0;
    1210             :   }
    1211           0 :   if (bits & 0x80)
    1212           0 :     *r_flags |= KSBA_KEYUSAGE_DIGITAL_SIGNATURE;
    1213           0 :   if (bits & 0x40)
    1214           0 :     *r_flags |= KSBA_KEYUSAGE_NON_REPUDIATION;
    1215           0 :   if (bits & 0x20)
    1216           0 :     *r_flags |= KSBA_KEYUSAGE_KEY_ENCIPHERMENT;
    1217           0 :   if (bits & 0x10)
    1218           0 :     *r_flags |= KSBA_KEYUSAGE_DATA_ENCIPHERMENT;
    1219           0 :   if (bits & 0x08)
    1220           0 :     *r_flags |= KSBA_KEYUSAGE_KEY_AGREEMENT;
    1221           0 :   if (bits & 0x04)
    1222           0 :     *r_flags |= KSBA_KEYUSAGE_KEY_CERT_SIGN;
    1223           0 :   if (bits & 0x02)
    1224           0 :     *r_flags |= KSBA_KEYUSAGE_CRL_SIGN;
    1225           0 :   if (bits & 0x01)
    1226           0 :     *r_flags |= KSBA_KEYUSAGE_ENCIPHER_ONLY;
    1227             : 
    1228             :   /* the second octet */
    1229           0 :   if (!ti.length)
    1230           0 :     return 0; /* no bits set */
    1231           0 :   bits = *der++; derlen--; ti.length--;
    1232           0 :   if (full)
    1233           0 :     full--;
    1234             :   else {
    1235           0 :     bits &= mask;
    1236           0 :     mask = ~0;
    1237             :   }
    1238           0 :   if (bits & 0x80)
    1239           0 :     *r_flags |= KSBA_KEYUSAGE_DECIPHER_ONLY;
    1240             : 
    1241           0 :   return 0;
    1242             : }
    1243             : 
    1244             : 
    1245             : 
    1246             : /* Note, that this helper is also used for ext_key_usage. */
    1247             : static gpg_error_t
    1248           0 : append_cert_policy (char **policies, const char *oid, int crit)
    1249             : {
    1250             :   char *p;
    1251             : 
    1252           0 :   if (!*policies)
    1253             :     {
    1254           0 :       *policies = xtrymalloc (strlen (oid) + 4);
    1255           0 :       if (!*policies)
    1256           0 :         return gpg_error (GPG_ERR_ENOMEM);
    1257           0 :       p = *policies;
    1258             :     }
    1259             :   else
    1260             :     {
    1261           0 :       char *tmp = xtryrealloc (*policies,
    1262             :                                strlen(*policies) + 1 + strlen (oid) + 4);
    1263           0 :       if (!tmp)
    1264           0 :         return gpg_error (GPG_ERR_ENOMEM);
    1265           0 :       *policies = tmp;
    1266           0 :       p = stpcpy (tmp+strlen (tmp), "\n");;
    1267             :     }
    1268             : 
    1269           0 :   strcpy (stpcpy (p, oid), crit? ":C:": ":N:");
    1270           0 :   return 0;
    1271             : }
    1272             : 
    1273             : 
    1274             : /* Return a string with the certificatePolicies delimited by
    1275             :    linefeeds.  The return values may be extended to carry more
    1276             :    information er line, so the caller should only use the first
    1277             :    white-space delimited token per line.  The function returns
    1278             :    GPG_ERR_NO_DATA when this extension is not used.  Caller must free
    1279             :    the returned value.  */
    1280             : gpg_error_t
    1281           0 : ksba_cert_get_cert_policies (ksba_cert_t cert, char **r_policies)
    1282             : {
    1283             :   gpg_error_t err;
    1284             :   const char *oid;
    1285             :   int idx, crit;
    1286             :   size_t off, derlen, seqlen;
    1287             :   const unsigned char *der;
    1288             :   struct tag_info ti;
    1289             : 
    1290           0 :   if (!cert || !r_policies)
    1291           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    1292           0 :   *r_policies = NULL;
    1293             : 
    1294           0 :   for (idx=0; !(err=ksba_cert_get_extension (cert, idx, &oid, &crit,
    1295           0 :                                              &off, &derlen)); idx++)
    1296             :     {
    1297           0 :       if (!strcmp (oid, oidstr_certificatePolicies))
    1298             :         {
    1299             :           char *suboid;
    1300             : 
    1301           0 :           der = cert->image + off;
    1302             : 
    1303           0 :           err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1304           0 :           if (err)
    1305           0 :             goto leave;
    1306           0 :           if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1307           0 :                  && ti.is_constructed) )
    1308             :             {
    1309           0 :               err = gpg_error (GPG_ERR_INV_CERT_OBJ);
    1310           0 :               goto leave;
    1311             :             }
    1312           0 :           if (ti.ndef)
    1313             :             {
    1314           0 :               err = gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1315           0 :               goto leave;
    1316             :             }
    1317           0 :           seqlen = ti.length;
    1318           0 :           if (seqlen > derlen)
    1319             :             {
    1320           0 :               err = gpg_error (GPG_ERR_BAD_BER);
    1321           0 :               goto leave;
    1322             :             }
    1323           0 :           while (seqlen)
    1324             :             {
    1325             :               size_t seqseqlen;
    1326             : 
    1327           0 :               err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1328           0 :               if (err)
    1329           0 :                 goto leave;
    1330           0 :               if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1331           0 :                      && ti.is_constructed) )
    1332             :                 {
    1333           0 :                   err = gpg_error (GPG_ERR_INV_CERT_OBJ);
    1334           0 :                   goto leave;
    1335             :                 }
    1336           0 :               if (ti.ndef)
    1337             :                 {
    1338           0 :                   err = gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1339           0 :                   goto leave;
    1340             :                 }
    1341           0 :               if (ti.length > derlen)
    1342             :                 {
    1343           0 :                   err = gpg_error (GPG_ERR_BAD_BER);
    1344           0 :                   goto leave;
    1345             :                 }
    1346           0 :               if (!ti.length)
    1347             :                 {
    1348             :                   /* We do not accept an empty inner SEQ */
    1349           0 :                   err = gpg_error (GPG_ERR_INV_CERT_OBJ);
    1350           0 :                   goto leave;
    1351             :                 }
    1352           0 :               if (ti.nhdr+ti.length > seqlen)
    1353             :                 {
    1354           0 :                   err = gpg_error (GPG_ERR_BAD_BER);
    1355           0 :                   goto leave;
    1356             :                 }
    1357           0 :               seqlen -= ti.nhdr + ti.length;
    1358           0 :               seqseqlen = ti.length;
    1359             : 
    1360           0 :               err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1361           0 :               if (err)
    1362           0 :                 goto leave;
    1363           0 :               if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OBJECT_ID))
    1364             :                 {
    1365           0 :                   err = gpg_error (GPG_ERR_INV_CERT_OBJ);
    1366           0 :                   goto leave;
    1367             :                 }
    1368           0 :               if (ti.length > derlen)
    1369             :                 {
    1370           0 :                   err = gpg_error (GPG_ERR_BAD_BER);
    1371           0 :                   goto leave;
    1372             :                 }
    1373           0 :               if (ti.nhdr+ti.length > seqseqlen)
    1374             :                 {
    1375           0 :                   err = gpg_error (GPG_ERR_BAD_BER);
    1376           0 :                   goto leave;
    1377             :                 }
    1378           0 :               seqseqlen -= ti.nhdr;
    1379             : 
    1380           0 :               suboid = ksba_oid_to_str (der, ti.length);
    1381           0 :               if (!suboid)
    1382             :                 {
    1383           0 :                   err = gpg_error (GPG_ERR_ENOMEM);
    1384           0 :                   goto leave;
    1385             :                 }
    1386           0 :               der       += ti.length;
    1387           0 :               derlen    -= ti.length;
    1388           0 :               seqseqlen -= ti.length;
    1389             : 
    1390           0 :               err = append_cert_policy (r_policies, suboid, crit);
    1391           0 :               xfree (suboid);
    1392           0 :               if (err)
    1393           0 :                 goto leave;
    1394             : 
    1395             :               /* skip the rest of the seq which is more or less optional */
    1396           0 :               der    += seqseqlen;
    1397           0 :               derlen -= seqseqlen;
    1398             :             }
    1399             :         }
    1400             :     }
    1401             : 
    1402           0 :   if (gpg_err_code (err) == GPG_ERR_EOF)
    1403           0 :     err = 0;
    1404           0 :   if (!*r_policies || gpg_err_code (err) == GPG_ERR_NO_VALUE)
    1405           0 :     err = gpg_error (GPG_ERR_NO_DATA);
    1406             : 
    1407             :  leave:
    1408           0 :   if (err)
    1409             :     {
    1410           0 :       xfree (*r_policies);
    1411           0 :       *r_policies = NULL;
    1412             :     }
    1413           0 :   return err;
    1414             : }
    1415             : 
    1416             : 
    1417             : /* Return a string with the extendedKeyUsageOIDs delimited by
    1418             :    linefeeds.  The return values may be extended to carry more
    1419             :    information per line, so the caller should only use the first
    1420             :    white-space delimited token per line.  The function returns
    1421             :    GPG_ERR_NO_DATA when this extension is not used.  Caller must free
    1422             :    the returned value.  */
    1423             : gpg_error_t
    1424           0 : ksba_cert_get_ext_key_usages (ksba_cert_t cert, char **result)
    1425             : {
    1426             :   gpg_error_t err;
    1427             :   const char *oid;
    1428             :   int idx, crit;
    1429             :   size_t off, derlen;
    1430             :   const unsigned char *der;
    1431             :   struct tag_info ti;
    1432             : 
    1433           0 :   if (!cert || !result)
    1434           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    1435           0 :   *result = NULL;
    1436             : 
    1437           0 :   for (idx=0; !(err=ksba_cert_get_extension (cert, idx, &oid, &crit,
    1438           0 :                                              &off, &derlen)); idx++)
    1439             :     {
    1440           0 :       if (!strcmp (oid, oidstr_extKeyUsage))
    1441             :         {
    1442             :           char *suboid;
    1443             : 
    1444           0 :           der = cert->image + off;
    1445             : 
    1446           0 :           err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1447           0 :           if (err)
    1448           0 :             goto leave;
    1449           0 :           if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1450           0 :                  && ti.is_constructed) )
    1451             :             {
    1452           0 :               err = gpg_error (GPG_ERR_INV_CERT_OBJ);
    1453           0 :               goto leave;
    1454             :             }
    1455           0 :           if (ti.ndef)
    1456             :             {
    1457           0 :               err = gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1458           0 :               goto leave;
    1459             :             }
    1460           0 :           if (ti.length > derlen)
    1461             :             {
    1462           0 :               err = gpg_error (GPG_ERR_BAD_BER);
    1463           0 :               goto leave;
    1464             :             }
    1465           0 :           while (derlen)
    1466             :             {
    1467           0 :               err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1468           0 :               if (err)
    1469           0 :                 goto leave;
    1470           0 :               if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OBJECT_ID))
    1471             :                 {
    1472           0 :                   err = gpg_error (GPG_ERR_INV_CERT_OBJ);
    1473           0 :                   goto leave;
    1474             :                 }
    1475           0 :               if (ti.ndef)
    1476             :                 {
    1477           0 :                   err = gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1478           0 :                   goto leave;
    1479             :                 }
    1480           0 :               if (ti.length > derlen)
    1481             :                 {
    1482           0 :                   err = gpg_error (GPG_ERR_BAD_BER);
    1483           0 :                   goto leave;
    1484             :                 }
    1485             : 
    1486           0 :               suboid = ksba_oid_to_str (der, ti.length);
    1487           0 :               if (!suboid)
    1488             :                 {
    1489           0 :                   err = gpg_error (GPG_ERR_ENOMEM);
    1490           0 :                   goto leave;
    1491             :                 }
    1492           0 :               der       += ti.length;
    1493           0 :               derlen    -= ti.length;
    1494             : 
    1495           0 :               err = append_cert_policy (result, suboid, crit);
    1496           0 :               xfree (suboid);
    1497           0 :               if (err)
    1498           0 :                 goto leave;
    1499             :             }
    1500             :         }
    1501             :     }
    1502             : 
    1503           0 :   if (gpg_err_code (err) == GPG_ERR_EOF)
    1504           0 :     err = 0;
    1505           0 :   if (!*result || gpg_err_code (err) == GPG_ERR_NO_VALUE)
    1506           0 :     err = gpg_error (GPG_ERR_NO_DATA);
    1507             : 
    1508             :  leave:
    1509           0 :   if (err)
    1510             :     {
    1511           0 :       xfree (*result);
    1512           0 :       *result = NULL;
    1513             :     }
    1514           0 :   return err;
    1515             : }
    1516             : 
    1517             : 
    1518             : 
    1519             : 
    1520             : /* Helper function for ksba_cert_get_crl_dist_point */
    1521             : static gpg_error_t
    1522           0 : parse_distribution_point (const unsigned char *der, size_t derlen,
    1523             :                           ksba_name_t *distpoint, ksba_name_t *issuer,
    1524             :                           ksba_crl_reason_t *reason)
    1525             : {
    1526             :   gpg_error_t err;
    1527             :   struct tag_info ti;
    1528             : 
    1529           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1530           0 :   if (err)
    1531           0 :     return err;
    1532           0 :   if (ti.class != CLASS_CONTEXT)
    1533           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1534           0 :   if (ti.ndef)
    1535           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1536           0 :   if (derlen < ti.length)
    1537           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1538             : 
    1539           0 :   if (ti.tag == 0 && derlen)
    1540             :     { /* distributionPointName */
    1541           0 :       err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1542           0 :       if (err)
    1543           0 :         return err;
    1544           0 :       if (ti.class != CLASS_CONTEXT)
    1545           0 :         return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1546           0 :       if (ti.ndef)
    1547           0 :         return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1548           0 :       if (derlen < ti.nhdr)
    1549           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1550           0 :       if (derlen < ti.length)
    1551           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1552             : 
    1553           0 :       if (ti.tag == 0)
    1554             :         {
    1555           0 :           if (distpoint)
    1556             :             {
    1557           0 :               err = _ksba_name_new_from_der (distpoint, der, ti.length);
    1558           0 :               if (err)
    1559           0 :                 return err;
    1560             :             }
    1561             :         }
    1562             :       else
    1563             :         {
    1564             :           /* We don't support nameRelativeToCRLIssuer yet*/
    1565             :         }
    1566           0 :       der += ti.length;
    1567           0 :       derlen -= ti.length;
    1568             : 
    1569           0 :       if (!derlen)
    1570           0 :         return 0;
    1571             : 
    1572             :       /* read the next optional element */
    1573           0 :       err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1574           0 :       if (err)
    1575           0 :         return err;
    1576           0 :       if (ti.class != CLASS_CONTEXT)
    1577           0 :         return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1578           0 :       if (ti.ndef)
    1579           0 :         return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1580           0 :       if (derlen < ti.length)
    1581           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1582             :     }
    1583             : 
    1584           0 :   if (ti.tag == 1 && derlen)
    1585             :     { /* reasonFlags */
    1586             :       unsigned int bits, mask;
    1587             :       int i, unused, full;
    1588             : 
    1589           0 :       if (!ti.length || ti.length > derlen)
    1590           0 :         return gpg_error (GPG_ERR_ENCODING_PROBLEM);
    1591           0 :       unused = *der++; derlen--;
    1592           0 :       ti.length--;
    1593           0 :       if ((!ti.length && unused) || unused/8 > ti.length)
    1594           0 :         return gpg_error (GPG_ERR_ENCODING_PROBLEM);
    1595             : 
    1596           0 :       full = ti.length - (unused+7)/8;
    1597           0 :       unused %= 8;
    1598           0 :       mask = 0;
    1599           0 :       for (i=1; unused; i <<= 1, unused--)
    1600           0 :         mask |= i;
    1601             : 
    1602             :       /* we are only required to look at the first octect */
    1603           0 :       if (ti.length && reason)
    1604             :         {
    1605           0 :           bits = *der;
    1606           0 :           if (full)
    1607           0 :             full--;
    1608             :           else {
    1609           0 :             bits &= ~mask;
    1610           0 :             mask = 0;
    1611             :           }
    1612             : 
    1613           0 :           if (bits & 0x80)
    1614           0 :             *reason |= KSBA_CRLREASON_UNSPECIFIED;
    1615           0 :           if (bits & 0x40)
    1616           0 :             *reason |= KSBA_CRLREASON_KEY_COMPROMISE;
    1617           0 :           if (bits & 0x20)
    1618           0 :             *reason |= KSBA_CRLREASON_CA_COMPROMISE;
    1619           0 :           if (bits & 0x10)
    1620           0 :             *reason |= KSBA_CRLREASON_AFFILIATION_CHANGED;
    1621           0 :           if (bits & 0x08)
    1622           0 :             *reason |= KSBA_CRLREASON_SUPERSEDED;
    1623           0 :           if (bits & 0x04)
    1624           0 :             *reason |= KSBA_CRLREASON_CESSATION_OF_OPERATION;
    1625           0 :           if (bits & 0x02)
    1626           0 :             *reason |= KSBA_CRLREASON_CERTIFICATE_HOLD;
    1627             :         }
    1628             : 
    1629           0 :       der += ti.length;
    1630           0 :       derlen -= ti.length;
    1631             : 
    1632           0 :       if (!derlen)
    1633           0 :         return 0;
    1634             : 
    1635             :       /* read the next optional element */
    1636           0 :       err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1637           0 :       if (err)
    1638           0 :         return err;
    1639           0 :       if (ti.class != CLASS_CONTEXT)
    1640           0 :         return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1641           0 :       if (ti.ndef)
    1642           0 :         return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1643           0 :       if (derlen < ti.length)
    1644           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1645             :     }
    1646             : 
    1647           0 :   if (ti.tag == 2 && derlen)
    1648             :     { /* crlIssuer */
    1649           0 :       if (issuer)
    1650             :         {
    1651           0 :           err = _ksba_name_new_from_der (issuer, der, ti.length);
    1652           0 :           if (err)
    1653           0 :             return err;
    1654             :         }
    1655             : 
    1656           0 :       der += ti.length;
    1657           0 :       derlen -= ti.length;
    1658             :     }
    1659             : 
    1660           0 :   if (derlen)
    1661           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1662             : 
    1663           0 :   return 0;
    1664             : }
    1665             : 
    1666             : /* Return the CRLDistPoints given in the cert extension.  IDX should
    1667             :    be iterated started from 0 until the function returns -1.
    1668             :    R_DISTPOINT returns a ksba_name_t object with the distribution point
    1669             :    name(s) the return value may be NULL to indicate that this name is
    1670             :    not available.  R_ISSUER returns the CRL issuer; if the returned
    1671             :    value is NULL the caller should assume that the CRL issuer is the
    1672             :    same as the certificate issuer.  R_REASON returns the reason for
    1673             :    the CRL.  This is a bit encoded value with no bit set if this has
    1674             :    not been specified in the cert.
    1675             : 
    1676             :    The caller may pass NULL to any of the pointer arguments if he is
    1677             :    not interested in this value.  The return values for R_DISTPOINT
    1678             :    and R_ISSUER must be released by the caller using
    1679             :    ksba_name_release(). */
    1680             : 
    1681             : gpg_error_t
    1682           0 : ksba_cert_get_crl_dist_point (ksba_cert_t cert, int idx,
    1683             :                               ksba_name_t *r_distpoint,
    1684             :                               ksba_name_t *r_issuer,
    1685             :                               ksba_crl_reason_t *r_reason)
    1686             : {
    1687             :   gpg_error_t err;
    1688             :   const char *oid;
    1689             :   size_t off, derlen;
    1690             :   int myidx, crit;
    1691             : 
    1692           0 :   if (r_distpoint)
    1693           0 :     *r_distpoint = NULL;
    1694           0 :   if (r_issuer)
    1695           0 :     *r_issuer = NULL;
    1696           0 :   if (r_reason)
    1697           0 :     *r_reason = 0;
    1698             : 
    1699           0 :   for (myidx=0; !(err=ksba_cert_get_extension (cert, myidx, &oid, &crit,
    1700           0 :                                                &off, &derlen)); myidx++)
    1701             :     {
    1702           0 :       if (!strcmp (oid, oidstr_crlDistributionPoints))
    1703             :         {
    1704             :           const unsigned char *der;
    1705             :           struct tag_info ti;
    1706             :            size_t seqlen;
    1707             : 
    1708           0 :           der = cert->image + off;
    1709             : 
    1710           0 :           err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1711           0 :           if (err)
    1712           0 :             return err;
    1713           0 :           if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1714           0 :                  && ti.is_constructed) )
    1715           0 :             return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1716           0 :           if (ti.ndef)
    1717           0 :             return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1718           0 :           seqlen = ti.length;
    1719           0 :           if (seqlen > derlen)
    1720           0 :             return gpg_error (GPG_ERR_BAD_BER);
    1721             : 
    1722             :           /* Note: an empty sequence is actually not allowed but we
    1723             :              better don't care */
    1724             : 
    1725           0 :           while (seqlen)
    1726             :             {
    1727           0 :               err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1728           0 :               if (err)
    1729           0 :                 return err;
    1730           0 :               if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1731           0 :                      && ti.is_constructed) )
    1732           0 :                 return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1733           0 :               if (derlen < ti.length)
    1734           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    1735           0 :               if (seqlen < ti.nhdr)
    1736           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    1737           0 :               seqlen -= ti.nhdr;
    1738           0 :               if (seqlen < ti.length)
    1739           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    1740             : 
    1741           0 :               if (idx)
    1742             :                 { /* skip because we are not yet at the desired index */
    1743           0 :                   der    += ti.length;
    1744           0 :                   derlen -= ti.length;
    1745           0 :                   seqlen -= ti.length;
    1746           0 :                   idx--;
    1747           0 :                   continue;
    1748             :                 }
    1749             : 
    1750           0 :               if (!ti.length)
    1751           0 :                 return 0;
    1752             : 
    1753           0 :               err = parse_distribution_point (der, ti.length,
    1754             :                                               r_distpoint, r_issuer, r_reason);
    1755           0 :               if (err && r_distpoint)
    1756             :                 {
    1757           0 :                   ksba_name_release (*r_distpoint);
    1758           0 :                   *r_distpoint = NULL;
    1759             :                 }
    1760           0 :               if (err && r_issuer)
    1761             :                 {
    1762           0 :                   ksba_name_release (*r_issuer);
    1763           0 :                   *r_issuer = NULL;
    1764             :                 }
    1765           0 :               if (err && r_reason)
    1766           0 :                 *r_reason = 0;
    1767             : 
    1768           0 :               return err;
    1769             :             }
    1770             :         }
    1771             :     }
    1772             : 
    1773           0 :   return err;
    1774             : }
    1775             : 
    1776             : 
    1777             : /* Return the authorityKeyIdentifier in R_NAME and R_SERIAL or/and in
    1778             :    R_KEYID.  GPG_ERR_NO_DATA is returned if no authorityKeyIdentifier
    1779             :    or only one using the keyIdentifier method is available and R_KEYID
    1780             :    is NULL. */
    1781             : gpg_error_t
    1782           0 : ksba_cert_get_auth_key_id (ksba_cert_t cert,
    1783             :                            ksba_sexp_t *r_keyid,
    1784             :                            ksba_name_t *r_name,
    1785             :                            ksba_sexp_t *r_serial)
    1786             : {
    1787             :   gpg_error_t err;
    1788             :   const char *oid;
    1789             :   size_t off, derlen;
    1790             :   const unsigned char *der;
    1791           0 :   const unsigned char *keyid_der = NULL;
    1792           0 :   size_t keyid_derlen = 0;
    1793             :   int idx, crit;
    1794             :   struct tag_info ti;
    1795             :   char numbuf[30];
    1796             :   size_t numbuflen;
    1797             : 
    1798           0 :   if (r_keyid)
    1799           0 :     *r_keyid = NULL;
    1800           0 :   if (!r_name || !r_serial)
    1801           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    1802           0 :   *r_name = NULL;
    1803           0 :   *r_serial = NULL;
    1804             : 
    1805           0 :   for (idx=0; !(err=ksba_cert_get_extension (cert, idx, &oid, &crit,
    1806           0 :                                              &off, &derlen)); idx++)
    1807             :     {
    1808           0 :       if (!strcmp (oid, oidstr_authorityKeyIdentifier))
    1809           0 :         break;
    1810             :     }
    1811           0 :   if (gpg_err_code (err) == GPG_ERR_EOF
    1812           0 :       || gpg_err_code (err) == GPG_ERR_NO_VALUE)
    1813           0 :     return gpg_error (GPG_ERR_NO_DATA); /* not available */
    1814           0 :   if (err)
    1815           0 :     return err;
    1816             : 
    1817             :   /* check that there is only one */
    1818           0 :   for (idx++; !(err=ksba_cert_get_extension (cert, idx, &oid, NULL,
    1819           0 :                                              NULL, NULL)); idx++)
    1820             :     {
    1821           0 :       if (!strcmp (oid, oidstr_authorityKeyIdentifier))
    1822           0 :         return gpg_error (GPG_ERR_DUP_VALUE);
    1823             :     }
    1824             : 
    1825           0 :   der = cert->image + off;
    1826             : 
    1827           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1828           0 :   if (err)
    1829           0 :     return err;
    1830           0 :   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    1831           0 :          && ti.is_constructed) )
    1832           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1833           0 :   if (ti.ndef)
    1834           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1835           0 :   if (ti.length > derlen)
    1836           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1837             : 
    1838           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1839           0 :   if (err)
    1840           0 :     return err;
    1841           0 :   if (ti.class != CLASS_CONTEXT)
    1842           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1843           0 :   if (ti.ndef)
    1844           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1845           0 :   if (derlen < ti.length)
    1846           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1847             : 
    1848           0 :   if (ti.tag == 0)
    1849             :     { /* keyIdentifier:  Save it away and skip over it. */
    1850           0 :       keyid_der = der;
    1851           0 :       keyid_derlen = ti.length;
    1852             : 
    1853           0 :       der += ti.length;
    1854           0 :       derlen -= ti.length;
    1855             :       /* If the keyid has been requested but no other data follows, we
    1856             :          directly jump to the end. */
    1857           0 :       if (r_keyid && !derlen)
    1858           0 :         goto build_keyid;
    1859           0 :       if (!derlen)
    1860           0 :         return gpg_error (GPG_ERR_NO_DATA); /* not available */
    1861           0 :       err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1862           0 :       if (err)
    1863           0 :         return err;
    1864           0 :       if (ti.class != CLASS_CONTEXT)
    1865           0 :         return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1866           0 :       if (ti.ndef)
    1867           0 :         return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1868           0 :       if (derlen < ti.length)
    1869           0 :         return gpg_error (GPG_ERR_BAD_BER);
    1870             :     }
    1871             : 
    1872           0 :   if (ti.tag != 1 || !derlen)
    1873           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1874             : 
    1875           0 :   err = _ksba_name_new_from_der (r_name, der, ti.length);
    1876           0 :   if (err)
    1877           0 :     return err;
    1878             : 
    1879           0 :   der += ti.length;
    1880           0 :   derlen -= ti.length;
    1881             : 
    1882             :   /* fixme: we should release r_name before returning on error */
    1883           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1884           0 :   if (err)
    1885           0 :     return err;
    1886           0 :   if (ti.class != CLASS_CONTEXT)
    1887           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ); /* we expected a tag */
    1888           0 :   if (ti.ndef)
    1889           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1890           0 :   if (derlen < ti.length)
    1891           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1892             : 
    1893           0 :   if (ti.tag != 2 || !derlen)
    1894           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1895             : 
    1896           0 :   sprintf (numbuf,"(%u:", (unsigned int)ti.length);
    1897           0 :   numbuflen = strlen (numbuf);
    1898           0 :   *r_serial = xtrymalloc (numbuflen + ti.length + 2);
    1899           0 :   if (!*r_serial)
    1900           0 :     return gpg_error (GPG_ERR_ENOMEM);
    1901           0 :   strcpy (*r_serial, numbuf);
    1902           0 :   memcpy (*r_serial+numbuflen, der, ti.length);
    1903           0 :   (*r_serial)[numbuflen + ti.length] = ')';
    1904           0 :   (*r_serial)[numbuflen + ti.length + 1] = 0;
    1905             : 
    1906             :  build_keyid:
    1907           0 :   if (r_keyid && keyid_der && keyid_derlen)
    1908             :     {
    1909           0 :       sprintf (numbuf,"(%u:", (unsigned int)keyid_derlen);
    1910           0 :       numbuflen = strlen (numbuf);
    1911           0 :       *r_keyid = xtrymalloc (numbuflen + keyid_derlen + 2);
    1912           0 :       if (!*r_keyid)
    1913           0 :         return gpg_error (GPG_ERR_ENOMEM);
    1914           0 :       strcpy (*r_keyid, numbuf);
    1915           0 :       memcpy (*r_keyid+numbuflen, keyid_der, keyid_derlen);
    1916           0 :       (*r_keyid)[numbuflen + keyid_derlen] = ')';
    1917           0 :       (*r_keyid)[numbuflen + keyid_derlen + 1] = 0;
    1918             :     }
    1919           0 :   return 0;
    1920             : }
    1921             : 
    1922             : 
    1923             : /* Return a simple octet string extension at the object identifier OID
    1924             :    from certificate CERT.  The data is return as a simple S-expression
    1925             :    and stored at R_DATA.  Returns 0 on success or an error code.
    1926             :    common error codes are: GPG_ERR_NO_DATA if no such extension is
    1927             :    available, GPG_ERR_DUP_VALUE if more than one is available.  If
    1928             :    R_CRIT is not NULL, the critical extension flag will be stored at
    1929             :    that address. */
    1930             : static gpg_error_t
    1931           0 : get_simple_octet_string_ext (ksba_cert_t cert, const char *oid,
    1932             :                              int *r_crit, ksba_sexp_t *r_data)
    1933             : {
    1934             :   gpg_error_t err;
    1935             :   const char *tmpoid;
    1936             :   size_t off, derlen;
    1937             :   const unsigned char *der;
    1938             :   int idx, crit;
    1939             :   struct tag_info ti;
    1940             :   char numbuf[30];
    1941             :   size_t numbuflen;
    1942             : 
    1943           0 :   if (!r_data)
    1944           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    1945           0 :   *r_data = NULL;
    1946             : 
    1947           0 :   for (idx=0; !(err=ksba_cert_get_extension (cert, idx, &tmpoid, &crit,
    1948           0 :                                              &off, &derlen)); idx++)
    1949             :     {
    1950           0 :       if (!strcmp (tmpoid, oid))
    1951           0 :         break;
    1952             :     }
    1953           0 :   if (err)
    1954             :     {
    1955           0 :       if (gpg_err_code (err) == GPG_ERR_EOF
    1956           0 :           || gpg_err_code (err) == GPG_ERR_NO_VALUE)
    1957           0 :         return gpg_error (GPG_ERR_NO_DATA);
    1958           0 :       return err;
    1959             :     }
    1960             : 
    1961             :   /* Check that there is only one */
    1962           0 :   for (idx++; !(err=ksba_cert_get_extension (cert, idx, &tmpoid, NULL,
    1963           0 :                                              NULL, NULL)); idx++)
    1964             :     {
    1965           0 :       if (!strcmp (tmpoid, oid))
    1966           0 :         return gpg_error (GPG_ERR_DUP_VALUE);
    1967             :     }
    1968             : 
    1969           0 :   der = cert->image + off;
    1970             : 
    1971           0 :   err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    1972           0 :   if (err)
    1973           0 :     return err;
    1974           0 :   if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OCTET_STRING
    1975           0 :          && !ti.is_constructed) )
    1976           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ);
    1977           0 :   if (ti.ndef)
    1978           0 :     return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    1979           0 :   if (ti.length > derlen)
    1980           0 :     return gpg_error (GPG_ERR_BAD_BER);
    1981           0 :   if (ti.length != derlen)
    1982           0 :     return gpg_error (GPG_ERR_INV_CERT_OBJ); /* Garbage follows. */
    1983             : 
    1984           0 :   sprintf (numbuf,"(%u:", (unsigned int)ti.length);
    1985           0 :   numbuflen = strlen (numbuf);
    1986           0 :   *r_data = xtrymalloc (numbuflen + ti.length + 2);
    1987           0 :   if (!*r_data)
    1988           0 :     return gpg_error (GPG_ERR_ENOMEM);
    1989           0 :   strcpy (*r_data, numbuf);
    1990           0 :   memcpy (*r_data+numbuflen, der, ti.length);
    1991           0 :   (*r_data)[numbuflen + ti.length] = ')';
    1992           0 :   (*r_data)[numbuflen + ti.length + 1] = 0;
    1993           0 :   if (r_crit)
    1994           0 :     *r_crit = crit;
    1995           0 :   return 0;
    1996             : }
    1997             : 
    1998             : 
    1999             : /* Return the subjectKeyIdentifier extension as a simple allocated
    2000             :    S-expression at the address of R_KEYID. 0 is returned on success,
    2001             :    GPG_ERR_NO_DATA if no such extension is available or any other
    2002             :    error code.  If R_CRIT is not passed as NULL, the criticla flag of
    2003             :    this is extension is stored there. */
    2004             : gpg_error_t
    2005           0 : ksba_cert_get_subj_key_id (ksba_cert_t cert, int *r_crit, ksba_sexp_t *r_keyid)
    2006             : {
    2007           0 :   return get_simple_octet_string_ext (cert, oidstr_subjectKeyIdentifier,
    2008             :                                       r_crit, r_keyid);
    2009             : }
    2010             : 
    2011             : 
    2012             : 
    2013             : /* MODE 0 := authorityInfoAccess
    2014             :         1 := subjectInfoAccess
    2015             : 
    2016             :    Caller must release METHOD and LOCATION if the function returned
    2017             :    with success; on error both variables will point to NULL.
    2018             :  */
    2019             : static gpg_error_t
    2020           0 : get_info_access (ksba_cert_t cert, int idx, int mode,
    2021             :                  char **method, ksba_name_t *location)
    2022             : {
    2023             :   gpg_error_t err;
    2024             :   const char *oid;
    2025             :   size_t off, derlen;
    2026             :   int myidx, crit;
    2027             : 
    2028           0 :   *method = NULL;
    2029           0 :   *location = NULL;
    2030             : 
    2031           0 :   if (!cert || !cert->initialized)
    2032           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    2033           0 :   if (idx < 0)
    2034           0 :     return gpg_error (GPG_ERR_INV_INDEX);
    2035             : 
    2036           0 :   for (myidx=0; !(err=ksba_cert_get_extension (cert, myidx, &oid, &crit,
    2037           0 :                                                &off, &derlen)); myidx++)
    2038             :     {
    2039           0 :       if (!strcmp (oid,(mode == 0)? oidstr_authorityInfoAccess
    2040             :                                   : oidstr_subjectInfoAccess) )
    2041             :         {
    2042             :           const unsigned char *der;
    2043             :           struct tag_info ti;
    2044             :           size_t seqlen;
    2045             : 
    2046           0 :           der = cert->image + off;
    2047             : 
    2048             :           /* What we are going to parse is:
    2049             :            *
    2050             :            *    AuthorityInfoAccessSyntax  ::=
    2051             :            *            SEQUENCE SIZE (1..MAX) OF AccessDescription
    2052             :            *
    2053             :            *    AccessDescription  ::=  SEQUENCE {
    2054             :            *            accessMethod          OBJECT IDENTIFIER,
    2055             :            *            accessLocation        GeneralName  }
    2056             :            */
    2057           0 :           err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    2058           0 :           if (err)
    2059           0 :             return err;
    2060           0 :           if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    2061           0 :                  && ti.is_constructed) )
    2062           0 :             return gpg_error (GPG_ERR_INV_CERT_OBJ);
    2063           0 :           if (ti.ndef)
    2064           0 :             return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    2065           0 :           seqlen = ti.length;
    2066           0 :           if (seqlen > derlen)
    2067           0 :             return gpg_error (GPG_ERR_BAD_BER);
    2068             : 
    2069             :           /* Note: an empty sequence is actually not allowed but we
    2070             :              better don't care. */
    2071             : 
    2072           0 :           while (seqlen)
    2073             :             {
    2074           0 :               err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    2075           0 :               if (err)
    2076           0 :                 return err;
    2077           0 :               if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_SEQUENCE
    2078           0 :                      && ti.is_constructed) )
    2079           0 :                 return gpg_error (GPG_ERR_INV_CERT_OBJ);
    2080           0 :               if (derlen < ti.length)
    2081           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    2082           0 :               if (seqlen < ti.nhdr)
    2083           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    2084           0 :               seqlen -= ti.nhdr;
    2085           0 :               if (seqlen < ti.length)
    2086           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    2087             : 
    2088           0 :               if (idx)
    2089             :                 { /* Skip because we are not yet at the desired index. */
    2090           0 :                   der    += ti.length;
    2091           0 :                   derlen -= ti.length;
    2092           0 :                   seqlen -= ti.length;
    2093           0 :                   idx--;
    2094           0 :                   continue;
    2095             :                 }
    2096             :               /* We only need the next object, thus we can (and
    2097             :                  actually need to) limit the DERLEN to the length of
    2098             :                  the current sequence. */
    2099           0 :               derlen = ti.length;
    2100           0 :               if (!derlen)
    2101           0 :                 return gpg_error (GPG_ERR_INV_CERT_OBJ);
    2102             : 
    2103           0 :               err = _ksba_ber_parse_tl (&der, &derlen, &ti);
    2104           0 :               if (err)
    2105           0 :                 return err;
    2106             : 
    2107           0 :               if ( !(ti.class == CLASS_UNIVERSAL && ti.tag == TYPE_OBJECT_ID
    2108           0 :                      && !ti.is_constructed))
    2109           0 :                 return gpg_error (GPG_ERR_INV_CERT_OBJ);
    2110           0 :               if (ti.ndef)
    2111           0 :                 return gpg_error (GPG_ERR_NOT_DER_ENCODED);
    2112           0 :               if (derlen < ti.length)
    2113           0 :                 return gpg_error (GPG_ERR_BAD_BER);
    2114             : 
    2115           0 :               *method = ksba_oid_to_str (der, ti.length);
    2116           0 :               if (!*method)
    2117           0 :                 return gpg_error (GPG_ERR_ENOMEM);
    2118           0 :               der       += ti.length;
    2119           0 :               derlen    -= ti.length;
    2120             : 
    2121           0 :               err = _ksba_name_new_from_der (location, der, derlen);
    2122           0 :               if (err)
    2123             :                 {
    2124           0 :                   ksba_free (*method);
    2125           0 :                   *method = NULL;
    2126           0 :                   return err;
    2127             :                 }
    2128           0 :               return 0;
    2129             :             }
    2130             :         }
    2131             :     }
    2132             : 
    2133           0 :   return err;
    2134             : }
    2135             : 
    2136             : 
    2137             : /* Return the authorityInfoAccess attributes. IDX should be iterated
    2138             :    starting from 0 until the function returns GPG_ERR_EOF.  R_METHOD
    2139             :    returns an allocated string with the OID of one item and R_LOCATION
    2140             :    return the GeneralName for that OID.  The return values for
    2141             :    R_METHOD and R_LOCATION must be released by the caller unless the
    2142             :    function returned an error; the function will however make sure
    2143             :    that R_METHOD and R_LOCATION will point to NULL if the function
    2144             :    returns an error.  See RFC 2459, section 4.2.2.1 */
    2145             : gpg_error_t
    2146           0 : ksba_cert_get_authority_info_access (ksba_cert_t cert, int idx,
    2147             :                                      char **r_method, ksba_name_t *r_location)
    2148             : {
    2149           0 :   if (!r_method || !r_location)
    2150           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    2151           0 :   return get_info_access (cert, idx, 0, r_method, r_location);
    2152             : }
    2153             : 
    2154             : /* Return the subjectInfoAccess attributes. IDX should be iterated
    2155             :    starting from 0 until the function returns GPG_ERR_EOF.  R_METHOD
    2156             :    returns an allocated string with the OID of one item and R_LOCATION
    2157             :    return the GeneralName for that OID.  The return values for
    2158             :    R_METHOD and R_LOCATION must be released by the caller unless the
    2159             :    function returned an error; the function will however make sure
    2160             :    that R_METHOD and R_LOCATION will point to NULL if the function
    2161             :    returns an error.  See RFC 2459, section 4.2.2.2 */
    2162             : gpg_error_t
    2163           0 : ksba_cert_get_subject_info_access (ksba_cert_t cert, int idx,
    2164             :                                    char **r_method, ksba_name_t *r_location)
    2165             : {
    2166           0 :   if (!r_method || !r_location)
    2167           0 :     return gpg_error (GPG_ERR_INV_VALUE);
    2168           0 :   return get_info_access (cert, idx, 1, r_method, r_location);
    2169             : }

Generated by: LCOV version 1.12