root/source4/torture/rpc/netlogon.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. test_LogonUasLogon
  2. test_LogonUasLogoff
  3. test_SetupCredentials
  4. test_SetupCredentials2
  5. test_SetupCredentials3
  6. test_SetPassword
  7. netlogon_very_rand_pass
  8. test_SetPassword2
  9. test_GetPassword
  10. test_GetTrustPasswords
  11. test_netlogon_ops
  12. test_SamLogon
  13. test_DatabaseSync
  14. test_DatabaseDeltas
  15. test_DatabaseRedo
  16. test_AccountDeltas
  17. test_AccountSync
  18. test_GetDcName
  19. test_LogonControl
  20. test_GetAnyDCName
  21. test_LogonControl2
  22. test_DatabaseSync2
  23. test_LogonControl2Ex
  24. test_netr_DsRGetForestTrustInformation
  25. test_DsrEnumerateDomainTrusts
  26. test_netr_NetrEnumerateTrustedDomains
  27. test_netr_NetrEnumerateTrustedDomainsEx
  28. test_netr_DsRGetSiteName
  29. test_netr_DsRGetDCName
  30. test_netr_DsRGetDCNameEx
  31. test_netr_DsRGetDCNameEx2
  32. test_netr_DsrGetDcSiteCoverageW
  33. test_netr_DsRAddressToSitenamesW
  34. test_netr_DsRAddressToSitenamesExW
  35. test_netr_ServerGetTrustInfo
  36. test_GetDomainInfo
  37. async_callback
  38. test_GetDomainInfo_async
  39. test_ManyGetDCName
  40. torture_rpc_netlogon

   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    
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14    
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19    
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23 
  24 #include "includes.h"
  25 #include "torture/torture.h"
  26 #include "lib/events/events.h"
  27 #include "auth/auth.h"
  28 #include "auth/gensec/gensec.h"
  29 #include "lib/cmdline/popt_common.h"
  30 #include "torture/rpc/rpc.h"
  31 #include "torture/rpc/netlogon.h"
  32 #include "../lib/crypto/crypto.h"
  33 #include "libcli/auth/libcli_auth.h"
  34 #include "librpc/gen_ndr/ndr_netlogon_c.h"
  35 #include "librpc/gen_ndr/ndr_netlogon.h"
  36 #include "librpc/gen_ndr/ndr_lsa_c.h"
  37 #include "param/param.h"
  38 #include "libcli/security/security.h"
  39 
  40 #define TEST_MACHINE_NAME "torturetest"
  41 
  42 static bool test_LogonUasLogon(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
  43                                struct dcerpc_pipe *p)
  44 {
  45         NTSTATUS status;
  46         struct netr_LogonUasLogon r;
  47         struct netr_UasInfo *info = NULL;
  48 
  49         r.in.server_name = NULL;
  50         r.in.account_name = cli_credentials_get_username(cmdline_credentials);
  51         r.in.workstation = TEST_MACHINE_NAME;
  52         r.out.info = &info;
  53 
  54         status = dcerpc_netr_LogonUasLogon(p, tctx, &r);
  55         torture_assert_ntstatus_ok(tctx, status, "LogonUasLogon");
  56 
  57         return true;
  58 }
  59 
  60 static bool test_LogonUasLogoff(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
  61                                 struct dcerpc_pipe *p)
  62 {
  63         NTSTATUS status;
  64         struct netr_LogonUasLogoff r;
  65         struct netr_UasLogoffInfo info;
  66 
  67         r.in.server_name = NULL;
  68         r.in.account_name = cli_credentials_get_username(cmdline_credentials);
  69         r.in.workstation = TEST_MACHINE_NAME;
  70         r.out.info = &info;
  71 
  72         status = dcerpc_netr_LogonUasLogoff(p, tctx, &r);
  73         torture_assert_ntstatus_ok(tctx, status, "LogonUasLogoff");
  74 
  75         return true;
  76 }
  77 
  78 bool test_SetupCredentials(struct dcerpc_pipe *p, struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
  79                                   struct cli_credentials *credentials,
  80                                   struct creds_CredentialState **creds_out)
  81 {
  82         NTSTATUS status;
  83         struct netr_ServerReqChallenge r;
  84         struct netr_ServerAuthenticate a;
  85         struct netr_Credential credentials1, credentials2, credentials3;
  86         struct creds_CredentialState *creds;
  87         const struct samr_Password *mach_password;
  88         const char *machine_name;
  89 
  90         mach_password = cli_credentials_get_nt_hash(credentials, tctx);
  91         machine_name = cli_credentials_get_workstation(credentials);
  92 
  93         torture_comment(tctx, "Testing ServerReqChallenge\n");
  94 
  95         creds = talloc(tctx, struct creds_CredentialState);
  96         torture_assert(tctx, creds != NULL, "memory allocation");
  97 
  98         r.in.server_name = NULL;
  99         r.in.computer_name = machine_name;
 100         r.in.credentials = &credentials1;
 101         r.out.return_credentials = &credentials2;
 102 
 103         generate_random_buffer(credentials1.data, sizeof(credentials1.data));
 104 
 105         status = dcerpc_netr_ServerReqChallenge(p, tctx, &r);
 106         torture_assert_ntstatus_ok(tctx, status, "ServerReqChallenge");
 107 
 108         a.in.server_name = NULL;
 109         a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
 110         a.in.secure_channel_type = SEC_CHAN_BDC;
 111         a.in.computer_name = machine_name;
 112         a.in.credentials = &credentials3;
 113         a.out.return_credentials = &credentials3;
 114 
 115         creds_client_init(creds, &credentials1, &credentials2, 
 116                           mach_password, &credentials3, 
 117                           0);
 118 
 119         torture_comment(tctx, "Testing ServerAuthenticate\n");
 120 
 121         status = dcerpc_netr_ServerAuthenticate(p, tctx, &a);
 122 
 123         /* This allows the tests to continue against the more fussy windows 2008 */
 124         if (NT_STATUS_EQUAL(status, NT_STATUS_DOWNGRADE_DETECTED)) {
 125                 return test_SetupCredentials2(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS, 
 126                                               credentials, SEC_CHAN_BDC, creds_out);
 127         }
 128 
 129         torture_assert_ntstatus_ok(tctx, status, "ServerAuthenticate");
 130 
 131         torture_assert(tctx, creds_client_check(creds, &credentials3), 
 132                        "Credential chaining failed");
 133 
 134         *creds_out = creds;
 135         return true;
 136 }
 137 
 138 bool test_SetupCredentials2(struct dcerpc_pipe *p, struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 139                             uint32_t negotiate_flags,
 140                             struct cli_credentials *machine_credentials,
 141                             int sec_chan_type,
 142                             struct creds_CredentialState **creds_out)
 143 {
 144         NTSTATUS status;
 145         struct netr_ServerReqChallenge r;
 146         struct netr_ServerAuthenticate2 a;
 147         struct netr_Credential credentials1, credentials2, credentials3;
 148         struct creds_CredentialState *creds;
 149         const struct samr_Password *mach_password;
 150         const char *machine_name;
 151 
 152         mach_password = cli_credentials_get_nt_hash(machine_credentials, tctx);
 153         machine_name = cli_credentials_get_workstation(machine_credentials);
 154 
 155         torture_comment(tctx, "Testing ServerReqChallenge\n");
 156 
 157         creds = talloc(tctx, struct creds_CredentialState);
 158         torture_assert(tctx, creds != NULL, "memory allocation");
 159 
 160         r.in.server_name = NULL;
 161         r.in.computer_name = machine_name;
 162         r.in.credentials = &credentials1;
 163         r.out.return_credentials = &credentials2;
 164 
 165         generate_random_buffer(credentials1.data, sizeof(credentials1.data));
 166 
 167         status = dcerpc_netr_ServerReqChallenge(p, tctx, &r);
 168         torture_assert_ntstatus_ok(tctx, status, "ServerReqChallenge");
 169 
 170         a.in.server_name = NULL;
 171         a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
 172         a.in.secure_channel_type = sec_chan_type;
 173         a.in.computer_name = machine_name;
 174         a.in.negotiate_flags = &negotiate_flags;
 175         a.out.negotiate_flags = &negotiate_flags;
 176         a.in.credentials = &credentials3;
 177         a.out.return_credentials = &credentials3;
 178 
 179         creds_client_init(creds, &credentials1, &credentials2, 
 180                           mach_password, &credentials3, 
 181                           negotiate_flags);
 182 
 183         torture_comment(tctx, "Testing ServerAuthenticate2\n");
 184 
 185         status = dcerpc_netr_ServerAuthenticate2(p, tctx, &a);
 186         torture_assert_ntstatus_ok(tctx, status, "ServerAuthenticate2");
 187 
 188         torture_assert(tctx, creds_client_check(creds, &credentials3), 
 189                 "Credential chaining failed");
 190 
 191         torture_comment(tctx, "negotiate_flags=0x%08x\n", negotiate_flags);
 192 
 193         *creds_out = creds;
 194         return true;
 195 }
 196 
 197 
 198 static bool test_SetupCredentials3(struct dcerpc_pipe *p, struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 199                             uint32_t negotiate_flags,
 200                             struct cli_credentials *machine_credentials,
 201                             struct creds_CredentialState **creds_out)
 202 {
 203         NTSTATUS status;
 204         struct netr_ServerReqChallenge r;
 205         struct netr_ServerAuthenticate3 a;
 206         struct netr_Credential credentials1, credentials2, credentials3;
 207         struct creds_CredentialState *creds;
 208         struct samr_Password mach_password;
 209         uint32_t rid;
 210         const char *machine_name;
 211         const char *plain_pass;
 212 
 213         machine_name = cli_credentials_get_workstation(machine_credentials);
 214         plain_pass = cli_credentials_get_password(machine_credentials);
 215 
 216         torture_comment(tctx, "Testing ServerReqChallenge\n");
 217 
 218         creds = talloc(tctx, struct creds_CredentialState);
 219         torture_assert(tctx, creds != NULL, "memory allocation");
 220 
 221         r.in.server_name = NULL;
 222         r.in.computer_name = machine_name;
 223         r.in.credentials = &credentials1;
 224         r.out.return_credentials = &credentials2;
 225 
 226         generate_random_buffer(credentials1.data, sizeof(credentials1.data));
 227 
 228         status = dcerpc_netr_ServerReqChallenge(p, tctx, &r);
 229         torture_assert_ntstatus_ok(tctx, status, "ServerReqChallenge");
 230 
 231         E_md4hash(plain_pass, mach_password.hash);
 232 
 233         a.in.server_name = NULL;
 234         a.in.account_name = talloc_asprintf(tctx, "%s$", machine_name);
 235         a.in.secure_channel_type = SEC_CHAN_BDC;
 236         a.in.computer_name = machine_name;
 237         a.in.negotiate_flags = &negotiate_flags;
 238         a.in.credentials = &credentials3;
 239         a.out.return_credentials = &credentials3;
 240         a.out.negotiate_flags = &negotiate_flags;
 241         a.out.rid = &rid;
 242 
 243         creds_client_init(creds, &credentials1, &credentials2, 
 244                           &mach_password, &credentials3,
 245                           negotiate_flags);
 246 
 247         torture_comment(tctx, "Testing ServerAuthenticate3\n");
 248 
 249         status = dcerpc_netr_ServerAuthenticate3(p, tctx, &a);
 250         torture_assert_ntstatus_ok(tctx, status, "ServerAuthenticate3");
 251         torture_assert(tctx, creds_client_check(creds, &credentials3), "Credential chaining failed");
 252 
 253         torture_comment(tctx, "negotiate_flags=0x%08x\n", negotiate_flags);
 254         
 255         /* Prove that requesting a challenge again won't break it */
 256         status = dcerpc_netr_ServerReqChallenge(p, tctx, &r);
 257         torture_assert_ntstatus_ok(tctx, status, "ServerReqChallenge");
 258 
 259         *creds_out = creds;
 260         return true;
 261 }
 262 
 263 /*
 264   try a change password for our machine account
 265 */
 266 static bool test_SetPassword(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 267                              struct dcerpc_pipe *p,
 268                              struct cli_credentials *machine_credentials)
 269 {
 270         NTSTATUS status;
 271         struct netr_ServerPasswordSet r;
 272         const char *password;
 273         struct creds_CredentialState *creds;
 274         struct netr_Authenticator credential, return_authenticator;
 275         struct samr_Password new_password;
 276 
 277         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 278                 return false;
 279         }
 280 
 281         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 282         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 283         r.in.secure_channel_type = SEC_CHAN_BDC;
 284         r.in.computer_name = TEST_MACHINE_NAME;
 285         r.in.credential = &credential;
 286         r.in.new_password = &new_password;
 287         r.out.return_authenticator = &return_authenticator;
 288 
 289         password = generate_random_str(tctx, 8);
 290         E_md4hash(password, new_password.hash);
 291 
 292         creds_des_encrypt(creds, &new_password);
 293 
 294         torture_comment(tctx, "Testing ServerPasswordSet on machine account\n");
 295         torture_comment(tctx, "Changing machine account password to '%s'\n", 
 296                         password);
 297 
 298         creds_client_authenticator(creds, &credential);
 299 
 300         status = dcerpc_netr_ServerPasswordSet(p, tctx, &r);
 301         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet");
 302 
 303         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 304                 torture_comment(tctx, "Credential chaining failed\n");
 305         }
 306 
 307         /* by changing the machine password twice we test the
 308            credentials chaining fully, and we verify that the server
 309            allows the password to be set to the same value twice in a
 310            row (match win2k3) */
 311         torture_comment(tctx, 
 312                 "Testing a second ServerPasswordSet on machine account\n");
 313         torture_comment(tctx, 
 314                 "Changing machine account password to '%s' (same as previous run)\n", password);
 315 
 316         creds_client_authenticator(creds, &credential);
 317 
 318         status = dcerpc_netr_ServerPasswordSet(p, tctx, &r);
 319         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet (2)");
 320 
 321         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 322                 torture_comment(tctx, "Credential chaining failed\n");
 323         }
 324 
 325         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 326 
 327         torture_assert(tctx, 
 328                 test_SetupCredentials(p, tctx, machine_credentials, &creds), 
 329                 "ServerPasswordSet failed to actually change the password");
 330 
 331         return true;
 332 }
 333 
 334 /*
 335   generate a random password for password change tests
 336 */
 337 static DATA_BLOB netlogon_very_rand_pass(TALLOC_CTX *mem_ctx, int len)
     /* [<][>][^][v][top][bottom][index][help] */
 338 {
 339         int i;
 340         DATA_BLOB password = data_blob_talloc(mem_ctx, NULL, len * 2 /* number of unicode chars */);
 341         generate_random_buffer(password.data, password.length);
 342 
 343         for (i=0; i < len; i++) {
 344                 if (((uint16_t *)password.data)[i] == 0) {
 345                         ((uint16_t *)password.data)[i] = 1;
 346                 }
 347         }
 348 
 349         return password;
 350 }
 351 
 352 /*
 353   try a change password for our machine account
 354 */
 355 static bool test_SetPassword2(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 356                               struct dcerpc_pipe *p, 
 357                               struct cli_credentials *machine_credentials)
 358 {
 359         NTSTATUS status;
 360         struct netr_ServerPasswordSet2 r;
 361         const char *password;
 362         DATA_BLOB new_random_pass;
 363         struct creds_CredentialState *creds;
 364         struct samr_CryptPassword password_buf;
 365         struct samr_Password nt_hash;
 366         struct netr_Authenticator credential, return_authenticator;
 367         struct netr_CryptPassword new_password;
 368 
 369         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 370                 return false;
 371         }
 372 
 373         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 374         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 375         r.in.secure_channel_type = SEC_CHAN_BDC;
 376         r.in.computer_name = TEST_MACHINE_NAME;
 377         r.in.credential = &credential;
 378         r.in.new_password = &new_password;
 379         r.out.return_authenticator = &return_authenticator;
 380 
 381         password = generate_random_str(tctx, 8);
 382         encode_pw_buffer(password_buf.data, password, STR_UNICODE);
 383         creds_arcfour_crypt(creds, password_buf.data, 516);
 384 
 385         memcpy(new_password.data, password_buf.data, 512);
 386         new_password.length = IVAL(password_buf.data, 512);
 387 
 388         torture_comment(tctx, "Testing ServerPasswordSet2 on machine account\n");
 389         torture_comment(tctx, "Changing machine account password to '%s'\n", password);
 390 
 391         creds_client_authenticator(creds, &credential);
 392 
 393         status = dcerpc_netr_ServerPasswordSet2(p, tctx, &r);
 394         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet2");
 395 
 396         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 397                 torture_comment(tctx, "Credential chaining failed\n");
 398         }
 399 
 400         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 401 
 402         if (!torture_setting_bool(tctx, "dangerous", false)) {
 403                 torture_comment(tctx, 
 404                         "Not testing ability to set password to '', enable dangerous tests to perform this test\n");
 405         } else {
 406                 /* by changing the machine password to ""
 407                  * we check if the server uses password restrictions
 408                  * for ServerPasswordSet2
 409                  * (win2k3 accepts "")
 410                  */
 411                 password = "";
 412                 encode_pw_buffer(password_buf.data, password, STR_UNICODE);
 413                 creds_arcfour_crypt(creds, password_buf.data, 516);
 414                 
 415                 memcpy(new_password.data, password_buf.data, 512);
 416                 new_password.length = IVAL(password_buf.data, 512);
 417                 
 418                 torture_comment(tctx, 
 419                         "Testing ServerPasswordSet2 on machine account\n");
 420                 torture_comment(tctx, 
 421                         "Changing machine account password to '%s'\n", password);
 422                 
 423                 creds_client_authenticator(creds, &credential);
 424                 
 425                 status = dcerpc_netr_ServerPasswordSet2(p, tctx, &r);
 426                 torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet2");
 427                 
 428                 if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 429                         torture_comment(tctx, "Credential chaining failed\n");
 430                 }
 431                 
 432                 cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 433         }
 434 
 435         torture_assert(tctx, test_SetupCredentials(p, tctx, machine_credentials, &creds), 
 436                 "ServerPasswordSet failed to actually change the password");
 437 
 438         /* now try a random password */
 439         password = generate_random_str(tctx, 8);
 440         encode_pw_buffer(password_buf.data, password, STR_UNICODE);
 441         creds_arcfour_crypt(creds, password_buf.data, 516);
 442 
 443         memcpy(new_password.data, password_buf.data, 512);
 444         new_password.length = IVAL(password_buf.data, 512);
 445 
 446         torture_comment(tctx, "Testing second ServerPasswordSet2 on machine account\n");
 447         torture_comment(tctx, "Changing machine account password to '%s'\n", password);
 448 
 449         creds_client_authenticator(creds, &credential);
 450 
 451         status = dcerpc_netr_ServerPasswordSet2(p, tctx, &r);
 452         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet2 (2)");
 453 
 454         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 455                 torture_comment(tctx, "Credential chaining failed\n");
 456         }
 457 
 458         /* by changing the machine password twice we test the
 459            credentials chaining fully, and we verify that the server
 460            allows the password to be set to the same value twice in a
 461            row (match win2k3) */
 462         torture_comment(tctx, 
 463                 "Testing a second ServerPasswordSet2 on machine account\n");
 464         torture_comment(tctx, 
 465                 "Changing machine account password to '%s' (same as previous run)\n", password);
 466 
 467         creds_client_authenticator(creds, &credential);
 468 
 469         status = dcerpc_netr_ServerPasswordSet2(p, tctx, &r);
 470         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet (3)");
 471 
 472         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 473                 torture_comment(tctx, "Credential chaining failed\n");
 474         }
 475 
 476         cli_credentials_set_password(machine_credentials, password, CRED_SPECIFIED);
 477 
 478         torture_assert (tctx, 
 479                 test_SetupCredentials(p, tctx, machine_credentials, &creds), 
 480                 "ServerPasswordSet failed to actually change the password");
 481 
 482         new_random_pass = netlogon_very_rand_pass(tctx, 128);
 483 
 484         /* now try a random stream of bytes for a password */
 485         set_pw_in_buffer(password_buf.data, &new_random_pass);
 486 
 487         creds_arcfour_crypt(creds, password_buf.data, 516);
 488 
 489         memcpy(new_password.data, password_buf.data, 512);
 490         new_password.length = IVAL(password_buf.data, 512);
 491 
 492         torture_comment(tctx, 
 493                 "Testing a third ServerPasswordSet2 on machine account, with a compleatly random password\n");
 494 
 495         creds_client_authenticator(creds, &credential);
 496 
 497         status = dcerpc_netr_ServerPasswordSet2(p, tctx, &r);
 498         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordSet (3)");
 499 
 500         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 501                 torture_comment(tctx, "Credential chaining failed\n");
 502         }
 503 
 504         mdfour(nt_hash.hash, new_random_pass.data, new_random_pass.length);
 505 
 506         cli_credentials_set_password(machine_credentials, NULL, CRED_UNINITIALISED);
 507         cli_credentials_set_nt_hash(machine_credentials, &nt_hash, CRED_SPECIFIED);
 508 
 509         torture_assert (tctx, 
 510                 test_SetupCredentials(p, tctx, machine_credentials, &creds), 
 511                 "ServerPasswordSet failed to actually change the password");
 512 
 513         return true;
 514 }
 515 
 516 static bool test_GetPassword(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 517                              struct dcerpc_pipe *p,
 518                              struct cli_credentials *machine_credentials)
 519 {
 520         struct netr_ServerPasswordGet r;
 521         struct creds_CredentialState *creds;
 522         struct netr_Authenticator credential;
 523         NTSTATUS status;
 524         struct netr_Authenticator return_authenticator;
 525         struct samr_Password password;
 526 
 527         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 528                 return false;
 529         }
 530 
 531         creds_client_authenticator(creds, &credential);
 532 
 533         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 534         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 535         r.in.secure_channel_type = SEC_CHAN_BDC;
 536         r.in.computer_name = TEST_MACHINE_NAME;
 537         r.in.credential = &credential;
 538         r.out.return_authenticator = &return_authenticator;
 539         r.out.password = &password;
 540 
 541         status = dcerpc_netr_ServerPasswordGet(p, tctx, &r);
 542         torture_assert_ntstatus_ok(tctx, status, "ServerPasswordGet");
 543 
 544         return true;
 545 }
 546 
 547 static bool test_GetTrustPasswords(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 548                                    struct dcerpc_pipe *p,
 549                                    struct cli_credentials *machine_credentials)
 550 {
 551         struct netr_ServerTrustPasswordsGet r;
 552         struct creds_CredentialState *creds;
 553         struct netr_Authenticator credential;
 554         NTSTATUS status;
 555         struct netr_Authenticator return_authenticator;
 556         struct samr_Password password, password2;
 557 
 558         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 559                 return false;
 560         }
 561 
 562         creds_client_authenticator(creds, &credential);
 563 
 564         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 565         r.in.account_name = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
 566         r.in.secure_channel_type = SEC_CHAN_BDC;
 567         r.in.computer_name = TEST_MACHINE_NAME;
 568         r.in.credential = &credential;
 569         r.out.return_authenticator = &return_authenticator;
 570         r.out.password = &password;
 571         r.out.password2 = &password2;
 572 
 573         status = dcerpc_netr_ServerTrustPasswordsGet(p, tctx, &r);
 574         torture_assert_ntstatus_ok(tctx, status, "ServerTrustPasswordsGet");
 575 
 576         return true;
 577 }
 578 
 579 /*
 580   try a netlogon SamLogon
 581 */
 582 bool test_netlogon_ops(struct dcerpc_pipe *p, struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 583                               struct cli_credentials *credentials, 
 584                               struct creds_CredentialState *creds)
 585 {
 586         NTSTATUS status;
 587         struct netr_LogonSamLogon r;
 588         struct netr_Authenticator auth, auth2;
 589         union netr_LogonLevel logon;
 590         union netr_Validation validation;
 591         uint8_t authoritative;
 592         struct netr_NetworkInfo ninfo;
 593         DATA_BLOB names_blob, chal, lm_resp, nt_resp;
 594         int i;
 595         int flags = CLI_CRED_NTLM_AUTH;
 596         if (lp_client_lanman_auth(tctx->lp_ctx)) {
 597                 flags |= CLI_CRED_LANMAN_AUTH;
 598         }
 599 
 600         if (lp_client_ntlmv2_auth(tctx->lp_ctx)) {
 601                 flags |= CLI_CRED_NTLMv2_AUTH;
 602         }
 603 
 604         cli_credentials_get_ntlm_username_domain(cmdline_credentials, tctx, 
 605                                                  &ninfo.identity_info.account_name.string,
 606                                                  &ninfo.identity_info.domain_name.string);
 607         
 608         generate_random_buffer(ninfo.challenge, 
 609                                sizeof(ninfo.challenge));
 610         chal = data_blob_const(ninfo.challenge, 
 611                                sizeof(ninfo.challenge));
 612 
 613         names_blob = NTLMv2_generate_names_blob(tctx, cli_credentials_get_workstation(credentials), 
 614                                                 cli_credentials_get_domain(credentials));
 615 
 616         status = cli_credentials_get_ntlm_response(cmdline_credentials, tctx, 
 617                                                    &flags, 
 618                                                    chal,
 619                                                    names_blob,
 620                                                    &lm_resp, &nt_resp,
 621                                                    NULL, NULL);
 622         torture_assert_ntstatus_ok(tctx, status, "cli_credentials_get_ntlm_response failed");
 623 
 624         ninfo.lm.data = lm_resp.data;
 625         ninfo.lm.length = lm_resp.length;
 626 
 627         ninfo.nt.data = nt_resp.data;
 628         ninfo.nt.length = nt_resp.length;
 629 
 630         ninfo.identity_info.parameter_control = 0;
 631         ninfo.identity_info.logon_id_low = 0;
 632         ninfo.identity_info.logon_id_high = 0;
 633         ninfo.identity_info.workstation.string = cli_credentials_get_workstation(credentials);
 634 
 635         logon.network = &ninfo;
 636 
 637         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 638         r.in.computer_name = cli_credentials_get_workstation(credentials);
 639         r.in.credential = &auth;
 640         r.in.return_authenticator = &auth2;
 641         r.in.logon_level = 2;
 642         r.in.logon = &logon;
 643         r.out.validation = &validation;
 644         r.out.authoritative = &authoritative;
 645 
 646         d_printf("Testing LogonSamLogon with name %s\n", ninfo.identity_info.account_name.string);
 647         
 648         for (i=2;i<3;i++) {
 649                 ZERO_STRUCT(auth2);
 650                 creds_client_authenticator(creds, &auth);
 651                 
 652                 r.in.validation_level = i;
 653                 
 654                 status = dcerpc_netr_LogonSamLogon(p, tctx, &r);
 655                 torture_assert_ntstatus_ok(tctx, status, "LogonSamLogon failed");
 656                 
 657                 torture_assert(tctx, creds_client_check(creds, &r.out.return_authenticator->cred), 
 658                         "Credential chaining failed");
 659         }
 660 
 661         r.in.credential = NULL;
 662 
 663         for (i=2;i<=3;i++) {
 664 
 665                 r.in.validation_level = i;
 666 
 667                 torture_comment(tctx, "Testing SamLogon with validation level %d and a NULL credential\n", i);
 668 
 669                 status = dcerpc_netr_LogonSamLogon(p, tctx, &r);
 670                 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_INVALID_PARAMETER, 
 671                         "LogonSamLogon expected INVALID_PARAMETER");
 672 
 673         }
 674 
 675         return true;
 676 }
 677 
 678 /*
 679   try a netlogon SamLogon
 680 */
 681 static bool test_SamLogon(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 682                           struct dcerpc_pipe *p,
 683                           struct cli_credentials *credentials)
 684 {
 685         struct creds_CredentialState *creds;
 686 
 687         if (!test_SetupCredentials(p, tctx, credentials, &creds)) {
 688                 return false;
 689         }
 690 
 691         return test_netlogon_ops(p, tctx, credentials, creds);
 692 }
 693 
 694 /* we remember the sequence numbers so we can easily do a DatabaseDelta */
 695 static uint64_t sequence_nums[3];
 696 
 697 /*
 698   try a netlogon DatabaseSync
 699 */
 700 static bool test_DatabaseSync(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 701                               struct dcerpc_pipe *p,
 702                               struct cli_credentials *machine_credentials)
 703 {
 704         NTSTATUS status;
 705         struct netr_DatabaseSync r;
 706         struct creds_CredentialState *creds;
 707         const uint32_t database_ids[] = {SAM_DATABASE_DOMAIN, SAM_DATABASE_BUILTIN, SAM_DATABASE_PRIVS}; 
 708         int i;
 709         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
 710         struct netr_Authenticator credential, return_authenticator;
 711 
 712         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 713                 return false;
 714         }
 715 
 716         ZERO_STRUCT(return_authenticator);
 717 
 718         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 719         r.in.computername = TEST_MACHINE_NAME;
 720         r.in.preferredmaximumlength = (uint32_t)-1;
 721         r.in.return_authenticator = &return_authenticator;
 722         r.out.delta_enum_array = &delta_enum_array;
 723         r.out.return_authenticator = &return_authenticator;
 724 
 725         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
 726 
 727                 uint32_t sync_context = 0;
 728 
 729                 r.in.database_id = database_ids[i];
 730                 r.in.sync_context = &sync_context;
 731                 r.out.sync_context = &sync_context;
 732 
 733                 torture_comment(tctx, "Testing DatabaseSync of id %d\n", r.in.database_id);
 734 
 735                 do {
 736                         creds_client_authenticator(creds, &credential);
 737 
 738                         r.in.credential = &credential;
 739 
 740                         status = dcerpc_netr_DatabaseSync(p, tctx, &r);
 741                         if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES))
 742                             break;
 743 
 744                         /* Native mode servers don't do this */
 745                         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
 746                                 return true;
 747                         }
 748                         torture_assert_ntstatus_ok(tctx, status, "DatabaseSync");
 749 
 750                         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
 751                                 torture_comment(tctx, "Credential chaining failed\n");
 752                         }
 753 
 754                         if (delta_enum_array &&
 755                             delta_enum_array->num_deltas > 0 &&
 756                             delta_enum_array->delta_enum[0].delta_type == NETR_DELTA_DOMAIN &&
 757                             delta_enum_array->delta_enum[0].delta_union.domain) {
 758                                 sequence_nums[r.in.database_id] = 
 759                                         delta_enum_array->delta_enum[0].delta_union.domain->sequence_num;
 760                                 torture_comment(tctx, "\tsequence_nums[%d]=%llu\n",
 761                                        r.in.database_id, 
 762                                        (unsigned long long)sequence_nums[r.in.database_id]);
 763                         }
 764                 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
 765         }
 766 
 767         return true;
 768 }
 769 
 770 
 771 /*
 772   try a netlogon DatabaseDeltas
 773 */
 774 static bool test_DatabaseDeltas(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
 775                                 struct dcerpc_pipe *p,
 776                                 struct cli_credentials *machine_credentials)
 777 {
 778         NTSTATUS status;
 779         struct netr_DatabaseDeltas r;
 780         struct creds_CredentialState *creds;
 781         struct netr_Authenticator credential;
 782         struct netr_Authenticator return_authenticator;
 783         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
 784         const uint32_t database_ids[] = {0, 1, 2}; 
 785         int i;
 786 
 787         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
 788                 return false;
 789         }
 790 
 791         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 792         r.in.computername = TEST_MACHINE_NAME;
 793         r.in.preferredmaximumlength = (uint32_t)-1;
 794         ZERO_STRUCT(r.in.return_authenticator);
 795         r.out.return_authenticator = &return_authenticator;
 796         r.out.delta_enum_array = &delta_enum_array;
 797 
 798         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
 799                 r.in.database_id = database_ids[i];
 800                 r.in.sequence_num = &sequence_nums[r.in.database_id];
 801 
 802                 if (*r.in.sequence_num == 0) continue;
 803 
 804                 *r.in.sequence_num -= 1;
 805 
 806                 torture_comment(tctx, "Testing DatabaseDeltas of id %d at %llu\n", 
 807                        r.in.database_id, (unsigned long long)*r.in.sequence_num);
 808 
 809                 do {
 810                         creds_client_authenticator(creds, &credential);
 811 
 812                         status = dcerpc_netr_DatabaseDeltas(p, tctx, &r);
 813                         if (NT_STATUS_EQUAL(status, 
 814                                              NT_STATUS_SYNCHRONIZATION_REQUIRED)) {
 815                                 torture_comment(tctx, "not considering %s to be an error\n",
 816                                        nt_errstr(status));
 817                                 return true;
 818                         }
 819                         if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) 
 820                             break;
 821 
 822                         torture_assert_ntstatus_ok(tctx, status, "DatabaseDeltas");
 823 
 824                         if (!creds_client_check(creds, &return_authenticator.cred)) {
 825                                 torture_comment(tctx, "Credential chaining failed\n");
 826                         }
 827 
 828                         (*r.in.sequence_num)++;
 829                 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
 830         }
 831 
 832         return true;
 833 }
 834 
 835 static bool test_DatabaseRedo(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 836                               struct dcerpc_pipe *p,
 837                               struct cli_credentials *machine_credentials)
 838 {
 839         NTSTATUS status;
 840         struct netr_DatabaseRedo r;
 841         struct creds_CredentialState *creds;
 842         struct netr_Authenticator credential;
 843         struct netr_Authenticator return_authenticator;
 844         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
 845         struct netr_ChangeLogEntry e;
 846         struct dom_sid null_sid, *sid;
 847         int i,d;
 848 
 849         ZERO_STRUCT(null_sid);
 850 
 851         sid = dom_sid_parse_talloc(tctx, "S-1-5-21-1111111111-2222222222-333333333-500");
 852 
 853         {
 854 
 855         struct {
 856                 uint32_t rid;
 857                 uint16_t flags;
 858                 uint8_t db_index;
 859                 uint8_t delta_type;
 860                 struct dom_sid sid;
 861                 const char *name;
 862                 NTSTATUS expected_error;
 863                 uint32_t expected_num_results;
 864                 uint8_t expected_delta_type_1;
 865                 uint8_t expected_delta_type_2;
 866                 const char *comment;
 867         } changes[] = {
 868 
 869                 /* SAM_DATABASE_DOMAIN */
 870 
 871                 {
 872                         .rid                    = 0,
 873                         .flags                  = 0,
 874                         .db_index               = SAM_DATABASE_DOMAIN,
 875                         .delta_type             = NETR_DELTA_MODIFY_COUNT,
 876                         .sid                    = null_sid,
 877                         .name                   = NULL,
 878                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED,
 879                         .expected_num_results   = 0,
 880                         .comment                = "NETR_DELTA_MODIFY_COUNT"
 881                 },
 882                 {
 883                         .rid                    = 0,
 884                         .flags                  = 0,
 885                         .db_index               = SAM_DATABASE_DOMAIN,
 886                         .delta_type             = 0,
 887                         .sid                    = null_sid,
 888                         .name                   = NULL,
 889                         .expected_error         = NT_STATUS_OK,
 890                         .expected_num_results   = 1,
 891                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
 892                         .comment                = "NULL DELTA"
 893                 },
 894                 {
 895                         .rid                    = 0,
 896                         .flags                  = 0,
 897                         .db_index               = SAM_DATABASE_DOMAIN,
 898                         .delta_type             = NETR_DELTA_DOMAIN,
 899                         .sid                    = null_sid,
 900                         .name                   = NULL,
 901                         .expected_error         = NT_STATUS_OK,
 902                         .expected_num_results   = 1,
 903                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
 904                         .comment                = "NETR_DELTA_DOMAIN"
 905                 },
 906                 {
 907                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
 908                         .flags                  = 0,
 909                         .db_index               = SAM_DATABASE_DOMAIN,
 910                         .delta_type             = NETR_DELTA_USER,
 911                         .sid                    = null_sid,
 912                         .name                   = NULL,
 913                         .expected_error         = NT_STATUS_OK,
 914                         .expected_num_results   = 1,
 915                         .expected_delta_type_1  = NETR_DELTA_USER,
 916                         .comment                = "NETR_DELTA_USER by rid 500"
 917                 },
 918                 {
 919                         .rid                    = DOMAIN_RID_GUEST,
 920                         .flags                  = 0,
 921                         .db_index               = SAM_DATABASE_DOMAIN,
 922                         .delta_type             = NETR_DELTA_USER,
 923                         .sid                    = null_sid,
 924                         .name                   = NULL,
 925                         .expected_error         = NT_STATUS_OK,
 926                         .expected_num_results   = 1,
 927                         .expected_delta_type_1  = NETR_DELTA_USER,
 928                         .comment                = "NETR_DELTA_USER by rid 501"
 929                 },
 930                 {
 931                         .rid                    = 0,
 932                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
 933                         .db_index               = SAM_DATABASE_DOMAIN,
 934                         .delta_type             = NETR_DELTA_USER,
 935                         .sid                    = *sid,
 936                         .name                   = NULL,
 937                         .expected_error         = NT_STATUS_OK,
 938                         .expected_num_results   = 1,
 939                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
 940                         .comment                = "NETR_DELTA_USER by sid and flags"
 941                 },
 942                 {
 943                         .rid                    = 0,
 944                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
 945                         .db_index               = SAM_DATABASE_DOMAIN,
 946                         .delta_type             = NETR_DELTA_USER,
 947                         .sid                    = null_sid,
 948                         .name                   = NULL,
 949                         .expected_error         = NT_STATUS_OK,
 950                         .expected_num_results   = 1,
 951                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
 952                         .comment                = "NETR_DELTA_USER by null_sid and flags"
 953                 },
 954                 {
 955                         .rid                    = 0,
 956                         .flags                  = NETR_CHANGELOG_NAME_INCLUDED,
 957                         .db_index               = SAM_DATABASE_DOMAIN,
 958                         .delta_type             = NETR_DELTA_USER,
 959                         .sid                    = null_sid,
 960                         .name                   = "administrator",
 961                         .expected_error         = NT_STATUS_OK,
 962                         .expected_num_results   = 1,
 963                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
 964                         .comment                = "NETR_DELTA_USER by name 'administrator'"
 965                 },
 966                 {
 967                         .rid                    = DOMAIN_RID_ADMINS,
 968                         .flags                  = 0,
 969                         .db_index               = SAM_DATABASE_DOMAIN,
 970                         .delta_type             = NETR_DELTA_GROUP,
 971                         .sid                    = null_sid,
 972                         .name                   = NULL,
 973                         .expected_error         = NT_STATUS_OK,
 974                         .expected_num_results   = 2,
 975                         .expected_delta_type_1  = NETR_DELTA_GROUP,
 976                         .expected_delta_type_2  = NETR_DELTA_GROUP_MEMBER,
 977                         .comment                = "NETR_DELTA_GROUP by rid 512"
 978                 },
 979                 {
 980                         .rid                    = DOMAIN_RID_ADMINS,
 981                         .flags                  = 0,
 982                         .db_index               = SAM_DATABASE_DOMAIN,
 983                         .delta_type             = NETR_DELTA_GROUP_MEMBER,
 984                         .sid                    = null_sid,
 985                         .name                   = NULL,
 986                         .expected_error         = NT_STATUS_OK,
 987                         .expected_num_results   = 2,
 988                         .expected_delta_type_1  = NETR_DELTA_GROUP,
 989                         .expected_delta_type_2  = NETR_DELTA_GROUP_MEMBER,
 990                         .comment                = "NETR_DELTA_GROUP_MEMBER by rid 512"
 991                 },
 992 
 993 
 994                 /* SAM_DATABASE_BUILTIN */
 995 
 996                 {
 997                         .rid                    = 0,
 998                         .flags                  = 0,
 999                         .db_index               = SAM_DATABASE_BUILTIN,
1000                         .delta_type             = NETR_DELTA_MODIFY_COUNT,
1001                         .sid                    = null_sid,
1002                         .name                   = NULL,
1003                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED,
1004                         .expected_num_results   = 0,
1005                         .comment                = "NETR_DELTA_MODIFY_COUNT"
1006                 },
1007                 {
1008                         .rid                    = 0,
1009                         .flags                  = 0,
1010                         .db_index               = SAM_DATABASE_BUILTIN,
1011                         .delta_type             = NETR_DELTA_DOMAIN,
1012                         .sid                    = null_sid,
1013                         .name                   = NULL,
1014                         .expected_error         = NT_STATUS_OK,
1015                         .expected_num_results   = 1,
1016                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1017                         .comment                = "NETR_DELTA_DOMAIN"
1018                 },
1019                 {
1020                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1021                         .flags                  = 0,
1022                         .db_index               = SAM_DATABASE_BUILTIN,
1023                         .delta_type             = NETR_DELTA_USER,
1024                         .sid                    = null_sid,
1025                         .name                   = NULL,
1026                         .expected_error         = NT_STATUS_OK,
1027                         .expected_num_results   = 1,
1028                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1029                         .comment                = "NETR_DELTA_USER by rid 500"
1030                 },
1031                 {
1032                         .rid                    = 0,
1033                         .flags                  = 0,
1034                         .db_index               = SAM_DATABASE_BUILTIN,
1035                         .delta_type             = NETR_DELTA_USER,
1036                         .sid                    = null_sid,
1037                         .name                   = NULL,
1038                         .expected_error         = NT_STATUS_OK,
1039                         .expected_num_results   = 1,
1040                         .expected_delta_type_1  = NETR_DELTA_DELETE_USER,
1041                         .comment                = "NETR_DELTA_USER"
1042                 },
1043                 {
1044                         .rid                    = 544,
1045                         .flags                  = 0,
1046                         .db_index               = SAM_DATABASE_BUILTIN,
1047                         .delta_type             = NETR_DELTA_ALIAS,
1048                         .sid                    = null_sid,
1049                         .name                   = NULL,
1050                         .expected_error         = NT_STATUS_OK,
1051                         .expected_num_results   = 2,
1052                         .expected_delta_type_1  = NETR_DELTA_ALIAS,
1053                         .expected_delta_type_2  = NETR_DELTA_ALIAS_MEMBER,
1054                         .comment                = "NETR_DELTA_ALIAS by rid 544"
1055                 },
1056                 {
1057                         .rid                    = 544,
1058                         .flags                  = 0,
1059                         .db_index               = SAM_DATABASE_BUILTIN,
1060                         .delta_type             = NETR_DELTA_ALIAS_MEMBER,
1061                         .sid                    = null_sid,
1062                         .name                   = NULL,
1063                         .expected_error         = NT_STATUS_OK,
1064                         .expected_num_results   = 2,
1065                         .expected_delta_type_1  = NETR_DELTA_ALIAS,
1066                         .expected_delta_type_2  = NETR_DELTA_ALIAS_MEMBER,
1067                         .comment                = "NETR_DELTA_ALIAS_MEMBER by rid 544"
1068                 },
1069                 {
1070                         .rid                    = 544,
1071                         .flags                  = 0,
1072                         .db_index               = SAM_DATABASE_BUILTIN,
1073                         .delta_type             = 0,
1074                         .sid                    = null_sid,
1075                         .name                   = NULL,
1076                         .expected_error         = NT_STATUS_OK,
1077                         .expected_num_results   = 1,
1078                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1079                         .comment                = "NULL DELTA by rid 544"
1080                 },
1081                 {
1082                         .rid                    = 544,
1083                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1084                         .db_index               = SAM_DATABASE_BUILTIN,
1085                         .delta_type             = 0,
1086                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32-544"),
1087                         .name                   = NULL,
1088                         .expected_error         = NT_STATUS_OK,
1089                         .expected_num_results   = 1,
1090                         .expected_delta_type_1  = NETR_DELTA_DOMAIN,
1091                         .comment                = "NULL DELTA by rid 544 sid S-1-5-32-544 and flags"
1092                 },
1093                 {
1094                         .rid                    = 544,
1095                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1096                         .db_index               = SAM_DATABASE_BUILTIN,
1097                         .delta_type             = NETR_DELTA_ALIAS,
1098                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32-544"),
1099                         .name                   = NULL,
1100                         .expected_error         = NT_STATUS_OK,
1101                         .expected_num_results   = 2,
1102                         .expected_delta_type_1  = NETR_DELTA_ALIAS,
1103                         .expected_delta_type_2  = NETR_DELTA_ALIAS_MEMBER,
1104                         .comment                = "NETR_DELTA_ALIAS by rid 544 and sid S-1-5-32-544 and flags"
1105                 },
1106                 {
1107                         .rid                    = 0,
1108                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1109                         .db_index               = SAM_DATABASE_BUILTIN,
1110                         .delta_type             = NETR_DELTA_ALIAS,
1111                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32-544"),
1112                         .name                   = NULL,
1113                         .expected_error         = NT_STATUS_OK,
1114                         .expected_num_results   = 1,
1115                         .expected_delta_type_1  = NETR_DELTA_DELETE_ALIAS,
1116                         .comment                = "NETR_DELTA_ALIAS by sid S-1-5-32-544 and flags"
1117                 },
1118 
1119                 /* SAM_DATABASE_PRIVS */
1120 
1121                 {
1122                         .rid                    = 0,
1123                         .flags                  = 0,
1124                         .db_index               = SAM_DATABASE_PRIVS,
1125                         .delta_type             = 0,
1126                         .sid                    = null_sid,
1127                         .name                   = NULL,
1128                         .expected_error         = NT_STATUS_ACCESS_DENIED,
1129                         .expected_num_results   = 0,
1130                         .comment                = "NULL DELTA"
1131                 },
1132                 {
1133                         .rid                    = 0,
1134                         .flags                  = 0,
1135                         .db_index               = SAM_DATABASE_PRIVS,
1136                         .delta_type             = NETR_DELTA_MODIFY_COUNT,
1137                         .sid                    = null_sid,
1138                         .name                   = NULL,
1139                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED,
1140                         .expected_num_results   = 0,
1141                         .comment                = "NETR_DELTA_MODIFY_COUNT"
1142                 },
1143                 {
1144                         .rid                    = 0,
1145                         .flags                  = 0,
1146                         .db_index               = SAM_DATABASE_PRIVS,
1147                         .delta_type             = NETR_DELTA_POLICY,
1148                         .sid                    = null_sid,
1149                         .name                   = NULL,
1150                         .expected_error         = NT_STATUS_OK,
1151                         .expected_num_results   = 1,
1152                         .expected_delta_type_1  = NETR_DELTA_POLICY,
1153                         .comment                = "NETR_DELTA_POLICY"
1154                 },
1155                 {
1156                         .rid                    = 0,
1157                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1158                         .db_index               = SAM_DATABASE_PRIVS,
1159                         .delta_type             = NETR_DELTA_POLICY,
1160                         .sid                    = null_sid,
1161                         .name                   = NULL,
1162                         .expected_error         = NT_STATUS_OK,
1163                         .expected_num_results   = 1,
1164                         .expected_delta_type_1  = NETR_DELTA_POLICY,
1165                         .comment                = "NETR_DELTA_POLICY by null sid and flags"
1166                 },
1167                 {
1168                         .rid                    = 0,
1169                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1170                         .db_index               = SAM_DATABASE_PRIVS,
1171                         .delta_type             = NETR_DELTA_POLICY,
1172                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-5-32"),
1173                         .name                   = NULL,
1174                         .expected_error         = NT_STATUS_OK,
1175                         .expected_num_results   = 1,
1176                         .expected_delta_type_1  = NETR_DELTA_POLICY,
1177                         .comment                = "NETR_DELTA_POLICY by sid S-1-5-32 and flags"
1178                 },
1179                 {
1180                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1181                         .flags                  = 0,
1182                         .db_index               = SAM_DATABASE_PRIVS,
1183                         .delta_type             = NETR_DELTA_ACCOUNT,
1184                         .sid                    = null_sid,
1185                         .name                   = NULL,
1186                         .expected_error         = NT_STATUS_SYNCHRONIZATION_REQUIRED, /* strange */
1187                         .expected_num_results   = 0,
1188                         .comment                = "NETR_DELTA_ACCOUNT by rid 500"
1189                 },
1190                 {
1191                         .rid                    = 0,
1192                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1193                         .db_index               = SAM_DATABASE_PRIVS,
1194                         .delta_type             = NETR_DELTA_ACCOUNT,
1195                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-1-0"),
1196                         .name                   = NULL,
1197                         .expected_error         = NT_STATUS_OK,
1198                         .expected_num_results   = 1,
1199                         .expected_delta_type_1  = NETR_DELTA_ACCOUNT,
1200                         .comment                = "NETR_DELTA_ACCOUNT by sid S-1-1-0 and flags"
1201                 },
1202                 {
1203                         .rid                    = 0,
1204                         .flags                  = NETR_CHANGELOG_SID_INCLUDED |
1205                                                   NETR_CHANGELOG_IMMEDIATE_REPL_REQUIRED,
1206                         .db_index               = SAM_DATABASE_PRIVS,
1207                         .delta_type             = NETR_DELTA_ACCOUNT,
1208                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-1-0"),
1209                         .name                   = NULL,
1210                         .expected_error         = NT_STATUS_OK,
1211                         .expected_num_results   = 1,
1212                         .expected_delta_type_1  = NETR_DELTA_ACCOUNT,
1213                         .comment                = "NETR_DELTA_ACCOUNT by sid S-1-1-0 and 2 flags"
1214                 },
1215                 {
1216                         .rid                    = 0,
1217                         .flags                  = NETR_CHANGELOG_SID_INCLUDED |
1218                                                   NETR_CHANGELOG_NAME_INCLUDED,
1219                         .db_index               = SAM_DATABASE_PRIVS,
1220                         .delta_type             = NETR_DELTA_ACCOUNT,
1221                         .sid                    = *dom_sid_parse_talloc(tctx, "S-1-1-0"),
1222                         .name                   = NULL,
1223                         .expected_error         = NT_STATUS_INVALID_PARAMETER,
1224                         .expected_num_results   = 0,
1225                         .comment                = "NETR_DELTA_ACCOUNT by sid S-1-1-0 and invalid flags"
1226                 },
1227                 {
1228                         .rid                    = DOMAIN_RID_ADMINISTRATOR,
1229                         .flags                  = NETR_CHANGELOG_SID_INCLUDED,
1230                         .db_index               = SAM_DATABASE_PRIVS,
1231                         .delta_type             = NETR_DELTA_ACCOUNT,
1232                         .sid                    = *sid,
1233                         .name                   = NULL,
1234                         .expected_error         = NT_STATUS_OK,
1235                         .expected_num_results   = 1,
1236                         .expected_delta_type_1  = NETR_DELTA_DELETE_ACCOUNT,
1237                         .comment                = "NETR_DELTA_ACCOUNT by rid 500, sid and flags"
1238                 },
1239                 {
1240                         .rid                    = 0,
1241                         .flags                  = NETR_CHANGELOG_NAME_INCLUDED,
1242                         .db_index               = SAM_DATABASE_PRIVS,
1243                         .delta_type             = NETR_DELTA_SECRET,
1244                         .sid                    = null_sid,
1245                         .name                   = "IsurelydontexistIhope",
1246                         .expected_error         = NT_STATUS_OK,
1247                         .expected_num_results   = 1,
1248                         .expected_delta_type_1  = NETR_DELTA_DELETE_SECRET,
1249                         .comment                = "NETR_DELTA_SECRET by name 'IsurelydontexistIhope' and flags"
1250                 },
1251                 {
1252                         .rid                    = 0,
1253                         .flags                  = NETR_CHANGELOG_NAME_INCLUDED,
1254                         .db_index               = SAM_DATABASE_PRIVS,
1255                         .delta_type             = NETR_DELTA_SECRET,
1256                         .sid                    = null_sid,
1257                         .name                   = "G$BCKUPKEY_P",
1258                         .expected_error         = NT_STATUS_OK,
1259                         .expected_num_results   = 1,
1260                         .expected_delta_type_1  = NETR_DELTA_SECRET,
1261                         .comment                = "NETR_DELTA_SECRET by name 'G$BCKUPKEY_P' and flags"
1262                 }
1263         };
1264 
1265         ZERO_STRUCT(return_authenticator);
1266 
1267         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1268         r.in.computername = TEST_MACHINE_NAME;
1269         r.in.return_authenticator = &return_authenticator;
1270         r.out.return_authenticator = &return_authenticator;
1271         r.out.delta_enum_array = &delta_enum_array;
1272 
1273         for (d=0; d<3; d++) {
1274 
1275                 const char *database;
1276 
1277                 switch (d) {
1278                 case 0:
1279                         database = "SAM";
1280                         break;
1281                 case 1:
1282                         database = "BUILTIN";
1283                         break;
1284                 case 2:
1285                         database = "LSA";
1286                         break;
1287                 default:
1288                         break;
1289                 }
1290 
1291                 torture_comment(tctx, "Testing DatabaseRedo\n");
1292 
1293                 if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1294                         return false;
1295                 }
1296 
1297                 for (i=0;i<ARRAY_SIZE(changes);i++) {
1298 
1299                         if (d != changes[i].db_index) {
1300                                 continue;
1301                         }
1302 
1303                         creds_client_authenticator(creds, &credential);
1304 
1305                         r.in.credential = &credential;
1306 
1307                         e.serial_number1        = 0;
1308                         e.serial_number2        = 0;
1309                         e.object_rid            = changes[i].rid;
1310                         e.flags                 = changes[i].flags;
1311                         e.db_index              = changes[i].db_index;
1312                         e.delta_type            = changes[i].delta_type;
1313 
1314                         switch (changes[i].flags & (NETR_CHANGELOG_NAME_INCLUDED | NETR_CHANGELOG_SID_INCLUDED)) {
1315                         case NETR_CHANGELOG_SID_INCLUDED:
1316                                 e.object.object_sid             = changes[i].sid;
1317                                 break;
1318                         case NETR_CHANGELOG_NAME_INCLUDED:
1319                                 e.object.object_name            = changes[i].name;
1320                                 break;
1321                         default:
1322                                 break;
1323                         }
1324 
1325                         r.in.change_log_entry = e;
1326 
1327                         torture_comment(tctx, "Testing DatabaseRedo with database %s and %s\n",
1328                                 database, changes[i].comment);
1329 
1330                         status = dcerpc_netr_DatabaseRedo(p, tctx, &r);
1331                         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
1332                                 return true;
1333                         }
1334 
1335                         torture_assert_ntstatus_equal(tctx, status, changes[i].expected_error, changes[i].comment);
1336                         if (delta_enum_array) {
1337                                 torture_assert_int_equal(tctx,
1338                                         delta_enum_array->num_deltas,
1339                                         changes[i].expected_num_results,
1340                                         changes[i].comment);
1341                                 if (delta_enum_array->num_deltas > 0) {
1342                                         torture_assert_int_equal(tctx,
1343                                                 delta_enum_array->delta_enum[0].delta_type,
1344                                                 changes[i].expected_delta_type_1,
1345                                                 changes[i].comment);
1346                                 }
1347                                 if (delta_enum_array->num_deltas > 1) {
1348                                         torture_assert_int_equal(tctx,
1349                                                 delta_enum_array->delta_enum[1].delta_type,
1350                                                 changes[i].expected_delta_type_2,
1351                                                 changes[i].comment);
1352                                 }
1353                         }
1354 
1355                         if (!creds_client_check(creds, &return_authenticator.cred)) {
1356                                 torture_comment(tctx, "Credential chaining failed\n");
1357                                 if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1358                                         return false;
1359                                 }
1360                         }
1361                 }
1362         }
1363         }
1364 
1365         return true;
1366 }
1367 
1368 /*
1369   try a netlogon AccountDeltas
1370 */
1371 static bool test_AccountDeltas(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1372                                struct dcerpc_pipe *p,
1373                                struct cli_credentials *machine_credentials)
1374 {
1375         NTSTATUS status;
1376         struct netr_AccountDeltas r;
1377         struct creds_CredentialState *creds;
1378 
1379         struct netr_AccountBuffer buffer;
1380         uint32_t count_returned = 0;
1381         uint32_t total_entries = 0;
1382         struct netr_UAS_INFO_0 recordid;
1383         struct netr_Authenticator return_authenticator;
1384 
1385         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1386                 return false;
1387         }
1388 
1389         ZERO_STRUCT(return_authenticator);
1390 
1391         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1392         r.in.computername = TEST_MACHINE_NAME;
1393         r.in.return_authenticator = &return_authenticator;
1394         creds_client_authenticator(creds, &r.in.credential);
1395         ZERO_STRUCT(r.in.uas);
1396         r.in.count=10;
1397         r.in.level=0;
1398         r.in.buffersize=100;
1399         r.out.buffer = &buffer;
1400         r.out.count_returned = &count_returned;
1401         r.out.total_entries = &total_entries;
1402         r.out.recordid = &recordid;
1403         r.out.return_authenticator = &return_authenticator;
1404 
1405         /* w2k3 returns "NOT IMPLEMENTED" for this call */
1406         status = dcerpc_netr_AccountDeltas(p, tctx, &r);
1407         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_IMPLEMENTED, "AccountDeltas");
1408 
1409         return true;
1410 }
1411 
1412 /*
1413   try a netlogon AccountSync
1414 */
1415 static bool test_AccountSync(struct torture_context *tctx, struct dcerpc_pipe *p, 
     /* [<][>][^][v][top][bottom][index][help] */
1416                              struct cli_credentials *machine_credentials)
1417 {
1418         NTSTATUS status;
1419         struct netr_AccountSync r;
1420         struct creds_CredentialState *creds;
1421 
1422         struct netr_AccountBuffer buffer;
1423         uint32_t count_returned = 0;
1424         uint32_t total_entries = 0;
1425         uint32_t next_reference = 0;
1426         struct netr_UAS_INFO_0 recordid;
1427         struct netr_Authenticator return_authenticator;
1428 
1429         ZERO_STRUCT(recordid);
1430         ZERO_STRUCT(return_authenticator);
1431 
1432         if (!test_SetupCredentials(p, tctx, machine_credentials, &creds)) {
1433                 return false;
1434         }
1435 
1436         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1437         r.in.computername = TEST_MACHINE_NAME;
1438         r.in.return_authenticator = &return_authenticator;
1439         creds_client_authenticator(creds, &r.in.credential);
1440         r.in.recordid = &recordid;
1441         r.in.reference=0;
1442         r.in.level=0;
1443         r.in.buffersize=100;
1444         r.out.buffer = &buffer;
1445         r.out.count_returned = &count_returned;
1446         r.out.total_entries = &total_entries;
1447         r.out.next_reference = &next_reference;
1448         r.out.recordid = &recordid;
1449         r.out.return_authenticator = &return_authenticator;
1450 
1451         /* w2k3 returns "NOT IMPLEMENTED" for this call */
1452         status = dcerpc_netr_AccountSync(p, tctx, &r);
1453         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_IMPLEMENTED, "AccountSync");
1454 
1455         return true;
1456 }
1457 
1458 /*
1459   try a netlogon GetDcName
1460 */
1461 static bool test_GetDcName(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1462                            struct dcerpc_pipe *p)
1463 {
1464         NTSTATUS status;
1465         struct netr_GetDcName r;
1466         const char *dcname = NULL;
1467 
1468         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1469         r.in.domainname = lp_workgroup(tctx->lp_ctx);
1470         r.out.dcname = &dcname;
1471 
1472         status = dcerpc_netr_GetDcName(p, tctx, &r);
1473         torture_assert_ntstatus_ok(tctx, status, "GetDcName");
1474         torture_assert_werr_ok(tctx, r.out.result, "GetDcName");
1475 
1476         torture_comment(tctx, "\tDC is at '%s'\n", dcname);
1477 
1478         return true;
1479 }
1480 
1481 /*
1482   try a netlogon LogonControl 
1483 */
1484 static bool test_LogonControl(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1485                               struct dcerpc_pipe *p)
1486 {
1487         NTSTATUS status;
1488         struct netr_LogonControl r;
1489         union netr_CONTROL_QUERY_INFORMATION info;
1490         int i;
1491 
1492         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1493         r.in.function_code = 1;
1494         r.out.info = &info;
1495 
1496         for (i=1;i<4;i++) {
1497                 r.in.level = i;
1498 
1499                 torture_comment(tctx, "Testing LogonControl level %d\n", i);
1500 
1501                 status = dcerpc_netr_LogonControl(p, tctx, &r);
1502                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1503         }
1504 
1505         return true;
1506 }
1507 
1508 
1509 /*
1510   try a netlogon GetAnyDCName
1511 */
1512 static bool test_GetAnyDCName(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1513                               struct dcerpc_pipe *p)
1514 {
1515         NTSTATUS status;
1516         struct netr_GetAnyDCName r;
1517         const char *dcname = NULL;
1518 
1519         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1520         r.in.domainname = lp_workgroup(tctx->lp_ctx);
1521         r.out.dcname = &dcname;
1522 
1523         status = dcerpc_netr_GetAnyDCName(p, tctx, &r);
1524         torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
1525         torture_assert_werr_ok(tctx, r.out.result, "GetAnyDCName");
1526 
1527         if (dcname) {
1528             torture_comment(tctx, "\tDC is at '%s'\n", dcname);
1529         }
1530 
1531         return true;
1532 }
1533 
1534 
1535 /*
1536   try a netlogon LogonControl2
1537 */
1538 static bool test_LogonControl2(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1539                                struct dcerpc_pipe *p)
1540 {
1541         NTSTATUS status;
1542         struct netr_LogonControl2 r;
1543         union netr_CONTROL_DATA_INFORMATION data;
1544         union netr_CONTROL_QUERY_INFORMATION query;
1545         int i;
1546 
1547         data.domain = lp_workgroup(tctx->lp_ctx);
1548 
1549         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1550 
1551         r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
1552         r.in.data = &data;
1553         r.out.query = &query;
1554 
1555         for (i=1;i<4;i++) {
1556                 r.in.level = i;
1557 
1558                 torture_comment(tctx, "Testing LogonControl2 level %d function %d\n", 
1559                        i, r.in.function_code);
1560 
1561                 status = dcerpc_netr_LogonControl2(p, tctx, &r);
1562                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1563         }
1564 
1565         data.domain = lp_workgroup(tctx->lp_ctx);
1566 
1567         r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
1568         r.in.data = &data;
1569 
1570         for (i=1;i<4;i++) {
1571                 r.in.level = i;
1572 
1573                 torture_comment(tctx, "Testing LogonControl2 level %d function %d\n", 
1574                        i, r.in.function_code);
1575 
1576                 status = dcerpc_netr_LogonControl2(p, tctx, &r);
1577                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1578         }
1579 
1580         data.domain = lp_workgroup(tctx->lp_ctx);
1581 
1582         r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
1583         r.in.data = &data;
1584 
1585         for (i=1;i<4;i++) {
1586                 r.in.level = i;
1587 
1588                 torture_comment(tctx, "Testing LogonControl2 level %d function %d\n", 
1589                        i, r.in.function_code);
1590 
1591                 status = dcerpc_netr_LogonControl2(p, tctx, &r);
1592                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1593         }
1594 
1595         data.debug_level = ~0;
1596 
1597         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
1598         r.in.data = &data;
1599 
1600         for (i=1;i<4;i++) {
1601                 r.in.level = i;
1602 
1603                 torture_comment(tctx, "Testing LogonControl2 level %d function %d\n", 
1604                        i, r.in.function_code);
1605 
1606                 status = dcerpc_netr_LogonControl2(p, tctx, &r);
1607                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1608         }
1609 
1610         return true;
1611 }
1612 
1613 /*
1614   try a netlogon DatabaseSync2
1615 */
1616 static bool test_DatabaseSync2(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1617                                struct dcerpc_pipe *p,
1618                                struct cli_credentials *machine_credentials)
1619 {
1620         NTSTATUS status;
1621         struct netr_DatabaseSync2 r;
1622         struct netr_DELTA_ENUM_ARRAY *delta_enum_array = NULL;
1623         struct netr_Authenticator return_authenticator, credential;
1624 
1625         struct creds_CredentialState *creds;
1626         const uint32_t database_ids[] = {0, 1, 2}; 
1627         int i;
1628 
1629         if (!test_SetupCredentials2(p, tctx, NETLOGON_NEG_AUTH2_FLAGS, 
1630                                     machine_credentials,
1631                                     SEC_CHAN_BDC, &creds)) {
1632                 return false;
1633         }
1634 
1635         ZERO_STRUCT(return_authenticator);
1636 
1637         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1638         r.in.computername = TEST_MACHINE_NAME;
1639         r.in.preferredmaximumlength = (uint32_t)-1;
1640         r.in.return_authenticator = &return_authenticator;
1641         r.out.return_authenticator = &return_authenticator;
1642         r.out.delta_enum_array = &delta_enum_array;
1643 
1644         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
1645 
1646                 uint32_t sync_context = 0;
1647 
1648                 r.in.database_id = database_ids[i];
1649                 r.in.sync_context = &sync_context;
1650                 r.out.sync_context = &sync_context;
1651                 r.in.restart_state = 0;
1652 
1653                 torture_comment(tctx, "Testing DatabaseSync2 of id %d\n", r.in.database_id);
1654 
1655                 do {
1656                         creds_client_authenticator(creds, &credential);
1657 
1658                         r.in.credential = &credential;
1659 
1660                         status = dcerpc_netr_DatabaseSync2(p, tctx, &r);
1661                         if (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES))
1662                             break;
1663 
1664                         /* Native mode servers don't do this */
1665                         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
1666                                 return true;
1667                         }
1668 
1669                         torture_assert_ntstatus_ok(tctx, status, "DatabaseSync2");
1670 
1671                         if (!creds_client_check(creds, &r.out.return_authenticator->cred)) {
1672                                 torture_comment(tctx, "Credential chaining failed\n");
1673                         }
1674 
1675                 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
1676         }
1677 
1678         return true;
1679 }
1680 
1681 
1682 /*
1683   try a netlogon LogonControl2Ex
1684 */
1685 static bool test_LogonControl2Ex(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1686                                  struct dcerpc_pipe *p)
1687 {
1688         NTSTATUS status;
1689         struct netr_LogonControl2Ex r;
1690         union netr_CONTROL_DATA_INFORMATION data;
1691         union netr_CONTROL_QUERY_INFORMATION query;
1692         int i;
1693 
1694         data.domain = lp_workgroup(tctx->lp_ctx);
1695 
1696         r.in.logon_server = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1697 
1698         r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
1699         r.in.data = &data;
1700         r.out.query = &query;
1701 
1702         for (i=1;i<4;i++) {
1703                 r.in.level = i;
1704 
1705                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n", 
1706                        i, r.in.function_code);
1707 
1708                 status = dcerpc_netr_LogonControl2Ex(p, tctx, &r);
1709                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1710         }
1711 
1712         data.domain = lp_workgroup(tctx->lp_ctx);
1713 
1714         r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
1715         r.in.data = &data;
1716 
1717         for (i=1;i<4;i++) {
1718                 r.in.level = i;
1719 
1720                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n", 
1721                        i, r.in.function_code);
1722 
1723                 status = dcerpc_netr_LogonControl2Ex(p, tctx, &r);
1724                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1725         }
1726 
1727         data.domain = lp_workgroup(tctx->lp_ctx);
1728 
1729         r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
1730         r.in.data = &data;
1731 
1732         for (i=1;i<4;i++) {
1733                 r.in.level = i;
1734 
1735                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n", 
1736                        i, r.in.function_code);
1737 
1738                 status = dcerpc_netr_LogonControl2Ex(p, tctx, &r);
1739                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1740         }
1741 
1742         data.debug_level = ~0;
1743 
1744         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
1745         r.in.data = &data;
1746 
1747         for (i=1;i<4;i++) {
1748                 r.in.level = i;
1749 
1750                 torture_comment(tctx, "Testing LogonControl2Ex level %d function %d\n", 
1751                        i, r.in.function_code);
1752 
1753                 status = dcerpc_netr_LogonControl2Ex(p, tctx, &r);
1754                 torture_assert_ntstatus_ok(tctx, status, "LogonControl");
1755         }
1756 
1757         return true;
1758 }
1759 
1760 static bool test_netr_DsRGetForestTrustInformation(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1761                                                    struct dcerpc_pipe *p, const char *trusted_domain_name) 
1762 {
1763         NTSTATUS status;
1764         struct netr_DsRGetForestTrustInformation r;
1765         struct lsa_ForestTrustInformation info, *info_ptr;
1766 
1767         info_ptr = &info;
1768 
1769         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1770         r.in.trusted_domain_name = trusted_domain_name;
1771         r.in.flags = 0;
1772         r.out.forest_trust_info = &info_ptr;
1773 
1774         torture_comment(tctx ,"Testing netr_DsRGetForestTrustInformation\n");
1775 
1776         status = dcerpc_netr_DsRGetForestTrustInformation(p, tctx, &r);
1777         torture_assert_ntstatus_ok(tctx, status, "DsRGetForestTrustInformation");
1778         torture_assert_werr_ok(tctx, r.out.result, "DsRGetForestTrustInformation");
1779 
1780         return true;
1781 }
1782 
1783 /*
1784   try a netlogon netr_DsrEnumerateDomainTrusts
1785 */
1786 static bool test_DsrEnumerateDomainTrusts(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1787                                           struct dcerpc_pipe *p)
1788 {
1789         NTSTATUS status;
1790         struct netr_DsrEnumerateDomainTrusts r;
1791         struct netr_DomainTrustList trusts;
1792         int i;
1793 
1794         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1795         r.in.trust_flags = 0x3f;
1796         r.out.trusts = &trusts;
1797 
1798         status = dcerpc_netr_DsrEnumerateDomainTrusts(p, tctx, &r);
1799         torture_assert_ntstatus_ok(tctx, status, "DsrEnumerateDomaintrusts");
1800         torture_assert_werr_ok(tctx, r.out.result, "DsrEnumerateDomaintrusts");
1801 
1802         /* when trusted_domain_name is NULL, netr_DsRGetForestTrustInformation
1803          * will show non-forest trusts and all UPN suffixes of the own forest
1804          * as LSA_FOREST_TRUST_TOP_LEVEL_NAME types */
1805 
1806         if (r.out.trusts->count) {
1807                 if (!test_netr_DsRGetForestTrustInformation(tctx, p, NULL)) {
1808                         return false;
1809                 }
1810         }
1811 
1812         for (i=0; i<r.out.trusts->count; i++) {
1813 
1814                 /* get info for transitive forest trusts */
1815 
1816                 if (r.out.trusts->array[i].trust_attributes & NETR_TRUST_ATTRIBUTE_FOREST_TRANSITIVE) {
1817                         if (!test_netr_DsRGetForestTrustInformation(tctx, p, 
1818                                                                     r.out.trusts->array[i].dns_name)) {
1819                                 return false;
1820                         }
1821                 }
1822         }
1823 
1824         return true;
1825 }
1826 
1827 static bool test_netr_NetrEnumerateTrustedDomains(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1828                                                   struct dcerpc_pipe *p)
1829 {
1830         NTSTATUS status;
1831         struct netr_NetrEnumerateTrustedDomains r;
1832         struct netr_Blob trusted_domains_blob;
1833 
1834         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1835         r.out.trusted_domains_blob = &trusted_domains_blob;
1836 
1837         status = dcerpc_netr_NetrEnumerateTrustedDomains(p, tctx, &r);
1838         torture_assert_ntstatus_ok(tctx, status, "netr_NetrEnumerateTrustedDomains");
1839         torture_assert_werr_ok(tctx, r.out.result, "NetrEnumerateTrustedDomains");
1840 
1841         return true;
1842 }
1843 
1844 static bool test_netr_NetrEnumerateTrustedDomainsEx(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1845                                                     struct dcerpc_pipe *p)
1846 {
1847         NTSTATUS status;
1848         struct netr_NetrEnumerateTrustedDomainsEx r;
1849         struct netr_DomainTrustList dom_trust_list;
1850 
1851         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1852         r.out.dom_trust_list = &dom_trust_list;
1853 
1854         status = dcerpc_netr_NetrEnumerateTrustedDomainsEx(p, tctx, &r);
1855         torture_assert_ntstatus_ok(tctx, status, "netr_NetrEnumerateTrustedDomainsEx");
1856         torture_assert_werr_ok(tctx, r.out.result, "NetrEnumerateTrustedDomainsEx");
1857 
1858         return true;
1859 }
1860 
1861 
1862 static bool test_netr_DsRGetSiteName(struct dcerpc_pipe *p, struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1863                                      const char *computer_name, 
1864                                      const char *expected_site) 
1865 {
1866         NTSTATUS status;
1867         struct netr_DsRGetSiteName r;
1868         const char *site = NULL;
1869 
1870         if (torture_setting_bool(tctx, "samba4", false))
1871                 torture_skip(tctx, "skipping DsRGetSiteName test against Samba4");
1872 
1873         r.in.computer_name              = computer_name;
1874         r.out.site                      = &site;
1875         torture_comment(tctx, "Testing netr_DsRGetSiteName\n");
1876 
1877         status = dcerpc_netr_DsRGetSiteName(p, tctx, &r);
1878         torture_assert_ntstatus_ok(tctx, status, "DsRGetSiteName");
1879         torture_assert_werr_ok(tctx, r.out.result, "DsRGetSiteName");
1880         torture_assert_str_equal(tctx, expected_site, site, "netr_DsRGetSiteName");
1881 
1882         r.in.computer_name              = talloc_asprintf(tctx, "\\\\%s", computer_name);
1883         torture_comment(tctx, 
1884                         "Testing netr_DsRGetSiteName with broken computer name: %s\n", r.in.computer_name);
1885 
1886         status = dcerpc_netr_DsRGetSiteName(p, tctx, &r);
1887         torture_assert_ntstatus_ok(tctx, status, "DsRGetSiteName");
1888         torture_assert_werr_equal(tctx, r.out.result, WERR_INVALID_COMPUTERNAME, "netr_DsRGetSiteName");
1889 
1890         return true;
1891 }
1892 
1893 /*
1894   try a netlogon netr_DsRGetDCName
1895 */
1896 static bool test_netr_DsRGetDCName(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1897                                    struct dcerpc_pipe *p)
1898 {
1899         NTSTATUS status;
1900         struct netr_DsRGetDCName r;
1901         struct netr_DsRGetDCNameInfo *info = NULL;
1902 
1903         r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1904         r.in.domain_name        = talloc_asprintf(tctx, "%s", lp_realm(tctx->lp_ctx));
1905         r.in.domain_guid        = NULL;
1906         r.in.site_guid          = NULL;
1907         r.in.flags              = DS_RETURN_DNS_NAME;
1908         r.out.info              = &info;
1909 
1910         status = dcerpc_netr_DsRGetDCName(p, tctx, &r);
1911         torture_assert_ntstatus_ok(tctx, status, "DsRGetDCName");
1912         torture_assert_werr_ok(tctx, r.out.result, "DsRGetDCName");
1913         return test_netr_DsRGetSiteName(p, tctx, 
1914                                        info->dc_unc,
1915                                        info->dc_site_name);
1916 }
1917 
1918 /*
1919   try a netlogon netr_DsRGetDCNameEx
1920 */
1921 static bool test_netr_DsRGetDCNameEx(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1922                                      struct dcerpc_pipe *p)
1923 {
1924         NTSTATUS status;
1925         struct netr_DsRGetDCNameEx r;
1926         struct netr_DsRGetDCNameInfo *info = NULL;
1927 
1928         r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1929         r.in.domain_name        = talloc_asprintf(tctx, "%s", lp_realm(tctx->lp_ctx));
1930         r.in.domain_guid        = NULL;
1931         r.in.site_name          = NULL;
1932         r.in.flags              = DS_RETURN_DNS_NAME;
1933         r.out.info              = &info;
1934 
1935         status = dcerpc_netr_DsRGetDCNameEx(p, tctx, &r);
1936         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx");
1937         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx");
1938 
1939         return test_netr_DsRGetSiteName(p, tctx, info->dc_unc,
1940                                         info->dc_site_name);
1941 }
1942 
1943 /*
1944   try a netlogon netr_DsRGetDCNameEx2
1945 */
1946 static bool test_netr_DsRGetDCNameEx2(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1947                                       struct dcerpc_pipe *p)
1948 {
1949         NTSTATUS status;
1950         struct netr_DsRGetDCNameEx2 r;
1951         struct netr_DsRGetDCNameInfo *info = NULL;
1952 
1953         r.in.server_unc         = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1954         r.in.client_account     = NULL;
1955         r.in.mask               = 0x00000000;
1956         r.in.domain_name        = talloc_asprintf(tctx, "%s", lp_realm(tctx->lp_ctx));
1957         r.in.domain_guid        = NULL;
1958         r.in.site_name          = NULL;
1959         r.in.flags              = DS_RETURN_DNS_NAME;
1960         r.out.info              = &info;
1961 
1962         torture_comment(tctx, "Testing netr_DsRGetDCNameEx2 without client account\n");
1963 
1964         status = dcerpc_netr_DsRGetDCNameEx2(p, tctx, &r);
1965         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
1966         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
1967 
1968         torture_comment(tctx, "Testing netr_DsRGetDCNameEx2 with client acount\n");
1969         r.in.client_account     = TEST_MACHINE_NAME"$";
1970         r.in.mask               = ACB_SVRTRUST;
1971         r.in.flags              = DS_RETURN_FLAT_NAME;
1972         r.out.info              = &info;
1973 
1974         status = dcerpc_netr_DsRGetDCNameEx2(p, tctx, &r);
1975         torture_assert_ntstatus_ok(tctx, status, "netr_DsRGetDCNameEx2");
1976         torture_assert_werr_ok(tctx, r.out.result, "netr_DsRGetDCNameEx2");
1977         return test_netr_DsRGetSiteName(p, tctx, info->dc_unc,
1978                                         info->dc_site_name);
1979 }
1980 
1981 static bool test_netr_DsrGetDcSiteCoverageW(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
1982                                             struct dcerpc_pipe *p)
1983 {
1984         NTSTATUS status;
1985         struct netr_DsrGetDcSiteCoverageW r;
1986         struct DcSitesCtr *ctr = NULL;
1987 
1988         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
1989         r.out.ctr = &ctr;
1990 
1991         status = dcerpc_netr_DsrGetDcSiteCoverageW(p, tctx, &r);
1992         torture_assert_ntstatus_ok(tctx, status, "failed");
1993         torture_assert_werr_ok(tctx, r.out.result, "failed");
1994 
1995         return true;
1996 }
1997 
1998 static bool test_netr_DsRAddressToSitenamesW(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1999                                              struct dcerpc_pipe *p)
2000 {
2001         NTSTATUS status;
2002         struct netr_DsRAddressToSitenamesW r;
2003         struct netr_DsRAddress addr;
2004         struct netr_DsRAddressToSitenamesWCtr *ctr;
2005 
2006         ctr = talloc(tctx, struct netr_DsRAddressToSitenamesWCtr);
2007 
2008         addr.size = 16;
2009         addr.buffer = talloc_zero_array(tctx, uint8_t, addr.size);
2010 
2011         addr.buffer[0] = 2; /* AF_INET */
2012         addr.buffer[4] = 127;
2013         addr.buffer[5] = 0;
2014         addr.buffer[6] = 0;
2015         addr.buffer[7] = 1;
2016 
2017         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2018         r.in.count = 1;
2019         r.in.addresses = talloc_zero_array(tctx, struct netr_DsRAddress, r.in.count);
2020         r.in.addresses[0] = addr;
2021         r.out.ctr = &ctr;
2022 
2023         status = dcerpc_netr_DsRAddressToSitenamesW(p, tctx, &r);
2024         torture_assert_ntstatus_ok(tctx, status, "failed");
2025         torture_assert_werr_ok(tctx, r.out.result, "failed");
2026 
2027         return true;
2028 }
2029 
2030 static bool test_netr_DsRAddressToSitenamesExW(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
2031                                                struct dcerpc_pipe *p)
2032 {
2033         NTSTATUS status;
2034         struct netr_DsRAddressToSitenamesExW r;
2035         struct netr_DsRAddress addr;
2036         struct netr_DsRAddressToSitenamesExWCtr *ctr;
2037 
2038         ctr = talloc(tctx, struct netr_DsRAddressToSitenamesExWCtr);
2039 
2040         addr.size = 16;
2041         addr.buffer = talloc_zero_array(tctx, uint8_t, addr.size);
2042 
2043         addr.buffer[0] = 2; /* AF_INET */
2044         addr.buffer[4] = 127;
2045         addr.buffer[5] = 0;
2046         addr.buffer[6] = 0;
2047         addr.buffer[7] = 1;
2048 
2049         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2050         r.in.count = 1;
2051         r.in.addresses = talloc_zero_array(tctx, struct netr_DsRAddress, r.in.count);
2052         r.in.addresses[0] = addr;
2053         r.out.ctr = &ctr;
2054 
2055         status = dcerpc_netr_DsRAddressToSitenamesExW(p, tctx, &r);
2056         torture_assert_ntstatus_ok(tctx, status, "failed");
2057         torture_assert_werr_ok(tctx, r.out.result, "failed");
2058 
2059         return true;
2060 }
2061 
2062 static bool test_netr_ServerGetTrustInfo(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
2063                                          struct dcerpc_pipe *p,
2064                                          struct cli_credentials *machine_credentials)
2065 {
2066         NTSTATUS status;
2067         struct netr_ServerGetTrustInfo r;
2068 
2069         struct netr_Authenticator a;
2070         struct netr_Authenticator return_authenticator;
2071         struct samr_Password new_owf_password;
2072         struct samr_Password old_owf_password;
2073         struct netr_TrustInfo *trust_info;
2074 
2075         struct creds_CredentialState *creds;
2076 
2077         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS,
2078                                     machine_credentials, &creds)) {
2079                 return false;
2080         }
2081 
2082         creds_client_authenticator(creds, &a);
2083 
2084         r.in.server_name                = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2085         r.in.account_name               = talloc_asprintf(tctx, "%s$", TEST_MACHINE_NAME);
2086         r.in.secure_channel_type        = SEC_CHAN_BDC;
2087         r.in.computer_name              = TEST_MACHINE_NAME;
2088         r.in.credential                 = &a;
2089 
2090         r.out.return_authenticator      = &return_authenticator;
2091         r.out.new_owf_password          = &new_owf_password;
2092         r.out.old_owf_password          = &old_owf_password;
2093         r.out.trust_info                = &trust_info;
2094 
2095         status = dcerpc_netr_ServerGetTrustInfo(p, tctx, &r);
2096         torture_assert_ntstatus_ok(tctx, status, "failed");
2097         torture_assert(tctx, creds_client_check(creds, &return_authenticator.cred), "Credential chaining failed");
2098 
2099         return true;
2100 }
2101 
2102 
2103 static bool test_GetDomainInfo(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
2104                                struct dcerpc_pipe *p,
2105                                struct cli_credentials *machine_credentials)
2106 {
2107         NTSTATUS status;
2108         struct netr_LogonGetDomainInfo r;
2109         struct netr_DomainQuery1 q1;
2110         struct netr_Authenticator a;
2111         struct creds_CredentialState *creds;
2112         union netr_DomainInfo info;
2113 
2114         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS, 
2115                                     machine_credentials, &creds)) {
2116                 return false;
2117         }
2118 
2119         ZERO_STRUCT(r);
2120 
2121         creds_client_authenticator(creds, &a);
2122 
2123         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2124         r.in.computer_name = TEST_MACHINE_NAME;
2125         r.in.level = 1;
2126         r.in.credential = &a;
2127         r.in.return_authenticator = &a;
2128         r.out.return_authenticator = &a;
2129         r.out.info = &info;
2130 
2131         r.in.query.query1 = &q1;
2132         ZERO_STRUCT(q1);
2133         
2134         /* this should really be the fully qualified name */
2135         q1.workstation_domain = TEST_MACHINE_NAME;
2136         q1.workstation_site = "Default-First-Site-Name";
2137         q1.blob2.length = 0;
2138         q1.blob2.size = 0;
2139         q1.blob2.array = NULL;
2140         q1.product.string = "product string";
2141 
2142         torture_comment(tctx, "Testing netr_LogonGetDomainInfo\n");
2143 
2144         status = dcerpc_netr_LogonGetDomainInfo(p, tctx, &r);
2145         torture_assert_ntstatus_ok(tctx, status, "netr_LogonGetDomainInfo");
2146         torture_assert(tctx, creds_client_check(creds, &a.cred), "Credential chaining failed");
2147 
2148         torture_comment(tctx, "Testing netr_LogonGetDomainInfo 2nd call\n");
2149         creds_client_authenticator(creds, &a);
2150 
2151         status = dcerpc_netr_LogonGetDomainInfo(p, tctx, &r);
2152         torture_assert_ntstatus_ok(tctx, status, "netr_LogonGetDomainInfo");
2153         torture_assert(tctx, creds_client_check(creds, &a.cred), "Credential chaining failed");
2154 
2155         return true;
2156 }
2157 
2158 
2159 static void async_callback(struct rpc_request *req)
     /* [<][>][^][v][top][bottom][index][help] */
