src/lib/kadm5/unit-test/setkey-test.c

   1 #include <stdio.h>
   2 #include <krb5.h>
   3 #include <kadm5/admin.h>
   4
   5 krb5_keyblock test1[] = {
   6      0, ENCTYPE_DES_CBC_CRC, 0, 0,
   7      -1,
   8 };
   9 krb5_keyblock test2[] = {
  10      0, ENCTYPE_DES_CBC_RAW, 0, 0,
  11      -1,
  12 };
  13 krb5_keyblock test3[] = {
  14      0, ENCTYPE_DES_CBC_MD5, 0, 0,
  15      -1,
  16 };
  17
  18 krb5_keyblock *tests[] = {
  19   test1, test2, test3, NULL
  20 };
  21
  22 int keyblocks_equal(krb5_keyblock *kb1, krb5_keyblock *kb2)
  23 {
  24   return (kb1->enctype == kb2->enctype &&
  25           kb1->length == kb2->length &&
  26           memcmp(kb1->contents, kb2->contents, kb1->length) == 0);
  27 }
  28
  29 krb5_data tgtname = {
  30     0,
  31     KRB5_TGS_NAME_SIZE,
  32     KRB5_TGS_NAME
  33 };
  34
  35 unsigned int ktypes[] = { 0, 0 };
  36
  37 extern krb5_kt_ops krb5_ktf_writable_ops;
  38
  39 main(int argc, char **argv)
  40 {
  41   krb5_context context;
  42   krb5_keytab kt;
  43   krb5_keytab_entry ktent;
  44   krb5_encrypt_block eblock;
  45   krb5_creds my_creds;
  46   kadm5_principal_ent_rec princ_ent;
  47   krb5_principal princ, server;
  48   char pw[16];
  49   char *whoami, *principal, *authprinc;
  50   krb5_data pwdata;
  51   void *handle;
  52   int ret, i, test, encnum;
  53
  54   whoami = argv[0];
  55
  56   if (argc != 2 && argc != 3) {
  57     fprintf(stderr, "Usage: %s principal [authuser]\n", whoami);
  58     exit(1);
  59   }
  60   principal = argv[1];
  61   authprinc = argv[2] ? argv[2] : argv[0];
  62
  63   /*
  64    * Setup.  Initialize data structures, open keytab, open connection
  65    * to kadm5 server.
  66    */
  67
  68   memset((char *) &context, 0, sizeof(context));
  69   krb5_init_context(&context);
  70
  71   ret = krb5_parse_name(context, principal, &princ);
  72   if (ret) {
  73     com_err(whoami, ret, "while parsing principal name %s", principal);
  74     exit(1);
  75   }
  76
  77   if((ret = krb5_build_principal_ext(context, &server,
  78                                      krb5_princ_realm(kcontext, princ)->length,
  79                                      krb5_princ_realm(kcontext, princ)->data,
  80                                      tgtname.length, tgtname.data,
  81                                      krb5_princ_realm(kcontext, princ)->length,
  82                                      krb5_princ_realm(kcontext, princ)->data,
  83                                      0))) {
  84        com_err(whoami, ret, "while building server name");
  85        exit(1);
  86   }
  87
  88   /* register the WRFILE keytab type  */
  89   if (ret = krb5_kt_register(context, &krb5_ktf_writable_ops)) {
  90        com_err(whoami, ret,
  91                "while registering writable key table functions");
  92        exit(1);
  93   }
  94
  95   ret = krb5_kt_default(context, &kt);
  96   if (ret) {
  97        com_err(whoami, ret, "while opening keytab");
  98        exit(1);
  99   }
 100
 101   ret = kadm5_init(authprinc, NULL, KADM5_ADMIN_SERVICE, NULL,
 102                    KADM5_STRUCT_VERSION, KADM5_API_VERSION_2,
 103                    &handle);
 104   if (ret) {
 105     com_err(whoami, ret, "while initializing connection");
 106     exit(1);
 107   }
 108
 109   /* these pw's don't need to be secure, just different every time */
 110   srandom(getpid() ^ time(0));
 111   pwdata.data = pw;
 112   pwdata.length = sizeof(pw);
 113
 114   /*
 115    * For each test:
 116    *
 117    * For each enctype in the test, construct a random password/key.
 118    * Assign all keys to principal with kadm5_setkey_principal.  Add
 119    * each key to the keytab, and acquire an initial ticket with the
 120    * keytab (XXX can I specify the enctype & kvno explicitly?).  If
 121    * krb5_get_in_tkt_with_keytab succeeds, then the keys were set
 122    * successfully.
 123    */
 124   for (test = 0; tests[test] != NULL; test++) {
 125        krb5_keyblock *testp = tests[test];
 126        printf("+ Test %d:\n", test);
 127
 128        for (encnum = 0; testp[encnum].magic != -1; encnum++) {
 129             for (i = 0; i < sizeof(pw); i++)
 130                  pw[i] = (random() % 26) + '0'; /* XXX */
 131
 132             krb5_use_enctype(context, &eblock, testp[encnum].enctype);
 133             if (ret = krb5_string_to_key(context, &eblock, &testp[encnum],
 134                                          &pwdata, NULL)) {
 135                  com_err(whoami, ret, "while converting string to key");
 136                  exit(1);
 137             }
 138        }
 139
 140        /* now, encnum == # of keyblocks in testp */
 141        ret = kadm5_setkey_principal(handle, princ, testp, encnum);
 142        if (ret) {
 143             com_err(whoami, ret, "while setting keys");
 144             exit(1);
 145        }
 146
 147        ret = kadm5_get_principal(handle, princ, &princ_ent, KADM5_KVNO);
 148        if (ret) {
 149             com_err(whoami, ret, "while retrieving principal");
 150             exit(1);
 151        }
 152
 153        for (encnum = 0; testp[encnum].magic != -1; encnum++) {
 154             printf("+   enctype %d\n", testp[encnum].enctype);
 155
 156             memset((char *) &ktent, 0, sizeof(ktent));
 157             ktent.principal = princ;
 158             ktent.key = testp[encnum];
 159             ktent.vno = princ_ent.kvno;
 160
 161             ret = krb5_kt_add_entry(context, kt, &ktent);
 162             if (ret) {
 163                  com_err(whoami, ret, "while adding keytab entry");
 164                  exit(1);
 165             }
 166
 167             memset((char *)&my_creds, 0, sizeof(my_creds));
 168             my_creds.client = princ;
 169             my_creds.server = server;
 170
 171             ktypes[0] = testp[encnum].enctype;
 172             ret = krb5_get_in_tkt_with_keytab(context,
 173                                               0 /* options */,
 174                                               NULL /* addrs */,
 175                                               ktypes,
 176                                               NULL /* preauth */,
 177                                               kt, 0,
 178                                               &my_creds, 0);
 179             if (ret) {
 180                  com_err(whoami, ret, "while acquiring initial ticket");
 181                  exit(1);
 182             }
 183
 184             /* since I can't specify enctype explicitly ... */
 185             ret = krb5_kt_remove_entry(context, kt, &ktent);
 186             if (ret) {
 187                  com_err(whoami, ret, "while removing keytab entry");
 188                  exit(1);
 189             }
 190        }
 191   }
 192
 193   ret = krb5_kt_close(context, kt);
 194   if (ret) {
 195        com_err(whoami, ret, "while closing keytab");
 196        exit(1);
 197   }
 198
 199   ret = kadm5_destroy(handle);
 200   if (ret) {
 201        com_err(whoami, ret, "while closing kadmin connection");
 202        exit(1);
 203   }
 204
 205   return 0;
 206 }
 207
 208
 209
 210
 211
 212