sshconnect2.c

   1 /*
   2  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "includes.h"
  26 RCSID("$OpenBSD: sshconnect2.c,v 1.108 2002/11/21 22:45:31 markus Exp $");
  27
  28 #include "ssh.h"
  29 #include "ssh2.h"
  30 #include "xmalloc.h"
  31 #include "buffer.h"
  32 #include "packet.h"
  33 #include "compat.h"
  34 #include "bufaux.h"
  35 #include "cipher.h"
  36 #include "kex.h"
  37 #include "myproposal.h"
  38 #include "sshconnect.h"
  39 #include "authfile.h"
  40 #include "dh.h"
  41 #include "authfd.h"
  42 #include "log.h"
  43 #include "readconf.h"
  44 #include "readpass.h"
  45 #include "match.h"
  46 #include "dispatch.h"
  47 #include "canohost.h"
  48 #include "msg.h"
  49 #include "pathnames.h"
  50
  51 /* import */
  52 extern char *client_version_string;
  53 extern char *server_version_string;
  54 extern Options options;
  55
  56 /*
  57  * SSH2 key exchange
  58  */
  59
  60 u_char *session_id2 = NULL;
  61 int session_id2_len = 0;
  62
  63 char *xxx_host;
  64 struct sockaddr *xxx_hostaddr;
  65
  66 Kex *xxx_kex = NULL;
  67
  68 static int
  69 verify_host_key_callback(Key *hostkey)
  70 {
  71         if (verify_host_key(xxx_host, xxx_hostaddr, hostkey) == -1)
  72                 fatal("Host key verification failed.");
  73         return 0;
  74 }
  75
  76 void
  77 ssh_kex2(char *host, struct sockaddr *hostaddr)
  78 {
  79         Kex *kex;
  80
  81         xxx_host = host;
  82         xxx_hostaddr = hostaddr;
  83
  84         if (options.ciphers == (char *)-1) {
  85                 log("No valid ciphers for protocol version 2 given, using defaults.");
  86                 options.ciphers = NULL;
  87         }
  88         if (options.ciphers != NULL) {
  89                 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
  90                 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
  91         }
  92         myproposal[PROPOSAL_ENC_ALGS_CTOS] =
  93             compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_CTOS]);
  94         myproposal[PROPOSAL_ENC_ALGS_STOC] =
  95             compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_STOC]);
  96         if (options.compression) {
  97                 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
  98                 myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib,none";
  99         } else {
 100                 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
 101                 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none,zlib";
 102         }
 103         if (options.macs != NULL) {
 104                 myproposal[PROPOSAL_MAC_ALGS_CTOS] =
 105                 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
 106         }
 107         if (options.hostkeyalgorithms != NULL)
 108                 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
 109                     options.hostkeyalgorithms;
 110
 111         /* start key exchange */
 112         kex = kex_setup(myproposal);
 113         kex->client_version_string=client_version_string;
 114         kex->server_version_string=server_version_string;
 115         kex->verify_host_key=&verify_host_key_callback;
 116
 117         xxx_kex = kex;
 118
 119         dispatch_run(DISPATCH_BLOCK, &kex->done, kex);
 120
 121         session_id2 = kex->session_id;
 122         session_id2_len = kex->session_id_len;
 123
 124 #ifdef DEBUG_KEXDH
 125         /* send 1st encrypted/maced/compressed message */
 126         packet_start(SSH2_MSG_IGNORE);
 127         packet_put_cstring("markus");
 128         packet_send();
 129         packet_write_wait();
 130 #endif
 131 }
 132
 133 /*
 134  * Authenticate user
 135  */
 136
 137 typedef struct Authctxt Authctxt;
 138 typedef struct Authmethod Authmethod;
 139
 140 typedef int sign_cb_fn(
 141     Authctxt *authctxt, Key *key,
 142     u_char **sigp, u_int *lenp, u_char *data, u_int datalen);
 143
 144 struct Authctxt {
 145         const char *server_user;
 146         const char *local_user;
 147         const char *host;
 148         const char *service;
 149         Authmethod *method;
 150         int success;
 151         char *authlist;
 152         /* pubkey */
 153         Key *last_key;
 154         sign_cb_fn *last_key_sign;
 155         int last_key_hint;
 156         AuthenticationConnection *agent;
 157         /* hostbased */
 158         Sensitive *sensitive;
 159         /* kbd-interactive */
 160         int info_req_seen;
 161 };
 162 struct Authmethod {
 163         char    *name;          /* string to compare against server's list */
 164         int     (*userauth)(Authctxt *authctxt);
 165         int     *enabled;       /* flag in option struct that enables method */
 166         int     *batch_flag;    /* flag in option struct that disables method */
 167 };
 168
 169 void    input_userauth_success(int, u_int32_t, void *);
 170 void    input_userauth_failure(int, u_int32_t, void *);
 171 void    input_userauth_banner(int, u_int32_t, void *);
 172 void    input_userauth_error(int, u_int32_t, void *);
 173 void    input_userauth_info_req(int, u_int32_t, void *);
 174 void    input_userauth_pk_ok(int, u_int32_t, void *);
 175 void    input_userauth_passwd_changereq(int, u_int32_t, void *);
 176
 177 int     userauth_none(Authctxt *);
 178 int     userauth_pubkey(Authctxt *);
 179 int     userauth_passwd(Authctxt *);
 180 int     userauth_kbdint(Authctxt *);
 181 int     userauth_hostbased(Authctxt *);
 182
 183 void    userauth(Authctxt *, char *);
 184
 185 static int sign_and_send_pubkey(Authctxt *, Key *, sign_cb_fn *);
 186 static void clear_auth_state(Authctxt *);
 187
 188 static Authmethod *authmethod_get(char *authlist);
 189 static Authmethod *authmethod_lookup(const char *name);
 190 static char *authmethods_get(void);
 191
 192 Authmethod authmethods[] = {
 193         {"hostbased",
 194                 userauth_hostbased,
 195                 &options.hostbased_authentication,
 196                 NULL},
 197         {"publickey",
 198                 userauth_pubkey,
 199                 &options.pubkey_authentication,
 200                 NULL},
 201         {"keyboard-interactive",
 202                 userauth_kbdint,
 203                 &options.kbd_interactive_authentication,
 204                 &options.batch_mode},
 205         {"password",
 206                 userauth_passwd,
 207                 &options.password_authentication,
 208                 &options.batch_mode},
 209         {"none",
 210                 userauth_none,
 211                 NULL,
 212                 NULL},
 213         {NULL, NULL, NULL, NULL}
 214 };
 215
 216 void
 217 ssh_userauth2(const char *local_user, const char *server_user, char *host,
 218     Sensitive *sensitive)
 219 {
 220         Authctxt authctxt;
 221         int type;
 222
 223         if (options.challenge_response_authentication)
 224                 options.kbd_interactive_authentication = 1;
 225
 226         packet_start(SSH2_MSG_SERVICE_REQUEST);
 227         packet_put_cstring("ssh-userauth");
 228         packet_send();
 229         debug("SSH2_MSG_SERVICE_REQUEST sent");
 230         packet_write_wait();
 231         type = packet_read();
 232         if (type != SSH2_MSG_SERVICE_ACCEPT)
 233                 fatal("Server denied authentication request: %d", type);
 234         if (packet_remaining() > 0) {
 235                 char *reply = packet_get_string(NULL);
 236                 debug2("service_accept: %s", reply);
 237                 xfree(reply);
 238         } else {
 239                 debug("buggy server: service_accept w/o service");
 240         }
 241         packet_check_eom();
 242         debug("SSH2_MSG_SERVICE_ACCEPT received");
 243
 244         if (options.preferred_authentications == NULL)
 245                 options.preferred_authentications = authmethods_get();
 246
 247         /* setup authentication context */
 248         memset(&authctxt, 0, sizeof(authctxt));
 249         authctxt.agent = ssh_get_authentication_connection();
 250         authctxt.server_user = server_user;
 251         authctxt.local_user = local_user;
 252         authctxt.host = host;
 253         authctxt.service = "ssh-connection";            /* service name */
 254         authctxt.success = 0;
 255         authctxt.method = authmethod_lookup("none");
 256         authctxt.authlist = NULL;
 257         authctxt.sensitive = sensitive;
 258         authctxt.info_req_seen = 0;
 259         if (authctxt.method == NULL)
 260                 fatal("ssh_userauth2: internal error: cannot send userauth none request");
 261
 262         /* initial userauth request */
 263         userauth_none(&authctxt);
 264
 265         dispatch_init(&input_userauth_error);
 266         dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
 267         dispatch_set(SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);
 268         dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
 269         dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt);     /* loop until success */
 270
 271         if (authctxt.agent != NULL)
 272                 ssh_close_authentication_connection(authctxt.agent);
 273
 274         debug("ssh-userauth2 successful: method %s", authctxt.method->name);
 275 }
 276 void
 277 userauth(Authctxt *authctxt, char *authlist)
 278 {
 279         if (authlist == NULL) {
 280                 authlist = authctxt->authlist;
 281         } else {
 282                 if (authctxt->authlist)
 283                         xfree(authctxt->authlist);
 284                 authctxt->authlist = authlist;
 285         }
 286         for (;;) {
 287                 Authmethod *method = authmethod_get(authlist);
 288                 if (method == NULL)
 289                         fatal("Permission denied (%s).", authlist);
 290                 authctxt->method = method;
 291                 if (method->userauth(authctxt) != 0) {
 292                         debug2("we sent a %s packet, wait for reply", method->name);
 293                         break;
 294                 } else {
 295                         debug2("we did not send a packet, disable method");
 296                         method->enabled = NULL;
 297                 }
 298         }
 299 }
 300
 301 void
 302 input_userauth_error(int type, u_int32_t seq, void *ctxt)
 303 {
 304         fatal("input_userauth_error: bad message during authentication: "
 305            "type %d", type);
 306 }
 307
 308 void
 309 input_userauth_banner(int type, u_int32_t seq, void *ctxt)
 310 {
 311         char *msg, *lang;
 312         debug3("input_userauth_banner");
 313         msg = packet_get_string(NULL);
 314         lang = packet_get_string(NULL);
 315         fprintf(stderr, "%s", msg);
 316         xfree(msg);
 317         xfree(lang);
 318 }
 319
 320 void
 321 input_userauth_success(int type, u_int32_t seq, void *ctxt)
 322 {
 323         Authctxt *authctxt = ctxt;
 324         if (authctxt == NULL)
 325                 fatal("input_userauth_success: no authentication context");
 326         if (authctxt->authlist)
 327                 xfree(authctxt->authlist);
 328         clear_auth_state(authctxt);
 329         authctxt->success = 1;                  /* break out */
 330 }
 331
 332 void
 333 input_userauth_failure(int type, u_int32_t seq, void *ctxt)
 334 {
 335         Authctxt *authctxt = ctxt;
 336         char *authlist = NULL;
 337         int partial;
 338
 339         if (authctxt == NULL)
 340                 fatal("input_userauth_failure: no authentication context");
 341
 342         authlist = packet_get_string(NULL);
 343         partial = packet_get_char();
 344         packet_check_eom();
 345
 346         if (partial != 0)
 347                 log("Authenticated with partial success.");
 348         debug("authentications that can continue: %s", authlist);
 349
 350         clear_auth_state(authctxt);
 351         userauth(authctxt, authlist);
 352 }
 353 void
 354 input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
 355 {
 356         Authctxt *authctxt = ctxt;
 357         Key *key = NULL;
 358         Buffer b;
 359         int pktype, sent = 0;
 360         u_int alen, blen;
 361         char *pkalg, *fp;
 362         u_char *pkblob;
 363
 364         if (authctxt == NULL)
 365                 fatal("input_userauth_pk_ok: no authentication context");
 366         if (datafellows & SSH_BUG_PKOK) {
 367                 /* this is similar to SSH_BUG_PKAUTH */
 368                 debug2("input_userauth_pk_ok: SSH_BUG_PKOK");
 369                 pkblob = packet_get_string(&blen);
 370                 buffer_init(&b);
 371                 buffer_append(&b, pkblob, blen);
 372                 pkalg = buffer_get_string(&b, &alen);
 373                 buffer_free(&b);
 374         } else {
 375                 pkalg = packet_get_string(&alen);
 376                 pkblob = packet_get_string(&blen);
 377         }
 378         packet_check_eom();
 379
 380         debug("input_userauth_pk_ok: pkalg %s blen %u lastkey %p hint %d",
 381             pkalg, blen, authctxt->last_key, authctxt->last_key_hint);
 382
 383         do {
 384                 if (authctxt->last_key == NULL ||
 385                     authctxt->last_key_sign == NULL) {
 386                         debug("no last key or no sign cb");
 387                         break;
 388                 }
 389                 if ((pktype = key_type_from_name(pkalg)) == KEY_UNSPEC) {
 390                         debug("unknown pkalg %s", pkalg);
 391                         break;
 392                 }
 393                 if ((key = key_from_blob(pkblob, blen)) == NULL) {
 394                         debug("no key from blob. pkalg %s", pkalg);
 395                         break;
 396                 }
 397                 if (key->type != pktype) {
 398                         error("input_userauth_pk_ok: type mismatch "
 399                             "for decoded key (received %d, expected %d)",
 400                             key->type, pktype);
 401                         break;
 402                 }
 403                 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
 404                 debug2("input_userauth_pk_ok: fp %s", fp);
 405                 xfree(fp);
 406                 if (!key_equal(key, authctxt->last_key)) {
 407                         debug("key != last_key");
 408                         break;
 409                 }
 410                 sent = sign_and_send_pubkey(authctxt, key,
 411                    authctxt->last_key_sign);
 412         } while (0);
 413
 414         if (key != NULL)
 415                 key_free(key);
 416         xfree(pkalg);
 417         xfree(pkblob);
 418
 419         /* unregister */
 420         clear_auth_state(authctxt);
 421         dispatch_set(SSH2_MSG_USERAUTH_PK_OK, NULL);
 422
 423         /* try another method if we did not send a packet */
 424         if (sent == 0)
 425                 userauth(authctxt, NULL);
 426
 427 }
 428
 429 int
 430 userauth_none(Authctxt *authctxt)
 431 {
 432         /* initial userauth request */
 433         packet_start(SSH2_MSG_USERAUTH_REQUEST);
 434         packet_put_cstring(authctxt->server_user);
 435         packet_put_cstring(authctxt->service);
 436         packet_put_cstring(authctxt->method->name);
 437         packet_send();
 438         return 1;
 439 }
 440
 441 int
 442 userauth_passwd(Authctxt *authctxt)
 443 {
 444         static int attempt = 0;
 445         char prompt[150];
 446         char *password;
 447
 448         if (attempt++ >= options.number_of_password_prompts)
 449                 return 0;
 450
 451         if (attempt != 1)
 452                 error("Permission denied, please try again.");
 453
 454         snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
 455             authctxt->server_user, authctxt->host);
 456         password = read_passphrase(prompt, 0);
 457         packet_start(SSH2_MSG_USERAUTH_REQUEST);
 458         packet_put_cstring(authctxt->server_user);
 459         packet_put_cstring(authctxt->service);
 460         packet_put_cstring(authctxt->method->name);
 461         packet_put_char(0);
 462         packet_put_cstring(password);
 463         memset(password, 0, strlen(password));
 464         xfree(password);
 465         packet_add_padding(64);
 466         packet_send();
 467
 468         dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
 469             &input_userauth_passwd_changereq);
 470
 471         return 1;
 472 }
 473 /*
 474  * parse PASSWD_CHANGEREQ, prompt user and send SSH2_MSG_USERAUTH_REQUEST
 475  */
 476 void
 477 input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
 478 {
 479         Authctxt *authctxt = ctxt;
 480         char *info, *lang, *password = NULL, *retype = NULL;
 481         char prompt[150];
 482
 483         debug2("input_userauth_passwd_changereq");
 484
 485         if (authctxt == NULL)
 486                 fatal("input_userauth_passwd_changereq: "
 487                     "no authentication context");
 488
 489         info = packet_get_string(NULL);
 490         lang = packet_get_string(NULL);
 491         if (strlen(info) > 0)
 492                 log("%s", info);
 493         xfree(info);
 494         xfree(lang);
 495         packet_start(SSH2_MSG_USERAUTH_REQUEST);
 496         packet_put_cstring(authctxt->server_user);
 497         packet_put_cstring(authctxt->service);
 498         packet_put_cstring(authctxt->method->name);
 499         packet_put_char(1);                     /* additional info */
 500         snprintf(prompt, sizeof(prompt),
 501             "Enter %.30s@%.128s's old password: ",
 502             authctxt->server_user, authctxt->host);
 503         password = read_passphrase(prompt, 0);
 504         packet_put_cstring(password);
 505         memset(password, 0, strlen(password));
 506         xfree(password);
 507         password = NULL;
 508         while (password == NULL) {
 509                 snprintf(prompt, sizeof(prompt),
 510                     "Enter %.30s@%.128s's new password: ",
 511                     authctxt->server_user, authctxt->host);
 512                 password = read_passphrase(prompt, RP_ALLOW_EOF);
 513                 if (password == NULL) {
 514                         /* bail out */
 515                         return;
 516                 }
 517                 snprintf(prompt, sizeof(prompt),
 518                     "Retype %.30s@%.128s's new password: ",
 519                     authctxt->server_user, authctxt->host);
 520                 retype = read_passphrase(prompt, 0);
 521                 if (strcmp(password, retype) != 0) {
 522                         memset(password, 0, strlen(password));
 523                         xfree(password);
 524                         log("Mismatch; try again, EOF to quit.");
 525                         password = NULL;
 526                 }
 527                 memset(retype, 0, strlen(retype));
 528                 xfree(retype);
 529         }
 530         packet_put_cstring(password);
 531         memset(password, 0, strlen(password));
 532         xfree(password);
 533         packet_add_padding(64);
 534         packet_send();
 535
 536         dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
 537             &input_userauth_passwd_changereq);
 538 }
 539
 540 static void
 541 clear_auth_state(Authctxt *authctxt)
 542 {
 543         /* XXX clear authentication state */
 544         dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, NULL);
 545
 546         if (authctxt->last_key != NULL && authctxt->last_key_hint == -1) {
 547                 debug3("clear_auth_state: key_free %p", authctxt->last_key);
 548                 key_free(authctxt->last_key);
 549         }
 550         authctxt->last_key = NULL;
 551         authctxt->last_key_hint = -2;
 552         authctxt->last_key_sign = NULL;
 553 }
 554
 555 static int
 556 sign_and_send_pubkey(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback)
 557 {
 558         Buffer b;
 559         u_char *blob, *signature;
 560         u_int bloblen, slen;
 561         int skip = 0;
 562         int ret = -1;
 563         int have_sig = 1;
 564
 565         debug3("sign_and_send_pubkey");
 566
 567         if (key_to_blob(k, &blob, &bloblen) == 0) {
 568                 /* we cannot handle this key */
 569                 debug3("sign_and_send_pubkey: cannot handle key");
 570                 return 0;
 571         }
 572         /* data to be signed */
 573         buffer_init(&b);
 574         if (datafellows & SSH_OLD_SESSIONID) {
 575                 buffer_append(&b, session_id2, session_id2_len);
 576                 skip = session_id2_len;
 577         } else {
 578                 buffer_put_string(&b, session_id2, session_id2_len);
 579                 skip = buffer_len(&b);
 580         }
 581         buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
 582         buffer_put_cstring(&b, authctxt->server_user);
 583         buffer_put_cstring(&b,
 584             datafellows & SSH_BUG_PKSERVICE ?
 585             "ssh-userauth" :
 586             authctxt->service);
 587         if (datafellows & SSH_BUG_PKAUTH) {
 588                 buffer_put_char(&b, have_sig);
 589         } else {
 590                 buffer_put_cstring(&b, authctxt->method->name);
 591                 buffer_put_char(&b, have_sig);
 592                 buffer_put_cstring(&b, key_ssh_name(k));
 593         }
 594         buffer_put_string(&b, blob, bloblen);
 595
 596         /* generate signature */
 597         ret = (*sign_callback)(authctxt, k, &signature, &slen,
 598             buffer_ptr(&b), buffer_len(&b));
 599         if (ret == -1) {
 600                 xfree(blob);
 601                 buffer_free(&b);
 602                 return 0;
 603         }
 604 #ifdef DEBUG_PK
 605         buffer_dump(&b);
 606 #endif
 607         if (datafellows & SSH_BUG_PKSERVICE) {
 608                 buffer_clear(&b);
 609                 buffer_append(&b, session_id2, session_id2_len);
 610                 skip = session_id2_len;
 611                 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
 612                 buffer_put_cstring(&b, authctxt->server_user);
 613                 buffer_put_cstring(&b, authctxt->service);
 614                 buffer_put_cstring(&b, authctxt->method->name);
 615                 buffer_put_char(&b, have_sig);
 616                 if (!(datafellows & SSH_BUG_PKAUTH))
 617                         buffer_put_cstring(&b, key_ssh_name(k));
 618                 buffer_put_string(&b, blob, bloblen);
 619         }
 620         xfree(blob);
 621
 622         /* append signature */
 623         buffer_put_string(&b, signature, slen);
 624         xfree(signature);
 625
 626         /* skip session id and packet type */
 627         if (buffer_len(&b) < skip + 1)
 628                 fatal("userauth_pubkey: internal error");
 629         buffer_consume(&b, skip + 1);
 630
 631         /* put remaining data from buffer into packet */
 632         packet_start(SSH2_MSG_USERAUTH_REQUEST);
 633         packet_put_raw(buffer_ptr(&b), buffer_len(&b));
 634         buffer_free(&b);
 635         packet_send();
 636
 637         return 1;
 638 }
 639
 640 static int
 641 send_pubkey_test(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback,
 642     int hint)
 643 {
 644         u_char *blob;
 645         u_int bloblen, have_sig = 0;
 646
 647         debug3("send_pubkey_test");
 648
 649         if (key_to_blob(k, &blob, &bloblen) == 0) {
 650                 /* we cannot handle this key */
 651                 debug3("send_pubkey_test: cannot handle key");
 652                 return 0;
 653         }
 654         /* register callback for USERAUTH_PK_OK message */
 655         authctxt->last_key_sign = sign_callback;
 656         authctxt->last_key_hint = hint;
 657         authctxt->last_key = k;
 658         dispatch_set(SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);
 659
 660         packet_start(SSH2_MSG_USERAUTH_REQUEST);
 661         packet_put_cstring(authctxt->server_user);
 662         packet_put_cstring(authctxt->service);
 663         packet_put_cstring(authctxt->method->name);
 664         packet_put_char(have_sig);
 665         if (!(datafellows & SSH_BUG_PKAUTH))
 666                 packet_put_cstring(key_ssh_name(k));
 667         packet_put_string(blob, bloblen);
 668         xfree(blob);
 669         packet_send();
 670         return 1;
 671 }
 672
 673 static Key *
 674 load_identity_file(char *filename)
 675 {
 676         Key *private;
 677         char prompt[300], *passphrase;
 678         int quit, i;
 679         struct stat st;
 680
 681         if (stat(filename, &st) < 0) {
 682                 debug3("no such identity: %s", filename);
 683                 return NULL;
 684         }
 685         private = key_load_private_type(KEY_UNSPEC, filename, "", NULL);
 686         if (private == NULL) {
 687                 if (options.batch_mode)
 688                         return NULL;
 689                 snprintf(prompt, sizeof prompt,
 690                     "Enter passphrase for key '%.100s': ", filename);
 691                 for (i = 0; i < options.number_of_password_prompts; i++) {
 692                         passphrase = read_passphrase(prompt, 0);
 693                         if (strcmp(passphrase, "") != 0) {
 694                                 private = key_load_private_type(KEY_UNSPEC, filename,
 695                                     passphrase, NULL);
 696                                 quit = 0;
 697                         } else {
 698                                 debug2("no passphrase given, try next key");
 699                                 quit = 1;
 700                         }
 701                         memset(passphrase, 0, strlen(passphrase));
 702                         xfree(passphrase);
 703                         if (private != NULL || quit)
 704                                 break;
 705                         debug2("bad passphrase given, try again...");
 706                 }
 707         }
 708         return private;
 709 }
 710
 711 static int
 712 identity_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
 713     u_char *data, u_int datalen)
 714 {
 715         Key *private;
 716         int idx, ret;
 717
 718         idx = authctxt->last_key_hint;
 719         if (idx < 0)
 720                 return -1;
 721
 722         /* private key is stored in external hardware */
 723         if (options.identity_keys[idx]->flags & KEY_FLAG_EXT)
 724                 return key_sign(options.identity_keys[idx], sigp, lenp, data, datalen);
 725
 726         private = load_identity_file(options.identity_files[idx]);
 727         if (private == NULL)
 728                 return -1;
 729         ret = key_sign(private, sigp, lenp, data, datalen);
 730         key_free(private);
 731         return ret;
 732 }
 733
 734 static int
 735 agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
 736     u_char *data, u_int datalen)
 737 {
 738         return ssh_agent_sign(authctxt->agent, key, sigp, lenp, data, datalen);
 739 }
 740
 741 static int
 742 key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
 743     u_char *data, u_int datalen)
 744 {
 745         return key_sign(key, sigp, lenp, data, datalen);
 746 }
 747
 748 static int
 749 userauth_pubkey_agent(Authctxt *authctxt)
 750 {
 751         static int called = 0;
 752         int ret = 0;
 753         char *comment;
 754         Key *k;
 755
 756         if (called == 0) {
 757                 if (ssh_get_num_identities(authctxt->agent, 2) == 0)
 758                         debug2("userauth_pubkey_agent: no keys at all");
 759                 called = 1;
 760         }
 761         k = ssh_get_next_identity(authctxt->agent, &comment, 2);
 762         if (k == NULL) {
 763                 debug2("userauth_pubkey_agent: no more keys");
 764         } else {
 765                 debug("userauth_pubkey_agent: testing agent key %s", comment);
 766                 xfree(comment);
 767                 ret = send_pubkey_test(authctxt, k, agent_sign_cb, -1);
 768                 if (ret == 0)
 769                         key_free(k);
 770         }
 771         if (ret == 0)
 772                 debug2("userauth_pubkey_agent: no message sent");
 773         return ret;
 774 }
 775
 776 int
 777 userauth_pubkey(Authctxt *authctxt)
 778 {
 779         static int idx = 0;
 780         int sent = 0;
 781         Key *key;
 782         char *filename;
 783
 784         if (authctxt->agent != NULL) {
 785                 do {
 786                         sent = userauth_pubkey_agent(authctxt);
 787                 } while (!sent && authctxt->agent->howmany > 0);
 788         }
 789         while (!sent && idx < options.num_identity_files) {
 790                 key = options.identity_keys[idx];
 791                 filename = options.identity_files[idx];
 792                 if (key == NULL) {
 793                         debug("try privkey: %s", filename);
 794                         key = load_identity_file(filename);
 795                         if (key != NULL) {
 796                                 sent = sign_and_send_pubkey(authctxt, key,
 797                                     key_sign_cb);
 798                                 key_free(key);
 799                         }
 800                 } else if (key->type != KEY_RSA1) {
 801                         debug("try pubkey: %s", filename);
 802                         sent = send_pubkey_test(authctxt, key,
 803                             identity_sign_cb, idx);
 804                 }
 805                 idx++;
 806         }
 807         return sent;
 808 }
 809
 810 /*
 811  * Send userauth request message specifying keyboard-interactive method.
 812  */
 813 int
 814 userauth_kbdint(Authctxt *authctxt)
 815 {
 816         static int attempt = 0;
 817
 818         if (attempt++ >= options.number_of_password_prompts)
 819                 return 0;
 820         /* disable if no SSH2_MSG_USERAUTH_INFO_REQUEST has been seen */
 821         if (attempt > 1 && !authctxt->info_req_seen) {
 822                 debug3("userauth_kbdint: disable: no info_req_seen");
 823                 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);
 824                 return 0;
 825         }
 826
 827         debug2("userauth_kbdint");
 828         packet_start(SSH2_MSG_USERAUTH_REQUEST);
 829         packet_put_cstring(authctxt->server_user);
 830         packet_put_cstring(authctxt->service);
 831         packet_put_cstring(authctxt->method->name);
 832         packet_put_cstring("");                                 /* lang */
 833         packet_put_cstring(options.kbd_interactive_devices ?
 834             options.kbd_interactive_devices : "");
 835         packet_send();
 836
 837         dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);
 838         return 1;
 839 }
 840
 841 /*
 842  * parse INFO_REQUEST, prompt user and send INFO_RESPONSE
 843  */
 844 void
 845 input_userauth_info_req(int type, u_int32_t seq, void *ctxt)
 846 {
 847         Authctxt *authctxt = ctxt;
 848         char *name, *inst, *lang, *prompt, *response;
 849         u_int num_prompts, i;
 850         int echo = 0;
 851
 852         debug2("input_userauth_info_req");
 853
 854         if (authctxt == NULL)
 855                 fatal("input_userauth_info_req: no authentication context");
 856
 857         authctxt->info_req_seen = 1;
 858
 859         name = packet_get_string(NULL);
 860         inst = packet_get_string(NULL);
 861         lang = packet_get_string(NULL);
 862         if (strlen(name) > 0)
 863                 log("%s", name);
 864         if (strlen(inst) > 0)
 865                 log("%s", inst);
 866         xfree(name);
 867         xfree(inst);
 868         xfree(lang);
 869
 870         num_prompts = packet_get_int();
 871         /*
 872          * Begin to build info response packet based on prompts requested.
 873          * We commit to providing the correct number of responses, so if
 874          * further on we run into a problem that prevents this, we have to
 875          * be sure and clean this up and send a correct error response.
 876          */
 877         packet_start(SSH2_MSG_USERAUTH_INFO_RESPONSE);
 878         packet_put_int(num_prompts);
 879
 880         debug2("input_userauth_info_req: num_prompts %d", num_prompts);
 881         for (i = 0; i < num_prompts; i++) {
 882                 prompt = packet_get_string(NULL);
 883                 echo = packet_get_char();
 884
 885                 response = read_passphrase(prompt, echo ? RP_ECHO : 0);
 886
 887                 packet_put_cstring(response);
 888                 memset(response, 0, strlen(response));
 889                 xfree(response);
 890                 xfree(prompt);
 891         }
 892         packet_check_eom(); /* done with parsing incoming message. */
 893
 894         packet_add_padding(64);
 895         packet_send();
 896 }
 897
 898 static int
 899 ssh_keysign(Key *key, u_char **sigp, u_int *lenp,
 900     u_char *data, u_int datalen)
 901 {
 902         Buffer b;
 903         struct stat st;
 904         pid_t pid;
 905         int to[2], from[2], status, version = 2;
 906
 907         debug("ssh_keysign called");
 908
 909         if (stat(_PATH_SSH_KEY_SIGN, &st) < 0) {
 910                 error("ssh_keysign: no installed: %s", strerror(errno));
 911                 return -1;
 912         }
 913         if (fflush(stdout) != 0)
 914                 error("ssh_keysign: fflush: %s", strerror(errno));
 915         if (pipe(to) < 0) {
 916                 error("ssh_keysign: pipe: %s", strerror(errno));
 917                 return -1;
 918         }
 919         if (pipe(from) < 0) {
 920                 error("ssh_keysign: pipe: %s", strerror(errno));
 921                 return -1;
 922         }
 923         if ((pid = fork()) < 0) {
 924                 error("ssh_keysign: fork: %s", strerror(errno));
 925                 return -1;
 926         }
 927         if (pid == 0) {
 928                 seteuid(getuid());
 929                 setuid(getuid());
 930                 close(from[0]);
 931                 if (dup2(from[1], STDOUT_FILENO) < 0)
 932                         fatal("ssh_keysign: dup2: %s", strerror(errno));
 933                 close(to[1]);
 934                 if (dup2(to[0], STDIN_FILENO) < 0)
 935                         fatal("ssh_keysign: dup2: %s", strerror(errno));
 936                 close(from[1]);
 937                 close(to[0]);
 938                 execl(_PATH_SSH_KEY_SIGN, _PATH_SSH_KEY_SIGN, (char *) 0);
 939                 fatal("ssh_keysign: exec(%s): %s", _PATH_SSH_KEY_SIGN,
 940                     strerror(errno));
 941         }
 942         close(from[1]);
 943         close(to[0]);
 944
 945         buffer_init(&b);
 946         buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */
 947         buffer_put_string(&b, data, datalen);
 948         ssh_msg_send(to[1], version, &b);
 949
 950         if (ssh_msg_recv(from[0], &b) < 0) {
 951                 error("ssh_keysign: no reply");
 952                 buffer_clear(&b);
 953                 return -1;
 954         }
 955         close(from[0]);
 956         close(to[1]);
 957
 958         while (waitpid(pid, &status, 0) < 0)
 959                 if (errno != EINTR)
 960                         break;
 961
 962         if (buffer_get_char(&b) != version) {
 963                 error("ssh_keysign: bad version");
 964                 buffer_clear(&b);
 965                 return -1;
 966         }
 967         *sigp = buffer_get_string(&b, lenp);
 968         buffer_clear(&b);
 969
 970         return 0;
 971 }
 972
 973 int
 974 userauth_hostbased(Authctxt *authctxt)
 975 {
 976         Key *private = NULL;
 977         Sensitive *sensitive = authctxt->sensitive;
 978         Buffer b;
 979         u_char *signature, *blob;
 980         char *chost, *pkalg, *p;
 981         const char *service;
 982         u_int blen, slen;
 983         int ok, i, len, found = 0;
 984
 985         /* check for a useful key */
 986         for (i = 0; i < sensitive->nkeys; i++) {
 987                 private = sensitive->keys[i];
 988                 if (private && private->type != KEY_RSA1) {
 989                         found = 1;
 990                         /* we take and free the key */
 991                         sensitive->keys[i] = NULL;
 992                         break;
 993                 }
 994         }
 995         if (!found) {
 996                 debug("userauth_hostbased: no more client hostkeys");
 997                 return 0;
 998         }
 999         if (key_to_blob(private, &blob, &blen) == 0) {
1000                 key_free(private);
1001                 return 0;
1002         }
1003         /* figure out a name for the client host */
1004         p = get_local_name(packet_get_connection_in());
1005         if (p == NULL) {
1006                 error("userauth_hostbased: cannot get local ipaddr/name");
1007                 key_free(private);
1008                 return 0;
1009         }
1010         len = strlen(p) + 2;
1011         chost = xmalloc(len);
1012         strlcpy(chost, p, len);
1013         strlcat(chost, ".", len);
1014         debug2("userauth_hostbased: chost %s", chost);
1015
1016         service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :
1017             authctxt->service;
1018         pkalg = xstrdup(key_ssh_name(private));
1019         buffer_init(&b);
1020         /* construct data */
1021         buffer_put_string(&b, session_id2, session_id2_len);
1022         buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
1023         buffer_put_cstring(&b, authctxt->server_user);
1024         buffer_put_cstring(&b, service);
1025         buffer_put_cstring(&b, authctxt->method->name);
1026         buffer_put_cstring(&b, pkalg);
1027         buffer_put_string(&b, blob, blen);
1028         buffer_put_cstring(&b, chost);
1029         buffer_put_cstring(&b, authctxt->local_user);
1030 #ifdef DEBUG_PK
1031         buffer_dump(&b);
1032 #endif
1033         if (sensitive->external_keysign)
1034                 ok = ssh_keysign(private, &signature, &slen,
1035                     buffer_ptr(&b), buffer_len(&b));
1036         else
1037                 ok = key_sign(private, &signature, &slen,
1038                     buffer_ptr(&b), buffer_len(&b));
1039         key_free(private);
1040         buffer_free(&b);
1041         if (ok != 0) {
1042                 error("key_sign failed");
1043                 xfree(chost);
1044                 xfree(pkalg);
1045                 return 0;
1046         }
1047         packet_start(SSH2_MSG_USERAUTH_REQUEST);
1048         packet_put_cstring(authctxt->server_user);
1049         packet_put_cstring(authctxt->service);
1050         packet_put_cstring(authctxt->method->name);
1051         packet_put_cstring(pkalg);
1052         packet_put_string(blob, blen);
1053         packet_put_cstring(chost);
1054         packet_put_cstring(authctxt->local_user);
1055         packet_put_string(signature, slen);
1056         memset(signature, 's', slen);
1057         xfree(signature);
1058         xfree(chost);
1059         xfree(pkalg);
1060
1061         packet_send();
1062         return 1;
1063 }
1064
1065 /* find auth method */
1066
1067 /*
1068  * given auth method name, if configurable options permit this method fill
1069  * in auth_ident field and return true, otherwise return false.
1070  */
1071 static int
1072 authmethod_is_enabled(Authmethod *method)
1073 {
1074         if (method == NULL)
1075                 return 0;
1076         /* return false if options indicate this method is disabled */
1077         if  (method->enabled == NULL || *method->enabled == 0)
1078                 return 0;
1079         /* return false if batch mode is enabled but method needs interactive mode */
1080         if  (method->batch_flag != NULL && *method->batch_flag != 0)
1081                 return 0;
1082         return 1;
1083 }
1084
1085 static Authmethod *
1086 authmethod_lookup(const char *name)
1087 {
1088         Authmethod *method = NULL;
1089         if (name != NULL)
1090                 for (method = authmethods; method->name != NULL; method++)
1091                         if (strcmp(name, method->name) == 0)
1092                                 return method;
1093         debug2("Unrecognized authentication method name: %s", name ? name : "NULL");
1094         return NULL;
1095 }
1096
1097 /* XXX internal state */
1098 static Authmethod *current = NULL;
1099 static char *supported = NULL;
1100 static char *preferred = NULL;
1101
1102 /*
1103  * Given the authentication method list sent by the server, return the
1104  * next method we should try.  If the server initially sends a nil list,
1105  * use a built-in default list.
1106  */
1107 static Authmethod *
1108 authmethod_get(char *authlist)
1109 {
1110
1111         char *name = NULL;
1112         u_int next;
1113
1114         /* Use a suitable default if we're passed a nil list.  */
1115         if (authlist == NULL || strlen(authlist) == 0)
1116                 authlist = options.preferred_authentications;
1117
1118         if (supported == NULL || strcmp(authlist, supported) != 0) {
1119                 debug3("start over, passed a different list %s", authlist);
1120                 if (supported != NULL)
1121                         xfree(supported);
1122                 supported = xstrdup(authlist);
1123                 preferred = options.preferred_authentications;
1124                 debug3("preferred %s", preferred);
1125                 current = NULL;
1126         } else if (current != NULL && authmethod_is_enabled(current))
1127                 return current;
1128
1129         for (;;) {
1130                 if ((name = match_list(preferred, supported, &next)) == NULL) {
1131                         debug("no more auth methods to try");
1132                         current = NULL;
1133                         return NULL;
1134                 }
1135                 preferred += next;
1136                 debug3("authmethod_lookup %s", name);
1137                 debug3("remaining preferred: %s", preferred);
1138                 if ((current = authmethod_lookup(name)) != NULL &&
1139                     authmethod_is_enabled(current)) {
1140                         debug3("authmethod_is_enabled %s", name);
1141                         debug("next auth method to try is %s", name);
1142                         return current;
1143                 }
1144         }
1145 }
1146
1147 static char *
1148 authmethods_get(void)
1149 {
1150         Authmethod *method = NULL;
1151         Buffer b;
1152         char *list;
1153
1154         buffer_init(&b);
1155         for (method = authmethods; method->name != NULL; method++) {
1156                 if (authmethod_is_enabled(method)) {
1157                         if (buffer_len(&b) > 0)
1158                                 buffer_append(&b, ",", 1);
1159                         buffer_append(&b, method->name, strlen(method->name));
1160                 }
1161         }
1162         buffer_append(&b, "\0", 1);
1163         list = xstrdup(buffer_ptr(&b));
1164         buffer_free(&b);
1165         return list;
1166 }