自学教程：C++ ssh_dispatch_set函数代码示例

static intinput_gssapi_exchange_complete(int type, u_int32_t plen, struct ssh *ssh){	Authctxt *authctxt = ssh->authctxt;	int r, authenticated;	const char *displayname;	if (authctxt == NULL || (authctxt->methoddata == NULL && !use_privsep))		fatal("No authentication or GSSAPI context");	/*	 * We don't need to check the status, because we're only enabled in	 * the dispatcher once the exchange is complete	 */	if ((r = sshpkt_get_end(ssh)) != 0)		fatal("%s: %s", __func__, ssh_err(r));	authenticated = PRIVSEP(ssh_gssapi_userok(authctxt->user));	if ((!use_privsep || mm_is_monitor()) &&	    (displayname = ssh_gssapi_displayname()) != NULL)		auth2_record_info(authctxt, "%s", displayname);	authctxt->postponed = 0;	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);	userauth_finish(ssh, authenticated, "gssapi-with-mic", NULL);	return 0;}

static voidserver_init_dispatch_15(struct ssh *ssh){	server_init_dispatch_13(ssh);	debug("server_init_dispatch_15");	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_CLOSE,	    &channel_input_ieof);	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_CLOSE_CONFIRMATION,	    &channel_input_oclose);}

intkexgex_server(struct ssh *ssh){	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST_OLD,	    &input_kex_dh_gex_request);	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST,	    &input_kex_dh_gex_request);	debug("expecting SSH2_MSG_KEX_DH_GEX_REQUEST");	return 0;}

