Mainly changes to adjust for the changed KSBA API.
[gnupg.git] / sm / certchain.c
index a32c2d7..a25e082 100644 (file)
@@ -1,5 +1,5 @@
-/* certpath.c - path validation
- *     Copyright (C) 2001 Free Software Foundation, Inc.
+/* certchain.c - certificate chain validation
+ *     Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <time.h>
 #include <assert.h>
 
+#include "gpgsm.h"
 #include <gcrypt.h>
 #include <ksba.h>
 
-#include "gpgsm.h"
 #include "keydb.h"
 #include "i18n.h"
 
@@ -58,28 +58,28 @@ unknown_criticals (KsbaCert cert)
         {
           log_error (_("critical certificate extension %s is not supported\n"),
                      oid);
-          rc = GNUPG_Unsupported_Certificate;
+          rc = gpg_error (GPG_ERR_UNSUPPORTED_CERT);
         }
     }
   if (err && err != -1)
-    rc = map_ksba_err (err);
+    rc = err;
 
   return rc;
 }
 
 static int
-allowed_ca (KsbaCert cert, int *pathlen)
+allowed_ca (KsbaCert cert, int *chainlen)
 {
   KsbaError err;
   int flag;
 
-  err = ksba_cert_is_ca (cert, &flag, pathlen);
+  err = ksba_cert_is_ca (cert, &flag, chainlen);
   if (err)
-    return map_ksba_err (err);
+    return err;
   if (!flag)
     {
       log_error (_("issuer certificate is not marked as a CA\n"));
-      return GNUPG_Bad_CA_Certificate;
+      return gpg_error (GPG_ERR_BAD_CA_CERT);
     }
   return 0;
 }
@@ -94,10 +94,10 @@ check_cert_policy (KsbaCert cert)
   int any_critical;
 
   err = ksba_cert_get_cert_policies (cert, &policies);
-  if (err == KSBA_No_Data)
+  if (gpg_err_code (err) == GPG_ERR_NO_DATA)
     return 0; /* no policy given */
   if (err)
-    return map_ksba_err (err);
+    return err;
 
   /* STRING is a line delimited list of certifiate policies as stored
      in the certificate.  The line itself is colon delimited where the
@@ -116,7 +116,7 @@ check_cert_policy (KsbaCert cert)
       if (any_critical)
         {
           log_error ("critical marked policy without configured policies\n");
-          return GNUPG_No_Policy_Match;
+          return gpg_error (GPG_ERR_NO_POLICY_MATCH);
         }
       return 0;
     }
@@ -127,7 +127,7 @@ check_cert_policy (KsbaCert cert)
       log_error ("failed to open `%s': %s\n",
                  opt.policy_file, strerror (errno));
       xfree (policies);
-      return GNUPG_No_Policy_Match;
+      return gpg_error (GPG_ERR_NO_POLICY_MATCH);
     }
 
   for (;;) 
@@ -141,16 +141,24 @@ check_cert_policy (KsbaCert cert)
         {
           if (!fgets (line, DIM(line)-1, fp) )
             {
+              gpg_error_t tmperr;
+
               xfree (policies);
               if (feof (fp))
                 {
                   fclose (fp);
-                  log_error (_("certificate policy not allowed\n"));
                   /* with no critical policies this is only a warning */
-                  return any_critical? GNUPG_No_Policy_Match : 0;
+                  if (!any_critical)
+                    {
+                      log_info (_("note: certificate policy not allowed\n"));
+                      return 0;
+                    }
+                  log_error (_("certificate policy not allowed\n"));
+                  return gpg_error (GPG_ERR_NO_POLICY_MATCH);
                 }
+              tmperr = gpg_error (gpg_err_code_from_errno (errno));
               fclose (fp);
-              return GNUPG_Read_Error;
+              return tmperr;
             }
       
           if (!*line || line[strlen(line)-1] != '\n')
@@ -160,7 +168,8 @@ check_cert_policy (KsbaCert cert)
                 ;
               fclose (fp);
               xfree (policies);
-              return *line? GNUPG_Line_Too_Long: GNUPG_Incomplete_Line;
+              return gpg_error (*line? GPG_ERR_LINE_TOO_LONG
+                                     : GPG_ERR_INCOMPLETE_LINE);
             }
           
           /* Allow for empty lines and spaces */
@@ -177,7 +186,7 @@ check_cert_policy (KsbaCert cert)
         {
           fclose (fp);
           xfree (policies);
-          return GNUPG_Configuration_Error;
+          return gpg_error (GPG_ERR_CONFIGURATION);
         }
       *p = 0; /* strip the rest of the line */
       /* See whether we find ALLOWED (which is an OID) in POLICIES */
