2004-03-23 Marcus Brinkmann <marcus@g10code.de>
[gnupg.git] / g10 / passphrase.c
index 0da40e3..27ffcad 100644 (file)
@@ -1,5 +1,5 @@
 /* passphrase.c -  Get a passphrase
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <sys/socket.h>
 #include <sys/un.h>
 #endif
-#if defined (__MINGW32__) || defined (__CYGWIN32__)
+#if defined (_WIN32) || defined (__CYGWIN32__)
 # include <windows.h>
 #endif
 #include <errno.h>
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #endif
+#ifdef HAVE_LANGINFO_CODESET
+#include <langinfo.h>
+#endif
 
+#include "gpg.h"
 #include "util.h"
 #include "memory.h"
 #include "options.h"
@@ -97,7 +101,7 @@ static char *fd_passwd = NULL;
 static char *next_pw = NULL;
 static char *last_pw = NULL;
 
-#if defined (__MINGW32__) || defined (__CYGWIN32__)
+#if defined (_WIN32)
 static int read_fd = 0;
 static int write_fd = 0;
 #endif
@@ -119,10 +123,10 @@ have_static_passphrase()
 void
 set_next_passphrase( const char *s )
 {
-    m_free(next_pw);
+    xfree (next_pw);
     next_pw = NULL;
     if( s ) {
-       next_pw = m_alloc_secure( strlen(s)+1 );
+       next_pw = gcry_xmalloc_secure ( strlen(s)+1 );
        strcpy(next_pw, s );
     }
 }
@@ -144,39 +148,50 @@ get_last_passphrase()
 void
 read_passphrase_from_fd( int fd )
 {
-    int i, len;
-    char *pw;
+  int i, len;
+  char *pw;
+  
+  if ( opt.use_agent ) 
+    { /* 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. */
+      char buf[1];
 
-    if ( opt.use_agent ) 
-        return;  /* not used here */
+      while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
+        ;
+      *buf = 0;
+      return; 
+    }
 
-    if( !opt.batch )
+  if (!opt.batch )
        tty_printf("Reading passphrase from file descriptor %d ...", fd );
