Finished the bulk of changes for gnupg 1.9. This included switching
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stddef.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <assert.h>
28 #if !defined(HAVE_DOSISH_SYSTEM) && !defined(__riscos__)
29 #include <sys/socket.h>
30 #include <sys/un.h>
31 #endif
32 #if defined (__MINGW32__) || defined (__CYGWIN32__)
33 # include <windows.h>
34 #endif
35 #include <errno.h>
36 #ifdef HAVE_LOCALE_H
37 #include <locale.h>
38 #endif
39 #ifdef HAVE_LANGINFO_CODESET
40 #include <langinfo.h>
41 #endif
42
43 #include "gpg.h"
44 #include "util.h"
45 #include "memory.h"
46 #include "options.h"
47 #include "ttyio.h"
48 #include "cipher.h"
49 #include "keydb.h"
50 #include "main.h"
51 #include "i18n.h"
52 #include "status.h"
53
54
55 enum gpga_protocol_codes {
56     /* Request codes */
57     GPGA_PROT_GET_VERSION     = 1,
58     GPGA_PROT_GET_PASSPHRASE  = 2,
59     GPGA_PROT_CLEAR_PASSPHRASE= 3,
60     GPGA_PROT_SHUTDOWN        = 4,
61     GPGA_PROT_FLUSH           = 5,
62
63     /* Reply codes */
64     GPGA_PROT_REPLY_BASE     = 0x10000,
65     GPGA_PROT_OKAY           = 0x10001,
66     GPGA_PROT_GOT_PASSPHRASE = 0x10002,
67
68     /* Error codes */
69     GPGA_PROT_ERROR_BASE     = 0x20000,
70     GPGA_PROT_PROTOCOL_ERROR = 0x20001,
71     GPGA_PROT_INVALID_REQUEST= 0x20002,
72     GPGA_PROT_CANCELED       = 0x20003,    
73     GPGA_PROT_NO_PASSPHRASE  = 0x20004,    
74     GPGA_PROT_BAD_PASSPHRASE = 0x20005,
75     GPGA_PROT_INVALID_DATA   = 0x20006,
76     GPGA_PROT_NOT_IMPLEMENTED= 0x20007,
77     GPGA_PROT_UI_PROBLEM     = 0x20008
78 };
79
80
81 #define buftou32( p )  ((*(byte*)(p) << 24) | (*((byte*)(p)+1)<< 16) | \
82                        (*((byte*)(p)+2) << 8) | (*((byte*)(p)+3)))
83 #define u32tobuf( p, a ) do {                                   \
84                             ((byte*)p)[0] = (byte)((a) >> 24);  \
85                             ((byte*)p)[1] = (byte)((a) >> 16);  \
86                             ((byte*)p)[2] = (byte)((a) >>  8);  \
87                             ((byte*)p)[3] = (byte)((a)      );  \
88                         } while(0)
89
90 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
91 #define hexdigitp(a) (digitp (a)                     \
92                       || (*(a) >= 'A' && *(a) <= 'F')  \
93                       || (*(a) >= 'a' && *(a) <= 'f'))
94 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
95                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
96 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
97
98
99
100 static char *fd_passwd = NULL;
101 static char *next_pw = NULL;
102 static char *last_pw = NULL;
103
104 #if defined (__MINGW32__)
105 static int read_fd = 0;
106 static int write_fd = 0;
107 #endif
108
109 static void hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create );
110
111 int
112 have_static_passphrase()
113 {
114     if ( opt.use_agent )
115         return 0;
116     return !!fd_passwd;
117 }
118
119 /****************
120  * Set the passphrase to be used for the next query and only for the next
121  * one.
122  */
123 void
124 set_next_passphrase( const char *s )
125 {
126     xfree (next_pw);
127     next_pw = NULL;
128     if( s ) {
129         next_pw = gcry_xmalloc_secure ( strlen(s)+1 );
130         strcpy(next_pw, s );
131     }
132 }
133
134 /****************
135  * Get the last passphrase used in passphrase_to_dek.
136  * Note: This removes the passphrase from this modules and
137  * the caller must free the result.  May return NULL:
138  */
139 char *
140 get_last_passphrase()
141 {
142     char *p = last_pw;
143     last_pw = NULL;
144     return p;
145 }
146
147
148 void
149 read_passphrase_from_fd( int fd )
150 {
151   int i, len;
152   char *pw;
153   
154   if ( opt.use_agent ) 
155     { /* Not used but we have to do a dummy read, so that it won't end
156          up at the begin of the message if the quite usual trick to
157          prepend the passphtrase to the message is used. */
158       char buf[1];
159
160       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
161         ;
162       *buf = 0;
163       return; 
164     }
165
166   if (!opt.batch )
167         tty_printf("Reading passphrase from file descriptor %d ...", fd );
168   for (pw = NULL, i = len = 100; ; i++ ) 
169     {
170       if (i >= len-1 ) 
171         {
172           char *pw2 = pw;
173           len += 100;
174           pw = gcry_xmalloc_secure ( len );
175           if( pw2 )
176             memcpy(pw, pw2, i );
177           else
178             i=0;
179         }
180       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
181         break;
182     }
183   pw[i] = 0;
184   if (!opt.batch)
185     tty_printf("\b\b\b   \n" );
186
187   xfree ( fd_passwd );
188   fd_passwd = pw;
189 }
190
191 static int
192 writen ( int fd, const void *buf, size_t nbytes )
193 {
194 #if defined (__MINGW32__)
195     DWORD nwritten, nleft = nbytes;
196     
197     while (nleft > 0) {
198         if ( !WriteFile( (HANDLE)write_fd, buf, nleft, &nwritten, NULL) ) {
199                 log_error("write failed: ec=%d\n", (int)GetLastError());
200                 return -1;
201         }
202         /*log_info("** WriteFile fd=%d nytes=%d nwritten=%d\n",
203                  write_fd, nbytes, (int)nwritten);*/
204         Sleep(100);
205         
206         nleft -= nwritten;
207         buf = (const BYTE *)buf + nwritten;
208     }
209 #elif defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
210     /* not implemented */
211 #else
212     size_t nleft = nbytes;
213     int nwritten;
214
215     while( nleft > 0 ) {
216         nwritten = write( fd, buf, nleft );
217         if( nwritten < 0 ) {
218             if ( errno == EINTR )
219                 nwritten = 0;
220             else {
221                 log_error ( "write() failed: %s\n", strerror (errno) );
222                 return -1;
223             }
224         }
225         nleft -= nwritten;
226         buf = (const char*)buf + nwritten;
227     }
228 #endif
229     
230     return 0;
231 }
232
233
234 static int
235 readn ( int fd, void *buf, size_t buflen, size_t *ret_nread )
236 {
237 #if defined (__MINGW32__)
238     DWORD nread, nleft = buflen;
239     
240     while (nleft > 0) {
241         if ( !ReadFile( (HANDLE)read_fd, buf, nleft, &nread, NULL) ) {
242             log_error("read() error: ec=%d\n", (int)GetLastError());
243             return -1;
244         }
245         if (!nread || GetLastError() == ERROR_BROKEN_PIPE)
246             break;
247         /*log_info("** ReadFile fd=%d buflen=%d nread=%d\n",
248           read_fd, buflen, (int)nread);*/
249         Sleep(100);
250         
251         nleft -= nread;
252         buf = (BYTE *)buf + nread;
253     }           
254     if (ret_nread)
255         *ret_nread = buflen - nleft;
256
257 #elif defined(HAVE_DOSISH_SYSTEM) || defined(__riscos__)
258     /* not implemented */
259 #else
260     size_t nleft = buflen;
261     int nread;
262     char *p;
263
264     p = buf;
265     while( nleft > 0 ) {
266         nread = read ( fd, buf, nleft );
267         if( nread < 0 ) {
268             if (nread == EINTR)
269                 nread = 0;
270             else {
271                 log_error ( "read() error: %s\n", strerror (errno) );
272                 return -1;
273             }
274         }
275         else if( !nread )
276             break; /* EOF */
277         nleft -= nread;
278         buf = (char*)buf + nread;
279     }
280     if( ret_nread )
281         *ret_nread = buflen - nleft;
282 #endif
283     
284     return 0;
285 }
286
287 /* read an entire line */
288 static int
289 readline (int fd, char *buf, size_t buflen)
290 {
291   size_t nleft = buflen;
292   char *p;
293   int nread = 0;
294
295   while (nleft > 0)
296     {
297       int n = read (fd, buf, nleft);
298       if (n < 0)
299         {
300           if (errno == EINTR)
301             continue;
302           return -1; /* read error */
303         }
304       else if (!n)
305         {
306           return -1; /* incomplete line */
307         }
308       p = buf;
309       nleft -= n;
310       buf += n;
311       nread += n;
312       
313       for (; n && *p != '\n'; n--, p++)
314         ;
315       if (n)
316         {
317           break; /* at least one full line available - that's enough.
318                     This function is just a temporary hack until we use
319                     the assuna lib in gpg.  So it is okay to forget
320                     about pending bytes */
321         }
322     }
323
324   return nread; 
325 }
326
327
328
329 #if !defined (__riscos__)
330
331 #if !defined (__MINGW32__)
332 /* For the new Assuan protocol we may have to send options */
333 static int
334 agent_send_option (int fd, const char *name, const char *value)
335 {
336   char buf[200];
337   int nread;
338   char *line;
339   int i; 
340   
341   line = xmalloc (7 + strlen (name) + 1 + strlen (value) + 2);
342   strcpy (stpcpy (stpcpy (stpcpy (
343                      stpcpy (line, "OPTION "), name), "="), value), "\n");
344   i = writen (fd, line, strlen (line));
345   xfree (line);
346   if (i)
347     return -1;
348   
349   /* get response */
350   nread = readline (fd, buf, DIM(buf)-1);
351   if (nread < 3)
352     return -1;
353   
354   if (buf[0] == 'O' && buf[1] == 'K' && (buf[2] == ' ' || buf[2] == '\n')) 
355     return 0; /* okay */
356
357   return -1;
358 }
359
360 static int 
361 agent_send_all_options (int fd)
362 {
363   char *dft_display = NULL;
364   const char *dft_ttyname = NULL;
365   char *dft_ttytype = NULL;
366   char *old_lc = NULL;
367   char *dft_lc = NULL;
368   int rc = 0;
369
370   dft_display = getenv ("DISPLAY");
371   if (opt.display || dft_display)
372     {
373       if (agent_send_option (fd, "display",
374                              opt.display ? opt.display : dft_display))
375         return -1;
376     }
377
378   if (!opt.ttyname)
379     dft_ttyname = tty_get_ttyname ();
380   if (opt.ttyname || dft_ttyname)
381     {
382       if (agent_send_option (fd, "ttyname",
383                              opt.ttyname ? opt.ttyname : dft_ttyname))
384         return -1;
385     }
386
387   dft_ttytype = getenv ("TERM");
388   if (opt.ttytype || (dft_ttyname && dft_ttytype))
389     {
390       if (agent_send_option (fd, "ttytype",
391                              opt.ttyname ? opt.ttytype : dft_ttytype))
392         return -1;
393     }
394
395 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
396   old_lc = setlocale (LC_CTYPE, NULL);
397   if (old_lc)
398     old_lc = xstrdup (old_lc);
399   dft_lc = setlocale (LC_CTYPE, "");
400 #endif
401   if (opt.lc_ctype || (dft_ttyname && dft_lc))
402     {
403       rc = agent_send_option (fd, "lc-ctype",
404                               opt.lc_ctype ? opt.lc_ctype : dft_lc);
405     }
406 #if defined(HAVE_SETLOCALE) && defined(LC_CTYPE)
407   if (old_lc)
408     {
409       setlocale (LC_CTYPE, old_lc);
410       xfree (old_lc);
411     }
412 #endif
413   if (rc)
414     return rc;
415
416 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
417   old_lc = setlocale (LC_MESSAGES, NULL);
418   if (old_lc)
419     old_lc = xstrdup (old_lc);
420   dft_lc = setlocale (LC_MESSAGES, "");
421 #endif
422   if (opt.lc_messages || (dft_ttyname && dft_lc))
423     {
424       rc = agent_send_option (fd, "lc-messages",
425                               opt.lc_messages ? opt.lc_messages : dft_lc);
426     }
427 #if defined(HAVE_SETLOCALE) && defined(LC_MESSAGES)
428   if (old_lc)
429     {
430       setlocale (LC_MESSAGES, old_lc);
431       xfree (old_lc);
432     }
433 #endif
434   return rc;
435 }
436 #endif /*!__MINGW32__*/
437
438
439 /*
440  * Open a connection to the agent and send the magic string
441  * Returns: -1 on error or an filedescriptor for urther processing
442  */
443
444 static int
445 agent_open (int *ret_prot)
446 {
447 #if defined (__MINGW32__)
448     int fd;
449     char *infostr, *p;
450     HANDLE h;
451     char pidstr[128];
452
453     *ret_prot = 0;
454     if ( !(infostr = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
455                                               "agentPID")) 
456          || *infostr == '0') {
457         log_error( _("gpg-agent is not available in this session\n"));
458         return -1;
459     }
460     free(infostr);
461     
462     sprintf(pidstr, "%u", (unsigned int)GetCurrentProcessId());
463     if (write_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
464                                   "agentCID", pidstr)) {
465         log_error( _("can't set client pid for the agent\n") );
466         return -1;
467     }
468     h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
469     SetEvent(h);
470     Sleep(50); /* some time for the server */ 
471     if ( !(p = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
472                                         "agentReadFD")) ) {
473         log_error( _("can't get server read FD for the agent\n") );
474         return -1;
475     }
476     read_fd = atol(p);
477     free(p);    
478     if ( !(p = read_w32_registry_string(NULL, "Software\\GNU\\GnuPG",
479                                         "agentWriteFD")) ) {
480         log_error ( _("can't get server write FD for the agent\n") );
481         return -1;
482     }
483     write_fd = atol(p);
484     free(p);
485     fd = 0;
486
487     if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
488         fd = -1;
489     }
490 #else /* Posix */
491
492     int fd;
493     char *infostr, *p;
494     struct sockaddr_un client_addr;
495     size_t len;
496     int prot;
497
498     if (opt.gpg_agent_info)
499       infostr = xstrdup (opt.gpg_agent_info);
500     else
501       {
502         infostr = getenv ( "GPG_AGENT_INFO" );
503         if ( !infostr ) {
504           log_error (_("gpg-agent is not available in this session\n"));
505           opt.use_agent = 0;
506           return -1;
507         }
508         infostr = xstrdup ( infostr );
509       }
510
511     if ( !(p = strchr ( infostr, ':')) || p == infostr
512          || (p-infostr)+1 >= sizeof client_addr.sun_path ) {
513         log_error( _("malformed GPG_AGENT_INFO environment variable\n"));
514         xfree (infostr );
515         opt.use_agent = 0;
516         return -1;
517     }
518     *p++ = 0;
519     /* See whether this is the new gpg-agent using the Assuna protocl.
520        This agent identifies itself by have an info string with a
521        version number in the 3rd field. */
522     while (*p && *p != ':')
523       p++;
524     prot = *p? atoi (p+1) : 0;
525     if ( prot < 0 || prot > 1) {
526         log_error (_("gpg-agent protocol version %d is not supported\n"),prot);
527         xfree (infostr );
528         opt.use_agent = 0;
529         return -1;
530     }
531     *ret_prot = prot;
532        
533     if( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1 ) {
534         log_error ("can't create socket: %s\n", strerror(errno) );
535         xfree (infostr );
536         opt.use_agent = 0;
537         return -1;
538     }
539     
540     memset( &client_addr, 0, sizeof client_addr );
541     client_addr.sun_family = AF_UNIX;
542     strcpy( client_addr.sun_path, infostr );
543     len = offsetof (struct sockaddr_un, sun_path)
544         + strlen(client_addr.sun_path) + 1;
545     
546     if( connect( fd, (struct sockaddr*)&client_addr, len ) == -1 ) {
547         log_error ( _("can't connect to `%s': %s\n"), 
548                     infostr, strerror (errno) );
549         xfree (infostr );
550         close (fd );
551         opt.use_agent = 0;
552         return -1;
553     }
554     xfree (infostr);
555
556     if (!prot) {
557         if ( writen ( fd, "GPGA\0\0\0\x01", 8 ) ) {
558           close (fd);
559           fd = -1;
560         }
561     }
562     else { /* assuan based gpg-agent */
563       char line[200];
564       int nread;
565
566       nread = readline (fd, line, DIM(line));
567       if (nread < 3 || !(line[0] == 'O' && line[1] == 'K'
568                          && (line[2] == '\n' || line[2] == ' ')) ) {
569         log_error ( _("communication problem with gpg-agent\n"));
570         close (fd );
571         opt.use_agent = 0;
572         return -1;
573       }
574
575       if (agent_send_all_options (fd)) {
576         log_error (_("problem with the agent - disabling agent use\n"));
577         close (fd);
578         opt.use_agent = 0;
579         return -1;
580       }
581         
582     }
583 #endif
584
585     return fd;
586 }
587
588
589 static void
590 agent_close ( int fd )
591 {
592 #if defined (__MINGW32__)
593     HANDLE h = OpenEvent(EVENT_ALL_ACCESS, FALSE, "gpg_agent");
594     ResetEvent(h);
595 #else
596     close (fd);
597 #endif
598 }
599 #endif /* !__riscos__ */
600
601
602
603 /*
604  * Ask the GPG Agent for the passphrase.
605  * Mode 0:  Allow cached passphrase
606  *      1:  No cached passphrase FIXME: Not really implemented
607  *      2:  Ditto, but change the text to "repeat entry"
608  *
609  * Note that TRYAGAIN_TEXT must not be translated.  If canceled is not
610  * NULL, the function does set it to 1 if the user canceled the
611  * operation.
612  */
613 static char *
614 agent_get_passphrase ( u32 *keyid, int mode, const char *tryagain_text,
615                        int *canceled)
616 {
617 #if defined(__riscos__)
618   return NULL;
619 #else
620   size_t n;
621   char *atext = NULL;
622   char buf[50];
623   int fd = -1;
624   int nread;
625   u32 reply;
626   char *pw = NULL;
627   PKT_public_key *pk = xcalloc (1, sizeof *pk );
628   byte fpr[MAX_FINGERPRINT_LEN];
629   int have_fpr = 0;
630   int prot;
631   char *orig_codeset = NULL;
632
633   if (canceled)
634     *canceled = 0;
635
636 #if MAX_FINGERPRINT_LEN < 20
637 #error agent needs a 20 byte fingerprint
638 #endif
639
640   memset (fpr, 0, MAX_FINGERPRINT_LEN );
641   if( keyid && get_pubkey( pk, keyid ) )
642     {
643       free_public_key( pk );      
644       pk = NULL; /* oops: no key for some reason */
645     }
646   
647 #ifdef ENABLE_NLS
648   /* The Assuan agent protol requires us to trasnmit utf-8 strings */
649   orig_codeset = bind_textdomain_codeset (PACKAGE, NULL);
650 #ifdef HAVE_LANGINFO_CODESET
651   if (!orig_codeset)
652     orig_codeset = nl_langinfo (CODESET);
653 #endif
654   if (orig_codeset)
655     { /* We only switch when we are able to restore the codeset later. */
656       orig_codeset = xstrdup (orig_codeset);
657       if (!bind_textdomain_codeset (PACKAGE, "utf-8"))
658         orig_codeset = NULL; 
659     }
660 #endif
661
662   if ( (fd = agent_open (&prot)) == -1 ) 
663     goto failure;
664
665   if ( !mode && pk && keyid )
666     { 
667       char *uid;
668       size_t uidlen;
669       const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
670       const char *timestr;
671       char *maink;
672       const char *fmtstr;
673       
674       if ( !algo_name )
675         algo_name = "?";
676       
677       fmtstr = _(" (main key ID %08lX)");
678       maink = xmalloc ( strlen (fmtstr) + 20 );
679       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
680           && keyid[1] != keyid[3] )
681         sprintf( maink, fmtstr, (ulong)keyid[3] );
682       else
683         *maink = 0;
684       
685       uid = get_user_id ( keyid, &uidlen ); 
686       timestr = strtimestamp (pk->timestamp);
687       fmtstr = _("You need a passphrase to unlock the"
688                  " secret key for user:\n"
689                  "\"%.*s\"\n"
690                  "%u-bit %s key, ID %08lX, created %s%s\n" );
691       atext = xmalloc ( 100 + strlen (fmtstr)  
692                         + uidlen + 15 + strlen(algo_name) + 8
693                         + strlen (timestr) + strlen (maink) );
694       sprintf (atext, fmtstr,
695                uidlen, uid,
696                nbits_from_pk (pk), algo_name, (ulong)keyid[1], timestr,
697                maink  );
698       xfree (uid);
699       xfree (maink);
700       
701       { 
702         size_t dummy;
703         fingerprint_from_pk( pk, fpr, &dummy );
704         have_fpr = 1;
705       }
706       
707     }
708   else if (mode == 2 ) 
709     atext = xstrdup ( _("Repeat passphrase\n") );
710   else
711     atext = xstrdup ( _("Enter passphrase\n") );
712                 
713   if (!prot)
714     { /* old style protocol */
715       n = 4 + 20 + strlen (atext);
716       u32tobuf (buf, n );
717       u32tobuf (buf+4, GPGA_PROT_GET_PASSPHRASE );
718       memcpy (buf+8, fpr, 20 );
719       if ( writen ( fd, buf, 28 ) || writen ( fd, atext, strlen (atext) ) ) 
720         goto failure;
721       xfree (atext); atext = NULL;
722       
723       /* get response */
724       if ( readn ( fd, buf, 12, &nread ) ) 
725         goto failure;
726       
727       if ( nread < 8 ) 
728         {
729           log_error ( "response from agent too short\n" );
730           goto failure;
731         }
732       n = buftou32 ( buf );
733       reply = buftou32 ( buf + 4 );
734       if ( reply == GPGA_PROT_GOT_PASSPHRASE ) 
735         {
736           size_t pwlen;
737           size_t nn;
738           
739           if ( nread < 12 || n < 8 ) 
740             {
741               log_error ( "response from agent too short\n" );
742               goto failure;
743             }
744           pwlen = buftou32 ( buf + 8 );
745           nread -= 12;
746           n -= 8;
747           if ( pwlen > n || n > 1000 ) 
748             {
749               log_error (_("passphrase too long\n"));
750               /* or protocol error */
751               goto failure;
752             }
753           /* we read the whole block in one chunk to give no hints
754            * on how long the passhrase actually is - this wastes some bytes
755            * but because we already have this padding we should not loosen
756            * this by issuing 2 read calls */
757           pw = xmalloc_secure ( n+1 );
758           if ( readn ( fd, pw, n, &nn ) )
759             goto failure;
760           if ( n != nn ) 
761             {
762               log_error (_("invalid response from agent\n"));
763               goto failure;           
764             }
765           pw[pwlen] = 0; /* make a C String */
766           agent_close (fd);
767           free_public_key( pk );
768 #ifdef ENABLE_NLS
769           if (orig_codeset)
770             bind_textdomain_codeset (PACKAGE, orig_codeset);
771 #endif
772           xfree (orig_codeset);
773           return pw;
774         }
775       else if ( reply == GPGA_PROT_CANCELED ) 
776         {
777           log_info ( _("cancelled by user\n") );
778           if (canceled)
779             *canceled = 1;
780         }
781       else 
782         log_error ( _("problem with the agent: agent returns 0x%lx\n"),
783                     (ulong)reply );
784     }
785   else
786     { /* The new Assuan protocol */
787       char *line, *p;
788       const unsigned char *s;
789       int i; 
790
791       if (!tryagain_text)
792         tryagain_text = "X";
793       else
794         tryagain_text = _(tryagain_text);
795
796       /* We allocate 2 time the needed space for atext so that there
797          is nenough space for escaping */
798       line = xmalloc (15 + 46 
799                       +  3*strlen (tryagain_text) + 3*strlen (atext) + 2);
800       strcpy (line, "GET_PASSPHRASE ");
801       p = line+15;
802       if (!mode && have_fpr)
803         {
804           for (i=0; i < 20; i++, p +=2 )
805             sprintf (p, "%02X", fpr[i]);
806         }
807       else
808         *p++ = 'X'; /* no caching */
809       *p++ = ' ';
810       for (i=0, s=tryagain_text; *s; s++)
811         {
812           if (*s < ' ' || *s == '+')
813             {
814               sprintf (p, "%%%02X", *s);
815               p += 3;
816             }
817           else if (*s == ' ')
818             *p++ = '+';
819           else
820             *p++ = *s;
821         }
822       *p++ = ' ';
823       *p++ = 'X'; /* Use the standard prompt */
824       *p++ = ' ';
825       /* copy description */
826       for (i=0, s= atext; *s; s++)
827         {
828           if (*s < ' ' || *s == '+')
829             {
830               sprintf (p, "%%%02X", *s);
831               p += 3;
832             }
833           else if (*s == ' ')
834             *p++ = '+';
835           else
836             *p++ = *s;
837         }
838       *p++ = '\n';
839       i = writen (fd, line, p - line);
840       xfree (line);
841       if (i)
842         goto failure;
843       xfree (atext); atext = NULL;
844       
845       /* get response */
846       pw = xmalloc_secure (500);
847       nread = readline (fd, pw, 499);
848       if (nread < 3)
849         goto failure;
850       
851       if (pw[0] == 'O' && pw[1] == 'K' && pw[2] == ' ') 
852         { /* we got a passphrase - convert it back from hex */
853           size_t pwlen = 0;
854
855           for (i=3; i < nread && hexdigitp (pw+i); i+=2)
856             pw[pwlen++] = xtoi_2 (pw+i);
857           pw[pwlen] = 0; /* make a C String */
858           agent_close (fd);
859           free_public_key( pk );
860 #ifdef ENABLE_NLS
861           if (orig_codeset)
862             bind_textdomain_codeset (PACKAGE, orig_codeset);
863 #endif
864           xfree (orig_codeset);
865           return pw;
866         }
867       else if (nread > 7 && !memcmp (pw, "ERR 111", 7)
868                && (pw[7] == ' ' || pw[7] == '\n') ) 
869         {
870           log_info (_("cancelled by user\n") );
871           if (canceled)
872             *canceled = 1;
873         }
874       else 
875         {
876           log_error (_("problem with the agent - disabling agent use\n"));
877           opt.use_agent = 0;
878         }
879     }
880       
881         
882  failure:
883 #ifdef ENABLE_NLS
884   if (orig_codeset)
885     bind_textdomain_codeset (PACKAGE, orig_codeset);
886 #endif
887   xfree (atext);
888   if ( fd != -1 )
889     agent_close (fd);
890   xfree (pw );
891   free_public_key( pk );
892   
893   return NULL;
894 #endif /* Posix or W32 */
895 }
896
897 /*
898  * Clear the cached passphrase
899  */
900 void
901 passphrase_clear_cache ( u32 *keyid, int algo )
902 {
903 #if defined(__riscos__)
904   return ;
905 #else
906   size_t n;
907   char buf[200];
908   int fd = -1;
909   size_t nread;
910   u32 reply;
911   PKT_public_key *pk;
912   byte fpr[MAX_FINGERPRINT_LEN];
913   int prot;
914   
915 #if MAX_FINGERPRINT_LEN < 20
916 #error agent needs a 20 byte fingerprint
917 #endif
918     
919   if (!opt.use_agent)
920     return;
921   
922   pk = xcalloc (1, sizeof *pk );
923   memset (fpr, 0, MAX_FINGERPRINT_LEN );
924   if( !keyid || get_pubkey( pk, keyid ) )
925     {
926       log_debug ("oops, no key in passphrase_clear_cache\n");
927       goto failure; /* oops: no key for some reason */
928     }
929   
930   {
931     size_t dummy;
932     fingerprint_from_pk( pk, fpr, &dummy );
933   }
934     
935   if ( (fd = agent_open (&prot)) == -1 ) 
936     goto failure;
937
938   if (!prot)
939     {
940       n = 4 + 20;
941       u32tobuf (buf, n );
942       u32tobuf (buf+4, GPGA_PROT_CLEAR_PASSPHRASE );
943       memcpy (buf+8, fpr, 20 );
944       if ( writen ( fd, buf, 28 ) )  
945         goto failure;
946       
947       /* get response */
948       if ( readn ( fd, buf, 8, &nread ) ) 
949         goto failure;
950       
951       if ( nread < 8 ) {
952         log_error ( "response from agent too short\n" );
953         goto failure;
954       }
955       
956       reply = buftou32 ( buf + 4 );
957       if ( reply != GPGA_PROT_OKAY && reply != GPGA_PROT_NO_PASSPHRASE )
958         {
959           log_error ( _("problem with the agent: agent returns 0x%lx\n"),
960                       (ulong)reply );
961         }
962     }
963   else 
964     { /* The assuan protocol */
965       char *line, *p;
966       int i; 
967
968       line = xmalloc (17 + 40 + 2);
969       strcpy (line, "CLEAR_PASSPHRASE ");
970       p = line+17;
971       for (i=0; i < 20; i++, p +=2 )
972         sprintf (p, "%02X", fpr[i]);
973       *p++ = '\n';
974       i = writen (fd, line, p - line);
975       xfree (line);
976       if (i)
977         goto failure;
978       
979       /* get response */
980       nread = readline (fd, buf, DIM(buf)-1);
981       if (nread < 3)
982         goto failure;
983       
984       if (buf[0] == 'O' && buf[1] == 'K' && (buf[2] == ' ' || buf[2] == '\n')) 
985         ;
986       else 
987         {
988           log_error (_("problem with the agent - disabling agent use\n"));
989           opt.use_agent = 0;
990         }
991     }
992         
993  failure:
994   if (fd != -1)
995     agent_close (fd);
996   free_public_key( pk );
997 #endif /* Posix or W32 */
998 }
999
1000
1001
1002
1003 /****************
1004  * Get a passphrase for the secret key with KEYID, display TEXT
1005  * if the user needs to enter the passphrase.
1006  * mode 0 = standard, 1 = same but don't show key info,
1007  *      2 = create new passphrase
1008  * Returns: a DEK with a session key; caller must free
1009  *          or NULL if the passphrase was not correctly repeated.
1010  *          (only for mode 2)
1011  *          a dek->keylen of 0 means: no passphrase entered.
1012  *          (only for mode 2)
1013  *
1014  * pubkey_algo is only informational.  Note that TRYAGAIN_TEXT must
1015  * not be translated as this is done within this function (required to
1016  * switch to utf-8 when the agent is in use).  If CANCELED is not
1017  * NULL, it is set to 1 if the user choosed to cancel the operation,
1018  * otherwise it will be set to 0.
1019  */
1020 DEK *
1021 passphrase_to_dek( u32 *keyid, int pubkey_algo,
1022                    int cipher_algo, STRING2KEY *s2k, int mode,
1023                    const char *tryagain_text, int *canceled)
1024 {
1025     char *pw = NULL;
1026     DEK *dek;
1027     STRING2KEY help_s2k;
1028
1029     if (canceled)
1030       *canceled = 0;
1031
1032     if( !s2k ) {
1033         /* This is used for the old rfc1991 mode 
1034          * Note: This must match the code in encode.c with opt.rfc1991 set */
1035         s2k = &help_s2k;
1036         s2k->mode = 0;
1037         s2k->hash_algo = opt.s2k_digest_algo;
1038     }
1039
1040     if( !next_pw && is_status_enabled() ) {
1041         char buf[50];
1042
1043         if( keyid ) {
1044             u32 used_kid[2];
1045             char *us;
1046
1047             if( keyid[2] && keyid[3] ) {
1048                 used_kid[0] = keyid[2];
1049                 used_kid[1] = keyid[3];
1050             }
1051             else {
1052                 used_kid[0] = keyid[0];
1053                 used_kid[1] = keyid[1];
1054             }
1055
1056             us = get_long_user_id_string( keyid );
1057             write_status_text( STATUS_USERID_HINT, us );
1058             xfree (us);
1059
1060             sprintf( buf, "%08lX%08lX %08lX%08lX %d 0",
1061                      (ulong)keyid[0], (ulong)keyid[1],
1062                      (ulong)used_kid[0], (ulong)used_kid[1],
1063                      pubkey_algo );
1064                      
1065             write_status_text( STATUS_NEED_PASSPHRASE, buf );
1066         }
1067         else {
1068             sprintf( buf, "%d %d %d", cipher_algo, s2k->mode, s2k->hash_algo );
1069             write_status_text( STATUS_NEED_PASSPHRASE_SYM, buf );
1070         }
1071     }
1072
1073     if( keyid && !opt.batch && !next_pw && mode!=1 ) {
1074         PKT_public_key *pk = xcalloc (1, sizeof *pk );
1075         size_t n;
1076         char *p;
1077
1078         tty_printf(_("\nYou need a passphrase to unlock the secret key for\n"
1079                      "user: \"") );
1080         p = get_user_id( keyid, &n );
1081         tty_print_utf8_string( p, n );
1082         xfree (p);
1083         tty_printf("\"\n");
1084
1085         if( !get_pubkey( pk, keyid ) ) {
1086             const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
1087             tty_printf( _("%u-bit %s key, ID %08lX, created %s"),
1088                        nbits_from_pk( pk ), s?s:"?", (ulong)keyid[1],
1089                        strtimestamp(pk->timestamp) );
1090             if( keyid[2] && keyid[3] && keyid[0] != keyid[2]
1091                                      && keyid[1] != keyid[3] )
1092                 tty_printf( _(" (main key ID %08lX)"), (ulong)keyid[3] );
1093             tty_printf("\n");
1094         }
1095
1096         tty_printf("\n");
1097         free_public_key( pk );
1098     }
1099
1100  agent_died:
1101     if( next_pw ) {
1102         pw = next_pw;
1103         next_pw = NULL;
1104     }
1105     else if ( opt.use_agent ) {
1106         pw = agent_get_passphrase ( keyid, mode == 2? 1: 0,
1107                                     tryagain_text, canceled );
1108         if (!pw)
1109           {
1110             if (!opt.use_agent)
1111               goto agent_died;
1112             pw = xstrdup ("");
1113           }
1114         if( *pw && mode == 2 ) {
1115             char *pw2 = agent_get_passphrase ( keyid, 2, NULL, canceled );
1116             if (!pw2)
1117               {
1118                 if (!opt.use_agent)
1119                   {
1120                     xfree (pw);
1121                     pw = NULL;
1122                     goto agent_died;
1123                   }
1124                 pw2 = xstrdup ("");
1125               }
1126             if( strcmp(pw, pw2) ) {
1127                 xfree (pw2);
1128                 xfree (pw);
1129                 return NULL;
1130             }
1131             xfree (pw2);
1132         }
1133     }
1134     else if( fd_passwd ) {
1135         pw = xmalloc_secure ( strlen(fd_passwd)+1 );
1136         strcpy( pw, fd_passwd );
1137     }
1138     else if( opt.batch ) {
1139         log_error(_("can't query password in batchmode\n"));
1140         pw = xstrdup ( "" ); /* return an empty passphrase */
1141     }
1142     else {
1143         pw = cpr_get_hidden("passphrase.enter", _("Enter passphrase: ") );
1144         tty_kill_prompt();
1145         if( mode == 2 && !cpr_enabled() ) {
1146             char *pw2 = cpr_get_hidden("passphrase.repeat",
1147                                        _("Repeat passphrase: ") );
1148             tty_kill_prompt();
1149             if( strcmp(pw, pw2) ) {
1150                 xfree (pw2);
1151                 xfree (pw);
1152                 return NULL;
1153             }
1154             xfree (pw2);
1155         }
1156     }
1157
1158     if( !pw || !*pw )
1159         write_status( STATUS_MISSING_PASSPHRASE );
1160
1161     dek = xcalloc_secure (1, sizeof *dek );
1162     dek->algo = cipher_algo;
1163     if( !*pw && mode == 2 )
1164         dek->keylen = 0;
1165     else
1166         hash_passphrase( dek, pw, s2k, mode==2 );
1167     xfree (last_pw);
1168     last_pw = pw;
1169     return dek;
1170 }
1171
1172
1173 /****************
1174  * Hash a passphrase using the supplied s2k. If create is true, create
1175  * a new salt or what else must be filled into the s2k for a new key.
1176  * always needs: dek->algo, s2k->mode, s2k->hash_algo.
1177  */
1178 static void
1179 hash_passphrase( DEK *dek, char *pw, STRING2KEY *s2k, int create )
1180 {
1181     MD_HANDLE md;
1182     int pass, i;
1183     int used = 0;
1184     int pwlen = strlen(pw);
1185
1186     assert( s2k->hash_algo );
1187     dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
1188     if( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
1189         BUG();
1190
1191     gcry_md_open (&md, s2k->hash_algo, 1);
1192     for(pass=0; used < dek->keylen ; pass++ ) {
1193         if( pass ) {
1194             gcry_md_reset(md);
1195             for(i=0; i < pass; i++ ) /* preset the hash context */
1196                 gcry_md_putc (md, 0 );
1197         }
1198
1199         if( s2k->mode == 1 || s2k->mode == 3 ) {
1200             int len2 = pwlen + 8;
1201             ulong count = len2;
1202
1203             if( create && !pass ) {
1204                 gcry_randomize(s2k->salt, 8, GCRY_STRONG_RANDOM );
1205                 if( s2k->mode == 3 )
1206                     s2k->count = 96; /* 65536 iterations */
1207             }
1208
1209             if( s2k->mode == 3 ) {
1210                 count = (16ul + (s2k->count & 15)) << ((s2k->count >> 4) + 6);
1211                 if( count < len2 )
1212                     count = len2;
1213             }
1214             /* a little bit complicated because we need a ulong for count */
1215             while( count > len2 ) { /* maybe iterated+salted */
1216                 gcry_md_write( md, s2k->salt, 8 );
1217                 gcry_md_write( md, pw, pwlen );
1218                 count -= len2;
1219             }
1220             if( count < 8 )
1221                 gcry_md_write( md, s2k->salt, count );
1222             else {
1223                 gcry_md_write( md, s2k->salt, 8 );
1224                 count -= 8;
1225                 gcry_md_write( md, pw, count );
1226             }
1227         }
1228         else
1229             gcry_md_write( md, pw, pwlen );
1230         gcry_md_final ( md );
1231         i = gcry_md_get_algo_dlen (s2k->hash_algo);
1232         if( i > dek->keylen - used )
1233             i = dek->keylen - used;
1234         memcpy( dek->key+used, gcry_md_read (md, s2k->hash_algo), i );
1235         used += i;
1236     }
1237     gcry_md_close (md);
1238 }
1239