[gentoo-commits] gentoo-x86 commit in mail-client/mutt/files: mutt-1.5.19-mutt_ssl-3af7e8af1983-dc9ec900c657.patch mutt-1.5.19-mutt-gnutls-7d0583e0315d-0b13183e40e0.patch

[Fabian Groffen (grobian)]

grobian     09/06/18 09:20:37

  Added:               
                        mutt-1.5.19-mutt_ssl-3af7e8af1983-dc9ec900c657.patch
                        mutt-1.5.19-mutt-gnutls-7d0583e0315d-0b13183e40e0.patch
  Log:
  Revision bump for CVE-2009-1390, add related patches
  (Portage version: 2.1.6.13/cvs/Linux x86_64)

Revision  Changes    Path
1.1                  mail-client/mutt/files/mutt-1.5.19-mutt_ssl-3af7e8af1983-dc9ec900c657.patch

file : http://sources.gentoo.org/viewcvs.py/gentoo-x86/mail-client/mutt/files/mutt-1.5.19-mutt_ssl-3af7e8af1983-dc9ec900c657.patch?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo-x86/mail-client/mutt/files/mutt-1.5.19-mutt_ssl-3af7e8af1983-dc9ec900c657.patch?rev=1.1&content-type=text/plain

Index: mutt-1.5.19-mutt_ssl-3af7e8af1983-dc9ec900c657.patch
===================================================================
http://thread.gmane.org/gmane.comp.security.oss.general/1847
http://bugs.gentoo.org/show_bug.cgi?id=274488

whitespace-only hunks removed

Index: mutt_ssl.c
===================================================================
--- mutt_ssl.c (revision 5622:3af7e8af1983)
+++ mutt_ssl.c (revision 5870:dc9ec900c657)
@@ -565,17 +565,20 @@
 
   /* expiration check */
-  if (X509_cmp_current_time (X509_get_notBefore (peercert)) >= 0)
-  {
-    dprint (2, (debugfile, "Server certificate is not yet valid\n"));
-    mutt_error (_("Server certificate is not yet valid"));
-    mutt_sleep (2);
-    return 0;
-  }
-  if (X509_cmp_current_time (X509_get_notAfter (peercert)) <= 0)
-  {
-    dprint (2, (debugfile, "Server certificate has expired"));
-    mutt_error (_("Server certificate has expired"));
-    mutt_sleep (2);
-    return 0;
+  if (option (OPTSSLVERIFYDATES) != M_NO)
+  {
+    if (X509_cmp_current_time (X509_get_notBefore (peercert)) >= 0)
+    {
+      dprint (2, (debugfile, "Server certificate is not yet valid\n"));
+      mutt_error (_("Server certificate is not yet valid"));
+      mutt_sleep (2);
+      return 0;
+    }
+    if (X509_cmp_current_time (X509_get_notAfter (peercert)) <= 0)
+    {
+      dprint (2, (debugfile, "Server certificate has expired"));
+      mutt_error (_("Server certificate has expired"));
+      mutt_sleep (2);
+      return 0;
+    }
   }
 
@@ -585,5 +588,5 @@
   if (!X509_digest (peercert, EVP_sha1(), peermd, &peermdlen))
   {
-    fclose (fp);
+    safe_fclose (&fp);
     return 0;
   }
@@ -592,10 +595,10 @@
   {
     pass = compare_certificates (cert, peercert, peermd, peermdlen) ? 0 : 1;
-    
+
     if (pass)
       break;
   }
   X509_free (cert);
-  fclose (fp);
+  safe_fclose (&fp);
 
   return pass;
@@ -737,6 +740,8 @@
 }
 
