/*

* This work is licensed under the terms of the GNU GPL, version 2 or later.

* See the COPYING file in the top-level directory.

*/

#include "qemu/osdep.h"

#include <glib-unix.h>

#include <glib/gstdio.h>

#include <locale.h>

#include <pwd.h>

#include "qapi/error.h"

#include "qga-qapi-commands.h"

#ifdef QGA_BUILD_UNIT_TEST

static struct passwd *

test_get_passwd_entry(const gchar *user_name, GError **error)

{

struct passwd *p;

int ret;

if (!user_name || g_strcmp0(user_name, g_get_user_name())) {

g_set_error(error, G_UNIX_ERROR, 0, "Invalid user name");

return NULL;

}

p = g_new0(struct passwd, 1);

p->pw_dir = (char *)g_get_home_dir();

p->pw_uid = geteuid();

p->pw_gid = getegid();

ret = g_mkdir_with_parents(p->pw_dir, 0700);

g_assert(ret == 0);

return p;

}

#define g_unix_get_passwd_entry_qemu(username, err) \

test_get_passwd_entry(username, err)

#endif

static struct passwd *

get_passwd_entry(const char *username, Error **errp)

{

g_autoptr(GError) err = NULL;

struct passwd *p;

p = g_unix_get_passwd_entry_qemu(username, &err);

if (p == NULL) {

error_setg(errp, "failed to lookup user '%s': %s",

username, err->message);

return NULL;

}

return p;

}

static bool

mkdir_for_user(const char *path, const struct passwd *p,

mode_t mode, Error **errp)

{

if (g_mkdir(path, mode) == -1) {

error_setg(errp, "failed to create directory '%s': %s",

path, g_strerror(errno));

return false;

}

if (chown(path, p->pw_uid, p->pw_gid) == -1) {

error_setg(errp, "failed to set ownership of directory '%s': %s",

path, g_strerror(errno));

return false;

}

if (chmod(path, mode) == -1) {

error_setg(errp, "failed to set permissions of directory '%s': %s",

path, g_strerror(errno));

return false;

}

return true;

}

static bool

check_openssh_pub_key(const char *key, Error **errp)

{

/* simple sanity-check, we may want more? */

if (!key || key[0] == '#' || strchr(key, '\n')) {

error_setg(errp, "invalid OpenSSH public key: '%s'", key);

return false;

}

return true;

}

static bool

check_openssh_pub_keys(strList *keys, size_t *nkeys, Error **errp)

{

size_t n = 0;

strList *k;

for (k = keys; k != NULL; k = k->next) {

if (!check_openssh_pub_key(k->value, errp)) {

return false;

}

n++;

}

if (nkeys) {

*nkeys = n;

}

return true;

}

static bool

write_authkeys(const char *path, const GStrv keys,

const struct passwd *p, Error **errp)

{

g_autofree char *contents = NULL;

g_autoptr(GError) err = NULL;

contents = g_strjoinv("\n", keys);

if (!g_file_set_contents(path, contents, -1, &err)) {

error_setg(errp, "failed to write to '%s': %s", path, err->message);

return false;

}

if (chown(path, p->pw_uid, p->pw_gid) == -1) {

error_setg(errp, "failed to set ownership of directory '%s': %s",

path, g_strerror(errno));

return false;

}

if (chmod(path, 0600) == -1) {

error_setg(errp, "failed to set permissions of '%s': %s",

path, g_strerror(errno));

return false;

}

return true;

}

static GStrv

read_authkeys(const char *path, Error **errp)

{

g_autoptr(GError) err = NULL;

g_autofree char *contents = NULL;

if (!g_file_get_contents(path, &contents, NULL, &err)) {

error_setg(errp, "failed to read '%s': %s", path, err->message);

return NULL;

}

return g_strsplit(contents, "\n", -1);

}

void

qmp_guest_ssh_add_authorized_keys(const char *username, strList *keys,

bool has_reset, bool reset,

Error **errp)

