1 /* $OpenBSD: ssh-pkcs11-helper.c,v 1.14 2018/01/08 15:18:46 markus 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 "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 #ifdef ENABLE_PKCS11 42 43 /* borrows code from sftp-server and ssh-agent */ 44 45 struct pkcs11_keyinfo { 46 struct sshkey *key; 47 char *providername; 48 TAILQ_ENTRY(pkcs11_keyinfo) next; 49 }; 50 51 TAILQ_HEAD(, pkcs11_keyinfo) pkcs11_keylist; 52 53 #define MAX_MSG_LENGTH 10240 /*XXX*/ 54 55 /* input and output queue */ 56 struct sshbuf *iqueue; 57 struct sshbuf *oqueue; 58 59 static void 60 add_key(struct sshkey *k, char *name) 61 { 62 struct pkcs11_keyinfo *ki; 63 64 ki = xcalloc(1, sizeof(*ki)); 65 ki->providername = xstrdup(name); 66 ki->key = k; 67 TAILQ_INSERT_TAIL(&pkcs11_keylist, ki, next); 68 } 69 70 static void 71 del_keys_by_name(char *name) 72 { 73 struct pkcs11_keyinfo *ki, *nxt; 74 75 for (ki = TAILQ_FIRST(&pkcs11_keylist); ki; ki = nxt) { 76 nxt = TAILQ_NEXT(ki, next); 77 if (!strcmp(ki->providername, name)) { 78 TAILQ_REMOVE(&pkcs11_keylist, ki, next); 79 free(ki->providername); 80 sshkey_free(ki->key); 81 free(ki); 82 } 83 } 84 } 85 86 /* lookup matching 'private' key */ 87 static struct sshkey * 88 lookup_key(struct sshkey *k) 89 { 90 struct pkcs11_keyinfo *ki; 91 92 TAILQ_FOREACH(ki, &pkcs11_keylist, next) { 93 debug("check %p %s", ki, ki->providername); 94 if (sshkey_equal(k, ki->key)) 95 return (ki->key); 96 } 97 return (NULL); 98 } 99 100 static void 101 send_msg(struct sshbuf *m) 102 { 103 int r; 104 105 if ((r = sshbuf_put_stringb(oqueue, m)) != 0) 106 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 107 } 108 109 static void 110 process_add(void) 111 { 112 char *name, *pin; 113 struct sshkey **keys; 114 int r, i, nkeys; 115 u_char *blob; 116 size_t blen; 117 struct sshbuf *msg; 118 119 if ((msg = sshbuf_new()) == NULL) 120 fatal("%s: sshbuf_new failed", __func__); 121 if ((r = sshbuf_get_cstring(iqueue, &name, NULL)) != 0 || 122 (r = sshbuf_get_cstring(iqueue, &pin, NULL)) != 0) 123 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 124 if ((nkeys = pkcs11_add_provider(name, pin, &keys)) > 0) { 125 if ((r = sshbuf_put_u8(msg, 126 SSH2_AGENT_IDENTITIES_ANSWER)) != 0 || 127 (r = sshbuf_put_u32(msg, nkeys)) != 0) 128 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 129 for (i = 0; i < nkeys; i++) { 130 if ((r = sshkey_to_blob(keys[i], &blob, &blen)) != 0) { 131 debug("%s: sshkey_to_blob: %s", 132 __func__, ssh_err(r)); 133 continue; 134 } 135 if ((r = sshbuf_put_string(msg, blob, blen)) != 0 || 136 (r = sshbuf_put_cstring(msg, name)) != 0) 137 fatal("%s: buffer error: %s", 138 __func__, ssh_err(r)); 139 free(blob); 140 add_key(keys[i], name); 141 } 142 free(keys); 143 } else { 144 if ((r = sshbuf_put_u8(msg, SSH_AGENT_FAILURE)) != 0) 145 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 146 } 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 int ret; 196 197 slen = RSA_size(key->rsa); 198 signature = xmalloc(slen); 199 if ((ret = RSA_private_encrypt(dlen, data, signature, 200 found->rsa, RSA_PKCS1_PADDING)) != -1) { 201 slen = ret; 202 ok = 0; 203 } 204 #endif /* WITH_OPENSSL */ 205 } 206 sshkey_free(key); 207 } 208 if ((msg = sshbuf_new()) == NULL) 209 fatal("%s: sshbuf_new failed", __func__); 210 if (ok == 0) { 211 if ((r = sshbuf_put_u8(msg, SSH2_AGENT_SIGN_RESPONSE)) != 0 || 212 (r = sshbuf_put_string(msg, signature, slen)) != 0) 213 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 214 } else { 215 if ((r = sshbuf_put_u8(msg, SSH2_AGENT_FAILURE)) != 0) 216 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 217 } 218 free(data); 219 free(blob); 220 free(signature); 221 send_msg(msg); 222 sshbuf_free(msg); 223 } 224 225 static void 226 process(void) 227 { 228 u_int msg_len; 229 u_int buf_len; 230 u_int consumed; 231 u_char type; 232 const u_char *cp; 233 int r; 234 235 buf_len = sshbuf_len(iqueue); 236 if (buf_len < 5) 237 return; /* Incomplete message. */ 238 cp = sshbuf_ptr(iqueue); 239 msg_len = get_u32(cp); 240 if (msg_len > MAX_MSG_LENGTH) { 241 error("bad message len %d", msg_len); 242 cleanup_exit(11); 243 } 244 if (buf_len < msg_len + 4) 245 return; 246 if ((r = sshbuf_consume(iqueue, 4)) != 0 || 247 (r = sshbuf_get_u8(iqueue, &type)) != 0) 248 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 249 buf_len -= 4; 250 switch (type) { 251 case SSH_AGENTC_ADD_SMARTCARD_KEY: 252 debug("process_add"); 253 process_add(); 254 break; 255 case SSH_AGENTC_REMOVE_SMARTCARD_KEY: 256 debug("process_del"); 257 process_del(); 258 break; 259 case SSH2_AGENTC_SIGN_REQUEST: 260 debug("process_sign"); 261 process_sign(); 262 break; 263 default: 264 error("Unknown message %d", type); 265 break; 266 } 267 /* discard the remaining bytes from the current packet */ 268 if (buf_len < sshbuf_len(iqueue)) { 269 error("iqueue grew unexpectedly"); 270 cleanup_exit(255); 271 } 272 consumed = buf_len - sshbuf_len(iqueue); 273 if (msg_len < consumed) { 274 error("msg_len %d < consumed %d", msg_len, consumed); 275 cleanup_exit(255); 276 } 277 if (msg_len > consumed) { 278 if ((r = sshbuf_consume(iqueue, msg_len - consumed)) != 0) 279 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 280 } 281 } 282 283 void 284 cleanup_exit(int i) 285 { 286 /* XXX */ 287 _exit(i); 288 } 289 290 int 291 main(int argc, char **argv) 292 { 293 fd_set *rset, *wset; 294 int r, in, out, max, log_stderr = 0; 295 ssize_t len, olen, set_size; 296 SyslogFacility log_facility = SYSLOG_FACILITY_AUTH; 297 LogLevel log_level = SYSLOG_LEVEL_ERROR; 298 char buf[4*4096]; 299 300 extern char *__progname; 301 302 ssh_malloc_init(); /* must be called before any mallocs */ 303 TAILQ_INIT(&pkcs11_keylist); 304 pkcs11_init(0); 305 306 seed_rng(); 307 __progname = ssh_get_progname(argv[0]); 308 309 log_init(__progname, log_level, log_facility, log_stderr); 310 311 in = STDIN_FILENO; 312 out = STDOUT_FILENO; 313 314 max = 0; 315 if (in > max) 316 max = in; 317 if (out > max) 318 max = out; 319 320 if ((iqueue = sshbuf_new()) == NULL) 321 fatal("%s: sshbuf_new failed", __func__); 322 if ((oqueue = sshbuf_new()) == NULL) 323 fatal("%s: sshbuf_new failed", __func__); 324 325 set_size = howmany(max + 1, NFDBITS) * sizeof(fd_mask); 326 rset = xmalloc(set_size); 327 wset = xmalloc(set_size); 328 329 for (;;) { 330 memset(rset, 0, set_size); 331 memset(wset, 0, set_size); 332 333 /* 334 * Ensure that we can read a full buffer and handle 335 * the worst-case length packet it can generate, 336 * otherwise apply backpressure by stopping reads. 337 */ 338 if ((r = sshbuf_check_reserve(iqueue, sizeof(buf))) == 0 && 339 (r = sshbuf_check_reserve(oqueue, MAX_MSG_LENGTH)) == 0) 340 FD_SET(in, rset); 341 else if (r != SSH_ERR_NO_BUFFER_SPACE) 342 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 343 344 olen = sshbuf_len(oqueue); 345 if (olen > 0) 346 FD_SET(out, wset); 347 348 if (select(max+1, rset, wset, NULL, NULL) < 0) { 349 if (errno == EINTR) 350 continue; 351 error("select: %s", strerror(errno)); 352 cleanup_exit(2); 353 } 354 355 /* copy stdin to iqueue */ 356 if (FD_ISSET(in, rset)) { 357 len = read(in, buf, sizeof buf); 358 if (len == 0) { 359 debug("read eof"); 360 cleanup_exit(0); 361 } else if (len < 0) { 362 error("read: %s", strerror(errno)); 363 cleanup_exit(1); 364 } else if ((r = sshbuf_put(iqueue, buf, len)) != 0) { 365 fatal("%s: buffer error: %s", 366 __func__, ssh_err(r)); 367 } 368 } 369 /* send oqueue to stdout */ 370 if (FD_ISSET(out, wset)) { 371 len = write(out, sshbuf_ptr(oqueue), olen); 372 if (len < 0) { 373 error("write: %s", strerror(errno)); 374 cleanup_exit(1); 375 } else if ((r = sshbuf_consume(oqueue, len)) != 0) { 376 fatal("%s: buffer error: %s", 377 __func__, ssh_err(r)); 378 } 379 } 380 381 /* 382 * Process requests from client if we can fit the results 383 * into the output buffer, otherwise stop processing input 384 * and let the output queue drain. 385 */ 386 if ((r = sshbuf_check_reserve(oqueue, MAX_MSG_LENGTH)) == 0) 387 process(); 388 else if (r != SSH_ERR_NO_BUFFER_SPACE) 389 fatal("%s: buffer error: %s", __func__, ssh_err(r)); 390 } 391 } 392 #else /* ENABLE_PKCS11 */ 393 int 394 main(int argc, char **argv) 395 { 396 extern char *__progname; 397 398 __progname = ssh_get_progname(argv[0]); 399 log_init(__progname, SYSLOG_LEVEL_ERROR, SYSLOG_FACILITY_AUTH, 0); 400 fatal("PKCS#11 support disabled at compile time"); 401 } 402 #endif /* ENABLE_PKCS11 */ 403