source4/kdc/hdb-ldb.c

   1 /*
   2  * Copyright (c) 1999-2001, 2003, PADL Software Pty Ltd.
   3  * Copyright (c) 2004, Andrew Bartlett <abartlet@samba.org>.
   4  * Copyright (c) 2004, Stefan Metzmacher <metze@samba.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * 3. Neither the name of PADL Software  nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY PADL SOFTWARE AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL PADL SOFTWARE OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 #include "includes.h"
  36 #include "system/time.h"
  37 #include "kdc.h"
  38 #include "dsdb/common/flags.h"
  39 #include "hdb.h"
  40 #include "krb5_locl.h"
  41 #include "lib/ldb/include/ldb.h"
  42 #include "lib/ldb/include/ldb_errors.h"
  43 #include "librpc/gen_ndr/netlogon.h"
  44 #include "auth/auth.h"
  45 #include "auth/credentials/credentials.h"
  46 #include "auth/auth_sam.h"
  47 #include "util/util_ldb.h"
  48 #include "dsdb/samdb/samdb.h"
  49 #include "librpc/ndr/libndr.h"
  50 #include "librpc/gen_ndr/ndr_drsblobs.h"
  51 #include "libcli/auth/libcli_auth.h"
  52 #include "param/param.h"
  53
  54 enum hdb_ldb_ent_type
  55 { HDB_LDB_ENT_TYPE_CLIENT, HDB_LDB_ENT_TYPE_SERVER,
  56   HDB_LDB_ENT_TYPE_KRBTGT, HDB_LDB_ENT_TYPE_ANY };
  57
  58 static const char *realm_ref_attrs[] = {
  59         "nCName",
  60         "dnsRoot",
  61         NULL
  62 };
  63
  64 static KerberosTime ldb_msg_find_krb5time_ldap_time(struct ldb_message *msg, const char *attr, KerberosTime default_val)
  65 {
  66     const char *tmp;
  67     const char *gentime;
  68     struct tm tm;
  69
  70     gentime = ldb_msg_find_attr_as_string(msg, attr, NULL);
  71     if (!gentime)
  72         return default_val;
  73
  74     tmp = strptime(gentime, "%Y%m%d%H%M%SZ", &tm);
  75     if (tmp == NULL) {
  76             return default_val;
  77     }
  78
  79     return timegm(&tm);
  80 }
  81
  82 static HDBFlags uf2HDBFlags(krb5_context context, int userAccountControl, enum hdb_ldb_ent_type ent_type)
  83 {
  84         HDBFlags flags = int2HDBFlags(0);
  85
  86         /* we don't allow kadmin deletes */
  87         flags.immutable = 1;
  88
  89         /* mark the principal as invalid to start with */
  90         flags.invalid = 1;
  91
  92         flags.renewable = 1;
  93
  94         /* All accounts are servers, but this may be disabled again in the caller */
  95         flags.server = 1;
  96
  97         /* Account types - clear the invalid bit if it turns out to be valid */
  98         if (userAccountControl & UF_NORMAL_ACCOUNT) {
  99                 if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
 100                         flags.client = 1;
 101                 }
 102                 flags.invalid = 0;
 103         }
 104
 105         if (userAccountControl & UF_INTERDOMAIN_TRUST_ACCOUNT) {
 106                 if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
 107                         flags.client = 1;
 108                 }
 109                 flags.invalid = 0;
 110         }
 111         if (userAccountControl & UF_WORKSTATION_TRUST_ACCOUNT) {
 112                 if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
 113                         flags.client = 1;
 114                 }
 115                 flags.invalid = 0;
 116         }
 117         if (userAccountControl & UF_SERVER_TRUST_ACCOUNT) {
 118                 if (ent_type == HDB_LDB_ENT_TYPE_CLIENT || ent_type == HDB_LDB_ENT_TYPE_ANY) {
 119                         flags.client = 1;
 120                 }
 121                 flags.invalid = 0;
 122         }
 123
 124         /* Not permitted to act as a client if disabled */
 125         if (userAccountControl & UF_ACCOUNTDISABLE) {
 126                 flags.client = 0;
 127         }
 128         if (userAccountControl & UF_LOCKOUT) {
 129                 flags.invalid = 1;
 130         }
 131 /*
 132         if (userAccountControl & UF_PASSWORD_NOTREQD) {
 133                 flags.invalid = 1;
 134         }
 135 */
 136 /*
 137         UF_PASSWORD_CANT_CHANGE and UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED are irrelevent
 138 */
 139         if (userAccountControl & UF_TEMP_DUPLICATE_ACCOUNT) {
 140                 flags.invalid = 1;
 141         }
 142
 143 /* UF_DONT_EXPIRE_PASSWD and UF_USE_DES_KEY_ONLY handled in LDB_message2entry() */
 144
 145 /*
 146         if (userAccountControl & UF_MNS_LOGON_ACCOUNT) {
 147                 flags.invalid = 1;
 148         }
 149 */
 150         if (userAccountControl & UF_SMARTCARD_REQUIRED) {
 151                 flags.require_hwauth = 1;
 152         }
 153         if (userAccountControl & UF_TRUSTED_FOR_DELEGATION) {
 154                 flags.ok_as_delegate = 1;
 155         }
 156         if (!(userAccountControl & UF_NOT_DELEGATED)) {
 157                 flags.forwardable = 1;
 158                 flags.proxiable = 1;
 159         }
 160
 161         if (userAccountControl & UF_DONT_REQUIRE_PREAUTH) {
 162                 flags.require_preauth = 0;
 163         } else {
 164                 flags.require_preauth = 1;
 165
 166         }
 167         return flags;
 168 }
 169
 170 static int hdb_ldb_destrutor(struct hdb_ldb_private *private)
 171 {
 172     hdb_entry_ex *entry_ex = private->entry_ex;
 173     free_hdb_entry(&entry_ex->entry);
 174     return 0;
 175 }
 176
 177 static void hdb_ldb_free_entry(krb5_context context, hdb_entry_ex *entry_ex)
 178 {
 179         talloc_free(entry_ex->ctx);
 180 }
 181
 182 static krb5_error_code LDB_message2entry_keys(krb5_context context,
 183                                               struct smb_iconv_convenience *iconv_convenience,
 184                                               TALLOC_CTX *mem_ctx,
 185                                               struct ldb_message *msg,
 186                                               unsigned int userAccountControl,
 187                                               hdb_entry_ex *entry_ex)
 188 {
 189         krb5_error_code ret = 0;
 190         enum ndr_err_code ndr_err;
 191         struct samr_Password *hash;
 192         const struct ldb_val *sc_val;
 193         struct supplementalCredentialsBlob scb;
 194         struct supplementalCredentialsPackage *scp = NULL;
 195         struct package_PrimaryKerberosBlob _pkb;
 196         struct package_PrimaryKerberosCtr3 *pkb3 = NULL;
 197         uint32_t i;
 198         uint32_t allocated_keys = 0;
 199
 200         entry_ex->entry.keys.val = NULL;
 201         entry_ex->entry.keys.len = 0;
 202
 203         entry_ex->entry.kvno = ldb_msg_find_attr_as_int(msg, "msDS-KeyVersionNumber", 0);
 204
 205         /* Get keys from the db */
 206
 207         hash = samdb_result_hash(mem_ctx, msg, "unicodePwd");
 208         sc_val = ldb_msg_find_ldb_val(msg, "supplementalCredentials");
 209
 210         /* unicodePwd for enctype 0x17 (23) if present */
 211         if (hash) {
 212                 allocated_keys++;
 213         }
 214
 215         /* supplementalCredentials if present */
 216         if (sc_val) {
 217                 ndr_err = ndr_pull_struct_blob_all(sc_val, mem_ctx, iconv_convenience, &scb,
 218                                                    (ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob);
 219                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 220                         dump_data(0, sc_val->data, sc_val->length);
 221                         ret = EINVAL;
 222                         goto out;
 223                 }
 224
 225                 for (i=0; i < scb.sub.num_packages; i++) {
 226                         if (scb.sub.packages[i].unknown1 != 0x00000001) {
 227                                 continue;
 228                         }
 229
 230                         if (strcmp("Primary:Kerberos", scb.sub.packages[i].name) != 0) {
 231                                 continue;
 232                         }
 233
 234                         if (!scb.sub.packages[i].data || !scb.sub.packages[i].data[0]) {
 235                                 continue;
 236                         }
 237
 238                         scp = &scb.sub.packages[i];
 239                         break;
 240                 }
 241         }
 242         /* Primary:Kerberos element of supplementalCredentials */
 243         if (scp) {
 244                 DATA_BLOB blob;
 245
 246                 blob = strhex_to_data_blob(scp->data);
 247                 if (!blob.data) {
 248                         ret = ENOMEM;
 249                         goto out;
 250                 }
 251                 talloc_steal(mem_ctx, blob.data);
 252
 253                 /* TODO: use ndr_pull_struct_blob_all(), when the ndr layer handles it correct with relative pointers */
 254                 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, iconv_convenience, &_pkb,
 255                                                (ndr_pull_flags_fn_t)ndr_pull_package_PrimaryKerberosBlob);
 256                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 257                         krb5_set_error_string(context, "LDB_message2entry_keys: could not parse package_PrimaryKerberosBlob");
 258                         krb5_warnx(context, "LDB_message2entry_keys: could not parse package_PrimaryKerberosBlob");
 259                         ret = EINVAL;
 260                         goto out;
 261                 }
 262
 263                 if (_pkb.version != 3) {
 264                         krb5_set_error_string(context, "LDB_message2entry_keys: could not parse PrimaryKerberos not version 3");
 265                         krb5_warnx(context, "LDB_message2entry_keys: could not parse PrimaryKerberos not version 3");
 266                         ret = EINVAL;
 267                         goto out;
 268                 }
 269
 270                 pkb3 = &_pkb.ctr.ctr3;
 271
 272                 allocated_keys += pkb3->num_keys;
 273         }
 274
 275         if (allocated_keys == 0) {
 276                 /* oh, no password.  Apparently (comment in
 277                  * hdb-ldap.c) this violates the ASN.1, but this
 278                  * allows an entry with no keys (yet). */
 279                 return 0;
 280         }
 281
 282         /* allocate space to decode into */
 283         entry_ex->entry.keys.len = 0;
 284         entry_ex->entry.keys.val = calloc(allocated_keys, sizeof(Key));
 285         if (entry_ex->entry.keys.val == NULL) {
 286                 ret = ENOMEM;
 287                 goto out;
 288         }
 289
 290         if (hash && !(userAccountControl & UF_USE_DES_KEY_ONLY)) {
 291                 Key key;
 292
 293                 key.mkvno = 0;
 294                 key.salt = NULL; /* No salt for this enc type */
 295
 296                 ret = krb5_keyblock_init(context,
 297                                          ENCTYPE_ARCFOUR_HMAC_MD5,
 298                                          hash->hash, sizeof(hash->hash),
 299                                          &key.key);
 300                 if (ret) {
 301                         goto out;
 302                 }
 303
 304                 entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
 305                 entry_ex->entry.keys.len++;
 306         }
 307
 308         if (pkb3) {
 309                 for (i=0; i < pkb3->num_keys; i++) {
 310                         bool use = true;
 311                         Key key;
 312
 313                         if (!pkb3->keys[i].value) continue;
 314
 315                         if (userAccountControl & UF_USE_DES_KEY_ONLY) {
 316                                 switch (pkb3->keys[i].keytype) {
 317                                 case ENCTYPE_DES_CBC_CRC:
 318                                 case ENCTYPE_DES_CBC_MD5:
 319                                         break;
 320                                 default:
 321                                         use = false;
 322                                         break;
 323                                 }
 324                         }
 325
 326                         if (!use) continue;
 327
 328                         key.mkvno = 0;
 329
 330                         if (pkb3->salt.string) {
 331                                 DATA_BLOB salt;
 332
 333                                 salt = data_blob_string_const(pkb3->salt.string);
 334
 335                                 key.salt = calloc(1, sizeof(*key.salt));
 336                                 if (key.salt == NULL) {
 337                                         ret = ENOMEM;
 338                                         goto out;
 339                                 }
 340
 341                                 key.salt->type = hdb_pw_salt;
 342
 343                                 ret = krb5_data_copy(&key.salt->salt, salt.data, salt.length);
 344                                 if (ret) {
 345                                         free(key.salt);
 346                                         key.salt = NULL;
 347                                         goto out;
 348                                 }
 349                         }
 350
 351                         ret = krb5_keyblock_init(context,
 352                                                  pkb3->keys[i].keytype,
 353                                                  pkb3->keys[i].value->data,
 354                                                  pkb3->keys[i].value->length,
 355                                                  &key.key);
 356                         if (ret) {
 357                                 if (key.salt) {
 358                                         free_Salt(key.salt);
 359                                         free(key.salt);
 360                                         key.salt = NULL;
 361                                 }
 362                                 goto out;
 363                         }
 364
 365                         entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
 366                         entry_ex->entry.keys.len++;
 367                 }
 368         }
 369
 370 out:
 371         if (ret != 0) {
 372                 entry_ex->entry.keys.len = 0;
 373         }
 374         if (entry_ex->entry.keys.len == 0 && entry_ex->entry.keys.val) {
 375                 free(entry_ex->entry.keys.val);
 376                 entry_ex->entry.keys.val = NULL;
 377         }
 378         return ret;
 379 }
 380
 381 /*
 382  * Construct an hdb_entry from a directory entry.
 383  */
 384 static krb5_error_code LDB_message2entry(krb5_context context, HDB *db,
 385                                          TALLOC_CTX *mem_ctx, krb5_const_principal principal,
 386                                          enum hdb_ldb_ent_type ent_type,
 387                                          struct ldb_message *msg,
 388                                          struct ldb_message *realm_ref_msg,
 389                                          hdb_entry_ex *entry_ex)
 390 {
 391         unsigned int userAccountControl;
 392         int i;
 393         krb5_error_code ret = 0;
 394         krb5_boolean is_computer = FALSE;
 395         const char *dnsdomain = ldb_msg_find_attr_as_string(realm_ref_msg, "dnsRoot", NULL);
 396         char *realm = strupper_talloc(mem_ctx, dnsdomain);
 397         struct loadparm_context *lp_ctx = ldb_get_opaque((struct ldb_context *)db->hdb_db, "loadparm");
 398         struct ldb_dn *domain_dn = samdb_result_dn((struct ldb_context *)db->hdb_db,
 399                                                         mem_ctx,
 400                                                         realm_ref_msg,
 401                                                         "nCName",
 402                                                         ldb_dn_new(mem_ctx, (struct ldb_context *)db->hdb_db, NULL));
 403
 404         struct hdb_ldb_private *private;
 405         NTTIME acct_expiry;
 406
 407         struct ldb_message_element *objectclasses;
 408         struct ldb_val computer_val;
 409         computer_val.data = discard_const_p(uint8_t,"computer");
 410         computer_val.length = strlen((const char *)computer_val.data);
 411
 412         objectclasses = ldb_msg_find_element(msg, "objectClass");
 413
 414         if (objectclasses && ldb_msg_find_val(objectclasses, &computer_val)) {
 415                 is_computer = TRUE;
 416         }
 417
 418         memset(entry_ex, 0, sizeof(*entry_ex));
 419
 420         if (!realm) {
 421                 krb5_set_error_string(context, "talloc_strdup: out of memory");
 422                 ret = ENOMEM;
 423                 goto out;
 424         }
 425
 426         private = talloc(mem_ctx, struct hdb_ldb_private);
 427         if (!private) {
 428                 ret = ENOMEM;
 429                 goto out;
 430         }
 431
 432         private->entry_ex = entry_ex;
 433         private->iconv_convenience = lp_iconv_convenience(lp_ctx);
 434         private->netbios_name = lp_netbios_name(lp_ctx);
 435
 436         talloc_set_destructor(private, hdb_ldb_destrutor);
 437
 438         entry_ex->ctx = private;
 439         entry_ex->free_entry = hdb_ldb_free_entry;
 440
 441         userAccountControl = ldb_msg_find_attr_as_uint(msg, "userAccountControl", 0);
 442
 443
 444         entry_ex->entry.principal = malloc(sizeof(*(entry_ex->entry.principal)));
 445         if (ent_type == HDB_LDB_ENT_TYPE_ANY && principal == NULL) {
 446                 const char *samAccountName = ldb_msg_find_attr_as_string(msg, "samAccountName", NULL);
 447                 if (!samAccountName) {
 448                         krb5_set_error_string(context, "LDB_message2entry: no samAccountName present");
 449                         ret = ENOENT;
 450                         goto out;
 451                 }
 452                 samAccountName = ldb_msg_find_attr_as_string(msg, "samAccountName", NULL);
 453                 krb5_make_principal(context, &entry_ex->entry.principal, realm, samAccountName, NULL);
 454         } else {
 455                 char *strdup_realm;
 456                 ret = copy_Principal(principal, entry_ex->entry.principal);
 457                 if (ret) {
 458                         krb5_clear_error_string(context);
 459                         goto out;
 460                 }
 461
 462                 /* While we have copied the client principal, tests
 463                  * show that Win2k3 returns the 'corrected' realm, not
 464                  * the client-specified realm.  This code attempts to
 465                  * replace the client principal's realm with the one
 466                  * we determine from our records */
 467
 468                 /* this has to be with malloc() */
 469                 strdup_realm = strdup(realm);
 470                 if (!strdup_realm) {
 471                         ret = ENOMEM;
 472                         krb5_clear_error_string(context);
 473                         goto out;
 474                 }
 475                 free(*krb5_princ_realm(context, entry_ex->entry.principal));
 476                 krb5_princ_set_realm(context, entry_ex->entry.principal, &strdup_realm);
 477         }
 478
 479         entry_ex->entry.flags = uf2HDBFlags(context, userAccountControl, ent_type);
 480
 481         if (ent_type == HDB_LDB_ENT_TYPE_KRBTGT) {
 482                 entry_ex->entry.flags.invalid = 0;
 483                 entry_ex->entry.flags.server = 1;
 484                 entry_ex->entry.flags.forwardable = 1;
 485                 entry_ex->entry.flags.ok_as_delegate = 1;
 486         }
 487
 488         if (lp_parm_bool(lp_ctx, NULL, "kdc", "require spn for service", true)) {
 489                 if (!is_computer && !ldb_msg_find_attr_as_string(msg, "servicePrincipalName", NULL)) {
 490                         entry_ex->entry.flags.server = 0;
 491                 }
 492         }
 493
 494         /* use 'whenCreated' */
 495         entry_ex->entry.created_by.time = ldb_msg_find_krb5time_ldap_time(msg, "whenCreated", 0);
 496         /* use '???' */
 497         entry_ex->entry.created_by.principal = NULL;
 498
 499         entry_ex->entry.modified_by = (Event *) malloc(sizeof(Event));
 500         if (entry_ex->entry.modified_by == NULL) {
 501                 krb5_set_error_string(context, "malloc: out of memory");
 502                 ret = ENOMEM;
 503                 goto out;
 504         }
 505
 506         /* use 'whenChanged' */
 507         entry_ex->entry.modified_by->time = ldb_msg_find_krb5time_ldap_time(msg, "whenChanged", 0);
 508         /* use '???' */
 509         entry_ex->entry.modified_by->principal = NULL;
 510
 511         entry_ex->entry.valid_start = NULL;
 512
 513         acct_expiry = samdb_result_account_expires(msg);
 514         if (acct_expiry == 0x7FFFFFFFFFFFFFFFULL) {
 515                 entry_ex->entry.valid_end = NULL;
 516         } else {
 517                 entry_ex->entry.valid_end = malloc(sizeof(*entry_ex->entry.valid_end));
 518                 if (entry_ex->entry.valid_end == NULL) {
 519                         ret = ENOMEM;
 520                         goto out;
 521                 }
 522                 *entry_ex->entry.valid_end = nt_time_to_unix(acct_expiry);
 523         }
 524
 525         if (ent_type != HDB_LDB_ENT_TYPE_KRBTGT) {
 526                 NTTIME must_change_time
 527                         = samdb_result_force_password_change((struct ldb_context *)db->hdb_db, mem_ctx,
 528                                                              domain_dn, msg);
 529                 if (must_change_time == 0x7FFFFFFFFFFFFFFFULL) {
 530                         entry_ex->entry.pw_end = NULL;
 531                 } else {
 532                         entry_ex->entry.pw_end = malloc(sizeof(*entry_ex->entry.pw_end));
 533                         if (entry_ex->entry.pw_end == NULL) {
 534                                 ret = ENOMEM;
 535                                 goto out;
 536                         }
 537                         *entry_ex->entry.pw_end = nt_time_to_unix(must_change_time);
 538                 }
 539         } else {
 540                 entry_ex->entry.pw_end = NULL;
 541         }
 542
 543         entry_ex->entry.max_life = NULL;
 544
 545         entry_ex->entry.max_renew = NULL;
 546
 547         entry_ex->entry.generation = NULL;
 548
 549         /* Get keys from the db */
 550         ret = LDB_message2entry_keys(context, private->iconv_convenience, private, msg, userAccountControl, entry_ex);
 551         if (ret) {
 552                 /* Could be bougus data in the entry, or out of memory */
 553                 goto out;
 554         }
 555
 556         entry_ex->entry.etypes = malloc(sizeof(*(entry_ex->entry.etypes)));
 557         if (entry_ex->entry.etypes == NULL) {
 558                 krb5_clear_error_string(context);
 559                 ret = ENOMEM;
 560                 goto out;
 561         }
 562         entry_ex->entry.etypes->len = entry_ex->entry.keys.len;
 563         entry_ex->entry.etypes->val = calloc(entry_ex->entry.etypes->len, sizeof(int));
 564         if (entry_ex->entry.etypes->val == NULL) {
 565                 krb5_clear_error_string(context);
 566                 ret = ENOMEM;
 567                 goto out;
 568         }
 569         for (i=0; i < entry_ex->entry.etypes->len; i++) {
 570                 entry_ex->entry.etypes->val[i] = entry_ex->entry.keys.val[i].key.keytype;
 571         }
 572
 573
 574         private->msg = talloc_steal(private, msg);
 575         private->realm_ref_msg = talloc_steal(private, realm_ref_msg);
 576         private->samdb = (struct ldb_context *)db->hdb_db;
 577
 578 out:
 579         if (ret != 0) {
 580                 /* This doesn't free ent itself, that is for the eventual caller to do */
 581                 hdb_free_entry(context, entry_ex);
 582         } else {
 583                 talloc_steal(db, entry_ex->ctx);
 584         }
 585
 586         return ret;
 587 }
 588
 589 static krb5_error_code LDB_lookup_principal(krb5_context context, struct ldb_context *ldb_ctx,
 590                                             TALLOC_CTX *mem_ctx,
 591                                             krb5_const_principal principal,
 592                                             enum hdb_ldb_ent_type ent_type,
 593                                             struct ldb_dn *realm_dn,
 594                                             struct ldb_message ***pmsg)
 595 {
 596         krb5_error_code ret;
 597         int lret;
 598         char *filter = NULL;
 599         const char * const *princ_attrs = user_attrs;
 600
 601         char *short_princ;
 602         char *short_princ_talloc;
 603
 604         struct ldb_result *res = NULL;
 605
 606         ret = krb5_unparse_name_flags(context, principal,  KRB5_PRINCIPAL_UNPARSE_NO_REALM, &short_princ);
 607
 608         if (ret != 0) {
 609                 krb5_set_error_string(context, "LDB_lookup_principal: could not parse principal");
 610                 krb5_warnx(context, "LDB_lookup_principal: could not parse principal");
 611                 return ret;
 612         }
 613
 614         short_princ_talloc = talloc_strdup(mem_ctx, short_princ);
 615         free(short_princ);
 616         if (!short_princ_talloc) {
 617                 krb5_set_error_string(context, "LDB_lookup_principal: talloc_strdup() failed!");
 618                 return ENOMEM;
 619         }
 620
 621         switch (ent_type) {
 622         case HDB_LDB_ENT_TYPE_CLIENT:
 623                 /* Can't happen */
 624                 return EINVAL;
 625         case HDB_LDB_ENT_TYPE_ANY:
 626                 /* Can't happen */
 627                 return EINVAL;
 628         case HDB_LDB_ENT_TYPE_KRBTGT:
 629                 filter = talloc_asprintf(mem_ctx, "(&(objectClass=user)(samAccountName=%s))",
 630                                          KRB5_TGS_NAME);
 631                 break;
 632         case HDB_LDB_ENT_TYPE_SERVER:
 633                 filter = talloc_asprintf(mem_ctx, "(&(objectClass=user)(samAccountName=%s))",
 634                                          short_princ_talloc);
 635                 break;
 636         }
 637
 638         if (!filter) {
 639                 krb5_set_error_string(context, "talloc_asprintf: out of memory");
 640                 return ENOMEM;
 641         }
 642
 643         lret = ldb_search(ldb_ctx, realm_dn, LDB_SCOPE_SUBTREE, filter, princ_attrs, &res);
 644
 645         if (lret != LDB_SUCCESS) {
 646                 DEBUG(3, ("Failed to search for %s: %s\n", filter, ldb_errstring(ldb_ctx)));
 647                 return HDB_ERR_NOENTRY;
 648         } else if (res->count == 0 || res->count > 1) {
 649                 DEBUG(3, ("Failed find a single entry for %s: got %d\n", filter, res->count));
 650                 talloc_free(res);
 651                 return HDB_ERR_NOENTRY;
 652         }
 653         talloc_steal(mem_ctx, res->msgs);
 654         *pmsg = res->msgs;
 655         talloc_free(res);
 656         return 0;
 657 }
 658
 659 static krb5_error_code LDB_lookup_realm(krb5_context context, struct ldb_context *ldb_ctx,
 660                                         TALLOC_CTX *mem_ctx,
 661                                         const char *realm,
 662                                         struct ldb_message ***pmsg)
 663 {
 664         int ret;
 665         struct ldb_result *cross_ref_res;
 666         struct ldb_dn *partitions_basedn = samdb_partitions_dn(ldb_ctx, mem_ctx);
 667
 668         ret = ldb_search_exp_fmt(ldb_ctx, mem_ctx, &cross_ref_res,
 669                         partitions_basedn, LDB_SCOPE_SUBTREE, realm_ref_attrs,
 670                         "(&(&(|(&(dnsRoot=%s)(nETBIOSName=*))(nETBIOSName=%s))(objectclass=crossRef))(ncName=*))",
 671                         realm, realm);
 672
 673         if (ret != LDB_SUCCESS) {
 674                 DEBUG(3, ("Failed to search to lookup realm(%s): %s\n", realm, ldb_errstring(ldb_ctx)));
 675                 talloc_free(cross_ref_res);
 676                 return HDB_ERR_NOENTRY;
 677         } else if (cross_ref_res->count == 0 || cross_ref_res->count > 1) {
 678                 DEBUG(3, ("Failed find a single entry for realm %s: got %d\n", realm, cross_ref_res->count));
 679                 talloc_free(cross_ref_res);
 680                 return HDB_ERR_NOENTRY;
 681         }
 682
 683         if (pmsg) {
 684                 *pmsg = cross_ref_res->msgs;
 685                 talloc_steal(mem_ctx, cross_ref_res->msgs);
 686         }
 687         talloc_free(cross_ref_res);
 688
 689         return 0;
 690 }
 691
 692
 693 static krb5_error_code LDB_open(krb5_context context, HDB *db, int flags, mode_t mode)
 694 {
 695         if (db->hdb_master_key_set) {
 696                 krb5_warnx(context, "LDB_open: use of a master key incompatible with LDB\n");
 697                 krb5_set_error_string(context, "LDB_open: use of a master key incompatible with LDB\n");
 698                 return HDB_ERR_NOENTRY;
 699         }
 700
 701         return 0;
 702 }
 703
 704 static krb5_error_code LDB_close(krb5_context context, HDB *db)
 705 {
 706         return 0;
 707 }
 708
 709 static krb5_error_code LDB_lock(krb5_context context, HDB *db, int operation)
 710 {
 711         return 0;
 712 }
 713
 714 static krb5_error_code LDB_unlock(krb5_context context, HDB *db)
 715 {
 716         return 0;
 717 }
 718
 719 static krb5_error_code LDB_rename(krb5_context context, HDB *db, const char *new_name)
 720 {
 721         return HDB_ERR_DB_INUSE;
 722 }
 723
 724 static krb5_error_code LDB_fetch_client(krb5_context context, HDB *db,
 725                                         TALLOC_CTX *mem_ctx,
 726                                         krb5_const_principal principal,
 727                                         unsigned flags,
 728                                         hdb_entry_ex *entry_ex) {
 729         NTSTATUS nt_status;
 730         char *principal_string;
 731         krb5_error_code ret;
 732         struct ldb_message **msg = NULL;
 733         struct ldb_message **realm_ref_msg = NULL;
 734
 735         ret = krb5_unparse_name(context, principal, &principal_string);
 736
 737         if (ret != 0) {
 738                 return ret;
 739         }
 740
 741         nt_status = sam_get_results_principal((struct ldb_context *)db->hdb_db,
 742                                               mem_ctx, principal_string,
 743                                               &msg, &realm_ref_msg);
 744         free(principal_string);
 745         if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_SUCH_USER)) {
 746                 return HDB_ERR_NOENTRY;
 747         } else if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_MEMORY)) {
 748                 return ENOMEM;
 749         } else if (!NT_STATUS_IS_OK(nt_status)) {
 750                 return EINVAL;
 751         }
 752
 753         ret = LDB_message2entry(context, db, mem_ctx,
 754                                 principal, HDB_LDB_ENT_TYPE_CLIENT,
 755                                 msg[0], realm_ref_msg[0], entry_ex);
 756         return ret;
 757 }
 758
 759 static krb5_error_code LDB_fetch_krbtgt(krb5_context context, HDB *db,
 760                                         TALLOC_CTX *mem_ctx,
 761                                         krb5_const_principal principal,
 762                                         unsigned flags,
 763                                         hdb_entry_ex *entry_ex)
 764 {
 765         krb5_error_code ret;
 766         struct ldb_message **msg = NULL;
 767         struct ldb_message **realm_ref_msg = NULL;
 768         struct ldb_dn *realm_dn;
 769
 770         krb5_principal alloc_principal = NULL;
 771         if (principal->name.name_string.len != 2
 772             || (strcmp(principal->name.name_string.val[0], KRB5_TGS_NAME) != 0)) {
 773                 /* Not a krbtgt */
 774                 return HDB_ERR_NOENTRY;
 775         }
 776
 777         /* krbtgt case.  Either us or a trusted realm */
 778         if ((LDB_lookup_realm(context, (struct ldb_context *)db->hdb_db,
 779                               mem_ctx, principal->name.name_string.val[1], &realm_ref_msg) == 0)) {
 780                 /* us */
 781                 /* Cludge, cludge cludge.  If the realm part of krbtgt/realm,
 782                  * is in our db, then direct the caller at our primary
 783                  * krgtgt */
 784
 785                 const char *dnsdomain = ldb_msg_find_attr_as_string(realm_ref_msg[0], "dnsRoot", NULL);
 786                 char *realm_fixed = strupper_talloc(mem_ctx, dnsdomain);
 787                 if (!realm_fixed) {
 788                         krb5_set_error_string(context, "strupper_talloc: out of memory");
 789                         return ENOMEM;
 790                 }
 791
 792                 ret = krb5_copy_principal(context, principal, &alloc_principal);
 793                 if (ret) {
 794                         return ret;
 795                 }
 796
 797                 free(alloc_principal->name.name_string.val[1]);
 798                 alloc_principal->name.name_string.val[1] = strdup(realm_fixed);
 799                 talloc_free(realm_fixed);
 800                 if (!alloc_principal->name.name_string.val[1]) {
 801                         krb5_set_error_string(context, "LDB_fetch: strdup() failed!");
 802                         return ENOMEM;
 803                 }
 804                 principal = alloc_principal;
 805                 realm_dn = samdb_result_dn((struct ldb_context *)db->hdb_db, mem_ctx, realm_ref_msg[0], "nCName", NULL);
 806         } else {
 807                 /* we should lookup trusted domains */
 808                 return HDB_ERR_NOENTRY;
 809         }
 810
 811         realm_dn = samdb_result_dn((struct ldb_context *)db->hdb_db, mem_ctx, realm_ref_msg[0], "nCName", NULL);
 812
 813         ret = LDB_lookup_principal(context, (struct ldb_context *)db->hdb_db,
 814                                    mem_ctx,
 815                                    principal, HDB_LDB_ENT_TYPE_KRBTGT, realm_dn, &msg);
 816
 817         if (ret != 0) {
 818                 krb5_warnx(context, "LDB_fetch: could not find principal in DB");
 819                 krb5_set_error_string(context, "LDB_fetch: could not find principal in DB");
 820                 return ret;
 821         }
 822
 823         ret = LDB_message2entry(context, db, mem_ctx,
 824                                 principal, HDB_LDB_ENT_TYPE_KRBTGT,
 825                                 msg[0], realm_ref_msg[0], entry_ex);
 826         if (ret != 0) {
 827                 krb5_warnx(context, "LDB_fetch: message2entry failed");
 828         }
 829         return ret;
 830 }
 831
 832 static krb5_error_code LDB_fetch_server(krb5_context context, HDB *db,
 833                                         TALLOC_CTX *mem_ctx,
 834                                         krb5_const_principal principal,
 835                                         unsigned flags,
 836                                         hdb_entry_ex *entry_ex)
 837 {
 838         krb5_error_code ret;
 839         const char *realm;
 840         struct ldb_message **msg = NULL;
 841         struct ldb_message **realm_ref_msg = NULL;
 842         struct ldb_dn *partitions_basedn = samdb_partitions_dn(db->hdb_db, mem_ctx);
 843         if (principal->name.name_string.len >= 2) {
 844                 /* 'normal server' case */
 845                 int ldb_ret;
 846                 NTSTATUS nt_status;
 847                 struct ldb_dn *user_dn, *domain_dn;
 848                 char *principal_string;
 849
 850                 ret = krb5_unparse_name_flags(context, principal,
 851                                               KRB5_PRINCIPAL_UNPARSE_NO_REALM,
 852                                               &principal_string);
 853                 if (ret != 0) {
 854                         return ret;
 855                 }
 856
 857                 /* At this point we may find the host is known to be
 858                  * in a different realm, so we should generate a
 859                  * referral instead */
 860                 nt_status = crack_service_principal_name((struct ldb_context *)db->hdb_db,
 861                                                          mem_ctx, principal_string,
 862                                                          &user_dn, &domain_dn);
 863                 free(principal_string);
 864
 865                 if (!NT_STATUS_IS_OK(nt_status)) {
 866                         return HDB_ERR_NOENTRY;
 867                 }
 868
 869                 ldb_ret = gendb_search_dn((struct ldb_context *)db->hdb_db,
 870                                           mem_ctx, user_dn, &msg, user_attrs);
 871
 872                 if (ldb_ret != 1) {
 873                         return HDB_ERR_NOENTRY;
 874                 }
 875
 876                 ldb_ret = gendb_search((struct ldb_context *)db->hdb_db,
 877                                        mem_ctx, partitions_basedn, &realm_ref_msg, realm_ref_attrs,
 878                                        "ncName=%s", ldb_dn_get_linearized(domain_dn));
 879
 880                 if (ldb_ret != 1) {
 881                         return HDB_ERR_NOENTRY;
 882                 }
 883
 884         } else {
 885                 struct ldb_dn *realm_dn;
 886                 /* server as client principal case, but we must not lookup userPrincipalNames */
 887
 888                 realm = krb5_principal_get_realm(context, principal);
 889
 890                 ret = LDB_lookup_realm(context, (struct ldb_context *)db->hdb_db,
 891                                        mem_ctx, realm, &realm_ref_msg);
 892                 if (ret != 0) {
 893                         return HDB_ERR_NOENTRY;
 894                 }
 895
 896                 realm_dn = samdb_result_dn((struct ldb_context *)db->hdb_db, mem_ctx, realm_ref_msg[0], "nCName", NULL);
 897
 898                 ret = LDB_lookup_principal(context, (struct ldb_context *)db->hdb_db,
 899                                            mem_ctx,
 900                                            principal, HDB_LDB_ENT_TYPE_SERVER, realm_dn, &msg);
 901
 902                 if (ret != 0) {
 903                         return ret;
 904                 }
 905         }
 906
 907         ret = LDB_message2entry(context, db, mem_ctx,
 908                                 principal, HDB_LDB_ENT_TYPE_SERVER,
 909                                 msg[0], realm_ref_msg[0], entry_ex);
 910         if (ret != 0) {
 911                 krb5_warnx(context, "LDB_fetch: message2entry failed");
 912         }
 913
 914         return ret;
 915 }
 916
 917 static krb5_error_code LDB_fetch(krb5_context context, HDB *db,
 918                                  krb5_const_principal principal,
 919                                  unsigned flags,
 920                                  hdb_entry_ex *entry_ex)
 921 {
 922         krb5_error_code ret = HDB_ERR_NOENTRY;
 923
 924         TALLOC_CTX *mem_ctx = talloc_named(db, 0, "LDB_fetch context");
 925
 926         if (!mem_ctx) {
 927                 krb5_set_error_string(context, "LDB_fetch: talloc_named() failed!");
 928                 return ENOMEM;
 929         }
 930
 931         if (flags & HDB_F_GET_CLIENT) {
 932                 ret = LDB_fetch_client(context, db, mem_ctx, principal, flags, entry_ex);
 933                 if (ret != HDB_ERR_NOENTRY) goto done;
 934         }
 935         if (flags & HDB_F_GET_SERVER) {
 936                 ret = LDB_fetch_server(context, db, mem_ctx, principal, flags, entry_ex);
 937                 if (ret != HDB_ERR_NOENTRY) goto done;
 938                 ret = LDB_fetch_krbtgt(context, db, mem_ctx, principal, flags, entry_ex);
 939                 if (ret != HDB_ERR_NOENTRY) goto done;
 940         }
 941         if (flags & HDB_F_GET_KRBTGT) {
 942                 ret = LDB_fetch_krbtgt(context, db, mem_ctx, principal, flags, entry_ex);
 943                 if (ret != HDB_ERR_NOENTRY) goto done;
 944         }
 945
 946 done:
 947         talloc_free(mem_ctx);
 948         return ret;
 949 }
 950
 951 static krb5_error_code LDB_store(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
 952 {
 953         return HDB_ERR_DB_INUSE;
 954 }
 955
 956 static krb5_error_code LDB_remove(krb5_context context, HDB *db, krb5_const_principal principal)
 957 {
 958         return HDB_ERR_DB_INUSE;
 959 }
 960
 961 struct hdb_ldb_seq {
 962         struct ldb_context *ctx;
 963         int index;
 964         int count;
 965         struct ldb_message **msgs;
 966         struct ldb_message **realm_ref_msgs;
 967 };
 968
 969 static krb5_error_code LDB_seq(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
 970 {
 971         krb5_error_code ret;
 972         struct hdb_ldb_seq *priv = (struct hdb_ldb_seq *)db->hdb_dbc;
 973         TALLOC_CTX *mem_ctx;
 974         hdb_entry_ex entry_ex;
 975         memset(&entry_ex, '\0', sizeof(entry_ex));
 976
 977         if (!priv) {
 978                 return HDB_ERR_NOENTRY;
 979         }
 980
 981         mem_ctx = talloc_named(priv, 0, "LDB_seq context");
 982
 983         if (!mem_ctx) {
 984                 krb5_set_error_string(context, "LDB_seq: talloc_named() failed!");
 985                 return ENOMEM;
 986         }
 987
 988         if (priv->index < priv->count) {
 989                 ret = LDB_message2entry(context, db, mem_ctx,
 990                                         NULL, HDB_LDB_ENT_TYPE_ANY,
 991                                         priv->msgs[priv->index++],
 992                                         priv->realm_ref_msgs[0], entry);
 993         } else {
 994                 ret = HDB_ERR_NOENTRY;
 995         }
 996
 997         if (ret != 0) {
 998                 talloc_free(priv);
 999                 db->hdb_dbc = NULL;
1000         } else {
1001                 talloc_free(mem_ctx);
1002         }
1003
1004         return ret;
1005 }
1006
1007 static krb5_error_code LDB_firstkey(krb5_context context, HDB *db, unsigned flags,
1008                                         hdb_entry_ex *entry)
1009 {
1010         struct ldb_context *ldb_ctx = (struct ldb_context *)db->hdb_db;
1011         struct hdb_ldb_seq *priv = (struct hdb_ldb_seq *)db->hdb_dbc;
1012         char *realm;
1013         struct ldb_dn *realm_dn = NULL;
1014         struct ldb_result *res = NULL;
1015         struct ldb_message **realm_ref_msgs = NULL;
1016         krb5_error_code ret;
1017         TALLOC_CTX *mem_ctx;
1018         int lret;
1019
1020         if (priv) {
1021                 talloc_free(priv);
1022                 db->hdb_dbc = NULL;
1023         }
1024
1025         priv = (struct hdb_ldb_seq *) talloc(db, struct hdb_ldb_seq);
1026         if (!priv) {
1027                 krb5_set_error_string(context, "talloc: out of memory");
1028                 return ENOMEM;
1029         }
1030
1031         priv->ctx = ldb_ctx;
1032         priv->index = 0;
1033         priv->msgs = NULL;
1034         priv->realm_ref_msgs = NULL;
1035         priv->count = 0;
1036
1037         mem_ctx = talloc_named(priv, 0, "LDB_firstkey context");
1038
1039         if (!mem_ctx) {
1040                 krb5_set_error_string(context, "LDB_firstkey: talloc_named() failed!");
1041                 return ENOMEM;
1042         }
1043
1044         ret = krb5_get_default_realm(context, &realm);
1045         if (ret != 0) {
1046                 talloc_free(priv);
1047                 return ret;
1048         }
1049
1050         ret = LDB_lookup_realm(context, (struct ldb_context *)db->hdb_db,
1051                                mem_ctx, realm, &realm_ref_msgs);
1052
1053         free(realm);
1054
1055         if (ret != 0) {
1056                 talloc_free(priv);
1057                 krb5_warnx(context, "LDB_firstkey: could not find realm\n");
1058                 return HDB_ERR_NOENTRY;
1059         }
1060
1061         realm_dn = samdb_result_dn((struct ldb_context *)db->hdb_db, mem_ctx, realm_ref_msgs[0], "nCName", NULL);
1062
1063         priv->realm_ref_msgs = talloc_steal(priv, realm_ref_msgs);
1064
1065         lret = ldb_search(ldb_ctx, realm_dn,
1066                                  LDB_SCOPE_SUBTREE, "(objectClass=user)",
1067                                  user_attrs, &res);
1068
1069         if (lret != LDB_SUCCESS) {
1070                 talloc_free(priv);
1071                 return HDB_ERR_NOENTRY;
1072         }
1073
1074         priv->count = res->count;
1075         priv->msgs = talloc_steal(priv, res->msgs);
1076         talloc_free(res);
1077
1078         db->hdb_dbc = priv;
1079
1080         ret = LDB_seq(context, db, flags, entry);
1081
1082         if (ret != 0) {
1083                 talloc_free(priv);
1084                 db->hdb_dbc = NULL;
1085         } else {
1086                 talloc_free(mem_ctx);
1087         }
1088         return ret;
1089 }
1090
1091 static krb5_error_code LDB_nextkey(krb5_context context, HDB *db, unsigned flags,
1092                                    hdb_entry_ex *entry)
1093 {
1094         return LDB_seq(context, db, flags, entry);
1095 }
1096
1097 static krb5_error_code LDB_destroy(krb5_context context, HDB *db)
1098 {
1099         talloc_free(db);
1100         return 0;
1101 }
1102
1103 /* This interface is to be called by the KDC, which is expecting Samba
1104  * calling conventions.  It is also called by a wrapper
1105  * (hdb_ldb_create) from the kpasswdd -> krb5 -> keytab_hdb -> hdb
1106  * code */
1107
1108 NTSTATUS kdc_hdb_ldb_create(TALLOC_CTX *mem_ctx,
1109                             struct loadparm_context *lp_ctx,
1110                             krb5_context context, struct HDB **db, const char *arg)
1111 {
1112         NTSTATUS nt_status;
1113         struct auth_session_info *session_info;
1114         *db = talloc(mem_ctx, HDB);
1115         if (!*db) {
1116                 krb5_set_error_string(context, "malloc: out of memory");
1117                 return NT_STATUS_NO_MEMORY;
1118         }
1119
1120         (*db)->hdb_master_key_set = 0;
1121         (*db)->hdb_db = NULL;
1122
1123         nt_status = auth_system_session_info(*db, lp_ctx, &session_info);
1124         if (!NT_STATUS_IS_OK(nt_status)) {
1125                 return nt_status;
1126         }
1127
1128         /* The idea here is very simple.  Using Kerberos to
1129          * authenticate the KDC to the LDAP server is higly likely to
1130          * be circular.
1131          *
1132          * In future we may set this up to use EXERNAL and SSL
1133          * certificates, for now it will almost certainly be NTLMSSP
1134         */
1135
1136         cli_credentials_set_kerberos_state(session_info->credentials,
1137                                            CRED_DONT_USE_KERBEROS);
1138
1139         /* Setup the link to LDB */
1140         (*db)->hdb_db = samdb_connect(*db, lp_ctx, session_info);
1141         if ((*db)->hdb_db == NULL) {
1142                 DEBUG(1, ("hdb_ldb_create: Cannot open samdb for KDC backend!"));
1143                 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
1144         }
1145
1146         (*db)->hdb_dbc = NULL;
1147         (*db)->hdb_open = LDB_open;
1148         (*db)->hdb_close = LDB_close;
1149         (*db)->hdb_fetch = LDB_fetch;
1150         (*db)->hdb_store = LDB_store;
1151         (*db)->hdb_remove = LDB_remove;
1152         (*db)->hdb_firstkey = LDB_firstkey;
1153         (*db)->hdb_nextkey = LDB_nextkey;
1154         (*db)->hdb_lock = LDB_lock;
1155         (*db)->hdb_unlock = LDB_unlock;
1156         (*db)->hdb_rename = LDB_rename;
1157         /* we don't implement these, as we are not a lockable database */
1158         (*db)->hdb__get = NULL;
1159         (*db)->hdb__put = NULL;
1160         /* kadmin should not be used for deletes - use other tools instead */
1161         (*db)->hdb__del = NULL;
1162         (*db)->hdb_destroy = LDB_destroy;
1163
1164         return NT_STATUS_OK;
1165 }
1166
1167 krb5_error_code hdb_ldb_create(krb5_context context, struct HDB **db, const char *arg)
1168 {
1169         NTSTATUS nt_status;
1170         /* The global kdc_mem_ctx and kdc_lp_ctx, Disgusting, ugly hack, but it means one less private hook */
1171         nt_status = kdc_hdb_ldb_create(kdc_mem_ctx, kdc_lp_ctx,
1172                                        context, db, arg);
1173
1174         if (NT_STATUS_IS_OK(nt_status)) {
1175                 return 0;
1176         }
1177         return EINVAL;
1178 }