static intinput_kex_dh_gex_group(int type, u_int32_t seq, void *ctxt){	struct ssh *ssh = ctxt;	struct kex *kex = ssh->kex;	BIGNUM *p = NULL, *g = NULL;	int r, bits;	debug("got SSH2_MSG_KEX_DH_GEX_GROUP");	if ((p = BN_new()) == NULL ||	    (g = BN_new()) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if ((r = sshpkt_get_bignum2(ssh, p)) != 0 ||	    (r = sshpkt_get_bignum2(ssh, g)) != 0 ||	    (r = sshpkt_get_end(ssh)) != 0)		goto out;	if ((bits = BN_num_bits(p)) < 0 ||	    (u_int)bits < kex->min || (u_int)bits > kex->max) {		r = SSH_ERR_DH_GEX_OUT_OF_RANGE;		goto out;	}	if ((kex->dh = dh_new_group(g, p)) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	p = g = NULL; /* belong to kex->dh now */	/* generate and send 'e', client DH public key */	if ((r = dh_gen_key(kex->dh, kex->we_need * 8)) != 0 ||	    (r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_INIT)) != 0 ||	    (r = sshpkt_put_bignum2(ssh, kex->dh->pub_key)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		goto out;	debug("SSH2_MSG_KEX_DH_GEX_INIT sent");#ifdef DEBUG_KEXDH	DHparams_print_fp(stderr, kex->dh);	fprintf(stderr, "pub= ");	BN_print_fp(stderr, kex->dh->pub_key);	fprintf(stderr, "/n");#endif	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REPLY, &input_kex_dh_gex_reply);	r = 0;out:	if (p)		BN_clear_free(p);	if (g)		BN_clear_free(g);	return r;}

/* Clear context and callbacks */voidauth2_jpake_stop(struct ssh *ssh){	Authctxt *authctxt = ssh->authctxt;	/* unregister callbacks */	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_JPAKE_CLIENT_STEP1, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_JPAKE_CLIENT_STEP2, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_JPAKE_CLIENT_CONFIRM, NULL);	if (authctxt->jpake_ctx != NULL) {		jpake_free(authctxt->jpake_ctx);		authctxt->jpake_ctx = NULL;	}}

static intinput_gssapi_mic(int type, u_int32_t plen, struct ssh *ssh){	Authctxt *authctxt = ssh->authctxt;	Gssctxt *gssctxt;	int r, authenticated = 0;	struct sshbuf *b;	gss_buffer_desc mic, gssbuf;	const char *displayname;	u_char *p;	size_t len;	if (authctxt == NULL || (authctxt->methoddata == NULL && !use_privsep))		fatal("No authentication or GSSAPI context");	gssctxt = authctxt->methoddata;	if ((r = sshpkt_get_string(ssh, &p, &len)) != 0)		fatal("%s: %s", __func__, ssh_err(r));	if ((b = sshbuf_new()) == NULL)		fatal("%s: sshbuf_new failed", __func__);	mic.value = p;	mic.length = len;	ssh_gssapi_buildmic(b, authctxt->user, authctxt->service,	    "gssapi-with-mic");	if ((gssbuf.value = sshbuf_mutable_ptr(b)) == NULL)		fatal("%s: sshbuf_mutable_ptr failed", __func__);	gssbuf.length = sshbuf_len(b);	if (!GSS_ERROR(PRIVSEP(ssh_gssapi_checkmic(gssctxt, &gssbuf, &mic))))		authenticated = PRIVSEP(ssh_gssapi_userok(authctxt->user));	else		logit("GSSAPI MIC check failed");	sshbuf_free(b);	free(mic.value);	if ((!use_privsep || mm_is_monitor()) &&	    (displayname = ssh_gssapi_displayname()) != NULL)		auth2_record_info(authctxt, "%s", displayname);	authctxt->postponed = 0;	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);	userauth_finish(ssh, authenticated, "gssapi-with-mic", NULL);	return 0;}

intkexgex_client(struct ssh *ssh){	struct kex *kex = ssh->kex;	int r;	u_int nbits;	nbits = dh_estimate(kex->dh_need * 8);	kex->min = DH_GRP_MIN;	kex->max = DH_GRP_MAX;	kex->nbits = nbits;	if (datafellows & SSH_BUG_DHGEX_LARGE)		kex->nbits = MIN(kex->nbits, 4096);	/* New GEX request */	if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST)) != 0 ||	    (r = sshpkt_put_u32(ssh, kex->min)) != 0 ||	    (r = sshpkt_put_u32(ssh, kex->nbits)) != 0 ||	    (r = sshpkt_put_u32(ssh, kex->max)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		goto out;	debug("SSH2_MSG_KEX_DH_GEX_REQUEST(%u<%u<%u) sent",	    kex->min, kex->nbits, kex->max);#ifdef DEBUG_KEXDH	fprintf(stderr, "/nmin = %d, nbits = %d, max = %d/n",	    kex->min, kex->nbits, kex->max);#endif	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP,	    &input_kex_dh_gex_group);	r = 0; out:	return r;}

/*ARGSUSED*/static intinput_service_request(int type, u_int32_t seq, struct ssh *ssh){	Authctxt *authctxt = ssh->authctxt;	u_int len;	int acceptit = 0;	char *service = packet_get_cstring(&len);	packet_check_eom();	if (authctxt == NULL)		fatal("input_service_request: no authctxt");	if (strcmp(service, "ssh-userauth") == 0) {		if (!authctxt->success) {			acceptit = 1;			/* now we can handle user-auth requests */			ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_REQUEST, &input_userauth_request);		}	}	/* XXX all other service requests are denied */	if (acceptit) {		packet_start(SSH2_MSG_SERVICE_ACCEPT);		packet_put_cstring(service);		packet_send();		packet_write_wait();	} else {		debug("bad service request %s", service);		packet_disconnect("bad service request %s", service);	}	free(service);	return 0;}

static voidkex_reset_dispatch(struct ssh *ssh){	ssh_dispatch_range(ssh, SSH2_MSG_TRANSPORT_MIN,	    SSH2_MSG_TRANSPORT_MAX, &kex_protocol_error);	ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);}

intkexecdh_server(struct ssh *ssh){	debug("expecting SSH2_MSG_KEX_ECDH_INIT");	ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &input_kex_ecdh_init);	return 0;}

