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