reactos/dll/win32/advapi32/sec/lsa.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/advapi32/sec/lsa.c
   5  * PURPOSE:         Local security authority functions
   6  * PROGRAMMER:      Emanuele Aliberti
   7  * UPDATE HISTORY:
   8  *      19990322 EA created
   9  *      19990515 EA stubs
  10  *      20030202 KJK compressed stubs
  11  *
  12  */
  13
  14 #include <advapi32.h>
  15
  16 #define NDEBUG
  17 #include <debug.h>
  18
  19 static handle_t LSABindingHandle = NULL;
  20
  21 static VOID
  22 LSAHandleUnbind(handle_t *Handle)
  23 {
  24     RPC_STATUS status;
  25
  26     if (*Handle == NULL)
  27         return;
  28
  29     status = RpcBindingFree(Handle);
  30     if (status)
  31     {
  32         DPRINT1("RpcBindingFree returned 0x%x\n", status);
  33     }
  34 }
  35
  36 static VOID
  37 LSAHandleBind(VOID)
  38 {
  39     LPWSTR pszStringBinding;
  40     RPC_STATUS status;
  41     handle_t Handle;
  42
  43     if (LSABindingHandle != NULL)
  44         return;
  45
  46     status = RpcStringBindingComposeW(NULL,
  47                                       L"ncacn_np",
  48                                       NULL,
  49                                       L"\\pipe\\lsarpc",
  50                                       NULL,
  51                                       &pszStringBinding);
  52     if (status)
  53     {
  54         DPRINT1("RpcStringBindingCompose returned 0x%x\n", status);
  55         return;
  56     }
  57
  58     /* Set the binding handle that will be used to bind to the server. */
  59     status = RpcBindingFromStringBindingW(pszStringBinding,
  60                                           &Handle);
  61     if (status)
  62     {
  63         DPRINT1("RpcBindingFromStringBinding returned 0x%x\n", status);
  64     }
  65
  66     status = RpcStringFreeW(&pszStringBinding);
  67     if (status)
  68     {
  69         DPRINT1("RpcStringFree returned 0x%x\n", status);
  70     }
  71
  72     if (InterlockedCompareExchangePointer(&LSABindingHandle,
  73                                           (PVOID)Handle,
  74                                           NULL) != NULL)
  75     {
  76         LSAHandleUnbind(&Handle);
  77     }
  78 }
  79
  80
  81 /*
  82  * @implemented
  83  */
  84 NTSTATUS STDCALL
  85 LsaClose(LSA_HANDLE ObjectHandle)
  86 {
  87     DPRINT("LsaClose(0x%p) called\n", ObjectHandle);
  88
  89     LSAHandleBind();
  90
  91     return LsarClose(LSABindingHandle,
  92                      (unsigned long)ObjectHandle);
  93 }
  94
  95
  96 /*
  97  * @implemented
  98  */
  99 NTSTATUS STDCALL
 100 LsaDelete(LSA_HANDLE ObjectHandle)
 101 {
 102     DPRINT("LsaDelete(0x%p) called\n", ObjectHandle);
 103
 104     LSAHandleBind();
 105
 106     return LsarDelete(LSABindingHandle,
 107                       (unsigned long)ObjectHandle);
 108 }
 109
 110
 111 /*
 112  * @unimplemented
 113  */
 114 NTSTATUS
 115 STDCALL
 116 LsaAddAccountRights(
 117     LSA_HANDLE PolicyHandle,
 118     PSID AccountSid,
 119     PLSA_UNICODE_STRING UserRights,
 120     ULONG CountOfRights)
 121 {
 122   return STATUS_NOT_IMPLEMENTED;
 123 }
 124
 125 /*
 126  * @unimplemented
 127  */
 128 NTSTATUS
 129 STDCALL
 130 LsaCreateTrustedDomainEx(
 131     LSA_HANDLE PolicyHandle,
 132     PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
 133     PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
 134     ACCESS_MASK DesiredAccess,
 135     PLSA_HANDLE TrustedDomainHandle)
 136 {
 137   return STATUS_NOT_IMPLEMENTED;
 138 }
 139
 140 /*
 141  * @unimplemented
 142  */
 143 NTSTATUS
 144 STDCALL
 145 LsaDeleteTrustedDomain(
 146     LSA_HANDLE PolicyHandle,
 147     PSID TrustedDomainSid)
 148 {
 149   return STATUS_NOT_IMPLEMENTED;
 150 }
 151
 152 /*
 153  * @unimplemented
 154  */
 155 NTSTATUS
 156 STDCALL
 157 LsaEnumerateAccountRights(
 158     LSA_HANDLE PolicyHandle,
 159     PSID AccountSid,
 160     PLSA_UNICODE_STRING *UserRights,
 161     PULONG CountOfRights)
 162 {
 163   return STATUS_NOT_IMPLEMENTED;
 164 }
 165
 166 /*
 167  * @unimplemented
 168  */
 169 NTSTATUS
 170 STDCALL
 171 LsaEnumerateAccountsWithUserRight(
 172     LSA_HANDLE PolicyHandle,
 173     OPTIONAL PLSA_UNICODE_STRING UserRights,
 174     PVOID *EnumerationBuffer,
 175     PULONG CountReturned)
 176 {
 177   return STATUS_NOT_IMPLEMENTED;
 178 }
 179
 180 /*
 181  * @unimplemented
 182  */
 183 NTSTATUS
 184 STDCALL
 185 LsaEnumerateTrustedDomains(
 186     LSA_HANDLE PolicyHandle,
 187     PLSA_ENUMERATION_HANDLE EnumerationContext,
 188     PVOID *Buffer,
 189     ULONG PreferedMaximumLength,
 190     PULONG CountReturned)
 191 {
 192   return STATUS_NOT_IMPLEMENTED;
 193 }
 194
 195 /*
 196  * @unimplemented
 197  */
 198 NTSTATUS
 199 STDCALL
 200 LsaEnumerateTrustedDomainsEx(
 201     LSA_HANDLE PolicyHandle,
 202     PLSA_ENUMERATION_HANDLE EnumerationContext,
 203     PVOID *Buffer,
 204     ULONG PreferedMaximumLength,
 205     PULONG CountReturned)
 206 {
 207   return STATUS_NOT_IMPLEMENTED;
 208 }
 209
 210 /*
 211  * @implemented
 212  */
 213 NTSTATUS STDCALL
 214 LsaFreeMemory(PVOID Buffer)
 215 {
 216   return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 217 }
 218
 219 /*
 220  * @implemented
 221  */
 222 NTSTATUS
 223 WINAPI
 224 LsaLookupNames(
 225     LSA_HANDLE PolicyHandle,
 226     ULONG Count,
 227     PLSA_UNICODE_STRING Names,
 228     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 229     PLSA_TRANSLATED_SID *Sids)
 230 {
 231     PLSA_TRANSLATED_SID2 Sids2;
 232     LSA_TRANSLATED_SID *TranslatedSids;
 233     ULONG i;
 234     NTSTATUS Status;
 235
 236     /* Call LsaLookupNames2, which supersedes this function */
 237     Status = LsaLookupNames2(PolicyHandle, Count, 0, Names, ReferencedDomains, &Sids2);
 238     if (!NT_SUCCESS(Status))
 239         return Status;
 240
 241     /* Translate the returned structure */
 242     TranslatedSids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID));
 243     if (!TranslatedSids)
 244     {
 245         LsaFreeMemory(Sids2);
 246         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 247     }
 248     RtlZeroMemory(Sids, Count * sizeof(PLSA_TRANSLATED_SID));
 249     for (i = 0; i < Count; i++)
 250     {
 251         TranslatedSids[i].Use = Sids2[i].Use;
 252         if (Sids2[i].Use != SidTypeInvalid && Sids2[i].Use != SidTypeUnknown)
 253         {
 254             TranslatedSids[i].DomainIndex = Sids2[i].DomainIndex;
 255             if (Sids2[i].Use != SidTypeDomain)
 256                 TranslatedSids[i].RelativeId = *GetSidSubAuthority(Sids2[i].Sid, 0);
 257         }
 258     }
 259     LsaFreeMemory(Sids2);
 260
 261     *Sids = TranslatedSids;
 262
 263     return Status;
 264 }
 265
 266 /*
 267  * @unimplemented
 268  */
 269 NTSTATUS
 270 STDCALL
 271 LsaLookupNames2(
 272     LSA_HANDLE PolicyHandle,
 273     ULONG Flags,
 274     ULONG Count,
 275     PLSA_UNICODE_STRING Names,
 276     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 277     PLSA_TRANSLATED_SID2 *Sids)
 278 {
 279   return STATUS_NOT_IMPLEMENTED;
 280 }
 281
 282 /*
 283  * @unimplemented
 284  */
 285 NTSTATUS
 286 WINAPI
 287 LsaLookupSids(
 288     LSA_HANDLE PolicyHandle,
 289     ULONG Count,
 290     PSID *Sids,
 291     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 292     PLSA_TRANSLATED_NAME *Names)
 293 {
 294     static const UNICODE_STRING UserName = RTL_CONSTANT_STRING(L"Administrator");
 295     PLSA_REFERENCED_DOMAIN_LIST LocalDomains;
 296     PLSA_TRANSLATED_NAME LocalNames;
 297
 298     DPRINT("LsaLookupSids(): stub. Always returning 'Administrator'\n");
 299     if (Count != 1)
 300         return STATUS_NONE_MAPPED;
 301     LocalDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_SID));
 302     if (!LocalDomains)
 303         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 304     LocalNames = RtlAllocateHeap(RtlGetProcessHeap(), 0,  sizeof(LSA_TRANSLATED_NAME) + UserName.MaximumLength);
 305     if (!LocalNames)
 306     {
 307         LsaFreeMemory(LocalDomains);
 308         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 309     }
 310     LocalDomains[0].Entries = 0;
 311     LocalDomains[0].Domains = NULL;
 312     LocalNames[0].Use = SidTypeWellKnownGroup;
 313     LocalNames[0].Name.Buffer = (LPWSTR)((ULONG_PTR)(LocalNames) + sizeof(LSA_TRANSLATED_NAME));
 314     LocalNames[0].Name.Length = UserName.Length;
 315     LocalNames[0].Name.MaximumLength = UserName.MaximumLength;
 316     RtlCopyMemory(LocalNames[0].Name.Buffer, UserName.Buffer, UserName.MaximumLength);
 317
 318     *ReferencedDomains = LocalDomains;
 319     *Names = LocalNames;
 320     return STATUS_SUCCESS;
 321 }
 322
 323 /******************************************************************************
 324  * LsaNtStatusToWinError
 325  *
 326  * PARAMS
 327  *   Status [I]
 328  *
 329  * @implemented
 330  */
 331 ULONG STDCALL
 332 LsaNtStatusToWinError(NTSTATUS Status)
 333 {
 334   return RtlNtStatusToDosError(Status);
 335 }
 336
 337 /******************************************************************************
 338  * LsaOpenPolicy
 339  *
 340  * PARAMS
 341  *   x1 []
 342  *   x2 []
 343  *   x3 []
 344  *   x4 []
 345  *
 346  * @unimplemented
 347  */
 348 NTSTATUS STDCALL
 349 LsaOpenPolicy(PLSA_UNICODE_STRING lsaucs,
 350               PLSA_OBJECT_ATTRIBUTES lsaoa,
 351               ACCESS_MASK access,
 352               PLSA_HANDLE PolicyHandle)
 353 {
 354   static int count = 0;
 355   if (count++ < 20)
 356   {
 357      DPRINT("LsaOpenPolicy - stub\n");
 358   }
 359   return STATUS_SUCCESS;
 360 }
 361
 362 /*
 363  * @unimplemented
 364  */
 365 NTSTATUS
 366 STDCALL
 367 LsaOpenTrustedDomainByName(
 368     LSA_HANDLE PolicyHandle,
 369     PLSA_UNICODE_STRING TrustedDomainName,
 370     ACCESS_MASK DesiredAccess,
 371     PLSA_HANDLE TrustedDomainHandle)
 372 {
 373   return STATUS_NOT_IMPLEMENTED;
 374 }
 375
 376 /*
 377  * @unimplemented
 378  */
 379 NTSTATUS
 380 STDCALL
 381 LsaQueryDomainInformationPolicy(
 382     LSA_HANDLE PolicyHandle,
 383     POLICY_DOMAIN_INFORMATION_CLASS pic,
 384     PVOID *Buffer)
 385 {
 386   return STATUS_NOT_IMPLEMENTED;
 387 }
 388
 389 /*
 390  * @unimplemented
 391  */
 392 NTSTATUS
 393 STDCALL
 394 LsaQueryForestTrustInformation(
 395     LSA_HANDLE PolicyHandle,
 396     PLSA_UNICODE_STRING TrustedDomainName,
 397     PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
 398 {
 399   return STATUS_NOT_IMPLEMENTED;
 400 }
 401
 402 /*
 403  * @unimplemented
 404  */
 405 NTSTATUS STDCALL
 406 LsaQueryInformationPolicy(LSA_HANDLE PolicyHandle,
 407                           POLICY_INFORMATION_CLASS pic,
 408                           PVOID *Buffer)
 409 {
 410   DPRINT1("(%p,0x%08x,%p):LsaQueryInformationPolicy stub\n",
 411           PolicyHandle, pic, Buffer);
 412
 413   if (!Buffer)
 414     return FALSE;
 415
 416         switch (pic)
 417         {
 418           case PolicyAuditEventsInformation: /* 2 */
 419             {
 420               PPOLICY_AUDIT_EVENTS_INFO p = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(POLICY_AUDIT_EVENTS_INFO));
 421               p->AuditingMode = FALSE; /* no auditing */
 422               *Buffer = p;
 423             }
 424             break;
 425           case PolicyPrimaryDomainInformation: /* 3 */
 426           case PolicyAccountDomainInformation: /* 5 */
 427             {
 428               struct di
 429               { POLICY_PRIMARY_DOMAIN_INFO ppdi;
 430                 SID sid;
 431               };
 432               SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
 433
 434               struct di * xdi = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(xdi));
 435               HKEY key;
 436               BOOL useDefault = TRUE;
 437               LONG ret;
 438
 439               if ((ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 440                "System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0,
 441                KEY_READ, &key)) == ERROR_SUCCESS)
 442               {
 443                   DWORD size = 0;
 444                   WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
 445
 446                   ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
 447                   if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
 448                   {
 449                       xdi->ppdi.Name.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
 450                        HEAP_ZERO_MEMORY, size);
 451                       if ((ret = RegQueryValueExW(key, wg, NULL, NULL,
 452                        (LPBYTE)xdi->ppdi.Name.Buffer, &size)) == ERROR_SUCCESS)
 453                       {
 454                           xdi->ppdi.Name.Length = (USHORT)size;
 455                           useDefault = FALSE;
 456                       }
 457                       else
 458                       {
 459                           RtlFreeHeap(RtlGetProcessHeap(), 0, xdi->ppdi.Name.Buffer);
 460                           xdi->ppdi.Name.Buffer = NULL;
 461                       }
 462                   }
 463                   RegCloseKey(key);
 464               }
 465               if (useDefault)
 466                   RtlCreateUnicodeStringFromAsciiz(&(xdi->ppdi.Name), "DOMAIN");
 467               DPRINT1("setting domain to \n");
 468
 469               xdi->ppdi.Sid = &(xdi->sid);
 470               xdi->sid.Revision = SID_REVISION;
 471               xdi->sid.SubAuthorityCount = 1;
 472               xdi->sid.IdentifierAuthority = localSidAuthority;
 473               xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
 474               *Buffer = xdi;
 475             }
 476             break;
 477           case PolicyAuditLogInformation:
 478           case PolicyPdAccountInformation:
 479           case PolicyLsaServerRoleInformation:
 480           case PolicyReplicaSourceInformation:
 481           case PolicyDefaultQuotaInformation:
 482           case PolicyModificationInformation:
 483           case PolicyAuditFullSetInformation:
 484           case PolicyAuditFullQueryInformation:
 485           case PolicyDnsDomainInformation:
 486           case PolicyEfsInformation:
 487             {
 488               DPRINT1("category not implemented\n");
 489               return FALSE;
 490             }
 491         }
 492         return TRUE;
 493 }
 494
 495 /*
 496  * @unimplemented
 497  */
 498 NTSTATUS
 499 STDCALL
 500 LsaQueryTrustedDomainInfoByName(
 501     LSA_HANDLE PolicyHandle,
 502     PLSA_UNICODE_STRING TrustedDomainName,
 503     TRUSTED_INFORMATION_CLASS pic,
 504     PVOID *Buffer)
 505 {
 506   return STATUS_NOT_IMPLEMENTED;
 507 }
 508
 509 /*
 510  * @unimplemented
 511  */
 512 NTSTATUS
 513 STDCALL
 514 LsaQueryTrustedDomainInfo(
 515     LSA_HANDLE PolicyHandle,
 516     PSID TrustedDomainSid,
 517     TRUSTED_INFORMATION_CLASS pic,
 518     PVOID *Buffer)
 519 {
 520   return STATUS_NOT_IMPLEMENTED;
 521 }
 522
 523 /*
 524  * @unimplemented
 525  */
 526 NTSTATUS
 527 STDCALL
 528 LsaRemoveAccountRights(
 529     LSA_HANDLE PolicyHandle,
 530     PSID AccountSid,
 531     BOOLEAN AllRights,
 532     PLSA_UNICODE_STRING UserRights,
 533     ULONG CountOfRights)
 534 {
 535   return STATUS_NOT_IMPLEMENTED;
 536 }
 537
 538 /*
 539  * @unimplemented
 540  */
 541 NTSTATUS
 542 STDCALL
 543 LsaRetrievePrivateData(
 544     LSA_HANDLE PolicyHandle,
 545     PLSA_UNICODE_STRING KeyName,
 546     PLSA_UNICODE_STRING *PrivateData)
 547 {
 548   return STATUS_NOT_IMPLEMENTED;
 549 }
 550
 551 /*
 552  * @unimplemented
 553  */
 554 NTSTATUS
 555 STDCALL
 556 LsaSetDomainInformationPolicy(
 557     LSA_HANDLE PolicyHandle,
 558     POLICY_DOMAIN_INFORMATION_CLASS pic,
 559     PVOID Buffer)
 560 {
 561   return STATUS_NOT_IMPLEMENTED;
 562 }
 563
 564 /*
 565  * @unimplemented
 566  */
 567 NTSTATUS
 568 STDCALL
 569 LsaSetInformationPolicy(
 570     LSA_HANDLE PolicyHandle,
 571     POLICY_INFORMATION_CLASS pic,
 572     PVOID Buffer)
 573 {
 574   return STATUS_NOT_IMPLEMENTED;
 575 }
 576
 577 /*
 578  * @unimplemented
 579  */
 580 NTSTATUS
 581 STDCALL
 582 LsaSetForestTrustInformation(
 583     LSA_HANDLE PolicyHandle,
 584     PLSA_UNICODE_STRING TrustedDomainName,
 585     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
 586     BOOL CheckOnly,
 587     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
 588 {
 589   return STATUS_NOT_IMPLEMENTED;
 590 }
 591
 592 /*
 593  * @unimplemented
 594  */
 595 NTSTATUS
 596 STDCALL
 597 LsaSetTrustedDomainInfoByName(
 598     LSA_HANDLE PolicyHandle,
 599     PLSA_UNICODE_STRING TrustedDomainName,
 600     TRUSTED_INFORMATION_CLASS pic,
 601     PVOID Buffer)
 602 {
 603   return STATUS_NOT_IMPLEMENTED;
 604 }
 605
 606 /*
 607  * @unimplemented
 608  */
 609 NTSTATUS
 610 STDCALL
 611 LsaSetTrustedDomainInformation(
 612     LSA_HANDLE PolicyHandle,
 613     PSID TrustedDomainSid,
 614     TRUSTED_INFORMATION_CLASS pic,
 615     PVOID Buffer)
 616 {
 617   return STATUS_NOT_IMPLEMENTED;
 618 }
 619
 620 /*
 621  * @unimplemented
 622  */
 623 NTSTATUS
 624 STDCALL
 625 LsaStorePrivateData(
 626     LSA_HANDLE PolicyHandle,
 627     PLSA_UNICODE_STRING KeyName,
 628     PLSA_UNICODE_STRING PrivateData)
 629 {
 630   return STATUS_NOT_IMPLEMENTED;
 631 }
 632
 633 /*
 634  * @unimplemented
 635  */
 636 NTSTATUS
 637 STDCALL
 638 LsaGetUserName(
 639     PUNICODE_STRING *UserName,
 640     PUNICODE_STRING *DomainName)
 641 {
 642   DPRINT1("LsaGetUserName not implemented\n");
 643
 644   return STATUS_NOT_IMPLEMENTED;
 645 }
 646
 647 /*
 648  * @unimplemented
 649  */
 650 NTSTATUS
 651 STDCALL
 652 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
 653                            DWORD Unknonw1,
 654                            DWORD Unknonw2)
 655 {
 656   DPRINT1("LsaQueryInfoTrustedDomain not implemented\n");
 657
 658   return STATUS_NOT_IMPLEMENTED;
 659 }
 660
 661
 662 /* EOF */