1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: Local Security Authority (LSA) Server
4 * FILE: reactos/dll/win32/lsasrv/lsarpc.h
5 * PURPOSE: RPC interface functions
6 *
7 * PROGRAMMERS: Eric Kohl
8 */
9
10 #include "lsasrv.h"
11
12 /* GLOBALS *****************************************************************/
13
14 static RTL_CRITICAL_SECTION PolicyHandleTableLock;
15
16 static
17 GENERIC_MAPPING
18 LsapPolicyMapping = {POLICY_READ,
19 POLICY_WRITE,
20 POLICY_EXECUTE,
21 POLICY_ALL_ACCESS};
22
23 static
24 GENERIC_MAPPING
25 LsapAccountMapping = {ACCOUNT_READ,
26 ACCOUNT_WRITE,
27 ACCOUNT_EXECUTE,
28 ACCOUNT_ALL_ACCESS};
29
30 static
31 GENERIC_MAPPING
32 LsapSecretMapping = {SECRET_READ,
33 SECRET_WRITE,
34 SECRET_EXECUTE,
35 SECRET_ALL_ACCESS};
36
37 /* FUNCTIONS ***************************************************************/
38
39 NTSTATUS
LsarStartRpcServer(VOID)40 LsarStartRpcServer(VOID)
41 {
42 RPC_STATUS Status;
43 DWORD dwError;
44 HANDLE hEvent;
45
46 RtlInitializeCriticalSection(&PolicyHandleTableLock);
47
48 TRACE("LsarStartRpcServer() called\n");
49
50 Status = RpcServerUseProtseqEpW(L"ncacn_np",
51 RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
52 L"\\pipe\\lsarpc",
53 NULL);
54 if (Status != RPC_S_OK)
55 {
56 WARN("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
57 return I_RpcMapWin32Status(Status);
58 }
59
60 Status = RpcServerRegisterIf(lsarpc_v0_0_s_ifspec,
61 NULL,
62 NULL);
63 if (Status != RPC_S_OK)
64 {
65 WARN("RpcServerRegisterIf() failed (Status %lx)\n", Status);
66 return I_RpcMapWin32Status(Status);
67 }
68
69 DsSetupInit();
70
71 Status = RpcServerListen(1, 20, TRUE);
72 if (Status != RPC_S_OK)
73 {
74 WARN("RpcServerListen() failed (Status %lx)\n", Status);
75 return I_RpcMapWin32Status(Status);
76 }
77
78 /* Notify the service manager */
79 TRACE("Creating notification event!\n");
80 hEvent = CreateEventW(NULL,
81 TRUE,
82 FALSE,
83 L"LSA_RPC_SERVER_ACTIVE");
84 if (hEvent == NULL)
85 {
86 dwError = GetLastError();
87 TRACE("Failed to create or open the notification event (Error %lu)\n", dwError);
88 #if 0
89 if (dwError == ERROR_ALREADY_EXISTS)
90 {
91 hEvent = OpenEventW(GENERIC_WRITE,
92 FALSE,
93 L"LSA_RPC_SERVER_ACTIVE");
94 if (hEvent == NULL)
95 {
96 ERR("Could not open the notification event (Error %lu)\n", GetLastError());
97 return STATUS_UNSUCCESSFUL;
98 }
99 }
100 #endif
101 return STATUS_UNSUCCESSFUL;
102 }
103
104 TRACE("Set notification event!\n");
105 SetEvent(hEvent);
106
107 /* NOTE: Do not close the event handle, as it must remain alive! */
108
109 TRACE("LsarStartRpcServer() done\n");
110 return STATUS_SUCCESS;
111 }
112
113
114 void
115 __RPC_USER
LSAPR_HANDLE_rundown(LSAPR_HANDLE hHandle)116 LSAPR_HANDLE_rundown(
117 LSAPR_HANDLE hHandle)
118 {
119 }
120
121
122 /* Function 0 */
123 NTSTATUS
124 WINAPI
LsarClose(LSAPR_HANDLE * ObjectHandle)125 LsarClose(
126 LSAPR_HANDLE *ObjectHandle)
127 {
128 PLSA_DB_OBJECT DbObject;
129 NTSTATUS Status = STATUS_SUCCESS;
130
131 TRACE("LsarClose(%p)\n", ObjectHandle);
132
133 // RtlEnterCriticalSection(&PolicyHandleTableLock);
134
135 Status = LsapValidateDbObject(*ObjectHandle,
136 LsaDbIgnoreObject,
137 0,
138 &DbObject);
139 if (Status == STATUS_SUCCESS)
140 {
141 Status = LsapCloseDbObject(DbObject);
142 *ObjectHandle = NULL;
143 }
144
145 // RtlLeaveCriticalSection(&PolicyHandleTableLock);
146
147 return Status;
148 }
149
150
151 /* Function 1 */
152 NTSTATUS
153 WINAPI
LsarDelete(LSAPR_HANDLE ObjectHandle)154 LsarDelete(
155 LSAPR_HANDLE ObjectHandle)
156 {
157 TRACE("LsarDelete(%p)\n", ObjectHandle);
158
159 return LsarDeleteObject(&ObjectHandle);
160 }
161
162
163 /* Function 2 */
164 NTSTATUS
165 WINAPI
LsarEnumeratePrivileges(LSAPR_HANDLE PolicyHandle,DWORD * EnumerationContext,PLSAPR_PRIVILEGE_ENUM_BUFFER EnumerationBuffer,DWORD PreferedMaximumLength)166 LsarEnumeratePrivileges(
167 LSAPR_HANDLE PolicyHandle,
168 DWORD *EnumerationContext,
169 PLSAPR_PRIVILEGE_ENUM_BUFFER EnumerationBuffer,
170 DWORD PreferedMaximumLength)
171 {
172 PLSA_DB_OBJECT PolicyObject;
173 NTSTATUS Status;
174
175 TRACE("LsarEnumeratePrivileges(%p %p %p %lu)\n",
176 PolicyHandle, EnumerationContext, EnumerationBuffer,
177 PreferedMaximumLength);
178
179 Status = LsapValidateDbObject(PolicyHandle,
180 LsaDbPolicyObject,
181 POLICY_VIEW_LOCAL_INFORMATION,
182 &PolicyObject);
183 if (!NT_SUCCESS(Status))
184 return Status;
185
186 if (EnumerationContext == NULL)
187 return STATUS_INVALID_PARAMETER;
188
189 return LsarpEnumeratePrivileges(EnumerationContext,
190 EnumerationBuffer,
191 PreferedMaximumLength);
192 }
193
194
195 /* Function 3 */
196 NTSTATUS
197 WINAPI
LsarQuerySecurityObject(LSAPR_HANDLE ObjectHandle,SECURITY_INFORMATION SecurityInformation,PLSAPR_SR_SECURITY_DESCRIPTOR * SecurityDescriptor)198 LsarQuerySecurityObject(
199 LSAPR_HANDLE ObjectHandle,
200 SECURITY_INFORMATION SecurityInformation,
201 PLSAPR_SR_SECURITY_DESCRIPTOR *SecurityDescriptor)
202 {
203 PLSA_DB_OBJECT DbObject = NULL;
204 PISECURITY_DESCRIPTOR_RELATIVE RelativeSd = NULL;
205 PSECURITY_DESCRIPTOR ResultSd = NULL;
206 PLSAPR_SR_SECURITY_DESCRIPTOR SdData = NULL;
207 ACCESS_MASK DesiredAccess = 0;
208 ULONG RelativeSdSize = 0;
209 ULONG ResultSdSize = 0;
210 NTSTATUS Status;
211
212 TRACE("LsarQuerySecurityObject(%p %lx %p)\n",
213 ObjectHandle, SecurityInformation, SecurityDescriptor);
214
215 if (SecurityDescriptor == NULL)
216 return STATUS_INVALID_PARAMETER;
217
218 *SecurityDescriptor = NULL;
219
220 if ((SecurityInformation & OWNER_SECURITY_INFORMATION) ||
221 (SecurityInformation & GROUP_SECURITY_INFORMATION) ||
222 (SecurityInformation & DACL_SECURITY_INFORMATION))
223 DesiredAccess |= READ_CONTROL;
224
225 if (SecurityInformation & SACL_SECURITY_INFORMATION)
226 DesiredAccess |= ACCESS_SYSTEM_SECURITY;
227
228 /* Validate the ObjectHandle */
229 Status = LsapValidateDbObject(ObjectHandle,
230 LsaDbIgnoreObject,
231 DesiredAccess,
232 &DbObject);
233 if (!NT_SUCCESS(Status))
234 return Status;
235
236 /* Get the size of the SD */
237 Status = LsapGetObjectAttribute(DbObject,
238 L"SecDesc",
239 NULL,
240 &RelativeSdSize);
241 if (!NT_SUCCESS(Status))
242 return Status;
243
244 /* Allocate a buffer for the SD */
245 RelativeSd = MIDL_user_allocate(RelativeSdSize);
246 if (RelativeSd == NULL)
247 return STATUS_INSUFFICIENT_RESOURCES;
248
249 /* Get the SD */
250 Status = LsapGetObjectAttribute(DbObject,
251 L"SecDesc",
252 RelativeSd,
253 &RelativeSdSize);
254 if (!NT_SUCCESS(Status))
255 goto done;
256
257 /* Invalidate the SD information that was not requested */
258 if (!(SecurityInformation & OWNER_SECURITY_INFORMATION))
259 RelativeSd->Owner = 0;
260
261 if (!(SecurityInformation & GROUP_SECURITY_INFORMATION))
262 RelativeSd->Group = 0;
263
264 if (!(SecurityInformation & DACL_SECURITY_INFORMATION))
265 RelativeSd->Control &= ~SE_DACL_PRESENT;
266
267 if (!(SecurityInformation & SACL_SECURITY_INFORMATION))
268 RelativeSd->Control &= ~SE_SACL_PRESENT;
269
270 /* Calculate the required SD size */
271 Status = RtlMakeSelfRelativeSD(RelativeSd,
272 NULL,
273 &ResultSdSize);
274 if (Status != STATUS_BUFFER_TOO_SMALL)
275 goto done;
276
277 /* Allocate a buffer for the new SD */
278 ResultSd = MIDL_user_allocate(ResultSdSize);
279 if (ResultSd == NULL)
280 {
281 Status = STATUS_INSUFFICIENT_RESOURCES;
282 goto done;
283 }
284
285 /* Build the new SD */
286 Status = RtlMakeSelfRelativeSD(RelativeSd,
287 ResultSd,
288 &ResultSdSize);
289 if (!NT_SUCCESS(Status))
290 goto done;
291
292 /* Allocate the SD data buffer */
293 SdData = MIDL_user_allocate(sizeof(LSAPR_SR_SECURITY_DESCRIPTOR));
294 if (SdData == NULL)
295 {
296 Status = STATUS_INSUFFICIENT_RESOURCES;
297 goto done;
298 }
299
300 /* Fill the SD data buffer and return it to the caller */
301 SdData->Length = ResultSdSize;
302 SdData->SecurityDescriptor = (PBYTE)ResultSd;
303
304 *SecurityDescriptor = SdData;
305
306 done:
307 if (!NT_SUCCESS(Status))
308 {
309 if (ResultSd != NULL)
310 MIDL_user_free(ResultSd);
311 }
312
313 if (RelativeSd != NULL)
314 MIDL_user_free(RelativeSd);
315
316 return Status;
317 }
318
319
320 /* Function 4 */
321 NTSTATUS
322 WINAPI
LsarSetSecurityObject(LSAPR_HANDLE ObjectHandle,SECURITY_INFORMATION SecurityInformation,PLSAPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)323 LsarSetSecurityObject(
324 LSAPR_HANDLE ObjectHandle,
325 SECURITY_INFORMATION SecurityInformation,
326 PLSAPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)
327 {
328 PLSA_DB_OBJECT DbObject = NULL;
329 ACCESS_MASK DesiredAccess = 0;
330 PSECURITY_DESCRIPTOR RelativeSd = NULL;
331 ULONG RelativeSdSize = 0;
332 HANDLE TokenHandle = NULL;
333 PGENERIC_MAPPING Mapping;
334 NTSTATUS Status;
335
336 TRACE("LsarSetSecurityObject(%p %lx %p)\n",
337 ObjectHandle, SecurityInformation, SecurityDescriptor);
338
339 if ((SecurityDescriptor == NULL) ||
340 (SecurityDescriptor->SecurityDescriptor == NULL) ||
341 !RtlValidSecurityDescriptor((PSECURITY_DESCRIPTOR)SecurityDescriptor->SecurityDescriptor))
342 return ERROR_INVALID_PARAMETER;
343
344 if (SecurityInformation == 0 ||
345 SecurityInformation & ~(OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION
346 | DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION))
347 return ERROR_INVALID_PARAMETER;
348
349 if (SecurityInformation & SACL_SECURITY_INFORMATION)
350 DesiredAccess |= ACCESS_SYSTEM_SECURITY;
351
352 if (SecurityInformation & DACL_SECURITY_INFORMATION)
353 DesiredAccess |= WRITE_DAC;
354
355 if (SecurityInformation & (OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION))
356 DesiredAccess |= WRITE_OWNER;
357
358 if ((SecurityInformation & OWNER_SECURITY_INFORMATION) &&
359 (((PISECURITY_DESCRIPTOR)SecurityDescriptor)->Owner == NULL))
360 return ERROR_INVALID_PARAMETER;
361
362 if ((SecurityInformation & GROUP_SECURITY_INFORMATION) &&
363 (((PISECURITY_DESCRIPTOR)SecurityDescriptor)->Group == NULL))
364 return ERROR_INVALID_PARAMETER;
365
366 /* Validate the ObjectHandle */
367 Status = LsapValidateDbObject(ObjectHandle,
368 LsaDbIgnoreObject,
369 DesiredAccess,
370 &DbObject);
371 if (!NT_SUCCESS(Status))
372 {
373 ERR("LsapValidateDbObject failed (Status 0x%08lx)\n", Status);
374 return Status;
375 }
376
377 /* Get the mapping for the object type */
378 switch (DbObject->ObjectType)
379 {
380 case LsaDbPolicyObject:
381 Mapping = &LsapPolicyMapping;
382 break;
383
384 case LsaDbAccountObject:
385 Mapping = &LsapAccountMapping;
386 break;
387
388 // case LsaDbDomainObject:
389 // Mapping = &LsapDomainMapping;
390 // break;
391
392 case LsaDbSecretObject:
393 Mapping = &LsapSecretMapping;
394 break;
395
396 default:
397 return STATUS_INVALID_HANDLE;
398 }
399
400 /* Get the size of the SD */
401 Status = LsapGetObjectAttribute(DbObject,
402 L"SecDesc",
403 NULL,
404 &RelativeSdSize);
405 if (!NT_SUCCESS(Status))
406 return Status;
407
408 /* Allocate a buffer for the SD */
409 RelativeSd = RtlAllocateHeap(RtlGetProcessHeap(), 0, RelativeSdSize);
410 if (RelativeSd == NULL)
411 return STATUS_INSUFFICIENT_RESOURCES;
412
413 /* Get the SD */
414 Status = LsapGetObjectAttribute(DbObject,
415 L"SecDesc",
416 RelativeSd,
417 &RelativeSdSize);
418 if (!NT_SUCCESS(Status))
419 goto done;
420
421 /* Get the clients token if we try to set the owner */
422 if (SecurityInformation & OWNER_SECURITY_INFORMATION)
423 {
424 Status = I_RpcMapWin32Status(RpcImpersonateClient(NULL));
425 if (!NT_SUCCESS(Status))
426 {
427 ERR("RpcImpersonateClient returns 0x%08lx\n", Status);
428 goto done;
429 }
430
431 Status = NtOpenThreadToken(NtCurrentThread(),
432 TOKEN_QUERY,
433 TRUE,
434 &TokenHandle);
435 RpcRevertToSelf();
436 if (!NT_SUCCESS(Status))
437 {
438 ERR("NtOpenThreadToken returns 0x%08lx\n", Status);
439 goto done;
440 }
441 }
442
443 /* Build the new security descriptor */
444 Status = RtlSetSecurityObject(SecurityInformation,
445 (PSECURITY_DESCRIPTOR)SecurityDescriptor->SecurityDescriptor,
446 &RelativeSd,
447 Mapping,
448 TokenHandle);
449 if (!NT_SUCCESS(Status))
450 {
451 ERR("RtlSetSecurityObject failed (Status 0x%08lx)\n", Status);
452 goto done;
453 }
454
455 /* Set the modified SD */
456 Status = LsapSetObjectAttribute(DbObject,
457 L"SecDesc",
458 RelativeSd,
459 RtlLengthSecurityDescriptor(RelativeSd));
460 if (!NT_SUCCESS(Status))
461 {
462 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
463 }
464
465 done:
466 if (TokenHandle != NULL)
467 NtClose(TokenHandle);
468
469 if (RelativeSd != NULL)
470 RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
471
472 return Status;
473 }
474
475
476 /* Function 5 */
477 NTSTATUS
478 WINAPI
LsarChangePassword(handle_t IDL_handle,PRPC_UNICODE_STRING String1,PRPC_UNICODE_STRING String2,PRPC_UNICODE_STRING String3,PRPC_UNICODE_STRING String4,PRPC_UNICODE_STRING String5)479 LsarChangePassword(
480 handle_t IDL_handle,
481 PRPC_UNICODE_STRING String1,
482 PRPC_UNICODE_STRING String2,
483 PRPC_UNICODE_STRING String3,
484 PRPC_UNICODE_STRING String4,
485 PRPC_UNICODE_STRING String5)
486 {
487 /* Deprecated */
488 return STATUS_NOT_IMPLEMENTED;
489 }
490
491
492 /* Function 6 */
493 NTSTATUS
494 WINAPI
LsarOpenPolicy(LPWSTR SystemName,PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * PolicyHandle)495 LsarOpenPolicy(
496 LPWSTR SystemName,
497 PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
498 ACCESS_MASK DesiredAccess,
499 LSAPR_HANDLE *PolicyHandle)
500 {
501 PLSA_DB_OBJECT PolicyObject;
502 NTSTATUS Status;
503
504 TRACE("LsarOpenPolicy(%S %p %lx %p)\n",
505 SystemName, ObjectAttributes, DesiredAccess, PolicyHandle);
506
507 RtlEnterCriticalSection(&PolicyHandleTableLock);
508
509 Status = LsapOpenDbObject(NULL,
510 NULL,
511 L"Policy",
512 LsaDbPolicyObject,
513 DesiredAccess,
514 FALSE,
515 &PolicyObject);
516
517 RtlLeaveCriticalSection(&PolicyHandleTableLock);
518
519 if (NT_SUCCESS(Status))
520 *PolicyHandle = (LSAPR_HANDLE)PolicyObject;
521
522 TRACE("LsarOpenPolicy done!\n");
523
524 return Status;
525 }
526
527
528 /* Function 7 */
529 NTSTATUS
530 WINAPI
LsarQueryInformationPolicy(LSAPR_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_POLICY_INFORMATION * PolicyInformation)531 LsarQueryInformationPolicy(
532 LSAPR_HANDLE PolicyHandle,
533 POLICY_INFORMATION_CLASS InformationClass,
534 PLSAPR_POLICY_INFORMATION *PolicyInformation)
535 {
536 PLSA_DB_OBJECT PolicyObject;
537 ACCESS_MASK DesiredAccess = 0;
538 NTSTATUS Status;
539
540 TRACE("LsarQueryInformationPolicy(%p,0x%08x,%p)\n",
541 PolicyHandle, InformationClass, PolicyInformation);
542
543 if (PolicyInformation)
544 {
545 TRACE("*PolicyInformation %p\n", *PolicyInformation);
546 }
547
548 switch (InformationClass)
549 {
550 case PolicyAuditLogInformation:
551 case PolicyAuditEventsInformation:
552 case PolicyAuditFullQueryInformation:
553 DesiredAccess = POLICY_VIEW_AUDIT_INFORMATION;
554 break;
555
556 case PolicyPrimaryDomainInformation:
557 case PolicyAccountDomainInformation:
558 case PolicyLsaServerRoleInformation:
559 case PolicyReplicaSourceInformation:
560 case PolicyDefaultQuotaInformation:
561 case PolicyModificationInformation:
562 case PolicyDnsDomainInformation:
563 case PolicyDnsDomainInformationInt:
564 case PolicyLocalAccountDomainInformation:
565 DesiredAccess = POLICY_VIEW_LOCAL_INFORMATION;
566 break;
567
568 case PolicyPdAccountInformation:
569 DesiredAccess = POLICY_GET_PRIVATE_INFORMATION;
570 break;
571
572 default:
573 ERR("Invalid InformationClass!\n");
574 return STATUS_INVALID_PARAMETER;
575 }
576
577 Status = LsapValidateDbObject(PolicyHandle,
578 LsaDbPolicyObject,
579 DesiredAccess,
580 &PolicyObject);
581 if (!NT_SUCCESS(Status))
582 return Status;
583
584 switch (InformationClass)
585 {
586 case PolicyAuditLogInformation: /* 1 */
587 Status = LsarQueryAuditLog(PolicyObject,
588 PolicyInformation);
589 break;
590
591 case PolicyAuditEventsInformation: /* 2 */
592 Status = LsarQueryAuditEvents(PolicyObject,
593 PolicyInformation);
594 break;
595
596 case PolicyPrimaryDomainInformation: /* 3 */
597 Status = LsarQueryPrimaryDomain(PolicyObject,
598 PolicyInformation);
599 break;
600
601 case PolicyPdAccountInformation: /* 4 */
602 Status = LsarQueryPdAccount(PolicyObject,
603 PolicyInformation);
604 break;
605
606 case PolicyAccountDomainInformation: /* 5 */
607 Status = LsarQueryAccountDomain(PolicyObject,
608 PolicyInformation);
609 break;
610
611 case PolicyLsaServerRoleInformation: /* 6 */
612 Status = LsarQueryServerRole(PolicyObject,
613 PolicyInformation);
614 break;
615
616 case PolicyReplicaSourceInformation: /* 7 */
617 Status = LsarQueryReplicaSource(PolicyObject,
618 PolicyInformation);
619 break;
620
621 case PolicyDefaultQuotaInformation: /* 8 */
622 Status = LsarQueryDefaultQuota(PolicyObject,
623 PolicyInformation);
624 break;
625
626 case PolicyModificationInformation: /* 9 */
627 Status = LsarQueryModification(PolicyObject,
628 PolicyInformation);
629 break;
630
631 case PolicyAuditFullQueryInformation: /* 11 (0xB) */
632 Status = LsarQueryAuditFull(PolicyObject,
633 PolicyInformation);
634 break;
635
636 case PolicyDnsDomainInformation: /* 12 (0xC) */
637 Status = LsarQueryDnsDomain(PolicyObject,
638 PolicyInformation);
639 break;
640
641 case PolicyDnsDomainInformationInt: /* 13 (0xD) */
642 Status = LsarQueryDnsDomainInt(PolicyObject,
643 PolicyInformation);
644 break;
645
646 case PolicyLocalAccountDomainInformation: /* 14 (0xE) */
647 Status = LsarQueryLocalAccountDomain(PolicyObject,
648 PolicyInformation);
649 break;
650
651 default:
652 ERR("Invalid InformationClass!\n");
653 Status = STATUS_INVALID_PARAMETER;
654 }
655
656 return Status;
657 }
658
659
660 /* Function 8 */
661 NTSTATUS
662 WINAPI
LsarSetInformationPolicy(LSAPR_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_POLICY_INFORMATION PolicyInformation)663 LsarSetInformationPolicy(
664 LSAPR_HANDLE PolicyHandle,
665 POLICY_INFORMATION_CLASS InformationClass,
666 PLSAPR_POLICY_INFORMATION PolicyInformation)
667 {
668 PLSA_DB_OBJECT PolicyObject;
669 ACCESS_MASK DesiredAccess = 0;
670 NTSTATUS Status;
671
672 TRACE("LsarSetInformationPolicy(%p,0x%08x,%p)\n",
673 PolicyHandle, InformationClass, PolicyInformation);
674
675 if (PolicyInformation)
676 {
677 TRACE("*PolicyInformation %p\n", *PolicyInformation);
678 }
679
680 switch (InformationClass)
681 {
682 case PolicyAuditLogInformation:
683 case PolicyAuditFullSetInformation:
684 DesiredAccess = POLICY_AUDIT_LOG_ADMIN;
685 break;
686
687 case PolicyAuditEventsInformation:
688 DesiredAccess = POLICY_SET_AUDIT_REQUIREMENTS;
689 break;
690
691 case PolicyPrimaryDomainInformation:
692 case PolicyAccountDomainInformation:
693 case PolicyDnsDomainInformation:
694 case PolicyDnsDomainInformationInt:
695 case PolicyLocalAccountDomainInformation:
696 DesiredAccess = POLICY_TRUST_ADMIN;
697 break;
698
699 case PolicyLsaServerRoleInformation:
700 case PolicyReplicaSourceInformation:
701 DesiredAccess = POLICY_SERVER_ADMIN;
702 break;
703
704 case PolicyDefaultQuotaInformation:
705 DesiredAccess = POLICY_SET_DEFAULT_QUOTA_LIMITS;
706 break;
707
708 default:
709 ERR("Invalid InformationClass!\n");
710 return STATUS_INVALID_PARAMETER;
711 }
712
713 Status = LsapValidateDbObject(PolicyHandle,
714 LsaDbPolicyObject,
715 DesiredAccess,
716 &PolicyObject);
717 if (!NT_SUCCESS(Status))
718 return Status;
719
720 switch (InformationClass)
721 {
722 case PolicyAuditLogInformation: /* 1 */
723 Status = LsarSetAuditLog(PolicyObject,
724 (PPOLICY_AUDIT_LOG_INFO)PolicyInformation);
725 break;
726
727 case PolicyAuditEventsInformation: /* 2 */
728 Status = LsarSetAuditEvents(PolicyObject,
729 (PLSAPR_POLICY_AUDIT_EVENTS_INFO)PolicyInformation);
730 if (NT_SUCCESS(Status))
731 LsapNotifyPolicyChange(PolicyNotifyAuditEventsInformation);
732 break;
733
734 case PolicyPrimaryDomainInformation: /* 3 */
735 Status = LsarSetPrimaryDomain(PolicyObject,
736 (PLSAPR_POLICY_PRIMARY_DOM_INFO)PolicyInformation);
737 if (NT_SUCCESS(Status))
738 LsapNotifyPolicyChange(PolicyNotifyDnsDomainInformation);
739 break;
740
741 case PolicyAccountDomainInformation: /* 5 */
742 Status = LsarSetAccountDomain(PolicyObject,
743 (PLSAPR_POLICY_ACCOUNT_DOM_INFO)PolicyInformation);
744 if (NT_SUCCESS(Status))
745 LsapNotifyPolicyChange(PolicyNotifyAccountDomainInformation);
746 break;
747
748 case PolicyLsaServerRoleInformation: /* 6 */
749 Status = LsarSetServerRole(PolicyObject,
750 (PPOLICY_LSA_SERVER_ROLE_INFO)PolicyInformation);
751 if (NT_SUCCESS(Status))
752 LsapNotifyPolicyChange(PolicyNotifyServerRoleInformation);
753 break;
754
755 case PolicyReplicaSourceInformation: /* 7 */
756 Status = LsarSetReplicaSource(PolicyObject,
757 (PPOLICY_LSA_REPLICA_SRCE_INFO)PolicyInformation);
758 break;
759
760 case PolicyDefaultQuotaInformation: /* 8 */
761 Status = LsarSetDefaultQuota(PolicyObject,
762 (PPOLICY_DEFAULT_QUOTA_INFO)PolicyInformation);
763 break;
764
765 case PolicyModificationInformation: /* 9 */
766 Status = LsarSetModification(PolicyObject,
767 (PPOLICY_MODIFICATION_INFO)PolicyInformation);
768 break;
769
770 case PolicyAuditFullSetInformation: /* 10 (0xA) */
771 Status = LsarSetAuditFull(PolicyObject,
772 (PPOLICY_AUDIT_FULL_QUERY_INFO)PolicyInformation);
773 break;
774
775 case PolicyDnsDomainInformation: /* 12 (0xC) */
776 Status = LsarSetDnsDomain(PolicyObject,
777 (PLSAPR_POLICY_DNS_DOMAIN_INFO)PolicyInformation);
778 if (NT_SUCCESS(Status))
779 LsapNotifyPolicyChange(PolicyNotifyDnsDomainInformation);
780 break;
781
782 case PolicyDnsDomainInformationInt: /* 13 (0xD) */
783 Status = LsarSetDnsDomainInt(PolicyObject,
784 (PLSAPR_POLICY_DNS_DOMAIN_INFO)PolicyInformation);
785 break;
786
787 case PolicyLocalAccountDomainInformation: /* 14 (0xE) */
788 Status = LsarSetLocalAccountDomain(PolicyObject,
789 (PLSAPR_POLICY_ACCOUNT_DOM_INFO)PolicyInformation);
790 break;
791
792 default:
793 Status = STATUS_INVALID_PARAMETER;
794 break;
795 }
796
797 return Status;
798 }
799
800
801 /* Function 9 */
802 NTSTATUS
803 WINAPI
LsarClearAuditLog(LSAPR_HANDLE ObjectHandle)804 LsarClearAuditLog(
805 LSAPR_HANDLE ObjectHandle)
806 {
807 /* Deprecated */
808 return STATUS_NOT_IMPLEMENTED;
809 }
810
811
812 NTSTATUS
LsarpCreateAccount(PLSA_DB_OBJECT PolicyObject,PRPC_SID AccountSid,ACCESS_MASK DesiredAccess,PLSA_DB_OBJECT * AccountObject)813 LsarpCreateAccount(
814 PLSA_DB_OBJECT PolicyObject,
815 PRPC_SID AccountSid,
816 ACCESS_MASK DesiredAccess,
817 PLSA_DB_OBJECT *AccountObject)
818 {
819 LPWSTR SidString = NULL;
820 PSECURITY_DESCRIPTOR AccountSd = NULL;
821 ULONG AccountSdSize;
822 NTSTATUS Status = STATUS_SUCCESS;
823
824 /* Create SID string */
825 if (!ConvertSidToStringSid((PSID)AccountSid,
826 &SidString))
827 {
828 ERR("ConvertSidToStringSid failed\n");
829 return STATUS_INVALID_PARAMETER;
830 }
831
832 /* Create a security descriptor for the account */
833 Status = LsapCreateAccountSd(&AccountSd,
834 &AccountSdSize);
835 if (!NT_SUCCESS(Status))
836 {
837 ERR("LsapCreateAccountSd returned 0x%08lx\n", Status);
838 goto done;
839 }
840
841 /* Create the Account object */
842 Status = LsapCreateDbObject(PolicyObject,
843 L"Accounts",
844 SidString,
845 LsaDbAccountObject,
846 DesiredAccess,
847 PolicyObject->Trusted,
848 AccountObject);
849 if (!NT_SUCCESS(Status))
850 {
851 ERR("LsapCreateDbObject failed (Status 0x%08lx)\n", Status);
852 goto done;
853 }
854
855 /* Set the Sid attribute */
856 Status = LsapSetObjectAttribute(*AccountObject,
857 L"Sid",
858 (PVOID)AccountSid,
859 GetLengthSid(AccountSid));
860 if (!NT_SUCCESS(Status))
861 goto done;
862
863 /* Set the SecDesc attribute */
864 Status = LsapSetObjectAttribute(*AccountObject,
865 L"SecDesc",
866 AccountSd,
867 AccountSdSize);
868
869 done:
870 if (SidString != NULL)
871 LocalFree(SidString);
872
873 if (AccountSd != NULL)
874 RtlFreeHeap(RtlGetProcessHeap(), 0, AccountSd);
875
876 return Status;
877 }
878
879
880 /* Function 10 */
881 NTSTATUS
882 WINAPI
LsarCreateAccount(LSAPR_HANDLE PolicyHandle,PRPC_SID AccountSid,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * AccountHandle)883 LsarCreateAccount(
884 LSAPR_HANDLE PolicyHandle,
885 PRPC_SID AccountSid,
886 ACCESS_MASK DesiredAccess,
887 LSAPR_HANDLE *AccountHandle)
888 {
889 PLSA_DB_OBJECT PolicyObject;
890 PLSA_DB_OBJECT AccountObject = NULL;
891 NTSTATUS Status = STATUS_SUCCESS;
892
893 TRACE("LsarCreateAccount(%p %p %lx %p)\n",
894 PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
895
896 /* Validate the AccountSid */
897 if (!RtlValidSid(AccountSid))
898 return STATUS_INVALID_PARAMETER;
899
900 /* Validate the PolicyHandle */
901 Status = LsapValidateDbObject(PolicyHandle,
902 LsaDbPolicyObject,
903 POLICY_CREATE_ACCOUNT,
904 &PolicyObject);
905 if (!NT_SUCCESS(Status))
906 {
907 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
908 return Status;
909 }
910
911
912 Status = LsarpCreateAccount(PolicyObject,
913 AccountSid,
914 DesiredAccess,
915 &AccountObject);
916 if (NT_SUCCESS(Status))
917 {
918 *AccountHandle = (LSAPR_HANDLE)AccountObject;
919 }
920
921 return Status;
922 }
923
924
925 /* Function 11 */
926 NTSTATUS
927 WINAPI
LsarEnumerateAccounts(LSAPR_HANDLE PolicyHandle,DWORD * EnumerationContext,PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer,DWORD PreferedMaximumLength)928 LsarEnumerateAccounts(
929 LSAPR_HANDLE PolicyHandle,
930 DWORD *EnumerationContext,
931 PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer,
932 DWORD PreferedMaximumLength)
933 {
934 LSAPR_ACCOUNT_ENUM_BUFFER EnumBuffer = {0, NULL};
935 PLSA_DB_OBJECT PolicyObject = NULL;
936 PWSTR AccountKeyBuffer = NULL;
937 HANDLE AccountsKeyHandle = NULL;
938 HANDLE AccountKeyHandle;
939 HANDLE SidKeyHandle;
940 ULONG AccountKeyBufferSize;
941 ULONG EnumIndex;
942 ULONG EnumCount;
943 ULONG RequiredLength;
944 ULONG DataLength;
945 ULONG i;
946 NTSTATUS Status = STATUS_SUCCESS;
947
948 TRACE("LsarEnumerateAccount(%p %p %p %lu)\n",
949 PolicyHandle, EnumerationContext, EnumerationBuffer, PreferedMaximumLength);
950
951 if (EnumerationContext == NULL ||
952 EnumerationBuffer == NULL)
953 return STATUS_INVALID_PARAMETER;
954
955 EnumerationBuffer->EntriesRead = 0;
956 EnumerationBuffer->Information = NULL;
957
958 /* Validate the PolicyHandle */
959 Status = LsapValidateDbObject(PolicyHandle,
960 LsaDbPolicyObject,
961 POLICY_VIEW_LOCAL_INFORMATION,
962 &PolicyObject);
963 if (!NT_SUCCESS(Status))
964 {
965 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
966 return Status;
967 }
968
969 Status = LsapRegOpenKey(PolicyObject->KeyHandle,
970 L"Accounts",
971 KEY_READ,
972 &AccountsKeyHandle);
973 if (!NT_SUCCESS(Status))
974 return Status;
975
976 Status = LsapRegQueryKeyInfo(AccountsKeyHandle,
977 NULL,
978 &AccountKeyBufferSize,
979 NULL);
980 if (!NT_SUCCESS(Status))
981 {
982 ERR("LsapRegQueryKeyInfo returned 0x%08lx\n", Status);
983 return Status;
984 }
985
986 AccountKeyBufferSize += sizeof(WCHAR);
987 AccountKeyBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, AccountKeyBufferSize);
988 if (AccountKeyBuffer == NULL)
989 {
990 return STATUS_NO_MEMORY;
991 }
992
993 EnumIndex = *EnumerationContext;
994 EnumCount = 0;
995 RequiredLength = 0;
996
997 while (TRUE)
998 {
999 Status = LsapRegEnumerateSubKey(AccountsKeyHandle,
1000 EnumIndex,
1001 AccountKeyBufferSize,
1002 AccountKeyBuffer);
1003 if (!NT_SUCCESS(Status))
1004 break;
1005
1006 TRACE("EnumIndex: %lu\n", EnumIndex);
1007 TRACE("Account key name: %S\n", AccountKeyBuffer);
1008
1009 Status = LsapRegOpenKey(AccountsKeyHandle,
1010 AccountKeyBuffer,
1011 KEY_READ,
1012 &AccountKeyHandle);
1013 TRACE("LsapRegOpenKey returned %08lX\n", Status);
1014 if (NT_SUCCESS(Status))
1015 {
1016 Status = LsapRegOpenKey(AccountKeyHandle,
1017 L"Sid",
1018 KEY_READ,
1019 &SidKeyHandle);
1020 TRACE("LsapRegOpenKey returned %08lX\n", Status);
1021 if (NT_SUCCESS(Status))
1022 {
1023 DataLength = 0;
1024 Status = LsapRegQueryValue(SidKeyHandle,
1025 NULL,
1026 NULL,
1027 NULL,
1028 &DataLength);
1029 TRACE("LsapRegQueryValue returned %08lX\n", Status);
1030 if (NT_SUCCESS(Status))
1031 {
1032 TRACE("Data length: %lu\n", DataLength);
1033
1034 if ((RequiredLength + DataLength + sizeof(LSAPR_ACCOUNT_INFORMATION)) > PreferedMaximumLength)
1035 break;
1036
1037 RequiredLength += (DataLength + sizeof(LSAPR_ACCOUNT_INFORMATION));
1038 EnumCount++;
1039 }
1040
1041 LsapRegCloseKey(SidKeyHandle);
1042 }
1043
1044 LsapRegCloseKey(AccountKeyHandle);
1045 }
1046
1047 EnumIndex++;
1048 }
1049
1050 TRACE("EnumCount: %lu\n", EnumCount);
1051 TRACE("RequiredLength: %lu\n", RequiredLength);
1052
1053 EnumBuffer.EntriesRead = EnumCount;
1054 EnumBuffer.Information = midl_user_allocate(EnumCount * sizeof(LSAPR_ACCOUNT_INFORMATION));
1055 if (EnumBuffer.Information == NULL)
1056 {
1057 Status = STATUS_INSUFFICIENT_RESOURCES;
1058 goto done;
1059 }
1060
1061 EnumIndex = *EnumerationContext;
1062 for (i = 0; i < EnumCount; i++, EnumIndex++)
1063 {
1064 Status = LsapRegEnumerateSubKey(AccountsKeyHandle,
1065 EnumIndex,
1066 AccountKeyBufferSize,
1067 AccountKeyBuffer);
1068 if (!NT_SUCCESS(Status))
1069 break;
1070
1071 TRACE("EnumIndex: %lu\n", EnumIndex);
1072 TRACE("Account key name: %S\n", AccountKeyBuffer);
1073
1074 Status = LsapRegOpenKey(AccountsKeyHandle,
1075 AccountKeyBuffer,
1076 KEY_READ,
1077 &AccountKeyHandle);
1078 TRACE("LsapRegOpenKey returned %08lX\n", Status);
1079 if (NT_SUCCESS(Status))
1080 {
1081 Status = LsapRegOpenKey(AccountKeyHandle,
1082 L"Sid",
1083 KEY_READ,
1084 &SidKeyHandle);
1085 TRACE("LsapRegOpenKey returned %08lX\n", Status);
1086 if (NT_SUCCESS(Status))
1087 {
1088 DataLength = 0;
1089 Status = LsapRegQueryValue(SidKeyHandle,
1090 NULL,
1091 NULL,
1092 NULL,
1093 &DataLength);
1094 TRACE("LsapRegQueryValue returned %08lX\n", Status);
1095 if (NT_SUCCESS(Status))
1096 {
1097 EnumBuffer.Information[i].Sid = midl_user_allocate(DataLength);
1098 if (EnumBuffer.Information[i].Sid == NULL)
1099 {
1100 LsapRegCloseKey(AccountKeyHandle);
1101 Status = STATUS_INSUFFICIENT_RESOURCES;
1102 goto done;
1103 }
1104
1105 Status = LsapRegQueryValue(SidKeyHandle,
1106 NULL,
1107 NULL,
1108 EnumBuffer.Information[i].Sid,
1109 &DataLength);
1110 TRACE("SampRegQueryValue returned %08lX\n", Status);
1111 }
1112
1113 LsapRegCloseKey(SidKeyHandle);
1114 }
1115
1116 LsapRegCloseKey(AccountKeyHandle);
1117
1118 if (!NT_SUCCESS(Status))
1119 goto done;
1120 }
1121 }
1122
1123 if (NT_SUCCESS(Status))
1124 {
1125 *EnumerationContext += EnumCount;
1126 EnumerationBuffer->EntriesRead = EnumBuffer.EntriesRead;
1127 EnumerationBuffer->Information = EnumBuffer.Information;
1128 }
1129
1130 done:
1131 if (!NT_SUCCESS(Status))
1132 {
1133 if (EnumBuffer.Information)
1134 {
1135 for (i = 0; i < EnumBuffer.EntriesRead; i++)
1136 {
1137 if (EnumBuffer.Information[i].Sid != NULL)
1138 midl_user_free(EnumBuffer.Information[i].Sid);
1139 }
1140
1141 midl_user_free(EnumBuffer.Information);
1142 }
1143 }
1144
1145 if (AccountKeyBuffer != NULL)
1146 RtlFreeHeap(RtlGetProcessHeap(), 0, AccountKeyBuffer);
1147
1148 if (AccountsKeyHandle != NULL)
1149 LsapRegCloseKey(AccountsKeyHandle);
1150
1151 return Status;
1152 }
1153
1154
1155 /* Function 12 */
1156 NTSTATUS
1157 WINAPI
LsarCreateTrustedDomain(LSAPR_HANDLE PolicyHandle,PLSAPR_TRUST_INFORMATION TrustedDomainInformation,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * TrustedDomainHandle)1158 LsarCreateTrustedDomain(
1159 LSAPR_HANDLE PolicyHandle,
1160 PLSAPR_TRUST_INFORMATION TrustedDomainInformation,
1161 ACCESS_MASK DesiredAccess,
1162 LSAPR_HANDLE *TrustedDomainHandle)
1163 {
1164 /* Fail, if we are not a domain controller */
1165 if (LsapProductType != NtProductLanManNt)
1166 return STATUS_DIRECTORY_SERVICE_REQUIRED;
1167
1168 UNIMPLEMENTED;
1169 return STATUS_NOT_IMPLEMENTED;
1170 }
1171
1172
1173 /* Function 13 */
1174 NTSTATUS
1175 WINAPI
LsarEnumerateTrustedDomains(LSAPR_HANDLE PolicyHandle,DWORD * EnumerationContext,PLSAPR_TRUSTED_ENUM_BUFFER EnumerationBuffer,DWORD PreferedMaximumLength)1176 LsarEnumerateTrustedDomains(
1177 LSAPR_HANDLE PolicyHandle,
1178 DWORD *EnumerationContext,
1179 PLSAPR_TRUSTED_ENUM_BUFFER EnumerationBuffer,
1180 DWORD PreferedMaximumLength)
1181 {
1182 /* FIXME: We are not running an AD yet */
1183 EnumerationBuffer->EntriesRead = 0;
1184 EnumerationBuffer->Information = NULL;
1185 return STATUS_NO_MORE_ENTRIES;
1186 }
1187
1188
1189 /* Function 14 */
1190 NTSTATUS
1191 WINAPI
LsarLookupNames(LSAPR_HANDLE PolicyHandle,DWORD Count,PRPC_UNICODE_STRING Names,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_SIDS TranslatedSids,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount)1192 LsarLookupNames(
1193 LSAPR_HANDLE PolicyHandle,
1194 DWORD Count,
1195 PRPC_UNICODE_STRING Names,
1196 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1197 PLSAPR_TRANSLATED_SIDS TranslatedSids,
1198 LSAP_LOOKUP_LEVEL LookupLevel,
1199 DWORD *MappedCount)
1200 {
1201 LSAPR_TRANSLATED_SIDS_EX2 TranslatedSidsEx2;
1202 ULONG i;
1203 NTSTATUS Status;
1204
1205 TRACE("LsarLookupNames(%p %lu %p %p %p %d %p)\n",
1206 PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
1207 LookupLevel, MappedCount);
1208
1209 TranslatedSids->Entries = 0;
1210 TranslatedSids->Sids = NULL;
1211 *ReferencedDomains = NULL;
1212
1213 if (Count == 0)
1214 return STATUS_NONE_MAPPED;
1215
1216 TranslatedSidsEx2.Entries = 0;
1217 TranslatedSidsEx2.Sids = NULL;
1218
1219 Status = LsapLookupNames(Count,
1220 Names,
1221 ReferencedDomains,
1222 &TranslatedSidsEx2,
1223 LookupLevel,
1224 MappedCount,
1225 0,
1226 0);
1227 if (!NT_SUCCESS(Status))
1228 return Status;
1229
1230 TranslatedSids->Entries = TranslatedSidsEx2.Entries;
1231 TranslatedSids->Sids = MIDL_user_allocate(TranslatedSids->Entries * sizeof(LSA_TRANSLATED_SID));
1232 if (TranslatedSids->Sids == NULL)
1233 {
1234 MIDL_user_free(TranslatedSidsEx2.Sids);
1235 MIDL_user_free(*ReferencedDomains);
1236 *ReferencedDomains = NULL;
1237 return STATUS_INSUFFICIENT_RESOURCES;
1238 }
1239
1240 for (i = 0; i < TranslatedSidsEx2.Entries; i++)
1241 {
1242 TranslatedSids->Sids[i].Use = TranslatedSidsEx2.Sids[i].Use;
1243 TranslatedSids->Sids[i].RelativeId = LsapGetRelativeIdFromSid(TranslatedSidsEx2.Sids[i].Sid);
1244 TranslatedSids->Sids[i].DomainIndex = TranslatedSidsEx2.Sids[i].DomainIndex;
1245 }
1246
1247 MIDL_user_free(TranslatedSidsEx2.Sids);
1248
1249 return STATUS_SUCCESS;
1250 }
1251
1252
1253 /* Function 15 */
1254 NTSTATUS
1255 WINAPI
LsarLookupSids(LSAPR_HANDLE PolicyHandle,PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_NAMES TranslatedNames,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount)1256 LsarLookupSids(
1257 LSAPR_HANDLE PolicyHandle,
1258 PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
1259 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1260 PLSAPR_TRANSLATED_NAMES TranslatedNames,
1261 LSAP_LOOKUP_LEVEL LookupLevel,
1262 DWORD *MappedCount)
1263 {
1264 LSAPR_TRANSLATED_NAMES_EX TranslatedNamesEx;
1265 ULONG i;
1266 NTSTATUS Status;
1267
1268 TRACE("LsarLookupSids(%p %p %p %p %d %p)\n",
1269 PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
1270 LookupLevel, MappedCount);
1271
1272 /* FIXME: Fail, if there is an invalid SID in the SidEnumBuffer */
1273
1274 TranslatedNames->Entries = SidEnumBuffer->Entries;
1275 TranslatedNames->Names = NULL;
1276 *ReferencedDomains = NULL;
1277
1278 TranslatedNamesEx.Entries = SidEnumBuffer->Entries;
1279 TranslatedNamesEx.Names = NULL;
1280
1281 Status = LsapLookupSids(SidEnumBuffer,
1282 ReferencedDomains,
1283 &TranslatedNamesEx,
1284 LookupLevel,
1285 MappedCount,
1286 0,
1287 0);
1288 if (!NT_SUCCESS(Status))
1289 return Status;
1290
1291 TranslatedNames->Entries = SidEnumBuffer->Entries;
1292 TranslatedNames->Names = MIDL_user_allocate(SidEnumBuffer->Entries * sizeof(LSAPR_TRANSLATED_NAME));
1293 if (TranslatedNames->Names == NULL)
1294 {
1295 MIDL_user_free(TranslatedNamesEx.Names);
1296 MIDL_user_free(*ReferencedDomains);
1297 *ReferencedDomains = NULL;
1298 return STATUS_INSUFFICIENT_RESOURCES;
1299 }
1300
1301 for (i = 0; i < TranslatedNamesEx.Entries; i++)
1302 {
1303 TranslatedNames->Names[i].Use = TranslatedNamesEx.Names[i].Use;
1304 TranslatedNames->Names[i].Name.Length = TranslatedNamesEx.Names[i].Name.Length;
1305 TranslatedNames->Names[i].Name.MaximumLength = TranslatedNamesEx.Names[i].Name.MaximumLength;
1306 TranslatedNames->Names[i].Name.Buffer = TranslatedNamesEx.Names[i].Name.Buffer;
1307 TranslatedNames->Names[i].DomainIndex = TranslatedNamesEx.Names[i].DomainIndex;
1308 }
1309
1310 MIDL_user_free(TranslatedNamesEx.Names);
1311
1312 return Status;
1313 }
1314
1315
1316 /* Function 16 */
1317 NTSTATUS
1318 WINAPI
LsarCreateSecret(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING SecretName,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * SecretHandle)1319 LsarCreateSecret(
1320 LSAPR_HANDLE PolicyHandle,
1321 PRPC_UNICODE_STRING SecretName,
1322 ACCESS_MASK DesiredAccess,
1323 LSAPR_HANDLE *SecretHandle)
1324 {
1325 PLSA_DB_OBJECT PolicyObject;
1326 PLSA_DB_OBJECT SecretObject = NULL;
1327 LARGE_INTEGER Time;
1328 PSECURITY_DESCRIPTOR SecretSd = NULL;
1329 ULONG SecretSdSize;
1330 NTSTATUS Status = STATUS_SUCCESS;
1331
1332 TRACE("LsarCreateSecret(%p %wZ %lx %p)\n",
1333 PolicyHandle, SecretName, DesiredAccess, SecretHandle);
1334
1335 /* Validate the PolicyHandle */
1336 Status = LsapValidateDbObject(PolicyHandle,
1337 LsaDbPolicyObject,
1338 POLICY_CREATE_SECRET,
1339 &PolicyObject);
1340 if (!NT_SUCCESS(Status))
1341 {
1342 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1343 return Status;
1344 }
1345
1346 /* Get the current time */
1347 Status = NtQuerySystemTime(&Time);
1348 if (!NT_SUCCESS(Status))
1349 {
1350 ERR("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
1351 goto done;
1352 }
1353
1354 /* Create a security descriptor for the secret */
1355 Status = LsapCreateSecretSd(&SecretSd,
1356 &SecretSdSize);
1357 if (!NT_SUCCESS(Status))
1358 {
1359 ERR("LsapCreateAccountSd returned 0x%08lx\n", Status);
1360 return Status;
1361 }
1362
1363 /* Create the Secret object */
1364 Status = LsapCreateDbObject(PolicyObject,
1365 L"Secrets",
1366 SecretName->Buffer,
1367 LsaDbSecretObject,
1368 DesiredAccess,
1369 PolicyObject->Trusted,
1370 &SecretObject);
1371 if (!NT_SUCCESS(Status))
1372 {
1373 ERR("LsapCreateDbObject failed (Status 0x%08lx)\n", Status);
1374 goto done;
1375 }
1376
1377 /* Set the CurrentTime attribute */
1378 Status = LsapSetObjectAttribute(SecretObject,
1379 L"CurrentTime",
1380 (PVOID)&Time,
1381 sizeof(LARGE_INTEGER));
1382 if (!NT_SUCCESS(Status))
1383 {
1384 ERR("LsapSetObjectAttribute (CurrentTime) failed (Status 0x%08lx)\n", Status);
1385 goto done;
1386 }
1387
1388 /* Set the OldTime attribute */
1389 Status = LsapSetObjectAttribute(SecretObject,
1390 L"OldTime",
1391 (PVOID)&Time,
1392 sizeof(LARGE_INTEGER));
1393 if (!NT_SUCCESS(Status))
1394 {
1395 ERR("LsapSetObjectAttribute (OldTime) failed (Status 0x%08lx)\n", Status);
1396 goto done;
1397 }
1398
1399 /* Set the SecDesc attribute */
1400 Status = LsapSetObjectAttribute(SecretObject,
1401 L"SecDesc",
1402 SecretSd,
1403 SecretSdSize);
1404
1405 done:
1406 if (SecretSd != NULL)
1407 RtlFreeHeap(RtlGetProcessHeap(), 0, SecretSd);
1408
1409 if (!NT_SUCCESS(Status))
1410 {
1411 if (SecretObject != NULL)
1412 LsapCloseDbObject(SecretObject);
1413 }
1414 else
1415 {
1416 *SecretHandle = (LSAPR_HANDLE)SecretObject;
1417 }
1418
1419 return STATUS_SUCCESS;
1420 }
1421
1422
1423 static
1424 NTSTATUS
LsarpOpenAccount(IN PLSA_DB_OBJECT PolicyObject,IN PRPC_SID AccountSid,IN ACCESS_MASK DesiredAccess,OUT PLSA_DB_OBJECT * AccountObject)1425 LsarpOpenAccount(
1426 IN PLSA_DB_OBJECT PolicyObject,
1427 IN PRPC_SID AccountSid,
1428 IN ACCESS_MASK DesiredAccess,
1429 OUT PLSA_DB_OBJECT *AccountObject)
1430 {
1431 LPWSTR SidString = NULL;
1432 NTSTATUS Status = STATUS_SUCCESS;
1433
1434 /* Create SID string */
1435 if (!ConvertSidToStringSid((PSID)AccountSid,
1436 &SidString))
1437 {
1438 ERR("ConvertSidToStringSid failed\n");
1439 return STATUS_INVALID_PARAMETER;
1440 }
1441
1442 /* Create the Account object */
1443 Status = LsapOpenDbObject(PolicyObject,
1444 L"Accounts",
1445 SidString,
1446 LsaDbAccountObject,
1447 DesiredAccess,
1448 PolicyObject->Trusted,
1449 AccountObject);
1450 if (!NT_SUCCESS(Status))
1451 {
1452 ERR("LsapOpenDbObject(Accounts/%S) failed (Status 0x%08lx)\n", SidString, Status);
1453 }
1454
1455 if (SidString != NULL)
1456 LocalFree(SidString);
1457
1458 return Status;
1459 }
1460
1461
1462 /* Function 17 */
1463 NTSTATUS
1464 WINAPI
LsarOpenAccount(LSAPR_HANDLE PolicyHandle,PRPC_SID AccountSid,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * AccountHandle)1465 LsarOpenAccount(
1466 LSAPR_HANDLE PolicyHandle,
1467 PRPC_SID AccountSid,
1468 ACCESS_MASK DesiredAccess,
1469 LSAPR_HANDLE *AccountHandle)
1470 {
1471 PLSA_DB_OBJECT PolicyObject;
1472 NTSTATUS Status;
1473
1474 TRACE("LsarOpenAccount(%p %p %lx %p)\n",
1475 PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
1476
1477 /* Validate the AccountSid */
1478 if (!RtlValidSid(AccountSid))
1479 return STATUS_INVALID_PARAMETER;
1480
1481 /* Validate the PolicyHandle */
1482 Status = LsapValidateDbObject(PolicyHandle,
1483 LsaDbPolicyObject,
1484 0,
1485 &PolicyObject);
1486 if (!NT_SUCCESS(Status))
1487 {
1488 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1489 return Status;
1490 }
1491
1492
1493 /* Open the Account object */
1494 return LsarpOpenAccount(PolicyObject,
1495 AccountSid,
1496 DesiredAccess,
1497 (PLSA_DB_OBJECT *)AccountHandle);
1498 }
1499
1500
1501 /* Function 18 */
1502 NTSTATUS
1503 WINAPI
LsarEnumeratePrivilegesAccount(LSAPR_HANDLE AccountHandle,PLSAPR_PRIVILEGE_SET * Privileges)1504 LsarEnumeratePrivilegesAccount(
1505 LSAPR_HANDLE AccountHandle,
1506 PLSAPR_PRIVILEGE_SET *Privileges)
1507 {
1508 PLSA_DB_OBJECT AccountObject;
1509 ULONG PrivilegeSetSize = 0;
1510 PLSAPR_PRIVILEGE_SET PrivilegeSet = NULL;
1511 NTSTATUS Status;
1512
1513 TRACE("LsarEnumeratePrivilegesAccount(%p %p)\n",
1514 AccountHandle, Privileges);
1515
1516 *Privileges = NULL;
1517
1518 /* Validate the AccountHandle */
1519 Status = LsapValidateDbObject(AccountHandle,
1520 LsaDbAccountObject,
1521 ACCOUNT_VIEW,
1522 &AccountObject);
1523 if (!NT_SUCCESS(Status))
1524 {
1525 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1526 return Status;
1527 }
1528
1529 /* Get the size of the privilege set */
1530 Status = LsapGetObjectAttribute(AccountObject,
1531 L"Privilgs",
1532 NULL,
1533 &PrivilegeSetSize);
1534 if (!NT_SUCCESS(Status))
1535 return Status;
1536
1537 /* Allocate a buffer for the privilege set */
1538 PrivilegeSet = MIDL_user_allocate(PrivilegeSetSize);
1539 if (PrivilegeSet == NULL)
1540 return STATUS_NO_MEMORY;
1541
1542 /* Get the privilege set */
1543 Status = LsapGetObjectAttribute(AccountObject,
1544 L"Privilgs",
1545 PrivilegeSet,
1546 &PrivilegeSetSize);
1547 if (!NT_SUCCESS(Status))
1548 {
1549 MIDL_user_free(PrivilegeSet);
1550 return Status;
1551 }
1552
1553 /* Return a pointer to the privilege set */
1554 *Privileges = PrivilegeSet;
1555
1556 return STATUS_SUCCESS;
1557 }
1558
1559
1560 /* Function 19 */
1561 NTSTATUS
1562 WINAPI
LsarAddPrivilegesToAccount(LSAPR_HANDLE AccountHandle,PLSAPR_PRIVILEGE_SET Privileges)1563 LsarAddPrivilegesToAccount(
1564 LSAPR_HANDLE AccountHandle,
1565 PLSAPR_PRIVILEGE_SET Privileges)
1566 {
1567 PLSA_DB_OBJECT AccountObject;
1568 PPRIVILEGE_SET CurrentPrivileges = NULL;
1569 PPRIVILEGE_SET NewPrivileges = NULL;
1570 ULONG PrivilegeSetSize = 0;
1571 ULONG PrivilegeCount;
1572 ULONG i, j;
1573 BOOL bFound;
1574 NTSTATUS Status;
1575
1576 TRACE("LsarAddPrivilegesToAccount(%p %p)\n",
1577 AccountHandle, Privileges);
1578
1579 /* Validate the AccountHandle */
1580 Status = LsapValidateDbObject(AccountHandle,
1581 LsaDbAccountObject,
1582 ACCOUNT_ADJUST_PRIVILEGES,
1583 &AccountObject);
1584 if (!NT_SUCCESS(Status))
1585 {
1586 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1587 return Status;
1588 }
1589
1590 /* Get the size of the Privilgs attribute */
1591 Status = LsapGetObjectAttribute(AccountObject,
1592 L"Privilgs",
1593 NULL,
1594 &PrivilegeSetSize);
1595 if (!NT_SUCCESS(Status) || PrivilegeSetSize == 0)
1596 {
1597 /* The Privilgs attribute does not exist */
1598
1599 PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
1600 (Privileges->PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
1601 Status = LsapSetObjectAttribute(AccountObject,
1602 L"Privilgs",
1603 Privileges,
1604 PrivilegeSetSize);
1605 }
1606 else
1607 {
1608 /* The Privilgs attribute exists */
1609
1610 /* Allocate memory for the stored privilege set */
1611 CurrentPrivileges = MIDL_user_allocate(PrivilegeSetSize);
1612 if (CurrentPrivileges == NULL)
1613 return STATUS_NO_MEMORY;
1614
1615 /* Get the current privilege set */
1616 Status = LsapGetObjectAttribute(AccountObject,
1617 L"Privilgs",
1618 CurrentPrivileges,
1619 &PrivilegeSetSize);
1620 if (!NT_SUCCESS(Status))
1621 {
1622 TRACE("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
1623 goto done;
1624 }
1625
1626 PrivilegeCount = CurrentPrivileges->PrivilegeCount;
1627 TRACE("Current privilege count: %lu\n", PrivilegeCount);
1628
1629 /* Calculate the number of privileges in the combined privilege set */
1630 for (i = 0; i < Privileges->PrivilegeCount; i++)
1631 {
1632 bFound = FALSE;
1633 for (j = 0; j < CurrentPrivileges->PrivilegeCount; j++)
1634 {
1635 if (RtlEqualLuid(&(Privileges->Privilege[i].Luid),
1636 &(CurrentPrivileges->Privilege[i].Luid)))
1637 {
1638 bFound = TRUE;
1639 break;
1640 }
1641 }
1642
1643 if (bFound == FALSE)
1644 {
1645 TRACE("Found new privilege\n");
1646 PrivilegeCount++;
1647 }
1648 }
1649 TRACE("New privilege count: %lu\n", PrivilegeCount);
1650
1651 /* Calculate the size of the new privilege set and allocate it */
1652 PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
1653 (PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
1654 NewPrivileges = MIDL_user_allocate(PrivilegeSetSize);
1655 if (NewPrivileges == NULL)
1656 {
1657 Status = STATUS_NO_MEMORY;
1658 goto done;
1659 }
1660
1661 /* Initialize the new privilege set */
1662 NewPrivileges->PrivilegeCount = PrivilegeCount;
1663 NewPrivileges->Control = 0;
1664
1665 /* Copy all privileges from the current privilege set */
1666 RtlCopyLuidAndAttributesArray(CurrentPrivileges->PrivilegeCount,
1667 &(CurrentPrivileges->Privilege[0]),
1668 &(NewPrivileges->Privilege[0]));
1669
1670 /* Add new privileges to the new privilege set */
1671 PrivilegeCount = CurrentPrivileges->PrivilegeCount;
1672 for (i = 0; i < Privileges->PrivilegeCount; i++)
1673 {
1674 bFound = FALSE;
1675 for (j = 0; j < CurrentPrivileges->PrivilegeCount; j++)
1676 {
1677 if (RtlEqualLuid(&(Privileges->Privilege[i].Luid),
1678 &(CurrentPrivileges->Privilege[i].Luid)))
1679 {
1680 /* Overwrite attributes if a matching privilege was found */
1681 NewPrivileges->Privilege[j].Attributes = Privileges->Privilege[i].Attributes;
1682
1683 bFound = TRUE;
1684 break;
1685 }
1686 }
1687
1688 if (bFound == FALSE)
1689 {
1690 /* Copy the new privilege */
1691 RtlCopyLuidAndAttributesArray(1,
1692 (PLUID_AND_ATTRIBUTES)&(Privileges->Privilege[i]),
1693 &(NewPrivileges->Privilege[PrivilegeCount]));
1694 PrivilegeCount++;
1695 }
1696 }
1697
1698 /* Set the new privilege set */
1699 Status = LsapSetObjectAttribute(AccountObject,
1700 L"Privilgs",
1701 NewPrivileges,
1702 PrivilegeSetSize);
1703 }
1704
1705 done:
1706 if (CurrentPrivileges != NULL)
1707 MIDL_user_free(CurrentPrivileges);
1708
1709 if (NewPrivileges != NULL)
1710 MIDL_user_free(NewPrivileges);
1711
1712 return Status;
1713 }
1714
1715
1716 /* Function 20 */
1717 NTSTATUS
1718 WINAPI
LsarRemovePrivilegesFromAccount(LSAPR_HANDLE AccountHandle,BOOLEAN AllPrivileges,PLSAPR_PRIVILEGE_SET Privileges)1719 LsarRemovePrivilegesFromAccount(
1720 LSAPR_HANDLE AccountHandle,
1721 BOOLEAN AllPrivileges,
1722 PLSAPR_PRIVILEGE_SET Privileges)
1723 {
1724 PLSA_DB_OBJECT AccountObject;
1725 PPRIVILEGE_SET CurrentPrivileges = NULL;
1726 PPRIVILEGE_SET NewPrivileges = NULL;
1727 ULONG PrivilegeSetSize = 0;
1728 ULONG PrivilegeCount;
1729 ULONG i, j, k;
1730 BOOL bFound;
1731 NTSTATUS Status;
1732
1733 TRACE("LsarRemovePrivilegesFromAccount(%p %u %p)\n",
1734 AccountHandle, AllPrivileges, Privileges);
1735
1736 /* */
1737 if (((AllPrivileges == FALSE) && (Privileges == NULL)) ||
1738 ((AllPrivileges != FALSE) && (Privileges != NULL)))
1739 return STATUS_INVALID_PARAMETER;
1740
1741 /* Validate the AccountHandle */
1742 Status = LsapValidateDbObject(AccountHandle,
1743 LsaDbAccountObject,
1744 ACCOUNT_ADJUST_PRIVILEGES,
1745 &AccountObject);
1746 if (!NT_SUCCESS(Status))
1747 {
1748 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1749 return Status;
1750 }
1751
1752 if (AllPrivileges != FALSE)
1753 {
1754 /* Delete the Privilgs attribute */
1755 Status = LsapDeleteObjectAttribute(AccountObject,
1756 L"Privilgs");
1757 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
1758 Status = STATUS_SUCCESS;
1759 }
1760 else
1761 {
1762 /* Get the size of the Privilgs attribute */
1763 Status = LsapGetObjectAttribute(AccountObject,
1764 L"Privilgs",
1765 NULL,
1766 &PrivilegeSetSize);
1767 if (!NT_SUCCESS(Status))
1768 goto done;
1769
1770 /* Succeed, if there is no privilege set to remove privileges from */
1771 if (PrivilegeSetSize == 0)
1772 {
1773 Status = STATUS_SUCCESS;
1774 goto done;
1775 }
1776
1777 /* Allocate memory for the stored privilege set */
1778 CurrentPrivileges = MIDL_user_allocate(PrivilegeSetSize);
1779 if (CurrentPrivileges == NULL)
1780 return STATUS_NO_MEMORY;
1781
1782 /* Get the current privilege set */
1783 Status = LsapGetObjectAttribute(AccountObject,
1784 L"Privilgs",
1785 CurrentPrivileges,
1786 &PrivilegeSetSize);
1787 if (!NT_SUCCESS(Status))
1788 {
1789 TRACE("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
1790 goto done;
1791 }
1792
1793 PrivilegeCount = CurrentPrivileges->PrivilegeCount;
1794 TRACE("Current privilege count: %lu\n", PrivilegeCount);
1795
1796 /* Calculate the number of privileges in the new privilege set */
1797 for (i = 0; i < CurrentPrivileges->PrivilegeCount; i++)
1798 {
1799 for (j = 0; j < Privileges->PrivilegeCount; j++)
1800 {
1801 if (RtlEqualLuid(&(CurrentPrivileges->Privilege[i].Luid),
1802 &(Privileges->Privilege[j].Luid)))
1803 {
1804 if (PrivilegeCount > 0)
1805 PrivilegeCount--;
1806 }
1807 }
1808 }
1809 TRACE("New privilege count: %lu\n", PrivilegeCount);
1810
1811 if (PrivilegeCount == 0)
1812 {
1813 /* Delete the Privilgs attribute */
1814 Status = LsapDeleteObjectAttribute(AccountObject,
1815 L"Privilgs");
1816 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
1817 Status = STATUS_SUCCESS;
1818 }
1819 else
1820 {
1821 /* Calculate the size of the new privilege set and allocate it */
1822 PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
1823 (PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
1824 NewPrivileges = MIDL_user_allocate(PrivilegeSetSize);
1825 if (NewPrivileges == NULL)
1826 {
1827 Status = STATUS_NO_MEMORY;
1828 goto done;
1829 }
1830
1831 /* Initialize the new privilege set */
1832 NewPrivileges->PrivilegeCount = PrivilegeCount;
1833 NewPrivileges->Control = 0;
1834
1835 /* Copy the privileges which are not to be removed */
1836 for (i = 0, k = 0; i < CurrentPrivileges->PrivilegeCount; i++)
1837 {
1838 bFound = FALSE;
1839 for (j = 0; j < Privileges->PrivilegeCount; j++)
1840 {
1841 if (RtlEqualLuid(&(CurrentPrivileges->Privilege[i].Luid),
1842 &(Privileges->Privilege[j].Luid)))
1843 bFound = TRUE;
1844 }
1845
1846 if (bFound == FALSE)
1847 {
1848 /* Copy the privilege */
1849 RtlCopyLuidAndAttributesArray(1,
1850 &(CurrentPrivileges->Privilege[i]),
1851 &(NewPrivileges->Privilege[k]));
1852 k++;
1853 }
1854 }
1855
1856 /* Set the new privilege set */
1857 Status = LsapSetObjectAttribute(AccountObject,
1858 L"Privilgs",
1859 NewPrivileges,
1860 PrivilegeSetSize);
1861 }
1862 }
1863
1864 done:
1865 if (CurrentPrivileges != NULL)
1866 MIDL_user_free(CurrentPrivileges);
1867
1868 if (NewPrivileges != NULL)
1869 MIDL_user_free(NewPrivileges);
1870
1871 return Status;
1872 }
1873
1874
1875 /* Function 21 */
1876 NTSTATUS
1877 WINAPI
LsarGetQuotasForAccount(LSAPR_HANDLE AccountHandle,PQUOTA_LIMITS QuotaLimits)1878 LsarGetQuotasForAccount(
1879 LSAPR_HANDLE AccountHandle,
1880 PQUOTA_LIMITS QuotaLimits)
1881 {
1882 PLSA_DB_OBJECT AccountObject;
1883 ULONG Size;
1884 NTSTATUS Status;
1885
1886 TRACE("LsarGetQuotasForAccount(%p %p)\n",
1887 AccountHandle, QuotaLimits);
1888
1889 /* Validate the account handle */
1890 Status = LsapValidateDbObject(AccountHandle,
1891 LsaDbAccountObject,
1892 ACCOUNT_VIEW,
1893 &AccountObject);
1894 if (!NT_SUCCESS(Status))
1895 {
1896 ERR("Invalid handle (Status %lx)\n", Status);
1897 return Status;
1898 }
1899
1900 /* Get the quota attribute */
1901 Status = LsapGetObjectAttribute(AccountObject,
1902 L"DefQuota",
1903 QuotaLimits,
1904 &Size);
1905
1906 return Status;
1907 }
1908
1909
1910 /* Function 22 */
1911 NTSTATUS
1912 WINAPI
LsarSetQuotasForAccount(LSAPR_HANDLE AccountHandle,PQUOTA_LIMITS QuotaLimits)1913 LsarSetQuotasForAccount(
1914 LSAPR_HANDLE AccountHandle,
1915 PQUOTA_LIMITS QuotaLimits)
1916 {
1917 PLSA_DB_OBJECT AccountObject;
1918 QUOTA_LIMITS InternalQuotaLimits;
1919 ULONG Size;
1920 NTSTATUS Status;
1921
1922 TRACE("LsarSetQuotasForAccount(%p %p)\n",
1923 AccountHandle, QuotaLimits);
1924
1925 /* Validate the account handle */
1926 Status = LsapValidateDbObject(AccountHandle,
1927 LsaDbAccountObject,
1928 ACCOUNT_ADJUST_QUOTAS,
1929 &AccountObject);
1930 if (!NT_SUCCESS(Status))
1931 {
1932 ERR("Invalid handle (Status %lx)\n", Status);
1933 return Status;
1934 }
1935
1936 /* Get the quota limits attribute */
1937 Size = sizeof(QUOTA_LIMITS);
1938 Status = LsapGetObjectAttribute(AccountObject,
1939 L"DefQuota",
1940 &InternalQuotaLimits,
1941 &Size);
1942 if (!NT_SUCCESS(Status))
1943 {
1944 TRACE("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
1945 return Status;
1946 }
1947
1948 /* Update the quota limits */
1949 if (QuotaLimits->PagedPoolLimit != 0)
1950 InternalQuotaLimits.PagedPoolLimit = QuotaLimits->PagedPoolLimit;
1951
1952 if (QuotaLimits->NonPagedPoolLimit != 0)
1953 InternalQuotaLimits.NonPagedPoolLimit = QuotaLimits->NonPagedPoolLimit;
1954
1955 if (QuotaLimits->MinimumWorkingSetSize != 0)
1956 InternalQuotaLimits.MinimumWorkingSetSize = QuotaLimits->MinimumWorkingSetSize;
1957
1958 if (QuotaLimits->MaximumWorkingSetSize != 0)
1959 InternalQuotaLimits.MaximumWorkingSetSize = QuotaLimits->MaximumWorkingSetSize;
1960
1961 if (QuotaLimits->PagefileLimit != 0)
1962 InternalQuotaLimits.PagefileLimit = QuotaLimits->PagefileLimit;
1963
1964 /* Set the quota limits attribute */
1965 Status = LsapSetObjectAttribute(AccountObject,
1966 L"DefQuota",
1967 &InternalQuotaLimits,
1968 sizeof(QUOTA_LIMITS));
1969
1970 return Status;
1971 }
1972
1973
1974 /* Function 23 */
1975 NTSTATUS
1976 WINAPI
LsarGetSystemAccessAccount(LSAPR_HANDLE AccountHandle,ACCESS_MASK * SystemAccess)1977 LsarGetSystemAccessAccount(
1978 LSAPR_HANDLE AccountHandle,
1979 ACCESS_MASK *SystemAccess)
1980 {
1981 PLSA_DB_OBJECT AccountObject;
1982 ULONG Size = sizeof(ACCESS_MASK);
1983 NTSTATUS Status;
1984
1985 TRACE("LsarGetSystemAccessAccount(%p %p)\n",
1986 AccountHandle, SystemAccess);
1987
1988 /* Validate the account handle */
1989 Status = LsapValidateDbObject(AccountHandle,
1990 LsaDbAccountObject,
1991 ACCOUNT_VIEW,
1992 &AccountObject);
1993 if (!NT_SUCCESS(Status))
1994 {
1995 ERR("Invalid handle (Status %lx)\n", Status);
1996 return Status;
1997 }
1998
1999 /* Get the system access flags */
2000 Status = LsapGetObjectAttribute(AccountObject,
2001 L"ActSysAc",
2002 SystemAccess,
2003 &Size);
2004
2005 return Status;
2006 }
2007
2008
2009 /* Function 24 */
2010 NTSTATUS
2011 WINAPI
LsarSetSystemAccessAccount(LSAPR_HANDLE AccountHandle,ACCESS_MASK SystemAccess)2012 LsarSetSystemAccessAccount(
2013 LSAPR_HANDLE AccountHandle,
2014 ACCESS_MASK SystemAccess)
2015 {
2016 PLSA_DB_OBJECT AccountObject;
2017 NTSTATUS Status;
2018
2019 TRACE("LsarSetSystemAccessAccount(%p %lx)\n",
2020 AccountHandle, SystemAccess);
2021
2022 /* Validate the account handle */
2023 Status = LsapValidateDbObject(AccountHandle,
2024 LsaDbAccountObject,
2025 ACCOUNT_ADJUST_SYSTEM_ACCESS,
2026 &AccountObject);
2027 if (!NT_SUCCESS(Status))
2028 {
2029 ERR("Invalid handle (Status %lx)\n", Status);
2030 return Status;
2031 }
2032
2033 /* Set the system access flags */
2034 Status = LsapSetObjectAttribute(AccountObject,
2035 L"ActSysAc",
2036 &SystemAccess,
2037 sizeof(ACCESS_MASK));
2038
2039 return Status;
2040 }
2041
2042
2043 /* Function 25 */
2044 NTSTATUS
2045 WINAPI
LsarOpenTrustedDomain(LSAPR_HANDLE PolicyHandle,PRPC_SID TrustedDomainSid,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * TrustedDomainHandle)2046 LsarOpenTrustedDomain(
2047 LSAPR_HANDLE PolicyHandle,
2048 PRPC_SID TrustedDomainSid,
2049 ACCESS_MASK DesiredAccess,
2050 LSAPR_HANDLE *TrustedDomainHandle)
2051 {
2052 /* Fail, if we are not a domain controller */
2053 if (LsapProductType != NtProductLanManNt)
2054 return STATUS_DIRECTORY_SERVICE_REQUIRED;
2055
2056 UNIMPLEMENTED;
2057 return STATUS_NOT_IMPLEMENTED;
2058 }
2059
2060
2061 /* Function 26 */
2062 NTSTATUS
2063 WINAPI
LsarQueryInfoTrustedDomain(LSAPR_HANDLE TrustedDomainHandle,TRUSTED_INFORMATION_CLASS InformationClass,PLSAPR_TRUSTED_DOMAIN_INFO * TrustedDomainInformation)2064 LsarQueryInfoTrustedDomain(
2065 LSAPR_HANDLE TrustedDomainHandle,
2066 TRUSTED_INFORMATION_CLASS InformationClass,
2067 PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
2068 {
2069 UNIMPLEMENTED;
2070 return STATUS_NOT_IMPLEMENTED;
2071 }
2072
2073
2074 /* Function 27 */
2075 NTSTATUS
2076 WINAPI
LsarSetInformationTrustedDomain(LSAPR_HANDLE TrustedDomainHandle,TRUSTED_INFORMATION_CLASS InformationClass,PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)2077 LsarSetInformationTrustedDomain(
2078 LSAPR_HANDLE TrustedDomainHandle,
2079 TRUSTED_INFORMATION_CLASS InformationClass,
2080 PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
2081 {
2082 UNIMPLEMENTED;
2083 return STATUS_NOT_IMPLEMENTED;
2084 }
2085
2086
2087 /* Function 28 */
2088 NTSTATUS
2089 WINAPI
LsarOpenSecret(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING SecretName,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * SecretHandle)2090 LsarOpenSecret(
2091 LSAPR_HANDLE PolicyHandle,
2092 PRPC_UNICODE_STRING SecretName,
2093 ACCESS_MASK DesiredAccess,
2094 LSAPR_HANDLE *SecretHandle)
2095 {
2096 PLSA_DB_OBJECT PolicyObject;
2097 PLSA_DB_OBJECT SecretObject = NULL;
2098 NTSTATUS Status = STATUS_SUCCESS;
2099
2100 TRACE("LsarOpenSecret(%p %wZ %lx %p)\n",
2101 PolicyHandle, SecretName, DesiredAccess, SecretHandle);
2102
2103 /* Validate the PolicyHandle */
2104 Status = LsapValidateDbObject(PolicyHandle,
2105 LsaDbPolicyObject,
2106 0,
2107 &PolicyObject);
2108 if (!NT_SUCCESS(Status))
2109 {
2110 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
2111 return Status;
2112 }
2113
2114 /* Create the secret object */
2115 Status = LsapOpenDbObject(PolicyObject,
2116 L"Secrets",
2117 SecretName->Buffer,
2118 LsaDbSecretObject,
2119 DesiredAccess,
2120 PolicyObject->Trusted,
2121 &SecretObject);
2122 if (!NT_SUCCESS(Status))
2123 {
2124 ERR("LsapOpenDbObject failed (Status 0x%08lx)\n", Status);
2125 goto done;
2126 }
2127
2128 done:
2129 if (!NT_SUCCESS(Status))
2130 {
2131 if (SecretObject != NULL)
2132 LsapCloseDbObject(SecretObject);
2133 }
2134 else
2135 {
2136 *SecretHandle = (LSAPR_HANDLE)SecretObject;
2137 }
2138
2139 return Status;
2140 }
2141
2142
2143 /* Function 29 */
2144 NTSTATUS
2145 WINAPI
LsarSetSecret(LSAPR_HANDLE SecretHandle,PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue,PLSAPR_CR_CIPHER_VALUE EncryptedOldValue)2146 LsarSetSecret(
2147 LSAPR_HANDLE SecretHandle,
2148 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue,
2149 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue)
2150 {
2151 PLSA_DB_OBJECT SecretObject;
2152 PBYTE CurrentValue = NULL;
2153 PBYTE OldValue = NULL;
2154 ULONG CurrentValueLength = 0;
2155 ULONG OldValueLength = 0;
2156 LARGE_INTEGER Time;
2157 NTSTATUS Status;
2158
2159 TRACE("LsarSetSecret(%p %p %p)\n", SecretHandle,
2160 EncryptedCurrentValue, EncryptedOldValue);
2161
2162 /* Validate the SecretHandle */
2163 Status = LsapValidateDbObject(SecretHandle,
2164 LsaDbSecretObject,
2165 SECRET_SET_VALUE,
2166 &SecretObject);
2167 if (!NT_SUCCESS(Status))
2168 {
2169 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
2170 return Status;
2171 }
2172
2173 if (EncryptedCurrentValue != NULL)
2174 {
2175 /* FIXME: Decrypt the current value */
2176 CurrentValue = EncryptedCurrentValue->Buffer;
2177 CurrentValueLength = EncryptedCurrentValue->MaximumLength;
2178 }
2179
2180 /* Set the current value */
2181 Status = LsapSetObjectAttribute(SecretObject,
2182 L"CurrentValue",
2183 CurrentValue,
2184 CurrentValueLength);
2185 if (!NT_SUCCESS(Status))
2186 {
2187 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
2188 goto done;
2189 }
2190
2191 /* Get the current time */
2192 Status = NtQuerySystemTime(&Time);
2193 if (!NT_SUCCESS(Status))
2194 {
2195 ERR("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
2196 goto done;
2197 }
2198
2199 /* Set the current time */
2200 Status = LsapSetObjectAttribute(SecretObject,
2201 L"CurrentTime",
2202 &Time,
2203 sizeof(LARGE_INTEGER));
2204 if (!NT_SUCCESS(Status))
2205 {
2206 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
2207 goto done;
2208 }
2209
2210 if (EncryptedOldValue != NULL)
2211 {
2212 /* FIXME: Decrypt the old value */
2213 OldValue = EncryptedOldValue->Buffer;
2214 OldValueLength = EncryptedOldValue->MaximumLength;
2215 }
2216
2217 /* Set the old value */
2218 Status = LsapSetObjectAttribute(SecretObject,
2219 L"OldValue",
2220 OldValue,
2221 OldValueLength);
2222 if (!NT_SUCCESS(Status))
2223 {
2224 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
2225 goto done;
2226 }
2227
2228 /* Set the old time */
2229 Status = LsapSetObjectAttribute(SecretObject,
2230 L"OldTime",
2231 &Time,
2232 sizeof(LARGE_INTEGER));
2233 if (!NT_SUCCESS(Status))
2234 {
2235 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
2236 }
2237
2238 done:
2239 return Status;
2240 }
2241
2242
2243 /* Function 30 */
2244 NTSTATUS
2245 WINAPI
LsarQuerySecret(LSAPR_HANDLE SecretHandle,PLSAPR_CR_CIPHER_VALUE * EncryptedCurrentValue,PLARGE_INTEGER CurrentValueSetTime,PLSAPR_CR_CIPHER_VALUE * EncryptedOldValue,PLARGE_INTEGER OldValueSetTime)2246 LsarQuerySecret(
2247 LSAPR_HANDLE SecretHandle,
2248 PLSAPR_CR_CIPHER_VALUE *EncryptedCurrentValue,
2249 PLARGE_INTEGER CurrentValueSetTime,
2250 PLSAPR_CR_CIPHER_VALUE *EncryptedOldValue,
2251 PLARGE_INTEGER OldValueSetTime)
2252 {
2253 PLSA_DB_OBJECT SecretObject;
2254 PLSAPR_CR_CIPHER_VALUE EncCurrentValue = NULL;
2255 PLSAPR_CR_CIPHER_VALUE EncOldValue = NULL;
2256 PBYTE CurrentValue = NULL;
2257 PBYTE OldValue = NULL;
2258 ULONG CurrentValueLength = 0;
2259 ULONG OldValueLength = 0;
2260 ULONG BufferSize;
2261 NTSTATUS Status;
2262
2263 TRACE("LsarQuerySecret(%p %p %p %p %p)\n", SecretHandle,
2264 EncryptedCurrentValue, CurrentValueSetTime,
2265 EncryptedOldValue, OldValueSetTime);
2266
2267 /* Validate the SecretHandle */
2268 Status = LsapValidateDbObject(SecretHandle,
2269 LsaDbSecretObject,
2270 SECRET_QUERY_VALUE,
2271 &SecretObject);
2272 if (!NT_SUCCESS(Status))
2273 {
2274 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
2275 return Status;
2276 }
2277
2278 if (EncryptedCurrentValue != NULL)
2279 {
2280 CurrentValueLength = 0;
2281
2282 /* Get the size of the current value */
2283 Status = LsapGetObjectAttribute(SecretObject,
2284 L"CurrentValue",
2285 NULL,
2286 &CurrentValueLength);
2287 if (!NT_SUCCESS(Status))
2288 goto done;
2289
2290 /* Allocate a buffer for the current value */
2291 CurrentValue = midl_user_allocate(CurrentValueLength);
2292 if (CurrentValue == NULL)
2293 {
2294 Status = STATUS_INSUFFICIENT_RESOURCES;
2295 goto done;
2296 }
2297
2298 /* Get the current value */
2299 Status = LsapGetObjectAttribute(SecretObject,
2300 L"CurrentValue",
2301 CurrentValue,
2302 &CurrentValueLength);
2303 if (!NT_SUCCESS(Status))
2304 goto done;
2305
2306 /* Allocate a buffer for the encrypted current value */
2307 EncCurrentValue = midl_user_allocate(sizeof(LSAPR_CR_CIPHER_VALUE));
2308 if (EncCurrentValue == NULL)
2309 {
2310 Status = STATUS_INSUFFICIENT_RESOURCES;
2311 goto done;
2312 }
2313
2314 /* FIXME: Encrypt the current value */
2315 EncCurrentValue->Length = (USHORT)(CurrentValueLength - sizeof(WCHAR));
2316 EncCurrentValue->MaximumLength = (USHORT)CurrentValueLength;
2317 EncCurrentValue->Buffer = (PBYTE)CurrentValue;
2318 }
2319
2320 if (CurrentValueSetTime != NULL)
2321 {
2322 BufferSize = sizeof(LARGE_INTEGER);
2323
2324 /* Get the current value time */
2325 Status = LsapGetObjectAttribute(SecretObject,
2326 L"CurrentTime",
2327 (PBYTE)CurrentValueSetTime,
2328 &BufferSize);
2329 if (!NT_SUCCESS(Status))
2330 goto done;
2331 }
2332
2333 if (EncryptedOldValue != NULL)
2334 {
2335 OldValueLength = 0;
2336
2337 /* Get the size of the old value */
2338 Status = LsapGetObjectAttribute(SecretObject,
2339 L"OldValue",
2340 NULL,
2341 &OldValueLength);
2342 if (!NT_SUCCESS(Status))
2343 goto done;
2344
2345 /* Allocate a buffer for the old value */
2346 OldValue = midl_user_allocate(OldValueLength);
2347 if (OldValue == NULL)
2348 {
2349 Status = STATUS_INSUFFICIENT_RESOURCES;
2350 goto done;
2351 }
2352
2353 /* Get the old value */
2354 Status = LsapGetObjectAttribute(SecretObject,
2355 L"OldValue",
2356 OldValue,
2357 &OldValueLength);
2358 if (!NT_SUCCESS(Status))
2359 goto done;
2360
2361 /* Allocate a buffer for the encrypted old value */
2362 EncOldValue = midl_user_allocate(sizeof(LSAPR_CR_CIPHER_VALUE) + OldValueLength);
2363 if (EncOldValue == NULL)
2364 {
2365 Status = STATUS_INSUFFICIENT_RESOURCES;
2366 goto done;
2367 }
2368
2369 /* FIXME: Encrypt the old value */
2370 EncOldValue->Length = (USHORT)(OldValueLength - sizeof(WCHAR));
2371 EncOldValue->MaximumLength = (USHORT)OldValueLength;
2372 EncOldValue->Buffer = (PBYTE)OldValue;
2373 }
2374
2375 if (OldValueSetTime != NULL)
2376 {
2377 BufferSize = sizeof(LARGE_INTEGER);
2378
2379 /* Get the old value time */
2380 Status = LsapGetObjectAttribute(SecretObject,
2381 L"OldTime",
2382 (PBYTE)OldValueSetTime,
2383 &BufferSize);
2384 if (!NT_SUCCESS(Status))
2385 goto done;
2386 }
2387
2388
2389 done:
2390 if (NT_SUCCESS(Status))
2391 {
2392 if (EncryptedCurrentValue != NULL)
2393 *EncryptedCurrentValue = EncCurrentValue;
2394
2395 if (EncryptedOldValue != NULL)
2396 *EncryptedOldValue = EncOldValue;
2397 }
2398 else
2399 {
2400 if (EncryptedCurrentValue != NULL)
2401 *EncryptedCurrentValue = NULL;
2402
2403 if (EncryptedOldValue != NULL)
2404 *EncryptedOldValue = NULL;
2405
2406 if (EncCurrentValue != NULL)
2407 midl_user_free(EncCurrentValue);
2408
2409 if (EncOldValue != NULL)
2410 midl_user_free(EncOldValue);
2411
2412 if (CurrentValue != NULL)
2413 midl_user_free(CurrentValue);
2414
2415 if (OldValue != NULL)
2416 midl_user_free(OldValue);
2417 }
2418
2419 TRACE("LsarQuerySecret done (Status 0x%08lx)\n", Status);
2420
2421 return Status;
2422 }
2423
2424
2425 /* Function 31 */
2426 NTSTATUS
2427 WINAPI
LsarLookupPrivilegeValue(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING Name,PLUID Value)2428 LsarLookupPrivilegeValue(
2429 LSAPR_HANDLE PolicyHandle,
2430 PRPC_UNICODE_STRING Name,
2431 PLUID Value)
2432 {
2433 PLUID pValue;
2434 NTSTATUS Status;
2435
2436 TRACE("LsarLookupPrivilegeValue(%p, %wZ, %p)\n",
2437 PolicyHandle, Name, Value);
2438
2439 Status = LsapValidateDbObject(PolicyHandle,
2440 LsaDbPolicyObject,
2441 POLICY_LOOKUP_NAMES,
2442 NULL);
2443 if (!NT_SUCCESS(Status))
2444 {
2445 ERR("Invalid handle (Status %lx)\n", Status);
2446 return Status;
2447 }
2448
2449 TRACE("Privilege: %wZ\n", Name);
2450
2451 pValue = LsarpLookupPrivilegeValue(Name);
2452 if (pValue == NULL)
2453 return STATUS_NO_SUCH_PRIVILEGE;
2454
2455 RtlCopyLuid(Value, pValue);
2456
2457 return STATUS_SUCCESS;
2458 }
2459
2460
2461 /* Function 32 */
2462 NTSTATUS
2463 WINAPI
LsarLookupPrivilegeName(LSAPR_HANDLE PolicyHandle,PLUID Value,PRPC_UNICODE_STRING * Name)2464 LsarLookupPrivilegeName(
2465 LSAPR_HANDLE PolicyHandle,
2466 PLUID Value,
2467 PRPC_UNICODE_STRING *Name)
2468 {
2469 NTSTATUS Status;
2470
2471 TRACE("LsarLookupPrivilegeName(%p, %p, %p)\n",
2472 PolicyHandle, Value, Name);
2473
2474 Status = LsapValidateDbObject(PolicyHandle,
2475 LsaDbPolicyObject,
2476 POLICY_LOOKUP_NAMES,
2477 NULL);
2478 if (!NT_SUCCESS(Status))
2479 {
2480 ERR("Invalid handle\n");
2481 return Status;
2482 }
2483
2484 Status = LsarpLookupPrivilegeName(Value,
2485 Name);
2486
2487 return Status;
2488 }
2489
2490
2491 /* Function 33 */
2492 NTSTATUS
2493 WINAPI
LsarLookupPrivilegeDisplayName(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING Name,USHORT ClientLanguage,USHORT ClientSystemDefaultLanguage,PRPC_UNICODE_STRING * DisplayName,USHORT * LanguageReturned)2494 LsarLookupPrivilegeDisplayName(
2495 LSAPR_HANDLE PolicyHandle,
2496 PRPC_UNICODE_STRING Name,
2497 USHORT ClientLanguage,
2498 USHORT ClientSystemDefaultLanguage,
2499 PRPC_UNICODE_STRING *DisplayName,
2500 USHORT *LanguageReturned)
2501 {
2502 NTSTATUS Status;
2503
2504 TRACE("LsarLookupPrivilegeDisplayName(%p, %p, %u, %u, %p, %p)\n",
2505 PolicyHandle, Name, ClientLanguage, ClientSystemDefaultLanguage, DisplayName, LanguageReturned);
2506
2507 Status = LsapValidateDbObject(PolicyHandle,
2508 LsaDbPolicyObject,
2509 POLICY_LOOKUP_NAMES,
2510 NULL);
2511 if (!NT_SUCCESS(Status))
2512 {
2513 ERR("Invalid handle\n");
2514 return Status;
2515 }
2516
2517 Status = LsarpLookupPrivilegeDisplayName(Name,
2518 ClientLanguage,
2519 ClientSystemDefaultLanguage,
2520 DisplayName,
2521 LanguageReturned);
2522
2523 return Status;
2524 }
2525
2526
2527 /* Function 34 */
2528 NTSTATUS
2529 WINAPI
LsarDeleteObject(LSAPR_HANDLE * ObjectHandle)2530 LsarDeleteObject(
2531 LSAPR_HANDLE *ObjectHandle)
2532 {
2533 PLSA_DB_OBJECT DbObject;
2534 NTSTATUS Status;
2535
2536 TRACE("LsarDeleteObject(%p)\n", ObjectHandle);
2537
2538 if (ObjectHandle == NULL)
2539 return STATUS_INVALID_PARAMETER;
2540
2541 /* Validate the ObjectHandle */
2542 Status = LsapValidateDbObject(*ObjectHandle,
2543 LsaDbIgnoreObject,
2544 DELETE,
2545 &DbObject);
2546 if (!NT_SUCCESS(Status))
2547 {
2548 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
2549 return Status;
2550 }
2551
2552 /* You cannot delete the policy object */
2553 if (DbObject->ObjectType == LsaDbPolicyObject)
2554 return STATUS_INVALID_PARAMETER;
2555
2556 /* Delete the database object */
2557 Status = LsapDeleteDbObject(DbObject);
2558 if (!NT_SUCCESS(Status))
2559 {
2560 ERR("LsapDeleteDbObject returned 0x%08lx\n", Status);
2561 return Status;
2562 }
2563
2564 /* Invalidate the object handle */
2565 *ObjectHandle = NULL;
2566
2567 return STATUS_SUCCESS;
2568 }
2569
2570
2571 /* Function 35 */
2572 NTSTATUS
2573 WINAPI
LsarEnumerateAccountsWithUserRight(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING UserRight,PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer)2574 LsarEnumerateAccountsWithUserRight(
2575 LSAPR_HANDLE PolicyHandle,
2576 PRPC_UNICODE_STRING UserRight,
2577 PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer)
2578 {
2579 PLSA_DB_OBJECT PolicyObject;
2580 ACCESS_MASK AccountRight = 0;
2581 PLUID Luid = NULL;
2582 ULONG AccountKeyBufferSize;
2583 PWSTR AccountKeyBuffer = NULL;
2584 HKEY AccountsKeyHandle = NULL;
2585 HKEY AccountKeyHandle = NULL;
2586 HKEY AttributeKeyHandle;
2587 ACCESS_MASK SystemAccess;
2588 PPRIVILEGE_SET PrivilegeSet;
2589 PLSAPR_ACCOUNT_INFORMATION EnumBuffer = NULL, ReturnBuffer;
2590 ULONG SubKeyCount = 0;
2591 ULONG EnumIndex, EnumCount;
2592 ULONG Size, i;
2593 BOOL Found;
2594 NTSTATUS Status;
2595
2596 TRACE("LsarEnumerateAccountsWithUserRights(%p %wZ %p)\n",
2597 PolicyHandle, UserRight, EnumerationBuffer);
2598
2599 /* Validate the privilege and account right names */
2600 if (UserRight != NULL)
2601 {
2602 Luid = LsarpLookupPrivilegeValue(UserRight);
2603 if (Luid == NULL)
2604 {
2605 AccountRight = LsapLookupAccountRightValue(UserRight);
2606 if (AccountRight == 0)
2607 return STATUS_NO_SUCH_PRIVILEGE;
2608 }
2609 }
2610
2611 if (EnumerationBuffer == NULL)
2612 return STATUS_INVALID_PARAMETER;
2613
2614 EnumerationBuffer->EntriesRead = 0;
2615 EnumerationBuffer->Information = NULL;
2616
2617 /* Validate the PolicyHandle */
2618 Status = LsapValidateDbObject(PolicyHandle,
2619 LsaDbPolicyObject,
2620 POLICY_LOOKUP_NAMES | POLICY_VIEW_LOCAL_INFORMATION,
2621 &PolicyObject);
2622 if (!NT_SUCCESS(Status))
2623 {
2624 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
2625 return Status;
2626 }
2627
2628 Status = LsapRegOpenKey(PolicyObject->KeyHandle,
2629 L"Accounts",
2630 KEY_READ,
2631 &AccountsKeyHandle);
2632 if (!NT_SUCCESS(Status))
2633 {
2634 ERR("LsapRegOpenKey returned 0x%08lx\n", Status);
2635 return Status;
2636 }
2637
2638 Status = LsapRegQueryKeyInfo(AccountsKeyHandle,
2639 &SubKeyCount,
2640 &AccountKeyBufferSize,
2641 NULL);
2642 if (!NT_SUCCESS(Status))
2643 {
2644 ERR("LsapRegOpenKey returned 0x%08lx\n", Status);
2645 return Status;
2646 }
2647
2648 AccountKeyBufferSize += sizeof(WCHAR);
2649 AccountKeyBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, AccountKeyBufferSize);
2650 if (AccountKeyBuffer == NULL)
2651 {
2652 return STATUS_INSUFFICIENT_RESOURCES;
2653 }
2654
2655 EnumBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
2656 HEAP_ZERO_MEMORY,
2657 SubKeyCount * sizeof(LSAPR_ACCOUNT_INFORMATION));
2658 if (EnumBuffer == NULL)
2659 {
2660 Status = STATUS_INSUFFICIENT_RESOURCES;
2661 goto done;
2662 }
2663
2664 EnumCount = 0;
2665 EnumIndex = 0;
2666 while (TRUE)
2667 {
2668 Found = FALSE;
2669
2670 Status = LsapRegEnumerateSubKey(AccountsKeyHandle,
2671 EnumIndex,
2672 AccountKeyBufferSize,
2673 AccountKeyBuffer);
2674 if (!NT_SUCCESS(Status))
2675 {
2676 if (Status == STATUS_NO_MORE_ENTRIES)
2677 Status = STATUS_SUCCESS;
2678 break;
2679 }
2680
2681 TRACE("EnumIndex: %lu\n", EnumIndex);
2682 TRACE("Account key name: %S\n", AccountKeyBuffer);
2683
2684 Status = LsapRegOpenKey(AccountsKeyHandle,
2685 AccountKeyBuffer,
2686 KEY_READ,
2687 &AccountKeyHandle);
2688 if (NT_SUCCESS(Status))
2689 {
2690 if (Luid != NULL || AccountRight != 0)
2691 {
2692 Status = LsapRegOpenKey(AccountKeyHandle,
2693 (Luid != NULL) ? L"Privilgs" : L"ActSysAc",
2694 KEY_READ,
2695 &AttributeKeyHandle);
2696 if (NT_SUCCESS(Status))
2697 {
2698 if (Luid != NULL)
2699 {
2700 Size = 0;
2701 LsapRegQueryValue(AttributeKeyHandle,
2702 NULL,
2703 NULL,
2704 NULL,
2705 &Size);
2706 if (Size != 0)
2707 {
2708 PrivilegeSet = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
2709 if (PrivilegeSet)
2710 {
2711 if (LsapRegQueryValue(AttributeKeyHandle,
2712 NULL,
2713 NULL,
2714 PrivilegeSet,
2715 &Size) == STATUS_SUCCESS)
2716 {
2717 for (i = 0; i < PrivilegeSet->PrivilegeCount; i++)
2718 {
2719 if (RtlEqualLuid(&(PrivilegeSet->Privilege[i].Luid), Luid))
2720 {
2721 TRACE("%S got the privilege!\n", AccountKeyBuffer);
2722 Found = TRUE;
2723 break;
2724 }
2725 }
2726 }
2727
2728 RtlFreeHeap(RtlGetProcessHeap(), 0, PrivilegeSet);
2729 }
2730 }
2731 }
2732 else if (AccountRight != 0)
2733 {
2734 SystemAccess = 0;
2735 Size = sizeof(ACCESS_MASK);
2736 LsapRegQueryValue(AttributeKeyHandle,
2737 NULL,
2738 NULL,
2739 &SystemAccess,
2740 &Size);
2741 if (SystemAccess & AccountRight)
2742 {
2743 TRACE("%S got the account right!\n", AccountKeyBuffer);
2744 Found = TRUE;
2745 }
2746 }
2747
2748 LsapRegCloseKey(AttributeKeyHandle);
2749 }
2750 }
2751 else
2752 {
2753 /* enumerate all accounts */
2754 Found = TRUE;
2755 }
2756
2757 if (Found == TRUE)
2758 {
2759 TRACE("Add account: %S\n", AccountKeyBuffer);
2760
2761 Status = LsapRegOpenKey(AccountKeyHandle,
2762 L"Sid",
2763 KEY_READ,
2764 &AttributeKeyHandle);
2765 if (NT_SUCCESS(Status))
2766 {
2767 Size = 0;
2768 LsapRegQueryValue(AttributeKeyHandle,
2769 NULL,
2770 NULL,
2771 NULL,
2772 &Size);
2773 if (Size != 0)
2774 {
2775 EnumBuffer[EnumCount].Sid = midl_user_allocate(Size);
2776 if (EnumBuffer[EnumCount].Sid != NULL)
2777 {
2778 Status = LsapRegQueryValue(AttributeKeyHandle,
2779 NULL,
2780 NULL,
2781 EnumBuffer[EnumCount].Sid,
2782 &Size);
2783 if (NT_SUCCESS(Status))
2784 {
2785 EnumCount++;
2786 }
2787 else
2788 {
2789 TRACE("SampRegQueryValue returned %08lX\n", Status);
2790 midl_user_free(EnumBuffer[EnumCount].Sid);
2791 EnumBuffer[EnumCount].Sid = NULL;
2792 }
2793 }
2794 }
2795
2796 LsapRegCloseKey(AttributeKeyHandle);
2797 }
2798 }
2799
2800 LsapRegCloseKey(AccountKeyHandle);
2801 }
2802
2803 EnumIndex++;
2804 }
2805
2806 TRACE("EnumCount: %lu\n", EnumCount);
2807
2808 if (NT_SUCCESS(Status) && EnumCount != 0)
2809 {
2810 ReturnBuffer = midl_user_allocate(EnumCount * sizeof(LSAPR_ACCOUNT_INFORMATION));
2811 if (ReturnBuffer == NULL)
2812 {
2813 Status = STATUS_INSUFFICIENT_RESOURCES;
2814 goto done;
2815 }
2816
2817 RtlCopyMemory(ReturnBuffer,
2818 EnumBuffer,
2819 EnumCount * sizeof(LSAPR_ACCOUNT_INFORMATION));
2820
2821 EnumerationBuffer->EntriesRead = EnumCount;
2822 EnumerationBuffer->Information = ReturnBuffer;
2823 }
2824
2825 done:
2826 if (EnumBuffer != NULL)
2827 {
2828 if (Status != STATUS_SUCCESS)
2829 {
2830 for (i = 0; i < EnumCount; i++)
2831 {
2832 if (EnumBuffer[i].Sid != NULL)
2833 midl_user_free(EnumBuffer[i].Sid);
2834 }
2835 }
2836
2837 RtlFreeHeap(RtlGetProcessHeap(), 0, EnumBuffer);
2838 }
2839
2840 if (AccountKeyBuffer != NULL)
2841 RtlFreeHeap(RtlGetProcessHeap(), 0, AccountKeyBuffer);
2842
2843 if (Status == STATUS_SUCCESS && EnumCount == 0)
2844 Status = STATUS_NO_MORE_ENTRIES;
2845
2846 return Status;
2847 }
2848
2849
2850 /* Function 36 */
2851 NTSTATUS
2852 WINAPI
LsarEnumerateAccountRights(LSAPR_HANDLE PolicyHandle,PRPC_SID AccountSid,PLSAPR_USER_RIGHT_SET UserRights)2853 LsarEnumerateAccountRights(
2854 LSAPR_HANDLE PolicyHandle,
2855 PRPC_SID AccountSid,
2856 PLSAPR_USER_RIGHT_SET UserRights)
2857 {
2858 LSAPR_HANDLE AccountHandle;
2859 PLSAPR_PRIVILEGE_SET PrivilegeSet = NULL;
2860 PRPC_UNICODE_STRING RightsBuffer = NULL;
2861 PRPC_UNICODE_STRING PrivilegeString;
2862 ACCESS_MASK SystemAccess = 0;
2863 ULONG RightsCount = 0;
2864 ULONG Index;
2865 ULONG i;
2866 NTSTATUS Status;
2867
2868 TRACE("LsarEnumerateAccountRights(%p %p %p)\n",
2869 PolicyHandle, AccountSid, UserRights);
2870
2871 /* Open the account */
2872 Status = LsarOpenAccount(PolicyHandle,
2873 AccountSid,
2874 ACCOUNT_VIEW,
2875 &AccountHandle);
2876 if (!NT_SUCCESS(Status))
2877 {
2878 WARN("LsarOpenAccount returned 0x%08lx\n", Status);
2879 return Status;
2880 }
2881
2882 /* Enumerate the privileges */
2883 Status = LsarEnumeratePrivilegesAccount(AccountHandle,
2884 &PrivilegeSet);
2885 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
2886 {
2887 WARN("LsarEnumeratePrivilegesAccount returned 0x%08lx\n", Status);
2888 goto done;
2889 }
2890
2891 /* Get account rights */
2892 Status = LsarGetSystemAccessAccount(AccountHandle,
2893 &SystemAccess);
2894 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
2895 {
2896 WARN("LsarGetSystemAccessAccount returned 0x%08lx\n", Status);
2897 goto done;
2898 }
2899
2900 RightsCount = PrivilegeSet->PrivilegeCount;
2901
2902 /* Count account rights */
2903 for (i = 0; i < sizeof(ACCESS_MASK) * 8; i++)
2904 {
2905 if (SystemAccess & (1 << i))
2906 RightsCount++;
2907 }
2908
2909 /* We are done if there are no rights to be enumerated */
2910 if (RightsCount == 0)
2911 {
2912 UserRights->Entries = 0;
2913 UserRights->UserRights = NULL;
2914 Status = STATUS_SUCCESS;
2915 goto done;
2916 }
2917
2918 /* Allocate a buffer for the account rights */
2919 RightsBuffer = MIDL_user_allocate(RightsCount * sizeof(RPC_UNICODE_STRING));
2920 if (RightsBuffer == NULL)
2921 {
2922 Status = STATUS_INSUFFICIENT_RESOURCES;
2923 goto done;
2924 }
2925
2926 /* Copy the privileges into the buffer */
2927 Index = 0;
2928 if (PrivilegeSet)
2929 {
2930 for (i = 0; i < PrivilegeSet->PrivilegeCount; i++)
2931 {
2932 PrivilegeString = NULL;
2933 Status = LsarLookupPrivilegeName(PolicyHandle,
2934 (PLUID)&PrivilegeSet->Privilege[i].Luid,
2935 &PrivilegeString);
2936 if (!NT_SUCCESS(Status))
2937 {
2938 WARN("LsarLookupPrivilegeName returned 0x%08lx\n", Status);
2939 goto done;
2940 }
2941
2942 RightsBuffer[Index].Length = PrivilegeString->Length;
2943 RightsBuffer[Index].MaximumLength = PrivilegeString->MaximumLength;
2944 RightsBuffer[Index].Buffer = PrivilegeString->Buffer;
2945
2946 MIDL_user_free(PrivilegeString);
2947 Index++;
2948 }
2949 }
2950
2951 /* Copy account rights into the buffer */
2952 for (i = 0; i < sizeof(ACCESS_MASK) * 8; i++)
2953 {
2954 if (SystemAccess & (1 << i))
2955 {
2956 Status = LsapLookupAccountRightName(1 << i,
2957 &PrivilegeString);
2958 if (!NT_SUCCESS(Status))
2959 {
2960 WARN("LsarLookupAccountRightName returned 0x%08lx\n", Status);
2961 goto done;
2962 }
2963
2964 RightsBuffer[Index].Length = PrivilegeString->Length;
2965 RightsBuffer[Index].MaximumLength = PrivilegeString->MaximumLength;
2966 RightsBuffer[Index].Buffer = PrivilegeString->Buffer;
2967
2968 MIDL_user_free(PrivilegeString);
2969 Index++;
2970 }
2971 }
2972
2973 UserRights->Entries = RightsCount;
2974 UserRights->UserRights = (PRPC_UNICODE_STRING)RightsBuffer;
2975
2976 done:
2977 if (!NT_SUCCESS(Status))
2978 {
2979 if (RightsBuffer != NULL)
2980 {
2981 for (Index = 0; Index < RightsCount; Index++)
2982 {
2983 if (RightsBuffer[Index].Buffer != NULL)
2984 MIDL_user_free(RightsBuffer[Index].Buffer);
2985 }
2986
2987 MIDL_user_free(RightsBuffer);
2988 }
2989 }
2990
2991 if (PrivilegeSet != NULL)
2992 MIDL_user_free(PrivilegeSet);
2993
2994 LsarClose(&AccountHandle);
2995
2996 return Status;
2997 }
2998
2999
3000 /* Function 37 */
3001 NTSTATUS
3002 WINAPI
LsarAddAccountRights(LSAPR_HANDLE PolicyHandle,PRPC_SID AccountSid,PLSAPR_USER_RIGHT_SET UserRights)3003 LsarAddAccountRights(
3004 LSAPR_HANDLE PolicyHandle,
3005 PRPC_SID AccountSid,
3006 PLSAPR_USER_RIGHT_SET UserRights)
3007 {
3008 PLSA_DB_OBJECT PolicyObject;
3009 PLSA_DB_OBJECT AccountObject = NULL;
3010 ULONG ulNewPrivileges = 0, ulNewRights = 0;
3011 ACCESS_MASK SystemAccess = 0;
3012 ULONG Size, Value, i, j;
3013 PPRIVILEGE_SET PrivilegeSet = NULL;
3014 ULONG PrivilegeSetBufferSize = 0;
3015 ULONG PrivilegeCount;
3016 BOOLEAN bFound;
3017 PLUID pLuid;
3018 NTSTATUS Status;
3019
3020 TRACE("LsarAddAccountRights(%p %p %p)\n",
3021 PolicyHandle, AccountSid, UserRights);
3022
3023 /* Validate the AccountSid */
3024 if (!RtlValidSid(AccountSid))
3025 return STATUS_INVALID_PARAMETER;
3026
3027 /* Validate the UserRights */
3028 if (UserRights == NULL)
3029 return STATUS_INVALID_PARAMETER;
3030
3031 /* Validate the privilege and account right names */
3032 for (i = 0; i < UserRights->Entries; i++)
3033 {
3034 if (LsarpLookupPrivilegeValue(&UserRights->UserRights[i]) != NULL)
3035 {
3036 ulNewPrivileges++;
3037 }
3038 else
3039 {
3040 if (LsapLookupAccountRightValue(&UserRights->UserRights[i]) == 0)
3041 return STATUS_NO_SUCH_PRIVILEGE;
3042
3043 ulNewRights++;
3044 }
3045 }
3046
3047 TRACE("ulNewPrivileges: %lu\n", ulNewPrivileges);
3048 TRACE("ulNewRights: %lu\n", ulNewRights);
3049
3050 /* Validate the PolicyHandle */
3051 Status = LsapValidateDbObject(PolicyHandle,
3052 LsaDbPolicyObject,
3053 POLICY_LOOKUP_NAMES,
3054 &PolicyObject);
3055 if (!NT_SUCCESS(Status))
3056 {
3057 WARN("LsapValidateDbObject returned 0x%08lx\n", Status);
3058 return Status;
3059 }
3060
3061 /* Open the account */
3062 Status = LsarpOpenAccount(PolicyObject,
3063 AccountSid,
3064 0,
3065 &AccountObject);
3066 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3067 {
3068 WARN("LsarpOpenAccount returned 0x%08lx\n", Status);
3069 goto done;
3070 }
3071 else if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
3072 {
3073 /* Create a new account if it does not yet exist */
3074 Status = LsarpCreateAccount(PolicyObject,
3075 AccountSid,
3076 0,
3077 &AccountObject);
3078 if (!NT_SUCCESS(Status))
3079 {
3080 WARN("LsarpCreateAccount returned 0x%08lx\n", Status);
3081 goto done;
3082 }
3083 }
3084
3085 if (ulNewPrivileges > 0)
3086 {
3087 Size = 0;
3088
3089 /* Get the size of the Privilgs attribute */
3090 Status = LsapGetObjectAttribute(AccountObject,
3091 L"Privilgs",
3092 NULL,
3093 &Size);
3094 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3095 goto done;
3096
3097 /* Calculate the required privilege set buffer size */
3098 if (Size == 0)
3099 PrivilegeSetBufferSize = sizeof(PRIVILEGE_SET) +
3100 (ulNewPrivileges - 1) * sizeof(LUID_AND_ATTRIBUTES);
3101 else
3102 PrivilegeSetBufferSize = Size +
3103 ulNewPrivileges * sizeof(LUID_AND_ATTRIBUTES);
3104
3105 /* Allocate the privilege set buffer */
3106 PrivilegeSet = RtlAllocateHeap(RtlGetProcessHeap(),
3107 HEAP_ZERO_MEMORY,
3108 PrivilegeSetBufferSize);
3109 if (PrivilegeSet == NULL)
3110 return STATUS_NO_MEMORY;
3111
3112 /* Get the privilege set */
3113 if (Size != 0)
3114 {
3115 Status = LsapGetObjectAttribute(AccountObject,
3116 L"Privilgs",
3117 PrivilegeSet,
3118 &Size);
3119 if (!NT_SUCCESS(Status))
3120 {
3121 WARN("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
3122 goto done;
3123 }
3124 }
3125
3126 PrivilegeCount = PrivilegeSet->PrivilegeCount;
3127 TRACE("Privilege count: %lu\n", PrivilegeCount);
3128
3129 for (i = 0; i < UserRights->Entries; i++)
3130 {
3131 pLuid = LsarpLookupPrivilegeValue(&UserRights->UserRights[i]);
3132 if (pLuid == NULL)
3133 continue;
3134
3135 bFound = FALSE;
3136 for (j = 0; j < PrivilegeSet->PrivilegeCount; j++)
3137 {
3138 if (RtlEqualLuid(&(PrivilegeSet->Privilege[j].Luid), pLuid))
3139 {
3140 bFound = TRUE;
3141 break;
3142 }
3143 }
3144
3145 if (bFound == FALSE)
3146 {
3147 /* Copy the new privilege */
3148 RtlCopyMemory(&(PrivilegeSet->Privilege[PrivilegeSet->PrivilegeCount]),
3149 pLuid,
3150 sizeof(LUID));
3151 PrivilegeSet->PrivilegeCount++;
3152 }
3153 }
3154
3155 /* Store the extended privilege set */
3156 if (PrivilegeCount != PrivilegeSet->PrivilegeCount)
3157 {
3158 Size = sizeof(PRIVILEGE_SET) +
3159 (PrivilegeSet->PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
3160
3161 Status = LsapSetObjectAttribute(AccountObject,
3162 L"Privilgs",
3163 PrivilegeSet,
3164 Size);
3165 if (!NT_SUCCESS(Status))
3166 {
3167 WARN("LsapSetObjectAttribute() failed (Status 0x%08lx)\n", Status);
3168 goto done;
3169 }
3170 }
3171 }
3172
3173 if (ulNewRights > 0)
3174 {
3175 Size = sizeof(ACCESS_MASK);
3176
3177 /* Get the system access flags, if the attribute exists */
3178 Status = LsapGetObjectAttribute(AccountObject,
3179 L"ActSysAc",
3180 &SystemAccess,
3181 &Size);
3182 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3183 goto done;
3184
3185 /* Set the new access rights */
3186 for (i = 0; i < UserRights->Entries; i++)
3187 {
3188 Value = LsapLookupAccountRightValue(&UserRights->UserRights[i]);
3189 if (Value != 0)
3190 SystemAccess |= Value;
3191 }
3192
3193 /* Set the system access flags */
3194 Status = LsapSetObjectAttribute(AccountObject,
3195 L"ActSysAc",
3196 &SystemAccess,
3197 sizeof(ACCESS_MASK));
3198 }
3199
3200 done:
3201 if (PrivilegeSet != NULL)
3202 RtlFreeHeap(RtlGetProcessHeap(), 0, PrivilegeSet);
3203
3204 if (AccountObject != NULL)
3205 LsapCloseDbObject(AccountObject);
3206
3207 return Status;
3208 }
3209
3210
3211 /* Function 38 */
3212 NTSTATUS
3213 WINAPI
LsarRemoveAccountRights(LSAPR_HANDLE PolicyHandle,PRPC_SID AccountSid,BOOLEAN AllRights,PLSAPR_USER_RIGHT_SET UserRights)3214 LsarRemoveAccountRights(
3215 LSAPR_HANDLE PolicyHandle,
3216 PRPC_SID AccountSid,
3217 BOOLEAN AllRights,
3218 PLSAPR_USER_RIGHT_SET UserRights)
3219 {
3220 PLSA_DB_OBJECT PolicyObject;
3221 PLSA_DB_OBJECT AccountObject = NULL;
3222 ULONG PrivilegesToRemove = 0, RightsToRemove = 0;
3223 ACCESS_MASK SystemAccess = 0;
3224 ULONG Size, Value, i, j, Index;
3225 PPRIVILEGE_SET PrivilegeSet = NULL;
3226 ULONG PrivilegeCount;
3227 PLUID pLuid;
3228 NTSTATUS Status;
3229
3230 TRACE("LsarRemoveAccountRights(%p %p %lu %p)\n",
3231 PolicyHandle, AccountSid, AllRights, UserRights);
3232
3233 /* Validate the AccountSid */
3234 if (!RtlValidSid(AccountSid))
3235 return STATUS_INVALID_PARAMETER;
3236
3237 /* Validate the UserRights */
3238 if (UserRights == NULL)
3239 return STATUS_INVALID_PARAMETER;
3240
3241 /* Validate the privilege and account right names */
3242 for (i = 0; i < UserRights->Entries; i++)
3243 {
3244 if (LsarpLookupPrivilegeValue(&UserRights->UserRights[i]) != NULL)
3245 {
3246 PrivilegesToRemove++;
3247 }
3248 else
3249 {
3250 if (LsapLookupAccountRightValue(&UserRights->UserRights[i]) == 0)
3251 return STATUS_NO_SUCH_PRIVILEGE;
3252
3253 RightsToRemove++;
3254 }
3255 }
3256
3257 /* Validate the PolicyHandle */
3258 Status = LsapValidateDbObject(PolicyHandle,
3259 LsaDbPolicyObject,
3260 POLICY_LOOKUP_NAMES,
3261 &PolicyObject);
3262 if (!NT_SUCCESS(Status))
3263 {
3264 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
3265 return Status;
3266 }
3267
3268 /* Open the account */
3269 Status = LsarpOpenAccount(PolicyObject,
3270 AccountSid,
3271 0,
3272 &AccountObject);
3273 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3274 {
3275 ERR("LsarpOpenAccount returned 0x%08lx\n", Status);
3276 goto done;
3277 }
3278
3279 if (AllRights == FALSE)
3280 {
3281 /* Get the size of the Privilgs attribute */
3282 Size = 0;
3283 Status = LsapGetObjectAttribute(AccountObject,
3284 L"Privilgs",
3285 NULL,
3286 &Size);
3287 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3288 goto done;
3289
3290 if ((Size != 0) && (PrivilegesToRemove != 0))
3291 {
3292 /* Allocate the privilege set buffer */
3293 PrivilegeSet = RtlAllocateHeap(RtlGetProcessHeap(),
3294 HEAP_ZERO_MEMORY,
3295 Size);
3296 if (PrivilegeSet == NULL)
3297 return STATUS_NO_MEMORY;
3298
3299 /* Get the privilege set */
3300 Status = LsapGetObjectAttribute(AccountObject,
3301 L"Privilgs",
3302 PrivilegeSet,
3303 &Size);
3304 if (!NT_SUCCESS(Status))
3305 {
3306 ERR("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
3307 goto done;
3308 }
3309
3310 PrivilegeCount = PrivilegeSet->PrivilegeCount;
3311
3312 for (i = 0; i < UserRights->Entries; i++)
3313 {
3314 pLuid = LsarpLookupPrivilegeValue(&UserRights->UserRights[i]);
3315 if (pLuid == NULL)
3316 continue;
3317
3318 Index = -1;
3319 for (j = 0; j < PrivilegeSet->PrivilegeCount; j++)
3320 {
3321 if (RtlEqualLuid(&(PrivilegeSet->Privilege[j].Luid), pLuid))
3322 {
3323 Index = j;
3324 break;
3325 }
3326 }
3327
3328 if (Index != -1)
3329 {
3330 /* Remove the privilege */
3331 if ((PrivilegeSet->PrivilegeCount > 1) &&
3332 (Index < PrivilegeSet->PrivilegeCount - 1))
3333 RtlMoveMemory(&(PrivilegeSet->Privilege[Index]),
3334 &(PrivilegeSet->Privilege[Index + 1]),
3335 (Index - PrivilegeSet->PrivilegeCount - 1) * sizeof(LUID));
3336
3337 /* Wipe the last entry */
3338 RtlZeroMemory(&(PrivilegeSet->Privilege[PrivilegeSet->PrivilegeCount - 1]),
3339 sizeof(LUID));
3340
3341 PrivilegeSet->PrivilegeCount--;
3342 }
3343 }
3344
3345 /* Store the extended privilege set */
3346 if (PrivilegeCount != PrivilegeSet->PrivilegeCount)
3347 {
3348 Size = sizeof(PRIVILEGE_SET) +
3349 (PrivilegeSet->PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
3350
3351 Status = LsapSetObjectAttribute(AccountObject,
3352 L"Privilgs",
3353 PrivilegeSet,
3354 Size);
3355 if (!NT_SUCCESS(Status))
3356 {
3357 ERR("LsapSetObjectAttribute() failed (Status 0x%08lx)\n", Status);
3358 goto done;
3359 }
3360 }
3361 }
3362
3363 /* Get the system access flags, if the attribute exists */
3364 Size = 0;
3365 Status = LsapGetObjectAttribute(AccountObject,
3366 L"ActSysAc",
3367 &SystemAccess,
3368 &Size);
3369 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3370 goto done;
3371
3372 if ((Size != 0) && (RightsToRemove != 0))
3373 {
3374 ERR("Rights: 0x%lx\n", SystemAccess);
3375
3376 /* Set the new access rights */
3377 for (i = 0; i < UserRights->Entries; i++)
3378 {
3379 Value = LsapLookupAccountRightValue(&UserRights->UserRights[i]);
3380 if (Value != 0)
3381 SystemAccess &= ~Value;
3382 }
3383 ERR("New Rights: 0x%lx\n", SystemAccess);
3384
3385 /* Set the system access flags */
3386 Status = LsapSetObjectAttribute(AccountObject,
3387 L"ActSysAc",
3388 &SystemAccess,
3389 sizeof(ACCESS_MASK));
3390 }
3391 }
3392 else
3393 {
3394 }
3395
3396 done:
3397 if (PrivilegeSet != NULL)
3398 RtlFreeHeap(RtlGetProcessHeap(), 0, PrivilegeSet);
3399
3400 if (AccountObject != NULL)
3401 LsapCloseDbObject(AccountObject);
3402
3403 return Status;
3404 }
3405
3406
3407 /* Function 39 */
3408 NTSTATUS
3409 WINAPI
LsarQueryTrustedDomainInfo(LSAPR_HANDLE PolicyHandle,PRPC_SID TrustedDomainSid,TRUSTED_INFORMATION_CLASS InformationClass,PLSAPR_TRUSTED_DOMAIN_INFO * TrustedDomainInformation)3410 LsarQueryTrustedDomainInfo(
3411 LSAPR_HANDLE PolicyHandle,
3412 PRPC_SID TrustedDomainSid,
3413 TRUSTED_INFORMATION_CLASS InformationClass,
3414 PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
3415 {
3416 /* Fail, if we are not a domain controller */
3417 if (LsapProductType != NtProductLanManNt)
3418 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3419
3420 UNIMPLEMENTED;
3421 return STATUS_NOT_IMPLEMENTED;
3422 }
3423
3424
3425 /* Function 40 */
3426 NTSTATUS
3427 WINAPI
LsarSetTrustedDomainInfo(LSAPR_HANDLE PolicyHandle,PRPC_SID TrustedDomainSid,TRUSTED_INFORMATION_CLASS InformationClass,PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)3428 LsarSetTrustedDomainInfo(
3429 LSAPR_HANDLE PolicyHandle,
3430 PRPC_SID TrustedDomainSid,
3431 TRUSTED_INFORMATION_CLASS InformationClass,
3432 PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
3433 {
3434 /* Fail, if we are not a domain controller */
3435 if (LsapProductType != NtProductLanManNt)
3436 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3437
3438 UNIMPLEMENTED;
3439 return STATUS_NOT_IMPLEMENTED;
3440 }
3441
3442
3443 /* Function 41 */
3444 NTSTATUS
3445 WINAPI
LsarDeleteTrustedDomain(LSAPR_HANDLE PolicyHandle,PRPC_SID TrustedDomainSid)3446 LsarDeleteTrustedDomain(
3447 LSAPR_HANDLE PolicyHandle,
3448 PRPC_SID TrustedDomainSid)
3449 {
3450 /* Fail, if we are not a domain controller */
3451 if (LsapProductType != NtProductLanManNt)
3452 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3453
3454 UNIMPLEMENTED;
3455 return STATUS_NOT_IMPLEMENTED;
3456 }
3457
3458
3459 /* Function 42 */
3460 NTSTATUS
3461 WINAPI
LsarStorePrivateData(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING KeyName,PLSAPR_CR_CIPHER_VALUE EncryptedData)3462 LsarStorePrivateData(
3463 LSAPR_HANDLE PolicyHandle,
3464 PRPC_UNICODE_STRING KeyName,
3465 PLSAPR_CR_CIPHER_VALUE EncryptedData)
3466 {
3467 PLSA_DB_OBJECT PolicyObject = NULL;
3468 PLSA_DB_OBJECT SecretsObject = NULL;
3469 PLSA_DB_OBJECT SecretObject = NULL;
3470 LARGE_INTEGER Time;
3471 PBYTE Value = NULL;
3472 ULONG ValueLength = 0;
3473 NTSTATUS Status;
3474
3475 TRACE("LsarStorePrivateData(%p %p %p)\n",
3476 PolicyHandle, KeyName, EncryptedData);
3477
3478 /* Validate the SecretHandle */
3479 Status = LsapValidateDbObject(PolicyHandle,
3480 LsaDbPolicyObject,
3481 POLICY_CREATE_SECRET,
3482 &PolicyObject);
3483 if (!NT_SUCCESS(Status))
3484 {
3485 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
3486 return Status;
3487 }
3488
3489 /* Open the 'Secrets' object */
3490 Status = LsapOpenDbObject(PolicyObject,
3491 NULL,
3492 L"Secrets",
3493 LsaDbIgnoreObject,
3494 0,
3495 PolicyObject->Trusted,
3496 &SecretsObject);
3497 if (!NT_SUCCESS(Status))
3498 {
3499 ERR("LsapOpenDbObject failed (Status 0x%08lx)\n", Status);
3500 goto done;
3501 }
3502
3503 if (EncryptedData == NULL)
3504 {
3505 /* Open the Secret object */
3506 Status = LsapOpenDbObject(SecretsObject,
3507 NULL,
3508 KeyName->Buffer,
3509 LsaDbSecretObject,
3510 0,
3511 PolicyObject->Trusted,
3512 &SecretObject);
3513 if (!NT_SUCCESS(Status))
3514 {
3515 ERR("LsapOpenDbObject failed (Status 0x%08lx)\n", Status);
3516 goto done;
3517 }
3518
3519 /* Delete the secret */
3520 Status = LsapDeleteDbObject(SecretObject);
3521 if (NT_SUCCESS(Status))
3522 SecretObject = NULL;
3523 }
3524 else
3525 {
3526 /* Create the Secret object */
3527 Status = LsapCreateDbObject(SecretsObject,
3528 NULL,
3529 KeyName->Buffer,
3530 LsaDbSecretObject,
3531 0,
3532 PolicyObject->Trusted,
3533 &SecretObject);
3534 if (!NT_SUCCESS(Status))
3535 {
3536 ERR("LsapCreateDbObject failed (Status 0x%08lx)\n", Status);
3537 goto done;
3538 }
3539
3540 /* FIXME: Decrypt data */
3541 Value = EncryptedData->Buffer;
3542 ValueLength = EncryptedData->MaximumLength;
3543
3544 /* Get the current time */
3545 Status = NtQuerySystemTime(&Time);
3546 if (!NT_SUCCESS(Status))
3547 {
3548 ERR("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
3549 goto done;
3550 }
3551
3552 /* Set the current value */
3553 Status = LsapSetObjectAttribute(SecretObject,
3554 L"CurrentValue",
3555 Value,
3556 ValueLength);
3557 if (!NT_SUCCESS(Status))
3558 {
3559 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
3560 goto done;
3561 }
3562
3563 /* Set the current time */
3564 Status = LsapSetObjectAttribute(SecretObject,
3565 L"CurrentTime",
3566 &Time,
3567 sizeof(LARGE_INTEGER));
3568 if (!NT_SUCCESS(Status))
3569 {
3570 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
3571 goto done;
3572 }
3573
3574 /* Get the current time */
3575 Status = NtQuerySystemTime(&Time);
3576 if (!NT_SUCCESS(Status))
3577 {
3578 ERR("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
3579 goto done;
3580 }
3581
3582 /* Set the old value */
3583 Status = LsapSetObjectAttribute(SecretObject,
3584 L"OldValue",
3585 NULL,
3586 0);
3587 if (!NT_SUCCESS(Status))
3588 {
3589 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
3590 goto done;
3591 }
3592
3593 /* Set the old time */
3594 Status = LsapSetObjectAttribute(SecretObject,
3595 L"OldTime",
3596 &Time,
3597 sizeof(LARGE_INTEGER));
3598 if (!NT_SUCCESS(Status))
3599 {
3600 ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
3601 }
3602 }
3603
3604 done:
3605 if (SecretObject != NULL)
3606 LsapCloseDbObject(SecretObject);
3607
3608 if (SecretsObject != NULL)
3609 LsapCloseDbObject(SecretsObject);
3610
3611 return Status;
3612 }
3613
3614
3615 /* Function 43 */
3616 NTSTATUS
3617 WINAPI
LsarRetrievePrivateData(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING KeyName,PLSAPR_CR_CIPHER_VALUE * EncryptedData)3618 LsarRetrievePrivateData(
3619 LSAPR_HANDLE PolicyHandle,
3620 PRPC_UNICODE_STRING KeyName,
3621 PLSAPR_CR_CIPHER_VALUE *EncryptedData)
3622 {
3623 PLSA_DB_OBJECT PolicyObject = NULL;
3624 PLSA_DB_OBJECT SecretObject = NULL;
3625 PLSAPR_CR_CIPHER_VALUE EncCurrentValue = NULL;
3626 ULONG CurrentValueLength = 0;
3627 PBYTE CurrentValue = NULL;
3628 NTSTATUS Status;
3629
3630 TRACE("LsarRetrievePrivateData(%p %wZ %p)\n",
3631 PolicyHandle, KeyName, EncryptedData);
3632
3633 /* Validate the SecretHandle */
3634 Status = LsapValidateDbObject(PolicyHandle,
3635 LsaDbPolicyObject,
3636 POLICY_CREATE_SECRET,
3637 &PolicyObject);
3638 if (!NT_SUCCESS(Status))
3639 {
3640 ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
3641 return Status;
3642 }
3643
3644 /* Open the secret object */
3645 Status = LsapOpenDbObject(PolicyObject,
3646 L"Secrets",
3647 KeyName->Buffer,
3648 LsaDbSecretObject,
3649 0,
3650 PolicyObject->Trusted,
3651 &SecretObject);
3652 if (!NT_SUCCESS(Status))
3653 {
3654 ERR("LsapOpenDbObject failed (Status 0x%08lx)\n", Status);
3655 goto done;
3656 }
3657
3658 /* Get the size of the current value */
3659 Status = LsapGetObjectAttribute(SecretObject,
3660 L"CurrentValue",
3661 NULL,
3662 &CurrentValueLength);
3663 if (!NT_SUCCESS(Status))
3664 goto done;
3665
3666 /* Allocate a buffer for the current value */
3667 CurrentValue = midl_user_allocate(CurrentValueLength);
3668 if (CurrentValue == NULL)
3669 {
3670 Status = STATUS_INSUFFICIENT_RESOURCES;
3671 goto done;
3672 }
3673
3674 /* Get the current value */
3675 Status = LsapGetObjectAttribute(SecretObject,
3676 L"CurrentValue",
3677 CurrentValue,
3678 &CurrentValueLength);
3679 if (!NT_SUCCESS(Status))
3680 goto done;
3681
3682 /* Allocate a buffer for the encrypted current value */
3683 EncCurrentValue = midl_user_allocate(sizeof(LSAPR_CR_CIPHER_VALUE) + CurrentValueLength);
3684 if (EncCurrentValue == NULL)
3685 {
3686 Status = STATUS_INSUFFICIENT_RESOURCES;
3687 goto done;
3688 }
3689
3690 /* FIXME: Encrypt the current value */
3691 EncCurrentValue->Length = (USHORT)(CurrentValueLength - sizeof(WCHAR));
3692 EncCurrentValue->MaximumLength = (USHORT)CurrentValueLength;
3693 EncCurrentValue->Buffer = (PBYTE)(EncCurrentValue + 1);
3694 RtlCopyMemory(EncCurrentValue->Buffer,
3695 CurrentValue,
3696 CurrentValueLength);
3697
3698 done:
3699 if (NT_SUCCESS(Status))
3700 {
3701 if (EncryptedData != NULL)
3702 *EncryptedData = EncCurrentValue;
3703 }
3704 else
3705 {
3706 if (EncryptedData != NULL)
3707 *EncryptedData = NULL;
3708
3709 if (EncCurrentValue != NULL)
3710 midl_user_free(EncCurrentValue);
3711 }
3712
3713 if (SecretObject != NULL)
3714 LsapCloseDbObject(SecretObject);
3715
3716 return Status;
3717 }
3718
3719
3720 /* Function 44 */
3721 NTSTATUS
3722 WINAPI
LsarOpenPolicy2(LPWSTR SystemName,PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * PolicyHandle)3723 LsarOpenPolicy2(
3724 LPWSTR SystemName,
3725 PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
3726 ACCESS_MASK DesiredAccess,
3727 LSAPR_HANDLE *PolicyHandle)
3728 {
3729 return LsarOpenPolicy(SystemName,
3730 ObjectAttributes,
3731 DesiredAccess,
3732 PolicyHandle);
3733 }
3734
3735
3736 /* Function 45 */
3737 NTSTATUS
3738 WINAPI
LsarGetUserName(LPWSTR SystemName,PRPC_UNICODE_STRING * UserName,PRPC_UNICODE_STRING * DomainName)3739 LsarGetUserName(
3740 LPWSTR SystemName,
3741 PRPC_UNICODE_STRING *UserName,
3742 PRPC_UNICODE_STRING *DomainName)
3743 {
3744 UNIMPLEMENTED;
3745 return STATUS_NOT_IMPLEMENTED;
3746 }
3747
3748
3749 /* Function 46 */
3750 NTSTATUS
3751 WINAPI
LsarQueryInformationPolicy2(LSAPR_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_POLICY_INFORMATION * PolicyInformation)3752 LsarQueryInformationPolicy2(
3753 LSAPR_HANDLE PolicyHandle,
3754 POLICY_INFORMATION_CLASS InformationClass,
3755 PLSAPR_POLICY_INFORMATION *PolicyInformation)
3756 {
3757 return LsarQueryInformationPolicy(PolicyHandle,
3758 InformationClass,
3759 PolicyInformation);
3760 }
3761
3762
3763 /* Function 47 */
3764 NTSTATUS
3765 WINAPI
LsarSetInformationPolicy2(LSAPR_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_POLICY_INFORMATION PolicyInformation)3766 LsarSetInformationPolicy2(
3767 LSAPR_HANDLE PolicyHandle,
3768 POLICY_INFORMATION_CLASS InformationClass,
3769 PLSAPR_POLICY_INFORMATION PolicyInformation)
3770 {
3771 return LsarSetInformationPolicy(PolicyHandle,
3772 InformationClass,
3773 PolicyInformation);
3774 }
3775
3776
3777 /* Function 48 */
3778 NTSTATUS
3779 WINAPI
LsarQueryTrustedDomainInfoByName(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING TrustedDomainName,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_TRUSTED_DOMAIN_INFO * PolicyInformation)3780 LsarQueryTrustedDomainInfoByName(
3781 LSAPR_HANDLE PolicyHandle,
3782 PRPC_UNICODE_STRING TrustedDomainName,
3783 POLICY_INFORMATION_CLASS InformationClass,
3784 PLSAPR_TRUSTED_DOMAIN_INFO *PolicyInformation)
3785 {
3786 /* Fail, if we are not a domain controller */
3787 if (LsapProductType != NtProductLanManNt)
3788 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3789
3790 /* FIXME: We are not running an AD yet */
3791 return STATUS_OBJECT_NAME_NOT_FOUND;
3792 }
3793
3794
3795 /* Function 49 */
3796 NTSTATUS
3797 WINAPI
LsarSetTrustedDomainInfoByName(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING TrustedDomainName,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_TRUSTED_DOMAIN_INFO PolicyInformation)3798 LsarSetTrustedDomainInfoByName(
3799 LSAPR_HANDLE PolicyHandle,
3800 PRPC_UNICODE_STRING TrustedDomainName,
3801 POLICY_INFORMATION_CLASS InformationClass,
3802 PLSAPR_TRUSTED_DOMAIN_INFO PolicyInformation)
3803 {
3804 /* Fail, if we are not a domain controller */
3805 if (LsapProductType != NtProductLanManNt)
3806 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3807
3808 /* FIXME: We are not running an AD yet */
3809 return STATUS_OBJECT_NAME_NOT_FOUND;
3810 }
3811
3812
3813 /* Function 50 */
3814 NTSTATUS
3815 WINAPI
LsarEnumerateTrustedDomainsEx(LSAPR_HANDLE PolicyHandle,DWORD * EnumerationContext,PLSAPR_TRUSTED_ENUM_BUFFER_EX EnumerationBuffer,DWORD PreferedMaximumLength)3816 LsarEnumerateTrustedDomainsEx(
3817 LSAPR_HANDLE PolicyHandle,
3818 DWORD *EnumerationContext,
3819 PLSAPR_TRUSTED_ENUM_BUFFER_EX EnumerationBuffer,
3820 DWORD PreferedMaximumLength)
3821 {
3822 /* Fail, if we are not a domain controller */
3823 if (LsapProductType != NtProductLanManNt)
3824 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3825
3826 /* FIXME: We are not running an AD yet */
3827 EnumerationBuffer->EntriesRead = 0;
3828 EnumerationBuffer->EnumerationBuffer = NULL;
3829 return STATUS_NO_MORE_ENTRIES;
3830 }
3831
3832
3833 /* Function 51 */
3834 NTSTATUS
3835 WINAPI
LsarCreateTrustedDomainEx(LSAPR_HANDLE PolicyHandle,PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION AuthentificationInformation,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * TrustedDomainHandle)3836 LsarCreateTrustedDomainEx(
3837 LSAPR_HANDLE PolicyHandle,
3838 PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
3839 PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION AuthentificationInformation,
3840 ACCESS_MASK DesiredAccess,
3841 LSAPR_HANDLE *TrustedDomainHandle)
3842 {
3843 /* Fail, if we are not a domain controller */
3844 if (LsapProductType != NtProductLanManNt)
3845 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3846
3847 UNIMPLEMENTED;
3848 return STATUS_NOT_IMPLEMENTED;
3849 }
3850
3851
3852 /* Function 52 */
3853 NTSTATUS
3854 WINAPI
LsarSetPolicyReplicationHandle(PLSAPR_HANDLE PolicyHandle)3855 LsarSetPolicyReplicationHandle(
3856 PLSAPR_HANDLE PolicyHandle)
3857 {
3858 /* Deprecated */
3859 return STATUS_NOT_IMPLEMENTED;
3860 }
3861
3862
3863 /* Function 53 */
3864 NTSTATUS
3865 WINAPI
LsarQueryDomainInformationPolicy(LSAPR_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_POLICY_DOMAIN_INFORMATION * PolicyInformation)3866 LsarQueryDomainInformationPolicy(
3867 LSAPR_HANDLE PolicyHandle,
3868 POLICY_INFORMATION_CLASS InformationClass,
3869 PLSAPR_POLICY_DOMAIN_INFORMATION *PolicyInformation)
3870 {
3871 UNIMPLEMENTED;
3872 return STATUS_NOT_IMPLEMENTED;
3873 }
3874
3875
3876 /* Function 54 */
3877 NTSTATUS
3878 WINAPI
LsarSetDomainInformationPolicy(LSAPR_HANDLE PolicyHandle,POLICY_INFORMATION_CLASS InformationClass,PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation)3879 LsarSetDomainInformationPolicy(
3880 LSAPR_HANDLE PolicyHandle,
3881 POLICY_INFORMATION_CLASS InformationClass,
3882 PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation)
3883 {
3884 UNIMPLEMENTED;
3885 return STATUS_NOT_IMPLEMENTED;
3886 }
3887
3888
3889 /* Function 55 */
3890 NTSTATUS
3891 WINAPI
LsarOpenTrustedDomainByName(LSAPR_HANDLE PolicyHandle,PRPC_UNICODE_STRING TrustedDomainName,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * TrustedDomainHandle)3892 LsarOpenTrustedDomainByName(
3893 LSAPR_HANDLE PolicyHandle,
3894 PRPC_UNICODE_STRING TrustedDomainName,
3895 ACCESS_MASK DesiredAccess,
3896 LSAPR_HANDLE *TrustedDomainHandle)
3897 {
3898 /* Fail, if we are not a domain controller */
3899 if (LsapProductType != NtProductLanManNt)
3900 return STATUS_DIRECTORY_SERVICE_REQUIRED;
3901
3902 UNIMPLEMENTED;
3903 return STATUS_NOT_IMPLEMENTED;
3904 }
3905
3906
3907 /* Function 56 */
3908 NTSTATUS
3909 WINAPI
LsarTestCall(handle_t hBinding)3910 LsarTestCall(
3911 handle_t hBinding)
3912 {
3913 UNIMPLEMENTED;
3914 return STATUS_NOT_IMPLEMENTED;
3915 }
3916
3917
3918 /* Function 57 */
3919 NTSTATUS
3920 WINAPI
LsarLookupSids2(LSAPR_HANDLE PolicyHandle,PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount,DWORD LookupOptions,DWORD ClientRevision)3921 LsarLookupSids2(
3922 LSAPR_HANDLE PolicyHandle,
3923 PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
3924 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
3925 PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
3926 LSAP_LOOKUP_LEVEL LookupLevel,
3927 DWORD *MappedCount,
3928 DWORD LookupOptions,
3929 DWORD ClientRevision)
3930 {
3931 NTSTATUS Status;
3932
3933 TRACE("LsarLookupSids2(%p %p %p %p %d %p %lu %lu)\n",
3934 PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
3935 LookupLevel, MappedCount, LookupOptions, ClientRevision);
3936
3937 TranslatedNames->Entries = SidEnumBuffer->Entries;
3938 TranslatedNames->Names = NULL;
3939 *ReferencedDomains = NULL;
3940
3941 /* FIXME: Fail, if there is an invalid SID in the SidEnumBuffer */
3942
3943 Status = LsapLookupSids(SidEnumBuffer,
3944 ReferencedDomains,
3945 TranslatedNames,
3946 LookupLevel,
3947 MappedCount,
3948 LookupOptions,
3949 ClientRevision);
3950
3951 return Status;
3952 }
3953
3954
3955 /* Function 58 */
3956 NTSTATUS
3957 WINAPI
LsarLookupNames2(LSAPR_HANDLE PolicyHandle,DWORD Count,PRPC_UNICODE_STRING Names,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_SIDS_EX TranslatedSids,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount,DWORD LookupOptions,DWORD ClientRevision)3958 LsarLookupNames2(
3959 LSAPR_HANDLE PolicyHandle,
3960 DWORD Count,
3961 PRPC_UNICODE_STRING Names,
3962 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
3963 PLSAPR_TRANSLATED_SIDS_EX TranslatedSids,
3964 LSAP_LOOKUP_LEVEL LookupLevel,
3965 DWORD *MappedCount,
3966 DWORD LookupOptions,
3967 DWORD ClientRevision)
3968 {
3969 LSAPR_TRANSLATED_SIDS_EX2 TranslatedSidsEx2;
3970 ULONG i;
3971 NTSTATUS Status;
3972
3973 TRACE("LsarLookupNames2(%p %lu %p %p %p %d %p %lu %lu)\n",
3974 PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
3975 LookupLevel, MappedCount, LookupOptions, ClientRevision);
3976
3977 TranslatedSids->Entries = 0;
3978 TranslatedSids->Sids = NULL;
3979 *ReferencedDomains = NULL;
3980
3981 if (Count == 0)
3982 return STATUS_NONE_MAPPED;
3983
3984 TranslatedSidsEx2.Entries = 0;
3985 TranslatedSidsEx2.Sids = NULL;
3986
3987 Status = LsapLookupNames(Count,
3988 Names,
3989 ReferencedDomains,
3990 &TranslatedSidsEx2,
3991 LookupLevel,
3992 MappedCount,
3993 LookupOptions,
3994 ClientRevision);
3995 if (!NT_SUCCESS(Status))
3996 return Status;
3997
3998 TranslatedSids->Entries = TranslatedSidsEx2.Entries;
3999 TranslatedSids->Sids = MIDL_user_allocate(TranslatedSids->Entries * sizeof(LSA_TRANSLATED_SID));
4000 if (TranslatedSids->Sids == NULL)
4001 {
4002 MIDL_user_free(TranslatedSidsEx2.Sids);
4003 MIDL_user_free(*ReferencedDomains);
4004 *ReferencedDomains = NULL;
4005 return STATUS_INSUFFICIENT_RESOURCES;
4006 }
4007
4008 for (i = 0; i < TranslatedSidsEx2.Entries; i++)
4009 {
4010 TranslatedSids->Sids[i].Use = TranslatedSidsEx2.Sids[i].Use;
4011 TranslatedSids->Sids[i].RelativeId = LsapGetRelativeIdFromSid(TranslatedSidsEx2.Sids[i].Sid);
4012 TranslatedSids->Sids[i].DomainIndex = TranslatedSidsEx2.Sids[i].DomainIndex;
4013 TranslatedSids->Sids[i].Flags = TranslatedSidsEx2.Sids[i].Flags;
4014 }
4015
4016 MIDL_user_free(TranslatedSidsEx2.Sids);
4017
4018 return STATUS_SUCCESS;
4019 }
4020
4021
4022 /* Function 59 */
4023 NTSTATUS
4024 WINAPI
LsarCreateTrustedDomainEx2(LSAPR_HANDLE PolicyHandle,PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL AuthentificationInformation,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * TrustedDomainHandle)4025 LsarCreateTrustedDomainEx2(
4026 LSAPR_HANDLE PolicyHandle,
4027 PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
4028 PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL AuthentificationInformation,
4029 ACCESS_MASK DesiredAccess,
4030 LSAPR_HANDLE *TrustedDomainHandle)
4031 {
4032 /* Fail, if we are not a domain controller */
4033 if (LsapProductType != NtProductLanManNt)
4034 return STATUS_DIRECTORY_SERVICE_REQUIRED;
4035
4036 UNIMPLEMENTED;
4037 return STATUS_NOT_IMPLEMENTED;
4038 }
4039
4040
4041 /* Function 60 */
4042 NTSTATUS
4043 WINAPI
CredrWrite(PLSAPR_SERVER_NAME SystemName)4044 CredrWrite(
4045 PLSAPR_SERVER_NAME SystemName)
4046 {
4047 UNIMPLEMENTED;
4048 return STATUS_NOT_IMPLEMENTED;
4049 }
4050
4051
4052 /* Function 61 */
4053 NTSTATUS
4054 WINAPI
CredrRead(PLSAPR_SERVER_NAME SystemName)4055 CredrRead(
4056 PLSAPR_SERVER_NAME SystemName)
4057 {
4058 UNIMPLEMENTED;
4059 return STATUS_NOT_IMPLEMENTED;
4060 }
4061
4062
4063 /* Function 62 */
4064 NTSTATUS
4065 WINAPI
CredrEnumerate(PLSAPR_SERVER_NAME SystemName)4066 CredrEnumerate(
4067 PLSAPR_SERVER_NAME SystemName)
4068 {
4069 UNIMPLEMENTED;
4070 return STATUS_NOT_IMPLEMENTED;
4071 }
4072
4073
4074 /* Function 63 */
4075 NTSTATUS
4076 WINAPI
CredrWriteDomainCredentials(PLSAPR_SERVER_NAME SystemName)4077 CredrWriteDomainCredentials(
4078 PLSAPR_SERVER_NAME SystemName)
4079 {
4080 UNIMPLEMENTED;
4081 return STATUS_NOT_IMPLEMENTED;
4082 }
4083
4084
4085 /* Function 64 */
4086 NTSTATUS
4087 WINAPI
CredrReadDomainCredentials(PLSAPR_SERVER_NAME SystemName)4088 CredrReadDomainCredentials(
4089 PLSAPR_SERVER_NAME SystemName)
4090 {
4091 UNIMPLEMENTED;
4092 return STATUS_NOT_IMPLEMENTED;
4093 }
4094
4095
4096 /* Function 65 */
4097 NTSTATUS
4098 WINAPI
CredrDelete(PLSAPR_SERVER_NAME SystemName,LPWSTR TargetName,DWORD Type,DWORD Flags)4099 CredrDelete(
4100 PLSAPR_SERVER_NAME SystemName,
4101 LPWSTR TargetName,
4102 DWORD Type,
4103 DWORD Flags)
4104 {
4105 UNIMPLEMENTED;
4106 return STATUS_NOT_IMPLEMENTED;
4107 }
4108
4109
4110 /* Function 66 */
4111 NTSTATUS
4112 WINAPI
CredrGetTargetInfo(PLSAPR_SERVER_NAME SystemName,LPWSTR TargetName,DWORD Flags,CREDPR_TARGET_INFORMATION * TargetInformation)4113 CredrGetTargetInfo(
4114 PLSAPR_SERVER_NAME SystemName,
4115 LPWSTR TargetName,
4116 DWORD Flags,
4117 CREDPR_TARGET_INFORMATION *TargetInformation)
4118 {
4119 UNIMPLEMENTED;
4120 return STATUS_NOT_IMPLEMENTED;
4121 }
4122
4123
4124 /* Function 67 */
4125 NTSTATUS
4126 WINAPI
CredrProfileLoaded(PLSAPR_SERVER_NAME SystemName)4127 CredrProfileLoaded(
4128 PLSAPR_SERVER_NAME SystemName)
4129 {
4130 UNIMPLEMENTED;
4131 return STATUS_NOT_IMPLEMENTED;
4132 }
4133
4134
4135 /* Function 68 */
4136 NTSTATUS
4137 WINAPI
LsarLookupNames3(LSAPR_HANDLE PolicyHandle,DWORD Count,PRPC_UNICODE_STRING Names,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount,DWORD LookupOptions,DWORD ClientRevision)4138 LsarLookupNames3(
4139 LSAPR_HANDLE PolicyHandle,
4140 DWORD Count,
4141 PRPC_UNICODE_STRING Names,
4142 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
4143 PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
4144 LSAP_LOOKUP_LEVEL LookupLevel,
4145 DWORD *MappedCount,
4146 DWORD LookupOptions,
4147 DWORD ClientRevision)
4148 {
4149 NTSTATUS Status;
4150
4151 TRACE("LsarLookupNames3(%p %lu %p %p %p %d %p %lu %lu)\n",
4152 PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
4153 LookupLevel, MappedCount, LookupOptions, ClientRevision);
4154
4155 TranslatedSids->Entries = 0;
4156 TranslatedSids->Sids = NULL;
4157 *ReferencedDomains = NULL;
4158
4159 if (Count == 0)
4160 return STATUS_NONE_MAPPED;
4161
4162 Status = LsapLookupNames(Count,
4163 Names,
4164 ReferencedDomains,
4165 TranslatedSids,
4166 LookupLevel,
4167 MappedCount,
4168 LookupOptions,
4169 ClientRevision);
4170
4171 return Status;
4172 }
4173
4174
4175 /* Function 69 */
4176 NTSTATUS
4177 WINAPI
CredrGetSessionTypes(PLSAPR_SERVER_NAME SystemName,DWORD MaximumPersistCount,DWORD * MaximumPersist)4178 CredrGetSessionTypes(
4179 PLSAPR_SERVER_NAME SystemName,
4180 DWORD MaximumPersistCount,
4181 DWORD *MaximumPersist)
4182 {
4183 UNIMPLEMENTED;
4184 return STATUS_NOT_IMPLEMENTED;
4185 }
4186
4187
4188 /* Function 70 */
4189 NTSTATUS
4190 WINAPI
LsarRegisterAuditEvent(handle_t hBinding)4191 LsarRegisterAuditEvent(
4192 handle_t hBinding)
4193 {
4194 UNIMPLEMENTED;
4195 return STATUS_NOT_IMPLEMENTED;
4196 }
4197
4198
4199 /* Function 71 */
4200 NTSTATUS
4201 WINAPI
LsarGenAuditEvent(handle_t hBinding)4202 LsarGenAuditEvent(
4203 handle_t hBinding)
4204 {
4205 UNIMPLEMENTED;
4206 return STATUS_NOT_IMPLEMENTED;
4207 }
4208
4209
4210 /* Function 72 */
4211 NTSTATUS
4212 WINAPI
LsarUnregisterAuditEvent(handle_t hBinding)4213 LsarUnregisterAuditEvent(
4214 handle_t hBinding)
4215 {
4216 UNIMPLEMENTED;
4217 return STATUS_NOT_IMPLEMENTED;
4218 }
4219
4220
4221 /* Function 73 */
4222 NTSTATUS
4223 WINAPI
LsarQueryForestTrustInformation(LSAPR_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)4224 LsarQueryForestTrustInformation(
4225 LSAPR_HANDLE PolicyHandle,
4226 PLSA_UNICODE_STRING TrustedDomainName,
4227 LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
4228 PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
4229 {
4230 UNIMPLEMENTED;
4231 return STATUS_NOT_IMPLEMENTED;
4232 }
4233
4234
4235 /* Function 74 */
4236 NTSTATUS
4237 WINAPI
LsarSetForestTrustInformation(LSAPR_HANDLE PolicyHandle,PLSA_UNICODE_STRING TrustedDomainName,LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,BOOLEAN CheckOnly,PLSA_FOREST_TRUST_COLLISION_INFORMATION * CollisionInfo)4238 LsarSetForestTrustInformation(
4239 LSAPR_HANDLE PolicyHandle,
4240 PLSA_UNICODE_STRING TrustedDomainName,
4241 LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
4242 PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
4243 BOOLEAN CheckOnly,
4244 PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
4245 {
4246 UNIMPLEMENTED;
4247 return STATUS_NOT_IMPLEMENTED;
4248 }
4249
4250
4251 /* Function 75 */
4252 NTSTATUS
4253 WINAPI
CredrRename(PLSAPR_SERVER_NAME SystemName,LPWSTR OldTargetName,LPWSTR NewTargetName,DWORD Type,DWORD Flags)4254 CredrRename(
4255 PLSAPR_SERVER_NAME SystemName,
4256 LPWSTR OldTargetName,
4257 LPWSTR NewTargetName,
4258 DWORD Type,
4259 DWORD Flags)
4260 {
4261 UNIMPLEMENTED;
4262 return STATUS_NOT_IMPLEMENTED;
4263 }
4264
4265
4266 /* Function 76 */
4267 NTSTATUS
4268 WINAPI
LsarLookupSids3(LSAPR_HANDLE PolicyHandle,PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount,DWORD LookupOptions,DWORD ClientRevision)4269 LsarLookupSids3(
4270 LSAPR_HANDLE PolicyHandle,
4271 PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
4272 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
4273 PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
4274 LSAP_LOOKUP_LEVEL LookupLevel,
4275 DWORD *MappedCount,
4276 DWORD LookupOptions,
4277 DWORD ClientRevision)
4278 {
4279 NTSTATUS Status;
4280
4281 TRACE("LsarLookupSids3(%p %p %p %p %d %p %lu %lu)\n",
4282 PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
4283 LookupLevel, MappedCount, LookupOptions, ClientRevision);
4284
4285 TranslatedNames->Entries = SidEnumBuffer->Entries;
4286 TranslatedNames->Names = NULL;
4287 *ReferencedDomains = NULL;
4288
4289 /* FIXME: Fail, if there is an invalid SID in the SidEnumBuffer */
4290
4291 Status = LsapLookupSids(SidEnumBuffer,
4292 ReferencedDomains,
4293 TranslatedNames,
4294 LookupLevel,
4295 MappedCount,
4296 LookupOptions,
4297 ClientRevision);
4298
4299 return Status;
4300 }
4301
4302
4303 /* Function 77 */
4304 NTSTATUS
4305 WINAPI
LsarLookupNames4(handle_t RpcHandle,DWORD Count,PRPC_UNICODE_STRING Names,PLSAPR_REFERENCED_DOMAIN_LIST * ReferencedDomains,PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,LSAP_LOOKUP_LEVEL LookupLevel,DWORD * MappedCount,DWORD LookupOptions,DWORD ClientRevision)4306 LsarLookupNames4(
4307 handle_t RpcHandle,
4308 DWORD Count,
4309 PRPC_UNICODE_STRING Names,
4310 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
4311 PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
4312 LSAP_LOOKUP_LEVEL LookupLevel,
4313 DWORD *MappedCount,
4314 DWORD LookupOptions,
4315 DWORD ClientRevision)
4316 {
4317 NTSTATUS Status;
4318
4319 TRACE("LsarLookupNames4(%p %lu %p %p %p %d %p %lu %lu)\n",
4320 RpcHandle, Count, Names, ReferencedDomains, TranslatedSids,
4321 LookupLevel, MappedCount, LookupOptions, ClientRevision);
4322
4323 TranslatedSids->Entries = 0;
4324 TranslatedSids->Sids = NULL;
4325 *ReferencedDomains = NULL;
4326
4327 if (Count == 0)
4328 return STATUS_NONE_MAPPED;
4329
4330 Status = LsapLookupNames(Count,
4331 Names,
4332 ReferencedDomains,
4333 TranslatedSids,
4334 LookupLevel,
4335 MappedCount,
4336 LookupOptions,
4337 ClientRevision);
4338
4339 return Status;
4340 }
4341
4342
4343 /* Function 78 */
4344 NTSTATUS
4345 WINAPI
LsarOpenPolicySce(LPWSTR SystemName,PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,ACCESS_MASK DesiredAccess,LSAPR_HANDLE * PolicyHandle)4346 LsarOpenPolicySce(
4347 LPWSTR SystemName,
4348 PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
4349 ACCESS_MASK DesiredAccess,
4350 LSAPR_HANDLE *PolicyHandle)
4351 {
4352 UNIMPLEMENTED;
4353 return STATUS_NOT_IMPLEMENTED;
4354 }
4355
4356
4357 /* Function 79 */
4358 NTSTATUS
4359 WINAPI
LsarAdtRegisterSecurityEventSource(handle_t hBinding)4360 LsarAdtRegisterSecurityEventSource(
4361 handle_t hBinding)
4362 {
4363 UNIMPLEMENTED;
4364 return STATUS_NOT_IMPLEMENTED;
4365 }
4366
4367
4368 /* Function 80 */
4369 NTSTATUS
4370 WINAPI
LsarAdtUnregisterSecurityEventSource(handle_t hBinding)4371 LsarAdtUnregisterSecurityEventSource(
4372 handle_t hBinding)
4373 {
4374 UNIMPLEMENTED;
4375 return STATUS_NOT_IMPLEMENTED;
4376 }
4377
4378
4379 /* Function 81 */
4380 NTSTATUS
4381 WINAPI
LsarAdtReportSecurityEvent(handle_t hBinding)4382 LsarAdtReportSecurityEvent(
4383 handle_t hBinding)
4384 {
4385 UNIMPLEMENTED;
4386 return STATUS_NOT_IMPLEMENTED;
4387 }
4388
4389 /* EOF */
4390