@@ -196,6 +205,15 @@ check_cert_policy (KsbaCert cert)
 }
 
 
+static void
+find_up_store_certs_cb (void *cb_value, KsbaCert cert)
+{
+  if (keydb_store_cert (cert, 1, NULL))
+    log_error ("error storing issuer certificate as ephemeral\n");
+  ++*(int*)cb_value;
+}
+
+
 static int
 find_up (KEYDB_HANDLE kh, KsbaCert cert, const char *issuer)
 {
@@ -211,13 +229,95 @@ find_up (KEYDB_HANDLE kh, KsbaCert cert, const char *issuer)
           rc = keydb_search_issuer_sn (kh, s, authidno);
           if (rc)
               keydb_search_reset (kh);
+          if (rc == -1)
+            { /* And try the ephemeral DB. */
+              int old = keydb_set_ephemeral (kh, 1);
+              if (!old)
+                {
+                  rc = keydb_search_issuer_sn (kh, s, authidno);
+                  if (rc)
+                    keydb_search_reset (kh);
+                }
+              keydb_set_ephemeral (kh, old);
+            }
+        }
+      /* print a note so that the user does not feel too helpless when
+         an issuer certificate was found and gpgsm prints BAD
+         signature becuase it is not the correct one. */
+      if (rc == -1)
+        {
+          log_info ("issuer certificate (#");
+          gpgsm_dump_serial (authidno);
+          log_printf ("/");
+          gpgsm_dump_string (s);
+          log_printf (") not found\n");
         }
+      else if (rc)
+        log_error ("failed to find authorityKeyIdentifier: rc=%d\n", rc);
       ksba_name_release (authid);
       xfree (authidno);
+      /* Fixme: don't know how to do dirmngr lookup with serial+issuer. */
     }
   
-  if (rc)
-    rc = keydb_search_subject (kh, issuer);
+  if (rc) /* not found via authorithyKeyIdentifier, try regular issuer name */
+      rc = keydb_search_subject (kh, issuer);
+  if (rc == -1)
+    {
+      /* Not found, lets see whether we have one in the ephemeral key DB. */
+      int old = keydb_set_ephemeral (kh, 1);
+      if (!old)
+        {
+          keydb_search_reset (kh);
+          rc = keydb_search_subject (kh, issuer);
+        }
+      keydb_set_ephemeral (kh, old);
+    }
+
+  if (rc == -1 && opt.auto_issuer_key_retrieve)
+    {
+      STRLIST names = NULL;
+      int count = 0;
+      char *pattern;
+      const char *s;
+      
+      if (opt.verbose)
+        log_info (_("looking up issuer at external location\n"));
+      /* dirmngr is confused about unknown attributes so has a quick
+         and ugly hack we locate the CN and use this and the
+         following.  Fixme: we should have far better parsing in the
+         dirmngr. */
+      s = strstr (issuer, "CN=");
+      if (!s || s == issuer || s[-1] != ',')
+        s = issuer;
+
+      pattern = xtrymalloc (strlen (s)+2);
+      if (!pattern)
+        return OUT_OF_CORE (errno);
+      strcpy (stpcpy (pattern, "/"), s);
+      add_to_strlist (&names, pattern);
+      xfree (pattern);
+      rc = gpgsm_dirmngr_lookup (NULL, names, find_up_store_certs_cb, &count);
+      free_strlist (names);
+      if (opt.verbose)
+        log_info (_("number of issuers matching: %d\n"), count);
+      if (rc) 
+        {
+          log_error ("external key lookup failed: %s\n", gpg_strerror (rc));
+          rc = -1;
+        }
+      else if (!count)
+        rc = -1;
+      else
+        {
+          int old;
+          /* The issuers are currently stored in the ephemeral key
+             DB, so we temporary switch to ephemeral mode. */
+          old = keydb_set_ephemeral (kh, 1);
+          keydb_search_reset (kh);
+          rc = keydb_search_subject (kh, issuer);
+          keydb_set_ephemeral (kh, old);
+        }
+    }
   return rc;
 }
 
