qga/commands-posix-ssh.c

   1  /*
   2   * This work is licensed under the terms of the GNU GPL, version 2 or later.
   3   * See the COPYING file in the top-level directory.
   4   */
   5 #include "qemu/osdep.h"
   6
   7 #include <glib-unix.h>
   8 #include <glib/gstdio.h>
   9 #include <locale.h>
  10 #include <pwd.h>
  11
  12 #include "qapi/error.h"
  13 #include "qga-qapi-commands.h"
  14
  15 #ifdef QGA_BUILD_UNIT_TEST
  16 static struct passwd *
  17 test_get_passwd_entry(const gchar *user_name, GError **error)
  18 {
  19     struct passwd *p;
  20     int ret;
  21
  22     if (!user_name || g_strcmp0(user_name, g_get_user_name())) {
  23         g_set_error(error, G_UNIX_ERROR, 0, "Invalid user name");
  24         return NULL;
  25     }
  26
  27     p = g_new0(struct passwd, 1);
  28     p->pw_dir = (char *)g_get_home_dir();
  29     p->pw_uid = geteuid();
  30     p->pw_gid = getegid();
  31
  32     ret = g_mkdir_with_parents(p->pw_dir, 0700);
  33     g_assert(ret == 0);
  34
  35     return p;
  36 }
  37
  38 #define g_unix_get_passwd_entry_qemu(username, err) \
  39    test_get_passwd_entry(username, err)
  40 #endif
  41
  42 static struct passwd *
  43 get_passwd_entry(const char *username, Error **errp)
  44 {
  45     g_autoptr(GError) err = NULL;
  46     struct passwd *p;
  47
  48     ERRP_GUARD();
  49
  50     p = g_unix_get_passwd_entry_qemu(username, &err);
  51     if (p == NULL) {
  52         error_setg(errp, "failed to lookup user '%s': %s",
  53                    username, err->message);
  54         return NULL;
  55     }
  56
  57     return p;
  58 }
  59
  60 static bool
  61 mkdir_for_user(const char *path, const struct passwd *p,
  62                mode_t mode, Error **errp)
  63 {
  64     ERRP_GUARD();
  65
  66     if (g_mkdir(path, mode) == -1) {
  67         error_setg(errp, "failed to create directory '%s': %s",
  68                    path, g_strerror(errno));
  69         return false;
  70     }
  71
  72     if (chown(path, p->pw_uid, p->pw_gid) == -1) {
  73         error_setg(errp, "failed to set ownership of directory '%s': %s",
  74                    path, g_strerror(errno));
  75         return false;
  76     }
  77
  78     if (chmod(path, mode) == -1) {
  79         error_setg(errp, "failed to set permissions of directory '%s': %s",
  80                    path, g_strerror(errno));
  81         return false;
  82     }
  83
  84     return true;
  85 }
  86
  87 static bool
  88 check_openssh_pub_key(const char *key, Error **errp)
  89 {
  90     ERRP_GUARD();
  91
  92     /* simple sanity-check, we may want more? */
  93     if (!key || key[0] == '#' || strchr(key, '\n')) {
  94         error_setg(errp, "invalid OpenSSH public key: '%s'", key);
  95         return false;
  96     }
  97
  98     return true;
  99 }
 100
 101 static bool
 102 check_openssh_pub_keys(strList *keys, size_t *nkeys, Error **errp)
 103 {
 104     size_t n = 0;
 105     strList *k;
 106
 107     ERRP_GUARD();
 108
 109     for (k = keys; k != NULL; k = k->next) {
 110         if (!check_openssh_pub_key(k->value, errp)) {
 111             return false;
 112         }
 113         n++;
 114     }
 115
 116     if (nkeys) {
 117         *nkeys = n;
 118     }
 119     return true;
 120 }
 121
 122 static bool
 123 write_authkeys(const char *path, const GStrv keys,
 124                const struct passwd *p, Error **errp)
 125 {
 126     g_autofree char *contents = NULL;
 127     g_autoptr(GError) err = NULL;
 128
 129     ERRP_GUARD();
 130
 131     contents = g_strjoinv("\n", keys);
 132     if (!g_file_set_contents(path, contents, -1, &err)) {
 133         error_setg(errp, "failed to write to '%s': %s", path, err->message);
 134         return false;
 135     }
 136
 137     if (chown(path, p->pw_uid, p->pw_gid) == -1) {
 138         error_setg(errp, "failed to set ownership of directory '%s': %s",
 139                    path, g_strerror(errno));
 140         return false;
 141     }
 142
 143     if (chmod(path, 0600) == -1) {
 144         error_setg(errp, "failed to set permissions of '%s': %s",
 145                    path, g_strerror(errno));
 146         return false;
 147     }
 148
 149     return true;
 150 }
 151
 152 static GStrv
 153 read_authkeys(const char *path, Error **errp)
 154 {
 155     g_autoptr(GError) err = NULL;
 156     g_autofree char *contents = NULL;
 157
 158     ERRP_GUARD();
 159
 160     if (!g_file_get_contents(path, &contents, NULL, &err)) {
 161         error_setg(errp, "failed to read '%s': %s", path, err->message);
 162         return NULL;
 163     }
 164
 165     return g_strsplit(contents, "\n", -1);
 166
 167 }
 168
 169 void
 170 qmp_guest_ssh_add_authorized_keys(const char *username, strList *keys,
 171                                   bool has_reset, bool reset,
 172                                   Error **errp)
 173 {
 174     g_autofree struct passwd *p = NULL;
 175     g_autofree char *ssh_path = NULL;
 176     g_autofree char *authkeys_path = NULL;
 177     g_auto(GStrv) authkeys = NULL;
 178     strList *k;
 179     size_t nkeys, nauthkeys;
 180
 181     ERRP_GUARD();
 182     reset = has_reset && reset;
 183
 184     if (!check_openssh_pub_keys(keys, &nkeys, errp)) {
 185         return;
 186     }
 187
 188     p = get_passwd_entry(username, errp);
 189     if (p == NULL) {
 190         return;
 191     }
 192
 193     ssh_path = g_build_filename(p->pw_dir, ".ssh", NULL);
 194     authkeys_path = g_build_filename(ssh_path, "authorized_keys", NULL);
 195
 196     if (!reset) {
 197         authkeys = read_authkeys(authkeys_path, NULL);
 198     }
 199     if (authkeys == NULL) {
 200         if (!g_file_test(ssh_path, G_FILE_TEST_IS_DIR) &&
 201             !mkdir_for_user(ssh_path, p, 0700, errp)) {
 202             return;
 203         }
 204     }
 205
 206     nauthkeys = authkeys ? g_strv_length(authkeys) : 0;
 207     authkeys = g_realloc_n(authkeys, nauthkeys + nkeys + 1, sizeof(char *));
 208     memset(authkeys + nauthkeys, 0, (nkeys + 1) * sizeof(char *));
 209
 210     for (k = keys; k != NULL; k = k->next) {
 211         if (g_strv_contains((const gchar * const *)authkeys, k->value)) {
 212             continue;
 213         }
 214         authkeys[nauthkeys++] = g_strdup(k->value);
 215     }
 216
 217     write_authkeys(authkeys_path, authkeys, p, errp);
 218 }
 219
 220 void
 221 qmp_guest_ssh_remove_authorized_keys(const char *username, strList *keys,
 222                                      Error **errp)
 223 {
 224     g_autofree struct passwd *p = NULL;
 225     g_autofree char *authkeys_path = NULL;
 226     g_autofree GStrv new_keys = NULL; /* do not own the strings */
 227     g_auto(GStrv) authkeys = NULL;
 228     GStrv a;
 229     size_t nkeys = 0;
 230
 231     ERRP_GUARD();
 232
 233     if (!check_openssh_pub_keys(keys, NULL, errp)) {
 234         return;
 235     }
 236
 237     p = get_passwd_entry(username, errp);
 238     if (p == NULL) {
 239         return;
 240     }
 241
 242     authkeys_path = g_build_filename(p->pw_dir, ".ssh",
 243                                      "authorized_keys", NULL);
 244     if (!g_file_test(authkeys_path, G_FILE_TEST_EXISTS)) {
 245         return;
 246     }
 247     authkeys = read_authkeys(authkeys_path, errp);
 248     if (authkeys == NULL) {
 249         return;
 250     }
 251
 252     new_keys = g_new0(char *, g_strv_length(authkeys) + 1);
 253     for (a = authkeys; *a != NULL; a++) {
 254         strList *k;
 255
 256         for (k = keys; k != NULL; k = k->next) {
 257             if (g_str_equal(k->value, *a)) {
 258                 break;
 259             }
 260         }
 261         if (k != NULL) {
 262             continue;
 263         }
 264
 265         new_keys[nkeys++] = *a;
 266     }
 267
 268     write_authkeys(authkeys_path, new_keys, p, errp);
 269 }
 270
 271 GuestAuthorizedKeys *
 272 qmp_guest_ssh_get_authorized_keys(const char *username, Error **errp)
 273 {
 274     g_autofree struct passwd *p = NULL;
 275     g_autofree char *authkeys_path = NULL;
 276     g_auto(GStrv) authkeys = NULL;
 277     g_autoptr(GuestAuthorizedKeys) ret = NULL;
 278     int i;
 279
 280     ERRP_GUARD();
 281
 282     p = get_passwd_entry(username, errp);
 283     if (p == NULL) {
 284         return NULL;
 285     }
 286
 287     authkeys_path = g_build_filename(p->pw_dir, ".ssh",
 288                                      "authorized_keys", NULL);
 289     authkeys = read_authkeys(authkeys_path, errp);
 290     if (authkeys == NULL) {
 291         return NULL;
 292     }
 293
 294     ret = g_new0(GuestAuthorizedKeys, 1);
 295     for (i = 0; authkeys[i] != NULL; i++) {
 296         g_strstrip(authkeys[i]);
 297         if (!authkeys[i][0] || authkeys[i][0] == '#') {
 298             continue;
 299         }
 300
 301         QAPI_LIST_PREPEND(ret->keys, g_strdup(authkeys[i]));
 302     }
 303
 304     return g_steal_pointer(&ret);
 305 }
 306
 307 #ifdef QGA_BUILD_UNIT_TEST
 308 #if GLIB_CHECK_VERSION(2, 60, 0)
 309 static const strList test_key2 = {
 310     .value = (char *)"algo key2 comments"
 311 };
 312
 313 static const strList test_key1_2 = {
 314     .value = (char *)"algo key1 comments",
 315     .next = (strList *)&test_key2,
 316 };
 317
 318 static char *
 319 test_get_authorized_keys_path(void)
 320 {
 321     return g_build_filename(g_get_home_dir(), ".ssh", "authorized_keys", NULL);
 322 }
 323
 324 static void
 325 test_authorized_keys_set(const char *contents)
 326 {
 327     g_autoptr(GError) err = NULL;
 328     g_autofree char *path = NULL;
 329     int ret;
 330
 331     path = g_build_filename(g_get_home_dir(), ".ssh", NULL);
 332     ret = g_mkdir_with_parents(path, 0700);
 333     g_assert(ret == 0);
 334     g_free(path);
 335
 336     path = test_get_authorized_keys_path();
 337     g_file_set_contents(path, contents, -1, &err);
 338     g_assert(err == NULL);
 339 }
 340
 341 static void
 342 test_authorized_keys_equal(const char *expected)
 343 {
 344     g_autoptr(GError) err = NULL;
 345     g_autofree char *path = NULL;
 346     g_autofree char *contents = NULL;
 347
 348     path = test_get_authorized_keys_path();
 349     g_file_get_contents(path, &contents, NULL, &err);
 350     g_assert(err == NULL);
 351
 352     g_assert(g_strcmp0(contents, expected) == 0);
 353 }
 354
 355 static void
 356 test_invalid_user(void)
 357 {
 358     Error *err = NULL;
 359
 360     qmp_guest_ssh_add_authorized_keys("", NULL, FALSE, FALSE, &err);
 361     error_free_or_abort(&err);
 362
 363     qmp_guest_ssh_remove_authorized_keys("", NULL, &err);
 364     error_free_or_abort(&err);
 365 }
 366
 367 static void
 368 test_invalid_key(void)
 369 {
 370     strList key = {
 371         .value = (char *)"not a valid\nkey"
 372     };
 373     Error *err = NULL;
 374
 375     qmp_guest_ssh_add_authorized_keys(g_get_user_name(), &key,
 376                                       FALSE, FALSE, &err);
 377     error_free_or_abort(&err);
 378
 379     qmp_guest_ssh_remove_authorized_keys(g_get_user_name(), &key, &err);
 380     error_free_or_abort(&err);
 381 }
 382
 383 static void
 384 test_add_keys(void)
 385 {
 386     Error *err = NULL;
 387
 388     qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
 389                                       (strList *)&test_key2,
 390                                       FALSE, FALSE,
 391                                       &err);
 392     g_assert(err == NULL);
 393
 394     test_authorized_keys_equal("algo key2 comments");
 395
 396     qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
 397                                       (strList *)&test_key1_2,
 398                                       FALSE, FALSE,
 399                                       &err);
 400     g_assert(err == NULL);
 401
 402     /*  key2 came first, and should'nt be duplicated */
 403     test_authorized_keys_equal("algo key2 comments\n"
 404                                "algo key1 comments");
 405 }
 406
 407 static void
 408 test_add_reset_keys(void)
 409 {
 410     Error *err = NULL;
 411
 412     qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
 413                                       (strList *)&test_key1_2,
 414                                       FALSE, FALSE,
 415                                       &err);
 416     g_assert(err == NULL);
 417
 418     /* reset with key2 only */
 419     test_authorized_keys_equal("algo key1 comments\n"
 420                                "algo key2 comments");
 421
 422     qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
 423                                       (strList *)&test_key2,
 424                                       TRUE, TRUE,
 425                                       &err);
 426     g_assert(err == NULL);
 427
 428     test_authorized_keys_equal("algo key2 comments");
 429
 430     /* empty should clear file */
 431     qmp_guest_ssh_add_authorized_keys(g_get_user_name(),
 432                                       (strList *)NULL,
 433                                       TRUE, TRUE,
 434                                       &err);
 435     g_assert(err == NULL);
 436
 437     test_authorized_keys_equal("");
 438 }
 439
 440 static void
 441 test_remove_keys(void)
 442 {
 443     Error *err = NULL;
 444     static const char *authkeys =
 445         "algo key1 comments\n"
 446         /* originally duplicated */
 447         "algo key1 comments\n"
 448         "# a commented line\n"
 449         "algo some-key another\n";
 450
 451     test_authorized_keys_set(authkeys);
 452     qmp_guest_ssh_remove_authorized_keys(g_get_user_name(),
 453                                          (strList *)&test_key2, &err);
 454     g_assert(err == NULL);
 455     test_authorized_keys_equal(authkeys);
 456
 457     qmp_guest_ssh_remove_authorized_keys(g_get_user_name(),
 458                                          (strList *)&test_key1_2, &err);
 459     g_assert(err == NULL);
 460     test_authorized_keys_equal("# a commented line\n"
 461                                "algo some-key another\n");
 462 }
 463
 464 static void
 465 test_get_keys(void)
 466 {
 467     Error *err = NULL;
 468     static const char *authkeys =
 469         "algo key1 comments\n"
 470         "# a commented line\n"
 471         "algo some-key another\n";
 472     g_autoptr(GuestAuthorizedKeys) ret = NULL;
 473     strList *k;
 474     size_t len = 0;
 475
 476     test_authorized_keys_set(authkeys);
 477
 478     ret = qmp_guest_ssh_get_authorized_keys(g_get_user_name(), &err);
 479     g_assert(err == NULL);
 480
 481     for (len = 0, k = ret->keys; k != NULL; k = k->next) {
 482         g_assert(g_str_has_prefix(k->value, "algo "));
 483         len++;
 484     }
 485
 486     g_assert(len == 2);
 487 }
 488
 489 int main(int argc, char *argv[])
 490 {
 491     setlocale(LC_ALL, "");
 492
 493     g_test_init(&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
 494
 495     g_test_add_func("/qga/ssh/invalid_user", test_invalid_user);
 496     g_test_add_func("/qga/ssh/invalid_key", test_invalid_key);
 497     g_test_add_func("/qga/ssh/add_keys", test_add_keys);
 498     g_test_add_func("/qga/ssh/add_reset_keys", test_add_reset_keys);
 499     g_test_add_func("/qga/ssh/remove_keys", test_remove_keys);
 500     g_test_add_func("/qga/ssh/get_keys", test_get_keys);
 501
 502     return g_test_run();
 503 }
 504 #else
 505 int main(int argc, char *argv[])
 506 {
 507     g_test_message("test skipped, needs glib >= 2.60");
 508     return 0;
 509 }
 510 #endif /* GLIB_2_60 */
 511 #endif /* BUILD_UNIT_TEST */