-/* check whether cert is preauthorized */
-static int ssl_check_preauth (X509 *cert, CONNECTION *conn)
+/* check whether cert is preauthorized. If host is not null, verify that
+ * it matches the certificate.
+ * Return > 0: authorized, < 0: problems, 0: unknown validity */
+static int ssl_check_preauth (X509 *cert, const char* host)
 {
   char buf[SHORT_STRING];
@@ -750,11 +755,14 @@
 
   buf[0] = 0;
-  if (!check_host (cert, conn->account.host, buf, sizeof (buf)))
-  {
-    mutt_error (_("Certificate host check failed: %s"), buf);
-    mutt_sleep (2);
-    return -1;
-  }
-  dprint (2, (debugfile, "ssl_check_preauth: hostname check passed\n"));
+  if (host && option (OPTSSLVERIFYHOST) != M_NO)
+  {
+    if (!check_host (cert, host, buf, sizeof (buf)))
+    {
+      mutt_error (_("Certificate host check failed: %s"), buf);
+      mutt_sleep (2);
+      return -1;
+    }
+    dprint (2, (debugfile, "ssl_check_preauth: hostname check passed\n"));
+  }
 
   if (check_certificate_by_signer (cert))
@@ -780,42 +788,28 @@
   X509 *cert;
 
-  if ((preauthrc = ssl_check_preauth (data->cert, conn)) > 0)
+  if ((preauthrc = ssl_check_preauth (data->cert, conn->account.host)) > 0)
     return preauthrc;
 
   chain = SSL_get_peer_cert_chain (data->ssl);
   chain_len = sk_X509_num (chain);
-  if (!chain || (chain_len < 1))
+  /* negative preauthrc means the certificate won't be accepted without
+   * manual override. */
+  if (preauthrc < 0 || !chain || (chain_len <= 1))
     return interactive_check_cert (data->cert, 0, 0);
 
-  /* check the chain from root to peer */
+  /* check the chain from root to peer. */
   for (i = chain_len-1; i >= 0; i--)
   {
     cert = sk_X509_value (chain, i);
-    if (check_certificate_cache (cert))
-      dprint (2, (debugfile, "ssl chain: already cached: %s\n", cert->name));
-    else if (i /* 0 is the peer */ || !preauthrc)
-    {
-      if (check_certificate_by_signer (cert))
-      {
-	dprint (2, (debugfile, "ssl chain: checked by signer: %s\n", cert->name));
-	ssl_cache_trusted_cert (cert);
+
+    /* if the certificate validates or is manually accepted, then add it to
+     * the trusted set and recheck the peer certificate */
+    if (ssl_check_preauth (cert, NULL)
+	|| interactive_check_cert (cert, i, chain_len))
+    {
+      ssl_cache_trusted_cert (cert);
+      if (ssl_check_preauth (data->cert, conn->account.host))
 	return 1;
-      }
-      else if (SslCertFile && check_certificate_by_digest (cert))
-      {
-	dprint (2, (debugfile, "ssl chain: trusted with file: %s\n", cert->name));
-	ssl_cache_trusted_cert (cert);
-	return 1;
-      }
-      else /* allow users to shoot their foot */
-      {
-	dprint (2, (debugfile, "ssl chain: check failed: %s\n", cert->name));
-	if (interactive_check_cert (cert, i, chain_len))
-	  return 1;
-      }
-    }
-    else /* highly suspicious because (i==0 && preauthrc < 0) */
-      if (interactive_check_cert (cert, i, chain_len))
-	return 1;
+    }
   }
 
@@ -882,6 +876,8 @@
 	    len - idx, len);
   menu->title = title;
-  if (SslCertFile && X509_cmp_current_time (X509_get_notAfter (cert)) >= 0
-      && X509_cmp_current_time (X509_get_notBefore (cert)) < 0)
+  if (SslCertFile
+      && (option (OPTSSLVERIFYDATES) == M_NO
+	  || (X509_cmp_current_time (X509_get_notAfter (cert)) >= 0
+	      && X509_cmp_current_time (X509_get_notBefore (cert)) < 0)))
   {
     menu->prompt = _("(r)eject, accept (o)nce, (a)ccept always");
@@ -893,5 +889,5 @@
     menu->keys = _("ro");
   }
-  
+
   helpstr[0] = '\0';
   mutt_make_help (buf, sizeof (buf), _("Exit  "), MENU_GENERIC, OP_EXIT);
@@ -918,5 +914,5 @@
 	  if (PEM_write_X509 (fp, cert))
 	    done = 1;
-	  fclose (fp);
+	  safe_fclose (&fp);
 	}
 	if (!done)



1.1                  mail-client/mutt/files/mutt-1.5.19-mutt-gnutls-7d0583e0315d-0b13183e40e0.patch

