Keyserver search and get basically works again.
[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, 2009 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
54 /* Pack an s2k iteration count into the form specified in 2440.  If
55    we're in between valid values, round up.  With value 0 return the
56    old default.  */
57 unsigned char
58 encode_s2k_iterations (int iterations)
59 {
60   gpg_error_t err;
61   unsigned char c=0;
62   unsigned char result;
63   unsigned int count;
64
65   if (!iterations)
66     {
67       unsigned long mycnt;
68
69       /* Ask the gpg-agent for a useful iteration count.  */
70       err = agent_get_s2k_count (&mycnt);
71       if (err || mycnt < 65536)
72         {
73           /* Don't print an error if an older agent is used.  */
74           if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
75             log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
76           /* Default to 65536 which we used up to 2.0.13.  */
77           return 96; 
78         }
79       else if (mycnt >= 65011712)
80         return 255; /* Largest possible value.  */
81       else
82         return encode_s2k_iterations ((int)mycnt);
83     }
84
85   if (iterations <= 1024)
86     return 0;  /* Command line arg compatibility.  */
87
88   if (iterations >= 65011712)
89     return 255;
90   
91   /* Need count to be in the range 16-31 */
92   for (count=iterations>>6; count>=32; count>>=1)
93     c++;
94
95   result = (c<<4)|(count-16);
96
97   if (S2K_DECODE_COUNT(result) < iterations)
98     result++;
99   
100   return result;
101 }
102
103
104
105 /* Hash a passphrase using the supplied s2k. 
106    Always needs: dek->algo, s2k->mode, s2k->hash_algo.  */
107 static void
108 hash_passphrase ( DEK *dek, char *pw, STRING2KEY *s2k)
109 {
110   gcry_md_hd_t md;
111   int pass, i;
112   int used = 0;
113   int pwlen = strlen(pw);
114
115   assert ( s2k->hash_algo );
116   dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
117   if ( !(dek->keylen > 0 && dek->keylen <= DIM(dek->key)) )
118     BUG();
119
120   if (gcry_md_open (&md, s2k->hash_algo, 1))
121     BUG ();
122   for (pass=0; used < dek->keylen ; pass++ ) 
123     {
124       if ( pass ) 
125         {
126           gcry_md_reset (md);
127           for (i=0; i < pass; i++ ) /* Preset the hash context.  */
128             gcry_md_putc (md, 0 );
129         }
130
131       if ( s2k->mode == 1 || s2k->mode == 3 ) 
132         {
133           int len2 = pwlen + 8;
134           ulong count = len2;
135           
136           if ( s2k->mode == 3 )
137             {
138               count = S2K_DECODE_COUNT(s2k->count);
139               if ( count < len2 )
140                 count = len2;
141             }
142
143           /* Fixme: To avoid DoS attacks by sending an sym-encrypted
144              packet with a very high S2K count, we should either cap
145              the iteration count or CPU seconds based timeout.  */
146
147           /* A little bit complicated because we need a ulong for count. */
148           while ( count > len2 )  /* maybe iterated+salted */
149             { 
150               gcry_md_write ( md, s2k->salt, 8 );
151               gcry_md_write ( md, pw, pwlen );
152               count -= len2;
153             }
154           if ( count < 8 )
155             gcry_md_write ( md, s2k->salt, count );
156           else
157             {
158               gcry_md_write ( md, s2k->salt, 8 );
159               count -= 8;
160               gcry_md_write ( md, pw, count );
161             }
162         }
163       else
164         gcry_md_write ( md, pw, pwlen );
165       gcry_md_final( md );
166
167       i = gcry_md_get_algo_dlen ( s2k->hash_algo );
168       if ( i > dek->keylen - used )
169         i = dek->keylen - used;
170
171       memcpy (dek->key+used, gcry_md_read (md, s2k->hash_algo), i);
172       used += i;
173     }
174   gcry_md_close(md);
175 }
176
177
178
179 int
180 have_static_passphrase()
181 {
182   return !!fd_passwd && opt.batch;
183 }
184
185 /****************
186  * Set the passphrase to be used for the next query and only for the next
187  * one.
188  */
189 void
190 set_next_passphrase( const char *s )
191 {
192   xfree(next_pw);
193   next_pw = NULL;
194   if ( s )
195     {
196       next_pw = xmalloc_secure( strlen(s)+1 );
197       strcpy (next_pw, s );
198     }
199 }
200
201 /****************
202  * Get the last passphrase used in passphrase_to_dek.
203  * Note: This removes the passphrase from this modules and
204  * the caller must free the result.  May return NULL:
205  */
206 char *
207 get_last_passphrase()
208 {
209   char *p = last_pw;
210   last_pw = NULL;
211   return p;
212 }
213
214 /* Here's an interesting question: since this passphrase was passed in
215    on the command line, is there really any point in using secure
216    memory for it?  I'm going with 'yes', since it doesn't hurt, and
217    might help in some small way (swapping). */
218
219 void
220 set_passphrase_from_string(const char *pass)
221 {
222   xfree (fd_passwd);
223   fd_passwd = xmalloc_secure(strlen(pass)+1);
224   strcpy (fd_passwd, pass);
225 }
226
227
228 void
229 read_passphrase_from_fd( int fd )
230 {
231   int i, len;
232   char *pw;
233
234   if ( !opt.batch ) 
235     { /* Not used but we have to do a dummy read, so that it won't end
236          up at the begin of the message if the quite usual trick to
237          prepend the passphtrase to the message is used. */
238       char buf[1];
239
240       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
241         ;
242       *buf = 0;
243       return; 
244     }
245
246   for (pw = NULL, i = len = 100; ; i++ ) 
247     {
248       if (i >= len-1 ) 
249         {
250           char *pw2 = pw;
251           len += 100;
252           pw = xmalloc_secure( len );
253           if( pw2 )
254             {
255               memcpy(pw, pw2, i );
256               xfree (pw2);
257             }
258           else
259             i=0;
260         }
261       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
262         break;
263     }
264   pw[i] = 0;
265   if (!opt.batch)
266     tty_printf("\b\b\b   \n" );
267
268   xfree ( fd_passwd );
269   fd_passwd = pw;
270 }
271
272
273 /*
274  * Ask the GPG Agent for the passphrase.
275  * Mode 0:  Allow cached passphrase
276  *      1:  No cached passphrase; that is we are asking for a new passphrase
277  *          FIXME: Only partially implemented
278  *
279  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
280  * NULL, the function does set it to 1 if the user canceled the
281  * operation.  If CACHEID is not NULL, it will be used as the cacheID
282  * for the gpg-agent; if is NULL and a key fingerprint can be
283  * computed, this will be used as the cacheid.
284  */
285 static char *
286 passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
287                  const char *tryagain_text,
288                  const char *custom_description,
289                  const char *custom_prompt, int *canceled)
290 {
291   int rc;
292   char *atext = NULL;
293   char *pw = NULL;
294   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
295   byte fpr[MAX_FINGERPRINT_LEN];
296   int have_fpr = 0;
297   char *orig_codeset;
298   char *my_prompt;
299   char hexfprbuf[20*2+1];
300   const char *my_cacheid;
301   int check = (mode == 1);
302
303   if (canceled)
304     *canceled = 0;
305
306 #if MAX_FINGERPRINT_LEN < 20
307 #error agent needs a 20 byte fingerprint
308 #endif
309
310   memset (fpr, 0, MAX_FINGERPRINT_LEN );
311   if( keyid && get_pubkey( pk, keyid ) )
312     {
313       if (pk)
314         free_public_key( pk );      
315       pk = NULL; /* oops: no key for some reason */
316     }
317   
318   orig_codeset = i18n_switchto_utf8 ();
319
320   if (custom_description)
321     atext = native_to_utf8 (custom_description);
322   else if ( !mode && pk && keyid )
323     { 
324       char *uid;
325       size_t uidlen;
326       const char *algo_name = gcry_pk_algo_name ( pk->pubkey_algo );
327       const char *timestr;
328       char *maink;
329       
330       if ( !algo_name )
331         algo_name = "?";
332
333 #define KEYIDSTRING _(" (main key ID %s)")
334
335       maink = xmalloc ( strlen (KEYIDSTRING) + keystrlen() + 20 );
336       if( keyid[2] && keyid[3] && keyid[0] != keyid[2] 
337           && keyid[1] != keyid[3] )
338         sprintf( maink, KEYIDSTRING, keystr(&keyid[2]) );
339       else
340         *maink = 0;
341       
342       uid = get_user_id ( keyid, &uidlen ); 
343       timestr = strtimestamp (pk->timestamp);
344
345 #undef KEYIDSTRING
346
347 #define PROMPTSTRING _("Please enter the passphrase to unlock the" \
348                        " secret key for the OpenPGP certificate:\n" \
349                        "\"%.*s\"\n" \
350                        "%u-bit %s key, ID %s,\n" \
351                        "created %s%s.\n" )
352
353       atext = xmalloc ( 100 + strlen (PROMPTSTRING)  
354                         + uidlen + 15 + strlen(algo_name) + keystrlen()
355                         + strlen (timestr) + strlen (maink) );
356       sprintf (atext, PROMPTSTRING,
357                (int)uidlen, uid,
358                nbits_from_pk (pk), algo_name, keystr(&keyid[0]), timestr,
359                maink  );
360       xfree (uid);
361       xfree (maink);
362
363 #undef PROMPTSTRING
364
365       { 
366         size_t dummy;
367         fingerprint_from_pk( pk, fpr, &dummy );
368         have_fpr = 1;
369       }
370       
371     }
372   else
373     atext = xstrdup ( _("Enter passphrase\n") );
374                 
375
376   if (!mode && cacheid)
377     my_cacheid = cacheid;
378   else if (!mode && have_fpr)
379     my_cacheid = bin2hex (fpr, 20, hexfprbuf);
380   else
381     my_cacheid = NULL;
382
383   if (tryagain_text)
384     tryagain_text = _(tryagain_text);
385
386   my_prompt = custom_prompt ? native_to_utf8 (custom_prompt): NULL;
387
388   rc = agent_get_passphrase (my_cacheid, tryagain_text, my_prompt, atext,
389                              repeat, check, &pw);
390   
391   xfree (my_prompt);
392   xfree (atext); atext = NULL;
393
394   i18n_switchback (orig_codeset);
395
396
397   if (!rc)
398     ;
399   else if (gpg_err_code (rc) == GPG_ERR_CANCELED 
400             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
401     {
402       log_info (_("cancelled by user\n") );
403       if (canceled)
404         *canceled = 1;
405     }
406   else 
407     {
408       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
409       /* Due to limitations in the API of the upper layers they
410          consider an error as no passphrase entered.  This works in
411          most cases but not during key creation where this should
412          definitely not happen and let it continue without requiring a
413          passphrase.  Given that now all the upper layers handle a
414          cancel correctly, we simply set the cancel flag now for all
415          errors from the agent.  */ 
416       if (canceled)
417         *canceled = 1;
418
419       write_status_errcode ("get_passphrase", rc);
420     }
421
422   if (pk)
423     free_public_key( pk );
424   if (rc)
425     {
426       xfree (pw);
427       return NULL;
428     }
429   return pw;
430 }
431
432
433 /*
434  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
435  * used instead of a cache ID derived from KEYID.
436  */
437 void
438 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
439 {
440   int rc;
441
442   (void)algo;
443     
444   if (!cacheid)
445     {
446       PKT_public_key *pk;
447 #     if MAX_FINGERPRINT_LEN < 20
448 #       error agent needs a 20 byte fingerprint
449 #     endif
450       byte fpr[MAX_FINGERPRINT_LEN];
451       char hexfprbuf[2*20+1];
452       size_t dummy;
453       
454       pk = xcalloc (1, sizeof *pk);
455       if ( !keyid || get_pubkey( pk, keyid ) )
456         {
457           log_error ("key not found in passphrase_clear_cache\n");
458           free_public_key (pk);
459           return;
460         }
461       memset (fpr, 0, MAX_FINGERPRINT_LEN );
462       fingerprint_from_pk ( pk, fpr, &dummy );
463       bin2hex (fpr, 20, hexfprbuf);
464       rc = agent_clear_passphrase (hexfprbuf);
465       free_public_key ( pk );
466     }
467   else
468     rc = agent_clear_passphrase (cacheid);
469
470   if (rc)
471     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
472 }
473
474
475 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
476    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
477    selected to cancel the passphrase entry and if CANCELED is not
478    NULL, sets it to true.
479
480    MODE 0:  Allow cached passphrase
481         1:  Ignore cached passphrase 
482         2:  Ditto, but create a new key
483         3:  Allow cached passphrase; use the S2K salt as the cache ID
484         4:  Ditto, but create a new key
485 */
486 DEK *
487 passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
488                        int cipher_algo, STRING2KEY *s2k, int mode,
489                        const char *tryagain_text, 
490                        const char *custdesc, const char *custprompt,
491                        int *canceled)
492 {
493   char *pw = NULL;
494   DEK *dek;
495   STRING2KEY help_s2k;
496   int dummy_canceled;
497   char s2k_cacheidbuf[1+16+1], *s2k_cacheid = NULL;
498
499   if (!canceled)
500     canceled = &dummy_canceled;
501   *canceled = 0;
502   
503   if ( !s2k )
504     {
505       assert (mode != 3 && mode != 4);
506       /* This is used for the old rfc1991 mode 
507        * Note: This must match the code in encode.c with opt.rfc1991 set */
508       s2k = &help_s2k;
509       s2k->mode = 0;
510       s2k->hash_algo = S2K_DIGEST_ALGO;
511     }
512
513   /* Create a new salt or what else to be filled into the s2k for a
514      new key.  */
515   if ((mode == 2 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
516     {
517       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
518       if ( s2k->mode == 3 )
519         {
520           /* We delay the encoding until it is really needed.  This is
521              if we are going to dynamically calibrate it, we need to
522              call out to gpg-agent and that should not be done during
523              option processing in main().  */
524           if (!opt.s2k_count)
525             opt.s2k_count = encode_s2k_iterations (0);
526           s2k->count = opt.s2k_count;
527         }
528     }
529
530   /* If we do not have a passphrase available in NEXT_PW and status
531      information are request, we print them now. */
532   if ( !next_pw && is_status_enabled() ) 
533     {
534       char buf[50];
535       
536       if ( keyid )
537         {
538           u32 used_kid[2];
539           char *us;
540           
541           if ( keyid[2] && keyid[3] ) 
542             {
543               used_kid[0] = keyid[2];
544               used_kid[1] = keyid[3];
545             }
546           else
547             {
548               used_kid[0] = keyid[0];
549               used_kid[1] = keyid[1];
550             }
551           
552           us = get_long_user_id_string ( keyid );
553           write_status_text ( STATUS_USERID_HINT, us );
554           xfree(us);
555           
556           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
557                     (ulong)keyid[0], (ulong)keyid[1],
558                     (ulong)used_kid[0], (ulong)used_kid[1],
559                     pubkey_algo );
560           
561           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
562         }
563       else
564         {
565           snprintf (buf, sizeof buf -1, "%d %d %d",
566                     cipher_algo, s2k->mode, s2k->hash_algo );
567           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
568         }
569     }
570
571   /* If we do have a keyID, we do not have a passphrase available in
572      NEXT_PW, we are not running in batch mode and we do not want to
573      ignore the passphrase cache (mode!=1), print a prompt with
574      information on that key. */
575   if ( keyid && !opt.batch && !next_pw && mode!=1 )
576     {
577       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
578       char *p;
579       
580       p = get_user_id_native(keyid);
581       tty_printf ("\n");
582       tty_printf (_("You need a passphrase to unlock the secret key for\n"
583                     "user: \"%s\"\n"),p);
584       xfree(p);
585
586       if ( !get_pubkey( pk, keyid ) )
587         {
588           const char *s = gcry_pk_algo_name ( pk->pubkey_algo );
589           
590           tty_printf (_("%u-bit %s key, ID %s, created %s"),
591                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
592                       strtimestamp(pk->timestamp) );
593           if ( keyid[2] && keyid[3]
594                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
595             {
596               if ( keystrlen () > 10 )
597                 {
598                   tty_printf ("\n");
599                   tty_printf (_("         (subkey on main key ID %s)"),
600                               keystr(&keyid[2]) );
601                 }
602               else
603                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
604             }
605           tty_printf("\n");
606         }
607
608       tty_printf("\n");
609       if (pk)
610         free_public_key( pk );
611     }
612
613   if ( next_pw ) 
614     {
615       /* Simply return the passphrase we already have in NEXT_PW. */
616       pw = next_pw;
617       next_pw = NULL;
618     }
619   else if ( have_static_passphrase () ) 
620     {
621       /* Return the passphrase we have stored in FD_PASSWD. */
622       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
623       strcpy ( pw, fd_passwd );
624     }
625   else 
626     {
627       if ((mode == 3 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
628         {
629           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
630           *s2k_cacheidbuf = 'S';
631           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
632           s2k_cacheid = s2k_cacheidbuf;
633         }
634
635       /* Divert to the gpg-agent. */
636       pw = passphrase_get (keyid, mode == 2, s2k_cacheid,
637                            (mode == 2 || mode == 4)? opt.passphrase_repeat : 0,
638                            tryagain_text, custdesc, custprompt, canceled);
639       if (*canceled)
640         {
641           xfree (pw);
642           write_status( STATUS_MISSING_PASSPHRASE );
643           return NULL;
644         }
645     }
646     
647   if ( !pw || !*pw )
648     write_status( STATUS_MISSING_PASSPHRASE );
649
650   /* Hash the passphrase and store it in a newly allocated DEK object.
651      Keep a copy of the passphrase in LAST_PW for use by
652      get_last_passphrase(). */
653   dek = xmalloc_secure_clear ( sizeof *dek );
654   dek->algo = cipher_algo;
655   if ( (!pw || !*pw) && (mode == 2 || mode == 4))
656     dek->keylen = 0;
657   else
658     hash_passphrase (dek, pw, s2k);
659   if (s2k_cacheid)
660     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
661   xfree(last_pw);
662   last_pw = pw;
663   return dek;
664 }
665
666
667 DEK *
668 passphrase_to_dek (u32 *keyid, int pubkey_algo,
669                    int cipher_algo, STRING2KEY *s2k, int mode,
670                    const char *tryagain_text, int *canceled)
671 {
672   return passphrase_to_dek_ext (keyid, pubkey_algo, cipher_algo,
673                                 s2k, mode, tryagain_text, NULL, NULL,
674                                 canceled);
675 }
676
677
678 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
679    is true spaces and control characters are percent or plus escaped.
680    MODE 0 is for the common prompt, MODE 1 for the import prompt. */
681 char *
682 gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped)
683 {
684   char *uid;
685   size_t uidlen;
686   const char *algo_name;
687   const char *timestr;
688   char *orig_codeset;
689   char *maink;
690   char *desc;
691   const char *prompt;
692       
693   algo_name = gcry_pk_algo_name (pk->pubkey_algo);
694   timestr = strtimestamp (pk->timestamp);
695   uid = get_user_id (pk->keyid, &uidlen); 
696
697   orig_codeset = i18n_switchto_utf8 ();
698
699   if (pk->main_keyid[0] && pk->main_keyid[1]
700       && pk->keyid[0] != pk->main_keyid[0] 
701       && pk->keyid[1] != pk->main_keyid[1])
702     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
703   else
704     maink = NULL;
705
706   switch (mode)
707     {
708     case 0:
709       prompt = _("Please enter the passphrase to unlock the"
710                  " secret key for the OpenPGP certificate:");
711       break;
712     case 1:
713       prompt = _("Please enter the passphrase to import the"
714                  " secret key for the OpenPGP certificate:");
715       break;
716     default:
717       prompt = "?";
718       break;
719     }
720
721   desc = xtryasprintf (_("%s\n"
722                          "\"%.*s\"\n"
723                          "%u-bit %s key, ID %s,\n"
724                          "created %s%s.\n"),
725                        prompt,
726                        (int)uidlen, uid,
727                        nbits_from_pk (pk), algo_name, 
728                        keystr (pk->keyid), timestr,
729                        maink?maink:"" );
730   xfree (maink);
731   xfree (uid);
732
733   i18n_switchback (orig_codeset);
734
735   if (escaped)
736     {
737       char *tmp = percent_plus_escape (desc);
738       xfree (desc); 
739       desc = tmp;
740     }
741
742   return desc;
743 }