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 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "libcli/dgram/libdgram.h"
  25 #include "librpc/gen_ndr/ndr_samr.h"
  26 #include "lib/socket/socket.h"
  27 #include "lib/events/events.h"
  28
  29 #define TEST_NAME "TORTURE_TEST"
  30
  31 /*
  32   reply handler for netlogon request
  33 */
  34 static void netlogon_handler(struct dgram_mailslot_handler *dgmslot,
  35                              struct nbt_dgram_packet *packet,
  36                              const struct nbt_peer_socket *src)
  37 {
  38         NTSTATUS status;
  39         struct nbt_netlogon_packet netlogon;
  40         int *replies = dgmslot->private;
  41
  42         printf("netlogon reply from %s:%d\n", src->addr, src->port);
  43
  44         status = dgram_mailslot_netlogon_parse(dgmslot, dgmslot, packet, &netlogon);
  45         if (!NT_STATUS_IS_OK(status)) {
  46                 printf("Failed to parse netlogon packet from %s:%d\n",
  47                        src->addr, src->port);
  48                 return;
  49         }
  50
  51         NDR_PRINT_DEBUG(nbt_netlogon_packet, &netlogon);
  52
  53         (*replies)++;
  54 }
  55
  56
  57 /* test UDP/138 netlogon requests */
  58 static BOOL nbt_test_netlogon(TALLOC_CTX *mem_ctx,
  59                               struct nbt_name name, const char *address)
  60 {
  61         struct dgram_mailslot_handler *dgmslot;
  62         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
  63         struct nbt_peer_socket dest;
  64         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
  65         struct nbt_netlogon_packet logon;
  66         struct nbt_name myname;
  67         NTSTATUS status;
  68         struct timeval tv = timeval_current();
  69         int replies = 0;
  70
  71         /* try receiving replies on port 138 first, which will only
  72            work if we are root and smbd/nmbd are not running - fall
  73            back to listening on any port, which means replies from
  74            some windows versions won't be seen */
  75         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
  76         if (!NT_STATUS_IS_OK(status)) {
  77                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
  78         }
  79
  80         /* setup a temporary mailslot listener for replies */
  81         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
  82                                       netlogon_handler, &replies);
  83
  84         ZERO_STRUCT(logon);
  85         logon.command = NETLOGON_QUERY_FOR_PDC;
  86         logon.req.pdc.computer_name = TEST_NAME;
  87         logon.req.pdc.mailslot_name = dgmslot->mailslot_name;
  88         logon.req.pdc.unicode_name  = TEST_NAME;
  89         logon.req.pdc.nt_version    = 1;
  90         logon.req.pdc.lmnt_token    = 0xFFFF;
  91         logon.req.pdc.lm20_token    = 0xFFFF;
  92
  93         make_nbt_name_client(&myname, TEST_NAME);
  94
  95         dest.port = 0;
  96         dest.addr = address;
  97         status = dgram_mailslot_netlogon_send(dgmsock, &name, &dest,
  98                                               &myname, &logon);
  99         if (!NT_STATUS_IS_OK(status)) {
 100                 printf("Failed to send netlogon request - %s\n", nt_errstr(status));
 101                 goto failed;
 102         }
 103
 104         while (timeval_elapsed(&tv) < 5 && replies == 0) {
 105                 event_loop_once(dgmsock->event_ctx);
 106         }
 107
 108         talloc_free(dgmsock);
 109         return True;
 110
 111 failed:
 112         talloc_free(dgmsock);
 113         return False;
 114 }
 115
 116
 117 /* test UDP/138 netlogon requests */
 118 static BOOL nbt_test_netlogon2(TALLOC_CTX *mem_ctx,
 119                               struct nbt_name name, const char *address)
 120 {
 121         struct dgram_mailslot_handler *dgmslot;
 122         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
 123         struct nbt_peer_socket dest;
 124         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
 125         struct nbt_netlogon_packet logon;
 126         struct nbt_name myname;
 127         NTSTATUS status;
 128         struct timeval tv = timeval_current();
 129         int replies = 0;
 130
 131         /* try receiving replies on port 138 first, which will only
 132            work if we are root and smbd/nmbd are not running - fall
 133            back to listening on any port, which means replies from
 134            some windows versions won't be seen */
 135         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
 136         if (!NT_STATUS_IS_OK(status)) {
 137                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
 138         }
 139
 140         /* setup a temporary mailslot listener for replies */
 141         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 142                                       netlogon_handler, &replies);
 143
 144
 145         ZERO_STRUCT(logon);
 146         logon.command = NETLOGON_QUERY_FOR_PDC2;
 147         logon.req.pdc2.request_count = 0;
 148         logon.req.pdc2.computer_name = TEST_NAME;
 149         logon.req.pdc2.user_name     = "";
 150         logon.req.pdc2.mailslot_name = dgmslot->mailslot_name;
 151         logon.req.pdc2.nt_version    = 11;
 152         logon.req.pdc2.lmnt_token    = 0xFFFF;
 153         logon.req.pdc2.lm20_token    = 0xFFFF;
 154
 155         make_nbt_name_client(&myname, TEST_NAME);
 156
 157         dest.port = 0;
 158         dest.addr = address;
 159         status = dgram_mailslot_netlogon_send(dgmsock, &name, &dest,
 160                                               &myname, &logon);
 161         if (!NT_STATUS_IS_OK(status)) {
 162                 printf("Failed to send netlogon request - %s\n", nt_errstr(status));
 163                 goto failed;
 164         }
 165
 166
 167         while (timeval_elapsed(&tv) < 5 && replies == 0) {
 168                 event_loop_once(dgmsock->event_ctx);
 169         }
 170
 171         talloc_free(dgmsock);
 172         return True;
 173
 174 failed:
 175         talloc_free(dgmsock);
 176         return False;
 177 }
 178
 179
 180 /*
 181   reply handler for ntlogon request
 182 */
 183 static void ntlogon_handler(struct dgram_mailslot_handler *dgmslot,
 184                              struct nbt_dgram_packet *packet,
 185                              const struct nbt_peer_socket *src)
 186 {
 187         NTSTATUS status;
 188         struct nbt_ntlogon_packet ntlogon;
 189         int *replies = dgmslot->private;
 190
 191         printf("ntlogon reply from %s:%d\n", src->addr, src->port);
 192
 193         status = dgram_mailslot_ntlogon_parse(dgmslot, dgmslot, packet, &ntlogon);
 194         if (!NT_STATUS_IS_OK(status)) {
 195                 printf("Failed to parse ntlogon packet from %s:%d\n",
 196                        src->addr, src->port);
 197                 return;
 198         }
 199
 200         NDR_PRINT_DEBUG(nbt_ntlogon_packet, &ntlogon);
 201
 202         (*replies)++;
 203 }
 204
 205
 206 /* test UDP/138 ntlogon requests */
 207 static BOOL nbt_test_ntlogon(TALLOC_CTX *mem_ctx,
 208                              struct nbt_name name, const char *address)
 209 {
 210         struct dgram_mailslot_handler *dgmslot;
 211         struct nbt_dgram_socket *dgmsock = nbt_dgram_socket_init(mem_ctx, NULL);
 212         struct nbt_peer_socket dest;
 213         const char *myaddress = talloc_strdup(dgmsock, iface_best_ip(address));
 214         struct nbt_ntlogon_packet logon;
 215         struct nbt_name myname;
 216         NTSTATUS status;
 217         struct timeval tv = timeval_current();
 218         int replies = 0;
 219         struct test_join *join_ctx;
 220         struct cli_credentials *machine_credentials;
 221         const char *dom_sid;
 222
 223         join_ctx = torture_join_domain(TEST_NAME,
 224                                        ACB_WSTRUST, &machine_credentials);
 225         if (join_ctx == NULL) {
 226                 printf("Failed to join domain %s as %s\n", lp_workgroup(), TEST_NAME);
 227                 talloc_free(dgmsock);
 228                 return False;
 229         }
 230
 231         dom_sid = torture_join_sid(join_ctx);
 232
 233         /* try receiving replies on port 138 first, which will only
 234            work if we are root and smbd/nmbd are not running - fall
 235            back to listening on any port, which means replies from
 236            some windows versions won't be seen */
 237         status = socket_listen(dgmsock->sock, myaddress, lp_dgram_port(), 0, 0);
 238         if (!NT_STATUS_IS_OK(status)) {
 239                 socket_listen(dgmsock->sock, myaddress, 0, 0, 0);
 240         }
 241
 242         /* setup a temporary mailslot listener for replies */
 243         dgmslot = dgram_mailslot_temp(dgmsock, NBT_MAILSLOT_GETDC,
 244                                       ntlogon_handler, &replies);
 245
 246
 247         ZERO_STRUCT(logon);
 248         logon.command = NTLOGON_SAM_LOGON;
 249         logon.req.logon.request_count = 0;
 250         logon.req.logon.computer_name = TEST_NAME;
 251         logon.req.logon.user_name     = TEST_NAME"$";
 252         logon.req.logon.mailslot_name = dgmslot->mailslot_name;
 253         logon.req.logon.acct_control  = ACB_WSTRUST;
 254         logon.req.logon.sid           = *dom_sid_parse_talloc(dgmslot, dom_sid);
 255         logon.req.logon.nt_version    = 1;
 256         logon.req.logon.lmnt_token    = 0xFFFF;
 257         logon.req.logon.lm20_token    = 0xFFFF;
 258
 259         make_nbt_name_client(&myname, TEST_NAME);
 260
 261         dest.port = 0;
 262         dest.addr = address;
 263         status = dgram_mailslot_ntlogon_send(dgmsock, DGRAM_DIRECT_UNIQUE,
 264                                              &name, &dest, &myname, &logon);
 265         if (!NT_STATUS_IS_OK(status)) {
 266                 printf("Failed to send ntlogon request - %s\n", nt_errstr(status));
 267                 goto failed;
 268         }
 269
 270
 271         while (timeval_elapsed(&tv) < 5 && replies == 0) {
 272                 event_loop_once(dgmsock->event_ctx);
 273         }
 274
 275         torture_leave_domain(join_ctx);
 276         talloc_free(dgmsock);
 277         return True;
 278
 279 failed:
 280         torture_leave_domain(join_ctx);
 281         talloc_free(dgmsock);
 282         return False;
 283 }
 284
 285
 286 /*
 287   test nbt dgram operations
 288 */
 289 BOOL torture_nbt_dgram(void)
 290 {
 291         const char *address;
 292         struct nbt_name name;
 293         TALLOC_CTX *mem_ctx = talloc_new(NULL);
 294         NTSTATUS status;
 295         BOOL ret = True;
 296
 297         name.name = lp_workgroup();
 298         name.type = NBT_NAME_LOGON;
 299         name.scope = NULL;
 300
 301         /* do an initial name resolution to find its IP */
 302         status = resolve_name(&name, mem_ctx, &address, event_context_find(mem_ctx));
 303         if (!NT_STATUS_IS_OK(status)) {
 304                 printf("Failed to resolve %s - %s\n",
 305                        name.name, nt_errstr(status));
 306                 talloc_free(mem_ctx);
 307                 return False;
 308         }
 309
 310         ret &= nbt_test_netlogon(mem_ctx, name, address);
 311         ret &= nbt_test_netlogon2(mem_ctx, name, address);
 312         ret &= nbt_test_ntlogon(mem_ctx, name, address);
 313
 314         talloc_free(mem_ctx);
 315
 316         return ret;
 317 }