file : http://sources.gentoo.org/viewcvs.py/gentoo-x86/mail-client/mutt/files/mutt-1.5.19-mutt-gnutls-7d0583e0315d-0b13183e40e0.patch?rev=1.1&view=markup
plain: http://sources.gentoo.org/viewcvs.py/gentoo-x86/mail-client/mutt/files/mutt-1.5.19-mutt-gnutls-7d0583e0315d-0b13183e40e0.patch?rev=1.1&content-type=text/plain

Index: mutt-1.5.19-mutt-gnutls-7d0583e0315d-0b13183e40e0.patch
===================================================================
http://thread.gmane.org/gmane.comp.security.oss.general/1847
http://bugs.gentoo.org/show_bug.cgi?id=274488

whitespace-only hunks removed

Index: mutt_ssl_gnutls.c
===================================================================
--- mutt_ssl_gnutls.c (revision 5623:7d0583e0315d)
+++ mutt_ssl_gnutls.c (revision 5853:0b13183e40e0)
@@ -34,4 +34,13 @@
 #include "mutt_regex.h"
 
+/* certificate error bitmap values */
+#define CERTERR_VALID       0
+#define CERTERR_EXPIRED     1
+#define CERTERR_NOTYETVALID 2
+#define CERTERR_REVOKED     4
+#define CERTERR_NOTTRUSTED  8
+#define CERTERR_HOSTNAME    16
+#define CERTERR_SIGNERNOTCA 32
+
 typedef struct _tlssockdata
 {
@@ -409,5 +418,5 @@
 
   b64_data.size = fread(b64_data.data, 1, b64_data.size, fd1);
-  fclose(fd1);
+  safe_fclose (&fd1);
 
   do {
@@ -505,5 +514,5 @@
     buf[0] = '\0';
     tls_fingerprint (GNUTLS_DIG_MD5, buf, sizeof (buf), cert);
-    while ((linestr = mutt_read_line(linestr, &linestrsize, fp, &linenum)) != NULL)
+    while ((linestr = mutt_read_line(linestr, &linestrsize, fp, &linenum, 0)) != NULL)
     {
       if(linestr[0] == '#' && linestr[1] == 'H')
@@ -518,5 +527,5 @@
             regfree(&preg);
             FREE(&linestr);
-            fclose(fp);
+            safe_fclose (&fp);
             return 1;
           }
@@ -526,9 +535,113 @@
 
     regfree(&preg);
-    fclose(fp);
+    safe_fclose (&fp);
   }
 
   /* not found a matching name */
   return 0;
+}
+
+static int tls_check_preauth (const gnutls_datum_t *certdata,
+                              gnutls_certificate_status certstat,
+                              const char *hostname, int chainidx, int* certerr,
+                              int* savedcert)
+{
+  gnutls_x509_crt cert;
+
+  *certerr = CERTERR_VALID;
+  *savedcert = 0;
+
+  if (gnutls_x509_crt_init (&cert) < 0)
+  {
+    mutt_error (_("Error initialising gnutls certificate data"));
+    mutt_sleep (2);
+    return -1;
+  }
+
+  if (gnutls_x509_crt_import (cert, certdata, GNUTLS_X509_FMT_DER) < 0)
+  {
+    mutt_error (_("Error processing certificate data"));
+    mutt_sleep (2);
+    gnutls_x509_crt_deinit (cert);
+    return -1;
+  }
+
+  if (option (OPTSSLVERIFYDATES) != M_NO)
+  {
+    if (gnutls_x509_crt_get_expiration_time (cert) < time(NULL))
+      *certerr |= CERTERR_EXPIRED;
+    if (gnutls_x509_crt_get_activation_time (cert) > time(NULL))
+      *certerr |= CERTERR_NOTYETVALID;
+  }
+
+  if (chainidx == 0 && option (OPTSSLVERIFYHOST) != M_NO
+      && !gnutls_x509_crt_check_hostname (cert, hostname)
+      && !tls_check_stored_hostname (certdata, hostname))
+    *certerr |= CERTERR_HOSTNAME;
+
+  /* see whether certificate is in our cache (certificates file) */
+  if (tls_compare_certificates (certdata))
+  {
+    *savedcert = 1;
+
+    if (chainidx == 0 && certstat & GNUTLS_CERT_INVALID)
+    {
+      /* doesn't matter - have decided is valid because server
+       certificate is in our trusted cache */
+      certstat ^= GNUTLS_CERT_INVALID;
+    }
+
+    if (chainidx == 0 && certstat & GNUTLS_CERT_SIGNER_NOT_FOUND)
+    {
+      /* doesn't matter that we haven't found the signer, since
+       certificate is in our trusted cache */
+      certstat ^= GNUTLS_CERT_SIGNER_NOT_FOUND;
+    }
+
+    if (chainidx <= 1 && certstat & GNUTLS_CERT_SIGNER_NOT_CA)
+    {
+      /* Hmm. Not really sure how to handle this, but let's say
+       that we don't care if the CA certificate hasn't got the
+       correct X.509 basic constraints if server or first signer
+       certificate is in our cache. */
+      certstat ^= GNUTLS_CERT_SIGNER_NOT_CA;
+    }
+  }
+
+  if (certstat & GNUTLS_CERT_REVOKED)
+  {
+    *certerr |= CERTERR_REVOKED;
+    certstat ^= GNUTLS_CERT_REVOKED;
+  }
+
+  if (certstat & GNUTLS_CERT_INVALID)
+  {
+    *certerr |= CERTERR_NOTTRUSTED;
+    certstat ^= GNUTLS_CERT_INVALID;
+  }
+
+  if (certstat & GNUTLS_CERT_SIGNER_NOT_FOUND)
+  {
+    /* NB: already cleared if cert in cache */
+    *certerr |= CERTERR_NOTTRUSTED;
+    certstat ^= GNUTLS_CERT_SIGNER_NOT_FOUND;
+  }
+
+  if (certstat & GNUTLS_CERT_SIGNER_NOT_CA)
+  {
+    /* NB: already cleared if cert in cache */
+    *certerr |= CERTERR_SIGNERNOTCA;
+    certstat ^= GNUTLS_CERT_SIGNER_NOT_CA;
+  }
+
+  gnutls_x509_crt_deinit (cert);
+
+  /* we've been zeroing the interesting bits in certstat -
+   don't return OK if there are any unhandled bits we don't
+   understand */
+  if (*certerr == CERTERR_VALID && certstat == 0)
+    return 0;
+
+  return -1;
 }
 
