1 files changed, 164 insertions, 461 deletions

diff --git a/sshconnect2.c b/sshconnect2.c
index 933c223ec..642b34b9e 100644
--- a/sshconnect2.c
+++ b/sshconnect2.c
@@ -23,9 +23,7 @@
  */
 
 #include "includes.h"
-RCSID("$OpenBSD: sshconnect2.c,v 1.124 2003/08/25 10:33:33 djm Exp $");
-
-#include "openbsd-compat/sys-queue.h"
+RCSID("$OpenBSD: sshconnect2.c,v 1.114 2003/04/01 10:22:21 markus Exp $");
 
 #include "ssh.h"
 #include "ssh2.h"
@@ -50,10 +48,6 @@ RCSID("$OpenBSD: sshconnect2.c,v 1.124 2003/08/25 10:33:33 djm Exp $");
 #include "msg.h"
 #include "pathnames.h"
 
-#ifdef GSSAPI
-#include "ssh-gss.h"
-#endif
-
 /* import */
 extern char *client_version_string;
 extern char *server_version_string;
@@ -64,7 +58,7 @@ extern Options options;
  */
 
 u_char *session_id2 = NULL;
-u_int session_id2_len = 0;
+int session_id2_len = 0;
 
 char *xxx_host;
 struct sockaddr *xxx_hostaddr;
