Exporting secret keys via gpg-agent is now basically supported.
[gnupg.git] / agent / protect.c
index ee1b5ec..795d062 100644 (file)
@@ -1,12 +1,12 @@
 /* protect.c - Un/Protect a secret key
  * Copyright (C) 1998, 1999, 2000, 2001, 2002,
- *               2003, 2007 Free Software Foundation, Inc.
+ *               2003, 2007, 2009 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG 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
+ * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
@@ -15,9 +15,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
- * USA.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <assert.h>
 #include <unistd.h>
 #include <sys/stat.h>
+#ifdef HAVE_W32_SYSTEM
+# include <windows.h>
+#else
+# include <sys/times.h>
+#endif
 
 #include "agent.h"
 
@@ -53,6 +56,17 @@ static struct {
 };
 
 
+/* A helper object for time measurement.  */
+struct calibrate_time_s
+{
+#ifdef HAVE_W32_SYSTEM
+  FILETIME creation_time, exit_time, kernel_time, user_time;
+#else
+  clock_t ticks;
+#endif
+};
+
+
 static int
 hash_passphrase (const char *passphrase, int hashalgo,
                  int s2kmode,
@@ -61,14 +75,132 @@ hash_passphrase (const char *passphrase, int hashalgo,
 
 
 \f
-/* Calculate the MIC for a private key S-Exp. SHA1HASH should point to
-   a 20 byte buffer.  This function is suitable for any algorithms. */
+/* Get the process time and store it in DATA.  */
+static void
+calibrate_get_time (struct calibrate_time_s *data)
+{
+#ifdef HAVE_W32_SYSTEM
+# ifdef HAVE_W32CE_SYSTEM
+  GetThreadTimes (GetCurrentThread (),
+# else 
+  GetProcessTimes (GetCurrentProcess (),
+# endif
+                   &data->creation_time, &data->exit_time,
+                   &data->kernel_time, &data->user_time);
+#else
+  struct tms tmp;
+  
+  times (&tmp);
+  data->ticks = tmp.tms_utime;
+#endif
+}
+
+
+static unsigned long
+calibrate_elapsed_time (struct calibrate_time_s *starttime)
+{
+  struct calibrate_time_s stoptime;
+  
+  calibrate_get_time (&stoptime);
+#ifdef HAVE_W32_SYSTEM
+  {
+    unsigned long long t1, t2;
+    
+    t1 = (((unsigned long long)starttime->kernel_time.dwHighDateTime << 32)
+          + starttime->kernel_time.dwLowDateTime);
+    t1 += (((unsigned long long)starttime->user_time.dwHighDateTime << 32)
+           + starttime->user_time.dwLowDateTime);
+    t2 = (((unsigned long long)stoptime.kernel_time.dwHighDateTime << 32)
+          + stoptime.kernel_time.dwLowDateTime);
+    t2 += (((unsigned long long)stoptime.user_time.dwHighDateTime << 32)
+           + stoptime.user_time.dwLowDateTime);
+    return (unsigned long)((t2 - t1)/10000);
+  }
+#else
+  return (unsigned long)((((double) (stoptime.ticks - starttime->ticks))
+                          /CLOCKS_PER_SEC)*10000000);
+#endif
+}
+
+
+/* Run a test hashing for COUNT and return the time required in
+   milliseconds.  */
+static unsigned long
+calibrate_s2k_count_one (unsigned long count)
+{
+  int rc;
+  char keybuf[PROT_CIPHER_KEYLEN];
+  struct calibrate_time_s starttime;
+
+  calibrate_get_time (&starttime);
+  rc = hash_passphrase ("123456789abcdef0", GCRY_MD_SHA1,
+                        3, "saltsalt", count, keybuf, sizeof keybuf);
+  if (rc)
+    BUG ();
+  return calibrate_elapsed_time (&starttime);
+}
+
+
+/* Measure the time we need to do the hash operations and deduce an
+   S2K count which requires about 100ms of time.  */ 
+static unsigned long
+calibrate_s2k_count (void)
+{
+  unsigned long count;
+  unsigned long ms;
+
+  for (count = 65536; count; count *= 2)
+    {
+      ms = calibrate_s2k_count_one (count);
+      if (opt.verbose > 1)
+        log_info ("S2K calibration: %lu -> %lums\n", count, ms);
+      if (ms > 100)
+        break;
+    }
+
+  count = (unsigned long)(((double)count / ms) * 100);
+  count /= 1024;
+  count *= 1024;
+  if (count < 65536)
+    count = 65536;
+
+  if (opt.verbose)
+    {
+      ms = calibrate_s2k_count_one (count);
+      log_info ("S2K calibration: %lu -> %lums\n", count, ms);
+    }
+
+  return count;
+}
+
+
+
+/* Return the standard S2K count.  */
+unsigned long
+get_standard_s2k_count (void)
+{
+  static unsigned long count;
+
+  if (!count)
+    count = calibrate_s2k_count ();
+
+  /* Enforce a lower limit.  */
+  return count < 65536 ? 65536 : count;
+}
+
+
+
+\f
+/* Calculate the MIC for a private key or shared secret S-expression.
+   SHA1HASH should point to a 20 byte buffer.  This function is
+   suitable for all algorithms. */
 static int 
 calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
 {
   const unsigned char *hash_begin, *hash_end;
   const unsigned char *s;
   size_t n;
+  int is_shared_secret;
 
   s = plainkey;
   if (*s != '(')
@@ -77,16 +209,23 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
   n = snext (&s);
   if (!n)
     return gpg_error (GPG_ERR_INV_SEXP); 
-  if (!smatch (&s, n, "private-key"))
+  if (smatch (&s, n, "private-key"))
+    is_shared_secret = 0;
+  else if (smatch (&s, n, "shared-secret"))
+    is_shared_secret = 1;
+  else
     return gpg_error (GPG_ERR_UNKNOWN_SEXP); 
   if (*s != '(')
     return gpg_error (GPG_ERR_UNKNOWN_SEXP);
   hash_begin = s;
-  s++;
-  n = snext (&s);
-  if (!n)
-    return gpg_error (GPG_ERR_INV_SEXP); 
-  s += n; /* skip over the algorithm name */
+  if (!is_shared_secret)
+    {
+      s++;
+      n = snext (&s);
+      if (!n)
+        return gpg_error (GPG_ERR_INV_SEXP); 
+      s += n; /* Skip the algorithm name.  */
+    }
 
   while (*s == '(')
     {
@@ -165,7 +304,7 @@ do_encryption (const unsigned char *protbegin, size_t protlen,
      ((<parameter_list>)(4:hash4:sha120:<hashvalue>)) + padding
 
      We always append a full block of random bytes as padding but
-     encrypt only what is needed for a full blocksize */
+     encrypt only what is needed for a full blocksize */
   blklen = gcry_cipher_get_algo_blklen (PROT_CIPHER);
   outlen = 2 + protlen + 2 + 6 + 6 + 23 + 2 + blklen;
   enclen = outlen/blklen * blklen;
@@ -178,8 +317,11 @@ do_encryption (const unsigned char *protbegin, size_t protlen,
       iv = xtrymalloc (blklen*2+8);
       if (!iv)
         rc = gpg_error (GPG_ERR_ENOMEM);
-      gcry_create_nonce (iv, blklen*2+8);
-      rc = gcry_cipher_setiv (hd, iv, blklen);
+      else
+        {
+          gcry_create_nonce (iv, blklen*2+8);
+          rc = gcry_cipher_setiv (hd, iv, blklen);
+        }
     }
   if (!rc)
     {
@@ -192,7 +334,8 @@ do_encryption (const unsigned char *protbegin, size_t protlen,
       else
         {
           rc = hash_passphrase (passphrase, GCRY_MD_SHA1,
-                                3, iv+2*blklen, 96, key, keylen);
+                                3, iv+2*blklen, 
+                                get_standard_s2k_count (), key, keylen);
           if (!rc)
             rc = gcry_cipher_setkey (hd, key, keylen);
           xfree (key);
@@ -231,28 +374,26 @@ do_encryption (const unsigned char *protbegin, size_t protlen,
        encrypted_octet_string)
        
      in canoncical format of course.  We use asprintf and %n modifier
-     and spaces as palceholders.  */
-  asprintf (&p,
-            "(9:protected%d:%s((4:sha18:%n_8bytes_2:96)%d:%n%*s)%d:%n%*s)",
-            (int)strlen (modestr), modestr,
-            &saltpos, 
-            blklen, &ivpos, blklen, "",
-            enclen, &encpos, enclen, "");
-  if (p)
-    { /* asprintf does not use our malloc system */
-      char *psave = p;
-      p = xtrymalloc (strlen (psave)+1);
-      if (p)
-        strcpy (p, psave);
-      free (psave);
-    }
-  if (!p)
-    {
-      gpg_error_t tmperr = out_of_core ();
-      xfree (iv);
-      xfree (outbuf);
-      return tmperr;
-    }
+     and dummy values as placeholders.  */
+  {
+    char countbuf[35];
+
+    snprintf (countbuf, sizeof countbuf, "%lu", get_standard_s2k_count ());
+    p = xtryasprintf
+      ("(9:protected%d:%s((4:sha18:%n_8bytes_%u:%s)%d:%n%*s)%d:%n%*s)",
+       (int)strlen (modestr), modestr,
+       &saltpos, 
+       (unsigned int)strlen (countbuf), countbuf,
+       blklen, &ivpos, blklen, "",
+       enclen, &encpos, enclen, "");
+    if (!p)
+      {
+        gpg_error_t tmperr = out_of_core ();
+        xfree (iv);
+        xfree (outbuf);
+        return tmperr;
+      }
+  }
   *resultlen = strlen (p);
   *result = (unsigned char*)p;
   memcpy (p+saltpos, iv+2*blklen, 8);
@@ -278,11 +419,19 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
   size_t n;
   int c, infidx, i;
   unsigned char hashvalue[20];
+  char timestamp_exp[35];
   unsigned char *protected;
   size_t protectedlen;
   int depth = 0;
   unsigned char *p;
+  gcry_md_hd_t md;
+
+  /* Create an S-expression with the protected-at timestamp.  */
+  memcpy (timestamp_exp, "(12:protected-at15:", 19);
+  gnupg_get_isotime (timestamp_exp+19);
+  timestamp_exp[19+15] = ')';
 
+  /* Parse original key.  */
   s = plainkey;
   if (*s != '(')
     return gpg_error (GPG_ERR_INV_SEXP);
@@ -347,8 +496,18 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
   assert (!depth);
   real_end = s-1;
 
-  gcry_md_hash_buffer (GCRY_MD_SHA1, hashvalue,
-                       hash_begin, hash_end - hash_begin + 1);
+  
+  /* Hash the stuff.  Because the timestamp_exp won't get protected,
+     we can't simply hash a continuous buffer but need to use several
+     md_writes.  */ 
+  rc = gcry_md_open (&md, GCRY_MD_SHA1, 0 );
+  if (rc)
+    return rc;
+  gcry_md_write (md, hash_begin, hash_end - hash_begin);
+  gcry_md_write (md, timestamp_exp, 35);
+  gcry_md_write (md, ")", 1);
+  memcpy (hashvalue, gcry_md_read (md, GCRY_MD_SHA1), 20);
+  gcry_md_close (md);
 
   rc = do_encryption (prot_begin, prot_end - prot_begin + 1,
                       passphrase,  hashvalue,
@@ -358,10 +517,12 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
 
   /* Now create the protected version of the key.  Note that the 10
      extra bytes are for for the inserted "protected-" string (the
-     beginning of the plaintext reads: "((11:private-key(" ). */
+     beginning of the plaintext reads: "((11:private-key(" ).  The 35
+     term is the space for (12:protected-at15:<timestamp>).  */
   *resultlen = (10
                 + (prot_begin-plainkey)
                 + protectedlen
+                + 35
                 + (real_end-prot_end));
   *result = p = xtrymalloc (*resultlen);
   if (!p)
@@ -376,10 +537,15 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
   p += prot_begin - plainkey - 4;
   memcpy (p, protected, protectedlen);
   p += protectedlen;
+
+  memcpy (p, timestamp_exp, 35);
+  p += 35;
+
   memcpy (p, prot_end+1, real_end - prot_end);
   p += real_end - prot_end;
   assert ( p - *result == *resultlen);
   xfree (protected);
+
   return 0;
 }
 
@@ -459,13 +625,16 @@ do_decryption (const unsigned char *protected, size_t protectedlen,
 /* Merge the parameter list contained in CLEARTEXT with the original
    protect lists PROTECTEDKEY by replacing the list at REPLACEPOS.
    Return the new list in RESULT and the MIC value in the 20 byte
-   buffer SHA1HASH. */
+   buffer SHA1HASH.  CUTOFF and CUTLEN will receive the offset and the
+   length of the resulting list which should go into the MIC
+   calculation but then be removed.  */
 static int
 merge_lists (const unsigned char *protectedkey,
              size_t replacepos, 
              const unsigned char *cleartext,
              unsigned char *sha1hash,
-             unsigned char **result, size_t *resultlen)
+             unsigned char **result, size_t *resultlen,
+             size_t *cutoff, size_t *cutlen)
 {
   size_t n, newlistlen;
   unsigned char *newlist, *p;
@@ -475,6 +644,8 @@ merge_lists (const unsigned char *protectedkey,
   
   *result = NULL;
   *resultlen = 0;
+  *cutoff = 0;
+  *cutlen = 0;
 
   if (replacepos < 26)
     return gpg_error (GPG_ERR_BUG);
@@ -524,7 +695,7 @@ merge_lists (const unsigned char *protectedkey,
     goto invalid_sexp;
   endpos = s;
   s++;
-  /* short intermezzo: Get the MIC */
+  /* Intermezzo: Get the MIC */
   if (*s != '(')
     goto invalid_sexp;
   s++;
@@ -541,13 +712,13 @@ merge_lists (const unsigned char *protectedkey,
   s += n;
   if (*s != ')')
     goto invalid_sexp;
-  /* end intermezzo */
+  /* End intermezzo */
 
   /* append the parameter list */
   memcpy (p, startpos, endpos - startpos);
   p += endpos - startpos;
   
-  /* skip overt the protected list element in the original list */
+  /* Skip over the protected list element in the original list.  */
   s = protectedkey + replacepos;
   assert (*s == '(');
   s++;
@@ -555,6 +726,22 @@ merge_lists (const unsigned char *protectedkey,
   rc = sskip (&s, &i);
   if (rc)
     goto failure;
+  /* Record the position of the optional protected-at expression.  */
+  if (*s == '(')
+    {
+      const unsigned char *save_s = s;
+      s++;
+      n = snext (&s);
+      if (smatch (&s, n, "protected-at"))
+        {
+          i = 1;
+          rc = sskip (&s, &i);
+          if (rc)
+            goto failure;
+          *cutlen = s - save_s;
+        }
+      s = save_s;
+    }
   startpos = s;
   i = 2; /* we are inside this level */
   rc = sskip (&s, &i);
@@ -563,9 +750,12 @@ merge_lists (const unsigned char *protectedkey,
   assert (s[-1] == ')');
   endpos = s; /* one behind the end of the list */
 
-  /* append the rest */
+  /* Append the rest. */
+  if (*cutlen)
+    *cutoff = p - newlist;
   memcpy (p, startpos, endpos - startpos);
   p += endpos - startpos;
+  
 
   /* ready */
   *result = newlist;
@@ -586,13 +776,16 @@ merge_lists (const unsigned char *protectedkey,
 
 
 /* Unprotect the key encoded in canonical format.  We assume a valid
-   S-Exp here. */
+   S-Exp here.  If a protected-at item is available, its value will
+   be stored at protocted_at unless this is NULL.  */
 int 
 agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
+                 gnupg_isotime_t protected_at, 
                  unsigned char **result, size_t *resultlen)
 {
   int rc;
   const unsigned char *s;
+  const unsigned char *protect_list; 
   size_t n;
   int infidx, i;
   unsigned char sha1hash[20], sha1hash2[20];
@@ -603,6 +796,10 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
   unsigned char *cleartext;
   unsigned char *final;
   size_t finallen;
+  size_t cutoff, cutlen;
+
+  if (protected_at)
+    *protected_at = 0;
 
   s = protectedkey;
   if (*s != '(')
@@ -626,12 +823,44 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
   if (!protect_info[infidx].algo)
     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM); 
 
+
+  /* See wether we have a protected-at timestamp.  */
+  protect_list = s;  /* Save for later.  */
+  if (protected_at)
+    {
+      while (*s == '(')
+        {
+          prot_begin = s;
+          s++;
+          n = snext (&s);
+          if (!n)
+            return gpg_error (GPG_ERR_INV_SEXP);
+          if (smatch (&s, n, "protected-at"))
+            {
+              n = snext (&s);
+              if (!n)
+                return gpg_error (GPG_ERR_INV_SEXP);
+              if (n != 15)
+                return gpg_error (GPG_ERR_UNKNOWN_SEXP);
+              memcpy (protected_at, s, 15);
+              protected_at[15] = 0;
+              break;
+            }
+          s += n;
+          i = 1;
+          rc = sskip (&s, &i);
+          if (rc)
+            return rc;
+        }
+    }
+
   /* Now find the list with the protected information.  Here is an
      example for such a list:
      (protected openpgp-s2k3-sha1-aes-cbc 
         ((sha1 <salt> <count>) <Initialization_Vector>)
         <encrypted_data>)
    */
+  s = protect_list;
   for (;;)
     {
       if (*s != '(')
@@ -676,9 +905,23 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
      is nothing we should worry about */
   if (s[n] != ')' )
     return gpg_error (GPG_ERR_INV_SEXP);
+  
+  /* Old versions of gpg-agent used the funny floating point number in
+     a byte encoding as specified by OpenPGP.  However this is not
+     needed and thus we now store it as a plain unsigned integer.  We
+     can easily distinguish the old format by looking at its value:
+     Less than 256 is an old-style encoded number; other values are
+     plain integers.  In any case we check that they are at least
+     65536 because we never used a lower value in the past and we
+     should have a lower limit.  */
   s2kcount = strtoul ((const char*)s, NULL, 10);
   if (!s2kcount)
     return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
+  if (s2kcount < 256)
+    s2kcount = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
+  if (s2kcount < 65536)
+    return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
+
   s += n;
   s++; /* skip list end */
 
@@ -694,6 +937,7 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
   if (!n)
     return gpg_error (GPG_ERR_INV_SEXP); 
   
+  cleartext = NULL; /* Avoid cc warning. */
   rc = do_decryption (s, n,
                       passphrase, s2ksalt, s2kcount,
                       iv, 16,
@@ -702,7 +946,7 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
     return rc;
 
   rc = merge_lists (protectedkey, prot_begin-protectedkey, cleartext,
-                    sha1hash, &final, &finallen);
+                    sha1hash, &final, &finallen, &cutoff, &cutlen);
   /* Albeit cleartext has been allocated in secure memory and thus
      xfree will wipe it out, we do an extra wipe just in case
      somethings goes badly wrong. */
@@ -720,6 +964,13 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
       xfree (final);
       return rc;
     }
+  /* Now remove the part which is included in the MIC but should not
+     go into the final thing.  */
+  if (cutlen)
+    {
+      memmove (final+cutoff, final+cutoff+cutlen, finallen-cutoff-cutlen);
+      finallen -= cutlen;
+    }
 
   *result = final;
   *resultlen = gcry_sexp_canon_len (final, 0, NULL, NULL);
@@ -759,8 +1010,7 @@ agent_private_key_type (const unsigned char *privatekey)
 /* Transform a passphrase into a suitable key of length KEYLEN and
    store this key in the caller provided buffer KEY.  The caller must
    provide an HASHALGO, a valid S2KMODE (see rfc-2440) and depending on
-   that mode an S2KSALT of 8 random bytes and an S2KCOUNT (a suitable
-   value is 96).
+   that mode an S2KSALT of 8 random bytes and an S2KCOUNT.
   
    Returns an error code on failure.  */
 static int
@@ -802,7 +1052,7 @@ hash_passphrase (const char *passphrase, int hashalgo,
 
           if (s2kmode == 3)
             {
-              count = (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6);
+              count = s2kcount;
               if (count < len2)
                 count = len2;
             }
@@ -837,6 +1087,19 @@ hash_passphrase (const char *passphrase, int hashalgo,
 }
 
 
+gpg_error_t
+s2k_hash_passphrase (const char *passphrase, int hashalgo,
+                     int s2kmode,
+                     const unsigned char *s2ksalt,
+                     unsigned int s2kcount,
+                     unsigned char *key, size_t keylen)
+{
+  return hash_passphrase (passphrase, hashalgo, s2kmode, s2ksalt, 
+                          (16ul + (s2kcount & 15)) << ((s2kcount >> 4) + 6),
+                          key, keylen);
+}
+
+
 \f
 
 /* Create an canonical encoded S-expression with the shadow info from
@@ -1020,3 +1283,68 @@ agent_get_shadow_info (const unsigned char *shadowkey,
   return 0;
 }
 
+
+/* Parse the canonical encoded SHADOW_INFO S-expression.  On success
+   the hex encoded serial number is returned as a malloced strings at
+   R_HEXSN and the Id string as a malloced string at R_IDSTR.  On
+   error an error code is returned and NULL is stored at the result
+   parameters addresses.  If the serial number or the ID string is not
+   required, NULL may be passed for them.  */
+gpg_error_t
+parse_shadow_info (const unsigned char *shadow_info, 
+                   char **r_hexsn, char **r_idstr)
+{
+  const unsigned char *s;
+  size_t n;
+
+  if (r_hexsn)
+    *r_hexsn = NULL;
+  if (r_idstr)
+    *r_idstr = NULL;
+
+  s = shadow_info;
+  if (*s != '(')
+    return gpg_error (GPG_ERR_INV_SEXP);
+  s++;
+  n = snext (&s);
+  if (!n)
+    return gpg_error (GPG_ERR_INV_SEXP);
+
+  if (r_hexsn)
+    {
+      *r_hexsn = bin2hex (s, n, NULL);
+      if (!*r_hexsn)
+        return gpg_error_from_syserror ();
+    }
+  s += n;
+
+  n = snext (&s);
+  if (!n)
+    {
+      if (r_hexsn)
+        {
+          xfree (*r_hexsn);
+          *r_hexsn = NULL;
+        }
+      return gpg_error (GPG_ERR_INV_SEXP);
+    }
+  
+  if (r_idstr)
+    {
+      *r_idstr = xtrymalloc (n+1);
+      if (!*r_idstr)
+        {
+          if (r_hexsn)
+            {
+              xfree (*r_hexsn);
+              *r_hexsn = NULL;
+            }
+          return gpg_error_from_syserror ();
+        }
+      memcpy (*r_idstr, s, n);
+      (*r_idstr)[n] = 0;
+    }
+
+  return 0;
+}
+