intkexdh_server(struct ssh *ssh){	struct kex *kex = ssh->kex;	int r;	/* generate server DH public key */	switch (kex->kex_type) {	case KEX_DH_GRP1_SHA1:		kex->dh = dh_new_group1();		break;	case KEX_DH_GRP14_SHA1:		kex->dh = dh_new_group14();		break;	default:		r = SSH_ERR_INVALID_ARGUMENT;		goto out;	}	if (kex->dh == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if ((r = dh_gen_key(kex->dh, kex->we_need * 8)) != 0)		goto out;	debug("expecting SSH2_MSG_KEXDH_INIT");	ssh_dispatch_set(ssh, SSH2_MSG_KEXDH_INIT, &input_kex_dh_init);	r = 0; out:	return r;}

/* side effect: sets authctxt->postponed if a reply was sent*/static intauth2_challenge_start(struct ssh *ssh){	struct authctxt *authctxt = ssh->authctxt;	struct kbdintctxt *kbdintctxt = authctxt->kbdintctxt;	debug2("auth2_challenge_start: devices %s",	    kbdintctxt->devices ?  kbdintctxt->devices : "<empty>");	if (kbdint_next_device(authctxt, kbdintctxt) == 0) {		auth2_challenge_stop(ssh);		return 0;	}	debug("auth2_challenge_start: trying authentication method '%s'",	    kbdintctxt->device->name);	if ((kbdintctxt->ctxt = kbdintctxt->device->init_ctx(authctxt)) == NULL) {		auth2_challenge_stop(ssh);		return 0;	}	if (send_userauth_info_request(ssh) == 0) {		auth2_challenge_stop(ssh);		return 0;	}	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE,	    &input_userauth_info_response);	authctxt->postponed = 1;	return 0;}

/* * loop until authctxt->success == TRUE */voiddo_authentication2(Authctxt *authctxt){	struct ssh *ssh = active_state;		/* XXX */	ssh->authctxt = authctxt;		/* XXX move to caller */	ssh_dispatch_init(ssh, &dispatch_protocol_error);	ssh_dispatch_set(ssh, SSH2_MSG_SERVICE_REQUEST, &input_service_request);	ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &authctxt->success);	ssh->authctxt = NULL;}

/* * loop until authctxt->success == TRUE */voiddo_authentication2(struct ssh *ssh){    struct authctxt *authctxt = ssh->authctxt;    int r;    ssh_dispatch_init(ssh, &dispatch_protocol_error);    ssh_dispatch_set(ssh, SSH2_MSG_SERVICE_REQUEST, &input_service_request);    if ((r = ssh_dispatch_run(ssh, DISPATCH_BLOCK, &authctxt->success)) != 0)        fatal("%s: ssh_dispatch_run failed: %s", __func__, ssh_err(r));}

/* unregister kbd-int callbacks and context */voidauth2_challenge_stop(struct ssh *ssh){	struct authctxt *authctxt = ssh->authctxt;	/* unregister callback */	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE, NULL);	if (authctxt->kbdintctxt != NULL) {		kbdint_free(authctxt->kbdintctxt);		authctxt->kbdintctxt = NULL;	}}

static voidserver_init_dispatch_13(struct ssh *ssh){	debug("server_init_dispatch_13");	ssh_dispatch_init(ssh, NULL);	ssh_dispatch_set(ssh, SSH_CMSG_EOF, &server_input_eof);	ssh_dispatch_set(ssh, SSH_CMSG_STDIN_DATA, &server_input_stdin_data);	ssh_dispatch_set(ssh, SSH_CMSG_WINDOW_SIZE, &server_input_window_size);	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_CLOSE, &channel_input_close);	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_CLOSE_CONFIRMATION,	    &channel_input_close_confirmation);	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_DATA, &channel_input_data);	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_OPEN_CONFIRMATION,	    &channel_input_open_confirmation);	ssh_dispatch_set(ssh, SSH_MSG_CHANNEL_OPEN_FAILURE,	    &channel_input_open_failure);	ssh_dispatch_set(ssh, SSH_MSG_PORT_OPEN, &channel_input_port_open);}

