/**
* @brief tests the privatekey_from_file function with passphrase
*/
static void torture_privatekey_from_file_passphrase(void **state) {
ssh_session session = *state;
ssh_private_key key = NULL;
key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, SSH_KEYTYPE_RSA, LIBSSH_PASSPHRASE);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, SSH_KEYTYPE_DSS, LIBSSH_PASSPHRASE);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
/* Test the automatic type discovery */
key = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
key = privatekey_from_file(session, LIBSSH_DSA_TESTKEY, 0, LIBSSH_PASSPHRASE);
assert_true(key != NULL);
if (key != NULL) {
privatekey_free(key);
key = NULL;
}
}
/**
* Authenticate in the SSH server with key
* @param QString private_key the private key to use for connect in the SSH server
* @param QString password the password to use for connect in the SSH server (passphrase of the private key)
* @return bool true if it's ok, false else
* @todo test with a private key with passphrase
*/
bool Kssh::authenticateKey(QString private_key, QString password)
{
ssh_string public_key_to_use;
ssh_private_key private_key_to_use;
int auth;
private_key_to_use = privatekey_from_file(this->m_session, private_key.toStdString().c_str(), 0, password.toStdString().c_str());
if (private_key_to_use == NULL) {
Klog::error(QString("Fatal error while get the private key : ") + QString(ssh_get_error(this->m_session)));
return false;
}
// get the public key
public_key_to_use = publickey_to_string(publickey_from_privatekey(private_key_to_use));
// try to authenticate
auth = ssh_userauth_pubkey(this->m_session, NULL, public_key_to_use, private_key_to_use);
if (auth == SSH_AUTH_SUCCESS) {
// clear the keys of the memory
privatekey_free(private_key_to_use);
string_free(public_key_to_use);
// it's ok
return true;
} else if (auth == SSH_AUTH_DENIED || auth == SSH_AUTH_PARTIAL) {
Klog::warning(QString("Authenticated denied with this key"));
return false;
} else if (auth == SSH_AUTH_ERROR) {
Klog::error(QString("Fatal error in authenticated with key : ") + QString(ssh_get_error(this->m_session)));
return false;
}
return false;
}
static void torture_pubkey_generate_from_privkey(void **state) {
ssh_session session = *state;
ssh_private_key privkey = NULL;
ssh_public_key pubkey = NULL;
ssh_string pubkey_orig = NULL;
ssh_string pubkey_new = NULL;
char pubkey_line_orig[512] = {0};
char pubkey_line_new[512] = {0};
int type_orig = 0;
int type_new = 0;
int rc;
/* read the publickey */
rc = ssh_try_publickey_from_file(session, LIBSSH_RSA_TESTKEY, &pubkey_orig,
&type_orig);
assert_true(rc == 0);
assert_true(pubkey_orig != NULL);
rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_orig,
sizeof(pubkey_line_orig));
assert_true(rc == 0);
/* remove the public key, generate it from the private key and write it. */
unlink(LIBSSH_RSA_TESTKEY ".pub");
privkey = privatekey_from_file(session, LIBSSH_RSA_TESTKEY, 0, NULL);
assert_true(privkey != NULL);
pubkey = publickey_from_privatekey(privkey);
assert_true(pubkey != NULL);
type_new = privkey->type;
privatekey_free(privkey);
pubkey_new = publickey_to_string(pubkey);
publickey_free(pubkey);
assert_true(pubkey_new != NULL);
assert_true(ssh_string_len(pubkey_orig) == ssh_string_len(pubkey_new));
assert_memory_equal(ssh_string_data(pubkey_orig),
ssh_string_data(pubkey_new),
ssh_string_len(pubkey_orig));
rc = ssh_publickey_to_file(session, LIBSSH_RSA_TESTKEY ".pub", pubkey_new, type_new);
assert_true(rc == 0);
rc = torture_read_one_line(LIBSSH_RSA_TESTKEY ".pub", pubkey_line_new,
sizeof(pubkey_line_new));
assert_true(rc == 0);
assert_string_equal(pubkey_line_orig, pubkey_line_new);
ssh_string_free(pubkey_orig);
ssh_string_free(pubkey_new);
}
/**
* @brief import a key from a file
* @param[out] key the ssh_key to update
* @param[in] session The SSH Session to use. If a key decryption callback is set, it will
* be used to ask for the passphrase.
* @param[in] filename The filename of the the private key.
* @param[in] passphrase The passphrase to decrypt the private key. Set to null
* if none is needed or it is unknown.
* @returns SSH_OK on success, SSH_ERROR otherwise.
**/
int ssh_key_import_private(ssh_key key, ssh_session session, const char *filename, const char *passphrase){
ssh_private_key priv=privatekey_from_file(session,filename,0,passphrase);
if(priv==NULL)
return SSH_ERROR;
ssh_key_clean(key);
key->dsa=priv->dsa_priv;
key->rsa=priv->rsa_priv;
key->type=priv->type;
key->flags=SSH_KEY_FLAG_PRIVATE | SSH_KEY_FLAG_PUBLIC;
key->type_c=ssh_type_to_char(key->type);
SAFE_FREE(priv);
return SSH_OK;
}
// Connect to a SSH server.
// When the connection is established, read data from stdin and send it to the server.
void client_pipe(char *host, int port)
{
ssh_session s = ssh_new();
ssh_options_set(s, SSH_OPTIONS_HOST, host);
ssh_options_set(s, SSH_OPTIONS_PORT, &port);
ssh_options_set(s, SSH_OPTIONS_USER, "xya");
//ssh_options_set(s, SSH_OPTIONS_LOG_VERBOSITY_STR, "5");
if(ssh_connect(s) != SSH_OK)
return session_error(s, "connect");
char *hash = pubkey_hash(ssh_get_pubkey(s));
if(authenticate(hash, 0))
{
session_event(s, "authenticated", hash);
free(hash);
}
else
{
free(hash);
exit(1);
}
int keytype;
ssh_string pub = publickey_from_file(s, "test-client-key.pub", &keytype);
if(!pub)
session_error(s, "open-public-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_offer_pubkey(s, NULL, keytype, pub))
session_error(s, "offer-public-key");
ssh_private_key priv = privatekey_from_file(s, "test-client-key", keytype, NULL);
if(!priv)
session_error(s, "open-private-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_pubkey(s, NULL, pub, priv))
session_error(s, "user-auth");
string_free(pub);
privatekey_free(priv);
ssh_channel chan = channel_new(s);
if(!chan)
session_error(s, "create-channel");
if(channel_open_session(chan) < 0)
session_error(s, "open-channel");
session_event(s, "channel-opened", NULL);
channel_from_file(chan, 0);
channel_free(chan);
ssh_disconnect(s);
ssh_finalize();
}
int start_sshkey(int s, char *ip, int port, unsigned char options, char *miscptr, FILE * fp) {
char *empty = "";
char *login, *key, keep_login[300];
int auth_state = 0, rc = 0, i = 0;
ssh_private_key privkey;
if (strlen(login = hydra_get_next_login()) == 0)
login = empty;
if (strlen(key = hydra_get_next_password()) == 0)
key = empty;
if (new_session) {
if (session) {
ssh_disconnect(session);
ssh_finalize();
ssh_free(session);
}
session = ssh_new();
ssh_options_set(session, SSH_OPTIONS_PORT, &port);
ssh_options_set(session, SSH_OPTIONS_HOST, hydra_address2string(ip));
ssh_options_set(session, SSH_OPTIONS_USER, login);
ssh_options_set(session, SSH_OPTIONS_COMPRESSION_C_S, "none");
ssh_options_set(session, SSH_OPTIONS_COMPRESSION_S_C, "none");
if (ssh_connect(session) != 0) {
//if the connection was drop, exit and let hydra main handle it
if (verbose)
hydra_report(stderr, "[ERROR] could not connect to target port %d\n", port);
return 3;
}
if ((rc = ssh_userauth_none(session, NULL)) == SSH_AUTH_ERROR) {
return 3;
} else if (rc == SSH_AUTH_SUCCESS) {
hydra_report_found_host(port, ip, "sshkey", fp);
hydra_completed_pair_found();
if (memcmp(hydra_get_next_pair(), &HYDRA_EXIT, sizeof(HYDRA_EXIT)) == 0)
return 2;
else
return 1;
}
} else
new_session = 1;
auth_state = ssh_auth_list(session);
if ((auth_state & SSH_AUTH_METHOD_PUBLICKEY) > 0) {
privkey = privatekey_from_file(session, key, 0, NULL);
if (!privkey) {
hydra_report(stderr, "[ERROR] skipping invalid private key: \"%s\"\n", key);
hydra_completed_pair();
if (memcmp(hydra_get_next_pair(), &HYDRA_EXIT, sizeof(HYDRA_EXIT)) == 0)
return 2;
return 1;
}
auth_state = ssh_userauth_pubkey(session, NULL, NULL, privkey);
} else {
return 4;
}
if (auth_state == SSH_AUTH_ERROR) {
new_session = 1;
return 1;
}
if (auth_state == SSH_AUTH_SUCCESS || auth_state == SSH_AUTH_PARTIAL) {
hydra_report_found_host(port, ip, "sshkey", fp);
hydra_completed_pair_found();
if (memcmp(hydra_get_next_pair(), &HYDRA_EXIT, sizeof(HYDRA_EXIT)) == 0)
return 2;
return 1;
} else {
strncpy(keep_login, login, sizeof(keep_login) - 1);
keep_login[sizeof(keep_login) - 1] = '\0';
hydra_completed_pair();
if (memcmp(hydra_get_next_pair(), &HYDRA_EXIT, sizeof(HYDRA_EXIT)) == 0)
return 2;
login = hydra_get_next_login();
if (strcmp(login, keep_login) == 0)
new_session = 0;
return 1;
}
/* not reached */
return 1;
}
gboolean remmina_nx_session_open(RemminaNXSession *nx, const gchar *server, guint port, const gchar *private_key_file,
RemminaNXPassphraseCallback passphrase_func, gpointer userdata)
{
gint ret;
ssh_private_key privkey;
ssh_public_key pubkey;
ssh_string pubkeystr;
gint keytype;
gboolean encrypted;
gchar *passphrase = NULL;
gchar tmpfile[L_tmpnam + 1];
nx ->session = ssh_new();
ssh_options_set(nx->session, SSH_OPTIONS_HOST, server);
ssh_options_set(nx->session, SSH_OPTIONS_PORT, &port);
ssh_options_set(nx->session, SSH_OPTIONS_USER, "nx");
if (private_key_file && private_key_file[0])
{
if (!remmina_get_keytype(private_key_file, &keytype, &encrypted))
{
remmina_nx_session_set_application_error(nx, "Invalid private key file.");
return FALSE;
}
if (encrypted && !passphrase_func(&passphrase, userdata))
{
return FALSE;
}
privkey = privatekey_from_file(nx->session, private_key_file, keytype, (passphrase ? passphrase : ""));
g_free(passphrase);
}
else
{
/* Use NoMachine's default nx private key */
if ((tmpnam(tmpfile)) == NULL || !g_file_set_contents(tmpfile, nx_default_private_key, -1, NULL))
{
remmina_nx_session_set_application_error(nx, "Failed to create temporary private key file.");
return FALSE;
}
privkey = privatekey_from_file(nx->session, tmpfile, REMMINA_SSH_TYPE_DSS, "");
g_unlink(tmpfile);
}
if (privkey == NULL)
{
remmina_nx_session_set_error(nx, "Invalid private key file: %s");
return FALSE;
}
pubkey = publickey_from_privatekey(privkey);
pubkeystr = publickey_to_string(pubkey);
publickey_free(pubkey);
if (ssh_connect(nx->session))
{
string_free(pubkeystr);
privatekey_free(privkey);
remmina_nx_session_set_error(nx, "Failed to startup SSH session: %s");
return FALSE;
}
ret = ssh_userauth_pubkey(nx->session, NULL, pubkeystr, privkey);
string_free(pubkeystr);
privatekey_free(privkey);
if (ret != SSH_AUTH_SUCCESS)
{
remmina_nx_session_set_error(nx, "NX SSH authentication failed: %s");
return FALSE;
}
if ((nx->channel = channel_new(nx->session)) == NULL || channel_open_session(nx->channel))
{
return FALSE;
}
if (channel_request_shell(nx->channel))
{
return FALSE;
}
/* NX server starts the session with an initial 105 status */
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
/* Say hello to the NX server */
remmina_nx_session_send_command(nx, "HELLO NXCLIENT - Version %s", nx->version);
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
/* Set the NX session environment */
remmina_nx_session_send_command(nx, "SET SHELL_MODE SHELL");
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
remmina_nx_session_send_command(nx, "SET AUTH_MODE PASSWORD");
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
nx->server = g_strdup(server);
return TRUE;
}
int ssh_userauth_autopubkey(SSH_SESSION *session){
int count=1; /* bypass identity */
int type=0;
int err;
STRING *pubkey;
char *privkeyfile=NULL;
PRIVATE_KEY *privkey;
char *id=NULL;
enter_function();
// always testing none
err=ssh_userauth_none(session,NULL);
if(err==SSH_AUTH_ERROR || err==SSH_AUTH_SUCCESS){
leave_function();
return err;
}
if(session->options->identity){
ssh_say(2,"Trying identity file %s\n",session->options->identity);
keys_path[0]=session->options->identity;
/* let's hope alloca exists */
id=malloc(strlen(session->options->identity)+1 + 4);
sprintf(id,"%s.pub",session->options->identity);
pub_keys_path[0]=id;
count =0;
}
while((pubkey=publickey_from_next_file(session,pub_keys_path,keys_path, &privkeyfile,&type,&count))){
err=ssh_userauth_offer_pubkey(session,NULL,type,pubkey);
if(err==SSH_AUTH_ERROR){
if(id){
pub_keys_path[0]=NULL;
keys_path[0]=NULL;
free(id);
}
free(pubkey);
free(privkeyfile);
leave_function();
return err;
} else
if(err != SSH_AUTH_SUCCESS){
ssh_say(2,"Public key refused by server\n");
free(pubkey);
pubkey=NULL;
free(privkeyfile);
privkeyfile=NULL;
continue;
}
/* pubkey accepted by server ! */
privkey=privatekey_from_file(session,privkeyfile,type,NULL);
if(!privkey){
ssh_say(0,"Reading private key %s failed (bad passphrase ?)\n",privkeyfile);
free(pubkey);
pubkey=NULL;
free(privkeyfile);
privkeyfile=NULL;
continue; /* continue the loop with other pubkey */
}
err=ssh_userauth_pubkey(session,NULL,pubkey,privkey);
if(err==SSH_AUTH_ERROR){
if(id){
pub_keys_path[0]=NULL;
keys_path[0]=NULL;
free(id);
}
free(pubkey);
free(privkeyfile);
private_key_free(privkey);
leave_function();
return err;
} else
if(err != SSH_AUTH_SUCCESS){
ssh_say(0,"Weird : server accepted our public key but refused the signature\nit might be a bug of libssh\n");
free(pubkey);
pubkey=NULL;
free(privkeyfile);
privkeyfile=NULL;
private_key_free(privkey);
continue;
}
/* auth success */
ssh_say(1,"Authentication using %s success\n",privkeyfile);
free(pubkey);
private_key_free(privkey);
free(privkeyfile);
if(id){
pub_keys_path[0]=NULL;
keys_path[0]=NULL;
free(id);
}
leave_function();
return SSH_AUTH_SUCCESS;
}
/* at this point, pubkey is NULL and so is privkeyfile */
ssh_say(1,"Tried every public key, none matched\n");
ssh_set_error(session,SSH_NO_ERROR,"no public key matched");
if(id){
pub_keys_path[0]=NULL;
keys_path[0]=NULL;
free(id);
}
leave_function();
return SSH_AUTH_DENIED;
}
/**
* @brief Tries to automaticaly authenticate with public key and "none"
*
* It may fail, for instance it doesn't ask for a password and uses a default
* asker for passphrases (in case the private key is encrypted).
*
* @param session The ssh session to authenticate with.
*
* @param passphrase Use this passphrase to unlock the privatekey. Use NULL
* if you don't want to use a passphrase or the user
* should be asked.
*
* @returns SSH_AUTH_ERROR: A serious error happened\n
* SSH_AUTH_DENIED: Authentication failed: use another method\n
* SSH_AUTH_PARTIAL: You've been partially authenticated, you still
* have to use another method\n
* SSH_AUTH_SUCCESS: Authentication success
*
* @see ssh_userauth_kbdint()
* @see ssh_userauth_password()
*/
int ssh_userauth_autopubkey(ssh_session session, const char *passphrase) {
struct ssh_iterator *it;
ssh_private_key privkey;
ssh_public_key pubkey;
ssh_string pubkey_string;
int type = 0;
int rc;
enter_function();
/* Always test none authentication */
rc = ssh_userauth_none(session, NULL);
if (rc == SSH_AUTH_ERROR || rc == SSH_AUTH_SUCCESS) {
leave_function();
return rc;
}
/* Try authentication with ssh-agent first */
#ifndef _WIN32
if (agent_is_running(session)) {
char *privkey_file = NULL;
ssh_log(session, SSH_LOG_RARE,
"Trying to authenticate with SSH agent keys as user: %s",
session->username);
for (pubkey = agent_get_first_ident(session, &privkey_file);
pubkey != NULL;
pubkey = agent_get_next_ident(session, &privkey_file)) {
ssh_log(session, SSH_LOG_RARE, "Trying identity %s", privkey_file);
pubkey_string = publickey_to_string(pubkey);
if (pubkey_string) {
rc = ssh_userauth_offer_pubkey(session, NULL, pubkey->type, pubkey_string);
string_free(pubkey_string);
if (rc == SSH_AUTH_ERROR) {
SAFE_FREE(privkey_file);
publickey_free(pubkey);
leave_function();
return rc;
} else if (rc != SSH_AUTH_SUCCESS) {
ssh_log(session, SSH_LOG_PROTOCOL, "Public key refused by server");
SAFE_FREE(privkey_file);
publickey_free(pubkey);
continue;
}
ssh_log(session, SSH_LOG_RARE, "Public key accepted");
/* pubkey accepted by server ! */
rc = ssh_userauth_agent_pubkey(session, NULL, pubkey);
if (rc == SSH_AUTH_ERROR) {
SAFE_FREE(privkey_file);
publickey_free(pubkey);
leave_function();
return rc;
} else if (rc != SSH_AUTH_SUCCESS) {
ssh_log(session, SSH_LOG_RARE,
"Server accepted public key but refused the signature ;"
" It might be a bug of libssh");
SAFE_FREE(privkey_file);
publickey_free(pubkey);
continue;
}
/* auth success */
ssh_log(session, SSH_LOG_PROTOCOL, "Authentication using %s success",
privkey_file);
SAFE_FREE(privkey_file);
publickey_free(pubkey);
leave_function();
return SSH_AUTH_SUCCESS;
} /* if pubkey */
SAFE_FREE(privkey_file);
publickey_free(pubkey);
} /* for each privkey */
} /* if agent is running */
#endif
for (it = ssh_list_get_iterator(session->identity);
it != NULL;
it = it->next) {
const char *privkey_file = it->data;
int privkey_open = 0;
privkey = NULL;
ssh_log(session, SSH_LOG_PROTOCOL, "Trying to read privatekey %s", privkey_file);
rc = ssh_try_publickey_from_file(session, privkey_file, &pubkey_string, &type);
if (rc == 1) {
char *publickey_file;
size_t len;
privkey = privatekey_from_file(session, privkey_file, type, passphrase);
if (privkey == NULL) {
ssh_log(session, SSH_LOG_RARE,
"Reading private key %s failed (bad passphrase ?)",
privkey_file);
leave_function();
return SSH_AUTH_ERROR;
}
privkey_open = 1;
pubkey = publickey_from_privatekey(privkey);
if (pubkey == NULL) {
privatekey_free(privkey);
ssh_set_error_oom(session);
leave_function();
return SSH_AUTH_ERROR;
}
pubkey_string = publickey_to_string(pubkey);
type = pubkey->type;
publickey_free(pubkey);
if (pubkey_string == NULL) {
ssh_set_error_oom(session);
leave_function();
return SSH_AUTH_ERROR;
}
len = strlen(privkey_file) + 5;
publickey_file = malloc(len);
if (publickey_file == NULL) {
ssh_set_error_oom(session);
leave_function();
return SSH_AUTH_ERROR;
}
snprintf(publickey_file, len, "%s.pub", privkey_file);
rc = ssh_publickey_to_file(session, publickey_file, pubkey_string, type);
if (rc < 0) {
ssh_log(session, SSH_LOG_PACKET,
"Could not write public key to file: %s", publickey_file);
}
SAFE_FREE(publickey_file);
} else if (rc < 0) {
continue;
}
rc = ssh_userauth_offer_pubkey(session, NULL, type, pubkey_string);
if (rc == SSH_AUTH_ERROR){
string_free(pubkey_string);
ssh_log(session, SSH_LOG_RARE, "Publickey authentication error");
leave_function();
return rc;
} else {
if (rc != SSH_AUTH_SUCCESS){
ssh_log(session, SSH_LOG_PROTOCOL, "Publickey refused by server");
string_free(pubkey_string);
continue;
}
}
/* Public key accepted by server! */
if (!privkey_open) {
ssh_log(session, SSH_LOG_PROTOCOL, "Trying to read privatekey %s",
privkey_file);
privkey = privatekey_from_file(session, privkey_file, type, passphrase);
if (privkey == NULL) {
ssh_log(session, SSH_LOG_RARE,
"Reading private key %s failed (bad passphrase ?)",
privkey_file);
string_free(pubkey_string);
continue; /* continue the loop with other pubkey */
}
}
rc = ssh_userauth_pubkey(session, NULL, pubkey_string, privkey);
if (rc == SSH_AUTH_ERROR) {
string_free(pubkey_string);
privatekey_free(privkey);
leave_function();
return rc;
} else {
if (rc != SSH_AUTH_SUCCESS){
ssh_log(session, SSH_LOG_FUNCTIONS,
"The server accepted the public key but refused the signature");
string_free(pubkey_string);
privatekey_free(privkey);
continue;
}
}
/* auth success */
ssh_log(session, SSH_LOG_PROTOCOL,
"Successfully authenticated using %s", privkey_file);
string_free(pubkey_string);
privatekey_free(privkey);
leave_function();
return SSH_AUTH_SUCCESS;
}
/* at this point, pubkey is NULL and so is privkeyfile */
ssh_log(session, SSH_LOG_FUNCTIONS,
"Tried every public key, none matched");
ssh_set_error(session,SSH_NO_ERROR,"No public key matched");
leave_function();
return SSH_AUTH_DENIED;
}
ssh_private_key _privatekey_from_file(void *session, const char *filename,
int type) {
return privatekey_from_file(session, filename, type, NULL);
}
