/*
* keyfiles.c - private and public key handling for authentication.
*
* This file is part of the SSH Library
*
* Copyright (c) 2003-2009 by Aris Adamantiadis
* Copyright (c) 2009 by Andreas Schneider <asn@cryptomilk.org>
*
* The SSH Library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1 of the License, or (at your
* option) any later version.
*
* The SSH Library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
* License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with the SSH Library; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
* MA 02111-1307, USA.
*/
#include "config.h"
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include "libssh/priv.h"
#include "libssh/session.h"
#include "libssh/buffer.h"
#include "libssh/misc.h"
#include "libssh/dh.h"
#include "libssh/pki.h"
#include "libssh/options.h"
#include "libssh/knownhosts.h"
/*todo: remove this include */
#include "libssh/string.h"
#include "libssh/token.h"
#ifndef _WIN32
# include <netinet/in.h>
# include <arpa/inet.h>
#endif
/**
* @addtogroup libssh_session
*
* @{
*/
/**
* @internal
*
* @brief Return one line of known host file.
*
* This will return a token array containing (host|ip), keytype and key.
*
* @param[out] file A pointer to the known host file. Could be pointing to
* NULL at start.
*
* @param[in] filename The file name of the known host file.
*
* @param[out] found_type A pointer to a string to be set with the found key
* type.
*
* @returns The found_type type of key (ie "dsa","ssh-rsa"). Don't
* free that value. NULL if no match was found or the file
* was not found.
*/
static struct ssh_tokens_st *ssh_get_knownhost_line(FILE **file,
const char *filename,
const char **found_type)
{
char buffer[4096] = {0};
char *ptr;
struct ssh_tokens_st *tokens;
if (*file == NULL) {
*file = fopen(filename,"r");
if (*file == NULL) {
return NULL;
}
}
while (fgets(buffer, sizeof(buffer), *file)) {
ptr = strchr(buffer, '\n');
if (ptr) {
*ptr = '\0';
}
ptr = strchr(buffer,'\r');
if (ptr) {
*ptr = '\0';
}
if (buffer[0] == '\0' || buffer[0] == '#') {
continue; /* skip empty lines */
}
tokens = ssh_tokenize(buffer, ' ');
if (tokens == NULL) {
fclose(*file);
*file = NULL;
return NULL;
}
if (tokens->tokens[0] == NULL ||
tokens->tokens[1] == NULL ||
tokens->tokens[2] == NULL)
{
/* it should have at least 3 tokens */
ssh_tokens_free(tokens);
continue;
}
*found_type = tokens->tokens[1];
return tokens;
}
fclose(*file);
*file = NULL;
/* we did not find anything, end of file*/
return NULL;
}
/**
* @internal
*
* @brief Check the public key in the known host line matches the public key of
* the currently connected server.
*
* @param[in] session The SSH session to use.
*
* @param[in] tokens A list of tokens in the known_hosts line.
*
* @returns 1 if the key matches, 0 if the key doesn't match and -1
* on error.
*/
static int check_public_key(ssh_session session, char **tokens) {
ssh_string pubkey_blob = NULL;
ssh_buffer pubkey_buffer;
char *pubkey_64;
int rc;
/* ssh-dss or ssh-rsa */
pubkey_64 = tokens[2];
pubkey_buffer = base64_to_bin(pubkey_64);
if (pubkey_buffer == NULL) {
ssh_set_error(session, SSH_FATAL,
"Verifying that server is a known host: base64 error");
return -1;
}
rc = ssh_dh_get_current_server_publickey_blob(session, &pubkey_blob);
if (rc != 0) {
ssh_buffer_free(pubkey_buffer);
return -1;
}
if (ssh_buffer_get_len(pubkey_buffer) != ssh_string_len(pubkey_blob)) {
ssh_string_free(pubkey_blob);
ssh_buffer_free(pubkey_buffer);
return 0;
}
/* now test that they are identical */
if (memcmp(ssh_buffer_get(pubkey_buffer), ssh_string_data(pubkey_blob),
ssh_buffer_get_len(pubkey_buffer)) != 0) {
ssh_string_free(pubkey_blob);
ssh_buffer_free(pubkey_buffer);
return 0;
}
ssh_string_free(pubkey_blob);
ssh_buffer_free(pubkey_buffer);
return 1;
}
/**
* @internal
* @brief Check if a hostname matches a openssh-style hashed known host.
*
* @param[in] host The host to check.
*
* @param[in] hashed The hashed value.
*
* @returns 1 if it matches, 0 otherwise.
*/
static int match_hashed_host(const char *host, const char *sourcehash)
{
/* Openssh hash structure :
* |1|base64 encoded salt|base64 encoded hash
* hash is produced that way :
* hash := HMAC_SHA1(key=salt,data=host)
*/
unsigned char buffer[256] = {0};
ssh_buffer salt;
ssh_buffer hash;
HMACCTX mac;
char *source;
char *b64hash;
int match;
unsigned int size;
if (strncmp(sourcehash, "|1|", 3) != 0) {
return 0;
}
source = strdup(sourcehash + 3);
if (source == NULL) {
return 0;
}
b64hash = strchr(source, '|');
if (b64hash == NULL) {
/* Invalid hash */
SAFE_FREE(source);
return 0;
}
*b64hash = '\0';
b64hash++;
salt = base64_to_bin(source);
if (salt == NULL) {
SAFE_FREE(source);
return 0;
}
hash = base64_to_bin(b64hash);
SAFE_FREE(source);
if (hash == NULL) {
ssh_buffer_free(salt);
return 0;
}
mac = hmac_init(ssh_buffer_get(salt), ssh_buffer_get_len(salt), SSH_HMAC_SHA1);
if (mac == NULL) {
ssh_buffer_free(salt);
ssh_buffer_free(hash);
return 0;
}
size = sizeof(buffer);
hmac_update(mac, host, strlen(host));
hmac_final(mac, buffer, &size);
if (size == ssh_buffer_get_len(hash) &&
memcmp(buffer, ssh_buffer_get(hash), size) == 0) {
match = 1;
} else {
match = 0;
}
ssh_buffer_free(salt);
ssh_buffer_free(hash);
SSH_LOG(SSH_LOG_PACKET,
"Matching a hashed host: %s match=%d", host, match);
return match;
}
/* How it's working :
* 1- we open the known host file and bitch if it doesn't exist
* 2- we need to examine each line of the file, until going on state SSH_SERVER_KNOWN_OK:
* - there's a match. if the key is good, state is SSH_SERVER_KNOWN_OK,
* else it's SSH_SERVER_KNOWN_CHANGED (or SSH_SERVER_FOUND_OTHER)
* - there's no match : no change
*/
/**
* @brief This function is deprecated
*
* @deprecated Please use ssh_session_is_known_server()
* @see ssh_session_is_known_server()
*/
int ssh_is_server_known(ssh_session session)
{
FILE *file = NULL;
char *host;
char *hostport;
const char *type;
int match;
int i = 0;
char *files[3];
struct ssh_tokens_st *tokens;
int ret = SSH_SERVER_NOT_KNOWN;
if (session->opts.knownhosts == NULL) {
if (ssh_options_apply(session) < 0) {
ssh_set_error(session, SSH_REQUEST_DENIED,
"Can't find a known_hosts file");
return SSH_SERVER_FILE_NOT_FOUND;
}
}
if (session->opts.host == NULL) {
ssh_set_error(session, SSH_FATAL,
"Can't verify host in known hosts if the hostname isn't known");
return SSH_SERVER_ERROR;
}
if (session->current_crypto == NULL){
ssh_set_error(session, SSH_FATAL,
"ssh_is_host_known called without cryptographic context");
return SSH_SERVER_ERROR;
}
host = ssh_lowercase(session->opts.host);
hostport = ssh_hostport(host, session->opts.port > 0 ? session->opts.port : 22);
if (host == NULL || hostport == NULL) {
ssh_set_error_oom(session);
SAFE_FREE(host);
SAFE_FREE(hostport);
return SSH_SERVER_ERROR;
}
/* Set the list of known hosts files */
i = 0;
if (session->opts.global_knownhosts != NULL){
files[i++] = session->opts.global_knownhosts;
}
files[i++] = session->opts.knownhosts;
files[i] = NULL;
i = 0;
do {
tokens = ssh_get_knownhost_line(&file,
files[i],
&type);
/* End of file, return the current state or use next file */
if (tokens == NULL) {
++i;
if(files[i] == NULL)
break;
else
continue;
}
match = match_hashed_host(host, tokens->tokens[0]);
if (match == 0){
match = match_hostname(hostport, tokens->tokens[0],
strlen(tokens->tokens[0]));
}
if (match == 0) {
match = match_hostname(host, tokens->tokens[0],
strlen(tokens->tokens[0]));
}
if (match == 0) {
match = match_hashed_host(hostport, tokens->tokens[0]);
}
if (match) {
ssh_key pubkey = ssh_dh_get_current_server_publickey(session);
const char *pubkey_type = ssh_key_type_to_char(ssh_key_type(pubkey));
/* We got a match. Now check the key type */
if (strcmp(pubkey_type, type) != 0) {
SSH_LOG(SSH_LOG_PACKET,
"ssh_is_server_known: server type [%s] doesn't match the "
"type [%s] in known_hosts file",
pubkey_type,
type);
/* 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;
ssh_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);
ssh_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 {
ssh_tokens_free(tokens);
}
} while (1);
if ((ret == SSH_SERVER_NOT_KNOWN) &&
(session->opts.StrictHostKeyChecking == 0)) {
int rv = ssh_session_update_known_hosts(session);
if (rv != SSH_OK) {
ret = SSH_SERVER_ERROR;
} else {
ret = SSH_SERVER_KNOWN_OK;
}
}
SAFE_FREE(host);
SAFE_FREE(hostport);
if (file != NULL) {
fclose(file);
}
/* Return the current state at end of file */
return ret;
}
/**
* @deprecated Please use ssh_session_export_known_hosts_entry()
* @brief This function is deprecated.
*/
char * ssh_dump_knownhost(ssh_session session) {
ssh_key server_pubkey = NULL;
char *host;
char *hostport;
size_t len = 4096;
char *buffer;
char *b64_key;
int rc;
if (session->opts.host == NULL) {
ssh_set_error(session, SSH_FATAL,
"Can't write host in known hosts if the hostname isn't known");
return NULL;
}
host = ssh_lowercase(session->opts.host);
/* If using a nonstandard port, save the host in the [host]:port format */
if (session->opts.port > 0 && session->opts.port != 22) {
hostport = ssh_hostport(host, session->opts.port);
SAFE_FREE(host);
if (hostport == NULL) {
return NULL;
}
host = hostport;
hostport = NULL;
}
if (session->current_crypto==NULL) {
ssh_set_error(session, SSH_FATAL, "No current crypto context");
SAFE_FREE(host);
return NULL;
}
server_pubkey = ssh_dh_get_current_server_publickey(session);
if (server_pubkey == NULL){
ssh_set_error(session, SSH_FATAL, "No public key present");
SAFE_FREE(host);
return NULL;
}
buffer = calloc (1, 4096);
if (!buffer) {
SAFE_FREE(host);
return NULL;
}
rc = ssh_pki_export_pubkey_base64(server_pubkey, &b64_key);
if (rc < 0) {
SAFE_FREE(buffer);
SAFE_FREE(host);
return NULL;
}
snprintf(buffer, len,
"%s %s %s\n",
host,
server_pubkey->type_c,
b64_key);
SAFE_FREE(host);
SAFE_FREE(b64_key);
return buffer;
}
/**
* @deprecated Please use ssh_session_update_known_hosts()
* @brief This function is deprecated
*/
int ssh_write_knownhost(ssh_session session)
{
FILE *file;
char *buffer = NULL;
char *dir;
int rc;
if (session->opts.knownhosts == NULL) {
if (ssh_options_apply(session) < 0) {
ssh_set_error(session, SSH_FATAL, "Can't find a known_hosts file");
return SSH_ERROR;
}
}
errno = 0;
file = fopen(session->opts.knownhosts, "a");
if (file == NULL) {
if (errno == ENOENT) {
dir = ssh_dirname(session->opts.knownhosts);
if (dir == NULL) {
ssh_set_error(session, SSH_FATAL, "%s", strerror(errno));
return SSH_ERROR;
}
rc = ssh_mkdirs(dir, 0700);
if (rc < 0) {
ssh_set_error(session, SSH_FATAL,
"Cannot create %s directory: %s",
dir, strerror(errno));
SAFE_FREE(dir);
return SSH_ERROR;
}
SAFE_FREE(dir);
errno = 0;
file = fopen(session->opts.knownhosts, "a");
if (file == NULL) {
ssh_set_error(session, SSH_FATAL,
"Couldn't open known_hosts file %s"
" for appending: %s",
session->opts.knownhosts, strerror(errno));
return SSH_ERROR;
}
} else {
ssh_set_error(session, SSH_FATAL,
"Couldn't open known_hosts file %s for appending: %s",
session->opts.knownhosts, strerror(errno));
return SSH_ERROR;
}
}
rc = ssh_session_export_known_hosts_entry(session, &buffer);
if (rc != SSH_OK) {
fclose(file);
return SSH_ERROR;
}
if (fwrite(buffer, strlen(buffer), 1, file) != 1 || ferror(file)) {
SAFE_FREE(buffer);
fclose(file);
return -1;
}
SAFE_FREE(buffer);
fclose(file);
return 0;
}
#define KNOWNHOSTS_MAXTYPES 10
/** @} */