gpg: Add build and runtime support for larger RSA keys
[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 /* As if we had used the passphrase - make it the last_pw. */
215 void
216 next_to_last_passphrase(void)
217 {
218   if (next_pw)
219     {
220       last_pw=next_pw;
221       next_pw=NULL;
222     }
223 }
224
225 /* Here's an interesting question: since this passphrase was passed in
226    on the command line, is there really any point in using secure
227    memory for it?  I'm going with 'yes', since it doesn't hurt, and
228    might help in some small way (swapping). */
229
230 void
231 set_passphrase_from_string(const char *pass)
232 {
233   xfree (fd_passwd);
234   fd_passwd = xmalloc_secure(strlen(pass)+1);
235   strcpy (fd_passwd, pass);
236 }
237
238
239 void
240 read_passphrase_from_fd( int fd )
241 {
242   int i, len;
243   char *pw;
244
245   if ( !opt.batch )
246     { /* Not used but we have to do a dummy read, so that it won't end
247          up at the begin of the message if the quite usual trick to
248          prepend the passphtrase to the message is used. */
249       char buf[1];
250
251       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
252         ;
253       *buf = 0;
254       return;
255     }
256
257   for (pw = NULL, i = len = 100; ; i++ )
258     {
259       if (i >= len-1 )
260         {
261           char *pw2 = pw;
262           len += 100;
263           pw = xmalloc_secure( len );
264           if( pw2 )
265             {
266               memcpy(pw, pw2, i );
267               xfree (pw2);
268             }
269           else
270             i=0;
271         }
272       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
273         break;
274     }
275   pw[i] = 0;
276   if (!opt.batch)
277     tty_printf("\b\b\b   \n" );
278
279   xfree ( fd_passwd );
280   fd_passwd = pw;
281 }
282
283
284 /*
285  * Ask the GPG Agent for the passphrase.
286  * Mode 0:  Allow cached passphrase
287  *      1:  No cached passphrase; that is we are asking for a new passphrase
288  *          FIXME: Only partially implemented
289  *
290  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
291  * NULL, the function does set it to 1 if the user canceled the
292  * operation.  If CACHEID is not NULL, it will be used as the cacheID
293  * for the gpg-agent; if is NULL and a key fingerprint can be
294  * computed, this will be used as the cacheid.
295  */
296 static char *
297 passphrase_get ( u32 *keyid, int mode, const char *cacheid, int repeat,
298                  const char *tryagain_text,
299                  const char *custom_description,
300                  const char *custom_prompt, int *canceled)
301 {
302   int rc;
303   char *atext = NULL;
304   char *pw = NULL;
305   PKT_public_key *pk = xmalloc_clear( sizeof *pk );
306   byte fpr[MAX_FINGERPRINT_LEN];
307   int have_fpr = 0;
308   char *orig_codeset;
309   char *my_prompt;
310   char hexfprbuf[20*2+1];
311   const char *my_cacheid;
312   int check = (mode == 1);
313
314   if (canceled)
315     *canceled = 0;
316
317 #if MAX_FINGERPRINT_LEN < 20
318 #error agent needs a 20 byte fingerprint
319 #endif
320
321   memset (fpr, 0, MAX_FINGERPRINT_LEN );
322   if( keyid && get_pubkey( pk, keyid ) )
323     {
324       if (pk)
325         free_public_key( pk );
326       pk = NULL; /* oops: no key for some reason */
327     }
328
329   orig_codeset = i18n_switchto_utf8 ();
330
331   if (custom_description)
332     atext = native_to_utf8 (custom_description);
333   else if ( !mode && pk && keyid )
334     {
335       char *uid;
336       size_t uidlen;
337       const char *algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
338       const char *timestr;
339       char *maink;
340
341       if ( !algo_name )
342         algo_name = "?";
343
344       if (keyid[2] && keyid[3]
345           && keyid[0] != keyid[2]
346           && keyid[1] != keyid[3] )
347         maink = xasprintf (_(" (main key ID %s)"), keystr (&keyid[2]));
348       else
349         maink = xstrdup ("");
350
351       uid = get_user_id ( keyid, &uidlen );
352       timestr = strtimestamp (pk->timestamp);
353
354       atext = xasprintf (_("Please enter the passphrase to unlock the"
355                            " secret key for the OpenPGP certificate:\n"
356                            "\"%.*s\"\n"
357                            "%u-bit %s key, ID %s,\n"
358                            "created %s%s.\n"),
359                          (int)uidlen, uid,
360                          nbits_from_pk (pk), algo_name, keystr(&keyid[0]),
361                          timestr, maink);
362       xfree (uid);
363       xfree (maink);
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     {
401       log_info (_("cancelled by user\n") );
402       if (canceled)
403         *canceled = 1;
404     }
405   else
406     {
407       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
408       /* Due to limitations in the API of the upper layers they
409          consider an error as no passphrase entered.  This works in
410          most cases but not during key creation where this should
411          definitely not happen and let it continue without requiring a
412          passphrase.  Given that now all the upper layers handle a
413          cancel correctly, we simply set the cancel flag now for all
414          errors from the agent.  */
415       if (canceled)
416         *canceled = 1;
417
418       write_status_error ("get_passphrase", rc);
419     }
420
421   if (pk)
422     free_public_key( pk );
423   if (rc)
424     {
425       xfree (pw);
426       return NULL;
427     }
428   return pw;
429 }
430
431
432 /*
433  * Clear the cached passphrase.  If CACHEID is not NULL, it will be
434  * used instead of a cache ID derived from KEYID.
435  */
436 void
437 passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo )
438 {
439   int rc;
440
441   (void)algo;
442
443   if (!cacheid)
444     {
445       PKT_public_key *pk;
446 #     if MAX_FINGERPRINT_LEN < 20
447 #       error agent needs a 20 byte fingerprint
448 #     endif
449       byte fpr[MAX_FINGERPRINT_LEN];
450       char hexfprbuf[2*20+1];
451       size_t dummy;
452
453       pk = xcalloc (1, sizeof *pk);
454       if ( !keyid || get_pubkey( pk, keyid ) )
455         {
456           log_error ("key not found in passphrase_clear_cache\n");
457           free_public_key (pk);
458           return;
459         }
460       memset (fpr, 0, MAX_FINGERPRINT_LEN );
461       fingerprint_from_pk ( pk, fpr, &dummy );
462       bin2hex (fpr, 20, hexfprbuf);
463       rc = agent_clear_passphrase (hexfprbuf);
464       free_public_key ( pk );
465     }
466   else
467     rc = agent_clear_passphrase (cacheid);
468
469   if (rc)
470     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
471 }
472
473
474 /* Return a new DEK object Using the string-to-key sepcifier S2K.  Use
475    KEYID and PUBKEY_ALGO to prompt the user.  Returns NULL is the user
476    selected to cancel the passphrase entry and if CANCELED is not
477    NULL, sets it to true.
478
479    MODE 0:  Allow cached passphrase
480         1:  Ignore cached passphrase
481         2:  Ditto, but create a new key
482         3:  Allow cached passphrase; use the S2K salt as the cache ID
483         4:  Ditto, but create a new key
484 */
485 DEK *
486 passphrase_to_dek_ext (u32 *keyid, int pubkey_algo,
487                        int cipher_algo, STRING2KEY *s2k, int mode,
488                        const char *tryagain_text,
489                        const char *custdesc, const char *custprompt,
490                        int *canceled)
491 {
492   char *pw = NULL;
493   DEK *dek;
494   STRING2KEY help_s2k;
495   int dummy_canceled;
496   char s2k_cacheidbuf[1+16+1], *s2k_cacheid = NULL;
497
498   if (!canceled)
499     canceled = &dummy_canceled;
500   *canceled = 0;
501
502   if ( !s2k )
503     {
504       assert (mode != 3 && mode != 4);
505       /* This is used for the old rfc1991 mode
506        * Note: This must match the code in encode.c with opt.rfc1991 set */
507       s2k = &help_s2k;
508       s2k->mode = 0;
509       s2k->hash_algo = S2K_DIGEST_ALGO;
510     }
511
512   /* Create a new salt or what else to be filled into the s2k for a
513      new key.  */
514   if ((mode == 2 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
515     {
516       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
517       if ( s2k->mode == 3 )
518         {
519           /* We delay the encoding until it is really needed.  This is
520              if we are going to dynamically calibrate it, we need to
521              call out to gpg-agent and that should not be done during
522              option processing in main().  */
523           if (!opt.s2k_count)
524             opt.s2k_count = encode_s2k_iterations (0);
525           s2k->count = opt.s2k_count;
526         }
527     }
528
529   /* If we do not have a passphrase available in NEXT_PW and status
530      information are request, we print them now. */
531   if ( !next_pw && is_status_enabled() )
532     {
533       char buf[50];
534
535       if ( keyid )
536         {
537           u32 used_kid[2];
538           char *us;
539
540           if ( keyid[2] && keyid[3] )
541             {
542               used_kid[0] = keyid[2];
543               used_kid[1] = keyid[3];
544             }
545           else
546             {
547               used_kid[0] = keyid[0];
548               used_kid[1] = keyid[1];
549             }
550
551           us = get_long_user_id_string ( keyid );
552           write_status_text ( STATUS_USERID_HINT, us );
553           xfree(us);
554
555           snprintf (buf, sizeof buf -1, "%08lX%08lX %08lX%08lX %d 0",
556                     (ulong)keyid[0], (ulong)keyid[1],
557                     (ulong)used_kid[0], (ulong)used_kid[1],
558                     pubkey_algo );
559
560           write_status_text ( STATUS_NEED_PASSPHRASE, buf );
561         }
562       else
563         {
564           snprintf (buf, sizeof buf -1, "%d %d %d",
565                     cipher_algo, s2k->mode, s2k->hash_algo );
566           write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
567         }
568     }
569
570   /* If we do have a keyID, we do not have a passphrase available in
571      NEXT_PW, we are not running in batch mode and we do not want to
572      ignore the passphrase cache (mode!=1), print a prompt with
573      information on that key. */
574   if ( keyid && !opt.batch && !next_pw && mode!=1 )
575     {
576       PKT_public_key *pk = xmalloc_clear( sizeof *pk );
577       char *p;
578
579       p = get_user_id_native(keyid);
580       tty_printf ("\n");
581       tty_printf (_("You need a passphrase to unlock the secret key for\n"
582                     "user: \"%s\"\n"),p);
583       xfree(p);
584
585       if ( !get_pubkey( pk, keyid ) )
586         {
587           const char *s = openpgp_pk_algo_name (pk->pubkey_algo);
588
589           tty_printf (_("%u-bit %s key, ID %s, created %s"),
590                       nbits_from_pk( pk ), s?s:"?", keystr(keyid),
591                       strtimestamp(pk->timestamp) );
592           if ( keyid[2] && keyid[3]
593                && keyid[0] != keyid[2] && keyid[1] != keyid[3] )
594             {
595               if ( keystrlen () > 10 )
596                 {
597                   tty_printf ("\n");
598                   tty_printf (_("         (subkey on main key ID %s)"),
599                               keystr(&keyid[2]) );
600                 }
601               else
602                 tty_printf ( _(" (main key ID %s)"), keystr(&keyid[2]) );
603             }
604           tty_printf("\n");
605         }
606
607       tty_printf("\n");
608       if (pk)
609         free_public_key( pk );
610     }
611
612   if ( next_pw )
613     {
614       /* Simply return the passphrase we already have in NEXT_PW. */
615       pw = next_pw;
616       next_pw = NULL;
617     }
618   else if ( have_static_passphrase () )
619     {
620       /* Return the passphrase we have stored in FD_PASSWD. */
621       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
622       strcpy ( pw, fd_passwd );
623     }
624   else
625     {
626       if ((mode == 3 || mode == 4) && (s2k->mode == 1 || s2k->mode == 3))
627         {
628           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
629           *s2k_cacheidbuf = 'S';
630           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
631           s2k_cacheid = s2k_cacheidbuf;
632         }
633
634       /* Divert to the gpg-agent. */
635       pw = passphrase_get (keyid, mode == 2, s2k_cacheid,
636                            (mode == 2 || mode == 4)? opt.passphrase_repeat : 0,
637                            tryagain_text, custdesc, custprompt, canceled);
638       if (*canceled)
639         {
640           xfree (pw);
641           write_status( STATUS_MISSING_PASSPHRASE );
642           return NULL;
643         }
644     }
645
646   if ( !pw || !*pw )
647     write_status( STATUS_MISSING_PASSPHRASE );
648
649   /* Hash the passphrase and store it in a newly allocated DEK object.
650      Keep a copy of the passphrase in LAST_PW for use by
651      get_last_passphrase(). */
652   dek = xmalloc_secure_clear ( sizeof *dek );
653   dek->algo = cipher_algo;
654   if ( (!pw || !*pw) && (mode == 2 || mode == 4))
655     dek->keylen = 0;
656   else
657     hash_passphrase (dek, pw, s2k);
658   if (s2k_cacheid)
659     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
660   xfree(last_pw);
661   last_pw = pw;
662   return dek;
663 }
664
665
666 DEK *
667 passphrase_to_dek (u32 *keyid, int pubkey_algo,
668                    int cipher_algo, STRING2KEY *s2k, int mode,
669                    const char *tryagain_text, int *canceled)
670 {
671   return passphrase_to_dek_ext (keyid, pubkey_algo, cipher_algo,
672                                 s2k, mode, tryagain_text, NULL, NULL,
673                                 canceled);
674 }