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