241c0534dae0feb8e5f1486d55012a29a9c66c5b
[metze/samba-autobuild/.git] / source4 / dsdb / samdb / ldb_modules / tests / test_group_audit.c
1 /*
2    Unit tests for the dsdb group auditing code in group_audit.c
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 #include <stdarg.h>
21 #include <stddef.h>
22 #include <setjmp.h>
23 #include <unistd.h>
24 #include <cmocka.h>
25
26 int ldb_group_audit_log_module_init(const char *version);
27 #include "../group_audit.c"
28
29 #include "lib/ldb/include/ldb_private.h"
30 #include <regex.h>
31
32 /*
33  * Mock version of dsdb_search_one
34  */
35 struct ldb_dn *g_basedn = NULL;
36 enum ldb_scope g_scope;
37 const char * const *g_attrs = NULL;
38 uint32_t g_dsdb_flags;
39 const char *g_exp_fmt;
40 const char *g_dn = NULL;
41 int g_status = LDB_SUCCESS;
42
43 int dsdb_search_one(struct ldb_context *ldb,
44                     TALLOC_CTX *mem_ctx,
45                     struct ldb_message **msg,
46                     struct ldb_dn *basedn,
47                     enum ldb_scope scope,
48                     const char * const *attrs,
49                     uint32_t dsdb_flags,
50                     const char *exp_fmt, ...) _PRINTF_ATTRIBUTE(8, 9)
51 {
52         struct ldb_dn *dn = ldb_dn_new(mem_ctx, ldb, g_dn);
53         struct ldb_message *m = talloc_zero(mem_ctx, struct ldb_message);
54         m->dn = dn;
55         *msg = m;
56
57         g_basedn = basedn;
58         g_scope = scope;
59         g_attrs = attrs;
60         g_dsdb_flags = dsdb_flags;
61         g_exp_fmt = exp_fmt;
62
63         return g_status;
64 }
65
66 /*
67  * Mock version of audit_log_json
68  */
69
70 #define MAX_EXPECTED_MESSAGES 16
71 static struct json_object messages[MAX_EXPECTED_MESSAGES];
72 static size_t messages_sent = 0;
73
74 void audit_message_send(
75         struct imessaging_context *msg_ctx,
76         const char *server_name,
77         uint32_t message_type,
78         struct json_object *message)
79 {
80         messages[messages_sent].root = json_deep_copy(message->root);
81         messages[messages_sent].valid = message->valid;
82         messages_sent++;
83 }
84
85 #define check_group_change_message(m, u, a)\
86         _check_group_change_message(m, u, a, __FILE__, __LINE__);
87 /*
88  * declare the internal cmocka cm_print_error so that we can output messages
89  * in sub unit format
90  */
91 void cm_print_error(const char * const format, ...);
92
93 /*
94  * Validate a group change JSON audit message
95  *
96  * It should contain 3 elements.
97  * Have a type of "groupChange"
98  * Have a groupChange element
99  *
100  * The group change element should have 10 elements.
101  *
102  * There should be a user element matching the expected value
103  * There should be an action matching the expected value
104  */
105 static void _check_group_change_message(
106         const int message,
107         const char *user,
108         const char *action,
109         const char *file,
110         const int line)
111 {
112         struct json_object json;
113         json_t *audit = NULL;
114         json_t *v = NULL;
115         const char* value;
116         int cmp;
117
118         json = messages[message];
119
120         /*
121          * Validate the root JSON element
122          * check the number of elements
123          */
124         if (json_object_size(json.root) != 3) {
125                 cm_print_error(
126                     "Unexpected number of elements in root %zu != %d\n",
127                     json_object_size(json.root),
128                     3);
129                 _fail(file, line);
130         }
131
132         /*
133          * Check the type element
134          */
135         v = json_object_get(json.root, "type");
136         if (v == NULL) {
137                 cm_print_error( "No \"type\" element\n");
138                 _fail(file, line);
139         }
140
141         value = json_string_value(v);
142         cmp = strcmp("groupChange", value);
143         if (cmp != 0) {
144                 cm_print_error(
145                     "Unexpected type \"%s\" != \"groupChange\"\n",
146                     value);
147                 _fail(file, line);
148         }
149
150
151         audit = json_object_get(json.root, "groupChange");
152         if (audit == NULL) {
153                 cm_print_error("No groupChange element\n");
154                 _fail(file, line);
155         }
156
157         /*
158          * Validate the groupChange element
159          */
160         if (json_object_size(audit) != 10) {
161                 cm_print_error(
162                     "Unexpected number of elements in groupChange "
163                     "%zu != %d\n",
164                     json_object_size(audit),
165                     10);
166                 _fail(file, line);
167         }
168         /*
169          * Validate the user element
170          */
171         v = json_object_get(audit, "user");
172         if (v == NULL) {
173                 cm_print_error( "No user element\n");
174                 _fail(file, line);
175         }
176
177         value = json_string_value(v);
178         cmp = strcmp(user, value);
179         if (cmp != 0) {
180                 cm_print_error(
181                     "Unexpected user name \"%s\" != \"%s\"\n",
182                     value,
183                     user);
184                 _fail(file, line);
185         }
186
187         /*
188          * Validate the action element
189          */
190         v = json_object_get(audit, "action");
191         if (v == NULL) {
192                 cm_print_error( "No action element\n");
193                 _fail(file, line);
194         }
195
196         value = json_string_value(v);
197         cmp = strcmp(action, value);
198         if (cmp != 0) {
199                 print_error(
200                     "Unexpected action \"%s\" != \"%s\"\n",
201                     value,
202                     action);
203                 _fail(file, line);
204         }
205 }
206
207 #define check_timestamp(b, t)\
208         _check_timestamp(b, t, __FILE__, __LINE__);
209 /*
210  * Test helper to check ISO 8601 timestamps for validity
211  */
212 static void _check_timestamp(
213         time_t before,
214         const char *timestamp,
215         const char *file,
216         const int line)
217 {
218         int rc;
219         int usec, tz;
220         char c[2];
221         struct tm tm;
222         time_t after;
223         time_t actual;
224
225
226         after = time(NULL);
227
228         /*
229          * Convert the ISO 8601 timestamp into a time_t
230          * Note for convenience we ignore the value of the microsecond
231          * part of the time stamp.
232          */
233         rc = sscanf(
234                 timestamp,
235                 "%4d-%2d-%2dT%2d:%2d:%2d.%6d%1c%4d",
236                 &tm.tm_year,
237                 &tm.tm_mon,
238                 &tm.tm_mday,
239                 &tm.tm_hour,
240                 &tm.tm_min,
241                 &tm.tm_sec,
242                 &usec,
243                 c,
244                 &tz);
245         assert_int_equal(9, rc);
246         tm.tm_year = tm.tm_year - 1900;
247         tm.tm_mon = tm.tm_mon - 1;
248         tm.tm_isdst = -1;
249         actual = mktime(&tm);
250
251         /*
252          * The time stamp should be before <= actual <= after
253          */
254         if (difftime(actual, before) < 0) {
255                 char buffer[40];
256                 strftime(buffer,
257                          sizeof(buffer)-1,
258                          "%Y-%m-%dT%T",
259                          localtime(&before));
260                 cm_print_error(
261                     "time stamp \"%s\" is before start time \"%s\"\n",
262                     timestamp,
263                     buffer);
264                 _fail(file, line);
265         }
266         if (difftime(after, actual) < 0) {
267                 char buffer[40];
268                 strftime(buffer,
269                          sizeof(buffer)-1,
270                          "%Y-%m-%dT%T",
271                          localtime(&after));
272                 cm_print_error(
273                     "time stamp \"%s\" is after finish time \"%s\"\n",
274                     timestamp,
275                     buffer);
276                 _fail(file, line);
277         }
278 }
279
280 #define check_version(v, m, n)\
281         _check_version(v, m, n, __FILE__, __LINE__);
282 /*
283  * Test helper to validate a version object.
284  */
285 static void _check_version(
286         struct json_t *version,
287         int major,
288         int minor,
289         const char* file,
290         const int line)
291 {
292         struct json_t *v = NULL;
293         int value;
294
295         if (!json_is_object(version)) {
296                 cm_print_error("version is not a JSON object\n");
297                 _fail(file, line);
298         }
299
300         if (json_object_size(version) != 2) {
301                 cm_print_error(
302                     "Unexpected number of elements in version %zu != %d\n",
303                     json_object_size(version),
304                     2);
305                 _fail(file, line);
306         }
307
308         /*
309          * Validate the major version number element
310          */
311         v = json_object_get(version, "major");
312         if (v == NULL) {
313                 cm_print_error( "No major element\n");
314                 _fail(file, line);
315         }
316
317         value = json_integer_value(v);
318         if (value != major) {
319                 print_error(
320                     "Unexpected major version number \"%d\" != \"%d\"\n",
321                     value,
322                     major);
323                 _fail(file, line);
324         }
325
326         /*
327          * Validate the minor version number element
328          */
329         v = json_object_get(version, "minor");
330         if (v == NULL) {
331                 cm_print_error( "No minor element\n");
332                 _fail(file, line);
333         }
334
335         value = json_integer_value(v);
336         if (value != minor) {
337                 print_error(
338                     "Unexpected minor version number \"%d\" != \"%d\"\n",
339                     value,
340                     minor);
341                 _fail(file, line);
342         }
343 }
344
345 /*
346  * Test helper to insert a transaction_id into a request.
347  */
348 static void add_transaction_id(struct ldb_request *req, const char *id)
349 {
350         struct GUID guid;
351         struct dsdb_control_transaction_identifier *transaction_id = NULL;
352
353         transaction_id = talloc_zero(
354                 req,
355                 struct dsdb_control_transaction_identifier);
356         assert_non_null(transaction_id);
357         GUID_from_string(id, &guid);
358         transaction_id->transaction_guid = guid;
359         ldb_request_add_control(
360                 req,
361                 DSDB_CONTROL_TRANSACTION_IDENTIFIER_OID,
362                 false,
363                 transaction_id);
364 }
365
366 /*
367  * Test helper to add a session id and user SID
368  */
369 static void add_session_data(
370         TALLOC_CTX *ctx,
371         struct ldb_context *ldb,
372         const char *session,
373         const char *user_sid)
374 {
375         struct auth_session_info *sess = NULL;
376         struct security_token *token = NULL;
377         struct dom_sid *sid = NULL;
378         struct GUID session_id;
379         bool ok;
380
381         sess = talloc_zero(ctx, struct auth_session_info);
382         token = talloc_zero(ctx, struct security_token);
383         sid = talloc_zero(ctx, struct dom_sid);
384         ok = string_to_sid(sid, user_sid);
385         assert_true(ok);
386         token->sids = sid;
387         sess->security_token = token;
388         GUID_from_string(session, &session_id);
389         sess->unique_session_token = session_id;
390         ldb_set_opaque(ldb, DSDB_SESSION_INFO, sess);
391 }
392
393 static void test_get_transaction_id(void **state)
394 {
395         struct ldb_request *req = NULL;
396         struct GUID *guid;
397         const char * const ID = "7130cb06-2062-6a1b-409e-3514c26b1773";
398         char *guid_str = NULL;
399         struct GUID_txt_buf guid_buff;
400
401
402         TALLOC_CTX *ctx = talloc_new(NULL);
403
404
405         /*
406          * No transaction id, should return a zero guid
407          */
408         req = talloc_zero(ctx, struct ldb_request);
409         guid = get_transaction_id(req);
410         assert_null(guid);
411         TALLOC_FREE(req);
412
413         /*
414          * And now test with the transaction_id set
415          */
416         req = talloc_zero(ctx, struct ldb_request);
417         assert_non_null(req);
418         add_transaction_id(req, ID);
419
420         guid = get_transaction_id(req);
421         guid_str = GUID_buf_string(guid, &guid_buff);
422         assert_string_equal(ID, guid_str);
423         TALLOC_FREE(req);
424
425         TALLOC_FREE(ctx);
426 }
427
428 static void test_audit_group_hr(void **state)
429 {
430         struct ldb_context *ldb = NULL;
431         struct ldb_module  *module = NULL;
432         struct ldb_request *req = NULL;
433
434         struct tsocket_address *ts = NULL;
435
436         const char *const SID = "S-1-5-21-2470180966-3899876309-2637894779";
437         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
438
439         struct GUID transaction_id;
440         const char *const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
441
442
443         char *line = NULL;
444         const char *rs = NULL;
445         regex_t regex;
446         int ret;
447
448
449         TALLOC_CTX *ctx = talloc_new(NULL);
450
451         ldb = ldb_init(ctx, NULL);
452
453         GUID_from_string(TRANSACTION, &transaction_id);
454
455         module = talloc_zero(ctx, struct ldb_module);
456         module->ldb = ldb;
457
458         tsocket_address_inet_from_strings(ctx, "ip", "127.0.0.1", 0, &ts);
459         ldb_set_opaque(ldb, "remoteAddress", ts);
460
461         add_session_data(ctx, ldb, SESSION, SID);
462
463         req = talloc_zero(ctx, struct ldb_request);
464         req->operation =  LDB_ADD;
465         add_transaction_id(req, TRANSACTION);
466
467         line = audit_group_human_readable(
468                 ctx,
469                 module,
470                 req,
471                 "the-action",
472                 "the-user-name",
473                 "the-group-name",
474                 LDB_ERR_OPERATIONS_ERROR);
475         assert_non_null(line);
476
477         rs =    "\\[the-action\\] at \\["
478                 "[^]]*"
479                 "\\] status \\[Operations error\\] "
480                 "Remote host \\[ipv4:127.0.0.1:0\\] "
481                 "SID \\[S-1-5-21-2470180966-3899876309-2637894779\\] "
482                 "Group \\[the-group-name\\] "
483                 "User \\[the-user-name\\]";
484
485         ret = regcomp(&regex, rs, 0);
486         assert_int_equal(0, ret);
487
488         ret = regexec(&regex, line, 0, NULL, 0);
489         assert_int_equal(0, ret);
490
491         regfree(&regex);
492         TALLOC_FREE(ctx);
493
494 }
495
496 /*
497  * test get_parsed_dns
498  * For this test we assume Valgrind or Address Sanitizer will detect any over
499  * runs. Also we don't care that the values are DN's only that the value in the
500  * element is copied to the parsed_dns.
501  */
502 static void test_get_parsed_dns(void **state)
503 {
504         struct ldb_message_element *el = NULL;
505         struct parsed_dn *dns = NULL;
506
507         TALLOC_CTX *ctx = talloc_new(NULL);
508
509         el = talloc_zero(ctx, struct ldb_message_element);
510
511         /*
512          * empty element, zero dns
513          */
514         dns = get_parsed_dns(ctx, el);
515         assert_null(dns);
516
517         /*
518          * one entry
519          */
520         el->num_values = 1;
521         el->values = talloc_zero_array(ctx, DATA_BLOB, 1);
522         el->values[0] = data_blob_string_const("The first value");
523
524         dns = get_parsed_dns(ctx, el);
525
526         assert_ptr_equal(el->values[0].data, dns[0].v->data);
527         assert_int_equal(el->values[0].length, dns[0].v->length);
528
529         TALLOC_FREE(dns);
530         TALLOC_FREE(el);
531
532
533         /*
534          * Multiple values
535          */
536         el = talloc_zero(ctx, struct ldb_message_element);
537         el->num_values = 2;
538         el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
539         el->values[0] = data_blob_string_const("The first value");
540         el->values[0] = data_blob_string_const("The second value");
541
542         dns = get_parsed_dns(ctx, el);
543
544         assert_ptr_equal(el->values[0].data, dns[0].v->data);
545         assert_int_equal(el->values[0].length, dns[0].v->length);
546
547         assert_ptr_equal(el->values[1].data, dns[1].v->data);
548         assert_int_equal(el->values[1].length, dns[1].v->length);
549
550         TALLOC_FREE(ctx);
551 }
552
553 static void test_dn_compare(void **state)
554 {
555
556         struct ldb_context *ldb = NULL;
557         struct parsed_dn *a;
558         DATA_BLOB ab;
559
560         struct parsed_dn *b;
561         DATA_BLOB bb;
562
563         int res;
564
565         TALLOC_CTX *ctx = talloc_new(NULL);
566         const struct GUID *ZERO_GUID = talloc_zero(ctx, struct GUID);
567
568         ldb = ldb_init(ctx, NULL);
569         ldb_register_samba_handlers(ldb);
570
571
572         /*
573          * Identical binary DN's
574          */
575         ab = data_blob_string_const(
576                 "<GUID=fbee08fd-6f75-4bd4-af3f-e4f063a6379e>;"
577                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
578         a = talloc_zero(ctx, struct parsed_dn);
579         a->v = &ab;
580
581         bb = data_blob_string_const(
582                 "<GUID=fbee08fd-6f75-4bd4-af3f-e4f063a6379e>;"
583                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
584         b = talloc_zero(ctx, struct parsed_dn);
585         b->v = &bb;
586
587         res = dn_compare(ctx, ldb, a, b);
588         assert_int_equal(BINARY_EQUAL, res);
589         /*
590          * DN's should not have been parsed
591          */
592         assert_null(a->dsdb_dn);
593         assert_memory_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
594         assert_null(b->dsdb_dn);
595         assert_memory_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
596
597         TALLOC_FREE(a);
598         TALLOC_FREE(b);
599
600         /*
601          * differing binary DN's but equal GUID's
602          */
603         ab = data_blob_string_const(
604                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651e>;"
605                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=com");
606         a = talloc_zero(ctx, struct parsed_dn);
607         a->v = &ab;
608
609         bb = data_blob_string_const(
610                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651e>;"
611                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
612         b = talloc_zero(ctx, struct parsed_dn);
613         b->v = &bb;
614
615         res = dn_compare(ctx, ldb, a, b);
616         assert_int_equal(EQUAL, res);
617         /*
618          * DN's should have been parsed
619          */
620         assert_non_null(a->dsdb_dn);
621         assert_memory_not_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
622         assert_non_null(b->dsdb_dn);
623         assert_memory_not_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
624
625         TALLOC_FREE(a);
626         TALLOC_FREE(b);
627
628         /*
629          * differing binary DN's but and second guid greater
630          */
631         ab = data_blob_string_const(
632                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651d>;"
633                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=com");
634         a = talloc_zero(ctx, struct parsed_dn);
635         a->v = &ab;
636
637         bb = data_blob_string_const(
638                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651e>;"
639                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
640         b = talloc_zero(ctx, struct parsed_dn);
641         b->v = &bb;
642
643         res = dn_compare(ctx, ldb, a, b);
644         assert_int_equal(LESS_THAN, res);
645         /*
646          * DN's should have been parsed
647          */
648         assert_non_null(a->dsdb_dn);
649         assert_memory_not_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
650         assert_non_null(b->dsdb_dn);
651         assert_memory_not_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
652
653         TALLOC_FREE(a);
654         TALLOC_FREE(b);
655
656         /*
657          * differing binary DN's but and second guid less
658          */
659         ab = data_blob_string_const(
660                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651d>;"
661                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=com");
662         a = talloc_zero(ctx, struct parsed_dn);
663         a->v = &ab;
664
665         bb = data_blob_string_const(
666                 "<GUID=efdc91e5-5a5a-493e-9606-166ed0c2651c>;"
667                 "OU=Domain Controllers,DC=ad,DC=testing,DC=samba,DC=org");
668         b = talloc_zero(ctx, struct parsed_dn);
669         b->v = &bb;
670
671         res = dn_compare(ctx, ldb, a, b);
672         assert_int_equal(GREATER_THAN, res);
673         /*
674          * DN's should have been parsed
675          */
676         assert_non_null(a->dsdb_dn);
677         assert_memory_not_equal(ZERO_GUID, &a->guid, sizeof(struct GUID));
678         assert_non_null(b->dsdb_dn);
679         assert_memory_not_equal(ZERO_GUID, &b->guid, sizeof(struct GUID));
680
681         TALLOC_FREE(a);
682         TALLOC_FREE(b);
683
684         TALLOC_FREE(ctx);
685 }
686
687 static void test_get_primary_group_dn(void **state)
688 {
689
690         struct ldb_context *ldb = NULL;
691         struct ldb_module *module = NULL;
692         const uint32_t RID = 71;
693         struct dom_sid sid;
694         const char *SID = "S-1-5-21-2470180966-3899876309-2637894779";
695         const char *DN = "OU=Things,DC=ad,DC=testing,DC=samba,DC=org";
696         const char *dn;
697
698         TALLOC_CTX *ctx = talloc_new(NULL);
699
700         ldb = ldb_init(ctx, NULL);
701         ldb_register_samba_handlers(ldb);
702
703         module = talloc_zero(ctx, struct ldb_module);
704         module->ldb = ldb;
705
706         /*
707          * Pass an empty dom sid this will cause dom_sid_split_rid to fail;
708          * assign to sid.num_auths to suppress a valgrind warning.
709          */
710         sid.num_auths = 0;
711         dn = get_primary_group_dn(ctx, module, &sid, RID);
712         assert_null(dn);
713
714         /*
715          * A valid dom sid
716          */
717         assert_true(string_to_sid(&sid, SID));
718         g_dn = DN;
719         dn = get_primary_group_dn(ctx, module, &sid, RID);
720         assert_non_null(dn);
721         assert_string_equal(DN, dn);
722         assert_int_equal(LDB_SCOPE_BASE, g_scope);
723         assert_int_equal(0, g_dsdb_flags);
724         assert_null(g_attrs);
725         assert_null(g_exp_fmt);
726         assert_string_equal
727                 ("<SID=S-1-5-21-2470180966-3899876309-71>",
728                 ldb_dn_get_extended_linearized(ctx, g_basedn, 1));
729
730         /*
731          * Test dsdb search failure
732          */
733         g_status = LDB_ERR_NO_SUCH_OBJECT;
734         dn = get_primary_group_dn(ctx, module, &sid, RID);
735         assert_null(dn);
736
737         TALLOC_FREE(ldb);
738         TALLOC_FREE(ctx);
739 }
740
741 static void test_audit_group_json(void **state)
742 {
743         struct ldb_context *ldb = NULL;
744         struct ldb_module  *module = NULL;
745         struct ldb_request *req = NULL;
746
747         struct tsocket_address *ts = NULL;
748
749         const char *const SID = "S-1-5-21-2470180966-3899876309-2637894779";
750         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
751
752         struct GUID transaction_id;
753         const char *const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
754
755
756         struct json_object json;
757         json_t *audit = NULL;
758         json_t *v = NULL;
759         json_t *o = NULL;
760         time_t before;
761
762
763         TALLOC_CTX *ctx = talloc_new(NULL);
764
765         ldb = ldb_init(ctx, NULL);
766
767         GUID_from_string(TRANSACTION, &transaction_id);
768
769         module = talloc_zero(ctx, struct ldb_module);
770         module->ldb = ldb;
771
772         tsocket_address_inet_from_strings(ctx, "ip", "127.0.0.1", 0, &ts);
773         ldb_set_opaque(ldb, "remoteAddress", ts);
774
775         add_session_data(ctx, ldb, SESSION, SID);
776
777         req = talloc_zero(ctx, struct ldb_request);
778         req->operation =  LDB_ADD;
779         add_transaction_id(req, TRANSACTION);
780
781         before = time(NULL);
782         json = audit_group_json(
783                 module,
784                 req,
785                 "the-action",
786                 "the-user-name",
787                 "the-group-name",
788                 LDB_ERR_OPERATIONS_ERROR);
789         assert_int_equal(3, json_object_size(json.root));
790
791         v = json_object_get(json.root, "type");
792         assert_non_null(v);
793         assert_string_equal("groupChange", json_string_value(v));
794
795         v = json_object_get(json.root, "timestamp");
796         assert_non_null(v);
797         assert_true(json_is_string(v));
798         check_timestamp(before, json_string_value(v));
799
800         audit = json_object_get(json.root, "groupChange");
801         assert_non_null(audit);
802         assert_true(json_is_object(audit));
803         assert_int_equal(10, json_object_size(audit));
804
805         o = json_object_get(audit, "version");
806         assert_non_null(o);
807         check_version(o, AUDIT_MAJOR, AUDIT_MINOR);
808
809         v = json_object_get(audit, "statusCode");
810         assert_non_null(v);
811         assert_true(json_is_integer(v));
812         assert_int_equal(LDB_ERR_OPERATIONS_ERROR, json_integer_value(v));
813
814         v = json_object_get(audit, "status");
815         assert_non_null(v);
816         assert_true(json_is_string(v));
817         assert_string_equal("Operations error", json_string_value(v));
818
819         v = json_object_get(audit, "user");
820         assert_non_null(v);
821         assert_true(json_is_string(v));
822         assert_string_equal("the-user-name", json_string_value(v));
823
824         v = json_object_get(audit, "group");
825         assert_non_null(v);
826         assert_true(json_is_string(v));
827         assert_string_equal("the-group-name", json_string_value(v));
828
829         v = json_object_get(audit, "action");
830         assert_non_null(v);
831         assert_true(json_is_string(v));
832         assert_string_equal("the-action", json_string_value(v));
833
834         json_free(&json);
835         TALLOC_FREE(ctx);
836 }
837
838 static void setup_ldb(
839         TALLOC_CTX *ctx,
840         struct ldb_context **ldb,
841         struct ldb_module **module,
842         const char *ip,
843         const char *session,
844         const char *sid)
845 {
846         struct tsocket_address *ts = NULL;
847         struct audit_context *context = NULL;
848
849         *ldb = ldb_init(ctx, NULL);
850         ldb_register_samba_handlers(*ldb);
851
852
853         *module = talloc_zero(ctx, struct ldb_module);
854         (*module)->ldb = *ldb;
855
856         context = talloc_zero(*module, struct audit_context);
857         context->send_events = true;
858         context->msg_ctx = (struct imessaging_context *) 0x01;
859
860         ldb_module_set_private(*module, context);
861
862         tsocket_address_inet_from_strings(ctx, "ip", "127.0.0.1", 0, &ts);
863         ldb_set_opaque(*ldb, "remoteAddress", ts);
864
865         add_session_data(ctx, *ldb, session, sid);
866 }
867
868 /*
869  * Test the removal of a user from a group.
870  *
871  * The new element contains one group member
872  * The old element contains two group member
873  *
874  * Expect to see the removed entry logged.
875  *
876  * This test confirms bug 13664
877  * https://bugzilla.samba.org/show_bug.cgi?id=13664
878  */
879 static void test_log_membership_changes_removed(void **state)
880 {
881         struct ldb_context *ldb = NULL;
882         struct ldb_module  *module = NULL;
883         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
884         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
885         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
886         const char * const IP = "127.0.0.1";
887         struct ldb_request *req = NULL;
888         struct ldb_message_element *new_el = NULL;
889         struct ldb_message_element *old_el = NULL;
890         int status = 0;
891         TALLOC_CTX *ctx = talloc_new(NULL);
892
893         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
894
895         /*
896          * Build the ldb_request
897          */
898         req = talloc_zero(ctx, struct ldb_request);
899         req->operation =  LDB_ADD;
900         add_transaction_id(req, TRANSACTION);
901
902         /*
903          * Populate the new elements, containing one entry.
904          * Indicating that one element has been removed
905          */
906         new_el = talloc_zero(ctx, struct ldb_message_element);
907         new_el->num_values = 1;
908         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 1);
909         new_el->values[0] = data_blob_string_const(
910                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
911                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
912                 "DC=example,DC=com");
913
914         /*
915          * Populate the old elements, with two elements
916          * The first is the same as the one in new elements.
917          */
918         old_el = talloc_zero(ctx, struct ldb_message_element);
919         old_el->num_values = 2;
920         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
921         old_el->values[0] = data_blob_string_const(
922                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
923                 "cn=grpadttstuser01,cn=users,DC=addom,"
924                 "DC=samba,DC=example,DC=com");
925         old_el->values[1] = data_blob_string_const(
926                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
927                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
928                 "DC=example,DC=com");
929
930         /*
931          * call log_membership_changes
932          */
933         messages_sent = 0;
934         log_membership_changes(module, req, new_el, old_el, status);
935
936         /*
937          * Check the results
938          */
939         assert_int_equal(1, messages_sent);
940
941         check_group_change_message(
942             0,
943             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
944             "Removed");
945
946         /*
947          * Clean up
948          */
949         json_free(&messages[0]);
950         TALLOC_FREE(ctx);
951 }
952
953 /* test log_membership_changes
954  *
955  * old contains 2 user dn's
956  * new contains 0 user dn's
957  *
958  * Expect to see both dn's logged as deleted.
959  */
960 static void test_log_membership_changes_remove_all(void **state)
961 {
962         struct ldb_context *ldb = NULL;
963         struct ldb_module  *module = NULL;
964         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
965         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
966         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
967         const char * const IP = "127.0.0.1";
968         struct ldb_request *req = NULL;
969         struct ldb_message_element *new_el = NULL;
970         struct ldb_message_element *old_el = NULL;
971         int status = 0;
972         TALLOC_CTX *ctx = talloc_new(NULL);
973
974         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
975
976         /*
977          * Build the ldb_request
978          */
979         req = talloc_zero(ctx, struct ldb_request);
980         req->operation =  LDB_ADD;
981         add_transaction_id(req, TRANSACTION);
982
983         /*
984          * Populate the new elements, containing no entries.
985          * Indicating that all elements have been removed
986          */
987         new_el = talloc_zero(ctx, struct ldb_message_element);
988         new_el->num_values = 0;
989         new_el->values = NULL;
990
991         /*
992          * Populate the old elements, with two elements
993          */
994         old_el = talloc_zero(ctx, struct ldb_message_element);
995         old_el->num_values = 2;
996         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
997         old_el->values[0] = data_blob_string_const(
998                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
999                 "cn=grpadttstuser01,cn=users,DC=addom,"
1000                 "DC=samba,DC=example,DC=com");
1001         old_el->values[1] = data_blob_string_const(
1002                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1003                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1004                 "DC=example,DC=com");
1005
1006         /*
1007          * call log_membership_changes
1008          */
1009         messages_sent = 0;
1010         log_membership_changes( module, req, new_el, old_el, status);
1011
1012         /*
1013          * Check the results
1014          */
1015         assert_int_equal(2, messages_sent);
1016
1017         check_group_change_message(
1018             0,
1019             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1020             "Removed");
1021
1022         check_group_change_message(
1023             1,
1024             "CN=testuser131953,CN=Users,DC=addom,DC=samba,DC=example,DC=com",
1025             "Removed");
1026
1027         /*
1028          * Clean up
1029          */
1030         json_free(&messages[0]);
1031         json_free(&messages[1]);
1032         TALLOC_FREE(ctx);
1033 }
1034
1035 /* test log_membership_changes
1036  *
1037  * Add an entry.
1038  *
1039  * Old entries contains a single user dn
1040  * New entries contains 2 user dn's, one matching the dn in old entries
1041  *
1042  * Should see a single new entry logged.
1043  */
1044 static void test_log_membership_changes_added(void **state)
1045 {
1046         struct ldb_context *ldb = NULL;
1047         struct ldb_module  *module = NULL;
1048         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
1049         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1050         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1051         const char * const IP = "127.0.0.1";
1052         struct ldb_request *req = NULL;
1053         struct ldb_message_element *new_el = NULL;
1054         struct ldb_message_element *old_el = NULL;
1055         int status = 0;
1056         TALLOC_CTX *ctx = talloc_new(NULL);
1057
1058         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
1059
1060         /*
1061          * Build the ldb_request
1062          */
1063         req = talloc_zero(ctx, struct ldb_request);
1064         req->operation =  LDB_ADD;
1065         add_transaction_id(req, TRANSACTION);
1066
1067         /*
1068          * Populate the old elements adding a single entry.
1069          */
1070         old_el = talloc_zero(ctx, struct ldb_message_element);
1071         old_el->num_values = 1;
1072         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 1);
1073         old_el->values[0] = data_blob_string_const(
1074                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1075                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1076                 "DC=example,DC=com");
1077
1078         /*
1079          * Populate the new elements adding two entries. One matches the entry
1080          * in old elements. We expect to see the other element logged as Added
1081          */
1082         new_el = talloc_zero(ctx, struct ldb_message_element);
1083         new_el->num_values = 2;
1084         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
1085         new_el->values[0] = data_blob_string_const(
1086                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1087                 "cn=grpadttstuser01,cn=users,DC=addom,"
1088                 "DC=samba,DC=example,DC=com");
1089         new_el->values[1] = data_blob_string_const(
1090                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1091                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1092                 "DC=example,DC=com");
1093
1094         /*
1095          * call log_membership_changes
1096          */
1097         messages_sent = 0;
1098         log_membership_changes( module, req, new_el, old_el, status);
1099
1100         /*
1101          * Check the results
1102          */
1103         assert_int_equal(1, messages_sent);
1104
1105         check_group_change_message(
1106             0,
1107             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1108             "Added");
1109
1110         /*
1111          * Clean up
1112          */
1113         json_free(&messages[0]);
1114         TALLOC_FREE(ctx);
1115 }
1116
1117 /*
1118  * test log_membership_changes.
1119  *
1120  * Old entries is empty
1121  * New entries contains 2 user dn's
1122  *
1123  * Expect to see log messages for two added users
1124  */
1125 static void test_log_membership_changes_add_to_empty(void **state)
1126 {
1127         struct ldb_context *ldb = NULL;
1128         struct ldb_module  *module = NULL;
1129         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
1130         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1131         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1132         const char * const IP = "127.0.0.1";
1133         struct ldb_request *req = NULL;
1134         struct ldb_message_element *new_el = NULL;
1135         struct ldb_message_element *old_el = NULL;
1136         int status = 0;
1137         TALLOC_CTX *ctx = talloc_new(NULL);
1138
1139         /*
1140          * Set up the ldb and module structures
1141          */
1142         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
1143
1144         /*
1145          * Build the request structure
1146          */
1147         req = talloc_zero(ctx, struct ldb_request);
1148         req->operation =  LDB_ADD;
1149         add_transaction_id(req, TRANSACTION);
1150
1151         /*
1152          * Build the element containing the old values
1153          */
1154         old_el = talloc_zero(ctx, struct ldb_message_element);
1155         old_el->num_values = 0;
1156         old_el->values = NULL;
1157
1158         /*
1159          * Build the element containing the new values
1160          */
1161         new_el = talloc_zero(ctx, struct ldb_message_element);
1162         new_el->num_values = 2;
1163         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 2);
1164         new_el->values[0] = data_blob_string_const(
1165                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1166                 "cn=grpadttstuser01,cn=users,DC=addom,"
1167                 "DC=samba,DC=example,DC=com");
1168         new_el->values[1] = data_blob_string_const(
1169                 "<GUID=081519b5-a709-44a0-bc95-dd4bfe809bf8>;"
1170                 "CN=testuser131953,CN=Users,DC=addom,DC=samba,"
1171                 "DC=example,DC=com");
1172
1173         /*
1174          * Run log membership changes
1175          */
1176         messages_sent = 0;
1177         log_membership_changes( module, req, new_el, old_el, status);
1178         assert_int_equal(2, messages_sent);
1179
1180         check_group_change_message(
1181             0,
1182             "cn=grpadttstuser01,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1183             "Added");
1184
1185         check_group_change_message(
1186             1,
1187             "CN=testuser131953,CN=Users,DC=addom,DC=samba,DC=example,DC=com",
1188             "Added");
1189
1190         json_free(&messages[0]);
1191         json_free(&messages[1]);
1192         TALLOC_FREE(ctx);
1193 }
1194
1195 /* test log_membership_changes
1196  *
1197  * Test Replication Meta Data flag handling.
1198  *
1199  * 4 entries in old and new entries with their RMD_FLAGS set as below:
1200  *    old   new
1201  * 1)  0     0    Not logged
1202  * 2)  1     1    Both deleted, no change not logged
1203  * 3)  0     1    New tagged as deleted, log as deleted
1204  * 4)  1     0    Has been undeleted, log as an add
1205  *
1206  * Should see a single new entry logged.
1207  */
1208 static void test_log_membership_changes_rmd_flags(void **state)
1209 {
1210         struct ldb_context *ldb = NULL;
1211         struct ldb_module  *module = NULL;
1212         const char * const SID = "S-1-5-21-2470180966-3899876309-2637894779";
1213         const char * const SESSION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1214         const char * const TRANSACTION = "7130cb06-2062-6a1b-409e-3514c26b1773";
1215         const char * const IP = "127.0.0.1";
1216         struct ldb_request *req = NULL;
1217         struct ldb_message_element *new_el = NULL;
1218         struct ldb_message_element *old_el = NULL;
1219         int status = 0;
1220         TALLOC_CTX *ctx = talloc_new(NULL);
1221
1222         setup_ldb(ctx, &ldb, &module, IP, SESSION, SID);
1223
1224         /*
1225          * Build the ldb_request
1226          */
1227         req = talloc_zero(ctx, struct ldb_request);
1228         req->operation =  LDB_ADD;
1229         add_transaction_id(req, TRANSACTION);
1230
1231         /*
1232          * Populate the old elements.
1233          */
1234         old_el = talloc_zero(ctx, struct ldb_message_element);
1235         old_el->num_values = 4;
1236         old_el->values = talloc_zero_array(ctx, DATA_BLOB, 4);
1237         old_el->values[0] = data_blob_string_const(
1238                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1239                 "<RMD_FLAGS=0>;"
1240                 "cn=grpadttstuser01,cn=users,DC=addom,"
1241                 "DC=samba,DC=example,DC=com");
1242         old_el->values[1] = data_blob_string_const(
1243                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681c>;"
1244                 "<RMD_FLAGS=1>;"
1245                 "cn=grpadttstuser02,cn=users,DC=addom,"
1246                 "DC=samba,DC=example,DC=com");
1247         old_el->values[2] = data_blob_string_const(
1248                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681d>;"
1249                 "<RMD_FLAGS=0>;"
1250                 "cn=grpadttstuser03,cn=users,DC=addom,"
1251                 "DC=samba,DC=example,DC=com");
1252         old_el->values[3] = data_blob_string_const(
1253                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681e>;"
1254                 "<RMD_FLAGS=1>;"
1255                 "cn=grpadttstuser04,cn=users,DC=addom,"
1256                 "DC=samba,DC=example,DC=com");
1257
1258         /*
1259          * Populate the new elements.
1260          */
1261         new_el = talloc_zero(ctx, struct ldb_message_element);
1262         new_el->num_values = 4;
1263         new_el->values = talloc_zero_array(ctx, DATA_BLOB, 4);
1264         new_el->values[0] = data_blob_string_const(
1265                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681b>;"
1266                 "<RMD_FLAGS=0>;"
1267                 "cn=grpadttstuser01,cn=users,DC=addom,"
1268                 "DC=samba,DC=example,DC=com");
1269         new_el->values[1] = data_blob_string_const(
1270                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681c>;"
1271                 "<RMD_FLAGS=1>;"
1272                 "cn=grpadttstuser02,cn=users,DC=addom,"
1273                 "DC=samba,DC=example,DC=com");
1274         new_el->values[2] = data_blob_string_const(
1275                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681d>;"
1276                 "<RMD_FLAGS=1>;"
1277                 "cn=grpadttstuser03,cn=users,DC=addom,"
1278                 "DC=samba,DC=example,DC=com");
1279         new_el->values[3] = data_blob_string_const(
1280                 "<GUID=cb8c2777-dcf5-419c-ab57-f645dbdf681e>;"
1281                 "<RMD_FLAGS=0>;"
1282                 "cn=grpadttstuser04,cn=users,DC=addom,"
1283                 "DC=samba,DC=example,DC=com");
1284
1285         /*
1286          * call log_membership_changes
1287          */
1288         messages_sent = 0;
1289         log_membership_changes( module, req, new_el, old_el, status);
1290
1291         /*
1292          * Check the results
1293          */
1294         assert_int_equal(2, messages_sent);
1295
1296         check_group_change_message(
1297             0,
1298             "cn=grpadttstuser03,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1299             "Removed");
1300         check_group_change_message(
1301             1,
1302             "cn=grpadttstuser04,cn=users,DC=addom,DC=samba,DC=example,DC=com",
1303             "Added");
1304
1305         /*
1306          * Clean up
1307          */
1308         json_free(&messages[0]);
1309         json_free(&messages[1]);
1310         TALLOC_FREE(ctx);
1311 }
1312
1313 /*
1314  * Note: to run under valgrind us:
1315  *       valgrind --suppressions=test_group_audit.valgrind bin/test_group_audit
1316  *       This suppresses the errors generated because the ldb_modules are not
1317  *       de-registered.
1318  *
1319  */
1320 int main(void) {
1321         const struct CMUnitTest tests[] = {
1322                 cmocka_unit_test(test_audit_group_json),
1323                 cmocka_unit_test(test_get_transaction_id),
1324                 cmocka_unit_test(test_audit_group_hr),
1325                 cmocka_unit_test(test_get_parsed_dns),
1326                 cmocka_unit_test(test_dn_compare),
1327                 cmocka_unit_test(test_get_primary_group_dn),
1328                 cmocka_unit_test(test_log_membership_changes_removed),
1329                 cmocka_unit_test(test_log_membership_changes_remove_all),
1330                 cmocka_unit_test(test_log_membership_changes_added),
1331                 cmocka_unit_test(test_log_membership_changes_add_to_empty),
1332                 cmocka_unit_test(test_log_membership_changes_rmd_flags),
1333         };
1334
1335         cmocka_set_message_output(CM_OUTPUT_SUBUNIT);
1336         return cmocka_run_group_tests(tests, NULL, NULL);
1337 }