src/usr.bin/ssh/sshconnect2.c - diff

Return to sshconnect2.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/sshconnect2.c between version 1.99 and 1.99.2.3

version 1.99, 2002/03/26 15:58:46

version 1.99.2.3, 2003/04/03 22:35:18

Line 45

#include "match.h"

#include "dispatch.h"

#include "canohost.h"

#include "msg.h"

#include "pathnames.h"

/* import */

extern char *client_version_string;

Line 93

Line 95

compat_cipher_proposal(myproposal[PROPOSAL_ENC_ALGS_STOC]);

if (options.compression) {

myproposal[PROPOSAL_COMP_ALGS_CTOS] =

myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib";

myproposal[PROPOSAL_COMP_ALGS_STOC] = "zlib,none";

} else {

myproposal[PROPOSAL_COMP_ALGS_CTOS] =

myproposal[PROPOSAL_COMP_ALGS_STOC] = "none";

myproposal[PROPOSAL_COMP_ALGS_STOC] = "none,zlib";

}

if (options.macs != NULL) {

myproposal[PROPOSAL_MAC_ALGS_CTOS] =

Line 108

Line 110

/* start key exchange */

kex = kex_setup(myproposal);

kex->kex[KEX_DH_GRP1_SHA1] = kexdh_client;

kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;

kex->client_version_string=client_version_string;

kex->server_version_string=server_version_string;

kex->verify_host_key=&verify_host_key_callback;

Line 126

Line 130

packet_send();

packet_write_wait();

#endif

debug("done: ssh_kex2.");

}

Line 154

Line 157

int last_key_hint;

AuthenticationConnection *agent;

/* hostbased */

Key **keys;

Sensitive *sensitive;

int nkeys;

/* kbd-interactive */

int info_req_seen;

};

Line 215

Line 217

void

ssh_userauth2(const char *local_user, const char *server_user, char *host,

Key **keys, int nkeys)

Sensitive *sensitive)

{

Authctxt authctxt;

int type;

Line 223

Line 225

if (options.challenge_response_authentication)

options.kbd_interactive_authentication = 1;

debug("send SSH2_MSG_SERVICE_REQUEST");

packet_start(SSH2_MSG_SERVICE_REQUEST);

packet_put_cstring("ssh-userauth");

packet_send();

debug("SSH2_MSG_SERVICE_REQUEST sent");

packet_write_wait();

type = packet_read();

if (type != SSH2_MSG_SERVICE_ACCEPT) {

if (type != SSH2_MSG_SERVICE_ACCEPT)

fatal("denied SSH2_MSG_SERVICE_ACCEPT: %d", type);

fatal("Server denied authentication request: %d", type);

}

if (packet_remaining() > 0) {

char *reply = packet_get_string(NULL);

debug("service_accept: %s", reply);

debug2("service_accept: %s", reply);

xfree(reply);

} else {

debug("buggy server: service_accept w/o service");

debug2("buggy server: service_accept w/o service");

}

packet_check_eom();

debug("got SSH2_MSG_SERVICE_ACCEPT");

debug("SSH2_MSG_SERVICE_ACCEPT received");

if (options.preferred_authentications == NULL)

options.preferred_authentications = authmethods_get();

Line 255

Line 256

authctxt.success = 0;

authctxt.method = authmethod_lookup("none");

authctxt.authlist = NULL;

authctxt.keys = keys;

authctxt.sensitive = sensitive;

authctxt.nkeys = nkeys;

authctxt.info_req_seen = 0;

if (authctxt.method == NULL)

fatal("ssh_userauth2: internal error: cannot send userauth none request");

Line 273

if (authctxt.agent != NULL)

ssh_close_authentication_connection(authctxt.agent);

debug("ssh-userauth2 successful: method %s", authctxt.method->name);

debug("Authentication succeeded (%s).", authctxt.method->name);

}

void

userauth(Authctxt *authctxt, char *authlist)

Line 299

}

void

input_userauth_error(int type, u_int32_t seq, void *ctxt)

{

fatal("input_userauth_error: bad message during authentication: "

"type %d", type);

}

void

input_userauth_banner(int type, u_int32_t seq, void *ctxt)

{

Line 316

Line 318

xfree(msg);

xfree(lang);

}