@@ -88,7 +82,7 @@ ssh_kex2(char *host, struct sockaddr *hostaddr)
         xxx_hostaddr = hostaddr;
 
         if (options.ciphers == (char *)-1) {
-                logit("No valid ciphers for protocol version 2 given, using defaults.");
+                log("No valid ciphers for protocol version 2 given, using defaults.");
                 options.ciphers = NULL;
         }
         if (options.ciphers != NULL) {
@@ -114,9 +108,6 @@ ssh_kex2(char *host, struct sockaddr *hostaddr)
                 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
                     options.hostkeyalgorithms;
 
-        if (options.rekey_limit)
-                packet_set_rekey_limit(options.rekey_limit);
-
         /* start key exchange */
         kex = kex_setup(myproposal);
         kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;
@@ -147,18 +138,10 @@ ssh_kex2(char *host, struct sockaddr *hostaddr)
 
 typedef struct Authctxt Authctxt;
 typedef struct Authmethod Authmethod;
-typedef struct identity Identity;
-typedef struct idlist Idlist;
-
-struct identity {
-        TAILQ_ENTRY(identity) next;
-        AuthenticationConnection *ac;   /* set if agent supports key */
-        Key     *key;                   /* public/private key */
-        char    *filename;              /* comment for agent-only keys */
-        int     tried;
-        int     isprivate;              /* key points to the private key */
-};
-TAILQ_HEAD(idlist, identity);
+
+typedef int sign_cb_fn(
+    Authctxt *authctxt, Key *key,
+    u_char **sigp, u_int *lenp, u_char *data, u_int datalen);
 
 struct Authctxt {
         const char *server_user;
@@ -169,14 +152,14 @@ struct Authctxt {
         int success;
         char *authlist;
         /* pubkey */
-        Idlist keys;
+        Key *last_key;
+        sign_cb_fn *last_key_sign;
+        int last_key_hint;
         AuthenticationConnection *agent;
         /* hostbased */
         Sensitive *sensitive;
         /* kbd-interactive */
         int info_req_seen;
-        /* generic */
-        void *methoddata;
 };
 struct Authmethod {
         char    *name;          /* string to compare against server's list */
@@ -198,35 +181,17 @@ int	userauth_pubkey(Authctxt *);
 int     userauth_passwd(Authctxt *);
 int     userauth_kbdint(Authctxt *);
 int     userauth_hostbased(Authctxt *);
-int     userauth_kerberos(Authctxt *);
-
-#ifdef GSSAPI
-int     userauth_gssapi(Authctxt *authctxt);
-void    input_gssapi_response(int type, u_int32_t, void *);
-void    input_gssapi_token(int type, u_int32_t, void *);
-void    input_gssapi_hash(int type, u_int32_t, void *);
-void    input_gssapi_error(int, u_int32_t, void *);
-void    input_gssapi_errtok(int, u_int32_t, void *);
-#endif
 
 void    userauth(Authctxt *, char *);
 
-static int sign_and_send_pubkey(Authctxt *, Identity *);
-static void pubkey_prepare(Authctxt *);
-static void pubkey_cleanup(Authctxt *);
-static Key *load_identity_file(char *);
+static int sign_and_send_pubkey(Authctxt *, Key *, sign_cb_fn *);
+static void clear_auth_state(Authctxt *);
 
 static Authmethod *authmethod_get(char *authlist);
 static Authmethod *authmethod_lookup(const char *name);
 static char *authmethods_get(void);
 
 Authmethod authmethods[] = {
-#ifdef GSSAPI
-        {"gssapi",
-                userauth_gssapi,
-                &options.gss_authentication,
-                NULL},
-#endif
         {"hostbased",
                 userauth_hostbased,
                 &options.hostbased_authentication,
@@ -283,7 +248,7 @@ ssh_userauth2(const char *local_user, const char *server_user, char *host,
 
         /* setup authentication context */
         memset(&authctxt, 0, sizeof(authctxt));
-        pubkey_prepare(&authctxt);
+        authctxt.agent = ssh_get_authentication_connection();
         authctxt.server_user = server_user;
         authctxt.local_user = local_user;
         authctxt.host = host;
@@ -291,7 +256,6 @@ ssh_userauth2(const char *local_user, const char *server_user, char *host,
         authctxt.success = 0;
         authctxt.method = authmethod_lookup("none");
         authctxt.authlist = NULL;
-        authctxt.methoddata = NULL;
         authctxt.sensitive = sensitive;
         authctxt.info_req_seen = 0;
         if (authctxt.method == NULL)
@@ -306,19 +270,14 @@ ssh_userauth2(const char *local_user, const char *server_user, char *host,
         dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
         dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt);     /* loop until success */
 
-        pubkey_cleanup(&authctxt);
-        dispatch_range(SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);
+        if (authctxt.agent != NULL)
+                ssh_close_authentication_connection(authctxt.agent);
 
         debug("Authentication succeeded (%s).", authctxt.method->name);
 }
-
 void
 userauth(Authctxt *authctxt, char *authlist)
 {
-        if (authctxt->methoddata) {
-                xfree(authctxt->methoddata);
-                authctxt->methoddata = NULL;
-        }
         if (authlist == NULL) {
                 authlist = authctxt->authlist;
         } else {
@@ -331,12 +290,6 @@ userauth(Authctxt *authctxt, char *authlist)
                 if (method == NULL)
                         fatal("Permission denied (%s).", authlist);
                 authctxt->method = method;
-
-                /* reset the per method handler */
-                dispatch_range(SSH2_MSG_USERAUTH_PER_METHOD_MIN,
-                    SSH2_MSG_USERAUTH_PER_METHOD_MAX, NULL);
-
-                /* and try new method */
                 if (method->userauth(authctxt) != 0) {
                         debug2("we sent a %s packet, wait for reply", method->name);
                         break;
@@ -361,7 +314,7 @@ input_userauth_banner(int type, u_int32_t seq, void *ctxt)
         debug3("input_userauth_banner");
         msg = packet_get_string(NULL);
         lang = packet_get_string(NULL);
-        logit("%s", msg);
+        fprintf(stderr, "%s", msg);
         xfree(msg);
         xfree(lang);
 }
@@ -374,8 +327,7 @@ input_userauth_success(int type, u_int32_t seq, void *ctxt)
                 fatal("input_userauth_success: no authentication context");
         if (authctxt->authlist)
                 xfree(authctxt->authlist);
-        if (authctxt->methoddata)
-                xfree(authctxt->methoddata);
+        clear_auth_state(authctxt);
         authctxt->success = 1;                  /* break out */
 }
 
@@ -394,9 +346,10 @@ input_userauth_failure(int type, u_int32_t seq, void *ctxt)
         packet_check_eom();
 
         if (partial != 0)
-                logit("Authenticated with partial success.");
+                log("Authenticated with partial success.");
         debug("Authentications that can continue: %s", authlist);
 
+        clear_auth_state(authctxt);
         userauth(authctxt, authlist);
 }
 void
@@ -404,7 +357,6 @@ input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
 {
         Authctxt *authctxt = ctxt;
         Key *key = NULL;
-        Identity *id = NULL;
         Buffer b;
         int pktype, sent = 0;
         u_int alen, blen;
@@ -427,267 +379,55 @@ input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
         }
         packet_check_eom();
 
-        debug("Server accepts key: pkalg %s blen %u", pkalg, blen);
-
-        if ((pktype = key_type_from_name(pkalg)) == KEY_UNSPEC) {
-                debug("unknown pkalg %s", pkalg);
-                goto done;
-        }
-        if ((key = key_from_blob(pkblob, blen)) == NULL) {
-                debug("no key from blob. pkalg %s", pkalg);
-                goto done;
-        }
-        if (key->type != pktype) {
-                error("input_userauth_pk_ok: type mismatch "
-                    "for decoded key (received %d, expected %d)",
-                    key->type, pktype);
-                goto done;
-        }
-        fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
-        debug2("input_userauth_pk_ok: fp %s", fp);
-        xfree(fp);
+        debug("Server accepts key: pkalg %s blen %u lastkey %p hint %d",
+            pkalg, blen, authctxt->last_key, authctxt->last_key_hint);
 
-        TAILQ_FOREACH(id, &authctxt->keys, next) {
-                if (key_equal(key, id->key)) {
-                        sent = sign_and_send_pubkey(authctxt, id);
+        do {
+                if (authctxt->last_key == NULL ||
+                    authctxt->last_key_sign == NULL) {
+                        debug("no last key or no sign cb");
                         break;
                 }
-        }
-done:
+                if ((pktype = key_type_from_name(pkalg)) == KEY_UNSPEC) {
+                        debug("unknown pkalg %s", pkalg);
+                        break;
+                }
+                if ((key = key_from_blob(pkblob, blen)) == NULL) {
+                        debug("no key from blob. pkalg %s", pkalg);
+                        break;
+                }
+                if (key->type != pktype) {
+                        error("input_userauth_pk_ok: type mismatch "
+                            "for decoded key (received %d, expected %d)",
+                            key->type, pktype);
+                        break;
+                }
+                fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
+                debug2("input_userauth_pk_ok: fp %s", fp);
+                xfree(fp);
+                if (!key_equal(key, authctxt->last_key)) {
+                        debug("key != last_key");
+                        break;
+                }
+                sent = sign_and_send_pubkey(authctxt, key,
+                   authctxt->last_key_sign);
+        } while (0);
+
         if (key != NULL)
                 key_free(key);
         xfree(pkalg);
         xfree(pkblob);
 
+        /* unregister */
+        clear_auth_state(authctxt);
+        dispatch_set(SSH2_MSG_USERAUTH_PK_OK, NULL);
+
         /* try another method if we did not send a packet */
         if (sent == 0)
                 userauth(authctxt, NULL);
-}
-
-#ifdef GSSAPI
-int 
-userauth_gssapi(Authctxt *authctxt)
-{
-        Gssctxt *gssctxt = NULL;
-        static gss_OID_set supported = NULL;
-        static int mech = 0;
-        OM_uint32 min;
-        int ok = 0;
-
-        /* Try one GSSAPI method at a time, rather than sending them all at
-         * once. */
-
-        if (supported == NULL)
-                gss_indicate_mechs(&min, &supported);
-
-        /* Check to see if the mechanism is usable before we offer it */
-        while (mech<supported->count && !ok) {
-                if (gssctxt)
-                        ssh_gssapi_delete_ctx(&gssctxt);
-                ssh_gssapi_build_ctx(&gssctxt);
-                ssh_gssapi_set_oid(gssctxt, &supported->elements[mech]);
-
-                /* My DER encoding requires length<128 */
-                if (supported->elements[mech].length < 128 &&
-                    !GSS_ERROR(ssh_gssapi_import_name(gssctxt,
-                    authctxt->host))) {
-                        ok = 1; /* Mechanism works */
-                } else {
-                        mech++;
-                }
-        }
-
-        if (!ok) return 0;
-
-        authctxt->methoddata=(void *)gssctxt;
-
-        packet_start(SSH2_MSG_USERAUTH_REQUEST);
-        packet_put_cstring(authctxt->server_user);
-        packet_put_cstring(authctxt->service);
-        packet_put_cstring(authctxt->method->name);
 
-        packet_put_int(1);
-
-        /* Some servers encode the OID incorrectly (as we used to) */
-        if (datafellows & SSH_BUG_GSSAPI_BER) {
-                packet_put_string(supported->elements[mech].elements,
-                    supported->elements[mech].length);
-        } else {
-                packet_put_int((supported->elements[mech].length)+2);
-                packet_put_char(SSH_GSS_OIDTYPE);
-                packet_put_char(supported->elements[mech].length);
-                packet_put_raw(supported->elements[mech].elements,
-                    supported->elements[mech].length);
-        }
-
-        packet_send();
-
-        dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_RESPONSE, &input_gssapi_response);
-        dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);
-        dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_ERROR, &input_gssapi_error);
-        dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);
-
-        mech++; /* Move along to next candidate */
-
-        return 1;
-}
-
-void
-input_gssapi_response(int type, u_int32_t plen, void *ctxt)
-{
-        Authctxt *authctxt = ctxt;
-        Gssctxt *gssctxt;
-        OM_uint32 status, ms;
-        int oidlen;
-        char *oidv;
-        gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
-
-        if (authctxt == NULL)
-                fatal("input_gssapi_response: no authentication context");
-        gssctxt = authctxt->methoddata;
-
-        /* Setup our OID */
-        oidv = packet_get_string(&oidlen);
-
-        if (datafellows & SSH_BUG_GSSAPI_BER) {
-                if (!ssh_gssapi_check_oid(gssctxt, oidv, oidlen))
-                        fatal("Server returned different OID than expected");
-        } else {
-                if(oidv[0] != SSH_GSS_OIDTYPE || oidv[1] != oidlen-2) {
-                        debug("Badly encoded mechanism OID received");
-                        userauth(authctxt, NULL);
-                        xfree(oidv);
-                        return;
-                }
-                if (!ssh_gssapi_check_oid(gssctxt, oidv+2, oidlen-2))
-                        fatal("Server returned different OID than expected");
-        }
-
-        packet_check_eom();
-
-        xfree(oidv);
-
-        status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
-            GSS_C_NO_BUFFER, &send_tok, NULL);
-        if (GSS_ERROR(status)) {
-                if (send_tok.length > 0) {
-                        packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);
-                        packet_put_string(send_tok.value, send_tok.length);
-                        packet_send();
-                        gss_release_buffer(&ms, &send_tok);
-                }
-                /* Start again with next method on list */
-                debug("Trying to start again");
-                userauth(authctxt, NULL);
-                return;
-        }
-
-        /* We must have data to send */
-        packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
-        packet_put_string(send_tok.value, send_tok.length);
-        packet_send();
-        gss_release_buffer(&ms, &send_tok);
 }
 
