/**
* Check if the host doesn't change
* @return bool true if it's ok, false else
*/
bool Kssh::check_known_host()
{
QString error, server_public_key;
int state, hlen;
unsigned char *hash = NULL;
// get the public key of the server
state = ssh_is_server_known(this->m_session);
hlen = ssh_get_pubkey_hash(this->m_session, &hash);
if (hlen < 0) {
#ifdef DEBUG
Klog::debug("no public key for this server");
#endif
return false;
}
server_public_key = QString(ssh_get_hexa(hash, hlen));
delete[] hash;
switch (state) {
case SSH_SERVER_KNOWN_OK:
break;
case SSH_SERVER_KNOWN_CHANGED:
Klog::warning(QString("Host key for server changed, now it's : ") + server_public_key);
return false;
case SSH_SERVER_FOUND_OTHER:
error = "The host key for this server was not found but an other type of key exists.\n"
"into thinking the key does not exist.\n";
Klog::warning(error);
return false;
case SSH_SERVER_FILE_NOT_FOUND:
Klog::warning("Could not find known host file. This file will be automatically created.");
if (ssh_write_knownhost(this->m_session) < 0) {
#ifdef DEBUG
Klog::debug("impossible to write the knowhosts");
#endif
}
break;
case SSH_SERVER_NOT_KNOWN:
Klog::warning("The server is unknown. This new key will be written on disk for further usage.");
if (ssh_write_knownhost(this->m_session) < 0) {
#ifdef DEBUG
Klog::debug("impossible to write the knowhosts");
#endif
}
break;
case SSH_SERVER_ERROR:
Klog::error(QString("Error while check the knowhosts : ") + QString(ssh_get_error(this->m_session)));
return false;
}
return true;
}
void clSSH::AcceptServerAuthentication() throw(clException)
{
if(!m_session) {
throw clException("NULL SSH session");
}
ssh_write_knownhost(m_session);
}
int verify_knownhost(ssh_session session){
char *hexa;
int state;
char buf[10];
unsigned char *hash = NULL;
int hlen;
state=ssh_is_server_known(session);
hlen = ssh_get_pubkey_hash(session, &hash);
if (hlen < 0) {
return -1;
}
switch(state){
case SSH_SERVER_KNOWN_OK:
break; /* ok */
case SSH_SERVER_KNOWN_CHANGED:
fprintf(stderr,"Host key for server changed : server's one is now :\n");
ssh_print_hexa("Public key hash",hash, hlen);
free(hash);
fprintf(stderr,"For security reason, connection will be stopped\n");
return -1;
case SSH_SERVER_FOUND_OTHER:
fprintf(stderr,"The host key for this server was not found but an other type of key exists.\n");
fprintf(stderr,"An attacker might change the default server key to confuse your client"
"into thinking the key does not exist\n"
"We advise you to rerun the client with -d or -r for more safety.\n");
return -1;
case SSH_SERVER_FILE_NOT_FOUND:
fprintf(stderr,"Could not find known host file. If you accept the host key here,\n");
fprintf(stderr,"the file will be automatically created.\n");
/* fallback to SSH_SERVER_NOT_KNOWN behavior */
case SSH_SERVER_NOT_KNOWN:
hexa = ssh_get_hexa(hash, hlen);
fprintf(stderr,"The server is unknown. Do you trust the host key ?\n");
fprintf(stderr, "Public key hash: %s\n", hexa);
free(hexa);
fgets(buf,sizeof(buf),stdin);
if(strncasecmp(buf,"yes",3)!=0){
return -1;
}
fprintf(stderr,"This new key will be written on disk for further usage. do you agree ?\n");
fgets(buf,sizeof(buf),stdin);
if(strncasecmp(buf,"yes",3)==0){
if (ssh_write_knownhost(session) < 0) {
free(hash);
fprintf(stderr, "error %s\n", strerror(errno));
return -1;
}
}
break;
case SSH_SERVER_ERROR:
free(hash);
fprintf(stderr,"%s",ssh_get_error(session));
return -1;
}
free(hash);
return 0;
}
int SSH::verifyHost()
{
int state;
size_t hlen;
unsigned char* hash = NULL;
int gpkh_res;
state = ssh_is_server_known(_ssh);
// hlen = ssh_get_pubkey_hash(_ssh, &hash);
if ((gpkh_res = ssh_get_publickey_hash(_ssh_key, SSH_PUBLICKEY_HASH_SHA1, &hash, &hlen)))
return gpkh_res;
if (hlen < 0) {
return -1;
}
switch (state) {
case SSH_SERVER_KNOWN_OK:
break;
case SSH_SERVER_KNOWN_CHANGED:
break;
case SSH_SERVER_FOUND_OTHER:
free(hash);
return -1;
break;
case SSH_SERVER_FILE_NOT_FOUND:
case SSH_SERVER_NOT_KNOWN:
if (ssh_write_knownhost(_ssh) < 0) {
free(hash);
return -1;
}
break;
case SSH_SERVER_ERROR:
free(hash);
return -1;
break;
};
free(hash);
return 0;
}
/*
* NOTE: This function changes the SSH_OPTIONS_KNOWNHOSTS option on
* the session.
*
* We can't save and restore it since ssh_options_get doesn't allow us
* to retrieve the old value of SSH_OPTIONS_KNOWNHOSTS.
*
* HACK: This function should be provided by libssh.
*
* https://red.libssh.org/issues/162
*/
static gchar *
get_knownhosts_line (ssh_session session)
{
char name[] = "/tmp/cockpit-XXXXXX";
int fd;
GError *error = NULL;
gchar *line = NULL;
fd = mkstemp (name);
if (fd == -1)
{
g_warning ("Couldn't make temporary name for knownhosts line: %m");
goto out;
}
close (fd);
if (ssh_options_set (session, SSH_OPTIONS_KNOWNHOSTS, name) != SSH_OK)
{
g_warning ("Couldn't set SSH_OPTIONS_KNOWNHOSTS option.");
goto out;
}
if (ssh_write_knownhost (session) != SSH_OK)
{
g_warning ("Couldn't write knownhosts file: %s", ssh_get_error (session));
goto out;
}
if (!g_file_get_contents (name, &line, NULL, &error))
{
g_warning ("Couldn't read temporary known_hosts %s: %s", name, error->message);
g_clear_error (&error);
goto out;
}
g_strstrip (line);
out:
if (fd != -1)
g_unlink (name);
return line;
}
int verify_knownhost(ssh_session session) {
int state, hlen;
unsigned char *hash = NULL;
char *hexa;
char buf[10];
state = ssh_is_server_known(session);
hlen = ssh_get_pubkey_hash(session, &hash);
if (hlen < 0)
return -1;
switch (state)
{
case SSH_SERVER_KNOWN_OK:
break; /* ok */
case SSH_SERVER_KNOWN_CHANGED:
fprintf(stderr, "Host key for server changed: it is now:\n");
ssh_print_hexa("Public key hash", hash, hlen);
fprintf(stderr, "For security reasons, connection will be stopped\n");
free(hash);
return -1;
case SSH_SERVER_FOUND_OTHER:
fprintf(stderr, "The host key for this server was not found but an other"
"type of key exists.\n");
fprintf(stderr, "An attacker might change the default server key to"
"confuse your client into thinking the key does not exist\n");
free(hash);
return -1;
case SSH_SERVER_FILE_NOT_FOUND:
fprintf(stderr, "Could not find known host file.\n");
fprintf(stderr, "If you accept the host key here, the file will be"
"automatically created.\n");
/* fallback to SSH_SERVER_NOT_KNOWN behavior */
case SSH_SERVER_NOT_KNOWN:
hexa = ssh_get_hexa(hash, hlen);
fprintf(stderr,"The server is unknown. Do you trust the host key [yes/no]?\n");
fprintf(stderr, "Public key hash: %s\n", hexa);
free(hexa);
if (fgets(buf, sizeof(buf), stdin) == NULL)
{
free(hash);
return -1;
}
if (strncasecmp(buf, "yes", 3) != 0)
{
free(hash);
return -1;
}
if (ssh_write_knownhost(session) < 0)
{
fprintf(stderr, "Error %s\n", strerror(errno));
free(hash);
return -1;
}
break;
case SSH_SERVER_ERROR:
fprintf(stderr, "Error %s", ssh_get_error(session));
free(hash);
return -1;
}
free(hash);
return 0;
}
gint
remmina_ssh_auth_gui (RemminaSSH *ssh, RemminaInitDialog *dialog, gboolean threaded)
{
gchar *tips;
gchar *keyname;
gint ret;
size_t len;
guchar *pubkey;
ssh_key server_pubkey;
/* Check if the server's public key is known */
ret = ssh_is_server_known (ssh->session);
switch (ret)
{
case SSH_SERVER_KNOWN_OK:
break;
case SSH_SERVER_NOT_KNOWN:
case SSH_SERVER_FILE_NOT_FOUND:
case SSH_SERVER_KNOWN_CHANGED:
case SSH_SERVER_FOUND_OTHER:
if ( ssh_get_publickey(ssh->session, &server_pubkey) != SSH_OK )
{
remmina_ssh_set_error(ssh, "ssh_get_publickey() has failed: %s");
return 0;
}
if ( ssh_get_publickey_hash(server_pubkey, SSH_PUBLICKEY_HASH_MD5, &pubkey, &len) != 0 ) {
ssh_key_free(server_pubkey);
remmina_ssh_set_error(ssh, "ssh_get_publickey_hash() has failed: %s");
return 0;
}
ssh_key_free(server_pubkey);
keyname = ssh_get_hexa (pubkey, len);
if (threaded) gdk_threads_enter();
if (ret == SSH_SERVER_NOT_KNOWN || ret == SSH_SERVER_FILE_NOT_FOUND)
{
ret = remmina_init_dialog_serverkey_unknown (dialog, keyname);
}
else
{
ret = remmina_init_dialog_serverkey_changed (dialog, keyname);
}
if (threaded)
{ gdk_flush();gdk_threads_leave();}
ssh_string_free_char(keyname);
ssh_clean_pubkey_hash (&pubkey);
if (ret != GTK_RESPONSE_OK) return -1;
ssh_write_knownhost (ssh->session);
break;
case SSH_SERVER_ERROR:
default:
remmina_ssh_set_error (ssh, "SSH known host checking failed: %s");
return 0;
}
/* Try empty password or existing password first */
ret = remmina_ssh_auth (ssh, NULL);
if (ret > 0) return 1;
/* Requested for a non-empty password */
if (ret < 0)
{
if (!dialog) return -1;
switch (ssh->auth)
{
case SSH_AUTH_PASSWORD:
tips = _("Authenticating %s's password to SSH server %s...");
keyname = _("SSH password");
break;
case SSH_AUTH_PUBLICKEY:
tips = _("Authenticating %s's identity to SSH server %s...");
keyname = _("SSH private key passphrase");
break;
default:
return FALSE;
}
if (ssh->auth != SSH_AUTH_AUTO_PUBLICKEY)
{
if (threaded) gdk_threads_enter();
remmina_init_dialog_set_status (dialog, tips, ssh->user, ssh->server);
ret = remmina_init_dialog_authpwd (dialog, keyname, FALSE);
if (threaded)
{ gdk_flush();gdk_threads_leave();}
if (ret != GTK_RESPONSE_OK) return -1;
}
ret = remmina_ssh_auth (ssh, dialog->password);
}
if (ret <= 0)
{
return 0;
}
return 1;
}
/**
* @brief Check if the server is known.
*
* Checks the user's known host file for a previous connection to the
* current server.
*
* @param[in] session The SSH session to use.
*
* @returns SSH_SERVER_KNOWN_OK: The server is known and has not changed.\n
* SSH_SERVER_KNOWN_CHANGED: The server key has changed. Either you
* are under attack or the administrator
* changed the key. You HAVE to warn the
* user about a possible attack.\n
* SSH_SERVER_FOUND_OTHER: The server gave use a key of a type while
* we had an other type recorded. It is a
* possible attack.\n
* SSH_SERVER_NOT_KNOWN: The server is unknown. User should
* confirm the MD5 is correct.\n
* SSH_SERVER_FILE_NOT_FOUND: The known host file does not exist. The
* host is thus unknown. File will be
* created if host key is accepted.\n
* SSH_SERVER_ERROR: Some error happened.
*
* @see ssh_get_pubkey_hash()
*
* @bug There is no current way to remove or modify an entry into the known
* host table.
*/
int ssh_is_server_known(ssh_session session) {
FILE *file = NULL;
char **tokens;
char *host;
char *hostport;
const char *type;
int match;
int ret = SSH_SERVER_NOT_KNOWN;
enter_function();
if (session->knownhosts == NULL) {
if (ssh_options_apply(session) < 0) {
ssh_set_error(session, SSH_REQUEST_DENIED,
"Can't find a known_hosts file");
leave_function();
return SSH_SERVER_FILE_NOT_FOUND;
}
}
if (session->host == NULL) {
ssh_set_error(session, SSH_FATAL,
"Can't verify host in known hosts if the hostname isn't known");
leave_function();
return SSH_SERVER_ERROR;
}
if (session->current_crypto == NULL){
ssh_set_error(session, SSH_FATAL,
"ssh_is_host_known called without cryptographic context");
leave_function();
return SSH_SERVER_ERROR;
}
host = ssh_lowercase(session->host);
hostport = ssh_hostport(host,session->port);
if (host == NULL || hostport == NULL) {
ssh_set_error_oom(session);
SAFE_FREE(host);
SAFE_FREE(hostport);
leave_function();
return SSH_SERVER_ERROR;
}
do {
tokens = ssh_get_knownhost_line(session, &file,
session->knownhosts, &type);
/* End of file, return the current state */
if (tokens == NULL) {
break;
}
match = match_hashed_host(session, host, tokens[0]);
if (match == 0){
match = match_hostname(hostport, tokens[0], strlen(tokens[0]));
}
if (match == 0) {
match = match_hostname(host, tokens[0], strlen(tokens[0]));
}
if (match == 0) {
match = match_hashed_host(session, hostport, tokens[0]);
}
if (match) {
/* We got a match. Now check the key type */
if (strcmp(session->current_crypto->server_pubkey_type, type) != 0) {
/* Different type. We don't override the known_changed error which is
* more important */
if (ret != SSH_SERVER_KNOWN_CHANGED)
ret = SSH_SERVER_FOUND_OTHER;
tokens_free(tokens);
continue;
}
/* so we know the key type is good. We may get a good key or a bad key. */
match = check_public_key(session, tokens);
tokens_free(tokens);
if (match < 0) {
ret = SSH_SERVER_ERROR;
break;
} else if (match == 1) {
ret = SSH_SERVER_KNOWN_OK;
break;
} else if(match == 0) {
/* We override the status with the wrong key state */
ret = SSH_SERVER_KNOWN_CHANGED;
}
} else {
tokens_free(tokens);
}
} while (1);
if ( (ret == SSH_SERVER_NOT_KNOWN) && (session->StrictHostKeyChecking == 0) ) {
ssh_write_knownhost(session);
ret = SSH_SERVER_KNOWN_OK;
}
SAFE_FREE(host);
SAFE_FREE(hostport);
if (file != NULL) {
fclose(file);
}
/* Return the current state at end of file */
leave_function();
return ret;
}
/**
Verifying the target host.
@param session is the created ssh session
@return the server status
*/
int SSHSession::verifyKnownHost(ssh_session session) {
unsigned char *hash = NULL;
auto state = ssh_is_server_known(session);
auto hlen = ssh_get_pubkey_hash(session, &hash);
char buf[10];
char *hexa;
if (hlen < 0)
return -1;
switch (state) {
case SSH_SERVER_KNOWN_OK:
return 1; // ok
case SSH_SERVER_KNOWN_CHANGED:
std::cout << "Host key for server changed: it is now" << std::endl;
ssh_print_hexa("Public key hash", hash, hlen);
delete hash;
return -1;
case SSH_SERVER_FOUND_OTHER:
std::cout << "The host key for this server was not found but an other type of key exists." << std::endl;
delete hash;
return -1;
case SSH_SERVER_FILE_NOT_FOUND:
std::cout << "Could not find known host file." << std::endl;
std::cout << "If you accept the host key here, the file will be automatically created." << std::endl;
delete hash;
return -1;
case SSH_SERVER_NOT_KNOWN:
hexa = ssh_get_hexa(hash, hlen);
std::cout << "The server is unknown. Do you trust the host key?" << std::endl;
std::cout << "Public key hash: " << hexa << std::endl;
delete hexa;
if (fgets(buf, sizeof(buf), stdin) == NULL) {
delete hash;
return -1;
}
if (strncasecmp(buf, "yes", 3) != 0) {
delete hash;
return -1;
}
if (ssh_write_knownhost(session) < 0) {
std::cout << "Error" << std::endl;
delete hash;
return -1;
}
break;
case SSH_SERVER_ERROR:
std::cout << "Error" << ssh_get_error(session) << std::endl;
delete hash;
return -1;
}
delete hash;
return 0;
}
static int _sftp_connect(const char *uri) {
char *scheme = NULL;
char *user = NULL;
char *passwd = NULL;
char *host = NULL;
unsigned int port = 0;
char *path = NULL;
unsigned char *hash = NULL;
int hlen;
int rc = -1;
int state = SSH_SERVER_ERROR;
int timeout = 10;
int method;
char *verbosity;
if (_connected) {
return 0;
}
rc = c_parse_uri(uri, &scheme, &user, &passwd, &host, &port, &path);
if (rc < 0) {
goto out;
}
DEBUG_SFTP(("csync_sftp - conntecting to: %s\n", host));
/* create the session */
_ssh_session = ssh_new();
if (_ssh_session == NULL) {
fprintf(stderr, "csync_sftp - error creating new connection: %s\n",
strerror(errno));
rc = -1;
goto out;
}
rc = ssh_options_set(_ssh_session, SSH_OPTIONS_TIMEOUT, &timeout);
if (rc < 0) {
fprintf(stderr, "csync_sftp - error setting options: %s\n",
strerror(errno));
goto out;
}
rc = ssh_options_set(_ssh_session, SSH_OPTIONS_COMPRESSION_C_S, "none");
if (rc < 0) {
fprintf(stderr, "csync_sftp - error setting options: %s\n",
strerror(errno));
goto out;
}
rc = ssh_options_set(_ssh_session, SSH_OPTIONS_COMPRESSION_S_C, "none");
if (rc < 0) {
fprintf(stderr, "csync_sftp - error setting options: %s\n",
strerror(errno));
goto out;
}
ssh_options_set(_ssh_session, SSH_OPTIONS_HOST, host);
if (rc < 0) {
fprintf(stderr, "csync_sftp - error setting options: %s\n",
strerror(errno));
goto out;
}
if (port) {
ssh_options_set(_ssh_session, SSH_OPTIONS_PORT, &port);
if (rc < 0) {
fprintf(stderr, "csync_sftp - error setting options: %s\n",
strerror(errno));
goto out;
}
DEBUG_SFTP(("csync_sftp - port set to: %d\n", port));
}
if (user && *user) {
ssh_options_set(_ssh_session, SSH_OPTIONS_USER, user);
if (rc < 0) {
fprintf(stderr, "csync_sftp - error setting options: %s\n",
strerror(errno));
goto out;
}
DEBUG_SFTP(("csync_sftp - username set to: %s\n", user));
}
verbosity = getenv("CSYNC_SFTP_LOG_VERBOSITY");
if (verbosity) {
rc = ssh_options_set(_ssh_session, SSH_OPTIONS_LOG_VERBOSITY_STR, verbosity);
if (rc < 0) {
goto out;
}
}
/* read ~/.ssh/config */
rc = ssh_options_parse_config(_ssh_session, NULL);
if (rc < 0) {
goto out;
}
_ssh_callbacks = (ssh_callbacks) c_malloc(sizeof(struct ssh_callbacks_struct));
if (_ssh_callbacks == NULL) {
rc = -1;
goto out;
}
ZERO_STRUCTP(_ssh_callbacks);
_ssh_callbacks->userdata = _userdata;
_ssh_callbacks->auth_function = _ssh_auth_callback;
ssh_callbacks_init(_ssh_callbacks);
ssh_set_callbacks(_ssh_session, _ssh_callbacks);
rc = ssh_connect(_ssh_session);
if (rc < 0) {
fprintf(stderr, "csync_sftp - error connecting to the server: %s\n", ssh_get_error(_ssh_session));
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
goto out;
}
hlen = ssh_get_pubkey_hash(_ssh_session, &hash);
if (hlen < 0) {
fprintf(stderr, "csync_sftp - error connecting to the server: %s\n",
ssh_get_error(_ssh_session));
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
goto out;
}
/* check the server public key hash */
state = ssh_is_server_known(_ssh_session);
switch (state) {
case SSH_SERVER_KNOWN_OK:
break;
case SSH_SERVER_KNOWN_CHANGED:
fprintf(stderr, "csync_sftp - The host key for this server was "
"not found, but another type of key exists.\n"
"An attacker might change the default server key to confuse your "
"client into thinking the key does not exist.\n"
"Please contact your system administrator.\n"
"%s\n", ssh_get_error(_ssh_session));
ssh_print_hexa("csync_sftp - public key hash", hash, hlen);
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
break;
case SSH_SERVER_FOUND_OTHER:
fprintf(stderr, "csync_sftp - the host key for this server was not "
"found but an other type of key exists.\n");
fprintf(stderr, "csync_sftp - an attacker might change the default "
"server key to confuse your client into thinking the key does not "
"exist\n");
fprintf(stderr, "The host key for the server %s has changed.\n"
"This could either mean that DNS SPOOFING is happening or the IP "
"address for the host and its host key have changed at the same time.\n"
"The fingerprint for the key sent by the remote host is:\n", host);
ssh_print_hexa("", hash, hlen);
fprintf(stderr, "Please contact your system administrator.\n"
"%s\n", ssh_get_error(_ssh_session));
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
break;
case SSH_SERVER_NOT_KNOWN:
if (_authcb) {
char *hexa;
char *prompt;
char buf[4] = {0};
hexa = ssh_get_hexa(hash, hlen);
if (hexa == NULL) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
if (asprintf(&prompt,
"The authenticity of host '%s' can't be established.\n"
"RSA key fingerprint is %s.\n"
"Are you sure you want to continue connecting (yes/no)?",
host, hexa) < 0 ) {
free(hexa);
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
free(hexa);
if ((*_authcb)(prompt, buf, sizeof(buf), 1, 0, _userdata) < 0) {
free(prompt);
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
free(prompt);
if (strncasecmp(buf, "yes", 3) != 0) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
if (ssh_write_knownhost(_ssh_session) < 0) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
} else {
fprintf(stderr,"csync_sftp - the server is unknown. Connect manually to "
"the host to retrieve the public key hash, then try again.\n");
}
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
break;
case SSH_SERVER_ERROR:
fprintf(stderr, "%s\n", ssh_get_error(_ssh_session));
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
break;
default:
break;
}
/* Try to authenticate */
rc = ssh_userauth_none(_ssh_session, NULL);
if (rc == SSH_AUTH_ERROR) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
#if 0
/* authenticate with the server */
if (passwd && *passwd) {
DEBUG_SFTP(("csync_sftp - authenticating with user/password\n"));
/*
* This is tunneled cleartext password authentication and possibly needs
* to be allowed by the ssh server. Set 'PasswordAuthentication yes'
*/
auth = ssh_userauth_password(_ssh_session, user, passwd);
} else {
DEBUG_SFTP(("csync_sftp - authenticating with pubkey\n"));
auth = ssh_userauth_autopubkey(_ssh_session, NULL);
}
if (auth == SSH_AUTH_ERROR) {
fprintf(stderr, "csync_sftp - authenticating with pubkey: %s\n",
ssh_get_error(_ssh_session));
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
if (auth != SSH_AUTH_SUCCESS) {
if (_authcb != NULL) {
auth = auth_kbdint(_ssh_session);
if (auth == SSH_AUTH_ERROR) {
fprintf(stderr,"csync_sftp - authentication failed: %s\n",
ssh_get_error(_ssh_session));
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
} else {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
}
}
#endif
method = ssh_auth_list(_ssh_session);
while (rc != SSH_AUTH_SUCCESS) {
/* Try to authenticate with public key first */
if (method & SSH_AUTH_METHOD_PUBLICKEY) {
rc = ssh_userauth_autopubkey(_ssh_session, NULL);
if (rc == SSH_AUTH_ERROR) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
} else if (rc == SSH_AUTH_SUCCESS) {
break;
}
}
/* Try to authenticate with keyboard interactive */
if (method & SSH_AUTH_METHOD_INTERACTIVE) {
rc = auth_kbdint(_ssh_session, user, passwd);
if (rc == SSH_AUTH_ERROR) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
} else if (rc == SSH_AUTH_SUCCESS) {
break;
}
}
/* Try to authenticate with password */
if ((method & SSH_AUTH_METHOD_PASSWORD) && passwd && *passwd) {
rc = ssh_userauth_password(_ssh_session, user, passwd);
if (rc == SSH_AUTH_ERROR) {
ssh_disconnect(_ssh_session);
_ssh_session = NULL;
ssh_finalize();
rc = -1;
goto out;
} else if (rc == SSH_AUTH_SUCCESS) {
break;
}
}
}
DEBUG_SFTP(("csync_sftp - creating sftp channel...\n"));
/* start the sftp session */
_sftp_session = sftp_new(_ssh_session);
if (_sftp_session == NULL) {
fprintf(stderr, "csync_sftp - sftp error initialising channel: %s\n", ssh_get_error(_ssh_session));
rc = -1;
goto out;
}
rc = sftp_init(_sftp_session);
if (rc < 0) {
fprintf(stderr, "csync_sftp - error initialising sftp: %s\n", ssh_get_error(_ssh_session));
goto out;
}
DEBUG_SFTP(("csync_sftp - connection established...\n"));
_connected = 1;
rc = 0;
out:
SAFE_FREE(scheme);
SAFE_FREE(user);
SAFE_FREE(passwd);
SAFE_FREE(host);
SAFE_FREE(path);
SAFE_FREE(hash);
return rc;
}
int main(int argc, char **argv){
SSH_SESSION *session;
SSH_OPTIONS *options;
int auth=0;
char *password;
char *banner;
int state;
char buf[10];
unsigned char hash[MD5_DIGEST_LEN];
options=ssh_options_new();
if(ssh_options_getopt(options,&argc, argv))
usage();
opts(argc,argv);
signal(SIGTERM,do_exit);
if(user)
ssh_options_set_username(options,user);
ssh_options_set_host(options,host);
session=ssh_new();
ssh_set_options(session,options);
if(ssh_connect(session)){
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
ssh_disconnect(session);
ssh_finalize();
return 1;
}
state=ssh_is_server_known(session);
switch(state){
case SSH_SERVER_KNOWN_OK:
break; /* ok */
case SSH_SERVER_KNOWN_CHANGED:
fprintf(stderr,"Host key for server changed : server's one is now :\n");
ssh_get_pubkey_hash(session,hash);
ssh_print_hexa("Public key hash",hash,MD5_DIGEST_LEN);
fprintf(stderr,"For security reason, connection will be stopped\n");
ssh_disconnect(session);
ssh_finalize();
exit(-1);
case SSH_SERVER_FOUND_OTHER:
fprintf(stderr,"The host key for this server was not found but an other type of key exists.\n");
fprintf(stderr,"An attacker might change the default server key to confuse your client"
"into thinking the key does not exist\n"
"We advise you to rerun the client with -d or -r for more safety.\n");
ssh_disconnect(session);
ssh_finalize();
exit(-1);
case SSH_SERVER_NOT_KNOWN:
fprintf(stderr,"The server is unknown. Do you trust the host key ?\n");
ssh_get_pubkey_hash(session,hash);
ssh_print_hexa("Public key hash",hash,MD5_DIGEST_LEN);
fgets(buf,sizeof(buf),stdin);
if(strncasecmp(buf,"yes",3)!=0){
ssh_disconnect(session);
exit(-1);
}
fprintf(stderr,"This new key will be written on disk for further usage. do you agree ?\n");
fgets(buf,sizeof(buf),stdin);
if(strncasecmp(buf,"yes",3)==0){
if(ssh_write_knownhost(session))
fprintf(stderr,"error %s\n",ssh_get_error(session));
}
break;
case SSH_SERVER_ERROR:
fprintf(stderr,"%s",ssh_get_error(session));
ssh_disconnect(session);
ssh_finalize();
exit(-1);
}
/* no ? you should :) */
auth=ssh_userauth_autopubkey(session);
if(auth==SSH_AUTH_ERROR){
fprintf(stderr,"Authenticating with pubkey: %s\n",ssh_get_error(session));
ssh_finalize();
return -1;
}
banner=ssh_get_issue_banner(session);
if(banner){
printf("%s\n",banner);
free(banner);
}
if(auth!=SSH_AUTH_SUCCESS){
auth=auth_kbdint(session);
if(auth==SSH_AUTH_ERROR){
fprintf(stderr,"authenticating with keyb-interactive: %s\n",
ssh_get_error(session));
ssh_finalize();
return -1;
}
}
if(auth!=SSH_AUTH_SUCCESS){
password=getpass("Password : "******"Authentication failed: %s\n",ssh_get_error(session));
ssh_disconnect(session);
ssh_finalize();
return -1;
}
memset(password,0,strlen(password));
}
ssh_say(1,"Authentication success\n");
printf("%s\n",argv[0]);
if(strstr(argv[0],"sftp")){
sftp=1;
ssh_say(1,"doing sftp instead\n");
}
if(!sftp){
if(!cmds[0])
shell(session);
else
batch_shell(session);
}
else
do_sftp(session);
if(!sftp && !cmds[0])
do_cleanup();
ssh_disconnect(session);
ssh_finalize();
return 0;
}
bool
SSHClient::sshConnect(int /* fd */, std::string &hostname)
{
// GNASH_REPORT_FUNCTION;
char *password;
char *banner;
char *hexa;
// We always need a hostname to connect to
if (ssh_options_set(_session, SSH_OPTIONS_HOST, hostname.c_str()) < 0) {
log_error(_("Couldn't set hostname option"));
return false;
}
// We always need a user name for the connection
if (_user.empty()) {
if (ssh_options_set(_session, SSH_OPTIONS_USER, _user.c_str()) < 0) {
log_error(_("Couldn't set user name option"));
return false;
}
}
// Start a new session
_session = ssh_new();
if(ssh_connect(_session)){
log_error(_("Connection failed : %s\n"), ssh_get_error(_session));
sshShutdown();
return false;
}
_state = ssh_is_server_known(_session);
unsigned char *hash = 0;
int hlen = ssh_get_pubkey_hash(_session, &hash);
if (hlen < 0) {
sshShutdown();
return false;
}
switch(_state){
case SSH_SERVER_KNOWN_OK: // ok
log_debug(_("SSH Server is currently known: %d"), _state);
break;
case SSH_SERVER_KNOWN_CHANGED:
log_error(_("Host key for server changed : server's one is now: "));
ssh_print_hexa(_("Public key hash"), hash, hlen);
free(hash);
log_error(_("For security reason, connection will be stopped"));
sshShutdown();
return false;;
case SSH_SERVER_FOUND_OTHER:
log_error(_("The host key for this server was not found but an other type of key exists."));
log_error(_("An attacker might change the default server key to confuse your client"
" into thinking the key does not exist"
"We advise you to rerun the client with -d or -r for more safety."));
sshShutdown();
return false;;
case SSH_SERVER_NOT_KNOWN:
hexa = ssh_get_hexa(hash, hlen);
free(hash);
// FIXME: for now, accecpt all new keys, and update the
// $HOME/.ssh/know_hosts file.
#if 0
log_error(_("The server is unknown. Do you trust the host key ? (yes,no)"));
log_error(_("Public key hash: %s"), hexa);
free(hexa);
fgets(buf, sizeof(buf), stdin);
if(strncasecmp(buf, "yes", 3) != 0){
sshShutdown();
return false;
}
log_error(_("This new key will be written on disk for further usage. do you agree? (yes,no) "));
fgets(buf, sizeof(buf), stdin);
if(strncasecmp(buf, "yes", 3)==0){
if(ssh_write_knownhost(_session))
log_error(ssh_get_error(_session));
}
#else
if(ssh_write_knownhost(_session)) {
log_error(ssh_get_error(_session));
}
#endif
break;
case SSH_SERVER_ERROR:
free(hash);
log_error(ssh_get_error(_session));
sshShutdown();
return false;
}
free(hash);
ssh_userauth_none(_session, NULL);
int auth = ssh_auth_list(_session);
// log_debug("auth: 0x%04x", auth);
log_debug(_("supported auth methods: "));
if (auth & SSH_AUTH_METHOD_PUBLICKEY) {
log_debug(_("\tpublickey"));
}
if (auth & SSH_AUTH_METHOD_INTERACTIVE) {
log_debug(_("\tkeyboard-interactive"));
}
/* no ? you should :) */
auth=ssh_userauth_autopubkey(_session, NULL);
if(auth == SSH_AUTH_ERROR){
log_debug(_("Authenticating with pubkey: %s"), ssh_get_error(_session));
ssh_finalize();
return false;
}
banner = ssh_get_issue_banner(_session);
if(banner){
log_debug(banner);
free(banner);
}
if(auth != SSH_AUTH_SUCCESS){
auth = authKbdint(_session);
if(auth == SSH_AUTH_ERROR){
log_error(_("authenticating with keyb-interactive: %s"),
ssh_get_error(_session));
ssh_finalize();
return false;
}
}
if(auth != SSH_AUTH_SUCCESS){
password = getpass("Password: "******"Authentication failed: %s"), ssh_get_error(_session));
ssh_disconnect(_session);
ssh_finalize();
return false;
}
memset(password, 0, strlen(password));
}
ssh_log(_session, SSH_LOG_FUNCTIONS, "Authentication success");
#if 0
if(strstr(argv[0],"sftp")){
sftp = 1;
ssh_log(_session, SSH_LOG_FUNCTIONS, "Doing sftp instead");
}
if(!sftp){
if(!cmds[0])
shell(_session);
else
batch_shell(_session);
}
else
do_sftp(_session);
if(!sftp && !cmds[0])
do_cleanup(0);
#endif
return true;
}
// Verify if Server is a known host.
int SSH_Socket::verify_knownhost()
{
int state;
size_t hlen;
unsigned char *hash = nullptr;
char *hexa;
state = ssh_is_server_known(session);
ssh_key srv_pubkey;
int rc;
rc = ssh_get_publickey(session, &srv_pubkey);
if(rc < 0)
{
return -1;
}
rc = ssh_get_publickey_hash(srv_pubkey, SSH_PUBLICKEY_HASH_SHA1, &hash, &hlen);
ssh_key_free(srv_pubkey);
if(rc < 0)
{
return -1;
}
switch(state)
{
case SSH_SERVER_KNOWN_OK:
break; /* ok */
case SSH_SERVER_KNOWN_CHANGED:
std::cout << "Host key for server changed: it is now" << std::endl;
ssh_print_hexa("Public key hash", hash, hlen);
std::cout << "For security reasons, connection will be stopped" << std::endl;
free(hash);
return -1;
case SSH_SERVER_FOUND_OTHER:
std::cout << "The host key for this server was not found but an other"
<< "type of key exists." << std::endl;
std::cout << "An attacker might change the default server key to"
<< "confuse your client into thinking the key does not exist" << std::endl;
free(hash);
return -1;
case SSH_SERVER_FILE_NOT_FOUND:
std::cout << "Could not find known host file." << std::endl;
std::cout << "If you accept the host key here, the file will be"
<< "automatically created." << std::endl;
/* fallback to SSH_SERVER_NOT_KNOWN behavior */
case SSH_SERVER_NOT_KNOWN:
hexa = ssh_get_hexa(hash, hlen);
//Do you trust the host key?\n");
std::cout << "The server is unknown. Adding Key." << std::endl;
std::cout << "Public key hash: " << hexa << std::endl;
free(hexa);
/*
if (fgets(buf, sizeof(buf), stdin) == NULL)
{
free(hash);
return -1;
}
if (strncasecmp(buf, "yes", 3) != 0)
{
free(hash);
return -1;
}
*/
if(ssh_write_knownhost(session) < 0)
{
std::cout << "Error: " << strerror(errno) << std::endl;
free(hash);
return -1;
}
break;
case SSH_SERVER_ERROR:
std::cout << "Error: " << ssh_get_error(session) << std::endl;
free(hash);
return -1;
}
free(hash);
return 0;
}
