Fix APDU buffer problem under MAC OS.
[gnupg.git] / g10 / passphrase.c
1 /* passphrase.c -  Get a passphrase
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005, 2006, 2007 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
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 #include <errno.h>
29 #ifdef HAVE_LOCALE_H
30 #include <locale.h>
31 #endif
32 #ifdef HAVE_LANGINFO_CODESET
33 #include <langinfo.h>
34 #endif
35
36 #include "gpg.h"
37 #include "util.h"
38 #include "options.h"
39 #include "ttyio.h"
40 #include "cipher.h"
41 #include "keydb.h"
42 #include "main.h"
43 #include "i18n.h"
44 #include "status.h"
45 #include "call-agent.h"
46
47
48 static char *fd_passwd = NULL;
49 static char *next_pw = NULL;
50 static char *last_pw = NULL;
51
52
53 /* Hash a passphrase using the supplied s2k. If create is true, create
54    a new salt or what else must be filled into the s2k for a new key.
55    always needs: dek->algo, s2k->mode, s2k->hash_algo.  */
56 static void
57 hash_passphrase ( DEK *dek, char *pw, STRING2KEY *s2k, int create )
58 {
59   gcry_md_hd_t md;
60   int pass, i;
61   int used = 0;
62   int pwlen = strlen(pw);
63
64   assert ( s2k->hash_algo );
65   dek->keylen = gcry_cipher_get_algo_keylen (dek->algo);
66   if ( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
67     BUG();
68
69   if (gcry_md_open (&md, s2k->hash_algo, 1))
70     BUG ();
71   for (pass=0; used < dek->keylen ; pass++ ) 
72     {
73       if ( pass ) 
74         {
75           gcry_md_reset (md);
76           for (i=0; i < pass; i++ ) /* Preset the hash context.  */
77             gcry_md_putc (md, 0 );
78         }
79
80       if ( s2k->mode == 1 || s2k->mode == 3 ) 
81         {
82           int len2 = pwlen + 8;
83           ulong count = len2;
84           
85           if ( create && !pass )
86             {
87               gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
88               if ( s2k->mode == 3 )
89                 s2k->count = opt.s2k_count;
90             }
91
92           if ( s2k->mode == 3 )
93             {
94               count = S2K_DECODE_COUNT(s2k->count);
95               if ( count < len2 )
96                 count = len2;
97             }
98
99           /* A little bit complicated because we need a ulong for count. */
100           while ( count > len2 )  /* maybe iterated+salted */
101             { 
102               gcry_md_write ( md, s2k->salt, 8 );
103               gcry_md_write ( md, pw, pwlen );
104               count -= len2;
105             }
106           if ( count < 8 )
107             gcry_md_write ( md, s2k->salt, count );
108           else
109             {
110               gcry_md_write ( md, s2k->salt, 8 );
111               count -= 8;
112               gcry_md_write ( md, pw, count );
113             }
114         }
115       else
116         gcry_md_write ( md, pw, pwlen );
117       gcry_md_final( md );
118
119       i = gcry_md_get_algo_dlen ( s2k->hash_algo );
120       if ( i > dek->keylen - used )
121         i = dek->keylen - used;
122
123       memcpy (dek->key+used, gcry_md_read (md, s2k->hash_algo), i);
124       used += i;
125     }
126   gcry_md_close(md);
127 }
128
129
130
131 int
132 have_static_passphrase()
133 {
134   return !!fd_passwd && opt.batch;
135 }
136
137 /****************
138  * Set the passphrase to be used for the next query and only for the next
139  * one.
140  */
141 void
142 set_next_passphrase( const char *s )
143 {
144   xfree(next_pw);
145   next_pw = NULL;
146   if ( s )
147     {
148       next_pw = xmalloc_secure( strlen(s)+1 );
149       strcpy (next_pw, s );
150     }
151 }
152
153 /****************
154  * Get the last passphrase used in passphrase_to_dek.
155  * Note: This removes the passphrase from this modules and
156  * the caller must free the result.  May return NULL:
157  */
158 char *
159 get_last_passphrase()
160 {
161   char *p = last_pw;
162   last_pw = NULL;
163   return p;
164 }
165
166 /* As if we had used the passphrase - make it the last_pw. */
167 void
168 next_to_last_passphrase(void)
169 {
170   if (next_pw)
171     {
172       last_pw=next_pw;
173       next_pw=NULL;
174     }
175 }
176
177 /* Here's an interesting question: since this passphrase was passed in
178    on the command line, is there really any point in using secure
179    memory for it?  I'm going with 'yes', since it doesn't hurt, and
180    might help in some small way (swapping). */
181
182 void
183 set_passphrase_from_string(const char *pass)
184 {
185   xfree (fd_passwd);
186   fd_passwd = xmalloc_secure(strlen(pass)+1);
187   strcpy (fd_passwd, pass);
188 }
189
190
191 void
192 read_passphrase_from_fd( int fd )
193 {
194   int i, len;
195   char *pw;
196
197   if ( !opt.batch ) 
198     { /* Not used but we have to do a dummy read, so that it won't end
199          up at the begin of the message if the quite usual trick to
200          prepend the passphtrase to the message is used. */
201       char buf[1];
202
203       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
204         ;
205       *buf = 0;
206       return; 
207     }
208
209   for (pw = NULL, i = len = 100; ; i++ ) 
210     {
211       if (i >= len-1 ) 
212         {
213           char *pw2 = pw;
214           len += 100;
215           pw = xmalloc_secure( len );
216           if( pw2 )
217             {
218               memcpy(pw, pw2, i );
219               xfree (pw2);
220             }
221           else
222             i=0;
223         }
224       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
225         break;
226     }
227   pw[i] = 0;
228   if (!opt.batch)
229     tty_printf("\b\b\b   \n" );
230
231   xfree ( fd_passwd );
232   fd_passwd = pw;
233 }
234
235
236 /*
237  * Ask the GPG Agent for the passphrase.
238  * Mode 0:  Allow cached passphrase
239  *      1:  No cached passphrase FIXME: Not really implemented
240  *      2:  Ditto, but change the text to "repeat entry"
241  *
242  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
243  * NULL, the function does set it to 1 if the user canceled the
244  * operation.  If CACHEID is not NULL, it will be used as the cacheID
245  * for the gpg-agent; if is NULL and a key fingerprint can be
246  * computed, this will be used as the cacheid.
247  */
248 static char *
249 passphrase_get ( u32 *keyid, int mode, const char *cacheid,
250                  const char *tryagain_text,
251                  const char *custom_description,
252                  const char *custom_prompt, int *canceled)
253 {
254   int rc;
255   char *atext = NULL;
256   char *pw = NULL;
257   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
258   byte fpr[MAX_FINGERPRINT_LEN];
259   int have_fpr = 0;
260   char *orig_codeset;
261   char *my_prompt;
262   char hexfprbuf[20*2+1];
263   const char *my_cacheid;
264
265   if (canceled)
266     *canceled = 0;
267
268 #if MAX_FINGERPRINT_LEN < 20
269 #error agent needs a 20 byte fingerprint
270 #endif
271
272   memset (fpr, 0, MAX_FINGERPRINT_LEN );
273   if( keyid && get_pubkey( pk, keyid ) )
274     {
275       if (pk)
276         free_public_key( pk );      
277       pk = NULL; /* oops: no key for some reason */
278     }
279   
280   orig_codeset = i18n_switchto_utf8 ();
281
282   if (custom_description)
283     atext = native_to_utf8 (custom_description);
284   else if ( !mode && pk && keyid )
285     { 
286       char *uid;
287       size_t uidlen;
288       const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
289       const char *timestr;
290       char *maink;
291       
292       if ( !algo_name )
293         algo_name = "?";
294
295 #define KEYIDSTRING _(" (main key ID %s)")
296
297       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
298       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
299           && keyid[1] != keyid[3] )
300         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
301       else
302         *maink = 0;
303       
304       uid = get_user_id ( keyid, &uidlen ); 
305       timestr = strtimestamp (pk->timestamp);
306
307 #undef KEYIDSTRING
308
309 #define PROMPTSTRING _("Please enter the passphrase to unlock the" \
310                        " secret key for the OpenPGP certificate:\n" \
311                        "\"%.*s\"\n" \
312                        "%u-bit %s key, ID %s,\n" \
313                        "created %s%s.\n" )
314
315       atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
316                         + uidlen + 15 + strlen(algo_name) + keystrlen()
317                         + strlen (timestr) + strlen (maink) );
318       sprintf (atext, PROMPTSTRING,
319                (int)uidlen, uid,
320                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
321                maink  );
322       xfree (uid);
323       xfree (maink);
324
325 #undef PROMPTSTRING
326
327       { 
328         size_t dummy;
329         fingerprint_from_pk( pk, fpr, &dummy );
330         have_fpr = 1;
331       }
332       
333     }
334   else if (mode == 2 ) 
335     atext = xstrdup ( _("Repeat passphrase\n") );
336   else
337     atext = xstrdup ( _("Enter passphrase\n") );
338                 
339
340   if (!mode && cacheid)
341     my_cacheid = cacheid;
342   else if (!mode && have_fpr)
343     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
344   else
345     my_cacheid = NULL;
346
347   if (tryagain_text)
348     tryagain_text = _(tryagain_text);
349
350   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
351
352   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext, &pw);
353   
354   xfree (my_prompt);
355   xfree (atext); atext = NULL;
356
357   i18n_switchback (orig_codeset);
358
359
360   if (!rc)
361     ;
362   else if ( gpg_err_code (rc) == GPG_ERR_CANCELED )
363     {
364       log_info (_("cancelled by user\n") );
365       if (canceled)
366         *canceled = 1;
367     }
368   else 
369     {
370       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
371       /* Due to limitations in the API of the upper layers they
372          consider an error as no passphrase entered.  This works in
373          most cases but not during key creation where this should
374          definitely not happen and let it continue without requiring a
375          passphrase.  Given that now all the upper layers handle a
376          cancel correctly, we simply set the cancel flag now for all
377          errors from the agent.  */ 
378       if (canceled)
379         *canceled = 1;
380     }
381
382   if (pk)
383     free_public_key( pk );
384   if (rc)
385     {
386       xfree (pw);
387       return NULL;
388     }
389   return pw;
390 }
391
392
393 /*
394  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
395  * used instead of a cache ID derived from KEYID.
396  */
397 void
398 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
399 {
400   int rc;
401     
402   if (!cacheid)
403     {
404       PKT_public_key *pk;
405 #     if MAX_FINGERPRINT_LEN < 20
406 #       error agent needs a 20 byte fingerprint
407 #     endif
408       byte fpr[MAX_FINGERPRINT_LEN];
409       char hexfprbuf[2*20+1];
410       size_t dummy;
411       
412       pk = xcalloc (1, sizeof *pk);
413       if ( !keyid || get_pubkey( pk, keyid ) )
414         {
415           log_error ("key not found in passphrase_clear_cache\n");
416           free_public_key (pk);
417           return;
418         }
419       memset (fpr, 0, MAX_FINGERPRINT_LEN );
420       fingerprint_from_pk ( pk, fpr, &dummy );
421       bin2hex (fpr, 20, hexfprbuf);
422       rc = agent_clear_passphrase (hexfprbuf);
423       free_public_key ( pk );
424     }
425   else
426     rc = agent_clear_passphrase (cacheid);
427
428   if (rc)
429     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
430 }
431
432
433 /****************
434  * Ask for a passphrase and return that string.
435  */
436 char *
437 ask_passphrase (const char *description,
438                 const char *tryagain_text,
439                 const char *promptid,
440                 const char *prompt,
441                 const char *cacheid, int *canceled)
442 {
443   char *pw = NULL;
444   
445   if (canceled)
446     *canceled = 0;
447
448   if (!opt.batch && description)
449     {
450       if (strchr (description, '%'))
451         {
452           char *tmp = unescape_percent_string
453             ((const unsigned char*)description);
454           tty_printf ("\n%s\n", tmp);
455           xfree (tmp);
456         }
457       else
458         tty_printf ("\n%s\n",description);
459     }
460                
461   if (have_static_passphrase ()) 
462     {
463       pw = xmalloc_secure (strlen(fd_passwd)+1);
464       strcpy (pw, fd_passwd);
465     }
466   else
467     pw = passphrase_get (NULL, 0, cacheid,
468                          tryagain_text, description, prompt,
469                          canceled );
470
471   if (!pw || !*pw)
472     write_status( STATUS_MISSING_PASSPHRASE );
473
474   return pw;
475 }
476
477
478 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
479    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
480    selected to cancel the passphrase entry and if CANCELED is not
481    NULL, sets it to true.
482
483    MODE 0:  Allow cached passphrase
484         1:  Ignore cached passphrase 
485         2:  Ditto, but change the text to "repeat entry"
486 */
487 DEK *
488 passphrase_to_dek (u32 *keyid, int pubkey_algo,
489                    int cipher_algo, STRING2KEY *s2k, int mode,
490                    const char *tryagain_text, int *canceled)
491 {
492   char *pw = NULL;
493   DEK *dek;
494   STRING2KEY help_s2k;
495   int dummy_canceled;
496
497   if (!canceled)
498     canceled = &dummy_canceled;
499   *canceled = 0;
500   
501   if ( !s2k )
502     {
503       /* This is used for the old rfc1991 mode 
504        * Note: This must match the code in encode.c with opt.rfc1991 set */
505       s2k = &help_s2k;
506       s2k->mode = 0;
507       s2k->hash_algo = S2K_DIGEST_ALGO;
508     }
509
510   /* If we do not have a passphrase available in NEXT_PW and status
511      information are request, we print them now. */
512   if ( !next_pw && is_status_enabled() ) 
513     {
514       char buf[50];
515       
516       if ( keyid )
517         {
518           u32 used_kid[2];
519           char *us;
520           
521           if ( keyid[2] && keyid[3] ) 
522             {
523               used_kid[0] = keyid[2];
524               used_kid[1] = keyid[3];
525             }
526           else
527             {
528               used_kid[0] = keyid[0];
529               used_kid[1] = keyid[1];
530             }
531           
532           us = get_long_user_id_string ( keyid );
533           write_status_text ( STATUS_USERID_HINT, us );
534           xfree(us);
535           
536           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
537                     (ulong)keyid[0], (ulong)keyid[1],
538                     (ulong)used_kid[0], (ulong)used_kid[1],
539                     pubkey_algo );
540           
541           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
542         }
543       else
544         {
545           snprintf (buf, sizeof buf -1, "%d %d %d",
546                     cipher_algo, s2k->mode, s2k->hash_algo );
547           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
548         }
549     }
550
551   /* If we do have a keyID, we do not have a passphrase available in
552      NEXT_PW, we are not running in batch mode and we do not want to
553      ignore the passphrase cache (mode!=1), print a prompt with
554      information on that key. */
555   if ( keyid && !opt.batch && !next_pw && mode!=1 )
556     {
557       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
558       char *p;
559       
560       p = get_user_id_native(keyid);
561       tty_printf ("\n");
562       tty_printf (_("You need a passphrase to unlock the secret key for\n"
563                     "user: \"%s\"\n"),p);
564       xfree(p);
565
566       if ( !get_pubkey( pk, keyid ) )
567         {
568           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
569           
570           tty_printf (_("%u-bit %s key, ID %s, created %s"),
571                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
572                       strtimestamp(pk->timestamp) );
573           if ( keyid[2] && keyid[3]
574                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
575             {
576               if ( keystrlen () > 10 )
577                 {
578                   tty_printf ("\n");
579                   tty_printf (_("         (subkey on main key ID %s)"),
580                               keystr(&keyid[2]) );
581                 }
582               else
583                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
584             }
585           tty_printf("\n");
586         }
587
588       tty_printf("\n");
589       if (pk)
590         free_public_key( pk );
591     }
592
593   if ( next_pw ) 
594     {
595       /* Simply return the passphrase we already have in NEXT_PW. */
596       pw = next_pw;
597       next_pw = NULL;
598     }
599   else if ( have_static_passphrase () ) 
600     {
601       /* Return the passphrase we have stored in FD_PASSWD. */
602       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
603       strcpy ( pw, fd_passwd );
604     }
605   else 
606     {
607       /* Divert to the gpg-agent. */
608       pw = passphrase_get ( keyid, mode == 2? 1: 0, NULL,
609                             tryagain_text, NULL, NULL, canceled );
610       if (*canceled)
611         {
612           xfree (pw);
613           write_status( STATUS_MISSING_PASSPHRASE );
614           return NULL;
615         }
616       if (!pw)
617         pw = xstrdup ("");
618       if ( *pw && mode == 2 )
619         {
620           int i;
621           for(i=0;i<opt.passwd_repeat;i++)
622             {
623               char *pw2 = passphrase_get ( keyid, 2, NULL, NULL, NULL,
624                                            NULL, canceled );
625               if (*canceled)
626                 {
627                   xfree (pw);
628                   xfree (pw2);
629                   write_status( STATUS_MISSING_PASSPHRASE );
630                   return NULL;
631                 }
632               if (!pw2)
633                 pw2 = xstrdup ("");
634               if ( strcmp(pw, pw2) )
635                 {
636                   xfree(pw2);
637                   xfree(pw);
638                   return NULL;
639                 }
640               xfree(pw2);
641             }
642         }
643     }
644     
645   if ( !pw || !*pw )
646     write_status( STATUS_MISSING_PASSPHRASE );
647
648   /* Hash the passphrase and store it in a newly allocated DEK object.
649      Keep a copy of the passphrase in LAST_PW for use by
650      get_last_passphrase(). */
651   dek = xmalloc_secure_clear ( sizeof *dek );
652   dek->algo = cipher_algo;
653   if ( !*pw && mode == 2 )
654     dek->keylen = 0;
655   else
656     hash_passphrase( dek, pw, s2k, mode==2 );
657   xfree(last_pw);
658   last_pw = pw;
659   return dek;
660 }