183128d3718367991c9781f1493ef2920de82150
[samba.git] / source4 / torture / rpc / winreg.c
1 /* 
2    Unix SMB/CIFS implementation.
3    test suite for winreg rpc operations
4
5    Copyright (C) Tim Potter 2003
6    Copyright (C) Jelmer Vernooij 2004
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 "librpc/gen_ndr/ndr_winreg.h"
25
26 static void init_winreg_String(struct winreg_String *name, const char *s)
27 {
28         name->name = s;
29         if (s) {
30                 name->name_len = 2 * (strlen_m(s) + 1);
31                 name->name_size = name->name_len;
32         } else {
33                 name->name_len = 0;
34                 name->name_size = 0;
35         }
36 }
37
38 static BOOL test_GetVersion(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
39                             struct policy_handle *handle)
40 {
41         NTSTATUS status;
42         struct winreg_GetVersion r;
43
44         printf("\ntesting GetVersion\n");
45
46         r.in.handle = handle;
47
48         status = dcerpc_winreg_GetVersion(p, mem_ctx, &r);
49
50         if (!NT_STATUS_IS_OK(status)) {
51                 printf("GetVersion failed - %s\n", nt_errstr(status));
52                 return False;
53         }
54
55         if (!W_ERROR_IS_OK(r.out.result)) {
56                 printf("GetVersion failed - %s\n", win_errstr(r.out.result));
57                 return False;
58         }
59
60         return True;
61 }
62
63 static BOOL test_CreateKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
64                           struct policy_handle *handle, const char *name, 
65                            const char *class)
66 {
67         struct winreg_CreateKey r;
68         struct policy_handle newhandle;
69         NTSTATUS status;
70         uint32_t sec_info = 0;
71
72         printf("\ntesting CreateKey\n");
73
74         r.in.handle = handle;
75         r.out.handle = &newhandle;
76         init_winreg_String(&r.in.key, name);    
77         init_winreg_String(&r.in.class, class);
78         r.in.reserved = 0x0;
79         r.in.access_mask = 0x02000000;
80         r.in.sec_info = &sec_info;
81         r.in.sec_desc = NULL;
82
83         status = dcerpc_winreg_CreateKey(p, mem_ctx, &r);
84
85         if (!NT_STATUS_IS_OK(status)) {
86                 printf("CreateKey failed - %s\n", nt_errstr(status));
87                 return False;
88         }
89
90         if (!W_ERROR_IS_OK(r.out.result)) {
91                 printf("CreateKey failed - %s\n", win_errstr(r.out.result));
92                 return False;
93         }
94
95         return True;
96 }
97
98 static BOOL test_GetKeySecurity(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
99                           struct policy_handle *handle)
100 {
101         NTSTATUS status;
102         struct winreg_GetKeySecurity r;
103
104         printf("\ntesting GetKeySecurity\n");
105
106         ZERO_STRUCT(r);
107
108         r.in.handle = handle;
109         r.in.data = r.out.data =  talloc_zero_p(mem_ctx, struct KeySecurityData);
110         r.in.data->size = 0xffff;
111         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
112
113         status = dcerpc_winreg_GetKeySecurity(p, mem_ctx, &r);
114
115         if (!NT_STATUS_IS_OK(status)) {
116                 printf("GetKeySecurity failed - %s\n", nt_errstr(status));
117                 return False;
118         }
119
120         if (!W_ERROR_IS_OK(r.out.result)) {
121                 printf("GetKeySecurity failed - %s\n", win_errstr(r.out.result));
122                 return False;
123         }
124
125         return False;
126 }
127
128 static BOOL test_CloseKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
129                           struct policy_handle *handle)
130 {
131         NTSTATUS status;
132         struct winreg_CloseKey r;
133
134         printf("\ntesting CloseKey\n");
135
136         r.in.handle = r.out.handle = handle;
137
138         status = dcerpc_winreg_CloseKey(p, mem_ctx, &r);
139
140         if (!NT_STATUS_IS_OK(status)) {
141                 printf("CloseKey failed - %s\n", nt_errstr(status));
142                 return False;
143         }
144
145         if (!W_ERROR_IS_OK(r.out.result)) {
146                 printf("CloseKey failed - %s\n", win_errstr(r.out.result));
147                 return False;
148         }
149
150         return True;
151 }
152
153 static BOOL test_FlushKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
154                           struct policy_handle *handle)
155 {
156         NTSTATUS status;
157         struct winreg_FlushKey r;
158
159         printf("\ntesting FlushKey\n");
160
161         r.in.handle = handle;
162
163         status = dcerpc_winreg_FlushKey(p, mem_ctx, &r);
164
165         if (!NT_STATUS_IS_OK(status)) {
166                 printf("FlushKey failed - %s\n", nt_errstr(status));
167                 return False;
168         }
169
170         if (!W_ERROR_IS_OK(r.out.result)) {
171                 printf("FlushKey failed - %s\n", win_errstr(r.out.result));
172                 return False;
173         }
174
175         return True;
176 }
177
178 static BOOL test_OpenKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
179                          struct policy_handle *hive_handle,
180                          const char *keyname, struct policy_handle *key_handle)
181 {
182         NTSTATUS status;
183         struct winreg_OpenKey r;
184
185         printf("\ntesting OpenKey\n");
186
187         r.in.handle = hive_handle;
188         init_winreg_String(&r.in.keyname, keyname);
189         r.in.unknown = 0x00000000;
190         r.in.access_mask = 0x02000000;
191         r.out.handle = key_handle;
192
193         status = dcerpc_winreg_OpenKey(p, mem_ctx, &r);
194
195         if (!NT_STATUS_IS_OK(status)) {
196                 printf("OpenKey failed - %s\n", nt_errstr(status));
197                 return False;
198         }
199
200         if (!W_ERROR_IS_OK(r.out.result)) {
201                 printf("OpenKey failed - %s\n", win_errstr(r.out.result));
202
203                 return False;
204         }
205
206         return True;
207 }
208
209 static BOOL test_DeleteKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
210                            struct policy_handle *handle, const char *key)
211 {
212         NTSTATUS status;
213         struct winreg_DeleteKey r;
214
215         printf("\ntesting DeleteKey\n");
216
217         r.in.handle = handle;
218         init_winreg_String(&r.in.key, key);     
219
220         status = dcerpc_winreg_DeleteKey(p, mem_ctx, &r);
221
222         if (!NT_STATUS_IS_OK(status)) {
223                 printf("DeleteKey failed - %s\n", nt_errstr(status));
224                 return False;
225         }
226
227         if (!W_ERROR_IS_OK(r.out.result)) {
228                 printf("DeleteKey failed - %s\n", win_errstr(r.out.result));
229                 return False;
230         }
231
232         return True;
233 }
234
235 static BOOL test_QueryInfoKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
236                               struct policy_handle *handle, char *class)
237 {
238         NTSTATUS status;
239         struct winreg_QueryInfoKey r;
240
241         printf("\ntesting QueryInfoKey\n");
242
243         r.in.handle = handle;
244         init_winreg_String(&r.in.class, class);
245         
246         status = dcerpc_winreg_QueryInfoKey(p, mem_ctx, &r);
247
248         if (!NT_STATUS_IS_OK(status)) {
249                 printf("QueryInfoKey failed - %s\n", nt_errstr(status));
250                 return False;
251         }
252
253         if (!W_ERROR_IS_OK(r.out.result)) {
254                 printf("QueryInfoKey failed - %s\n", win_errstr(r.out.result));
255                 return False;
256         }
257
258         return True;
259 }
260
261 static BOOL test_key(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
262                      struct policy_handle *handle, int depth);
263
264 static BOOL test_EnumKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
265                          struct policy_handle *handle, int depth)
266 {
267         struct winreg_EnumKey r;
268         struct winreg_EnumKeyNameRequest keyname;
269         struct winreg_String classname;
270         struct winreg_Time tm;
271         NTSTATUS status;
272
273         printf("Testing EnumKey\n\n");
274
275         r.in.handle = handle;
276         r.in.enum_index = 0;
277         r.in.key_name_len = r.out.key_name_len = 0;
278         r.in.unknown = r.out.unknown = 0x0414;
279         keyname.unknown = 0x0000020a;
280         init_winreg_String(&keyname.key_name, NULL);
281         init_winreg_String(&classname, NULL);
282         r.in.in_name = &keyname;
283         r.in.class = &classname;
284         tm.low = tm.high = 0x7fffffff;
285         r.in.last_changed_time = &tm;
286
287         do {
288                 status = dcerpc_winreg_EnumKey(p, mem_ctx, &r);
289
290                 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
291                         struct policy_handle key_handle;
292
293                         printf("EnumKey: %d: %s\n", r.in.enum_index, r.out.out_name->name);
294
295                         if (!test_OpenKey(
296                                     p, mem_ctx, handle, r.out.out_name->name,
297                                     &key_handle)) {
298                         } else {
299                                 test_key(p, mem_ctx, &key_handle, depth + 1);
300                         }
301                 }
302
303                 r.in.enum_index++;
304
305         } while (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result));
306
307         if (!NT_STATUS_IS_OK(status)) {
308                 printf("EnumKey failed - %s\n", nt_errstr(status));
309                 return False;
310         }
311
312         if (!W_ERROR_IS_OK(r.out.result) && !W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
313                 printf("EnumKey failed - %s\n", win_errstr(r.out.result));
314                 return False;
315         }
316
317
318
319         return True;
320 }
321
322 static BOOL test_QueryValue(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *valuename)
323 {
324         struct winreg_QueryValue r;
325         NTSTATUS status;
326         uint32 zero = 0;
327         uint32 offered = 0xfff;
328
329         printf("Testing QueryValue\n");
330
331         r.in.handle = handle;
332         r.in.value_name.name = valuename;
333         r.in.type = &zero;
334         r.in.size = &offered;
335         r.in.length = &zero;
336
337         status = dcerpc_winreg_QueryValue(p, mem_ctx, &r);
338         if(NT_STATUS_IS_ERR(status)) {
339                 printf("QueryValue failed - %s\n", nt_errstr(status));
340                 return False;
341         }
342
343         if (!W_ERROR_IS_OK(r.out.result)) {
344                 printf("QueryValue failed - %s\n", win_errstr(r.out.result));
345                 return False;
346         }
347
348         return True;
349 }
350
351 static BOOL test_EnumValue(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
352                            struct policy_handle *handle, int max_valnamelen, int max_valbufsize)
353 {
354         struct winreg_EnumValue r;
355         uint32 type = 0;
356         uint32 size = max_valbufsize, zero = 0;
357         BOOL ret = True;
358         uint8_t buf8;
359         uint16_t buf16;
360
361         printf("testing EnumValue\n");
362
363         r.in.handle = handle;
364         r.in.enum_index = 0;
365         r.in.name_in.length = 0;
366         r.in.name_in.size = 0x200;
367         r.in.name_in.name = &buf16;
368         r.in.type = &type;
369         r.in.value = &buf8;
370         r.in.length = &zero;
371         r.in.size = &size;
372         
373         do {
374                 NTSTATUS status = dcerpc_winreg_EnumValue(p, mem_ctx, &r);
375                 if(NT_STATUS_IS_ERR(status)) {
376                         printf("EnumValue failed - %s\n", nt_errstr(status));
377                         return False;
378                 }
379
380                 if (W_ERROR_IS_OK(r.out.result)) {
381                         ret &= test_QueryValue(p, mem_ctx, handle, r.out.name_out.name);
382                 }
383
384                 r.in.enum_index++;
385         } while (W_ERROR_IS_OK(r.out.result));
386
387         if(!W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
388                 printf("EnumValue failed - %s\n", win_errstr(r.out.result));
389                 return False;
390         }
391
392         return ret;
393 }
394
395 static BOOL test_OpenHKLM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
396                           struct policy_handle *handle)
397 {
398         NTSTATUS status;
399         struct winreg_OpenHKLM r;
400         struct winreg_OpenUnknown unknown;
401         BOOL ret = True;
402
403         printf("\ntesting OpenHKLM\n");
404
405         unknown.unknown0 = 0x84e0;
406         unknown.unknown1 = 0x0000;
407         r.in.unknown = &unknown;
408         r.in.access_required = SEC_FLAG_MAXIMUM_ALLOWED;
409         r.out.handle = handle;
410
411         status = dcerpc_winreg_OpenHKLM(p, mem_ctx, &r);
412
413         if (!NT_STATUS_IS_OK(status)) {
414                 printf("OpenHKLM failed - %s\n", nt_errstr(status));
415                 return False;
416         }
417
418         if (!W_ERROR_IS_OK(r.out.result)) {
419                 printf("OpenHKLM failed - %s\n", win_errstr(r.out.result));
420                 return False;
421         }
422
423         return ret;
424 }
425
426 static BOOL test_OpenHKU(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
427                          struct policy_handle *handle)
428 {
429         NTSTATUS status;
430         struct winreg_OpenHKU r;
431         struct winreg_OpenUnknown unknown;
432         BOOL ret = True;
433
434         printf("\ntesting OpenHKU\n");
435
436         unknown.unknown0 = 0x84e0;
437         unknown.unknown1 = 0x0000;
438         r.in.unknown = &unknown;
439         r.in.access_required = SEC_FLAG_MAXIMUM_ALLOWED;
440         r.out.handle = handle;
441
442         status = dcerpc_winreg_OpenHKU(p, mem_ctx, &r);
443
444         if (!NT_STATUS_IS_OK(status)) {
445                 printf("OpenHKU failed - %s\n", nt_errstr(status));
446                 return False;
447         }
448
449         if (!W_ERROR_IS_OK(r.out.result)) {
450                 printf("OpenHKU failed - %s\n", win_errstr(r.out.result));
451                 return False;
452         }
453
454         return ret;
455 }
456
457 static BOOL test_OpenHKCR(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
458                           struct policy_handle *handle)
459 {
460         NTSTATUS status;
461         struct winreg_OpenHKCR r;
462         struct winreg_OpenUnknown unknown;
463         BOOL ret = True;
464
465         printf("\ntesting OpenHKCR\n");
466
467         unknown.unknown0 = 0x84e0;
468         unknown.unknown1 = 0x0000;
469         r.in.unknown = &unknown;
470         r.in.access_required = SEC_FLAG_MAXIMUM_ALLOWED;
471         r.out.handle = handle;
472
473         status = dcerpc_winreg_OpenHKCR(p, mem_ctx, &r);
474
475         if (!NT_STATUS_IS_OK(status)) {
476                 printf("OpenHKCR failed - %s\n", nt_errstr(status));
477                 return False;
478         }
479
480         if (!W_ERROR_IS_OK(r.out.result)) {
481                 printf("OpenHKU failed - %s\n", win_errstr(r.out.result));
482                 return False;
483         }
484         return ret;
485 }
486
487 static BOOL test_InitiateSystemShutdown(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
488                         const char *msg, uint32_t timeout)
489 {
490         struct winreg_InitiateSystemShutdown r;
491         NTSTATUS status;
492         
493         init_winreg_String(&r.in.hostname, NULL);
494         init_winreg_String(&r.in.message, msg);
495         r.in.flags = 0;
496         r.in.timeout = timeout;
497
498         status = dcerpc_winreg_InitiateSystemShutdown(p, mem_ctx, &r);
499
500         if (!NT_STATUS_IS_OK(status)) {
501                 printf("InitiateSystemShutdown failed - %s\n", nt_errstr(status));
502                 return False;
503         }
504
505         if (!W_ERROR_IS_OK(r.out.result)) {
506                 printf("InitiateSystemShutdown failed - %s\n", win_errstr(r.out.result));
507                 return False;
508         }
509
510         return True;
511 }
512
513 static BOOL test_AbortSystemShutdown(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
514 {
515         struct winreg_AbortSystemShutdown r;
516         NTSTATUS status;
517         uint16_t server = 0x0;
518
519         r.in.server = &server;
520         
521         status = dcerpc_winreg_AbortSystemShutdown(p, mem_ctx, &r);
522
523         if (!NT_STATUS_IS_OK(status)) {
524                 printf("AbortSystemShutdown failed - %s\n", nt_errstr(status));
525                 return False;
526         }
527
528         if (!W_ERROR_IS_OK(r.out.result)) {
529                 printf("AbortSystemShutdown failed - %s\n", win_errstr(r.out.result));
530                 return False;
531         }
532
533         return True;
534 }
535
536 static BOOL test_OpenHKCU(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
537                           struct policy_handle *handle)
538 {
539         NTSTATUS status;
540         struct winreg_OpenHKCU r;
541         struct winreg_OpenUnknown unknown;
542         BOOL ret = True;
543
544         printf("\ntesting OpenHKCU\n");
545
546         unknown.unknown0 = 0x84e0;
547         unknown.unknown1 = 0x0000;
548         r.in.unknown = &unknown;
549         r.in.access_required = SEC_FLAG_MAXIMUM_ALLOWED;
550         r.out.handle = handle;
551
552         status = dcerpc_winreg_OpenHKCU(p, mem_ctx, &r);
553
554         if (!NT_STATUS_IS_OK(status)) {
555                 printf("OpenHKCU failed - %s\n", nt_errstr(status));
556                 return False;
557         }
558
559         return ret;
560 }
561
562 #define MAX_DEPTH 2             /* Only go this far down the tree */
563
564 static BOOL test_key(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
565                      struct policy_handle *handle, int depth)
566 {
567         if (depth == MAX_DEPTH)
568                 return True;
569
570         if (!test_QueryInfoKey(p, mem_ctx, handle, NULL)) {
571         }
572
573
574         if (!test_GetKeySecurity(p, mem_ctx, handle)) {
575         }
576
577         if (!test_EnumKey(p, mem_ctx, handle, depth)) {
578         }
579
580         if (!test_EnumValue(p, mem_ctx, handle, 0xFF, 0xFFFF)) {
581         }
582
583
584         test_CloseKey(p, mem_ctx, handle);
585
586         return True;
587 }
588
589 typedef BOOL winreg_open_fn(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
590                             struct policy_handle *handle);
591
592 static BOOL test_Open(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, void *fn)
593 {
594         struct policy_handle handle, newhandle;
595         BOOL ret = True;
596         winreg_open_fn *open_fn = (winreg_open_fn *)fn;
597
598         if (!open_fn(p, mem_ctx, &handle)) {
599                 return False;
600         }
601
602         if (!test_CreateKey(p, mem_ctx, &handle, "spottyfoot", NULL)) {
603                 printf("CreateKey failed\n");
604                 ret = False;
605         }
606
607         if (!test_FlushKey(p, mem_ctx, &handle)) {
608                 printf("FlushKey failed\n");
609                 ret = False;
610         }
611
612         if (!test_OpenKey(p, mem_ctx, &handle, "spottyfoot", &newhandle)) {
613                 printf("CreateKey failed (OpenKey after Create didn't work)\n");
614                 ret = False;
615         }
616
617         if (!test_DeleteKey(p, mem_ctx, &handle, "spottyfoot")) {
618                 printf("DeleteKey failed\n");
619                 ret = False;
620         }
621
622         if (!test_FlushKey(p, mem_ctx, &handle)) {
623                 printf("FlushKey failed\n");
624                 ret = False;
625         }
626
627         if (test_OpenKey(p, mem_ctx, &handle, "spottyfoot", &newhandle)) {
628                 printf("DeleteKey failed (OpenKey after Delete didn't work)\n");
629                 ret = False;
630         }
631
632         if (!test_GetVersion(p, mem_ctx, &handle)) {
633                 printf("GetVersion failed\n");
634                 ret = False;
635         }
636
637         /* The HKCR hive has a very large fanout */
638
639         if (open_fn == test_OpenHKCR) {
640                 if(!test_key(p, mem_ctx, &handle, MAX_DEPTH - 1)) {
641                         ret = False;
642                 }
643         }
644
645         if(!test_key(p, mem_ctx, &handle, 0)) {
646                 ret = False;
647         }
648
649         return ret;
650 }
651
652 BOOL torture_rpc_winreg(void)
653 {
654         NTSTATUS status;
655        struct dcerpc_pipe *p;
656         TALLOC_CTX *mem_ctx;
657         BOOL ret = True;
658         winreg_open_fn *open_fns[] = { test_OpenHKLM, test_OpenHKU,
659                                        test_OpenHKCR, test_OpenHKCU };
660         int i;
661
662         mem_ctx = talloc_init("torture_rpc_winreg");
663
664         status = torture_rpc_connection(&p, 
665                                         DCERPC_WINREG_NAME, 
666                                         DCERPC_WINREG_UUID, 
667                                         DCERPC_WINREG_VERSION);
668
669         if (!NT_STATUS_IS_OK(status)) {
670                 return False;
671         }
672
673         if(!test_InitiateSystemShutdown(p, mem_ctx, "spottyfood", 30))
674                 ret = False;
675
676         if(!test_AbortSystemShutdown(p, mem_ctx))
677                 ret = False;
678
679         for (i = 0; i < ARRAY_SIZE(open_fns); i++) {
680                 if (!test_Open(p, mem_ctx, open_fns[i]))
681                         ret = False;
682         }
683
684         talloc_destroy(mem_ctx);
685
686         torture_rpc_close(p);
687
688         return ret;
689 }