source/torture/basic/scanner.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB torture tester - scanning functions
   4    Copyright (C) Andrew Tridgell 2001
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 #define VERBOSE 0
  24 #define OP_MIN 0
  25 #define OP_MAX 100
  26
  27 /****************************************************************************
  28 look for a partial hit
  29 ****************************************************************************/
  30 static void trans2_check_hit(const char *format, int op, int level, NTSTATUS status)
  31 {
  32         if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_LEVEL) ||
  33             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) ||
  34             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_SUPPORTED) ||
  35             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) ||
  36             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_INFO_CLASS)) {
  37                 return;
  38         }
  39 #if VERBOSE
  40         printf("possible %s hit op=%3d level=%5d status=%s\n",
  41                format, op, level, nt_errstr(status));
  42 #endif
  43 }
  44
  45 /****************************************************************************
  46 check for existance of a trans2 call
  47 ****************************************************************************/
  48 static NTSTATUS try_trans2(struct smbcli_state *cli,
  49                            int op,
  50                            char *param, char *data,
  51                            int param_len, int data_len,
  52                            int *rparam_len, int *rdata_len)
  53 {
  54         NTSTATUS status;
  55         struct smb_trans2 t2;
  56         uint16_t setup = op;
  57         TALLOC_CTX *mem_ctx;
  58
  59         mem_ctx = talloc_init("try_trans2");
  60
  61         t2.in.max_param = 64;
  62         t2.in.max_data = smb_raw_max_trans_data(cli->tree, 64);
  63         t2.in.max_setup = 10;
  64         t2.in.flags = 0;
  65         t2.in.timeout = 0;
  66         t2.in.setup_count = 1;
  67         t2.in.setup = &setup;
  68         t2.in.params.data = param;
  69         t2.in.params.length = param_len;
  70         t2.in.data.data = data;
  71         t2.in.data.length = data_len;
  72
  73         status = smb_raw_trans2(cli->tree, mem_ctx, &t2);
  74
  75         *rparam_len = t2.out.params.length;
  76         *rdata_len = t2.out.data.length;
  77
  78         talloc_destroy(mem_ctx);
  79
  80         return status;
  81 }
  82
  83
  84 static NTSTATUS try_trans2_len(struct smbcli_state *cli,
  85                              const char *format,
  86                              int op, int level,
  87                              char *param, char *data,
  88                              int param_len, int *data_len,
  89                              int *rparam_len, int *rdata_len)
  90 {
  91         NTSTATUS ret=NT_STATUS_OK;
  92
  93         ret = try_trans2(cli, op, param, data, param_len,
  94                          sizeof(pstring), rparam_len, rdata_len);
  95 #if VERBOSE
  96         printf("op=%d level=%d ret=%s\n", op, level, nt_errstr(ret));
  97 #endif
  98         if (!NT_STATUS_IS_OK(ret)) return ret;
  99
 100         *data_len = 0;
 101         while (*data_len < sizeof(pstring)) {
 102                 ret = try_trans2(cli, op, param, data, param_len,
 103                                  *data_len, rparam_len, rdata_len);
 104                 if (NT_STATUS_IS_OK(ret)) break;
 105                 *data_len += 2;
 106         }
 107         if (NT_STATUS_IS_OK(ret)) {
 108                 printf("found %s level=%d data_len=%d rparam_len=%d rdata_len=%d\n",
 109                        format, level, *data_len, *rparam_len, *rdata_len);
 110         } else {
 111                 trans2_check_hit(format, op, level, ret);
 112         }
 113         return ret;
 114 }
 115
 116
 117 /****************************************************************************
 118 check whether a trans2 opnum exists at all
 119 ****************************************************************************/
 120 static BOOL trans2_op_exists(struct smbcli_state *cli, int op)
 121 {
 122         int data_len = 0;
 123         int param_len = 0;
 124         int rparam_len, rdata_len;
 125         pstring param, data;
 126         NTSTATUS status1, status2;
 127
 128         memset(data, 0, sizeof(data));
 129         data_len = 4;
 130
 131         /* try with a info level only */
 132         param_len = sizeof(param);
 133         data_len = sizeof(data);
 134
 135         memset(param, 0xFF, sizeof(param));
 136         memset(data, 0xFF, sizeof(data));
 137
 138         status1 = try_trans2(cli, 0xFFFF, param, data, param_len, data_len,
 139                              &rparam_len, &rdata_len);
 140
 141         status2 = try_trans2(cli, op, param, data, param_len, data_len,
 142                              &rparam_len, &rdata_len);
 143
 144         if (NT_STATUS_EQUAL(status1, status2)) return False;
 145
 146         printf("Found op %d (status=%s)\n", op, nt_errstr(status2));
 147
 148         return True;
 149 }
 150
 151 /****************************************************************************
 152 check for existance of a trans2 call
 153 ****************************************************************************/
 154 static BOOL scan_trans2(struct smbcli_state *cli, int op, int level,
 155                         int fnum, int dnum, int qfnum, const char *fname)
 156 {
 157         int data_len = 0;
 158         int param_len = 0;
 159         int rparam_len, rdata_len;
 160         pstring param, data;
 161         NTSTATUS status;
 162
 163         memset(data, 0, sizeof(data));
 164         data_len = 4;
 165
 166         /* try with a info level only */
 167         param_len = 2;
 168         SSVAL(param, 0, level);
 169         status = try_trans2_len(cli, "void", op, level, param, data, param_len, &data_len,
 170                             &rparam_len, &rdata_len);
 171         if (NT_STATUS_IS_OK(status)) return True;
 172
 173         /* try with a file descriptor */
 174         param_len = 6;
 175         SSVAL(param, 0, fnum);
 176         SSVAL(param, 2, level);
 177         SSVAL(param, 4, 0);
 178         status = try_trans2_len(cli, "fnum", op, level, param, data, param_len, &data_len,
 179                                 &rparam_len, &rdata_len);
 180         if (NT_STATUS_IS_OK(status)) return True;
 181
 182         /* try with a quota file descriptor */
 183         param_len = 6;
 184         SSVAL(param, 0, qfnum);
 185         SSVAL(param, 2, level);
 186         SSVAL(param, 4, 0);
 187         status = try_trans2_len(cli, "qfnum", op, level, param, data, param_len, &data_len,
 188                                 &rparam_len, &rdata_len);
 189         if (NT_STATUS_IS_OK(status)) return True;
 190
 191         /* try with a notify style */
 192         param_len = 6;
 193         SSVAL(param, 0, dnum);
 194         SSVAL(param, 2, dnum);
 195         SSVAL(param, 4, level);
 196         status = try_trans2_len(cli, "notify", op, level, param, data, param_len, &data_len,
 197                                 &rparam_len, &rdata_len);
 198         if (NT_STATUS_IS_OK(status)) return True;
 199
 200         /* try with a file name */
 201         param_len = 6;
 202         SSVAL(param, 0, level);
 203         SSVAL(param, 2, 0);
 204         SSVAL(param, 4, 0);
 205         param_len += push_string(&param[6], fname, sizeof(pstring)-7, STR_TERMINATE|STR_UNICODE);
 206
 207         status = try_trans2_len(cli, "fname", op, level, param, data, param_len, &data_len,
 208                                 &rparam_len, &rdata_len);
 209         if (NT_STATUS_IS_OK(status)) return True;
 210
 211         /* try with a new file name */
 212         param_len = 6;
 213         SSVAL(param, 0, level);
 214         SSVAL(param, 2, 0);
 215         SSVAL(param, 4, 0);
 216         param_len += push_string(&param[6], "\\newfile.dat", sizeof(pstring)-7, STR_TERMINATE|STR_UNICODE);
 217
 218         status = try_trans2_len(cli, "newfile", op, level, param, data, param_len, &data_len,
 219                                 &rparam_len, &rdata_len);
 220         smbcli_unlink(cli->tree, "\\newfile.dat");
 221         smbcli_rmdir(cli->tree, "\\newfile.dat");
 222         if (NT_STATUS_IS_OK(status)) return True;
 223
 224         /* try dfs style  */
 225         smbcli_mkdir(cli->tree, "\\testdir");
 226         param_len = 2;
 227         SSVAL(param, 0, level);
 228         param_len += push_string(&param[2], "\\testdir", sizeof(pstring)-3, STR_TERMINATE|STR_UNICODE);
 229
 230         status = try_trans2_len(cli, "dfs", op, level, param, data, param_len, &data_len,
 231                                 &rparam_len, &rdata_len);
 232         smbcli_rmdir(cli->tree, "\\testdir");
 233         if (NT_STATUS_IS_OK(status)) return True;
 234
 235         return False;
 236 }
 237
 238
 239 BOOL torture_trans2_scan(void)
 240 {
 241         static struct smbcli_state *cli;
 242         int op, level;
 243         const char *fname = "\\scanner.dat";
 244         int fnum, dnum, qfnum;
 245
 246         printf("starting trans2 scan test\n");
 247
 248         if (!torture_open_connection(&cli)) {
 249                 return False;
 250         }
 251
 252         fnum = smbcli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE);
 253         if (fnum == -1) {
 254                 printf("file open failed - %s\n", smbcli_errstr(cli->tree));
 255         }
 256         dnum = smbcli_nt_create_full(cli->tree, "\\",
 257                                   0, GENERIC_RIGHTS_FILE_READ, FILE_ATTRIBUTE_NORMAL,
 258                                   NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE,
 259                                   NTCREATEX_DISP_OPEN,
 260                                   NTCREATEX_OPTIONS_DIRECTORY, 0);
 261         if (dnum == -1) {
 262                 printf("directory open failed - %s\n", smbcli_errstr(cli->tree));
 263         }
 264         qfnum = smbcli_nt_create_full(cli->tree, "\\$Extend\\$Quota:$Q:$INDEX_ALLOCATION",
 265                                    NTCREATEX_FLAGS_EXTENDED,
 266                                    SEC_RIGHTS_MAXIMUM_ALLOWED,
 267                                    0,
 268                                    NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
 269                                    NTCREATEX_DISP_OPEN,
 270                                    0, 0);
 271         if (qfnum == -1) {
 272                 printf("quota open failed - %s\n", smbcli_errstr(cli->tree));
 273         }
 274
 275         for (op=OP_MIN; op<=OP_MAX; op++) {
 276
 277                 if (!trans2_op_exists(cli, op)) {
 278                         continue;
 279                 }
 280
 281                 for (level = 0; level <= 50; level++) {
 282                         scan_trans2(cli, op, level, fnum, dnum, qfnum, fname);
 283                 }
 284
 285                 for (level = 0x100; level <= 0x130; level++) {
 286                         scan_trans2(cli, op, level, fnum, dnum, qfnum, fname);
 287                 }
 288
 289                 for (level = 1000; level < 1050; level++) {
 290                         scan_trans2(cli, op, level, fnum, dnum, qfnum, fname);
 291                 }
 292         }
 293
 294         torture_close_connection(cli);
 295
 296         printf("trans2 scan finished\n");
 297         return True;
 298 }
 299
 300
 301
 302
 303 /****************************************************************************
 304 look for a partial hit
 305 ****************************************************************************/
 306 static void nttrans_check_hit(const char *format, int op, int level, NTSTATUS status)
 307 {
 308         if (NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_LEVEL) ||
 309             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_IMPLEMENTED) ||
 310             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_NOT_SUPPORTED) ||
 311             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_UNSUCCESSFUL) ||
 312             NT_STATUS_V(status) == NT_STATUS_V(NT_STATUS_INVALID_INFO_CLASS)) {
 313                 return;
 314         }
 315 #if VERBOSE
 316                 printf("possible %s hit op=%3d level=%5d status=%s\n",
 317                        format, op, level, nt_errstr(status));
 318 #endif
 319 }
 320
 321 /****************************************************************************
 322 check for existence of a nttrans call
 323 ****************************************************************************/
 324 static NTSTATUS try_nttrans(struct smbcli_state *cli,
 325                             int op,
 326                             char *param, char *data,
 327                             int param_len, int data_len,
 328                             int *rparam_len, int *rdata_len)
 329 {
 330         struct smb_nttrans parms;
 331         DATA_BLOB ntparam_blob, ntdata_blob;
 332         TALLOC_CTX *mem_ctx;
 333         NTSTATUS status;
 334
 335         mem_ctx = talloc_init("try_nttrans");
 336
 337         ntparam_blob.length = param_len;
 338         ntparam_blob.data = param;
 339         ntdata_blob.length = data_len;
 340         ntdata_blob.data = data;
 341
 342         parms.in.max_param = 64;
 343         parms.in.max_data = smb_raw_max_trans_data(cli->tree, 64);
 344         parms.in.max_setup = 0;
 345         parms.in.setup_count = 0;
 346         parms.in.function = op;
 347         parms.in.params = ntparam_blob;
 348         parms.in.data = ntdata_blob;
 349
 350         status = smb_raw_nttrans(cli->tree, mem_ctx, &parms);
 351
 352         if (NT_STATUS_IS_ERR(status)) {
 353                 DEBUG(1,("Failed to send NT_TRANS\n"));
 354                 talloc_destroy(mem_ctx);
 355                 return status;
 356         }
 357         *rparam_len = parms.out.params.length;
 358         *rdata_len = parms.out.data.length;
 359
 360         talloc_destroy(mem_ctx);
 361
 362         return status;
 363 }
 364
 365
 366 static NTSTATUS try_nttrans_len(struct smbcli_state *cli,
 367                              const char *format,
 368                              int op, int level,
 369                              char *param, char *data,
 370                              int param_len, int *data_len,
 371                              int *rparam_len, int *rdata_len)
 372 {
 373         NTSTATUS ret=NT_STATUS_OK;
 374
 375         ret = try_nttrans(cli, op, param, data, param_len,
 376                          sizeof(pstring), rparam_len, rdata_len);
 377 #if VERBOSE
 378         printf("op=%d level=%d ret=%s\n", op, level, nt_errstr(ret));
 379 #endif
 380         if (!NT_STATUS_IS_OK(ret)) return ret;
 381
 382         *data_len = 0;
 383         while (*data_len < sizeof(pstring)) {
 384                 ret = try_nttrans(cli, op, param, data, param_len,
 385                                  *data_len, rparam_len, rdata_len);
 386                 if (NT_STATUS_IS_OK(ret)) break;
 387                 *data_len += 2;
 388         }
 389         if (NT_STATUS_IS_OK(ret)) {
 390                 printf("found %s level=%d data_len=%d rparam_len=%d rdata_len=%d\n",
 391                        format, level, *data_len, *rparam_len, *rdata_len);
 392         } else {
 393                 nttrans_check_hit(format, op, level, ret);
 394         }
 395         return ret;
 396 }
 397
 398 /****************************************************************************
 399 check for existance of a nttrans call
 400 ****************************************************************************/
 401 static BOOL scan_nttrans(struct smbcli_state *cli, int op, int level,
 402                         int fnum, int dnum, const char *fname)
 403 {
 404         int data_len = 0;
 405         int param_len = 0;
 406         int rparam_len, rdata_len;
 407         pstring param, data;
 408         NTSTATUS status;
 409
 410         memset(data, 0, sizeof(data));
 411         data_len = 4;
 412
 413         /* try with a info level only */
 414         param_len = 2;
 415         SSVAL(param, 0, level);
 416         status = try_nttrans_len(cli, "void", op, level, param, data, param_len, &data_len,
 417                             &rparam_len, &rdata_len);
 418         if (NT_STATUS_IS_OK(status)) return True;
 419
 420         /* try with a file descriptor */
 421         param_len = 6;
 422         SSVAL(param, 0, fnum);
 423         SSVAL(param, 2, level);
 424         SSVAL(param, 4, 0);
 425         status = try_nttrans_len(cli, "fnum", op, level, param, data, param_len, &data_len,
 426                                 &rparam_len, &rdata_len);
 427         if (NT_STATUS_IS_OK(status)) return True;
 428
 429
 430         /* try with a notify style */
 431         param_len = 6;
 432         SSVAL(param, 0, dnum);
 433         SSVAL(param, 2, dnum);
 434         SSVAL(param, 4, level);
 435         status = try_nttrans_len(cli, "notify", op, level, param, data, param_len, &data_len,
 436                                 &rparam_len, &rdata_len);
 437         if (NT_STATUS_IS_OK(status)) return True;
 438
 439         /* try with a file name */
 440         param_len = 6;
 441         SSVAL(param, 0, level);
 442         SSVAL(param, 2, 0);
 443         SSVAL(param, 4, 0);
 444         param_len += push_string(&param[6], fname, -1, STR_TERMINATE | STR_UNICODE);
 445
 446         status = try_nttrans_len(cli, "fname", op, level, param, data, param_len, &data_len,
 447                                 &rparam_len, &rdata_len);
 448         if (NT_STATUS_IS_OK(status)) return True;
 449
 450         /* try with a new file name */
 451         param_len = 6;
 452         SSVAL(param, 0, level);
 453         SSVAL(param, 2, 0);
 454         SSVAL(param, 4, 0);
 455         param_len += push_string(&param[6], "\\newfile.dat", -1, STR_TERMINATE | STR_UNICODE);
 456
 457         status = try_nttrans_len(cli, "newfile", op, level, param, data, param_len, &data_len,
 458                                 &rparam_len, &rdata_len);
 459         smbcli_unlink(cli->tree, "\\newfile.dat");
 460         smbcli_rmdir(cli->tree, "\\newfile.dat");
 461         if (NT_STATUS_IS_OK(status)) return True;
 462
 463         /* try dfs style  */
 464         smbcli_mkdir(cli->tree, "\\testdir");
 465         param_len = 2;
 466         SSVAL(param, 0, level);
 467         param_len += push_string(&param[2], "\\testdir", -1, STR_TERMINATE | STR_UNICODE);
 468
 469         status = try_nttrans_len(cli, "dfs", op, level, param, data, param_len, &data_len,
 470                                 &rparam_len, &rdata_len);
 471         smbcli_rmdir(cli->tree, "\\testdir");
 472         if (NT_STATUS_IS_OK(status)) return True;
 473
 474         return False;
 475 }
 476
 477
 478 BOOL torture_nttrans_scan(void)
 479 {
 480         static struct smbcli_state *cli;
 481         int op, level;
 482         const char *fname = "\\scanner.dat";
 483         int fnum, dnum;
 484
 485         printf("starting nttrans scan test\n");
 486
 487         if (!torture_open_connection(&cli)) {
 488                 return False;
 489         }
 490
 491         fnum = smbcli_open(cli->tree, fname, O_RDWR | O_CREAT | O_TRUNC,
 492                          DENY_NONE);
 493         dnum = smbcli_open(cli->tree, "\\", O_RDONLY, DENY_NONE);
 494
 495         for (op=OP_MIN; op<=OP_MAX; op++) {
 496                 printf("Scanning op=%d\n", op);
 497                 for (level = 0; level <= 50; level++) {
 498                         scan_nttrans(cli, op, level, fnum, dnum, fname);
 499                 }
 500
 501                 for (level = 0x100; level <= 0x130; level++) {
 502                         scan_nttrans(cli, op, level, fnum, dnum, fname);
 503                 }
 504
 505                 for (level = 1000; level < 1050; level++) {
 506                         scan_nttrans(cli, op, level, fnum, dnum, fname);
 507                 }
 508         }
 509
 510         torture_close_connection(cli);
 511
 512         printf("nttrans scan finished\n");
 513         return True;
 514 }
 515
 516
 517 /* scan for valid base SMB requests */
 518 BOOL torture_smb_scan(void)
 519 {
 520         static struct smbcli_state *cli;
 521         int op;
 522         struct smbcli_request *req;
 523         NTSTATUS status;
 524
 525         for (op=0x0;op<=0xFF;op++) {
 526                 if (op == SMBreadbraw) continue;
 527
 528                 if (!torture_open_connection(&cli)) {
 529                         return False;
 530                 }
 531
 532                 req = smbcli_request_setup(cli->tree, op, 0, 0);
 533
 534                 if (!smbcli_request_send(req)) {
 535                         smbcli_request_destroy(req);
 536                         break;
 537                 }
 538
 539                 usleep(10000);
 540                 smbcli_transport_process(cli->transport);
 541                 if (req->state > SMBCLI_REQUEST_RECV) {
 542                         status = smbcli_request_simple_recv(req);
 543                         printf("op=0x%x status=%s\n", op, nt_errstr(status));
 544                         torture_close_connection(cli);
 545                         continue;
 546                 }
 547
 548                 sleep(1);
 549                 smbcli_transport_process(cli->transport);
 550                 if (req->state > SMBCLI_REQUEST_RECV) {
 551                         status = smbcli_request_simple_recv(req);
 552                         printf("op=0x%x status=%s\n", op, nt_errstr(status));
 553                 } else {
 554                         printf("op=0x%x no reply\n", op);
 555                         smbcli_request_destroy(req);
 556                         continue; /* don't attempt close! */
 557                 }
 558
 559                 torture_close_connection(cli);
 560         }
 561
 562
 563         printf("smb scan finished\n");
 564         return True;
 565 }