2 Unix SMB/CIFS implementation.
3 test suite for samr rpc operations
5 Copyright (C) Andrew Tridgell 2003
6 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2003
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #define TEST_ACCOUNT_NAME "samrtorturetest"
26 #define TEST_ALIASNAME "samrtorturetestalias"
27 #define TEST_GROUPNAME "samrtorturetestgroup"
28 #define TEST_MACHINENAME "samrtorturetestmach$"
29 #define TEST_DOMAINNAME "samrtorturetestdom$"
32 static BOOL test_QueryUserInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
33 struct policy_handle *handle);
35 static BOOL test_QueryUserInfo2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
36 struct policy_handle *handle);
38 static BOOL test_QueryAliasInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
39 struct policy_handle *handle);
41 static void init_samr_Name(struct samr_Name *name, const char *s)
46 static BOOL test_Close(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
47 struct policy_handle *handle)
53 r.out.handle = handle;
55 status = dcerpc_samr_Close(p, mem_ctx, &r);
56 if (!NT_STATUS_IS_OK(status)) {
57 printf("Close handle failed - %s\n", nt_errstr(status));
64 static BOOL test_Shutdown(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
65 struct policy_handle *handle)
68 struct samr_Shutdown r;
70 if (lp_parm_int(-1, "torture", "dangerous") != 1) {
71 printf("samr_Shutdown disabled - enable dangerous tests to use\n");
77 printf("testing samr_Shutdown\n");
79 status = dcerpc_samr_Shutdown(p, mem_ctx, &r);
80 if (!NT_STATUS_IS_OK(status)) {
81 printf("samr_Shutdown failed - %s\n", nt_errstr(status));
88 static BOOL test_SetDsrmPassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
89 struct policy_handle *handle)
92 struct samr_SetDsrmPassword r;
93 struct samr_Name name;
94 struct samr_Password hash;
96 if (lp_parm_int(-1, "torture", "dangerous") != 1) {
97 printf("samr_SetDsrmPassword disabled - enable dangerous tests to use\n");
101 E_md4hash("TeSTDSRM123", hash.hash);
103 init_samr_Name(&name, "Administrator");
109 printf("testing samr_SetDsrmPassword\n");
111 status = dcerpc_samr_SetDsrmPassword(p, mem_ctx, &r);
112 if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)) {
113 printf("samr_SetDsrmPassword failed - %s\n", nt_errstr(status));
121 static BOOL test_QuerySecurity(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
122 struct policy_handle *handle)
125 struct samr_QuerySecurity r;
126 struct samr_SetSecurity s;
128 r.in.handle = handle;
131 status = dcerpc_samr_QuerySecurity(p, mem_ctx, &r);
132 if (!NT_STATUS_IS_OK(status)) {
133 printf("QuerySecurity failed - %s\n", nt_errstr(status));
137 if (s.in.sdbuf == NULL) {
141 s.in.handle = handle;
143 s.in.sdbuf = r.out.sdbuf;
145 status = dcerpc_samr_SetSecurity(p, mem_ctx, &s);
146 if (!NT_STATUS_IS_OK(status)) {
147 printf("SetSecurity failed - %s\n", nt_errstr(status));
151 status = dcerpc_samr_QuerySecurity(p, mem_ctx, &r);
152 if (!NT_STATUS_IS_OK(status)) {
153 printf("QuerySecurity failed - %s\n", nt_errstr(status));
161 static BOOL test_SetUserInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
162 struct policy_handle *handle)
165 struct samr_SetUserInfo s;
166 struct samr_SetUserInfo2 s2;
167 struct samr_QueryUserInfo q;
168 struct samr_QueryUserInfo q0;
169 union samr_UserInfo u;
172 s.in.handle = handle;
175 s2.in.handle = handle;
178 q.in.handle = handle;
182 #define TESTCALL(call, r) \
183 status = dcerpc_samr_ ##call(p, mem_ctx, &r); \
184 if (!NT_STATUS_IS_OK(status)) { \
185 printf(#call " level %u failed - %s (line %d)\n", \
186 r.in.level, nt_errstr(status), __LINE__); \
191 #define STRING_EQUAL(s1, s2, field) \
192 if ((s1 && !s2) || (s2 && !s1) || strcmp(s1, s2)) { \
193 printf("Failed to set %s to '%s' (line %d)\n", \
194 #field, s2, __LINE__); \
199 #define INT_EQUAL(i1, i2, field) \
201 printf("Failed to set %s to %u (line %d)\n", \
202 #field, i2, __LINE__); \
207 #define TEST_USERINFO_NAME(lvl1, field1, lvl2, field2, value, fpval) do { \
208 printf("field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
210 TESTCALL(QueryUserInfo, q) \
212 s2.in.level = lvl1; \
215 ZERO_STRUCT(u.info21); \
216 u.info21.fields_present = fpval; \
218 init_samr_Name(&u.info ## lvl1.field1, value); \
219 TESTCALL(SetUserInfo, s) \
220 TESTCALL(SetUserInfo2, s2) \
221 init_samr_Name(&u.info ## lvl1.field1, ""); \
222 TESTCALL(QueryUserInfo, q); \
224 STRING_EQUAL(u.info ## lvl1.field1.name, value, field1); \
226 TESTCALL(QueryUserInfo, q) \
228 STRING_EQUAL(u.info ## lvl2.field2.name, value, field2); \
231 #define TEST_USERINFO_INT(lvl1, field1, lvl2, field2, value, fpval) do { \
232 printf("field test %d/%s vs %d/%s\n", lvl1, #field1, lvl2, #field2); \
234 TESTCALL(QueryUserInfo, q) \
236 s2.in.level = lvl1; \
239 uint8_t *bitmap = u.info21.logon_hours.bitmap; \
240 ZERO_STRUCT(u.info21); \
241 if (fpval == SAMR_FIELD_LOGON_HOURS) { \
242 u.info21.logon_hours.units_per_week = 168; \
243 u.info21.logon_hours.bitmap = bitmap; \
245 u.info21.fields_present = fpval; \
247 u.info ## lvl1.field1 = value; \
248 TESTCALL(SetUserInfo, s) \
249 TESTCALL(SetUserInfo2, s2) \
250 u.info ## lvl1.field1 = 0; \
251 TESTCALL(QueryUserInfo, q); \
253 INT_EQUAL(u.info ## lvl1.field1, value, field1); \
255 TESTCALL(QueryUserInfo, q) \
257 INT_EQUAL(u.info ## lvl2.field2, value, field1); \
261 do { TESTCALL(QueryUserInfo, q0) } while (0);
263 TEST_USERINFO_NAME(2, comment, 1, comment, "xx2-1 comment", 0);
264 TEST_USERINFO_NAME(2, comment, 21, comment, "xx2-21 comment", 0);
265 TEST_USERINFO_NAME(21, comment, 21, comment, "xx21-21 comment",
268 TEST_USERINFO_NAME(6, full_name, 1, full_name, "xx6-1 full_name", 0);
269 TEST_USERINFO_NAME(6, full_name, 3, full_name, "xx6-3 full_name", 0);
270 TEST_USERINFO_NAME(6, full_name, 5, full_name, "xx6-5 full_name", 0);
271 TEST_USERINFO_NAME(6, full_name, 6, full_name, "xx6-6 full_name", 0);
272 TEST_USERINFO_NAME(6, full_name, 8, full_name, "xx6-8 full_name", 0);
273 TEST_USERINFO_NAME(6, full_name, 21, full_name, "xx6-21 full_name", 0);
274 TEST_USERINFO_NAME(8, full_name, 21, full_name, "xx8-21 full_name", 0);
275 TEST_USERINFO_NAME(21, full_name, 21, full_name, "xx21-21 full_name",
278 TEST_USERINFO_NAME(11, logon_script, 3, logon_script, "xx11-3 logon_script", 0);
279 TEST_USERINFO_NAME(11, logon_script, 5, logon_script, "xx11-5 logon_script", 0);
280 TEST_USERINFO_NAME(11, logon_script, 21, logon_script, "xx11-21 logon_script", 0);
281 TEST_USERINFO_NAME(21, logon_script, 21, logon_script, "xx21-21 logon_script",
282 SAMR_FIELD_LOGON_SCRIPT);
284 TEST_USERINFO_NAME(12, profile_path, 3, profile_path, "xx12-3 profile_path", 0);
285 TEST_USERINFO_NAME(12, profile_path, 5, profile_path, "xx12-5 profile_path", 0);
286 TEST_USERINFO_NAME(12, profile_path, 21, profile_path, "xx12-21 profile_path", 0);
287 TEST_USERINFO_NAME(21, profile_path, 21, profile_path, "xx21-21 profile_path",
288 SAMR_FIELD_PROFILE_PATH);
290 TEST_USERINFO_NAME(13, description, 1, description, "xx13-1 description", 0);
291 TEST_USERINFO_NAME(13, description, 5, description, "xx13-5 description", 0);
292 TEST_USERINFO_NAME(13, description, 21, description, "xx13-21 description", 0);
293 TEST_USERINFO_NAME(21, description, 21, description, "xx21-21 description",
294 SAMR_FIELD_DESCRIPTION);
296 TEST_USERINFO_NAME(14, workstations, 3, workstations, "14workstation3", 0);
297 TEST_USERINFO_NAME(14, workstations, 5, workstations, "14workstation4", 0);
298 TEST_USERINFO_NAME(14, workstations, 21, workstations, "14workstation21", 0);
299 TEST_USERINFO_NAME(21, workstations, 21, workstations, "21workstation21",
300 SAMR_FIELD_WORKSTATION);
302 TEST_USERINFO_NAME(20, callback, 21, callback, "xx20-21 callback", 0);
303 TEST_USERINFO_NAME(21, callback, 21, callback, "xx21-21 callback",
304 SAMR_FIELD_CALLBACK);
306 TEST_USERINFO_INT(2, country_code, 21, country_code, __LINE__, 0);
307 TEST_USERINFO_INT(21, country_code, 21, country_code, __LINE__,
308 SAMR_FIELD_COUNTRY_CODE);
310 TEST_USERINFO_INT(2, code_page, 21, code_page, __LINE__, 0);
311 TEST_USERINFO_INT(21, code_page, 21, code_page, __LINE__,
312 SAMR_FIELD_CODE_PAGE);
314 TEST_USERINFO_INT(4, logon_hours.bitmap[3], 3, logon_hours.bitmap[3], 1, 0);
315 TEST_USERINFO_INT(4, logon_hours.bitmap[3], 5, logon_hours.bitmap[3], 2, 0);
316 TEST_USERINFO_INT(4, logon_hours.bitmap[3], 21, logon_hours.bitmap[3], 3, 0);
317 TEST_USERINFO_INT(21, logon_hours.bitmap[3], 21, logon_hours.bitmap[3], 4,
318 SAMR_FIELD_LOGON_HOURS);
321 /* these fail with win2003 - it appears you can't set the primary gid?
322 the set succeeds, but the gid isn't changed. Very weird! */
323 TEST_USERINFO_INT(9, primary_gid, 1, primary_gid, 513);
324 TEST_USERINFO_INT(9, primary_gid, 3, primary_gid, 513);
325 TEST_USERINFO_INT(9, primary_gid, 5, primary_gid, 513);
326 TEST_USERINFO_INT(9, primary_gid, 21, primary_gid, 513);
332 generate a random password for password change tests
334 static char *samr_rand_pass(TALLOC_CTX *mem_ctx)
336 size_t len = 8 + (random() % 6);
337 char *s = generate_random_str(mem_ctx, len);
338 printf("Generated password '%s'\n", s);
342 static BOOL test_SetUserPass(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
343 struct policy_handle *handle, char **password)
346 struct samr_SetUserInfo s;
347 union samr_UserInfo u;
349 DATA_BLOB session_key;
350 char *newpass = samr_rand_pass(mem_ctx);
352 s.in.handle = handle;
356 encode_pw_buffer(u.info24.password.data, newpass, STR_UNICODE);
357 /* w2k3 ignores this length */
358 u.info24.pw_len = str_charnum(newpass)*2;
360 status = dcerpc_fetch_session_key(p, &session_key);
361 if (!NT_STATUS_IS_OK(status)) {
362 printf("SetUserInfo level %u - no session key - %s\n",
363 s.in.level, nt_errstr(status));
367 arcfour_crypt_blob(u.info24.password.data, 516, &session_key);
369 printf("Testing SetUserInfo level 24 (set password)\n");
371 status = dcerpc_samr_SetUserInfo(p, mem_ctx, &s);
372 if (!NT_STATUS_IS_OK(status)) {
373 printf("SetUserInfo level %u failed - %s\n",
374 s.in.level, nt_errstr(status));
384 static BOOL test_SetUserPass_23(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
385 struct policy_handle *handle, char **password)
388 struct samr_SetUserInfo s;
389 union samr_UserInfo u;
391 DATA_BLOB session_key;
392 char *newpass = samr_rand_pass(mem_ctx);
394 s.in.handle = handle;
400 u.info23.info.fields_present = SAMR_FIELD_PASSWORD;
402 encode_pw_buffer(u.info23.password.data, newpass, STR_UNICODE);
404 status = dcerpc_fetch_session_key(p, &session_key);
405 if (!NT_STATUS_IS_OK(status)) {
406 printf("SetUserInfo level %u - no session key - %s\n",
407 s.in.level, nt_errstr(status));
411 arcfour_crypt_blob(u.info23.password.data, 516, &session_key);
413 printf("Testing SetUserInfo level 23 (set password)\n");
415 status = dcerpc_samr_SetUserInfo(p, mem_ctx, &s);
416 if (!NT_STATUS_IS_OK(status)) {
417 printf("SetUserInfo level %u failed - %s\n",
418 s.in.level, nt_errstr(status));
428 static BOOL test_SetUserPassEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
429 struct policy_handle *handle, char **password)
432 struct samr_SetUserInfo s;
433 union samr_UserInfo u;
435 DATA_BLOB session_key;
436 DATA_BLOB confounded_session_key = data_blob_talloc(mem_ctx, NULL, 16);
437 uint8_t confounder[16];
438 char *newpass = samr_rand_pass(mem_ctx);
439 struct MD5Context ctx;
441 s.in.handle = handle;
445 encode_pw_buffer(u.info26.password.data, newpass, STR_UNICODE);
446 u.info26.pw_len = strlen(newpass);
448 status = dcerpc_fetch_session_key(p, &session_key);
449 if (!NT_STATUS_IS_OK(status)) {
450 printf("SetUserInfo level %u - no session key - %s\n",
451 s.in.level, nt_errstr(status));
455 generate_random_buffer((uint8_t *)confounder, 16, False);
458 MD5Update(&ctx, confounder, 16);
459 MD5Update(&ctx, session_key.data, session_key.length);
460 MD5Final(confounded_session_key.data, &ctx);
462 arcfour_crypt_blob(u.info26.password.data, 516, &confounded_session_key);
463 memcpy(&u.info26.password.data[516], confounder, 16);
465 printf("Testing SetUserInfo level 26 (set password ex)\n");
467 status = dcerpc_samr_SetUserInfo(p, mem_ctx, &s);
468 if (!NT_STATUS_IS_OK(status)) {
469 printf("SetUserInfo level %u failed - %s\n",
470 s.in.level, nt_errstr(status));
479 static BOOL test_SetUserPass_25(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
480 struct policy_handle *handle, char **password)
483 struct samr_SetUserInfo s;
484 union samr_UserInfo u;
486 DATA_BLOB session_key;
487 DATA_BLOB confounded_session_key = data_blob_talloc(mem_ctx, NULL, 16);
488 uint8_t confounder[16];
489 char *newpass = samr_rand_pass(mem_ctx);
490 struct MD5Context ctx;
492 s.in.handle = handle;
498 u.info25.info.fields_present = SAMR_FIELD_PASSWORD;
500 encode_pw_buffer(u.info25.password.data, newpass, STR_UNICODE);
502 status = dcerpc_fetch_session_key(p, &session_key);
503 if (!NT_STATUS_IS_OK(status)) {
504 printf("SetUserInfo level %u - no session key - %s\n",
505 s.in.level, nt_errstr(status));
509 generate_random_buffer((uint8_t *)confounder, 16, False);
512 MD5Update(&ctx, confounder, 16);
513 MD5Update(&ctx, session_key.data, session_key.length);
514 MD5Final(confounded_session_key.data, &ctx);
516 arcfour_crypt_blob(u.info25.password.data, 516, &confounded_session_key);
517 memcpy(&u.info25.password.data[516], confounder, 16);
519 printf("Testing SetUserInfo level 25 (set password ex)\n");
521 status = dcerpc_samr_SetUserInfo(p, mem_ctx, &s);
522 if (!NT_STATUS_IS_OK(status)) {
523 printf("SetUserInfo level %u failed - %s\n",
524 s.in.level, nt_errstr(status));
533 static BOOL test_SetAliasInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
534 struct policy_handle *handle)
537 struct samr_SetAliasInfo r;
538 struct samr_QueryAliasInfo q;
539 uint16_t levels[] = {2, 3};
543 /* Ignoring switch level 1, as that includes the number of members for the alias
544 * and setting this to a wrong value might have negative consequences
547 for (i=0;i<ARRAY_SIZE(levels);i++) {
548 printf("Testing SetAliasInfo level %u\n", levels[i]);
550 r.in.handle = handle;
551 r.in.level = levels[i];
552 switch (r.in.level) {
553 case 2 : init_samr_Name(&r.in.info.name,TEST_ALIASNAME); break;
554 case 3 : init_samr_Name(&r.in.info.description,
555 "Test Description, should test I18N as well"); break;
558 status = dcerpc_samr_SetAliasInfo(p, mem_ctx, &r);
559 if (!NT_STATUS_IS_OK(status)) {
560 printf("SetAliasInfo level %u failed - %s\n",
561 levels[i], nt_errstr(status));
565 q.in.handle = handle;
566 q.in.level = levels[i];
568 status = dcerpc_samr_QueryAliasInfo(p, mem_ctx, &q);
569 if (!NT_STATUS_IS_OK(status)) {
570 printf("QueryAliasInfo level %u failed - %s\n",
571 levels[i], nt_errstr(status));
579 static BOOL test_GetGroupsForUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
580 struct policy_handle *user_handle)
582 struct samr_GetGroupsForUser r;
586 printf("testing GetGroupsForUser\n");
588 r.in.handle = user_handle;
590 status = dcerpc_samr_GetGroupsForUser(p, mem_ctx, &r);
591 if (!NT_STATUS_IS_OK(status)) {
592 printf("GetGroupsForUser failed - %s\n",nt_errstr(status));
600 static BOOL test_GetDomPwInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
601 struct samr_Name *domain_name)
604 struct samr_GetDomPwInfo r;
607 r.in.name = domain_name;
608 printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
610 status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
611 if (!NT_STATUS_IS_OK(status)) {
612 printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
616 r.in.name->name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
617 printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
619 status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
620 if (!NT_STATUS_IS_OK(status)) {
621 printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
625 r.in.name->name = "\\\\__NONAME__";
626 printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
628 status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
629 if (!NT_STATUS_IS_OK(status)) {
630 printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
634 r.in.name->name = "\\\\Builtin";
635 printf("Testing GetDomPwInfo with name %s\n", r.in.name->name);
637 status = dcerpc_samr_GetDomPwInfo(p, mem_ctx, &r);
638 if (!NT_STATUS_IS_OK(status)) {
639 printf("GetDomPwInfo failed - %s\n", nt_errstr(status));
647 static BOOL test_GetUserPwInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
648 struct policy_handle *handle)
651 struct samr_GetUserPwInfo r;
654 printf("Testing GetUserPwInfo\n");
656 r.in.handle = handle;
658 status = dcerpc_samr_GetUserPwInfo(p, mem_ctx, &r);
659 if (!NT_STATUS_IS_OK(status)) {
660 printf("GetUserPwInfo failed - %s\n", nt_errstr(status));
667 static NTSTATUS test_LookupName(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
668 struct policy_handle *domain_handle, const char *name,
672 struct samr_LookupNames n;
673 struct samr_Name sname[2];
675 init_samr_Name(&sname[0], name);
677 n.in.handle = domain_handle;
680 status = dcerpc_samr_LookupNames(p, mem_ctx, &n);
681 if (NT_STATUS_IS_OK(status)) {
682 *rid = n.out.rids.ids[0];
687 init_samr_Name(&sname[1], "xxNONAMExx");
689 status = dcerpc_samr_LookupNames(p, mem_ctx, &n);
690 if (!NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
691 printf("LookupNames[2] failed - %s\n", nt_errstr(status));
695 init_samr_Name(&sname[1], "xxNONAMExx");
697 status = dcerpc_samr_LookupNames(p, mem_ctx, &n);
698 if (!NT_STATUS_IS_OK(status)) {
699 printf("LookupNames[0] failed - %s\n", nt_errstr(status));
705 static NTSTATUS test_OpenUser_byname(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
706 struct policy_handle *domain_handle,
707 const char *name, struct policy_handle *user_handle)
710 struct samr_OpenUser r;
713 status = test_LookupName(p, mem_ctx, domain_handle, name, &rid);
714 if (!NT_STATUS_IS_OK(status)) {
718 r.in.handle = domain_handle;
719 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
721 r.out.acct_handle = user_handle;
722 status = dcerpc_samr_OpenUser(p, mem_ctx, &r);
723 if (!NT_STATUS_IS_OK(status)) {
724 printf("OpenUser_byname(%s) failed - %s\n", name, nt_errstr(status));
731 static BOOL test_ChangePasswordUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
732 struct policy_handle *handle, char **password)
735 struct samr_ChangePasswordUser r;
737 struct samr_Password hash1, hash2, hash3, hash4, hash5, hash6;
738 struct policy_handle user_handle;
739 char *oldpass = *password;
740 char *newpass = samr_rand_pass(mem_ctx);
741 uint8_t old_nt_hash[16], new_nt_hash[16];
742 uint8_t old_lm_hash[16], new_lm_hash[16];
744 status = test_OpenUser_byname(p, mem_ctx, handle, TEST_ACCOUNT_NAME, &user_handle);
745 if (!NT_STATUS_IS_OK(status)) {
749 printf("Testing ChangePasswordUser\n");
751 E_md4hash(oldpass, old_nt_hash);
752 E_md4hash(newpass, new_nt_hash);
753 E_deshash(oldpass, old_lm_hash);
754 E_deshash(newpass, new_lm_hash);
756 E_old_pw_hash(new_lm_hash, old_lm_hash, hash1.hash);
757 E_old_pw_hash(old_lm_hash, new_lm_hash, hash2.hash);
758 E_old_pw_hash(new_nt_hash, old_nt_hash, hash3.hash);
759 E_old_pw_hash(old_nt_hash, new_nt_hash, hash4.hash);
760 E_old_pw_hash(old_lm_hash, new_nt_hash, hash5.hash);
761 E_old_pw_hash(old_nt_hash, new_lm_hash, hash6.hash);
763 r.in.handle = &user_handle;
765 r.in.old_lm_crypted = &hash1;
766 r.in.new_lm_crypted = &hash2;
768 r.in.old_nt_crypted = &hash3;
769 r.in.new_nt_crypted = &hash4;
770 r.in.cross1_present = 1;
771 r.in.nt_cross = &hash5;
772 r.in.cross2_present = 1;
773 r.in.lm_cross = &hash6;
775 status = dcerpc_samr_ChangePasswordUser(p, mem_ctx, &r);
776 if (!NT_STATUS_IS_OK(status)) {
777 printf("ChangePasswordUser failed - %s\n", nt_errstr(status));
783 if (!test_Close(p, mem_ctx, &user_handle)) {
791 static BOOL test_OemChangePasswordUser2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
792 struct policy_handle *handle, char **password)
795 struct samr_OemChangePasswordUser2 r;
797 struct samr_Password lm_verifier;
798 struct samr_CryptPassword lm_pass;
799 struct samr_AsciiName server, account;
800 char *oldpass = *password;
801 char *newpass = samr_rand_pass(mem_ctx);
802 uint8_t old_lm_hash[16], new_lm_hash[16];
804 printf("Testing OemChangePasswordUser2\n");
806 server.name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
807 account.name = TEST_ACCOUNT_NAME;
809 E_deshash(oldpass, old_lm_hash);
810 E_deshash(newpass, new_lm_hash);
812 encode_pw_buffer(lm_pass.data, newpass, STR_ASCII);
813 arcfour_crypt(lm_pass.data, old_lm_hash, 516);
814 E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
816 r.in.server = &server;
817 r.in.account = &account;
818 r.in.password = &lm_pass;
819 r.in.hash = &lm_verifier;
821 status = dcerpc_samr_OemChangePasswordUser2(p, mem_ctx, &r);
822 if (!NT_STATUS_IS_OK(status)) {
823 printf("OemChangePasswordUser2 failed - %s\n", nt_errstr(status));
833 static BOOL test_ChangePasswordUser2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
834 struct policy_handle *handle, char **password)
837 struct samr_ChangePasswordUser2 r;
839 struct samr_Name server, account;
840 struct samr_CryptPassword nt_pass, lm_pass;
841 struct samr_Password nt_verifier, lm_verifier;
842 char *oldpass = *password;
843 char *newpass = samr_rand_pass(mem_ctx);
844 uint8_t old_nt_hash[16], new_nt_hash[16];
845 uint8_t old_lm_hash[16], new_lm_hash[16];
847 printf("Testing ChangePasswordUser2\n");
849 server.name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
850 init_samr_Name(&account, TEST_ACCOUNT_NAME);
852 E_md4hash(oldpass, old_nt_hash);
853 E_md4hash(newpass, new_nt_hash);
855 E_deshash(oldpass, old_lm_hash);
856 E_deshash(newpass, new_lm_hash);
858 encode_pw_buffer(lm_pass.data, newpass, STR_ASCII|STR_TERMINATE);
859 arcfour_crypt(lm_pass.data, old_lm_hash, 516);
860 E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
862 encode_pw_buffer(nt_pass.data, newpass, STR_UNICODE);
863 arcfour_crypt(nt_pass.data, old_nt_hash, 516);
864 E_old_pw_hash(new_nt_hash, old_nt_hash, nt_verifier.hash);
866 r.in.server = &server;
867 r.in.account = &account;
868 r.in.nt_password = &nt_pass;
869 r.in.nt_verifier = &nt_verifier;
871 r.in.lm_password = &lm_pass;
872 r.in.lm_verifier = &lm_verifier;
874 status = dcerpc_samr_ChangePasswordUser2(p, mem_ctx, &r);
875 if (!NT_STATUS_IS_OK(status)) {
876 printf("ChangePasswordUser2 failed - %s\n", nt_errstr(status));
886 static BOOL test_ChangePasswordUser3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
887 struct policy_handle *handle, char **password)
890 struct samr_ChangePasswordUser3 r;
892 struct samr_Name server, account;
893 struct samr_CryptPassword nt_pass, lm_pass;
894 struct samr_Password nt_verifier, lm_verifier;
895 char *oldpass = *password;
896 char *newpass = samr_rand_pass(mem_ctx);
897 uint8_t old_nt_hash[16], new_nt_hash[16];
898 uint8_t old_lm_hash[16], new_lm_hash[16];
900 printf("Testing ChangePasswordUser3\n");
902 server.name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
903 init_samr_Name(&account, TEST_ACCOUNT_NAME);
905 E_md4hash(oldpass, old_nt_hash);
906 E_md4hash(newpass, new_nt_hash);
908 E_deshash(oldpass, old_lm_hash);
909 E_deshash(newpass, new_lm_hash);
911 encode_pw_buffer(lm_pass.data, newpass, STR_UNICODE);
912 arcfour_crypt(lm_pass.data, old_nt_hash, 516);
913 E_old_pw_hash(new_lm_hash, old_lm_hash, lm_verifier.hash);
915 encode_pw_buffer(nt_pass.data, newpass, STR_UNICODE);
916 arcfour_crypt(nt_pass.data, old_nt_hash, 516);
917 E_old_pw_hash(new_nt_hash, old_nt_hash, nt_verifier.hash);
919 r.in.server = &server;
920 r.in.account = &account;
921 r.in.nt_password = &nt_pass;
922 r.in.nt_verifier = &nt_verifier;
924 r.in.lm_password = &lm_pass;
925 r.in.lm_verifier = &lm_verifier;
926 r.in.password3 = NULL;
928 status = dcerpc_samr_ChangePasswordUser3(p, mem_ctx, &r);
929 if (!NT_STATUS_IS_OK(status)) {
930 printf("ChangePasswordUser3 failed - %s\n", nt_errstr(status));
940 static BOOL test_GetMembersInAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
941 struct policy_handle *alias_handle)
943 struct samr_GetMembersInAlias r;
944 struct lsa_SidArray sids;
948 printf("Testing GetMembersInAlias\n");
950 r.in.handle = alias_handle;
953 status = dcerpc_samr_GetMembersInAlias(p, mem_ctx, &r);
954 if (!NT_STATUS_IS_OK(status)) {
955 printf("GetMembersInAlias failed - %s\n",
963 static BOOL test_AddMemberToAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
964 struct policy_handle *alias_handle,
965 struct policy_handle *domain_handle,
966 const struct dom_sid *domain_sid)
968 struct samr_AddAliasMember r;
969 struct samr_DeleteAliasMember d;
974 sid = dom_sid_add_rid(mem_ctx, domain_sid, 512);
976 printf("testing AddAliasMember\n");
977 r.in.handle = alias_handle;
980 status = dcerpc_samr_AddAliasMember(p, mem_ctx, &r);
981 if (!NT_STATUS_IS_OK(status)) {
982 printf("AddAliasMember failed - %s\n", nt_errstr(status));
986 d.in.handle = alias_handle;
989 status = dcerpc_samr_DeleteAliasMember(p, mem_ctx, &d);
990 if (!NT_STATUS_IS_OK(status)) {
991 printf("DelAliasMember failed - %s\n", nt_errstr(status));
998 static BOOL test_AddMultipleMembersToAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
999 struct policy_handle *alias_handle)
1001 struct samr_AddMultipleMembersToAlias a;
1002 struct samr_RemoveMultipleMembersFromAlias r;
1005 struct lsa_SidArray sids;
1007 printf("testing AddMultipleMembersToAlias\n");
1008 a.in.handle = alias_handle;
1012 sids.sids = talloc_array_p(mem_ctx, struct lsa_SidPtr, 3);
1014 sids.sids[0].sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1-2-3-1");
1015 sids.sids[1].sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1-2-3-2");
1016 sids.sids[2].sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1-2-3-3");
1018 status = dcerpc_samr_AddMultipleMembersToAlias(p, mem_ctx, &a);
1019 if (!NT_STATUS_IS_OK(status)) {
1020 printf("AddMultipleMembersToAlias failed - %s\n", nt_errstr(status));
1025 printf("testing RemoveMultipleMembersFromAlias\n");
1026 r.in.handle = alias_handle;
1029 status = dcerpc_samr_RemoveMultipleMembersFromAlias(p, mem_ctx, &r);
1030 if (!NT_STATUS_IS_OK(status)) {
1031 printf("RemoveMultipleMembersFromAlias failed - %s\n", nt_errstr(status));
1035 /* strange! removing twice doesn't give any error */
1036 status = dcerpc_samr_RemoveMultipleMembersFromAlias(p, mem_ctx, &r);
1037 if (!NT_STATUS_IS_OK(status)) {
1038 printf("RemoveMultipleMembersFromAlias failed - %s\n", nt_errstr(status));
1042 /* but removing an alias that isn't there does */
1043 sids.sids[2].sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-1-2-3-4");
1045 status = dcerpc_samr_RemoveMultipleMembersFromAlias(p, mem_ctx, &r);
1046 if (!NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
1047 printf("RemoveMultipleMembersFromAlias failed - %s\n", nt_errstr(status));
1054 static BOOL test_TestPrivateFunctionsUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1055 struct policy_handle *user_handle)
1057 struct samr_TestPrivateFunctionsUser r;
1061 printf("Testing TestPrivateFunctionsUser\n");
1063 r.in.handle = user_handle;
1065 status = dcerpc_samr_TestPrivateFunctionsUser(p, mem_ctx, &r);
1066 if (!NT_STATUS_EQUAL(NT_STATUS_NOT_IMPLEMENTED, status)) {
1067 printf("TestPrivateFunctionsUser failed - %s\n", nt_errstr(status));
1075 static BOOL test_user_ops(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1076 struct policy_handle *handle)
1080 if (!test_QuerySecurity(p, mem_ctx, handle)) {
1084 if (!test_QueryUserInfo(p, mem_ctx, handle)) {
1088 if (!test_QueryUserInfo2(p, mem_ctx, handle)) {
1092 if (!test_SetUserInfo(p, mem_ctx, handle)) {
1096 if (!test_GetUserPwInfo(p, mem_ctx, handle)) {
1100 if (!test_TestPrivateFunctionsUser(p, mem_ctx, handle)) {
1107 static BOOL test_alias_ops(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1108 struct policy_handle *alias_handle,
1109 struct policy_handle *domain_handle,
1110 const struct dom_sid *domain_sid)
1114 if (!test_QuerySecurity(p, mem_ctx, alias_handle)) {
1118 if (!test_QueryAliasInfo(p, mem_ctx, alias_handle)) {
1122 if (!test_SetAliasInfo(p, mem_ctx, alias_handle)) {
1126 if (!test_AddMemberToAlias(p, mem_ctx, alias_handle,
1127 domain_handle, domain_sid)) {
1131 if (!test_AddMultipleMembersToAlias(p, mem_ctx, alias_handle)) {
1139 BOOL test_DeleteUser_byname(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1140 struct policy_handle *handle, const char *name)
1143 struct samr_DeleteUser d;
1144 struct policy_handle acct_handle;
1147 status = test_LookupName(p, mem_ctx, handle, name, &rid);
1148 if (!NT_STATUS_IS_OK(status)) {
1152 status = test_OpenUser_byname(p, mem_ctx, handle, name, &acct_handle);
1153 if (!NT_STATUS_IS_OK(status)) {
1157 d.in.handle = &acct_handle;
1158 d.out.handle = &acct_handle;
1159 status = dcerpc_samr_DeleteUser(p, mem_ctx, &d);
1160 if (!NT_STATUS_IS_OK(status)) {
1167 printf("DeleteUser_byname(%s) failed - %s\n", name, nt_errstr(status));
1172 static BOOL test_DeleteGroup_byname(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1173 struct policy_handle *handle, const char *name)
1176 struct samr_OpenGroup r;
1177 struct samr_DeleteDomainGroup d;
1178 struct policy_handle group_handle;
1181 status = test_LookupName(p, mem_ctx, handle, name, &rid);
1182 if (!NT_STATUS_IS_OK(status)) {
1186 r.in.handle = handle;
1187 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1189 r.out.acct_handle = &group_handle;
1190 status = dcerpc_samr_OpenGroup(p, mem_ctx, &r);
1191 if (!NT_STATUS_IS_OK(status)) {
1195 d.in.handle = &group_handle;
1196 d.out.handle = &group_handle;
1197 status = dcerpc_samr_DeleteDomainGroup(p, mem_ctx, &d);
1198 if (!NT_STATUS_IS_OK(status)) {
1205 printf("DeleteGroup_byname(%s) failed - %s\n", name, nt_errstr(status));
1210 static BOOL test_DeleteAlias_byname(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1211 struct policy_handle *domain_handle, const char *name)
1214 struct samr_OpenAlias r;
1215 struct samr_DeleteDomAlias d;
1216 struct policy_handle alias_handle;
1219 printf("testing DeleteAlias_byname\n");
1221 status = test_LookupName(p, mem_ctx, domain_handle, name, &rid);
1222 if (!NT_STATUS_IS_OK(status)) {
1226 r.in.handle = domain_handle;
1227 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1229 r.out.acct_handle = &alias_handle;
1230 status = dcerpc_samr_OpenAlias(p, mem_ctx, &r);
1231 if (!NT_STATUS_IS_OK(status)) {
1235 d.in.handle = &alias_handle;
1236 d.out.handle = &alias_handle;
1237 status = dcerpc_samr_DeleteDomAlias(p, mem_ctx, &d);
1238 if (!NT_STATUS_IS_OK(status)) {
1245 printf("DeleteUser_byname(%s) failed - %s\n", name, nt_errstr(status));
1249 static BOOL test_DeleteAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1250 struct policy_handle *alias_handle)
1252 struct samr_DeleteDomAlias d;
1255 printf("Testing DeleteAlias\n");
1257 d.in.handle = alias_handle;
1258 d.out.handle = alias_handle;
1260 status = dcerpc_samr_DeleteDomAlias(p, mem_ctx, &d);
1261 if (!NT_STATUS_IS_OK(status)) {
1262 printf("DeleteAlias failed - %s\n", nt_errstr(status));
1269 static BOOL test_CreateAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1270 struct policy_handle *domain_handle,
1271 struct policy_handle *alias_handle,
1272 const struct dom_sid *domain_sid)
1275 struct samr_CreateDomAlias r;
1276 struct samr_Name name;
1280 init_samr_Name(&name, TEST_ALIASNAME);
1281 r.in.handle = domain_handle;
1282 r.in.aliasname = &name;
1283 r.in.access_mask = SEC_RIGHT_MAXIMUM_ALLOWED;
1284 r.out.acct_handle = alias_handle;
1287 printf("Testing CreateAlias (%s)\n", r.in.aliasname->name);
1289 status = dcerpc_samr_CreateDomAlias(p, mem_ctx, &r);
1291 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1292 printf("Server refused create of '%s'\n", r.in.aliasname->name);
1296 if (NT_STATUS_EQUAL(status, NT_STATUS_ALIAS_EXISTS)) {
1297 if (!test_DeleteAlias_byname(p, mem_ctx, domain_handle, r.in.aliasname->name)) {
1300 status = dcerpc_samr_CreateDomAlias(p, mem_ctx, &r);
1303 if (!NT_STATUS_IS_OK(status)) {
1304 printf("CreateAlias failed - %s\n", nt_errstr(status));
1308 if (!test_alias_ops(p, mem_ctx, alias_handle, domain_handle, domain_sid)) {
1315 static BOOL test_ChangePassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1316 struct policy_handle *domain_handle, char **password)
1324 if (!test_ChangePasswordUser(p, mem_ctx, domain_handle, password)) {
1328 if (!test_ChangePasswordUser2(p, mem_ctx, domain_handle, password)) {
1332 if (!test_OemChangePasswordUser2(p, mem_ctx, domain_handle, password)) {
1336 if (!test_ChangePasswordUser3(p, mem_ctx, domain_handle, password)) {
1343 static BOOL test_CreateUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1344 struct policy_handle *domain_handle, struct policy_handle *user_handle)
1347 struct samr_CreateUser r;
1348 struct samr_QueryUserInfo q;
1350 char *password = NULL;
1352 /* This call creates a 'normal' account - check that it really does */
1353 const uint32_t acct_flags = ACB_NORMAL;
1354 struct samr_Name name;
1357 init_samr_Name(&name, TEST_ACCOUNT_NAME);
1359 r.in.handle = domain_handle;
1360 r.in.account_name = &name;
1361 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1362 r.out.acct_handle = user_handle;
1365 printf("Testing CreateUser(%s)\n", r.in.account_name->name);
1367 status = dcerpc_samr_CreateUser(p, mem_ctx, &r);
1369 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1370 printf("Server refused create of '%s'\n", r.in.account_name->name);
1371 ZERO_STRUCTP(user_handle);
1375 if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
1376 if (!test_DeleteUser_byname(p, mem_ctx, domain_handle, r.in.account_name->name)) {
1379 status = dcerpc_samr_CreateUser(p, mem_ctx, &r);
1381 if (!NT_STATUS_IS_OK(status)) {
1382 printf("CreateUser failed - %s\n", nt_errstr(status));
1386 q.in.handle = user_handle;
1389 status = dcerpc_samr_QueryUserInfo(p, mem_ctx, &q);
1390 if (!NT_STATUS_IS_OK(status)) {
1391 printf("QueryUserInfo level %u failed - %s\n",
1392 q.in.level, nt_errstr(status));
1395 if ((q.out.info->info16.acct_flags & acct_flags) != acct_flags) {
1396 printf("QuerUserInfo level 16 failed, it returned 0x%08x (%u) when we expected flags of 0x%08x (%u)\n",
1397 q.out.info->info16.acct_flags, q.out.info->info16.acct_flags,
1398 acct_flags, acct_flags);
1403 if (!test_user_ops(p, mem_ctx, user_handle)) {
1407 if (!test_SetUserPass(p, mem_ctx, user_handle, &password)) {
1411 if (!test_SetUserPass_23(p, mem_ctx, user_handle, &password)) {
1415 if (!test_SetUserPassEx(p, mem_ctx, user_handle, &password)) {
1419 if (!test_SetUserPass_25(p, mem_ctx, user_handle, &password)) {
1423 /* we change passwords twice - this has the effect of verifying
1424 they were changed correctly */
1425 if (!test_ChangePassword(p, mem_ctx, domain_handle, &password)) {
1429 if (!test_ChangePassword(p, mem_ctx, domain_handle, &password)) {
1438 static BOOL test_DeleteUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1439 struct policy_handle *user_handle)
1441 struct samr_DeleteUser d;
1445 printf("Testing DeleteUser\n");
1447 d.in.handle = user_handle;
1448 d.out.handle = user_handle;
1450 status = dcerpc_samr_DeleteUser(p, mem_ctx, &d);
1451 if (!NT_STATUS_IS_OK(status)) {
1452 printf("DeleteUser failed - %s\n", nt_errstr(status));
1459 static BOOL test_CreateUser2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1460 struct policy_handle *handle)
1463 struct samr_CreateUser2 r;
1464 struct samr_QueryUserInfo q;
1465 struct samr_DeleteUser d;
1466 struct policy_handle acct_handle;
1468 struct samr_Name name;
1473 uint32_t acct_flags;
1474 const char *account_name;
1476 } account_types[] = {
1477 { ACB_NORMAL, TEST_ACCOUNT_NAME, NT_STATUS_OK },
1478 { ACB_NORMAL | ACB_DISABLED, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
1479 { ACB_NORMAL | ACB_PWNOEXP, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
1480 { ACB_WSTRUST, TEST_MACHINENAME, NT_STATUS_OK },
1481 { ACB_WSTRUST | ACB_DISABLED, TEST_MACHINENAME, NT_STATUS_INVALID_PARAMETER },
1482 { ACB_WSTRUST | ACB_PWNOEXP, TEST_MACHINENAME, NT_STATUS_INVALID_PARAMETER },
1483 { ACB_SVRTRUST, TEST_MACHINENAME, NT_STATUS_OK },
1484 { ACB_SVRTRUST | ACB_DISABLED, TEST_MACHINENAME, NT_STATUS_INVALID_PARAMETER },
1485 { ACB_SVRTRUST | ACB_PWNOEXP, TEST_MACHINENAME, NT_STATUS_INVALID_PARAMETER },
1486 { ACB_DOMTRUST, TEST_DOMAINNAME, NT_STATUS_OK },
1487 { ACB_DOMTRUST | ACB_DISABLED, TEST_DOMAINNAME, NT_STATUS_INVALID_PARAMETER },
1488 { ACB_DOMTRUST | ACB_PWNOEXP, TEST_DOMAINNAME, NT_STATUS_INVALID_PARAMETER },
1489 { 0, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
1490 { ACB_DISABLED, TEST_ACCOUNT_NAME, NT_STATUS_INVALID_PARAMETER },
1491 { 0, NULL, NT_STATUS_INVALID_PARAMETER }
1494 for (i = 0; account_types[i].account_name; i++) {
1495 uint32_t acct_flags = account_types[i].acct_flags;
1496 uint32_t access_granted;
1498 init_samr_Name(&name, account_types[i].account_name);
1500 r.in.handle = handle;
1501 r.in.account_name = &name;
1502 r.in.acct_flags = acct_flags;
1503 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1504 r.out.acct_handle = &acct_handle;
1505 r.out.access_granted = &access_granted;
1508 printf("Testing CreateUser2(%s)\n", r.in.account_name->name);
1510 status = dcerpc_samr_CreateUser2(p, mem_ctx, &r);
1512 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
1513 printf("Server refused create of '%s'\n", r.in.account_name->name);
1516 } else if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
1517 if (!test_DeleteUser_byname(p, mem_ctx, handle, r.in.account_name->name)) {
1520 status = dcerpc_samr_CreateUser2(p, mem_ctx, &r);
1523 if (!NT_STATUS_EQUAL(status, account_types[i].nt_status)) {
1524 printf("CreateUser2 failed gave incorrect error return - %s (should be %s)\n",
1525 nt_errstr(status), nt_errstr(account_types[i].nt_status));
1529 if (NT_STATUS_IS_OK(status)) {
1530 q.in.handle = &acct_handle;
1533 status = dcerpc_samr_QueryUserInfo(p, mem_ctx, &q);
1534 if (!NT_STATUS_IS_OK(status)) {
1535 printf("QueryUserInfo level %u failed - %s\n",
1536 q.in.level, nt_errstr(status));
1539 if ((q.out.info->info16.acct_flags & acct_flags) != acct_flags) {
1540 printf("QuerUserInfo level 16 failed, it returned 0x%08x when we expected flags of 0x%08x\n",
1541 q.out.info->info16.acct_flags,
1547 if (!test_user_ops(p, mem_ctx, &acct_handle)) {
1551 printf("Testing DeleteUser (createuser2 test)\n");
1553 d.in.handle = &acct_handle;
1554 d.out.handle = &acct_handle;
1556 status = dcerpc_samr_DeleteUser(p, mem_ctx, &d);
1557 if (!NT_STATUS_IS_OK(status)) {
1558 printf("DeleteUser failed - %s\n", nt_errstr(status));
1567 static BOOL test_QueryAliasInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1568 struct policy_handle *handle)
1571 struct samr_QueryAliasInfo r;
1572 uint16_t levels[] = {1, 2, 3};
1576 for (i=0;i<ARRAY_SIZE(levels);i++) {
1577 printf("Testing QueryAliasInfo level %u\n", levels[i]);
1579 r.in.handle = handle;
1580 r.in.level = levels[i];
1582 status = dcerpc_samr_QueryAliasInfo(p, mem_ctx, &r);
1583 if (!NT_STATUS_IS_OK(status)) {
1584 printf("QueryAliasInfo level %u failed - %s\n",
1585 levels[i], nt_errstr(status));
1593 static BOOL test_QueryGroupInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1594 struct policy_handle *handle)
1597 struct samr_QueryGroupInfo r;
1598 uint16_t levels[] = {1, 2, 3, 4};
1602 for (i=0;i<ARRAY_SIZE(levels);i++) {
1603 printf("Testing QueryGroupInfo level %u\n", levels[i]);
1605 r.in.handle = handle;
1606 r.in.level = levels[i];
1608 status = dcerpc_samr_QueryGroupInfo(p, mem_ctx, &r);
1609 if (!NT_STATUS_IS_OK(status)) {
1610 printf("QueryGroupInfo level %u failed - %s\n",
1611 levels[i], nt_errstr(status));
1620 static BOOL test_SetGroupInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1621 struct policy_handle *handle)
1624 struct samr_QueryGroupInfo r;
1625 struct samr_SetGroupInfo s;
1626 uint16_t levels[] = {1, 2, 3, 4};
1627 uint16_t set_ok[] = {0, 1, 1, 1};
1631 for (i=0;i<ARRAY_SIZE(levels);i++) {
1632 printf("Testing QueryGroupInfo level %u\n", levels[i]);
1634 r.in.handle = handle;
1635 r.in.level = levels[i];
1637 status = dcerpc_samr_QueryGroupInfo(p, mem_ctx, &r);
1638 if (!NT_STATUS_IS_OK(status)) {
1639 printf("QueryGroupInfo level %u failed - %s\n",
1640 levels[i], nt_errstr(status));
1644 printf("Testing SetGroupInfo level %u\n", levels[i]);
1646 s.in.handle = handle;
1647 s.in.level = levels[i];
1648 s.in.info = r.out.info;
1650 if (s.in.level == 2) {
1651 init_samr_Name(&s.in.info->name, "NewName");
1654 if (s.in.level == 4) {
1655 init_samr_Name(&s.in.info->description, "test description");
1658 status = dcerpc_samr_SetGroupInfo(p, mem_ctx, &s);
1660 if (!NT_STATUS_IS_OK(status)) {
1661 printf("SetGroupInfo level %u failed - %s\n",
1662 r.in.level, nt_errstr(status));
1667 if (!NT_STATUS_EQUAL(NT_STATUS_INVALID_INFO_CLASS, status)) {
1668 printf("SetGroupInfo level %u gave %s - should have been NT_STATUS_INVALID_INFO_CLASS\n",
1669 r.in.level, nt_errstr(status));
1679 static BOOL test_QueryUserInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1680 struct policy_handle *handle)
1683 struct samr_QueryUserInfo r;
1684 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1685 11, 12, 13, 14, 16, 17, 20, 21};
1689 for (i=0;i<ARRAY_SIZE(levels);i++) {
1690 printf("Testing QueryUserInfo level %u\n", levels[i]);
1692 r.in.handle = handle;
1693 r.in.level = levels[i];
1695 status = dcerpc_samr_QueryUserInfo(p, mem_ctx, &r);
1696 if (!NT_STATUS_IS_OK(status)) {
1697 printf("QueryUserInfo level %u failed - %s\n",
1698 levels[i], nt_errstr(status));
1706 static BOOL test_QueryUserInfo2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1707 struct policy_handle *handle)
1710 struct samr_QueryUserInfo2 r;
1711 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1712 11, 12, 13, 14, 16, 17, 20, 21};
1716 for (i=0;i<ARRAY_SIZE(levels);i++) {
1717 printf("Testing QueryUserInfo2 level %u\n", levels[i]);
1719 r.in.handle = handle;
1720 r.in.level = levels[i];
1722 status = dcerpc_samr_QueryUserInfo2(p, mem_ctx, &r);
1723 if (!NT_STATUS_IS_OK(status)) {
1724 printf("QueryUserInfo2 level %u failed - %s\n",
1725 levels[i], nt_errstr(status));
1733 static BOOL test_OpenUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1734 struct policy_handle *handle, uint32_t rid)
1737 struct samr_OpenUser r;
1738 struct policy_handle acct_handle;
1741 printf("Testing OpenUser(%u)\n", rid);
1743 r.in.handle = handle;
1744 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1746 r.out.acct_handle = &acct_handle;
1748 status = dcerpc_samr_OpenUser(p, mem_ctx, &r);
1749 if (!NT_STATUS_IS_OK(status)) {
1750 printf("OpenUser(%u) failed - %s\n", rid, nt_errstr(status));
1754 if (!test_QuerySecurity(p, mem_ctx, &acct_handle)) {
1758 if (!test_QueryUserInfo(p, mem_ctx, &acct_handle)) {
1762 if (!test_QueryUserInfo2(p, mem_ctx, &acct_handle)) {
1766 if (!test_GetUserPwInfo(p, mem_ctx, &acct_handle)) {
1770 if (!test_GetGroupsForUser(p,mem_ctx, &acct_handle)) {
1774 if (!test_Close(p, mem_ctx, &acct_handle)) {
1781 static BOOL test_OpenGroup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1782 struct policy_handle *handle, uint32_t rid)
1785 struct samr_OpenGroup r;
1786 struct policy_handle acct_handle;
1789 printf("Testing OpenGroup(%u)\n", rid);
1791 r.in.handle = handle;
1792 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1794 r.out.acct_handle = &acct_handle;
1796 status = dcerpc_samr_OpenGroup(p, mem_ctx, &r);
1797 if (!NT_STATUS_IS_OK(status)) {
1798 printf("OpenGroup(%u) failed - %s\n", rid, nt_errstr(status));
1802 if (!test_QuerySecurity(p, mem_ctx, &acct_handle)) {
1806 if (!test_QueryGroupInfo(p, mem_ctx, &acct_handle)) {
1810 if (!test_Close(p, mem_ctx, &acct_handle)) {
1817 static BOOL test_OpenAlias(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1818 struct policy_handle *handle, uint32_t rid)
1821 struct samr_OpenAlias r;
1822 struct policy_handle acct_handle;
1825 printf("Testing OpenAlias(%u)\n", rid);
1827 r.in.handle = handle;
1828 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1830 r.out.acct_handle = &acct_handle;
1832 status = dcerpc_samr_OpenAlias(p, mem_ctx, &r);
1833 if (!NT_STATUS_IS_OK(status)) {
1834 printf("OpenAlias(%u) failed - %s\n", rid, nt_errstr(status));
1838 if (!test_QuerySecurity(p, mem_ctx, &acct_handle)) {
1842 if (!test_QueryAliasInfo(p, mem_ctx, &acct_handle)) {
1846 if (!test_GetMembersInAlias(p, mem_ctx, &acct_handle)) {
1850 if (!test_Close(p, mem_ctx, &acct_handle)) {
1857 static BOOL test_EnumDomainUsers(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1858 struct policy_handle *handle)
1861 struct samr_EnumDomainUsers r;
1862 uint32_t resume_handle=0;
1865 struct samr_LookupNames n;
1866 struct samr_LookupRids lr ;
1868 printf("Testing EnumDomainUsers\n");
1870 r.in.handle = handle;
1871 r.in.resume_handle = &resume_handle;
1872 r.in.acct_flags = 0;
1873 r.in.max_size = (uint32_t)-1;
1874 r.out.resume_handle = &resume_handle;
1876 status = dcerpc_samr_EnumDomainUsers(p, mem_ctx, &r);
1877 if (!NT_STATUS_IS_OK(status)) {
1878 printf("EnumDomainUsers failed - %s\n", nt_errstr(status));
1886 if (r.out.sam->count == 0) {
1890 for (i=0;i<r.out.sam->count;i++) {
1891 if (!test_OpenUser(p, mem_ctx, handle, r.out.sam->entries[i].idx)) {
1896 printf("Testing LookupNames\n");
1897 n.in.handle = handle;
1898 n.in.num_names = r.out.sam->count;
1899 n.in.names = talloc(mem_ctx, r.out.sam->count * sizeof(struct samr_Name));
1900 for (i=0;i<r.out.sam->count;i++) {
1901 n.in.names[i] = r.out.sam->entries[i].name;
1903 status = dcerpc_samr_LookupNames(p, mem_ctx, &n);
1904 if (!NT_STATUS_IS_OK(status)) {
1905 printf("LookupNames failed - %s\n", nt_errstr(status));
1910 printf("Testing LookupRids\n");
1911 lr.in.handle = handle;
1912 lr.in.num_rids = r.out.sam->count;
1913 lr.in.rids = talloc(mem_ctx, r.out.sam->count * sizeof(uint32_t));
1914 for (i=0;i<r.out.sam->count;i++) {
1915 lr.in.rids[i] = r.out.sam->entries[i].idx;
1917 status = dcerpc_samr_LookupRids(p, mem_ctx, &lr);
1918 if (!NT_STATUS_IS_OK(status)) {
1919 printf("LookupRids failed - %s\n", nt_errstr(status));
1926 static BOOL test_EnumDomainGroups(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1927 struct policy_handle *handle)
1930 struct samr_EnumDomainGroups r;
1931 uint32_t resume_handle=0;
1935 printf("Testing EnumDomainGroups\n");
1937 r.in.handle = handle;
1938 r.in.resume_handle = &resume_handle;
1939 r.in.max_size = (uint32_t)-1;
1940 r.out.resume_handle = &resume_handle;
1942 status = dcerpc_samr_EnumDomainGroups(p, mem_ctx, &r);
1943 if (!NT_STATUS_IS_OK(status)) {
1944 printf("EnumDomainGroups failed - %s\n", nt_errstr(status));
1952 for (i=0;i<r.out.sam->count;i++) {
1953 if (!test_OpenGroup(p, mem_ctx, handle, r.out.sam->entries[i].idx)) {
1961 static BOOL test_EnumDomainAliases(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1962 struct policy_handle *handle)
1965 struct samr_EnumDomainAliases r;
1966 uint32_t resume_handle=0;
1970 printf("Testing EnumDomainAliases\n");
1972 r.in.handle = handle;
1973 r.in.resume_handle = &resume_handle;
1974 r.in.account_flags = (uint32_t)-1;
1975 r.out.resume_handle = &resume_handle;
1977 status = dcerpc_samr_EnumDomainAliases(p, mem_ctx, &r);
1978 if (!NT_STATUS_IS_OK(status)) {
1979 printf("EnumDomainAliases failed - %s\n", nt_errstr(status));
1987 for (i=0;i<r.out.sam->count;i++) {
1988 if (!test_OpenAlias(p, mem_ctx, handle, r.out.sam->entries[i].idx)) {
1996 static BOOL test_GetDisplayEnumerationIndex(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
1997 struct policy_handle *handle)
2000 struct samr_GetDisplayEnumerationIndex r;
2002 uint16_t levels[] = {1, 2, 3, 4, 5};
2003 uint16_t ok_lvl[] = {1, 1, 1, 0, 0};
2006 for (i=0;i<ARRAY_SIZE(levels);i++) {
2007 printf("Testing GetDisplayEnumerationIndex level %u\n", levels[i]);
2009 r.in.handle = handle;
2010 r.in.level = levels[i];
2011 init_samr_Name(&r.in.name, TEST_ACCOUNT_NAME);
2013 status = dcerpc_samr_GetDisplayEnumerationIndex(p, mem_ctx, &r);
2016 !NT_STATUS_IS_OK(status) &&
2017 !NT_STATUS_EQUAL(NT_STATUS_NO_MORE_ENTRIES, status)) {
2018 printf("GetDisplayEnumerationIndex level %u failed - %s\n",
2019 levels[i], nt_errstr(status));
2023 init_samr_Name(&r.in.name, "zzzzzzzz");
2025 status = dcerpc_samr_GetDisplayEnumerationIndex(p, mem_ctx, &r);
2027 if (ok_lvl[i] && !NT_STATUS_EQUAL(NT_STATUS_NO_MORE_ENTRIES, status)) {
2028 printf("GetDisplayEnumerationIndex level %u failed - %s\n",
2029 levels[i], nt_errstr(status));
2037 static BOOL test_GetDisplayEnumerationIndex2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2038 struct policy_handle *handle)
2041 struct samr_GetDisplayEnumerationIndex2 r;
2043 uint16_t levels[] = {1, 2, 3, 4, 5};
2044 uint16_t ok_lvl[] = {1, 1, 1, 0, 0};
2047 for (i=0;i<ARRAY_SIZE(levels);i++) {
2048 printf("Testing GetDisplayEnumerationIndex2 level %u\n", levels[i]);
2050 r.in.handle = handle;
2051 r.in.level = levels[i];
2052 init_samr_Name(&r.in.name, TEST_ACCOUNT_NAME);
2054 status = dcerpc_samr_GetDisplayEnumerationIndex2(p, mem_ctx, &r);
2056 !NT_STATUS_IS_OK(status) &&
2057 !NT_STATUS_EQUAL(NT_STATUS_NO_MORE_ENTRIES, status)) {
2058 printf("GetDisplayEnumerationIndex2 level %u failed - %s\n",
2059 levels[i], nt_errstr(status));
2063 init_samr_Name(&r.in.name, "zzzzzzzz");
2065 status = dcerpc_samr_GetDisplayEnumerationIndex2(p, mem_ctx, &r);
2066 if (ok_lvl[i] && !NT_STATUS_EQUAL(NT_STATUS_NO_MORE_ENTRIES, status)) {
2067 printf("GetDisplayEnumerationIndex2 level %u failed - %s\n",
2068 levels[i], nt_errstr(status));
2076 static BOOL test_QueryDisplayInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2077 struct policy_handle *handle)
2080 struct samr_QueryDisplayInfo r;
2082 uint16_t levels[] = {1, 2, 3, 4, 5};
2085 for (i=0;i<ARRAY_SIZE(levels);i++) {
2086 printf("Testing QueryDisplayInfo level %u\n", levels[i]);
2088 r.in.handle = handle;
2089 r.in.level = levels[i];
2091 r.in.max_entries = 1000;
2092 r.in.buf_size = (uint32_t)-1;
2094 status = dcerpc_samr_QueryDisplayInfo(p, mem_ctx, &r);
2095 if (!NT_STATUS_IS_OK(status)) {
2096 printf("QueryDisplayInfo level %u failed - %s\n",
2097 levels[i], nt_errstr(status));
2105 static BOOL test_QueryDisplayInfo2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2106 struct policy_handle *handle)
2109 struct samr_QueryDisplayInfo2 r;
2111 uint16_t levels[] = {1, 2, 3, 4, 5};
2114 for (i=0;i<ARRAY_SIZE(levels);i++) {
2115 printf("Testing QueryDisplayInfo2 level %u\n", levels[i]);
2117 r.in.handle = handle;
2118 r.in.level = levels[i];
2120 r.in.max_entries = 1000;
2121 r.in.buf_size = (uint32_t)-1;
2123 status = dcerpc_samr_QueryDisplayInfo2(p, mem_ctx, &r);
2124 if (!NT_STATUS_IS_OK(status)) {
2125 printf("QueryDisplayInfo2 level %u failed - %s\n",
2126 levels[i], nt_errstr(status));
2134 static BOOL test_QueryDisplayInfo3(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2135 struct policy_handle *handle)
2138 struct samr_QueryDisplayInfo3 r;
2140 uint16_t levels[] = {1, 2, 3, 4, 5};
2143 for (i=0;i<ARRAY_SIZE(levels);i++) {
2144 printf("Testing QueryDisplayInfo3 level %u\n", levels[i]);
2146 r.in.handle = handle;
2147 r.in.level = levels[i];
2149 r.in.max_entries = 1000;
2150 r.in.buf_size = (uint32_t)-1;
2152 status = dcerpc_samr_QueryDisplayInfo3(p, mem_ctx, &r);
2153 if (!NT_STATUS_IS_OK(status)) {
2154 printf("QueryDisplayInfo3 level %u failed - %s\n",
2155 levels[i], nt_errstr(status));
2163 static BOOL test_QueryDomainInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2164 struct policy_handle *handle)
2167 struct samr_QueryDomainInfo r;
2168 struct samr_SetDomainInfo s;
2169 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13};
2170 uint16_t set_ok[] = {1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0};
2174 for (i=0;i<ARRAY_SIZE(levels);i++) {
2175 printf("Testing QueryDomainInfo level %u\n", levels[i]);
2177 r.in.handle = handle;
2178 r.in.level = levels[i];
2180 status = dcerpc_samr_QueryDomainInfo(p, mem_ctx, &r);
2181 if (!NT_STATUS_IS_OK(status)) {
2182 printf("QueryDomainInfo level %u failed - %s\n",
2183 r.in.level, nt_errstr(status));
2188 printf("Testing SetDomainInfo level %u\n", levels[i]);
2190 s.in.handle = handle;
2191 s.in.level = levels[i];
2192 s.in.info = r.out.info;
2194 status = dcerpc_samr_SetDomainInfo(p, mem_ctx, &s);
2196 if (!NT_STATUS_IS_OK(status)) {
2197 printf("SetDomainInfo level %u failed - %s\n",
2198 r.in.level, nt_errstr(status));
2203 if (!NT_STATUS_EQUAL(NT_STATUS_INVALID_INFO_CLASS, status)) {
2204 printf("SetDomainInfo level %u gave %s - should have been NT_STATUS_INVALID_INFO_CLASS\n",
2205 r.in.level, nt_errstr(status));
2211 status = dcerpc_samr_QueryDomainInfo(p, mem_ctx, &r);
2212 if (!NT_STATUS_IS_OK(status)) {
2213 printf("QueryDomainInfo level %u failed - %s\n",
2214 r.in.level, nt_errstr(status));
2224 static BOOL test_QueryDomainInfo2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2225 struct policy_handle *handle)
2228 struct samr_QueryDomainInfo2 r;
2229 uint16_t levels[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13};
2233 for (i=0;i<ARRAY_SIZE(levels);i++) {
2234 printf("Testing QueryDomainInfo2 level %u\n", levels[i]);
2236 r.in.handle = handle;
2237 r.in.level = levels[i];
2239 status = dcerpc_samr_QueryDomainInfo2(p, mem_ctx, &r);
2240 if (!NT_STATUS_IS_OK(status)) {
2241 printf("QueryDomainInfo2 level %u failed - %s\n",
2242 r.in.level, nt_errstr(status));
2251 void add_string_to_array(TALLOC_CTX *mem_ctx,
2252 const char *str, const char ***strings, int *num)
2254 *strings = talloc_realloc(mem_ctx, *strings,
2255 ((*num)+1) * sizeof(**strings));
2257 if (*strings == NULL)
2260 (*strings)[*num] = str;
2266 /* Test whether querydispinfo level 5 and enumdomgroups return the same
2267 set of group names. */
2268 static BOOL test_GroupList(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2269 struct policy_handle *handle)
2271 struct samr_EnumDomainGroups q1;
2272 struct samr_QueryDisplayInfo q2;
2274 uint32_t resume_handle=0;
2279 const char **names = NULL;
2281 printf("Testing coherency of querydispinfo vs enumdomgroups\n");
2283 q1.in.handle = handle;
2284 q1.in.resume_handle = &resume_handle;
2286 q1.out.resume_handle = &resume_handle;
2288 status = STATUS_MORE_ENTRIES;
2289 while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
2290 status = dcerpc_samr_EnumDomainGroups(p, mem_ctx, &q1);
2292 if (!NT_STATUS_IS_OK(status) &&
2293 !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES))
2296 for (i=0; i<q1.out.sam->count; i++) {
2297 add_string_to_array(mem_ctx,
2298 q1.out.sam->entries[i].name.name,
2299 &names, &num_names);
2303 if (!NT_STATUS_IS_OK(status)) {
2304 printf("EnumDomainGroups failed - %s\n", nt_errstr(status));
2312 q2.in.handle = handle;
2314 q2.in.start_idx = 0;
2315 q2.in.max_entries = 5;
2316 q2.in.buf_size = (uint32_t)-1;
2318 status = STATUS_MORE_ENTRIES;
2319 while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
2320 status = dcerpc_samr_QueryDisplayInfo(p, mem_ctx, &q2);
2322 if (!NT_STATUS_IS_OK(status) &&
2323 !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES))
2326 for (i=0; i<q2.out.info.info5.count; i++) {
2332 /* Querydisplayinfo returns ascii -- convert */
2334 namelen = convert_string_allocate(CH_DISPLAY, CH_UNIX,
2335 q2.out.info.info5.entries[i].account_name.name,
2336 q2.out.info.info5.entries[i].account_name.name_len,
2338 name = realloc(name, namelen+1);
2341 for (j=0; j<num_names; j++) {
2342 if (names[j] == NULL)
2344 /* Hmm. No strequal in samba4 */
2345 if (strequal(names[j], name)) {
2353 printf("QueryDisplayInfo gave name [%s] that EnumDomainGroups did not\n",
2358 q2.in.start_idx += q2.out.info.info5.count;
2361 if (!NT_STATUS_IS_OK(status)) {
2362 printf("QueryDisplayInfo level 5 failed - %s\n",
2367 for (i=0; i<num_names; i++) {
2368 if (names[i] != NULL) {
2369 printf("EnumDomainGroups gave name [%s] that QueryDisplayInfo did not\n",
2378 static BOOL test_DeleteDomainGroup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2379 struct policy_handle *group_handle)
2381 struct samr_DeleteDomainGroup d;
2385 printf("Testing DeleteDomainGroup\n");
2387 d.in.handle = group_handle;
2388 d.out.handle = group_handle;
2390 status = dcerpc_samr_DeleteDomainGroup(p, mem_ctx, &d);
2391 if (!NT_STATUS_IS_OK(status)) {
2392 printf("DeleteDomainGroup failed - %s\n", nt_errstr(status));
2399 static BOOL test_TestPrivateFunctionsDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2400 struct policy_handle *domain_handle)
2402 struct samr_TestPrivateFunctionsDomain r;
2406 printf("Testing TestPrivateFunctionsDomain\n");
2408 r.in.handle = domain_handle;
2410 status = dcerpc_samr_TestPrivateFunctionsDomain(p, mem_ctx, &r);
2411 if (!NT_STATUS_EQUAL(NT_STATUS_NOT_IMPLEMENTED, status)) {
2412 printf("TestPrivateFunctionsDomain failed - %s\n", nt_errstr(status));
2419 static BOOL test_RidToSid(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2420 struct policy_handle *domain_handle)
2422 struct samr_RidToSid r;
2426 printf("Testing RidToSid\n");
2428 r.in.handle = domain_handle;
2431 status = dcerpc_samr_RidToSid(p, mem_ctx, &r);
2432 if (!NT_STATUS_IS_OK(status)) {
2433 printf("RidToSid failed - %s\n", nt_errstr(status));
2440 static BOOL test_GetBootKeyInformation(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2441 struct policy_handle *domain_handle)
2443 struct samr_GetBootKeyInformation r;
2447 printf("Testing GetBootKeyInformation\n");
2449 r.in.handle = domain_handle;
2451 status = dcerpc_samr_GetBootKeyInformation(p, mem_ctx, &r);
2452 if (!NT_STATUS_IS_OK(status)) {
2453 /* w2k3 seems to fail this sometimes and pass it sometimes */
2454 printf("GetBootKeyInformation (ignored) - %s\n", nt_errstr(status));
2460 static BOOL test_AddGroupMember(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2461 struct policy_handle *domain_handle,
2462 struct policy_handle *group_handle)
2465 struct samr_AddGroupMember r;
2466 struct samr_DeleteGroupMember d;
2467 struct samr_QueryGroupMember q;
2468 struct samr_SetMemberAttributesOfGroup s;
2472 status = test_LookupName(p, mem_ctx, domain_handle, TEST_ACCOUNT_NAME, &rid);
2473 if (!NT_STATUS_IS_OK(status)) {
2477 r.in.handle = group_handle;
2479 r.in.flags = 0; /* ??? */
2481 printf("Testing AddGroupMember and DeleteGroupMember\n");
2483 d.in.handle = group_handle;
2486 status = dcerpc_samr_DeleteGroupMember(p, mem_ctx, &d);
2487 if (!NT_STATUS_EQUAL(NT_STATUS_MEMBER_NOT_IN_GROUP, status)) {
2488 printf("DeleteGroupMember gave %s - should be NT_STATUS_MEMBER_NOT_IN_GROUP\n",
2493 status = dcerpc_samr_AddGroupMember(p, mem_ctx, &r);
2494 if (!NT_STATUS_IS_OK(status)) {
2495 printf("AddGroupMember failed - %s\n", nt_errstr(status));
2499 status = dcerpc_samr_AddGroupMember(p, mem_ctx, &r);
2500 if (!NT_STATUS_EQUAL(NT_STATUS_MEMBER_IN_GROUP, status)) {
2501 printf("AddGroupMember gave %s - should be NT_STATUS_MEMBER_IN_GROUP\n",
2506 /* this one is quite strange. I am using random inputs in the
2507 hope of triggering an error that might give us a clue */
2508 s.in.handle = group_handle;
2509 s.in.unknown1 = random();
2510 s.in.unknown2 = random();
2512 status = dcerpc_samr_SetMemberAttributesOfGroup(p, mem_ctx, &s);
2513 if (!NT_STATUS_IS_OK(status)) {
2514 printf("SetMemberAttributesOfGroup failed - %s\n", nt_errstr(status));
2518 q.in.handle = group_handle;
2520 status = dcerpc_samr_QueryGroupMember(p, mem_ctx, &q);
2521 if (!NT_STATUS_IS_OK(status)) {
2522 printf("QueryGroupMember failed - %s\n", nt_errstr(status));
2526 status = dcerpc_samr_DeleteGroupMember(p, mem_ctx, &d);
2527 if (!NT_STATUS_IS_OK(status)) {
2528 printf("DeleteGroupMember failed - %s\n", nt_errstr(status));
2532 status = dcerpc_samr_AddGroupMember(p, mem_ctx, &r);
2533 if (!NT_STATUS_IS_OK(status)) {
2534 printf("AddGroupMember failed - %s\n", nt_errstr(status));
2542 static BOOL test_CreateDomainGroup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2543 struct policy_handle *domain_handle, struct policy_handle *group_handle)
2546 struct samr_CreateDomainGroup r;
2548 struct samr_Name name;
2551 init_samr_Name(&name, TEST_GROUPNAME);
2553 r.in.handle = domain_handle;
2555 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2556 r.out.group_handle = group_handle;
2559 printf("Testing CreateDomainGroup(%s)\n", r.in.name->name);
2561 status = dcerpc_samr_CreateDomainGroup(p, mem_ctx, &r);
2563 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
2564 printf("Server refused create of '%s'\n", r.in.name->name);
2565 ZERO_STRUCTP(group_handle);
2569 if (NT_STATUS_EQUAL(status, NT_STATUS_GROUP_EXISTS) ||
2570 NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
2571 if (!test_DeleteGroup_byname(p, mem_ctx, domain_handle, r.in.name->name)) {
2574 status = dcerpc_samr_CreateDomainGroup(p, mem_ctx, &r);
2576 if (!NT_STATUS_IS_OK(status)) {
2577 printf("CreateDomainGroup failed - %s\n", nt_errstr(status));
2581 if (!test_AddGroupMember(p, mem_ctx, domain_handle, group_handle)) {
2585 if (!test_SetGroupInfo(p, mem_ctx, group_handle)) {
2594 its not totally clear what this does. It seems to accept any sid you like.
2596 static BOOL test_RemoveMemberFromForeignDomain(struct dcerpc_pipe *p,
2597 TALLOC_CTX *mem_ctx,
2598 struct policy_handle *domain_handle)
2601 struct samr_RemoveMemberFromForeignDomain r;
2603 r.in.handle = domain_handle;
2604 r.in.sid = dom_sid_parse_talloc(mem_ctx, "S-1-5-32-12-34-56-78-9");
2606 status = dcerpc_samr_RemoveMemberFromForeignDomain(p, mem_ctx, &r);
2607 if (!NT_STATUS_IS_OK(status)) {
2608 printf("RemoveMemberFromForeignDomain failed - %s\n", nt_errstr(status));
2618 static BOOL test_OpenDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2619 struct policy_handle *handle, struct dom_sid *sid)
2622 struct samr_OpenDomain r;
2623 struct policy_handle domain_handle;
2624 struct policy_handle user_handle;
2625 struct policy_handle alias_handle;
2626 struct policy_handle group_handle;
2629 ZERO_STRUCT(user_handle);
2630 ZERO_STRUCT(alias_handle);
2631 ZERO_STRUCT(group_handle);
2632 ZERO_STRUCT(domain_handle);
2634 printf("Testing OpenDomain\n");
2636 r.in.handle = handle;
2637 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2639 r.out.domain_handle = &domain_handle;
2641 status = dcerpc_samr_OpenDomain(p, mem_ctx, &r);
2642 if (!NT_STATUS_IS_OK(status)) {
2643 printf("OpenDomain failed - %s\n", nt_errstr(status));
2647 if (!test_QuerySecurity(p, mem_ctx, &domain_handle)) {
2651 if (!test_RemoveMemberFromForeignDomain(p, mem_ctx, &domain_handle)) {
2655 if (!test_CreateUser2(p, mem_ctx, &domain_handle)) {
2659 if (!test_CreateUser(p, mem_ctx, &domain_handle, &user_handle)) {
2663 if (!test_CreateAlias(p, mem_ctx, &domain_handle, &alias_handle, sid)) {
2667 if (!test_CreateDomainGroup(p, mem_ctx, &domain_handle, &group_handle)) {
2671 if (!test_QueryDomainInfo(p, mem_ctx, &domain_handle)) {
2675 if (!test_QueryDomainInfo2(p, mem_ctx, &domain_handle)) {
2679 if (!test_EnumDomainUsers(p, mem_ctx, &domain_handle)) {
2683 if (!test_EnumDomainGroups(p, mem_ctx, &domain_handle)) {
2687 if (!test_EnumDomainAliases(p, mem_ctx, &domain_handle)) {
2691 if (!test_QueryDisplayInfo(p, mem_ctx, &domain_handle)) {
2695 if (!test_QueryDisplayInfo2(p, mem_ctx, &domain_handle)) {
2699 if (!test_QueryDisplayInfo3(p, mem_ctx, &domain_handle)) {
2703 if (!test_GetDisplayEnumerationIndex(p, mem_ctx, &domain_handle)) {
2707 if (!test_GetDisplayEnumerationIndex2(p, mem_ctx, &domain_handle)) {
2711 if (!test_GroupList(p, mem_ctx, &domain_handle)) {
2715 if (!test_TestPrivateFunctionsDomain(p, mem_ctx, &domain_handle)) {
2719 if (!test_RidToSid(p, mem_ctx, &domain_handle)) {
2723 if (!test_GetBootKeyInformation(p, mem_ctx, &domain_handle)) {
2727 if (!policy_handle_empty(&user_handle) &&
2728 !test_DeleteUser(p, mem_ctx, &user_handle)) {
2732 if (!policy_handle_empty(&alias_handle) &&
2733 !test_DeleteAlias(p, mem_ctx, &alias_handle)) {
2737 if (!policy_handle_empty(&group_handle) &&
2738 !test_DeleteDomainGroup(p, mem_ctx, &group_handle)) {
2742 if (!test_Close(p, mem_ctx, &domain_handle)) {
2749 static BOOL test_LookupDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2750 struct policy_handle *handle, struct samr_Name *domain)
2753 struct samr_LookupDomain r;
2754 struct samr_Name n2;
2757 printf("Testing LookupDomain(%s)\n", domain->name);
2759 /* check for correct error codes */
2760 r.in.handle = handle;
2764 status = dcerpc_samr_LookupDomain(p, mem_ctx, &r);
2765 if (!NT_STATUS_EQUAL(NT_STATUS_INVALID_PARAMETER, status)) {
2766 printf("failed: LookupDomain expected NT_STATUS_INVALID_PARAMETER - %s\n", nt_errstr(status));
2770 n2.name = "xxNODOMAINxx";
2772 status = dcerpc_samr_LookupDomain(p, mem_ctx, &r);
2773 if (!NT_STATUS_EQUAL(NT_STATUS_NO_SUCH_DOMAIN, status)) {
2774 printf("failed: LookupDomain expected NT_STATUS_NO_SUCH_DOMAIN - %s\n", nt_errstr(status));
2778 r.in.handle = handle;
2779 r.in.domain = domain;
2781 status = dcerpc_samr_LookupDomain(p, mem_ctx, &r);
2782 if (!NT_STATUS_IS_OK(status)) {
2783 printf("LookupDomain failed - %s\n", nt_errstr(status));
2787 if (!test_GetDomPwInfo(p, mem_ctx, domain)) {
2791 if (!test_OpenDomain(p, mem_ctx, handle, r.out.sid)) {
2799 static BOOL test_EnumDomains(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2800 struct policy_handle *handle)
2803 struct samr_EnumDomains r;
2804 uint32_t resume_handle = 0;
2808 r.in.handle = handle;
2809 r.in.resume_handle = &resume_handle;
2810 r.in.buf_size = (uint32_t)-1;
2811 r.out.resume_handle = &resume_handle;
2813 status = dcerpc_samr_EnumDomains(p, mem_ctx, &r);
2814 if (!NT_STATUS_IS_OK(status)) {
2815 printf("EnumDomains failed - %s\n", nt_errstr(status));
2823 for (i=0;i<r.out.sam->count;i++) {
2824 if (!test_LookupDomain(p, mem_ctx, handle,
2825 &r.out.sam->entries[i].name)) {
2830 status = dcerpc_samr_EnumDomains(p, mem_ctx, &r);
2831 if (!NT_STATUS_IS_OK(status)) {
2832 printf("EnumDomains failed - %s\n", nt_errstr(status));
2840 static BOOL test_Connect(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
2841 struct policy_handle *handle)
2844 struct samr_Connect r;
2845 struct samr_Connect2 r2;
2846 struct samr_Connect3 r3;
2847 struct samr_Connect4 r4;
2848 struct samr_Connect5 r5;
2849 union samr_ConnectInfo info;
2852 printf("testing samr_Connect\n");
2854 r.in.system_name = 0;
2855 r.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2856 r.out.handle = handle;
2858 status = dcerpc_samr_Connect(p, mem_ctx, &r);
2859 if (!NT_STATUS_IS_OK(status)) {
2860 printf("Connect failed - %s\n", nt_errstr(status));
2864 printf("testing samr_Connect2\n");
2866 r2.in.system_name = NULL;
2867 r2.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2868 r2.out.handle = handle;
2870 status = dcerpc_samr_Connect2(p, mem_ctx, &r2);
2871 if (!NT_STATUS_IS_OK(status)) {
2872 printf("Connect2 failed - %s\n", nt_errstr(status));
2876 printf("testing samr_Connect3\n");
2878 r3.in.system_name = NULL;
2880 r3.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2881 r3.out.handle = handle;
2883 status = dcerpc_samr_Connect3(p, mem_ctx, &r3);
2884 if (!NT_STATUS_IS_OK(status)) {
2885 printf("Connect3 failed - %s\n", nt_errstr(status));
2889 printf("testing samr_Connect4\n");
2891 r4.in.system_name = "";
2893 r4.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2894 r4.out.handle = handle;
2896 status = dcerpc_samr_Connect4(p, mem_ctx, &r4);
2897 if (!NT_STATUS_IS_OK(status)) {
2898 printf("Connect4 failed - %s\n", nt_errstr(status));
2902 printf("testing samr_Connect5\n");
2904 info.info1.unknown1 = 0;
2905 info.info1.unknown2 = 0;
2907 r5.in.system_name = "";
2908 r5.in.access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
2911 r5.out.info = &info;
2912 r5.out.handle = handle;
2914 status = dcerpc_samr_Connect5(p, mem_ctx, &r5);
2915 if (!NT_STATUS_IS_OK(status)) {
2916 printf("Connect5 failed - %s\n", nt_errstr(status));
2924 BOOL torture_rpc_samr(int dummy)
2927 struct dcerpc_pipe *p;
2928 TALLOC_CTX *mem_ctx;
2930 struct policy_handle handle;
2932 mem_ctx = talloc_init("torture_rpc_samr");
2934 status = torture_rpc_connection(&p,
2937 DCERPC_SAMR_VERSION);
2938 if (!NT_STATUS_IS_OK(status)) {
2942 if (!test_Connect(p, mem_ctx, &handle)) {
2946 if (!test_QuerySecurity(p, mem_ctx, &handle)) {
2950 if (!test_EnumDomains(p, mem_ctx, &handle)) {
2954 if (!test_SetDsrmPassword(p, mem_ctx, &handle)) {
2958 if (!test_Shutdown(p, mem_ctx, &handle)) {
2962 if (!test_Close(p, mem_ctx, &handle)) {
2966 talloc_destroy(mem_ctx);
2968 torture_rpc_close(p);