{

g_autofree struct passwd *p = NULL;

g_autofree char *ssh_path = NULL;

g_autofree char *authkeys_path = NULL;

g_auto(GStrv) authkeys = NULL;

strList *k;

size_t nkeys, nauthkeys;

reset = has_reset && reset;

if (!check_openssh_pub_keys(keys, &nkeys, errp)) {

return;

}

p = get_passwd_entry(username, errp);

if (p == NULL) {

return;

}

ssh_path = g_build_filename(p->pw_dir, ".ssh", NULL);

authkeys_path = g_build_filename(ssh_path, "authorized_keys", NULL);

if (!reset) {

authkeys = read_authkeys(authkeys_path, NULL);

}

if (authkeys == NULL) {

if (!g_file_test(ssh_path, G_FILE_TEST_IS_DIR) &&

!mkdir_for_user(ssh_path, p, 0700, errp)) {

return;

}

}

nauthkeys = authkeys ? g_strv_length(authkeys) : 0;

authkeys = g_realloc_n(authkeys, nauthkeys + nkeys + 1, sizeof(char *));

memset(authkeys + nauthkeys, 0, (nkeys + 1) * sizeof(char *));

for (k = keys; k != NULL; k = k->next) {

if (g_strv_contains((const gchar * const *)authkeys, k->value)) {

continue;

}

authkeys[nauthkeys++] = g_strdup(k->value);

}

write_authkeys(authkeys_path, authkeys, p, errp);

}

void

qmp_guest_ssh_remove_authorized_keys(const char *username, strList *keys,

Error **errp)

{

g_autofree struct passwd *p = NULL;

g_autofree char *authkeys_path = NULL;

g_autofree GStrv new_keys = NULL; /* do not own the strings */

g_auto(GStrv) authkeys = NULL;

GStrv a;

size_t nkeys = 0;

if (!check_openssh_pub_keys(keys, NULL, errp)) {

return;

}

p = get_passwd_entry(username, errp);

if (p == NULL) {

return;

}

authkeys_path = g_build_filename(p->pw_dir, ".ssh",

"authorized_keys", NULL);

if (!g_file_test(authkeys_path, G_FILE_TEST_EXISTS)) {

return;

}

authkeys = read_authkeys(authkeys_path, errp);

if (authkeys == NULL) {

return;

}

new_keys = g_new0(char *, g_strv_length(authkeys) + 1);

for (a = authkeys; *a != NULL; a++) {

strList *k;

for (k = keys; k != NULL; k = k->next) {

if (g_str_equal(k->value, *a)) {

break;

}

}

if (k != NULL) {

continue;

}

new_keys[nkeys++] = *a;

}

write_authkeys(authkeys_path, new_keys, p, errp);

}

GuestAuthorizedKeys *

qmp_guest_ssh_get_authorized_keys(const char *username, Error **errp)

{

g_autofree struct passwd *p = NULL;

g_autofree char *authkeys_path = NULL;

g_auto(GStrv) authkeys = NULL;

g_autoptr(GuestAuthorizedKeys) ret = NULL;

int i;

p = get_passwd_entry(username, errp);

if (p == NULL) {

return NULL;

}

authkeys_path = g_build_filename(p->pw_dir, ".ssh",

"authorized_keys", NULL);

authkeys = read_authkeys(authkeys_path, errp);

if (authkeys == NULL) {

return NULL;

}

ret = g_new0(GuestAuthorizedKeys, 1);

for (i = 0; authkeys[i] != NULL; i++) {

g_strstrip(authkeys[i]);

if (!authkeys[i][0] || authkeys[i][0] == '#') {

continue;

}

QAPI_LIST_PREPEND(ret->keys, g_strdup(authkeys[i]));

}

return g_steal_pointer(&ret);

}

#ifdef QGA_BUILD_UNIT_TEST

#if GLIB_CHECK_VERSION(2, 60, 0)

static const strList test_key2 = {

.value = (char *)"algo key2 comments"

};

static const strList test_key1_2 = {

.value = (char *)"algo key1 comments",

.next = (strList *)&test_key2,

};

static char *

test_get_authorized_keys_path(void)

{

return g_build_filename(g_get_home_dir(), ".ssh", "authorized_keys", NULL);

}

static void

test_authorized_keys_set(const char *contents)

{

g_autoptr(GError) err = NULL;

g_autofree char *path = NULL;

int ret;

path = g_build_filename(g_get_home_dir(), ".ssh", NULL);

ret = g_mkdir_with_parents(path, 0700);

g_assert(ret == 0);

g_free(path);

path = test_get_authorized_keys_path();

g_file_set_contents(path, contents, -1, &err);

g_assert(err == NULL);

}

static void

test_authorized_keys_equal(const char *expected)

{

g_autoptr(GError) err = NULL;

g_autofree char *path = NULL;

g_autofree char *contents = NULL;

path = test_get_authorized_keys_path();

g_file_get_contents(path, &contents, NULL, &err);

g_assert(err == NULL);

g_assert(g_strcmp0(contents, expected) == 0);

}

