root/source4/torture/rpc/wkssvc.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. test_NetWkstaGetInfo
  2. test_NetWkstaTransportEnum
  3. test_NetrWkstaTransportAdd
  4. test_NetrWkstaTransportDel
  5. test_NetWkstaEnumUsers
  6. test_NetrWkstaUserGetInfo
  7. test_NetrUseEnum
  8. test_NetrUseAdd
  9. test_NetrUseDel
  10. test_NetrUseGetInfo_level
  11. test_NetrUseGetInfo
  12. test_NetrLogonDomainNameAdd
  13. test_NetrLogonDomainNameDel
  14. test_NetrEnumerateComputerNames_level
  15. test_NetrEnumerateComputerNames
  16. test_NetrValidateName
  17. test_NetrValidateName2
  18. test_NetrAddAlternateComputerName
  19. test_NetrRemoveAlternateComputerName
  20. test_NetrSetPrimaryComputername_name
  21. test_NetrSetPrimaryComputername
  22. test_NetrRenameMachineInDomain
  23. test_NetrRenameMachineInDomain2_name
  24. test_NetrRenameMachineInDomain2
  25. test_NetrWorkstationStatisticsGet
  26. test_NetrMessageBufferSend
  27. test_NetrGetJoinInformation
  28. test_GetJoinInformation
  29. test_NetrGetJoinableOus
  30. test_NetrGetJoinableOus2
  31. test_NetrUnjoinDomain
  32. test_NetrJoinDomain
  33. encode_wkssvc_join_password_buffer
  34. test_NetrJoinDomain2
  35. test_NetrUnjoinDomain2
  36. torture_rpc_wkssvc

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for wkssvc rpc operations
   4 
   5    Copyright (C) Andrew Tridgell 2003
   6    Copyright (C) Günther Deschner 2007
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21 
  22 #include "includes.h"
  23 #include "torture/torture.h"
  24 #include "librpc/gen_ndr/ndr_wkssvc_c.h"
  25 #include "torture/rpc/rpc.h"
  26 #include "lib/cmdline/popt_common.h"
  27 #include "param/param.h"
  28 #include "../lib/crypto/crypto.h"
  29 #include "libcli/auth/libcli_auth.h"
  30 
  31 #define SMBTORTURE_MACHINE_NAME "smbtrt_name"
  32 #define SMBTORTURE_ALTERNATE_NAME "smbtrt_altname"
  33 #define SMBTORTURE_TRANSPORT_NAME "\\Device\\smbtrt_transport_name"
  34 #define SMBTORTURE_USE_NAME "S:"
  35 #define SMBTORTURE_MESSAGE "You are currently tortured by Samba"
  36 
  37 static bool test_NetWkstaGetInfo(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
  38                                  struct dcerpc_pipe *p)
  39 {
  40         NTSTATUS status;
  41         struct wkssvc_NetWkstaGetInfo r;
  42         union wkssvc_NetWkstaInfo info;
  43         uint16_t levels[] = {100, 101, 102, 502};
  44         int i;
  45 
  46         r.in.server_name = dcerpc_server_name(p);
  47         r.out.info = &info;
  48 
  49         for (i=0;i<ARRAY_SIZE(levels);i++) {
  50                 r.in.level = levels[i];
  51                 torture_comment(tctx, "testing NetWkstaGetInfo level %u\n",
  52                                 r.in.level);
  53                 status = dcerpc_wkssvc_NetWkstaGetInfo(p, tctx, &r);
  54                 torture_assert_ntstatus_ok(tctx, status,
  55                         talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
  56                                         r.in.level));
  57                 torture_assert_werr_ok(tctx, r.out.result,
  58                         talloc_asprintf(tctx, "NetWkstaGetInfo level %u failed",
  59                                         r.in.level));
  60         }
  61 
  62         return true;
  63 }
  64 
  65 static bool test_NetWkstaTransportEnum(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
  66                                        struct dcerpc_pipe *p)
  67 {
  68         NTSTATUS status;
  69         struct wkssvc_NetWkstaTransportEnum r;
  70         uint32_t resume_handle = 0;
  71         struct wkssvc_NetWkstaTransportInfo info;
  72         union wkssvc_NetWkstaTransportCtr ctr;
  73         struct wkssvc_NetWkstaTransportCtr0 ctr0;
  74         uint32_t total_entries = 0;
  75 
  76         ZERO_STRUCT(ctr0);
  77         ctr.ctr0 = &ctr0;
  78 
  79         info.level = 0;
  80         info.ctr = ctr;
  81 
  82         r.in.server_name = dcerpc_server_name(p);
  83         r.in.info = &info;
  84         r.in.max_buffer = (uint32_t)-1;
  85         r.in.resume_handle = &resume_handle;
  86         r.out.total_entries = &total_entries;
  87         r.out.info = &info;
  88         r.out.resume_handle = &resume_handle;
  89 
  90         torture_comment(tctx, "testing NetWkstaTransportEnum level 0\n");
  91 
  92         status = dcerpc_wkssvc_NetWkstaTransportEnum(p, tctx, &r);
  93         torture_assert_ntstatus_ok(tctx, status,
  94                                    "NetWkstaTransportEnum failed");
  95         torture_assert_werr_ok(tctx, r.out.result, talloc_asprintf(tctx,
  96                                "NetWkstaTransportEnum level %u failed",
  97                                info.level));
  98 
  99         return true;
 100 }
 101 
 102 static bool test_NetrWkstaTransportAdd(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 103                                        struct dcerpc_pipe *p)
 104 {
 105         NTSTATUS status;
 106         struct wkssvc_NetrWkstaTransportAdd r;
 107         struct wkssvc_NetWkstaTransportInfo0 info0;
 108         uint32_t parm_err = 0;
 109 
 110         ZERO_STRUCT(info0);
 111 
 112         info0.quality_of_service = 0xffff;
 113         info0.vc_count = 0;
 114         info0.name = SMBTORTURE_TRANSPORT_NAME;
 115         info0.address = "000000000000";
 116         info0.wan_link = 0x400;
 117 
 118         r.in.server_name = dcerpc_server_name(p);
 119         r.in.level = 0;
 120         r.in.info0 = &info0;
 121         r.in.parm_err = r.out.parm_err = &parm_err;
 122 
 123         torture_comment(tctx, "testing NetrWkstaTransportAdd level 0\n");
 124 
 125         status = dcerpc_wkssvc_NetrWkstaTransportAdd(p, tctx, &r);
 126         torture_assert_ntstatus_ok(tctx, status,
 127                                    "NetrWkstaTransportAdd failed");
 128         torture_assert_werr_equal(tctx, r.out.result,
 129                                   WERR_INVALID_PARAM,
 130                                   "NetrWkstaTransportAdd level 0 failed");
 131 
 132         return true;
 133 }
 134 
 135 static bool test_NetrWkstaTransportDel(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 136                                        struct dcerpc_pipe *p)
 137 {
 138         NTSTATUS status;
 139         struct wkssvc_NetrWkstaTransportDel r;
 140 
 141         r.in.server_name = dcerpc_server_name(p);
 142         r.in.transport_name = SMBTORTURE_TRANSPORT_NAME;
 143         r.in.unknown3 = 0;
 144 
 145         torture_comment(tctx, "testing NetrWkstaTransportDel\n");
 146 
 147         status = dcerpc_wkssvc_NetrWkstaTransportDel(p, tctx, &r);
 148         torture_assert_ntstatus_ok(tctx, status,
 149                                    "NetrWkstaTransportDel failed");
 150         torture_assert_werr_ok(tctx, r.out.result,
 151                                "NetrWkstaTransportDel");
 152 
 153         return true;
 154 }
 155 
 156 static bool test_NetWkstaEnumUsers(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 157                                    struct dcerpc_pipe *p)
 158 {
 159         NTSTATUS status;
 160         struct wkssvc_NetWkstaEnumUsers r;
 161         uint32_t handle = 0;
 162         uint32_t entries_read = 0;
 163         struct wkssvc_NetWkstaEnumUsersInfo info;
 164         struct wkssvc_NetWkstaEnumUsersCtr0 *user0;
 165         struct wkssvc_NetWkstaEnumUsersCtr1 *user1;
 166         uint32_t levels[] = { 0, 1 };
 167         int i;
 168 
 169         for (i=0; i<ARRAY_SIZE(levels); i++) {
 170 
 171                 ZERO_STRUCT(info);
 172 
 173                 info.level = levels[i];
 174                 switch (info.level) {
 175                 case 0:
 176                         user0 = talloc_zero(tctx,
 177                                             struct wkssvc_NetWkstaEnumUsersCtr0);
 178                         info.ctr.user0 = user0;
 179                         break;
 180                 case 1:
 181                         user1 = talloc_zero(tctx,
 182                                             struct wkssvc_NetWkstaEnumUsersCtr1);
 183                         info.ctr.user1 = user1;
 184                         break;
 185                 default:
 186                         break;
 187                 }
 188 
 189                 r.in.server_name = dcerpc_server_name(p);
 190                 r.in.prefmaxlen = (uint32_t)-1;
 191                 r.in.info = r.out.info = &info;
 192                 r.in.resume_handle = r.out.resume_handle = &handle;
 193 
 194                 r.out.entries_read = &entries_read;
 195 
 196                 torture_comment(tctx, "testing NetWkstaEnumUsers level %u\n",
 197                                 levels[i]);
 198 
 199                 status = dcerpc_wkssvc_NetWkstaEnumUsers(p, tctx, &r);
 200                 torture_assert_ntstatus_ok(tctx, status,
 201                                            "NetWkstaEnumUsers failed");
 202                 torture_assert_werr_ok(tctx, r.out.result,
 203                                        "NetWkstaEnumUsers failed");
 204         }
 205 
 206         return true;
 207 }
 208 
 209 static bool test_NetrWkstaUserGetInfo(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 210                                       struct dcerpc_pipe *p)
 211 {
 212         NTSTATUS status;
 213         struct wkssvc_NetrWkstaUserGetInfo r;
 214         union wkssvc_NetrWkstaUserInfo info;
 215         const char *dom = lp_workgroup(tctx->lp_ctx);
 216         struct cli_credentials *creds = cmdline_credentials;
 217         const char *user = cli_credentials_get_username(creds);
 218         int i;
 219 
 220         const struct {
 221                 const char *unknown;
 222                 uint32_t level;
 223                 WERROR result;
 224         } tests[] = {
 225                 { NULL, 0, WERR_NO_SUCH_LOGON_SESSION },
 226                 { NULL, 1, WERR_NO_SUCH_LOGON_SESSION },
 227                 { NULL, 1101, WERR_OK },
 228                 { dom, 0, WERR_INVALID_PARAM },
 229                 { dom, 1, WERR_INVALID_PARAM },
 230                 { dom, 1101, WERR_INVALID_PARAM },
 231                 { user, 0, WERR_INVALID_PARAM },
 232                 { user, 1, WERR_INVALID_PARAM },
 233                 { user, 1101, WERR_INVALID_PARAM },
 234         };
 235 
 236         for (i=0; i<ARRAY_SIZE(tests); i++) {
 237                 r.in.unknown = tests[i].unknown;
 238                 r.in.level = tests[i].level;
 239                 r.out.info = &info;
 240 
 241                 torture_comment(tctx, "testing NetrWkstaUserGetInfo level %u\n",
 242                                 r.in.level);
 243 
 244                 status = dcerpc_wkssvc_NetrWkstaUserGetInfo(p, tctx, &r);
 245                 torture_assert_ntstatus_ok(tctx, status,
 246                                            "NetrWkstaUserGetInfo failed");
 247                 torture_assert_werr_equal(tctx, r.out.result,
 248                                           tests[i].result,
 249                                           "NetrWkstaUserGetInfo failed");
 250         }
 251 
 252         return true;
 253 }
 254 
 255 static bool test_NetrUseEnum(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 256                              struct dcerpc_pipe *p)
 257 {
 258         NTSTATUS status;
 259         struct wkssvc_NetrUseEnum r;
 260         uint32_t handle = 0;
 261         uint32_t entries_read = 0;
 262         struct wkssvc_NetrUseEnumInfo info;
 263         struct wkssvc_NetrUseEnumCtr0 *use0;
 264         struct wkssvc_NetrUseEnumCtr1 *use1;
 265         struct wkssvc_NetrUseEnumCtr2 *use2;
 266         uint32_t levels[] = { 0, 1, 2 };
 267         int i;
 268 
 269         for (i=0; i<ARRAY_SIZE(levels); i++) {
 270 
 271                 ZERO_STRUCT(info);
 272 
 273                 info.level = levels[i];
 274                 switch (info.level) {
 275                 case 0:
 276                         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 277                         info.ctr.ctr0 = use0;
 278                         break;
 279                 case 1:
 280                         use1 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr1);
 281                         info.ctr.ctr1 = use1;
 282                         break;
 283                 case 2:
 284                         use2 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr2);
 285                         info.ctr.ctr2 = use2;
 286                         break;
 287                 default:
 288                         break;
 289                 }
 290 
 291                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 292                 r.in.prefmaxlen = (uint32_t)-1;
 293                 r.in.info = r.out.info = &info;
 294                 r.in.resume_handle = r.out.resume_handle = &handle;
 295 
 296                 r.out.entries_read = &entries_read;
 297 
 298                 torture_comment(tctx, "testing NetrUseEnum level %u\n",
 299                                 levels[i]);
 300 
 301                 status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 302                 torture_assert_ntstatus_ok(tctx, status,
 303                                            "NetrUseEnum failed");
 304                 torture_assert_werr_ok(tctx, r.out.result,
 305                                        "NetrUseEnum failed");
 306         }
 307 
 308         return true;
 309 }
 310 
 311 static bool test_NetrUseAdd(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 312                             struct dcerpc_pipe *p)
 313 {
 314         NTSTATUS status;
 315         struct wkssvc_NetrUseAdd r;
 316         struct wkssvc_NetrUseInfo0 info0;
 317         struct wkssvc_NetrUseInfo1 info1;
 318         union wkssvc_NetrUseGetInfoCtr *ctr;
 319         uint32_t parm_err = 0;
 320 
 321         ctr = talloc(tctx, union wkssvc_NetrUseGetInfoCtr);
 322 
 323         ZERO_STRUCT(info0);
 324 
 325         info0.local = SMBTORTURE_USE_NAME;
 326         info0.remote = "\\\\localhost\\c$";
 327 
 328         ctr->info0 = &info0;
 329 
 330         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 331         r.in.level = 0;
 332         r.in.ctr = ctr;
 333         r.in.parm_err = r.out.parm_err = &parm_err;
 334 
 335         torture_comment(tctx, "testing NetrUseAdd level %u\n",
 336                         r.in.level);
 337 
 338         status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 339         torture_assert_ntstatus_ok(tctx, status,
 340                                    "NetrUseAdd failed");
 341         torture_assert_werr_equal(tctx, r.out.result, WERR_UNKNOWN_LEVEL,
 342                                "NetrUseAdd failed");
 343 
 344         ZERO_STRUCT(r);
 345         ZERO_STRUCT(info1);
 346 
 347         info1.local = SMBTORTURE_USE_NAME;
 348         info1.remote = "\\\\localhost\\sysvol";
 349         info1.password = NULL;
 350 
 351         ctr->info1 = &info1;
 352 
 353         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 354         r.in.level = 1;
 355         r.in.ctr = ctr;
 356         r.in.parm_err = r.out.parm_err = &parm_err;
 357 
 358         torture_comment(tctx, "testing NetrUseAdd level %u\n",
 359                         r.in.level);
 360 
 361         status = dcerpc_wkssvc_NetrUseAdd(p, tctx, &r);
 362         torture_assert_ntstatus_ok(tctx, status,
 363                                    "NetrUseAdd failed");
 364         torture_assert_werr_ok(tctx, r.out.result,
 365                                "NetrUseAdd failed");
 366 
 367         return true;
 368 }
 369 
 370 static bool test_NetrUseDel(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 371                             struct dcerpc_pipe *p)
 372 {
 373         NTSTATUS status;
 374         struct wkssvc_NetrUseDel r;
 375 
 376         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 377         r.in.use_name = SMBTORTURE_USE_NAME;
 378         r.in.force_cond = 0;
 379 
 380         torture_comment(tctx, "testing NetrUseDel\n");
 381 
 382         status = dcerpc_wkssvc_NetrUseDel(p, tctx, &r);
 383         torture_assert_ntstatus_ok(tctx, status,
 384                                    "NetrUseDel failed");
 385         torture_assert_werr_ok(tctx, r.out.result,
 386                                "NetrUseDel failed");
 387         return true;
 388 }
 389 
 390 static bool test_NetrUseGetInfo_level(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 391                                       struct dcerpc_pipe *p,
 392                                       const char *use_name,
 393                                       uint32_t level,
 394                                       WERROR werr)
 395 {
 396         NTSTATUS status;
 397         struct wkssvc_NetrUseGetInfo r;
 398         union wkssvc_NetrUseGetInfoCtr ctr;
 399 
 400         ZERO_STRUCT(ctr);
 401 
 402         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 403         r.in.use_name = use_name;
 404         r.in.level = level;
 405         r.out.ctr = &ctr;
 406         status = dcerpc_wkssvc_NetrUseGetInfo(p, tctx, &r);
 407 
 408         torture_assert_ntstatus_ok(tctx, status,
 409                                    "NetrUseGetInfo failed");
 410         torture_assert_werr_equal(tctx, r.out.result, werr,
 411                                   "NetrUseGetInfo failed");
 412         return true;
 413 }
 414 
 415 static bool test_NetrUseGetInfo(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 416                                 struct dcerpc_pipe *p)
 417 {
 418         NTSTATUS status;
 419         struct wkssvc_NetrUseEnum r;
 420         uint32_t handle = 0;
 421         uint32_t entries_read = 0;
 422         struct wkssvc_NetrUseEnumInfo info;
 423         struct wkssvc_NetrUseEnumCtr0 *use0;
 424         uint32_t levels[] = { 0, 1, 2 };
 425         const char *use_name = NULL;
 426         int i, k;
 427 
 428         ZERO_STRUCT(info);
 429 
 430         info.level = 0;
 431         use0 = talloc_zero(tctx, struct wkssvc_NetrUseEnumCtr0);
 432         info.ctr.ctr0 = use0;
 433 
 434         r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 435         r.in.prefmaxlen = (uint32_t)-1;
 436         r.in.info = r.out.info = &info;
 437         r.in.resume_handle = r.out.resume_handle = &handle;
 438         r.out.entries_read = &entries_read;
 439 
 440         status = dcerpc_wkssvc_NetrUseEnum(p, tctx, &r);
 441         torture_assert_ntstatus_ok(tctx, status,
 442                                    "NetrUseEnum failed");
 443         torture_assert_werr_ok(tctx, r.out.result,
 444                                "NetrUseEnum failed");
 445 
 446         for (k=0; k < r.out.info->ctr.ctr0->count; k++) {
 447 
 448                 use_name = r.out.info->ctr.ctr0->array[k].local;
 449 
 450                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 451 
 452                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 453                                                        levels[i],
 454                                                        WERR_OK))
 455                         {
 456                                 if (levels[i] != 0) {
 457                                         return false;
 458                                 }
 459                         }
 460                 }
 461 
 462                 use_name = r.out.info->ctr.ctr0->array[k].remote;
 463 
 464                 for (i=0; i<ARRAY_SIZE(levels); i++) {
 465 
 466                         if (!test_NetrUseGetInfo_level(tctx, p, use_name,
 467                                                        levels[i],
 468                                                        WERR_NOT_CONNECTED))
 469                         {
 470                                 if (levels[i] != 0) {
 471                                         return false;
 472                                 }
 473                         }
 474                 }
 475         }
 476 
 477         return true;
 478 }
 479 
 480 static bool test_NetrLogonDomainNameAdd(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 481                                         struct dcerpc_pipe *p)
 482 {
 483         NTSTATUS status;
 484         struct wkssvc_NetrLogonDomainNameAdd r;
 485 
 486         r.in.domain_name = lp_workgroup(tctx->lp_ctx);
 487 
 488         torture_comment(tctx, "testing NetrLogonDomainNameAdd\n");
 489 
 490         status = dcerpc_wkssvc_NetrLogonDomainNameAdd(p, tctx, &r);
 491         torture_assert_ntstatus_ok(tctx, status,
 492                                    "NetrLogonDomainNameAdd failed");
 493         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 494                                   "NetrLogonDomainNameAdd failed");
 495         return true;
 496 }
 497 
 498 static bool test_NetrLogonDomainNameDel(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 499                                         struct dcerpc_pipe *p)
 500 {
 501         NTSTATUS status;
 502         struct wkssvc_NetrLogonDomainNameDel r;
 503 
 504         r.in.domain_name = lp_workgroup(tctx->lp_ctx);
 505 
 506         torture_comment(tctx, "testing NetrLogonDomainNameDel\n");
 507 
 508         status = dcerpc_wkssvc_NetrLogonDomainNameDel(p, tctx, &r);
 509         torture_assert_ntstatus_ok(tctx, status,
 510                                    "NetrLogonDomainNameDel failed");
 511         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 512                                   "NetrLogonDomainNameDel failed");
 513         return true;
 514 }
 515 
 516 static bool test_NetrEnumerateComputerNames_level(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 517                                                   struct dcerpc_pipe *p,
 518                                                   uint16_t level,
 519                                                   const char ***names,
 520                                                   int *num_names)
 521 {
 522         NTSTATUS status;
 523         struct wkssvc_NetrEnumerateComputerNames r;
 524         struct wkssvc_ComputerNamesCtr *ctr;
 525         int i;
 526 
 527         ctr = talloc_zero(tctx, struct wkssvc_ComputerNamesCtr);
 528 
 529         r.in.server_name = dcerpc_server_name(p);
 530         r.in.name_type = level;
 531         r.in.Reserved = 0;
 532         r.out.ctr = &ctr;
 533 
 534         torture_comment(tctx, "testing NetrEnumerateComputerNames level %u\n",
 535                         r.in.name_type);
 536 
 537         status = dcerpc_wkssvc_NetrEnumerateComputerNames(p, tctx, &r);
 538         torture_assert_ntstatus_ok(tctx, status,
 539                                    "NetrEnumerateComputerNames failed");
 540         torture_assert_werr_ok(tctx, r.out.result,
 541                                "NetrEnumerateComputerNames failed");
 542 
 543         if ((level == NetPrimaryComputerName) && ctr->count != 1) {
 544                 torture_comment(tctx,
 545                                 "NetrEnumerateComputerNames did not return one "
 546                                 "name but %u\n", ctr->count);
 547                 return false;
 548         }
 549 
 550         if (names && num_names) {
 551                 *num_names = 0;
 552                 *names = NULL;
 553                 for (i=0; i<ctr->count; i++) {
 554                         if (!add_string_to_array(tctx,
 555                                                  ctr->computer_name[i].string,
 556                                                  names,
 557                                                  num_names))
 558                         {
 559                                 return false;
 560                         }
 561                 }
 562         }
 563 
 564         return true;
 565 }
 566 
 567 static bool test_NetrEnumerateComputerNames(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 568                                             struct dcerpc_pipe *p)
 569 {
 570         uint16_t levels[] = {0,1,2};
 571         int i;
 572 
 573         for (i=0; i<ARRAY_SIZE(levels); i++) {
 574 
 575                 if (!test_NetrEnumerateComputerNames_level(tctx,
 576                                                            p,
 577                                                            levels[i],
 578                                                            NULL, NULL))
 579                 {
 580                         return false;
 581                 }
 582         }
 583 
 584         return true;
 585 }
 586 
 587 static bool test_NetrValidateName(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 588                                   struct dcerpc_pipe *p)
 589 {
 590         NTSTATUS status;
 591         struct wkssvc_NetrValidateName r;
 592         uint16_t levels[] = {0,1,2,3,4,5};
 593         int i;
 594 
 595         for (i=0; i<ARRAY_SIZE(levels); i++) {
 596 
 597                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 598                 r.in.name = lp_workgroup(tctx->lp_ctx);
 599                 r.in.Account = NULL;
 600                 r.in.Password = NULL;
 601                 r.in.name_type = levels[i];
 602 
 603                 torture_comment(tctx, "testing NetrValidateName level %u\n",
 604                                 r.in.name_type);
 605 
 606                 status = dcerpc_wkssvc_NetrValidateName(p, tctx, &r);
 607                 torture_assert_ntstatus_ok(tctx, status,
 608                                            "NetrValidateName failed");
 609                 torture_assert_werr_equal(tctx, r.out.result,
 610                                           WERR_NOT_SUPPORTED,
 611                                           "NetrValidateName failed");
 612         }
 613 
 614         return true;
 615 }
 616 
 617 static bool test_NetrValidateName2(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 618                                    struct dcerpc_pipe *p)
 619 {
 620         NTSTATUS status;
 621         struct wkssvc_NetrValidateName2 r;
 622         uint16_t levels[] = {0,1,2,3,4,5};
 623         int i;
 624 
 625         for (i=0; i<ARRAY_SIZE(levels); i++) {
 626 
 627                 r.in.server_name = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
 628                 r.in.name = lp_workgroup(tctx->lp_ctx);
 629                 r.in.Account = NULL;
 630                 r.in.EncryptedPassword = NULL;
 631                 r.in.name_type = levels[i];
 632 
 633                 torture_comment(tctx, "testing NetrValidateName2 level %u\n",
 634                                 r.in.name_type);
 635 
 636                 status = dcerpc_wkssvc_NetrValidateName2(p, tctx, &r);
 637                 torture_assert_ntstatus_ok(tctx, status,
 638                                            "NetrValidateName2 failed");
 639                 torture_assert_werr_equal(tctx, r.out.result,
 640                                           WERR_RPC_E_REMOTE_DISABLED,
 641                                           "NetrValidateName2 failed");
 642         }
 643 
 644         return true;
 645 }
 646 
 647 static bool test_NetrAddAlternateComputerName(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 648                                               struct dcerpc_pipe *p)
 649 {
 650         NTSTATUS status;
 651         struct wkssvc_NetrAddAlternateComputerName r;
 652         const char **names = NULL;
 653         int num_names = 0;
 654         int i;
 655 
 656         r.in.server_name = dcerpc_server_name(p);
 657         r.in.NewAlternateMachineName = SMBTORTURE_ALTERNATE_NAME;
 658         r.in.Account = NULL;
 659         r.in.EncryptedPassword = NULL;
 660         r.in.Reserved = 0;
 661 
 662         torture_comment(tctx, "testing NetrAddAlternateComputerName\n");
 663 
 664         status = dcerpc_wkssvc_NetrAddAlternateComputerName(p, tctx, &r);
 665         torture_assert_ntstatus_ok(tctx, status,
 666                                    "NetrAddAlternateComputerName failed");
 667         torture_assert_werr_ok(tctx, r.out.result,
 668                                "NetrAddAlternateComputerName failed");
 669 
 670         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 671                                                    NetAlternateComputerNames,
 672                                                    &names, &num_names))
 673         {
 674                 return false;
 675         }
 676 
 677         for (i=0; i<num_names; i++) {
 678                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 679                         return true;
 680                 }
 681         }
 682 
 683         torture_comment(tctx, "new alternate name not set\n");
 684 
 685         return false;
 686 }
 687 
 688 static bool test_NetrRemoveAlternateComputerName(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 689                                                  struct dcerpc_pipe *p)
 690 {
 691         NTSTATUS status;
 692         struct wkssvc_NetrRemoveAlternateComputerName r;
 693         const char **names = NULL;
 694         int num_names = 0;
 695         int i;
 696 
 697         r.in.server_name = dcerpc_server_name(p);
 698         r.in.AlternateMachineNameToRemove = SMBTORTURE_ALTERNATE_NAME;
 699         r.in.Account = NULL;
 700         r.in.EncryptedPassword = NULL;
 701         r.in.Reserved = 0;
 702 
 703         torture_comment(tctx, "testing NetrRemoveAlternateComputerName\n");
 704 
 705         status = dcerpc_wkssvc_NetrRemoveAlternateComputerName(p, tctx, &r);
 706         torture_assert_ntstatus_ok(tctx, status,
 707                                    "NetrRemoveAlternateComputerName failed");
 708         torture_assert_werr_ok(tctx, r.out.result,
 709                                "NetrRemoveAlternateComputerName failed");
 710 
 711         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 712                                                    NetAlternateComputerNames,
 713                                                    &names, &num_names))
 714         {
 715                 return false;
 716         }
 717 
 718         for (i=0; i<num_names; i++) {
 719                 if (strequal(names[i], SMBTORTURE_ALTERNATE_NAME)) {
 720                         return false;
 721                 }
 722         }
 723 
 724         return true;
 725 }
 726 
 727 static bool test_NetrSetPrimaryComputername_name(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 728                                                  struct dcerpc_pipe *p,
 729                                                  const char *name)
 730 {
 731         NTSTATUS status;
 732         struct wkssvc_NetrSetPrimaryComputername r;
 733 
 734         r.in.server_name = dcerpc_server_name(p);
 735         r.in.primary_name = name;
 736         r.in.Account = NULL;
 737         r.in.EncryptedPassword = NULL;
 738         r.in.Reserved = 0;
 739 
 740         status = dcerpc_wkssvc_NetrSetPrimaryComputername(p, tctx, &r);
 741         torture_assert_ntstatus_ok(tctx, status,
 742                                    "NetrSetPrimaryComputername failed");
 743         torture_assert_werr_ok(tctx, r.out.result,
 744                                "NetrSetPrimaryComputername failed");
 745         return true;
 746 }
 747 
 748 
 749 static bool test_NetrSetPrimaryComputername(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 750                                             struct dcerpc_pipe *p)
 751 {
 752         /*
 753           add alternate,
 754           check if there
 755           store old primary
 756           set new primary (alternate)
 757           check if there
 758           later: check if del is possible
 759           set primary back to origin
 760           check if there
 761           del alternate
 762         */
 763 
 764         const char **names_o = NULL, **names = NULL;
 765         int num_names_o = 0, num_names = 0;
 766 
 767         torture_comment(tctx, "testing NetrSetPrimaryComputername\n");
 768 
 769         if (!test_NetrAddAlternateComputerName(tctx, p)) {
 770                 return false;
 771         }
 772 
 773         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 774                                                    NetPrimaryComputerName,
 775                                                    &names_o, &num_names_o))
 776         {
 777                 return false;
 778         }
 779 
 780         if (num_names_o != 1) {
 781                 return false;
 782         }
 783 
 784         if (!test_NetrSetPrimaryComputername_name(tctx, p,
 785                                                   SMBTORTURE_ALTERNATE_NAME))
 786         {
 787                 return false;
 788         }
 789 
 790         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 791                                                    NetPrimaryComputerName,
 792                                                    &names, &num_names))
 793         {
 794                 return false;
 795         }
 796 
 797         if (num_names != 1) {
 798                 return false;
 799         }
 800 
 801         if (!strequal(names[0], SMBTORTURE_ALTERNATE_NAME)) {
 802                 torture_comment(tctx,
 803                                 "name mismatch (%s != %s) after NetrSetPrimaryComputername!\n",
 804                                 names[0], SMBTORTURE_ALTERNATE_NAME);
 805                 /*return false */;
 806         }
 807 
 808         if (!test_NetrSetPrimaryComputername_name(tctx, p,
 809                                                   names_o[0]))
 810         {
 811                 return false;
 812         }
 813 
 814         if (!test_NetrRemoveAlternateComputerName(tctx, p)) {
 815                 return false;
 816         }
 817 
 818 
 819         return true;
 820 }
 821 
 822 static bool test_NetrRenameMachineInDomain(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 823                                            struct dcerpc_pipe *p)
 824 {
 825         NTSTATUS status;
 826         struct wkssvc_NetrRenameMachineInDomain r;
 827 
 828         r.in.server_name = dcerpc_server_name(p);
 829         r.in.NewMachineName = SMBTORTURE_MACHINE_NAME;
 830         r.in.Account = NULL;
 831         r.in.password = NULL;
 832         r.in.RenameOptions = 0;
 833 
 834         torture_comment(tctx, "testing NetrRenameMachineInDomain\n");
 835 
 836         status = dcerpc_wkssvc_NetrRenameMachineInDomain(p, tctx, &r);
 837         torture_assert_ntstatus_ok(tctx, status,
 838                                    "NetrRenameMachineInDomain failed");
 839         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
 840                                   "NetrRenameMachineInDomain failed");
 841         return true;
 842 }
 843 
 844 static bool test_NetrRenameMachineInDomain2_name(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 845                                                  struct dcerpc_pipe *p,
 846                                                  const char *new_name)
 847 {
 848         NTSTATUS status;
 849         struct wkssvc_NetrRenameMachineInDomain2 r;
 850 
 851         r.in.server_name = dcerpc_server_name(p);
 852         r.in.NewMachineName = new_name;
 853         r.in.Account = NULL;
 854         r.in.EncryptedPassword = NULL;
 855         r.in.RenameOptions = 0;
 856 
 857         status = dcerpc_wkssvc_NetrRenameMachineInDomain2(p, tctx, &r);
 858         torture_assert_ntstatus_ok(tctx, status,
 859                                    "NetrRenameMachineInDomain2 failed");
 860         torture_assert_werr_ok(tctx, r.out.result,
 861                                "NetrRenameMachineInDomain2 failed");
 862         return true;
 863 }
 864 
 865 static bool test_NetrRenameMachineInDomain2(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 866                                             struct dcerpc_pipe *p)
 867 {
 868         const char **names_o = NULL, **names = NULL;
 869         int num_names_o = 0, num_names = 0;
 870 
 871         torture_comment(tctx, "testing NetrRenameMachineInDomain2\n");
 872 
 873         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 874                                                    NetPrimaryComputerName,
 875                                                    &names_o, &num_names_o))
 876         {
 877                 return false;
 878         }
 879 
 880         if (num_names_o != 1) {
 881                 return false;
 882         }
 883 
 884         if (!test_NetrRenameMachineInDomain2_name(tctx, p,
 885                                                   SMBTORTURE_MACHINE_NAME))
 886         {
 887                 return false;
 888         }
 889 
 890         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 891                                                    NetPrimaryComputerName,
 892                                                    &names, &num_names))
 893         {
 894                 return false;
 895         }
 896 
 897         if (num_names != 1) {
 898                 return false;
 899         }
 900 
 901         if (strequal(names[0], names_o[0])) {
 902                 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
 903                 return false;
 904         }
 905 
 906         if (!strequal(names[0], SMBTORTURE_MACHINE_NAME)) {
 907                 test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]);
 908                 return false;
 909         }
 910 
 911         if (!test_NetrRenameMachineInDomain2_name(tctx, p, names_o[0]))
 912         {
 913                 return false;
 914         }
 915 
 916         if (!test_NetrEnumerateComputerNames_level(tctx, p,
 917                                                    NetPrimaryComputerName,
 918                                                    &names, &num_names))
 919         {
 920                 return false;
 921         }
 922 
 923         if (num_names != 1) {
 924                 return false;
 925         }
 926 
 927         if (!strequal(names[0], names_o[0])) {
 928                 return false;
 929         }
 930 
 931         return true;
 932 }
 933 
 934 static bool test_NetrWorkstationStatisticsGet(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 935                                               struct dcerpc_pipe *p)
 936 {
 937         NTSTATUS status;
 938         struct wkssvc_NetrWorkstationStatisticsGet r;
 939         struct wkssvc_NetrWorkstationStatistics *info;
 940 
 941         ZERO_STRUCT(r);
 942 
 943         info = talloc_zero(tctx, struct wkssvc_NetrWorkstationStatistics);
 944 
 945         r.in.server_name = dcerpc_server_name(p);
 946         r.out.info = &info;
 947 
 948         torture_comment(tctx, "testing NetrWorkstationStatisticsGet\n");
 949 
 950         status = dcerpc_wkssvc_NetrWorkstationStatisticsGet(p, tctx, &r);
 951         torture_assert_ntstatus_ok(tctx, status,
 952                                    "NetrWorkstationStatisticsGet failed");
 953         torture_assert_werr_ok(tctx, r.out.result,
 954                                "NetrWorkstationStatisticsGet failed");
 955         return true;
 956 }
 957 
 958 /* only succeeds as long as the local messenger service is running - Guenther */
 959 
 960 static bool test_NetrMessageBufferSend(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 961                                        struct dcerpc_pipe *p)
 962 {
 963         NTSTATUS status;
 964         struct wkssvc_NetrMessageBufferSend r;
 965         const char *message = SMBTORTURE_MESSAGE;
 966         size_t size;
 967         uint8_t *msg;
 968 
 969         push_ucs2_talloc(tctx, (void **)&msg, message, &size);
 970 
 971         r.in.server_name = dcerpc_server_name(p);
 972         r.in.message_name = dcerpc_server_name(p);
 973         r.in.message_sender_name = dcerpc_server_name(p);
 974         r.in.message_buffer = msg;
 975         r.in.message_size = size;
 976 
 977         torture_comment(tctx, "testing NetrMessageBufferSend\n");
 978 
 979         status = dcerpc_wkssvc_NetrMessageBufferSend(p, tctx, &r);
 980         torture_assert_ntstatus_ok(tctx, status,
 981                                    "NetrMessageBufferSend failed");
 982         torture_assert_werr_ok(tctx, r.out.result,
 983                                "NetrMessageBufferSend failed");
 984         return true;
 985 }
 986 
 987 static bool test_NetrGetJoinInformation(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
 988                                         struct dcerpc_pipe *p)
 989 {
 990         NTSTATUS status;
 991         struct wkssvc_NetrGetJoinInformation r;
 992         enum wkssvc_NetJoinStatus join_status;
 993         const char *name_buffer = "";
 994 
 995         r.in.server_name = dcerpc_server_name(p);
 996         r.in.name_buffer = r.out.name_buffer = &name_buffer;
 997         r.out.name_type = &join_status;
 998 
 999         torture_comment(tctx, "testing NetrGetJoinInformation\n");
1000 
1001         status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
1002         torture_assert_ntstatus_ok(tctx, status,
1003                                    "NetrGetJoinInformation failed");
1004         torture_assert_werr_ok(tctx, r.out.result,
1005                                "NetrGetJoinInformation failed");
1006         return true;
1007 }
1008 
1009 static bool test_GetJoinInformation(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1010                                     struct dcerpc_pipe *p,
1011                                     enum wkssvc_NetJoinStatus *join_status_p,
1012                                     const char **name)
1013 {
1014         NTSTATUS status;
1015         struct wkssvc_NetrGetJoinInformation r;
1016         enum wkssvc_NetJoinStatus join_status;
1017         const char *name_buffer = "";
1018 
1019         r.in.server_name = dcerpc_server_name(p);
1020         r.in.name_buffer = r.out.name_buffer = &name_buffer;
1021         r.out.name_type = &join_status;
1022 
1023         status = dcerpc_wkssvc_NetrGetJoinInformation(p, tctx, &r);
1024         torture_assert_ntstatus_ok(tctx, status,
1025                                    "NetrGetJoinInformation failed");
1026         torture_assert_werr_ok(tctx, r.out.result,
1027                                "NetrGetJoinInformation failed");
1028 
1029         if (join_status_p) {
1030                 *join_status_p = join_status;
1031         }
1032 
1033         if (*name) {
1034                 *name = talloc_strdup(tctx, name_buffer);
1035         }
1036 
1037         return true;
1038 
1039 }
1040 
1041 static bool test_NetrGetJoinableOus(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1042                                     struct dcerpc_pipe *p)
1043 {
1044         NTSTATUS status;
1045         struct wkssvc_NetrGetJoinableOus r;
1046         uint32_t num_ous = 0;
1047         const char **ous = NULL;
1048 
1049         r.in.server_name = dcerpc_server_name(p);
1050         r.in.domain_name = lp_workgroup(tctx->lp_ctx);
1051         r.in.Account = NULL;
1052         r.in.unknown = NULL;
1053         r.in.num_ous = r.out.num_ous = &num_ous;
1054         r.out.ous = &ous;
1055 
1056         torture_comment(tctx, "testing NetrGetJoinableOus\n");
1057 
1058         status = dcerpc_wkssvc_NetrGetJoinableOus(p, tctx, &r);
1059         torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus failed");
1060         torture_assert_werr_equal(tctx, r.out.result,
1061                                   WERR_NOT_SUPPORTED,
1062                                   "NetrGetJoinableOus failed");
1063 
1064         return true;
1065 }
1066 
1067 static bool test_NetrGetJoinableOus2(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1068                                      struct dcerpc_pipe *p)
1069 {
1070         NTSTATUS status;
1071         struct wkssvc_NetrGetJoinableOus2 r;
1072         uint32_t num_ous = 0;
1073         const char **ous = NULL;
1074 
1075         r.in.server_name = dcerpc_server_name(p);
1076         r.in.domain_name = lp_workgroup(tctx->lp_ctx);
1077         r.in.Account = NULL;
1078         r.in.EncryptedPassword = NULL;
1079         r.in.num_ous = r.out.num_ous = &num_ous;
1080         r.out.ous = &ous;
1081 
1082         torture_comment(tctx, "testing NetrGetJoinableOus2\n");
1083 
1084         status = dcerpc_wkssvc_NetrGetJoinableOus2(p, tctx, &r);
1085         torture_assert_ntstatus_ok(tctx, status, "NetrGetJoinableOus2 failed");
1086         torture_assert_werr_equal(tctx, r.out.result,
1087                                   WERR_RPC_E_REMOTE_DISABLED,
1088                                   "NetrGetJoinableOus2 failed");
1089 
1090         return true;
1091 }
1092 
1093 static bool test_NetrUnjoinDomain(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1094                                   struct dcerpc_pipe *p)
1095 {
1096         NTSTATUS status;
1097         struct wkssvc_NetrUnjoinDomain r;
1098         struct cli_credentials *creds = cmdline_credentials;
1099         const char *user = cli_credentials_get_username(creds);
1100         const char *admin_account = NULL;
1101 
1102         admin_account = talloc_asprintf(tctx, "%s\\%s",
1103                                         lp_workgroup(tctx->lp_ctx),
1104                                         user);
1105 
1106         r.in.server_name = dcerpc_server_name(p);
1107         r.in.Account = admin_account;
1108         r.in.password = NULL;
1109         r.in.unjoin_flags = 0;
1110 
1111         torture_comment(tctx, "testing NetrUnjoinDomain\n");
1112 
1113         status = dcerpc_wkssvc_NetrUnjoinDomain(p, tctx, &r);
1114         torture_assert_ntstatus_ok(tctx, status,
1115                                    "NetrUnjoinDomain failed");
1116         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1117                                   "NetrUnjoinDomain failed");
1118         return true;
1119 }
1120 
1121 static bool test_NetrJoinDomain(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1122                                 struct dcerpc_pipe *p)
1123 {
1124         NTSTATUS status;
1125         struct wkssvc_NetrJoinDomain r;
1126         struct cli_credentials *creds = cmdline_credentials;
1127         const char *user = cli_credentials_get_username(creds);
1128         const char *admin_account = NULL;
1129 
1130         admin_account = talloc_asprintf(tctx, "%s\\%s",
1131                                         lp_workgroup(tctx->lp_ctx),
1132                                         user);
1133 
1134         r.in.server_name = dcerpc_server_name(p);
1135         r.in.domain_name = lp_realm(tctx->lp_ctx);
1136         r.in.account_ou = NULL;
1137         r.in.Account = admin_account;
1138         r.in.password = NULL;
1139         r.in.join_flags = 0;
1140 
1141         torture_comment(tctx, "testing NetrJoinDomain\n");
1142 
1143         status = dcerpc_wkssvc_NetrJoinDomain(p, tctx, &r);
1144         torture_assert_ntstatus_ok(tctx, status,
1145                                    "NetrJoinDomain failed");
1146         torture_assert_werr_equal(tctx, r.out.result, WERR_NOT_SUPPORTED,
1147                                   "NetrJoinDomain failed");
1148         return true;
1149 }
1150 
1151 /* encode a wkssvc_PasswordBuffer for remote joining/unjoining:
1152  *
1153  * similar to samr_CryptPasswordEx. Different: 8byte confounder (instead of
1154  * 16byte), confounder in front of the 516 byte buffer (instead of after that
1155  * buffer), calling MD5Update() first with session_key and then with confounder
1156  * (vice versa in samr) - Guenther */
1157 
1158 static void encode_wkssvc_join_password_buffer(TALLOC_CTX *mem_ctx,
     /* [<][>][^][v][top][bottom][index][help] */
1159                                                const char *pwd,
1160                                                DATA_BLOB *session_key,
1161                                                struct wkssvc_PasswordBuffer *pwd_buf)
1162 {
1163         uint8_t buffer[516];
1164         struct MD5Context ctx;
1165 
1166         DATA_BLOB confounded_session_key = data_blob_talloc(mem_ctx, NULL, 16);
1167 
1168         int confounder_len = 8;
1169         uint8_t confounder[8];
1170 
1171         encode_pw_buffer(buffer, pwd, STR_UNICODE);
1172 
1173         generate_random_buffer((uint8_t *)confounder, confounder_len);
1174 
1175         MD5Init(&ctx);
1176         MD5Update(&ctx, session_key->data, session_key->length);
1177         MD5Update(&ctx, confounder, confounder_len);
1178         MD5Final(confounded_session_key.data, &ctx);
1179 
1180         arcfour_crypt_blob(buffer, 516, &confounded_session_key);
1181 
1182         memcpy(&pwd_buf->data[0], confounder, confounder_len);
1183         memcpy(&pwd_buf->data[8], buffer, 516);
1184 
1185         data_blob_free(&confounded_session_key);
1186 }
1187 
1188 /*
1189  * prerequisites for remotely joining an unjoined XP SP2 workstation:
1190  * - firewall needs to be disabled (or open for ncacn_np access)
1191  * - HKLM\System\CurrentControlSet\Control\Lsa\forceguest needs to 0
1192  * see also:
1193  * http://support.microsoft.com/kb/294355/EN-US/ and
1194  * http://support.microsoft.com/kb/290403/EN-US/
1195  */
1196 
1197 static bool test_NetrJoinDomain2(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1198                                  struct dcerpc_pipe *p)
1199 {
1200         NTSTATUS status;
1201         struct wkssvc_NetrJoinDomain2 r;
1202         const char *domain_admin_account = NULL;
1203         const char *domain_admin_password = NULL;
1204         const char *domain_name = NULL;
1205         struct wkssvc_PasswordBuffer pwd_buf;
1206         enum wkssvc_NetJoinStatus join_status;
1207         const char *join_name = NULL;
1208         WERROR expected_err;
1209         DATA_BLOB session_key;
1210 
1211         /* FIXME: this test assumes to join workstations / servers and does not
1212          * handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
1213 
1214         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1215         {
1216                 return false;
1217         }
1218 
1219         switch (join_status) {
1220                 case NET_SETUP_DOMAIN_NAME:
1221                         expected_err = WERR_SETUP_ALREADY_JOINED;
1222                         break;
1223                 case NET_SETUP_UNKNOWN_STATUS:
1224                 case NET_SETUP_UNJOINED:
1225                 case NET_SETUP_WORKGROUP_NAME:
1226                 default:
1227                         expected_err = WERR_OK;
1228                         break;
1229         }
1230 
1231         domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1232 
1233         domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1234 
1235         domain_name = torture_setting_string(tctx, "domain_name", NULL);
1236 
1237         if ((domain_admin_account == NULL) ||
1238             (domain_admin_password == NULL) ||
1239             (domain_name == NULL)) {
1240                 torture_comment(tctx, "not enough input parameter\n");
1241                 return false;
1242         }
1243 
1244         status = dcerpc_fetch_session_key(p, &session_key);
1245         if (!NT_STATUS_IS_OK(status)) {
1246                 return false;
1247         }
1248 
1249         encode_wkssvc_join_password_buffer(tctx, domain_admin_password,
1250                                            &session_key, &pwd_buf);
1251 
1252         r.in.server_name = dcerpc_server_name(p);
1253         r.in.domain_name = domain_name;
1254         r.in.account_ou = NULL;
1255         r.in.admin_account = domain_admin_account;
1256         r.in.encrypted_password = &pwd_buf;
1257         r.in.join_flags = WKSSVC_JOIN_FLAGS_JOIN_TYPE |
1258                           WKSSVC_JOIN_FLAGS_ACCOUNT_CREATE;
1259 
1260         torture_comment(tctx, "testing NetrJoinDomain2 (assuming non-DC)\n");
1261 
1262         status = dcerpc_wkssvc_NetrJoinDomain2(p, tctx, &r);
1263         torture_assert_ntstatus_ok(tctx, status,
1264                                    "NetrJoinDomain2 failed");
1265         torture_assert_werr_equal(tctx, r.out.result, expected_err,
1266                                   "NetrJoinDomain2 failed");
1267 
1268         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1269         {
1270                 return false;
1271         }
1272 
1273         if (join_status != NET_SETUP_DOMAIN_NAME) {
1274                 torture_comment(tctx,
1275                                 "Join verify failed: got %d\n", join_status);
1276                 return false;
1277         }
1278 
1279         return true;
1280 }
1281 
1282 static bool test_NetrUnjoinDomain2(struct torture_context *tctx,
     /* [<][>][^][v][top][bottom][index][help] */
1283                                    struct dcerpc_pipe *p)
1284 {
1285         NTSTATUS status;
1286         struct wkssvc_NetrUnjoinDomain2 r;
1287         const char *domain_admin_account = NULL;
1288         const char *domain_admin_password = NULL;
1289         struct wkssvc_PasswordBuffer pwd_buf;
1290         enum wkssvc_NetJoinStatus join_status;
1291         const char *join_name = NULL;
1292         WERROR expected_err;
1293         DATA_BLOB session_key;
1294 
1295         /* FIXME: this test assumes to join workstations / servers and does not
1296          * handle DCs (WERR_SETUP_DOMAIN_CONTROLLER) */
1297 
1298         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1299         {
1300                 return false;
1301         }
1302 
1303         switch (join_status) {
1304                 case NET_SETUP_UNJOINED:
1305                         expected_err = WERR_SETUP_NOT_JOINED;
1306                         break;
1307                 case NET_SETUP_DOMAIN_NAME:
1308                 case NET_SETUP_UNKNOWN_STATUS:
1309                 case NET_SETUP_WORKGROUP_NAME:
1310                 default:
1311                         expected_err = WERR_OK;
1312                         break;
1313         }
1314 
1315         domain_admin_account = torture_setting_string(tctx, "domain_admin_account", NULL);
1316 
1317         domain_admin_password = torture_setting_string(tctx, "domain_admin_password", NULL);
1318 
1319         if ((domain_admin_account == NULL) ||
1320             (domain_admin_password == NULL)) {
1321                 torture_comment(tctx, "not enough input parameter\n");
1322                 return false;
1323         }
1324 
1325         status = dcerpc_fetch_session_key(p, &session_key);
1326         if (!NT_STATUS_IS_OK(status)) {
1327                 return false;
1328         }
1329 
1330         encode_wkssvc_join_password_buffer(tctx, domain_admin_password,
1331                                            &session_key, &pwd_buf);
1332 
1333         r.in.server_name = dcerpc_server_name(p);
1334         r.in.account = domain_admin_account;
1335         r.in.encrypted_password = &pwd_buf;
1336         r.in.unjoin_flags = 0;
1337 
1338         torture_comment(tctx, "testing NetrUnjoinDomain2 (assuming non-DC)\n");
1339 
1340         status = dcerpc_wkssvc_NetrUnjoinDomain2(p, tctx, &r);
1341         torture_assert_ntstatus_ok(tctx, status,
1342                                    "NetrUnjoinDomain2 failed");
1343         torture_assert_werr_equal(tctx, r.out.result, expected_err,
1344                                   "NetrUnjoinDomain2 failed");
1345 
1346         if (!test_GetJoinInformation(tctx, p, &join_status, &join_name))
1347         {
1348                 return false;
1349         }
1350 
1351         switch (join_status) {
1352                 case NET_SETUP_UNJOINED:
1353                 case NET_SETUP_WORKGROUP_NAME:
1354                         break;
1355                 case NET_SETUP_UNKNOWN_STATUS:
1356                 case NET_SETUP_DOMAIN_NAME:
1357                 default:
1358                         torture_comment(tctx,
1359                                 "Unjoin verify failed: got %d\n", join_status);
1360                         return false;
1361         }
1362 
1363         return true;
1364 }
1365 
1366 
1367 struct torture_suite *torture_rpc_wkssvc(TALLOC_CTX *mem_ctx)
     /* [<][>][^][v][top][bottom][index][help] */
