2005-10-01 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / verify.c
index afd5946..d7c3216 100644 (file)
@@ -1,22 +1,23 @@
 /* verify.c - Signature verification.
    Copyright (C) 2000 Werner Koch (dd9jn)
-   Copyright (C) 2001, 2002, 2003 g10 Code GmbH
+   Copyright (C) 2001, 2002, 2003, 2004, 2005 g10 Code GmbH
 
    This file is part of GPGME.
  
    GPGME is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
+   under the terms of the GNU Lesser General Public License as
+   published by the Free Software Foundation; either version 2.1 of
+   the License, or (at your option) any later version.
+   
    GPGME is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   General Public License for more details.
-   You should have received a copy of the GNU General Public License
-   along with GPGME; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   Lesser General Public License for more details.
+   
+   You should have received a copy of the GNU Lesser General Public
+   License along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.  */
 
 #if HAVE_CONFIG_H
 #include <config.h>
@@ -38,6 +39,7 @@ typedef struct
 
   gpgme_signature_t current_sig;
   int did_prepare_new_sig;
+  int only_newsig_seen;
 } *op_data_t;
 
 
@@ -56,10 +58,7 @@ release_op_data (void *hook)
        {
          gpgme_sig_notation_t next_nota = notation->next;
 
-         if (notation->name)
-           free (notation->name);
-         if (notation->value)
-           free (notation->value);
+         _gpgme_sig_notation_free (notation);
          notation = next_nota;
        }
 
@@ -68,6 +67,9 @@ release_op_data (void *hook)
       free (sig);
       sig = next;
     }
+
+  if (opd->result.file_name)
+    free (opd->result.file_name);
 }
 
 
