crypto/openssh/ssh-pkcs11-helper.c

   1 /* $OpenBSD: ssh-pkcs11-helper.c,v 1.6 2013/05/17 00:13:14 djm Exp $ */
   2 /*
   3  * Copyright (c) 2010 Markus Friedl.  All rights reserved.
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include "includes.h"
  19
  20 #include <sys/types.h>
  21 #ifdef HAVE_SYS_TIME_H
  22 # include <sys/time.h>
  23 #endif
  24
  25 #include "openbsd-compat/sys-queue.h"
  26
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <errno.h>
  31
  32 #include "xmalloc.h"
  33 #include "buffer.h"
  34 #include "log.h"
  35 #include "misc.h"
  36 #include "key.h"
  37 #include "authfd.h"
  38 #include "ssh-pkcs11.h"
  39
  40 #ifdef ENABLE_PKCS11
  41
  42 /* borrows code from sftp-server and ssh-agent */
  43
  44 struct pkcs11_keyinfo {
  45         Key             *key;
  46         char            *providername;
  47         TAILQ_ENTRY(pkcs11_keyinfo) next;
  48 };
  49
  50 TAILQ_HEAD(, pkcs11_keyinfo) pkcs11_keylist;
  51
  52 #define MAX_MSG_LENGTH          10240 /*XXX*/
  53
  54 /* helper */
  55 #define get_int()                       buffer_get_int(&iqueue);
  56 #define get_string(lenp)                buffer_get_string(&iqueue, lenp);
  57
  58 /* input and output queue */
  59 Buffer iqueue;
  60 Buffer oqueue;
  61
  62 static void
  63 add_key(Key *k, char *name)
  64 {
  65         struct pkcs11_keyinfo *ki;
  66
  67         ki = xcalloc(1, sizeof(*ki));
  68         ki->providername = xstrdup(name);
  69         ki->key = k;
  70         TAILQ_INSERT_TAIL(&pkcs11_keylist, ki, next);
  71 }
  72
  73 static void
  74 del_keys_by_name(char *name)
  75 {
  76         struct pkcs11_keyinfo *ki, *nxt;
  77
  78         for (ki = TAILQ_FIRST(&pkcs11_keylist); ki; ki = nxt) {
  79                 nxt = TAILQ_NEXT(ki, next);
  80                 if (!strcmp(ki->providername, name)) {
  81                         TAILQ_REMOVE(&pkcs11_keylist, ki, next);
  82                         free(ki->providername);
  83                         key_free(ki->key);
  84                         free(ki);
  85                 }
  86         }
  87 }
  88
  89 /* lookup matching 'private' key */
  90 static Key *
  91 lookup_key(Key *k)
  92 {
  93         struct pkcs11_keyinfo *ki;
  94
  95         TAILQ_FOREACH(ki, &pkcs11_keylist, next) {
  96                 debug("check %p %s", ki, ki->providername);
  97                 if (key_equal(k, ki->key))
  98                         return (ki->key);
  99         }
 100         return (NULL);
 101 }
 102
 103 static void
 104 send_msg(Buffer *m)
 105 {
 106         int mlen = buffer_len(m);
 107
 108         buffer_put_int(&oqueue, mlen);
 109         buffer_append(&oqueue, buffer_ptr(m), mlen);
 110         buffer_consume(m, mlen);
 111 }
 112
 113 static void
 114 process_add(void)
 115 {
 116         char *name, *pin;
 117         Key **keys;
 118         int i, nkeys;
 119         u_char *blob;
 120         u_int blen;
 121         Buffer msg;
 122
 123         buffer_init(&msg);
 124         name = get_string(NULL);
 125         pin = get_string(NULL);
 126         if ((nkeys = pkcs11_add_provider(name, pin, &keys)) > 0) {
 127                 buffer_put_char(&msg, SSH2_AGENT_IDENTITIES_ANSWER);
 128                 buffer_put_int(&msg, nkeys);
 129                 for (i = 0; i < nkeys; i++) {
 130                         key_to_blob(keys[i], &blob, &blen);
 131                         buffer_put_string(&msg, blob, blen);
 132                         buffer_put_cstring(&msg, name);
 133                         free(blob);
 134                         add_key(keys[i], name);
 135                 }
 136                 free(keys);
 137         } else {
 138                 buffer_put_char(&msg, SSH_AGENT_FAILURE);
 139         }
 140         free(pin);
 141         free(name);
 142         send_msg(&msg);
 143         buffer_free(&msg);
 144 }
 145
 146 static void
 147 process_del(void)
 148 {
 149         char *name, *pin;
 150         Buffer msg;
 151
 152         buffer_init(&msg);
 153         name = get_string(NULL);
 154         pin = get_string(NULL);
 155         del_keys_by_name(name);
 156         if (pkcs11_del_provider(name) == 0)
 157                  buffer_put_char(&msg, SSH_AGENT_SUCCESS);
 158         else
 159                  buffer_put_char(&msg, SSH_AGENT_FAILURE);
 160         free(pin);
 161         free(name);
 162         send_msg(&msg);
 163         buffer_free(&msg);
 164 }
 165
 166 static void
 167 process_sign(void)
 168 {
 169         u_char *blob, *data, *signature = NULL;
 170         u_int blen, dlen, slen = 0;
 171         int ok = -1, ret;
 172         Key *key, *found;
 173         Buffer msg;
 174
 175         blob = get_string(&blen);
 176         data = get_string(&dlen);
 177         (void)get_int(); /* XXX ignore flags */
 178
 179         if ((key = key_from_blob(blob, blen)) != NULL) {
 180                 if ((found = lookup_key(key)) != NULL) {
 181                         slen = RSA_size(key->rsa);
 182                         signature = xmalloc(slen);
 183                         if ((ret = RSA_private_encrypt(dlen, data, signature,
 184                             found->rsa, RSA_PKCS1_PADDING)) != -1) {
 185                                 slen = ret;
 186                                 ok = 0;
 187                         }
 188                 }
 189                 key_free(key);
 190         }
 191         buffer_init(&msg);
 192         if (ok == 0) {
 193                 buffer_put_char(&msg, SSH2_AGENT_SIGN_RESPONSE);
 194                 buffer_put_string(&msg, signature, slen);
 195         } else {
 196                 buffer_put_char(&msg, SSH_AGENT_FAILURE);
 197         }
 198         free(data);
 199         free(blob);
 200         free(signature);
 201         send_msg(&msg);
 202         buffer_free(&msg);
 203 }
 204
 205 static void
 206 process(void)
 207 {
 208         u_int msg_len;
 209         u_int buf_len;
 210         u_int consumed;
 211         u_int type;
 212         u_char *cp;
 213
 214         buf_len = buffer_len(&iqueue);
 215         if (buf_len < 5)
 216                 return;         /* Incomplete message. */
 217         cp = buffer_ptr(&iqueue);
 218         msg_len = get_u32(cp);
 219         if (msg_len > MAX_MSG_LENGTH) {
 220                 error("bad message len %d", msg_len);
 221                 cleanup_exit(11);
 222         }
 223         if (buf_len < msg_len + 4)
 224                 return;
 225         buffer_consume(&iqueue, 4);
 226         buf_len -= 4;
 227         type = buffer_get_char(&iqueue);
 228         switch (type) {
 229         case SSH_AGENTC_ADD_SMARTCARD_KEY:
 230                 debug("process_add");
 231                 process_add();
 232                 break;
 233         case SSH_AGENTC_REMOVE_SMARTCARD_KEY:
 234                 debug("process_del");
 235                 process_del();
 236                 break;
 237         case SSH2_AGENTC_SIGN_REQUEST:
 238                 debug("process_sign");
 239                 process_sign();
 240                 break;
 241         default:
 242                 error("Unknown message %d", type);
 243                 break;
 244         }
 245         /* discard the remaining bytes from the current packet */
 246         if (buf_len < buffer_len(&iqueue)) {
 247                 error("iqueue grew unexpectedly");
 248                 cleanup_exit(255);
 249         }
 250         consumed = buf_len - buffer_len(&iqueue);
 251         if (msg_len < consumed) {
 252                 error("msg_len %d < consumed %d", msg_len, consumed);
 253                 cleanup_exit(255);
 254         }
 255         if (msg_len > consumed)
 256                 buffer_consume(&iqueue, msg_len - consumed);
 257 }
 258
 259 void
 260 cleanup_exit(int i)
 261 {
 262         /* XXX */
 263         _exit(i);
 264 }
 265
 266 int
 267 main(int argc, char **argv)
 268 {
 269         fd_set *rset, *wset;
 270         int in, out, max, log_stderr = 0;
 271         ssize_t len, olen, set_size;
 272         SyslogFacility log_facility = SYSLOG_FACILITY_AUTH;
 273         LogLevel log_level = SYSLOG_LEVEL_ERROR;
 274         char buf[4*4096];
 275
 276         extern char *__progname;
 277
 278         TAILQ_INIT(&pkcs11_keylist);
 279         pkcs11_init(0);
 280
 281         seed_rng();
 282         __progname = ssh_get_progname(argv[0]);
 283
 284         log_init(__progname, log_level, log_facility, log_stderr);
 285
 286         in = STDIN_FILENO;
 287         out = STDOUT_FILENO;
 288
 289         max = 0;
 290         if (in > max)
 291                 max = in;
 292         if (out > max)
 293                 max = out;
 294
 295         buffer_init(&iqueue);
 296         buffer_init(&oqueue);
 297
 298         set_size = howmany(max + 1, NFDBITS) * sizeof(fd_mask);
 299         rset = (fd_set *)xmalloc(set_size);
 300         wset = (fd_set *)xmalloc(set_size);
 301
 302         for (;;) {
 303                 memset(rset, 0, set_size);
 304                 memset(wset, 0, set_size);
 305
 306                 /*
 307                  * Ensure that we can read a full buffer and handle
 308                  * the worst-case length packet it can generate,
 309                  * otherwise apply backpressure by stopping reads.
 310                  */
 311                 if (buffer_check_alloc(&iqueue, sizeof(buf)) &&
 312                     buffer_check_alloc(&oqueue, MAX_MSG_LENGTH))
 313                         FD_SET(in, rset);
 314
 315                 olen = buffer_len(&oqueue);
 316                 if (olen > 0)
 317                         FD_SET(out, wset);
 318
 319                 if (select(max+1, rset, wset, NULL, NULL) < 0) {
 320                         if (errno == EINTR)
 321                                 continue;
 322                         error("select: %s", strerror(errno));
 323                         cleanup_exit(2);
 324                 }
 325
 326                 /* copy stdin to iqueue */
 327                 if (FD_ISSET(in, rset)) {
 328                         len = read(in, buf, sizeof buf);
 329                         if (len == 0) {
 330                                 debug("read eof");
 331                                 cleanup_exit(0);
 332                         } else if (len < 0) {
 333                                 error("read: %s", strerror(errno));
 334                                 cleanup_exit(1);
 335                         } else {
 336                                 buffer_append(&iqueue, buf, len);
 337                         }
 338                 }
 339                 /* send oqueue to stdout */
 340                 if (FD_ISSET(out, wset)) {
 341                         len = write(out, buffer_ptr(&oqueue), olen);
 342                         if (len < 0) {
 343                                 error("write: %s", strerror(errno));
 344                                 cleanup_exit(1);
 345                         } else {
 346                                 buffer_consume(&oqueue, len);
 347                         }
 348                 }
 349
 350                 /*
 351                  * Process requests from client if we can fit the results
 352                  * into the output buffer, otherwise stop processing input
 353                  * and let the output queue drain.
 354                  */
 355                 if (buffer_check_alloc(&oqueue, MAX_MSG_LENGTH))
 356                         process();
 357         }
 358 }
 359 #else /* ENABLE_PKCS11 */
 360 int
 361 main(int argc, char **argv)
 362 {
 363         extern char *__progname;
 364
 365         __progname = ssh_get_progname(argv[0]);
 366         log_init(__progname, SYSLOG_LEVEL_ERROR, SYSLOG_FACILITY_AUTH, 0);
 367         fatal("PKCS#11 support disabled at compile time");
 368 }
 369 #endif /* ENABLE_PKCS11 */