po: auto update
[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, 2011 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 <https://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 <errno.h>
28 #ifdef HAVE_LOCALE_H
29 #include <locale.h>
30 #endif
31 #ifdef HAVE_LANGINFO_CODESET
32 #include <langinfo.h>
33 #endif
34
35 #include "gpg.h"
36 #include "../common/util.h"
37 #include "options.h"
38 #include "../common/ttyio.h"
39 #include "keydb.h"
40 #include "main.h"
41 #include "../common/i18n.h"
42 #include "../common/status.h"
43 #include "call-agent.h"
44 #include "../common/shareddefs.h"
45
46 static char *fd_passwd = NULL;
47 static char *next_pw = NULL;
48 static char *last_pw = NULL;
49
50
51
52 /* Pack an s2k iteration count into the form specified in 2440.  If
53    we're in between valid values, round up.  With value 0 return the
54    old default.  */
55 unsigned char
56 encode_s2k_iterations (int iterations)
57 {
58   gpg_error_t err;
59   unsigned char c=0;
60   unsigned char result;
61   unsigned int count;
62
63   if (!iterations)
64     {
65       unsigned long mycnt;
66
67       /* Ask the gpg-agent for a useful iteration count.  */
68       err = agent_get_s2k_count (&mycnt);
69       if (err || mycnt < 65536)
70         {
71           /* Don't print an error if an older agent is used.  */
72           if (err && gpg_err_code (err) != GPG_ERR_ASS_PARAMETER)
73             log_error (_("problem with the agent: %s\n"), gpg_strerror (err));
74           /* Default to 65536 which we used up to 2.0.13.  */
75           return 96;
76         }
77       else if (mycnt >= 65011712)
78         return 255; /* Largest possible value.  */
79       else
80         return encode_s2k_iterations ((int)mycnt);
81     }
82
83   if (iterations <= 1024)
84     return 0;  /* Command line arg compatibility.  */
85
86   if (iterations >= 65011712)
87     return 255;
88
89   /* Need count to be in the range 16-31 */
90   for (count=iterations>>6; count>=32; count>>=1)
91     c++;
92
93   result = (c<<4)|(count-16);
94
95   if (S2K_DECODE_COUNT(result) < iterations)
96     result++;
97
98   return result;
99 }
100
101
102 int
103 have_static_passphrase()
104 {
105   return (!!fd_passwd
106           && (opt.batch || opt.pinentry_mode == PINENTRY_MODE_LOOPBACK));
107 }
108
109 /* Return a static passphrase.  The returned value is only valid as
110    long as no other passphrase related function is called.  NULL may
111    be returned if no passphrase has been set; better use
112    have_static_passphrase first.  */
113 const char *
114 get_static_passphrase (void)
115 {
116   return fd_passwd;
117 }
118
119
120 /****************
121  * Set the passphrase to be used for the next query and only for the next
122  * one.
123  */
124 void
125 set_next_passphrase( const char *s )
126 {
127   xfree(next_pw);
128   next_pw = NULL;
129   if ( s )
130     {
131       next_pw = xmalloc_secure( strlen(s)+1 );
132       strcpy (next_pw, s );
133     }
134 }
135
136 /****************
137  * Get the last passphrase used in passphrase_to_dek.
138  * Note: This removes the passphrase from this modules and
139  * the caller must free the result.  May return NULL:
140  */
141 char *
142 get_last_passphrase()
143 {
144   char *p = last_pw;
145   last_pw = NULL;
146   return p;
147 }
148
149 /* Here's an interesting question: since this passphrase was passed in
150    on the command line, is there really any point in using secure
151    memory for it?  I'm going with 'yes', since it doesn't hurt, and
152    might help in some small way (swapping). */
153
154 void
155 set_passphrase_from_string(const char *pass)
156 {
157   xfree (fd_passwd);
158   fd_passwd = xmalloc_secure(strlen(pass)+1);
159   strcpy (fd_passwd, pass);
160 }
161
162
163 void
164 read_passphrase_from_fd( int fd )
165 {
166   int i, len;
167   char *pw;
168
169   if (! gnupg_fd_valid (fd))
170     log_fatal ("passphrase-fd is invalid: %s\n", strerror (errno));
171
172   if ( !opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
173     { /* Not used but we have to do a dummy read, so that it won't end
174          up at the begin of the message if the quite usual trick to
175          prepend the passphtrase to the message is used. */
176       char buf[1];
177
178       while (!(read (fd, buf, 1) != 1 || *buf == '\n' ))
179         ;
180       *buf = 0;
181       return;
182     }
183
184   for (pw = NULL, i = len = 100; ; i++ )
185     {
186       if (i >= len-1 )
187         {
188           char *pw2 = pw;
189           len += 100;
190           pw = xmalloc_secure( len );
191           if( pw2 )
192             {
193               memcpy(pw, pw2, i );
194               xfree (pw2);
195             }
196           else
197             i=0;
198         }
199       if (read( fd, pw+i, 1) != 1 || pw[i] == '\n' )
200         break;
201     }
202   pw[i] = 0;
203   if (!opt.batch && opt.pinentry_mode != PINENTRY_MODE_LOOPBACK)
204     tty_printf("\b\b\b   \n" );
205
206   xfree ( fd_passwd );
207   fd_passwd = pw;
208 }
209
210
211 /*
212  * Ask the GPG Agent for the passphrase.
213  * If NOCACHE is set the symmetric passpharse caching will not be used.
214  *
215  * Note that TRYAGAIN_TEXT must not be translated.  If CANCELED is not
216  * NULL, the function does set it to 1 if the user canceled the
217  * operation.  If CACHEID is not NULL, it will be used as the cacheID
218  * for the gpg-agent; if is NULL and a key fingerprint can be
219  * computed, this will be used as the cacheid.
220  */
221 static char *
222 passphrase_get (int nocache, const char *cacheid, int repeat,
223                 const char *tryagain_text, int *canceled)
224 {
225   int rc;
226   char *pw = NULL;
227   char *orig_codeset;
228   const char *my_cacheid;
229
230   if (canceled)
231     *canceled = 0;
232
233   orig_codeset = i18n_switchto_utf8 ();
234
235   if (!nocache && cacheid)
236     my_cacheid = cacheid;
237   else
238     my_cacheid = NULL;
239
240   if (tryagain_text)
241     tryagain_text = _(tryagain_text);
242
243   rc = agent_get_passphrase (my_cacheid, tryagain_text, NULL,
244                              _("Enter passphrase\n"),
245                              repeat, nocache, &pw);
246
247   i18n_switchback (orig_codeset);
248
249
250   if (!rc)
251     ;
252   else if (gpg_err_code (rc) == GPG_ERR_CANCELED
253             || gpg_err_code (rc) == GPG_ERR_FULLY_CANCELED)
254     {
255       log_info (_("cancelled by user\n") );
256       if (canceled)
257         *canceled = 1;
258     }
259   else
260     {
261       log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
262       /* Due to limitations in the API of the upper layers they
263          consider an error as no passphrase entered.  This works in
264          most cases but not during key creation where this should
265          definitely not happen and let it continue without requiring a
266          passphrase.  Given that now all the upper layers handle a
267          cancel correctly, we simply set the cancel flag now for all
268          errors from the agent.  */
269       if (canceled)
270         *canceled = 1;
271
272       write_status_errcode ("get_passphrase", rc);
273     }
274
275   if (rc)
276     {
277       xfree (pw);
278       pw = NULL;
279     }
280   return pw;
281 }
282
283
284 /*
285  * Clear the cached passphrase with CACHEID.
286  */
287 void
288 passphrase_clear_cache (const char *cacheid)
289 {
290   int rc;
291
292   rc = agent_clear_passphrase (cacheid);
293   if (rc)
294     log_error (_("problem with the agent: %s\n"), gpg_strerror (rc));
295 }
296
297
298 /* Return a new DEK object using the string-to-key specifier S2K.
299  * Returns NULL if the user canceled the passphrase entry and if
300  * CANCELED is not NULL, sets it to true.
301  *
302  * If CREATE is true a new passphrase sll be created.  If NOCACHE is
303  * true the symmetric key caching will not be used.  */
304 DEK *
305 passphrase_to_dek (int cipher_algo, STRING2KEY *s2k,
306                    int create, int nocache,
307                    const char *tryagain_text, int *canceled)
308 {
309   char *pw = NULL;
310   DEK *dek;
311   STRING2KEY help_s2k;
312   int dummy_canceled;
313   char s2k_cacheidbuf[1+16+1];
314   char *s2k_cacheid = NULL;
315
316   if (!canceled)
317     canceled = &dummy_canceled;
318   *canceled = 0;
319
320   if (opt.no_symkey_cache)
321     nocache = 1;  /* Force no symmtric key caching.  */
322
323   if ( !s2k )
324     {
325       log_assert (create && !nocache);
326       /* This is used for the old rfc1991 mode
327        * Note: This must match the code in encode.c with opt.rfc1991 set */
328       memset (&help_s2k, 0, sizeof (help_s2k));
329       s2k = &help_s2k;
330       s2k->hash_algo = S2K_DIGEST_ALGO;
331     }
332
333   /* Create a new salt or what else to be filled into the s2k for a
334      new key.  */
335   if (create && (s2k->mode == 1 || s2k->mode == 3))
336     {
337       gcry_randomize (s2k->salt, 8, GCRY_STRONG_RANDOM);
338       if ( s2k->mode == 3 )
339         {
340           /* We delay the encoding until it is really needed.  This is
341              if we are going to dynamically calibrate it, we need to
342              call out to gpg-agent and that should not be done during
343              option processing in main().  */
344           if (!opt.s2k_count)
345             opt.s2k_count = encode_s2k_iterations (0);
346           s2k->count = opt.s2k_count;
347         }
348     }
349
350   /* If we do not have a passphrase available in NEXT_PW and status
351      information are request, we print them now. */
352   if ( !next_pw && is_status_enabled() )
353     {
354       char buf[50];
355
356       snprintf (buf, sizeof buf, "%d %d %d",
357                 cipher_algo, s2k->mode, s2k->hash_algo );
358       write_status_text ( STATUS_NEED_PASSPHRASE_SYM, buf );
359     }
360
361   if ( next_pw )
362     {
363       /* Simply return the passphrase we already have in NEXT_PW. */
364       pw = next_pw;
365       next_pw = NULL;
366     }
367   else if ( have_static_passphrase () )
368     {
369       /* Return the passphrase we have stored in FD_PASSWD. */
370       pw = xmalloc_secure ( strlen(fd_passwd)+1 );
371       strcpy ( pw, fd_passwd );
372     }
373   else
374     {
375       if (!nocache && (s2k->mode == 1 || s2k->mode == 3))
376         {
377           memset (s2k_cacheidbuf, 0, sizeof s2k_cacheidbuf);
378           *s2k_cacheidbuf = 'S';
379           bin2hex (s2k->salt, 8, s2k_cacheidbuf + 1);
380           s2k_cacheid = s2k_cacheidbuf;
381         }
382
383       if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
384         {
385           char buf[32];
386
387           snprintf (buf, sizeof (buf), "%u", 100);
388           write_status_text (STATUS_INQUIRE_MAXLEN, buf);
389         }
390
391       /* Divert to the gpg-agent. */
392       pw = passphrase_get (create && nocache, s2k_cacheid,
393                            create? opt.passphrase_repeat : 0,
394                            tryagain_text, canceled);
395       if (*canceled)
396         {
397           xfree (pw);
398           write_status( STATUS_MISSING_PASSPHRASE );
399           return NULL;
400         }
401     }
402
403   if ( !pw || !*pw )
404     write_status( STATUS_MISSING_PASSPHRASE );
405
406   /* Hash the passphrase and store it in a newly allocated DEK object.
407      Keep a copy of the passphrase in LAST_PW for use by
408      get_last_passphrase(). */
409   dek = xmalloc_secure_clear ( sizeof *dek );
410   dek->algo = cipher_algo;
411   if ( (!pw || !*pw) && create)
412     dek->keylen = 0;
413   else
414     {
415       gpg_error_t err;
416
417       dek->keylen = openpgp_cipher_get_algo_keylen (dek->algo);
418       if (!(dek->keylen > 0 && dek->keylen <= DIM(dek->key)))
419         BUG ();
420       err = gcry_kdf_derive (pw, strlen (pw),
421                              s2k->mode == 3? GCRY_KDF_ITERSALTED_S2K :
422                              s2k->mode == 1? GCRY_KDF_SALTED_S2K :
423                              /* */           GCRY_KDF_SIMPLE_S2K,
424                              s2k->hash_algo, s2k->salt, 8,
425                              S2K_DECODE_COUNT(s2k->count),
426                              dek->keylen, dek->key);
427       if (err)
428         {
429           log_error ("gcry_kdf_derive failed: %s", gpg_strerror (err));
430           xfree (pw);
431           xfree (dek);
432           write_status( STATUS_MISSING_PASSPHRASE );
433           return NULL;
434         }
435     }
436   if (s2k_cacheid)
437     memcpy (dek->s2k_cacheid, s2k_cacheid, sizeof dek->s2k_cacheid);
438   xfree(last_pw);
439   last_pw = pw;
440   return dek;
441 }
442
443
444 /* Emit the USERID_HINT and the NEED_PASSPHRASE status messages.
445    MAINKEYID may be NULL. */
446 void
447 emit_status_need_passphrase (ctrl_t ctrl,
448                              u32 *keyid, u32 *mainkeyid, int pubkey_algo)
449 {
450   char buf[50];
451   char *us;
452
453   us = get_long_user_id_string (ctrl, keyid);
454   write_status_text (STATUS_USERID_HINT, us);
455   xfree (us);
456
457   snprintf (buf, sizeof buf, "%08lX%08lX %08lX%08lX %d 0",
458             (ulong)keyid[0],
459             (ulong)keyid[1],
460             (ulong)(mainkeyid? mainkeyid[0]:keyid[0]),
461             (ulong)(mainkeyid? mainkeyid[1]:keyid[1]),
462             pubkey_algo);
463
464   write_status_text (STATUS_NEED_PASSPHRASE, buf);
465 }
466
467
468 /* Return an allocated utf-8 string describing the key PK.  If ESCAPED
469    is true spaces and control characters are percent or plus escaped.
470    MODE describes the use of the key description; use one of the
471    FORMAT_KEYDESC_ macros. */
472 char *
473 gpg_format_keydesc (ctrl_t ctrl, PKT_public_key *pk, int mode, int escaped)
474 {
475   char *uid;
476   size_t uidlen;
477   const char *algo_name;
478   const char *timestr;
479   char *orig_codeset;
480   char *maink;
481   char *desc;
482   const char *prompt;
483   const char *trailer = "";
484   int is_subkey;
485
486   is_subkey = (pk->main_keyid[0] && pk->main_keyid[1]
487                && pk->keyid[0] != pk->main_keyid[0]
488                && pk->keyid[1] != pk->main_keyid[1]);
489   algo_name = openpgp_pk_algo_name (pk->pubkey_algo);
490   timestr = strtimestamp (pk->timestamp);
491   uid = get_user_id (ctrl, is_subkey? pk->main_keyid:pk->keyid, &uidlen, NULL);
492
493   orig_codeset = i18n_switchto_utf8 ();
494
495   if (is_subkey)
496     maink = xtryasprintf (_(" (main key ID %s)"), keystr (pk->main_keyid));
497   else
498     maink = NULL;
499
500   switch (mode)
501     {
502     case FORMAT_KEYDESC_NORMAL:
503       prompt = _("Please enter the passphrase to unlock the"
504                  " OpenPGP secret key:");
505       break;
506     case FORMAT_KEYDESC_IMPORT:
507       prompt = _("Please enter the passphrase to import the"
508                  " OpenPGP secret key:");
509       break;
510     case FORMAT_KEYDESC_EXPORT:
511       if (is_subkey)
512         prompt = _("Please enter the passphrase to export the"
513                    " OpenPGP secret subkey:");
514       else
515         prompt = _("Please enter the passphrase to export the"
516                    " OpenPGP secret key:");
517       break;
518     case FORMAT_KEYDESC_DELKEY:
519       if (is_subkey)
520         prompt = _("Do you really want to permanently delete the"
521                    " OpenPGP secret subkey key:");
522       else
523         prompt = _("Do you really want to permanently delete the"
524                    " OpenPGP secret key:");
525       trailer = "?";
526       break;
527     default:
528       prompt = "?";
529       break;
530     }
531
532   desc = xtryasprintf (_("%s\n"
533                          "\"%.*s\"\n"
534                          "%u-bit %s key, ID %s,\n"
535                          "created %s%s.\n%s"),
536                        prompt,
537                        (int)uidlen, uid,
538                        nbits_from_pk (pk), algo_name,
539                        keystr (pk->keyid), timestr,
540                        maink?maink:"", trailer);
541   xfree (maink);
542   xfree (uid);
543
544   i18n_switchback (orig_codeset);
545
546   if (escaped)
547     {
548       char *tmp = percent_plus_escape (desc);
549       xfree (desc);
550       desc = tmp;
551     }
552
553   return desc;
554 }