-    for( pw = NULL, i = len = 100; ; i++ ) {
-       if( i >= len-1 ) {
-           char *pw2 = pw;
-           len += 100;
-           pw = m_alloc_secure( len );
-           if( pw2 )
-               memcpy(pw, pw2, i );
-           else
-               i=0;
+  for (pw = NULL, i = len = 100; ; i++ ) 
+    {
+      if (i >= len-1 ) 
+        {
+          char *pw2 = pw;
+          len += 100;
+          pw = gcry_xmalloc_secure ( len );
+          if( pw2 )
+            memcpy(pw, pw2, i );
+          else
+            i=0;
        }
-       if( read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
-           break;
+      if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
+        break;
     }
-    pw[i] = 0;
-    if( !opt.batch )
-       tty_printf("\b\b\b   \n" );
+  pw[i] = 0;
+  if (!opt.batch)
+    tty_printf("\b\b\b   \n" );
 
-    m_free( fd_passwd );
-    fd_passwd = pw;
+  xfree ( fd_passwd );
+  fd_passwd = pw;
 }
 
 static int
 writen ( int fd, const void *buf, size_t nbytes )
 {
-#if defined (__MINGW32__) || defined (__CYGWIN32__)
+#if defined (_WIN32)
     DWORD nwritten, nleft = nbytes;
     
     while (nleft > 0) {
@@ -219,7 +234,7 @@ writen ( int fd, const void *buf, size_t nbytes )
 static int
 readn ( int fd, void *buf, size_t buflen, size_t *ret_nread )
 {
-#if defined (__MINGW32__) || defined (__CYGWIN32__)
+#if defined (_WIN32)
     DWORD nread, nleft = buflen;
     
     while (nleft > 0) {
@@ -313,7 +328,7 @@ readline (int fd, char *buf, size_t buflen)
 
 #if !defined (__riscos__)
 
-#if !defined (__MINGW32__) && !defined (__CYGWIN32__)
+#if !defined (_WIN32)
 /* For the new Assuan protocol we may have to send options */
 static int
 agent_send_option (int fd, const char *name, const char *value)
@@ -323,11 +338,11 @@ agent_send_option (int fd, const char *name, const char *value)
   char *line;
   int i; 
   
-  line = m_alloc (7 + strlen (name) + 1 + strlen (value) + 2);
+  line = xmalloc (7 + strlen (name) + 1 + strlen (value) + 2);
   strcpy (stpcpy (stpcpy (stpcpy (
                      stpcpy (line, "OPTION "), name), "="), value), "\n");
   i = writen (fd, line, strlen (line));
-  m_free (line);
+  xfree (line);
   if (i)
     return -1;
   
@@ -346,7 +361,7 @@ static int
 agent_send_all_options (int fd)
 {
   char *dft_display = NULL;
-  char *dft_ttyname = NULL;
+  const char *dft_ttyname = NULL;
   char *dft_ttytype = NULL;
   char *old_lc = NULL;
   char *dft_lc = NULL;
@@ -360,8 +375,12 @@ agent_send_all_options (int fd)
         return -1;
     }
 
-  if (!opt.ttyname && ttyname (1))
-    dft_ttyname = ttyname (1);
+  if (!opt.ttyname)
+    {
+      dft_ttyname = getenv ("GPG_TTY");
+      if ((!dft_ttyname || !*dft_ttyname) && tty_get_ttyname ())
+        dft_ttyname = tty_get_ttyname ();
+    }
   if (opt.ttyname || dft_ttyname)
     {
       if (agent_send_option (fd, "ttyname",
@@ -380,7 +399,7 @@ agent_send_all_options (int fd)
 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
   old_lc = setlocale (LC_CTYPE, NULL);
   if (old_lc)
-    old_lc = m_strdup (old_lc);
+    old_lc = xstrdup (old_lc);
   dft_lc = setlocale (LC_CTYPE, "");
 #endif
   if (opt.lc_ctype || (dft_ttyname && dft_lc))
@@ -392,7 +411,7 @@ agent_send_all_options (int fd)
   if (old_lc)
     {
       setlocale (LC_CTYPE, old_lc);
-      m_free (old_lc);
+      xfree (old_lc);
     }
 #endif
   if (rc)
@@ -401,7 +420,7 @@ agent_send_all_options (int fd)
 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
   old_lc = setlocale (LC_MESSAGES, NULL);
   if (old_lc)
-    old_lc = m_strdup (old_lc);
+    old_lc = xstrdup (old_lc);
   dft_lc = setlocale (LC_MESSAGES, "");
 #endif
   if (opt.lc_messages || (dft_ttyname && dft_lc))
@@ -413,12 +432,12 @@ agent_send_all_options (int fd)
   if (old_lc)
     {
       setlocale (LC_MESSAGES, old_lc);
-      m_free (old_lc);
+      xfree (old_lc);
     }
 #endif
   return rc;
 }
-#endif /*!__MINGW32__ && !__CYGWIN32__*/
+#endif /*!_WIN32*/
 
 
 /*
@@ -429,7 +448,7 @@ agent_send_all_options (int fd)
 static int
 agent_open (int *ret_prot)
 {
-#if defined (__MINGW32__) || defined (__CYGWIN32__)
+#if defined (_WIN32)
     int fd;
     char *infostr, *p;
     HANDLE h;
@@ -481,22 +500,22 @@ agent_open (int *ret_prot)
     int prot;
 
     if (opt.gpg_agent_info)
-      infostr = m_strdup (opt.gpg_agent_info);
+      infostr = xstrdup (opt.gpg_agent_info);
     else
       {
         infostr = getenv ( "GPG_AGENT_INFO" );
-        if ( !infostr ) {
+        if ( !infostr || !*infostr ) {
           log_error (_("gpg-agent is not available in this session\n"));
           opt.use_agent = 0;
           return -1;
         }
-        infostr = m_strdup ( infostr );
+        infostr = xstrdup ( infostr );
       }
 
     if ( !(p = strchr ( infostr, ':')) || p == infostr
          || (p-infostr)+1 >= sizeof client_addr.sun_path ) {
         log_error( _("malformed GPG_AGENT_INFO environment variable\n"));
-        m_free (infostr );
+        xfree (infostr );
         opt.use_agent = 0;
         return -1;
     }
@@ -509,7 +528,7 @@ agent_open (int *ret_prot)
     prot = *p? atoi (p+1) : 0;
     if ( prot < 0 || prot > 1) {
         log_error (_("gpg-agent protocol version %d is not supported\n"),prot);
-        m_free (infostr );
+        xfree (infostr );
         opt.use_agent = 0;
         return -1;
     }
@@ -517,7 +536,7 @@ agent_open (int *ret_prot)
        
     if( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ) {
         log_error ("can't create socket: %s\n", strerror(errno) );
-        m_free (infostr );
+        xfree (infostr );
         opt.use_agent = 0;
         return -1;
     }
@@ -531,12 +550,12 @@ agent_open (int *ret_prot)
     if( connect( fd, (struct sockaddr*)&client_addr, len ) == -1 ) {
         log_error ( _("can't connect to `%s': %s\n"), 
                     infostr, strerror (errno) );
-        m_free (infostr );
+        xfree (infostr );
         close (fd );
         opt.use_agent = 0;
         return -1;
     }
-    m_free (infostr);
+    xfree (infostr);
 
     if (!prot) {
         if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
@@ -574,7 +593,7 @@ agent_open (int *ret_prot)
 static void
 agent_close ( int fd )
 {
-#if defined (__MINGW32__) || defined (__CYGWIN32__)
+#if defined (_WIN32)
     HANDLE h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
     ResetEvent(h);
 #else
@@ -590,23 +609,33 @@ agent_close ( int fd )
  * Mode 0:  Allow cached passphrase
  *      1:  No cached passphrase FIXME: Not really implemented
  *      2:  Ditto, but change the text to "repeat entry"
+ *
+ * Note that TRYAGAIN_TEXT must not be translated.  If canceled is not
+ * NULL, the function does set it to 1 if the user canceled the
+ * operation.
  */
 static char *
-agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
+agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text,
+                       int *canceled)
 {
 #if defined(__riscos__)
   return NULL;
 #else
   size_t n;
-  char *atext;
+  char *atext = NULL;
   char buf[50];
   int fd = -1;
   int nread;
   u32 reply;
   char *pw = NULL;
-  PKT_public_key *pk = m_alloc_clear( sizeof *pk );
+  PKT_public_key *pk = xcalloc (1, sizeof *pk );
   byte fpr[MAX_FINGERPRINT_LEN];
+  int have_fpr = 0;
   int prot;
+  char *orig_codeset = NULL;
+
+  if (canceled)
+    *canceled = 0;
 
 #if MAX_FINGERPRINT_LEN < 20
 #error agent needs a 20 byte fingerprint
@@ -614,58 +643,71 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
 
   memset (fpr, 0, MAX_FINGERPRINT_LEN );
   if( keyid && get_pubkey( pk, keyid ) )
-    pk = NULL; /* oops: no key for some reason */
+    {
+      free_public_key( pk );      
+      pk = NULL; /* oops: no key for some reason */
+    }
   
-  if ( !mode && pk )
+#ifdef ENABLE_NLS
+  /* The Assuan agent protol requires us to trasnmit utf-8 strings */
+  orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
+#ifdef HAVE_LANGINFO_CODESET
+  if (!orig_codeset)
+    orig_codeset = nl_langinfo (CODESET);
+#endif
+  if (orig_codeset)
+    { /* We only switch when we are able to restore the codeset later. */
+      orig_codeset = xstrdup (orig_codeset);
+      if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
+        orig_codeset = NULL; 
+    }
+#endif
+
+  if ( (fd = agent_open (&prot)) == -1 ) 
+    goto failure;
+
+  if ( !mode && pk && keyid )
     { 
       char *uid;
       size_t uidlen;
-      const char *algo_name = pubkey_algo_to_string ( pk->pubkey_algo );
+      const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
       const char *timestr;
       char *maink;
-      const char *fmtstr;
       
       if ( !algo_name )
         algo_name = "?";
       
-      fmtstr = _(" (main key ID %08lX)");
-      maink = m_alloc ( strlen (fmtstr) + 20 );
       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
           && keyid[1] != keyid[3] )
-        sprintf( maink, fmtstr, (ulong)keyid[3] );
+         maink = xasprintf ( _(" (main key ID %08lX)"), (ulong)keyid[3] );
       else
-        *maink = 0;
+         maink = NULL;
       
       uid = get_user_id ( keyid, &uidlen ); 
       timestr = strtimestamp (pk->timestamp);
-      fmtstr = _("You need a passphrase to unlock the"
+      atext = xasprintf (
+               _("You need a passphrase to unlock the"
                  " secret key for user:\n"
                  "\"%.*s\"\n"
-                 "%u-bit %s key, ID %08lX, created %s%s\n" );
-      atext = m_alloc ( 100 + strlen (fmtstr)  
-                        + uidlen + 15 + strlen(algo_name) + 8
-                        + strlen (timestr) + strlen (maink) );
-      sprintf (atext, fmtstr,
+                 "%u-bit %s key, ID %08lX, created %s%s\n" ),
                uidlen, uid,
                nbits_from_pk (pk), algo_name, (ulong)keyid[1], timestr,
-               maink  );
-      m_free (uid);
-      m_free (maink);
+               maink?maink:"" );
+      xfree (uid);
+      xfree (maink);
       
       { 
         size_t dummy;
         fingerprint_from_pk( pk, fpr, &dummy );
+        have_fpr = 1;
       }
       
     }
-  else if (mode == 1 ) 
-    atext = m_strdup ( _("Enter passphrase\n") );
-  else 
-    atext = m_strdup ( _("Repeat passphrase\n") );
+  else if (mode == 2 ) 
+    atext = xstrdup ( _("Repeat passphrase\n") );
+  else
+    atext = xstrdup ( _("Enter passphrase\n") );
                 
-  if ( (fd = agent_open (&prot)) == -1 ) 
-    goto failure;
-
   if (!prot)
     { /* old style protocol */
       n = 4 + 20 + strlen (atext);
@@ -674,7 +716,7 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
       memcpy (buf+8, fpr, 20 );
       if ( writen ( fd, buf, 28 ) || writen ( fd, atext, strlen (atext) ) ) 
         goto failure;
-      m_free (atext); atext = NULL;
+      xfree (atext); atext = NULL;
       
       /* get response */
       if ( readn ( fd, buf, 12, &nread ) ) 
@@ -710,7 +752,7 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
            * on how long the passhrase actually is - this wastes some bytes
            * but because we already have this padding we should not loosen
            * this by issuing 2 read calls */
-          pw = m_alloc_secure ( n+1 );
+          pw = xmalloc_secure ( n+1 );
           if ( readn ( fd, pw, n, &nn ) )
             goto failure;
           if ( n != nn ) 
@@ -721,10 +763,19 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
           pw[pwlen] = 0; /* make a C String */
           agent_close (fd);
           free_public_key( pk );
+#ifdef ENABLE_NLS
+          if (orig_codeset)
+            bind_textdomain_codeset (PACKAGE, orig_codeset);
+#endif
+          xfree (orig_codeset);
           return pw;
         }
       else if ( reply == GPGA_PROT_CANCELED ) 
-        log_info ( _("cancelled by user\n") );
+        {
+          log_info ( _("cancelled by user\n") );
+          if (canceled)
+            *canceled = 1;
+        }
       else 
         log_error ( _("problem with the agent: agent returns 0x%lx\n"),
                     (ulong)reply );
@@ -732,18 +783,21 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
   else
     { /* The new Assuan protocol */
       char *line, *p;
+      const unsigned char *s;
       int i; 
 
       if (!tryagain_text)
         tryagain_text = "X";
+      else
+        tryagain_text = _(tryagain_text);
 
       /* We allocate 2 time the needed space for atext so that there
-         is nenough space for escaping */
-      line = m_alloc (15 + 46 
+         is enough space for escaping */
+      line = xmalloc (15 + 46 
                       +  3*strlen (tryagain_text) + 3*strlen (atext) + 2);
       strcpy (line, "GET_PASSPHRASE ");
       p = line+15;
-      if (!mode)
+      if (!mode && have_fpr)
         {
           for (i=0; i < 20; i++, p +=2 )
             sprintf (p, "%02X", fpr[i]);
@@ -751,43 +805,43 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
       else
         *p++ = 'X'; /* no caching */
       *p++ = ' ';
-      for (i=0; tryagain_text[i]; i++)
+      for (i=0, s=tryagain_text; *s; s++)
         {
-          if (tryagain_text[i] < ' ' || tryagain_text[i] == '+')
+          if (*s < ' ' || *s == '+')
             {
-              sprintf (p, "%%%02X", tryagain_text[i]);
+              sprintf (p, "%%%02X", *s);
               p += 3;
             }
-          else if (tryagain_text[i] == ' ')
+          else if (*s == ' ')
             *p++ = '+';
           else
-            *p++ = tryagain_text[i];
+            *p++ = *s;
         }
       *p++ = ' ';
       *p++ = 'X'; /* Use the standard prompt */
       *p++ = ' ';
       /* copy description */
-      for (i=0; atext[i]; i++)
+      for (i=0, s= atext; *s; s++)
         {
-          if (atext[i] < ' ' || atext[i] == '+')
+          if (*s < ' ' || *s == '+')
             {
-              sprintf (p, "%%%02X", atext[i]);
+              sprintf (p, "%%%02X", *s);
               p += 3;
             }
-          else if (atext[i] == ' ')
+          else if (*s == ' ')
             *p++ = '+';
           else
-            *p++ = atext[i];
+            *p++ = *s;
         }
       *p++ = '\n';
       i = writen (fd, line, p - line);
-      m_free (line);
+      xfree (line);
       if (i)
         goto failure;
-      m_free (atext); atext = NULL;
+      xfree (atext); atext = NULL;
       
       /* get response */
-      pw = m_alloc_secure (500);
+      pw = xmalloc_secure (500);
       nread = readline (fd, pw, 499);
       if (nread < 3)
         goto failure;
@@ -801,11 +855,20 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
           pw[pwlen] = 0; /* make a C String */
           agent_close (fd);
           free_public_key( pk );
+#ifdef ENABLE_NLS
+          if (orig_codeset)
+            bind_textdomain_codeset (PACKAGE, orig_codeset);
+#endif
+          xfree (orig_codeset);
           return pw;
         }
       else if (nread > 7 && !memcmp (pw, "ERR 111", 7)
                && (pw[7] == ' ' || pw[7] == '\n') ) 
-        log_info (_("cancelled by user\n") );
+        {
+          log_info (_("cancelled by user\n") );
+          if (canceled)
+            *canceled = 1;
+        }
       else 
         {
           log_error (_("problem with the agent - disabling agent use\n"));
@@ -815,10 +878,14 @@ agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text )
       
         
  failure:
-  m_free (atext);
+#ifdef ENABLE_NLS
+  if (orig_codeset)
+    bind_textdomain_codeset (PACKAGE, orig_codeset);
+#endif
+  xfree (atext);
   if ( fd != -1 )
     agent_close (fd);
-  m_free (pw );
+  xfree (pw );
   free_public_key( pk );
   
   return NULL;
@@ -850,7 +917,7 @@ passphrase_clear_cache ( u32 *keyid, int algo )
   if (!opt.use_agent)
     return;
   
-  pk = m_alloc_clear ( sizeof *pk );
+  pk = xcalloc (1, sizeof *pk );
   memset (fpr, 0, MAX_FINGERPRINT_LEN );
   if( !keyid || get_pubkey( pk, keyid ) )
     {
@@ -896,14 +963,14 @@ passphrase_clear_cache ( u32 *keyid, int algo )
       char *line, *p;
       int i; 
 
-      line = m_alloc (17 + 40 + 2);
+      line = xmalloc (17 + 40 + 2);
       strcpy (line, "CLEAR_PASSPHRASE ");
       p = line+17;
       for (i=0; i < 20; i++, p +=2 )
         sprintf (p, "%02X", fpr[i]);
       *p++ = '\n';
       i = writen (fd, line, p - line);
-      m_free (line);
+      xfree (line);
       if (i)
         goto failure;
       
@@ -934,32 +1001,38 @@ passphrase_clear_cache ( u32 *keyid, int algo )
 /****************
  * Get a passphrase for the secret key with KEYID, display TEXT
  * if the user needs to enter the passphrase.
- * mode 0 = standard, 2 = create new passphrase
+ * mode 0 = standard, 1 = same but don't show key info,
+ *      2 = create new passphrase
  * Returns: a DEK with a session key; caller must free
  *         or NULL if the passphrase was not correctly repeated.
  *         (only for mode 2)
  *         a dek->keylen of 0 means: no passphrase entered.
  *         (only for mode 2)
- * pubkey_algo is only informational.
+ *
+ * pubkey_algo is only informational.  Note that TRYAGAIN_TEXT must
+ * not be translated as this is done within this function (required to
+ * switch to utf-8 when the agent is in use).  If CANCELED is not
+ * NULL, it is set to 1 if the user choosed to cancel the operation,
+ * otherwise it will be set to 0.
  */
 DEK *
 passphrase_to_dek( u32 *keyid, int pubkey_algo,
                   int cipher_algo, STRING2KEY *s2k, int mode,
-                   const char *tryagain_text)
+                   const char *tryagain_text, int *canceled)
 {
     char *pw = NULL;
     DEK *dek;
     STRING2KEY help_s2k;
 
+    if (canceled)
+      *canceled = 0;
+
     if( !s2k ) {
         /* This is used for the old rfc1991 mode 
          * Note: This must match the code in encode.c with opt.rfc1991 set */
-        int algo = opt.def_digest_algo ? opt.def_digest_algo
-                                       : opt.s2k_digest_algo;
-
        s2k = &help_s2k;
        s2k->mode = 0;
-       s2k->hash_algo = algo;
+       s2k->hash_algo = opt.s2k_digest_algo;
     }
 
     if( !next_pw && is_status_enabled() ) {
@@ -980,7 +1053,7 @@ passphrase_to_dek( u32 *keyid, int pubkey_algo,
 
             us = get_long_user_id_string( keyid );
             write_status_text( STATUS_USERID_HINT, us );
-            m_free(us);
+            xfree (us);
 
            sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
                      (ulong)keyid[0], (ulong)keyid[1],
@@ -995,8 +1068,8 @@ passphrase_to_dek( u32 *keyid, int pubkey_algo,
        }
     }
 
-    if( keyid && !opt.batch && !next_pw ) {
-       PKT_public_key *pk = m_alloc_clear( sizeof *pk );
+    if( keyid && !opt.batch && !next_pw && mode!=1 ) {
+       PKT_public_key *pk = xcalloc (1, sizeof *pk );
        size_t n;
        char *p;
 
@@ -1004,11 +1077,11 @@ passphrase_to_dek( u32 *keyid, int pubkey_algo,
                     "user: \"") );
        p = get_user_id( keyid, &n );
        tty_print_utf8_string( p, n );
-       m_free(p);
+       xfree (p);
        tty_printf("\"\n");
 
        if( !get_pubkey( pk, keyid ) ) {
-           const char *s = pubkey_algo_to_string( pk->pubkey_algo );
+           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
            tty_printf( _("%u-bit %s key, ID %08lX, created %s"),
                       nbits_from_pk( pk ), s?s:"?", (ulong)keyid[1],
                       strtimestamp(pk->timestamp) );
@@ -1028,40 +1101,41 @@ passphrase_to_dek( u32 *keyid, int pubkey_algo,
        next_pw = NULL;
     }
     else if ( opt.use_agent ) {
-       pw = agent_get_passphrase ( keyid, mode == 2? 1: 0, tryagain_text );
+       pw = agent_get_passphrase ( keyid, mode == 2? 1: 0,
+                                    tryagain_text, canceled );
         if (!pw)
           {
             if (!opt.use_agent)
               goto agent_died;
-            pw = m_strdup ("");
+            pw = xstrdup ("");
           }
         if( *pw && mode == 2 ) {
-           char *pw2 = agent_get_passphrase ( keyid, 2, NULL );
+           char *pw2 = agent_get_passphrase ( keyid, 2, NULL, canceled );
             if (!pw2)
               {
                 if (!opt.use_agent)
                   {
-                    m_free (pw);
+                    xfree (pw);
                     pw = NULL;
                     goto agent_died;
                   }
-                pw2 = m_strdup ("");
+                pw2 = xstrdup ("");
               }
            if( strcmp(pw, pw2) ) {
-               m_free(pw2);
-               m_free(pw);
+               xfree (pw2);
+               xfree (pw);
                return NULL;
            }
-           m_free(pw2);
+           xfree (pw2);
        }
     }
     else if( fd_passwd ) {
-       pw = m_alloc_secure( strlen(fd_passwd)+1 );
+       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
        strcpy( pw, fd_passwd );
     }
     else if( opt.batch ) {
        log_error(_("can't query password in batchmode\n"));
-       pw = m_strdup( "" ); /* return an empty passphrase */
+       pw = xstrdup ( "" ); /* return an empty passphrase */
     }
     else {
        pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
@@ -1071,24 +1145,24 @@ passphrase_to_dek( u32 *keyid, int pubkey_algo,
                                       _("Repeat passphrase: ") );
            tty_kill_prompt();
            if( strcmp(pw, pw2) ) {
-               m_free(pw2);
-               m_free(pw);
+               xfree (pw2);
+               xfree (pw);
                return NULL;
            }
-           m_free(pw2);
+           xfree (pw2);
        }
     }
 
     if( !pw || !*pw )
        write_status( STATUS_MISSING_PASSPHRASE );
 
-    dek = m_alloc_secure_clear ( sizeof *dek );
+    dek = xcalloc_secure (1, sizeof *dek );
     dek->algo = cipher_algo;
     if( !*pw && mode == 2 )
        dek->keylen = 0;
     else
        hash_passphrase( dek, pw, s2k, mode==2 );
-    m_free(last_pw);
+    xfree (last_pw);
     last_pw = pw;
     return dek;
 }
@@ -1108,16 +1182,16 @@ hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
     int pwlen = strlen(pw);
 
     assert( s2k->hash_algo );
-    dek->keylen = cipher_get_keylen( dek->algo ) / 8;
+    dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
        BUG();
 
-    md = md_open( s2k->hash_algo, 1);
+    gcry_md_open (&md, s2k->hash_algo, 1);
     for(pass=0; used < dek->keylen ; pass++ ) {
        if( pass ) {
-            md_reset(md);
+            gcry_md_reset(md);
            for(i=0; i < pass; i++ ) /* preset the hash context */
-               md_putc(md, 0 );
+               gcry_md_putc (md, 0 );
        }
 
        if( s2k->mode == 1 || s2k->mode == 3 ) {
@@ -1125,7 +1199,7 @@ hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
            ulong count = len2;
 
            if( create && !pass ) {
-               randomize_buffer(s2k->salt, 8, 1);
+               gcry_randomize(s2k->salt, 8, GCRY_STRONG_RANDOM );
                if( s2k->mode == 3 )
                    s2k->count = 96; /* 65536 iterations */
            }
@@ -1137,27 +1211,27 @@ hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
            }
            /* a little bit complicated because we need a ulong for count */
            while( count > len2 ) { /* maybe iterated+salted */
-               md_write( md, s2k->salt, 8 );
-               md_write( md, pw, pwlen );
+               gcry_md_write( md, s2k->salt, 8 );
+               gcry_md_write( md, pw, pwlen );
                count -= len2;
            }
            if( count < 8 )
-               md_write( md, s2k->salt, count );
+               gcry_md_write( md, s2k->salt, count );
            else {
-               md_write( md, s2k->salt, 8 );
+               gcry_md_write( md, s2k->salt, 8 );
                count -= 8;
-                md_write( md, pw, count );
+                gcry_md_write( md, pw, count );
            }
        }
        else
-           md_write( md, pw, pwlen );
-       md_final( md );
-       i = md_digest_length( s2k->hash_algo );
+           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, md_read(md, s2k->hash_algo), i );
+       memcpy( dek->key+used, gcry_md_read (md, s2k->hash_algo), i );
        used += i;
     }
-    md_close(md);
+    gcry_md_close (md);
 }