dsdb/group_audit: use common get_parsed_dns_trusted()
[gd/samba-autobuild/.git] / source4 / dsdb / samdb / ldb_modules / group_audit.c
1 /*
2    ldb database library
3
4    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 /*
21  * Provide an audit log of changes made to group memberships
22  *
23  */
24
25 #include "includes.h"
26 #include "ldb_module.h"
27 #include "lib/audit_logging/audit_logging.h"
28 #include "librpc/gen_ndr/windows_event_ids.h"
29
30 #include "dsdb/samdb/samdb.h"
31 #include "dsdb/samdb/ldb_modules/util.h"
32 #include "dsdb/samdb/ldb_modules/audit_util_proto.h"
33 #include "libcli/security/dom_sid.h"
34 #include "auth/common_auth.h"
35 #include "param/param.h"
36
37 #define AUDIT_JSON_TYPE "groupChange"
38 #define AUDIT_HR_TAG "Group Change"
39 #define AUDIT_MAJOR 1
40 #define AUDIT_MINOR 1
41 #define GROUP_LOG_LVL 5
42
43 static const char *const group_attrs[] = {"member", "groupType", NULL};
44 static const char *const group_type_attr[] = {"groupType", NULL};
45 static const char * const primary_group_attr[] = {
46         "primaryGroupID",
47         "objectSID",
48         NULL};
49
50 struct audit_context {
51         bool send_events;
52         struct imessaging_context *msg_ctx;
53 };
54
55 struct audit_callback_context {
56         struct ldb_request *request;
57         struct ldb_module *module;
58         struct ldb_message_element *members;
59         uint32_t primary_group;
60         void (*log_changes)(
61                 struct audit_callback_context *acc,
62                 const int status);
63 };
64
65 /*
66  * @brief get the transaction id.
67  *
68  * Get the id of the transaction that the current request is contained in.
69  *
70  * @param req the request.
71  *
72  * @return the transaction id GUID, or NULL if it is not there.
73  */
74 static struct GUID *get_transaction_id(
75         const struct ldb_request *request)
76 {
77         struct ldb_control *control;
78         struct dsdb_control_transaction_identifier *transaction_id;
79
80         control = ldb_request_get_control(
81                 discard_const(request),
82                 DSDB_CONTROL_TRANSACTION_IDENTIFIER_OID);
83         if (control == NULL) {
84                 return NULL;
85         }
86         transaction_id = talloc_get_type(
87                 control->data,
88                 struct dsdb_control_transaction_identifier);
89         if (transaction_id == NULL) {
90                 return NULL;
91         }
92         return &transaction_id->transaction_guid;
93 }
94
95 /*
96  * @brief generate a JSON log entry for a group change.
97  *
98  * Generate a JSON object containing details of a users group change.
99  *
100  * @param module the ldb module
101  * @param request the ldb_request
102  * @param action the change action being performed
103  * @param user the user name
104  * @param group the group name
105  * @param status the ldb status code for the ldb operation.
106  *
107  * @return A json object containing the details.
108  *         NULL if an error was detected
109  */
110 static struct json_object audit_group_json(const struct ldb_module *module,
111                                            const struct ldb_request *request,
112                                            const char *action,
113                                            const char *user,
114                                            const char *group,
115                                            const enum event_id_type event_id,
116                                            const int status)
117 {
118         struct ldb_context *ldb = NULL;
119         const struct dom_sid *sid = NULL;
120         struct json_object wrapper = json_empty_object;
121         struct json_object audit = json_empty_object;
122         const struct tsocket_address *remote = NULL;
123         const struct GUID *unique_session_token = NULL;
124         struct GUID *transaction_id = NULL;
125         int rc = 0;
126
127         ldb = ldb_module_get_ctx(discard_const(module));
128
129         remote = dsdb_audit_get_remote_address(ldb);
130         sid = dsdb_audit_get_user_sid(module);
131         unique_session_token = dsdb_audit_get_unique_session_token(module);
132         transaction_id = get_transaction_id(request);
133
134         audit = json_new_object();
135         if (json_is_invalid(&audit)) {
136                 goto failure;
137         }
138         rc = json_add_version(&audit, AUDIT_MAJOR, AUDIT_MINOR);
139         if (rc != 0) {
140                 goto failure;
141         }
142         if (event_id != EVT_ID_NONE) {
143                 rc = json_add_int(&audit, "eventId", event_id);
144                 if (rc != 0) {
145                         goto failure;
146                 }
147         }
148         rc = json_add_int(&audit, "statusCode", status);
149         if (rc != 0) {
150                 goto failure;
151         }
152         rc = json_add_string(&audit, "status", ldb_strerror(status));
153         if (rc != 0) {
154                 goto failure;
155         }
156         rc = json_add_string(&audit, "action", action);
157         if (rc != 0) {
158                 goto failure;
159         }
160         rc = json_add_address(&audit, "remoteAddress", remote);
161         if (rc != 0) {
162                 goto failure;
163         }
164         rc = json_add_sid(&audit, "userSid", sid);
165         if (rc != 0) {
166                 goto failure;
167         }
168         rc = json_add_string(&audit, "group", group);
169         if (rc != 0) {
170                 goto failure;
171         }
172         rc = json_add_guid(&audit, "transactionId", transaction_id);
173         if (rc != 0) {
174                 goto failure;
175         }
176         rc = json_add_guid(&audit, "sessionId", unique_session_token);
177         if (rc != 0) {
178                 goto failure;
179         }
180         rc = json_add_string(&audit, "user", user);
181         if (rc != 0) {
182                 goto failure;
183         }
184
185         wrapper = json_new_object();
186         if (json_is_invalid(&wrapper)) {
187                 goto failure;
188         }
189         rc = json_add_timestamp(&wrapper);
190         if (rc != 0) {
191                 goto failure;
192         }
193         rc = json_add_string(&wrapper, "type", AUDIT_JSON_TYPE);
194         if (rc != 0) {
195                 goto failure;
196         }
197         rc = json_add_object(&wrapper, AUDIT_JSON_TYPE, &audit);
198         if (rc != 0) {
199                 goto failure;
200         }
201
202         return wrapper;
203 failure:
204         /*
205          * On a failure audit will not have been added to wrapper so it
206          * needs to free it to avoid a leak.
207          *
208          * wrapper is freed to invalidate it as it will have only been
209          * partially constructed and may be inconsistent.
210          *
211          * All the json manipulation routines handle a freed object correctly
212          */
213         json_free(&audit);
214         json_free(&wrapper);
215         DBG_ERR("Failed to create group change JSON log message\n");
216         return wrapper;
217 }
218
219 /*
220  * @brief generate a human readable log entry for a group change.
221  *
222  * Generate a human readable log entry containing details of a users group
223  * change.
224  *
225  * @param ctx the talloc context owning the returned log entry
226  * @param module the ldb module
227  * @param request the ldb_request
228  * @param action the change action being performed
229  * @param user the user name
230  * @param group the group name
231  * @param status the ldb status code for the ldb operation.
232  *
233  * @return A human readable log line.
234  */
235 static char *audit_group_human_readable(
236         TALLOC_CTX *mem_ctx,
237         const struct ldb_module *module,
238         const struct ldb_request *request,
239         const char *action,
240         const char *user,
241         const char *group,
242         const int status)
243 {
244         struct ldb_context *ldb = NULL;
245         const char *remote_host = NULL;
246         const struct dom_sid *sid = NULL;
247         const char *user_sid = NULL;
248         const char *timestamp = NULL;
249         char *log_entry = NULL;
250
251         TALLOC_CTX *ctx = talloc_new(NULL);
252
253         ldb = ldb_module_get_ctx(discard_const(module));
254
255         remote_host = dsdb_audit_get_remote_host(ldb, ctx);
256         sid = dsdb_audit_get_user_sid(module);
257         user_sid = dom_sid_string(ctx, sid);
258         timestamp = audit_get_timestamp(ctx);
259
260         log_entry = talloc_asprintf(
261                 mem_ctx,
262                 "[%s] at [%s] status [%s] "
263                 "Remote host [%s] SID [%s] Group [%s] User [%s]",
264                 action,
265                 timestamp,
266                 ldb_strerror(status),
267                 remote_host,
268                 user_sid,
269                 group,
270                 user);
271         TALLOC_FREE(ctx);
272         return log_entry;
273 }
274
275 /*
276  * @brief generate an array of parsed_dns, deferring the actual parsing.
277  *
278  * Get an array of 'struct parsed_dns' without the parsing.
279  * The parsed_dns are parsed only when needed to avoid the expense of parsing.
280  *
281  * This procedure assumes that the dn's are sorted in GUID order and contains
282  * no duplicates.  This should be valid as the module sits below repl_meta_data
283  * which ensures this.
284  *
285  * @param mem_ctx The memory context that will own the generated array
286  * @param el The message element used to generate the array.
287  *
288  * @return an array of struct parsed_dns, or NULL in the event of an error
289  */
290 static struct parsed_dn *get_parsed_dns(
291         TALLOC_CTX *mem_ctx,
292         struct ldb_message_element *el)
293 {
294         int ret;
295         struct parsed_dn *pdn = NULL;
296
297         if (el == NULL || el->num_values == 0) {
298                 return NULL;
299         }
300
301         ret = get_parsed_dns_trusted(mem_ctx, el, &pdn);
302         if (ret == LDB_ERR_OPERATIONS_ERROR) {
303                 DBG_ERR("Out of memory\n");
304                 return NULL;
305         }
306         return pdn;
307
308 }
309
310 enum dn_compare_result {
311         LESS_THAN,
312         BINARY_EQUAL,
313         EQUAL,
314         GREATER_THAN
315 };
316 /*
317  * @brief compare parsed_dn, using GUID ordering
318  *
319  * Compare two parsed_dn structures, using GUID ordering.
320  * To avoid the overhead of parsing the DN's this function does a binary
321  * compare first. The DN's tre only parsed if they are not equal at a binary
322  * level.
323  *
324  * @param ctx talloc context that will own the parsed dsdb_dn
325  * @param ldb ldb_context
326  * @param dn1 The first dn
327  * @param dn2 The second dn
328  *
329  * @return BINARY_EQUAL values are equal at a binary level
330  *         EQUAL        DN's are equal but the meta data is different
331  *         LESS_THAN    dn1's GUID is less than dn2's GUID
332  *         GREATER_THAN dn1's GUID is greater than  dn2's GUID
333  *
334  */
335 static enum dn_compare_result dn_compare(
336         TALLOC_CTX *mem_ctx,
337         struct ldb_context *ldb,
338         struct parsed_dn *dn1,
339         struct parsed_dn *dn2) {
340
341         int res = 0;
342
343         /*
344          * Do a binary compare first to avoid unnecessary parsing
345          */
346         if (data_blob_cmp(dn1->v, dn2->v) == 0) {
347                 /*
348                  * Values are equal at a binary level so no need
349                  * for further processing
350                  */
351                 return BINARY_EQUAL;
352         }
353         /*
354          * Values not equal at the binary level, so lets
355          * do a GUID ordering compare. To do this we will need to ensure
356          * that the dn's have been parsed.
357          */
358         if (dn1->dsdb_dn == NULL) {
359                 really_parse_trusted_dn(
360                         mem_ctx,
361                         ldb,
362                         dn1,
363                         LDB_SYNTAX_DN);
364         }
365         if (dn2->dsdb_dn == NULL) {
366                 really_parse_trusted_dn(
367                         mem_ctx,
368                         ldb,
369                         dn2,
370                         LDB_SYNTAX_DN);
371         }
372
373         res = ndr_guid_compare(&dn1->guid, &dn2->guid);
374         if (res < 0) {
375                 return LESS_THAN;
376         } else if (res == 0) {
377                 return EQUAL;
378         } else {
379                 return GREATER_THAN;
380         }
381 }
382
383 /*
384  * @brief Get the DN of a users primary group as a printable string.
385  *
386  * Get the DN of a users primary group as a printable string.
387  *
388  * @param mem_ctx Talloc context the the returned string will be allocated on.
389  * @param module The ldb module
390  * @param account_sid The SID for the uses account.
391  * @param primary_group_rid The RID for the users primary group.
392  *
393  * @return a formatted DN, or null if there is an error.
394  */
395 static const char *get_primary_group_dn(
396         TALLOC_CTX *mem_ctx,
397         struct ldb_module *module,
398         struct dom_sid *account_sid,
399         uint32_t primary_group_rid)
400 {
401         NTSTATUS status;
402
403         struct ldb_context *ldb = NULL;
404         struct dom_sid *domain_sid = NULL;
405         struct dom_sid *primary_group_sid = NULL;
406         char *sid = NULL;
407         struct ldb_dn *dn = NULL;
408         struct ldb_message *msg = NULL;
409         int rc;
410
411         ldb = ldb_module_get_ctx(module);
412
413         status = dom_sid_split_rid(mem_ctx, account_sid, &domain_sid, NULL);
414         if (!NT_STATUS_IS_OK(status)) {
415                 return NULL;
416         }
417
418         primary_group_sid = dom_sid_add_rid(
419                 mem_ctx,
420                 domain_sid,
421                 primary_group_rid);
422         if (!primary_group_sid) {
423                 return NULL;
424         }
425
426         sid = dom_sid_string(mem_ctx, primary_group_sid);
427         if (sid == NULL) {
428                 return NULL;
429         }
430
431         dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>", sid);
432         if(dn == NULL) {
433                 return sid;
434         }
435         rc = dsdb_search_one(
436                 ldb,
437                 mem_ctx,
438                 &msg,
439                 dn,
440                 LDB_SCOPE_BASE,
441                 NULL,
442                 0,
443                 NULL);
444         if (rc != LDB_SUCCESS) {
445                 return NULL;
446         }
447
448         return ldb_dn_get_linearized(msg->dn);
449 }
450
451 /*
452  * @brief Log details of a change to a users primary group.
453  *
454  * Log details of a change to a users primary group.
455  * There is no windows event id associated with a Primary Group change.
456  * However for a new user we generate an added to group event.
457  *
458  * @param module The ldb module.
459  * @param request The request being logged.
460  * @param action Description of the action being performed.
461  * @param group The linearized for of the group DN
462  * @param status the LDB status code for the processing of the request.
463  *
464  */
465 static void log_primary_group_change(
466         struct ldb_module *module,
467         const struct ldb_request *request,
468         const char *action,
469         const char *group,
470         const int  status)
471 {
472         const char *user = NULL;
473
474         struct audit_context *ac =
475                 talloc_get_type(
476                         ldb_module_get_private(module),
477                         struct audit_context);
478
479         TALLOC_CTX *ctx = talloc_new(NULL);
480
481         user = dsdb_audit_get_primary_dn(request);
482         if (CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT, GROUP_LOG_LVL)) {
483                 char *message = NULL;
484                 message = audit_group_human_readable(
485                         ctx,
486                         module,
487                         request,
488                         action,
489                         user,
490                         group,
491                         status);
492                 audit_log_human_text(
493                         AUDIT_HR_TAG,
494                         message,
495                         DBGC_DSDB_GROUP_AUDIT,
496                         GROUP_LOG_LVL);
497                 TALLOC_FREE(message);
498         }
499
500         if (CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT_JSON, GROUP_LOG_LVL) ||
501                 (ac->msg_ctx && ac->send_events)) {
502
503                 struct json_object json;
504                 json = audit_group_json(
505                     module, request, action, user, group, EVT_ID_NONE, status);
506                 audit_log_json(
507                         &json,
508                         DBGC_DSDB_GROUP_AUDIT_JSON,
509                         GROUP_LOG_LVL);
510                 if (ac->send_events) {
511                         audit_message_send(
512                                 ac->msg_ctx,
513                                 DSDB_GROUP_EVENT_NAME,
514                                 MSG_GROUP_LOG,
515                                 &json);
516                 }
517                 json_free(&json);
518                 if (request->operation == LDB_ADD) {
519                         /*
520                          * Have just added a user, generate a groupChange
521                          * message indicating the user has been added to thier
522                          * new PrimaryGroup.
523                          */
524                 }
525         }
526         TALLOC_FREE(ctx);
527 }
528
529 /*
530  * @brief Log details of a single change to a users group membership.
531  *
532  * Log details of a change to a users group membership, except for changes
533  * to their primary group which is handled by log_primary_group_change.
534  *
535  * @param module The ldb module.
536  * @param request The request being logged.
537  * @param action Description of the action being performed.
538  * @param user The linearized form of the users DN
539  * @param status the LDB status code for the processing of the request.
540  *
541  */
542 static void log_membership_change(struct ldb_module *module,
543                                   const struct ldb_request *request,
544                                   const char *action,
545                                   const char *user,
546                                   const enum event_id_type event_id,
547                                   const int status)
548 {
549         const char *group = NULL;
550         struct audit_context *ac =
551                 talloc_get_type(
552                         ldb_module_get_private(module),
553                         struct audit_context);
554
555         TALLOC_CTX *ctx = talloc_new(NULL);
556         group = dsdb_audit_get_primary_dn(request);
557         if (CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT, GROUP_LOG_LVL)) {
558                 char *message = NULL;
559                 message = audit_group_human_readable(
560                         ctx,
561                         module,
562                         request,
563                         action,
564                         user,
565                         group,
566                         status);
567                 audit_log_human_text(
568                         AUDIT_HR_TAG,
569                         message,
570                         DBGC_DSDB_GROUP_AUDIT,
571                         GROUP_LOG_LVL);
572                 TALLOC_FREE(message);
573         }
574
575         if (CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT_JSON, GROUP_LOG_LVL) ||
576                 (ac->msg_ctx && ac->send_events)) {
577                 struct json_object json;
578                 json = audit_group_json(
579                     module, request, action, user, group, event_id, status);
580                 audit_log_json(
581                         &json,
582                         DBGC_DSDB_GROUP_AUDIT_JSON,
583                         GROUP_LOG_LVL);
584                 if (ac->send_events) {
585                         audit_message_send(
586                                 ac->msg_ctx,
587                                 DSDB_GROUP_EVENT_NAME,
588                                 MSG_GROUP_LOG,
589                                 &json);
590                 }
591                 json_free(&json);
592         }
593         TALLOC_FREE(ctx);
594 }
595
596 /*
597  * @brief Get the windows event type id for removing a user from a group type.
598  *
599  * @param group_type the type of the current group, see libds/common/flags.h
600  *
601  * @return the Windows Event Id
602  *
603  */
604 static enum event_id_type get_remove_member_event(uint32_t group_type)
605 {
606
607         switch (group_type) {
608         case GTYPE_SECURITY_BUILTIN_LOCAL_GROUP:
609                 return EVT_ID_USER_REMOVED_FROM_LOCAL_SEC_GROUP;
610         case GTYPE_SECURITY_GLOBAL_GROUP:
611                 return EVT_ID_USER_REMOVED_FROM_GLOBAL_SEC_GROUP;
612         case GTYPE_SECURITY_DOMAIN_LOCAL_GROUP:
613                 return EVT_ID_USER_REMOVED_FROM_LOCAL_SEC_GROUP;
614         case GTYPE_SECURITY_UNIVERSAL_GROUP:
615                 return EVT_ID_USER_REMOVED_FROM_UNIVERSAL_SEC_GROUP;
616         case GTYPE_DISTRIBUTION_GLOBAL_GROUP:
617                 return EVT_ID_USER_REMOVED_FROM_GLOBAL_GROUP;
618         case GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP:
619                 return EVT_ID_USER_REMOVED_FROM_LOCAL_GROUP;
620         case GTYPE_DISTRIBUTION_UNIVERSAL_GROUP:
621                 return EVT_ID_USER_REMOVED_FROM_UNIVERSAL_GROUP;
622         default:
623                 return EVT_ID_NONE;
624         }
625 }
626
627 /*
628  * @brief Get the windows event type id for adding a user to a group type.
629  *
630  * @param group_type the type of the current group, see libds/common/flags.h
631  *
632  * @return the Windows Event Id
633  *
634  */
635 static enum event_id_type get_add_member_event(uint32_t group_type)
636 {
637
638         switch (group_type) {
639         case GTYPE_SECURITY_BUILTIN_LOCAL_GROUP:
640                 return EVT_ID_USER_ADDED_TO_LOCAL_SEC_GROUP;
641         case GTYPE_SECURITY_GLOBAL_GROUP:
642                 return EVT_ID_USER_ADDED_TO_GLOBAL_SEC_GROUP;
643         case GTYPE_SECURITY_DOMAIN_LOCAL_GROUP:
644                 return EVT_ID_USER_ADDED_TO_LOCAL_SEC_GROUP;
645         case GTYPE_SECURITY_UNIVERSAL_GROUP:
646                 return EVT_ID_USER_ADDED_TO_UNIVERSAL_SEC_GROUP;
647         case GTYPE_DISTRIBUTION_GLOBAL_GROUP:
648                 return EVT_ID_USER_ADDED_TO_GLOBAL_GROUP;
649         case GTYPE_DISTRIBUTION_DOMAIN_LOCAL_GROUP:
650                 return EVT_ID_USER_ADDED_TO_LOCAL_GROUP;
651         case GTYPE_DISTRIBUTION_UNIVERSAL_GROUP:
652                 return EVT_ID_USER_ADDED_TO_UNIVERSAL_GROUP;
653         default:
654                 return EVT_ID_NONE;
655         }
656 }
657
658 /*
659  * @brief Log all the changes to a users group membership.
660  *
661  * Log details of a change to a users group memberships, except for changes
662  * to their primary group which is handled by log_primary_group_change.
663  *
664  * @param module The ldb module.
665  * @param request The request being logged.
666  * @param action Description of the action being performed.
667  * @param user The linearized form of the users DN
668  * @param status the LDB status code for the processing of the request.
669  *
670  */
671 static void log_membership_changes(struct ldb_module *module,
672                                    const struct ldb_request *request,
673                                    struct ldb_message_element *el,
674                                    struct ldb_message_element *old_el,
675                                    uint32_t group_type,
676                                    int status)
677 {
678         unsigned int i, old_i, new_i;
679         unsigned int old_num_values;
680         unsigned int max_num_values;
681         unsigned int new_num_values;
682         struct parsed_dn *old_val = NULL;
683         struct parsed_dn *new_val = NULL;
684         struct parsed_dn *new_values = NULL;
685         struct parsed_dn *old_values = NULL;
686         struct ldb_context *ldb = NULL;
687
688         TALLOC_CTX *ctx = talloc_new(NULL);
689
690         old_num_values = old_el ? old_el->num_values : 0;
691         new_num_values = el ? el->num_values : 0;
692         max_num_values = old_num_values + new_num_values;
693
694         if (max_num_values == 0) {
695                 /*
696                  * There is nothing to do!
697                  */
698                 TALLOC_FREE(ctx);
699                 return;
700         }
701
702         old_values = get_parsed_dns(ctx, old_el);
703         new_values = get_parsed_dns(ctx, el);
704         ldb = ldb_module_get_ctx(module);
705
706         old_i = 0;
707         new_i = 0;
708         for (i = 0; i < max_num_values; i++) {
709                 enum dn_compare_result cmp;
710                 if (old_i < old_num_values && new_i < new_num_values) {
711                         /*
712                          * Both list have values, so compare the values
713                          */
714                         old_val = &old_values[old_i];
715                         new_val = &new_values[new_i];
716                         cmp = dn_compare(ctx, ldb, old_val, new_val);
717                 } else if (old_i < old_num_values) {
718                         /*
719                          * the new list is empty, read the old list
720                          */
721                         old_val = &old_values[old_i];
722                         new_val = NULL;
723                         cmp = LESS_THAN;
724                 } else if (new_i < new_num_values) {
725                         /*
726                          * the old list is empty, read new list
727                          */
728                         old_val = NULL;
729                         new_val = &new_values[new_i];
730                         cmp = GREATER_THAN;
731                 } else {
732                         break;
733                 }
734
735                 if (cmp == LESS_THAN) {
736                         /*
737                          * Have an entry in the original record that is not in
738                          * the new record. So it's been deleted
739                          */
740                         const char *user = NULL;
741                         enum event_id_type event_id;
742                         if (old_val->dsdb_dn == NULL) {
743                                 really_parse_trusted_dn(
744                                         ctx,
745                                         ldb,
746                                         old_val,
747                                         LDB_SYNTAX_DN);
748                         }
749                         user = ldb_dn_get_linearized(old_val->dsdb_dn->dn);
750                         event_id = get_remove_member_event(group_type);
751                         log_membership_change(
752                             module, request, "Removed", user, event_id, status);
753                         old_i++;
754                 } else if (cmp == BINARY_EQUAL) {
755                         /*
756                          * DN's unchanged at binary level so nothing to do.
757                          */
758                         old_i++;
759                         new_i++;
760                 } else if (cmp == EQUAL) {
761                         /*
762                          * DN is unchanged now need to check the flags to
763                          * determine if a record has been deleted or undeleted
764                          */
765                         uint32_t old_flags;
766                         uint32_t new_flags;
767                         if (old_val->dsdb_dn == NULL) {
768                                 really_parse_trusted_dn(
769                                         ctx,
770                                         ldb,
771                                         old_val,
772                                         LDB_SYNTAX_DN);
773                         }
774                         if (new_val->dsdb_dn == NULL) {
775                                 really_parse_trusted_dn(
776                                         ctx,
777                                         ldb,
778                                         new_val,
779                                         LDB_SYNTAX_DN);
780                         }
781
782                         dsdb_get_extended_dn_uint32(
783                                 old_val->dsdb_dn->dn,
784                                 &old_flags,
785                                 "RMD_FLAGS");
786                         dsdb_get_extended_dn_uint32(
787                                 new_val->dsdb_dn->dn,
788                                 &new_flags,
789                                 "RMD_FLAGS");
790                         if (new_flags == old_flags) {
791                                 /*
792                                  * No changes to the Repl meta data so can
793                                  * no need to log the change
794                                  */
795                                 old_i++;
796                                 new_i++;
797                                 continue;
798                         }
799                         if (new_flags & DSDB_RMD_FLAG_DELETED) {
800                                 /*
801                                  * DN has been deleted.
802                                  */
803                                 const char *user = NULL;
804                                 enum event_id_type event_id;
805                                 user = ldb_dn_get_linearized(
806                                         old_val->dsdb_dn->dn);
807                                 event_id = get_remove_member_event(group_type);
808                                 log_membership_change(module,
809                                                       request,
810                                                       "Removed",
811                                                       user,
812                                                       event_id,
813                                                       status);
814                         } else {
815                                 /*
816                                  * DN has been re-added
817                                  */
818                                 const char *user = NULL;
819                                 enum event_id_type event_id;
820                                 user = ldb_dn_get_linearized(
821                                         new_val->dsdb_dn->dn);
822                                 event_id = get_add_member_event(group_type);
823                                 log_membership_change(module,
824                                                       request,
825                                                       "Added",
826                                                       user,
827                                                       event_id,
828                                                       status);
829                         }
830                         old_i++;
831                         new_i++;
832                 } else {
833                         /*
834                          * Member in the updated record that's not in the
835                          * original, so it must have been added.
836                          */
837                         const char *user = NULL;
838                         enum event_id_type event_id;
839                         if ( new_val->dsdb_dn == NULL) {
840                                 really_parse_trusted_dn(
841                                         ctx,
842                                         ldb,
843                                         new_val,
844                                         LDB_SYNTAX_DN);
845                         }
846                         user = ldb_dn_get_linearized(new_val->dsdb_dn->dn);
847                         event_id = get_add_member_event(group_type);
848                         log_membership_change(
849                             module, request, "Added", user, event_id, status);
850                         new_i++;
851                 }
852         }
853
854         TALLOC_FREE(ctx);
855 }
856
857 /*
858  * @brief log a group change message for a newly added user.
859  *
860  * When a user is added we need to generate a GroupChange Add message to
861  * log that the user has been added to their PrimaryGroup
862  */
863 static void log_new_user_added_to_primary_group(
864     TALLOC_CTX *ctx,
865     struct audit_callback_context *acc,
866     const char *group,
867     const int status)
868 {
869         uint32_t group_type;
870         enum event_id_type event_id = EVT_ID_NONE;
871         struct ldb_result *res = NULL;
872         struct ldb_dn *group_dn = NULL;
873         struct ldb_context *ldb = NULL;
874         int ret;
875
876         ldb = ldb_module_get_ctx(acc->module);
877         group_dn = ldb_dn_new(ctx, ldb, group);
878         ret = dsdb_module_search_dn(acc->module,
879                                     ctx,
880                                     &res,
881                                     group_dn,
882                                     group_type_attr,
883                                     DSDB_FLAG_NEXT_MODULE |
884                                         DSDB_SEARCH_REVEAL_INTERNALS |
885                                         DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
886                                     NULL);
887         if (ret == LDB_SUCCESS) {
888                 const char *user = NULL;
889                 group_type =
890                     ldb_msg_find_attr_as_uint(res->msgs[0], "groupType", 0);
891                 event_id = get_add_member_event(group_type);
892                 user = dsdb_audit_get_primary_dn(acc->request);
893                 log_membership_change(
894                     acc->module, acc->request, "Added", user, event_id, status);
895         }
896 }
897
898 /*
899  * @brief Log the details of a primary group change.
900  *
901  * Retrieve the users primary groupo after the operation has completed
902  * and call log_primary_group_change to log the actual changes.
903  *
904  * @param acc details of the primary group before the operation.
905  * @param status The status code returned by the operation.
906  *
907  * @return an LDB status code.
908  */
909 static void log_user_primary_group_change(
910         struct audit_callback_context *acc,
911         const int status)
912 {
913         TALLOC_CTX *ctx = talloc_new(NULL);
914         uint32_t new_rid;
915         struct dom_sid *account_sid = NULL;
916         int ret;
917         const struct ldb_message *msg = dsdb_audit_get_message(acc->request);
918
919         if (status == LDB_SUCCESS && msg != NULL) {
920                 struct ldb_result *res = NULL;
921                 ret = dsdb_module_search_dn(
922                         acc->module,
923                         ctx,
924                         &res,
925                         msg->dn,
926                         primary_group_attr,
927                         DSDB_FLAG_NEXT_MODULE |
928                         DSDB_SEARCH_REVEAL_INTERNALS |
929                         DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
930                         NULL);
931                 if (ret == LDB_SUCCESS) {
932                         new_rid = ldb_msg_find_attr_as_uint(
933                                 msg,
934                                 "primaryGroupID",
935                                 ~0);
936                         account_sid = samdb_result_dom_sid(
937                                 ctx,
938                                 res->msgs[0],
939                                 "objectSid");
940                 }
941         }
942         /*
943          * If we don't have a new value then the user has been deleted
944          * which we currently do not log.
945          * Otherwise only log if the primary group has actually changed.
946          */
947         if (account_sid != NULL &&
948             new_rid != ~0 &&
949             acc->primary_group != new_rid) {
950                 const char* group = get_primary_group_dn(
951                         ctx,
952                         acc->module,
953                         account_sid,
954                         new_rid);
955                 log_primary_group_change(
956                         acc->module,
957                         acc->request,
958                         "PrimaryGroup",
959                         group,
960                         status);
961                 /*
962                  * Are we adding a new user with the primaryGroupID
963                  * set. If so and we're generating JSON audit logs, will need to
964                  * generate an "Add" message with the appropriate windows
965                  * event id.
966                  */
967                 if (acc->request->operation == LDB_ADD) {
968                         log_new_user_added_to_primary_group(
969                             ctx, acc, group, status);
970                 }
971         }
972         TALLOC_FREE(ctx);
973 }
974
975 /*
976  * @brief log the changes to users group membership.
977  *
978  * Retrieve the users group memberships after the operation has completed
979  * and call log_membership_changes to log the actual changes.
980  *
981  * @param acc details of the group memberships before the operation.
982  * @param status The status code returned by the operation.
983  *
984  */
985 static void log_group_membership_changes(
986         struct audit_callback_context *acc,
987         const int status)
988 {
989         TALLOC_CTX *ctx = talloc_new(NULL);
990         struct ldb_message_element *new_val = NULL;
991         int ret;
992         uint32_t group_type = 0;
993         const struct ldb_message *msg = dsdb_audit_get_message(acc->request);
994         if (status == LDB_SUCCESS && msg != NULL) {
995                 struct ldb_result *res = NULL;
996                 ret = dsdb_module_search_dn(
997                         acc->module,
998                         ctx,
999                         &res,
1000                         msg->dn,
1001                         group_attrs,
1002                         DSDB_FLAG_NEXT_MODULE |
1003                         DSDB_SEARCH_REVEAL_INTERNALS |
1004                         DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
1005                         NULL);
1006                 if (ret == LDB_SUCCESS) {
1007                         new_val = ldb_msg_find_element(res->msgs[0], "member");
1008                         group_type = ldb_msg_find_attr_as_uint(
1009                             res->msgs[0], "groupType", 0);
1010                         log_membership_changes(acc->module,
1011                                                acc->request,
1012                                                new_val,
1013                                                acc->members,
1014                                                group_type,
1015                                                status);
1016                         TALLOC_FREE(ctx);
1017                         return;
1018                 }
1019         }
1020         /*
1021          * If we get here either
1022          *   one of the lower level modules failed and the group record did
1023          *   not get updated
1024          * or
1025          *   the updated group record could not be read.
1026          *
1027          * In both cases it does not make sense to log individual membership
1028          * changes so we log a group membership change "Failure" message.
1029          *
1030          */
1031         log_membership_change(acc->module,
1032                               acc->request,
1033                               "Failure",
1034                               "",
1035                               EVT_ID_NONE,
1036                               status);
1037         TALLOC_FREE(ctx);
1038 }
1039
1040 /*
1041  * @brief call back function to log changes to the group memberships.
1042  *
1043  * Call back function to log changes to the uses broup memberships.
1044  *
1045  * @param req the ldb request.
1046  * @param ares the ldb result
1047  *
1048  * @return am LDB status code.
1049  */
1050 static int group_audit_callback(
1051         struct ldb_request *req,
1052         struct ldb_reply *ares)
1053 {
1054         struct audit_callback_context *ac = NULL;
1055
1056         ac = talloc_get_type(
1057                 req->context,
1058                 struct audit_callback_context);
1059
1060         if (!ares) {
1061                 return ldb_module_done(
1062                                 ac->request, NULL, NULL,
1063                                 LDB_ERR_OPERATIONS_ERROR);
1064         }
1065
1066         /* pass on to the callback */
1067         switch (ares->type) {
1068         case LDB_REPLY_ENTRY:
1069                 return ldb_module_send_entry(
1070                         ac->request,
1071                         ares->message,
1072                         ares->controls);
1073
1074         case LDB_REPLY_REFERRAL:
1075                 return ldb_module_send_referral(
1076                         ac->request,
1077                         ares->referral);
1078
1079         case LDB_REPLY_DONE:
1080                 /*
1081                  * Log on DONE now we have a result code
1082                  */
1083                 ac->log_changes(ac, ares->error);
1084                 return ldb_module_done(
1085                         ac->request,
1086                         ares->controls,
1087                         ares->response,
1088                         ares->error);
1089                 break;
1090
1091         default:
1092                 /* Can't happen */
1093                 return LDB_ERR_OPERATIONS_ERROR;
1094         }
1095 }
1096
1097 /*
1098  * @brief Does this request change the primary group.
1099  *
1100  * Does the request change the primary group, i.e. does it contain the
1101  * primaryGroupID attribute.
1102  *
1103  * @param req the request to examine.
1104  *
1105  * @return True if the request modifies the primary group.
1106  */
1107 static bool has_primary_group_id(struct ldb_request *req)
1108 {
1109         struct ldb_message_element *el = NULL;
1110         const struct ldb_message *msg = NULL;
1111
1112         msg = dsdb_audit_get_message(req);
1113         el = ldb_msg_find_element(msg, "primaryGroupID");
1114
1115         return (el != NULL);
1116 }
1117
1118 /*
1119  * @brief Does this request change group membership.
1120  *
1121  * Does the request change the ses group memberships, i.e. does it contain the
1122  * member attribute.
1123  *
1124  * @param req the request to examine.
1125  *
1126  * @return True if the request modifies the users group memberships.
1127  */
1128 static bool has_group_membership_changes(struct ldb_request *req)
1129 {
1130         struct ldb_message_element *el = NULL;
1131         const struct ldb_message *msg = NULL;
1132
1133         msg = dsdb_audit_get_message(req);
1134         el = ldb_msg_find_element(msg, "member");
1135
1136         return (el != NULL);
1137 }
1138
1139
1140
1141 /*
1142  * @brief Install the callback function to log an add request.
1143  *
1144  * Install the callback function to log an add request changing the users
1145  * group memberships. As we want to log the returned status code, we need to
1146  * register a callback function that will be called once the operation has
1147  * completed.
1148  *
1149  * This function reads the current user record so that we can log the before
1150  * and after state.
1151  *
1152  * @param module The ldb module.
1153  * @param req The modify request.
1154  *
1155  * @return and LDB status code.
1156  */
1157 static int set_group_membership_add_callback(
1158         struct ldb_module *module,
1159         struct ldb_request *req)
1160 {
1161         struct audit_callback_context *context = NULL;
1162         struct ldb_request *new_req = NULL;
1163         struct ldb_context *ldb = NULL;
1164         int ret;
1165         /*
1166          * Adding group memberships so will need to log the changes.
1167          */
1168         ldb = ldb_module_get_ctx(module);
1169         context = talloc_zero(req, struct audit_callback_context);
1170
1171         if (context == NULL) {
1172                 return ldb_oom(ldb);
1173         }
1174         context->request = req;
1175         context->module = module;
1176         context->log_changes = log_group_membership_changes;
1177         /*
1178          * We want to log the return code status, so we need to register
1179          * a callback function to get the actual result.
1180          * We need to take a new copy so that we don't alter the callers copy
1181          */
1182         ret = ldb_build_add_req(
1183                 &new_req,
1184                 ldb,
1185                 req,
1186                 req->op.add.message,
1187                 req->controls,
1188                 context,
1189                 group_audit_callback,
1190                 req);
1191         if (ret != LDB_SUCCESS) {
1192                 return ret;
1193         }
1194         return ldb_next_request(module, new_req);
1195 }
1196
1197
1198 /*
1199  * @brief Install the callback function to log a modify request.
1200  *
1201  * Install the callback function to log a modify request changing the primary
1202  * group . As we want to log the returned status code, we need to register a
1203  * callback function that will be called once the operation has completed.
1204  *
1205  * This function reads the current user record so that we can log the before
1206  * and after state.
1207  *
1208  * @param module The ldb module.
1209  * @param req The modify request.
1210  *
1211  * @return and LDB status code.
1212  */
1213 static int set_primary_group_modify_callback(
1214         struct ldb_module *module,
1215         struct ldb_request *req)
1216 {
1217         struct audit_callback_context *context = NULL;
1218         struct ldb_request *new_req = NULL;
1219         struct ldb_context *ldb = NULL;
1220         const struct ldb_message *msg = NULL;
1221         struct ldb_result *res = NULL;
1222         int ret;
1223
1224         TALLOC_CTX *ctx = talloc_new(NULL);
1225
1226         ldb = ldb_module_get_ctx(module);
1227
1228         context = talloc_zero(req, struct audit_callback_context);
1229         if (context == NULL) {
1230                 ret = ldb_oom(ldb);
1231                 goto exit;
1232         }
1233         context->request = req;
1234         context->module = module;
1235         context->log_changes = log_user_primary_group_change;
1236
1237         msg = dsdb_audit_get_message(req);
1238         ret = dsdb_module_search_dn(
1239                 module,
1240                 ctx,
1241                 &res,
1242                 msg->dn,
1243                 primary_group_attr,
1244                 DSDB_FLAG_NEXT_MODULE |
1245                 DSDB_SEARCH_REVEAL_INTERNALS |
1246                 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
1247                 NULL);
1248         if (ret == LDB_SUCCESS) {
1249                 uint32_t pg;
1250                 pg = ldb_msg_find_attr_as_uint(
1251                         res->msgs[0],
1252                         "primaryGroupID",
1253                         ~0);
1254                 context->primary_group = pg;
1255         }
1256         /*
1257          * We want to log the return code status, so we need to register
1258          * a callback function to get the actual result.
1259          * We need to take a new copy so that we don't alter the callers copy
1260          */
1261         ret = ldb_build_mod_req(
1262                 &new_req,
1263                 ldb,
1264                 req,
1265                 req->op.add.message,
1266                 req->controls,
1267                 context,
1268                 group_audit_callback,
1269                 req);
1270         if (ret != LDB_SUCCESS) {
1271                 goto exit;
1272         }
1273         ret = ldb_next_request(module, new_req);
1274 exit:
1275         TALLOC_FREE(ctx);
1276         return ret;
1277 }
1278
1279 /*
1280  * @brief Install the callback function to log an add request.
1281  *
1282  * Install the callback function to log an add request changing the primary
1283  * group . As we want to log the returned status code, we need to register a
1284  * callback function that will be called once the operation has completed.
1285  *
1286  * This function reads the current user record so that we can log the before
1287  * and after state.
1288  *
1289  * @param module The ldb module.
1290  * @param req The modify request.
1291  *
1292  * @return and LDB status code.
1293  */
1294 static int set_primary_group_add_callback(
1295         struct ldb_module *module,
1296         struct ldb_request *req)
1297 {
1298         struct audit_callback_context *context = NULL;
1299         struct ldb_request *new_req = NULL;
1300         struct ldb_context *ldb = NULL;
1301         int ret;
1302         /*
1303          * Adding a user with a primary group.
1304          */
1305         ldb = ldb_module_get_ctx(module);
1306         context = talloc_zero(req, struct audit_callback_context);
1307
1308         if (context == NULL) {
1309                 return ldb_oom(ldb);
1310         }
1311         context->request = req;
1312         context->module = module;
1313         context->log_changes = log_user_primary_group_change;
1314         /*
1315          * We want to log the return code status, so we need to register
1316          * a callback function to get the actual result.
1317          * We need to take a new copy so that we don't alter the callers copy
1318          */
1319         ret = ldb_build_add_req(
1320                 &new_req,
1321                 ldb,
1322                 req,
1323                 req->op.add.message,
1324                 req->controls,
1325                 context,
1326                 group_audit_callback,
1327                 req);
1328         if (ret != LDB_SUCCESS) {
1329                 return ret;
1330         }
1331         return ldb_next_request(module, new_req);
1332 }
1333
1334 /*
1335  * @brief Module handler for add operations.
1336  *
1337  * Inspect the current add request, and if needed log any group membership
1338  * changes.
1339  *
1340  * @param module The ldb module.
1341  * @param req The modify request.
1342  *
1343  * @return and LDB status code.
1344  */
1345 static int group_add(
1346         struct ldb_module *module,
1347         struct ldb_request *req)
1348 {
1349
1350         struct audit_context *ac =
1351                 talloc_get_type(
1352                         ldb_module_get_private(module),
1353                         struct audit_context);
1354         /*
1355          * Currently we don't log replicated group changes
1356          */
1357         if (ldb_request_get_control(req, DSDB_CONTROL_REPLICATED_UPDATE_OID)) {
1358                 return ldb_next_request(module, req);
1359         }
1360
1361         if (CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT, GROUP_LOG_LVL) ||
1362                 CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT_JSON, GROUP_LOG_LVL) ||
1363                 (ac->msg_ctx && ac->send_events)) {
1364                 /*
1365                  * Avoid the overheads of logging unless it has been
1366                  * enabled
1367                  */
1368                 if (has_group_membership_changes(req)) {
1369                         return set_group_membership_add_callback(module, req);
1370                 }
1371                 if (has_primary_group_id(req)) {
1372                         return set_primary_group_add_callback(module, req);
1373                 }
1374         }
1375         return ldb_next_request(module, req);
1376 }
1377
1378 /*
1379  * @brief Module handler for delete operations.
1380  *
1381  * Currently there is no logging for delete operations.
1382  *
1383  * @param module The ldb module.
1384  * @param req The modify request.
1385  *
1386  * @return and LDB status code.
1387  */
1388 static int group_delete(
1389         struct ldb_module *module,
1390         struct ldb_request *req)
1391 {
1392         return ldb_next_request(module, req);
1393 }
1394
1395 /*
1396  * @brief Install the callback function to log a modify request.
1397  *
1398  * Install the callback function to log a modify request. As we want to log the
1399  * returned status code, we need to register a callback function that will be
1400  * called once the operation has completed.
1401  *
1402  * This function reads the current user record so that we can log the before
1403  * and after state.
1404  *
1405  * @param module The ldb module.
1406  * @param req The modify request.
1407  *
1408  * @return and LDB status code.
1409  */
1410 static int set_group_modify_callback(
1411         struct ldb_module *module,
1412         struct ldb_request *req)
1413 {
1414         struct audit_callback_context *context = NULL;
1415         struct ldb_request *new_req = NULL;
1416         struct ldb_context *ldb = NULL;
1417         struct ldb_result *res = NULL;
1418         int ret;
1419
1420         ldb = ldb_module_get_ctx(module);
1421         context = talloc_zero(req, struct audit_callback_context);
1422
1423         if (context == NULL) {
1424                 return ldb_oom(ldb);
1425         }
1426         context->request = req;
1427         context->module  = module;
1428         context->log_changes = log_group_membership_changes;
1429
1430         /*
1431          * About to change the group memberships need to read
1432          * the current state from the database.
1433          */
1434         ret = dsdb_module_search_dn(
1435                 module,
1436                 context,
1437                 &res,
1438                 req->op.add.message->dn,
1439                 group_attrs,
1440                 DSDB_FLAG_NEXT_MODULE |
1441                 DSDB_SEARCH_REVEAL_INTERNALS |
1442                 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
1443                 NULL);
1444         if (ret == LDB_SUCCESS) {
1445                 context->members = ldb_msg_find_element(res->msgs[0], "member");
1446         }
1447
1448         ret = ldb_build_mod_req(
1449                 &new_req,
1450                 ldb,
1451                 req,
1452                 req->op.mod.message,
1453                 req->controls,
1454                 context,
1455                 group_audit_callback,
1456                 req);
1457         if (ret != LDB_SUCCESS) {
1458                 return ret;
1459         }
1460         return ldb_next_request(module, new_req);
1461 }
1462
1463 /*
1464  * @brief Module handler for modify operations.
1465  *
1466  * Inspect the current modify request, and if needed log any group membership
1467  * changes.
1468  *
1469  * @param module The ldb module.
1470  * @param req The modify request.
1471  *
1472  * @return and LDB status code.
1473  */
1474 static int group_modify(
1475         struct ldb_module *module,
1476         struct ldb_request *req)
1477 {
1478
1479         struct audit_context *ac =
1480                 talloc_get_type(
1481                         ldb_module_get_private(module),
1482                         struct audit_context);
1483         /*
1484          * Currently we don't log replicated group changes
1485          */
1486         if (ldb_request_get_control(req, DSDB_CONTROL_REPLICATED_UPDATE_OID)) {
1487                 return ldb_next_request(module, req);
1488         }
1489
1490         if (CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT, GROUP_LOG_LVL) ||
1491             CHECK_DEBUGLVLC(DBGC_DSDB_GROUP_AUDIT_JSON, GROUP_LOG_LVL) ||
1492                 (ac->msg_ctx && ac->send_events)) {
1493                 /*
1494                  * Avoid the overheads of logging unless it has been
1495                  * enabled
1496                  */
1497                 if (has_group_membership_changes(req)) {
1498                         return set_group_modify_callback(module, req);
1499                 }
1500                 if (has_primary_group_id(req)) {
1501                         return set_primary_group_modify_callback(module, req);
1502                 }
1503         }
1504         return ldb_next_request(module, req);
1505 }
1506
1507 /*
1508  * @brief ldb module initialisation
1509  *
1510  * Initialise the module, loading the private data etc.
1511  *
1512  * @param module The ldb module to initialise.
1513  *
1514  * @return An LDB status code.
1515  */
1516 static int group_init(struct ldb_module *module)
1517 {
1518
1519         struct ldb_context *ldb = ldb_module_get_ctx(module);
1520         struct audit_context *context = NULL;
1521         struct loadparm_context *lp_ctx
1522                 = talloc_get_type_abort(
1523                         ldb_get_opaque(ldb, "loadparm"),
1524                         struct loadparm_context);
1525         struct tevent_context *ev = ldb_get_event_context(ldb);
1526
1527         context = talloc_zero(module, struct audit_context);
1528         if (context == NULL) {
1529                 return ldb_module_oom(module);
1530         }
1531
1532         if (lp_ctx && lpcfg_dsdb_group_change_notification(lp_ctx)) {
1533                 context->send_events = true;
1534                 context->msg_ctx = imessaging_client_init(context,
1535                                                           lp_ctx,
1536                                                           ev);
1537         }
1538
1539         ldb_module_set_private(module, context);
1540         return ldb_next_init(module);
1541 }
1542
1543 static const struct ldb_module_ops ldb_group_audit_log_module_ops = {
1544         .name              = "group_audit_log",
1545         .add               = group_add,
1546         .modify            = group_modify,
1547         .del               = group_delete,
1548         .init_context      = group_init,
1549 };
1550
1551 int ldb_group_audit_log_module_init(const char *version)
1552 {
1553         LDB_MODULE_CHECK_VERSION(version);
1554         return ldb_register_module(&ldb_group_audit_log_module_ops);
1555 }