1 /* $NetBSD: ssh-pkcs11-helper.c,v 1.16 2019/04/20 17:16:40 christos Exp $ */ 2 /* $OpenBSD: ssh-pkcs11-helper.c,v 1.17 2019/01/23 02:01:10 djm Exp $ */ 3 /* 4 * Copyright (c) 2010 Markus Friedl. All rights reserved. 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 #include "includes.h" 19 __RCSID("$NetBSD: ssh-pkcs11-helper.c,v 1.16 2019/04/20 17:16:40 christos Exp $"); 20 21 #include <sys/types.h> 22 #include <sys/queue.h> 23 #include <sys/time.h> 24 #include <sys/param.h> 25 26 #include <errno.h> 27 #include <poll.h> 28 #include <stdarg.h> 29 #include <string.h> 30 #include <unistd.h> 31 32 #include "xmalloc.h" 33 #include "sshbuf.h" 34 #include "log.h" 35 #include "misc.h" 36 #include "sshkey.h" 37 #include "authfd.h" 38 #include "ssh-pkcs11.h" 39 #include "ssherr.h" 40 41 /* borrows code from sftp-server and ssh-agent */ 42 43 struct pkcs11_keyinfo { 44 struct sshkey *key; 45 char *providername; 46 TAILQ_ENTRY(pkcs11_keyinfo) next; 47 }; 48 49 TAILQ_HEAD(, pkcs11_keyinfo) pkcs11_keylist; 50 51 #define MAX_MSG_LENGTH 10240 /*XXX*/ 52 53 /* input and output queue */ 54 struct sshbuf *iqueue; 55 struct sshbuf *oqueue; 56 57 static void 58 add_key(struct sshkey *k, char *name) 59 { 60 struct pkcs11_keyinfo *ki; 61 62 ki = xcalloc(1, sizeof(*ki)); 63 ki->providername = xstrdup(name); 64 ki->key = k; 65 TAILQ_INSERT_TAIL(&pkcs11_keylist, ki, next); 66 } 67 68 static void 69 del_keys_by_name(char *name) 70 { 71 struct pkcs11_keyinfo *ki, *nxt; 72 73 for (ki = TAILQ_FIRST(&pkcs11_keylist); ki; ki = nxt) { 74 nxt = TAILQ_NEXT(ki, next); 75 if (!strcmp(ki->providername, name)) { 76 TAILQ_REMOVE(&pkcs11_keylist, ki, next); 77 free(ki->providername); 78 sshkey_free(ki->key); 79 free(ki); 80 } 81 } 82 } 83 84 /* lookup matching 'private' key */ 85 static struct sshkey * 86 lookup_key(struct sshkey *k) 87 { 88 struct pkcs11_keyinfo *ki; 89 90 TAILQ_FOREACH(ki, &pkcs11_keylist, next) { 91 debug("check %p %s", ki, ki->providername); 92 if (sshkey_equal(k, ki->key)) 93 return (ki->key); 94 } 95 return (NULL); 96 } 97 98 static void 99 send_msg(struct sshbuf *m) 100 { 101 int r; 102 103 if ((r = sshbuf_put_stringb(oqueue, m)) != 0) 104 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 105 } 106 107 static void 108 process_add(void) 109 { 110 char *name, *pin; 111 struct sshkey **keys = NULL; 112 int r, i, nkeys; 113 u_char *blob; 114 size_t blen; 115 struct sshbuf *msg; 116 117 if ((msg = sshbuf_new()) == NULL) 118 fatal("%s: sshbuf_new failed", __func__); 119 if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 || 120 (r = sshbuf_get_cstring(iqueue, &pin, NULL)) != 0) 121 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 122 if ((nkeys = pkcs11_add_provider(name, pin, &keys)) > 0) { 123 if ((r = sshbuf_put_u8(msg, 124 SSH2_AGENT_IDENTITIES_ANSWER)) != 0 || 125 (r = sshbuf_put_u32(msg, nkeys)) != 0) 126 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 127 for (i = 0; i < nkeys; i++) { 128 if ((r = sshkey_to_blob(keys[i], &blob, &blen)) != 0) { 129 debug("%s: sshkey_to_blob: %s", 130 __func__, ssh_err(r)); 131 continue; 132 } 133 if ((r = sshbuf_put_string(msg, blob, blen)) != 0 || 134 (r = sshbuf_put_cstring(msg, name)) != 0) 135 fatal("%s: buffer error: %s", 136 __func__, ssh_err(r)); 137 free(blob); 138 add_key(keys[i], name); 139 } 140 } else { 141 if ((r = sshbuf_put_u8(msg, SSH_AGENT_FAILURE)) != 0) 142 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 143 if ((r = sshbuf_put_u32(msg, -nkeys)) != 0) 144 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 145 } 146 free(keys); 147 free(pin); 148 free(name); 149 send_msg(msg); 150 sshbuf_free(msg); 151 } 152 153 static void 154 process_del(void) 155 { 156 char *name, *pin; 157 struct sshbuf *msg; 158 int r; 159 160 if ((msg = sshbuf_new()) == NULL) 161 fatal("%s: sshbuf_new failed", __func__); 162 if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 || 163 (r = sshbuf_get_cstring(iqueue, &pin, NULL)) != 0) 164 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 165 del_keys_by_name(name); 166 if ((r = sshbuf_put_u8(msg, pkcs11_del_provider(name) == 0 ? 167 SSH_AGENT_SUCCESS : SSH_AGENT_FAILURE)) != 0) 168 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 169 free(pin); 170 free(name); 171 send_msg(msg); 172 sshbuf_free(msg); 173 } 174 175 static void 176 process_sign(void) 177 { 178 u_char *blob, *data, *signature = NULL; 179 size_t blen, dlen, slen = 0; 180 int r, ok = -1; 181 struct sshkey *key, *found; 182 struct sshbuf *msg; 183 184 /* XXX support SHA2 signature flags */ 185 if ((r = sshbuf_get_string(iqueue, &blob, &blen)) != 0 || 186 (r = sshbuf_get_string(iqueue, &data, &dlen)) != 0 || 187 (r = sshbuf_get_u32(iqueue, NULL)) != 0) 188 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 189 190 if ((r = sshkey_from_blob(blob, blen, &key)) != 0) 191 error("%s: sshkey_from_blob: %s", __func__, ssh_err(r)); 192 else { 193 if ((found = lookup_key(key)) != NULL) { 194 #ifdef WITH_OPENSSL 195 u_int xslen; 196 int ret; 197 198 if (key->type == KEY_RSA) { 199 slen = RSA_size(key->rsa); 200 signature = xmalloc(slen); 201 ret = RSA_private_encrypt(dlen, data, signature, 202 found->rsa, RSA_PKCS1_PADDING); 203 if (ret != -1) { 204 slen = ret; 205 ok = 0; 206 } 207 } else if (key->type == KEY_ECDSA) { 208 xslen = ECDSA_size(key->ecdsa); 209 signature = xmalloc(xslen); 210 /* "The parameter type is ignored." */ 211 ret = ECDSA_sign(-1, data, dlen, signature, 212 &xslen, found->ecdsa); 213 if (ret != 0) 214 ok = 0; 215 else 216 error("%s: ECDSA_sign" 217 " returns %d", __func__, ret); 218 slen = xslen; 219 } else 220 error("%s: don't know how to sign with key " 221 "type %d", __func__, (int)key->type); 222 #endif /* WITH_OPENSSL */ 223 } 224 sshkey_free(key); 225 } 226 if ((msg = sshbuf_new()) == NULL) 227 fatal("%s: sshbuf_new failed", __func__); 228 if (ok == 0) { 229 if ((r = sshbuf_put_u8(msg, SSH2_AGENT_SIGN_RESPONSE)) != 0 || 230 (r = sshbuf_put_string(msg, signature, slen)) != 0) 231 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 232 } else { 233 if ((r = sshbuf_put_u8(msg, SSH2_AGENT_FAILURE)) != 0) 234 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 235 } 236 free(data); 237 free(blob); 238 free(signature); 239 send_msg(msg); 240 sshbuf_free(msg); 241 } 242 243 static void 244 process(void) 245 { 246 u_int msg_len; 247 u_int buf_len; 248 u_int consumed; 249 u_char type; 250 const u_char *cp; 251 int r; 252 253 buf_len = sshbuf_len(iqueue); 254 if (buf_len < 5) 255 return; /* Incomplete message. */ 256 cp = sshbuf_ptr(iqueue); 257 msg_len = get_u32(cp); 258 if (msg_len > MAX_MSG_LENGTH) { 259 error("bad message len %d", msg_len); 260 cleanup_exit(11); 261 } 262 if (buf_len < msg_len + 4) 263 return; 264 if ((r = sshbuf_consume(iqueue, 4)) != 0 || 265 (r = sshbuf_get_u8(iqueue, &type)) != 0) 266 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 267 buf_len -= 4; 268 switch (type) { 269 case SSH_AGENTC_ADD_SMARTCARD_KEY: 270 debug("process_add"); 271 process_add(); 272 break; 273 case SSH_AGENTC_REMOVE_SMARTCARD_KEY: 274 debug("process_del"); 275 process_del(); 276 break; 277 case SSH2_AGENTC_SIGN_REQUEST: 278 debug("process_sign"); 279 process_sign(); 280 break; 281 default: 282 error("Unknown message %d", type); 283 break; 284 } 285 /* discard the remaining bytes from the current packet */ 286 if (buf_len < sshbuf_len(iqueue)) { 287 error("iqueue grew unexpectedly"); 288 cleanup_exit(255); 289 } 290 consumed = buf_len - sshbuf_len(iqueue); 291 if (msg_len < consumed) { 292 error("msg_len %d < consumed %d", msg_len, consumed); 293 cleanup_exit(255); 294 } 295 if (msg_len > consumed) { 296 if ((r = sshbuf_consume(iqueue, msg_len - consumed)) != 0) 297 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 298 } 299 } 300 301 void 302 cleanup_exit(int i) 303 { 304 /* XXX */ 305 _exit(i); 306 } 307 308 309 int 310 main(int argc, char **argv) 311 { 312 int r, ch, in, out, max, log_stderr = 0; 313 ssize_t len; 314 SyslogFacility log_facility = SYSLOG_FACILITY_AUTH; 315 LogLevel log_level = SYSLOG_LEVEL_ERROR; 316 char buf[4*4096]; 317 extern char *__progname; 318 struct pollfd pfd[2]; 319 320 ssh_malloc_init(); /* must be called before any mallocs */ 321 TAILQ_INIT(&pkcs11_keylist); 322 323 log_init(__progname, log_level, log_facility, log_stderr); 324 325 while ((ch = getopt(argc, argv, "v")) != -1) { 326 switch (ch) { 327 case 'v': 328 log_stderr = 1; 329 if (log_level == SYSLOG_LEVEL_ERROR) 330 log_level = SYSLOG_LEVEL_DEBUG1; 331 else if (log_level < SYSLOG_LEVEL_DEBUG3) 332 log_level++; 333 break; 334 default: 335 fprintf(stderr, "usage: %s [-v]\n", __progname); 336 exit(1); 337 } 338 } 339 340 log_init(__progname, log_level, log_facility, log_stderr); 341 342 pkcs11_init(0); 343 in = STDIN_FILENO; 344 out = STDOUT_FILENO; 345 346 max = 0; 347 if (in > max) 348 max = in; 349 if (out > max) 350 max = out; 351 352 if ((iqueue = sshbuf_new()) == NULL) 353 fatal("%s: sshbuf_new failed", __func__); 354 if ((oqueue = sshbuf_new()) == NULL) 355 fatal("%s: sshbuf_new failed", __func__); 356 357 while (1) { 358 memset(pfd, 0, sizeof(pfd)); 359 pfd[0].fd = in; 360 pfd[1].fd = out; 361 362 /* 363 * Ensure that we can read a full buffer and handle 364 * the worst-case length packet it can generate, 365 * otherwise apply backpressure by stopping reads. 366 */ 367 if ((r = sshbuf_check_reserve(iqueue, sizeof(buf))) == 0 && 368 (r = sshbuf_check_reserve(oqueue, MAX_MSG_LENGTH)) == 0) 369 pfd[0].events = POLLIN; 370 else if (r != SSH_ERR_NO_BUFFER_SPACE) 371 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 372 373 if (sshbuf_len(oqueue) > 0) 374 pfd[1].events = POLLOUT; 375 376 if ((r = poll(pfd, 2, -1 /* INFTIM */)) <= 0) { 377 if (r == 0 || errno == EINTR) 378 continue; 379 fatal("poll: %s", strerror(errno)); 380 } 381 382 /* copy stdin to iqueue */ 383 if ((pfd[0].revents & (POLLIN|POLLERR)) != 0) { 384 len = read(in, buf, sizeof buf); 385 if (len == 0) { 386 debug("read eof"); 387 cleanup_exit(0); 388 } else if (len < 0) { 389 error("read: %s", strerror(errno)); 390 cleanup_exit(1); 391 } else if ((r = sshbuf_put(iqueue, buf, len)) != 0) { 392 fatal("%s: buffer error: %s", 393 __func__, ssh_err(r)); 394 } 395 } 396 /* send oqueue to stdout */ 397 if ((pfd[1].revents & (POLLOUT|POLLHUP)) != 0) { 398 len = write(out, sshbuf_ptr(oqueue), 399 sshbuf_len(oqueue)); 400 if (len < 0) { 401 error("write: %s", strerror(errno)); 402 cleanup_exit(1); 403 } else if ((r = sshbuf_consume(oqueue, len)) != 0) { 404 fatal("%s: buffer error: %s", 405 __func__, ssh_err(r)); 406 } 407 } 408 409 /* 410 * Process requests from client if we can fit the results 411 * into the output buffer, otherwise stop processing input 412 * and let the output queue drain. 413 */ 414 if ((r = sshbuf_check_reserve(oqueue, MAX_MSG_LENGTH)) == 0) 415 process(); 416 else if (r != SSH_ERR_NO_BUFFER_SPACE) 417 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 418 } 419 } 420