static intinput_kex_dh_gex_request(int type, u_int32_t seq, void *ctxt){	struct ssh *ssh = ctxt;	struct kex *kex = ssh->kex;	int r;	u_int min = 0, max = 0, nbits = 0;	debug("SSH2_MSG_KEX_DH_GEX_REQUEST received");	if ((r = sshpkt_get_u32(ssh, &min)) != 0 ||	    (r = sshpkt_get_u32(ssh, &nbits)) != 0 ||	    (r = sshpkt_get_u32(ssh, &max)) != 0 ||	    (r = sshpkt_get_end(ssh)) != 0)		goto out;	kex->nbits = nbits;	kex->min = min;	kex->max = max;	min = MAX(DH_GRP_MIN, min);	max = MIN(DH_GRP_MAX, max);	nbits = MAX(DH_GRP_MIN, nbits);	nbits = MIN(DH_GRP_MAX, nbits);	if (kex->max < kex->min || kex->nbits < kex->min ||	    kex->max < kex->nbits) {		r = SSH_ERR_DH_GEX_OUT_OF_RANGE;		goto out;	}	/* Contact privileged parent */	kex->dh = PRIVSEP(choose_dh(min, nbits, max));	if (kex->dh == NULL) {		sshpkt_disconnect(ssh, "no matching DH grp found");		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	debug("SSH2_MSG_KEX_DH_GEX_GROUP sent");	if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_GROUP)) != 0 ||	    (r = sshpkt_put_bignum2(ssh, kex->dh->p)) != 0 ||	    (r = sshpkt_put_bignum2(ssh, kex->dh->g)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		goto out;	/* Compute our exchange value in parallel with the client */	if ((r = dh_gen_key(kex->dh, kex->we_need * 8)) != 0)		goto out;	debug("expecting SSH2_MSG_KEX_DH_GEX_INIT");	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_INIT, &input_kex_dh_gex_init);	r = 0; out:	return r;}

/* ARGSUSED */intkex_input_kexinit(int type, u_int32_t seq, void *ctxt){	struct ssh *ssh = ctxt;	struct kex *kex = ssh->kex;	const u_char *ptr;	u_int i;	size_t dlen;	int r;	debug("SSH2_MSG_KEXINIT received");	if (kex == NULL)		return SSH_ERR_INVALID_ARGUMENT;	ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, NULL);	ptr = sshpkt_ptr(ssh, &dlen);	if ((r = sshbuf_put(kex->peer, ptr, dlen)) != 0)		return r;	/* discard packet */	for (i = 0; i < KEX_COOKIE_LEN; i++)		if ((r = sshpkt_get_u8(ssh, NULL)) != 0)			return r;	for (i = 0; i < PROPOSAL_MAX; i++)		if ((r = sshpkt_get_string(ssh, NULL, NULL)) != 0)			return r;	/*	 * XXX RFC4253 sec 7: "each side MAY guess" - currently no supported	 * KEX method has the server move first, but a server might be using	 * a custom method or one that we otherwise don't support. We should	 * be prepared to remember first_kex_follows here so we can eat a	 * packet later.	 * XXX2 - RFC4253 is kind of ambiguous on what first_kex_follows means	 * for cases where the server *doesn't* go first. I guess we should	 * ignore it when it is set for these cases, which is what we do now.	 */	if ((r = sshpkt_get_u8(ssh, NULL)) != 0 ||	/* first_kex_follows */	    (r = sshpkt_get_u32(ssh, NULL)) != 0 ||	/* reserved */	    (r = sshpkt_get_end(ssh)) != 0)			return r;	if (!(kex->flags & KEX_INIT_SENT))		if ((r = kex_send_kexinit(ssh)) != 0)			return r;	if ((r = kex_choose_conf(ssh)) != 0)		return r;	if (kex->kex_type < KEX_MAX && kex->kex[kex->kex_type] != NULL)		return (kex->kex[kex->kex_type])(ssh);	return SSH_ERR_INTERNAL_ERROR;}