-void
-input_gssapi_token(int type, u_int32_t plen, void *ctxt)
-{
-        Authctxt *authctxt = ctxt;
-        Gssctxt *gssctxt;
-        gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
-        gss_buffer_desc recv_tok;
-        OM_uint32 status, ms;
-        u_int slen;
-
-        if (authctxt == NULL)
-                fatal("input_gssapi_response: no authentication context");
-        gssctxt = authctxt->methoddata;
-
-        recv_tok.value = packet_get_string(&slen);
-        recv_tok.length = slen; /* safe typecast */
-
-        packet_check_eom();
-
-        status=ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
-            &recv_tok, &send_tok, NULL);
-
-        xfree(recv_tok.value);
-
-        if (GSS_ERROR(status)) {
-                if (send_tok.length > 0) {
-                        packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);
-                        packet_put_string(send_tok.value, send_tok.length);
-                        packet_send();
-                        gss_release_buffer(&ms, &send_tok);
-                }
-                /* Start again with the next method in the list */
-                userauth(authctxt, NULL);
-                return;
-        }
-
-        if (send_tok.length > 0) {
-                packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
-                packet_put_string(send_tok.value, send_tok.length);
-                packet_send();
-                gss_release_buffer(&ms, &send_tok);
-        }
-
-        if (status == GSS_S_COMPLETE) {
-                /* If that succeeded, send a exchange complete message */
-                packet_start(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE);
-                packet_send();
-        }
-}
-
-void
-input_gssapi_errtok(int type, u_int32_t plen, void *ctxt)
-{
-        Authctxt *authctxt = ctxt;
-        Gssctxt *gssctxt;
-        gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
-        gss_buffer_desc recv_tok;
-        OM_uint32 status, ms;
-        u_int len;
-
-        if (authctxt == NULL)
-                fatal("input_gssapi_response: no authentication context");
-        gssctxt = authctxt->methoddata;
-
-        recv_tok.value = packet_get_string(&len);
-        recv_tok.length = len;
-
-        packet_check_eom();
-
-        /* Stick it into GSSAPI and see what it says */
-        status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
-                                     &recv_tok, &send_tok, NULL);
-
-        xfree(recv_tok.value);
-        gss_release_buffer(&ms, &send_tok);
-
-        /* Server will be returning a failed packet after this one */
-}
-
-void
-input_gssapi_error(int type, u_int32_t plen, void *ctxt)
-{
-        OM_uint32 maj, min;
-        char *msg;
-        char *lang;
-
-        maj=packet_get_int();
-        min=packet_get_int();
-        msg=packet_get_string(NULL);
-        lang=packet_get_string(NULL);
-
-        packet_check_eom();
-
-        debug("Server GSSAPI Error:\n%s\n", msg);
-        xfree(msg);
-        xfree(lang);
-}
-#endif /* GSSAPI */
-
 int
 userauth_none(Authctxt *authctxt)
 {
@@ -751,7 +491,7 @@ input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
         info = packet_get_string(NULL);
         lang = packet_get_string(NULL);
         if (strlen(info) > 0)
-                logit("%s", info);
+                log("%s", info);
         xfree(info);
         xfree(lang);
         packet_start(SSH2_MSG_USERAUTH_REQUEST);
@@ -783,7 +523,7 @@ input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
                 if (strcmp(password, retype) != 0) {
                         memset(password, 0, strlen(password));
                         xfree(password);
-                        logit("Mismatch; try again, EOF to quit.");
+                        log("Mismatch; try again, EOF to quit.");
                         password = NULL;
                 }
                 memset(retype, 0, strlen(retype));
@@ -799,44 +539,34 @@ input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
             &input_userauth_passwd_changereq);
 }
 
