third_party/heimdal/kdc/kdc-tester.c

   1 /*
   2  * Copyright (c) 1997-2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Portions Copyright (c) 2009 Apple Inc. All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * 3. Neither the name of the Institute nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include "kdc_locl.h"
  37 #include "send_to_kdc_plugin.h"
  38
  39 struct perf {
  40     unsigned long as_req;
  41     unsigned long tgs_req;
  42     struct timeval start;
  43     struct timeval stop;
  44     struct perf *next;
  45 } *ptop;
  46
  47 int detach_from_console = -1;
  48 int daemon_child = -1;
  49 int do_bonjour = -1;
  50
  51 static krb5_kdc_configuration *kdc_config;
  52 static krb5_context kdc_context;
  53
  54 static struct sockaddr_storage sa;
  55 static const char *astr = "0.0.0.0";
  56
  57 static void eval_object(heim_object_t);
  58
  59
  60 /*
  61  *
  62  */
  63
  64 static krb5_error_code
  65 plugin_init(krb5_context context, void **pctx)
  66 {
  67     *pctx = NULL;
  68     return 0;
  69 }
  70
  71 static void
  72 plugin_fini(void *ctx)
  73 {
  74 }
  75
  76 static krb5_error_code
  77 plugin_send_to_kdc(krb5_context context,
  78                    void *ctx,
  79                    krb5_krbhst_info *ho,
  80                    time_t timeout,
  81                    const krb5_data *in,
  82                    krb5_data *out)
  83 {
  84     return KRB5_PLUGIN_NO_HANDLE;
  85 }
  86
  87 static krb5_error_code
  88 plugin_send_to_realm(krb5_context context,
  89                      void *ctx,
  90                      krb5_const_realm realm,
  91                      time_t timeout,
  92                      const krb5_data *in,
  93                      krb5_data *out)
  94 {
  95     int ret;
  96
  97     krb5_kdc_update_time(NULL);
  98
  99     ret = krb5_kdc_process_request(kdc_context, kdc_config,
 100                                    in->data, in->length,
 101                                    out, NULL, astr,
 102                                    (struct sockaddr *)&sa, 0);
 103     if (ret)
 104         krb5_err(kdc_context, 1, ret, "krb5_kdc_process_request");
 105
 106     return 0;
 107 }
 108
 109 static krb5plugin_send_to_kdc_ftable send_to_kdc = {
 110     KRB5_PLUGIN_SEND_TO_KDC_VERSION_2,
 111     plugin_init,
 112     plugin_fini,
 113     plugin_send_to_kdc,
 114     plugin_send_to_realm
 115 };
 116
 117 static void
 118 perf_start(struct perf *perf)
 119 {
 120     memset(perf, 0, sizeof(*perf));
 121
 122     gettimeofday(&perf->start, NULL);
 123     perf->next = ptop;
 124     ptop = perf;
 125 }
 126
 127 static void
 128 perf_stop(struct perf *perf)
 129 {
 130     gettimeofday(&perf->stop, NULL);
 131     ptop = perf->next;
 132
 133     if (ptop) {
 134         ptop->as_req += perf->as_req;
 135         ptop->tgs_req += perf->tgs_req;
 136     }
 137
 138     timevalsub(&perf->stop, &perf->start);
 139     printf("time: %lu.%06lu\n",
 140            (unsigned long)perf->stop.tv_sec,
 141            (unsigned long)perf->stop.tv_usec);
 142
 143 #define USEC_PER_SEC 1000000
 144
 145     if (perf->as_req) {
 146         double as_ps = 0.0;
 147         as_ps = (perf->as_req * USEC_PER_SEC) / (double)((perf->stop.tv_sec * USEC_PER_SEC) + perf->stop.tv_usec);
 148         printf("as-req/s %.2lf  (total %lu requests)\n", as_ps, perf->as_req);
 149     }
 150
 151     if (perf->tgs_req) {
 152         double tgs_ps = 0.0;
 153         tgs_ps = (perf->tgs_req * USEC_PER_SEC) / (double)((perf->stop.tv_sec * USEC_PER_SEC) + perf->stop.tv_usec);
 154         printf("tgs-req/s %.2lf (total %lu requests)\n", tgs_ps, perf->tgs_req);
 155     }
 156 }
 157
 158 /*
 159  *
 160  */
 161
 162 static void
 163 eval_repeat(heim_dict_t o)
 164 {
 165     heim_object_t or = heim_dict_get_value(o, HSTR("value"));
 166     heim_number_t n = heim_dict_get_value(o, HSTR("num"));
 167     int i, num;
 168     struct perf perf;
 169
 170     perf_start(&perf);
 171
 172     heim_assert(or != NULL, "value missing");
 173     heim_assert(n != NULL, "num missing");
 174
 175     num = heim_number_get_int(n);
 176     heim_assert(num >= 0, "num >= 0");
 177
 178     for (i = 0; i < num; i++)
 179         eval_object(or);
 180
 181     perf_stop(&perf);
 182 }
 183
 184 /*
 185  *
 186  */
 187
 188 static krb5_error_code
 189 copy_keytab(krb5_context context, krb5_keytab from, krb5_keytab to)
 190 {
 191     krb5_keytab_entry entry;
 192     krb5_kt_cursor cursor;
 193     krb5_error_code ret;
 194
 195     ret = krb5_kt_start_seq_get(context, from, &cursor);
 196     if (ret)
 197         return ret;
 198     while((ret = krb5_kt_next_entry(context, from, &entry, &cursor)) == 0){
 199         krb5_kt_add_entry(context, to, &entry);
 200         krb5_kt_free_entry(context, &entry);
 201     }
 202     return krb5_kt_end_seq_get(context, from, &cursor);
 203 }
 204
 205 /*
 206  *
 207  */
 208
 209 static void
 210 eval_kinit(heim_dict_t o)
 211 {
 212     heim_string_t user, password, keytab, fast_armor_cc, pk_user_id, ccache;
 213     krb5_get_init_creds_opt *opt;
 214     krb5_init_creds_context ctx;
 215     krb5_principal client;
 216     krb5_keytab ktmem = NULL;
 217     krb5_ccache fast_cc = NULL;
 218     krb5_error_code ret;
 219
 220     if (ptop)
 221         ptop->as_req++;
 222
 223     user = heim_dict_get_value(o, HSTR("client"));
 224     if (user == NULL)
 225         krb5_errx(kdc_context, 1, "no client");
 226
 227     password = heim_dict_get_value(o, HSTR("password"));
 228     keytab = heim_dict_get_value(o, HSTR("keytab"));
 229     pk_user_id = heim_dict_get_value(o, HSTR("pkinit-user-cert-id"));
 230     if (password == NULL && keytab == NULL && pk_user_id == NULL)
 231         krb5_errx(kdc_context, 1, "password, keytab, nor PKINIT user cert ID");
 232
 233     ccache = heim_dict_get_value(o, HSTR("ccache"));
 234
 235     ret = krb5_parse_name(kdc_context, heim_string_get_utf8(user), &client);
 236     if (ret)
 237         krb5_err(kdc_context, 1, ret, "krb5_unparse_name");
 238
 239     /* PKINIT parts */
 240     ret = krb5_get_init_creds_opt_alloc (kdc_context, &opt);
 241     if (ret)
 242         krb5_err(kdc_context, 1, ret, "krb5_get_init_creds_opt_alloc");
 243
 244     if (pk_user_id) {
 245         heim_bool_t rsaobj = heim_dict_get_value(o, HSTR("pkinit-use-rsa"));
 246         int use_rsa = rsaobj ? heim_bool_val(rsaobj) : 0;
 247
 248         ret = krb5_get_init_creds_opt_set_pkinit(kdc_context, opt,
 249                                                  client,
 250                                                  heim_string_get_utf8(pk_user_id),
 251                                                  NULL, NULL, NULL,
 252                                                  use_rsa ? 2 : 0,
 253                                                  NULL, NULL, NULL);
 254         if (ret)
 255             krb5_err(kdc_context, 1, ret, "krb5_get_init_creds_opt_set_pkinit");
 256     }
 257
 258     ret = krb5_init_creds_init(kdc_context, client, NULL, NULL, 0, opt, &ctx);
 259     if (ret)
 260         krb5_err(kdc_context, 1, ret, "krb5_init_creds_init");
 261
 262     fast_armor_cc = heim_dict_get_value(o, HSTR("fast-armor-cc"));
 263     if (fast_armor_cc) {
 264
 265         ret = krb5_cc_resolve(kdc_context, heim_string_get_utf8(fast_armor_cc), &fast_cc);
 266         if (ret)
 267             krb5_err(kdc_context, 1, ret, "krb5_cc_resolve");
 268
 269         ret = krb5_init_creds_set_fast_ccache(kdc_context, ctx, fast_cc);
 270         if (ret)
 271             krb5_err(kdc_context, 1, ret, "krb5_init_creds_set_fast_ccache");
 272
 273         fast_cc = NULL;
 274     }
 275
 276     if (password) {
 277         ret = krb5_init_creds_set_password(kdc_context, ctx,
 278                                            heim_string_get_utf8(password));
 279         if (ret)
 280             krb5_err(kdc_context, 1, ret, "krb5_init_creds_set_password");
 281     }
 282     if (keytab) {
 283         krb5_keytab kt = NULL;
 284
 285         ret = krb5_kt_resolve(kdc_context, heim_string_get_utf8(keytab), &kt);
 286         if (ret)
 287             krb5_err(kdc_context, 1, ret, "krb5_kt_resolve");
 288
 289         ret = krb5_kt_resolve(kdc_context, "MEMORY:keytab", &ktmem);
 290         if (ret)
 291             krb5_err(kdc_context, 1, ret, "krb5_kt_resolve(MEMORY)");
 292
 293         ret = copy_keytab(kdc_context, kt, ktmem);
 294         if (ret)
 295             krb5_err(kdc_context, 1, ret, "copy_keytab");
 296
 297         krb5_kt_close(kdc_context, kt);
 298
 299         ret = krb5_init_creds_set_keytab(kdc_context, ctx, ktmem);
 300         if (ret)
 301             krb5_err(kdc_context, 1, ret, "krb5_init_creds_set_keytab");
 302     }
 303
 304     ret = krb5_init_creds_get(kdc_context, ctx);
 305     if (ret)
 306         krb5_err(kdc_context, 1, ret, "krb5_init_creds_get");
 307
 308     if (ccache) {
 309         const char *name = heim_string_get_utf8(ccache);
 310         krb5_creds cred;
 311         krb5_ccache cc;
 312
 313         ret = krb5_init_creds_get_creds(kdc_context, ctx, &cred);
 314         if (ret)
 315             krb5_err(kdc_context, 1, ret, "krb5_init_creds_get_creds");
 316
 317         ret = krb5_cc_resolve(kdc_context, name, &cc);
 318         if (ret)
 319             krb5_err(kdc_context, 1, ret, "krb5_cc_resolve");
 320
 321         krb5_init_creds_store(kdc_context, ctx, cc);
 322
 323         ret = krb5_cc_close(kdc_context, cc);
 324         if (ret)
 325             krb5_err(kdc_context, 1, ret, "krb5_cc_close");
 326
 327         krb5_free_cred_contents(kdc_context, &cred);
 328     }
 329
 330     krb5_init_creds_free(kdc_context, ctx);
 331
 332     if (ktmem)
 333         krb5_kt_close(kdc_context, ktmem);
 334     if (fast_cc)
 335         krb5_cc_close(kdc_context, fast_cc);
 336 }
 337
 338 /*
 339  *
 340  */
 341
 342 static void
 343 eval_kgetcred(heim_dict_t o)
 344 {
 345     heim_string_t server, ccache;
 346     krb5_get_creds_opt opt;
 347     heim_bool_t nostore;
 348     krb5_error_code ret;
 349     krb5_ccache cc = NULL;
 350     krb5_principal s;
 351     krb5_creds *out = NULL;
 352
 353     if (ptop)
 354         ptop->tgs_req++;
 355
 356     server = heim_dict_get_value(o, HSTR("server"));
 357     if (server == NULL)
 358         krb5_errx(kdc_context, 1, "no server");
 359
 360     ccache = heim_dict_get_value(o, HSTR("ccache"));
 361     if (ccache == NULL)
 362         krb5_errx(kdc_context, 1, "no ccache");
 363
 364     nostore = heim_dict_get_value(o, HSTR("nostore"));
 365     if (nostore == NULL)
 366         nostore = heim_bool_create(1);
 367
 368     ret = krb5_cc_resolve(kdc_context, heim_string_get_utf8(ccache), &cc);
 369     if (ret)
 370         krb5_err(kdc_context, 1, ret, "krb5_cc_resolve");
 371
 372     ret = krb5_parse_name(kdc_context, heim_string_get_utf8(server), &s);
 373     if (ret)
 374         krb5_err(kdc_context, 1, ret, "krb5_parse_name");
 375
 376     ret = krb5_get_creds_opt_alloc(kdc_context, &opt);
 377     if (ret)
 378         krb5_err(kdc_context, 1, ret, "krb5_get_creds_opt_alloc");
 379
 380     if (heim_bool_val(nostore))
 381         krb5_get_creds_opt_add_options(kdc_context, opt, KRB5_GC_NO_STORE);
 382
 383     ret = krb5_get_creds(kdc_context, opt, cc, s, &out);
 384     if (ret)
 385         krb5_err(kdc_context, 1, ret, "krb5_get_creds");
 386
 387     krb5_free_creds(kdc_context, out);
 388     krb5_free_principal(kdc_context, s);
 389     krb5_get_creds_opt_free(kdc_context, opt);
 390     krb5_cc_close(kdc_context, cc);
 391 }
 392
 393
 394 /*
 395  *
 396  */
 397
 398 static void
 399 eval_kdestroy(heim_dict_t o)
 400 {
 401     heim_string_t ccache = heim_dict_get_value(o, HSTR("ccache"));;
 402     krb5_error_code ret;
 403     const char *name;
 404     krb5_ccache cc;
 405
 406     heim_assert(ccache != NULL, "ccache_missing");
 407
 408     name = heim_string_get_utf8(ccache);
 409
 410     ret = krb5_cc_resolve(kdc_context, name, &cc);
 411     if (ret)
 412         krb5_err(kdc_context, 1, ret, "krb5_cc_resolve");
 413
 414     krb5_cc_destroy(kdc_context, cc);
 415 }
 416
 417
 418 /*
 419  *
 420  */
 421
 422 static void
 423 eval_array_element(heim_object_t o, void *ptr, int *stop)
 424 {
 425     eval_object(o);
 426 }
 427
 428 static void
 429 eval_object(heim_object_t o)
 430 {
 431     heim_tid_t t = heim_get_tid(o);
 432
 433     if (t == heim_array_get_type_id()) {
 434         heim_array_iterate_f(o, NULL, eval_array_element);
 435     } else if (t == heim_dict_get_type_id()) {
 436         const char *op = heim_dict_get_value(o, HSTR("op"));
 437
 438         heim_assert(op != NULL, "op missing");
 439
 440         if (strcmp(op, "repeat") == 0) {
 441             eval_repeat(o);
 442         } else if (strcmp(op, "kinit") == 0) {
 443             eval_kinit(o);
 444         } else if (strcmp(op, "kgetcred") == 0) {
 445             eval_kgetcred(o);
 446         } else if (strcmp(op, "kdestroy") == 0) {
 447             eval_kdestroy(o);
 448         } else {
 449             errx(1, "unsupported ops %s", op);
 450         }
 451
 452     } else
 453         errx(1, "unsupported");
 454 }
 455
 456
 457 int
 458 main(int argc, char **argv)
 459 {
 460     krb5_error_code ret;
 461     int optidx = 0;
 462
 463     setprogname(argv[0]);
 464
 465     ret = krb5_init_context(&kdc_context);
 466     if (ret == KRB5_CONFIG_BADFORMAT)
 467         errx (1, "krb5_init_context failed to parse configuration file");
 468     else if (ret)
 469         errx (1, "krb5_init_context failed: %d", ret);
 470
 471     ret = krb5_kt_register(kdc_context, &hdb_get_kt_ops);
 472     if (ret)
 473         errx (1, "krb5_kt_register(HDB) failed: %d", ret);
 474
 475     kdc_config = configure(kdc_context, argc, argv, &optidx);
 476
 477     argc -= optidx;
 478     argv += optidx;
 479
 480     if (argc == 0)
 481         errx(1, "missing operations");
 482
 483     krb5_plugin_register(kdc_context, PLUGIN_TYPE_DATA,
 484                          KRB5_PLUGIN_SEND_TO_KDC, &send_to_kdc);
 485
 486     {
 487         void *buf;
 488         size_t size;
 489         heim_object_t o;
 490
 491         if (rk_undumpdata(argv[0], &buf, &size))
 492             errx(1, "undumpdata: %s", argv[0]);
 493
 494         o = heim_json_create_with_bytes(buf, size, 10, 0, NULL);
 495         free(buf);
 496         if (o == NULL)
 497             errx(1, "heim_json");
 498
 499         /*
 500          * do the work here
 501          */
 502
 503         eval_object(o);
 504
 505         heim_release(o);
 506     }
 507
 508     krb5_free_context(kdc_context);
 509     return 0;
 510 }