void

input_userauth_success(int type, u_int32_t seq, void *ctxt)

{

Line 327

Line 330

clear_auth_state(authctxt);

authctxt->success = 1; /* break out */

}

void

input_userauth_failure(int type, u_int32_t seq, void *ctxt)

{

Line 343

Line 347

if (partial != 0)

log("Authenticated with partial success.");

debug("authentications that can continue: %s", authlist);

debug("Authentications that can continue: %s", authlist);

clear_auth_state(authctxt);

userauth(authctxt, authlist);

Line 375

Line 379

}

packet_check_eom();

debug("input_userauth_pk_ok: pkalg %s blen %d lastkey %p hint %d",

debug("Server accepts key: pkalg %s blen %u lastkey %p hint %d",

pkalg, blen, authctxt->last_key, authctxt->last_key_hint);

do {

Line 395

Line 399

if (key->type != pktype) {

error("input_userauth_pk_ok: type mismatch "

"for decoded key (received %d, expected %d)",

key->type, pktype);

break;

}

fp = key_fingerprint(key, SSH_FP_MD5, SSH_FP_HEX);

Line 418

Line 422

clear_auth_state(authctxt);

dispatch_set(SSH2_MSG_USERAUTH_PK_OK, NULL);

/* try another method if we did not send a packet*/

/* try another method if we did not send a packet */

if (sent == 0)

userauth(authctxt, NULL);

Line 463

Line 467

packet_add_padding(64);

packet_send();

dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

&input_userauth_passwd_changereq);

return 1;

Line 495

Line 499

packet_put_cstring(authctxt->service);

packet_put_cstring(authctxt->method->name);

packet_put_char(1); /* additional info */

snprintf(prompt, sizeof(prompt),

"Enter %.30s@%.128s's old password: ",

authctxt->server_user, authctxt->host);

password = read_passphrase(prompt, 0);

Line 504

Line 508

xfree(password);

password = NULL;

while (password == NULL) {

snprintf(prompt, sizeof(prompt),

"Enter %.30s@%.128s's new password: ",

authctxt->server_user, authctxt->host);

password = read_passphrase(prompt, RP_ALLOW_EOF);

Line 512

Line 516

/* bail out */

return;

}

snprintf(prompt, sizeof(prompt),

"Retype %.30s@%.128s's new password: ",

authctxt->server_user, authctxt->host);

retype = read_passphrase(prompt, 0);

Line 530

Line 534

xfree(password);

packet_add_padding(64);

packet_send();

dispatch_set(SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

&input_userauth_passwd_changereq);

}

Line 760

Line 764

