1 /* $OpenBSD: ssh-pkcs11-helper.c,v 1.26 2021/11/18 03:31:44 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 <stdlib.h> 28 #include <errno.h> 29 #ifdef HAVE_POLL_H 30 #include <poll.h> 31 #endif 32 #include <stdarg.h> 33 #include <string.h> 34 #include <unistd.h> 35 36 #include "xmalloc.h" 37 #include "sshbuf.h" 38 #include "log.h" 39 #include "misc.h" 40 #include "sshkey.h" 41 #include "authfd.h" 42 #include "ssh-pkcs11.h" 43 #include "ssherr.h" 44 45 #ifdef ENABLE_PKCS11 46 47 #ifdef WITH_OPENSSL 48 49 /* borrows code from sftp-server and ssh-agent */ 50 51 struct pkcs11_keyinfo { 52 struct sshkey *key; 53 char *providername, *label; 54 TAILQ_ENTRY(pkcs11_keyinfo) next; 55 }; 56 57 TAILQ_HEAD(, pkcs11_keyinfo) pkcs11_keylist; 58 59 #define MAX_MSG_LENGTH 10240 /*XXX*/ 60 61 /* input and output queue */ 62 struct sshbuf *iqueue; 63 struct sshbuf *oqueue; 64 65 static void 66 add_key(struct sshkey *k, char *name, char *label) 67 { 68 struct pkcs11_keyinfo *ki; 69 70 ki = xcalloc(1, sizeof(*ki)); 71 ki->providername = xstrdup(name); 72 ki->key = k; 73 ki->label = xstrdup(label); 74 TAILQ_INSERT_TAIL(&pkcs11_keylist, ki, next); 75 } 76 77 static void 78 del_keys_by_name(char *name) 79 { 80 struct pkcs11_keyinfo *ki, *nxt; 81 82 for (ki = TAILQ_FIRST(&pkcs11_keylist); ki; ki = nxt) { 83 nxt = TAILQ_NEXT(ki, next); 84 if (!strcmp(ki->providername, name)) { 85 TAILQ_REMOVE(&pkcs11_keylist, ki, next); 86 free(ki->providername); 87 free(ki->label); 88 sshkey_free(ki->key); 89 free(ki); 90 } 91 } 92 } 93 94 /* lookup matching 'private' key */ 95 static struct sshkey * 96 lookup_key(struct sshkey *k) 97 { 98 struct pkcs11_keyinfo *ki; 99 100 TAILQ_FOREACH(ki, &pkcs11_keylist, next) { 101 debug("check %s %s %s", sshkey_type(ki->key), 102 ki->providername, ki->label); 103 if (sshkey_equal(k, ki->key)) 104 return (ki->key); 105 } 106 return (NULL); 107 } 108 109 static void 110 send_msg(struct sshbuf *m) 111 { 112 int r; 113 114 if ((r = sshbuf_put_stringb(oqueue, m)) != 0) 115 fatal_fr(r, "enqueue"); 116 } 117 118 static void 119 process_add(void) 120 { 121 char *name, *pin; 122 struct sshkey **keys = NULL; 123 int r, i, nkeys; 124 u_char *blob; 125 size_t blen; 126 struct sshbuf *msg; 127 char **labels = NULL; 128 129 if ((msg = sshbuf_new()) == NULL) 130 fatal_f("sshbuf_new failed"); 131 if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 || 132 (r = sshbuf_get_cstring(iqueue, &pin, NULL)) != 0) 133 fatal_fr(r, "parse"); 134 if ((nkeys = pkcs11_add_provider(name, pin, &keys, &labels)) > 0) { 135 if ((r = sshbuf_put_u8(msg, 136 SSH2_AGENT_IDENTITIES_ANSWER)) != 0 || 137 (r = sshbuf_put_u32(msg, nkeys)) != 0) 138 fatal_fr(r, "compose"); 139 for (i = 0; i < nkeys; i++) { 140 if ((r = sshkey_to_blob(keys[i], &blob, &blen)) != 0) { 141 debug_fr(r, "encode key"); 142 continue; 143 } 144 if ((r = sshbuf_put_string(msg, blob, blen)) != 0 || 145 (r = sshbuf_put_cstring(msg, labels[i])) != 0) 146 fatal_fr(r, "compose key"); 147 free(blob); 148 add_key(keys[i], name, labels[i]); 149 free(labels[i]); 150 } 151 } else if ((r = sshbuf_put_u8(msg, SSH_AGENT_FAILURE)) != 0 || 152 (r = sshbuf_put_u32(msg, -nkeys)) != 0) 153 fatal_fr(r, "compose"); 154 free(labels); 155 free(keys); /* keys themselves are transferred to pkcs11_keylist */ 156 free(pin); 157 free(name); 158 send_msg(msg); 159 sshbuf_free(msg); 160 } 161 162 static void 163 process_del(void) 164 { 165 char *name, *pin; 166 struct sshbuf *msg; 167 int r; 168 169 if ((msg = sshbuf_new()) == NULL) 170 fatal_f("sshbuf_new failed"); 171 if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 || 172 (r = sshbuf_get_cstring(iqueue, &pin, NULL)) != 0) 173 fatal_fr(r, "parse"); 174 del_keys_by_name(name); 175 if ((r = sshbuf_put_u8(msg, pkcs11_del_provider(name) == 0 ? 176 SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE)) != 0) 177 fatal_fr(r, "compose"); 178 free(pin); 179 free(name); 180 send_msg(msg); 181 sshbuf_free(msg); 182 } 183 184 static void 185 process_sign(void) 186 { 187 u_char *blob, *data, *signature = NULL; 188 size_t blen, dlen, slen = 0; 189 int r, ok = -1; 190 struct sshkey *key, *found; 191 struct sshbuf *msg; 192 193 /* XXX support SHA2 signature flags */ 194 if ((r = sshbuf_get_string(iqueue, &blob, &blen)) != 0 || 195 (r = sshbuf_get_string(iqueue, &data, &dlen)) != 0 || 196 (r = sshbuf_get_u32(iqueue, NULL)) != 0) 197 fatal_fr(r, "parse"); 198 199 if ((r = sshkey_from_blob(blob, blen, &key)) != 0) 200 fatal_fr(r, "decode key"); 201 else { 202 if ((found = lookup_key(key)) != NULL) { 203 #ifdef WITH_OPENSSL 204 int ret; 205 206 if (key->type == KEY_RSA) { 207 slen = RSA_size(key->rsa); 208 signature = xmalloc(slen); 209 ret = RSA_private_encrypt(dlen, data, signature, 210 found->rsa, RSA_PKCS1_PADDING); 211 if (ret != -1) { 212 slen = ret; 213 ok = 0; 214 } 215 #ifdef OPENSSL_HAS_ECC 216 } else if (key->type == KEY_ECDSA) { 217 u_int xslen = ECDSA_size(key->ecdsa); 218 219 signature = xmalloc(xslen); 220 /* "The parameter type is ignored." */ 221 ret = ECDSA_sign(-1, data, dlen, signature, 222 &xslen, found->ecdsa); 223 if (ret != 0) 224 ok = 0; 225 else 226 error_f("ECDSA_sign returned %d", ret); 227 slen = xslen; 228 #endif /* OPENSSL_HAS_ECC */ 229 } else 230 error_f("don't know how to sign with key " 231 "type %d", (int)key->type); 232 #endif /* WITH_OPENSSL */ 233 } 234 sshkey_free(key); 235 } 236 if ((msg = sshbuf_new()) == NULL) 237 fatal_f("sshbuf_new failed"); 238 if (ok == 0) { 239 if ((r = sshbuf_put_u8(msg, SSH2_AGENT_SIGN_RESPONSE)) != 0 || 240 (r = sshbuf_put_string(msg, signature, slen)) != 0) 241 fatal_fr(r, "compose response"); 242 } else { 243 if ((r = sshbuf_put_u8(msg, SSH2_AGENT_FAILURE)) != 0) 244 fatal_fr(r, "compose failure response"); 245 } 246 free(data); 247 free(blob); 248 free(signature); 249 send_msg(msg); 250 sshbuf_free(msg); 251 } 252 253 static void 254 process(void) 255 { 256 u_int msg_len; 257 u_int buf_len; 258 u_int consumed; 259 u_char type; 260 const u_char *cp; 261 int r; 262 263 buf_len = sshbuf_len(iqueue); 264 if (buf_len < 5) 265 return; /* Incomplete message. */ 266 cp = sshbuf_ptr(iqueue); 267 msg_len = get_u32(cp); 268 if (msg_len > MAX_MSG_LENGTH) { 269 error("bad message len %d", msg_len); 270 cleanup_exit(11); 271 } 272 if (buf_len < msg_len + 4) 273 return; 274 if ((r = sshbuf_consume(iqueue, 4)) != 0 || 275 (r = sshbuf_get_u8(iqueue, &type)) != 0) 276 fatal_fr(r, "parse type/len"); 277 buf_len -= 4; 278 switch (type) { 279 case SSH_AGENTC_ADD_SMARTCARD_KEY: 280 debug("process_add"); 281 process_add(); 282 break; 283 case SSH_AGENTC_REMOVE_SMARTCARD_KEY: 284 debug("process_del"); 285 process_del(); 286 break; 287 case SSH2_AGENTC_SIGN_REQUEST: 288 debug("process_sign"); 289 process_sign(); 290 break; 291 default: 292 error("Unknown message %d", type); 293 break; 294 } 295 /* discard the remaining bytes from the current packet */ 296 if (buf_len < sshbuf_len(iqueue)) { 297 error("iqueue grew unexpectedly"); 298 cleanup_exit(255); 299 } 300 consumed = buf_len - sshbuf_len(iqueue); 301 if (msg_len < consumed) { 302 error("msg_len %d < consumed %d", msg_len, consumed); 303 cleanup_exit(255); 304 } 305 if (msg_len > consumed) { 306 if ((r = sshbuf_consume(iqueue, msg_len - consumed)) != 0) 307 fatal_fr(r, "consume"); 308 } 309 } 310 311 void 312 cleanup_exit(int i) 313 { 314 /* XXX */ 315 _exit(i); 316 } 317 318 319 int 320 main(int argc, char **argv) 321 { 322 int r, ch, in, out, log_stderr = 0; 323 ssize_t len; 324 SyslogFacility log_facility = SYSLOG_FACILITY_AUTH; 325 LogLevel log_level = SYSLOG_LEVEL_ERROR; 326 char buf[4*4096]; 327 extern char *__progname; 328 struct pollfd pfd[2]; 329 330 __progname = ssh_get_progname(argv[0]); 331 seed_rng(); 332 TAILQ_INIT(&pkcs11_keylist); 333 334 log_init(__progname, log_level, log_facility, log_stderr); 335 336 while ((ch = getopt(argc, argv, "v")) != -1) { 337 switch (ch) { 338 case 'v': 339 log_stderr = 1; 340 if (log_level == SYSLOG_LEVEL_ERROR) 341 log_level = SYSLOG_LEVEL_DEBUG1; 342 else if (log_level < SYSLOG_LEVEL_DEBUG3) 343 log_level++; 344 break; 345 default: 346 fprintf(stderr, "usage: %s [-v]\n", __progname); 347 exit(1); 348 } 349 } 350 351 log_init(__progname, log_level, log_facility, log_stderr); 352 353 pkcs11_init(0); 354 in = STDIN_FILENO; 355 out = STDOUT_FILENO; 356 357 if ((iqueue = sshbuf_new()) == NULL) 358 fatal_f("sshbuf_new failed"); 359 if ((oqueue = sshbuf_new()) == NULL) 360 fatal_f("sshbuf_new failed"); 361 362 while (1) { 363 memset(pfd, 0, sizeof(pfd)); 364 pfd[0].fd = in; 365 pfd[1].fd = out; 366 367 /* 368 * Ensure that we can read a full buffer and handle 369 * the worst-case length packet it can generate, 370 * otherwise apply backpressure by stopping reads. 371 */ 372 if ((r = sshbuf_check_reserve(iqueue, sizeof(buf))) == 0 && 373 (r = sshbuf_check_reserve(oqueue, MAX_MSG_LENGTH)) == 0) 374 pfd[0].events = POLLIN; 375 else if (r != SSH_ERR_NO_BUFFER_SPACE) 376 fatal_fr(r, "reserve"); 377 378 if (sshbuf_len(oqueue) > 0) 379 pfd[1].events = POLLOUT; 380 381 if ((r = poll(pfd, 2, -1 /* INFTIM */)) <= 0) { 382 if (r == 0 || errno == EINTR) 383 continue; 384 fatal("poll: %s", strerror(errno)); 385 } 386 387 /* copy stdin to iqueue */ 388 if ((pfd[0].revents & (POLLIN|POLLHUP|POLLERR)) != 0) { 389 len = read(in, buf, sizeof buf); 390 if (len == 0) { 391 debug("read eof"); 392 cleanup_exit(0); 393 } else if (len < 0) { 394 error("read: %s", strerror(errno)); 395 cleanup_exit(1); 396 } else if ((r = sshbuf_put(iqueue, buf, len)) != 0) 397 fatal_fr(r, "sshbuf_put"); 398 } 399 /* send oqueue to stdout */ 400 if ((pfd[1].revents & (POLLOUT|POLLHUP)) != 0) { 401 len = write(out, sshbuf_ptr(oqueue), 402 sshbuf_len(oqueue)); 403 if (len < 0) { 404 error("write: %s", strerror(errno)); 405 cleanup_exit(1); 406 } else if ((r = sshbuf_consume(oqueue, len)) != 0) 407 fatal_fr(r, "consume"); 408 } 409 410 /* 411 * Process requests from client if we can fit the results 412 * into the output buffer, otherwise stop processing input 413 * and let the output queue drain. 414 */ 415 if ((r = sshbuf_check_reserve(oqueue, MAX_MSG_LENGTH)) == 0) 416 process(); 417 else if (r != SSH_ERR_NO_BUFFER_SPACE) 418 fatal_fr(r, "reserve"); 419 } 420 } 421 422 #else /* WITH_OPENSSL */ 423 void 424 cleanup_exit(int i) 425 { 426 _exit(i); 427 } 428 429 int 430 main(int argc, char **argv) 431 { 432 fprintf(stderr, "PKCS#11 code is not enabled\n"); 433 return 1; 434 } 435 #endif /* WITH_OPENSSL */ 436 #else /* ENABLE_PKCS11 */ 437 int 438 main(int argc, char **argv) 439 { 440 extern char *__progname; 441 442 __progname = ssh_get_progname(argv[0]); 443 log_init(__progname, SYSLOG_LEVEL_ERROR, SYSLOG_FACILITY_AUTH, 0); 444 fatal("PKCS#11 support disabled at compile time"); 445 } 446 #endif /* ENABLE_PKCS11 */ 447