2160 {
2161         int *counter = (int *)req->async.private_data;
2162         if (NT_STATUS_IS_OK(req->status)) {
2163                 (*counter)++;
2164         }
2165 }
2166 
2167 static bool test_GetDomainInfo_async(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
2168                                      struct dcerpc_pipe *p,
2169                                      struct cli_credentials *machine_credentials)
2170 {
2171         NTSTATUS status;
2172         struct netr_LogonGetDomainInfo r;
2173         struct netr_DomainQuery1 q1;
2174         struct netr_Authenticator a;
2175 #define ASYNC_COUNT 100
2176         struct creds_CredentialState *creds;
2177         struct creds_CredentialState *creds_async[ASYNC_COUNT];
2178         struct rpc_request *req[ASYNC_COUNT];
2179         int i;
2180         int *async_counter = talloc(tctx, int);
2181         union netr_DomainInfo info;
2182 
2183         if (!test_SetupCredentials3(p, tctx, NETLOGON_NEG_AUTH2_ADS_FLAGS, 
2184                                     machine_credentials, &creds)) {
2185                 return false;
2186         }
2187 
2188         ZERO_STRUCT(r);
2189         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
2190         r.in.computer_name = TEST_MACHINE_NAME;
2191         r.in.level = 1;
2192         r.in.credential = &a;
2193         r.in.return_authenticator = &a;
2194         r.out.return_authenticator = &a;
2195         r.out.info = &info;
2196 
2197         r.in.query.query1 = &q1;
2198         ZERO_STRUCT(q1);
2199         
2200         /* this should really be the fully qualified name */
2201         q1.workstation_domain = TEST_MACHINE_NAME;
2202         q1.workstation_site = "Default-First-Site-Name";
2203         q1.blob2.length = 0;
2204         q1.blob2.size = 0;
2205         q1.blob2.array = NULL;
2206         q1.product.string = "product string";
2207 
2208         torture_comment(tctx, "Testing netr_LogonGetDomainInfo - async count %d\n", ASYNC_COUNT);
2209 
2210         *async_counter = 0;
2211 
2212         for (i=0;i<ASYNC_COUNT;i++) {
2213                 creds_client_authenticator(creds, &a);
2214 
2215                 creds_async[i] = (struct creds_CredentialState *)talloc_memdup(creds, creds, sizeof(*creds));
2216                 req[i] = dcerpc_netr_LogonGetDomainInfo_send(p, tctx, &r);
2217 
2218                 req[i]->async.callback = async_callback;
2219                 req[i]->async.private_data = async_counter;
2220 
2221                 /* even with this flush per request a w2k3 server seems to 
2222                    clag with multiple outstanding requests. bleergh. */
2223                 torture_assert_int_equal(tctx, event_loop_once(dcerpc_event_context(p)), 0, 
2224                                          "event_loop_once failed");
2225         }
2226 
2227         for (i=0;i<ASYNC_COUNT;i++) {
2228                 status = dcerpc_ndr_request_recv(req[i]);
2229 
2230                 torture_assert_ntstatus_ok(tctx, status, "netr_LogonGetDomainInfo_async");
2231                 torture_assert_ntstatus_ok(tctx, r.out.result, "netr_LogonGetDomainInfo_async"); 
2232 
2233                 torture_assert(tctx, creds_client_check(creds_async[i], &a.cred), 
2234                         "Credential chaining failed at async");
2235         }
2236 
2237         torture_comment(tctx, 
2238                         "Testing netr_LogonGetDomainInfo - async count %d OK\n", *async_counter);
2239 
2240         torture_assert_int_equal(tctx, (*async_counter), ASYNC_COUNT, "int");
2241 
2242         return true;
2243 }
2244 
2245 static bool test_ManyGetDCName(struct torture_context *tctx, 
     /* [<][>][^][v][top][bottom][index][help] */
2246                                struct dcerpc_pipe *p)
2247 {
2248         NTSTATUS status;
2249         struct dcerpc_pipe *p2;
2250         struct lsa_ObjectAttribute attr;
2251         struct lsa_QosInfo qos;
2252         struct lsa_OpenPolicy2 o;
2253         struct policy_handle lsa_handle;
2254         struct lsa_DomainList domains;
2255 
2256         struct lsa_EnumTrustDom t;
2257         uint32_t resume_handle = 0;
2258         struct netr_GetAnyDCName d;
2259         const char *dcname = NULL;
2260 
2261         int i;
2262 
2263         if (p->conn->transport.transport != NCACN_NP) {
2264                 return true;
2265         }
2266 
2267         torture_comment(tctx, "Torturing GetDCName\n");
2268 
2269         status = dcerpc_secondary_connection(p, &p2, p->binding);
2270         torture_assert_ntstatus_ok(tctx, status, "Failed to create secondary connection");
2271 
2272         status = dcerpc_bind_auth_none(p2, &ndr_table_lsarpc);
2273         torture_assert_ntstatus_ok(tctx, status, "Failed to create bind on secondary connection");
2274 
2275         qos.len = 0;
2276         qos.impersonation_level = 2;
2277         qos.context_mode = 1;
2278         qos.effective_only = 0;
2279 
2280         attr.len = 0;
2281         attr.root_dir = NULL;
2282         attr.object_name = NULL;
2283         attr.attributes = 0;
2284         attr.sec_desc = NULL;
2285         attr.sec_qos = &qos;
2286 
2287         o.in.system_name = "\\";
2288         o.in.attr = &attr;
2289         o.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
2290         o.out.handle = &lsa_handle;
2291 
2292         status = dcerpc_lsa_OpenPolicy2(p2, tctx, &o);
2293         torture_assert_ntstatus_ok(tctx, status, "OpenPolicy2 failed");
2294 
2295         t.in.handle = &lsa_handle;
2296         t.in.resume_handle = &resume_handle;
2297         t.in.max_size = 1000;
2298         t.out.domains = &domains;
2299         t.out.resume_handle = &resume_handle;
2300 
2301         status = dcerpc_lsa_EnumTrustDom(p2, tctx, &t);
2302 
2303         if ((!NT_STATUS_IS_OK(status) &&
2304              (!NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES))))
2305                 torture_fail(tctx, "Could not list domains");
2306 
2307         talloc_free(p2);
2308 
2309         d.in.logon_server = talloc_asprintf(tctx, "\\\\%s",
2310                                             dcerpc_server_name(p));
2311         d.out.dcname = &dcname;
2312 
2313         for (i=0; i<domains.count * 4; i++) {
2314                 struct lsa_DomainInfo *info =
2315                         &domains.domains[rand()%domains.count];
2316 
2317                 d.in.domainname = info->name.string;
2318 
2319                 status = dcerpc_netr_GetAnyDCName(p, tctx, &d);
2320                 torture_assert_ntstatus_ok(tctx, status, "GetAnyDCName");
2321 
2322                 torture_comment(tctx, "\tDC for domain %s is %s\n", info->name.string,
2323                        dcname ? dcname : "unknown");
2324         }
2325 
2326         return true;
2327 }
2328 
2329 struct torture_suite *torture_rpc_netlogon(TALLOC_CTX *mem_ctx)
     /* [<][>][^][v][top][bottom][index][help] */