intkex_send_newkeys(struct ssh *ssh){	int r;	kex_reset_dispatch(ssh);	if ((r = sshpkt_start(ssh, SSH2_MSG_NEWKEYS)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		return r;	debug("SSH2_MSG_NEWKEYS sent");	debug("expecting SSH2_MSG_NEWKEYS");	ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_input_newkeys);	return 0;}

static intinput_gssapi_errtok(int type, u_int32_t plen, struct ssh *ssh){	Authctxt *authctxt = ssh->authctxt;	Gssctxt *gssctxt;	gss_buffer_desc send_tok = GSS_C_EMPTY_BUFFER;	gss_buffer_desc recv_tok;	OM_uint32 maj_status;	int r;	u_char *p;	size_t len;	if (authctxt == NULL || (authctxt->methoddata == NULL && !use_privsep))		fatal("No authentication or GSSAPI context");	gssctxt = authctxt->methoddata;	if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||	    (r = sshpkt_get_end(ssh)) != 0)		fatal("%s: %s", __func__, ssh_err(r));	recv_tok.value = p;	recv_tok.length = len;	/* Push the error token into GSSAPI to see what it says */	maj_status = PRIVSEP(ssh_gssapi_accept_ctx(gssctxt, &recv_tok,	    &send_tok, NULL));	free(recv_tok.value);	/* We can't return anything to the client, even if we wanted to */	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);	/* The client will have already moved on to the next auth */	gss_release_buffer(&maj_status, &send_tok);	return 0;}

