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 #include <ldb.h>
  32 #include "param/secrets.h"
  33
  34 struct principal_container {
  35         struct smb_krb5_context *smb_krb5_context;
  36         krb5_principal principal;
  37         const char *string_form; /* Optional */
  38 };
  39
  40 static krb5_error_code free_principal(struct principal_container *pc)
  41 {
  42         /* current heimdal - 0.6.3, which we need anyway, fixes segfaults here */
  43         krb5_free_principal(pc->smb_krb5_context->krb5_context, pc->principal);
  44
  45         return 0;
  46 }
  47
  48
  49 static krb5_error_code parse_principal(TALLOC_CTX *parent_ctx,
  50                                        const char *princ_string,
  51                                        struct smb_krb5_context *smb_krb5_context,
  52                                        krb5_principal *princ,
  53                                        const char **error_string)
  54 {
  55         int ret;
  56         struct principal_container *mem_ctx;
  57         if (princ_string == NULL) {
  58                  *princ = NULL;
  59                  return 0;
  60         }
  61
  62         ret = krb5_parse_name(smb_krb5_context->krb5_context,
  63                               princ_string, princ);
  64
  65         if (ret) {
  66                 (*error_string) = smb_get_krb5_error_message(smb_krb5_context->krb5_context, 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, smb_krb5_context);
  79         mem_ctx->principal = *princ;
  80         talloc_set_destructor(mem_ctx, free_principal);
  81         return 0;
  82 }
  83
  84 static krb5_error_code principals_from_msg(TALLOC_CTX *parent_ctx,
  85                                            struct ldb_message *msg,
  86                                            struct smb_krb5_context *smb_krb5_context,
  87                                            struct principal_container ***principals_out,
  88                                            const char **error_string)
  89 {
  90         unsigned int i;
  91         krb5_error_code ret;
  92         char *upper_realm;
  93         const char *realm = ldb_msg_find_attr_as_string(msg, "realm", NULL);
  94         const char *samAccountName = ldb_msg_find_attr_as_string(msg, "samAccountName", NULL);
  95         struct ldb_message_element *spn_el = ldb_msg_find_element(msg, "servicePrincipalName");
  96         TALLOC_CTX *tmp_ctx;
  97         struct principal_container **principals;
  98         tmp_ctx = talloc_new(parent_ctx);
  99         if (!tmp_ctx) {
 100                 *error_string = "Cannot allocate tmp_ctx";
 101                 return ENOMEM;
 102         }
 103
 104         if (!realm) {
 105                 *error_string = "Cannot have a kerberos secret in secrets.ldb without a realm";
 106                 return EINVAL;
 107         }
 108
 109         upper_realm = strupper_talloc(tmp_ctx, realm);
 110         if (!upper_realm) {
 111                 talloc_free(tmp_ctx);
 112                 *error_string = "Cannot allocate full upper case realm";
 113                 return ENOMEM;
 114         }
 115
 116         principals = talloc_array(tmp_ctx, struct principal_container *, spn_el ? (spn_el->num_values + 2) : 2);
 117
 118         spn_el = ldb_msg_find_element(msg, "servicePrincipalName");
 119         for (i=0; spn_el && i < spn_el->num_values; i++) {
 120                 principals[i] = talloc(principals, struct principal_container);
 121                 if (!principals[i]) {
 122                         talloc_free(tmp_ctx);
 123                         *error_string = "Cannot allocate mem_ctx";
 124                         return ENOMEM;
 125                 }
 126
 127                 principals[i]->smb_krb5_context = talloc_reference(principals[i], smb_krb5_context);
 128                 principals[i]->string_form = talloc_asprintf(principals[i], "%*.*s@%s",
 129                                                              (int)spn_el->values[i].length,
 130                                                              (int)spn_el->values[i].length,
 131                                                              (const char *)spn_el->values[i].data, upper_realm);
 132                 if (!principals[i]->string_form) {
 133                         talloc_free(tmp_ctx);
 134                         *error_string = "Cannot allocate full samAccountName";
 135                         return ENOMEM;
 136                 }
 137
 138                 ret = krb5_parse_name(smb_krb5_context->krb5_context,
 139                                       principals[i]->string_form, &principals[i]->principal);
 140
 141                 if (ret) {
 142                         talloc_free(tmp_ctx);
 143                         (*error_string) = smb_get_krb5_error_message(smb_krb5_context->krb5_context, ret, parent_ctx);
 144                         return ret;
 145                 }
 146
 147                 /* This song-and-dance effectivly puts the principal
 148                  * into talloc, so we can't loose it. */
 149                 talloc_set_destructor(principals[i], free_principal);
 150         }
 151
 152         if (samAccountName) {
 153                 principals[i] = talloc(principals, struct principal_container);
 154                 if (!principals[i]) {
 155                         talloc_free(tmp_ctx);
 156                         *error_string = "Cannot allocate mem_ctx";
 157                         return ENOMEM;
 158                 }
 159
 160                 principals[i]->smb_krb5_context = talloc_reference(principals[i], smb_krb5_context);
 161                 principals[i]->string_form = talloc_asprintf(parent_ctx, "%s@%s", samAccountName, upper_realm);
 162                 if (!principals[i]->string_form) {
 163                         talloc_free(tmp_ctx);
 164                         *error_string = "Cannot allocate full samAccountName";
 165                         return ENOMEM;
 166                 }
 167
 168                 ret = krb5_make_principal(smb_krb5_context->krb5_context, &principals[i]->principal, upper_realm, samAccountName,
 169                                           NULL);
 170                 if (ret) {
 171                         talloc_free(tmp_ctx);
 172                         (*error_string) = smb_get_krb5_error_message(smb_krb5_context->krb5_context, ret, parent_ctx);
 173                         return ret;
 174                 }
 175
 176                 /* This song-and-dance effectively puts the principal
 177                  * into talloc, so we can't loose it. */
 178                 talloc_set_destructor(principals[i], free_principal);
 179                 i++;
 180         }
 181
 182         principals[i] = NULL;
 183         *principals_out = talloc_steal(parent_ctx, principals);
 184
 185         talloc_free(tmp_ctx);
 186         return ret;
 187 }
 188
 189 static krb5_error_code salt_principal_from_msg(TALLOC_CTX *parent_ctx,
 190                                                struct ldb_message *msg,
 191                                                struct smb_krb5_context *smb_krb5_context,
 192                                                krb5_principal *salt_princ,
 193                                                const char **error_string)
 194 {
 195         const char *salt_principal = ldb_msg_find_attr_as_string(msg, "saltPrincipal", NULL);
 196         const char *samAccountName = ldb_msg_find_attr_as_string(msg, "samAccountName", NULL);
 197         const char *realm = ldb_msg_find_attr_as_string(msg, "realm", NULL);
 198         if (salt_principal) {
 199                 return parse_principal(parent_ctx, salt_principal, smb_krb5_context, salt_princ, error_string);
 200         } else if (samAccountName) {
 201                 krb5_error_code ret;
 202                 char *machine_username;
 203                 char *salt_body;
 204                 char *lower_realm;
 205                 char *upper_realm;
 206
 207                 TALLOC_CTX *tmp_ctx;
 208                 struct principal_container *mem_ctx = talloc(parent_ctx, struct principal_container);
 209                 if (!mem_ctx) {
 210                         *error_string = "Cannot allocate mem_ctx";
 211                         return ENOMEM;
 212                 }
 213
 214                 tmp_ctx = talloc_new(mem_ctx);
 215                 if (!tmp_ctx) {
 216                         talloc_free(mem_ctx);
 217                         *error_string = "Cannot allocate tmp_ctx";
 218                         return ENOMEM;
 219                 }
 220
 221                 if (!realm) {
 222                         *error_string = "Cannot have a kerberos secret in secrets.ldb without a realm";
 223                         return EINVAL;
 224                 }
 225
 226                 machine_username = talloc_strdup(tmp_ctx, samAccountName);
 227                 if (!machine_username) {
 228                         talloc_free(mem_ctx);
 229                         *error_string = "Cannot duplicate samAccountName";
 230                         return ENOMEM;
 231                 }
 232
 233                 if (machine_username[strlen(machine_username)-1] == '$') {
 234                         machine_username[strlen(machine_username)-1] = '\0';
 235                 }
 236
 237                 lower_realm = strlower_talloc(tmp_ctx, realm);
 238                 if (!lower_realm) {
 239                         talloc_free(mem_ctx);
 240                         *error_string = "Cannot allocate to lower case realm";
 241                         return ENOMEM;
 242                 }
 243
 244                 upper_realm = strupper_talloc(tmp_ctx, realm);
 245                 if (!upper_realm) {
 246                         talloc_free(mem_ctx);
 247                         *error_string = "Cannot allocate to upper case realm";
 248                         return ENOMEM;
 249                 }
 250
 251                 salt_body = talloc_asprintf(tmp_ctx, "%s.%s", machine_username,
 252                                             lower_realm);
 253                 talloc_free(lower_realm);
 254                 talloc_free(machine_username);
 255                 if (!salt_body) {
 256                         talloc_free(mem_ctx);
 257                         *error_string = "Cannot form salt principal body";
 258                         return ENOMEM;
 259                 }
 260
 261                 ret = krb5_make_principal(smb_krb5_context->krb5_context, salt_princ,
 262                                           upper_realm,
 263                                           "host", salt_body, NULL);
 264                 if (ret == 0) {
 265                         /* This song-and-dance effectively puts the principal
 266                          * into talloc, so we can't loose it. */
 267                         mem_ctx->smb_krb5_context = talloc_reference(mem_ctx, smb_krb5_context);
 268                         mem_ctx->principal = *salt_princ;
 269                         talloc_set_destructor(mem_ctx, free_principal);
 270                 } else {
 271                         (*error_string) = smb_get_krb5_error_message(smb_krb5_context->krb5_context, ret, parent_ctx);
 272                 }
 273                 talloc_free(tmp_ctx);
 274                 return ret;
 275         } else {
 276                 (*error_string) = "Cannot determine salt principal, no saltPrincipal or samAccountName specified";
 277                 return EINVAL;
 278         }
 279 }
 280
 281 /* Obtain the principal set on this context.  Requires a
 282  * smb_krb5_context because we are doing krb5 principal parsing with
 283  * the library routines.  The returned princ is placed in the talloc
 284  * system by means of a destructor (do *not* free). */
 285
 286 krb5_error_code principal_from_credentials(TALLOC_CTX *parent_ctx,
 287                                             struct cli_credentials *credentials,
 288                                             struct smb_krb5_context *smb_krb5_context,
 289                                             krb5_principal *princ,
 290                                             enum credentials_obtained *obtained,
 291                                             const char **error_string)
 292 {
 293         krb5_error_code ret;
 294         const char *princ_string;
 295         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 296         *obtained = CRED_UNINITIALISED;
 297
 298         if (!mem_ctx) {
 299                 (*error_string) = error_message(ENOMEM);
 300                 return ENOMEM;
 301         }
 302         princ_string = cli_credentials_get_principal_and_obtained(credentials, mem_ctx, obtained);
 303         if (!princ_string) {
 304                 *princ = NULL;
 305                 return 0;
 306         }
 307
 308         ret = parse_principal(parent_ctx, princ_string,
 309                               smb_krb5_context, princ, error_string);
 310         talloc_free(mem_ctx);
 311         return ret;
 312 }
 313
 314 /* Obtain the principal set on this context.  Requires a
 315  * smb_krb5_context because we are doing krb5 principal parsing with
 316  * the library routines.  The returned princ is placed in the talloc
 317  * system by means of a destructor (do *not* free). */
 318
 319 static
 320  krb5_error_code impersonate_principal_from_credentials(TALLOC_CTX *parent_ctx,
 321                                                         struct cli_credentials *credentials,
 322                                                         struct smb_krb5_context *smb_krb5_context,
 323                                                         krb5_principal *princ,
 324                                                         const char **error_string)
 325 {
 326         return parse_principal(parent_ctx, cli_credentials_get_impersonate_principal(credentials),
 327                                smb_krb5_context, princ, error_string);
 328 }
 329
 330 /**
 331  * Return a freshly allocated ccache (destroyed by destructor on child
 332  * of parent_ctx), for a given set of client credentials
 333  */
 334
 335  krb5_error_code kinit_to_ccache(TALLOC_CTX *parent_ctx,
 336                                  struct cli_credentials *credentials,
 337                                  struct smb_krb5_context *smb_krb5_context,
 338                                  struct tevent_context *event_ctx,
 339                                  krb5_ccache ccache,
 340                                  enum credentials_obtained *obtained,
 341                                  const char **error_string)
 342 {
 343         krb5_error_code ret;
 344         const char *password;
 345         const char *self_service;
 346         const char *target_service;
 347         time_t kdc_time = 0;
 348         krb5_principal princ;
 349         krb5_principal impersonate_principal;
 350         int tries;
 351         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 352         krb5_get_init_creds_opt *krb_options;
 353
 354         if (!mem_ctx) {
 355                 (*error_string) = strerror(ENOMEM);
 356                 return ENOMEM;
 357         }
 358
 359         ret = principal_from_credentials(mem_ctx, credentials, smb_krb5_context, &princ, obtained, error_string);
 360         if (ret) {
 361                 talloc_free(mem_ctx);
 362                 return ret;
 363         }
 364
 365         if (princ == NULL) {
 366                 (*error_string) = talloc_asprintf(credentials, "principal, username or realm was not specified in the credentials");
 367                 talloc_free(mem_ctx);
 368                 return KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN;
 369         }
 370
 371         ret = impersonate_principal_from_credentials(mem_ctx, credentials, smb_krb5_context, &impersonate_principal, error_string);
 372         if (ret) {
 373                 talloc_free(mem_ctx);
 374                 return ret;
 375         }
 376
 377         self_service = cli_credentials_get_self_service(credentials);
 378         target_service = cli_credentials_get_target_service(credentials);
 379
 380         password = cli_credentials_get_password(credentials);
 381
 382         /* setup the krb5 options we want */
 383         if ((ret = krb5_get_init_creds_opt_alloc(smb_krb5_context->krb5_context, &krb_options))) {
 384                 (*error_string) = talloc_asprintf(credentials, "krb5_get_init_creds_opt_alloc failed (%s)\n",
 385                                                   smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 386                                                                              ret, mem_ctx));
 387                 talloc_free(mem_ctx);
 388                 return ret;
 389         }
 390
 391         /* get the defaults */
 392         krb5_get_init_creds_opt_set_default_flags(smb_krb5_context->krb5_context, NULL, NULL, krb_options);
 393
 394         /* set if we want a forwardable ticket */
 395         switch (cli_credentials_get_krb_forwardable(credentials)) {
 396         case CRED_AUTO_KRB_FORWARDABLE:
 397                 break;
 398         case CRED_NO_KRB_FORWARDABLE:
 399                 krb5_get_init_creds_opt_set_forwardable(krb_options, FALSE);
 400                 break;
 401         case CRED_FORCE_KRB_FORWARDABLE:
 402                 krb5_get_init_creds_opt_set_forwardable(krb_options, TRUE);
 403                 break;
 404         }
 405
 406         /*
 407          * In order to work against windows KDCs even if we use
 408          * the netbios domain name as realm, we need to add the following
 409          * flags:
 410          * KRB5_INIT_CREDS_NO_C_CANON_CHECK;
 411          * KRB5_INIT_CREDS_NO_C_NO_EKU_CHECK;
 412          */
 413         krb5_get_init_creds_opt_set_win2k(smb_krb5_context->krb5_context,
 414                                           krb_options, true);
 415
 416         tries = 2;
 417         while (tries--) {
 418                 struct tevent_context *previous_ev;
 419                 /* Do this every time, in case we have weird recursive issues here */
 420                 ret = smb_krb5_context_set_event_ctx(smb_krb5_context, event_ctx, &previous_ev);
 421                 if (ret) {
 422                         talloc_free(mem_ctx);
 423                         return ret;
 424                 }
 425                 if (password) {
 426                         ret = kerberos_kinit_password_cc(smb_krb5_context->krb5_context, ccache,
 427                                                          princ, password,
 428                                                          impersonate_principal,
 429                                                          self_service,
 430                                                          target_service,
 431                                                          krb_options,
 432                                                          NULL, &kdc_time);
 433                 } else if (impersonate_principal) {
 434                         talloc_free(mem_ctx);
 435                         (*error_string) = "INTERNAL error: Cannot impersonate principal with just a keyblock.  A password must be specified in the credentials";
 436                         return EINVAL;
 437                 } else {
 438                         /* No password available, try to use a keyblock instead */
 439
 440                         krb5_keyblock keyblock;
 441                         const struct samr_Password *mach_pwd;
 442                         mach_pwd = cli_credentials_get_nt_hash(credentials, mem_ctx);
 443                         if (!mach_pwd) {
 444                                 talloc_free(mem_ctx);
 445                                 (*error_string) = "kinit_to_ccache: No password available for kinit\n";
 446                                 krb5_get_init_creds_opt_free(smb_krb5_context->krb5_context, krb_options);
 447                                 smb_krb5_context_remove_event_ctx(smb_krb5_context, previous_ev, event_ctx);
 448                                 return EINVAL;
 449                         }
 450                         ret = krb5_keyblock_init(smb_krb5_context->krb5_context,
 451                                                  ENCTYPE_ARCFOUR_HMAC,
 452                                                  mach_pwd->hash, sizeof(mach_pwd->hash),
 453                                                  &keyblock);
 454
 455                         if (ret == 0) {
 456                                 ret = kerberos_kinit_keyblock_cc(smb_krb5_context->krb5_context, ccache,
 457                                                                  princ, &keyblock,
 458                                                                  target_service, krb_options,
 459                                                                  NULL, &kdc_time);
 460                                 krb5_free_keyblock_contents(smb_krb5_context->krb5_context, &keyblock);
 461                         }
 462                 }
 463
 464                 smb_krb5_context_remove_event_ctx(smb_krb5_context, previous_ev, event_ctx);
 465
 466                 if (ret == KRB5KRB_AP_ERR_SKEW || ret == KRB5_KDCREP_SKEW) {
 467                         /* Perhaps we have been given an invalid skew, so try again without it */
 468                         time_t t = time(NULL);
 469                         krb5_set_real_time(smb_krb5_context->krb5_context, t, 0);
 470                 } else {
 471                         /* not a skew problem */
 472                         break;
 473                 }
 474         }
 475
 476         krb5_get_init_creds_opt_free(smb_krb5_context->krb5_context, krb_options);
 477
 478         if (ret == KRB5KRB_AP_ERR_SKEW || ret == KRB5_KDCREP_SKEW) {
 479                 (*error_string) = talloc_asprintf(credentials, "kinit for %s failed (%s)\n",
 480                                                   cli_credentials_get_principal(credentials, mem_ctx),
 481                                                   smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 482                                                                              ret, mem_ctx));
 483                 talloc_free(mem_ctx);
 484                 return ret;
 485         }
 486
 487         /* cope with ticket being in the future due to clock skew */
 488         if ((unsigned)kdc_time > time(NULL)) {
 489                 time_t t = time(NULL);
 490                 int time_offset =(unsigned)kdc_time-t;
 491                 DEBUG(4,("Advancing clock by %d seconds to cope with clock skew\n", time_offset));
 492                 krb5_set_real_time(smb_krb5_context->krb5_context, t + time_offset + 1, 0);
 493         }
 494
 495         if (ret == KRB5KDC_ERR_PREAUTH_FAILED && cli_credentials_wrong_password(credentials)) {
 496                 ret = kinit_to_ccache(parent_ctx,
 497                                       credentials,
 498                                       smb_krb5_context,
 499                                       event_ctx,
 500                                       ccache, obtained,
 501                                       error_string);
 502         }
 503
 504         if (ret) {
 505                 (*error_string) = talloc_asprintf(credentials, "kinit for %s failed (%s)\n",
 506                                                   cli_credentials_get_principal(credentials, mem_ctx),
 507                                                   smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 508                                                                              ret, mem_ctx));
 509                 talloc_free(mem_ctx);
 510                 return ret;
 511         }
 512         talloc_free(mem_ctx);
 513         return 0;
 514 }
 515
 516 static krb5_error_code free_keytab_container(struct keytab_container *ktc)
 517 {
 518         return krb5_kt_close(ktc->smb_krb5_context->krb5_context, ktc->keytab);
 519 }
 520
 521 krb5_error_code smb_krb5_get_keytab_container(TALLOC_CTX *mem_ctx,
 522                                               struct smb_krb5_context *smb_krb5_context,
 523                                               const char *keytab_name, struct keytab_container **ktc)
 524 {
 525         krb5_keytab keytab;
 526         krb5_error_code ret;
 527         ret = krb5_kt_resolve(smb_krb5_context->krb5_context, keytab_name, &keytab);
 528         if (ret) {
 529                 DEBUG(1,("failed to open krb5 keytab: %s\n",
 530                          smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 531                                                     ret, mem_ctx)));
 532                 return ret;
 533         }
 534
 535         *ktc = talloc(mem_ctx, struct keytab_container);
 536         if (!*ktc) {
 537                 return ENOMEM;
 538         }
 539
 540         (*ktc)->smb_krb5_context = talloc_reference(*ktc, smb_krb5_context);
 541         (*ktc)->keytab = keytab;
 542         talloc_set_destructor(*ktc, free_keytab_container);
 543
 544         return 0;
 545 }
 546
 547 static krb5_error_code keytab_add_keys(TALLOC_CTX *parent_ctx,
 548                                        struct principal_container **principals,
 549                                        krb5_principal salt_princ,
 550                                        int kvno,
 551                                        const char *password_s,
 552                                        struct smb_krb5_context *smb_krb5_context,
 553                                        krb5_enctype *enctypes,
 554                                        krb5_keytab keytab,
 555                                        const char **error_string)
 556 {
 557         unsigned int i, p;
 558         krb5_error_code ret;
 559         krb5_data password;
 560
 561         password.data = discard_const_p(char *, password_s);
 562         password.length = strlen(password_s);
 563
 564         for (i=0; enctypes[i]; i++) {
 565                 krb5_keytab_entry entry;
 566
 567                 ZERO_STRUCT(entry);
 568
 569                 ret = create_kerberos_key_from_string_direct(smb_krb5_context->krb5_context,
 570                                                              salt_princ, &password, &entry.keyblock, enctypes[i]);
 571                 if (ret != 0) {
 572                         return ret;
 573                 }
 574
 575                 entry.vno = kvno;
 576
 577                 for (p=0; principals[p]; p++) {
 578                         entry.principal = principals[p]->principal;
 579                         ret = krb5_kt_add_entry(smb_krb5_context->krb5_context, keytab, &entry);
 580                         if (ret != 0) {
 581                                 char *k5_error_string = smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 582                                                                                    ret, NULL);
 583                                 *error_string = talloc_asprintf(parent_ctx, "Failed to add enctype %d entry for %s(kvno %d) to keytab: %s\n",
 584                                                                 (int)enctypes[i],
 585                                                                 principals[p]->string_form,
 586                                                                 kvno,
 587                                                                 k5_error_string);
 588                                 talloc_free(k5_error_string);
 589                                 krb5_free_keyblock_contents(smb_krb5_context->krb5_context, &entry.keyblock);
 590                                 return ret;
 591                         }
 592
 593                         DEBUG(5, ("Added %s(kvno %d) to keytab (enctype %d)\n",
 594                                   principals[p]->string_form, kvno,
 595                                   (int)enctypes[i]));
 596                 }
 597                 krb5_free_keyblock_contents(smb_krb5_context->krb5_context, &entry.keyblock);
 598         }
 599         return 0;
 600 }
 601
 602 static krb5_error_code ms_suptypes_to_ietf_enctypes(TALLOC_CTX *mem_ctx,
 603                                                 uint32_t enctype_bitmap,
 604                                                 krb5_enctype **enctypes);
 605
 606 static krb5_error_code create_keytab(TALLOC_CTX *parent_ctx,
 607                                      struct ldb_message *msg,
 608                                      struct principal_container **principals,
 609                                      struct smb_krb5_context *smb_krb5_context,
 610                                      krb5_keytab keytab,
 611                                      bool add_old,
 612                                      const char **error_string)
 613 {
 614         krb5_error_code ret;
 615         const char *password_s;
 616         const char *old_secret;
 617         int kvno;
 618         uint32_t enctype_bitmap;
 619         krb5_principal salt_princ;
 620         krb5_enctype *enctypes;
 621         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 622         if (!mem_ctx) {
 623                 *error_string = "unable to allocate tmp_ctx for create_keytab";
 624                 return ENOMEM;
 625         }
 626
 627         /* The salt used to generate these entries may be different however, fetch that */
 628         ret = salt_principal_from_msg(mem_ctx, msg,
 629                                       smb_krb5_context,
 630                                       &salt_princ, error_string);
 631         if (ret) {
 632                 talloc_free(mem_ctx);
 633                 return ret;
 634         }
 635
 636         kvno = ldb_msg_find_attr_as_int(msg, "msDS-KeyVersionNumber", 0);
 637
 638         /* Finally, do the dance to get the password to put in the entry */
 639         password_s =  ldb_msg_find_attr_as_string(msg, "secret", NULL);
 640
 641         if (!password_s) {
 642                 /* There is no password here, so nothing to do */
 643                 talloc_free(mem_ctx);
 644                 return 0;
 645         }
 646
 647         if (add_old && kvno != 0) {
 648                 old_secret = ldb_msg_find_attr_as_string(msg, "priorSecret", NULL);
 649         } else {
 650                 old_secret = NULL;
 651         }
 652
 653         enctype_bitmap = (uint32_t)ldb_msg_find_attr_as_int(msg, "msDS-SupportedEncryptionTypes", ENC_ALL_TYPES);
 654
 655         ret = ms_suptypes_to_ietf_enctypes(mem_ctx, enctype_bitmap, &enctypes);
 656         if (ret) {
 657                 *error_string = talloc_asprintf(parent_ctx, "create_keytab: generating list of encryption types failed (%s)\n",
 658                                                 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 659                                                                            ret, mem_ctx));
 660                 talloc_free(mem_ctx);
 661                 return ret;
 662         }
 663
 664         ret = keytab_add_keys(mem_ctx, principals,
 665                               salt_princ,
 666                               kvno, password_s, smb_krb5_context,
 667                               enctypes, keytab, error_string);
 668         if (ret) {
 669                 talloc_free(mem_ctx);
 670                 return ret;
 671         }
 672
 673         if (old_secret) {
 674                 ret = keytab_add_keys(mem_ctx, principals,
 675                                       salt_princ,
 676                                       kvno - 1, old_secret, smb_krb5_context,
 677                                       enctypes, keytab, error_string);
 678                 if (ret) {
 679                         talloc_free(mem_ctx);
 680                         return ret;
 681                 }
 682         }
 683
 684         talloc_free(mem_ctx);
 685         return ret;
 686 }
 687
 688 /*
 689  * Walk the keytab, looking for entries of this principal name, with KVNO other than current kvno -1.
 690  *
 691  * These entries are now stale, we only keep the current, and previous entries around.
 692  *
 693  * Inspired by the code in Samba3 for 'use kerberos keytab'.
 694  *
 695  */
 696
 697 static krb5_error_code remove_old_entries(TALLOC_CTX *parent_ctx,
 698                                           struct ldb_message *msg,
 699                                           struct principal_container **principals,
 700                                           bool delete_all_kvno,
 701                                           struct smb_krb5_context *smb_krb5_context,
 702                                           krb5_keytab keytab, bool *found_previous,
 703                                           const char **error_string)
 704 {
 705         krb5_error_code ret, ret2;
 706         krb5_kt_cursor cursor;
 707         int kvno;
 708         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 709
 710         if (!mem_ctx) {
 711                 return ENOMEM;
 712         }
 713
 714         *found_previous = false;
 715
 716         kvno = ldb_msg_find_attr_as_int(msg, "msDS-KeyVersionNumber", 0);
 717
 718         /* for each entry in the keytab */
 719         ret = krb5_kt_start_seq_get(smb_krb5_context->krb5_context, keytab, &cursor);
 720         switch (ret) {
 721         case 0:
 722                 break;
 723         case HEIM_ERR_OPNOTSUPP:
 724         case ENOENT:
 725         case KRB5_KT_END:
 726                 /* no point enumerating if there isn't anything here */
 727                 talloc_free(mem_ctx);
 728                 return 0;
 729         default:
 730                 *error_string = talloc_asprintf(parent_ctx, "failed to open keytab for read of old entries: %s\n",
 731                                                 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 732                                                                            ret, mem_ctx));
 733                 talloc_free(mem_ctx);
 734                 return ret;
 735         }
 736
 737         while (!ret) {
 738                 unsigned int i;
 739                 bool matched = false;
 740                 krb5_keytab_entry entry;
 741                 ret = krb5_kt_next_entry(smb_krb5_context->krb5_context, keytab, &entry, &cursor);
 742                 if (ret) {
 743                         break;
 744                 }
 745                 for (i = 0; principals[i]; i++) {
 746                         /* if it matches our principal */
 747                         if (krb5_kt_compare(smb_krb5_context->krb5_context, &entry, principals[i]->principal, 0, 0)) {
 748                                 matched = true;
 749                                 break;
 750                         }
 751                 }
 752
 753                 if (!matched) {
 754                         /* Free the entry, it wasn't the one we were looking for anyway */
 755                         krb5_kt_free_entry(smb_krb5_context->krb5_context, &entry);
 756                         continue;
 757                 }
 758
 759                 /* delete it, if it is not kvno -1 */
 760                 if (entry.vno != (kvno - 1 )) {
 761                         /* Release the enumeration.  We are going to
 762                          * have to start this from the top again,
 763                          * because deletes during enumeration may not
 764                          * always be consistent.
 765                          *
 766                          * Also, the enumeration locks a FILE: keytab
 767                          */
 768
 769                         krb5_kt_end_seq_get(smb_krb5_context->krb5_context, keytab, &cursor);
 770
 771                         ret = krb5_kt_remove_entry(smb_krb5_context->krb5_context, keytab, &entry);
 772                         krb5_kt_free_entry(smb_krb5_context->krb5_context, &entry);
 773
 774                         /* Deleted: Restart from the top */
 775                         ret2 = krb5_kt_start_seq_get(smb_krb5_context->krb5_context, keytab, &cursor);
 776                         if (ret2) {
 777                                 krb5_kt_free_entry(smb_krb5_context->krb5_context, &entry);
 778                                 DEBUG(1,("failed to restart enumeration of keytab: %s\n",
 779                                          smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 780                                                                     ret, mem_ctx)));
 781
 782                                 talloc_free(mem_ctx);
 783                                 return ret2;
 784                         }
 785
 786                         if (ret) {
 787                                 break;
 788                         }
 789
 790                 } else {
 791                         *found_previous = true;
 792                 }
 793
 794                 /* Free the entry, we don't need it any more */
 795                 krb5_kt_free_entry(smb_krb5_context->krb5_context, &entry);
 796
 797
 798         }
 799         krb5_kt_end_seq_get(smb_krb5_context->krb5_context, keytab, &cursor);
 800
 801         switch (ret) {
 802         case 0:
 803                 break;
 804         case ENOENT:
 805         case KRB5_KT_END:
 806                 ret = 0;
 807                 break;
 808         default:
 809                 *error_string = talloc_asprintf(parent_ctx, "failed in deleting old entries for principal: %s\n",
 810                                                 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
 811                                                                            ret, mem_ctx));
 812         }
 813         talloc_free(mem_ctx);
 814         return ret;
 815 }
 816
 817 krb5_error_code smb_krb5_update_keytab(TALLOC_CTX *parent_ctx,
 818                                        struct smb_krb5_context *smb_krb5_context,
 819                                        struct ldb_context *ldb,
 820                                        struct ldb_message *msg,
 821                                        bool delete_all_kvno,
 822                                        const char **error_string)
 823 {
 824         krb5_error_code ret;
 825         bool found_previous;
 826         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 827         struct keytab_container *keytab_container;
 828         struct principal_container **principals;
 829         const char *keytab_name;
 830
 831         if (!mem_ctx) {
 832                 return ENOMEM;
 833         }
 834
 835         keytab_name = keytab_name_from_msg(mem_ctx, ldb, msg);
 836         if (!keytab_name) {
 837                 return ENOENT;
 838         }
 839
 840         ret = smb_krb5_get_keytab_container(mem_ctx, smb_krb5_context, keytab_name, &keytab_container);
 841
 842         if (ret != 0) {
 843                 talloc_free(mem_ctx);
 844                 return ret;
 845         }
 846
 847         DEBUG(5, ("Opened keytab %s\n", keytab_name));
 848
 849         /* Get the principal we will store the new keytab entries under */
 850         ret = principals_from_msg(mem_ctx, msg, smb_krb5_context, &principals, error_string);
 851
 852         if (ret != 0) {
 853                 *error_string = talloc_asprintf(parent_ctx, "Failed to load principals from ldb message: %s\n", *error_string);
 854                 talloc_free(mem_ctx);
 855                 return ret;
 856         }
 857
 858         ret = remove_old_entries(mem_ctx, msg, principals, delete_all_kvno,
 859                                  smb_krb5_context, keytab_container->keytab, &found_previous, error_string);
 860         if (ret != 0) {
 861                 *error_string = talloc_asprintf(parent_ctx, "Failed to remove old principals from keytab: %s\n", *error_string);
 862                 talloc_free(mem_ctx);
 863                 return ret;
 864         }
 865
 866         if (!delete_all_kvno) {
 867                 /* Create a new keytab.  If during the cleanout we found
 868                  * entires for kvno -1, then don't try and duplicate them.
 869                  * Otherwise, add kvno, and kvno -1 */
 870
 871                 ret = create_keytab(mem_ctx, msg, principals,
 872                                     smb_krb5_context,
 873                                     keytab_container->keytab,
 874                                     found_previous ? false : true, error_string);
 875         }
 876         talloc_free(mem_ctx);
 877         return ret;
 878 }
 879
 880 krb5_error_code smb_krb5_create_memory_keytab(TALLOC_CTX *parent_ctx,
 881                                            struct cli_credentials *machine_account,
 882                                            struct smb_krb5_context *smb_krb5_context,
 883                                            struct keytab_container **keytab_container)
 884 {
 885         krb5_error_code ret;
 886         TALLOC_CTX *mem_ctx = talloc_new(parent_ctx);
 887         const char *rand_string;
 888         const char *keytab_name;
 889         struct ldb_message *msg;
 890         const char *error_string;
 891         if (!mem_ctx) {
 892                 return ENOMEM;
 893         }
 894
 895         *keytab_container = talloc(mem_ctx, struct keytab_container);
 896
 897         rand_string = generate_random_str(mem_ctx, 16);
 898         if (!rand_string) {
 899                 talloc_free(mem_ctx);
 900                 return ENOMEM;
 901         }
 902
 903         keytab_name = talloc_asprintf(mem_ctx, "MEMORY:%s",
 904                                       rand_string);
 905         if (!keytab_name) {
 906                 talloc_free(mem_ctx);
 907                 return ENOMEM;
 908         }
 909
 910         ret = smb_krb5_get_keytab_container(mem_ctx, smb_krb5_context, keytab_name, keytab_container);
 911         if (ret) {
 912                 return ret;
 913         }
 914
 915         msg = ldb_msg_new(mem_ctx);
 916         if (!msg) {
 917                 talloc_free(mem_ctx);
 918                 return ENOMEM;
 919         }
 920         ldb_msg_add_string(msg, "krb5Keytab", keytab_name);
 921         ldb_msg_add_string(msg, "secret", cli_credentials_get_password(machine_account));
 922         ldb_msg_add_string(msg, "samAccountName", cli_credentials_get_username(machine_account));
 923         ldb_msg_add_string(msg, "realm", cli_credentials_get_realm(machine_account));
 924         ldb_msg_add_fmt(msg, "msDS-KeyVersionNumber", "%d", (int)cli_credentials_get_kvno(machine_account));
 925
 926         ret = smb_krb5_update_keytab(mem_ctx, smb_krb5_context, NULL, msg, false, &error_string);
 927         if (ret == 0) {
 928                 talloc_steal(parent_ctx, *keytab_container);
 929         } else {
 930                 DEBUG(0, ("Failed to create in-memory keytab: %s\n", error_string));
 931                 *keytab_container = NULL;
 932         }
 933         talloc_free(mem_ctx);
 934         return ret;
 935 }
 936 /* Translate between the IETF encryption type values and the Microsoft msDS-SupportedEncryptionTypes values */
 937 uint32_t kerberos_enctype_to_bitmap(krb5_enctype enc_type_enum)
 938 {
 939         switch (enc_type_enum) {
 940         case ENCTYPE_DES_CBC_CRC:
 941                 return ENC_CRC32;
 942         case ENCTYPE_DES_CBC_MD5:
 943                 return ENC_RSA_MD5;
 944         case ENCTYPE_ARCFOUR_HMAC_MD5:
 945                 return ENC_RC4_HMAC_MD5;
 946         case ENCTYPE_AES128_CTS_HMAC_SHA1_96:
 947                 return ENC_HMAC_SHA1_96_AES128;
 948         case ENCTYPE_AES256_CTS_HMAC_SHA1_96:
 949                 return ENC_HMAC_SHA1_96_AES256;
 950         default:
 951                 return 0;
 952         }
 953 }
 954
 955 /* Translate between the Microsoft msDS-SupportedEncryptionTypes values
 956  * and the IETF encryption type values */
 957 static krb5_enctype ms_suptype_to_ietf_enctype(uint32_t enctype_bitmap)
 958 {
 959         switch (enctype_bitmap) {
 960         case ENC_CRC32:
 961                 return ENCTYPE_DES_CBC_CRC;
 962         case ENC_RSA_MD5:
 963                 return ENCTYPE_DES_CBC_MD5;
 964         case ENC_RC4_HMAC_MD5:
 965                 return ENCTYPE_ARCFOUR_HMAC_MD5;
 966         case ENC_HMAC_SHA1_96_AES128:
 967                 return ENCTYPE_AES128_CTS_HMAC_SHA1_96;
 968         case ENC_HMAC_SHA1_96_AES256:
 969                 return ENCTYPE_AES256_CTS_HMAC_SHA1_96;
 970         default:
 971                 return 0;
 972         }
 973 }
 974 /* Return an array of krb5_enctype values */
 975 static krb5_error_code ms_suptypes_to_ietf_enctypes(TALLOC_CTX *mem_ctx,
 976                                                 uint32_t enctype_bitmap,
 977                                                 krb5_enctype **enctypes)
 978 {
 979         unsigned int i, j = 0;
 980         *enctypes = talloc_zero_array(mem_ctx, krb5_enctype,
 981                                         (8 * sizeof(enctype_bitmap)) + 1);
 982         if (!*enctypes) {
 983                 return ENOMEM;
 984         }
 985         for (i = 0; i < (8 * sizeof(enctype_bitmap)); i++) {
 986                 uint32_t bit_value = (1 << i) & enctype_bitmap;
 987                 if (bit_value & enctype_bitmap) {
 988                         (*enctypes)[j] = ms_suptype_to_ietf_enctype(bit_value);
 989                         if (!(*enctypes)[j]) {
 990                                 continue;
 991                         }
 992                         j++;
 993                 }
 994         }
 995         (*enctypes)[j] = 0;
 996         return 0;
 997 }