diff options
Diffstat (limited to 'sm/call-agent.c')
| -rw-r--r-- | sm/call-agent.c | 556 |
1 files changed, 556 insertions, 0 deletions
diff --git a/sm/call-agent.c b/sm/call-agent.c new file mode 100644 index 000000000..c440f2bf1 --- /dev/null +++ b/sm/call-agent.c @@ -0,0 +1,556 @@ +/* call-agent.c - divert operations to the agent + * Copyright (C) 2001 Free Software Foundation, Inc. + * + * This file is part of GnuPG. + * + * GnuPG is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * GnuPG is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#include <config.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <unistd.h> +#include <time.h> +#include <assert.h> + +#include <gcrypt.h> + +#include "gpgsm.h" +#include "../assuan/assuan.h" +#include "i18n.h" + +#ifdef _POSIX_OPEN_MAX +#define MAX_OPEN_FDS _POSIX_OPEN_MAX +#else +#define MAX_OPEN_FDS 20 +#endif + +#define LINELENGTH 1002 /* 1000 + [CR,]LF */ + +#define xtoi_1(p) (*(p) <= '9'? (*(p)- '0'): \ + *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10)) +#define xtoi_2(p) ((xtoi_1(p) * 16) + xtoi_1((p)+1)) + + +static pid_t agent_pid = -1; +/* fixme: replace this code by calling assuna functions */ +static int inbound_fd = -1; +static int outbound_fd = -1; +static struct { + int eof; + char line[LINELENGTH]; + int linelen; /* w/o CR, LF - might not be the same as + strlen(line) due to embedded nuls. However a nul + is always written at this pos */ + struct { + char line[LINELENGTH]; + int linelen ; + } attic; +} inbound; + + +struct membuf { + size_t len; + size_t size; + char *buf; + int out_of_core; +}; + + + +/* A simple implemnation of a dynamic buffer. Use init_membuf() to + create a buffer, put_membuf to append bytes and get_membuf to + release and return the buffer. Allocation errors are detected but + only returned at the final get_membuf(), this helps not to clutter + the code with out of core checks. */ + +static void +init_membuf (struct membuf *mb, int initiallen) +{ + mb->len = 0; + mb->size = initiallen; + mb->out_of_core = 0; + mb->buf = xtrymalloc (initiallen); + if (!mb->buf) + mb->out_of_core = 1; +} + +static void +put_membuf (struct membuf *mb, const void *buf, size_t len) +{ + if (mb->out_of_core) + return; + + if (mb->len + len >= mb->size) + { + char *p; + + mb->size += len + 1024; + p = xtryrealloc (mb->buf, mb->size); + if (!p) + { + mb->out_of_core = 1; + return; + } + mb->buf = p; + } + memcpy (mb->buf + mb->len, buf, len); + mb->len += len; +} + +static void * +get_membuf (struct membuf *mb, size_t *len) +{ + char *p; + + if (mb->out_of_core) + { + xfree (mb->buf); + mb->buf = NULL; + return NULL; + } + + p = mb->buf; + *len = mb->len; + mb->buf = NULL; + mb->out_of_core = 1; /* don't allow a reuse */ + return p; +} + + + +static int +writen (int fd, const void *buf, size_t nbytes) +{ + size_t nleft = nbytes; + int nwritten; + + while (nleft > 0) + { + nwritten = write (fd, buf, nleft); + if (nwritten < 0) + { + if (errno == EINTR) + nwritten = 0; + else + { + log_error ("write() failed: %s\n", strerror (errno)); + return seterr (Write_Error); + } + } + nleft -= nwritten; + buf = (const char*)buf + nwritten; + } + + return 0; +} + + + +/* read an entire line */ +static int +readline (int fd, char *buf, size_t buflen, int *r_nread, int *eof) +{ + size_t nleft = buflen; + int n; + char *p; + + *eof = 0; + *r_nread = 0; + while (nleft > 0) + { + do + n = read (fd, buf, nleft); + while (n < 0 && errno == EINTR); + if (n < 0) + { + log_error ("read() error: %s\n", strerror (errno) ); + return seterr (Read_Error); + } + + if (!n) + { + *eof = 1; + break; /* allow incomplete lines */ + } + p = buf; + nleft -= n; + buf += n; + *r_nread += n; + + for (; n && *p != '\n'; n--, p++) + ; + if (n) + break; /* at least one full line available - that's enough for now */ + } + + return 0; +} + + +static int +read_from_agent (int *okay) +{ + char *line = inbound.line; + int n, nread; + int rc; + + *okay = 0; + restart: + if (inbound.eof) + return -1; + + if (inbound.attic.linelen) + { + memcpy (line, inbound.attic.line, inbound.attic.linelen); + nread = inbound.attic.linelen; + inbound.attic.linelen = 0; + for (n=0; n < nread && line[n] != '\n'; n++) + ; + if (n < nread) + rc = 0; /* found another line in the attic */ + else + { /* read the rest */ + n = nread; + assert (n < LINELENGTH); + rc = readline (inbound_fd, line + n, LINELENGTH - n, + &nread, &inbound.eof); + } + } + else + rc = readline (inbound_fd, line, LINELENGTH, + &nread, &inbound.eof); + if (rc) + return seterr(Read_Error); + if (!nread) + { + assert (inbound.eof); + return -1; /* eof */ + } + + for (n=0; n < nread; n++) + { + if (line[n] == '\n') + { + if (n+1 < nread) + { + n++; + /* we have to copy the rest because the handlers are + allowed to modify the passed buffer */ + memcpy (inbound.attic.line, line+n, nread-n); + inbound.attic.linelen = nread-n; + n--; + } + if (n && line[n-1] == '\r') + n--; + line[n] = 0; + inbound.linelen = n; + if (n && *line == '#') + goto restart; + + rc = 0; + if (n >= 1 + && line[0] == 'D' && line[1] == ' ') + *okay = 2; /* data line */ + else if (n >= 2 + && line[0] == 'O' && line[1] == 'K' + && (line[2] == '\0' || line[2] == ' ')) + *okay = 1; + else if (n >= 3 + && line[0] == 'E' && line[1] == 'R' && line[2] == 'R' + && (line[3] == '\0' || line[3] == ' ')) + *okay = 0; + else + rc = seterr (Invalid_Response); + return rc; + } + } + + *line = 0; + inbound.linelen = 0; + return inbound.eof? seterr (Incomplete_Line):seterr (Invalid_Response); +} + + + + + +/* Try to connect to the agent via socket or fork it off and work by + pipes. Handle the server's initial greeting */ +static int +start_agent (void) +{ + int rc; + char *infostr, *p; + int okay; + + if (agent_pid != -1) + return 0; + + infostr = getenv ("GPG_AGENT_INFO"); + if (!infostr) + { + pid_t pid; + int inpipe[2], outpipe[2]; + + log_info (_("no running gpg-agent - starting one\n")); + + if (fflush (NULL)) + { + log_error ("error flushing pending output: %s\n", strerror (errno)); + return seterr (Write_Error); + } + + if (pipe (inpipe)) + { + log_error ("error creating pipe: %s\n", strerror (errno)); + return seterr (General_Error); + } + if (pipe (outpipe)) + { + log_error ("error creating pipe: %s\n", strerror (errno)); + close (inpipe[0]); + close (inpipe[1]); + return seterr (General_Error); + } + + pid = fork (); + if (pid == -1) + return seterr (General_Error); + + if (!pid) + { /* child */ + int i, n; + char errbuf[100]; + int log_fd = log_get_fd (); + + /* close all files which will not be duped but keep stderr + and log_stream for now */ + n = sysconf (_SC_OPEN_MAX); + if (n < 0) + n = MAX_OPEN_FDS; + for (i=0; i < n; i++) + { + if (i != fileno (stderr) && i != log_fd + && i != inpipe[1] && i != outpipe[0]) + close(i); + } + errno = 0; + + if (inpipe[1] != 1) + { + if (dup2 (inpipe[1], 1) == -1) + { + log_error ("dup2 failed in child: %s\n", strerror (errno)); + _exit (4); + } + close (inpipe[1]); + } + if (outpipe[0] != 0) + { + if (dup2 (outpipe[0], 0) == -1) + { + log_error ("dup2 failed in child: %s\n", strerror (errno)); + _exit (4); + } + close (outpipe[0]); + } + + /* and start it */ + execl ("../agent/gpg-agent", "gpg-agent", "--server", NULL); + /* oops - tell the parent about it */ + snprintf (errbuf, DIM(errbuf)-1, "ERR %d execl failed: %.50s\n", + ASSUAN_Problem_Starting_Server, strerror (errno)); + errbuf[DIM(errbuf)-1] = 0; + writen (1, errbuf, strlen (errbuf)); + _exit (4); + } /* end child */ + + agent_pid = pid; + + inbound_fd = inpipe[0]; + close (inpipe[1]); + + close (outpipe[0]); + outbound_fd = outpipe[1]; + } + else + { + infostr = xstrdup (infostr); + if ( !(p = strchr (infostr, ':')) || p == infostr + /* || (p-infostr)+1 >= sizeof client_addr.sun_path */) + { + log_error (_("malformed GPG_AGENT_INFO environment variable\n")); + xfree (infostr); + return seterr (General_Error); + } + *p = 0; + log_error (_("socket based agent communication not yet implemented\n")); + return seterr (Not_Implemented); + } + + inbound.eof = 0; + inbound.linelen = 0; + inbound.attic.linelen = 0; + + /* The server is available - read the greeting */ + rc = read_from_agent (&okay); + if (rc) + { + log_error ("can't connect to the agent: %s\n", gnupg_strerror (rc)); + } + else if (!okay) + { + log_error ("can't connect to the agent: %s\n", inbound.line); + rc = seterr (No_Agent); + } + else + log_debug ("connection to agent established\n"); + + return 0; +} + + +static int +request_reply (const char *line, struct membuf *membuf) +{ + int rc, okay; + + if (DBG_AGENT) + log_debug ("agent-request=`%.*s'", (int)(*line? strlen(line)-1:0), line); + rc = writen (outbound_fd, line, strlen (line)); + if (rc) + return rc; + again: + rc = read_from_agent (&okay); + if (rc) + log_error ("error reading from agent: %s\n", gnupg_strerror (rc)); + else if (!okay) + { + log_error ("got error from agent: %s\n", inbound.line); + rc = seterr (Agent_Error); + } + else if (okay == 2 && !membuf) + { + log_error ("got unexpected data line\n"); + rc = seterr (Agent_Error); + } + else + { + if (DBG_AGENT) + log_debug ("agent-reply=`%s'", inbound.line); + } + + if (!rc && okay == 2 && inbound.linelen >= 2) + { /* handle data line */ + unsigned char *buf = inbound.line; + size_t len = inbound.linelen; + unsigned char *p; + + buf += 2; + len -= 2; + + p = buf; + while (len) + { + for (;len && *p != '%'; len--, p++) + ; + put_membuf (membuf, buf, p-buf); + buf = p; + if (len>2) + { /* handle escaping */ + unsigned char tmp[1]; + buf++; + *tmp = xtoi_2 (buf); + buf += 2; + len -= 3; + put_membuf (membuf, tmp, 1); + } + } + goto again; + } + return rc; +} + + + + +/* Call the agent to do a sign operation using the key identified by + the hex string KEYGRIP. */ +int +gpgsm_agent_pksign (const char *keygrip, + unsigned char *digest, size_t digestlen, int digestalgo, + char **r_buf, size_t *r_buflen ) +{ + int rc, i; + char *p, line[LINELENGTH]; + struct membuf data; + size_t len; + + *r_buf = NULL; + rc = start_agent (); + if (rc) + return rc; + + if (digestlen*2 + 50 > DIM(line)) + return seterr (General_Error); + + rc = request_reply ("RESET\n", NULL); + if (rc) + return rc; + + snprintf (line, DIM(line)-1, "SIGKEY %s\n", keygrip); + line[DIM(line)-1] = 0; + rc = request_reply (line, NULL); + if (rc) + return rc; + + sprintf (line, "SETHASH %d ", digestalgo); + p = line + strlen (line); + for (i=0; i < digestlen ; i++, p += 2 ) + sprintf (p, "%02X", digest[i]); + strcpy (p, "\n"); + rc = request_reply (line, NULL); + if (rc) + return rc; + + init_membuf (&data, 1024); + rc = request_reply ("PKSIGN\n", &data); + if (rc) + { + xfree (get_membuf (&data, &len)); + return rc; + } + *r_buf = get_membuf (&data, r_buflen); +/* if (DBG_AGENT && *r_buf) */ +/* { */ +/* FILE *fp; */ +/* char fname[100]; */ + +/* memcpy (fname, keygrip, 40); */ +/* strcpy (fname+40, "_pksign-dump.tmp"); */ +/* fp = fopen (fname, "wb"); */ +/* fwrite (*r_buf, *r_buflen, 1, fp); */ +/* fclose (fp); */ +/* } */ + + return *r_buf? 0 : GNUPG_Out_Of_Core; +} + + + + |