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