source3/libads/kerberos.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    kerberos utility library
   4    Copyright (C) Andrew Tridgell 2001
   5    Copyright (C) Remus Koos 2001
   6    Copyright (C) Nalin Dahyabhai 2004.
   7    Copyright (C) Jeremy Allison 2004.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26 #ifdef HAVE_KRB5
  27
  28 #define LIBADS_CCACHE_NAME "MEMORY:libads"
  29
  30 /*
  31   we use a prompter to avoid a crash bug in the kerberos libs when
  32   dealing with empty passwords
  33   this prompter is just a string copy ...
  34 */
  35 static krb5_error_code
  36 kerb_prompter(krb5_context ctx, void *data,
  37                const char *name,
  38                const char *banner,
  39                int num_prompts,
  40                krb5_prompt prompts[])
  41 {
  42         if (num_prompts == 0) return 0;
  43
  44         memset(prompts[0].reply->data, '\0', prompts[0].reply->length);
  45         if (prompts[0].reply->length > 0) {
  46                 if (data) {
  47                         strncpy(prompts[0].reply->data, data, prompts[0].reply->length-1);
  48                         prompts[0].reply->length = strlen(prompts[0].reply->data);
  49                 } else {
  50                         prompts[0].reply->length = 0;
  51                 }
  52         }
  53         return 0;
  54 }
  55
  56 /*
  57   simulate a kinit, putting the tgt in the given cache location. If cache_name == NULL
  58   place in default cache location.
  59   remus@snapserver.com
  60 */
  61 int kerberos_kinit_password(const char *principal,
  62                                 const char *password,
  63                                 int time_offset,
  64                                 time_t *expire_time,
  65                                 const char *cache_name)
  66 {
  67         krb5_context ctx = NULL;
  68         krb5_error_code code = 0;
  69         krb5_ccache cc = NULL;
  70         krb5_principal me;
  71         krb5_creds my_creds;
  72
  73         if ((code = krb5_init_context(&ctx)))
  74                 return code;
  75
  76         if (time_offset != 0) {
  77                 krb5_set_real_time(ctx, time(NULL) + time_offset, 0);
  78         }
  79
  80         if ((code = krb5_cc_resolve(ctx, cache_name ?
  81                         cache_name : krb5_cc_default_name(ctx), &cc))) {
  82                 krb5_free_context(ctx);
  83                 return code;
  84         }
  85
  86         if ((code = krb5_parse_name(ctx, principal, &me))) {
  87                 krb5_free_context(ctx);
  88                 return code;
  89         }
  90
  91         if ((code = krb5_get_init_creds_password(ctx, &my_creds, me, password,
  92                                                  kerb_prompter,
  93                                                  NULL, 0, NULL, NULL))) {
  94                 krb5_free_principal(ctx, me);
  95                 krb5_free_context(ctx);
  96                 return code;
  97         }
  98
  99         if ((code = krb5_cc_initialize(ctx, cc, me))) {
 100                 krb5_free_cred_contents(ctx, &my_creds);
 101                 krb5_free_principal(ctx, me);
 102                 krb5_free_context(ctx);
 103                 return code;
 104         }
 105
 106         if ((code = krb5_cc_store_cred(ctx, cc, &my_creds))) {
 107                 krb5_cc_close(ctx, cc);
 108                 krb5_free_cred_contents(ctx, &my_creds);
 109                 krb5_free_principal(ctx, me);
 110                 krb5_free_context(ctx);
 111                 return code;
 112         }
 113
 114         if (expire_time)
 115                 *expire_time = (time_t) my_creds.times.endtime;
 116
 117         krb5_cc_close(ctx, cc);
 118         krb5_free_cred_contents(ctx, &my_creds);
 119         krb5_free_principal(ctx, me);
 120         krb5_free_context(ctx);
 121
 122         return 0;
 123 }
 124
 125
 126
 127 /* run kinit to setup our ccache */
 128 int ads_kinit_password(ADS_STRUCT *ads)
 129 {
 130         char *s;
 131         int ret;
 132
 133         if (asprintf(&s, "%s@%s", ads->auth.user_name, ads->auth.realm) == -1) {
 134                 return KRB5_CC_NOMEM;
 135         }
 136
 137         if (!ads->auth.password) {
 138                 return KRB5_LIBOS_CANTREADPWD;
 139         }
 140
 141         ret = kerberos_kinit_password(s, ads->auth.password, ads->auth.time_offset,
 142                         &ads->auth.expire, NULL);
 143
 144         if (ret) {
 145                 DEBUG(0,("kerberos_kinit_password %s failed: %s\n",
 146                          s, error_message(ret)));
 147         }
 148         free(s);
 149         return ret;
 150 }
 151
 152 int ads_kdestroy(const char *cc_name)
 153 {
 154         krb5_error_code code;
 155         krb5_context ctx = NULL;
 156         krb5_ccache cc = NULL;
 157
 158         if ((code = krb5_init_context (&ctx))) {
 159                 DEBUG(3, ("ads_kdestroy: kdb5_init_context failed: %s\n",
 160                         error_message(code)));
 161                 return code;
 162         }
 163
 164         if (!cc_name) {
 165                 if ((code = krb5_cc_default(ctx, &cc))) {
 166                         krb5_free_context(ctx);
 167                         return code;
 168                 }
 169         } else {
 170                 if ((code = krb5_cc_resolve(ctx, cc_name, &cc))) {
 171                         DEBUG(3, ("ads_kdestroy: krb5_cc_resolve failed: %s\n",
 172                                   error_message(code)));
 173                         krb5_free_context(ctx);
 174                         return code;
 175                 }
 176         }
 177
 178         if ((code = krb5_cc_destroy (ctx, cc))) {
 179                 DEBUG(3, ("ads_kdestroy: krb5_cc_destroy failed: %s\n",
 180                         error_message(code)));
 181         }
 182
 183         krb5_free_context (ctx);
 184         return code;
 185 }
 186
 187 /************************************************************************
 188  Routine to fetch the salting principal for a service.  Active
 189  Directory may use a non-obvious principal name to generate the salt
 190  when it determines the key to use for encrypting tickets for a service,
 191  and hopefully we detected that when we joined the domain.
 192  ************************************************************************/
 193
 194 static char *kerberos_secrets_fetch_salting_principal(const char *service, int enctype)
 195 {
 196         char *key = NULL;
 197         char *ret = NULL;
 198
 199         asprintf(&key, "%s/%s/enctype=%d", SECRETS_SALTING_PRINCIPAL, service, enctype);
 200         if (!key) {
 201                 return NULL;
 202         }
 203         ret = (char *)secrets_fetch(key, NULL);
 204         SAFE_FREE(key);
 205         return ret;
 206 }
 207
 208 /************************************************************************
 209  Routine to get the salting principal for this service.  Active
 210  Directory may use a non-obvious principal name to generate the salt
 211  when it determines the key to use for encrypting tickets for a service,
 212  and hopefully we detected that when we joined the domain.
 213  Caller must free if return is not null.
 214  ************************************************************************/
 215
 216 krb5_principal kerberos_fetch_salt_princ_for_host_princ(krb5_context context,
 217                                                         krb5_principal host_princ,
 218                                                         int enctype)
 219 {
 220         char *unparsed_name = NULL, *salt_princ_s = NULL;
 221         krb5_principal ret_princ = NULL;
 222
 223         if (krb5_unparse_name(context, host_princ, &unparsed_name) != 0) {
 224                 return (krb5_principal)NULL;
 225         }
 226
 227         if ((salt_princ_s = kerberos_secrets_fetch_salting_principal(unparsed_name, enctype)) == NULL) {
 228                 krb5_free_unparsed_name(context, unparsed_name);
 229                 return (krb5_principal)NULL;
 230         }
 231
 232         if (krb5_parse_name(context, salt_princ_s, &ret_princ) != 0) {
 233                 krb5_free_unparsed_name(context, unparsed_name);
 234                 SAFE_FREE(salt_princ_s);
 235                 return (krb5_principal)NULL;
 236         }
 237         krb5_free_unparsed_name(context, unparsed_name);
 238         SAFE_FREE(salt_princ_s);
 239         return ret_princ;
 240 }
 241
 242 /************************************************************************
 243  Routine to set the salting principal for this service.  Active
 244  Directory may use a non-obvious principal name to generate the salt
 245  when it determines the key to use for encrypting tickets for a service,
 246  and hopefully we detected that when we joined the domain.
 247  Setting principal to NULL deletes this entry.
 248  ************************************************************************/
 249
 250  BOOL kerberos_secrets_store_salting_principal(const char *service,
 251                                               int enctype,
 252                                               const char *principal)
 253 {
 254         char *key = NULL;
 255         BOOL ret = False;
 256         krb5_context context = NULL;
 257         krb5_principal princ = NULL;
 258         char *princ_s = NULL;
 259         char *unparsed_name = NULL;
 260
 261         krb5_init_context(&context);
 262         if (!context) {
 263                 return False;
 264         }
 265         if (strchr_m(service, '@')) {
 266                 asprintf(&princ_s, "%s", service);
 267         } else {
 268                 asprintf(&princ_s, "%s@%s", service, lp_realm());
 269         }
 270
 271         if (krb5_parse_name(context, princ_s, &princ) != 0) {
 272                 goto out;
 273
 274         }
 275         if (krb5_unparse_name(context, princ, &unparsed_name) != 0) {
 276                 goto out;
 277         }
 278
 279         asprintf(&key, "%s/%s/enctype=%d", SECRETS_SALTING_PRINCIPAL, unparsed_name, enctype);
 280         if (!key)  {
 281                 goto out;
 282         }
 283
 284         if ((principal != NULL) && (strlen(principal) > 0)) {
 285                 ret = secrets_store(key, principal, strlen(principal) + 1);
 286         } else {
 287                 ret = secrets_delete(key);
 288         }
 289
 290  out:
 291
 292         SAFE_FREE(key);
 293         SAFE_FREE(princ_s);
 294
 295         if (unparsed_name) {
 296                 krb5_free_unparsed_name(context, unparsed_name);
 297         }
 298         if (context) {
 299                 krb5_free_context(context);
 300         }
 301
 302         return ret;
 303 }
 304
 305 /************************************************************************
 306  Routine to get initial credentials as a service ticket for the local machine.
 307  Returns a buffer initialized with krb5_mk_req_extended.
 308  ************************************************************************/
 309
 310 static krb5_error_code get_service_ticket(krb5_context ctx,
 311                                         krb5_ccache ccache,
 312                                         const char *service_principal,
 313                                         int enctype,
 314                                         krb5_data *p_outbuf)
 315 {
 316         krb5_creds creds, *new_creds = NULL;
 317         char *service_s = NULL;
 318         char *machine_account = NULL, *password = NULL;
 319         krb5_data in_data;
 320         krb5_auth_context auth_context = NULL;
 321         krb5_error_code err = 0;
 322
 323         asprintf(&machine_account, "%s$@%s", global_myname(), lp_realm());
 324         if (machine_account == NULL) {
 325                 goto out;
 326         }
 327         password = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 328         if (password == NULL) {
 329                 goto out;
 330         }
 331         if ((err = kerberos_kinit_password(machine_account, password, 0, NULL, LIBADS_CCACHE_NAME)) != 0) {
 332                 DEBUG(0,("get_service_ticket: kerberos_kinit_password %s@%s failed: %s\n",
 333                         machine_account,
 334                         lp_realm(),
 335                         error_message(err)));
 336                 goto out;
 337         }
 338
 339         /* Ok - the above call has gotten a TGT. Now we need to get a service
 340            ticket to ourselves. */
 341
 342         /* Set up the enctype and client and server principal fields for krb5_get_credentials. */
 343         memset(&creds, '\0', sizeof(creds));
 344         kerberos_set_creds_enctype(&creds, enctype);
 345
 346         if ((err = krb5_cc_get_principal(ctx, ccache, &creds.client))) {
 347                 DEBUG(3, ("get_service_ticket: krb5_cc_get_principal failed: %s\n",
 348                         error_message(err)));
 349                 goto out;
 350         }
 351
 352         if (strchr_m(service_principal, '@')) {
 353                 asprintf(&service_s, "%s", service_principal);
 354         } else {
 355                 asprintf(&service_s, "%s@%s", service_principal, lp_realm());
 356         }
 357
 358         if ((err = krb5_parse_name(ctx, service_s, &creds.server))) {
 359                 DEBUG(0,("get_service_ticket: krb5_parse_name %s failed: %s\n",
 360                         service_s, error_message(err)));
 361                 goto out;
 362         }
 363
 364         if ((err = krb5_get_credentials(ctx, 0, ccache, &creds, &new_creds))) {
 365                 DEBUG(5,("get_service_ticket: krb5_get_credentials for %s failed: %s\n",
 366                         service_s, error_message(err)));
 367                 goto out;
 368         }
 369
 370         memset(&in_data, '\0', sizeof(in_data));
 371         if ((err = krb5_mk_req_extended(ctx, &auth_context, 0, &in_data,
 372                         new_creds, p_outbuf)) != 0) {
 373                 DEBUG(0,("get_service_ticket: krb5_mk_req_extended failed: %s\n",
 374                         error_message(err)));
 375                 goto out;
 376         }
 377
 378  out:
 379
 380         if (auth_context) {
 381                 krb5_auth_con_free(ctx, auth_context);
 382         }
 383         if (new_creds) {
 384                 krb5_free_creds(ctx, new_creds);
 385         }
 386         if (creds.server) {
 387                 krb5_free_principal(ctx, creds.server);
 388         }
 389         if (creds.client) {
 390                 krb5_free_principal(ctx, creds.client);
 391         }
 392
 393         SAFE_FREE(service_s);
 394         SAFE_FREE(password);
 395         SAFE_FREE(machine_account);
 396         return err;
 397 }
 398
 399 /************************************************************************
 400  Check if the machine password can be used in conjunction with the salting_principal
 401  to generate a key which will successfully decrypt the AP_REQ already
 402  gotten as a message to the local machine.
 403  ************************************************************************/
 404
 405 static BOOL verify_service_password(krb5_context ctx,
 406                                     int enctype,
 407                                     const char *salting_principal,
 408                                     krb5_data *in_data)
 409 {
 410         BOOL ret = False;
 411         krb5_principal salting_kprinc = NULL;
 412         krb5_ticket *ticket = NULL;
 413         krb5_keyblock key;
 414         krb5_data passdata;
 415         char *salting_s = NULL;
 416         char *machine_account = NULL, *password = NULL;
 417         krb5_auth_context auth_context = NULL;
 418         krb5_error_code err;
 419
 420         memset(&passdata, '\0', sizeof(passdata));
 421         memset(&key, '\0', sizeof(key));
 422
 423         asprintf(&machine_account, "%s$@%s", global_myname(), lp_realm());
 424         if (machine_account == NULL) {
 425                 goto out;
 426         }
 427         password = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 428         if (password == NULL) {
 429                 goto out;
 430         }
 431
 432         if (strchr_m(salting_principal, '@')) {
 433                 asprintf(&salting_s, "%s", salting_principal);
 434         } else {
 435                 asprintf(&salting_s, "%s@%s", salting_principal, lp_realm());
 436         }
 437
 438         if ((err = krb5_parse_name(ctx, salting_s, &salting_kprinc))) {
 439                 DEBUG(0,("verify_service_password: krb5_parse_name %s failed: %s\n",
 440                         salting_s, error_message(err)));
 441                 goto out;
 442         }
 443
 444         passdata.length = strlen(password);
 445         passdata.data = (char*)password;
 446         if ((err = create_kerberos_key_from_string_direct(ctx, salting_kprinc, &passdata, &key, enctype))) {
 447                 DEBUG(0,("verify_service_password: create_kerberos_key_from_string %d failed: %s\n",
 448                         enctype, error_message(err)));
 449                 goto out;
 450         }
 451
 452         if ((err = krb5_auth_con_init(ctx, &auth_context)) != 0) {
 453                 DEBUG(0,("verify_service_password: krb5_auth_con_init failed %s\n", error_message(err)));
 454                 goto out;
 455         }
 456
 457         if ((err = krb5_auth_con_setuseruserkey(ctx, auth_context, &key)) != 0) {
 458                 DEBUG(0,("verify_service_password: krb5_auth_con_setuseruserkey failed %s\n", error_message(err)));
 459                 goto out;
 460         }
 461
 462         if (!(err = krb5_rd_req(ctx, &auth_context, in_data, NULL, NULL, NULL, &ticket))) {
 463                 DEBUG(10,("verify_service_password: decrypted message with enctype %u salt %s!\n",
 464                                 (unsigned int)enctype, salting_s));
 465                 ret = True;
 466         }
 467
 468  out:
 469
 470         memset(&passdata, 0, sizeof(passdata));
 471         krb5_free_keyblock_contents(ctx, &key);
 472         if (ticket != NULL) {
 473                 krb5_free_ticket(ctx, ticket);
 474         }
 475         if (salting_kprinc) {
 476                 krb5_free_principal(ctx, salting_kprinc);
 477         }
 478         SAFE_FREE(salting_s);
 479         SAFE_FREE(password);
 480         SAFE_FREE(machine_account);
 481         return ret;
 482 }
 483
 484 /************************************************************************
 485  *
 486  * From the current draft of kerberos-clarifications:
 487  *
 488  *     It is not possible to reliably generate a user's key given a pass
 489  *     phrase without contacting the KDC, since it will not be known
 490  *     whether alternate salt or parameter values are required.
 491  *
 492  * And because our server has a password, we have this exact problem.  We
 493  * make multiple guesses as to which principal name provides the salt which
 494  * the KDC is using.
 495  *
 496  ************************************************************************/
 497
 498 static void kerberos_derive_salting_principal_for_enctype(const char *service_principal,
 499                                                           krb5_context ctx,
 500                                                           krb5_ccache ccache,
 501                                                           krb5_enctype enctype,
 502                                                           krb5_enctype *enctypes)
 503 {
 504         char *salting_principals[3] = {NULL, NULL, NULL}, *second_principal = NULL;
 505         krb5_error_code err = 0;
 506         krb5_data outbuf;
 507         int i, j;
 508
 509         memset(&outbuf, '\0', sizeof(outbuf));
 510
 511         /* Check that the service_principal is useful. */
 512         if ((service_principal == NULL) || (strlen(service_principal) == 0)) {
 513                 return;
 514         }
 515
 516         /* Generate our first guess -- the principal as-given. */
 517         asprintf(&salting_principals[0], "%s", service_principal);
 518         if ((salting_principals[0] == NULL) || (strlen(salting_principals[0]) == 0)) {
 519                 return;
 520         }
 521
 522         /* Generate our second guess -- the computer's principal, as Win2k3. */
 523         asprintf(&second_principal, "host/%s.%s", global_myname(), lp_realm());
 524         if (second_principal != NULL) {
 525                 strlower_m(second_principal);
 526                 asprintf(&salting_principals[1], "%s@%s", second_principal, lp_realm());
 527                 SAFE_FREE(second_principal);
 528         }
 529         if ((salting_principals[1] == NULL) || (strlen(salting_principals[1]) == 0)) {
 530                 goto out;
 531         }
 532
 533         /* Generate our third guess -- the computer's principal, as Win2k. */
 534         asprintf(&second_principal, "HOST/%s", global_myname());
 535         if (second_principal != NULL) {
 536                 strlower_m(second_principal + 5);
 537                 asprintf(&salting_principals[2], "%s@%s",
 538                         second_principal, lp_realm());
 539                 SAFE_FREE(second_principal);
 540         }
 541         if ((salting_principals[2] == NULL) || (strlen(salting_principals[2]) == 0)) {
 542                 goto out;
 543         }
 544
 545         /* Get a service ticket for ourselves into our memory ccache. */
 546         /* This will commonly fail if there is no principal by that name (and we're trying
 547            many names). So don't print a debug 0 error. */
 548
 549         if ((err = get_service_ticket(ctx, ccache, service_principal, enctype, &outbuf)) != 0) {
 550                 DEBUG(3, ("verify_service_password: get_service_ticket failed: %s\n",
 551                         error_message(err)));
 552                 goto out;
 553         }
 554
 555         /* At this point we have a message to ourselves, salted only the KDC knows how. We
 556            have to work out what that salting is. */
 557
 558         /* Try and find the correct salting principal. */
 559         for (i = 0; i < sizeof(salting_principals) / sizeof(salting_principals[i]); i++) {
 560                 if (verify_service_password(ctx, enctype, salting_principals[i], &outbuf)) {
 561                         break;
 562                 }
 563         }
 564
 565         /* If we failed to get a match, return. */
 566         if (i >= sizeof(salting_principals) / sizeof(salting_principals[i])) {
 567                 goto out;
 568         }
 569
 570         /* If we succeeded, store the principal for use for all enctypes which
 571          * share the same cipher and string-to-key function.  Doing this here
 572          * allows servers which just pass a keytab to krb5_rd_req() to work
 573          * correctly. */
 574         for (j = 0; enctypes[j] != 0; j++) {
 575                 if (enctype != enctypes[j]) {
 576                         /* If this enctype isn't compatible with the one which
 577                          * we used, skip it. */
 578
 579                         if (!kerberos_compatible_enctypes(ctx, enctypes[j], enctype))
 580                                 continue;
 581                 }
 582                 /* If the principal which gives us the proper salt is the one
 583                  * which we would normally guess, don't bother noting anything
 584                  * in the secrets tdb. */
 585                 if (strcmp(service_principal, salting_principals[i]) != 0) {
 586                         kerberos_secrets_store_salting_principal(service_principal,
 587                                                                 enctypes[j],
 588                                                                 salting_principals[i]);
 589                 }
 590         }
 591
 592  out :
 593
 594         kerberos_free_data_contents(ctx, &outbuf);
 595         SAFE_FREE(salting_principals[0]);
 596         SAFE_FREE(salting_principals[1]);
 597         SAFE_FREE(salting_principals[2]);
 598         SAFE_FREE(second_principal);
 599 }
 600
 601 /************************************************************************
 602  Go through all the possible enctypes for this principal.
 603  ************************************************************************/
 604
 605  void kerberos_derive_salting_principal(krb5_context context,
 606                                         krb5_ccache ccache,
 607                                         krb5_enctype *enctypes,
 608                                         char *service_principal)
 609 {
 610         int i;
 611         BOOL free_ccache = False;
 612
 613         if (ccache == NULL) {
 614                 krb5_error_code ret;
 615                 if ((ret = krb5_cc_resolve(context, LIBADS_CCACHE_NAME, &ccache)) != 0) {
 616                         DEBUG(0, ("kerberos_derive_salting_principal: krb5_cc_resolve for %s failed: %s\n",
 617                                 LIBADS_CCACHE_NAME, error_message(ret)));
 618                         return;
 619                 }
 620                 free_ccache = True;
 621         }
 622
 623         /* Try for each enctype separately, because the rules are
 624          * different for different enctypes. */
 625         for (i = 0; enctypes[i] != 0; i++) {
 626                 /* Delete secrets entry first. */
 627                 kerberos_secrets_store_salting_principal(service_principal, 0, NULL);
 628 #ifdef ENCTYPE_ARCFOUR_HMAC
 629                 if (enctypes[i] == ENCTYPE_ARCFOUR_HMAC) {
 630                         /* Of course this'll always work, so just save
 631                          * ourselves the effort. */
 632                         continue;
 633                 }
 634 #endif
 635                 /* Try to figure out what's going on with this
 636                  * principal. */
 637                 kerberos_derive_salting_principal_for_enctype(service_principal,
 638                                                                 context,
 639                                                                 ccache,
 640                                                                 enctypes[i],
 641                                                                 enctypes);
 642         }
 643
 644         if (free_ccache && ccache) {
 645                 krb5_cc_close(context, ccache);
 646         }
 647 }
 648
 649 /************************************************************************
 650  Core function to try and determine what salt is being used for any keytab
 651  keys.
 652  ************************************************************************/
 653
 654 BOOL kerberos_derive_cifs_salting_principals(void)
 655 {
 656         fstring my_fqdn;
 657         char *service = NULL;
 658         krb5_context context = NULL;
 659         krb5_enctype *enctypes = NULL;
 660         krb5_ccache ccache = NULL;
 661         krb5_error_code ret = 0;
 662         BOOL retval = False;
 663
 664         initialize_krb5_error_table();
 665         if ((ret = krb5_init_context(&context)) != 0) {
 666                 DEBUG(1,("kerberos_derive_cifs_salting_principals: krb5_init_context failed. %s\n",
 667                         error_message(ret)));
 668                 return False;
 669         }
 670         if ((ret = get_kerberos_allowed_etypes(context, &enctypes)) != 0) {
 671                 DEBUG(1,("kerberos_derive_cifs_salting_principals: get_kerberos_allowed_etypes failed. %s\n",
 672                         error_message(ret)));
 673                 goto out;
 674         }
 675
 676         if ((ret = krb5_cc_resolve(context, LIBADS_CCACHE_NAME, &ccache)) != 0) {
 677                 DEBUG(3, ("get_service_ticket: krb5_cc_resolve for %s failed: %s\n",
 678                         LIBADS_CCACHE_NAME, error_message(ret)));
 679                 goto out;
 680         }
 681
 682         if (asprintf(&service, "%s$", global_myname()) != -1) {
 683                 strlower_m(service);
 684                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 685                 SAFE_FREE(service);
 686         }
 687         if (asprintf(&service, "cifs/%s", global_myname()) != -1) {
 688                 strlower_m(service);
 689                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 690                 SAFE_FREE(service);
 691         }
 692         if (asprintf(&service, "host/%s", global_myname()) != -1) {
 693                 strlower_m(service);
 694                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 695                 SAFE_FREE(service);
 696         }
 697         if (asprintf(&service, "cifs/%s.%s", global_myname(), lp_realm()) != -1) {
 698                 strlower_m(service);
 699                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 700                 SAFE_FREE(service);
 701         }
 702         if (asprintf(&service, "host/%s.%s", global_myname(), lp_realm()) != -1) {
 703                 strlower_m(service);
 704                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 705                 SAFE_FREE(service);
 706         }
 707         name_to_fqdn(my_fqdn, global_myname());
 708         if (asprintf(&service, "cifs/%s", my_fqdn) != -1) {
 709                 strlower_m(service);
 710                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 711                 SAFE_FREE(service);
 712         }
 713         if (asprintf(&service, "host/%s", my_fqdn) != -1) {
 714                 strlower_m(service);
 715                 kerberos_derive_salting_principal(context, ccache, enctypes, service);
 716                 SAFE_FREE(service);
 717         }
 718
 719         retval = True;
 720
 721   out:
 722         if (enctypes) {
 723                 free_kerberos_etypes(context, enctypes);
 724         }
 725         if (ccache) {
 726                 krb5_cc_destroy(context, ccache);
 727         }
 728         if (context) {
 729                 krb5_free_context(context);
 730         }
 731         return retval;
 732 }
 733 #endif