@@ -537,11 +650,6 @@
                                       const char* hostname, int idx, int len)
 {
+  int certerr, savedcert;
   gnutls_x509_crt cert;
-  int certerr_hostname = 0;
-  int certerr_expired = 0;
-  int certerr_notyetvalid = 0;
-  int certerr_nottrusted = 0;
-  int certerr_revoked = 0;
-  int certerr_signernotca = 0;
   char buf[SHORT_STRING];
   char fpbuf[SHORT_STRING];
@@ -563,4 +671,9 @@
   int i, row, done, ret;
 
+  if (!tls_check_preauth (certdata, certstat, hostname, idx, &certerr,
+      &savedcert))
+    return 1;
+
+  /* interactive check from user */
   if (gnutls_x509_crt_init (&cert) < 0)
   {
@@ -569,5 +682,5 @@
     return 0;
   }
-  
+
   if (gnutls_x509_crt_import (cert, certdata, GNUTLS_X509_FMT_DER) < 0)
   {
@@ -577,82 +690,5 @@
     return -1;
   }
-  
-  if (gnutls_x509_crt_get_expiration_time (cert) < time(NULL))
-    certerr_expired = 1;
-  if (gnutls_x509_crt_get_activation_time (cert) > time(NULL))
-    certerr_notyetvalid = 1;
-
-  if (!idx)
-  {
-    if (!gnutls_x509_crt_check_hostname (cert, hostname) &&
-        !tls_check_stored_hostname (certdata, hostname))
-      certerr_hostname = 1;
-  }
-  
-  /* see whether certificate is in our cache (certificates file) */
-  if (tls_compare_certificates (certdata))
-  {
-    if (certstat & GNUTLS_CERT_INVALID)
-    {
-      /* doesn't matter - have decided is valid because server
-       certificate is in our trusted cache */
-      certstat ^= GNUTLS_CERT_INVALID;
-    }
-    
-    if (certstat & GNUTLS_CERT_SIGNER_NOT_FOUND)
-    {
-      /* doesn't matter that we haven't found the signer, since
-       certificate is in our trusted cache */
-      certstat ^= GNUTLS_CERT_SIGNER_NOT_FOUND;
-    }
-    
-    if (certstat & GNUTLS_CERT_SIGNER_NOT_CA)
-    {
-      /* Hmm. Not really sure how to handle this, but let's say
-       that we don't care if the CA certificate hasn't got the
-       correct X.509 basic constraints if server certificate is
-       in our cache. */
-      certstat ^= GNUTLS_CERT_SIGNER_NOT_CA;
-    }
-  }
-
-  if (certstat & GNUTLS_CERT_REVOKED)
-  {
-    certerr_revoked = 1;
-    certstat ^= GNUTLS_CERT_REVOKED;
-  }
-  
-  if (certstat & GNUTLS_CERT_INVALID)
-  {
-    certerr_nottrusted = 1;
-    certstat ^= GNUTLS_CERT_INVALID;
-  }
-  
-  if (certstat & GNUTLS_CERT_SIGNER_NOT_FOUND)
-  {
-    /* NB: already cleared if cert in cache */
-    certerr_nottrusted = 1;
-    certstat ^= GNUTLS_CERT_SIGNER_NOT_FOUND;
-  }
-  
-  if (certstat & GNUTLS_CERT_SIGNER_NOT_CA)
-  {
-    /* NB: already cleared if cert in cache */
-    certerr_signernotca = 1;
-    certstat ^= GNUTLS_CERT_SIGNER_NOT_CA;
-  }
-
-  /* OK if signed by (or is) a trusted certificate */
-  /* we've been zeroing the interesting bits in certstat - 
-   don't return OK if there are any unhandled bits we don't
-   understand */
-  if (!(certerr_expired || certerr_notyetvalid || 
-	certerr_hostname || certerr_nottrusted) && certstat == 0)
-  {
-    gnutls_x509_crt_deinit (cert);
-    return 1;
-  }
-
-  /* interactive check from user */
+
   menu = mutt_new_menu (-1);
   menu->max = 25;
@@ -756,26 +792,26 @@
   tls_fingerprint (GNUTLS_DIG_MD5, fpbuf, sizeof (fpbuf), certdata);
   snprintf (menu->dialog[row++], SHORT_STRING, _("MD5 Fingerprint: %s"), fpbuf);
-  
-  if (certerr_notyetvalid)
+
+  if (certerr & CERTERR_NOTYETVALID)
   {
     row++;
     strfcpy (menu->dialog[row], _("WARNING: Server certificate is not yet valid"), SHORT_STRING);
   }
-  if (certerr_expired)
+  if (certerr & CERTERR_EXPIRED)
   {
     row++;
     strfcpy (menu->dialog[row], _("WARNING: Server certificate has expired"), SHORT_STRING);
   }
-  if (certerr_revoked)
+  if (certerr & CERTERR_REVOKED)
   {
     row++;
     strfcpy (menu->dialog[row], _("WARNING: Server certificate has been revoked"), SHORT_STRING);
   }
-  if (certerr_hostname)
+  if (certerr & CERTERR_HOSTNAME)
   {
     row++;
     strfcpy (menu->dialog[row], _("WARNING: Server hostname does not match certificate"), SHORT_STRING);
   }
-  if (certerr_signernotca)
+  if (certerr & CERTERR_SIGNERNOTCA)
   {
     row++;
@@ -789,5 +825,7 @@
   /* certificates with bad dates, or that are revoked, must be
    accepted manually each and every time */
-  if (SslCertFile && !certerr_expired && !certerr_notyetvalid && !certerr_revoked)
+  if (SslCertFile && !savedcert
+        && !(certerr & (CERTERR_EXPIRED | CERTERR_NOTYETVALID
+                        | CERTERR_REVOKED)))
   {
     menu->prompt = _("(r)eject, accept (o)nce, (a)ccept always");
@@ -823,10 +861,10 @@
 	{
 	  /* save hostname if necessary */
-	  if (certerr_hostname)
+	  if (certerr & CERTERR_HOSTNAME)
 	  {
 	    fprintf(fp, "#H %s %s\n", hostname, fpbuf);
 	    done = 1;
 	  }
-	  if (certerr_nottrusted)
+	  if (certerr & CERTERR_NOTTRUSTED)
 	  {
             done = 0;
@@ -842,5 +880,5 @@
 	    }
 	  }
-	  fclose (fp);
+	  safe_fclose (&fp);
 	}
 	if (!done)
@@ -867,4 +905,38 @@
 }
 
+/* sanity-checking wrapper for gnutls_certificate_verify_peers */
+static gnutls_certificate_status tls_verify_peers (gnutls_session tlsstate)
+{
+  gnutls_certificate_status certstat;
+
+  certstat = gnutls_certificate_verify_peers (tlsstate);
+  if (!certstat)
+    return certstat;
+
+  if (certstat == GNUTLS_E_NO_CERTIFICATE_FOUND)
+  {
+    mutt_error (_("Unable to get certificate from peer"));
+    mutt_sleep (2);
+    return 0;
+  }
+  if (certstat < 0)
+  {
+    mutt_error (_("Certificate verification error (%s)"),
+                gnutls_strerror (certstat));
+    mutt_sleep (2);
+    return 0;
+  }
+
+  /* We only support X.509 certificates (not OpenPGP) at the moment */
+  if (gnutls_certificate_type_get (tlsstate) != GNUTLS_CRT_X509)
+  {
+    mutt_error (_("Certificate is not X.509"));
+    mutt_sleep (2);
+    return 0;
+  }
+
+  return certstat;
+}
+
 static int tls_check_certificate (CONNECTION* conn)
 {
@@ -874,5 +946,5 @@
   unsigned int cert_list_size = 0;
   gnutls_certificate_status certstat;
-  int i, rc;
+  int certerr, i, preauthrc, savedcert, rc = 0;
 
   if (gnutls_auth_get_type (state) != GNUTLS_CRD_CERTIFICATE)
@@ -883,27 +955,5 @@
   }
 
-  certstat = gnutls_certificate_verify_peers (state);
-
-  if (certstat == GNUTLS_E_NO_CERTIFICATE_FOUND)
-  {
-    mutt_error (_("Unable to get certificate from peer"));
-    mutt_sleep (2);
-    return 0;
-  }
-  if (certstat < 0)
-  {
-    mutt_error (_("Certificate verification error (%s)"),
-                gnutls_strerror (certstat));
-    mutt_sleep (2);
-    return 0;
-  }
-
-  /* We only support X.509 certificates (not OpenPGP) at the moment */
-  if (gnutls_certificate_type_get (state) != GNUTLS_CRT_X509)
-  {
-    mutt_error (_("Certificate is not X.509"));
-    mutt_sleep (2);
-    return 0;
-  }
+  certstat = tls_verify_peers (state);
 
   cert_list = gnutls_certificate_get_peers (state, &cert_list_size);
@@ -915,12 +965,41 @@
   }
 
