source3/rpc_client/cli_netlogon.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    NT Domain Authentication SMB / MSRPC client
   4    Copyright (C) Andrew Tridgell 1992-2000
   5    Copyright (C) Jeremy Allison                    1998.
   6    Largely re-written by Jeremy Allison (C)        2005.
   7    Copyright (C) Guenther Deschner                 2008.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "system/filesys.h"
  25 #include "libsmb/libsmb.h"
  26 #include "rpc_client/rpc_client.h"
  27 #include "rpc_client/cli_pipe.h"
  28 #include "../libcli/auth/libcli_auth.h"
  29 #include "../libcli/auth/netlogon_creds_cli.h"
  30 #include "../librpc/gen_ndr/ndr_netlogon_c.h"
  31 #include "../librpc/gen_ndr/schannel.h"
  32 #include "rpc_client/cli_netlogon.h"
  33 #include "rpc_client/init_netlogon.h"
  34 #include "rpc_client/util_netlogon.h"
  35 #include "../libcli/security/security.h"
  36 #include "lib/param/param.h"
  37 #include "libcli/smb/smbXcli_base.h"
  38 #include "dbwrap/dbwrap.h"
  39 #include "dbwrap/dbwrap_open.h"
  40 #include "util_tdb.h"
  41
  42
  43 NTSTATUS rpccli_pre_open_netlogon_creds(void)
  44 {
  45         static bool already_open = false;
  46         TALLOC_CTX *frame;
  47         struct loadparm_context *lp_ctx;
  48         char *fname;
  49         struct db_context *global_db;
  50         NTSTATUS status;
  51
  52         if (already_open) {
  53                 return NT_STATUS_OK;
  54         }
  55
  56         frame = talloc_stackframe();
  57
  58         lp_ctx = loadparm_init_s3(frame, loadparm_s3_helpers());
  59         if (lp_ctx == NULL) {
  60                 TALLOC_FREE(frame);
  61                 return NT_STATUS_NO_MEMORY;
  62         }
  63
  64         fname = lpcfg_private_db_path(frame, lp_ctx, "netlogon_creds_cli");
  65         if (fname == NULL) {
  66                 TALLOC_FREE(frame);
  67                 return NT_STATUS_NO_MEMORY;
  68         }
  69
  70         global_db = db_open(frame, fname,
  71                             0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
  72                             O_RDWR|O_CREAT, 0600, DBWRAP_LOCK_ORDER_2,
  73                             DBWRAP_FLAG_OPTIMIZE_READONLY_ACCESS);
  74         if (global_db == NULL) {
  75                 TALLOC_FREE(frame);
  76                 return NT_STATUS_NO_MEMORY;
  77         }
  78
  79         status = netlogon_creds_cli_set_global_db(&global_db);
  80         TALLOC_FREE(frame);
  81         if (!NT_STATUS_IS_OK(status)) {
  82                 return status;
  83         }
  84
  85         already_open = true;
  86         return NT_STATUS_OK;
  87 }
  88
  89 static NTSTATUS rpccli_create_netlogon_creds(
  90         const char *server_computer,
  91         const char *server_netbios_domain,
  92         const char *server_dns_domain,
  93         const char *client_account,
  94         enum netr_SchannelType sec_chan_type,
  95         struct messaging_context *msg_ctx,
  96         TALLOC_CTX *mem_ctx,
  97         struct netlogon_creds_cli_context **netlogon_creds)
  98 {
  99         TALLOC_CTX *frame = talloc_stackframe();
 100         struct loadparm_context *lp_ctx;
 101         NTSTATUS status;
 102
 103         status = rpccli_pre_open_netlogon_creds();
 104         if (!NT_STATUS_IS_OK(status)) {
 105                 TALLOC_FREE(frame);
 106                 return status;
 107         }
 108
 109         lp_ctx = loadparm_init_s3(frame, loadparm_s3_helpers());
 110         if (lp_ctx == NULL) {
 111                 TALLOC_FREE(frame);
 112                 return NT_STATUS_NO_MEMORY;
 113         }
 114         status = netlogon_creds_cli_context_global(lp_ctx,
 115                                                    msg_ctx,
 116                                                    client_account,
 117                                                    sec_chan_type,
 118                                                    server_computer,
 119                                                    server_netbios_domain,
 120                                                    server_dns_domain,
 121                                                    mem_ctx, netlogon_creds);
 122         TALLOC_FREE(frame);
 123         if (!NT_STATUS_IS_OK(status)) {
 124                 return status;
 125         }
 126
 127         return NT_STATUS_OK;
 128 }
 129
 130 NTSTATUS rpccli_create_netlogon_creds_ctx(
 131         struct cli_credentials *creds,
 132         const char *server_computer,
 133         struct messaging_context *msg_ctx,
 134         TALLOC_CTX *mem_ctx,
 135         struct netlogon_creds_cli_context **creds_ctx)
 136 {
 137         enum netr_SchannelType sec_chan_type;
 138         const char *server_netbios_domain;
 139         const char *server_dns_domain;
 140         const char *client_account;
 141
 142         sec_chan_type = cli_credentials_get_secure_channel_type(creds);
 143         client_account = cli_credentials_get_username(creds);
 144         server_netbios_domain = cli_credentials_get_domain(creds);
 145         server_dns_domain = cli_credentials_get_realm(creds);
 146
 147         return rpccli_create_netlogon_creds(server_computer,
 148                                             server_netbios_domain,
 149                                             server_dns_domain,
 150                                             client_account,
 151                                             sec_chan_type,
 152                                             msg_ctx, mem_ctx,
 153                                             creds_ctx);
 154 }
 155
 156 NTSTATUS rpccli_setup_netlogon_creds(
 157         struct cli_state *cli,
 158         enum dcerpc_transport_t transport,
 159         struct netlogon_creds_cli_context *creds_ctx,
 160         bool force_reauth,
 161         struct cli_credentials *cli_creds)
 162 {
 163         TALLOC_CTX *frame = talloc_stackframe();
 164         struct rpc_pipe_client *netlogon_pipe = NULL;
 165         struct netlogon_creds_CredentialState *creds = NULL;
 166         uint8_t num_nt_hashes = 0;
 167         const struct samr_Password *nt_hashes[2] = { NULL, NULL };
 168         uint8_t idx_nt_hashes = 0;
 169         NTSTATUS status;
 170
 171         status = netlogon_creds_cli_get(creds_ctx, frame, &creds);
 172         if (NT_STATUS_IS_OK(status)) {
 173                 const char *action = "using";
 174
 175                 if (force_reauth) {
 176                         action = "overwrite";
 177                 }
 178
 179                 DEBUG(5,("%s: %s cached netlogon_creds cli[%s/%s] to %s\n",
 180                          __FUNCTION__, action,
 181                          creds->account_name, creds->computer_name,
 182                          smbXcli_conn_remote_name(cli->conn)));
 183                 if (!force_reauth) {
 184                         TALLOC_FREE(frame);
 185                         return NT_STATUS_OK;
 186                 }
 187                 TALLOC_FREE(creds);
 188         }
 189
 190         nt_hashes[0] = cli_credentials_get_nt_hash(cli_creds, talloc_tos());
 191         if (nt_hashes[0] == NULL) {
 192                 TALLOC_FREE(frame);
 193                 return NT_STATUS_NO_MEMORY;
 194         }
 195         num_nt_hashes = 1;
 196
 197         nt_hashes[1] = cli_credentials_get_old_nt_hash(cli_creds,
 198                                                        talloc_tos());
 199         if (nt_hashes[1] != NULL) {
 200                 num_nt_hashes = 2;
 201         }
 202
 203         status = cli_rpc_pipe_open_noauth_transport(cli,
 204                                                     transport,
 205                                                     &ndr_table_netlogon,
 206                                                     &netlogon_pipe);
 207         if (!NT_STATUS_IS_OK(status)) {
 208                 DEBUG(5,("%s: failed to open noauth netlogon connection to %s - %s\n",
 209                          __FUNCTION__,
 210                          smbXcli_conn_remote_name(cli->conn),
 211                          nt_errstr(status)));
 212                 TALLOC_FREE(frame);
 213                 return status;
 214         }
 215         talloc_steal(frame, netlogon_pipe);
 216
 217         status = netlogon_creds_cli_auth(creds_ctx,
 218                                          netlogon_pipe->binding_handle,
 219                                          num_nt_hashes,
 220                                          nt_hashes,
 221                                          &idx_nt_hashes);
 222         if (!NT_STATUS_IS_OK(status)) {
 223                 TALLOC_FREE(frame);
 224                 return status;
 225         }
 226
 227         status = netlogon_creds_cli_get(creds_ctx, frame, &creds);
 228         if (!NT_STATUS_IS_OK(status)) {
 229                 TALLOC_FREE(frame);
 230                 return NT_STATUS_INTERNAL_ERROR;
 231         }
 232
 233         DEBUG(5,("%s: using new netlogon_creds cli[%s/%s] to %s\n",
 234                  __FUNCTION__,
 235                  creds->account_name, creds->computer_name,
 236                  smbXcli_conn_remote_name(cli->conn)));
 237
 238         TALLOC_FREE(frame);
 239         return NT_STATUS_OK;
 240 }
 241
 242 static NTSTATUS map_validation_to_info3(TALLOC_CTX *mem_ctx,
 243                                         uint16_t validation_level,
 244                                         union netr_Validation *validation,
 245                                         struct netr_SamInfo3 **info3_p)
 246 {
 247         struct netr_SamInfo3 *info3;
 248         NTSTATUS status;
 249
 250         if (validation == NULL) {
 251                 return NT_STATUS_INVALID_PARAMETER;
 252         }
 253
 254         switch (validation_level) {
 255         case 3:
 256                 if (validation->sam3 == NULL) {
 257                         return NT_STATUS_INVALID_PARAMETER;
 258                 }
 259
 260                 info3 = talloc_move(mem_ctx, &validation->sam3);
 261                 break;
 262         case 6:
 263                 if (validation->sam6 == NULL) {
 264                         return NT_STATUS_INVALID_PARAMETER;
 265                 }
 266
 267                 info3 = talloc_zero(mem_ctx, struct netr_SamInfo3);
 268                 if (info3 == NULL) {
 269                         return NT_STATUS_NO_MEMORY;
 270                 }
 271                 status = copy_netr_SamBaseInfo(info3, &validation->sam6->base, &info3->base);
 272                 if (!NT_STATUS_IS_OK(status)) {
 273                         TALLOC_FREE(info3);
 274                         return status;
 275                 }
 276
 277                 info3->sidcount = validation->sam6->sidcount;
 278                 info3->sids = talloc_move(info3, &validation->sam6->sids);
 279                 break;
 280         default:
 281                 return NT_STATUS_BAD_VALIDATION_CLASS;
 282         }
 283
 284         *info3_p = info3;
 285
 286         return NT_STATUS_OK;
 287 }
 288
 289 /* Logon domain user */
 290
 291 NTSTATUS rpccli_netlogon_password_logon(
 292         struct netlogon_creds_cli_context *creds_ctx,
 293         struct dcerpc_binding_handle *binding_handle,
 294         TALLOC_CTX *mem_ctx,
 295         uint32_t logon_parameters,
 296         const char *domain,
 297         const char *username,
 298         const char *password,
 299         const char *workstation,
 300         enum netr_LogonInfoClass logon_type,
 301         uint8_t *authoritative,
 302         uint32_t *flags,
 303         struct netr_SamInfo3 **info3)
 304 {
 305         TALLOC_CTX *frame = talloc_stackframe();
 306         NTSTATUS status;
 307         union netr_LogonLevel *logon;
 308         uint16_t validation_level = 0;
 309         union netr_Validation *validation = NULL;
 310         char *workstation_slash = NULL;
 311
 312         logon = talloc_zero(frame, union netr_LogonLevel);
 313         if (logon == NULL) {
 314                 TALLOC_FREE(frame);
 315                 return NT_STATUS_NO_MEMORY;
 316         }
 317
 318         if (workstation == NULL) {
 319                 workstation = lp_netbios_name();
 320         }
 321
 322         workstation_slash = talloc_asprintf(frame, "\\\\%s", workstation);
 323         if (workstation_slash == NULL) {
 324                 TALLOC_FREE(frame);
 325                 return NT_STATUS_NO_MEMORY;
 326         }
 327
 328         /* Initialise input parameters */
 329
 330         switch (logon_type) {
 331         case NetlogonInteractiveInformation: {
 332
 333                 struct netr_PasswordInfo *password_info;
 334
 335                 struct samr_Password lmpassword;
 336                 struct samr_Password ntpassword;
 337
 338                 password_info = talloc_zero(frame, struct netr_PasswordInfo);
 339                 if (password_info == NULL) {
 340                         TALLOC_FREE(frame);
 341                         return NT_STATUS_NO_MEMORY;
 342                 }
 343
 344                 nt_lm_owf_gen(password, ntpassword.hash, lmpassword.hash);
 345
 346                 password_info->identity_info.domain_name.string         = domain;
 347                 password_info->identity_info.parameter_control          = logon_parameters;
 348                 password_info->identity_info.logon_id_low               = 0xdead;
 349                 password_info->identity_info.logon_id_high              = 0xbeef;
 350                 password_info->identity_info.account_name.string        = username;
 351                 password_info->identity_info.workstation.string         = workstation_slash;
 352
 353                 password_info->lmpassword = lmpassword;
 354                 password_info->ntpassword = ntpassword;
 355
 356                 logon->password = password_info;
 357
 358                 break;
 359         }
 360         case NetlogonNetworkInformation: {
 361                 struct netr_NetworkInfo *network_info;
 362                 uint8_t chal[8];
 363                 unsigned char local_lm_response[24];
 364                 unsigned char local_nt_response[24];
 365                 struct netr_ChallengeResponse lm;
 366                 struct netr_ChallengeResponse nt;
 367
 368                 ZERO_STRUCT(lm);
 369                 ZERO_STRUCT(nt);
 370
 371                 network_info = talloc_zero(frame, struct netr_NetworkInfo);
 372                 if (network_info == NULL) {
 373                         TALLOC_FREE(frame);
 374                         return NT_STATUS_NO_MEMORY;
 375                 }
 376
 377                 generate_random_buffer(chal, 8);
 378
 379                 SMBencrypt(password, chal, local_lm_response);
 380                 SMBNTencrypt(password, chal, local_nt_response);
 381
 382                 lm.length = 24;
 383                 lm.data = local_lm_response;
 384
 385                 nt.length = 24;
 386                 nt.data = local_nt_response;
 387
 388                 network_info->identity_info.domain_name.string          = domain;
 389                 network_info->identity_info.parameter_control           = logon_parameters;
 390                 network_info->identity_info.logon_id_low                = 0xdead;
 391                 network_info->identity_info.logon_id_high               = 0xbeef;
 392                 network_info->identity_info.account_name.string         = username;
 393                 network_info->identity_info.workstation.string          = workstation_slash;
 394
 395                 memcpy(network_info->challenge, chal, 8);
 396                 network_info->nt = nt;
 397                 network_info->lm = lm;
 398
 399                 logon->network = network_info;
 400
 401                 break;
 402         }
 403         default:
 404                 DEBUG(0, ("switch value %d not supported\n",
 405                         logon_type));
 406                 TALLOC_FREE(frame);
 407                 return NT_STATUS_INVALID_INFO_CLASS;
 408         }
 409
 410         status = netlogon_creds_cli_LogonSamLogon(creds_ctx,
 411                                                   binding_handle,
 412                                                   logon_type,
 413                                                   logon,
 414                                                   frame,
 415                                                   &validation_level,
 416                                                   &validation,
 417                                                   authoritative,
 418                                                   flags);
 419         if (!NT_STATUS_IS_OK(status)) {
 420                 TALLOC_FREE(frame);
 421                 return status;
 422         }
 423
 424         status = map_validation_to_info3(mem_ctx,
 425                                          validation_level, validation,
 426                                          info3);
 427         TALLOC_FREE(frame);
 428         if (!NT_STATUS_IS_OK(status)) {
 429                 return status;
 430         }
 431
 432
 433         return NT_STATUS_OK;
 434 }
 435
 436 /**
 437  * Logon domain user with an 'network' SAM logon
 438  *
 439  * @param info3 Pointer to a NET_USER_INFO_3 already allocated by the caller.
 440  **/
 441
 442
 443 NTSTATUS rpccli_netlogon_network_logon(
 444         struct netlogon_creds_cli_context *creds_ctx,
 445         struct dcerpc_binding_handle *binding_handle,
 446         TALLOC_CTX *mem_ctx,
 447         uint32_t logon_parameters,
 448         const char *username,
 449         const char *domain,
 450         const char *workstation,
 451         const uint8_t chal[8],
 452         DATA_BLOB lm_response,
 453         DATA_BLOB nt_response,
 454         uint8_t *authoritative,
 455         uint32_t *flags,
 456         struct netr_SamInfo3 **info3)
 457 {
 458         NTSTATUS status;
 459         const char *workstation_name_slash;
 460         union netr_LogonLevel *logon = NULL;
 461         struct netr_NetworkInfo *network_info;
 462         uint16_t validation_level = 0;
 463         union netr_Validation *validation = NULL;
 464         struct netr_ChallengeResponse lm;
 465         struct netr_ChallengeResponse nt;
 466
 467         *info3 = NULL;
 468
 469         ZERO_STRUCT(lm);
 470         ZERO_STRUCT(nt);
 471
 472         logon = talloc_zero(mem_ctx, union netr_LogonLevel);
 473         if (!logon) {
 474                 return NT_STATUS_NO_MEMORY;
 475         }
 476
 477         network_info = talloc_zero(mem_ctx, struct netr_NetworkInfo);
 478         if (!network_info) {
 479                 return NT_STATUS_NO_MEMORY;
 480         }
 481
 482         if (workstation[0] != '\\' && workstation[1] != '\\') {
 483                 workstation_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", workstation);
 484         } else {
 485                 workstation_name_slash = workstation;
 486         }
 487
 488         if (!workstation_name_slash) {
 489                 DEBUG(0, ("talloc_asprintf failed!\n"));
 490                 return NT_STATUS_NO_MEMORY;
 491         }
 492
 493         /* Initialise input parameters */
 494
 495         lm.data = lm_response.data;
 496         lm.length = lm_response.length;
 497         nt.data = nt_response.data;
 498         nt.length = nt_response.length;
 499
 500         network_info->identity_info.domain_name.string          = domain;
 501         network_info->identity_info.parameter_control           = logon_parameters;
 502         network_info->identity_info.logon_id_low                = 0xdead;
 503         network_info->identity_info.logon_id_high               = 0xbeef;
 504         network_info->identity_info.account_name.string         = username;
 505         network_info->identity_info.workstation.string          = workstation_name_slash;
 506
 507         memcpy(network_info->challenge, chal, 8);
 508         network_info->nt = nt;
 509         network_info->lm = lm;
 510
 511         logon->network = network_info;
 512
 513         /* Marshall data and send request */
 514
 515         status = netlogon_creds_cli_LogonSamLogon(creds_ctx,
 516                                                   binding_handle,
 517                                                   NetlogonNetworkInformation,
 518                                                   logon,
 519                                                   mem_ctx,
 520                                                   &validation_level,
 521                                                   &validation,
 522                                                   authoritative,
 523                                                   flags);
 524         if (!NT_STATUS_IS_OK(status)) {
 525                 return status;
 526         }
 527
 528         status = map_validation_to_info3(mem_ctx,
 529                                          validation_level, validation,
 530                                          info3);
 531         if (!NT_STATUS_IS_OK(status)) {
 532                 return status;
 533         }
 534
 535         return NT_STATUS_OK;
 536 }