?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:kdc Use a clearer name for the samba kdc entry
[Samba/fernandojvsilva.git] / source4 / kdc / hdb-samba4.c
blob856c330d8065cafc41f813230728aeace1a63f1e
1 /*
2 * Copyright (c) 1999-2001, 2003, PADL Software Pty Ltd.
3 * Copyright (c) 2004-2009, 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 "../libds/common/flags.h"
38 #include "lib/ldb/include/ldb.h"
39 #include "lib/ldb/include/ldb_errors.h"
40 #include "librpc/gen_ndr/netlogon.h"
41 #include "libcli/security/security.h"
42 #include "auth/auth.h"
43 #include "auth/credentials/credentials.h"
44 #include "auth/auth_sam.h"
45 #include "../lib/util/util_ldb.h"
46 #include "dsdb/samdb/samdb.h"
47 #include "librpc/ndr/libndr.h"
48 #include "librpc/gen_ndr/ndr_drsblobs.h"
49 #include "librpc/gen_ndr/lsa.h"
50 #include "libcli/auth/libcli_auth.h"
51 #include "param/param.h"
52 #include "events/events.h"
53 #include "kdc/kdc.h"
54 #include "../lib/crypto/md4.h"
55
56 enum hdb_samba4_ent_type
57 { HDB_SAMBA4_ENT_TYPE_CLIENT, HDB_SAMBA4_ENT_TYPE_SERVER,
58 HDB_SAMBA4_ENT_TYPE_KRBTGT, HDB_SAMBA4_ENT_TYPE_TRUST, HDB_SAMBA4_ENT_TYPE_ANY };
59
60 enum trust_direction {
61 UNKNOWN = 0,
62 INBOUND = LSA_TRUST_DIRECTION_INBOUND,
63 OUTBOUND = LSA_TRUST_DIRECTION_OUTBOUND
64 };
65
66 static const char *trust_attrs[] = {
67 "trustPartner",
68 "trustAuthIncoming",
69 "trustAuthOutgoing",
70 "whenCreated",
71 "msDS-SupportedEncryptionTypes",
72 "trustAttributes",
73 "trustDirection",
74 "trustType",
75 NULL
76 };
77
78 static KerberosTime ldb_msg_find_krb5time_ldap_time(struct ldb_message *msg, const char *attr, KerberosTime default_val)
79 {
80 const char *tmp;
81 const char *gentime;
82 struct tm tm;
83
84 gentime = ldb_msg_find_attr_as_string(msg, attr, NULL);
85 if (!gentime)
86 return default_val;
87
88 tmp = strptime(gentime, "%Y%m%d%H%M%SZ", &tm);
89 if (tmp == NULL) {
90 return default_val;
91 }
92
93 return timegm(&tm);
94 }
95
96 static HDBFlags uf2HDBFlags(krb5_context context, int userAccountControl, enum hdb_samba4_ent_type ent_type)
97 {
98 HDBFlags flags = int2HDBFlags(0);
99
100 /* we don't allow kadmin deletes */
101 flags.immutable = 1;
102
103 /* mark the principal as invalid to start with */
104 flags.invalid = 1;
105
106 flags.renewable = 1;
107
108 /* All accounts are servers, but this may be disabled again in the caller */
109 flags.server = 1;
110
111 /* Account types - clear the invalid bit if it turns out to be valid */
112 if (userAccountControl & UF_NORMAL_ACCOUNT) {
113 if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
114 flags.client = 1;
115 }
116 flags.invalid = 0;
117 }
118
119 if (userAccountControl & UF_INTERDOMAIN_TRUST_ACCOUNT) {
120 if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
121 flags.client = 1;
122 }
123 flags.invalid = 0;
124 }
125 if (userAccountControl & UF_WORKSTATION_TRUST_ACCOUNT) {
126 if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
127 flags.client = 1;
128 }
129 flags.invalid = 0;
130 }
131 if (userAccountControl & UF_SERVER_TRUST_ACCOUNT) {
132 if (ent_type == HDB_SAMBA4_ENT_TYPE_CLIENT || ent_type == HDB_SAMBA4_ENT_TYPE_ANY) {
133 flags.client = 1;
134 }
135 flags.invalid = 0;
136 }
137
138 /* Not permitted to act as a client if disabled */
139 if (userAccountControl & UF_ACCOUNTDISABLE) {
140 flags.client = 0;
141 }
142 if (userAccountControl & UF_LOCKOUT) {
143 flags.invalid = 1;
144 }
145 /*
146 if (userAccountControl & UF_PASSWORD_NOTREQD) {
147 flags.invalid = 1;
148 }
149 */
150 /*
151 UF_PASSWORD_CANT_CHANGE and UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED are irrelevent
152 */
153 if (userAccountControl & UF_TEMP_DUPLICATE_ACCOUNT) {
154 flags.invalid = 1;
155 }
156
157 /* UF_DONT_EXPIRE_PASSWD and UF_USE_DES_KEY_ONLY handled in hdb_samba4_message2entry() */
158
159 /*
160 if (userAccountControl & UF_MNS_LOGON_ACCOUNT) {
161 flags.invalid = 1;
162 }
163 */
164 if (userAccountControl & UF_SMARTCARD_REQUIRED) {
165 flags.require_hwauth = 1;
166 }
167 if (userAccountControl & UF_TRUSTED_FOR_DELEGATION) {
168 flags.ok_as_delegate = 1;
169 }
170 if (!(userAccountControl & UF_NOT_DELEGATED)) {
171 flags.forwardable = 1;
172 flags.proxiable = 1;
173 }
174
175 if (userAccountControl & UF_DONT_REQUIRE_PREAUTH) {
176 flags.require_preauth = 0;
177 } else {
178 flags.require_preauth = 1;
179
180 }
181 return flags;
182 }
183
184 static int samba_kdc_entry_destructor(struct samba_kdc_entry *p)
185 {
186 hdb_entry_ex *entry_ex = p->entry_ex;
187 free_hdb_entry(&entry_ex->entry);
188 return 0;
189 }
190
191 static void hdb_samba4_free_entry(krb5_context context, hdb_entry_ex *entry_ex)
192 {
193 talloc_free(entry_ex->ctx);
194 }
195
196 static krb5_error_code hdb_samba4_message2entry_keys(krb5_context context,
197 struct smb_iconv_convenience *iconv_convenience,
198 TALLOC_CTX *mem_ctx,
199 struct ldb_message *msg,
200 unsigned int userAccountControl,
201 hdb_entry_ex *entry_ex)
202 {
203 krb5_error_code ret = 0;
204 enum ndr_err_code ndr_err;
205 struct samr_Password *hash;
206 const struct ldb_val *sc_val;
207 struct supplementalCredentialsBlob scb;
208 struct supplementalCredentialsPackage *scpk = NULL;
209 bool newer_keys = false;
210 struct package_PrimaryKerberosBlob _pkb;
211 struct package_PrimaryKerberosCtr3 *pkb3 = NULL;
212 struct package_PrimaryKerberosCtr4 *pkb4 = NULL;
213 uint32_t i;
214 uint32_t allocated_keys = 0;
215
216 entry_ex->entry.keys.val = NULL;
217 entry_ex->entry.keys.len = 0;
218
219 entry_ex->entry.kvno = ldb_msg_find_attr_as_int(msg, "msDS-KeyVersionNumber", 0);
220
221 /* Get keys from the db */
222
223 hash = samdb_result_hash(mem_ctx, msg, "unicodePwd");
224 sc_val = ldb_msg_find_ldb_val(msg, "supplementalCredentials");
225
226 /* unicodePwd for enctype 0x17 (23) if present */
227 if (hash) {
228 allocated_keys++;
229 }
230
231 /* supplementalCredentials if present */
232 if (sc_val) {
233 ndr_err = ndr_pull_struct_blob_all(sc_val, mem_ctx, iconv_convenience, &scb,
234 (ndr_pull_flags_fn_t)ndr_pull_supplementalCredentialsBlob);
235 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
236 dump_data(0, sc_val->data, sc_val->length);
237 ret = EINVAL;
238 goto out;
239 }
240
241 if (scb.sub.signature != SUPPLEMENTAL_CREDENTIALS_SIGNATURE) {
242 NDR_PRINT_DEBUG(supplementalCredentialsBlob, &scb);
243 ret = EINVAL;
244 goto out;
245 }
246
247 for (i=0; i < scb.sub.num_packages; i++) {
248 if (strcmp("Primary:Kerberos-Newer-Keys", scb.sub.packages[i].name) == 0) {
249 scpk = &scb.sub.packages[i];
250 if (!scpk->data || !scpk->data[0]) {
251 scpk = NULL;
252 continue;
253 }
254 newer_keys = true;
255 break;
256 } else if (strcmp("Primary:Kerberos", scb.sub.packages[i].name) == 0) {
257 scpk = &scb.sub.packages[i];
258 if (!scpk->data || !scpk->data[0]) {
259 scpk = NULL;
260 }
261 /*
262 * we don't break here in hope to find
263 * a Kerberos-Newer-Keys package
264 */
265 }
266 }
267 }
268 /*
269 * Primary:Kerberos-Newer-Keys or Primary:Kerberos element
270 * of supplementalCredentials
271 */
272 if (scpk) {
273 DATA_BLOB blob;
274
275 blob = strhex_to_data_blob(mem_ctx, scpk->data);
276 if (!blob.data) {
277 ret = ENOMEM;
278 goto out;
279 }
280
281 /* we cannot use ndr_pull_struct_blob_all() here, as w2k and w2k3 add padding bytes */
282 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, iconv_convenience, &_pkb,
283 (ndr_pull_flags_fn_t)ndr_pull_package_PrimaryKerberosBlob);
284 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
285 ret = EINVAL;
286 krb5_set_error_message(context, ret, "hdb_samba4_message2entry_keys: could not parse package_PrimaryKerberosBlob");
287 krb5_warnx(context, "hdb_samba4_message2entry_keys: could not parse package_PrimaryKerberosBlob");
288 goto out;
289 }
290
291 if (newer_keys && _pkb.version != 4) {
292 ret = EINVAL;
293 krb5_set_error_message(context, ret, "hdb_samba4_message2entry_keys: Primary:Kerberos-Newer-Keys not version 4");
294 krb5_warnx(context, "hdb_samba4_message2entry_keys: Primary:Kerberos-Newer-Keys not version 4");
295 goto out;
296 }
297
298 if (!newer_keys && _pkb.version != 3) {
299 ret = EINVAL;
300 krb5_set_error_message(context, ret, "hdb_samba4_message2entry_keys: could not parse Primary:Kerberos not version 3");
301 krb5_warnx(context, "hdb_samba4_message2entry_keys: could not parse Primary:Kerberos not version 3");
302 goto out;
303 }
304
305 if (_pkb.version == 4) {
306 pkb4 = &_pkb.ctr.ctr4;
307 allocated_keys += pkb4->num_keys;
308 } else if (_pkb.version == 3) {
309 pkb3 = &_pkb.ctr.ctr3;
310 allocated_keys += pkb3->num_keys;
311 }
312 }
313
314 if (allocated_keys == 0) {
315 /* oh, no password. Apparently (comment in
316 * hdb-ldap.c) this violates the ASN.1, but this
317 * allows an entry with no keys (yet). */
318 return 0;
319 }
320
321 /* allocate space to decode into */
322 entry_ex->entry.keys.len = 0;
323 entry_ex->entry.keys.val = calloc(allocated_keys, sizeof(Key));
324 if (entry_ex->entry.keys.val == NULL) {
325 ret = ENOMEM;
326 goto out;
327 }
328
329 if (hash && !(userAccountControl & UF_USE_DES_KEY_ONLY)) {
330 Key key;
331
332 key.mkvno = 0;
333 key.salt = NULL; /* No salt for this enc type */
334
335 ret = krb5_keyblock_init(context,
336 ENCTYPE_ARCFOUR_HMAC,
337 hash->hash, sizeof(hash->hash),
338 &key.key);
339 if (ret) {
340 goto out;
341 }
342
343 entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
344 entry_ex->entry.keys.len++;
345 }
346
347 if (pkb4) {
348 for (i=0; i < pkb4->num_keys; i++) {
349 bool use = true;
350 Key key;
351
352 if (!pkb4->keys[i].value) continue;
353
354 if (userAccountControl & UF_USE_DES_KEY_ONLY) {
355 switch (pkb4->keys[i].keytype) {
356 case ENCTYPE_DES_CBC_CRC:
357 case ENCTYPE_DES_CBC_MD5:
358 break;
359 default:
360 use = false;
361 break;
362 }
363 }
364
365 if (!use) continue;
366
367 key.mkvno = 0;
368 key.salt = NULL;
369
370 if (pkb4->salt.string) {
371 DATA_BLOB salt;
372
373 salt = data_blob_string_const(pkb4->salt.string);
374
375 key.salt = calloc(1, sizeof(*key.salt));
376 if (key.salt == NULL) {
377 ret = ENOMEM;
378 goto out;
379 }
380
381 key.salt->type = hdb_pw_salt;
382
383 ret = krb5_data_copy(&key.salt->salt, salt.data, salt.length);
384 if (ret) {
385 free(key.salt);
386 key.salt = NULL;
387 goto out;
388 }
389 }
390
391 /* TODO: maybe pass the iteration_count somehow... */
392
393 ret = krb5_keyblock_init(context,
394 pkb4->keys[i].keytype,
395 pkb4->keys[i].value->data,
396 pkb4->keys[i].value->length,
397 &key.key);
398 if (ret == KRB5_PROG_ETYPE_NOSUPP) {
399 DEBUG(2,("Unsupported keytype ignored - type %u\n",
400 pkb4->keys[i].keytype));
401 ret = 0;
402 continue;
403 }
404 if (ret) {
405 if (key.salt) {
406 free_Salt(key.salt);
407 free(key.salt);
408 key.salt = NULL;
409 }
410 goto out;
411 }
412
413 entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
414 entry_ex->entry.keys.len++;
415 }
416 } else if (pkb3) {
417 for (i=0; i < pkb3->num_keys; i++) {
418 bool use = true;
419 Key key;
420
421 if (!pkb3->keys[i].value) continue;
422
423 if (userAccountControl & UF_USE_DES_KEY_ONLY) {
424 switch (pkb3->keys[i].keytype) {
425 case ENCTYPE_DES_CBC_CRC:
426 case ENCTYPE_DES_CBC_MD5:
427 break;
428 default:
429 use = false;
430 break;
431 }
432 }
433
434 if (!use) continue;
435
436 key.mkvno = 0;
437 key.salt = NULL;
438
439 if (pkb3->salt.string) {
440 DATA_BLOB salt;
441
442 salt = data_blob_string_const(pkb3->salt.string);
443
444 key.salt = calloc(1, sizeof(*key.salt));
445 if (key.salt == NULL) {
446 ret = ENOMEM;
447 goto out;
448 }
449
450 key.salt->type = hdb_pw_salt;
451
452 ret = krb5_data_copy(&key.salt->salt, salt.data, salt.length);
453 if (ret) {
454 free(key.salt);
455 key.salt = NULL;
456 goto out;
457 }
458 }
459
460 ret = krb5_keyblock_init(context,
461 pkb3->keys[i].keytype,
462 pkb3->keys[i].value->data,
463 pkb3->keys[i].value->length,
464 &key.key);
465 if (ret) {
466 if (key.salt) {
467 free_Salt(key.salt);
468 free(key.salt);
469 key.salt = NULL;
470 }
471 goto out;
472 }
473
474 entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
475 entry_ex->entry.keys.len++;
476 }
477 }
478
479 out:
480 if (ret != 0) {
481 entry_ex->entry.keys.len = 0;
482 }
483 if (entry_ex->entry.keys.len == 0 && entry_ex->entry.keys.val) {
484 free(entry_ex->entry.keys.val);
485 entry_ex->entry.keys.val = NULL;
486 }
487 return ret;
488 }
489
490 /*
491 * Construct an hdb_entry from a directory entry.
492 */
493 static krb5_error_code hdb_samba4_message2entry(krb5_context context,
494 struct samba_kdc_db_context *kdc_db_ctx,
495 struct loadparm_context *lp_ctx,
496 TALLOC_CTX *mem_ctx, krb5_const_principal principal,
497 enum hdb_samba4_ent_type ent_type,
498 struct ldb_dn *realm_dn,
499 struct ldb_message *msg,
500 hdb_entry_ex *entry_ex)
501 {
502 unsigned int userAccountControl;
503 int i;
504 krb5_error_code ret = 0;
505 krb5_boolean is_computer = FALSE;
506 char *realm = strupper_talloc(mem_ctx, lp_realm(lp_ctx));
507
508 struct samba_kdc_entry *p;
509 NTTIME acct_expiry;
510 NTSTATUS status;
511
512 uint32_t rid;
513 struct ldb_message_element *objectclasses;
514 struct ldb_val computer_val;
515 const char *samAccountName = ldb_msg_find_attr_as_string(msg, "samAccountName", NULL);
516 computer_val.data = discard_const_p(uint8_t,"computer");
517 computer_val.length = strlen((const char *)computer_val.data);
518
519 if (!samAccountName) {
520 ret = ENOENT;
521 krb5_set_error_message(context, ret, "hdb_samba4_message2entry: no samAccountName present");
522 goto out;
523 }
524
525 objectclasses = ldb_msg_find_element(msg, "objectClass");
526
527 if (objectclasses && ldb_msg_find_val(objectclasses, &computer_val)) {
528 is_computer = TRUE;
529 }
530
531 memset(entry_ex, 0, sizeof(*entry_ex));
532
533 if (!realm) {
534 ret = ENOMEM;
535 krb5_set_error_message(context, ret, "talloc_strdup: out of memory");
536 goto out;
537 }
538
539 p = talloc(mem_ctx, struct samba_kdc_entry);
540 if (!p) {
541 ret = ENOMEM;
542 goto out;
543 }
544
545 p->kdc_db_ctx = kdc_db_ctx;
546 p->entry_ex = entry_ex;
547 p->realm_dn = talloc_reference(p, realm_dn);
548 if (!p->realm_dn) {
549 ret = ENOMEM;
550 goto out;
551 }
552
553 talloc_set_destructor(p, samba_kdc_entry_destructor);
554
555 entry_ex->ctx = p;
556 entry_ex->free_entry = hdb_samba4_free_entry;
557
558 userAccountControl = ldb_msg_find_attr_as_uint(msg, "userAccountControl", 0);
559
560
561 entry_ex->entry.principal = malloc(sizeof(*(entry_ex->entry.principal)));
562 if (ent_type == HDB_SAMBA4_ENT_TYPE_ANY && principal == NULL) {
563 krb5_make_principal(context, &entry_ex->entry.principal, realm, samAccountName, NULL);
564 } else {
565 ret = copy_Principal(principal, entry_ex->entry.principal);
566 if (ret) {
567 krb5_clear_error_message(context);
568 goto out;
569 }
570
571 /* While we have copied the client principal, tests
572 * show that Win2k3 returns the 'corrected' realm, not
573 * the client-specified realm. This code attempts to
574 * replace the client principal's realm with the one
575 * we determine from our records */
576
577 /* this has to be with malloc() */
578 krb5_principal_set_realm(context, entry_ex->entry.principal, realm);
579 }
580
581 /* First try and figure out the flags based on the userAccountControl */
582 entry_ex->entry.flags = uf2HDBFlags(context, userAccountControl, ent_type);
583
584 /* Windows 2008 seems to enforce this (very sensible) rule by
585 * default - don't allow offline attacks on a user's password
586 * by asking for a ticket to them as a service (encrypted with
587 * their probably patheticly insecure password) */
588
589 if (entry_ex->entry.flags.server
590 && lp_parm_bool(lp_ctx, NULL, "kdc", "require spn for service", true)) {
591 if (!is_computer && !ldb_msg_find_attr_as_string(msg, "servicePrincipalName", NULL)) {
592 entry_ex->entry.flags.server = 0;
593 }
594 }
595
596 {
597 /* These (created_by, modified_by) parts of the entry are not relevant for Samba4's use
598 * of the Heimdal KDC. They are stored in a the traditional
599 * DB for audit purposes, and still form part of the structure
600 * we must return */
601
602 /* use 'whenCreated' */
603 entry_ex->entry.created_by.time = ldb_msg_find_krb5time_ldap_time(msg, "whenCreated", 0);
604 /* use '???' */
605 entry_ex->entry.created_by.principal = NULL;
606
607 entry_ex->entry.modified_by = (Event *) malloc(sizeof(Event));
608 if (entry_ex->entry.modified_by == NULL) {
609 ret = ENOMEM;
610 krb5_set_error_message(context, ret, "malloc: out of memory");
611 goto out;
612 }
613
614 /* use 'whenChanged' */
615 entry_ex->entry.modified_by->time = ldb_msg_find_krb5time_ldap_time(msg, "whenChanged", 0);
616 /* use '???' */
617 entry_ex->entry.modified_by->principal = NULL;
618 }
619
620
621 /* The lack of password controls etc applies to krbtgt by
622 * virtue of being that particular RID */
623 status = dom_sid_split_rid(NULL, samdb_result_dom_sid(mem_ctx, msg, "objectSid"), NULL, &rid);
624
625 if (!NT_STATUS_IS_OK(status)) {
626 ret = EINVAL;
627 goto out;
628 }
629
630 if (rid == DOMAIN_RID_KRBTGT) {
631 entry_ex->entry.valid_end = NULL;
632 entry_ex->entry.pw_end = NULL;
633
634 entry_ex->entry.flags.invalid = 0;
635 entry_ex->entry.flags.server = 1;
636
637 /* Don't mark all requests for the krbtgt/realm as
638 * 'change password', as otherwise we could get into
639 * trouble, and not enforce the password expirty.
640 * Instead, only do it when request is for the kpasswd service */
641 if (ent_type == HDB_SAMBA4_ENT_TYPE_SERVER
642 && principal->name.name_string.len == 2
643 && (strcmp(principal->name.name_string.val[0], "kadmin") == 0)
644 && (strcmp(principal->name.name_string.val[1], "changepw") == 0)
645 && lp_is_my_domain_or_realm(lp_ctx, principal->realm)) {
646 entry_ex->entry.flags.change_pw = 1;
647 }
648 entry_ex->entry.flags.client = 0;
649 entry_ex->entry.flags.forwardable = 1;
650 entry_ex->entry.flags.ok_as_delegate = 1;
651 } else if (entry_ex->entry.flags.server && ent_type == HDB_SAMBA4_ENT_TYPE_SERVER) {
652 /* The account/password expiry only applies when the account is used as a
653 * client (ie password login), not when used as a server */
654
655 /* Make very well sure we don't use this for a client,
656 * it could bypass the password restrictions */
657 entry_ex->entry.flags.client = 0;
658
659 entry_ex->entry.valid_end = NULL;
660 entry_ex->entry.pw_end = NULL;
661
662 } else {
663 NTTIME must_change_time
664 = samdb_result_force_password_change(kdc_db_ctx->samdb, mem_ctx,
665 realm_dn, msg);
666 if (must_change_time == 0x7FFFFFFFFFFFFFFFULL) {
667 entry_ex->entry.pw_end = NULL;
668 } else {
669 entry_ex->entry.pw_end = malloc(sizeof(*entry_ex->entry.pw_end));
670 if (entry_ex->entry.pw_end == NULL) {
671 ret = ENOMEM;
672 goto out;
673 }
674 *entry_ex->entry.pw_end = nt_time_to_unix(must_change_time);
675 }
676
677 acct_expiry = samdb_result_account_expires(msg);
678 if (acct_expiry == 0x7FFFFFFFFFFFFFFFULL) {
679 entry_ex->entry.valid_end = NULL;
680 } else {
681 entry_ex->entry.valid_end = malloc(sizeof(*entry_ex->entry.valid_end));
682 if (entry_ex->entry.valid_end == NULL) {
683 ret = ENOMEM;
684 goto out;
685 }
686 *entry_ex->entry.valid_end = nt_time_to_unix(acct_expiry);
687 }
688 }
689
690 entry_ex->entry.valid_start = NULL;
691
692 entry_ex->entry.max_life = NULL;
693
694 entry_ex->entry.max_renew = NULL;
695
696 entry_ex->entry.generation = NULL;
697
698 /* Get keys from the db */
699 ret = hdb_samba4_message2entry_keys(context, p->kdc_db_ctx->ic_ctx, p,
700 msg, userAccountControl, entry_ex);
701 if (ret) {
702 /* Could be bougus data in the entry, or out of memory */
703 goto out;
704 }
705
706 entry_ex->entry.etypes = malloc(sizeof(*(entry_ex->entry.etypes)));
707 if (entry_ex->entry.etypes == NULL) {
708 krb5_clear_error_message(context);
709 ret = ENOMEM;
710 goto out;
711 }
712 entry_ex->entry.etypes->len = entry_ex->entry.keys.len;
713 entry_ex->entry.etypes->val = calloc(entry_ex->entry.etypes->len, sizeof(int));
714 if (entry_ex->entry.etypes->val == NULL) {
715 krb5_clear_error_message(context);
716 ret = ENOMEM;
717 goto out;
718 }
719 for (i=0; i < entry_ex->entry.etypes->len; i++) {
720 entry_ex->entry.etypes->val[i] = entry_ex->entry.keys.val[i].key.keytype;
721 }
722
723
724 p->msg = talloc_steal(p, msg);
725
726 out:
727 if (ret != 0) {
728 /* This doesn't free ent itself, that is for the eventual caller to do */
729 hdb_free_entry(context, entry_ex);
730 } else {
731 talloc_steal(kdc_db_ctx, entry_ex->ctx);
732 }
733
734 return ret;
735 }
736
737 /*
738 * Construct an hdb_entry from a directory entry.
739 */
740 static krb5_error_code hdb_samba4_trust_message2entry(krb5_context context,
741 struct samba_kdc_db_context *kdc_db_ctx,
742 struct loadparm_context *lp_ctx,
743 TALLOC_CTX *mem_ctx, krb5_const_principal principal,
744 enum trust_direction direction,
745 struct ldb_dn *realm_dn,
746 struct ldb_message *msg,
747 hdb_entry_ex *entry_ex)
748 {
749
750 const char *dnsdomain;
751 char *realm;
752 DATA_BLOB password_utf16;
753 struct samr_Password password_hash;
754 const struct ldb_val *password_val;
755 struct trustAuthInOutBlob password_blob;
756 struct samba_kdc_entry *p;
757
758 enum ndr_err_code ndr_err;
759 int i, ret, trust_direction_flags;
760
761 p = talloc(mem_ctx, struct samba_kdc_entry);
762 if (!p) {
763 ret = ENOMEM;
764 goto out;
765 }
766
767 p->kdc_db_ctx = kdc_db_ctx;
768 p->entry_ex = entry_ex;
769 p->realm_dn = realm_dn;
770
771 talloc_set_destructor(p, samba_kdc_entry_destructor);
772
773 entry_ex->ctx = p;
774 entry_ex->free_entry = hdb_samba4_free_entry;
775
776 /* use 'whenCreated' */
777 entry_ex->entry.created_by.time = ldb_msg_find_krb5time_ldap_time(msg, "whenCreated", 0);
778 /* use '???' */
779 entry_ex->entry.created_by.principal = NULL;
780
781 entry_ex->entry.valid_start = NULL;
782
783 trust_direction_flags = ldb_msg_find_attr_as_int(msg, "trustDirection", 0);
784
785 if (direction == INBOUND) {
786 realm = strupper_talloc(mem_ctx, lp_realm(lp_ctx));
787 password_val = ldb_msg_find_ldb_val(msg, "trustAuthIncoming");
788
789 } else { /* OUTBOUND */
790 dnsdomain = ldb_msg_find_attr_as_string(msg, "trustPartner", NULL);
791 realm = strupper_talloc(mem_ctx, dnsdomain);
792 password_val = ldb_msg_find_ldb_val(msg, "trustAuthOutgoing");
793 }
794
795 if (!password_val || !(trust_direction_flags & direction)) {
796 ret = ENOENT;
797 goto out;
798 }
799
800 ndr_err = ndr_pull_struct_blob(password_val, mem_ctx, p->kdc_db_ctx->ic_ctx, &password_blob,
801 (ndr_pull_flags_fn_t)ndr_pull_trustAuthInOutBlob);
802 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
803 ret = EINVAL;
804 goto out;
805 }
806
807 entry_ex->entry.kvno = -1;
808 for (i=0; i < password_blob.count; i++) {
809 if (password_blob.current->array[i].AuthType == TRUST_AUTH_TYPE_VERSION) {
810 entry_ex->entry.kvno = password_blob.current->array[i].AuthInfo.version.version;
811 }
812 }
813
814 for (i=0; i < password_blob.count; i++) {
815 if (password_blob.current->array[i].AuthType == TRUST_AUTH_TYPE_CLEAR) {
816 password_utf16 = data_blob_const(password_blob.current->array[i].AuthInfo.clear.password,
817 password_blob.current->array[i].AuthInfo.clear.size);
818 /* In the future, generate all sorts of
819 * hashes, but for now we can't safely convert
820 * the random strings windows uses into
821 * utf8 */
822
823 /* but as it is utf16 already, we can get the NT password/arcfour-hmac-md5 key */
824 mdfour(password_hash.hash, password_utf16.data, password_utf16.length);
825 break;
826 } else if (password_blob.current->array[i].AuthType == TRUST_AUTH_TYPE_NT4OWF) {
827 password_hash = password_blob.current->array[i].AuthInfo.nt4owf.password;
828 break;
829 }
830 }
831 entry_ex->entry.keys.len = 0;
832 entry_ex->entry.keys.val = NULL;
833
834 if (i < password_blob.count) {
835 Key key;
836 /* Must have found a cleartext or MD4 password */
837 entry_ex->entry.keys.val = calloc(1, sizeof(Key));
838
839 key.mkvno = 0;
840 key.salt = NULL; /* No salt for this enc type */
841
842 if (entry_ex->entry.keys.val == NULL) {
843 ret = ENOMEM;
844 goto out;
845 }
846
847 ret = krb5_keyblock_init(context,
848 ENCTYPE_ARCFOUR_HMAC,
849 password_hash.hash, sizeof(password_hash.hash),
850 &key.key);
851
852 entry_ex->entry.keys.val[entry_ex->entry.keys.len] = key;
853 entry_ex->entry.keys.len++;
854 }
855
856 entry_ex->entry.principal = malloc(sizeof(*(entry_ex->entry.principal)));
857
858 ret = copy_Principal(principal, entry_ex->entry.principal);
859 if (ret) {
860 krb5_clear_error_message(context);
861 goto out;
862 }
863
864 /* While we have copied the client principal, tests
865 * show that Win2k3 returns the 'corrected' realm, not
866 * the client-specified realm. This code attempts to
867 * replace the client principal's realm with the one
868 * we determine from our records */
869
870 krb5_principal_set_realm(context, entry_ex->entry.principal, realm);
871 entry_ex->entry.flags = int2HDBFlags(0);
872 entry_ex->entry.flags.immutable = 1;
873 entry_ex->entry.flags.invalid = 0;
874 entry_ex->entry.flags.server = 1;
875 entry_ex->entry.flags.require_preauth = 1;
876
877 entry_ex->entry.pw_end = NULL;
878
879 entry_ex->entry.max_life = NULL;
880
881 entry_ex->entry.max_renew = NULL;
882
883 entry_ex->entry.generation = NULL;
884
885 entry_ex->entry.etypes = malloc(sizeof(*(entry_ex->entry.etypes)));
886 if (entry_ex->entry.etypes == NULL) {
887 krb5_clear_error_message(context);
888 ret = ENOMEM;
889 goto out;
890 }
891 entry_ex->entry.etypes->len = entry_ex->entry.keys.len;
892 entry_ex->entry.etypes->val = calloc(entry_ex->entry.etypes->len, sizeof(int));
893 if (entry_ex->entry.etypes->val == NULL) {
894 krb5_clear_error_message(context);
895 ret = ENOMEM;
896 goto out;
897 }
898 for (i=0; i < entry_ex->entry.etypes->len; i++) {
899 entry_ex->entry.etypes->val[i] = entry_ex->entry.keys.val[i].key.keytype;
900 }
901
902
903 p->msg = talloc_steal(p, msg);
904
905 out:
906 if (ret != 0) {
907 /* This doesn't free ent itself, that is for the eventual caller to do */
908 hdb_free_entry(context, entry_ex);
909 } else {
910 talloc_steal(kdc_db_ctx, entry_ex->ctx);
911 }
912
913 return ret;
914
915 }
916
917 static krb5_error_code hdb_samba4_lookup_trust(krb5_context context, struct ldb_context *ldb_ctx,
918 TALLOC_CTX *mem_ctx,
919 const char *realm,
920 struct ldb_dn *realm_dn,
921 struct ldb_message **pmsg)
922 {
923 int lret;
924 krb5_error_code ret;
925 char *filter = NULL;
926 const char * const *attrs = trust_attrs;
927
928 struct ldb_result *res = NULL;
929 filter = talloc_asprintf(mem_ctx, "(&(objectClass=trustedDomain)(|(flatname=%s)(trustPartner=%s)))", realm, realm);
930
931 if (!filter) {
932 ret = ENOMEM;
933 krb5_set_error_message(context, ret, "talloc_asprintf: out of memory");
934 return ret;
935 }
936
937 lret = ldb_search(ldb_ctx, mem_ctx, &res,
938 ldb_get_default_basedn(ldb_ctx),
939 LDB_SCOPE_SUBTREE, attrs, "%s", filter);
940 if (lret != LDB_SUCCESS) {
941 DEBUG(3, ("Failed to search for %s: %s\n", filter, ldb_errstring(ldb_ctx)));
942 return HDB_ERR_NOENTRY;
943 } else if (res->count == 0 || res->count > 1) {
944 DEBUG(3, ("Failed find a single entry for %s: got %d\n", filter, res->count));
945 talloc_free(res);
946 return HDB_ERR_NOENTRY;
947 }
948 talloc_steal(mem_ctx, res->msgs);
949 *pmsg = res->msgs[0];
950 talloc_free(res);
951 return 0;
952 }
953
954 static krb5_error_code hdb_samba4_open(krb5_context context, HDB *db, int flags, mode_t mode)
955 {
956 if (db->hdb_master_key_set) {
957 krb5_error_code ret = HDB_ERR_NOENTRY;
958 krb5_warnx(context, "hdb_samba4_open: use of a master key incompatible with LDB\n");
959 krb5_set_error_message(context, ret, "hdb_samba4_open: use of a master key incompatible with LDB\n");
960 return ret;
961 }
962
963 return 0;
964 }
965
966 static krb5_error_code hdb_samba4_close(krb5_context context, HDB *db)
967 {
968 return 0;
969 }
970
971 static krb5_error_code hdb_samba4_lock(krb5_context context, HDB *db, int operation)
972 {
973 return 0;
974 }
975
976 static krb5_error_code hdb_samba4_unlock(krb5_context context, HDB *db)
977 {
978 return 0;
979 }
980
981 static krb5_error_code hdb_samba4_rename(krb5_context context, HDB *db, const char *new_name)
982 {
983 return HDB_ERR_DB_INUSE;
984 }
985
986 static krb5_error_code hdb_samba4_lookup_client(krb5_context context,
987 struct samba_kdc_db_context *kdc_db_ctx,
988 struct loadparm_context *lp_ctx,
989 TALLOC_CTX *mem_ctx,
990 krb5_const_principal principal,
991 const char **attrs,
992 struct ldb_dn **realm_dn,
993 struct ldb_message **msg) {
994 NTSTATUS nt_status;
995 char *principal_string;
996 krb5_error_code ret;
997
998 ret = krb5_unparse_name(context, principal, &principal_string);
999
1000 if (ret != 0) {
1001 return ret;
1002 }
1003
1004 nt_status = sam_get_results_principal(kdc_db_ctx->samdb,
1005 mem_ctx, principal_string, attrs,
1006 realm_dn, msg);
1007 free(principal_string);
1008 if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_SUCH_USER)) {
1009 return HDB_ERR_NOENTRY;
1010 } else if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_MEMORY)) {
1011 return ENOMEM;
1012 } else if (!NT_STATUS_IS_OK(nt_status)) {
1013 return EINVAL;
1014 }
1015
1016 return ret;
1017 }
1018
1019 static krb5_error_code hdb_samba4_fetch_client(krb5_context context,
1020 struct samba_kdc_db_context *kdc_db_ctx,
1021 struct loadparm_context *lp_ctx,
1022 TALLOC_CTX *mem_ctx,
1023 krb5_const_principal principal,
1024 unsigned flags,
1025 hdb_entry_ex *entry_ex) {
1026 struct ldb_dn *realm_dn;
1027 krb5_error_code ret;
1028 struct ldb_message *msg = NULL;
1029
1030 ret = hdb_samba4_lookup_client(context, kdc_db_ctx, lp_ctx,
1031 mem_ctx, principal, user_attrs,
1032 &realm_dn, &msg);
1033 if (ret != 0) {
1034 return ret;
1035 }
1036
1037 ret = hdb_samba4_message2entry(context, kdc_db_ctx, lp_ctx, mem_ctx,
1038 principal, HDB_SAMBA4_ENT_TYPE_CLIENT,
1039 realm_dn, msg, entry_ex);
1040 return ret;
1041 }
1042
1043 static krb5_error_code hdb_samba4_fetch_krbtgt(krb5_context context,
1044 struct samba_kdc_db_context *kdc_db_ctx,
1045 struct loadparm_context *lp_ctx,
1046 TALLOC_CTX *mem_ctx,
1047 krb5_const_principal principal,
1048 unsigned flags,
1049 hdb_entry_ex *entry_ex)
1050 {
1051 krb5_error_code ret;
1052 struct ldb_message *msg = NULL;
1053 struct ldb_dn *realm_dn = ldb_get_default_basedn(kdc_db_ctx->samdb);
1054 const char *realm;
1055
1056 krb5_principal alloc_principal = NULL;
1057 if (principal->name.name_string.len != 2
1058 || (strcmp(principal->name.name_string.val[0], KRB5_TGS_NAME) != 0)) {
1059 /* Not a krbtgt */
1060 return HDB_ERR_NOENTRY;
1061 }
1062
1063 /* krbtgt case. Either us or a trusted realm */
1064
1065 if (lp_is_my_domain_or_realm(lp_ctx, principal->realm)
1066 && lp_is_my_domain_or_realm(lp_ctx, principal->name.name_string.val[1])) {
1067 /* us */
1068 /* Cludge, cludge cludge. If the realm part of krbtgt/realm,
1069 * is in our db, then direct the caller at our primary
1070 * krbtgt */
1071
1072 int lret;
1073 char *realm_fixed;
1074
1075 lret = gendb_search_single_extended_dn(kdc_db_ctx->samdb, mem_ctx,
1076 realm_dn, LDB_SCOPE_SUBTREE,
1077 &msg, krbtgt_attrs,
1078 "(&(objectClass=user)(samAccountName=krbtgt))");
1079 if (lret == LDB_ERR_NO_SUCH_OBJECT) {
1080 krb5_warnx(context, "hdb_samba4_fetch: could not find own KRBTGT in DB!");
1081 krb5_set_error_message(context, HDB_ERR_NOENTRY, "hdb_samba4_fetch: could not find own KRBTGT in DB!");
1082 return HDB_ERR_NOENTRY;
1083 } else if (lret != LDB_SUCCESS) {
1084 krb5_warnx(context, "hdb_samba4_fetch: could not find own KRBTGT in DB: %s", ldb_errstring(kdc_db_ctx->samdb));
1085 krb5_set_error_message(context, HDB_ERR_NOENTRY, "hdb_samba4_fetch: could not find own KRBTGT in DB: %s", ldb_errstring(kdc_db_ctx->samdb));
1086 return HDB_ERR_NOENTRY;
1087 }
1088
1089 realm_fixed = strupper_talloc(mem_ctx, lp_realm(lp_ctx));
1090 if (!realm_fixed) {
1091 ret = ENOMEM;
1092 krb5_set_error_message(context, ret, "strupper_talloc: out of memory");
1093 return ret;
1094 }
1095
1096 ret = krb5_copy_principal(context, principal, &alloc_principal);
1097 if (ret) {
1098 return ret;
1099 }
1100
1101 free(alloc_principal->name.name_string.val[1]);
1102 alloc_principal->name.name_string.val[1] = strdup(realm_fixed);
1103 talloc_free(realm_fixed);
1104 if (!alloc_principal->name.name_string.val[1]) {
1105 ret = ENOMEM;
1106 krb5_set_error_message(context, ret, "hdb_samba4_fetch: strdup() failed!");
1107 return ret;
1108 }
1109 principal = alloc_principal;
1110
1111 ret = hdb_samba4_message2entry(context, kdc_db_ctx, lp_ctx, mem_ctx,
1112 principal, HDB_SAMBA4_ENT_TYPE_KRBTGT,
1113 realm_dn, msg, entry_ex);
1114 if (ret != 0) {
1115 krb5_warnx(context, "hdb_samba4_fetch: self krbtgt message2entry failed");
1116 }
1117 return ret;
1118
1119 } else {
1120 enum trust_direction direction = UNKNOWN;
1121
1122 /* Either an inbound or outbound trust */
1123
1124 if (strcasecmp(lp_realm(lp_ctx), principal->realm) == 0) {
1125 /* look for inbound trust */
1126 direction = INBOUND;
1127 realm = principal->name.name_string.val[1];
1128 }
1129
1130 if (strcasecmp(lp_realm(lp_ctx), principal->name.name_string.val[1]) == 0) {
1131 /* look for outbound trust */
1132 direction = OUTBOUND;
1133 realm = principal->realm;
1134 }
1135
1136 /* Trusted domains are under CN=system */
1137
1138 ret = hdb_samba4_lookup_trust(context, kdc_db_ctx->samdb,
1139 mem_ctx,
1140 realm, realm_dn, &msg);
1141
1142 if (ret != 0) {
1143 krb5_warnx(context, "hdb_samba4_fetch: could not find principal in DB");
1144 krb5_set_error_message(context, ret, "hdb_samba4_fetch: could not find principal in DB");
1145 return ret;
1146 }
1147
1148 ret = hdb_samba4_trust_message2entry(context, kdc_db_ctx, lp_ctx, mem_ctx,
1149 principal, direction,
1150 realm_dn, msg, entry_ex);
1151 if (ret != 0) {
1152 krb5_warnx(context, "hdb_samba4_fetch: trust_message2entry failed");
1153 }
1154 return ret;
1155
1156
1157 /* we should lookup trusted domains */
1158 return HDB_ERR_NOENTRY;
1159 }
1160
1161 }
1162
1163 static krb5_error_code hdb_samba4_lookup_server(krb5_context context,
1164 struct samba_kdc_db_context *kdc_db_ctx,
1165 struct loadparm_context *lp_ctx,
1166 TALLOC_CTX *mem_ctx,
1167 krb5_const_principal principal,
1168 const char **attrs,
1169 struct ldb_dn **realm_dn,
1170 struct ldb_message **msg)
1171 {
1172 krb5_error_code ret;
1173 const char *realm;
1174 if (principal->name.name_string.len >= 2) {
1175 /* 'normal server' case */
1176 int ldb_ret;
1177 NTSTATUS nt_status;
1178 struct ldb_dn *user_dn;
1179 char *principal_string;
1180
1181 ret = krb5_unparse_name_flags(context, principal,
1182 KRB5_PRINCIPAL_UNPARSE_NO_REALM,
1183 &principal_string);
1184 if (ret != 0) {
1185 return ret;
1186 }
1187
1188 /* At this point we may find the host is known to be
1189 * in a different realm, so we should generate a
1190 * referral instead */
1191 nt_status = crack_service_principal_name(kdc_db_ctx->samdb,
1192 mem_ctx, principal_string,
1193 &user_dn, realm_dn);
1194 free(principal_string);
1195
1196 if (!NT_STATUS_IS_OK(nt_status)) {
1197 return HDB_ERR_NOENTRY;
1198 }
1199
1200 ldb_ret = gendb_search_single_extended_dn(kdc_db_ctx->samdb,
1201 mem_ctx,
1202 user_dn, LDB_SCOPE_BASE,
1203 msg, attrs,
1204 "(objectClass=*)");
1205 if (ldb_ret != LDB_SUCCESS) {
1206 return HDB_ERR_NOENTRY;
1207 }
1208
1209 } else {
1210 int lret;
1211 char *filter = NULL;
1212 char *short_princ;
1213 /* server as client principal case, but we must not lookup userPrincipalNames */
1214 *realm_dn = ldb_get_default_basedn(kdc_db_ctx->samdb);
1215 realm = krb5_principal_get_realm(context, principal);
1216
1217 /* TODO: Check if it is our realm, otherwise give referall */
1218
1219 ret = krb5_unparse_name_flags(context, principal, KRB5_PRINCIPAL_UNPARSE_NO_REALM, &short_princ);
1220
1221 if (ret != 0) {
1222 krb5_set_error_message(context, ret, "hdb_samba4_lookup_principal: could not parse principal");
1223 krb5_warnx(context, "hdb_samba4_lookup_principal: could not parse principal");
1224 return ret;
1225 }
1226
1227 lret = gendb_search_single_extended_dn(kdc_db_ctx->samdb, mem_ctx,
1228 *realm_dn, LDB_SCOPE_SUBTREE,
1229 msg, attrs, "(&(objectClass=user)(samAccountName=%s))",
1230 ldb_binary_encode_string(mem_ctx, short_princ));
1231 free(short_princ);
1232 if (lret == LDB_ERR_NO_SUCH_OBJECT) {
1233 DEBUG(3, ("Failed find a entry for %s\n", filter));
1234 return HDB_ERR_NOENTRY;
1235 }
1236 if (lret != LDB_SUCCESS) {
1237 DEBUG(3, ("Failed single search for for %s - %s\n",
1238 filter, ldb_errstring(kdc_db_ctx->samdb)));
1239 return HDB_ERR_NOENTRY;
1240 }
1241 }
1242
1243 return 0;
1244 }
1245
1246 static krb5_error_code hdb_samba4_fetch_server(krb5_context context,
1247 struct samba_kdc_db_context *kdc_db_ctx,
1248 struct loadparm_context *lp_ctx,
1249 TALLOC_CTX *mem_ctx,
1250 krb5_const_principal principal,
1251 unsigned flags,
1252 hdb_entry_ex *entry_ex)
1253 {
1254 krb5_error_code ret;
1255 struct ldb_dn *realm_dn;
1256 struct ldb_message *msg;
1257
1258 ret = hdb_samba4_lookup_server(context, kdc_db_ctx, lp_ctx, mem_ctx, principal,
1259 server_attrs, &realm_dn, &msg);
1260 if (ret != 0) {
1261 return ret;
1262 }
1263
1264 ret = hdb_samba4_message2entry(context, kdc_db_ctx, lp_ctx, mem_ctx,
1265 principal, HDB_SAMBA4_ENT_TYPE_SERVER,
1266 realm_dn, msg, entry_ex);
1267 if (ret != 0) {
1268 krb5_warnx(context, "hdb_samba4_fetch: message2entry failed");
1269 }
1270
1271 return ret;
1272 }
1273
1274 static krb5_error_code hdb_samba4_fetch(krb5_context context, HDB *db,
1275 krb5_const_principal principal,
1276 unsigned flags,
1277 hdb_entry_ex *entry_ex)
1278 {
1279 struct samba_kdc_db_context *kdc_db_ctx = (struct samba_kdc_db_context *)db->hdb_db;
1280 krb5_error_code ret = HDB_ERR_NOENTRY;
1281 TALLOC_CTX *mem_ctx = talloc_named(kdc_db_ctx, 0, "hdb_samba4_fetch context");
1282 struct loadparm_context *lp_ctx = kdc_db_ctx->lp_ctx;
1283
1284 if (!mem_ctx) {
1285 ret = ENOMEM;
1286 krb5_set_error_message(context, ret, "hdb_samba4_fetch: talloc_named() failed!");
1287 return ret;
1288 }
1289
1290 if (flags & HDB_F_GET_CLIENT) {
1291 ret = hdb_samba4_fetch_client(context, kdc_db_ctx, lp_ctx, mem_ctx, principal, flags, entry_ex);
1292 if (ret != HDB_ERR_NOENTRY) goto done;
1293 }
1294 if (flags & HDB_F_GET_SERVER) {
1295 /* krbtgt fits into this situation for trusted realms, and for resolving different versions of our own realm name */
1296 ret = hdb_samba4_fetch_krbtgt(context, kdc_db_ctx, lp_ctx, mem_ctx, principal, flags, entry_ex);
1297 if (ret != HDB_ERR_NOENTRY) goto done;
1298
1299 /* We return 'no entry' if it does not start with krbtgt/, so move to the common case quickly */
1300 ret = hdb_samba4_fetch_server(context, kdc_db_ctx, lp_ctx, mem_ctx, principal, flags, entry_ex);
1301 if (ret != HDB_ERR_NOENTRY) goto done;
1302 }
1303 if (flags & HDB_F_GET_KRBTGT) {
1304 ret = hdb_samba4_fetch_krbtgt(context, kdc_db_ctx, lp_ctx, mem_ctx, principal, flags, entry_ex);
1305 if (ret != HDB_ERR_NOENTRY) goto done;
1306 }
1307
1308 done:
1309 talloc_free(mem_ctx);
1310 return ret;
1311 }
1312
1313 static krb5_error_code hdb_samba4_store(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
1314 {
1315 return HDB_ERR_DB_INUSE;
1316 }
1317
1318 static krb5_error_code hdb_samba4_remove(krb5_context context, HDB *db, krb5_const_principal principal)
1319 {
1320 return HDB_ERR_DB_INUSE;
1321 }
1322
1323 struct hdb_samba4_seq {
1324 struct ldb_context *ctx;
1325 struct loadparm_context *lp_ctx;
1326 int index;
1327 int count;
1328 struct ldb_message **msgs;
1329 struct ldb_dn *realm_dn;
1330 };
1331
1332 static krb5_error_code hdb_samba4_seq(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
1333 {
1334 struct samba_kdc_db_context *kdc_db_ctx = (struct samba_kdc_db_context *)db->hdb_db;
1335 krb5_error_code ret;
1336 struct hdb_samba4_seq *priv = (struct hdb_samba4_seq *)db->hdb_dbc;
1337 TALLOC_CTX *mem_ctx;
1338 hdb_entry_ex entry_ex;
1339 memset(&entry_ex, '\0', sizeof(entry_ex));
1340
1341 if (!priv) {
1342 return HDB_ERR_NOENTRY;
1343 }
1344
1345 mem_ctx = talloc_named(priv, 0, "hdb_samba4_seq context");
1346
1347 if (!mem_ctx) {
1348 ret = ENOMEM;
1349 krb5_set_error_message(context, ret, "hdb_samba4_seq: talloc_named() failed!");
1350 return ret;
1351 }
1352
1353 if (priv->index < priv->count) {
1354 ret = hdb_samba4_message2entry(context, kdc_db_ctx, priv->lp_ctx,
1355 mem_ctx,
1356 NULL, HDB_SAMBA4_ENT_TYPE_ANY,
1357 priv->realm_dn, priv->msgs[priv->index++], entry);
1358 } else {
1359 ret = HDB_ERR_NOENTRY;
1360 }
1361
1362 if (ret != 0) {
1363 db->hdb_dbc = NULL;
1364 } else {
1365 talloc_free(mem_ctx);
1366 }
1367
1368 return ret;
1369 }
1370
1371 static krb5_error_code hdb_samba4_firstkey(krb5_context context, HDB *db, unsigned flags,
1372 hdb_entry_ex *entry)
1373 {
1374 struct samba_kdc_db_context *kdc_db_ctx = (struct samba_kdc_db_context *)db->hdb_db;
1375 struct ldb_context *ldb_ctx = kdc_db_ctx->samdb;
1376 struct loadparm_context *lp_ctx = talloc_get_type(ldb_get_opaque(ldb_ctx, "loadparm"),
1377 struct loadparm_context);
1378 struct hdb_samba4_seq *priv = (struct hdb_samba4_seq *)db->hdb_dbc;
1379 char *realm;
1380 struct ldb_result *res = NULL;
1381 krb5_error_code ret;
1382 TALLOC_CTX *mem_ctx;
1383 int lret;
1384
1385 if (priv) {
1386 talloc_free(priv);
1387 db->hdb_dbc = NULL;
1388 }
1389
1390 priv = (struct hdb_samba4_seq *) talloc(db, struct hdb_samba4_seq);
1391 if (!priv) {
1392 ret = ENOMEM;
1393 krb5_set_error_message(context, ret, "talloc: out of memory");
1394 return ret;
1395 }
1396
1397 priv->ctx = ldb_ctx;
1398 priv->lp_ctx = lp_ctx;
1399 priv->index = 0;
1400 priv->msgs = NULL;
1401 priv->realm_dn = ldb_get_default_basedn(ldb_ctx);
1402 priv->count = 0;
1403
1404 mem_ctx = talloc_named(priv, 0, "hdb_samba4_firstkey context");
1405
1406 if (!mem_ctx) {
1407 ret = ENOMEM;
1408 krb5_set_error_message(context, ret, "hdb_samba4_firstkey: talloc_named() failed!");
1409 return ret;
1410 }
1411
1412 ret = krb5_get_default_realm(context, &realm);
1413 if (ret != 0) {
1414 talloc_free(priv);
1415 return ret;
1416 }
1417
1418 lret = ldb_search(ldb_ctx, priv, &res,
1419 priv->realm_dn, LDB_SCOPE_SUBTREE, user_attrs,
1420 "(objectClass=user)");
1421
1422 if (lret != LDB_SUCCESS) {
1423 talloc_free(priv);
1424 return HDB_ERR_NOENTRY;
1425 }
1426
1427 priv->count = res->count;
1428 priv->msgs = talloc_steal(priv, res->msgs);
1429 talloc_free(res);
1430
1431 db->hdb_dbc = priv;
1432
1433 ret = hdb_samba4_seq(context, db, flags, entry);
1434
1435 if (ret != 0) {
1436 talloc_free(priv);
1437 db->hdb_dbc = NULL;
1438 } else {
1439 talloc_free(mem_ctx);
1440 }
1441 return ret;
1442 }
1443
1444 static krb5_error_code hdb_samba4_nextkey(krb5_context context, HDB *db, unsigned flags,
1445 hdb_entry_ex *entry)
1446 {
1447 return hdb_samba4_seq(context, db, flags, entry);
1448 }
1449
1450 static krb5_error_code hdb_samba4_destroy(krb5_context context, HDB *db)
1451 {
1452 talloc_free(db);
1453 return 0;
1454 }
1455
1456
1457 /* Check if a given entry may delegate to this target principal
1458 *
1459 * This is currently a very nasty hack - allowing only delegation to itself.
1460 */
1461 static krb5_error_code
1462 hdb_samba4_check_constrained_delegation(krb5_context context, HDB *db,
1463 hdb_entry_ex *entry,
1464 krb5_const_principal target_principal)
1465 {
1466 struct samba_kdc_db_context *kdc_db_ctx = (struct samba_kdc_db_context *)db->hdb_db;
1467 struct loadparm_context *lp_ctx = kdc_db_ctx->lp_ctx;
1468 krb5_error_code ret;
1469 krb5_principal enterprise_prinicpal = NULL;
1470 struct ldb_dn *realm_dn;
1471 struct ldb_message *msg;
1472 struct dom_sid *orig_sid;
1473 struct dom_sid *target_sid;
1474 struct samba_kdc_entry *p = talloc_get_type(entry->ctx, struct samba_kdc_entry);
1475 const char *delegation_check_attrs[] = {
1476 "objectSid", NULL
1477 };
1478
1479 TALLOC_CTX *mem_ctx = talloc_named(kdc_db_ctx, 0, "hdb_samba4_check_constrained_delegation");
1480
1481 if (!mem_ctx) {
1482 ret = ENOMEM;
1483 krb5_set_error_message(context, ret, "hdb_samba4_fetch: talloc_named() failed!");
1484 return ret;
1485 }
1486
1487 if (target_principal->name.name_type == KRB5_NT_ENTERPRISE_PRINCIPAL) {
1488 /* Need to reparse the enterprise principal to find the real target */
1489 if (target_principal->name.name_string.len != 1) {
1490 ret = KRB5_PARSE_MALFORMED;
1491 krb5_set_error_message(context, ret, "hdb_samba4_check_constrained_delegation: request for delegation to enterprise principal with wrong (%d) number of components",
1492 target_principal->name.name_string.len);
1493 talloc_free(mem_ctx);
1494 return ret;
1495 }
1496 ret = krb5_parse_name(context, target_principal->name.name_string.val[0],
1497 &enterprise_prinicpal);
1498 if (ret) {
1499 talloc_free(mem_ctx);
1500 return ret;
1501 }
1502 target_principal = enterprise_prinicpal;
1503 }
1504
1505 ret = hdb_samba4_lookup_server(context, kdc_db_ctx, lp_ctx, mem_ctx, target_principal,
1506 delegation_check_attrs, &realm_dn, &msg);
1507
1508 krb5_free_principal(context, enterprise_prinicpal);
1509
1510 if (ret != 0) {
1511 talloc_free(mem_ctx);
1512 return ret;
1513 }
1514
1515 orig_sid = samdb_result_dom_sid(mem_ctx, p->msg, "objectSid");
1516 target_sid = samdb_result_dom_sid(mem_ctx, msg, "objectSid");
1517
1518 /* Allow delegation to the same principal, even if by a different
1519 * name. The easy and safe way to prove this is by SID
1520 * comparison */
1521 if (!(orig_sid && target_sid && dom_sid_equal(orig_sid, target_sid))) {
1522 talloc_free(mem_ctx);
1523 return KRB5KDC_ERR_BADOPTION;
1524 }
1525
1526 talloc_free(mem_ctx);
1527 return ret;
1528 }
1529
1530 /* Certificates printed by a the Certificate Authority might have a
1531 * slightly different form of the user principal name to that in the
1532 * database. Allow a mismatch where they both refer to the same
1533 * SID */
1534
1535 static krb5_error_code
1536 hdb_samba4_check_pkinit_ms_upn_match(krb5_context context, HDB *db,
1537 hdb_entry_ex *entry,
1538 krb5_const_principal certificate_principal)
1539 {
1540 struct samba_kdc_db_context *kdc_db_ctx = (struct samba_kdc_db_context *)db->hdb_db;
1541 struct loadparm_context *lp_ctx = kdc_db_ctx->lp_ctx;
1542 krb5_error_code ret;
1543 struct ldb_dn *realm_dn;
1544 struct ldb_message *msg;
1545 struct dom_sid *orig_sid;
1546 struct dom_sid *target_sid;
1547 struct samba_kdc_entry *p = talloc_get_type(entry->ctx, struct samba_kdc_entry);
1548 const char *ms_upn_check_attrs[] = {
1549 "objectSid", NULL
1550 };
1551
1552 TALLOC_CTX *mem_ctx = talloc_named(db, 0, "hdb_samba4_check_pkinit_ms_upn_match");
1553
1554 if (!mem_ctx) {
1555 ret = ENOMEM;
1556 krb5_set_error_message(context, ret, "hdb_samba4_fetch: talloc_named() failed!");
1557 return ret;
1558 }
1559
1560 ret = hdb_samba4_lookup_client(context, kdc_db_ctx, lp_ctx,
1561 mem_ctx, certificate_principal,
1562 ms_upn_check_attrs, &realm_dn, &msg);
1563
1564 if (ret != 0) {
1565 talloc_free(mem_ctx);
1566 return ret;
1567 }
1568
1569 orig_sid = samdb_result_dom_sid(mem_ctx, p->msg, "objectSid");
1570 target_sid = samdb_result_dom_sid(mem_ctx, msg, "objectSid");
1571
1572 /* Consider these to be the same principal, even if by a different
1573 * name. The easy and safe way to prove this is by SID
1574 * comparison */
1575 if (!(orig_sid && target_sid && dom_sid_equal(orig_sid, target_sid))) {
1576 talloc_free(mem_ctx);
1577 return KRB5_KDC_ERR_CLIENT_NAME_MISMATCH;
1578 }
1579
1580 talloc_free(mem_ctx);
1581 return ret;
1582 }
1583
1584 /* This interface is to be called by the KDC and libnet_keytab_dump, which is expecting Samba
1585 * calling conventions. It is also called by a wrapper
1586 * (hdb_samba4_create) from the kpasswdd -> krb5 -> keytab_hdb -> hdb
1587 * code */
1588
1589 NTSTATUS hdb_samba4_create_kdc(struct samba_kdc_base_context *base_ctx,
1590 krb5_context context, struct HDB **db)
1591 {
1592 struct samba_kdc_db_context *kdc_db_ctx;
1593 struct auth_session_info *session_info;
1594 NTSTATUS nt_status;
1595
1596 *db = talloc(base_ctx, HDB);
1597 if (!*db) {
1598 krb5_set_error_message(context, ENOMEM, "malloc: out of memory");
1599 return NT_STATUS_NO_MEMORY;
1600 }
1601
1602 (*db)->hdb_master_key_set = 0;
1603 (*db)->hdb_db = NULL;
1604 (*db)->hdb_capability_flags = 0;
1605
1606 #if 1
1607 /* we would prefer to use system_session(), as that would
1608 * allow us to share the samdb backend context with other parts of the
1609 * system. For now we can't as we need to override the
1610 * credentials to set CRED_DONT_USE_KERBEROS, which would
1611 * break other users of the system_session */
1612 DEBUG(0,("FIXME: Using new system session for hdb\n"));
1613 nt_status = auth_system_session_info(*db, base_ctx->lp_ctx, &session_info);
1614 if (!NT_STATUS_IS_OK(nt_status)) {
1615 return nt_status;
1616 }
1617 #else
1618 session_info = system_session(kdc_db_ctx->lp_ctx);
1619 if (session_info == NULL) {
1620 return NT_STATUS_INTERNAL_ERROR;
1621 }
1622 #endif
1623
1624 /* The idea here is very simple. Using Kerberos to
1625 * authenticate the KDC to the LDAP server is higly likely to
1626 * be circular.
1627 *
1628 * In future we may set this up to use EXERNAL and SSL
1629 * certificates, for now it will almost certainly be NTLMSSP_SET_USERNAME
1630 */
1631
1632 cli_credentials_set_kerberos_state(session_info->credentials,
1633 CRED_DONT_USE_KERBEROS);
1634
1635 kdc_db_ctx = talloc_zero(*db, struct samba_kdc_db_context);
1636 if (kdc_db_ctx == NULL) {
1637 return NT_STATUS_NO_MEMORY;
1638 }
1639 kdc_db_ctx->ev_ctx = base_ctx->ev_ctx;
1640 kdc_db_ctx->lp_ctx = base_ctx->lp_ctx;
1641 kdc_db_ctx->ic_ctx = lp_iconv_convenience(base_ctx->lp_ctx);
1642
1643 /* Setup the link to LDB */
1644 kdc_db_ctx->samdb = samdb_connect(kdc_db_ctx, base_ctx->ev_ctx,
1645 base_ctx->lp_ctx, session_info);
1646 if (kdc_db_ctx->samdb == NULL) {
1647 DEBUG(1, ("hdb_samba4_create: Cannot open samdb for KDC backend!"));
1648 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
1649 }
1650
1651 (*db)->hdb_db = kdc_db_ctx;
1652
1653 (*db)->hdb_dbc = NULL;
1654 (*db)->hdb_open = hdb_samba4_open;
1655 (*db)->hdb_close = hdb_samba4_close;
1656 (*db)->hdb_fetch = hdb_samba4_fetch;
1657 (*db)->hdb_store = hdb_samba4_store;
1658 (*db)->hdb_remove = hdb_samba4_remove;
1659 (*db)->hdb_firstkey = hdb_samba4_firstkey;
1660 (*db)->hdb_nextkey = hdb_samba4_nextkey;
1661 (*db)->hdb_lock = hdb_samba4_lock;
1662 (*db)->hdb_unlock = hdb_samba4_unlock;
1663 (*db)->hdb_rename = hdb_samba4_rename;
1664 /* we don't implement these, as we are not a lockable database */
1665 (*db)->hdb__get = NULL;
1666 (*db)->hdb__put = NULL;
1667 /* kadmin should not be used for deletes - use other tools instead */
1668 (*db)->hdb__del = NULL;
1669 (*db)->hdb_destroy = hdb_samba4_destroy;
1670
1671 (*db)->hdb_auth_status = NULL;
1672 (*db)->hdb_check_constrained_delegation = hdb_samba4_check_constrained_delegation;
1673 (*db)->hdb_check_pkinit_ms_upn_match = hdb_samba4_check_pkinit_ms_upn_match;
1674
1675 return NT_STATUS_OK;
1676 }
1677
1678 static krb5_error_code hdb_samba4_create(krb5_context context, struct HDB **db, const char *arg)
1679 {
1680 NTSTATUS nt_status;
1681 void *ptr;
1682 struct samba_kdc_base_context *base_ctx;
1683
1684 if (sscanf(arg, "&%p", &ptr) != 1) {
1685 return EINVAL;
1686 }
1687 base_ctx = talloc_get_type_abort(ptr, struct samba_kdc_base_context);
1688 /* The global kdc_mem_ctx and kdc_lp_ctx, Disgusting, ugly hack, but it means one less private hook */
1689 nt_status = hdb_samba4_create_kdc(base_ctx, context, db);
1690
1691 if (NT_STATUS_IS_OK(nt_status)) {
1692 return 0;
1693 }
1694 return EINVAL;
1695 }
1696
1697 /* Only used in the hdb-backed keytab code
1698 * for a keytab of 'samba4&<address>', to find
1699 * kpasswd's key in the main DB, and to
1700 * copy all the keys into a file (libnet_keytab_export)
1701 *
1702 * The <address> is the string form of a pointer to a talloced struct hdb_samba_context
1703 */
1704 struct hdb_method hdb_samba4 = {
1705 .interface_version = HDB_INTERFACE_VERSION,
1706 .prefix = "samba4",
1707 .create = hdb_samba4_create
1708 };
fernandojvsilva's samba4 branch