4 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2014
5 Copyright (C) Simo Sorce 2004-2008
6 Copyright (C) Matthias Dieter Wallnöfer 2009-2011
7 Copyright (C) Matthieu Patou 2012
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.
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.
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/>.
26 * Component: ldb samldb module
28 * Description: various internal DSDB triggers - most for SAM specific objects
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"
43 #include "param/param.h"
44 #include "libds/common/flag_mapping.h"
47 enum samldb_add_type
{
54 typedef int (*samldb_step_fn_t
)(struct samldb_ctx
*);
57 struct samldb_step
*next
;
62 struct ldb_module
*module
;
63 struct ldb_request
*req
;
65 /* used for add operations */
66 enum samldb_add_type type
;
68 /* the resulting message */
69 struct ldb_message
*msg
;
71 /* used in "samldb_find_for_defaultObjectCategory" */
72 struct ldb_dn
*dn
, *res_dn
;
74 /* all the async steps necessary to complete the operation */
75 struct samldb_step
*steps
;
76 struct samldb_step
*curstep
;
78 /* If someone set an ares to forward controls and response back to the caller */
79 struct ldb_reply
*ares
;
82 static struct samldb_ctx
*samldb_ctx_init(struct ldb_module
*module
,
83 struct ldb_request
*req
)
85 struct ldb_context
*ldb
;
86 struct samldb_ctx
*ac
;
88 ldb
= ldb_module_get_ctx(module
);
90 ac
= talloc_zero(req
, struct samldb_ctx
);
102 static int samldb_add_step(struct samldb_ctx
*ac
, samldb_step_fn_t fn
)
104 struct samldb_step
*step
, *stepper
;
106 step
= talloc_zero(ac
, struct samldb_step
);
108 return ldb_oom(ldb_module_get_ctx(ac
->module
));
113 if (ac
->steps
== NULL
) {
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
;
127 static int samldb_first_step(struct samldb_ctx
*ac
)
129 if (ac
->steps
== NULL
) {
130 return ldb_operr(ldb_module_get_ctx(ac
->module
));
133 ac
->curstep
= ac
->steps
;
134 return ac
->curstep
->fn(ac
);
137 static int samldb_next_step(struct samldb_ctx
*ac
)
139 if (ac
->curstep
->next
) {
140 ac
->curstep
= ac
->curstep
->next
;
141 return ac
->curstep
->fn(ac
);
144 /* We exit the samldb module here. If someone set an "ares" to forward
145 * controls and response back to the caller, use them. */
147 return ldb_module_done(ac
->req
, ac
->ares
->controls
,
148 ac
->ares
->response
, LDB_SUCCESS
);
150 return ldb_module_done(ac
->req
, NULL
, NULL
, LDB_SUCCESS
);
155 /* sAMAccountName handling */
157 static int samldb_generate_sAMAccountName(struct ldb_context
*ldb
,
158 struct ldb_message
*msg
)
162 /* Format: $000000-000000000000 */
164 name
= talloc_asprintf(msg
, "$%.6X-%.6X%.6X",
165 (unsigned int)generate_random(),
166 (unsigned int)generate_random(),
167 (unsigned int)generate_random());
171 return ldb_msg_add_steal_string(msg
, "sAMAccountName", name
);
174 static int samldb_check_sAMAccountName(struct samldb_ctx
*ac
)
176 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
179 struct ldb_result
*res
;
180 const char * const noattrs
[] = { NULL
};
182 if (ldb_msg_find_element(ac
->msg
, "sAMAccountName") == NULL
) {
183 ret
= samldb_generate_sAMAccountName(ldb
, ac
->msg
);
184 if (ret
!= LDB_SUCCESS
) {
189 name
= ldb_msg_find_attr_as_string(ac
->msg
, "sAMAccountName", 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
;
197 ret
= dsdb_module_search(ac
->module
, ac
, &res
,
198 ldb_get_default_basedn(ldb
), LDB_SCOPE_SUBTREE
, noattrs
,
199 DSDB_FLAG_NEXT_MODULE
,
201 "(sAMAccountName=%s)",
202 ldb_binary_encode_string(ac
, name
));
203 if (ret
!= LDB_SUCCESS
) {
206 if (res
->count
!= 0) {
207 ldb_asprintf_errstring(ldb
,
208 "samldb: Account name (sAMAccountName) '%s' already in use!",
211 return LDB_ERR_ENTRY_ALREADY_EXISTS
;
215 return samldb_next_step(ac
);
219 static bool samldb_msg_add_sid(struct ldb_message
*msg
,
221 const struct dom_sid
*sid
)
224 enum ndr_err_code ndr_err
;
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
)) {
231 return (ldb_msg_add_value(msg
, name
, &v
, NULL
) == 0);
235 /* allocate a SID using our RID Set */
236 static int samldb_allocate_sid(struct samldb_ctx
*ac
)
240 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
243 ret
= ridalloc_allocate_rid(ac
->module
, &rid
, ac
->req
);
244 if (ret
!= LDB_SUCCESS
) {
248 sid
= dom_sid_add_rid(ac
, samdb_domain_sid(ldb
), rid
);
250 return ldb_module_oom(ac
->module
);
253 if ( ! samldb_msg_add_sid(ac
->msg
, "objectSid", sid
)) {
254 return ldb_operr(ldb
);
257 return samldb_next_step(ac
);
261 see if a krbtgt_number is available
263 static bool samldb_krbtgtnumber_available(struct samldb_ctx
*ac
,
264 uint32_t krbtgt_number
)
266 TALLOC_CTX
*tmp_ctx
= talloc_new(ac
);
267 struct ldb_result
*res
;
268 const char * const no_attrs
[] = { NULL
};
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
,
276 "(msDC-SecondaryKrbTgtNumber=%u)",
278 if (ret
== LDB_SUCCESS
&& res
->count
== 0) {
279 talloc_free(tmp_ctx
);
282 talloc_free(tmp_ctx
);
286 /* special handling for add in RODC join */
287 static int samldb_rodc_add(struct samldb_ctx
*ac
)
289 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
290 uint32_t krbtgt_number
, i_start
, i
;
293 struct ldb_val newpass_utf16
;
295 /* find a unused msDC-SecondaryKrbTgtNumber */
296 i_start
= generate_random() & 0xFFFF;
301 for (i
=i_start
; i
<=0xFFFF; i
++) {
302 if (samldb_krbtgtnumber_available(ac
, i
)) {
307 for (i
=1; i
<i_start
; i
++) {
308 if (samldb_krbtgtnumber_available(ac
, i
)) {
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
;
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
);
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
);
332 ret
= ldb_msg_add_fmt(ac
->msg
, "sAMAccountName", "krbtgt_%u",
334 if (ret
!= LDB_SUCCESS
) {
335 return ldb_operr(ldb
);
338 newpass
= generate_random_password(ac
->msg
, 128, 255);
339 if (newpass
== NULL
) {
340 return ldb_operr(ldb
);
343 if (!convert_string_talloc(ac
,
345 newpass
, strlen(newpass
),
346 (void *)&newpass_utf16
.data
,
347 &newpass_utf16
.length
)) {
348 ldb_asprintf_errstring(ldb
,
350 "failed to generate UTF16 password from random password");
351 return LDB_ERR_OPERATIONS_ERROR
;
353 ret
= ldb_msg_add_steal_value(ac
->msg
, "clearTextPassword", &newpass_utf16
);
354 if (ret
!= LDB_SUCCESS
) {
355 return ldb_operr(ldb
);
358 return samldb_next_step(ac
);
361 static int samldb_find_for_defaultObjectCategory(struct samldb_ctx
*ac
)
363 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
364 struct ldb_result
*res
;
365 const char * const no_attrs
[] = { NULL
};
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
,
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
;
387 if ((ret
!= LDB_ERR_NO_SUCH_OBJECT
) && (ret
!= LDB_SUCCESS
)) {
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
);
399 if (ldb_msg_add_string(m
, "defaultObjectCategory",
400 ldb_dn_get_extended_linearized(m
, res
->msgs
[0]->dn
, 1)) !=
404 m
->elements
[0].flags
= LDB_FLAG_MOD_REPLACE
;
406 ret
= dsdb_module_modify(ac
->module
, m
,
407 DSDB_FLAG_NEXT_MODULE
,
409 if (ret
!= LDB_SUCCESS
) {
417 return samldb_next_step(ac
);
421 * msDS-IntId attributeSchema attribute handling
422 * during LDB_ADD request processing
424 static int samldb_add_handle_msDS_IntId(struct samldb_ctx
*ac
)
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
;
436 ldb
= ldb_module_get_ctx(ac
->module
);
437 schema_dn
= ldb_get_schema_basedn(ldb
);
439 /* replicated update should always go through */
440 if (ldb_request_get_control(ac
->req
,
441 DSDB_CONTROL_REPLICATED_UPDATE_OID
)) {
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
;
451 /* do not generate msDS-IntId if Relax control is passed */
452 if (ldb_request_get_control(ac
->req
, LDB_CONTROL_RELAX_OID
)) {
456 /* check Functional Level */
457 if (dsdb_functional_level(ldb
) < DS_DOMAIN_FUNCTION_2003
) {
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
) {
466 schema
= dsdb_get_schema(ldb
, NULL
);
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
);
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"));
485 msds_intid
= msds_intid_struct
->msds_intid
;
488 /* probe id values until unique one is found */
490 uint64_t current_usn
;
492 if (msds_intid
> 0xBFFFFFFF) {
493 msds_intid
= 0x80000001;
496 * Alternative strategy to a costly (even indexed search) to the
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
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.
507 if (dsdb_attribute_by_attributeID_id(schema
, msds_intid
)) {
508 msds_intid
= generate_random() % 0X3FFFFFFF;
509 msds_intid
+= 0x80000000;
513 ret
= dsdb_module_load_partition_usn(ac
->module
, schema_dn
,
514 ¤t_usn
, NULL
, NULL
);
515 if (ret
!= LDB_SUCCESS
) {
516 ldb_debug_set(ldb
, LDB_DEBUG_ERROR
,
517 __location__
": Searching for schema USN failed: %s\n",
519 return ldb_operr(ldb
);
522 /* current_usn can be lesser than msds_intid_struct-> if there is
523 * uncommited changes.
525 if (current_usn
> msds_intid_struct
->usn
) {
526 /* oups something has changed, someone/something
527 * else is modifying or has modified the schema
528 * we'd better check this intid is the database directly
531 DEBUG(2, ("Schema has changed, searching the database for the unicity of %d\n",
534 ret
= dsdb_module_search(ac
->module
, ac
,
536 schema_dn
, LDB_SCOPE_ONELEVEL
, NULL
,
537 DSDB_FLAG_NEXT_MODULE
,
539 "(msDS-IntId=%d)", msds_intid
);
540 if (ret
!= LDB_SUCCESS
) {
541 ldb_debug_set(ldb
, LDB_DEBUG_ERROR
,
542 __location__
": Searching for msDS-IntId=%d failed - %s\n",
545 return ldb_operr(ldb
);
547 id_exists
= (ldb_res
->count
> 0);
548 talloc_free(ldb_res
);
554 msds_intid_struct
->msds_intid
= msds_intid
;
555 ldb_set_opaque(ldb
, SAMLDB_MSDS_INTID_OPAQUE
, msds_intid_struct
);
557 return samdb_msg_add_int(ldb
, ac
->msg
, ac
->msg
, "msDS-IntId",
563 * samldb_add_entry (async)
566 static int samldb_add_entry_callback(struct ldb_request
*req
,
567 struct ldb_reply
*ares
)
569 struct ldb_context
*ldb
;
570 struct samldb_ctx
*ac
;
573 ac
= talloc_get_type(req
->context
, struct samldb_ctx
);
574 ldb
= ldb_module_get_ctx(ac
->module
);
577 return ldb_module_done(ac
->req
, NULL
, NULL
,
578 LDB_ERR_OPERATIONS_ERROR
);
581 if (ares
->type
== LDB_REPLY_REFERRAL
) {
582 return ldb_module_send_referral(ac
->req
, ares
->referral
);
585 if (ares
->error
!= LDB_SUCCESS
) {
586 return ldb_module_done(ac
->req
, ares
->controls
,
587 ares
->response
, ares
->error
);
589 if (ares
->type
!= LDB_REPLY_DONE
) {
590 ldb_asprintf_errstring(ldb
, "Invalid LDB reply type %d", ares
->type
);
591 return ldb_module_done(ac
->req
, NULL
, NULL
,
592 LDB_ERR_OPERATIONS_ERROR
);
595 /* The caller may wish to get controls back from the add */
596 ac
->ares
= talloc_steal(ac
, ares
);
598 ret
= samldb_next_step(ac
);
599 if (ret
!= LDB_SUCCESS
) {
600 return ldb_module_done(ac
->req
, NULL
, NULL
, ret
);
605 static int samldb_add_entry(struct samldb_ctx
*ac
)
607 struct ldb_context
*ldb
;
608 struct ldb_request
*req
;
611 ldb
= ldb_module_get_ctx(ac
->module
);
613 ret
= ldb_build_add_req(&req
, ldb
, ac
,
616 ac
, samldb_add_entry_callback
,
618 LDB_REQ_SET_LOCATION(req
);
619 if (ret
!= LDB_SUCCESS
) {
623 return ldb_next_request(ac
->module
, req
);
627 * return true if msg carries an attributeSchema that is intended to be RODC
628 * filtered but is also a system-critical attribute.
630 static bool check_rodc_critical_attribute(struct ldb_message
*msg
)
632 uint32_t schemaFlagsEx
, searchFlags
, rodc_filtered_flags
;
634 schemaFlagsEx
= ldb_msg_find_attr_as_uint(msg
, "schemaFlagsEx", 0);
635 searchFlags
= ldb_msg_find_attr_as_uint(msg
, "searchFlags", 0);
636 rodc_filtered_flags
= (SEARCH_FLAG_RODC_ATTRIBUTE
637 | SEARCH_FLAG_CONFIDENTIAL
);
639 if ((schemaFlagsEx
& SCHEMA_FLAG_ATTR_IS_CRITICAL
) &&
640 ((searchFlags
& rodc_filtered_flags
) == rodc_filtered_flags
)) {
648 static int samldb_fill_object(struct samldb_ctx
*ac
)
650 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
653 /* Add information for the different account types */
655 case SAMLDB_TYPE_USER
: {
656 struct ldb_control
*rodc_control
= ldb_request_get_control(ac
->req
,
657 LDB_CONTROL_RODC_DCPROMO_OID
);
658 if (rodc_control
!= NULL
) {
659 /* see [MS-ADTS] 3.1.1.3.4.1.23 LDAP_SERVER_RODC_DCPROMO_OID */
660 rodc_control
->critical
= false;
661 ret
= samldb_add_step(ac
, samldb_rodc_add
);
662 if (ret
!= LDB_SUCCESS
) return ret
;
665 /* check if we have a valid sAMAccountName */
666 ret
= samldb_add_step(ac
, samldb_check_sAMAccountName
);
667 if (ret
!= LDB_SUCCESS
) return ret
;
669 ret
= samldb_add_step(ac
, samldb_add_entry
);
670 if (ret
!= LDB_SUCCESS
) return ret
;
674 case SAMLDB_TYPE_GROUP
: {
675 /* check if we have a valid sAMAccountName */
676 ret
= samldb_add_step(ac
, samldb_check_sAMAccountName
);
677 if (ret
!= LDB_SUCCESS
) return ret
;
679 ret
= samldb_add_step(ac
, samldb_add_entry
);
680 if (ret
!= LDB_SUCCESS
) return ret
;
684 case SAMLDB_TYPE_CLASS
: {
685 const struct ldb_val
*rdn_value
, *def_obj_cat_val
;
686 unsigned int v
= ldb_msg_find_attr_as_uint(ac
->msg
, "objectClassCategory", -2);
688 /* As discussed with Microsoft through dochelp in April 2012 this is the behavior of windows*/
689 if (!ldb_msg_find_element(ac
->msg
, "subClassOf")) {
690 ret
= ldb_msg_add_string(ac
->msg
, "subClassOf", "top");
691 if (ret
!= LDB_SUCCESS
) return ret
;
694 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
696 if (ret
!= LDB_SUCCESS
) return ret
;
698 /* do not allow to mark an attributeSchema as RODC filtered if it
699 * is system-critical */
700 if (check_rodc_critical_attribute(ac
->msg
)) {
701 ldb_asprintf_errstring(ldb
, "Refusing schema add of %s - cannot combine critical class with RODC filtering",
702 ldb_dn_get_linearized(ac
->msg
->dn
));
703 return LDB_ERR_UNWILLING_TO_PERFORM
;
706 rdn_value
= ldb_dn_get_rdn_val(ac
->msg
->dn
);
707 if (rdn_value
== NULL
) {
708 return ldb_operr(ldb
);
710 if (!ldb_msg_find_element(ac
->msg
, "lDAPDisplayName")) {
711 /* the RDN has prefix "CN" */
712 ret
= ldb_msg_add_string(ac
->msg
, "lDAPDisplayName",
713 samdb_cn_to_lDAPDisplayName(ac
->msg
,
714 (const char *) rdn_value
->data
));
715 if (ret
!= LDB_SUCCESS
) {
721 if (!ldb_msg_find_element(ac
->msg
, "schemaIDGUID")) {
724 guid
= GUID_random();
725 ret
= dsdb_msg_add_guid(ac
->msg
, &guid
, "schemaIDGUID");
726 if (ret
!= LDB_SUCCESS
) {
732 def_obj_cat_val
= ldb_msg_find_ldb_val(ac
->msg
,
733 "defaultObjectCategory");
734 if (def_obj_cat_val
!= NULL
) {
735 /* "defaultObjectCategory" has been set by the caller.
736 * Do some checks for consistency.
737 * NOTE: The real constraint check (that
738 * 'defaultObjectCategory' is the DN of the new
739 * objectclass or any parent of it) is still incomplete.
740 * For now we say that 'defaultObjectCategory' is valid
741 * if it exists and it is of objectclass "classSchema".
743 ac
->dn
= ldb_dn_from_ldb_val(ac
, ldb
, def_obj_cat_val
);
744 if (ac
->dn
== NULL
) {
745 ldb_set_errstring(ldb
,
746 "Invalid DN for 'defaultObjectCategory'!");
747 return LDB_ERR_CONSTRAINT_VIOLATION
;
750 /* "defaultObjectCategory" has not been set by the
751 * caller. Use the entry DN for it. */
752 ac
->dn
= ac
->msg
->dn
;
754 ret
= ldb_msg_add_string(ac
->msg
, "defaultObjectCategory",
755 ldb_dn_alloc_linearized(ac
->msg
, ac
->dn
));
756 if (ret
!= LDB_SUCCESS
) {
762 ret
= samldb_add_step(ac
, samldb_add_entry
);
763 if (ret
!= LDB_SUCCESS
) return ret
;
765 /* Now perform the checks for the 'defaultObjectCategory'. The
766 * lookup DN was already saved in "ac->dn" */
767 ret
= samldb_add_step(ac
, samldb_find_for_defaultObjectCategory
);
768 if (ret
!= LDB_SUCCESS
) return ret
;
770 /* -2 is not a valid objectClassCategory so it means the attribute wasn't present */
772 /* Windows 2003 does this*/
773 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
, "objectClassCategory", 0);
774 if (ret
!= LDB_SUCCESS
) {
781 case SAMLDB_TYPE_ATTRIBUTE
: {
782 const struct ldb_val
*rdn_value
;
783 struct ldb_message_element
*el
;
784 rdn_value
= ldb_dn_get_rdn_val(ac
->msg
->dn
);
785 if (rdn_value
== NULL
) {
786 return ldb_operr(ldb
);
788 if (!ldb_msg_find_element(ac
->msg
, "lDAPDisplayName")) {
789 /* the RDN has prefix "CN" */
790 ret
= ldb_msg_add_string(ac
->msg
, "lDAPDisplayName",
791 samdb_cn_to_lDAPDisplayName(ac
->msg
,
792 (const char *) rdn_value
->data
));
793 if (ret
!= LDB_SUCCESS
) {
799 /* do not allow to mark an attributeSchema as RODC filtered if it
800 * is system-critical */
801 if (check_rodc_critical_attribute(ac
->msg
)) {
802 ldb_asprintf_errstring(ldb
,
803 "samldb: refusing schema add of %s - cannot combine critical attribute with RODC filtering",
804 ldb_dn_get_linearized(ac
->msg
->dn
));
805 return LDB_ERR_UNWILLING_TO_PERFORM
;
808 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
809 "isSingleValued", "FALSE");
810 if (ret
!= LDB_SUCCESS
) return ret
;
812 if (!ldb_msg_find_element(ac
->msg
, "schemaIDGUID")) {
815 guid
= GUID_random();
816 ret
= dsdb_msg_add_guid(ac
->msg
, &guid
, "schemaIDGUID");
817 if (ret
!= LDB_SUCCESS
) {
823 el
= ldb_msg_find_element(ac
->msg
, "attributeSyntax");
826 * No need to scream if there isn't as we have code later on
827 * that will take care of it.
829 const struct dsdb_syntax
*syntax
= find_syntax_map_by_ad_oid((const char *)el
->values
[0].data
);
831 DEBUG(9, ("Can't find dsdb_syntax object for attributeSyntax %s\n",
832 (const char *)el
->values
[0].data
));
834 unsigned int v
= ldb_msg_find_attr_as_uint(ac
->msg
, "oMSyntax", 0);
835 const struct ldb_val
*val
= ldb_msg_find_ldb_val(ac
->msg
, "oMObjectClass");
838 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
, "oMSyntax", syntax
->oMSyntax
);
839 if (ret
!= LDB_SUCCESS
) {
844 struct ldb_val val2
= ldb_val_dup(ldb
, &syntax
->oMObjectClass
);
845 if (val2
.length
> 0) {
846 ret
= ldb_msg_add_value(ac
->msg
, "oMObjectClass", &val2
, NULL
);
847 if (ret
!= LDB_SUCCESS
) {
855 /* handle msDS-IntID attribute */
856 ret
= samldb_add_handle_msDS_IntId(ac
);
857 if (ret
!= LDB_SUCCESS
) return ret
;
859 ret
= samldb_add_step(ac
, samldb_add_entry
);
860 if (ret
!= LDB_SUCCESS
) return ret
;
865 ldb_asprintf_errstring(ldb
, "Invalid entry type!");
866 return LDB_ERR_OPERATIONS_ERROR
;
870 return samldb_first_step(ac
);
873 static int samldb_fill_foreignSecurityPrincipal_object(struct samldb_ctx
*ac
)
875 struct ldb_context
*ldb
;
876 const struct ldb_val
*rdn_value
;
880 ldb
= ldb_module_get_ctx(ac
->module
);
882 sid
= samdb_result_dom_sid(ac
->msg
, ac
->msg
, "objectSid");
884 rdn_value
= ldb_dn_get_rdn_val(ac
->msg
->dn
);
885 if (rdn_value
== NULL
) {
886 return ldb_operr(ldb
);
888 sid
= dom_sid_parse_talloc(ac
->msg
,
889 (const char *)rdn_value
->data
);
891 ldb_set_errstring(ldb
,
892 "samldb: No valid SID found in ForeignSecurityPrincipal CN!");
893 return LDB_ERR_CONSTRAINT_VIOLATION
;
895 if (! samldb_msg_add_sid(ac
->msg
, "objectSid", sid
)) {
896 return ldb_operr(ldb
);
900 /* finally proceed with adding the entry */
901 ret
= samldb_add_step(ac
, samldb_add_entry
);
902 if (ret
!= LDB_SUCCESS
) return ret
;
904 return samldb_first_step(ac
);
907 static int samldb_schema_info_update(struct samldb_ctx
*ac
)
910 struct ldb_context
*ldb
;
911 struct dsdb_schema
*schema
;
913 /* replicated update should always go through */
914 if (ldb_request_get_control(ac
->req
,
915 DSDB_CONTROL_REPLICATED_UPDATE_OID
)) {
919 /* do not update schemaInfo during provisioning */
920 if (ldb_request_get_control(ac
->req
, LDB_CONTROL_RELAX_OID
)) {
924 ldb
= ldb_module_get_ctx(ac
->module
);
925 schema
= dsdb_get_schema(ldb
, NULL
);
927 ldb_debug_set(ldb
, LDB_DEBUG_FATAL
,
928 "samldb_schema_info_update: no dsdb_schema loaded");
929 DEBUG(0,(__location__
": %s\n", ldb_errstring(ldb
)));
930 return ldb_operr(ldb
);
933 ret
= dsdb_module_schema_info_update(ac
->module
, schema
,
934 DSDB_FLAG_NEXT_MODULE
|
937 if (ret
!= LDB_SUCCESS
) {
938 ldb_asprintf_errstring(ldb
,
939 "samldb_schema_info_update: dsdb_module_schema_info_update failed with %s",
947 static int samldb_prim_group_tester(struct samldb_ctx
*ac
, uint32_t rid
);
948 static int samldb_check_user_account_control_rules(struct samldb_ctx
*ac
,
950 uint32_t user_account_control
,
951 uint32_t user_account_control_old
);
954 * "Objectclass" trigger (MS-SAMR 3.1.1.8.1)
956 * Has to be invoked on "add" and "modify" operations on "user", "computer" and
958 * ac->msg contains the "add"/"modify" message
959 * ac->type contains the object type (main objectclass)
961 static int samldb_objectclass_trigger(struct samldb_ctx
*ac
)
963 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
964 void *skip_allocate_sids
= ldb_get_opaque(ldb
,
965 "skip_allocate_sids");
966 struct ldb_message_element
*el
, *el2
;
970 /* make sure that "sAMAccountType" is not specified */
971 el
= ldb_msg_find_element(ac
->msg
, "sAMAccountType");
973 ldb_set_errstring(ldb
,
974 "samldb: sAMAccountType must not be specified!");
975 return LDB_ERR_UNWILLING_TO_PERFORM
;
978 /* Step 1: objectSid assignment */
980 /* Don't allow the objectSid to be changed. But beside the RELAX
981 * control we have also to guarantee that it can always be set with
982 * SYSTEM permissions. This is needed for the "samba3sam" backend. */
983 sid
= samdb_result_dom_sid(ac
, ac
->msg
, "objectSid");
984 if ((sid
!= NULL
) && (!dsdb_module_am_system(ac
->module
)) &&
985 (ldb_request_get_control(ac
->req
, LDB_CONTROL_RELAX_OID
) == NULL
)) {
986 ldb_set_errstring(ldb
,
987 "samldb: objectSid must not be specified!");
988 return LDB_ERR_UNWILLING_TO_PERFORM
;
991 /* but generate a new SID when we do have an add operations */
992 if ((sid
== NULL
) && (ac
->req
->operation
== LDB_ADD
) && !skip_allocate_sids
) {
993 ret
= samldb_add_step(ac
, samldb_allocate_sid
);
994 if (ret
!= LDB_SUCCESS
) return ret
;
998 case SAMLDB_TYPE_USER
: {
999 bool uac_generated
= false, uac_add_flags
= false;
1001 /* Step 1.2: Default values */
1002 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1003 "accountExpires", "9223372036854775807");
1004 if (ret
!= LDB_SUCCESS
) return ret
;
1005 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1006 "badPasswordTime", "0");
1007 if (ret
!= LDB_SUCCESS
) return ret
;
1008 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1009 "badPwdCount", "0");
1010 if (ret
!= LDB_SUCCESS
) return ret
;
1011 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1013 if (ret
!= LDB_SUCCESS
) return ret
;
1014 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1015 "countryCode", "0");
1016 if (ret
!= LDB_SUCCESS
) return ret
;
1017 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1019 if (ret
!= LDB_SUCCESS
) return ret
;
1020 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1022 if (ret
!= LDB_SUCCESS
) return ret
;
1023 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1025 if (ret
!= LDB_SUCCESS
) return ret
;
1026 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1028 if (ret
!= LDB_SUCCESS
) return ret
;
1030 /* On add operations we might need to generate a
1031 * "userAccountControl" (if it isn't specified). */
1032 el
= ldb_msg_find_element(ac
->msg
, "userAccountControl");
1033 if ((el
== NULL
) && (ac
->req
->operation
== LDB_ADD
)) {
1034 ret
= samdb_msg_set_uint(ldb
, ac
->msg
, ac
->msg
,
1035 "userAccountControl",
1037 if (ret
!= LDB_SUCCESS
) {
1040 uac_generated
= true;
1041 uac_add_flags
= true;
1044 el
= ldb_msg_find_element(ac
->msg
, "userAccountControl");
1046 uint32_t user_account_control
, account_type
;
1047 /* Step 1.3: "userAccountControl" -> "sAMAccountType" mapping */
1048 user_account_control
= ldb_msg_find_attr_as_uint(ac
->msg
,
1049 "userAccountControl",
1052 * "userAccountControl" = 0 or missing one of
1053 * the types means "UF_NORMAL_ACCOUNT". See
1054 * MS-SAMR 3.1.1.8.10 point 8
1056 if ((user_account_control
& UF_ACCOUNT_TYPE_MASK
) == 0) {
1057 user_account_control
= UF_NORMAL_ACCOUNT
| user_account_control
;
1058 uac_generated
= true;
1062 * As per MS-SAMR 3.1.1.8.10 these flags have not to be set
1064 if ((user_account_control
& UF_LOCKOUT
) != 0) {
1065 user_account_control
&= ~UF_LOCKOUT
;
1066 uac_generated
= true;
1068 if ((user_account_control
& UF_PASSWORD_EXPIRED
) != 0) {
1069 user_account_control
&= ~UF_PASSWORD_EXPIRED
;
1070 uac_generated
= true;
1073 ret
= samldb_check_user_account_control_rules(ac
, NULL
,
1074 user_account_control
, 0);
1075 if (ret
!= LDB_SUCCESS
) {
1079 /* Workstation and (read-only) DC objects do need objectclass "computer" */
1080 if ((samdb_find_attribute(ldb
, ac
->msg
,
1081 "objectclass", "computer") == NULL
) &&
1082 (user_account_control
&
1083 (UF_SERVER_TRUST_ACCOUNT
| UF_WORKSTATION_TRUST_ACCOUNT
))) {
1084 ldb_set_errstring(ldb
,
1085 "samldb: Requested account type does need objectclass 'computer'!");
1086 return LDB_ERR_OBJECT_CLASS_VIOLATION
;
1089 account_type
= ds_uf2atype(user_account_control
);
1090 if (account_type
== 0) {
1091 ldb_set_errstring(ldb
, "samldb: Unrecognized account type!");
1092 return LDB_ERR_UNWILLING_TO_PERFORM
;
1094 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
,
1097 if (ret
!= LDB_SUCCESS
) {
1100 el2
= ldb_msg_find_element(ac
->msg
, "sAMAccountType");
1101 el2
->flags
= LDB_FLAG_MOD_REPLACE
;
1103 /* "isCriticalSystemObject" might be set */
1104 if (user_account_control
&
1105 (UF_SERVER_TRUST_ACCOUNT
| UF_PARTIAL_SECRETS_ACCOUNT
)) {
1106 ret
= ldb_msg_add_string(ac
->msg
, "isCriticalSystemObject",
1108 if (ret
!= LDB_SUCCESS
) {
1111 el2
= ldb_msg_find_element(ac
->msg
,
1112 "isCriticalSystemObject");
1113 el2
->flags
= LDB_FLAG_MOD_REPLACE
;
1114 } else if (user_account_control
& UF_WORKSTATION_TRUST_ACCOUNT
) {
1115 ret
= ldb_msg_add_string(ac
->msg
, "isCriticalSystemObject",
1117 if (ret
!= LDB_SUCCESS
) {
1120 el2
= ldb_msg_find_element(ac
->msg
,
1121 "isCriticalSystemObject");
1122 el2
->flags
= LDB_FLAG_MOD_REPLACE
;
1125 /* Step 1.4: "userAccountControl" -> "primaryGroupID" mapping */
1126 if (!ldb_msg_find_element(ac
->msg
, "primaryGroupID")) {
1127 uint32_t rid
= ds_uf2prim_group_rid(user_account_control
);
1130 * Older AD deployments don't know about the
1133 if (rid
== DOMAIN_RID_READONLY_DCS
) {
1134 ret
= samldb_prim_group_tester(ac
, rid
);
1135 if (ret
!= LDB_SUCCESS
) {
1140 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
,
1141 "primaryGroupID", rid
);
1142 if (ret
!= LDB_SUCCESS
) {
1145 el2
= ldb_msg_find_element(ac
->msg
,
1147 el2
->flags
= LDB_FLAG_MOD_REPLACE
;
1150 /* Step 1.5: Add additional flags when needed */
1151 /* Obviously this is done when the "userAccountControl"
1152 * has been generated here (tested against Windows
1154 if (uac_generated
) {
1155 if (uac_add_flags
) {
1156 user_account_control
|= UF_ACCOUNTDISABLE
;
1157 user_account_control
|= UF_PASSWD_NOTREQD
;
1160 ret
= samdb_msg_set_uint(ldb
, ac
->msg
, ac
->msg
,
1161 "userAccountControl",
1162 user_account_control
);
1163 if (ret
!= LDB_SUCCESS
) {
1172 case SAMLDB_TYPE_GROUP
: {
1173 const char *tempstr
;
1175 /* Step 2.2: Default values */
1176 tempstr
= talloc_asprintf(ac
->msg
, "%d",
1177 GTYPE_SECURITY_GLOBAL_GROUP
);
1178 if (tempstr
== NULL
) return ldb_operr(ldb
);
1179 ret
= samdb_find_or_add_attribute(ldb
, ac
->msg
,
1180 "groupType", tempstr
);
1181 if (ret
!= LDB_SUCCESS
) return ret
;
1183 /* Step 2.3: "groupType" -> "sAMAccountType" */
1184 el
= ldb_msg_find_element(ac
->msg
, "groupType");
1186 uint32_t group_type
, account_type
;
1188 group_type
= ldb_msg_find_attr_as_uint(ac
->msg
,
1191 /* The creation of builtin groups requires the
1193 if (group_type
== GTYPE_SECURITY_BUILTIN_LOCAL_GROUP
) {
1194 if (ldb_request_get_control(ac
->req
,
1195 LDB_CONTROL_RELAX_OID
) == NULL
) {
1196 return LDB_ERR_UNWILLING_TO_PERFORM
;
1200 account_type
= ds_gtype2atype(group_type
);
1201 if (account_type
== 0) {
1202 ldb_set_errstring(ldb
, "samldb: Unrecognized account type!");
1203 return LDB_ERR_UNWILLING_TO_PERFORM
;
1205 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
,
1208 if (ret
!= LDB_SUCCESS
) {
1211 el2
= ldb_msg_find_element(ac
->msg
, "sAMAccountType");
1212 el2
->flags
= LDB_FLAG_MOD_REPLACE
;
1218 ldb_asprintf_errstring(ldb
,
1219 "Invalid entry type!");
1220 return LDB_ERR_OPERATIONS_ERROR
;
1228 * "Primary group ID" trigger (MS-SAMR 3.1.1.8.2)
1230 * Has to be invoked on "add" and "modify" operations on "user" and "computer"
1232 * ac->msg contains the "add"/"modify" message
1235 static int samldb_prim_group_tester(struct samldb_ctx
*ac
, uint32_t rid
)
1237 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
1238 struct dom_sid
*sid
;
1239 struct ldb_result
*res
;
1241 const char * const noattrs
[] = { NULL
};
1243 sid
= dom_sid_add_rid(ac
, samdb_domain_sid(ldb
), rid
);
1245 return ldb_operr(ldb
);
1248 ret
= dsdb_module_search(ac
->module
, ac
, &res
,
1249 ldb_get_default_basedn(ldb
),
1251 noattrs
, DSDB_FLAG_NEXT_MODULE
,
1254 ldap_encode_ndr_dom_sid(ac
, sid
));
1255 if (ret
!= LDB_SUCCESS
) {
1258 if (res
->count
!= 1) {
1260 ldb_asprintf_errstring(ldb
,
1261 "Failed to find primary group with RID %u!",
1263 return LDB_ERR_UNWILLING_TO_PERFORM
;
1270 static int samldb_prim_group_set(struct samldb_ctx
*ac
)
1272 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
1275 rid
= ldb_msg_find_attr_as_uint(ac
->msg
, "primaryGroupID", (uint32_t) -1);
1276 if (rid
== (uint32_t) -1) {
1277 /* we aren't affected of any primary group set */
1280 } else if (!ldb_request_get_control(ac
->req
, LDB_CONTROL_RELAX_OID
)) {
1281 ldb_set_errstring(ldb
,
1282 "The primary group isn't settable on add operations!");
1283 return LDB_ERR_UNWILLING_TO_PERFORM
;
1286 return samldb_prim_group_tester(ac
, rid
);
1289 static int samldb_prim_group_change(struct samldb_ctx
*ac
)
1291 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
1292 const char * const attrs
[] = {
1295 "userAccountControl",
1297 struct ldb_result
*res
, *group_res
;
1298 struct ldb_message_element
*el
;
1299 struct ldb_message
*msg
;
1300 uint32_t prev_rid
, new_rid
, uac
;
1301 struct dom_sid
*prev_sid
, *new_sid
;
1302 struct ldb_dn
*prev_prim_group_dn
, *new_prim_group_dn
;
1304 const char * const noattrs
[] = { NULL
};
1306 el
= dsdb_get_single_valued_attr(ac
->msg
, "primaryGroupID",
1307 ac
->req
->operation
);
1309 /* we are not affected */
1313 /* Fetch information from the existing object */
1315 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
, ac
->msg
->dn
, attrs
,
1316 DSDB_FLAG_NEXT_MODULE
, ac
->req
);
1317 if (ret
!= LDB_SUCCESS
) {
1321 uac
= ldb_msg_find_attr_as_uint(res
->msgs
[0], "userAccountControl", 0);
1323 /* Finds out the DN of the old primary group */
1325 prev_rid
= ldb_msg_find_attr_as_uint(res
->msgs
[0], "primaryGroupID",
1327 if (prev_rid
== (uint32_t) -1) {
1328 /* User objects do always have a mandatory "primaryGroupID"
1329 * attribute. If this doesn't exist then the object is of the
1330 * wrong type. This is the exact Windows error code */
1331 return LDB_ERR_OBJECT_CLASS_VIOLATION
;
1334 prev_sid
= dom_sid_add_rid(ac
, samdb_domain_sid(ldb
), prev_rid
);
1335 if (prev_sid
== NULL
) {
1336 return ldb_operr(ldb
);
1339 /* Finds out the DN of the new primary group
1340 * Notice: in order to parse the primary group ID correctly we create
1341 * a temporary message here. */
1343 msg
= ldb_msg_new(ac
->msg
);
1345 return ldb_module_oom(ac
->module
);
1347 ret
= ldb_msg_add(msg
, el
, 0);
1348 if (ret
!= LDB_SUCCESS
) {
1351 new_rid
= ldb_msg_find_attr_as_uint(msg
, "primaryGroupID", (uint32_t) -1);
1353 if (new_rid
== (uint32_t) -1) {
1354 /* we aren't affected of any primary group change */
1358 if (prev_rid
== new_rid
) {
1362 if ((uac
& UF_SERVER_TRUST_ACCOUNT
) && new_rid
!= DOMAIN_RID_DCS
) {
1363 ldb_asprintf_errstring(ldb
,
1364 "%08X: samldb: UF_SERVER_TRUST_ACCOUNT requires "
1365 "primaryGroupID=%u!",
1366 W_ERROR_V(WERR_DS_CANT_MOD_PRIMARYGROUPID
),
1368 return LDB_ERR_UNWILLING_TO_PERFORM
;
1371 if ((uac
& UF_PARTIAL_SECRETS_ACCOUNT
) && new_rid
!= DOMAIN_RID_READONLY_DCS
) {
1372 ldb_asprintf_errstring(ldb
,
1373 "%08X: samldb: UF_PARTIAL_SECRETS_ACCOUNT requires "
1374 "primaryGroupID=%u!",
1375 W_ERROR_V(WERR_DS_CANT_MOD_PRIMARYGROUPID
),
1376 DOMAIN_RID_READONLY_DCS
);
1377 return LDB_ERR_UNWILLING_TO_PERFORM
;
1380 ret
= dsdb_module_search(ac
->module
, ac
, &group_res
,
1381 ldb_get_default_basedn(ldb
),
1383 noattrs
, DSDB_FLAG_NEXT_MODULE
,
1386 ldap_encode_ndr_dom_sid(ac
, prev_sid
));
1387 if (ret
!= LDB_SUCCESS
) {
1390 if (group_res
->count
!= 1) {
1391 return ldb_operr(ldb
);
1393 prev_prim_group_dn
= group_res
->msgs
[0]->dn
;
1395 new_sid
= dom_sid_add_rid(ac
, samdb_domain_sid(ldb
), new_rid
);
1396 if (new_sid
== NULL
) {
1397 return ldb_operr(ldb
);
1400 ret
= dsdb_module_search(ac
->module
, ac
, &group_res
,
1401 ldb_get_default_basedn(ldb
),
1403 noattrs
, DSDB_FLAG_NEXT_MODULE
,
1406 ldap_encode_ndr_dom_sid(ac
, new_sid
));
1407 if (ret
!= LDB_SUCCESS
) {
1410 if (group_res
->count
!= 1) {
1411 /* Here we know if the specified new primary group candidate is
1413 return LDB_ERR_UNWILLING_TO_PERFORM
;
1415 new_prim_group_dn
= group_res
->msgs
[0]->dn
;
1417 /* We need to be already a normal member of the new primary
1418 * group in order to be successful. */
1419 el
= samdb_find_attribute(ldb
, res
->msgs
[0], "memberOf",
1420 ldb_dn_get_linearized(new_prim_group_dn
));
1422 return LDB_ERR_UNWILLING_TO_PERFORM
;
1425 /* Remove the "member" attribute on the new primary group */
1426 msg
= ldb_msg_new(ac
->msg
);
1428 return ldb_module_oom(ac
->module
);
1430 msg
->dn
= new_prim_group_dn
;
1432 ret
= samdb_msg_add_delval(ldb
, msg
, msg
, "member",
1433 ldb_dn_get_linearized(ac
->msg
->dn
));
1434 if (ret
!= LDB_SUCCESS
) {
1438 ret
= dsdb_module_modify(ac
->module
, msg
, DSDB_FLAG_NEXT_MODULE
, ac
->req
);
1439 if (ret
!= LDB_SUCCESS
) {
1444 /* Add a "member" attribute for the previous primary group */
1445 msg
= ldb_msg_new(ac
->msg
);
1447 return ldb_module_oom(ac
->module
);
1449 msg
->dn
= prev_prim_group_dn
;
1451 ret
= samdb_msg_add_addval(ldb
, msg
, msg
, "member",
1452 ldb_dn_get_linearized(ac
->msg
->dn
));
1453 if (ret
!= LDB_SUCCESS
) {
1457 ret
= dsdb_module_modify(ac
->module
, msg
, DSDB_FLAG_NEXT_MODULE
, ac
->req
);
1458 if (ret
!= LDB_SUCCESS
) {
1466 static int samldb_prim_group_trigger(struct samldb_ctx
*ac
)
1470 if (ac
->req
->operation
== LDB_ADD
) {
1471 ret
= samldb_prim_group_set(ac
);
1473 ret
= samldb_prim_group_change(ac
);
1479 static int samldb_check_user_account_control_invariants(struct samldb_ctx
*ac
,
1480 uint32_t user_account_control
)
1483 bool need_check
= false;
1484 const struct uac_to_guid
{
1489 const char *error_string
;
1492 .uac
= UF_TEMP_DUPLICATE_ACCOUNT
,
1494 .error_string
= "Updating the UF_TEMP_DUPLICATE_ACCOUNT flag is never allowed"
1497 .uac
= UF_PARTIAL_SECRETS_ACCOUNT
,
1498 .needs
= UF_WORKSTATION_TRUST_ACCOUNT
,
1499 .error_string
= "Setting UF_PARTIAL_SECRETS_ACCOUNT only permitted with UF_WORKSTATION_TRUST_ACCOUNT"
1502 .uac
= UF_TRUSTED_FOR_DELEGATION
,
1503 .not_with
= UF_PARTIAL_SECRETS_ACCOUNT
,
1504 .error_string
= "Setting UF_TRUSTED_FOR_DELEGATION not allowed with UF_PARTIAL_SECRETS_ACCOUNT"
1507 .uac
= UF_NORMAL_ACCOUNT
,
1508 .not_with
= UF_ACCOUNT_TYPE_MASK
& ~UF_NORMAL_ACCOUNT
,
1509 .error_string
= "Setting more than one account type not permitted"
1512 .uac
= UF_WORKSTATION_TRUST_ACCOUNT
,
1513 .not_with
= UF_ACCOUNT_TYPE_MASK
& ~UF_WORKSTATION_TRUST_ACCOUNT
,
1514 .error_string
= "Setting more than one account type not permitted"
1517 .uac
= UF_INTERDOMAIN_TRUST_ACCOUNT
,
1518 .not_with
= UF_ACCOUNT_TYPE_MASK
& ~UF_INTERDOMAIN_TRUST_ACCOUNT
,
1519 .error_string
= "Setting more than one account type not permitted"
1522 .uac
= UF_SERVER_TRUST_ACCOUNT
,
1523 .not_with
= UF_ACCOUNT_TYPE_MASK
& ~UF_SERVER_TRUST_ACCOUNT
,
1524 .error_string
= "Setting more than one account type not permitted"
1527 .uac
= UF_TRUSTED_FOR_DELEGATION
,
1528 .not_with
= UF_PARTIAL_SECRETS_ACCOUNT
,
1529 .error_string
= "Setting UF_TRUSTED_FOR_DELEGATION not allowed with UF_PARTIAL_SECRETS_ACCOUNT"
1533 for (i
= 0; i
< ARRAY_SIZE(map
); i
++) {
1534 if (user_account_control
& map
[i
].uac
) {
1539 if (need_check
== false) {
1543 for (i
= 0; i
< ARRAY_SIZE(map
); i
++) {
1544 uint32_t this_uac
= user_account_control
& map
[i
].uac
;
1545 if (this_uac
!= 0) {
1547 ret
= LDB_ERR_OTHER
;
1549 } else if (map
[i
].needs
!= 0) {
1550 if ((map
[i
].needs
& user_account_control
) == 0) {
1551 ret
= LDB_ERR_OTHER
;
1554 } else if (map
[i
].not_with
!= 0) {
1555 if ((map
[i
].not_with
& user_account_control
) != 0) {
1556 ret
= LDB_ERR_OTHER
;
1562 if (ret
!= LDB_SUCCESS
) {
1563 switch (ac
->req
->operation
) {
1565 ldb_asprintf_errstring(ldb_module_get_ctx(ac
->module
),
1566 "Failed to add %s: %s",
1567 ldb_dn_get_linearized(ac
->msg
->dn
),
1568 map
[i
].error_string
);
1571 ldb_asprintf_errstring(ldb_module_get_ctx(ac
->module
),
1572 "Failed to modify %s: %s",
1573 ldb_dn_get_linearized(ac
->msg
->dn
),
1574 map
[i
].error_string
);
1577 return ldb_module_operr(ac
->module
);
1584 * Validate that the restriction in point 5 of MS-SAMR 3.1.1.8.10 userAccountControl is honoured
1587 static int samldb_check_user_account_control_acl(struct samldb_ctx
*ac
,
1588 struct dom_sid
*sid
,
1589 uint32_t user_account_control
,
1590 uint32_t user_account_control_old
)
1593 bool need_acl_check
= false;
1594 struct ldb_result
*res
;
1595 const char * const sd_attrs
[] = {"ntSecurityDescriptor", NULL
};
1596 struct security_token
*user_token
;
1597 struct security_descriptor
*domain_sd
;
1598 struct ldb_dn
*domain_dn
= ldb_get_default_basedn(ldb_module_get_ctx(ac
->module
));
1599 const struct uac_to_guid
{
1603 enum sec_privilege privilege
;
1604 bool delete_is_privileged
;
1605 const char *error_string
;
1608 .uac
= UF_PASSWD_NOTREQD
,
1609 .guid
= GUID_DRS_UPDATE_PASSWORD_NOT_REQUIRED_BIT
,
1610 .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"
1613 .uac
= UF_DONT_EXPIRE_PASSWD
,
1614 .guid
= GUID_DRS_UNEXPIRE_PASSWORD
,
1615 .error_string
= "Adding the UF_DONT_EXPIRE_PASSWD bit in userAccountControl requires the Unexpire-Password right that was not given on the Domain object"
1618 .uac
= UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED
,
1619 .guid
= GUID_DRS_ENABLE_PER_USER_REVERSIBLY_ENCRYPTED_PASSWORD
,
1620 .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"
1623 .uac
= UF_SERVER_TRUST_ACCOUNT
,
1624 .guid
= GUID_DRS_DS_INSTALL_REPLICA
,
1625 .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"
1628 .uac
= UF_PARTIAL_SECRETS_ACCOUNT
,
1629 .guid
= GUID_DRS_DS_INSTALL_REPLICA
,
1630 .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"
1633 .uac
= UF_INTERDOMAIN_TRUST_ACCOUNT
,
1634 .oid
= DSDB_CONTROL_PERMIT_INTERDOMAIN_TRUST_UAC_OID
,
1635 .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",
1636 .delete_is_privileged
= true
1639 .uac
= UF_TRUSTED_FOR_DELEGATION
,
1640 .privilege
= SEC_PRIV_ENABLE_DELEGATION
,
1641 .delete_is_privileged
= true,
1642 .error_string
= "Updating the UF_TRUSTED_FOR_DELEGATION bit in userAccountControl is not permitted without the SeEnableDelegationPrivilege"
1645 .uac
= UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION
,
1646 .privilege
= SEC_PRIV_ENABLE_DELEGATION
,
1647 .delete_is_privileged
= true,
1648 .error_string
= "Updating the UF_TRUSTED_TO_AUTHENTICATE_FOR_DELEGATION bit in userAccountControl is not permitted without the SeEnableDelegationPrivilege"
1653 if (dsdb_module_am_system(ac
->module
)) {
1657 for (i
= 0; i
< ARRAY_SIZE(map
); i
++) {
1658 if (user_account_control
& map
[i
].uac
) {
1659 need_acl_check
= true;
1663 if (need_acl_check
== false) {
1667 user_token
= acl_user_token(ac
->module
);
1668 if (user_token
== NULL
) {
1669 return LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS
;
1672 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
,
1675 DSDB_FLAG_NEXT_MODULE
| DSDB_SEARCH_SHOW_DELETED
,
1677 if (ret
!= LDB_SUCCESS
) {
1680 if (res
->count
!= 1) {
1681 return ldb_module_operr(ac
->module
);
1684 ret
= dsdb_get_sd_from_ldb_message(ldb_module_get_ctx(ac
->module
),
1685 ac
, res
->msgs
[0], &domain_sd
);
1687 if (ret
!= LDB_SUCCESS
) {
1691 for (i
= 0; i
< ARRAY_SIZE(map
); i
++) {
1692 uint32_t this_uac_new
= user_account_control
& map
[i
].uac
;
1693 uint32_t this_uac_old
= user_account_control_old
& map
[i
].uac
;
1694 if (this_uac_new
!= this_uac_old
) {
1695 if (this_uac_old
!= 0) {
1696 if (map
[i
].delete_is_privileged
== false) {
1701 struct ldb_control
*control
= ldb_request_get_control(ac
->req
, map
[i
].oid
);
1702 if (control
== NULL
) {
1703 ret
= LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS
;
1705 } else if (map
[i
].privilege
!= SEC_PRIV_INVALID
) {
1706 bool have_priv
= security_token_has_privilege(user_token
,
1708 if (have_priv
== false) {
1709 ret
= LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS
;
1712 ret
= acl_check_extended_right(ac
, domain_sd
,
1715 SEC_ADS_CONTROL_ACCESS
,
1718 if (ret
!= LDB_SUCCESS
) {
1723 if (ret
== LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS
) {
1724 switch (ac
->req
->operation
) {
1726 ldb_asprintf_errstring(ldb_module_get_ctx(ac
->module
),
1727 "Failed to add %s: %s",
1728 ldb_dn_get_linearized(ac
->msg
->dn
),
1729 map
[i
].error_string
);
1732 ldb_asprintf_errstring(ldb_module_get_ctx(ac
->module
),
1733 "Failed to modify %s: %s",
1734 ldb_dn_get_linearized(ac
->msg
->dn
),
1735 map
[i
].error_string
);
1738 return ldb_module_operr(ac
->module
);
1741 dsdb_acl_debug(domain_sd
, acl_user_token(ac
->module
),
1750 static int samldb_check_user_account_control_rules(struct samldb_ctx
*ac
,
1751 struct dom_sid
*sid
,
1752 uint32_t user_account_control
,
1753 uint32_t user_account_control_old
)
1756 ret
= samldb_check_user_account_control_invariants(ac
, user_account_control
);
1757 if (ret
!= LDB_SUCCESS
) {
1760 ret
= samldb_check_user_account_control_acl(ac
, sid
, user_account_control
, user_account_control_old
);
1761 if (ret
!= LDB_SUCCESS
) {
1769 * This function is called on LDB modify operations. It performs some additions/
1770 * replaces on the current LDB message when "userAccountControl" changes.
1772 static int samldb_user_account_control_change(struct samldb_ctx
*ac
)
1774 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
1787 NTTIME old_lockoutTime
;
1788 struct ldb_message_element
*el
;
1789 struct ldb_val
*val
;
1790 struct ldb_val computer_val
;
1791 struct ldb_message
*tmp_msg
;
1792 struct dom_sid
*sid
;
1794 struct ldb_result
*res
;
1795 const char * const attrs
[] = {
1797 "isCriticalSystemObject",
1798 "userAccountControl",
1799 "msDS-User-Account-Control-Computed",
1804 bool is_computer
= false;
1805 bool old_is_critical
= false;
1806 bool new_is_critical
= false;
1808 el
= dsdb_get_single_valued_attr(ac
->msg
, "userAccountControl",
1809 ac
->req
->operation
);
1810 if (el
== NULL
|| el
->num_values
== 0) {
1811 ldb_asprintf_errstring(ldb
,
1812 "%08X: samldb: 'userAccountControl' can't be deleted!",
1813 W_ERROR_V(WERR_DS_ILLEGAL_MOD_OPERATION
));
1814 return LDB_ERR_UNWILLING_TO_PERFORM
;
1817 /* Create a temporary message for fetching the "userAccountControl" */
1818 tmp_msg
= ldb_msg_new(ac
->msg
);
1819 if (tmp_msg
== NULL
) {
1820 return ldb_module_oom(ac
->module
);
1822 ret
= ldb_msg_add(tmp_msg
, el
, 0);
1823 if (ret
!= LDB_SUCCESS
) {
1826 raw_uac
= ldb_msg_find_attr_as_uint(tmp_msg
,
1827 "userAccountControl",
1829 new_acb
= samdb_result_acct_flags(tmp_msg
, NULL
);
1830 talloc_free(tmp_msg
);
1832 * UF_LOCKOUT, UF_PASSWD_CANT_CHANGE and UF_PASSWORD_EXPIRED
1833 * are only generated and not stored. We ignore them almost
1834 * completely, along with unknown bits and UF_SCRIPT.
1836 * The only exception is ACB_AUTOLOCK, which features in
1837 * clear_acb when the bit is cleared in this modify operation.
1839 * MS-SAMR 2.2.1.13 UF_FLAG Codes states that some bits are
1840 * ignored by clients and servers
1842 new_uac
= raw_uac
& UF_SETTABLE_BITS
;
1844 /* Fetch the old "userAccountControl" and "objectClass" */
1845 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
, ac
->msg
->dn
, attrs
,
1846 DSDB_FLAG_NEXT_MODULE
, ac
->req
);
1847 if (ret
!= LDB_SUCCESS
) {
1850 old_uac
= ldb_msg_find_attr_as_uint(res
->msgs
[0], "userAccountControl", 0);
1852 return ldb_operr(ldb
);
1854 old_acb
= samdb_result_acct_flags(res
->msgs
[0],
1855 "msDS-User-Account-Control-Computed");
1856 old_lockoutTime
= ldb_msg_find_attr_as_int64(res
->msgs
[0],
1858 old_is_critical
= ldb_msg_find_attr_as_bool(res
->msgs
[0],
1859 "isCriticalSystemObject", 0);
1860 /* When we do not have objectclass "omputer" we cannot switch to a (read-only) DC */
1861 el
= ldb_msg_find_element(res
->msgs
[0], "objectClass");
1863 return ldb_operr(ldb
);
1865 computer_val
= data_blob_string_const("computer");
1866 val
= ldb_msg_find_val(el
, &computer_val
);
1871 old_ufa
= old_uac
& UF_ACCOUNT_TYPE_MASK
;
1872 old_atype
= ds_uf2atype(old_ufa
);
1873 old_pgrid
= ds_uf2prim_group_rid(old_uac
);
1875 new_ufa
= new_uac
& UF_ACCOUNT_TYPE_MASK
;
1878 * "userAccountControl" = 0 or missing one of the
1879 * types means "UF_NORMAL_ACCOUNT". See MS-SAMR
1880 * 3.1.1.8.10 point 8
1882 new_ufa
= UF_NORMAL_ACCOUNT
;
1885 sid
= samdb_result_dom_sid(res
, res
->msgs
[0], "objectSid");
1887 return ldb_module_operr(ac
->module
);
1890 ret
= samldb_check_user_account_control_rules(ac
, sid
, new_uac
, old_uac
);
1891 if (ret
!= LDB_SUCCESS
) {
1895 new_atype
= ds_uf2atype(new_ufa
);
1896 new_pgrid
= ds_uf2prim_group_rid(new_uac
);
1898 clear_acb
= old_acb
& ~new_acb
;
1901 case UF_NORMAL_ACCOUNT
:
1902 new_is_critical
= old_is_critical
;
1905 case UF_INTERDOMAIN_TRUST_ACCOUNT
:
1906 new_is_critical
= true;
1909 case UF_WORKSTATION_TRUST_ACCOUNT
:
1910 new_is_critical
= false;
1911 if (new_uac
& UF_PARTIAL_SECRETS_ACCOUNT
) {
1913 ldb_asprintf_errstring(ldb
,
1914 "%08X: samldb: UF_PARTIAL_SECRETS_ACCOUNT "
1915 "requires objectclass 'computer'!",
1916 W_ERROR_V(WERR_DS_MACHINE_ACCOUNT_CREATED_PRENT4
));
1917 return LDB_ERR_UNWILLING_TO_PERFORM
;
1919 new_is_critical
= true;
1923 case UF_SERVER_TRUST_ACCOUNT
:
1925 ldb_asprintf_errstring(ldb
,
1926 "%08X: samldb: UF_SERVER_TRUST_ACCOUNT "
1927 "requires objectclass 'computer'!",
1928 W_ERROR_V(WERR_DS_MACHINE_ACCOUNT_CREATED_PRENT4
));
1929 return LDB_ERR_UNWILLING_TO_PERFORM
;
1931 new_is_critical
= true;
1935 ldb_asprintf_errstring(ldb
,
1936 "%08X: samldb: invalid userAccountControl[0x%08X]",
1937 W_ERROR_V(WERR_INVALID_PARAMETER
), raw_uac
);
1938 return LDB_ERR_OTHER
;
1941 if (old_atype
!= new_atype
) {
1942 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
,
1943 "sAMAccountType", new_atype
);
1944 if (ret
!= LDB_SUCCESS
) {
1947 el
= ldb_msg_find_element(ac
->msg
, "sAMAccountType");
1948 el
->flags
= LDB_FLAG_MOD_REPLACE
;
1951 /* As per MS-SAMR 3.1.1.8.10 these flags have not to be set */
1952 if ((clear_acb
& ACB_AUTOLOCK
) && (old_lockoutTime
!= 0)) {
1953 /* "pwdLastSet" reset as password expiration has been forced */
1954 ldb_msg_remove_attr(ac
->msg
, "lockoutTime");
1955 ret
= samdb_msg_add_uint64(ldb
, ac
->msg
, ac
->msg
, "lockoutTime",
1957 if (ret
!= LDB_SUCCESS
) {
1960 el
= ldb_msg_find_element(ac
->msg
, "lockoutTime");
1961 el
->flags
= LDB_FLAG_MOD_REPLACE
;
1964 /* "isCriticalSystemObject" might be set/changed */
1965 if (old_is_critical
!= new_is_critical
) {
1966 ret
= ldb_msg_add_string(ac
->msg
, "isCriticalSystemObject",
1967 new_is_critical
? "TRUE": "FALSE");
1968 if (ret
!= LDB_SUCCESS
) {
1971 el
= ldb_msg_find_element(ac
->msg
,
1972 "isCriticalSystemObject");
1973 el
->flags
= LDB_FLAG_MOD_REPLACE
;
1976 if (!ldb_msg_find_element(ac
->msg
, "primaryGroupID") &&
1977 (old_pgrid
!= new_pgrid
)) {
1978 /* Older AD deployments don't know about the RODC group */
1979 if (new_pgrid
== DOMAIN_RID_READONLY_DCS
) {
1980 ret
= samldb_prim_group_tester(ac
, new_pgrid
);
1981 if (ret
!= LDB_SUCCESS
) {
1986 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
,
1987 "primaryGroupID", new_pgrid
);
1988 if (ret
!= LDB_SUCCESS
) {
1991 el
= ldb_msg_find_element(ac
->msg
,
1993 el
->flags
= LDB_FLAG_MOD_REPLACE
;
1996 /* Propagate eventual "userAccountControl" attribute changes */
1997 if (old_uac
!= new_uac
) {
1998 char *tempstr
= talloc_asprintf(ac
->msg
, "%d",
2000 if (tempstr
== NULL
) {
2001 return ldb_module_oom(ac
->module
);
2004 /* Overwrite "userAccountControl" correctly */
2005 el
= dsdb_get_single_valued_attr(ac
->msg
, "userAccountControl",
2006 ac
->req
->operation
);
2007 el
->values
[0].data
= (uint8_t *) tempstr
;
2008 el
->values
[0].length
= strlen(tempstr
);
2010 ldb_msg_remove_attr(ac
->msg
, "userAccountControl");
2016 static int samldb_lockout_time(struct samldb_ctx
*ac
)
2018 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2020 struct ldb_message_element
*el
;
2021 struct ldb_message
*tmp_msg
;
2024 el
= dsdb_get_single_valued_attr(ac
->msg
, "lockoutTime",
2025 ac
->req
->operation
);
2026 if (el
== NULL
|| el
->num_values
== 0) {
2027 ldb_asprintf_errstring(ldb
,
2028 "%08X: samldb: 'lockoutTime' can't be deleted!",
2029 W_ERROR_V(WERR_DS_ILLEGAL_MOD_OPERATION
));
2030 return LDB_ERR_UNWILLING_TO_PERFORM
;
2033 /* Create a temporary message for fetching the "lockoutTime" */
2034 tmp_msg
= ldb_msg_new(ac
->msg
);
2035 if (tmp_msg
== NULL
) {
2036 return ldb_module_oom(ac
->module
);
2038 ret
= ldb_msg_add(tmp_msg
, el
, 0);
2039 if (ret
!= LDB_SUCCESS
) {
2042 lockoutTime
= ldb_msg_find_attr_as_int64(tmp_msg
,
2045 talloc_free(tmp_msg
);
2047 if (lockoutTime
!= 0) {
2051 /* lockoutTime == 0 resets badPwdCount */
2052 ldb_msg_remove_attr(ac
->msg
, "badPwdCount");
2053 ret
= samdb_msg_add_int(ldb
, ac
->msg
, ac
->msg
,
2055 if (ret
!= LDB_SUCCESS
) {
2058 el
= ldb_msg_find_element(ac
->msg
, "badPwdCount");
2059 el
->flags
= LDB_FLAG_MOD_REPLACE
;
2064 static int samldb_group_type_change(struct samldb_ctx
*ac
)
2066 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2067 uint32_t group_type
, old_group_type
, account_type
;
2068 struct ldb_message_element
*el
;
2069 struct ldb_message
*tmp_msg
;
2071 struct ldb_result
*res
;
2072 const char * const attrs
[] = { "groupType", NULL
};
2074 el
= dsdb_get_single_valued_attr(ac
->msg
, "groupType",
2075 ac
->req
->operation
);
2077 /* we are not affected */
2081 /* Create a temporary message for fetching the "groupType" */
2082 tmp_msg
= ldb_msg_new(ac
->msg
);
2083 if (tmp_msg
== NULL
) {
2084 return ldb_module_oom(ac
->module
);
2086 ret
= ldb_msg_add(tmp_msg
, el
, 0);
2087 if (ret
!= LDB_SUCCESS
) {
2090 group_type
= ldb_msg_find_attr_as_uint(tmp_msg
, "groupType", 0);
2091 talloc_free(tmp_msg
);
2093 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
, ac
->msg
->dn
, attrs
,
2094 DSDB_FLAG_NEXT_MODULE
|
2095 DSDB_SEARCH_SHOW_DELETED
, ac
->req
);
2096 if (ret
!= LDB_SUCCESS
) {
2099 old_group_type
= ldb_msg_find_attr_as_uint(res
->msgs
[0], "groupType", 0);
2100 if (old_group_type
== 0) {
2101 return ldb_operr(ldb
);
2104 /* Group type switching isn't so easy as it seems: We can only
2105 * change in this directions: global <-> universal <-> local
2106 * On each step also the group type itself
2107 * (security/distribution) is variable. */
2109 if (ldb_request_get_control(ac
->req
, LDB_CONTROL_PROVISION_OID
) == NULL
) {
2110 switch (group_type
) {
2111 case GTYPE_SECURITY_GLOBAL_GROUP
:
2112 case GTYPE_DISTRIBUTION_GLOBAL_GROUP
:
2113 /* change to "universal" allowed */
2114 if ((old_group_type
== GTYPE_SECURITY_DOMAIN_LOCAL_GROUP
) ||
2115 (old_group_type
== GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP
)) {
2116 ldb_set_errstring(ldb
,
2117 "samldb: Change from security/distribution local group forbidden!");
2118 return LDB_ERR_UNWILLING_TO_PERFORM
;
2122 case GTYPE_SECURITY_UNIVERSAL_GROUP
:
2123 case GTYPE_DISTRIBUTION_UNIVERSAL_GROUP
:
2124 /* each change allowed */
2126 case GTYPE_SECURITY_DOMAIN_LOCAL_GROUP
:
2127 case GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP
:
2128 /* change to "universal" allowed */
2129 if ((old_group_type
== GTYPE_SECURITY_GLOBAL_GROUP
) ||
2130 (old_group_type
== GTYPE_DISTRIBUTION_GLOBAL_GROUP
)) {
2131 ldb_set_errstring(ldb
,
2132 "samldb: Change from security/distribution global group forbidden!");
2133 return LDB_ERR_UNWILLING_TO_PERFORM
;
2137 case GTYPE_SECURITY_BUILTIN_LOCAL_GROUP
:
2139 /* we don't allow this "groupType" values */
2140 return LDB_ERR_UNWILLING_TO_PERFORM
;
2145 account_type
= ds_gtype2atype(group_type
);
2146 if (account_type
== 0) {
2147 ldb_set_errstring(ldb
, "samldb: Unrecognized account type!");
2148 return LDB_ERR_UNWILLING_TO_PERFORM
;
2150 ret
= samdb_msg_add_uint(ldb
, ac
->msg
, ac
->msg
, "sAMAccountType",
2152 if (ret
!= LDB_SUCCESS
) {
2155 el
= ldb_msg_find_element(ac
->msg
, "sAMAccountType");
2156 el
->flags
= LDB_FLAG_MOD_REPLACE
;
2161 static int samldb_sam_accountname_check(struct samldb_ctx
*ac
)
2163 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2164 const char * const no_attrs
[] = { NULL
};
2165 struct ldb_result
*res
;
2166 const char *sam_accountname
, *enc_str
;
2167 struct ldb_message_element
*el
;
2168 struct ldb_message
*tmp_msg
;
2171 el
= dsdb_get_single_valued_attr(ac
->msg
, "sAMAccountName",
2172 ac
->req
->operation
);
2174 /* we are not affected */
2178 /* Create a temporary message for fetching the "sAMAccountName" */
2179 tmp_msg
= ldb_msg_new(ac
->msg
);
2180 if (tmp_msg
== NULL
) {
2181 return ldb_module_oom(ac
->module
);
2183 ret
= ldb_msg_add(tmp_msg
, el
, 0);
2184 if (ret
!= LDB_SUCCESS
) {
2188 /* We must not steal the original string, it belongs to the caller! */
2189 sam_accountname
= talloc_strdup(ac
,
2190 ldb_msg_find_attr_as_string(tmp_msg
, "sAMAccountName", NULL
));
2191 talloc_free(tmp_msg
);
2193 if (sam_accountname
== NULL
) {
2194 /* The "sAMAccountName" cannot be nothing */
2195 ldb_set_errstring(ldb
,
2196 "samldb: Empty account names aren't allowed!");
2197 return LDB_ERR_UNWILLING_TO_PERFORM
;
2200 enc_str
= ldb_binary_encode_string(ac
, sam_accountname
);
2201 if (enc_str
== NULL
) {
2202 return ldb_module_oom(ac
->module
);
2205 /* Make sure that a "sAMAccountName" is only used once */
2207 ret
= dsdb_module_search(ac
->module
, ac
, &res
,
2208 ldb_get_default_basedn(ldb
),
2209 LDB_SCOPE_SUBTREE
, no_attrs
,
2210 DSDB_FLAG_NEXT_MODULE
, ac
->req
,
2211 "(sAMAccountName=%s)", enc_str
);
2212 if (ret
!= LDB_SUCCESS
) {
2215 if (res
->count
> 1) {
2216 return ldb_operr(ldb
);
2217 } else if (res
->count
== 1) {
2218 if (ldb_dn_compare(res
->msgs
[0]->dn
, ac
->msg
->dn
) != 0) {
2219 ldb_asprintf_errstring(ldb
,
2220 "samldb: Account name (sAMAccountName) '%s' already in use!",
2222 return LDB_ERR_ENTRY_ALREADY_EXISTS
;
2230 static int samldb_member_check(struct samldb_ctx
*ac
)
2232 const char * const attrs
[] = { "objectSid", NULL
};
2233 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2234 struct ldb_message_element
*el
;
2235 struct ldb_dn
*member_dn
;
2236 struct dom_sid
*sid
;
2237 struct ldb_result
*res
;
2238 struct dom_sid
*group_sid
;
2242 /* Fetch information from the existing object */
2244 ret
= dsdb_module_search(ac
->module
, ac
, &res
, ac
->msg
->dn
, LDB_SCOPE_BASE
, attrs
,
2245 DSDB_FLAG_NEXT_MODULE
| DSDB_SEARCH_SHOW_DELETED
, ac
->req
, NULL
);
2246 if (ret
!= LDB_SUCCESS
) {
2249 if (res
->count
!= 1) {
2250 return ldb_operr(ldb
);
2253 group_sid
= samdb_result_dom_sid(res
, res
->msgs
[0], "objectSid");
2254 if (group_sid
== NULL
) {
2255 return ldb_operr(ldb
);
2258 /* We've to walk over all modification entries and consider the "member"
2260 for (i
= 0; i
< ac
->msg
->num_elements
; i
++) {
2261 if (ldb_attr_cmp(ac
->msg
->elements
[i
].name
, "member") != 0) {
2265 el
= &ac
->msg
->elements
[i
];
2266 for (j
= 0; j
< el
->num_values
; j
++) {
2267 struct ldb_result
*group_res
;
2268 const char *group_attrs
[] = { "primaryGroupID" , NULL
};
2269 uint32_t prim_group_rid
;
2271 if (LDB_FLAG_MOD_TYPE(el
->flags
) == LDB_FLAG_MOD_DELETE
) {
2272 /* Deletes will be handled in
2273 * repl_meta_data, and deletes not
2274 * matching a member will return
2275 * LDB_ERR_UNWILLING_TO_PERFORM
2280 member_dn
= ldb_dn_from_ldb_val(ac
, ldb
,
2282 if (!ldb_dn_validate(member_dn
)) {
2283 return ldb_operr(ldb
);
2286 /* Denies to add "member"s to groups which are primary
2287 * ones for them - in this case return
2288 * ERR_ENTRY_ALREADY_EXISTS. */
2290 ret
= dsdb_module_search_dn(ac
->module
, ac
, &group_res
,
2291 member_dn
, group_attrs
,
2292 DSDB_FLAG_NEXT_MODULE
, ac
->req
);
2293 if (ret
== LDB_ERR_NO_SUCH_OBJECT
) {
2294 /* member DN doesn't exist yet */
2297 if (ret
!= LDB_SUCCESS
) {
2300 prim_group_rid
= ldb_msg_find_attr_as_uint(group_res
->msgs
[0], "primaryGroupID", (uint32_t)-1);
2301 if (prim_group_rid
== (uint32_t) -1) {
2302 /* the member hasn't to be a user account ->
2303 * therefore no check needed in this case. */
2307 sid
= dom_sid_add_rid(ac
, samdb_domain_sid(ldb
),
2310 return ldb_operr(ldb
);
2313 if (dom_sid_equal(group_sid
, sid
)) {
2314 ldb_asprintf_errstring(ldb
,
2315 "samldb: member %s already set via primaryGroupID %u",
2316 ldb_dn_get_linearized(member_dn
), prim_group_rid
);
2317 return LDB_ERR_ENTRY_ALREADY_EXISTS
;
2327 /* SAM objects have special rules regarding the "description" attribute on
2328 * modify operations. */
2329 static int samldb_description_check(struct samldb_ctx
*ac
, bool *modified
)
2331 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2332 const char * const attrs
[] = { "objectClass", "description", NULL
};
2333 struct ldb_result
*res
;
2337 /* Fetch information from the existing object */
2338 ret
= dsdb_module_search(ac
->module
, ac
, &res
, ac
->msg
->dn
, LDB_SCOPE_BASE
, attrs
,
2339 DSDB_FLAG_NEXT_MODULE
| DSDB_SEARCH_SHOW_DELETED
, ac
->req
,
2340 "(|(objectclass=user)(objectclass=group)(objectclass=samDomain)(objectclass=samServer))");
2341 if (ret
!= LDB_SUCCESS
) {
2342 /* don't treat it specially ... let normal error codes
2343 happen from other places */
2344 ldb_reset_err_string(ldb
);
2347 if (res
->count
== 0) {
2348 /* we didn't match the filter */
2353 /* We've to walk over all modification entries and consider the
2354 * "description" ones. */
2355 for (i
= 0; i
< ac
->msg
->num_elements
; i
++) {
2356 if (ldb_attr_cmp(ac
->msg
->elements
[i
].name
, "description") == 0) {
2357 ac
->msg
->elements
[i
].flags
|= LDB_FLAG_INTERNAL_FORCE_SINGLE_VALUE_CHECK
;
2367 /* This trigger adapts the "servicePrincipalName" attributes if the
2368 * "dNSHostName" and/or "sAMAccountName" attribute change(s) */
2369 static int samldb_service_principal_names_change(struct samldb_ctx
*ac
)
2371 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2372 struct ldb_message_element
*el
= NULL
, *el2
= NULL
;
2373 struct ldb_message
*msg
;
2374 const char * const attrs
[] = { "servicePrincipalName", NULL
};
2375 struct ldb_result
*res
;
2376 const char *dns_hostname
= NULL
, *old_dns_hostname
= NULL
,
2377 *sam_accountname
= NULL
, *old_sam_accountname
= NULL
;
2381 el
= dsdb_get_single_valued_attr(ac
->msg
, "dNSHostName",
2382 ac
->req
->operation
);
2383 el2
= dsdb_get_single_valued_attr(ac
->msg
, "sAMAccountName",
2384 ac
->req
->operation
);
2385 if ((el
== NULL
) && (el2
== NULL
)) {
2386 /* we are not affected */
2390 /* Create a temporary message for fetching the "dNSHostName" */
2392 const char *dns_attrs
[] = { "dNSHostName", NULL
};
2393 msg
= ldb_msg_new(ac
->msg
);
2395 return ldb_module_oom(ac
->module
);
2397 ret
= ldb_msg_add(msg
, el
, 0);
2398 if (ret
!= LDB_SUCCESS
) {
2401 dns_hostname
= talloc_strdup(ac
,
2402 ldb_msg_find_attr_as_string(msg
, "dNSHostName", NULL
));
2403 if (dns_hostname
== NULL
) {
2404 return ldb_module_oom(ac
->module
);
2409 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
, ac
->msg
->dn
,
2410 dns_attrs
, DSDB_FLAG_NEXT_MODULE
, ac
->req
);
2411 if (ret
== LDB_SUCCESS
) {
2412 old_dns_hostname
= ldb_msg_find_attr_as_string(res
->msgs
[0], "dNSHostName", NULL
);
2416 /* Create a temporary message for fetching the "sAMAccountName" */
2418 char *tempstr
, *tempstr2
= NULL
;
2419 const char *acct_attrs
[] = { "sAMAccountName", NULL
};
2421 msg
= ldb_msg_new(ac
->msg
);
2423 return ldb_module_oom(ac
->module
);
2425 ret
= ldb_msg_add(msg
, el2
, 0);
2426 if (ret
!= LDB_SUCCESS
) {
2429 tempstr
= talloc_strdup(ac
,
2430 ldb_msg_find_attr_as_string(msg
, "sAMAccountName", NULL
));
2433 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
, ac
->msg
->dn
, acct_attrs
,
2434 DSDB_FLAG_NEXT_MODULE
, ac
->req
);
2435 if (ret
== LDB_SUCCESS
) {
2436 tempstr2
= talloc_strdup(ac
,
2437 ldb_msg_find_attr_as_string(res
->msgs
[0],
2438 "sAMAccountName", NULL
));
2442 /* The "sAMAccountName" needs some additional trimming: we need
2443 * to remove the trailing "$"s if they exist. */
2444 if ((tempstr
!= NULL
) && (tempstr
[0] != '\0') &&
2445 (tempstr
[strlen(tempstr
) - 1] == '$')) {
2446 tempstr
[strlen(tempstr
) - 1] = '\0';
2448 if ((tempstr2
!= NULL
) && (tempstr2
[0] != '\0') &&
2449 (tempstr2
[strlen(tempstr2
) - 1] == '$')) {
2450 tempstr2
[strlen(tempstr2
) - 1] = '\0';
2452 sam_accountname
= tempstr
;
2453 old_sam_accountname
= tempstr2
;
2456 if (old_dns_hostname
== NULL
) {
2457 /* we cannot change when the old name is unknown */
2458 dns_hostname
= NULL
;
2460 if ((old_dns_hostname
!= NULL
) && (dns_hostname
!= NULL
) &&
2461 (strcasecmp_m(old_dns_hostname
, dns_hostname
) == 0)) {
2462 /* The "dNSHostName" didn't change */
2463 dns_hostname
= NULL
;
2466 if (old_sam_accountname
== NULL
) {
2467 /* we cannot change when the old name is unknown */
2468 sam_accountname
= NULL
;
2470 if ((old_sam_accountname
!= NULL
) && (sam_accountname
!= NULL
) &&
2471 (strcasecmp_m(old_sam_accountname
, sam_accountname
) == 0)) {
2472 /* The "sAMAccountName" didn't change */
2473 sam_accountname
= NULL
;
2476 if ((dns_hostname
== NULL
) && (sam_accountname
== NULL
)) {
2477 /* Well, there are information missing (old name(s)) or the
2478 * names didn't change. We've nothing to do and can exit here */
2482 /* Potential "servicePrincipalName" changes in the same request have to
2483 * be handled before the update (Windows behaviour). */
2484 el
= ldb_msg_find_element(ac
->msg
, "servicePrincipalName");
2486 msg
= ldb_msg_new(ac
->msg
);
2488 return ldb_module_oom(ac
->module
);
2490 msg
->dn
= ac
->msg
->dn
;
2493 ret
= ldb_msg_add(msg
, el
, el
->flags
);
2494 if (ret
!= LDB_SUCCESS
) {
2498 ldb_msg_remove_element(ac
->msg
, el
);
2500 el
= ldb_msg_find_element(ac
->msg
,
2501 "servicePrincipalName");
2502 } while (el
!= NULL
);
2504 ret
= dsdb_module_modify(ac
->module
, msg
,
2505 DSDB_FLAG_NEXT_MODULE
, ac
->req
);
2506 if (ret
!= LDB_SUCCESS
) {
2512 /* Fetch the "servicePrincipalName"s if any */
2513 ret
= dsdb_module_search(ac
->module
, ac
, &res
, ac
->msg
->dn
, LDB_SCOPE_BASE
, attrs
,
2514 DSDB_FLAG_NEXT_MODULE
, ac
->req
, NULL
);
2515 if (ret
!= LDB_SUCCESS
) {
2518 if ((res
->count
!= 1) || (res
->msgs
[0]->num_elements
> 1)) {
2519 return ldb_operr(ldb
);
2522 if (res
->msgs
[0]->num_elements
== 1) {
2524 * Yes, we do have "servicePrincipalName"s. First we update them
2525 * locally, that means we do always substitute the current
2526 * "dNSHostName" with the new one and/or "sAMAccountName"
2527 * without "$" with the new one and then we append the
2528 * modified "servicePrincipalName"s as a message element
2529 * replace to the modification request (Windows behaviour). We
2530 * need also to make sure that the values remain case-
2531 * insensitively unique.
2534 ret
= ldb_msg_add_empty(ac
->msg
, "servicePrincipalName",
2535 LDB_FLAG_MOD_REPLACE
, &el
);
2536 if (ret
!= LDB_SUCCESS
) {
2540 for (i
= 0; i
< res
->msgs
[0]->elements
[0].num_values
; i
++) {
2541 char *old_str
, *new_str
, *pos
;
2543 struct ldb_val
*vals
;
2547 res
->msgs
[0]->elements
[0].values
[i
].data
;
2549 new_str
= talloc_strdup(ac
->msg
,
2550 strtok_r(old_str
, "/", &pos
));
2551 if (new_str
== NULL
) {
2552 return ldb_module_oom(ac
->module
);
2555 while ((tok
= strtok_r(NULL
, "/", &pos
)) != NULL
) {
2556 if ((dns_hostname
!= NULL
) &&
2557 (strcasecmp_m(tok
, old_dns_hostname
) == 0)) {
2560 if ((sam_accountname
!= NULL
) &&
2561 (strcasecmp_m(tok
, old_sam_accountname
) == 0)) {
2562 tok
= sam_accountname
;
2565 new_str
= talloc_asprintf(ac
->msg
, "%s/%s",
2567 if (new_str
== NULL
) {
2568 return ldb_module_oom(ac
->module
);
2572 /* Uniqueness check */
2573 for (j
= 0; (!found
) && (j
< el
->num_values
); j
++) {
2574 if (strcasecmp_m((char *)el
->values
[j
].data
,
2584 * append the new "servicePrincipalName" -
2585 * code derived from ldb_msg_add_value().
2587 * Open coded to make it clear that we must
2588 * append to the MOD_REPLACE el created above.
2590 vals
= talloc_realloc(ac
->msg
, el
->values
,
2592 el
->num_values
+ 1);
2594 return ldb_module_oom(ac
->module
);
2597 el
->values
[el
->num_values
] = data_blob_string_const(new_str
);
2607 /* This checks the "fSMORoleOwner" attributes */
2608 static int samldb_fsmo_role_owner_check(struct samldb_ctx
*ac
)
2610 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
2611 const char * const no_attrs
[] = { NULL
};
2612 struct ldb_message_element
*el
;
2613 struct ldb_message
*tmp_msg
;
2614 struct ldb_dn
*res_dn
;
2615 struct ldb_result
*res
;
2618 el
= dsdb_get_single_valued_attr(ac
->msg
, "fSMORoleOwner",
2619 ac
->req
->operation
);
2621 /* we are not affected */
2625 /* Create a temporary message for fetching the "fSMORoleOwner" */
2626 tmp_msg
= ldb_msg_new(ac
->msg
);
2627 if (tmp_msg
== NULL
) {
2628 return ldb_module_oom(ac
->module
);
2630 ret
= ldb_msg_add(tmp_msg
, el
, 0);
2631 if (ret
!= LDB_SUCCESS
) {
2634 res_dn
= ldb_msg_find_attr_as_dn(ldb
, ac
, tmp_msg
, "fSMORoleOwner");
2635 talloc_free(tmp_msg
);
2637 if (res_dn
== NULL
) {
2638 ldb_set_errstring(ldb
,
2639 "samldb: 'fSMORoleOwner' attributes have to reference 'nTDSDSA' entries!");
2640 if (ac
->req
->operation
== LDB_ADD
) {
2641 return LDB_ERR_CONSTRAINT_VIOLATION
;
2643 return LDB_ERR_UNWILLING_TO_PERFORM
;
2647 /* Fetched DN has to reference a "nTDSDSA" entry */
2648 ret
= dsdb_module_search(ac
->module
, ac
, &res
, res_dn
, LDB_SCOPE_BASE
,
2650 DSDB_FLAG_NEXT_MODULE
| DSDB_SEARCH_SHOW_DELETED
,
2651 ac
->req
, "(objectClass=nTDSDSA)");
2652 if (ret
!= LDB_SUCCESS
) {
2655 if (res
->count
!= 1) {
2656 ldb_set_errstring(ldb
,
2657 "samldb: 'fSMORoleOwner' attributes have to reference 'nTDSDSA' entries!");
2658 return LDB_ERR_UNWILLING_TO_PERFORM
;
2668 static int samldb_add(struct ldb_module
*module
, struct ldb_request
*req
)
2670 struct ldb_context
*ldb
;
2671 struct samldb_ctx
*ac
;
2672 struct ldb_message_element
*el
;
2675 ldb
= ldb_module_get_ctx(module
);
2676 ldb_debug(ldb
, LDB_DEBUG_TRACE
, "samldb_add\n");
2678 /* do not manipulate our control entries */
2679 if (ldb_dn_is_special(req
->op
.add
.message
->dn
)) {
2680 return ldb_next_request(module
, req
);
2683 el
= ldb_msg_find_element(req
->op
.add
.message
, "userParameters");
2684 if (el
!= NULL
&& ldb_req_is_untrusted(req
)) {
2685 const char *reason
= "samldb_add: "
2686 "setting userParameters is not supported over LDAP, "
2687 "see https://bugzilla.samba.org/show_bug.cgi?id=8077";
2688 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "%s", reason
);
2689 return ldb_error(ldb
, LDB_ERR_CONSTRAINT_VIOLATION
, reason
);
2692 ac
= samldb_ctx_init(module
, req
);
2694 return ldb_operr(ldb
);
2697 /* build the new msg */
2698 ac
->msg
= ldb_msg_copy_shallow(ac
, req
->op
.add
.message
);
2699 if (ac
->msg
== NULL
) {
2701 ldb_debug(ldb
, LDB_DEBUG_FATAL
,
2702 "samldb_add: ldb_msg_copy_shallow failed!\n");
2703 return ldb_operr(ldb
);
2706 el
= ldb_msg_find_element(ac
->msg
, "fSMORoleOwner");
2708 ret
= samldb_fsmo_role_owner_check(ac
);
2709 if (ret
!= LDB_SUCCESS
) {
2714 if (samdb_find_attribute(ldb
, ac
->msg
,
2715 "objectclass", "user") != NULL
) {
2716 ac
->type
= SAMLDB_TYPE_USER
;
2718 ret
= samldb_prim_group_trigger(ac
);
2719 if (ret
!= LDB_SUCCESS
) {
2723 ret
= samldb_objectclass_trigger(ac
);
2724 if (ret
!= LDB_SUCCESS
) {
2728 return samldb_fill_object(ac
);
2731 if (samdb_find_attribute(ldb
, ac
->msg
,
2732 "objectclass", "group") != NULL
) {
2733 ac
->type
= SAMLDB_TYPE_GROUP
;
2735 ret
= samldb_objectclass_trigger(ac
);
2736 if (ret
!= LDB_SUCCESS
) {
2740 return samldb_fill_object(ac
);
2743 /* perhaps a foreignSecurityPrincipal? */
2744 if (samdb_find_attribute(ldb
, ac
->msg
,
2746 "foreignSecurityPrincipal") != NULL
) {
2747 return samldb_fill_foreignSecurityPrincipal_object(ac
);
2750 if (samdb_find_attribute(ldb
, ac
->msg
,
2751 "objectclass", "classSchema") != NULL
) {
2752 ret
= samldb_schema_info_update(ac
);
2753 if (ret
!= LDB_SUCCESS
) {
2758 ac
->type
= SAMLDB_TYPE_CLASS
;
2759 return samldb_fill_object(ac
);
2762 if (samdb_find_attribute(ldb
, ac
->msg
,
2763 "objectclass", "attributeSchema") != NULL
) {
2764 ret
= samldb_schema_info_update(ac
);
2765 if (ret
!= LDB_SUCCESS
) {
2770 ac
->type
= SAMLDB_TYPE_ATTRIBUTE
;
2771 return samldb_fill_object(ac
);
2776 /* nothing matched, go on */
2777 return ldb_next_request(module
, req
);
2781 static int samldb_modify(struct ldb_module
*module
, struct ldb_request
*req
)
2783 struct ldb_context
*ldb
;
2784 struct samldb_ctx
*ac
;
2785 struct ldb_message_element
*el
, *el2
;
2786 bool modified
= false;
2789 if (ldb_dn_is_special(req
->op
.mod
.message
->dn
)) {
2790 /* do not manipulate our control entries */
2791 return ldb_next_request(module
, req
);
2794 ldb
= ldb_module_get_ctx(module
);
2796 /* make sure that "objectSid" is not specified */
2797 el
= ldb_msg_find_element(req
->op
.mod
.message
, "objectSid");
2799 if (ldb_request_get_control(req
, LDB_CONTROL_PROVISION_OID
) == NULL
) {
2800 ldb_set_errstring(ldb
,
2801 "samldb: objectSid must not be specified!");
2802 return LDB_ERR_UNWILLING_TO_PERFORM
;
2805 /* make sure that "sAMAccountType" is not specified */
2806 el
= ldb_msg_find_element(req
->op
.mod
.message
, "sAMAccountType");
2808 ldb_set_errstring(ldb
,
2809 "samldb: sAMAccountType must not be specified!");
2810 return LDB_ERR_UNWILLING_TO_PERFORM
;
2812 /* make sure that "isCriticalSystemObject" is not specified */
2813 el
= ldb_msg_find_element(req
->op
.mod
.message
, "isCriticalSystemObject");
2815 if (ldb_request_get_control(req
, LDB_CONTROL_RELAX_OID
) == NULL
) {
2816 ldb_set_errstring(ldb
,
2817 "samldb: isCriticalSystemObject must not be specified!");
2818 return LDB_ERR_UNWILLING_TO_PERFORM
;
2822 /* msDS-IntId is not allowed to be modified
2823 * except when modification comes from replication */
2824 if (ldb_msg_find_element(req
->op
.mod
.message
, "msDS-IntId")) {
2825 if (!ldb_request_get_control(req
,
2826 DSDB_CONTROL_REPLICATED_UPDATE_OID
)) {
2827 return LDB_ERR_CONSTRAINT_VIOLATION
;
2831 el
= ldb_msg_find_element(req
->op
.mod
.message
, "userParameters");
2832 if (el
!= NULL
&& ldb_req_is_untrusted(req
)) {
2833 const char *reason
= "samldb: "
2834 "setting userParameters is not supported over LDAP, "
2835 "see https://bugzilla.samba.org/show_bug.cgi?id=8077";
2836 ldb_debug(ldb
, LDB_DEBUG_WARNING
, "%s", reason
);
2837 return ldb_error(ldb
, LDB_ERR_CONSTRAINT_VIOLATION
, reason
);
2840 ac
= samldb_ctx_init(module
, req
);
2842 return ldb_operr(ldb
);
2845 /* build the new msg */
2846 ac
->msg
= ldb_msg_copy_shallow(ac
, req
->op
.mod
.message
);
2847 if (ac
->msg
== NULL
) {
2849 ldb_debug(ldb
, LDB_DEBUG_FATAL
,
2850 "samldb_modify: ldb_msg_copy_shallow failed!\n");
2851 return ldb_operr(ldb
);
2854 el
= ldb_msg_find_element(ac
->msg
, "primaryGroupID");
2856 ret
= samldb_prim_group_trigger(ac
);
2857 if (ret
!= LDB_SUCCESS
) {
2862 el
= ldb_msg_find_element(ac
->msg
, "userAccountControl");
2865 ret
= samldb_user_account_control_change(ac
);
2866 if (ret
!= LDB_SUCCESS
) {
2871 el
= ldb_msg_find_element(ac
->msg
, "lockoutTime");
2874 ret
= samldb_lockout_time(ac
);
2875 if (ret
!= LDB_SUCCESS
) {
2880 el
= ldb_msg_find_element(ac
->msg
, "groupType");
2883 ret
= samldb_group_type_change(ac
);
2884 if (ret
!= LDB_SUCCESS
) {
2889 el
= ldb_msg_find_element(ac
->msg
, "sAMAccountName");
2891 ret
= samldb_sam_accountname_check(ac
);
2892 if (ret
!= LDB_SUCCESS
) {
2897 el
= ldb_msg_find_element(ac
->msg
, "member");
2899 ret
= samldb_member_check(ac
);
2900 if (ret
!= LDB_SUCCESS
) {
2905 el
= ldb_msg_find_element(ac
->msg
, "description");
2907 ret
= samldb_description_check(ac
, &modified
);
2908 if (ret
!= LDB_SUCCESS
) {
2913 el
= ldb_msg_find_element(ac
->msg
, "dNSHostName");
2914 el2
= ldb_msg_find_element(ac
->msg
, "sAMAccountName");
2915 if ((el
!= NULL
) || (el2
!= NULL
)) {
2917 ret
= samldb_service_principal_names_change(ac
);
2918 if (ret
!= LDB_SUCCESS
) {
2923 el
= ldb_msg_find_element(ac
->msg
, "fSMORoleOwner");
2925 ret
= samldb_fsmo_role_owner_check(ac
);
2926 if (ret
!= LDB_SUCCESS
) {
2932 struct ldb_request
*child_req
;
2934 /* Now perform the real modifications as a child request */
2935 ret
= ldb_build_mod_req(&child_req
, ldb
, ac
,
2938 req
, dsdb_next_callback
,
2940 LDB_REQ_SET_LOCATION(child_req
);
2941 if (ret
!= LDB_SUCCESS
) {
2945 return ldb_next_request(module
, child_req
);
2950 /* no change which interests us, go on */
2951 return ldb_next_request(module
, req
);
2956 static int samldb_prim_group_users_check(struct samldb_ctx
*ac
)
2958 struct ldb_context
*ldb
;
2959 struct dom_sid
*sid
;
2963 struct ldb_result
*res
;
2964 const char * const attrs
[] = { "objectSid", "isDeleted", NULL
};
2965 const char * const noattrs
[] = { NULL
};
2967 ldb
= ldb_module_get_ctx(ac
->module
);
2969 /* Finds out the SID/RID of the SAM object */
2970 ret
= dsdb_module_search_dn(ac
->module
, ac
, &res
, ac
->req
->op
.del
.dn
,
2972 DSDB_FLAG_NEXT_MODULE
| DSDB_SEARCH_SHOW_DELETED
,
2974 if (ret
!= LDB_SUCCESS
) {
2978 if (ldb_msg_check_string_attribute(res
->msgs
[0], "isDeleted", "TRUE")) {
2982 sid
= samdb_result_dom_sid(ac
, res
->msgs
[0], "objectSid");
2984 /* No SID - it might not be a SAM object - therefore ok */
2987 status
= dom_sid_split_rid(ac
, sid
, NULL
, &rid
);
2988 if (!NT_STATUS_IS_OK(status
)) {
2989 return ldb_operr(ldb
);
2992 /* Special object (security principal?) */
2995 /* do not allow deletion of well-known sids */
2996 if (rid
< DSDB_SAMDB_MINIMUM_ALLOWED_RID
&&
2997 (ldb_request_get_control(ac
->req
, LDB_CONTROL_RELAX_OID
) == NULL
)) {
2998 return LDB_ERR_OTHER
;
3001 /* Deny delete requests from groups which are primary ones */
3002 ret
= dsdb_module_search(ac
->module
, ac
, &res
,
3003 ldb_get_default_basedn(ldb
),
3004 LDB_SCOPE_SUBTREE
, noattrs
,
3005 DSDB_FLAG_NEXT_MODULE
,
3007 "(&(primaryGroupID=%u)(objectClass=user))", rid
);
3008 if (ret
!= LDB_SUCCESS
) {
3011 if (res
->count
> 0) {
3012 return LDB_ERR_ENTRY_ALREADY_EXISTS
;
3018 static int samldb_delete(struct ldb_module
*module
, struct ldb_request
*req
)
3020 struct samldb_ctx
*ac
;
3023 if (ldb_dn_is_special(req
->op
.del
.dn
)) {
3024 /* do not manipulate our control entries */
3025 return ldb_next_request(module
, req
);
3028 ac
= samldb_ctx_init(module
, req
);
3030 return ldb_operr(ldb_module_get_ctx(module
));
3033 ret
= samldb_prim_group_users_check(ac
);
3034 if (ret
!= LDB_SUCCESS
) {
3040 return ldb_next_request(module
, req
);
3045 static int check_rename_constraints(struct ldb_message
*msg
,
3046 struct samldb_ctx
*ac
,
3047 struct ldb_dn
*olddn
, struct ldb_dn
*newdn
)
3049 struct ldb_context
*ldb
= ldb_module_get_ctx(ac
->module
);
3050 struct ldb_dn
*dn1
, *dn2
, *nc_root
;
3051 int32_t systemFlags
;
3052 bool move_op
= false;
3053 bool rename_op
= false;
3056 /* Skip the checks if old and new DN are the same, or if we have the
3057 * relax control specified or if the returned objects is already
3058 * deleted and needs only to be moved for consistency. */
3060 if (ldb_dn_compare(olddn
, newdn
) == 0) {
3063 if (ldb_request_get_control(ac
->req
, LDB_CONTROL_RELAX_OID
) != NULL
) {
3066 if (ldb_msg_find_attr_as_bool(msg
, "isDeleted", false)) {
3070 /* Objects under CN=System */
3072 dn1
= ldb_dn_copy(ac
, ldb_get_default_basedn(ldb
));
3073 if (dn1
== NULL
) return ldb_oom(ldb
);
3075 if ( ! ldb_dn_add_child_fmt(dn1
, "CN=System")) {
3077 return LDB_ERR_OPERATIONS_ERROR
;
3080 if ((ldb_dn_compare_base(dn1
, olddn
) == 0) &&
3081 (ldb_dn_compare_base(dn1
, newdn
) != 0)) {
3083 ldb_asprintf_errstring(ldb
,
3084 "subtree_rename: Cannot move/rename %s. Objects under CN=System have to stay under it!",
3085 ldb_dn_get_linearized(olddn
));
3086 return LDB_ERR_OTHER
;
3093 if ((samdb_find_attribute(ldb
, msg
, "objectClass", "secret") != NULL
) ||
3094 (samdb_find_attribute(ldb
, msg
, "objectClass", "trustedDomain") != NULL
)) {
3095 ldb_asprintf_errstring(ldb
,
3096 "subtree_rename: Cannot move/rename %s. It's an LSA-specific object!",
3097 ldb_dn_get_linearized(olddn
));
3098 return LDB_ERR_UNWILLING_TO_PERFORM
;
3103 dn1
= ldb_dn_get_parent(ac
, olddn
);
3104 if (dn1
== NULL
) return ldb_oom(ldb
);
3105 dn2
= ldb_dn_get_parent(ac
, newdn
);
3106 if (dn2
== NULL
) return ldb_oom(ldb
);
3108 if (ldb_dn_compare(dn1
, dn2
) == 0) {
3117 systemFlags
= ldb_msg_find_attr_as_int(msg
, "systemFlags", 0);
3119 /* Fetch name context */
3121 ret
= dsdb_find_nc_root(ldb
, ac
, olddn
, &nc_root
);
3122 if (ret
!= LDB_SUCCESS
) {
3126 if (ldb_dn_compare(nc_root
, ldb_get_schema_basedn(ldb
)) == 0) {
3128 ldb_asprintf_errstring(ldb
,
3129 "subtree_rename: Cannot move %s within schema partition",
3130 ldb_dn_get_linearized(olddn
));
3131 return LDB_ERR_UNWILLING_TO_PERFORM
;
3134 (systemFlags
& SYSTEM_FLAG_SCHEMA_BASE_OBJECT
) != 0) {
3135 ldb_asprintf_errstring(ldb
,
3136 "subtree_rename: Cannot rename %s within schema partition",
3137 ldb_dn_get_linearized(olddn
));
3138 return LDB_ERR_UNWILLING_TO_PERFORM
;
3140 } else if (ldb_dn_compare(nc_root
, ldb_get_config_basedn(ldb
)) == 0) {
3142 (systemFlags
& SYSTEM_FLAG_CONFIG_ALLOW_MOVE
) == 0) {
3143 /* Here we have to do more: control the
3144 * "ALLOW_LIMITED_MOVE" flag. This means that the
3145 * grand-grand-parents of two objects have to be equal
3146 * in order to perform the move (this is used for
3147 * moving "server" objects in the "sites" container). */
3149 systemFlags
& SYSTEM_FLAG_CONFIG_ALLOW_LIMITED_MOVE
;
3152 dn1
= ldb_dn_copy(ac
, olddn
);
3153 if (dn1
== NULL
) return ldb_oom(ldb
);
3154 dn2
= ldb_dn_copy(ac
, newdn
);
3155 if (dn2
== NULL
) return ldb_oom(ldb
);
3157 limited_move
&= ldb_dn_remove_child_components(dn1
, 3);
3158 limited_move
&= ldb_dn_remove_child_components(dn2
, 3);
3159 limited_move
&= ldb_dn_compare(dn1
, dn2
) == 0;
3165 if (!limited_move
) {
3166 ldb_asprintf_errstring(ldb
,
3167 "subtree_rename: Cannot move %s to %s in config partition",
3168 ldb_dn_get_linearized(olddn
), ldb_dn_get_linearized(newdn
));
3169 return LDB_ERR_UNWILLING_TO_PERFORM
;
3173 (systemFlags
& SYSTEM_FLAG_CONFIG_ALLOW_RENAME
) == 0) {
3174 ldb_asprintf_errstring(ldb
,
3175 "subtree_rename: Cannot rename %s to %s within config partition",
3176 ldb_dn_get_linearized(olddn
), ldb_dn_get_linearized(newdn
));
3177 return LDB_ERR_UNWILLING_TO_PERFORM
;
3179 } else if (ldb_dn_compare(nc_root
, ldb_get_default_basedn(ldb
)) == 0) {
3181 (systemFlags
& SYSTEM_FLAG_DOMAIN_DISALLOW_MOVE
) != 0) {
3182 ldb_asprintf_errstring(ldb
,
3183 "subtree_rename: Cannot move %s to %s - DISALLOW_MOVE set",
3184 ldb_dn_get_linearized(olddn
), ldb_dn_get_linearized(newdn
));
3185 return LDB_ERR_UNWILLING_TO_PERFORM
;
3188 (systemFlags
& SYSTEM_FLAG_DOMAIN_DISALLOW_RENAME
) != 0) {
3189 ldb_asprintf_errstring(ldb
,
3190 "subtree_rename: Cannot rename %s to %s - DISALLOW_RENAME set",
3191 ldb_dn_get_linearized(olddn
), ldb_dn_get_linearized(newdn
));
3192 return LDB_ERR_UNWILLING_TO_PERFORM
;
3196 talloc_free(nc_root
);
3202 static int samldb_rename_search_base_callback(struct ldb_request
*req
,
3203 struct ldb_reply
*ares
)
3205 struct samldb_ctx
*ac
;
3208 ac
= talloc_get_type(req
->context
, struct samldb_ctx
);
3211 return ldb_module_done(ac
->req
, NULL
, NULL
,
3212 LDB_ERR_OPERATIONS_ERROR
);
3214 if (ares
->error
!= LDB_SUCCESS
) {
3215 return ldb_module_done(ac
->req
, ares
->controls
,
3216 ares
->response
, ares
->error
);
3219 switch (ares
->type
) {
3220 case LDB_REPLY_ENTRY
:
3222 * This is the root entry of the originating move
3223 * respectively rename request. It has been already
3224 * stored in the list using "subtree_rename_search()".
3225 * Only this one is subject to constraint checking.
3227 ret
= check_rename_constraints(ares
->message
, ac
,
3228 ac
->req
->op
.rename
.olddn
,
3229 ac
->req
->op
.rename
.newdn
);
3230 if (ret
!= LDB_SUCCESS
) {
3231 return ldb_module_done(ac
->req
, NULL
, NULL
,
3236 case LDB_REPLY_REFERRAL
:
3240 case LDB_REPLY_DONE
:
3243 * Great, no problem with the rename, so go ahead as
3244 * if we never were here
3246 ret
= ldb_next_request(ac
->module
, ac
->req
);
3257 static int samldb_rename(struct ldb_module
*module
, struct ldb_request
*req
)
3259 struct ldb_context
*ldb
;
3260 static const char * const attrs
[] = { "objectClass", "systemFlags",
3261 "isDeleted", NULL
};
3262 struct ldb_request
*search_req
;
3263 struct samldb_ctx
*ac
;
3266 if (ldb_dn_is_special(req
->op
.rename
.olddn
)) { /* do not manipulate our control entries */
3267 return ldb_next_request(module
, req
);
3270 ldb
= ldb_module_get_ctx(module
);
3272 ac
= samldb_ctx_init(module
, req
);
3274 return ldb_oom(ldb
);
3277 ret
= ldb_build_search_req(&search_req
, ldb
, ac
,
3278 req
->op
.rename
.olddn
,
3284 samldb_rename_search_base_callback
,
3286 LDB_REQ_SET_LOCATION(search_req
);
3287 if (ret
!= LDB_SUCCESS
) {
3291 ret
= ldb_request_add_control(search_req
, LDB_CONTROL_SHOW_RECYCLED_OID
,
3293 if (ret
!= LDB_SUCCESS
) {
3297 return ldb_next_request(ac
->module
, search_req
);
3302 static int samldb_extended_allocate_rid_pool(struct ldb_module
*module
, struct ldb_request
*req
)
3304 struct ldb_context
*ldb
= ldb_module_get_ctx(module
);
3305 struct dsdb_fsmo_extended_op
*exop
;
3308 exop
= talloc_get_type(req
->op
.extended
.data
,
3309 struct dsdb_fsmo_extended_op
);
3311 ldb_set_errstring(ldb
,
3312 "samldb_extended_allocate_rid_pool: invalid extended data");
3313 return LDB_ERR_PROTOCOL_ERROR
;
3316 ret
= ridalloc_allocate_rid_pool_fsmo(module
, exop
, req
);
3317 if (ret
!= LDB_SUCCESS
) {
3321 return ldb_module_done(req
, NULL
, NULL
, LDB_SUCCESS
);
3324 static int samldb_extended(struct ldb_module
*module
, struct ldb_request
*req
)
3326 if (strcmp(req
->op
.extended
.oid
, DSDB_EXTENDED_ALLOCATE_RID_POOL
) == 0) {
3327 return samldb_extended_allocate_rid_pool(module
, req
);
3330 return ldb_next_request(module
, req
);
3334 static const struct ldb_module_ops ldb_samldb_module_ops
= {
3337 .modify
= samldb_modify
,
3338 .del
= samldb_delete
,
3339 .rename
= samldb_rename
,
3340 .extended
= samldb_extended
3344 int ldb_samldb_module_init(const char *version
)
3346 LDB_MODULE_CHECK_VERSION(version
);
3347 return ldb_register_module(&ldb_samldb_module_ops
);