1368 {
1369         struct torture_suite *suite;
1370         struct torture_rpc_tcase *tcase;
1371         struct torture_test *test;
1372 
1373         suite = torture_suite_create(mem_ctx, "WKSSVC");
1374         tcase = torture_suite_add_rpc_iface_tcase(suite, "wkssvc",
1375                                                   &ndr_table_wkssvc);
1376 
1377         torture_rpc_tcase_add_test(tcase, "NetWkstaGetInfo",
1378                                    test_NetWkstaGetInfo);
1379 
1380         torture_rpc_tcase_add_test(tcase, "NetWkstaTransportEnum",
1381                                    test_NetWkstaTransportEnum);
1382         torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportDel",
1383                                    test_NetrWkstaTransportDel);
1384         torture_rpc_tcase_add_test(tcase, "NetrWkstaTransportAdd",
1385                                    test_NetrWkstaTransportAdd);
1386 
1387         torture_rpc_tcase_add_test(tcase, "NetWkstaEnumUsers",
1388                                    test_NetWkstaEnumUsers);
1389         torture_rpc_tcase_add_test(tcase, "NetrWkstaUserGetInfo",
1390                                    test_NetrWkstaUserGetInfo);
1391 
1392         torture_rpc_tcase_add_test(tcase, "NetrUseDel",
1393                                    test_NetrUseDel);
1394         torture_rpc_tcase_add_test(tcase, "NetrUseGetInfo",
1395                                    test_NetrUseGetInfo);
1396         torture_rpc_tcase_add_test(tcase, "NetrUseEnum",
1397                                    test_NetrUseEnum);
1398         torture_rpc_tcase_add_test(tcase, "NetrUseAdd",
1399                                    test_NetrUseAdd);
1400 
1401         torture_rpc_tcase_add_test(tcase, "NetrValidateName",
1402                                    test_NetrValidateName);
1403         torture_rpc_tcase_add_test(tcase, "NetrValidateName2",
1404                                    test_NetrValidateName2);
1405         torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameDel",
1406                                    test_NetrLogonDomainNameDel);
1407         torture_rpc_tcase_add_test(tcase, "NetrLogonDomainNameAdd",
1408                                    test_NetrLogonDomainNameAdd);
1409         torture_rpc_tcase_add_test(tcase, "NetrRemoveAlternateComputerName",
1410                                    test_NetrRemoveAlternateComputerName);
1411         torture_rpc_tcase_add_test(tcase, "NetrAddAlternateComputerName",
1412                                    test_NetrAddAlternateComputerName);
1413         test = torture_rpc_tcase_add_test(tcase, "NetrSetPrimaryComputername",
1414                                           test_NetrSetPrimaryComputername);
1415         test->dangerous = true;
1416         test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain",
1417                                           test_NetrRenameMachineInDomain);
1418         test->dangerous = true;
1419         test = torture_rpc_tcase_add_test(tcase, "NetrRenameMachineInDomain2",
1420                                           test_NetrRenameMachineInDomain2);
1421         test->dangerous = true;
1422         torture_rpc_tcase_add_test(tcase, "NetrEnumerateComputerNames",
1423                                    test_NetrEnumerateComputerNames);
1424 
1425         test = torture_rpc_tcase_add_test(tcase, "NetrJoinDomain2",
1426                                           test_NetrJoinDomain2);
1427         test->dangerous = true;
1428         test = torture_rpc_tcase_add_test(tcase, "NetrUnjoinDomain2",
1429                                           test_NetrUnjoinDomain2);
1430         test->dangerous = true;
1431 
1432         torture_rpc_tcase_add_test(tcase, "NetrJoinDomain",
1433                                    test_NetrJoinDomain);
1434         test->dangerous = true;
1435         torture_rpc_tcase_add_test(tcase, "NetrUnjoinDomain",
1436                                    test_NetrUnjoinDomain);
1437         test->dangerous = true;
1438         torture_rpc_tcase_add_test(tcase, "NetrGetJoinInformation",
1439                                    test_NetrGetJoinInformation);
1440         torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus",
1441                                    test_NetrGetJoinableOus);
1442         torture_rpc_tcase_add_test(tcase, "NetrGetJoinableOus2",
1443                                    test_NetrGetJoinableOus2);
1444 
1445         torture_rpc_tcase_add_test(tcase, "NetrWorkstationStatisticsGet",
1446                                    test_NetrWorkstationStatisticsGet);
1447         torture_rpc_tcase_add_test(tcase, "NetrMessageBufferSend",
1448                                    test_NetrMessageBufferSend);
1449 
1450         return suite;
1451 }

/* [<][>][^][v][top][bottom][index][help] */