- add 'print' to the DCERPC binding strings
[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_EnumAccountRights(struct dcerpc_pipe *p, 
234                                    TALLOC_CTX *mem_ctx, 
235                                    struct policy_handle *acct_handle,
236                                    struct dom_sid *sid)
237 {
238         NTSTATUS status;
239         struct lsa_EnumAccountRights r;
240         struct lsa_RightSet rights;
241
242         printf("Testing EnumAccountRights\n");
243
244         r.in.handle = acct_handle;
245         r.in.sid = sid;
246         r.out.rights = &rights;
247
248         status = dcerpc_lsa_EnumAccountRights(p, mem_ctx, &r);
249         if (!NT_STATUS_IS_OK(status)) {
250                 printf("EnumAccountRights failed - %s\n", nt_errstr(status));
251                 return False;
252         }
253
254         return True;
255 }
256
257
258 static BOOL test_QuerySecObj(struct dcerpc_pipe *p, 
259                              TALLOC_CTX *mem_ctx, 
260                              struct policy_handle *handle,
261                              struct policy_handle *acct_handle)
262 {
263         NTSTATUS status;
264         struct lsa_QuerySecObj r;
265
266         printf("Testing QuerySecObj\n");
267
268         r.in.handle = acct_handle;
269         r.in.sec_info = 7;
270
271         status = dcerpc_lsa_QuerySecObj(p, mem_ctx, &r);
272         if (!NT_STATUS_IS_OK(status)) {
273                 printf("QuerySecObj failed - %s\n", nt_errstr(status));
274                 return False;
275         }
276
277         return True;
278 }
279
280 static BOOL test_OpenAccount(struct dcerpc_pipe *p, 
281                              TALLOC_CTX *mem_ctx, 
282                              struct policy_handle *handle,
283                              struct dom_sid *sid)
284 {
285         NTSTATUS status;
286         struct lsa_OpenAccount r;
287         struct policy_handle acct_handle;
288
289         printf("Testing OpenAccount\n");
290
291         r.in.handle = handle;
292         r.in.sid = sid;
293         r.in.desired_access = SEC_RIGHTS_MAXIMUM_ALLOWED;
294         r.out.acct_handle = &acct_handle;
295
296         status = dcerpc_lsa_OpenAccount(p, mem_ctx, &r);
297         if (!NT_STATUS_IS_OK(status)) {
298                 printf("OpenAccount failed - %s\n", nt_errstr(status));
299                 return False;
300         }
301
302         if (!test_EnumPrivsAccount(p, mem_ctx, handle, &acct_handle)) {
303                 return False;
304         }
305
306         if (!test_QuerySecObj(p, mem_ctx, handle, &acct_handle)) {
307                 return False;
308         }
309
310         return True;
311 }
312
313 static BOOL test_EnumAccounts(struct dcerpc_pipe *p, 
314                           TALLOC_CTX *mem_ctx, 
315                           struct policy_handle *handle)
316 {
317         NTSTATUS status;
318         struct lsa_EnumAccounts r;
319         struct lsa_SidArray sids1, sids2;
320         uint32 resume_handle = 0;
321         int i;
322
323         printf("\ntesting EnumAccounts\n");
324
325         r.in.handle = handle;
326         r.in.resume_handle = &resume_handle;
327         r.in.num_entries = 100;
328         r.out.resume_handle = &resume_handle;
329         r.out.sids = &sids1;
330
331         resume_handle = 0;
332         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
333         if (!NT_STATUS_IS_OK(status)) {
334                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
335                 return False;
336         }
337
338         if (!test_LookupSids(p, mem_ctx, handle, &sids1)) {
339                 return False;
340         }
341
342         printf("testing all accounts\n");
343         for (i=0;i<sids1.num_sids;i++) {
344                 test_OpenAccount(p, mem_ctx, handle, sids1.sids[i].sid);
345                 test_EnumAccountRights(p, mem_ctx, handle, sids1.sids[i].sid);
346         }
347         printf("\n");
348
349         if (sids1.num_sids < 3) {
350                 return True;
351         }
352         
353         printf("trying EnumAccounts partial listing (asking for 1 at 2)\n");
354         resume_handle = 2;
355         r.in.num_entries = 1;
356         r.out.sids = &sids2;
357
358         status = dcerpc_lsa_EnumAccounts(p, mem_ctx, &r);
359         if (!NT_STATUS_IS_OK(status)) {
360                 printf("EnumAccounts failed - %s\n", nt_errstr(status));
361                 return False;
362         }
363
364         if (sids2.num_sids != 1) {
365                 printf("Returned wrong number of entries (%d)\n", sids2.num_sids);
366                 return False;
367         }
368
369         return True;
370 }
371
372
373 static BOOL test_EnumPrivs(struct dcerpc_pipe *p, 
374                            TALLOC_CTX *mem_ctx, 
375                            struct policy_handle *handle)
376 {
377         NTSTATUS status;
378         struct lsa_EnumPrivs r;
379         struct lsa_PrivArray privs1;
380         uint32 resume_handle = 0;
381
382         printf("\ntesting EnumPrivs\n");
383
384         r.in.handle = handle;
385         r.in.resume_handle = &resume_handle;
386         r.in.max_count = 1000;
387         r.out.resume_handle = &resume_handle;
388         r.out.privs = &privs1;
389
390         resume_handle = 0;
391         status = dcerpc_lsa_EnumPrivs(p, mem_ctx, &r);
392         if (!NT_STATUS_IS_OK(status)) {
393                 printf("EnumPrivs failed - %s\n", nt_errstr(status));
394                 return False;
395         }
396
397         return True;
398 }
399
400
401 static BOOL test_EnumTrustDom(struct dcerpc_pipe *p, 
402                               TALLOC_CTX *mem_ctx, 
403                               struct policy_handle *handle)
404 {
405         struct lsa_EnumTrustDom r;
406         NTSTATUS status;
407         uint32 resume_handle = 0;
408         struct lsa_DomainList domains;
409
410         printf("\nTesting EnumTrustDom\n");
411
412         r.in.handle = handle;
413         r.in.resume_handle = &resume_handle;
414         r.in.num_entries = 1000;
415         r.out.domains = &domains;
416         r.out.resume_handle = &resume_handle;
417
418         status = dcerpc_lsa_EnumTrustDom(p, mem_ctx, &r);
419
420         /* NO_MORE_ENTRIES is allowed */
421         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_ENTRIES)) {
422                 return True;
423         }
424
425         if (!NT_STATUS_IS_OK(status)) {
426                 printf("EnumTrustDom failed - %s\n", nt_errstr(status));
427                 return False;
428         }
429
430         return True;
431 }
432
433 static BOOL test_QueryInfoPolicy(struct dcerpc_pipe *p, 
434                                  TALLOC_CTX *mem_ctx, 
435                                  struct policy_handle *handle)
436 {
437         struct lsa_QueryInfoPolicy r;
438         NTSTATUS status;
439         int i;
440         BOOL ret = True;
441         printf("\nTesting QueryInfoPolicy\n");
442
443         for (i=1;i<13;i++) {
444                 r.in.handle = handle;
445                 r.in.level = i;
446
447                 printf("\ntrying QueryInfoPolicy level %d\n", i);
448
449                 status = dcerpc_lsa_QueryInfoPolicy(p, mem_ctx, &r);
450
451                 if ((i == 9 || i == 10 || i == 11) &&
452                     NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
453                         printf("server failed level %u (OK)\n", i);
454                         continue;
455                 }
456
457                 if (!NT_STATUS_IS_OK(status)) {
458                         printf("QueryInfoPolicy failed - %s\n", nt_errstr(status));
459                         ret = False;
460                         continue;
461                 }
462         }
463
464         return ret;
465 }
466
467 static BOOL test_Delete(struct dcerpc_pipe *p, 
468                        TALLOC_CTX *mem_ctx, 
469                        struct policy_handle *handle)
470 {
471         NTSTATUS status;
472         struct lsa_Delete r;
473
474         printf("\ntesting Delete - but what does it do?\n");
475
476         r.in.handle = handle;
477         status = dcerpc_lsa_Delete(p, mem_ctx, &r);
478         if (!NT_STATUS_IS_OK(status)) {
479                 printf("Delete failed - %s\n", nt_errstr(status));
480                 return False;
481         }
482
483         printf("\n");
484
485         return True;
486 }
487
488 static BOOL test_Close(struct dcerpc_pipe *p, 
489                        TALLOC_CTX *mem_ctx, 
490                        struct policy_handle *handle)
491 {
492         NTSTATUS status;
493         struct lsa_Close r;
494         struct policy_handle handle2;
495
496         printf("\ntesting Close\n");
497
498         r.in.handle = handle;
499         r.out.handle = &handle2;
500
501         status = dcerpc_lsa_Close(p, mem_ctx, &r);
502         if (!NT_STATUS_IS_OK(status)) {
503                 printf("Close failed - %s\n", nt_errstr(status));
504                 return False;
505         }
506
507         status = dcerpc_lsa_Close(p, mem_ctx, &r);
508         /* its really a fault - we need a status code for rpc fault */
509         if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
510                 printf("Close failed - %s\n", nt_errstr(status));
511                 return False;
512         }
513
514         printf("\n");
515
516         return True;
517 }
518
519 BOOL torture_rpc_lsa(int dummy)
520 {
521         NTSTATUS status;
522         struct dcerpc_pipe *p;
523         TALLOC_CTX *mem_ctx;
524         BOOL ret = True;
525         struct policy_handle handle;
526
527         mem_ctx = talloc_init("torture_rpc_lsa");
528
529         status = torture_rpc_connection(&p, 
530                                         DCERPC_LSARPC_NAME, 
531                                         DCERPC_LSARPC_UUID, 
532                                         DCERPC_LSARPC_VERSION);
533         if (!NT_STATUS_IS_OK(status)) {
534                 return False;
535         }
536
537         if (!test_OpenPolicy(p, mem_ctx)) {
538                 ret = False;
539         }
540
541         if (!test_OpenPolicy2(p, mem_ctx, &handle)) {
542                 ret = False;
543         }
544
545         if (!test_EnumAccounts(p, mem_ctx, &handle)) {
546                 ret = False;
547         }
548
549         if (!test_EnumPrivs(p, mem_ctx, &handle)) {
550                 ret = False;
551         }
552
553         if (!test_EnumTrustDom(p, mem_ctx, &handle)) {
554                 ret = False;
555         }
556
557         if (!test_QueryInfoPolicy(p, mem_ctx, &handle)) {
558                 ret = False;
559         }
560         
561 #if 0
562         if (!test_Delete(p, mem_ctx, &handle)) {
563                 ret = False;
564         }
565 #endif
566         
567         if (!test_Close(p, mem_ctx, &handle)) {
568                 ret = False;
569         }
570
571         talloc_destroy(mem_ctx);
572
573         torture_rpc_close(p);
574
575         return ret;
576 }