?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
CVE-2014-8143:dsdb-samldb: Check for extended access rights before we allow changes...
[Samba.git] / source4 / dsdb / samdb / ldb_modules / samldb.c
blob20f593297ab96073afd9abb455754599a280ddd0
1 /*
2 SAM ldb module
3
4 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
5 Copyright (C) Simo Sorce 2004-2008
6 Copyright (C) Matthias Dieter Wallnöfer 2009-2011
7 Copyright (C) Matthieu Patou 2012
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 /*
24 * Name: ldb
25 *
26 * Component: ldb samldb module
27 *
28 * Description: various internal DSDB triggers - most for SAM specific objects
29 *
30 * Author: Simo Sorce
31 */
32
33 #include "includes.h"
34 #include "libcli/ldap/ldap_ndr.h"
35 #include "ldb_module.h"
36 #include "auth/auth.h"
37 #include "dsdb/samdb/samdb.h"
38 #include "dsdb/samdb/ldb_modules/util.h"
39 #include "dsdb/samdb/ldb_modules/ridalloc.h"
40 #include "libcli/security/security.h"
41 #include "librpc/gen_ndr/ndr_security.h"
42 #include "ldb_wrap.h"
43 #include "param/param.h"
44 #include "libds/common/flag_mapping.h"
45
46 struct samldb_ctx;
47 enum samldb_add_type {
48 SAMLDB_TYPE_USER,
49 SAMLDB_TYPE_GROUP,
50 SAMLDB_TYPE_CLASS,
51 SAMLDB_TYPE_ATTRIBUTE
52 };
53
54 typedef int (*samldb_step_fn_t)(struct samldb_ctx *);
55
56 struct samldb_step {
57 struct samldb_step *next;
58 samldb_step_fn_t fn;
59 };
60
61 struct samldb_ctx {
62 struct ldb_module *module;
63 struct ldb_request *req;
64
65 /* used for add operations */
66 enum samldb_add_type type;
67
68 /* the resulting message */
69 struct ldb_message *msg;
70
71 /* used in "samldb_find_for_defaultObjectCategory" */
72 struct ldb_dn *dn, *res_dn;
73
74 /* all the async steps necessary to complete the operation */
75 struct samldb_step *steps;
76 struct samldb_step *curstep;
77
78 /* If someone set an ares to forward controls and response back to the caller */
79 struct ldb_reply *ares;
80 };
81
82 static struct samldb_ctx *samldb_ctx_init(struct ldb_module *module,
83 struct ldb_request *req)
84 {
85 struct ldb_context *ldb;
86 struct samldb_ctx *ac;
87
88 ldb = ldb_module_get_ctx(module);
89
90 ac = talloc_zero(req, struct samldb_ctx);
91 if (ac == NULL) {
92 ldb_oom(ldb);
93 return NULL;
94 }
95
96 ac->module = module;
97 ac->req = req;
98
99 return ac;
100 }
101
102 static int samldb_add_step(struct samldb_ctx *ac, samldb_step_fn_t fn)
103 {
104 struct samldb_step *step, *stepper;
105
106 step = talloc_zero(ac, struct samldb_step);
107 if (step == NULL) {
108 return ldb_oom(ldb_module_get_ctx(ac->module));
109 }
110
111 step->fn = fn;
112
113 if (ac->steps == NULL) {
114 ac->steps = step;
115 ac->curstep = step;
116 } else {
117 if (ac->curstep == NULL)
118 return ldb_operr(ldb_module_get_ctx(ac->module));
119 for (stepper = ac->curstep; stepper->next != NULL;
120 stepper = stepper->next);
121 stepper->next = step;
122 }
123
124 return LDB_SUCCESS;
125 }
126
127 static int samldb_first_step(struct samldb_ctx *ac)
128 {
129 if (ac->steps == NULL) {
130 return ldb_operr(ldb_module_get_ctx(ac->module));
131 }
132
133 ac->curstep = ac->steps;
134 return ac->curstep->fn(ac);
135 }
136
137 static int samldb_next_step(struct samldb_ctx *ac)
138 {
139 if (ac->curstep->next) {
140 ac->curstep = ac->curstep->next;
141 return ac->curstep->fn(ac);
142 }
143
144 /* We exit the samldb module here. If someone set an "ares" to forward
145 * controls and response back to the caller, use them. */
146 if (ac->ares) {
147 return ldb_module_done(ac->req, ac->ares->controls,
148 ac->ares->response, LDB_SUCCESS);
149 } else {
150 return ldb_module_done(ac->req, NULL, NULL, LDB_SUCCESS);
151 }
152 }
153
154
155 /* sAMAccountName handling */
156
157 static int samldb_generate_sAMAccountName(struct ldb_context *ldb,
158 struct ldb_message *msg)
159 {
160 char *name;
161
162 /* Format: $000000-000000000000 */
163
164 name = talloc_asprintf(msg, "$%.6X-%.6X%.6X",
165 (unsigned int)generate_random(),
166 (unsigned int)generate_random(),
167 (unsigned int)generate_random());
168 if (name == NULL) {
169 return ldb_oom(ldb);
170 }
171 return ldb_msg_add_steal_string(msg, "sAMAccountName", name);
172 }
173
174 static int samldb_check_sAMAccountName(struct samldb_ctx *ac)
175 {
176 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
177 const char *name;
178 int ret;
179 struct ldb_result *res;
180 const char * const noattrs[] = { NULL };
181
182 if (ldb_msg_find_element(ac->msg, "sAMAccountName") == NULL) {
183 ret = samldb_generate_sAMAccountName(ldb, ac->msg);
184 if (ret != LDB_SUCCESS) {
185 return ret;
186 }
187 }
188
189 name = ldb_msg_find_attr_as_string(ac->msg, "sAMAccountName", NULL);
190 if (name == NULL) {
191 /* The "sAMAccountName" cannot be nothing */
192 ldb_set_errstring(ldb,
193 "samldb: Empty account names aren't allowed!");
194 return LDB_ERR_CONSTRAINT_VIOLATION;
195 }
196
197 ret = dsdb_module_search(ac->module, ac, &res,
198 ldb_get_default_basedn(ldb), LDB_SCOPE_SUBTREE, noattrs,
199 DSDB_FLAG_NEXT_MODULE,
200 ac->req,
201 "(sAMAccountName=%s)",
202 ldb_binary_encode_string(ac, name));
203 if (ret != LDB_SUCCESS) {
204 return ret;
205 }
206 if (res->count != 0) {
207 ldb_asprintf_errstring(ldb,
208 "samldb: Account name (sAMAccountName) '%s' already in use!",
209 name);
210 talloc_free(res);
211 return LDB_ERR_ENTRY_ALREADY_EXISTS;
212 }
213 talloc_free(res);
214
215 return samldb_next_step(ac);
216 }
217
218
219 static bool samldb_msg_add_sid(struct ldb_message *msg,
220 const char *name,
221 const struct dom_sid *sid)
222 {
223 struct ldb_val v;
224 enum ndr_err_code ndr_err;
225
226 ndr_err = ndr_push_struct_blob(&v, msg, sid,
227 (ndr_push_flags_fn_t)ndr_push_dom_sid);
228 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
229 return false;
230 }
231 return (ldb_msg_add_value(msg, name, &v, NULL) == 0);
232 }
233
234
235 /* allocate a SID using our RID Set */
236 static int samldb_allocate_sid(struct samldb_ctx *ac)
237 {
238 uint32_t rid;
239 struct dom_sid *sid;
240 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
241 int ret;
242
243 ret = ridalloc_allocate_rid(ac->module, &rid, ac->req);
244 if (ret != LDB_SUCCESS) {
245 return ret;
246 }
247
248 sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
249 if (sid == NULL) {
250 return ldb_module_oom(ac->module);
251 }
252
253 if ( ! samldb_msg_add_sid(ac->msg, "objectSid", sid)) {
254 return ldb_operr(ldb);
255 }
256
257 return samldb_next_step(ac);
258 }
259
260 /*
261 see if a krbtgt_number is available
262 */
263 static bool samldb_krbtgtnumber_available(struct samldb_ctx *ac,
264 uint32_t krbtgt_number)
265 {
266 TALLOC_CTX *tmp_ctx = talloc_new(ac);
267 struct ldb_result *res;
268 const char * const no_attrs[] = { NULL };
269 int ret;
270
271 ret = dsdb_module_search(ac->module, tmp_ctx, &res,
272 ldb_get_default_basedn(ldb_module_get_ctx(ac->module)),
273 LDB_SCOPE_SUBTREE, no_attrs,
274 DSDB_FLAG_NEXT_MODULE,
275 ac->req,
276 "(msDC-SecondaryKrbTgtNumber=%u)",
277 krbtgt_number);
278 if (ret == LDB_SUCCESS && res->count == 0) {
279 talloc_free(tmp_ctx);
280 return true;
281 }
282 talloc_free(tmp_ctx);
283 return false;
284 }
285
286 /* special handling for add in RODC join */
287 static int samldb_rodc_add(struct samldb_ctx *ac)
288 {
289 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
290 uint32_t krbtgt_number, i_start, i;
291 int ret;
292 char *newpass;
293 struct ldb_val newpass_utf16;
294
295 /* find a unused msDC-SecondaryKrbTgtNumber */
296 i_start = generate_random() & 0xFFFF;
297 if (i_start == 0) {
298 i_start = 1;
299 }
300
301 for (i=i_start; i<=0xFFFF; i++) {
302 if (samldb_krbtgtnumber_available(ac, i)) {
303 krbtgt_number = i;
304 goto found;
305 }
306 }
307 for (i=1; i<i_start; i++) {
308 if (samldb_krbtgtnumber_available(ac, i)) {
309 krbtgt_number = i;
310 goto found;
311 }
312 }
313
314 ldb_asprintf_errstring(ldb,
315 "%08X: Unable to find available msDS-SecondaryKrbTgtNumber",
316 W_ERROR_V(WERR_NO_SYSTEM_RESOURCES));
317 return LDB_ERR_OTHER;
318
319 found:
320 ret = ldb_msg_add_empty(ac->msg, "msDS-SecondaryKrbTgtNumber",
321 LDB_FLAG_INTERNAL_DISABLE_VALIDATION, NULL);
322 if (ret != LDB_SUCCESS) {
323 return ldb_operr(ldb);
324 }
325
326 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg,
327 "msDS-SecondaryKrbTgtNumber", krbtgt_number);
328 if (ret != LDB_SUCCESS) {
329 return ldb_operr(ldb);
330 }
331
332 ret = ldb_msg_add_fmt(ac->msg, "sAMAccountName", "krbtgt_%u",
333 krbtgt_number);
334 if (ret != LDB_SUCCESS) {
335 return ldb_operr(ldb);
336 }
337
338 newpass = generate_random_password(ac->msg, 128, 255);
339 if (newpass == NULL) {
340 return ldb_operr(ldb);
341 }
342
343 if (!convert_string_talloc(ac,
344 CH_UNIX, CH_UTF16,
345 newpass, strlen(newpass),
346 (void *)&newpass_utf16.data,
347 &newpass_utf16.length)) {
348 ldb_asprintf_errstring(ldb,
349 "samldb_rodc_add: "
350 "failed to generate UTF16 password from random password");
351 return LDB_ERR_OPERATIONS_ERROR;
352 }
353 ret = ldb_msg_add_steal_value(ac->msg, "clearTextPassword", &newpass_utf16);
354 if (ret != LDB_SUCCESS) {
355 return ldb_operr(ldb);
356 }
357
358 return samldb_next_step(ac);
359 }
360
361 static int samldb_find_for_defaultObjectCategory(struct samldb_ctx *ac)
362 {
363 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
364 struct ldb_result *res;
365 const char * const no_attrs[] = { NULL };
366 int ret;
367
368 ac->res_dn = NULL;
369
370 ret = dsdb_module_search(ac->module, ac, &res,
371 ac->dn, LDB_SCOPE_BASE, no_attrs,
372 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT
373 | DSDB_FLAG_NEXT_MODULE,
374 ac->req,
375 "(objectClass=classSchema)");
376 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
377 /* Don't be pricky when the DN doesn't exist if we have the */
378 /* RELAX control specified */
379 if (ldb_request_get_control(ac->req,
380 LDB_CONTROL_RELAX_OID) == NULL) {
381 ldb_set_errstring(ldb,
382 "samldb_find_defaultObjectCategory: "
383 "Invalid DN for 'defaultObjectCategory'!");
384 return LDB_ERR_CONSTRAINT_VIOLATION;
385 }
386 }
387 if ((ret != LDB_ERR_NO_SUCH_OBJECT) && (ret != LDB_SUCCESS)) {
388 return ret;
389 }
390
391 if (ret == LDB_SUCCESS) {
392 /* ensure the defaultObjectCategory has a full GUID */
393 struct ldb_message *m;
394 m = ldb_msg_new(ac->msg);
395 if (m == NULL) {
396 return ldb_oom(ldb);
397 }
398 m->dn = ac->msg->dn;
399 if (ldb_msg_add_string(m, "defaultObjectCategory",
400 ldb_dn_get_extended_linearized(m, res->msgs[0]->dn, 1)) !=
401 LDB_SUCCESS) {
402 return ldb_oom(ldb);
403 }
404 m->elements[0].flags = LDB_FLAG_MOD_REPLACE;
405
406 ret = dsdb_module_modify(ac->module, m,
407 DSDB_FLAG_NEXT_MODULE,
408 ac->req);
409 if (ret != LDB_SUCCESS) {
410 return ret;
411 }
412 }
413
414
415 ac->res_dn = ac->dn;
416
417 return samldb_next_step(ac);
418 }
419
420 /**
421 * msDS-IntId attributeSchema attribute handling
422 * during LDB_ADD request processing
423 */
424 static int samldb_add_handle_msDS_IntId(struct samldb_ctx *ac)
425 {
426 int ret;
427 bool id_exists;
428 uint32_t msds_intid;
429 int32_t system_flags;
430 struct ldb_context *ldb;
431 struct ldb_result *ldb_res;
432 struct ldb_dn *schema_dn;
433 struct samldb_msds_intid_persistant *msds_intid_struct;
434 struct dsdb_schema *schema;
435
436 ldb = ldb_module_get_ctx(ac->module);
437 schema_dn = ldb_get_schema_basedn(ldb);
438
439 /* replicated update should always go through */
440 if (ldb_request_get_control(ac->req,
441 DSDB_CONTROL_REPLICATED_UPDATE_OID)) {
442 return LDB_SUCCESS;
443 }
444
445 /* msDS-IntId is handled by system and should never be
446 * passed by clients */
447 if (ldb_msg_find_element(ac->msg, "msDS-IntId")) {
448 return LDB_ERR_UNWILLING_TO_PERFORM;
449 }
450
451 /* do not generate msDS-IntId if Relax control is passed */
452 if (ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID)) {
453 return LDB_SUCCESS;
454 }
455
456 /* check Functional Level */
457 if (dsdb_functional_level(ldb) < DS_DOMAIN_FUNCTION_2003) {
458 return LDB_SUCCESS;
459 }
460
461 /* check systemFlags for SCHEMA_BASE_OBJECT flag */
462 system_flags = ldb_msg_find_attr_as_int(ac->msg, "systemFlags", 0);
463 if (system_flags & SYSTEM_FLAG_SCHEMA_BASE_OBJECT) {
464 return LDB_SUCCESS;
465 }
466 schema = dsdb_get_schema(ldb, NULL);
467 if (!schema) {
468 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
469 "samldb_schema_info_update: no dsdb_schema loaded");
470 DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
471 return ldb_operr(ldb);
472 }
473
474 msds_intid_struct = (struct samldb_msds_intid_persistant*) ldb_get_opaque(ldb, SAMLDB_MSDS_INTID_OPAQUE);
475 if (!msds_intid_struct) {
476 msds_intid_struct = talloc(ldb, struct samldb_msds_intid_persistant);
477 /* Generate new value for msDs-IntId
478 * Value should be in 0x80000000..0xBFFFFFFF range */
479 msds_intid = generate_random() % 0X3FFFFFFF;
480 msds_intid += 0x80000000;
481 msds_intid_struct->msds_intid = msds_intid;
482 msds_intid_struct->usn = schema->loaded_usn;
483 DEBUG(2, ("No samldb_msds_intid_persistant struct, allocating a new one\n"));
484 } else {
485 msds_intid = msds_intid_struct->msds_intid;
486 }
487
488 /* probe id values until unique one is found */
489 do {
490 uint64_t current_usn;
491 msds_intid++;
492 if (msds_intid > 0xBFFFFFFF) {
493 msds_intid = 0x80000001;
494 }
495 /*
496 * Alternative strategy to a costly (even indexed search) to the
497 * database.
498 * We search in the schema if we have already this intid (using dsdb_attribute_by_attributeID_id because
499 * in the range 0x80000000 0xBFFFFFFFF, attributeID is a DSDB_ATTID_TYPE_INTID).
500 * If so generate another random value.
501 * If not check if the highest USN in the database for the schema partition is the
502 * one that we know.
503 * If so it means that's only this ldb context that is touching the schema in the database.
504 * If not it means that's someone else has modified the database while we are doing our changes too
505 * (this case should be very bery rare) in order to be sure do the search in the database.
506 */
507 if (dsdb_attribute_by_attributeID_id(schema, msds_intid)) {
508 msds_intid = generate_random() % 0X3FFFFFFF;
509 msds_intid += 0x80000000;
510 continue;
511 }
512
513 ret = dsdb_module_load_partition_usn(ac->module, schema->base_dn, &current_usn, NULL, NULL);
514 if (ret != LDB_SUCCESS) {
515 ldb_debug_set(ldb, LDB_DEBUG_ERROR,
516 __location__": Searching for schema USN failed: %s\n",
517 ldb_errstring(ldb));
518 return ldb_operr(ldb);
519 }
520
521 /* current_usn can be lesser than msds_intid_struct-> if there is
522 * uncommited changes.
523 */
524 if (current_usn > msds_intid_struct->usn) {
525 /* oups something has changed, someone/something
526 * else is modifying or has modified the schema
527 * we'd better check this intid is the database directly
528 */
529
530 DEBUG(2, ("Schema has changed, searching the database for the unicity of %d\n",
531 msds_intid));
532
533 ret = dsdb_module_search(ac->module, ac,
534 &ldb_res,
535 schema_dn, LDB_SCOPE_ONELEVEL, NULL,
536 DSDB_FLAG_NEXT_MODULE,
537 ac->req,
538 "(msDS-IntId=%d)", msds_intid);
539 if (ret != LDB_SUCCESS) {
540 ldb_debug_set(ldb, LDB_DEBUG_ERROR,
541 __location__": Searching for msDS-IntId=%d failed - %s\n",
542 msds_intid,
543 ldb_errstring(ldb));
544 return ldb_operr(ldb);
545 }
546 id_exists = (ldb_res->count > 0);
547 talloc_free(ldb_res);
548 } else {
549 id_exists = 0;
550 }
551
552 } while(id_exists);
553 msds_intid_struct->msds_intid = msds_intid;
554 ldb_set_opaque(ldb, SAMLDB_MSDS_INTID_OPAQUE, msds_intid_struct);
555
556 return samdb_msg_add_int(ldb, ac->msg, ac->msg, "msDS-IntId",
557 msds_intid);
558 }
559
560
561 /*
562 * samldb_add_entry (async)
563 */
564
565 static int samldb_add_entry_callback(struct ldb_request *req,
566 struct ldb_reply *ares)
567 {
568 struct ldb_context *ldb;
569 struct samldb_ctx *ac;
570 int ret;
571
572 ac = talloc_get_type(req->context, struct samldb_ctx);
573 ldb = ldb_module_get_ctx(ac->module);
574
575 if (!ares) {
576 return ldb_module_done(ac->req, NULL, NULL,
577 LDB_ERR_OPERATIONS_ERROR);
578 }
579
580 if (ares->type == LDB_REPLY_REFERRAL) {
581 return ldb_module_send_referral(ac->req, ares->referral);
582 }
583
584 if (ares->error != LDB_SUCCESS) {
585 return ldb_module_done(ac->req, ares->controls,
586 ares->response, ares->error);
587 }
588 if (ares->type != LDB_REPLY_DONE) {
589 ldb_asprintf_errstring(ldb, "Invalid LDB reply type %d", ares->type);
590 return ldb_module_done(ac->req, NULL, NULL,
591 LDB_ERR_OPERATIONS_ERROR);
592 }
593
594 /* The caller may wish to get controls back from the add */
595 ac->ares = talloc_steal(ac, ares);
596
597 ret = samldb_next_step(ac);
598 if (ret != LDB_SUCCESS) {
599 return ldb_module_done(ac->req, NULL, NULL, ret);
600 }
601 return ret;
602 }
603
604 static int samldb_add_entry(struct samldb_ctx *ac)
605 {
606 struct ldb_context *ldb;
607 struct ldb_request *req;
608 int ret;
609
610 ldb = ldb_module_get_ctx(ac->module);
611
612 ret = ldb_build_add_req(&req, ldb, ac,
613 ac->msg,
614 ac->req->controls,
615 ac, samldb_add_entry_callback,
616 ac->req);
617 LDB_REQ_SET_LOCATION(req);
618 if (ret != LDB_SUCCESS) {
619 return ret;
620 }
621
622 return ldb_next_request(ac->module, req);
623 }
624
625 /*
626 * return true if msg carries an attributeSchema that is intended to be RODC
627 * filtered but is also a system-critical attribute.
628 */
629 static bool check_rodc_critical_attribute(struct ldb_message *msg)
630 {
631 uint32_t schemaFlagsEx, searchFlags, rodc_filtered_flags;
632
633 schemaFlagsEx = ldb_msg_find_attr_as_uint(msg, "schemaFlagsEx", 0);
634 searchFlags = ldb_msg_find_attr_as_uint(msg, "searchFlags", 0);
635 rodc_filtered_flags = (SEARCH_FLAG_RODC_ATTRIBUTE
636 | SEARCH_FLAG_CONFIDENTIAL);
637
638 if ((schemaFlagsEx & SCHEMA_FLAG_ATTR_IS_CRITICAL) &&
639 ((searchFlags & rodc_filtered_flags) == rodc_filtered_flags)) {
640 return true;
641 } else {
642 return false;
643 }
644 }
645
646
647 static int samldb_fill_object(struct samldb_ctx *ac)
648 {
649 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
650 int ret;
651
652 /* Add information for the different account types */
653 switch(ac->type) {
654 case SAMLDB_TYPE_USER: {
655 struct ldb_control *rodc_control = ldb_request_get_control(ac->req,
656 LDB_CONTROL_RODC_DCPROMO_OID);
657 if (rodc_control != NULL) {
658 /* see [MS-ADTS] 3.1.1.3.4.1.23 LDAP_SERVER_RODC_DCPROMO_OID */
659 rodc_control->critical = false;
660 ret = samldb_add_step(ac, samldb_rodc_add);
661 if (ret != LDB_SUCCESS) return ret;
662 }
663
664 /* check if we have a valid sAMAccountName */
665 ret = samldb_add_step(ac, samldb_check_sAMAccountName);
666 if (ret != LDB_SUCCESS) return ret;
667
668 ret = samldb_add_step(ac, samldb_add_entry);
669 if (ret != LDB_SUCCESS) return ret;
670 break;
671 }
672
673 case SAMLDB_TYPE_GROUP: {
674 /* check if we have a valid sAMAccountName */
675 ret = samldb_add_step(ac, samldb_check_sAMAccountName);
676 if (ret != LDB_SUCCESS) return ret;
677
678 ret = samldb_add_step(ac, samldb_add_entry);
679 if (ret != LDB_SUCCESS) return ret;
680 break;
681 }
682
683 case SAMLDB_TYPE_CLASS: {
684 const struct ldb_val *rdn_value, *def_obj_cat_val;
685 unsigned int v = ldb_msg_find_attr_as_uint(ac->msg, "objectClassCategory", -2);
686
687 /* As discussed with Microsoft through dochelp in April 2012 this is the behavior of windows*/
688 if (!ldb_msg_find_element(ac->msg, "subClassOf")) {
689 ret = ldb_msg_add_string(ac->msg, "subClassOf", "top");
690 if (ret != LDB_SUCCESS) return ret;
691 }
692
693 ret = samdb_find_or_add_attribute(ldb, ac->msg,
694 "rdnAttId", "cn");
695 if (ret != LDB_SUCCESS) return ret;
696
697 /* do not allow to mark an attributeSchema as RODC filtered if it
698 * is system-critical */
699 if (check_rodc_critical_attribute(ac->msg)) {
700 ldb_asprintf_errstring(ldb, "Refusing schema add of %s - cannot combine critical class with RODC filtering",
701 ldb_dn_get_linearized(ac->msg->dn));
702 return LDB_ERR_UNWILLING_TO_PERFORM;
703 }
704
705 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
706 if (rdn_value == NULL) {
707 return ldb_operr(ldb);
708 }
709 if (!ldb_msg_find_element(ac->msg, "lDAPDisplayName")) {
710 /* the RDN has prefix "CN" */
711 ret = ldb_msg_add_string(ac->msg, "lDAPDisplayName",
712 samdb_cn_to_lDAPDisplayName(ac->msg,
713 (const char *) rdn_value->data));
714 if (ret != LDB_SUCCESS) {
715 ldb_oom(ldb);
716 return ret;
717 }
718 }
719
720 if (!ldb_msg_find_element(ac->msg, "schemaIDGUID")) {
721 struct GUID guid;
722 /* a new GUID */
723 guid = GUID_random();
724 ret = dsdb_msg_add_guid(ac->msg, &guid, "schemaIDGUID");
725 if (ret != LDB_SUCCESS) {
726 ldb_oom(ldb);
727 return ret;
728 }
729 }
730
731 def_obj_cat_val = ldb_msg_find_ldb_val(ac->msg,
732 "defaultObjectCategory");
733 if (def_obj_cat_val != NULL) {
734 /* "defaultObjectCategory" has been set by the caller.
735 * Do some checks for consistency.
736 * NOTE: The real constraint check (that
737 * 'defaultObjectCategory' is the DN of the new
738 * objectclass or any parent of it) is still incomplete.
739 * For now we say that 'defaultObjectCategory' is valid
740 * if it exists and it is of objectclass "classSchema".
741 */
742 ac->dn = ldb_dn_from_ldb_val(ac, ldb, def_obj_cat_val);
743 if (ac->dn == NULL) {
744 ldb_set_errstring(ldb,
745 "Invalid DN for 'defaultObjectCategory'!");
746 return LDB_ERR_CONSTRAINT_VIOLATION;
747 }
748 } else {
749 /* "defaultObjectCategory" has not been set by the
750 * caller. Use the entry DN for it. */
751 ac->dn = ac->msg->dn;
752
753 ret = ldb_msg_add_string(ac->msg, "defaultObjectCategory",
754 ldb_dn_alloc_linearized(ac->msg, ac->dn));
755 if (ret != LDB_SUCCESS) {
756 ldb_oom(ldb);
757 return ret;
758 }
759 }
760
761 ret = samldb_add_step(ac, samldb_add_entry);
762 if (ret != LDB_SUCCESS) return ret;
763
764 /* Now perform the checks for the 'defaultObjectCategory'. The
765 * lookup DN was already saved in "ac->dn" */
766 ret = samldb_add_step(ac, samldb_find_for_defaultObjectCategory);
767 if (ret != LDB_SUCCESS) return ret;
768
769 /* -2 is not a valid objectClassCategory so it means the attribute wasn't present */
770 if (v == -2) {
771 /* Windows 2003 does this*/
772 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg, "objectClassCategory", 0);
773 if (ret != LDB_SUCCESS) {
774 return ret;
775 }
776 }
777 break;
778 }
779
780 case SAMLDB_TYPE_ATTRIBUTE: {
781 const struct ldb_val *rdn_value;
782 struct ldb_message_element *el;
783 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
784 if (rdn_value == NULL) {
785 return ldb_operr(ldb);
786 }
787 if (!ldb_msg_find_element(ac->msg, "lDAPDisplayName")) {
788 /* the RDN has prefix "CN" */
789 ret = ldb_msg_add_string(ac->msg, "lDAPDisplayName",
790 samdb_cn_to_lDAPDisplayName(ac->msg,
791 (const char *) rdn_value->data));
792 if (ret != LDB_SUCCESS) {
793 ldb_oom(ldb);
794 return ret;
795 }
796 }
797
798 /* do not allow to mark an attributeSchema as RODC filtered if it
799 * is system-critical */
800 if (check_rodc_critical_attribute(ac->msg)) {
801 ldb_asprintf_errstring(ldb,
802 "samldb: refusing schema add of %s - cannot combine critical attribute with RODC filtering",
803 ldb_dn_get_linearized(ac->msg->dn));
804 return LDB_ERR_UNWILLING_TO_PERFORM;
805 }
806
807 ret = samdb_find_or_add_attribute(ldb, ac->msg,
808 "isSingleValued", "FALSE");
809 if (ret != LDB_SUCCESS) return ret;
810
811 if (!ldb_msg_find_element(ac->msg, "schemaIDGUID")) {
812 struct GUID guid;
813 /* a new GUID */
814 guid = GUID_random();
815 ret = dsdb_msg_add_guid(ac->msg, &guid, "schemaIDGUID");
816 if (ret != LDB_SUCCESS) {
817 ldb_oom(ldb);
818 return ret;
819 }
820 }
821
822 el = ldb_msg_find_element(ac->msg, "attributeSyntax");
823 if (el) {
824 /*
825 * No need to scream if there isn't as we have code later on
826 * that will take care of it.
827 */
828 const struct dsdb_syntax *syntax = find_syntax_map_by_ad_oid((const char *)el->values[0].data);
829 if (!syntax) {
830 DEBUG(9, ("Can't find dsdb_syntax object for attributeSyntax %s\n",
831 (const char *)el->values[0].data));
832 } else {
833 unsigned int v = ldb_msg_find_attr_as_uint(ac->msg, "oMSyntax", 0);
834 const struct ldb_val *val = ldb_msg_find_ldb_val(ac->msg, "oMObjectClass");
835
836 if (v == 0) {
837 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg, "oMSyntax", syntax->oMSyntax);
838 if (ret != LDB_SUCCESS) {
839 return ret;
840 }
841 }
842 if (!val) {
843 struct ldb_val val2 = ldb_val_dup(ldb, &syntax->oMObjectClass);
844 if (val2.length > 0) {
845 ret = ldb_msg_add_value(ac->msg, "oMObjectClass", &val2, NULL);
846 if (ret != LDB_SUCCESS) {
847 return ret;
848 }
849 }
850 }
851 }
852 }
853
854 /* handle msDS-IntID attribute */
855 ret = samldb_add_handle_msDS_IntId(ac);
856 if (ret != LDB_SUCCESS) return ret;
857
858 ret = samldb_add_step(ac, samldb_add_entry);
859 if (ret != LDB_SUCCESS) return ret;
860 break;
861 }
862
863 default:
864 ldb_asprintf_errstring(ldb, "Invalid entry type!");
865 return LDB_ERR_OPERATIONS_ERROR;
866 break;
867 }
868
869 return samldb_first_step(ac);
870 }
871
872 static int samldb_fill_foreignSecurityPrincipal_object(struct samldb_ctx *ac)
873 {
874 struct ldb_context *ldb;
875 const struct ldb_val *rdn_value;
876 struct dom_sid *sid;
877 int ret;
878
879 ldb = ldb_module_get_ctx(ac->module);
880
881 sid = samdb_result_dom_sid(ac->msg, ac->msg, "objectSid");
882 if (sid == NULL) {
883 rdn_value = ldb_dn_get_rdn_val(ac->msg->dn);
884 if (rdn_value == NULL) {
885 return ldb_operr(ldb);
886 }
887 sid = dom_sid_parse_talloc(ac->msg,
888 (const char *)rdn_value->data);
889 if (sid == NULL) {
890 ldb_set_errstring(ldb,
891 "samldb: No valid SID found in ForeignSecurityPrincipal CN!");
892 return LDB_ERR_CONSTRAINT_VIOLATION;
893 }
894 if (! samldb_msg_add_sid(ac->msg, "objectSid", sid)) {
895 return ldb_operr(ldb);
896 }
897 }
898
899 /* finally proceed with adding the entry */
900 ret = samldb_add_step(ac, samldb_add_entry);
901 if (ret != LDB_SUCCESS) return ret;
902
903 return samldb_first_step(ac);
904 }
905
906 static int samldb_schema_info_update(struct samldb_ctx *ac)
907 {
908 int ret;
909 struct ldb_context *ldb;
910 struct dsdb_schema *schema;
911
912 /* replicated update should always go through */
913 if (ldb_request_get_control(ac->req,
914 DSDB_CONTROL_REPLICATED_UPDATE_OID)) {
915 return LDB_SUCCESS;
916 }
917
918 /* do not update schemaInfo during provisioning */
919 if (ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID)) {
920 return LDB_SUCCESS;
921 }
922
923 ldb = ldb_module_get_ctx(ac->module);
924 schema = dsdb_get_schema(ldb, NULL);
925 if (!schema) {
926 ldb_debug_set(ldb, LDB_DEBUG_FATAL,
927 "samldb_schema_info_update: no dsdb_schema loaded");
928 DEBUG(0,(__location__ ": %s\n", ldb_errstring(ldb)));
929 return ldb_operr(ldb);
930 }
931
932 ret = dsdb_module_schema_info_update(ac->module, schema,
933 DSDB_FLAG_NEXT_MODULE|
934 DSDB_FLAG_AS_SYSTEM,
935 ac->req);
936 if (ret != LDB_SUCCESS) {
937 ldb_asprintf_errstring(ldb,
938 "samldb_schema_info_update: dsdb_module_schema_info_update failed with %s",
939 ldb_errstring(ldb));
940 return ret;
941 }
942
943 return LDB_SUCCESS;
944 }
945
946 static int samldb_prim_group_tester(struct samldb_ctx *ac, uint32_t rid);
947 static int samldb_check_user_account_control_acl(struct samldb_ctx *ac,
948 struct dom_sid *sid,
949 uint32_t user_account_control,
950 uint32_t user_account_control_old);
951
952 /*
953 * "Objectclass" trigger (MS-SAMR 3.1.1.8.1)
954 *
955 * Has to be invoked on "add" and "modify" operations on "user", "computer" and
956 * "group" objects.
957 * ac->msg contains the "add"/"modify" message
958 * ac->type contains the object type (main objectclass)
959 */
960 static int samldb_objectclass_trigger(struct samldb_ctx *ac)
961 {
962 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
963 void *skip_allocate_sids = ldb_get_opaque(ldb,
964 "skip_allocate_sids");
965 struct ldb_message_element *el, *el2;
966 struct dom_sid *sid;
967 int ret;
968
969 /* make sure that "sAMAccountType" is not specified */
970 el = ldb_msg_find_element(ac->msg, "sAMAccountType");
971 if (el != NULL) {
972 ldb_set_errstring(ldb,
973 "samldb: sAMAccountType must not be specified!");
974 return LDB_ERR_UNWILLING_TO_PERFORM;
975 }
976
977 /* Step 1: objectSid assignment */
978
979 /* Don't allow the objectSid to be changed. But beside the RELAX
980 * control we have also to guarantee that it can always be set with
981 * SYSTEM permissions. This is needed for the "samba3sam" backend. */
982 sid = samdb_result_dom_sid(ac, ac->msg, "objectSid");
983 if ((sid != NULL) && (!dsdb_module_am_system(ac->module)) &&
984 (ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID) == NULL)) {
985 ldb_set_errstring(ldb,
986 "samldb: objectSid must not be specified!");
987 return LDB_ERR_UNWILLING_TO_PERFORM;
988 }
989
990 /* but generate a new SID when we do have an add operations */
991 if ((sid == NULL) && (ac->req->operation == LDB_ADD) && !skip_allocate_sids) {
992 ret = samldb_add_step(ac, samldb_allocate_sid);
993 if (ret != LDB_SUCCESS) return ret;
994 }
995
996 switch(ac->type) {
997 case SAMLDB_TYPE_USER: {
998 bool uac_generated = false;
999
1000 /* Step 1.2: Default values */
1001 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1002 "accountExpires", "9223372036854775807");
1003 if (ret != LDB_SUCCESS) return ret;
1004 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1005 "badPasswordTime", "0");
1006 if (ret != LDB_SUCCESS) return ret;
1007 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1008 "badPwdCount", "0");
1009 if (ret != LDB_SUCCESS) return ret;
1010 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1011 "codePage", "0");
1012 if (ret != LDB_SUCCESS) return ret;
1013 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1014 "countryCode", "0");
1015 if (ret != LDB_SUCCESS) return ret;
1016 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1017 "lastLogoff", "0");
1018 if (ret != LDB_SUCCESS) return ret;
1019 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1020 "lastLogon", "0");
1021 if (ret != LDB_SUCCESS) return ret;
1022 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1023 "logonCount", "0");
1024 if (ret != LDB_SUCCESS) return ret;
1025 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1026 "pwdLastSet", "0");
1027 if (ret != LDB_SUCCESS) return ret;
1028
1029 /* On add operations we might need to generate a
1030 * "userAccountControl" (if it isn't specified). */
1031 el = ldb_msg_find_element(ac->msg, "userAccountControl");
1032 if ((el == NULL) && (ac->req->operation == LDB_ADD)) {
1033 ret = samdb_msg_set_uint(ldb, ac->msg, ac->msg,
1034 "userAccountControl",
1035 UF_NORMAL_ACCOUNT);
1036 if (ret != LDB_SUCCESS) {
1037 return ret;
1038 }
1039 uac_generated = true;
1040 }
1041
1042 el = ldb_msg_find_element(ac->msg, "userAccountControl");
1043 if (el != NULL) {
1044 uint32_t user_account_control, account_type;
1045 /* Step 1.3: "userAccountControl" -> "sAMAccountType" mapping */
1046 user_account_control = ldb_msg_find_attr_as_uint(ac->msg,
1047 "userAccountControl",
1048 0);
1049
1050 /* Temporary duplicate accounts aren't allowed */
1051 if ((user_account_control & UF_TEMP_DUPLICATE_ACCOUNT) != 0) {
1052 return LDB_ERR_OTHER;
1053 }
1054
1055 /* Workstation and (read-only) DC objects do need objectclass "computer" */
1056 if ((samdb_find_attribute(ldb, ac->msg,
1057 "objectclass", "computer") == NULL) &&
1058 (user_account_control &
1059 (UF_SERVER_TRUST_ACCOUNT | UF_WORKSTATION_TRUST_ACCOUNT))) {
1060 ldb_set_errstring(ldb,
1061 "samldb: Requested account type does need objectclass 'computer'!");
1062 return LDB_ERR_OBJECT_CLASS_VIOLATION;
1063 }
1064
1065 account_type = ds_uf2atype(user_account_control);
1066 if (account_type == 0) {
1067 ldb_set_errstring(ldb, "samldb: Unrecognized account type!");
1068 return LDB_ERR_UNWILLING_TO_PERFORM;
1069 }
1070 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg,
1071 "sAMAccountType",
1072 account_type);
1073 if (ret != LDB_SUCCESS) {
1074 return ret;
1075 }
1076 el2 = ldb_msg_find_element(ac->msg, "sAMAccountType");
1077 el2->flags = LDB_FLAG_MOD_REPLACE;
1078
1079 /* "isCriticalSystemObject" might be set */
1080 if (user_account_control &
1081 (UF_SERVER_TRUST_ACCOUNT | UF_PARTIAL_SECRETS_ACCOUNT)) {
1082 ret = ldb_msg_add_string(ac->msg, "isCriticalSystemObject",
1083 "TRUE");
1084 if (ret != LDB_SUCCESS) {
1085 return ret;
1086 }
1087 el2 = ldb_msg_find_element(ac->msg,
1088 "isCriticalSystemObject");
1089 el2->flags = LDB_FLAG_MOD_REPLACE;
1090 } else if (user_account_control & UF_WORKSTATION_TRUST_ACCOUNT) {
1091 ret = ldb_msg_add_string(ac->msg, "isCriticalSystemObject",
1092 "FALSE");
1093 if (ret != LDB_SUCCESS) {
1094 return ret;
1095 }
1096 el2 = ldb_msg_find_element(ac->msg,
1097 "isCriticalSystemObject");
1098 el2->flags = LDB_FLAG_MOD_REPLACE;
1099 }
1100
1101 /* Step 1.4: "userAccountControl" -> "primaryGroupID" mapping */
1102 if (!ldb_msg_find_element(ac->msg, "primaryGroupID")) {
1103 uint32_t rid = ds_uf2prim_group_rid(user_account_control);
1104
1105 /*
1106 * Older AD deployments don't know about the
1107 * RODC group
1108 */
1109 if (rid == DOMAIN_RID_READONLY_DCS) {
1110 ret = samldb_prim_group_tester(ac, rid);
1111 if (ret != LDB_SUCCESS) {
1112 return ret;
1113 }
1114 }
1115
1116 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg,
1117 "primaryGroupID", rid);
1118 if (ret != LDB_SUCCESS) {
1119 return ret;
1120 }
1121 el2 = ldb_msg_find_element(ac->msg,
1122 "primaryGroupID");
1123 el2->flags = LDB_FLAG_MOD_REPLACE;
1124 }
1125
1126 /* Step 1.5: Add additional flags when needed */
1127 /* Obviously this is done when the "userAccountControl"
1128 * has been generated here (tested against Windows
1129 * Server) */
1130 if (uac_generated) {
1131 user_account_control |= UF_ACCOUNTDISABLE;
1132 user_account_control |= UF_PASSWD_NOTREQD;
1133
1134 ret = samdb_msg_set_uint(ldb, ac->msg, ac->msg,
1135 "userAccountControl",
1136 user_account_control);
1137 if (ret != LDB_SUCCESS) {
1138 return ret;
1139 }
1140 }
1141
1142 ret = samldb_check_user_account_control_acl(ac, NULL,
1143 user_account_control, 0);
1144 if (ret != LDB_SUCCESS) {
1145 return ret;
1146 }
1147 }
1148 break;
1149 }
1150
1151 case SAMLDB_TYPE_GROUP: {
1152 const char *tempstr;
1153
1154 /* Step 2.2: Default values */
1155 tempstr = talloc_asprintf(ac->msg, "%d",
1156 GTYPE_SECURITY_GLOBAL_GROUP);
1157 if (tempstr == NULL) return ldb_operr(ldb);
1158 ret = samdb_find_or_add_attribute(ldb, ac->msg,
1159 "groupType", tempstr);
1160 if (ret != LDB_SUCCESS) return ret;
1161
1162 /* Step 2.3: "groupType" -> "sAMAccountType" */
1163 el = ldb_msg_find_element(ac->msg, "groupType");
1164 if (el != NULL) {
1165 uint32_t group_type, account_type;
1166
1167 group_type = ldb_msg_find_attr_as_uint(ac->msg,
1168 "groupType", 0);
1169
1170 /* The creation of builtin groups requires the
1171 * RELAX control */
1172 if (group_type == GTYPE_SECURITY_BUILTIN_LOCAL_GROUP) {
1173 if (ldb_request_get_control(ac->req,
1174 LDB_CONTROL_RELAX_OID) == NULL) {
1175 return LDB_ERR_UNWILLING_TO_PERFORM;
1176 }
1177 }
1178
1179 account_type = ds_gtype2atype(group_type);
1180 if (account_type == 0) {
1181 ldb_set_errstring(ldb, "samldb: Unrecognized account type!");
1182 return LDB_ERR_UNWILLING_TO_PERFORM;
1183 }
1184 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg,
1185 "sAMAccountType",
1186 account_type);
1187 if (ret != LDB_SUCCESS) {
1188 return ret;
1189 }
1190 el2 = ldb_msg_find_element(ac->msg, "sAMAccountType");
1191 el2->flags = LDB_FLAG_MOD_REPLACE;
1192 }
1193 break;
1194 }
1195
1196 default:
1197 ldb_asprintf_errstring(ldb,
1198 "Invalid entry type!");
1199 return LDB_ERR_OPERATIONS_ERROR;
1200 break;
1201 }
1202
1203 return LDB_SUCCESS;
1204 }
1205
1206 /*
1207 * "Primary group ID" trigger (MS-SAMR 3.1.1.8.2)
1208 *
1209 * Has to be invoked on "add" and "modify" operations on "user" and "computer"
1210 * objects.
1211 * ac->msg contains the "add"/"modify" message
1212 */
1213
1214 static int samldb_prim_group_tester(struct samldb_ctx *ac, uint32_t rid)
1215 {
1216 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1217 struct dom_sid *sid;
1218 struct ldb_result *res;
1219 int ret;
1220 const char * const noattrs[] = { NULL };
1221
1222 sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), rid);
1223 if (sid == NULL) {
1224 return ldb_operr(ldb);
1225 }
1226
1227 ret = dsdb_module_search(ac->module, ac, &res,
1228 ldb_get_default_basedn(ldb),
1229 LDB_SCOPE_SUBTREE,
1230 noattrs, DSDB_FLAG_NEXT_MODULE,
1231 ac->req,
1232 "(objectSid=%s)",
1233 ldap_encode_ndr_dom_sid(ac, sid));
1234 if (ret != LDB_SUCCESS) {
1235 return ret;
1236 }
1237 if (res->count != 1) {
1238 talloc_free(res);
1239 ldb_asprintf_errstring(ldb,
1240 "Failed to find primary group with RID %u!",
1241 rid);
1242 return LDB_ERR_UNWILLING_TO_PERFORM;
1243 }
1244 talloc_free(res);
1245
1246 return LDB_SUCCESS;
1247 }
1248
1249 static int samldb_prim_group_set(struct samldb_ctx *ac)
1250 {
1251 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1252 uint32_t rid;
1253
1254 rid = ldb_msg_find_attr_as_uint(ac->msg, "primaryGroupID", (uint32_t) -1);
1255 if (rid == (uint32_t) -1) {
1256 /* we aren't affected of any primary group set */
1257 return LDB_SUCCESS;
1258
1259 } else if (!ldb_request_get_control(ac->req, LDB_CONTROL_RELAX_OID)) {
1260 ldb_set_errstring(ldb,
1261 "The primary group isn't settable on add operations!");
1262 return LDB_ERR_UNWILLING_TO_PERFORM;
1263 }
1264
1265 return samldb_prim_group_tester(ac, rid);
1266 }
1267
1268 static int samldb_prim_group_change(struct samldb_ctx *ac)
1269 {
1270 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1271 const char * const attrs[] = { "primaryGroupID", "memberOf", NULL };
1272 struct ldb_result *res, *group_res;
1273 struct ldb_message_element *el;
1274 struct ldb_message *msg;
1275 uint32_t prev_rid, new_rid;
1276 struct dom_sid *prev_sid, *new_sid;
1277 struct ldb_dn *prev_prim_group_dn, *new_prim_group_dn;
1278 int ret;
1279 const char * const noattrs[] = { NULL };
1280
1281 el = dsdb_get_single_valued_attr(ac->msg, "primaryGroupID",
1282 ac->req->operation);
1283 if (el == NULL) {
1284 /* we are not affected */
1285 return LDB_SUCCESS;
1286 }
1287
1288 /* Fetch information from the existing object */
1289
1290 ret = dsdb_module_search_dn(ac->module, ac, &res, ac->msg->dn, attrs,
1291 DSDB_FLAG_NEXT_MODULE, ac->req);
1292 if (ret != LDB_SUCCESS) {
1293 return ret;
1294 }
1295
1296 /* Finds out the DN of the old primary group */
1297
1298 prev_rid = ldb_msg_find_attr_as_uint(res->msgs[0], "primaryGroupID",
1299 (uint32_t) -1);
1300 if (prev_rid == (uint32_t) -1) {
1301 /* User objects do always have a mandatory "primaryGroupID"
1302 * attribute. If this doesn't exist then the object is of the
1303 * wrong type. This is the exact Windows error code */
1304 return LDB_ERR_OBJECT_CLASS_VIOLATION;
1305 }
1306
1307 prev_sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), prev_rid);
1308 if (prev_sid == NULL) {
1309 return ldb_operr(ldb);
1310 }
1311
1312 /* Finds out the DN of the new primary group
1313 * Notice: in order to parse the primary group ID correctly we create
1314 * a temporary message here. */
1315
1316 msg = ldb_msg_new(ac->msg);
1317 if (msg == NULL) {
1318 return ldb_module_oom(ac->module);
1319 }
1320 ret = ldb_msg_add(msg, el, 0);
1321 if (ret != LDB_SUCCESS) {
1322 return ret;
1323 }
1324 new_rid = ldb_msg_find_attr_as_uint(msg, "primaryGroupID", (uint32_t) -1);
1325 talloc_free(msg);
1326 if (new_rid == (uint32_t) -1) {
1327 /* we aren't affected of any primary group change */
1328 return LDB_SUCCESS;
1329 }
1330
1331 if (prev_rid == new_rid) {
1332 return LDB_SUCCESS;
1333 }
1334
1335 ret = dsdb_module_search(ac->module, ac, &group_res,
1336 ldb_get_default_basedn(ldb),
1337 LDB_SCOPE_SUBTREE,
1338 noattrs, DSDB_FLAG_NEXT_MODULE,
1339 ac->req,
1340 "(objectSid=%s)",
1341 ldap_encode_ndr_dom_sid(ac, prev_sid));
1342 if (ret != LDB_SUCCESS) {
1343 return ret;
1344 }
1345 if (group_res->count != 1) {
1346 return ldb_operr(ldb);
1347 }
1348 prev_prim_group_dn = group_res->msgs[0]->dn;
1349
1350 new_sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb), new_rid);
1351 if (new_sid == NULL) {
1352 return ldb_operr(ldb);
1353 }
1354
1355 ret = dsdb_module_search(ac->module, ac, &group_res,
1356 ldb_get_default_basedn(ldb),
1357 LDB_SCOPE_SUBTREE,
1358 noattrs, DSDB_FLAG_NEXT_MODULE,
1359 ac->req,
1360 "(objectSid=%s)",
1361 ldap_encode_ndr_dom_sid(ac, new_sid));
1362 if (ret != LDB_SUCCESS) {
1363 return ret;
1364 }
1365 if (group_res->count != 1) {
1366 /* Here we know if the specified new primary group candidate is
1367 * valid or not. */
1368 return LDB_ERR_UNWILLING_TO_PERFORM;
1369 }
1370 new_prim_group_dn = group_res->msgs[0]->dn;
1371
1372 /* We need to be already a normal member of the new primary
1373 * group in order to be successful. */
1374 el = samdb_find_attribute(ldb, res->msgs[0], "memberOf",
1375 ldb_dn_get_linearized(new_prim_group_dn));
1376 if (el == NULL) {
1377 return LDB_ERR_UNWILLING_TO_PERFORM;
1378 }
1379
1380 /* Remove the "member" attribute on the new primary group */
1381 msg = ldb_msg_new(ac->msg);
1382 if (msg == NULL) {
1383 return ldb_module_oom(ac->module);
1384 }
1385 msg->dn = new_prim_group_dn;
1386
1387 ret = samdb_msg_add_delval(ldb, msg, msg, "member",
1388 ldb_dn_get_linearized(ac->msg->dn));
1389 if (ret != LDB_SUCCESS) {
1390 return ret;
1391 }
1392
1393 ret = dsdb_module_modify(ac->module, msg, DSDB_FLAG_NEXT_MODULE, ac->req);
1394 if (ret != LDB_SUCCESS) {
1395 return ret;
1396 }
1397 talloc_free(msg);
1398
1399 /* Add a "member" attribute for the previous primary group */
1400 msg = ldb_msg_new(ac->msg);
1401 if (msg == NULL) {
1402 return ldb_module_oom(ac->module);
1403 }
1404 msg->dn = prev_prim_group_dn;
1405
1406 ret = samdb_msg_add_addval(ldb, msg, msg, "member",
1407 ldb_dn_get_linearized(ac->msg->dn));
1408 if (ret != LDB_SUCCESS) {
1409 return ret;
1410 }
1411
1412 ret = dsdb_module_modify(ac->module, msg, DSDB_FLAG_NEXT_MODULE, ac->req);
1413 if (ret != LDB_SUCCESS) {
1414 return ret;
1415 }
1416 talloc_free(msg);
1417
1418 return LDB_SUCCESS;
1419 }
1420
1421 static int samldb_prim_group_trigger(struct samldb_ctx *ac)
1422 {
1423 int ret;
1424
1425 if (ac->req->operation == LDB_ADD) {
1426 ret = samldb_prim_group_set(ac);
1427 } else {
1428 ret = samldb_prim_group_change(ac);
1429 }
1430
1431 return ret;
1432 }
1433
1434 /**
1435 * Validate that the restriction in point 5 of MS-SAMR 3.1.1.8.10 userAccountControl is honoured
1436 *
1437 */
1438 static int samldb_check_user_account_control_acl(struct samldb_ctx *ac,
1439 struct dom_sid *sid,
1440 uint32_t user_account_control,
1441 uint32_t user_account_control_old)
1442 {
1443 int i, ret = 0;
1444 bool need_acl_check = false;
1445 struct ldb_result *res;
1446 const char * const sd_attrs[] = {"ntSecurityDescriptor", NULL};
1447 struct security_token *user_token;
1448 struct security_descriptor *domain_sd;
1449 struct ldb_dn *domain_dn = ldb_get_default_basedn(ldb_module_get_ctx(ac->module));
1450 const struct uac_to_guid {
1451 uint32_t uac;
1452 const char *oid;
1453 const char *guid;
1454 enum sec_privilege privilege;
1455 bool delete_is_privileged;
1456 const char *error_string;
1457 } map[] = {
1458 {
1459 .uac = UF_PASSWD_NOTREQD,
1460 .guid = GUID_DRS_UPDATE_PASSWORD_NOT_REQUIRED_BIT,
1461 .error_string = "Adding the UF_PASSWD_NOTREQD bit in userAccountControl requires the Update-Password-Not-Required-Bit right that was not given on the Domain object"
1462 },
1463 {
1464 .uac = UF_DONT_EXPIRE_PASSWD,
1465 .guid = GUID_DRS_UNEXPIRE_PASSWORD,
1466 .error_string = "Adding the UF_DONT_EXPIRE_PASSWD bit in userAccountControl requires the Unexpire-Password right that was not given on the Domain object"
1467 },
1468 {
1469 .uac = UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED,
1470 .guid = GUID_DRS_ENABLE_PER_USER_REVERSIBLY_ENCRYPTED_PASSWORD,
1471 .error_string = "Adding the UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED bit in userAccountControl requires the Enable-Per-User-Reversibly-Encrypted-Password right that was not given on the Domain object"
1472 },
1473 {
1474 .uac = UF_SERVER_TRUST_ACCOUNT,
1475 .guid = GUID_DRS_DS_INSTALL_REPLICA,
1476 .error_string = "Adding the UF_SERVER_TRUST_ACCOUNT bit in userAccountControl requires the DS-Install-Replica right that was not given on the Domain object"
1477 },
1478 {
1479 .uac = UF_PARTIAL_SECRETS_ACCOUNT,
1480 .guid = GUID_DRS_DS_INSTALL_REPLICA,
1481 .error_string = "Adding the UF_PARTIAL_SECRETS_ACCOUNT bit in userAccountControl requires the DS-Install-Replica right that was not given on the Domain object"
1482 },
1483 {
1484 .uac = UF_INTERDOMAIN_TRUST_ACCOUNT,
1485 .oid = DSDB_CONTROL_PERMIT_INTERDOMAIN_TRUST_UAC_OID,
1486 .error_string = "Updating the UF_INTERDOMAIN_TRUST_ACCOUNT bit in userAccountControl is not permitted over LDAP. This bit is restricted to the LSA CreateTrustedDomain interface",
1487 .delete_is_privileged = true
1488 },
1489 {
1490 .uac = UF_TRUSTED_FOR_DELEGATION,
1491 .privilege = SEC_PRIV_ENABLE_DELEGATION,
1492 .delete_is_privileged = true,
1493 .error_string = "Updating the UF_TRUSTED_FOR_DELEGATION bit in userAccountControl is not permitted without the SeEnableDelegationPrivilege"
1494 },
1495 {
1496 .uac = UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION,
1497 .privilege = SEC_PRIV_ENABLE_DELEGATION,
1498 .delete_is_privileged = true,
1499 .error_string = "Updating the UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION bit in userAccountControl is not permitted without the SeEnableDelegationPrivilege"
1500 }
1501
1502 };
1503
1504 if (dsdb_module_am_system(ac->module)) {
1505 return LDB_SUCCESS;
1506 }
1507
1508 for (i = 0; i < ARRAY_SIZE(map); i++) {
1509 if (user_account_control & map[i].uac) {
1510 need_acl_check = true;
1511 break;
1512 }
1513 }
1514 if (need_acl_check == false) {
1515 return LDB_SUCCESS;
1516 }
1517
1518 user_token = acl_user_token(ac->module);
1519 if (user_token == NULL) {
1520 return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
1521 }
1522
1523 ret = dsdb_module_search_dn(ac->module, ac, &res,
1524 domain_dn,
1525 sd_attrs,
1526 DSDB_FLAG_NEXT_MODULE | DSDB_SEARCH_SHOW_DELETED,
1527 ac->req);
1528 if (ret != LDB_SUCCESS) {
1529 return ret;
1530 }
1531 if (res->count != 1) {
1532 return ldb_module_operr(ac->module);
1533 }
1534
1535 ret = dsdb_get_sd_from_ldb_message(ldb_module_get_ctx(ac->module),
1536 ac, res->msgs[0], &domain_sd);
1537
1538 if (ret != LDB_SUCCESS) {
1539 return ret;
1540 }
1541
1542 for (i = 0; i < ARRAY_SIZE(map); i++) {
1543 uint32_t this_uac_new = user_account_control & map[i].uac;
1544 uint32_t this_uac_old = user_account_control_old & map[i].uac;
1545 if (this_uac_new != this_uac_old) {
1546 if (this_uac_old != 0) {
1547 if (map[i].delete_is_privileged == false) {
1548 continue;
1549 }
1550 }
1551 if (map[i].oid) {
1552 struct ldb_control *control = ldb_request_get_control(ac->req, map[i].oid);
1553 if (control == NULL) {
1554 ret = LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
1555 }
1556 } else if (map[i].privilege != SEC_PRIV_INVALID) {
1557 bool have_priv = security_token_has_privilege(user_token,
1558 map[i].privilege);
1559 if (have_priv == false) {
1560 ret = LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS;
1561 }
1562 } else {
1563 ret = acl_check_extended_right(ac, domain_sd,
1564 user_token,
1565 map[i].guid,
1566 SEC_ADS_CONTROL_ACCESS,
1567 sid);
1568 }
1569 if (ret != LDB_SUCCESS) {
1570 break;
1571 }
1572 }
1573 }
1574 if (ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
1575 switch (ac->req->operation) {
1576 case LDB_ADD:
1577 ldb_asprintf_errstring(ldb_module_get_ctx(ac->module),
1578 "Failed to add %s: %s",
1579 ldb_dn_get_linearized(ac->msg->dn),
1580 map[i].error_string);
1581 break;
1582 case LDB_MODIFY:
1583 ldb_asprintf_errstring(ldb_module_get_ctx(ac->module),
1584 "Failed to modify %s: %s",
1585 ldb_dn_get_linearized(ac->msg->dn),
1586 map[i].error_string);
1587 break;
1588 default:
1589 return ldb_module_operr(ac->module);
1590 }
1591 if (map[i].guid) {
1592 dsdb_acl_debug(domain_sd, acl_user_token(ac->module),
1593 domain_dn,
1594 true,
1595 10);
1596 }
1597 }
1598 return ret;
1599 }
1600
1601 /**
1602 * This function is called on LDB modify operations. It performs some additions/
1603 * replaces on the current LDB message when "userAccountControl" changes.
1604 */
1605 static int samldb_user_account_control_change(struct samldb_ctx *ac)
1606 {
1607 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1608 uint32_t user_account_control, old_user_account_control, account_type;
1609 struct ldb_message_element *el;
1610 struct ldb_message *tmp_msg;
1611 struct dom_sid *sid;
1612 int ret;
1613 struct ldb_result *res;
1614 const char * const attrs[] = { "userAccountControl", "objectClass", "objectSid", NULL };
1615 unsigned int i;
1616 bool is_computer = false;
1617
1618 el = dsdb_get_single_valued_attr(ac->msg, "userAccountControl",
1619 ac->req->operation);
1620 if (el == NULL) {
1621 /* we are not affected */
1622 return LDB_SUCCESS;
1623 }
1624
1625 /* Create a temporary message for fetching the "userAccountControl" */
1626 tmp_msg = ldb_msg_new(ac->msg);
1627 if (tmp_msg == NULL) {
1628 return ldb_module_oom(ac->module);
1629 }
1630 ret = ldb_msg_add(tmp_msg, el, 0);
1631 if (ret != LDB_SUCCESS) {
1632 return ret;
1633 }
1634 user_account_control = ldb_msg_find_attr_as_uint(tmp_msg,
1635 "userAccountControl",
1636 0);
1637 talloc_free(tmp_msg);
1638
1639 /* Temporary duplicate accounts aren't allowed */
1640 if ((user_account_control & UF_TEMP_DUPLICATE_ACCOUNT) != 0) {
1641 return LDB_ERR_OTHER;
1642 }
1643
1644 /* Fetch the old "userAccountControl" and "objectClass" */
1645 ret = dsdb_module_search_dn(ac->module, ac, &res, ac->msg->dn, attrs,
1646 DSDB_FLAG_NEXT_MODULE, ac->req);
1647 if (ret != LDB_SUCCESS) {
1648 return ret;
1649 }
1650 old_user_account_control = ldb_msg_find_attr_as_uint(res->msgs[0], "userAccountControl", 0);
1651 if (old_user_account_control == 0) {
1652 return ldb_operr(ldb);
1653 }
1654 el = ldb_msg_find_element(res->msgs[0], "objectClass");
1655 if (el == NULL) {
1656 return ldb_operr(ldb);
1657 }
1658
1659 /* When we do not have objectclass "computer" we cannot switch to a (read-only) DC */
1660 for (i = 0; i < el->num_values; i++) {
1661 if (ldb_attr_cmp((char *)el->values[i].data, "computer") == 0) {
1662 is_computer = true;
1663 break;
1664 }
1665 }
1666 if (!is_computer &&
1667 (user_account_control & (UF_SERVER_TRUST_ACCOUNT | UF_PARTIAL_SECRETS_ACCOUNT))) {
1668 ldb_set_errstring(ldb,
1669 "samldb: Requested account type does need objectclass 'computer'!");
1670 return LDB_ERR_UNWILLING_TO_PERFORM;
1671 }
1672
1673 /*
1674 * The functions "ds_uf2atype" and "ds_uf2prim_group_rid" are used as
1675 * detectors for account type changes.
1676 * So if the account type does change then we need to adjust the
1677 * "sAMAccountType", the "isCriticalSystemObject" and the
1678 * "primaryGroupID" attribute.
1679 */
1680 if ((ds_uf2atype(user_account_control)
1681 == ds_uf2atype(old_user_account_control)) &&
1682 (ds_uf2prim_group_rid(user_account_control)
1683 == ds_uf2prim_group_rid(old_user_account_control))) {
1684 return LDB_SUCCESS;
1685 }
1686
1687 account_type = ds_uf2atype(user_account_control);
1688 if (account_type == 0) {
1689 ldb_set_errstring(ldb, "samldb: Unrecognized account type!");
1690 return LDB_ERR_UNWILLING_TO_PERFORM;
1691 }
1692 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg, "sAMAccountType",
1693 account_type);
1694 if (ret != LDB_SUCCESS) {
1695 return ret;
1696 }
1697 el = ldb_msg_find_element(ac->msg, "sAMAccountType");
1698 el->flags = LDB_FLAG_MOD_REPLACE;
1699
1700 /* "isCriticalSystemObject" might be set/changed */
1701 if (user_account_control
1702 & (UF_SERVER_TRUST_ACCOUNT | UF_PARTIAL_SECRETS_ACCOUNT)) {
1703 ret = ldb_msg_add_string(ac->msg, "isCriticalSystemObject",
1704 "TRUE");
1705 if (ret != LDB_SUCCESS) {
1706 return ret;
1707 }
1708 el = ldb_msg_find_element(ac->msg,
1709 "isCriticalSystemObject");
1710 el->flags = LDB_FLAG_MOD_REPLACE;
1711 } else if (user_account_control & UF_WORKSTATION_TRUST_ACCOUNT) {
1712 ret = ldb_msg_add_string(ac->msg, "isCriticalSystemObject",
1713 "FALSE");
1714 if (ret != LDB_SUCCESS) {
1715 return ret;
1716 }
1717 el = ldb_msg_find_element(ac->msg,
1718 "isCriticalSystemObject");
1719 el->flags = LDB_FLAG_MOD_REPLACE;
1720 }
1721
1722 if (!ldb_msg_find_element(ac->msg, "primaryGroupID")) {
1723 uint32_t rid = ds_uf2prim_group_rid(user_account_control);
1724
1725 /* Older AD deployments don't know about the RODC group */
1726 if (rid == DOMAIN_RID_READONLY_DCS) {
1727 ret = samldb_prim_group_tester(ac, rid);
1728 if (ret != LDB_SUCCESS) {
1729 return ret;
1730 }
1731 }
1732
1733 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg,
1734 "primaryGroupID", rid);
1735 if (ret != LDB_SUCCESS) {
1736 return ret;
1737 }
1738 el = ldb_msg_find_element(ac->msg,
1739 "primaryGroupID");
1740 el->flags = LDB_FLAG_MOD_REPLACE;
1741 }
1742
1743 sid = samdb_result_dom_sid(res, res->msgs[0], "objectSid");
1744 if (sid == NULL) {
1745 return ldb_module_operr(ac->module);
1746 }
1747
1748 ret = samldb_check_user_account_control_acl(ac, sid, user_account_control,
1749 old_user_account_control);
1750 if (ret != LDB_SUCCESS) {
1751 return ret;
1752 }
1753
1754 return LDB_SUCCESS;
1755 }
1756
1757 static int samldb_group_type_change(struct samldb_ctx *ac)
1758 {
1759 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1760 uint32_t group_type, old_group_type, account_type;
1761 struct ldb_message_element *el;
1762 struct ldb_message *tmp_msg;
1763 int ret;
1764 struct ldb_result *res;
1765 const char * const attrs[] = { "groupType", NULL };
1766
1767 el = dsdb_get_single_valued_attr(ac->msg, "groupType",
1768 ac->req->operation);
1769 if (el == NULL) {
1770 /* we are not affected */
1771 return LDB_SUCCESS;
1772 }
1773
1774 /* Create a temporary message for fetching the "groupType" */
1775 tmp_msg = ldb_msg_new(ac->msg);
1776 if (tmp_msg == NULL) {
1777 return ldb_module_oom(ac->module);
1778 }
1779 ret = ldb_msg_add(tmp_msg, el, 0);
1780 if (ret != LDB_SUCCESS) {
1781 return ret;
1782 }
1783 group_type = ldb_msg_find_attr_as_uint(tmp_msg, "groupType", 0);
1784 talloc_free(tmp_msg);
1785
1786 ret = dsdb_module_search_dn(ac->module, ac, &res, ac->msg->dn, attrs,
1787 DSDB_FLAG_NEXT_MODULE |
1788 DSDB_SEARCH_SHOW_DELETED, ac->req);
1789 if (ret != LDB_SUCCESS) {
1790 return ret;
1791 }
1792 old_group_type = ldb_msg_find_attr_as_uint(res->msgs[0], "groupType", 0);
1793 if (old_group_type == 0) {
1794 return ldb_operr(ldb);
1795 }
1796
1797 /* Group type switching isn't so easy as it seems: We can only
1798 * change in this directions: global <-> universal <-> local
1799 * On each step also the group type itself
1800 * (security/distribution) is variable. */
1801
1802 if (ldb_request_get_control(ac->req, LDB_CONTROL_PROVISION_OID) == NULL) {
1803 switch (group_type) {
1804 case GTYPE_SECURITY_GLOBAL_GROUP:
1805 case GTYPE_DISTRIBUTION_GLOBAL_GROUP:
1806 /* change to "universal" allowed */
1807 if ((old_group_type == GTYPE_SECURITY_DOMAIN_LOCAL_GROUP) ||
1808 (old_group_type == GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP)) {
1809 ldb_set_errstring(ldb,
1810 "samldb: Change from security/distribution local group forbidden!");
1811 return LDB_ERR_UNWILLING_TO_PERFORM;
1812 }
1813 break;
1814
1815 case GTYPE_SECURITY_UNIVERSAL_GROUP:
1816 case GTYPE_DISTRIBUTION_UNIVERSAL_GROUP:
1817 /* each change allowed */
1818 break;
1819 case GTYPE_SECURITY_DOMAIN_LOCAL_GROUP:
1820 case GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP:
1821 /* change to "universal" allowed */
1822 if ((old_group_type == GTYPE_SECURITY_GLOBAL_GROUP) ||
1823 (old_group_type == GTYPE_DISTRIBUTION_GLOBAL_GROUP)) {
1824 ldb_set_errstring(ldb,
1825 "samldb: Change from security/distribution global group forbidden!");
1826 return LDB_ERR_UNWILLING_TO_PERFORM;
1827 }
1828 break;
1829
1830 case GTYPE_SECURITY_BUILTIN_LOCAL_GROUP:
1831 default:
1832 /* we don't allow this "groupType" values */
1833 return LDB_ERR_UNWILLING_TO_PERFORM;
1834 break;
1835 }
1836 }
1837
1838 account_type = ds_gtype2atype(group_type);
1839 if (account_type == 0) {
1840 ldb_set_errstring(ldb, "samldb: Unrecognized account type!");
1841 return LDB_ERR_UNWILLING_TO_PERFORM;
1842 }
1843 ret = samdb_msg_add_uint(ldb, ac->msg, ac->msg, "sAMAccountType",
1844 account_type);
1845 if (ret != LDB_SUCCESS) {
1846 return ret;
1847 }
1848 el = ldb_msg_find_element(ac->msg, "sAMAccountType");
1849 el->flags = LDB_FLAG_MOD_REPLACE;
1850
1851 return LDB_SUCCESS;
1852 }
1853
1854 static int samldb_sam_accountname_check(struct samldb_ctx *ac)
1855 {
1856 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1857 const char * const no_attrs[] = { NULL };
1858 struct ldb_result *res;
1859 const char *sam_accountname, *enc_str;
1860 struct ldb_message_element *el;
1861 struct ldb_message *tmp_msg;
1862 int ret;
1863
1864 el = dsdb_get_single_valued_attr(ac->msg, "sAMAccountName",
1865 ac->req->operation);
1866 if (el == NULL) {
1867 /* we are not affected */
1868 return LDB_SUCCESS;
1869 }
1870
1871 /* Create a temporary message for fetching the "sAMAccountName" */
1872 tmp_msg = ldb_msg_new(ac->msg);
1873 if (tmp_msg == NULL) {
1874 return ldb_module_oom(ac->module);
1875 }
1876 ret = ldb_msg_add(tmp_msg, el, 0);
1877 if (ret != LDB_SUCCESS) {
1878 return ret;
1879 }
1880
1881 /* We must not steal the original string, it belongs to the caller! */
1882 sam_accountname = talloc_strdup(ac,
1883 ldb_msg_find_attr_as_string(tmp_msg, "sAMAccountName", NULL));
1884 talloc_free(tmp_msg);
1885
1886 if (sam_accountname == NULL) {
1887 /* The "sAMAccountName" cannot be nothing */
1888 ldb_set_errstring(ldb,
1889 "samldb: Empty account names aren't allowed!");
1890 return LDB_ERR_UNWILLING_TO_PERFORM;
1891 }
1892
1893 enc_str = ldb_binary_encode_string(ac, sam_accountname);
1894 if (enc_str == NULL) {
1895 return ldb_module_oom(ac->module);
1896 }
1897
1898 /* Make sure that a "sAMAccountName" is only used once */
1899
1900 ret = dsdb_module_search(ac->module, ac, &res,
1901 ldb_get_default_basedn(ldb),
1902 LDB_SCOPE_SUBTREE, no_attrs,
1903 DSDB_FLAG_NEXT_MODULE, ac->req,
1904 "(sAMAccountName=%s)", enc_str);
1905 if (ret != LDB_SUCCESS) {
1906 return ret;
1907 }
1908 if (res->count > 1) {
1909 return ldb_operr(ldb);
1910 } else if (res->count == 1) {
1911 if (ldb_dn_compare(res->msgs[0]->dn, ac->msg->dn) != 0) {
1912 ldb_asprintf_errstring(ldb,
1913 "samldb: Account name (sAMAccountName) '%s' already in use!",
1914 sam_accountname);
1915 return LDB_ERR_ENTRY_ALREADY_EXISTS;
1916 }
1917 }
1918 talloc_free(res);
1919
1920 return LDB_SUCCESS;
1921 }
1922
1923 static int samldb_member_check(struct samldb_ctx *ac)
1924 {
1925 const char * const attrs[] = { "objectSid", NULL };
1926 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
1927 struct ldb_message_element *el;
1928 struct ldb_dn *member_dn;
1929 struct dom_sid *sid;
1930 struct ldb_result *res;
1931 struct dom_sid *group_sid;
1932 unsigned int i, j;
1933 int ret;
1934
1935 /* Fetch information from the existing object */
1936
1937 ret = dsdb_module_search(ac->module, ac, &res, ac->msg->dn, LDB_SCOPE_BASE, attrs,
1938 DSDB_FLAG_NEXT_MODULE | DSDB_SEARCH_SHOW_DELETED, ac->req, NULL);
1939 if (ret != LDB_SUCCESS) {
1940 return ret;
1941 }
1942 if (res->count != 1) {
1943 return ldb_operr(ldb);
1944 }
1945
1946 group_sid = samdb_result_dom_sid(res, res->msgs[0], "objectSid");
1947 if (group_sid == NULL) {
1948 return ldb_operr(ldb);
1949 }
1950
1951 /* We've to walk over all modification entries and consider the "member"
1952 * ones. */
1953 for (i = 0; i < ac->msg->num_elements; i++) {
1954 if (ldb_attr_cmp(ac->msg->elements[i].name, "member") != 0) {
1955 continue;
1956 }
1957
1958 el = &ac->msg->elements[i];
1959 for (j = 0; j < el->num_values; j++) {
1960 struct ldb_result *group_res;
1961 const char *group_attrs[] = { "primaryGroupID" , NULL };
1962 uint32_t prim_group_rid;
1963
1964 if (LDB_FLAG_MOD_TYPE(el->flags) == LDB_FLAG_MOD_DELETE) {
1965 /* Deletes will be handled in
1966 * repl_meta_data, and deletes not
1967 * matching a member will return
1968 * LDB_ERR_UNWILLING_TO_PERFORM
1969 * there */
1970 continue;
1971 }
1972
1973 member_dn = ldb_dn_from_ldb_val(ac, ldb,
1974 &el->values[j]);
1975 if (!ldb_dn_validate(member_dn)) {
1976 return ldb_operr(ldb);
1977 }
1978
1979 /* Denies to add "member"s to groups which are primary
1980 * ones for them - in this case return
1981 * ERR_ENTRY_ALREADY_EXISTS. */
1982
1983 ret = dsdb_module_search_dn(ac->module, ac, &group_res,
1984 member_dn, group_attrs,
1985 DSDB_FLAG_NEXT_MODULE, ac->req);
1986 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1987 /* member DN doesn't exist yet */
1988 continue;
1989 }
1990 if (ret != LDB_SUCCESS) {
1991 return ret;
1992 }
1993 prim_group_rid = ldb_msg_find_attr_as_uint(group_res->msgs[0], "primaryGroupID", (uint32_t)-1);
1994 if (prim_group_rid == (uint32_t) -1) {
1995 /* the member hasn't to be a user account ->
1996 * therefore no check needed in this case. */
1997 continue;
1998 }
1999
2000 sid = dom_sid_add_rid(ac, samdb_domain_sid(ldb),
2001 prim_group_rid);
2002 if (sid == NULL) {
2003 return ldb_operr(ldb);
2004 }
2005
2006 if (dom_sid_equal(group_sid, sid)) {
2007 ldb_asprintf_errstring(ldb,
2008 "samldb: member %s already set via primaryGroupID %u",
2009 ldb_dn_get_linearized(member_dn), prim_group_rid);
2010 return LDB_ERR_ENTRY_ALREADY_EXISTS;
2011 }
2012 }
2013 }
2014
2015 talloc_free(res);
2016
2017 return LDB_SUCCESS;
2018 }
2019
2020 /* SAM objects have special rules regarding the "description" attribute on
2021 * modify operations. */
2022 static int samldb_description_check(struct samldb_ctx *ac, bool *modified)
2023 {
2024 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
2025 const char * const attrs[] = { "objectClass", "description", NULL };
2026 struct ldb_result *res;
2027 unsigned int i;
2028 int ret;
2029
2030 /* Fetch information from the existing object */
2031 ret = dsdb_module_search(ac->module, ac, &res, ac->msg->dn, LDB_SCOPE_BASE, attrs,
2032 DSDB_FLAG_NEXT_MODULE | DSDB_SEARCH_SHOW_DELETED, ac->req,
2033 "(|(objectclass=user)(objectclass=group)(objectclass=samDomain)(objectclass=samServer))");
2034 if (ret != LDB_SUCCESS) {
2035 /* don't treat it specially ... let normal error codes
2036 happen from other places */
2037 ldb_reset_err_string(ldb);
2038 return LDB_SUCCESS;
2039 }
2040 if (res->count == 0) {
2041 /* we didn't match the filter */
2042 talloc_free(res);
2043 return LDB_SUCCESS;
2044 }
2045
2046 /* We've to walk over all modification entries and consider the
2047 * "description" ones. */
2048 for (i = 0; i < ac->msg->num_elements; i++) {
2049 if (ldb_attr_cmp(ac->msg->elements[i].name, "description") == 0) {
2050 ac->msg->elements[i].flags |= LDB_FLAG_INTERNAL_FORCE_SINGLE_VALUE_CHECK;
2051 *modified = true;
2052 }
2053 }
2054
2055 talloc_free(res);
2056
2057 return LDB_SUCCESS;
2058 }
2059
2060 /* This trigger adapts the "servicePrincipalName" attributes if the
2061 * "dNSHostName" and/or "sAMAccountName" attribute change(s) */
2062 static int samldb_service_principal_names_change(struct samldb_ctx *ac)
2063 {
2064 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
2065 struct ldb_message_element *el = NULL, *el2 = NULL;
2066 struct ldb_message *msg;
2067 const char * const attrs[] = { "servicePrincipalName", NULL };
2068 struct ldb_result *res;
2069 const char *dns_hostname = NULL, *old_dns_hostname = NULL,
2070 *sam_accountname = NULL, *old_sam_accountname = NULL;
2071 unsigned int i, j;
2072 int ret;
2073
2074 el = dsdb_get_single_valued_attr(ac->msg, "dNSHostName",
2075 ac->req->operation);
2076 el2 = dsdb_get_single_valued_attr(ac->msg, "sAMAccountName",
2077 ac->req->operation);
2078 if ((el == NULL) && (el2 == NULL)) {
2079 /* we are not affected */
2080 return LDB_SUCCESS;
2081 }
2082
2083 /* Create a temporary message for fetching the "dNSHostName" */
2084 if (el != NULL) {
2085 const char *dns_attrs[] = { "dNSHostName", NULL };
2086 msg = ldb_msg_new(ac->msg);
2087 if (msg == NULL) {
2088 return ldb_module_oom(ac->module);
2089 }
2090 ret = ldb_msg_add(msg, el, 0);
2091 if (ret != LDB_SUCCESS) {
2092 return ret;
2093 }
2094 dns_hostname = talloc_strdup(ac,
2095 ldb_msg_find_attr_as_string(msg, "dNSHostName", NULL));
2096 if (dns_hostname == NULL) {
2097 return ldb_module_oom(ac->module);
2098 }
2099
2100 talloc_free(msg);
2101
2102 ret = dsdb_module_search_dn(ac->module, ac, &res, ac->msg->dn,
2103 dns_attrs, DSDB_FLAG_NEXT_MODULE, ac->req);
2104 if (ret == LDB_SUCCESS) {
2105 old_dns_hostname = ldb_msg_find_attr_as_string(res->msgs[0], "dNSHostName", NULL);
2106 }
2107 }
2108
2109 /* Create a temporary message for fetching the "sAMAccountName" */
2110 if (el2 != NULL) {
2111 char *tempstr, *tempstr2;
2112 const char *acct_attrs[] = { "sAMAccountName", NULL };
2113
2114 msg = ldb_msg_new(ac->msg);
2115 if (msg == NULL) {
2116 return ldb_module_oom(ac->module);
2117 }
2118 ret = ldb_msg_add(msg, el2, 0);
2119 if (ret != LDB_SUCCESS) {
2120 return ret;
2121 }
2122 tempstr = talloc_strdup(ac,
2123 ldb_msg_find_attr_as_string(msg, "sAMAccountName", NULL));
2124 talloc_free(msg);
2125
2126 ret = dsdb_module_search_dn(ac->module, ac, &res, ac->msg->dn, acct_attrs,
2127 DSDB_FLAG_NEXT_MODULE, ac->req);
2128 if (ret == LDB_SUCCESS) {
2129 tempstr2 = talloc_strdup(ac,
2130 ldb_msg_find_attr_as_string(res->msgs[0],
2131 "sAMAccountName", NULL));
2132 }
2133
2134
2135 /* The "sAMAccountName" needs some additional trimming: we need
2136 * to remove the trailing "$"s if they exist. */
2137 if ((tempstr != NULL) && (tempstr[0] != '\0') &&
2138 (tempstr[strlen(tempstr) - 1] == '$')) {
2139 tempstr[strlen(tempstr) - 1] = '\0';
2140 }
2141 if ((tempstr2 != NULL) && (tempstr2[0] != '\0') &&
2142 (tempstr2[strlen(tempstr2) - 1] == '$')) {
2143 tempstr2[strlen(tempstr2) - 1] = '\0';
2144 }
2145 sam_accountname = tempstr;
2146 old_sam_accountname = tempstr2;
2147 }
2148
2149 if (old_dns_hostname == NULL) {
2150 /* we cannot change when the old name is unknown */
2151 dns_hostname = NULL;
2152 }
2153 if ((old_dns_hostname != NULL) && (dns_hostname != NULL) &&
2154 (strcasecmp_m(old_dns_hostname, dns_hostname) == 0)) {
2155 /* The "dNSHostName" didn't change */
2156 dns_hostname = NULL;
2157 }
2158
2159 if (old_sam_accountname == NULL) {
2160 /* we cannot change when the old name is unknown */
2161 sam_accountname = NULL;
2162 }
2163 if ((old_sam_accountname != NULL) && (sam_accountname != NULL) &&
2164 (strcasecmp_m(old_sam_accountname, sam_accountname) == 0)) {
2165 /* The "sAMAccountName" didn't change */
2166 sam_accountname = NULL;
2167 }
2168
2169 if ((dns_hostname == NULL) && (sam_accountname == NULL)) {
2170 /* Well, there are information missing (old name(s)) or the
2171 * names didn't change. We've nothing to do and can exit here */
2172 return LDB_SUCCESS;
2173 }
2174
2175 /* Potential "servicePrincipalName" changes in the same request have to
2176 * be handled before the update (Windows behaviour). */
2177 el = ldb_msg_find_element(ac->msg, "servicePrincipalName");
2178 if (el != NULL) {
2179 msg = ldb_msg_new(ac->msg);
2180 if (msg == NULL) {
2181 return ldb_module_oom(ac->module);
2182 }
2183 msg->dn = ac->msg->dn;
2184
2185 do {
2186 ret = ldb_msg_add(msg, el, el->flags);
2187 if (ret != LDB_SUCCESS) {
2188 return ret;
2189 }
2190
2191 ldb_msg_remove_element(ac->msg, el);
2192
2193 el = ldb_msg_find_element(ac->msg,
2194 "servicePrincipalName");
2195 } while (el != NULL);
2196
2197 ret = dsdb_module_modify(ac->module, msg,
2198 DSDB_FLAG_NEXT_MODULE, ac->req);
2199 if (ret != LDB_SUCCESS) {
2200 return ret;
2201 }
2202 talloc_free(msg);
2203 }
2204
2205 /* Fetch the "servicePrincipalName"s if any */
2206 ret = dsdb_module_search(ac->module, ac, &res, ac->msg->dn, LDB_SCOPE_BASE, attrs,
2207 DSDB_FLAG_NEXT_MODULE, ac->req, NULL);
2208 if (ret != LDB_SUCCESS) {
2209 return ret;
2210 }
2211 if ((res->count != 1) || (res->msgs[0]->num_elements > 1)) {
2212 return ldb_operr(ldb);
2213 }
2214
2215 if (res->msgs[0]->num_elements == 1) {
2216 /*
2217 * Yes, we do have "servicePrincipalName"s. First we update them
2218 * locally, that means we do always substitute the current
2219 * "dNSHostName" with the new one and/or "sAMAccountName"
2220 * without "$" with the new one and then we append the
2221 * modified "servicePrincipalName"s as a message element
2222 * replace to the modification request (Windows behaviour). We
2223 * need also to make sure that the values remain case-
2224 * insensitively unique.
2225 */
2226
2227 ret = ldb_msg_add_empty(ac->msg, "servicePrincipalName",
2228 LDB_FLAG_MOD_REPLACE, &el);
2229 if (ret != LDB_SUCCESS) {
2230 return ret;
2231 }
2232
2233 for (i = 0; i < res->msgs[0]->elements[0].num_values; i++) {
2234 char *old_str, *new_str, *pos;
2235 const char *tok;
2236 struct ldb_val *vals;
2237 bool found = false;
2238
2239 old_str = (char *)
2240 res->msgs[0]->elements[0].values[i].data;
2241
2242 new_str = talloc_strdup(ac->msg,
2243 strtok_r(old_str, "/", &pos));
2244 if (new_str == NULL) {
2245 return ldb_module_oom(ac->module);
2246 }
2247
2248 while ((tok = strtok_r(NULL, "/", &pos)) != NULL) {
2249 if ((dns_hostname != NULL) &&
2250 (strcasecmp_m(tok, old_dns_hostname) == 0)) {
2251 tok = dns_hostname;
2252 }
2253 if ((sam_accountname != NULL) &&
2254 (strcasecmp_m(tok, old_sam_accountname) == 0)) {
2255 tok = sam_accountname;
2256 }
2257
2258 new_str = talloc_asprintf(ac->msg, "%s/%s",
2259 new_str, tok);
2260 if (new_str == NULL) {
2261 return ldb_module_oom(ac->module);
2262 }
2263 }
2264
2265 /* Uniqueness check */
2266 for (j = 0; (!found) && (j < el->num_values); j++) {
2267 if (strcasecmp_m((char *)el->values[j].data,
2268 new_str) == 0) {
2269 found = true;
2270 }
2271 }
2272 if (found) {
2273 continue;
2274 }
2275
2276 /*
2277 * append the new "servicePrincipalName" -
2278 * code derived from ldb_msg_add_value().
2279 *
2280 * Open coded to make it clear that we must
2281 * append to the MOD_REPLACE el created above.
2282 */
2283 vals = talloc_realloc(ac->msg, el->values,
2284 struct ldb_val,
2285 el->num_values + 1);
2286 if (vals == NULL) {
2287 return ldb_module_oom(ac->module);
2288 }
2289 el->values = vals;
2290 el->values[el->num_values] = data_blob_string_const(new_str);
2291 ++(el->num_values);
2292 }
2293 }
2294
2295 talloc_free(res);
2296
2297 return LDB_SUCCESS;
2298 }
2299
2300 /* This checks the "fSMORoleOwner" attributes */
2301 static int samldb_fsmo_role_owner_check(struct samldb_ctx *ac)
2302 {
2303 struct ldb_context *ldb = ldb_module_get_ctx(ac->module);
2304 const char * const no_attrs[] = { NULL };
2305 struct ldb_message_element *el;
2306 struct ldb_message *tmp_msg;
2307 struct ldb_dn *res_dn;
2308 struct ldb_result *res;
2309 int ret;
2310
2311 el = dsdb_get_single_valued_attr(ac->msg, "fSMORoleOwner",
2312 ac->req->operation);
2313 if (el == NULL) {
2314 /* we are not affected */
2315 return LDB_SUCCESS;
2316 }
2317
2318 /* Create a temporary message for fetching the "fSMORoleOwner" */
2319 tmp_msg = ldb_msg_new(ac->msg);
2320 if (tmp_msg == NULL) {
2321 return ldb_module_oom(ac->module);
2322 }
2323 ret = ldb_msg_add(tmp_msg, el, 0);
2324 if (ret != LDB_SUCCESS) {
2325 return ret;
2326 }
2327 res_dn = ldb_msg_find_attr_as_dn(ldb, ac, tmp_msg, "fSMORoleOwner");
2328 talloc_free(tmp_msg);
2329
2330 if (res_dn == NULL) {
2331 ldb_set_errstring(ldb,
2332 "samldb: 'fSMORoleOwner' attributes have to reference 'nTDSDSA' entries!");
2333 if (ac->req->operation == LDB_ADD) {
2334 return LDB_ERR_CONSTRAINT_VIOLATION;
2335 } else {
2336 return LDB_ERR_UNWILLING_TO_PERFORM;
2337 }
2338 }
2339
2340 /* Fetched DN has to reference a "nTDSDSA" entry */
2341 ret = dsdb_module_search(ac->module, ac, &res, res_dn, LDB_SCOPE_BASE,
2342 no_attrs,
2343 DSDB_FLAG_NEXT_MODULE | DSDB_SEARCH_SHOW_DELETED,
2344 ac->req, "(objectClass=nTDSDSA)");
2345 if (ret != LDB_SUCCESS) {
2346 return ret;
2347 }
2348 if (res->count != 1) {
2349 ldb_set_errstring(ldb,
2350 "samldb: 'fSMORoleOwner' attributes have to reference 'nTDSDSA' entries!");
2351 return LDB_ERR_UNWILLING_TO_PERFORM;
2352 }
2353
2354 talloc_free(res);
2355
2356 return LDB_SUCCESS;
2357 }
2358
2359
2360 /* add */
2361 static int samldb_add(struct ldb_module *module, struct ldb_request *req)
2362 {
2363 struct ldb_context *ldb;
2364 struct samldb_ctx *ac;
2365 struct ldb_message_element *el;
2366 int ret;
2367
2368 ldb = ldb_module_get_ctx(module);
2369 ldb_debug(ldb, LDB_DEBUG_TRACE, "samldb_add\n");
2370
2371 /* do not manipulate our control entries */
2372 if (ldb_dn_is_special(req->op.add.message->dn)) {
2373 return ldb_next_request(module, req);
2374 }
2375
2376 ac = samldb_ctx_init(module, req);
2377 if (ac == NULL) {
2378 return ldb_operr(ldb);
2379 }
2380
2381 /* build the new msg */
2382 ac->msg = ldb_msg_copy_shallow(ac, req->op.add.message);
2383 if (ac->msg == NULL) {
2384 talloc_free(ac);
2385 ldb_debug(ldb, LDB_DEBUG_FATAL,
2386 "samldb_add: ldb_msg_copy_shallow failed!\n");
2387 return ldb_operr(ldb);
2388 }
2389
2390 el = ldb_msg_find_element(ac->msg, "fSMORoleOwner");
2391 if (el != NULL) {
2392 ret = samldb_fsmo_role_owner_check(ac);
2393 if (ret != LDB_SUCCESS) {
2394 return ret;
2395 }
2396 }
2397
2398 if (samdb_find_attribute(ldb, ac->msg,
2399 "objectclass", "user") != NULL) {
2400 ac->type = SAMLDB_TYPE_USER;
2401
2402 ret = samldb_prim_group_trigger(ac);
2403 if (ret != LDB_SUCCESS) {
2404 return ret;
2405 }
2406
2407 ret = samldb_objectclass_trigger(ac);
2408 if (ret != LDB_SUCCESS) {
2409 return ret;
2410 }
2411
2412 return samldb_fill_object(ac);
2413 }
2414
2415 if (samdb_find_attribute(ldb, ac->msg,
2416 "objectclass", "group") != NULL) {
2417 ac->type = SAMLDB_TYPE_GROUP;
2418
2419 ret = samldb_objectclass_trigger(ac);
2420 if (ret != LDB_SUCCESS) {
2421 return ret;
2422 }
2423
2424 return samldb_fill_object(ac);
2425 }
2426
2427 /* perhaps a foreignSecurityPrincipal? */
2428 if (samdb_find_attribute(ldb, ac->msg,
2429 "objectclass",
2430 "foreignSecurityPrincipal") != NULL) {
2431 return samldb_fill_foreignSecurityPrincipal_object(ac);
2432 }
2433
2434 if (samdb_find_attribute(ldb, ac->msg,
2435 "objectclass", "classSchema") != NULL) {
2436 ret = samldb_schema_info_update(ac);
2437 if (ret != LDB_SUCCESS) {
2438 talloc_free(ac);
2439 return ret;
2440 }
2441
2442 ac->type = SAMLDB_TYPE_CLASS;
2443 return samldb_fill_object(ac);
2444 }
2445
2446 if (samdb_find_attribute(ldb, ac->msg,
2447 "objectclass", "attributeSchema") != NULL) {
2448 ret = samldb_schema_info_update(ac);
2449 if (ret != LDB_SUCCESS) {
2450 talloc_free(ac);
2451 return ret;
2452 }
2453
2454 ac->type = SAMLDB_TYPE_ATTRIBUTE;
2455 return samldb_fill_object(ac);
2456 }
2457
2458 talloc_free(ac);
2459
2460 /* nothing matched, go on */
2461 return ldb_next_request(module, req);
2462 }
2463
2464 /* modify */
2465 static int samldb_modify(struct ldb_module *module, struct ldb_request *req)
2466 {
2467 struct ldb_context *ldb;
2468 struct samldb_ctx *ac;
2469 struct ldb_message_element *el, *el2;
2470 bool modified = false;
2471 int ret;
2472
2473 if (ldb_dn_is_special(req->op.mod.message->dn)) {
2474 /* do not manipulate our control entries */
2475 return ldb_next_request(module, req);
2476 }
2477
2478 ldb = ldb_module_get_ctx(module);
2479
2480 /* make sure that "objectSid" is not specified */
2481 el = ldb_msg_find_element(req->op.mod.message, "objectSid");
2482 if (el != NULL) {
2483 if (ldb_request_get_control(req, LDB_CONTROL_PROVISION_OID) == NULL) {
2484 ldb_set_errstring(ldb,
2485 "samldb: objectSid must not be specified!");
2486 return LDB_ERR_UNWILLING_TO_PERFORM;
2487 }
2488 }
2489 /* make sure that "sAMAccountType" is not specified */
2490 el = ldb_msg_find_element(req->op.mod.message, "sAMAccountType");
2491 if (el != NULL) {
2492 ldb_set_errstring(ldb,
2493 "samldb: sAMAccountType must not be specified!");
2494 return LDB_ERR_UNWILLING_TO_PERFORM;
2495 }
2496 /* make sure that "isCriticalSystemObject" is not specified */
2497 el = ldb_msg_find_element(req->op.mod.message, "isCriticalSystemObject");
2498 if (el != NULL) {
2499 if (ldb_request_get_control(req, LDB_CONTROL_RELAX_OID) == NULL) {
2500 ldb_set_errstring(ldb,
2501 "samldb: isCriticalSystemObject must not be specified!");
2502 return LDB_ERR_UNWILLING_TO_PERFORM;
2503 }
2504 }
2505
2506 /* msDS-IntId is not allowed to be modified
2507 * except when modification comes from replication */
2508 if (ldb_msg_find_element(req->op.mod.message, "msDS-IntId")) {
2509 if (!ldb_request_get_control(req,
2510 DSDB_CONTROL_REPLICATED_UPDATE_OID)) {
2511 return LDB_ERR_CONSTRAINT_VIOLATION;
2512 }
2513 }
2514
2515 ac = samldb_ctx_init(module, req);
2516 if (ac == NULL) {
2517 return ldb_operr(ldb);
2518 }
2519
2520 /* build the new msg */
2521 ac->msg = ldb_msg_copy_shallow(ac, req->op.mod.message);
2522 if (ac->msg == NULL) {
2523 talloc_free(ac);
2524 ldb_debug(ldb, LDB_DEBUG_FATAL,
2525 "samldb_modify: ldb_msg_copy_shallow failed!\n");
2526 return ldb_operr(ldb);
2527 }
2528
2529 el = ldb_msg_find_element(ac->msg, "primaryGroupID");
2530 if (el != NULL) {
2531 ret = samldb_prim_group_trigger(ac);
2532 if (ret != LDB_SUCCESS) {
2533 return ret;
2534 }
2535 }
2536
2537 el = ldb_msg_find_element(ac->msg, "userAccountControl");
2538 if (el != NULL) {
2539 modified = true;
2540 ret = samldb_user_account_control_change(ac);
2541 if (ret != LDB_SUCCESS) {
2542 return ret;
2543 }
2544 }
2545
2546 el = ldb_msg_find_element(ac->msg, "groupType");
2547 if (el != NULL) {
2548 modified = true;
2549 ret = samldb_group_type_change(ac);
2550 if (ret != LDB_SUCCESS) {
2551 return ret;
2552 }
2553 }
2554
2555 el = ldb_msg_find_element(ac->msg, "sAMAccountName");
2556 if (el != NULL) {
2557 ret = samldb_sam_accountname_check(ac);
2558 if (ret != LDB_SUCCESS) {
2559 return ret;
2560 }
2561 }
2562
2563 el = ldb_msg_find_element(ac->msg, "member");
2564 if (el != NULL) {
2565 ret = samldb_member_check(ac);
2566 if (ret != LDB_SUCCESS) {
2567 return ret;
2568 }
2569 }
2570
2571 el = ldb_msg_find_element(ac->msg, "description");
2572 if (el != NULL) {
2573 ret = samldb_description_check(ac, &modified);
2574 if (ret != LDB_SUCCESS) {
2575 return ret;
2576 }
2577 }
2578
2579 el = ldb_msg_find_element(ac->msg, "dNSHostName");
2580 el2 = ldb_msg_find_element(ac->msg, "sAMAccountName");
2581 if ((el != NULL) || (el2 != NULL)) {
2582 modified = true;
2583 ret = samldb_service_principal_names_change(ac);
2584 if (ret != LDB_SUCCESS) {
2585 return ret;
2586 }
2587 }
2588
2589 el = ldb_msg_find_element(ac->msg, "fSMORoleOwner");
2590 if (el != NULL) {
2591 ret = samldb_fsmo_role_owner_check(ac);
2592 if (ret != LDB_SUCCESS) {
2593 return ret;
2594 }
2595 }
2596
2597 if (modified) {
2598 struct ldb_request *child_req;
2599
2600 /* Now perform the real modifications as a child request */
2601 ret = ldb_build_mod_req(&child_req, ldb, ac,
2602 ac->msg,
2603 req->controls,
2604 req, dsdb_next_callback,
2605 req);
2606 LDB_REQ_SET_LOCATION(child_req);
2607 if (ret != LDB_SUCCESS) {
2608 return ret;
2609 }
2610
2611 return ldb_next_request(module, child_req);
2612 }
2613
2614 talloc_free(ac);
2615
2616 /* no change which interests us, go on */
2617 return ldb_next_request(module, req);
2618 }
2619
2620 /* delete */
2621
2622 static int samldb_prim_group_users_check(struct samldb_ctx *ac)
2623 {
2624 struct ldb_context *ldb;
2625 struct dom_sid *sid;
2626 uint32_t rid;
2627 NTSTATUS status;
2628 int ret;
2629 struct ldb_result *res;
2630 const char * const attrs[] = { "objectSid", "isDeleted", NULL };
2631 const char * const noattrs[] = { NULL };
2632
2633 ldb = ldb_module_get_ctx(ac->module);
2634
2635 /* Finds out the SID/RID of the SAM object */
2636 ret = dsdb_module_search_dn(ac->module, ac, &res, ac->req->op.del.dn,
2637 attrs,
2638 DSDB_FLAG_NEXT_MODULE | DSDB_SEARCH_SHOW_DELETED,
2639 ac->req);
2640 if (ret != LDB_SUCCESS) {
2641 return ret;
2642 }
2643
2644 if (ldb_msg_check_string_attribute(res->msgs[0], "isDeleted", "TRUE")) {
2645 return LDB_SUCCESS;
2646 }
2647
2648 sid = samdb_result_dom_sid(ac, res->msgs[0], "objectSid");
2649 if (sid == NULL) {
2650 /* No SID - it might not be a SAM object - therefore ok */
2651 return LDB_SUCCESS;
2652 }
2653 status = dom_sid_split_rid(ac, sid, NULL, &rid);
2654 if (!NT_STATUS_IS_OK(status)) {
2655 return ldb_operr(ldb);
2656 }
2657 if (rid == 0) {
2658 /* Special object (security principal?) */
2659 return LDB_SUCCESS;
2660 }
2661
2662 /* Deny delete requests from groups which are primary ones */
2663 ret = dsdb_module_search(ac->module, ac, &res,
2664 ldb_get_default_basedn(ldb),
2665 LDB_SCOPE_SUBTREE, noattrs,
2666 DSDB_FLAG_NEXT_MODULE,
2667 ac->req,
2668 "(&(primaryGroupID=%u)(objectClass=user))", rid);
2669 if (ret != LDB_SUCCESS) {
2670 return ret;
2671 }
2672 if (res->count > 0) {
2673 return LDB_ERR_ENTRY_ALREADY_EXISTS;
2674 }
2675
2676 return LDB_SUCCESS;
2677 }
2678
2679 static int samldb_delete(struct ldb_module *module, struct ldb_request *req)
2680 {
2681 struct samldb_ctx *ac;
2682 int ret;
2683
2684 if (ldb_dn_is_special(req->op.del.dn)) {
2685 /* do not manipulate our control entries */
2686 return ldb_next_request(module, req);
2687 }
2688
2689 ac = samldb_ctx_init(module, req);
2690 if (ac == NULL) {
2691 return ldb_operr(ldb_module_get_ctx(module));
2692 }
2693
2694 ret = samldb_prim_group_users_check(ac);
2695 if (ret != LDB_SUCCESS) {
2696 return ret;
2697 }
2698
2699 talloc_free(ac);
2700
2701 return ldb_next_request(module, req);
2702 }
2703
2704 /* extended */
2705
2706 static int samldb_extended_allocate_rid_pool(struct ldb_module *module, struct ldb_request *req)
2707 {
2708 struct ldb_context *ldb = ldb_module_get_ctx(module);
2709 struct dsdb_fsmo_extended_op *exop;
2710 int ret;
2711
2712 exop = talloc_get_type(req->op.extended.data,
2713 struct dsdb_fsmo_extended_op);
2714 if (!exop) {
2715 ldb_set_errstring(ldb,
2716 "samldb_extended_allocate_rid_pool: invalid extended data");
2717 return LDB_ERR_PROTOCOL_ERROR;
2718 }
2719
2720 ret = ridalloc_allocate_rid_pool_fsmo(module, exop, req);
2721 if (ret != LDB_SUCCESS) {
2722 return ret;
2723 }
2724
2725 return ldb_module_done(req, NULL, NULL, LDB_SUCCESS);
2726 }
2727
2728 static int samldb_extended(struct ldb_module *module, struct ldb_request *req)
2729 {
2730 if (strcmp(req->op.extended.oid, DSDB_EXTENDED_ALLOCATE_RID_POOL) == 0) {
2731 return samldb_extended_allocate_rid_pool(module, req);
2732 }
2733
2734 return ldb_next_request(module, req);
2735 }
2736
2737
2738 static const struct ldb_module_ops ldb_samldb_module_ops = {
2739 .name = "samldb",
2740 .add = samldb_add,
2741 .modify = samldb_modify,
2742 .del = samldb_delete,
2743 .extended = samldb_extended
2744 };
2745
2746
2747 int ldb_samldb_module_init(const char *version)
2748 {
2749 LDB_MODULE_CHECK_VERSION(version);
2750 return ldb_register_module(&ldb_samldb_module_ops);
2751 }
Samba GIT mirror