?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Move rpccli_try_samr_connects out of rpcclient.
[Samba.git] / source / rpcclient / cmd_samr.c
bloba003a2e640a60e8d19201edbc387690397db28a0
1 /*
2 Unix SMB/CIFS implementation.
3 RPC pipe client
4
5 Copyright (C) Andrew Tridgell 1992-2000,
6 Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
7 Copyright (C) Elrond 2000,
8 Copyright (C) Tim Potter 2000
9 Copyright (C) Guenther Deschner 2008
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #include "rpcclient.h"
27
28 extern DOM_SID domain_sid;
29
30 /****************************************************************************
31 display samr_user_info_7 structure
32 ****************************************************************************/
33 static void display_samr_user_info_7(struct samr_UserInfo7 *r)
34 {
35 printf("\tUser Name :\t%s\n", r->account_name.string);
36 }
37
38 /****************************************************************************
39 display samr_user_info_9 structure
40 ****************************************************************************/
41 static void display_samr_user_info_9(struct samr_UserInfo9 *r)
42 {
43 printf("\tPrimary group RID :\tox%x\n", r->primary_gid);
44 }
45
46 /****************************************************************************
47 display samr_user_info_16 structure
48 ****************************************************************************/
49 static void display_samr_user_info_16(struct samr_UserInfo16 *r)
50 {
51 printf("\tAcct Flags :\tox%x\n", r->acct_flags);
52 }
53
54 /****************************************************************************
55 display samr_user_info_20 structure
56 ****************************************************************************/
57 static void display_samr_user_info_20(struct samr_UserInfo20 *r)
58 {
59 printf("\tRemote Dial :\n");
60 dump_data(0, (uint8_t *)r->parameters.array, r->parameters.length*2);
61 }
62
63
64 /****************************************************************************
65 display samr_user_info_21 structure
66 ****************************************************************************/
67 static void display_samr_user_info_21(struct samr_UserInfo21 *r)
68 {
69 printf("\tUser Name :\t%s\n", r->account_name.string);
70 printf("\tFull Name :\t%s\n", r->full_name.string);
71 printf("\tHome Drive :\t%s\n", r->home_directory.string);
72 printf("\tDir Drive :\t%s\n", r->home_drive.string);
73 printf("\tProfile Path:\t%s\n", r->profile_path.string);
74 printf("\tLogon Script:\t%s\n", r->logon_script.string);
75 printf("\tDescription :\t%s\n", r->description.string);
76 printf("\tWorkstations:\t%s\n", r->workstations.string);
77 printf("\tComment :\t%s\n", r->comment.string);
78 printf("\tRemote Dial :\n");
79 dump_data(0, (uint8_t *)r->parameters.array, r->parameters.length*2);
80
81 printf("\tLogon Time :\t%s\n",
82 http_timestring(nt_time_to_unix(r->last_logon)));
83 printf("\tLogoff Time :\t%s\n",
84 http_timestring(nt_time_to_unix(r->last_logoff)));
85 printf("\tKickoff Time :\t%s\n",
86 http_timestring(nt_time_to_unix(r->acct_expiry)));
87 printf("\tPassword last set Time :\t%s\n",
88 http_timestring(nt_time_to_unix(r->last_password_change)));
89 printf("\tPassword can change Time :\t%s\n",
90 http_timestring(nt_time_to_unix(r->allow_password_change)));
91 printf("\tPassword must change Time:\t%s\n",
92 http_timestring(nt_time_to_unix(r->force_password_change)));
93
94 printf("\tunknown_2[0..31]...\n"); /* user passwords? */
95
96 printf("\tuser_rid :\t0x%x\n" , r->rid); /* User ID */
97 printf("\tgroup_rid:\t0x%x\n" , r->primary_gid); /* Group ID */
98 printf("\tacb_info :\t0x%08x\n", r->acct_flags); /* Account Control Info */
99
100 printf("\tfields_present:\t0x%08x\n", r->fields_present); /* 0x00ff ffff */
101 printf("\tlogon_divs:\t%d\n", r->logon_hours.units_per_week); /* 0x0000 00a8 which is 168 which is num hrs in a week */
102 printf("\tbad_password_count:\t0x%08x\n", r->bad_password_count);
103 printf("\tlogon_count:\t0x%08x\n", r->logon_count);
104
105 printf("\tpadding1[0..7]...\n");
106
107 if (r->logon_hours.bits) {
108 printf("\tlogon_hrs[0..%d]...\n", r->logon_hours.units_per_week/8);
109 }
110 }
111
112
113 static void display_password_properties(uint32_t password_properties)
114 {
115 printf("password_properties: 0x%08x\n", password_properties);
116
117 if (password_properties & DOMAIN_PASSWORD_COMPLEX)
118 printf("\tDOMAIN_PASSWORD_COMPLEX\n");
119
120 if (password_properties & DOMAIN_PASSWORD_NO_ANON_CHANGE)
121 printf("\tDOMAIN_PASSWORD_NO_ANON_CHANGE\n");
122
123 if (password_properties & DOMAIN_PASSWORD_NO_CLEAR_CHANGE)
124 printf("\tDOMAIN_PASSWORD_NO_CLEAR_CHANGE\n");
125
126 if (password_properties & DOMAIN_PASSWORD_LOCKOUT_ADMINS)
127 printf("\tDOMAIN_PASSWORD_LOCKOUT_ADMINS\n");
128
129 if (password_properties & DOMAIN_PASSWORD_STORE_CLEARTEXT)
130 printf("\tDOMAIN_PASSWORD_STORE_CLEARTEXT\n");
131
132 if (password_properties & DOMAIN_REFUSE_PASSWORD_CHANGE)
133 printf("\tDOMAIN_REFUSE_PASSWORD_CHANGE\n");
134 }
135
136 static void display_sam_dom_info_1(struct samr_DomInfo1 *info1)
137 {
138 printf("Minimum password length:\t\t\t%d\n",
139 info1->min_password_length);
140 printf("Password uniqueness (remember x passwords):\t%d\n",
141 info1->password_history_length);
142 display_password_properties(info1->password_properties);
143 printf("password expire in:\t\t\t\t%s\n",
144 display_time(info1->max_password_age));
145 printf("Min password age (allow changing in x days):\t%s\n",
146 display_time(info1->min_password_age));
147 }
148
149 static void display_sam_dom_info_2(struct samr_DomInfo2 *info2)
150 {
151 printf("Domain:\t\t%s\n", info2->domain_name.string);
152 printf("Server:\t\t%s\n", info2->primary.string);
153 printf("Comment:\t%s\n", info2->comment.string);
154
155 printf("Total Users:\t%d\n", info2->num_users);
156 printf("Total Groups:\t%d\n", info2->num_groups);
157 printf("Total Aliases:\t%d\n", info2->num_aliases);
158
159 printf("Sequence No:\t%llu\n", (unsigned long long)info2->sequence_num);
160
161 printf("Force Logoff:\t%d\n",
162 (int)nt_time_to_unix_abs(&info2->force_logoff_time));
163
164 printf("Unknown 2:\t0x%x\n", info2->unknown2);
165 printf("Server Role:\t%s\n", server_role_str(info2->role));
166 printf("Unknown 3:\t0x%x\n", info2->unknown3);
167 }
168
169 static void display_sam_dom_info_3(struct samr_DomInfo3 *info3)
170 {
171 printf("Force Logoff:\t%d\n",
172 (int)nt_time_to_unix_abs(&info3->force_logoff_time));
173 }
174
175 static void display_sam_dom_info_4(struct samr_DomInfo4 *info4)
176 {
177 printf("Comment:\t%s\n", info4->comment.string);
178 }
179
180 static void display_sam_dom_info_5(struct samr_DomInfo5 *info5)
181 {
182 printf("Domain:\t\t%s\n", info5->domain_name.string);
183 }
184
185 static void display_sam_dom_info_6(struct samr_DomInfo6 *info6)
186 {
187 printf("Server:\t\t%s\n", info6->primary.string);
188 }
189
190 static void display_sam_dom_info_7(struct samr_DomInfo7 *info7)
191 {
192 printf("Server Role:\t%s\n", server_role_str(info7->role));
193 }
194
195 static void display_sam_dom_info_8(struct samr_DomInfo8 *info8)
196 {
197 printf("Sequence No:\t%llu\n", (unsigned long long)info8->sequence_num);
198 printf("Domain Create Time:\t%s\n",
199 http_timestring(nt_time_to_unix(info8->domain_create_time)));
200 }
201
202 static void display_sam_dom_info_9(struct samr_DomInfo9 *info9)
203 {
204 printf("unknown:\t%d (0x%08x)\n", info9->unknown, info9->unknown);
205 }
206
207 static void display_sam_dom_info_12(struct samr_DomInfo12 *info12)
208 {
209 printf("Bad password lockout duration: %s\n",
210 display_time(info12->lockout_duration));
211 printf("Reset Lockout after: %s\n",
212 display_time(info12->lockout_window));
213 printf("Lockout after bad attempts: %d\n",
214 info12->lockout_threshold);
215 }
216
217 static void display_sam_dom_info_13(struct samr_DomInfo13 *info13)
218 {
219 printf("Sequence No:\t%llu\n", (unsigned long long)info13->sequence_num);
220 printf("Domain Create Time:\t%s\n",
221 http_timestring(nt_time_to_unix(info13->domain_create_time)));
222 printf("Unknown1:\t%d\n", info13->unknown1);
223 printf("Unknown2:\t%d\n", info13->unknown2);
224
225 }
226
227 static void display_sam_info_1(struct samr_DispEntryGeneral *r)
228 {
229 printf("index: 0x%x ", r->idx);
230 printf("RID: 0x%x ", r->rid);
231 printf("acb: 0x%08x ", r->acct_flags);
232 printf("Account: %s\t", r->account_name.string);
233 printf("Name: %s\t", r->full_name.string);
234 printf("Desc: %s\n", r->description.string);
235 }
236
237 static void display_sam_info_2(struct samr_DispEntryFull *r)
238 {
239 printf("index: 0x%x ", r->idx);
240 printf("RID: 0x%x ", r->rid);
241 printf("acb: 0x%08x ", r->acct_flags);
242 printf("Account: %s\t", r->account_name.string);
243 printf("Desc: %s\n", r->description.string);
244 }
245
246 static void display_sam_info_3(struct samr_DispEntryFullGroup *r)
247 {
248 printf("index: 0x%x ", r->idx);
249 printf("RID: 0x%x ", r->rid);
250 printf("acb: 0x%08x ", r->acct_flags);
251 printf("Account: %s\t", r->account_name.string);
252 printf("Desc: %s\n", r->description.string);
253 }
254
255 static void display_sam_info_4(struct samr_DispEntryAscii *r)
256 {
257 printf("index: 0x%x ", r->idx);
258 printf("Account: %s\n", r->account_name.string);
259 }
260
261 static void display_sam_info_5(struct samr_DispEntryAscii *r)
262 {
263 printf("index: 0x%x ", r->idx);
264 printf("Account: %s\n", r->account_name.string);
265 }
266
267 /**********************************************************************
268 * Query user information
269 */
270 static NTSTATUS cmd_samr_query_user(struct rpc_pipe_client *cli,
271 TALLOC_CTX *mem_ctx,
272 int argc, const char **argv)
273 {
274 POLICY_HND connect_pol, domain_pol, user_pol;
275 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
276 uint32 info_level = 21;
277 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
278 union samr_UserInfo *info = NULL;
279 fstring server;
280 uint32 user_rid = 0;
281
282 if ((argc < 2) || (argc > 4)) {
283 printf("Usage: %s rid [info level] [access mask] \n", argv[0]);
284 return NT_STATUS_OK;
285 }
286
287 sscanf(argv[1], "%i", &user_rid);
288
289 if (argc > 2)
290 sscanf(argv[2], "%i", &info_level);
291
292 if (argc > 3)
293 sscanf(argv[3], "%x", &access_mask);
294
295
296 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
297 strupper_m(server);
298
299 result = rpccli_try_samr_connects(cli, mem_ctx,
300 MAXIMUM_ALLOWED_ACCESS,
301 &connect_pol);
302
303 if (!NT_STATUS_IS_OK(result))
304 goto done;
305
306 result = rpccli_samr_OpenDomain(cli, mem_ctx,
307 &connect_pol,
308 MAXIMUM_ALLOWED_ACCESS,
309 &domain_sid,
310 &domain_pol);
311 if (!NT_STATUS_IS_OK(result))
312 goto done;
313
314 result = rpccli_samr_OpenUser(cli, mem_ctx,
315 &domain_pol,
316 access_mask,
317 user_rid,
318 &user_pol);
319
320 if (NT_STATUS_EQUAL(result, NT_STATUS_NO_SUCH_USER) &&
321 (user_rid == 0)) {
322
323 /* Probably this was a user name, try lookupnames */
324 struct samr_Ids rids, types;
325 struct lsa_String lsa_acct_name;
326
327 init_lsa_String(&lsa_acct_name, argv[1]);
328
329 result = rpccli_samr_LookupNames(cli, mem_ctx,
330 &domain_pol,
331 1,
332 &lsa_acct_name,
333 &rids,
334 &types);
335
336 if (NT_STATUS_IS_OK(result)) {
337 result = rpccli_samr_OpenUser(cli, mem_ctx,
338 &domain_pol,
339 access_mask,
340 rids.ids[0],
341 &user_pol);
342 }
343 }
344
345
346 if (!NT_STATUS_IS_OK(result))
347 goto done;
348
349 result = rpccli_samr_QueryUserInfo(cli, mem_ctx,
350 &user_pol,
351 info_level,
352 &info);
353
354 if (!NT_STATUS_IS_OK(result))
355 goto done;
356
357 switch (info_level) {
358 case 7:
359 display_samr_user_info_7(&info->info7);
360 break;
361 case 9:
362 display_samr_user_info_9(&info->info9);
363 break;
364 case 16:
365 display_samr_user_info_16(&info->info16);
366 break;
367 case 20:
368 display_samr_user_info_20(&info->info20);
369 break;
370 case 21:
371 display_samr_user_info_21(&info->info21);
372 break;
373 default:
374 printf("Unsupported infolevel: %d\n", info_level);
375 break;
376 }
377
378 rpccli_samr_Close(cli, mem_ctx, &user_pol);
379 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
380 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
381
382 done:
383 return result;
384 }
385
386 /****************************************************************************
387 display group info
388 ****************************************************************************/
389 static void display_group_info1(struct samr_GroupInfoAll *info1)
390 {
391 printf("\tGroup Name:\t%s\n", info1->name.string);
392 printf("\tDescription:\t%s\n", info1->description.string);
393 printf("\tGroup Attribute:%d\n", info1->attributes);
394 printf("\tNum Members:%d\n", info1->num_members);
395 }
396
397 /****************************************************************************
398 display group info
399 ****************************************************************************/
400 static void display_group_info2(struct lsa_String *info2)
401 {
402 printf("\tGroup Description:%s\n", info2->string);
403 }
404
405
406 /****************************************************************************
407 display group info
408 ****************************************************************************/
409 static void display_group_info3(struct samr_GroupInfoAttributes *info3)
410 {
411 printf("\tGroup Attribute:%d\n", info3->attributes);
412 }
413
414
415 /****************************************************************************
416 display group info
417 ****************************************************************************/
418 static void display_group_info4(struct lsa_String *info4)
419 {
420 printf("\tGroup Description:%s\n", info4->string);
421 }
422
423 /****************************************************************************
424 display group info
425 ****************************************************************************/
426 static void display_group_info5(struct samr_GroupInfoAll *info5)
427 {
428 printf("\tGroup Name:\t%s\n", info5->name.string);
429 printf("\tDescription:\t%s\n", info5->description.string);
430 printf("\tGroup Attribute:%d\n", info5->attributes);
431 printf("\tNum Members:%d\n", info5->num_members);
432 }
433
434 /****************************************************************************
435 display sam sync structure
436 ****************************************************************************/
437 static void display_group_info(union samr_GroupInfo *info,
438 enum samr_GroupInfoEnum level)
439 {
440 switch (level) {
441 case 1:
442 display_group_info1(&info->all);
443 break;
444 case 2:
445 display_group_info2(&info->name);
446 break;
447 case 3:
448 display_group_info3(&info->attributes);
449 break;
450 case 4:
451 display_group_info4(&info->description);
452 break;
453 case 5:
454 display_group_info5(&info->all2);
455 break;
456 }
457 }
458
459 /***********************************************************************
460 * Query group information
461 */
462 static NTSTATUS cmd_samr_query_group(struct rpc_pipe_client *cli,
463 TALLOC_CTX *mem_ctx,
464 int argc, const char **argv)
465 {
466 POLICY_HND connect_pol, domain_pol, group_pol;
467 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
468 enum samr_GroupInfoEnum info_level = GROUPINFOALL;
469 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
470 union samr_GroupInfo *group_info = NULL;
471 fstring server;
472 uint32 group_rid;
473
474 if ((argc < 2) || (argc > 4)) {
475 printf("Usage: %s rid [info level] [access mask]\n", argv[0]);
476 return NT_STATUS_OK;
477 }
478
479 sscanf(argv[1], "%i", &group_rid);
480
481 if (argc > 2)
482 info_level = atoi(argv[2]);
483
484 if (argc > 3)
485 sscanf(argv[3], "%x", &access_mask);
486
487 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
488 strupper_m(server);
489
490 result = rpccli_try_samr_connects(cli, mem_ctx,
491 MAXIMUM_ALLOWED_ACCESS,
492 &connect_pol);
493
494 if (!NT_STATUS_IS_OK(result))
495 goto done;
496
497 result = rpccli_samr_OpenDomain(cli, mem_ctx,
498 &connect_pol,
499 MAXIMUM_ALLOWED_ACCESS,
500 &domain_sid,
501 &domain_pol);
502
503 if (!NT_STATUS_IS_OK(result))
504 goto done;
505
506 result = rpccli_samr_OpenGroup(cli, mem_ctx,
507 &domain_pol,
508 access_mask,
509 group_rid,
510 &group_pol);
511
512 if (!NT_STATUS_IS_OK(result))
513 goto done;
514
515 result = rpccli_samr_QueryGroupInfo(cli, mem_ctx,
516 &group_pol,
517 info_level,
518 &group_info);
519 if (!NT_STATUS_IS_OK(result)) {
520 goto done;
521 }
522
523 display_group_info(group_info, info_level);
524
525 rpccli_samr_Close(cli, mem_ctx, &group_pol);
526 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
527 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
528 done:
529 return result;
530 }
531
532 /* Query groups a user is a member of */
533
534 static NTSTATUS cmd_samr_query_usergroups(struct rpc_pipe_client *cli,
535 TALLOC_CTX *mem_ctx,
536 int argc, const char **argv)
537 {
538 POLICY_HND connect_pol,
539 domain_pol,
540 user_pol;
541 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
542 uint32 user_rid;
543 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
544 int i;
545 fstring server;
546 struct samr_RidWithAttributeArray *rid_array = NULL;
547
548 if ((argc < 2) || (argc > 3)) {
549 printf("Usage: %s rid [access mask]\n", argv[0]);
550 return NT_STATUS_OK;
551 }
552
553 sscanf(argv[1], "%i", &user_rid);
554
555 if (argc > 2)
556 sscanf(argv[2], "%x", &access_mask);
557
558 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
559 strupper_m(server);
560
561 result = rpccli_try_samr_connects(cli, mem_ctx,
562 MAXIMUM_ALLOWED_ACCESS,
563 &connect_pol);
564
565 if (!NT_STATUS_IS_OK(result))
566 goto done;
567
568 result = rpccli_samr_OpenDomain(cli, mem_ctx,
569 &connect_pol,
570 MAXIMUM_ALLOWED_ACCESS,
571 &domain_sid, &domain_pol);
572
573 if (!NT_STATUS_IS_OK(result))
574 goto done;
575
576 result = rpccli_samr_OpenUser(cli, mem_ctx,
577 &domain_pol,
578 access_mask,
579 user_rid,
580 &user_pol);
581
582 if (!NT_STATUS_IS_OK(result))
583 goto done;
584
585 result = rpccli_samr_GetGroupsForUser(cli, mem_ctx,
586 &user_pol,
587 &rid_array);
588
589 if (!NT_STATUS_IS_OK(result))
590 goto done;
591
592 for (i = 0; i < rid_array->count; i++) {
593 printf("\tgroup rid:[0x%x] attr:[0x%x]\n",
594 rid_array->rids[i].rid,
595 rid_array->rids[i].attributes);
596 }
597
598 rpccli_samr_Close(cli, mem_ctx, &user_pol);
599 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
600 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
601 done:
602 return result;
603 }
604
605 /* Query aliases a user is a member of */
606
607 static NTSTATUS cmd_samr_query_useraliases(struct rpc_pipe_client *cli,
608 TALLOC_CTX *mem_ctx,
609 int argc, const char **argv)
610 {
611 POLICY_HND connect_pol, domain_pol;
612 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
613 DOM_SID *sids;
614 size_t num_sids;
615 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
616 int i;
617 fstring server;
618 struct lsa_SidArray sid_array;
619 struct samr_Ids alias_rids;
620
621 if (argc < 3) {
622 printf("Usage: %s builtin|domain sid1 sid2 ...\n", argv[0]);
623 return NT_STATUS_INVALID_PARAMETER;
624 }
625
626 sids = NULL;
627 num_sids = 0;
628
629 for (i=2; i<argc; i++) {
630 DOM_SID tmp_sid;
631 if (!string_to_sid(&tmp_sid, argv[i])) {
632 printf("%s is not a legal SID\n", argv[i]);
633 return NT_STATUS_INVALID_PARAMETER;
634 }
635 result = add_sid_to_array(mem_ctx, &tmp_sid, &sids, &num_sids);
636 if (!NT_STATUS_IS_OK(result)) {
637 return result;
638 }
639 }
640
641 if (num_sids) {
642 sid_array.sids = TALLOC_ZERO_ARRAY(mem_ctx, struct lsa_SidPtr, num_sids);
643 if (sid_array.sids == NULL)
644 return NT_STATUS_NO_MEMORY;
645 } else {
646 sid_array.sids = NULL;
647 }
648
649 for (i=0; i<num_sids; i++) {
650 sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sids[i]);
651 if (!sid_array.sids[i].sid) {
652 return NT_STATUS_NO_MEMORY;
653 }
654 }
655
656 sid_array.num_sids = num_sids;
657
658 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
659 strupper_m(server);
660
661 result = rpccli_try_samr_connects(cli, mem_ctx,
662 MAXIMUM_ALLOWED_ACCESS,
663 &connect_pol);
664
665 if (!NT_STATUS_IS_OK(result))
666 goto done;
667
668 if (StrCaseCmp(argv[1], "domain")==0)
669 result = rpccli_samr_OpenDomain(cli, mem_ctx,
670 &connect_pol,
671 access_mask,
672 &domain_sid, &domain_pol);
673 else if (StrCaseCmp(argv[1], "builtin")==0)
674 result = rpccli_samr_OpenDomain(cli, mem_ctx,
675 &connect_pol,
676 access_mask,
677 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
678 &domain_pol);
679 else {
680 printf("Usage: %s builtin|domain sid1 sid2 ...\n", argv[0]);
681 return NT_STATUS_INVALID_PARAMETER;
682 }
683
684 if (!NT_STATUS_IS_OK(result))
685 goto done;
686
687 result = rpccli_samr_GetAliasMembership(cli, mem_ctx,
688 &domain_pol,
689 &sid_array,
690 &alias_rids);
691 if (!NT_STATUS_IS_OK(result))
692 goto done;
693
694 for (i = 0; i < alias_rids.count; i++) {
695 printf("\tgroup rid:[0x%x]\n", alias_rids.ids[i]);
696 }
697
698 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
699 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
700 done:
701 return result;
702 }
703
704 /* Query members of a group */
705
706 static NTSTATUS cmd_samr_query_groupmem(struct rpc_pipe_client *cli,
707 TALLOC_CTX *mem_ctx,
708 int argc, const char **argv)
709 {
710 POLICY_HND connect_pol, domain_pol, group_pol;
711 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
712 uint32 group_rid;
713 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
714 int i;
715 fstring server;
716 unsigned int old_timeout;
717 struct samr_RidTypeArray *rids = NULL;
718
719 if ((argc < 2) || (argc > 3)) {
720 printf("Usage: %s rid [access mask]\n", argv[0]);
721 return NT_STATUS_OK;
722 }
723
724 sscanf(argv[1], "%i", &group_rid);
725
726 if (argc > 2)
727 sscanf(argv[2], "%x", &access_mask);
728
729 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
730 strupper_m(server);
731
732 result = rpccli_try_samr_connects(cli, mem_ctx,
733 MAXIMUM_ALLOWED_ACCESS,
734 &connect_pol);
735
736 if (!NT_STATUS_IS_OK(result))
737 goto done;
738
739 result = rpccli_samr_OpenDomain(cli, mem_ctx,
740 &connect_pol,
741 MAXIMUM_ALLOWED_ACCESS,
742 &domain_sid,
743 &domain_pol);
744
745 if (!NT_STATUS_IS_OK(result))
746 goto done;
747
748 result = rpccli_samr_OpenGroup(cli, mem_ctx,
749 &domain_pol,
750 access_mask,
751 group_rid,
752 &group_pol);
753
754 if (!NT_STATUS_IS_OK(result))
755 goto done;
756
757 /* Make sure to wait for our DC's reply */
758 old_timeout = cli_set_timeout(cli->cli, MAX(cli->cli->timeout,30000)); /* 30 seconds. */
759
760 result = rpccli_samr_QueryGroupMember(cli, mem_ctx,
761 &group_pol,
762 &rids);
763
764 cli_set_timeout(cli->cli, old_timeout);
765
766 if (!NT_STATUS_IS_OK(result))
767 goto done;
768
769 for (i = 0; i < rids->count; i++) {
770 printf("\trid:[0x%x] attr:[0x%x]\n", rids->rids[i],
771 rids->types[i]);
772 }
773
774 rpccli_samr_Close(cli, mem_ctx, &group_pol);
775 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
776 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
777 done:
778 return result;
779 }
780
781 /* Enumerate domain users */
782
783 static NTSTATUS cmd_samr_enum_dom_users(struct rpc_pipe_client *cli,
784 TALLOC_CTX *mem_ctx,
785 int argc, const char **argv)
786 {
787 POLICY_HND connect_pol, domain_pol;
788 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
789 uint32 start_idx, size, num_dom_users, i;
790 struct samr_SamArray *dom_users = NULL;
791 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
792 uint32 acb_mask = ACB_NORMAL;
793 bool got_connect_pol = False, got_domain_pol = False;
794
795 if ((argc < 1) || (argc > 3)) {
796 printf("Usage: %s [access_mask] [acb_mask]\n", argv[0]);
797 return NT_STATUS_OK;
798 }
799
800 if (argc > 1)
801 sscanf(argv[1], "%x", &access_mask);
802
803 if (argc > 2)
804 sscanf(argv[2], "%x", &acb_mask);
805
806 /* Get sam policy handle */
807
808 result = rpccli_try_samr_connects(cli, mem_ctx,
809 MAXIMUM_ALLOWED_ACCESS,
810 &connect_pol);
811
812 if (!NT_STATUS_IS_OK(result))
813 goto done;
814
815 got_connect_pol = True;
816
817 /* Get domain policy handle */
818
819 result = rpccli_samr_OpenDomain(cli, mem_ctx,
820 &connect_pol,
821 access_mask,
822 &domain_sid,
823 &domain_pol);
824
825 if (!NT_STATUS_IS_OK(result))
826 goto done;
827
828 got_domain_pol = True;
829
830 /* Enumerate domain users */
831
832 start_idx = 0;
833 size = 0xffff;
834
835 do {
836 result = rpccli_samr_EnumDomainUsers(cli, mem_ctx,
837 &domain_pol,
838 &start_idx,
839 acb_mask,
840 &dom_users,
841 size,
842 &num_dom_users);
843
844 if (NT_STATUS_IS_OK(result) ||
845 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
846
847 for (i = 0; i < num_dom_users; i++)
848 printf("user:[%s] rid:[0x%x]\n",
849 dom_users->entries[i].name.string,
850 dom_users->entries[i].idx);
851 }
852
853 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
854
855 done:
856 if (got_domain_pol)
857 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
858
859 if (got_connect_pol)
860 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
861
862 return result;
863 }
864
865 /* Enumerate domain groups */
866
867 static NTSTATUS cmd_samr_enum_dom_groups(struct rpc_pipe_client *cli,
868 TALLOC_CTX *mem_ctx,
869 int argc, const char **argv)
870 {
871 POLICY_HND connect_pol, domain_pol;
872 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
873 uint32 start_idx, size, num_dom_groups, i;
874 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
875 struct samr_SamArray *dom_groups = NULL;
876 bool got_connect_pol = False, got_domain_pol = False;
877
878 if ((argc < 1) || (argc > 2)) {
879 printf("Usage: %s [access_mask]\n", argv[0]);
880 return NT_STATUS_OK;
881 }
882
883 if (argc > 1)
884 sscanf(argv[1], "%x", &access_mask);
885
886 /* Get sam policy handle */
887
888 result = rpccli_try_samr_connects(cli, mem_ctx,
889 MAXIMUM_ALLOWED_ACCESS,
890 &connect_pol);
891
892 if (!NT_STATUS_IS_OK(result))
893 goto done;
894
895 got_connect_pol = True;
896
897 /* Get domain policy handle */
898
899 result = rpccli_samr_OpenDomain(cli, mem_ctx,
900 &connect_pol,
901 access_mask,
902 &domain_sid,
903 &domain_pol);
904
905 if (!NT_STATUS_IS_OK(result))
906 goto done;
907
908 got_domain_pol = True;
909
910 /* Enumerate domain groups */
911
912 start_idx = 0;
913 size = 0xffff;
914
915 do {
916 result = rpccli_samr_EnumDomainGroups(cli, mem_ctx,
917 &domain_pol,
918 &start_idx,
919 &dom_groups,
920 size,
921 &num_dom_groups);
922 if (NT_STATUS_IS_OK(result) ||
923 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
924
925 for (i = 0; i < num_dom_groups; i++)
926 printf("group:[%s] rid:[0x%x]\n",
927 dom_groups->entries[i].name.string,
928 dom_groups->entries[i].idx);
929 }
930
931 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
932
933 done:
934 if (got_domain_pol)
935 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
936
937 if (got_connect_pol)
938 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
939
940 return result;
941 }
942
943 /* Enumerate alias groups */
944
945 static NTSTATUS cmd_samr_enum_als_groups(struct rpc_pipe_client *cli,
946 TALLOC_CTX *mem_ctx,
947 int argc, const char **argv)
948 {
949 POLICY_HND connect_pol, domain_pol;
950 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
951 uint32 start_idx, size, num_als_groups, i;
952 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
953 struct samr_SamArray *als_groups = NULL;
954 bool got_connect_pol = False, got_domain_pol = False;
955
956 if ((argc < 2) || (argc > 3)) {
957 printf("Usage: %s builtin|domain [access mask]\n", argv[0]);
958 return NT_STATUS_OK;
959 }
960
961 if (argc > 2)
962 sscanf(argv[2], "%x", &access_mask);
963
964 /* Get sam policy handle */
965
966 result = rpccli_try_samr_connects(cli, mem_ctx,
967 MAXIMUM_ALLOWED_ACCESS,
968 &connect_pol);
969
970 if (!NT_STATUS_IS_OK(result))
971 goto done;
972
973 got_connect_pol = True;
974
975 /* Get domain policy handle */
976
977 if (StrCaseCmp(argv[1], "domain")==0)
978 result = rpccli_samr_OpenDomain(cli, mem_ctx,
979 &connect_pol,
980 access_mask,
981 &domain_sid,
982 &domain_pol);
983 else if (StrCaseCmp(argv[1], "builtin")==0)
984 result = rpccli_samr_OpenDomain(cli, mem_ctx,
985 &connect_pol,
986 access_mask,
987 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
988 &domain_pol);
989 else
990 return NT_STATUS_OK;
991
992 if (!NT_STATUS_IS_OK(result))
993 goto done;
994
995 got_domain_pol = True;
996
997 /* Enumerate alias groups */
998
999 start_idx = 0;
1000 size = 0xffff; /* Number of groups to retrieve */
1001
1002 do {
1003 result = rpccli_samr_EnumDomainAliases(cli, mem_ctx,
1004 &domain_pol,
1005 &start_idx,
1006 &als_groups,
1007 size,
1008 &num_als_groups);
1009
1010 if (NT_STATUS_IS_OK(result) ||
1011 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1012
1013 for (i = 0; i < num_als_groups; i++)
1014 printf("group:[%s] rid:[0x%x]\n",
1015 als_groups->entries[i].name.string,
1016 als_groups->entries[i].idx);
1017 }
1018 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
1019
1020 done:
1021 if (got_domain_pol)
1022 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1023
1024 if (got_connect_pol)
1025 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1026
1027 return result;
1028 }
1029
1030 /* Enumerate domains */
1031
1032 static NTSTATUS cmd_samr_enum_domains(struct rpc_pipe_client *cli,
1033 TALLOC_CTX *mem_ctx,
1034 int argc, const char **argv)
1035 {
1036 POLICY_HND connect_pol;
1037 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1038 uint32 start_idx, size, num_entries, i;
1039 uint32 access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1040 bool got_connect_pol = false;
1041 struct samr_SamArray *sam = NULL;
1042
1043 if ((argc < 1) || (argc > 2)) {
1044 printf("Usage: %s [access mask]\n", argv[0]);
1045 return NT_STATUS_OK;
1046 }
1047
1048 if (argc > 1) {
1049 sscanf(argv[1], "%x", &access_mask);
1050 }
1051
1052 /* Get sam policy handle */
1053
1054 result = rpccli_try_samr_connects(cli, mem_ctx,
1055 access_mask,
1056 &connect_pol);
1057
1058 if (!NT_STATUS_IS_OK(result)) {
1059 goto done;
1060 }
1061
1062 got_connect_pol = true;
1063
1064 /* Enumerate alias groups */
1065
1066 start_idx = 0;
1067 size = 0xffff;
1068
1069 do {
1070 result = rpccli_samr_EnumDomains(cli, mem_ctx,
1071 &connect_pol,
1072 &start_idx,
1073 &sam,
1074 size,
1075 &num_entries);
1076
1077 if (NT_STATUS_IS_OK(result) ||
1078 NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
1079
1080 for (i = 0; i < num_entries; i++)
1081 printf("name:[%s] idx:[0x%x]\n",
1082 sam->entries[i].name.string,
1083 sam->entries[i].idx);
1084 }
1085 } while (NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES));
1086
1087 done:
1088 if (got_connect_pol) {
1089 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1090 }
1091
1092 return result;
1093 }
1094
1095
1096 /* Query alias membership */
1097
1098 static NTSTATUS cmd_samr_query_aliasmem(struct rpc_pipe_client *cli,
1099 TALLOC_CTX *mem_ctx,
1100 int argc, const char **argv)
1101 {
1102 POLICY_HND connect_pol, domain_pol, alias_pol;
1103 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1104 uint32 alias_rid, i;
1105 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1106 struct lsa_SidArray sid_array;
1107
1108 if ((argc < 3) || (argc > 4)) {
1109 printf("Usage: %s builtin|domain rid [access mask]\n", argv[0]);
1110 return NT_STATUS_OK;
1111 }
1112
1113 sscanf(argv[2], "%i", &alias_rid);
1114
1115 if (argc > 3)
1116 sscanf(argv[3], "%x", &access_mask);
1117
1118 /* Open SAMR handle */
1119
1120 result = rpccli_try_samr_connects(cli, mem_ctx,
1121 MAXIMUM_ALLOWED_ACCESS,
1122 &connect_pol);
1123
1124 if (!NT_STATUS_IS_OK(result))
1125 goto done;
1126
1127 /* Open handle on domain */
1128
1129 if (StrCaseCmp(argv[1], "domain")==0)
1130 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1131 &connect_pol,
1132 MAXIMUM_ALLOWED_ACCESS,
1133 &domain_sid,
1134 &domain_pol);
1135 else if (StrCaseCmp(argv[1], "builtin")==0)
1136 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1137 &connect_pol,
1138 MAXIMUM_ALLOWED_ACCESS,
1139 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
1140 &domain_pol);
1141 else
1142 return NT_STATUS_OK;
1143
1144 if (!NT_STATUS_IS_OK(result))
1145 goto done;
1146
1147 /* Open handle on alias */
1148
1149 result = rpccli_samr_OpenAlias(cli, mem_ctx,
1150 &domain_pol,
1151 access_mask,
1152 alias_rid,
1153 &alias_pol);
1154 if (!NT_STATUS_IS_OK(result))
1155 goto done;
1156
1157 result = rpccli_samr_GetMembersInAlias(cli, mem_ctx,
1158 &alias_pol,
1159 &sid_array);
1160
1161 if (!NT_STATUS_IS_OK(result))
1162 goto done;
1163
1164 for (i = 0; i < sid_array.num_sids; i++) {
1165 fstring sid_str;
1166
1167 sid_to_fstring(sid_str, sid_array.sids[i].sid);
1168 printf("\tsid:[%s]\n", sid_str);
1169 }
1170
1171 rpccli_samr_Close(cli, mem_ctx, &alias_pol);
1172 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1173 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1174 done:
1175 return result;
1176 }
1177
1178 /* Query alias info */
1179
1180 static NTSTATUS cmd_samr_query_aliasinfo(struct rpc_pipe_client *cli,
1181 TALLOC_CTX *mem_ctx,
1182 int argc, const char **argv)
1183 {
1184 POLICY_HND connect_pol, domain_pol, alias_pol;
1185 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1186 uint32_t alias_rid;
1187 uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1188 union samr_AliasInfo *info = NULL;
1189 enum samr_AliasInfoEnum level = ALIASINFOALL;
1190
1191 if ((argc < 3) || (argc > 4)) {
1192 printf("Usage: %s builtin|domain rid [level] [access mask]\n",
1193 argv[0]);
1194 return NT_STATUS_OK;
1195 }
1196
1197 sscanf(argv[2], "%i", &alias_rid);
1198
1199 if (argc > 2) {
1200 level = atoi(argv[3]);
1201 }
1202
1203 if (argc > 3) {
1204 sscanf(argv[4], "%x", &access_mask);
1205 }
1206
1207 /* Open SAMR handle */
1208
1209 result = rpccli_try_samr_connects(cli, mem_ctx,
1210 SEC_FLAG_MAXIMUM_ALLOWED,
1211 &connect_pol);
1212
1213 if (!NT_STATUS_IS_OK(result)) {
1214 goto done;
1215 }
1216
1217 /* Open handle on domain */
1218
1219 if (strequal(argv[1], "domain")) {
1220
1221 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1222 &connect_pol,
1223 SEC_FLAG_MAXIMUM_ALLOWED,
1224 &domain_sid,
1225 &domain_pol);
1226
1227 } else if (strequal(argv[1], "builtin")) {
1228
1229 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1230 &connect_pol,
1231 SEC_FLAG_MAXIMUM_ALLOWED,
1232 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
1233 &domain_pol);
1234
1235 } else {
1236 return NT_STATUS_OK;
1237 }
1238
1239 if (!NT_STATUS_IS_OK(result)) {
1240 goto done;
1241 }
1242
1243 /* Open handle on alias */
1244
1245 result = rpccli_samr_OpenAlias(cli, mem_ctx,
1246 &domain_pol,
1247 access_mask,
1248 alias_rid,
1249 &alias_pol);
1250 if (!NT_STATUS_IS_OK(result)) {
1251 goto done;
1252 }
1253
1254 result = rpccli_samr_QueryAliasInfo(cli, mem_ctx,
1255 &alias_pol,
1256 level,
1257 &info);
1258
1259 if (!NT_STATUS_IS_OK(result)) {
1260 goto done;
1261 }
1262
1263 switch (level) {
1264 case ALIASINFOALL:
1265 printf("Name: %s\n", info->all.name.string);
1266 printf("Description: %s\n", info->all.description.string);
1267 printf("Num Members: %d\n", info->all.num_members);
1268 break;
1269 case ALIASINFONAME:
1270 printf("Name: %s\n", info->name.string);
1271 break;
1272 case ALIASINFODESCRIPTION:
1273 printf("Description: %s\n", info->description.string);
1274 break;
1275 default:
1276 break;
1277 }
1278
1279 rpccli_samr_Close(cli, mem_ctx, &alias_pol);
1280 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1281 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1282 done:
1283 return result;
1284 }
1285
1286
1287 /* Query delete an alias membership */
1288
1289 static NTSTATUS cmd_samr_delete_alias(struct rpc_pipe_client *cli,
1290 TALLOC_CTX *mem_ctx,
1291 int argc, const char **argv)
1292 {
1293 POLICY_HND connect_pol, domain_pol, alias_pol;
1294 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1295 uint32 alias_rid;
1296 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1297
1298 if (argc != 3) {
1299 printf("Usage: %s builtin|domain [rid|name]\n", argv[0]);
1300 return NT_STATUS_OK;
1301 }
1302
1303 alias_rid = strtoul(argv[2], NULL, 10);
1304
1305 /* Open SAMR handle */
1306
1307 result = rpccli_try_samr_connects(cli, mem_ctx,
1308 MAXIMUM_ALLOWED_ACCESS,
1309 &connect_pol);
1310
1311 if (!NT_STATUS_IS_OK(result))
1312 goto done;
1313
1314 /* Open handle on domain */
1315
1316 if (StrCaseCmp(argv[1], "domain")==0)
1317 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1318 &connect_pol,
1319 MAXIMUM_ALLOWED_ACCESS,
1320 &domain_sid,
1321 &domain_pol);
1322 else if (StrCaseCmp(argv[1], "builtin")==0)
1323 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1324 &connect_pol,
1325 MAXIMUM_ALLOWED_ACCESS,
1326 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
1327 &domain_pol);
1328 else
1329 return NT_STATUS_INVALID_PARAMETER;
1330
1331 if (!NT_STATUS_IS_OK(result))
1332 goto done;
1333
1334 /* Open handle on alias */
1335
1336 result = rpccli_samr_OpenAlias(cli, mem_ctx,
1337 &domain_pol,
1338 access_mask,
1339 alias_rid,
1340 &alias_pol);
1341 if (!NT_STATUS_IS_OK(result) && (alias_rid == 0)) {
1342 /* Probably this was a user name, try lookupnames */
1343 struct samr_Ids rids, types;
1344 struct lsa_String lsa_acct_name;
1345
1346 init_lsa_String(&lsa_acct_name, argv[2]);
1347
1348 result = rpccli_samr_LookupNames(cli, mem_ctx,
1349 &domain_pol,
1350 1,
1351 &lsa_acct_name,
1352 &rids,
1353 &types);
1354
1355 if (NT_STATUS_IS_OK(result)) {
1356 result = rpccli_samr_OpenAlias(cli, mem_ctx,
1357 &domain_pol,
1358 access_mask,
1359 rids.ids[0],
1360 &alias_pol);
1361 }
1362 }
1363
1364 result = rpccli_samr_DeleteDomAlias(cli, mem_ctx,
1365 &alias_pol);
1366
1367 if (!NT_STATUS_IS_OK(result))
1368 goto done;
1369
1370 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1371 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1372 done:
1373 return result;
1374 }
1375
1376 /* Query display info */
1377
1378 static NTSTATUS cmd_samr_query_dispinfo_internal(struct rpc_pipe_client *cli,
1379 TALLOC_CTX *mem_ctx,
1380 int argc, const char **argv,
1381 uint32_t opcode)
1382 {
1383 POLICY_HND connect_pol, domain_pol;
1384 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1385 uint32 start_idx=0, max_entries=250, max_size = 0xffff, num_entries = 0, i;
1386 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1387 uint32 info_level = 1;
1388 union samr_DispInfo info;
1389 int loop_count = 0;
1390 bool got_params = False; /* Use get_query_dispinfo_params() or not? */
1391 uint32_t total_size, returned_size;
1392
1393 if (argc > 6) {
1394 printf("Usage: %s [info level] [start index] [max entries] [max size] [access mask]\n", argv[0]);
1395 return NT_STATUS_OK;
1396 }
1397
1398 if (argc >= 2)
1399 sscanf(argv[1], "%i", &info_level);
1400
1401 if (argc >= 3)
1402 sscanf(argv[2], "%i", &start_idx);
1403
1404 if (argc >= 4) {
1405 sscanf(argv[3], "%i", &max_entries);
1406 got_params = True;
1407 }
1408
1409 if (argc >= 5) {
1410 sscanf(argv[4], "%i", &max_size);
1411 got_params = True;
1412 }
1413
1414 if (argc >= 6)
1415 sscanf(argv[5], "%x", &access_mask);
1416
1417 /* Get sam policy handle */
1418
1419 result = rpccli_try_samr_connects(cli, mem_ctx,
1420 MAXIMUM_ALLOWED_ACCESS,
1421 &connect_pol);
1422
1423 if (!NT_STATUS_IS_OK(result))
1424 goto done;
1425
1426 /* Get domain policy handle */
1427
1428 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1429 &connect_pol,
1430 access_mask,
1431 &domain_sid,
1432 &domain_pol);
1433
1434 if (!NT_STATUS_IS_OK(result))
1435 goto done;
1436
1437 /* Query display info */
1438
1439 do {
1440
1441 if (!got_params)
1442 get_query_dispinfo_params(
1443 loop_count, &max_entries, &max_size);
1444
1445 switch (opcode) {
1446 case NDR_SAMR_QUERYDISPLAYINFO:
1447 result = rpccli_samr_QueryDisplayInfo(cli, mem_ctx,
1448 &domain_pol,
1449 info_level,
1450 start_idx,
1451 max_entries,
1452 max_size,
1453 &total_size,
1454 &returned_size,
1455 &info);
1456 break;
1457 case NDR_SAMR_QUERYDISPLAYINFO2:
1458 result = rpccli_samr_QueryDisplayInfo2(cli, mem_ctx,
1459 &domain_pol,
1460 info_level,
1461 start_idx,
1462 max_entries,
1463 max_size,
1464 &total_size,
1465 &returned_size,
1466 &info);
1467
1468 break;
1469 case NDR_SAMR_QUERYDISPLAYINFO3:
1470 result = rpccli_samr_QueryDisplayInfo3(cli, mem_ctx,
1471 &domain_pol,
1472 info_level,
1473 start_idx,
1474 max_entries,
1475 max_size,
1476 &total_size,
1477 &returned_size,
1478 &info);
1479
1480 break;
1481 default:
1482 return NT_STATUS_INVALID_PARAMETER;
1483 }
1484
1485 if (!NT_STATUS_IS_OK(result) &&
1486 !NT_STATUS_EQUAL(result, NT_STATUS_NO_MORE_ENTRIES) &&
1487 !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES)) {
1488 break;
1489 }
1490
1491 loop_count++;
1492
1493 switch (info_level) {
1494 case 1:
1495 num_entries = info.info1.count;
1496 break;
1497 case 2:
1498 num_entries = info.info2.count;
1499 break;
1500 case 3:
1501 num_entries = info.info3.count;
1502 break;
1503 case 4:
1504 num_entries = info.info4.count;
1505 break;
1506 case 5:
1507 num_entries = info.info5.count;
1508 break;
1509 default:
1510 break;
1511 }
1512
1513 start_idx += num_entries;
1514
1515 if (num_entries == 0)
1516 break;
1517
1518 for (i = 0; i < num_entries; i++) {
1519 switch (info_level) {
1520 case 1:
1521 display_sam_info_1(&info.info1.entries[i]);
1522 break;
1523 case 2:
1524 display_sam_info_2(&info.info2.entries[i]);
1525 break;
1526 case 3:
1527 display_sam_info_3(&info.info3.entries[i]);
1528 break;
1529 case 4:
1530 display_sam_info_4(&info.info4.entries[i]);
1531 break;
1532 case 5:
1533 display_sam_info_5(&info.info5.entries[i]);
1534 break;
1535 }
1536 }
1537 } while ( NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
1538
1539 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1540 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1541 done:
1542 return result;
1543 }
1544
1545 static NTSTATUS cmd_samr_query_dispinfo(struct rpc_pipe_client *cli,
1546 TALLOC_CTX *mem_ctx,
1547 int argc, const char **argv)
1548 {
1549 return cmd_samr_query_dispinfo_internal(cli, mem_ctx, argc, argv,
1550 NDR_SAMR_QUERYDISPLAYINFO);
1551 }
1552
1553 static NTSTATUS cmd_samr_query_dispinfo2(struct rpc_pipe_client *cli,
1554 TALLOC_CTX *mem_ctx,
1555 int argc, const char **argv)
1556 {
1557 return cmd_samr_query_dispinfo_internal(cli, mem_ctx, argc, argv,
1558 NDR_SAMR_QUERYDISPLAYINFO2);
1559 }
1560
1561 static NTSTATUS cmd_samr_query_dispinfo3(struct rpc_pipe_client *cli,
1562 TALLOC_CTX *mem_ctx,
1563 int argc, const char **argv)
1564 {
1565 return cmd_samr_query_dispinfo_internal(cli, mem_ctx, argc, argv,
1566 NDR_SAMR_QUERYDISPLAYINFO3);
1567 }
1568
1569 /* Query domain info */
1570
1571 static NTSTATUS cmd_samr_query_dominfo(struct rpc_pipe_client *cli,
1572 TALLOC_CTX *mem_ctx,
1573 int argc, const char **argv)
1574 {
1575 POLICY_HND connect_pol, domain_pol;
1576 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1577 uint32 switch_level = 2;
1578 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1579 union samr_DomainInfo *info = NULL;
1580
1581 if (argc > 3) {
1582 printf("Usage: %s [info level] [access mask]\n", argv[0]);
1583 return NT_STATUS_OK;
1584 }
1585
1586 if (argc > 1)
1587 sscanf(argv[1], "%i", &switch_level);
1588
1589 if (argc > 2)
1590 sscanf(argv[2], "%x", &access_mask);
1591
1592 /* Get sam policy handle */
1593
1594 result = rpccli_try_samr_connects(cli, mem_ctx,
1595 MAXIMUM_ALLOWED_ACCESS,
1596 &connect_pol);
1597
1598 if (!NT_STATUS_IS_OK(result))
1599 goto done;
1600
1601 /* Get domain policy handle */
1602
1603 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1604 &connect_pol,
1605 access_mask,
1606 &domain_sid,
1607 &domain_pol);
1608
1609 if (!NT_STATUS_IS_OK(result))
1610 goto done;
1611
1612 /* Query domain info */
1613
1614 result = rpccli_samr_QueryDomainInfo(cli, mem_ctx,
1615 &domain_pol,
1616 switch_level,
1617 &info);
1618
1619 if (!NT_STATUS_IS_OK(result))
1620 goto done;
1621
1622 /* Display domain info */
1623
1624 switch (switch_level) {
1625 case 1:
1626 display_sam_dom_info_1(&info->info1);
1627 break;
1628 case 2:
1629 display_sam_dom_info_2(&info->info2);
1630 break;
1631 case 3:
1632 display_sam_dom_info_3(&info->info3);
1633 break;
1634 case 4:
1635 display_sam_dom_info_4(&info->info4);
1636 break;
1637 case 5:
1638 display_sam_dom_info_5(&info->info5);
1639 break;
1640 case 6:
1641 display_sam_dom_info_6(&info->info6);
1642 break;
1643 case 7:
1644 display_sam_dom_info_7(&info->info7);
1645 break;
1646 case 8:
1647 display_sam_dom_info_8(&info->info8);
1648 break;
1649 case 9:
1650 display_sam_dom_info_9(&info->info9);
1651 break;
1652 case 12:
1653 display_sam_dom_info_12(&info->info12);
1654 break;
1655 case 13:
1656 display_sam_dom_info_13(&info->info13);
1657 break;
1658
1659 default:
1660 printf("cannot display domain info for switch value %d\n",
1661 switch_level);
1662 break;
1663 }
1664
1665 done:
1666
1667 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1668 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1669 return result;
1670 }
1671
1672 /* Create domain user */
1673
1674 static NTSTATUS cmd_samr_create_dom_user(struct rpc_pipe_client *cli,
1675 TALLOC_CTX *mem_ctx,
1676 int argc, const char **argv)
1677 {
1678 POLICY_HND connect_pol, domain_pol, user_pol;
1679 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1680 struct lsa_String acct_name;
1681 uint32 acb_info;
1682 uint32 acct_flags, user_rid;
1683 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1684 uint32_t access_granted = 0;
1685
1686 if ((argc < 2) || (argc > 3)) {
1687 printf("Usage: %s username [access mask]\n", argv[0]);
1688 return NT_STATUS_OK;
1689 }
1690
1691 init_lsa_String(&acct_name, argv[1]);
1692
1693 if (argc > 2)
1694 sscanf(argv[2], "%x", &access_mask);
1695
1696 /* Get sam policy handle */
1697
1698 result = rpccli_try_samr_connects(cli, mem_ctx,
1699 MAXIMUM_ALLOWED_ACCESS,
1700 &connect_pol);
1701
1702 if (!NT_STATUS_IS_OK(result))
1703 goto done;
1704
1705 /* Get domain policy handle */
1706
1707 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1708 &connect_pol,
1709 access_mask,
1710 &domain_sid,
1711 &domain_pol);
1712
1713 if (!NT_STATUS_IS_OK(result))
1714 goto done;
1715
1716 /* Create domain user */
1717
1718 acb_info = ACB_NORMAL;
1719 acct_flags = SEC_GENERIC_READ | SEC_GENERIC_WRITE | SEC_GENERIC_EXECUTE |
1720 SEC_STD_WRITE_DAC | SEC_STD_DELETE |
1721 SAMR_USER_ACCESS_SET_PASSWORD |
1722 SAMR_USER_ACCESS_GET_ATTRIBUTES |
1723 SAMR_USER_ACCESS_SET_ATTRIBUTES;
1724
1725 result = rpccli_samr_CreateUser2(cli, mem_ctx,
1726 &domain_pol,
1727 &acct_name,
1728 acb_info,
1729 acct_flags,
1730 &user_pol,
1731 &access_granted,
1732 &user_rid);
1733
1734 if (!NT_STATUS_IS_OK(result))
1735 goto done;
1736
1737 result = rpccli_samr_Close(cli, mem_ctx, &user_pol);
1738 if (!NT_STATUS_IS_OK(result)) goto done;
1739
1740 result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1741 if (!NT_STATUS_IS_OK(result)) goto done;
1742
1743 result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1744 if (!NT_STATUS_IS_OK(result)) goto done;
1745
1746 done:
1747 return result;
1748 }
1749
1750 /* Create domain group */
1751
1752 static NTSTATUS cmd_samr_create_dom_group(struct rpc_pipe_client *cli,
1753 TALLOC_CTX *mem_ctx,
1754 int argc, const char **argv)
1755 {
1756 POLICY_HND connect_pol, domain_pol, group_pol;
1757 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1758 struct lsa_String grp_name;
1759 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1760 uint32_t rid = 0;
1761
1762 if ((argc < 2) || (argc > 3)) {
1763 printf("Usage: %s groupname [access mask]\n", argv[0]);
1764 return NT_STATUS_OK;
1765 }
1766
1767 init_lsa_String(&grp_name, argv[1]);
1768
1769 if (argc > 2)
1770 sscanf(argv[2], "%x", &access_mask);
1771
1772 /* Get sam policy handle */
1773
1774 result = rpccli_try_samr_connects(cli, mem_ctx,
1775 MAXIMUM_ALLOWED_ACCESS,
1776 &connect_pol);
1777
1778 if (!NT_STATUS_IS_OK(result))
1779 goto done;
1780
1781 /* Get domain policy handle */
1782
1783 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1784 &connect_pol,
1785 access_mask,
1786 &domain_sid,
1787 &domain_pol);
1788
1789 if (!NT_STATUS_IS_OK(result))
1790 goto done;
1791
1792 /* Create domain user */
1793 result = rpccli_samr_CreateDomainGroup(cli, mem_ctx,
1794 &domain_pol,
1795 &grp_name,
1796 MAXIMUM_ALLOWED_ACCESS,
1797 &group_pol,
1798 &rid);
1799
1800 if (!NT_STATUS_IS_OK(result))
1801 goto done;
1802
1803 result = rpccli_samr_Close(cli, mem_ctx, &group_pol);
1804 if (!NT_STATUS_IS_OK(result)) goto done;
1805
1806 result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1807 if (!NT_STATUS_IS_OK(result)) goto done;
1808
1809 result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1810 if (!NT_STATUS_IS_OK(result)) goto done;
1811
1812 done:
1813 return result;
1814 }
1815
1816 /* Create domain alias */
1817
1818 static NTSTATUS cmd_samr_create_dom_alias(struct rpc_pipe_client *cli,
1819 TALLOC_CTX *mem_ctx,
1820 int argc, const char **argv)
1821 {
1822 POLICY_HND connect_pol, domain_pol, alias_pol;
1823 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1824 struct lsa_String alias_name;
1825 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
1826 uint32_t rid = 0;
1827
1828 if ((argc < 2) || (argc > 3)) {
1829 printf("Usage: %s aliasname [access mask]\n", argv[0]);
1830 return NT_STATUS_OK;
1831 }
1832
1833 init_lsa_String(&alias_name, argv[1]);
1834
1835 if (argc > 2)
1836 sscanf(argv[2], "%x", &access_mask);
1837
1838 /* Get sam policy handle */
1839
1840 result = rpccli_try_samr_connects(cli, mem_ctx,
1841 MAXIMUM_ALLOWED_ACCESS,
1842 &connect_pol);
1843
1844 if (!NT_STATUS_IS_OK(result))
1845 goto done;
1846
1847 /* Get domain policy handle */
1848
1849 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1850 &connect_pol,
1851 access_mask,
1852 &domain_sid,
1853 &domain_pol);
1854
1855 if (!NT_STATUS_IS_OK(result))
1856 goto done;
1857
1858 /* Create domain user */
1859
1860 result = rpccli_samr_CreateDomAlias(cli, mem_ctx,
1861 &domain_pol,
1862 &alias_name,
1863 MAXIMUM_ALLOWED_ACCESS,
1864 &alias_pol,
1865 &rid);
1866
1867 if (!NT_STATUS_IS_OK(result))
1868 goto done;
1869
1870 result = rpccli_samr_Close(cli, mem_ctx, &alias_pol);
1871 if (!NT_STATUS_IS_OK(result)) goto done;
1872
1873 result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1874 if (!NT_STATUS_IS_OK(result)) goto done;
1875
1876 result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1877 if (!NT_STATUS_IS_OK(result)) goto done;
1878
1879 done:
1880 return result;
1881 }
1882
1883 /* Lookup sam names */
1884
1885 static NTSTATUS cmd_samr_lookup_names(struct rpc_pipe_client *cli,
1886 TALLOC_CTX *mem_ctx,
1887 int argc, const char **argv)
1888 {
1889 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1890 POLICY_HND connect_pol, domain_pol;
1891 uint32 num_names;
1892 struct samr_Ids rids, name_types;
1893 int i;
1894 struct lsa_String *names = NULL;;
1895
1896 if (argc < 3) {
1897 printf("Usage: %s domain|builtin name1 [name2 [name3] [...]]\n", argv[0]);
1898 printf("check on the domain SID: S-1-5-21-x-y-z\n");
1899 printf("or check on the builtin SID: S-1-5-32\n");
1900 return NT_STATUS_OK;
1901 }
1902
1903 /* Get sam policy and domain handles */
1904
1905 result = rpccli_try_samr_connects(cli, mem_ctx,
1906 MAXIMUM_ALLOWED_ACCESS,
1907 &connect_pol);
1908
1909 if (!NT_STATUS_IS_OK(result))
1910 goto done;
1911
1912 if (StrCaseCmp(argv[1], "domain")==0)
1913 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1914 &connect_pol,
1915 MAXIMUM_ALLOWED_ACCESS,
1916 &domain_sid,
1917 &domain_pol);
1918 else if (StrCaseCmp(argv[1], "builtin")==0)
1919 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1920 &connect_pol,
1921 MAXIMUM_ALLOWED_ACCESS,
1922 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
1923 &domain_pol);
1924 else
1925 return NT_STATUS_OK;
1926
1927 if (!NT_STATUS_IS_OK(result))
1928 goto done;
1929
1930 /* Look up names */
1931
1932 num_names = argc - 2;
1933
1934 if ((names = TALLOC_ARRAY(mem_ctx, struct lsa_String, num_names)) == NULL) {
1935 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1936 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1937 result = NT_STATUS_NO_MEMORY;
1938 goto done;
1939 }
1940
1941 for (i = 0; i < num_names; i++) {
1942 init_lsa_String(&names[i], argv[i + 2]);
1943 }
1944
1945 result = rpccli_samr_LookupNames(cli, mem_ctx,
1946 &domain_pol,
1947 num_names,
1948 names,
1949 &rids,
1950 &name_types);
1951
1952 if (!NT_STATUS_IS_OK(result))
1953 goto done;
1954
1955 /* Display results */
1956
1957 for (i = 0; i < num_names; i++)
1958 printf("name %s: 0x%x (%d)\n", names[i].string, rids.ids[i],
1959 name_types.ids[i]);
1960
1961 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
1962 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
1963 done:
1964 return result;
1965 }
1966
1967 /* Lookup sam rids */
1968
1969 static NTSTATUS cmd_samr_lookup_rids(struct rpc_pipe_client *cli,
1970 TALLOC_CTX *mem_ctx,
1971 int argc, const char **argv)
1972 {
1973 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1974 POLICY_HND connect_pol, domain_pol;
1975 uint32_t num_rids, *rids;
1976 struct lsa_Strings names;
1977 struct samr_Ids types;
1978
1979 int i;
1980
1981 if (argc < 3) {
1982 printf("Usage: %s domain|builtin rid1 [rid2 [rid3] [...]]\n", argv[0]);
1983 return NT_STATUS_OK;
1984 }
1985
1986 /* Get sam policy and domain handles */
1987
1988 result = rpccli_try_samr_connects(cli, mem_ctx,
1989 MAXIMUM_ALLOWED_ACCESS,
1990 &connect_pol);
1991
1992 if (!NT_STATUS_IS_OK(result))
1993 goto done;
1994
1995 if (StrCaseCmp(argv[1], "domain")==0)
1996 result = rpccli_samr_OpenDomain(cli, mem_ctx,
1997 &connect_pol,
1998 MAXIMUM_ALLOWED_ACCESS,
1999 &domain_sid,
2000 &domain_pol);
2001 else if (StrCaseCmp(argv[1], "builtin")==0)
2002 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2003 &connect_pol,
2004 MAXIMUM_ALLOWED_ACCESS,
2005 CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
2006 &domain_pol);
2007 else
2008 return NT_STATUS_OK;
2009
2010 if (!NT_STATUS_IS_OK(result))
2011 goto done;
2012
2013 /* Look up rids */
2014
2015 num_rids = argc - 2;
2016
2017 if ((rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids)) == NULL) {
2018 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2019 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2020 result = NT_STATUS_NO_MEMORY;
2021 goto done;
2022 }
2023
2024 for (i = 0; i < argc - 2; i++)
2025 sscanf(argv[i + 2], "%i", &rids[i]);
2026
2027 result = rpccli_samr_LookupRids(cli, mem_ctx,
2028 &domain_pol,
2029 num_rids,
2030 rids,
2031 &names,
2032 &types);
2033
2034 if (!NT_STATUS_IS_OK(result) &&
2035 !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
2036 goto done;
2037
2038 /* Display results */
2039
2040 for (i = 0; i < num_rids; i++) {
2041 printf("rid 0x%x: %s (%d)\n",
2042 rids[i], names.names[i].string, types.ids[i]);
2043 }
2044
2045 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2046 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2047 done:
2048 return result;
2049 }
2050
2051 /* Delete domain group */
2052
2053 static NTSTATUS cmd_samr_delete_dom_group(struct rpc_pipe_client *cli,
2054 TALLOC_CTX *mem_ctx,
2055 int argc, const char **argv)
2056 {
2057 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2058 POLICY_HND connect_pol, domain_pol, group_pol;
2059 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2060
2061 if ((argc < 2) || (argc > 3)) {
2062 printf("Usage: %s groupname\n", argv[0]);
2063 return NT_STATUS_OK;
2064 }
2065
2066 if (argc > 2)
2067 sscanf(argv[2], "%x", &access_mask);
2068
2069 /* Get sam policy and domain handles */
2070
2071 result = rpccli_try_samr_connects(cli, mem_ctx,
2072 MAXIMUM_ALLOWED_ACCESS,
2073 &connect_pol);
2074
2075 if (!NT_STATUS_IS_OK(result))
2076 goto done;
2077
2078 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2079 &connect_pol,
2080 MAXIMUM_ALLOWED_ACCESS,
2081 &domain_sid,
2082 &domain_pol);
2083
2084 if (!NT_STATUS_IS_OK(result))
2085 goto done;
2086
2087 /* Get handle on group */
2088
2089 {
2090 struct samr_Ids group_rids, name_types;
2091 struct lsa_String lsa_acct_name;
2092
2093 init_lsa_String(&lsa_acct_name, argv[1]);
2094
2095 result = rpccli_samr_LookupNames(cli, mem_ctx,
2096 &domain_pol,
2097 1,
2098 &lsa_acct_name,
2099 &group_rids,
2100 &name_types);
2101 if (!NT_STATUS_IS_OK(result))
2102 goto done;
2103
2104 result = rpccli_samr_OpenGroup(cli, mem_ctx,
2105 &domain_pol,
2106 access_mask,
2107 group_rids.ids[0],
2108 &group_pol);
2109
2110 if (!NT_STATUS_IS_OK(result))
2111 goto done;
2112 }
2113
2114 /* Delete group */
2115
2116 result = rpccli_samr_DeleteDomainGroup(cli, mem_ctx,
2117 &group_pol);
2118
2119 if (!NT_STATUS_IS_OK(result))
2120 goto done;
2121
2122 /* Display results */
2123
2124 rpccli_samr_Close(cli, mem_ctx, &group_pol);
2125 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2126 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2127
2128 done:
2129 return result;
2130 }
2131
2132 /* Delete domain user */
2133
2134 static NTSTATUS cmd_samr_delete_dom_user(struct rpc_pipe_client *cli,
2135 TALLOC_CTX *mem_ctx,
2136 int argc, const char **argv)
2137 {
2138 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2139 POLICY_HND connect_pol, domain_pol, user_pol;
2140 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2141
2142 if ((argc < 2) || (argc > 3)) {
2143 printf("Usage: %s username\n", argv[0]);
2144 return NT_STATUS_OK;
2145 }
2146
2147 if (argc > 2)
2148 sscanf(argv[2], "%x", &access_mask);
2149
2150 /* Get sam policy and domain handles */
2151
2152 result = rpccli_try_samr_connects(cli, mem_ctx,
2153 MAXIMUM_ALLOWED_ACCESS,
2154 &connect_pol);
2155
2156 if (!NT_STATUS_IS_OK(result))
2157 goto done;
2158
2159 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2160 &connect_pol,
2161 MAXIMUM_ALLOWED_ACCESS,
2162 &domain_sid,
2163 &domain_pol);
2164
2165 if (!NT_STATUS_IS_OK(result))
2166 goto done;
2167
2168 /* Get handle on user */
2169
2170 {
2171 struct samr_Ids user_rids, name_types;
2172 struct lsa_String lsa_acct_name;
2173
2174 init_lsa_String(&lsa_acct_name, argv[1]);
2175
2176 result = rpccli_samr_LookupNames(cli, mem_ctx,
2177 &domain_pol,
2178 1,
2179 &lsa_acct_name,
2180 &user_rids,
2181 &name_types);
2182
2183 if (!NT_STATUS_IS_OK(result))
2184 goto done;
2185
2186 result = rpccli_samr_OpenUser(cli, mem_ctx,
2187 &domain_pol,
2188 access_mask,
2189 user_rids.ids[0],
2190 &user_pol);
2191
2192 if (!NT_STATUS_IS_OK(result))
2193 goto done;
2194 }
2195
2196 /* Delete user */
2197
2198 result = rpccli_samr_DeleteUser(cli, mem_ctx,
2199 &user_pol);
2200
2201 if (!NT_STATUS_IS_OK(result))
2202 goto done;
2203
2204 /* Display results */
2205
2206 rpccli_samr_Close(cli, mem_ctx, &user_pol);
2207 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2208 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2209
2210 done:
2211 return result;
2212 }
2213
2214 /**********************************************************************
2215 * Query user security object
2216 */
2217 static NTSTATUS cmd_samr_query_sec_obj(struct rpc_pipe_client *cli,
2218 TALLOC_CTX *mem_ctx,
2219 int argc, const char **argv)
2220 {
2221 POLICY_HND connect_pol, domain_pol, user_pol, *pol;
2222 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2223 uint32 sec_info = DACL_SECURITY_INFORMATION;
2224 fstring server;
2225 uint32 user_rid = 0;
2226 TALLOC_CTX *ctx = NULL;
2227 SEC_DESC_BUF *sec_desc_buf=NULL;
2228 bool domain = False;
2229
2230 ctx=talloc_init("cmd_samr_query_sec_obj");
2231
2232 if ((argc < 1) || (argc > 3)) {
2233 printf("Usage: %s [rid|-d] [sec_info]\n", argv[0]);
2234 printf("\tSpecify rid for security on user, -d for security on domain\n");
2235 talloc_destroy(ctx);
2236 return NT_STATUS_OK;
2237 }
2238
2239 if (argc > 1) {
2240 if (strcmp(argv[1], "-d") == 0)
2241 domain = True;
2242 else
2243 sscanf(argv[1], "%i", &user_rid);
2244 }
2245
2246 if (argc == 3) {
2247 sec_info = atoi(argv[2]);
2248 }
2249
2250 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
2251 strupper_m(server);
2252 result = rpccli_try_samr_connects(cli, mem_ctx,
2253 MAXIMUM_ALLOWED_ACCESS,
2254 &connect_pol);
2255
2256 if (!NT_STATUS_IS_OK(result))
2257 goto done;
2258
2259 if (domain || user_rid)
2260 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2261 &connect_pol,
2262 MAXIMUM_ALLOWED_ACCESS,
2263 &domain_sid,
2264 &domain_pol);
2265
2266 if (!NT_STATUS_IS_OK(result))
2267 goto done;
2268
2269 if (user_rid)
2270 result = rpccli_samr_OpenUser(cli, mem_ctx,
2271 &domain_pol,
2272 MAXIMUM_ALLOWED_ACCESS,
2273 user_rid,
2274 &user_pol);
2275
2276 if (!NT_STATUS_IS_OK(result))
2277 goto done;
2278
2279 /* Pick which query pol to use */
2280
2281 pol = &connect_pol;
2282
2283 if (domain)
2284 pol = &domain_pol;
2285
2286 if (user_rid)
2287 pol = &user_pol;
2288
2289 /* Query SAM security object */
2290
2291 result = rpccli_samr_QuerySecurity(cli, mem_ctx,
2292 pol,
2293 sec_info,
2294 &sec_desc_buf);
2295
2296 if (!NT_STATUS_IS_OK(result))
2297 goto done;
2298
2299 display_sec_desc(sec_desc_buf->sd);
2300
2301 rpccli_samr_Close(cli, mem_ctx, &user_pol);
2302 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2303 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2304 done:
2305 talloc_destroy(ctx);
2306 return result;
2307 }
2308
2309 static NTSTATUS cmd_samr_get_usrdom_pwinfo(struct rpc_pipe_client *cli,
2310 TALLOC_CTX *mem_ctx,
2311 int argc, const char **argv)
2312 {
2313 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2314 POLICY_HND connect_pol, domain_pol, user_pol;
2315 struct samr_PwInfo info;
2316 uint32_t rid;
2317
2318 if (argc != 2) {
2319 printf("Usage: %s rid\n", argv[0]);
2320 return NT_STATUS_OK;
2321 }
2322
2323 sscanf(argv[1], "%i", &rid);
2324
2325 result = rpccli_try_samr_connects(cli, mem_ctx,
2326 MAXIMUM_ALLOWED_ACCESS,
2327 &connect_pol);
2328
2329 if (!NT_STATUS_IS_OK(result)) {
2330 goto done;
2331 }
2332
2333 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2334 &connect_pol,
2335 MAXIMUM_ALLOWED_ACCESS,
2336 &domain_sid,
2337 &domain_pol);
2338
2339 if (!NT_STATUS_IS_OK(result)) {
2340 goto done;
2341 }
2342
2343 result = rpccli_samr_OpenUser(cli, mem_ctx,
2344 &domain_pol,
2345 MAXIMUM_ALLOWED_ACCESS,
2346 rid,
2347 &user_pol);
2348
2349 if (!NT_STATUS_IS_OK(result)) {
2350 goto done;
2351 }
2352
2353 result = rpccli_samr_GetUserPwInfo(cli, mem_ctx, &user_pol, &info);
2354 if (NT_STATUS_IS_OK(result)) {
2355 printf("min_password_length: %d\n", info.min_password_length);
2356 printf("%s\n",
2357 NDR_PRINT_STRUCT_STRING(mem_ctx,
2358 samr_PasswordProperties, &info.password_properties));
2359 }
2360
2361 done:
2362 rpccli_samr_Close(cli, mem_ctx, &user_pol);
2363 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2364 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2365
2366 return result;
2367 }
2368
2369 static NTSTATUS cmd_samr_get_dom_pwinfo(struct rpc_pipe_client *cli,
2370 TALLOC_CTX *mem_ctx,
2371 int argc, const char **argv)
2372 {
2373 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2374 struct lsa_String domain_name;
2375 struct samr_PwInfo info;
2376
2377 if (argc < 1 || argc > 3) {
2378 printf("Usage: %s <domain>\n", argv[0]);
2379 return NT_STATUS_OK;
2380 }
2381
2382 init_lsa_String(&domain_name, argv[1]);
2383
2384 result = rpccli_samr_GetDomPwInfo(cli, mem_ctx, &domain_name, &info);
2385
2386 if (NT_STATUS_IS_OK(result)) {
2387 printf("min_password_length: %d\n", info.min_password_length);
2388 display_password_properties(info.password_properties);
2389 }
2390
2391 return result;
2392 }
2393
2394 /* Look up domain name */
2395
2396 static NTSTATUS cmd_samr_lookup_domain(struct rpc_pipe_client *cli,
2397 TALLOC_CTX *mem_ctx,
2398 int argc, const char **argv)
2399 {
2400 POLICY_HND connect_pol, domain_pol;
2401 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2402 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2403 fstring sid_string;
2404 struct lsa_String domain_name;
2405 DOM_SID *sid = NULL;
2406
2407 if (argc != 2) {
2408 printf("Usage: %s domain_name\n", argv[0]);
2409 return NT_STATUS_OK;
2410 }
2411
2412 init_lsa_String(&domain_name, argv[1]);
2413
2414 result = rpccli_try_samr_connects(cli, mem_ctx,
2415 access_mask,
2416 &connect_pol);
2417
2418 if (!NT_STATUS_IS_OK(result))
2419 goto done;
2420
2421 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2422 &connect_pol,
2423 access_mask,
2424 &domain_sid,
2425 &domain_pol);
2426
2427 if (!NT_STATUS_IS_OK(result))
2428 goto done;
2429
2430 result = rpccli_samr_LookupDomain(cli, mem_ctx,
2431 &connect_pol,
2432 &domain_name,
2433 &sid);
2434
2435 if (NT_STATUS_IS_OK(result)) {
2436 sid_to_fstring(sid_string, sid);
2437 printf("SAMR_LOOKUP_DOMAIN: Domain Name: %s Domain SID: %s\n",
2438 argv[1], sid_string);
2439 }
2440
2441 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2442 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2443 done:
2444 return result;
2445 }
2446
2447 /* Change user password */
2448
2449 static NTSTATUS cmd_samr_chgpasswd2(struct rpc_pipe_client *cli,
2450 TALLOC_CTX *mem_ctx,
2451 int argc, const char **argv)
2452 {
2453 POLICY_HND connect_pol, domain_pol;
2454 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2455 const char *user, *oldpass, *newpass;
2456 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2457
2458 if (argc < 3) {
2459 printf("Usage: %s username oldpass newpass\n", argv[0]);
2460 return NT_STATUS_INVALID_PARAMETER;
2461 }
2462
2463 user = argv[1];
2464 oldpass = argv[2];
2465 newpass = argv[3];
2466
2467 /* Get sam policy handle */
2468
2469 result = rpccli_try_samr_connects(cli, mem_ctx,
2470 MAXIMUM_ALLOWED_ACCESS,
2471 &connect_pol);
2472
2473 if (!NT_STATUS_IS_OK(result))
2474 goto done;
2475
2476 /* Get domain policy handle */
2477
2478 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2479 &connect_pol,
2480 access_mask,
2481 &domain_sid,
2482 &domain_pol);
2483
2484 if (!NT_STATUS_IS_OK(result))
2485 goto done;
2486
2487 /* Change user password */
2488 result = rpccli_samr_chgpasswd_user(cli, mem_ctx, user, newpass, oldpass);
2489
2490 if (!NT_STATUS_IS_OK(result))
2491 goto done;
2492
2493 result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2494 if (!NT_STATUS_IS_OK(result)) goto done;
2495
2496 result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2497 if (!NT_STATUS_IS_OK(result)) goto done;
2498
2499 done:
2500 return result;
2501 }
2502
2503
2504 /* Change user password */
2505
2506 static NTSTATUS cmd_samr_chgpasswd3(struct rpc_pipe_client *cli,
2507 TALLOC_CTX *mem_ctx,
2508 int argc, const char **argv)
2509 {
2510 POLICY_HND connect_pol, domain_pol;
2511 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2512 const char *user, *oldpass, *newpass;
2513 uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
2514 struct samr_DomInfo1 *info = NULL;
2515 struct samr_ChangeReject *reject = NULL;
2516
2517 if (argc < 3) {
2518 printf("Usage: %s username oldpass newpass\n", argv[0]);
2519 return NT_STATUS_INVALID_PARAMETER;
2520 }
2521
2522 user = argv[1];
2523 oldpass = argv[2];
2524 newpass = argv[3];
2525
2526 /* Get sam policy handle */
2527
2528 result = rpccli_try_samr_connects(cli, mem_ctx,
2529 MAXIMUM_ALLOWED_ACCESS,
2530 &connect_pol);
2531
2532 if (!NT_STATUS_IS_OK(result))
2533 goto done;
2534
2535 /* Get domain policy handle */
2536
2537 result = rpccli_samr_OpenDomain(cli, mem_ctx,
2538 &connect_pol,
2539 access_mask,
2540 &domain_sid,
2541 &domain_pol);
2542
2543 if (!NT_STATUS_IS_OK(result))
2544 goto done;
2545
2546 /* Change user password */
2547 result = rpccli_samr_chgpasswd3(cli, mem_ctx,
2548 user,
2549 newpass,
2550 oldpass,
2551 &info,
2552 &reject);
2553
2554 if (NT_STATUS_EQUAL(result, NT_STATUS_PASSWORD_RESTRICTION)) {
2555
2556 display_sam_dom_info_1(info);
2557
2558 switch (reject->reason) {
2559 case SAMR_REJECT_TOO_SHORT:
2560 d_printf("SAMR_REJECT_TOO_SHORT\n");
2561 break;
2562 case SAMR_REJECT_IN_HISTORY:
2563 d_printf("SAMR_REJECT_IN_HISTORY\n");
2564 break;
2565 case SAMR_REJECT_COMPLEXITY:
2566 d_printf("SAMR_REJECT_COMPLEXITY\n");
2567 break;
2568 case SAMR_REJECT_OTHER:
2569 d_printf("SAMR_REJECT_OTHER\n");
2570 break;
2571 default:
2572 d_printf("unknown reject reason: %d\n",
2573 reject->reason);
2574 break;
2575 }
2576 }
2577
2578 if (!NT_STATUS_IS_OK(result))
2579 goto done;
2580
2581 result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
2582 if (!NT_STATUS_IS_OK(result)) goto done;
2583
2584 result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
2585 if (!NT_STATUS_IS_OK(result)) goto done;
2586
2587 done:
2588 return result;
2589 }
2590
2591 /* List of commands exported by this module */
2592
2593 struct cmd_set samr_commands[] = {
2594
2595 { "SAMR" },
2596
2597 { "queryuser", RPC_RTYPE_NTSTATUS, cmd_samr_query_user, NULL, PI_SAMR, NULL, "Query user info", "" },
2598 { "querygroup", RPC_RTYPE_NTSTATUS, cmd_samr_query_group, NULL, PI_SAMR, NULL, "Query group info", "" },
2599 { "queryusergroups", RPC_RTYPE_NTSTATUS, cmd_samr_query_usergroups, NULL, PI_SAMR, NULL, "Query user groups", "" },
2600 { "queryuseraliases", RPC_RTYPE_NTSTATUS, cmd_samr_query_useraliases, NULL, PI_SAMR, NULL, "Query user aliases", "" },
2601 { "querygroupmem", RPC_RTYPE_NTSTATUS, cmd_samr_query_groupmem, NULL, PI_SAMR, NULL, "Query group membership", "" },
2602 { "queryaliasmem", RPC_RTYPE_NTSTATUS, cmd_samr_query_aliasmem, NULL, PI_SAMR, NULL, "Query alias membership", "" },
2603 { "queryaliasinfo", RPC_RTYPE_NTSTATUS, cmd_samr_query_aliasinfo, NULL, PI_SAMR, NULL, "Query alias info", "" },
2604 { "deletealias", RPC_RTYPE_NTSTATUS, cmd_samr_delete_alias, NULL, PI_SAMR, NULL, "Delete an alias", "" },
2605 { "querydispinfo", RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo, NULL, PI_SAMR, NULL, "Query display info", "" },
2606 { "querydispinfo2", RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo2, NULL, PI_SAMR, NULL, "Query display info", "" },
2607 { "querydispinfo3", RPC_RTYPE_NTSTATUS, cmd_samr_query_dispinfo3, NULL, PI_SAMR, NULL, "Query display info", "" },
2608 { "querydominfo", RPC_RTYPE_NTSTATUS, cmd_samr_query_dominfo, NULL, PI_SAMR, NULL, "Query domain info", "" },
2609 { "enumdomusers", RPC_RTYPE_NTSTATUS, cmd_samr_enum_dom_users, NULL, PI_SAMR, NULL, "Enumerate domain users", "" },
2610 { "enumdomgroups", RPC_RTYPE_NTSTATUS, cmd_samr_enum_dom_groups, NULL, PI_SAMR, NULL, "Enumerate domain groups", "" },
2611 { "enumalsgroups", RPC_RTYPE_NTSTATUS, cmd_samr_enum_als_groups, NULL, PI_SAMR, NULL, "Enumerate alias groups", "" },
2612 { "enumdomains", RPC_RTYPE_NTSTATUS, cmd_samr_enum_domains, NULL, PI_SAMR, NULL, "Enumerate domains", "" },
2613
2614 { "createdomuser", RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_user, NULL, PI_SAMR, NULL, "Create domain user", "" },
2615 { "createdomgroup", RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_group, NULL, PI_SAMR, NULL, "Create domain group", "" },
2616 { "createdomalias", RPC_RTYPE_NTSTATUS, cmd_samr_create_dom_alias, NULL, PI_SAMR, NULL, "Create domain alias", "" },
2617 { "samlookupnames", RPC_RTYPE_NTSTATUS, cmd_samr_lookup_names, NULL, PI_SAMR, NULL, "Look up names", "" },
2618 { "samlookuprids", RPC_RTYPE_NTSTATUS, cmd_samr_lookup_rids, NULL, PI_SAMR, NULL, "Look up names", "" },
2619 { "deletedomgroup", RPC_RTYPE_NTSTATUS, cmd_samr_delete_dom_group, NULL, PI_SAMR, NULL, "Delete domain group", "" },
2620 { "deletedomuser", RPC_RTYPE_NTSTATUS, cmd_samr_delete_dom_user, NULL, PI_SAMR, NULL, "Delete domain user", "" },
2621 { "samquerysecobj", RPC_RTYPE_NTSTATUS, cmd_samr_query_sec_obj, NULL, PI_SAMR, NULL, "Query SAMR security object", "" },
2622 { "getdompwinfo", RPC_RTYPE_NTSTATUS, cmd_samr_get_dom_pwinfo, NULL, PI_SAMR, NULL, "Retrieve domain password info", "" },
2623 { "getusrdompwinfo", RPC_RTYPE_NTSTATUS, cmd_samr_get_usrdom_pwinfo, NULL, PI_SAMR, NULL, "Retrieve user domain password info", "" },
2624
2625 { "lookupdomain", RPC_RTYPE_NTSTATUS, cmd_samr_lookup_domain, NULL, PI_SAMR, NULL, "Lookup Domain Name", "" },
2626 { "chgpasswd2", RPC_RTYPE_NTSTATUS, cmd_samr_chgpasswd2, NULL, PI_SAMR, NULL, "Change user password", "" },
2627 { "chgpasswd3", RPC_RTYPE_NTSTATUS, cmd_samr_chgpasswd3, NULL, PI_SAMR, NULL, "Change user password", "" },
2628 { NULL }
2629 };
Samba GIT mirror