authfd.c

   1 /* $OpenBSD: authfd.c,v 1.134 2023/12/18 14:46:56 djm Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * Functions for connecting the local authentication agent.
   7  *
   8  * As far as I am concerned, the code I have written for this software
   9  * can be used freely for any purpose.  Any derived versions of this
  10  * software must be clearly marked as such, and if the derived work is
  11  * incompatible with the protocol description in the RFC file, it must be
  12  * called by a name other than "ssh" or "Secure Shell".
  13  *
  14  * SSH2 implementation,
  15  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
  16  *
  17  * Redistribution and use in source and binary forms, with or without
  18  * modification, are permitted provided that the following conditions
  19  * are met:
  20  * 1. Redistributions of source code must retain the above copyright
  21  *    notice, this list of conditions and the following disclaimer.
  22  * 2. Redistributions in binary form must reproduce the above copyright
  23  *    notice, this list of conditions and the following disclaimer in the
  24  *    documentation and/or other materials provided with the distribution.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  29  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  30  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  31  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  35  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 #include "includes.h"
  39
  40 #include <sys/types.h>
  41 #include <sys/un.h>
  42 #include <sys/socket.h>
  43
  44 #include <fcntl.h>
  45 #include <stdlib.h>
  46 #include <signal.h>
  47 #include <string.h>
  48 #include <stdarg.h>
  49 #include <unistd.h>
  50 #include <errno.h>
  51
  52 #include "xmalloc.h"
  53 #include "ssh.h"
  54 #include "sshbuf.h"
  55 #include "sshkey.h"
  56 #include "authfd.h"
  57 #include "cipher.h"
  58 #include "log.h"
  59 #include "atomicio.h"
  60 #include "misc.h"
  61 #include "ssherr.h"
  62
  63 #define MAX_AGENT_IDENTITIES    2048            /* Max keys in agent reply */
  64 #define MAX_AGENT_REPLY_LEN     (256 * 1024)    /* Max bytes in agent reply */
  65
  66 /* macro to check for "agent failure" message */
  67 #define agent_failed(x) \
  68     ((x == SSH_AGENT_FAILURE) || \
  69     (x == SSH_COM_AGENT2_FAILURE) || \
  70     (x == SSH2_AGENT_FAILURE))
  71
  72 /* Convert success/failure response from agent to a err.h status */
  73 static int
  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,
 508     u_int maxsign, const char *provider,
 509     struct dest_constraint **dest_constraints, size_t ndest_constraints,
 510     int cert_only, struct sshkey **certs, size_t ncerts)
 511 {
 512         int r;
 513         struct sshbuf *b = NULL;
 514         size_t i;
 515
 516         if (life != 0) {
 517                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_LIFETIME)) != 0 ||
 518                     (r = sshbuf_put_u32(m, life)) != 0)
 519                         goto out;
 520         }
 521         if (confirm != 0) {
 522                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_CONFIRM)) != 0)
 523                         goto out;
 524         }
 525         if (maxsign != 0) {
 526                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_MAXSIGN)) != 0 ||
 527                     (r = sshbuf_put_u32(m, maxsign)) != 0)
 528                         goto out;
 529         }
 530         if (provider != NULL) {
 531                 if ((r = sshbuf_put_u8(m,
 532                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 533                     (r = sshbuf_put_cstring(m,
 534                     "sk-provider@openssh.com")) != 0 ||
 535                     (r = sshbuf_put_cstring(m, provider)) != 0)
 536                         goto out;
 537         }
 538         if (dest_constraints != NULL && ndest_constraints > 0) {
 539                 if ((b = sshbuf_new()) == NULL) {
 540                         r = SSH_ERR_ALLOC_FAIL;
 541                         goto out;
 542                 }
 543                 for (i = 0; i < ndest_constraints; i++) {
 544                         if ((r = encode_dest_constraint(b,
 545                             dest_constraints[i])) != 0)
 546                                 goto out;
 547                 }
 548                 if ((r = sshbuf_put_u8(m,
 549                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 550                     (r = sshbuf_put_cstring(m,
 551                     "restrict-destination-v00@openssh.com")) != 0 ||
 552                     (r = sshbuf_put_stringb(m, b)) != 0)
 553                         goto out;
 554                 sshbuf_free(b);
 555                 b = NULL;
 556         }
 557         if (ncerts != 0) {
 558                 if ((b = sshbuf_new()) == NULL) {
 559                         r = SSH_ERR_ALLOC_FAIL;
 560                         goto out;
 561                 }
 562                 for (i = 0; i < ncerts; i++) {
 563                         if ((r = sshkey_puts(certs[i], b)) != 0)
 564                                 goto out;
 565                 }
 566                 if ((r = sshbuf_put_u8(m,
 567                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 568                     (r = sshbuf_put_cstring(m,
 569                     "associated-certs-v00@openssh.com")) != 0 ||
 570                     (r = sshbuf_put_u8(m, cert_only != 0)) != 0 ||
 571                     (r = sshbuf_put_stringb(m, b)) != 0)
 572                         goto out;
 573                 sshbuf_free(b);
 574                 b = NULL;
 575         }
 576         r = 0;
 577  out:
 578         sshbuf_free(b);
 579         return r;
 580 }
 581
 582 /*
 583  * Adds an identity to the authentication server.
 584  * This call is intended only for use by ssh-add(1) and like applications.
 585  */
 586 int
 587 ssh_add_identity_constrained(int sock, struct sshkey *key,
 588     const char *comment, u_int life, u_int confirm, u_int maxsign,
 589     const char *provider, struct dest_constraint **dest_constraints,
 590     size_t ndest_constraints)
 591 {
 592         struct sshbuf *msg;
 593         int r, constrained = (life || confirm || maxsign ||
 594             provider || dest_constraints);
 595         u_char type;
 596
 597         if ((msg = sshbuf_new()) == NULL)
 598                 return SSH_ERR_ALLOC_FAIL;
 599
 600         switch (key->type) {
 601 #ifdef WITH_OPENSSL
 602         case KEY_RSA:
 603         case KEY_RSA_CERT:
 604         case KEY_DSA:
 605         case KEY_DSA_CERT:
 606         case KEY_ECDSA:
 607         case KEY_ECDSA_CERT:
 608         case KEY_ECDSA_SK:
 609         case KEY_ECDSA_SK_CERT:
 610 #endif
 611         case KEY_ED25519:
 612         case KEY_ED25519_CERT:
 613         case KEY_ED25519_SK:
 614         case KEY_ED25519_SK_CERT:
 615         case KEY_XMSS:
 616         case KEY_XMSS_CERT:
 617                 type = constrained ?
 618                     SSH2_AGENTC_ADD_ID_CONSTRAINED :
 619                     SSH2_AGENTC_ADD_IDENTITY;
 620                 if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 621                     (r = sshkey_private_serialize_maxsign(key, msg, maxsign,
 622                     0)) != 0 ||
 623                     (r = sshbuf_put_cstring(msg, comment)) != 0)
 624                         goto out;
 625                 break;
 626         default:
 627                 r = SSH_ERR_INVALID_ARGUMENT;
 628                 goto out;
 629         }
 630         if (constrained &&
 631             (r = encode_constraints(msg, life, confirm, maxsign,
 632             provider, dest_constraints, ndest_constraints, 0, NULL, 0)) != 0)
 633                 goto out;
 634         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 635                 goto out;
 636         /* success */
 637         r = 0;
 638  out:
 639         sshbuf_free(msg);
 640         return r;
 641 }
 642
 643 /*
 644  * Removes an identity from the authentication server.
 645  * This call is intended only for use by ssh-add(1) and like applications.
 646  */
 647 int
 648 ssh_remove_identity(int sock, const struct sshkey *key)
 649 {
 650         struct sshbuf *msg;
 651         int r;
 652         u_char *blob = NULL;
 653         size_t blen;
 654
 655         if ((msg = sshbuf_new()) == NULL)
 656                 return SSH_ERR_ALLOC_FAIL;
 657
 658         if (key->type != KEY_UNSPEC) {
 659                 if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)
 660                         goto out;
 661                 if ((r = sshbuf_put_u8(msg,
 662                     SSH2_AGENTC_REMOVE_IDENTITY)) != 0 ||
 663                     (r = sshbuf_put_string(msg, blob, blen)) != 0)
 664                         goto out;
 665         } else {
 666                 r = SSH_ERR_INVALID_ARGUMENT;
 667                 goto out;
 668         }
 669         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 670                 goto out;
 671         /* success */
 672         r = 0;
 673  out:
 674         if (blob != NULL)
 675                 freezero(blob, blen);
 676         sshbuf_free(msg);
 677         return r;
 678 }
 679
 680 /*
 681  * Add/remove an token-based identity from the authentication server.
 682  * This call is intended only for use by ssh-add(1) and like applications.
 683  */
 684 int
 685 ssh_update_card(int sock, int add, const char *reader_id, const char *pin,
 686     u_int life, u_int confirm,
 687     struct dest_constraint **dest_constraints, size_t ndest_constraints,
 688     int cert_only, struct sshkey **certs, size_t ncerts)
 689 {
 690         struct sshbuf *msg;
 691         int r, constrained = (life || confirm || dest_constraints || certs);
 692         u_char type;
 693
 694         if (add) {
 695                 type = constrained ?
 696                     SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED :
 697                     SSH_AGENTC_ADD_SMARTCARD_KEY;
 698         } else
 699                 type = SSH_AGENTC_REMOVE_SMARTCARD_KEY;
 700
 701         if ((msg = sshbuf_new()) == NULL)
 702                 return SSH_ERR_ALLOC_FAIL;
 703         if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 704             (r = sshbuf_put_cstring(msg, reader_id)) != 0 ||
 705             (r = sshbuf_put_cstring(msg, pin)) != 0)
 706                 goto out;
 707         if (constrained &&
 708             (r = encode_constraints(msg, life, confirm, 0, NULL,
 709             dest_constraints, ndest_constraints,
 710             cert_only, certs, ncerts)) != 0)
 711                 goto out;
 712         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 713                 goto out;
 714         /* success */
 715         r = 0;
 716  out:
 717         sshbuf_free(msg);
 718         return r;
 719 }
 720
 721 /*
 722  * Removes all identities from the agent.
 723  * This call is intended only for use by ssh-add(1) and like applications.
 724  *
 725  * This supports the SSH protocol 1 message to because, when clearing all
 726  * keys from an agent, we generally want to clear both protocol v1 and v2
 727  * keys.
 728  */
 729 int
 730 ssh_remove_all_identities(int sock, int version)
 731 {
 732         struct sshbuf *msg;
 733         u_char type = (version == 1) ?
 734             SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES :
 735             SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
 736         int r;
 737
 738         if ((msg = sshbuf_new()) == NULL)
 739                 return SSH_ERR_ALLOC_FAIL;
 740         if ((r = sshbuf_put_u8(msg, type)) != 0)
 741                 goto out;
 742         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 743                 goto out;
 744         /* success */
 745         r = 0;
 746  out:
 747         sshbuf_free(msg);
 748         return r;
 749 }
 750
 751 /* Binds a session ID to a hostkey via the initial KEX signature. */
 752 int
 753 ssh_agent_bind_hostkey(int sock, const struct sshkey *key,
 754     const struct sshbuf *session_id, const struct sshbuf *signature,
 755     int forwarding)
 756 {
 757         struct sshbuf *msg;
 758         int r;
 759
 760         if (key == NULL || session_id == NULL || signature == NULL)
 761                 return SSH_ERR_INVALID_ARGUMENT;
 762         if ((msg = sshbuf_new()) == NULL)
 763                 return SSH_ERR_ALLOC_FAIL;
 764         if ((r = sshbuf_put_u8(msg, SSH_AGENTC_EXTENSION)) != 0 ||
 765             (r = sshbuf_put_cstring(msg, "session-bind@openssh.com")) != 0 ||
 766             (r = sshkey_puts(key, msg)) != 0 ||
 767             (r = sshbuf_put_stringb(msg, session_id)) != 0 ||
 768             (r = sshbuf_put_stringb(msg, signature)) != 0 ||
 769             (r = sshbuf_put_u8(msg, forwarding ? 1 : 0)) != 0)
 770                 goto out;
 771         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 772                 goto out;
 773         /* success */
 774         r = 0;
 775  out:
 776         sshbuf_free(msg);
 777         return r;
 778 }