g10: Fix another race condition for trustdb access.
[gnupg.git] / g10 / passphrase.c
index 9f1218b..b1d1a05 100644 (file)
@@ -1,6 +1,6 @@
 /* passphrase.c -  Get a passphrase
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- *               2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+ *               2005, 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -24,7 +24,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <assert.h>
 #include <errno.h>
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #include "util.h"
 #include "options.h"
 #include "ttyio.h"
-#include "cipher.h"
 #include "keydb.h"
 #include "main.h"
 #include "i18n.h"
 #include "status.h"
 #include "call-agent.h"
-
+#include "../common/shareddefs.h"
 
 static char *fd_passwd = NULL;
 static char *next_pw = NULL;
@@ -74,7 +72,7 @@ encode_s2k_iterations (int iterations)
           if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
             log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
           /* Default to 65536 which we used up to 2.0.13.  */
-          return 96; 
+          return 96;
         }
       else if (mycnt >= 65011712)
         return 255; /* Largest possible value.  */
@@ -87,7 +85,7 @@ encode_s2k_iterations (int iterations)
 
   if (iterations >= 65011712)
     return 255;
-  
+
   /* Need count to be in the range 16-31 */
   for (count=iterations>>6; count>=32; count>>=1)
     c++;
@@ -96,92 +94,29 @@ encode_s2k_iterations (int iterations)
 
   if (S2K_DECODE_COUNT(result) < iterations)
     result++;
-  
+
   return result;
 }
 
 
-
-/* Hash a passphrase using the supplied s2k. 
-   Always needs: dek->algo, s2k->mode, s2k->hash_algo.  */
-static void
-hash_passphrase ( DEK *dek, char *pw, STRING2KEY *s2k)
+int
+have_static_passphrase()
 {
-  gcry_md_hd_t md;
-  int pass, i;
-  int used = 0;
-  int pwlen = strlen(pw);
-
-  assert ( s2k->hash_algo );
-  dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
-  if ( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
-    BUG();
-
-  if (gcry_md_open (&md, s2k->hash_algo, 1))
-    BUG ();
-  for (pass=0; used < dek->keylen ; pass++ ) 
-    {
-      if ( pass ) 
-        {
-          gcry_md_reset (md);
-          for (i=0; i < pass; i++ ) /* Preset the hash context.  */
-            gcry_md_putc (md, 0 );
-       }
-
-      if ( s2k->mode == 1 || s2k->mode == 3 ) 
-        {
-          int len2 = pwlen + 8;
-          ulong count = len2;
-          
-          if ( s2k->mode == 3 )
-            {
-              count = S2K_DECODE_COUNT(s2k->count);
-              if ( count < len2 )
-                count = len2;
-           }
-
-          /* Fixme: To avoid DoS attacks by sending an sym-encrypted
-             packet with a very high S2K count, we should either cap
-             the iteration count or CPU seconds based timeout.  */
-
-          /* A little bit complicated because we need a ulong for count. */
-          while ( count > len2 )  /* maybe iterated+salted */
-            { 
-              gcry_md_write ( md, s2k->salt, 8 );
-              gcry_md_write ( md, pw, pwlen );
-              count -= len2;
-           }
-          if ( count < 8 )
-            gcry_md_write ( md, s2k->salt, count );
-          else
-            {
-              gcry_md_write ( md, s2k->salt, 8 );
-              count -= 8;
-              gcry_md_write ( md, pw, count );
-           }
-       }
-      else
-        gcry_md_write ( md, pw, pwlen );
-      gcry_md_final( md );
-
-      i = gcry_md_get_algo_dlen ( s2k->hash_algo );
-      if ( i > dek->keylen - used )
-        i = dek->keylen - used;
-
-      memcpy (dek->key+used, gcry_md_read (md, s2k->hash_algo), i);
-      used += i;
-    }
-  gcry_md_close(md);
+  return (!!fd_passwd
+          && (opt.batch || opt.pinentry_mode == PINENTRY_MODE_LOOPBACK));
 }
 
-
-
-int
-have_static_passphrase()
+/* Return a static passphrase.  The returned value is only valid as
+   long as no other passphrase related function is called.  NULL may
+   be returned if no passphrase has been set; better use
+   have_static_passphrase first.  */
+const char *
+get_static_passphrase (void)
 {
-  return !!fd_passwd && opt.batch;
+  return fd_passwd;
 }
 
+
 /****************
  * Set the passphrase to be used for the next query and only for the next
  * one.
@@ -231,7 +166,7 @@ read_passphrase_from_fd( int fd )
   int i, len;
   char *pw;
 
-  if ( !opt.batch 
+  if ( !opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
     { /* Not used but we have to do a dummy read, so that it won't end
          up at the begin of the message if the quite usual trick to
          prepend the passphtrase to the message is used. */
@@ -240,12 +175,12 @@ read_passphrase_from_fd( int fd )
       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
         ;
       *buf = 0;
-      return; 
+      return;
     }
 
