r101: added lsa_SetSecret() and lsa_QuerySecret()
[samba.git] / 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 test_CreateAccount(struct dcerpc_pipe *p, 
256                                TALLOC_CTX *mem_ctx, 
257                                struct policy_handle *handle)
258 {
259         NTSTATUS status;
260         struct lsa_CreateAccount r;
261         struct dom_sid2 *newsid;
262         struct policy_handle acct_handle;
263
264         newsid = dom_sid_parse_talloc(mem_ctx, "S-1-5-12349876-4321-2854");
265
266         printf("Testing CreateAccount\n");
267
268         r.in.handle = handle;
269         r.in.sid = newsid;
270         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
271         r.out.acct_handle = &acct_handle;
272
273         status = dcerpc_lsa_CreateAccount(p, mem_ctx, &r);
274         if (!NT_STATUS_IS_OK(status)) {
275                 printf("CreateAccount failed - %s\n", nt_errstr(status));
276                 return False;
277         }
278
279         if (!test_Delete(p, mem_ctx, &acct_handle)) {
280                 return False;
281         }
282
283         return True;
284 }
285
286
287 static BOOL test_CreateTrustedDomain(struct dcerpc_pipe *p, 
288                                      TALLOC_CTX *mem_ctx, 
289                                      struct policy_handle *handle)
290 {
291         NTSTATUS status;
292         struct lsa_CreateTrustedDomain r;
293         struct lsa_TrustInformation trustinfo;
294         struct dom_sid *domsid;
295         struct policy_handle dom_handle;
296
297         printf("Testing CreateTrustedDomain\n");
298
299         domsid = dom_sid_parse_talloc(mem_ctx, "S-1-5-697-97398-3797956");
300
301         trustinfo.sid = domsid;
302         init_lsa_Name(&trustinfo.name, "torturedomain");
303
304         r.in.handle = handle;
305         r.in.info = &trustinfo;
306         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
307         r.out.dom_handle = &dom_handle;
308
309         status = dcerpc_lsa_CreateTrustedDomain(p, mem_ctx, &r);
310         if (!NT_STATUS_IS_OK(status)) {
311                 printf("CreateTrustedDomain failed - %s\n", nt_errstr(status));
312                 return False;
313         }
314
315         if (!test_Delete(p, mem_ctx, &dom_handle)) {
316                 return False;
317         }
318
319         return True;
320 }
321
322 static BOOL test_CreateSecret(struct dcerpc_pipe *p, 
323                               TALLOC_CTX *mem_ctx, 
324                               struct policy_handle *handle)
325 {
326         NTSTATUS status;
327         struct lsa_CreateSecret r;
328         struct lsa_OpenSecret r2;
329         struct lsa_SetSecret r3;
330         struct lsa_QuerySecret r4;
331         struct policy_handle sec_handle, sec_handle2;
332         struct lsa_Delete d;
333         struct lsa_DATA_BUF buf1;
334         struct lsa_DATA_BUF_PTR bufp1;
335         DATA_BLOB enc_key;
336         BOOL ret = True;
337         uint8 session_key[16];
338         NTTIME old_mtime, new_mtime;
339         DATA_BLOB blob1, blob2;
340         const char *secret1 = "abcdef12345699qwerty";
341         char *secret2;
342         char *secname;
343
344         printf("Testing CreateSecret\n");
345
346         asprintf(&secname, "torturesecret-%u", (unsigned)random());
347
348         init_lsa_Name(&r.in.name, secname);
349
350         r.in.handle = handle;
351         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
352         r.out.sec_handle = &sec_handle;
353
354         status = dcerpc_lsa_CreateSecret(p, mem_ctx, &r);
355         if (!NT_STATUS_IS_OK(status)) {
356                 printf("CreateSecret failed - %s\n", nt_errstr(status));
357                 return False;
358         }
359
360         r2.in.handle = handle;
361         r2.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
362         r2.in.name = r.in.name;
363         r2.out.sec_handle = &sec_handle2;
364
365         printf("Testing OpenSecret\n");
366
367         status = dcerpc_lsa_OpenSecret(p, mem_ctx, &r2);
368         if (!NT_STATUS_IS_OK(status)) {
369                 printf("OpenSecret failed - %s\n", nt_errstr(status));
370                 ret = False;
371         }
372
373         status = dcerpc_fetch_session_key(p, session_key);
374         if (!NT_STATUS_IS_OK(status)) {
375                 printf("dcerpc_fetch_session_key failed - %s\n", nt_errstr(status));
376                 ret = False;
377         }
378
379         enc_key = sess_encrypt_string(secret1, session_key);
380
381         r3.in.handle = &sec_handle;
382         r3.in.new_val = &buf1;
383         r3.in.old_val = NULL;
384         r3.in.new_val->data = enc_key.data;
385         r3.in.new_val->length = enc_key.length;
386         r3.in.new_val->size = enc_key.length;
387
388         printf("Testing SetSecret\n");
389
390         status = dcerpc_lsa_SetSecret(p, mem_ctx, &r3);
391         if (!NT_STATUS_IS_OK(status)) {
392                 printf("SetSecret failed - %s\n", nt_errstr(status));
393                 ret = False;
394         }
395
396         data_blob_free(&enc_key);
397
398         ZERO_STRUCT(new_mtime);
399         ZERO_STRUCT(old_mtime);
400
401         /* fetch the secret back again */
402         r4.in.handle = &sec_handle;
403         r4.in.new_val = &bufp1;
404         r4.in.new_mtime = &new_mtime;
405         r4.in.old_val = NULL;
406         r4.in.old_mtime = NULL;
407
408         bufp1.buf = NULL;
409
410         status = dcerpc_lsa_QuerySecret(p, mem_ctx, &r4);
411         if (!NT_STATUS_IS_OK(status)) {
412                 printf("QuerySecret failed - %s\n", nt_errstr(status));
413                 ret = False;
414         }
415
416         blob1.data = r4.out.new_val->buf->data;
417         blob1.length = r4.out.new_val->buf->length;
418
419         blob2 = data_blob(NULL, blob1.length);
420
421         secret2 = sess_decrypt_string(&blob1, session_key);
422
423         printf("returned secret '%s'\n", secret2);
424
425         if (strcmp(secret1, secret2) != 0) {
426                 printf("Returned secret doesn't match\n");
427                 ret = False;
428         }
429
430         if (!test_Delete(p, mem_ctx, &sec_handle)) {
431                 ret = False;
432         }
433
434         d.in.handle = &sec_handle2;
435         status = dcerpc_lsa_Delete(p, mem_ctx, &d);
436         if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_HANDLE)) {
437                 printf("Second delete expected INVALID_HANDLE - %s\n", nt_errstr(status));
438                 ret = False;
439         }
440
441         return ret;
442 }
443
444 static BOOL test_EnumAccountRights(struct dcerpc_pipe *p, 
445                                    TALLOC_CTX *mem_ctx, 
446                                    struct policy_handle *acct_handle,
447                                    struct dom_sid *sid)
448 {
449         NTSTATUS status;
450         struct lsa_EnumAccountRights r;
451         struct lsa_RightSet rights;
452
453         printf("Testing EnumAccountRights\n");
454
455         r.in.handle = acct_handle;
456         r.in.sid = sid;
457         r.out.rights = &rights;
458
459         status = dcerpc_lsa_EnumAccountRights(p, mem_ctx, &r);
460         if (!NT_STATUS_IS_OK(status)) {
461                 printf("EnumAccountRights failed - %s\n", nt_errstr(status));
462                 return False;
463         }
464
465         return True;
466 }
467
468
469 static BOOL test_QuerySecObj(struct dcerpc_pipe *p, 
470                              TALLOC_CTX *mem_ctx, 
471                              struct policy_handle *handle,
472                              struct policy_handle *acct_handle)
473 {
474         NTSTATUS status;
475         struct lsa_QuerySecObj r;
476
477         printf("Testing QuerySecObj\n");
478
479         r.in.handle = acct_handle;
480         r.in.sec_info = 7;
481
482         status = dcerpc_lsa_QuerySecObj(p, mem_ctx, &r);
483         if (!NT_STATUS_IS_OK(status)) {
484                 printf("QuerySecObj failed - %s\n", nt_errstr(status));
485                 return False;
486         }
487
488         return True;
489 }
490
491 static BOOL test_OpenAccount(struct dcerpc_pipe *p, 
492                              TALLOC_CTX *mem_ctx, 
493                              struct policy_handle *handle,
494                              struct dom_sid *sid)
495 {
496         NTSTATUS status;
497         struct lsa_OpenAccount r;
498         struct policy_handle acct_handle;
499
500         printf("Testing OpenAccount\n");
501
502         r.in.handle = handle;
503         r.in.sid = sid;
504         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
505         r.out.acct_handle = &acct_handle;
506
507         status = dcerpc_lsa_OpenAccount(p, mem_ctx, &r);
508         if (!NT_STATUS_IS_OK(status)) {
509                 printf("OpenAccount failed - %s\n", nt_errstr(status));
510                 return False;
511         }
512
513         if (!test_EnumPrivsAccount(p, mem_ctx, handle, &acct_handle)) {
514                 return False;
515         }
516
517         if (!test_QuerySecObj(p, mem_ctx, handle, &acct_handle)) {
518                 return False;
519         }
520
521         return True;
522 }
523
524 static BOOL test_EnumAccounts(struct dcerpc_pipe *p, 
525                           TALLOC_CTX *mem_ctx, 
526                           struct policy_handle *handle)
527 {
528         NTSTATUS status;
529         struct lsa_EnumAccounts r;
530         struct lsa_SidArray sids1, sids2;
531         uint32 resume_handle = 0;
532         int i;
533
534         printf("\ntesting EnumAccounts\n");
535
536         r.in.handle = handle;
537         r.in.resume_handle = &resume_handle;
538         r.in.num_entries = 100;
539         r.out.resume_handle = &resume_handle;
540         r.out.sids = &sids1;
541
542         resume_handle = 0;
543         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
544         if (!NT_STATUS_IS_OK(status)) {
545                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
546                 return False;
547         }
548
549         if (!test_LookupSids(p, mem_ctx, handle, &sids1)) {
550                 return False;
551         }
552
553         printf("testing all accounts\n");
554         for (i=0;i<sids1.num_sids;i++) {
555                 test_OpenAccount(p, mem_ctx, handle, sids1.sids[i].sid);
556                 test_EnumAccountRights(p, mem_ctx, handle, sids1.sids[i].sid);
557         }
558         printf("\n");
559
560         if (sids1.num_sids < 3) {
561                 return True;
562         }
563         
564         printf("trying EnumAccounts partial listing (asking for 1 at 2)\n");
565         resume_handle = 2;
566         r.in.num_entries = 1;
567         r.out.sids = &sids2;
568
569         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
570         if (!NT_STATUS_IS_OK(status)) {
571                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
572                 return False;
573         }
574
575         if (sids2.num_sids != 1) {
576                 printf("Returned wrong number of entries (%d)\n", sids2.num_sids);
577                 return False;
578         }
579
580         return True;
581 }
582
583
584 static BOOL test_EnumPrivs(struct dcerpc_pipe *p, 
585                            TALLOC_CTX *mem_ctx, 
586                            struct policy_handle *handle)
587 {
588         NTSTATUS status;
589         struct lsa_EnumPrivs r;
590         struct lsa_PrivArray privs1;
591         uint32 resume_handle = 0;
592
593         printf("\ntesting EnumPrivs\n");
594
595         r.in.handle = handle;
596         r.in.resume_handle = &resume_handle;
597         r.in.max_count = 1000;
598         r.out.resume_handle = &resume_handle;
599         r.out.privs = &privs1;
600
601         resume_handle = 0;
602         status = dcerpc_lsa_EnumPrivs(p, mem_ctx, &r);
603         if (!NT_STATUS_IS_OK(status)) {
604                 printf("EnumPrivs failed - %s\n", nt_errstr(status));
605                 return False;
606         }
607
608         return True;
609 }
610
611
612 static BOOL test_EnumTrustDom(struct dcerpc_pipe *p, 
613                               TALLOC_CTX *mem_ctx, 
614                               struct policy_handle *handle)
615 {
616         struct lsa_EnumTrustDom r;
617         NTSTATUS status;
618         uint32 resume_handle = 0;
619         struct lsa_DomainList domains;
620
621         printf("\nTesting EnumTrustDom\n");
622
623         r.in.handle = handle;
624         r.in.resume_handle = &resume_handle;
625         r.in.num_entries = 1000;
626         r.out.domains = &domains;
627         r.out.resume_handle = &resume_handle;
628
629         status = dcerpc_lsa_EnumTrustDom(p, mem_ctx, &r);
630
631         /* NO_MORE_ENTRIES is allowed */
632         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
633                 return True;
634         }
635
636         if (!NT_STATUS_IS_OK(status)) {
637                 printf("EnumTrustDom failed - %s\n", nt_errstr(status));
638                 return False;
639         }
640
641         return True;
642 }
643
644 static BOOL test_QueryInfoPolicy(struct dcerpc_pipe *p, 
645                                  TALLOC_CTX *mem_ctx, 
646                                  struct policy_handle *handle)
647 {
648         struct lsa_QueryInfoPolicy r;
649         NTSTATUS status;
650         int i;
651         BOOL ret = True;
652         printf("\nTesting QueryInfoPolicy\n");
653
654         for (i=1;i<13;i++) {
655                 r.in.handle = handle;
656                 r.in.level = i;
657
658                 printf("\ntrying QueryInfoPolicy level %d\n", i);
659
660                 status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
661
662                 if ((i == 9 || i == 10 || i == 11) &&
663                     NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
664                         printf("server failed level %u (OK)\n", i);
665                         continue;
666                 }
667
668                 if (!NT_STATUS_IS_OK(status)) {
669                         printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
670                         ret = False;
671                         continue;
672                 }
673         }
674
675         return ret;
676 }
677
678 static BOOL test_Close(struct dcerpc_pipe *p, 
679                        TALLOC_CTX *mem_ctx, 
680                        struct policy_handle *handle)
681 {
682         NTSTATUS status;
683         struct lsa_Close r;
684         struct policy_handle handle2;
685
686         printf("\ntesting Close\n");
687
688         r.in.handle = handle;
689         r.out.handle = &handle2;
690
691         status = dcerpc_lsa_Close(p, mem_ctx, &r);
692         if (!NT_STATUS_IS_OK(status)) {
693                 printf("Close failed - %s\n", nt_errstr(status));
694                 return False;
695         }
696
697         status = dcerpc_lsa_Close(p, mem_ctx, &r);
698         /* its really a fault - we need a status code for rpc fault */
699         if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
700                 printf("Close failed - %s\n", nt_errstr(status));
701                 return False;
702         }
703
704         printf("\n");
705
706         return True;
707 }
708
709 BOOL torture_rpc_lsa(int dummy)
710 {
711         NTSTATUS status;
712         struct dcerpc_pipe *p;
713         TALLOC_CTX *mem_ctx;
714         BOOL ret = True;
715         struct policy_handle handle;
716
717         mem_ctx = talloc_init("torture_rpc_lsa");
718
719         status = torture_rpc_connection(&p, 
720                                         DCERPC_LSARPC_NAME, 
721                                         DCERPC_LSARPC_UUID, 
722                                         DCERPC_LSARPC_VERSION);
723         if (!NT_STATUS_IS_OK(status)) {
724                 return False;
725         }
726
727         if (!test_OpenPolicy(p, mem_ctx)) {
728                 ret = False;
729         }
730
731         if (!test_OpenPolicy2(p, mem_ctx, &handle)) {
732                 ret = False;
733         }
734
735         if (!test_CreateAccount(p, mem_ctx, &handle)) {
736                 ret = False;
737         }
738
739         if (!test_CreateSecret(p, mem_ctx, &handle)) {
740                 ret = False;
741         }
742
743         if (!test_CreateTrustedDomain(p, mem_ctx, &handle)) {
744                 ret = False;
745         }
746
747         if (!test_EnumAccounts(p, mem_ctx, &handle)) {
748                 ret = False;
749         }
750
751         if (!test_EnumPrivs(p, mem_ctx, &handle)) {
752                 ret = False;
753         }
754
755         if (!test_EnumTrustDom(p, mem_ctx, &handle)) {
756                 ret = False;
757         }
758
759         if (!test_QueryInfoPolicy(p, mem_ctx, &handle)) {
760                 ret = False;
761         }
762         
763 #if 0
764         if (!test_Delete(p, mem_ctx, &handle)) {
765                 ret = False;
766         }
767 #endif
768         
769         if (!test_Close(p, mem_ctx, &handle)) {
770                 ret = False;
771         }
772
773         talloc_destroy(mem_ctx);
774
775         torture_rpc_close(p);
776
777         return ret;
778 }