* call-scd.c (inq_needpin): Skip leading spaces in of PIN
[gnupg.git] / agent / query.c
1 /* query.c - fork of the pinentry to query stuff from the user
2  * Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 #include <unistd.h>
29 #include <sys/stat.h>
30 #ifdef USE_GNU_PTH
31 # include <pth.h>
32 #endif
33
34 #include "agent.h"
35 #include "i18n.h"
36 #include <assuan.h>
37
38 #ifdef _POSIX_OPEN_MAX
39 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
40 #else
41 #define MAX_OPEN_FDS 20
42 #endif
43
44
45 /* Because access to the pinentry must be serialized (it is and shall
46    be a global mutual dialog) we should better timeout further
47    requests after some time.  2 minutes seem to be a reasonable
48    time. */
49 #define LOCK_TIMEOUT  (1*60)
50
51
52 static ASSUAN_CONTEXT entry_ctx = NULL;
53 #ifdef USE_GNU_PTH
54 static pth_mutex_t entry_lock;
55 #endif
56
57 /* data to be passed to our callbacks */
58 struct entry_parm_s {
59   int lines;
60   size_t size;
61   char *buffer;
62 };
63
64
65
66 \f
67 /* This function must be called once to initialize this module.  This
68    has to be done before a second thread is spawned.  We can't do the
69    static initialization because Pth emulation code might not be able
70    to do a static init; in particualr, it is not possible for W32. */
71 void
72 initialize_module_query (void)
73 {
74 #ifdef USE_GNU_PTH
75   static int initialized;
76
77   if (!initialized)
78     if (pth_mutex_init (&entry_lock))
79       initialized = 1;
80 #endif /*USE_GNU_PTH*/
81 }
82
83
84
85
86 /* Unlock the pinentry so that another thread can start one and
87    disconnect that pinentry - we do this after the unlock so that a
88    stalled pinentry does not block other threads.  Fixme: We should
89    have a timeout in Assuan for the disconnect operation. */
90 static int 
91 unlock_pinentry (int rc)
92 {
93   ASSUAN_CONTEXT ctx = entry_ctx;
94
95 #ifdef USE_GNU_PTH
96   if (!pth_mutex_release (&entry_lock))
97     {
98       log_error ("failed to release the entry lock\n");
99       if (!rc)
100         rc = gpg_error (GPG_ERR_INTERNAL);
101     }
102 #endif
103   entry_ctx = NULL;
104   assuan_disconnect (ctx);
105   return rc;
106 }
107
108
109 /* To make sure we leave no secrets in our image after forking of the
110    pinentry, we use this callback. */
111 static void
112 atfork_cb (void *opaque, int where)
113 {
114   if (!where)
115     gcry_control (GCRYCTL_TERM_SECMEM);
116 }
117
118
119 /* Fork off the pin entry if this has not already been done.  Note,
120    that this function must always be used to aquire the lock for the
121    pinentry - we will serialize _all_ pinentry calls.
122  */
123 static int
124 start_pinentry (CTRL ctrl)
125 {
126   int rc;
127   const char *pgmname;
128   ASSUAN_CONTEXT ctx;
129   const char *argv[5];
130   int no_close_list[3];
131   int i;
132
133 #ifdef USE_GNU_PTH
134  {
135    pth_event_t evt;
136
137    evt = pth_event (PTH_EVENT_TIME, pth_timeout (LOCK_TIMEOUT, 0));
138    if (!pth_mutex_acquire (&entry_lock, 0, evt))
139     {
140       if (pth_event_occurred (evt))
141         rc = gpg_error (GPG_ERR_TIMEOUT);
142       else
143         rc = gpg_error (GPG_ERR_INTERNAL);
144       pth_event_free (evt, PTH_FREE_THIS);
145       log_error (_("failed to acquire the pinentry lock: %s\n"),
146                  gpg_strerror (rc));
147       return rc;
148     }
149    pth_event_free (evt, PTH_FREE_THIS);
150  }
151 #endif
152
153   if (entry_ctx)
154     return 0; 
155
156   if (opt.verbose)
157     log_info ("starting a new PIN Entry\n");
158       
159   if (fflush (NULL))
160     {
161       gpg_error_t tmperr = gpg_error (gpg_err_code_from_errno (errno));
162       log_error ("error flushing pending output: %s\n", strerror (errno));
163       return unlock_pinentry (tmperr);
164     }
165
166   if (!opt.pinentry_program || !*opt.pinentry_program)
167     opt.pinentry_program = GNUPG_DEFAULT_PINENTRY;
168   if ( !(pgmname = strrchr (opt.pinentry_program, '/')))
169     pgmname = opt.pinentry_program;
170   else
171     pgmname++;
172
173   argv[0] = pgmname;
174   if (ctrl->display && !opt.keep_display)
175     {
176       argv[1] = "--display";
177       argv[2] = ctrl->display;
178       argv[3] = NULL;
179     }
180   else
181     argv[1] = NULL;
182   
183   i=0;
184   if (!opt.running_detached)
185     {
186       if (log_get_fd () != -1)
187         no_close_list[i++] = log_get_fd ();
188       no_close_list[i++] = fileno (stderr);
189     }
190   no_close_list[i] = -1;
191
192   /* Connect to the pinentry and perform initial handshaking */
193   rc = assuan_pipe_connect2 (&ctx, opt.pinentry_program, (char**)argv,
194                              no_close_list, atfork_cb, NULL);
195   if (rc)
196     {
197       log_error ("can't connect to the PIN entry module: %s\n",
198                  assuan_strerror (rc));
199       return unlock_pinentry (gpg_error (GPG_ERR_NO_PIN_ENTRY));
200     }
201   entry_ctx = ctx;
202
203   if (DBG_ASSUAN)
204     log_debug ("connection to PIN entry established\n");
205
206   rc = assuan_transact (entry_ctx, 
207                         opt.no_grab? "OPTION no-grab":"OPTION grab",
208                         NULL, NULL, NULL, NULL, NULL, NULL);
209   if (rc)
210     return unlock_pinentry (map_assuan_err (rc));
211   if (ctrl->ttyname)
212     {
213       char *optstr;
214       if (asprintf (&optstr, "OPTION ttyname=%s", ctrl->ttyname) < 0 )
215         return unlock_pinentry (out_of_core ());
216       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
217                             NULL);
218       free (optstr);
219       if (rc)
220         return unlock_pinentry (map_assuan_err (rc));
221     }
222   if (ctrl->ttytype)
223     {
224       char *optstr;
225       if (asprintf (&optstr, "OPTION ttytype=%s", ctrl->ttytype) < 0 )
226         return unlock_pinentry (out_of_core ());
227       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
228                             NULL);
229       if (rc)
230         return unlock_pinentry (map_assuan_err (rc));
231     }
232   if (ctrl->lc_ctype)
233     {
234       char *optstr;
235       if (asprintf (&optstr, "OPTION lc-ctype=%s", ctrl->lc_ctype) < 0 )
236         return unlock_pinentry (out_of_core ());
237       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
238                             NULL);
239       if (rc)
240         return unlock_pinentry (map_assuan_err (rc));
241     }
242   if (ctrl->lc_messages)
243     {
244       char *optstr;
245       if (asprintf (&optstr, "OPTION lc-messages=%s", ctrl->lc_messages) < 0 )
246         return unlock_pinentry (out_of_core ());
247       rc = assuan_transact (entry_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
248                             NULL);
249       if (rc)
250         return unlock_pinentry (map_assuan_err (rc));
251     }
252   return 0;
253 }
254
255
256 static AssuanError
257 getpin_cb (void *opaque, const void *buffer, size_t length)
258 {
259   struct entry_parm_s *parm = opaque;
260
261   if (!buffer)
262     return 0;
263
264   /* we expect the pin to fit on one line */
265   if (parm->lines || length >= parm->size)
266     return ASSUAN_Too_Much_Data;
267
268   /* fixme: we should make sure that the assuan buffer is allocated in
269      secure memory or read the response byte by byte */
270   memcpy (parm->buffer, buffer, length);
271   parm->buffer[length] = 0;
272   parm->lines++;
273   return 0;
274 }
275
276
277 static int
278 all_digitsp( const char *s)
279 {
280   for (; *s && *s >= '0' && *s <= '9'; s++)
281     ;
282   return !*s;
283 }  
284
285
286 \f
287 /* Call the Entry and ask for the PIN.  We do check for a valid PIN
288    number here and repeat it as long as we have invalid formed
289    numbers. */
290 int
291 agent_askpin (ctrl_t ctrl,
292               const char *desc_text, const char *prompt_text,
293               const char *initial_errtext,
294               struct pin_entry_info_s *pininfo)
295 {
296   int rc;
297   char line[ASSUAN_LINELENGTH];
298   struct entry_parm_s parm;
299   const char *errtext = NULL;
300   int is_pin = 0;
301
302   if (opt.batch)
303     return 0; /* fixme: we should return BAD PIN */
304
305   if (!pininfo || pininfo->max_length < 1)
306     return gpg_error (GPG_ERR_INV_VALUE);
307   if (!desc_text && pininfo->min_digits)
308     desc_text = _("Please enter your PIN, so that the secret key "
309                   "can be unlocked for this session");
310   else if (!desc_text)
311     desc_text = _("Please enter your passphrase, so that the secret key "
312                   "can be unlocked for this session");
313
314   if (prompt_text)
315     is_pin = !!strstr (prompt_text, "PIN");
316   else
317     is_pin = desc_text && strstr (desc_text, "PIN");
318
319   rc = start_pinentry (ctrl);
320   if (rc)
321     return rc;
322
323   snprintf (line, DIM(line)-1, "SETDESC %s", desc_text);
324   line[DIM(line)-1] = 0;
325   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
326   if (rc)
327     return unlock_pinentry (map_assuan_err (rc));
328
329   snprintf (line, DIM(line)-1, "SETPROMPT %s",
330             prompt_text? prompt_text : is_pin? "PIN:" : "Passphrase:");
331   line[DIM(line)-1] = 0;
332   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
333   if (rc)
334     return unlock_pinentry (map_assuan_err (rc));
335
336
337   if (initial_errtext)
338     { 
339       snprintf (line, DIM(line)-1, "SETERROR %s", initial_errtext);
340       line[DIM(line)-1] = 0;
341       rc = assuan_transact (entry_ctx, line,
342                             NULL, NULL, NULL, NULL, NULL, NULL);
343       if (rc)
344         return unlock_pinentry (map_assuan_err (rc));
345     }
346
347   for (;pininfo->failed_tries < pininfo->max_tries; pininfo->failed_tries++)
348     {
349       memset (&parm, 0, sizeof parm);
350       parm.size = pininfo->max_length;
351       parm.buffer = pininfo->pin;
352
353       if (errtext)
354         { 
355           /* fixme: should we show the try count? It must be translated */
356           snprintf (line, DIM(line)-1, "SETERROR %s (try %d of %d)",
357                     errtext, pininfo->failed_tries+1, pininfo->max_tries);
358           line[DIM(line)-1] = 0;
359           rc = assuan_transact (entry_ctx, line,
360                                 NULL, NULL, NULL, NULL, NULL, NULL);
361           if (rc)
362             return unlock_pinentry (map_assuan_err (rc));
363           errtext = NULL;
364         }
365       
366       rc = assuan_transact (entry_ctx, "GETPIN", getpin_cb, &parm,
367                             NULL, NULL, NULL, NULL);
368       if (rc == ASSUAN_Too_Much_Data)
369         errtext = is_pin? _("PIN too long")
370                         : _("Passphrase too long");
371       else if (rc)
372         return unlock_pinentry (map_assuan_err (rc));
373
374       if (!errtext && pininfo->min_digits)
375         {
376           /* do some basic checks on the entered PIN. */
377           if (!all_digitsp (pininfo->pin))
378             errtext = _("Invalid characters in PIN");
379           else if (pininfo->max_digits
380                    && strlen (pininfo->pin) > pininfo->max_digits)
381             errtext = _("PIN too long");
382           else if (strlen (pininfo->pin) < pininfo->min_digits)
383             errtext = _("PIN too short");
384         }
385
386       if (!errtext && pininfo->check_cb)
387         {
388           /* More checks by utilizing the optional callback. */
389           pininfo->cb_errtext = NULL;
390           rc = pininfo->check_cb (pininfo);
391           if (rc == -1 && pininfo->cb_errtext)
392             errtext = pininfo->cb_errtext;
393           else if (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
394                    || gpg_err_code (rc) == GPG_ERR_BAD_PIN)
395             errtext = (is_pin? _("Bad PIN")
396                        : _("Bad Passphrase"));
397           else if (rc)
398             return unlock_pinentry (map_assuan_err (rc));
399         }
400
401       if (!errtext)
402         return unlock_pinentry (0); /* okay, got a PIN or passphrase */
403     }
404
405   return unlock_pinentry (gpg_error (pininfo->min_digits? GPG_ERR_BAD_PIN
406                           : GPG_ERR_BAD_PASSPHRASE));
407 }
408
409
410 \f
411 /* Ask for the passphrase using the supplied arguments.  The
412    passphrase is returned in RETPASS as an hex encoded string to be
413    freed by the caller */
414 int 
415 agent_get_passphrase (CTRL ctrl,
416                       char **retpass, const char *desc, const char *prompt,
417                       const char *errtext)
418 {
419
420   int rc;
421   char line[ASSUAN_LINELENGTH];
422   struct entry_parm_s parm;
423   unsigned char *p, *hexstring;
424   int i;
425
426   *retpass = NULL;
427   if (opt.batch)
428     return gpg_error (GPG_ERR_BAD_PASSPHRASE); 
429
430   rc = start_pinentry (ctrl);
431   if (rc)
432     return rc;
433
434   if (!prompt)
435     prompt = desc && strstr (desc, "PIN")? "PIN": _("Passphrase");
436
437
438   if (desc)
439     snprintf (line, DIM(line)-1, "SETDESC %s", desc);
440   else
441     snprintf (line, DIM(line)-1, "RESET");
442   line[DIM(line)-1] = 0;
443   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
444   if (rc)
445     return unlock_pinentry (map_assuan_err (rc));
446
447   snprintf (line, DIM(line)-1, "SETPROMPT %s", prompt);
448   line[DIM(line)-1] = 0;
449   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
450   if (rc)
451     return unlock_pinentry (map_assuan_err (rc));
452
453   if (errtext)
454     {
455       snprintf (line, DIM(line)-1, "SETERROR %s", errtext);
456       line[DIM(line)-1] = 0;
457       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
458       if (rc)
459         return unlock_pinentry (map_assuan_err (rc));
460     }
461
462   memset (&parm, 0, sizeof parm);
463   parm.size = ASSUAN_LINELENGTH/2 - 5;
464   parm.buffer = gcry_malloc_secure (parm.size+10);
465   if (!parm.buffer)
466     return unlock_pinentry (out_of_core ());
467
468   assuan_begin_confidential (entry_ctx);
469   rc = assuan_transact (entry_ctx, "GETPIN", getpin_cb, &parm, NULL, NULL, NULL, NULL);
470   if (rc)
471     {
472       xfree (parm.buffer);
473       return unlock_pinentry (map_assuan_err (rc));
474     }
475   
476   hexstring = gcry_malloc_secure (strlen (parm.buffer)*2+1);
477   if (!hexstring)
478     {
479       gpg_error_t tmperr = out_of_core ();
480       xfree (parm.buffer);
481       return unlock_pinentry (tmperr);
482     }
483
484   for (i=0, p=parm.buffer; *p; p++, i += 2)
485     sprintf (hexstring+i, "%02X", *p);
486   
487   xfree (parm.buffer);
488   *retpass = hexstring;
489   return unlock_pinentry (0);
490 }
491
492
493 \f
494 /* Pop up the PIN-entry, display the text and the prompt and ask the
495    user to confirm this.  We return 0 for success, ie. the used
496    confirmed it, GPG_ERR_NOT_CONFIRMED for what the text says or an
497    other error. */
498 int 
499 agent_get_confirmation (CTRL ctrl,
500                         const char *desc, const char *ok, const char *cancel)
501 {
502   int rc;
503   char line[ASSUAN_LINELENGTH];
504
505   rc = start_pinentry (ctrl);
506   if (rc)
507     return rc;
508
509   if (desc)
510     snprintf (line, DIM(line)-1, "SETDESC %s", desc);
511   else
512     snprintf (line, DIM(line)-1, "RESET");
513   line[DIM(line)-1] = 0;
514   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
515   if (rc)
516     return unlock_pinentry (map_assuan_err (rc));
517
518   if (ok)
519     {
520       snprintf (line, DIM(line)-1, "SETOK %s", ok);
521       line[DIM(line)-1] = 0;
522       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
523       if (rc)
524         return unlock_pinentry (map_assuan_err (rc));
525     }
526   if (cancel)
527     {
528       snprintf (line, DIM(line)-1, "SETCANCEL %s", cancel);
529       line[DIM(line)-1] = 0;
530       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
531       if (rc)
532         return unlock_pinentry (map_assuan_err (rc));
533     }
534
535   rc = assuan_transact (entry_ctx, "CONFIRM", NULL, NULL, NULL, NULL, NULL, NULL);
536   return unlock_pinentry (map_assuan_err (rc));
537 }
538
539
540