source4/heimdal/lib/krb5/context.c

   1 /*
   2  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "krb5_locl.h"
  35 #include <com_err.h>
  36
  37 RCSID("$Id: context.c,v 1.102 2005/05/18 04:20:50 lha Exp $");
  38
  39 #define INIT_FIELD(C, T, E, D, F)                                       \
  40     (C)->E = krb5_config_get_ ## T ## _default ((C), NULL, (D),         \
  41                                                 "libdefaults", F, NULL)
  42
  43 /*
  44  * Set the list of etypes `ret_etypes' from the configuration variable
  45  * `name'
  46  */
  47
  48 static krb5_error_code
  49 set_etypes (krb5_context context,
  50             const char *name,
  51             krb5_enctype **ret_enctypes)
  52 {
  53     char **etypes_str;
  54     krb5_enctype *etypes = NULL;
  55
  56     etypes_str = krb5_config_get_strings(context, NULL, "libdefaults",
  57                                          name, NULL);
  58     if(etypes_str){
  59         int i, j, k;
  60         for(i = 0; etypes_str[i]; i++);
  61         etypes = malloc((i+1) * sizeof(*etypes));
  62         if (etypes == NULL) {
  63             krb5_config_free_strings (etypes_str);
  64             krb5_set_error_string (context, "malloc: out of memory");
  65             return ENOMEM;
  66         }
  67         for(j = 0, k = 0; j < i; j++) {
  68             krb5_enctype e;
  69             if(krb5_string_to_enctype(context, etypes_str[j], &e) != 0)
  70                 continue;
  71             if (krb5_enctype_valid(context, e) != 0)
  72                 continue;
  73             etypes[k++] = e;
  74         }
  75         etypes[k] = ETYPE_NULL;
  76         krb5_config_free_strings(etypes_str);
  77     }
  78     *ret_enctypes = etypes;
  79     return 0;
  80 }
  81
  82 /*
  83  * read variables from the configuration file and set in `context'
  84  */
  85
  86 static krb5_error_code
  87 init_context_from_config_file(krb5_context context)
  88 {
  89     krb5_error_code ret;
  90     const char * tmp;
  91     krb5_enctype *tmptypes;
  92
  93     INIT_FIELD(context, time, max_skew, 5 * 60, "clockskew");
  94     INIT_FIELD(context, time, kdc_timeout, 3, "kdc_timeout");
  95     INIT_FIELD(context, int, max_retries, 3, "max_retries");
  96
  97     INIT_FIELD(context, string, http_proxy, NULL, "http_proxy");
  98
  99     ret = set_etypes (context, "default_etypes", &tmptypes);
 100     if(ret)
 101         return ret;
 102     free(context->etypes);
 103     context->etypes = tmptypes;
 104
 105     ret = set_etypes (context, "default_etypes_des", &tmptypes);
 106     if(ret)
 107         return ret;
 108     free(context->etypes_des);
 109     context->etypes_des = tmptypes;
 110
 111     /* default keytab name */
 112     tmp = NULL;
 113     if(!issuid())
 114         tmp = getenv("KRB5_KTNAME");
 115     if(tmp != NULL)
 116         context->default_keytab = tmp;
 117     else
 118         INIT_FIELD(context, string, default_keytab,
 119                    KEYTAB_DEFAULT, "default_keytab_name");
 120
 121     INIT_FIELD(context, string, default_keytab_modify,
 122                NULL, "default_keytab_modify_name");
 123
 124     INIT_FIELD(context, string, time_fmt,
 125                "%Y-%m-%dT%H:%M:%S", "time_format");
 126
 127     INIT_FIELD(context, string, date_fmt,
 128                "%Y-%m-%d", "date_format");
 129
 130     INIT_FIELD(context, bool, log_utc,
 131                FALSE, "log_utc");
 132
 133
 134
 135     /* init dns-proxy slime */
 136     tmp = krb5_config_get_string(context, NULL, "libdefaults",
 137                                  "dns_proxy", NULL);
 138     if(tmp)
 139         roken_gethostby_setup(context->http_proxy, tmp);
 140     krb5_free_host_realm (context, context->default_realms);
 141     context->default_realms = NULL;
 142
 143     {
 144         krb5_addresses addresses;
 145         char **adr, **a;
 146
 147         krb5_set_extra_addresses(context, NULL);
 148         adr = krb5_config_get_strings(context, NULL,
 149                                       "libdefaults",
 150                                       "extra_addresses",
 151                                       NULL);
 152         memset(&addresses, 0, sizeof(addresses));
 153         for(a = adr; a && *a; a++) {
 154             ret = krb5_parse_address(context, *a, &addresses);
 155             if (ret == 0) {
 156                 krb5_add_extra_addresses(context, &addresses);
 157                 krb5_free_addresses(context, &addresses);
 158             }
 159         }
 160         krb5_config_free_strings(adr);
 161
 162         krb5_set_ignore_addresses(context, NULL);
 163         adr = krb5_config_get_strings(context, NULL,
 164                                       "libdefaults",
 165                                       "ignore_addresses",
 166                                       NULL);
 167         memset(&addresses, 0, sizeof(addresses));
 168         for(a = adr; a && *a; a++) {
 169             ret = krb5_parse_address(context, *a, &addresses);
 170             if (ret == 0) {
 171                 krb5_add_ignore_addresses(context, &addresses);
 172                 krb5_free_addresses(context, &addresses);
 173             }
 174         }
 175         krb5_config_free_strings(adr);
 176     }
 177
 178     INIT_FIELD(context, bool, scan_interfaces, TRUE, "scan_interfaces");
 179     INIT_FIELD(context, int, fcache_vno, 0, "fcache_version");
 180     /* prefer dns_lookup_kdc over srv_lookup. */
 181     INIT_FIELD(context, bool, srv_lookup, TRUE, "srv_lookup");
 182     INIT_FIELD(context, bool, srv_lookup, context->srv_lookup, "dns_lookup_kdc");
 183     INIT_FIELD(context, int, large_msg_size, 6000, "large_message_size");
 184     context->default_cc_name = NULL;
 185     INIT_FIELD(context, bool, fdns, TRUE, "fdns");
 186     return 0;
 187 }
 188
 189 krb5_error_code KRB5_LIB_FUNCTION
 190 krb5_init_context(krb5_context *context)
 191 {
 192     krb5_context p;
 193     krb5_error_code ret;
 194     char **files;
 195
 196     *context = NULL;
 197
 198     p = calloc(1, sizeof(*p));
 199     if(!p)
 200         return ENOMEM;
 201
 202     p->mutex = malloc(sizeof(HEIMDAL_MUTEX));
 203     if (p->mutex == NULL) {
 204         free(p);
 205         return ENOMEM;
 206     }
 207     HEIMDAL_MUTEX_init(p->mutex);
 208
 209     ret = krb5_get_default_config_files(&files);
 210     if(ret)
 211         goto out;
 212     ret = krb5_set_config_files(p, files);
 213     krb5_free_config_files(files);
 214     if(ret)
 215         goto out;
 216
 217     /* init error tables */
 218     krb5_init_ets(p);
 219
 220     p->cc_ops = NULL;
 221     p->num_cc_ops = 0;
 222     krb5_cc_register(p, &krb5_acc_ops, TRUE);
 223     krb5_cc_register(p, &krb5_fcc_ops, TRUE);
 224     krb5_cc_register(p, &krb5_mcc_ops, TRUE);
 225 #ifdef HAVE_KCM
 226     krb5_cc_register(p, &krb5_kcm_ops, TRUE);
 227 #endif
 228
 229     p->num_kt_types = 0;
 230     p->kt_types     = NULL;
 231     krb5_kt_register (p, &krb5_fkt_ops);
 232     krb5_kt_register (p, &krb5_wrfkt_ops);
 233     krb5_kt_register (p, &krb5_javakt_ops);
 234     krb5_kt_register (p, &krb5_mkt_ops);
 235     krb5_kt_register (p, &krb5_akf_ops);
 236     krb5_kt_register (p, &krb4_fkt_ops);
 237     krb5_kt_register (p, &krb5_srvtab_fkt_ops);
 238     krb5_kt_register (p, &krb5_any_ops);
 239
 240 out:
 241     if(ret) {
 242         krb5_free_context(p);
 243         p = NULL;
 244     }
 245     *context = p;
 246     return ret;
 247 }
 248
 249 void KRB5_LIB_FUNCTION
 250 krb5_free_context(krb5_context context)
 251 {
 252     if (context->default_cc_name)
 253         free(context->default_cc_name);
 254     free(context->etypes);
 255     free(context->etypes_des);
 256     krb5_free_host_realm (context, context->default_realms);
 257     krb5_config_file_free (context, context->cf);
 258     free_error_table (context->et_list);
 259     free(context->cc_ops);
 260     free(context->kt_types);
 261     krb5_clear_error_string(context);
 262     if(context->warn_dest != NULL)
 263         krb5_closelog(context, context->warn_dest);
 264     krb5_set_extra_addresses(context, NULL);
 265     krb5_set_ignore_addresses(context, NULL);
 266     if (context->mutex != NULL) {
 267         HEIMDAL_MUTEX_destroy(context->mutex);
 268         free(context->mutex);
 269     }
 270     memset(context, 0, sizeof(*context));
 271     free(context);
 272 }
 273
 274 krb5_error_code KRB5_LIB_FUNCTION
 275 krb5_set_config_files(krb5_context context, char **filenames)
 276 {
 277     krb5_error_code ret;
 278     krb5_config_binding *tmp = NULL;
 279     while(filenames != NULL && *filenames != NULL && **filenames != '\0') {
 280         ret = krb5_config_parse_file_multi(context, *filenames, &tmp);
 281         if(ret != 0 && ret != ENOENT && ret != EACCES) {
 282             krb5_config_file_free(context, tmp);
 283             return ret;
 284         }
 285         filenames++;
 286     }
 287 #if 0
 288     /* with this enabled and if there are no config files, Kerberos is
 289        considererd disabled */
 290     if(tmp == NULL)
 291         return ENXIO;
 292 #endif
 293     krb5_config_file_free(context, context->cf);
 294     context->cf = tmp;
 295     ret = init_context_from_config_file(context);
 296     return ret;
 297 }
 298
 299 static krb5_error_code
 300 add_file(char ***pfilenames, int *len, char *file)
 301 {
 302     char **pp = *pfilenames;
 303     int i;
 304
 305     for(i = 0; i < *len; i++) {
 306         if(strcmp(pp[i], file) == 0) {
 307             free(file);
 308             return 0;
 309         }
 310     }
 311
 312     pp = realloc(*pfilenames, (*len + 2) * sizeof(*pp));
 313     if (pp == NULL) {
 314         free(file);
 315         return ENOMEM;
 316     }
 317
 318     pp[*len] = file;
 319     pp[*len + 1] = NULL;
 320     *pfilenames = pp;
 321     *len += 1;
 322     return 0;
 323 }
 324
 325 /*
 326  *  `pq' isn't free, its up the the caller
 327  */
 328
 329 krb5_error_code KRB5_LIB_FUNCTION
 330 krb5_prepend_config_files(const char *filelist, char **pq, char ***ret_pp)
 331 {
 332     krb5_error_code ret;
 333     const char *p, *q;
 334     char **pp;
 335     int len;
 336     char *fn;
 337
 338     pp = NULL;
 339
 340     len = 0;
 341     p = filelist;
 342     while(1) {
 343         ssize_t l;
 344         q = p;
 345         l = strsep_copy(&q, ":", NULL, 0);
 346         if(l == -1)
 347             break;
 348         fn = malloc(l + 1);
 349         if(fn == NULL) {
 350             krb5_free_config_files(pp);
 351             return ENOMEM;
 352         }
 353         l = strsep_copy(&p, ":", fn, l + 1);
 354         ret = add_file(&pp, &len, fn);
 355         if (ret) {
 356             krb5_free_config_files(pp);
 357             return ret;
 358         }
 359     }
 360
 361     if (pq != NULL) {
 362         int i;
 363
 364         for (i = 0; pq[i] != NULL; i++) {
 365             fn = strdup(pq[i]);
 366             if (fn == NULL) {
 367                 krb5_free_config_files(pp);
 368                 return ENOMEM;
 369             }
 370             ret = add_file(&pp, &len, fn);
 371             if (ret) {
 372                 krb5_free_config_files(pp);
 373                 return ret;
 374             }
 375         }
 376     }
 377
 378     *ret_pp = pp;
 379     return 0;
 380 }
 381
 382 krb5_error_code KRB5_LIB_FUNCTION
 383 krb5_prepend_config_files_default(const char *filelist, char ***pfilenames)
 384 {
 385     krb5_error_code ret;
 386     char **defpp, **pp = NULL;
 387
 388     ret = krb5_get_default_config_files(&defpp);
 389     if (ret)
 390         return ret;
 391
 392     ret = krb5_prepend_config_files(filelist, defpp, &pp);
 393     krb5_free_config_files(defpp);
 394     if (ret) {
 395         return ret;
 396     }
 397     *pfilenames = pp;
 398     return 0;
 399 }
 400
 401 krb5_error_code KRB5_LIB_FUNCTION
 402 krb5_get_default_config_files(char ***pfilenames)
 403 {
 404     const char *files = NULL;
 405
 406     if (pfilenames == NULL)
 407         return EINVAL;
 408     if(!issuid())
 409         files = getenv("KRB5_CONFIG");
 410     if (files == NULL)
 411         files = krb5_config_file;
 412
 413     return krb5_prepend_config_files(files, NULL, pfilenames);
 414 }
 415
 416 void KRB5_LIB_FUNCTION
 417 krb5_free_config_files(char **filenames)
 418 {
 419     char **p;
 420     for(p = filenames; *p != NULL; p++)
 421         free(*p);
 422     free(filenames);
 423 }
 424
 425 /*
 426  * set `etype' to a malloced list of the default enctypes
 427  */
 428
 429 static krb5_error_code
 430 default_etypes(krb5_context context, krb5_enctype **etype)
 431 {
 432     krb5_enctype p[] = {
 433         ETYPE_AES256_CTS_HMAC_SHA1_96,
 434         ETYPE_AES128_CTS_HMAC_SHA1_96,
 435         ETYPE_DES3_CBC_SHA1,
 436         ETYPE_DES3_CBC_MD5,
 437         ETYPE_ARCFOUR_HMAC_MD5,
 438         ETYPE_DES_CBC_MD5,
 439         ETYPE_DES_CBC_MD4,
 440         ETYPE_DES_CBC_CRC
 441     };
 442     krb5_enctype *e = NULL, *ep;
 443     int i, n = 0;
 444
 445     for (i = 0; i < sizeof(p)/sizeof(p[0]); i++) {
 446         if (krb5_enctype_valid(context, p[i]) != 0)
 447             continue;
 448         ep = realloc(e, (n + 2) * sizeof(*e));
 449         if (ep == NULL) {
 450             free(e);
 451             krb5_set_error_string (context, "malloc: out of memory");
 452             return ENOMEM;
 453         }
 454         e = ep;
 455         e[n] = p[i];
 456         e[n + 1] = ETYPE_NULL;
 457         n++;
 458     }
 459     *etype = e;
 460     return 0;
 461 }
 462
 463 krb5_error_code KRB5_LIB_FUNCTION
 464 krb5_set_default_in_tkt_etypes(krb5_context context,
 465                                const krb5_enctype *etypes)
 466 {
 467     krb5_enctype *p = NULL;
 468     int i;
 469
 470     if(etypes) {
 471         for (i = 0; etypes[i]; ++i) {
 472             krb5_error_code ret;
 473             ret = krb5_enctype_valid(context, etypes[i]);
 474             if (ret)
 475                 return ret;
 476         }
 477         ++i;
 478         ALLOC(p, i);
 479         if(!p) {
 480             krb5_set_error_string (context, "malloc: out of memory");
 481             return ENOMEM;
 482         }
 483         memmove(p, etypes, i * sizeof(krb5_enctype));
 484     }
 485     if(context->etypes)
 486         free(context->etypes);
 487     context->etypes = p;
 488     return 0;
 489 }
 490
 491
 492 krb5_error_code KRB5_LIB_FUNCTION
 493 krb5_get_default_in_tkt_etypes(krb5_context context,
 494                                krb5_enctype **etypes)
 495 {
 496   krb5_enctype *p;
 497   int i;
 498   krb5_error_code ret;
 499
 500   if(context->etypes) {
 501     for(i = 0; context->etypes[i]; i++);
 502     ++i;
 503     ALLOC(p, i);
 504     if(!p) {
 505       krb5_set_error_string (context, "malloc: out of memory");
 506       return ENOMEM;
 507     }
 508     memmove(p, context->etypes, i * sizeof(krb5_enctype));
 509   } else {
 510     ret = default_etypes(context, &p);
 511     if (ret)
 512       return ret;
 513   }
 514   *etypes = p;
 515   return 0;
 516 }
 517
 518 const char* KRB5_LIB_FUNCTION
 519 krb5_get_err_text(krb5_context context, krb5_error_code code)
 520 {
 521     const char *p = NULL;
 522     if(context != NULL)
 523         p = com_right(context->et_list, code);
 524     if(p == NULL)
 525         p = strerror(code);
 526     if (p == NULL)
 527         p = "Unknown error";
 528     return p;
 529 }
 530
 531 void KRB5_LIB_FUNCTION
 532 krb5_init_ets(krb5_context context)
 533 {
 534     if(context->et_list == NULL){
 535         krb5_add_et_list(context, initialize_krb5_error_table_r);
 536         krb5_add_et_list(context, initialize_asn1_error_table_r);
 537         krb5_add_et_list(context, initialize_heim_error_table_r);
 538         krb5_add_et_list(context, initialize_k524_error_table_r);
 539     }
 540 }
 541
 542 void KRB5_LIB_FUNCTION
 543 krb5_set_use_admin_kdc (krb5_context context, krb5_boolean flag)
 544 {
 545     context->use_admin_kdc = flag;
 546 }
 547
 548 krb5_boolean KRB5_LIB_FUNCTION
 549 krb5_get_use_admin_kdc (krb5_context context)
 550 {
 551     return context->use_admin_kdc;
 552 }
 553
 554 krb5_error_code KRB5_LIB_FUNCTION
 555 krb5_add_extra_addresses(krb5_context context, krb5_addresses *addresses)
 556 {
 557
 558     if(context->extra_addresses)
 559         return krb5_append_addresses(context,
 560                                      context->extra_addresses, addresses);
 561     else
 562         return krb5_set_extra_addresses(context, addresses);
 563 }
 564
 565 krb5_error_code KRB5_LIB_FUNCTION
 566 krb5_set_extra_addresses(krb5_context context, const krb5_addresses *addresses)
 567 {
 568     if(context->extra_addresses)
 569         krb5_free_addresses(context, context->extra_addresses);
 570
 571     if(addresses == NULL) {
 572         if(context->extra_addresses != NULL) {
 573             free(context->extra_addresses);
 574             context->extra_addresses = NULL;
 575         }
 576         return 0;
 577     }
 578     if(context->extra_addresses == NULL) {
 579         context->extra_addresses = malloc(sizeof(*context->extra_addresses));
 580         if(context->extra_addresses == NULL) {
 581             krb5_set_error_string (context, "malloc: out of memory");
 582             return ENOMEM;
 583         }
 584     }
 585     return krb5_copy_addresses(context, addresses, context->extra_addresses);
 586 }
 587
 588 krb5_error_code KRB5_LIB_FUNCTION
 589 krb5_get_extra_addresses(krb5_context context, krb5_addresses *addresses)
 590 {
 591     if(context->extra_addresses == NULL) {
 592         memset(addresses, 0, sizeof(*addresses));
 593         return 0;
 594     }
 595     return krb5_copy_addresses(context,context->extra_addresses, addresses);
 596 }
 597
 598 krb5_error_code KRB5_LIB_FUNCTION
 599 krb5_add_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 600 {
 601
 602     if(context->ignore_addresses)
 603         return krb5_append_addresses(context,
 604                                      context->ignore_addresses, addresses);
 605     else
 606         return krb5_set_ignore_addresses(context, addresses);
 607 }
 608
 609 krb5_error_code KRB5_LIB_FUNCTION
 610 krb5_set_ignore_addresses(krb5_context context, const krb5_addresses *addresses)
 611 {
 612     if(context->ignore_addresses)
 613         krb5_free_addresses(context, context->ignore_addresses);
 614     if(addresses == NULL) {
 615         if(context->ignore_addresses != NULL) {
 616             free(context->ignore_addresses);
 617             context->ignore_addresses = NULL;
 618         }
 619         return 0;
 620     }
 621     if(context->ignore_addresses == NULL) {
 622         context->ignore_addresses = malloc(sizeof(*context->ignore_addresses));
 623         if(context->ignore_addresses == NULL) {
 624             krb5_set_error_string (context, "malloc: out of memory");
 625             return ENOMEM;
 626         }
 627     }
 628     return krb5_copy_addresses(context, addresses, context->ignore_addresses);
 629 }
 630
 631 krb5_error_code KRB5_LIB_FUNCTION
 632 krb5_get_ignore_addresses(krb5_context context, krb5_addresses *addresses)
 633 {
 634     if(context->ignore_addresses == NULL) {
 635         memset(addresses, 0, sizeof(*addresses));
 636         return 0;
 637     }
 638     return krb5_copy_addresses(context, context->ignore_addresses, addresses);
 639 }
 640
 641 krb5_error_code KRB5_LIB_FUNCTION
 642 krb5_set_fcache_version(krb5_context context, int version)
 643 {
 644     context->fcache_vno = version;
 645     return 0;
 646 }
 647
 648 krb5_error_code KRB5_LIB_FUNCTION
 649 krb5_get_fcache_version(krb5_context context, int *version)
 650 {
 651     *version = context->fcache_vno;
 652     return 0;
 653 }
 654
 655 krb5_boolean KRB5_LIB_FUNCTION
 656 krb5_is_thread_safe(void)
 657 {
 658 #ifdef ENABLE_PTHREAD_SUPPORT
 659     return TRUE;
 660 #else
 661     return FALSE;
 662 #endif
 663 }