2005-10-01 Marcus Brinkmann <marcus@g10code.de>
[gpgme.git] / gpgme / verify.c
index b92e753..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>
@@ -24,6 +25,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <assert.h>
 
 #include "gpgme.h"
 #include "util.h"
@@ -36,6 +38,8 @@ typedef struct
   struct _gpgme_op_verify_result result;
 
   gpgme_signature_t current_sig;
+  int did_prepare_new_sig;
+  int only_newsig_seen;
 } *op_data_t;
 
 
@@ -54,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;
        }
 
@@ -66,6 +67,9 @@ release_op_data (void *hook)
       free (sig);
       sig = next;
     }
+
+  if (opd->result.file_name)
+    free (opd->result.file_name);
 }
 
 
@@ -90,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)
     {
@@ -108,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))
     {
@@ -133,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;
   
@@ -146,10 +169,41 @@ calc_sig_summary (gpgme_signature_t sig)
   
 
 static gpgme_error_t
+prepare_new_sig (op_data_t opd)
+{
+  gpgme_signature_t 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;
+}
+
+static gpgme_error_t
 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)
     {
@@ -157,14 +211,19 @@ parse_new_sig (op_data_t opd, gpgme_status_code_t code, char *args)
       end++;
     }
 
-  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->did_prepare_new_sig)
+    {
+      gpg_error_t err;
+
+      err = prepare_new_sig (opd);
+      if (err)
+        return err;
+    }
+  assert (opd->did_prepare_new_sig);
+  opd->did_prepare_new_sig = 0;
+
+  assert (opd->current_sig);
+  sig = opd->current_sig;
 
   /* FIXME: We should set the source of the state.  */
   switch (code)
@@ -185,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)
-           {
-             end = strchr (end, ' ');
-             if (end)
-               end++;
-             i++;
-           }
-         if (end && end[0] && (!end[1] || end[1] == ' '))
+         switch (end[0])
            {
-             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);
     }
@@ -237,7 +331,6 @@ static gpgme_error_t
 parse_valid_sig (gpgme_signature_t sig, char *args)
 {
   char *end = strchr (args, ' ');
-
   if (end)
     {
       *end = '\0';
@@ -254,21 +347,57 @@ 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)
     {
       char *tail;
-      errno = 0;
 
-      /* FIXME: We need to cope with ISO time strings here. */
-      sig->timestamp = strtol (end, &tail, 0);
-      if (errno || end == tail || (*tail && *tail != ' '))
+      sig->timestamp = _gpgme_parse_timestamp (end, &tail);
+      if (sig->timestamp == -1 || end == tail || (*tail && *tail != ' '))
        return gpg_error (GPG_ERR_INV_ENGINE);
       end = tail;
      
-      sig->exp_timestamp = strtol (end, &tail, 0);
-      if (errno || end == tail || (*tail && *tail != ' '))
+      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;
 }
@@ -299,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;
     }
@@ -383,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);
@@ -421,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;
 }
@@ -477,26 +598,38 @@ _gpgme_verify_status_handler (void *priv, gpgme_status_code_t code, char *args)
 
   switch (code)
     {
+    case GPGME_STATUS_NEWSIG:
+      if (sig)
+        calc_sig_summary (sig);
+      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:
-      if (sig)
+    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);
@@ -505,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);
 
@@ -513,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)
+      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;
     }