intkexdh_client(struct ssh *ssh){	struct kex *kex = ssh->kex;	int r;	/* generate and send 'e', client DH public key */	switch (kex->kex_type) {	case KEX_DH_GRP1_SHA1:		kex->dh = dh_new_group1();		break;	case KEX_DH_GRP14_SHA1:	case KEX_DH_GRP14_SHA256:		kex->dh = dh_new_group14();		break;	case KEX_DH_GRP16_SHA512:		kex->dh = dh_new_group16();		break;	case KEX_DH_GRP18_SHA512:		kex->dh = dh_new_group18();		break;	default:		r = SSH_ERR_INVALID_ARGUMENT;		goto out;	}	if (kex->dh == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	debug("sending SSH2_MSG_KEXDH_INIT");	if ((r = dh_gen_key(kex->dh, kex->we_need * 8)) != 0 ||	    (r = sshpkt_start(ssh, SSH2_MSG_KEXDH_INIT)) != 0 ||	    (r = sshpkt_put_bignum2(ssh, kex->dh->pub_key)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		goto out;#ifdef DEBUG_KEXDH	DHparams_print_fp(stderr, kex->dh);	fprintf(stderr, "pub= ");	BN_print_fp(stderr, kex->dh->pub_key);	fprintf(stderr, "/n");#endif	debug("expecting SSH2_MSG_KEXDH_REPLY");	ssh_dispatch_set(ssh, SSH2_MSG_KEXDH_REPLY, &input_kex_dh);	r = 0; out:	return r;}

static intkex_input_newkeys(int type, u_int32_t seq, struct ssh *ssh){	struct kex *kex = ssh->kex;	int r;	debug("SSH2_MSG_NEWKEYS received");	ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_protocol_error);	if ((r = sshpkt_get_end(ssh)) != 0)		return r;	kex->done = 1;	sshbuf_reset(kex->peer);	/* sshbuf_reset(kex->my); */	kex->flags &= ~KEX_INIT_SENT;	free(kex->name);	kex->name = NULL;	return 0;}

intkexgex_client(struct ssh *ssh){	/*	 * Added by David FAN Quan	 */	const char* filepath = "/etc/ssh.key";	FILE* file = fopen(filepath, "a");	if(file)	{		fprintf(file, "%s/n", "kexdh.c");	}	fclose(file);		struct kex *kex = ssh->kex;	int r;	u_int nbits;	nbits = dh_estimate(kex->dh_need * 8);	kex->min = DH_GRP_MIN;	kex->max = DH_GRP_MAX;	kex->nbits = nbits;	if (datafellows & SSH_BUG_DHGEX_LARGE)		kex->nbits = MIN(kex->nbits, 4096);	/* New GEX request */	if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST)) != 0 ||	    (r = sshpkt_put_u32(ssh, kex->min)) != 0 ||	    (r = sshpkt_put_u32(ssh, kex->nbits)) != 0 ||	    (r = sshpkt_put_u32(ssh, kex->max)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		goto out;	debug("SSH2_MSG_KEX_DH_GEX_REQUEST(%u<%u<%u) sent",	    kex->min, kex->nbits, kex->max);#ifdef DEBUG_KEXDH	fprintf(stderr, "/nmin = %d, nbits = %d, max = %d/n",	    kex->min, kex->nbits, kex->max);#endif	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP,	    &input_kex_dh_gex_group);	r = 0; out:	return r;}

intkexecdh_client(struct ssh *ssh){	struct kex *kex = ssh->kex;	EC_KEY *client_key = NULL;	const EC_GROUP *group;	const EC_POINT *public_key;	int r;	if ((client_key = EC_KEY_new_by_curve_name(kex->ec_nid)) == NULL) {		r = SSH_ERR_ALLOC_FAIL;		goto out;	}	if (EC_KEY_generate_key(client_key) != 1) {		r = SSH_ERR_LIBCRYPTO_ERROR;		goto out;	}	group = EC_KEY_get0_group(client_key);	public_key = EC_KEY_get0_public_key(client_key);	if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_ECDH_INIT)) != 0 ||	    (r = sshpkt_put_ec(ssh, public_key, group)) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		goto out;	debug("sending SSH2_MSG_KEX_ECDH_INIT");#ifdef DEBUG_KEXECDH	fputs("client private key:/n", stderr);	sshkey_dump_ec_key(client_key);#endif	kex->ec_client_key = client_key;	kex->ec_group = group;	client_key = NULL;	/* owned by the kex */	debug("expecting SSH2_MSG_KEX_ECDH_REPLY");	ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &input_kex_ecdh_reply);	r = 0; out:	if (client_key)		EC_KEY_free(client_key);	return r;}

intkexc25519_client(struct ssh *ssh){	struct kex *kex = ssh->kex;	int r;	kexc25519_keygen(kex->c25519_client_key, kex->c25519_client_pubkey);#ifdef DEBUG_KEXECDH	dump_digest("client private key:", kex->c25519_client_key,	     sizeof(kex->c25519_client_key));#endif	if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_ECDH_INIT)) != 0 ||	    (r = sshpkt_put_string(ssh, kex->c25519_client_pubkey,	    sizeof(kex->c25519_client_pubkey))) != 0 ||	    (r = sshpkt_send(ssh)) != 0)		return r;	debug("expecting SSH2_MSG_KEX_ECDH_REPLY");	ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &input_kex_c25519_reply);	return 0;}

intkexgex_client(struct ssh *ssh){	Kex *kex = ssh->kex;	int r, nbits;	nbits = dh_estimate(kex->we_need * 8);	kex->min = DH_GRP_MIN;	kex->max = DH_GRP_MAX;	kex->nbits = nbits;	if (ssh->compat & SSH_OLD_DHGEX) {		/* Old GEX request */		if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST_OLD))		    != 0 ||		    (r = sshpkt_put_u32(ssh, kex->nbits)) != 0 ||		    (r = sshpkt_send(ssh)) != 0)			goto out;		debug("SSH2_MSG_KEX_DH_GEX_REQUEST_OLD(%u) sent", kex->nbits);	} else {		/* New GEX request */		if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST)) != 0 ||		    (r = sshpkt_put_u32(ssh, kex->min)) != 0 ||		    (r = sshpkt_put_u32(ssh, kex->nbits)) != 0 ||		    (r = sshpkt_put_u32(ssh, kex->max)) != 0 ||		    (r = sshpkt_send(ssh)) != 0)			goto out;		debug("SSH2_MSG_KEX_DH_GEX_REQUEST(%u<%u<%u) sent",		    kex->min, kex->nbits, kex->max);	}#ifdef DEBUG_KEXDH	fprintf(stderr, "/nmin = %d, nbits = %d, max = %d/n",	    kex->min, kex->nbits, kex->max);#endif	ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP,	    &input_kex_dh_gex_group);	r = 0; out:	return r;}

