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