[auth1.c auth-rsa.c channels.c dispatch.c kex.c kexdh.c kexgex.c packet.c packet.h serverloop.c session.c ssh.c sshconnect1.c sshconnect2.c sshd.c]
packet_read* no longer return the packet length, since it's not used.
- markus@cvs.openbsd.org 2001/12/28 14:13:13
[bufaux.c bufaux.h packet.c]
buffer_get_bignum: int -> void
+ - markus@cvs.openbsd.org 2001/12/28 14:50:54
+ [auth1.c auth-rsa.c channels.c dispatch.c kex.c kexdh.c kexgex.c]
+ [packet.c packet.h serverloop.c session.c ssh.c sshconnect1.c]
+ [sshconnect2.c sshd.c]
+ packet_read* no longer return the packet length, since it's not used.
20020121
*/
#include "includes.h"
-RCSID("$OpenBSD: auth-rsa.c,v 1.49 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: auth-rsa.c,v 1.50 2001/12/28 14:50:54 markus Exp $");
#include <openssl/rsa.h>
#include <openssl/md5.h>
u_char buf[32], mdbuf[16], response[16];
MD5_CTX md;
u_int i;
- int plen, len;
+ int len;
if ((encrypted_challenge = BN_new()) == NULL)
fatal("auth_rsa_challenge_dialog: BN_new() failed");
packet_write_wait();
/* Wait for a response. */
- packet_read_expect(&plen, SSH_CMSG_AUTH_RSA_RESPONSE);
+ packet_read_expect(SSH_CMSG_AUTH_RSA_RESPONSE);
for (i = 0; i < 16; i++)
response[i] = packet_get_char();
packet_check_eom();
*/
#include "includes.h"
-RCSID("$OpenBSD: auth1.c,v 1.33 2001/12/28 13:57:33 markus Exp $");
+RCSID("$OpenBSD: auth1.c,v 1.34 2001/12/28 14:50:54 markus Exp $");
#include "xmalloc.h"
#include "rsa.h"
char *client_user, *password;
char info[1024];
u_int dlen;
- int plen;
u_int ulen;
int type = 0;
struct passwd *pw = authctxt->pw;
info[0] = '\0';
/* Get a packet from the client. */
- type = packet_read(&plen);
+ type = packet_read();
/* Process the packet. */
switch (type) {
{
Authctxt *authctxt;
struct passwd *pw;
- int plen;
u_int ulen;
char *p, *user, *style = NULL;
/* Get the name of the user that we wish to log in as. */
- packet_read_expect(&plen, SSH_CMSG_USER);
+ packet_read_expect(SSH_CMSG_USER);
/* Get the user name. */
user = packet_get_string(&ulen);
*/
#include "includes.h"
-RCSID("$OpenBSD: channels.c,v 1.152 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: channels.c,v 1.153 2001/12/28 14:50:54 markus Exp $");
#include "ssh.h"
#include "ssh1.h"
channel_request_remote_forwarding(u_short listen_port,
const char *host_to_connect, u_short port_to_connect)
{
- int payload_len, type, success = 0;
+ int type, success = 0;
/* Record locally that connection to this host/port is permitted. */
if (num_permitted_opens >= SSH_MAX_FORWARDS_PER_DIRECTION)
packet_write_wait();
/* Wait for response from the remote side. */
- type = packet_read(&payload_len);
+ type = packet_read();
switch (type) {
case SSH_SMSG_SUCCESS:
success = 1;
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "includes.h"
-RCSID("$OpenBSD: dispatch.c,v 1.12 2001/12/20 22:50:24 djm Exp $");
+RCSID("$OpenBSD: dispatch.c,v 1.13 2001/12/28 14:50:54 markus Exp $");
#include "ssh1.h"
#include "ssh2.h"
dispatch_run(int mode, int *done, void *ctxt)
{
for (;;) {
- int plen;
int type;
u_int32_t seqnr;
if (mode == DISPATCH_BLOCK) {
- type = packet_read_seqnr(&plen, &seqnr);
+ type = packet_read_seqnr(&seqnr);
} else {
- type = packet_read_poll_seqnr(&plen, &seqnr);
+ type = packet_read_poll_seqnr(&seqnr);
if (type == SSH_MSG_NONE)
return;
}
if (type > 0 && type < DISPATCH_MAX && dispatch[type] != NULL)
- (*dispatch[type])(type, plen, seqnr, ctxt);
+ (*dispatch[type])(type, 1234, seqnr, ctxt);
else
packet_disconnect("protocol error: rcvd type %d", type);
if (done != NULL && *done)
*/
#include "includes.h"
-RCSID("$OpenBSD: kex.c,v 1.39 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: kex.c,v 1.40 2001/12/28 14:50:54 markus Exp $");
#include <openssl/crypto.h>
void
kex_finish(Kex *kex)
{
- int plen;
-
kex_clear_dispatch();
packet_start(SSH2_MSG_NEWKEYS);
debug("SSH2_MSG_NEWKEYS sent");
debug("waiting for SSH2_MSG_NEWKEYS");
- packet_read_expect(&plen, SSH2_MSG_NEWKEYS);
+ packet_read_expect(SSH2_MSG_NEWKEYS);
debug("SSH2_MSG_NEWKEYS received");
kex->done = 1;
*/
#include "includes.h"
-RCSID("$OpenBSD: kexdh.c,v 1.11 2001/12/28 13:57:33 markus Exp $");
+RCSID("$OpenBSD: kexdh.c,v 1.12 2001/12/28 14:50:54 markus Exp $");
#include <openssl/crypto.h>
#include <openssl/bn.h>
u_char *server_host_key_blob = NULL, *signature = NULL;
u_char *kbuf, *hash;
u_int klen, kout, slen, sbloblen;
- int plen;
/* generate and send 'e', client DH public key */
dh = dh_new_group1();
#endif
debug("expecting SSH2_MSG_KEXDH_REPLY");
- packet_read_expect(&plen, SSH2_MSG_KEXDH_REPLY);
+ packet_read_expect(SSH2_MSG_KEXDH_REPLY);
/* key, cert */
server_host_key_blob = packet_get_string(&sbloblen);
Key *server_host_key;
u_char *kbuf, *hash, *signature = NULL, *server_host_key_blob = NULL;
u_int sbloblen, klen, kout;
- int slen, plen;
+ int slen;
/* generate server DH public key */
dh = dh_new_group1();
dh_gen_key(dh, kex->we_need * 8);
debug("expecting SSH2_MSG_KEXDH_INIT");
- packet_read_expect(&plen, SSH2_MSG_KEXDH_INIT);
+ packet_read_expect(SSH2_MSG_KEXDH_INIT);
if (kex->load_host_key == NULL)
fatal("Cannot load hostkey");
*/
#include "includes.h"
-RCSID("$OpenBSD: kexgex.c,v 1.14 2001/12/28 13:57:33 markus Exp $");
+RCSID("$OpenBSD: kexgex.c,v 1.15 2001/12/28 14:50:54 markus Exp $");
#include <openssl/bn.h>
Key *server_host_key;
u_char *kbuf, *hash, *signature = NULL, *server_host_key_blob = NULL;
u_int klen, kout, slen, sbloblen;
- int plen, min, max, nbits;
+ int min, max, nbits;
DH *dh;
nbits = dh_estimate(kex->we_need * 8);
packet_send();
debug("expecting SSH2_MSG_KEX_DH_GEX_GROUP");
- packet_read_expect(&plen, SSH2_MSG_KEX_DH_GEX_GROUP);
+ packet_read_expect(SSH2_MSG_KEX_DH_GEX_GROUP);
if ((p = BN_new()) == NULL)
fatal("BN_new");
packet_send();
debug("expecting SSH2_MSG_KEX_DH_GEX_REPLY");
- packet_read_expect(&plen, SSH2_MSG_KEX_DH_GEX_REPLY);
+ packet_read_expect(SSH2_MSG_KEX_DH_GEX_REPLY);
/* key, cert */
server_host_key_blob = packet_get_string(&sbloblen);
DH *dh = dh;
u_char *kbuf, *hash, *signature = NULL, *server_host_key_blob = NULL;
u_int sbloblen, klen, kout;
- int min = -1, max = -1, nbits = -1, type, plen, slen;
+ int min = -1, max = -1, nbits = -1, type, slen;
if (kex->load_host_key == NULL)
fatal("Cannot load hostkey");
if (server_host_key == NULL)
fatal("Unsupported hostkey type %d", kex->hostkey_type);
- type = packet_read(&plen);
+ type = packet_read();
switch (type) {
case SSH2_MSG_KEX_DH_GEX_REQUEST:
debug("SSH2_MSG_KEX_DH_GEX_REQUEST received");
dh_gen_key(dh, kex->we_need * 8);
debug("expecting SSH2_MSG_KEX_DH_GEX_INIT");
- packet_read_expect(&plen, SSH2_MSG_KEX_DH_GEX_INIT);
+ packet_read_expect(SSH2_MSG_KEX_DH_GEX_INIT);
/* key, cert */
if ((dh_client_pub = BN_new()) == NULL)
*/
#include "includes.h"
-RCSID("$OpenBSD: packet.c,v 1.81 2001/12/28 14:13:13 markus Exp $");
+RCSID("$OpenBSD: packet.c,v 1.82 2001/12/28 14:50:54 markus Exp $");
#include "xmalloc.h"
#include "buffer.h"
*/
int
-packet_read_seqnr(int *payload_len_ptr, u_int32_t *seqnr_p)
+packet_read_seqnr(u_int32_t *seqnr_p)
{
int type, len;
fd_set *setp;
/* Stay in the loop until we have received a complete packet. */
for (;;) {
/* Try to read a packet from the buffer. */
- type = packet_read_poll_seqnr(payload_len_ptr, seqnr_p);
+ type = packet_read_poll_seqnr(seqnr_p);
if (!compat20 && (
type == SSH_SMSG_SUCCESS
|| type == SSH_SMSG_FAILURE
}
int
-packet_read(int *payload_len_ptr)
+packet_read(void)
{
- return packet_read_seqnr(payload_len_ptr, NULL);
+ return packet_read_seqnr(NULL);
}
/*
*/
void
-packet_read_expect(int *payload_len_ptr, int expected_type)
+packet_read_expect(int expected_type)
{
int type;
- type = packet_read(payload_len_ptr);
+ type = packet_read();
if (type != expected_type)
packet_disconnect("Protocol error: expected packet type %d, got %d",
expected_type, type);
* SSH_MSG_DISCONNECT is handled specially here. Also,
* SSH_MSG_IGNORE messages are skipped by this function and are never returned
* to higher levels.
- *
- * The returned payload_len does include space consumed by:
- * Packet length
- * Padding
- * Packet type
- * Check bytes
*/
static int
-packet_read_poll1(int *payload_len_ptr)
+packet_read_poll1(void)
{
u_int len, padded_len;
u_char *ucp, type;
buffer_len(&compression_buffer));
}
type = buffer_get_char(&incoming_packet);
- *payload_len_ptr = buffer_len(&incoming_packet);
return type;
}
static int
-packet_read_poll2(int *payload_len_ptr, u_int32_t *seqnr_p)
+packet_read_poll2(u_int32_t *seqnr_p)
{
static u_int32_t seqnr = 0;
static u_int packet_length = 0;
type = buffer_get_char(&incoming_packet);
if (type == SSH2_MSG_NEWKEYS)
set_newkeys(MODE_IN);
- *payload_len_ptr = buffer_len(&incoming_packet);
#ifdef PACKET_DEBUG
fprintf(stderr, "read/plain[%d]:\r\n", type);
buffer_dump(&incoming_packet);
}
int
-packet_read_poll_seqnr(int *payload_len_ptr, u_int32_t *seqnr_p)
+packet_read_poll_seqnr(u_int32_t *seqnr_p)
{
int reason;
u_char type;
for (;;) {
if (compat20) {
- type = packet_read_poll2(payload_len_ptr, seqnr_p);
+ type = packet_read_poll2(seqnr_p);
if (type)
DBG(debug("received packet type %d", type));
switch (type) {
break;
}
} else {
- type = packet_read_poll1(payload_len_ptr);
+ type = packet_read_poll1();
switch (type) {
case SSH_MSG_IGNORE:
break;
}
int
-packet_read_poll(int *payload_len_ptr)
+packet_read_poll(void)
{
- return packet_read_poll_seqnr(payload_len_ptr, NULL);
+ return packet_read_poll_seqnr(NULL);
}
/*
* called by a name other than "ssh" or "Secure Shell".
*/
-/* RCSID("$OpenBSD: packet.h,v 1.31 2001/12/28 13:57:33 markus Exp $"); */
+/* RCSID("$OpenBSD: packet.h,v 1.32 2001/12/28 14:50:54 markus Exp $"); */
#ifndef PACKET_H
#define PACKET_H
void packet_put_raw(const void *buf, u_int len);
void packet_send(void);
-int packet_read(int *payload_len_ptr);
-void packet_read_expect(int *payload_len_ptr, int type);
-int packet_read_poll(int *packet_len_ptr);
+int packet_read(void);
+void packet_read_expect(int type);
+int packet_read_poll(void);
void packet_process_incoming(const char *buf, u_int len);
-int packet_read_seqnr(int *payload_len_ptr, u_int32_t *seqnr_p);
-int packet_read_poll_seqnr(int *packet_len_ptr, u_int32_t *seqnr_p);
+int packet_read_seqnr(u_int32_t *seqnr_p);
+int packet_read_poll_seqnr(u_int32_t *seqnr_p);
u_int packet_get_char(void);
u_int packet_get_int(void);
*/
#include "includes.h"
-RCSID("$OpenBSD: serverloop.c,v 1.91 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: serverloop.c,v 1.92 2001/12/28 14:50:54 markus Exp $");
#include "xmalloc.h"
#include "packet.h"
* the exit status.
*/
do {
- int plen;
- type = packet_read(&plen);
+ type = packet_read();
}
while (type != SSH_CMSG_EXIT_CONFIRMATION);
*/
#include "includes.h"
-RCSID("$OpenBSD: session.c,v 1.116 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: session.c,v 1.117 2001/12/28 14:50:54 markus Exp $");
#include "ssh.h"
#include "ssh1.h"
{
Session *s;
char *command;
- int success, type, plen, screen_flag;
+ int success, type, screen_flag;
int compression_level = 0, enable_compression_after_reply = 0;
u_int proto_len, data_len, dlen;
success = 0;
/* Get a packet from the client. */
- type = packet_read(&plen);
+ type = packet_read();
/* Process the packet. */
switch (type) {
*/
#include "includes.h"
-RCSID("$OpenBSD: ssh.c,v 1.155 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: ssh.c,v 1.156 2001/12/28 14:50:54 markus Exp $");
#include <openssl/evp.h>
#include <openssl/err.h>
ssh_session(void)
{
int type;
- int plen;
int interactive = 0;
int have_tty = 0;
struct winsize ws;
packet_put_int(options.compression_level);
packet_send();
packet_write_wait();
- type = packet_read(&plen);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
packet_start_compression(options.compression_level);
else if (type == SSH_SMSG_FAILURE)
packet_write_wait();
/* Read response from the server. */
- type = packet_read(&plen);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS) {
interactive = 1;
have_tty = 1;
x11_request_forwarding_with_spoofing(0, proto, data);
/* Read response from the server. */
- type = packet_read(&plen);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS) {
interactive = 1;
} else if (type == SSH_SMSG_FAILURE) {
auth_request_forwarding();
/* Read response from the server. */
- type = packet_read(&plen);
+ type = packet_read();
packet_check_eom();
if (type != SSH_SMSG_SUCCESS)
log("Warning: Remote host denied authentication agent forwarding.");
*/
#include "includes.h"
-RCSID("$OpenBSD: sshconnect1.c,v 1.46 2001/12/28 13:57:33 markus Exp $");
+RCSID("$OpenBSD: sshconnect1.c,v 1.47 2001/12/28 14:50:54 markus Exp $");
#include <openssl/bn.h>
#include <openssl/evp.h>
AuthenticationConnection *auth;
u_char response[16];
u_int i;
- int plen;
Key *key;
BIGNUM *challenge;
packet_write_wait();
/* Wait for server's response. */
- type = packet_read(&plen);
+ type = packet_read();
/* The server sends failure if it doesn\'t like our key or
does not support RSA authentication. */
packet_write_wait();
/* Wait for response from the server. */
- type = packet_read(&plen);
+ type = packet_read();
/* The server returns success if it accepted the authentication. */
if (type == SSH_SMSG_SUCCESS) {
BIGNUM *challenge;
Key *public, *private;
char buf[300], *passphrase, *comment, *authfile;
- int i, type, quit, plen;
+ int i, type, quit;
public = options.identity_keys[idx];
authfile = options.identity_files[idx];
packet_write_wait();
/* Wait for server's response. */
- type = packet_read(&plen);
+ type = packet_read();
/*
* The server responds with failure if it doesn\'t like our key or
packet_write_wait();
/* Expect the server to reject it... */
- packet_read_expect(&plen, SSH_SMSG_FAILURE);
+ packet_read_expect(SSH_SMSG_FAILURE);
BN_clear_free(challenge);
return 0;
}
BN_clear_free(challenge);
/* Wait for response from the server. */
- type = packet_read(&plen);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS) {
debug("RSA authentication accepted by server.");
return 1;
{
int type;
BIGNUM *challenge;
- int plen;
debug("Trying rhosts or /etc/hosts.equiv with RSA host authentication.");
packet_write_wait();
/* Wait for server's response. */
- type = packet_read(&plen);
+ type = packet_read();
/* The server responds with failure if it doesn't admit our
.rhosts authentication or doesn't know our host key. */
BN_clear_free(challenge);
/* Wait for response from the server. */
- type = packet_read(&plen);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS) {
debug("Rhosts or /etc/hosts.equiv with RSA host authentication accepted by server.");
return 1;
char inst[INST_SZ];
char *realm;
CREDENTIALS cred;
- int r, type, plen;
+ int r, type;
socklen_t slen;
Key_schedule schedule;
u_long checksum, cksum;
fatal_cleanup();
}
/* Get server reply. */
- type = packet_read(&plen);
+ type = packet_read();
switch (type) {
case SSH_SMSG_FAILURE:
/* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */
krb5_ccache ccache = NULL;
const char *remotehost;
krb5_data ap;
- int type, payload_len;
+ int type;
krb5_ap_rep_enc_part *reply = NULL;
int ret;
xfree(ap.data);
ap.length = 0;
- type = packet_read(&payload_len);
+ type = packet_read();
switch (type) {
case SSH_SMSG_FAILURE:
/* Should really be SSH_SMSG_AUTH_KERBEROS_FAILURE */
static void
send_krb5_tgt(krb5_context context, krb5_auth_context auth_context)
{
- int fd, type, payload_len;
+ int fd, type;
krb5_error_code problem;
krb5_data outbuf;
krb5_ccache ccache = NULL;
packet_send();
packet_write_wait();
- type = packet_read(&payload_len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS) {
char *pname;
CREDENTIALS *creds;
struct stat st;
char buffer[4096], pname[ANAME_SZ], pinst[INST_SZ], prealm[REALM_SZ];
- int problem, type, len;
+ int problem, type;
/* Don't do anything if we don't have any tickets. */
if (stat(tkt_string(), &st) < 0)
packet_send();
packet_write_wait();
- type = packet_read(&len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
debug("Kerberos v4 TGT forwarded (%s%s%s@%s).",
/* Roger, Roger. Clearance, Clarence. What's your vector,
Victor? */
- type = packet_read(&len);
+ type = packet_read();
if (type == SSH_SMSG_FAILURE)
debug("AFS token for cell %s rejected.", server_cell);
try_challenge_response_authentication(void)
{
int type, i;
- int payload_len;
u_int clen;
char prompt[1024];
char *challenge, *response;
packet_send();
packet_write_wait();
- type = packet_read(&payload_len);
+ type = packet_read();
if (type != SSH_SMSG_FAILURE &&
type != SSH_SMSG_AUTH_TIS_CHALLENGE) {
packet_disconnect("Protocol error: got %d in response "
xfree(response);
packet_send();
packet_write_wait();
- type = packet_read(&payload_len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
return 1;
if (type != SSH_SMSG_FAILURE)
static int
try_password_authentication(char *prompt)
{
- int type, i, payload_len;
+ int type, i;
char *password;
debug("Doing password authentication.");
packet_send();
packet_write_wait();
- type = packet_read(&payload_len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
return 1;
if (type != SSH_SMSG_FAILURE)
u_char cookie[8];
u_int supported_ciphers;
u_int server_flags, client_flags;
- int payload_len;
u_int32_t rand = 0;
debug("Waiting for server public key.");
/* Wait for a public key packet from the server. */
- packet_read_expect(&payload_len, SSH_SMSG_PUBLIC_KEY);
+ packet_read_expect(SSH_SMSG_PUBLIC_KEY);
/* Get cookie from the packet. */
for (i = 0; i < 8; i++)
* Expect a success message from the server. Note that this message
* will be received in encrypted form.
*/
- packet_read_expect(&payload_len, SSH_SMSG_SUCCESS);
+ packet_read_expect(SSH_SMSG_SUCCESS);
debug("Received encrypted confirmation.");
}
krb5_auth_context auth_context = NULL;
#endif
int i, type;
- int payload_len;
if (supported_authentications == 0)
fatal("ssh_userauth1: server supports no auth methods");
* needed (the user has no password). Otherwise the server responds
* with failure.
*/
- type = packet_read(&payload_len);
+ type = packet_read();
/* check whether the connection was accepted without authentication. */
if (type == SSH_SMSG_SUCCESS)
debug("Trying Kerberos v5 authentication.");
if (try_krb5_authentication(&context, &auth_context)) {
- type = packet_read(&payload_len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
goto success;
if (type != SSH_SMSG_FAILURE)
debug("Trying Kerberos v4 authentication.");
if (try_krb4_authentication()) {
- type = packet_read(&payload_len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
goto success;
if (type != SSH_SMSG_FAILURE)
packet_write_wait();
/* The server should respond with success or failure. */
- type = packet_read(&payload_len);
+ type = packet_read();
if (type == SSH_SMSG_SUCCESS)
goto success;
if (type != SSH_SMSG_FAILURE)
*/
#include "includes.h"
-RCSID("$OpenBSD: sshconnect2.c,v 1.90 2001/12/28 12:14:27 markus Exp $");
+RCSID("$OpenBSD: sshconnect2.c,v 1.91 2001/12/28 14:50:54 markus Exp $");
#include <openssl/bn.h>
#include <openssl/md5.h>
{
Authctxt authctxt;
int type;
- int plen;
if (options.challenge_response_authentication)
options.kbd_interactive_authentication = 1;
packet_put_cstring("ssh-userauth");
packet_send();
packet_write_wait();
- type = packet_read(&plen);
+ type = packet_read();
if (type != SSH2_MSG_SERVICE_ACCEPT) {
fatal("denied SSH2_MSG_SERVICE_ACCEPT: %d", type);
}
if (packet_remaining() > 0) {
- char *reply = packet_get_string(&plen);
+ char *reply = packet_get_string(NULL);
debug("service_accept: %s", reply);
xfree(reply);
} else {
*/
#include "includes.h"
-RCSID("$OpenBSD: sshd.c,v 1.221 2001/12/28 13:57:33 markus Exp $");
+RCSID("$OpenBSD: sshd.c,v 1.222 2001/12/28 14:50:54 markus Exp $");
#include <openssl/dh.h>
#include <openssl/bn.h>
do_ssh1_kex(void)
{
int i, len;
- int plen;
int rsafail = 0;
BIGNUM *session_key_int;
u_char session_key[SSH_SESSION_KEY_LENGTH];
BN_num_bits(sensitive_data.ssh1_host_key->rsa->n));
/* Read clients reply (cipher type and session key). */
- packet_read_expect(&plen, SSH_CMSG_SESSION_KEY);
+ packet_read_expect(SSH_CMSG_SESSION_KEY);
/* Get cipher type and check whether we accept this. */
cipher_type = packet_get_char();