static void

test_invalid_user(void)

{

Error *err = NULL;

qmp_guest_ssh_add_authorized_keys("", NULL, FALSE, FALSE, &err);

error_free_or_abort(&err);

qmp_guest_ssh_remove_authorized_keys("", NULL, &err);

error_free_or_abort(&err);

}

static void

test_invalid_key(void)

{

strList key = {

.value = (char *)"not a valid\nkey"

};

Error *err = NULL;

qmp_guest_ssh_add_authorized_keys(g_get_user_name(), &key,

FALSE, FALSE, &err);

error_free_or_abort(&err);

qmp_guest_ssh_remove_authorized_keys(g_get_user_name(), &key, &err);

error_free_or_abort(&err);

}

static void

test_add_keys(void)

{

Error *err = NULL;

qmp_guest_ssh_add_authorized_keys(g_get_user_name(),

(strList *)&test_key2,

FALSE, FALSE,

&err);

g_assert(err == NULL);

test_authorized_keys_equal("algo key2 comments");

qmp_guest_ssh_add_authorized_keys(g_get_user_name(),

(strList *)&test_key1_2,

FALSE, FALSE,

&err);

g_assert(err == NULL);

/* key2 came first, and should'nt be duplicated */

test_authorized_keys_equal("algo key2 comments\n"

"algo key1 comments");

}

static void

test_add_reset_keys(void)

{

Error *err = NULL;

qmp_guest_ssh_add_authorized_keys(g_get_user_name(),

(strList *)&test_key1_2,

FALSE, FALSE,

&err);

g_assert(err == NULL);

/* reset with key2 only */

test_authorized_keys_equal("algo key1 comments\n"

"algo key2 comments");

qmp_guest_ssh_add_authorized_keys(g_get_user_name(),

(strList *)&test_key2,

TRUE, TRUE,

&err);

g_assert(err == NULL);

test_authorized_keys_equal("algo key2 comments");

/* empty should clear file */

qmp_guest_ssh_add_authorized_keys(g_get_user_name(),

(strList *)NULL,

TRUE, TRUE,

&err);

g_assert(err == NULL);

test_authorized_keys_equal("");

}

static void

test_remove_keys(void)

{

Error *err = NULL;

static const char *authkeys =

"algo key1 comments\n"

/* originally duplicated */

"algo key1 comments\n"

"# a commented line\n"

"algo some-key another\n";

test_authorized_keys_set(authkeys);

qmp_guest_ssh_remove_authorized_keys(g_get_user_name(),

(strList *)&test_key2, &err);

g_assert(err == NULL);

test_authorized_keys_equal(authkeys);

qmp_guest_ssh_remove_authorized_keys(g_get_user_name(),

(strList *)&test_key1_2, &err);

g_assert(err == NULL);

test_authorized_keys_equal("# a commented line\n"

"algo some-key another\n");

}

static void

test_get_keys(void)

{

Error *err = NULL;

static const char *authkeys =

"algo key1 comments\n"

"# a commented line\n"

"algo some-key another\n";

g_autoptr(GuestAuthorizedKeys) ret = NULL;

strList *k;

size_t len = 0;

test_authorized_keys_set(authkeys);

ret = qmp_guest_ssh_get_authorized_keys(g_get_user_name(), &err);

g_assert(err == NULL);

for (len = 0, k = ret->keys; k != NULL; k = k->next) {

g_assert(g_str_has_prefix(k->value, "algo "));

len++;

}

g_assert(len == 2);

}

int main(int argc, char *argv[])

{

setlocale(LC_ALL, "");

g_test_init(&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);

g_test_add_func("/qga/ssh/invalid_user", test_invalid_user);

g_test_add_func("/qga/ssh/invalid_key", test_invalid_key);

g_test_add_func("/qga/ssh/add_keys", test_add_keys);

g_test_add_func("/qga/ssh/add_reset_keys", test_add_reset_keys);

g_test_add_func("/qga/ssh/remove_keys", test_remove_keys);

g_test_add_func("/qga/ssh/get_keys", test_get_keys);

return g_test_run();

}

#else

int main(int argc, char *argv[])

{

g_test_message("test skipped, needs glib >= 2.60");

return 0;

}

#endif /* GLIB_2_60 */

#endif /* BUILD_UNIT_TEST */