1 /* $OpenBSD: authfd.c,v 1.134 2023/12/18 14:46:56 djm Exp $ */
2 /*
3 * Author: Tatu Ylonen <ylo@cs.hut.fi>
4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * All rights reserved
6 * Functions for connecting the local authentication agent.
7 *
8 * As far as I am concerned, the code I have written for this software
9 * can be used freely for any purpose. Any derived versions of this
10 * software must be clearly marked as such, and if the derived work is
11 * incompatible with the protocol description in the RFC file, it must be
12 * called by a name other than "ssh" or "Secure Shell".
13 *
14 * SSH2 implementation,
15 * Copyright (c) 2000 Markus Friedl. All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions
19 * are met:
20 * 1. Redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer.
22 * 2. Redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
28 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
29 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
30 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
31 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
35 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 */
37
38 #include "includes.h"
39
40 #include <sys/types.h>
41 #include <sys/un.h>
42 #include <sys/socket.h>
43
44 #include <fcntl.h>
45 #include <stdlib.h>
46 #include <signal.h>
47 #include <string.h>
48 #include <stdarg.h>
49 #include <unistd.h>
50 #include <errno.h>
51
52 #include "xmalloc.h"
53 #include "ssh.h"
54 #include "sshbuf.h"
55 #include "sshkey.h"
56 #include "authfd.h"
57 #include "cipher.h"
58 #include "log.h"
59 #include "atomicio.h"
60 #include "misc.h"
61 #include "ssherr.h"
62
63 #define MAX_AGENT_IDENTITIES 2048 /* Max keys in agent reply */
64 #define MAX_AGENT_REPLY_LEN (256 * 1024) /* Max bytes in agent reply */
65
66 /* macro to check for "agent failure" message */
67 #define agent_failed(x) \
68 ((x == SSH_AGENT_FAILURE) || \
69 (x == SSH_COM_AGENT2_FAILURE) || \
70 (x == SSH2_AGENT_FAILURE))
71
72 /* Convert success/failure response from agent to a err.h status */
73 static int
decode_reply(u_char type)74 decode_reply(u_char type)
75 {
76 if (agent_failed(type))
77 return SSH_ERR_AGENT_FAILURE;
78 else if (type == SSH_AGENT_SUCCESS)
79 return 0;
80 else
81 return SSH_ERR_INVALID_FORMAT;
82 }
83
84 /*
85 * Opens an authentication socket at the provided path and stores the file
86 * descriptor in fdp. Returns 0 on success and an error on failure.
87 */
88 int
ssh_get_authentication_socket_path(const char * authsocket,int * fdp)89 ssh_get_authentication_socket_path(const char *authsocket, int *fdp)
90 {
91 int sock, oerrno;
92 struct sockaddr_un sunaddr;
93
94 debug3_f("path '%s'", authsocket);
95 memset(&sunaddr, 0, sizeof(sunaddr));
96 sunaddr.sun_family = AF_UNIX;
97 strlcpy(sunaddr.sun_path, authsocket, sizeof(sunaddr.sun_path));
98
99 if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
100 return SSH_ERR_SYSTEM_ERROR;
101
102 /* close on exec */
103 if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1 ||
104 connect(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
105 oerrno = errno;
106 close(sock);
107 errno = oerrno;
108 return SSH_ERR_SYSTEM_ERROR;
109 }
110 if (fdp != NULL)
111 *fdp = sock;
112 else
113 close(sock);
114 return 0;
115 }
116
117 /*
118 * Opens the default authentication socket and stores the file descriptor in
119 * fdp. Returns 0 on success and an error on failure.
120 */
121 int
ssh_get_authentication_socket(int * fdp)122 ssh_get_authentication_socket(int *fdp)
123 {
124 const char *authsocket;
125
126 if (fdp != NULL)
127 *fdp = -1;
128
129 authsocket = getenv(SSH_AUTHSOCKET_ENV_NAME);
130 if (authsocket == NULL || *authsocket == '\0')
131 return SSH_ERR_AGENT_NOT_PRESENT;
132
133 return ssh_get_authentication_socket_path(authsocket, fdp);
134 }
135
136 /* Communicate with agent: send request and read reply */
137 static int
ssh_request_reply(int sock,struct sshbuf * request,struct sshbuf * reply)138 ssh_request_reply(int sock, struct sshbuf *request, struct sshbuf *reply)
139 {
140 int r;
141 size_t l, len;
142 char buf[1024];
143
144 /* Get the length of the message, and format it in the buffer. */
145 len = sshbuf_len(request);
146 POKE_U32(buf, len);
147
148 /* Send the length and then the packet to the agent. */
149 if (atomicio(vwrite, sock, buf, 4) != 4 ||
150 atomicio(vwrite, sock, sshbuf_mutable_ptr(request),
151 sshbuf_len(request)) != sshbuf_len(request))
152 return SSH_ERR_AGENT_COMMUNICATION;
153 /*
154 * Wait for response from the agent. First read the length of the
155 * response packet.
156 */
157 if (atomicio(read, sock, buf, 4) != 4)
158 return SSH_ERR_AGENT_COMMUNICATION;
159
160 /* Extract the length, and check it for sanity. */
161 len = PEEK_U32(buf);
162 if (len > MAX_AGENT_REPLY_LEN)
163 return SSH_ERR_INVALID_FORMAT;
164
165 /* Read the rest of the response in to the buffer. */
166 sshbuf_reset(reply);
167 while (len > 0) {
168 l = len;
169 if (l > sizeof(buf))
170 l = sizeof(buf);
171 if (atomicio(read, sock, buf, l) != l)
172 return SSH_ERR_AGENT_COMMUNICATION;
173 if ((r = sshbuf_put(reply, buf, l)) != 0)
174 return r;
175 len -= l;
176 }
177 return 0;
178 }
179
180 /* Communicate with agent: sent request, read and decode status reply */
181 static int
ssh_request_reply_decode(int sock,struct sshbuf * request)182 ssh_request_reply_decode(int sock, struct sshbuf *request)
183 {
184 struct sshbuf *reply;
185 int r;
186 u_char type;
187
188 if ((reply = sshbuf_new()) == NULL)
189 return SSH_ERR_ALLOC_FAIL;
190 if ((r = ssh_request_reply(sock, request, reply)) != 0 ||
191 (r = sshbuf_get_u8(reply, &type)) != 0 ||
192 (r = decode_reply(type)) != 0)
193 goto out;
194 /* success */
195 r = 0;
196 out:
197 sshbuf_free(reply);
198 return r;
199 }
200
201 /*
202 * Closes the agent socket if it should be closed (depends on how it was
203 * obtained). The argument must have been returned by
204 * ssh_get_authentication_socket().
205 */
206 void
ssh_close_authentication_socket(int sock)207 ssh_close_authentication_socket(int sock)
208 {
209 if (getenv(SSH_AUTHSOCKET_ENV_NAME))
210 close(sock);
211 }
212
213 /* Lock/unlock agent */
214 int
ssh_lock_agent(int sock,int lock,const char * password)215 ssh_lock_agent(int sock, int lock, const char *password)
216 {
217 int r;
218 u_char type = lock ? SSH_AGENTC_LOCK : SSH_AGENTC_UNLOCK;
219 struct sshbuf *msg;
220
221 if ((msg = sshbuf_new()) == NULL)
222 return SSH_ERR_ALLOC_FAIL;
223 if ((r = sshbuf_put_u8(msg, type)) != 0 ||
224 (r = sshbuf_put_cstring(msg, password)) != 0 ||
225 (r = ssh_request_reply_decode(sock, msg)) != 0)
226 goto out;
227 /* success */
228 r = 0;
229 out:
230 sshbuf_free(msg);
231 return r;
232 }
233
234
235 static int
deserialise_identity2(struct sshbuf * ids,struct sshkey ** keyp,char ** commentp)236 deserialise_identity2(struct sshbuf *ids, struct sshkey **keyp, char **commentp)
237 {
238 int r;
239 char *comment = NULL;
240 const u_char *blob;
241 size_t blen;
242
243 if ((r = sshbuf_get_string_direct(ids, &blob, &blen)) != 0 ||
244 (r = sshbuf_get_cstring(ids, &comment, NULL)) != 0)
245 goto out;
246 if ((r = sshkey_from_blob(blob, blen, keyp)) != 0)
247 goto out;
248 if (commentp != NULL) {
249 *commentp = comment;
250 comment = NULL;
251 }
252 r = 0;
253 out:
254 free(comment);
255 return r;
256 }
257
258 /*
259 * Fetch list of identities held by the agent.
260 */
261 int
ssh_fetch_identitylist(int sock,struct ssh_identitylist ** idlp)262 ssh_fetch_identitylist(int sock, struct ssh_identitylist **idlp)
263 {
264 u_char type;
265 u_int32_t num, i;
266 struct sshbuf *msg;
267 struct ssh_identitylist *idl = NULL;
268 int r;
269
270 /*
271 * Send a message to the agent requesting for a list of the
272 * identities it can represent.
273 */
274 if ((msg = sshbuf_new()) == NULL)
275 return SSH_ERR_ALLOC_FAIL;
276 if ((r = sshbuf_put_u8(msg, SSH2_AGENTC_REQUEST_IDENTITIES)) != 0)
277 goto out;
278
279 if ((r = ssh_request_reply(sock, msg, msg)) != 0)
280 goto out;
281
282 /* Get message type, and verify that we got a proper answer. */
283 if ((r = sshbuf_get_u8(msg, &type)) != 0)
284 goto out;
285 if (agent_failed(type)) {
286 r = SSH_ERR_AGENT_FAILURE;
287 goto out;
288 } else if (type != SSH2_AGENT_IDENTITIES_ANSWER) {
289 r = SSH_ERR_INVALID_FORMAT;
290 goto out;
291 }
292
293 /* Get the number of entries in the response and check it for sanity. */
294 if ((r = sshbuf_get_u32(msg, &num)) != 0)
295 goto out;
296 if (num > MAX_AGENT_IDENTITIES) {
297 r = SSH_ERR_INVALID_FORMAT;
298 goto out;
299 }
300 if (num == 0) {
301 r = SSH_ERR_AGENT_NO_IDENTITIES;
302 goto out;
303 }
304
305 /* Deserialise the response into a list of keys/comments */
306 if ((idl = calloc(1, sizeof(*idl))) == NULL ||
307 (idl->keys = calloc(num, sizeof(*idl->keys))) == NULL ||
308 (idl->comments = calloc(num, sizeof(*idl->comments))) == NULL) {
309 r = SSH_ERR_ALLOC_FAIL;
310 goto out;
311 }
312 for (i = 0; i < num;) {
313 if ((r = deserialise_identity2(msg, &(idl->keys[i]),
314 &(idl->comments[i]))) != 0) {
315 if (r == SSH_ERR_KEY_TYPE_UNKNOWN) {
316 /* Gracefully skip unknown key types */
317 num--;
318 continue;
319 } else
320 goto out;
321 }
322 i++;
323 }
324 idl->nkeys = num;
325 *idlp = idl;
326 idl = NULL;
327 r = 0;
328 out:
329 sshbuf_free(msg);
330 if (idl != NULL)
331 ssh_free_identitylist(idl);
332 return r;
333 }
334
335 void
ssh_free_identitylist(struct ssh_identitylist * idl)336 ssh_free_identitylist(struct ssh_identitylist *idl)
337 {
338 size_t i;
339
340 if (idl == NULL)
341 return;
342 for (i = 0; i < idl->nkeys; i++) {
343 if (idl->keys != NULL)
344 sshkey_free(idl->keys[i]);
345 if (idl->comments != NULL)
346 free(idl->comments[i]);
347 }
348 free(idl->keys);
349 free(idl->comments);
350 free(idl);
351 }
352
353 /*
354 * Check if the ssh agent has a given key.
355 * Returns 0 if found, or a negative SSH_ERR_* error code on failure.
356 */
357 int
ssh_agent_has_key(int sock,const struct sshkey * key)358 ssh_agent_has_key(int sock, const struct sshkey *key)
359 {
360 int r, ret = SSH_ERR_KEY_NOT_FOUND;
361 size_t i;
362 struct ssh_identitylist *idlist = NULL;
363
364 if ((r = ssh_fetch_identitylist(sock, &idlist)) != 0) {
365 return r;
366 }
367
368 for (i = 0; i < idlist->nkeys; i++) {
369 if (sshkey_equal_public(idlist->keys[i], key)) {
370 ret = 0;
371 break;
372 }
373 }
374
375 ssh_free_identitylist(idlist);
376 return ret;
377 }
378
379 /*
380 * Sends a challenge (typically from a server via ssh(1)) to the agent,
381 * and waits for a response from the agent.
382 * Returns true (non-zero) if the agent gave the correct answer, zero
383 * otherwise.
384 */
385
386
387 /* encode signature algorithm in flag bits, so we can keep the msg format */
388 static u_int
agent_encode_alg(const struct sshkey * key,const char * alg)389 agent_encode_alg(const struct sshkey *key, const char *alg)
390 {
391 if (alg != NULL && sshkey_type_plain(key->type) == KEY_RSA) {
392 if (strcmp(alg, "rsa-sha2-256") == 0 ||
393 strcmp(alg, "rsa-sha2-256-cert-v01@openssh.com") == 0)
394 return SSH_AGENT_RSA_SHA2_256;
395 if (strcmp(alg, "rsa-sha2-512") == 0 ||
396 strcmp(alg, "rsa-sha2-512-cert-v01@openssh.com") == 0)
397 return SSH_AGENT_RSA_SHA2_512;
398 }
399 return 0;
400 }
401
402 /* ask agent to sign data, returns err.h code on error, 0 on success */
403 int
ssh_agent_sign(int sock,const struct sshkey * key,u_char ** sigp,size_t * lenp,const u_char * data,size_t datalen,const char * alg,u_int compat)404 ssh_agent_sign(int sock, const struct sshkey *key,
405 u_char **sigp, size_t *lenp,
406 const u_char *data, size_t datalen, const char *alg, u_int compat)
407 {
408 struct sshbuf *msg;
409 u_char *sig = NULL, type = 0;
410 size_t len = 0;
411 u_int flags = 0;
412 int r = SSH_ERR_INTERNAL_ERROR;
413
414 *sigp = NULL;
415 *lenp = 0;
416
417 if (datalen > SSH_KEY_MAX_SIGN_DATA_SIZE)
418 return SSH_ERR_INVALID_ARGUMENT;
419 if ((msg = sshbuf_new()) == NULL)
420 return SSH_ERR_ALLOC_FAIL;
421 flags |= agent_encode_alg(key, alg);
422 if ((r = sshbuf_put_u8(msg, SSH2_AGENTC_SIGN_REQUEST)) != 0 ||
423 (r = sshkey_puts(key, msg)) != 0 ||
424 (r = sshbuf_put_string(msg, data, datalen)) != 0 ||
425 (r = sshbuf_put_u32(msg, flags)) != 0)
426 goto out;
427 if ((r = ssh_request_reply(sock, msg, msg)) != 0)
428 goto out;
429 if ((r = sshbuf_get_u8(msg, &type)) != 0)
430 goto out;
431 if (agent_failed(type)) {
432 r = SSH_ERR_AGENT_FAILURE;
433 goto out;
434 } else if (type != SSH2_AGENT_SIGN_RESPONSE) {
435 r = SSH_ERR_INVALID_FORMAT;
436 goto out;
437 }
438 if ((r = sshbuf_get_string(msg, &sig, &len)) != 0)
439 goto out;
440 /* Check what we actually got back from the agent. */
441 if ((r = sshkey_check_sigtype(sig, len, alg)) != 0)
442 goto out;
443 /* success */
444 *sigp = sig;
445 *lenp = len;
446 sig = NULL;
447 len = 0;
448 r = 0;
449 out:
450 freezero(sig, len);
451 sshbuf_free(msg);
452 return r;
453 }
454
455 /* Encode key for a message to the agent. */
456
457 static int
encode_dest_constraint_hop(struct sshbuf * m,const struct dest_constraint_hop * dch)458 encode_dest_constraint_hop(struct sshbuf *m,
459 const struct dest_constraint_hop *dch)
460 {
461 struct sshbuf *b;
462 u_int i;
463 int r;
464
465 if ((b = sshbuf_new()) == NULL)
466 return SSH_ERR_ALLOC_FAIL;
467 if ((r = sshbuf_put_cstring(b, dch->user)) != 0 ||
468 (r = sshbuf_put_cstring(b, dch->hostname)) != 0 ||
469 (r = sshbuf_put_string(b, NULL, 0)) != 0) /* reserved */
470 goto out;
471 for (i = 0; i < dch->nkeys; i++) {
472 if ((r = sshkey_puts(dch->keys[i], b)) != 0 ||
473 (r = sshbuf_put_u8(b, dch->key_is_ca[i] != 0)) != 0)
474 goto out;
475 }
476 if ((r = sshbuf_put_stringb(m, b)) != 0)
477 goto out;
478 /* success */
479 r = 0;
480 out:
481 sshbuf_free(b);
482 return r;
483 }
484
485 static int
encode_dest_constraint(struct sshbuf * m,const struct dest_constraint * dc)486 encode_dest_constraint(struct sshbuf *m, const struct dest_constraint *dc)
487 {
488 struct sshbuf *b;
489 int r;
490
491 if ((b = sshbuf_new()) == NULL)
492 return SSH_ERR_ALLOC_FAIL;
493 if ((r = encode_dest_constraint_hop(b, &dc->from)) != 0 ||
494 (r = encode_dest_constraint_hop(b, &dc->to)) != 0 ||
495 (r = sshbuf_put_string(b, NULL, 0)) != 0) /* reserved */
496 goto out;
497 if ((r = sshbuf_put_stringb(m, b)) != 0)
498 goto out;
499 /* success */
500 r = 0;
501 out:
502 sshbuf_free(b);
503 return r;
504 }
505
506 static int
encode_constraints(struct sshbuf * m,u_int life,u_int confirm,u_int maxsign,const char * provider,struct dest_constraint ** dest_constraints,size_t ndest_constraints,int cert_only,struct sshkey ** certs,size_t ncerts)507 encode_constraints(struct sshbuf *m, u_int life, u_int confirm,
508 u_int maxsign, const char *provider,
509 struct dest_constraint **dest_constraints, size_t ndest_constraints,
510 int cert_only, struct sshkey **certs, size_t ncerts)
511 {
512 int r;
513 struct sshbuf *b = NULL;
514 size_t i;
515
516 if (life != 0) {
517 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_LIFETIME)) != 0 ||
518 (r = sshbuf_put_u32(m, life)) != 0)
519 goto out;
520 }
521 if (confirm != 0) {
522 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_CONFIRM)) != 0)
523 goto out;
524 }
525 if (maxsign != 0) {
526 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_MAXSIGN)) != 0 ||
527 (r = sshbuf_put_u32(m, maxsign)) != 0)
528 goto out;
529 }
530 if (provider != NULL) {
531 if ((r = sshbuf_put_u8(m,
532 SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
533 (r = sshbuf_put_cstring(m,
534 "sk-provider@openssh.com")) != 0 ||
535 (r = sshbuf_put_cstring(m, provider)) != 0)
536 goto out;
537 }
538 if (dest_constraints != NULL && ndest_constraints > 0) {
539 if ((b = sshbuf_new()) == NULL) {
540 r = SSH_ERR_ALLOC_FAIL;
541 goto out;
542 }
543 for (i = 0; i < ndest_constraints; i++) {
544 if ((r = encode_dest_constraint(b,
545 dest_constraints[i])) != 0)
546 goto out;
547 }
548 if ((r = sshbuf_put_u8(m,
549 SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
550 (r = sshbuf_put_cstring(m,
551 "restrict-destination-v00@openssh.com")) != 0 ||
552 (r = sshbuf_put_stringb(m, b)) != 0)
553 goto out;
554 sshbuf_free(b);
555 b = NULL;
556 }
557 if (ncerts != 0) {
558 if ((b = sshbuf_new()) == NULL) {
559 r = SSH_ERR_ALLOC_FAIL;
560 goto out;
561 }
562 for (i = 0; i < ncerts; i++) {
563 if ((r = sshkey_puts(certs[i], b)) != 0)
564 goto out;
565 }
566 if ((r = sshbuf_put_u8(m,
567 SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
568 (r = sshbuf_put_cstring(m,
569 "associated-certs-v00@openssh.com")) != 0 ||
570 (r = sshbuf_put_u8(m, cert_only != 0)) != 0 ||
571 (r = sshbuf_put_stringb(m, b)) != 0)
572 goto out;
573 sshbuf_free(b);
574 b = NULL;
575 }
576 r = 0;
577 out:
578 sshbuf_free(b);
579 return r;
580 }
581
582 /*
583 * Adds an identity to the authentication server.
584 * This call is intended only for use by ssh-add(1) and like applications.
585 */
586 int
ssh_add_identity_constrained(int sock,struct sshkey * key,const char * comment,u_int life,u_int confirm,u_int maxsign,const char * provider,struct dest_constraint ** dest_constraints,size_t ndest_constraints)587 ssh_add_identity_constrained(int sock, struct sshkey *key,
588 const char *comment, u_int life, u_int confirm, u_int maxsign,
589 const char *provider, struct dest_constraint **dest_constraints,
590 size_t ndest_constraints)
591 {
592 struct sshbuf *msg;
593 int r, constrained = (life || confirm || maxsign ||
594 provider || dest_constraints);
595 u_char type;
596
597 if ((msg = sshbuf_new()) == NULL)
598 return SSH_ERR_ALLOC_FAIL;
599
600 switch (key->type) {
601 #ifdef WITH_OPENSSL
602 case KEY_RSA:
603 case KEY_RSA_CERT:
604 case KEY_DSA:
605 case KEY_DSA_CERT:
606 case KEY_ECDSA:
607 case KEY_ECDSA_CERT:
608 case KEY_ECDSA_SK:
609 case KEY_ECDSA_SK_CERT:
610 #endif
611 case KEY_ED25519:
612 case KEY_ED25519_CERT:
613 case KEY_ED25519_SK:
614 case KEY_ED25519_SK_CERT:
615 case KEY_XMSS:
616 case KEY_XMSS_CERT:
617 type = constrained ?
618 SSH2_AGENTC_ADD_ID_CONSTRAINED :
619 SSH2_AGENTC_ADD_IDENTITY;
620 if ((r = sshbuf_put_u8(msg, type)) != 0 ||
621 (r = sshkey_private_serialize_maxsign(key, msg, maxsign,
622 0)) != 0 ||
623 (r = sshbuf_put_cstring(msg, comment)) != 0)
624 goto out;
625 break;
626 default:
627 r = SSH_ERR_INVALID_ARGUMENT;
628 goto out;
629 }
630 if (constrained &&
631 (r = encode_constraints(msg, life, confirm, maxsign,
632 provider, dest_constraints, ndest_constraints, 0, NULL, 0)) != 0)
633 goto out;
634 if ((r = ssh_request_reply_decode(sock, msg)) != 0)
635 goto out;
636 /* success */
637 r = 0;
638 out:
639 sshbuf_free(msg);
640 return r;
641 }
642
643 /*
644 * Removes an identity from the authentication server.
645 * This call is intended only for use by ssh-add(1) and like applications.
646 */
647 int
ssh_remove_identity(int sock,const struct sshkey * key)648 ssh_remove_identity(int sock, const struct sshkey *key)
649 {
650 struct sshbuf *msg;
651 int r;
652 u_char *blob = NULL;
653 size_t blen;
654
655 if ((msg = sshbuf_new()) == NULL)
656 return SSH_ERR_ALLOC_FAIL;
657
658 if (key->type != KEY_UNSPEC) {
659 if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)
660 goto out;
661 if ((r = sshbuf_put_u8(msg,
662 SSH2_AGENTC_REMOVE_IDENTITY)) != 0 ||
663 (r = sshbuf_put_string(msg, blob, blen)) != 0)
664 goto out;
665 } else {
666 r = SSH_ERR_INVALID_ARGUMENT;
667 goto out;
668 }
669 if ((r = ssh_request_reply_decode(sock, msg)) != 0)
670 goto out;
671 /* success */
672 r = 0;
673 out:
674 if (blob != NULL)
675 freezero(blob, blen);
676 sshbuf_free(msg);
677 return r;
678 }
679
680 /*
681 * Add/remove an token-based identity from the authentication server.
682 * This call is intended only for use by ssh-add(1) and like applications.
683 */
684 int
ssh_update_card(int sock,int add,const char * reader_id,const char * pin,u_int life,u_int confirm,struct dest_constraint ** dest_constraints,size_t ndest_constraints,int cert_only,struct sshkey ** certs,size_t ncerts)685 ssh_update_card(int sock, int add, const char *reader_id, const char *pin,
686 u_int life, u_int confirm,
687 struct dest_constraint **dest_constraints, size_t ndest_constraints,
688 int cert_only, struct sshkey **certs, size_t ncerts)
689 {
690 struct sshbuf *msg;
691 int r, constrained = (life || confirm || dest_constraints || certs);
692 u_char type;
693
694 if (add) {
695 type = constrained ?
696 SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED :
697 SSH_AGENTC_ADD_SMARTCARD_KEY;
698 } else
699 type = SSH_AGENTC_REMOVE_SMARTCARD_KEY;
700
701 if ((msg = sshbuf_new()) == NULL)
702 return SSH_ERR_ALLOC_FAIL;
703 if ((r = sshbuf_put_u8(msg, type)) != 0 ||
704 (r = sshbuf_put_cstring(msg, reader_id)) != 0 ||
705 (r = sshbuf_put_cstring(msg, pin)) != 0)
706 goto out;
707 if (constrained &&
708 (r = encode_constraints(msg, life, confirm, 0, NULL,
709 dest_constraints, ndest_constraints,
710 cert_only, certs, ncerts)) != 0)
711 goto out;
712 if ((r = ssh_request_reply_decode(sock, msg)) != 0)
713 goto out;
714 /* success */
715 r = 0;
716 out:
717 sshbuf_free(msg);
718 return r;
719 }
720
721 /*
722 * Removes all identities from the agent.
723 * This call is intended only for use by ssh-add(1) and like applications.
724 *
725 * This supports the SSH protocol 1 message to because, when clearing all
726 * keys from an agent, we generally want to clear both protocol v1 and v2
727 * keys.
728 */
729 int
ssh_remove_all_identities(int sock,int version)730 ssh_remove_all_identities(int sock, int version)
731 {
732 struct sshbuf *msg;
733 u_char type = (version == 1) ?
734 SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES :
735 SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
736 int r;
737
738 if ((msg = sshbuf_new()) == NULL)
739 return SSH_ERR_ALLOC_FAIL;
740 if ((r = sshbuf_put_u8(msg, type)) != 0)
741 goto out;
742 if ((r = ssh_request_reply_decode(sock, msg)) != 0)
743 goto out;
744 /* success */
745 r = 0;
746 out:
747 sshbuf_free(msg);
748 return r;
749 }
750
751 /* Binds a session ID to a hostkey via the initial KEX signature. */
752 int
ssh_agent_bind_hostkey(int sock,const struct sshkey * key,const struct sshbuf * session_id,const struct sshbuf * signature,int forwarding)753 ssh_agent_bind_hostkey(int sock, const struct sshkey *key,
754 const struct sshbuf *session_id, const struct sshbuf *signature,
755 int forwarding)
756 {
757 struct sshbuf *msg;
758 int r;
759
760 if (key == NULL || session_id == NULL || signature == NULL)
761 return SSH_ERR_INVALID_ARGUMENT;
762 if ((msg = sshbuf_new()) == NULL)
763 return SSH_ERR_ALLOC_FAIL;
764 if ((r = sshbuf_put_u8(msg, SSH_AGENTC_EXTENSION)) != 0 ||
765 (r = sshbuf_put_cstring(msg, "session-bind@openssh.com")) != 0 ||
766 (r = sshkey_puts(key, msg)) != 0 ||
767 (r = sshbuf_put_stringb(msg, session_id)) != 0 ||
768 (r = sshbuf_put_stringb(msg, signature)) != 0 ||
769 (r = sshbuf_put_u8(msg, forwarding ? 1 : 0)) != 0)
770 goto out;
771 if ((r = ssh_request_reply_decode(sock, msg)) != 0)
772 goto out;
773 /* success */
774 r = 0;
775 out:
776 sshbuf_free(msg);
777 return r;
778 }
779