dll/win32/lsasrv/authpackage.c

   1 /*
   2  * PROJECT:     Local Security Authority Server DLL
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        dll/win32/lsasrv/authpackage.c
   5  * PURPOSE:     Authenticaton package management routines
   6  * COPYRIGHT:   Copyright 2013 Eric Kohl
   7  */
   8
   9 /* INCLUDES ****************************************************************/
  10
  11 #include "lsasrv.h"
  12
  13 WINE_DEFAULT_DEBUG_CHANNEL(lsasrv);
  14
  15 typedef enum _LSA_TOKEN_INFORMATION_TYPE
  16 {
  17     LsaTokenInformationNull,
  18     LsaTokenInformationV1
  19 } LSA_TOKEN_INFORMATION_TYPE, *PLSA_TOKEN_INFORMATION_TYPE;
  20
  21 typedef PVOID PLSA_CLIENT_REQUEST;
  22
  23 typedef PVOID (NTAPI *PLSA_ALLOCATE_LSA_HEAP)(ULONG);
  24 typedef VOID (NTAPI *PLSA_FREE_LSA_HEAP)(PVOID);
  25 typedef NTSTATUS (NTAPI *PLSA_ALLOCATE_CLIENT_BUFFER)(PLSA_CLIENT_REQUEST, ULONG, PVOID*);
  26 typedef NTSTATUS (NTAPI *PLSA_FREE_CLIENT_BUFFER)(PLSA_CLIENT_REQUEST, PVOID);
  27 typedef NTSTATUS (NTAPI *PLSA_COPY_TO_CLIENT_BUFFER)(PLSA_CLIENT_REQUEST, ULONG,
  28  PVOID, PVOID);
  29 typedef NTSTATUS (NTAPI *PLSA_COPY_FROM_CLIENT_BUFFER)(PLSA_CLIENT_REQUEST,
  30  ULONG, PVOID, PVOID);
  31
  32 typedef struct LSA_DISPATCH_TABLE
  33 {
  34     PVOID /*PLSA_CREATE_LOGON_SESSION */ CreateLogonSession;
  35     PVOID /*PLSA_DELETE_LOGON_SESSION */ DeleteLogonSession;
  36     PVOID /*PLSA_ADD_CREDENTIAL */ AddCredential;
  37     PVOID /*PLSA_GET_CREDENTIALS */ GetCredentials;
  38     PVOID /*PLSA_DELETE_CREDENTIAL */ DeleteCredential;
  39     PLSA_ALLOCATE_LSA_HEAP AllocateLsaHeap;
  40     PLSA_FREE_LSA_HEAP FreeLsaHeap;
  41     PLSA_ALLOCATE_CLIENT_BUFFER AllocateClientBuffer;
  42     PLSA_FREE_CLIENT_BUFFER FreeClientBuffer;
  43     PLSA_COPY_TO_CLIENT_BUFFER CopyToClientBuffer;
  44     PLSA_COPY_FROM_CLIENT_BUFFER CopyFromClientBuffer;
  45 } LSA_DISPATCH_TABLE, *PLSA_DISPATCH_TABLE;
  46
  47
  48 typedef NTSTATUS (NTAPI *PLSA_AP_INITIALIZE_PACKAGE)(ULONG, PLSA_DISPATCH_TABLE,
  49  PLSA_STRING, PLSA_STRING, PLSA_STRING *);
  50 typedef NTSTATUS (NTAPI *PLSA_AP_CALL_PACKAGE_INTERNAL)(PLSA_CLIENT_REQUEST, PVOID, PVOID,
  51  ULONG, PVOID *, PULONG, PNTSTATUS);
  52 typedef NTSTATUS (NTAPI *PLSA_AP_CALL_PACKAGE_PASSTHROUGH)(PLSA_CLIENT_REQUEST,
  53  PVOID, PVOID, ULONG, PVOID *, PULONG, PNTSTATUS);
  54 typedef NTSTATUS (NTAPI *PLSA_AP_CALL_PACKAGE_UNTRUSTED)(PLSA_CLIENT_REQUEST,
  55  PVOID, PVOID, ULONG, PVOID *, PULONG, PNTSTATUS);
  56 typedef VOID (NTAPI *PLSA_AP_LOGON_TERMINATED)(PLUID);
  57 typedef NTSTATUS (NTAPI *PLSA_AP_LOGON_USER_EX2)(PLSA_CLIENT_REQUEST,
  58  SECURITY_LOGON_TYPE, PVOID, PVOID, ULONG, PVOID *, PULONG, PLUID, PNTSTATUS,
  59  PLSA_TOKEN_INFORMATION_TYPE, PVOID *, PUNICODE_STRING *, PUNICODE_STRING *,
  60  PUNICODE_STRING *, PVOID /*PSECPKG_PRIMARY_CRED*/, PVOID /*PSECPKG_SUPPLEMENTAL_CRED_ARRAY **/);
  61 typedef NTSTATUS (NTAPI *PLSA_AP_LOGON_USER_EX)(PLSA_CLIENT_REQUEST,
  62  SECURITY_LOGON_TYPE, PVOID, PVOID, ULONG, PVOID *, PULONG, PLUID, PNTSTATUS,
  63  PLSA_TOKEN_INFORMATION_TYPE, PVOID *, PUNICODE_STRING *, PUNICODE_STRING *,
  64  PUNICODE_STRING *);
  65
  66 typedef NTSTATUS (NTAPI *PLSA_AP_LOGON_USER_INTERNAL)(PLSA_CLIENT_REQUEST, SECURITY_LOGON_TYPE,
  67  PVOID, PVOID, ULONG, PVOID *, PULONG, PLUID, PNTSTATUS, PLSA_TOKEN_INFORMATION_TYPE,
  68  PVOID *, PUNICODE_STRING *, PUNICODE_STRING *);
  69
  70 typedef struct _AUTH_PACKAGE
  71 {
  72     LIST_ENTRY Entry;
  73     PSTRING Name;
  74     ULONG Id;
  75     PVOID ModuleHandle;
  76
  77     PLSA_AP_INITIALIZE_PACKAGE LsaApInitializePackage;
  78     PLSA_AP_CALL_PACKAGE_INTERNAL LsaApCallPackage;
  79     PLSA_AP_CALL_PACKAGE_PASSTHROUGH LsaApCallPackagePassthrough;
  80     PLSA_AP_CALL_PACKAGE_UNTRUSTED LsaApCallPackageUntrusted;
  81     PLSA_AP_LOGON_TERMINATED LsaApLogonTerminated;
  82     PLSA_AP_LOGON_USER_EX2 LsaApLogonUserEx2;
  83     PLSA_AP_LOGON_USER_EX LsaApLogonUserEx;
  84     PLSA_AP_LOGON_USER_INTERNAL LsaApLogonUser;
  85 } AUTH_PACKAGE, *PAUTH_PACKAGE;
  86
  87
  88 /* GLOBALS *****************************************************************/
  89
  90 static LIST_ENTRY PackageListHead;
  91 static ULONG PackageId;
  92 static LSA_DISPATCH_TABLE DispatchTable;
  93
  94
  95 /* FUNCTIONS ***************************************************************/
  96
  97 static
  98 NTSTATUS
  99 NTAPI
 100 LsapAddAuthPackage(IN PWSTR ValueName,
 101                    IN ULONG ValueType,
 102                    IN PVOID ValueData,
 103                    IN ULONG ValueLength,
 104                    IN PVOID Context,
 105                    IN PVOID EntryContext)
 106 {
 107     PAUTH_PACKAGE Package = NULL;
 108     UNICODE_STRING PackageName;
 109     STRING ProcName;
 110     PULONG Id;
 111     NTSTATUS Status = STATUS_SUCCESS;
 112
 113     TRACE("LsapAddAuthPackage()\n");
 114
 115     PackageName.Length = (USHORT)ValueLength - sizeof(WCHAR);
 116     PackageName.MaximumLength = (USHORT)ValueLength;
 117     PackageName.Buffer = ValueData;
 118
 119     Id = (PULONG)Context;
 120
 121     Package = RtlAllocateHeap(RtlGetProcessHeap(),
 122                                   HEAP_ZERO_MEMORY,
 123                                   sizeof(AUTH_PACKAGE));
 124     if (Package == NULL)
 125         return STATUS_INSUFFICIENT_RESOURCES;
 126
 127     Status = LdrLoadDll(NULL,
 128                         NULL,
 129                         &PackageName,
 130                         &Package->ModuleHandle);
 131     if (!NT_SUCCESS(Status))
 132     {
 133         TRACE("LdrLoadDll failed (Status 0x%08lx)\n", Status);
 134         goto done;
 135     }
 136
 137     RtlInitAnsiString(&ProcName, "LsaApInitializePackage");
 138     Status = LdrGetProcedureAddress(Package->ModuleHandle,
 139                                     &ProcName,
 140                                     0,
 141                                     (PVOID *)&Package->LsaApInitializePackage);
 142     if (!NT_SUCCESS(Status))
 143     {
 144         TRACE("LdrGetProcedureAddress() failed (Status 0x%08lx)\n", Status);
 145         goto done;
 146     }
 147
 148     RtlInitAnsiString(&ProcName, "LsaApCallPackage");
 149     Status = LdrGetProcedureAddress(Package->ModuleHandle,
 150                                     &ProcName,
 151                                     0,
 152                                     (PVOID *)&Package->LsaApCallPackage);
 153     if (!NT_SUCCESS(Status))
 154     {
 155         TRACE("LdrGetProcedureAddress() failed (Status 0x%08lx)\n", Status);
 156         goto done;
 157     }
 158
 159     RtlInitAnsiString(&ProcName, "LsaApCallPackagePassthrough");
 160     Status = LdrGetProcedureAddress(Package->ModuleHandle,
 161                                     &ProcName,
 162                                     0,
 163                                     (PVOID *)&Package->LsaApCallPackagePassthrough);
 164     if (!NT_SUCCESS(Status))
 165     {
 166         TRACE("LdrGetProcedureAddress() failed (Status 0x%08lx)\n", Status);
 167         goto done;
 168     }
 169
 170     RtlInitAnsiString(&ProcName, "LsaApCallPackageUntrusted");
 171     Status = LdrGetProcedureAddress(Package->ModuleHandle,
 172                                     &ProcName,
 173                                     0,
 174                                     (PVOID *)&Package->LsaApCallPackageUntrusted);
 175     if (!NT_SUCCESS(Status))
 176     {
 177         TRACE("LdrGetProcedureAddress() failed (Status 0x%08lx)\n", Status);
 178         goto done;
 179     }
 180
 181     RtlInitAnsiString(&ProcName, "LsaApLogonTerminated");
 182     Status = LdrGetProcedureAddress(Package->ModuleHandle,
 183                                     &ProcName,
 184                                     0,
 185                                     (PVOID *)&Package->LsaApLogonTerminated);
 186     if (!NT_SUCCESS(Status))
 187     {
 188         TRACE("LdrGetProcedureAddress() failed (Status 0x%08lx)\n", Status);
 189         goto done;
 190     }
 191
 192     RtlInitAnsiString(&ProcName, "LsaApLogonUserEx2");
 193     Status = LdrGetProcedureAddress(Package->ModuleHandle,
 194                                     &ProcName,
 195                                     0,
 196                                     (PVOID *)&Package->LsaApLogonUserEx2);
 197     if (!NT_SUCCESS(Status))
 198     {
 199         RtlInitAnsiString(&ProcName, "LsaApLogonUserEx");
 200         Status = LdrGetProcedureAddress(Package->ModuleHandle,
 201                                         &ProcName,
 202                                         0,
 203                                         (PVOID *)&Package->LsaApLogonUserEx);
 204         if (!NT_SUCCESS(Status))
 205         {
 206             RtlInitAnsiString(&ProcName, "LsaApLogonUser");
 207             Status = LdrGetProcedureAddress(Package->ModuleHandle,
 208                                             &ProcName,
 209                                             0,
 210                                             (PVOID *)&Package->LsaApLogonUser);
 211             if (!NT_SUCCESS(Status))
 212             {
 213                 TRACE("LdrGetProcedureAddress() failed (Status 0x%08lx)\n", Status);
 214                 goto done;
 215             }
 216         }
 217     }
 218
 219     /* Initialize the current package */
 220     Status = Package->LsaApInitializePackage(*Id,
 221                                              &DispatchTable,
 222                                              NULL,
 223                                              NULL,
 224                                              &Package->Name);
 225     if (!NT_SUCCESS(Status))
 226     {
 227         TRACE("Package->LsaApInitializePackage() failed (Status 0x%08lx)\n", Status);
 228         goto done;
 229     }
 230
 231     TRACE("Package Name: %s\n", Package->Name->Buffer);
 232
 233     Package->Id = *Id;
 234     (*Id)++;
 235
 236     InsertTailList(&PackageListHead, &Package->Entry);
 237
 238 done:
 239     if (!NT_SUCCESS(Status))
 240     {
 241         if (Package != NULL)
 242         {
 243             if (Package->ModuleHandle != NULL)
 244                 LdrUnloadDll(Package->ModuleHandle);
 245
 246             if (Package->Name != NULL)
 247             {
 248                 if (Package->Name->Buffer != NULL)
 249                     RtlFreeHeap(RtlGetProcessHeap(), 0, Package->Name->Buffer);
 250
 251                 RtlFreeHeap(RtlGetProcessHeap(), 0, Package->Name);
 252             }
 253
 254             RtlFreeHeap(RtlGetProcessHeap(), 0, Package);
 255         }
 256     }
 257
 258     return Status;
 259 }
 260
 261
 262 static
 263 PAUTH_PACKAGE
 264 LsapGetAuthenticationPackage(IN ULONG PackageId)
 265 {
 266     PLIST_ENTRY ListEntry;
 267     PAUTH_PACKAGE Package;
 268
 269     ListEntry = PackageListHead.Flink;
 270     while (ListEntry != &PackageListHead)
 271     {
 272         Package = CONTAINING_RECORD(ListEntry, AUTH_PACKAGE, Entry);
 273
 274         if (Package->Id == PackageId)
 275         {
 276             return Package;
 277         }
 278
 279         ListEntry = ListEntry->Flink;
 280     }
 281
 282     return NULL;
 283 }
 284
 285
 286 static
 287 PVOID
 288 NTAPI
 289 LsapAllocateHeap(IN ULONG Length)
 290 {
 291     return RtlAllocateHeap(RtlGetProcessHeap(),
 292                            HEAP_ZERO_MEMORY,
 293                            Length);
 294 }
 295
 296
 297 static
 298 VOID
 299 NTAPI
 300 LsapFreeHeap(IN PVOID Base)
 301 {
 302     RtlFreeHeap(RtlGetProcessHeap(),
 303                 0,
 304                 Base);
 305 }
 306
 307
 308 static
 309 NTSTATUS
 310 NTAPI
 311 LsapAllocateClientBuffer(IN PLSA_CLIENT_REQUEST ClientRequest,
 312                          IN ULONG LengthRequired,
 313                          OUT PVOID *ClientBaseAddress)
 314 {
 315     PLSAP_LOGON_CONTEXT LogonContext;
 316     ULONG Length;
 317
 318     *ClientBaseAddress = NULL;
 319
 320     LogonContext = (PLSAP_LOGON_CONTEXT)ClientRequest;
 321
 322     Length = LengthRequired;
 323     return NtAllocateVirtualMemory(LogonContext->ClientProcessHandle,
 324                                    ClientBaseAddress,
 325                                    0,
 326                                    &Length,
 327                                    MEM_COMMIT,
 328                                    PAGE_READWRITE);
 329 }
 330
 331
 332 static
 333 NTSTATUS
 334 NTAPI
 335 LsapFreeClientBuffer(IN PLSA_CLIENT_REQUEST ClientRequest,
 336                      IN PVOID ClientBaseAddress)
 337 {
 338     PLSAP_LOGON_CONTEXT LogonContext;
 339     ULONG Length;
 340
 341     if (ClientBaseAddress == NULL)
 342         return STATUS_SUCCESS;
 343
 344     LogonContext = (PLSAP_LOGON_CONTEXT)ClientRequest;
 345
 346     Length = 0;
 347     return NtFreeVirtualMemory(LogonContext->ClientProcessHandle,
 348                                &ClientBaseAddress,
 349                                &Length,
 350                                MEM_RELEASE);
 351 }
 352
 353
 354 static
 355 NTSTATUS
 356 NTAPI
 357 LsapCopyToClientBuffer(IN PLSA_CLIENT_REQUEST ClientRequest,
 358                        IN ULONG Length,
 359                        IN PVOID ClientBaseAddress,
 360                        IN PVOID BufferToCopy)
 361 {
 362     PLSAP_LOGON_CONTEXT LogonContext;
 363
 364     LogonContext = (PLSAP_LOGON_CONTEXT)ClientRequest;
 365
 366     return NtWriteVirtualMemory(LogonContext->ClientProcessHandle,
 367                                 ClientBaseAddress,
 368                                 BufferToCopy,
 369                                 Length,
 370                                 NULL);
 371 }
 372
 373
 374 static
 375 NTSTATUS
 376 NTAPI
 377 LsapCopyFromClientBuffer(IN PLSA_CLIENT_REQUEST ClientRequest,
 378                          IN ULONG Length,
 379                          IN PVOID BufferToCopy,
 380                          IN PVOID ClientBaseAddress)
 381 {
 382     PLSAP_LOGON_CONTEXT LogonContext;
 383
 384     LogonContext = (PLSAP_LOGON_CONTEXT)ClientRequest;
 385
 386     return NtReadVirtualMemory(LogonContext->ClientProcessHandle,
 387                                ClientBaseAddress,
 388                                BufferToCopy,
 389                                Length,
 390                                NULL);
 391 }
 392
 393
 394 NTSTATUS
 395 LsapInitAuthPackages(VOID)
 396 {
 397     RTL_QUERY_REGISTRY_TABLE AuthPackageTable[] = {
 398     {LsapAddAuthPackage, 0, L"Authentication Packages", NULL, REG_NONE, NULL, 0},
 399     {NULL, 0, NULL, NULL, REG_NONE, NULL, 0}};
 400
 401     NTSTATUS Status;
 402
 403     InitializeListHead(&PackageListHead);
 404     PackageId = 0;
 405
 406     /* Initialize the dispatch table */
 407     DispatchTable.CreateLogonSession = NULL;
 408     DispatchTable.DeleteLogonSession = NULL;
 409     DispatchTable.AddCredential = NULL;
 410     DispatchTable.GetCredentials = NULL;
 411     DispatchTable.DeleteCredential = NULL;
 412     DispatchTable.AllocateLsaHeap = &LsapAllocateHeap;
 413     DispatchTable.FreeLsaHeap = &LsapFreeHeap;
 414     DispatchTable.AllocateClientBuffer = &LsapAllocateClientBuffer;
 415     DispatchTable.FreeClientBuffer = &LsapFreeClientBuffer;
 416     DispatchTable.CopyToClientBuffer = &LsapCopyToClientBuffer;
 417     DispatchTable.CopyFromClientBuffer = &LsapCopyFromClientBuffer;
 418
 419     /* Add registered authentication packages */
 420     Status = RtlQueryRegistryValues(RTL_REGISTRY_CONTROL,
 421                                     L"Lsa",
 422                                     AuthPackageTable,
 423                                     &PackageId,
 424                                     NULL);
 425
 426
 427     return STATUS_SUCCESS;
 428 }
 429
 430
 431 NTSTATUS
 432 LsapLookupAuthenticationPackage(PLSA_API_MSG RequestMsg,
 433                                 PLSAP_LOGON_CONTEXT LogonContext)
 434 {
 435     PLIST_ENTRY ListEntry;
 436     PAUTH_PACKAGE Package;
 437     ULONG PackageNameLength;
 438     PCHAR PackageName;
 439
 440     TRACE("(%p %p)\n", RequestMsg, LogonContext);
 441
 442     PackageNameLength = RequestMsg->LookupAuthenticationPackage.Request.PackageNameLength;
 443     PackageName = RequestMsg->LookupAuthenticationPackage.Request.PackageName;
 444
 445     TRACE("PackageName: %s\n", PackageName);
 446
 447     ListEntry = PackageListHead.Flink;
 448     while (ListEntry != &PackageListHead)
 449     {
 450         Package = CONTAINING_RECORD(ListEntry, AUTH_PACKAGE, Entry);
 451
 452         if ((PackageNameLength == Package->Name->Length) &&
 453             (_strnicmp(PackageName, Package->Name->Buffer, Package->Name->Length) == 0))
 454         {
 455             RequestMsg->LookupAuthenticationPackage.Reply.Package = Package->Id;
 456             return STATUS_SUCCESS;
 457         }
 458
 459         ListEntry = ListEntry->Flink;
 460     }
 461
 462     return STATUS_NO_SUCH_PACKAGE;
 463 }
 464
 465
 466 NTSTATUS
 467 LsapCallAuthenticationPackage(PLSA_API_MSG RequestMsg,
 468                               PLSAP_LOGON_CONTEXT LogonContext)
 469 {
 470     PAUTH_PACKAGE Package;
 471     PVOID LocalBuffer = NULL;
 472     ULONG PackageId;
 473     NTSTATUS Status;
 474
 475     TRACE("(%p %p)\n", RequestMsg, LogonContext);
 476
 477     PackageId = RequestMsg->CallAuthenticationPackage.Request.AuthenticationPackage;
 478
 479     /* Get the right authentication package */
 480     Package = LsapGetAuthenticationPackage(PackageId);
 481     if (Package == NULL)
 482     {
 483         TRACE("LsapGetAuthenticationPackage() failed to find a package\n");
 484         return STATUS_NO_SUCH_PACKAGE;
 485     }
 486
 487     if (RequestMsg->CallAuthenticationPackage.Request.SubmitBufferLength > 0)
 488     {
 489         LocalBuffer = RtlAllocateHeap(RtlGetProcessHeap(),
 490                                       HEAP_ZERO_MEMORY,
 491                                       RequestMsg->CallAuthenticationPackage.Request.SubmitBufferLength);
 492         if (LocalBuffer == NULL)
 493         {
 494             return STATUS_INSUFFICIENT_RESOURCES;
 495         }
 496
 497         Status = NtReadVirtualMemory(LogonContext->ClientProcessHandle,
 498                                      RequestMsg->CallAuthenticationPackage.Request.ProtocolSubmitBuffer,
 499                                      LocalBuffer,
 500                                      RequestMsg->CallAuthenticationPackage.Request.SubmitBufferLength,
 501                                      NULL);
 502         if (!NT_SUCCESS(Status))
 503         {
 504             TRACE("NtReadVirtualMemory() failed (Status 0x%08lx)\n", Status);
 505             RtlFreeHeap(RtlGetProcessHeap(), 0, LocalBuffer);
 506             return Status;
 507         }
 508     }
 509
 510     Status = Package->LsaApCallPackage((PLSA_CLIENT_REQUEST)LogonContext,
 511                                        LocalBuffer,
 512                                        RequestMsg->CallAuthenticationPackage.Request.ProtocolSubmitBuffer,
 513                                        RequestMsg->CallAuthenticationPackage.Request.SubmitBufferLength,
 514                                        &RequestMsg->CallAuthenticationPackage.Reply.ProtocolReturnBuffer,
 515                                        &RequestMsg->CallAuthenticationPackage.Reply.ReturnBufferLength,
 516                                        &RequestMsg->CallAuthenticationPackage.Reply.ProtocolStatus);
 517     if (!NT_SUCCESS(Status))
 518     {
 519         TRACE("Package->LsaApCallPackage() failed (Status 0x%08lx)\n", Status);
 520     }
 521
 522     if (LocalBuffer != NULL)
 523         RtlFreeHeap(RtlGetProcessHeap(), 0, LocalBuffer);
 524
 525     return Status;
 526 }
 527
 528
 529 NTSTATUS
 530 LsapLogonUser(PLSA_API_MSG RequestMsg,
 531               PLSAP_LOGON_CONTEXT LogonContext)
 532 {
 533     PAUTH_PACKAGE Package;
 534     ULONG PackageId;
 535     NTSTATUS Status;
 536
 537     LSA_TOKEN_INFORMATION_TYPE TokenInformationType;
 538     PVOID TokenInformation = NULL;
 539     PUNICODE_STRING AccountName = NULL;
 540     PUNICODE_STRING AuthenticatingAuthority = NULL;
 541     PUNICODE_STRING MachineName = NULL;
 542
 543     PVOID LocalAuthInfo = NULL;
 544
 545     TRACE("(%p %p)\n", RequestMsg, LogonContext);
 546
 547     PackageId = RequestMsg->LogonUser.Request.AuthenticationPackage;
 548
 549     /* Get the right authentication package */
 550     Package = LsapGetAuthenticationPackage(PackageId);
 551     if (Package == NULL)
 552     {
 553         TRACE("LsapGetAuthenticationPackage() failed to find a package\n");
 554         return STATUS_NO_SUCH_PACKAGE;
 555     }
 556
 557     if (RequestMsg->LogonUser.Request.AuthenticationInformationLength > 0)
 558     {
 559         /* Allocat the local authentication info buffer */
 560         LocalAuthInfo = RtlAllocateHeap(RtlGetProcessHeap(),
 561                                         HEAP_ZERO_MEMORY,
 562                                         RequestMsg->LogonUser.Request.AuthenticationInformationLength);
 563         if (LocalAuthInfo == NULL)
 564         {
 565             TRACE("RtlAllocateHeap() failed\n");
 566             return STATUS_INSUFFICIENT_RESOURCES;
 567         }
 568
 569         /* Read the authentication info from the callers adress space */
 570         Status = NtReadVirtualMemory(LogonContext->ClientProcessHandle,
 571                                      RequestMsg->LogonUser.Request.AuthenticationInformation,
 572                                      LocalAuthInfo,
 573                                      RequestMsg->LogonUser.Request.AuthenticationInformationLength,
 574                                      NULL);
 575         if (!NT_SUCCESS(Status))
 576         {
 577             TRACE("NtReadVirtualMemory() failed (Status 0x%08lx)\n", Status);
 578             RtlFreeHeap(RtlGetProcessHeap(), 0, LocalAuthInfo);
 579             return Status;
 580         }
 581     }
 582
 583     if (Package->LsaApLogonUserEx2 != NULL)
 584     {
 585         Status = Package->LsaApLogonUserEx2((PLSA_CLIENT_REQUEST)LogonContext,
 586                                             RequestMsg->LogonUser.Request.LogonType,
 587                                             LocalAuthInfo,
 588                                             RequestMsg->LogonUser.Request.AuthenticationInformation,
 589                                             RequestMsg->LogonUser.Request.AuthenticationInformationLength,
 590                                             &RequestMsg->LogonUser.Reply.ProfileBuffer,
 591                                             &RequestMsg->LogonUser.Reply.ProfileBufferLength,
 592                                             &RequestMsg->LogonUser.Reply.LogonId,
 593                                             &RequestMsg->LogonUser.Reply.SubStatus,
 594                                             &TokenInformationType,
 595                                             &TokenInformation,
 596                                             &AccountName,
 597                                             &AuthenticatingAuthority,
 598                                             &MachineName,
 599                                             NULL,  /* FIXME: PSECPKG_PRIMARY_CRED PrimaryCredentials */
 600                                             NULL); /* FIXME: PSECPKG_SUPPLEMENTAL_CRED_ARRAY *SupplementalCredentials */
 601     }
 602     else if (Package->LsaApLogonUserEx != NULL)
 603     {
 604         Status = Package->LsaApLogonUserEx((PLSA_CLIENT_REQUEST)LogonContext,
 605                                            RequestMsg->LogonUser.Request.LogonType,
 606                                            LocalAuthInfo,
 607                                            RequestMsg->LogonUser.Request.AuthenticationInformation,
 608                                            RequestMsg->LogonUser.Request.AuthenticationInformationLength,
 609                                            &RequestMsg->LogonUser.Reply.ProfileBuffer,
 610                                            &RequestMsg->LogonUser.Reply.ProfileBufferLength,
 611                                            &RequestMsg->LogonUser.Reply.LogonId,
 612                                            &RequestMsg->LogonUser.Reply.SubStatus,
 613                                            &TokenInformationType,
 614                                            &TokenInformation,
 615                                            &AccountName,
 616                                            &AuthenticatingAuthority,
 617                                            &MachineName);
 618     }
 619     else
 620     {
 621         Status = Package->LsaApLogonUser((PLSA_CLIENT_REQUEST)LogonContext,
 622                                          RequestMsg->LogonUser.Request.LogonType,
 623                                          LocalAuthInfo,
 624                                          RequestMsg->LogonUser.Request.AuthenticationInformation,
 625                                          RequestMsg->LogonUser.Request.AuthenticationInformationLength,
 626                                          &RequestMsg->LogonUser.Reply.ProfileBuffer,
 627                                          &RequestMsg->LogonUser.Reply.ProfileBufferLength,
 628                                          &RequestMsg->LogonUser.Reply.LogonId,
 629                                          &RequestMsg->LogonUser.Reply.SubStatus,
 630                                          &TokenInformationType,
 631                                          &TokenInformation,
 632                                          &AccountName,
 633                                          &AuthenticatingAuthority);
 634     }
 635
 636     /* Free the local authentication info buffer */
 637     if (LocalAuthInfo != NULL)
 638         RtlFreeHeap(RtlGetProcessHeap(), 0, LocalAuthInfo);
 639
 640     if (TokenInformation != NULL)
 641     {
 642
 643     }
 644
 645     if (AuthenticatingAuthority != NULL)
 646     {
 647
 648     }
 649
 650     if (AccountName != NULL)
 651     {
 652
 653     }
 654
 655     if (MachineName != NULL)
 656     {
 657
 658     }
 659
 660     return Status;
 661 }
 662
 663 /* EOF */