@@ -92,7 +94,8 @@ static void
 calc_sig_summary (gpgme_signature_t sig)
 {
   unsigned long sum = 0;
-
+  
+  /* Calculate the red/green flag.  */
   if (sig->validity == GPGME_VALIDITY_FULL
       || sig->validity == GPGME_VALIDITY_ULTIMATE)
     {
@@ -110,7 +113,8 @@ calc_sig_summary (gpgme_signature_t sig)
     }
   else if (gpg_err_code (sig->status) == GPG_ERR_BAD_SIGNATURE)
     sum |= GPGME_SIGSUM_RED;
-  
+
+
   /* FIXME: handle the case when key and message are expired. */
   switch (gpg_err_code (sig->status))
     {
@@ -135,6 +139,23 @@ calc_sig_summary (gpgme_signature_t sig)
       break;
     }
   
+  /* Now look at the certain reason codes.  */
+  switch (gpg_err_code (sig->validity_reason))
+    {
+    case GPG_ERR_CRL_TOO_OLD:
+      if (sig->validity == GPGME_VALIDITY_UNKNOWN)
+        sum |= GPGME_SIGSUM_CRL_TOO_OLD;
+      break;
+        
+    case GPG_ERR_CERT_REVOKED:
+      sum |= GPGME_SIGSUM_KEY_REVOKED;
+      break;
+
+    default:
+      break;
+    }
+
+  /* Check other flags. */
   if (sig->wrong_key_usage)
     sum |= GPGME_SIGSUM_BAD_POLICY;
   
@@ -151,16 +172,29 @@ static gpgme_error_t
 prepare_new_sig (op_data_t opd)
 {
   gpgme_signature_t sig;
-  
-  sig = calloc (1, sizeof (*sig));
-  if (!sig)
-    return gpg_error_from_errno (errno);
-  if (!opd->result.signatures)
-    opd->result.signatures = sig;
-  if (opd->current_sig)
-    opd->current_sig->next = sig;
-  opd->current_sig = sig;
+
+  if (opd->only_newsig_seen && opd->current_sig)
+    {
+      /* We have only seen the NEWSIG status and nothing else - we
+         better skip this signature therefore and reuse it for the
+         next possible signature. */
+      sig = opd->current_sig;
+      memset (sig, 0, sizeof *sig);
+      assert (opd->result.signatures == sig);
+    }
+  else
+    {
+      sig = calloc (1, sizeof (*sig));
+      if (!sig)
+        return gpg_error_from_errno (errno);
+      if (!opd->result.signatures)
+        opd->result.signatures = sig;
+      if (opd->current_sig)
+        opd->current_sig->next = sig;
+      opd->current_sig = sig;
+    }
   opd->did_prepare_new_sig = 1;
+  opd->only_newsig_seen = 0;
   return 0;
 }
 
@@ -169,6 +203,7 @@ parse_new_sig (op_data_t opd, gpgme_status_code_t code, char *args)
 {
   gpgme_signature_t sig;
   char *end = strchr (args, ' ');
+  char *tail;
 
   if (end)
     {
@@ -209,40 +244,75 @@ parse_new_sig (op_data_t opd, gpgme_status_code_t code, char *args)
       sig->status = gpg_error (GPG_ERR_BAD_SIGNATURE);
       break;
 
+    case GPGME_STATUS_REVKEYSIG:
+      sig->status = gpg_error (GPG_ERR_CERT_REVOKED);
+      break;
+
     case GPGME_STATUS_ERRSIG:
-      if (end)
+      /* Parse the pubkey algo.  */
+      if (!end)
+       goto parse_err_sig_fail;
+      errno = 0;
+      sig->pubkey_algo = strtol (end, &tail, 0);
+      if (errno || end == tail || *tail != ' ')
+       goto parse_err_sig_fail;
+      end = tail;
+      while (*end == ' ')
+       end++;
+     
+      /* Parse the hash algo.  */
+      if (!*end)
+       goto parse_err_sig_fail;
+      errno = 0;
+      sig->hash_algo = strtol (end, &tail, 0);
+      if (errno || end == tail || *tail != ' ')
+       goto parse_err_sig_fail;
+      end = tail;
+      while (*end == ' ')
+       end++;
+
+      /* Skip the sig class.  */
+      end = strchr (end, ' ');
+      if (!end)
+       goto parse_err_sig_fail;
+      while (*end == ' ')
+       end++;
+
+      /* Parse the timestamp.  */
+      sig->timestamp = _gpgme_parse_timestamp (end, &tail);
+      if (sig->timestamp == -1 || end == tail || (*tail && *tail != ' '))
+       return gpg_error (GPG_ERR_INV_ENGINE);
+      end = tail;
+      while (*end == ' ')
+       end++;
+      
+      /* Parse the return code.  */
+      if (end[0] && (!end[1] || end[1] == ' '))
        {
-         int i = 0;
-         /* The return code is the 6th argument, if it is 9, the
-            problem is a missing key.  */
-         while (end && i < 4)
+         switch (end[0])
            {
-             end = strchr (end, ' ');
-             if (end)
-               end++;
-             i++;
-           }
-         if (end && end[0] && (!end[1] || end[1] == ' '))
-           {
-             switch (end[0])
-               {
-               case '4':
-                 sig->status = gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
-                 break;
-                 
-               case '9':
-                 sig->status = gpg_error (GPG_ERR_NO_PUBKEY);
-                 break;
-                 
-               default:
-                 sig->status = gpg_error (GPG_ERR_GENERAL);
-               }
+           case '4':
+             sig->status = gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
+             break;
+             
+           case '9':
+             sig->status = gpg_error (GPG_ERR_NO_PUBKEY);
+             break;
+             
+           default:
+             sig->status = gpg_error (GPG_ERR_GENERAL);
            }
        }
       else
-       sig->status = gpg_error (GPG_ERR_GENERAL);
-      break;
+       goto parse_err_sig_fail;
 
+      goto parse_err_sig_ok;
+      
+    parse_err_sig_fail:
+      sig->status = gpg_error (GPG_ERR_GENERAL);
+    parse_err_sig_ok:
+      break;
+      
     default:
       return gpg_error (GPG_ERR_GENERAL);
     }
@@ -261,7 +331,6 @@ static gpgme_error_t
 parse_valid_sig (gpgme_signature_t sig, char *args)
 {
   char *end = strchr (args, ' ');
-
   if (end)
     {
       *end = '\0';
@@ -278,6 +347,7 @@ parse_valid_sig (gpgme_signature_t sig, char *args)
   if (!sig->fpr)
     return gpg_error_from_errno (errno);
 
+  /* Skip the creation date.  */
   end = strchr (end, ' ');
   if (end)
     {
@@ -291,6 +361,43 @@ parse_valid_sig (gpgme_signature_t sig, char *args)
       sig->exp_timestamp = _gpgme_parse_timestamp (end, &tail);
       if (sig->exp_timestamp == -1 || end == tail || (*tail && *tail != ' '))
        return gpg_error (GPG_ERR_INV_ENGINE);
+      end = tail;
+
+      while (*end == ' ')
+       end++;
+      /* Skip the signature version.  */
+      end = strchr (end, ' ');
+      if (end)
+       {
+         while (*end == ' ')
+           end++;
+
+         /* Skip the reserved field.  */
+         end = strchr (end, ' ');
+         if (end)
+           {
+             /* Parse the pubkey algo.  */
+             errno = 0;
+             sig->pubkey_algo = strtol (end, &tail, 0);
+             if (errno || end == tail || *tail != ' ')
+               return gpg_error (GPG_ERR_INV_ENGINE);
+             end = tail;
+
+             while (*end == ' ')
+               end++;
+
+             if (*end)
+               {
+                 /* Parse the hash algo.  */
+
+                 errno = 0;
+                 sig->hash_algo = strtol (end, &tail, 0);
+                 if (errno || end == tail || *tail != ' ')
+                   return gpg_error (GPG_ERR_INV_ENGINE);
+                 end = tail;
+               }
+           }
+       }
     }
   return 0;
 }
@@ -321,51 +428,39 @@ parse_notation (gpgme_signature_t sig, gpgme_status_code_t code, char *args)
           previous one.  The crypto backend misbehaves.  */
        return gpg_error (GPG_ERR_INV_ENGINE);
 
-      notation = malloc (sizeof (*sig));
-      if (!notation)
-       return gpg_error_from_errno (errno);
-      notation->next = NULL;
+      err = _gpgme_sig_notation_create (&notation, NULL, 0, NULL, 0, 0);
+      if (err)
+       return err;
 
       if (code == GPGME_STATUS_NOTATION_NAME)
        {
-         int len = strlen (args) + 1;
-
-         notation->name = malloc (len);
-         if (!notation->name)
-           {
-             int saved_errno = errno;
-             free (notation);
-             return gpg_error_from_errno (saved_errno);
-           }
-         err = _gpgme_decode_percent_string (args, &notation->name, len);
+         err = _gpgme_decode_percent_string (args, &notation->name, 0);
          if (err)
            {
-             free (notation->name);
-             free (notation);
+             _gpgme_sig_notation_free (notation);
              return err;
            }
 
-         notation->value = NULL;
+         notation->name_len = strlen (notation->name);
+
+         /* FIXME: For now we fake the human-readable flag.  The
+            critical flag can not be reported as it is not
+            provided.  */
+         notation->flags = GPGME_SIG_NOTATION_HUMAN_READABLE;
+         notation->human_readable = 1;
        }
       else
        {
-         int len = strlen (args) + 1;
+         /* This is a policy URL.  */
 
-         notation->name = NULL;
-         notation->value = malloc (len);
-         if (!notation->value)
-           {
-             int saved_errno = errno;
-             free (notation);
-             return gpg_error_from_errno (saved_errno);
-           }
-         err = _gpgme_decode_percent_string (args, &notation->value, len);
+         err = _gpgme_decode_percent_string (args, &notation->value, 0);
          if (err)
            {
-             free (notation->value);
-             free (notation);
+             _gpgme_sig_notation_free (notation);
              return err;
            }
+
+         notation->value_len = strlen (notation->value);
        }
       *lastp = notation;
     }
@@ -405,6 +500,8 @@ parse_notation (gpgme_signature_t sig, gpgme_status_code_t code, char *args)
       err = _gpgme_decode_percent_string (args, &dest, len);
       if (err)
        return err;
+
+      notation->value_len += strlen (dest);
     }
   else
     return gpg_error (GPG_ERR_INV_ENGINE);
@@ -443,6 +540,8 @@ parse_trust (gpgme_signature_t sig, gpgme_status_code_t code, char *args)
 
   if (*args)
     sig->validity_reason = _gpgme_map_gnupg_error (args);
+  else
+    sig->validity_reason = 0;
 
   return 0;
 }
