?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
more rpcclient syncs with HEAD. Should not affect server functionality
[Samba.git] / source / rpcclient / cmd_samr.c
blobed152b9f5c88b25549803e5e35b8ec94a89e778d
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
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26 #include "rpcclient.h"
27
28 extern DOM_SID domain_sid;
29
30 /****************************************************************************
31 display sam_user_info_21 structure
32 ****************************************************************************/
33 static void display_sam_user_info_21(SAM_USER_INFO_21 *usr)
34 {
35 fstring temp;
36
37 unistr2_to_ascii(temp, &usr->uni_user_name, sizeof(temp)-1);
38 printf("\tUser Name :\t%s\n", temp);
39
40 unistr2_to_ascii(temp, &usr->uni_full_name, sizeof(temp)-1);
41 printf("\tFull Name :\t%s\n", temp);
42
43 unistr2_to_ascii(temp, &usr->uni_home_dir, sizeof(temp)-1);
44 printf("\tHome Drive :\t%s\n", temp);
45
46 unistr2_to_ascii(temp, &usr->uni_dir_drive, sizeof(temp)-1);
47 printf("\tDir Drive :\t%s\n", temp);
48
49 unistr2_to_ascii(temp, &usr->uni_profile_path, sizeof(temp)-1);
50 printf("\tProfile Path:\t%s\n", temp);
51
52 unistr2_to_ascii(temp, &usr->uni_logon_script, sizeof(temp)-1);
53 printf("\tLogon Script:\t%s\n", temp);
54
55 unistr2_to_ascii(temp, &usr->uni_acct_desc, sizeof(temp)-1);
56 printf("\tDescription :\t%s\n", temp);
57
58 unistr2_to_ascii(temp, &usr->uni_workstations, sizeof(temp)-1);
59 printf("\tWorkstations:\t%s\n", temp);
60
61 unistr2_to_ascii(temp, &usr->uni_unknown_str, sizeof(temp)-1);
62 printf("\tUnknown Str :\t%s\n", temp);
63
64 unistr2_to_ascii(temp, &usr->uni_munged_dial, sizeof(temp)-1);
65 printf("\tRemote Dial :\t%s\n", temp);
66
67 printf("\tLogon Time :\t%s\n",
68 http_timestring(nt_time_to_unix(&usr->logon_time)));
69 printf("\tLogoff Time :\t%s\n",
70 http_timestring(nt_time_to_unix(&usr->logoff_time)));
71 printf("\tKickoff Time :\t%s\n",
72 http_timestring(nt_time_to_unix(&usr->kickoff_time)));
73 printf("\tPassword last set Time :\t%s\n",
74 http_timestring(nt_time_to_unix(&usr->pass_last_set_time)));
75 printf("\tPassword can change Time :\t%s\n",
76 http_timestring(nt_time_to_unix(&usr->pass_can_change_time)));
77 printf("\tPassword must change Time:\t%s\n",
78 http_timestring(nt_time_to_unix(&usr->pass_must_change_time)));
79
80 printf("\tunknown_2[0..31]...\n"); /* user passwords? */
81
82 printf("\tuser_rid :\t%x\n" , usr->user_rid ); /* User ID */
83 printf("\tgroup_rid:\t%x\n" , usr->group_rid); /* Group ID */
84 printf("\tacb_info :\t%04x\n", usr->acb_info ); /* Account Control Info */
85
86 printf("\tunknown_3:\t%08x\n", usr->unknown_3); /* 0x00ff ffff */
87 printf("\tlogon_divs:\t%d\n", usr->logon_divs); /* 0x0000 00a8 which is 168 which is num hrs in a week */
88 printf("\tunknown_5:\t%08x\n", usr->unknown_5); /* 0x0002 0000 */
89
90 printf("\tpadding1[0..7]...\n");
91
92 if (usr->ptr_logon_hrs) {
93 printf("\tlogon_hrs[0..%d]...\n", usr->logon_hrs.len);
94 }
95 }
96
97 static char *display_time(NTTIME nttime)
98 {
99 static fstring string;
100
101 float high;
102 float low;
103 int sec;
104 int days, hours, mins, secs;
105
106 if (nttime.high==0 && nttime.low==0)
107 return "Now";
108
109 if (nttime.high==0x80000000 && nttime.low==0)
110 return "Never";
111
112 high = 65536;
113 high = high/10000;
114 high = high*65536;
115 high = high/1000;
116 high = high * (~nttime.high);
117
118 low = ~nttime.low;
119 low = low/(1000*1000*10);
120
121 sec=high+low;
122
123 days=sec/(60*60*24);
124 hours=(sec - (days*60*60*24)) / (60*60);
125 mins=(sec - (days*60*60*24) - (hours*60*60) ) / 60;
126 secs=sec - (days*60*60*24) - (hours*60*60) - (mins*60);
127
128 snprintf(string, sizeof(string)-1, "%u days, %u hours, %u minutes, %u seconds", days, hours, mins, secs);
129 return (string);
130 }
131
132 static void display_sam_unk_info_1(SAM_UNK_INFO_1 *info1)
133 {
134
135 printf("Minimum password length: %d\n", info1->min_length_password);
136 printf("Password uniqueness (remember x passwords): %d\n", info1->password_history);
137 printf("flag: ");
138 if(info1->flag&&2==2) printf("users must open a session to change password ");
139 printf("\n");
140
141 printf("password expire in: %s\n", display_time(info1->expire));
142 printf("Min password age (allow changing in x days): %s\n", display_time(info1->min_passwordage));
143 }
144
145 static void display_sam_unk_info_2(SAM_UNK_INFO_2 *info2)
146 {
147 fstring name;
148
149 unistr2_to_ascii(name, &info2->uni_domain, sizeof(name) - 1);
150 printf("Domain:\t%s\n", name);
151
152 unistr2_to_ascii(name, &info2->uni_server, sizeof(name) - 1);
153 printf("Server:\t%s\n", name);
154
155 printf("Total Users:\t%d\n", info2->num_domain_usrs);
156 printf("Total Groups:\t%d\n", info2->num_domain_grps);
157 printf("Total Aliases:\t%d\n", info2->num_local_grps);
158
159 printf("Sequence No:\t%d\n", info2->seq_num);
160
161 printf("Unknown 0:\t0x%x\n", info2->unknown_0);
162 printf("Unknown 1:\t0x%x\n", info2->unknown_1);
163 printf("Unknown 2:\t0x%x\n", info2->unknown_2);
164 printf("Unknown 3:\t0x%x\n", info2->unknown_3);
165 printf("Unknown 4:\t0x%x\n", info2->unknown_4);
166 printf("Unknown 5:\t0x%x\n", info2->unknown_5);
167 printf("Unknown 6:\t0x%x\n", info2->unknown_6);
168 }
169
170 static void display_sam_info_1(SAM_ENTRY1 *e1, SAM_STR1 *s1)
171 {
172 fstring tmp;
173
174 printf("index: 0x%x ", e1->user_idx);
175 printf("RID: 0x%x ", e1->rid_user);
176 printf("acb: 0x%x ", e1->acb_info);
177
178 unistr2_to_ascii(tmp, &s1->uni_acct_name, sizeof(tmp)-1);
179 printf("Account: %s\t", tmp);
180
181 unistr2_to_ascii(tmp, &s1->uni_full_name, sizeof(tmp)-1);
182 printf("Name: %s\t", tmp);
183
184 unistr2_to_ascii(tmp, &s1->uni_acct_desc, sizeof(tmp)-1);
185 printf("Desc: %s\n", tmp);
186 }
187
188 static void display_sam_info_2(SAM_ENTRY2 *e2, SAM_STR2 *s2)
189 {
190 fstring tmp;
191
192 printf("index: 0x%x ", e2->user_idx);
193 printf("RID: 0x%x ", e2->rid_user);
194 printf("acb: 0x%x ", e2->acb_info);
195
196 unistr2_to_ascii(tmp, &s2->uni_srv_name, sizeof(tmp)-1);
197 printf("Account: %s\t", tmp);
198
199 unistr2_to_ascii(tmp, &s2->uni_srv_desc, sizeof(tmp)-1);
200 printf("Name: %s\n", tmp);
201
202 }
203
204 static void display_sam_info_3(SAM_ENTRY3 *e3, SAM_STR3 *s3)
205 {
206 fstring tmp;
207
208 printf("index: 0x%x ", e3->grp_idx);
209 printf("RID: 0x%x ", e3->rid_grp);
210 printf("attr: 0x%x ", e3->attr);
211
212 unistr2_to_ascii(tmp, &s3->uni_grp_name, sizeof(tmp)-1);
213 printf("Account: %s\t", tmp);
214
215 unistr2_to_ascii(tmp, &s3->uni_grp_desc, sizeof(tmp)-1);
216 printf("Name: %s\n", tmp);
217
218 }
219
220 static void display_sam_info_4(SAM_ENTRY4 *e4, SAM_STR4 *s4)
221 {
222 int i;
223
224 printf("index: %d ", e4->user_idx);
225
226 printf("Account: ");
227 for (i=0; i<s4->acct_name.str_str_len; i++)
228 printf("%c", s4->acct_name.buffer[i]);
229 printf("\n");
230
231 }
232
233 static void display_sam_info_5(SAM_ENTRY5 *e5, SAM_STR5 *s5)
234 {
235 int i;
236
237 printf("index: 0x%x ", e5->grp_idx);
238
239 printf("Account: ");
240 for (i=0; i<s5->grp_name.str_str_len; i++)
241 printf("%c", s5->grp_name.buffer[i]);
242 printf("\n");
243
244 }
245
246 /**********************************************************************
247 * Query user information
248 */
249 static NTSTATUS cmd_samr_query_user(struct cli_state *cli,
250 TALLOC_CTX *mem_ctx,
251 int argc, char **argv)
252 {
253 POLICY_HND connect_pol, domain_pol, user_pol;
254 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
255 uint32 info_level = 21;
256 SAM_USERINFO_CTR *user_ctr;
257 fstring server;
258 uint32 user_rid;
259
260 if (argc != 2) {
261 printf("Usage: %s rid\n", argv[0]);
262 return NT_STATUS_OK;
263 }
264
265 sscanf(argv[1], "%i", &user_rid);
266
267 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
268 strupper (server);
269
270 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
271 &connect_pol);
272
273 if (!NT_STATUS_IS_OK(result))
274 goto done;
275
276 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
277 MAXIMUM_ALLOWED_ACCESS,
278 &domain_sid, &domain_pol);
279
280 if (!NT_STATUS_IS_OK(result))
281 goto done;
282
283 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
284 MAXIMUM_ALLOWED_ACCESS,
285 user_rid, &user_pol);
286
287 if (!NT_STATUS_IS_OK(result))
288 goto done;
289
290 ZERO_STRUCT(user_ctr);
291
292 result = cli_samr_query_userinfo(cli, mem_ctx, &user_pol,
293 info_level, &user_ctr);
294
295 if (!NT_STATUS_IS_OK(result))
296 goto done;
297
298 display_sam_user_info_21(user_ctr->info.id21);
299
300 done:
301 return result;
302 }
303
304 /****************************************************************************
305 display group info
306 ****************************************************************************/
307 static void display_group_info1(GROUP_INFO1 *info1)
308 {
309 fstring temp;
310
311 unistr2_to_ascii(temp, &info1->uni_acct_name, sizeof(temp)-1);
312 printf("\tGroup Name:\t%s\n", temp);
313 unistr2_to_ascii(temp, &info1->uni_acct_desc, sizeof(temp)-1);
314 printf("\tDescription:\t%s\n", temp);
315 printf("\tunk1:%d\n", info1->unknown_1);
316 printf("\tNum Members:%d\n", info1->num_members);
317 }
318
319 /****************************************************************************
320 display group info
321 ****************************************************************************/
322 static void display_group_info4(GROUP_INFO4 *info4)
323 {
324 fstring desc;
325
326 unistr2_to_ascii(desc, &info4->uni_acct_desc, sizeof(desc)-1);
327 printf("\tGroup Description:%s\n", desc);
328 }
329
330 /****************************************************************************
331 display sam sync structure
332 ****************************************************************************/
333 static void display_group_info_ctr(GROUP_INFO_CTR *ctr)
334 {
335 switch (ctr->switch_value1) {
336 case 1: {
337 display_group_info1(&ctr->group.info1);
338 break;
339 }
340 case 4: {
341 display_group_info4(&ctr->group.info4);
342 break;
343 }
344 }
345 }
346
347 /***********************************************************************
348 * Query group information
349 */
350 static NTSTATUS cmd_samr_query_group(struct cli_state *cli,
351 TALLOC_CTX *mem_ctx,
352 int argc, char **argv)
353 {
354 POLICY_HND connect_pol, domain_pol, group_pol;
355 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
356 uint32 info_level = 1;
357 GROUP_INFO_CTR group_ctr;
358 fstring server;
359 uint32 group_rid;
360
361 if (argc != 2) {
362 printf("Usage: %s rid\n", argv[0]);
363 return NT_STATUS_OK;
364 }
365
366 sscanf(argv[1], "%i", &group_rid);
367
368 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
369 strupper (server);
370
371 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
372 &connect_pol);
373
374 if (!NT_STATUS_IS_OK(result))
375 goto done;
376
377 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
378 MAXIMUM_ALLOWED_ACCESS,
379 &domain_sid, &domain_pol);
380
381 if (!NT_STATUS_IS_OK(result))
382 goto done;
383
384 result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
385 MAXIMUM_ALLOWED_ACCESS,
386 group_rid, &group_pol);
387
388 if (!NT_STATUS_IS_OK(result))
389 goto done;
390
391 ZERO_STRUCT(group_ctr);
392
393 result = cli_samr_query_groupinfo(cli, mem_ctx, &group_pol,
394 info_level, &group_ctr);
395 if (!NT_STATUS_IS_OK(result)) {
396 goto done;
397 }
398
399 display_group_info_ctr(&group_ctr);
400
401 done:
402 return result;
403 }
404
405 /* Query groups a user is a member of */
406
407 static NTSTATUS cmd_samr_query_usergroups(struct cli_state *cli,
408 TALLOC_CTX *mem_ctx,
409 int argc, char **argv)
410 {
411 POLICY_HND connect_pol,
412 domain_pol,
413 user_pol;
414 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
415 uint32 num_groups,
416 user_rid;
417 DOM_GID *user_gids;
418 int i;
419 fstring server;
420
421 if (argc != 2) {
422 printf("Usage: %s rid\n", argv[0]);
423 return NT_STATUS_OK;
424 }
425
426 sscanf(argv[1], "%i", &user_rid);
427
428 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
429 strupper (server);
430
431 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
432 &connect_pol);
433 if (!NT_STATUS_IS_OK(result)) {
434 goto done;
435 }
436
437 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
438 MAXIMUM_ALLOWED_ACCESS,
439 &domain_sid, &domain_pol);
440 if (!NT_STATUS_IS_OK(result)) {
441 goto done;
442 }
443
444 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
445 MAXIMUM_ALLOWED_ACCESS,
446 user_rid, &user_pol);
447 if (!NT_STATUS_IS_OK(result)) {
448 goto done;
449 }
450
451 result = cli_samr_query_usergroups(cli, mem_ctx, &user_pol,
452 &num_groups, &user_gids);
453 if (!NT_STATUS_IS_OK(result)) {
454 goto done;
455 }
456
457 for (i = 0; i < num_groups; i++) {
458 printf("\tgroup rid:[0x%x] attr:[0x%x]\n",
459 user_gids[i].g_rid, user_gids[i].attr);
460 }
461
462 done:
463 return result;
464 }
465
466 /* Query aliases a user is a member of */
467
468 static NTSTATUS cmd_samr_query_useraliases(struct cli_state *cli,
469 TALLOC_CTX *mem_ctx,
470 int argc, char **argv)
471 {
472 POLICY_HND connect_pol, domain_pol;
473 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
474 uint32 user_rid, num_aliases, *alias_rids;
475 int i;
476 fstring server;
477 DOM_SID tmp_sid;
478 DOM_SID2 sid;
479 DOM_SID global_sid_Builtin;
480
481 string_to_sid(&global_sid_Builtin, "S-1-5-32");
482
483 if (argc != 3) {
484 printf("Usage: %s builtin|domain rid\n", argv[0]);
485 return NT_STATUS_OK;
486 }
487
488 sscanf(argv[2], "%i", &user_rid);
489
490 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
491 strupper (server);
492
493 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
494 &connect_pol);
495 if (!NT_STATUS_IS_OK(result)) {
496 goto done;
497 }
498
499 if (StrCaseCmp(argv[1], "domain")==0)
500 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
501 MAXIMUM_ALLOWED_ACCESS,
502 &domain_sid, &domain_pol);
503 else if (StrCaseCmp(argv[1], "builtin")==0)
504 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
505 MAXIMUM_ALLOWED_ACCESS,
506 &global_sid_Builtin, &domain_pol);
507 else
508 return NT_STATUS_OK;
509
510 if (!NT_STATUS_IS_OK(result)) {
511 goto done;
512 }
513
514 sid_copy(&tmp_sid, &domain_sid);
515 sid_append_rid(&tmp_sid, user_rid);
516 init_dom_sid2(&sid, &tmp_sid);
517
518 result = cli_samr_query_useraliases(cli, mem_ctx, &domain_pol, 1, &sid, &num_aliases, &alias_rids);
519 if (!NT_STATUS_IS_OK(result)) {
520 goto done;
521 }
522
523 for (i = 0; i < num_aliases; i++) {
524 printf("\tgroup rid:[0x%x]\n", alias_rids[i]);
525 }
526
527 done:
528 return result;
529 }
530
531 /* Query members of a group */
532
533 static NTSTATUS cmd_samr_query_groupmem(struct cli_state *cli,
534 TALLOC_CTX *mem_ctx,
535 int argc, char **argv)
536 {
537 POLICY_HND connect_pol, domain_pol, group_pol;
538 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
539 uint32 num_members, *group_rids, *group_attrs, group_rid;
540 int i;
541 fstring server;
542
543 if (argc != 2) {
544 printf("Usage: %s rid\n", argv[0]);
545 return NT_STATUS_OK;
546 }
547
548 sscanf(argv[1], "%i", &group_rid);
549
550 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
551 strupper (server);
552
553 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
554 &connect_pol);
555 if (!NT_STATUS_IS_OK(result)) {
556 goto done;
557 }
558
559 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
560 MAXIMUM_ALLOWED_ACCESS,
561 &domain_sid, &domain_pol);
562 if (!NT_STATUS_IS_OK(result)) {
563 goto done;
564 }
565
566 result = cli_samr_open_group(cli, mem_ctx, &domain_pol,
567 MAXIMUM_ALLOWED_ACCESS,
568 group_rid, &group_pol);
569 if (!NT_STATUS_IS_OK(result)) {
570 goto done;
571 }
572
573 result = cli_samr_query_groupmem(cli, mem_ctx, &group_pol,
574 &num_members, &group_rids,
575 &group_attrs);
576 if (!NT_STATUS_IS_OK(result)) {
577 goto done;
578 }
579
580 for (i = 0; i < num_members; i++) {
581 printf("\trid:[0x%x] attr:[0x%x]\n", group_rids[i],
582 group_attrs[i]);
583 }
584
585 done:
586 return result;
587 }
588
589 /* Enumerate domain groups */
590
591 static NTSTATUS cmd_samr_enum_dom_groups(struct cli_state *cli,
592 TALLOC_CTX *mem_ctx,
593 int argc, char **argv)
594 {
595 POLICY_HND connect_pol, domain_pol;
596 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
597 uint32 start_idx, size, num_dom_groups, i;
598 struct acct_info *dom_groups;
599
600 if (argc != 1) {
601 printf("Usage: %s\n", argv[0]);
602 return NT_STATUS_OK;
603 }
604
605 /* Get sam policy handle */
606
607 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
608 &connect_pol);
609 if (!NT_STATUS_IS_OK(result)) {
610 goto done;
611 }
612
613 /* Get domain policy handle */
614
615 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
616 MAXIMUM_ALLOWED_ACCESS,
617 &domain_sid, &domain_pol);
618 if (!NT_STATUS_IS_OK(result)) {
619 goto done;
620 }
621
622 /* Enumerate domain groups */
623
624 start_idx = 0;
625 size = 0xffff;
626
627 result = cli_samr_enum_dom_groups(cli, mem_ctx, &domain_pol,
628 &start_idx, size,
629 &dom_groups, &num_dom_groups);
630
631 for (i = 0; i < num_dom_groups; i++)
632 printf("group:[%s] rid:[0x%x]\n", dom_groups[i].acct_name,
633 dom_groups[i].rid);
634
635 done:
636 return result;
637 }
638
639 /* Enumerate domain groups */
640
641 static NTSTATUS cmd_samr_enum_als_groups(struct cli_state *cli,
642 TALLOC_CTX *mem_ctx,
643 int argc, char **argv)
644 {
645 POLICY_HND connect_pol, domain_pol;
646 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
647 uint32 start_idx, size, num_dom_groups, i;
648 struct acct_info *dom_groups;
649 DOM_SID global_sid_Builtin;
650
651 string_to_sid(&global_sid_Builtin, "S-1-5-32");
652
653 if (argc != 2) {
654 printf("Usage: %s builtin|domain\n", argv[0]);
655 return NT_STATUS_OK;
656 }
657
658 /* Get sam policy handle */
659
660 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
661 &connect_pol);
662 if (!NT_STATUS_IS_OK(result)) {
663 goto done;
664 }
665
666 /* Get domain policy handle */
667
668 if (StrCaseCmp(argv[1], "domain")==0)
669 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
670 MAXIMUM_ALLOWED_ACCESS,
671 &domain_sid, &domain_pol);
672 else if (StrCaseCmp(argv[1], "builtin")==0)
673 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
674 MAXIMUM_ALLOWED_ACCESS,
675 &global_sid_Builtin, &domain_pol);
676 else
677 return NT_STATUS_OK;
678 if (!NT_STATUS_IS_OK(result)) {
679 goto done;
680 }
681
682 /* Enumerate domain groups */
683
684 start_idx = 0;
685 size = 0xffff;
686
687 result = cli_samr_enum_als_groups(cli, mem_ctx, &domain_pol,
688 &start_idx, size,
689 &dom_groups, &num_dom_groups);
690
691 for (i = 0; i < num_dom_groups; i++)
692 printf("group:[%s] rid:[0x%x]\n", dom_groups[i].acct_name,
693 dom_groups[i].rid);
694
695 done:
696 return result;
697 }
698
699 /* Query alias membership */
700
701 static NTSTATUS cmd_samr_query_aliasmem(struct cli_state *cli,
702 TALLOC_CTX *mem_ctx,
703 int argc, char **argv)
704 {
705 POLICY_HND connect_pol, domain_pol, alias_pol;
706 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
707 uint32 alias_rid, num_members, i;
708 DOM_SID *alias_sids;
709
710 if (argc != 2) {
711 printf("Usage: %s rid\n", argv[0]);
712 return NT_STATUS_OK;
713 }
714
715 sscanf(argv[1], "%i", &alias_rid);
716
717 /* Open SAMR handle */
718
719 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
720 &connect_pol);
721 if (!NT_STATUS_IS_OK(result)) {
722 goto done;
723 }
724
725 /* Open handle on domain */
726
727 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
728 MAXIMUM_ALLOWED_ACCESS,
729 &domain_sid, &domain_pol);
730 if (!NT_STATUS_IS_OK(result)) {
731 goto done;
732 }
733
734 /* Open handle on alias */
735
736 result = cli_samr_open_alias(cli, mem_ctx, &domain_pol,
737 MAXIMUM_ALLOWED_ACCESS,
738 alias_rid, &alias_pol);
739 if (!NT_STATUS_IS_OK(result)) {
740 goto done;
741 }
742
743 result = cli_samr_query_aliasmem(cli, mem_ctx, &alias_pol,
744 &num_members, &alias_sids);
745 if (!NT_STATUS_IS_OK(result)) {
746 goto done;
747 }
748
749 for (i = 0; i < num_members; i++) {
750 fstring sid_str;
751
752 sid_to_string(sid_str, &alias_sids[i]);
753 printf("\tsid:[%s]\n", sid_str);
754 }
755
756 done:
757 return result;
758 }
759
760 /* Query display info */
761
762 static NTSTATUS cmd_samr_query_dispinfo(struct cli_state *cli,
763 TALLOC_CTX *mem_ctx,
764 int argc, char **argv)
765 {
766 POLICY_HND connect_pol, domain_pol;
767 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
768 uint32 start_idx=0, max_entries=250, num_entries, i;
769 int info_level = 1;
770 SAM_DISPINFO_CTR ctr;
771 SAM_DISPINFO_1 info1;
772 SAM_DISPINFO_2 info2;
773 SAM_DISPINFO_3 info3;
774 SAM_DISPINFO_4 info4;
775 SAM_DISPINFO_5 info5;
776
777 if (argc > 4) {
778 printf("Usage: %s [info level] [start index] [max entries]\n", argv[0]);
779 return NT_STATUS_OK;
780 }
781
782 if (argc >= 2)
783 sscanf(argv[1], "%i", &info_level);
784
785 if (argc >= 3)
786 sscanf(argv[2], "%i", &start_idx);
787
788 if (argc >= 4)
789 sscanf(argv[3], "%i", &max_entries);
790
791 /* Get sam policy handle */
792
793 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS, &connect_pol);
794 if (!NT_STATUS_IS_OK(result)) {
795 goto done;
796 }
797
798 /* Get domain policy handle */
799
800 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
801 MAXIMUM_ALLOWED_ACCESS,
802 &domain_sid, &domain_pol);
803 if (!NT_STATUS_IS_OK(result)) {
804 goto done;
805 }
806
807 /* Query display info */
808
809 ZERO_STRUCT(ctr);
810 ZERO_STRUCT(info1);
811
812 switch (info_level) {
813 case 1:
814 ZERO_STRUCT(info1);
815 ctr.sam.info1 = &info1;
816 break;
817 case 2:
818 ZERO_STRUCT(info2);
819 ctr.sam.info2 = &info2;
820 break;
821 case 3:
822 ZERO_STRUCT(info3);
823 ctr.sam.info3 = &info3;
824 break;
825 case 4:
826 ZERO_STRUCT(info4);
827 ctr.sam.info4 = &info4;
828 break;
829 case 5:
830 ZERO_STRUCT(info5);
831 ctr.sam.info5 = &info5;
832 break;
833 }
834
835
836 do {
837 result = cli_samr_query_dispinfo(cli, mem_ctx, &domain_pol,
838 &start_idx, info_level,
839 &num_entries, max_entries, &ctr);
840
841 for (i = 0; i < num_entries; i++) {
842 switch (info_level) {
843 case 1:
844 display_sam_info_1(&ctr.sam.info1->sam[i], &ctr.sam.info1->str[i]);
845 break;
846 case 2:
847 display_sam_info_2(&ctr.sam.info2->sam[i], &ctr.sam.info2->str[i]);
848 break;
849 case 3:
850 display_sam_info_3(&ctr.sam.info3->sam[i], &ctr.sam.info3->str[i]);
851 break;
852 case 4:
853 display_sam_info_4(&ctr.sam.info4->sam[i], &ctr.sam.info4->str[i]);
854 break;
855 case 5:
856 display_sam_info_5(&ctr.sam.info5->sam[i], &ctr.sam.info5->str[i]);
857 break;
858 }
859 }
860 } while (!NT_STATUS_IS_OK(result));
861 done:
862 return result;
863 }
864
865 /* Query domain info */
866
867 static NTSTATUS cmd_samr_query_dominfo(struct cli_state *cli,
868 TALLOC_CTX *mem_ctx,
869 int argc, char **argv)
870 {
871 POLICY_HND connect_pol, domain_pol;
872 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
873 int switch_value = 2;
874 SAM_UNK_CTR ctr;
875
876 if (argc > 2) {
877 printf("Usage: %s [infolevel]\n", argv[0]);
878 return NT_STATUS_OK;
879 }
880
881 if (argc == 2)
882 sscanf(argv[1], "%i", &switch_value);
883
884 /* Get sam policy handle */
885
886 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
887 &connect_pol);
888 if (!NT_STATUS_IS_OK(result)) {
889 goto done;
890 }
891
892 /* Get domain policy handle */
893
894 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
895 MAXIMUM_ALLOWED_ACCESS,
896 &domain_sid, &domain_pol);
897 if (!NT_STATUS_IS_OK(result)) {
898 goto done;
899 }
900
901 /* Query domain info */
902
903 result = cli_samr_query_dom_info(cli, mem_ctx, &domain_pol,
904 switch_value, &ctr);
905 if (!NT_STATUS_IS_OK(result)) {
906 goto done;
907 }
908
909 /* Display domain info */
910
911 switch (switch_value) {
912 case 1:
913 display_sam_unk_info_1(&ctr.info.inf1);
914 break;
915 case 2:
916 display_sam_unk_info_2(&ctr.info.inf2);
917 break;
918 default:
919 printf("cannot display domain info for switch value %d\n",
920 switch_value);
921 break;
922 }
923
924 done:
925
926 cli_samr_close(cli, mem_ctx, &domain_pol);
927 cli_samr_close(cli, mem_ctx, &connect_pol);
928 return result;
929 }
930
931 /* Create domain user */
932
933 static NTSTATUS cmd_samr_create_dom_user(struct cli_state *cli,
934 TALLOC_CTX *mem_ctx,
935 int argc, char **argv)
936 {
937 POLICY_HND connect_pol, domain_pol, user_pol;
938 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
939 char *acct_name;
940 uint16 acb_info;
941 uint32 unknown, user_rid;
942
943 if (argc != 2) {
944 printf("Usage: %s username\n", argv[0]);
945 return NT_STATUS_OK;
946 }
947
948 acct_name = argv[1];
949
950 /* Get sam policy handle */
951
952 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
953 &connect_pol);
954 if (!NT_STATUS_IS_OK(result)) {
955 goto done;
956 }
957
958 /* Get domain policy handle */
959
960 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
961 MAXIMUM_ALLOWED_ACCESS,
962 &domain_sid, &domain_pol);
963 if (!NT_STATUS_IS_OK(result)) {
964 goto done;
965 }
966
967 /* Create domain user */
968
969 acb_info = ACB_NORMAL;
970 unknown = 0xe005000b; /* No idea what this is - a permission mask? */
971
972 result = cli_samr_create_dom_user(cli, mem_ctx, &domain_pol,
973 acct_name, acb_info, unknown,
974 &user_pol, &user_rid);
975 if (!NT_STATUS_IS_OK(result)) {
976 goto done;
977 }
978
979 done:
980 return result;
981 }
982
983 /* Lookup sam names */
984
985 static NTSTATUS cmd_samr_lookup_names(struct cli_state *cli,
986 TALLOC_CTX *mem_ctx,
987 int argc, char **argv)
988 {
989 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
990 POLICY_HND connect_pol, domain_pol;
991 uint32 flags = 0x000003e8; /* Unknown */
992 uint32 num_rids, num_names, *name_types, *rids;
993 char **names;
994 int i;
995 DOM_SID global_sid_Builtin;
996
997 string_to_sid(&global_sid_Builtin, "S-1-5-32");
998
999 if (argc < 3) {
1000 printf("Usage: %s domain|builtin name1 [name2 [name3] [...]]\n", argv[0]);
1001 printf("check on the domain SID: S-1-5-21-x-y-z\n");
1002 printf("or check on the builtin SID: S-1-5-32\n");
1003 return NT_STATUS_OK;
1004 }
1005
1006 /* Get sam policy and domain handles */
1007
1008 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1009 &connect_pol);
1010
1011 if (!NT_STATUS_IS_OK(result)) {
1012 goto done;
1013 }
1014
1015 if (StrCaseCmp(argv[1], "domain")==0)
1016 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1017 MAXIMUM_ALLOWED_ACCESS,
1018 &domain_sid, &domain_pol);
1019 else if (StrCaseCmp(argv[1], "builtin")==0)
1020 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1021 MAXIMUM_ALLOWED_ACCESS,
1022 &global_sid_Builtin, &domain_pol);
1023 else
1024 return NT_STATUS_OK;
1025
1026 if (!NT_STATUS_IS_OK(result)) {
1027 goto done;
1028 }
1029
1030 /* Look up names */
1031
1032 num_names = argc - 2;
1033 names = (char **)talloc(mem_ctx, sizeof(char *) * num_names);
1034
1035 for (i = 0; i < argc - 2; i++)
1036 names[i] = argv[i + 2];
1037
1038 result = cli_samr_lookup_names(cli, mem_ctx, &domain_pol,
1039 flags, num_names, names,
1040 &num_rids, &rids, &name_types);
1041
1042 if (!NT_STATUS_IS_OK(result)) {
1043 goto done;
1044 }
1045
1046 /* Display results */
1047
1048 for (i = 0; i < num_names; i++)
1049 printf("name %s: 0x%x (%d)\n", names[i], rids[i],
1050 name_types[i]);
1051
1052 done:
1053 return result;
1054 }
1055
1056 /* Lookup sam rids */
1057
1058 static NTSTATUS cmd_samr_lookup_rids(struct cli_state *cli,
1059 TALLOC_CTX *mem_ctx,
1060 int argc, char **argv)
1061 {
1062 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1063 POLICY_HND connect_pol, domain_pol;
1064 uint32 flags = 0x000003e8; /* Unknown */
1065 uint32 num_rids, num_names, *rids, *name_types;
1066 char **names;
1067 int i;
1068
1069 if (argc < 2) {
1070 printf("Usage: %s rid1 [rid2 [rid3] [...]]\n", argv[0]);
1071 return NT_STATUS_OK;
1072 }
1073
1074 /* Get sam policy and domain handles */
1075
1076 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1077 &connect_pol);
1078
1079 if (!NT_STATUS_IS_OK(result)) {
1080 goto done;
1081 }
1082
1083 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1084 MAXIMUM_ALLOWED_ACCESS,
1085 &domain_sid, &domain_pol);
1086
1087 if (!NT_STATUS_IS_OK(result)) {
1088 goto done;
1089 }
1090
1091 /* Look up rids */
1092
1093 num_rids = argc - 1;
1094 rids = (uint32 *)talloc(mem_ctx, sizeof(uint32) * num_rids);
1095
1096 for (i = 0; i < argc - 1; i++)
1097 sscanf(argv[i + 1], "%i", &rids[i]);
1098
1099 result = cli_samr_lookup_rids(cli, mem_ctx, &domain_pol,
1100 flags, num_rids, rids,
1101 &num_names, &names, &name_types);
1102
1103 if (!NT_STATUS_IS_OK(result)) {
1104 goto done;
1105 }
1106
1107 /* Display results */
1108
1109 for (i = 0; i < num_names; i++)
1110 printf("rid 0x%x: %s (%d)\n", rids[i], names[i], name_types[i]);
1111
1112 done:
1113 return result;
1114 }
1115
1116 /* Delete domain user */
1117
1118 static NTSTATUS cmd_samr_delete_dom_user(struct cli_state *cli,
1119 TALLOC_CTX *mem_ctx,
1120 int argc, char **argv)
1121 {
1122 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1123 POLICY_HND connect_pol, domain_pol, user_pol;
1124
1125 if (argc != 2) {
1126 printf("Usage: %s username\n", argv[0]);
1127 return NT_STATUS_OK;
1128 }
1129
1130 /* Get sam policy and domain handles */
1131
1132 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1133 &connect_pol);
1134
1135 if (!NT_STATUS_IS_OK(result)) {
1136 goto done;
1137 }
1138
1139 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1140 MAXIMUM_ALLOWED_ACCESS,
1141 &domain_sid, &domain_pol);
1142
1143 if (!NT_STATUS_IS_OK(result)) {
1144 goto done;
1145 }
1146
1147 /* Get handle on user */
1148
1149 {
1150 uint32 *user_rids, num_rids, *name_types;
1151 uint32 flags = 0x000003e8; /* Unknown */
1152
1153 result = cli_samr_lookup_names(cli, mem_ctx, &domain_pol,
1154 flags, 1, &argv[1],
1155 &num_rids, &user_rids,
1156 &name_types);
1157
1158 if (!NT_STATUS_IS_OK(result)) {
1159 goto done;
1160 }
1161
1162 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
1163 MAXIMUM_ALLOWED_ACCESS,
1164 user_rids[0], &user_pol);
1165
1166 if (!NT_STATUS_IS_OK(result)) {
1167 goto done;
1168 }
1169 }
1170
1171 /* Delete user */
1172
1173 result = cli_samr_delete_dom_user(cli, mem_ctx, &user_pol);
1174
1175 if (!NT_STATUS_IS_OK(result)) {
1176 goto done;
1177 }
1178
1179 /* Display results */
1180
1181 done:
1182 return result;
1183 }
1184
1185 /**********************************************************************
1186 * Query user security object
1187 */
1188 static NTSTATUS cmd_samr_query_sec_obj(struct cli_state *cli,
1189 TALLOC_CTX *mem_ctx,
1190 int argc, char **argv)
1191 {
1192 POLICY_HND connect_pol, domain_pol, user_pol, *pol;
1193 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1194 uint32 info_level = 4;
1195 fstring server;
1196 uint32 user_rid = 0;
1197 TALLOC_CTX *ctx = NULL;
1198 SEC_DESC_BUF *sec_desc_buf=NULL;
1199 BOOL domain = False;
1200
1201 ctx=talloc_init();
1202
1203 if (argc > 2) {
1204 printf("Usage: %s [rid|-d]\n", argv[0]);
1205 printf("\tSpecify rid for security on user, -d for security on domain\n");
1206 return NT_STATUS_OK;
1207 }
1208
1209 if (argc == 2) {
1210 if (strcmp(argv[1], "-d") == 0)
1211 domain = True;
1212 else
1213 sscanf(argv[1], "%i", &user_rid);
1214 }
1215
1216 slprintf (server, sizeof(fstring)-1, "\\\\%s", cli->desthost);
1217 strupper (server);
1218 result = cli_samr_connect(cli, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1219 &connect_pol);
1220
1221 if (!NT_STATUS_IS_OK(result))
1222 goto done;
1223
1224 if (domain || user_rid)
1225 result = cli_samr_open_domain(cli, mem_ctx, &connect_pol,
1226 MAXIMUM_ALLOWED_ACCESS,
1227 &domain_sid, &domain_pol);
1228
1229 if (!NT_STATUS_IS_OK(result))
1230 goto done;
1231
1232 if (user_rid)
1233 result = cli_samr_open_user(cli, mem_ctx, &domain_pol,
1234 MAXIMUM_ALLOWED_ACCESS,
1235 user_rid, &user_pol);
1236
1237 if (!NT_STATUS_IS_OK(result))
1238 goto done;
1239
1240 /* Pick which query pol to use */
1241
1242 pol = &connect_pol;
1243
1244 if (domain)
1245 pol = &domain_pol;
1246
1247 if (user_rid)
1248 pol = &user_pol;
1249
1250 /* Query SAM security object */
1251
1252 result = cli_samr_query_sec_obj(cli, mem_ctx, pol, info_level, ctx,
1253 &sec_desc_buf);
1254
1255 if (!NT_STATUS_IS_OK(result))
1256 goto done;
1257
1258 display_sec_desc(sec_desc_buf->sec);
1259
1260 done:
1261 talloc_destroy(ctx);
1262 return result;
1263 }
1264
1265 /* List of commands exported by this module */
1266
1267 struct cmd_set samr_commands[] = {
1268
1269 { "SAMR" },
1270
1271 { "queryuser", cmd_samr_query_user, PIPE_SAMR, "Query user info", "" },
1272 { "querygroup", cmd_samr_query_group, PIPE_SAMR, "Query group info", "" },
1273 { "queryusergroups", cmd_samr_query_usergroups, PIPE_SAMR, "Query user groups", "" },
1274 { "queryuseraliases", cmd_samr_query_useraliases, PIPE_SAMR, "Query user aliases", "" },
1275 { "querygroupmem", cmd_samr_query_groupmem, PIPE_SAMR, "Query group membership", "" },
1276 { "queryaliasmem", cmd_samr_query_aliasmem, PIPE_SAMR, "Query alias membership", "" },
1277 { "querydispinfo", cmd_samr_query_dispinfo, PIPE_SAMR, "Query display info", "" },
1278 { "querydominfo", cmd_samr_query_dominfo, PIPE_SAMR, "Query domain info", "" },
1279 { "enumdomgroups", cmd_samr_enum_dom_groups, PIPE_SAMR, "Enumerate domain groups", "" },
1280 { "enumalsgroups", cmd_samr_enum_als_groups, PIPE_SAMR, "Enumerate alias groups", "" },
1281
1282 { "createdomuser", cmd_samr_create_dom_user, PIPE_SAMR, "Create domain user", "" },
1283 { "samlookupnames", cmd_samr_lookup_names, PIPE_SAMR, "Look up names", "" },
1284 { "samlookuprids", cmd_samr_lookup_rids, PIPE_SAMR, "Look up names", "" },
1285 { "deletedomuser", cmd_samr_delete_dom_user, PIPE_SAMR, "Delete domain user", "" },
1286 { "samquerysecobj", cmd_samr_query_sec_obj, PIPE_SAMR, "Query SAMR security object", "" },
1287
1288 { NULL }
1289 };
Samba GIT mirror