source4/torture/rpc/netlogon.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    test suite for netlogon rpc operations
   5
   6    Copyright (C) Andrew Tridgell 2003
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2003-2004
   8    Copyright (C) Tim Potter      2003
   9    Copyright (C) Matthias Dieter Wallnöfer            2009-2010
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "lib/events/events.h"
  27 #include "lib/cmdline/popt_common.h"
  28 #include "torture/rpc/torture_rpc.h"
  29 #include "../lib/crypto/crypto.h"
  30 #include "libcli/auth/libcli_auth.h"
  31 #include "librpc/gen_ndr/ndr_netlogon_c.h"
  32 #include "librpc/gen_ndr/ndr_lsa_c.h"
  33 #include "param/param.h"
  34 #include "libcli/security/security.h"
  35 #include <ldb.h>
  36 #include "lib/util/util_ldb.h"
  37 #include "ldb_wrap.h"
  38 #include "lib/replace/system/network.h"
  39 #include "dsdb/samdb/samdb.h"
  40
  41 #define TEST_MACHINE_NAME "torturetest"
  42
  43 static bool test_netr_broken_binding_handle(struct torture_context *tctx,
  44                                             struct dcerpc_pipe *p)
  45 {
  46         NTSTATUS status;
  47         struct netr_DsRGetSiteName r;
  48         const char *site = NULL;
  49         struct dcerpc_binding_handle *b = p->binding_handle;
  50
  51         r.in.computer_name      = talloc_asprintf(tctx, "\\\\%s",
  52                                                   dcerpc_server_name(p));
  53         r.out.site              = &site;
  54
  55         torture_comment(tctx,
  56                         "Testing netlogon request with correct binding handle: %s\n",
  57                         r.in.computer_name);
  58
  59         status = dcerpc_netr_DsRGetSiteName_r(b, tctx, &r);
  60         torture_assert_ntstatus_ok(tctx, status,
  61                                    "Netlogon request with broken binding handle");
  62         torture_assert_werr_ok(tctx, r.out.result,
  63                                "Netlogon request with broken binding handle");
  64
  65         if (torture_setting_bool(tctx, "samba3", false) ||
  66             torture_setting_bool(tctx, "samba4", false)) {
  67                 torture_skip(tctx,
  68                              "Skipping broken binding handle check against Samba");
  69         }
  70
  71         r.in.computer_name      = talloc_asprintf(tctx, "\\\\\\\\%s",
  72                                                   dcerpc_server_name(p));
  73
  74         torture_comment(tctx,
  75                         "Testing netlogon request with broken binding handle: %s\n",
  76                         r.in.computer_name);
  77
  78         status = dcerpc_netr_DsRGetSiteName_r(b, tctx, &r);
  79         torture_assert_ntstatus_ok(tctx, status,
  80                                    "Netlogon request with broken binding handle");
  81         torture_assert_werr_equal(tctx, r.out.result,
  82                                   WERR_INVALID_COMPUTERNAME,
  83                                   "Netlogon request with broken binding handle");
  84
  85         r.in.computer_name      = "\\\\\\\\THIS_IS_NOT_VALID";
  86
  87         torture_comment(tctx,
  88                         "Testing netlogon request with broken binding handle: %s\n",
  89                         r.in.computer_name);
  90
  91         status = dcerpc_netr_DsRGetSiteName_r(b, tctx, &r);
  92         torture_assert_ntstatus_ok(tctx, status,
  93                                    "Netlogon request with broken binding handle");
  94         torture_assert_werr_equal(tctx, r.out.result,
  95                                   WERR_INVALID_COMPUTERNAME,
  96                                   "Netlogon request with broken binding handle");
  97
  98         return true;
  99 }
 100
 101 static bool test_LogonUasLogon(struct torture_context *tctx,
 102                                struct dcerpc_pipe *p)
 103 {
 104         NTSTATUS status;
 105         struct netr_LogonUasLogon r;
 106         struct netr_UasInfo *info = NULL;
 107         struct dcerpc_binding_handle *b = p->binding_handle;
 108
 109         r.in.server_name = NULL;
 110         r.in.account_name = cli_credentials_get_username(cmdline_credentials);
 111         r.in.workstation = TEST_MACHINE_NAME;
 112         r.out.info = &info;
 113
 114         status = dcerpc_netr_LogonUasLogon_r(b, tctx, &r);
 115         torture_assert_ntstatus_ok(tctx, status, "LogonUasLogon");
 116
 117         return true;
 118 }
 119
 120 static bool test_LogonUasLogoff(struct torture_context *tctx,
 121                                 struct dcerpc_pipe *p)
 122 {
 123         NTSTATUS status;
 124         struct netr_LogonUasLogoff r;
 125         struct netr_UasLogoffInfo info;
 126         struct dcerpc_binding_handle *b = p->binding_handle;
 127
 128         r.in.server_name = NULL;
 129         r.in.account_name = cli_credentials_get_username(cmdline_credentials);
 130         r.in.workstation = TEST_MACHINE_NAME;
 131         r.out.info = &info;
 132
 133         status = dcerpc_netr_LogonUasLogoff_r(b, tctx, &r);
 134         torture_assert_ntstatus_ok(tctx, status, "LogonUasLogoff");
 135
 136         return true;
 137 }
 138
 139 bool test_SetupCredentials(struct dcerpc_pipe *p, struct torture_context *tctx,
 140                                   struct cli_credentials *credentials,
 141                                   struct netlogon_creds_CredentialState **creds_out)
 142 {
 143         struct netr_ServerReqChallenge r;
 144         struct netr_ServerAuthenticate a;
 145         struct netr_Credential credentials1, credentials2, credentials3;
 146         struct netlogon_creds_CredentialState *creds;
 147         const struct samr_Password *mach_password;
 148         const char *machine_name;
 149         struct dcerpc_binding_handle *b = p->binding_handle;
 150
 151         mach_password = cli_credentials_get_nt_hash(credentials, tctx);
 152         machine_name = cli_credentials_get_workstation(credentials);
 153
 154         torture_comment(tctx, "Testing ServerReqChallenge\n");
 155
 156         r.in.server_name = NULL;
 157         r.in.computer_name = machine_name;
 158         r.in.credentials = &credentials1;
 159         r.out.return_credentials = &credentials2;
 160
 161         generate_random_buffer(credentials1.data, sizeof(credentials1.data));
 162
 163         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerReqChallenge_r(b, tctx, &r),
 164                 "ServerReqChallenge failed");
 165         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerReqChallenge failed");
 166
 167         a.in.server_name = NULL;
 168         a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
 169         a.in.secure_channel_type = cli_credentials_get_secure_channel_type(credentials);
 170         a.in.computer_name = machine_name;
 171         a.in.credentials = &credentials3;
 172         a.out.return_credentials = &credentials3;
 173
 174         creds = netlogon_creds_client_init(tctx, a.in.account_name,
 175                                            a.in.computer_name,
 176                                            &credentials1, &credentials2,
 177                                            mach_password, &credentials3,
 178                                            0);
 179         torture_assert(tctx, creds != NULL, "memory allocation");
 180
 181
 182         torture_comment(tctx, "Testing ServerAuthenticate\n");
 183
 184         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerAuthenticate_r(b, tctx, &a),
 185                 "ServerAuthenticate failed");
 186
 187         /* This allows the tests to continue against the more fussy windows 2008 */
 188         if (NT_STATUS_EQUAL(a.out.result, NT_STATUS_DOWNGRADE_DETECTED)) {
 189                 return test_SetupCredentials2(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
 190                                               credentials,
 191                                               cli_credentials_get_secure_channel_type(credentials),
 192                                               creds_out);
 193         }
 194
 195         torture_assert_ntstatus_ok(tctx, a.out.result, "ServerAuthenticate");
 196
 197         torture_assert(tctx, netlogon_creds_client_check(creds, &credentials3),
 198                        "Credential chaining failed");
 199
 200         *creds_out = creds;
 201         return true;
 202 }
 203
 204 bool test_SetupCredentials2(struct dcerpc_pipe *p, struct torture_context *tctx,
 205                             uint32_t negotiate_flags,
 206                             struct cli_credentials *machine_credentials,
 207                             enum netr_SchannelType sec_chan_type,
 208                             struct netlogon_creds_CredentialState **creds_out)
 209 {
 210         struct netr_ServerReqChallenge r;
 211         struct netr_ServerAuthenticate2 a;
 212         struct netr_Credential credentials1, credentials2, credentials3;
 213         struct netlogon_creds_CredentialState *creds;
 214         const struct samr_Password *mach_password;
 215         const char *machine_name;
 216         struct dcerpc_binding_handle *b = p->binding_handle;
 217
 218         mach_password = cli_credentials_get_nt_hash(machine_credentials, tctx);
 219         machine_name = cli_credentials_get_workstation(machine_credentials);
 220
 221         torture_comment(tctx, "Testing ServerReqChallenge\n");
 222
 223
 224         r.in.server_name = NULL;
 225         r.in.computer_name = machine_name;
 226         r.in.credentials = &credentials1;
 227         r.out.return_credentials = &credentials2;
 228
 229         generate_random_buffer(credentials1.data, sizeof(credentials1.data));
 230
 231         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerReqChallenge_r(b, tctx, &r),
 232                 "ServerReqChallenge failed");
 233         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerReqChallenge failed");
 234
 235         a.in.server_name = NULL;
 236         a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
 237         a.in.secure_channel_type = sec_chan_type;
 238         a.in.computer_name = machine_name;
 239         a.in.negotiate_flags = &negotiate_flags;
 240         a.out.negotiate_flags = &negotiate_flags;
 241         a.in.credentials = &credentials3;
 242         a.out.return_credentials = &credentials3;
 243
 244         creds = netlogon_creds_client_init(tctx, a.in.account_name,
 245                                            a.in.computer_name,
 246                                            &credentials1, &credentials2,
 247                                            mach_password, &credentials3,
 248                                            negotiate_flags);
 249
 250         torture_assert(tctx, creds != NULL, "memory allocation");
 251
 252         torture_comment(tctx, "Testing ServerAuthenticate2\n");
 253
 254         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerAuthenticate2_r(b, tctx, &a),
 255                 "ServerAuthenticate2 failed");
 256         torture_assert_ntstatus_ok(tctx, a.out.result, "ServerAuthenticate2 failed");
 257
 258         torture_assert(tctx, netlogon_creds_client_check(creds, &credentials3),
 259                 "Credential chaining failed");
 260
 261         torture_comment(tctx, "negotiate_flags=0x%08x\n", negotiate_flags);
 262
 263         *creds_out = creds;
 264         return true;
 265 }
 266
 267
 268 bool test_SetupCredentials3(struct dcerpc_pipe *p, struct torture_context *tctx,
 269                             uint32_t negotiate_flags,
 270                             struct cli_credentials *machine_credentials,
 271                             struct netlogon_creds_CredentialState **creds_out)
 272 {
 273         struct netr_ServerReqChallenge r;
 274         struct netr_ServerAuthenticate3 a;
 275         struct netr_Credential credentials1, credentials2, credentials3;
 276         struct netlogon_creds_CredentialState *creds;
 277         struct samr_Password mach_password;
 278         uint32_t rid;
 279         const char *machine_name;
 280         const char *plain_pass;
 281         struct dcerpc_binding_handle *b = p->binding_handle;
 282
 283         machine_name = cli_credentials_get_workstation(machine_credentials);
 284         plain_pass = cli_credentials_get_password(machine_credentials);
 285
 286         torture_comment(tctx, "Testing ServerReqChallenge\n");
 287
 288         r.in.server_name = NULL;
 289         r.in.computer_name = machine_name;
 290         r.in.credentials = &credentials1;
 291         r.out.return_credentials = &credentials2;
 292
 293         generate_random_buffer(credentials1.data, sizeof(credentials1.data));
 294
 295         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerReqChallenge_r(b, tctx, &r),
 296                 "ServerReqChallenge failed");
 297         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerReqChallenge failed");
 298
 299         E_md4hash(plain_pass, mach_password.hash);
 300
 301         a.in.server_name = NULL;
 302         a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
 303         a.in.secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
 304         a.in.computer_name = machine_name;
 305         a.in.negotiate_flags = &negotiate_flags;
 306         a.in.credentials = &credentials3;
 307         a.out.return_credentials = &credentials3;
 308         a.out.negotiate_flags = &negotiate_flags;
 309         a.out.rid = &rid;
 310
 311         creds = netlogon_creds_client_init(tctx, a.in.account_name,
 312                                            a.in.computer_name,
 313                                            &credentials1, &credentials2,
 314                                            &mach_password, &credentials3,
 315                                            negotiate_flags);
 316
 317         torture_assert(tctx, creds != NULL, "memory allocation");
 318
 319         torture_comment(tctx, "Testing ServerAuthenticate3\n");
 320
 321         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerAuthenticate3_r(b, tctx, &a),
 322                 "ServerAuthenticate3 failed");
 323         torture_assert_ntstatus_ok(tctx, a.out.result, "ServerAuthenticate3 failed");
 324         torture_assert(tctx, netlogon_creds_client_check(creds, &credentials3), "Credential chaining failed");
 325
 326         torture_comment(tctx, "negotiate_flags=0x%08x\n", negotiate_flags);
 327
 328         /* Prove that requesting a challenge again won't break it */
 329         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerReqChallenge_r(b, tctx, &r),
 330                 "ServerReqChallenge failed");
 331         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerReqChallenge failed");
 332
 333         *creds_out = creds;
 334         return true;
 335 }
 336
 337 /*
 338   try a change password for our machine account
 339 */
 340 static bool test_SetPassword(struct torture_context *tctx,
 341                              struct dcerpc_pipe *p,
 342                              struct cli_credentials *machine_credentials)
 343 {
 344         struct netr_ServerPasswordSet r;
 345         const char *password;
 346         struct netlogon_creds_CredentialState *creds;
 347         struct netr_Authenticator credential, return_authenticator;
 348         struct samr_Password new_password;
 349         struct dcerpc_binding_handle *b = p->binding_handle;
 350
 351         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 352                 return false;
 353         }
 354
 355         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 356         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 357         r.in.secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
 358         r.in.computer_name = TEST_MACHINE_NAME;
 359         r.in.credential = &credential;
 360         r.in.new_password = &new_password;
 361         r.out.return_authenticator = &return_authenticator;
 362
 363         password = generate_random_password(tctx, 8, 255);
 364         E_md4hash(password, new_password.hash);
 365
 366         netlogon_creds_des_encrypt(creds, &new_password);
 367
 368         torture_comment(tctx, "Testing ServerPasswordSet on machine account\n");
 369         torture_comment(tctx, "Changing machine account password to '%s'\n",
 370                         password);
 371
 372         netlogon_creds_client_authenticator(creds, &credential);
 373
 374         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet_r(b, tctx, &r),
 375                 "ServerPasswordSet failed");
 376         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet failed");
 377
 378         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 379                 torture_comment(tctx, "Credential chaining failed\n");
 380         }
 381
 382         /* by changing the machine password twice we test the
 383            credentials chaining fully, and we verify that the server
 384            allows the password to be set to the same value twice in a
 385            row (match win2k3) */
 386         torture_comment(tctx,
 387                 "Testing a second ServerPasswordSet on machine account\n");
 388         torture_comment(tctx,
 389                 "Changing machine account password to '%s' (same as previous run)\n", password);
 390
 391         netlogon_creds_client_authenticator(creds, &credential);
 392
 393         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet_r(b, tctx, &r),
 394                 "ServerPasswordSet (2) failed");
 395         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet (2) failed");
 396
 397         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 398                 torture_comment(tctx, "Credential chaining failed\n");
 399         }
 400
 401         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 402
 403         torture_assert(tctx,
 404                 test_SetupCredentials(p, tctx, machine_credentials, &creds),
 405                 "ServerPasswordSet failed to actually change the password");
 406
 407         return true;
 408 }
 409
 410 /*
 411   try a change password for our machine account
 412 */
 413 static bool test_SetPassword_flags(struct torture_context *tctx,
 414                                    struct dcerpc_pipe *p,
 415                                    struct cli_credentials *machine_credentials,
 416                                    uint32_t negotiate_flags)
 417 {
 418         struct netr_ServerPasswordSet r;
 419         const char *password;
 420         struct netlogon_creds_CredentialState *creds;
 421         struct netr_Authenticator credential, return_authenticator;
 422         struct samr_Password new_password;
 423         struct dcerpc_binding_handle *b = p->binding_handle;
 424
 425         if (!test_SetupCredentials2(p, tctx, negotiate_flags,
 426                                     machine_credentials,
 427                                     cli_credentials_get_secure_channel_type(machine_credentials),
 428                                     &creds)) {
 429                 return false;
 430         }
 431
 432         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 433         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 434         r.in.secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
 435         r.in.computer_name = TEST_MACHINE_NAME;
 436         r.in.credential = &credential;
 437         r.in.new_password = &new_password;
 438         r.out.return_authenticator = &return_authenticator;
 439
 440         password = generate_random_password(tctx, 8, 255);
 441         E_md4hash(password, new_password.hash);
 442
 443         netlogon_creds_des_encrypt(creds, &new_password);
 444
 445         torture_comment(tctx, "Testing ServerPasswordSet on machine account\n");
 446         torture_comment(tctx, "Changing machine account password to '%s'\n",
 447                         password);
 448
 449         netlogon_creds_client_authenticator(creds, &credential);
 450
 451         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet_r(b, tctx, &r),
 452                 "ServerPasswordSet failed");
 453         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet failed");
 454
 455         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 456                 torture_comment(tctx, "Credential chaining failed\n");
 457         }
 458
 459         /* by changing the machine password twice we test the
 460            credentials chaining fully, and we verify that the server
 461            allows the password to be set to the same value twice in a
 462            row (match win2k3) */
 463         torture_comment(tctx,
 464                 "Testing a second ServerPasswordSet on machine account\n");
 465         torture_comment(tctx,
 466                 "Changing machine account password to '%s' (same as previous run)\n", password);
 467
 468         netlogon_creds_client_authenticator(creds, &credential);
 469
 470         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet_r(b, tctx, &r),
 471                 "ServerPasswordSet (2) failed");
 472         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet (2) failed");
 473
 474         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 475                 torture_comment(tctx, "Credential chaining failed\n");
 476         }
 477
 478         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 479
 480         torture_assert(tctx,
 481                 test_SetupCredentials(p, tctx, machine_credentials, &creds),
 482                 "ServerPasswordSet failed to actually change the password");
 483
 484         return true;
 485 }
 486
 487
 488 /*
 489   generate a random password for password change tests
 490 */
 491 static DATA_BLOB netlogon_very_rand_pass(TALLOC_CTX *mem_ctx, int len)
 492 {
 493         int i;
 494         DATA_BLOB password = data_blob_talloc(mem_ctx, NULL, len * 2 /* number of unicode chars */);
 495         generate_random_buffer(password.data, password.length);
 496
 497         for (i=0; i < len; i++) {
 498                 if (((uint16_t *)password.data)[i] == 0) {
 499                         ((uint16_t *)password.data)[i] = 1;
 500                 }
 501         }
 502
 503         return password;
 504 }
 505
 506 /*
 507   try a change password for our machine account
 508 */
 509 static bool test_SetPassword2_with_flags(struct torture_context *tctx,
 510                                          struct dcerpc_pipe *p,
 511                                          struct cli_credentials *machine_credentials,
 512                                          uint32_t flags)
 513 {
 514         struct netr_ServerPasswordSet2 r;
 515         const char *password;
 516         DATA_BLOB new_random_pass;
 517         struct netlogon_creds_CredentialState *creds;
 518         struct samr_CryptPassword password_buf;
 519         struct samr_Password nt_hash;
 520         struct netr_Authenticator credential, return_authenticator;
 521         struct netr_CryptPassword new_password;
 522         struct dcerpc_binding_handle *b = p->binding_handle;
 523
 524         if (!test_SetupCredentials2(p, tctx, flags, machine_credentials, cli_credentials_get_secure_channel_type(machine_credentials), &creds)) {
 525                 return false;
 526         }
 527
 528         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 529         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 530         r.in.secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
 531         r.in.computer_name = TEST_MACHINE_NAME;
 532         r.in.credential = &credential;
 533         r.in.new_password = &new_password;
 534         r.out.return_authenticator = &return_authenticator;
 535
 536         password = generate_random_password(tctx, 8, 255);
 537         encode_pw_buffer(password_buf.data, password, STR_UNICODE);
 538         netlogon_creds_arcfour_crypt(creds, password_buf.data, 516);
 539
 540         memcpy(new_password.data, password_buf.data, 512);
 541         new_password.length = IVAL(password_buf.data, 512);
 542
 543         torture_comment(tctx, "Testing ServerPasswordSet2 on machine account\n");
 544         torture_comment(tctx, "Changing machine account password to '%s'\n", password);
 545
 546         netlogon_creds_client_authenticator(creds, &credential);
 547
 548         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet2_r(b, tctx, &r),
 549                 "ServerPasswordSet2 failed");
 550         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet2 failed");
 551
 552         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 553                 torture_comment(tctx, "Credential chaining failed\n");
 554         }
 555
 556         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 557
 558         if (!torture_setting_bool(tctx, "dangerous", false)) {
 559                 torture_comment(tctx,
 560                         "Not testing ability to set password to '', enable dangerous tests to perform this test\n");
 561         } else {
 562                 /* by changing the machine password to ""
 563                  * we check if the server uses password restrictions
 564                  * for ServerPasswordSet2
 565                  * (win2k3 accepts "")
 566                  */
 567                 password = "";
 568                 encode_pw_buffer(password_buf.data, password, STR_UNICODE);
 569                 netlogon_creds_arcfour_crypt(creds, password_buf.data, 516);
 570
 571                 memcpy(new_password.data, password_buf.data, 512);
 572                 new_password.length = IVAL(password_buf.data, 512);
 573
 574                 torture_comment(tctx,
 575                         "Testing ServerPasswordSet2 on machine account\n");
 576                 torture_comment(tctx,
 577                         "Changing machine account password to '%s'\n", password);
 578
 579                 netlogon_creds_client_authenticator(creds, &credential);
 580
 581                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet2_r(b, tctx, &r),
 582                         "ServerPasswordSet2 failed");
 583                 torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet2 failed");
 584
 585                 if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 586                         torture_comment(tctx, "Credential chaining failed\n");
 587                 }
 588
 589                 cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 590         }
 591
 592         torture_assert(tctx, test_SetupCredentials(p, tctx, machine_credentials, &creds),
 593                 "ServerPasswordSet failed to actually change the password");
 594
 595         /* now try a random password */
 596         password = generate_random_password(tctx, 8, 255);
 597         encode_pw_buffer(password_buf.data, password, STR_UNICODE);
 598         netlogon_creds_arcfour_crypt(creds, password_buf.data, 516);
 599
 600         memcpy(new_password.data, password_buf.data, 512);
 601         new_password.length = IVAL(password_buf.data, 512);
 602
 603         torture_comment(tctx, "Testing second ServerPasswordSet2 on machine account\n");
 604         torture_comment(tctx, "Changing machine account password to '%s'\n", password);
 605
 606         netlogon_creds_client_authenticator(creds, &credential);
 607
 608         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet2_r(b, tctx, &r),
 609                 "ServerPasswordSet2 (2) failed");
 610         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet2 (2) failed");
 611
 612         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 613                 torture_comment(tctx, "Credential chaining failed\n");
 614         }
 615
 616         /* by changing the machine password twice we test the
 617            credentials chaining fully, and we verify that the server
 618            allows the password to be set to the same value twice in a
 619            row (match win2k3) */
 620         torture_comment(tctx,
 621                 "Testing a second ServerPasswordSet2 on machine account\n");
 622         torture_comment(tctx,
 623                 "Changing machine account password to '%s' (same as previous run)\n", password);
 624
 625         netlogon_creds_client_authenticator(creds, &credential);
 626
 627         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet2_r(b, tctx, &r),
 628                 "ServerPasswordSet (3) failed");
 629         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet (3) failed");
 630
 631         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 632                 torture_comment(tctx, "Credential chaining failed\n");
 633         }
 634
 635         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 636
 637         torture_assert (tctx,
 638                 test_SetupCredentials(p, tctx, machine_credentials, &creds),
 639                 "ServerPasswordSet failed to actually change the password");
 640
 641         new_random_pass = netlogon_very_rand_pass(tctx, 128);
 642
 643         /* now try a random stream of bytes for a password */
 644         set_pw_in_buffer(password_buf.data, &new_random_pass);
 645
 646         netlogon_creds_arcfour_crypt(creds, password_buf.data, 516);
 647
 648         memcpy(new_password.data, password_buf.data, 512);
 649         new_password.length = IVAL(password_buf.data, 512);
 650
 651         torture_comment(tctx,
 652                 "Testing a third ServerPasswordSet2 on machine account, with a completely random password\n");
 653
 654         netlogon_creds_client_authenticator(creds, &credential);
 655
 656         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerPasswordSet2_r(b, tctx, &r),
 657                 "ServerPasswordSet (3) failed");
 658         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerPasswordSet (3) failed");
 659
 660         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
 661                 torture_comment(tctx, "Credential chaining failed\n");
 662         }
 663
 664         mdfour(nt_hash.hash, new_random_pass.data, new_random_pass.length);
 665
 666         cli_credentials_set_password(machine_credentials, NULL, CRED_UNINITIALISED);
 667         cli_credentials_set_nt_hash(machine_credentials, &nt_hash, CRED_SPECIFIED);
 668
 669         torture_assert (tctx,
 670                 test_SetupCredentials(p, tctx, machine_credentials, &creds),
 671                 "ServerPasswordSet failed to actually change the password");
 672
 673         return true;
 674 }
 675
 676 static bool test_SetPassword2(struct torture_context *tctx,
 677                               struct dcerpc_pipe *p,
 678                               struct cli_credentials *machine_credentials)
 679 {
 680         return test_SetPassword2_with_flags(tctx, p, machine_credentials, NETLOGON_NEG_AUTH2_ADS_FLAGS);
 681 }
 682
 683 static bool test_GetPassword(struct torture_context *tctx,
 684                              struct dcerpc_pipe *p,
 685                              struct cli_credentials *machine_credentials)
 686 {
 687         struct netr_ServerPasswordGet r;
 688         struct netlogon_creds_CredentialState *creds;
 689         struct netr_Authenticator credential;
 690         NTSTATUS status;
 691         struct netr_Authenticator return_authenticator;
 692         struct samr_Password password;
 693         struct dcerpc_binding_handle *b = p->binding_handle;
 694
 695         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 696                 return false;
 697         }
 698
 699         netlogon_creds_client_authenticator(creds, &credential);
 700
 701         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 702         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 703         r.in.secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
 704         r.in.computer_name = TEST_MACHINE_NAME;
 705         r.in.credential = &credential;
 706         r.out.return_authenticator = &return_authenticator;
 707         r.out.password = &password;
 708
 709         status = dcerpc_netr_ServerPasswordGet_r(b, tctx, &r);
 710         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordGet");
 711
 712         return true;
 713 }
 714
 715 static bool test_GetTrustPasswords(struct torture_context *tctx,
 716                                    struct dcerpc_pipe *p,
 717                                    struct cli_credentials *machine_credentials)
 718 {
 719         struct netr_ServerTrustPasswordsGet r;
 720         struct netlogon_creds_CredentialState *creds;
 721         struct netr_Authenticator credential;
 722         struct netr_Authenticator return_authenticator;
 723         struct samr_Password password, password2;
 724         struct dcerpc_binding_handle *b = p->binding_handle;
 725
 726         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 727                 return false;
 728         }
 729
 730         netlogon_creds_client_authenticator(creds, &credential);
 731
 732         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 733         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 734         r.in.secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
 735         r.in.computer_name = TEST_MACHINE_NAME;
 736         r.in.credential = &credential;
 737         r.out.return_authenticator = &return_authenticator;
 738         r.out.password = &password;
 739         r.out.password2 = &password2;
 740
 741         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerTrustPasswordsGet_r(b, tctx, &r),
 742                 "ServerTrustPasswordsGet failed");
 743         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerTrustPasswordsGet failed");
 744
 745         return true;
 746 }
 747
 748 /*
 749   try a netlogon SamLogon
 750 */
 751 static bool test_netlogon_ops_args(struct dcerpc_pipe *p, struct torture_context *tctx,
 752                                    struct cli_credentials *credentials,
 753                                    struct netlogon_creds_CredentialState *creds,
 754                                    bool null_domain)
 755 {
 756         NTSTATUS status;
 757         struct netr_LogonSamLogon r;
 758         struct netr_Authenticator auth, auth2;
 759         static const struct netr_Authenticator auth_zero;
 760         union netr_LogonLevel logon;
 761         union netr_Validation validation;
 762         uint8_t authoritative;
 763         struct netr_NetworkInfo ninfo;
 764         DATA_BLOB names_blob, chal, lm_resp, nt_resp;
 765         int i;
 766         struct dcerpc_binding_handle *b = p->binding_handle;
 767         int flags = CLI_CRED_NTLM_AUTH;
 768         if (lpcfg_client_lanman_auth(tctx->lp_ctx)) {
 769                 flags |= CLI_CRED_LANMAN_AUTH;
 770         }
 771
 772         if (lpcfg_client_ntlmv2_auth(tctx->lp_ctx) && !null_domain) {
 773                 flags |= CLI_CRED_NTLMv2_AUTH;
 774         }
 775
 776         cli_credentials_get_ntlm_username_domain(cmdline_credentials, tctx,
 777                                                  &ninfo.identity_info.account_name.string,
 778                                                  &ninfo.identity_info.domain_name.string);
 779
 780         if (null_domain) {
 781                 ninfo.identity_info.domain_name.string = NULL;
 782         }
 783
 784         generate_random_buffer(ninfo.challenge,
 785                                sizeof(ninfo.challenge));
 786         chal = data_blob_const(ninfo.challenge,
 787                                sizeof(ninfo.challenge));
 788
 789         names_blob = NTLMv2_generate_names_blob(tctx, cli_credentials_get_workstation(credentials),
 790                                                 cli_credentials_get_domain(credentials));
 791
 792         status = cli_credentials_get_ntlm_response(cmdline_credentials, tctx,
 793                                                    &flags,
 794                                                    chal,
 795                                                    names_blob,
 796                                                    &lm_resp, &nt_resp,
 797                                                    NULL, NULL);
 798         torture_assert_ntstatus_ok(tctx, status, "cli_credentials_get_ntlm_response failed");
 799
 800         ninfo.lm.data = lm_resp.data;
 801         ninfo.lm.length = lm_resp.length;
 802
 803         ninfo.nt.data = nt_resp.data;
 804         ninfo.nt.length = nt_resp.length;
 805
 806         ninfo.identity_info.parameter_control = 0;
 807         ninfo.identity_info.logon_id_low = 0;
 808         ninfo.identity_info.logon_id_high = 0;
 809         ninfo.identity_info.workstation.string = cli_credentials_get_workstation(credentials);
 810
 811         logon.network = &ninfo;
 812
 813         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 814         r.in.computer_name = cli_credentials_get_workstation(credentials);
 815         r.in.credential = &auth;
 816         r.in.return_authenticator = &auth2;
 817         r.in.logon_level = 2;
 818         r.in.logon = &logon;
 819         r.out.validation = &validation;
 820         r.out.authoritative = &authoritative;
 821
 822         d_printf("Testing LogonSamLogon with name %s\n", ninfo.identity_info.account_name.string);
 823
 824         for (i=2;i<=3;i++) {
 825                 ZERO_STRUCT(auth2);
 826                 netlogon_creds_client_authenticator(creds, &auth);
 827
 828                 r.in.validation_level = i;
 829
 830                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonSamLogon_r(b, tctx, &r),
 831                         "LogonSamLogon failed");
 832                 torture_assert_ntstatus_ok(tctx, r.out.result, "LogonSamLogon failed");
 833
 834                 torture_assert(tctx, netlogon_creds_client_check(creds,
 835                                                                  &r.out.return_authenticator->cred),
 836                         "Credential chaining failed");
 837                 torture_assert_int_equal(tctx, *r.out.authoritative, 1,
 838                                          "LogonSamLogon invalid  *r.out.authoritative");
 839         }
 840
 841         /* this makes sure we get the unmarshalling right for invalid levels */
 842         for (i=52;i<53;i++) {
 843                 ZERO_STRUCT(auth2);
 844                 /* the authenticator should be ignored by the server */
 845                 generate_random_buffer((uint8_t *) &auth, sizeof(auth));
 846
 847                 r.in.validation_level = i;
 848
 849                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonSamLogon_r(b, tctx, &r),
 850                                            "LogonSamLogon failed");
 851                 torture_assert_ntstatus_equal(tctx, r.out.result,
 852                                               NT_STATUS_INVALID_INFO_CLASS,
 853                                               "LogonSamLogon failed");
 854
 855                 torture_assert_int_equal(tctx, *r.out.authoritative, 1,
 856                                          "LogonSamLogon invalid  *r.out.authoritative");
 857                 torture_assert(tctx,
 858                                memcmp(&auth2, &auth_zero, sizeof(auth2)) == 0,
 859                                "Return authenticator non zero");
 860         }
 861
 862         for (i=2;i<=3;i++) {
 863                 ZERO_STRUCT(auth2);
 864                 netlogon_creds_client_authenticator(creds, &auth);
 865
 866                 r.in.validation_level = i;
 867
 868                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonSamLogon_r(b, tctx, &r),
 869                         "LogonSamLogon failed");
 870                 torture_assert_ntstatus_ok(tctx, r.out.result, "LogonSamLogon failed");
 871
 872                 torture_assert(tctx, netlogon_creds_client_check(creds,
 873                                                                  &r.out.return_authenticator->cred),
 874                         "Credential chaining failed");
 875                 torture_assert_int_equal(tctx, *r.out.authoritative, 1,
 876                                          "LogonSamLogon invalid  *r.out.authoritative");
 877         }
 878
 879         r.in.logon_level = 52;
 880
 881         for (i=2;i<=3;i++) {
 882                 ZERO_STRUCT(auth2);
 883                 /* the authenticator should be ignored by the server */
 884                 generate_random_buffer((uint8_t *) &auth, sizeof(auth));
 885
 886                 r.in.validation_level = i;
 887
 888                 torture_comment(tctx, "Testing SamLogon with validation level %d and a NULL credential\n", i);
 889
 890                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonSamLogon_r(b, tctx, &r),
 891                         "LogonSamLogon failed");
 892                 torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_INVALID_PARAMETER,
 893                         "LogonSamLogon expected INVALID_PARAMETER");
 894
 895                 torture_assert(tctx,
 896                                memcmp(&auth2, &auth_zero, sizeof(auth2)) == 0,
 897                                "Return authenticator non zero");
 898                 torture_assert_int_equal(tctx, *r.out.authoritative, 1,
 899                                          "LogonSamLogon invalid  *r.out.authoritative");
 900         }
 901
 902         r.in.credential = NULL;
 903
 904         for (i=2;i<=3;i++) {
 905                 ZERO_STRUCT(auth2);
 906
 907                 r.in.validation_level = i;
 908
 909                 torture_comment(tctx, "Testing SamLogon with validation level %d and a NULL credential\n", i);
 910
 911                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonSamLogon_r(b, tctx, &r),
 912                         "LogonSamLogon failed");
 913                 torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_INVALID_PARAMETER,
 914                         "LogonSamLogon expected INVALID_PARAMETER");
 915
 916                 torture_assert(tctx,
 917                                memcmp(&auth2, &auth_zero, sizeof(auth2)) == 0,
 918                                "Return authenticator non zero");
 919                 torture_assert_int_equal(tctx, *r.out.authoritative, 1,
 920                                          "LogonSamLogon invalid  *r.out.authoritative");
 921         }
 922
 923         r.in.logon_level = 2;
 924         r.in.credential = &auth;
 925
 926         for (i=2;i<=3;i++) {
 927                 ZERO_STRUCT(auth2);
 928                 netlogon_creds_client_authenticator(creds, &auth);
 929
 930                 r.in.validation_level = i;
 931
 932                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonSamLogon_r(b, tctx, &r),
 933                         "LogonSamLogon failed");
 934                 torture_assert_ntstatus_ok(tctx, r.out.result, "LogonSamLogon failed");
 935
 936                 torture_assert(tctx, netlogon_creds_client_check(creds,
 937                                                                  &r.out.return_authenticator->cred),
 938                         "Credential chaining failed");
 939                 torture_assert_int_equal(tctx, *r.out.authoritative, 1,
 940                                          "LogonSamLogon invalid  *r.out.authoritative");
 941         }
 942
 943         return true;
 944 }
 945
 946 bool test_netlogon_ops(struct dcerpc_pipe *p, struct torture_context *tctx,
 947                        struct cli_credentials *credentials,
 948                        struct netlogon_creds_CredentialState *creds)
 949 {
 950         return test_netlogon_ops_args(p, tctx, credentials, creds, false);
 951 }
 952
 953 /*
 954   try a netlogon GetCapabilities
 955 */
 956 bool test_netlogon_capabilities(struct dcerpc_pipe *p, struct torture_context *tctx,
 957                                 struct cli_credentials *credentials,
 958                                 struct netlogon_creds_CredentialState *creds)
 959 {
 960         NTSTATUS status;
 961         struct netr_LogonGetCapabilities r;
 962         union netr_Capabilities capabilities;
 963         struct netr_Authenticator auth, return_auth;
 964         struct netlogon_creds_CredentialState tmp_creds;
 965         struct dcerpc_binding_handle *b = p->binding_handle;
 966
 967         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 968         r.in.computer_name = cli_credentials_get_workstation(credentials);
 969         r.in.credential = &auth;
 970         r.in.return_authenticator = &return_auth;
 971         r.in.query_level = 1;
 972         r.out.capabilities = &capabilities;
 973         r.out.return_authenticator = &return_auth;
 974
 975         torture_comment(tctx, "Testing LogonGetCapabilities\n");
 976
 977         ZERO_STRUCT(return_auth);
 978
 979         /*
 980          * we need to operate on a temporary copy of creds
 981          * because dcerpc_netr_LogonGetCapabilities was
 982          * dcerpc_netr_DummyFunction and returns NT_STATUS_NOT_IMPLEMENTED
 983          * without looking a the authenticator.
 984          */
 985         tmp_creds = *creds;
 986         netlogon_creds_client_authenticator(&tmp_creds, &auth);
 987
 988         status = dcerpc_netr_LogonGetCapabilities_r(b, tctx, &r);
 989         torture_assert_ntstatus_ok(tctx, status, "LogonGetCapabilities failed");
 990         if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_NOT_IMPLEMENTED)) {
 991                 return true;
 992         }
 993
 994         *creds = tmp_creds;
 995
 996         torture_assert(tctx, netlogon_creds_client_check(creds,
 997                                                          &r.out.return_authenticator->cred),
 998                        "Credential chaining failed");
 999
