tests/plugin/heimdal-t.c

   1 /*
   2  * Test for the Heimdal shared module API.
   3  *
   4  * Written by Russ Allbery <eagle@eyrie.org>
   5  * Copyright 2009, 2013, 2014
   6  *     The Board of Trustees of the Leland Stanford Junior University
   7  *
   8  * See LICENSE for licensing terms.
   9  */
  10
  11 #include <config.h>
  12 #include <portable/krb5.h>
  13 #include <portable/system.h>
  14
  15 #include <dlfcn.h>
  16 #include <errno.h>
  17 #ifdef HAVE_KADM5_KADM5_PWCHECK_H
  18 # include <kadm5/kadm5-pwcheck.h>
  19 #endif
  20
  21 #include <tests/tap/basic.h>
  22 #include <tests/tap/kerberos.h>
  23 #include <tests/tap/process.h>
  24 #include <tests/tap/string.h>
  25 #include <util/macros.h>
  26
  27 /*
  28  * The password test data, generated from the JSON source.  Defines arrays
  29  * named *_tests, where * is the file name without the ".c" suffix.
  30  */
  31 #include <tests/data/passwords/cdb.c>
  32 #include <tests/data/passwords/classes.c>
  33 #include <tests/data/passwords/cracklib.c>
  34 #include <tests/data/passwords/length.c>
  35 #include <tests/data/passwords/letter.c>
  36 #include <tests/data/passwords/principal.c>
  37 #include <tests/data/passwords/sqlite.c>
  38
  39
  40 #ifndef HAVE_KADM5_KADM5_PWCHECK_H
  41 /*
  42  * If we're not building with Heimdal, we can't run this test and much of the
  43  * test won't even compile.  Replace this test with a small program that just
  44  * calls skip_all.
  45  */
  46 int
  47 main(void)
  48 {
  49     skip_all("not built against Heimdal libraries");
  50     return 0;
  51 }
  52
  53 #else
  54
  55 /*
  56  * Loads the Heimdal password change plugin and tests that its metadata is
  57  * correct.  Returns a pointer to the kadm5_pw_policy_verifier struct or bails
  58  * on failure to load the plugin.  Stores the handle in the last argument so
  59  * that the caller can free the handle at the end of the test suite.
  60  */
  61 static struct kadm5_pw_policy_verifier *
  62 load_plugin(void **handle)
  63 {
  64     char *path;
  65     struct kadm5_pw_policy_verifier *verifier;
  66
  67     /* Load the module. */
  68     path = test_file_path("../plugin/.libs/strength.so");
  69     if (path == NULL)
  70         bail("cannot find plugin");
  71     *handle = dlopen(path, RTLD_NOW);
  72     if (*handle == NULL)
  73         bail("cannot dlopen %s: %s", path, dlerror());
  74     test_file_path_free(path);
  75
  76     /* Find the dispatch table and do a basic sanity check. */
  77     verifier = dlsym(*handle, "kadm5_password_verifier");
  78     if (verifier == NULL)
  79         bail("cannot get kadm5_password_verifier symbol: %s", dlerror());
  80     if (verifier->funcs == NULL || verifier->funcs[0].func == NULL)
  81         bail("no verifier functions in module");
  82
  83     /* Verify the metadata. */
  84     is_string("krb5-strength", verifier->name, "Module name");
  85     is_string("Russ Allbery", verifier->vendor, "Module vendor");
  86     is_int(KADM5_PASSWD_VERSION_V1, verifier->version, "Module version");
  87     is_string("krb5-strength", verifier->funcs[0].name,
  88               "Module function name");
  89     ok(verifier->funcs[1].name == NULL, "Only one function in module");
  90
  91     /* Return the dispatch table. */
  92     return verifier;
  93 }
  94
  95
  96 /*
  97  * Given the dispatch table and a test case, call out to the password strength
  98  * checking module and check the results.
  99  */
 100 static void
 101 is_password_test(const struct kadm5_pw_policy_verifier *verifier,
 102                  const struct password_test *test)
 103 {
 104     krb5_context ctx;
 105     krb5_principal princ;
 106     krb5_error_code code;
 107     krb5_data password;
 108     int result;
 109     char error[BUFSIZ] = "";
 110
 111     /* Obtain a Kerberos context to use for parsing principal names. */
 112     code = krb5_init_context(&ctx);
 113     if (code != 0)
 114         bail_krb5(ctx, code, "cannot initialize Kerberos context");
 115
 116     /* Translate the test data into the form that the verifier expects. */
 117     code = krb5_parse_name(ctx, test->principal, &princ);
 118     if (code != 0)
 119         bail_krb5(ctx, code, "cannot parse principal %s", test->principal);
 120     password.data = (char *) test->password;
 121     password.length = strlen(test->password);
 122
 123     /* Call the verifier. */
 124     result = (verifier->funcs[0].func)(ctx, princ, &password, NULL, error,
 125                                        sizeof(error));
 126
 127     /* Heimdal only returns 0 or 1, so translate the expected code. */
 128     is_int(test->code == 0 ? 0 : 1, result, "%s (status)", test->name);
 129     is_string(test->error == NULL ? "" : test->error, error, "%s (error)",
 130               test->name);
 131
 132     /* Free data structures. */
 133     krb5_free_principal(ctx, princ);
 134     krb5_free_context(ctx);
 135 }
 136
 137
 138 int
 139 main(void)
 140 {
 141     char *path, *krb5_config, *krb5_config_empty, *tmpdir;
 142     char *setup_argv[12];
 143     size_t i, count;
 144     struct kadm5_pw_policy_verifier *verifier;
 145     void *handle;
 146
 147     /*
 148      * Calculate how many tests we have.  There are five tests for the module
 149      * metadata and two tests per password test.  We run the principal tests
 150      * three times, once each with CrackLib, CDB, and SQLite.
 151      */
 152     count = ARRAY_SIZE(cracklib_tests);
 153     count += 2 * ARRAY_SIZE(length_tests);
 154     count += ARRAY_SIZE(cdb_tests);
 155     count += ARRAY_SIZE(sqlite_tests);
 156     count += ARRAY_SIZE(classes_tests);
 157     count += ARRAY_SIZE(letter_tests);
 158     count += ARRAY_SIZE(principal_tests) * 3;
 159     plan(5 + count * 2);
 160
 161     /* Start with the krb5.conf that contains no dictionary configuration. */
 162     path = test_file_path("data/krb5.conf");
 163     if (path == NULL)
 164         bail("cannot find data/krb5.conf in the test suite");
 165     basprintf(&krb5_config_empty, "KRB5_CONFIG=%s", path);
 166     putenv(krb5_config_empty);
 167
 168     /* Load the plugin. */
 169     verifier = load_plugin(&handle);
 170
 171     /* Set up our krb5.conf with the dictionary configuration. */
 172     setup_argv[0] = test_file_path("data/make-krb5-conf");
 173     if (setup_argv[0] == NULL)
 174         bail("cannot find data/make-krb5-conf in the test suite");
 175     tmpdir = test_tmpdir();
 176     setup_argv[1] = path;
 177     setup_argv[2] = tmpdir;
 178     setup_argv[3] = (char *) "password_dictionary";
 179     basprintf(&setup_argv[4], "%s/data/dictionary", getenv("BUILD"));
 180     setup_argv[5] = NULL;
 181     run_setup((const char **) setup_argv);
 182
 183     /* Point KRB5_CONFIG at the newly-generated krb5.conf file. */
 184     basprintf(&krb5_config, "KRB5_CONFIG=%s/krb5.conf", tmpdir);
 185     putenv(krb5_config);
 186     free(krb5_config_empty);
 187
 188     /* Now, run all of the tests. */
 189     for (i = 0; i < ARRAY_SIZE(cracklib_tests); i++)
 190         is_password_test(verifier, &cracklib_tests[i]);
 191     for (i = 0; i < ARRAY_SIZE(principal_tests); i++)
 192         is_password_test(verifier, &principal_tests[i]);
 193
 194     /*
 195      * Add length restrictions and a maximum length for CrackLib.  This should
 196      * reject passwords as too short, but let through a password that's
 197      * actually in the CrackLib dictionary.
 198      */
 199     setup_argv[5] = (char *) "minimum_length";
 200     setup_argv[6] = (char *) "12";
 201     setup_argv[7] = (char *) "cracklib_maxlen";
 202     setup_argv[8] = (char *) "11";
 203     setup_argv[9] = NULL;
 204     run_setup((const char **) setup_argv);
 205
 206     /* Run the length tests. */
 207     for (i = 0; i < ARRAY_SIZE(length_tests); i++)
 208         is_password_test(verifier, &length_tests[i]);
 209
 210     /* Add simple character class restrictions. */
 211     setup_argv[5] = (char *) "minimum_different";
 212     setup_argv[6] = (char *) "8";
 213     setup_argv[7] = (char *) "require_ascii_printable";
 214     setup_argv[8] = (char *) "true";
 215     setup_argv[9] = (char *) "require_non_letter";
 216     setup_argv[10] = (char *) "true";
 217     setup_argv[11] = NULL;
 218     run_setup((const char **) setup_argv);
 219
 220     /* Run the simple character class tests. */
 221     for (i = 0; i < ARRAY_SIZE(letter_tests); i++)
 222         is_password_test(verifier, &letter_tests[i]);
 223
 224     /* Add complex character class restrictions and remove the dictionary. */
 225     free(setup_argv[4]);
 226     setup_argv[3] = (char *) "require_classes";
 227     setup_argv[4] = (char *) "8-19:lower,upper 8-15:digit 8-11:symbol 24-24:3";
 228     setup_argv[5] = NULL;
 229     run_setup((const char **) setup_argv);
 230
 231     /* Run the simple character class tests. */
 232     for (i = 0; i < ARRAY_SIZE(classes_tests); i++)
 233         is_password_test(verifier, &classes_tests[i]);
 234
 235     /* Try the length checks again with no dictionary at all. */
 236     setup_argv[3] = (char *) "minimum_length";
 237     setup_argv[4] = (char *) "12";
 238     setup_argv[5] = NULL;
 239     run_setup((const char **) setup_argv);
 240
 241     /* Run the length tests. */
 242     for (i = 0; i < ARRAY_SIZE(length_tests); i++)
 243         is_password_test(verifier, &length_tests[i]);
 244
 245 #ifdef HAVE_CDB
 246
 247     /* If built with CDB, set up krb5.conf to use a CDB dictionary instead. */
 248     setup_argv[3] = (char *) "password_dictionary_cdb";
 249     setup_argv[4] = test_file_path("data/wordlist.cdb");
 250     if (setup_argv[4] == NULL)
 251         bail("cannot find data/wordlist.cdb in the test suite");
 252     setup_argv[5] = NULL;
 253     run_setup((const char **) setup_argv);
 254     test_file_path_free(setup_argv[4]);
 255
 256     /* Run the CDB tests. */
 257     for (i = 0; i < ARRAY_SIZE(cdb_tests); i++)
 258         is_password_test(verifier, &cdb_tests[i]);
 259     for (i = 0; i < ARRAY_SIZE(principal_tests); i++)
 260         is_password_test(verifier, &principal_tests[i]);
 261
 262 #else /* !HAVE_CDB */
 263
 264     /* Otherwise, mark the CDB tests as skipped. */
 265     count = ARRAY_SIZE(cdb_tests) + ARRAY_SIZE(principal_tests);
 266     skip_block(count * 2, "not built with CDB support");
 267
 268 #endif /* !HAVE_CDB */
 269
 270 #ifdef HAVE_SQLITE
 271
 272     /*
 273      * If built with SQLite, set up krb5.conf to use a SQLite dictionary
 274      * instead.
 275      */
 276     setup_argv[3] = (char *) "password_dictionary_sqlite";
 277     setup_argv[4] = test_file_path("data/wordlist.sqlite");
 278     if (setup_argv[4] == NULL)
 279         bail("cannot find data/wordlist.sqlite in the test suite");
 280     setup_argv[5] = NULL;
 281     run_setup((const char **) setup_argv);
 282     test_file_path_free(setup_argv[0]);
 283     test_file_path_free(setup_argv[4]);
 284     test_file_path_free(path);
 285
 286     /* Run the SQLite tests. */
 287     for (i = 0; i < ARRAY_SIZE(sqlite_tests); i++)
 288         is_password_test(verifier, &sqlite_tests[i]);
 289     for (i = 0; i < ARRAY_SIZE(principal_tests); i++)
 290         is_password_test(verifier, &principal_tests[i]);
 291
 292 #else /* !HAVE_SQLITE */
 293
 294     /* Otherwise, mark the SQLite tests as skipped. */
 295     count = ARRAY_SIZE(sqlite_tests) + ARRAY_SIZE(principal_tests);
 296     skip_block(count * 2, "not built with SQLite support");
 297
 298 #endif /* !HAVE_SQLITE */
 299
 300     /* Manually clean up after the results of make-krb5-conf. */
 301     basprintf(&path, "%s/krb5.conf", tmpdir);
 302     unlink(path);
 303     free(path);
 304     test_tmpdir_free(tmpdir);
 305
 306     /* Close down the module. */
 307     if (dlclose(handle) != 0)
 308         bail("cannot close plugin: %s", dlerror());
 309
 310     /* Keep valgrind clean by freeing environmental memory. */
 311     putenv((char *) "KRB5_CONFIG=");
 312     free(krb5_config);
 313     return 0;
 314 }
 315
 316 #endif /* HAVE_KADM5_KADM5_PWCHECK_H */