@@ -454,7 +553,6 @@ parse_error (gpgme_signature_t sig, char *args)
   gpgme_error_t err;
   char *where = strchr (args, ' ');
   char *which;
-  char *where_last;
 
   if (where)
     {
@@ -470,16 +568,11 @@ parse_error (gpgme_signature_t sig, char *args)
   else
     return gpg_error (GPG_ERR_INV_ENGINE);
 
-  /* It is often useful to compare only the last part of the where token. */
-  where_last = strrchr (where, '.');
-  if (!where_last)
-    where_last = where;
-
   err = _gpgme_map_gnupg_error (which);
 
-  if (!strcmp (where_last, ".findkey"))
+  if (!strcmp (where, "verify.findkey"))
     sig->status = err;
-  else if (!strcmp (where_last, ".keyusage")
+  else if (!strcmp (where, "verify.keyusage")
           && gpg_err_code (err) == GPG_ERR_WRONG_KEY_USAGE)
     sig->wrong_key_usage = 1;
 
@@ -508,28 +601,35 @@ _gpgme_verify_status_handler (void *priv, gpgme_status_code_t code, char *args)
     case GPGME_STATUS_NEWSIG:
       if (sig)
         calc_sig_summary (sig);
-      return prepare_new_sig (opd);
+      err = prepare_new_sig (opd);
+      opd->only_newsig_seen = 1;
+      return err;
 
     case GPGME_STATUS_GOODSIG:
     case GPGME_STATUS_EXPSIG:
     case GPGME_STATUS_EXPKEYSIG:
     case GPGME_STATUS_BADSIG:
     case GPGME_STATUS_ERRSIG:
+    case GPGME_STATUS_REVKEYSIG:
       if (sig && !opd->did_prepare_new_sig)
        calc_sig_summary (sig);
+      opd->only_newsig_seen = 0;
       return parse_new_sig (opd, code, args);
 
     case GPGME_STATUS_VALIDSIG:
+      opd->only_newsig_seen = 0;
       return sig ? parse_valid_sig (sig, args)
        : gpg_error (GPG_ERR_INV_ENGINE);
 
     case GPGME_STATUS_NODATA:
+      opd->only_newsig_seen = 0;
       if (!sig)
        return gpg_error (GPG_ERR_NO_DATA);
       sig->status = gpg_error (GPG_ERR_NO_DATA);
       break;
 
     case GPGME_STATUS_UNEXPECTED:
+      opd->only_newsig_seen = 0;
       if (!sig)
        return gpg_error (GPG_ERR_GENERAL);
       sig->status = gpg_error (GPG_ERR_NO_DATA);
@@ -538,6 +638,7 @@ _gpgme_verify_status_handler (void *priv, gpgme_status_code_t code, char *args)
     case GPGME_STATUS_NOTATION_NAME:
     case GPGME_STATUS_NOTATION_DATA:
     case GPGME_STATUS_POLICY_URL:
+      opd->only_newsig_seen = 0;
       return sig ? parse_notation (sig, code, args)
        : gpg_error (GPG_ERR_INV_ENGINE);
 
@@ -546,17 +647,49 @@ _gpgme_verify_status_handler (void *priv, gpgme_status_code_t code, char *args)
     case GPGME_STATUS_TRUST_MARGINAL:
     case GPGME_STATUS_TRUST_FULLY:
     case GPGME_STATUS_TRUST_ULTIMATE:
+      opd->only_newsig_seen = 0;
       return sig ? parse_trust (sig, code, args)
        : gpg_error (GPG_ERR_INV_ENGINE);
 
     case GPGME_STATUS_ERROR:
-      return sig ? parse_error (sig, args) : gpg_error (GPG_ERR_INV_ENGINE);
+      opd->only_newsig_seen = 0;
+      /* The error status is informational, so we don't return an
+         error code if we are not ready to process this status. */
+      return sig ? parse_error (sig, args) : 0;
 
     case GPGME_STATUS_EOF:
       if (sig && !opd->did_prepare_new_sig)
        calc_sig_summary (sig);
+      if (opd->only_newsig_seen && sig)
+        {
+          gpgme_signature_t sig2;
+          /* The last signature has no valid information - remove it
+             from the list. */
+          assert (!sig->next);
+          if (sig == opd->result.signatures)
+            opd->result.signatures = NULL;
+          else
+            {
+              for (sig2 = opd->result.signatures; sig2; sig2 = sig2->next)
+                if (sig2->next == sig)
+                  {
+                    sig2->next = NULL;
+                    break;
+                  }
+            }
+          /* Note that there is no need to release the members of SIG
+             because we won't be here if they have been set. */
+          free (sig);
+          opd->current_sig = NULL;
+        }
+      opd->only_newsig_seen = 0;
       break;
 
+    case GPGME_STATUS_PLAINTEXT:
+      err = _gpgme_parse_plaintext (args, &opd->result.file_name);
+      if (err)
+       return err;
+
     default:
       break;
     }