?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
man pages: Fix synonyms.
[Samba.git] / source / rpc_client / cli_netlogon.c
blobfb8c5cf037d95d22f98c06832a4b65dbc9ec5f85
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
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
25 /* LSA Request Challenge. Sends our challenge to server, then gets
26 server response. These are used to generate the credentials.
27 The sent and received challenges are stored in the netlog pipe
28 private data. Only call this via rpccli_netlogon_setup_creds(). JRA.
29 */
30
31 static NTSTATUS rpccli_net_req_chal(struct rpc_pipe_client *cli,
32 TALLOC_CTX *mem_ctx,
33 const char *server_name,
34 const char *clnt_name,
35 const DOM_CHAL *clnt_chal_in,
36 DOM_CHAL *srv_chal_out)
37 {
38 prs_struct qbuf, rbuf;
39 NET_Q_REQ_CHAL q;
40 NET_R_REQ_CHAL r;
41 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
42
43 /* create and send a MSRPC command with api NET_REQCHAL */
44
45 DEBUG(4,("cli_net_req_chal: LSA Request Challenge from %s to %s\n",
46 clnt_name, server_name));
47
48 /* store the parameters */
49 init_q_req_chal(&q, server_name, clnt_name, clnt_chal_in);
50
51 /* Marshall data and send request */
52 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_REQCHAL,
53 q, r,
54 qbuf, rbuf,
55 net_io_q_req_chal,
56 net_io_r_req_chal,
57 NT_STATUS_UNSUCCESSFUL);
58
59 result = r.status;
60
61 /* Return result */
62
63 if (NT_STATUS_IS_OK(result)) {
64 /* Store the returned server challenge. */
65 *srv_chal_out = r.srv_chal;
66 }
67
68 return result;
69 }
70
71 #if 0
72 /****************************************************************************
73 LSA Authenticate 2
74
75 Send the client credential, receive back a server credential.
76 Ensure that the server credential returned matches the session key
77 encrypt of the server challenge originally received. JRA.
78 ****************************************************************************/
79
80 NTSTATUS rpccli_net_auth2(struct rpc_pipe_client *cli,
81 uint16 sec_chan,
82 uint32 *neg_flags, DOM_CHAL *srv_chal)
83 {
84 prs_struct qbuf, rbuf;
85 NET_Q_AUTH_2 q;
86 NET_R_AUTH_2 r;
87 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
88 fstring machine_acct;
89
90 if ( sec_chan == SEC_CHAN_DOMAIN )
91 fstr_sprintf( machine_acct, "%s$", lp_workgroup() );
92 else
93 fstrcpy( machine_acct, cli->mach_acct );
94
95 /* create and send a MSRPC command with api NET_AUTH2 */
96
97 DEBUG(4,("cli_net_auth2: srv:%s acct:%s sc:%x mc: %s chal %s neg: %x\n",
98 cli->srv_name_slash, machine_acct, sec_chan, global_myname(),
99 credstr(cli->clnt_cred.challenge.data), *neg_flags));
100
101 /* store the parameters */
102
103 init_q_auth_2(&q, cli->srv_name_slash, machine_acct,
104 sec_chan, global_myname(), &cli->clnt_cred.challenge,
105 *neg_flags);
106
107 /* turn parameters into data stream */
108
109 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_AUTH2,
110 q, r,
111 qbuf, rbuf,
112 net_io_q_auth_2,
113 net_io_r_auth_2,
114 NT_STATUS_UNSUCCESSFUL);
115
116 result = r.status;
117
118 if (NT_STATUS_IS_OK(result)) {
119 UTIME zerotime;
120
121 /*
122 * Check the returned value using the initial
123 * server received challenge.
124 */
125
126 zerotime.time = 0;
127 if (cred_assert( &r.srv_chal, cli->sess_key, srv_chal, zerotime) == 0) {
128
129 /*
130 * Server replied with bad credential. Fail.
131 */
132 DEBUG(0,("cli_net_auth2: server %s replied with bad credential (bad machine \
133 password ?).\n", cli->cli->desthost ));
134 return NT_STATUS_ACCESS_DENIED;
135 }
136 *neg_flags = r.srv_flgs.neg_flags;
137 }
138
139 return result;
140 }
141 #endif
142
143 /****************************************************************************
144 LSA Authenticate 2
145
146 Send the client credential, receive back a server credential.
147 The caller *must* ensure that the server credential returned matches the session key
148 encrypt of the server challenge originally received. JRA.
149 ****************************************************************************/
150
151 static NTSTATUS rpccli_net_auth2(struct rpc_pipe_client *cli,
152 TALLOC_CTX *mem_ctx,
153 const char *server_name,
154 const char *account_name,
155 uint16 sec_chan_type,
156 const char *computer_name,
157 uint32 *neg_flags_inout,
158 const DOM_CHAL *clnt_chal_in,
159 DOM_CHAL *srv_chal_out)
160 {
161 prs_struct qbuf, rbuf;
162 NET_Q_AUTH_2 q;
163 NET_R_AUTH_2 r;
164 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
165
166 /* create and send a MSRPC command with api NET_AUTH2 */
167
168 DEBUG(4,("cli_net_auth2: srv:%s acct:%s sc:%x mc: %s neg: %x\n",
169 server_name, account_name, sec_chan_type, computer_name,
170 *neg_flags_inout));
171
172 /* store the parameters */
173
174 init_q_auth_2(&q, server_name, account_name, sec_chan_type,
175 computer_name, clnt_chal_in, *neg_flags_inout);
176
177 /* turn parameters into data stream */
178
179 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_AUTH2,
180 q, r,
181 qbuf, rbuf,
182 net_io_q_auth_2,
183 net_io_r_auth_2,
184 NT_STATUS_UNSUCCESSFUL);
185
186 result = r.status;
187
188 *neg_flags_inout = r.srv_flgs.neg_flags;
189
190 if (NT_STATUS_IS_OK(result)) {
191 *srv_chal_out = r.srv_chal;
192 }
193
194 return result;
195 }
196
197 #if 0 /* not currebntly used */
198 /****************************************************************************
199 LSA Authenticate 3
200
201 Send the client credential, receive back a server credential.
202 The caller *must* ensure that the server credential returned matches the session key
203 encrypt of the server challenge originally received. JRA.
204 ****************************************************************************/
205
206 static NTSTATUS rpccli_net_auth3(struct rpc_pipe_client *cli,
207 TALLOC_CTX *mem_ctx,
208 const char *server_name,
209 const char *account_name,
210 uint16 sec_chan_type,
211 const char *computer_name,
212 uint32 *neg_flags_inout,
213 const DOM_CHAL *clnt_chal_in,
214 DOM_CHAL *srv_chal_out)
215 {
216 prs_struct qbuf, rbuf;
217 NET_Q_AUTH_3 q;
218 NET_R_AUTH_3 r;
219 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
220
221 /* create and send a MSRPC command with api NET_AUTH2 */
222
223 DEBUG(4,("cli_net_auth3: srv:%s acct:%s sc:%x mc: %s chal %s neg: %x\n",
224 server_name, account_name, sec_chan_type, computer_name,
225 credstr(clnt_chal_in->data), *neg_flags_inout));
226
227 /* store the parameters */
228 init_q_auth_3(&q, server_name, account_name, sec_chan_type,
229 computer_name, clnt_chal_in, *neg_flags_inout);
230
231 /* turn parameters into data stream */
232
233 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_AUTH3,
234 q, r,
235 qbuf, rbuf,
236 net_io_q_auth_3,
237 net_io_r_auth_3,
238 NT_STATUS_UNSUCCESSFUL);
239
240 if (NT_STATUS_IS_OK(result)) {
241 *srv_chal_out = r.srv_chal;
242 *neg_flags_inout = r.srv_flgs.neg_flags;
243 }
244
245 return result;
246 }
247 #endif /* not currebntly used */
248
249 /****************************************************************************
250 Wrapper function that uses the auth and auth2 calls to set up a NETLOGON
251 credentials chain. Stores the credentials in the struct dcinfo in the
252 netlogon pipe struct.
253 ****************************************************************************/
254
255 NTSTATUS rpccli_netlogon_setup_creds(struct rpc_pipe_client *cli,
256 const char *server_name,
257 const char *domain,
258 const char *clnt_name,
259 const char *machine_account,
260 const unsigned char machine_pwd[16],
261 uint32 sec_chan_type,
262 uint32 *neg_flags_inout)
263 {
264 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
265 DOM_CHAL clnt_chal_send;
266 DOM_CHAL srv_chal_recv;
267 struct dcinfo *dc;
268 bool retried = false;
269
270 SMB_ASSERT(cli->pipe_idx == PI_NETLOGON);
271
272 dc = cli->dc;
273 if (!dc) {
274 return NT_STATUS_INVALID_PARAMETER;
275 }
276
277 /* Ensure we don't reuse any of this state. */
278 ZERO_STRUCTP(dc);
279
280 /* Store the machine account password we're going to use. */
281 memcpy(dc->mach_pw, machine_pwd, 16);
282
283 fstrcpy(dc->remote_machine, "\\\\");
284 fstrcat(dc->remote_machine, server_name);
285
286 fstrcpy(dc->domain, domain);
287
288 fstr_sprintf( dc->mach_acct, "%s$", machine_account);
289
290 again:
291 /* Create the client challenge. */
292 generate_random_buffer(clnt_chal_send.data, 8);
293
294 /* Get the server challenge. */
295 result = rpccli_net_req_chal(cli,
296 cli->mem_ctx,
297 dc->remote_machine,
298 clnt_name,
299 &clnt_chal_send,
300 &srv_chal_recv);
301
302 if (!NT_STATUS_IS_OK(result)) {
303 return result;
304 }
305
306 /* Calculate the session key and client credentials */
307 creds_client_init(*neg_flags_inout,
308 dc,
309 &clnt_chal_send,
310 &srv_chal_recv,
311 machine_pwd,
312 &clnt_chal_send);
313
314 /*
315 * Send client auth-2 challenge and receive server repy.
316 */
317
318 result = rpccli_net_auth2(cli,
319 cli->mem_ctx,
320 dc->remote_machine,
321 dc->mach_acct,
322 sec_chan_type,
323 clnt_name,
324 neg_flags_inout,
325 &clnt_chal_send, /* input. */
326 &srv_chal_recv); /* output */
327
328 /* we might be talking to NT4, so let's downgrade in that case and retry
329 * with the returned neg_flags - gd */
330
331 if (NT_STATUS_EQUAL(result, NT_STATUS_ACCESS_DENIED) && !retried) {
332 retried = true;
333 goto again;
334 }
335
336 if (!NT_STATUS_IS_OK(result)) {
337 return result;
338 }
339
340 /*
341 * Check the returned value using the initial
342 * server received challenge.
343 */
344
345 if (!creds_client_check(dc, &srv_chal_recv)) {
346 /*
347 * Server replied with bad credential. Fail.
348 */
349 DEBUG(0,("rpccli_netlogon_setup_creds: server %s "
350 "replied with bad credential\n",
351 cli->cli->desthost ));
352 return NT_STATUS_ACCESS_DENIED;
353 }
354
355 DEBUG(5,("rpccli_netlogon_setup_creds: server %s credential "
356 "chain established.\n",
357 cli->cli->desthost ));
358
359 return NT_STATUS_OK;
360 }
361
362 /* Logon Control 2 */
363
364 NTSTATUS rpccli_netlogon_logon_ctrl2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
365 uint32 query_level)
366 {
367 prs_struct qbuf, rbuf;
368 NET_Q_LOGON_CTRL2 q;
369 NET_R_LOGON_CTRL2 r;
370 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
371 fstring server;
372
373 ZERO_STRUCT(q);
374 ZERO_STRUCT(r);
375
376 /* Initialise input parameters */
377
378 slprintf(server, sizeof(fstring)-1, "\\\\%s", cli->cli->desthost);
379 init_net_q_logon_ctrl2(&q, server, query_level);
380
381 /* Marshall data and send request */
382
383 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_LOGON_CTRL2,
384 q, r,
385 qbuf, rbuf,
386 net_io_q_logon_ctrl2,
387 net_io_r_logon_ctrl2,
388 NT_STATUS_UNSUCCESSFUL);
389
390 result = r.status;
391 return result;
392 }
393
394 /* GetAnyDCName */
395
396 WERROR rpccli_netlogon_getanydcname(struct rpc_pipe_client *cli,
397 TALLOC_CTX *mem_ctx, const char *mydcname,
398 const char *domainname, fstring newdcname)
399 {
400 prs_struct qbuf, rbuf;
401 NET_Q_GETANYDCNAME q;
402 NET_R_GETANYDCNAME r;
403 WERROR result;
404 fstring mydcname_slash;
405
406 ZERO_STRUCT(q);
407 ZERO_STRUCT(r);
408
409 /* Initialise input parameters */
410
411 slprintf(mydcname_slash, sizeof(fstring)-1, "\\\\%s", mydcname);
412 init_net_q_getanydcname(&q, mydcname_slash, domainname);
413
414 /* Marshall data and send request */
415
416 CLI_DO_RPC_WERR(cli, mem_ctx, PI_NETLOGON, NET_GETANYDCNAME,
417 q, r,
418 qbuf, rbuf,
419 net_io_q_getanydcname,
420 net_io_r_getanydcname,
421 WERR_GENERAL_FAILURE);
422
423 result = r.status;
424
425 if (W_ERROR_IS_OK(result)) {
426 rpcstr_pull_unistr2_fstring(newdcname, &r.uni_dcname);
427 }
428
429 return result;
430 }
431
432 static WERROR pull_domain_controller_info_from_getdcname_reply(TALLOC_CTX *mem_ctx,
433 struct DS_DOMAIN_CONTROLLER_INFO **info_out,
434 NET_R_DSR_GETDCNAME *r)
435 {
436 struct DS_DOMAIN_CONTROLLER_INFO *info;
437
438 info = TALLOC_ZERO_P(mem_ctx, struct DS_DOMAIN_CONTROLLER_INFO);
439 if (!info) {
440 return WERR_NOMEM;
441 }
442
443 if (&r->uni_dc_unc) {
444
445 char *tmp;
446 tmp = rpcstr_pull_unistr2_talloc(mem_ctx, &r->uni_dc_unc);
447 if (tmp == NULL) {
448 return WERR_GENERAL_FAILURE;
449 }
450 if (*tmp == '\\') tmp += 1;
451 if (*tmp == '\\') tmp += 1;
452
453 info->domain_controller_name = talloc_strdup(mem_ctx, tmp);
454 if (info->domain_controller_name == NULL) {
455 return WERR_GENERAL_FAILURE;
456 }
457 }
458
459 if (&r->uni_dc_address) {
460
461 char *tmp;
462 tmp = rpcstr_pull_unistr2_talloc(mem_ctx, &r->uni_dc_address);
463 if (tmp == NULL) {
464 return WERR_GENERAL_FAILURE;
465 }
466 if (*tmp == '\\') tmp += 1;
467 if (*tmp == '\\') tmp += 1;
468
469 info->domain_controller_address = talloc_strdup(mem_ctx, tmp);
470 if (info->domain_controller_address == NULL) {
471 return WERR_GENERAL_FAILURE;
472 }
473 }
474
475 info->domain_controller_address_type = r->dc_address_type;
476
477 info->domain_guid = talloc_memdup(mem_ctx, &r->domain_guid, sizeof(struct GUID));
478 if (!info->domain_guid) {
479 return WERR_GENERAL_FAILURE;
480 }
481
482 if (&r->uni_domain_name) {
483 info->domain_name = rpcstr_pull_unistr2_talloc(mem_ctx, &r->uni_domain_name);
484 if (!info->domain_name) {
485 return WERR_GENERAL_FAILURE;
486 }
487 }
488
489 if (&r->uni_forest_name) {
490 info->dns_forest_name = rpcstr_pull_unistr2_talloc(mem_ctx, &r->uni_forest_name);
491 if (!info->dns_forest_name) {
492 return WERR_GENERAL_FAILURE;
493 }
494 }
495
496 info->flags = r->dc_flags;
497
498 if (&r->uni_dc_site_name) {
499 info->dc_site_name = rpcstr_pull_unistr2_talloc(mem_ctx, &r->uni_dc_site_name);
500 if (!info->dc_site_name) {
501 return WERR_GENERAL_FAILURE;
502 }
503 }
504
505 if (&r->uni_client_site_name) {
506 info->client_site_name = rpcstr_pull_unistr2_talloc(mem_ctx, &r->uni_client_site_name);
507 if (!info->client_site_name) {
508 return WERR_GENERAL_FAILURE;
509 }
510 }
511
512 *info_out = info;
513
514 return WERR_OK;
515 }
516
517 /* Dsr_GetDCName */
518
519 WERROR rpccli_netlogon_dsr_getdcname(struct rpc_pipe_client *cli,
520 TALLOC_CTX *mem_ctx,
521 const char *server_name,
522 const char *domain_name,
523 struct GUID *domain_guid,
524 struct GUID *site_guid,
525 uint32_t flags,
526 struct DS_DOMAIN_CONTROLLER_INFO **info_out)
527 {
528 prs_struct qbuf, rbuf;
529 NET_Q_DSR_GETDCNAME q;
530 NET_R_DSR_GETDCNAME r;
531 char *tmp_str;
532
533 ZERO_STRUCT(q);
534 ZERO_STRUCT(r);
535
536 /* Initialize input parameters */
537
538 tmp_str = talloc_asprintf(mem_ctx, "\\\\%s", server_name);
539 if (tmp_str == NULL) {
540 return WERR_NOMEM;
541 }
542
543 init_net_q_dsr_getdcname(&q, tmp_str, domain_name, domain_guid,
544 site_guid, flags);
545
546 /* Marshall data and send request */
547
548 CLI_DO_RPC_WERR(cli, mem_ctx, PI_NETLOGON, NET_DSR_GETDCNAME,
549 q, r,
550 qbuf, rbuf,
551 net_io_q_dsr_getdcname,
552 net_io_r_dsr_getdcname,
553 WERR_GENERAL_FAILURE);
554
555 if (!W_ERROR_IS_OK(r.result)) {
556 return r.result;
557 }
558
559 r.result = pull_domain_controller_info_from_getdcname_reply(mem_ctx, info_out, &r);
560 if (!W_ERROR_IS_OK(r.result)) {
561 return r.result;
562 }
563
564 return WERR_OK;
565 }
566
567 /* Dsr_GetDCNameEx */
568
569 WERROR rpccli_netlogon_dsr_getdcnameex(struct rpc_pipe_client *cli,
570 TALLOC_CTX *mem_ctx,
571 const char *server_name,
572 const char *domain_name,
573 struct GUID *domain_guid,
574 const char *site_name,
575 uint32_t flags,
576 struct DS_DOMAIN_CONTROLLER_INFO **info_out)
577 {
578 prs_struct qbuf, rbuf;
579 NET_Q_DSR_GETDCNAMEEX q;
580 NET_R_DSR_GETDCNAME r;
581 char *tmp_str;
582
583 ZERO_STRUCT(q);
584 ZERO_STRUCT(r);
585
586 /* Initialize input parameters */
587
588 tmp_str = talloc_asprintf(mem_ctx, "\\\\%s", server_name);
589 if (tmp_str == NULL) {
590 return WERR_NOMEM;
591 }
592
593 init_net_q_dsr_getdcnameex(&q, server_name, domain_name, domain_guid,
594 site_name, flags);
595
596 /* Marshall data and send request */
597
598 CLI_DO_RPC_WERR(cli, mem_ctx, PI_NETLOGON, NET_DSR_GETDCNAMEEX,
599 q, r,
600 qbuf, rbuf,
601 net_io_q_dsr_getdcnameex,
602 net_io_r_dsr_getdcname,
603 WERR_GENERAL_FAILURE);
604
605 if (!W_ERROR_IS_OK(r.result)) {
606 return r.result;
607 }
608
609 r.result = pull_domain_controller_info_from_getdcname_reply(mem_ctx, info_out, &r);
610 if (!W_ERROR_IS_OK(r.result)) {
611 return r.result;
612 }
613
614 return WERR_OK;
615 }
616
617 /* Dsr_GetDCNameEx */
618
619 WERROR rpccli_netlogon_dsr_getdcnameex2(struct rpc_pipe_client *cli,
620 TALLOC_CTX *mem_ctx,
621 const char *server_name,
622 const char *client_account,
623 uint32 mask,
624 const char *domain_name,
625 struct GUID *domain_guid,
626 const char *site_name,
627 uint32_t flags,
628 struct DS_DOMAIN_CONTROLLER_INFO **info_out)
629 {
630 prs_struct qbuf, rbuf;
631 NET_Q_DSR_GETDCNAMEEX2 q;
632 NET_R_DSR_GETDCNAME r;
633 char *tmp_str;
634
635 ZERO_STRUCT(q);
636 ZERO_STRUCT(r);
637
638 /* Initialize input parameters */
639
640 tmp_str = talloc_asprintf(mem_ctx, "\\\\%s", server_name);
641 if (tmp_str == NULL) {
642 return WERR_NOMEM;
643 }
644
645 init_net_q_dsr_getdcnameex2(&q, server_name, domain_name, client_account,
646 mask, domain_guid, site_name, flags);
647
648 /* Marshall data and send request */
649
650 CLI_DO_RPC_WERR(cli, mem_ctx, PI_NETLOGON, NET_DSR_GETDCNAMEEX2,
651 q, r,
652 qbuf, rbuf,
653 net_io_q_dsr_getdcnameex2,
654 net_io_r_dsr_getdcname,
655 WERR_GENERAL_FAILURE);
656
657 if (!W_ERROR_IS_OK(r.result)) {
658 return r.result;
659 }
660
661 r.result = pull_domain_controller_info_from_getdcname_reply(mem_ctx, info_out, &r);
662 if (!W_ERROR_IS_OK(r.result)) {
663 return r.result;
664 }
665
666 return WERR_OK;
667 }
668
669
670 /* Dsr_GetSiteName */
671
672 WERROR rpccli_netlogon_dsr_getsitename(struct rpc_pipe_client *cli,
673 TALLOC_CTX *mem_ctx,
674 const char *computer_name,
675 char **site_name)
676 {
677 prs_struct qbuf, rbuf;
678 NET_Q_DSR_GETSITENAME q;
679 NET_R_DSR_GETSITENAME r;
680
681 ZERO_STRUCT(q);
682 ZERO_STRUCT(r);
683
684 /* Initialize input parameters */
685
686 init_net_q_dsr_getsitename(&q, computer_name);
687
688 /* Marshall data and send request */
689
690 CLI_DO_RPC_WERR(cli, mem_ctx, PI_NETLOGON, NET_DSR_GETSITENAME,
691 q, r,
692 qbuf, rbuf,
693 net_io_q_dsr_getsitename,
694 net_io_r_dsr_getsitename,
695 WERR_GENERAL_FAILURE);
696
697 if (!W_ERROR_IS_OK(r.result)) {
698 return r.result;
699 }
700
701 if ((site_name != NULL) &&
702 ((*site_name = rpcstr_pull_unistr2_talloc(
703 mem_ctx, &r.uni_site_name)) == NULL)) {
704 return WERR_GENERAL_FAILURE;
705 }
706
707 return WERR_OK;
708 }
709
710
711
712 /* Sam synchronisation */
713
714 NTSTATUS rpccli_netlogon_sam_sync(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
715 uint32 database_id, uint32 next_rid, uint32 *num_deltas,
716 SAM_DELTA_HDR **hdr_deltas,
717 SAM_DELTA_CTR **deltas)
718 {
719 prs_struct qbuf, rbuf;
720 NET_Q_SAM_SYNC q;
721 NET_R_SAM_SYNC r;
722 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
723 DOM_CRED clnt_creds;
724 DOM_CRED ret_creds;
725
726 ZERO_STRUCT(q);
727 ZERO_STRUCT(r);
728
729 ZERO_STRUCT(ret_creds);
730
731 /* Initialise input parameters */
732
733 creds_client_step(cli->dc, &clnt_creds);
734
735 init_net_q_sam_sync(&q, cli->dc->remote_machine, global_myname(),
736 &clnt_creds, &ret_creds, database_id, next_rid);
737
738 /* Marshall data and send request */
739
740 CLI_DO_RPC_COPY_SESS_KEY(cli, mem_ctx, PI_NETLOGON, NET_SAM_SYNC,
741 q, r,
742 qbuf, rbuf,
743 net_io_q_sam_sync,
744 net_io_r_sam_sync,
745 NT_STATUS_UNSUCCESSFUL);
746
747 /* Return results */
748
749 result = r.status;
750 *num_deltas = r.num_deltas2;
751 *hdr_deltas = r.hdr_deltas;
752 *deltas = r.deltas;
753
754 if (!NT_STATUS_IS_ERR(result)) {
755 /* Check returned credentials. */
756 if (!creds_client_check(cli->dc, &r.srv_creds.challenge)) {
757 DEBUG(0,("cli_netlogon_sam_sync: credentials chain check failed\n"));
758 return NT_STATUS_ACCESS_DENIED;
759 }
760 }
761
762 return result;
763 }
764
765 /* Sam synchronisation */
766
767 NTSTATUS rpccli_netlogon_sam_deltas(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
768 uint32 database_id, uint64 seqnum,
769 uint32 *num_deltas,
770 SAM_DELTA_HDR **hdr_deltas,
771 SAM_DELTA_CTR **deltas)
772 {
773 prs_struct qbuf, rbuf;
774 NET_Q_SAM_DELTAS q;
775 NET_R_SAM_DELTAS r;
776 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
777 DOM_CRED clnt_creds;
778
779 ZERO_STRUCT(q);
780 ZERO_STRUCT(r);
781
782 /* Initialise input parameters */
783
784 creds_client_step(cli->dc, &clnt_creds);
785
786 init_net_q_sam_deltas(&q, cli->dc->remote_machine,
787 global_myname(), &clnt_creds,
788 database_id, seqnum);
789
790 /* Marshall data and send request */
791
792 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_SAM_DELTAS,
793 q, r,
794 qbuf, rbuf,
795 net_io_q_sam_deltas,
796 net_io_r_sam_deltas,
797 NT_STATUS_UNSUCCESSFUL);
798
799 /* Return results */
800
801 result = r.status;
802 *num_deltas = r.num_deltas2;
803 *hdr_deltas = r.hdr_deltas;
804 *deltas = r.deltas;
805
806 if (!NT_STATUS_IS_ERR(result)) {
807 /* Check returned credentials. */
808 if (!creds_client_check(cli->dc, &r.srv_creds.challenge)) {
809 DEBUG(0,("cli_netlogon_sam_sync: credentials chain check failed\n"));
810 return NT_STATUS_ACCESS_DENIED;
811 }
812 }
813
814 return result;
815 }
816
817 /* Logon domain user */
818
819 NTSTATUS rpccli_netlogon_sam_logon(struct rpc_pipe_client *cli,
820 TALLOC_CTX *mem_ctx,
821 uint32 logon_parameters,
822 const char *domain,
823 const char *username,
824 const char *password,
825 const char *workstation,
826 int logon_type)
827 {
828 prs_struct qbuf, rbuf;
829 NET_Q_SAM_LOGON q;
830 NET_R_SAM_LOGON r;
831 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
832 DOM_CRED clnt_creds;
833 DOM_CRED ret_creds;
834 NET_ID_INFO_CTR ctr;
835 NET_USER_INFO_3 user;
836 int validation_level = 3;
837 fstring clnt_name_slash;
838
839 ZERO_STRUCT(q);
840 ZERO_STRUCT(r);
841 ZERO_STRUCT(ret_creds);
842
843 if (workstation) {
844 fstr_sprintf( clnt_name_slash, "\\\\%s", workstation );
845 } else {
846 fstr_sprintf( clnt_name_slash, "\\\\%s", global_myname() );
847 }
848
849 /* Initialise input parameters */
850
851 creds_client_step(cli->dc, &clnt_creds);
852
853 q.validation_level = validation_level;
854
855 ctr.switch_value = logon_type;
856
857 switch (logon_type) {
858 case INTERACTIVE_LOGON_TYPE: {
859 unsigned char lm_owf_user_pwd[16], nt_owf_user_pwd[16];
860
861 nt_lm_owf_gen(password, nt_owf_user_pwd, lm_owf_user_pwd);
862
863 init_id_info1(&ctr.auth.id1, domain,
864 logon_parameters, /* param_ctrl */
865 0xdead, 0xbeef, /* LUID? */
866 username, clnt_name_slash,
867 (const char *)cli->dc->sess_key, lm_owf_user_pwd,
868 nt_owf_user_pwd);
869
870 break;
871 }
872 case NET_LOGON_TYPE: {
873 uint8 chal[8];
874 unsigned char local_lm_response[24];
875 unsigned char local_nt_response[24];
876
877 generate_random_buffer(chal, 8);
878
879 SMBencrypt(password, chal, local_lm_response);
880 SMBNTencrypt(password, chal, local_nt_response);
881
882 init_id_info2(&ctr.auth.id2, domain,
883 logon_parameters, /* param_ctrl */
884 0xdead, 0xbeef, /* LUID? */
885 username, clnt_name_slash, chal,
886 local_lm_response, 24, local_nt_response, 24);
887 break;
888 }
889 default:
890 DEBUG(0, ("switch value %d not supported\n",
891 ctr.switch_value));
892 return NT_STATUS_INVALID_INFO_CLASS;
893 }
894
895 r.user = &user;
896
897 init_sam_info(&q.sam_id, cli->dc->remote_machine, global_myname(),
898 &clnt_creds, &ret_creds, logon_type,
899 &ctr);
900
901 /* Marshall data and send request */
902
903 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_SAMLOGON,
904 q, r,
905 qbuf, rbuf,
906 net_io_q_sam_logon,
907 net_io_r_sam_logon,
908 NT_STATUS_UNSUCCESSFUL);
909
910 /* Return results */
911
912 result = r.status;
913
914 if (r.buffer_creds) {
915 /* Check returned credentials if present. */
916 if (!creds_client_check(cli->dc, &r.srv_creds.challenge)) {
917 DEBUG(0,("rpccli_netlogon_sam_logon: credentials chain check failed\n"));
918 return NT_STATUS_ACCESS_DENIED;
919 }
920 }
921
922 return result;
923 }
924
925
926 /**
927 * Logon domain user with an 'network' SAM logon
928 *
929 * @param info3 Pointer to a NET_USER_INFO_3 already allocated by the caller.
930 **/
931
932 NTSTATUS rpccli_netlogon_sam_network_logon(struct rpc_pipe_client *cli,
933 TALLOC_CTX *mem_ctx,
934 uint32 logon_parameters,
935 const char *server,
936 const char *username,
937 const char *domain,
938 const char *workstation,
939 const uint8 chal[8],
940 DATA_BLOB lm_response,
941 DATA_BLOB nt_response,
942 NET_USER_INFO_3 *info3)
943 {
944 prs_struct qbuf, rbuf;
945 NET_Q_SAM_LOGON q;
946 NET_R_SAM_LOGON r;
947 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
948 NET_ID_INFO_CTR ctr;
949 int validation_level = 3;
950 const char *workstation_name_slash;
951 const char *server_name_slash;
952 static uint8 zeros[16];
953 DOM_CRED clnt_creds;
954 DOM_CRED ret_creds;
955 int i;
956
957 ZERO_STRUCT(q);
958 ZERO_STRUCT(r);
959 ZERO_STRUCT(ret_creds);
960
961 creds_client_step(cli->dc, &clnt_creds);
962
963 if (server[0] != '\\' && server[1] != '\\') {
964 server_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", server);
965 } else {
966 server_name_slash = server;
967 }
968
969 if (workstation[0] != '\\' && workstation[1] != '\\') {
970 workstation_name_slash = talloc_asprintf(mem_ctx, "\\\\%s", workstation);
971 } else {
972 workstation_name_slash = workstation;
973 }
974
975 if (!workstation_name_slash || !server_name_slash) {
976 DEBUG(0, ("talloc_asprintf failed!\n"));
977 return NT_STATUS_NO_MEMORY;
978 }
979
980 /* Initialise input parameters */
981
982 q.validation_level = validation_level;
983
984 ctr.switch_value = NET_LOGON_TYPE;
985
986 init_id_info2(&ctr.auth.id2, domain,
987 logon_parameters, /* param_ctrl */
988 0xdead, 0xbeef, /* LUID? */
989 username, workstation_name_slash, (const uchar*)chal,
990 lm_response.data, lm_response.length, nt_response.data, nt_response.length);
991
992 init_sam_info(&q.sam_id, server_name_slash, global_myname(),
993 &clnt_creds, &ret_creds, NET_LOGON_TYPE,
994 &ctr);
995
996 r.user = info3;
997
998 /* Marshall data and send request */
999
1000 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_SAMLOGON,
1001 q, r,
1002 qbuf, rbuf,
1003 net_io_q_sam_logon,
1004 net_io_r_sam_logon,
1005 NT_STATUS_UNSUCCESSFUL);
1006
1007 if (memcmp(zeros, info3->user_sess_key, 16) != 0) {
1008 SamOEMhash(info3->user_sess_key, cli->dc->sess_key, 16);
1009 } else {
1010 memset(info3->user_sess_key, '\0', 16);
1011 }
1012
1013 if (memcmp(zeros, info3->lm_sess_key, 8) != 0) {
1014 SamOEMhash(info3->lm_sess_key, cli->dc->sess_key, 8);
1015 } else {
1016 memset(info3->lm_sess_key, '\0', 8);
1017 }
1018
1019 for (i=0; i < 7; i++) {
1020 memset(&info3->unknown[i], '\0', 4);
1021 }
1022
1023 /* Return results */
1024
1025 result = r.status;
1026
1027 if (r.buffer_creds) {
1028 /* Check returned credentials if present. */
1029 if (!creds_client_check(cli->dc, &r.srv_creds.challenge)) {
1030 DEBUG(0,("rpccli_netlogon_sam_network_logon: credentials chain check failed\n"));
1031 return NT_STATUS_ACCESS_DENIED;
1032 }
1033 }
1034
1035 return result;
1036 }
1037
1038 /***************************************************************************
1039 LSA Server Password Set.
1040 ****************************************************************************/
1041
1042 NTSTATUS rpccli_net_srv_pwset(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
1043 const char *machine_name, const uint8 hashed_mach_pwd[16])
1044 {
1045 prs_struct rbuf;
1046 prs_struct qbuf;
1047 DOM_CRED clnt_creds;
1048 NET_Q_SRV_PWSET q;
1049 NET_R_SRV_PWSET r;
1050 uint16 sec_chan_type = 2;
1051 NTSTATUS result;
1052
1053 creds_client_step(cli->dc, &clnt_creds);
1054
1055 DEBUG(4,("cli_net_srv_pwset: srv:%s acct:%s sc: %d mc: %s\n",
1056 cli->dc->remote_machine, cli->dc->mach_acct, sec_chan_type, machine_name));
1057
1058 /* store the parameters */
1059 init_q_srv_pwset(&q, cli->dc->remote_machine, (const char *)cli->dc->sess_key,
1060 cli->dc->mach_acct, sec_chan_type, machine_name,
1061 &clnt_creds, hashed_mach_pwd);
1062
1063 CLI_DO_RPC(cli, mem_ctx, PI_NETLOGON, NET_SRVPWSET,
1064 q, r,
1065 qbuf, rbuf,
1066 net_io_q_srv_pwset,
1067 net_io_r_srv_pwset,
1068 NT_STATUS_UNSUCCESSFUL);
1069
1070 result = r.status;
1071
1072 if (!NT_STATUS_IS_OK(result)) {
1073 /* report error code */
1074 DEBUG(0,("cli_net_srv_pwset: %s\n", nt_errstr(result)));
1075 }
1076
1077 /* Always check returned credentials. */
1078 if (!creds_client_check(cli->dc, &r.srv_cred.challenge)) {
1079 DEBUG(0,("rpccli_net_srv_pwset: credentials chain check failed\n"));
1080 return NT_STATUS_ACCESS_DENIED;
1081 }
1082
1083 return result;
1084 }
Samba GIT mirror