-  for (pw = NULL, i = len = 100; ; i++ ) 
+  for (pw = NULL, i = len = 100; ; i++ )
     {
-      if (i >= len-1 ) 
+      if (i >= len-1 )
         {
           char *pw2 = pw;
           len += 100;
@@ -262,7 +197,7 @@ read_passphrase_from_fd( int fd )
         break;
     }
   pw[i] = 0;
-  if (!opt.batch)
+  if (!opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
     tty_printf("\b\b\b   \n" );
 
   xfree ( fd_passwd );
@@ -310,68 +245,56 @@ passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
   memset (fpr, 0, MAX_FINGERPRINT_LEN );
   if( keyid && get_pubkey( pk, keyid ) )
     {
-      if (pk)
-        free_public_key( pk );      
+      free_public_key (pk);
       pk = NULL; /* oops: no key for some reason */
     }
-  
+
   orig_codeset = i18n_switchto_utf8 ();
 
   if (custom_description)
     atext = native_to_utf8 (custom_description);
   else if ( !mode && pk && keyid )
-    { 
+    {
       char *uid;
       size_t uidlen;
-      const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
+      const char *algo_name = openpgp_pk_algo_name ( pk->pubkey_algo );
       const char *timestr;
       char *maink;
-      
+
       if ( !algo_name )
         algo_name = "?";
 
-#define KEYIDSTRING _(" (main key ID %s)")
-
-      maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
-      if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
+      if (keyid[2] && keyid[3]
+          && keyid[0] != keyid[2]
           && keyid[1] != keyid[3] )
-        sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
+        maink = xasprintf (_(" (main key ID %s)"), keystr (&keyid[2]));
       else
-        *maink = 0;
-      
-      uid = get_user_id ( keyid, &uidlen ); 
+        maink = xstrdup ("");
+
+      uid = get_user_id ( keyid, &uidlen );
       timestr = strtimestamp (pk->timestamp);
 
-#undef KEYIDSTRING
-
-#define PROMPTSTRING _("Please enter the passphrase to unlock the" \
-                      " secret key for the OpenPGP certificate:\n" \
-                      "\"%.*s\"\n" \
-                      "%u-bit %s key, ID %s,\n" \
-                       "created %s%s.\n" )
-
-      atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
-                        + uidlen + 15 + strlen(algo_name) + keystrlen()
-                        + strlen (timestr) + strlen (maink) );
-      sprintf (atext, PROMPTSTRING,
-               (int)uidlen, uid,
-               nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
-               maink  );
+      atext = xasprintf (_("Please enter the passphrase to unlock the"
+                           " secret key for the OpenPGP certificate:\n"
+                           "\"%.*s\"\n"
+                           "%u-bit %s key, ID %s,\n"
+                           "created %s%s.\n"),
+                         (int)uidlen, uid,
+                         nbits_from_pk (pk), algo_name, keystr(&keyid[0]),
+                         timestr, maink);
       xfree (uid);
       xfree (maink);
 
-#undef PROMPTSTRING
-
-      { 
+      {
         size_t dummy;
         fingerprint_from_pk( pk, fpr, &dummy );
         have_fpr = 1;
       }
-      
+
     }
   else
     atext = xstrdup ( _("Enter passphrase\n") );
-                
+
 
   if (!mode && cacheid)
     my_cacheid = cacheid;
@@ -387,7 +310,7 @@ passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
 
   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext,
                              repeat, check, &pw);
-  
+
   xfree (my_prompt);
   xfree (atext); atext = NULL;
 
@@ -396,14 +319,14 @@ passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
 
   if (!rc)
     ;
-  else if (gpg_err_code (rc) == GPG_ERR_CANCELED 
+  else if (gpg_err_code (rc) == GPG_ERR_CANCELED
             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
     {
       log_info (_("cancelled by user\n") );
       if (canceled)
         *canceled = 1;
     }
-  else 
+  else
     {
       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
       /* Due to limitations in the API of the upper layers they
@@ -412,15 +335,14 @@ passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
          definitely not happen and let it continue without requiring a
          passphrase.  Given that now all the upper layers handle a
          cancel correctly, we simply set the cancel flag now for all
-         errors from the agent.  */ 
+         errors from the agent.  */
       if (canceled)
         *canceled = 1;
 
       write_status_errcode ("get_passphrase", rc);
     }
 
-  if (pk)
-    free_public_key( pk );
+  free_public_key (pk);
   if (rc)
     {
       xfree (pw);
@@ -440,7 +362,7 @@ passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
   int rc;
 
   (void)algo;
-    
+
   if (!cacheid)
     {
       PKT_public_key *pk;
@@ -450,7 +372,7 @@ passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
       byte fpr[MAX_FINGERPRINT_LEN];
       char hexfprbuf[2*20+1];
       size_t dummy;
-      
+
       pk = xcalloc (1, sizeof *pk);
       if ( !keyid || get_pubkey( pk, keyid ) )
         {
@@ -472,13 +394,13 @@ passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
 }
 
 
-/* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
+/* Return a new DEK object using the string-to-key specifier S2K.  Use
    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
    selected to cancel the passphrase entry and if CANCELED is not
    NULL, sets it to true.
 
    MODE 0:  Allow cached passphrase
-        1:  Ignore cached passphrase 
+        1:  Ignore cached passphrase
         2:  Ditto, but create a new key
         3:  Allow cached passphrase; use the S2K salt as the cache ID
         4:  Ditto, but create a new key
@@ -486,7 +408,7 @@ passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
 DEK *
 passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
                        int cipher_algo, STRING2KEY *s2k, int mode,
-                       const char *tryagain_text, 
+                       const char *tryagain_text,
                        const char *custdesc, const char *custprompt,
                        int *canceled)
 {
@@ -499,11 +421,11 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
   if (!canceled)
     canceled = &dummy_canceled;
   *canceled = 0;
-  
+
   if ( !s2k )
     {
-      assert (mode != 3 && mode != 4);
-      /* This is used for the old rfc1991 mode 
+      log_assert (mode != 3 && mode != 4);
+      /* This is used for the old rfc1991 mode
        * Note: This must match the code in encode.c with opt.rfc1991 set */
       s2k = &help_s2k;
       s2k->mode = 0;
@@ -529,36 +451,15 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
 
   /* If we do not have a passphrase available in NEXT_PW and status
      information are request, we print them now. */
-  if ( !next_pw && is_status_enabled() ) 
+  if ( !next_pw && is_status_enabled() )
     {
       char buf[50];
-      
+
       if ( keyid )
         {
-          u32 used_kid[2];
-          char *us;
-          
-          if ( keyid[2] && keyid[3] ) 
-            {
-              used_kid[0] = keyid[2];
-              used_kid[1] = keyid[3];
-            }
-          else
-            {
-              used_kid[0] = keyid[0];
-              used_kid[1] = keyid[1];
-            }
-          
-          us = get_long_user_id_string ( keyid );
-          write_status_text ( STATUS_USERID_HINT, us );
-          xfree(us);
-          
-          snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
-                    (ulong)keyid[0], (ulong)keyid[1],
-                    (ulong)used_kid[0], (ulong)used_kid[1],
-                    pubkey_algo );
-          
-          write_status_text ( STATUS_NEED_PASSPHRASE, buf );
+          emit_status_need_passphrase (keyid,
+                                       keyid[2] && keyid[3]? keyid+2:NULL,
+                                       pubkey_algo);
        }
       else
         {
@@ -576,7 +477,7 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
     {
       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
       char *p;
-      
+
       p = get_user_id_native(keyid);
       tty_printf ("\n");
       tty_printf (_("You need a passphrase to unlock the secret key for\n"
@@ -585,8 +486,8 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
 
       if ( !get_pubkey( pk, keyid ) )
         {
-          const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
-          
+          const char *s = openpgp_pk_algo_name ( pk->pubkey_algo );
+
           tty_printf (_("%u-bit %s key, ID %s, created %s"),
                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
                       strtimestamp(pk->timestamp) );
@@ -606,23 +507,22 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
        }
 
       tty_printf("\n");
-      if (pk)
-        free_public_key( pk );
+      free_public_key (pk);
     }
 
-  if ( next_pw ) 
+  if ( next_pw )
     {
       /* Simply return the passphrase we already have in NEXT_PW. */
       pw = next_pw;
       next_pw = NULL;
     }
-  else if ( have_static_passphrase () ) 
+  else if ( have_static_passphrase () )
     {
       /* Return the passphrase we have stored in FD_PASSWD. */
       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
       strcpy ( pw, fd_passwd );
     }
-  else 
+  else
     {
       if ((mode == 3 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
        {
@@ -632,6 +532,14 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
          s2k_cacheid = s2k_cacheidbuf;
        }
 
+      if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
+        {
+          char buf[32];
+
+          snprintf (buf, sizeof (buf), "%u", 100);
+          write_status_text (STATUS_INQUIRE_MAXLEN, buf);
+        }
+
       /* Divert to the gpg-agent. */
       pw = passphrase_get (keyid, mode == 2, s2k_cacheid,
                            (mode == 2 || mode == 4)? opt.passphrase_repeat : 0,
@@ -643,7 +551,7 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
           return NULL;
         }
     }
-    
+
   if ( !pw || !*pw )
     write_status( STATUS_MISSING_PASSPHRASE );
 
@@ -655,7 +563,28 @@ passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
   if ( (!pw || !*pw) && (mode == 2 || mode == 4))
     dek->keylen = 0;
   else
-    hash_passphrase (dek, pw, s2k);
+    {
+      gpg_error_t err;
+
+      dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
+      if (!(dek->keylen > 0 && dek->keylen <= DIM(dek->key)))
+        BUG ();
+      err = gcry_kdf_derive (pw, strlen (pw),
+                             s2k->mode == 3? GCRY_KDF_ITERSALTED_S2K :
+                             s2k->mode == 1? GCRY_KDF_SALTED_S2K :
+                             /* */           GCRY_KDF_SIMPLE_S2K,
+                             s2k->hash_algo, s2k->salt, 8,
+                             S2K_DECODE_COUNT(s2k->count),
+                             dek->keylen, dek->key);
+      if (err)
+        {
+          log_error ("gcry_kdf_derive failed: %s", gpg_strerror (err));
+          xfree (pw);
+          xfree (dek);
+         write_status( STATUS_MISSING_PASSPHRASE );
+          return NULL;
+        }
+    }
   if (s2k_cacheid)
     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
   xfree(last_pw);
@@ -675,9 +604,33 @@ passphrase_to_dek (u32 *keyid, int pubkey_algo,
 }
 
 
+/* Emit the USERID_HINT and the NEED_PASSPHRASE status messages.
+   MAINKEYID may be NULL. */
+void
+emit_status_need_passphrase (u32 *keyid, u32 *mainkeyid, int pubkey_algo)
+{
+  char buf[50];
+  char *us;
+
+  us = get_long_user_id_string (keyid);
+  write_status_text (STATUS_USERID_HINT, us);
+  xfree (us);
+
+  snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
+            (ulong)keyid[0],
+            (ulong)keyid[1],
+            (ulong)(mainkeyid? mainkeyid[0]:keyid[0]),
+            (ulong)(mainkeyid? mainkeyid[1]:keyid[1]),
+            pubkey_algo);
+
+  write_status_text (STATUS_NEED_PASSPHRASE, buf);
+}
+
+
 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
    is true spaces and control characters are percent or plus escaped.
-   MODE 0 is for the common prompt, MODE 1 for the import prompt. */
+   MODE describes the use of the key description; use one of the
+   FORMAT_KEYDESC_ macros. */
 char *
 gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
 {
@@ -689,29 +642,49 @@ gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
   char *maink;
   char *desc;
   const char *prompt;
-      
-  algo_name = gcry_pk_algo_name (pk->pubkey_algo);
+  const char *trailer = "";
+  int is_subkey;
+
+  is_subkey = (pk->main_keyid[0] && pk->main_keyid[1]
+               && pk->keyid[0] != pk->main_keyid[0]
+               && pk->keyid[1] != pk->main_keyid[1]);
+  algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
   timestr = strtimestamp (pk->timestamp);
-  uid = get_user_id (pk->keyid, &uidlen); 
+  uid = get_user_id (is_subkey? pk->main_keyid:pk->keyid, &uidlen);
 
   orig_codeset = i18n_switchto_utf8 ();
 
-  if (pk->main_keyid[0] && pk->main_keyid[1]
-      && pk->keyid[0] != pk->main_keyid[0] 
-      && pk->keyid[1] != pk->main_keyid[1])
+  if (is_subkey)
     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
   else
     maink = NULL;
 
   switch (mode)
     {
-    case 0:
+    case FORMAT_KEYDESC_NORMAL:
       prompt = _("Please enter the passphrase to unlock the"
-                 " secret key for the OpenPGP certificate:");
+                 " OpenPGP secret key:");
       break;
-    case 1:
+    case FORMAT_KEYDESC_IMPORT:
       prompt = _("Please enter the passphrase to import the"
-                 " secret key for the OpenPGP certificate:");
+                 " OpenPGP secret key:");
+      break;
+    case FORMAT_KEYDESC_EXPORT:
+      if (is_subkey)
+        prompt = _("Please enter the passphrase to export the"
+                   " OpenPGP secret subkey:");
+      else
+        prompt = _("Please enter the passphrase to export the"
+                   " OpenPGP secret key:");
+      break;
+    case FORMAT_KEYDESC_DELKEY:
+      if (is_subkey)
+        prompt = _("Do you really want to permanently delete the"
+                   " OpenPGP secret subkey key:");
+      else
+        prompt = _("Do you really want to permanently delete the"
+                   " OpenPGP secret key:");
+      trailer = "?";
       break;
     default:
       prompt = "?";
@@ -721,12 +694,12 @@ gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
   desc = xtryasprintf (_("%s\n"
                          "\"%.*s\"\n"
                          "%u-bit %s key, ID %s,\n"
-                         "created %s%s.\n"),
+                         "created %s%s.\n%s"),
                        prompt,
                        (int)uidlen, uid,
-                       nbits_from_pk (pk), algo_name, 
+                       nbits_from_pk (pk), algo_name,
                        keystr (pk->keyid), timestr,
-                       maink?maink:"" );
+                       maink?maink:"", trailer);
   xfree (maink);
   xfree (uid);
 
@@ -735,7 +708,7 @@ gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
   if (escaped)
     {
       char *tmp = percent_plus_escape (desc);
-      xfree (desc); 
+      xfree (desc);
       desc = tmp;
     }