reactos/lib/lsalib/lsa.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/lsalib/lsa.c
   5  * PURPOSE:         Client-side LSA functions
   6  * UPDATE HISTORY:
   7  *                  Created 05/08/00
   8  */
   9
  10 /* INCLUDES ******************************************************************/
  11
  12 #include <ndk/lpctypes.h>
  13 #include <ndk/lpcfuncs.h>
  14 #include <ndk/rtlfuncs.h>
  15 #include <psdk/ntsecapi.h>
  16 #include <lsass/lsass.h>
  17
  18 #define NDEBUG
  19 #include <debug.h>
  20
  21 /* GLOBALS *******************************************************************/
  22
  23 extern HANDLE Secur32Heap;
  24
  25 /* FUNCTIONS *****************************************************************/
  26
  27 /*
  28  * @implemented
  29  */
  30 NTSTATUS WINAPI
  31 LsaDeregisterLogonProcess(HANDLE LsaHandle)
  32 {
  33     LSASS_REQUEST Request;
  34     LSASS_REPLY Reply;
  35     NTSTATUS Status;
  36
  37     Request.Header.u1.s1.DataLength = 0;
  38     Request.Header.u1.s1.TotalLength = sizeof(LSASS_REQUEST);
  39     Request.Type = LSASS_REQUEST_DEREGISTER_LOGON_PROCESS;
  40     Status = ZwRequestWaitReplyPort(LsaHandle,
  41                                     &Request.Header,
  42                                     &Reply.Header);
  43     if (!NT_SUCCESS(Status))
  44     {
  45         return Status;
  46     }
  47
  48     if (!NT_SUCCESS(Reply.Status))
  49     {
  50         return Reply.Status;
  51     }
  52
  53     return Status;
  54 }
  55
  56
  57 /*
  58  * @unimplemented
  59  */
  60 NTSTATUS WINAPI
  61 LsaConnectUntrusted(PHANDLE LsaHandle)
  62 {
  63     UNIMPLEMENTED;
  64     return STATUS_NOT_IMPLEMENTED;
  65 }
  66
  67
  68 /*
  69  * @implemented
  70  */
  71 NTSTATUS WINAPI
  72 LsaCallAuthenticationPackage(HANDLE LsaHandle,
  73                              ULONG AuthenticationPackage,
  74                              PVOID ProtocolSubmitBuffer,
  75                              ULONG SubmitBufferLength,
  76                              PVOID *ProtocolReturnBuffer,
  77                              PULONG ReturnBufferLength,
  78                              PNTSTATUS ProtocolStatus)
  79 {
  80     PLSASS_REQUEST Request;
  81     PLSASS_REPLY Reply;
  82     LSASS_REQUEST RawRequest;
  83     LSASS_REPLY RawReply;
  84     NTSTATUS Status;
  85     ULONG OutBufferSize;
  86
  87     Request = (PLSASS_REQUEST)&RawRequest;
  88     Reply = (PLSASS_REPLY)&RawReply;
  89
  90     Request->Header.u1.s1.DataLength = sizeof(LSASS_REQUEST) + SubmitBufferLength -
  91         sizeof(PORT_MESSAGE);
  92     Request->Header.u1.s1.TotalLength =
  93         Request->Header.u1.s1.DataLength + sizeof(PORT_MESSAGE);
  94     Request->Type = LSASS_REQUEST_CALL_AUTHENTICATION_PACKAGE;
  95     Request->d.CallAuthenticationPackageRequest.AuthenticationPackage =
  96         AuthenticationPackage;
  97     Request->d.CallAuthenticationPackageRequest.InBufferLength =
  98         SubmitBufferLength;
  99     memcpy(Request->d.CallAuthenticationPackageRequest.InBuffer,
 100            ProtocolSubmitBuffer,
 101            SubmitBufferLength);
 102
 103     Status = ZwRequestWaitReplyPort(LsaHandle,
 104                                     &Request->Header,
 105                                     &Reply->Header);
 106     if (!NT_SUCCESS(Status))
 107     {
 108         return Status;
 109     }
 110
 111     if (!NT_SUCCESS(Reply->Status))
 112     {
 113         return Reply->Status;
 114     }
 115
 116     OutBufferSize = Reply->d.CallAuthenticationPackageReply.OutBufferLength;
 117     *ProtocolReturnBuffer = RtlAllocateHeap(Secur32Heap,
 118                                             0,
 119                                             OutBufferSize);
 120     *ReturnBufferLength = OutBufferSize;
 121     memcpy(*ProtocolReturnBuffer,
 122            Reply->d.CallAuthenticationPackageReply.OutBuffer,
 123            *ReturnBufferLength);
 124
 125     return Status;
 126 }
 127
 128
 129 /*
 130  * @implemented
 131  */
 132 NTSTATUS WINAPI
 133 LsaFreeReturnBuffer(PVOID Buffer)
 134 {
 135     return RtlFreeHeap(Secur32Heap, 0, Buffer);
 136 }
 137
 138
 139 /*
 140  * @implemented
 141  */
 142 NTSTATUS WINAPI
 143 LsaLookupAuthenticationPackage(HANDLE LsaHandle,
 144                                PLSA_STRING PackageName,
 145                                PULONG AuthenticationPackage)
 146 {
 147     NTSTATUS Status;
 148     PLSASS_REQUEST Request;
 149     LSASS_REQUEST RawRequest;
 150     LSASS_REPLY Reply;
 151
 152     Request = (PLSASS_REQUEST)&RawRequest;
 153     Request->Header.u1.s1.DataLength = sizeof(LSASS_REQUEST) + PackageName->Length -
 154         sizeof(PORT_MESSAGE);
 155     Request->Header.u1.s1.TotalLength = Request->Header.u1.s1.DataLength +
 156         sizeof(PORT_MESSAGE);
 157     Request->Type = LSASS_REQUEST_LOOKUP_AUTHENTICATION_PACKAGE;
 158
 159     Status = ZwRequestWaitReplyPort(LsaHandle,
 160                                     &Request->Header,
 161                                     &Reply.Header);
 162     if (!NT_SUCCESS(Status))
 163     {
 164         return Status;
 165     }
 166
 167     if (!NT_SUCCESS(Reply.Status))
 168     {
 169         return Reply.Status;
 170     }
 171
 172     *AuthenticationPackage = Reply.d.LookupAuthenticationPackageReply.Package;
 173
 174     return Reply.Status;
 175 }
 176
 177
 178 /*
 179  * @implemented
 180  */
 181 NTSTATUS WINAPI
 182 LsaLogonUser(HANDLE LsaHandle,
 183              PLSA_STRING OriginName,
 184              SECURITY_LOGON_TYPE LogonType,
 185              ULONG AuthenticationPackage,
 186              PVOID AuthenticationInformation,
 187              ULONG AuthenticationInformationLength,
 188              PTOKEN_GROUPS LocalGroups,
 189              PTOKEN_SOURCE SourceContext,
 190              PVOID *ProfileBuffer,
 191              PULONG ProfileBufferLength,
 192              PLUID LogonId,
 193              PHANDLE Token,
 194              PQUOTA_LIMITS Quotas,
 195              PNTSTATUS SubStatus)
 196 {
 197     ULONG RequestLength;
 198     ULONG CurrentLength;
 199     PLSASS_REQUEST Request;
 200     LSASS_REQUEST RawMessage;
 201     PLSASS_REPLY Reply;
 202     LSASS_REPLY RawReply;
 203     NTSTATUS Status;
 204
 205     RequestLength = sizeof(LSASS_REQUEST) - sizeof(PORT_MESSAGE);
 206     RequestLength = RequestLength + (OriginName->Length * sizeof(WCHAR));
 207     RequestLength = RequestLength + AuthenticationInformationLength;
 208     RequestLength = RequestLength +
 209         (LocalGroups->GroupCount * sizeof(SID_AND_ATTRIBUTES));
 210
 211     CurrentLength = 0;
 212     Request = (PLSASS_REQUEST)&RawMessage;
 213
 214     Request->d.LogonUserRequest.OriginNameLength = OriginName->Length;
 215     Request->d.LogonUserRequest.OriginName = (PWSTR)&RawMessage + CurrentLength;
 216     memcpy((PWSTR)&RawMessage + CurrentLength,
 217            OriginName->Buffer,
 218            OriginName->Length * sizeof(WCHAR));
 219     CurrentLength = CurrentLength + (OriginName->Length * sizeof(WCHAR));
 220
 221     Request->d.LogonUserRequest.LogonType = LogonType;
 222
 223     Request->d.LogonUserRequest.AuthenticationPackage =
 224         AuthenticationPackage;
 225
 226     Request->d.LogonUserRequest.AuthenticationInformation =
 227         (PVOID)((ULONG_PTR)&RawMessage + CurrentLength);
 228     Request->d.LogonUserRequest.AuthenticationInformationLength =
 229         AuthenticationInformationLength;
 230     memcpy((PVOID)((ULONG_PTR)&RawMessage + CurrentLength),
 231            AuthenticationInformation,
 232            AuthenticationInformationLength);
 233     CurrentLength = CurrentLength + AuthenticationInformationLength;
 234
 235     Request->d.LogonUserRequest.LocalGroupsCount = LocalGroups->GroupCount;
 236     Request->d.LogonUserRequest.LocalGroups =
 237         (PSID_AND_ATTRIBUTES)&RawMessage + CurrentLength;
 238     memcpy((PSID_AND_ATTRIBUTES)&RawMessage + CurrentLength,
 239            LocalGroups->Groups,
 240            LocalGroups->GroupCount * sizeof(SID_AND_ATTRIBUTES));
 241
 242     Request->d.LogonUserRequest.SourceContext = *SourceContext;
 243
 244     Request->Type = LSASS_REQUEST_LOGON_USER;
 245     Request->Header.u1.s1.DataLength = RequestLength - sizeof(PORT_MESSAGE);
 246     Request->Header.u1.s1.TotalLength = RequestLength + sizeof(PORT_MESSAGE);
 247
 248     Reply = (PLSASS_REPLY)&RawReply;
 249
 250     Status = ZwRequestWaitReplyPort(LsaHandle,
 251                                    &Request->Header,
 252                                    &Reply->Header);
 253     if (!NT_SUCCESS(Status))
 254     {
 255         return Status;
 256     }
 257
 258     *SubStatus = Reply->d.LogonUserReply.SubStatus;
 259
 260     if (!NT_SUCCESS(Reply->Status))
 261     {
 262         return Status;
 263     }
 264
 265     *ProfileBuffer = RtlAllocateHeap(Secur32Heap,
 266                                      0,
 267                                      Reply->d.LogonUserReply.ProfileBufferLength);
 268     memcpy(*ProfileBuffer,
 269            (PVOID)((ULONG_PTR)Reply->d.LogonUserReply.Data +
 270                    (ULONG_PTR)Reply->d.LogonUserReply.ProfileBuffer),
 271            Reply->d.LogonUserReply.ProfileBufferLength);
 272     *LogonId = Reply->d.LogonUserReply.LogonId;
 273     *Token = Reply->d.LogonUserReply.Token;
 274     memcpy(Quotas,
 275            &Reply->d.LogonUserReply.Quotas,
 276            sizeof(Reply->d.LogonUserReply.Quotas));
 277
 278     return Status;
 279 }
 280
 281
 282 /*
 283  * @implemented
 284  */
 285 NTSTATUS WINAPI
 286 LsaRegisterLogonProcess(PLSA_STRING LsaLogonProcessName,
 287                         PHANDLE Handle,
 288                         PLSA_OPERATIONAL_MODE OperationalMode)
 289 {
 290     UNICODE_STRING PortName; // = RTL_CONSTANT_STRING(L"\\LsaAuthenticationPort");
 291     SECURITY_QUALITY_OF_SERVICE SecurityQos;
 292     ULONG ConnectInfoLength;
 293     NTSTATUS Status;
 294     LSASS_CONNECT_DATA ConnectInfo;
 295 //    LSASS_REQUEST Request;
 296 //    LSASS_REPLY Reply;
 297
 298     /* Check the logon process name length */
 299     if (LsaLogonProcessName->Length > LSASS_MAX_LOGON_PROCESS_NAME_LENGTH)
 300         return STATUS_NAME_TOO_LONG;
 301
 302     RtlInitUnicodeString(&PortName,
 303                          L"\\LsaAuthenticationPort");
 304
 305     SecurityQos.Length              = sizeof (SecurityQos);
 306     SecurityQos.ImpersonationLevel  = SecurityIdentification;
 307     SecurityQos.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING;
 308     SecurityQos.EffectiveOnly       = TRUE;
 309
 310     ConnectInfoLength = sizeof(LSASS_CONNECT_DATA);
 311
 312     strncpy(ConnectInfo.LogonProcessNameBuffer,
 313             LsaLogonProcessName->Buffer,
 314             LsaLogonProcessName->Length);
 315     ConnectInfo.Length = LsaLogonProcessName->Length;
 316     ConnectInfo.LogonProcessNameBuffer[ConnectInfo.Length] = '\0';
 317
 318     Status = ZwConnectPort(Handle,
 319                            &PortName,
 320                            &SecurityQos,
 321                            NULL,
 322                            NULL,
 323                            NULL,
 324                            &ConnectInfo,
 325                            &ConnectInfoLength);
 326     if (!NT_SUCCESS(Status))
 327     {
 328         return Status;
 329     }
 330
 331     return Status;
 332 #if 0
 333     Request.Type = LSASS_REQUEST_REGISTER_LOGON_PROCESS;
 334     Request.Header.u1.s1.DataLength = sizeof(LSASS_REQUEST) -
 335         sizeof(PORT_MESSAGE);
 336     Request.Header.u1.s1.TotalLength = sizeof(LSASS_REQUEST);
 337
 338     Request.d.RegisterLogonProcessRequest.Length = LsaLogonProcessName->Length;
 339     memcpy(Request.d.RegisterLogonProcessRequest.LogonProcessNameBuffer,
 340            LsaLogonProcessName->Buffer,
 341            Request.d.RegisterLogonProcessRequest.Length);
 342
 343     Status = ZwRequestWaitReplyPort(*Handle,
 344                                     &Request.Header,
 345                                     &Reply.Header);
 346     if (!NT_SUCCESS(Status))
 347     {
 348 //        NtClose(*Handle);
 349 //        *Handle = NULL;
 350         return Status;
 351     }
 352
 353     if (!NT_SUCCESS(Reply.Status))
 354     {
 355 //        NtClose(*Handle);
 356 //        *Handle = NULL;
 357         return Status;
 358     }
 359
 360     *OperationalMode = Reply.d.RegisterLogonProcessReply.OperationalMode;
 361
 362     return Reply.Status;
 363 #endif
 364 }
 365
 366
 367 /*
 368  * @unimplemented
 369  */
 370 NTSTATUS
 371 WINAPI
 372 LsaEnumerateLogonSessions(PULONG LogonSessionCount,
 373                           PLUID *LogonSessionList)
 374 {
 375     UNIMPLEMENTED;
 376     return STATUS_NOT_IMPLEMENTED;
 377 }
 378
 379
 380 /*
 381  * @unimplemented
 382  */
 383 NTSTATUS
 384 WINAPI
 385 LsaGetLogonSessionData(PLUID LogonId,
 386                        PSECURITY_LOGON_SESSION_DATA *ppLogonSessionData)
 387 {
 388     UNIMPLEMENTED;
 389     return STATUS_NOT_IMPLEMENTED;
 390 }
 391
 392
 393 /*
 394  * @unimplemented
 395  */
 396 NTSTATUS
 397 WINAPI
 398 LsaRegisterPolicyChangeNotification(POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass,
 399                                     HANDLE NotificationEventHandle)
 400 {
 401     UNIMPLEMENTED;
 402     return STATUS_NOT_IMPLEMENTED;
 403 }
 404
 405
 406 /*
 407  * @unimplemented
 408  */
 409 NTSTATUS
 410 WINAPI
 411 LsaUnregisterPolicyChangeNotification(POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass,
 412                                       HANDLE NotificationEventHandle)
 413 {
 414     UNIMPLEMENTED;
 415     return STATUS_NOT_IMPLEMENTED;
 416 }