* gpgsm.c: New option --agent-program
[gnupg.git] / sm / call-agent.c
1 /* call-agent.c - divert operations to the agent
2  *      Copyright (C) 2001 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 <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26 #include <unistd.h> 
27 #include <time.h>
28 #include <assert.h>
29
30 #include <gcrypt.h>
31
32 #include "gpgsm.h"
33 #include "../assuan/assuan.h"
34 #include "i18n.h"
35
36 #ifdef _POSIX_OPEN_MAX
37 #define MAX_OPEN_FDS _POSIX_OPEN_MAX
38 #else
39 #define MAX_OPEN_FDS 20
40 #endif
41
42 #define LINELENGTH 1002 /* 1000 + [CR,]LF */
43
44 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
45                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
46 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
47
48
49 static pid_t agent_pid = -1;
50 /* fixme: replace this code by calling assuna functions */
51 static int inbound_fd = -1;
52 static int outbound_fd = -1;
53 static struct {
54   int eof;
55   char line[LINELENGTH];
56   int linelen;  /* w/o CR, LF - might not be the same as
57                    strlen(line) due to embedded nuls. However a nul
58                    is always written at this pos */
59   struct {
60     char line[LINELENGTH];
61     int linelen ;
62   } attic;
63 } inbound;
64
65
66 struct membuf {
67   size_t len;
68   size_t size;
69   char *buf;
70   int out_of_core;
71 };
72
73
74 \f
75 /* A simple implemnation of a dynamic buffer.  Use init_membuf() to
76    create a buffer, put_membuf to append bytes and get_membuf to
77    release and return the buffer.  Allocation errors are detected but
78    only returned at the final get_membuf(), this helps not to clutter
79    the code with out of core checks.  */
80
81 static void
82 init_membuf (struct membuf *mb, int initiallen)
83 {
84   mb->len = 0;
85   mb->size = initiallen;
86   mb->out_of_core = 0;
87   mb->buf = xtrymalloc (initiallen);
88   if (!mb->buf)
89       mb->out_of_core = 1;
90 }
91
92 static void
93 put_membuf (struct membuf *mb, const void *buf, size_t len)
94 {
95   if (mb->out_of_core)
96     return;
97
98   if (mb->len + len >= mb->size)
99     {
100       char *p;
101       
102       mb->size += len + 1024;
103       p = xtryrealloc (mb->buf, mb->size);
104       if (!p)
105         {
106           mb->out_of_core = 1;
107           return;
108         }
109       mb->buf = p;
110     }
111   memcpy (mb->buf + mb->len, buf, len);
112   mb->len += len;
113 }
114
115 static void *
116 get_membuf (struct membuf *mb, size_t *len)
117 {
118   char *p;
119
120   if (mb->out_of_core)
121     {
122       xfree (mb->buf);
123       mb->buf = NULL;
124       return NULL;
125     }
126
127   p = mb->buf;
128   *len = mb->len;
129   mb->buf = NULL;
130   mb->out_of_core = 1; /* don't allow a reuse */
131   return p;
132 }
133
134
135 \f
136 static int
137 writen (int fd, const void *buf, size_t nbytes)
138 {
139   size_t nleft = nbytes;
140   int nwritten;
141
142   while (nleft > 0)
143     {
144       nwritten = write (fd, buf, nleft);
145       if (nwritten < 0)
146         {
147           if (errno == EINTR)
148             nwritten = 0;
149           else 
150             {
151               log_error ("write() failed: %s\n", strerror (errno));
152               return seterr (Write_Error);
153             }
154         }
155       nleft -= nwritten;
156       buf = (const char*)buf + nwritten;
157     }
158   
159   return 0;
160 }
161
162
163
164 /* read an entire line */
165 static int
166 readline (int fd, char *buf, size_t buflen, int *r_nread, int *eof)
167 {
168   size_t nleft = buflen;
169   int n;
170   char *p;
171
172   *eof = 0;
173   *r_nread = 0;
174   while (nleft > 0)
175     {
176       do 
177         n = read (fd, buf, nleft);
178       while (n < 0 && errno == EINTR);
179       if (n < 0)
180         {
181           log_error ("read() error: %s\n", strerror (errno) );
182           return seterr (Read_Error);
183         }
184         
185       if (!n)
186         {
187           *eof = 1;
188           break; /* allow incomplete lines */
189         }
190       p = buf;
191       nleft -= n;
192       buf += n;
193       *r_nread += n;
194       
195       for (; n && *p != '\n'; n--, p++)
196         ;
197       if (n)
198         break; /* at least one full line available - that's enough for now */
199     }
200   
201   return 0;
202 }
203
204
205 static int
206 read_from_agent (int *okay)
207 {
208   char *line = inbound.line;
209   int n, nread;
210   int rc;
211
212   *okay = 0;
213  restart:  
214   if (inbound.eof)
215     return -1;
216
217   if (inbound.attic.linelen)
218     {
219       memcpy (line, inbound.attic.line, inbound.attic.linelen);
220       nread = inbound.attic.linelen;
221       inbound.attic.linelen = 0;
222       for (n=0; n < nread && line[n] != '\n'; n++)
223         ;
224       if (n < nread)
225         rc = 0; /* found another line in the attic */
226       else
227         { /* read the rest */
228           n = nread;
229           assert (n < LINELENGTH);
230           rc = readline (inbound_fd, line + n, LINELENGTH - n,
231                          &nread, &inbound.eof);
232         }
233     }
234   else
235     rc = readline (inbound_fd, line, LINELENGTH,
236                    &nread, &inbound.eof);
237   if (rc)
238     return seterr(Read_Error);
239   if (!nread)
240     {
241       assert (inbound.eof);
242       return -1; /* eof */ 
243     }
244
245   for (n=0; n < nread; n++)
246     {
247       if (line[n] == '\n')
248         {
249           if (n+1 < nread)
250             {
251               n++;
252               /* we have to copy the rest because the handlers are
253                  allowed to modify the passed buffer */
254               memcpy (inbound.attic.line, line+n, nread-n);
255               inbound.attic.linelen = nread-n;
256               n--;
257             }
258           if (n && line[n-1] == '\r')
259             n--;
260           line[n] = 0;
261           inbound.linelen = n;
262           if (n && *line == '#')
263             goto restart;
264
265           rc = 0;
266           if (n >= 1
267               && line[0] == 'D' && line[1] == ' ')
268             *okay = 2; /* data line */
269           else if (n >= 2
270               && line[0] == 'O' && line[1] == 'K'
271               && (line[2] == '\0' || line[2] == ' '))
272             *okay = 1;
273           else if (n >= 3
274                    && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
275                    && (line[3] == '\0' || line[3] == ' '))
276             *okay = 0;
277           else
278             rc = seterr (Invalid_Response);
279           return rc;
280         }
281     }
282
283   *line = 0;
284   inbound.linelen = 0;
285   return inbound.eof? seterr (Incomplete_Line):seterr (Invalid_Response);
286 }
287
288
289
290
291 \f
292 /* Try to connect to the agent via socket or fork it off and work by
293    pipes.  Handle the server's initial greeting */
294 static int
295 start_agent (void)
296 {
297   int rc;
298   char *infostr, *p;
299   int okay;
300
301   if (agent_pid != -1)
302     return 0;
303
304   infostr = getenv ("GPG_AGENT_INFO");
305   if (!infostr)
306     {
307       pid_t pid;
308       int inpipe[2], outpipe[2];
309
310       log_info (_("no running gpg-agent - starting one\n"));
311       
312       if (fflush (NULL))
313         {
314           log_error ("error flushing pending output: %s\n", strerror (errno));
315           return seterr (Write_Error);
316         }
317
318       if (pipe (inpipe))
319         {
320           log_error ("error creating pipe: %s\n", strerror (errno));
321           return seterr (General_Error);
322         }
323       if (pipe (outpipe))
324         {
325           log_error ("error creating pipe: %s\n", strerror (errno));
326           close (inpipe[0]);
327           close (inpipe[1]);
328           return seterr (General_Error);
329         }
330
331       pid = fork ();
332       if (pid == -1) 
333         return seterr (General_Error);
334
335       if (!pid)
336         { /* child */
337           int i, n;
338           char errbuf[512];
339           int log_fd = log_get_fd ();
340           const char *pgmname;
341
342           /* close all files which will not be duped but keep stderr
343              and log_stream for now */
344           n = sysconf (_SC_OPEN_MAX);
345           if (n < 0)
346               n = MAX_OPEN_FDS;
347           for (i=0; i < n; i++)
348             {
349               if (i != fileno (stderr) && i != log_fd
350                   && i != inpipe[1] && i != outpipe[0])
351                 close(i);
352             }
353           errno = 0;
354
355           if (inpipe[1] != 1)
356             {
357               if (dup2 (inpipe[1], 1) == -1)
358                 {
359                   log_error ("dup2 failed in child: %s\n", strerror (errno));
360                   _exit (4);
361                 }
362               close (inpipe[1]);
363             }
364           if (outpipe[0] != 0)
365             {
366               if (dup2 (outpipe[0], 0) == -1)
367                 {
368                   log_error ("dup2 failed in child: %s\n", strerror (errno));
369                   _exit (4);
370                 }
371               close (outpipe[0]);
372             }
373
374           /* and start it */
375           if (!opt.agent_program || !*opt.agent_program)
376             opt.agent_program = "../agent/gpg-agent";
377           if ( !(pgmname = strrchr (opt.agent_program, '/')))
378             pgmname = opt.agent_program;
379           else
380             pgmname++;
381           execl (opt.agent_program, pgmname, "--server", NULL); 
382           /* oops - tell the parent about it */
383           snprintf (errbuf, DIM(errbuf)-1, "ERR %d can't exec `%s': %.50s\n",
384                     ASSUAN_Problem_Starting_Server, opt.agent_program,
385                     strerror (errno));
386           errbuf[DIM(errbuf)-1] = 0;
387           writen (1, errbuf, strlen (errbuf));
388           _exit (4);
389         } /* end child */
390
391       agent_pid = pid;
392     
393       inbound_fd = inpipe[0];
394       close (inpipe[1]);
395
396       close (outpipe[0]);
397       outbound_fd = outpipe[1];
398     }
399   else
400     {
401       infostr = xstrdup (infostr);
402       if ( !(p = strchr (infostr, ':')) || p == infostr
403            /* || (p-infostr)+1 >= sizeof client_addr.sun_path */)
404         {
405           log_error (_("malformed GPG_AGENT_INFO environment variable\n"));
406           xfree (infostr);
407           return seterr (General_Error);
408         }
409       *p = 0;
410       log_error (_("socket based agent communication not yet implemented\n"));
411       return seterr (Not_Implemented);
412     }
413
414   inbound.eof = 0;
415   inbound.linelen = 0;
416   inbound.attic.linelen = 0;
417
418   /* The server is available - read the greeting */
419   rc = read_from_agent (&okay);
420   if (rc)
421     {
422       log_error ("can't connect to the agent: %s\n", gnupg_strerror (rc));
423     }
424   else if (!okay)
425     {
426       log_error ("can't connect to the agent: %s\n", inbound.line);
427       rc = seterr (No_Agent);
428     }
429  else
430    log_debug ("connection to agent established\n");
431
432   return 0;
433 }
434
435
436 static int
437 request_reply (const char *line, struct membuf *membuf)
438 {
439   int rc, okay;
440
441   if (DBG_AGENT)
442     log_debug ("agent-request=`%.*s'", (int)(*line? strlen(line)-1:0), line);
443   rc = writen (outbound_fd, line, strlen (line));
444   if (rc)
445     return rc;
446  again:
447   rc = read_from_agent (&okay);
448   if (rc)
449       log_error ("error reading from agent: %s\n", gnupg_strerror (rc));
450   else if (!okay)
451     {
452       log_error ("got error from agent: %s\n", inbound.line);
453       rc = seterr (Agent_Error);
454     }
455   else if (okay == 2 && !membuf)
456     {
457       log_error ("got unexpected data line\n");
458       rc = seterr (Agent_Error);
459     }
460   else
461     {
462       if (DBG_AGENT)
463         log_debug ("agent-reply=`%s'", inbound.line);
464     }
465
466   if (!rc && okay == 2 && inbound.linelen >= 2)
467     { /* handle data line */
468       unsigned char *buf = inbound.line;
469       size_t len = inbound.linelen;
470       unsigned char *p;
471
472       buf += 2;
473       len -= 2;
474
475       p = buf;
476       while (len)
477         {
478           for (;len && *p != '%'; len--, p++)
479             ;
480           put_membuf (membuf, buf, p-buf);
481           if (len>2)
482             { /* handle escaping */
483               unsigned char tmp[1];
484               p++;
485               *tmp = xtoi_2 (p);
486               p += 2;
487               len -= 3;
488               put_membuf (membuf, tmp, 1);
489             }
490           buf = p;
491         }
492       goto again;
493     }
494   return rc;
495 }
496
497
498
499 \f
500 /* Call the agent to do a sign operation using the key identified by
501    the hex string KEYGRIP. */
502 int
503 gpgsm_agent_pksign (const char *keygrip,
504                     unsigned char *digest, size_t digestlen, int digestalgo,
505                     char **r_buf, size_t *r_buflen )
506 {
507   int rc, i;
508   char *p, line[LINELENGTH];
509   struct membuf data;
510   size_t len;
511
512   *r_buf = NULL;
513   rc = start_agent ();
514   if (rc)
515     return rc;
516
517   if (digestlen*2 + 50 > DIM(line))
518     return seterr (General_Error);
519
520   rc = request_reply ("RESET\n", NULL);
521   if (rc)
522     return rc;
523
524   snprintf (line, DIM(line)-1, "SIGKEY %s\n", keygrip);
525   line[DIM(line)-1] = 0;
526   rc = request_reply (line, NULL);
527   if (rc)
528     return rc;
529
530   sprintf (line, "SETHASH %d ", digestalgo);
531   p = line + strlen (line);
532   for (i=0; i < digestlen ; i++, p += 2 )
533     sprintf (p, "%02X", digest[i]);
534   strcpy (p, "\n");
535   rc = request_reply (line, NULL);
536   if (rc)
537     return rc;
538
539   init_membuf (&data, 1024);
540   rc = request_reply ("PKSIGN\n", &data);
541   if (rc)
542     {
543       xfree (get_membuf (&data, &len));
544       return rc;
545     }
546   *r_buf = get_membuf (&data, r_buflen);
547 /*    if (DBG_AGENT && *r_buf) */
548 /*      {  */
549 /*        FILE *fp; */
550 /*        char fname[100]; */
551       
552 /*        memcpy (fname, keygrip, 40); */
553 /*        strcpy (fname+40, "_pksign-dump.tmp"); */
554 /*        fp = fopen (fname, "wb"); */
555 /*        fwrite (*r_buf, *r_buflen, 1, fp); */
556 /*        fclose (fp); */
557 /*    } */
558
559   return *r_buf? 0 : GNUPG_Out_Of_Core;
560 }
561
562
563
564