agent: Send back all public keys for available cards.
[gnupg.git] / agent / genkey.c
1 /* genkey.c - Generate a keypair
2  * Copyright (C) 2002, 2003, 2004, 2007, 2010 Free Software Foundation, Inc.
3  * Copyright (C) 2015 g10 Code GmbH.
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 <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <assert.h>
28
29 #include "agent.h"
30 #include "i18n.h"
31 #include "exechelp.h"
32 #include "sysutils.h"
33
34 static int
35 store_key (gcry_sexp_t private, const char *passphrase, int force,
36         unsigned long s2k_count)
37 {
38   int rc;
39   unsigned char *buf;
40   size_t len;
41   unsigned char grip[20];
42
43   if ( !gcry_pk_get_keygrip (private, grip) )
44     {
45       log_error ("can't calculate keygrip\n");
46       return gpg_error (GPG_ERR_GENERAL);
47     }
48
49   len = gcry_sexp_sprint (private, GCRYSEXP_FMT_CANON, NULL, 0);
50   assert (len);
51   buf = gcry_malloc_secure (len);
52   if (!buf)
53       return out_of_core ();
54   len = gcry_sexp_sprint (private, GCRYSEXP_FMT_CANON, buf, len);
55   assert (len);
56
57   if (passphrase)
58     {
59       unsigned char *p;
60
61       rc = agent_protect (buf, passphrase, &p, &len, s2k_count, -1);
62       if (rc)
63         {
64           xfree (buf);
65           return rc;
66         }
67       xfree (buf);
68       buf = p;
69     }
70
71   rc = agent_write_private_key (grip, buf, len, force);
72   xfree (buf);
73   return rc;
74 }
75
76
77 /* Count the number of non-alpha characters in S.  Control characters
78    and non-ascii characters are not considered.  */
79 static size_t
80 nonalpha_count (const char *s)
81 {
82   size_t n;
83
84   for (n=0; *s; s++)
85     if (isascii (*s) && ( isdigit (*s) || ispunct (*s) ))
86       n++;
87
88   return n;
89 }
90
91
92 /* Check PW against a list of pattern.  Return 0 if PW does not match
93    these pattern.  */
94 static int
95 check_passphrase_pattern (ctrl_t ctrl, const char *pw)
96 {
97   gpg_error_t err = 0;
98   const char *pgmname = gnupg_module_name (GNUPG_MODULE_NAME_CHECK_PATTERN);
99   FILE *infp;
100   const char *argv[10];
101   pid_t pid;
102   int result, i;
103
104   (void)ctrl;
105
106   infp = gnupg_tmpfile ();
107   if (!infp)
108     {
109       err = gpg_error_from_syserror ();
110       log_error (_("error creating temporary file: %s\n"), gpg_strerror (err));
111       return 1; /* Error - assume password should not be used.  */
112     }
113
114   if (fwrite (pw, strlen (pw), 1, infp) != 1)
115     {
116       err = gpg_error_from_syserror ();
117       log_error (_("error writing to temporary file: %s\n"),
118                  gpg_strerror (err));
119       fclose (infp);
120       return 1; /* Error - assume password should not be used.  */
121     }
122   fseek (infp, 0, SEEK_SET);
123   clearerr (infp);
124
125   i = 0;
126   argv[i++] = "--null";
127   argv[i++] = "--",
128   argv[i++] = opt.check_passphrase_pattern,
129   argv[i] = NULL;
130   assert (i < sizeof argv);
131
132   if (gnupg_spawn_process_fd (pgmname, argv, fileno (infp), -1, -1, &pid))
133     result = 1; /* Execute error - assume password should no be used.  */
134   else if (gnupg_wait_process (pgmname, pid, 1, NULL))
135     result = 1; /* Helper returned an error - probably a match.  */
136   else
137     result = 0; /* Success; i.e. no match.  */
138   gnupg_release_process (pid);
139
140   /* Overwrite our temporary file. */
141   fseek (infp, 0, SEEK_SET);
142   clearerr (infp);
143   for (i=((strlen (pw)+99)/100)*100; i > 0; i--)
144     putc ('\xff', infp);
145   fflush (infp);
146   fclose (infp);
147   return result;
148 }
149
150
151 static int
152 take_this_one_anyway2 (ctrl_t ctrl, const char *desc, const char *anyway_btn)
153 {
154   gpg_error_t err;
155
156   if (opt.enforce_passphrase_constraints)
157     {
158       err = agent_show_message (ctrl, desc, L_("Enter new passphrase"));
159       if (!err)
160         err = gpg_error (GPG_ERR_CANCELED);
161     }
162   else
163     err = agent_get_confirmation (ctrl, desc,
164                                   anyway_btn, L_("Enter new passphrase"), 0);
165   return err;
166 }
167
168
169 static int
170 take_this_one_anyway (ctrl_t ctrl, const char *desc)
171 {
172   return take_this_one_anyway2 (ctrl, desc, L_("Take this one anyway"));
173 }
174
175
176 /* Check whether the passphrase PW is suitable. Returns 0 if the
177    passphrase is suitable and true if it is not and the user should be
178    asked to provide a different one.  If FAILED_CONSTRAINT is set, a
179    message describing the problem is returned in
180    *FAILED_CONSTRAINT.  */
181 int
182 check_passphrase_constraints (ctrl_t ctrl, const char *pw,
183                               char **failed_constraint)
184 {
185   gpg_error_t err = 0;
186   unsigned int minlen = opt.min_passphrase_len;
187   unsigned int minnonalpha = opt.min_passphrase_nonalpha;
188   char *msg1 = NULL;
189   char *msg2 = NULL;
190   char *msg3 = NULL;
191
192   if (ctrl && ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
193     return 0;
194
195   if (!pw)
196     pw = "";
197
198   /* The first check is to warn about an empty passphrase. */
199   if (!*pw)
200     {
201       const char *desc = (opt.enforce_passphrase_constraints?
202                           L_("You have not entered a passphrase!%0A"
203                              "An empty passphrase is not allowed.") :
204                           L_("You have not entered a passphrase - "
205                              "this is in general a bad idea!%0A"
206                              "Please confirm that you do not want to "
207                              "have any protection on your key."));
208
209       err = 1;
210       if (failed_constraint)
211         {
212           if (opt.enforce_passphrase_constraints)
213             *failed_constraint = xstrdup (desc);
214           else
215             err = take_this_one_anyway2 (ctrl, desc,
216                                          L_("Yes, protection is not needed"));
217         }
218
219       goto leave;
220     }
221
222   /* Now check the constraints and collect the error messages unless
223      in in silent mode which returns immediately.  */
224   if (utf8_charcount (pw, -1) < minlen )
225     {
226       if (!failed_constraint)
227         {
228           err = gpg_error (GPG_ERR_INV_PASSPHRASE);
229           goto leave;
230         }
231
232       msg1 = xtryasprintf
233         ( ngettext ("A passphrase should be at least %u character long.",
234                     "A passphrase should be at least %u characters long.",
235                     minlen), minlen );
236       if (!msg1)
237         {
238           err = gpg_error_from_syserror ();
239           goto leave;
240         }
241     }
242
243   if (nonalpha_count (pw) < minnonalpha )
244     {
245       if (!failed_constraint)
246         {
247           err = gpg_error (GPG_ERR_INV_PASSPHRASE);
248           goto leave;
249         }
250
251       msg2 = xtryasprintf
252         ( ngettext ("A passphrase should contain at least %u digit or%%0A"
253                     "special character.",
254                     "A passphrase should contain at least %u digits or%%0A"
255                     "special characters.",
256                     minnonalpha), minnonalpha );
257       if (!msg2)
258         {
259           err = gpg_error_from_syserror ();
260           goto leave;
261         }
262     }
263
264   /* If configured check the passphrase against a list of known words
265      and pattern.  The actual test is done by an external program.
266      The warning message is generic to give the user no hint on how to
267      circumvent this list.  */
268   if (*pw && opt.check_passphrase_pattern &&
269       check_passphrase_pattern (ctrl, pw))
270     {
271       if (!failed_constraint)
272         {
273           err = gpg_error (GPG_ERR_INV_PASSPHRASE);
274           goto leave;
275         }
276
277       msg3 = xtryasprintf
278         (L_("A passphrase may not be a known term or match%%0A"
279             "certain pattern."));
280       if (!msg3)
281         {
282           err = gpg_error_from_syserror ();
283           goto leave;
284         }
285     }
286
287   if (failed_constraint && (msg1 || msg2 || msg3))
288     {
289       char *msg;
290       size_t n;
291
292       msg = strconcat
293         (L_("Warning: You have entered an insecure passphrase."),
294          "%0A%0A",
295          msg1? msg1 : "", msg1? "%0A" : "",
296          msg2? msg2 : "", msg2? "%0A" : "",
297          msg3? msg3 : "", msg3? "%0A" : "",
298          NULL);
299       if (!msg)
300         {
301           err = gpg_error_from_syserror ();
302           goto leave;
303         }
304       /* Strip a trailing "%0A".  */
305       n = strlen (msg);
306       if (n > 3 && !strcmp (msg + n - 3, "%0A"))
307         msg[n-3] = 0;
308
309       err = 1;
310       if (opt.enforce_passphrase_constraints)
311         *failed_constraint = msg;
312       else
313         {
314           err = take_this_one_anyway (ctrl, msg);
315           xfree (msg);
316         }
317     }
318
319  leave:
320   xfree (msg1);
321   xfree (msg2);
322   xfree (msg3);
323   return err;
324 }
325
326
327 /* Callback function to compare the first entered PIN with the one
328    currently being entered. */
329 static gpg_error_t
330 reenter_compare_cb (struct pin_entry_info_s *pi)
331 {
332   const char *pin1 = pi->check_cb_arg;
333
334   if (!strcmp (pin1, pi->pin))
335     return 0; /* okay */
336   return gpg_error (GPG_ERR_BAD_PASSPHRASE);
337 }
338
339
340 /* Ask the user for a new passphrase using PROMPT.  On success the
341    function returns 0 and store the passphrase at R_PASSPHRASE; if the
342    user opted not to use a passphrase NULL will be stored there.  The
343    user needs to free the returned string.  In case of an error and
344    error code is returned and NULL stored at R_PASSPHRASE.  */
345 gpg_error_t
346 agent_ask_new_passphrase (ctrl_t ctrl, const char *prompt,
347                           char **r_passphrase)
348 {
349   gpg_error_t err;
350   const char *text1 = prompt;
351   const char *text2 = L_("Please re-enter this passphrase");
352   char *initial_errtext = NULL;
353   struct pin_entry_info_s *pi, *pi2;
354
355   *r_passphrase = NULL;
356
357   if (ctrl->pinentry_mode == PINENTRY_MODE_LOOPBACK)
358     {
359         size_t size;
360         size_t len = 100;
361         unsigned char *buffer;
362
363         err = pinentry_loopback(ctrl, "NEW_PASSPHRASE", &buffer, &size, len);
364         if (!err)
365           {
366             if (size)
367               {
368                 buffer[size] = 0;
369                 *r_passphrase = buffer;
370               }
371             else
372                 *r_passphrase = NULL;
373           }
374         return err;
375     }
376
377   pi = gcry_calloc_secure (1, sizeof (*pi) + MAX_PASSPHRASE_LEN + 1);
378   if (!pi)
379     return gpg_error_from_syserror ();
380   pi2 = gcry_calloc_secure (1, sizeof (*pi2) + MAX_PASSPHRASE_LEN + 1);
381   if (!pi2)
382     {
383       err = gpg_error_from_syserror ();
384       xfree (pi2);
385       return err;
386     }
387   pi->max_length = MAX_PASSPHRASE_LEN + 1;
388   pi->max_tries = 3;
389   pi->with_qualitybar = 1;
390   pi->with_repeat = 1;
391   pi2->max_length = MAX_PASSPHRASE_LEN + 1;
392   pi2->max_tries = 3;
393   pi2->check_cb = reenter_compare_cb;
394   pi2->check_cb_arg = pi->pin;
395
396  next_try:
397   err = agent_askpin (ctrl, text1, NULL, initial_errtext, pi, NULL, 0);
398   xfree (initial_errtext);
399   initial_errtext = NULL;
400   if (!err)
401     {
402       if (check_passphrase_constraints (ctrl, pi->pin, &initial_errtext))
403         {
404           pi->failed_tries = 0;
405           pi2->failed_tries = 0;
406           goto next_try;
407         }
408       /* Unless the passphrase is empty or the pinentry told us that
409          it already did the repetition check, ask to confirm it.  */
410       if (*pi->pin && !pi->repeat_okay)
411         {
412           err = agent_askpin (ctrl, text2, NULL, NULL, pi2, NULL, 0);
413           if (gpg_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
414             { /* The re-entered one did not match and the user did not
415                  hit cancel. */
416               initial_errtext = xtrystrdup (L_("does not match - try again"));
417               if (initial_errtext)
418                 goto next_try;
419               err = gpg_error_from_syserror ();
420             }
421         }
422     }
423
424   if (!err && *pi->pin)
425     {
426       /* User wants a passphrase. */
427       *r_passphrase = xtrystrdup (pi->pin);
428       if (!*r_passphrase)
429         err = gpg_error_from_syserror ();
430     }
431
432   xfree (initial_errtext);
433   xfree (pi2);
434   xfree (pi);
435   return err;
436 }
437
438
439
440 /* Generate a new keypair according to the parameters given in
441    KEYPARAM.  If CACHE_NONCE is given first try to lookup a passphrase
442    using the cache nonce.  If NO_PROTECTION is true the key will not
443    be protected by a passphrase.  If OVERRIDE_PASSPHRASE is true that
444    passphrase will be used for the new key.  */
445 int
446 agent_genkey (ctrl_t ctrl, const char *cache_nonce,
447               const char *keyparam, size_t keyparamlen, int no_protection,
448               const char *override_passphrase, int preset, membuf_t *outbuf)
449 {
450   gcry_sexp_t s_keyparam, s_key, s_private, s_public;
451   char *passphrase_buffer = NULL;
452   const char *passphrase;
453   int rc;
454   size_t len;
455   char *buf;
456
457   rc = gcry_sexp_sscan (&s_keyparam, NULL, keyparam, keyparamlen);
458   if (rc)
459     {
460       log_error ("failed to convert keyparam: %s\n", gpg_strerror (rc));
461       return gpg_error (GPG_ERR_INV_DATA);
462     }
463
464   /* Get the passphrase now, cause key generation may take a while. */
465   if (override_passphrase)
466     passphrase = override_passphrase;
467   else if (no_protection || !cache_nonce)
468     passphrase = NULL;
469   else
470     {
471       passphrase_buffer = agent_get_cache (cache_nonce, CACHE_MODE_NONCE);
472       passphrase = passphrase_buffer;
473     }
474
475   if (passphrase || no_protection)
476     ;
477   else
478     {
479       rc = agent_ask_new_passphrase (ctrl,
480                                      L_("Please enter the passphrase to%0A"
481                                         "protect your new key"),
482                                      &passphrase_buffer);
483       if (rc)
484         return rc;
485       passphrase = passphrase_buffer;
486     }
487
488   rc = gcry_pk_genkey (&s_key, s_keyparam );
489   gcry_sexp_release (s_keyparam);
490   if (rc)
491     {
492       log_error ("key generation failed: %s\n", gpg_strerror (rc));
493       xfree (passphrase_buffer);
494       return rc;
495     }
496
497   /* break out the parts */
498   s_private = gcry_sexp_find_token (s_key, "private-key", 0);
499   if (!s_private)
500     {
501       log_error ("key generation failed: invalid return value\n");
502       gcry_sexp_release (s_key);
503       xfree (passphrase_buffer);
504       return gpg_error (GPG_ERR_INV_DATA);
505     }
506   s_public = gcry_sexp_find_token (s_key, "public-key", 0);
507   if (!s_public)
508     {
509       log_error ("key generation failed: invalid return value\n");
510       gcry_sexp_release (s_private);
511       gcry_sexp_release (s_key);
512       xfree (passphrase_buffer);
513       return gpg_error (GPG_ERR_INV_DATA);
514     }
515   gcry_sexp_release (s_key); s_key = NULL;
516
517   /* store the secret key */
518   if (DBG_CRYPTO)
519     log_debug ("storing private key\n");
520   rc = store_key (s_private, passphrase, 0, ctrl->s2k_count);
521   if (!rc)
522     {
523       if (!cache_nonce)
524         {
525           char tmpbuf[12];
526           gcry_create_nonce (tmpbuf, 12);
527           cache_nonce = bin2hex (tmpbuf, 12, NULL);
528         }
529       if (cache_nonce
530           && !no_protection
531           && !agent_put_cache (cache_nonce, CACHE_MODE_NONCE,
532                                passphrase, ctrl->cache_ttl_opt_preset))
533         agent_write_status (ctrl, "CACHE_NONCE", cache_nonce, NULL);
534       if (preset && !no_protection)
535         {
536           unsigned char grip[20];
537           char hexgrip[40+1];
538           if (gcry_pk_get_keygrip (s_private, grip))
539             {
540               bin2hex(grip, 20, hexgrip);
541               rc = agent_put_cache (hexgrip, CACHE_MODE_ANY, passphrase,
542                                     ctrl->cache_ttl_opt_preset);
543             }
544         }
545     }
546   xfree (passphrase_buffer);
547   passphrase_buffer = NULL;
548   passphrase = NULL;
549   gcry_sexp_release (s_private);
550   if (rc)
551     {
552       gcry_sexp_release (s_public);
553       return rc;
554     }
555
556   /* return the public key */
557   if (DBG_CRYPTO)
558     log_debug ("returning public key\n");
559   len = gcry_sexp_sprint (s_public, GCRYSEXP_FMT_CANON, NULL, 0);
560   assert (len);
561   buf = xtrymalloc (len);
562   if (!buf)
563     {
564       gpg_error_t tmperr = out_of_core ();
565       gcry_sexp_release (s_private);
566       gcry_sexp_release (s_public);
567       return tmperr;
568     }
569   len = gcry_sexp_sprint (s_public, GCRYSEXP_FMT_CANON, buf, len);
570   assert (len);
571   put_membuf (outbuf, buf, len);
572   gcry_sexp_release (s_public);
573   xfree (buf);
574
575   return 0;
576 }
577
578
579 \f
580 /* Apply a new passphrase to the key S_SKEY and store it.  If
581    PASSPHRASE_ADDR and *PASSPHRASE_ADDR are not NULL, use that
582    passphrase.  If PASSPHRASE_ADDR is not NULL store a newly entered
583    passphrase at that address. */
584 gpg_error_t
585 agent_protect_and_store (ctrl_t ctrl, gcry_sexp_t s_skey,
586                          char **passphrase_addr)
587 {
588   gpg_error_t err;
589
590   if (passphrase_addr && *passphrase_addr)
591     {
592       /* Take an empty string as request not to protect the key.  */
593       err = store_key (s_skey, **passphrase_addr? *passphrase_addr:NULL, 1,
594               ctrl->s2k_count);
595     }
596   else
597     {
598       char *pass = NULL;
599
600       if (passphrase_addr)
601         {
602           xfree (*passphrase_addr);
603           *passphrase_addr = NULL;
604         }
605       err = agent_ask_new_passphrase (ctrl,
606                                       L_("Please enter the new passphrase"),
607                                       &pass);
608       if (!err)
609         err = store_key (s_skey, pass, 1, ctrl->s2k_count);
610       if (!err && passphrase_addr)
611         *passphrase_addr = pass;
612       else
613         xfree (pass);
614     }
615
616   return err;
617 }