xref: /openssh-portable/authfd.c (revision cb7b22ea)
1 /* $OpenBSD: authfd.c,v 1.127 2021/01/26 00:46:17 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 "compat.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 	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 
458 static int
encode_constraints(struct sshbuf * m,u_int life,u_int confirm,u_int maxsign,const char * provider)459 encode_constraints(struct sshbuf *m, u_int life, u_int confirm, u_int maxsign,
460     const char *provider)
461 {
462 	int r;
463 
464 	if (life != 0) {
465 		if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_LIFETIME)) != 0 ||
466 		    (r = sshbuf_put_u32(m, life)) != 0)
467 			goto out;
468 	}
469 	if (confirm != 0) {
470 		if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_CONFIRM)) != 0)
471 			goto out;
472 	}
473 	if (maxsign != 0) {
474 		if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_MAXSIGN)) != 0 ||
475 		    (r = sshbuf_put_u32(m, maxsign)) != 0)
476 			goto out;
477 	}
478 	if (provider != NULL) {
479 		if ((r = sshbuf_put_u8(m,
480 		    SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
481 		    (r = sshbuf_put_cstring(m,
482 		    "sk-provider@openssh.com")) != 0 ||
483 		    (r = sshbuf_put_cstring(m, provider)) != 0)
484 			goto out;
485 	}
486 	r = 0;
487  out:
488 	return r;
489 }
490 
491 /*
492  * Adds an identity to the authentication server.
493  * This call is intended only for use by ssh-add(1) and like applications.
494  */
495 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)496 ssh_add_identity_constrained(int sock, struct sshkey *key,
497     const char *comment, u_int life, u_int confirm, u_int maxsign,
498     const char *provider)
499 {
500 	struct sshbuf *msg;
501 	int r, constrained = (life || confirm || maxsign || provider);
502 	u_char type;
503 
504 	if ((msg = sshbuf_new()) == NULL)
505 		return SSH_ERR_ALLOC_FAIL;
506 
507 	switch (key->type) {
508 #ifdef WITH_OPENSSL
509 	case KEY_RSA:
510 	case KEY_RSA_CERT:
511 	case KEY_DSA:
512 	case KEY_DSA_CERT:
513 	case KEY_ECDSA:
514 	case KEY_ECDSA_CERT:
515 	case KEY_ECDSA_SK:
516 	case KEY_ECDSA_SK_CERT:
517 #endif
518 	case KEY_ED25519:
519 	case KEY_ED25519_CERT:
520 	case KEY_ED25519_SK:
521 	case KEY_ED25519_SK_CERT:
522 	case KEY_XMSS:
523 	case KEY_XMSS_CERT:
524 		type = constrained ?
525 		    SSH2_AGENTC_ADD_ID_CONSTRAINED :
526 		    SSH2_AGENTC_ADD_IDENTITY;
527 		if ((r = sshbuf_put_u8(msg, type)) != 0 ||
528 		    (r = sshkey_private_serialize_maxsign(key, msg, maxsign,
529 		    0)) != 0 ||
530 		    (r = sshbuf_put_cstring(msg, comment)) != 0)
531 			goto out;
532 		break;
533 	default:
534 		r = SSH_ERR_INVALID_ARGUMENT;
535 		goto out;
536 	}
537 	if (constrained &&
538 	    (r = encode_constraints(msg, life, confirm, maxsign,
539 	    provider)) != 0)
540 		goto out;
541 	if ((r = ssh_request_reply_decode(sock, msg)) != 0)
542 		goto out;
543 	/* success */
544 	r = 0;
545  out:
546 	sshbuf_free(msg);
547 	return r;
548 }
549 
550 /*
551  * Removes an identity from the authentication server.
552  * This call is intended only for use by ssh-add(1) and like applications.
553  */
554 int
ssh_remove_identity(int sock,const struct sshkey * key)555 ssh_remove_identity(int sock, const struct sshkey *key)
556 {
557 	struct sshbuf *msg;
558 	int r;
559 	u_char *blob = NULL;
560 	size_t blen;
561 
562 	if ((msg = sshbuf_new()) == NULL)
563 		return SSH_ERR_ALLOC_FAIL;
564 
565 	if (key->type != KEY_UNSPEC) {
566 		if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)
567 			goto out;
568 		if ((r = sshbuf_put_u8(msg,
569 		    SSH2_AGENTC_REMOVE_IDENTITY)) != 0 ||
570 		    (r = sshbuf_put_string(msg, blob, blen)) != 0)
571 			goto out;
572 	} else {
573 		r = SSH_ERR_INVALID_ARGUMENT;
574 		goto out;
575 	}
576 	if ((r = ssh_request_reply_decode(sock, msg)) != 0)
577 		goto out;
578 	/* success */
579 	r = 0;
580  out:
581 	if (blob != NULL)
582 		freezero(blob, blen);
583 	sshbuf_free(msg);
584 	return r;
585 }
586 
587 /*
588  * Add/remove an token-based identity from the authentication server.
589  * This call is intended only for use by ssh-add(1) and like applications.
590  */
591 int
ssh_update_card(int sock,int add,const char * reader_id,const char * pin,u_int life,u_int confirm)592 ssh_update_card(int sock, int add, const char *reader_id, const char *pin,
593     u_int life, u_int confirm)
594 {
595 	struct sshbuf *msg;
596 	int r, constrained = (life || confirm);
597 	u_char type;
598 
599 	if (add) {
600 		type = constrained ?
601 		    SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED :
602 		    SSH_AGENTC_ADD_SMARTCARD_KEY;
603 	} else
604 		type = SSH_AGENTC_REMOVE_SMARTCARD_KEY;
605 
606 	if ((msg = sshbuf_new()) == NULL)
607 		return SSH_ERR_ALLOC_FAIL;
608 	if ((r = sshbuf_put_u8(msg, type)) != 0 ||
609 	    (r = sshbuf_put_cstring(msg, reader_id)) != 0 ||
610 	    (r = sshbuf_put_cstring(msg, pin)) != 0)
611 		goto out;
612 	if (constrained &&
613 	    (r = encode_constraints(msg, life, confirm, 0, NULL)) != 0)
614 		goto out;
615 	if ((r = ssh_request_reply_decode(sock, msg)) != 0)
616 		goto out;
617 	/* success */
618 	r = 0;
619  out:
620 	sshbuf_free(msg);
621 	return r;
622 }
623 
624 /*
625  * Removes all identities from the agent.
626  * This call is intended only for use by ssh-add(1) and like applications.
627  *
628  * This supports the SSH protocol 1 message to because, when clearing all
629  * keys from an agent, we generally want to clear both protocol v1 and v2
630  * keys.
631  */
632 int
ssh_remove_all_identities(int sock,int version)633 ssh_remove_all_identities(int sock, int version)
634 {
635 	struct sshbuf *msg;
636 	u_char type = (version == 1) ?
637 	    SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES :
638 	    SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
639 	int r;
640 
641 	if ((msg = sshbuf_new()) == NULL)
642 		return SSH_ERR_ALLOC_FAIL;
643 	if ((r = sshbuf_put_u8(msg, type)) != 0)
644 		goto out;
645 	if ((r = ssh_request_reply_decode(sock, msg)) != 0)
646 		goto out;
647 	/* success */
648 	r = 0;
649  out:
650 	sshbuf_free(msg);
651 	return r;
652 }
653