tests/test-crypto-secret.c

   1 /*
   2  * QEMU Crypto secret handling
   3  *
   4  * Copyright (c) 2015 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22
  23 #include "crypto/init.h"
  24 #include "crypto/secret.h"
  25 #include "qapi/error.h"
  26 #include "qemu/module.h"
  27 #ifdef CONFIG_TEST_SECRET_KEYRING
  28 #include "crypto/secret_keyring.h"
  29 #include <keyutils.h>
  30 #endif
  31
  32 static void test_secret_direct(void)
  33 {
  34     Object *sec = object_new_with_props(
  35         TYPE_QCRYPTO_SECRET,
  36         object_get_objects_root(),
  37         "sec0",
  38         &error_abort,
  39         "data", "123456",
  40         NULL);
  41
  42     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
  43                                              &error_abort);
  44
  45     g_assert_cmpstr(pw, ==, "123456");
  46
  47     object_unparent(sec);
  48     g_free(pw);
  49 }
  50
  51
  52 static void test_secret_indirect_good(void)
  53 {
  54     Object *sec;
  55     char *fname = NULL;
  56     int fd = g_file_open_tmp("qemu-test-crypto-secret-XXXXXX",
  57                              &fname,
  58                              NULL);
  59
  60     g_assert(fd >= 0);
  61     g_assert_nonnull(fname);
  62
  63     g_assert(write(fd, "123456", 6) == 6);
  64
  65     sec = object_new_with_props(
  66         TYPE_QCRYPTO_SECRET,
  67         object_get_objects_root(),
  68         "sec0",
  69         &error_abort,
  70         "file", fname,
  71         NULL);
  72
  73     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
  74                                              &error_abort);
  75
  76     g_assert_cmpstr(pw, ==, "123456");
  77
  78     object_unparent(sec);
  79     g_free(pw);
  80     close(fd);
  81     unlink(fname);
  82     g_free(fname);
  83 }
  84
  85
  86 static void test_secret_indirect_badfile(void)
  87 {
  88     Object *sec = object_new_with_props(
  89         TYPE_QCRYPTO_SECRET,
  90         object_get_objects_root(),
  91         "sec0",
  92         NULL,
  93         "file", "does-not-exist",
  94         NULL);
  95
  96     g_assert(sec == NULL);
  97 }
  98
  99
 100 static void test_secret_indirect_emptyfile(void)
 101 {
 102     Object *sec;
 103     char *fname = NULL;
 104     int fd = g_file_open_tmp("qemu-test-crypto-secretXXXXXX",
 105                              &fname,
 106                              NULL);
 107
 108     g_assert(fd >= 0);
 109     g_assert_nonnull(fname);
 110
 111     sec = object_new_with_props(
 112         TYPE_QCRYPTO_SECRET,
 113         object_get_objects_root(),
 114         "sec0",
 115         &error_abort,
 116         "file", fname,
 117         NULL);
 118
 119     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 120                                              &error_abort);
 121
 122     g_assert_cmpstr(pw, ==, "");
 123
 124     object_unparent(sec);
 125     g_free(pw);
 126     close(fd);
 127     unlink(fname);
 128     g_free(fname);
 129 }
 130
 131 #ifdef CONFIG_TEST_SECRET_KEYRING
 132
 133 #define DESCRIPTION "qemu_test_secret"
 134 #define PAYLOAD "Test Payload"
 135
 136
 137 static void test_secret_keyring_good(void)
 138 {
 139     char key_str[16];
 140     Object *sec;
 141     int32_t key = add_key("user", DESCRIPTION, PAYLOAD,
 142                           strlen(PAYLOAD), KEY_SPEC_PROCESS_KEYRING);
 143
 144     g_assert(key >= 0);
 145
 146     snprintf(key_str, sizeof(key_str), "0x%08x", key);
 147     sec = object_new_with_props(
 148         TYPE_QCRYPTO_SECRET_KEYRING,
 149         object_get_objects_root(),
 150         "sec0",
 151         &error_abort,
 152         "serial", key_str,
 153         NULL);
 154
 155     assert(0 <= keyctl_unlink(key, KEY_SPEC_PROCESS_KEYRING));
 156     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 157                                              &error_abort);
 158     g_assert_cmpstr(pw, ==, PAYLOAD);
 159
 160     object_unparent(sec);
 161     g_free(pw);
 162 }
 163
 164
 165 static void test_secret_keyring_revoked_key(void)
 166 {
 167     char key_str[16];
 168     Object *sec;
 169     int32_t key = add_key("user", DESCRIPTION, PAYLOAD,
 170                           strlen(PAYLOAD), KEY_SPEC_PROCESS_KEYRING);
 171     g_assert(key >= 0);
 172     g_assert_false(keyctl_revoke(key));
 173
 174     snprintf(key_str, sizeof(key_str), "0x%08x", key);
 175     sec = object_new_with_props(
 176         TYPE_QCRYPTO_SECRET_KEYRING,
 177         object_get_objects_root(),
 178         "sec0",
 179         NULL,
 180         "serial", key_str,
 181         NULL);
 182
 183     g_assert(errno == EKEYREVOKED);
 184     g_assert(sec == NULL);
 185
 186     keyctl_unlink(key, KEY_SPEC_PROCESS_KEYRING);
 187 }
 188
 189
 190 static void test_secret_keyring_expired_key(void)
 191 {
 192     char key_str[16];
 193     Object *sec;
 194     int32_t key = add_key("user", DESCRIPTION, PAYLOAD,
 195                           strlen(PAYLOAD), KEY_SPEC_PROCESS_KEYRING);
 196     g_assert(key >= 0);
 197     g_assert_false(keyctl_set_timeout(key, 1));
 198     sleep(1);
 199
 200     snprintf(key_str, sizeof(key_str), "0x%08x", key);
 201     sec = object_new_with_props(
 202         TYPE_QCRYPTO_SECRET_KEYRING,
 203         object_get_objects_root(),
 204         "sec0",
 205         NULL,
 206         "serial", key_str,
 207         NULL);
 208
 209     g_assert(errno == EKEYEXPIRED);
 210     g_assert(sec == NULL);
 211
 212     keyctl_unlink(key, KEY_SPEC_PROCESS_KEYRING);
 213 }
 214
 215
 216 static void test_secret_keyring_bad_serial_key(void)
 217 {
 218     Object *sec;
 219
 220     sec = object_new_with_props(
 221         TYPE_QCRYPTO_SECRET_KEYRING,
 222         object_get_objects_root(),
 223         "sec0",
 224         NULL,
 225         "serial", "1",
 226         NULL);
 227
 228     g_assert(errno == ENOKEY);
 229     g_assert(sec == NULL);
 230 }
 231
 232 /*
 233  * TODO
 234  * test_secret_keyring_bad_key_access_right() is not working yet.
 235  * We don't know yet if this due a bug in the Linux kernel or
 236  * whether it's normal syscall behavior.
 237  * We've requested information from kernel maintainers.
 238  * See: <https://www.spinics.net/lists/keyrings/index.html>
 239  * Thread: 'security/keys: remove possessor verify after key permission check'
 240  */
 241
 242 static void test_secret_keyring_bad_key_access_right(void)
 243 {
 244     char key_str[16];
 245     Object *sec;
 246
 247     g_test_skip("TODO: Need responce from Linux kernel maintainers");
 248     return;
 249
 250     int32_t key = add_key("user", DESCRIPTION, PAYLOAD,
 251                           strlen(PAYLOAD), KEY_SPEC_PROCESS_KEYRING);
 252     g_assert(key >= 0);
 253     g_assert_false(keyctl_setperm(key, KEY_POS_ALL & (~KEY_POS_READ)));
 254
 255     snprintf(key_str, sizeof(key_str), "0x%08x", key);
 256
 257     sec = object_new_with_props(
 258         TYPE_QCRYPTO_SECRET_KEYRING,
 259         object_get_objects_root(),
 260         "sec0",
 261         NULL,
 262         "serial", key_str,
 263         NULL);
 264
 265     g_assert(errno == EACCES);
 266     g_assert(sec == NULL);
 267
 268     keyctl_unlink(key, KEY_SPEC_PROCESS_KEYRING);
 269 }
 270
 271 #endif /* CONFIG_TEST_SECRET_KEYRING */
 272
 273 static void test_secret_noconv_base64_good(void)
 274 {
 275     Object *sec = object_new_with_props(
 276         TYPE_QCRYPTO_SECRET,
 277         object_get_objects_root(),
 278         "sec0",
 279         &error_abort,
 280         "data", "MTIzNDU2",
 281         "format", "base64",
 282         NULL);
 283
 284     char *pw = qcrypto_secret_lookup_as_base64("sec0",
 285                                                &error_abort);
 286
 287     g_assert_cmpstr(pw, ==, "MTIzNDU2");
 288
 289     object_unparent(sec);
 290     g_free(pw);
 291 }
 292
 293
 294 static void test_secret_noconv_base64_bad(void)
 295 {
 296     Object *sec = object_new_with_props(
 297         TYPE_QCRYPTO_SECRET,
 298         object_get_objects_root(),
 299         "sec0",
 300         NULL,
 301         "data", "MTI$NDU2",
 302         "format", "base64",
 303         NULL);
 304
 305     g_assert(sec == NULL);
 306 }
 307
 308
 309 static void test_secret_noconv_utf8(void)
 310 {
 311     Object *sec = object_new_with_props(
 312         TYPE_QCRYPTO_SECRET,
 313         object_get_objects_root(),
 314         "sec0",
 315         &error_abort,
 316         "data", "123456",
 317         "format", "raw",
 318         NULL);
 319
 320     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 321                                              &error_abort);
 322
 323     g_assert_cmpstr(pw, ==, "123456");
 324
 325     object_unparent(sec);
 326     g_free(pw);
 327 }
 328
 329
 330 static void test_secret_conv_base64_utf8valid(void)
 331 {
 332     Object *sec = object_new_with_props(
 333         TYPE_QCRYPTO_SECRET,
 334         object_get_objects_root(),
 335         "sec0",
 336         &error_abort,
 337         "data", "MTIzNDU2",
 338         "format", "base64",
 339         NULL);
 340
 341     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 342                                              &error_abort);
 343
 344     g_assert_cmpstr(pw, ==, "123456");
 345
 346     object_unparent(sec);
 347     g_free(pw);
 348 }
 349
 350
 351 static void test_secret_conv_base64_utf8invalid(void)
 352 {
 353     Object *sec = object_new_with_props(
 354         TYPE_QCRYPTO_SECRET,
 355         object_get_objects_root(),
 356         "sec0",
 357         &error_abort,
 358         "data", "f0VMRgIBAQAAAA==",
 359         "format", "base64",
 360         NULL);
 361
 362     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 363                                              NULL);
 364     g_assert(pw == NULL);
 365
 366     object_unparent(sec);
 367 }
 368
 369
 370 static void test_secret_conv_utf8_base64(void)
 371 {
 372     Object *sec = object_new_with_props(
 373         TYPE_QCRYPTO_SECRET,
 374         object_get_objects_root(),
 375         "sec0",
 376         &error_abort,
 377         "data", "123456",
 378         NULL);
 379
 380     char *pw = qcrypto_secret_lookup_as_base64("sec0",
 381                                                &error_abort);
 382
 383     g_assert_cmpstr(pw, ==, "MTIzNDU2");
 384
 385     object_unparent(sec);
 386     g_free(pw);
 387 }
 388
 389
 390 static void test_secret_crypt_raw(void)
 391 {
 392     Object *master = object_new_with_props(
 393         TYPE_QCRYPTO_SECRET,
 394         object_get_objects_root(),
 395         "master",
 396         &error_abort,
 397         "data", "9miloPQCzGy+TL6aonfzVcptibCmCIhKzrnlfwiWivk=",
 398         "format", "base64",
 399         NULL);
 400     Object *sec = object_new_with_props(
 401         TYPE_QCRYPTO_SECRET,
 402         object_get_objects_root(),
 403         "sec0",
 404         &error_abort,
 405         "data",
 406         "\xCC\xBF\xF7\x09\x46\x19\x0B\x52\x2A\x3A\xB4\x6B\xCD\x7A\xB0\xB0",
 407         "format", "raw",
 408         "keyid", "master",
 409         "iv", "0I7Gw/TKuA+Old2W2apQ3g==",
 410         NULL);
 411
 412     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 413                                              &error_abort);
 414
 415     g_assert_cmpstr(pw, ==, "123456");
 416
 417     object_unparent(sec);
 418     object_unparent(master);
 419     g_free(pw);
 420 }
 421
 422
 423 static void test_secret_crypt_base64(void)
 424 {
 425     Object *master = object_new_with_props(
 426         TYPE_QCRYPTO_SECRET,
 427         object_get_objects_root(),
 428         "master",
 429         &error_abort,
 430         "data", "9miloPQCzGy+TL6aonfzVcptibCmCIhKzrnlfwiWivk=",
 431         "format", "base64",
 432         NULL);
 433     Object *sec = object_new_with_props(
 434         TYPE_QCRYPTO_SECRET,
 435         object_get_objects_root(),
 436         "sec0",
 437         &error_abort,
 438         "data", "zL/3CUYZC1IqOrRrzXqwsA==",
 439         "format", "base64",
 440         "keyid", "master",
 441         "iv", "0I7Gw/TKuA+Old2W2apQ3g==",
 442         NULL);
 443
 444     char *pw = qcrypto_secret_lookup_as_utf8("sec0",
 445                                              &error_abort);
 446
 447     g_assert_cmpstr(pw, ==, "123456");
 448
 449     object_unparent(sec);
 450     object_unparent(master);
 451     g_free(pw);
 452 }
 453
 454
 455 static void test_secret_crypt_short_key(void)
 456 {
 457     Object *master = object_new_with_props(
 458         TYPE_QCRYPTO_SECRET,
 459         object_get_objects_root(),
 460         "master",
 461         &error_abort,
 462         "data", "9miloPQCzGy+TL6aonfzVc",
 463         "format", "base64",
 464         NULL);
 465     Object *sec = object_new_with_props(
 466         TYPE_QCRYPTO_SECRET,
 467         object_get_objects_root(),
 468         "sec0",
 469         NULL,
 470         "data", "zL/3CUYZC1IqOrRrzXqwsA==",
 471         "format", "raw",
 472         "keyid", "master",
 473         "iv", "0I7Gw/TKuA+Old2W2apQ3g==",
 474         NULL);
 475
 476     g_assert(sec == NULL);
 477     object_unparent(master);
 478 }
 479
 480
 481 static void test_secret_crypt_short_iv(void)
 482 {
 483     Object *master = object_new_with_props(
 484         TYPE_QCRYPTO_SECRET,
 485         object_get_objects_root(),
 486         "master",
 487         &error_abort,
 488         "data", "9miloPQCzGy+TL6aonfzVcptibCmCIhKzrnlfwiWivk=",
 489         "format", "base64",
 490         NULL);
 491     Object *sec = object_new_with_props(
 492         TYPE_QCRYPTO_SECRET,
 493         object_get_objects_root(),
 494         "sec0",
 495         NULL,
 496         "data", "zL/3CUYZC1IqOrRrzXqwsA==",
 497         "format", "raw",
 498         "keyid", "master",
 499         "iv", "0I7Gw/TKuA+Old2W2a",
 500         NULL);
 501
 502     g_assert(sec == NULL);
 503     object_unparent(master);
 504 }
 505
 506
 507 static void test_secret_crypt_missing_iv(void)
 508 {
 509     Object *master = object_new_with_props(
 510         TYPE_QCRYPTO_SECRET,
 511         object_get_objects_root(),
 512         "master",
 513         &error_abort,
 514         "data", "9miloPQCzGy+TL6aonfzVcptibCmCIhKzrnlfwiWivk=",
 515         "format", "base64",
 516         NULL);
 517     Object *sec = object_new_with_props(
 518         TYPE_QCRYPTO_SECRET,
 519         object_get_objects_root(),
 520         "sec0",
 521         NULL,
 522         "data", "zL/3CUYZC1IqOrRrzXqwsA==",
 523         "format", "raw",
 524         "keyid", "master",
 525         NULL);
 526
 527     g_assert(sec == NULL);
 528     object_unparent(master);
 529 }
 530
 531
 532 static void test_secret_crypt_bad_iv(void)
 533 {
 534     Object *master = object_new_with_props(
 535         TYPE_QCRYPTO_SECRET,
 536         object_get_objects_root(),
 537         "master",
 538         &error_abort,
 539         "data", "9miloPQCzGy+TL6aonfzVcptibCmCIhKzrnlfwiWivk=",
 540         "format", "base64",
 541         NULL);
 542     Object *sec = object_new_with_props(
 543         TYPE_QCRYPTO_SECRET,
 544         object_get_objects_root(),
 545         "sec0",
 546         NULL,
 547         "data", "zL/3CUYZC1IqOrRrzXqwsA==",
 548         "format", "raw",
 549         "keyid", "master",
 550         "iv", "0I7Gw/TK$$uA+Old2W2a",
 551         NULL);
 552
 553     g_assert(sec == NULL);
 554     object_unparent(master);
 555 }
 556
 557
 558 int main(int argc, char **argv)
 559 {
 560     module_call_init(MODULE_INIT_QOM);
 561     g_test_init(&argc, &argv, NULL);
 562
 563     g_assert(qcrypto_init(NULL) == 0);
 564
 565     g_test_add_func("/crypto/secret/direct",
 566                     test_secret_direct);
 567     g_test_add_func("/crypto/secret/indirect/good",
 568                     test_secret_indirect_good);
 569     g_test_add_func("/crypto/secret/indirect/badfile",
 570                     test_secret_indirect_badfile);
 571     g_test_add_func("/crypto/secret/indirect/emptyfile",
 572                     test_secret_indirect_emptyfile);
 573
 574 #ifdef CONFIG_TEST_SECRET_KEYRING
 575     g_test_add_func("/crypto/secret/keyring/good",
 576                     test_secret_keyring_good);
 577     g_test_add_func("/crypto/secret/keyring/revoked_key",
 578                     test_secret_keyring_revoked_key);
 579     g_test_add_func("/crypto/secret/keyring/expired_key",
 580                     test_secret_keyring_expired_key);
 581     g_test_add_func("/crypto/secret/keyring/bad_serial_key",
 582                     test_secret_keyring_bad_serial_key);
 583     g_test_add_func("/crypto/secret/keyring/bad_key_access_right",
 584                     test_secret_keyring_bad_key_access_right);
 585 #endif /* CONFIG_TEST_SECRET_KEYRING */
 586
 587     g_test_add_func("/crypto/secret/noconv/base64/good",
 588                     test_secret_noconv_base64_good);
 589     g_test_add_func("/crypto/secret/noconv/base64/bad",
 590                     test_secret_noconv_base64_bad);
 591     g_test_add_func("/crypto/secret/noconv/utf8",
 592                     test_secret_noconv_utf8);
 593     g_test_add_func("/crypto/secret/conv/base64/utf8valid",
 594                     test_secret_conv_base64_utf8valid);
 595     g_test_add_func("/crypto/secret/conv/base64/utf8invalid",
 596                     test_secret_conv_base64_utf8invalid);
 597     g_test_add_func("/crypto/secret/conv/utf8/base64",
 598                     test_secret_conv_utf8_base64);
 599
 600     g_test_add_func("/crypto/secret/crypt/raw",
 601                     test_secret_crypt_raw);
 602     g_test_add_func("/crypto/secret/crypt/base64",
 603                     test_secret_crypt_base64);
 604     g_test_add_func("/crypto/secret/crypt/shortkey",
 605                     test_secret_crypt_short_key);
 606     g_test_add_func("/crypto/secret/crypt/shortiv",
 607                     test_secret_crypt_short_iv);
 608     g_test_add_func("/crypto/secret/crypt/missingiv",
 609                     test_secret_crypt_missing_iv);
 610     g_test_add_func("/crypto/secret/crypt/badiv",
 611                     test_secret_crypt_bad_iv);
 612
 613     return g_test_run();
 614 }