source/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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "rpcclient.h"
  25
  26
  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 cli_state *cli,
  30                             TALLOC_CTX *mem_ctx,
  31                             DOM_SID *sid, const char *name)
  32 {
  33         POLICY_HND pol;
  34         uint32 *sid_types;
  35         NTSTATUS result;
  36         DOM_SID *sids;
  37
  38         /* maybe its a raw SID */
  39         if (strncmp(name, "S-", 2) == 0 &&
  40             string_to_sid(sid, name)) {
  41                 return NT_STATUS_OK;
  42         }
  43
  44         result = cli_lsa_open_policy(cli, mem_ctx, True,
  45                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
  46                                      &pol);
  47         if (!NT_STATUS_IS_OK(result))
  48                 goto done;
  49
  50         result = cli_lsa_lookup_names(cli, mem_ctx, &pol, 1, &name, &sids, &sid_types);
  51         if (!NT_STATUS_IS_OK(result))
  52                 goto done;
  53
  54         cli_lsa_close(cli, mem_ctx, &pol);
  55
  56         *sid = sids[0];
  57
  58 done:
  59         return result;
  60 }
  61
  62
  63 /* Look up domain related information on a remote host */
  64
  65 static NTSTATUS cmd_lsa_query_info_policy(struct cli_state *cli,
  66                                           TALLOC_CTX *mem_ctx, int argc,
  67                                           const char **argv)
  68 {
  69         POLICY_HND pol;
  70         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
  71         DOM_SID *dom_sid;
  72         struct uuid *dom_guid;
  73         fstring sid_str;
  74         char *domain_name = NULL;
  75         char *dns_name = NULL;
  76         char *forest_name = NULL;
  77
  78         uint32 info_class = 3;
  79
  80         if (argc > 2) {
  81                 printf("Usage: %s [info_class]\n", argv[0]);
  82                 return NT_STATUS_OK;
  83         }
  84
  85         if (argc == 2)
  86                 info_class = atoi(argv[1]);
  87
  88         /* Lookup info policy */
  89         switch (info_class) {
  90         case 12:
  91                 result = cli_lsa_open_policy2(cli, mem_ctx, True,
  92                                              SEC_RIGHTS_MAXIMUM_ALLOWED,
  93                                              &pol);
  94
  95                 if (!NT_STATUS_IS_OK(result))
  96                         goto done;
  97                 result = cli_lsa_query_info_policy2(cli, mem_ctx, &pol,
  98                                                     info_class, &domain_name,
  99                                                     &dns_name, &forest_name,
 100                                                     &dom_guid, &dom_sid);
 101                 break;
 102         default:
 103                 result = cli_lsa_open_policy(cli, mem_ctx, True,
 104                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 105                                      &pol);
 106
 107                 if (!NT_STATUS_IS_OK(result))
 108                         goto done;
 109                 result = cli_lsa_query_info_policy(cli, mem_ctx, &pol,
 110                                                    info_class, &domain_name,
 111                                                    &dom_sid);
 112         }
 113
 114         if (!NT_STATUS_IS_OK(result))
 115                 goto done;
 116
 117         sid_to_string(sid_str, dom_sid);
 118
 119         if (domain_name)
 120                 printf("domain %s has sid %s\n", domain_name, sid_str);
 121         else
 122                 printf("could not query info for level %d\n", info_class);
 123
 124         if (dns_name)
 125                 printf("domain dns name is %s\n", dns_name);
 126         if (forest_name)
 127                 printf("forest name is %s\n", forest_name);
 128
 129         if (info_class == 12) {
 130                 printf("domain GUID is ");
 131                 smb_uuid_string_static(*dom_guid);
 132         }
 133  done:
 134         return result;
 135 }
 136
 137 /* Resolve a list of names to a list of sids */
 138
 139 static NTSTATUS cmd_lsa_lookup_names(struct cli_state *cli,
 140                                      TALLOC_CTX *mem_ctx, int argc,
 141                                      const char **argv)
 142 {
 143         POLICY_HND pol;
 144         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 145         DOM_SID *sids;
 146         uint32 *types;
 147         int i;
 148
 149         if (argc == 1) {
 150                 printf("Usage: %s [name1 [name2 [...]]]\n", argv[0]);
 151                 return NT_STATUS_OK;
 152         }
 153
 154         result = cli_lsa_open_policy(cli, mem_ctx, True,
 155                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 156                                      &pol);
 157
 158         if (!NT_STATUS_IS_OK(result))
 159                 goto done;
 160
 161         result = cli_lsa_lookup_names(cli, mem_ctx, &pol, argc - 1,
 162                                       (const char**)(argv + 1), &sids, &types);
 163
 164         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
 165             NT_STATUS_V(STATUS_SOME_UNMAPPED))
 166                 goto done;
 167
 168         result = NT_STATUS_OK;
 169
 170         /* Print results */
 171
 172         for (i = 0; i < (argc - 1); i++) {
 173                 fstring sid_str;
 174                 sid_to_string(sid_str, &sids[i]);
 175                 printf("%s %s (%s: %d)\n", argv[i + 1], sid_str,
 176                        sid_type_lookup(types[i]), types[i]);
 177         }
 178
 179  done:
 180         return result;
 181 }
 182
 183 /* Resolve a list of SIDs to a list of names */
 184
 185 static NTSTATUS cmd_lsa_lookup_sids(struct cli_state *cli, TALLOC_CTX *mem_ctx,
 186                                     int argc, const char **argv)
 187 {
 188         POLICY_HND pol;
 189         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 190         DOM_SID *sids;
 191         char **domains;
 192         char **names;
 193         uint32 *types;
 194         int i;
 195
 196         if (argc == 1) {
 197                 printf("Usage: %s [sid1 [sid2 [...]]]\n", argv[0]);
 198                 return NT_STATUS_OK;
 199         }
 200
 201         result = cli_lsa_open_policy(cli, mem_ctx, True,
 202                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 203                                      &pol);
 204
 205         if (!NT_STATUS_IS_OK(result))
 206                 goto done;
 207
 208         /* Convert arguments to sids */
 209
 210         sids = TALLOC_ARRAY(mem_ctx, DOM_SID, argc - 1);
 211
 212         if (!sids) {
 213                 printf("could not allocate memory for %d sids\n", argc - 1);
 214                 goto done;
 215         }
 216
 217         for (i = 0; i < argc - 1; i++)
 218                 if (!string_to_sid(&sids[i], argv[i + 1])) {
 219                         result = NT_STATUS_INVALID_SID;
 220                         goto done;
 221                 }
 222
 223         /* Lookup the SIDs */
 224
 225         result = cli_lsa_lookup_sids(cli, mem_ctx, &pol, argc - 1, sids,
 226                                      &domains, &names, &types);
 227
 228         if (!NT_STATUS_IS_OK(result) && NT_STATUS_V(result) !=
 229             NT_STATUS_V(STATUS_SOME_UNMAPPED))
 230                 goto done;
 231
 232         result = NT_STATUS_OK;
 233
 234         /* Print results */
 235
 236         for (i = 0; i < (argc - 1); i++) {
 237                 fstring sid_str;
 238
 239                 sid_to_string(sid_str, &sids[i]);
 240                 printf("%s %s\\%s (%d)\n", sid_str,
 241                        domains[i] ? domains[i] : "*unknown*",
 242                        names[i] ? names[i] : "*unknown*", types[i]);
 243         }
 244
 245  done:
 246         return result;
 247 }
 248
 249 /* Enumerate list of trusted domains */
 250
 251 static NTSTATUS cmd_lsa_enum_trust_dom(struct cli_state *cli,
 252                                        TALLOC_CTX *mem_ctx, int argc,
 253                                        const char **argv)
 254 {
 255         POLICY_HND pol;
 256         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 257         DOM_SID *domain_sids;
 258         char **domain_names;
 259
 260         /* defaults, but may be changed using params */
 261         uint32 enum_ctx = 0;
 262         uint32 num_domains = 0;
 263         int i;
 264
 265         if (argc > 2) {
 266                 printf("Usage: %s [enum context (0)]\n", argv[0]);
 267                 return NT_STATUS_OK;
 268         }
 269
 270         if (argc == 2 && argv[1]) {
 271                 enum_ctx = atoi(argv[2]);
 272         }
 273
 274         result = cli_lsa_open_policy(cli, mem_ctx, True,
 275                                      POLICY_VIEW_LOCAL_INFORMATION,
 276                                      &pol);
 277
 278         if (!NT_STATUS_IS_OK(result))
 279                 goto done;
 280
 281         /* Lookup list of trusted domains */
 282
 283         result = cli_lsa_enum_trust_dom(cli, mem_ctx, &pol, &enum_ctx,
 284                                         &num_domains,
 285                                         &domain_names, &domain_sids);
 286         if (!NT_STATUS_IS_OK(result) &&
 287             !NT_STATUS_EQUAL(result, NT_STATUS_NO_MORE_ENTRIES) &&
 288             !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
 289             goto done;
 290
 291         /* Print results: list of names and sids returned in this response. */
 292         for (i = 0; i < num_domains; i++) {
 293                 fstring sid_str;
 294
 295                 sid_to_string(sid_str, &domain_sids[i]);
 296                 printf("%s %s\n", domain_names[i] ? domain_names[i] :
 297                        "*unknown*", sid_str);
 298         }
 299
 300  done:
 301         return result;
 302 }
 303
 304 /* Enumerates privileges */
 305
 306 static NTSTATUS cmd_lsa_enum_privilege(struct cli_state *cli,
 307                                        TALLOC_CTX *mem_ctx, int argc,
 308                                        const char **argv)
 309 {
 310         POLICY_HND pol;
 311         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 312
 313         uint32 enum_context=0;
 314         uint32 pref_max_length=0x1000;
 315         uint32 count=0;
 316         char   **privs_name;
 317         uint32 *privs_high;
 318         uint32 *privs_low;
 319         int i;
 320
 321         if (argc > 3) {
 322                 printf("Usage: %s [enum context] [max length]\n", argv[0]);
 323                 return NT_STATUS_OK;
 324         }
 325
 326         if (argc>=2)
 327                 enum_context=atoi(argv[1]);
 328
 329         if (argc==3)
 330                 pref_max_length=atoi(argv[2]);
 331
 332         result = cli_lsa_open_policy(cli, mem_ctx, True,
 333                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 334                                      &pol);
 335
 336         if (!NT_STATUS_IS_OK(result))
 337                 goto done;
 338
 339         result = cli_lsa_enum_privilege(cli, mem_ctx, &pol, &enum_context, pref_max_length,
 340                                         &count, &privs_name, &privs_high, &privs_low);
 341
 342         if (!NT_STATUS_IS_OK(result))
 343                 goto done;
 344
 345         /* Print results */
 346         printf("found %d privileges\n\n", count);
 347
 348         for (i = 0; i < count; i++) {
 349                 printf("%s \t\t%d:%d (0x%x:0x%x)\n", privs_name[i] ? privs_name[i] : "*unknown*",
 350                        privs_high[i], privs_low[i], privs_high[i], privs_low[i]);
 351         }
 352
 353  done:
 354         return result;
 355 }
 356
 357 /* Get privilege name */
 358
 359 static NTSTATUS cmd_lsa_get_dispname(struct cli_state *cli,
 360                                      TALLOC_CTX *mem_ctx, int argc,
 361                                      const char **argv)
 362 {
 363         POLICY_HND pol;
 364         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 365
 366         uint16 lang_id=0;
 367         uint16 lang_id_sys=0;
 368         uint16 lang_id_desc;
 369         fstring description;
 370
 371         if (argc != 2) {
 372                 printf("Usage: %s privilege name\n", argv[0]);
 373                 return NT_STATUS_OK;
 374         }
 375
 376         result = cli_lsa_open_policy(cli, mem_ctx, True,
 377                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 378                                      &pol);
 379
 380         if (!NT_STATUS_IS_OK(result))
 381                 goto done;
 382
 383         result = cli_lsa_get_dispname(cli, mem_ctx, &pol, argv[1], lang_id, lang_id_sys, description, &lang_id_desc);
 384
 385         if (!NT_STATUS_IS_OK(result))
 386                 goto done;
 387
 388         /* Print results */
 389         printf("%s -> %s (language: 0x%x)\n", argv[1], description, lang_id_desc);
 390
 391  done:
 392         return result;
 393 }
 394
 395 /* Enumerate the LSA SIDS */
 396
 397 static NTSTATUS cmd_lsa_enum_sids(struct cli_state *cli,
 398                                   TALLOC_CTX *mem_ctx, int argc,
 399                                   const char **argv)
 400 {
 401         POLICY_HND pol;
 402         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 403
 404         uint32 enum_context=0;
 405         uint32 pref_max_length=0x1000;
 406         DOM_SID *sids;
 407         uint32 count=0;
 408         int i;
 409
 410         if (argc > 3) {
 411                 printf("Usage: %s [enum context] [max length]\n", argv[0]);
 412                 return NT_STATUS_OK;
 413         }
 414
 415         if (argc>=2)
 416                 enum_context=atoi(argv[1]);
 417
 418         if (argc==3)
 419                 pref_max_length=atoi(argv[2]);
 420
 421         result = cli_lsa_open_policy(cli, mem_ctx, True,
 422                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 423                                      &pol);
 424
 425         if (!NT_STATUS_IS_OK(result))
 426                 goto done;
 427
 428         result = cli_lsa_enum_sids(cli, mem_ctx, &pol, &enum_context, pref_max_length,
 429                                         &count, &sids);
 430
 431         if (!NT_STATUS_IS_OK(result))
 432                 goto done;
 433
 434         /* Print results */
 435         printf("found %d SIDs\n\n", count);
 436
 437         for (i = 0; i < count; i++) {
 438                 fstring sid_str;
 439
 440                 sid_to_string(sid_str, &sids[i]);
 441                 printf("%s\n", sid_str);
 442         }
 443
 444  done:
 445         return result;
 446 }
 447
 448 /* Enumerate the privileges of an SID */
 449
 450 static NTSTATUS cmd_lsa_enum_privsaccounts(struct cli_state *cli,
 451                                            TALLOC_CTX *mem_ctx, int argc,
 452                                            const char **argv)
 453 {
 454         POLICY_HND dom_pol;
 455         POLICY_HND user_pol;
 456         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 457         uint32 access_desired = 0x000f000f;
 458
 459         DOM_SID sid;
 460         uint32 count=0;
 461         LUID_ATTR *set;
 462         int i;
 463
 464         if (argc != 2 ) {
 465                 printf("Usage: %s SID\n", argv[0]);
 466                 return NT_STATUS_OK;
 467         }
 468
 469         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 470         if (!NT_STATUS_IS_OK(result))
 471                 goto done;
 472
 473         result = cli_lsa_open_policy2(cli, mem_ctx, True,
 474                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 475                                      &dom_pol);
 476
 477         if (!NT_STATUS_IS_OK(result))
 478                 goto done;
 479
 480         result = cli_lsa_open_account(cli, mem_ctx, &dom_pol, &sid, access_desired, &user_pol);
 481
 482         if (!NT_STATUS_IS_OK(result))
 483                 goto done;
 484
 485         result = cli_lsa_enum_privsaccount(cli, mem_ctx, &user_pol, &count, &set);
 486
 487         if (!NT_STATUS_IS_OK(result))
 488                 goto done;
 489
 490         /* Print results */
 491         printf("found %d privileges for SID %s\n\n", count, argv[1]);
 492         printf("high\tlow\tattribute\n");
 493
 494         for (i = 0; i < count; i++) {
 495                 printf("%u\t%u\t%u\n", set[i].luid.high, set[i].luid.low, set[i].attr);
 496         }
 497
 498  done:
 499         return result;
 500 }
 501
 502
 503 /* Enumerate the privileges of an SID via LsaEnumerateAccountRights */
 504
 505 static NTSTATUS cmd_lsa_enum_acct_rights(struct cli_state *cli,
 506                                          TALLOC_CTX *mem_ctx, int argc,
 507                                          const char **argv)
 508 {
 509         POLICY_HND dom_pol;
 510         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 511
 512         DOM_SID sid;
 513         uint32 count;
 514         char **rights;
 515
 516         int i;
 517
 518         if (argc != 2 ) {
 519                 printf("Usage: %s SID\n", argv[0]);
 520                 return NT_STATUS_OK;
 521         }
 522
 523         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 524         if (!NT_STATUS_IS_OK(result))
 525                 goto done;
 526
 527         result = cli_lsa_open_policy2(cli, mem_ctx, True,
 528                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 529                                      &dom_pol);
 530
 531         if (!NT_STATUS_IS_OK(result))
 532                 goto done;
 533
 534         result = cli_lsa_enum_account_rights(cli, mem_ctx, &dom_pol, sid, &count, &rights);
 535
 536         if (!NT_STATUS_IS_OK(result))
 537                 goto done;
 538
 539         printf("found %d privileges for SID %s\n", count, sid_string_static(&sid));
 540
 541         for (i = 0; i < count; i++) {
 542                 printf("\t%s\n", rights[i]);
 543         }
 544
 545  done:
 546         return result;
 547 }
 548
 549
 550 /* add some privileges to a SID via LsaAddAccountRights */
 551
 552 static NTSTATUS cmd_lsa_add_acct_rights(struct cli_state *cli,
 553                                         TALLOC_CTX *mem_ctx, int argc,
 554                                         const char **argv)
 555 {
 556         POLICY_HND dom_pol;
 557         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 558
 559         DOM_SID sid;
 560
 561         if (argc < 3 ) {
 562                 printf("Usage: %s SID [rights...]\n", argv[0]);
 563                 return NT_STATUS_OK;
 564         }
 565
 566         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 567         if (!NT_STATUS_IS_OK(result))
 568                 goto done;
 569
 570         result = cli_lsa_open_policy2(cli, mem_ctx, True,
 571                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 572                                      &dom_pol);
 573
 574         if (!NT_STATUS_IS_OK(result))
 575                 goto done;
 576
 577         result = cli_lsa_add_account_rights(cli, mem_ctx, &dom_pol, sid,
 578                                             argc-2, argv+2);
 579
 580         if (!NT_STATUS_IS_OK(result))
 581                 goto done;
 582
 583  done:
 584         return result;
 585 }
 586
 587
 588 /* remove some privileges to a SID via LsaRemoveAccountRights */
 589
 590 static NTSTATUS cmd_lsa_remove_acct_rights(struct cli_state *cli,
 591                                         TALLOC_CTX *mem_ctx, int argc,
 592                                         const char **argv)
 593 {
 594         POLICY_HND dom_pol;
 595         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 596
 597         DOM_SID sid;
 598
 599         if (argc < 3 ) {
 600                 printf("Usage: %s SID [rights...]\n", argv[0]);
 601                 return NT_STATUS_OK;
 602         }
 603
 604         result = name_to_sid(cli, mem_ctx, &sid, argv[1]);
 605         if (!NT_STATUS_IS_OK(result))
 606                 goto done;
 607
 608         result = cli_lsa_open_policy2(cli, mem_ctx, True,
 609                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 610                                      &dom_pol);
 611
 612         if (!NT_STATUS_IS_OK(result))
 613                 goto done;
 614
 615         result = cli_lsa_remove_account_rights(cli, mem_ctx, &dom_pol, sid,
 616                                                False, argc-2, argv+2);
 617
 618         if (!NT_STATUS_IS_OK(result))
 619                 goto done;
 620
 621  done:
 622         return result;
 623 }
 624
 625
 626 /* Get a privilege value given its name */
 627
 628 static NTSTATUS cmd_lsa_lookupprivvalue(struct cli_state *cli,
 629                                         TALLOC_CTX *mem_ctx, int argc,
 630                                         const char **argv)
 631 {
 632         POLICY_HND pol;
 633         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 634         LUID luid;
 635
 636         if (argc != 2 ) {
 637                 printf("Usage: %s name\n", argv[0]);
 638                 return NT_STATUS_OK;
 639         }
 640
 641         result = cli_lsa_open_policy2(cli, mem_ctx, True,
 642                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
 643                                      &pol);
 644
 645         if (!NT_STATUS_IS_OK(result))
 646                 goto done;
 647
 648         result = cli_lsa_lookupprivvalue(cli, mem_ctx, &pol, argv[1], &luid);
 649
 650         if (!NT_STATUS_IS_OK(result))
 651                 goto done;
 652
 653         /* Print results */
 654
 655         printf("%u:%u (0x%x:0x%x)\n", luid.high, luid.low, luid.high, luid.low);
 656
 657  done:
 658         return result;
 659 }
 660
 661 /* Query LSA security object */
 662
 663 static NTSTATUS cmd_lsa_query_secobj(struct cli_state *cli,
 664                                      TALLOC_CTX *mem_ctx, int argc,
 665                                      const char **argv)
 666 {
 667         POLICY_HND pol;
 668         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 669         SEC_DESC_BUF *sdb;
 670         uint32 sec_info = 0x00000004; /* ??? */
 671
 672         if (argc != 1 ) {
 673                 printf("Usage: %s\n", argv[0]);
 674                 return NT_STATUS_OK;
 675         }
 676
 677         result = cli_lsa_open_policy2(cli, mem_ctx, True,
 678                                       SEC_RIGHTS_MAXIMUM_ALLOWED,
 679                                       &pol);
 680
 681         if (!NT_STATUS_IS_OK(result))
 682                 goto done;
 683
 684         result = cli_lsa_query_secobj(cli, mem_ctx, &pol, sec_info, &sdb);
 685
 686         if (!NT_STATUS_IS_OK(result))
 687                 goto done;
 688
 689         /* Print results */
 690
 691         display_sec_desc(sdb->sec);
 692
 693  done:
 694         return result;
 695 }
 696
 697
 698 /* List of commands exported by this module */
 699
 700 struct cmd_set lsarpc_commands[] = {
 701
 702         { "LSARPC" },
 703
 704         { "lsaquery",            RPC_RTYPE_NTSTATUS, cmd_lsa_query_info_policy,  NULL, PI_LSARPC, "Query info policy",                    "" },
 705         { "lookupsids",          RPC_RTYPE_NTSTATUS, cmd_lsa_lookup_sids,        NULL, PI_LSARPC, "Convert SIDs to names",                "" },
 706         { "lookupnames",         RPC_RTYPE_NTSTATUS, cmd_lsa_lookup_names,       NULL, PI_LSARPC, "Convert names to SIDs",                "" },
 707         { "enumtrust",           RPC_RTYPE_NTSTATUS, cmd_lsa_enum_trust_dom,     NULL, PI_LSARPC, "Enumerate trusted domains",            "Usage: [preferred max number] [enum context (0)]" },
 708         { "enumprivs",           RPC_RTYPE_NTSTATUS, cmd_lsa_enum_privilege,     NULL, PI_LSARPC, "Enumerate privileges",                 "" },
 709         { "getdispname",         RPC_RTYPE_NTSTATUS, cmd_lsa_get_dispname,       NULL, PI_LSARPC, "Get the privilege name",               "" },
 710         { "lsaenumsid",          RPC_RTYPE_NTSTATUS, cmd_lsa_enum_sids,          NULL, PI_LSARPC, "Enumerate the LSA SIDS",               "" },
 711         { "lsaenumprivsaccount", RPC_RTYPE_NTSTATUS, cmd_lsa_enum_privsaccounts, NULL, PI_LSARPC, "Enumerate the privileges of an SID",   "" },
 712         { "lsaenumacctrights",   RPC_RTYPE_NTSTATUS, cmd_lsa_enum_acct_rights,   NULL, PI_LSARPC, "Enumerate the rights of an SID",   "" },
 713         { "lsaaddacctrights",    RPC_RTYPE_NTSTATUS, cmd_lsa_add_acct_rights,    NULL, PI_LSARPC, "Add rights to an account",   "" },
 714         { "lsaremoveacctrights", RPC_RTYPE_NTSTATUS, cmd_lsa_remove_acct_rights, NULL, PI_LSARPC, "Remove rights from an account",   "" },
 715         { "lsalookupprivvalue",  RPC_RTYPE_NTSTATUS, cmd_lsa_lookupprivvalue,    NULL, PI_LSARPC, "Get a privilege value given its name", "" },
 716         { "lsaquerysecobj",      RPC_RTYPE_NTSTATUS, cmd_lsa_query_secobj,       NULL, PI_LSARPC, "Query LSA security object", "" },
 717
 718         { NULL }
 719 };