source/torture/rpc/lsa.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for lsa rpc operations
   4
   5    Copyright (C) Andrew Tridgell 2003
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 static void init_lsa_Name(struct lsa_Name *name, const char *s)
  25 {
  26         name->name = s;
  27 }
  28
  29 static BOOL test_OpenPolicy(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
  30 {
  31         struct lsa_ObjectAttribute attr;
  32         struct policy_handle handle;
  33         struct lsa_QosInfo qos;
  34         struct lsa_OpenPolicy r;
  35         NTSTATUS status;
  36         uint16 system_name = '\\';
  37
  38         printf("\ntesting OpenPolicy\n");
  39
  40         qos.len = 0;
  41         qos.impersonation_level = 2;
  42         qos.context_mode = 1;
  43         qos.effective_only = 0;
  44
  45         attr.len = 0;
  46         attr.root_dir = NULL;
  47         attr.object_name = NULL;
  48         attr.attributes = 0;
  49         attr.sec_desc = NULL;
  50         attr.sec_qos = &qos;
  51
  52         r.in.system_name = &system_name;
  53         r.in.attr = &attr;
  54         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
  55         r.out.handle = &handle;
  56
  57         status = dcerpc_lsa_OpenPolicy(p, mem_ctx, &r);
  58         if (!NT_STATUS_IS_OK(status)) {
  59                 printf("OpenPolicy failed - %s\n", nt_errstr(status));
  60                 return False;
  61         }
  62
  63         return True;
  64 }
  65
  66
  67 static BOOL test_OpenPolicy2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
  68                              struct policy_handle *handle)
  69 {
  70         struct lsa_ObjectAttribute attr;
  71         struct lsa_QosInfo qos;
  72         struct lsa_OpenPolicy2 r;
  73         NTSTATUS status;
  74
  75         printf("\ntesting OpenPolicy2\n");
  76
  77         qos.len = 0;
  78         qos.impersonation_level = 2;
  79         qos.context_mode = 1;
  80         qos.effective_only = 0;
  81
  82         attr.len = 0;
  83         attr.root_dir = NULL;
  84         attr.object_name = NULL;
  85         attr.attributes = 0;
  86         attr.sec_desc = NULL;
  87         attr.sec_qos = &qos;
  88
  89         r.in.system_name = "\\";
  90         r.in.attr = &attr;
  91         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
  92         r.out.handle = handle;
  93
  94         status = dcerpc_lsa_OpenPolicy2(p, mem_ctx, &r);
  95         if (!NT_STATUS_IS_OK(status)) {
  96                 printf("OpenPolicy2 failed - %s\n", nt_errstr(status));
  97                 return False;
  98         }
  99
 100         return True;
 101 }
 102
 103 static BOOL test_LookupNames(struct dcerpc_pipe *p,
 104                             TALLOC_CTX *mem_ctx,
 105                             struct policy_handle *handle,
 106                             struct lsa_TransNameArray *tnames)
 107 {
 108         struct lsa_LookupNames r;
 109         struct lsa_TransSidArray sids;
 110         struct lsa_Name *names;
 111         uint32 count = 0;
 112         NTSTATUS status;
 113         int i;
 114
 115         printf("\nTesting LookupNames\n");
 116
 117         sids.count = 0;
 118         sids.sids = NULL;
 119
 120         names = talloc(mem_ctx, tnames->count * sizeof(names[0]));
 121         for (i=0;i<tnames->count;i++) {
 122                 init_lsa_Name(&names[i], tnames->names[i].name.name);
 123         }
 124
 125         r.in.handle = handle;
 126         r.in.num_names = tnames->count;
 127         r.in.names = names;
 128         r.in.sids = &sids;
 129         r.in.level = 1;
 130         r.in.count = &count;
 131         r.out.count = &count;
 132         r.out.sids = &sids;
 133
 134         status = dcerpc_lsa_LookupNames(p, mem_ctx, &r);
 135         if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
 136                 printf("LookupNames failed - %s\n", nt_errstr(status));
 137                 return False;
 138         }
 139
 140         printf("\n");
 141
 142         return True;
 143 }
 144
 145
 146 static BOOL test_LookupSids(struct dcerpc_pipe *p,
 147                             TALLOC_CTX *mem_ctx,
 148                             struct policy_handle *handle,
 149                             struct lsa_SidArray *sids)
 150 {
 151         struct lsa_LookupSids r;
 152         struct lsa_TransNameArray names;
 153         uint32 count = sids->num_sids;
 154         NTSTATUS status;
 155
 156         printf("\nTesting LookupSids\n");
 157
 158         names.count = 0;
 159         names.names = NULL;
 160
 161         r.in.handle = handle;
 162         r.in.sids = sids;
 163         r.in.names = &names;
 164         r.in.level = 1;
 165         r.in.count = &count;
 166         r.out.count = &count;
 167         r.out.names = &names;
 168
 169         status = dcerpc_lsa_LookupSids(p, mem_ctx, &r);
 170         if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
 171                 printf("LookupSids failed - %s\n", nt_errstr(status));
 172                 return False;
 173         }
 174
 175         printf("\n");
 176
 177         if (!test_LookupNames(p, mem_ctx, handle, &names)) {
 178                 return False;
 179         }
 180
 181         return True;
 182 }
 183
 184 static BOOL test_LookupPrivName(struct dcerpc_pipe *p,
 185                                 TALLOC_CTX *mem_ctx,
 186                                 struct policy_handle *handle,
 187                                 struct lsa_LUID *luid)
 188 {
 189         NTSTATUS status;
 190         struct lsa_LookupPrivName r;
 191
 192         r.in.handle = handle;
 193         r.in.luid = luid;
 194
 195         status = dcerpc_lsa_LookupPrivName(p, mem_ctx, &r);
 196         if (!NT_STATUS_IS_OK(status)) {
 197                 printf("\nLookupPrivName failed - %s\n", nt_errstr(status));
 198                 return False;
 199         }
 200
 201         return True;
 202 }
 203
 204 static BOOL test_EnumPrivsAccount(struct dcerpc_pipe *p,
 205                                   TALLOC_CTX *mem_ctx,
 206                                   struct policy_handle *handle,
 207                                   struct policy_handle *acct_handle)
 208 {
 209         NTSTATUS status;
 210         struct lsa_EnumPrivsAccount r;
 211
 212         printf("Testing EnumPrivsAccount\n");
 213
 214         r.in.handle = acct_handle;
 215
 216         status = dcerpc_lsa_EnumPrivsAccount(p, mem_ctx, &r);
 217         if (!NT_STATUS_IS_OK(status)) {
 218                 printf("EnumPrivsAccount failed - %s\n", nt_errstr(status));
 219                 return False;
 220         }
 221
 222         if (r.out.privs) {
 223                 int i;
 224                 for (i=0;i<r.out.privs->count;i++) {
 225                         test_LookupPrivName(p, mem_ctx, handle,
 226                                             &r.out.privs->set[i].luid);
 227                 }
 228         }
 229
 230         return True;
 231 }
 232
 233 static BOOL test_Delete(struct dcerpc_pipe *p,
 234                        TALLOC_CTX *mem_ctx,
 235                        struct policy_handle *handle)
 236 {
 237         NTSTATUS status;
 238         struct lsa_Delete r;
 239
 240         printf("\ntesting Delete\n");
 241
 242         r.in.handle = handle;
 243         status = dcerpc_lsa_Delete(p, mem_ctx, &r);
 244         if (!NT_STATUS_IS_OK(status)) {
 245                 printf("Delete failed - %s\n", nt_errstr(status));
 246                 return False;
 247         }
 248
 249         printf("\n");
 250
 251         return True;
 252 }
 253
 254
 255 static BOOL find_domain_sid(struct dcerpc_pipe *p,
 256                             TALLOC_CTX *mem_ctx,
 257                             struct policy_handle *handle,
 258                             struct dom_sid2 **sid)
 259 {
 260         struct lsa_QueryInfoPolicy r;
 261         NTSTATUS status;
 262
 263         r.in.handle = handle;
 264         r.in.level = LSA_POLICY_INFO_DOMAIN;
 265
 266         status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
 267
 268         if (!NT_STATUS_IS_OK(status)) {
 269                 printf("LSA_POLICY_INFO_DOMAIN failed - %s\n", nt_errstr(status));
 270                 return False;
 271         }
 272
 273         *sid = r.out.info->domain.sid;
 274
 275         return True;
 276 }
 277
 278 static struct dom_sid *sid_add_auth(TALLOC_CTX *mem_ctx,
 279                                     const struct dom_sid *sid,
 280                                     uint32 sub_auth)
 281 {
 282         struct dom_sid *ret;
 283
 284         ret = talloc_p(mem_ctx, struct dom_sid);
 285         if (!ret) {
 286                 return NULL;
 287         }
 288
 289         *ret = *sid;
 290
 291         ret->sub_auths = talloc_array_p(mem_ctx, uint32, ret->num_auths+1);
 292         if (!ret->sub_auths) {
 293                 return NULL;
 294         }
 295
 296         memcpy(ret->sub_auths, sid->sub_auths,
 297                ret->num_auths * sizeof(sid->sub_auths[0]));
 298         ret->sub_auths[ret->num_auths] = sub_auth;
 299         ret->num_auths++;
 300
 301         return ret;
 302 }
 303
 304 static BOOL test_CreateAccount(struct dcerpc_pipe *p,
 305                                TALLOC_CTX *mem_ctx,
 306                                struct policy_handle *handle)
 307 {
 308         NTSTATUS status;
 309         struct lsa_CreateAccount r;
 310         struct dom_sid2 *domsid, *newsid;
 311         struct policy_handle acct_handle;
 312
 313         if (!find_domain_sid(p, mem_ctx, handle, &domsid)) {
 314                 return False;
 315         }
 316
 317         newsid = sid_add_auth(mem_ctx, domsid, 0x1234abcd);
 318         if (!newsid) {
 319                 printf("Failed to create newsid\n");
 320                 return False;
 321         }
 322
 323         printf("Testing CreateAccount\n");
 324
 325         r.in.handle = handle;
 326         r.in.sid = newsid;
 327         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 328         r.out.acct_handle = &acct_handle;
 329
 330         status = dcerpc_lsa_CreateAccount(p, mem_ctx, &r);
 331         if (!NT_STATUS_IS_OK(status)) {
 332                 printf("CreateAccount failed - %s\n", nt_errstr(status));
 333                 return False;
 334         }
 335
 336         if (!test_Delete(p, mem_ctx, &acct_handle)) {
 337                 return False;
 338         }
 339
 340         return True;
 341 }
 342
 343
 344 static BOOL test_CreateTrustedDomain(struct dcerpc_pipe *p,
 345                                      TALLOC_CTX *mem_ctx,
 346                                      struct policy_handle *handle)
 347 {
 348         NTSTATUS status;
 349         struct lsa_CreateTrustedDomain r;
 350         struct lsa_TrustInformation trustinfo;
 351         struct dom_sid *domsid;
 352         struct policy_handle dom_handle;
 353
 354         printf("Testing CreateTrustedDomain\n");
 355
 356         if (!find_domain_sid(p, mem_ctx, handle, &domsid)) {
 357                 return False;
 358         }
 359
 360         domsid->sub_auths[domsid->num_auths-1] ^= 0xF0F0F0F0;
 361
 362         trustinfo.sid = domsid;
 363         init_lsa_Name(&trustinfo.name, "torturedomain");
 364
 365         r.in.handle = handle;
 366         r.in.info = &trustinfo;
 367         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 368         r.out.dom_handle = &dom_handle;
 369
 370         status = dcerpc_lsa_CreateTrustedDomain(p, mem_ctx, &r);
 371         if (!NT_STATUS_IS_OK(status)) {
 372                 printf("CreateTrustedDomain failed - %s\n", nt_errstr(status));
 373                 return False;
 374         }
 375
 376         if (!test_Delete(p, mem_ctx, &dom_handle)) {
 377                 return False;
 378         }
 379
 380         return True;
 381 }
 382
 383 static BOOL test_CreateSecret(struct dcerpc_pipe *p,
 384                               TALLOC_CTX *mem_ctx,
 385                               struct policy_handle *handle)
 386 {
 387         NTSTATUS status;
 388         struct lsa_CreateSecret r;
 389         struct lsa_OpenSecret r2;
 390         struct policy_handle sec_handle, sec_handle2;
 391         struct lsa_Delete d;
 392
 393         printf("Testing CreateSecret\n");
 394
 395         init_lsa_Name(&r.in.name, "torturesecret");
 396
 397         r.in.handle = handle;
 398         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 399         r.out.sec_handle = &sec_handle;
 400
 401         status = dcerpc_lsa_CreateSecret(p, mem_ctx, &r);
 402         if (!NT_STATUS_IS_OK(status)) {
 403                 printf("CreateSecret failed - %s\n", nt_errstr(status));
 404                 return False;
 405         }
 406
 407         r2.in.handle = handle;
 408         r2.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 409         init_lsa_Name(&r2.in.name, "torturesecret");
 410         r2.out.sec_handle = &sec_handle2;
 411
 412         printf("Testing OpenSecret\n");
 413
 414         status = dcerpc_lsa_OpenSecret(p, mem_ctx, &r2);
 415         if (!NT_STATUS_IS_OK(status)) {
 416                 printf("OpenSecret failed - %s\n", nt_errstr(status));
 417                 return False;
 418         }
 419
 420         if (!test_Delete(p, mem_ctx, &sec_handle)) {
 421                 return False;
 422         }
 423
 424         d.in.handle = &sec_handle2;
 425         status = dcerpc_lsa_Delete(p, mem_ctx, &d);
 426         if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
 427                 printf("Second delete expected INVALID_HANDLE - %s\n", nt_errstr(status));
 428                 return False;
 429         }
 430
 431         return True;
 432 }
 433
 434 static BOOL test_EnumAccountRights(struct dcerpc_pipe *p,
 435                                    TALLOC_CTX *mem_ctx,
 436                                    struct policy_handle *acct_handle,
 437                                    struct dom_sid *sid)
 438 {
 439         NTSTATUS status;
 440         struct lsa_EnumAccountRights r;
 441         struct lsa_RightSet rights;
 442
 443         printf("Testing EnumAccountRights\n");
 444
 445         r.in.handle = acct_handle;
 446         r.in.sid = sid;
 447         r.out.rights = &rights;
 448
 449         status = dcerpc_lsa_EnumAccountRights(p, mem_ctx, &r);
 450         if (!NT_STATUS_IS_OK(status)) {
 451                 printf("EnumAccountRights failed - %s\n", nt_errstr(status));
 452                 return False;
 453         }
 454
 455         return True;
 456 }
 457
 458
 459 static BOOL test_QuerySecObj(struct dcerpc_pipe *p,
 460                              TALLOC_CTX *mem_ctx,
 461                              struct policy_handle *handle,
 462                              struct policy_handle *acct_handle)
 463 {
 464         NTSTATUS status;
 465         struct lsa_QuerySecObj r;
 466
 467         printf("Testing QuerySecObj\n");
 468
 469         r.in.handle = acct_handle;
 470         r.in.sec_info = 7;
 471
 472         status = dcerpc_lsa_QuerySecObj(p, mem_ctx, &r);
 473         if (!NT_STATUS_IS_OK(status)) {
 474                 printf("QuerySecObj failed - %s\n", nt_errstr(status));
 475                 return False;
 476         }
 477
 478         return True;
 479 }
 480
 481 static BOOL test_OpenAccount(struct dcerpc_pipe *p,
 482                              TALLOC_CTX *mem_ctx,
 483                              struct policy_handle *handle,
 484                              struct dom_sid *sid)
 485 {
 486         NTSTATUS status;
 487         struct lsa_OpenAccount r;
 488         struct policy_handle acct_handle;
 489
 490         printf("Testing OpenAccount\n");
 491
 492         r.in.handle = handle;
 493         r.in.sid = sid;
 494         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 495         r.out.acct_handle = &acct_handle;
 496
 497         status = dcerpc_lsa_OpenAccount(p, mem_ctx, &r);
 498         if (!NT_STATUS_IS_OK(status)) {
 499                 printf("OpenAccount failed - %s\n", nt_errstr(status));
 500                 return False;
 501         }
 502
 503         if (!test_EnumPrivsAccount(p, mem_ctx, handle, &acct_handle)) {
 504                 return False;
 505         }
 506
 507         if (!test_QuerySecObj(p, mem_ctx, handle, &acct_handle)) {
 508                 return False;
 509         }
 510
 511         return True;
 512 }
 513
 514 static BOOL test_EnumAccounts(struct dcerpc_pipe *p,
 515                           TALLOC_CTX *mem_ctx,
 516                           struct policy_handle *handle)
 517 {
 518         NTSTATUS status;
 519         struct lsa_EnumAccounts r;
 520         struct lsa_SidArray sids1, sids2;
 521         uint32 resume_handle = 0;
 522         int i;
 523
 524         printf("\ntesting EnumAccounts\n");
 525
 526         r.in.handle = handle;
 527         r.in.resume_handle = &resume_handle;
 528         r.in.num_entries = 100;
 529         r.out.resume_handle = &resume_handle;
 530         r.out.sids = &sids1;
 531
 532         resume_handle = 0;
 533         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
 534         if (!NT_STATUS_IS_OK(status)) {
 535                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
 536                 return False;
 537         }
 538
 539         if (!test_LookupSids(p, mem_ctx, handle, &sids1)) {
 540                 return False;
 541         }
 542
 543         printf("testing all accounts\n");
 544         for (i=0;i<sids1.num_sids;i++) {
 545                 test_OpenAccount(p, mem_ctx, handle, sids1.sids[i].sid);
 546                 test_EnumAccountRights(p, mem_ctx, handle, sids1.sids[i].sid);
 547         }
 548         printf("\n");
 549
 550         if (sids1.num_sids < 3) {
 551                 return True;
 552         }
 553
 554         printf("trying EnumAccounts partial listing (asking for 1 at 2)\n");
 555         resume_handle = 2;
 556         r.in.num_entries = 1;
 557         r.out.sids = &sids2;
 558
 559         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
 560         if (!NT_STATUS_IS_OK(status)) {
 561                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
 562                 return False;
 563         }
 564
 565         if (sids2.num_sids != 1) {
 566                 printf("Returned wrong number of entries (%d)\n", sids2.num_sids);
 567                 return False;
 568         }
 569
 570         return True;
 571 }
 572
 573
 574 static BOOL test_EnumPrivs(struct dcerpc_pipe *p,
 575                            TALLOC_CTX *mem_ctx,
 576                            struct policy_handle *handle)
 577 {
 578         NTSTATUS status;
 579         struct lsa_EnumPrivs r;
 580         struct lsa_PrivArray privs1;
 581         uint32 resume_handle = 0;
 582
 583         printf("\ntesting EnumPrivs\n");
 584
 585         r.in.handle = handle;
 586         r.in.resume_handle = &resume_handle;
 587         r.in.max_count = 1000;
 588         r.out.resume_handle = &resume_handle;
 589         r.out.privs = &privs1;
 590
 591         resume_handle = 0;
 592         status = dcerpc_lsa_EnumPrivs(p, mem_ctx, &r);
 593         if (!NT_STATUS_IS_OK(status)) {
 594                 printf("EnumPrivs failed - %s\n", nt_errstr(status));
 595                 return False;
 596         }
 597
 598         return True;
 599 }
 600
 601
 602 static BOOL test_EnumTrustDom(struct dcerpc_pipe *p,
 603                               TALLOC_CTX *mem_ctx,
 604                               struct policy_handle *handle)
 605 {
 606         struct lsa_EnumTrustDom r;
 607         NTSTATUS status;
 608         uint32 resume_handle = 0;
 609         struct lsa_DomainList domains;
 610
 611         printf("\nTesting EnumTrustDom\n");
 612
 613         r.in.handle = handle;
 614         r.in.resume_handle = &resume_handle;
 615         r.in.num_entries = 1000;
 616         r.out.domains = &domains;
 617         r.out.resume_handle = &resume_handle;
 618
 619         status = dcerpc_lsa_EnumTrustDom(p, mem_ctx, &r);
 620
 621         /* NO_MORE_ENTRIES is allowed */
 622         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
 623                 return True;
 624         }
 625
 626         if (!NT_STATUS_IS_OK(status)) {
 627                 printf("EnumTrustDom failed - %s\n", nt_errstr(status));
 628                 return False;
 629         }
 630
 631         return True;
 632 }
 633
 634 static BOOL test_QueryInfoPolicy(struct dcerpc_pipe *p,
 635                                  TALLOC_CTX *mem_ctx,
 636                                  struct policy_handle *handle)
 637 {
 638         struct lsa_QueryInfoPolicy r;
 639         NTSTATUS status;
 640         int i;
 641         BOOL ret = True;
 642         printf("\nTesting QueryInfoPolicy\n");
 643
 644         for (i=1;i<13;i++) {
 645                 r.in.handle = handle;
 646                 r.in.level = i;
 647
 648                 printf("\ntrying QueryInfoPolicy level %d\n", i);
 649
 650                 status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
 651
 652                 if ((i == 9 || i == 10 || i == 11) &&
 653                     NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
 654                         printf("server failed level %u (OK)\n", i);
 655                         continue;
 656                 }
 657
 658                 if (!NT_STATUS_IS_OK(status)) {
 659                         printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
 660                         ret = False;
 661                         continue;
 662                 }
 663         }
 664
 665         return ret;
 666 }
 667
 668 static BOOL test_Close(struct dcerpc_pipe *p,
 669                        TALLOC_CTX *mem_ctx,
 670                        struct policy_handle *handle)
 671 {
 672         NTSTATUS status;
 673         struct lsa_Close r;
 674         struct policy_handle handle2;
 675
 676         printf("\ntesting Close\n");
 677
 678         r.in.handle = handle;
 679         r.out.handle = &handle2;
 680
 681         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 682         if (!NT_STATUS_IS_OK(status)) {
 683                 printf("Close failed - %s\n", nt_errstr(status));
 684                 return False;
 685         }
 686
 687         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 688         /* its really a fault - we need a status code for rpc fault */
 689         if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 690                 printf("Close failed - %s\n", nt_errstr(status));
 691                 return False;
 692         }
 693
 694         printf("\n");
 695
 696         return True;
 697 }
 698
 699 BOOL torture_rpc_lsa(int dummy)
 700 {
 701         NTSTATUS status;
 702         struct dcerpc_pipe *p;
 703         TALLOC_CTX *mem_ctx;
 704         BOOL ret = True;
 705         struct policy_handle handle;
 706
 707         mem_ctx = talloc_init("torture_rpc_lsa");
 708
 709         status = torture_rpc_connection(&p,
 710                                         DCERPC_LSARPC_NAME,
 711                                         DCERPC_LSARPC_UUID,
 712                                         DCERPC_LSARPC_VERSION);
 713         if (!NT_STATUS_IS_OK(status)) {
 714                 return False;
 715         }
 716
 717         if (!test_OpenPolicy(p, mem_ctx)) {
 718                 ret = False;
 719         }
 720
 721         if (!test_OpenPolicy2(p, mem_ctx, &handle)) {
 722                 ret = False;
 723         }
 724
 725         if (!test_CreateAccount(p, mem_ctx, &handle)) {
 726                 ret = False;
 727         }
 728
 729         if (!test_CreateSecret(p, mem_ctx, &handle)) {
 730                 ret = False;
 731         }
 732
 733         if (!test_CreateTrustedDomain(p, mem_ctx, &handle)) {
 734                 ret = False;
 735         }
 736
 737         if (!test_EnumAccounts(p, mem_ctx, &handle)) {
 738                 ret = False;
 739         }
 740
 741         if (!test_EnumPrivs(p, mem_ctx, &handle)) {
 742                 ret = False;
 743         }
 744
 745         if (!test_EnumTrustDom(p, mem_ctx, &handle)) {
 746                 ret = False;
 747         }
 748
 749         if (!test_QueryInfoPolicy(p, mem_ctx, &handle)) {
 750                 ret = False;
 751         }
 752
 753 #if 0
 754         if (!test_Delete(p, mem_ctx, &handle)) {
 755                 ret = False;
 756         }
 757 #endif
 758
 759         if (!test_Close(p, mem_ctx, &handle)) {
 760                 ret = False;
 761         }
 762
 763         talloc_destroy(mem_ctx);
 764
 765         torture_rpc_close(p);
 766
 767         return ret;
 768 }