if (k == NULL) {

debug2("userauth_pubkey_agent: no more keys");

} else {

debug("userauth_pubkey_agent: testing agent key %s", comment);

debug("Offering agent key: %s", comment);

xfree(comment);

ret = send_pubkey_test(authctxt, k, agent_sign_cb, -1);

if (ret == 0)

Line 788

Line 792

key = options.identity_keys[idx];

filename = options.identity_files[idx];

if (key == NULL) {

debug("try privkey: %s", filename);

debug("Trying private key: %s", filename);

key = load_identity_file(filename);

if (key != NULL) {

sent = sign_and_send_pubkey(authctxt, key,

Line 796

Line 800

key_free(key);

}

} else if (key->type != KEY_RSA1) {

debug("try pubkey: %s", filename);

debug("Offering public key: %s", filename);

sent = send_pubkey_test(authctxt, key,

identity_sign_cb, idx);

}

Line 893

Line 897

packet_send();

}

static int

* this will be move to an external program (ssh-keysign) ASAP. ssh-keysign

ssh_keysign(Key *key, u_char **sigp, u_int *lenp,

* will be setuid-root and the sbit can be removed from /usr/bin/ssh.

u_char *data, u_int datalen)

{

Buffer b;

struct stat st;

pid_t pid;

int to[2], from[2], status, version = 2;

debug2("ssh_keysign called");

if (stat(_PATH_SSH_KEY_SIGN, &st) < 0) {

error("ssh_keysign: no installed: %s", strerror(errno));

return -1;

}

if (fflush(stdout) != 0)

error("ssh_keysign: fflush: %s", strerror(errno));

if (pipe(to) < 0) {

error("ssh_keysign: pipe: %s", strerror(errno));

return -1;

}

if (pipe(from) < 0) {

error("ssh_keysign: pipe: %s", strerror(errno));

return -1;

}

if ((pid = fork()) < 0) {

error("ssh_keysign: fork: %s", strerror(errno));

return -1;

}

if (pid == 0) {

seteuid(getuid());

setuid(getuid());

close(from[0]);

if (dup2(from[1], STDOUT_FILENO) < 0)

fatal("ssh_keysign: dup2: %s", strerror(errno));

close(to[1]);

if (dup2(to[0], STDIN_FILENO) < 0)

fatal("ssh_keysign: dup2: %s", strerror(errno));

close(from[1]);

close(to[0]);

execl(_PATH_SSH_KEY_SIGN, _PATH_SSH_KEY_SIGN, (char *) 0);

fatal("ssh_keysign: exec(%s): %s", _PATH_SSH_KEY_SIGN,

strerror(errno));

}

close(from[1]);

close(to[0]);

buffer_init(&b);

buffer_put_int(&b, packet_get_connection_in()); /* send # of socket */

buffer_put_string(&b, data, datalen);

ssh_msg_send(to[1], version, &b);

if (ssh_msg_recv(from[0], &b) < 0) {

error("ssh_keysign: no reply");

buffer_clear(&b);

return -1;

}

close(from[0]);

close(to[1]);

while (waitpid(pid, &status, 0) < 0)

if (errno != EINTR)

break;

if (buffer_get_char(&b) != version) {

error("ssh_keysign: bad version");

buffer_clear(&b);

return -1;

}

*sigp = buffer_get_string(&b, lenp);

buffer_clear(&b);

return 0;

}

int

userauth_hostbased(Authctxt *authctxt)

{

Key *private = NULL;

Sensitive *sensitive = authctxt->sensitive;

Buffer b;

u_char *signature, *blob;

char *chost, *pkalg, *p;

Line 909

Line 985

int ok, i, len, found = 0;

/* check for a useful key */

for (i = 0; i < authctxt->nkeys; i++) {

for (i = 0; i < sensitive->nkeys; i++) {

private = authctxt->keys[i];

private = sensitive->keys[i];

if (private && private->type != KEY_RSA1) {

found = 1;

/* we take and free the key */

authctxt->keys[i] = NULL;

sensitive->keys[i] = NULL;

break;

}

if (!found) {

debug("userauth_hostbased: no more client hostkeys");

debug("No more client hostkeys for hostbased authentication.");

return 0;

}

if (key_to_blob(private, &blob, &blen) == 0) {

Line 938

Line 1014

strlcpy(chost, p, len);

strlcat(chost, ".", len);

debug2("userauth_hostbased: chost %s", chost);

xfree(p);

service = datafellows & SSH_BUG_HBSERVICE ? "ssh-userauth" :

authctxt->service;

Line 956

Line 1033

#ifdef DEBUG_PK

buffer_dump(&b);

#endif

ok = key_sign(private, &signature, &slen, buffer_ptr(&b), buffer_len(&b));

if (sensitive->external_keysign)

ok = ssh_keysign(private, &signature, &slen,

buffer_ptr(&b), buffer_len(&b));

else

ok = key_sign(private, &signature, &slen,

buffer_ptr(&b), buffer_len(&b));

key_free(private);

buffer_free(&b);

if (ok != 0) {

Line 1019

Line 1101

static Authmethod *current = NULL;

static char *supported = NULL;

static char *preferred = NULL;

* Given the authentication method list sent by the server, return the

* next method we should try. If the server initially sends a nil list,

Line 1027

Line 1110

static Authmethod *

authmethod_get(char *authlist)

{

char *name = NULL;

u_int next;

Line 1048

Line 1130

for (;;) {

if ((name = match_list(preferred, supported, &next)) == NULL) {

debug("no more auth methods to try");

debug("No more authentication methods to try.");

current = NULL;

return NULL;

}

Line 1058

Line 1140

if ((current = authmethod_lookup(name)) != NULL &&

authmethod_is_enabled(current)) {

debug3("authmethod_is_enabled %s", name);

debug("next auth method to try is %s", name);

debug("Next authentication method: %s", name);

return current;

}