2005-01-26 Moritz Schulte <moritz@g10code.com>
[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 disconnetc 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 ctrl,
292               const char *desc_text, const char *initial_errtext,
293               struct pin_entry_info_s *pininfo)
294 {
295   int rc;
296   char line[ASSUAN_LINELENGTH];
297   struct entry_parm_s parm;
298   const char *errtext = NULL;
299   int is_pin = 0;
300
301   if (opt.batch)
302     return 0; /* fixme: we should return BAD PIN */
303
304   if (!pininfo || pininfo->max_length < 1)
305     return gpg_error (GPG_ERR_INV_VALUE);
306   if (!desc_text && pininfo->min_digits)
307     desc_text = _("Please enter your PIN, so that the secret key "
308                   "can be unlocked for this session");
309   else if (!desc_text)
310     desc_text = _("Please enter your passphrase, so that the secret key "
311                   "can be unlocked for this session");
312
313   is_pin = desc_text && strstr (desc_text, "PIN");
314
315   rc = start_pinentry (ctrl);
316   if (rc)
317     return rc;
318
319   snprintf (line, DIM(line)-1, "SETDESC %s", desc_text);
320   line[DIM(line)-1] = 0;
321   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
322   if (rc)
323     return unlock_pinentry (map_assuan_err (rc));
324
325   rc = assuan_transact (entry_ctx,
326                         is_pin? "SETPROMPT PIN:"
327                               : "SETPROMPT Passphrase:",
328                         NULL, NULL, NULL, NULL, NULL, NULL);
329   if (rc)
330     return unlock_pinentry (map_assuan_err (rc));
331
332
333   if (initial_errtext)
334     { 
335       snprintf (line, DIM(line)-1, "SETERROR %s", initial_errtext);
336       line[DIM(line)-1] = 0;
337       rc = assuan_transact (entry_ctx, line,
338                             NULL, NULL, NULL, NULL, NULL, NULL);
339       if (rc)
340         return unlock_pinentry (map_assuan_err (rc));
341     }
342
343   for (;pininfo->failed_tries < pininfo->max_tries; pininfo->failed_tries++)
344     {
345       memset (&parm, 0, sizeof parm);
346       parm.size = pininfo->max_length;
347       parm.buffer = pininfo->pin;
348
349       if (errtext)
350         { 
351           /* fixme: should we show the try count? It must be translated */
352           snprintf (line, DIM(line)-1, "SETERROR %s (try %d of %d)",
353                     errtext, pininfo->failed_tries+1, pininfo->max_tries);
354           line[DIM(line)-1] = 0;
355           rc = assuan_transact (entry_ctx, line,
356                                 NULL, NULL, NULL, NULL, NULL, NULL);
357           if (rc)
358             return unlock_pinentry (map_assuan_err (rc));
359           errtext = NULL;
360         }
361       
362       rc = assuan_transact (entry_ctx, "GETPIN", getpin_cb, &parm,
363                             NULL, NULL, NULL, NULL);
364       if (rc == ASSUAN_Too_Much_Data)
365         errtext = is_pin? _("PIN too long")
366                         : _("Passphrase too long");
367       else if (rc)
368         return unlock_pinentry (map_assuan_err (rc));
369
370       if (!errtext && pininfo->min_digits)
371         {
372           /* do some basic checks on the entered PIN. */
373           if (!all_digitsp (pininfo->pin))
374             errtext = _("Invalid characters in PIN");
375           else if (pininfo->max_digits
376                    && strlen (pininfo->pin) > pininfo->max_digits)
377             errtext = _("PIN too long");
378           else if (strlen (pininfo->pin) < pininfo->min_digits)
379             errtext = _("PIN too short");
380         }
381
382       if (!errtext && pininfo->check_cb)
383         {
384           /* More checks by utilizing the optional callback. */
385           pininfo->cb_errtext = NULL;
386           rc = pininfo->check_cb (pininfo);
387           if (rc == -1 && pininfo->cb_errtext)
388             errtext = pininfo->cb_errtext;
389           else if (gpg_err_code (rc) == GPG_ERR_BAD_PASSPHRASE
390                    || gpg_err_code (rc) == GPG_ERR_BAD_PIN)
391             errtext = (is_pin? _("Bad PIN")
392                        : _("Bad Passphrase"));
393           else if (rc)
394             return unlock_pinentry (map_assuan_err (rc));
395         }
396
397       if (!errtext)
398         return unlock_pinentry (0); /* okay, got a PIN or passphrase */
399     }
400
401   return unlock_pinentry (gpg_error (pininfo->min_digits? GPG_ERR_BAD_PIN
402                           : GPG_ERR_BAD_PASSPHRASE));
403 }
404
405
406 \f
407 /* Ask for the passphrase using the supplied arguments.  The
408    passphrase is returned in RETPASS as an hex encoded string to be
409    freed by the caller */
410 int 
411 agent_get_passphrase (CTRL ctrl,
412                       char **retpass, const char *desc, const char *prompt,
413                       const char *errtext)
414 {
415
416   int rc;
417   char line[ASSUAN_LINELENGTH];
418   struct entry_parm_s parm;
419   unsigned char *p, *hexstring;
420   int i;
421
422   *retpass = NULL;
423   if (opt.batch)
424     return gpg_error (GPG_ERR_BAD_PASSPHRASE); 
425
426   rc = start_pinentry (ctrl);
427   if (rc)
428     return rc;
429
430   if (!prompt)
431     prompt = desc && strstr (desc, "PIN")? "PIN": _("Passphrase");
432
433
434   if (desc)
435     snprintf (line, DIM(line)-1, "SETDESC %s", desc);
436   else
437     snprintf (line, DIM(line)-1, "RESET");
438   line[DIM(line)-1] = 0;
439   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
440   if (rc)
441     return unlock_pinentry (map_assuan_err (rc));
442
443   snprintf (line, DIM(line)-1, "SETPROMPT %s", prompt);
444   line[DIM(line)-1] = 0;
445   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
446   if (rc)
447     return unlock_pinentry (map_assuan_err (rc));
448
449   if (errtext)
450     {
451       snprintf (line, DIM(line)-1, "SETERROR %s", errtext);
452       line[DIM(line)-1] = 0;
453       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
454       if (rc)
455         return unlock_pinentry (map_assuan_err (rc));
456     }
457
458   memset (&parm, 0, sizeof parm);
459   parm.size = ASSUAN_LINELENGTH/2 - 5;
460   parm.buffer = gcry_malloc_secure (parm.size+10);
461   if (!parm.buffer)
462     return unlock_pinentry (out_of_core ());
463
464   assuan_begin_confidential (entry_ctx);
465   rc = assuan_transact (entry_ctx, "GETPIN", getpin_cb, &parm, NULL, NULL, NULL, NULL);
466   if (rc)
467     {
468       xfree (parm.buffer);
469       return unlock_pinentry (map_assuan_err (rc));
470     }
471   
472   hexstring = gcry_malloc_secure (strlen (parm.buffer)*2+1);
473   if (!hexstring)
474     {
475       gpg_error_t tmperr = out_of_core ();
476       xfree (parm.buffer);
477       return unlock_pinentry (tmperr);
478     }
479
480   for (i=0, p=parm.buffer; *p; p++, i += 2)
481     sprintf (hexstring+i, "%02X", *p);
482   
483   xfree (parm.buffer);
484   *retpass = hexstring;
485   return unlock_pinentry (0);
486 }
487
488
489 \f
490 /* Pop up the PIN-entry, display the text and the prompt and ask the
491    user to confirm this.  We return 0 for success, ie. the used
492    confirmed it, GPG_ERR_NOT_CONFIRMED for what the text says or an
493    other error. */
494 int 
495 agent_get_confirmation (CTRL ctrl,
496                         const char *desc, const char *ok, const char *cancel)
497 {
498   int rc;
499   char line[ASSUAN_LINELENGTH];
500
501   rc = start_pinentry (ctrl);
502   if (rc)
503     return rc;
504
505   if (desc)
506     snprintf (line, DIM(line)-1, "SETDESC %s", desc);
507   else
508     snprintf (line, DIM(line)-1, "RESET");
509   line[DIM(line)-1] = 0;
510   rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
511   if (rc)
512     return unlock_pinentry (map_assuan_err (rc));
513
514   if (ok)
515     {
516       snprintf (line, DIM(line)-1, "SETOK %s", ok);
517       line[DIM(line)-1] = 0;
518       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
519       if (rc)
520         return unlock_pinentry (map_assuan_err (rc));
521     }
522   if (cancel)
523     {
524       snprintf (line, DIM(line)-1, "SETCANCEL %s", cancel);
525       line[DIM(line)-1] = 0;
526       rc = assuan_transact (entry_ctx, line, NULL, NULL, NULL, NULL, NULL, NULL);
527       if (rc)
528         return unlock_pinentry (map_assuan_err (rc));
529     }
530
531   rc = assuan_transact (entry_ctx, "CONFIRM", NULL, NULL, NULL, NULL, NULL, NULL);
532   return unlock_pinentry (map_assuan_err (rc));
533 }
534
535
536