2330 {
2331         struct torture_suite *suite = torture_suite_create(mem_ctx, "NETLOGON");
2332         struct torture_rpc_tcase *tcase;
2333         struct torture_test *test;
2334 
2335         tcase = torture_suite_add_machine_rpc_iface_tcase(suite, "netlogon", 
2336                                                   &ndr_table_netlogon, TEST_MACHINE_NAME);
2337 
2338         torture_rpc_tcase_add_test(tcase, "LogonUasLogon", test_LogonUasLogon);
2339         torture_rpc_tcase_add_test(tcase, "LogonUasLogoff", test_LogonUasLogoff);
2340         torture_rpc_tcase_add_test_creds(tcase, "SamLogon", test_SamLogon);
2341         torture_rpc_tcase_add_test_creds(tcase, "SetPassword", test_SetPassword);
2342         torture_rpc_tcase_add_test_creds(tcase, "SetPassword2", test_SetPassword2);
2343         torture_rpc_tcase_add_test_creds(tcase, "GetPassword", test_GetPassword);
2344         torture_rpc_tcase_add_test_creds(tcase, "GetTrustPasswords", test_GetTrustPasswords);
2345         torture_rpc_tcase_add_test_creds(tcase, "GetDomainInfo", test_GetDomainInfo);
2346         torture_rpc_tcase_add_test_creds(tcase, "DatabaseSync", test_DatabaseSync);
2347         torture_rpc_tcase_add_test_creds(tcase, "DatabaseDeltas", test_DatabaseDeltas);
2348         torture_rpc_tcase_add_test_creds(tcase, "DatabaseRedo", test_DatabaseRedo);
2349         torture_rpc_tcase_add_test_creds(tcase, "AccountDeltas", test_AccountDeltas);
2350         torture_rpc_tcase_add_test_creds(tcase, "AccountSync", test_AccountSync);
2351         torture_rpc_tcase_add_test(tcase, "GetDcName", test_GetDcName);
2352         torture_rpc_tcase_add_test(tcase, "ManyGetDCName", test_ManyGetDCName);
2353         torture_rpc_tcase_add_test(tcase, "LogonControl", test_LogonControl);
2354         torture_rpc_tcase_add_test(tcase, "GetAnyDCName", test_GetAnyDCName);
2355         torture_rpc_tcase_add_test(tcase, "LogonControl2", test_LogonControl2);
2356         torture_rpc_tcase_add_test_creds(tcase, "DatabaseSync2", test_DatabaseSync2);
2357         torture_rpc_tcase_add_test(tcase, "LogonControl2Ex", test_LogonControl2Ex);
2358         torture_rpc_tcase_add_test(tcase, "DsrEnumerateDomainTrusts", test_DsrEnumerateDomainTrusts);
2359         torture_rpc_tcase_add_test(tcase, "NetrEnumerateTrustedDomains", test_netr_NetrEnumerateTrustedDomains);
2360         torture_rpc_tcase_add_test(tcase, "NetrEnumerateTrustedDomainsEx", test_netr_NetrEnumerateTrustedDomainsEx);
2361         test = torture_rpc_tcase_add_test_creds(tcase, "GetDomainInfo_async", test_GetDomainInfo_async);
2362         test->dangerous = true;
2363         torture_rpc_tcase_add_test(tcase, "DsRGetDCName", test_netr_DsRGetDCName);
2364         torture_rpc_tcase_add_test(tcase, "DsRGetDCNameEx", test_netr_DsRGetDCNameEx);
2365         torture_rpc_tcase_add_test(tcase, "DsRGetDCNameEx2", test_netr_DsRGetDCNameEx2);
2366         torture_rpc_tcase_add_test(tcase, "DsrGetDcSiteCoverageW", test_netr_DsrGetDcSiteCoverageW);
2367         torture_rpc_tcase_add_test(tcase, "DsRAddressToSitenamesW", test_netr_DsRAddressToSitenamesW);
2368         torture_rpc_tcase_add_test(tcase, "DsRAddressToSitenamesExW", test_netr_DsRAddressToSitenamesExW);
2369         torture_rpc_tcase_add_test_creds(tcase, "ServerGetTrustInfo", test_netr_ServerGetTrustInfo);
2370 
2371         return suite;
2372 }

/* [<][>][^][v][top][bottom][index][help] */