?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix Coverity ID 628, Andrew B., please check!
[Samba/gbeck.git] / source4 / rpc_server / lsa / dcesrv_lsa.c
blobcbadf654fbdadceac3bb49322baa8312f5dc5bbc
1 /* need access mask/acl implementation */
2
3 /*
4 Unix SMB/CIFS implementation.
5
6 endpoint server for the lsarpc pipe
7
8 Copyright (C) Andrew Tridgell 2004
9 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2008
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "rpc_server/lsa/lsa.h"
26 #include "../lib/util/util_ldb.h"
27 #include "libcli/ldap/ldap_ndr.h"
28 #include "system/kerberos.h"
29 #include "auth/kerberos/kerberos.h"
30 #include "librpc/gen_ndr/ndr_drsblobs.h"
31 #include "librpc/gen_ndr/ndr_lsa.h"
32 #include "../lib/crypto/crypto.h"
33
34 /*
35 this type allows us to distinguish handle types
36 */
37
38 /*
39 state associated with a lsa_OpenAccount() operation
40 */
41 struct lsa_account_state {
42 struct lsa_policy_state *policy;
43 uint32_t access_mask;
44 struct dom_sid *account_sid;
45 };
46
47
48 /*
49 state associated with a lsa_OpenSecret() operation
50 */
51 struct lsa_secret_state {
52 struct lsa_policy_state *policy;
53 uint32_t access_mask;
54 struct ldb_dn *secret_dn;
55 struct ldb_context *sam_ldb;
56 bool global;
57 };
58
59 /*
60 state associated with a lsa_OpenTrustedDomain() operation
61 */
62 struct lsa_trusted_domain_state {
63 struct lsa_policy_state *policy;
64 uint32_t access_mask;
65 struct ldb_dn *trusted_domain_dn;
66 struct ldb_dn *trusted_domain_user_dn;
67 };
68
69 static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
70 TALLOC_CTX *mem_ctx,
71 struct lsa_EnumAccountRights *r);
72
73 static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
74 TALLOC_CTX *mem_ctx,
75 struct lsa_policy_state *state,
76 int ldb_flag,
77 struct dom_sid *sid,
78 const struct lsa_RightSet *rights);
79
80 /*
81 lsa_Close
82 */
83 static NTSTATUS dcesrv_lsa_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
84 struct lsa_Close *r)
85 {
86 struct dcesrv_handle *h;
87
88 *r->out.handle = *r->in.handle;
89
90 DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
91
92 talloc_free(h);
93
94 ZERO_STRUCTP(r->out.handle);
95
96 return NT_STATUS_OK;
97 }
98
99
100 /*
101 lsa_Delete
102 */
103 static NTSTATUS dcesrv_lsa_Delete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
104 struct lsa_Delete *r)
105 {
106 return NT_STATUS_NOT_SUPPORTED;
107 }
108
109
110 /*
111 lsa_DeleteObject
112 */
113 static NTSTATUS dcesrv_lsa_DeleteObject(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
114 struct lsa_DeleteObject *r)
115 {
116 struct dcesrv_handle *h;
117 int ret;
118
119 DCESRV_PULL_HANDLE(h, r->in.handle, DCESRV_HANDLE_ANY);
120
121 if (h->wire_handle.handle_type == LSA_HANDLE_SECRET) {
122 struct lsa_secret_state *secret_state = h->data;
123
124 /* Ensure user is permitted to delete this... */
125 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
126 {
127 case SECURITY_SYSTEM:
128 case SECURITY_ADMINISTRATOR:
129 break;
130 default:
131 /* Users and annonymous are not allowed delete things */
132 return NT_STATUS_ACCESS_DENIED;
133 }
134
135 ret = ldb_delete(secret_state->sam_ldb,
136 secret_state->secret_dn);
137 talloc_free(h);
138 if (ret != 0) {
139 return NT_STATUS_INVALID_HANDLE;
140 }
141
142 ZERO_STRUCTP(r->out.handle);
143
144 return NT_STATUS_OK;
145 } else if (h->wire_handle.handle_type == LSA_HANDLE_TRUSTED_DOMAIN) {
146 struct lsa_trusted_domain_state *trusted_domain_state =
147 talloc_get_type(h->data, struct lsa_trusted_domain_state);
148 ret = ldb_transaction_start(trusted_domain_state->policy->sam_ldb);
149 if (ret != 0) {
150 return NT_STATUS_INTERNAL_DB_CORRUPTION;
151 }
152
153 ret = ldb_delete(trusted_domain_state->policy->sam_ldb,
154 trusted_domain_state->trusted_domain_dn);
155 if (ret != 0) {
156 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
157 return NT_STATUS_INVALID_HANDLE;
158 }
159
160 if (trusted_domain_state->trusted_domain_user_dn) {
161 ret = ldb_delete(trusted_domain_state->policy->sam_ldb,
162 trusted_domain_state->trusted_domain_user_dn);
163 if (ret != 0) {
164 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
165 return NT_STATUS_INVALID_HANDLE;
166 }
167 }
168
169 ret = ldb_transaction_commit(trusted_domain_state->policy->sam_ldb);
170 if (ret != 0) {
171 return NT_STATUS_INTERNAL_DB_CORRUPTION;
172 }
173 talloc_free(h);
174 ZERO_STRUCTP(r->out.handle);
175
176 return NT_STATUS_OK;
177 } else if (h->wire_handle.handle_type == LSA_HANDLE_ACCOUNT) {
178 struct lsa_RightSet *rights;
179 struct lsa_account_state *astate;
180 struct lsa_EnumAccountRights r2;
181 NTSTATUS status;
182
183 rights = talloc(mem_ctx, struct lsa_RightSet);
184
185 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
186
187 astate = h->data;
188
189 r2.in.handle = &astate->policy->handle->wire_handle;
190 r2.in.sid = astate->account_sid;
191 r2.out.rights = rights;
192
193 /* dcesrv_lsa_EnumAccountRights takes a LSA_HANDLE_POLICY,
194 but we have a LSA_HANDLE_ACCOUNT here, so this call
195 will always fail */
196 status = dcesrv_lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
197 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
198 return NT_STATUS_OK;
199 }
200
201 if (!NT_STATUS_IS_OK(status)) {
202 return status;
203 }
204
205 status = dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
206 LDB_FLAG_MOD_DELETE, astate->account_sid,
207 r2.out.rights);
208 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
209 return NT_STATUS_OK;
210 }
211
212 if (!NT_STATUS_IS_OK(status)) {
213 return status;
214 }
215
216 ZERO_STRUCTP(r->out.handle);
217 }
218
219 return NT_STATUS_INVALID_HANDLE;
220 }
221
222
223 /*
224 lsa_EnumPrivs
225 */
226 static NTSTATUS dcesrv_lsa_EnumPrivs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
227 struct lsa_EnumPrivs *r)
228 {
229 struct dcesrv_handle *h;
230 struct lsa_policy_state *state;
231 int i;
232 const char *privname;
233
234 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
235
236 state = h->data;
237
238 i = *r->in.resume_handle;
239 if (i == 0) i = 1;
240
241 while ((privname = sec_privilege_name(i)) &&
242 r->out.privs->count < r->in.max_count) {
243 struct lsa_PrivEntry *e;
244
245 r->out.privs->privs = talloc_realloc(r->out.privs,
246 r->out.privs->privs,
247 struct lsa_PrivEntry,
248 r->out.privs->count+1);
249 if (r->out.privs->privs == NULL) {
250 return NT_STATUS_NO_MEMORY;
251 }
252 e = &r->out.privs->privs[r->out.privs->count];
253 e->luid.low = i;
254 e->luid.high = 0;
255 e->name.string = privname;
256 r->out.privs->count++;
257 i++;
258 }
259
260 *r->out.resume_handle = i;
261
262 return NT_STATUS_OK;
263 }
264
265
266 /*
267 lsa_QuerySecObj
268 */
269 static NTSTATUS dcesrv_lsa_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
270 struct lsa_QuerySecurity *r)
271 {
272 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
273 }
274
275
276 /*
277 lsa_SetSecObj
278 */
279 static NTSTATUS dcesrv_lsa_SetSecObj(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
280 struct lsa_SetSecObj *r)
281 {
282 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
283 }
284
285
286 /*
287 lsa_ChangePassword
288 */
289 static NTSTATUS dcesrv_lsa_ChangePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
290 struct lsa_ChangePassword *r)
291 {
292 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
293 }
294
295 /*
296 dssetup_DsRoleGetPrimaryDomainInformation
297
298 This is not an LSA call, but is the only call left on the DSSETUP
299 pipe (after the pipe was truncated), and needs lsa_get_policy_state
300 */
301 static WERROR dcesrv_dssetup_DsRoleGetPrimaryDomainInformation(struct dcesrv_call_state *dce_call,
302 TALLOC_CTX *mem_ctx,
303 struct dssetup_DsRoleGetPrimaryDomainInformation *r)
304 {
305 union dssetup_DsRoleInfo *info;
306
307 info = talloc(mem_ctx, union dssetup_DsRoleInfo);
308 W_ERROR_HAVE_NO_MEMORY(info);
309
310 switch (r->in.level) {
311 case DS_ROLE_BASIC_INFORMATION:
312 {
313 enum dssetup_DsRole role = DS_ROLE_STANDALONE_SERVER;
314 uint32_t flags = 0;
315 const char *domain = NULL;
316 const char *dns_domain = NULL;
317 const char *forest = NULL;
318 struct GUID domain_guid;
319 struct lsa_policy_state *state;
320
321 NTSTATUS status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx, &state);
322 if (!NT_STATUS_IS_OK(status)) {
323 return ntstatus_to_werror(status);
324 }
325
326 ZERO_STRUCT(domain_guid);
327
328 switch (lp_server_role(dce_call->conn->dce_ctx->lp_ctx)) {
329 case ROLE_STANDALONE:
330 role = DS_ROLE_STANDALONE_SERVER;
331 break;
332 case ROLE_DOMAIN_MEMBER:
333 role = DS_ROLE_MEMBER_SERVER;
334 break;
335 case ROLE_DOMAIN_CONTROLLER:
336 if (samdb_is_pdc(state->sam_ldb)) {
337 role = DS_ROLE_PRIMARY_DC;
338 } else {
339 role = DS_ROLE_BACKUP_DC;
340 }
341 break;
342 }
343
344 switch (lp_server_role(dce_call->conn->dce_ctx->lp_ctx)) {
345 case ROLE_STANDALONE:
346 domain = talloc_strdup(mem_ctx, lp_workgroup(dce_call->conn->dce_ctx->lp_ctx));
347 W_ERROR_HAVE_NO_MEMORY(domain);
348 break;
349 case ROLE_DOMAIN_MEMBER:
350 domain = talloc_strdup(mem_ctx, lp_workgroup(dce_call->conn->dce_ctx->lp_ctx));
351 W_ERROR_HAVE_NO_MEMORY(domain);
352 /* TODO: what is with dns_domain and forest and guid? */
353 break;
354 case ROLE_DOMAIN_CONTROLLER:
355 flags = DS_ROLE_PRIMARY_DS_RUNNING;
356
357 if (state->mixed_domain == 1) {
358 flags |= DS_ROLE_PRIMARY_DS_MIXED_MODE;
359 }
360
361 domain = state->domain_name;
362 dns_domain = state->domain_dns;
363 forest = state->forest_dns;
364
365 domain_guid = state->domain_guid;
366 flags |= DS_ROLE_PRIMARY_DOMAIN_GUID_PRESENT;
367 break;
368 }
369
370 info->basic.role = role;
371 info->basic.flags = flags;
372 info->basic.domain = domain;
373 info->basic.dns_domain = dns_domain;
374 info->basic.forest = forest;
375 info->basic.domain_guid = domain_guid;
376
377 r->out.info = info;
378 return WERR_OK;
379 }
380 case DS_ROLE_UPGRADE_STATUS:
381 {
382 info->upgrade.upgrading = DS_ROLE_NOT_UPGRADING;
383 info->upgrade.previous_role = DS_ROLE_PREVIOUS_UNKNOWN;
384
385 r->out.info = info;
386 return WERR_OK;
387 }
388 case DS_ROLE_OP_STATUS:
389 {
390 info->opstatus.status = DS_ROLE_OP_IDLE;
391
392 r->out.info = info;
393 return WERR_OK;
394 }
395 default:
396 return WERR_INVALID_PARAM;
397 }
398
399 return WERR_INVALID_PARAM;
400 }
401
402 /*
403 fill in the AccountDomain info
404 */
405 static NTSTATUS dcesrv_lsa_info_AccountDomain(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
406 struct lsa_DomainInfo *info)
407 {
408 info->name.string = state->domain_name;
409 info->sid = state->domain_sid;
410
411 return NT_STATUS_OK;
412 }
413
414 /*
415 fill in the DNS domain info
416 */
417 static NTSTATUS dcesrv_lsa_info_DNS(struct lsa_policy_state *state, TALLOC_CTX *mem_ctx,
418 struct lsa_DnsDomainInfo *info)
419 {
420 info->name.string = state->domain_name;
421 info->sid = state->domain_sid;
422 info->dns_domain.string = state->domain_dns;
423 info->dns_forest.string = state->forest_dns;
424 info->domain_guid = state->domain_guid;
425
426 return NT_STATUS_OK;
427 }
428
429 /*
430 lsa_QueryInfoPolicy2
431 */
432 static NTSTATUS dcesrv_lsa_QueryInfoPolicy2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
433 struct lsa_QueryInfoPolicy2 *r)
434 {
435 struct lsa_policy_state *state;
436 struct dcesrv_handle *h;
437 union lsa_PolicyInformation *info;
438
439 *r->out.info = NULL;
440
441 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
442
443 state = h->data;
444
445 info = talloc_zero(mem_ctx, union lsa_PolicyInformation);
446 if (!info) {
447 return NT_STATUS_NO_MEMORY;
448 }
449 *r->out.info = info;
450
451 switch (r->in.level) {
452 case LSA_POLICY_INFO_AUDIT_LOG:
453 /* we don't need to fill in any of this */
454 ZERO_STRUCT(info->audit_log);
455 return NT_STATUS_OK;
456 case LSA_POLICY_INFO_AUDIT_EVENTS:
457 /* we don't need to fill in any of this */
458 ZERO_STRUCT(info->audit_events);
459 return NT_STATUS_OK;
460 case LSA_POLICY_INFO_PD:
461 /* we don't need to fill in any of this */
462 ZERO_STRUCT(info->pd);
463 return NT_STATUS_OK;
464
465 case LSA_POLICY_INFO_DOMAIN:
466 return dcesrv_lsa_info_AccountDomain(state, mem_ctx, &info->domain);
467 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
468 return dcesrv_lsa_info_AccountDomain(state, mem_ctx, &info->account_domain);
469 case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN:
470 return dcesrv_lsa_info_AccountDomain(state, mem_ctx, &info->l_account_domain);
471
472
473 case LSA_POLICY_INFO_ROLE:
474 info->role.role = LSA_ROLE_PRIMARY;
475 return NT_STATUS_OK;
476
477 case LSA_POLICY_INFO_DNS:
478 case LSA_POLICY_INFO_DNS_INT:
479 return dcesrv_lsa_info_DNS(state, mem_ctx, &info->dns);
480
481 case LSA_POLICY_INFO_REPLICA:
482 ZERO_STRUCT(info->replica);
483 return NT_STATUS_OK;
484
485 case LSA_POLICY_INFO_QUOTA:
486 ZERO_STRUCT(info->quota);
487 return NT_STATUS_OK;
488
489 case LSA_POLICY_INFO_MOD:
490 case LSA_POLICY_INFO_AUDIT_FULL_SET:
491 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
492 /* windows gives INVALID_PARAMETER */
493 *r->out.info = NULL;
494 return NT_STATUS_INVALID_PARAMETER;
495 }
496
497 *r->out.info = NULL;
498 return NT_STATUS_INVALID_INFO_CLASS;
499 }
500
501 /*
502 lsa_QueryInfoPolicy
503 */
504 static NTSTATUS dcesrv_lsa_QueryInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
505 struct lsa_QueryInfoPolicy *r)
506 {
507 struct lsa_QueryInfoPolicy2 r2;
508 NTSTATUS status;
509
510 ZERO_STRUCT(r2);
511
512 r2.in.handle = r->in.handle;
513 r2.in.level = r->in.level;
514 r2.out.info = r->out.info;
515
516 status = dcesrv_lsa_QueryInfoPolicy2(dce_call, mem_ctx, &r2);
517
518 return status;
519 }
520
521 /*
522 lsa_SetInfoPolicy
523 */
524 static NTSTATUS dcesrv_lsa_SetInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
525 struct lsa_SetInfoPolicy *r)
526 {
527 /* need to support this */
528 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
529 }
530
531
532 /*
533 lsa_ClearAuditLog
534 */
535 static NTSTATUS dcesrv_lsa_ClearAuditLog(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
536 struct lsa_ClearAuditLog *r)
537 {
538 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
539 }
540
541
542 /*
543 lsa_CreateAccount
544
545 This call does not seem to have any long-term effects, hence no database operations
546
547 we need to talk to the MS product group to find out what this account database means!
548
549 answer is that the lsa database is totally separate from the SAM and
550 ldap databases. We are going to need a separate ldb to store these
551 accounts. The SIDs on this account bear no relation to the SIDs in
552 AD
553 */
554 static NTSTATUS dcesrv_lsa_CreateAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
555 struct lsa_CreateAccount *r)
556 {
557 struct lsa_account_state *astate;
558
559 struct lsa_policy_state *state;
560 struct dcesrv_handle *h, *ah;
561
562 ZERO_STRUCTP(r->out.acct_handle);
563
564 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
565
566 state = h->data;
567
568 astate = talloc(dce_call->conn, struct lsa_account_state);
569 if (astate == NULL) {
570 return NT_STATUS_NO_MEMORY;
571 }
572
573 astate->account_sid = dom_sid_dup(astate, r->in.sid);
574 if (astate->account_sid == NULL) {
575 talloc_free(astate);
576 return NT_STATUS_NO_MEMORY;
577 }
578
579 astate->policy = talloc_reference(astate, state);
580 astate->access_mask = r->in.access_mask;
581
582 ah = dcesrv_handle_new(dce_call->context, LSA_HANDLE_ACCOUNT);
583 if (!ah) {
584 talloc_free(astate);
585 return NT_STATUS_NO_MEMORY;
586 }
587
588 ah->data = talloc_steal(ah, astate);
589
590 *r->out.acct_handle = ah->wire_handle;
591
592 return NT_STATUS_OK;
593 }
594
595
596 /*
597 lsa_EnumAccounts
598 */
599 static NTSTATUS dcesrv_lsa_EnumAccounts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
600 struct lsa_EnumAccounts *r)
601 {
602 struct dcesrv_handle *h;
603 struct lsa_policy_state *state;
604 int ret, i;
605 struct ldb_message **res;
606 const char * const attrs[] = { "objectSid", NULL};
607 uint32_t count;
608
609 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
610
611 state = h->data;
612
613 /* NOTE: This call must only return accounts that have at least
614 one privilege set
615 */
616 ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs,
617 "(&(objectSid=*)(privilege=*))");
618 if (ret < 0) {
619 return NT_STATUS_NO_SUCH_USER;
620 }
621
622 if (*r->in.resume_handle >= ret) {
623 return NT_STATUS_NO_MORE_ENTRIES;
624 }
625
626 count = ret - *r->in.resume_handle;
627 if (count > r->in.num_entries) {
628 count = r->in.num_entries;
629 }
630
631 if (count == 0) {
632 return NT_STATUS_NO_MORE_ENTRIES;
633 }
634
635 r->out.sids->sids = talloc_array(r->out.sids, struct lsa_SidPtr, count);
636 if (r->out.sids->sids == NULL) {
637 return NT_STATUS_NO_MEMORY;
638 }
639
640 for (i=0;i<count;i++) {
641 r->out.sids->sids[i].sid =
642 samdb_result_dom_sid(r->out.sids->sids,
643 res[i + *r->in.resume_handle],
644 "objectSid");
645 NT_STATUS_HAVE_NO_MEMORY(r->out.sids->sids[i].sid);
646 }
647
648 r->out.sids->num_sids = count;
649 *r->out.resume_handle = count + *r->in.resume_handle;
650
651 return NT_STATUS_OK;
652
653 }
654
655
656 /*
657 lsa_CreateTrustedDomainEx2
658 */
659 static NTSTATUS dcesrv_lsa_CreateTrustedDomain_base(struct dcesrv_call_state *dce_call,
660 TALLOC_CTX *mem_ctx,
661 struct lsa_CreateTrustedDomainEx2 *r,
662 int op)
663 {
664 struct dcesrv_handle *policy_handle;
665 struct lsa_policy_state *policy_state;
666 struct lsa_trusted_domain_state *trusted_domain_state;
667 struct dcesrv_handle *handle;
668 struct ldb_message **msgs, *msg, *msg_user;
669 const char *attrs[] = {
670 NULL
671 };
672 const char *netbios_name;
673 const char *dns_name;
674 const char *name;
675 DATA_BLOB session_key = data_blob(NULL, 0);
676 DATA_BLOB trustAuthIncoming, trustAuthOutgoing, auth_blob;
677 struct trustDomainPasswords auth_struct;
678 int ret;
679 NTSTATUS nt_status;
680 enum ndr_err_code ndr_err;
681
682 DCESRV_PULL_HANDLE(policy_handle, r->in.policy_handle, LSA_HANDLE_POLICY);
683 ZERO_STRUCTP(r->out.trustdom_handle);
684
685 policy_state = policy_handle->data;
686
687 nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
688 if (!NT_STATUS_IS_OK(nt_status)) {
689 return nt_status;
690 }
691
692 netbios_name = r->in.info->netbios_name.string;
693 if (!netbios_name) {
694 return NT_STATUS_INVALID_PARAMETER;
695 }
696
697 dns_name = r->in.info->domain_name.string;
698
699 trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
700 if (!trusted_domain_state) {
701 return NT_STATUS_NO_MEMORY;
702 }
703 trusted_domain_state->policy = policy_state;
704
705 if (strcasecmp(netbios_name, "BUILTIN") == 0
706 || (dns_name && strcasecmp(dns_name, "BUILTIN") == 0)
707 || (dom_sid_in_domain(policy_state->builtin_sid, r->in.info->sid))) {
708 return NT_STATUS_INVALID_PARAMETER;;
709 }
710
711 if (strcasecmp(netbios_name, policy_state->domain_name) == 0
712 || strcasecmp(netbios_name, policy_state->domain_dns) == 0
713 || (dns_name && strcasecmp(dns_name, policy_state->domain_dns) == 0)
714 || (dns_name && strcasecmp(dns_name, policy_state->domain_name) == 0)
715 || (dom_sid_equal(policy_state->domain_sid, r->in.info->sid))) {
716 return NT_STATUS_CURRENT_DOMAIN_NOT_ALLOWED;
717 }
718
719 /* While this is a REF pointer, some of the functions that wrap this don't provide this */
720 if (op == NDR_LSA_CREATETRUSTEDDOMAIN) {
721 /* No secrets are created at this time, for this function */
722 auth_struct.outgoing.count = 0;
723 auth_struct.incoming.count = 0;
724 } else {
725 auth_blob = data_blob_const(r->in.auth_info->auth_blob.data, r->in.auth_info->auth_blob.size);
726 arcfour_crypt_blob(auth_blob.data, auth_blob.length, &session_key);
727 ndr_err = ndr_pull_struct_blob(&auth_blob, mem_ctx,
728 lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
729 &auth_struct,
730 (ndr_pull_flags_fn_t)ndr_pull_trustDomainPasswords);
731 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
732 return NT_STATUS_INVALID_PARAMETER;
733 }
734
735 if (op == NDR_LSA_CREATETRUSTEDDOMAINEX) {
736 if (auth_struct.incoming.count > 1) {
737 return NT_STATUS_INVALID_PARAMETER;
738 }
739 }
740 }
741
742 if (auth_struct.incoming.count) {
743 int i;
744 struct trustAuthInOutBlob incoming;
745
746 incoming.count = auth_struct.incoming.count;
747 incoming.current = talloc(mem_ctx, struct AuthenticationInformationArray);
748 if (!incoming.current) {
749 return NT_STATUS_NO_MEMORY;
750 }
751
752 incoming.current->array = *auth_struct.incoming.current;
753 if (!incoming.current->array) {
754 return NT_STATUS_NO_MEMORY;
755 }
756
757 incoming.previous = talloc(mem_ctx, struct AuthenticationInformationArray);
758 if (!incoming.previous) {
759 return NT_STATUS_NO_MEMORY;
760 }
761 incoming.previous->array = talloc_array(mem_ctx, struct AuthenticationInformation, incoming.count);
762 if (!incoming.previous->array) {
763 return NT_STATUS_NO_MEMORY;
764 }
765
766 for (i = 0; i < incoming.count; i++) {
767 incoming.previous->array[i].LastUpdateTime = 0;
768 incoming.previous->array[i].AuthType = 0;
769 }
770 ndr_err = ndr_push_struct_blob(&trustAuthIncoming, mem_ctx,
771 lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
772 &incoming,
773 (ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
774 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
775 return NT_STATUS_INVALID_PARAMETER;
776 }
777 } else {
778 trustAuthIncoming = data_blob(NULL, 0);
779 }
780
781 if (auth_struct.outgoing.count) {
782 int i;
783 struct trustAuthInOutBlob outgoing;
784
785 outgoing.count = auth_struct.outgoing.count;
786 outgoing.current = talloc(mem_ctx, struct AuthenticationInformationArray);
787 if (!outgoing.current) {
788 return NT_STATUS_NO_MEMORY;
789 }
790
791 outgoing.current->array = *auth_struct.outgoing.current;
792 if (!outgoing.current->array) {
793 return NT_STATUS_NO_MEMORY;
794 }
795
796 outgoing.previous = talloc(mem_ctx, struct AuthenticationInformationArray);
797 if (!outgoing.previous) {
798 return NT_STATUS_NO_MEMORY;
799 }
800 outgoing.previous->array = talloc_array(mem_ctx, struct AuthenticationInformation, outgoing.count);
801 if (!outgoing.previous->array) {
802 return NT_STATUS_NO_MEMORY;
803 }
804
805 for (i = 0; i < outgoing.count; i++) {
806 outgoing.previous->array[i].LastUpdateTime = 0;
807 outgoing.previous->array[i].AuthType = 0;
808 }
809 ndr_err = ndr_push_struct_blob(&trustAuthOutgoing, mem_ctx,
810 lp_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
811 &outgoing,
812 (ndr_push_flags_fn_t)ndr_push_trustAuthInOutBlob);
813 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
814 return NT_STATUS_INVALID_PARAMETER;
815 }
816 } else {
817 trustAuthOutgoing = data_blob(NULL, 0);
818 }
819
820 ret = ldb_transaction_start(policy_state->sam_ldb);
821 if (ret != LDB_SUCCESS) {
822 return NT_STATUS_INTERNAL_DB_CORRUPTION;
823 }
824
825 if (dns_name) {
826 char *dns_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
827 char *netbios_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
828 /* search for the trusted_domain record */
829 ret = gendb_search(policy_state->sam_ldb,
830 mem_ctx, policy_state->system_dn, &msgs, attrs,
831 "(&(|(flatname=%s)(cn=%s)(trustPartner=%s)(flatname=%s)(cn=%s)(trustPartner=%s))(objectclass=trustedDomain))",
832 dns_encoded, dns_encoded, dns_encoded, netbios_encoded, netbios_encoded, netbios_encoded);
833 if (ret > 0) {
834 ldb_transaction_cancel(policy_state->sam_ldb);
835 return NT_STATUS_OBJECT_NAME_COLLISION;
836 }
837 } else {
838 char *netbios_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
839 /* search for the trusted_domain record */
840 ret = gendb_search(policy_state->sam_ldb,
841 mem_ctx, policy_state->system_dn, &msgs, attrs,
842 "(&(|(flatname=%s)(cn=%s)(trustPartner=%s))(objectclass=trustedDomain))",
843 netbios_encoded, netbios_encoded, netbios_encoded);
844 if (ret > 0) {
845 ldb_transaction_cancel(policy_state->sam_ldb);
846 return NT_STATUS_OBJECT_NAME_COLLISION;
847 }
848 }
849
850 if (ret < 0 ) {
851 ldb_transaction_cancel(policy_state->sam_ldb);
852 return NT_STATUS_INTERNAL_DB_CORRUPTION;
853 }
854
855 name = dns_name ? dns_name : netbios_name;
856
857 msg = ldb_msg_new(mem_ctx);
858 if (msg == NULL) {
859 return NT_STATUS_NO_MEMORY;
860 }
861
862 msg->dn = ldb_dn_copy(mem_ctx, policy_state->system_dn);
863 if ( ! ldb_dn_add_child_fmt(msg->dn, "cn=%s", name)) {
864 ldb_transaction_cancel(policy_state->sam_ldb);
865 return NT_STATUS_NO_MEMORY;
866 }
867
868 samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "flatname", netbios_name);
869
870 if (r->in.info->sid) {
871 const char *sid_string = dom_sid_string(mem_ctx, r->in.info->sid);
872 if (!sid_string) {
873 ldb_transaction_cancel(policy_state->sam_ldb);
874 return NT_STATUS_NO_MEMORY;
875 }
876
877 samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "securityIdentifier", sid_string);
878 }
879
880 samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "objectClass", "trustedDomain");
881
882 samdb_msg_add_int(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "trustType", r->in.info->trust_type);
883
884 samdb_msg_add_int(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "trustAttributes", r->in.info->trust_attributes);
885
886 samdb_msg_add_int(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "trustDirection", r->in.info->trust_direction);
887
888 if (dns_name) {
889 samdb_msg_add_string(trusted_domain_state->policy->sam_ldb, mem_ctx, msg, "trustPartner", dns_name);
890 }
891
892 if (trustAuthIncoming.data) {
893 ret = ldb_msg_add_value(msg, "trustAuthIncoming", &trustAuthIncoming, NULL);
894 if (ret != LDB_SUCCESS) {
895 ldb_transaction_cancel(policy_state->sam_ldb);
896 return NT_STATUS_NO_MEMORY;
897 }
898 }
899 if (trustAuthOutgoing.data) {
900 ret = ldb_msg_add_value(msg, "trustAuthOutgoing", &trustAuthOutgoing, NULL);
901 if (ret != LDB_SUCCESS) {
902 ldb_transaction_cancel(policy_state->sam_ldb);
903 return NT_STATUS_NO_MEMORY;
904 }
905 }
906
907 trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msg->dn);
908
909 /* create the trusted_domain */
910 ret = ldb_add(trusted_domain_state->policy->sam_ldb, msg);
911 switch (ret) {
912 case LDB_SUCCESS:
913 break;
914 case LDB_ERR_ENTRY_ALREADY_EXISTS:
915 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
916 DEBUG(0,("Failed to create trusted domain record %s: %s\n",
917 ldb_dn_get_linearized(msg->dn),
918 ldb_errstring(trusted_domain_state->policy->sam_ldb)));
919 return NT_STATUS_DOMAIN_EXISTS;
920 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
921 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
922 DEBUG(0,("Failed to create trusted domain record %s: %s\n",
923 ldb_dn_get_linearized(msg->dn),
924 ldb_errstring(trusted_domain_state->policy->sam_ldb)));
925 return NT_STATUS_ACCESS_DENIED;
926 default:
927 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
928 DEBUG(0,("Failed to create user record %s: %s\n",
929 ldb_dn_get_linearized(msg->dn),
930 ldb_errstring(trusted_domain_state->policy->sam_ldb)));
931 return NT_STATUS_INTERNAL_DB_CORRUPTION;
932 }
933
934 if (r->in.info->trust_direction & LSA_TRUST_DIRECTION_INBOUND) {
935 msg_user = ldb_msg_new(mem_ctx);
936 if (msg_user == NULL) {
937 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
938 return NT_STATUS_NO_MEMORY;
939 }
940
941 /* Inbound trusts must also create a cn=users object to match */
942
943 trusted_domain_state->trusted_domain_user_dn = msg_user->dn
944 = ldb_dn_copy(trusted_domain_state, policy_state->domain_dn);
945 if ( ! ldb_dn_add_child_fmt(msg_user->dn, "cn=users")) {
946 ldb_transaction_cancel(policy_state->sam_ldb);
947 return NT_STATUS_NO_MEMORY;
948 }
949
950 if ( ! ldb_dn_add_child_fmt(msg_user->dn, "cn=%s", netbios_name)) {
951 ldb_transaction_cancel(policy_state->sam_ldb);
952 return NT_STATUS_NO_MEMORY;
953 }
954
955 ldb_msg_add_string(msg_user, "objectClass", "user");
956
957 ldb_msg_add_steal_string(msg_user, "samAccountName",
958 talloc_asprintf(mem_ctx, "%s$", netbios_name));
959
960 if (samdb_msg_add_uint(trusted_domain_state->policy->sam_ldb, mem_ctx, msg_user,
961 "userAccountControl",
962 UF_INTERDOMAIN_TRUST_ACCOUNT) != 0) {
963 ldb_transaction_cancel(policy_state->sam_ldb);
964 return NT_STATUS_NO_MEMORY;
965 }
966
967 if (auth_struct.incoming.count) {
968 int i;
969 for (i=0; i < auth_struct.incoming.count; i++ ) {
970 if (auth_struct.incoming.current[i]->AuthType == TRUST_AUTH_TYPE_NT4OWF) {
971 samdb_msg_add_hash(trusted_domain_state->policy->sam_ldb,
972 mem_ctx, msg_user, "unicodePwd",
973 &auth_struct.incoming.current[i]->AuthInfo.nt4owf.password);
974 } else if (auth_struct.incoming.current[i]->AuthType == TRUST_AUTH_TYPE_CLEAR) {
975 DATA_BLOB new_password = data_blob_const(auth_struct.incoming.current[i]->AuthInfo.clear.password,
976 auth_struct.incoming.current[i]->AuthInfo.clear.size);
977 ret = ldb_msg_add_value(msg_user, "clearTextPassword", &new_password, NULL);
978 if (ret != LDB_SUCCESS) {
979 ldb_transaction_cancel(policy_state->sam_ldb);
980 return NT_STATUS_NO_MEMORY;
981 }
982 }
983 }
984 }
985
986 /* create the cn=users trusted_domain account */
987 ret = ldb_add(trusted_domain_state->policy->sam_ldb, msg_user);
988 switch (ret) {
989 case LDB_SUCCESS:
990 break;
991 case LDB_ERR_ENTRY_ALREADY_EXISTS:
992 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
993 DEBUG(0,("Failed to create trusted domain record %s: %s\n",
994 ldb_dn_get_linearized(msg_user->dn),
995 ldb_errstring(trusted_domain_state->policy->sam_ldb)));
996 return NT_STATUS_DOMAIN_EXISTS;
997 case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
998 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
999 DEBUG(0,("Failed to create trusted domain record %s: %s\n",
1000 ldb_dn_get_linearized(msg_user->dn),
1001 ldb_errstring(trusted_domain_state->policy->sam_ldb)));
1002 return NT_STATUS_ACCESS_DENIED;
1003 default:
1004 ldb_transaction_cancel(trusted_domain_state->policy->sam_ldb);
1005 DEBUG(0,("Failed to create user record %s: %s\n",
1006 ldb_dn_get_linearized(msg_user->dn),
1007 ldb_errstring(trusted_domain_state->policy->sam_ldb)));
1008 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1009 }
1010 }
1011
1012 ret = ldb_transaction_commit(policy_state->sam_ldb);
1013 if (ret != LDB_SUCCESS) {
1014 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1015 }
1016
1017 handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
1018 if (!handle) {
1019 return NT_STATUS_NO_MEMORY;
1020 }
1021
1022 handle->data = talloc_steal(handle, trusted_domain_state);
1023
1024 trusted_domain_state->access_mask = r->in.access_mask;
1025 trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
1026
1027 *r->out.trustdom_handle = handle->wire_handle;
1028
1029 return NT_STATUS_OK;
1030 }
1031
1032 /*
1033 lsa_CreateTrustedDomainEx2
1034 */
1035 static NTSTATUS dcesrv_lsa_CreateTrustedDomainEx2(struct dcesrv_call_state *dce_call,
1036 TALLOC_CTX *mem_ctx,
1037 struct lsa_CreateTrustedDomainEx2 *r)
1038 {
1039 return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, r, NDR_LSA_CREATETRUSTEDDOMAINEX2);
1040 }
1041 /*
1042 lsa_CreateTrustedDomainEx
1043 */
1044 static NTSTATUS dcesrv_lsa_CreateTrustedDomainEx(struct dcesrv_call_state *dce_call,
1045 TALLOC_CTX *mem_ctx,
1046 struct lsa_CreateTrustedDomainEx *r)
1047 {
1048 struct lsa_CreateTrustedDomainEx2 r2;
1049
1050 r2.in.policy_handle = r->in.policy_handle;
1051 r2.in.info = r->in.info;
1052 r2.in.auth_info = r->in.auth_info;
1053 r2.out.trustdom_handle = r->out.trustdom_handle;
1054 return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, &r2, NDR_LSA_CREATETRUSTEDDOMAINEX);
1055 }
1056
1057 /*
1058 lsa_CreateTrustedDomain
1059 */
1060 static NTSTATUS dcesrv_lsa_CreateTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1061 struct lsa_CreateTrustedDomain *r)
1062 {
1063 struct lsa_CreateTrustedDomainEx2 r2;
1064
1065 r2.in.policy_handle = r->in.policy_handle;
1066 r2.in.info = talloc(mem_ctx, struct lsa_TrustDomainInfoInfoEx);
1067 if (!r2.in.info) {
1068 return NT_STATUS_NO_MEMORY;
1069 }
1070
1071 r2.in.info->domain_name.string = NULL;
1072 r2.in.info->netbios_name = r->in.info->name;
1073 r2.in.info->sid = r->in.info->sid;
1074 r2.in.info->trust_direction = LSA_TRUST_DIRECTION_OUTBOUND;
1075 r2.in.info->trust_type = LSA_TRUST_TYPE_DOWNLEVEL;
1076 r2.in.info->trust_attributes = 0;
1077
1078 r2.in.access_mask = r->in.access_mask;
1079 r2.out.trustdom_handle = r->out.trustdom_handle;
1080
1081 return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, &r2, NDR_LSA_CREATETRUSTEDDOMAIN);
1082
1083 }
1084
1085 /*
1086 lsa_OpenTrustedDomain
1087 */
1088 static NTSTATUS dcesrv_lsa_OpenTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1089 struct lsa_OpenTrustedDomain *r)
1090 {
1091 struct dcesrv_handle *policy_handle;
1092
1093 struct lsa_policy_state *policy_state;
1094 struct lsa_trusted_domain_state *trusted_domain_state;
1095 struct dcesrv_handle *handle;
1096 struct ldb_message **msgs;
1097 const char *attrs[] = {
1098 "trustDirection",
1099 "flatname",
1100 NULL
1101 };
1102
1103 const char *sid_string;
1104 int ret;
1105
1106 DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
1107 ZERO_STRUCTP(r->out.trustdom_handle);
1108 policy_state = policy_handle->data;
1109
1110 trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
1111 if (!trusted_domain_state) {
1112 return NT_STATUS_NO_MEMORY;
1113 }
1114 trusted_domain_state->policy = policy_state;
1115
1116 sid_string = dom_sid_string(mem_ctx, r->in.sid);
1117 if (!sid_string) {
1118 return NT_STATUS_NO_MEMORY;
1119 }
1120
1121 /* search for the trusted_domain record */
1122 ret = gendb_search(trusted_domain_state->policy->sam_ldb,
1123 mem_ctx, policy_state->system_dn, &msgs, attrs,
1124 "(&(securityIdentifier=%s)(objectclass=trustedDomain))",
1125 sid_string);
1126 if (ret == 0) {
1127 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1128 }
1129
1130 if (ret != 1) {
1131 DEBUG(0,("Found %d records matching DN %s\n", ret,
1132 ldb_dn_get_linearized(policy_state->system_dn)));
1133 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1134 }
1135
1136 trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msgs[0]->dn);
1137
1138 trusted_domain_state->trusted_domain_user_dn = NULL;
1139
1140 if (ldb_msg_find_attr_as_int(msgs[0], "trustDirection", 0) & LSA_TRUST_DIRECTION_INBOUND) {
1141 const char *flatname = ldb_binary_encode_string(mem_ctx, ldb_msg_find_attr_as_string(msgs[0], "flatname", NULL));
1142 /* search for the trusted_domain record */
1143 ret = gendb_search(trusted_domain_state->policy->sam_ldb,
1144 mem_ctx, policy_state->domain_dn, &msgs, attrs,
1145 "(&(samaccountname=%s$)(objectclass=user)(userAccountControl:1.2.840.113556.1.4.803:=%d))",
1146 flatname, UF_INTERDOMAIN_TRUST_ACCOUNT);
1147 if (ret == 1) {
1148 trusted_domain_state->trusted_domain_user_dn = talloc_steal(trusted_domain_state, msgs[0]->dn);
1149 }
1150 }
1151 handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
1152 if (!handle) {
1153 return NT_STATUS_NO_MEMORY;
1154 }
1155
1156 handle->data = talloc_steal(handle, trusted_domain_state);
1157
1158 trusted_domain_state->access_mask = r->in.access_mask;
1159 trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
1160
1161 *r->out.trustdom_handle = handle->wire_handle;
1162
1163 return NT_STATUS_OK;
1164 }
1165
1166
1167 /*
1168 lsa_OpenTrustedDomainByName
1169 */
1170 static NTSTATUS dcesrv_lsa_OpenTrustedDomainByName(struct dcesrv_call_state *dce_call,
1171 TALLOC_CTX *mem_ctx,
1172 struct lsa_OpenTrustedDomainByName *r)
1173 {
1174 struct dcesrv_handle *policy_handle;
1175
1176 struct lsa_policy_state *policy_state;
1177 struct lsa_trusted_domain_state *trusted_domain_state;
1178 struct dcesrv_handle *handle;
1179 struct ldb_message **msgs;
1180 const char *attrs[] = {
1181 NULL
1182 };
1183
1184 int ret;
1185
1186 DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
1187 ZERO_STRUCTP(r->out.trustdom_handle);
1188 policy_state = policy_handle->data;
1189
1190 if (!r->in.name.string) {
1191 return NT_STATUS_INVALID_PARAMETER;
1192 }
1193
1194 trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
1195 if (!trusted_domain_state) {
1196 return NT_STATUS_NO_MEMORY;
1197 }
1198 trusted_domain_state->policy = policy_state;
1199
1200 /* search for the trusted_domain record */
1201 ret = gendb_search(trusted_domain_state->policy->sam_ldb,
1202 mem_ctx, policy_state->system_dn, &msgs, attrs,
1203 "(&(flatname=%s)(objectclass=trustedDomain))",
1204 ldb_binary_encode_string(mem_ctx, r->in.name.string));
1205 if (ret == 0) {
1206 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1207 }
1208
1209 if (ret != 1) {
1210 DEBUG(0,("Found %d records matching DN %s\n", ret,
1211 ldb_dn_get_linearized(policy_state->system_dn)));
1212 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1213 }
1214
1215 trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msgs[0]->dn);
1216
1217 handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
1218 if (!handle) {
1219 return NT_STATUS_NO_MEMORY;
1220 }
1221
1222 handle->data = talloc_steal(handle, trusted_domain_state);
1223
1224 trusted_domain_state->access_mask = r->in.access_mask;
1225 trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
1226
1227 *r->out.trustdom_handle = handle->wire_handle;
1228
1229 return NT_STATUS_OK;
1230 }
1231
1232
1233
1234 /*
1235 lsa_SetTrustedDomainInfo
1236 */
1237 static NTSTATUS dcesrv_lsa_SetTrustedDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1238 struct lsa_SetTrustedDomainInfo *r)
1239 {
1240 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1241 }
1242
1243
1244
1245 /*
1246 lsa_SetInfomrationTrustedDomain
1247 */
1248 static NTSTATUS dcesrv_lsa_SetInformationTrustedDomain(struct dcesrv_call_state *dce_call,
1249 TALLOC_CTX *mem_ctx,
1250 struct lsa_SetInformationTrustedDomain *r)
1251 {
1252 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1253 }
1254
1255
1256 /*
1257 lsa_DeleteTrustedDomain
1258 */
1259 static NTSTATUS dcesrv_lsa_DeleteTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1260 struct lsa_DeleteTrustedDomain *r)
1261 {
1262 NTSTATUS status;
1263 struct lsa_OpenTrustedDomain opn;
1264 struct lsa_DeleteObject del;
1265 struct dcesrv_handle *h;
1266
1267 opn.in.handle = r->in.handle;
1268 opn.in.sid = r->in.dom_sid;
1269 opn.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1270 opn.out.trustdom_handle = talloc(mem_ctx, struct policy_handle);
1271 if (!opn.out.trustdom_handle) {
1272 return NT_STATUS_NO_MEMORY;
1273 }
1274 status = dcesrv_lsa_OpenTrustedDomain(dce_call, mem_ctx, &opn);
1275 if (!NT_STATUS_IS_OK(status)) {
1276 return status;
1277 }
1278
1279 DCESRV_PULL_HANDLE(h, opn.out.trustdom_handle, DCESRV_HANDLE_ANY);
1280 talloc_steal(mem_ctx, h);
1281
1282 del.in.handle = opn.out.trustdom_handle;
1283 del.out.handle = opn.out.trustdom_handle;
1284 status = dcesrv_lsa_DeleteObject(dce_call, mem_ctx, &del);
1285 if (!NT_STATUS_IS_OK(status)) {
1286 return status;
1287 }
1288 return NT_STATUS_OK;
1289 }
1290
1291 static NTSTATUS fill_trust_domain_ex(TALLOC_CTX *mem_ctx,
1292 struct ldb_message *msg,
1293 struct lsa_TrustDomainInfoInfoEx *info_ex)
1294 {
1295 info_ex->domain_name.string
1296 = ldb_msg_find_attr_as_string(msg, "trustPartner", NULL);
1297 info_ex->netbios_name.string
1298 = ldb_msg_find_attr_as_string(msg, "flatname", NULL);
1299 info_ex->sid
1300 = samdb_result_dom_sid(mem_ctx, msg, "securityIdentifier");
1301 info_ex->trust_direction
1302 = ldb_msg_find_attr_as_int(msg, "trustDirection", 0);
1303 info_ex->trust_type
1304 = ldb_msg_find_attr_as_int(msg, "trustType", 0);
1305 info_ex->trust_attributes
1306 = ldb_msg_find_attr_as_int(msg, "trustAttributes", 0);
1307 return NT_STATUS_OK;
1308 }
1309
1310 /*
1311 lsa_QueryTrustedDomainInfo
1312 */
1313 static NTSTATUS dcesrv_lsa_QueryTrustedDomainInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1314 struct lsa_QueryTrustedDomainInfo *r)
1315 {
1316 union lsa_TrustedDomainInfo *info = NULL;
1317 struct dcesrv_handle *h;
1318 struct lsa_trusted_domain_state *trusted_domain_state;
1319 struct ldb_message *msg;
1320 int ret;
1321 struct ldb_message **res;
1322 const char *attrs[] = {
1323 "flatname",
1324 "trustPartner",
1325 "securityIdentifier",
1326 "trustDirection",
1327 "trustType",
1328 "trustAttributes",
1329 "msDs-supportedEncryptionTypes",
1330 NULL
1331 };
1332
1333 DCESRV_PULL_HANDLE(h, r->in.trustdom_handle, LSA_HANDLE_TRUSTED_DOMAIN);
1334
1335 trusted_domain_state = talloc_get_type(h->data, struct lsa_trusted_domain_state);
1336
1337 /* pull all the user attributes */
1338 ret = gendb_search_dn(trusted_domain_state->policy->sam_ldb, mem_ctx,
1339 trusted_domain_state->trusted_domain_dn, &res, attrs);
1340 if (ret != 1) {
1341 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1342 }
1343 msg = res[0];
1344
1345 info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo);
1346 if (!info) {
1347 return NT_STATUS_NO_MEMORY;
1348 }
1349 *r->out.info = info;
1350
1351 switch (r->in.level) {
1352 case LSA_TRUSTED_DOMAIN_INFO_NAME:
1353 info->name.netbios_name.string
1354 = samdb_result_string(msg, "flatname", NULL);
1355 break;
1356 case LSA_TRUSTED_DOMAIN_INFO_POSIX_OFFSET:
1357 info->posix_offset.posix_offset
1358 = samdb_result_uint(msg, "posixOffset", 0);
1359 break;
1360 #if 0 /* Win2k3 doesn't implement this */
1361 case LSA_TRUSTED_DOMAIN_INFO_BASIC:
1362 r->out.info->info_basic.netbios_name.string
1363 = ldb_msg_find_attr_as_string(msg, "flatname", NULL);
1364 r->out.info->info_basic.sid
1365 = samdb_result_dom_sid(mem_ctx, msg, "securityIdentifier");
1366 break;
1367 #endif
1368 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX:
1369 return fill_trust_domain_ex(mem_ctx, msg, &info->info_ex);
1370
1371 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO:
1372 ZERO_STRUCT(info->full_info);
1373 return fill_trust_domain_ex(mem_ctx, msg, &info->full_info.info_ex);
1374
1375 case LSA_TRUSTED_DOMAIN_INFO_FULL_INFO_2_INTERNAL:
1376 ZERO_STRUCT(info->full_info2_internal);
1377 info->full_info2_internal.posix_offset.posix_offset
1378 = samdb_result_uint(msg, "posixOffset", 0);
1379 return fill_trust_domain_ex(mem_ctx, msg, &info->full_info2_internal.info.info_ex);
1380
1381 case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRTYPION_TYPES:
1382 info->enc_types.enc_types
1383 = samdb_result_uint(msg, "msDs-supportedEncryptionTypes", KERB_ENCTYPE_RC4_HMAC_MD5);
1384 break;
1385
1386 case LSA_TRUSTED_DOMAIN_INFO_CONTROLLERS:
1387 case LSA_TRUSTED_DOMAIN_INFO_INFO_EX2_INTERNAL:
1388 /* oops, we don't want to return the info after all */
1389 talloc_free(info);
1390 *r->out.info = NULL;
1391 return NT_STATUS_INVALID_PARAMETER;
1392 default:
1393 /* oops, we don't want to return the info after all */
1394 talloc_free(info);
1395 *r->out.info = NULL;
1396 return NT_STATUS_INVALID_INFO_CLASS;
1397 }
1398
1399 return NT_STATUS_OK;
1400 }
1401
1402
1403 /*
1404 lsa_QueryTrustedDomainInfoBySid
1405 */
1406 static NTSTATUS dcesrv_lsa_QueryTrustedDomainInfoBySid(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1407 struct lsa_QueryTrustedDomainInfoBySid *r)
1408 {
1409 NTSTATUS status;
1410 struct lsa_OpenTrustedDomain opn;
1411 struct lsa_QueryTrustedDomainInfo query;
1412 struct dcesrv_handle *h;
1413
1414 opn.in.handle = r->in.handle;
1415 opn.in.sid = r->in.dom_sid;
1416 opn.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1417 opn.out.trustdom_handle = talloc(mem_ctx, struct policy_handle);
1418 if (!opn.out.trustdom_handle) {
1419 return NT_STATUS_NO_MEMORY;
1420 }
1421 status = dcesrv_lsa_OpenTrustedDomain(dce_call, mem_ctx, &opn);
1422 if (!NT_STATUS_IS_OK(status)) {
1423 return status;
1424 }
1425
1426 /* Ensure this handle goes away at the end of this call */
1427 DCESRV_PULL_HANDLE(h, opn.out.trustdom_handle, DCESRV_HANDLE_ANY);
1428 talloc_steal(mem_ctx, h);
1429
1430 query.in.trustdom_handle = opn.out.trustdom_handle;
1431 query.in.level = r->in.level;
1432 query.out.info = r->out.info;
1433 status = dcesrv_lsa_QueryTrustedDomainInfo(dce_call, mem_ctx, &query);
1434 if (!NT_STATUS_IS_OK(status)) {
1435 return status;
1436 }
1437
1438 return NT_STATUS_OK;
1439 }
1440
1441 /*
1442 lsa_SetTrustedDomainInfoByName
1443 */
1444 static NTSTATUS dcesrv_lsa_SetTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
1445 TALLOC_CTX *mem_ctx,
1446 struct lsa_SetTrustedDomainInfoByName *r)
1447 {
1448 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
1449 }
1450
1451 /*
1452 lsa_QueryTrustedDomainInfoByName
1453 */
1454 static NTSTATUS dcesrv_lsa_QueryTrustedDomainInfoByName(struct dcesrv_call_state *dce_call,
1455 TALLOC_CTX *mem_ctx,
1456 struct lsa_QueryTrustedDomainInfoByName *r)
1457 {
1458 NTSTATUS status;
1459 struct lsa_OpenTrustedDomainByName opn;
1460 struct lsa_QueryTrustedDomainInfo query;
1461 struct dcesrv_handle *h;
1462
1463 opn.in.handle = r->in.handle;
1464 opn.in.name = *r->in.trusted_domain;
1465 opn.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
1466 opn.out.trustdom_handle = talloc(mem_ctx, struct policy_handle);
1467 if (!opn.out.trustdom_handle) {
1468 return NT_STATUS_NO_MEMORY;
1469 }
1470 status = dcesrv_lsa_OpenTrustedDomainByName(dce_call, mem_ctx, &opn);
1471 if (!NT_STATUS_IS_OK(status)) {
1472 return status;
1473 }
1474
1475 /* Ensure this handle goes away at the end of this call */
1476 DCESRV_PULL_HANDLE(h, opn.out.trustdom_handle, DCESRV_HANDLE_ANY);
1477 talloc_steal(mem_ctx, h);
1478
1479 query.in.trustdom_handle = opn.out.trustdom_handle;
1480 query.in.level = r->in.level;
1481 query.out.info = r->out.info;
1482 status = dcesrv_lsa_QueryTrustedDomainInfo(dce_call, mem_ctx, &query);
1483 if (!NT_STATUS_IS_OK(status)) {
1484 return status;
1485 }
1486
1487 return NT_STATUS_OK;
1488 }
1489
1490 /*
1491 lsa_CloseTrustedDomainEx
1492 */
1493 static NTSTATUS dcesrv_lsa_CloseTrustedDomainEx(struct dcesrv_call_state *dce_call,
1494 TALLOC_CTX *mem_ctx,
1495 struct lsa_CloseTrustedDomainEx *r)
1496 {
1497 /* The result of a bad hair day from an IDL programmer? Not
1498 * implmented in Win2k3. You should always just lsa_Close
1499 * anyway. */
1500 return NT_STATUS_NOT_IMPLEMENTED;
1501 }
1502
1503
1504 /*
1505 comparison function for sorting lsa_DomainInformation array
1506 */
1507 static int compare_DomainInfo(struct lsa_DomainInfo *e1, struct lsa_DomainInfo *e2)
1508 {
1509 return strcasecmp_m(e1->name.string, e2->name.string);
1510 }
1511
1512 /*
1513 lsa_EnumTrustDom
1514 */
1515 static NTSTATUS dcesrv_lsa_EnumTrustDom(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1516 struct lsa_EnumTrustDom *r)
1517 {
1518 struct dcesrv_handle *policy_handle;
1519 struct lsa_DomainInfo *entries;
1520 struct lsa_policy_state *policy_state;
1521 struct ldb_message **domains;
1522 const char *attrs[] = {
1523 "flatname",
1524 "securityIdentifier",
1525 NULL
1526 };
1527
1528
1529 int count, i;
1530
1531 *r->out.resume_handle = 0;
1532
1533 r->out.domains->domains = NULL;
1534 r->out.domains->count = 0;
1535
1536 DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
1537
1538 policy_state = policy_handle->data;
1539
1540 /* search for all users in this domain. This could possibly be cached and
1541 resumed based on resume_key */
1542 count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
1543 "objectclass=trustedDomain");
1544 if (count == -1) {
1545 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1546 }
1547
1548 /* convert to lsa_TrustInformation format */
1549 entries = talloc_array(mem_ctx, struct lsa_DomainInfo, count);
1550 if (!entries) {
1551 return NT_STATUS_NO_MEMORY;
1552 }
1553 for (i=0;i<count;i++) {
1554 entries[i].sid = samdb_result_dom_sid(mem_ctx, domains[i], "securityIdentifier");
1555 entries[i].name.string = samdb_result_string(domains[i], "flatname", NULL);
1556 }
1557
1558 /* sort the results by name */
1559 qsort(entries, count, sizeof(*entries),
1560 (comparison_fn_t)compare_DomainInfo);
1561
1562 if (*r->in.resume_handle >= count) {
1563 *r->out.resume_handle = -1;
1564
1565 return NT_STATUS_NO_MORE_ENTRIES;
1566 }
1567
1568 /* return the rest, limit by max_size. Note that we
1569 use the w2k3 element size value of 60 */
1570 r->out.domains->count = count - *r->in.resume_handle;
1571 r->out.domains->count = MIN(r->out.domains->count,
1572 1+(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_MULTIPLIER));
1573
1574 r->out.domains->domains = entries + *r->in.resume_handle;
1575 r->out.domains->count = r->out.domains->count;
1576
1577 if (r->out.domains->count < count - *r->in.resume_handle) {
1578 *r->out.resume_handle = *r->in.resume_handle + r->out.domains->count;
1579 return STATUS_MORE_ENTRIES;
1580 }
1581
1582 return NT_STATUS_OK;
1583 }
1584
1585 /*
1586 comparison function for sorting lsa_DomainInformation array
1587 */
1588 static int compare_TrustDomainInfoInfoEx(struct lsa_TrustDomainInfoInfoEx *e1, struct lsa_TrustDomainInfoInfoEx *e2)
1589 {
1590 return strcasecmp_m(e1->netbios_name.string, e2->netbios_name.string);
1591 }
1592
1593 /*
1594 lsa_EnumTrustedDomainsEx
1595 */
1596 static NTSTATUS dcesrv_lsa_EnumTrustedDomainsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1597 struct lsa_EnumTrustedDomainsEx *r)
1598 {
1599 struct dcesrv_handle *policy_handle;
1600 struct lsa_TrustDomainInfoInfoEx *entries;
1601 struct lsa_policy_state *policy_state;
1602 struct ldb_message **domains;
1603 const char *attrs[] = {
1604 "flatname",
1605 "trustPartner",
1606 "securityIdentifier",
1607 "trustDirection",
1608 "trustType",
1609 "trustAttributes",
1610 NULL
1611 };
1612 NTSTATUS nt_status;
1613
1614 int count, i;
1615
1616 *r->out.resume_handle = 0;
1617
1618 r->out.domains->domains = NULL;
1619 r->out.domains->count = 0;
1620
1621 DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
1622
1623 policy_state = policy_handle->data;
1624
1625 /* search for all users in this domain. This could possibly be cached and
1626 resumed based on resume_key */
1627 count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
1628 "objectclass=trustedDomain");
1629 if (count == -1) {
1630 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1631 }
1632
1633 /* convert to lsa_DomainInformation format */
1634 entries = talloc_array(mem_ctx, struct lsa_TrustDomainInfoInfoEx, count);
1635 if (!entries) {
1636 return NT_STATUS_NO_MEMORY;
1637 }
1638 for (i=0;i<count;i++) {
1639 nt_status = fill_trust_domain_ex(mem_ctx, domains[i], &entries[i]);
1640 if (!NT_STATUS_IS_OK(nt_status)) {
1641 return nt_status;
1642 }
1643 }
1644
1645 /* sort the results by name */
1646 qsort(entries, count, sizeof(*entries),
1647 (comparison_fn_t)compare_TrustDomainInfoInfoEx);
1648
1649 if (*r->in.resume_handle >= count) {
1650 *r->out.resume_handle = -1;
1651
1652 return NT_STATUS_NO_MORE_ENTRIES;
1653 }
1654
1655 /* return the rest, limit by max_size. Note that we
1656 use the w2k3 element size value of 60 */
1657 r->out.domains->count = count - *r->in.resume_handle;
1658 r->out.domains->count = MIN(r->out.domains->count,
1659 1+(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_EX_MULTIPLIER));
1660
1661 r->out.domains->domains = entries + *r->in.resume_handle;
1662 r->out.domains->count = r->out.domains->count;
1663
1664 if (r->out.domains->count < count - *r->in.resume_handle) {
1665 *r->out.resume_handle = *r->in.resume_handle + r->out.domains->count;
1666 return STATUS_MORE_ENTRIES;
1667 }
1668
1669 return NT_STATUS_OK;
1670 }
1671
1672
1673 /*
1674 lsa_OpenAccount
1675 */
1676 static NTSTATUS dcesrv_lsa_OpenAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1677 struct lsa_OpenAccount *r)
1678 {
1679 struct dcesrv_handle *h, *ah;
1680 struct lsa_policy_state *state;
1681 struct lsa_account_state *astate;
1682
1683 ZERO_STRUCTP(r->out.acct_handle);
1684
1685 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
1686
1687 state = h->data;
1688
1689 astate = talloc(dce_call->conn, struct lsa_account_state);
1690 if (astate == NULL) {
1691 return NT_STATUS_NO_MEMORY;
1692 }
1693
1694 astate->account_sid = dom_sid_dup(astate, r->in.sid);
1695 if (astate->account_sid == NULL) {
1696 talloc_free(astate);
1697 return NT_STATUS_NO_MEMORY;
1698 }
1699
1700 astate->policy = talloc_reference(astate, state);
1701 astate->access_mask = r->in.access_mask;
1702
1703 ah = dcesrv_handle_new(dce_call->context, LSA_HANDLE_ACCOUNT);
1704 if (!ah) {
1705 talloc_free(astate);
1706 return NT_STATUS_NO_MEMORY;
1707 }
1708
1709 ah->data = talloc_steal(ah, astate);
1710
1711 *r->out.acct_handle = ah->wire_handle;
1712
1713 return NT_STATUS_OK;
1714 }
1715
1716
1717 /*
1718 lsa_EnumPrivsAccount
1719 */
1720 static NTSTATUS dcesrv_lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call,
1721 TALLOC_CTX *mem_ctx,
1722 struct lsa_EnumPrivsAccount *r)
1723 {
1724 struct dcesrv_handle *h;
1725 struct lsa_account_state *astate;
1726 int ret, i;
1727 struct ldb_message **res;
1728 const char * const attrs[] = { "privilege", NULL};
1729 struct ldb_message_element *el;
1730 const char *sidstr;
1731 struct lsa_PrivilegeSet *privs;
1732
1733 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
1734
1735 astate = h->data;
1736
1737 privs = talloc(mem_ctx, struct lsa_PrivilegeSet);
1738 if (privs == NULL) {
1739 return NT_STATUS_NO_MEMORY;
1740 }
1741 privs->count = 0;
1742 privs->unknown = 0;
1743 privs->set = NULL;
1744
1745 *r->out.privs = privs;
1746
1747 sidstr = ldap_encode_ndr_dom_sid(mem_ctx, astate->account_sid);
1748 if (sidstr == NULL) {
1749 return NT_STATUS_NO_MEMORY;
1750 }
1751
1752 ret = gendb_search(astate->policy->sam_ldb, mem_ctx, NULL, &res, attrs,
1753 "objectSid=%s", sidstr);
1754 if (ret != 1) {
1755 return NT_STATUS_OK;
1756 }
1757
1758 el = ldb_msg_find_element(res[0], "privilege");
1759 if (el == NULL || el->num_values == 0) {
1760 return NT_STATUS_OK;
1761 }
1762
1763 privs->set = talloc_array(privs,
1764 struct lsa_LUIDAttribute, el->num_values);
1765 if (privs->set == NULL) {
1766 return NT_STATUS_NO_MEMORY;
1767 }
1768
1769 for (i=0;i<el->num_values;i++) {
1770 int id = sec_privilege_id((const char *)el->values[i].data);
1771 if (id == -1) {
1772 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1773 }
1774 privs->set[i].attribute = 0;
1775 privs->set[i].luid.low = id;
1776 privs->set[i].luid.high = 0;
1777 }
1778
1779 privs->count = el->num_values;
1780
1781 return NT_STATUS_OK;
1782 }
1783
1784 /*
1785 lsa_EnumAccountRights
1786 */
1787 static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
1788 TALLOC_CTX *mem_ctx,
1789 struct lsa_EnumAccountRights *r)
1790 {
1791 struct dcesrv_handle *h;
1792 struct lsa_policy_state *state;
1793 int ret, i;
1794 struct ldb_message **res;
1795 const char * const attrs[] = { "privilege", NULL};
1796 const char *sidstr;
1797 struct ldb_message_element *el;
1798
1799 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
1800
1801 state = h->data;
1802
1803 sidstr = ldap_encode_ndr_dom_sid(mem_ctx, r->in.sid);
1804 if (sidstr == NULL) {
1805 return NT_STATUS_NO_MEMORY;
1806 }
1807
1808 ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs,
1809 "(&(objectSid=%s)(privilege=*))", sidstr);
1810 if (ret == 0) {
1811 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1812 }
1813 if (ret > 1) {
1814 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1815 }
1816 if (ret == -1) {
1817 DEBUG(3, ("searching for account rights for SID: %s failed: %s",
1818 dom_sid_string(mem_ctx, r->in.sid),
1819 ldb_errstring(state->sam_ldb)));
1820 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1821 }
1822
1823 el = ldb_msg_find_element(res[0], "privilege");
1824 if (el == NULL || el->num_values == 0) {
1825 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1826 }
1827
1828 r->out.rights->count = el->num_values;
1829 r->out.rights->names = talloc_array(r->out.rights,
1830 struct lsa_StringLarge, r->out.rights->count);
1831 if (r->out.rights->names == NULL) {
1832 return NT_STATUS_NO_MEMORY;
1833 }
1834
1835 for (i=0;i<el->num_values;i++) {
1836 r->out.rights->names[i].string = (const char *)el->values[i].data;
1837 }
1838
1839 return NT_STATUS_OK;
1840 }
1841
1842
1843
1844 /*
1845 helper for lsa_AddAccountRights and lsa_RemoveAccountRights
1846 */
1847 static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
1848 TALLOC_CTX *mem_ctx,
1849 struct lsa_policy_state *state,
1850 int ldb_flag,
1851 struct dom_sid *sid,
1852 const struct lsa_RightSet *rights)
1853 {
1854 const char *sidstr;
1855 struct ldb_message *msg;
1856 struct ldb_message_element *el;
1857 int i, ret;
1858 struct lsa_EnumAccountRights r2;
1859
1860 sidstr = ldap_encode_ndr_dom_sid(mem_ctx, sid);
1861 if (sidstr == NULL) {
1862 return NT_STATUS_NO_MEMORY;
1863 }
1864
1865 msg = ldb_msg_new(mem_ctx);
1866 if (msg == NULL) {
1867 return NT_STATUS_NO_MEMORY;
1868 }
1869
1870 msg->dn = samdb_search_dn(state->sam_ldb, mem_ctx,
1871 NULL, "objectSid=%s", sidstr);
1872 if (msg->dn == NULL) {
1873 NTSTATUS status;
1874 if (ldb_flag == LDB_FLAG_MOD_DELETE) {
1875 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1876 }
1877 status = samdb_create_foreign_security_principal(state->sam_ldb, mem_ctx,
1878 sid, &msg->dn);
1879 if (!NT_STATUS_IS_OK(status)) {
1880 return status;
1881 }
1882 return NT_STATUS_NO_SUCH_USER;
1883 }
1884
1885 if (ldb_msg_add_empty(msg, "privilege", ldb_flag, NULL)) {
1886 return NT_STATUS_NO_MEMORY;
1887 }
1888
1889 if (ldb_flag == LDB_FLAG_MOD_ADD) {
1890 NTSTATUS status;
1891
1892 r2.in.handle = &state->handle->wire_handle;
1893 r2.in.sid = sid;
1894 r2.out.rights = talloc(mem_ctx, struct lsa_RightSet);
1895
1896 status = dcesrv_lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
1897 if (!NT_STATUS_IS_OK(status)) {
1898 ZERO_STRUCTP(r2.out.rights);
1899 }
1900 }
1901
1902 for (i=0;i<rights->count;i++) {
1903 if (sec_privilege_id(rights->names[i].string) == -1) {
1904 return NT_STATUS_NO_SUCH_PRIVILEGE;
1905 }
1906
1907 if (ldb_flag == LDB_FLAG_MOD_ADD) {
1908 int j;
1909 for (j=0;j<r2.out.rights->count;j++) {
1910 if (strcasecmp_m(r2.out.rights->names[j].string,
1911 rights->names[i].string) == 0) {
1912 break;
1913 }
1914 }
1915 if (j != r2.out.rights->count) continue;
1916 }
1917
1918 ret = ldb_msg_add_string(msg, "privilege", rights->names[i].string);
1919 if (ret != LDB_SUCCESS) {
1920 return NT_STATUS_NO_MEMORY;
1921 }
1922 }
1923
1924 el = ldb_msg_find_element(msg, "privilege");
1925 if (!el) {
1926 return NT_STATUS_OK;
1927 }
1928
1929 ret = ldb_modify(state->sam_ldb, msg);
1930 if (ret != 0) {
1931 if (ldb_flag == LDB_FLAG_MOD_DELETE && ret == LDB_ERR_NO_SUCH_ATTRIBUTE) {
1932 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1933 }
1934 DEBUG(3, ("Could not %s attributes from %s: %s",
1935 ldb_flag == LDB_FLAG_MOD_DELETE ? "delete" : "add",
1936 ldb_dn_get_linearized(msg->dn), ldb_errstring(state->sam_ldb)));
1937 return NT_STATUS_UNEXPECTED_IO_ERROR;
1938 }
1939
1940 return NT_STATUS_OK;
1941 }
1942
1943 /*
1944 lsa_AddPrivilegesToAccount
1945 */
1946 static NTSTATUS dcesrv_lsa_AddPrivilegesToAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1947 struct lsa_AddPrivilegesToAccount *r)
1948 {
1949 struct lsa_RightSet rights;
1950 struct dcesrv_handle *h;
1951 struct lsa_account_state *astate;
1952 int i;
1953
1954 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
1955
1956 astate = h->data;
1957
1958 rights.count = r->in.privs->count;
1959 rights.names = talloc_array(mem_ctx, struct lsa_StringLarge, rights.count);
1960 if (rights.names == NULL) {
1961 return NT_STATUS_NO_MEMORY;
1962 }
1963 for (i=0;i<rights.count;i++) {
1964 int id = r->in.privs->set[i].luid.low;
1965 if (r->in.privs->set[i].luid.high) {
1966 return NT_STATUS_NO_SUCH_PRIVILEGE;
1967 }
1968 rights.names[i].string = sec_privilege_name(id);
1969 if (rights.names[i].string == NULL) {
1970 return NT_STATUS_NO_SUCH_PRIVILEGE;
1971 }
1972 }
1973
1974 return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
1975 LDB_FLAG_MOD_ADD, astate->account_sid,
1976 &rights);
1977 }
1978
1979
1980 /*
1981 lsa_RemovePrivilegesFromAccount
1982 */
1983 static NTSTATUS dcesrv_lsa_RemovePrivilegesFromAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
1984 struct lsa_RemovePrivilegesFromAccount *r)
1985 {
1986 struct lsa_RightSet *rights;
1987 struct dcesrv_handle *h;
1988 struct lsa_account_state *astate;
1989 int i;
1990
1991 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
1992
1993 astate = h->data;
1994
1995 rights = talloc(mem_ctx, struct lsa_RightSet);
1996
1997 if (r->in.remove_all == 1 &&
1998 r->in.privs == NULL) {
1999 struct lsa_EnumAccountRights r2;
2000 NTSTATUS status;
2001
2002 r2.in.handle = &astate->policy->handle->wire_handle;
2003 r2.in.sid = astate->account_sid;
2004 r2.out.rights = rights;
2005
2006 status = dcesrv_lsa_EnumAccountRights(dce_call, mem_ctx, &r2);
2007 if (!NT_STATUS_IS_OK(status)) {
2008 return status;
2009 }
2010
2011 return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
2012 LDB_FLAG_MOD_DELETE, astate->account_sid,
2013 r2.out.rights);
2014 }
2015
2016 if (r->in.remove_all != 0) {
2017 return NT_STATUS_INVALID_PARAMETER;
2018 }
2019
2020 rights->count = r->in.privs->count;
2021 rights->names = talloc_array(mem_ctx, struct lsa_StringLarge, rights->count);
2022 if (rights->names == NULL) {
2023 return NT_STATUS_NO_MEMORY;
2024 }
2025 for (i=0;i<rights->count;i++) {
2026 int id = r->in.privs->set[i].luid.low;
2027 if (r->in.privs->set[i].luid.high) {
2028 return NT_STATUS_NO_SUCH_PRIVILEGE;
2029 }
2030 rights->names[i].string = sec_privilege_name(id);
2031 if (rights->names[i].string == NULL) {
2032 return NT_STATUS_NO_SUCH_PRIVILEGE;
2033 }
2034 }
2035
2036 return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
2037 LDB_FLAG_MOD_DELETE, astate->account_sid,
2038 rights);
2039 }
2040
2041
2042 /*
2043 lsa_GetQuotasForAccount
2044 */
2045 static NTSTATUS dcesrv_lsa_GetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2046 struct lsa_GetQuotasForAccount *r)
2047 {
2048 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2049 }
2050
2051
2052 /*
2053 lsa_SetQuotasForAccount
2054 */
2055 static NTSTATUS dcesrv_lsa_SetQuotasForAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2056 struct lsa_SetQuotasForAccount *r)
2057 {
2058 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2059 }
2060
2061
2062 /*
2063 lsa_GetSystemAccessAccount
2064 */
2065 static NTSTATUS dcesrv_lsa_GetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2066 struct lsa_GetSystemAccessAccount *r)
2067 {
2068 int i;
2069 NTSTATUS status;
2070 struct lsa_EnumPrivsAccount enumPrivs;
2071 struct lsa_PrivilegeSet *privs;
2072
2073 privs = talloc(mem_ctx, struct lsa_PrivilegeSet);
2074 if (!privs) {
2075 return NT_STATUS_NO_MEMORY;
2076 }
2077 privs->count = 0;
2078 privs->unknown = 0;
2079 privs->set = NULL;
2080
2081 enumPrivs.in.handle = r->in.handle;
2082 enumPrivs.out.privs = &privs;
2083
2084 status = dcesrv_lsa_EnumPrivsAccount(dce_call, mem_ctx, &enumPrivs);
2085 if (!NT_STATUS_IS_OK(status)) {
2086 return status;
2087 }
2088
2089 *(r->out.access_mask) = 0x00000000;
2090
2091 for (i = 0; i < privs->count; i++) {
2092 int priv = privs->set[i].luid.low;
2093
2094 switch (priv) {
2095 case SEC_PRIV_INTERACTIVE_LOGON:
2096 *(r->out.access_mask) |= LSA_POLICY_MODE_INTERACTIVE;
2097 break;
2098 case SEC_PRIV_NETWORK_LOGON:
2099 *(r->out.access_mask) |= LSA_POLICY_MODE_NETWORK;
2100 break;
2101 case SEC_PRIV_REMOTE_INTERACTIVE_LOGON:
2102 *(r->out.access_mask) |= LSA_POLICY_MODE_REMOTE_INTERACTIVE;
2103 break;
2104 }
2105 }
2106
2107 return NT_STATUS_OK;
2108 }
2109
2110
2111 /*
2112 lsa_SetSystemAccessAccount
2113 */
2114 static NTSTATUS dcesrv_lsa_SetSystemAccessAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2115 struct lsa_SetSystemAccessAccount *r)
2116 {
2117 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2118 }
2119
2120
2121 /*
2122 lsa_CreateSecret
2123 */
2124 static NTSTATUS dcesrv_lsa_CreateSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2125 struct lsa_CreateSecret *r)
2126 {
2127 struct dcesrv_handle *policy_handle;
2128 struct lsa_policy_state *policy_state;
2129 struct lsa_secret_state *secret_state;
2130 struct dcesrv_handle *handle;
2131 struct ldb_message **msgs, *msg;
2132 const char *errstr;
2133 const char *attrs[] = {
2134 NULL
2135 };
2136
2137 const char *name;
2138
2139 int ret;
2140
2141 DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
2142 ZERO_STRUCTP(r->out.sec_handle);
2143
2144 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
2145 {
2146 case SECURITY_SYSTEM:
2147 case SECURITY_ADMINISTRATOR:
2148 break;
2149 default:
2150 /* Users and annonymous are not allowed create secrets */
2151 return NT_STATUS_ACCESS_DENIED;
2152 }
2153
2154 policy_state = policy_handle->data;
2155
2156 if (!r->in.name.string) {
2157 return NT_STATUS_INVALID_PARAMETER;
2158 }
2159
2160 secret_state = talloc(mem_ctx, struct lsa_secret_state);
2161 if (!secret_state) {
2162 return NT_STATUS_NO_MEMORY;
2163 }
2164 secret_state->policy = policy_state;
2165
2166 msg = ldb_msg_new(mem_ctx);
2167 if (msg == NULL) {
2168 return NT_STATUS_NO_MEMORY;
2169 }
2170
2171 if (strncmp("G$", r->in.name.string, 2) == 0) {
2172 const char *name2;
2173 name = &r->in.name.string[2];
2174 /* We need to connect to the database as system, as this is one of the rare RPC calls that must read the secrets (and this is denied otherwise) */
2175 secret_state->sam_ldb = talloc_reference(secret_state,
2176 samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(secret_state, dce_call->conn->dce_ctx->lp_ctx)));
2177 secret_state->global = true;
2178
2179 if (strlen(name) < 1) {
2180 return NT_STATUS_INVALID_PARAMETER;
2181 }
2182
2183 name2 = talloc_asprintf(mem_ctx, "%s Secret", ldb_binary_encode_string(mem_ctx, name));
2184 /* search for the secret record */
2185 ret = gendb_search(secret_state->sam_ldb,
2186 mem_ctx, policy_state->system_dn, &msgs, attrs,
2187 "(&(cn=%s)(objectclass=secret))",
2188 name2);
2189 if (ret > 0) {
2190 return NT_STATUS_OBJECT_NAME_COLLISION;
2191 }
2192
2193 if (ret == -1) {
2194 DEBUG(0,("Failure searching for CN=%s: %s\n",
2195 name2, ldb_errstring(secret_state->sam_ldb)));
2196 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2197 }
2198
2199 msg->dn = ldb_dn_copy(mem_ctx, policy_state->system_dn);
2200 if (!name2 || ! ldb_dn_add_child_fmt(msg->dn, "cn=%s", name2)) {
2201 return NT_STATUS_NO_MEMORY;
2202 }
2203
2204 samdb_msg_add_string(secret_state->sam_ldb, mem_ctx, msg, "cn", name2);
2205
2206 } else {
2207 secret_state->global = false;
2208
2209 name = r->in.name.string;
2210 if (strlen(name) < 1) {
2211 return NT_STATUS_INVALID_PARAMETER;
2212 }
2213
2214 secret_state->sam_ldb = talloc_reference(secret_state,
2215 secrets_db_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx));
2216 /* search for the secret record */
2217 ret = gendb_search(secret_state->sam_ldb, mem_ctx,
2218 ldb_dn_new(mem_ctx, secret_state->sam_ldb, "cn=LSA Secrets"),
2219 &msgs, attrs,
2220 "(&(cn=%s)(objectclass=secret))",
2221 ldb_binary_encode_string(mem_ctx, name));
2222 if (ret > 0) {
2223 return NT_STATUS_OBJECT_NAME_COLLISION;
2224 }
2225
2226 if (ret == -1) {
2227 DEBUG(0,("Failure searching for CN=%s: %s\n",
2228 name, ldb_errstring(secret_state->sam_ldb)));
2229 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2230 }
2231
2232 msg->dn = ldb_dn_new_fmt(mem_ctx, secret_state->sam_ldb, "cn=%s,cn=LSA Secrets", name);
2233 samdb_msg_add_string(secret_state->sam_ldb, mem_ctx, msg, "cn", name);
2234 }
2235
2236 /* pull in all the template attributes. Note this is always from the global samdb */
2237 ret = samdb_copy_template(secret_state->policy->sam_ldb, msg,
2238 "secret", &errstr);
2239 if (ret != 0) {
2240 DEBUG(0,("Failed to load TemplateSecret from samdb: %s\n",
2241 errstr));
2242 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2243 }
2244
2245 samdb_msg_add_string(secret_state->sam_ldb, mem_ctx, msg, "objectClass", "secret");
2246
2247 secret_state->secret_dn = talloc_reference(secret_state, msg->dn);
2248
2249 /* create the secret */
2250 ret = ldb_add(secret_state->sam_ldb, msg);
2251 if (ret != 0) {
2252 DEBUG(0,("Failed to create secret record %s: %s\n",
2253 ldb_dn_get_linearized(msg->dn),
2254 ldb_errstring(secret_state->sam_ldb)));
2255 return NT_STATUS_ACCESS_DENIED;
2256 }
2257
2258 handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_SECRET);
2259 if (!handle) {
2260 return NT_STATUS_NO_MEMORY;
2261 }
2262
2263 handle->data = talloc_steal(handle, secret_state);
2264
2265 secret_state->access_mask = r->in.access_mask;
2266 secret_state->policy = talloc_reference(secret_state, policy_state);
2267
2268 *r->out.sec_handle = handle->wire_handle;
2269
2270 return NT_STATUS_OK;
2271 }
2272
2273
2274 /*
2275 lsa_OpenSecret
2276 */
2277 static NTSTATUS dcesrv_lsa_OpenSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2278 struct lsa_OpenSecret *r)
2279 {
2280 struct dcesrv_handle *policy_handle;
2281
2282 struct lsa_policy_state *policy_state;
2283 struct lsa_secret_state *secret_state;
2284 struct dcesrv_handle *handle;
2285 struct ldb_message **msgs;
2286 const char *attrs[] = {
2287 NULL
2288 };
2289
2290 const char *name;
2291
2292 int ret;
2293
2294 DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
2295 ZERO_STRUCTP(r->out.sec_handle);
2296 policy_state = policy_handle->data;
2297
2298 if (!r->in.name.string) {
2299 return NT_STATUS_INVALID_PARAMETER;
2300 }
2301
2302 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
2303 {
2304 case SECURITY_SYSTEM:
2305 case SECURITY_ADMINISTRATOR:
2306 break;
2307 default:
2308 /* Users and annonymous are not allowed to access secrets */
2309 return NT_STATUS_ACCESS_DENIED;
2310 }
2311
2312 secret_state = talloc(mem_ctx, struct lsa_secret_state);
2313 if (!secret_state) {
2314 return NT_STATUS_NO_MEMORY;
2315 }
2316 secret_state->policy = policy_state;
2317
2318 if (strncmp("G$", r->in.name.string, 2) == 0) {
2319 name = &r->in.name.string[2];
2320 /* We need to connect to the database as system, as this is one of the rare RPC calls that must read the secrets (and this is denied otherwise) */
2321 secret_state->sam_ldb = talloc_reference(secret_state,
2322 samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(secret_state, dce_call->conn->dce_ctx->lp_ctx)));
2323 secret_state->global = true;
2324
2325 if (strlen(name) < 1) {
2326 return NT_STATUS_INVALID_PARAMETER;
2327 }
2328
2329 /* search for the secret record */
2330 ret = gendb_search(secret_state->sam_ldb,
2331 mem_ctx, policy_state->system_dn, &msgs, attrs,
2332 "(&(cn=%s Secret)(objectclass=secret))",
2333 ldb_binary_encode_string(mem_ctx, name));
2334 if (ret == 0) {
2335 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2336 }
2337
2338 if (ret != 1) {
2339 DEBUG(0,("Found %d records matching DN %s\n", ret,
2340 ldb_dn_get_linearized(policy_state->system_dn)));
2341 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2342 }
2343
2344 } else {
2345 secret_state->global = false;
2346 secret_state->sam_ldb = talloc_reference(secret_state,
2347 secrets_db_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx));
2348
2349 name = r->in.name.string;
2350 if (strlen(name) < 1) {
2351 return NT_STATUS_INVALID_PARAMETER;
2352 }
2353
2354 /* search for the secret record */
2355 ret = gendb_search(secret_state->sam_ldb, mem_ctx,
2356 ldb_dn_new(mem_ctx, secret_state->sam_ldb, "cn=LSA Secrets"),
2357 &msgs, attrs,
2358 "(&(cn=%s)(objectclass=secret))",
2359 ldb_binary_encode_string(mem_ctx, name));
2360 if (ret == 0) {
2361 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2362 }
2363
2364 if (ret != 1) {
2365 DEBUG(0,("Found %d records matching CN=%s\n",
2366 ret, ldb_binary_encode_string(mem_ctx, name)));
2367 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2368 }
2369 }
2370
2371 secret_state->secret_dn = talloc_reference(secret_state, msgs[0]->dn);
2372
2373 handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_SECRET);
2374 if (!handle) {
2375 return NT_STATUS_NO_MEMORY;
2376 }
2377
2378 handle->data = talloc_steal(handle, secret_state);
2379
2380 secret_state->access_mask = r->in.access_mask;
2381 secret_state->policy = talloc_reference(secret_state, policy_state);
2382
2383 *r->out.sec_handle = handle->wire_handle;
2384
2385 return NT_STATUS_OK;
2386 }
2387
2388
2389 /*
2390 lsa_SetSecret
2391 */
2392 static NTSTATUS dcesrv_lsa_SetSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2393 struct lsa_SetSecret *r)
2394 {
2395
2396 struct dcesrv_handle *h;
2397 struct lsa_secret_state *secret_state;
2398 struct ldb_message *msg;
2399 DATA_BLOB session_key;
2400 DATA_BLOB crypt_secret, secret;
2401 struct ldb_val val;
2402 int ret;
2403 NTSTATUS status = NT_STATUS_OK;
2404
2405 struct timeval now = timeval_current();
2406 NTTIME nt_now = timeval_to_nttime(&now);
2407
2408 DCESRV_PULL_HANDLE(h, r->in.sec_handle, LSA_HANDLE_SECRET);
2409
2410 secret_state = h->data;
2411
2412 msg = ldb_msg_new(mem_ctx);
2413 if (msg == NULL) {
2414 return NT_STATUS_NO_MEMORY;
2415 }
2416
2417 msg->dn = talloc_reference(mem_ctx, secret_state->secret_dn);
2418 if (!msg->dn) {
2419 return NT_STATUS_NO_MEMORY;
2420 }
2421 status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
2422 if (!NT_STATUS_IS_OK(status)) {
2423 return status;
2424 }
2425
2426 if (r->in.old_val) {
2427 /* Decrypt */
2428 crypt_secret.data = r->in.old_val->data;
2429 crypt_secret.length = r->in.old_val->size;
2430
2431 status = sess_decrypt_blob(mem_ctx, &crypt_secret, &session_key, &secret);
2432 if (!NT_STATUS_IS_OK(status)) {
2433 return status;
2434 }
2435
2436 val.data = secret.data;
2437 val.length = secret.length;
2438
2439 /* set value */
2440 if (samdb_msg_add_value(secret_state->sam_ldb,
2441 mem_ctx, msg, "priorValue", &val) != 0) {
2442 return NT_STATUS_NO_MEMORY;
2443 }
2444
2445 /* set old value mtime */
2446 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2447 mem_ctx, msg, "priorSetTime", nt_now) != 0) {
2448 return NT_STATUS_NO_MEMORY;
2449 }
2450
2451 } else {
2452 /* If the old value is not set, then migrate the
2453 * current value to the old value */
2454 const struct ldb_val *old_val;
2455 NTTIME last_set_time;
2456 struct ldb_message **res;
2457 const char *attrs[] = {
2458 "currentValue",
2459 "lastSetTime",
2460 NULL
2461 };
2462
2463 /* search for the secret record */
2464 ret = gendb_search_dn(secret_state->sam_ldb,mem_ctx,
2465 secret_state->secret_dn, &res, attrs);
2466 if (ret == 0) {
2467 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2468 }
2469
2470 if (ret != 1) {
2471 DEBUG(0,("Found %d records matching dn=%s\n", ret,
2472 ldb_dn_get_linearized(secret_state->secret_dn)));
2473 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2474 }
2475
2476 old_val = ldb_msg_find_ldb_val(res[0], "currentValue");
2477 last_set_time = ldb_msg_find_attr_as_uint64(res[0], "lastSetTime", 0);
2478
2479 if (old_val) {
2480 /* set old value */
2481 if (samdb_msg_add_value(secret_state->sam_ldb,
2482 mem_ctx, msg, "priorValue",
2483 old_val) != 0) {
2484 return NT_STATUS_NO_MEMORY;
2485 }
2486 } else {
2487 if (samdb_msg_add_delete(secret_state->sam_ldb,
2488 mem_ctx, msg, "priorValue")) {
2489 return NT_STATUS_NO_MEMORY;
2490 }
2491
2492 }
2493
2494 /* set old value mtime */
2495 if (ldb_msg_find_ldb_val(res[0], "lastSetTime")) {
2496 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2497 mem_ctx, msg, "priorSetTime", last_set_time) != 0) {
2498 return NT_STATUS_NO_MEMORY;
2499 }
2500 } else {
2501 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2502 mem_ctx, msg, "priorSetTime", nt_now) != 0) {
2503 return NT_STATUS_NO_MEMORY;
2504 }
2505 }
2506 }
2507
2508 if (r->in.new_val) {
2509 /* Decrypt */
2510 crypt_secret.data = r->in.new_val->data;
2511 crypt_secret.length = r->in.new_val->size;
2512
2513 status = sess_decrypt_blob(mem_ctx, &crypt_secret, &session_key, &secret);
2514 if (!NT_STATUS_IS_OK(status)) {
2515 return status;
2516 }
2517
2518 val.data = secret.data;
2519 val.length = secret.length;
2520
2521 /* set value */
2522 if (samdb_msg_add_value(secret_state->sam_ldb,
2523 mem_ctx, msg, "currentValue", &val) != 0) {
2524 return NT_STATUS_NO_MEMORY;
2525 }
2526
2527 /* set new value mtime */
2528 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2529 mem_ctx, msg, "lastSetTime", nt_now) != 0) {
2530 return NT_STATUS_NO_MEMORY;
2531 }
2532
2533 } else {
2534 /* NULL out the NEW value */
2535 if (samdb_msg_add_uint64(secret_state->sam_ldb,
2536 mem_ctx, msg, "lastSetTime", nt_now) != 0) {
2537 return NT_STATUS_NO_MEMORY;
2538 }
2539 if (samdb_msg_add_delete(secret_state->sam_ldb,
2540 mem_ctx, msg, "currentValue")) {
2541 return NT_STATUS_NO_MEMORY;
2542 }
2543 }
2544
2545 /* modify the samdb record */
2546 ret = samdb_replace(secret_state->sam_ldb, mem_ctx, msg);
2547 if (ret != 0) {
2548 /* we really need samdb.c to return NTSTATUS */
2549 return NT_STATUS_UNSUCCESSFUL;
2550 }
2551
2552 return NT_STATUS_OK;
2553 }
2554
2555
2556 /*
2557 lsa_QuerySecret
2558 */
2559 static NTSTATUS dcesrv_lsa_QuerySecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2560 struct lsa_QuerySecret *r)
2561 {
2562 struct dcesrv_handle *h;
2563 struct lsa_secret_state *secret_state;
2564 struct ldb_message *msg;
2565 DATA_BLOB session_key;
2566 DATA_BLOB crypt_secret, secret;
2567 int ret;
2568 struct ldb_message **res;
2569 const char *attrs[] = {
2570 "currentValue",
2571 "priorValue",
2572 "lastSetTime",
2573 "priorSetTime",
2574 NULL
2575 };
2576
2577 NTSTATUS nt_status;
2578
2579 DCESRV_PULL_HANDLE(h, r->in.sec_handle, LSA_HANDLE_SECRET);
2580
2581 /* Ensure user is permitted to read this... */
2582 switch (security_session_user_level(dce_call->conn->auth_state.session_info))
2583 {
2584 case SECURITY_SYSTEM:
2585 case SECURITY_ADMINISTRATOR:
2586 break;
2587 default:
2588 /* Users and annonymous are not allowed to read secrets */
2589 return NT_STATUS_ACCESS_DENIED;
2590 }
2591
2592 secret_state = h->data;
2593
2594 /* pull all the user attributes */
2595 ret = gendb_search_dn(secret_state->sam_ldb, mem_ctx,
2596 secret_state->secret_dn, &res, attrs);
2597 if (ret != 1) {
2598 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2599 }
2600 msg = res[0];
2601
2602 nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
2603 if (!NT_STATUS_IS_OK(nt_status)) {
2604 return nt_status;
2605 }
2606
2607 if (r->in.old_val) {
2608 const struct ldb_val *prior_val;
2609 r->out.old_val = talloc_zero(mem_ctx, struct lsa_DATA_BUF_PTR);
2610 if (!r->out.old_val) {
2611 return NT_STATUS_NO_MEMORY;
2612 }
2613 prior_val = ldb_msg_find_ldb_val(res[0], "priorValue");
2614
2615 if (prior_val && prior_val->length) {
2616 secret.data = prior_val->data;
2617 secret.length = prior_val->length;
2618
2619 /* Encrypt */
2620 crypt_secret = sess_encrypt_blob(mem_ctx, &secret, &session_key);
2621 if (!crypt_secret.length) {
2622 return NT_STATUS_NO_MEMORY;
2623 }
2624 r->out.old_val->buf = talloc(mem_ctx, struct lsa_DATA_BUF);
2625 if (!r->out.old_val->buf) {
2626 return NT_STATUS_NO_MEMORY;
2627 }
2628 r->out.old_val->buf->size = crypt_secret.length;
2629 r->out.old_val->buf->length = crypt_secret.length;
2630 r->out.old_val->buf->data = crypt_secret.data;
2631 }
2632 }
2633
2634 if (r->in.old_mtime) {
2635 r->out.old_mtime = talloc(mem_ctx, NTTIME);
2636 if (!r->out.old_mtime) {
2637 return NT_STATUS_NO_MEMORY;
2638 }
2639 *r->out.old_mtime = ldb_msg_find_attr_as_uint64(res[0], "priorSetTime", 0);
2640 }
2641
2642 if (r->in.new_val) {
2643 const struct ldb_val *new_val;
2644 r->out.new_val = talloc_zero(mem_ctx, struct lsa_DATA_BUF_PTR);
2645 if (!r->out.new_val) {
2646 return NT_STATUS_NO_MEMORY;
2647 }
2648
2649 new_val = ldb_msg_find_ldb_val(res[0], "currentValue");
2650
2651 if (new_val && new_val->length) {
2652 secret.data = new_val->data;
2653 secret.length = new_val->length;
2654
2655 /* Encrypt */
2656 crypt_secret = sess_encrypt_blob(mem_ctx, &secret, &session_key);
2657 if (!crypt_secret.length) {
2658 return NT_STATUS_NO_MEMORY;
2659 }
2660 r->out.new_val->buf = talloc(mem_ctx, struct lsa_DATA_BUF);
2661 if (!r->out.new_val->buf) {
2662 return NT_STATUS_NO_MEMORY;
2663 }
2664 r->out.new_val->buf->length = crypt_secret.length;
2665 r->out.new_val->buf->size = crypt_secret.length;
2666 r->out.new_val->buf->data = crypt_secret.data;
2667 }
2668 }
2669
2670 if (r->in.new_mtime) {
2671 r->out.new_mtime = talloc(mem_ctx, NTTIME);
2672 if (!r->out.new_mtime) {
2673 return NT_STATUS_NO_MEMORY;
2674 }
2675 *r->out.new_mtime = ldb_msg_find_attr_as_uint64(res[0], "lastSetTime", 0);
2676 }
2677
2678 return NT_STATUS_OK;
2679 }
2680
2681
2682 /*
2683 lsa_LookupPrivValue
2684 */
2685 static NTSTATUS dcesrv_lsa_LookupPrivValue(struct dcesrv_call_state *dce_call,
2686 TALLOC_CTX *mem_ctx,
2687 struct lsa_LookupPrivValue *r)
2688 {
2689 struct dcesrv_handle *h;
2690 struct lsa_policy_state *state;
2691 int id;
2692
2693 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2694
2695 state = h->data;
2696
2697 id = sec_privilege_id(r->in.name->string);
2698 if (id == -1) {
2699 return NT_STATUS_NO_SUCH_PRIVILEGE;
2700 }
2701
2702 r->out.luid->low = id;
2703 r->out.luid->high = 0;
2704
2705 return NT_STATUS_OK;
2706 }
2707
2708
2709 /*
2710 lsa_LookupPrivName
2711 */
2712 static NTSTATUS dcesrv_lsa_LookupPrivName(struct dcesrv_call_state *dce_call,
2713 TALLOC_CTX *mem_ctx,
2714 struct lsa_LookupPrivName *r)
2715 {
2716 struct dcesrv_handle *h;
2717 struct lsa_policy_state *state;
2718 struct lsa_StringLarge *name;
2719 const char *privname;
2720
2721 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2722
2723 state = h->data;
2724
2725 if (r->in.luid->high != 0) {
2726 return NT_STATUS_NO_SUCH_PRIVILEGE;
2727 }
2728
2729 privname = sec_privilege_name(r->in.luid->low);
2730 if (privname == NULL) {
2731 return NT_STATUS_NO_SUCH_PRIVILEGE;
2732 }
2733
2734 name = talloc(mem_ctx, struct lsa_StringLarge);
2735 if (name == NULL) {
2736 return NT_STATUS_NO_MEMORY;
2737 }
2738
2739 name->string = privname;
2740
2741 *r->out.name = name;
2742
2743 return NT_STATUS_OK;
2744 }
2745
2746
2747 /*
2748 lsa_LookupPrivDisplayName
2749 */
2750 static NTSTATUS dcesrv_lsa_LookupPrivDisplayName(struct dcesrv_call_state *dce_call,
2751 TALLOC_CTX *mem_ctx,
2752 struct lsa_LookupPrivDisplayName *r)
2753 {
2754 struct dcesrv_handle *h;
2755 struct lsa_policy_state *state;
2756 struct lsa_StringLarge *disp_name = NULL;
2757 int id;
2758
2759 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2760
2761 state = h->data;
2762
2763 id = sec_privilege_id(r->in.name->string);
2764 if (id == -1) {
2765 return NT_STATUS_NO_SUCH_PRIVILEGE;
2766 }
2767
2768 disp_name = talloc(mem_ctx, struct lsa_StringLarge);
2769 if (disp_name == NULL) {
2770 return NT_STATUS_NO_MEMORY;
2771 }
2772
2773 disp_name->string = sec_privilege_display_name(id, &r->in.language_id);
2774 if (disp_name->string == NULL) {
2775 return NT_STATUS_INTERNAL_ERROR;
2776 }
2777
2778 *r->out.disp_name = disp_name;
2779 *r->out.returned_language_id = 0;
2780
2781 return NT_STATUS_OK;
2782 }
2783
2784
2785 /*
2786 lsa_EnumAccountsWithUserRight
2787 */
2788 static NTSTATUS dcesrv_lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *dce_call,
2789 TALLOC_CTX *mem_ctx,
2790 struct lsa_EnumAccountsWithUserRight *r)
2791 {
2792 struct dcesrv_handle *h;
2793 struct lsa_policy_state *state;
2794 int ret, i;
2795 struct ldb_message **res;
2796 const char * const attrs[] = { "objectSid", NULL};
2797 const char *privname;
2798
2799 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2800
2801 state = h->data;
2802
2803 if (r->in.name == NULL) {
2804 return NT_STATUS_NO_SUCH_PRIVILEGE;
2805 }
2806
2807 privname = r->in.name->string;
2808 if (sec_privilege_id(privname) == -1) {
2809 return NT_STATUS_NO_SUCH_PRIVILEGE;
2810 }
2811
2812 ret = gendb_search(state->sam_ldb, mem_ctx, NULL, &res, attrs,
2813 "privilege=%s", privname);
2814 if (ret == -1) {
2815 return NT_STATUS_INTERNAL_DB_CORRUPTION;
2816 }
2817 if (ret == 0) {
2818 return NT_STATUS_NO_MORE_ENTRIES;
2819 }
2820
2821 r->out.sids->sids = talloc_array(r->out.sids, struct lsa_SidPtr, ret);
2822 if (r->out.sids->sids == NULL) {
2823 return NT_STATUS_NO_MEMORY;
2824 }
2825 for (i=0;i<ret;i++) {
2826 r->out.sids->sids[i].sid = samdb_result_dom_sid(r->out.sids->sids,
2827 res[i], "objectSid");
2828 NT_STATUS_HAVE_NO_MEMORY(r->out.sids->sids[i].sid);
2829 }
2830 r->out.sids->num_sids = ret;
2831
2832 return NT_STATUS_OK;
2833 }
2834
2835
2836 /*
2837 lsa_AddAccountRights
2838 */
2839 static NTSTATUS dcesrv_lsa_AddAccountRights(struct dcesrv_call_state *dce_call,
2840 TALLOC_CTX *mem_ctx,
2841 struct lsa_AddAccountRights *r)
2842 {
2843 struct dcesrv_handle *h;
2844 struct lsa_policy_state *state;
2845
2846 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2847
2848 state = h->data;
2849
2850 return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
2851 LDB_FLAG_MOD_ADD,
2852 r->in.sid, r->in.rights);
2853 }
2854
2855
2856 /*
2857 lsa_RemoveAccountRights
2858 */
2859 static NTSTATUS dcesrv_lsa_RemoveAccountRights(struct dcesrv_call_state *dce_call,
2860 TALLOC_CTX *mem_ctx,
2861 struct lsa_RemoveAccountRights *r)
2862 {
2863 struct dcesrv_handle *h;
2864 struct lsa_policy_state *state;
2865
2866 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
2867
2868 state = h->data;
2869
2870 return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
2871 LDB_FLAG_MOD_DELETE,
2872 r->in.sid, r->in.rights);
2873 }
2874
2875
2876 /*
2877 lsa_StorePrivateData
2878 */
2879 static NTSTATUS dcesrv_lsa_StorePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2880 struct lsa_StorePrivateData *r)
2881 {
2882 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2883 }
2884
2885
2886 /*
2887 lsa_RetrievePrivateData
2888 */
2889 static NTSTATUS dcesrv_lsa_RetrievePrivateData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2890 struct lsa_RetrievePrivateData *r)
2891 {
2892 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2893 }
2894
2895
2896 /*
2897 lsa_GetUserName
2898 */
2899 static NTSTATUS dcesrv_lsa_GetUserName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
2900 struct lsa_GetUserName *r)
2901 {
2902 NTSTATUS status = NT_STATUS_OK;
2903 const char *account_name;
2904 const char *authority_name;
2905 struct lsa_String *_account_name;
2906 struct lsa_String *_authority_name = NULL;
2907
2908 /* this is what w2k3 does */
2909 r->out.account_name = r->in.account_name;
2910 r->out.authority_name = r->in.authority_name;
2911
2912 if (r->in.account_name
2913 && *r->in.account_name
2914 /* && *(*r->in.account_name)->string */
2915 ) {
2916 return NT_STATUS_INVALID_PARAMETER;
2917 }
2918
2919 if (r->in.authority_name
2920 && *r->in.authority_name
2921 /* && *(*r->in.authority_name)->string */
2922 ) {
2923 return NT_STATUS_INVALID_PARAMETER;
2924 }
2925
2926 account_name = talloc_reference(mem_ctx, dce_call->conn->auth_state.session_info->server_info->account_name);
2927 authority_name = talloc_reference(mem_ctx, dce_call->conn->auth_state.session_info->server_info->domain_name);
2928
2929 _account_name = talloc(mem_ctx, struct lsa_String);
2930 NT_STATUS_HAVE_NO_MEMORY(_account_name);
2931 _account_name->string = account_name;
2932
2933 if (r->in.authority_name) {
2934 _authority_name = talloc(mem_ctx, struct lsa_String);
2935 NT_STATUS_HAVE_NO_MEMORY(_authority_name);
2936 _authority_name->string = authority_name;
2937 }
2938
2939 *r->out.account_name = _account_name;
2940 if (r->out.authority_name) {
2941 *r->out.authority_name = _authority_name;
2942 }
2943
2944 return status;
2945 }
2946
2947 /*
2948 lsa_SetInfoPolicy2
2949 */
2950 static NTSTATUS dcesrv_lsa_SetInfoPolicy2(struct dcesrv_call_state *dce_call,
2951 TALLOC_CTX *mem_ctx,
2952 struct lsa_SetInfoPolicy2 *r)
2953 {
2954 /* need to support these */
2955 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
2956 }
2957
2958 /*
2959 lsa_QueryDomainInformationPolicy
2960 */
2961 static NTSTATUS dcesrv_lsa_QueryDomainInformationPolicy(struct dcesrv_call_state *dce_call,
2962 TALLOC_CTX *mem_ctx,
2963 struct lsa_QueryDomainInformationPolicy *r)
2964 {
2965 union lsa_DomainInformationPolicy *info;
2966
2967 info = talloc(r->out.info, union lsa_DomainInformationPolicy);
2968 if (!info) {
2969 return NT_STATUS_NO_MEMORY;
2970 }
2971
2972 switch (r->in.level) {
2973 case LSA_DOMAIN_INFO_POLICY_EFS:
2974 talloc_free(info);
2975 *r->out.info = NULL;
2976 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2977 case LSA_DOMAIN_INFO_POLICY_KERBEROS:
2978 {
2979 struct lsa_DomainInfoKerberos *k = &info->kerberos_info;
2980 struct smb_krb5_context *smb_krb5_context;
2981 int ret = smb_krb5_init_context(mem_ctx,
2982 dce_call->event_ctx,
2983 dce_call->conn->dce_ctx->lp_ctx,
2984 &smb_krb5_context);
2985 if (ret != 0) {
2986 talloc_free(info);
2987 *r->out.info = NULL;
2988 return NT_STATUS_INTERNAL_ERROR;
2989 }
2990 k->enforce_restrictions = 0; /* FIXME, details missing from MS-LSAD 2.2.53 */
2991 k->service_tkt_lifetime = 0; /* Need to find somewhere to store this, and query in KDC too */
2992 k->user_tkt_lifetime = 0; /* Need to find somewhere to store this, and query in KDC too */
2993 k->user_tkt_renewaltime = 0; /* Need to find somewhere to store this, and query in KDC too */
2994 k->clock_skew = krb5_get_max_time_skew(smb_krb5_context->krb5_context);
2995 talloc_free(smb_krb5_context);
2996 *r->out.info = info;
2997 return NT_STATUS_OK;
2998 }
2999 default:
3000 talloc_free(info);
3001 *r->out.info = NULL;
3002 return NT_STATUS_INVALID_INFO_CLASS;
3003 }
3004 }
3005
3006 /*
3007 lsa_SetDomInfoPolicy
3008 */
3009 static NTSTATUS dcesrv_lsa_SetDomainInformationPolicy(struct dcesrv_call_state *dce_call,
3010 TALLOC_CTX *mem_ctx,
3011 struct lsa_SetDomainInformationPolicy *r)
3012 {
3013 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3014 }
3015
3016 /*
3017 lsa_TestCall
3018 */
3019 static NTSTATUS dcesrv_lsa_TestCall(struct dcesrv_call_state *dce_call,
3020 TALLOC_CTX *mem_ctx,
3021 struct lsa_TestCall *r)
3022 {
3023 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3024 }
3025
3026 /*
3027 lsa_CREDRWRITE
3028 */
3029 static NTSTATUS dcesrv_lsa_CREDRWRITE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3030 struct lsa_CREDRWRITE *r)
3031 {
3032 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3033 }
3034
3035
3036 /*
3037 lsa_CREDRREAD
3038 */
3039 static NTSTATUS dcesrv_lsa_CREDRREAD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3040 struct lsa_CREDRREAD *r)
3041 {
3042 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3043 }
3044
3045
3046 /*
3047 lsa_CREDRENUMERATE
3048 */
3049 static NTSTATUS dcesrv_lsa_CREDRENUMERATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3050 struct lsa_CREDRENUMERATE *r)
3051 {
3052 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3053 }
3054
3055
3056 /*
3057 lsa_CREDRWRITEDOMAINCREDENTIALS
3058 */
3059 static NTSTATUS dcesrv_lsa_CREDRWRITEDOMAINCREDENTIALS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3060 struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
3061 {
3062 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3063 }
3064
3065
3066 /*
3067 lsa_CREDRREADDOMAINCREDENTIALS
3068 */
3069 static NTSTATUS dcesrv_lsa_CREDRREADDOMAINCREDENTIALS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3070 struct lsa_CREDRREADDOMAINCREDENTIALS *r)
3071 {
3072 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3073 }
3074
3075
3076 /*
3077 lsa_CREDRDELETE
3078 */
3079 static NTSTATUS dcesrv_lsa_CREDRDELETE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3080 struct lsa_CREDRDELETE *r)
3081 {
3082 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3083 }
3084
3085
3086 /*
3087 lsa_CREDRGETTARGETINFO
3088 */
3089 static NTSTATUS dcesrv_lsa_CREDRGETTARGETINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3090 struct lsa_CREDRGETTARGETINFO *r)
3091 {
3092 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3093 }
3094
3095
3096 /*
3097 lsa_CREDRPROFILELOADED
3098 */
3099 static NTSTATUS dcesrv_lsa_CREDRPROFILELOADED(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3100 struct lsa_CREDRPROFILELOADED *r)
3101 {
3102 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3103 }
3104
3105
3106 /*
3107 lsa_CREDRGETSESSIONTYPES
3108 */
3109 static NTSTATUS dcesrv_lsa_CREDRGETSESSIONTYPES(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3110 struct lsa_CREDRGETSESSIONTYPES *r)
3111 {
3112 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3113 }
3114
3115
3116 /*
3117 lsa_LSARREGISTERAUDITEVENT
3118 */
3119 static NTSTATUS dcesrv_lsa_LSARREGISTERAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3120 struct lsa_LSARREGISTERAUDITEVENT *r)
3121 {
3122 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3123 }
3124
3125
3126 /*
3127 lsa_LSARGENAUDITEVENT
3128 */
3129 static NTSTATUS dcesrv_lsa_LSARGENAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3130 struct lsa_LSARGENAUDITEVENT *r)
3131 {
3132 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3133 }
3134
3135
3136 /*
3137 lsa_LSARUNREGISTERAUDITEVENT
3138 */
3139 static NTSTATUS dcesrv_lsa_LSARUNREGISTERAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3140 struct lsa_LSARUNREGISTERAUDITEVENT *r)
3141 {
3142 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3143 }
3144
3145
3146 /*
3147 lsa_lsaRQueryForestTrustInformation
3148 */
3149 static NTSTATUS dcesrv_lsa_lsaRQueryForestTrustInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3150 struct lsa_lsaRQueryForestTrustInformation *r)
3151 {
3152 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3153 }
3154
3155
3156 /*
3157 lsa_LSARSETFORESTTRUSTINFORMATION
3158 */
3159 static NTSTATUS dcesrv_lsa_LSARSETFORESTTRUSTINFORMATION(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3160 struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
3161 {
3162 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3163 }
3164
3165
3166 /*
3167 lsa_CREDRRENAME
3168 */
3169 static NTSTATUS dcesrv_lsa_CREDRRENAME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3170 struct lsa_CREDRRENAME *r)
3171 {
3172 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3173 }
3174
3175
3176
3177 /*
3178 lsa_LSAROPENPOLICYSCE
3179 */
3180 static NTSTATUS dcesrv_lsa_LSAROPENPOLICYSCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3181 struct lsa_LSAROPENPOLICYSCE *r)
3182 {
3183 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3184 }
3185
3186
3187 /*
3188 lsa_LSARADTREGISTERSECURITYEVENTSOURCE
3189 */
3190 static NTSTATUS dcesrv_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3191 struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
3192 {
3193 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3194 }
3195
3196
3197 /*
3198 lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
3199 */
3200 static NTSTATUS dcesrv_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3201 struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
3202 {
3203 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3204 }
3205
3206
3207 /*
3208 lsa_LSARADTREPORTSECURITYEVENT
3209 */
3210 static NTSTATUS dcesrv_lsa_LSARADTREPORTSECURITYEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3211 struct lsa_LSARADTREPORTSECURITYEVENT *r)
3212 {
3213 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3214 }
3215
3216
3217 /* include the generated boilerplate */
3218 #include "librpc/gen_ndr/ndr_lsa_s.c"
3219
3220
3221
3222 /*****************************************
3223 NOTE! The remaining calls below were
3224 removed in w2k3, so the DCESRV_FAULT()
3225 replies are the correct implementation. Do
3226 not try and fill these in with anything else
3227 ******************************************/
3228
3229 /*
3230 dssetup_DsRoleDnsNameToFlatName
3231 */
3232 static WERROR dcesrv_dssetup_DsRoleDnsNameToFlatName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3233 struct dssetup_DsRoleDnsNameToFlatName *r)
3234 {
3235 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3236 }
3237
3238
3239 /*
3240 dssetup_DsRoleDcAsDc
3241 */
3242 static WERROR dcesrv_dssetup_DsRoleDcAsDc(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3243 struct dssetup_DsRoleDcAsDc *r)
3244 {
3245 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3246 }
3247
3248
3249 /*
3250 dssetup_DsRoleDcAsReplica
3251 */
3252 static WERROR dcesrv_dssetup_DsRoleDcAsReplica(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3253 struct dssetup_DsRoleDcAsReplica *r)
3254 {
3255 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3256 }
3257
3258
3259 /*
3260 dssetup_DsRoleDemoteDc
3261 */
3262 static WERROR dcesrv_dssetup_DsRoleDemoteDc(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3263 struct dssetup_DsRoleDemoteDc *r)
3264 {
3265 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3266 }
3267
3268
3269 /*
3270 dssetup_DsRoleGetDcOperationProgress
3271 */
3272 static WERROR dcesrv_dssetup_DsRoleGetDcOperationProgress(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3273 struct dssetup_DsRoleGetDcOperationProgress *r)
3274 {
3275 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3276 }
3277
3278
3279 /*
3280 dssetup_DsRoleGetDcOperationResults
3281 */
3282 static WERROR dcesrv_dssetup_DsRoleGetDcOperationResults(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3283 struct dssetup_DsRoleGetDcOperationResults *r)
3284 {
3285 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3286 }
3287
3288
3289 /*
3290 dssetup_DsRoleCancel
3291 */
3292 static WERROR dcesrv_dssetup_DsRoleCancel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3293 struct dssetup_DsRoleCancel *r)
3294 {
3295 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3296 }
3297
3298
3299 /*
3300 dssetup_DsRoleServerSaveStateForUpgrade
3301 */
3302 static WERROR dcesrv_dssetup_DsRoleServerSaveStateForUpgrade(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3303 struct dssetup_DsRoleServerSaveStateForUpgrade *r)
3304 {
3305 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3306 }
3307
3308
3309 /*
3310 dssetup_DsRoleUpgradeDownlevelServer
3311 */
3312 static WERROR dcesrv_dssetup_DsRoleUpgradeDownlevelServer(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3313 struct dssetup_DsRoleUpgradeDownlevelServer *r)
3314 {
3315 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3316 }
3317
3318
3319 /*
3320 dssetup_DsRoleAbortDownlevelServerUpgrade
3321 */
3322 static WERROR dcesrv_dssetup_DsRoleAbortDownlevelServerUpgrade(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
3323 struct dssetup_DsRoleAbortDownlevelServerUpgrade *r)
3324 {
3325 DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
3326 }
3327
3328
3329 /* include the generated boilerplate */
3330 #include "librpc/gen_ndr/ndr_dssetup_s.c"
3331
3332 NTSTATUS dcerpc_server_lsa_init(void)
3333 {
3334 NTSTATUS ret;
3335
3336 ret = dcerpc_server_dssetup_init();
3337 if (!NT_STATUS_IS_OK(ret)) {
3338 return ret;
3339 }
3340 ret = dcerpc_server_lsarpc_init();
3341 if (!NT_STATUS_IS_OK(ret)) {
3342 return ret;
3343 }
3344 return ret;
3345 }
WIP