1000         torture_assert_int_equal(tctx, creds->negotiate_flags,
1001                                  capabilities.server_capabilities,
1002                                  "negotiate flags");
1003
1004         return true;
1005 }
1006
1007 /*
1008   try a netlogon SamLogon
1009 */
1010 static bool test_SamLogon(struct torture_context *tctx,
1011                           struct dcerpc_pipe *p,
1012                           struct cli_credentials *credentials)
1013 {
1014         struct netlogon_creds_CredentialState *creds;
1015
1016         if (!test_SetupCredentials(p, tctx, credentials, &creds)) {
1017                 return false;
1018         }
1019
1020         return test_netlogon_ops(p, tctx, credentials, creds);
1021 }
1022
1023 static bool test_SamLogon_NULL_domain(struct torture_context *tctx,
1024                                       struct dcerpc_pipe *p,
1025                                       struct cli_credentials *credentials)
1026 {
1027         struct netlogon_creds_CredentialState *creds;
1028
1029         if (!test_SetupCredentials(p, tctx, credentials, &creds)) {
1030                 return false;
1031         }
1032
1033         return test_netlogon_ops_args(p, tctx, credentials, creds, true);
1034 }
1035
1036 /* we remember the sequence numbers so we can easily do a DatabaseDelta */
1037 static uint64_t sequence_nums[3];
1038
1039 /*
1040   try a netlogon DatabaseSync
1041 */
1042 static bool test_DatabaseSync(struct torture_context *tctx,
1043                               struct dcerpc_pipe *p,
1044                               struct cli_credentials *machine_credentials)
1045 {
1046         struct netr_DatabaseSync r;
1047         struct netlogon_creds_CredentialState *creds;
1048         const uint32_t database_ids[] = {SAM_DATABASE_DOMAIN, SAM_DATABASE_BUILTIN, SAM_DATABASE_PRIVS};
1049         int i;
1050         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
1051         struct netr_Authenticator credential, return_authenticator;
1052         struct dcerpc_binding_handle *b = p->binding_handle;
1053
1054         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1055                 return false;
1056         }
1057
1058         ZERO_STRUCT(return_authenticator);
1059
1060         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1061         r.in.computername = TEST_MACHINE_NAME;
1062         r.in.preferredmaximumlength = (uint32_t)-1;
1063         r.in.return_authenticator = &return_authenticator;
1064         r.out.delta_enum_array = &delta_enum_array;
1065         r.out.return_authenticator = &return_authenticator;
1066
1067         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
1068
1069                 uint32_t sync_context = 0;
1070
1071                 r.in.database_id = database_ids[i];
1072                 r.in.sync_context = &sync_context;
1073                 r.out.sync_context = &sync_context;
1074
1075                 torture_comment(tctx, "Testing DatabaseSync of id %d\n", r.in.database_id);
1076
1077                 do {
1078                         netlogon_creds_client_authenticator(creds, &credential);
1079
1080                         r.in.credential = &credential;
1081
1082                         torture_assert_ntstatus_ok(tctx, dcerpc_netr_DatabaseSync_r(b, tctx, &r),
1083                                 "DatabaseSync failed");
1084                         if (NT_STATUS_EQUAL(r.out.result, STATUS_MORE_ENTRIES))
1085                             break;
1086
1087                         /* Native mode servers don't do this */
1088                         if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_NOT_SUPPORTED)) {
1089                                 return true;
1090                         }
1091                         torture_assert_ntstatus_ok(tctx, r.out.result, "DatabaseSync");
1092
1093                         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
1094                                 torture_comment(tctx, "Credential chaining failed\n");
1095                         }
1096
1097                         if (delta_enum_array &&
1098                             delta_enum_array->num_deltas > 0 &&
1099                             delta_enum_array->delta_enum[0].delta_type == NETR_DELTA_DOMAIN &&
1100                             delta_enum_array->delta_enum[0].delta_union.domain) {
1101                                 sequence_nums[r.in.database_id] =
1102                                         delta_enum_array->delta_enum[0].delta_union.domain->sequence_num;
1103                                 torture_comment(tctx, "\tsequence_nums[%d]=%llu\n",
1104                                        r.in.database_id,
1105                                        (unsigned long long)sequence_nums[r.in.database_id]);
1106                         }
1107                 } while (NT_STATUS_EQUAL(r.out.result, STATUS_MORE_ENTRIES));
1108         }
1109
1110         return true;
1111 }
1112
1113
1114 /*
1115   try a netlogon DatabaseDeltas
1116 */
1117 static bool test_DatabaseDeltas(struct torture_context *tctx,
1118                                 struct dcerpc_pipe *p,
1119                                 struct cli_credentials *machine_credentials)
1120 {
1121         struct netr_DatabaseDeltas r;
1122         struct netlogon_creds_CredentialState *creds;
1123         struct netr_Authenticator credential;
1124         struct netr_Authenticator return_authenticator;
1125         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
1126         const uint32_t database_ids[] = {0, 1, 2};
1127         int i;
1128         struct dcerpc_binding_handle *b = p->binding_handle;
1129
1130         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1131                 return false;
1132         }
1133
1134         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1135         r.in.computername = TEST_MACHINE_NAME;
1136         r.in.preferredmaximumlength = (uint32_t)-1;
1137         ZERO_STRUCT(r.in.return_authenticator);
1138         r.out.return_authenticator = &return_authenticator;
1139         r.out.delta_enum_array = &delta_enum_array;
1140
1141         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
1142                 r.in.database_id = database_ids[i];
1143                 r.in.sequence_num = &sequence_nums[r.in.database_id];
1144
1145                 if (*r.in.sequence_num == 0) continue;
1146
1147                 *r.in.sequence_num -= 1;
1148
1149                 torture_comment(tctx, "Testing DatabaseDeltas of id %d at %llu\n",
1150                        r.in.database_id, (unsigned long long)*r.in.sequence_num);
1151
1152                 do {
1153                         netlogon_creds_client_authenticator(creds, &credential);
1154
1155                         torture_assert_ntstatus_ok(tctx, dcerpc_netr_DatabaseDeltas_r(b, tctx, &r),
1156                                 "DatabaseDeltas failed");
1157                         if (NT_STATUS_EQUAL(r.out.result,
1158                                              NT_STATUS_SYNCHRONIZATION_REQUIRED)) {
1159                                 torture_comment(tctx, "not considering %s to be an error\n",
1160                                        nt_errstr(r.out.result));
1161                                 return true;
1162                         }
1163                         if (NT_STATUS_EQUAL(r.out.result, STATUS_MORE_ENTRIES))
1164                             break;
1165
1166                         torture_assert_ntstatus_ok(tctx, r.out.result, "DatabaseDeltas");
1167
1168                         if (!netlogon_creds_client_check(creds, &return_authenticator.cred)) {
1169                                 torture_comment(tctx, "Credential chaining failed\n");
1170                         }
1171
1172                         (*r.in.sequence_num)++;
1173                 } while (NT_STATUS_EQUAL(r.out.result, STATUS_MORE_ENTRIES));
1174         }
1175
1176         return true;
1177 }
1178
1179 static bool test_DatabaseRedo(struct torture_context *tctx,
1180                               struct dcerpc_pipe *p,
1181                               struct cli_credentials *machine_credentials)
1182 {
1183         struct netr_DatabaseRedo r;
1184         struct netlogon_creds_CredentialState *creds;
1185         struct netr_Authenticator credential;
1186         struct netr_Authenticator return_authenticator;
1187         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
1188         struct netr_ChangeLogEntry e;
1189         struct dom_sid null_sid, *sid;
1190         int i,d;
1191         struct dcerpc_binding_handle *b = p->binding_handle;
1192
1193         ZERO_STRUCT(null_sid);
1194
1195         sid = dom_sid_parse_talloc(tctx, "S-1-5-21-1111111111-2222222222-333333333-500");
1196
1197         {
1198
1199         struct {
1200                 uint32_t rid;
1201                 uint16_t flags;
1202                 uint8_t db_index;
1203                 uint8_t delta_type;
1204                 struct dom_sid sid;
1205                 const char *name;
1206                 NTSTATUS expected_error;
1207                 uint32_t expected_num_results;
1208                 uint8_t expected_delta_type_1;
1209                 uint8_t expected_delta_type_2;
1210                 const char *comment;
1211         } changes[] = {
1212
1213                 /* SAM_DATABASE_DOMAIN */
1214
1215                 {
1216                         .rid                    = 0,
1217                         .flags                  = 0,
1218                         .db_index               = SAM_DATABASE_DOMAIN,
1219                         .delta_type             = NETR_DELTA_MODIFY_COUNT,
1220                         .sid                    = null_sid,
1221                         .name                   = NULL,
1222                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED,
1223                         .expected_num_results   = 0,
1224                         .comment                = "NETR_DELTA_MODIFY_COUNT"
1225                 },
1226                 {
1227                         .rid                    = 0,
1228                         .flags                  = 0,
1229                         .db_index               = SAM_DATABASE_DOMAIN,
1230                         .delta_type             = 0,
1231                         .sid                    = null_sid,
1232                         .name                   = NULL,
1233                         .expected_error         = NT_STATUS_OK,
1234                         .expected_num_results   = 1,
1235                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1236                         .comment                = "NULL DELTA"
1237                 },
1238                 {
1239                         .rid                    = 0,
1240                         .flags                  = 0,
1241                         .db_index               = SAM_DATABASE_DOMAIN,
1242                         .delta_type             = NETR_DELTA_DOMAIN,
1243                         .sid                    = null_sid,
1244                         .name                   = NULL,
1245                         .expected_error         = NT_STATUS_OK,
1246                         .expected_num_results   = 1,
1247                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1248                         .comment                = "NETR_DELTA_DOMAIN"
1249                 },
1250                 {
1251                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1252                         .flags                  = 0,
1253                         .db_index               = SAM_DATABASE_DOMAIN,
1254                         .delta_type             = NETR_DELTA_USER,
1255                         .sid                    = null_sid,
1256                         .name                   = NULL,
1257                         .expected_error         = NT_STATUS_OK,
1258                         .expected_num_results   = 1,
1259                         .expected_delta_type_1  = NETR_DELTA_USER,
1260                         .comment                = "NETR_DELTA_USER by rid 500"
1261                 },
1262                 {
1263                         .rid                    = DOMAIN_RID_GUEST,
1264                         .flags                  = 0,
1265                         .db_index               = SAM_DATABASE_DOMAIN,
1266                         .delta_type             = NETR_DELTA_USER,
1267                         .sid                    = null_sid,
1268                         .name                   = NULL,
1269                         .expected_error         = NT_STATUS_OK,
1270                         .expected_num_results   = 1,
1271                         .expected_delta_type_1  = NETR_DELTA_USER,
1272                         .comment                = "NETR_DELTA_USER by rid 501"
1273                 },
1274                 {
1275                         .rid                    = 0,
1276                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1277                         .db_index               = SAM_DATABASE_DOMAIN,
1278                         .delta_type             = NETR_DELTA_USER,
1279                         .sid                    = *sid,
1280                         .name                   = NULL,
1281                         .expected_error         = NT_STATUS_OK,
1282                         .expected_num_results   = 1,
1283                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1284                         .comment                = "NETR_DELTA_USER by sid and flags"
1285                 },
1286                 {
1287                         .rid                    = 0,
1288                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1289                         .db_index               = SAM_DATABASE_DOMAIN,
1290                         .delta_type             = NETR_DELTA_USER,
1291                         .sid                    = null_sid,
1292                         .name                   = NULL,
1293                         .expected_error         = NT_STATUS_OK,
1294                         .expected_num_results   = 1,
1295                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1296                         .comment                = "NETR_DELTA_USER by null_sid and flags"
1297                 },
1298                 {
1299                         .rid                    = 0,
1300                         .flags                  = NETR_CHANGELOG_NAME_INCLUDED,
1301                         .db_index               = SAM_DATABASE_DOMAIN,
1302                         .delta_type             = NETR_DELTA_USER,
1303                         .sid                    = null_sid,
1304                         .name                   = "administrator",
1305                         .expected_error         = NT_STATUS_OK,
1306                         .expected_num_results   = 1,
1307                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1308                         .comment                = "NETR_DELTA_USER by name 'administrator'"
1309                 },
1310                 {
1311                         .rid                    = DOMAIN_RID_ADMINS,
1312                         .flags                  = 0,
1313                         .db_index               = SAM_DATABASE_DOMAIN,
1314                         .delta_type             = NETR_DELTA_GROUP,
1315                         .sid                    = null_sid,
1316                         .name                   = NULL,
1317                         .expected_error         = NT_STATUS_OK,
1318                         .expected_num_results   = 2,
1319                         .expected_delta_type_1  = NETR_DELTA_GROUP,
1320                         .expected_delta_type_2  = NETR_DELTA_GROUP_MEMBER,
1321                         .comment                = "NETR_DELTA_GROUP by rid 512"
1322                 },
1323                 {
1324                         .rid                    = DOMAIN_RID_ADMINS,
1325                         .flags                  = 0,
1326                         .db_index               = SAM_DATABASE_DOMAIN,
1327                         .delta_type             = NETR_DELTA_GROUP_MEMBER,
1328                         .sid                    = null_sid,
1329                         .name                   = NULL,
1330                         .expected_error         = NT_STATUS_OK,
1331                         .expected_num_results   = 2,
1332                         .expected_delta_type_1  = NETR_DELTA_GROUP,
1333                         .expected_delta_type_2  = NETR_DELTA_GROUP_MEMBER,
1334                         .comment                = "NETR_DELTA_GROUP_MEMBER by rid 512"
1335                 },
1336
1337
1338                 /* SAM_DATABASE_BUILTIN */
1339
1340                 {
1341                         .rid                    = 0,
1342                         .flags                  = 0,
1343                         .db_index               = SAM_DATABASE_BUILTIN,
1344                         .delta_type             = NETR_DELTA_MODIFY_COUNT,
1345                         .sid                    = null_sid,
1346                         .name                   = NULL,
1347                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED,
1348                         .expected_num_results   = 0,
1349                         .comment                = "NETR_DELTA_MODIFY_COUNT"
1350                 },
1351                 {
1352                         .rid                    = 0,
1353                         .flags                  = 0,
1354                         .db_index               = SAM_DATABASE_BUILTIN,
1355                         .delta_type             = NETR_DELTA_DOMAIN,
1356                         .sid                    = null_sid,
1357                         .name                   = NULL,
1358                         .expected_error         = NT_STATUS_OK,
1359                         .expected_num_results   = 1,
1360                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1361                         .comment                = "NETR_DELTA_DOMAIN"
1362                 },
1363                 {
1364                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1365                         .flags                  = 0,
1366                         .db_index               = SAM_DATABASE_BUILTIN,
1367                         .delta_type             = NETR_DELTA_USER,
1368                         .sid                    = null_sid,
1369                         .name                   = NULL,
1370                         .expected_error         = NT_STATUS_OK,
1371                         .expected_num_results   = 1,
1372                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1373                         .comment                = "NETR_DELTA_USER by rid 500"
1374                 },
1375                 {
1376                         .rid                    = 0,
1377                         .flags                  = 0,
1378                         .db_index               = SAM_DATABASE_BUILTIN,
1379                         .delta_type             = NETR_DELTA_USER,
1380                         .sid                    = null_sid,
1381                         .name                   = NULL,
1382                         .expected_error         = NT_STATUS_OK,
1383                         .expected_num_results   = 1,
1384                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1385                         .comment                = "NETR_DELTA_USER"
1386                 },
1387                 {
1388                         .rid                    = 544,
1389                         .flags                  = 0,
1390                         .db_index               = SAM_DATABASE_BUILTIN,
1391                         .delta_type             = NETR_DELTA_ALIAS,
1392                         .sid                    = null_sid,
1393                         .name                   = NULL,
1394                         .expected_error         = NT_STATUS_OK,
1395                         .expected_num_results   = 2,
1396                         .expected_delta_type_1  = NETR_DELTA_ALIAS,
1397                         .expected_delta_type_2  = NETR_DELTA_ALIAS_MEMBER,
1398                         .comment                = "NETR_DELTA_ALIAS by rid 544"
1399                 },
1400                 {
1401                         .rid                    = 544,
1402                         .flags                  = 0,
1403                         .db_index               = SAM_DATABASE_BUILTIN,
1404                         .delta_type             = NETR_DELTA_ALIAS_MEMBER,
1405                         .sid                    = null_sid,
1406                         .name                   = NULL,
1407                         .expected_error         = NT_STATUS_OK,
1408                         .expected_num_results   = 2,
1409                         .expected_delta_type_1  = NETR_DELTA_ALIAS,
1410                         .expected_delta_type_2  = NETR_DELTA_ALIAS_MEMBER,
1411                         .comment                = "NETR_DELTA_ALIAS_MEMBER by rid 544"
1412                 },
1413                 {
1414                         .rid                    = 544,
1415                         .flags                  = 0,
1416                         .db_index               = SAM_DATABASE_BUILTIN,
1417                         .delta_type             = 0,
1418                         .sid                    = null_sid,
1419                         .name                   = NULL,
1420                         .expected_error         = NT_STATUS_OK,
1421                         .expected_num_results   = 1,
1422                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1423                         .comment                = "NULL DELTA by rid 544"
1424                 },
1425                 {
1426                         .rid                    = 544,
1427                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1428                         .db_index               = SAM_DATABASE_BUILTIN,
1429                         .delta_type             = 0,
1430                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32-544"),
1431                         .name                   = NULL,
1432                         .expected_error         = NT_STATUS_OK,
1433                         .expected_num_results   = 1,
1434                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1435                         .comment                = "NULL DELTA by rid 544 sid S-1-5-32-544 and flags"
1436                 },
1437                 {
1438                         .rid                    = 544,
1439                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1440                         .db_index               = SAM_DATABASE_BUILTIN,
1441                         .delta_type             = NETR_DELTA_ALIAS,
1442                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32-544"),
1443                         .name                   = NULL,
1444                         .expected_error         = NT_STATUS_OK,
1445                         .expected_num_results   = 2,
1446                         .expected_delta_type_1  = NETR_DELTA_ALIAS,
1447                         .expected_delta_type_2  = NETR_DELTA_ALIAS_MEMBER,
1448                         .comment                = "NETR_DELTA_ALIAS by rid 544 and sid S-1-5-32-544 and flags"
1449                 },
1450                 {
1451                         .rid                    = 0,
1452                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1453                         .db_index               = SAM_DATABASE_BUILTIN,
1454                         .delta_type             = NETR_DELTA_ALIAS,
1455                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32-544"),
1456                         .name                   = NULL,
1457                         .expected_error         = NT_STATUS_OK,
1458                         .expected_num_results   = 1,
1459                         .expected_delta_type_1  = NETR_DELTA_DELETE_ALIAS,
1460                         .comment                = "NETR_DELTA_ALIAS by sid S-1-5-32-544 and flags"
1461                 },
1462
1463                 /* SAM_DATABASE_PRIVS */
1464
1465                 {
1466                         .rid                    = 0,
1467                         .flags                  = 0,
1468                         .db_index               = SAM_DATABASE_PRIVS,
1469                         .delta_type             = 0,
1470                         .sid                    = null_sid,
1471                         .name                   = NULL,
1472                         .expected_error         = NT_STATUS_ACCESS_DENIED,
1473                         .expected_num_results   = 0,
1474                         .comment                = "NULL DELTA"
1475                 },
1476                 {
1477                         .rid                    = 0,
1478                         .flags                  = 0,
1479                         .db_index               = SAM_DATABASE_PRIVS,
1480                         .delta_type             = NETR_DELTA_MODIFY_COUNT,
1481                         .sid                    = null_sid,
1482                         .name                   = NULL,
1483                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED,
1484                         .expected_num_results   = 0,
1485                         .comment                = "NETR_DELTA_MODIFY_COUNT"
1486                 },
1487                 {
1488                         .rid                    = 0,
1489                         .flags                  = 0,
1490                         .db_index               = SAM_DATABASE_PRIVS,
1491                         .delta_type             = NETR_DELTA_POLICY,
1492                         .sid                    = null_sid,
1493                         .name                   = NULL,
1494                         .expected_error         = NT_STATUS_OK,
1495                         .expected_num_results   = 1,
1496                         .expected_delta_type_1  = NETR_DELTA_POLICY,
1497                         .comment                = "NETR_DELTA_POLICY"
1498                 },
1499                 {
1500                         .rid                    = 0,
1501                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1502                         .db_index               = SAM_DATABASE_PRIVS,
1503                         .delta_type             = NETR_DELTA_POLICY,
1504                         .sid                    = null_sid,
1505                         .name                   = NULL,
1506                         .expected_error         = NT_STATUS_OK,
1507                         .expected_num_results   = 1,
1508                         .expected_delta_type_1  = NETR_DELTA_POLICY,
1509                         .comment                = "NETR_DELTA_POLICY by null sid and flags"
1510                 },
1511                 {
1512                         .rid                    = 0,
1513                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1514                         .db_index               = SAM_DATABASE_PRIVS,
1515                         .delta_type             = NETR_DELTA_POLICY,
1516                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32"),
1517                         .name                   = NULL,
1518                         .expected_error         = NT_STATUS_OK,
1519                         .expected_num_results   = 1,
1520                         .expected_delta_type_1  = NETR_DELTA_POLICY,
1521                         .comment                = "NETR_DELTA_POLICY by sid S-1-5-32 and flags"
1522                 },
1523                 {
1524                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1525                         .flags                  = 0,
1526                         .db_index               = SAM_DATABASE_PRIVS,
1527                         .delta_type             = NETR_DELTA_ACCOUNT,
1528                         .sid                    = null_sid,
1529                         .name                   = NULL,
1530                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED, /* strange */
1531                         .expected_num_results   = 0,
1532                         .comment                = "NETR_DELTA_ACCOUNT by rid 500"
1533                 },
1534                 {
1535                         .rid                    = 0,
1536                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1537                         .db_index               = SAM_DATABASE_PRIVS,
1538                         .delta_type             = NETR_DELTA_ACCOUNT,
1539                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-1-0"),
1540                         .name                   = NULL,
1541                         .expected_error         = NT_STATUS_OK,
1542                         .expected_num_results   = 1,
1543                         .expected_delta_type_1  = NETR_DELTA_ACCOUNT,
1544                         .comment                = "NETR_DELTA_ACCOUNT by sid S-1-1-0 and flags"
1545                 },
1546                 {
1547                         .rid                    = 0,
1548                         .flags                  = NETR_CHANGELOG_SID_INCLUDED |
1549                                                   NETR_CHANGELOG_IMMEDIATE_REPL_REQUIRED,
1550                         .db_index               = SAM_DATABASE_PRIVS,
1551                         .delta_type             = NETR_DELTA_ACCOUNT,
1552                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-1-0"),
1553                         .name                   = NULL,
1554                         .expected_error         = NT_STATUS_OK,
1555                         .expected_num_results   = 1,
1556                         .expected_delta_type_1  = NETR_DELTA_ACCOUNT,
1557                         .comment                = "NETR_DELTA_ACCOUNT by sid S-1-1-0 and 2 flags"
1558                 },
1559                 {
1560                         .rid                    = 0,
1561                         .flags                  = NETR_CHANGELOG_SID_INCLUDED |
1562                                                   NETR_CHANGELOG_NAME_INCLUDED,
1563                         .db_index               = SAM_DATABASE_PRIVS,
1564                         .delta_type             = NETR_DELTA_ACCOUNT,
1565                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-1-0"),
1566                         .name                   = NULL,
1567                         .expected_error         = NT_STATUS_INVALID_PARAMETER,
1568                         .expected_num_results   = 0,
1569                         .comment                = "NETR_DELTA_ACCOUNT by sid S-1-1-0 and invalid flags"
1570                 },
1571                 {
1572                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1573                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1574                         .db_index               = SAM_DATABASE_PRIVS,
1575                         .delta_type             = NETR_DELTA_ACCOUNT,
1576                         .sid                    = *sid,
1577                         .name                   = NULL,
1578                         .expected_error         = NT_STATUS_OK,
1579                         .expected_num_results   = 1,
1580                         .expected_delta_type_1  = NETR_DELTA_DELETE_ACCOUNT,
1581                         .comment                = "NETR_DELTA_ACCOUNT by rid 500, sid and flags"
1582                 },
1583                 {
1584                         .rid                    = 0,
1585                         .flags                  = NETR_CHANGELOG_NAME_INCLUDED,
1586                         .db_index               = SAM_DATABASE_PRIVS,
1587                         .delta_type             = NETR_DELTA_SECRET,
1588                         .sid                    = null_sid,
1589                         .name                   = "IsurelydontexistIhope",
1590                         .expected_error         = NT_STATUS_OK,
1591                         .expected_num_results   = 1,
1592                         .expected_delta_type_1  = NETR_DELTA_DELETE_SECRET,
1593                         .comment                = "NETR_DELTA_SECRET by name 'IsurelydontexistIhope' and flags"
1594                 },
1595                 {
1596                         .rid                    = 0,
1597                         .flags                  = NETR_CHANGELOG_NAME_INCLUDED,
1598                         .db_index               = SAM_DATABASE_PRIVS,
1599                         .delta_type             = NETR_DELTA_SECRET,
1600                         .sid                    = null_sid,
1601                         .name                   = "G$BCKUPKEY_P",
1602                         .expected_error         = NT_STATUS_OK,
1603                         .expected_num_results   = 1,
1604                         .expected_delta_type_1  = NETR_DELTA_SECRET,
1605                         .comment                = "NETR_DELTA_SECRET by name 'G$BCKUPKEY_P' and flags"
1606                 }
1607         };
1608
1609         ZERO_STRUCT(return_authenticator);
1610
1611         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1612         r.in.computername = TEST_MACHINE_NAME;
1613         r.in.return_authenticator = &return_authenticator;
1614         r.out.return_authenticator = &return_authenticator;
1615         r.out.delta_enum_array = &delta_enum_array;
1616
1617         for (d=0; d<3; d++) {
1618                 const char *database = NULL;
1619
1620                 switch (d) {
1621                 case 0:
1622                         database = "SAM";
1623                         break;
1624                 case 1:
1625                         database = "BUILTIN";
1626                         break;
1627                 case 2:
1628                         database = "LSA";
1629                         break;
1630                 default:
1631                         break;
1632                 }
1633
1634                 torture_comment(tctx, "Testing DatabaseRedo\n");
1635
1636                 if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1637                         return false;
1638                 }
1639
1640                 for (i=0;i<ARRAY_SIZE(changes);i++) {
1641
1642                         if (d != changes[i].db_index) {
1643                                 continue;
1644                         }
1645
1646                         netlogon_creds_client_authenticator(creds, &credential);
1647
1648                         r.in.credential = &credential;
1649
1650                         e.serial_number1        = 0;
1651                         e.serial_number2        = 0;
1652                         e.object_rid            = changes[i].rid;
1653                         e.flags                 = changes[i].flags;
1654                         e.db_index              = changes[i].db_index;
1655                         e.delta_type            = changes[i].delta_type;
1656
1657                         switch (changes[i].flags & (NETR_CHANGELOG_NAME_INCLUDED | NETR_CHANGELOG_SID_INCLUDED)) {
1658                         case NETR_CHANGELOG_SID_INCLUDED:
1659                                 e.object.object_sid             = changes[i].sid;
1660                                 break;
1661                         case NETR_CHANGELOG_NAME_INCLUDED:
1662                                 e.object.object_name            = changes[i].name;
1663                                 break;
1664                         default:
1665                                 break;
1666                         }
1667
1668                         r.in.change_log_entry = e;
1669
1670                         torture_comment(tctx, "Testing DatabaseRedo with database %s and %s\n",
1671                                 database, changes[i].comment);
1672
1673                         torture_assert_ntstatus_ok(tctx, dcerpc_netr_DatabaseRedo_r(b, tctx, &r),
1674                                 "DatabaseRedo failed");
1675                         if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_NOT_SUPPORTED)) {
1676                                 return true;
1677                         }
1678
1679                         torture_assert_ntstatus_equal(tctx, r.out.result, changes[i].expected_error, changes[i].comment);
1680                         if (delta_enum_array) {
1681                                 torture_assert_int_equal(tctx,
1682                                         delta_enum_array->num_deltas,
1683                                         changes[i].expected_num_results,
1684                                         changes[i].comment);
1685                                 if (delta_enum_array->num_deltas > 0) {
1686                                         torture_assert_int_equal(tctx,
1687                                                 delta_enum_array->delta_enum[0].delta_type,
1688                                                 changes[i].expected_delta_type_1,
1689                                                 changes[i].comment);
1690                                 }
1691                                 if (delta_enum_array->num_deltas > 1) {
1692                                         torture_assert_int_equal(tctx,
1693                                                 delta_enum_array->delta_enum[1].delta_type,
1694                                                 changes[i].expected_delta_type_2,
1695                                                 changes[i].comment);
1696                                 }
1697                         }
1698
1699                         if (!netlogon_creds_client_check(creds, &return_authenticator.cred)) {
1700                                 torture_comment(tctx, "Credential chaining failed\n");
1701                                 if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1702                                         return false;
1703                                 }
1704                         }
1705                 }
1706         }
1707         }
1708
1709         return true;
1710 }
1711
1712 /*
1713   try a netlogon AccountDeltas
1714 */
1715 static bool test_AccountDeltas(struct torture_context *tctx,
1716                                struct dcerpc_pipe *p,
1717                                struct cli_credentials *machine_credentials)
1718 {
1719         struct netr_AccountDeltas r;
1720         struct netlogon_creds_CredentialState *creds;
1721
1722         struct netr_AccountBuffer buffer;
1723         uint32_t count_returned = 0;
1724         uint32_t total_entries = 0;
1725         struct netr_UAS_INFO_0 recordid;
1726         struct netr_Authenticator return_authenticator;
1727         struct dcerpc_binding_handle *b = p->binding_handle;
1728
1729         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1730                 return false;
1731         }
1732
1733         ZERO_STRUCT(return_authenticator);
1734
1735         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1736         r.in.computername = TEST_MACHINE_NAME;
1737         r.in.return_authenticator = &return_authenticator;
1738         netlogon_creds_client_authenticator(creds, &r.in.credential);
1739         ZERO_STRUCT(r.in.uas);
1740         r.in.count=10;
1741         r.in.level=0;
1742         r.in.buffersize=100;
1743         r.out.buffer = &buffer;
1744         r.out.count_returned = &count_returned;
1745         r.out.total_entries = &total_entries;
1746         r.out.recordid = &recordid;
1747         r.out.return_authenticator = &return_authenticator;
1748
1749         /* w2k3 returns "NOT IMPLEMENTED" for this call */
1750         torture_assert_ntstatus_ok(tctx, dcerpc_netr_AccountDeltas_r(b, tctx, &r),
1751                 "AccountDeltas failed");
1752         torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_NOT_IMPLEMENTED, "AccountDeltas");
1753
1754         return true;
1755 }
1756
1757 /*
1758   try a netlogon AccountSync
1759 */
1760 static bool test_AccountSync(struct torture_context *tctx, struct dcerpc_pipe *p,
1761                              struct cli_credentials *machine_credentials)
1762 {
1763         struct netr_AccountSync r;
1764         struct netlogon_creds_CredentialState *creds;
1765
1766         struct netr_AccountBuffer buffer;
1767         uint32_t count_returned = 0;
1768         uint32_t total_entries = 0;
1769         uint32_t next_reference = 0;
1770         struct netr_UAS_INFO_0 recordid;
1771         struct netr_Authenticator return_authenticator;
1772         struct dcerpc_binding_handle *b = p->binding_handle;
1773
1774         ZERO_STRUCT(recordid);
1775         ZERO_STRUCT(return_authenticator);
1776
1777         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1778                 return false;
1779         }
1780
1781         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1782         r.in.computername = TEST_MACHINE_NAME;
1783         r.in.return_authenticator = &return_authenticator;
1784         netlogon_creds_client_authenticator(creds, &r.in.credential);
1785         r.in.recordid = &recordid;
1786         r.in.reference=0;
1787         r.in.level=0;
1788         r.in.buffersize=100;
1789         r.out.buffer = &buffer;
1790         r.out.count_returned = &count_returned;
1791         r.out.total_entries = &total_entries;
1792         r.out.next_reference = &next_reference;
1793         r.out.recordid = &recordid;
1794         r.out.return_authenticator = &return_authenticator;
1795
1796         /* w2k3 returns "NOT IMPLEMENTED" for this call */
1797         torture_assert_ntstatus_ok(tctx, dcerpc_netr_AccountSync_r(b, tctx, &r),
1798                 "AccountSync failed");
1799         torture_assert_ntstatus_equal(tctx, r.out.result, NT_STATUS_NOT_IMPLEMENTED, "AccountSync");
1800
1801         return true;
1802 }
1803
1804 /*
1805   try a netlogon GetDcName
1806 */
1807 static bool test_GetDcName(struct torture_context *tctx,
1808                            struct dcerpc_pipe *p)
1809 {
1810         struct netr_GetDcName r;
1811         const char *dcname = NULL;
1812         struct dcerpc_binding_handle *b = p->binding_handle;
1813
1814         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1815         r.in.domainname = lpcfg_workgroup(tctx->lp_ctx);
1816         r.out.dcname = &dcname;
1817
1818         torture_assert_ntstatus_ok(tctx, dcerpc_netr_GetDcName_r(b, tctx, &r),
1819                 "GetDcName failed");
1820         torture_assert_werr_ok(tctx, r.out.result, "GetDcName failed");
1821
1822         torture_comment(tctx, "\tDC is at '%s'\n", dcname);
1823
1824         return true;
1825 }
1826
1827 static const char *function_code_str(TALLOC_CTX *mem_ctx,
1828                                      enum netr_LogonControlCode function_code)
1829 {
1830         switch (function_code) {
1831         case NETLOGON_CONTROL_QUERY:
1832                 return "NETLOGON_CONTROL_QUERY";
1833         case NETLOGON_CONTROL_REPLICATE:
1834                 return "NETLOGON_CONTROL_REPLICATE";
1835         case NETLOGON_CONTROL_SYNCHRONIZE:
1836                 return "NETLOGON_CONTROL_SYNCHRONIZE";
1837         case NETLOGON_CONTROL_PDC_REPLICATE:
1838                 return "NETLOGON_CONTROL_PDC_REPLICATE";
1839         case NETLOGON_CONTROL_REDISCOVER:
1840                 return "NETLOGON_CONTROL_REDISCOVER";
1841         case NETLOGON_CONTROL_TC_QUERY:
1842                 return "NETLOGON_CONTROL_TC_QUERY";
1843         case NETLOGON_CONTROL_TRANSPORT_NOTIFY:
1844                 return "NETLOGON_CONTROL_TRANSPORT_NOTIFY";
1845         case NETLOGON_CONTROL_FIND_USER:
1846                 return "NETLOGON_CONTROL_FIND_USER";
1847         case NETLOGON_CONTROL_CHANGE_PASSWORD:
1848                 return "NETLOGON_CONTROL_CHANGE_PASSWORD";
1849         case NETLOGON_CONTROL_TC_VERIFY:
1850                 return "NETLOGON_CONTROL_TC_VERIFY";
1851         case NETLOGON_CONTROL_FORCE_DNS_REG:
1852                 return "NETLOGON_CONTROL_FORCE_DNS_REG";
1853         case NETLOGON_CONTROL_QUERY_DNS_REG:
1854                 return "NETLOGON_CONTROL_QUERY_DNS_REG";
1855         case NETLOGON_CONTROL_BACKUP_CHANGE_LOG:
1856                 return "NETLOGON_CONTROL_BACKUP_CHANGE_LOG";
1857         case NETLOGON_CONTROL_TRUNCATE_LOG:
1858                 return "NETLOGON_CONTROL_TRUNCATE_LOG";
1859         case NETLOGON_CONTROL_SET_DBFLAG:
1860                 return "NETLOGON_CONTROL_SET_DBFLAG";
1861         case NETLOGON_CONTROL_BREAKPOINT:
1862                 return "NETLOGON_CONTROL_BREAKPOINT";
1863         default:
1864                 return talloc_asprintf(mem_ctx, "unknown function code: %d",
1865                                        function_code);
1866         }
1867 }
1868
1869
1870 /*
1871   try a netlogon LogonControl
1872 */
1873 static bool test_LogonControl(struct torture_context *tctx,
1874                               struct dcerpc_pipe *p,
1875                               struct cli_credentials *machine_credentials)
1876
1877 {
1878         NTSTATUS status;
1879         struct netr_LogonControl r;
1880         union netr_CONTROL_QUERY_INFORMATION query;
1881         int i,f;
1882         enum netr_SchannelType secure_channel_type = SEC_CHAN_NULL;
1883         struct dcerpc_binding_handle *b = p->binding_handle;
1884
1885         uint32_t function_codes[] = {
1886                 NETLOGON_CONTROL_QUERY,
1887                 NETLOGON_CONTROL_REPLICATE,
1888                 NETLOGON_CONTROL_SYNCHRONIZE,
1889                 NETLOGON_CONTROL_PDC_REPLICATE,
1890                 NETLOGON_CONTROL_REDISCOVER,
1891                 NETLOGON_CONTROL_TC_QUERY,
1892                 NETLOGON_CONTROL_TRANSPORT_NOTIFY,
1893                 NETLOGON_CONTROL_FIND_USER,
1894                 NETLOGON_CONTROL_CHANGE_PASSWORD,
1895                 NETLOGON_CONTROL_TC_VERIFY,
1896                 NETLOGON_CONTROL_FORCE_DNS_REG,
1897                 NETLOGON_CONTROL_QUERY_DNS_REG,
1898                 NETLOGON_CONTROL_BACKUP_CHANGE_LOG,
1899                 NETLOGON_CONTROL_TRUNCATE_LOG,
1900                 NETLOGON_CONTROL_SET_DBFLAG,
1901                 NETLOGON_CONTROL_BREAKPOINT
1902         };
1903
1904         if (machine_credentials) {
1905                 secure_channel_type = cli_credentials_get_secure_channel_type(machine_credentials);
1906         }
1907
1908         torture_comment(tctx, "Testing LogonControl with secure channel type: %d\n",
1909                 secure_channel_type);
1910
1911         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1912         r.in.function_code = 1;
1913         r.out.query = &query;
1914
1915         for (f=0;f<ARRAY_SIZE(function_codes); f++) {
1916         for (i=1;i<5;i++) {
1917
1918                 r.in.function_code = function_codes[f];
1919                 r.in.level = i;
1920
1921                 torture_comment(tctx, "Testing LogonControl function code %s (%d) level %d\n",
1922                                 function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
1923
1924                 status = dcerpc_netr_LogonControl_r(b, tctx, &r);
1925                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1926
1927                 switch (r.in.level) {
1928                 case 1:
1929                         switch (r.in.function_code) {
1930                         case NETLOGON_CONTROL_REPLICATE:
1931                         case NETLOGON_CONTROL_SYNCHRONIZE:
1932                         case NETLOGON_CONTROL_PDC_REPLICATE:
1933                         case NETLOGON_CONTROL_BREAKPOINT:
1934                         case NETLOGON_CONTROL_BACKUP_CHANGE_LOG:
1935                                 if ((secure_channel_type == SEC_CHAN_BDC) ||
1936                                     (secure_channel_type == SEC_CHAN_WKSTA)) {
1937                                         torture_assert_werr_equal(tctx, r.out.result, WERR_ACCESS_DENIED,
1938                                                 "LogonControl returned unexpected error code");
1939                                 } else {
1940                                         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1941                                                 "LogonControl returned unexpected error code");
1942                                 }
1943                                 break;
1944
1945                         case NETLOGON_CONTROL_REDISCOVER:
1946                         case NETLOGON_CONTROL_TC_QUERY:
1947                         case NETLOGON_CONTROL_TRANSPORT_NOTIFY:
1948                         case NETLOGON_CONTROL_FIND_USER:
1949                         case NETLOGON_CONTROL_CHANGE_PASSWORD:
1950                         case NETLOGON_CONTROL_TC_VERIFY:
1951                         case NETLOGON_CONTROL_FORCE_DNS_REG:
1952                         case NETLOGON_CONTROL_QUERY_DNS_REG:
1953                         case NETLOGON_CONTROL_SET_DBFLAG:
1954                                 torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1955                                         "LogonControl returned unexpected error code");
1956                                 break;
1957                         case NETLOGON_CONTROL_TRUNCATE_LOG:
1958                                 if ((secure_channel_type == SEC_CHAN_BDC) ||
1959                                     (secure_channel_type == SEC_CHAN_WKSTA)) {
1960                                         torture_assert_werr_equal(tctx, r.out.result, WERR_ACCESS_DENIED,
1961                                                 "LogonControl returned unexpected error code");
1962                                 } else {
1963                                         torture_assert_werr_ok(tctx, r.out.result,
1964                                                 "LogonControl returned unexpected result");
1965                                 }
1966                                 break;
1967                         default:
1968                                 torture_assert_werr_ok(tctx, r.out.result,
1969                                         "LogonControl returned unexpected result");
1970                                 break;
1971                         }
1972                         break;
1973                 case 2:
1974                         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1975                                 "LogonControl returned unexpected error code");
1976                         break;
1977                 default:
1978                         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
1979                                 "LogonControl returned unexpected error code");
1980                         break;
1981                 }
1982         }
1983         }
1984
1985         r.in.level = 52;
1986         torture_comment(tctx, "Testing LogonControl function code %s (%d) level %d\n",
1987                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
1988         status = dcerpc_netr_LogonControl_r(b, tctx, &r);
1989         torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1990         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_LEVEL, "LogonControl");
1991
1992         return true;
1993 }
1994
1995
1996 /*
1997   try a netlogon GetAnyDCName
1998 */
1999 static bool test_GetAnyDCName(struct torture_context *tctx,
2000                               struct dcerpc_pipe *p)
2001 {
2002         NTSTATUS status;
2003         struct netr_GetAnyDCName r;
2004         const char *dcname = NULL;
2005         struct dcerpc_binding_handle *b = p->binding_handle;
2006
2007         r.in.domainname = lpcfg_workgroup(tctx->lp_ctx);
2008         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2009         r.out.dcname = &dcname;
2010
2011         status = dcerpc_netr_GetAnyDCName_r(b, tctx, &r);
2012         torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
2013         if ((!W_ERROR_IS_OK(r.out.result)) &&
2014             (!W_ERROR_EQUAL(r.out.result, WERR_NO_SUCH_DOMAIN))) {
2015                 return false;
2016         }
2017
2018         if (dcname) {
2019             torture_comment(tctx, "\tDC is at '%s'\n", dcname);
2020         }
2021
2022         r.in.domainname = NULL;
2023
2024         status = dcerpc_netr_GetAnyDCName_r(b, tctx, &r);
2025         torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
2026         if ((!W_ERROR_IS_OK(r.out.result)) &&
2027             (!W_ERROR_EQUAL(r.out.result, WERR_NO_SUCH_DOMAIN))) {
2028                 return false;
2029         }
2030
2031         r.in.domainname = "";
2032
2033         status = dcerpc_netr_GetAnyDCName_r(b, tctx, &r);
2034         torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
2035         if ((!W_ERROR_IS_OK(r.out.result)) &&
2036             (!W_ERROR_EQUAL(r.out.result, WERR_NO_SUCH_DOMAIN))) {
2037                 return false;
2038         }
2039
2040         return true;
2041 }
2042
2043
2044 /*
2045   try a netlogon LogonControl2
2046 */
2047 static bool test_LogonControl2(struct torture_context *tctx,
2048                                struct dcerpc_pipe *p,
2049                                struct cli_credentials *machine_credentials)
2050
2051 {
2052         NTSTATUS status;
2053         struct netr_LogonControl2 r;
2054         union netr_CONTROL_DATA_INFORMATION data;
2055         union netr_CONTROL_QUERY_INFORMATION query;
2056         int i;
2057         struct dcerpc_binding_handle *b = p->binding_handle;
2058
2059         data.domain = lpcfg_workgroup(tctx->lp_ctx);
2060
2061         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2062
2063         r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
2064         r.in.data = &data;
2065         r.out.query = &query;
2066
2067         for (i=1;i<4;i++) {
2068                 r.in.level = i;
2069
2070                 torture_comment(tctx, "Testing LogonControl2 function code %s (%d) level %d\n",
2071                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
2072
2073                 status = dcerpc_netr_LogonControl2_r(b, tctx, &r);
2074                 torture_assert_ntstatus_ok(tctx, status, "LogonControl2");
2075         }
2076
2077         data.domain = lpcfg_workgroup(tctx->lp_ctx);
2078
2079         r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
2080         r.in.data = &data;
2081
2082         for (i=1;i<4;i++) {
2083                 r.in.level = i;
2084
2085                 torture_comment(tctx, "Testing LogonControl2 function code %s (%d) level %d\n",
2086                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
2087
2088                 status = dcerpc_netr_LogonControl2_r(b, tctx, &r);
2089                 torture_assert_ntstatus_ok(tctx, status, "LogonControl2");
2090         }
2091
2092         data.domain = lpcfg_workgroup(tctx->lp_ctx);
2093
2094         r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
2095         r.in.data = &data;
2096
2097         for (i=1;i<4;i++) {
2098                 r.in.level = i;
2099
2100                 torture_comment(tctx, "Testing LogonControl2 function code %s (%d) level %d\n",
2101                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
2102
2103                 status = dcerpc_netr_LogonControl2_r(b, tctx, &r);
2104                 torture_assert_ntstatus_ok(tctx, status, "LogonControl2");
2105         }
2106
2107         data.debug_level = ~0;
2108
2109         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
2110         r.in.data = &data;
2111
2112         for (i=1;i<4;i++) {
2113                 r.in.level = i;
2114
2115                 torture_comment(tctx, "Testing LogonControl2 function code %s (%d) level %d\n",
2116                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
2117
2118                 status = dcerpc_netr_LogonControl2_r(b, tctx, &r);
2119                 torture_assert_ntstatus_ok(tctx, status, "LogonControl2");
2120         }
2121
2122         ZERO_STRUCT(data);
2123         r.in.function_code = 52;
2124         r.in.data = &data;
2125
2126         torture_comment(tctx, "Testing LogonControl2 function code %s (%d) level %d\n",
2127                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
2128
2129         status = dcerpc_netr_LogonControl2_r(b, tctx, &r);
2130         torture_assert_ntstatus_ok(tctx, status, "LogonControl2");
2131         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "LogonControl2");
2132
2133         data.debug_level = ~0;
2134
2135         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
2136         r.in.data = &data;
2137
2138         r.in.level = 52;
2139         torture_comment(tctx, "Testing LogonControl2 function code %s (%d) level %d\n",
2140                         function_code_str(tctx, r.in.function_code), r.in.function_code, r.in.level);
2141
2142         status = dcerpc_netr_LogonControl2_r(b, tctx, &r);
2143         torture_assert_ntstatus_ok(tctx, status, "LogonControl2");
2144         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL, "LogonControl2");
2145
2146         return true;
2147 }
2148
2149 /*
2150   try a netlogon DatabaseSync2
2151 */
2152 static bool test_DatabaseSync2(struct torture_context *tctx,
2153                                struct dcerpc_pipe *p,
2154                                struct cli_credentials *machine_credentials)
2155 {
2156         struct netr_DatabaseSync2 r;
2157         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
2158         struct netr_Authenticator return_authenticator, credential;
2159
2160         struct netlogon_creds_CredentialState *creds;
2161         const uint32_t database_ids[] = {0, 1, 2};
2162         int i;
2163         struct dcerpc_binding_handle *b = p->binding_handle;
2164
2165         if (!test_SetupCredentials2(p, tctx, NETLOGON_NEG_AUTH2_FLAGS,
2166                                     machine_credentials,
2167                                     cli_credentials_get_secure_channel_type(machine_credentials),
2168                                     &creds)) {
2169                 return false;
2170         }
2171
2172         ZERO_STRUCT(return_authenticator);
2173
2174         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2175         r.in.computername = TEST_MACHINE_NAME;
2176         r.in.preferredmaximumlength = (uint32_t)-1;
2177         r.in.return_authenticator = &return_authenticator;
2178         r.out.return_authenticator = &return_authenticator;
2179         r.out.delta_enum_array = &delta_enum_array;
2180
2181         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
2182
2183                 uint32_t sync_context = 0;
2184
2185                 r.in.database_id = database_ids[i];
2186                 r.in.sync_context = &sync_context;
2187                 r.out.sync_context = &sync_context;
2188                 r.in.restart_state = 0;
2189
2190                 torture_comment(tctx, "Testing DatabaseSync2 of id %d\n", r.in.database_id);
2191
2192                 do {
2193                         netlogon_creds_client_authenticator(creds, &credential);
2194
2195                         r.in.credential = &credential;
2196
2197                         torture_assert_ntstatus_ok(tctx, dcerpc_netr_DatabaseSync2_r(b, tctx, &r),
2198                                 "DatabaseSync2 failed");
2199                         if (NT_STATUS_EQUAL(r.out.result, STATUS_MORE_ENTRIES))
2200                             break;
2201
2202                         /* Native mode servers don't do this */
2203                         if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_NOT_SUPPORTED)) {
2204                                 return true;
2205                         }
2206
2207                         torture_assert_ntstatus_ok(tctx, r.out.result, "DatabaseSync2");
2208
2209                         if (!netlogon_creds_client_check(creds, &r.out.return_authenticator->cred)) {
2210                                 torture_comment(tctx, "Credential chaining failed\n");
2211                         }
2212
2213                 } while (NT_STATUS_EQUAL(r.out.result, STATUS_MORE_ENTRIES));
2214         }
2215
2216         return true;
2217 }
2218
2219
2220 /*
2221   try a netlogon LogonControl2Ex
2222 */
2223 static bool test_LogonControl2Ex(struct torture_context *tctx,
2224                                  struct dcerpc_pipe *p,
2225                                  struct cli_credentials *machine_credentials)
2226
2227 {
2228         NTSTATUS status;
2229         struct netr_LogonControl2Ex r;
2230         union netr_CONTROL_DATA_INFORMATION data;
2231         union netr_CONTROL_QUERY_INFORMATION query;
2232         int i;
2233         struct dcerpc_binding_handle *b = p->binding_handle;
2234
2235         data.domain = lpcfg_workgroup(tctx->lp_ctx);
2236
2237         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2238
2239         r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
2240         r.in.data = &data;
2241         r.out.query = &query;
2242
2243         for (i=1;i<4;i++) {
2244                 r.in.level = i;
2245
2246                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n",
2247                        i, r.in.function_code);
2248
2249                 status = dcerpc_netr_LogonControl2Ex_r(b, tctx, &r);
2250                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
2251         }
2252
2253         data.domain = lpcfg_workgroup(tctx->lp_ctx);
2254
2255         r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
2256         r.in.data = &data;
2257
2258         for (i=1;i<4;i++) {
2259                 r.in.level = i;
2260
2261                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n",
2262                        i, r.in.function_code);
2263
2264                 status = dcerpc_netr_LogonControl2Ex_r(b, tctx, &r);
2265                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
2266         }
2267
2268         data.domain = lpcfg_workgroup(tctx->lp_ctx);
2269
2270         r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
2271         r.in.data = &data;
2272
2273         for (i=1;i<4;i++) {
2274                 r.in.level = i;
2275
2276                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n",
2277                        i, r.in.function_code);
2278
2279                 status = dcerpc_netr_LogonControl2Ex_r(b, tctx, &r);
2280                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
2281         }
2282
2283         data.debug_level = ~0;
2284
2285         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
2286         r.in.data = &data;
2287
2288         for (i=1;i<4;i++) {
2289                 r.in.level = i;
2290
2291                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n",
2292                        i, r.in.function_code);
2293
2294                 status = dcerpc_netr_LogonControl2Ex_r(b, tctx, &r);
2295                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
2296         }
2297
2298         return true;
2299 }
2300
2301 static bool test_netr_GetForestTrustInformation(struct torture_context *tctx,
2302                                                 struct dcerpc_pipe *p,
2303                                                 struct cli_credentials *machine_credentials)
2304 {
2305         struct netr_GetForestTrustInformation r;
2306         struct netlogon_creds_CredentialState *creds;
2307         struct netr_Authenticator a;
2308         struct netr_Authenticator return_authenticator;
2309         struct lsa_ForestTrustInformation *forest_trust_info;
2310         struct dcerpc_binding_handle *b = p->binding_handle;
2311
2312         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
2313                                     machine_credentials, &creds)) {
2314                 return false;
2315         }
2316
2317         netlogon_creds_client_authenticator(creds, &a);
2318
2319         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2320         r.in.computer_name = TEST_MACHINE_NAME;
2321         r.in.credential = &a;
2322         r.in.flags = 0;
2323         r.out.return_authenticator = &return_authenticator;
2324         r.out.forest_trust_info = &forest_trust_info;
2325
2326         torture_assert_ntstatus_ok(tctx,
2327                 dcerpc_netr_GetForestTrustInformation_r(b, tctx, &r),
2328                 "netr_GetForestTrustInformation failed");
2329         if (NT_STATUS_EQUAL(r.out.result, NT_STATUS_NOT_IMPLEMENTED)) {
2330                 torture_comment(tctx, "not considering NT_STATUS_NOT_IMPLEMENTED as an error\n");
2331         } else {
2332                 torture_assert_ntstatus_ok(tctx, r.out.result,
2333                         "netr_GetForestTrustInformation failed");
2334         }
2335
2336         torture_assert(tctx,
2337                 netlogon_creds_client_check(creds, &return_authenticator.cred),
2338                 "Credential chaining failed");
2339
2340         return true;
2341 }
2342
2343 static bool test_netr_DsRGetForestTrustInformation(struct torture_context *tctx,
2344                                                    struct dcerpc_pipe *p, const char *trusted_domain_name)
2345 {
2346         NTSTATUS status;
2347         struct netr_DsRGetForestTrustInformation r;
2348         struct lsa_ForestTrustInformation info, *info_ptr;
2349         struct dcerpc_binding_handle *b = p->binding_handle;
2350
2351         info_ptr = &info;
2352
2353         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2354         r.in.trusted_domain_name = trusted_domain_name;
2355         r.in.flags = 0;
2356         r.out.forest_trust_info = &info_ptr;
2357
2358         torture_comment(tctx ,"Testing netr_DsRGetForestTrustInformation\n");
2359
2360         status = dcerpc_netr_DsRGetForestTrustInformation_r(b, tctx, &r);
2361         torture_assert_ntstatus_ok(tctx, status, "DsRGetForestTrustInformation");
2362         torture_assert_werr_ok(tctx, r.out.result, "DsRGetForestTrustInformation");
2363
2364         return true;
2365 }
2366
2367 /*
2368   try a netlogon netr_DsrEnumerateDomainTrusts
2369 */
2370 static bool test_DsrEnumerateDomainTrusts(struct torture_context *tctx,
2371                                           struct dcerpc_pipe *p)
2372 {
2373         NTSTATUS status;
2374         struct netr_DsrEnumerateDomainTrusts r;
2375         struct netr_DomainTrustList trusts;
2376         int i;
2377         struct dcerpc_binding_handle *b = p->binding_handle;
2378
2379         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2380         r.in.trust_flags = 0x3f;
2381         r.out.trusts = &trusts;
2382
2383         status = dcerpc_netr_DsrEnumerateDomainTrusts_r(b, tctx, &r);
2384         torture_assert_ntstatus_ok(tctx, status, "DsrEnumerateDomaintrusts");
2385         torture_assert_werr_ok(tctx, r.out.result, "DsrEnumerateDomaintrusts");
2386
2387         /* when trusted_domain_name is NULL, netr_DsRGetForestTrustInformation
2388          * will show non-forest trusts and all UPN suffixes of the own forest
2389          * as LSA_FOREST_TRUST_TOP_LEVEL_NAME types */
2390
2391         if (r.out.trusts->count) {
2392                 if (!test_netr_DsRGetForestTrustInformation(tctx, p, NULL)) {
2393                         return false;
2394                 }
2395         }
2396
2397         for (i=0; i<r.out.trusts->count; i++) {
2398
2399                 /* get info for transitive forest trusts */
2400
2401                 if (r.out.trusts->array[i].trust_attributes & NETR_TRUST_ATTRIBUTE_FOREST_TRANSITIVE) {
2402                         if (!test_netr_DsRGetForestTrustInformation(tctx, p,
2403                                                                     r.out.trusts->array[i].dns_name)) {
2404                                 return false;
2405                         }
2406                 }
2407         }
2408
2409         return true;
2410 }
2411
2412 static bool test_netr_NetrEnumerateTrustedDomains(struct torture_context *tctx,
2413                                                   struct dcerpc_pipe *p)
2414 {
2415         NTSTATUS status;
2416         struct netr_NetrEnumerateTrustedDomains r;
2417         struct netr_Blob trusted_domains_blob;
2418         struct dcerpc_binding_handle *b = p->binding_handle;
2419
2420         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2421         r.out.trusted_domains_blob = &trusted_domains_blob;
2422
2423         status = dcerpc_netr_NetrEnumerateTrustedDomains_r(b, tctx, &r);
2424         torture_assert_ntstatus_ok(tctx, status, "netr_NetrEnumerateTrustedDomains");
2425         torture_assert_ntstatus_ok(tctx, r.out.result, "NetrEnumerateTrustedDomains");
2426
2427         return true;
2428 }
2429
2430 static bool test_netr_NetrEnumerateTrustedDomainsEx(struct torture_context *tctx,
2431                                                     struct dcerpc_pipe *p)
2432 {
2433         NTSTATUS status;
2434         struct netr_NetrEnumerateTrustedDomainsEx r;
2435         struct netr_DomainTrustList dom_trust_list;
2436         struct dcerpc_binding_handle *b = p->binding_handle;
2437
2438         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2439         r.out.dom_trust_list = &dom_trust_list;
2440
2441         status = dcerpc_netr_NetrEnumerateTrustedDomainsEx_r(b, tctx, &r);
2442         torture_assert_ntstatus_ok(tctx, status, "netr_NetrEnumerateTrustedDomainsEx");
2443         torture_assert_werr_ok(tctx, r.out.result, "NetrEnumerateTrustedDomainsEx");
2444
2445         return true;
2446 }
2447
2448
2449 static bool test_netr_DsRGetSiteName(struct dcerpc_pipe *p, struct torture_context *tctx,
2450                                      const char *computer_name,
2451                                      const char *expected_site)
2452 {
2453         NTSTATUS status;
2454         struct netr_DsRGetSiteName r;
2455         const char *site = NULL;
2456         struct dcerpc_binding_handle *b = p->binding_handle;
2457
2458         r.in.computer_name              = computer_name;
2459         r.out.site                      = &site;
2460         torture_comment(tctx, "Testing netr_DsRGetSiteName\n");
2461
2462         status = dcerpc_netr_DsRGetSiteName_r(b, tctx, &r);
2463         torture_assert_ntstatus_ok(tctx, status, "DsRGetSiteName");
2464         torture_assert_werr_ok(tctx, r.out.result, "DsRGetSiteName");
2465         torture_assert_str_equal(tctx, expected_site, site, "netr_DsRGetSiteName");
2466
2467         return true;
2468 }
2469
2470 /*
2471   try a netlogon netr_DsRGetDCName
2472 */
2473 static bool test_netr_DsRGetDCName(struct torture_context *tctx,
2474                                    struct dcerpc_pipe *p)
2475 {
2476         NTSTATUS status;
2477         struct netr_DsRGetDCName r;
2478         struct netr_DsRGetDCNameInfo *info = NULL;
2479         struct dcerpc_binding_handle *b = p->binding_handle;
2480
2481         r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2482         r.in.domain_name        = lpcfg_dnsdomain(tctx->lp_ctx);
2483         r.in.domain_guid        = NULL;
2484         r.in.site_guid          = NULL;
2485         r.in.flags              = DS_RETURN_DNS_NAME;
2486         r.out.info              = &info;
2487
2488         status = dcerpc_netr_DsRGetDCName_r(b, tctx, &r);
2489         torture_assert_ntstatus_ok(tctx, status, "DsRGetDCName");
2490         torture_assert_werr_ok(tctx, r.out.result, "DsRGetDCName");
2491
2492         torture_assert_int_equal(tctx,
2493                                  (info->dc_flags & (DS_DNS_CONTROLLER)),
2494                                  DS_DNS_CONTROLLER,
2495                                  "DsRGetDCName");
2496         torture_assert_int_equal(tctx,
2497                                  (info->dc_flags & (DS_DNS_DOMAIN)),
2498                                  DS_DNS_DOMAIN,
2499                                  "DsRGetDCName");
2500         torture_assert_int_equal(tctx,
2501                                  (info->dc_flags & (DS_DNS_FOREST_ROOT)),
2502                                  DS_DNS_FOREST_ROOT,
2503                                  "DsRGetDCName");
2504
2505         r.in.domain_name        = lpcfg_workgroup(tctx->lp_ctx);
2506         r.in.flags              = 0;
2507
2508         status = dcerpc_netr_DsRGetDCName_r(b, tctx, &r);
2509         torture_assert_ntstatus_ok(tctx, status, "DsRGetDCName");
2510         torture_assert_werr_ok(tctx, r.out.result, "DsRGetDCName");
2511
2512         torture_assert_int_equal(tctx,
2513                                  (info->dc_flags & (DS_DNS_CONTROLLER)), 0,
2514                                  "DsRGetDCName");
2515         torture_assert_int_equal(tctx,
2516                                  (info->dc_flags & (DS_DNS_DOMAIN)), 0,
2517                                  "DsRGetDCName");
2518         torture_assert_int_equal(tctx,
2519                                  (info->dc_flags & (DS_DNS_FOREST_ROOT)),
2520                                  DS_DNS_FOREST_ROOT,
2521                                  "DsRGetDCName");
2522
2523         if (strcasecmp(info->dc_site_name, info->client_site_name) == 0) {
2524                 torture_assert_int_equal(tctx,
2525                                          (info->dc_flags & (DS_SERVER_CLOSEST)),
2526                                          DS_SERVER_CLOSEST,
2527                                          "DsRGetDCName");
2528         }
2529
2530         return test_netr_DsRGetSiteName(p, tctx,
2531                                        info->dc_unc,
2532                                        info->dc_site_name);
2533 }
2534
2535 /*
2536   try a netlogon netr_DsRGetDCNameEx
2537 */
2538 static bool test_netr_DsRGetDCNameEx(struct torture_context *tctx,
2539                                      struct dcerpc_pipe *p)
2540 {
2541         NTSTATUS status;
2542         struct netr_DsRGetDCNameEx r;
2543         struct netr_DsRGetDCNameInfo *info = NULL;
2544         struct dcerpc_binding_handle *b = p->binding_handle;
2545
2546         r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2547         r.in.domain_name        = lpcfg_dnsdomain(tctx->lp_ctx);
2548         r.in.domain_guid        = NULL;
2549         r.in.site_name          = NULL;
2550         r.in.flags              = DS_RETURN_DNS_NAME;
2551         r.out.info              = &info;
2552
2553         status = dcerpc_netr_DsRGetDCNameEx_r(b, tctx, &r);
2554         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx");
2555         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx");
2556
2557         torture_assert_int_equal(tctx,
2558                                  (info->dc_flags & (DS_DNS_CONTROLLER)),
2559                                  DS_DNS_CONTROLLER,
2560                                  "DsRGetDCNameEx");
2561         torture_assert_int_equal(tctx,
2562                                  (info->dc_flags & (DS_DNS_DOMAIN)),
2563                                  DS_DNS_DOMAIN,
2564                                  "DsRGetDCNameEx");
2565         torture_assert_int_equal(tctx,
2566                                  (info->dc_flags & (DS_DNS_FOREST_ROOT)),
2567                                  DS_DNS_FOREST_ROOT,
2568                                  "DsRGetDCNameEx");
2569
2570         r.in.domain_name        = lpcfg_workgroup(tctx->lp_ctx);
2571         r.in.flags              = 0;
2572
2573         status = dcerpc_netr_DsRGetDCNameEx_r(b, tctx, &r);
2574         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx");
2575         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx");
2576
2577         torture_assert_int_equal(tctx,
2578                                  (info->dc_flags & (DS_DNS_CONTROLLER)), 0,
2579                                  "DsRGetDCNameEx");
2580         torture_assert_int_equal(tctx,
2581                                  (info->dc_flags & (DS_DNS_DOMAIN)), 0,
2582                                  "DsRGetDCNameEx");
2583         torture_assert_int_equal(tctx,
2584                                  (info->dc_flags & (DS_DNS_FOREST_ROOT)),
2585                                  DS_DNS_FOREST_ROOT,
2586                                  "DsRGetDCNameEx");
2587
2588         if (strcasecmp(info->dc_site_name, info->client_site_name) == 0) {
2589                 torture_assert_int_equal(tctx,
2590                                          (info->dc_flags & (DS_SERVER_CLOSEST)),
2591                                          DS_SERVER_CLOSEST,
2592                                          "DsRGetDCNameEx");
2593         }
2594
2595         return test_netr_DsRGetSiteName(p, tctx, info->dc_unc,
2596                                         info->dc_site_name);
2597 }
2598
2599 /*
2600   try a netlogon netr_DsRGetDCNameEx2
2601 */
2602 static bool test_netr_DsRGetDCNameEx2(struct torture_context *tctx,
2603                                       struct dcerpc_pipe *p)
2604 {
2605         NTSTATUS status;
2606         struct netr_DsRGetDCNameEx2 r;
2607         struct netr_DsRGetDCNameInfo *info = NULL;
2608         struct dcerpc_binding_handle *b = p->binding_handle;
2609
2610         torture_comment(tctx, "Testing netr_DsRGetDCNameEx2 with no inputs\n");
2611         ZERO_STRUCT(r.in);
2612         r.in.flags              = DS_RETURN_DNS_NAME;
2613         r.out.info              = &info;
2614
2615         status = dcerpc_netr_DsRGetDCNameEx2_r(b, tctx, &r);
2616         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
2617         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
2618
2619         torture_assert_int_equal(tctx,
2620                                  (info->dc_flags & (DS_DNS_CONTROLLER)),
2621                                  DS_DNS_CONTROLLER,
2622                                  "DsRGetDCNameEx2");
2623         torture_assert_int_equal(tctx,
2624                                  (info->dc_flags & (DS_DNS_DOMAIN)),
2625                                  DS_DNS_DOMAIN,
2626                                  "DsRGetDCNameEx2");
2627         torture_assert_int_equal(tctx,
2628                                  (info->dc_flags & (DS_DNS_FOREST_ROOT)),
2629                                  DS_DNS_FOREST_ROOT,
2630                                  "DsRGetDCNameEx2");
2631
2632         r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2633         r.in.client_account     = NULL;
2634         r.in.mask               = 0x00000000;
2635         r.in.domain_name        = lpcfg_dnsdomain(tctx->lp_ctx);
2636         r.in.domain_guid        = NULL;
2637         r.in.site_name          = NULL;
2638         r.in.flags              = DS_RETURN_DNS_NAME;
2639         r.out.info              = &info;
2640
2641         torture_comment(tctx, "Testing netr_DsRGetDCNameEx2 without client account\n");
2642
2643         status = dcerpc_netr_DsRGetDCNameEx2_r(b, tctx, &r);
2644         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
2645         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
2646
2647         r.in.domain_name        = lpcfg_workgroup(tctx->lp_ctx);
2648         r.in.flags              = 0;
2649
2650         status = dcerpc_netr_DsRGetDCNameEx2_r(b, tctx, &r);
2651         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
2652         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
2653
2654         torture_assert_int_equal(tctx,
2655                                  (info->dc_flags & (DS_DNS_CONTROLLER)), 0,
2656                                  "DsRGetDCNameEx2");
2657         torture_assert_int_equal(tctx,
2658                                  (info->dc_flags & (DS_DNS_DOMAIN)), 0,
2659                                  "DsRGetDCNameEx2");
2660         torture_assert_int_equal(tctx,
2661                                  (info->dc_flags & (DS_DNS_FOREST_ROOT)),
2662                                  DS_DNS_FOREST_ROOT,
2663                                  "DsRGetDCNameEx2");
2664
2665         if (strcasecmp(info->dc_site_name, info->client_site_name) == 0) {
2666                 torture_assert_int_equal(tctx,
2667                                          (info->dc_flags & (DS_SERVER_CLOSEST)),
2668                                          DS_SERVER_CLOSEST,
2669                                          "DsRGetDCNameEx2");
2670         }
2671
2672         torture_comment(tctx, "Testing netr_DsRGetDCNameEx2 with client account\n");
2673         r.in.client_account     = TEST_MACHINE_NAME"$";
2674         r.in.mask               = ACB_SVRTRUST;
2675         r.in.flags              = DS_RETURN_FLAT_NAME;
2676         r.out.info              = &info;
2677
2678         status = dcerpc_netr_DsRGetDCNameEx2_r(b, tctx, &r);
2679         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
2680         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
2681
2682         return test_netr_DsRGetSiteName(p, tctx, info->dc_unc,
2683                                         info->dc_site_name);
2684 }
2685
2686 /* This is a substitution for "samdb_server_site_name" which relies on the
2687  * correct "lp_ctx" and therefore can't be used here. */
2688 static const char *server_site_name(struct torture_context *tctx,
2689                                     struct ldb_context *ldb)
2690 {
2691         TALLOC_CTX *tmp_ctx;
2692         struct ldb_dn *dn, *server_dn;
2693         const struct ldb_val *site_name_val;
2694         const char *server_dn_str, *site_name;
2695
2696         tmp_ctx = talloc_new(ldb);
2697         if (tmp_ctx == NULL) {
2698                 goto failed;
2699         }
2700
2701         dn = ldb_dn_new(tmp_ctx, ldb, "");
2702         if (dn == NULL) {
2703                 goto failed;
2704         }
2705
2706         server_dn_str = samdb_search_string(ldb, tmp_ctx, dn, "serverName",
2707                                             NULL);
2708         if (server_dn_str == NULL) {
2709                 goto failed;
2710         }
2711
2712         server_dn = ldb_dn_new(tmp_ctx, ldb, server_dn_str);
2713         if (server_dn == NULL) {
2714                 goto failed;
2715         }
2716
2717         /* CN=<Server name>, CN=Servers, CN=<Site name>, CN=Sites, ... */
2718         site_name_val = ldb_dn_get_component_val(server_dn, 2);
2719         if (site_name_val == NULL) {
2720                 goto failed;
2721         }
2722
2723         site_name = (const char *) site_name_val->data;
2724
2725         talloc_steal(tctx, site_name);
2726         talloc_free(tmp_ctx);
2727
2728         return site_name;
2729
2730 failed:
2731         talloc_free(tmp_ctx);
2732         return NULL;
2733 }
2734
2735 static bool test_netr_DsrGetDcSiteCoverageW(struct torture_context *tctx,
2736                                             struct dcerpc_pipe *p)
2737 {
2738         char *url;
2739         struct ldb_context *sam_ctx = NULL;
2740         NTSTATUS status;
2741         struct netr_DsrGetDcSiteCoverageW r;
2742         struct DcSitesCtr *ctr = NULL;
2743         struct dcerpc_binding_handle *b = p->binding_handle;
2744
2745         torture_comment(tctx, "This does only pass with the default site\n");
2746
2747         /* We won't double-check this when we are over 'local' transports */
2748         if (dcerpc_server_name(p)) {
2749                 /* Set up connection to SAMDB on DC */
2750                 url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
2751                 sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
2752                                            NULL,
2753                                            cmdline_credentials,
2754                                            0);
2755
2756                 torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
2757         }
2758
2759         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2760         r.out.ctr = &ctr;
2761
2762         status = dcerpc_netr_DsrGetDcSiteCoverageW_r(b, tctx, &r);
2763         torture_assert_ntstatus_ok(tctx, status, "failed");
2764         torture_assert_werr_ok(tctx, r.out.result, "failed");
2765
2766         torture_assert(tctx, ctr->num_sites == 1,
2767                        "we should per default only get the default site");
2768         if (sam_ctx != NULL) {
2769                 torture_assert_casestr_equal(tctx, ctr->sites[0].string,
2770                                              server_site_name(tctx, sam_ctx),
2771                                              "didn't return default site");
2772         }
2773
2774         return true;
2775 }
2776
2777 static bool test_netr_DsRAddressToSitenamesW(struct torture_context *tctx,
2778                                              struct dcerpc_pipe *p)
2779 {
2780         char *url;
2781         struct ldb_context *sam_ctx = NULL;
2782         NTSTATUS status;
2783         struct netr_DsRAddressToSitenamesW r;
2784         struct netr_DsRAddress addrs[6];
2785         struct sockaddr_in *addr;
2786 #ifdef HAVE_IPV6
2787         struct sockaddr_in6 *addr6;
2788 #endif
2789         struct netr_DsRAddressToSitenamesWCtr *ctr;
2790         struct dcerpc_binding_handle *b = p->binding_handle;
2791         uint32_t i;
2792         int ret;
2793
2794         torture_comment(tctx, "This does only pass with the default site\n");
2795
2796         /* We won't double-check this when we are over 'local' transports */
2797         if (dcerpc_server_name(p)) {
2798                 /* Set up connection to SAMDB on DC */
2799                 url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
2800                 sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
2801                                            NULL,
2802                                            cmdline_credentials,
2803                                            0);
2804
2805                 torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
2806         }
2807
2808         /* First try valid IP addresses */
2809
2810         addrs[0].size = sizeof(struct sockaddr_in);
2811         addrs[0].buffer = talloc_zero_array(tctx, uint8_t, addrs[0].size);
2812         addr = (struct sockaddr_in *) addrs[0].buffer;
2813         addrs[0].buffer[0] = AF_INET;
2814         ret = inet_pton(AF_INET, "127.0.0.1", &addr->sin_addr);
2815         torture_assert(tctx, ret > 0, "inet_pton failed");
2816
2817         addrs[1].size = sizeof(struct sockaddr_in);
2818         addrs[1].buffer = talloc_zero_array(tctx, uint8_t, addrs[1].size);
2819         addr = (struct sockaddr_in *) addrs[1].buffer;
2820         addrs[1].buffer[0] = AF_INET;
2821         ret = inet_pton(AF_INET, "0.0.0.0", &addr->sin_addr);
2822         torture_assert(tctx, ret > 0, "inet_pton failed");
2823
2824         addrs[2].size = sizeof(struct sockaddr_in);
2825         addrs[2].buffer = talloc_zero_array(tctx, uint8_t, addrs[2].size);
2826         addr = (struct sockaddr_in *) addrs[2].buffer;
2827         addrs[2].buffer[0] = AF_INET;
2828         ret = inet_pton(AF_INET, "255.255.255.255", &addr->sin_addr);
2829         torture_assert(tctx, ret > 0, "inet_pton failed");
2830
2831 #ifdef HAVE_IPV6
2832         addrs[3].size = sizeof(struct sockaddr_in6);
2833         addrs[3].buffer = talloc_zero_array(tctx, uint8_t, addrs[3].size);
2834         addr6 = (struct sockaddr_in6 *) addrs[3].buffer;
2835         addrs[3].buffer[0] = AF_INET6;
2836         ret = inet_pton(AF_INET6, "::1", &addr6->sin6_addr);
2837         torture_assert(tctx, ret > 0, "inet_pton failed");
2838
2839         addrs[4].size = sizeof(struct sockaddr_in6);
2840         addrs[4].buffer = talloc_zero_array(tctx, uint8_t, addrs[4].size);
2841         addr6 = (struct sockaddr_in6 *) addrs[4].buffer;
2842         addrs[4].buffer[0] = AF_INET6;
2843         ret = inet_pton(AF_INET6, "::", &addr6->sin6_addr);
2844         torture_assert(tctx, ret > 0, "inet_pton failed");
2845
2846         addrs[5].size = sizeof(struct sockaddr_in6);
2847         addrs[5].buffer = talloc_zero_array(tctx, uint8_t, addrs[5].size);
2848         addr6 = (struct sockaddr_in6 *) addrs[5].buffer;
2849         addrs[5].buffer[0] = AF_INET6;
2850         ret = inet_pton(AF_INET6, "ff02::1", &addr6->sin6_addr);
2851         torture_assert(tctx, ret > 0, "inet_pton failed");
2852 #else
2853         /* the test cases are repeated to have exactly 6. This is for
2854          * compatibility with IPv4-only machines */
2855         addrs[3].size = sizeof(struct sockaddr_in);
2856         addrs[3].buffer = talloc_zero_array(tctx, uint8_t, addrs[3].size);
2857         addr = (struct sockaddr_in *) addrs[3].buffer;
2858         addrs[3].buffer[0] = AF_INET;
2859         ret = inet_pton(AF_INET, "127.0.0.1", &addr->sin_addr);
2860         torture_assert(tctx, ret > 0, "inet_pton failed");
2861
2862         addrs[4].size = sizeof(struct sockaddr_in);
2863         addrs[4].buffer = talloc_zero_array(tctx, uint8_t, addrs[4].size);
2864         addr = (struct sockaddr_in *) addrs[4].buffer;
2865         addrs[4].buffer[0] = AF_INET;
2866         ret = inet_pton(AF_INET, "0.0.0.0", &addr->sin_addr);
2867         torture_assert(tctx, ret > 0, "inet_pton failed");
2868
2869         addrs[5].size = sizeof(struct sockaddr_in);
2870         addrs[5].buffer = talloc_zero_array(tctx, uint8_t, addrs[5].size);
2871         addr = (struct sockaddr_in *) addrs[5].buffer;
2872         addrs[5].buffer[0] = AF_INET;
2873         ret = inet_pton(AF_INET, "255.255.255.255", &addr->sin_addr);
2874         torture_assert(tctx, ret > 0, "inet_pton failed");
2875 #endif
2876
2877         ctr = talloc(tctx, struct netr_DsRAddressToSitenamesWCtr);
2878
2879         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2880         r.in.count = 6;
2881         r.in.addresses = addrs;
2882         r.out.ctr = &ctr;
2883
2884         status = dcerpc_netr_DsRAddressToSitenamesW_r(b, tctx, &r);
2885         torture_assert_ntstatus_ok(tctx, status, "failed");
2886         torture_assert_werr_ok(tctx, r.out.result, "failed");
2887
2888         if (sam_ctx != NULL) {
2889                 for (i = 0; i < 3; i++) {
2890                         torture_assert_casestr_equal(tctx,
2891                                                      ctr->sitename[i].string,
2892                                                      server_site_name(tctx, sam_ctx),
2893                                                      "didn't return default site");
2894                 }
2895                 for (i = 3; i < 6; i++) {
2896                         /* Windows returns "NULL" for the sitename if it isn't
2897                          * IPv6 configured */
2898                         if (torture_setting_bool(tctx, "samba4", false)) {
2899                                 torture_assert_casestr_equal(tctx,
2900                                                              ctr->sitename[i].string,
2901                                                              server_site_name(tctx, sam_ctx),
2902                                                              "didn't return default site");
2903                         }
2904                 }
2905         }
2906
2907         /* Now try invalid ones (too short buffers) */
2908
2909         addrs[0].size = 0;
2910         addrs[1].size = 1;
2911         addrs[2].size = 4;
2912
2913         addrs[3].size = 0;
2914         addrs[4].size = 1;
2915         addrs[5].size = 4;
2916
2917         status = dcerpc_netr_DsRAddressToSitenamesW_r(b, tctx, &r);
2918         torture_assert_ntstatus_ok(tctx, status, "failed");
2919         torture_assert_werr_ok(tctx, r.out.result, "failed");
2920
2921         for (i = 0; i < 6; i++) {
2922                 torture_assert(tctx, ctr->sitename[i].string == NULL,
2923                                "sitename should be null");
2924         }
2925
2926         /* Now try invalid ones (wrong address types) */
2927
2928         addrs[0].size = 10;
2929         addrs[0].buffer[0] = AF_UNSPEC;
2930         addrs[1].size = 10;
2931         addrs[1].buffer[0] = AF_UNIX; /* AF_LOCAL = AF_UNIX */
2932         addrs[2].size = 10;
2933         addrs[2].buffer[0] = AF_UNIX;
2934
2935         addrs[3].size = 10;
2936         addrs[3].buffer[0] = 250;
2937         addrs[4].size = 10;
2938         addrs[4].buffer[0] = 251;
2939         addrs[5].size = 10;
2940         addrs[5].buffer[0] = 252;
2941
2942         status = dcerpc_netr_DsRAddressToSitenamesW_r(b, tctx, &r);
2943         torture_assert_ntstatus_ok(tctx, status, "failed");
2944         torture_assert_werr_ok(tctx, r.out.result, "failed");
2945
2946         for (i = 0; i < 6; i++) {
2947                 torture_assert(tctx, ctr->sitename[i].string == NULL,
2948                                "sitename should be null");
2949         }
2950
2951         return true;
2952 }
2953
2954 static bool test_netr_DsRAddressToSitenamesExW(struct torture_context *tctx,
2955                                                struct dcerpc_pipe *p)
2956 {
2957         char *url;
2958         struct ldb_context *sam_ctx = NULL;
2959         NTSTATUS status;
2960         struct netr_DsRAddressToSitenamesExW r;
2961         struct netr_DsRAddress addrs[6];
2962         struct sockaddr_in *addr;
2963 #ifdef HAVE_IPV6
2964         struct sockaddr_in6 *addr6;
2965 #endif
2966         struct netr_DsRAddressToSitenamesExWCtr *ctr;
2967         struct dcerpc_binding_handle *b = p->binding_handle;
2968         uint32_t i;
2969         int ret;
2970
2971         torture_comment(tctx, "This does pass with the default site\n");
2972
2973         /* We won't double-check this when we are over 'local' transports */
2974         if (dcerpc_server_name(p)) {
2975                 /* Set up connection to SAMDB on DC */
2976                 url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
2977                 sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
2978                                            NULL,
2979                                            cmdline_credentials,
2980                                            0);
2981
2982                 torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
2983         }
2984
2985         /* First try valid IP addresses */
2986
2987         addrs[0].size = sizeof(struct sockaddr_in);
2988         addrs[0].buffer = talloc_zero_array(tctx, uint8_t, addrs[0].size);
2989         addr = (struct sockaddr_in *) addrs[0].buffer;
2990         addrs[0].buffer[0] = AF_INET;
2991         ret = inet_pton(AF_INET, "127.0.0.1", &addr->sin_addr);
2992         torture_assert(tctx, ret > 0, "inet_pton failed");
2993
2994         addrs[1].size = sizeof(struct sockaddr_in);
2995         addrs[1].buffer = talloc_zero_array(tctx, uint8_t, addrs[1].size);
2996         addr = (struct sockaddr_in *) addrs[1].buffer;
2997         addrs[1].buffer[0] = AF_INET;
2998         ret = inet_pton(AF_INET, "0.0.0.0", &addr->sin_addr);
2999         torture_assert(tctx, ret > 0, "inet_pton failed");
3000
3001         addrs[2].size = sizeof(struct sockaddr_in);
3002         addrs[2].buffer = talloc_zero_array(tctx, uint8_t, addrs[2].size);
3003         addr = (struct sockaddr_in *) addrs[2].buffer;
3004         addrs[2].buffer[0] = AF_INET;
3005         ret = inet_pton(AF_INET, "255.255.255.255", &addr->sin_addr);
3006         torture_assert(tctx, ret > 0, "inet_pton failed");
3007
3008 #ifdef HAVE_IPV6
3009         addrs[3].size = sizeof(struct sockaddr_in6);
3010         addrs[3].buffer = talloc_zero_array(tctx, uint8_t, addrs[3].size);
3011         addr6 = (struct sockaddr_in6 *) addrs[3].buffer;
3012         addrs[3].buffer[0] = AF_INET6;
3013         ret = inet_pton(AF_INET6, "::1", &addr6->sin6_addr);
3014         torture_assert(tctx, ret > 0, "inet_pton failed");
3015
3016         addrs[4].size = sizeof(struct sockaddr_in6);
3017         addrs[4].buffer = talloc_zero_array(tctx, uint8_t, addrs[4].size);
3018         addr6 = (struct sockaddr_in6 *) addrs[4].buffer;
3019         addrs[4].buffer[0] = AF_INET6;
3020         ret = inet_pton(AF_INET6, "::", &addr6->sin6_addr);
3021         torture_assert(tctx, ret > 0, "inet_pton failed");
3022
3023         addrs[5].size = sizeof(struct sockaddr_in6);
3024         addrs[5].buffer = talloc_zero_array(tctx, uint8_t, addrs[5].size);
3025         addr6 = (struct sockaddr_in6 *) addrs[5].buffer;
3026         addrs[5].buffer[0] = AF_INET6;
3027         ret = inet_pton(AF_INET6, "ff02::1", &addr6->sin6_addr);
3028         torture_assert(tctx, ret > 0, "inet_pton failed");
3029 #else
3030         /* the test cases are repeated to have exactly 6. This is for
3031          * compatibility with IPv4-only machines */
3032         addrs[3].size = sizeof(struct sockaddr_in);
3033         addrs[3].buffer = talloc_zero_array(tctx, uint8_t, addrs[3].size);
3034         addr = (struct sockaddr_in *) addrs[3].buffer;
3035         addrs[3].buffer[0] = AF_INET;
3036         ret = inet_pton(AF_INET, "127.0.0.1", &addr->sin_addr);
3037         torture_assert(tctx, ret > 0, "inet_pton failed");
3038
3039         addrs[4].size = sizeof(struct sockaddr_in);
3040         addrs[4].buffer = talloc_zero_array(tctx, uint8_t, addrs[4].size);
3041         addr = (struct sockaddr_in *) addrs[4].buffer;
3042         addrs[4].buffer[0] = AF_INET;
3043         ret = inet_pton(AF_INET, "0.0.0.0", &addr->sin_addr);
3044         torture_assert(tctx, ret > 0, "inet_pton failed");
3045
3046         addrs[5].size = sizeof(struct sockaddr_in);
3047         addrs[5].buffer = talloc_zero_array(tctx, uint8_t, addrs[5].size);
3048         addr = (struct sockaddr_in *) addrs[5].buffer;
3049         addrs[5].buffer[0] = AF_INET;
3050         ret = inet_pton(AF_INET, "255.255.255.255", &addr->sin_addr);
3051         torture_assert(tctx, ret > 0, "inet_pton failed");
3052 #endif
3053
3054         ctr = talloc(tctx, struct netr_DsRAddressToSitenamesExWCtr);
3055
3056         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
3057         r.in.count = 6;
3058         r.in.addresses = addrs;
3059         r.out.ctr = &ctr;
3060
3061         status = dcerpc_netr_DsRAddressToSitenamesExW_r(b, tctx, &r);
3062         torture_assert_ntstatus_ok(tctx, status, "failed");
3063         torture_assert_werr_ok(tctx, r.out.result, "failed");
3064
3065         if (sam_ctx != NULL) {
3066                 for (i = 0; i < 3; i++) {
3067                         torture_assert_casestr_equal(tctx,
3068                                                      ctr->sitename[i].string,
3069                                                      server_site_name(tctx, sam_ctx),
3070                                                      "didn't return default site");
3071                         torture_assert(tctx, ctr->subnetname[i].string == NULL,
3072                                        "subnet should be null");
3073                 }
3074                 for (i = 3; i < 6; i++) {
3075                         /* Windows returns "NULL" for the sitename if it isn't
3076                          * IPv6 configured */
3077                         if (torture_setting_bool(tctx, "samba4", false)) {
3078                                 torture_assert_casestr_equal(tctx,
3079                                                              ctr->sitename[i].string,
3080                                                              server_site_name(tctx, sam_ctx),
3081                                                              "didn't return default site");
3082                         }
3083                         torture_assert(tctx, ctr->subnetname[i].string == NULL,
3084                                        "subnet should be null");
3085                 }
3086         }
3087
3088         /* Now try invalid ones (too short buffers) */
3089
3090         addrs[0].size = 0;
3091         addrs[1].size = 1;
3092         addrs[2].size = 4;
3093
3094         addrs[3].size = 0;
3095         addrs[4].size = 1;
3096         addrs[5].size = 4;
3097
3098         status = dcerpc_netr_DsRAddressToSitenamesExW_r(b, tctx, &r);
3099         torture_assert_ntstatus_ok(tctx, status, "failed");
3100         torture_assert_werr_ok(tctx, r.out.result, "failed");
3101
3102         for (i = 0; i < 6; i++) {
3103                 torture_assert(tctx, ctr->sitename[i].string == NULL,
3104                                "sitename should be null");
3105                 torture_assert(tctx, ctr->subnetname[i].string == NULL,
3106                                "subnet should be null");
3107         }
3108
3109         addrs[0].size = 10;
3110         addrs[0].buffer[0] = AF_UNSPEC;
3111         addrs[1].size = 10;
3112         addrs[1].buffer[0] = AF_UNIX; /* AF_LOCAL = AF_UNIX */
3113         addrs[2].size = 10;
3114         addrs[2].buffer[0] = AF_UNIX;
3115
3116         addrs[3].size = 10;
3117         addrs[3].buffer[0] = 250;
3118         addrs[4].size = 10;
3119         addrs[4].buffer[0] = 251;
3120         addrs[5].size = 10;
3121         addrs[5].buffer[0] = 252;
3122
3123         status = dcerpc_netr_DsRAddressToSitenamesExW_r(b, tctx, &r);
3124         torture_assert_ntstatus_ok(tctx, status, "failed");
3125         torture_assert_werr_ok(tctx, r.out.result, "failed");
3126
3127         for (i = 0; i < 6; i++) {
3128                 torture_assert(tctx, ctr->sitename[i].string == NULL,
3129                                "sitename should be null");
3130                 torture_assert(tctx, ctr->subnetname[i].string == NULL,
3131                                "subnet should be null");
3132         }
3133
3134         return true;
3135 }
3136
3137 static bool test_netr_ServerGetTrustInfo(struct torture_context *tctx,
3138                                          struct dcerpc_pipe *p,
3139                                          struct cli_credentials *machine_credentials)
3140 {
3141         struct netr_ServerGetTrustInfo r;
3142
3143         struct netr_Authenticator a;
3144         struct netr_Authenticator return_authenticator;
3145         struct samr_Password new_owf_password;
3146         struct samr_Password old_owf_password;
3147         struct netr_TrustInfo *trust_info;
3148
3149         struct netlogon_creds_CredentialState *creds;
3150         struct dcerpc_binding_handle *b = p->binding_handle;
3151
3152         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
3153                                     machine_credentials, &creds)) {
3154                 return false;
3155         }
3156
3157         netlogon_creds_client_authenticator(creds, &a);
3158
3159         r.in.server_name                = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
3160         r.in.account_name               = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
3161         r.in.secure_channel_type        = cli_credentials_get_secure_channel_type(machine_credentials);
3162         r.in.computer_name              = TEST_MACHINE_NAME;
3163         r.in.credential                 = &a;
3164
3165         r.out.return_authenticator      = &return_authenticator;
3166         r.out.new_owf_password          = &new_owf_password;
3167         r.out.old_owf_password          = &old_owf_password;
3168         r.out.trust_info                = &trust_info;
3169
3170         torture_assert_ntstatus_ok(tctx, dcerpc_netr_ServerGetTrustInfo_r(b, tctx, &r),
3171                 "ServerGetTrustInfo failed");
3172         torture_assert_ntstatus_ok(tctx, r.out.result, "ServerGetTrustInfo failed");
3173         torture_assert(tctx, netlogon_creds_client_check(creds, &return_authenticator.cred), "Credential chaining failed");
3174
3175         return true;
3176 }
3177
3178
3179 static bool test_GetDomainInfo(struct torture_context *tctx,
3180                                struct dcerpc_pipe *p,
3181                                struct cli_credentials *machine_credentials)
3182 {
3183         struct netr_LogonGetDomainInfo r;
3184         struct netr_WorkstationInformation q1;
3185         struct netr_Authenticator a;
3186         struct netlogon_creds_CredentialState *creds;
3187         struct netr_OsVersion os;
3188         union netr_WorkstationInfo query;
3189         union netr_DomainInfo info;
3190         const char* const attrs[] = { "dNSHostName", "operatingSystem",
3191                 "operatingSystemServicePack", "operatingSystemVersion",
3192                 "servicePrincipalName", NULL };
3193         char *url;
3194         struct ldb_context *sam_ctx = NULL;
3195         struct ldb_message **res;
3196         struct ldb_message_element *spn_el;
3197         int ret, i;
3198         char *version_str;
3199         const char *old_dnsname = NULL;
3200         char **spns = NULL;
3201         int num_spns = 0;
3202         char *temp_str;
3203         struct dcerpc_binding_handle *b = p->binding_handle;
3204
3205         torture_comment(tctx, "Testing netr_LogonGetDomainInfo\n");
3206
3207         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
3208                                     machine_credentials, &creds)) {
3209                 return false;
3210         }
3211
3212         /* We won't double-check this when we are over 'local' transports */
3213         if (dcerpc_server_name(p)) {
3214                 /* Set up connection to SAMDB on DC */
3215                 url = talloc_asprintf(tctx, "ldap://%s", dcerpc_server_name(p));
3216                 sam_ctx = ldb_wrap_connect(tctx, tctx->ev, tctx->lp_ctx, url,
3217                                            NULL,
3218                                            cmdline_credentials,
3219                                            0);
3220
3221                 torture_assert(tctx, sam_ctx, "Connection to the SAMDB on DC failed!");
3222         }
3223
3224         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 1st call (no variation of DNS hostname)\n");
3225         netlogon_creds_client_authenticator(creds, &a);
3226
3227         ZERO_STRUCT(r);
3228         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
3229         r.in.computer_name = TEST_MACHINE_NAME;
3230         r.in.credential = &a;
3231         r.in.level = 1;
3232         r.in.return_authenticator = &a;
3233         r.in.query = &query;
3234         r.out.return_authenticator = &a;
3235         r.out.info = &info;
3236
3237         ZERO_STRUCT(os);
3238         os.os.MajorVersion = 123;
3239         os.os.MinorVersion = 456;
3240         os.os.BuildNumber = 789;
3241         os.os.CSDVersion = "Service Pack 10";
3242         os.os.ServicePackMajor = 10;
3243         os.os.ServicePackMinor = 1;
3244         os.os.SuiteMask = NETR_VER_SUITE_SINGLEUSERTS;
3245         os.os.ProductType = NETR_VER_NT_SERVER;
3246         os.os.Reserved = 0;
3247
3248         version_str = talloc_asprintf(tctx, "%d.%d (%d)", os.os.MajorVersion,
3249                 os.os.MinorVersion, os.os.BuildNumber);
3250
3251         ZERO_STRUCT(q1);
3252         q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
3253                 lpcfg_dnsdomain(tctx->lp_ctx));
3254         q1.sitename = "Default-First-Site-Name";
3255         q1.os_version.os = &os;
3256         q1.os_name.string = talloc_asprintf(tctx,
3257                                             "Tortured by Samba4 RPC-NETLOGON: %s",
3258                                             timestring(tctx, time(NULL)));
3259
3260         /* The workstation handles the "servicePrincipalName" and DNS hostname
3261            updates */
3262         q1.workstation_flags = NETR_WS_FLAG_HANDLES_SPN_UPDATE;
3263
3264         query.workstation_info = &q1;
3265
3266         if (sam_ctx) {
3267                 /* Gets back the old DNS hostname in AD */
3268                 ret = gendb_search(sam_ctx, tctx, NULL, &res, attrs,
3269                                    "(sAMAccountName=%s$)", TEST_MACHINE_NAME);
3270                 old_dnsname =
3271                         ldb_msg_find_attr_as_string(res[0], "dNSHostName", NULL);
3272
3273                 /* Gets back the "servicePrincipalName"s in AD */
3274                 spn_el = ldb_msg_find_element(res[0], "servicePrincipalName");
3275                 if (spn_el != NULL) {
3276                         for (i=0; i < spn_el->num_values; i++) {
3277                                 spns = talloc_realloc(tctx, spns, char *, i + 1);
3278                                 spns[i] = (char *) spn_el->values[i].data;
3279                         }
3280                         num_spns = i;
3281                 }
3282         }
3283
3284         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3285                 "LogonGetDomainInfo failed");
3286         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3287         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3288
3289         smb_msleep(250);
3290
3291         if (sam_ctx) {
3292                 /* AD workstation infos entry check */
3293                 ret = gendb_search(sam_ctx, tctx, NULL, &res, attrs,
3294                                    "(sAMAccountName=%s$)", TEST_MACHINE_NAME);
3295                 torture_assert(tctx, ret == 1, "Test machine account not found in SAMDB on DC! Has the workstation been joined?");
3296                 torture_assert_str_equal(tctx,
3297                                          ldb_msg_find_attr_as_string(res[0], "operatingSystem", NULL),
3298                                          q1.os_name.string, "'operatingSystem' wrong!");
3299                 torture_assert_str_equal(tctx,
3300                                          ldb_msg_find_attr_as_string(res[0], "operatingSystemServicePack", NULL),
3301                                          os.os.CSDVersion, "'operatingSystemServicePack' wrong!");
3302                 torture_assert_str_equal(tctx,
3303                                          ldb_msg_find_attr_as_string(res[0], "operatingSystemVersion", NULL),
3304                                          version_str, "'operatingSystemVersion' wrong!");
3305
3306                 if (old_dnsname != NULL) {
3307                         /* If before a DNS hostname was set then it should remain
3308                            the same in combination with the "servicePrincipalName"s.
3309                            The DNS hostname should also be returned by our
3310                            "LogonGetDomainInfo" call (in the domain info structure). */
3311
3312                         torture_assert_str_equal(tctx,
3313                                                  ldb_msg_find_attr_as_string(res[0], "dNSHostName", NULL),
3314                                                  old_dnsname, "'DNS hostname' was not set!");
3315
3316                         spn_el = ldb_msg_find_element(res[0], "servicePrincipalName");
3317                         torture_assert(tctx, ((spns != NULL) && (spn_el != NULL)),
3318                                        "'servicePrincipalName's not set!");
3319                         torture_assert(tctx, spn_el->num_values == num_spns,
3320                                        "'servicePrincipalName's incorrect!");
3321                         for (i=0; (i < spn_el->num_values) && (i < num_spns); i++)
3322                                 torture_assert_str_equal(tctx,
3323                                                          (char *) spn_el->values[i].data,
3324                                 spns[i], "'servicePrincipalName's incorrect!");
3325
3326                         torture_assert_str_equal(tctx,
3327                                                  info.domain_info->dns_hostname.string,
3328                                                  old_dnsname,
3329                                                  "Out 'DNS hostname' doesn't match the old one!");
3330                 } else {
3331                         /* If no DNS hostname was set then also now none should be set,
3332                            the "servicePrincipalName"s should remain empty and no DNS
3333                            hostname should be returned by our "LogonGetDomainInfo"
3334                            call (in the domain info structure). */
3335
3336                         torture_assert(tctx,
3337                                        ldb_msg_find_attr_as_string(res[0], "dNSHostName", NULL) == NULL,
3338                                        "'DNS hostname' was set!");
3339
3340                         spn_el = ldb_msg_find_element(res[0], "servicePrincipalName");
3341                         torture_assert(tctx, ((spns == NULL) && (spn_el == NULL)),
3342                                        "'servicePrincipalName's were set!");
3343
3344                         torture_assert(tctx,
3345                                        info.domain_info->dns_hostname.string == NULL,
3346                                        "Out 'DNS host name' was set!");
3347                 }
3348         }
3349
3350         /* Checks "workstation flags" */
3351         torture_assert(tctx,
3352                 info.domain_info->workstation_flags
3353                 == NETR_WS_FLAG_HANDLES_SPN_UPDATE,
3354                 "Out 'workstation flags' don't match!");
3355
3356
3357         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 2nd call (variation of DNS hostname doesn't work)\n");
3358         netlogon_creds_client_authenticator(creds, &a);
3359
3360         /* Wipe out the osVersion, and prove which values still 'stick' */
3361         q1.os_version.os = NULL;
3362
3363         /* Change also the DNS hostname to test differences in behaviour */
3364         talloc_free(discard_const_p(char, q1.dns_hostname));
3365         q1.dns_hostname = talloc_asprintf(tctx, "%s2.%s", TEST_MACHINE_NAME,
3366                 lpcfg_dnsdomain(tctx->lp_ctx));
3367
3368         /* The workstation handles the "servicePrincipalName" and DNS hostname
3369            updates */
3370         q1.workstation_flags = NETR_WS_FLAG_HANDLES_SPN_UPDATE;
3371
3372         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3373                 "LogonGetDomainInfo failed");
3374         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3375
3376         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3377
3378         smb_msleep(250);
3379
3380         if (sam_ctx) {
3381                 /* AD workstation infos entry check */
3382                 ret = gendb_search(sam_ctx, tctx, NULL, &res, attrs,
3383                                    "(sAMAccountName=%s$)", TEST_MACHINE_NAME);
3384                 torture_assert(tctx, ret == 1, "Test machine account not found in SAMDB on DC! Has the workstation been joined?");
3385
3386                 torture_assert_str_equal(tctx,
3387                                          ldb_msg_find_attr_as_string(res[0], "operatingSystem", NULL),
3388                                          q1.os_name.string, "'operatingSystem' should stick!");
3389                 torture_assert(tctx,
3390                                ldb_msg_find_attr_as_string(res[0], "operatingSystemServicePack", NULL) == NULL,
3391                                "'operatingSystemServicePack' shouldn't stick!");
3392                 torture_assert(tctx,
3393                                ldb_msg_find_attr_as_string(res[0], "operatingSystemVersion", NULL) == NULL,
3394                                "'operatingSystemVersion' shouldn't stick!");
3395
3396                 /* The DNS host name shouldn't have been updated by the server */
3397
3398                 torture_assert_str_equal(tctx,
3399                                          ldb_msg_find_attr_as_string(res[0], "dNSHostName", NULL),
3400                                          old_dnsname, "'DNS host name' did change!");
3401
3402                 /* Find the two "servicePrincipalName"s which the DC shouldn't have been
3403                    updated (HOST/<Netbios name> and HOST/<FQDN name>) - see MS-NRPC
3404                    3.5.4.3.9 */
3405                 spn_el = ldb_msg_find_element(res[0], "servicePrincipalName");
3406                 torture_assert(tctx, spn_el != NULL,
3407                                "There should exist 'servicePrincipalName's in AD!");
3408                 temp_str = talloc_asprintf(tctx, "HOST/%s", TEST_MACHINE_NAME);
3409                 for (i=0; i < spn_el->num_values; i++)
3410                         if (strcasecmp((char *) spn_el->values[i].data, temp_str) == 0)
3411                                 break;
3412                 torture_assert(tctx, i != spn_el->num_values,
3413                                "'servicePrincipalName' HOST/<Netbios name> not found!");
3414                 temp_str = talloc_asprintf(tctx, "HOST/%s", old_dnsname);
3415                 for (i=0; i < spn_el->num_values; i++)
3416                         if (strcasecmp((char *) spn_el->values[i].data, temp_str) == 0)
3417                                 break;
3418                 torture_assert(tctx, i != spn_el->num_values,
3419                                "'servicePrincipalName' HOST/<FQDN name> not found!");
3420
3421                 /* Check that the out DNS hostname was set properly */
3422                 torture_assert_str_equal(tctx, info.domain_info->dns_hostname.string,
3423                                          old_dnsname, "Out 'DNS hostname' doesn't match the old one!");
3424         }
3425
3426         /* Checks "workstation flags" */
3427         torture_assert(tctx,
3428                 info.domain_info->workstation_flags == NETR_WS_FLAG_HANDLES_SPN_UPDATE,
3429                 "Out 'workstation flags' don't match!");
3430
3431
3432         /* Now try the same but the workstation flags set to 0 */
3433
3434         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 3rd call (variation of DNS hostname doesn't work)\n");
3435         netlogon_creds_client_authenticator(creds, &a);
3436
3437         /* Change also the DNS hostname to test differences in behaviour */
3438         talloc_free(discard_const_p(char, q1.dns_hostname));
3439         q1.dns_hostname = talloc_asprintf(tctx, "%s2.%s", TEST_MACHINE_NAME,
3440                 lpcfg_dnsdomain(tctx->lp_ctx));
3441
3442         /* Wipe out the osVersion, and prove which values still 'stick' */
3443         q1.os_version.os = NULL;
3444
3445         /* Let the DC handle the "servicePrincipalName" and DNS hostname
3446            updates */
3447         q1.workstation_flags = 0;
3448
3449         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3450                 "LogonGetDomainInfo failed");
3451         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3452         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3453
3454         smb_msleep(250);
3455
3456         if (sam_ctx) {
3457                 /* AD workstation infos entry check */
3458                 ret = gendb_search(sam_ctx, tctx, NULL, &res, attrs,
3459                                    "(sAMAccountName=%s$)", TEST_MACHINE_NAME);
3460                 torture_assert(tctx, ret == 1, "Test machine account not found in SAMDB on DC! Has the workstation been joined?");
3461
3462                 torture_assert_str_equal(tctx,
3463                                          ldb_msg_find_attr_as_string(res[0], "operatingSystem", NULL),
3464                                          q1.os_name.string, "'operatingSystem' should stick!");
3465                 torture_assert(tctx,
3466                                ldb_msg_find_attr_as_string(res[0], "operatingSystemServicePack", NULL) == NULL,
3467                                "'operatingSystemServicePack' shouldn't stick!");
3468                 torture_assert(tctx,
3469                                ldb_msg_find_attr_as_string(res[0], "operatingSystemVersion", NULL) == NULL,
3470                                "'operatingSystemVersion' shouldn't stick!");
3471
3472                 /* The DNS host name shouldn't have been updated by the server */
3473
3474                 torture_assert_str_equal(tctx,
3475                                          ldb_msg_find_attr_as_string(res[0], "dNSHostName", NULL),
3476                                          old_dnsname, "'DNS host name' did change!");
3477
3478                 /* Find the two "servicePrincipalName"s which the DC shouldn't have been
3479                    updated (HOST/<Netbios name> and HOST/<FQDN name>) - see MS-NRPC
3480                    3.5.4.3.9 */
3481                 spn_el = ldb_msg_find_element(res[0], "servicePrincipalName");
3482                 torture_assert(tctx, spn_el != NULL,
3483                                "There should exist 'servicePrincipalName's in AD!");
3484                 temp_str = talloc_asprintf(tctx, "HOST/%s", TEST_MACHINE_NAME);
3485                 for (i=0; i < spn_el->num_values; i++)
3486                         if (strcasecmp((char *) spn_el->values[i].data, temp_str) == 0)
3487                                 break;
3488                 torture_assert(tctx, i != spn_el->num_values,
3489                                "'servicePrincipalName' HOST/<Netbios name> not found!");
3490                 temp_str = talloc_asprintf(tctx, "HOST/%s", old_dnsname);
3491                 for (i=0; i < spn_el->num_values; i++)
3492                         if (strcasecmp((char *) spn_el->values[i].data, temp_str) == 0)
3493                                 break;
3494                 torture_assert(tctx, i != spn_el->num_values,
3495                                "'servicePrincipalName' HOST/<FQDN name> not found!");
3496
3497                 /* Here the server gives us NULL as the out DNS hostname */
3498                 torture_assert(tctx, info.domain_info->dns_hostname.string == NULL,
3499                                "Out 'DNS hostname' should be NULL!");
3500         }
3501
3502         /* Checks "workstation flags" */
3503         torture_assert(tctx,
3504                 info.domain_info->workstation_flags == 0,
3505                 "Out 'workstation flags' don't match!");
3506
3507
3508         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 4th call (verification of DNS hostname and check for trusted domains)\n");
3509         netlogon_creds_client_authenticator(creds, &a);
3510
3511         /* Put the DNS hostname back */
3512         talloc_free(discard_const_p(char, q1.dns_hostname));
3513         q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
3514                 lpcfg_dnsdomain(tctx->lp_ctx));
3515
3516         /* The workstation handles the "servicePrincipalName" and DNS hostname
3517            updates */
3518         q1.workstation_flags = NETR_WS_FLAG_HANDLES_SPN_UPDATE;
3519
3520         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3521                 "LogonGetDomainInfo failed");
3522         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3523         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3524
3525         smb_msleep(250);
3526
3527         /* Now the in/out DNS hostnames should be the same */
3528         torture_assert_str_equal(tctx,
3529                 info.domain_info->dns_hostname.string,
3530                 query.workstation_info->dns_hostname,
3531                 "In/Out 'DNS hostnames' don't match!");
3532         old_dnsname = info.domain_info->dns_hostname.string;
3533
3534         /* Checks "workstation flags" */
3535         torture_assert(tctx,
3536                 info.domain_info->workstation_flags
3537                 == NETR_WS_FLAG_HANDLES_SPN_UPDATE,
3538                 "Out 'workstation flags' don't match!");
3539
3540         /* Checks for trusted domains */
3541         torture_assert(tctx,
3542                 (info.domain_info->trusted_domain_count != 0)
3543                 && (info.domain_info->trusted_domains != NULL),
3544                 "Trusted domains have been requested!");
3545
3546
3547         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 5th call (check for trusted domains)\n");
3548         netlogon_creds_client_authenticator(creds, &a);
3549
3550         /* The workstation handles the "servicePrincipalName" and DNS hostname
3551            updates and requests inbound trusts */
3552         q1.workstation_flags = NETR_WS_FLAG_HANDLES_SPN_UPDATE
3553                 | NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS;
3554
3555         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3556                 "LogonGetDomainInfo failed");
3557         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3558         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3559
3560         smb_msleep(250);
3561
3562         /* Checks "workstation flags" */
3563         torture_assert(tctx,
3564                 info.domain_info->workstation_flags
3565                 == (NETR_WS_FLAG_HANDLES_SPN_UPDATE
3566                         | NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS),
3567                 "Out 'workstation flags' don't match!");
3568
3569         /* Checks for trusted domains */
3570         torture_assert(tctx,
3571                 (info.domain_info->trusted_domain_count != 0)
3572                 && (info.domain_info->trusted_domains != NULL),
3573                 "Trusted domains have been requested!");
3574
3575
3576         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 6th call (no DNS hostname)\n");
3577         netlogon_creds_client_authenticator(creds, &a);
3578
3579         query.workstation_info->dns_hostname = NULL;
3580
3581         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3582                 "LogonGetDomainInfo failed");
3583         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3584         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3585
3586         /* The old DNS hostname should stick */
3587         torture_assert_str_equal(tctx,
3588                 info.domain_info->dns_hostname.string,
3589                 old_dnsname,
3590                 "'DNS hostname' changed!");
3591
3592         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 7th call (extra workstation flags)\n");
3593         netlogon_creds_client_authenticator(creds, &a);
3594
3595         q1.workstation_flags = NETR_WS_FLAG_HANDLES_SPN_UPDATE
3596                 | NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS | 0x4;
3597
3598         /* Put the DNS hostname back */
3599         talloc_free(discard_const_p(char, q1.dns_hostname));
3600         q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
3601                 lpcfg_dnsdomain(tctx->lp_ctx));
3602
3603         torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3604                 "LogonGetDomainInfo failed");
3605         torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3606         torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3607
3608         /* Checks "workstation flags" */
3609         torture_assert(tctx,
3610                 info.domain_info->workstation_flags
3611                 == (NETR_WS_FLAG_HANDLES_SPN_UPDATE
3612                         | NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS),
3613                 "Out 'workstation flags' don't match!");
3614
3615         if (!torture_setting_bool(tctx, "dangerous", false)) {
3616                 torture_comment(tctx, "Not testing netr_LogonGetDomainInfo 8th call (no workstation info) - enable dangerous tests in order to do so\n");
3617         } else {
3618                 /* Try a call without the workstation information structure */
3619
3620                 torture_comment(tctx, "Testing netr_LogonGetDomainInfo 8th call (no workstation info)\n");
3621                 netlogon_creds_client_authenticator(creds, &a);
3622
3623                 query.workstation_info = NULL;
3624
3625                 torture_assert_ntstatus_ok(tctx, dcerpc_netr_LogonGetDomainInfo_r(b, tctx, &r),
3626                         "LogonGetDomainInfo failed");
3627                 torture_assert_ntstatus_ok(tctx, r.out.result, "LogonGetDomainInfo failed");
3628                 torture_assert(tctx, netlogon_creds_client_check(creds, &a.cred), "Credential chaining failed");
3629         }
3630
3631         return true;
3632 }
3633
3634 static bool test_GetDomainInfo_async(struct torture_context *tctx,
3635                                      struct dcerpc_pipe *p,
3636                                      struct cli_credentials *machine_credentials)
3637 {
3638         NTSTATUS status;
3639         struct netr_LogonGetDomainInfo r;
3640         struct netr_WorkstationInformation q1;
3641         struct netr_Authenticator a;
3642 #define ASYNC_COUNT 100
3643         struct netlogon_creds_CredentialState *creds;
3644         struct netlogon_creds_CredentialState *creds_async[ASYNC_COUNT];
3645         struct tevent_req *req[ASYNC_COUNT];
3646         int i;
3647         union netr_WorkstationInfo query;
3648         union netr_DomainInfo info;
3649
3650         torture_comment(tctx, "Testing netr_LogonGetDomainInfo - async count %d\n", ASYNC_COUNT);
3651
3652         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
3653                                     machine_credentials, &creds)) {
3654                 return false;
3655         }
3656
3657         ZERO_STRUCT(r);
3658         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
3659         r.in.computer_name = TEST_MACHINE_NAME;
3660         r.in.credential = &a;
3661         r.in.level = 1;
3662         r.in.return_authenticator = &a;
3663         r.in.query = &query;
3664         r.out.return_authenticator = &a;
3665         r.out.info = &info;
3666
3667         ZERO_STRUCT(q1);
3668         q1.dns_hostname = talloc_asprintf(tctx, "%s.%s", TEST_MACHINE_NAME,
3669                 lpcfg_dnsdomain(tctx->lp_ctx));
3670         q1.sitename = "Default-First-Site-Name";
3671         q1.os_name.string = "UNIX/Linux or similar";
3672
3673         query.workstation_info = &q1;
3674
3675         for (i=0;i<ASYNC_COUNT;i++) {
3676                 netlogon_creds_client_authenticator(creds, &a);
3677
3678                 creds_async[i] = (struct netlogon_creds_CredentialState *)talloc_memdup(creds, creds, sizeof(*creds));
3679                 req[i] = dcerpc_netr_LogonGetDomainInfo_r_send(tctx, tctx->ev, p->binding_handle, &r);
3680
3681                 /* even with this flush per request a w2k3 server seems to
3682                    clag with multiple outstanding requests. bleergh. */
3683                 torture_assert_int_equal(tctx, tevent_loop_once(dcerpc_event_context(p)), 0,
3684                                          "tevent_loop_once failed");
3685         }
3686
3687         for (i=0;i<ASYNC_COUNT;i++) {
3688                 torture_assert_int_equal(tctx, tevent_req_poll(req[i], tctx->ev), true,
3689                                          "tevent_req_poll() failed");
3690
3691                 status = dcerpc_netr_LogonGetDomainInfo_r_recv(req[i], tctx);
3692
3693                 torture_assert_ntstatus_ok(tctx, status, "netr_LogonGetDomainInfo_async");
3694                 torture_assert_ntstatus_ok(tctx, r.out.result, "netr_LogonGetDomainInfo_async");
3695
3696                 torture_assert(tctx, netlogon_creds_client_check(creds_async[i], &a.cred),
3697                         "Credential chaining failed at async");
3698         }
3699
3700         torture_comment(tctx,
3701                         "Testing netr_LogonGetDomainInfo - async count %d OK\n", ASYNC_COUNT);
3702
3703         return true;
3704 }
3705
3706 static bool test_ManyGetDCName(struct torture_context *tctx,
3707                                struct dcerpc_pipe *p)
3708 {
3709         NTSTATUS status;
3710         struct dcerpc_pipe *p2;
3711         struct lsa_ObjectAttribute attr;
3712         struct lsa_QosInfo qos;
3713         struct lsa_OpenPolicy2 o;
3714         struct policy_handle lsa_handle;
3715         struct lsa_DomainList domains;
3716
3717         struct lsa_EnumTrustDom t;
3718         uint32_t resume_handle = 0;
3719         struct netr_GetAnyDCName d;
3720         const char *dcname = NULL;
3721         struct dcerpc_binding_handle *b = p->binding_handle;
3722         struct dcerpc_binding_handle *b2;
3723
3724         int i;
3725
3726         if (p->conn->transport.transport != NCACN_NP) {
3727                 return true;
3728         }
3729
3730         torture_comment(tctx, "Torturing GetDCName\n");
3731
3732         status = dcerpc_secondary_connection(p, &p2, p->binding);
3733         torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
3734
3735         status = dcerpc_bind_auth_none(p2, &ndr_table_lsarpc);
3736         torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
3737         b2 = p2->binding_handle;
3738
3739         qos.len = 0;
3740         qos.impersonation_level = 2;
3741         qos.context_mode = 1;
3742         qos.effective_only = 0;
3743
3744         attr.len = 0;
3745         attr.root_dir = NULL;
3746         attr.object_name = NULL;
3747         attr.attributes = 0;
3748         attr.sec_desc = NULL;
3749         attr.sec_qos = &qos;
3750
3751         o.in.system_name = "\\";
3752         o.in.attr = &attr;
3753         o.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
3754         o.out.handle = &lsa_handle;
3755
3756         torture_assert_ntstatus_ok(tctx, dcerpc_lsa_OpenPolicy2_r(b2, tctx, &o),
3757                 "OpenPolicy2 failed");
3758         torture_assert_ntstatus_ok(tctx, o.out.result, "OpenPolicy2 failed");
3759
3760         t.in.handle = &lsa_handle;
3761         t.in.resume_handle = &resume_handle;
3762         t.in.max_size = 1000;
3763         t.out.domains = &domains;
3764         t.out.resume_handle = &resume_handle;
3765
3766         torture_assert_ntstatus_ok(tctx, dcerpc_lsa_EnumTrustDom_r(b2, tctx, &t),
3767                 "EnumTrustDom failed");
3768
3769         if ((!NT_STATUS_IS_OK(t.out.result) &&
3770              (!NT_STATUS_EQUAL(t.out.result, NT_STATUS_NO_MORE_ENTRIES))))
3771                 torture_fail(tctx, "Could not list domains");
3772
3773         talloc_free(p2);
3774
3775         d.in.logon_server = talloc_asprintf(tctx, "\\\\%s",
3776                                             dcerpc_server_name(p));
3777         d.out.dcname = &dcname;
3778
3779         for (i=0; i<domains.count * 4; i++) {
3780                 struct lsa_DomainInfo *info =
3781                         &domains.domains[rand()%domains.count];
3782
3783                 d.in.domainname = info->name.string;
3784
3785                 status = dcerpc_netr_GetAnyDCName_r(b, tctx, &d);
3786                 torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
3787
3788                 torture_comment(tctx, "\tDC for domain %s is %s\n", info->name.string,
3789                        dcname ? dcname : "unknown");
3790         }
3791
3792         return true;
3793 }
3794
3795 static bool test_SetPassword_with_flags(struct torture_context *tctx,
3796                                         struct dcerpc_pipe *p,
3797                                         struct cli_credentials *machine_credentials)
3798 {
3799         uint32_t flags[] = { 0, NETLOGON_NEG_STRONG_KEYS };
3800         struct netlogon_creds_CredentialState *creds;
3801         int i;
3802
3803         if (!test_SetupCredentials2(p, tctx, 0,
3804                                     machine_credentials,
3805                                     cli_credentials_get_secure_channel_type(machine_credentials),
3806                                     &creds)) {
3807                 torture_skip(tctx, "DC does not support negotiation of 64bit session keys");
3808         }
3809
3810         for (i=0; i < ARRAY_SIZE(flags); i++) {
3811                 torture_assert(tctx,
3812                         test_SetPassword_flags(tctx, p, machine_credentials, flags[i]),
3813                         talloc_asprintf(tctx, "failed to test SetPassword negotiating with 0x%08x flags", flags[i]));
3814         }
3815
3816         return true;
3817 }
3818
3819 struct torture_suite *torture_rpc_netlogon(TALLOC_CTX *mem_ctx)
3820 {
3821         struct torture_suite *suite = torture_suite_create(mem_ctx, "netlogon");
3822         struct torture_rpc_tcase *tcase;
3823         struct torture_test *test;
3824
3825         tcase = torture_suite_add_machine_bdc_rpc_iface_tcase(suite, "netlogon",
3826                                                   &ndr_table_netlogon, TEST_MACHINE_NAME);
3827
3828         torture_rpc_tcase_add_test(tcase, "Broken RPC binding handle",
3829                                    test_netr_broken_binding_handle);
3830
3831         torture_rpc_tcase_add_test(tcase, "LogonUasLogon", test_LogonUasLogon);
3832         torture_rpc_tcase_add_test(tcase, "LogonUasLogoff", test_LogonUasLogoff);
3833         torture_rpc_tcase_add_test_creds(tcase, "SamLogon", test_SamLogon);
3834         torture_rpc_tcase_add_test_creds(tcase, "SetPassword", test_SetPassword);
3835         torture_rpc_tcase_add_test_creds(tcase, "SetPassword2", test_SetPassword2);
3836         torture_rpc_tcase_add_test_creds(tcase, "GetPassword", test_GetPassword);
3837         torture_rpc_tcase_add_test_creds(tcase, "GetTrustPasswords", test_GetTrustPasswords);
3838         torture_rpc_tcase_add_test_creds(tcase, "GetDomainInfo", test_GetDomainInfo);
3839         torture_rpc_tcase_add_test_creds(tcase, "DatabaseSync", test_DatabaseSync);
3840         torture_rpc_tcase_add_test_creds(tcase, "DatabaseDeltas", test_DatabaseDeltas);
3841         torture_rpc_tcase_add_test_creds(tcase, "DatabaseRedo", test_DatabaseRedo);
3842         torture_rpc_tcase_add_test_creds(tcase, "AccountDeltas", test_AccountDeltas);
3843         torture_rpc_tcase_add_test_creds(tcase, "AccountSync", test_AccountSync);
3844         torture_rpc_tcase_add_test(tcase, "GetDcName", test_GetDcName);
3845         torture_rpc_tcase_add_test(tcase, "ManyGetDCName", test_ManyGetDCName);
3846         torture_rpc_tcase_add_test(tcase, "GetAnyDCName", test_GetAnyDCName);
3847         torture_rpc_tcase_add_test_creds(tcase, "DatabaseSync2", test_DatabaseSync2);
3848         torture_rpc_tcase_add_test(tcase, "DsrEnumerateDomainTrusts", test_DsrEnumerateDomainTrusts);
3849         torture_rpc_tcase_add_test(tcase, "NetrEnumerateTrustedDomains", test_netr_NetrEnumerateTrustedDomains);
3850         torture_rpc_tcase_add_test(tcase, "NetrEnumerateTrustedDomainsEx", test_netr_NetrEnumerateTrustedDomainsEx);
3851         test = torture_rpc_tcase_add_test_creds(tcase, "GetDomainInfo_async", test_GetDomainInfo_async);
3852         test->dangerous = true;
3853         torture_rpc_tcase_add_test(tcase, "DsRGetDCName", test_netr_DsRGetDCName);
3854         torture_rpc_tcase_add_test(tcase, "DsRGetDCNameEx", test_netr_DsRGetDCNameEx);
3855         torture_rpc_tcase_add_test(tcase, "DsRGetDCNameEx2", test_netr_DsRGetDCNameEx2);
3856         torture_rpc_tcase_add_test(tcase, "DsrGetDcSiteCoverageW", test_netr_DsrGetDcSiteCoverageW);
3857         torture_rpc_tcase_add_test(tcase, "DsRAddressToSitenamesW", test_netr_DsRAddressToSitenamesW);
3858         torture_rpc_tcase_add_test(tcase, "DsRAddressToSitenamesExW", test_netr_DsRAddressToSitenamesExW);
3859         torture_rpc_tcase_add_test_creds(tcase, "ServerGetTrustInfo", test_netr_ServerGetTrustInfo);
3860         torture_rpc_tcase_add_test_creds(tcase, "GetForestTrustInformation", test_netr_GetForestTrustInformation);
3861
3862         return suite;
3863 }
3864
3865 struct torture_suite *torture_rpc_netlogon_s3(TALLOC_CTX *mem_ctx)
3866 {
3867         struct torture_suite *suite = torture_suite_create(mem_ctx, "netlogon-s3");
3868         struct torture_rpc_tcase *tcase;
3869
3870         tcase = torture_suite_add_machine_bdc_rpc_iface_tcase(suite, "netlogon",
3871                                                   &ndr_table_netlogon, TEST_MACHINE_NAME);
3872
3873         torture_rpc_tcase_add_test_creds(tcase, "SamLogon", test_SamLogon);
3874         torture_rpc_tcase_add_test_creds(tcase, "SamLogon_NULL_domain", test_SamLogon_NULL_domain);
3875         torture_rpc_tcase_add_test_creds(tcase, "SetPassword", test_SetPassword);
3876         torture_rpc_tcase_add_test_creds(tcase, "SetPassword_with_flags", test_SetPassword_with_flags);
3877         torture_rpc_tcase_add_test_creds(tcase, "SetPassword2", test_SetPassword2);
3878         torture_rpc_tcase_add_test(tcase, "NetrEnumerateTrustedDomains", test_netr_NetrEnumerateTrustedDomains);
3879
3880         return suite;
3881 }
3882
3883 struct torture_suite *torture_rpc_netlogon_admin(TALLOC_CTX *mem_ctx)
3884 {
3885         struct torture_suite *suite = torture_suite_create(mem_ctx, "netlogon.admin");
3886         struct torture_rpc_tcase *tcase;
3887
3888         tcase = torture_suite_add_machine_bdc_rpc_iface_tcase(suite, "netlogon",
3889                                                   &ndr_table_netlogon, TEST_MACHINE_NAME);
3890         torture_rpc_tcase_add_test_creds(tcase, "LogonControl", test_LogonControl);
3891         torture_rpc_tcase_add_test_creds(tcase, "LogonControl2", test_LogonControl2);
3892         torture_rpc_tcase_add_test_creds(tcase, "LogonControl2Ex", test_LogonControl2Ex);
3893
3894         tcase = torture_suite_add_machine_workstation_rpc_iface_tcase(suite, "netlogon",
3895                                                   &ndr_table_netlogon, TEST_MACHINE_NAME);
3896         torture_rpc_tcase_add_test_creds(tcase, "LogonControl", test_LogonControl);
3897         torture_rpc_tcase_add_test_creds(tcase, "LogonControl2", test_LogonControl2);
3898         torture_rpc_tcase_add_test_creds(tcase, "LogonControl2Ex", test_LogonControl2Ex);
3899
3900         tcase = torture_suite_add_rpc_iface_tcase(suite, "netlogon",
3901                                                   &ndr_table_netlogon);
3902         torture_rpc_tcase_add_test_creds(tcase, "LogonControl", test_LogonControl);
3903         torture_rpc_tcase_add_test_creds(tcase, "LogonControl2", test_LogonControl2);
3904         torture_rpc_tcase_add_test_creds(tcase, "LogonControl2Ex", test_LogonControl2Ex);
3905
3906         return suite;
3907 }