crypto/openssh/authfd.c

   1 /* $OpenBSD: authfd.c,v 1.133 2023/03/09 21:06:24 jcs 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
  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
  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
 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 static int
 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
 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
 507 encode_constraints(struct sshbuf *m, u_int life, u_int confirm, u_int maxsign,
 508     const char *provider, struct dest_constraint **dest_constraints,
 509     size_t ndest_constraints)
 510 {
 511         int r;
 512         struct sshbuf *b = NULL;
 513         size_t i;
 514
 515         if (life != 0) {
 516                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_LIFETIME)) != 0 ||
 517                     (r = sshbuf_put_u32(m, life)) != 0)
 518                         goto out;
 519         }
 520         if (confirm != 0) {
 521                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_CONFIRM)) != 0)
 522                         goto out;
 523         }
 524         if (maxsign != 0) {
 525                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_MAXSIGN)) != 0 ||
 526                     (r = sshbuf_put_u32(m, maxsign)) != 0)
 527                         goto out;
 528         }
 529         if (provider != NULL) {
 530                 if ((r = sshbuf_put_u8(m,
 531                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 532                     (r = sshbuf_put_cstring(m,
 533                     "sk-provider@openssh.com")) != 0 ||
 534                     (r = sshbuf_put_cstring(m, provider)) != 0)
 535                         goto out;
 536         }
 537         if (dest_constraints != NULL && ndest_constraints > 0) {
 538                 if ((b = sshbuf_new()) == NULL) {
 539                         r = SSH_ERR_ALLOC_FAIL;
 540                         goto out;
 541                 }
 542                 for (i = 0; i < ndest_constraints; i++) {
 543                         if ((r = encode_dest_constraint(b,
 544                             dest_constraints[i])) != 0)
 545                                 goto out;
 546                 }
 547                 if ((r = sshbuf_put_u8(m,
 548                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 549                     (r = sshbuf_put_cstring(m,
 550                     "restrict-destination-v00@openssh.com")) != 0 ||
 551                     (r = sshbuf_put_stringb(m, b)) != 0)
 552                         goto out;
 553         }
 554         r = 0;
 555  out:
 556         sshbuf_free(b);
 557         return r;
 558 }
 559
 560 /*
 561  * Adds an identity to the authentication server.
 562  * This call is intended only for use by ssh-add(1) and like applications.
 563  */
 564 int
 565 ssh_add_identity_constrained(int sock, struct sshkey *key,
 566     const char *comment, u_int life, u_int confirm, u_int maxsign,
 567     const char *provider, struct dest_constraint **dest_constraints,
 568     size_t ndest_constraints)
 569 {
 570         struct sshbuf *msg;
 571         int r, constrained = (life || confirm || maxsign ||
 572             provider || dest_constraints);
 573         u_char type;
 574
 575         if ((msg = sshbuf_new()) == NULL)
 576                 return SSH_ERR_ALLOC_FAIL;
 577
 578         switch (key->type) {
 579 #ifdef WITH_OPENSSL
 580         case KEY_RSA:
 581         case KEY_RSA_CERT:
 582         case KEY_DSA:
 583         case KEY_DSA_CERT:
 584         case KEY_ECDSA:
 585         case KEY_ECDSA_CERT:
 586         case KEY_ECDSA_SK:
 587         case KEY_ECDSA_SK_CERT:
 588 #endif
 589         case KEY_ED25519:
 590         case KEY_ED25519_CERT:
 591         case KEY_ED25519_SK:
 592         case KEY_ED25519_SK_CERT:
 593         case KEY_XMSS:
 594         case KEY_XMSS_CERT:
 595                 type = constrained ?
 596                     SSH2_AGENTC_ADD_ID_CONSTRAINED :
 597                     SSH2_AGENTC_ADD_IDENTITY;
 598                 if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 599                     (r = sshkey_private_serialize_maxsign(key, msg, maxsign,
 600                     0)) != 0 ||
 601                     (r = sshbuf_put_cstring(msg, comment)) != 0)
 602                         goto out;
 603                 break;
 604         default:
 605                 r = SSH_ERR_INVALID_ARGUMENT;
 606                 goto out;
 607         }
 608         if (constrained &&
 609             (r = encode_constraints(msg, life, confirm, maxsign,
 610             provider, dest_constraints, ndest_constraints)) != 0)
 611                 goto out;
 612         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 613                 goto out;
 614         /* success */
 615         r = 0;
 616  out:
 617         sshbuf_free(msg);
 618         return r;
 619 }
 620
 621 /*
 622  * Removes an identity from the authentication server.
 623  * This call is intended only for use by ssh-add(1) and like applications.
 624  */
 625 int
 626 ssh_remove_identity(int sock, const struct sshkey *key)
 627 {
 628         struct sshbuf *msg;
 629         int r;
 630         u_char *blob = NULL;
 631         size_t blen;
 632
 633         if ((msg = sshbuf_new()) == NULL)
 634                 return SSH_ERR_ALLOC_FAIL;
 635
 636         if (key->type != KEY_UNSPEC) {
 637                 if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)
 638                         goto out;
 639                 if ((r = sshbuf_put_u8(msg,
 640                     SSH2_AGENTC_REMOVE_IDENTITY)) != 0 ||
 641                     (r = sshbuf_put_string(msg, blob, blen)) != 0)
 642                         goto out;
 643         } else {
 644                 r = SSH_ERR_INVALID_ARGUMENT;
 645                 goto out;
 646         }
 647         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 648                 goto out;
 649         /* success */
 650         r = 0;
 651  out:
 652         if (blob != NULL)
 653                 freezero(blob, blen);
 654         sshbuf_free(msg);
 655         return r;
 656 }
 657
 658 /*
 659  * Add/remove an token-based identity from the authentication server.
 660  * This call is intended only for use by ssh-add(1) and like applications.
 661  */
 662 int
 663 ssh_update_card(int sock, int add, const char *reader_id, const char *pin,
 664     u_int life, u_int confirm,
 665     struct dest_constraint **dest_constraints, size_t ndest_constraints)
 666 {
 667         struct sshbuf *msg;
 668         int r, constrained = (life || confirm || dest_constraints);
 669         u_char type;
 670
 671         if (add) {
 672                 type = constrained ?
 673                     SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED :
 674                     SSH_AGENTC_ADD_SMARTCARD_KEY;
 675         } else
 676                 type = SSH_AGENTC_REMOVE_SMARTCARD_KEY;
 677
 678         if ((msg = sshbuf_new()) == NULL)
 679                 return SSH_ERR_ALLOC_FAIL;
 680         if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 681             (r = sshbuf_put_cstring(msg, reader_id)) != 0 ||
 682             (r = sshbuf_put_cstring(msg, pin)) != 0)
 683                 goto out;
 684         if (constrained &&
 685             (r = encode_constraints(msg, life, confirm, 0, NULL,
 686             dest_constraints, ndest_constraints)) != 0)
 687                 goto out;
 688         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 689                 goto out;
 690         /* success */
 691         r = 0;
 692  out:
 693         sshbuf_free(msg);
 694         return r;
 695 }
 696
 697 /*
 698  * Removes all identities from the agent.
 699  * This call is intended only for use by ssh-add(1) and like applications.
 700  *
 701  * This supports the SSH protocol 1 message to because, when clearing all
 702  * keys from an agent, we generally want to clear both protocol v1 and v2
 703  * keys.
 704  */
 705 int
 706 ssh_remove_all_identities(int sock, int version)
 707 {
 708         struct sshbuf *msg;
 709         u_char type = (version == 1) ?
 710             SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES :
 711             SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
 712         int r;
 713
 714         if ((msg = sshbuf_new()) == NULL)
 715                 return SSH_ERR_ALLOC_FAIL;
 716         if ((r = sshbuf_put_u8(msg, type)) != 0)
 717                 goto out;
 718         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 719                 goto out;
 720         /* success */
 721         r = 0;
 722  out:
 723         sshbuf_free(msg);
 724         return r;
 725 }
 726
 727 /* Binds a session ID to a hostkey via the initial KEX signature. */
 728 int
 729 ssh_agent_bind_hostkey(int sock, const struct sshkey *key,
 730     const struct sshbuf *session_id, const struct sshbuf *signature,
 731     int forwarding)
 732 {
 733         struct sshbuf *msg;
 734         int r;
 735
 736         if (key == NULL || session_id == NULL || signature == NULL)
 737                 return SSH_ERR_INVALID_ARGUMENT;
 738         if ((msg = sshbuf_new()) == NULL)
 739                 return SSH_ERR_ALLOC_FAIL;
 740         if ((r = sshbuf_put_u8(msg, SSH_AGENTC_EXTENSION)) != 0 ||
 741             (r = sshbuf_put_cstring(msg, "session-bind@openssh.com")) != 0 ||
 742             (r = sshkey_puts(key, msg)) != 0 ||
 743             (r = sshbuf_put_stringb(msg, session_id)) != 0 ||
 744             (r = sshbuf_put_stringb(msg, signature)) != 0 ||
 745             (r = sshbuf_put_u8(msg, forwarding ? 1 : 0)) != 0)
 746                 goto out;
 747         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 748                 goto out;
 749         /* success */
 750         r = 0;
 751  out:
 752         sshbuf_free(msg);
 753         return r;
 754 }