2 Unix SMB/CIFS implementation.
5 Copyright (C) Tim Potter 2000
6 Copyright (C) Rafal Szczesniak 2002
7 Copyright (C) Guenther Deschner 2008
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "rpcclient.h"
25 #include "../libcli/auth/libcli_auth.h"
27 /* useful function to allow entering a name instead of a SID and
28 * looking it up automatically */
29 static NTSTATUS
name_to_sid(struct rpc_pipe_client
*cli
,
31 DOM_SID
*sid
, const char *name
)
33 struct policy_handle pol
;
34 enum lsa_SidType
*sid_types
;
38 /* maybe its a raw SID */
39 if (strncmp(name
, "S-", 2) == 0 &&
40 string_to_sid(sid
, name
)) {
44 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
45 SEC_FLAG_MAXIMUM_ALLOWED
,
47 if (!NT_STATUS_IS_OK(result
))
50 result
= rpccli_lsa_lookup_names(cli
, mem_ctx
, &pol
, 1, &name
, NULL
, 1, &sids
, &sid_types
);
51 if (!NT_STATUS_IS_OK(result
))
54 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
62 static void display_query_info_1(struct lsa_AuditLogInfo
*r
)
64 d_printf("percent_full:\t%d\n", r
->percent_full
);
65 d_printf("maximum_log_size:\t%d\n", r
->maximum_log_size
);
66 d_printf("retention_time:\t%lld\n", (long long)r
->retention_time
);
67 d_printf("shutdown_in_progress:\t%d\n", r
->shutdown_in_progress
);
68 d_printf("time_to_shutdown:\t%lld\n", (long long)r
->time_to_shutdown
);
69 d_printf("next_audit_record:\t%d\n", r
->next_audit_record
);
72 static void display_query_info_2(struct lsa_AuditEventsInfo
*r
)
75 d_printf("Auditing enabled:\t%d\n", r
->auditing_mode
);
76 d_printf("Auditing categories:\t%d\n", r
->count
);
77 d_printf("Auditsettings:\n");
78 for (i
=0; i
<r
->count
; i
++) {
79 const char *val
= audit_policy_str(talloc_tos(), r
->settings
[i
]);
80 const char *policy
= audit_description_str(i
);
81 d_printf("%s:\t%s\n", policy
, val
);
85 static void display_query_info_3(struct lsa_DomainInfo
*r
)
87 d_printf("Domain Name: %s\n", r
->name
.string
);
88 d_printf("Domain Sid: %s\n", sid_string_tos(r
->sid
));
91 static void display_query_info_5(struct lsa_DomainInfo
*r
)
93 d_printf("Domain Name: %s\n", r
->name
.string
);
94 d_printf("Domain Sid: %s\n", sid_string_tos(r
->sid
));
97 static void display_query_info_10(struct lsa_AuditFullSetInfo
*r
)
99 d_printf("Shutdown on full: %d\n", r
->shutdown_on_full
);
102 static void display_query_info_11(struct lsa_AuditFullQueryInfo
*r
)
104 d_printf("Shutdown on full: %d\n", r
->shutdown_on_full
);
105 d_printf("Log is full: %d\n", r
->log_is_full
);
108 static void display_query_info_12(struct lsa_DnsDomainInfo
*r
)
110 d_printf("Domain NetBios Name: %s\n", r
->name
.string
);
111 d_printf("Domain DNS Name: %s\n", r
->dns_domain
.string
);
112 d_printf("Domain Forest Name: %s\n", r
->dns_forest
.string
);
113 d_printf("Domain Sid: %s\n", sid_string_tos(r
->sid
));
114 d_printf("Domain GUID: %s\n", GUID_string(talloc_tos(),
118 static void display_lsa_query_info(union lsa_PolicyInformation
*info
,
119 enum lsa_PolicyInfo level
)
123 display_query_info_1(&info
->audit_log
);
126 display_query_info_2(&info
->audit_events
);
129 display_query_info_3(&info
->domain
);
132 display_query_info_5(&info
->account_domain
);
135 display_query_info_10(&info
->auditfullset
);
138 display_query_info_11(&info
->auditfullquery
);
141 display_query_info_12(&info
->dns
);
144 printf("can't display info level: %d\n", level
);
149 static NTSTATUS
cmd_lsa_query_info_policy(struct rpc_pipe_client
*cli
,
150 TALLOC_CTX
*mem_ctx
, int argc
,
153 struct policy_handle pol
;
154 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
155 union lsa_PolicyInformation
*info
= NULL
;
157 uint32 info_class
= 3;
160 printf("Usage: %s [info_class]\n", argv
[0]);
165 info_class
= atoi(argv
[1]);
167 switch (info_class
) {
169 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
170 SEC_FLAG_MAXIMUM_ALLOWED
,
173 if (!NT_STATUS_IS_OK(result
))
176 result
= rpccli_lsa_QueryInfoPolicy2(cli
, mem_ctx
,
182 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
183 SEC_FLAG_MAXIMUM_ALLOWED
,
186 if (!NT_STATUS_IS_OK(result
))
189 result
= rpccli_lsa_QueryInfoPolicy(cli
, mem_ctx
,
195 if (NT_STATUS_IS_OK(result
)) {
196 display_lsa_query_info(info
, info_class
);
199 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
205 /* Resolve a list of names to a list of sids */
207 static NTSTATUS
cmd_lsa_lookup_names(struct rpc_pipe_client
*cli
,
208 TALLOC_CTX
*mem_ctx
, int argc
,
211 struct policy_handle pol
;
212 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
214 enum lsa_SidType
*types
;
218 printf("Usage: %s [name1 [name2 [...]]]\n", argv
[0]);
222 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
223 SEC_FLAG_MAXIMUM_ALLOWED
,
226 if (!NT_STATUS_IS_OK(result
))
229 result
= rpccli_lsa_lookup_names(cli
, mem_ctx
, &pol
, argc
- 1,
230 (const char**)(argv
+ 1), NULL
, 1, &sids
, &types
);
232 if (!NT_STATUS_IS_OK(result
) && NT_STATUS_V(result
) !=
233 NT_STATUS_V(STATUS_SOME_UNMAPPED
))
236 result
= NT_STATUS_OK
;
240 for (i
= 0; i
< (argc
- 1); i
++) {
242 sid_to_fstring(sid_str
, &sids
[i
]);
243 printf("%s %s (%s: %d)\n", argv
[i
+ 1], sid_str
,
244 sid_type_lookup(types
[i
]), types
[i
]);
247 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
253 /* Resolve a list of names to a list of sids */
255 static NTSTATUS
cmd_lsa_lookup_names_level(struct rpc_pipe_client
*cli
,
256 TALLOC_CTX
*mem_ctx
, int argc
,
259 struct policy_handle pol
;
260 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
262 enum lsa_SidType
*types
;
266 printf("Usage: %s [level] [name1 [name2 [...]]]\n", argv
[0]);
270 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
271 SEC_FLAG_MAXIMUM_ALLOWED
,
274 if (!NT_STATUS_IS_OK(result
))
277 level
= atoi(argv
[1]);
279 result
= rpccli_lsa_lookup_names(cli
, mem_ctx
, &pol
, argc
- 2,
280 (const char**)(argv
+ 2), NULL
, level
, &sids
, &types
);
282 if (!NT_STATUS_IS_OK(result
) && NT_STATUS_V(result
) !=
283 NT_STATUS_V(STATUS_SOME_UNMAPPED
))
286 result
= NT_STATUS_OK
;
290 for (i
= 0; i
< (argc
- 2); i
++) {
292 sid_to_fstring(sid_str
, &sids
[i
]);
293 printf("%s %s (%s: %d)\n", argv
[i
+ 2], sid_str
,
294 sid_type_lookup(types
[i
]), types
[i
]);
297 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
304 /* Resolve a list of SIDs to a list of names */
306 static NTSTATUS
cmd_lsa_lookup_sids(struct rpc_pipe_client
*cli
, TALLOC_CTX
*mem_ctx
,
307 int argc
, const char **argv
)
309 struct policy_handle pol
;
310 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
314 enum lsa_SidType
*types
;
318 printf("Usage: %s [sid1 [sid2 [...]]]\n", argv
[0]);
322 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
323 SEC_FLAG_MAXIMUM_ALLOWED
,
326 if (!NT_STATUS_IS_OK(result
))
329 /* Convert arguments to sids */
331 sids
= TALLOC_ARRAY(mem_ctx
, DOM_SID
, argc
- 1);
334 printf("could not allocate memory for %d sids\n", argc
- 1);
338 for (i
= 0; i
< argc
- 1; i
++)
339 if (!string_to_sid(&sids
[i
], argv
[i
+ 1])) {
340 result
= NT_STATUS_INVALID_SID
;
344 /* Lookup the SIDs */
346 result
= rpccli_lsa_lookup_sids(cli
, mem_ctx
, &pol
, argc
- 1, sids
,
347 &domains
, &names
, &types
);
349 if (!NT_STATUS_IS_OK(result
) && NT_STATUS_V(result
) !=
350 NT_STATUS_V(STATUS_SOME_UNMAPPED
))
353 result
= NT_STATUS_OK
;
357 for (i
= 0; i
< (argc
- 1); i
++) {
360 sid_to_fstring(sid_str
, &sids
[i
]);
361 printf("%s %s\\%s (%d)\n", sid_str
,
362 domains
[i
] ? domains
[i
] : "*unknown*",
363 names
[i
] ? names
[i
] : "*unknown*", types
[i
]);
366 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
372 /* Enumerate list of trusted domains */
374 static NTSTATUS
cmd_lsa_enum_trust_dom(struct rpc_pipe_client
*cli
,
375 TALLOC_CTX
*mem_ctx
, int argc
,
378 struct policy_handle pol
;
379 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
380 struct lsa_DomainList domain_list
;
382 /* defaults, but may be changed using params */
385 uint32_t max_size
= (uint32_t)-1;
388 printf("Usage: %s [enum context (0)]\n", argv
[0]);
392 if (argc
== 2 && argv
[1]) {
393 enum_ctx
= atoi(argv
[2]);
396 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
397 LSA_POLICY_VIEW_LOCAL_INFORMATION
,
400 if (!NT_STATUS_IS_OK(result
))
403 result
= STATUS_MORE_ENTRIES
;
405 while (NT_STATUS_EQUAL(result
, STATUS_MORE_ENTRIES
)) {
407 /* Lookup list of trusted domains */
409 result
= rpccli_lsa_EnumTrustDom(cli
, mem_ctx
,
414 if (!NT_STATUS_IS_OK(result
) &&
415 !NT_STATUS_EQUAL(result
, NT_STATUS_NO_MORE_ENTRIES
) &&
416 !NT_STATUS_EQUAL(result
, STATUS_MORE_ENTRIES
))
419 /* Print results: list of names and sids returned in this
421 for (i
= 0; i
< domain_list
.count
; i
++) {
424 sid_to_fstring(sid_str
, domain_list
.domains
[i
].sid
);
426 domain_list
.domains
[i
].name
.string
?
427 domain_list
.domains
[i
].name
.string
: "*unknown*",
432 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
437 /* Enumerates privileges */
439 static NTSTATUS
cmd_lsa_enum_privilege(struct rpc_pipe_client
*cli
,
440 TALLOC_CTX
*mem_ctx
, int argc
,
443 struct policy_handle pol
;
444 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
445 struct lsa_PrivArray priv_array
;
447 uint32 enum_context
=0;
448 uint32 pref_max_length
=0x1000;
452 printf("Usage: %s [enum context] [max length]\n", argv
[0]);
457 enum_context
=atoi(argv
[1]);
460 pref_max_length
=atoi(argv
[2]);
462 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
463 SEC_FLAG_MAXIMUM_ALLOWED
,
466 if (!NT_STATUS_IS_OK(result
))
469 result
= rpccli_lsa_EnumPrivs(cli
, mem_ctx
,
474 if (!NT_STATUS_IS_OK(result
))
478 printf("found %d privileges\n\n", priv_array
.count
);
480 for (i
= 0; i
< priv_array
.count
; i
++) {
481 printf("%s \t\t%d:%d (0x%x:0x%x)\n",
482 priv_array
.privs
[i
].name
.string
? priv_array
.privs
[i
].name
.string
: "*unknown*",
483 priv_array
.privs
[i
].luid
.high
,
484 priv_array
.privs
[i
].luid
.low
,
485 priv_array
.privs
[i
].luid
.high
,
486 priv_array
.privs
[i
].luid
.low
);
489 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
494 /* Get privilege name */
496 static NTSTATUS
cmd_lsa_get_dispname(struct rpc_pipe_client
*cli
,
497 TALLOC_CTX
*mem_ctx
, int argc
,
500 struct policy_handle pol
;
501 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
504 uint16 lang_id_sys
=0;
506 struct lsa_String lsa_name
;
507 struct lsa_StringLarge
*description
= NULL
;
510 printf("Usage: %s privilege name\n", argv
[0]);
514 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
515 SEC_FLAG_MAXIMUM_ALLOWED
,
518 if (!NT_STATUS_IS_OK(result
))
521 init_lsa_String(&lsa_name
, argv
[1]);
523 result
= rpccli_lsa_LookupPrivDisplayName(cli
, mem_ctx
,
531 if (!NT_STATUS_IS_OK(result
))
535 printf("%s -> %s (language: 0x%x)\n", argv
[1], description
->string
, lang_id_desc
);
537 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
542 /* Enumerate the LSA SIDS */
544 static NTSTATUS
cmd_lsa_enum_sids(struct rpc_pipe_client
*cli
,
545 TALLOC_CTX
*mem_ctx
, int argc
,
548 struct policy_handle pol
;
549 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
551 uint32 enum_context
=0;
552 uint32 pref_max_length
=0x1000;
553 struct lsa_SidArray sid_array
;
557 printf("Usage: %s [enum context] [max length]\n", argv
[0]);
562 enum_context
=atoi(argv
[1]);
565 pref_max_length
=atoi(argv
[2]);
567 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, True
,
568 SEC_FLAG_MAXIMUM_ALLOWED
,
571 if (!NT_STATUS_IS_OK(result
))
574 result
= rpccli_lsa_EnumAccounts(cli
, mem_ctx
,
580 if (!NT_STATUS_IS_OK(result
))
584 printf("found %d SIDs\n\n", sid_array
.num_sids
);
586 for (i
= 0; i
< sid_array
.num_sids
; i
++) {
589 sid_to_fstring(sid_str
, sid_array
.sids
[i
].sid
);
590 printf("%s\n", sid_str
);
593 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
598 /* Create a new account */
600 static NTSTATUS
cmd_lsa_create_account(struct rpc_pipe_client
*cli
,
601 TALLOC_CTX
*mem_ctx
, int argc
,
604 struct policy_handle dom_pol
;
605 struct policy_handle user_pol
;
606 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
607 uint32 des_access
= 0x000f000f;
612 printf("Usage: %s SID\n", argv
[0]);
616 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
617 if (!NT_STATUS_IS_OK(result
))
620 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
621 SEC_FLAG_MAXIMUM_ALLOWED
,
624 if (!NT_STATUS_IS_OK(result
))
627 result
= rpccli_lsa_CreateAccount(cli
, mem_ctx
,
633 if (!NT_STATUS_IS_OK(result
))
636 printf("Account for SID %s successfully created\n\n", argv
[1]);
637 result
= NT_STATUS_OK
;
639 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
645 /* Enumerate the privileges of an SID */
647 static NTSTATUS
cmd_lsa_enum_privsaccounts(struct rpc_pipe_client
*cli
,
648 TALLOC_CTX
*mem_ctx
, int argc
,
651 struct policy_handle dom_pol
;
652 struct policy_handle user_pol
;
653 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
654 uint32 access_desired
= 0x000f000f;
656 struct lsa_PrivilegeSet
*privs
= NULL
;
660 printf("Usage: %s SID\n", argv
[0]);
664 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
665 if (!NT_STATUS_IS_OK(result
))
668 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
669 SEC_FLAG_MAXIMUM_ALLOWED
,
672 if (!NT_STATUS_IS_OK(result
))
675 result
= rpccli_lsa_OpenAccount(cli
, mem_ctx
,
681 if (!NT_STATUS_IS_OK(result
))
684 result
= rpccli_lsa_EnumPrivsAccount(cli
, mem_ctx
,
688 if (!NT_STATUS_IS_OK(result
))
692 printf("found %d privileges for SID %s\n\n", privs
->count
, argv
[1]);
693 printf("high\tlow\tattribute\n");
695 for (i
= 0; i
< privs
->count
; i
++) {
696 printf("%u\t%u\t%u\n",
697 privs
->set
[i
].luid
.high
,
698 privs
->set
[i
].luid
.low
,
699 privs
->set
[i
].attribute
);
702 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
708 /* Enumerate the privileges of an SID via LsaEnumerateAccountRights */
710 static NTSTATUS
cmd_lsa_enum_acct_rights(struct rpc_pipe_client
*cli
,
711 TALLOC_CTX
*mem_ctx
, int argc
,
714 struct policy_handle dom_pol
;
715 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
717 struct lsa_RightSet rights
;
722 printf("Usage: %s SID\n", argv
[0]);
726 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
727 if (!NT_STATUS_IS_OK(result
))
730 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
731 SEC_FLAG_MAXIMUM_ALLOWED
,
734 if (!NT_STATUS_IS_OK(result
))
737 result
= rpccli_lsa_EnumAccountRights(cli
, mem_ctx
,
742 if (!NT_STATUS_IS_OK(result
))
745 printf("found %d privileges for SID %s\n", rights
.count
,
746 sid_string_tos(&sid
));
748 for (i
= 0; i
< rights
.count
; i
++) {
749 printf("\t%s\n", rights
.names
[i
].string
);
752 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
758 /* add some privileges to a SID via LsaAddAccountRights */
760 static NTSTATUS
cmd_lsa_add_acct_rights(struct rpc_pipe_client
*cli
,
761 TALLOC_CTX
*mem_ctx
, int argc
,
764 struct policy_handle dom_pol
;
765 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
766 struct lsa_RightSet rights
;
771 printf("Usage: %s SID [rights...]\n", argv
[0]);
775 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
776 if (!NT_STATUS_IS_OK(result
))
779 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
780 SEC_FLAG_MAXIMUM_ALLOWED
,
783 if (!NT_STATUS_IS_OK(result
))
786 rights
.count
= argc
-2;
787 rights
.names
= TALLOC_ARRAY(mem_ctx
, struct lsa_StringLarge
,
790 return NT_STATUS_NO_MEMORY
;
793 for (i
=0; i
<argc
-2; i
++) {
794 init_lsa_StringLarge(&rights
.names
[i
], argv
[i
+2]);
797 result
= rpccli_lsa_AddAccountRights(cli
, mem_ctx
,
802 if (!NT_STATUS_IS_OK(result
))
805 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
811 /* remove some privileges to a SID via LsaRemoveAccountRights */
813 static NTSTATUS
cmd_lsa_remove_acct_rights(struct rpc_pipe_client
*cli
,
814 TALLOC_CTX
*mem_ctx
, int argc
,
817 struct policy_handle dom_pol
;
818 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
819 struct lsa_RightSet rights
;
824 printf("Usage: %s SID [rights...]\n", argv
[0]);
828 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
829 if (!NT_STATUS_IS_OK(result
))
832 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
833 SEC_FLAG_MAXIMUM_ALLOWED
,
836 if (!NT_STATUS_IS_OK(result
))
839 rights
.count
= argc
-2;
840 rights
.names
= TALLOC_ARRAY(mem_ctx
, struct lsa_StringLarge
,
843 return NT_STATUS_NO_MEMORY
;
846 for (i
=0; i
<argc
-2; i
++) {
847 init_lsa_StringLarge(&rights
.names
[i
], argv
[i
+2]);
850 result
= rpccli_lsa_RemoveAccountRights(cli
, mem_ctx
,
856 if (!NT_STATUS_IS_OK(result
))
859 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
866 /* Get a privilege value given its name */
868 static NTSTATUS
cmd_lsa_lookup_priv_value(struct rpc_pipe_client
*cli
,
869 TALLOC_CTX
*mem_ctx
, int argc
,
872 struct policy_handle pol
;
873 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
874 struct lsa_LUID luid
;
875 struct lsa_String name
;
878 printf("Usage: %s name\n", argv
[0]);
882 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
883 SEC_FLAG_MAXIMUM_ALLOWED
,
886 if (!NT_STATUS_IS_OK(result
))
889 init_lsa_String(&name
, argv
[1]);
891 result
= rpccli_lsa_LookupPrivValue(cli
, mem_ctx
,
896 if (!NT_STATUS_IS_OK(result
))
901 printf("%u:%u (0x%x:0x%x)\n", luid
.high
, luid
.low
, luid
.high
, luid
.low
);
903 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
908 /* Query LSA security object */
910 static NTSTATUS
cmd_lsa_query_secobj(struct rpc_pipe_client
*cli
,
911 TALLOC_CTX
*mem_ctx
, int argc
,
914 struct policy_handle pol
;
915 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
917 uint32 sec_info
= DACL_SECURITY_INFORMATION
;
919 if (argc
< 1 || argc
> 2) {
920 printf("Usage: %s [sec_info]\n", argv
[0]);
924 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
925 SEC_FLAG_MAXIMUM_ALLOWED
,
929 sscanf(argv
[1], "%x", &sec_info
);
931 if (!NT_STATUS_IS_OK(result
))
934 result
= rpccli_lsa_QuerySecurity(cli
, mem_ctx
,
938 if (!NT_STATUS_IS_OK(result
))
943 display_sec_desc(sdb
->sd
);
945 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
950 static void display_trust_dom_info_4(struct lsa_TrustDomainInfoPassword
*p
,
951 uint8_t session_key
[16])
955 DATA_BLOB data
= data_blob_const(p
->password
->data
, p
->password
->length
);
956 DATA_BLOB data_old
= data_blob_const(p
->old_password
->data
, p
->old_password
->length
);
957 DATA_BLOB session_key_blob
= data_blob_const(session_key
, sizeof(session_key
));
959 pwd
= sess_decrypt_string(talloc_tos(), &data
, &session_key_blob
);
960 pwd_old
= sess_decrypt_string(talloc_tos(), &data_old
, &session_key_blob
);
962 d_printf("Password:\t%s\n", pwd
);
963 d_printf("Old Password:\t%s\n", pwd_old
);
966 talloc_free(pwd_old
);
969 static void display_trust_dom_info(TALLOC_CTX
*mem_ctx
,
970 union lsa_TrustedDomainInfo
*info
,
971 enum lsa_TrustDomInfoEnum info_class
,
974 switch (info_class
) {
975 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD
:
976 display_trust_dom_info_4(&info
->password
, nt_hash
);
979 const char *str
= NULL
;
980 str
= NDR_PRINT_UNION_STRING(mem_ctx
,
981 lsa_TrustedDomainInfo
,
984 d_printf("%s\n", str
);
991 static NTSTATUS
cmd_lsa_query_trustdominfobysid(struct rpc_pipe_client
*cli
,
992 TALLOC_CTX
*mem_ctx
, int argc
,
995 struct policy_handle pol
;
996 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
998 uint32 access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
999 union lsa_TrustedDomainInfo
*info
= NULL
;
1000 enum lsa_TrustDomInfoEnum info_class
= 1;
1001 uint8_t nt_hash
[16];
1003 if (argc
> 3 || argc
< 2) {
1004 printf("Usage: %s [sid] [info_class]\n", argv
[0]);
1005 return NT_STATUS_OK
;
1008 if (!string_to_sid(&dom_sid
, argv
[1]))
1009 return NT_STATUS_NO_MEMORY
;
1012 info_class
= atoi(argv
[2]);
1014 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
, access_mask
, &pol
);
1016 if (!NT_STATUS_IS_OK(result
))
1019 result
= rpccli_lsa_QueryTrustedDomainInfoBySid(cli
, mem_ctx
,
1024 if (!NT_STATUS_IS_OK(result
))
1027 if (!rpccli_get_pwd_hash(cli
, nt_hash
)) {
1028 d_fprintf(stderr
, "Could not get pwd hash\n");
1032 display_trust_dom_info(mem_ctx
, info
, info_class
, nt_hash
);
1035 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
1040 static NTSTATUS
cmd_lsa_query_trustdominfobyname(struct rpc_pipe_client
*cli
,
1041 TALLOC_CTX
*mem_ctx
, int argc
,
1044 struct policy_handle pol
;
1045 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
1046 uint32 access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
1047 union lsa_TrustedDomainInfo
*info
= NULL
;
1048 enum lsa_TrustDomInfoEnum info_class
= 1;
1049 struct lsa_String trusted_domain
;
1050 uint8_t nt_hash
[16];
1052 if (argc
> 3 || argc
< 2) {
1053 printf("Usage: %s [name] [info_class]\n", argv
[0]);
1054 return NT_STATUS_OK
;
1058 info_class
= atoi(argv
[2]);
1060 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
, access_mask
, &pol
);
1062 if (!NT_STATUS_IS_OK(result
))
1065 init_lsa_String(&trusted_domain
, argv
[1]);
1067 result
= rpccli_lsa_QueryTrustedDomainInfoByName(cli
, mem_ctx
,
1072 if (!NT_STATUS_IS_OK(result
))
1075 if (!rpccli_get_pwd_hash(cli
, nt_hash
)) {
1076 d_fprintf(stderr
, "Could not get pwd hash\n");
1080 display_trust_dom_info(mem_ctx
, info
, info_class
, nt_hash
);
1083 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
1088 static NTSTATUS
cmd_lsa_query_trustdominfo(struct rpc_pipe_client
*cli
,
1089 TALLOC_CTX
*mem_ctx
, int argc
,
1092 struct policy_handle pol
, trustdom_pol
;
1093 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
1094 uint32 access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
1095 union lsa_TrustedDomainInfo
*info
= NULL
;
1097 enum lsa_TrustDomInfoEnum info_class
= 1;
1098 uint8_t nt_hash
[16];
1100 if (argc
> 3 || argc
< 2) {
1101 printf("Usage: %s [sid] [info_class]\n", argv
[0]);
1102 return NT_STATUS_OK
;
1105 if (!string_to_sid(&dom_sid
, argv
[1]))
1106 return NT_STATUS_NO_MEMORY
;
1110 info_class
= atoi(argv
[2]);
1112 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
, access_mask
, &pol
);
1114 if (!NT_STATUS_IS_OK(result
))
1117 result
= rpccli_lsa_OpenTrustedDomain(cli
, mem_ctx
,
1123 if (!NT_STATUS_IS_OK(result
))
1126 result
= rpccli_lsa_QueryTrustedDomainInfo(cli
, mem_ctx
,
1131 if (!NT_STATUS_IS_OK(result
))
1134 if (!rpccli_get_pwd_hash(cli
, nt_hash
)) {
1135 d_fprintf(stderr
, "Could not get pwd hash\n");
1139 display_trust_dom_info(mem_ctx
, info
, info_class
, nt_hash
);
1142 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
1147 static NTSTATUS
cmd_lsa_get_username(struct rpc_pipe_client
*cli
,
1148 TALLOC_CTX
*mem_ctx
, int argc
,
1151 struct policy_handle pol
;
1152 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
1153 const char *servername
= cli
->desthost
;
1154 struct lsa_String
*account_name
= NULL
;
1155 struct lsa_String
*authority_name
= NULL
;
1158 printf("Usage: %s servername\n", argv
[0]);
1159 return NT_STATUS_OK
;
1162 result
= rpccli_lsa_open_policy(cli
, mem_ctx
, true,
1163 SEC_FLAG_MAXIMUM_ALLOWED
,
1166 if (!NT_STATUS_IS_OK(result
)) {
1170 result
= rpccli_lsa_GetUserName(cli
, mem_ctx
,
1174 if (!NT_STATUS_IS_OK(result
)) {
1180 printf("Account Name: %s, Authority Name: %s\n",
1181 account_name
->string
, authority_name
? authority_name
->string
:
1184 rpccli_lsa_Close(cli
, mem_ctx
, &pol
);
1189 static NTSTATUS
cmd_lsa_add_priv(struct rpc_pipe_client
*cli
,
1190 TALLOC_CTX
*mem_ctx
, int argc
,
1193 struct policy_handle dom_pol
, user_pol
;
1194 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
1195 struct lsa_PrivilegeSet privs
;
1196 struct lsa_LUIDAttribute
*set
= NULL
;
1203 printf("Usage: %s SID [rights...]\n", argv
[0]);
1204 return NT_STATUS_OK
;
1207 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
1208 if (!NT_STATUS_IS_OK(result
)) {
1212 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
1213 SEC_FLAG_MAXIMUM_ALLOWED
,
1216 if (!NT_STATUS_IS_OK(result
)) {
1220 result
= rpccli_lsa_OpenAccount(cli
, mem_ctx
,
1223 SEC_FLAG_MAXIMUM_ALLOWED
,
1226 if (!NT_STATUS_IS_OK(result
)) {
1230 for (i
=2; i
<argc
; i
++) {
1232 struct lsa_String priv_name
;
1233 struct lsa_LUID luid
;
1235 init_lsa_String(&priv_name
, argv
[i
]);
1237 result
= rpccli_lsa_LookupPrivValue(cli
, mem_ctx
,
1241 if (!NT_STATUS_IS_OK(result
)) {
1246 set
= TALLOC_REALLOC_ARRAY(mem_ctx
, set
,
1247 struct lsa_LUIDAttribute
,
1250 return NT_STATUS_NO_MEMORY
;
1253 set
[privs
.count
-1].luid
= luid
;
1254 set
[privs
.count
-1].attribute
= 0;
1259 result
= rpccli_lsa_AddPrivilegesToAccount(cli
, mem_ctx
,
1263 if (!NT_STATUS_IS_OK(result
)) {
1267 rpccli_lsa_Close(cli
, mem_ctx
, &user_pol
);
1268 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
1273 static NTSTATUS
cmd_lsa_del_priv(struct rpc_pipe_client
*cli
,
1274 TALLOC_CTX
*mem_ctx
, int argc
,
1277 struct policy_handle dom_pol
, user_pol
;
1278 NTSTATUS result
= NT_STATUS_UNSUCCESSFUL
;
1279 struct lsa_PrivilegeSet privs
;
1280 struct lsa_LUIDAttribute
*set
= NULL
;
1287 printf("Usage: %s SID [rights...]\n", argv
[0]);
1288 return NT_STATUS_OK
;
1291 result
= name_to_sid(cli
, mem_ctx
, &sid
, argv
[1]);
1292 if (!NT_STATUS_IS_OK(result
)) {
1296 result
= rpccli_lsa_open_policy2(cli
, mem_ctx
, True
,
1297 SEC_FLAG_MAXIMUM_ALLOWED
,
1300 if (!NT_STATUS_IS_OK(result
)) {
1304 result
= rpccli_lsa_OpenAccount(cli
, mem_ctx
,
1307 SEC_FLAG_MAXIMUM_ALLOWED
,
1310 if (!NT_STATUS_IS_OK(result
)) {
1314 for (i
=2; i
<argc
; i
++) {
1316 struct lsa_String priv_name
;
1317 struct lsa_LUID luid
;
1319 init_lsa_String(&priv_name
, argv
[i
]);
1321 result
= rpccli_lsa_LookupPrivValue(cli
, mem_ctx
,
1325 if (!NT_STATUS_IS_OK(result
)) {
1330 set
= TALLOC_REALLOC_ARRAY(mem_ctx
, set
,
1331 struct lsa_LUIDAttribute
,
1334 return NT_STATUS_NO_MEMORY
;
1337 set
[privs
.count
-1].luid
= luid
;
1338 set
[privs
.count
-1].attribute
= 0;
1344 result
= rpccli_lsa_RemovePrivilegesFromAccount(cli
, mem_ctx
,
1349 if (!NT_STATUS_IS_OK(result
)) {
1353 rpccli_lsa_Close(cli
, mem_ctx
, &user_pol
);
1354 rpccli_lsa_Close(cli
, mem_ctx
, &dom_pol
);
1359 static NTSTATUS
cmd_lsa_create_secret(struct rpc_pipe_client
*cli
,
1360 TALLOC_CTX
*mem_ctx
, int argc
,
1364 struct policy_handle handle
, sec_handle
;
1365 struct lsa_String name
;
1368 printf("Usage: %s name\n", argv
[0]);
1369 return NT_STATUS_OK
;
1372 status
= rpccli_lsa_open_policy2(cli
, mem_ctx
,
1374 SEC_FLAG_MAXIMUM_ALLOWED
,
1376 if (!NT_STATUS_IS_OK(status
)) {
1380 init_lsa_String(&name
, argv
[1]);
1382 status
= rpccli_lsa_CreateSecret(cli
, mem_ctx
,
1385 SEC_FLAG_MAXIMUM_ALLOWED
,
1387 if (!NT_STATUS_IS_OK(status
)) {
1392 if (is_valid_policy_hnd(&sec_handle
)) {
1393 rpccli_lsa_Close(cli
, mem_ctx
, &sec_handle
);
1395 if (is_valid_policy_hnd(&handle
)) {
1396 rpccli_lsa_Close(cli
, mem_ctx
, &handle
);
1402 static NTSTATUS
cmd_lsa_delete_secret(struct rpc_pipe_client
*cli
,
1403 TALLOC_CTX
*mem_ctx
, int argc
,
1407 struct policy_handle handle
, sec_handle
;
1408 struct lsa_String name
;
1411 printf("Usage: %s name\n", argv
[0]);
1412 return NT_STATUS_OK
;
1415 status
= rpccli_lsa_open_policy2(cli
, mem_ctx
,
1417 SEC_FLAG_MAXIMUM_ALLOWED
,
1419 if (!NT_STATUS_IS_OK(status
)) {
1423 init_lsa_String(&name
, argv
[1]);
1425 status
= rpccli_lsa_OpenSecret(cli
, mem_ctx
,
1428 SEC_FLAG_MAXIMUM_ALLOWED
,
1430 if (!NT_STATUS_IS_OK(status
)) {
1434 status
= rpccli_lsa_DeleteObject(cli
, mem_ctx
,
1436 if (!NT_STATUS_IS_OK(status
)) {
1441 if (is_valid_policy_hnd(&sec_handle
)) {
1442 rpccli_lsa_Close(cli
, mem_ctx
, &sec_handle
);
1444 if (is_valid_policy_hnd(&handle
)) {
1445 rpccli_lsa_Close(cli
, mem_ctx
, &handle
);
1451 static NTSTATUS
cmd_lsa_query_secret(struct rpc_pipe_client
*cli
,
1452 TALLOC_CTX
*mem_ctx
, int argc
,
1456 struct policy_handle handle
, sec_handle
;
1457 struct lsa_String name
;
1458 struct lsa_DATA_BUF_PTR new_val
;
1459 NTTIME new_mtime
= 0;
1460 struct lsa_DATA_BUF_PTR old_val
;
1461 NTTIME old_mtime
= 0;
1462 DATA_BLOB session_key
;
1463 DATA_BLOB new_blob
= data_blob_null
;
1464 DATA_BLOB old_blob
= data_blob_null
;
1465 char *new_secret
, *old_secret
;
1468 printf("Usage: %s name\n", argv
[0]);
1469 return NT_STATUS_OK
;
1472 status
= rpccli_lsa_open_policy2(cli
, mem_ctx
,
1474 SEC_FLAG_MAXIMUM_ALLOWED
,
1476 if (!NT_STATUS_IS_OK(status
)) {
1480 init_lsa_String(&name
, argv
[1]);
1482 status
= rpccli_lsa_OpenSecret(cli
, mem_ctx
,
1485 SEC_FLAG_MAXIMUM_ALLOWED
,
1487 if (!NT_STATUS_IS_OK(status
)) {
1491 ZERO_STRUCT(new_val
);
1492 ZERO_STRUCT(old_val
);
1494 status
= rpccli_lsa_QuerySecret(cli
, mem_ctx
,
1500 if (!NT_STATUS_IS_OK(status
)) {
1504 status
= cli_get_session_key(mem_ctx
, cli
, &session_key
);
1505 if (!NT_STATUS_IS_OK(status
)) {
1510 new_blob
= data_blob_const(new_val
.buf
->data
, new_val
.buf
->length
);
1513 old_blob
= data_blob_const(old_val
.buf
->data
, old_val
.buf
->length
);
1516 new_secret
= sess_decrypt_string(mem_ctx
, &new_blob
, &session_key
);
1517 old_secret
= sess_decrypt_string(mem_ctx
, &old_blob
, &session_key
);
1519 d_printf("new secret: %s\n", new_secret
);
1522 d_printf("old secret: %s\n", old_secret
);
1526 if (is_valid_policy_hnd(&sec_handle
)) {
1527 rpccli_lsa_Close(cli
, mem_ctx
, &sec_handle
);
1529 if (is_valid_policy_hnd(&handle
)) {
1530 rpccli_lsa_Close(cli
, mem_ctx
, &handle
);
1536 static NTSTATUS
cmd_lsa_set_secret(struct rpc_pipe_client
*cli
,
1537 TALLOC_CTX
*mem_ctx
, int argc
,
1541 struct policy_handle handle
, sec_handle
;
1542 struct lsa_String name
;
1543 struct lsa_DATA_BUF new_val
;
1544 struct lsa_DATA_BUF old_val
;
1546 DATA_BLOB session_key
;
1549 printf("Usage: %s name secret\n", argv
[0]);
1550 return NT_STATUS_OK
;
1553 status
= rpccli_lsa_open_policy2(cli
, mem_ctx
,
1555 SEC_FLAG_MAXIMUM_ALLOWED
,
1557 if (!NT_STATUS_IS_OK(status
)) {
1561 init_lsa_String(&name
, argv
[1]);
1563 status
= rpccli_lsa_OpenSecret(cli
, mem_ctx
,
1566 SEC_FLAG_MAXIMUM_ALLOWED
,
1568 if (!NT_STATUS_IS_OK(status
)) {
1572 ZERO_STRUCT(new_val
);
1573 ZERO_STRUCT(old_val
);
1575 status
= cli_get_session_key(mem_ctx
, cli
, &session_key
);
1576 if (!NT_STATUS_IS_OK(status
)) {
1580 enc_key
= sess_encrypt_string(argv
[2], &session_key
);
1582 new_val
.length
= enc_key
.length
;
1583 new_val
.size
= enc_key
.length
;
1584 new_val
.data
= enc_key
.data
;
1586 status
= rpccli_lsa_SetSecret(cli
, mem_ctx
,
1590 if (!NT_STATUS_IS_OK(status
)) {
1595 if (is_valid_policy_hnd(&sec_handle
)) {
1596 rpccli_lsa_Close(cli
, mem_ctx
, &sec_handle
);
1598 if (is_valid_policy_hnd(&handle
)) {
1599 rpccli_lsa_Close(cli
, mem_ctx
, &handle
);
1605 static NTSTATUS
cmd_lsa_retrieve_private_data(struct rpc_pipe_client
*cli
,
1606 TALLOC_CTX
*mem_ctx
, int argc
,
1610 struct policy_handle handle
;
1611 struct lsa_String name
;
1612 struct lsa_DATA_BUF
*val
;
1613 DATA_BLOB session_key
;
1618 printf("Usage: %s name\n", argv
[0]);
1619 return NT_STATUS_OK
;
1622 status
= rpccli_lsa_open_policy2(cli
, mem_ctx
,
1624 SEC_FLAG_MAXIMUM_ALLOWED
,
1626 if (!NT_STATUS_IS_OK(status
)) {
1630 init_lsa_String(&name
, argv
[1]);
1634 status
= rpccli_lsa_RetrievePrivateData(cli
, mem_ctx
,
1638 if (!NT_STATUS_IS_OK(status
)) {
1642 status
= cli_get_session_key(mem_ctx
, cli
, &session_key
);
1643 if (!NT_STATUS_IS_OK(status
)) {
1648 blob
= data_blob_const(val
->data
, val
->length
);
1651 secret
= sess_decrypt_string(mem_ctx
, &blob
, &session_key
);
1653 d_printf("secret: %s\n", secret
);
1657 if (is_valid_policy_hnd(&handle
)) {
1658 rpccli_lsa_Close(cli
, mem_ctx
, &handle
);
1664 static NTSTATUS
cmd_lsa_store_private_data(struct rpc_pipe_client
*cli
,
1665 TALLOC_CTX
*mem_ctx
, int argc
,
1669 struct policy_handle handle
;
1670 struct lsa_String name
;
1671 struct lsa_DATA_BUF val
;
1672 DATA_BLOB session_key
;
1676 printf("Usage: %s name secret\n", argv
[0]);
1677 return NT_STATUS_OK
;
1680 status
= rpccli_lsa_open_policy2(cli
, mem_ctx
,
1682 SEC_FLAG_MAXIMUM_ALLOWED
,
1684 if (!NT_STATUS_IS_OK(status
)) {
1688 init_lsa_String(&name
, argv
[1]);
1692 status
= cli_get_session_key(mem_ctx
, cli
, &session_key
);
1693 if (!NT_STATUS_IS_OK(status
)) {
1697 enc_key
= sess_encrypt_string(argv
[2], &session_key
);
1699 val
.length
= enc_key
.length
;
1700 val
.size
= enc_key
.length
;
1701 val
.data
= enc_key
.data
;
1703 status
= rpccli_lsa_StorePrivateData(cli
, mem_ctx
,
1707 if (!NT_STATUS_IS_OK(status
)) {
1712 if (is_valid_policy_hnd(&handle
)) {
1713 rpccli_lsa_Close(cli
, mem_ctx
, &handle
);
1720 /* List of commands exported by this module */
1722 struct cmd_set lsarpc_commands
[] = {
1726 { "lsaquery", RPC_RTYPE_NTSTATUS
, cmd_lsa_query_info_policy
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Query info policy", "" },
1727 { "lookupsids", RPC_RTYPE_NTSTATUS
, cmd_lsa_lookup_sids
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Convert SIDs to names", "" },
1728 { "lookupnames", RPC_RTYPE_NTSTATUS
, cmd_lsa_lookup_names
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Convert names to SIDs", "" },
1729 { "lookupnames_level", RPC_RTYPE_NTSTATUS
, cmd_lsa_lookup_names_level
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Convert names to SIDs", "" },
1730 { "enumtrust", RPC_RTYPE_NTSTATUS
, cmd_lsa_enum_trust_dom
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Enumerate trusted domains", "Usage: [preferred max number] [enum context (0)]" },
1731 { "enumprivs", RPC_RTYPE_NTSTATUS
, cmd_lsa_enum_privilege
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Enumerate privileges", "" },
1732 { "getdispname", RPC_RTYPE_NTSTATUS
, cmd_lsa_get_dispname
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Get the privilege name", "" },
1733 { "lsaenumsid", RPC_RTYPE_NTSTATUS
, cmd_lsa_enum_sids
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Enumerate the LSA SIDS", "" },
1734 { "lsacreateaccount", RPC_RTYPE_NTSTATUS
, cmd_lsa_create_account
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Create a new lsa account", "" },
1735 { "lsaenumprivsaccount", RPC_RTYPE_NTSTATUS
, cmd_lsa_enum_privsaccounts
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Enumerate the privileges of an SID", "" },
1736 { "lsaenumacctrights", RPC_RTYPE_NTSTATUS
, cmd_lsa_enum_acct_rights
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Enumerate the rights of an SID", "" },
1737 { "lsaaddpriv", RPC_RTYPE_NTSTATUS
, cmd_lsa_add_priv
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Assign a privilege to a SID", "" },
1738 { "lsadelpriv", RPC_RTYPE_NTSTATUS
, cmd_lsa_del_priv
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Revoke a privilege from a SID", "" },
1739 { "lsaaddacctrights", RPC_RTYPE_NTSTATUS
, cmd_lsa_add_acct_rights
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Add rights to an account", "" },
1740 { "lsaremoveacctrights", RPC_RTYPE_NTSTATUS
, cmd_lsa_remove_acct_rights
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Remove rights from an account", "" },
1741 { "lsalookupprivvalue", RPC_RTYPE_NTSTATUS
, cmd_lsa_lookup_priv_value
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Get a privilege value given its name", "" },
1742 { "lsaquerysecobj", RPC_RTYPE_NTSTATUS
, cmd_lsa_query_secobj
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Query LSA security object", "" },
1743 { "lsaquerytrustdominfo",RPC_RTYPE_NTSTATUS
, cmd_lsa_query_trustdominfo
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Query LSA trusted domains info (given a SID)", "" },
1744 { "lsaquerytrustdominfobyname",RPC_RTYPE_NTSTATUS
, cmd_lsa_query_trustdominfobyname
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Query LSA trusted domains info (given a name), only works for Windows > 2k", "" },
1745 { "lsaquerytrustdominfobysid",RPC_RTYPE_NTSTATUS
, cmd_lsa_query_trustdominfobysid
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Query LSA trusted domains info (given a SID)", "" },
1746 { "getusername", RPC_RTYPE_NTSTATUS
, cmd_lsa_get_username
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Get username", "" },
1747 { "createsecret", RPC_RTYPE_NTSTATUS
, cmd_lsa_create_secret
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Create Secret", "" },
1748 { "deletesecret", RPC_RTYPE_NTSTATUS
, cmd_lsa_delete_secret
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Delete Secret", "" },
1749 { "querysecret", RPC_RTYPE_NTSTATUS
, cmd_lsa_query_secret
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Query Secret", "" },
1750 { "setsecret", RPC_RTYPE_NTSTATUS
, cmd_lsa_set_secret
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Set Secret", "" },
1751 { "retrieveprivatedata", RPC_RTYPE_NTSTATUS
, cmd_lsa_retrieve_private_data
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Retrieve Private Data", "" },
1752 { "storeprivatedata", RPC_RTYPE_NTSTATUS
, cmd_lsa_store_private_data
, NULL
, &ndr_table_lsarpc
.syntax_id
, NULL
, "Store Private Data", "" },