source4/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.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 static BOOL test_EnumAccountRights(struct dcerpc_pipe *p,
 344                                    TALLOC_CTX *mem_ctx,
 345                                    struct policy_handle *acct_handle,
 346                                    struct dom_sid *sid)
 347 {
 348         NTSTATUS status;
 349         struct lsa_EnumAccountRights r;
 350         struct lsa_RightSet rights;
 351
 352         printf("Testing EnumAccountRights\n");
 353
 354         r.in.handle = acct_handle;
 355         r.in.sid = sid;
 356         r.out.rights = &rights;
 357
 358         status = dcerpc_lsa_EnumAccountRights(p, mem_ctx, &r);
 359         if (!NT_STATUS_IS_OK(status)) {
 360                 printf("EnumAccountRights failed - %s\n", nt_errstr(status));
 361                 return False;
 362         }
 363
 364         return True;
 365 }
 366
 367
 368 static BOOL test_QuerySecObj(struct dcerpc_pipe *p,
 369                              TALLOC_CTX *mem_ctx,
 370                              struct policy_handle *handle,
 371                              struct policy_handle *acct_handle)
 372 {
 373         NTSTATUS status;
 374         struct lsa_QuerySecObj r;
 375
 376         printf("Testing QuerySecObj\n");
 377
 378         r.in.handle = acct_handle;
 379         r.in.sec_info = 7;
 380
 381         status = dcerpc_lsa_QuerySecObj(p, mem_ctx, &r);
 382         if (!NT_STATUS_IS_OK(status)) {
 383                 printf("QuerySecObj failed - %s\n", nt_errstr(status));
 384                 return False;
 385         }
 386
 387         return True;
 388 }
 389
 390 static BOOL test_OpenAccount(struct dcerpc_pipe *p,
 391                              TALLOC_CTX *mem_ctx,
 392                              struct policy_handle *handle,
 393                              struct dom_sid *sid)
 394 {
 395         NTSTATUS status;
 396         struct lsa_OpenAccount r;
 397         struct policy_handle acct_handle;
 398
 399         printf("Testing OpenAccount\n");
 400
 401         r.in.handle = handle;
 402         r.in.sid = sid;
 403         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
 404         r.out.acct_handle = &acct_handle;
 405
 406         status = dcerpc_lsa_OpenAccount(p, mem_ctx, &r);
 407         if (!NT_STATUS_IS_OK(status)) {
 408                 printf("OpenAccount failed - %s\n", nt_errstr(status));
 409                 return False;
 410         }
 411
 412         if (!test_EnumPrivsAccount(p, mem_ctx, handle, &acct_handle)) {
 413                 return False;
 414         }
 415
 416         if (!test_QuerySecObj(p, mem_ctx, handle, &acct_handle)) {
 417                 return False;
 418         }
 419
 420         return True;
 421 }
 422
 423 static BOOL test_EnumAccounts(struct dcerpc_pipe *p,
 424                           TALLOC_CTX *mem_ctx,
 425                           struct policy_handle *handle)
 426 {
 427         NTSTATUS status;
 428         struct lsa_EnumAccounts r;
 429         struct lsa_SidArray sids1, sids2;
 430         uint32 resume_handle = 0;
 431         int i;
 432
 433         printf("\ntesting EnumAccounts\n");
 434
 435         r.in.handle = handle;
 436         r.in.resume_handle = &resume_handle;
 437         r.in.num_entries = 100;
 438         r.out.resume_handle = &resume_handle;
 439         r.out.sids = &sids1;
 440
 441         resume_handle = 0;
 442         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
 443         if (!NT_STATUS_IS_OK(status)) {
 444                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
 445                 return False;
 446         }
 447
 448         if (!test_LookupSids(p, mem_ctx, handle, &sids1)) {
 449                 return False;
 450         }
 451
 452         printf("testing all accounts\n");
 453         for (i=0;i<sids1.num_sids;i++) {
 454                 test_OpenAccount(p, mem_ctx, handle, sids1.sids[i].sid);
 455                 test_EnumAccountRights(p, mem_ctx, handle, sids1.sids[i].sid);
 456         }
 457         printf("\n");
 458
 459         if (sids1.num_sids < 3) {
 460                 return True;
 461         }
 462
 463         printf("trying EnumAccounts partial listing (asking for 1 at 2)\n");
 464         resume_handle = 2;
 465         r.in.num_entries = 1;
 466         r.out.sids = &sids2;
 467
 468         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
 469         if (!NT_STATUS_IS_OK(status)) {
 470                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
 471                 return False;
 472         }
 473
 474         if (sids2.num_sids != 1) {
 475                 printf("Returned wrong number of entries (%d)\n", sids2.num_sids);
 476                 return False;
 477         }
 478
 479         return True;
 480 }
 481
 482
 483 static BOOL test_EnumPrivs(struct dcerpc_pipe *p,
 484                            TALLOC_CTX *mem_ctx,
 485                            struct policy_handle *handle)
 486 {
 487         NTSTATUS status;
 488         struct lsa_EnumPrivs r;
 489         struct lsa_PrivArray privs1;
 490         uint32 resume_handle = 0;
 491
 492         printf("\ntesting EnumPrivs\n");
 493
 494         r.in.handle = handle;
 495         r.in.resume_handle = &resume_handle;
 496         r.in.max_count = 1000;
 497         r.out.resume_handle = &resume_handle;
 498         r.out.privs = &privs1;
 499
 500         resume_handle = 0;
 501         status = dcerpc_lsa_EnumPrivs(p, mem_ctx, &r);
 502         if (!NT_STATUS_IS_OK(status)) {
 503                 printf("EnumPrivs failed - %s\n", nt_errstr(status));
 504                 return False;
 505         }
 506
 507         return True;
 508 }
 509
 510
 511 static BOOL test_EnumTrustDom(struct dcerpc_pipe *p,
 512                               TALLOC_CTX *mem_ctx,
 513                               struct policy_handle *handle)
 514 {
 515         struct lsa_EnumTrustDom r;
 516         NTSTATUS status;
 517         uint32 resume_handle = 0;
 518         struct lsa_DomainList domains;
 519
 520         printf("\nTesting EnumTrustDom\n");
 521
 522         r.in.handle = handle;
 523         r.in.resume_handle = &resume_handle;
 524         r.in.num_entries = 1000;
 525         r.out.domains = &domains;
 526         r.out.resume_handle = &resume_handle;
 527
 528         status = dcerpc_lsa_EnumTrustDom(p, mem_ctx, &r);
 529
 530         /* NO_MORE_ENTRIES is allowed */
 531         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
 532                 return True;
 533         }
 534
 535         if (!NT_STATUS_IS_OK(status)) {
 536                 printf("EnumTrustDom failed - %s\n", nt_errstr(status));
 537                 return False;
 538         }
 539
 540         return True;
 541 }
 542
 543 static BOOL test_QueryInfoPolicy(struct dcerpc_pipe *p,
 544                                  TALLOC_CTX *mem_ctx,
 545                                  struct policy_handle *handle)
 546 {
 547         struct lsa_QueryInfoPolicy r;
 548         NTSTATUS status;
 549         int i;
 550         BOOL ret = True;
 551         printf("\nTesting QueryInfoPolicy\n");
 552
 553         for (i=1;i<13;i++) {
 554                 r.in.handle = handle;
 555                 r.in.level = i;
 556
 557                 printf("\ntrying QueryInfoPolicy level %d\n", i);
 558
 559                 status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
 560
 561                 if ((i == 9 || i == 10 || i == 11) &&
 562                     NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
 563                         printf("server failed level %u (OK)\n", i);
 564                         continue;
 565                 }
 566
 567                 if (!NT_STATUS_IS_OK(status)) {
 568                         printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
 569                         ret = False;
 570                         continue;
 571                 }
 572         }
 573
 574         return ret;
 575 }
 576
 577 static BOOL test_Close(struct dcerpc_pipe *p,
 578                        TALLOC_CTX *mem_ctx,
 579                        struct policy_handle *handle)
 580 {
 581         NTSTATUS status;
 582         struct lsa_Close r;
 583         struct policy_handle handle2;
 584
 585         printf("\ntesting Close\n");
 586
 587         r.in.handle = handle;
 588         r.out.handle = &handle2;
 589
 590         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 591         if (!NT_STATUS_IS_OK(status)) {
 592                 printf("Close failed - %s\n", nt_errstr(status));
 593                 return False;
 594         }
 595
 596         status = dcerpc_lsa_Close(p, mem_ctx, &r);
 597         /* its really a fault - we need a status code for rpc fault */
 598         if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 599                 printf("Close failed - %s\n", nt_errstr(status));
 600                 return False;
 601         }
 602
 603         printf("\n");
 604
 605         return True;
 606 }
 607
 608 BOOL torture_rpc_lsa(int dummy)
 609 {
 610         NTSTATUS status;
 611         struct dcerpc_pipe *p;
 612         TALLOC_CTX *mem_ctx;
 613         BOOL ret = True;
 614         struct policy_handle handle;
 615
 616         mem_ctx = talloc_init("torture_rpc_lsa");
 617
 618         status = torture_rpc_connection(&p,
 619                                         DCERPC_LSARPC_NAME,
 620                                         DCERPC_LSARPC_UUID,
 621                                         DCERPC_LSARPC_VERSION);
 622         if (!NT_STATUS_IS_OK(status)) {
 623                 return False;
 624         }
 625
 626         if (!test_OpenPolicy(p, mem_ctx)) {
 627                 ret = False;
 628         }
 629
 630         if (!test_OpenPolicy2(p, mem_ctx, &handle)) {
 631                 ret = False;
 632         }
 633
 634         if (!test_CreateAccount(p, mem_ctx, &handle)) {
 635                 ret = False;
 636         }
 637
 638         if (!test_EnumAccounts(p, mem_ctx, &handle)) {
 639                 ret = False;
 640         }
 641
 642         if (!test_EnumPrivs(p, mem_ctx, &handle)) {
 643                 ret = False;
 644         }
 645
 646         if (!test_EnumTrustDom(p, mem_ctx, &handle)) {
 647                 ret = False;
 648         }
 649
 650         if (!test_QueryInfoPolicy(p, mem_ctx, &handle)) {
 651                 ret = False;
 652         }
 653
 654 #if 0
 655         if (!test_Delete(p, mem_ctx, &handle)) {
 656                 ret = False;
 657         }
 658 #endif
 659
 660         if (!test_Close(p, mem_ctx, &handle)) {
 661                 ret = False;
 662         }
 663
 664         talloc_destroy(mem_ctx);
 665
 666         torture_rpc_close(p);
 667
 668         return ret;
 669 }