?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- dtucker@cvs.openbsd.org 2009/10/24 00:48:34
[openssh-git.git] / sshconnect2.c
blob1e0e9d5e10e1fcb587db9d98b75ce5d94b30ea6f
1 /* $OpenBSD: sshconnect2.c,v 1.172 2009/10/23 01:57:11 djm Exp $ */
2 /*
3 * Copyright (c) 2000 Markus Friedl. All rights reserved.
4 * Copyright (c) 2008 Damien Miller. All rights reserved.
5 *
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.
14 *
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"
28
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #include <sys/wait.h>
32 #include <sys/stat.h>
33
34 #include <errno.h>
35 #include <netdb.h>
36 #include <pwd.h>
37 #include <signal.h>
38 #include <stdarg.h>
39 #include <stdio.h>
40 #include <string.h>
41 #include <unistd.h>
42 #if defined(HAVE_STRNVIS) && defined(HAVE_VIS_H)
43 #include <vis.h>
44 #endif
45
46 #include "openbsd-compat/sys-queue.h"
47
48 #include "xmalloc.h"
49 #include "ssh.h"
50 #include "ssh2.h"
51 #include "buffer.h"
52 #include "packet.h"
53 #include "compat.h"
54 #include "cipher.h"
55 #include "key.h"
56 #include "kex.h"
57 #include "myproposal.h"
58 #include "sshconnect.h"
59 #include "authfile.h"
60 #include "dh.h"
61 #include "authfd.h"
62 #include "log.h"
63 #include "readconf.h"
64 #include "misc.h"
65 #include "match.h"
66 #include "dispatch.h"
67 #include "canohost.h"
68 #include "msg.h"
69 #include "pathnames.h"
70 #include "uidswap.h"
71 #include "schnorr.h"
72 #include "jpake.h"
73
74 #ifdef GSSAPI
75 #include "ssh-gss.h"
76 #endif
77
78 /* import */
79 extern char *client_version_string;
80 extern char *server_version_string;
81 extern Options options;
82
83 /*
84 * SSH2 key exchange
85 */
86
87 u_char *session_id2 = NULL;
88 u_int session_id2_len = 0;
89
90 char *xxx_host;
91 struct sockaddr *xxx_hostaddr;
92
93 Kex *xxx_kex = NULL;
94
95 static int
96 verify_host_key_callback(Key *hostkey)
97 {
98 if (verify_host_key(xxx_host, xxx_hostaddr, hostkey) == -1)
99 fatal("Host key verification failed.");
100 return 0;
101 }
102
103 void
104 ssh_kex2(char *host, struct sockaddr *hostaddr)
105 {
106 Kex *kex;
107
108 xxx_host = host;
109 xxx_hostaddr = hostaddr;
110
111 if (options.ciphers == (char *)-1) {
112 logit("No valid ciphers for protocol version 2 given, using defaults.");
113 options.ciphers = NULL;
114 }
115 if (options.ciphers != NULL) {
116 myproposal[PROPOSAL_ENC_ALGS_CTOS] =
117 myproposal[PROPOSAL_ENC_ALGS_STOC] = options.ciphers;
118 }
119 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]);
123 if (options.compression) {
124 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
125 myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib@openssh.com,zlib,none";
126 } else {
127 myproposal[PROPOSAL_COMP_ALGS_CTOS] =
128 myproposal[PROPOSAL_COMP_ALGS_STOC] = "none,zlib@openssh.com,zlib";
129 }
130 if (options.macs != NULL) {
131 myproposal[PROPOSAL_MAC_ALGS_CTOS] =
132 myproposal[PROPOSAL_MAC_ALGS_STOC] = options.macs;
133 }
134 if (options.hostkeyalgorithms != NULL)
135 myproposal[PROPOSAL_SERVER_HOST_KEY_ALGS] =
136 options.hostkeyalgorithms;
137
138 if (options.rekey_limit)
139 packet_set_rekey_limit((u_int32_t)options.rekey_limit);
140
141 /* start key exchange */
142 kex = kex_setup(myproposal);
143 kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;
144 kex->kex[KEX_DH_GRP14_SHA1] = kexdh_client;
145 kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;
146 kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;
147 kex->client_version_string=client_version_string;
148 kex->server_version_string=server_version_string;
149 kex->verify_host_key=&verify_host_key_callback;
150
151 xxx_kex = kex;
152
153 dispatch_run(DISPATCH_BLOCK, &kex->done, kex);
154
155 session_id2 = kex->session_id;
156 session_id2_len = kex->session_id_len;
157
158 #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
165 }
166
167 /*
168 * Authenticate user
169 */
170
171 typedef struct Authctxt Authctxt;
172 typedef struct Authmethod Authmethod;
173 typedef struct identity Identity;
174 typedef struct idlist Idlist;
175
176 struct 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 };
184 TAILQ_HEAD(idlist, identity);
185
186 struct Authctxt {
187 const char *server_user;
188 const char *local_user;
189 const char *host;
190 const char *service;
191 Authmethod *method;
192 int success;
193 char *authlist;
194 /* pubkey */
195 Idlist keys;
196 AuthenticationConnection *agent;
197 /* hostbased */
198 Sensitive *sensitive;
199 /* kbd-interactive */
200 int info_req_seen;
201 /* generic */
202 void *methoddata;
203 };
204 struct Authmethod {
205 char *name; /* string to compare against server's list */
206 int (*userauth)(Authctxt *authctxt);
207 void (*cleanup)(Authctxt *authctxt);
208 int *enabled; /* flag in option struct that enables method */
209 int *batch_flag; /* flag in option struct that disables method */
210 };
211
212 void input_userauth_success(int, u_int32_t, void *);
213 void input_userauth_success_unexpected(int, u_int32_t, void *);
214 void input_userauth_failure(int, u_int32_t, void *);
215 void input_userauth_banner(int, u_int32_t, void *);
216 void input_userauth_error(int, u_int32_t, void *);
217 void input_userauth_info_req(int, u_int32_t, void *);
218 void input_userauth_pk_ok(int, u_int32_t, void *);
219 void input_userauth_passwd_changereq(int, u_int32_t, void *);
220 void input_userauth_jpake_server_step1(int, u_int32_t, void *);
221 void input_userauth_jpake_server_step2(int, u_int32_t, void *);
222 void input_userauth_jpake_server_confirm(int, u_int32_t, void *);
223
224 int userauth_none(Authctxt *);
225 int userauth_pubkey(Authctxt *);
226 int userauth_passwd(Authctxt *);
227 int userauth_kbdint(Authctxt *);
228 int userauth_hostbased(Authctxt *);
229 int userauth_jpake(Authctxt *);
230
231 void userauth_jpake_cleanup(Authctxt *);
232
233 #ifdef GSSAPI
234 int userauth_gssapi(Authctxt *authctxt);
235 void input_gssapi_response(int type, u_int32_t, void *);
236 void input_gssapi_token(int type, u_int32_t, void *);
237 void input_gssapi_hash(int type, u_int32_t, void *);
238 void input_gssapi_error(int, u_int32_t, void *);
239 void input_gssapi_errtok(int, u_int32_t, void *);
240 #endif
241
242 void userauth(Authctxt *, char *);
243
244 static int sign_and_send_pubkey(Authctxt *, Identity *);
245 static void pubkey_prepare(Authctxt *);
246 static void pubkey_cleanup(Authctxt *);
247 static Key *load_identity_file(char *);
248
249 static Authmethod *authmethod_get(char *authlist);
250 static Authmethod *authmethod_lookup(const char *name);
251 static char *authmethods_get(void);
252
253 Authmethod authmethods[] = {
254 #ifdef GSSAPI
255 {"gssapi-with-mic",
256 userauth_gssapi,
257 NULL,
258 &options.gss_authentication,
259 NULL},
260 #endif
261 {"hostbased",
262 userauth_hostbased,
263 NULL,
264 &options.hostbased_authentication,
265 NULL},
266 {"publickey",
267 userauth_pubkey,
268 NULL,
269 &options.pubkey_authentication,
270 NULL},
271 #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
278 {"keyboard-interactive",
279 userauth_kbdint,
280 NULL,
281 &options.kbd_interactive_authentication,
282 &options.batch_mode},
283 {"password",
284 userauth_passwd,
285 NULL,
286 &options.password_authentication,
287 &options.batch_mode},
288 {"none",
289 userauth_none,
290 NULL,
291 NULL,
292 NULL},
293 {NULL, NULL, NULL, NULL, NULL}
294 };
295
296 void
297 ssh_userauth2(const char *local_user, const char *server_user, char *host,
298 Sensitive *sensitive)
299 {
300 Authctxt authctxt;
301 int type;
302
303 if (options.challenge_response_authentication)
304 options.kbd_interactive_authentication = 1;
305
306 packet_start(SSH2_MSG_SERVICE_REQUEST);
307 packet_put_cstring("ssh-userauth");
308 packet_send();
309 debug("SSH2_MSG_SERVICE_REQUEST sent");
310 packet_write_wait();
311 type = packet_read();
312 if (type != SSH2_MSG_SERVICE_ACCEPT)
313 fatal("Server denied authentication request: %d", type);
314 if (packet_remaining() > 0) {
315 char *reply = packet_get_string(NULL);
316 debug2("service_accept: %s", reply);
317 xfree(reply);
318 } else {
319 debug2("buggy server: service_accept w/o service");
320 }
321 packet_check_eom();
322 debug("SSH2_MSG_SERVICE_ACCEPT received");
323
324 if (options.preferred_authentications == NULL)
325 options.preferred_authentications = authmethods_get();
326
327 /* setup authentication context */
328 memset(&authctxt, 0, sizeof(authctxt));
329 pubkey_prepare(&authctxt);
330 authctxt.server_user = server_user;
331 authctxt.local_user = local_user;
332 authctxt.host = host;
333 authctxt.service = "ssh-connection"; /* service name */
334 authctxt.success = 0;
335 authctxt.method = authmethod_lookup("none");
336 authctxt.authlist = NULL;
337 authctxt.methoddata = NULL;
338 authctxt.sensitive = sensitive;
339 authctxt.info_req_seen = 0;
340 if (authctxt.method == NULL)
341 fatal("ssh_userauth2: internal error: cannot send userauth none request");
342
343 /* initial userauth request */
344 userauth_none(&authctxt);
345
346 dispatch_init(&input_userauth_error);
347 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
348 dispatch_set(SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);
349 dispatch_set(SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);
350 dispatch_run(DISPATCH_BLOCK, &authctxt.success, &authctxt); /* loop until success */
351
352 pubkey_cleanup(&authctxt);
353 dispatch_range(SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);
354
355 debug("Authentication succeeded (%s).", authctxt.method->name);
356 }
357
358 void
359 userauth(Authctxt *authctxt, char *authlist)
360 {
361 if (authctxt->method != NULL && authctxt->method->cleanup != NULL)
362 authctxt->method->cleanup(authctxt);
363
364 if (authctxt->methoddata) {
365 xfree(authctxt->methoddata);
366 authctxt->methoddata = NULL;
367 }
368 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;
380
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 */
386 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 }
395
396 /* ARGSUSED */
397 void
398 input_userauth_error(int type, u_int32_t seq, void *ctxt)
399 {
400 fatal("input_userauth_error: bad message during authentication: "
401 "type %d", type);
402 }
403
404 /* ARGSUSED */
405 void
406 input_userauth_banner(int type, u_int32_t seq, void *ctxt)
407 {
408 char *msg, *raw, *lang;
409 u_int len;
410
411 debug3("input_userauth_banner");
412 raw = packet_get_string(&len);
413 lang = packet_get_string(NULL);
414 if (len > 0 && options.log_level >= SYSLOG_LEVEL_INFO) {
415 if (len > 65536)
416 len = 65536;
417 msg = xmalloc(len * 4 + 1); /* max expansion from strnvis() */
418 strnvis(msg, raw, len * 4 + 1, VIS_SAFE|VIS_OCTAL);
419 fprintf(stderr, "%s", msg);
420 xfree(msg);
421 }
422 xfree(raw);
423 xfree(lang);
424 }
425
426 /* ARGSUSED */
427 void
428 input_userauth_success(int type, u_int32_t seq, void *ctxt)
429 {
430 Authctxt *authctxt = ctxt;
431
432 if (authctxt == NULL)
433 fatal("input_userauth_success: no authentication context");
434 if (authctxt->authlist) {
435 xfree(authctxt->authlist);
436 authctxt->authlist = NULL;
437 }
438 if (authctxt->method != NULL && authctxt->method->cleanup != NULL)
439 authctxt->method->cleanup(authctxt);
440 if (authctxt->methoddata) {
441 xfree(authctxt->methoddata);
442 authctxt->methoddata = NULL;
443 }
444 authctxt->success = 1; /* break out */
445 }
446
447 void
448 input_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
459 /* ARGSUSED */
460 void
461 input_userauth_failure(int type, u_int32_t seq, void *ctxt)
462 {
463 Authctxt *authctxt = ctxt;
464 char *authlist = NULL;
465 int partial;
466
467 if (authctxt == NULL)
468 fatal("input_userauth_failure: no authentication context");
469
470 authlist = packet_get_string(NULL);
471 partial = packet_get_char();
472 packet_check_eom();
473
474 if (partial != 0)
475 logit("Authenticated with partial success.");
476 debug("Authentications that can continue: %s", authlist);
477
478 userauth(authctxt, authlist);
479 }
480
481 /* ARGSUSED */
482 void
483 input_userauth_pk_ok(int type, u_int32_t seq, void *ctxt)
484 {
485 Authctxt *authctxt = ctxt;
486 Key *key = NULL;
487 Identity *id = NULL;
488 Buffer b;
489 int pktype, sent = 0;
490 u_int alen, blen;
491 char *pkalg, *fp;
492 u_char *pkblob;
493
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);
507 }
508 packet_check_eom();
509
510 debug("Server accepts key: pkalg %s blen %u", pkalg, blen);
511
512 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);
529
530 /*
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 */
535 TAILQ_FOREACH_REVERSE(id, &authctxt->keys, idlist, next) {
536 if (key_equal(key, id->key)) {
537 sent = sign_and_send_pubkey(authctxt, id);
538 break;
539 }
540 }
541 done:
542 if (key != NULL)
543 key_free(key);
544 xfree(pkalg);
545 xfree(pkblob);
546
547 /* try another method if we did not send a packet */
548 if (sent == 0)
549 userauth(authctxt, NULL);
550 }
551
552 #ifdef GSSAPI
553 int
554 userauth_gssapi(Authctxt *authctxt)
555 {
556 Gssctxt *gssctxt = NULL;
557 static gss_OID_set gss_supported = NULL;
558 static u_int mech = 0;
559 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
565 if (gss_supported == NULL)
566 gss_indicate_mechs(&min, &gss_supported);
567
568 /* Check to see if the mechanism is usable before we offer it */
569 while (mech < gss_supported->count && !ok) {
570 /* My DER encoding requires length<128 */
571 if (gss_supported->elements[mech].length < 128 &&
572 ssh_gssapi_check_mechanism(&gssctxt,
573 &gss_supported->elements[mech], authctxt->host)) {
574 ok = 1; /* Mechanism works */
575 } else {
576 mech++;
577 }
578 }
579
580 if (!ok)
581 return 0;
582
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
592 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);
597
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
610 static OM_uint32
611 process_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;
616 gss_buffer_desc mic = GSS_C_EMPTY_BUFFER;
617 gss_buffer_desc gssbuf;
618 OM_uint32 status, ms, flags;
619 Buffer b;
620
621 status = ssh_gssapi_init_ctx(gssctxt, options.gss_deleg_creds,
622 recv_tok, &send_tok, &flags);
623
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);
629
630 packet_put_string(send_tok.value, send_tok.length);
631 packet_send();
632 gss_release_buffer(&ms, &send_tok);
633 }
634
635 if (status == GSS_S_COMPLETE) {
636 /* 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);
646
647 status = ssh_gssapi_sign(gssctxt, &gssbuf, &mic);
648
649 if (!GSS_ERROR(status)) {
650 packet_start(SSH2_MSG_USERAUTH_GSSAPI_MIC);
651 packet_put_string(mic.value, mic.length);
652
653 packet_send();
654 }
655
656 buffer_free(&b);
657 gss_release_buffer(&ms, &mic);
658 }
659 }
660
661 return status;
662 }
663
664 /* ARGSUSED */
665 void
666 input_gssapi_response(int type, u_int32_t plen, void *ctxt)
667 {
668 Authctxt *authctxt = ctxt;
669 Gssctxt *gssctxt;
670 int oidlen;
671 char *oidv;
672
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
680 if (oidlen <= 2 ||
681 oidv[0] != SSH_GSS_OIDTYPE ||
682 oidv[1] != oidlen - 2) {
683 xfree(oidv);
684 debug("Badly encoded mechanism OID received");
685 userauth(authctxt, NULL);
686 return;
687 }
688
689 if (!ssh_gssapi_check_oid(gssctxt, oidv + 2, oidlen - 2))
690 fatal("Server returned different OID than expected");
691
692 packet_check_eom();
693
694 xfree(oidv);
695
696 if (GSS_ERROR(process_gssapi_token(ctxt, GSS_C_NO_BUFFER))) {
697 /* Start again with next method on list */
698 debug("Trying to start again");
699 userauth(authctxt, NULL);
700 return;
701 }
702 }
703
704 /* ARGSUSED */
705 void
706 input_gssapi_token(int type, u_int32_t plen, void *ctxt)
707 {
708 Authctxt *authctxt = ctxt;
709 gss_buffer_desc recv_tok;
710 OM_uint32 status;
711 u_int slen;
712
713 if (authctxt == NULL)
714 fatal("input_gssapi_response: no authentication context");
715
716 recv_tok.value = packet_get_string(&slen);
717 recv_tok.length = slen; /* safe typecast */
718
719 packet_check_eom();
720
721 status = process_gssapi_token(ctxt, &recv_tok);
722
723 xfree(recv_tok.value);
724
725 if (GSS_ERROR(status)) {
726 /* Start again with the next method in the list */
727 userauth(authctxt, NULL);
728 return;
729 }
730 }
731
732 /* ARGSUSED */
733 void
734 input_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;
741 u_int len;
742
743 if (authctxt == NULL)
744 fatal("input_gssapi_response: no authentication context");
745 gssctxt = authctxt->methoddata;
746
747 recv_tok.value = packet_get_string(&len);
748 recv_tok.length = len;
749
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,
754 &recv_tok, &send_tok, NULL);
755
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
762 /* ARGSUSED */
763 void
764 input_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
777 debug("Server GSSAPI Error:\n%s", msg);
778 xfree(msg);
779 xfree(lang);
780 }
781 #endif /* GSSAPI */
782
783 int
784 userauth_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();
792 return 1;
793 }
794
795 int
796 userauth_passwd(Authctxt *authctxt)
797 {
798 static int attempt = 0;
799 char prompt[150];
800 char *password;
801
802 if (attempt++ >= options.number_of_password_prompts)
803 return 0;
804
805 if (attempt != 1)
806 error("Permission denied, please try again.");
807
808 snprintf(prompt, sizeof(prompt), "%.30s@%.128s's password: ",
809 authctxt->server_user, authctxt->host);
810 password = read_passphrase(prompt, 0);
811 packet_start(SSH2_MSG_USERAUTH_REQUEST);
812 packet_put_cstring(authctxt->server_user);
813 packet_put_cstring(authctxt->service);
814 packet_put_cstring(authctxt->method->name);
815 packet_put_char(0);
816 packet_put_cstring(password);
817 memset(password, 0, strlen(password));
818 xfree(password);
819 packet_add_padding(64);
820 packet_send();
821
822 dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
823 &input_userauth_passwd_changereq);
824
825 return 1;
826 }
827
828 /*
829 * parse PASSWD_CHANGEREQ, prompt user and send SSH2_MSG_USERAUTH_REQUEST
830 */
831 /* ARGSUSED */
832 void
833 input_userauth_passwd_changereq(int type, u_int32_t seqnr, void *ctxt)
834 {
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)
848 logit("%s", info);
849 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 */
856 snprintf(prompt, sizeof(prompt),
857 "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) {
865 snprintf(prompt, sizeof(prompt),
866 "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 }
873 snprintf(prompt, sizeof(prompt),
874 "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);
880 logit("Mismatch; try again, EOF to quit.");
881 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();
891
892 dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,
893 &input_userauth_passwd_changereq);
894 }
895
896 #ifdef JPAKE
897 static char *
898 pw_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
911 static BIGNUM *
912 jpake_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 */
955 void
956 input_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 */
1023 void
1024 input_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 */
1070 void
1071 input_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
1099 static int
1100 identity_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
1124 static int
1125 sign_and_send_pubkey(Authctxt *authctxt, Identity *id)
1126 {
1127 Buffer b;
1128 u_char *blob, *signature;
1129 u_int bloblen, slen;
1130 u_int skip = 0;
1131 int ret = -1;
1132 int have_sig = 1;
1133
1134 debug3("sign_and_send_pubkey");
1135
1136 if (key_to_blob(id->key, &blob, &bloblen) == 0) {
1137 /* we cannot handle this key */
1138 debug3("sign_and_send_pubkey: cannot handle key");
1139 return 0;
1140 }
1141 /* data to be signed */
1142 buffer_init(&b);
1143 if (datafellows & SSH_OLD_SESSIONID) {
1144 buffer_append(&b, session_id2, session_id2_len);
1145 skip = session_id2_len;
1146 } else {
1147 buffer_put_string(&b, session_id2, session_id2_len);
1148 skip = buffer_len(&b);
1149 }
1150 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
1151 buffer_put_cstring(&b, authctxt->server_user);
1152 buffer_put_cstring(&b,
1153 datafellows & SSH_BUG_PKSERVICE ?
1154 "ssh-userauth" :
1155 authctxt->service);
1156 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);
1161 buffer_put_cstring(&b, key_ssh_name(id->key));
1162 }
1163 buffer_put_string(&b, blob, bloblen);
1164
1165 /* generate signature */
1166 ret = identity_sign(id, &signature, &slen,
1167 buffer_ptr(&b), buffer_len(&b));
1168 if (ret == -1) {
1169 xfree(blob);
1170 buffer_free(&b);
1171 return 0;
1172 }
1173 #ifdef DEBUG_PK
1174 buffer_dump(&b);
1175 #endif
1176 if (datafellows & SSH_BUG_PKSERVICE) {
1177 buffer_clear(&b);
1178 buffer_append(&b, session_id2, session_id2_len);
1179 skip = session_id2_len;
1180 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
1181 buffer_put_cstring(&b, authctxt->server_user);
1182 buffer_put_cstring(&b, authctxt->service);
1183 buffer_put_cstring(&b, authctxt->method->name);
1184 buffer_put_char(&b, have_sig);
1185 if (!(datafellows & SSH_BUG_PKAUTH))
1186 buffer_put_cstring(&b, key_ssh_name(id->key));
1187 buffer_put_string(&b, blob, bloblen);
1188 }
1189 xfree(blob);
1190
1191 /* append signature */
1192 buffer_put_string(&b, signature, slen);
1193 xfree(signature);
1194
1195 /* skip session id and packet type */
1196 if (buffer_len(&b) < skip + 1)
1197 fatal("userauth_pubkey: internal error");
1198 buffer_consume(&b, skip + 1);
1199
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);
1204 packet_send();
1205
1206 return 1;
1207 }
1208
1209 static int
1210 send_pubkey_test(Authctxt *authctxt, Identity *id)
1211 {
1212 u_char *blob;
1213 u_int bloblen, have_sig = 0;
1214
1215 debug3("send_pubkey_test");
1216
1217 if (key_to_blob(id->key, &blob, &bloblen) == 0) {
1218 /* we cannot handle this key */
1219 debug3("send_pubkey_test: cannot handle key");
1220 return 0;
1221 }
1222 /* register callback for USERAUTH_PK_OK message */
1223 dispatch_set(SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);
1224
1225 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))
1231 packet_put_cstring(key_ssh_name(id->key));
1232 packet_put_string(blob, bloblen);
1233 xfree(blob);
1234 packet_send();
1235 return 1;
1236 }
1237
1238 static Key *
1239 load_identity_file(char *filename)
1240 {
1241 Key *private;
1242 char prompt[300], *passphrase;
1243 int perm_ok, quit, i;
1244 struct stat st;
1245
1246 if (stat(filename, &st) < 0) {
1247 debug3("no such identity: %s", filename);
1248 return NULL;
1249 }
1250 private = key_load_private_type(KEY_UNSPEC, filename, "", NULL, &perm_ok);
1251 if (!perm_ok)
1252 return NULL;
1253 if (private == NULL) {
1254 if (options.batch_mode)
1255 return NULL;
1256 snprintf(prompt, sizeof prompt,
1257 "Enter passphrase for key '%.100s': ", filename);
1258 for (i = 0; i < options.number_of_password_prompts; i++) {
1259 passphrase = read_passphrase(prompt, 0);
1260 if (strcmp(passphrase, "") != 0) {
1261 private = key_load_private_type(KEY_UNSPEC,
1262 filename, passphrase, NULL, NULL);
1263 quit = 0;
1264 } else {
1265 debug2("no passphrase given, try next key");
1266 quit = 1;
1267 }
1268 memset(passphrase, 0, strlen(passphrase));
1269 xfree(passphrase);
1270 if (private != NULL || quit)
1271 break;
1272 debug2("bad passphrase given, try again...");
1273 }
1274 }
1275 return private;
1276 }
1277
1278 /*
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 */
1284 static void
1285 pubkey_prepare(Authctxt *authctxt)
1286 {
1287 Identity *id;
1288 Idlist agent, files, *preferred;
1289 Key *key;
1290 AuthenticationConnection *ac;
1291 char *comment;
1292 int i, found;
1293
1294 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;
1305 id = xcalloc(1, sizeof(*id));
1306 id->key = key;
1307 id->filename = xstrdup(options.identity_files[i]);
1308 TAILQ_INSERT_TAIL(&files, id, next);
1309 }
1310 /* 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) {
1317 /* agent keys from the config file are preferred */
1318 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 }
1328 if (!found && !options.identities_only) {
1329 id = xcalloc(1, sizeof(*id));
1330 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;
1342 }
1343 /* 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
1353 static void
1354 pubkey_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 }
1369 }
1370
1371 int
1372 userauth_pubkey(Authctxt *authctxt)
1373 {
1374 Identity *id;
1375 int sent = 0;
1376
1377 while ((id = TAILQ_FIRST(&authctxt->keys))) {
1378 if (id->tried++)
1379 return (0);
1380 /* move key to the end of the queue */
1381 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;
1399 }
1400 }
1401 if (sent)
1402 return (sent);
1403 }
1404 return (0);
1405 }
1406
1407 /*
1408 * Send userauth request message specifying keyboard-interactive method.
1409 */
1410 int
1411 userauth_kbdint(Authctxt *authctxt)
1412 {
1413 static int attempt = 0;
1414
1415 if (attempt++ >= options.number_of_password_prompts)
1416 return 0;
1417 /* 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 }
1423
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();
1433
1434 dispatch_set(SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);
1435 return 1;
1436 }
1437
1438 /*
1439 * parse INFO_REQUEST, prompt user and send INFO_RESPONSE
1440 */
1441 void
1442 input_userauth_info_req(int type, u_int32_t seq, void *ctxt)
1443 {
1444 Authctxt *authctxt = ctxt;
1445 char *name, *inst, *lang, *prompt, *response;
1446 u_int num_prompts, i;
1447 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
1454 authctxt->info_req_seen = 1;
1455
1456 name = packet_get_string(NULL);
1457 inst = packet_get_string(NULL);
1458 lang = packet_get_string(NULL);
1459 if (strlen(name) > 0)
1460 logit("%s", name);
1461 if (strlen(inst) > 0)
1462 logit("%s", inst);
1463 xfree(name);
1464 xfree(inst);
1465 xfree(lang);
1466
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
1477 debug2("input_userauth_info_req: num_prompts %d", num_prompts);
1478 for (i = 0; i < num_prompts; i++) {
1479 prompt = packet_get_string(NULL);
1480 echo = packet_get_char();
1481
1482 response = read_passphrase(prompt, echo ? RP_ECHO : 0);
1483
1484 packet_put_cstring(response);
1485 memset(response, 0, strlen(response));
1486 xfree(response);
1487 xfree(prompt);
1488 }
1489 packet_check_eom(); /* done with parsing incoming message. */
1490
1491 packet_add_padding(64);
1492 packet_send();
1493 }
1494
1495 static int
1496 ssh_keysign(Key *key, u_char **sigp, u_int *lenp,
1497 u_char *data, u_int datalen)
1498 {
1499 Buffer b;
1500 struct stat st;
1501 pid_t pid;
1502 int to[2], from[2], status, version = 2;
1503
1504 debug2("ssh_keysign called");
1505
1506 if (stat(_PATH_SSH_KEY_SIGN, &st) < 0) {
1507 error("ssh_keysign: no installed: %s", strerror(errno));
1508 return -1;
1509 }
1510 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) {
1525 permanently_drop_suid(getuid());
1526 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));
1532 close(from[1]);
1533 close(to[0]);
1534 execl(_PATH_SSH_KEY_SIGN, _PATH_SSH_KEY_SIGN, (char *) 0);
1535 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);
1542 buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */
1543 buffer_put_string(&b, data, datalen);
1544 if (ssh_msg_send(to[1], version, &b) == -1)
1545 fatal("ssh_keysign: couldn't send request");
1546
1547 if (ssh_msg_recv(from[0], &b) < 0) {
1548 error("ssh_keysign: no reply");
1549 buffer_free(&b);
1550 return -1;
1551 }
1552 close(from[0]);
1553 close(to[1]);
1554
1555 while (waitpid(pid, &status, 0) < 0)
1556 if (errno != EINTR)
1557 break;
1558
1559 if (buffer_get_char(&b) != version) {
1560 error("ssh_keysign: bad version");
1561 buffer_free(&b);
1562 return -1;
1563 }
1564 *sigp = buffer_get_string(&b, lenp);
1565 buffer_free(&b);
1566
1567 return 0;
1568 }
1569
1570 int
1571 userauth_hostbased(Authctxt *authctxt)
1572 {
1573 Key *private = NULL;
1574 Sensitive *sensitive = authctxt->sensitive;
1575 Buffer b;
1576 u_char *signature, *blob;
1577 char *chost, *pkalg, *p, myname[NI_MAXHOST];
1578 const char *service;
1579 u_int blen, slen;
1580 int ok, i, len, found = 0;
1581
1582 /* check for a useful key */
1583 for (i = 0; i < sensitive->nkeys; i++) {
1584 private = sensitive->keys[i];
1585 if (private && private->type != KEY_RSA1) {
1586 found = 1;
1587 /* we take and free the key */
1588 sensitive->keys[i] = NULL;
1589 break;
1590 }
1591 }
1592 if (!found) {
1593 debug("No more client hostkeys for hostbased authentication.");
1594 return 0;
1595 }
1596 if (key_to_blob(private, &blob, &blen) == 0) {
1597 key_free(private);
1598 return 0;
1599 }
1600 /* figure out a name for the client host */
1601 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 }
1611 if (p == NULL) {
1612 error("userauth_hostbased: cannot get local ipaddr/name");
1613 key_free(private);
1614 xfree(blob);
1615 return 0;
1616 }
1617 len = strlen(p) + 2;
1618 xasprintf(&chost, "%s.", p);
1619 debug2("userauth_hostbased: chost %s", chost);
1620 xfree(p);
1621
1622 service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :
1623 authctxt->service;
1624 pkalg = xstrdup(key_ssh_name(private));
1625 buffer_init(&b);
1626 /* construct data */
1627 buffer_put_string(&b, session_id2, session_id2_len);
1628 buffer_put_char(&b, SSH2_MSG_USERAUTH_REQUEST);
1629 buffer_put_cstring(&b, authctxt->server_user);
1630 buffer_put_cstring(&b, service);
1631 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
1639 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));
1645 key_free(private);
1646 buffer_free(&b);
1647 if (ok != 0) {
1648 error("key_sign failed");
1649 xfree(chost);
1650 xfree(pkalg);
1651 xfree(blob);
1652 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);
1667 xfree(blob);
1668
1669 packet_send();
1670 return 1;
1671 }
1672
1673 #ifdef JPAKE
1674 int
1675 userauth_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);
1728 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS,
1729 &input_userauth_success_unexpected);
1730
1731 return 1;
1732 }
1733
1734 void
1735 userauth_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 }
1742 dispatch_set(SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);
1743 }
1744 #endif /* JPAKE */
1745
1746 /* find auth method */
1747
1748 /*
1749 * given auth method name, if configurable options permit this method fill
1750 * in auth_ident field and return true, otherwise return false.
1751 */
1752 static int
1753 authmethod_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
1766 static Authmethod *
1767 authmethod_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
1778 /* XXX internal state */
1779 static Authmethod *current = NULL;
1780 static char *supported = NULL;
1781 static char *preferred = NULL;
1782
1783 /*
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,
1786 * use a built-in default list.
1787 */
1788 static Authmethod *
1789 authmethod_get(char *authlist)
1790 {
1791 char *name = NULL;
1792 u_int next;
1793
1794 /* Use a suitable default if we're passed a nil list. */
1795 if (authlist == NULL || strlen(authlist) == 0)
1796 authlist = options.preferred_authentications;
1797
1798 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;
1808
1809 for (;;) {
1810 if ((name = match_list(preferred, supported, &next)) == NULL) {
1811 debug("No more authentication methods to try.");
1812 current = NULL;
1813 return NULL;
1814 }
1815 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);
1821 debug("Next authentication method: %s", name);
1822 return current;
1823 }
1824 }
1825 }
1826
1827 static char *
1828 authmethods_get(void)
1829 {
1830 Authmethod *method = NULL;
1831 Buffer b;
1832 char *list;
1833
1834 buffer_init(&b);
1835 for (method = authmethods; method->name != NULL; method++) {
1836 if (authmethod_is_enabled(method)) {
1837 if (buffer_len(&b) > 0)
1838 buffer_append(&b, ",", 1);
1839 buffer_append(&b, method->name, strlen(method->name));
1840 }
1841 }
1842 buffer_append(&b, "\0", 1);
1843 list = xstrdup(buffer_ptr(&b));
1844 buffer_free(&b);
1845 return list;
1846 }
1847
A clone of openssh git repository