+  /* tls_verify_peers doesn't check hostname or expiration, so walk
+   * from most specific to least checking these. If we see a saved certificate,
+   * its status short-circuits the remaining checks. */
+  preauthrc = 0;
+  for (i = 0; i < cert_list_size; i++) {
+    rc = tls_check_preauth(&cert_list[i], certstat, conn->account.host, i,
+                           &certerr, &savedcert);
+    preauthrc += rc;
+
+    if (savedcert)
+    {
+      if (!preauthrc)
+        return 1;
+      else
+        break;
+    }
+  }
+
+  /* then check interactively, starting from chain root */
   for (i = cert_list_size - 1; i >= 0; i--)
   {
     rc = tls_check_one_certificate (&cert_list[i], certstat, conn->account.host,
                                     i, cert_list_size);
-    if (rc)
-      return rc;
-  }
-
-  return 0;
-}
+
+    /* add signers to trust set, then reverify */
+    if (i && rc) {
+      rc = gnutls_certificate_set_x509_trust_mem (data->xcred, &cert_list[i],
+                                                  GNUTLS_X509_FMT_DER);
+      if (rc != 1)
+        dprint (1, (debugfile, "error trusting certificate %d: %d\n", i, rc));
+
+      certstat = tls_verify_peers (state);
+      if (!certstat)
+        return 1;
+    }
+  }
+
+  return rc;
+}