crypto/openssh/authfd.c

   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
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 }