source4/torture/nbt/dgram.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    NBT dgram testing
   5
   6    Copyright (C) Andrew Tridgell 2005
   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 "libcli/dgram/libdgram.h"
  24 #include "lib/socket/socket.h"
  25 #include "lib/events/events.h"
  26 #include "torture/rpc/torture_rpc.h"
  27 #include "libcli/resolve/resolve.h"
  28 #include "system/network.h"
  29 #include "lib/socket/netif.h"
  30 #include "param/param.h"
  31
  32 #define TEST_NAME "TORTURE_TEST"
  33
  34 /*
  35   reply handler for netlogon request
  36 */
  37 static void netlogon_handler(struct dgram_mailslot_handler *dgmslot,
  38                              struct nbt_dgram_packet *packet,
  39                              struct socket_address *src)
  40 {
  41         NTSTATUS status;
  42         struct nbt_netlogon_response *netlogon = dgmslot->private_data;
  43
  44         dgmslot->private_data = netlogon = talloc(dgmslot, struct nbt_netlogon_response);
  45
  46         if (!dgmslot->private_data) {
  47                 return;
  48         }
  49
  50         printf("netlogon reply from %s:%d\n", src->addr, src->port);
  51
  52         /* Fills in the netlogon pointer */
  53         status = dgram_mailslot_netlogon_parse_response(dgmslot, netlogon, packet, netlogon);
  54         if (!NT_STATUS_IS_OK(status)) {
  55                 printf("Failed to parse netlogon packet from %s:%d\n",
  56                        src->addr, src->port);
  57                 return;
  58         }
  59
  60 }
  61
  62
  63 /* test UDP/138 netlogon requests */
  64 static bool nbt_test_netlogon(struct torture_context *tctx)
  65 {
  66         struct dgram_mailslot_handler *dgmslot;
  67         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
  68         struct socket_address *dest;
  69         const char *myaddress;
  70         struct nbt_netlogon_packet logon;
  71         struct nbt_netlogon_response *response;
  72         struct nbt_name myname;
  73         NTSTATUS status;
  74         struct timeval tv = timeval_current();
  75
  76         struct socket_address *socket_address;
  77
  78         const char *address;
  79         struct nbt_name name;
  80
  81         struct interface *ifaces;
  82
  83         name.name = lp_workgroup(tctx->lp_ctx);
  84         name.type = NBT_NAME_LOGON;
  85         name.scope = NULL;
  86
  87         /* do an initial name resolution to find its IP */
  88         torture_assert_ntstatus_ok(tctx,
  89                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
  90                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
  91
  92         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
  93         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
  94
  95
  96         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
  97                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
  98         torture_assert(tctx, socket_address != NULL, "Error getting address");
  99
 100         /* try receiving replies on port 138 first, which will only
 101            work if we are root and smbd/nmbd are not running - fall
 102            back to listening on any port, which means replies from
 103            most windows versions won't be seen */
 104         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 105         if (!NT_STATUS_IS_OK(status)) {
 106                 talloc_free(socket_address);
 107                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 108                                                              myaddress, 0);
 109                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 110
 111                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 112         }
 113
 114         /* setup a temporary mailslot listener for replies */
 115         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 116                                       netlogon_handler, NULL);
 117
 118         ZERO_STRUCT(logon);
 119         logon.command = LOGON_PRIMARY_QUERY;
 120         logon.req.pdc.computer_name = TEST_NAME;
 121         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 122         logon.req.pdc.unicode_name  = TEST_NAME;
 123         logon.req.pdc.nt_version    = 1;
 124         logon.req.pdc.lmnt_token    = 0xFFFF;
 125         logon.req.pdc.lm20_token    = 0xFFFF;
 126
 127         make_nbt_name_client(&myname, TEST_NAME);
 128
 129         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 130                                            address, lp_dgram_port(tctx->lp_ctx));
 131         torture_assert(tctx, dest != NULL, "Error getting address");
 132
 133         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 134                                               NBT_MAILSLOT_NETLOGON,
 135                                               &myname, &logon);
 136         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 137
 138         while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
 139                 event_loop_once(dgmsock->event_ctx);
 140         }
 141
 142         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 143
 144         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 145
 146         torture_assert(tctx, response->response_type == NETLOGON_GET_PDC, "Got incorrect type of netlogon response");
 147         torture_assert(tctx, response->data.get_pdc.command == NETLOGON_RESPONSE_FROM_PDC, "Got incorrect netlogon response command");
 148
 149         return true;
 150 }
 151
 152
 153 /* test UDP/138 netlogon requests */
 154 static bool nbt_test_netlogon2(struct torture_context *tctx)
 155 {
 156         struct dgram_mailslot_handler *dgmslot;
 157         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
 158         struct socket_address *dest;
 159         const char *myaddress;
 160         struct nbt_netlogon_packet logon;
 161         struct nbt_netlogon_response *response;
 162         struct nbt_name myname;
 163         NTSTATUS status;
 164         struct timeval tv = timeval_current();
 165
 166         struct socket_address *socket_address;
 167
 168         const char *address;
 169         struct nbt_name name;
 170
 171         struct interface *ifaces;
 172         struct test_join *join_ctx;
 173         struct cli_credentials *machine_credentials;
 174         const struct dom_sid *dom_sid;
 175
 176         name.name = lp_workgroup(tctx->lp_ctx);
 177         name.type = NBT_NAME_LOGON;
 178         name.scope = NULL;
 179
 180         /* do an initial name resolution to find its IP */
 181         torture_assert_ntstatus_ok(tctx,
 182                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
 183                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
 184
 185         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
 186         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
 187
 188         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 189                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
 190         torture_assert(tctx, socket_address != NULL, "Error getting address");
 191
 192         /* try receiving replies on port 138 first, which will only
 193            work if we are root and smbd/nmbd are not running - fall
 194            back to listening on any port, which means replies from
 195            some windows versions won't be seen */
 196         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 197         if (!NT_STATUS_IS_OK(status)) {
 198                 talloc_free(socket_address);
 199                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 200                                                              myaddress, 0);
 201                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 202
 203                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 204         }
 205
 206         /* setup a temporary mailslot listener for replies */
 207         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 208                                       netlogon_handler, NULL);
 209
 210
 211         ZERO_STRUCT(logon);
 212         logon.command = LOGON_SAM_LOGON_REQUEST;
 213         logon.req.logon.request_count = 0;
 214         logon.req.logon.computer_name = TEST_NAME;
 215         logon.req.logon.user_name     = "";
 216         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 217         logon.req.logon.nt_version    = NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5|NETLOGON_NT_VERSION_1;
 218         logon.req.logon.lmnt_token    = 0xFFFF;
 219         logon.req.logon.lm20_token    = 0xFFFF;
 220
 221         make_nbt_name_client(&myname, TEST_NAME);
 222
 223         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 224                                            address, lp_dgram_port(tctx->lp_ctx));
 225
 226         torture_assert(tctx, dest != NULL, "Error getting address");
 227         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 228                                               NBT_MAILSLOT_NETLOGON,
 229                                               &myname, &logon);
 230         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 231
 232         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 233                 event_loop_once(dgmsock->event_ctx);
 234         }
 235
 236         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 237
 238         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 239
 240         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 241         map_netlogon_samlogon_response(&response->data.samlogon);
 242
 243         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE_EX, "Got incorrect netlogon response command");
 244         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.nt_version, NETLOGON_NT_VERSION_5EX_WITH_IP|NETLOGON_NT_VERSION_5EX|NETLOGON_NT_VERSION_1, "Got incorrect netlogon response command");
 245
 246         /* setup (another) temporary mailslot listener for replies */
 247         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 248                                       netlogon_handler, NULL);
 249
 250         ZERO_STRUCT(logon);
 251         logon.command = LOGON_SAM_LOGON_REQUEST;
 252         logon.req.logon.request_count = 0;
 253         logon.req.logon.computer_name = TEST_NAME;
 254         logon.req.logon.user_name     = TEST_NAME"$";
 255         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 256         logon.req.logon.nt_version    = 1;
 257         logon.req.logon.lmnt_token    = 0xFFFF;
 258         logon.req.logon.lm20_token    = 0xFFFF;
 259
 260         make_nbt_name_client(&myname, TEST_NAME);
 261
 262         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 263                                            address, lp_dgram_port(tctx->lp_ctx));
 264
 265         torture_assert(tctx, dest != NULL, "Error getting address");
 266         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 267                                               NBT_MAILSLOT_NETLOGON,
 268                                               &myname, &logon);
 269         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 270
 271         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 272                 event_loop_once(dgmsock->event_ctx);
 273         }
 274
 275         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 276
 277         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 278
 279         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 280         map_netlogon_samlogon_response(&response->data.samlogon);
 281
 282         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 283
 284         torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 285
 286         join_ctx = torture_join_domain(tctx, TEST_NAME,
 287                                        ACB_WSTRUST, &machine_credentials);
 288
 289         torture_assert(tctx, join_ctx != NULL,
 290                        talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
 291                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
 292
 293         dom_sid = torture_join_sid(join_ctx);
 294
 295         /* setup (another) temporary mailslot listener for replies */
 296         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 297                                       netlogon_handler, NULL);
 298
 299         ZERO_STRUCT(logon);
 300         logon.command = LOGON_SAM_LOGON_REQUEST;
 301         logon.req.logon.request_count = 0;
 302         logon.req.logon.computer_name = TEST_NAME;
 303         logon.req.logon.user_name     = TEST_NAME"$";
 304         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 305         logon.req.logon.sid           = *dom_sid;
 306         logon.req.logon.nt_version    = 1;
 307         logon.req.logon.lmnt_token    = 0xFFFF;
 308         logon.req.logon.lm20_token    = 0xFFFF;
 309
 310         make_nbt_name_client(&myname, TEST_NAME);
 311
 312         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 313                                            address, lp_dgram_port(tctx->lp_ctx));
 314
 315         torture_assert(tctx, dest != NULL, "Error getting address");
 316         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 317                                               NBT_MAILSLOT_NETLOGON,
 318                                               &myname, &logon);
 319         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 320
 321
 322         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 323                 event_loop_once(dgmsock->event_ctx);
 324         }
 325
 326         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 327
 328         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 329
 330         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 331         map_netlogon_samlogon_response(&response->data.samlogon);
 332
 333         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 334
 335         /* setup (another) temporary mailslot listener for replies */
 336         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 337                                       netlogon_handler, NULL);
 338
 339         torture_assert(tctx, dgmslot != NULL, "Error getting a Mailslot for GetDC reply");
 340
 341         ZERO_STRUCT(logon);
 342         logon.command = LOGON_SAM_LOGON_REQUEST;
 343         logon.req.logon.request_count = 0;
 344         logon.req.logon.computer_name = TEST_NAME;
 345         logon.req.logon.user_name     = TEST_NAME"$";
 346         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 347         logon.req.logon.sid           = *dom_sid;
 348         logon.req.logon.acct_control  = ACB_WSTRUST;
 349         logon.req.logon.nt_version    = 1;
 350         logon.req.logon.lmnt_token    = 0xFFFF;
 351         logon.req.logon.lm20_token    = 0xFFFF;
 352
 353         make_nbt_name_client(&myname, TEST_NAME);
 354
 355         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 356                                            address, lp_dgram_port(tctx->lp_ctx));
 357
 358         torture_assert(tctx, dest != NULL, "Error getting address");
 359         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 360                                               NBT_MAILSLOT_NETLOGON,
 361                                               &myname, &logon);
 362         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 363
 364
 365         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 366                 event_loop_once(dgmsock->event_ctx);
 367         }
 368
 369         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 370
 371         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 372
 373         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 374         map_netlogon_samlogon_response(&response->data.samlogon);
 375
 376         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 377
 378         dgmslot->private_data = NULL;
 379
 380         ZERO_STRUCT(logon);
 381         logon.command = LOGON_SAM_LOGON_REQUEST;
 382         logon.req.logon.request_count = 0;
 383         logon.req.logon.computer_name = TEST_NAME;
 384         logon.req.logon.user_name     = TEST_NAME"$";
 385         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 386         logon.req.logon.sid           = *dom_sid;
 387         logon.req.logon.acct_control  = ACB_NORMAL;
 388         logon.req.logon.nt_version    = 1;
 389         logon.req.logon.lmnt_token    = 0xFFFF;
 390         logon.req.logon.lm20_token    = 0xFFFF;
 391
 392         make_nbt_name_client(&myname, TEST_NAME);
 393
 394         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 395                                            address, lp_dgram_port(tctx->lp_ctx));
 396
 397         torture_assert(tctx, dest != NULL, "Error getting address");
 398         status = dgram_mailslot_netlogon_send(dgmsock, &name, dest,
 399                                               NBT_MAILSLOT_NETLOGON,
 400                                               &myname, &logon);
 401         torture_assert_ntstatus_ok(tctx, status, "Failed to send netlogon request");
 402
 403
 404         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 405                 event_loop_once(dgmsock->event_ctx);
 406         }
 407
 408         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 409
 410         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 411
 412         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 413         map_netlogon_samlogon_response(&response->data.samlogon);
 414
 415         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_USER_UNKNOWN, "Got incorrect netlogon response command");
 416
 417         torture_leave_domain(tctx, join_ctx);
 418         return true;
 419 }
 420
 421
 422 /* test UDP/138 ntlogon requests */
 423 static bool nbt_test_ntlogon(struct torture_context *tctx)
 424 {
 425         struct dgram_mailslot_handler *dgmslot;
 426         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(tctx, tctx->ev);
 427         struct socket_address *dest;
 428         struct test_join *join_ctx;
 429         const struct dom_sid *dom_sid;
 430         struct cli_credentials *machine_credentials;
 431
 432         const char *myaddress;
 433         struct nbt_netlogon_packet logon;
 434         struct nbt_netlogon_response *response;
 435         struct nbt_name myname;
 436         NTSTATUS status;
 437         struct timeval tv = timeval_current();
 438
 439         struct socket_address *socket_address;
 440         const char *address;
 441         struct nbt_name name;
 442
 443         struct interface *ifaces;
 444
 445         name.name = lp_workgroup(tctx->lp_ctx);
 446         name.type = NBT_NAME_LOGON;
 447         name.scope = NULL;
 448
 449         /* do an initial name resolution to find its IP */
 450         torture_assert_ntstatus_ok(tctx,
 451                                    resolve_name(lp_resolve_context(tctx->lp_ctx), &name, tctx, &address, tctx->ev),
 452                                    talloc_asprintf(tctx, "Failed to resolve %s", name.name));
 453
 454         load_interfaces(tctx, lp_interfaces(tctx->lp_ctx), &ifaces);
 455         myaddress = talloc_strdup(dgmsock, iface_best_ip(ifaces, address));
 456
 457         socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 458                                                      myaddress, lp_dgram_port(tctx->lp_ctx));
 459         torture_assert(tctx, socket_address != NULL, "Error getting address");
 460
 461         /* try receiving replies on port 138 first, which will only
 462            work if we are root and smbd/nmbd are not running - fall
 463            back to listening on any port, which means replies from
 464            most windows versions won't be seen */
 465         status = socket_listen(dgmsock->sock, socket_address, 0, 0);
 466         if (!NT_STATUS_IS_OK(status)) {
 467                 talloc_free(socket_address);
 468                 socket_address = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 469                                                              myaddress, 0);
 470                 torture_assert(tctx, socket_address != NULL, "Error getting address");
 471
 472                 socket_listen(dgmsock->sock, socket_address, 0, 0);
 473         }
 474
 475         join_ctx = torture_join_domain(tctx, TEST_NAME,
 476                                        ACB_WSTRUST, &machine_credentials);
 477         dom_sid = torture_join_sid(join_ctx);
 478
 479         torture_assert(tctx, join_ctx != NULL,
 480                        talloc_asprintf(tctx, "Failed to join domain %s as %s\n",
 481                                        lp_workgroup(tctx->lp_ctx), TEST_NAME));
 482
 483         /* setup a temporary mailslot listener for replies */
 484         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 485                                       netlogon_handler, NULL);
 486
 487
 488         ZERO_STRUCT(logon);
 489         logon.command = LOGON_SAM_LOGON_REQUEST;
 490         logon.req.logon.request_count = 0;
 491         logon.req.logon.computer_name = TEST_NAME;
 492         logon.req.logon.user_name     = TEST_NAME"$";
 493         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 494         logon.req.logon.acct_control  = ACB_WSTRUST;
 495         /* Try with a SID this time */
 496         logon.req.logon.sid           = *dom_sid;
 497         logon.req.logon.nt_version    = 1;
 498         logon.req.logon.lmnt_token    = 0xFFFF;
 499         logon.req.logon.lm20_token    = 0xFFFF;
 500
 501         make_nbt_name_client(&myname, TEST_NAME);
 502
 503         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 504                                            address, lp_dgram_port(tctx->lp_ctx));
 505         torture_assert(tctx, dest != NULL, "Error getting address");
 506         status = dgram_mailslot_netlogon_send(dgmsock,
 507                                               &name, dest,
 508                                               NBT_MAILSLOT_NTLOGON,
 509                                               &myname, &logon);
 510         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 511
 512         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 513                 event_loop_once(dgmsock->event_ctx);
 514         }
 515
 516         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 517
 518         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 519
 520         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 521         map_netlogon_samlogon_response(&response->data.samlogon);
 522
 523         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 524
 525         torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 526
 527
 528         /* setup a temporary mailslot listener for replies */
 529         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 530                                       netlogon_handler, NULL);
 531
 532
 533         ZERO_STRUCT(logon);
 534         logon.command = LOGON_SAM_LOGON_REQUEST;
 535         logon.req.logon.request_count = 0;
 536         logon.req.logon.computer_name = TEST_NAME;
 537         logon.req.logon.user_name     = TEST_NAME"$";
 538         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 539         logon.req.logon.acct_control  = ACB_WSTRUST;
 540         /* Leave sid as all zero */
 541         logon.req.logon.nt_version    = 1;
 542         logon.req.logon.lmnt_token    = 0xFFFF;
 543         logon.req.logon.lm20_token    = 0xFFFF;
 544
 545         make_nbt_name_client(&myname, TEST_NAME);
 546
 547         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 548                                            address, lp_dgram_port(tctx->lp_ctx));
 549         torture_assert(tctx, dest != NULL, "Error getting address");
 550         status = dgram_mailslot_netlogon_send(dgmsock,
 551                                               &name, dest,
 552                                               NBT_MAILSLOT_NTLOGON,
 553                                               &myname, &logon);
 554         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 555
 556         while (timeval_elapsed(&tv) < 5 && dgmslot->private_data == NULL) {
 557                 event_loop_once(dgmsock->event_ctx);
 558         }
 559
 560         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 561
 562         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 563
 564         torture_assert_int_equal(tctx, response->response_type, NETLOGON_SAMLOGON, "Got incorrect type of netlogon response");
 565         map_netlogon_samlogon_response(&response->data.samlogon);
 566
 567         torture_assert_int_equal(tctx, response->data.samlogon.data.nt5_ex.command, LOGON_SAM_LOGON_RESPONSE, "Got incorrect netlogon response command");
 568
 569         torture_assert_str_equal(tctx, response->data.samlogon.data.nt5_ex.user_name, TEST_NAME"$", "Got incorrect user in netlogon response");
 570
 571
 572         /* setup (another) temporary mailslot listener for replies */
 573         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 574                                       netlogon_handler, NULL);
 575
 576         ZERO_STRUCT(logon);
 577         logon.command = LOGON_PRIMARY_QUERY;
 578         logon.req.pdc.computer_name = TEST_NAME;
 579         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 580         logon.req.pdc.unicode_name  = TEST_NAME;
 581         logon.req.pdc.nt_version    = 1;
 582         logon.req.pdc.lmnt_token    = 0xFFFF;
 583         logon.req.pdc.lm20_token    = 0xFFFF;
 584
 585         make_nbt_name_client(&myname, TEST_NAME);
 586
 587         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 588                                            address, lp_dgram_port(tctx->lp_ctx));
 589         torture_assert(tctx, dest != NULL, "Error getting address");
 590         status = dgram_mailslot_netlogon_send(dgmsock,
 591                                               &name, dest,
 592                                               NBT_MAILSLOT_NTLOGON,
 593                                               &myname, &logon);
 594         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 595
 596         while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
 597                 event_loop_once(dgmsock->event_ctx);
 598         }
 599
 600         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 601
 602         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 603
 604         torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
 605         torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
 606
 607         torture_leave_domain(tctx, join_ctx);
 608
 609         /* setup (another) temporary mailslot listener for replies */
 610         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 611                                       netlogon_handler, NULL);
 612
 613         ZERO_STRUCT(logon);
 614         logon.command = LOGON_PRIMARY_QUERY;
 615         logon.req.pdc.computer_name = TEST_NAME;
 616         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
 617         logon.req.pdc.unicode_name  = TEST_NAME;
 618         logon.req.pdc.nt_version    = 1;
 619         logon.req.pdc.lmnt_token    = 0xFFFF;
 620         logon.req.pdc.lm20_token    = 0xFFFF;
 621
 622         make_nbt_name_client(&myname, TEST_NAME);
 623
 624         dest = socket_address_from_strings(dgmsock, dgmsock->sock->backend_name,
 625                                            address, lp_dgram_port(tctx->lp_ctx));
 626         torture_assert(tctx, dest != NULL, "Error getting address");
 627         status = dgram_mailslot_netlogon_send(dgmsock,
 628                                               &name, dest,
 629                                               NBT_MAILSLOT_NTLOGON,
 630                                               &myname, &logon);
 631         torture_assert_ntstatus_ok(tctx, status, "Failed to send ntlogon request");
 632
 633         while (timeval_elapsed(&tv) < 5 && !dgmslot->private_data) {
 634                 event_loop_once(dgmsock->event_ctx);
 635         }
 636
 637         response = talloc_get_type(dgmslot->private_data, struct nbt_netlogon_response);
 638
 639         torture_assert(tctx, response != NULL, "Failed to receive a netlogon reply packet");
 640
 641         torture_assert_int_equal(tctx, response->response_type, NETLOGON_GET_PDC, "Got incorrect type of ntlogon response");
 642         torture_assert_int_equal(tctx, response->data.get_pdc.command, NETLOGON_RESPONSE_FROM_PDC, "Got incorrect ntlogon response command");
 643
 644
 645         return true;
 646 }
 647
 648
 649 /*
 650   test nbt dgram operations
 651 */
 652 struct torture_suite *torture_nbt_dgram(TALLOC_CTX *mem_ctx)
 653 {
 654         struct torture_suite *suite = torture_suite_create(mem_ctx, "DGRAM");
 655
 656         torture_suite_add_simple_test(suite, "netlogon", nbt_test_netlogon);
 657         torture_suite_add_simple_test(suite, "netlogon2", nbt_test_netlogon2);
 658         torture_suite_add_simple_test(suite, "ntlogon", nbt_test_ntlogon);
 659
 660         return suite;
 661 }