blob: 1e0e9d5e10e1fcb587db9d98b75ce5d94b30ea6f [file] [log] [blame]
Darren Tucker2f29a8c2009-10-24 11:47:58 +11001/* $OpenBSD: sshconnect2.c,v 1.172 2009/10/23 01:57:11 djm Exp $ */
Damien Millereba71ba2000-04-29 23:57:08 +10002/*
3 * Copyright (c) 2000 Markus Friedl. All rights reserved.
Damien Miller01ed2272008-11-05 16:20:46 +11004 * Copyright (c) 2008 Damien Miller. All rights reserved.
Damien Millereba71ba2000-04-29 23:57:08 +10005 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
Damien Millereba71ba2000-04-29 23:57:08 +100014 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#include "includes.h"
Damien Miller2eb63402006-03-15 11:09:42 +110028
Damien Miller9cf6d072006-03-15 11:29:24 +110029#include <sys/types.h>
Damien Millerd7834352006-08-05 12:39:39 +100030#include <sys/socket.h>
Damien Miller9cf6d072006-03-15 11:29:24 +110031#include <sys/wait.h>
Damien Millerf17883e2006-03-15 11:45:54 +110032#include <sys/stat.h>
Damien Millereba71ba2000-04-29 23:57:08 +100033
Darren Tucker39972492006-07-12 22:22:46 +100034#include <errno.h>
Darren Tuckerf520ea12007-05-20 15:11:33 +100035#include <netdb.h>
Damien Millerd7834352006-08-05 12:39:39 +100036#include <pwd.h>
37#include <signal.h>
Damien Millerded319c2006-09-01 15:38:36 +100038#include <stdarg.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100039#include <stdio.h>
Damien Millere3476ed2006-07-24 14:13:33 +100040#include <string.h>
Damien Miller1cdde6f2006-07-24 14:07:35 +100041#include <unistd.h>
Damien Miller2e28d862008-07-17 19:15:43 +100042#if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H)
Damien Miller7ba0ca72008-07-17 18:57:06 +100043#include <vis.h>
Damien Miller2e28d862008-07-17 19:15:43 +100044#endif
Darren Tucker39972492006-07-12 22:22:46 +100045
Damien Miller9c617692003-05-14 14:31:11 +100046#include "openbsd-compat/sys-queue.h"
47
Damien Millerd7834352006-08-05 12:39:39 +100048#include "xmalloc.h"
Damien Millereba71ba2000-04-29 23:57:08 +100049#include "ssh.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000050#include "ssh2.h"
Damien Millereba71ba2000-04-29 23:57:08 +100051#include "buffer.h"
52#include "packet.h"
Damien Millereba71ba2000-04-29 23:57:08 +100053#include "compat.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000054#include "cipher.h"
Damien Millerd7834352006-08-05 12:39:39 +100055#include "key.h"
Damien Millereba71ba2000-04-29 23:57:08 +100056#include "kex.h"
57#include "myproposal.h"
Damien Millereba71ba2000-04-29 23:57:08 +100058#include "sshconnect.h"
59#include "authfile.h"
Ben Lindstromdf221392001-03-29 00:36:16 +000060#include "dh.h"
Damien Millerad833b32000-08-23 10:46:23 +100061#include "authfd.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000062#include "log.h"
63#include "readconf.h"
Darren Tuckere608ca22004-05-13 16:15:47 +100064#include "misc.h"
Ben Lindstromb9be60a2001-03-11 01:49:19 +000065#include "match.h"
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000066#include "dispatch.h"
Ben Lindstrom5eabda32001-04-12 23:34:34 +000067#include "canohost.h"
Ben Lindstrom1bad2562002-06-06 19:57:33 +000068#include "msg.h"
69#include "pathnames.h"
Damien Miller6b4069a2006-06-13 13:05:15 +100070#include "uidswap.h"
Damien Millercee85232009-03-06 00:58:22 +110071#include "schnorr.h"
Damien Miller01ed2272008-11-05 16:20:46 +110072#include "jpake.h"
Damien Miller874d77b2000-10-14 16:23:11 +110073
Darren Tucker0efd1552003-08-26 11:49:55 +100074#ifdef GSSAPI
75#include "ssh-gss.h"
76#endif
77
Damien Millereba71ba2000-04-29 23:57:08 +100078/* import */
79extern char *client_version_string;
80extern char *server_version_string;
81extern Options options;
82
83/*
84 * SSH2 key exchange
85 */
86
Ben Lindstrom46c16222000-12-22 01:43:59 +000087u_char *session_id2 = NULL;
Darren Tucker502d3842003-06-28 12:38:01 +100088u_int session_id2_len = 0;
Damien Millereba71ba2000-04-29 23:57:08 +100089
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000090char *xxx_host;
91struct sockaddr *xxx_hostaddr;
92
Ben Lindstromf28f6342001-04-04 02:03:04 +000093Kex *xxx_kex = NULL;
94
Ben Lindstrombba81212001-06-25 05:01:22 +000095static int
Ben Lindstromd6481ea2001-06-25 04:37:41 +000096verify_host_key_callback(Key *hostkey)
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000097{
Ben Lindstromd6481ea2001-06-25 04:37:41 +000098 if (verify_host_key(xxx_host, xxx_hostaddr, hostkey) == -1)
Damien Miller59d9fb92001-10-10 15:03:11 +100099 fatal("Host key verification failed.");
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +0000100 return 0;
101}
102
Damien Millereba71ba2000-04-29 23:57:08 +1000103void
Damien Miller874d77b2000-10-14 16:23:11 +1100104ssh_kex2(char *host, struct sockaddr *hostaddr)
105{
Damien Miller874d77b2000-10-14 16:23:11 +1100106 Kex *kex;
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +0000107
108 xxx_host = host;
109 xxx_hostaddr = hostaddr;
Damien Miller874d77b2000-10-14 16:23:11 +1100110
Damien Millere39cacc2000-11-29 12:18:44 +1100111 if (options.ciphers == (char *)-1) {
Damien Miller996acd22003-04-09 20:59:48 +1000112 logit("No valid ciphers for protocol version 2 given, using defaults.");
Damien Millere39cacc2000-11-29 12:18:44 +1100113 options.ciphers = NULL;
Damien Miller874d77b2000-10-14 16:23:11 +1100114 }
115 if (options.ciphers != NULL) {
116 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
117 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
118 }
Damien Millera0ff4662001-03-30 10:49:35 +1000119 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
120 compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_CTOS]);
121 myproposal[PROPOSAL_ENC_ALGS_STOC] =
122 compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_STOC]);
Damien Miller874d77b2000-10-14 16:23:11 +1100123 if (options.compression) {
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000124 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
Damien Miller9786e6e2005-07-26 21:54:56 +1000125 myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib@openssh.com,zlib,none";
Damien Miller874d77b2000-10-14 16:23:11 +1100126 } else {
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000127 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
Damien Miller9786e6e2005-07-26 21:54:56 +1000128 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none,zlib@openssh.com,zlib";
Damien Miller874d77b2000-10-14 16:23:11 +1100129 }
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000130 if (options.macs != NULL) {
131 myproposal[PROPOSAL_MAC_ALGS_CTOS] =
132 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
133 }
Ben Lindstrom982dbbc2001-04-17 18:11:36 +0000134 if (options.hostkeyalgorithms != NULL)
Damien Miller9f0f5c62001-12-21 14:45:46 +1100135 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
Ben Lindstrom982dbbc2001-04-17 18:11:36 +0000136 options.hostkeyalgorithms;
Damien Miller874d77b2000-10-14 16:23:11 +1100137
Damien Millera5539d22003-04-09 20:50:06 +1000138 if (options.rekey_limit)
Damien Miller3dff1762008-02-10 22:25:52 +1100139 packet_set_rekey_limit((u_int32_t)options.rekey_limit);
Damien Millera5539d22003-04-09 20:50:06 +1000140
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000141 /* start key exchange */
Ben Lindstrom238abf62001-04-04 17:52:53 +0000142 kex = kex_setup(myproposal);
Damien Miller8e7fb332003-02-24 12:03:03 +1100143 kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;
Damien Millerf675fc42004-06-15 10:30:09 +1000144 kex->kex[KEX_DH_GRP14_SHA1] = kexdh_client;
Damien Miller8e7fb332003-02-24 12:03:03 +1100145 kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;
Damien Millera63128d2006-03-15 12:08:28 +1100146 kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +0000147 kex->client_version_string=client_version_string;
148 kex->server_version_string=server_version_string;
Ben Lindstromd6481ea2001-06-25 04:37:41 +0000149 kex->verify_host_key=&verify_host_key_callback;
Damien Miller874d77b2000-10-14 16:23:11 +1100150
Ben Lindstromf28f6342001-04-04 02:03:04 +0000151 xxx_kex = kex;
152
Ben Lindstrombe2cc432001-04-04 23:46:07 +0000153 dispatch_run(DISPATCH_BLOCK, &kex->done, kex);
Damien Miller874d77b2000-10-14 16:23:11 +1100154
Ben Lindstrom2d90e002001-04-04 02:00:54 +0000155 session_id2 = kex->session_id;
156 session_id2_len = kex->session_id_len;
157
Damien Miller874d77b2000-10-14 16:23:11 +1100158#ifdef DEBUG_KEXDH
159 /* send 1st encrypted/maced/compressed message */
160 packet_start(SSH2_MSG_IGNORE);
161 packet_put_cstring("markus");
162 packet_send();
163 packet_write_wait();
164#endif
Damien Millereba71ba2000-04-29 23:57:08 +1000165}
Damien Millerb1715dc2000-05-30 13:44:51 +1000166
Damien Millereba71ba2000-04-29 23:57:08 +1000167/*
168 * Authenticate user
169 */
Damien Miller62cee002000-09-23 17:15:56 +1100170
171typedef struct Authctxt Authctxt;
172typedef struct Authmethod Authmethod;
Damien Miller280ecfb2003-05-14 13:46:00 +1000173typedef struct identity Identity;
174typedef struct idlist Idlist;
Damien Miller62cee002000-09-23 17:15:56 +1100175
Damien Miller280ecfb2003-05-14 13:46:00 +1000176struct identity {
177 TAILQ_ENTRY(identity) next;
178 AuthenticationConnection *ac; /* set if agent supports key */
179 Key *key; /* public/private key */
180 char *filename; /* comment for agent-only keys */
181 int tried;
182 int isprivate; /* key points to the private key */
183};
184TAILQ_HEAD(idlist, identity);
Damien Miller62cee002000-09-23 17:15:56 +1100185
186struct Authctxt {
187 const char *server_user;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000188 const char *local_user;
Damien Miller62cee002000-09-23 17:15:56 +1100189 const char *host;
190 const char *service;
Damien Miller62cee002000-09-23 17:15:56 +1100191 Authmethod *method;
Damien Miller874d77b2000-10-14 16:23:11 +1100192 int success;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000193 char *authlist;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000194 /* pubkey */
Damien Miller280ecfb2003-05-14 13:46:00 +1000195 Idlist keys;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000196 AuthenticationConnection *agent;
197 /* hostbased */
Ben Lindstrom1bad2562002-06-06 19:57:33 +0000198 Sensitive *sensitive;
Ben Lindstrom7d199962001-09-12 18:29:00 +0000199 /* kbd-interactive */
200 int info_req_seen;
Darren Tucker0efd1552003-08-26 11:49:55 +1000201 /* generic */
202 void *methoddata;
Damien Miller62cee002000-09-23 17:15:56 +1100203};
204struct Authmethod {
205 char *name; /* string to compare against server's list */
206 int (*userauth)(Authctxt *authctxt);
Damien Miller01ed2272008-11-05 16:20:46 +1100207 void (*cleanup)(Authctxt *authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100208 int *enabled; /* flag in option struct that enables method */
209 int *batch_flag; /* flag in option struct that disables method */
210};
211
Damien Miller630d6f42002-01-22 23:17:30 +1100212void input_userauth_success(int, u_int32_t, void *);
Darren Tucker2f29a8c2009-10-24 11:47:58 +1100213void input_userauth_success_unexpected(int, u_int32_t, void *);
Damien Miller630d6f42002-01-22 23:17:30 +1100214void input_userauth_failure(int, u_int32_t, void *);
215void input_userauth_banner(int, u_int32_t, void *);
216void input_userauth_error(int, u_int32_t, void *);
217void input_userauth_info_req(int, u_int32_t, void *);
218void input_userauth_pk_ok(int, u_int32_t, void *);
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000219void input_userauth_passwd_changereq(int, u_int32_t, void *);
Damien Miller01ed2272008-11-05 16:20:46 +1100220void input_userauth_jpake_server_step1(int, u_int32_t, void *);
221void input_userauth_jpake_server_step2(int, u_int32_t, void *);
222void input_userauth_jpake_server_confirm(int, u_int32_t, void *);
Damien Miller874d77b2000-10-14 16:23:11 +1100223
Ben Lindstrom3c36bb22001-12-06 17:55:26 +0000224int userauth_none(Authctxt *);
225int userauth_pubkey(Authctxt *);
226int userauth_passwd(Authctxt *);
227int userauth_kbdint(Authctxt *);
228int userauth_hostbased(Authctxt *);
Damien Miller01ed2272008-11-05 16:20:46 +1100229int userauth_jpake(Authctxt *);
230
231void userauth_jpake_cleanup(Authctxt *);
Damien Miller62cee002000-09-23 17:15:56 +1100232
Darren Tucker0efd1552003-08-26 11:49:55 +1000233#ifdef GSSAPI
234int userauth_gssapi(Authctxt *authctxt);
235void input_gssapi_response(int type, u_int32_t, void *);
236void input_gssapi_token(int type, u_int32_t, void *);
237void input_gssapi_hash(int type, u_int32_t, void *);
238void input_gssapi_error(int, u_int32_t, void *);
239void input_gssapi_errtok(int, u_int32_t, void *);
240#endif
241
Ben Lindstrom3c36bb22001-12-06 17:55:26 +0000242void userauth(Authctxt *, char *);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000243
Damien Miller280ecfb2003-05-14 13:46:00 +1000244static int sign_and_send_pubkey(Authctxt *, Identity *);
Damien Miller280ecfb2003-05-14 13:46:00 +1000245static void pubkey_prepare(Authctxt *);
246static void pubkey_cleanup(Authctxt *);
247static Key *load_identity_file(char *);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000248
Ben Lindstrombba81212001-06-25 05:01:22 +0000249static Authmethod *authmethod_get(char *authlist);
250static Authmethod *authmethod_lookup(const char *name);
251static char *authmethods_get(void);
Damien Miller62cee002000-09-23 17:15:56 +1100252
253Authmethod authmethods[] = {
Darren Tucker0efd1552003-08-26 11:49:55 +1000254#ifdef GSSAPI
Damien Miller0425d402003-11-17 22:18:21 +1100255 {"gssapi-with-mic",
Darren Tucker0efd1552003-08-26 11:49:55 +1000256 userauth_gssapi,
Damien Miller01ed2272008-11-05 16:20:46 +1100257 NULL,
Darren Tucker0efd1552003-08-26 11:49:55 +1000258 &options.gss_authentication,
259 NULL},
260#endif
Ben Lindstrom1bfe2912001-06-05 19:37:25 +0000261 {"hostbased",
262 userauth_hostbased,
Damien Miller01ed2272008-11-05 16:20:46 +1100263 NULL,
Ben Lindstrom1bfe2912001-06-05 19:37:25 +0000264 &options.hostbased_authentication,
265 NULL},
Ben Lindstrom45350e82001-08-06 20:57:11 +0000266 {"publickey",
267 userauth_pubkey,
Damien Miller01ed2272008-11-05 16:20:46 +1100268 NULL,
Ben Lindstrom45350e82001-08-06 20:57:11 +0000269 &options.pubkey_authentication,
270 NULL},
Damien Miller01ed2272008-11-05 16:20:46 +1100271#ifdef JPAKE
272 {"jpake-01@openssh.com",
273 userauth_jpake,
274 userauth_jpake_cleanup,
275 &options.zero_knowledge_password_authentication,
276 &options.batch_mode},
277#endif
Damien Miller874d77b2000-10-14 16:23:11 +1100278 {"keyboard-interactive",
279 userauth_kbdint,
Damien Miller01ed2272008-11-05 16:20:46 +1100280 NULL,
Damien Miller874d77b2000-10-14 16:23:11 +1100281 &options.kbd_interactive_authentication,
282 &options.batch_mode},
Ben Lindstrom45350e82001-08-06 20:57:11 +0000283 {"password",
284 userauth_passwd,
Damien Miller01ed2272008-11-05 16:20:46 +1100285 NULL,
Ben Lindstrom45350e82001-08-06 20:57:11 +0000286 &options.password_authentication,
287 &options.batch_mode},
Damien Miller874d77b2000-10-14 16:23:11 +1100288 {"none",
289 userauth_none,
290 NULL,
Damien Miller01ed2272008-11-05 16:20:46 +1100291 NULL,
Damien Miller874d77b2000-10-14 16:23:11 +1100292 NULL},
Damien Miller01ed2272008-11-05 16:20:46 +1100293 {NULL, NULL, NULL, NULL, NULL}
Damien Miller62cee002000-09-23 17:15:56 +1100294};
295
296void
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000297ssh_userauth2(const char *local_user, const char *server_user, char *host,
Ben Lindstrom1bad2562002-06-06 19:57:33 +0000298 Sensitive *sensitive)
Damien Miller62cee002000-09-23 17:15:56 +1100299{
300 Authctxt authctxt;
301 int type;
Damien Miller62cee002000-09-23 17:15:56 +1100302
Ben Lindstrom551ea372001-06-05 18:56:16 +0000303 if (options.challenge_response_authentication)
Ben Lindstrom95fb2dd2001-01-23 03:12:10 +0000304 options.kbd_interactive_authentication = 1;
305
Damien Miller62cee002000-09-23 17:15:56 +1100306 packet_start(SSH2_MSG_SERVICE_REQUEST);
307 packet_put_cstring("ssh-userauth");
308 packet_send();
Ben Lindstrom064496f2002-12-23 02:04:22 +0000309 debug("SSH2_MSG_SERVICE_REQUEST sent");
Damien Miller62cee002000-09-23 17:15:56 +1100310 packet_write_wait();
Damien Millerdff50992002-01-22 23:16:32 +1100311 type = packet_read();
Ben Lindstrom064496f2002-12-23 02:04:22 +0000312 if (type != SSH2_MSG_SERVICE_ACCEPT)
313 fatal("Server denied authentication request: %d", type);
Damien Miller62cee002000-09-23 17:15:56 +1100314 if (packet_remaining() > 0) {
Damien Millerdff50992002-01-22 23:16:32 +1100315 char *reply = packet_get_string(NULL);
Ben Lindstrom064496f2002-12-23 02:04:22 +0000316 debug2("service_accept: %s", reply);
Damien Miller62cee002000-09-23 17:15:56 +1100317 xfree(reply);
Damien Miller62cee002000-09-23 17:15:56 +1100318 } else {
Ben Lindstrom1d568f92002-12-23 02:44:36 +0000319 debug2("buggy server: service_accept w/o service");
Damien Miller62cee002000-09-23 17:15:56 +1100320 }
Damien Miller48b03fc2002-01-22 23:11:40 +1100321 packet_check_eom();
Ben Lindstrom064496f2002-12-23 02:04:22 +0000322 debug("SSH2_MSG_SERVICE_ACCEPT received");
Damien Miller62cee002000-09-23 17:15:56 +1100323
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000324 if (options.preferred_authentications == NULL)
325 options.preferred_authentications = authmethods_get();
326
Damien Miller62cee002000-09-23 17:15:56 +1100327 /* setup authentication context */
Ben Lindstrom7d199962001-09-12 18:29:00 +0000328 memset(&authctxt, 0, sizeof(authctxt));
Damien Miller280ecfb2003-05-14 13:46:00 +1000329 pubkey_prepare(&authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100330 authctxt.server_user = server_user;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000331 authctxt.local_user = local_user;
Damien Miller62cee002000-09-23 17:15:56 +1100332 authctxt.host = host;
333 authctxt.service = "ssh-connection"; /* service name */
334 authctxt.success = 0;
Damien Miller874d77b2000-10-14 16:23:11 +1100335 authctxt.method = authmethod_lookup("none");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000336 authctxt.authlist = NULL;
Darren Tucker0efd1552003-08-26 11:49:55 +1000337 authctxt.methoddata = NULL;
Ben Lindstrom1bad2562002-06-06 19:57:33 +0000338 authctxt.sensitive = sensitive;
Ben Lindstrom7d199962001-09-12 18:29:00 +0000339 authctxt.info_req_seen = 0;
Damien Miller874d77b2000-10-14 16:23:11 +1100340 if (authctxt.method == NULL)
341 fatal("ssh_userauth2: internal error: cannot send userauth none request");
Damien Miller62cee002000-09-23 17:15:56 +1100342
343 /* initial userauth request */
Damien Miller874d77b2000-10-14 16:23:11 +1100344 userauth_none(&authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100345
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000346 dispatch_init(&input_userauth_error);
Damien Miller62cee002000-09-23 17:15:56 +1100347 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
348 dispatch_set(SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000349 dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
Damien Miller62cee002000-09-23 17:15:56 +1100350 dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt); /* loop until success */
351
Damien Miller280ecfb2003-05-14 13:46:00 +1000352 pubkey_cleanup(&authctxt);
Damien Millerf842fcb2003-05-15 12:01:28 +1000353 dispatch_range(SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);
354
Ben Lindstrom1d568f92002-12-23 02:44:36 +0000355 debug("Authentication succeeded (%s).", authctxt.method->name);
Damien Miller62cee002000-09-23 17:15:56 +1100356}
Damien Millerf842fcb2003-05-15 12:01:28 +1000357
Damien Miller62cee002000-09-23 17:15:56 +1100358void
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000359userauth(Authctxt *authctxt, char *authlist)
360{
Damien Miller01ed2272008-11-05 16:20:46 +1100361 if (authctxt->method != NULL && authctxt->method->cleanup != NULL)
362 authctxt->method->cleanup(authctxt);
363
Darren Tucker0efd1552003-08-26 11:49:55 +1000364 if (authctxt->methoddata) {
365 xfree(authctxt->methoddata);
366 authctxt->methoddata = NULL;
367 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000368 if (authlist == NULL) {
369 authlist = authctxt->authlist;
370 } else {
371 if (authctxt->authlist)
372 xfree(authctxt->authlist);
373 authctxt->authlist = authlist;
374 }
375 for (;;) {
376 Authmethod *method = authmethod_get(authlist);
377 if (method == NULL)
378 fatal("Permission denied (%s).", authlist);
379 authctxt->method = method;
Damien Millerf842fcb2003-05-15 12:01:28 +1000380
381 /* reset the per method handler */
382 dispatch_range(SSH2_MSG_USERAUTH_PER_METHOD_MIN,
383 SSH2_MSG_USERAUTH_PER_METHOD_MAX, NULL);
384
385 /* and try new method */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000386 if (method->userauth(authctxt) != 0) {
387 debug2("we sent a %s packet, wait for reply", method->name);
388 break;
389 } else {
390 debug2("we did not send a packet, disable method");
391 method->enabled = NULL;
392 }
393 }
394}
Ben Lindstrom5c385522002-06-23 21:23:20 +0000395
Damien Millerf7475d72008-11-03 19:26:18 +1100396/* ARGSUSED */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000397void
Damien Miller630d6f42002-01-22 23:17:30 +1100398input_userauth_error(int type, u_int32_t seq, void *ctxt)
Damien Miller62cee002000-09-23 17:15:56 +1100399{
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000400 fatal("input_userauth_error: bad message during authentication: "
Damien Miller0dc1bef2005-07-17 17:22:45 +1000401 "type %d", type);
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000402}
Ben Lindstrom5c385522002-06-23 21:23:20 +0000403
Damien Millerf7475d72008-11-03 19:26:18 +1100404/* ARGSUSED */
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000405void
Damien Miller630d6f42002-01-22 23:17:30 +1100406input_userauth_banner(int type, u_int32_t seq, void *ctxt)
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000407{
Damien Miller7ba0ca72008-07-17 18:57:06 +1000408 char *msg, *raw, *lang;
409 u_int len;
Darren Tucker79644822003-10-08 17:37:58 +1000410
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000411 debug3("input_userauth_banner");
Damien Miller7ba0ca72008-07-17 18:57:06 +1000412 raw = packet_get_string(&len);
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000413 lang = packet_get_string(NULL);
Damien Millerc674d582008-11-03 19:16:57 +1100414 if (len > 0 && options.log_level >= SYSLOG_LEVEL_INFO) {
Damien Miller7ba0ca72008-07-17 18:57:06 +1000415 if (len > 65536)
416 len = 65536;
Damien Millerc4d1b362008-11-03 19:22:09 +1100417 msg = xmalloc(len * 4 + 1); /* max expansion from strnvis() */
418 strnvis(msg, raw, len * 4 + 1, VIS_SAFE|VIS_OCTAL);
Darren Tucker046dff22003-10-08 17:32:02 +1000419 fprintf(stderr, "%s", msg);
Damien Miller7ba0ca72008-07-17 18:57:06 +1000420 xfree(msg);
421 }
422 xfree(raw);
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000423 xfree(lang);
Damien Miller62cee002000-09-23 17:15:56 +1100424}
Ben Lindstrom5c385522002-06-23 21:23:20 +0000425
Damien Millerf7475d72008-11-03 19:26:18 +1100426/* ARGSUSED */
Damien Miller62cee002000-09-23 17:15:56 +1100427void
Damien Miller630d6f42002-01-22 23:17:30 +1100428input_userauth_success(int type, u_int32_t seq, void *ctxt)
Damien Miller62cee002000-09-23 17:15:56 +1100429{
430 Authctxt *authctxt = ctxt;
Darren Tucker2f29a8c2009-10-24 11:47:58 +1100431
Damien Miller62cee002000-09-23 17:15:56 +1100432 if (authctxt == NULL)
433 fatal("input_userauth_success: no authentication context");
Darren Tucker79644822003-10-08 17:37:58 +1000434 if (authctxt->authlist) {
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000435 xfree(authctxt->authlist);
Darren Tucker79644822003-10-08 17:37:58 +1000436 authctxt->authlist = NULL;
437 }
Darren Tucker2f29a8c2009-10-24 11:47:58 +1100438 if (authctxt->method != NULL && authctxt->method->cleanup != NULL)
439 authctxt->method->cleanup(authctxt);
Darren Tucker79644822003-10-08 17:37:58 +1000440 if (authctxt->methoddata) {
Darren Tucker0efd1552003-08-26 11:49:55 +1000441 xfree(authctxt->methoddata);
Darren Tucker79644822003-10-08 17:37:58 +1000442 authctxt->methoddata = NULL;
443 }
Damien Miller62cee002000-09-23 17:15:56 +1100444 authctxt->success = 1; /* break out */
445}
Ben Lindstrom5c385522002-06-23 21:23:20 +0000446
Darren Tucker2f29a8c2009-10-24 11:47:58 +1100447void
448input_userauth_success_unexpected(int type, u_int32_t seq, void *ctxt)
449{
450 Authctxt *authctxt = ctxt;
451
452 if (authctxt == NULL)
453 fatal("%s: no authentication context", __func__);
454
455 fatal("Unexpected authentication success during %s.",
456 authctxt->method->name);
457}
458
Damien Millerf7475d72008-11-03 19:26:18 +1100459/* ARGSUSED */
Damien Miller62cee002000-09-23 17:15:56 +1100460void
Damien Miller630d6f42002-01-22 23:17:30 +1100461input_userauth_failure(int type, u_int32_t seq, void *ctxt)
Damien Miller62cee002000-09-23 17:15:56 +1100462{
Damien Miller62cee002000-09-23 17:15:56 +1100463 Authctxt *authctxt = ctxt;
464 char *authlist = NULL;
465 int partial;
Damien Miller62cee002000-09-23 17:15:56 +1100466
467 if (authctxt == NULL)
468 fatal("input_userauth_failure: no authentication context");
469
Damien Miller874d77b2000-10-14 16:23:11 +1100470 authlist = packet_get_string(NULL);
Damien Miller62cee002000-09-23 17:15:56 +1100471 partial = packet_get_char();
Damien Miller48b03fc2002-01-22 23:11:40 +1100472 packet_check_eom();
Damien Miller62cee002000-09-23 17:15:56 +1100473
474 if (partial != 0)
Damien Miller996acd22003-04-09 20:59:48 +1000475 logit("Authenticated with partial success.");
Ben Lindstrom1d568f92002-12-23 02:44:36 +0000476 debug("Authentications that can continue: %s", authlist);
Damien Miller62cee002000-09-23 17:15:56 +1100477
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000478 userauth(authctxt, authlist);
479}
Damien Millerf7475d72008-11-03 19:26:18 +1100480
481/* ARGSUSED */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000482void
Damien Miller630d6f42002-01-22 23:17:30 +1100483input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000484{
485 Authctxt *authctxt = ctxt;
486 Key *key = NULL;
Damien Miller280ecfb2003-05-14 13:46:00 +1000487 Identity *id = NULL;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000488 Buffer b;
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000489 int pktype, sent = 0;
490 u_int alen, blen;
491 char *pkalg, *fp;
492 u_char *pkblob;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000493
494 if (authctxt == NULL)
495 fatal("input_userauth_pk_ok: no authentication context");
496 if (datafellows & SSH_BUG_PKOK) {
497 /* this is similar to SSH_BUG_PKAUTH */
498 debug2("input_userauth_pk_ok: SSH_BUG_PKOK");
499 pkblob = packet_get_string(&blen);
500 buffer_init(&b);
501 buffer_append(&b, pkblob, blen);
502 pkalg = buffer_get_string(&b, &alen);
503 buffer_free(&b);
504 } else {
505 pkalg = packet_get_string(&alen);
506 pkblob = packet_get_string(&blen);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000507 }
Damien Miller48b03fc2002-01-22 23:11:40 +1100508 packet_check_eom();
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000509
Damien Miller280ecfb2003-05-14 13:46:00 +1000510 debug("Server accepts key: pkalg %s blen %u", pkalg, blen);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000511
Damien Miller280ecfb2003-05-14 13:46:00 +1000512 if ((pktype = key_type_from_name(pkalg)) == KEY_UNSPEC) {
513 debug("unknown pkalg %s", pkalg);
514 goto done;
515 }
516 if ((key = key_from_blob(pkblob, blen)) == NULL) {
517 debug("no key from blob. pkalg %s", pkalg);
518 goto done;
519 }
520 if (key->type != pktype) {
521 error("input_userauth_pk_ok: type mismatch "
522 "for decoded key (received %d, expected %d)",
523 key->type, pktype);
524 goto done;
525 }
526 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
527 debug2("input_userauth_pk_ok: fp %s", fp);
528 xfree(fp);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000529
Darren Tuckerd05b6012003-10-15 15:55:59 +1000530 /*
531 * search keys in the reverse order, because last candidate has been
532 * moved to the end of the queue. this also avoids confusion by
533 * duplicate keys
534 */
Damien Miller0b51a522004-04-20 20:07:19 +1000535 TAILQ_FOREACH_REVERSE(id, &authctxt->keys, idlist, next) {
Damien Miller280ecfb2003-05-14 13:46:00 +1000536 if (key_equal(key, id->key)) {
537 sent = sign_and_send_pubkey(authctxt, id);
538 break;
539 }
540 }
541done:
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000542 if (key != NULL)
543 key_free(key);
544 xfree(pkalg);
545 xfree(pkblob);
546
Ben Lindstroma962c2f2002-07-04 00:14:17 +0000547 /* try another method if we did not send a packet */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000548 if (sent == 0)
549 userauth(authctxt, NULL);
Damien Miller62cee002000-09-23 17:15:56 +1100550}
551
Darren Tucker0efd1552003-08-26 11:49:55 +1000552#ifdef GSSAPI
Damien Millera8e06ce2003-11-21 23:48:55 +1100553int
Darren Tucker0efd1552003-08-26 11:49:55 +1000554userauth_gssapi(Authctxt *authctxt)
555{
556 Gssctxt *gssctxt = NULL;
Darren Tucker56afe142003-11-03 20:06:14 +1100557 static gss_OID_set gss_supported = NULL;
Damien Millereccb9de2005-06-17 12:59:34 +1000558 static u_int mech = 0;
Darren Tucker0efd1552003-08-26 11:49:55 +1000559 OM_uint32 min;
560 int ok = 0;
561
562 /* Try one GSSAPI method at a time, rather than sending them all at
563 * once. */
564
Darren Tucker56afe142003-11-03 20:06:14 +1100565 if (gss_supported == NULL)
566 gss_indicate_mechs(&min, &gss_supported);
Darren Tucker0efd1552003-08-26 11:49:55 +1000567
568 /* Check to see if the mechanism is usable before we offer it */
Darren Tucker56afe142003-11-03 20:06:14 +1100569 while (mech < gss_supported->count && !ok) {
Darren Tucker0efd1552003-08-26 11:49:55 +1000570 /* My DER encoding requires length<128 */
Darren Tucker56afe142003-11-03 20:06:14 +1100571 if (gss_supported->elements[mech].length < 128 &&
Damien Millera1cb9f32006-08-19 00:33:34 +1000572 ssh_gssapi_check_mechanism(&gssctxt,
573 &gss_supported->elements[mech], authctxt->host)) {
Darren Tucker0efd1552003-08-26 11:49:55 +1000574 ok = 1; /* Mechanism works */
575 } else {
576 mech++;
577 }
578 }
579
Damien Millera1cb9f32006-08-19 00:33:34 +1000580 if (!ok)
Damien Millereccb9de2005-06-17 12:59:34 +1000581 return 0;
Darren Tucker0efd1552003-08-26 11:49:55 +1000582
583 authctxt->methoddata=(void *)gssctxt;
584
585 packet_start(SSH2_MSG_USERAUTH_REQUEST);
586 packet_put_cstring(authctxt->server_user);
587 packet_put_cstring(authctxt->service);
588 packet_put_cstring(authctxt->method->name);
589
590 packet_put_int(1);
591
Darren Tucker655a5e02003-11-03 20:09:03 +1100592 packet_put_int((gss_supported->elements[mech].length) + 2);
593 packet_put_char(SSH_GSS_OIDTYPE);
594 packet_put_char(gss_supported->elements[mech].length);
595 packet_put_raw(gss_supported->elements[mech].elements,
596 gss_supported->elements[mech].length);
Darren Tucker0efd1552003-08-26 11:49:55 +1000597
598 packet_send();
599
600 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_RESPONSE, &input_gssapi_response);
601 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);
602 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_ERROR, &input_gssapi_error);
603 dispatch_set(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);
604
605 mech++; /* Move along to next candidate */
606
607 return 1;
608}
609
Damien Miller91c6aa42003-11-17 21:20:18 +1100610static OM_uint32
611process_gssapi_token(void *ctxt, gss_buffer_t recv_tok)
612{
613 Authctxt *authctxt = ctxt;
614 Gssctxt *gssctxt = authctxt->methoddata;
615 gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
Damien Millerda9984f2005-08-31 19:46:26 +1000616 gss_buffer_desc mic = GSS_C_EMPTY_BUFFER;
617 gss_buffer_desc gssbuf;
Damien Miller0425d402003-11-17 22:18:21 +1100618 OM_uint32 status, ms, flags;
619 Buffer b;
Damien Miller787b2ec2003-11-21 23:56:47 +1100620
Damien Miller91c6aa42003-11-17 21:20:18 +1100621 status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
Damien Miller0425d402003-11-17 22:18:21 +1100622 recv_tok, &send_tok, &flags);
Damien Miller91c6aa42003-11-17 21:20:18 +1100623
624 if (send_tok.length > 0) {
625 if (GSS_ERROR(status))
626 packet_start(SSH2_MSG_USERAUTH_GSSAPI_ERRTOK);
627 else
628 packet_start(SSH2_MSG_USERAUTH_GSSAPI_TOKEN);
Damien Miller787b2ec2003-11-21 23:56:47 +1100629
Damien Miller91c6aa42003-11-17 21:20:18 +1100630 packet_put_string(send_tok.value, send_tok.length);
631 packet_send();
632 gss_release_buffer(&ms, &send_tok);
633 }
Damien Miller787b2ec2003-11-21 23:56:47 +1100634
Damien Miller91c6aa42003-11-17 21:20:18 +1100635 if (status == GSS_S_COMPLETE) {
Damien Miller0425d402003-11-17 22:18:21 +1100636 /* send either complete or MIC, depending on mechanism */
637 if (!(flags & GSS_C_INTEG_FLAG)) {
638 packet_start(SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE);
639 packet_send();
640 } else {
641 ssh_gssapi_buildmic(&b, authctxt->server_user,
642 authctxt->service, "gssapi-with-mic");
643
644 gssbuf.value = buffer_ptr(&b);
645 gssbuf.length = buffer_len(&b);
Damien Miller787b2ec2003-11-21 23:56:47 +1100646
Damien Miller0425d402003-11-17 22:18:21 +1100647 status = ssh_gssapi_sign(gssctxt, &gssbuf, &mic);
Damien Miller787b2ec2003-11-21 23:56:47 +1100648
Damien Miller0425d402003-11-17 22:18:21 +1100649 if (!GSS_ERROR(status)) {
650 packet_start(SSH2_MSG_USERAUTH_GSSAPI_MIC);
651 packet_put_string(mic.value, mic.length);
Damien Miller787b2ec2003-11-21 23:56:47 +1100652
Damien Miller0425d402003-11-17 22:18:21 +1100653 packet_send();
654 }
Damien Miller787b2ec2003-11-21 23:56:47 +1100655
Damien Miller0425d402003-11-17 22:18:21 +1100656 buffer_free(&b);
657 gss_release_buffer(&ms, &mic);
Damien Miller787b2ec2003-11-21 23:56:47 +1100658 }
Damien Miller91c6aa42003-11-17 21:20:18 +1100659 }
Damien Miller787b2ec2003-11-21 23:56:47 +1100660
Damien Miller91c6aa42003-11-17 21:20:18 +1100661 return status;
662}
663
Damien Millerf7475d72008-11-03 19:26:18 +1100664/* ARGSUSED */
Darren Tucker0efd1552003-08-26 11:49:55 +1000665void
666input_gssapi_response(int type, u_int32_t plen, void *ctxt)
667{
668 Authctxt *authctxt = ctxt;
669 Gssctxt *gssctxt;
Darren Tucker0efd1552003-08-26 11:49:55 +1000670 int oidlen;
671 char *oidv;
Darren Tucker0efd1552003-08-26 11:49:55 +1000672
673 if (authctxt == NULL)
674 fatal("input_gssapi_response: no authentication context");
675 gssctxt = authctxt->methoddata;
676
677 /* Setup our OID */
678 oidv = packet_get_string(&oidlen);
679
Darren Tucker655a5e02003-11-03 20:09:03 +1100680 if (oidlen <= 2 ||
681 oidv[0] != SSH_GSS_OIDTYPE ||
682 oidv[1] != oidlen - 2) {
Damien Miller91c6aa42003-11-17 21:20:18 +1100683 xfree(oidv);
Darren Tucker655a5e02003-11-03 20:09:03 +1100684 debug("Badly encoded mechanism OID received");
685 userauth(authctxt, NULL);
Darren Tucker655a5e02003-11-03 20:09:03 +1100686 return;
Darren Tucker0efd1552003-08-26 11:49:55 +1000687 }
688
Darren Tucker655a5e02003-11-03 20:09:03 +1100689 if (!ssh_gssapi_check_oid(gssctxt, oidv + 2, oidlen - 2))
690 fatal("Server returned different OID than expected");
691
Darren Tucker0efd1552003-08-26 11:49:55 +1000692 packet_check_eom();
693
694 xfree(oidv);
695
Damien Miller91c6aa42003-11-17 21:20:18 +1100696 if (GSS_ERROR(process_gssapi_token(ctxt, GSS_C_NO_BUFFER))) {
Darren Tucker0efd1552003-08-26 11:49:55 +1000697 /* Start again with next method on list */
698 debug("Trying to start again");
699 userauth(authctxt, NULL);
700 return;
701 }
Darren Tucker0efd1552003-08-26 11:49:55 +1000702}
703
Damien Millerf7475d72008-11-03 19:26:18 +1100704/* ARGSUSED */
Darren Tucker0efd1552003-08-26 11:49:55 +1000705void
706input_gssapi_token(int type, u_int32_t plen, void *ctxt)
707{
708 Authctxt *authctxt = ctxt;
Darren Tucker0efd1552003-08-26 11:49:55 +1000709 gss_buffer_desc recv_tok;
Damien Miller91c6aa42003-11-17 21:20:18 +1100710 OM_uint32 status;
Darren Tucker0efd1552003-08-26 11:49:55 +1000711 u_int slen;
712
713 if (authctxt == NULL)
714 fatal("input_gssapi_response: no authentication context");
Darren Tucker0efd1552003-08-26 11:49:55 +1000715
716 recv_tok.value = packet_get_string(&slen);
717 recv_tok.length = slen; /* safe typecast */
718
719 packet_check_eom();
720
Damien Miller91c6aa42003-11-17 21:20:18 +1100721 status = process_gssapi_token(ctxt, &recv_tok);
Darren Tucker0efd1552003-08-26 11:49:55 +1000722
723 xfree(recv_tok.value);
724
725 if (GSS_ERROR(status)) {
Darren Tucker0efd1552003-08-26 11:49:55 +1000726 /* Start again with the next method in the list */
727 userauth(authctxt, NULL);
728 return;
729 }
Darren Tucker0efd1552003-08-26 11:49:55 +1000730}
731
Damien Millerf7475d72008-11-03 19:26:18 +1100732/* ARGSUSED */
Darren Tucker0efd1552003-08-26 11:49:55 +1000733void
734input_gssapi_errtok(int type, u_int32_t plen, void *ctxt)
735{
736 Authctxt *authctxt = ctxt;
737 Gssctxt *gssctxt;
738 gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;
739 gss_buffer_desc recv_tok;
740 OM_uint32 status, ms;
Darren Tucker600ad8d2003-08-26 12:10:48 +1000741 u_int len;
Darren Tucker0efd1552003-08-26 11:49:55 +1000742
743 if (authctxt == NULL)
744 fatal("input_gssapi_response: no authentication context");
745 gssctxt = authctxt->methoddata;
746
Darren Tucker600ad8d2003-08-26 12:10:48 +1000747 recv_tok.value = packet_get_string(&len);
748 recv_tok.length = len;
Darren Tucker0efd1552003-08-26 11:49:55 +1000749
750 packet_check_eom();
751
752 /* Stick it into GSSAPI and see what it says */
753 status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
Damien Miller0dc1bef2005-07-17 17:22:45 +1000754 &recv_tok, &send_tok, NULL);
Darren Tucker0efd1552003-08-26 11:49:55 +1000755
756 xfree(recv_tok.value);
757 gss_release_buffer(&ms, &send_tok);
758
759 /* Server will be returning a failed packet after this one */
760}
761
Damien Millerf7475d72008-11-03 19:26:18 +1100762/* ARGSUSED */
Darren Tucker0efd1552003-08-26 11:49:55 +1000763void
764input_gssapi_error(int type, u_int32_t plen, void *ctxt)
765{
766 OM_uint32 maj, min;
767 char *msg;
768 char *lang;
769
770 maj=packet_get_int();
771 min=packet_get_int();
772 msg=packet_get_string(NULL);
773 lang=packet_get_string(NULL);
774
775 packet_check_eom();
776
Damien Miller15d72a02005-11-05 15:07:33 +1100777 debug("Server GSSAPI Error:\n%s", msg);
Darren Tucker0efd1552003-08-26 11:49:55 +1000778 xfree(msg);
779 xfree(lang);
780}
781#endif /* GSSAPI */
782
Damien Millereba71ba2000-04-29 23:57:08 +1000783int
Damien Miller874d77b2000-10-14 16:23:11 +1100784userauth_none(Authctxt *authctxt)
785{
786 /* initial userauth request */
787 packet_start(SSH2_MSG_USERAUTH_REQUEST);
788 packet_put_cstring(authctxt->server_user);
789 packet_put_cstring(authctxt->service);
790 packet_put_cstring(authctxt->method->name);
791 packet_send();
Damien Miller874d77b2000-10-14 16:23:11 +1100792 return 1;
793}
794
795int
Damien Miller62cee002000-09-23 17:15:56 +1100796userauth_passwd(Authctxt *authctxt)
Damien Millereba71ba2000-04-29 23:57:08 +1000797{
Damien Millere247cc42000-05-07 12:03:14 +1000798 static int attempt = 0;
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000799 char prompt[150];
Damien Millereba71ba2000-04-29 23:57:08 +1000800 char *password;
801
Damien Millerd3a18572000-06-07 19:55:44 +1000802 if (attempt++ >= options.number_of_password_prompts)
Damien Millere247cc42000-05-07 12:03:14 +1000803 return 0;
804
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000805 if (attempt != 1)
Damien Millerd3a18572000-06-07 19:55:44 +1000806 error("Permission denied, please try again.");
807
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000808 snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
Damien Miller62cee002000-09-23 17:15:56 +1100809 authctxt->server_user, authctxt->host);
Damien Millereba71ba2000-04-29 23:57:08 +1000810 password = read_passphrase(prompt, 0);
811 packet_start(SSH2_MSG_USERAUTH_REQUEST);
Damien Miller62cee002000-09-23 17:15:56 +1100812 packet_put_cstring(authctxt->server_user);
813 packet_put_cstring(authctxt->service);
Damien Miller874d77b2000-10-14 16:23:11 +1100814 packet_put_cstring(authctxt->method->name);
Damien Millereba71ba2000-04-29 23:57:08 +1000815 packet_put_char(0);
Ben Lindstrom5699c5f2001-03-05 06:17:49 +0000816 packet_put_cstring(password);
Damien Millereba71ba2000-04-29 23:57:08 +1000817 memset(password, 0, strlen(password));
818 xfree(password);
Damien Miller9f643902001-11-12 11:02:52 +1100819 packet_add_padding(64);
Damien Millereba71ba2000-04-29 23:57:08 +1000820 packet_send();
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000821
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000822 dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000823 &input_userauth_passwd_changereq);
824
Damien Millereba71ba2000-04-29 23:57:08 +1000825 return 1;
826}
Damien Millerf7475d72008-11-03 19:26:18 +1100827
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000828/*
829 * parse PASSWD_CHANGEREQ, prompt user and send SSH2_MSG_USERAUTH_REQUEST
830 */
Damien Millerf7475d72008-11-03 19:26:18 +1100831/* ARGSUSED */
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000832void
Tim Ricec8549622002-03-31 12:49:38 -0800833input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000834{
835 Authctxt *authctxt = ctxt;
836 char *info, *lang, *password = NULL, *retype = NULL;
837 char prompt[150];
838
839 debug2("input_userauth_passwd_changereq");
840
841 if (authctxt == NULL)
842 fatal("input_userauth_passwd_changereq: "
843 "no authentication context");
844
845 info = packet_get_string(NULL);
846 lang = packet_get_string(NULL);
847 if (strlen(info) > 0)
Damien Miller996acd22003-04-09 20:59:48 +1000848 logit("%s", info);
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000849 xfree(info);
850 xfree(lang);
851 packet_start(SSH2_MSG_USERAUTH_REQUEST);
852 packet_put_cstring(authctxt->server_user);
853 packet_put_cstring(authctxt->service);
854 packet_put_cstring(authctxt->method->name);
855 packet_put_char(1); /* additional info */
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000856 snprintf(prompt, sizeof(prompt),
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000857 "Enter %.30s@%.128s's old password: ",
858 authctxt->server_user, authctxt->host);
859 password = read_passphrase(prompt, 0);
860 packet_put_cstring(password);
861 memset(password, 0, strlen(password));
862 xfree(password);
863 password = NULL;
864 while (password == NULL) {
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000865 snprintf(prompt, sizeof(prompt),
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000866 "Enter %.30s@%.128s's new password: ",
867 authctxt->server_user, authctxt->host);
868 password = read_passphrase(prompt, RP_ALLOW_EOF);
869 if (password == NULL) {
870 /* bail out */
871 return;
872 }
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000873 snprintf(prompt, sizeof(prompt),
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000874 "Retype %.30s@%.128s's new password: ",
875 authctxt->server_user, authctxt->host);
876 retype = read_passphrase(prompt, 0);
877 if (strcmp(password, retype) != 0) {
878 memset(password, 0, strlen(password));
879 xfree(password);
Damien Miller996acd22003-04-09 20:59:48 +1000880 logit("Mismatch; try again, EOF to quit.");
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000881 password = NULL;
882 }
883 memset(retype, 0, strlen(retype));
884 xfree(retype);
885 }
886 packet_put_cstring(password);
887 memset(password, 0, strlen(password));
888 xfree(password);
889 packet_add_padding(64);
890 packet_send();
Ben Lindstromcb72e4f2002-06-21 00:41:51 +0000891
892 dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
Ben Lindstrom38a69e62002-03-27 17:28:46 +0000893 &input_userauth_passwd_changereq);
894}
Damien Millereba71ba2000-04-29 23:57:08 +1000895
Damien Miller01ed2272008-11-05 16:20:46 +1100896#ifdef JPAKE
897static char *
898pw_encrypt(const char *password, const char *crypt_scheme, const char *salt)
899{
900 /* OpenBSD crypt(3) handles all of these */
901 if (strcmp(crypt_scheme, "crypt") == 0 ||
902 strcmp(crypt_scheme, "bcrypt") == 0 ||
903 strcmp(crypt_scheme, "md5crypt") == 0 ||
904 strcmp(crypt_scheme, "crypt-extended") == 0)
905 return xstrdup(crypt(password, salt));
906 error("%s: unsupported password encryption scheme \"%.100s\"",
907 __func__, crypt_scheme);
908 return NULL;
909}
910
911static BIGNUM *
912jpake_password_to_secret(Authctxt *authctxt, const char *crypt_scheme,
913 const char *salt)
914{
915 char prompt[256], *password, *crypted;
916 u_char *secret;
917 u_int secret_len;
918 BIGNUM *ret;
919
920 snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password (JPAKE): ",
921 authctxt->server_user, authctxt->host);
922 password = read_passphrase(prompt, 0);
923
924 if ((crypted = pw_encrypt(password, crypt_scheme, salt)) == NULL) {
925 logit("Disabling %s authentication", authctxt->method->name);
926 authctxt->method->enabled = NULL;
927 /* Continue with an empty password to fail gracefully */
928 crypted = xstrdup("");
929 }
930
931#ifdef JPAKE_DEBUG
932 debug3("%s: salt = %s", __func__, salt);
933 debug3("%s: scheme = %s", __func__, crypt_scheme);
934 debug3("%s: crypted = %s", __func__, crypted);
935#endif
936
937 if (hash_buffer(crypted, strlen(crypted), EVP_sha256(),
938 &secret, &secret_len) != 0)
939 fatal("%s: hash_buffer", __func__);
940
941 bzero(password, strlen(password));
942 bzero(crypted, strlen(crypted));
943 xfree(password);
944 xfree(crypted);
945
946 if ((ret = BN_bin2bn(secret, secret_len, NULL)) == NULL)
947 fatal("%s: BN_bin2bn (secret)", __func__);
948 bzero(secret, secret_len);
949 xfree(secret);
950
951 return ret;
952}
953
954/* ARGSUSED */
955void
956input_userauth_jpake_server_step1(int type, u_int32_t seq, void *ctxt)
957{
958 Authctxt *authctxt = ctxt;
959 struct jpake_ctx *pctx = authctxt->methoddata;
960 u_char *x3_proof, *x4_proof, *x2_s_proof;
961 u_int x3_proof_len, x4_proof_len, x2_s_proof_len;
962 char *crypt_scheme, *salt;
963
964 /* Disable this message */
965 dispatch_set(SSH2_MSG_USERAUTH_JPAKE_SERVER_STEP1, NULL);
966
967 if ((pctx->g_x3 = BN_new()) == NULL ||
968 (pctx->g_x4 = BN_new()) == NULL)
969 fatal("%s: BN_new", __func__);
970
971 /* Fetch step 1 values */
972 crypt_scheme = packet_get_string(NULL);
973 salt = packet_get_string(NULL);
974 pctx->server_id = packet_get_string(&pctx->server_id_len);
975 packet_get_bignum2(pctx->g_x3);
976 packet_get_bignum2(pctx->g_x4);
977 x3_proof = packet_get_string(&x3_proof_len);
978 x4_proof = packet_get_string(&x4_proof_len);
979 packet_check_eom();
980
981 JPAKE_DEBUG_CTX((pctx, "step 1 received in %s", __func__));
982
983 /* Obtain password and derive secret */
984 pctx->s = jpake_password_to_secret(authctxt, crypt_scheme, salt);
985 bzero(crypt_scheme, strlen(crypt_scheme));
986 bzero(salt, strlen(salt));
987 xfree(crypt_scheme);
988 xfree(salt);
989 JPAKE_DEBUG_BN((pctx->s, "%s: s = ", __func__));
990
991 /* Calculate step 2 values */
992 jpake_step2(pctx->grp, pctx->s, pctx->g_x1,
993 pctx->g_x3, pctx->g_x4, pctx->x2,
994 pctx->server_id, pctx->server_id_len,
995 pctx->client_id, pctx->client_id_len,
996 x3_proof, x3_proof_len,
997 x4_proof, x4_proof_len,
998 &pctx->a,
999 &x2_s_proof, &x2_s_proof_len);
1000
1001 bzero(x3_proof, x3_proof_len);
1002 bzero(x4_proof, x4_proof_len);
1003 xfree(x3_proof);
1004 xfree(x4_proof);
1005
1006 JPAKE_DEBUG_CTX((pctx, "step 2 sending in %s", __func__));
1007
1008 /* Send values for step 2 */
1009 packet_start(SSH2_MSG_USERAUTH_JPAKE_CLIENT_STEP2);
1010 packet_put_bignum2(pctx->a);
1011 packet_put_string(x2_s_proof, x2_s_proof_len);
1012 packet_send();
1013
1014 bzero(x2_s_proof, x2_s_proof_len);
1015 xfree(x2_s_proof);
1016
1017 /* Expect step 2 packet from peer */
1018 dispatch_set(SSH2_MSG_USERAUTH_JPAKE_SERVER_STEP2,
1019 input_userauth_jpake_server_step2);
1020}
1021
1022/* ARGSUSED */
1023void
1024input_userauth_jpake_server_step2(int type, u_int32_t seq, void *ctxt)
1025{
1026 Authctxt *authctxt = ctxt;
1027 struct jpake_ctx *pctx = authctxt->methoddata;
1028 u_char *x4_s_proof;
1029 u_int x4_s_proof_len;
1030
1031 /* Disable this message */
1032 dispatch_set(SSH2_MSG_USERAUTH_JPAKE_SERVER_STEP2, NULL);
1033
1034 if ((pctx->b = BN_new()) == NULL)
1035 fatal("%s: BN_new", __func__);
1036
1037 /* Fetch step 2 values */
1038 packet_get_bignum2(pctx->b);
1039 x4_s_proof = packet_get_string(&x4_s_proof_len);
1040 packet_check_eom();
1041
1042 JPAKE_DEBUG_CTX((pctx, "step 2 received in %s", __func__));
1043
1044 /* Derive shared key and calculate confirmation hash */
1045 jpake_key_confirm(pctx->grp, pctx->s, pctx->b,
1046 pctx->x2, pctx->g_x1, pctx->g_x2, pctx->g_x3, pctx->g_x4,
1047 pctx->client_id, pctx->client_id_len,
1048 pctx->server_id, pctx->server_id_len,
1049 session_id2, session_id2_len,
1050 x4_s_proof, x4_s_proof_len,
1051 &pctx->k,
1052 &pctx->h_k_cid_sessid, &pctx->h_k_cid_sessid_len);
1053
1054 bzero(x4_s_proof, x4_s_proof_len);
1055 xfree(x4_s_proof);
1056
1057 JPAKE_DEBUG_CTX((pctx, "confirm sending in %s", __func__));
1058
1059 /* Send key confirmation proof */
1060 packet_start(SSH2_MSG_USERAUTH_JPAKE_CLIENT_CONFIRM);
1061 packet_put_string(pctx->h_k_cid_sessid, pctx->h_k_cid_sessid_len);
1062 packet_send();
1063
1064 /* Expect confirmation from peer */
1065 dispatch_set(SSH2_MSG_USERAUTH_JPAKE_SERVER_CONFIRM,
1066 input_userauth_jpake_server_confirm);
1067}
1068
1069/* ARGSUSED */
1070void
1071input_userauth_jpake_server_confirm(int type, u_int32_t seq, void *ctxt)
1072{
1073 Authctxt *authctxt = ctxt;
1074 struct jpake_ctx *pctx = authctxt->methoddata;
1075
1076 /* Disable this message */
1077 dispatch_set(SSH2_MSG_USERAUTH_JPAKE_SERVER_CONFIRM, NULL);
1078
1079 pctx->h_k_sid_sessid = packet_get_string(&pctx->h_k_sid_sessid_len);
1080 packet_check_eom();
1081
1082 JPAKE_DEBUG_CTX((pctx, "confirm received in %s", __func__));
1083
1084 /* Verify expected confirmation hash */
1085 if (jpake_check_confirm(pctx->k,
1086 pctx->server_id, pctx->server_id_len,
1087 session_id2, session_id2_len,
1088 pctx->h_k_sid_sessid, pctx->h_k_sid_sessid_len) == 1)
1089 debug("%s: %s success", __func__, authctxt->method->name);
1090 else {
1091 debug("%s: confirmation mismatch", __func__);
1092 /* XXX stash this so if auth succeeds then we can warn/kill */
1093 }
1094
1095 userauth_jpake_cleanup(authctxt);
1096}
1097#endif /* JPAKE */
1098
Ben Lindstrombba81212001-06-25 05:01:22 +00001099static int
Damien Miller280ecfb2003-05-14 13:46:00 +10001100identity_sign(Identity *id, u_char **sigp, u_int *lenp,
1101 u_char *data, u_int datalen)
1102{
1103 Key *prv;
1104 int ret;
1105
1106 /* the agent supports this key */
1107 if (id->ac)
1108 return (ssh_agent_sign(id->ac, id->key, sigp, lenp,
1109 data, datalen));
1110 /*
1111 * we have already loaded the private key or
1112 * the private key is stored in external hardware
1113 */
1114 if (id->isprivate || (id->key->flags & KEY_FLAG_EXT))
1115 return (key_sign(id->key, sigp, lenp, data, datalen));
1116 /* load the private key from the file */
1117 if ((prv = load_identity_file(id->filename)) == NULL)
1118 return (-1);
1119 ret = key_sign(prv, sigp, lenp, data, datalen);
1120 key_free(prv);
1121 return (ret);
1122}
1123
1124static int
1125sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
Damien Millereba71ba2000-04-29 23:57:08 +10001126{
1127 Buffer b;
Ben Lindstrom46c16222000-12-22 01:43:59 +00001128 u_char *blob, *signature;
Ben Lindstrom90fd8142002-02-26 18:09:42 +00001129 u_int bloblen, slen;
Darren Tucker502d3842003-06-28 12:38:01 +10001130 u_int skip = 0;
Damien Millerad833b32000-08-23 10:46:23 +10001131 int ret = -1;
Damien Miller874d77b2000-10-14 16:23:11 +11001132 int have_sig = 1;
Damien Millereba71ba2000-04-29 23:57:08 +10001133
Ben Lindstromd121f612000-12-03 17:00:47 +00001134 debug3("sign_and_send_pubkey");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001135
Damien Miller280ecfb2003-05-14 13:46:00 +10001136 if (key_to_blob(id->key, &blob, &bloblen) == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +11001137 /* we cannot handle this key */
Ben Lindstromd121f612000-12-03 17:00:47 +00001138 debug3("sign_and_send_pubkey: cannot handle key");
Damien Miller0bc1bd82000-11-13 22:57:25 +11001139 return 0;
1140 }
Damien Millereba71ba2000-04-29 23:57:08 +10001141 /* data to be signed */
1142 buffer_init(&b);
Damien Miller50a41ed2000-10-16 12:14:42 +11001143 if (datafellows & SSH_OLD_SESSIONID) {
Damien Miller6536c7d2000-06-22 21:32:31 +10001144 buffer_append(&b, session_id2, session_id2_len);
Kevin Stevesef4eea92001-02-05 12:42:17 +00001145 skip = session_id2_len;
Damien Miller50a41ed2000-10-16 12:14:42 +11001146 } else {
1147 buffer_put_string(&b, session_id2, session_id2_len);
1148 skip = buffer_len(&b);
Damien Miller6536c7d2000-06-22 21:32:31 +10001149 }
Damien Millereba71ba2000-04-29 23:57:08 +10001150 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
Damien Miller62cee002000-09-23 17:15:56 +11001151 buffer_put_cstring(&b, authctxt->server_user);
Damien Miller30c3d422000-05-09 11:02:59 +10001152 buffer_put_cstring(&b,
Ben Lindstromd121f612000-12-03 17:00:47 +00001153 datafellows & SSH_BUG_PKSERVICE ?
Damien Miller30c3d422000-05-09 11:02:59 +10001154 "ssh-userauth" :
Damien Miller62cee002000-09-23 17:15:56 +11001155 authctxt->service);
Ben Lindstromd121f612000-12-03 17:00:47 +00001156 if (datafellows & SSH_BUG_PKAUTH) {
1157 buffer_put_char(&b, have_sig);
1158 } else {
1159 buffer_put_cstring(&b, authctxt->method->name);
1160 buffer_put_char(&b, have_sig);
Damien Miller280ecfb2003-05-14 13:46:00 +10001161 buffer_put_cstring(&b, key_ssh_name(id->key));
Ben Lindstromd121f612000-12-03 17:00:47 +00001162 }
Damien Millereba71ba2000-04-29 23:57:08 +10001163 buffer_put_string(&b, blob, bloblen);
Damien Millereba71ba2000-04-29 23:57:08 +10001164
1165 /* generate signature */
Damien Miller280ecfb2003-05-14 13:46:00 +10001166 ret = identity_sign(id, &signature, &slen,
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001167 buffer_ptr(&b), buffer_len(&b));
Damien Millerad833b32000-08-23 10:46:23 +10001168 if (ret == -1) {
1169 xfree(blob);
1170 buffer_free(&b);
1171 return 0;
1172 }
Damien Miller0bc1bd82000-11-13 22:57:25 +11001173#ifdef DEBUG_PK
Damien Millereba71ba2000-04-29 23:57:08 +10001174 buffer_dump(&b);
1175#endif
Ben Lindstromd121f612000-12-03 17:00:47 +00001176 if (datafellows & SSH_BUG_PKSERVICE) {
Damien Miller30c3d422000-05-09 11:02:59 +10001177 buffer_clear(&b);
1178 buffer_append(&b, session_id2, session_id2_len);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001179 skip = session_id2_len;
Damien Miller30c3d422000-05-09 11:02:59 +10001180 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
Damien Miller62cee002000-09-23 17:15:56 +11001181 buffer_put_cstring(&b, authctxt->server_user);
1182 buffer_put_cstring(&b, authctxt->service);
Damien Miller874d77b2000-10-14 16:23:11 +11001183 buffer_put_cstring(&b, authctxt->method->name);
1184 buffer_put_char(&b, have_sig);
Ben Lindstromd121f612000-12-03 17:00:47 +00001185 if (!(datafellows & SSH_BUG_PKAUTH))
Damien Miller280ecfb2003-05-14 13:46:00 +10001186 buffer_put_cstring(&b, key_ssh_name(id->key));
Damien Miller30c3d422000-05-09 11:02:59 +10001187 buffer_put_string(&b, blob, bloblen);
1188 }
1189 xfree(blob);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001190
Damien Millereba71ba2000-04-29 23:57:08 +10001191 /* append signature */
1192 buffer_put_string(&b, signature, slen);
1193 xfree(signature);
1194
1195 /* skip session id and packet type */
Damien Miller6536c7d2000-06-22 21:32:31 +10001196 if (buffer_len(&b) < skip + 1)
Damien Miller62cee002000-09-23 17:15:56 +11001197 fatal("userauth_pubkey: internal error");
Damien Miller6536c7d2000-06-22 21:32:31 +10001198 buffer_consume(&b, skip + 1);
Damien Millereba71ba2000-04-29 23:57:08 +10001199
1200 /* put remaining data from buffer into packet */
1201 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1202 packet_put_raw(buffer_ptr(&b), buffer_len(&b));
1203 buffer_free(&b);
Damien Millereba71ba2000-04-29 23:57:08 +10001204 packet_send();
Damien Millerad833b32000-08-23 10:46:23 +10001205
1206 return 1;
Damien Miller994cf142000-07-21 10:19:44 +10001207}
1208
Ben Lindstrombba81212001-06-25 05:01:22 +00001209static int
Damien Miller280ecfb2003-05-14 13:46:00 +10001210send_pubkey_test(Authctxt *authctxt, Identity *id)
Damien Miller994cf142000-07-21 10:19:44 +10001211{
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001212 u_char *blob;
Ben Lindstromc58ab022002-02-26 18:15:09 +00001213 u_int bloblen, have_sig = 0;
Damien Miller994cf142000-07-21 10:19:44 +10001214
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001215 debug3("send_pubkey_test");
1216
Damien Miller280ecfb2003-05-14 13:46:00 +10001217 if (key_to_blob(id->key, &blob, &bloblen) == 0) {
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001218 /* we cannot handle this key */
1219 debug3("send_pubkey_test: cannot handle key");
Damien Miller994cf142000-07-21 10:19:44 +10001220 return 0;
1221 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001222 /* register callback for USERAUTH_PK_OK message */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001223 dispatch_set(SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);
Damien Miller994cf142000-07-21 10:19:44 +10001224
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001225 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1226 packet_put_cstring(authctxt->server_user);
1227 packet_put_cstring(authctxt->service);
1228 packet_put_cstring(authctxt->method->name);
1229 packet_put_char(have_sig);
1230 if (!(datafellows & SSH_BUG_PKAUTH))
Damien Miller280ecfb2003-05-14 13:46:00 +10001231 packet_put_cstring(key_ssh_name(id->key));
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001232 packet_put_string(blob, bloblen);
1233 xfree(blob);
1234 packet_send();
1235 return 1;
1236}
1237
Ben Lindstrombba81212001-06-25 05:01:22 +00001238static Key *
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001239load_identity_file(char *filename)
1240{
1241 Key *private;
1242 char prompt[300], *passphrase;
Darren Tucker232b76f2006-05-06 17:41:51 +10001243 int perm_ok, quit, i;
Ben Lindstrom329782e2001-03-10 17:08:59 +00001244 struct stat st;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001245
Ben Lindstrom329782e2001-03-10 17:08:59 +00001246 if (stat(filename, &st) < 0) {
1247 debug3("no such identity: %s", filename);
1248 return NULL;
1249 }
Darren Tucker232b76f2006-05-06 17:41:51 +10001250 private = key_load_private_type(KEY_UNSPEC, filename, "", NULL, &perm_ok);
1251 if (!perm_ok)
1252 return NULL;
Ben Lindstromd0fca422001-03-26 13:44:06 +00001253 if (private == NULL) {
1254 if (options.batch_mode)
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001255 return NULL;
Damien Miller994cf142000-07-21 10:19:44 +10001256 snprintf(prompt, sizeof prompt,
Damien Miller9f0f5c62001-12-21 14:45:46 +11001257 "Enter passphrase for key '%.100s': ", filename);
Damien Miller62cee002000-09-23 17:15:56 +11001258 for (i = 0; i < options.number_of_password_prompts; i++) {
1259 passphrase = read_passphrase(prompt, 0);
1260 if (strcmp(passphrase, "") != 0) {
Darren Tucker232b76f2006-05-06 17:41:51 +10001261 private = key_load_private_type(KEY_UNSPEC,
1262 filename, passphrase, NULL, NULL);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001263 quit = 0;
Damien Miller62cee002000-09-23 17:15:56 +11001264 } else {
1265 debug2("no passphrase given, try next key");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001266 quit = 1;
Damien Miller62cee002000-09-23 17:15:56 +11001267 }
1268 memset(passphrase, 0, strlen(passphrase));
1269 xfree(passphrase);
Ben Lindstromd0fca422001-03-26 13:44:06 +00001270 if (private != NULL || quit)
Damien Miller62cee002000-09-23 17:15:56 +11001271 break;
1272 debug2("bad passphrase given, try again...");
1273 }
Damien Miller994cf142000-07-21 10:19:44 +10001274 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001275 return private;
1276}
1277
Damien Miller280ecfb2003-05-14 13:46:00 +10001278/*
1279 * try keys in the following order:
1280 * 1. agent keys that are found in the config file
1281 * 2. other agent keys
1282 * 3. keys that are only listed in the config file
1283 */
1284static void
1285pubkey_prepare(Authctxt *authctxt)
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001286{
Damien Miller280ecfb2003-05-14 13:46:00 +10001287 Identity *id;
1288 Idlist agent, files, *preferred;
1289 Key *key;
1290 AuthenticationConnection *ac;
Damien Millerad833b32000-08-23 10:46:23 +10001291 char *comment;
Damien Miller280ecfb2003-05-14 13:46:00 +10001292 int i, found;
Damien Millerad833b32000-08-23 10:46:23 +10001293
Damien Miller280ecfb2003-05-14 13:46:00 +10001294 TAILQ_INIT(&agent); /* keys from the agent */
1295 TAILQ_INIT(&files); /* keys from the config file */
1296 preferred = &authctxt->keys;
1297 TAILQ_INIT(preferred); /* preferred order of keys */
1298
1299 /* list of keys stored in the filesystem */
1300 for (i = 0; i < options.num_identity_files; i++) {
1301 key = options.identity_keys[i];
1302 if (key && key->type == KEY_RSA1)
1303 continue;
1304 options.identity_keys[i] = NULL;
Damien Miller07d86be2006-03-26 14:19:21 +11001305 id = xcalloc(1, sizeof(*id));
Damien Miller280ecfb2003-05-14 13:46:00 +10001306 id->key = key;
1307 id->filename = xstrdup(options.identity_files[i]);
1308 TAILQ_INSERT_TAIL(&files, id, next);
Damien Millerad833b32000-08-23 10:46:23 +10001309 }
Damien Miller280ecfb2003-05-14 13:46:00 +10001310 /* list of keys supported by the agent */
1311 if ((ac = ssh_get_authentication_connection())) {
1312 for (key = ssh_get_first_identity(ac, &comment, 2);
1313 key != NULL;
1314 key = ssh_get_next_identity(ac, &comment, 2)) {
1315 found = 0;
1316 TAILQ_FOREACH(id, &files, next) {
Damien Millera8e06ce2003-11-21 23:48:55 +11001317 /* agent keys from the config file are preferred */
Damien Miller280ecfb2003-05-14 13:46:00 +10001318 if (key_equal(key, id->key)) {
1319 key_free(key);
1320 xfree(comment);
1321 TAILQ_REMOVE(&files, id, next);
1322 TAILQ_INSERT_TAIL(preferred, id, next);
1323 id->ac = ac;
1324 found = 1;
1325 break;
1326 }
1327 }
Damien Millerbd394c32004-03-08 23:12:36 +11001328 if (!found && !options.identities_only) {
Damien Miller07d86be2006-03-26 14:19:21 +11001329 id = xcalloc(1, sizeof(*id));
Damien Miller280ecfb2003-05-14 13:46:00 +10001330 id->key = key;
1331 id->filename = comment;
1332 id->ac = ac;
1333 TAILQ_INSERT_TAIL(&agent, id, next);
1334 }
1335 }
1336 /* append remaining agent keys */
1337 for (id = TAILQ_FIRST(&agent); id; id = TAILQ_FIRST(&agent)) {
1338 TAILQ_REMOVE(&agent, id, next);
1339 TAILQ_INSERT_TAIL(preferred, id, next);
1340 }
1341 authctxt->agent = ac;
Damien Miller62cee002000-09-23 17:15:56 +11001342 }
Damien Miller280ecfb2003-05-14 13:46:00 +10001343 /* append remaining keys from the config file */
1344 for (id = TAILQ_FIRST(&files); id; id = TAILQ_FIRST(&files)) {
1345 TAILQ_REMOVE(&files, id, next);
1346 TAILQ_INSERT_TAIL(preferred, id, next);
1347 }
1348 TAILQ_FOREACH(id, preferred, next) {
1349 debug2("key: %s (%p)", id->filename, id->key);
1350 }
1351}
1352
1353static void
1354pubkey_cleanup(Authctxt *authctxt)
1355{
1356 Identity *id;
1357
1358 if (authctxt->agent != NULL)
1359 ssh_close_authentication_connection(authctxt->agent);
1360 for (id = TAILQ_FIRST(&authctxt->keys); id;
1361 id = TAILQ_FIRST(&authctxt->keys)) {
1362 TAILQ_REMOVE(&authctxt->keys, id, next);
1363 if (id->key)
1364 key_free(id->key);
1365 if (id->filename)
1366 xfree(id->filename);
1367 xfree(id);
1368 }
Damien Millereba71ba2000-04-29 23:57:08 +10001369}
1370
Damien Miller62cee002000-09-23 17:15:56 +11001371int
1372userauth_pubkey(Authctxt *authctxt)
Damien Millereba71ba2000-04-29 23:57:08 +10001373{
Damien Miller280ecfb2003-05-14 13:46:00 +10001374 Identity *id;
Damien Miller62cee002000-09-23 17:15:56 +11001375 int sent = 0;
Damien Millereba71ba2000-04-29 23:57:08 +10001376
Damien Miller280ecfb2003-05-14 13:46:00 +10001377 while ((id = TAILQ_FIRST(&authctxt->keys))) {
1378 if (id->tried++)
1379 return (0);
Darren Tuckerd05b6012003-10-15 15:55:59 +10001380 /* move key to the end of the queue */
Damien Miller280ecfb2003-05-14 13:46:00 +10001381 TAILQ_REMOVE(&authctxt->keys, id, next);
1382 TAILQ_INSERT_TAIL(&authctxt->keys, id, next);
1383 /*
1384 * send a test message if we have the public key. for
1385 * encrypted keys we cannot do this and have to load the
1386 * private key instead
1387 */
1388 if (id->key && id->key->type != KEY_RSA1) {
1389 debug("Offering public key: %s", id->filename);
1390 sent = send_pubkey_test(authctxt, id);
1391 } else if (id->key == NULL) {
1392 debug("Trying private key: %s", id->filename);
1393 id->key = load_identity_file(id->filename);
1394 if (id->key != NULL) {
1395 id->isprivate = 1;
1396 sent = sign_and_send_pubkey(authctxt, id);
1397 key_free(id->key);
1398 id->key = NULL;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001399 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +00001400 }
Damien Miller280ecfb2003-05-14 13:46:00 +10001401 if (sent)
1402 return (sent);
Damien Miller0bc1bd82000-11-13 22:57:25 +11001403 }
Damien Miller280ecfb2003-05-14 13:46:00 +10001404 return (0);
Damien Miller62cee002000-09-23 17:15:56 +11001405}
Damien Millereba71ba2000-04-29 23:57:08 +10001406
Damien Miller874d77b2000-10-14 16:23:11 +11001407/*
1408 * Send userauth request message specifying keyboard-interactive method.
1409 */
1410int
1411userauth_kbdint(Authctxt *authctxt)
1412{
1413 static int attempt = 0;
1414
1415 if (attempt++ >= options.number_of_password_prompts)
1416 return 0;
Ben Lindstrom7d199962001-09-12 18:29:00 +00001417 /* disable if no SSH2_MSG_USERAUTH_INFO_REQUEST has been seen */
1418 if (attempt > 1 && !authctxt->info_req_seen) {
1419 debug3("userauth_kbdint: disable: no info_req_seen");
1420 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);
1421 return 0;
1422 }
Damien Miller874d77b2000-10-14 16:23:11 +11001423
1424 debug2("userauth_kbdint");
1425 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1426 packet_put_cstring(authctxt->server_user);
1427 packet_put_cstring(authctxt->service);
1428 packet_put_cstring(authctxt->method->name);
1429 packet_put_cstring(""); /* lang */
1430 packet_put_cstring(options.kbd_interactive_devices ?
1431 options.kbd_interactive_devices : "");
1432 packet_send();
Damien Miller874d77b2000-10-14 16:23:11 +11001433
1434 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);
1435 return 1;
1436}
1437
1438/*
Ben Lindstrom03df5bd2001-02-10 22:16:41 +00001439 * parse INFO_REQUEST, prompt user and send INFO_RESPONSE
Damien Miller874d77b2000-10-14 16:23:11 +11001440 */
1441void
Damien Miller630d6f42002-01-22 23:17:30 +11001442input_userauth_info_req(int type, u_int32_t seq, void *ctxt)
Damien Miller874d77b2000-10-14 16:23:11 +11001443{
1444 Authctxt *authctxt = ctxt;
Ben Lindstrom03df5bd2001-02-10 22:16:41 +00001445 char *name, *inst, *lang, *prompt, *response;
Ben Lindstrom46c16222000-12-22 01:43:59 +00001446 u_int num_prompts, i;
Damien Miller874d77b2000-10-14 16:23:11 +11001447 int echo = 0;
1448
1449 debug2("input_userauth_info_req");
1450
1451 if (authctxt == NULL)
1452 fatal("input_userauth_info_req: no authentication context");
1453
Ben Lindstrom7d199962001-09-12 18:29:00 +00001454 authctxt->info_req_seen = 1;
1455
Damien Miller874d77b2000-10-14 16:23:11 +11001456 name = packet_get_string(NULL);
1457 inst = packet_get_string(NULL);
1458 lang = packet_get_string(NULL);
Damien Miller874d77b2000-10-14 16:23:11 +11001459 if (strlen(name) > 0)
Damien Miller996acd22003-04-09 20:59:48 +10001460 logit("%s", name);
Damien Miller874d77b2000-10-14 16:23:11 +11001461 if (strlen(inst) > 0)
Damien Miller996acd22003-04-09 20:59:48 +10001462 logit("%s", inst);
Ben Lindstrom03df5bd2001-02-10 22:16:41 +00001463 xfree(name);
Damien Miller874d77b2000-10-14 16:23:11 +11001464 xfree(inst);
Ben Lindstrom03df5bd2001-02-10 22:16:41 +00001465 xfree(lang);
Damien Miller874d77b2000-10-14 16:23:11 +11001466
1467 num_prompts = packet_get_int();
1468 /*
1469 * Begin to build info response packet based on prompts requested.
1470 * We commit to providing the correct number of responses, so if
1471 * further on we run into a problem that prevents this, we have to
1472 * be sure and clean this up and send a correct error response.
1473 */
1474 packet_start(SSH2_MSG_USERAUTH_INFO_RESPONSE);
1475 packet_put_int(num_prompts);
1476
Ben Lindstrom551ea372001-06-05 18:56:16 +00001477 debug2("input_userauth_info_req: num_prompts %d", num_prompts);
Damien Miller874d77b2000-10-14 16:23:11 +11001478 for (i = 0; i < num_prompts; i++) {
1479 prompt = packet_get_string(NULL);
1480 echo = packet_get_char();
1481
Ben Lindstrom949974b2001-06-25 05:20:31 +00001482 response = read_passphrase(prompt, echo ? RP_ECHO : 0);
Damien Miller874d77b2000-10-14 16:23:11 +11001483
Ben Lindstrom5699c5f2001-03-05 06:17:49 +00001484 packet_put_cstring(response);
Damien Miller874d77b2000-10-14 16:23:11 +11001485 memset(response, 0, strlen(response));
1486 xfree(response);
1487 xfree(prompt);
1488 }
Damien Miller48b03fc2002-01-22 23:11:40 +11001489 packet_check_eom(); /* done with parsing incoming message. */
Damien Miller874d77b2000-10-14 16:23:11 +11001490
Damien Miller9f643902001-11-12 11:02:52 +11001491 packet_add_padding(64);
Damien Miller874d77b2000-10-14 16:23:11 +11001492 packet_send();
Damien Miller874d77b2000-10-14 16:23:11 +11001493}
Damien Miller62cee002000-09-23 17:15:56 +11001494
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001495static int
Ben Lindstrom5c385522002-06-23 21:23:20 +00001496ssh_keysign(Key *key, u_char **sigp, u_int *lenp,
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001497 u_char *data, u_int datalen)
1498{
1499 Buffer b;
Ben Lindstrom5206b952002-06-06 19:59:29 +00001500 struct stat st;
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001501 pid_t pid;
Ben Lindstromcec2ea82002-06-06 20:51:04 +00001502 int to[2], from[2], status, version = 2;
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001503
Ben Lindstrom1d568f92002-12-23 02:44:36 +00001504 debug2("ssh_keysign called");
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001505
Ben Lindstrom5206b952002-06-06 19:59:29 +00001506 if (stat(_PATH_SSH_KEY_SIGN, &st) < 0) {
1507 error("ssh_keysign: no installed: %s", strerror(errno));
1508 return -1;
1509 }
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001510 if (fflush(stdout) != 0)
1511 error("ssh_keysign: fflush: %s", strerror(errno));
1512 if (pipe(to) < 0) {
1513 error("ssh_keysign: pipe: %s", strerror(errno));
1514 return -1;
1515 }
1516 if (pipe(from) < 0) {
1517 error("ssh_keysign: pipe: %s", strerror(errno));
1518 return -1;
1519 }
1520 if ((pid = fork()) < 0) {
1521 error("ssh_keysign: fork: %s", strerror(errno));
1522 return -1;
1523 }
1524 if (pid == 0) {
Damien Miller2e5fe882006-06-13 13:10:00 +10001525 permanently_drop_suid(getuid());
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001526 close(from[0]);
1527 if (dup2(from[1], STDOUT_FILENO) < 0)
1528 fatal("ssh_keysign: dup2: %s", strerror(errno));
1529 close(to[1]);
1530 if (dup2(to[0], STDIN_FILENO) < 0)
1531 fatal("ssh_keysign: dup2: %s", strerror(errno));
Ben Lindstromcec2ea82002-06-06 20:51:04 +00001532 close(from[1]);
1533 close(to[0]);
Ben Lindstrom4887da22002-06-06 20:05:57 +00001534 execl(_PATH_SSH_KEY_SIGN, _PATH_SSH_KEY_SIGN, (char *) 0);
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001535 fatal("ssh_keysign: exec(%s): %s", _PATH_SSH_KEY_SIGN,
1536 strerror(errno));
1537 }
1538 close(from[1]);
1539 close(to[0]);
1540
1541 buffer_init(&b);
Ben Lindstromcec2ea82002-06-06 20:51:04 +00001542 buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001543 buffer_put_string(&b, data, datalen);
Damien Miller51bf11f2003-11-17 21:20:47 +11001544 if (ssh_msg_send(to[1], version, &b) == -1)
1545 fatal("ssh_keysign: couldn't send request");
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001546
Damien Miller901119b2002-10-04 11:10:04 +10001547 if (ssh_msg_recv(from[0], &b) < 0) {
Ben Lindstrom5206b952002-06-06 19:59:29 +00001548 error("ssh_keysign: no reply");
Damien Millerfb1310e2004-01-21 11:02:50 +11001549 buffer_free(&b);
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001550 return -1;
1551 }
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001552 close(from[0]);
1553 close(to[1]);
1554
Ben Lindstromcec2ea82002-06-06 20:51:04 +00001555 while (waitpid(pid, &status, 0) < 0)
1556 if (errno != EINTR)
1557 break;
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001558
Ben Lindstrom5206b952002-06-06 19:59:29 +00001559 if (buffer_get_char(&b) != version) {
1560 error("ssh_keysign: bad version");
Damien Millerfb1310e2004-01-21 11:02:50 +11001561 buffer_free(&b);
Ben Lindstrom5206b952002-06-06 19:59:29 +00001562 return -1;
1563 }
1564 *sigp = buffer_get_string(&b, lenp);
Damien Millerfb1310e2004-01-21 11:02:50 +11001565 buffer_free(&b);
Ben Lindstrom5206b952002-06-06 19:59:29 +00001566
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001567 return 0;
1568}
1569
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001570int
1571userauth_hostbased(Authctxt *authctxt)
1572{
1573 Key *private = NULL;
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001574 Sensitive *sensitive = authctxt->sensitive;
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001575 Buffer b;
1576 u_char *signature, *blob;
Darren Tucker26c66622007-05-20 15:09:42 +10001577 char *chost, *pkalg, *p, myname[NI_MAXHOST];
Ben Lindstrom671388f2001-04-19 20:40:45 +00001578 const char *service;
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001579 u_int blen, slen;
Ben Lindstrom2bffd6f2001-04-19 20:35:40 +00001580 int ok, i, len, found = 0;
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001581
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001582 /* check for a useful key */
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001583 for (i = 0; i < sensitive->nkeys; i++) {
1584 private = sensitive->keys[i];
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001585 if (private && private->type != KEY_RSA1) {
1586 found = 1;
1587 /* we take and free the key */
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001588 sensitive->keys[i] = NULL;
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001589 break;
1590 }
1591 }
1592 if (!found) {
Ben Lindstrom1d568f92002-12-23 02:44:36 +00001593 debug("No more client hostkeys for hostbased authentication.");
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001594 return 0;
1595 }
1596 if (key_to_blob(private, &blob, &blen) == 0) {
1597 key_free(private);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001598 return 0;
1599 }
Damien Miller91c18472001-11-12 11:02:03 +11001600 /* figure out a name for the client host */
Darren Tucker26c66622007-05-20 15:09:42 +10001601 p = NULL;
1602 if (packet_connection_is_on_socket())
1603 p = get_local_name(packet_get_connection_in());
1604 if (p == NULL) {
1605 if (gethostname(myname, sizeof(myname)) == -1) {
1606 verbose("userauth_hostbased: gethostname: %s",
1607 strerror(errno));
1608 } else
1609 p = xstrdup(myname);
1610 }
Damien Miller91c18472001-11-12 11:02:03 +11001611 if (p == NULL) {
1612 error("userauth_hostbased: cannot get local ipaddr/name");
1613 key_free(private);
Damien Miller5790b592006-03-26 13:54:03 +11001614 xfree(blob);
Damien Miller91c18472001-11-12 11:02:03 +11001615 return 0;
1616 }
1617 len = strlen(p) + 2;
Damien Miller07d86be2006-03-26 14:19:21 +11001618 xasprintf(&chost, "%s.", p);
Damien Miller91c18472001-11-12 11:02:03 +11001619 debug2("userauth_hostbased: chost %s", chost);
Damien Miller00111382003-03-10 11:21:17 +11001620 xfree(p);
Damien Miller91c18472001-11-12 11:02:03 +11001621
Ben Lindstrom671388f2001-04-19 20:40:45 +00001622 service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :
1623 authctxt->service;
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001624 pkalg = xstrdup(key_ssh_name(private));
1625 buffer_init(&b);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001626 /* construct data */
Ben Lindstrom671388f2001-04-19 20:40:45 +00001627 buffer_put_string(&b, session_id2, session_id2_len);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001628 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
1629 buffer_put_cstring(&b, authctxt->server_user);
Ben Lindstrom671388f2001-04-19 20:40:45 +00001630 buffer_put_cstring(&b, service);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001631 buffer_put_cstring(&b, authctxt->method->name);
1632 buffer_put_cstring(&b, pkalg);
1633 buffer_put_string(&b, blob, blen);
1634 buffer_put_cstring(&b, chost);
1635 buffer_put_cstring(&b, authctxt->local_user);
1636#ifdef DEBUG_PK
1637 buffer_dump(&b);
1638#endif
Ben Lindstrom1bad2562002-06-06 19:57:33 +00001639 if (sensitive->external_keysign)
1640 ok = ssh_keysign(private, &signature, &slen,
1641 buffer_ptr(&b), buffer_len(&b));
1642 else
1643 ok = key_sign(private, &signature, &slen,
1644 buffer_ptr(&b), buffer_len(&b));
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001645 key_free(private);
1646 buffer_free(&b);
1647 if (ok != 0) {
1648 error("key_sign failed");
1649 xfree(chost);
1650 xfree(pkalg);
Damien Miller5790b592006-03-26 13:54:03 +11001651 xfree(blob);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001652 return 0;
1653 }
1654 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1655 packet_put_cstring(authctxt->server_user);
1656 packet_put_cstring(authctxt->service);
1657 packet_put_cstring(authctxt->method->name);
1658 packet_put_cstring(pkalg);
1659 packet_put_string(blob, blen);
1660 packet_put_cstring(chost);
1661 packet_put_cstring(authctxt->local_user);
1662 packet_put_string(signature, slen);
1663 memset(signature, 's', slen);
1664 xfree(signature);
1665 xfree(chost);
1666 xfree(pkalg);
Damien Miller5790b592006-03-26 13:54:03 +11001667 xfree(blob);
Ben Lindstrom5eabda32001-04-12 23:34:34 +00001668
1669 packet_send();
1670 return 1;
1671}
1672
Damien Miller01ed2272008-11-05 16:20:46 +11001673#ifdef JPAKE
1674int
1675userauth_jpake(Authctxt *authctxt)
1676{
1677 struct jpake_ctx *pctx;
1678 u_char *x1_proof, *x2_proof;
1679 u_int x1_proof_len, x2_proof_len;
1680 static int attempt = 0; /* XXX share with userauth_password's? */
1681
1682 if (attempt++ >= options.number_of_password_prompts)
1683 return 0;
1684 if (attempt != 1)
1685 error("Permission denied, please try again.");
1686
1687 if (authctxt->methoddata != NULL)
1688 fatal("%s: authctxt->methoddata already set (%p)",
1689 __func__, authctxt->methoddata);
1690
1691 authctxt->methoddata = pctx = jpake_new();
1692
1693 /*
1694 * Send request immediately, to get the protocol going while
1695 * we do the initial computations.
1696 */
1697 packet_start(SSH2_MSG_USERAUTH_REQUEST);
1698 packet_put_cstring(authctxt->server_user);
1699 packet_put_cstring(authctxt->service);
1700 packet_put_cstring(authctxt->method->name);
1701 packet_send();
1702 packet_write_wait();
1703
1704 jpake_step1(pctx->grp,
1705 &pctx->client_id, &pctx->client_id_len,
1706 &pctx->x1, &pctx->x2, &pctx->g_x1, &pctx->g_x2,
1707 &x1_proof, &x1_proof_len,
1708 &x2_proof, &x2_proof_len);
1709
1710 JPAKE_DEBUG_CTX((pctx, "step 1 sending in %s", __func__));
1711
1712 packet_start(SSH2_MSG_USERAUTH_JPAKE_CLIENT_STEP1);
1713 packet_put_string(pctx->client_id, pctx->client_id_len);
1714 packet_put_bignum2(pctx->g_x1);
1715 packet_put_bignum2(pctx->g_x2);
1716 packet_put_string(x1_proof, x1_proof_len);
1717 packet_put_string(x2_proof, x2_proof_len);
1718 packet_send();
1719
1720 bzero(x1_proof, x1_proof_len);
1721 bzero(x2_proof, x2_proof_len);
1722 xfree(x1_proof);
1723 xfree(x2_proof);
1724
1725 /* Expect step 1 packet from peer */
1726 dispatch_set(SSH2_MSG_USERAUTH_JPAKE_SERVER_STEP1,
1727 input_userauth_jpake_server_step1);
Darren Tucker2f29a8c2009-10-24 11:47:58 +11001728 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS,
1729 &input_userauth_success_unexpected);
Damien Miller01ed2272008-11-05 16:20:46 +11001730
1731 return 1;
1732}
1733
1734void
1735userauth_jpake_cleanup(Authctxt *authctxt)
1736{
1737 debug3("%s: clean up", __func__);
1738 if (authctxt->methoddata != NULL) {
1739 jpake_free(authctxt->methoddata);
1740 authctxt->methoddata = NULL;
1741 }
Darren Tucker2f29a8c2009-10-24 11:47:58 +11001742 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
Damien Miller01ed2272008-11-05 16:20:46 +11001743}
1744#endif /* JPAKE */
1745
Damien Miller62cee002000-09-23 17:15:56 +11001746/* find auth method */
1747
Damien Miller62cee002000-09-23 17:15:56 +11001748/*
1749 * given auth method name, if configurable options permit this method fill
1750 * in auth_ident field and return true, otherwise return false.
1751 */
Ben Lindstrombba81212001-06-25 05:01:22 +00001752static int
Damien Miller62cee002000-09-23 17:15:56 +11001753authmethod_is_enabled(Authmethod *method)
1754{
1755 if (method == NULL)
1756 return 0;
1757 /* return false if options indicate this method is disabled */
1758 if (method->enabled == NULL || *method->enabled == 0)
1759 return 0;
1760 /* return false if batch mode is enabled but method needs interactive mode */
1761 if (method->batch_flag != NULL && *method->batch_flag != 0)
1762 return 0;
1763 return 1;
1764}
1765
Ben Lindstrombba81212001-06-25 05:01:22 +00001766static Authmethod *
Damien Miller62cee002000-09-23 17:15:56 +11001767authmethod_lookup(const char *name)
1768{
1769 Authmethod *method = NULL;
1770 if (name != NULL)
1771 for (method = authmethods; method->name != NULL; method++)
1772 if (strcmp(name, method->name) == 0)
1773 return method;
1774 debug2("Unrecognized authentication method name: %s", name ? name : "NULL");
1775 return NULL;
1776}
1777
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001778/* XXX internal state */
1779static Authmethod *current = NULL;
1780static char *supported = NULL;
1781static char *preferred = NULL;
Ben Lindstrom5c385522002-06-23 21:23:20 +00001782
Damien Miller62cee002000-09-23 17:15:56 +11001783/*
1784 * Given the authentication method list sent by the server, return the
1785 * next method we should try. If the server initially sends a nil list,
Ben Lindstroma3700052001-04-05 23:26:32 +00001786 * use a built-in default list.
Kevin Stevesef4eea92001-02-05 12:42:17 +00001787 */
Ben Lindstrombba81212001-06-25 05:01:22 +00001788static Authmethod *
Damien Miller62cee002000-09-23 17:15:56 +11001789authmethod_get(char *authlist)
1790{
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001791 char *name = NULL;
Ben Lindstromc58ab022002-02-26 18:15:09 +00001792 u_int next;
Kevin Stevesef4eea92001-02-05 12:42:17 +00001793
Damien Miller62cee002000-09-23 17:15:56 +11001794 /* Use a suitable default if we're passed a nil list. */
1795 if (authlist == NULL || strlen(authlist) == 0)
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001796 authlist = options.preferred_authentications;
Damien Miller62cee002000-09-23 17:15:56 +11001797
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001798 if (supported == NULL || strcmp(authlist, supported) != 0) {
1799 debug3("start over, passed a different list %s", authlist);
1800 if (supported != NULL)
1801 xfree(supported);
1802 supported = xstrdup(authlist);
1803 preferred = options.preferred_authentications;
1804 debug3("preferred %s", preferred);
1805 current = NULL;
1806 } else if (current != NULL && authmethod_is_enabled(current))
1807 return current;
Damien Millereba71ba2000-04-29 23:57:08 +10001808
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001809 for (;;) {
1810 if ((name = match_list(preferred, supported, &next)) == NULL) {
Ben Lindstrom1d568f92002-12-23 02:44:36 +00001811 debug("No more authentication methods to try.");
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001812 current = NULL;
1813 return NULL;
Damien Miller874d77b2000-10-14 16:23:11 +11001814 }
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001815 preferred += next;
1816 debug3("authmethod_lookup %s", name);
1817 debug3("remaining preferred: %s", preferred);
1818 if ((current = authmethod_lookup(name)) != NULL &&
1819 authmethod_is_enabled(current)) {
1820 debug3("authmethod_is_enabled %s", name);
Ben Lindstrom1d568f92002-12-23 02:44:36 +00001821 debug("Next authentication method: %s", name);
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001822 return current;
1823 }
Damien Millereba71ba2000-04-29 23:57:08 +10001824 }
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001825}
Damien Miller62cee002000-09-23 17:15:56 +11001826
Ben Lindstrom79073822001-07-04 03:42:30 +00001827static char *
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001828authmethods_get(void)
1829{
1830 Authmethod *method = NULL;
Damien Miller0e3b8722002-01-22 23:26:38 +11001831 Buffer b;
1832 char *list;
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001833
Damien Miller0e3b8722002-01-22 23:26:38 +11001834 buffer_init(&b);
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001835 for (method = authmethods; method->name != NULL; method++) {
1836 if (authmethod_is_enabled(method)) {
Damien Miller0e3b8722002-01-22 23:26:38 +11001837 if (buffer_len(&b) > 0)
1838 buffer_append(&b, ",", 1);
1839 buffer_append(&b, method->name, strlen(method->name));
Ben Lindstromb9be60a2001-03-11 01:49:19 +00001840 }
Damien Miller62cee002000-09-23 17:15:56 +11001841 }
Damien Miller0e3b8722002-01-22 23:26:38 +11001842 buffer_append(&b, "\0", 1);
1843 list = xstrdup(buffer_ptr(&b));
1844 buffer_free(&b);
1845 return list;
Damien Millereba71ba2000-04-29 23:57:08 +10001846}
Damien Miller01ed2272008-11-05 16:20:46 +11001847