source4/torture/rpc/drsuapi.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    DRSUapi tests
   5
   6    Copyright (C) Andrew Tridgell 2003
   7    Copyright (C) Stefan (metze) Metzmacher 2004
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25
  26
  27 static void reopen(struct dcerpc_pipe **p, const struct dcerpc_interface_table *iface)
  28 {
  29         NTSTATUS status;
  30
  31         if (*p) {
  32                 dcerpc_pipe_close(*p);
  33         }
  34
  35         status = torture_rpc_connection(p, iface->endpoints->names[0], iface->uuid, iface->if_version);
  36         if (!NT_STATUS_IS_OK(status)) {
  37                 printf("Failed to reopen '%s' - %s\n", iface->name, nt_errstr(status));
  38                 exit(1);
  39         }
  40 }
  41
  42 static void print_depth(int depth)
  43 {
  44         int i;
  45         for (i=0;i<depth;i++) {
  46                 printf("    ");
  47         }
  48 }
  49
  50 static void test_ptr_scan(TALLOC_CTX *mem_ctx, const struct dcerpc_interface_table *iface,
  51                           int opnum, DATA_BLOB *base_in, int min_ofs, int max_ofs, int depth);
  52
  53 static void try_expand(TALLOC_CTX *mem_ctx, const struct dcerpc_interface_table *iface,
  54                        int opnum, DATA_BLOB *base_in, int insert_ofs, int depth)
  55 {
  56         DATA_BLOB stub_in, stub_out;
  57         int n;
  58         NTSTATUS status;
  59         struct dcerpc_pipe *p = NULL;
  60
  61         reopen(&p, iface);
  62
  63         /* work out how much to expand to get a non fault */
  64         for (n=0;n<2000;n++) {
  65                 stub_in = data_blob(NULL, base_in->length + n);
  66                 data_blob_clear(&stub_in);
  67                 memcpy(stub_in.data, base_in->data, insert_ofs);
  68                 memcpy(stub_in.data+insert_ofs+n, base_in->data+insert_ofs, base_in->length-insert_ofs);
  69
  70                 status = dcerpc_request(p, opnum, mem_ctx, &stub_in, &stub_out);
  71
  72                 if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
  73                         print_depth(depth);
  74                         printf("expand by %d gives %s\n", n, nt_errstr(status));
  75                         if (n >= 4) {
  76                                 test_ptr_scan(mem_ctx, iface, opnum, &stub_in,
  77                                               insert_ofs, insert_ofs+n, depth+1);
  78                         }
  79                         return;
  80                 } else {
  81 #if 0
  82                         print_depth(depth);
  83                         printf("expand by %d gives fault 0x%x\n", n, p->last_fault_code);
  84 #endif
  85                 }
  86                 if (p->last_fault_code == 5) {
  87                         reopen(&p, iface);
  88                 }
  89         }
  90
  91         dcerpc_pipe_close(p);
  92 }
  93
  94
  95 static void test_ptr_scan(TALLOC_CTX *mem_ctx, const struct dcerpc_interface_table *iface,
  96                           int opnum, DATA_BLOB *base_in, int min_ofs, int max_ofs, int depth)
  97 {
  98         DATA_BLOB stub_in, stub_out;
  99         int ofs;
 100         NTSTATUS status;
 101         struct dcerpc_pipe *p = NULL;
 102
 103         reopen(&p, iface);
 104
 105         stub_in = data_blob(NULL, base_in->length);
 106         memcpy(stub_in.data, base_in->data, base_in->length);
 107
 108         /* work out which elements are pointers */
 109         for (ofs=min_ofs;ofs<=max_ofs-4;ofs+=4) {
 110                 SIVAL(stub_in.data, ofs, 1);
 111                 status = dcerpc_request(p, opnum, mem_ctx, &stub_in, &stub_out);
 112
 113                 if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 114                         print_depth(depth);
 115                         printf("possible ptr at ofs %d - fault 0x%08x\n",
 116                                ofs-min_ofs, p->last_fault_code);
 117                         if (p->last_fault_code == 5) {
 118                                 reopen(&p, iface);
 119                         }
 120                         if (depth == 0) {
 121                                 try_expand(mem_ctx, iface, opnum, &stub_in, ofs+4, depth+1);
 122                         } else {
 123                                 try_expand(mem_ctx, iface, opnum, &stub_in, max_ofs, depth+1);
 124                         }
 125                         SIVAL(stub_in.data, ofs, 0);
 126                         continue;
 127                 }
 128                 SIVAL(stub_in.data, ofs, 0);
 129         }
 130
 131         dcerpc_pipe_close(p);
 132 }
 133
 134
 135 static void test_scan_call(TALLOC_CTX *mem_ctx, const struct dcerpc_interface_table *iface, int opnum)
 136 {
 137         DATA_BLOB stub_in, stub_out;
 138         int i;
 139         NTSTATUS status;
 140         struct dcerpc_pipe *p = NULL;
 141
 142         reopen(&p, iface);
 143
 144         /* work out the minimum amount of input data */
 145         for (i=0;i<2000;i++) {
 146                 stub_in = data_blob(NULL, i);
 147                 data_blob_clear(&stub_in);
 148
 149
 150                 status = dcerpc_request(p, opnum, mem_ctx, &stub_in, &stub_out);
 151
 152                 if (NT_STATUS_IS_OK(status)) {
 153                         printf("opnum %d   min_input %d - output %d\n",
 154                                opnum, stub_in.length, stub_out.length);
 155                         dump_data(0, stub_out.data, stub_out.length);
 156                         dcerpc_pipe_close(p);
 157                         test_ptr_scan(mem_ctx, iface, opnum, &stub_in, 0, stub_in.length, 0);
 158                         return;
 159                 }
 160
 161                 if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 162                         printf("opnum %d  size %d fault 0x%08x\n", opnum, i, p->last_fault_code);
 163                         if (p->last_fault_code == 5) {
 164                                 reopen(&p, iface);
 165                         }
 166                         continue;
 167                 }
 168
 169                 printf("opnum %d  size %d error %s\n", opnum, i, nt_errstr(status));
 170         }
 171
 172         printf("opnum %d minimum not found!?\n", opnum);
 173         dcerpc_pipe_close(p);
 174 }
 175
 176
 177 static BOOL test_scan(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 178 {
 179         test_scan_call(mem_ctx, &dcerpc_table_drsuapi, 0x0);
 180         return True;
 181 }
 182
 183 static BOOL test_DRSBind(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
 184 {
 185         NTSTATUS status;
 186         struct DRSUAPI_BIND r;
 187         BOOL ret = True;
 188
 189         ZERO_STRUCT(r.in.blob);
 190
 191         status = dcerpc_DRSUAPI_BIND(p, mem_ctx, &r);
 192         if (!NT_STATUS_IS_OK(status)) {
 193                 printf("DRSUAPI_BIND level failed - %s\n", nt_errstr(status));
 194                 ret = False;
 195         }
 196
 197         return ret;
 198 }
 199
 200 BOOL torture_rpc_drsuapi(int dummy)
 201 {
 202         NTSTATUS status;
 203         struct dcerpc_pipe *p;
 204         TALLOC_CTX *mem_ctx;
 205         BOOL ret = True;
 206
 207         mem_ctx = talloc_init("torture_rpc_srvsvc");
 208
 209         status = torture_rpc_connection(&p,
 210                                         DCERPC_DRSUAPI_NAME,
 211                                         DCERPC_DRSUAPI_UUID,
 212                                         DCERPC_DRSUAPI_VERSION);
 213         if (!NT_STATUS_IS_OK(status)) {
 214                 return False;
 215         }
 216
 217         if (!test_DRSBind(p, mem_ctx)) {
 218                 ret = False;
 219         }
 220
 221         if (!test_scan(p, mem_ctx)) {
 222                 ret = False;
 223         }
 224
 225         talloc_destroy(mem_ctx);
 226
 227         torture_rpc_close(p);
 228
 229         return ret;
 230 }