1 /* $OpenBSD: sshconnect2.c,v 1.166 2008/07/17 08:48:00 djm Exp $ */
3 * Copyright (c) 2000 Markus Friedl. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 #include <sys/types.h>
29 #include <sys/socket.h>
41 #if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H)
45 #include "openbsd-compat/sys-queue.h"
56 #include "myproposal.h"
57 #include "sshconnect.h"
68 #include "pathnames.h"
76 extern char *client_version_string;
77 extern char *server_version_string;
78 extern Options options;
84 u_char *session_id2 = NULL;
85 u_int session_id2_len = 0;
88 struct sockaddr *xxx_hostaddr;
93 verify_host_key_callback(Key *hostkey)
95 if (verify_host_key(xxx_host, xxx_hostaddr, hostkey) == -1)
96 fatal("Host key verification failed.");
101 ssh_kex2(char *host, struct sockaddr *hostaddr)
106 xxx_hostaddr = hostaddr;
108 if (options.ciphers == (char *)-1) {
109 logit("No valid ciphers for protocol version 2 given, using defaults.");
110 options.ciphers = NULL;
112 if (options.ciphers != NULL) {
113 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
114 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
116 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
117 compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_CTOS]);
118 myproposal[PROPOSAL_ENC_ALGS_STOC] =
119 compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_STOC]);
120 if (options.compression) {
121 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
122 myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib@openssh.com,zlib,none";
124 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
125 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none,zlib@openssh.com,zlib";
127 if (options.macs != NULL) {
128 myproposal[PROPOSAL_MAC_ALGS_CTOS] =
129 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
131 if (options.hostkeyalgorithms != NULL)
132 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
133 options.hostkeyalgorithms;
135 if (options.rekey_limit)
136 packet_set_rekey_limit((u_int32_t)options.rekey_limit);
138 /* start key exchange */
139 kex = kex_setup(myproposal);
140 kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;
141 kex->kex[KEX_DH_GRP14_SHA1] = kexdh_client;
142 kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;
143 kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;
144 kex->client_version_string=client_version_string;
145 kex->server_version_string=server_version_string;
146 kex->verify_host_key=&verify_host_key_callback;
150 dispatch_run(DISPATCH_BLOCK, &kex->done, kex);
152 session_id2 = kex->session_id;
153 session_id2_len = kex->session_id_len;
156 /* send 1st encrypted/maced/compressed message */
157 packet_start(SSH2_MSG_IGNORE);
158 packet_put_cstring("markus");
168 typedef struct Authctxt Authctxt;
169 typedef struct Authmethod Authmethod;
170 typedef struct identity Identity;
171 typedef struct idlist Idlist;
174 TAILQ_ENTRY(identity) next;
175 AuthenticationConnection *ac; /* set if agent supports key */
176 Key *key; /* public/private key */
177 char *filename; /* comment for agent-only keys */
179 int isprivate; /* key points to the private key */
181 TAILQ_HEAD(idlist, identity);
184 const char *server_user;
185 const char *local_user;
193 AuthenticationConnection *agent;
195 Sensitive *sensitive;
196 /* kbd-interactive */
202 char *name; /* string to compare against server's list */
203 int (*userauth)(Authctxt *authctxt);
204 int *enabled; /* flag in option struct that enables method */
205 int *batch_flag; /* flag in option struct that disables method */
208 void input_userauth_success(int, u_int32_t, void *);
209 void input_userauth_failure(int, u_int32_t, void *);
210 void input_userauth_banner(int, u_int32_t, void *);
211 void input_userauth_error(int, u_int32_t, void *);
212 void input_userauth_info_req(int, u_int32_t, void *);
213 void input_userauth_pk_ok(int, u_int32_t, void *);
214 void input_userauth_passwd_changereq(int, u_int32_t, void *);
216 int userauth_none(Authctxt *);
217 int userauth_pubkey(Authctxt *);
218 int userauth_passwd(Authctxt *);
219 int userauth_kbdint(Authctxt *);
220 int userauth_hostbased(Authctxt *);
221 int userauth_kerberos(Authctxt *);
224 int userauth_gssapi(Authctxt *authctxt);
225 void input_gssapi_response(int type, u_int32_t, void *);
226 void input_gssapi_token(int type, u_int32_t, void *);
227 void input_gssapi_hash(int type, u_int32_t, void *);
228 void input_gssapi_error(int, u_int32_t, void *);
229 void input_gssapi_errtok(int, u_int32_t, void *);
232 void userauth(Authctxt *, char *);
234 static int sign_and_send_pubkey(Authctxt *, Identity *);
235 static void pubkey_prepare(Authctxt *);
236 static void pubkey_cleanup(Authctxt *);
237 static Key *load_identity_file(char *);
239 static Authmethod *authmethod_get(char *authlist);
240 static Authmethod *authmethod_lookup(const char *name);
241 static char *authmethods_get(void);
243 Authmethod authmethods[] = {
247 &options.gss_authentication,
252 &options.hostbased_authentication,
256 &options.pubkey_authentication,
258 {"keyboard-interactive",
260 &options.kbd_interactive_authentication,
261 &options.batch_mode},
264 &options.password_authentication,
265 &options.batch_mode},
270 {NULL, NULL, NULL, NULL}
274 ssh_userauth2(const char *local_user, const char *server_user, char *host,
275 Sensitive *sensitive)
280 if (options.challenge_response_authentication)
281 options.kbd_interactive_authentication = 1;
283 packet_start(SSH2_MSG_SERVICE_REQUEST);
284 packet_put_cstring("ssh-userauth");
286 debug("SSH2_MSG_SERVICE_REQUEST sent");
288 type = packet_read();
289 if (type != SSH2_MSG_SERVICE_ACCEPT)
290 fatal("Server denied authentication request: %d", type);
291 if (packet_remaining() > 0) {
292 char *reply = packet_get_string(NULL);
293 debug2("service_accept: %s", reply);
296 debug2("buggy server: service_accept w/o service");
299 debug("SSH2_MSG_SERVICE_ACCEPT received");
301 if (options.preferred_authentications == NULL)
302 options.preferred_authentications = authmethods_get();
304 /* setup authentication context */
305 memset(&authctxt, 0, sizeof(authctxt));
306 pubkey_prepare(&authctxt);
307 authctxt.server_user = server_user;
308 authctxt.local_user = local_user;
309 authctxt.host = host;
310 authctxt.service = "ssh-connection"; /* service name */
311 authctxt.success = 0;
312 authctxt.method = authmethod_lookup("none");
313 authctxt.authlist = NULL;
314 authctxt.methoddata = NULL;
315 authctxt.sensitive = sensitive;
316 authctxt.info_req_seen = 0;
317 if (authctxt.method == NULL)
318 fatal("ssh_userauth2: internal error: cannot send userauth none request");
320 /* initial userauth request */
321 userauth_none(&authctxt);
323 dispatch_init(&input_userauth_error);
324 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
325 dispatch_set(SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);
326 dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
327 dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt); /* loop until success */
329 pubkey_cleanup(&authctxt);
330 dispatch_range(SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);
332 debug("Authentication succeeded (%s).", authctxt.method->name);
336 userauth(Authctxt *authctxt, char *authlist)
338 if (authctxt->methoddata) {
339 xfree(authctxt->methoddata);
340 authctxt->methoddata = NULL;
342 if (authlist == NULL) {
343 authlist = authctxt->authlist;
345 if (authctxt->authlist)
346 xfree(authctxt->authlist);
347 authctxt->authlist = authlist;
350 Authmethod *method = authmethod_get(authlist);
352 fatal("Permission denied (%s).", authlist);
353 authctxt->method = method;
355 /* reset the per method handler */
356 dispatch_range(SSH2_MSG_USERAUTH_PER_METHOD_MIN,
357 SSH2_MSG_USERAUTH_PER_METHOD_MAX, NULL);
359 /* and try new method */
360 if (method->userauth(authctxt) != 0) {
361 debug2("we sent a %s packet, wait for reply", method->name);
364 debug2("we did not send a packet, disable method");
365 method->enabled = NULL;
371 input_userauth_error(int type, u_int32_t seq, void *ctxt)
373 fatal("input_userauth_error: bad message during authentication: "
378 input_userauth_banner(int type, u_int32_t seq, void *ctxt)
380 char *msg, *raw, *lang;
383 debug3("input_userauth_banner");
384 raw = packet_get_string(&len);
385 lang = packet_get_string(NULL);
386 if (options.log_level >= SYSLOG_LEVEL_INFO) {
389 msg = xmalloc(len * 4 + 1); /* max expansion from strnvis() */
390 strnvis(msg, raw, len * 4, VIS_SAFE|VIS_OCTAL);
392 fprintf(stderr, "%s", msg);
400 input_userauth_success(int type, u_int32_t seq, void *ctxt)
402 Authctxt *authctxt = ctxt;
403 if (authctxt == NULL)
404 fatal("input_userauth_success: no authentication context");
405 if (authctxt->authlist) {
406 xfree(authctxt->authlist);
407 authctxt->authlist = NULL;
409 if (authctxt->methoddata) {
410 xfree(authctxt->methoddata);
411 authctxt->methoddata = NULL;
413 authctxt->success = 1; /* break out */
417 input_userauth_failure(int type, u_int32_t seq, void *ctxt)
419 Authctxt *authctxt = ctxt;
420 char *authlist = NULL;
423 if (authctxt == NULL)
424 fatal("input_userauth_failure: no authentication context");
426 authlist = packet_get_string(NULL);
427 partial = packet_get_char();
431 logit("Authenticated with partial success.");
432 debug("Authentications that can continue: %s", authlist);
434 userauth(authctxt, authlist);
437 input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
439 Authctxt *authctxt = ctxt;
443 int pktype, sent = 0;
448 if (authctxt == NULL)
449 fatal("input_userauth_pk_ok: no authentication context");
450 if (datafellows & SSH_BUG_PKOK) {
451 /* this is similar to SSH_BUG_PKAUTH */
452 debug2("input_userauth_pk_ok: SSH_BUG_PKOK");
453 pkblob = packet_get_string(&blen);
455 buffer_append(&b, pkblob, blen);
456 pkalg = buffer_get_string(&b, &alen);
459 pkalg = packet_get_string(&alen);
460 pkblob = packet_get_string(&blen);
464 debug("Server accepts key: pkalg %s blen %u", pkalg, blen);
466 if ((pktype = key_type_from_name(pkalg)) == KEY_UNSPEC) {
467 debug("unknown pkalg %s", pkalg);
470 if ((key = key_from_blob(pkblob, blen)) == NULL) {
471 debug("no key from blob. pkalg %s", pkalg);
474 if (key->type != pktype) {
475 error("input_userauth_pk_ok: type mismatch "
476 "for decoded key (received %d, expected %d)",
480 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
481 debug2("input_userauth_pk_ok: fp %s", fp);
485 * search keys in the reverse order, because last candidate has been
486 * moved to the end of the queue. this also avoids confusion by
489 TAILQ_FOREACH_REVERSE(id, &authctxt->keys, idlist, next) {
490 if (key_equal(key, id->key)) {
491 sent = sign_and_send_pubkey(authctxt, id);
501 /* try another method if we did not send a packet */
503 userauth(authctxt, NULL);
508 userauth_gssapi(Authctxt *authctxt)
510 Gssctxt *gssctxt = NULL;
511 static gss_OID_set gss_supported = NULL;
512 static u_int mech = 0;
516 /* Try one GSSAPI method at a time, rather than sending them all at
519 if (gss_supported == NULL)
520 gss_indicate_mechs(&min, &gss_supported);
522 /* Check to see if the mechanism is usable before we offer it */
523 while (mech < gss_supported->count && !ok) {
524 /* My DER encoding requires length<128 */
525 if (gss_supported->elements[mech].length < 128 &&
526 ssh_gssapi_check_mechanism(&gssctxt,
527 &gss_supported->elements[mech], authctxt->host)) {
528 ok = 1; /* Mechanism works */
537 authctxt->methoddata=(void *)gssctxt;
539 packet_start(SSH2_MSG_USERAUTH_REQUEST);
540 packet_put_cstring(authctxt->server_user);
541 packet_put_cstring(authctxt->service);
542 packet_put_cstring(authctxt->method->name);
546 packet_put_int((gss_supported->elements[mech].length) + 2);
547 packet_put_char(SSH_GSS_OIDTYPE);
548 packet_put_char(gss_supported->elements[mech].length);
549 packet_put_raw(gss_supported->elements[mech].elements,
550 gss_supported->elements[mech].length);
554 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_RESPONSE, &input_gssapi_response);
555 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);
556 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_ERROR, &input_gssapi_error);
557 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);
559 mech++; /* Move along to next candidate */
565 process_gssapi_token(void *ctxt, gss_buffer_t recv_tok)
567 Authctxt *authctxt = ctxt;
568 Gssctxt *gssctxt = authctxt->methoddata;
569 gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
570 gss_buffer_desc mic = GSS_C_EMPTY_BUFFER;
571 gss_buffer_desc gssbuf;
572 OM_uint32 status, ms, flags;
575 status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
576 recv_tok, &send_tok, &flags);
578 if (send_tok.length > 0) {
579 if (GSS_ERROR(status))
580 packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);
582 packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
584 packet_put_string(send_tok.value, send_tok.length);
586 gss_release_buffer(&ms, &send_tok);
589 if (status == GSS_S_COMPLETE) {
590 /* send either complete or MIC, depending on mechanism */
591 if (!(flags & GSS_C_INTEG_FLAG)) {
592 packet_start(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE);
595 ssh_gssapi_buildmic(&b, authctxt->server_user,
596 authctxt->service, "gssapi-with-mic");
598 gssbuf.value = buffer_ptr(&b);
599 gssbuf.length = buffer_len(&b);
601 status = ssh_gssapi_sign(gssctxt, &gssbuf, &mic);
603 if (!GSS_ERROR(status)) {
604 packet_start(SSH2_MSG_USERAUTH_GSSAPI_MIC);
605 packet_put_string(mic.value, mic.length);
611 gss_release_buffer(&ms, &mic);
619 input_gssapi_response(int type, u_int32_t plen, void *ctxt)
621 Authctxt *authctxt = ctxt;
626 if (authctxt == NULL)
627 fatal("input_gssapi_response: no authentication context");
628 gssctxt = authctxt->methoddata;
631 oidv = packet_get_string(&oidlen);
634 oidv[0] != SSH_GSS_OIDTYPE ||
635 oidv[1] != oidlen - 2) {
637 debug("Badly encoded mechanism OID received");
638 userauth(authctxt, NULL);
642 if (!ssh_gssapi_check_oid(gssctxt, oidv + 2, oidlen - 2))
643 fatal("Server returned different OID than expected");
649 if (GSS_ERROR(process_gssapi_token(ctxt, GSS_C_NO_BUFFER))) {
650 /* Start again with next method on list */
651 debug("Trying to start again");
652 userauth(authctxt, NULL);
658 input_gssapi_token(int type, u_int32_t plen, void *ctxt)
660 Authctxt *authctxt = ctxt;
661 gss_buffer_desc recv_tok;
665 if (authctxt == NULL)
666 fatal("input_gssapi_response: no authentication context");
668 recv_tok.value = packet_get_string(&slen);
669 recv_tok.length = slen; /* safe typecast */
673 status = process_gssapi_token(ctxt, &recv_tok);
675 xfree(recv_tok.value);
677 if (GSS_ERROR(status)) {
678 /* Start again with the next method in the list */
679 userauth(authctxt, NULL);
685 input_gssapi_errtok(int type, u_int32_t plen, void *ctxt)
687 Authctxt *authctxt = ctxt;
689 gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
690 gss_buffer_desc recv_tok;
691 OM_uint32 status, ms;
694 if (authctxt == NULL)
695 fatal("input_gssapi_response: no authentication context");
696 gssctxt = authctxt->methoddata;
698 recv_tok.value = packet_get_string(&len);
699 recv_tok.length = len;
703 /* Stick it into GSSAPI and see what it says */
704 status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
705 &recv_tok, &send_tok, NULL);
707 xfree(recv_tok.value);
708 gss_release_buffer(&ms, &send_tok);
710 /* Server will be returning a failed packet after this one */
714 input_gssapi_error(int type, u_int32_t plen, void *ctxt)
720 maj=packet_get_int();
721 min=packet_get_int();
722 msg=packet_get_string(NULL);
723 lang=packet_get_string(NULL);
727 debug("Server GSSAPI Error:\n%s", msg);
734 userauth_none(Authctxt *authctxt)
736 /* initial userauth request */
737 packet_start(SSH2_MSG_USERAUTH_REQUEST);
738 packet_put_cstring(authctxt->server_user);
739 packet_put_cstring(authctxt->service);
740 packet_put_cstring(authctxt->method->name);
746 userauth_passwd(Authctxt *authctxt)
748 static int attempt = 0;
752 if (attempt++ >= options.number_of_password_prompts)
756 error("Permission denied, please try again.");
758 snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
759 authctxt->server_user, authctxt->host);
760 password = read_passphrase(prompt, 0);
761 packet_start(SSH2_MSG_USERAUTH_REQUEST);
762 packet_put_cstring(authctxt->server_user);
763 packet_put_cstring(authctxt->service);
764 packet_put_cstring(authctxt->method->name);
766 packet_put_cstring(password);
767 memset(password, 0, strlen(password));
769 packet_add_padding(64);
772 dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
773 &input_userauth_passwd_changereq);
778 * parse PASSWD_CHANGEREQ, prompt user and send SSH2_MSG_USERAUTH_REQUEST
781 input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
783 Authctxt *authctxt = ctxt;
784 char *info, *lang, *password = NULL, *retype = NULL;
787 debug2("input_userauth_passwd_changereq");
789 if (authctxt == NULL)
790 fatal("input_userauth_passwd_changereq: "
791 "no authentication context");
793 info = packet_get_string(NULL);
794 lang = packet_get_string(NULL);
795 if (strlen(info) > 0)
799 packet_start(SSH2_MSG_USERAUTH_REQUEST);
800 packet_put_cstring(authctxt->server_user);
801 packet_put_cstring(authctxt->service);
802 packet_put_cstring(authctxt->method->name);
803 packet_put_char(1); /* additional info */
804 snprintf(prompt, sizeof(prompt),
805 "Enter %.30s@%.128s's old password: ",
806 authctxt->server_user, authctxt->host);
807 password = read_passphrase(prompt, 0);
808 packet_put_cstring(password);
809 memset(password, 0, strlen(password));
812 while (password == NULL) {
813 snprintf(prompt, sizeof(prompt),
814 "Enter %.30s@%.128s's new password: ",
815 authctxt->server_user, authctxt->host);
816 password = read_passphrase(prompt, RP_ALLOW_EOF);
817 if (password == NULL) {
821 snprintf(prompt, sizeof(prompt),
822 "Retype %.30s@%.128s's new password: ",
823 authctxt->server_user, authctxt->host);
824 retype = read_passphrase(prompt, 0);
825 if (strcmp(password, retype) != 0) {
826 memset(password, 0, strlen(password));
828 logit("Mismatch; try again, EOF to quit.");
831 memset(retype, 0, strlen(retype));
834 packet_put_cstring(password);
835 memset(password, 0, strlen(password));
837 packet_add_padding(64);
840 dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
841 &input_userauth_passwd_changereq);
845 identity_sign(Identity *id, u_char **sigp, u_int *lenp,
846 u_char *data, u_int datalen)
851 /* the agent supports this key */
853 return (ssh_agent_sign(id->ac, id->key, sigp, lenp,
856 * we have already loaded the private key or
857 * the private key is stored in external hardware
859 if (id->isprivate || (id->key->flags & KEY_FLAG_EXT))
860 return (key_sign(id->key, sigp, lenp, data, datalen));
861 /* load the private key from the file */
862 if ((prv = load_identity_file(id->filename)) == NULL)
864 ret = key_sign(prv, sigp, lenp, data, datalen);
870 sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
873 u_char *blob, *signature;
879 debug3("sign_and_send_pubkey");
881 if (key_to_blob(id->key, &blob, &bloblen) == 0) {
882 /* we cannot handle this key */
883 debug3("sign_and_send_pubkey: cannot handle key");
886 /* data to be signed */
888 if (datafellows & SSH_OLD_SESSIONID) {
889 buffer_append(&b, session_id2, session_id2_len);
890 skip = session_id2_len;
892 buffer_put_string(&b, session_id2, session_id2_len);
893 skip = buffer_len(&b);
895 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
896 buffer_put_cstring(&b, authctxt->server_user);
897 buffer_put_cstring(&b,
898 datafellows & SSH_BUG_PKSERVICE ?
901 if (datafellows & SSH_BUG_PKAUTH) {
902 buffer_put_char(&b, have_sig);
904 buffer_put_cstring(&b, authctxt->method->name);
905 buffer_put_char(&b, have_sig);
906 buffer_put_cstring(&b, key_ssh_name(id->key));
908 buffer_put_string(&b, blob, bloblen);
910 /* generate signature */
911 ret = identity_sign(id, &signature, &slen,
912 buffer_ptr(&b), buffer_len(&b));
921 if (datafellows & SSH_BUG_PKSERVICE) {
923 buffer_append(&b, session_id2, session_id2_len);
924 skip = session_id2_len;
925 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
926 buffer_put_cstring(&b, authctxt->server_user);
927 buffer_put_cstring(&b, authctxt->service);
928 buffer_put_cstring(&b, authctxt->method->name);
929 buffer_put_char(&b, have_sig);
930 if (!(datafellows & SSH_BUG_PKAUTH))
931 buffer_put_cstring(&b, key_ssh_name(id->key));
932 buffer_put_string(&b, blob, bloblen);
936 /* append signature */
937 buffer_put_string(&b, signature, slen);
940 /* skip session id and packet type */
941 if (buffer_len(&b) < skip + 1)
942 fatal("userauth_pubkey: internal error");
943 buffer_consume(&b, skip + 1);
945 /* put remaining data from buffer into packet */
946 packet_start(SSH2_MSG_USERAUTH_REQUEST);
947 packet_put_raw(buffer_ptr(&b), buffer_len(&b));
955 send_pubkey_test(Authctxt *authctxt, Identity *id)
958 u_int bloblen, have_sig = 0;
960 debug3("send_pubkey_test");
962 if (key_to_blob(id->key, &blob, &bloblen) == 0) {
963 /* we cannot handle this key */
964 debug3("send_pubkey_test: cannot handle key");
967 /* register callback for USERAUTH_PK_OK message */
968 dispatch_set(SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);
970 packet_start(SSH2_MSG_USERAUTH_REQUEST);
971 packet_put_cstring(authctxt->server_user);
972 packet_put_cstring(authctxt->service);
973 packet_put_cstring(authctxt->method->name);
974 packet_put_char(have_sig);
975 if (!(datafellows & SSH_BUG_PKAUTH))
976 packet_put_cstring(key_ssh_name(id->key));
977 packet_put_string(blob, bloblen);
984 load_identity_file(char *filename)
987 char prompt[300], *passphrase;
988 int perm_ok, quit, i;
991 if (stat(filename, &st) < 0) {
992 debug3("no such identity: %s", filename);
995 private = key_load_private_type(KEY_UNSPEC, filename, "", NULL, &perm_ok);
998 if (private == NULL) {
999 if (options.batch_mode)
1001 snprintf(prompt, sizeof prompt,
1002 "Enter passphrase for key '%.100s': ", filename);
1003 for (i = 0; i < options.number_of_password_prompts; i++) {
1004 passphrase = read_passphrase(prompt, 0);
1005 if (strcmp(passphrase, "") != 0) {
1006 private = key_load_private_type(KEY_UNSPEC,
1007 filename, passphrase, NULL, NULL);
1010 debug2("no passphrase given, try next key");
1013 memset(passphrase, 0, strlen(passphrase));
1015 if (private != NULL || quit)
1017 debug2("bad passphrase given, try again...");
1024 * try keys in the following order:
1025 * 1. agent keys that are found in the config file
1026 * 2. other agent keys
1027 * 3. keys that are only listed in the config file
1030 pubkey_prepare(Authctxt *authctxt)
1033 Idlist agent, files, *preferred;
1035 AuthenticationConnection *ac;
1039 TAILQ_INIT(&agent); /* keys from the agent */
1040 TAILQ_INIT(&files); /* keys from the config file */
1041 preferred = &authctxt->keys;
1042 TAILQ_INIT(preferred); /* preferred order of keys */
1044 /* list of keys stored in the filesystem */
1045 for (i = 0; i < options.num_identity_files; i++) {
1046 key = options.identity_keys[i];
1047 if (key && key->type == KEY_RSA1)
1049 options.identity_keys[i] = NULL;
1050 id = xcalloc(1, sizeof(*id));
1052 id->filename = xstrdup(options.identity_files[i]);
1053 TAILQ_INSERT_TAIL(&files, id, next);
1055 /* list of keys supported by the agent */
1056 if ((ac = ssh_get_authentication_connection())) {
1057 for (key = ssh_get_first_identity(ac, &comment, 2);
1059 key = ssh_get_next_identity(ac, &comment, 2)) {
1061 TAILQ_FOREACH(id, &files, next) {
1062 /* agent keys from the config file are preferred */
1063 if (key_equal(key, id->key)) {
1066 TAILQ_REMOVE(&files, id, next);
1067 TAILQ_INSERT_TAIL(preferred, id, next);
1073 if (!found && !options.identities_only) {
1074 id = xcalloc(1, sizeof(*id));
1076 id->filename = comment;
1078 TAILQ_INSERT_TAIL(&agent, id, next);
1081 /* append remaining agent keys */
1082 for (id = TAILQ_FIRST(&agent); id; id = TAILQ_FIRST(&agent)) {
1083 TAILQ_REMOVE(&agent, id, next);
1084 TAILQ_INSERT_TAIL(preferred, id, next);
1086 authctxt->agent = ac;
1088 /* append remaining keys from the config file */
1089 for (id = TAILQ_FIRST(&files); id; id = TAILQ_FIRST(&files)) {
1090 TAILQ_REMOVE(&files, id, next);
1091 TAILQ_INSERT_TAIL(preferred, id, next);
1093 TAILQ_FOREACH(id, preferred, next) {
1094 debug2("key: %s (%p)", id->filename, id->key);
1099 pubkey_cleanup(Authctxt *authctxt)
1103 if (authctxt->agent != NULL)
1104 ssh_close_authentication_connection(authctxt->agent);
1105 for (id = TAILQ_FIRST(&authctxt->keys); id;
1106 id = TAILQ_FIRST(&authctxt->keys)) {
1107 TAILQ_REMOVE(&authctxt->keys, id, next);
1111 xfree(id->filename);
1117 userauth_pubkey(Authctxt *authctxt)
1122 while ((id = TAILQ_FIRST(&authctxt->keys))) {
1125 /* move key to the end of the queue */
1126 TAILQ_REMOVE(&authctxt->keys, id, next);
1127 TAILQ_INSERT_TAIL(&authctxt->keys, id, next);
1129 * send a test message if we have the public key. for
1130 * encrypted keys we cannot do this and have to load the
1131 * private key instead
1133 if (id->key && id->key->type != KEY_RSA1) {
1134 debug("Offering public key: %s", id->filename);
1135 sent = send_pubkey_test(authctxt, id);
1136 } else if (id->key == NULL) {
1137 debug("Trying private key: %s", id->filename);
1138 id->key = load_identity_file(id->filename);
1139 if (id->key != NULL) {
1141 sent = sign_and_send_pubkey(authctxt, id);
1153 * Send userauth request message specifying keyboard-interactive method.
1156 userauth_kbdint(Authctxt *authctxt)
1158 static int attempt = 0;
1160 if (attempt++ >= options.number_of_password_prompts)
1162 /* disable if no SSH2_MSG_USERAUTH_INFO_REQUEST has been seen */
1163 if (attempt > 1 && !authctxt->info_req_seen) {
1164 debug3("userauth_kbdint: disable: no info_req_seen");
1165 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);
1169 debug2("userauth_kbdint");
1170 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1171 packet_put_cstring(authctxt->server_user);
1172 packet_put_cstring(authctxt->service);
1173 packet_put_cstring(authctxt->method->name);
1174 packet_put_cstring(""); /* lang */
1175 packet_put_cstring(options.kbd_interactive_devices ?
1176 options.kbd_interactive_devices : "");
1179 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);
1184 * parse INFO_REQUEST, prompt user and send INFO_RESPONSE
1187 input_userauth_info_req(int type, u_int32_t seq, void *ctxt)
1189 Authctxt *authctxt = ctxt;
1190 char *name, *inst, *lang, *prompt, *response;
1191 u_int num_prompts, i;
1194 debug2("input_userauth_info_req");
1196 if (authctxt == NULL)
1197 fatal("input_userauth_info_req: no authentication context");
1199 authctxt->info_req_seen = 1;
1201 name = packet_get_string(NULL);
1202 inst = packet_get_string(NULL);
1203 lang = packet_get_string(NULL);
1204 if (strlen(name) > 0)
1206 if (strlen(inst) > 0)
1212 num_prompts = packet_get_int();
1214 * Begin to build info response packet based on prompts requested.
1215 * We commit to providing the correct number of responses, so if
1216 * further on we run into a problem that prevents this, we have to
1217 * be sure and clean this up and send a correct error response.
1219 packet_start(SSH2_MSG_USERAUTH_INFO_RESPONSE);
1220 packet_put_int(num_prompts);
1222 debug2("input_userauth_info_req: num_prompts %d", num_prompts);
1223 for (i = 0; i < num_prompts; i++) {
1224 prompt = packet_get_string(NULL);
1225 echo = packet_get_char();
1227 response = read_passphrase(prompt, echo ? RP_ECHO : 0);
1229 packet_put_cstring(response);
1230 memset(response, 0, strlen(response));
1234 packet_check_eom(); /* done with parsing incoming message. */
1236 packet_add_padding(64);
1241 ssh_keysign(Key *key, u_char **sigp, u_int *lenp,
1242 u_char *data, u_int datalen)
1247 int to[2], from[2], status, version = 2;
1249 debug2("ssh_keysign called");
1251 if (stat(_PATH_SSH_KEY_SIGN, &st) < 0) {
1252 error("ssh_keysign: no installed: %s", strerror(errno));
1255 if (fflush(stdout) != 0)
1256 error("ssh_keysign: fflush: %s", strerror(errno));
1258 error("ssh_keysign: pipe: %s", strerror(errno));
1261 if (pipe(from) < 0) {
1262 error("ssh_keysign: pipe: %s", strerror(errno));
1265 if ((pid = fork()) < 0) {
1266 error("ssh_keysign: fork: %s", strerror(errno));
1270 permanently_drop_suid(getuid());
1272 if (dup2(from[1], STDOUT_FILENO) < 0)
1273 fatal("ssh_keysign: dup2: %s", strerror(errno));
1275 if (dup2(to[0], STDIN_FILENO) < 0)
1276 fatal("ssh_keysign: dup2: %s", strerror(errno));
1279 execl(_PATH_SSH_KEY_SIGN, _PATH_SSH_KEY_SIGN, (char *) 0);
1280 fatal("ssh_keysign: exec(%s): %s", _PATH_SSH_KEY_SIGN,
1287 buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */
1288 buffer_put_string(&b, data, datalen);
1289 if (ssh_msg_send(to[1], version, &b) == -1)
1290 fatal("ssh_keysign: couldn't send request");
1292 if (ssh_msg_recv(from[0], &b) < 0) {
1293 error("ssh_keysign: no reply");
1300 while (waitpid(pid, &status, 0) < 0)
1304 if (buffer_get_char(&b) != version) {
1305 error("ssh_keysign: bad version");
1309 *sigp = buffer_get_string(&b, lenp);
1316 userauth_hostbased(Authctxt *authctxt)
1318 Key *private = NULL;
1319 Sensitive *sensitive = authctxt->sensitive;
1321 u_char *signature, *blob;
1322 char *chost, *pkalg, *p, myname[NI_MAXHOST];
1323 const char *service;
1325 int ok, i, len, found = 0;
1327 /* check for a useful key */
1328 for (i = 0; i < sensitive->nkeys; i++) {
1329 private = sensitive->keys[i];
1330 if (private && private->type != KEY_RSA1) {
1332 /* we take and free the key */
1333 sensitive->keys[i] = NULL;
1338 debug("No more client hostkeys for hostbased authentication.");
1341 if (key_to_blob(private, &blob, &blen) == 0) {
1345 /* figure out a name for the client host */
1347 if (packet_connection_is_on_socket())
1348 p = get_local_name(packet_get_connection_in());
1350 if (gethostname(myname, sizeof(myname)) == -1) {
1351 verbose("userauth_hostbased: gethostname: %s",
1354 p = xstrdup(myname);
1357 error("userauth_hostbased: cannot get local ipaddr/name");
1362 len = strlen(p) + 2;
1363 xasprintf(&chost, "%s.", p);
1364 debug2("userauth_hostbased: chost %s", chost);
1367 service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :
1369 pkalg = xstrdup(key_ssh_name(private));
1371 /* construct data */
1372 buffer_put_string(&b, session_id2, session_id2_len);
1373 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
1374 buffer_put_cstring(&b, authctxt->server_user);
1375 buffer_put_cstring(&b, service);
1376 buffer_put_cstring(&b, authctxt->method->name);
1377 buffer_put_cstring(&b, pkalg);
1378 buffer_put_string(&b, blob, blen);
1379 buffer_put_cstring(&b, chost);
1380 buffer_put_cstring(&b, authctxt->local_user);
1384 if (sensitive->external_keysign)
1385 ok = ssh_keysign(private, &signature, &slen,
1386 buffer_ptr(&b), buffer_len(&b));
1388 ok = key_sign(private, &signature, &slen,
1389 buffer_ptr(&b), buffer_len(&b));
1393 error("key_sign failed");
1399 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1400 packet_put_cstring(authctxt->server_user);
1401 packet_put_cstring(authctxt->service);
1402 packet_put_cstring(authctxt->method->name);
1403 packet_put_cstring(pkalg);
1404 packet_put_string(blob, blen);
1405 packet_put_cstring(chost);
1406 packet_put_cstring(authctxt->local_user);
1407 packet_put_string(signature, slen);
1408 memset(signature, 's', slen);
1418 /* find auth method */
1421 * given auth method name, if configurable options permit this method fill
1422 * in auth_ident field and return true, otherwise return false.
1425 authmethod_is_enabled(Authmethod *method)
1429 /* return false if options indicate this method is disabled */
1430 if (method->enabled == NULL || *method->enabled == 0)
1432 /* return false if batch mode is enabled but method needs interactive mode */
1433 if (method->batch_flag != NULL && *method->batch_flag != 0)
1439 authmethod_lookup(const char *name)
1441 Authmethod *method = NULL;
1443 for (method = authmethods; method->name != NULL; method++)
1444 if (strcmp(name, method->name) == 0)
1446 debug2("Unrecognized authentication method name: %s", name ? name : "NULL");
1450 /* XXX internal state */
1451 static Authmethod *current = NULL;
1452 static char *supported = NULL;
1453 static char *preferred = NULL;
1456 * Given the authentication method list sent by the server, return the
1457 * next method we should try. If the server initially sends a nil list,
1458 * use a built-in default list.
1461 authmethod_get(char *authlist)
1466 /* Use a suitable default if we're passed a nil list. */
1467 if (authlist == NULL || strlen(authlist) == 0)
1468 authlist = options.preferred_authentications;
1470 if (supported == NULL || strcmp(authlist, supported) != 0) {
1471 debug3("start over, passed a different list %s", authlist);
1472 if (supported != NULL)
1474 supported = xstrdup(authlist);
1475 preferred = options.preferred_authentications;
1476 debug3("preferred %s", preferred);
1478 } else if (current != NULL && authmethod_is_enabled(current))
1482 if ((name = match_list(preferred, supported, &next)) == NULL) {
1483 debug("No more authentication methods to try.");
1488 debug3("authmethod_lookup %s", name);
1489 debug3("remaining preferred: %s", preferred);
1490 if ((current = authmethod_lookup(name)) != NULL &&
1491 authmethod_is_enabled(current)) {
1492 debug3("authmethod_is_enabled %s", name);
1493 debug("Next authentication method: %s", name);
1500 authmethods_get(void)
1502 Authmethod *method = NULL;
1507 for (method = authmethods; method->name != NULL; method++) {
1508 if (authmethod_is_enabled(method)) {
1509 if (buffer_len(&b) > 0)
1510 buffer_append(&b, ",", 1);
1511 buffer_append(&b, method->name, strlen(method->name));
1514 buffer_append(&b, "\0", 1);
1515 list = xstrdup(buffer_ptr(&b));