xref: /freebsd/crypto/openssh/monitor.c (revision e146993e33182e13df79b5a957f2734f663fd836)
1*e146993eSDag-Erling Smørgrav /* $OpenBSD: monitor.c,v 1.115 2011/06/23 23:35:42 djm Exp $ */
2545d5ecaSDag-Erling Smørgrav /*
3545d5ecaSDag-Erling Smørgrav  * Copyright 2002 Niels Provos <provos@citi.umich.edu>
4545d5ecaSDag-Erling Smørgrav  * Copyright 2002 Markus Friedl <markus@openbsd.org>
5545d5ecaSDag-Erling Smørgrav  * All rights reserved.
6545d5ecaSDag-Erling Smørgrav  *
7545d5ecaSDag-Erling Smørgrav  * Redistribution and use in source and binary forms, with or without
8545d5ecaSDag-Erling Smørgrav  * modification, are permitted provided that the following conditions
9545d5ecaSDag-Erling Smørgrav  * are met:
10545d5ecaSDag-Erling Smørgrav  * 1. Redistributions of source code must retain the above copyright
11545d5ecaSDag-Erling Smørgrav  *    notice, this list of conditions and the following disclaimer.
12545d5ecaSDag-Erling Smørgrav  * 2. Redistributions in binary form must reproduce the above copyright
13545d5ecaSDag-Erling Smørgrav  *    notice, this list of conditions and the following disclaimer in the
14545d5ecaSDag-Erling Smørgrav  *    documentation and/or other materials provided with the distribution.
15545d5ecaSDag-Erling Smørgrav  *
16545d5ecaSDag-Erling Smørgrav  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17545d5ecaSDag-Erling Smørgrav  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18545d5ecaSDag-Erling Smørgrav  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19545d5ecaSDag-Erling Smørgrav  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20545d5ecaSDag-Erling Smørgrav  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21545d5ecaSDag-Erling Smørgrav  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22545d5ecaSDag-Erling Smørgrav  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23545d5ecaSDag-Erling Smørgrav  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24545d5ecaSDag-Erling Smørgrav  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25545d5ecaSDag-Erling Smørgrav  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26545d5ecaSDag-Erling Smørgrav  */
27545d5ecaSDag-Erling Smørgrav 
28545d5ecaSDag-Erling Smørgrav #include "includes.h"
29545d5ecaSDag-Erling Smørgrav 
30333ee039SDag-Erling Smørgrav #include <sys/types.h>
31333ee039SDag-Erling Smørgrav #include <sys/param.h>
32333ee039SDag-Erling Smørgrav #include <sys/socket.h>
33333ee039SDag-Erling Smørgrav #include "openbsd-compat/sys-tree.h"
34333ee039SDag-Erling Smørgrav #include <sys/wait.h>
35333ee039SDag-Erling Smørgrav 
36333ee039SDag-Erling Smørgrav #include <errno.h>
37333ee039SDag-Erling Smørgrav #include <fcntl.h>
38333ee039SDag-Erling Smørgrav #ifdef HAVE_PATHS_H
39333ee039SDag-Erling Smørgrav #include <paths.h>
40333ee039SDag-Erling Smørgrav #endif
41333ee039SDag-Erling Smørgrav #include <pwd.h>
42333ee039SDag-Erling Smørgrav #include <signal.h>
43333ee039SDag-Erling Smørgrav #include <stdarg.h>
44333ee039SDag-Erling Smørgrav #include <stdlib.h>
45333ee039SDag-Erling Smørgrav #include <string.h>
46333ee039SDag-Erling Smørgrav #include <unistd.h>
47*e146993eSDag-Erling Smørgrav #ifdef HAVE_POLL_H
48*e146993eSDag-Erling Smørgrav #include <poll.h>
49*e146993eSDag-Erling Smørgrav #else
50*e146993eSDag-Erling Smørgrav # ifdef HAVE_SYS_POLL_H
51*e146993eSDag-Erling Smørgrav #  include <sys/poll.h>
52*e146993eSDag-Erling Smørgrav # endif
53*e146993eSDag-Erling Smørgrav #endif
54545d5ecaSDag-Erling Smørgrav 
55545d5ecaSDag-Erling Smørgrav #ifdef SKEY
56989dd127SDag-Erling Smørgrav #include <skey.h>
57545d5ecaSDag-Erling Smørgrav #endif
58545d5ecaSDag-Erling Smørgrav 
59333ee039SDag-Erling Smørgrav #include <openssl/dh.h>
60333ee039SDag-Erling Smørgrav 
61d4af9e69SDag-Erling Smørgrav #include "openbsd-compat/sys-queue.h"
62*e146993eSDag-Erling Smørgrav #include "atomicio.h"
63333ee039SDag-Erling Smørgrav #include "xmalloc.h"
64545d5ecaSDag-Erling Smørgrav #include "ssh.h"
65333ee039SDag-Erling Smørgrav #include "key.h"
66333ee039SDag-Erling Smørgrav #include "buffer.h"
67333ee039SDag-Erling Smørgrav #include "hostfile.h"
68545d5ecaSDag-Erling Smørgrav #include "auth.h"
69333ee039SDag-Erling Smørgrav #include "cipher.h"
70545d5ecaSDag-Erling Smørgrav #include "kex.h"
71545d5ecaSDag-Erling Smørgrav #include "dh.h"
725962c0e9SDag-Erling Smørgrav #ifdef TARGET_OS_MAC	/* XXX Broken krb5 headers on Mac */
735962c0e9SDag-Erling Smørgrav #undef TARGET_OS_MAC
74545d5ecaSDag-Erling Smørgrav #include "zlib.h"
755962c0e9SDag-Erling Smørgrav #define TARGET_OS_MAC 1
765962c0e9SDag-Erling Smørgrav #else
775962c0e9SDag-Erling Smørgrav #include "zlib.h"
785962c0e9SDag-Erling Smørgrav #endif
79545d5ecaSDag-Erling Smørgrav #include "packet.h"
80545d5ecaSDag-Erling Smørgrav #include "auth-options.h"
81545d5ecaSDag-Erling Smørgrav #include "sshpty.h"
82545d5ecaSDag-Erling Smørgrav #include "channels.h"
83545d5ecaSDag-Erling Smørgrav #include "session.h"
84545d5ecaSDag-Erling Smørgrav #include "sshlogin.h"
85545d5ecaSDag-Erling Smørgrav #include "canohost.h"
86545d5ecaSDag-Erling Smørgrav #include "log.h"
87545d5ecaSDag-Erling Smørgrav #include "servconf.h"
88545d5ecaSDag-Erling Smørgrav #include "monitor.h"
89545d5ecaSDag-Erling Smørgrav #include "monitor_mm.h"
90333ee039SDag-Erling Smørgrav #ifdef GSSAPI
91333ee039SDag-Erling Smørgrav #include "ssh-gss.h"
92333ee039SDag-Erling Smørgrav #endif
93545d5ecaSDag-Erling Smørgrav #include "monitor_wrap.h"
94545d5ecaSDag-Erling Smørgrav #include "monitor_fdpass.h"
95545d5ecaSDag-Erling Smørgrav #include "misc.h"
96545d5ecaSDag-Erling Smørgrav #include "compat.h"
97545d5ecaSDag-Erling Smørgrav #include "ssh2.h"
98cce7d346SDag-Erling Smørgrav #include "jpake.h"
997aee6ffeSDag-Erling Smørgrav #include "roaming.h"
100545d5ecaSDag-Erling Smørgrav 
101cf2b5f3bSDag-Erling Smørgrav #ifdef GSSAPI
102cf2b5f3bSDag-Erling Smørgrav static Gssctxt *gsscontext = NULL;
103cf2b5f3bSDag-Erling Smørgrav #endif
104cf2b5f3bSDag-Erling Smørgrav 
105545d5ecaSDag-Erling Smørgrav /* Imports */
106545d5ecaSDag-Erling Smørgrav extern ServerOptions options;
107545d5ecaSDag-Erling Smørgrav extern u_int utmp_len;
108545d5ecaSDag-Erling Smørgrav extern Newkeys *current_keys[];
109545d5ecaSDag-Erling Smørgrav extern z_stream incoming_stream;
110545d5ecaSDag-Erling Smørgrav extern z_stream outgoing_stream;
111545d5ecaSDag-Erling Smørgrav extern u_char session_id[];
112545d5ecaSDag-Erling Smørgrav extern Buffer auth_debug;
113545d5ecaSDag-Erling Smørgrav extern int auth_debug_init;
11421e764dfSDag-Erling Smørgrav extern Buffer loginmsg;
115545d5ecaSDag-Erling Smørgrav 
116545d5ecaSDag-Erling Smørgrav /* State exported from the child */
117545d5ecaSDag-Erling Smørgrav 
118545d5ecaSDag-Erling Smørgrav struct {
119545d5ecaSDag-Erling Smørgrav 	z_stream incoming;
120545d5ecaSDag-Erling Smørgrav 	z_stream outgoing;
121545d5ecaSDag-Erling Smørgrav 	u_char *keyin;
122545d5ecaSDag-Erling Smørgrav 	u_int keyinlen;
123545d5ecaSDag-Erling Smørgrav 	u_char *keyout;
124545d5ecaSDag-Erling Smørgrav 	u_int keyoutlen;
125545d5ecaSDag-Erling Smørgrav 	u_char *ivin;
126545d5ecaSDag-Erling Smørgrav 	u_int ivinlen;
127545d5ecaSDag-Erling Smørgrav 	u_char *ivout;
128545d5ecaSDag-Erling Smørgrav 	u_int ivoutlen;
129545d5ecaSDag-Erling Smørgrav 	u_char *ssh1key;
130545d5ecaSDag-Erling Smørgrav 	u_int ssh1keylen;
131545d5ecaSDag-Erling Smørgrav 	int ssh1cipher;
132545d5ecaSDag-Erling Smørgrav 	int ssh1protoflags;
133545d5ecaSDag-Erling Smørgrav 	u_char *input;
134545d5ecaSDag-Erling Smørgrav 	u_int ilen;
135545d5ecaSDag-Erling Smørgrav 	u_char *output;
136545d5ecaSDag-Erling Smørgrav 	u_int olen;
1377aee6ffeSDag-Erling Smørgrav 	u_int64_t sent_bytes;
1387aee6ffeSDag-Erling Smørgrav 	u_int64_t recv_bytes;
139545d5ecaSDag-Erling Smørgrav } child_state;
140545d5ecaSDag-Erling Smørgrav 
141cf2b5f3bSDag-Erling Smørgrav /* Functions on the monitor that answer unprivileged requests */
142545d5ecaSDag-Erling Smørgrav 
143545d5ecaSDag-Erling Smørgrav int mm_answer_moduli(int, Buffer *);
144545d5ecaSDag-Erling Smørgrav int mm_answer_sign(int, Buffer *);
145545d5ecaSDag-Erling Smørgrav int mm_answer_pwnamallow(int, Buffer *);
146545d5ecaSDag-Erling Smørgrav int mm_answer_auth2_read_banner(int, Buffer *);
147545d5ecaSDag-Erling Smørgrav int mm_answer_authserv(int, Buffer *);
148545d5ecaSDag-Erling Smørgrav int mm_answer_authpassword(int, Buffer *);
149545d5ecaSDag-Erling Smørgrav int mm_answer_bsdauthquery(int, Buffer *);
150545d5ecaSDag-Erling Smørgrav int mm_answer_bsdauthrespond(int, Buffer *);
151545d5ecaSDag-Erling Smørgrav int mm_answer_skeyquery(int, Buffer *);
152545d5ecaSDag-Erling Smørgrav int mm_answer_skeyrespond(int, Buffer *);
153545d5ecaSDag-Erling Smørgrav int mm_answer_keyallowed(int, Buffer *);
154545d5ecaSDag-Erling Smørgrav int mm_answer_keyverify(int, Buffer *);
155545d5ecaSDag-Erling Smørgrav int mm_answer_pty(int, Buffer *);
156545d5ecaSDag-Erling Smørgrav int mm_answer_pty_cleanup(int, Buffer *);
157545d5ecaSDag-Erling Smørgrav int mm_answer_term(int, Buffer *);
158545d5ecaSDag-Erling Smørgrav int mm_answer_rsa_keyallowed(int, Buffer *);
159545d5ecaSDag-Erling Smørgrav int mm_answer_rsa_challenge(int, Buffer *);
160545d5ecaSDag-Erling Smørgrav int mm_answer_rsa_response(int, Buffer *);
161545d5ecaSDag-Erling Smørgrav int mm_answer_sesskey(int, Buffer *);
162545d5ecaSDag-Erling Smørgrav int mm_answer_sessid(int, Buffer *);
163cce7d346SDag-Erling Smørgrav int mm_answer_jpake_get_pwdata(int, Buffer *);
164cce7d346SDag-Erling Smørgrav int mm_answer_jpake_step1(int, Buffer *);
165cce7d346SDag-Erling Smørgrav int mm_answer_jpake_step2(int, Buffer *);
166cce7d346SDag-Erling Smørgrav int mm_answer_jpake_key_confirm(int, Buffer *);
167cce7d346SDag-Erling Smørgrav int mm_answer_jpake_check_confirm(int, Buffer *);
168545d5ecaSDag-Erling Smørgrav 
169989dd127SDag-Erling Smørgrav #ifdef USE_PAM
170989dd127SDag-Erling Smørgrav int mm_answer_pam_start(int, Buffer *);
171cf2b5f3bSDag-Erling Smørgrav int mm_answer_pam_account(int, Buffer *);
172382d19eeSDag-Erling Smørgrav int mm_answer_pam_init_ctx(int, Buffer *);
173382d19eeSDag-Erling Smørgrav int mm_answer_pam_query(int, Buffer *);
174382d19eeSDag-Erling Smørgrav int mm_answer_pam_respond(int, Buffer *);
175382d19eeSDag-Erling Smørgrav int mm_answer_pam_free_ctx(int, Buffer *);
176989dd127SDag-Erling Smørgrav #endif
177989dd127SDag-Erling Smørgrav 
178cf2b5f3bSDag-Erling Smørgrav #ifdef GSSAPI
179cf2b5f3bSDag-Erling Smørgrav int mm_answer_gss_setup_ctx(int, Buffer *);
180cf2b5f3bSDag-Erling Smørgrav int mm_answer_gss_accept_ctx(int, Buffer *);
181cf2b5f3bSDag-Erling Smørgrav int mm_answer_gss_userok(int, Buffer *);
1821ec0d754SDag-Erling Smørgrav int mm_answer_gss_checkmic(int, Buffer *);
183f388f5efSDag-Erling Smørgrav #endif
184f388f5efSDag-Erling Smørgrav 
185aa49c926SDag-Erling Smørgrav #ifdef SSH_AUDIT_EVENTS
186aa49c926SDag-Erling Smørgrav int mm_answer_audit_event(int, Buffer *);
187aa49c926SDag-Erling Smørgrav int mm_answer_audit_command(int, Buffer *);
188aa49c926SDag-Erling Smørgrav #endif
189aa49c926SDag-Erling Smørgrav 
190*e146993eSDag-Erling Smørgrav static int monitor_read_log(struct monitor *);
191*e146993eSDag-Erling Smørgrav 
192545d5ecaSDag-Erling Smørgrav static Authctxt *authctxt;
193545d5ecaSDag-Erling Smørgrav static BIGNUM *ssh1_challenge = NULL;	/* used for ssh1 rsa auth */
194545d5ecaSDag-Erling Smørgrav 
195545d5ecaSDag-Erling Smørgrav /* local state for key verify */
196545d5ecaSDag-Erling Smørgrav static u_char *key_blob = NULL;
197545d5ecaSDag-Erling Smørgrav static u_int key_bloblen = 0;
198545d5ecaSDag-Erling Smørgrav static int key_blobtype = MM_NOKEY;
199f388f5efSDag-Erling Smørgrav static char *hostbased_cuser = NULL;
200f388f5efSDag-Erling Smørgrav static char *hostbased_chost = NULL;
201545d5ecaSDag-Erling Smørgrav static char *auth_method = "unknown";
202cf2b5f3bSDag-Erling Smørgrav static u_int session_id2_len = 0;
203545d5ecaSDag-Erling Smørgrav static u_char *session_id2 = NULL;
204cf2b5f3bSDag-Erling Smørgrav static pid_t monitor_child_pid;
205545d5ecaSDag-Erling Smørgrav 
206545d5ecaSDag-Erling Smørgrav struct mon_table {
207545d5ecaSDag-Erling Smørgrav 	enum monitor_reqtype type;
208545d5ecaSDag-Erling Smørgrav 	int flags;
209545d5ecaSDag-Erling Smørgrav 	int (*f)(int, Buffer *);
210545d5ecaSDag-Erling Smørgrav };
211545d5ecaSDag-Erling Smørgrav 
212545d5ecaSDag-Erling Smørgrav #define MON_ISAUTH	0x0004	/* Required for Authentication */
213545d5ecaSDag-Erling Smørgrav #define MON_AUTHDECIDE	0x0008	/* Decides Authentication */
214545d5ecaSDag-Erling Smørgrav #define MON_ONCE	0x0010	/* Disable after calling */
215333ee039SDag-Erling Smørgrav #define MON_ALOG	0x0020	/* Log auth attempt without authenticating */
216545d5ecaSDag-Erling Smørgrav 
217545d5ecaSDag-Erling Smørgrav #define MON_AUTH	(MON_ISAUTH|MON_AUTHDECIDE)
218545d5ecaSDag-Erling Smørgrav 
219545d5ecaSDag-Erling Smørgrav #define MON_PERMIT	0x1000	/* Request is permitted */
220545d5ecaSDag-Erling Smørgrav 
221545d5ecaSDag-Erling Smørgrav struct mon_table mon_dispatch_proto20[] = {
222545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_MODULI, MON_ONCE, mm_answer_moduli},
223545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SIGN, MON_ONCE, mm_answer_sign},
224545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_PWNAM, MON_ONCE, mm_answer_pwnamallow},
225545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_AUTHSERV, MON_ONCE, mm_answer_authserv},
226545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_AUTH2_READ_BANNER, MON_ONCE, mm_answer_auth2_read_banner},
227545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_AUTHPASSWORD, MON_AUTH, mm_answer_authpassword},
228989dd127SDag-Erling Smørgrav #ifdef USE_PAM
229989dd127SDag-Erling Smørgrav     {MONITOR_REQ_PAM_START, MON_ONCE, mm_answer_pam_start},
230cf2b5f3bSDag-Erling Smørgrav     {MONITOR_REQ_PAM_ACCOUNT, 0, mm_answer_pam_account},
231382d19eeSDag-Erling Smørgrav     {MONITOR_REQ_PAM_INIT_CTX, MON_ISAUTH, mm_answer_pam_init_ctx},
232382d19eeSDag-Erling Smørgrav     {MONITOR_REQ_PAM_QUERY, MON_ISAUTH, mm_answer_pam_query},
233382d19eeSDag-Erling Smørgrav     {MONITOR_REQ_PAM_RESPOND, MON_ISAUTH, mm_answer_pam_respond},
234382d19eeSDag-Erling Smørgrav     {MONITOR_REQ_PAM_FREE_CTX, MON_ONCE|MON_AUTHDECIDE, mm_answer_pam_free_ctx},
235989dd127SDag-Erling Smørgrav #endif
236aa49c926SDag-Erling Smørgrav #ifdef SSH_AUDIT_EVENTS
237aa49c926SDag-Erling Smørgrav     {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
238aa49c926SDag-Erling Smørgrav #endif
239545d5ecaSDag-Erling Smørgrav #ifdef BSD_AUTH
240545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_BSDAUTHQUERY, MON_ISAUTH, mm_answer_bsdauthquery},
241545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_BSDAUTHRESPOND, MON_AUTH, mm_answer_bsdauthrespond},
242545d5ecaSDag-Erling Smørgrav #endif
243545d5ecaSDag-Erling Smørgrav #ifdef SKEY
244545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SKEYQUERY, MON_ISAUTH, mm_answer_skeyquery},
245545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SKEYRESPOND, MON_AUTH, mm_answer_skeyrespond},
246545d5ecaSDag-Erling Smørgrav #endif
247545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_KEYALLOWED, MON_ISAUTH, mm_answer_keyallowed},
248545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_KEYVERIFY, MON_AUTH, mm_answer_keyverify},
249cf2b5f3bSDag-Erling Smørgrav #ifdef GSSAPI
250cf2b5f3bSDag-Erling Smørgrav     {MONITOR_REQ_GSSSETUP, MON_ISAUTH, mm_answer_gss_setup_ctx},
251cf2b5f3bSDag-Erling Smørgrav     {MONITOR_REQ_GSSSTEP, MON_ISAUTH, mm_answer_gss_accept_ctx},
252cf2b5f3bSDag-Erling Smørgrav     {MONITOR_REQ_GSSUSEROK, MON_AUTH, mm_answer_gss_userok},
2531ec0d754SDag-Erling Smørgrav     {MONITOR_REQ_GSSCHECKMIC, MON_ISAUTH, mm_answer_gss_checkmic},
254cf2b5f3bSDag-Erling Smørgrav #endif
255cce7d346SDag-Erling Smørgrav #ifdef JPAKE
256cce7d346SDag-Erling Smørgrav     {MONITOR_REQ_JPAKE_GET_PWDATA, MON_ONCE, mm_answer_jpake_get_pwdata},
257cce7d346SDag-Erling Smørgrav     {MONITOR_REQ_JPAKE_STEP1, MON_ISAUTH, mm_answer_jpake_step1},
258cce7d346SDag-Erling Smørgrav     {MONITOR_REQ_JPAKE_STEP2, MON_ONCE, mm_answer_jpake_step2},
259cce7d346SDag-Erling Smørgrav     {MONITOR_REQ_JPAKE_KEY_CONFIRM, MON_ONCE, mm_answer_jpake_key_confirm},
260cce7d346SDag-Erling Smørgrav     {MONITOR_REQ_JPAKE_CHECK_CONFIRM, MON_AUTH, mm_answer_jpake_check_confirm},
261cce7d346SDag-Erling Smørgrav #endif
262545d5ecaSDag-Erling Smørgrav     {0, 0, NULL}
263545d5ecaSDag-Erling Smørgrav };
264545d5ecaSDag-Erling Smørgrav 
265545d5ecaSDag-Erling Smørgrav struct mon_table mon_dispatch_postauth20[] = {
266545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_MODULI, 0, mm_answer_moduli},
267545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SIGN, 0, mm_answer_sign},
268545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_PTY, 0, mm_answer_pty},
269545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_PTYCLEANUP, 0, mm_answer_pty_cleanup},
270545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_TERM, 0, mm_answer_term},
271aa49c926SDag-Erling Smørgrav #ifdef SSH_AUDIT_EVENTS
272aa49c926SDag-Erling Smørgrav     {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
273aa49c926SDag-Erling Smørgrav     {MONITOR_REQ_AUDIT_COMMAND, MON_PERMIT, mm_answer_audit_command},
274aa49c926SDag-Erling Smørgrav #endif
275545d5ecaSDag-Erling Smørgrav     {0, 0, NULL}
276545d5ecaSDag-Erling Smørgrav };
277545d5ecaSDag-Erling Smørgrav 
278545d5ecaSDag-Erling Smørgrav struct mon_table mon_dispatch_proto15[] = {
279545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_PWNAM, MON_ONCE, mm_answer_pwnamallow},
280545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SESSKEY, MON_ONCE, mm_answer_sesskey},
281545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SESSID, MON_ONCE, mm_answer_sessid},
282545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_AUTHPASSWORD, MON_AUTH, mm_answer_authpassword},
283333ee039SDag-Erling Smørgrav     {MONITOR_REQ_RSAKEYALLOWED, MON_ISAUTH|MON_ALOG, mm_answer_rsa_keyallowed},
284333ee039SDag-Erling Smørgrav     {MONITOR_REQ_KEYALLOWED, MON_ISAUTH|MON_ALOG, mm_answer_keyallowed},
285545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_RSACHALLENGE, MON_ONCE, mm_answer_rsa_challenge},
286545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_RSARESPONSE, MON_ONCE|MON_AUTHDECIDE, mm_answer_rsa_response},
287545d5ecaSDag-Erling Smørgrav #ifdef BSD_AUTH
288545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_BSDAUTHQUERY, MON_ISAUTH, mm_answer_bsdauthquery},
289545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_BSDAUTHRESPOND, MON_AUTH, mm_answer_bsdauthrespond},
290545d5ecaSDag-Erling Smørgrav #endif
291545d5ecaSDag-Erling Smørgrav #ifdef SKEY
292545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SKEYQUERY, MON_ISAUTH, mm_answer_skeyquery},
293545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_SKEYRESPOND, MON_AUTH, mm_answer_skeyrespond},
294545d5ecaSDag-Erling Smørgrav #endif
295a82e551fSDag-Erling Smørgrav #ifdef USE_PAM
296a82e551fSDag-Erling Smørgrav     {MONITOR_REQ_PAM_START, MON_ONCE, mm_answer_pam_start},
297cf2b5f3bSDag-Erling Smørgrav     {MONITOR_REQ_PAM_ACCOUNT, 0, mm_answer_pam_account},
298a82e551fSDag-Erling Smørgrav     {MONITOR_REQ_PAM_INIT_CTX, MON_ISAUTH, mm_answer_pam_init_ctx},
299a82e551fSDag-Erling Smørgrav     {MONITOR_REQ_PAM_QUERY, MON_ISAUTH, mm_answer_pam_query},
300a82e551fSDag-Erling Smørgrav     {MONITOR_REQ_PAM_RESPOND, MON_ISAUTH, mm_answer_pam_respond},
301a82e551fSDag-Erling Smørgrav     {MONITOR_REQ_PAM_FREE_CTX, MON_ONCE|MON_AUTHDECIDE, mm_answer_pam_free_ctx},
302a82e551fSDag-Erling Smørgrav #endif
303aa49c926SDag-Erling Smørgrav #ifdef SSH_AUDIT_EVENTS
304aa49c926SDag-Erling Smørgrav     {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
305aa49c926SDag-Erling Smørgrav #endif
306545d5ecaSDag-Erling Smørgrav     {0, 0, NULL}
307545d5ecaSDag-Erling Smørgrav };
308545d5ecaSDag-Erling Smørgrav 
309545d5ecaSDag-Erling Smørgrav struct mon_table mon_dispatch_postauth15[] = {
310545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_PTY, MON_ONCE, mm_answer_pty},
311545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_PTYCLEANUP, MON_ONCE, mm_answer_pty_cleanup},
312545d5ecaSDag-Erling Smørgrav     {MONITOR_REQ_TERM, 0, mm_answer_term},
313aa49c926SDag-Erling Smørgrav #ifdef SSH_AUDIT_EVENTS
314aa49c926SDag-Erling Smørgrav     {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event},
3159d2c6627SDag-Erling Smørgrav     {MONITOR_REQ_AUDIT_COMMAND, MON_PERMIT|MON_ONCE, mm_answer_audit_command},
316aa49c926SDag-Erling Smørgrav #endif
317545d5ecaSDag-Erling Smørgrav     {0, 0, NULL}
318545d5ecaSDag-Erling Smørgrav };
319545d5ecaSDag-Erling Smørgrav 
320545d5ecaSDag-Erling Smørgrav struct mon_table *mon_dispatch;
321545d5ecaSDag-Erling Smørgrav 
322545d5ecaSDag-Erling Smørgrav /* Specifies if a certain message is allowed at the moment */
323545d5ecaSDag-Erling Smørgrav 
324545d5ecaSDag-Erling Smørgrav static void
325545d5ecaSDag-Erling Smørgrav monitor_permit(struct mon_table *ent, enum monitor_reqtype type, int permit)
326545d5ecaSDag-Erling Smørgrav {
327545d5ecaSDag-Erling Smørgrav 	while (ent->f != NULL) {
328545d5ecaSDag-Erling Smørgrav 		if (ent->type == type) {
329545d5ecaSDag-Erling Smørgrav 			ent->flags &= ~MON_PERMIT;
330545d5ecaSDag-Erling Smørgrav 			ent->flags |= permit ? MON_PERMIT : 0;
331545d5ecaSDag-Erling Smørgrav 			return;
332545d5ecaSDag-Erling Smørgrav 		}
333545d5ecaSDag-Erling Smørgrav 		ent++;
334545d5ecaSDag-Erling Smørgrav 	}
335545d5ecaSDag-Erling Smørgrav }
336545d5ecaSDag-Erling Smørgrav 
337545d5ecaSDag-Erling Smørgrav static void
338545d5ecaSDag-Erling Smørgrav monitor_permit_authentications(int permit)
339545d5ecaSDag-Erling Smørgrav {
340545d5ecaSDag-Erling Smørgrav 	struct mon_table *ent = mon_dispatch;
341545d5ecaSDag-Erling Smørgrav 
342545d5ecaSDag-Erling Smørgrav 	while (ent->f != NULL) {
343545d5ecaSDag-Erling Smørgrav 		if (ent->flags & MON_AUTH) {
344545d5ecaSDag-Erling Smørgrav 			ent->flags &= ~MON_PERMIT;
345545d5ecaSDag-Erling Smørgrav 			ent->flags |= permit ? MON_PERMIT : 0;
346545d5ecaSDag-Erling Smørgrav 		}
347545d5ecaSDag-Erling Smørgrav 		ent++;
348545d5ecaSDag-Erling Smørgrav 	}
349545d5ecaSDag-Erling Smørgrav }
350545d5ecaSDag-Erling Smørgrav 
3511ec0d754SDag-Erling Smørgrav void
3521ec0d754SDag-Erling Smørgrav monitor_child_preauth(Authctxt *_authctxt, struct monitor *pmonitor)
353545d5ecaSDag-Erling Smørgrav {
354545d5ecaSDag-Erling Smørgrav 	struct mon_table *ent;
355545d5ecaSDag-Erling Smørgrav 	int authenticated = 0;
356545d5ecaSDag-Erling Smørgrav 
357545d5ecaSDag-Erling Smørgrav 	debug3("preauth child monitor started");
358545d5ecaSDag-Erling Smørgrav 
359*e146993eSDag-Erling Smørgrav 	close(pmonitor->m_recvfd);
360*e146993eSDag-Erling Smørgrav 	close(pmonitor->m_log_sendfd);
361*e146993eSDag-Erling Smørgrav 	pmonitor->m_log_sendfd = pmonitor->m_recvfd = -1;
362*e146993eSDag-Erling Smørgrav 
3631ec0d754SDag-Erling Smørgrav 	authctxt = _authctxt;
3641ec0d754SDag-Erling Smørgrav 	memset(authctxt, 0, sizeof(*authctxt));
3651ec0d754SDag-Erling Smørgrav 
366aa49c926SDag-Erling Smørgrav 	authctxt->loginmsg = &loginmsg;
367aa49c926SDag-Erling Smørgrav 
368545d5ecaSDag-Erling Smørgrav 	if (compat20) {
369545d5ecaSDag-Erling Smørgrav 		mon_dispatch = mon_dispatch_proto20;
370545d5ecaSDag-Erling Smørgrav 
371545d5ecaSDag-Erling Smørgrav 		/* Permit requests for moduli and signatures */
372545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_MODULI, 1);
373545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_SIGN, 1);
374545d5ecaSDag-Erling Smørgrav 	} else {
375545d5ecaSDag-Erling Smørgrav 		mon_dispatch = mon_dispatch_proto15;
376545d5ecaSDag-Erling Smørgrav 
377545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 1);
378545d5ecaSDag-Erling Smørgrav 	}
379545d5ecaSDag-Erling Smørgrav 
380545d5ecaSDag-Erling Smørgrav 	/* The first few requests do not require asynchronous access */
381545d5ecaSDag-Erling Smørgrav 	while (!authenticated) {
382333ee039SDag-Erling Smørgrav 		auth_method = "unknown";
38362efe23aSDag-Erling Smørgrav 		authenticated = (monitor_read(pmonitor, mon_dispatch, &ent) == 1);
384545d5ecaSDag-Erling Smørgrav 		if (authenticated) {
385545d5ecaSDag-Erling Smørgrav 			if (!(ent->flags & MON_AUTHDECIDE))
386545d5ecaSDag-Erling Smørgrav 				fatal("%s: unexpected authentication from %d",
387545d5ecaSDag-Erling Smørgrav 				    __func__, ent->type);
388545d5ecaSDag-Erling Smørgrav 			if (authctxt->pw->pw_uid == 0 &&
389545d5ecaSDag-Erling Smørgrav 			    !auth_root_allowed(auth_method))
390545d5ecaSDag-Erling Smørgrav 				authenticated = 0;
391cf2b5f3bSDag-Erling Smørgrav #ifdef USE_PAM
392cf2b5f3bSDag-Erling Smørgrav 			/* PAM needs to perform account checks after auth */
3931ec0d754SDag-Erling Smørgrav 			if (options.use_pam && authenticated) {
394cf2b5f3bSDag-Erling Smørgrav 				Buffer m;
395cf2b5f3bSDag-Erling Smørgrav 
396cf2b5f3bSDag-Erling Smørgrav 				buffer_init(&m);
397cf2b5f3bSDag-Erling Smørgrav 				mm_request_receive_expect(pmonitor->m_sendfd,
398cf2b5f3bSDag-Erling Smørgrav 				    MONITOR_REQ_PAM_ACCOUNT, &m);
399cf2b5f3bSDag-Erling Smørgrav 				authenticated = mm_answer_pam_account(pmonitor->m_sendfd, &m);
400cf2b5f3bSDag-Erling Smørgrav 				buffer_free(&m);
401cf2b5f3bSDag-Erling Smørgrav 			}
402cf2b5f3bSDag-Erling Smørgrav #endif
403545d5ecaSDag-Erling Smørgrav 		}
404545d5ecaSDag-Erling Smørgrav 
405333ee039SDag-Erling Smørgrav 		if (ent->flags & (MON_AUTHDECIDE|MON_ALOG)) {
406545d5ecaSDag-Erling Smørgrav 			auth_log(authctxt, authenticated, auth_method,
407545d5ecaSDag-Erling Smørgrav 			    compat20 ? " ssh2" : "");
408545d5ecaSDag-Erling Smørgrav 			if (!authenticated)
409545d5ecaSDag-Erling Smørgrav 				authctxt->failures++;
410545d5ecaSDag-Erling Smørgrav 		}
411cce7d346SDag-Erling Smørgrav #ifdef JPAKE
412cce7d346SDag-Erling Smørgrav 		/* Cleanup JPAKE context after authentication */
413cce7d346SDag-Erling Smørgrav 		if (ent->flags & MON_AUTHDECIDE) {
414cce7d346SDag-Erling Smørgrav 			if (authctxt->jpake_ctx != NULL) {
415cce7d346SDag-Erling Smørgrav 				jpake_free(authctxt->jpake_ctx);
416cce7d346SDag-Erling Smørgrav 				authctxt->jpake_ctx = NULL;
417cce7d346SDag-Erling Smørgrav 			}
418cce7d346SDag-Erling Smørgrav 		}
419cce7d346SDag-Erling Smørgrav #endif
420545d5ecaSDag-Erling Smørgrav 	}
421545d5ecaSDag-Erling Smørgrav 
422*e146993eSDag-Erling Smørgrav 	/* Drain any buffered messages from the child */
423*e146993eSDag-Erling Smørgrav 	while (pmonitor->m_log_recvfd != -1 && monitor_read_log(pmonitor) == 0)
424*e146993eSDag-Erling Smørgrav 		;
425*e146993eSDag-Erling Smørgrav 
426545d5ecaSDag-Erling Smørgrav 	if (!authctxt->valid)
427545d5ecaSDag-Erling Smørgrav 		fatal("%s: authenticated invalid user", __func__);
428333ee039SDag-Erling Smørgrav 	if (strcmp(auth_method, "unknown") == 0)
429333ee039SDag-Erling Smørgrav 		fatal("%s: authentication method name unknown", __func__);
430545d5ecaSDag-Erling Smørgrav 
431545d5ecaSDag-Erling Smørgrav 	debug("%s: %s has been authenticated by privileged process",
432545d5ecaSDag-Erling Smørgrav 	    __func__, authctxt->user);
433545d5ecaSDag-Erling Smørgrav 
434545d5ecaSDag-Erling Smørgrav 	mm_get_keystate(pmonitor);
435*e146993eSDag-Erling Smørgrav 
436*e146993eSDag-Erling Smørgrav 	close(pmonitor->m_sendfd);
437*e146993eSDag-Erling Smørgrav 	close(pmonitor->m_log_recvfd);
438*e146993eSDag-Erling Smørgrav 	pmonitor->m_sendfd = pmonitor->m_log_recvfd = -1;
439545d5ecaSDag-Erling Smørgrav }
440545d5ecaSDag-Erling Smørgrav 
441cf2b5f3bSDag-Erling Smørgrav static void
442cf2b5f3bSDag-Erling Smørgrav monitor_set_child_handler(pid_t pid)
443cf2b5f3bSDag-Erling Smørgrav {
444cf2b5f3bSDag-Erling Smørgrav 	monitor_child_pid = pid;
445cf2b5f3bSDag-Erling Smørgrav }
446cf2b5f3bSDag-Erling Smørgrav 
447cf2b5f3bSDag-Erling Smørgrav static void
44821e764dfSDag-Erling Smørgrav monitor_child_handler(int sig)
449cf2b5f3bSDag-Erling Smørgrav {
45021e764dfSDag-Erling Smørgrav 	kill(monitor_child_pid, sig);
451cf2b5f3bSDag-Erling Smørgrav }
452cf2b5f3bSDag-Erling Smørgrav 
453545d5ecaSDag-Erling Smørgrav void
454545d5ecaSDag-Erling Smørgrav monitor_child_postauth(struct monitor *pmonitor)
455545d5ecaSDag-Erling Smørgrav {
456*e146993eSDag-Erling Smørgrav 	close(pmonitor->m_recvfd);
457*e146993eSDag-Erling Smørgrav 	pmonitor->m_recvfd = -1;
458*e146993eSDag-Erling Smørgrav 
459cf2b5f3bSDag-Erling Smørgrav 	monitor_set_child_handler(pmonitor->m_pid);
460cf2b5f3bSDag-Erling Smørgrav 	signal(SIGHUP, &monitor_child_handler);
461cf2b5f3bSDag-Erling Smørgrav 	signal(SIGTERM, &monitor_child_handler);
462d4af9e69SDag-Erling Smørgrav 	signal(SIGINT, &monitor_child_handler);
463cf2b5f3bSDag-Erling Smørgrav 
464545d5ecaSDag-Erling Smørgrav 	if (compat20) {
465545d5ecaSDag-Erling Smørgrav 		mon_dispatch = mon_dispatch_postauth20;
466545d5ecaSDag-Erling Smørgrav 
467545d5ecaSDag-Erling Smørgrav 		/* Permit requests for moduli and signatures */
468545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_MODULI, 1);
469545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_SIGN, 1);
470545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_TERM, 1);
471545d5ecaSDag-Erling Smørgrav 	} else {
472545d5ecaSDag-Erling Smørgrav 		mon_dispatch = mon_dispatch_postauth15;
473545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_TERM, 1);
474545d5ecaSDag-Erling Smørgrav 	}
475545d5ecaSDag-Erling Smørgrav 	if (!no_pty_flag) {
476545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_PTY, 1);
477545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_PTYCLEANUP, 1);
478545d5ecaSDag-Erling Smørgrav 	}
479545d5ecaSDag-Erling Smørgrav 
480545d5ecaSDag-Erling Smørgrav 	for (;;)
481545d5ecaSDag-Erling Smørgrav 		monitor_read(pmonitor, mon_dispatch, NULL);
482*e146993eSDag-Erling Smørgrav 
483*e146993eSDag-Erling Smørgrav 	close(pmonitor->m_sendfd);
484*e146993eSDag-Erling Smørgrav 	pmonitor->m_sendfd = -1;
485545d5ecaSDag-Erling Smørgrav }
486545d5ecaSDag-Erling Smørgrav 
487545d5ecaSDag-Erling Smørgrav void
488545d5ecaSDag-Erling Smørgrav monitor_sync(struct monitor *pmonitor)
489545d5ecaSDag-Erling Smørgrav {
490545d5ecaSDag-Erling Smørgrav 	if (options.compression) {
491545d5ecaSDag-Erling Smørgrav 		/* The member allocation is not visible, so sync it */
492545d5ecaSDag-Erling Smørgrav 		mm_share_sync(&pmonitor->m_zlib, &pmonitor->m_zback);
493545d5ecaSDag-Erling Smørgrav 	}
494545d5ecaSDag-Erling Smørgrav }
495545d5ecaSDag-Erling Smørgrav 
496*e146993eSDag-Erling Smørgrav static int
497*e146993eSDag-Erling Smørgrav monitor_read_log(struct monitor *pmonitor)
498*e146993eSDag-Erling Smørgrav {
499*e146993eSDag-Erling Smørgrav 	Buffer logmsg;
500*e146993eSDag-Erling Smørgrav 	u_int len, level;
501*e146993eSDag-Erling Smørgrav 	char *msg;
502*e146993eSDag-Erling Smørgrav 
503*e146993eSDag-Erling Smørgrav 	buffer_init(&logmsg);
504*e146993eSDag-Erling Smørgrav 
505*e146993eSDag-Erling Smørgrav 	/* Read length */
506*e146993eSDag-Erling Smørgrav 	buffer_append_space(&logmsg, 4);
507*e146993eSDag-Erling Smørgrav 	if (atomicio(read, pmonitor->m_log_recvfd,
508*e146993eSDag-Erling Smørgrav 	    buffer_ptr(&logmsg), buffer_len(&logmsg)) != buffer_len(&logmsg)) {
509*e146993eSDag-Erling Smørgrav 		if (errno == EPIPE) {
510*e146993eSDag-Erling Smørgrav 			debug("%s: child log fd closed", __func__);
511*e146993eSDag-Erling Smørgrav 			close(pmonitor->m_log_recvfd);
512*e146993eSDag-Erling Smørgrav 			pmonitor->m_log_recvfd = -1;
513*e146993eSDag-Erling Smørgrav 			return -1;
514*e146993eSDag-Erling Smørgrav 		}
515*e146993eSDag-Erling Smørgrav 		fatal("%s: log fd read: %s", __func__, strerror(errno));
516*e146993eSDag-Erling Smørgrav 	}
517*e146993eSDag-Erling Smørgrav 	len = buffer_get_int(&logmsg);
518*e146993eSDag-Erling Smørgrav 	if (len <= 4 || len > 8192)
519*e146993eSDag-Erling Smørgrav 		fatal("%s: invalid log message length %u", __func__, len);
520*e146993eSDag-Erling Smørgrav 
521*e146993eSDag-Erling Smørgrav 	/* Read severity, message */
522*e146993eSDag-Erling Smørgrav 	buffer_clear(&logmsg);
523*e146993eSDag-Erling Smørgrav 	buffer_append_space(&logmsg, len);
524*e146993eSDag-Erling Smørgrav 	if (atomicio(read, pmonitor->m_log_recvfd,
525*e146993eSDag-Erling Smørgrav 	    buffer_ptr(&logmsg), buffer_len(&logmsg)) != buffer_len(&logmsg))
526*e146993eSDag-Erling Smørgrav 		fatal("%s: log fd read: %s", __func__, strerror(errno));
527*e146993eSDag-Erling Smørgrav 
528*e146993eSDag-Erling Smørgrav 	/* Log it */
529*e146993eSDag-Erling Smørgrav 	level = buffer_get_int(&logmsg);
530*e146993eSDag-Erling Smørgrav 	msg = buffer_get_string(&logmsg, NULL);
531*e146993eSDag-Erling Smørgrav 	if (log_level_name(level) == NULL)
532*e146993eSDag-Erling Smørgrav 		fatal("%s: invalid log level %u (corrupted message?)",
533*e146993eSDag-Erling Smørgrav 		    __func__, level);
534*e146993eSDag-Erling Smørgrav 	do_log2(level, "%s [preauth]", msg);
535*e146993eSDag-Erling Smørgrav 
536*e146993eSDag-Erling Smørgrav 	buffer_free(&logmsg);
537*e146993eSDag-Erling Smørgrav 	xfree(msg);
538*e146993eSDag-Erling Smørgrav 
539*e146993eSDag-Erling Smørgrav 	return 0;
540*e146993eSDag-Erling Smørgrav }
541*e146993eSDag-Erling Smørgrav 
542545d5ecaSDag-Erling Smørgrav int
543545d5ecaSDag-Erling Smørgrav monitor_read(struct monitor *pmonitor, struct mon_table *ent,
544545d5ecaSDag-Erling Smørgrav     struct mon_table **pent)
545545d5ecaSDag-Erling Smørgrav {
546545d5ecaSDag-Erling Smørgrav 	Buffer m;
547545d5ecaSDag-Erling Smørgrav 	int ret;
548545d5ecaSDag-Erling Smørgrav 	u_char type;
549*e146993eSDag-Erling Smørgrav 	struct pollfd pfd[2];
550*e146993eSDag-Erling Smørgrav 
551*e146993eSDag-Erling Smørgrav 	for (;;) {
552*e146993eSDag-Erling Smørgrav 		bzero(&pfd, sizeof(pfd));
553*e146993eSDag-Erling Smørgrav 		pfd[0].fd = pmonitor->m_sendfd;
554*e146993eSDag-Erling Smørgrav 		pfd[0].events = POLLIN;
555*e146993eSDag-Erling Smørgrav 		pfd[1].fd = pmonitor->m_log_recvfd;
556*e146993eSDag-Erling Smørgrav 		pfd[1].events = pfd[1].fd == -1 ? 0 : POLLIN;
557*e146993eSDag-Erling Smørgrav 		if (poll(pfd, pfd[1].fd == -1 ? 1 : 2, -1) == -1) {
558*e146993eSDag-Erling Smørgrav 			if (errno == EINTR || errno == EAGAIN)
559*e146993eSDag-Erling Smørgrav 				continue;
560*e146993eSDag-Erling Smørgrav 			fatal("%s: poll: %s", __func__, strerror(errno));
561*e146993eSDag-Erling Smørgrav 		}
562*e146993eSDag-Erling Smørgrav 		if (pfd[1].revents) {
563*e146993eSDag-Erling Smørgrav 			/*
564*e146993eSDag-Erling Smørgrav 			 * Drain all log messages before processing next
565*e146993eSDag-Erling Smørgrav 			 * monitor request.
566*e146993eSDag-Erling Smørgrav 			 */
567*e146993eSDag-Erling Smørgrav 			monitor_read_log(pmonitor);
568*e146993eSDag-Erling Smørgrav 			continue;
569*e146993eSDag-Erling Smørgrav 		}
570*e146993eSDag-Erling Smørgrav 		if (pfd[0].revents)
571*e146993eSDag-Erling Smørgrav 			break;  /* Continues below */
572*e146993eSDag-Erling Smørgrav 	}
573545d5ecaSDag-Erling Smørgrav 
574545d5ecaSDag-Erling Smørgrav 	buffer_init(&m);
575545d5ecaSDag-Erling Smørgrav 
576545d5ecaSDag-Erling Smørgrav 	mm_request_receive(pmonitor->m_sendfd, &m);
577545d5ecaSDag-Erling Smørgrav 	type = buffer_get_char(&m);
578545d5ecaSDag-Erling Smørgrav 
579545d5ecaSDag-Erling Smørgrav 	debug3("%s: checking request %d", __func__, type);
580545d5ecaSDag-Erling Smørgrav 
581545d5ecaSDag-Erling Smørgrav 	while (ent->f != NULL) {
582545d5ecaSDag-Erling Smørgrav 		if (ent->type == type)
583545d5ecaSDag-Erling Smørgrav 			break;
584545d5ecaSDag-Erling Smørgrav 		ent++;
585545d5ecaSDag-Erling Smørgrav 	}
586545d5ecaSDag-Erling Smørgrav 
587545d5ecaSDag-Erling Smørgrav 	if (ent->f != NULL) {
588545d5ecaSDag-Erling Smørgrav 		if (!(ent->flags & MON_PERMIT))
589545d5ecaSDag-Erling Smørgrav 			fatal("%s: unpermitted request %d", __func__,
590545d5ecaSDag-Erling Smørgrav 			    type);
591545d5ecaSDag-Erling Smørgrav 		ret = (*ent->f)(pmonitor->m_sendfd, &m);
592545d5ecaSDag-Erling Smørgrav 		buffer_free(&m);
593545d5ecaSDag-Erling Smørgrav 
594545d5ecaSDag-Erling Smørgrav 		/* The child may use this request only once, disable it */
595545d5ecaSDag-Erling Smørgrav 		if (ent->flags & MON_ONCE) {
596545d5ecaSDag-Erling Smørgrav 			debug2("%s: %d used once, disabling now", __func__,
597545d5ecaSDag-Erling Smørgrav 			    type);
598545d5ecaSDag-Erling Smørgrav 			ent->flags &= ~MON_PERMIT;
599545d5ecaSDag-Erling Smørgrav 		}
600545d5ecaSDag-Erling Smørgrav 
601545d5ecaSDag-Erling Smørgrav 		if (pent != NULL)
602545d5ecaSDag-Erling Smørgrav 			*pent = ent;
603545d5ecaSDag-Erling Smørgrav 
604545d5ecaSDag-Erling Smørgrav 		return ret;
605545d5ecaSDag-Erling Smørgrav 	}
606545d5ecaSDag-Erling Smørgrav 
607545d5ecaSDag-Erling Smørgrav 	fatal("%s: unsupported request: %d", __func__, type);
608545d5ecaSDag-Erling Smørgrav 
609545d5ecaSDag-Erling Smørgrav 	/* NOTREACHED */
610545d5ecaSDag-Erling Smørgrav 	return (-1);
611545d5ecaSDag-Erling Smørgrav }
612545d5ecaSDag-Erling Smørgrav 
613545d5ecaSDag-Erling Smørgrav /* allowed key state */
614545d5ecaSDag-Erling Smørgrav static int
615545d5ecaSDag-Erling Smørgrav monitor_allowed_key(u_char *blob, u_int bloblen)
616545d5ecaSDag-Erling Smørgrav {
617545d5ecaSDag-Erling Smørgrav 	/* make sure key is allowed */
618545d5ecaSDag-Erling Smørgrav 	if (key_blob == NULL || key_bloblen != bloblen ||
619e2f6069cSDag-Erling Smørgrav 	    timingsafe_bcmp(key_blob, blob, key_bloblen))
620545d5ecaSDag-Erling Smørgrav 		return (0);
621545d5ecaSDag-Erling Smørgrav 	return (1);
622545d5ecaSDag-Erling Smørgrav }
623545d5ecaSDag-Erling Smørgrav 
624545d5ecaSDag-Erling Smørgrav static void
625545d5ecaSDag-Erling Smørgrav monitor_reset_key_state(void)
626545d5ecaSDag-Erling Smørgrav {
627545d5ecaSDag-Erling Smørgrav 	/* reset state */
628545d5ecaSDag-Erling Smørgrav 	if (key_blob != NULL)
629545d5ecaSDag-Erling Smørgrav 		xfree(key_blob);
630545d5ecaSDag-Erling Smørgrav 	if (hostbased_cuser != NULL)
631545d5ecaSDag-Erling Smørgrav 		xfree(hostbased_cuser);
632545d5ecaSDag-Erling Smørgrav 	if (hostbased_chost != NULL)
633545d5ecaSDag-Erling Smørgrav 		xfree(hostbased_chost);
634545d5ecaSDag-Erling Smørgrav 	key_blob = NULL;
635545d5ecaSDag-Erling Smørgrav 	key_bloblen = 0;
636545d5ecaSDag-Erling Smørgrav 	key_blobtype = MM_NOKEY;
637545d5ecaSDag-Erling Smørgrav 	hostbased_cuser = NULL;
638545d5ecaSDag-Erling Smørgrav 	hostbased_chost = NULL;
639545d5ecaSDag-Erling Smørgrav }
640545d5ecaSDag-Erling Smørgrav 
641545d5ecaSDag-Erling Smørgrav int
64221e764dfSDag-Erling Smørgrav mm_answer_moduli(int sock, Buffer *m)
643545d5ecaSDag-Erling Smørgrav {
644545d5ecaSDag-Erling Smørgrav 	DH *dh;
645545d5ecaSDag-Erling Smørgrav 	int min, want, max;
646545d5ecaSDag-Erling Smørgrav 
647545d5ecaSDag-Erling Smørgrav 	min = buffer_get_int(m);
648545d5ecaSDag-Erling Smørgrav 	want = buffer_get_int(m);
649545d5ecaSDag-Erling Smørgrav 	max = buffer_get_int(m);
650545d5ecaSDag-Erling Smørgrav 
651545d5ecaSDag-Erling Smørgrav 	debug3("%s: got parameters: %d %d %d",
652545d5ecaSDag-Erling Smørgrav 	    __func__, min, want, max);
653545d5ecaSDag-Erling Smørgrav 	/* We need to check here, too, in case the child got corrupted */
654545d5ecaSDag-Erling Smørgrav 	if (max < min || want < min || max < want)
655545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad parameters: %d %d %d",
656545d5ecaSDag-Erling Smørgrav 		    __func__, min, want, max);
657545d5ecaSDag-Erling Smørgrav 
658545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
659545d5ecaSDag-Erling Smørgrav 
660545d5ecaSDag-Erling Smørgrav 	dh = choose_dh(min, want, max);
661545d5ecaSDag-Erling Smørgrav 	if (dh == NULL) {
662545d5ecaSDag-Erling Smørgrav 		buffer_put_char(m, 0);
663545d5ecaSDag-Erling Smørgrav 		return (0);
664545d5ecaSDag-Erling Smørgrav 	} else {
665545d5ecaSDag-Erling Smørgrav 		/* Send first bignum */
666545d5ecaSDag-Erling Smørgrav 		buffer_put_char(m, 1);
667545d5ecaSDag-Erling Smørgrav 		buffer_put_bignum2(m, dh->p);
668545d5ecaSDag-Erling Smørgrav 		buffer_put_bignum2(m, dh->g);
669545d5ecaSDag-Erling Smørgrav 
670545d5ecaSDag-Erling Smørgrav 		DH_free(dh);
671545d5ecaSDag-Erling Smørgrav 	}
67221e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_MODULI, m);
673545d5ecaSDag-Erling Smørgrav 	return (0);
674545d5ecaSDag-Erling Smørgrav }
675545d5ecaSDag-Erling Smørgrav 
676545d5ecaSDag-Erling Smørgrav int
67721e764dfSDag-Erling Smørgrav mm_answer_sign(int sock, Buffer *m)
678545d5ecaSDag-Erling Smørgrav {
679545d5ecaSDag-Erling Smørgrav 	Key *key;
680545d5ecaSDag-Erling Smørgrav 	u_char *p;
681545d5ecaSDag-Erling Smørgrav 	u_char *signature;
682545d5ecaSDag-Erling Smørgrav 	u_int siglen, datlen;
683545d5ecaSDag-Erling Smørgrav 	int keyid;
684545d5ecaSDag-Erling Smørgrav 
685545d5ecaSDag-Erling Smørgrav 	debug3("%s", __func__);
686545d5ecaSDag-Erling Smørgrav 
687545d5ecaSDag-Erling Smørgrav 	keyid = buffer_get_int(m);
688545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(m, &datlen);
689545d5ecaSDag-Erling Smørgrav 
690333ee039SDag-Erling Smørgrav 	/*
6914a421b63SDag-Erling Smørgrav 	 * Supported KEX types use SHA1 (20 bytes), SHA256 (32 bytes),
6924a421b63SDag-Erling Smørgrav 	 * SHA384 (48 bytes) and SHA512 (64 bytes).
693333ee039SDag-Erling Smørgrav 	 */
6944a421b63SDag-Erling Smørgrav 	if (datlen != 20 && datlen != 32 && datlen != 48 && datlen != 64)
695f388f5efSDag-Erling Smørgrav 		fatal("%s: data length incorrect: %u", __func__, datlen);
696545d5ecaSDag-Erling Smørgrav 
697545d5ecaSDag-Erling Smørgrav 	/* save session id, it will be passed on the first call */
698545d5ecaSDag-Erling Smørgrav 	if (session_id2_len == 0) {
699545d5ecaSDag-Erling Smørgrav 		session_id2_len = datlen;
700545d5ecaSDag-Erling Smørgrav 		session_id2 = xmalloc(session_id2_len);
701545d5ecaSDag-Erling Smørgrav 		memcpy(session_id2, p, session_id2_len);
702545d5ecaSDag-Erling Smørgrav 	}
703545d5ecaSDag-Erling Smørgrav 
704545d5ecaSDag-Erling Smørgrav 	if ((key = get_hostkey_by_index(keyid)) == NULL)
705545d5ecaSDag-Erling Smørgrav 		fatal("%s: no hostkey from index %d", __func__, keyid);
706545d5ecaSDag-Erling Smørgrav 	if (key_sign(key, &signature, &siglen, p, datlen) < 0)
707545d5ecaSDag-Erling Smørgrav 		fatal("%s: key_sign failed", __func__);
708545d5ecaSDag-Erling Smørgrav 
709f388f5efSDag-Erling Smørgrav 	debug3("%s: signature %p(%u)", __func__, signature, siglen);
710545d5ecaSDag-Erling Smørgrav 
711545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
712545d5ecaSDag-Erling Smørgrav 	buffer_put_string(m, signature, siglen);
713545d5ecaSDag-Erling Smørgrav 
714545d5ecaSDag-Erling Smørgrav 	xfree(p);
715545d5ecaSDag-Erling Smørgrav 	xfree(signature);
716545d5ecaSDag-Erling Smørgrav 
71721e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_SIGN, m);
718545d5ecaSDag-Erling Smørgrav 
719545d5ecaSDag-Erling Smørgrav 	/* Turn on permissions for getpwnam */
720545d5ecaSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_PWNAM, 1);
721545d5ecaSDag-Erling Smørgrav 
722545d5ecaSDag-Erling Smørgrav 	return (0);
723545d5ecaSDag-Erling Smørgrav }
724545d5ecaSDag-Erling Smørgrav 
725545d5ecaSDag-Erling Smørgrav /* Retrieves the password entry and also checks if the user is permitted */
726545d5ecaSDag-Erling Smørgrav 
727545d5ecaSDag-Erling Smørgrav int
72821e764dfSDag-Erling Smørgrav mm_answer_pwnamallow(int sock, Buffer *m)
729545d5ecaSDag-Erling Smørgrav {
73021e764dfSDag-Erling Smørgrav 	char *username;
731545d5ecaSDag-Erling Smørgrav 	struct passwd *pwent;
732545d5ecaSDag-Erling Smørgrav 	int allowed = 0;
733*e146993eSDag-Erling Smørgrav 	u_int i;
734545d5ecaSDag-Erling Smørgrav 
735545d5ecaSDag-Erling Smørgrav 	debug3("%s", __func__);
736545d5ecaSDag-Erling Smørgrav 
737545d5ecaSDag-Erling Smørgrav 	if (authctxt->attempt++ != 0)
738545d5ecaSDag-Erling Smørgrav 		fatal("%s: multiple attempts for getpwnam", __func__);
739545d5ecaSDag-Erling Smørgrav 
74021e764dfSDag-Erling Smørgrav 	username = buffer_get_string(m, NULL);
741545d5ecaSDag-Erling Smørgrav 
74221e764dfSDag-Erling Smørgrav 	pwent = getpwnamallow(username);
743545d5ecaSDag-Erling Smørgrav 
74421e764dfSDag-Erling Smørgrav 	authctxt->user = xstrdup(username);
74521e764dfSDag-Erling Smørgrav 	setproctitle("%s [priv]", pwent ? username : "unknown");
74621e764dfSDag-Erling Smørgrav 	xfree(username);
747545d5ecaSDag-Erling Smørgrav 
748545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
749545d5ecaSDag-Erling Smørgrav 
750545d5ecaSDag-Erling Smørgrav 	if (pwent == NULL) {
751545d5ecaSDag-Erling Smørgrav 		buffer_put_char(m, 0);
7521ec0d754SDag-Erling Smørgrav 		authctxt->pw = fakepw();
753545d5ecaSDag-Erling Smørgrav 		goto out;
754545d5ecaSDag-Erling Smørgrav 	}
755545d5ecaSDag-Erling Smørgrav 
756545d5ecaSDag-Erling Smørgrav 	allowed = 1;
757545d5ecaSDag-Erling Smørgrav 	authctxt->pw = pwent;
758545d5ecaSDag-Erling Smørgrav 	authctxt->valid = 1;
759545d5ecaSDag-Erling Smørgrav 
760545d5ecaSDag-Erling Smørgrav 	buffer_put_char(m, 1);
761545d5ecaSDag-Erling Smørgrav 	buffer_put_string(m, pwent, sizeof(struct passwd));
762545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, pwent->pw_name);
763545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, "*");
764545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, pwent->pw_gecos);
765989dd127SDag-Erling Smørgrav #ifdef HAVE_PW_CLASS_IN_PASSWD
766545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, pwent->pw_class);
767989dd127SDag-Erling Smørgrav #endif
768545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, pwent->pw_dir);
769545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, pwent->pw_shell);
770545d5ecaSDag-Erling Smørgrav 
771545d5ecaSDag-Erling Smørgrav  out:
772d4af9e69SDag-Erling Smørgrav 	buffer_put_string(m, &options, sizeof(options));
773*e146993eSDag-Erling Smørgrav 
774*e146993eSDag-Erling Smørgrav #define M_CP_STROPT(x) do { \
775*e146993eSDag-Erling Smørgrav 		if (options.x != NULL) \
776*e146993eSDag-Erling Smørgrav 			buffer_put_cstring(m, options.x); \
777*e146993eSDag-Erling Smørgrav 	} while (0)
778*e146993eSDag-Erling Smørgrav #define M_CP_STRARRAYOPT(x, nx) do { \
779*e146993eSDag-Erling Smørgrav 		for (i = 0; i < options.nx; i++) \
780*e146993eSDag-Erling Smørgrav 			buffer_put_cstring(m, options.x[i]); \
781*e146993eSDag-Erling Smørgrav 	} while (0)
782*e146993eSDag-Erling Smørgrav 	/* See comment in servconf.h */
783*e146993eSDag-Erling Smørgrav 	COPY_MATCH_STRING_OPTS();
784*e146993eSDag-Erling Smørgrav #undef M_CP_STROPT
785*e146993eSDag-Erling Smørgrav #undef M_CP_STRARRAYOPT
786*e146993eSDag-Erling Smørgrav 
787545d5ecaSDag-Erling Smørgrav 	debug3("%s: sending MONITOR_ANS_PWNAM: %d", __func__, allowed);
78821e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PWNAM, m);
789545d5ecaSDag-Erling Smørgrav 
790545d5ecaSDag-Erling Smørgrav 	/* For SSHv1 allow authentication now */
791545d5ecaSDag-Erling Smørgrav 	if (!compat20)
792545d5ecaSDag-Erling Smørgrav 		monitor_permit_authentications(1);
793545d5ecaSDag-Erling Smørgrav 	else {
794545d5ecaSDag-Erling Smørgrav 		/* Allow service/style information on the auth context */
795545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_AUTHSERV, 1);
796545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_AUTH2_READ_BANNER, 1);
797545d5ecaSDag-Erling Smørgrav 	}
798989dd127SDag-Erling Smørgrav #ifdef USE_PAM
799cf2b5f3bSDag-Erling Smørgrav 	if (options.use_pam)
800989dd127SDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_PAM_START, 1);
801989dd127SDag-Erling Smørgrav #endif
802545d5ecaSDag-Erling Smørgrav 
803545d5ecaSDag-Erling Smørgrav 	return (0);
804545d5ecaSDag-Erling Smørgrav }
805545d5ecaSDag-Erling Smørgrav 
80621e764dfSDag-Erling Smørgrav int mm_answer_auth2_read_banner(int sock, Buffer *m)
807545d5ecaSDag-Erling Smørgrav {
808545d5ecaSDag-Erling Smørgrav 	char *banner;
809545d5ecaSDag-Erling Smørgrav 
810545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
811545d5ecaSDag-Erling Smørgrav 	banner = auth2_read_banner();
812545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, banner != NULL ? banner : "");
81321e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_AUTH2_READ_BANNER, m);
814545d5ecaSDag-Erling Smørgrav 
815545d5ecaSDag-Erling Smørgrav 	if (banner != NULL)
816f388f5efSDag-Erling Smørgrav 		xfree(banner);
817545d5ecaSDag-Erling Smørgrav 
818545d5ecaSDag-Erling Smørgrav 	return (0);
819545d5ecaSDag-Erling Smørgrav }
820545d5ecaSDag-Erling Smørgrav 
821545d5ecaSDag-Erling Smørgrav int
82221e764dfSDag-Erling Smørgrav mm_answer_authserv(int sock, Buffer *m)
823545d5ecaSDag-Erling Smørgrav {
824545d5ecaSDag-Erling Smørgrav 	monitor_permit_authentications(1);
825545d5ecaSDag-Erling Smørgrav 
826545d5ecaSDag-Erling Smørgrav 	authctxt->service = buffer_get_string(m, NULL);
827545d5ecaSDag-Erling Smørgrav 	authctxt->style = buffer_get_string(m, NULL);
828545d5ecaSDag-Erling Smørgrav 	debug3("%s: service=%s, style=%s",
829545d5ecaSDag-Erling Smørgrav 	    __func__, authctxt->service, authctxt->style);
830545d5ecaSDag-Erling Smørgrav 
831545d5ecaSDag-Erling Smørgrav 	if (strlen(authctxt->style) == 0) {
832545d5ecaSDag-Erling Smørgrav 		xfree(authctxt->style);
833545d5ecaSDag-Erling Smørgrav 		authctxt->style = NULL;
834545d5ecaSDag-Erling Smørgrav 	}
835545d5ecaSDag-Erling Smørgrav 
836545d5ecaSDag-Erling Smørgrav 	return (0);
837545d5ecaSDag-Erling Smørgrav }
838545d5ecaSDag-Erling Smørgrav 
839545d5ecaSDag-Erling Smørgrav int
84021e764dfSDag-Erling Smørgrav mm_answer_authpassword(int sock, Buffer *m)
841545d5ecaSDag-Erling Smørgrav {
842545d5ecaSDag-Erling Smørgrav 	static int call_count;
843545d5ecaSDag-Erling Smørgrav 	char *passwd;
844f388f5efSDag-Erling Smørgrav 	int authenticated;
845f388f5efSDag-Erling Smørgrav 	u_int plen;
846545d5ecaSDag-Erling Smørgrav 
847545d5ecaSDag-Erling Smørgrav 	passwd = buffer_get_string(m, &plen);
848545d5ecaSDag-Erling Smørgrav 	/* Only authenticate if the context is valid */
849545d5ecaSDag-Erling Smørgrav 	authenticated = options.password_authentication &&
850cf2b5f3bSDag-Erling Smørgrav 	    auth_password(authctxt, passwd);
851545d5ecaSDag-Erling Smørgrav 	memset(passwd, 0, strlen(passwd));
852545d5ecaSDag-Erling Smørgrav 	xfree(passwd);
853545d5ecaSDag-Erling Smørgrav 
854545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
855545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, authenticated);
856545d5ecaSDag-Erling Smørgrav 
857545d5ecaSDag-Erling Smørgrav 	debug3("%s: sending result %d", __func__, authenticated);
85821e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_AUTHPASSWORD, m);
859545d5ecaSDag-Erling Smørgrav 
860545d5ecaSDag-Erling Smørgrav 	call_count++;
861545d5ecaSDag-Erling Smørgrav 	if (plen == 0 && call_count == 1)
862545d5ecaSDag-Erling Smørgrav 		auth_method = "none";
863545d5ecaSDag-Erling Smørgrav 	else
864545d5ecaSDag-Erling Smørgrav 		auth_method = "password";
865545d5ecaSDag-Erling Smørgrav 
866545d5ecaSDag-Erling Smørgrav 	/* Causes monitor loop to terminate if authenticated */
867545d5ecaSDag-Erling Smørgrav 	return (authenticated);
868545d5ecaSDag-Erling Smørgrav }
869545d5ecaSDag-Erling Smørgrav 
870545d5ecaSDag-Erling Smørgrav #ifdef BSD_AUTH
871545d5ecaSDag-Erling Smørgrav int
87221e764dfSDag-Erling Smørgrav mm_answer_bsdauthquery(int sock, Buffer *m)
873545d5ecaSDag-Erling Smørgrav {
874545d5ecaSDag-Erling Smørgrav 	char *name, *infotxt;
875545d5ecaSDag-Erling Smørgrav 	u_int numprompts;
876545d5ecaSDag-Erling Smørgrav 	u_int *echo_on;
877545d5ecaSDag-Erling Smørgrav 	char **prompts;
878e73e9afaSDag-Erling Smørgrav 	u_int success;
879545d5ecaSDag-Erling Smørgrav 
880e73e9afaSDag-Erling Smørgrav 	success = bsdauth_query(authctxt, &name, &infotxt, &numprompts,
881e73e9afaSDag-Erling Smørgrav 	    &prompts, &echo_on) < 0 ? 0 : 1;
882545d5ecaSDag-Erling Smørgrav 
883545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
884e73e9afaSDag-Erling Smørgrav 	buffer_put_int(m, success);
885e73e9afaSDag-Erling Smørgrav 	if (success)
886545d5ecaSDag-Erling Smørgrav 		buffer_put_cstring(m, prompts[0]);
887545d5ecaSDag-Erling Smørgrav 
888e73e9afaSDag-Erling Smørgrav 	debug3("%s: sending challenge success: %u", __func__, success);
88921e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_BSDAUTHQUERY, m);
890545d5ecaSDag-Erling Smørgrav 
891e73e9afaSDag-Erling Smørgrav 	if (success) {
892545d5ecaSDag-Erling Smørgrav 		xfree(name);
893545d5ecaSDag-Erling Smørgrav 		xfree(infotxt);
894545d5ecaSDag-Erling Smørgrav 		xfree(prompts);
895545d5ecaSDag-Erling Smørgrav 		xfree(echo_on);
896545d5ecaSDag-Erling Smørgrav 	}
897545d5ecaSDag-Erling Smørgrav 
898545d5ecaSDag-Erling Smørgrav 	return (0);
899545d5ecaSDag-Erling Smørgrav }
900545d5ecaSDag-Erling Smørgrav 
901545d5ecaSDag-Erling Smørgrav int
90221e764dfSDag-Erling Smørgrav mm_answer_bsdauthrespond(int sock, Buffer *m)
903545d5ecaSDag-Erling Smørgrav {
904545d5ecaSDag-Erling Smørgrav 	char *response;
905545d5ecaSDag-Erling Smørgrav 	int authok;
906545d5ecaSDag-Erling Smørgrav 
907545d5ecaSDag-Erling Smørgrav 	if (authctxt->as == 0)
908545d5ecaSDag-Erling Smørgrav 		fatal("%s: no bsd auth session", __func__);
909545d5ecaSDag-Erling Smørgrav 
910545d5ecaSDag-Erling Smørgrav 	response = buffer_get_string(m, NULL);
911545d5ecaSDag-Erling Smørgrav 	authok = options.challenge_response_authentication &&
912545d5ecaSDag-Erling Smørgrav 	    auth_userresponse(authctxt->as, response, 0);
913545d5ecaSDag-Erling Smørgrav 	authctxt->as = NULL;
914545d5ecaSDag-Erling Smørgrav 	debug3("%s: <%s> = <%d>", __func__, response, authok);
915545d5ecaSDag-Erling Smørgrav 	xfree(response);
916545d5ecaSDag-Erling Smørgrav 
917545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
918545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, authok);
919545d5ecaSDag-Erling Smørgrav 
920545d5ecaSDag-Erling Smørgrav 	debug3("%s: sending authenticated: %d", __func__, authok);
92121e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_BSDAUTHRESPOND, m);
922545d5ecaSDag-Erling Smørgrav 
923545d5ecaSDag-Erling Smørgrav 	auth_method = "bsdauth";
924545d5ecaSDag-Erling Smørgrav 
925545d5ecaSDag-Erling Smørgrav 	return (authok != 0);
926545d5ecaSDag-Erling Smørgrav }
927545d5ecaSDag-Erling Smørgrav #endif
928545d5ecaSDag-Erling Smørgrav 
929545d5ecaSDag-Erling Smørgrav #ifdef SKEY
930545d5ecaSDag-Erling Smørgrav int
93121e764dfSDag-Erling Smørgrav mm_answer_skeyquery(int sock, Buffer *m)
932545d5ecaSDag-Erling Smørgrav {
933989dd127SDag-Erling Smørgrav 	struct skey skey;
934545d5ecaSDag-Erling Smørgrav 	char challenge[1024];
935e73e9afaSDag-Erling Smørgrav 	u_int success;
936545d5ecaSDag-Erling Smørgrav 
9375962c0e9SDag-Erling Smørgrav 	success = _compat_skeychallenge(&skey, authctxt->user, challenge,
9385962c0e9SDag-Erling Smørgrav 	    sizeof(challenge)) < 0 ? 0 : 1;
939545d5ecaSDag-Erling Smørgrav 
940545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
941e73e9afaSDag-Erling Smørgrav 	buffer_put_int(m, success);
942e73e9afaSDag-Erling Smørgrav 	if (success)
943545d5ecaSDag-Erling Smørgrav 		buffer_put_cstring(m, challenge);
944545d5ecaSDag-Erling Smørgrav 
945e73e9afaSDag-Erling Smørgrav 	debug3("%s: sending challenge success: %u", __func__, success);
94621e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_SKEYQUERY, m);
947545d5ecaSDag-Erling Smørgrav 
948545d5ecaSDag-Erling Smørgrav 	return (0);
949545d5ecaSDag-Erling Smørgrav }
950545d5ecaSDag-Erling Smørgrav 
951545d5ecaSDag-Erling Smørgrav int
95221e764dfSDag-Erling Smørgrav mm_answer_skeyrespond(int sock, Buffer *m)
953545d5ecaSDag-Erling Smørgrav {
954545d5ecaSDag-Erling Smørgrav 	char *response;
955545d5ecaSDag-Erling Smørgrav 	int authok;
956545d5ecaSDag-Erling Smørgrav 
957545d5ecaSDag-Erling Smørgrav 	response = buffer_get_string(m, NULL);
958545d5ecaSDag-Erling Smørgrav 
959545d5ecaSDag-Erling Smørgrav 	authok = (options.challenge_response_authentication &&
960545d5ecaSDag-Erling Smørgrav 	    authctxt->valid &&
961989dd127SDag-Erling Smørgrav 	    skey_haskey(authctxt->pw->pw_name) == 0 &&
962989dd127SDag-Erling Smørgrav 	    skey_passcheck(authctxt->pw->pw_name, response) != -1);
963545d5ecaSDag-Erling Smørgrav 
964545d5ecaSDag-Erling Smørgrav 	xfree(response);
965545d5ecaSDag-Erling Smørgrav 
966545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
967545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, authok);
968545d5ecaSDag-Erling Smørgrav 
969545d5ecaSDag-Erling Smørgrav 	debug3("%s: sending authenticated: %d", __func__, authok);
97021e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_SKEYRESPOND, m);
971545d5ecaSDag-Erling Smørgrav 
972545d5ecaSDag-Erling Smørgrav 	auth_method = "skey";
973545d5ecaSDag-Erling Smørgrav 
974545d5ecaSDag-Erling Smørgrav 	return (authok != 0);
975545d5ecaSDag-Erling Smørgrav }
976545d5ecaSDag-Erling Smørgrav #endif
977545d5ecaSDag-Erling Smørgrav 
978989dd127SDag-Erling Smørgrav #ifdef USE_PAM
979989dd127SDag-Erling Smørgrav int
98021e764dfSDag-Erling Smørgrav mm_answer_pam_start(int sock, Buffer *m)
981989dd127SDag-Erling Smørgrav {
982cf2b5f3bSDag-Erling Smørgrav 	if (!options.use_pam)
983cf2b5f3bSDag-Erling Smørgrav 		fatal("UsePAM not set, but ended up in %s anyway", __func__);
984cf2b5f3bSDag-Erling Smørgrav 
9855962c0e9SDag-Erling Smørgrav 	start_pam(authctxt);
986989dd127SDag-Erling Smørgrav 
987cf2b5f3bSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_PAM_ACCOUNT, 1);
988cf2b5f3bSDag-Erling Smørgrav 
989989dd127SDag-Erling Smørgrav 	return (0);
990989dd127SDag-Erling Smørgrav }
991382d19eeSDag-Erling Smørgrav 
992cf2b5f3bSDag-Erling Smørgrav int
99321e764dfSDag-Erling Smørgrav mm_answer_pam_account(int sock, Buffer *m)
994cf2b5f3bSDag-Erling Smørgrav {
995cf2b5f3bSDag-Erling Smørgrav 	u_int ret;
996cf2b5f3bSDag-Erling Smørgrav 
997cf2b5f3bSDag-Erling Smørgrav 	if (!options.use_pam)
998cf2b5f3bSDag-Erling Smørgrav 		fatal("UsePAM not set, but ended up in %s anyway", __func__);
999cf2b5f3bSDag-Erling Smørgrav 
1000cf2b5f3bSDag-Erling Smørgrav 	ret = do_pam_account();
1001cf2b5f3bSDag-Erling Smørgrav 
1002cf2b5f3bSDag-Erling Smørgrav 	buffer_put_int(m, ret);
1003b74df5b2SDag-Erling Smørgrav 	buffer_put_string(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg));
1004cf2b5f3bSDag-Erling Smørgrav 
100521e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PAM_ACCOUNT, m);
1006cf2b5f3bSDag-Erling Smørgrav 
1007cf2b5f3bSDag-Erling Smørgrav 	return (ret);
1008cf2b5f3bSDag-Erling Smørgrav }
1009cf2b5f3bSDag-Erling Smørgrav 
1010cf2b5f3bSDag-Erling Smørgrav static void *sshpam_ctxt, *sshpam_authok;
1011cf2b5f3bSDag-Erling Smørgrav extern KbdintDevice sshpam_device;
1012382d19eeSDag-Erling Smørgrav 
1013382d19eeSDag-Erling Smørgrav int
101421e764dfSDag-Erling Smørgrav mm_answer_pam_init_ctx(int sock, Buffer *m)
1015382d19eeSDag-Erling Smørgrav {
1016382d19eeSDag-Erling Smørgrav 
1017382d19eeSDag-Erling Smørgrav 	debug3("%s", __func__);
1018382d19eeSDag-Erling Smørgrav 	authctxt->user = buffer_get_string(m, NULL);
1019cf2b5f3bSDag-Erling Smørgrav 	sshpam_ctxt = (sshpam_device.init_ctx)(authctxt);
1020cf2b5f3bSDag-Erling Smørgrav 	sshpam_authok = NULL;
1021382d19eeSDag-Erling Smørgrav 	buffer_clear(m);
1022cf2b5f3bSDag-Erling Smørgrav 	if (sshpam_ctxt != NULL) {
1023382d19eeSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_PAM_FREE_CTX, 1);
1024382d19eeSDag-Erling Smørgrav 		buffer_put_int(m, 1);
1025382d19eeSDag-Erling Smørgrav 	} else {
1026382d19eeSDag-Erling Smørgrav 		buffer_put_int(m, 0);
1027382d19eeSDag-Erling Smørgrav 	}
102821e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PAM_INIT_CTX, m);
1029382d19eeSDag-Erling Smørgrav 	return (0);
1030382d19eeSDag-Erling Smørgrav }
1031382d19eeSDag-Erling Smørgrav 
1032382d19eeSDag-Erling Smørgrav int
103321e764dfSDag-Erling Smørgrav mm_answer_pam_query(int sock, Buffer *m)
1034382d19eeSDag-Erling Smørgrav {
1035e2f6069cSDag-Erling Smørgrav 	char *name = NULL, *info = NULL, **prompts = NULL;
1036e2f6069cSDag-Erling Smørgrav 	u_int i, num = 0, *echo_on = 0;
1037d4ecd108SDag-Erling Smørgrav 	int ret;
1038382d19eeSDag-Erling Smørgrav 
1039382d19eeSDag-Erling Smørgrav 	debug3("%s", __func__);
1040cf2b5f3bSDag-Erling Smørgrav 	sshpam_authok = NULL;
1041cf2b5f3bSDag-Erling Smørgrav 	ret = (sshpam_device.query)(sshpam_ctxt, &name, &info, &num, &prompts, &echo_on);
104207fd326cSDag-Erling Smørgrav 	if (ret == 0 && num == 0)
1043cf2b5f3bSDag-Erling Smørgrav 		sshpam_authok = sshpam_ctxt;
1044382d19eeSDag-Erling Smørgrav 	if (num > 1 || name == NULL || info == NULL)
1045382d19eeSDag-Erling Smørgrav 		ret = -1;
1046645ca8e8SDag-Erling Smørgrav 	buffer_clear(m);
1047382d19eeSDag-Erling Smørgrav 	buffer_put_int(m, ret);
1048382d19eeSDag-Erling Smørgrav 	buffer_put_cstring(m, name);
1049382d19eeSDag-Erling Smørgrav 	xfree(name);
1050382d19eeSDag-Erling Smørgrav 	buffer_put_cstring(m, info);
1051382d19eeSDag-Erling Smørgrav 	xfree(info);
1052382d19eeSDag-Erling Smørgrav 	buffer_put_int(m, num);
1053382d19eeSDag-Erling Smørgrav 	for (i = 0; i < num; ++i) {
1054382d19eeSDag-Erling Smørgrav 		buffer_put_cstring(m, prompts[i]);
1055382d19eeSDag-Erling Smørgrav 		xfree(prompts[i]);
1056382d19eeSDag-Erling Smørgrav 		buffer_put_int(m, echo_on[i]);
1057382d19eeSDag-Erling Smørgrav 	}
1058382d19eeSDag-Erling Smørgrav 	if (prompts != NULL)
1059382d19eeSDag-Erling Smørgrav 		xfree(prompts);
1060382d19eeSDag-Erling Smørgrav 	if (echo_on != NULL)
1061382d19eeSDag-Erling Smørgrav 		xfree(echo_on);
1062333ee039SDag-Erling Smørgrav 	auth_method = "keyboard-interactive/pam";
106321e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PAM_QUERY, m);
1064382d19eeSDag-Erling Smørgrav 	return (0);
1065382d19eeSDag-Erling Smørgrav }
1066382d19eeSDag-Erling Smørgrav 
1067382d19eeSDag-Erling Smørgrav int
106821e764dfSDag-Erling Smørgrav mm_answer_pam_respond(int sock, Buffer *m)
1069382d19eeSDag-Erling Smørgrav {
1070382d19eeSDag-Erling Smørgrav 	char **resp;
1071d4ecd108SDag-Erling Smørgrav 	u_int i, num;
1072d4ecd108SDag-Erling Smørgrav 	int ret;
1073382d19eeSDag-Erling Smørgrav 
1074382d19eeSDag-Erling Smørgrav 	debug3("%s", __func__);
1075cf2b5f3bSDag-Erling Smørgrav 	sshpam_authok = NULL;
1076382d19eeSDag-Erling Smørgrav 	num = buffer_get_int(m);
1077382d19eeSDag-Erling Smørgrav 	if (num > 0) {
1078333ee039SDag-Erling Smørgrav 		resp = xcalloc(num, sizeof(char *));
1079382d19eeSDag-Erling Smørgrav 		for (i = 0; i < num; ++i)
1080382d19eeSDag-Erling Smørgrav 			resp[i] = buffer_get_string(m, NULL);
1081cf2b5f3bSDag-Erling Smørgrav 		ret = (sshpam_device.respond)(sshpam_ctxt, num, resp);
1082382d19eeSDag-Erling Smørgrav 		for (i = 0; i < num; ++i)
1083382d19eeSDag-Erling Smørgrav 			xfree(resp[i]);
1084382d19eeSDag-Erling Smørgrav 		xfree(resp);
1085382d19eeSDag-Erling Smørgrav 	} else {
1086cf2b5f3bSDag-Erling Smørgrav 		ret = (sshpam_device.respond)(sshpam_ctxt, num, NULL);
1087382d19eeSDag-Erling Smørgrav 	}
1088382d19eeSDag-Erling Smørgrav 	buffer_clear(m);
1089382d19eeSDag-Erling Smørgrav 	buffer_put_int(m, ret);
109021e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PAM_RESPOND, m);
1091382d19eeSDag-Erling Smørgrav 	auth_method = "keyboard-interactive/pam";
1092382d19eeSDag-Erling Smørgrav 	if (ret == 0)
1093cf2b5f3bSDag-Erling Smørgrav 		sshpam_authok = sshpam_ctxt;
1094669e440eSDag-Erling Smørgrav 	return (0);
1095382d19eeSDag-Erling Smørgrav }
1096382d19eeSDag-Erling Smørgrav 
1097382d19eeSDag-Erling Smørgrav int
109821e764dfSDag-Erling Smørgrav mm_answer_pam_free_ctx(int sock, Buffer *m)
1099382d19eeSDag-Erling Smørgrav {
1100382d19eeSDag-Erling Smørgrav 
1101382d19eeSDag-Erling Smørgrav 	debug3("%s", __func__);
1102cf2b5f3bSDag-Erling Smørgrav 	(sshpam_device.free_ctx)(sshpam_ctxt);
1103382d19eeSDag-Erling Smørgrav 	buffer_clear(m);
110421e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PAM_FREE_CTX, m);
1105333ee039SDag-Erling Smørgrav 	auth_method = "keyboard-interactive/pam";
1106cf2b5f3bSDag-Erling Smørgrav 	return (sshpam_authok == sshpam_ctxt);
1107382d19eeSDag-Erling Smørgrav }
1108989dd127SDag-Erling Smørgrav #endif
1109989dd127SDag-Erling Smørgrav 
1110545d5ecaSDag-Erling Smørgrav int
111121e764dfSDag-Erling Smørgrav mm_answer_keyallowed(int sock, Buffer *m)
1112545d5ecaSDag-Erling Smørgrav {
1113545d5ecaSDag-Erling Smørgrav 	Key *key;
1114f388f5efSDag-Erling Smørgrav 	char *cuser, *chost;
1115f388f5efSDag-Erling Smørgrav 	u_char *blob;
1116545d5ecaSDag-Erling Smørgrav 	u_int bloblen;
1117545d5ecaSDag-Erling Smørgrav 	enum mm_keytype type = 0;
1118545d5ecaSDag-Erling Smørgrav 	int allowed = 0;
1119545d5ecaSDag-Erling Smørgrav 
1120545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1121545d5ecaSDag-Erling Smørgrav 
1122545d5ecaSDag-Erling Smørgrav 	type = buffer_get_int(m);
1123545d5ecaSDag-Erling Smørgrav 	cuser = buffer_get_string(m, NULL);
1124545d5ecaSDag-Erling Smørgrav 	chost = buffer_get_string(m, NULL);
1125545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(m, &bloblen);
1126545d5ecaSDag-Erling Smørgrav 
1127545d5ecaSDag-Erling Smørgrav 	key = key_from_blob(blob, bloblen);
1128545d5ecaSDag-Erling Smørgrav 
1129545d5ecaSDag-Erling Smørgrav 	if ((compat20 && type == MM_RSAHOSTKEY) ||
1130545d5ecaSDag-Erling Smørgrav 	    (!compat20 && type != MM_RSAHOSTKEY))
1131545d5ecaSDag-Erling Smørgrav 		fatal("%s: key type and protocol mismatch", __func__);
1132545d5ecaSDag-Erling Smørgrav 
1133545d5ecaSDag-Erling Smørgrav 	debug3("%s: key_from_blob: %p", __func__, key);
1134545d5ecaSDag-Erling Smørgrav 
11351ec0d754SDag-Erling Smørgrav 	if (key != NULL && authctxt->valid) {
1136545d5ecaSDag-Erling Smørgrav 		switch (type) {
1137545d5ecaSDag-Erling Smørgrav 		case MM_USERKEY:
1138545d5ecaSDag-Erling Smørgrav 			allowed = options.pubkey_authentication &&
1139545d5ecaSDag-Erling Smørgrav 			    user_key_allowed(authctxt->pw, key);
1140333ee039SDag-Erling Smørgrav 			auth_method = "publickey";
1141d4af9e69SDag-Erling Smørgrav 			if (options.pubkey_authentication && allowed != 1)
1142d4af9e69SDag-Erling Smørgrav 				auth_clear_options();
1143545d5ecaSDag-Erling Smørgrav 			break;
1144545d5ecaSDag-Erling Smørgrav 		case MM_HOSTKEY:
1145545d5ecaSDag-Erling Smørgrav 			allowed = options.hostbased_authentication &&
1146545d5ecaSDag-Erling Smørgrav 			    hostbased_key_allowed(authctxt->pw,
1147545d5ecaSDag-Erling Smørgrav 			    cuser, chost, key);
1148333ee039SDag-Erling Smørgrav 			auth_method = "hostbased";
1149545d5ecaSDag-Erling Smørgrav 			break;
1150545d5ecaSDag-Erling Smørgrav 		case MM_RSAHOSTKEY:
1151545d5ecaSDag-Erling Smørgrav 			key->type = KEY_RSA1; /* XXX */
1152545d5ecaSDag-Erling Smørgrav 			allowed = options.rhosts_rsa_authentication &&
1153545d5ecaSDag-Erling Smørgrav 			    auth_rhosts_rsa_key_allowed(authctxt->pw,
1154545d5ecaSDag-Erling Smørgrav 			    cuser, chost, key);
1155d4af9e69SDag-Erling Smørgrav 			if (options.rhosts_rsa_authentication && allowed != 1)
1156d4af9e69SDag-Erling Smørgrav 				auth_clear_options();
1157333ee039SDag-Erling Smørgrav 			auth_method = "rsa";
1158545d5ecaSDag-Erling Smørgrav 			break;
1159545d5ecaSDag-Erling Smørgrav 		default:
1160545d5ecaSDag-Erling Smørgrav 			fatal("%s: unknown key type %d", __func__, type);
1161545d5ecaSDag-Erling Smørgrav 			break;
1162545d5ecaSDag-Erling Smørgrav 		}
1163545d5ecaSDag-Erling Smørgrav 	}
1164e73e9afaSDag-Erling Smørgrav 	if (key != NULL)
1165e73e9afaSDag-Erling Smørgrav 		key_free(key);
1166545d5ecaSDag-Erling Smørgrav 
1167545d5ecaSDag-Erling Smørgrav 	/* clear temporarily storage (used by verify) */
1168545d5ecaSDag-Erling Smørgrav 	monitor_reset_key_state();
1169545d5ecaSDag-Erling Smørgrav 
1170545d5ecaSDag-Erling Smørgrav 	if (allowed) {
1171545d5ecaSDag-Erling Smørgrav 		/* Save temporarily for comparison in verify */
1172545d5ecaSDag-Erling Smørgrav 		key_blob = blob;
1173545d5ecaSDag-Erling Smørgrav 		key_bloblen = bloblen;
1174545d5ecaSDag-Erling Smørgrav 		key_blobtype = type;
1175545d5ecaSDag-Erling Smørgrav 		hostbased_cuser = cuser;
1176545d5ecaSDag-Erling Smørgrav 		hostbased_chost = chost;
1177333ee039SDag-Erling Smørgrav 	} else {
1178333ee039SDag-Erling Smørgrav 		/* Log failed attempt */
1179333ee039SDag-Erling Smørgrav 		auth_log(authctxt, 0, auth_method, compat20 ? " ssh2" : "");
1180333ee039SDag-Erling Smørgrav 		xfree(blob);
1181333ee039SDag-Erling Smørgrav 		xfree(cuser);
1182333ee039SDag-Erling Smørgrav 		xfree(chost);
1183545d5ecaSDag-Erling Smørgrav 	}
1184545d5ecaSDag-Erling Smørgrav 
1185545d5ecaSDag-Erling Smørgrav 	debug3("%s: key %p is %s",
1186d4af9e69SDag-Erling Smørgrav 	    __func__, key, allowed ? "allowed" : "not allowed");
1187545d5ecaSDag-Erling Smørgrav 
1188545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1189545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, allowed);
1190e73e9afaSDag-Erling Smørgrav 	buffer_put_int(m, forced_command != NULL);
1191545d5ecaSDag-Erling Smørgrav 
119221e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_KEYALLOWED, m);
1193545d5ecaSDag-Erling Smørgrav 
1194545d5ecaSDag-Erling Smørgrav 	if (type == MM_RSAHOSTKEY)
1195545d5ecaSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed);
1196545d5ecaSDag-Erling Smørgrav 
1197545d5ecaSDag-Erling Smørgrav 	return (0);
1198545d5ecaSDag-Erling Smørgrav }
1199545d5ecaSDag-Erling Smørgrav 
1200545d5ecaSDag-Erling Smørgrav static int
1201545d5ecaSDag-Erling Smørgrav monitor_valid_userblob(u_char *data, u_int datalen)
1202545d5ecaSDag-Erling Smørgrav {
1203545d5ecaSDag-Erling Smørgrav 	Buffer b;
1204f388f5efSDag-Erling Smørgrav 	char *p;
1205545d5ecaSDag-Erling Smørgrav 	u_int len;
1206545d5ecaSDag-Erling Smørgrav 	int fail = 0;
1207545d5ecaSDag-Erling Smørgrav 
1208545d5ecaSDag-Erling Smørgrav 	buffer_init(&b);
1209545d5ecaSDag-Erling Smørgrav 	buffer_append(&b, data, datalen);
1210545d5ecaSDag-Erling Smørgrav 
1211545d5ecaSDag-Erling Smørgrav 	if (datafellows & SSH_OLD_SESSIONID) {
1212545d5ecaSDag-Erling Smørgrav 		p = buffer_ptr(&b);
1213545d5ecaSDag-Erling Smørgrav 		len = buffer_len(&b);
1214545d5ecaSDag-Erling Smørgrav 		if ((session_id2 == NULL) ||
1215545d5ecaSDag-Erling Smørgrav 		    (len < session_id2_len) ||
1216e2f6069cSDag-Erling Smørgrav 		    (timingsafe_bcmp(p, session_id2, session_id2_len) != 0))
1217545d5ecaSDag-Erling Smørgrav 			fail++;
1218545d5ecaSDag-Erling Smørgrav 		buffer_consume(&b, session_id2_len);
1219545d5ecaSDag-Erling Smørgrav 	} else {
1220545d5ecaSDag-Erling Smørgrav 		p = buffer_get_string(&b, &len);
1221545d5ecaSDag-Erling Smørgrav 		if ((session_id2 == NULL) ||
1222545d5ecaSDag-Erling Smørgrav 		    (len != session_id2_len) ||
1223e2f6069cSDag-Erling Smørgrav 		    (timingsafe_bcmp(p, session_id2, session_id2_len) != 0))
1224545d5ecaSDag-Erling Smørgrav 			fail++;
1225545d5ecaSDag-Erling Smørgrav 		xfree(p);
1226545d5ecaSDag-Erling Smørgrav 	}
1227545d5ecaSDag-Erling Smørgrav 	if (buffer_get_char(&b) != SSH2_MSG_USERAUTH_REQUEST)
1228545d5ecaSDag-Erling Smørgrav 		fail++;
1229545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&b, NULL);
1230545d5ecaSDag-Erling Smørgrav 	if (strcmp(authctxt->user, p) != 0) {
1231cf2b5f3bSDag-Erling Smørgrav 		logit("wrong user name passed to monitor: expected %s != %.100s",
1232545d5ecaSDag-Erling Smørgrav 		    authctxt->user, p);
1233545d5ecaSDag-Erling Smørgrav 		fail++;
1234545d5ecaSDag-Erling Smørgrav 	}
1235545d5ecaSDag-Erling Smørgrav 	xfree(p);
1236545d5ecaSDag-Erling Smørgrav 	buffer_skip_string(&b);
1237545d5ecaSDag-Erling Smørgrav 	if (datafellows & SSH_BUG_PKAUTH) {
1238545d5ecaSDag-Erling Smørgrav 		if (!buffer_get_char(&b))
1239545d5ecaSDag-Erling Smørgrav 			fail++;
1240545d5ecaSDag-Erling Smørgrav 	} else {
1241545d5ecaSDag-Erling Smørgrav 		p = buffer_get_string(&b, NULL);
1242545d5ecaSDag-Erling Smørgrav 		if (strcmp("publickey", p) != 0)
1243545d5ecaSDag-Erling Smørgrav 			fail++;
1244545d5ecaSDag-Erling Smørgrav 		xfree(p);
1245545d5ecaSDag-Erling Smørgrav 		if (!buffer_get_char(&b))
1246545d5ecaSDag-Erling Smørgrav 			fail++;
1247545d5ecaSDag-Erling Smørgrav 		buffer_skip_string(&b);
1248545d5ecaSDag-Erling Smørgrav 	}
1249545d5ecaSDag-Erling Smørgrav 	buffer_skip_string(&b);
1250545d5ecaSDag-Erling Smørgrav 	if (buffer_len(&b) != 0)
1251545d5ecaSDag-Erling Smørgrav 		fail++;
1252545d5ecaSDag-Erling Smørgrav 	buffer_free(&b);
1253545d5ecaSDag-Erling Smørgrav 	return (fail == 0);
1254545d5ecaSDag-Erling Smørgrav }
1255545d5ecaSDag-Erling Smørgrav 
1256545d5ecaSDag-Erling Smørgrav static int
1257f388f5efSDag-Erling Smørgrav monitor_valid_hostbasedblob(u_char *data, u_int datalen, char *cuser,
1258f388f5efSDag-Erling Smørgrav     char *chost)
1259545d5ecaSDag-Erling Smørgrav {
1260545d5ecaSDag-Erling Smørgrav 	Buffer b;
1261f388f5efSDag-Erling Smørgrav 	char *p;
1262545d5ecaSDag-Erling Smørgrav 	u_int len;
1263545d5ecaSDag-Erling Smørgrav 	int fail = 0;
1264545d5ecaSDag-Erling Smørgrav 
1265545d5ecaSDag-Erling Smørgrav 	buffer_init(&b);
1266545d5ecaSDag-Erling Smørgrav 	buffer_append(&b, data, datalen);
1267545d5ecaSDag-Erling Smørgrav 
1268545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&b, &len);
1269545d5ecaSDag-Erling Smørgrav 	if ((session_id2 == NULL) ||
1270545d5ecaSDag-Erling Smørgrav 	    (len != session_id2_len) ||
1271e2f6069cSDag-Erling Smørgrav 	    (timingsafe_bcmp(p, session_id2, session_id2_len) != 0))
1272545d5ecaSDag-Erling Smørgrav 		fail++;
1273545d5ecaSDag-Erling Smørgrav 	xfree(p);
1274545d5ecaSDag-Erling Smørgrav 
1275545d5ecaSDag-Erling Smørgrav 	if (buffer_get_char(&b) != SSH2_MSG_USERAUTH_REQUEST)
1276545d5ecaSDag-Erling Smørgrav 		fail++;
1277545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&b, NULL);
1278545d5ecaSDag-Erling Smørgrav 	if (strcmp(authctxt->user, p) != 0) {
1279cf2b5f3bSDag-Erling Smørgrav 		logit("wrong user name passed to monitor: expected %s != %.100s",
1280545d5ecaSDag-Erling Smørgrav 		    authctxt->user, p);
1281545d5ecaSDag-Erling Smørgrav 		fail++;
1282545d5ecaSDag-Erling Smørgrav 	}
1283545d5ecaSDag-Erling Smørgrav 	xfree(p);
1284545d5ecaSDag-Erling Smørgrav 	buffer_skip_string(&b);	/* service */
1285545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&b, NULL);
1286545d5ecaSDag-Erling Smørgrav 	if (strcmp(p, "hostbased") != 0)
1287545d5ecaSDag-Erling Smørgrav 		fail++;
1288545d5ecaSDag-Erling Smørgrav 	xfree(p);
1289545d5ecaSDag-Erling Smørgrav 	buffer_skip_string(&b);	/* pkalg */
1290545d5ecaSDag-Erling Smørgrav 	buffer_skip_string(&b);	/* pkblob */
1291545d5ecaSDag-Erling Smørgrav 
1292545d5ecaSDag-Erling Smørgrav 	/* verify client host, strip trailing dot if necessary */
1293545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&b, NULL);
1294545d5ecaSDag-Erling Smørgrav 	if (((len = strlen(p)) > 0) && p[len - 1] == '.')
1295545d5ecaSDag-Erling Smørgrav 		p[len - 1] = '\0';
1296545d5ecaSDag-Erling Smørgrav 	if (strcmp(p, chost) != 0)
1297545d5ecaSDag-Erling Smørgrav 		fail++;
1298545d5ecaSDag-Erling Smørgrav 	xfree(p);
1299545d5ecaSDag-Erling Smørgrav 
1300545d5ecaSDag-Erling Smørgrav 	/* verify client user */
1301545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&b, NULL);
1302545d5ecaSDag-Erling Smørgrav 	if (strcmp(p, cuser) != 0)
1303545d5ecaSDag-Erling Smørgrav 		fail++;
1304545d5ecaSDag-Erling Smørgrav 	xfree(p);
1305545d5ecaSDag-Erling Smørgrav 
1306545d5ecaSDag-Erling Smørgrav 	if (buffer_len(&b) != 0)
1307545d5ecaSDag-Erling Smørgrav 		fail++;
1308545d5ecaSDag-Erling Smørgrav 	buffer_free(&b);
1309545d5ecaSDag-Erling Smørgrav 	return (fail == 0);
1310545d5ecaSDag-Erling Smørgrav }
1311545d5ecaSDag-Erling Smørgrav 
1312545d5ecaSDag-Erling Smørgrav int
131321e764dfSDag-Erling Smørgrav mm_answer_keyverify(int sock, Buffer *m)
1314545d5ecaSDag-Erling Smørgrav {
1315545d5ecaSDag-Erling Smørgrav 	Key *key;
1316545d5ecaSDag-Erling Smørgrav 	u_char *signature, *data, *blob;
1317545d5ecaSDag-Erling Smørgrav 	u_int signaturelen, datalen, bloblen;
1318545d5ecaSDag-Erling Smørgrav 	int verified = 0;
1319545d5ecaSDag-Erling Smørgrav 	int valid_data = 0;
1320545d5ecaSDag-Erling Smørgrav 
1321545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(m, &bloblen);
1322545d5ecaSDag-Erling Smørgrav 	signature = buffer_get_string(m, &signaturelen);
1323545d5ecaSDag-Erling Smørgrav 	data = buffer_get_string(m, &datalen);
1324545d5ecaSDag-Erling Smørgrav 
1325545d5ecaSDag-Erling Smørgrav 	if (hostbased_cuser == NULL || hostbased_chost == NULL ||
1326545d5ecaSDag-Erling Smørgrav 	  !monitor_allowed_key(blob, bloblen))
1327545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad key, not previously allowed", __func__);
1328545d5ecaSDag-Erling Smørgrav 
1329545d5ecaSDag-Erling Smørgrav 	key = key_from_blob(blob, bloblen);
1330545d5ecaSDag-Erling Smørgrav 	if (key == NULL)
1331545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad public key blob", __func__);
1332545d5ecaSDag-Erling Smørgrav 
1333545d5ecaSDag-Erling Smørgrav 	switch (key_blobtype) {
1334545d5ecaSDag-Erling Smørgrav 	case MM_USERKEY:
1335545d5ecaSDag-Erling Smørgrav 		valid_data = monitor_valid_userblob(data, datalen);
1336545d5ecaSDag-Erling Smørgrav 		break;
1337545d5ecaSDag-Erling Smørgrav 	case MM_HOSTKEY:
1338545d5ecaSDag-Erling Smørgrav 		valid_data = monitor_valid_hostbasedblob(data, datalen,
1339545d5ecaSDag-Erling Smørgrav 		    hostbased_cuser, hostbased_chost);
1340545d5ecaSDag-Erling Smørgrav 		break;
1341545d5ecaSDag-Erling Smørgrav 	default:
1342545d5ecaSDag-Erling Smørgrav 		valid_data = 0;
1343545d5ecaSDag-Erling Smørgrav 		break;
1344545d5ecaSDag-Erling Smørgrav 	}
1345545d5ecaSDag-Erling Smørgrav 	if (!valid_data)
1346545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad signature data blob", __func__);
1347545d5ecaSDag-Erling Smørgrav 
1348545d5ecaSDag-Erling Smørgrav 	verified = key_verify(key, signature, signaturelen, data, datalen);
1349545d5ecaSDag-Erling Smørgrav 	debug3("%s: key %p signature %s",
135062efe23aSDag-Erling Smørgrav 	    __func__, key, (verified == 1) ? "verified" : "unverified");
1351545d5ecaSDag-Erling Smørgrav 
1352545d5ecaSDag-Erling Smørgrav 	key_free(key);
1353545d5ecaSDag-Erling Smørgrav 	xfree(blob);
1354545d5ecaSDag-Erling Smørgrav 	xfree(signature);
1355545d5ecaSDag-Erling Smørgrav 	xfree(data);
1356545d5ecaSDag-Erling Smørgrav 
1357a82e551fSDag-Erling Smørgrav 	auth_method = key_blobtype == MM_USERKEY ? "publickey" : "hostbased";
1358a82e551fSDag-Erling Smørgrav 
1359545d5ecaSDag-Erling Smørgrav 	monitor_reset_key_state();
1360545d5ecaSDag-Erling Smørgrav 
1361545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1362545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, verified);
136321e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_KEYVERIFY, m);
1364545d5ecaSDag-Erling Smørgrav 
136562efe23aSDag-Erling Smørgrav 	return (verified == 1);
1366545d5ecaSDag-Erling Smørgrav }
1367545d5ecaSDag-Erling Smørgrav 
1368545d5ecaSDag-Erling Smørgrav static void
1369545d5ecaSDag-Erling Smørgrav mm_record_login(Session *s, struct passwd *pw)
1370545d5ecaSDag-Erling Smørgrav {
1371545d5ecaSDag-Erling Smørgrav 	socklen_t fromlen;
1372545d5ecaSDag-Erling Smørgrav 	struct sockaddr_storage from;
1373545d5ecaSDag-Erling Smørgrav 
1374545d5ecaSDag-Erling Smørgrav 	/*
1375545d5ecaSDag-Erling Smørgrav 	 * Get IP address of client. If the connection is not a socket, let
1376545d5ecaSDag-Erling Smørgrav 	 * the address be 0.0.0.0.
1377545d5ecaSDag-Erling Smørgrav 	 */
1378545d5ecaSDag-Erling Smørgrav 	memset(&from, 0, sizeof(from));
1379545d5ecaSDag-Erling Smørgrav 	fromlen = sizeof(from);
13807ac32603SHajimu UMEMOTO 	if (packet_connection_is_on_socket()) {
1381545d5ecaSDag-Erling Smørgrav 		if (getpeername(packet_get_connection_in(),
1382545d5ecaSDag-Erling Smørgrav 		    (struct sockaddr *)&from, &fromlen) < 0) {
1383545d5ecaSDag-Erling Smørgrav 			debug("getpeername: %.100s", strerror(errno));
13841ec0d754SDag-Erling Smørgrav 			cleanup_exit(255);
1385545d5ecaSDag-Erling Smørgrav 		}
1386545d5ecaSDag-Erling Smørgrav 	}
1387545d5ecaSDag-Erling Smørgrav 	/* Record that there was a login on that tty from the remote host. */
1388545d5ecaSDag-Erling Smørgrav 	record_login(s->pid, s->tty, pw->pw_name, pw->pw_uid,
1389cf2b5f3bSDag-Erling Smørgrav 	    get_remote_name_or_ip(utmp_len, options.use_dns),
13907ac32603SHajimu UMEMOTO 	    (struct sockaddr *)&from, fromlen);
1391545d5ecaSDag-Erling Smørgrav }
1392545d5ecaSDag-Erling Smørgrav 
1393545d5ecaSDag-Erling Smørgrav static void
1394545d5ecaSDag-Erling Smørgrav mm_session_close(Session *s)
1395545d5ecaSDag-Erling Smørgrav {
1396cf2b5f3bSDag-Erling Smørgrav 	debug3("%s: session %d pid %ld", __func__, s->self, (long)s->pid);
1397545d5ecaSDag-Erling Smørgrav 	if (s->ttyfd != -1) {
1398545d5ecaSDag-Erling Smørgrav 		debug3("%s: tty %s ptyfd %d", __func__, s->tty, s->ptyfd);
1399545d5ecaSDag-Erling Smørgrav 		session_pty_cleanup2(s);
1400545d5ecaSDag-Erling Smørgrav 	}
1401d4af9e69SDag-Erling Smørgrav 	session_unused(s->self);
1402545d5ecaSDag-Erling Smørgrav }
1403545d5ecaSDag-Erling Smørgrav 
1404545d5ecaSDag-Erling Smørgrav int
140521e764dfSDag-Erling Smørgrav mm_answer_pty(int sock, Buffer *m)
1406545d5ecaSDag-Erling Smørgrav {
1407545d5ecaSDag-Erling Smørgrav 	extern struct monitor *pmonitor;
1408545d5ecaSDag-Erling Smørgrav 	Session *s;
1409545d5ecaSDag-Erling Smørgrav 	int res, fd0;
1410545d5ecaSDag-Erling Smørgrav 
1411545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1412545d5ecaSDag-Erling Smørgrav 
1413545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1414545d5ecaSDag-Erling Smørgrav 	s = session_new();
1415545d5ecaSDag-Erling Smørgrav 	if (s == NULL)
1416545d5ecaSDag-Erling Smørgrav 		goto error;
1417545d5ecaSDag-Erling Smørgrav 	s->authctxt = authctxt;
1418545d5ecaSDag-Erling Smørgrav 	s->pw = authctxt->pw;
1419545d5ecaSDag-Erling Smørgrav 	s->pid = pmonitor->m_pid;
1420545d5ecaSDag-Erling Smørgrav 	res = pty_allocate(&s->ptyfd, &s->ttyfd, s->tty, sizeof(s->tty));
1421545d5ecaSDag-Erling Smørgrav 	if (res == 0)
1422545d5ecaSDag-Erling Smørgrav 		goto error;
1423545d5ecaSDag-Erling Smørgrav 	pty_setowner(authctxt->pw, s->tty);
1424545d5ecaSDag-Erling Smørgrav 
1425545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, 1);
1426545d5ecaSDag-Erling Smørgrav 	buffer_put_cstring(m, s->tty);
1427545d5ecaSDag-Erling Smørgrav 
1428545d5ecaSDag-Erling Smørgrav 	/* We need to trick ttyslot */
1429545d5ecaSDag-Erling Smørgrav 	if (dup2(s->ttyfd, 0) == -1)
1430545d5ecaSDag-Erling Smørgrav 		fatal("%s: dup2", __func__);
1431545d5ecaSDag-Erling Smørgrav 
1432545d5ecaSDag-Erling Smørgrav 	mm_record_login(s, authctxt->pw);
1433545d5ecaSDag-Erling Smørgrav 
1434545d5ecaSDag-Erling Smørgrav 	/* Now we can close the file descriptor again */
1435545d5ecaSDag-Erling Smørgrav 	close(0);
1436545d5ecaSDag-Erling Smørgrav 
143721e764dfSDag-Erling Smørgrav 	/* send messages generated by record_login */
143821e764dfSDag-Erling Smørgrav 	buffer_put_string(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg));
143921e764dfSDag-Erling Smørgrav 	buffer_clear(&loginmsg);
144021e764dfSDag-Erling Smørgrav 
144121e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PTY, m);
144221e764dfSDag-Erling Smørgrav 
1443d4af9e69SDag-Erling Smørgrav 	if (mm_send_fd(sock, s->ptyfd) == -1 ||
1444d4af9e69SDag-Erling Smørgrav 	    mm_send_fd(sock, s->ttyfd) == -1)
1445d4af9e69SDag-Erling Smørgrav 		fatal("%s: send fds failed", __func__);
144621e764dfSDag-Erling Smørgrav 
1447545d5ecaSDag-Erling Smørgrav 	/* make sure nothing uses fd 0 */
1448545d5ecaSDag-Erling Smørgrav 	if ((fd0 = open(_PATH_DEVNULL, O_RDONLY)) < 0)
1449545d5ecaSDag-Erling Smørgrav 		fatal("%s: open(/dev/null): %s", __func__, strerror(errno));
1450545d5ecaSDag-Erling Smørgrav 	if (fd0 != 0)
1451545d5ecaSDag-Erling Smørgrav 		error("%s: fd0 %d != 0", __func__, fd0);
1452545d5ecaSDag-Erling Smørgrav 
1453545d5ecaSDag-Erling Smørgrav 	/* slave is not needed */
1454545d5ecaSDag-Erling Smørgrav 	close(s->ttyfd);
1455545d5ecaSDag-Erling Smørgrav 	s->ttyfd = s->ptyfd;
1456545d5ecaSDag-Erling Smørgrav 	/* no need to dup() because nobody closes ptyfd */
1457545d5ecaSDag-Erling Smørgrav 	s->ptymaster = s->ptyfd;
1458545d5ecaSDag-Erling Smørgrav 
1459545d5ecaSDag-Erling Smørgrav 	debug3("%s: tty %s ptyfd %d", __func__, s->tty, s->ttyfd);
1460545d5ecaSDag-Erling Smørgrav 
1461545d5ecaSDag-Erling Smørgrav 	return (0);
1462545d5ecaSDag-Erling Smørgrav 
1463545d5ecaSDag-Erling Smørgrav  error:
1464545d5ecaSDag-Erling Smørgrav 	if (s != NULL)
1465545d5ecaSDag-Erling Smørgrav 		mm_session_close(s);
1466545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, 0);
146721e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_PTY, m);
1468545d5ecaSDag-Erling Smørgrav 	return (0);
1469545d5ecaSDag-Erling Smørgrav }
1470545d5ecaSDag-Erling Smørgrav 
1471545d5ecaSDag-Erling Smørgrav int
147221e764dfSDag-Erling Smørgrav mm_answer_pty_cleanup(int sock, Buffer *m)
1473545d5ecaSDag-Erling Smørgrav {
1474545d5ecaSDag-Erling Smørgrav 	Session *s;
1475545d5ecaSDag-Erling Smørgrav 	char *tty;
1476545d5ecaSDag-Erling Smørgrav 
1477545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1478545d5ecaSDag-Erling Smørgrav 
1479545d5ecaSDag-Erling Smørgrav 	tty = buffer_get_string(m, NULL);
1480545d5ecaSDag-Erling Smørgrav 	if ((s = session_by_tty(tty)) != NULL)
1481545d5ecaSDag-Erling Smørgrav 		mm_session_close(s);
1482545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1483545d5ecaSDag-Erling Smørgrav 	xfree(tty);
1484545d5ecaSDag-Erling Smørgrav 	return (0);
1485545d5ecaSDag-Erling Smørgrav }
1486545d5ecaSDag-Erling Smørgrav 
1487545d5ecaSDag-Erling Smørgrav int
148821e764dfSDag-Erling Smørgrav mm_answer_sesskey(int sock, Buffer *m)
1489545d5ecaSDag-Erling Smørgrav {
1490545d5ecaSDag-Erling Smørgrav 	BIGNUM *p;
1491545d5ecaSDag-Erling Smørgrav 	int rsafail;
1492545d5ecaSDag-Erling Smørgrav 
1493545d5ecaSDag-Erling Smørgrav 	/* Turn off permissions */
1494aa49c926SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 0);
1495545d5ecaSDag-Erling Smørgrav 
1496545d5ecaSDag-Erling Smørgrav 	if ((p = BN_new()) == NULL)
1497545d5ecaSDag-Erling Smørgrav 		fatal("%s: BN_new", __func__);
1498545d5ecaSDag-Erling Smørgrav 
1499545d5ecaSDag-Erling Smørgrav 	buffer_get_bignum2(m, p);
1500545d5ecaSDag-Erling Smørgrav 
1501545d5ecaSDag-Erling Smørgrav 	rsafail = ssh1_session_key(p);
1502545d5ecaSDag-Erling Smørgrav 
1503545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1504545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, rsafail);
1505545d5ecaSDag-Erling Smørgrav 	buffer_put_bignum2(m, p);
1506545d5ecaSDag-Erling Smørgrav 
1507545d5ecaSDag-Erling Smørgrav 	BN_clear_free(p);
1508545d5ecaSDag-Erling Smørgrav 
150921e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_SESSKEY, m);
1510545d5ecaSDag-Erling Smørgrav 
1511545d5ecaSDag-Erling Smørgrav 	/* Turn on permissions for sessid passing */
1512545d5ecaSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_SESSID, 1);
1513545d5ecaSDag-Erling Smørgrav 
1514545d5ecaSDag-Erling Smørgrav 	return (0);
1515545d5ecaSDag-Erling Smørgrav }
1516545d5ecaSDag-Erling Smørgrav 
1517545d5ecaSDag-Erling Smørgrav int
151821e764dfSDag-Erling Smørgrav mm_answer_sessid(int sock, Buffer *m)
1519545d5ecaSDag-Erling Smørgrav {
1520545d5ecaSDag-Erling Smørgrav 	int i;
1521545d5ecaSDag-Erling Smørgrav 
1522545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1523545d5ecaSDag-Erling Smørgrav 
1524545d5ecaSDag-Erling Smørgrav 	if (buffer_len(m) != 16)
1525545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad ssh1 session id", __func__);
1526545d5ecaSDag-Erling Smørgrav 	for (i = 0; i < 16; i++)
1527545d5ecaSDag-Erling Smørgrav 		session_id[i] = buffer_get_char(m);
1528545d5ecaSDag-Erling Smørgrav 
1529545d5ecaSDag-Erling Smørgrav 	/* Turn on permissions for getpwnam */
1530545d5ecaSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_PWNAM, 1);
1531545d5ecaSDag-Erling Smørgrav 
1532545d5ecaSDag-Erling Smørgrav 	return (0);
1533545d5ecaSDag-Erling Smørgrav }
1534545d5ecaSDag-Erling Smørgrav 
1535545d5ecaSDag-Erling Smørgrav int
153621e764dfSDag-Erling Smørgrav mm_answer_rsa_keyallowed(int sock, Buffer *m)
1537545d5ecaSDag-Erling Smørgrav {
1538545d5ecaSDag-Erling Smørgrav 	BIGNUM *client_n;
1539545d5ecaSDag-Erling Smørgrav 	Key *key = NULL;
1540545d5ecaSDag-Erling Smørgrav 	u_char *blob = NULL;
1541545d5ecaSDag-Erling Smørgrav 	u_int blen = 0;
1542545d5ecaSDag-Erling Smørgrav 	int allowed = 0;
1543545d5ecaSDag-Erling Smørgrav 
1544545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1545545d5ecaSDag-Erling Smørgrav 
1546333ee039SDag-Erling Smørgrav 	auth_method = "rsa";
1547545d5ecaSDag-Erling Smørgrav 	if (options.rsa_authentication && authctxt->valid) {
1548545d5ecaSDag-Erling Smørgrav 		if ((client_n = BN_new()) == NULL)
1549545d5ecaSDag-Erling Smørgrav 			fatal("%s: BN_new", __func__);
1550545d5ecaSDag-Erling Smørgrav 		buffer_get_bignum2(m, client_n);
1551545d5ecaSDag-Erling Smørgrav 		allowed = auth_rsa_key_allowed(authctxt->pw, client_n, &key);
1552545d5ecaSDag-Erling Smørgrav 		BN_clear_free(client_n);
1553545d5ecaSDag-Erling Smørgrav 	}
1554545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1555545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, allowed);
1556e73e9afaSDag-Erling Smørgrav 	buffer_put_int(m, forced_command != NULL);
1557545d5ecaSDag-Erling Smørgrav 
1558545d5ecaSDag-Erling Smørgrav 	/* clear temporarily storage (used by generate challenge) */
1559545d5ecaSDag-Erling Smørgrav 	monitor_reset_key_state();
1560545d5ecaSDag-Erling Smørgrav 
1561545d5ecaSDag-Erling Smørgrav 	if (allowed && key != NULL) {
1562545d5ecaSDag-Erling Smørgrav 		key->type = KEY_RSA;	/* cheat for key_to_blob */
1563545d5ecaSDag-Erling Smørgrav 		if (key_to_blob(key, &blob, &blen) == 0)
1564545d5ecaSDag-Erling Smørgrav 			fatal("%s: key_to_blob failed", __func__);
1565545d5ecaSDag-Erling Smørgrav 		buffer_put_string(m, blob, blen);
1566545d5ecaSDag-Erling Smørgrav 
1567545d5ecaSDag-Erling Smørgrav 		/* Save temporarily for comparison in verify */
1568545d5ecaSDag-Erling Smørgrav 		key_blob = blob;
1569545d5ecaSDag-Erling Smørgrav 		key_bloblen = blen;
1570545d5ecaSDag-Erling Smørgrav 		key_blobtype = MM_RSAUSERKEY;
1571545d5ecaSDag-Erling Smørgrav 	}
1572e73e9afaSDag-Erling Smørgrav 	if (key != NULL)
1573e73e9afaSDag-Erling Smørgrav 		key_free(key);
1574545d5ecaSDag-Erling Smørgrav 
157521e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_RSAKEYALLOWED, m);
1576545d5ecaSDag-Erling Smørgrav 
1577545d5ecaSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed);
1578545d5ecaSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 0);
1579545d5ecaSDag-Erling Smørgrav 	return (0);
1580545d5ecaSDag-Erling Smørgrav }
1581545d5ecaSDag-Erling Smørgrav 
1582545d5ecaSDag-Erling Smørgrav int
158321e764dfSDag-Erling Smørgrav mm_answer_rsa_challenge(int sock, Buffer *m)
1584545d5ecaSDag-Erling Smørgrav {
1585545d5ecaSDag-Erling Smørgrav 	Key *key = NULL;
1586545d5ecaSDag-Erling Smørgrav 	u_char *blob;
1587545d5ecaSDag-Erling Smørgrav 	u_int blen;
1588545d5ecaSDag-Erling Smørgrav 
1589545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1590545d5ecaSDag-Erling Smørgrav 
1591545d5ecaSDag-Erling Smørgrav 	if (!authctxt->valid)
1592545d5ecaSDag-Erling Smørgrav 		fatal("%s: authctxt not valid", __func__);
1593545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(m, &blen);
1594545d5ecaSDag-Erling Smørgrav 	if (!monitor_allowed_key(blob, blen))
1595545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad key, not previously allowed", __func__);
1596545d5ecaSDag-Erling Smørgrav 	if (key_blobtype != MM_RSAUSERKEY && key_blobtype != MM_RSAHOSTKEY)
1597545d5ecaSDag-Erling Smørgrav 		fatal("%s: key type mismatch", __func__);
1598545d5ecaSDag-Erling Smørgrav 	if ((key = key_from_blob(blob, blen)) == NULL)
1599545d5ecaSDag-Erling Smørgrav 		fatal("%s: received bad key", __func__);
1600cce7d346SDag-Erling Smørgrav 	if (key->type != KEY_RSA)
1601cce7d346SDag-Erling Smørgrav 		fatal("%s: received bad key type %d", __func__, key->type);
1602cce7d346SDag-Erling Smørgrav 	key->type = KEY_RSA1;
1603545d5ecaSDag-Erling Smørgrav 	if (ssh1_challenge)
1604545d5ecaSDag-Erling Smørgrav 		BN_clear_free(ssh1_challenge);
1605545d5ecaSDag-Erling Smørgrav 	ssh1_challenge = auth_rsa_generate_challenge(key);
1606545d5ecaSDag-Erling Smørgrav 
1607545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1608545d5ecaSDag-Erling Smørgrav 	buffer_put_bignum2(m, ssh1_challenge);
1609545d5ecaSDag-Erling Smørgrav 
1610545d5ecaSDag-Erling Smørgrav 	debug3("%s sending reply", __func__);
161121e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_RSACHALLENGE, m);
1612545d5ecaSDag-Erling Smørgrav 
1613545d5ecaSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 1);
1614e73e9afaSDag-Erling Smørgrav 
1615e73e9afaSDag-Erling Smørgrav 	xfree(blob);
1616e73e9afaSDag-Erling Smørgrav 	key_free(key);
1617545d5ecaSDag-Erling Smørgrav 	return (0);
1618545d5ecaSDag-Erling Smørgrav }
1619545d5ecaSDag-Erling Smørgrav 
1620545d5ecaSDag-Erling Smørgrav int
162121e764dfSDag-Erling Smørgrav mm_answer_rsa_response(int sock, Buffer *m)
1622545d5ecaSDag-Erling Smørgrav {
1623545d5ecaSDag-Erling Smørgrav 	Key *key = NULL;
1624545d5ecaSDag-Erling Smørgrav 	u_char *blob, *response;
1625545d5ecaSDag-Erling Smørgrav 	u_int blen, len;
1626545d5ecaSDag-Erling Smørgrav 	int success;
1627545d5ecaSDag-Erling Smørgrav 
1628545d5ecaSDag-Erling Smørgrav 	debug3("%s entering", __func__);
1629545d5ecaSDag-Erling Smørgrav 
1630545d5ecaSDag-Erling Smørgrav 	if (!authctxt->valid)
1631545d5ecaSDag-Erling Smørgrav 		fatal("%s: authctxt not valid", __func__);
1632545d5ecaSDag-Erling Smørgrav 	if (ssh1_challenge == NULL)
1633545d5ecaSDag-Erling Smørgrav 		fatal("%s: no ssh1_challenge", __func__);
1634545d5ecaSDag-Erling Smørgrav 
1635545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(m, &blen);
1636545d5ecaSDag-Erling Smørgrav 	if (!monitor_allowed_key(blob, blen))
1637545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad key, not previously allowed", __func__);
1638545d5ecaSDag-Erling Smørgrav 	if (key_blobtype != MM_RSAUSERKEY && key_blobtype != MM_RSAHOSTKEY)
1639545d5ecaSDag-Erling Smørgrav 		fatal("%s: key type mismatch: %d", __func__, key_blobtype);
1640545d5ecaSDag-Erling Smørgrav 	if ((key = key_from_blob(blob, blen)) == NULL)
1641545d5ecaSDag-Erling Smørgrav 		fatal("%s: received bad key", __func__);
1642545d5ecaSDag-Erling Smørgrav 	response = buffer_get_string(m, &len);
1643545d5ecaSDag-Erling Smørgrav 	if (len != 16)
1644545d5ecaSDag-Erling Smørgrav 		fatal("%s: received bad response to challenge", __func__);
1645545d5ecaSDag-Erling Smørgrav 	success = auth_rsa_verify_response(key, ssh1_challenge, response);
1646545d5ecaSDag-Erling Smørgrav 
1647e73e9afaSDag-Erling Smørgrav 	xfree(blob);
1648545d5ecaSDag-Erling Smørgrav 	key_free(key);
1649545d5ecaSDag-Erling Smørgrav 	xfree(response);
1650545d5ecaSDag-Erling Smørgrav 
1651545d5ecaSDag-Erling Smørgrav 	auth_method = key_blobtype == MM_RSAUSERKEY ? "rsa" : "rhosts-rsa";
1652545d5ecaSDag-Erling Smørgrav 
1653545d5ecaSDag-Erling Smørgrav 	/* reset state */
1654545d5ecaSDag-Erling Smørgrav 	BN_clear_free(ssh1_challenge);
1655545d5ecaSDag-Erling Smørgrav 	ssh1_challenge = NULL;
1656545d5ecaSDag-Erling Smørgrav 	monitor_reset_key_state();
1657545d5ecaSDag-Erling Smørgrav 
1658545d5ecaSDag-Erling Smørgrav 	buffer_clear(m);
1659545d5ecaSDag-Erling Smørgrav 	buffer_put_int(m, success);
166021e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_RSARESPONSE, m);
1661545d5ecaSDag-Erling Smørgrav 
1662545d5ecaSDag-Erling Smørgrav 	return (success);
1663545d5ecaSDag-Erling Smørgrav }
1664545d5ecaSDag-Erling Smørgrav 
1665545d5ecaSDag-Erling Smørgrav int
166621e764dfSDag-Erling Smørgrav mm_answer_term(int sock, Buffer *req)
1667545d5ecaSDag-Erling Smørgrav {
1668545d5ecaSDag-Erling Smørgrav 	extern struct monitor *pmonitor;
1669545d5ecaSDag-Erling Smørgrav 	int res, status;
1670545d5ecaSDag-Erling Smørgrav 
1671545d5ecaSDag-Erling Smørgrav 	debug3("%s: tearing down sessions", __func__);
1672545d5ecaSDag-Erling Smørgrav 
1673545d5ecaSDag-Erling Smørgrav 	/* The child is terminating */
1674545d5ecaSDag-Erling Smørgrav 	session_destroy_all(&mm_session_close);
1675545d5ecaSDag-Erling Smørgrav 
1676d4af9e69SDag-Erling Smørgrav #ifdef USE_PAM
1677d4af9e69SDag-Erling Smørgrav 	if (options.use_pam)
1678d4af9e69SDag-Erling Smørgrav 		sshpam_cleanup();
1679d4af9e69SDag-Erling Smørgrav #endif
1680d4af9e69SDag-Erling Smørgrav 
1681545d5ecaSDag-Erling Smørgrav 	while (waitpid(pmonitor->m_pid, &status, 0) == -1)
1682545d5ecaSDag-Erling Smørgrav 		if (errno != EINTR)
1683545d5ecaSDag-Erling Smørgrav 			exit(1);
1684545d5ecaSDag-Erling Smørgrav 
1685545d5ecaSDag-Erling Smørgrav 	res = WIFEXITED(status) ? WEXITSTATUS(status) : 1;
1686545d5ecaSDag-Erling Smørgrav 
1687545d5ecaSDag-Erling Smørgrav 	/* Terminate process */
1688545d5ecaSDag-Erling Smørgrav 	exit(res);
1689545d5ecaSDag-Erling Smørgrav }
1690545d5ecaSDag-Erling Smørgrav 
1691aa49c926SDag-Erling Smørgrav #ifdef SSH_AUDIT_EVENTS
1692aa49c926SDag-Erling Smørgrav /* Report that an audit event occurred */
1693aa49c926SDag-Erling Smørgrav int
1694aa49c926SDag-Erling Smørgrav mm_answer_audit_event(int socket, Buffer *m)
1695aa49c926SDag-Erling Smørgrav {
1696aa49c926SDag-Erling Smørgrav 	ssh_audit_event_t event;
1697aa49c926SDag-Erling Smørgrav 
1698aa49c926SDag-Erling Smørgrav 	debug3("%s entering", __func__);
1699aa49c926SDag-Erling Smørgrav 
1700aa49c926SDag-Erling Smørgrav 	event = buffer_get_int(m);
1701aa49c926SDag-Erling Smørgrav 	switch(event) {
1702aa49c926SDag-Erling Smørgrav 	case SSH_AUTH_FAIL_PUBKEY:
1703aa49c926SDag-Erling Smørgrav 	case SSH_AUTH_FAIL_HOSTBASED:
1704aa49c926SDag-Erling Smørgrav 	case SSH_AUTH_FAIL_GSSAPI:
1705aa49c926SDag-Erling Smørgrav 	case SSH_LOGIN_EXCEED_MAXTRIES:
1706aa49c926SDag-Erling Smørgrav 	case SSH_LOGIN_ROOT_DENIED:
1707aa49c926SDag-Erling Smørgrav 	case SSH_CONNECTION_CLOSE:
1708aa49c926SDag-Erling Smørgrav 	case SSH_INVALID_USER:
1709aa49c926SDag-Erling Smørgrav 		audit_event(event);
1710aa49c926SDag-Erling Smørgrav 		break;
1711aa49c926SDag-Erling Smørgrav 	default:
1712aa49c926SDag-Erling Smørgrav 		fatal("Audit event type %d not permitted", event);
1713aa49c926SDag-Erling Smørgrav 	}
1714aa49c926SDag-Erling Smørgrav 
1715aa49c926SDag-Erling Smørgrav 	return (0);
1716aa49c926SDag-Erling Smørgrav }
1717aa49c926SDag-Erling Smørgrav 
1718aa49c926SDag-Erling Smørgrav int
1719aa49c926SDag-Erling Smørgrav mm_answer_audit_command(int socket, Buffer *m)
1720aa49c926SDag-Erling Smørgrav {
1721aa49c926SDag-Erling Smørgrav 	u_int len;
1722aa49c926SDag-Erling Smørgrav 	char *cmd;
1723aa49c926SDag-Erling Smørgrav 
1724aa49c926SDag-Erling Smørgrav 	debug3("%s entering", __func__);
1725aa49c926SDag-Erling Smørgrav 	cmd = buffer_get_string(m, &len);
1726aa49c926SDag-Erling Smørgrav 	/* sanity check command, if so how? */
1727aa49c926SDag-Erling Smørgrav 	audit_run_command(cmd);
1728aa49c926SDag-Erling Smørgrav 	xfree(cmd);
1729aa49c926SDag-Erling Smørgrav 	return (0);
1730aa49c926SDag-Erling Smørgrav }
1731aa49c926SDag-Erling Smørgrav #endif /* SSH_AUDIT_EVENTS */
1732aa49c926SDag-Erling Smørgrav 
1733545d5ecaSDag-Erling Smørgrav void
1734545d5ecaSDag-Erling Smørgrav monitor_apply_keystate(struct monitor *pmonitor)
1735545d5ecaSDag-Erling Smørgrav {
1736545d5ecaSDag-Erling Smørgrav 	if (compat20) {
1737545d5ecaSDag-Erling Smørgrav 		set_newkeys(MODE_IN);
1738545d5ecaSDag-Erling Smørgrav 		set_newkeys(MODE_OUT);
1739545d5ecaSDag-Erling Smørgrav 	} else {
1740545d5ecaSDag-Erling Smørgrav 		packet_set_protocol_flags(child_state.ssh1protoflags);
1741545d5ecaSDag-Erling Smørgrav 		packet_set_encryption_key(child_state.ssh1key,
1742545d5ecaSDag-Erling Smørgrav 		    child_state.ssh1keylen, child_state.ssh1cipher);
1743545d5ecaSDag-Erling Smørgrav 		xfree(child_state.ssh1key);
1744545d5ecaSDag-Erling Smørgrav 	}
1745545d5ecaSDag-Erling Smørgrav 
1746545d5ecaSDag-Erling Smørgrav 	/* for rc4 and other stateful ciphers */
1747545d5ecaSDag-Erling Smørgrav 	packet_set_keycontext(MODE_OUT, child_state.keyout);
1748545d5ecaSDag-Erling Smørgrav 	xfree(child_state.keyout);
1749545d5ecaSDag-Erling Smørgrav 	packet_set_keycontext(MODE_IN, child_state.keyin);
1750545d5ecaSDag-Erling Smørgrav 	xfree(child_state.keyin);
1751545d5ecaSDag-Erling Smørgrav 
1752545d5ecaSDag-Erling Smørgrav 	if (!compat20) {
1753545d5ecaSDag-Erling Smørgrav 		packet_set_iv(MODE_OUT, child_state.ivout);
1754545d5ecaSDag-Erling Smørgrav 		xfree(child_state.ivout);
1755545d5ecaSDag-Erling Smørgrav 		packet_set_iv(MODE_IN, child_state.ivin);
1756545d5ecaSDag-Erling Smørgrav 		xfree(child_state.ivin);
1757545d5ecaSDag-Erling Smørgrav 	}
1758545d5ecaSDag-Erling Smørgrav 
1759545d5ecaSDag-Erling Smørgrav 	memcpy(&incoming_stream, &child_state.incoming,
1760545d5ecaSDag-Erling Smørgrav 	    sizeof(incoming_stream));
1761545d5ecaSDag-Erling Smørgrav 	memcpy(&outgoing_stream, &child_state.outgoing,
1762545d5ecaSDag-Erling Smørgrav 	    sizeof(outgoing_stream));
1763545d5ecaSDag-Erling Smørgrav 
1764545d5ecaSDag-Erling Smørgrav 	/* Update with new address */
1765545d5ecaSDag-Erling Smørgrav 	if (options.compression)
1766545d5ecaSDag-Erling Smørgrav 		mm_init_compression(pmonitor->m_zlib);
1767545d5ecaSDag-Erling Smørgrav 
1768545d5ecaSDag-Erling Smørgrav 	/* Network I/O buffers */
1769545d5ecaSDag-Erling Smørgrav 	/* XXX inefficient for large buffers, need: buffer_init_from_string */
17707aee6ffeSDag-Erling Smørgrav 	buffer_clear(packet_get_input());
17717aee6ffeSDag-Erling Smørgrav 	buffer_append(packet_get_input(), child_state.input, child_state.ilen);
1772545d5ecaSDag-Erling Smørgrav 	memset(child_state.input, 0, child_state.ilen);
1773545d5ecaSDag-Erling Smørgrav 	xfree(child_state.input);
1774545d5ecaSDag-Erling Smørgrav 
17757aee6ffeSDag-Erling Smørgrav 	buffer_clear(packet_get_output());
17767aee6ffeSDag-Erling Smørgrav 	buffer_append(packet_get_output(), child_state.output,
17777aee6ffeSDag-Erling Smørgrav 		      child_state.olen);
1778545d5ecaSDag-Erling Smørgrav 	memset(child_state.output, 0, child_state.olen);
1779545d5ecaSDag-Erling Smørgrav 	xfree(child_state.output);
17807aee6ffeSDag-Erling Smørgrav 
17817aee6ffeSDag-Erling Smørgrav 	/* Roaming */
17827aee6ffeSDag-Erling Smørgrav 	if (compat20)
17837aee6ffeSDag-Erling Smørgrav 		roam_set_bytes(child_state.sent_bytes, child_state.recv_bytes);
1784545d5ecaSDag-Erling Smørgrav }
1785545d5ecaSDag-Erling Smørgrav 
1786545d5ecaSDag-Erling Smørgrav static Kex *
1787545d5ecaSDag-Erling Smørgrav mm_get_kex(Buffer *m)
1788545d5ecaSDag-Erling Smørgrav {
1789545d5ecaSDag-Erling Smørgrav 	Kex *kex;
1790545d5ecaSDag-Erling Smørgrav 	void *blob;
1791545d5ecaSDag-Erling Smørgrav 	u_int bloblen;
1792545d5ecaSDag-Erling Smørgrav 
1793333ee039SDag-Erling Smørgrav 	kex = xcalloc(1, sizeof(*kex));
1794545d5ecaSDag-Erling Smørgrav 	kex->session_id = buffer_get_string(m, &kex->session_id_len);
1795e2f6069cSDag-Erling Smørgrav 	if (session_id2 == NULL ||
1796e2f6069cSDag-Erling Smørgrav 	    kex->session_id_len != session_id2_len ||
1797e2f6069cSDag-Erling Smørgrav 	    timingsafe_bcmp(kex->session_id, session_id2, session_id2_len) != 0)
1798545d5ecaSDag-Erling Smørgrav 		fatal("mm_get_get: internal error: bad session id");
1799545d5ecaSDag-Erling Smørgrav 	kex->we_need = buffer_get_int(m);
1800e73e9afaSDag-Erling Smørgrav 	kex->kex[KEX_DH_GRP1_SHA1] = kexdh_server;
180121e764dfSDag-Erling Smørgrav 	kex->kex[KEX_DH_GRP14_SHA1] = kexdh_server;
1802e73e9afaSDag-Erling Smørgrav 	kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;
1803333ee039SDag-Erling Smørgrav 	kex->kex[KEX_DH_GEX_SHA256] = kexgex_server;
18044a421b63SDag-Erling Smørgrav 	kex->kex[KEX_ECDH_SHA2] = kexecdh_server;
1805545d5ecaSDag-Erling Smørgrav 	kex->server = 1;
1806545d5ecaSDag-Erling Smørgrav 	kex->hostkey_type = buffer_get_int(m);
1807545d5ecaSDag-Erling Smørgrav 	kex->kex_type = buffer_get_int(m);
1808545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(m, &bloblen);
1809545d5ecaSDag-Erling Smørgrav 	buffer_init(&kex->my);
1810545d5ecaSDag-Erling Smørgrav 	buffer_append(&kex->my, blob, bloblen);
1811545d5ecaSDag-Erling Smørgrav 	xfree(blob);
1812545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(m, &bloblen);
1813545d5ecaSDag-Erling Smørgrav 	buffer_init(&kex->peer);
1814545d5ecaSDag-Erling Smørgrav 	buffer_append(&kex->peer, blob, bloblen);
1815545d5ecaSDag-Erling Smørgrav 	xfree(blob);
1816545d5ecaSDag-Erling Smørgrav 	kex->done = 1;
1817545d5ecaSDag-Erling Smørgrav 	kex->flags = buffer_get_int(m);
1818545d5ecaSDag-Erling Smørgrav 	kex->client_version_string = buffer_get_string(m, NULL);
1819545d5ecaSDag-Erling Smørgrav 	kex->server_version_string = buffer_get_string(m, NULL);
1820b15c8340SDag-Erling Smørgrav 	kex->load_host_public_key=&get_hostkey_public_by_type;
1821b15c8340SDag-Erling Smørgrav 	kex->load_host_private_key=&get_hostkey_private_by_type;
1822545d5ecaSDag-Erling Smørgrav 	kex->host_key_index=&get_hostkey_index;
1823545d5ecaSDag-Erling Smørgrav 
1824545d5ecaSDag-Erling Smørgrav 	return (kex);
1825545d5ecaSDag-Erling Smørgrav }
1826545d5ecaSDag-Erling Smørgrav 
1827545d5ecaSDag-Erling Smørgrav /* This function requries careful sanity checking */
1828545d5ecaSDag-Erling Smørgrav 
1829545d5ecaSDag-Erling Smørgrav void
1830545d5ecaSDag-Erling Smørgrav mm_get_keystate(struct monitor *pmonitor)
1831545d5ecaSDag-Erling Smørgrav {
1832545d5ecaSDag-Erling Smørgrav 	Buffer m;
1833545d5ecaSDag-Erling Smørgrav 	u_char *blob, *p;
1834545d5ecaSDag-Erling Smørgrav 	u_int bloblen, plen;
1835cf2b5f3bSDag-Erling Smørgrav 	u_int32_t seqnr, packets;
1836d4af9e69SDag-Erling Smørgrav 	u_int64_t blocks, bytes;
1837545d5ecaSDag-Erling Smørgrav 
1838545d5ecaSDag-Erling Smørgrav 	debug3("%s: Waiting for new keys", __func__);
1839545d5ecaSDag-Erling Smørgrav 
1840545d5ecaSDag-Erling Smørgrav 	buffer_init(&m);
1841545d5ecaSDag-Erling Smørgrav 	mm_request_receive_expect(pmonitor->m_sendfd, MONITOR_REQ_KEYEXPORT, &m);
1842545d5ecaSDag-Erling Smørgrav 	if (!compat20) {
1843545d5ecaSDag-Erling Smørgrav 		child_state.ssh1protoflags = buffer_get_int(&m);
1844545d5ecaSDag-Erling Smørgrav 		child_state.ssh1cipher = buffer_get_int(&m);
1845545d5ecaSDag-Erling Smørgrav 		child_state.ssh1key = buffer_get_string(&m,
1846545d5ecaSDag-Erling Smørgrav 		    &child_state.ssh1keylen);
1847545d5ecaSDag-Erling Smørgrav 		child_state.ivout = buffer_get_string(&m,
1848545d5ecaSDag-Erling Smørgrav 		    &child_state.ivoutlen);
1849545d5ecaSDag-Erling Smørgrav 		child_state.ivin = buffer_get_string(&m, &child_state.ivinlen);
1850545d5ecaSDag-Erling Smørgrav 		goto skip;
1851545d5ecaSDag-Erling Smørgrav 	} else {
1852545d5ecaSDag-Erling Smørgrav 		/* Get the Kex for rekeying */
1853545d5ecaSDag-Erling Smørgrav 		*pmonitor->m_pkex = mm_get_kex(&m);
1854545d5ecaSDag-Erling Smørgrav 	}
1855545d5ecaSDag-Erling Smørgrav 
1856545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(&m, &bloblen);
1857545d5ecaSDag-Erling Smørgrav 	current_keys[MODE_OUT] = mm_newkeys_from_blob(blob, bloblen);
1858545d5ecaSDag-Erling Smørgrav 	xfree(blob);
1859545d5ecaSDag-Erling Smørgrav 
1860545d5ecaSDag-Erling Smørgrav 	debug3("%s: Waiting for second key", __func__);
1861545d5ecaSDag-Erling Smørgrav 	blob = buffer_get_string(&m, &bloblen);
1862545d5ecaSDag-Erling Smørgrav 	current_keys[MODE_IN] = mm_newkeys_from_blob(blob, bloblen);
1863545d5ecaSDag-Erling Smørgrav 	xfree(blob);
1864545d5ecaSDag-Erling Smørgrav 
1865545d5ecaSDag-Erling Smørgrav 	/* Now get sequence numbers for the packets */
1866cf2b5f3bSDag-Erling Smørgrav 	seqnr = buffer_get_int(&m);
1867cf2b5f3bSDag-Erling Smørgrav 	blocks = buffer_get_int64(&m);
1868cf2b5f3bSDag-Erling Smørgrav 	packets = buffer_get_int(&m);
1869d4af9e69SDag-Erling Smørgrav 	bytes = buffer_get_int64(&m);
1870d4af9e69SDag-Erling Smørgrav 	packet_set_state(MODE_OUT, seqnr, blocks, packets, bytes);
1871cf2b5f3bSDag-Erling Smørgrav 	seqnr = buffer_get_int(&m);
1872cf2b5f3bSDag-Erling Smørgrav 	blocks = buffer_get_int64(&m);
1873cf2b5f3bSDag-Erling Smørgrav 	packets = buffer_get_int(&m);
1874d4af9e69SDag-Erling Smørgrav 	bytes = buffer_get_int64(&m);
1875d4af9e69SDag-Erling Smørgrav 	packet_set_state(MODE_IN, seqnr, blocks, packets, bytes);
1876545d5ecaSDag-Erling Smørgrav 
1877545d5ecaSDag-Erling Smørgrav  skip:
1878545d5ecaSDag-Erling Smørgrav 	/* Get the key context */
1879545d5ecaSDag-Erling Smørgrav 	child_state.keyout = buffer_get_string(&m, &child_state.keyoutlen);
1880545d5ecaSDag-Erling Smørgrav 	child_state.keyin  = buffer_get_string(&m, &child_state.keyinlen);
1881545d5ecaSDag-Erling Smørgrav 
1882545d5ecaSDag-Erling Smørgrav 	debug3("%s: Getting compression state", __func__);
1883545d5ecaSDag-Erling Smørgrav 	/* Get compression state */
1884545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&m, &plen);
1885545d5ecaSDag-Erling Smørgrav 	if (plen != sizeof(child_state.outgoing))
1886545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad request size", __func__);
1887545d5ecaSDag-Erling Smørgrav 	memcpy(&child_state.outgoing, p, sizeof(child_state.outgoing));
1888545d5ecaSDag-Erling Smørgrav 	xfree(p);
1889545d5ecaSDag-Erling Smørgrav 
1890545d5ecaSDag-Erling Smørgrav 	p = buffer_get_string(&m, &plen);
1891545d5ecaSDag-Erling Smørgrav 	if (plen != sizeof(child_state.incoming))
1892545d5ecaSDag-Erling Smørgrav 		fatal("%s: bad request size", __func__);
1893545d5ecaSDag-Erling Smørgrav 	memcpy(&child_state.incoming, p, sizeof(child_state.incoming));
1894545d5ecaSDag-Erling Smørgrav 	xfree(p);
1895545d5ecaSDag-Erling Smørgrav 
1896545d5ecaSDag-Erling Smørgrav 	/* Network I/O buffers */
1897545d5ecaSDag-Erling Smørgrav 	debug3("%s: Getting Network I/O buffers", __func__);
1898545d5ecaSDag-Erling Smørgrav 	child_state.input = buffer_get_string(&m, &child_state.ilen);
1899545d5ecaSDag-Erling Smørgrav 	child_state.output = buffer_get_string(&m, &child_state.olen);
1900545d5ecaSDag-Erling Smørgrav 
19017aee6ffeSDag-Erling Smørgrav 	/* Roaming */
19027aee6ffeSDag-Erling Smørgrav 	if (compat20) {
19037aee6ffeSDag-Erling Smørgrav 		child_state.sent_bytes = buffer_get_int64(&m);
19047aee6ffeSDag-Erling Smørgrav 		child_state.recv_bytes = buffer_get_int64(&m);
19057aee6ffeSDag-Erling Smørgrav 	}
19067aee6ffeSDag-Erling Smørgrav 
1907545d5ecaSDag-Erling Smørgrav 	buffer_free(&m);
1908545d5ecaSDag-Erling Smørgrav }
1909545d5ecaSDag-Erling Smørgrav 
1910545d5ecaSDag-Erling Smørgrav 
1911545d5ecaSDag-Erling Smørgrav /* Allocation functions for zlib */
1912545d5ecaSDag-Erling Smørgrav void *
1913545d5ecaSDag-Erling Smørgrav mm_zalloc(struct mm_master *mm, u_int ncount, u_int size)
1914545d5ecaSDag-Erling Smørgrav {
1915e73e9afaSDag-Erling Smørgrav 	size_t len = (size_t) size * ncount;
1916545d5ecaSDag-Erling Smørgrav 	void *address;
1917545d5ecaSDag-Erling Smørgrav 
1918f388f5efSDag-Erling Smørgrav 	if (len == 0 || ncount > SIZE_T_MAX / size)
1919a82e551fSDag-Erling Smørgrav 		fatal("%s: mm_zalloc(%u, %u)", __func__, ncount, size);
1920a82e551fSDag-Erling Smørgrav 
1921a82e551fSDag-Erling Smørgrav 	address = mm_malloc(mm, len);
1922545d5ecaSDag-Erling Smørgrav 
1923545d5ecaSDag-Erling Smørgrav 	return (address);
1924545d5ecaSDag-Erling Smørgrav }
1925545d5ecaSDag-Erling Smørgrav 
1926545d5ecaSDag-Erling Smørgrav void
1927545d5ecaSDag-Erling Smørgrav mm_zfree(struct mm_master *mm, void *address)
1928545d5ecaSDag-Erling Smørgrav {
1929545d5ecaSDag-Erling Smørgrav 	mm_free(mm, address);
1930545d5ecaSDag-Erling Smørgrav }
1931545d5ecaSDag-Erling Smørgrav 
1932545d5ecaSDag-Erling Smørgrav void
1933545d5ecaSDag-Erling Smørgrav mm_init_compression(struct mm_master *mm)
1934545d5ecaSDag-Erling Smørgrav {
1935545d5ecaSDag-Erling Smørgrav 	outgoing_stream.zalloc = (alloc_func)mm_zalloc;
1936545d5ecaSDag-Erling Smørgrav 	outgoing_stream.zfree = (free_func)mm_zfree;
1937545d5ecaSDag-Erling Smørgrav 	outgoing_stream.opaque = mm;
1938545d5ecaSDag-Erling Smørgrav 
1939545d5ecaSDag-Erling Smørgrav 	incoming_stream.zalloc = (alloc_func)mm_zalloc;
1940545d5ecaSDag-Erling Smørgrav 	incoming_stream.zfree = (free_func)mm_zfree;
1941545d5ecaSDag-Erling Smørgrav 	incoming_stream.opaque = mm;
1942545d5ecaSDag-Erling Smørgrav }
1943545d5ecaSDag-Erling Smørgrav 
1944545d5ecaSDag-Erling Smørgrav /* XXX */
1945545d5ecaSDag-Erling Smørgrav 
1946545d5ecaSDag-Erling Smørgrav #define FD_CLOSEONEXEC(x) do { \
1947*e146993eSDag-Erling Smørgrav 	if (fcntl(x, F_SETFD, FD_CLOEXEC) == -1) \
1948545d5ecaSDag-Erling Smørgrav 		fatal("fcntl(%d, F_SETFD)", x); \
1949545d5ecaSDag-Erling Smørgrav } while (0)
1950545d5ecaSDag-Erling Smørgrav 
1951545d5ecaSDag-Erling Smørgrav static void
1952*e146993eSDag-Erling Smørgrav monitor_openfds(struct monitor *mon, int do_logfds)
1953545d5ecaSDag-Erling Smørgrav {
1954*e146993eSDag-Erling Smørgrav 	int pair[2];
1955*e146993eSDag-Erling Smørgrav 
1956545d5ecaSDag-Erling Smørgrav 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1)
1957*e146993eSDag-Erling Smørgrav 		fatal("%s: socketpair: %s", __func__, strerror(errno));
1958545d5ecaSDag-Erling Smørgrav 	FD_CLOSEONEXEC(pair[0]);
1959545d5ecaSDag-Erling Smørgrav 	FD_CLOSEONEXEC(pair[1]);
1960*e146993eSDag-Erling Smørgrav 	mon->m_recvfd = pair[0];
1961*e146993eSDag-Erling Smørgrav 	mon->m_sendfd = pair[1];
1962*e146993eSDag-Erling Smørgrav 
1963*e146993eSDag-Erling Smørgrav 	if (do_logfds) {
1964*e146993eSDag-Erling Smørgrav 		if (pipe(pair) == -1)
1965*e146993eSDag-Erling Smørgrav 			fatal("%s: pipe: %s", __func__, strerror(errno));
1966*e146993eSDag-Erling Smørgrav 		FD_CLOSEONEXEC(pair[0]);
1967*e146993eSDag-Erling Smørgrav 		FD_CLOSEONEXEC(pair[1]);
1968*e146993eSDag-Erling Smørgrav 		mon->m_log_recvfd = pair[0];
1969*e146993eSDag-Erling Smørgrav 		mon->m_log_sendfd = pair[1];
1970*e146993eSDag-Erling Smørgrav 	} else
1971*e146993eSDag-Erling Smørgrav 		mon->m_log_recvfd = mon->m_log_sendfd = -1;
1972545d5ecaSDag-Erling Smørgrav }
1973545d5ecaSDag-Erling Smørgrav 
1974545d5ecaSDag-Erling Smørgrav #define MM_MEMSIZE	65536
1975545d5ecaSDag-Erling Smørgrav 
1976545d5ecaSDag-Erling Smørgrav struct monitor *
1977545d5ecaSDag-Erling Smørgrav monitor_init(void)
1978545d5ecaSDag-Erling Smørgrav {
1979545d5ecaSDag-Erling Smørgrav 	struct monitor *mon;
1980545d5ecaSDag-Erling Smørgrav 
1981333ee039SDag-Erling Smørgrav 	mon = xcalloc(1, sizeof(*mon));
1982545d5ecaSDag-Erling Smørgrav 
1983*e146993eSDag-Erling Smørgrav 	monitor_openfds(mon, 1);
1984545d5ecaSDag-Erling Smørgrav 
1985545d5ecaSDag-Erling Smørgrav 	/* Used to share zlib space across processes */
1986545d5ecaSDag-Erling Smørgrav 	if (options.compression) {
1987545d5ecaSDag-Erling Smørgrav 		mon->m_zback = mm_create(NULL, MM_MEMSIZE);
1988545d5ecaSDag-Erling Smørgrav 		mon->m_zlib = mm_create(mon->m_zback, 20 * MM_MEMSIZE);
1989545d5ecaSDag-Erling Smørgrav 
1990545d5ecaSDag-Erling Smørgrav 		/* Compression needs to share state across borders */
1991545d5ecaSDag-Erling Smørgrav 		mm_init_compression(mon->m_zlib);
1992545d5ecaSDag-Erling Smørgrav 	}
1993545d5ecaSDag-Erling Smørgrav 
1994545d5ecaSDag-Erling Smørgrav 	return mon;
1995545d5ecaSDag-Erling Smørgrav }
1996545d5ecaSDag-Erling Smørgrav 
1997545d5ecaSDag-Erling Smørgrav void
1998545d5ecaSDag-Erling Smørgrav monitor_reinit(struct monitor *mon)
1999545d5ecaSDag-Erling Smørgrav {
2000*e146993eSDag-Erling Smørgrav 	monitor_openfds(mon, 0);
2001545d5ecaSDag-Erling Smørgrav }
2002cf2b5f3bSDag-Erling Smørgrav 
2003cf2b5f3bSDag-Erling Smørgrav #ifdef GSSAPI
2004cf2b5f3bSDag-Erling Smørgrav int
200521e764dfSDag-Erling Smørgrav mm_answer_gss_setup_ctx(int sock, Buffer *m)
2006cf2b5f3bSDag-Erling Smørgrav {
200721e764dfSDag-Erling Smørgrav 	gss_OID_desc goid;
2008cf2b5f3bSDag-Erling Smørgrav 	OM_uint32 major;
2009cf2b5f3bSDag-Erling Smørgrav 	u_int len;
2010cf2b5f3bSDag-Erling Smørgrav 
201121e764dfSDag-Erling Smørgrav 	goid.elements = buffer_get_string(m, &len);
201221e764dfSDag-Erling Smørgrav 	goid.length = len;
2013cf2b5f3bSDag-Erling Smørgrav 
201421e764dfSDag-Erling Smørgrav 	major = ssh_gssapi_server_ctx(&gsscontext, &goid);
2015cf2b5f3bSDag-Erling Smørgrav 
201621e764dfSDag-Erling Smørgrav 	xfree(goid.elements);
2017cf2b5f3bSDag-Erling Smørgrav 
2018cf2b5f3bSDag-Erling Smørgrav 	buffer_clear(m);
2019cf2b5f3bSDag-Erling Smørgrav 	buffer_put_int(m, major);
2020cf2b5f3bSDag-Erling Smørgrav 
202121e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_GSSSETUP, m);
2022cf2b5f3bSDag-Erling Smørgrav 
2023cf2b5f3bSDag-Erling Smørgrav 	/* Now we have a context, enable the step */
2024cf2b5f3bSDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 1);
2025cf2b5f3bSDag-Erling Smørgrav 
2026cf2b5f3bSDag-Erling Smørgrav 	return (0);
2027cf2b5f3bSDag-Erling Smørgrav }
2028cf2b5f3bSDag-Erling Smørgrav 
2029cf2b5f3bSDag-Erling Smørgrav int
203021e764dfSDag-Erling Smørgrav mm_answer_gss_accept_ctx(int sock, Buffer *m)
2031cf2b5f3bSDag-Erling Smørgrav {
2032cf2b5f3bSDag-Erling Smørgrav 	gss_buffer_desc in;
2033cf2b5f3bSDag-Erling Smørgrav 	gss_buffer_desc out = GSS_C_EMPTY_BUFFER;
2034cf2b5f3bSDag-Erling Smørgrav 	OM_uint32 major, minor;
2035cf2b5f3bSDag-Erling Smørgrav 	OM_uint32 flags = 0; /* GSI needs this */
2036cf2b5f3bSDag-Erling Smørgrav 	u_int len;
2037cf2b5f3bSDag-Erling Smørgrav 
2038cf2b5f3bSDag-Erling Smørgrav 	in.value = buffer_get_string(m, &len);
2039cf2b5f3bSDag-Erling Smørgrav 	in.length = len;
2040cf2b5f3bSDag-Erling Smørgrav 	major = ssh_gssapi_accept_ctx(gsscontext, &in, &out, &flags);
2041cf2b5f3bSDag-Erling Smørgrav 	xfree(in.value);
2042cf2b5f3bSDag-Erling Smørgrav 
2043cf2b5f3bSDag-Erling Smørgrav 	buffer_clear(m);
2044cf2b5f3bSDag-Erling Smørgrav 	buffer_put_int(m, major);
2045cf2b5f3bSDag-Erling Smørgrav 	buffer_put_string(m, out.value, out.length);
2046cf2b5f3bSDag-Erling Smørgrav 	buffer_put_int(m, flags);
204721e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_GSSSTEP, m);
2048cf2b5f3bSDag-Erling Smørgrav 
2049cf2b5f3bSDag-Erling Smørgrav 	gss_release_buffer(&minor, &out);
2050cf2b5f3bSDag-Erling Smørgrav 
2051cf2b5f3bSDag-Erling Smørgrav 	if (major == GSS_S_COMPLETE) {
2052cf2b5f3bSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 0);
2053cf2b5f3bSDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1);
20541ec0d754SDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_GSSCHECKMIC, 1);
2055cf2b5f3bSDag-Erling Smørgrav 	}
2056cf2b5f3bSDag-Erling Smørgrav 	return (0);
2057cf2b5f3bSDag-Erling Smørgrav }
2058cf2b5f3bSDag-Erling Smørgrav 
2059cf2b5f3bSDag-Erling Smørgrav int
206021e764dfSDag-Erling Smørgrav mm_answer_gss_checkmic(int sock, Buffer *m)
20611ec0d754SDag-Erling Smørgrav {
20621ec0d754SDag-Erling Smørgrav 	gss_buffer_desc gssbuf, mic;
20631ec0d754SDag-Erling Smørgrav 	OM_uint32 ret;
20641ec0d754SDag-Erling Smørgrav 	u_int len;
20651ec0d754SDag-Erling Smørgrav 
20661ec0d754SDag-Erling Smørgrav 	gssbuf.value = buffer_get_string(m, &len);
20671ec0d754SDag-Erling Smørgrav 	gssbuf.length = len;
20681ec0d754SDag-Erling Smørgrav 	mic.value = buffer_get_string(m, &len);
20691ec0d754SDag-Erling Smørgrav 	mic.length = len;
20701ec0d754SDag-Erling Smørgrav 
20711ec0d754SDag-Erling Smørgrav 	ret = ssh_gssapi_checkmic(gsscontext, &gssbuf, &mic);
20721ec0d754SDag-Erling Smørgrav 
20731ec0d754SDag-Erling Smørgrav 	xfree(gssbuf.value);
20741ec0d754SDag-Erling Smørgrav 	xfree(mic.value);
20751ec0d754SDag-Erling Smørgrav 
20761ec0d754SDag-Erling Smørgrav 	buffer_clear(m);
20771ec0d754SDag-Erling Smørgrav 	buffer_put_int(m, ret);
20781ec0d754SDag-Erling Smørgrav 
207921e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_GSSCHECKMIC, m);
20801ec0d754SDag-Erling Smørgrav 
20811ec0d754SDag-Erling Smørgrav 	if (!GSS_ERROR(ret))
20821ec0d754SDag-Erling Smørgrav 		monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1);
20831ec0d754SDag-Erling Smørgrav 
20841ec0d754SDag-Erling Smørgrav 	return (0);
20851ec0d754SDag-Erling Smørgrav }
20861ec0d754SDag-Erling Smørgrav 
20871ec0d754SDag-Erling Smørgrav int
208821e764dfSDag-Erling Smørgrav mm_answer_gss_userok(int sock, Buffer *m)
2089cf2b5f3bSDag-Erling Smørgrav {
2090cf2b5f3bSDag-Erling Smørgrav 	int authenticated;
2091cf2b5f3bSDag-Erling Smørgrav 
2092cf2b5f3bSDag-Erling Smørgrav 	authenticated = authctxt->valid && ssh_gssapi_userok(authctxt->user);
2093cf2b5f3bSDag-Erling Smørgrav 
2094cf2b5f3bSDag-Erling Smørgrav 	buffer_clear(m);
2095cf2b5f3bSDag-Erling Smørgrav 	buffer_put_int(m, authenticated);
2096cf2b5f3bSDag-Erling Smørgrav 
2097cf2b5f3bSDag-Erling Smørgrav 	debug3("%s: sending result %d", __func__, authenticated);
209821e764dfSDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_GSSUSEROK, m);
2099cf2b5f3bSDag-Erling Smørgrav 
21001ec0d754SDag-Erling Smørgrav 	auth_method = "gssapi-with-mic";
2101cf2b5f3bSDag-Erling Smørgrav 
2102cf2b5f3bSDag-Erling Smørgrav 	/* Monitor loop will terminate if authenticated */
2103cf2b5f3bSDag-Erling Smørgrav 	return (authenticated);
2104cf2b5f3bSDag-Erling Smørgrav }
2105cf2b5f3bSDag-Erling Smørgrav #endif /* GSSAPI */
2106cce7d346SDag-Erling Smørgrav 
2107cce7d346SDag-Erling Smørgrav #ifdef JPAKE
2108cce7d346SDag-Erling Smørgrav int
2109cce7d346SDag-Erling Smørgrav mm_answer_jpake_step1(int sock, Buffer *m)
2110cce7d346SDag-Erling Smørgrav {
2111cce7d346SDag-Erling Smørgrav 	struct jpake_ctx *pctx;
2112cce7d346SDag-Erling Smørgrav 	u_char *x3_proof, *x4_proof;
2113cce7d346SDag-Erling Smørgrav 	u_int x3_proof_len, x4_proof_len;
2114cce7d346SDag-Erling Smørgrav 
2115cce7d346SDag-Erling Smørgrav 	if (!options.zero_knowledge_password_authentication)
2116cce7d346SDag-Erling Smørgrav 		fatal("zero_knowledge_password_authentication disabled");
2117cce7d346SDag-Erling Smørgrav 
2118cce7d346SDag-Erling Smørgrav 	if (authctxt->jpake_ctx != NULL)
2119cce7d346SDag-Erling Smørgrav 		fatal("%s: authctxt->jpake_ctx already set (%p)",
2120cce7d346SDag-Erling Smørgrav 		    __func__, authctxt->jpake_ctx);
2121cce7d346SDag-Erling Smørgrav 	authctxt->jpake_ctx = pctx = jpake_new();
2122cce7d346SDag-Erling Smørgrav 
2123cce7d346SDag-Erling Smørgrav 	jpake_step1(pctx->grp,
2124cce7d346SDag-Erling Smørgrav 	    &pctx->server_id, &pctx->server_id_len,
2125cce7d346SDag-Erling Smørgrav 	    &pctx->x3, &pctx->x4, &pctx->g_x3, &pctx->g_x4,
2126cce7d346SDag-Erling Smørgrav 	    &x3_proof, &x3_proof_len,
2127cce7d346SDag-Erling Smørgrav 	    &x4_proof, &x4_proof_len);
2128cce7d346SDag-Erling Smørgrav 
2129cce7d346SDag-Erling Smørgrav 	JPAKE_DEBUG_CTX((pctx, "step1 done in %s", __func__));
2130cce7d346SDag-Erling Smørgrav 
2131cce7d346SDag-Erling Smørgrav 	buffer_clear(m);
2132cce7d346SDag-Erling Smørgrav 
2133cce7d346SDag-Erling Smørgrav 	buffer_put_string(m, pctx->server_id, pctx->server_id_len);
2134cce7d346SDag-Erling Smørgrav 	buffer_put_bignum2(m, pctx->g_x3);
2135cce7d346SDag-Erling Smørgrav 	buffer_put_bignum2(m, pctx->g_x4);
2136cce7d346SDag-Erling Smørgrav 	buffer_put_string(m, x3_proof, x3_proof_len);
2137cce7d346SDag-Erling Smørgrav 	buffer_put_string(m, x4_proof, x4_proof_len);
2138cce7d346SDag-Erling Smørgrav 
2139cce7d346SDag-Erling Smørgrav 	debug3("%s: sending step1", __func__);
2140cce7d346SDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_JPAKE_STEP1, m);
2141cce7d346SDag-Erling Smørgrav 
2142cce7d346SDag-Erling Smørgrav 	bzero(x3_proof, x3_proof_len);
2143cce7d346SDag-Erling Smørgrav 	bzero(x4_proof, x4_proof_len);
2144cce7d346SDag-Erling Smørgrav 	xfree(x3_proof);
2145cce7d346SDag-Erling Smørgrav 	xfree(x4_proof);
2146cce7d346SDag-Erling Smørgrav 
2147cce7d346SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_JPAKE_GET_PWDATA, 1);
2148cce7d346SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_JPAKE_STEP1, 0);
2149cce7d346SDag-Erling Smørgrav 
2150cce7d346SDag-Erling Smørgrav 	return 0;
2151cce7d346SDag-Erling Smørgrav }
2152cce7d346SDag-Erling Smørgrav 
2153cce7d346SDag-Erling Smørgrav int
2154cce7d346SDag-Erling Smørgrav mm_answer_jpake_get_pwdata(int sock, Buffer *m)
2155cce7d346SDag-Erling Smørgrav {
2156cce7d346SDag-Erling Smørgrav 	struct jpake_ctx *pctx = authctxt->jpake_ctx;
2157cce7d346SDag-Erling Smørgrav 	char *hash_scheme, *salt;
2158cce7d346SDag-Erling Smørgrav 
2159cce7d346SDag-Erling Smørgrav 	if (pctx == NULL)
2160cce7d346SDag-Erling Smørgrav 		fatal("%s: pctx == NULL", __func__);
2161cce7d346SDag-Erling Smørgrav 
2162cce7d346SDag-Erling Smørgrav 	auth2_jpake_get_pwdata(authctxt, &pctx->s, &hash_scheme, &salt);
2163cce7d346SDag-Erling Smørgrav 
2164cce7d346SDag-Erling Smørgrav 	buffer_clear(m);
2165cce7d346SDag-Erling Smørgrav 	/* pctx->s is sensitive, not returned to slave */
2166cce7d346SDag-Erling Smørgrav 	buffer_put_cstring(m, hash_scheme);
2167cce7d346SDag-Erling Smørgrav 	buffer_put_cstring(m, salt);
2168cce7d346SDag-Erling Smørgrav 
2169cce7d346SDag-Erling Smørgrav 	debug3("%s: sending pwdata", __func__);
2170cce7d346SDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_JPAKE_GET_PWDATA, m);
2171cce7d346SDag-Erling Smørgrav 
2172cce7d346SDag-Erling Smørgrav 	bzero(hash_scheme, strlen(hash_scheme));
2173cce7d346SDag-Erling Smørgrav 	bzero(salt, strlen(salt));
2174cce7d346SDag-Erling Smørgrav 	xfree(hash_scheme);
2175cce7d346SDag-Erling Smørgrav 	xfree(salt);
2176cce7d346SDag-Erling Smørgrav 
2177cce7d346SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_JPAKE_STEP2, 1);
2178cce7d346SDag-Erling Smørgrav 
2179cce7d346SDag-Erling Smørgrav 	return 0;
2180cce7d346SDag-Erling Smørgrav }
2181cce7d346SDag-Erling Smørgrav 
2182cce7d346SDag-Erling Smørgrav int
2183cce7d346SDag-Erling Smørgrav mm_answer_jpake_step2(int sock, Buffer *m)
2184cce7d346SDag-Erling Smørgrav {
2185cce7d346SDag-Erling Smørgrav 	struct jpake_ctx *pctx = authctxt->jpake_ctx;
2186cce7d346SDag-Erling Smørgrav 	u_char *x1_proof, *x2_proof, *x4_s_proof;
2187cce7d346SDag-Erling Smørgrav 	u_int x1_proof_len, x2_proof_len, x4_s_proof_len;
2188cce7d346SDag-Erling Smørgrav 
2189cce7d346SDag-Erling Smørgrav 	if (pctx == NULL)
2190cce7d346SDag-Erling Smørgrav 		fatal("%s: pctx == NULL", __func__);
2191cce7d346SDag-Erling Smørgrav 
2192cce7d346SDag-Erling Smørgrav 	if ((pctx->g_x1 = BN_new()) == NULL ||
2193cce7d346SDag-Erling Smørgrav 	    (pctx->g_x2 = BN_new()) == NULL)
2194cce7d346SDag-Erling Smørgrav 		fatal("%s: BN_new", __func__);
2195cce7d346SDag-Erling Smørgrav 	buffer_get_bignum2(m, pctx->g_x1);
2196cce7d346SDag-Erling Smørgrav 	buffer_get_bignum2(m, pctx->g_x2);
2197cce7d346SDag-Erling Smørgrav 	pctx->client_id = buffer_get_string(m, &pctx->client_id_len);
2198cce7d346SDag-Erling Smørgrav 	x1_proof = buffer_get_string(m, &x1_proof_len);
2199cce7d346SDag-Erling Smørgrav 	x2_proof = buffer_get_string(m, &x2_proof_len);
2200cce7d346SDag-Erling Smørgrav 
2201cce7d346SDag-Erling Smørgrav 	jpake_step2(pctx->grp, pctx->s, pctx->g_x3,
2202cce7d346SDag-Erling Smørgrav 	    pctx->g_x1, pctx->g_x2, pctx->x4,
2203cce7d346SDag-Erling Smørgrav 	    pctx->client_id, pctx->client_id_len,
2204cce7d346SDag-Erling Smørgrav 	    pctx->server_id, pctx->server_id_len,
2205cce7d346SDag-Erling Smørgrav 	    x1_proof, x1_proof_len,
2206cce7d346SDag-Erling Smørgrav 	    x2_proof, x2_proof_len,
2207cce7d346SDag-Erling Smørgrav 	    &pctx->b,
2208cce7d346SDag-Erling Smørgrav 	    &x4_s_proof, &x4_s_proof_len);
2209cce7d346SDag-Erling Smørgrav 
2210cce7d346SDag-Erling Smørgrav 	JPAKE_DEBUG_CTX((pctx, "step2 done in %s", __func__));
2211cce7d346SDag-Erling Smørgrav 
2212cce7d346SDag-Erling Smørgrav 	bzero(x1_proof, x1_proof_len);
2213cce7d346SDag-Erling Smørgrav 	bzero(x2_proof, x2_proof_len);
2214cce7d346SDag-Erling Smørgrav 	xfree(x1_proof);
2215cce7d346SDag-Erling Smørgrav 	xfree(x2_proof);
2216cce7d346SDag-Erling Smørgrav 
2217cce7d346SDag-Erling Smørgrav 	buffer_clear(m);
2218cce7d346SDag-Erling Smørgrav 
2219cce7d346SDag-Erling Smørgrav 	buffer_put_bignum2(m, pctx->b);
2220cce7d346SDag-Erling Smørgrav 	buffer_put_string(m, x4_s_proof, x4_s_proof_len);
2221cce7d346SDag-Erling Smørgrav 
2222cce7d346SDag-Erling Smørgrav 	debug3("%s: sending step2", __func__);
2223cce7d346SDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_JPAKE_STEP2, m);
2224cce7d346SDag-Erling Smørgrav 
2225cce7d346SDag-Erling Smørgrav 	bzero(x4_s_proof, x4_s_proof_len);
2226cce7d346SDag-Erling Smørgrav 	xfree(x4_s_proof);
2227cce7d346SDag-Erling Smørgrav 
2228cce7d346SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_JPAKE_KEY_CONFIRM, 1);
2229cce7d346SDag-Erling Smørgrav 
2230cce7d346SDag-Erling Smørgrav 	return 0;
2231cce7d346SDag-Erling Smørgrav }
2232cce7d346SDag-Erling Smørgrav 
2233cce7d346SDag-Erling Smørgrav int
2234cce7d346SDag-Erling Smørgrav mm_answer_jpake_key_confirm(int sock, Buffer *m)
2235cce7d346SDag-Erling Smørgrav {
2236cce7d346SDag-Erling Smørgrav 	struct jpake_ctx *pctx = authctxt->jpake_ctx;
2237cce7d346SDag-Erling Smørgrav 	u_char *x2_s_proof;
2238cce7d346SDag-Erling Smørgrav 	u_int x2_s_proof_len;
2239cce7d346SDag-Erling Smørgrav 
2240cce7d346SDag-Erling Smørgrav 	if (pctx == NULL)
2241cce7d346SDag-Erling Smørgrav 		fatal("%s: pctx == NULL", __func__);
2242cce7d346SDag-Erling Smørgrav 
2243cce7d346SDag-Erling Smørgrav 	if ((pctx->a = BN_new()) == NULL)
2244cce7d346SDag-Erling Smørgrav 		fatal("%s: BN_new", __func__);
2245cce7d346SDag-Erling Smørgrav 	buffer_get_bignum2(m, pctx->a);
2246cce7d346SDag-Erling Smørgrav 	x2_s_proof = buffer_get_string(m, &x2_s_proof_len);
2247cce7d346SDag-Erling Smørgrav 
2248cce7d346SDag-Erling Smørgrav 	jpake_key_confirm(pctx->grp, pctx->s, pctx->a,
2249cce7d346SDag-Erling Smørgrav 	    pctx->x4, pctx->g_x3, pctx->g_x4, pctx->g_x1, pctx->g_x2,
2250cce7d346SDag-Erling Smørgrav 	    pctx->server_id, pctx->server_id_len,
2251cce7d346SDag-Erling Smørgrav 	    pctx->client_id, pctx->client_id_len,
2252cce7d346SDag-Erling Smørgrav 	    session_id2, session_id2_len,
2253cce7d346SDag-Erling Smørgrav 	    x2_s_proof, x2_s_proof_len,
2254cce7d346SDag-Erling Smørgrav 	    &pctx->k,
2255cce7d346SDag-Erling Smørgrav 	    &pctx->h_k_sid_sessid, &pctx->h_k_sid_sessid_len);
2256cce7d346SDag-Erling Smørgrav 
2257cce7d346SDag-Erling Smørgrav 	JPAKE_DEBUG_CTX((pctx, "key_confirm done in %s", __func__));
2258cce7d346SDag-Erling Smørgrav 
2259cce7d346SDag-Erling Smørgrav 	bzero(x2_s_proof, x2_s_proof_len);
2260cce7d346SDag-Erling Smørgrav 	buffer_clear(m);
2261cce7d346SDag-Erling Smørgrav 
2262cce7d346SDag-Erling Smørgrav 	/* pctx->k is sensitive, not sent */
2263cce7d346SDag-Erling Smørgrav 	buffer_put_string(m, pctx->h_k_sid_sessid, pctx->h_k_sid_sessid_len);
2264cce7d346SDag-Erling Smørgrav 
2265cce7d346SDag-Erling Smørgrav 	debug3("%s: sending confirmation hash", __func__);
2266cce7d346SDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_JPAKE_KEY_CONFIRM, m);
2267cce7d346SDag-Erling Smørgrav 
2268cce7d346SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_JPAKE_CHECK_CONFIRM, 1);
2269cce7d346SDag-Erling Smørgrav 
2270cce7d346SDag-Erling Smørgrav 	return 0;
2271cce7d346SDag-Erling Smørgrav }
2272cce7d346SDag-Erling Smørgrav 
2273cce7d346SDag-Erling Smørgrav int
2274cce7d346SDag-Erling Smørgrav mm_answer_jpake_check_confirm(int sock, Buffer *m)
2275cce7d346SDag-Erling Smørgrav {
2276cce7d346SDag-Erling Smørgrav 	int authenticated = 0;
2277cce7d346SDag-Erling Smørgrav 	u_char *peer_confirm_hash;
2278cce7d346SDag-Erling Smørgrav 	u_int peer_confirm_hash_len;
2279cce7d346SDag-Erling Smørgrav 	struct jpake_ctx *pctx = authctxt->jpake_ctx;
2280cce7d346SDag-Erling Smørgrav 
2281cce7d346SDag-Erling Smørgrav 	if (pctx == NULL)
2282cce7d346SDag-Erling Smørgrav 		fatal("%s: pctx == NULL", __func__);
2283cce7d346SDag-Erling Smørgrav 
2284cce7d346SDag-Erling Smørgrav 	peer_confirm_hash = buffer_get_string(m, &peer_confirm_hash_len);
2285cce7d346SDag-Erling Smørgrav 
2286cce7d346SDag-Erling Smørgrav 	authenticated = jpake_check_confirm(pctx->k,
2287cce7d346SDag-Erling Smørgrav 	    pctx->client_id, pctx->client_id_len,
2288cce7d346SDag-Erling Smørgrav 	    session_id2, session_id2_len,
2289cce7d346SDag-Erling Smørgrav 	    peer_confirm_hash, peer_confirm_hash_len) && authctxt->valid;
2290cce7d346SDag-Erling Smørgrav 
2291cce7d346SDag-Erling Smørgrav 	JPAKE_DEBUG_CTX((pctx, "check_confirm done in %s", __func__));
2292cce7d346SDag-Erling Smørgrav 
2293cce7d346SDag-Erling Smørgrav 	bzero(peer_confirm_hash, peer_confirm_hash_len);
2294cce7d346SDag-Erling Smørgrav 	xfree(peer_confirm_hash);
2295cce7d346SDag-Erling Smørgrav 
2296cce7d346SDag-Erling Smørgrav 	buffer_clear(m);
2297cce7d346SDag-Erling Smørgrav 	buffer_put_int(m, authenticated);
2298cce7d346SDag-Erling Smørgrav 
2299cce7d346SDag-Erling Smørgrav 	debug3("%s: sending result %d", __func__, authenticated);
2300cce7d346SDag-Erling Smørgrav 	mm_request_send(sock, MONITOR_ANS_JPAKE_CHECK_CONFIRM, m);
2301cce7d346SDag-Erling Smørgrav 
2302cce7d346SDag-Erling Smørgrav 	monitor_permit(mon_dispatch, MONITOR_REQ_JPAKE_STEP1, 1);
2303cce7d346SDag-Erling Smørgrav 
2304cce7d346SDag-Erling Smørgrav 	auth_method = "jpake-01@openssh.com";
2305cce7d346SDag-Erling Smørgrav 	return authenticated;
2306cce7d346SDag-Erling Smørgrav }
2307cce7d346SDag-Erling Smørgrav 
2308cce7d346SDag-Erling Smørgrav #endif /* JPAKE */
2309