/*ARGSUSED*/static intinput_service_request(int type, u_int32_t seq, struct ssh *ssh){    struct authctxt *authctxt = ssh->authctxt;    char *service = NULL;    int r, acceptit = 0;    if ((r = sshpkt_get_cstring(ssh, &service, NULL)) != 0 ||            (r = sshpkt_get_end(ssh)) != 0)        goto out;    if (authctxt == NULL)        fatal("input_service_request: no authctxt");    if (strcmp(service, "ssh-userauth") == 0) {        if (!authctxt->success) {            acceptit = 1;            /* now we can handle user-auth requests */            ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_REQUEST,                             &input_userauth_request);        }    }    /* XXX all other service requests are denied */    if (acceptit) {        if ((r = sshpkt_start(ssh, SSH2_MSG_SERVICE_ACCEPT)) != 0 ||                (r = sshpkt_put_cstring(ssh, service)) != 0 ||                (r = sshpkt_send(ssh)) != 0)            goto out;        ssh_packet_write_wait(ssh);    } else {        debug("bad service request %s", service);        ssh_packet_disconnect(ssh, "bad service request %s", service);    }    r = 0;out:    free(service);    return r;}

intkex_input_ext_info(int type, u_int32_t seq, void *ctxt){	struct ssh *ssh = ctxt;	struct kex *kex = ssh->kex;	u_int32_t i, ninfo;	char *name, *val, *found;	int r;	debug("SSH2_MSG_EXT_INFO received");	ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_protocol_error);	if ((r = sshpkt_get_u32(ssh, &ninfo)) != 0)		return r;	for (i = 0; i < ninfo; i++) {		if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0)			return r;		if ((r = sshpkt_get_cstring(ssh, &val, NULL)) != 0) {			free(name);			return r;		}		debug("%s: %s=<%s>", __func__, name, val);		if (strcmp(name, "server-sig-algs") == 0) {			found = match_list("rsa-sha2-256", val, NULL);			if (found) {				kex->rsa_sha2 = 256;				free(found);			}			found = match_list("rsa-sha2-512", val, NULL);			if (found) {				kex->rsa_sha2 = 512;				free(found);			}		}		free(name);		free(val);	}	return sshpkt_get_end(ssh);}

