blob: 14e3d401a78aa77752807c64e2e043c11465b99b [file] [log] [blame]
Damien Millereba71ba2000-04-29 23:57:08 +10001/*
2 * Copyright (c) 2000 Markus Friedl. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
Damien Millereba71ba2000-04-29 23:57:08 +100012 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 */
24
25#include "includes.h"
Ben Lindstrom671388f2001-04-19 20:40:45 +000026RCSID("$OpenBSD: sshconnect2.c,v 1.72 2001/04/18 23:43:26 markus Exp $");
Damien Millereba71ba2000-04-29 23:57:08 +100027
28#include <openssl/bn.h>
Damien Millereba71ba2000-04-29 23:57:08 +100029#include <openssl/md5.h>
30#include <openssl/dh.h>
31#include <openssl/hmac.h>
32
33#include "ssh.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000034#include "ssh2.h"
Damien Millereba71ba2000-04-29 23:57:08 +100035#include "xmalloc.h"
36#include "rsa.h"
37#include "buffer.h"
38#include "packet.h"
Damien Millereba71ba2000-04-29 23:57:08 +100039#include "uidswap.h"
40#include "compat.h"
Damien Millereba71ba2000-04-29 23:57:08 +100041#include "bufaux.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000042#include "cipher.h"
Damien Millereba71ba2000-04-29 23:57:08 +100043#include "kex.h"
44#include "myproposal.h"
45#include "key.h"
Damien Millereba71ba2000-04-29 23:57:08 +100046#include "sshconnect.h"
47#include "authfile.h"
Damien Miller874d77b2000-10-14 16:23:11 +110048#include "cli.h"
Ben Lindstromdf221392001-03-29 00:36:16 +000049#include "dh.h"
Damien Millerad833b32000-08-23 10:46:23 +100050#include "authfd.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000051#include "log.h"
52#include "readconf.h"
53#include "readpass.h"
Ben Lindstromb9be60a2001-03-11 01:49:19 +000054#include "match.h"
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000055#include "dispatch.h"
Ben Lindstrom5eabda32001-04-12 23:34:34 +000056#include "canohost.h"
Damien Miller874d77b2000-10-14 16:23:11 +110057
Damien Millereba71ba2000-04-29 23:57:08 +100058/* import */
59extern char *client_version_string;
60extern char *server_version_string;
61extern Options options;
62
63/*
64 * SSH2 key exchange
65 */
66
Ben Lindstrom46c16222000-12-22 01:43:59 +000067u_char *session_id2 = NULL;
Damien Millereba71ba2000-04-29 23:57:08 +100068int session_id2_len = 0;
69
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000070char *xxx_host;
71struct sockaddr *xxx_hostaddr;
72
Ben Lindstromf28f6342001-04-04 02:03:04 +000073Kex *xxx_kex = NULL;
74
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000075int
76check_host_key_callback(Key *hostkey)
77{
78 check_host_key(xxx_host, xxx_hostaddr, hostkey,
79 options.user_hostfile2, options.system_hostfile2);
80 return 0;
81}
82
Damien Millereba71ba2000-04-29 23:57:08 +100083void
Damien Miller874d77b2000-10-14 16:23:11 +110084ssh_kex2(char *host, struct sockaddr *hostaddr)
85{
Damien Miller874d77b2000-10-14 16:23:11 +110086 Kex *kex;
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +000087
88 xxx_host = host;
89 xxx_hostaddr = hostaddr;
Damien Miller874d77b2000-10-14 16:23:11 +110090
Damien Millere39cacc2000-11-29 12:18:44 +110091 if (options.ciphers == (char *)-1) {
92 log("No valid ciphers for protocol version 2 given, using defaults.");
93 options.ciphers = NULL;
Damien Miller874d77b2000-10-14 16:23:11 +110094 }
95 if (options.ciphers != NULL) {
96 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
97 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
98 }
Damien Millera0ff4662001-03-30 10:49:35 +100099 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
100 compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_CTOS]);
101 myproposal[PROPOSAL_ENC_ALGS_STOC] =
102 compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_STOC]);
Damien Miller874d77b2000-10-14 16:23:11 +1100103 if (options.compression) {
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000104 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
Damien Miller874d77b2000-10-14 16:23:11 +1100105 myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib";
106 } else {
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000107 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
Damien Miller874d77b2000-10-14 16:23:11 +1100108 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none";
109 }
Ben Lindstrom06b33aa2001-02-15 03:01:59 +0000110 if (options.macs != NULL) {
111 myproposal[PROPOSAL_MAC_ALGS_CTOS] =
112 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
113 }
Ben Lindstrom982dbbc2001-04-17 18:11:36 +0000114 if (options.hostkeyalgorithms != NULL)
115 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
116 options.hostkeyalgorithms;
Damien Miller874d77b2000-10-14 16:23:11 +1100117
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000118 /* start key exchange */
Ben Lindstrom238abf62001-04-04 17:52:53 +0000119 kex = kex_setup(myproposal);
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +0000120 kex->client_version_string=client_version_string;
121 kex->server_version_string=server_version_string;
122 kex->check_host_key=&check_host_key_callback;
Damien Miller874d77b2000-10-14 16:23:11 +1100123
Ben Lindstromf28f6342001-04-04 02:03:04 +0000124 xxx_kex = kex;
125
Ben Lindstrombe2cc432001-04-04 23:46:07 +0000126 dispatch_run(DISPATCH_BLOCK, &kex->done, kex);
Damien Miller874d77b2000-10-14 16:23:11 +1100127
Ben Lindstrom2d90e002001-04-04 02:00:54 +0000128 session_id2 = kex->session_id;
129 session_id2_len = kex->session_id_len;
130
Damien Miller874d77b2000-10-14 16:23:11 +1100131#ifdef DEBUG_KEXDH
132 /* send 1st encrypted/maced/compressed message */
133 packet_start(SSH2_MSG_IGNORE);
134 packet_put_cstring("markus");
135 packet_send();
136 packet_write_wait();
137#endif
Ben Lindstrom20d7c7b2001-04-04 01:56:17 +0000138 debug("done: ssh_kex2.");
Damien Millereba71ba2000-04-29 23:57:08 +1000139}
Damien Millerb1715dc2000-05-30 13:44:51 +1000140
Damien Millereba71ba2000-04-29 23:57:08 +1000141/*
142 * Authenticate user
143 */
Damien Miller62cee002000-09-23 17:15:56 +1100144
145typedef struct Authctxt Authctxt;
146typedef struct Authmethod Authmethod;
147
148typedef int sign_cb_fn(
149 Authctxt *authctxt, Key *key,
Ben Lindstrom46c16222000-12-22 01:43:59 +0000150 u_char **sigp, int *lenp, u_char *data, int datalen);
Damien Miller62cee002000-09-23 17:15:56 +1100151
152struct Authctxt {
153 const char *server_user;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000154 const char *local_user;
Damien Miller62cee002000-09-23 17:15:56 +1100155 const char *host;
156 const char *service;
Damien Miller62cee002000-09-23 17:15:56 +1100157 Authmethod *method;
Damien Miller874d77b2000-10-14 16:23:11 +1100158 int success;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000159 char *authlist;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000160 /* pubkey */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000161 Key *last_key;
162 sign_cb_fn *last_key_sign;
163 int last_key_hint;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000164 AuthenticationConnection *agent;
165 /* hostbased */
166 Key **keys;
167 int nkeys;
Damien Miller62cee002000-09-23 17:15:56 +1100168};
169struct Authmethod {
170 char *name; /* string to compare against server's list */
171 int (*userauth)(Authctxt *authctxt);
172 int *enabled; /* flag in option struct that enables method */
173 int *batch_flag; /* flag in option struct that disables method */
174};
175
176void input_userauth_success(int type, int plen, void *ctxt);
177void input_userauth_failure(int type, int plen, void *ctxt);
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000178void input_userauth_banner(int type, int plen, void *ctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100179void input_userauth_error(int type, int plen, void *ctxt);
Damien Miller874d77b2000-10-14 16:23:11 +1100180void input_userauth_info_req(int type, int plen, void *ctxt);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000181void input_userauth_pk_ok(int type, int plen, void *ctxt);
Damien Miller874d77b2000-10-14 16:23:11 +1100182
183int userauth_none(Authctxt *authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100184int userauth_pubkey(Authctxt *authctxt);
185int userauth_passwd(Authctxt *authctxt);
Damien Miller874d77b2000-10-14 16:23:11 +1100186int userauth_kbdint(Authctxt *authctxt);
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000187int userauth_hostbased(Authctxt *authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100188
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000189void userauth(Authctxt *authctxt, char *authlist);
190
191int
192sign_and_send_pubkey(Authctxt *authctxt, Key *k,
193 sign_cb_fn *sign_callback);
194void clear_auth_state(Authctxt *authctxt);
195
Damien Miller874d77b2000-10-14 16:23:11 +1100196Authmethod *authmethod_get(char *authlist);
197Authmethod *authmethod_lookup(const char *name);
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000198char *authmethods_get(void);
Damien Miller62cee002000-09-23 17:15:56 +1100199
200Authmethod authmethods[] = {
201 {"publickey",
202 userauth_pubkey,
Damien Miller0bc1bd82000-11-13 22:57:25 +1100203 &options.pubkey_authentication,
Damien Miller62cee002000-09-23 17:15:56 +1100204 NULL},
205 {"password",
206 userauth_passwd,
207 &options.password_authentication,
208 &options.batch_mode},
Damien Miller874d77b2000-10-14 16:23:11 +1100209 {"keyboard-interactive",
210 userauth_kbdint,
211 &options.kbd_interactive_authentication,
212 &options.batch_mode},
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000213 {"hostbased",
214 userauth_hostbased,
215 &options.hostbased_authentication,
216 NULL},
Damien Miller874d77b2000-10-14 16:23:11 +1100217 {"none",
218 userauth_none,
219 NULL,
220 NULL},
Damien Miller62cee002000-09-23 17:15:56 +1100221 {NULL, NULL, NULL, NULL}
222};
223
224void
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000225ssh_userauth2(const char *local_user, const char *server_user, char *host,
226 Key **keys, int nkeys)
Damien Miller62cee002000-09-23 17:15:56 +1100227{
228 Authctxt authctxt;
229 int type;
230 int plen;
231
Ben Lindstrom95fb2dd2001-01-23 03:12:10 +0000232 if (options.challenge_reponse_authentication)
233 options.kbd_interactive_authentication = 1;
234
Damien Miller62cee002000-09-23 17:15:56 +1100235 debug("send SSH2_MSG_SERVICE_REQUEST");
236 packet_start(SSH2_MSG_SERVICE_REQUEST);
237 packet_put_cstring("ssh-userauth");
238 packet_send();
239 packet_write_wait();
240 type = packet_read(&plen);
241 if (type != SSH2_MSG_SERVICE_ACCEPT) {
242 fatal("denied SSH2_MSG_SERVICE_ACCEPT: %d", type);
243 }
244 if (packet_remaining() > 0) {
245 char *reply = packet_get_string(&plen);
246 debug("service_accept: %s", reply);
247 xfree(reply);
Damien Miller62cee002000-09-23 17:15:56 +1100248 } else {
249 debug("buggy server: service_accept w/o service");
250 }
251 packet_done();
252 debug("got SSH2_MSG_SERVICE_ACCEPT");
253
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000254 if (options.preferred_authentications == NULL)
255 options.preferred_authentications = authmethods_get();
256
Damien Miller62cee002000-09-23 17:15:56 +1100257 /* setup authentication context */
258 authctxt.agent = ssh_get_authentication_connection();
259 authctxt.server_user = server_user;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000260 authctxt.local_user = local_user;
Damien Miller62cee002000-09-23 17:15:56 +1100261 authctxt.host = host;
262 authctxt.service = "ssh-connection"; /* service name */
263 authctxt.success = 0;
Damien Miller874d77b2000-10-14 16:23:11 +1100264 authctxt.method = authmethod_lookup("none");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000265 authctxt.authlist = NULL;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000266 authctxt.keys = keys;
267 authctxt.nkeys = nkeys;
Damien Miller874d77b2000-10-14 16:23:11 +1100268 if (authctxt.method == NULL)
269 fatal("ssh_userauth2: internal error: cannot send userauth none request");
Damien Miller62cee002000-09-23 17:15:56 +1100270
271 /* initial userauth request */
Damien Miller874d77b2000-10-14 16:23:11 +1100272 userauth_none(&authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100273
Ben Lindstrom8ac91062001-04-04 17:57:54 +0000274 dispatch_init(&input_userauth_error);
Damien Miller62cee002000-09-23 17:15:56 +1100275 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
276 dispatch_set(SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000277 dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
Damien Miller62cee002000-09-23 17:15:56 +1100278 dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt); /* loop until success */
279
280 if (authctxt.agent != NULL)
281 ssh_close_authentication_connection(authctxt.agent);
282
Ben Lindstrom4dccfa52000-12-28 16:40:05 +0000283 debug("ssh-userauth2 successful: method %s", authctxt.method->name);
Damien Miller62cee002000-09-23 17:15:56 +1100284}
285void
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000286userauth(Authctxt *authctxt, char *authlist)
287{
288 if (authlist == NULL) {
289 authlist = authctxt->authlist;
290 } else {
291 if (authctxt->authlist)
292 xfree(authctxt->authlist);
293 authctxt->authlist = authlist;
294 }
295 for (;;) {
296 Authmethod *method = authmethod_get(authlist);
297 if (method == NULL)
298 fatal("Permission denied (%s).", authlist);
299 authctxt->method = method;
300 if (method->userauth(authctxt) != 0) {
301 debug2("we sent a %s packet, wait for reply", method->name);
302 break;
303 } else {
304 debug2("we did not send a packet, disable method");
305 method->enabled = NULL;
306 }
307 }
308}
309void
Damien Miller62cee002000-09-23 17:15:56 +1100310input_userauth_error(int type, int plen, void *ctxt)
311{
Ben Lindstromd26dcf32001-01-06 15:18:16 +0000312 fatal("input_userauth_error: bad message during authentication: "
313 "type %d", type);
314}
315void
316input_userauth_banner(int type, int plen, void *ctxt)
317{
318 char *msg, *lang;
319 debug3("input_userauth_banner");
320 msg = packet_get_string(NULL);
321 lang = packet_get_string(NULL);
322 fprintf(stderr, "%s", msg);
323 xfree(msg);
324 xfree(lang);
Damien Miller62cee002000-09-23 17:15:56 +1100325}
326void
327input_userauth_success(int type, int plen, void *ctxt)
328{
329 Authctxt *authctxt = ctxt;
330 if (authctxt == NULL)
331 fatal("input_userauth_success: no authentication context");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000332 if (authctxt->authlist)
333 xfree(authctxt->authlist);
334 clear_auth_state(authctxt);
Damien Miller62cee002000-09-23 17:15:56 +1100335 authctxt->success = 1; /* break out */
336}
337void
338input_userauth_failure(int type, int plen, void *ctxt)
339{
Damien Miller62cee002000-09-23 17:15:56 +1100340 Authctxt *authctxt = ctxt;
341 char *authlist = NULL;
342 int partial;
Damien Miller62cee002000-09-23 17:15:56 +1100343
344 if (authctxt == NULL)
345 fatal("input_userauth_failure: no authentication context");
346
Damien Miller874d77b2000-10-14 16:23:11 +1100347 authlist = packet_get_string(NULL);
Damien Miller62cee002000-09-23 17:15:56 +1100348 partial = packet_get_char();
349 packet_done();
350
351 if (partial != 0)
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000352 log("Authenticated with partial success.");
Damien Miller62cee002000-09-23 17:15:56 +1100353 debug("authentications that can continue: %s", authlist);
354
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000355 clear_auth_state(authctxt);
356 userauth(authctxt, authlist);
357}
358void
359input_userauth_pk_ok(int type, int plen, void *ctxt)
360{
361 Authctxt *authctxt = ctxt;
362 Key *key = NULL;
363 Buffer b;
Ben Lindstrom206941f2001-04-15 14:27:16 +0000364 int alen, blen, sent = 0;
Ben Lindstromcfccef92001-03-13 04:57:58 +0000365 char *pkalg, *pkblob, *fp;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000366
367 if (authctxt == NULL)
368 fatal("input_userauth_pk_ok: no authentication context");
369 if (datafellows & SSH_BUG_PKOK) {
370 /* this is similar to SSH_BUG_PKAUTH */
371 debug2("input_userauth_pk_ok: SSH_BUG_PKOK");
372 pkblob = packet_get_string(&blen);
373 buffer_init(&b);
374 buffer_append(&b, pkblob, blen);
375 pkalg = buffer_get_string(&b, &alen);
376 buffer_free(&b);
377 } else {
378 pkalg = packet_get_string(&alen);
379 pkblob = packet_get_string(&blen);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000380 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000381 packet_done();
382
383 debug("input_userauth_pk_ok: pkalg %s blen %d lastkey %p hint %d",
384 pkalg, blen, authctxt->last_key, authctxt->last_key_hint);
385
386 do {
387 if (authctxt->last_key == NULL ||
388 authctxt->last_key_sign == NULL) {
389 debug("no last key or no sign cb");
390 break;
391 }
Ben Lindstrom206941f2001-04-15 14:27:16 +0000392 if (key_type_from_name(pkalg) == KEY_UNSPEC) {
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000393 debug("unknown pkalg %s", pkalg);
394 break;
395 }
396 if ((key = key_from_blob(pkblob, blen)) == NULL) {
397 debug("no key from blob. pkalg %s", pkalg);
398 break;
399 }
Ben Lindstromcfccef92001-03-13 04:57:58 +0000400 fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);
401 debug2("input_userauth_pk_ok: fp %s", fp);
402 xfree(fp);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000403 if (!key_equal(key, authctxt->last_key)) {
404 debug("key != last_key");
405 break;
406 }
407 sent = sign_and_send_pubkey(authctxt, key,
408 authctxt->last_key_sign);
409 } while(0);
410
411 if (key != NULL)
412 key_free(key);
413 xfree(pkalg);
414 xfree(pkblob);
415
416 /* unregister */
417 clear_auth_state(authctxt);
418 dispatch_set(SSH2_MSG_USERAUTH_PK_OK, NULL);
419
420 /* try another method if we did not send a packet*/
421 if (sent == 0)
422 userauth(authctxt, NULL);
423
Damien Miller62cee002000-09-23 17:15:56 +1100424}
425
Damien Millereba71ba2000-04-29 23:57:08 +1000426int
Damien Miller874d77b2000-10-14 16:23:11 +1100427userauth_none(Authctxt *authctxt)
428{
429 /* initial userauth request */
430 packet_start(SSH2_MSG_USERAUTH_REQUEST);
431 packet_put_cstring(authctxt->server_user);
432 packet_put_cstring(authctxt->service);
433 packet_put_cstring(authctxt->method->name);
434 packet_send();
Damien Miller874d77b2000-10-14 16:23:11 +1100435 return 1;
436}
437
438int
Damien Miller62cee002000-09-23 17:15:56 +1100439userauth_passwd(Authctxt *authctxt)
Damien Millereba71ba2000-04-29 23:57:08 +1000440{
Damien Millere247cc42000-05-07 12:03:14 +1000441 static int attempt = 0;
Damien Millereba71ba2000-04-29 23:57:08 +1000442 char prompt[80];
443 char *password;
444
Damien Millerd3a18572000-06-07 19:55:44 +1000445 if (attempt++ >= options.number_of_password_prompts)
Damien Millere247cc42000-05-07 12:03:14 +1000446 return 0;
447
Damien Millerd3a18572000-06-07 19:55:44 +1000448 if(attempt != 1)
449 error("Permission denied, please try again.");
450
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000451 snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
Damien Miller62cee002000-09-23 17:15:56 +1100452 authctxt->server_user, authctxt->host);
Damien Millereba71ba2000-04-29 23:57:08 +1000453 password = read_passphrase(prompt, 0);
454 packet_start(SSH2_MSG_USERAUTH_REQUEST);
Damien Miller62cee002000-09-23 17:15:56 +1100455 packet_put_cstring(authctxt->server_user);
456 packet_put_cstring(authctxt->service);
Damien Miller874d77b2000-10-14 16:23:11 +1100457 packet_put_cstring(authctxt->method->name);
Damien Millereba71ba2000-04-29 23:57:08 +1000458 packet_put_char(0);
Ben Lindstrom5699c5f2001-03-05 06:17:49 +0000459 packet_put_cstring(password);
Damien Millereba71ba2000-04-29 23:57:08 +1000460 memset(password, 0, strlen(password));
461 xfree(password);
Ben Lindstrom5699c5f2001-03-05 06:17:49 +0000462 packet_inject_ignore(64);
Damien Millereba71ba2000-04-29 23:57:08 +1000463 packet_send();
Damien Millereba71ba2000-04-29 23:57:08 +1000464 return 1;
465}
466
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000467void
468clear_auth_state(Authctxt *authctxt)
469{
470 /* XXX clear authentication state */
471 if (authctxt->last_key != NULL && authctxt->last_key_hint == -1) {
472 debug3("clear_auth_state: key_free %p", authctxt->last_key);
473 key_free(authctxt->last_key);
474 }
475 authctxt->last_key = NULL;
476 authctxt->last_key_hint = -2;
477 authctxt->last_key_sign = NULL;
478}
479
Damien Millerad833b32000-08-23 10:46:23 +1000480int
Damien Miller62cee002000-09-23 17:15:56 +1100481sign_and_send_pubkey(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback)
Damien Millereba71ba2000-04-29 23:57:08 +1000482{
483 Buffer b;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000484 u_char *blob, *signature;
Damien Millereba71ba2000-04-29 23:57:08 +1000485 int bloblen, slen;
Damien Miller6536c7d2000-06-22 21:32:31 +1000486 int skip = 0;
Damien Millerad833b32000-08-23 10:46:23 +1000487 int ret = -1;
Damien Miller874d77b2000-10-14 16:23:11 +1100488 int have_sig = 1;
Damien Millereba71ba2000-04-29 23:57:08 +1000489
Ben Lindstromd121f612000-12-03 17:00:47 +0000490 debug3("sign_and_send_pubkey");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000491
Damien Miller0bc1bd82000-11-13 22:57:25 +1100492 if (key_to_blob(k, &blob, &bloblen) == 0) {
493 /* we cannot handle this key */
Ben Lindstromd121f612000-12-03 17:00:47 +0000494 debug3("sign_and_send_pubkey: cannot handle key");
Damien Miller0bc1bd82000-11-13 22:57:25 +1100495 return 0;
496 }
Damien Millereba71ba2000-04-29 23:57:08 +1000497 /* data to be signed */
498 buffer_init(&b);
Damien Miller50a41ed2000-10-16 12:14:42 +1100499 if (datafellows & SSH_OLD_SESSIONID) {
Damien Miller6536c7d2000-06-22 21:32:31 +1000500 buffer_append(&b, session_id2, session_id2_len);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000501 skip = session_id2_len;
Damien Miller50a41ed2000-10-16 12:14:42 +1100502 } else {
503 buffer_put_string(&b, session_id2, session_id2_len);
504 skip = buffer_len(&b);
Damien Miller6536c7d2000-06-22 21:32:31 +1000505 }
Damien Millereba71ba2000-04-29 23:57:08 +1000506 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
Damien Miller62cee002000-09-23 17:15:56 +1100507 buffer_put_cstring(&b, authctxt->server_user);
Damien Miller30c3d422000-05-09 11:02:59 +1000508 buffer_put_cstring(&b,
Ben Lindstromd121f612000-12-03 17:00:47 +0000509 datafellows & SSH_BUG_PKSERVICE ?
Damien Miller30c3d422000-05-09 11:02:59 +1000510 "ssh-userauth" :
Damien Miller62cee002000-09-23 17:15:56 +1100511 authctxt->service);
Ben Lindstromd121f612000-12-03 17:00:47 +0000512 if (datafellows & SSH_BUG_PKAUTH) {
513 buffer_put_char(&b, have_sig);
514 } else {
515 buffer_put_cstring(&b, authctxt->method->name);
516 buffer_put_char(&b, have_sig);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000517 buffer_put_cstring(&b, key_ssh_name(k));
Ben Lindstromd121f612000-12-03 17:00:47 +0000518 }
Damien Millereba71ba2000-04-29 23:57:08 +1000519 buffer_put_string(&b, blob, bloblen);
Damien Millereba71ba2000-04-29 23:57:08 +1000520
521 /* generate signature */
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000522 ret = (*sign_callback)(authctxt, k, &signature, &slen,
523 buffer_ptr(&b), buffer_len(&b));
Damien Millerad833b32000-08-23 10:46:23 +1000524 if (ret == -1) {
525 xfree(blob);
526 buffer_free(&b);
527 return 0;
528 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100529#ifdef DEBUG_PK
Damien Millereba71ba2000-04-29 23:57:08 +1000530 buffer_dump(&b);
531#endif
Ben Lindstromd121f612000-12-03 17:00:47 +0000532 if (datafellows & SSH_BUG_PKSERVICE) {
Damien Miller30c3d422000-05-09 11:02:59 +1000533 buffer_clear(&b);
534 buffer_append(&b, session_id2, session_id2_len);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000535 skip = session_id2_len;
Damien Miller30c3d422000-05-09 11:02:59 +1000536 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
Damien Miller62cee002000-09-23 17:15:56 +1100537 buffer_put_cstring(&b, authctxt->server_user);
538 buffer_put_cstring(&b, authctxt->service);
Damien Miller874d77b2000-10-14 16:23:11 +1100539 buffer_put_cstring(&b, authctxt->method->name);
540 buffer_put_char(&b, have_sig);
Ben Lindstromd121f612000-12-03 17:00:47 +0000541 if (!(datafellows & SSH_BUG_PKAUTH))
Kevin Stevesef4eea92001-02-05 12:42:17 +0000542 buffer_put_cstring(&b, key_ssh_name(k));
Damien Miller30c3d422000-05-09 11:02:59 +1000543 buffer_put_string(&b, blob, bloblen);
544 }
545 xfree(blob);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000546
Damien Millereba71ba2000-04-29 23:57:08 +1000547 /* append signature */
548 buffer_put_string(&b, signature, slen);
549 xfree(signature);
550
551 /* skip session id and packet type */
Damien Miller6536c7d2000-06-22 21:32:31 +1000552 if (buffer_len(&b) < skip + 1)
Damien Miller62cee002000-09-23 17:15:56 +1100553 fatal("userauth_pubkey: internal error");
Damien Miller6536c7d2000-06-22 21:32:31 +1000554 buffer_consume(&b, skip + 1);
Damien Millereba71ba2000-04-29 23:57:08 +1000555
556 /* put remaining data from buffer into packet */
557 packet_start(SSH2_MSG_USERAUTH_REQUEST);
558 packet_put_raw(buffer_ptr(&b), buffer_len(&b));
559 buffer_free(&b);
Damien Millereba71ba2000-04-29 23:57:08 +1000560 packet_send();
Damien Millerad833b32000-08-23 10:46:23 +1000561
562 return 1;
Damien Miller994cf142000-07-21 10:19:44 +1000563}
564
565int
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000566send_pubkey_test(Authctxt *authctxt, Key *k, sign_cb_fn *sign_callback,
567 int hint)
Damien Miller994cf142000-07-21 10:19:44 +1000568{
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000569 u_char *blob;
570 int bloblen, have_sig = 0;
Damien Miller994cf142000-07-21 10:19:44 +1000571
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000572 debug3("send_pubkey_test");
573
574 if (key_to_blob(k, &blob, &bloblen) == 0) {
575 /* we cannot handle this key */
576 debug3("send_pubkey_test: cannot handle key");
Damien Miller994cf142000-07-21 10:19:44 +1000577 return 0;
578 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000579 /* register callback for USERAUTH_PK_OK message */
580 authctxt->last_key_sign = sign_callback;
581 authctxt->last_key_hint = hint;
582 authctxt->last_key = k;
583 dispatch_set(SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);
Damien Miller994cf142000-07-21 10:19:44 +1000584
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000585 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 packet_put_char(have_sig);
590 if (!(datafellows & SSH_BUG_PKAUTH))
591 packet_put_cstring(key_ssh_name(k));
592 packet_put_string(blob, bloblen);
593 xfree(blob);
594 packet_send();
595 return 1;
596}
597
598Key *
599load_identity_file(char *filename)
600{
601 Key *private;
602 char prompt[300], *passphrase;
Ben Lindstromd0fca422001-03-26 13:44:06 +0000603 int quit, i;
Ben Lindstrom329782e2001-03-10 17:08:59 +0000604 struct stat st;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000605
Ben Lindstrom329782e2001-03-10 17:08:59 +0000606 if (stat(filename, &st) < 0) {
607 debug3("no such identity: %s", filename);
608 return NULL;
609 }
Ben Lindstromd0fca422001-03-26 13:44:06 +0000610 private = key_load_private_type(KEY_UNSPEC, filename, "", NULL);
611 if (private == NULL) {
612 if (options.batch_mode)
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000613 return NULL;
Damien Miller994cf142000-07-21 10:19:44 +1000614 snprintf(prompt, sizeof prompt,
Damien Miller0bc1bd82000-11-13 22:57:25 +1100615 "Enter passphrase for key '%.100s': ", filename);
Damien Miller62cee002000-09-23 17:15:56 +1100616 for (i = 0; i < options.number_of_password_prompts; i++) {
617 passphrase = read_passphrase(prompt, 0);
618 if (strcmp(passphrase, "") != 0) {
Ben Lindstromd0fca422001-03-26 13:44:06 +0000619 private = key_load_private_type(KEY_UNSPEC, filename,
620 passphrase, NULL);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000621 quit = 0;
Damien Miller62cee002000-09-23 17:15:56 +1100622 } else {
623 debug2("no passphrase given, try next key");
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000624 quit = 1;
Damien Miller62cee002000-09-23 17:15:56 +1100625 }
626 memset(passphrase, 0, strlen(passphrase));
627 xfree(passphrase);
Ben Lindstromd0fca422001-03-26 13:44:06 +0000628 if (private != NULL || quit)
Damien Miller62cee002000-09-23 17:15:56 +1100629 break;
630 debug2("bad passphrase given, try again...");
631 }
Damien Miller994cf142000-07-21 10:19:44 +1000632 }
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000633 return private;
634}
635
636int
637identity_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,
638 u_char *data, int datalen)
639{
640 Key *private;
641 int idx, ret;
642
643 idx = authctxt->last_key_hint;
644 if (idx < 0)
645 return -1;
646 private = load_identity_file(options.identity_files[idx]);
647 if (private == NULL)
648 return -1;
649 ret = key_sign(private, sigp, lenp, data, datalen);
650 key_free(private);
Damien Millerad833b32000-08-23 10:46:23 +1000651 return ret;
652}
653
Ben Lindstrom46c16222000-12-22 01:43:59 +0000654int agent_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,
655 u_char *data, int datalen)
Damien Millerad833b32000-08-23 10:46:23 +1000656{
Damien Miller62cee002000-09-23 17:15:56 +1100657 return ssh_agent_sign(authctxt->agent, key, sigp, lenp, data, datalen);
Damien Millerad833b32000-08-23 10:46:23 +1000658}
659
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000660int key_sign_cb(Authctxt *authctxt, Key *key, u_char **sigp, int *lenp,
661 u_char *data, int datalen)
662{
Ben Lindstroma3700052001-04-05 23:26:32 +0000663 return key_sign(key, sigp, lenp, data, datalen);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000664}
665
Damien Millerad833b32000-08-23 10:46:23 +1000666int
Damien Miller62cee002000-09-23 17:15:56 +1100667userauth_pubkey_agent(Authctxt *authctxt)
Damien Millerad833b32000-08-23 10:46:23 +1000668{
669 static int called = 0;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100670 int ret = 0;
Damien Millerad833b32000-08-23 10:46:23 +1000671 char *comment;
672 Key *k;
Damien Millerad833b32000-08-23 10:46:23 +1000673
674 if (called == 0) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100675 if (ssh_get_num_identities(authctxt->agent, 2) == 0)
676 debug2("userauth_pubkey_agent: no keys at all");
Damien Miller62cee002000-09-23 17:15:56 +1100677 called = 1;
Damien Millerad833b32000-08-23 10:46:23 +1000678 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100679 k = ssh_get_next_identity(authctxt->agent, &comment, 2);
Damien Miller62cee002000-09-23 17:15:56 +1100680 if (k == NULL) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100681 debug2("userauth_pubkey_agent: no more keys");
682 } else {
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000683 debug("userauth_pubkey_agent: testing agent key %s", comment);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100684 xfree(comment);
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000685 ret = send_pubkey_test(authctxt, k, agent_sign_cb, -1);
686 if (ret == 0)
687 key_free(k);
Damien Miller62cee002000-09-23 17:15:56 +1100688 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100689 if (ret == 0)
690 debug2("userauth_pubkey_agent: no message sent");
Damien Millerad833b32000-08-23 10:46:23 +1000691 return ret;
Damien Millereba71ba2000-04-29 23:57:08 +1000692}
693
Damien Miller62cee002000-09-23 17:15:56 +1100694int
695userauth_pubkey(Authctxt *authctxt)
Damien Millereba71ba2000-04-29 23:57:08 +1000696{
Damien Miller62cee002000-09-23 17:15:56 +1100697 static int idx = 0;
698 int sent = 0;
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000699 Key *key;
700 char *filename;
Damien Millereba71ba2000-04-29 23:57:08 +1000701
Damien Miller0bc1bd82000-11-13 22:57:25 +1100702 if (authctxt->agent != NULL) {
703 do {
704 sent = userauth_pubkey_agent(authctxt);
705 } while(!sent && authctxt->agent->howmany > 0);
706 }
707 while (!sent && idx < options.num_identity_files) {
Ben Lindstrom266dfdf2001-03-09 00:12:22 +0000708 key = options.identity_keys[idx];
709 filename = options.identity_files[idx];
710 if (key == NULL) {
711 debug("try privkey: %s", filename);
712 key = load_identity_file(filename);
713 if (key != NULL) {
714 sent = sign_and_send_pubkey(authctxt, key,
715 key_sign_cb);
716 key_free(key);
717 }
718 } else if (key->type != KEY_RSA1) {
719 debug("try pubkey: %s", filename);
720 sent = send_pubkey_test(authctxt, key,
721 identity_sign_cb, idx);
722 }
Damien Miller0bc1bd82000-11-13 22:57:25 +1100723 idx++;
724 }
Damien Miller62cee002000-09-23 17:15:56 +1100725 return sent;
726}
Damien Millereba71ba2000-04-29 23:57:08 +1000727
Damien Miller874d77b2000-10-14 16:23:11 +1100728/*
729 * Send userauth request message specifying keyboard-interactive method.
730 */
731int
732userauth_kbdint(Authctxt *authctxt)
733{
734 static int attempt = 0;
735
736 if (attempt++ >= options.number_of_password_prompts)
737 return 0;
738
739 debug2("userauth_kbdint");
740 packet_start(SSH2_MSG_USERAUTH_REQUEST);
741 packet_put_cstring(authctxt->server_user);
742 packet_put_cstring(authctxt->service);
743 packet_put_cstring(authctxt->method->name);
744 packet_put_cstring(""); /* lang */
745 packet_put_cstring(options.kbd_interactive_devices ?
746 options.kbd_interactive_devices : "");
747 packet_send();
Damien Miller874d77b2000-10-14 16:23:11 +1100748
749 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);
750 return 1;
751}
752
753/*
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000754 * parse INFO_REQUEST, prompt user and send INFO_RESPONSE
Damien Miller874d77b2000-10-14 16:23:11 +1100755 */
756void
757input_userauth_info_req(int type, int plen, void *ctxt)
758{
759 Authctxt *authctxt = ctxt;
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000760 char *name, *inst, *lang, *prompt, *response;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000761 u_int num_prompts, i;
Damien Miller874d77b2000-10-14 16:23:11 +1100762 int echo = 0;
763
764 debug2("input_userauth_info_req");
765
766 if (authctxt == NULL)
767 fatal("input_userauth_info_req: no authentication context");
768
769 name = packet_get_string(NULL);
770 inst = packet_get_string(NULL);
771 lang = packet_get_string(NULL);
Damien Miller874d77b2000-10-14 16:23:11 +1100772 if (strlen(name) > 0)
773 cli_mesg(name);
Damien Miller874d77b2000-10-14 16:23:11 +1100774 if (strlen(inst) > 0)
775 cli_mesg(inst);
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000776 xfree(name);
Damien Miller874d77b2000-10-14 16:23:11 +1100777 xfree(inst);
Ben Lindstrom03df5bd2001-02-10 22:16:41 +0000778 xfree(lang);
Damien Miller874d77b2000-10-14 16:23:11 +1100779
780 num_prompts = packet_get_int();
781 /*
782 * Begin to build info response packet based on prompts requested.
783 * We commit to providing the correct number of responses, so if
784 * further on we run into a problem that prevents this, we have to
785 * be sure and clean this up and send a correct error response.
786 */
787 packet_start(SSH2_MSG_USERAUTH_INFO_RESPONSE);
788 packet_put_int(num_prompts);
789
790 for (i = 0; i < num_prompts; i++) {
791 prompt = packet_get_string(NULL);
792 echo = packet_get_char();
793
794 response = cli_prompt(prompt, echo);
795
Ben Lindstrom5699c5f2001-03-05 06:17:49 +0000796 packet_put_cstring(response);
Damien Miller874d77b2000-10-14 16:23:11 +1100797 memset(response, 0, strlen(response));
798 xfree(response);
799 xfree(prompt);
800 }
801 packet_done(); /* done with parsing incoming message. */
802
Ben Lindstrom5699c5f2001-03-05 06:17:49 +0000803 packet_inject_ignore(64);
Damien Miller874d77b2000-10-14 16:23:11 +1100804 packet_send();
Damien Miller874d77b2000-10-14 16:23:11 +1100805}
Damien Miller62cee002000-09-23 17:15:56 +1100806
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000807/*
808 * this will be move to an external program (ssh-keysign) ASAP. ssh-keysign
809 * will be setuid-root and the sbit can be removed from /usr/bin/ssh.
810 */
811int
812userauth_hostbased(Authctxt *authctxt)
813{
814 Key *private = NULL;
815 Buffer b;
816 u_char *signature, *blob;
817 char *chost, *pkalg, *p;
Ben Lindstrom671388f2001-04-19 20:40:45 +0000818 const char *service;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000819 u_int blen, slen;
Ben Lindstrom2bffd6f2001-04-19 20:35:40 +0000820 int ok, i, len, found = 0;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000821
822 p = get_local_name(packet_get_connection_in());
823 if (p == NULL) {
824 error("userauth_hostbased: cannot get local ipaddr/name");
825 return 0;
826 }
Ben Lindstrom2bffd6f2001-04-19 20:35:40 +0000827 len = strlen(p) + 2;
828 chost = xmalloc(len);
829 strlcpy(chost, p, len);
830 strlcat(chost, ".", len);
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000831 debug2("userauth_hostbased: chost %s", chost);
832 /* check for a useful key */
833 for (i = 0; i < authctxt->nkeys; i++) {
834 private = authctxt->keys[i];
835 if (private && private->type != KEY_RSA1) {
836 found = 1;
837 /* we take and free the key */
838 authctxt->keys[i] = NULL;
839 break;
840 }
841 }
842 if (!found) {
843 xfree(chost);
844 return 0;
845 }
846 if (key_to_blob(private, &blob, &blen) == 0) {
847 key_free(private);
848 xfree(chost);
849 return 0;
850 }
Ben Lindstrom671388f2001-04-19 20:40:45 +0000851 service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :
852 authctxt->service;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000853 pkalg = xstrdup(key_ssh_name(private));
854 buffer_init(&b);
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000855 /* construct data */
Ben Lindstrom671388f2001-04-19 20:40:45 +0000856 buffer_put_string(&b, session_id2, session_id2_len);
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000857 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
858 buffer_put_cstring(&b, authctxt->server_user);
Ben Lindstrom671388f2001-04-19 20:40:45 +0000859 buffer_put_cstring(&b, service);
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000860 buffer_put_cstring(&b, authctxt->method->name);
861 buffer_put_cstring(&b, pkalg);
862 buffer_put_string(&b, blob, blen);
863 buffer_put_cstring(&b, chost);
864 buffer_put_cstring(&b, authctxt->local_user);
865#ifdef DEBUG_PK
866 buffer_dump(&b);
867#endif
868 debug2("xxx: chost %s", chost);
869 ok = key_sign(private, &signature, &slen, buffer_ptr(&b), buffer_len(&b));
870 key_free(private);
871 buffer_free(&b);
872 if (ok != 0) {
873 error("key_sign failed");
874 xfree(chost);
875 xfree(pkalg);
876 return 0;
877 }
878 packet_start(SSH2_MSG_USERAUTH_REQUEST);
879 packet_put_cstring(authctxt->server_user);
880 packet_put_cstring(authctxt->service);
881 packet_put_cstring(authctxt->method->name);
882 packet_put_cstring(pkalg);
883 packet_put_string(blob, blen);
884 packet_put_cstring(chost);
885 packet_put_cstring(authctxt->local_user);
886 packet_put_string(signature, slen);
887 memset(signature, 's', slen);
888 xfree(signature);
889 xfree(chost);
890 xfree(pkalg);
891
892 packet_send();
893 return 1;
894}
895
Damien Miller62cee002000-09-23 17:15:56 +1100896/* find auth method */
897
Damien Miller62cee002000-09-23 17:15:56 +1100898/*
899 * given auth method name, if configurable options permit this method fill
900 * in auth_ident field and return true, otherwise return false.
901 */
902int
903authmethod_is_enabled(Authmethod *method)
904{
905 if (method == NULL)
906 return 0;
907 /* return false if options indicate this method is disabled */
908 if (method->enabled == NULL || *method->enabled == 0)
909 return 0;
910 /* return false if batch mode is enabled but method needs interactive mode */
911 if (method->batch_flag != NULL && *method->batch_flag != 0)
912 return 0;
913 return 1;
914}
915
916Authmethod *
917authmethod_lookup(const char *name)
918{
919 Authmethod *method = NULL;
920 if (name != NULL)
921 for (method = authmethods; method->name != NULL; method++)
922 if (strcmp(name, method->name) == 0)
923 return method;
924 debug2("Unrecognized authentication method name: %s", name ? name : "NULL");
925 return NULL;
926}
927
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000928/* XXX internal state */
929static Authmethod *current = NULL;
930static char *supported = NULL;
931static char *preferred = NULL;
Damien Miller62cee002000-09-23 17:15:56 +1100932/*
933 * Given the authentication method list sent by the server, return the
934 * next method we should try. If the server initially sends a nil list,
Ben Lindstroma3700052001-04-05 23:26:32 +0000935 * use a built-in default list.
Kevin Stevesef4eea92001-02-05 12:42:17 +0000936 */
Damien Miller62cee002000-09-23 17:15:56 +1100937Authmethod *
938authmethod_get(char *authlist)
939{
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000940
941 char *name = NULL;
942 int next;
Kevin Stevesef4eea92001-02-05 12:42:17 +0000943
Damien Miller62cee002000-09-23 17:15:56 +1100944 /* Use a suitable default if we're passed a nil list. */
945 if (authlist == NULL || strlen(authlist) == 0)
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000946 authlist = options.preferred_authentications;
Damien Miller62cee002000-09-23 17:15:56 +1100947
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000948 if (supported == NULL || strcmp(authlist, supported) != 0) {
949 debug3("start over, passed a different list %s", authlist);
950 if (supported != NULL)
951 xfree(supported);
952 supported = xstrdup(authlist);
953 preferred = options.preferred_authentications;
954 debug3("preferred %s", preferred);
955 current = NULL;
956 } else if (current != NULL && authmethod_is_enabled(current))
957 return current;
Damien Millereba71ba2000-04-29 23:57:08 +1000958
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000959 for (;;) {
960 if ((name = match_list(preferred, supported, &next)) == NULL) {
961 debug("no more auth methods to try");
962 current = NULL;
963 return NULL;
Damien Miller874d77b2000-10-14 16:23:11 +1100964 }
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000965 preferred += next;
966 debug3("authmethod_lookup %s", name);
967 debug3("remaining preferred: %s", preferred);
968 if ((current = authmethod_lookup(name)) != NULL &&
969 authmethod_is_enabled(current)) {
970 debug3("authmethod_is_enabled %s", name);
971 debug("next auth method to try is %s", name);
972 return current;
973 }
Damien Millereba71ba2000-04-29 23:57:08 +1000974 }
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000975}
Damien Miller62cee002000-09-23 17:15:56 +1100976
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000977
978#define DELIM ","
979char *
980authmethods_get(void)
981{
982 Authmethod *method = NULL;
983 char buf[1024];
984
985 buf[0] = '\0';
986 for (method = authmethods; method->name != NULL; method++) {
987 if (authmethod_is_enabled(method)) {
988 if (buf[0] != '\0')
989 strlcat(buf, DELIM, sizeof buf);
990 strlcat(buf, method->name, sizeof buf);
991 }
Damien Miller62cee002000-09-23 17:15:56 +1100992 }
Ben Lindstromb9be60a2001-03-11 01:49:19 +0000993 return xstrdup(buf);
Damien Millereba71ba2000-04-29 23:57:08 +1000994}