source3/rpcclient/cmd_lsarpc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    RPC pipe client
   4
   5    Copyright (C) Tim Potter              2000
   6    Copyright (C) Rafal Szczesniak        2002
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "rpcclient.h"
  24
  25 /* useful function to allow entering a name instead of a SID and
  26  * looking it up automatically */
  27 static NTSTATUS name_to_sid(struct rpc_pipe_client *cli,
  28                             TALLOC_CTX *mem_ctx,
  29                             DOM_SID *sid, const char *name)
  30 {
  31         POLICY_HND pol;
  32         enum lsa_SidType *sid_types;
  33         NTSTATUS result;
  34         DOM_SID *sids;
  35
  36         /* maybe its a raw SID */
  37         if (strncmp(name, "S-", 2) == 0 &&
  38             string_to_sid(sid, name)) {
  39                 return NT_STATUS_OK;
  40         }
  41
  42         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
  43                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
  44                                      &pol);
  45         if (!NT_STATUS_IS_OK(result))
  46                 goto done;
  47
  48         result = rpccli_lsa_lookup_names(cli, mem_ctx, &pol, 1, &name, NULL, 1, &sids, &sid_types);
  49         if (!NT_STATUS_IS_OK(result))
  50                 goto done;
  51
  52         rpccli_lsa_Close(cli, mem_ctx, &pol);
  53
  54         *sid = sids[0];
  55
  56 done:
  57         return result;
  58 }
  59
  60 static void display_query_info_1(struct lsa_AuditLogInfo *r)
  61 {
  62         d_printf("percent_full:\t%d\n", r->percent_full);
  63         d_printf("log_size:\t%d\n", r->log_size);
  64         d_printf("retention_time:\t%lld\n", (long long)r->retention_time);
  65         d_printf("shutdown_in_progress:\t%d\n", r->shutdown_in_progress);
  66         d_printf("time_to_shutdown:\t%lld\n", (long long)r->time_to_shutdown);
  67         d_printf("next_audit_record:\t%d\n", r->next_audit_record);
  68         d_printf("unknown:\t%d\n", r->unknown);
  69 }
  70
  71 static void display_query_info_2(struct lsa_AuditEventsInfo *r)
  72 {
  73         int i;
  74         d_printf("Auditing enabled:\t%d\n", r->auditing_mode);
  75         d_printf("Auditing categories:\t%d\n", r->count);
  76         d_printf("Auditsettings:\n");
  77         for (i=0; i<r->count; i++) {
  78                 const char *val = audit_policy_str(talloc_tos(), r->settings[i]);
  79                 const char *policy = audit_description_str(i);
  80                 d_printf("%s:\t%s\n", policy, val);
  81         }
  82 }
  83
  84 static void display_query_info_3(struct lsa_DomainInfo *r)
  85 {
  86         d_printf("Domain Name: %s\n", r->name.string);
  87         d_printf("Domain Sid: %s\n", sid_string_tos(r->sid));
  88 }
  89
  90 static void display_query_info_5(struct lsa_DomainInfo *r)
  91 {
  92         d_printf("Domain Name: %s\n", r->name.string);
  93         d_printf("Domain Sid: %s\n", sid_string_tos(r->sid));
  94 }
  95
  96 static void display_query_info_10(struct lsa_AuditFullSetInfo *r)
  97 {
  98         d_printf("Shutdown on full: %d\n", r->shutdown_on_full);
  99 }
 100
 101 static void display_query_info_11(struct lsa_AuditFullQueryInfo *r)
 102 {
 103         d_printf("Shutdown on full: %d\n", r->shutdown_on_full);
 104         d_printf("Log is full: %d\n", r->log_is_full);
 105         d_printf("Unknown: %d\n", r->unknown);
 106 }
 107
 108 static void display_query_info_12(struct lsa_DnsDomainInfo *r)
 109 {
 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", smb_uuid_string(talloc_tos(),
 115                                                       r->domain_guid));
 116 }
 117
 118 static void display_lsa_query_info(union lsa_PolicyInformation *info,
 119                                    enum lsa_PolicyInfo level)
 120 {
 121         switch (level) {
 122                 case 1:
 123                         display_query_info_1(&info->audit_log);
 124                         break;
 125                 case 2:
 126                         display_query_info_2(&info->audit_events);
 127                         break;
 128                 case 3:
 129                         display_query_info_3(&info->domain);
 130                         break;
 131                 case 5:
 132                         display_query_info_5(&info->account_domain);
 133                         break;
 134                 case 10:
 135                         display_query_info_10(&info->auditfullset);
 136                         break;
 137                 case 11:
 138                         display_query_info_11(&info->auditfullquery);
 139                         break;
 140                 case 12:
 141                         display_query_info_12(&info->dns);
 142                         break;
 143                 default:
 144                         printf("can't display info level: %d\n", level);
 145                         break;
 146         }
 147 }
 148
 149 static NTSTATUS cmd_lsa_query_info_policy(struct rpc_pipe_client *cli,
 150                                           TALLOC_CTX *mem_ctx, int argc,
 151                                           const char **argv)
 152 {
 153         POLICY_HND pol;
 154         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 155         union lsa_PolicyInformation *info = NULL;
 156
 157         uint32 info_class = 3;
 158
 159         if (argc > 2) {
 160                 printf("Usage: %s [info_class]\n", argv[0]);
 161                 return NT_STATUS_OK;
 162         }
 163
 164         if (argc == 2)
 165                 info_class = atoi(argv[1]);
 166
 167         switch (info_class) {
 168         case 12:
 169                 result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 170                                                  SEC_RIGHTS_MAXIMUM_ALLOWED,
 171                                                  &pol);
 172
 173                 if (!NT_STATUS_IS_OK(result))
 174                         goto done;
 175
 176                 result = rpccli_lsa_QueryInfoPolicy2(cli, mem_ctx,
 177                                                      &pol,
 178                                                      info_class,
 179                                                      &info);
 180                 break;
 181         default:
 182                 result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 183                                                 SEC_RIGHTS_MAXIMUM_ALLOWED,
 184                                                 &pol);
 185
 186                 if (!NT_STATUS_IS_OK(result))
 187                         goto done;
 188
 189                 result = rpccli_lsa_QueryInfoPolicy(cli, mem_ctx,
 190                                                     &pol,
 191                                                     info_class,
 192                                                     &info);
 193         }
 194
 195         if (NT_STATUS_IS_OK(result)) {
 196                 display_lsa_query_info(info, info_class);
 197         }
 198
 199         rpccli_lsa_Close(cli, mem_ctx, &pol);
 200
 201  done:
 202         return result;
 203 }
 204
 205 /* Resolve a list of names to a list of sids */
 206
 207 static NTSTATUS cmd_lsa_lookup_names(struct rpc_pipe_client *cli,
 208                                      TALLOC_CTX *mem_ctx, int argc,
 209                                      const char **argv)
 210 {
 211         POLICY_HND pol;
 212         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 213         DOM_SID *sids;
 214         enum lsa_SidType *types;
 215         int i;
 216
 217         if (argc == 1) {
 218                 printf("Usage: %s [name1 [name2 [...]]]\n", argv[0]);
 219                 return NT_STATUS_OK;
 220         }
 221
 222         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 223                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 224                                      &pol);
 225
 226         if (!NT_STATUS_IS_OK(result))
 227                 goto done;
 228
 229         result = rpccli_lsa_lookup_names(cli, mem_ctx, &pol, argc - 1,
 230                                       (const char**)(argv + 1), NULL, 1, &sids, &types);
 231
 232         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
 233             NT_STATUS_V(STATUS_SOME_UNMAPPED))
 234                 goto done;
 235
 236         result = NT_STATUS_OK;
 237
 238         /* Print results */
 239
 240         for (i = 0; i < (argc - 1); i++) {
 241                 fstring sid_str;
 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]);
 245         }
 246
 247         rpccli_lsa_Close(cli, mem_ctx, &pol);
 248
 249  done:
 250         return result;
 251 }
 252
 253 /* Resolve a list of names to a list of sids */
 254
 255 static NTSTATUS cmd_lsa_lookup_names_level(struct rpc_pipe_client *cli,
 256                                            TALLOC_CTX *mem_ctx, int argc,
 257                                            const char **argv)
 258 {
 259         POLICY_HND pol;
 260         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 261         DOM_SID *sids;
 262         enum lsa_SidType *types;
 263         int i, level;
 264
 265         if (argc < 3) {
 266                 printf("Usage: %s [level] [name1 [name2 [...]]]\n", argv[0]);
 267                 return NT_STATUS_OK;
 268         }
 269
 270         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 271                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 272                                      &pol);
 273
 274         if (!NT_STATUS_IS_OK(result))
 275                 goto done;
 276
 277         level = atoi(argv[1]);
 278
 279         result = rpccli_lsa_lookup_names(cli, mem_ctx, &pol, argc - 2,
 280                                       (const char**)(argv + 2), NULL, level, &sids, &types);
 281
 282         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
 283             NT_STATUS_V(STATUS_SOME_UNMAPPED))
 284                 goto done;
 285
 286         result = NT_STATUS_OK;
 287
 288         /* Print results */
 289
 290         for (i = 0; i < (argc - 2); i++) {
 291                 fstring sid_str;
 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]);
 295         }
 296
 297         rpccli_lsa_Close(cli, mem_ctx, &pol);
 298
 299  done:
 300         return result;
 301 }
 302
 303
 304 /* Resolve a list of SIDs to a list of names */
 305
 306 static NTSTATUS cmd_lsa_lookup_sids(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
 307                                     int argc, const char **argv)
 308 {
 309         POLICY_HND pol;
 310         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 311         DOM_SID *sids;
 312         char **domains;
 313         char **names;
 314         enum lsa_SidType *types;
 315         int i;
 316
 317         if (argc == 1) {
 318                 printf("Usage: %s [sid1 [sid2 [...]]]\n", argv[0]);
 319                 return NT_STATUS_OK;
 320         }
 321
 322         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 323                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 324                                      &pol);
 325
 326         if (!NT_STATUS_IS_OK(result))
 327                 goto done;
 328
 329         /* Convert arguments to sids */
 330
 331         sids = TALLOC_ARRAY(mem_ctx, DOM_SID, argc - 1);
 332
 333         if (!sids) {
 334                 printf("could not allocate memory for %d sids\n", argc - 1);
 335                 goto done;
 336         }
 337
 338         for (i = 0; i < argc - 1; i++)
 339                 if (!string_to_sid(&sids[i], argv[i + 1])) {
 340                         result = NT_STATUS_INVALID_SID;
 341                         goto done;
 342                 }
 343
 344         /* Lookup the SIDs */
 345
 346         result = rpccli_lsa_lookup_sids(cli, mem_ctx, &pol, argc - 1, sids,
 347                                      &domains, &names, &types);
 348
 349         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
 350             NT_STATUS_V(STATUS_SOME_UNMAPPED))
 351                 goto done;
 352
 353         result = NT_STATUS_OK;
 354
 355         /* Print results */
 356
 357         for (i = 0; i < (argc - 1); i++) {
 358                 fstring sid_str;
 359
 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]);
 364         }
 365
 366         rpccli_lsa_Close(cli, mem_ctx, &pol);
 367
 368  done:
 369         return result;
 370 }
 371
 372 /* Enumerate list of trusted domains */
 373
 374 static NTSTATUS cmd_lsa_enum_trust_dom(struct rpc_pipe_client *cli,
 375                                        TALLOC_CTX *mem_ctx, int argc,
 376                                        const char **argv)
 377 {
 378         POLICY_HND pol;
 379         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 380         struct lsa_DomainList domain_list;
 381
 382         /* defaults, but may be changed using params */
 383         uint32 enum_ctx = 0;
 384         int i;
 385         uint32_t max_size = (uint32_t)-1;
 386
 387         if (argc > 2) {
 388                 printf("Usage: %s [enum context (0)]\n", argv[0]);
 389                 return NT_STATUS_OK;
 390         }
 391
 392         if (argc == 2 && argv[1]) {
 393                 enum_ctx = atoi(argv[2]);
 394         }
 395
 396         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 397                                      POLICY_VIEW_LOCAL_INFORMATION,
 398                                      &pol);
 399
 400         if (!NT_STATUS_IS_OK(result))
 401                 goto done;
 402
 403         result = STATUS_MORE_ENTRIES;
 404
 405         while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES)) {
 406
 407                 /* Lookup list of trusted domains */
 408
 409                 result = rpccli_lsa_EnumTrustDom(cli, mem_ctx,
 410                                                  &pol,
 411                                                  &enum_ctx,
 412                                                  &domain_list,
 413                                                  max_size);
 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))
 417                         goto done;
 418
 419                 /* Print results: list of names and sids returned in this
 420                  * response. */
 421                 for (i = 0; i < domain_list.count; i++) {
 422                         fstring sid_str;
 423
 424                         sid_to_fstring(sid_str, domain_list.domains[i].sid);
 425                         printf("%s %s\n",
 426                                 domain_list.domains[i].name.string ?
 427                                 domain_list.domains[i].name.string : "*unknown*",
 428                                 sid_str);
 429                 }
 430         }
 431
 432         rpccli_lsa_Close(cli, mem_ctx, &pol);
 433  done:
 434         return result;
 435 }
 436
 437 /* Enumerates privileges */
 438
 439 static NTSTATUS cmd_lsa_enum_privilege(struct rpc_pipe_client *cli,
 440                                        TALLOC_CTX *mem_ctx, int argc,
 441                                        const char **argv)
 442 {
 443         POLICY_HND pol;
 444         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 445         struct lsa_PrivArray priv_array;
 446
 447         uint32 enum_context=0;
 448         uint32 pref_max_length=0x1000;
 449         int i;
 450
 451         if (argc > 3) {
 452                 printf("Usage: %s [enum context] [max length]\n", argv[0]);
 453                 return NT_STATUS_OK;
 454         }
 455
 456         if (argc>=2)
 457                 enum_context=atoi(argv[1]);
 458
 459         if (argc==3)
 460                 pref_max_length=atoi(argv[2]);
 461
 462         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 463                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 464                                      &pol);
 465
 466         if (!NT_STATUS_IS_OK(result))
 467                 goto done;
 468
 469         result = rpccli_lsa_EnumPrivs(cli, mem_ctx,
 470                                       &pol,
 471                                       &enum_context,
 472                                       &priv_array,
 473                                       pref_max_length);
 474         if (!NT_STATUS_IS_OK(result))
 475                 goto done;
 476
 477         /* Print results */
 478         printf("found %d privileges\n\n", priv_array.count);
 479
 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);
 487         }
 488
 489         rpccli_lsa_Close(cli, mem_ctx, &pol);
 490  done:
 491         return result;
 492 }
 493
 494 /* Get privilege name */
 495
 496 static NTSTATUS cmd_lsa_get_dispname(struct rpc_pipe_client *cli,
 497                                      TALLOC_CTX *mem_ctx, int argc,
 498                                      const char **argv)
 499 {
 500         POLICY_HND pol;
 501         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 502
 503         uint16 lang_id=0;
 504         uint16 lang_id_sys=0;
 505         uint16 lang_id_desc;
 506         struct lsa_String lsa_name;
 507         struct lsa_StringLarge *description = NULL;
 508
 509         if (argc != 2) {
 510                 printf("Usage: %s privilege name\n", argv[0]);
 511                 return NT_STATUS_OK;
 512         }
 513
 514         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 515                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 516                                      &pol);
 517
 518         if (!NT_STATUS_IS_OK(result))
 519                 goto done;
 520
 521         init_lsa_String(&lsa_name, argv[1]);
 522
 523         result = rpccli_lsa_LookupPrivDisplayName(cli, mem_ctx,
 524                                                   &pol,
 525                                                   &lsa_name,
 526                                                   lang_id,
 527                                                   lang_id_sys,
 528                                                   &description,
 529                                                   &lang_id_desc);
 530
 531         if (!NT_STATUS_IS_OK(result))
 532                 goto done;
 533
 534         /* Print results */
 535         printf("%s -> %s (language: 0x%x)\n", argv[1], description->string, lang_id_desc);
 536
 537         rpccli_lsa_Close(cli, mem_ctx, &pol);
 538  done:
 539         return result;
 540 }
 541
 542 /* Enumerate the LSA SIDS */
 543
 544 static NTSTATUS cmd_lsa_enum_sids(struct rpc_pipe_client *cli,
 545                                   TALLOC_CTX *mem_ctx, int argc,
 546                                   const char **argv)
 547 {
 548         POLICY_HND pol;
 549         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 550
 551         uint32 enum_context=0;
 552         uint32 pref_max_length=0x1000;
 553         struct lsa_SidArray sid_array;
 554         int i;
 555
 556         if (argc > 3) {
 557                 printf("Usage: %s [enum context] [max length]\n", argv[0]);
 558                 return NT_STATUS_OK;
 559         }
 560
 561         if (argc>=2)
 562                 enum_context=atoi(argv[1]);
 563
 564         if (argc==3)
 565                 pref_max_length=atoi(argv[2]);
 566
 567         result = rpccli_lsa_open_policy(cli, mem_ctx, True,
 568                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 569                                      &pol);
 570
 571         if (!NT_STATUS_IS_OK(result))
 572                 goto done;
 573
 574         result = rpccli_lsa_EnumAccounts(cli, mem_ctx,
 575                                          &pol,
 576                                          &enum_context,
 577                                          &sid_array,
 578                                          pref_max_length);
 579
 580         if (!NT_STATUS_IS_OK(result))
 581                 goto done;
 582
 583         /* Print results */
 584         printf("found %d SIDs\n\n", sid_array.num_sids);
 585
 586         for (i = 0; i < sid_array.num_sids; i++) {
 587                 fstring sid_str;
 588
 589                 sid_to_fstring(sid_str, sid_array.sids[i].sid);
 590                 printf("%s\n", sid_str);
 591         }
 592
 593         rpccli_lsa_Close(cli, mem_ctx, &pol);
 594  done:
 595         return result;
 596 }
 597
 598 /* Create a new account */
 599
 600 static NTSTATUS cmd_lsa_create_account(struct rpc_pipe_client *cli,
 601                                            TALLOC_CTX *mem_ctx, int argc,
 602                                            const char **argv)
 603 {
 604         POLICY_HND dom_pol;
 605         POLICY_HND user_pol;
 606         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 607         uint32 des_access = 0x000f000f;
 608
 609         DOM_SID sid;
 610
 611         if (argc != 2 ) {
 612                 printf("Usage: %s SID\n", argv[0]);
 613                 return NT_STATUS_OK;
 614         }
 615
 616         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 617         if (!NT_STATUS_IS_OK(result))
 618                 goto done;
 619
 620         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 621                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 622                                      &dom_pol);
 623
 624         if (!NT_STATUS_IS_OK(result))
 625                 goto done;
 626
 627         result = rpccli_lsa_CreateAccount(cli, mem_ctx,
 628                                           &dom_pol,
 629                                           &sid,
 630                                           des_access,
 631                                           &user_pol);
 632
 633         if (!NT_STATUS_IS_OK(result))
 634                 goto done;
 635
 636         printf("Account for SID %s successfully created\n\n", argv[1]);
 637         result = NT_STATUS_OK;
 638
 639         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
 640  done:
 641         return result;
 642 }
 643
 644
 645 /* Enumerate the privileges of an SID */
 646
 647 static NTSTATUS cmd_lsa_enum_privsaccounts(struct rpc_pipe_client *cli,
 648                                            TALLOC_CTX *mem_ctx, int argc,
 649                                            const char **argv)
 650 {
 651         POLICY_HND dom_pol;
 652         POLICY_HND user_pol;
 653         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 654         uint32 access_desired = 0x000f000f;
 655         DOM_SID sid;
 656         struct lsa_PrivilegeSet *privs = NULL;
 657         int i;
 658
 659         if (argc != 2 ) {
 660                 printf("Usage: %s SID\n", argv[0]);
 661                 return NT_STATUS_OK;
 662         }
 663
 664         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 665         if (!NT_STATUS_IS_OK(result))
 666                 goto done;
 667
 668         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 669                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 670                                      &dom_pol);
 671
 672         if (!NT_STATUS_IS_OK(result))
 673                 goto done;
 674
 675         result = rpccli_lsa_OpenAccount(cli, mem_ctx,
 676                                         &dom_pol,
 677                                         &sid,
 678                                         access_desired,
 679                                         &user_pol);
 680
 681         if (!NT_STATUS_IS_OK(result))
 682                 goto done;
 683
 684         result = rpccli_lsa_EnumPrivsAccount(cli, mem_ctx,
 685                                              &user_pol,
 686                                              &privs);
 687
 688         if (!NT_STATUS_IS_OK(result))
 689                 goto done;
 690
 691         /* Print results */
 692         printf("found %d privileges for SID %s\n\n", privs->count, argv[1]);
 693         printf("high\tlow\tattribute\n");
 694
 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);
 700         }
 701
 702         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
 703  done:
 704         return result;
 705 }
 706
 707
 708 /* Enumerate the privileges of an SID via LsaEnumerateAccountRights */
 709
 710 static NTSTATUS cmd_lsa_enum_acct_rights(struct rpc_pipe_client *cli,
 711                                          TALLOC_CTX *mem_ctx, int argc,
 712                                          const char **argv)
 713 {
 714         POLICY_HND dom_pol;
 715         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 716         DOM_SID sid;
 717         struct lsa_RightSet rights;
 718
 719         int i;
 720
 721         if (argc != 2 ) {
 722                 printf("Usage: %s SID\n", argv[0]);
 723                 return NT_STATUS_OK;
 724         }
 725
 726         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 727         if (!NT_STATUS_IS_OK(result))
 728                 goto done;
 729
 730         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 731                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 732                                      &dom_pol);
 733
 734         if (!NT_STATUS_IS_OK(result))
 735                 goto done;
 736
 737         result = rpccli_lsa_EnumAccountRights(cli, mem_ctx,
 738                                               &dom_pol,
 739                                               &sid,
 740                                               &rights);
 741
 742         if (!NT_STATUS_IS_OK(result))
 743                 goto done;
 744
 745         printf("found %d privileges for SID %s\n", rights.count,
 746                sid_string_tos(&sid));
 747
 748         for (i = 0; i < rights.count; i++) {
 749                 printf("\t%s\n", rights.names[i].string);
 750         }
 751
 752         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
 753  done:
 754         return result;
 755 }
 756
 757
 758 /* add some privileges to a SID via LsaAddAccountRights */
 759
 760 static NTSTATUS cmd_lsa_add_acct_rights(struct rpc_pipe_client *cli,
 761                                         TALLOC_CTX *mem_ctx, int argc,
 762                                         const char **argv)
 763 {
 764         POLICY_HND dom_pol;
 765         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 766         struct lsa_RightSet rights;
 767         DOM_SID sid;
 768         int i;
 769
 770         if (argc < 3 ) {
 771                 printf("Usage: %s SID [rights...]\n", argv[0]);
 772                 return NT_STATUS_OK;
 773         }
 774
 775         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 776         if (!NT_STATUS_IS_OK(result))
 777                 goto done;
 778
 779         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 780                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 781                                      &dom_pol);
 782
 783         if (!NT_STATUS_IS_OK(result))
 784                 goto done;
 785
 786         rights.count = argc-2;
 787         rights.names = TALLOC_ARRAY(mem_ctx, struct lsa_StringLarge,
 788                                     rights.count);
 789         if (!rights.names) {
 790                 return NT_STATUS_NO_MEMORY;
 791         }
 792
 793         for (i=0; i<argc-1; i++) {
 794                 init_lsa_StringLarge(&rights.names[i], argv[i+2]);
 795         }
 796
 797         result = rpccli_lsa_AddAccountRights(cli, mem_ctx,
 798                                              &dom_pol,
 799                                              &sid,
 800                                              &rights);
 801
 802         if (!NT_STATUS_IS_OK(result))
 803                 goto done;
 804
 805         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
 806  done:
 807         return result;
 808 }
 809
 810
 811 /* remove some privileges to a SID via LsaRemoveAccountRights */
 812
 813 static NTSTATUS cmd_lsa_remove_acct_rights(struct rpc_pipe_client *cli,
 814                                         TALLOC_CTX *mem_ctx, int argc,
 815                                         const char **argv)
 816 {
 817         POLICY_HND dom_pol;
 818         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 819
 820         DOM_SID sid;
 821
 822         if (argc < 3 ) {
 823                 printf("Usage: %s SID [rights...]\n", argv[0]);
 824                 return NT_STATUS_OK;
 825         }
 826
 827         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 828         if (!NT_STATUS_IS_OK(result))
 829                 goto done;
 830
 831         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 832                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 833                                      &dom_pol);
 834
 835         if (!NT_STATUS_IS_OK(result))
 836                 goto done;
 837
 838         result = rpccli_lsa_remove_account_rights(cli, mem_ctx, &dom_pol, sid,
 839                                                False, argc-2, argv+2);
 840
 841         if (!NT_STATUS_IS_OK(result))
 842                 goto done;
 843
 844         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
 845
 846  done:
 847         return result;
 848 }
 849
 850
 851 /* Get a privilege value given its name */
 852
 853 static NTSTATUS cmd_lsa_lookup_priv_value(struct rpc_pipe_client *cli,
 854                                         TALLOC_CTX *mem_ctx, int argc,
 855                                         const char **argv)
 856 {
 857         POLICY_HND pol;
 858         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 859         struct lsa_LUID luid;
 860         struct lsa_String name;
 861
 862         if (argc != 2 ) {
 863                 printf("Usage: %s name\n", argv[0]);
 864                 return NT_STATUS_OK;
 865         }
 866
 867         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 868                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 869                                      &pol);
 870
 871         if (!NT_STATUS_IS_OK(result))
 872                 goto done;
 873
 874         init_lsa_String(&name, argv[1]);
 875
 876         result = rpccli_lsa_LookupPrivValue(cli, mem_ctx,
 877                                             &pol,
 878                                             &name,
 879                                             &luid);
 880
 881         if (!NT_STATUS_IS_OK(result))
 882                 goto done;
 883
 884         /* Print results */
 885
 886         printf("%u:%u (0x%x:0x%x)\n", luid.high, luid.low, luid.high, luid.low);
 887
 888         rpccli_lsa_Close(cli, mem_ctx, &pol);
 889  done:
 890         return result;
 891 }
 892
 893 /* Query LSA security object */
 894
 895 static NTSTATUS cmd_lsa_query_secobj(struct rpc_pipe_client *cli,
 896                                      TALLOC_CTX *mem_ctx, int argc,
 897                                      const char **argv)
 898 {
 899         POLICY_HND pol;
 900         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 901         SEC_DESC_BUF *sdb;
 902         uint32 sec_info = DACL_SECURITY_INFORMATION;
 903
 904         if (argc < 1 || argc > 2) {
 905                 printf("Usage: %s [sec_info]\n", argv[0]);
 906                 return NT_STATUS_OK;
 907         }
 908
 909         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
 910                                       SEC_RIGHTS_MAXIMUM_ALLOWED,
 911                                       &pol);
 912
 913         if (argc == 2)
 914                 sscanf(argv[1], "%x", &sec_info);
 915
 916         if (!NT_STATUS_IS_OK(result))
 917                 goto done;
 918
 919         result = rpccli_lsa_QuerySecurity(cli, mem_ctx,
 920                                           &pol,
 921                                           sec_info,
 922                                           &sdb);
 923         if (!NT_STATUS_IS_OK(result))
 924                 goto done;
 925
 926         /* Print results */
 927
 928         display_sec_desc(sdb->sd);
 929
 930         rpccli_lsa_Close(cli, mem_ctx, &pol);
 931  done:
 932         return result;
 933 }
 934
 935 static void display_trust_dom_info_4(struct lsa_TrustDomainInfoPassword *p, const char *password)
 936 {
 937         char *pwd, *pwd_old;
 938
 939         DATA_BLOB data     = data_blob(NULL, p->password->length);
 940         DATA_BLOB data_old = data_blob(NULL, p->old_password->length);
 941
 942         memcpy(data.data, p->password->data, p->password->length);
 943         memcpy(data_old.data, p->old_password->data, p->old_password->length);
 944
 945         pwd     = decrypt_trustdom_secret(password, &data);
 946         pwd_old = decrypt_trustdom_secret(password, &data_old);
 947
 948         d_printf("Password:\t%s\n", pwd);
 949         d_printf("Old Password:\t%s\n", pwd_old);
 950
 951         SAFE_FREE(pwd);
 952         SAFE_FREE(pwd_old);
 953
 954         data_blob_free(&data);
 955         data_blob_free(&data_old);
 956 }
 957
 958 static void display_trust_dom_info(TALLOC_CTX *mem_ctx,
 959                                    union lsa_TrustedDomainInfo *info,
 960                                    enum lsa_TrustDomInfoEnum info_class,
 961                                    const char *pass)
 962 {
 963         switch (info_class) {
 964                 case LSA_TRUSTED_DOMAIN_INFO_PASSWORD:
 965                         display_trust_dom_info_4(&info->password, pass);
 966                         break;
 967                 default: {
 968                         const char *str = NULL;
 969                         str = NDR_PRINT_UNION_STRING(mem_ctx,
 970                                                      lsa_TrustedDomainInfo,
 971                                                      info_class, info);
 972                         if (str) {
 973                                 d_printf("%s\n", str);
 974                         }
 975                         break;
 976                 }
 977         }
 978 }
 979
 980 static NTSTATUS cmd_lsa_query_trustdominfobysid(struct rpc_pipe_client *cli,
 981                                                 TALLOC_CTX *mem_ctx, int argc,
 982                                                 const char **argv)
 983 {
 984         POLICY_HND pol;
 985         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 986         DOM_SID dom_sid;
 987         uint32 access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
 988         union lsa_TrustedDomainInfo info;
 989         enum lsa_TrustDomInfoEnum info_class = 1;
 990
 991         if (argc > 3 || argc < 2) {
 992                 printf("Usage: %s [sid] [info_class]\n", argv[0]);
 993                 return NT_STATUS_OK;
 994         }
 995
 996         if (!string_to_sid(&dom_sid, argv[1]))
 997                 return NT_STATUS_NO_MEMORY;
 998
 999         if (argc == 3)
1000                 info_class = atoi(argv[2]);
1001
1002         result = rpccli_lsa_open_policy2(cli, mem_ctx, True, access_mask, &pol);
1003
1004         if (!NT_STATUS_IS_OK(result))
1005                 goto done;
1006
1007         result = rpccli_lsa_QueryTrustedDomainInfoBySid(cli, mem_ctx,
1008                                                         &pol,
1009                                                         &dom_sid,
1010                                                         info_class,
1011                                                         &info);
1012         if (!NT_STATUS_IS_OK(result))
1013                 goto done;
1014
1015         display_trust_dom_info(mem_ctx, &info, info_class, cli->pwd.password);
1016
1017  done:
1018         rpccli_lsa_Close(cli, mem_ctx, &pol);
1019
1020         return result;
1021 }
1022
1023 static NTSTATUS cmd_lsa_query_trustdominfobyname(struct rpc_pipe_client *cli,
1024                                                  TALLOC_CTX *mem_ctx, int argc,
1025                                                  const char **argv)
1026 {
1027         POLICY_HND pol;
1028         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1029         uint32 access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1030         union lsa_TrustedDomainInfo info;
1031         enum lsa_TrustDomInfoEnum info_class = 1;
1032         struct lsa_String trusted_domain;
1033
1034         if (argc > 3 || argc < 2) {
1035                 printf("Usage: %s [name] [info_class]\n", argv[0]);
1036                 return NT_STATUS_OK;
1037         }
1038
1039         if (argc == 3)
1040                 info_class = atoi(argv[2]);
1041
1042         result = rpccli_lsa_open_policy2(cli, mem_ctx, True, access_mask, &pol);
1043
1044         if (!NT_STATUS_IS_OK(result))
1045                 goto done;
1046
1047         init_lsa_String(&trusted_domain, argv[1]);
1048
1049         result = rpccli_lsa_QueryTrustedDomainInfoByName(cli, mem_ctx,
1050                                                          &pol,
1051                                                          &trusted_domain,
1052                                                          info_class,
1053                                                          &info);
1054         if (!NT_STATUS_IS_OK(result))
1055                 goto done;
1056
1057         display_trust_dom_info(mem_ctx, &info, info_class, cli->pwd.password);
1058
1059  done:
1060         rpccli_lsa_Close(cli, mem_ctx, &pol);
1061
1062         return result;
1063 }
1064
1065 static NTSTATUS cmd_lsa_query_trustdominfo(struct rpc_pipe_client *cli,
1066                                            TALLOC_CTX *mem_ctx, int argc,
1067                                            const char **argv)
1068 {
1069         POLICY_HND pol, trustdom_pol;
1070         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1071         uint32 access_mask = SEC_RIGHTS_MAXIMUM_ALLOWED;
1072         union lsa_TrustedDomainInfo info;
1073         DOM_SID dom_sid;
1074         enum lsa_TrustDomInfoEnum info_class = 1;
1075
1076         if (argc > 3 || argc < 2) {
1077                 printf("Usage: %s [sid] [info_class]\n", argv[0]);
1078                 return NT_STATUS_OK;
1079         }
1080
1081         if (!string_to_sid(&dom_sid, argv[1]))
1082                 return NT_STATUS_NO_MEMORY;
1083
1084
1085         if (argc == 3)
1086                 info_class = atoi(argv[2]);
1087
1088         result = rpccli_lsa_open_policy2(cli, mem_ctx, True, access_mask, &pol);
1089
1090         if (!NT_STATUS_IS_OK(result))
1091                 goto done;
1092
1093         result = rpccli_lsa_OpenTrustedDomain(cli, mem_ctx,
1094                                               &pol,
1095                                               &dom_sid,
1096                                               access_mask,
1097                                               &trustdom_pol);
1098
1099         if (!NT_STATUS_IS_OK(result))
1100                 goto done;
1101
1102         result = rpccli_lsa_QueryTrustedDomainInfo(cli, mem_ctx,
1103                                                    &trustdom_pol,
1104                                                    info_class,
1105                                                    &info);
1106
1107         if (!NT_STATUS_IS_OK(result))
1108                 goto done;
1109
1110         display_trust_dom_info(mem_ctx, &info, info_class, cli->pwd.password);
1111
1112  done:
1113         rpccli_lsa_Close(cli, mem_ctx, &pol);
1114
1115         return result;
1116 }
1117
1118 static NTSTATUS cmd_lsa_get_username(struct rpc_pipe_client *cli,
1119                                      TALLOC_CTX *mem_ctx, int argc,
1120                                      const char **argv)
1121 {
1122         POLICY_HND pol;
1123         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1124         const char *servername = cli->cli->desthost;
1125         struct lsa_String *account_name = NULL;
1126         struct lsa_String *authority_name = NULL;
1127
1128         if (argc > 2) {
1129                 printf("Usage: %s servername\n", argv[0]);
1130                 return NT_STATUS_OK;
1131         }
1132
1133         result = rpccli_lsa_open_policy(cli, mem_ctx, true,
1134                                         SEC_RIGHTS_MAXIMUM_ALLOWED,
1135                                         &pol);
1136
1137         if (!NT_STATUS_IS_OK(result)) {
1138                 goto done;
1139         }
1140
1141         result = rpccli_lsa_GetUserName(cli, mem_ctx,
1142                                         servername,
1143                                         &account_name,
1144                                         &authority_name);
1145         if (!NT_STATUS_IS_OK(result)) {
1146                 goto done;
1147         }
1148
1149         /* Print results */
1150
1151         printf("Account Name: %s, Authority Name: %s\n",
1152                 account_name->string, authority_name->string);
1153
1154         rpccli_lsa_Close(cli, mem_ctx, &pol);
1155  done:
1156         return result;
1157 }
1158
1159 static NTSTATUS cmd_lsa_add_priv(struct rpc_pipe_client *cli,
1160                                  TALLOC_CTX *mem_ctx, int argc,
1161                                  const char **argv)
1162 {
1163         POLICY_HND dom_pol, user_pol;
1164         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1165         struct lsa_PrivilegeSet privs;
1166         struct lsa_LUIDAttribute *set = NULL;
1167         DOM_SID sid;
1168         int i;
1169
1170         ZERO_STRUCT(privs);
1171
1172         if (argc < 3 ) {
1173                 printf("Usage: %s SID [rights...]\n", argv[0]);
1174                 return NT_STATUS_OK;
1175         }
1176
1177         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
1178         if (!NT_STATUS_IS_OK(result)) {
1179                 goto done;
1180         }
1181
1182         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
1183                                          SEC_RIGHTS_MAXIMUM_ALLOWED,
1184                                          &dom_pol);
1185
1186         if (!NT_STATUS_IS_OK(result)) {
1187                 goto done;
1188         }
1189
1190         result = rpccli_lsa_OpenAccount(cli, mem_ctx,
1191                                         &dom_pol,
1192                                         &sid,
1193                                         SEC_RIGHTS_MAXIMUM_ALLOWED,
1194                                         &user_pol);
1195
1196         if (!NT_STATUS_IS_OK(result)) {
1197                 goto done;
1198         }
1199
1200         for (i=2; i<argc; i++) {
1201
1202                 struct lsa_String priv_name;
1203                 struct lsa_LUID luid;
1204
1205                 init_lsa_String(&priv_name, argv[i]);
1206
1207                 result = rpccli_lsa_LookupPrivValue(cli, mem_ctx,
1208                                                     &dom_pol,
1209                                                     &priv_name,
1210                                                     &luid);
1211                 if (!NT_STATUS_IS_OK(result)) {
1212                         continue;
1213                 }
1214
1215                 privs.count++;
1216                 set = TALLOC_REALLOC_ARRAY(mem_ctx, set,
1217                                            struct lsa_LUIDAttribute,
1218                                            privs.count);
1219                 if (!set) {
1220                         return NT_STATUS_NO_MEMORY;
1221                 }
1222
1223                 set[privs.count-1].luid = luid;
1224                 set[privs.count-1].attribute = 0;
1225         }
1226
1227         privs.set = set;
1228
1229         result = rpccli_lsa_AddPrivilegesToAccount(cli, mem_ctx,
1230                                                    &user_pol,
1231                                                    &privs);
1232
1233         if (!NT_STATUS_IS_OK(result)) {
1234                 goto done;
1235         }
1236
1237         rpccli_lsa_Close(cli, mem_ctx, &user_pol);
1238         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
1239  done:
1240         return result;
1241 }
1242
1243 static NTSTATUS cmd_lsa_del_priv(struct rpc_pipe_client *cli,
1244                                  TALLOC_CTX *mem_ctx, int argc,
1245                                  const char **argv)
1246 {
1247         POLICY_HND dom_pol, user_pol;
1248         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1249         struct lsa_PrivilegeSet privs;
1250         struct lsa_LUIDAttribute *set = NULL;
1251         DOM_SID sid;
1252         int i;
1253
1254         ZERO_STRUCT(privs);
1255
1256         if (argc < 3 ) {
1257                 printf("Usage: %s SID [rights...]\n", argv[0]);
1258                 return NT_STATUS_OK;
1259         }
1260
1261         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
1262         if (!NT_STATUS_IS_OK(result)) {
1263                 goto done;
1264         }
1265
1266         result = rpccli_lsa_open_policy2(cli, mem_ctx, True,
1267                                          SEC_RIGHTS_MAXIMUM_ALLOWED,
1268                                          &dom_pol);
1269
1270         if (!NT_STATUS_IS_OK(result)) {
1271                 goto done;
1272         }
1273
1274         result = rpccli_lsa_OpenAccount(cli, mem_ctx,
1275                                         &dom_pol,
1276                                         &sid,
1277                                         SEC_RIGHTS_MAXIMUM_ALLOWED,
1278                                         &user_pol);
1279
1280         if (!NT_STATUS_IS_OK(result)) {
1281                 goto done;
1282         }
1283
1284         for (i=2; i<argc; i++) {
1285
1286                 struct lsa_String priv_name;
1287                 struct lsa_LUID luid;
1288
1289                 init_lsa_String(&priv_name, argv[i]);
1290
1291                 result = rpccli_lsa_LookupPrivValue(cli, mem_ctx,
1292                                                     &dom_pol,
1293                                                     &priv_name,
1294                                                     &luid);
1295                 if (!NT_STATUS_IS_OK(result)) {
1296                         continue;
1297                 }
1298
1299                 privs.count++;
1300                 set = TALLOC_REALLOC_ARRAY(mem_ctx, set,
1301                                            struct lsa_LUIDAttribute,
1302                                            privs.count);
1303                 if (!set) {
1304                         return NT_STATUS_NO_MEMORY;
1305                 }
1306
1307                 set[privs.count-1].luid = luid;
1308                 set[privs.count-1].attribute = 0;
1309         }
1310
1311         privs.set = set;
1312
1313
1314         result = rpccli_lsa_RemovePrivilegesFromAccount(cli, mem_ctx,
1315                                                         &user_pol,
1316                                                         false,
1317                                                         &privs);
1318
1319         if (!NT_STATUS_IS_OK(result)) {
1320                 goto done;
1321         }
1322
1323         rpccli_lsa_Close(cli, mem_ctx, &user_pol);
1324         rpccli_lsa_Close(cli, mem_ctx, &dom_pol);
1325  done:
1326         return result;
1327 }
1328
1329
1330 /* List of commands exported by this module */
1331
1332 struct cmd_set lsarpc_commands[] = {
1333
1334         { "LSARPC" },
1335
1336         { "lsaquery",            RPC_RTYPE_NTSTATUS, cmd_lsa_query_info_policy,  NULL, PI_LSARPC, NULL, "Query info policy",                    "" },
1337         { "lookupsids",          RPC_RTYPE_NTSTATUS, cmd_lsa_lookup_sids,        NULL, PI_LSARPC, NULL, "Convert SIDs to names",                "" },
1338         { "lookupnames",         RPC_RTYPE_NTSTATUS, cmd_lsa_lookup_names,       NULL, PI_LSARPC, NULL, "Convert names to SIDs",                "" },
1339         { "lookupnames_level",   RPC_RTYPE_NTSTATUS, cmd_lsa_lookup_names_level, NULL, PI_LSARPC, NULL, "Convert names to SIDs",                "" },
1340         { "enumtrust",           RPC_RTYPE_NTSTATUS, cmd_lsa_enum_trust_dom,     NULL, PI_LSARPC, NULL, "Enumerate trusted domains",            "Usage: [preferred max number] [enum context (0)]" },
1341         { "enumprivs",           RPC_RTYPE_NTSTATUS, cmd_lsa_enum_privilege,     NULL, PI_LSARPC, NULL, "Enumerate privileges",                 "" },
1342         { "getdispname",         RPC_RTYPE_NTSTATUS, cmd_lsa_get_dispname,       NULL, PI_LSARPC, NULL, "Get the privilege name",               "" },
1343         { "lsaenumsid",          RPC_RTYPE_NTSTATUS, cmd_lsa_enum_sids,          NULL, PI_LSARPC, NULL, "Enumerate the LSA SIDS",               "" },
1344         { "lsacreateaccount",    RPC_RTYPE_NTSTATUS, cmd_lsa_create_account,     NULL, PI_LSARPC, NULL, "Create a new lsa account",   "" },
1345         { "lsaenumprivsaccount", RPC_RTYPE_NTSTATUS, cmd_lsa_enum_privsaccounts, NULL, PI_LSARPC, NULL, "Enumerate the privileges of an SID",   "" },
1346         { "lsaenumacctrights",   RPC_RTYPE_NTSTATUS, cmd_lsa_enum_acct_rights,   NULL, PI_LSARPC, NULL, "Enumerate the rights of an SID",   "" },
1347         { "lsaaddpriv",          RPC_RTYPE_NTSTATUS, cmd_lsa_add_priv,           NULL, PI_LSARPC, NULL, "Assign a privilege to a SID", "" },
1348         { "lsadelpriv",          RPC_RTYPE_NTSTATUS, cmd_lsa_del_priv,           NULL, PI_LSARPC, NULL, "Revoke a privilege from a SID", "" },
1349         { "lsaaddacctrights",    RPC_RTYPE_NTSTATUS, cmd_lsa_add_acct_rights,    NULL, PI_LSARPC, NULL, "Add rights to an account",   "" },
1350         { "lsaremoveacctrights", RPC_RTYPE_NTSTATUS, cmd_lsa_remove_acct_rights, NULL, PI_LSARPC, NULL, "Remove rights from an account",   "" },
1351         { "lsalookupprivvalue",  RPC_RTYPE_NTSTATUS, cmd_lsa_lookup_priv_value,  NULL, PI_LSARPC, NULL, "Get a privilege value given its name", "" },
1352         { "lsaquerysecobj",      RPC_RTYPE_NTSTATUS, cmd_lsa_query_secobj,       NULL, PI_LSARPC, NULL, "Query LSA security object", "" },
1353         { "lsaquerytrustdominfo",RPC_RTYPE_NTSTATUS, cmd_lsa_query_trustdominfo, NULL, PI_LSARPC, NULL, "Query LSA trusted domains info (given a SID)", "" },
1354         { "lsaquerytrustdominfobyname",RPC_RTYPE_NTSTATUS, cmd_lsa_query_trustdominfobyname, NULL, PI_LSARPC, NULL, "Query LSA trusted domains info (given a name), only works for Windows > 2k", "" },
1355         { "lsaquerytrustdominfobysid",RPC_RTYPE_NTSTATUS, cmd_lsa_query_trustdominfobysid, NULL, PI_LSARPC, NULL, "Query LSA trusted domains info (given a SID)", "" },
1356         { "getusername",          RPC_RTYPE_NTSTATUS, cmd_lsa_get_username, NULL, PI_LSARPC, NULL, "Get username", "" },
1357
1358         { NULL }
1359 };
1360