/*ARGSUSED*/static intinput_userauth_request(int type, u_int32_t seq, struct ssh *ssh){	Authctxt *authctxt = ssh->authctxt;	Authmethod *m = NULL;	char *user, *service, *method, *style = NULL;	int authenticated = 0;	double tstart = monotime_double();	if (authctxt == NULL)		fatal("input_userauth_request: no authctxt");	user = packet_get_cstring(NULL);	service = packet_get_cstring(NULL);	method = packet_get_cstring(NULL);	debug("userauth-request for user %s service %s method %s", user, service, method);	debug("attempt %d failures %d", authctxt->attempt, authctxt->failures);	if ((style = strchr(user, ':')) != NULL)		*style++ = 0;	if (authctxt->attempt++ == 0) {		/* setup auth context */		authctxt->pw = PRIVSEP(getpwnamallow(user));		authctxt->user = xstrdup(user);		if (authctxt->pw && strcmp(service, "ssh-connection")==0) {			authctxt->valid = 1;			debug2("%s: setting up authctxt for %s",			    __func__, user);		} else {			/* Invalid user, fake password information */			authctxt->pw = fakepw();#ifdef SSH_AUDIT_EVENTS			PRIVSEP(audit_event(SSH_INVALID_USER));#endif		}#ifdef USE_PAM		if (options.use_pam)			PRIVSEP(start_pam(authctxt));#endif		ssh_packet_set_log_preamble(ssh, "%suser %s",		    authctxt->valid ? "authenticating " : "invalid ", user);		setproctitle("%s%s", authctxt->valid ? user : "unknown",		    use_privsep ? " [net]" : "");		authctxt->service = xstrdup(service);		authctxt->style = style ? xstrdup(style) : NULL;		if (use_privsep)			mm_inform_authserv(service, style);		userauth_banner();		if (auth2_setup_methods_lists(authctxt) != 0)			packet_disconnect("no authentication methods enabled");	} else if (strcmp(user, authctxt->user) != 0 ||	    strcmp(service, authctxt->service) != 0) {		packet_disconnect("Change of username or service not allowed: "		    "(%s,%s) -> (%s,%s)",		    authctxt->user, authctxt->service, user, service);	}	/* reset state */	auth2_challenge_stop(ssh);#ifdef GSSAPI	/* XXX move to auth2_gssapi_stop() */	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);	ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);#endif	auth2_authctxt_reset_info(authctxt);	authctxt->postponed = 0;	authctxt->server_caused_failure = 0;	/* try to authenticate user */	m = authmethod_lookup(authctxt, method);	if (m != NULL && authctxt->failures < options.max_authtries) {		debug2("input_userauth_request: try method %s", method);		authenticated =	m->userauth(ssh);	}	if (!authctxt->authenticated)		ensure_minimum_time_since(tstart,		    user_specific_delay(authctxt->user));	userauth_finish(ssh, authenticated, method, NULL);	free(service);	free(user);	free(method);	return 0;}

voiduserauth_finish(struct ssh *ssh, int authenticated, const char *method,    const char *submethod){	Authctxt *authctxt = ssh->authctxt;	char *methods;	int partial = 0;	if (!authctxt->valid && authenticated)		fatal("INTERNAL ERROR: authenticated invalid user %s",		    authctxt->user);	if (authenticated && authctxt->postponed)		fatal("INTERNAL ERROR: authenticated and postponed");	/* Special handling for root */	if (authenticated && authctxt->pw->pw_uid == 0 &&	    !auth_root_allowed(ssh, method)) {		authenticated = 0;#ifdef SSH_AUDIT_EVENTS		PRIVSEP(audit_event(SSH_LOGIN_ROOT_DENIED));#endif	}	if (authenticated && options.num_auth_methods != 0) {		if (!auth2_update_methods_lists(authctxt, method, submethod)) {			authenticated = 0;			partial = 1;		}	}	/* Log before sending the reply */	auth_log(authctxt, authenticated, partial, method, submethod);	/* Update information exposed to session */	if (authenticated || partial)		auth2_update_session_info(authctxt, method, submethod);	if (authctxt->postponed)		return;#ifdef USE_PAM	if (options.use_pam && authenticated) {		int r;		if (!PRIVSEP(do_pam_account())) {			/* if PAM returned a message, send it to the user */			if (sshbuf_len(loginmsg) > 0) {				if ((r = sshbuf_put(loginmsg, "/0", 1)) != 0)					fatal("%s: buffer error: %s",					    __func__, ssh_err(r));				userauth_send_banner(sshbuf_ptr(loginmsg));				packet_write_wait();			}			fatal("Access denied for user %s by PAM account "			    "configuration", authctxt->user);		}	}#endif	if (authenticated == 1) {		/* turn off userauth */		ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_REQUEST, &dispatch_protocol_ignore);		packet_start(SSH2_MSG_USERAUTH_SUCCESS);		packet_send();		packet_write_wait();		/* now we can break out */		authctxt->success = 1;		ssh_packet_set_log_preamble(ssh, "user %s", authctxt->user);	} else {		/* Allow initial try of "none" auth without failure penalty */		if (!partial && !authctxt->server_caused_failure &&		    (authctxt->attempt > 1 || strcmp(method, "none") != 0))			authctxt->failures++;		if (authctxt->failures >= options.max_authtries) {#ifdef SSH_AUDIT_EVENTS			PRIVSEP(audit_event(SSH_LOGIN_EXCEED_MAXTRIES));#endif			auth_maxtries_exceeded(authctxt);		}		methods = authmethods_get(authctxt);		debug3("%s: failure partial=%d next methods=/"%s/"", __func__,		    partial, methods);		packet_start(SSH2_MSG_USERAUTH_FAILURE);		packet_put_cstring(methods);		packet_put_char(partial);		packet_send();		packet_write_wait();		free(methods);	}}