crypto/openssh/authfd.c

   1 /* $OpenBSD: authfd.c,v 1.130 2022/04/27 11:08:55 dtucker 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         debug3_f("path '%s'", authsocket);
  96         memset(&sunaddr, 0, sizeof(sunaddr));
  97         sunaddr.sun_family = AF_UNIX;
  98         strlcpy(sunaddr.sun_path, authsocket, sizeof(sunaddr.sun_path));
  99
 100         if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 101                 return SSH_ERR_SYSTEM_ERROR;
 102
 103         /* close on exec */
 104         if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1 ||
 105             connect(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
 106                 oerrno = errno;
 107                 close(sock);
 108                 errno = oerrno;
 109                 return SSH_ERR_SYSTEM_ERROR;
 110         }
 111         if (fdp != NULL)
 112                 *fdp = sock;
 113         else
 114                 close(sock);
 115         return 0;
 116 }
 117
 118 /*
 119  * Opens the default authentication socket and stores the file descriptor in
 120  * fdp. Returns 0 on success and an error on failure.
 121  */
 122 int
 123 ssh_get_authentication_socket(int *fdp)
 124 {
 125         const char *authsocket;
 126
 127         if (fdp != NULL)
 128                 *fdp = -1;
 129
 130         authsocket = getenv(SSH_AUTHSOCKET_ENV_NAME);
 131         if (authsocket == NULL || *authsocket == '\0')
 132                 return SSH_ERR_AGENT_NOT_PRESENT;
 133
 134         return ssh_get_authentication_socket_path(authsocket, fdp);
 135 }
 136
 137 /* Communicate with agent: send request and read reply */
 138 static int
 139 ssh_request_reply(int sock, struct sshbuf *request, struct sshbuf *reply)
 140 {
 141         int r;
 142         size_t l, len;
 143         char buf[1024];
 144
 145         /* Get the length of the message, and format it in the buffer. */
 146         len = sshbuf_len(request);
 147         POKE_U32(buf, len);
 148
 149         /* Send the length and then the packet to the agent. */
 150         if (atomicio(vwrite, sock, buf, 4) != 4 ||
 151             atomicio(vwrite, sock, sshbuf_mutable_ptr(request),
 152             sshbuf_len(request)) != sshbuf_len(request))
 153                 return SSH_ERR_AGENT_COMMUNICATION;
 154         /*
 155          * Wait for response from the agent.  First read the length of the
 156          * response packet.
 157          */
 158         if (atomicio(read, sock, buf, 4) != 4)
 159             return SSH_ERR_AGENT_COMMUNICATION;
 160
 161         /* Extract the length, and check it for sanity. */
 162         len = PEEK_U32(buf);
 163         if (len > MAX_AGENT_REPLY_LEN)
 164                 return SSH_ERR_INVALID_FORMAT;
 165
 166         /* Read the rest of the response in to the buffer. */
 167         sshbuf_reset(reply);
 168         while (len > 0) {
 169                 l = len;
 170                 if (l > sizeof(buf))
 171                         l = sizeof(buf);
 172                 if (atomicio(read, sock, buf, l) != l)
 173                         return SSH_ERR_AGENT_COMMUNICATION;
 174                 if ((r = sshbuf_put(reply, buf, l)) != 0)
 175                         return r;
 176                 len -= l;
 177         }
 178         return 0;
 179 }
 180
 181 /* Communicate with agent: sent request, read and decode status reply */
 182 static int
 183 ssh_request_reply_decode(int sock, struct sshbuf *request)
 184 {
 185         struct sshbuf *reply;
 186         int r;
 187         u_char type;
 188
 189         if ((reply = sshbuf_new()) == NULL)
 190                 return SSH_ERR_ALLOC_FAIL;
 191         if ((r = ssh_request_reply(sock, request, reply)) != 0 ||
 192             (r = sshbuf_get_u8(reply, &type)) != 0 ||
 193             (r = decode_reply(type)) != 0)
 194                 goto out;
 195         /* success */
 196         r = 0;
 197  out:
 198         sshbuf_free(reply);
 199         return r;
 200 }
 201
 202 /*
 203  * Closes the agent socket if it should be closed (depends on how it was
 204  * obtained).  The argument must have been returned by
 205  * ssh_get_authentication_socket().
 206  */
 207 void
 208 ssh_close_authentication_socket(int sock)
 209 {
 210         if (getenv(SSH_AUTHSOCKET_ENV_NAME))
 211                 close(sock);
 212 }
 213
 214 /* Lock/unlock agent */
 215 int
 216 ssh_lock_agent(int sock, int lock, const char *password)
 217 {
 218         int r;
 219         u_char type = lock ? SSH_AGENTC_LOCK : SSH_AGENTC_UNLOCK;
 220         struct sshbuf *msg;
 221
 222         if ((msg = sshbuf_new()) == NULL)
 223                 return SSH_ERR_ALLOC_FAIL;
 224         if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 225             (r = sshbuf_put_cstring(msg, password)) != 0 ||
 226             (r = ssh_request_reply_decode(sock, msg)) != 0)
 227                 goto out;
 228         /* success */
 229         r = 0;
 230  out:
 231         sshbuf_free(msg);
 232         return r;
 233 }
 234
 235
 236 static int
 237 deserialise_identity2(struct sshbuf *ids, struct sshkey **keyp, char **commentp)
 238 {
 239         int r;
 240         char *comment = NULL;
 241         const u_char *blob;
 242         size_t blen;
 243
 244         if ((r = sshbuf_get_string_direct(ids, &blob, &blen)) != 0 ||
 245             (r = sshbuf_get_cstring(ids, &comment, NULL)) != 0)
 246                 goto out;
 247         if ((r = sshkey_from_blob(blob, blen, keyp)) != 0)
 248                 goto out;
 249         if (commentp != NULL) {
 250                 *commentp = comment;
 251                 comment = NULL;
 252         }
 253         r = 0;
 254  out:
 255         free(comment);
 256         return r;
 257 }
 258
 259 /*
 260  * Fetch list of identities held by the agent.
 261  */
 262 int
 263 ssh_fetch_identitylist(int sock, struct ssh_identitylist **idlp)
 264 {
 265         u_char type;
 266         u_int32_t num, i;
 267         struct sshbuf *msg;
 268         struct ssh_identitylist *idl = NULL;
 269         int r;
 270
 271         /*
 272          * Send a message to the agent requesting for a list of the
 273          * identities it can represent.
 274          */
 275         if ((msg = sshbuf_new()) == NULL)
 276                 return SSH_ERR_ALLOC_FAIL;
 277         if ((r = sshbuf_put_u8(msg, SSH2_AGENTC_REQUEST_IDENTITIES)) != 0)
 278                 goto out;
 279
 280         if ((r = ssh_request_reply(sock, msg, msg)) != 0)
 281                 goto out;
 282
 283         /* Get message type, and verify that we got a proper answer. */
 284         if ((r = sshbuf_get_u8(msg, &type)) != 0)
 285                 goto out;
 286         if (agent_failed(type)) {
 287                 r = SSH_ERR_AGENT_FAILURE;
 288                 goto out;
 289         } else if (type != SSH2_AGENT_IDENTITIES_ANSWER) {
 290                 r = SSH_ERR_INVALID_FORMAT;
 291                 goto out;
 292         }
 293
 294         /* Get the number of entries in the response and check it for sanity. */
 295         if ((r = sshbuf_get_u32(msg, &num)) != 0)
 296                 goto out;
 297         if (num > MAX_AGENT_IDENTITIES) {
 298                 r = SSH_ERR_INVALID_FORMAT;
 299                 goto out;
 300         }
 301         if (num == 0) {
 302                 r = SSH_ERR_AGENT_NO_IDENTITIES;
 303                 goto out;
 304         }
 305
 306         /* Deserialise the response into a list of keys/comments */
 307         if ((idl = calloc(1, sizeof(*idl))) == NULL ||
 308             (idl->keys = calloc(num, sizeof(*idl->keys))) == NULL ||
 309             (idl->comments = calloc(num, sizeof(*idl->comments))) == NULL) {
 310                 r = SSH_ERR_ALLOC_FAIL;
 311                 goto out;
 312         }
 313         for (i = 0; i < num;) {
 314                 if ((r = deserialise_identity2(msg, &(idl->keys[i]),
 315                     &(idl->comments[i]))) != 0) {
 316                         if (r == SSH_ERR_KEY_TYPE_UNKNOWN) {
 317                                 /* Gracefully skip unknown key types */
 318                                 num--;
 319                                 continue;
 320                         } else
 321                                 goto out;
 322                 }
 323                 i++;
 324         }
 325         idl->nkeys = num;
 326         *idlp = idl;
 327         idl = NULL;
 328         r = 0;
 329  out:
 330         sshbuf_free(msg);
 331         if (idl != NULL)
 332                 ssh_free_identitylist(idl);
 333         return r;
 334 }
 335
 336 void
 337 ssh_free_identitylist(struct ssh_identitylist *idl)
 338 {
 339         size_t i;
 340
 341         if (idl == NULL)
 342                 return;
 343         for (i = 0; i < idl->nkeys; i++) {
 344                 if (idl->keys != NULL)
 345                         sshkey_free(idl->keys[i]);
 346                 if (idl->comments != NULL)
 347                         free(idl->comments[i]);
 348         }
 349         free(idl->keys);
 350         free(idl->comments);
 351         free(idl);
 352 }
 353
 354 /*
 355  * Check if the ssh agent has a given key.
 356  * Returns 0 if found, or a negative SSH_ERR_* error code on failure.
 357  */
 358 int
 359 ssh_agent_has_key(int sock, const struct sshkey *key)
 360 {
 361         int r, ret = SSH_ERR_KEY_NOT_FOUND;
 362         size_t i;
 363         struct ssh_identitylist *idlist = NULL;
 364
 365         if ((r = ssh_fetch_identitylist(sock, &idlist)) != 0) {
 366                 return r;
 367         }
 368
 369         for (i = 0; i < idlist->nkeys; i++) {
 370                 if (sshkey_equal_public(idlist->keys[i], key)) {
 371                         ret = 0;
 372                         break;
 373                 }
 374         }
 375
 376         ssh_free_identitylist(idlist);
 377         return ret;
 378 }
 379
 380 /*
 381  * Sends a challenge (typically from a server via ssh(1)) to the agent,
 382  * and waits for a response from the agent.
 383  * Returns true (non-zero) if the agent gave the correct answer, zero
 384  * otherwise.
 385  */
 386
 387
 388 /* encode signature algorithm in flag bits, so we can keep the msg format */
 389 static u_int
 390 agent_encode_alg(const struct sshkey *key, const char *alg)
 391 {
 392         if (alg != NULL && sshkey_type_plain(key->type) == KEY_RSA) {
 393                 if (strcmp(alg, "rsa-sha2-256") == 0 ||
 394                     strcmp(alg, "rsa-sha2-256-cert-v01@openssh.com") == 0)
 395                         return SSH_AGENT_RSA_SHA2_256;
 396                 if (strcmp(alg, "rsa-sha2-512") == 0 ||
 397                     strcmp(alg, "rsa-sha2-512-cert-v01@openssh.com") == 0)
 398                         return SSH_AGENT_RSA_SHA2_512;
 399         }
 400         return 0;
 401 }
 402
 403 /* ask agent to sign data, returns err.h code on error, 0 on success */
 404 int
 405 ssh_agent_sign(int sock, const struct sshkey *key,
 406     u_char **sigp, size_t *lenp,
 407     const u_char *data, size_t datalen, const char *alg, u_int compat)
 408 {
 409         struct sshbuf *msg;
 410         u_char *sig = NULL, type = 0;
 411         size_t len = 0;
 412         u_int flags = 0;
 413         int r = SSH_ERR_INTERNAL_ERROR;
 414
 415         *sigp = NULL;
 416         *lenp = 0;
 417
 418         if (datalen > SSH_KEY_MAX_SIGN_DATA_SIZE)
 419                 return SSH_ERR_INVALID_ARGUMENT;
 420         if ((msg = sshbuf_new()) == NULL)
 421                 return SSH_ERR_ALLOC_FAIL;
 422         flags |= agent_encode_alg(key, alg);
 423         if ((r = sshbuf_put_u8(msg, SSH2_AGENTC_SIGN_REQUEST)) != 0 ||
 424             (r = sshkey_puts(key, msg)) != 0 ||
 425             (r = sshbuf_put_string(msg, data, datalen)) != 0 ||
 426             (r = sshbuf_put_u32(msg, flags)) != 0)
 427                 goto out;
 428         if ((r = ssh_request_reply(sock, msg, msg)) != 0)
 429                 goto out;
 430         if ((r = sshbuf_get_u8(msg, &type)) != 0)
 431                 goto out;
 432         if (agent_failed(type)) {
 433                 r = SSH_ERR_AGENT_FAILURE;
 434                 goto out;
 435         } else if (type != SSH2_AGENT_SIGN_RESPONSE) {
 436                 r = SSH_ERR_INVALID_FORMAT;
 437                 goto out;
 438         }
 439         if ((r = sshbuf_get_string(msg, &sig, &len)) != 0)
 440                 goto out;
 441         /* Check what we actually got back from the agent. */
 442         if ((r = sshkey_check_sigtype(sig, len, alg)) != 0)
 443                 goto out;
 444         /* success */
 445         *sigp = sig;
 446         *lenp = len;
 447         sig = NULL;
 448         len = 0;
 449         r = 0;
 450  out:
 451         freezero(sig, len);
 452         sshbuf_free(msg);
 453         return r;
 454 }
 455
 456 /* Encode key for a message to the agent. */
 457
 458 static int
 459 encode_dest_constraint_hop(struct sshbuf *m,
 460     const struct dest_constraint_hop *dch)
 461 {
 462         struct sshbuf *b;
 463         u_int i;
 464         int r;
 465
 466         if ((b = sshbuf_new()) == NULL)
 467                 return SSH_ERR_ALLOC_FAIL;
 468         if ((r = sshbuf_put_cstring(b, dch->user)) != 0 ||
 469             (r = sshbuf_put_cstring(b, dch->hostname)) != 0 ||
 470             (r = sshbuf_put_string(b, NULL, 0)) != 0) /* reserved */
 471                 goto out;
 472         for (i = 0; i < dch->nkeys; i++) {
 473                 if ((r = sshkey_puts(dch->keys[i], b)) != 0 ||
 474                     (r = sshbuf_put_u8(b, dch->key_is_ca[i] != 0)) != 0)
 475                         goto out;
 476         }
 477         if ((r = sshbuf_put_stringb(m, b)) != 0)
 478                 goto out;
 479         /* success */
 480         r = 0;
 481  out:
 482         sshbuf_free(b);
 483         return r;
 484 }
 485
 486 static int
 487 encode_dest_constraint(struct sshbuf *m, const struct dest_constraint *dc)
 488 {
 489         struct sshbuf *b;
 490         int r;
 491
 492         if ((b = sshbuf_new()) == NULL)
 493                 return SSH_ERR_ALLOC_FAIL;
 494         if ((r = encode_dest_constraint_hop(b, &dc->from) != 0) ||
 495             (r = encode_dest_constraint_hop(b, &dc->to) != 0) ||
 496             (r = sshbuf_put_string(b, NULL, 0)) != 0) /* reserved */
 497                 goto out;
 498         if ((r = sshbuf_put_stringb(m, b)) != 0)
 499                 goto out;
 500         /* success */
 501         r = 0;
 502  out:
 503         sshbuf_free(b);
 504         return r;
 505 }
 506
 507 static int
 508 encode_constraints(struct sshbuf *m, u_int life, u_int confirm, u_int maxsign,
 509     const char *provider, struct dest_constraint **dest_constraints,
 510     size_t ndest_constraints)
 511 {
 512         int r;
 513         struct sshbuf *b = NULL;
 514         size_t i;
 515
 516         if (life != 0) {
 517                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_LIFETIME)) != 0 ||
 518                     (r = sshbuf_put_u32(m, life)) != 0)
 519                         goto out;
 520         }
 521         if (confirm != 0) {
 522                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_CONFIRM)) != 0)
 523                         goto out;
 524         }
 525         if (maxsign != 0) {
 526                 if ((r = sshbuf_put_u8(m, SSH_AGENT_CONSTRAIN_MAXSIGN)) != 0 ||
 527                     (r = sshbuf_put_u32(m, maxsign)) != 0)
 528                         goto out;
 529         }
 530         if (provider != NULL) {
 531                 if ((r = sshbuf_put_u8(m,
 532                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 533                     (r = sshbuf_put_cstring(m,
 534                     "sk-provider@openssh.com")) != 0 ||
 535                     (r = sshbuf_put_cstring(m, provider)) != 0)
 536                         goto out;
 537         }
 538         if (dest_constraints != NULL && ndest_constraints > 0) {
 539                 if ((b = sshbuf_new()) == NULL) {
 540                         r = SSH_ERR_ALLOC_FAIL;
 541                         goto out;
 542                 }
 543                 for (i = 0; i < ndest_constraints; i++) {
 544                         if ((r = encode_dest_constraint(b,
 545                             dest_constraints[i])) != 0)
 546                                 goto out;
 547                 }
 548                 if ((r = sshbuf_put_u8(m,
 549                     SSH_AGENT_CONSTRAIN_EXTENSION)) != 0 ||
 550                     (r = sshbuf_put_cstring(m,
 551                     "restrict-destination-v00@openssh.com")) != 0 ||
 552                     (r = sshbuf_put_stringb(m, b)) != 0)
 553                         goto out;
 554         }
 555         r = 0;
 556  out:
 557         sshbuf_free(b);
 558         return r;
 559 }
 560
 561 /*
 562  * Adds an identity to the authentication server.
 563  * This call is intended only for use by ssh-add(1) and like applications.
 564  */
 565 int
 566 ssh_add_identity_constrained(int sock, struct sshkey *key,
 567     const char *comment, u_int life, u_int confirm, u_int maxsign,
 568     const char *provider, struct dest_constraint **dest_constraints,
 569     size_t ndest_constraints)
 570 {
 571         struct sshbuf *msg;
 572         int r, constrained = (life || confirm || maxsign ||
 573             provider || dest_constraints);
 574         u_char type;
 575
 576         if ((msg = sshbuf_new()) == NULL)
 577                 return SSH_ERR_ALLOC_FAIL;
 578
 579         switch (key->type) {
 580 #ifdef WITH_OPENSSL
 581         case KEY_RSA:
 582         case KEY_RSA_CERT:
 583         case KEY_DSA:
 584         case KEY_DSA_CERT:
 585         case KEY_ECDSA:
 586         case KEY_ECDSA_CERT:
 587         case KEY_ECDSA_SK:
 588         case KEY_ECDSA_SK_CERT:
 589 #endif
 590         case KEY_ED25519:
 591         case KEY_ED25519_CERT:
 592         case KEY_ED25519_SK:
 593         case KEY_ED25519_SK_CERT:
 594         case KEY_XMSS:
 595         case KEY_XMSS_CERT:
 596                 type = constrained ?
 597                     SSH2_AGENTC_ADD_ID_CONSTRAINED :
 598                     SSH2_AGENTC_ADD_IDENTITY;
 599                 if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 600                     (r = sshkey_private_serialize_maxsign(key, msg, maxsign,
 601                     0)) != 0 ||
 602                     (r = sshbuf_put_cstring(msg, comment)) != 0)
 603                         goto out;
 604                 break;
 605         default:
 606                 r = SSH_ERR_INVALID_ARGUMENT;
 607                 goto out;
 608         }
 609         if (constrained &&
 610             (r = encode_constraints(msg, life, confirm, maxsign,
 611             provider, dest_constraints, ndest_constraints)) != 0)
 612                 goto out;
 613         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 614                 goto out;
 615         /* success */
 616         r = 0;
 617  out:
 618         sshbuf_free(msg);
 619         return r;
 620 }
 621
 622 /*
 623  * Removes an identity from the authentication server.
 624  * This call is intended only for use by ssh-add(1) and like applications.
 625  */
 626 int
 627 ssh_remove_identity(int sock, const struct sshkey *key)
 628 {
 629         struct sshbuf *msg;
 630         int r;
 631         u_char *blob = NULL;
 632         size_t blen;
 633
 634         if ((msg = sshbuf_new()) == NULL)
 635                 return SSH_ERR_ALLOC_FAIL;
 636
 637         if (key->type != KEY_UNSPEC) {
 638                 if ((r = sshkey_to_blob(key, &blob, &blen)) != 0)
 639                         goto out;
 640                 if ((r = sshbuf_put_u8(msg,
 641                     SSH2_AGENTC_REMOVE_IDENTITY)) != 0 ||
 642                     (r = sshbuf_put_string(msg, blob, blen)) != 0)
 643                         goto out;
 644         } else {
 645                 r = SSH_ERR_INVALID_ARGUMENT;
 646                 goto out;
 647         }
 648         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 649                 goto out;
 650         /* success */
 651         r = 0;
 652  out:
 653         if (blob != NULL)
 654                 freezero(blob, blen);
 655         sshbuf_free(msg);
 656         return r;
 657 }
 658
 659 /*
 660  * Add/remove an token-based identity from the authentication server.
 661  * This call is intended only for use by ssh-add(1) and like applications.
 662  */
 663 int
 664 ssh_update_card(int sock, int add, const char *reader_id, const char *pin,
 665     u_int life, u_int confirm,
 666     struct dest_constraint **dest_constraints, size_t ndest_constraints)
 667 {
 668         struct sshbuf *msg;
 669         int r, constrained = (life || confirm);
 670         u_char type;
 671
 672         if (add) {
 673                 type = constrained ?
 674                     SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED :
 675                     SSH_AGENTC_ADD_SMARTCARD_KEY;
 676         } else
 677                 type = SSH_AGENTC_REMOVE_SMARTCARD_KEY;
 678
 679         if ((msg = sshbuf_new()) == NULL)
 680                 return SSH_ERR_ALLOC_FAIL;
 681         if ((r = sshbuf_put_u8(msg, type)) != 0 ||
 682             (r = sshbuf_put_cstring(msg, reader_id)) != 0 ||
 683             (r = sshbuf_put_cstring(msg, pin)) != 0)
 684                 goto out;
 685         if (constrained &&
 686             (r = encode_constraints(msg, life, confirm, 0, NULL,
 687             dest_constraints, ndest_constraints)) != 0)
 688                 goto out;
 689         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 690                 goto out;
 691         /* success */
 692         r = 0;
 693  out:
 694         sshbuf_free(msg);
 695         return r;
 696 }
 697
 698 /*
 699  * Removes all identities from the agent.
 700  * This call is intended only for use by ssh-add(1) and like applications.
 701  *
 702  * This supports the SSH protocol 1 message to because, when clearing all
 703  * keys from an agent, we generally want to clear both protocol v1 and v2
 704  * keys.
 705  */
 706 int
 707 ssh_remove_all_identities(int sock, int version)
 708 {
 709         struct sshbuf *msg;
 710         u_char type = (version == 1) ?
 711             SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES :
 712             SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
 713         int r;
 714
 715         if ((msg = sshbuf_new()) == NULL)
 716                 return SSH_ERR_ALLOC_FAIL;
 717         if ((r = sshbuf_put_u8(msg, type)) != 0)
 718                 goto out;
 719         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 720                 goto out;
 721         /* success */
 722         r = 0;
 723  out:
 724         sshbuf_free(msg);
 725         return r;
 726 }
 727
 728 /* Binds a session ID to a hostkey via the initial KEX signature. */
 729 int
 730 ssh_agent_bind_hostkey(int sock, const struct sshkey *key,
 731     const struct sshbuf *session_id, const struct sshbuf *signature,
 732     int forwarding)
 733 {
 734         struct sshbuf *msg;
 735         int r;
 736
 737         if (key == NULL || session_id == NULL || signature == NULL)
 738                 return SSH_ERR_INVALID_ARGUMENT;
 739         if ((msg = sshbuf_new()) == NULL)
 740                 return SSH_ERR_ALLOC_FAIL;
 741         if ((r = sshbuf_put_u8(msg, SSH_AGENTC_EXTENSION)) != 0 ||
 742             (r = sshbuf_put_cstring(msg, "session-bind@openssh.com")) != 0 ||
 743             (r = sshkey_puts(key, msg)) != 0 ||
 744             (r = sshbuf_put_stringb(msg, session_id)) != 0 ||
 745             (r = sshbuf_put_stringb(msg, signature)) != 0 ||
 746             (r = sshbuf_put_u8(msg, forwarding ? 1 : 0)) != 0)
 747                 goto out;
 748         if ((r = ssh_request_reply_decode(sock, msg)) != 0)
 749                 goto out;
 750         /* success */
 751         r = 0;
 752  out:
 753         sshbuf_free(msg);
 754         return r;
 755 }