source4/auth/kerberos/kerberos_util.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Kerberos utility functions for GENSEC
   5
   6    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "system/kerberos.h"
  25 #include "auth/kerberos/kerberos.h"
  26 #include "auth/credentials/credentials.h"
  27 #include "auth/credentials/credentials_proto.h"
  28 #include "auth/credentials/credentials_krb5.h"
  29 #include "auth/kerberos/kerberos_credentials.h"
  30 #include "auth/kerberos/kerberos_util.h"
  31
  32 struct principal_container {
  33         struct smb_krb5_context *smb_krb5_context;
  34         krb5_principal principal;
  35         const char *string_form; /* Optional */
  36 };
  37
  38 static krb5_error_code free_principal(struct principal_container *pc)
  39 {
  40         /* current heimdal - 0.6.3, which we need anyway, fixes segfaults here */
  41         krb5_free_principal(pc->smb_krb5_context->krb5_context, pc->principal);
  42
  43         return 0;
  44 }
  45
  46
  47 static krb5_error_code parse_principal(TALLOC_CTX *parent_ctx,
  48                                        const char *princ_string,
  49                                        struct smb_krb5_context *smb_krb5_context,
  50                                        krb5_principal *princ,
  51                                        const char **error_string)
  52 {
  53         int ret;
  54         struct principal_container *mem_ctx;
  55         if (princ_string == NULL) {
  56                  *princ = NULL;
  57                  return 0;
  58         }
  59
  60         ret = krb5_parse_name(smb_krb5_context->krb5_context,
  61                               princ_string, princ);
  62
  63         if (ret) {
  64                 (*error_string) = smb_get_krb5_error_message(
  65                                                 smb_krb5_context->krb5_context,
  66                                                 ret, parent_ctx);
  67                 return ret;
  68         }
  69
  70         mem_ctx = talloc(parent_ctx, struct principal_container);
  71         if (!mem_ctx) {
  72                 (*error_string) = error_message(ENOMEM);
  73                 return ENOMEM;
  74         }
  75
  76         /* This song-and-dance effectivly puts the principal
  77          * into talloc, so we can't loose it. */
  78         mem_ctx->smb_krb5_context = talloc_reference(mem_ctx,
  79                                                      smb_krb5_context);
  80         mem_ctx->principal = *princ;
  81         talloc_set_destructor(mem_ctx, free_principal);
  82         return 0;
  83 }
  84
  85 /* Obtain the principal set on this context.  Requires a
  86  * smb_krb5_context because we are doing krb5 principal parsing with
  87  * the library routines.  The returned princ is placed in the talloc
  88  * system by means of a destructor (do *not* free). */
  89
  90 krb5_error_code principal_from_credentials(TALLOC_CTX *parent_ctx,
  91                                 struct cli_credentials *credentials,
  92                                 struct smb_krb5_context *smb_krb5_context,
  93                                 krb5_principal *princ,
  94                                 enum credentials_obtained *obtained,
  95                                 const char **error_string)
  96 {
  97         krb5_error_code ret;
  98         const char *princ_string;
  99         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 100         *obtained = CRED_UNINITIALISED;
 101
 102         if (!mem_ctx) {
 103                 (*error_string) = error_message(ENOMEM);
 104                 return ENOMEM;
 105         }
 106         princ_string = cli_credentials_get_principal_and_obtained(credentials,
 107                                                                   mem_ctx,
 108                                                                   obtained);
 109         if (!princ_string) {
 110                 *princ = NULL;
 111                 return 0;
 112         }
 113
 114         ret = parse_principal(parent_ctx, princ_string,
 115                               smb_krb5_context, princ, error_string);
 116         talloc_free(mem_ctx);
 117         return ret;
 118 }
 119
 120 /* Obtain the principal set on this context.  Requires a
 121  * smb_krb5_context because we are doing krb5 principal parsing with
 122  * the library routines.  The returned princ is placed in the talloc
 123  * system by means of a destructor (do *not* free). */
 124
 125 static krb5_error_code impersonate_principal_from_credentials(
 126                                 TALLOC_CTX *parent_ctx,
 127                                 struct cli_credentials *credentials,
 128                                 struct smb_krb5_context *smb_krb5_context,
 129                                 krb5_principal *princ,
 130                                 const char **error_string)
 131 {
 132         return parse_principal(parent_ctx,
 133                         cli_credentials_get_impersonate_principal(credentials),
 134                         smb_krb5_context, princ, error_string);
 135 }
 136
 137 krb5_error_code smb_krb5_create_principals_array(TALLOC_CTX *mem_ctx,
 138                                                  krb5_context context,
 139                                                  const char *account_name,
 140                                                  const char *realm,
 141                                                  uint32_t num_spns,
 142                                                  const char *spns[],
 143                                                  uint32_t *pnum_principals,
 144                                                  krb5_principal **pprincipals,
 145                                                  const char **error_string)
 146 {
 147         krb5_error_code code;
 148         TALLOC_CTX *tmp_ctx;
 149         uint32_t num_principals = 0;
 150         krb5_principal *principals;
 151         uint32_t i;
 152
 153         tmp_ctx = talloc_new(mem_ctx);
 154         if (tmp_ctx == NULL) {
 155                 *error_string = "Cannot allocate tmp_ctx";
 156                 return ENOMEM;
 157         }
 158
 159         if (realm == NULL) {
 160                 *error_string = "Cannot create principal without a realm";
 161                 code = EINVAL;
 162                 goto done;
 163         }
 164
 165         if (account_name == NULL && (num_spns == 0 || spns == NULL)) {
 166                 *error_string = "Cannot create principal without an account or SPN";
 167                 code = EINVAL;
 168                 goto done;
 169         }
 170
 171         if (account_name != NULL && account_name[0] != '\0') {
 172                 num_principals++;
 173         }
 174         num_principals += num_spns;
 175
 176         principals = talloc_zero_array(tmp_ctx,
 177                                        krb5_principal,
 178                                        num_principals);
 179         if (principals == NULL) {
 180                 *error_string = "Cannot allocate principals";
 181                 code = ENOMEM;
 182                 goto done;
 183         }
 184
 185         for (i = 0; i < num_spns; i++) {
 186                 code = krb5_parse_name(context, spns[i], &(principals[i]));
 187                 if (code != 0) {
 188                         *error_string = smb_get_krb5_error_message(context,
 189                                                                    code,
 190                                                                    mem_ctx);
 191                         goto done;
 192                 }
 193         }
 194
 195         if (account_name != NULL && account_name[0] != '\0') {
 196                 code = smb_krb5_make_principal(context,
 197                                                &(principals[i]),
 198                                                realm,
 199                                                account_name,
 200                                                NULL);
 201                 if (code != 0) {
 202                         *error_string = smb_get_krb5_error_message(context,
 203                                                                    code,
 204                                                                    mem_ctx);
 205                         goto done;
 206                 }
 207         }
 208
 209         if (pnum_principals != NULL) {
 210                 *pnum_principals = num_principals;
 211
 212                 if (pprincipals != NULL) {
 213                         *pprincipals = talloc_steal(mem_ctx, principals);
 214                 }
 215         }
 216
 217         code = 0;
 218 done:
 219         talloc_free(tmp_ctx);
 220         return code;
 221 }
 222
 223 /**
 224  * Return a freshly allocated ccache (destroyed by destructor on child
 225  * of parent_ctx), for a given set of client credentials
 226  */
 227
 228  krb5_error_code kinit_to_ccache(TALLOC_CTX *parent_ctx,
 229                                  struct cli_credentials *credentials,
 230                                  struct smb_krb5_context *smb_krb5_context,
 231                                  struct tevent_context *event_ctx,
 232                                  krb5_ccache ccache,
 233                                  enum credentials_obtained *obtained,
 234                                  const char **error_string)
 235 {
 236         krb5_error_code ret;
 237         const char *password;
 238 #ifdef SAMBA4_USES_HEIMDAL
 239         const char *self_service;
 240 #endif
 241         const char *target_service;
 242         time_t kdc_time = 0;
 243         krb5_principal princ;
 244         krb5_principal impersonate_principal;
 245         int tries;
 246         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 247         krb5_get_init_creds_opt *krb_options;
 248
 249         if (!mem_ctx) {
 250                 (*error_string) = strerror(ENOMEM);
 251                 return ENOMEM;
 252         }
 253
 254         ret = principal_from_credentials(mem_ctx, credentials, smb_krb5_context, &princ, obtained, error_string);
 255         if (ret) {
 256                 talloc_free(mem_ctx);
 257                 return ret;
 258         }
 259
 260         if (princ == NULL) {
 261                 (*error_string) = talloc_asprintf(credentials, "principal, username or realm was not specified in the credentials");
 262                 talloc_free(mem_ctx);
 263                 return KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
 264         }
 265
 266         ret = impersonate_principal_from_credentials(mem_ctx, credentials, smb_krb5_context, &impersonate_principal, error_string);
 267         if (ret) {
 268                 talloc_free(mem_ctx);
 269                 return ret;
 270         }
 271
 272 #ifdef SAMBA4_USES_HEIMDAL
 273         self_service = cli_credentials_get_self_service(credentials);
 274 #endif
 275         target_service = cli_credentials_get_target_service(credentials);
 276
 277         password = cli_credentials_get_password(credentials);
 278
 279         /* setup the krb5 options we want */
 280         if ((ret = krb5_get_init_creds_opt_alloc(smb_krb5_context->krb5_context, &krb_options))) {
 281                 (*error_string) = talloc_asprintf(credentials, "krb5_get_init_creds_opt_alloc failed (%s)\n",
 282                                                   smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 283                                                                              ret, mem_ctx));
 284                 talloc_free(mem_ctx);
 285                 return ret;
 286         }
 287
 288 #ifdef SAMBA4_USES_HEIMDAL /* Disable for now MIT reads defaults when needed */
 289         /* get the defaults */
 290         krb5_get_init_creds_opt_set_default_flags(smb_krb5_context->krb5_context, NULL, NULL, krb_options);
 291 #endif
 292         /* set if we want a forwardable ticket */
 293         switch (cli_credentials_get_krb_forwardable(credentials)) {
 294         case CRED_AUTO_KRB_FORWARDABLE:
 295                 break;
 296         case CRED_NO_KRB_FORWARDABLE:
 297                 krb5_get_init_creds_opt_set_forwardable(krb_options, FALSE);
 298                 break;
 299         case CRED_FORCE_KRB_FORWARDABLE:
 300                 krb5_get_init_creds_opt_set_forwardable(krb_options, TRUE);
 301                 break;
 302         }
 303
 304 #ifdef SAMBA4_USES_HEIMDAL /* FIXME: MIT does not have this yet */
 305         /*
 306          * In order to work against windows KDCs even if we use
 307          * the netbios domain name as realm, we need to add the following
 308          * flags:
 309          * KRB5_INIT_CREDS_NO_C_CANON_CHECK;
 310          * KRB5_INIT_CREDS_NO_C_NO_EKU_CHECK;
 311          *
 312          * On MIT: Set pkinit_eku_checking to none
 313          */
 314         krb5_get_init_creds_opt_set_win2k(smb_krb5_context->krb5_context,
 315                                           krb_options, true);
 316 #else /* MIT */
 317         krb5_get_init_creds_opt_set_canonicalize(krb_options, true);
 318 #endif
 319
 320         tries = 2;
 321         while (tries--) {
 322 #ifdef SAMBA4_USES_HEIMDAL
 323                 struct tevent_context *previous_ev;
 324                 /* Do this every time, in case we have weird recursive issues here */
 325                 ret = smb_krb5_context_set_event_ctx(smb_krb5_context, event_ctx, &previous_ev);
 326                 if (ret) {
 327                         talloc_free(mem_ctx);
 328                         return ret;
 329                 }
 330 #endif
 331                 if (password) {
 332                         if (impersonate_principal) {
 333 #ifdef SAMBA4_USES_HEIMDAL
 334                                 ret = smb_krb5_kinit_s4u2_ccache(smb_krb5_context->krb5_context,
 335                                                                  ccache,
 336                                                                  princ,
 337                                                                  password,
 338                                                                  impersonate_principal,
 339                                                                  self_service,
 340                                                                  target_service,
 341                                                                  krb_options,
 342                                                                  NULL,
 343                                                                  &kdc_time);
 344 #else
 345                                 talloc_free(mem_ctx);
 346                                 (*error_string) = "INTERNAL error: s4u2 ops "
 347                                         "are not supported with MIT build yet";
 348                                 return EINVAL;
 349 #endif
 350                         } else {
 351                                 ret = smb_krb5_kinit_password_ccache(smb_krb5_context->krb5_context,
 352                                                                      ccache,
 353                                                                      princ,
 354                                                                      password,
 355                                                                      target_service,
 356                                                                      krb_options,
 357                                                                      NULL,
 358                                                                      &kdc_time);
 359                         }
 360                 } else if (impersonate_principal) {
 361                         talloc_free(mem_ctx);
 362                         (*error_string) = "INTERNAL error: Cannot impersonate principal with just a keyblock.  A password must be specified in the credentials";
 363                         return EINVAL;
 364                 } else {
 365                         /* No password available, try to use a keyblock instead */
 366
 367                         krb5_keyblock keyblock;
 368                         const struct samr_Password *mach_pwd;
 369                         mach_pwd = cli_credentials_get_nt_hash(credentials, mem_ctx);
 370                         if (!mach_pwd) {
 371                                 talloc_free(mem_ctx);
 372                                 (*error_string) = "kinit_to_ccache: No password available for kinit\n";
 373                                 krb5_get_init_creds_opt_free(smb_krb5_context->krb5_context, krb_options);
 374 #ifdef SAMBA4_USES_HEIMDAL
 375                                 smb_krb5_context_remove_event_ctx(smb_krb5_context, previous_ev, event_ctx);
 376 #endif
 377                                 return EINVAL;
 378                         }
 379                         ret = smb_krb5_keyblock_init_contents(smb_krb5_context->krb5_context,
 380                                                  ENCTYPE_ARCFOUR_HMAC,
 381                                                  mach_pwd->hash, sizeof(mach_pwd->hash),
 382                                                  &keyblock);
 383
 384                         if (ret == 0) {
 385                                 ret = smb_krb5_kinit_keyblock_ccache(smb_krb5_context->krb5_context,
 386                                                                      ccache,
 387                                                                      princ,
 388                                                                      &keyblock,
 389                                                                      target_service,
 390                                                                      krb_options,
 391                                                                      NULL,
 392                                                                      &kdc_time);
 393                                 krb5_free_keyblock_contents(smb_krb5_context->krb5_context, &keyblock);
 394                         }
 395                 }
 396
 397 #ifdef SAMBA4_USES_HEIMDAL
 398                 smb_krb5_context_remove_event_ctx(smb_krb5_context, previous_ev, event_ctx);
 399 #endif
 400
 401                 if (ret == KRB5KRB_AP_ERR_SKEW || ret == KRB5_KDCREP_SKEW) {
 402                         /* Perhaps we have been given an invalid skew, so try again without it */
 403                         time_t t = time(NULL);
 404                         krb5_set_real_time(smb_krb5_context->krb5_context, t, 0);
 405                 } else {
 406                         /* not a skew problem */
 407                         break;
 408                 }
 409         }
 410
 411         krb5_get_init_creds_opt_free(smb_krb5_context->krb5_context, krb_options);
 412
 413         if (ret == KRB5KRB_AP_ERR_SKEW || ret == KRB5_KDCREP_SKEW) {
 414                 (*error_string) = talloc_asprintf(credentials, "kinit for %s failed (%s)\n",
 415                                                   cli_credentials_get_principal(credentials, mem_ctx),
 416                                                   smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 417                                                                              ret, mem_ctx));
 418                 talloc_free(mem_ctx);
 419                 return ret;
 420         }
 421
 422         /* cope with ticket being in the future due to clock skew */
 423         if ((unsigned)kdc_time > time(NULL)) {
 424                 time_t t = time(NULL);
 425                 int time_offset =(unsigned)kdc_time-t;
 426                 DEBUG(4,("Advancing clock by %d seconds to cope with clock skew\n", time_offset));
 427                 krb5_set_real_time(smb_krb5_context->krb5_context, t + time_offset + 1, 0);
 428         }
 429
 430         if (ret == KRB5KDC_ERR_PREAUTH_FAILED && cli_credentials_wrong_password(credentials)) {
 431                 ret = kinit_to_ccache(parent_ctx,
 432                                       credentials,
 433                                       smb_krb5_context,
 434                                       event_ctx,
 435                                       ccache, obtained,
 436                                       error_string);
 437         }
 438
 439         if (ret) {
 440                 (*error_string) = talloc_asprintf(credentials, "kinit for %s failed (%s)\n",
 441                                                   cli_credentials_get_principal(credentials, mem_ctx),
 442                                                   smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 443                                                                              ret, mem_ctx));
 444                 talloc_free(mem_ctx);
 445                 return ret;
 446         }
 447
 448         DEBUG(10,("kinit for %s succeeded\n",
 449                 cli_credentials_get_principal(credentials, mem_ctx)));
 450
 451
 452         talloc_free(mem_ctx);
 453         return 0;
 454 }
 455
 456 static krb5_error_code free_keytab_container(struct keytab_container *ktc)
 457 {
 458         return krb5_kt_close(ktc->smb_krb5_context->krb5_context, ktc->keytab);
 459 }
 460
 461 krb5_error_code smb_krb5_get_keytab_container(TALLOC_CTX *mem_ctx,
 462                                 struct smb_krb5_context *smb_krb5_context,
 463                                 krb5_keytab opt_keytab,
 464                                 const char *keytab_name,
 465                                 struct keytab_container **ktc)
 466 {
 467         krb5_keytab keytab;
 468         krb5_error_code ret;
 469
 470         if (opt_keytab) {
 471                 keytab = opt_keytab;
 472         } else {
 473                 ret = krb5_kt_resolve(smb_krb5_context->krb5_context,
 474                                                 keytab_name, &keytab);
 475                 if (ret) {
 476                         DEBUG(1,("failed to open krb5 keytab: %s\n",
 477                                  smb_get_krb5_error_message(
 478                                         smb_krb5_context->krb5_context,
 479                                         ret, mem_ctx)));
 480                         return ret;
 481                 }
 482         }
 483
 484         *ktc = talloc(mem_ctx, struct keytab_container);
 485         if (!*ktc) {
 486                 return ENOMEM;
 487         }
 488
 489         (*ktc)->smb_krb5_context = talloc_reference(*ktc, smb_krb5_context);
 490         (*ktc)->keytab = keytab;
 491         (*ktc)->password_based = false;
 492         talloc_set_destructor(*ktc, free_keytab_container);
 493
 494         return 0;
 495 }
 496
 497 /*
 498  * Walk the keytab, looking for entries of this principal name,
 499  * with KVNO other than current kvno -1.
 500  *
 501  * These entries are now stale,
 502  * we only keep the current and previous entries around.
 503  *
 504  * Inspired by the code in Samba3 for 'use kerberos keytab'.
 505  */
 506 krb5_error_code smb_krb5_remove_obsolete_keytab_entries(TALLOC_CTX *mem_ctx,
 507                                                         krb5_context context,
 508                                                         krb5_keytab keytab,
 509                                                         uint32_t num_principals,
 510                                                         krb5_principal *principals,
 511                                                         krb5_kvno kvno,
 512                                                         bool *found_previous,
 513                                                         const char **error_string)
 514 {
 515         TALLOC_CTX *tmp_ctx;
 516         krb5_error_code code;
 517         krb5_kt_cursor cursor;
 518
 519         tmp_ctx = talloc_new(mem_ctx);
 520         if (tmp_ctx == NULL) {
 521                 *error_string = "Cannot allocate tmp_ctx";
 522                 return ENOMEM;
 523         }
 524
 525         *found_previous = true;
 526
 527         code = krb5_kt_start_seq_get(context, keytab, &cursor);
 528         switch (code) {
 529         case 0:
 530                 break;
 531 #ifdef HEIM_ERR_OPNOTSUPP
 532         case HEIM_ERR_OPNOTSUPP:
 533 #endif
 534         case ENOENT:
 535         case KRB5_KT_END:
 536                 /* no point enumerating if there isn't anything here */
 537                 code = 0;
 538                 goto done;
 539         default:
 540                 *error_string = talloc_asprintf(mem_ctx,
 541                                                 "failed to open keytab for read of old entries: %s\n",
 542                                                 smb_get_krb5_error_message(context, code, mem_ctx));
 543                 goto done;
 544         }
 545
 546         do {
 547                 krb5_kvno old_kvno = kvno - 1;
 548                 krb5_keytab_entry entry;
 549                 bool matched = false;
 550                 uint32_t i;
 551
 552                 code = krb5_kt_next_entry(context, keytab, &entry, &cursor);
 553                 if (code) {
 554                         break;
 555                 }
 556
 557                 for (i = 0; i < num_principals; i++) {
 558                         krb5_boolean ok;
 559
 560                         ok = smb_krb5_kt_compare(context,
 561                                                 &entry,
 562                                                 principals[i],
 563                                                 0,
 564                                                 0);
 565                         if (ok) {
 566                                 matched = true;
 567                                 break;
 568                         }
 569                 }
 570
 571                 if (!matched) {
 572                         /*
 573                          * Free the entry, it wasn't the one we were looking
 574                          * for anyway
 575                          */
 576                         krb5_kt_free_entry(context, &entry);
 577                         /* Make sure we do not double free */
 578                         ZERO_STRUCT(entry);
 579                         continue;
 580                 }
 581
 582                 /*
 583                  * Delete it, if it is not kvno - 1.
 584                  *
 585                  * Some keytab files store the kvno only in 8bits. Limit the
 586                  * compare to 8bits, so that we don't miss old keys and delete
 587                  * them.
 588                  */
 589                 if ((entry.vno & 0xff) != (old_kvno & 0xff)) {
 590                         krb5_error_code rc;
 591
 592                         /* Release the enumeration.  We are going to
 593                          * have to start this from the top again,
 594                          * because deletes during enumeration may not
 595                          * always be consistent.
 596                          *
 597                          * Also, the enumeration locks a FILE: keytab
 598                          */
 599                         krb5_kt_end_seq_get(context, keytab, &cursor);
 600
 601                         code = krb5_kt_remove_entry(context, keytab, &entry);
 602                         krb5_kt_free_entry(context, &entry);
 603
 604                         /* Make sure we do not double free */
 605                         ZERO_STRUCT(entry);
 606
 607                         /* Deleted: Restart from the top */
 608                         rc = krb5_kt_start_seq_get(context, keytab, &cursor);
 609                         if (rc != 0) {
 610                                 krb5_kt_free_entry(context, &entry);
 611
 612                                 /* Make sure we do not double free */
 613                                 ZERO_STRUCT(entry);
 614
 615                                 DEBUG(1, ("failed to restart enumeration of keytab: %s\n",
 616                                           smb_get_krb5_error_message(context,
 617                                                                      code,
 618                                                                      tmp_ctx)));
 619
 620                                 talloc_free(tmp_ctx);
 621                                 return rc;
 622                         }
 623
 624                         if (code != 0) {
 625                                 break;
 626                         }
 627
 628                 } else {
 629                         *found_previous = true;
 630                 }
 631
 632                 /* Free the entry, we don't need it any more */
 633                 krb5_kt_free_entry(context, &entry);
 634                 /* Make sure we do not double free */
 635                 ZERO_STRUCT(entry);
 636         } while (code != 0);
 637
 638         krb5_kt_end_seq_get(context, keytab, &cursor);
 639
 640         switch (code) {
 641         case 0:
 642                 break;
 643         case ENOENT:
 644         case KRB5_KT_END:
 645                 code = 0;
 646                 break;
 647         default:
 648                 *error_string = talloc_asprintf(mem_ctx,
 649                                                 "failed in deleting old entries for principal: %s\n",
 650                                                 smb_get_krb5_error_message(context,
 651                                                                            code,
 652                                                                            mem_ctx));
 653         }
 654
 655         code = 0;
 656 done:
 657         talloc_free(tmp_ctx);
 658         return code;
 659 }