@@ -236,7 +336,7 @@ gpgsm_walk_cert_chain (KsbaCert start, KsbaCert *r_next)
   if (!kh)
     {
       log_error (_("failed to allocated keyDB handle\n"));
-      rc = GNUPG_General_Error;
+      rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
@@ -245,13 +345,13 @@ gpgsm_walk_cert_chain (KsbaCert start, KsbaCert *r_next)
   if (!issuer)
     {
       log_error ("no issuer found in certificate\n");
-      rc = GNUPG_Bad_Certificate;
+      rc = gpg_error (GPG_ERR_BAD_CERT);
       goto leave;
     }
   if (!subject)
     {
       log_error ("no subject found in certificate\n");
-      rc = GNUPG_Bad_Certificate;
+      rc = gpg_error (GPG_ERR_BAD_CERT);
       goto leave;
     }
 
@@ -268,7 +368,7 @@ gpgsm_walk_cert_chain (KsbaCert start, KsbaCert *r_next)
          print an error here */
       if (rc != -1 && opt.verbose > 1)
         log_error ("failed to find issuer's certificate: rc=%d\n", rc);
-      rc = GNUPG_Missing_Certificate;
+      rc = gpg_error (GPG_ERR_MISSING_CERT);
       goto leave;
     }
 
@@ -276,7 +376,7 @@ gpgsm_walk_cert_chain (KsbaCert start, KsbaCert *r_next)
   if (rc)
     {
       log_error ("failed to get cert: rc=%d\n", rc);
-      rc = GNUPG_General_Error;
+      rc = gpg_error (GPG_ERR_GENERAL);
     }
 
  leave:
@@ -305,37 +405,40 @@ gpgsm_is_root_cert (KsbaCert cert)
 }
 
 \f
-/* Validate a path and optionally return the nearest expiration time
+/* Validate a chain and optionally return the nearest expiration time
    in R_EXPTIME */
 int
-gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
+gpgsm_validate_chain (CTRL ctrl, KsbaCert cert, ksba_isotime_t r_exptime)
 {
   int rc = 0, depth = 0, maxdepth;
   char *issuer = NULL;
   char *subject = NULL;
   KEYDB_HANDLE kh = keydb_new (0);
   KsbaCert subject_cert = NULL, issuer_cert = NULL;
-  time_t current_time = gnupg_get_time ();
-  time_t exptime = 0;
+  ksba_isotime_t current_time;
+  ksba_isotime_t exptime;
   int any_expired = 0;
   int any_revoked = 0;
   int any_no_crl = 0;
   int any_crl_too_old = 0;
   int any_no_policy_match = 0;
 
+
+  gnupg_get_isotime (current_time);
   if (r_exptime)
     *r_exptime = 0;
+  *exptime = 0;
 
-  if (opt.no_path_validation)
+  if (opt.no_chain_validation)
     {
-      log_info ("WARNING: bypassing path validation\n");
+      log_info ("WARNING: bypassing certificate chain validation\n");
       return 0;
     }
   
   if (!kh)
     {
       log_error (_("failed to allocated keyDB handle\n"));
-      rc = GNUPG_General_Error;
+      rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
@@ -355,39 +458,41 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
       if (!issuer)
         {
           log_error ("no issuer found in certificate\n");
-          rc = GNUPG_Bad_Certificate;
+          rc = gpg_error (GPG_ERR_BAD_CERT);
           goto leave;
         }
 
       {
-        time_t not_before, not_after;
+        ksba_isotime_t not_before, not_after;
 
-        not_before = ksba_cert_get_validity (subject_cert, 0);
-        not_after = ksba_cert_get_validity (subject_cert, 1);
-        if (not_before == (time_t)(-1) || not_after == (time_t)(-1))
+        rc = ksba_cert_get_validity (subject_cert, 0, not_before);
+        if (!rc)
+          rc = ksba_cert_get_validity (subject_cert, 1, not_after);
+        if (rc)
           {
-            log_error ("certificate with invalid validity\n");
-            rc = GNUPG_Bad_Certificate;
+            log_error (_("certificate with invalid validity: %s\n"),
+                       gpg_strerror (rc));
+            rc = gpg_error (GPG_ERR_BAD_CERT);
             goto leave;
           }
 
-        if (not_after)
+        if (*not_after)
           {
-            if (!exptime)
-              exptime = not_after;
-            else if (not_after < exptime)
-              exptime = not_after;
+            if (!*exptime)
+              gnupg_copy_time (exptime, not_after);
+            else if (strcmp (not_after, exptime) < 0 )
+              gnupg_copy_time (exptime, not_after);
           }
 
-        if (not_before && current_time < not_before)
+        if (*not_before && strcmp (current_time, not_before) < 0 )
           {
             log_error ("certificate too young; valid from ");
             gpgsm_dump_time (not_before);
             log_printf ("\n");
-            rc = GNUPG_Certificate_Too_Young;
+            rc = gpg_error (GPG_ERR_CERT_TOO_YOUNG);
             goto leave;
           }            
-        if (not_after && current_time > not_after)
+        if (not_after && strcmp (current_time, not_after) > 0 )
           {
             log_error ("certificate has expired at ");
             gpgsm_dump_time (not_after);
@@ -403,7 +508,7 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
       if (!opt.no_policy_check)
         {
           rc = check_cert_policy (subject_cert);
-          if (rc == GNUPG_No_Policy_Match)
+          if (gpg_err_code (rc) == GPG_ERR_NO_POLICY_MATCH)
             {
               any_no_policy_match = 1;
               rc = 1;
@@ -417,17 +522,17 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
           rc = gpgsm_dirmngr_isvalid (subject_cert);
           if (rc)
             {
-              switch (rc)
+              switch (gpg_err_code (rc))
                 {
-                case GNUPG_Certificate_Revoked:
+                case GPG_ERR_CERT_REVOKED:
                   log_error (_("the certificate has been revoked\n"));
                   any_revoked = 1;
                   break;
-                case GNUPG_No_CRL_Known:
+                case GPG_ERR_NO_CRL_KNOWN:
                   log_error (_("no CRL found for certificate\n"));
                   any_no_crl = 1;
                   break;
-                case GNUPG_CRL_Too_Old:
+                case GPG_ERR_CRL_TOO_OLD:
                   log_error (_("the available CRL is too old\n"));
                   log_info (_("please make sure that the "
                               "\"dirmngr\" is properly installed\n"));
@@ -435,7 +540,7 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
                   break;
                 default:
                   log_error (_("checking the CRL failed: %s\n"),
-                             gnupg_strerror (rc));
+                             gpg_strerror (rc));
                   goto leave;
                 }
               rc = 0;
@@ -447,7 +552,8 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
           if (gpgsm_check_cert_sig (subject_cert, subject_cert) )
             {
               log_error ("selfsigned certificate has a BAD signatures\n");
-              rc = depth? GNUPG_Bad_Certificate_Path : GNUPG_Bad_Certificate;
+              rc = gpg_error (depth? GPG_ERR_BAD_CERT_CHAIN
+                                   : GPG_ERR_BAD_CERT);
               goto leave;
             }
           rc = allowed_ca (subject_cert, NULL);
@@ -457,7 +563,7 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
           rc = gpgsm_agent_istrusted (subject_cert);
           if (!rc)
             ;
-          else if (rc == GNUPG_Not_Trusted)
+          else if (gpg_err_code (rc) == GPG_ERR_NOT_TRUSTED)
             {
               int rc2;
 
@@ -484,7 +590,7 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
           else 
             {
               log_error (_("checking the trust list failed: %s\n"),
-                         gnupg_strerror (rc));
+                         gpg_strerror (rc));
             }
           
           break;  /* okay, a self-signed certicate is an end-point */
@@ -493,8 +599,8 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
       depth++;
       if (depth > maxdepth)
         {
-          log_error (_("certificate path too long\n"));
-          rc = GNUPG_Bad_Certificate_Path;
+          log_error (_("certificate chain too long\n"));
+          rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
           goto leave;
         }
 
@@ -505,13 +611,13 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
         {
           if (rc == -1)
             {
-              log_info ("issuer certificate (");
+              log_info ("issuer certificate (#/");
               gpgsm_dump_string (issuer);
               log_printf (") not found\n");
             }
           else
             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
-          rc = GNUPG_Missing_Certificate;
+          rc = gpg_error (GPG_ERR_MISSING_CERT);
           goto leave;
         }
 
@@ -520,7 +626,7 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
       if (rc)
         {
           log_error ("failed to get cert: rc=%d\n", rc);
-          rc = GNUPG_General_Error;
+          rc = gpg_error (GPG_ERR_GENERAL);
           goto leave;
         }
 
@@ -533,20 +639,20 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
       if (gpgsm_check_cert_sig (issuer_cert, subject_cert) )
         {
           log_error ("certificate has a BAD signatures\n");
-          rc = GNUPG_Bad_Certificate_Path;
+          rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
           goto leave;
         }
 
       {
-        int pathlen;
-        rc = allowed_ca (issuer_cert, &pathlen);
+        int chainlen;
+        rc = allowed_ca (issuer_cert, &chainlen);
         if (rc)
           goto leave;
-        if (pathlen >= 0 && (depth - 1) > pathlen)
+        if (chainlen >= 0 && (depth - 1) > chainlen)
           {
-            log_error (_("certificate path longer than allowed by CA (%d)\n"),
-                       pathlen);
-            rc = GNUPG_Bad_Certificate_Path;
+            log_error (_("certificate chain longer than allowed by CA (%d)\n"),
+                       chainlen);
+            rc = gpg_error (GPG_ERR_BAD_CERT_CHAIN);
             goto leave;
           }
       }
@@ -554,8 +660,10 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
       rc = gpgsm_cert_use_cert_p (issuer_cert);
       if (rc)
         {
-          gpgsm_status2 (ctrl, STATUS_ERROR, "certpath.issuer.keyusage",
-                         gnupg_error_token (rc), NULL);
+          char numbuf[50];
+          sprintf (numbuf, "%d", rc);
+          gpgsm_status2 (ctrl, STATUS_ERROR, "certcert.issuer.keyusage",
+                         numbuf, NULL);
           rc = 0;
         }
 
@@ -576,20 +684,20 @@ gpgsm_validate_path (CTRL ctrl, KsbaCert cert, time_t *r_exptime)
     { /* If we encountered an error somewhere during the checks, set
          the error code to the most critical one */
       if (any_revoked)
-        rc = GNUPG_Certificate_Revoked;
+        rc = gpg_error (GPG_ERR_CERT_REVOKED);
       else if (any_no_crl)
-        rc = GNUPG_No_CRL_Known;
+        rc = gpg_error (GPG_ERR_NO_CRL_KNOWN);
       else if (any_crl_too_old)
-        rc = GNUPG_CRL_Too_Old;
+        rc = gpg_error (GPG_ERR_CRL_TOO_OLD);
       else if (any_no_policy_match)
-        rc = GNUPG_No_Policy_Match;
+        rc = gpg_error (GPG_ERR_NO_POLICY_MATCH);
       else if (any_expired)
-        rc = GNUPG_Certificate_Expired;
+        rc = gpg_error (GPG_ERR_CERT_EXPIRED);
     }
   
  leave:
   if (r_exptime)
-    *r_exptime = exptime;
+    gnupg_copy_time (r_exptime, exptime);
   xfree (issuer);
   keydb_release (kh); 
   ksba_cert_release (issuer_cert);
@@ -612,7 +720,7 @@ gpgsm_basic_cert_check (KsbaCert cert)
   KEYDB_HANDLE kh = keydb_new (0);
   KsbaCert issuer_cert = NULL;
 
-  if (opt.no_path_validation)
+  if (opt.no_chain_validation)
     {
       log_info ("WARNING: bypassing basic certificate checks\n");
       return 0;
@@ -621,7 +729,7 @@ gpgsm_basic_cert_check (KsbaCert cert)
   if (!kh)
     {
       log_error (_("failed to allocated keyDB handle\n"));
-      rc = GNUPG_General_Error;
+      rc = gpg_error (GPG_ERR_GENERAL);
       goto leave;
     }
 
@@ -630,7 +738,7 @@ gpgsm_basic_cert_check (KsbaCert cert)
   if (!issuer)
     {
       log_error ("no issuer found in certificate\n");
-      rc = GNUPG_Bad_Certificate;
+      rc = gpg_error (GPG_ERR_BAD_CERT);
       goto leave;
     }
 
@@ -639,7 +747,7 @@ gpgsm_basic_cert_check (KsbaCert cert)
       if (gpgsm_check_cert_sig (cert, cert) )
         {
           log_error ("selfsigned certificate has a BAD signatures\n");
-          rc = GNUPG_Bad_Certificate;
+          rc = gpg_error (GPG_ERR_BAD_CERT);
           goto leave;
         }
     }
@@ -652,13 +760,13 @@ gpgsm_basic_cert_check (KsbaCert cert)
         {
           if (rc == -1)
             {
-              log_info ("issuer certificate (");
+              log_info ("issuer certificate (#/");
               gpgsm_dump_string (issuer);
               log_printf (") not found\n");
             }
           else
             log_error ("failed to find issuer's certificate: rc=%d\n", rc);
-          rc = GNUPG_Missing_Certificate;
+          rc = gpg_error (GPG_ERR_MISSING_CERT);
           goto leave;
         }
       
@@ -667,14 +775,14 @@ gpgsm_basic_cert_check (KsbaCert cert)
       if (rc)
         {
           log_error ("failed to get cert: rc=%d\n", rc);
-          rc = GNUPG_General_Error;
+          rc = gpg_error (GPG_ERR_GENERAL);
           goto leave;
         }
 
       if (gpgsm_check_cert_sig (issuer_cert, cert) )
         {
           log_error ("certificate has a BAD signatures\n");
-          rc = GNUPG_Bad_Certificate;
+          rc = gpg_error (GPG_ERR_BAD_CERT);
           goto leave;
         }
       if (opt.verbose)