-static int
-identity_sign(Identity *id, u_char **sigp, u_int *lenp,
-    u_char *data, u_int datalen)
+static void
+clear_auth_state(Authctxt *authctxt)
 {
-        Key *prv;
-        int ret;
+        /* XXX clear authentication state */
+        dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ, NULL);
 
-        /* the agent supports this key */
-        if (id->ac)
-                return (ssh_agent_sign(id->ac, id->key, sigp, lenp,
-                    data, datalen));
-        /*
-         * we have already loaded the private key or
-         * the private key is stored in external hardware
-         */
-        if (id->isprivate || (id->key->flags & KEY_FLAG_EXT))
-                return (key_sign(id->key, sigp, lenp, data, datalen));
-        /* load the private key from the file */
-        if ((prv = load_identity_file(id->filename)) == NULL)
-                return (-1);
-        ret = key_sign(prv, sigp, lenp, data, datalen);
-        key_free(prv);
-        return (ret);
+        if (authctxt->last_key != NULL && authctxt->last_key_hint == -1) {
+                debug3("clear_auth_state: key_free %p", authctxt->last_key);
+                key_free(authctxt->last_key);
+        }
+        authctxt->last_key = NULL;
+        authctxt->last_key_hint = -2;
+        authctxt->last_key_sign = NULL;
 }
 
 static int
-sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
+sign_and_send_pubkey(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback)
 {
         Buffer b;
         u_char *blob, *signature;
         u_int bloblen, slen;
-        u_int skip = 0;
+        int skip = 0;
         int ret = -1;
         int have_sig = 1;
 
         debug3("sign_and_send_pubkey");
 
-        if (key_to_blob(id->key, &blob, &bloblen) == 0) {
+        if (key_to_blob(k, &blob, &bloblen) == 0) {
                 /* we cannot handle this key */
                 debug3("sign_and_send_pubkey: cannot handle key");
                 return 0;
@@ -861,12 +591,12 @@ sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
         } else {
                 buffer_put_cstring(&b, authctxt->method->name);
                 buffer_put_char(&b, have_sig);
-                buffer_put_cstring(&b, key_ssh_name(id->key));
+                buffer_put_cstring(&b, key_ssh_name(k));
         }
         buffer_put_string(&b, blob, bloblen);
 
         /* generate signature */
-        ret = identity_sign(id, &signature, &slen,
+        ret = (*sign_callback)(authctxt, k, &signature, &slen,
             buffer_ptr(&b), buffer_len(&b));
         if (ret == -1) {
                 xfree(blob);
@@ -886,7 +616,7 @@ sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
                 buffer_put_cstring(&b, authctxt->method->name);
                 buffer_put_char(&b, have_sig);
                 if (!(datafellows & SSH_BUG_PKAUTH))
-                        buffer_put_cstring(&b, key_ssh_name(id->key));
+                        buffer_put_cstring(&b, key_ssh_name(k));
                 buffer_put_string(&b, blob, bloblen);
         }
         xfree(blob);
@@ -910,19 +640,23 @@ sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
 }
 
 static int
-send_pubkey_test(Authctxt *authctxt, Identity *id)
+send_pubkey_test(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback,
+    int hint)
 {
         u_char *blob;
         u_int bloblen, have_sig = 0;
 
         debug3("send_pubkey_test");
 
-        if (key_to_blob(id->key, &blob, &bloblen) == 0) {
+        if (key_to_blob(k, &blob, &bloblen) == 0) {
                 /* we cannot handle this key */
                 debug3("send_pubkey_test: cannot handle key");
                 return 0;
         }
         /* register callback for USERAUTH_PK_OK message */
+        authctxt->last_key_sign = sign_callback;
+        authctxt->last_key_hint = hint;
+        authctxt->last_key = k;
         dispatch_set(SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);
 
         packet_start(SSH2_MSG_USERAUTH_REQUEST);
@@ -931,7 +665,7 @@ send_pubkey_test(Authctxt *authctxt, Identity *id)
         packet_put_cstring(authctxt->method->name);
         packet_put_char(have_sig);
         if (!(datafellows & SSH_BUG_PKAUTH))
-                packet_put_cstring(key_ssh_name(id->key));
+                packet_put_cstring(key_ssh_name(k));
         packet_put_string(blob, bloblen);
         xfree(blob);
         packet_send();
@@ -976,134 +710,103 @@ load_identity_file(char *filename)
         return private;
 }
 
-/*
- * try keys in the following order:
- *      1. agent keys that are found in the config file
- *      2. other agent keys
- *      3. keys that are only listed in the config file
- */
-static void
-pubkey_prepare(Authctxt *authctxt)
+static int
+identity_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
+    u_char *data, u_int datalen)
 {
-        Identity *id;
-        Idlist agent, files, *preferred;
-        Key *key;
-        AuthenticationConnection *ac;
-        char *comment;
-        int i, found;
-
-        TAILQ_INIT(&agent);     /* keys from the agent */
-        TAILQ_INIT(&files);     /* keys from the config file */
-        preferred = &authctxt->keys;
-        TAILQ_INIT(preferred);  /* preferred order of keys */
-
-        /* list of keys stored in the filesystem */
-        for (i = 0; i < options.num_identity_files; i++) {
-                key = options.identity_keys[i];
-                if (key && key->type == KEY_RSA1)
-                        continue;
-                options.identity_keys[i] = NULL;
-                id = xmalloc(sizeof(*id));
-                memset(id, 0, sizeof(*id));
-                id->key = key;
-                id->filename = xstrdup(options.identity_files[i]);
-                TAILQ_INSERT_TAIL(&files, id, next);
-        }
-        /* list of keys supported by the agent */
-        if ((ac = ssh_get_authentication_connection())) {
-                for (key = ssh_get_first_identity(ac, &comment, 2);
-                    key != NULL;
-                    key = ssh_get_next_identity(ac, &comment, 2)) {
-                        found = 0;
-                        TAILQ_FOREACH(id, &files, next) {
-                                /* agent keys from the config file are preferred */ 
-                                if (key_equal(key, id->key)) {
-                                        key_free(key);
-                                        xfree(comment);
-                                        TAILQ_REMOVE(&files, id, next);
-                                        TAILQ_INSERT_TAIL(preferred, id, next);
-                                        id->ac = ac;
-                                        found = 1;
-                                        break;
-                                }
-                        }
-                        if (!found) {
-                                id = xmalloc(sizeof(*id));
-                                memset(id, 0, sizeof(*id));
-                                id->key = key;
-                                id->filename = comment;
-                                id->ac = ac;
-                                TAILQ_INSERT_TAIL(&agent, id, next);
-                        }
-                }
-                /* append remaining agent keys */
-                for (id = TAILQ_FIRST(&agent); id; id = TAILQ_FIRST(&agent)) {
-                        TAILQ_REMOVE(&agent, id, next);
-                        TAILQ_INSERT_TAIL(preferred, id, next);
-                }
-                authctxt->agent = ac;
-        }
-        /* append remaining keys from the config file */
-        for (id = TAILQ_FIRST(&files); id; id = TAILQ_FIRST(&files)) {
-                TAILQ_REMOVE(&files, id, next);
-                TAILQ_INSERT_TAIL(preferred, id, next);
-        }
-        TAILQ_FOREACH(id, preferred, next) {
-                debug2("key: %s (%p)", id->filename, id->key);
-        }
+        Key *private;
+        int idx, ret;
+
+        idx = authctxt->last_key_hint;
+        if (idx < 0)
+                return -1;
+
+        /* private key is stored in external hardware */
+        if (options.identity_keys[idx]->flags & KEY_FLAG_EXT)
+                return key_sign(options.identity_keys[idx], sigp, lenp, data, datalen);
+
+        private = load_identity_file(options.identity_files[idx]);
+        if (private == NULL)
+                return -1;
+        ret = key_sign(private, sigp, lenp, data, datalen);
+        key_free(private);
+        return ret;
 }
 
-static void
-pubkey_cleanup(Authctxt *authctxt)
+static int
+agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
+    u_char *data, u_int datalen)
+{
+        return ssh_agent_sign(authctxt->agent, key, sigp, lenp, data, datalen);
+}
+
+static int
+key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, u_int *lenp,
+    u_char *data, u_int datalen)
 {
-        Identity *id;
-
-        if (authctxt->agent != NULL)
-                ssh_close_authentication_connection(authctxt->agent);
-        for (id = TAILQ_FIRST(&authctxt->keys); id;
-            id = TAILQ_FIRST(&authctxt->keys)) {
-                TAILQ_REMOVE(&authctxt->keys, id, next);
-                if (id->key)
-                        key_free(id->key);
-                if (id->filename)
-                        xfree(id->filename);
-                xfree(id);
+        return key_sign(key, sigp, lenp, data, datalen);
+}
+
+static int
+userauth_pubkey_agent(Authctxt *authctxt)
+{
+        static int called = 0;
+        int ret = 0;
+        char *comment;
+        Key *k;
+
+        if (called == 0) {
+                if (ssh_get_num_identities(authctxt->agent, 2) == 0)
+                        debug2("userauth_pubkey_agent: no keys at all");
+                called = 1;
+        }
+        k = ssh_get_next_identity(authctxt->agent, &comment, 2);
+        if (k == NULL) {
+                debug2("userauth_pubkey_agent: no more keys");
+        } else {
+                debug("Offering agent key: %s", comment);
+                xfree(comment);
+                ret = send_pubkey_test(authctxt, k, agent_sign_cb, -1);
+                if (ret == 0)
+                        key_free(k);
         }
+        if (ret == 0)
+                debug2("userauth_pubkey_agent: no message sent");
+        return ret;
 }
 
 int
 userauth_pubkey(Authctxt *authctxt)
 {
-        Identity *id;
+        static int idx = 0;
         int sent = 0;
+        Key *key;
+        char *filename;
 
-        while ((id = TAILQ_FIRST(&authctxt->keys))) {
-                if (id->tried++)
-                        return (0);
-                TAILQ_REMOVE(&authctxt->keys, id, next);
-                TAILQ_INSERT_TAIL(&authctxt->keys, id, next);
-                /*
-                 * send a test message if we have the public key. for
-                 * encrypted keys we cannot do this and have to load the
-                 * private key instead
-                 */
-                if (id->key && id->key->type != KEY_RSA1) {
-                        debug("Offering public key: %s", id->filename);
-                        sent = send_pubkey_test(authctxt, id);
-                } else if (id->key == NULL) {
-                        debug("Trying private key: %s", id->filename);
-                        id->key = load_identity_file(id->filename);
-                        if (id->key != NULL) {
-                                id->isprivate = 1;
-                                sent = sign_and_send_pubkey(authctxt, id);
-                                key_free(id->key);
-                                id->key = NULL;
+        if (authctxt->agent != NULL) {
+                do {
+                        sent = userauth_pubkey_agent(authctxt);
+                } while (!sent && authctxt->agent->howmany > 0);
+        }
+        while (!sent && idx < options.num_identity_files) {
+                key = options.identity_keys[idx];
+                filename = options.identity_files[idx];
+                if (key == NULL) {
+                        debug("Trying private key: %s", filename);
+                        key = load_identity_file(filename);
+                        if (key != NULL) {
+                                sent = sign_and_send_pubkey(authctxt, key,
+                                    key_sign_cb);
+                                key_free(key);
                         }
+                } else if (key->type != KEY_RSA1) {
+                        debug("Offering public key: %s", filename);
+                        sent = send_pubkey_test(authctxt, key,
+                            identity_sign_cb, idx);
                 }
-                if (sent)
-                        return (sent);
+                idx++;
         }
-        return (0);
+        return sent;
 }
 
 /*
@@ -1159,9 +862,9 @@ input_userauth_info_req(int type, u_int32_t seq, void *ctxt)
         inst = packet_get_string(NULL);
         lang = packet_get_string(NULL);
         if (strlen(name) > 0)
-                logit("%s", name);
+                log("%s", name);
         if (strlen(inst) > 0)
-                logit("%s", inst);
+                log("%s", inst);
         xfree(name);
         xfree(inst);
         xfree(lang);