xref: /reactos/dll/win32/lsasrv/session.c (revision cc439606) 
1 /*
2  * PROJECT:     Local Security Authority Server DLL
3  * LICENSE:     GPL - See COPYING in the top level directory
4  * FILE:        dll/win32/lsasrv/session.c
5  * PURPOSE:     Logon session management routines
6  * COPYRIGHT:   Copyright 2013 Eric Kohl
7  */
8 
9 #include "lsasrv.h"
10 
11 typedef struct _LSAP_LOGON_SESSION
12 {
13     LIST_ENTRY Entry;
14     LUID LogonId;
15     ULONG LogonType;
16     ULONG Session;
17     LARGE_INTEGER LogonTime;
18     PSID Sid;
19     UNICODE_STRING UserName;
20     UNICODE_STRING LogonDomain;
21     UNICODE_STRING AuthenticationPackage;
22     UNICODE_STRING LogonServer;
23     UNICODE_STRING DnsDomainName;
24     UNICODE_STRING Upn;
25 } LSAP_LOGON_SESSION, *PLSAP_LOGON_SESSION;
26 
27 
28 /* GLOBALS *****************************************************************/
29 
30 LIST_ENTRY SessionListHead;
31 ULONG SessionCount;
32 
33 /* FUNCTIONS ***************************************************************/
34 
35 VOID
36 LsapInitLogonSessions(VOID)
37 {
38     InitializeListHead(&SessionListHead);
39     SessionCount = 0;
40 }
41 
42 
43 static
44 PLSAP_LOGON_SESSION
45 LsapGetLogonSession(IN PLUID LogonId)
46 {
47     PLIST_ENTRY SessionEntry;
48     PLSAP_LOGON_SESSION CurrentSession;
49 
50     SessionEntry = SessionListHead.Flink;
51     while (SessionEntry != &SessionListHead)
52     {
53         CurrentSession = CONTAINING_RECORD(SessionEntry,
54                                            LSAP_LOGON_SESSION,
55                                            Entry);
56         if (RtlEqualLuid(&CurrentSession->LogonId, LogonId))
57             return CurrentSession;
58 
59         SessionEntry = SessionEntry->Flink;
60     }
61 
62     return NULL;
63 }
64 
65 
66 NTSTATUS
67 LsapSetLogonSessionData(
68     _In_ PLUID LogonId,
69     _In_ ULONG LogonType,
70     _In_ PUNICODE_STRING UserName,
71     _In_ PUNICODE_STRING LogonDomain,
72     _In_ PSID Sid)
73 {
74     PLSAP_LOGON_SESSION Session;
75     ULONG Length;
76 
77     TRACE("LsapSetLogonSessionData(%p)\n", LogonId);
78 
79     Session = LsapGetLogonSession(LogonId);
80     if (Session == NULL)
81         return STATUS_NO_SUCH_LOGON_SESSION;
82 
83     TRACE("LogonType %lu\n", LogonType);
84     Session->LogonType = LogonType;
85 
86     TRACE("UserName %wZ\n", UserName);
87     Session->UserName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, UserName->MaximumLength);
88     if (Session->UserName.Buffer == NULL)
89         return STATUS_INSUFFICIENT_RESOURCES;
90 
91     Session->UserName.Length = UserName->Length;
92     Session->UserName.MaximumLength = UserName->MaximumLength;
93     RtlCopyMemory(Session->UserName.Buffer, UserName->Buffer, UserName->MaximumLength);
94 
95     TRACE("LogonDomain %wZ\n", LogonDomain);
96     Session->LogonDomain.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, LogonDomain->MaximumLength);
97     if (Session->LogonDomain.Buffer == NULL)
98         return STATUS_INSUFFICIENT_RESOURCES;
99 
100     Session->LogonDomain.Length = LogonDomain->Length;
101     Session->LogonDomain.MaximumLength = LogonDomain->MaximumLength;
102     RtlCopyMemory(Session->LogonDomain.Buffer, LogonDomain->Buffer, LogonDomain->MaximumLength);
103 
104     Length = RtlLengthSid(Sid);
105     Session->Sid = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, Length);
106     if (Session->UserName.Buffer == NULL)
107         return STATUS_INSUFFICIENT_RESOURCES;
108 
109     RtlCopyMemory(Session->Sid, Sid, Length);
110 
111     return STATUS_SUCCESS;
112 }
113 
114 
115 NTSTATUS
116 NTAPI
117 LsapCreateLogonSession(IN PLUID LogonId)
118 {
119     PLSAP_LOGON_SESSION Session;
120     NTSTATUS Status;
121 
122     TRACE("LsapCreateLogonSession(%p)\n", LogonId);
123 
124     /* Fail, if a session already exists */
125     if (LsapGetLogonSession(LogonId) != NULL)
126         return STATUS_LOGON_SESSION_COLLISION;
127 
128     /* Allocate a new session entry */
129     Session = RtlAllocateHeap(RtlGetProcessHeap(),
130                               HEAP_ZERO_MEMORY,
131                               sizeof(LSAP_LOGON_SESSION));
132     if (Session == NULL)
133         return STATUS_INSUFFICIENT_RESOURCES;
134 
135     /* Initialize the session entry */
136     RtlCopyLuid(&Session->LogonId, LogonId);
137 
138     TRACE("LsapCreateLogonSession(<0x%lx,0x%lx>)\n",
139           LogonId->HighPart, LogonId->LowPart);
140 
141     /* Tell ntoskrnl to create a new logon session */
142     Status = LsapRmCreateLogonSession(LogonId);
143     if (!NT_SUCCESS(Status))
144     {
145         RtlFreeHeap(RtlGetProcessHeap(), 0, Session);
146         return Status;
147     }
148 
149     /* Insert the new session into the session list */
150     InsertHeadList(&SessionListHead, &Session->Entry);
151     SessionCount++;
152 
153     return STATUS_SUCCESS;
154 }
155 
156 
157 NTSTATUS
158 NTAPI
159 LsapDeleteLogonSession(IN PLUID LogonId)
160 {
161     PLSAP_LOGON_SESSION Session;
162     NTSTATUS Status;
163 
164     TRACE("LsapDeleteLogonSession(%p)\n", LogonId);
165 
166     /* Fail, if the session does not exist */
167     Session = LsapGetLogonSession(LogonId);
168     if (Session == NULL)
169         return STATUS_NO_SUCH_LOGON_SESSION;
170 
171     TRACE("LsapDeleteLogonSession(<0x%lx,0x%lx>)\n",
172           LogonId->HighPart, LogonId->LowPart);
173 
174     /* Tell ntoskrnl to delete the logon session */
175     Status = LsapRmDeleteLogonSession(LogonId);
176     if (!NT_SUCCESS(Status))
177         return Status;
178 
179     /* Remove the session entry from the list */
180     RemoveEntryList(&Session->Entry);
181     SessionCount--;
182 
183     /* Free the session data */
184     if (Session->Sid != NULL)
185         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->Sid);
186 
187     if (Session->UserName.Buffer != NULL)
188         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->UserName.Buffer);
189 
190     if (Session->LogonDomain.Buffer != NULL)
191         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->LogonDomain.Buffer);
192 
193     if (Session->AuthenticationPackage.Buffer != NULL)
194         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->AuthenticationPackage.Buffer);
195 
196     if (Session->LogonServer.Buffer != NULL)
197         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->LogonServer.Buffer);
198 
199     if (Session->DnsDomainName.Buffer != NULL)
200         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->DnsDomainName.Buffer);
201 
202     if (Session->Upn.Buffer != NULL)
203         RtlFreeHeap(RtlGetProcessHeap(), 0, Session->Upn.Buffer);
204 
205     /* Free the session entry */
206     RtlFreeHeap(RtlGetProcessHeap(), 0, Session);
207 
208     return STATUS_SUCCESS;
209 }
210 
211 
212 NTSTATUS
213 NTAPI
214 LsapAddCredential(
215     _In_ PLUID LogonId,
216     _In_ ULONG AuthenticationPackage,
217     _In_ PLSA_STRING PrimaryKeyValue,
218     _In_ PLSA_STRING Credential)
219 {
220 
221     return STATUS_SUCCESS;
222 }
223 
224 
225 NTSTATUS
226 NTAPI
227 LsapGetCredentials(
228     _In_ PLUID LogonId,
229     _In_ ULONG AuthenticationPackage,
230     _Inout_ PULONG QueryContext,
231     _In_ BOOLEAN RetrieveAllCredentials,
232     _Inout_ PLSA_STRING PrimaryKeyValue,
233     _Out_ PULONG PrimaryKeyLength,
234     _Out_ PLSA_STRING Credentials)
235 {
236 
237     return STATUS_SUCCESS;
238 }
239 
240 
241 NTSTATUS
242 NTAPI
243 LsapDeleteCredential(
244     _In_ PLUID LogonId,
245     _In_ ULONG AuthenticationPackage,
246     _In_ PLSA_STRING PrimaryKeyValue)
247 {
248 
249     return STATUS_SUCCESS;
250 }
251 
252 
253 NTSTATUS
254 LsapEnumLogonSessions(IN OUT PLSA_API_MSG RequestMsg)
255 {
256     OBJECT_ATTRIBUTES ObjectAttributes;
257     HANDLE ProcessHandle = NULL;
258     PLIST_ENTRY SessionEntry;
259     PLSAP_LOGON_SESSION CurrentSession;
260     PLUID SessionList;
261     ULONG i, Length;
262     SIZE_T MemSize;
263     PVOID ClientBaseAddress = NULL;
264     NTSTATUS Status;
265 
266     TRACE("LsapEnumLogonSessions(%p)\n", RequestMsg);
267 
268     Length = SessionCount * sizeof(LUID);
269     SessionList = RtlAllocateHeap(RtlGetProcessHeap(),
270                                   HEAP_ZERO_MEMORY,
271                                   Length);
272     if (SessionList == NULL)
273         return STATUS_INSUFFICIENT_RESOURCES;
274 
275     i = 0;
276     SessionEntry = SessionListHead.Flink;
277     while (SessionEntry != &SessionListHead)
278     {
279         CurrentSession = CONTAINING_RECORD(SessionEntry,
280                                            LSAP_LOGON_SESSION,
281                                            Entry);
282 
283         RtlCopyLuid(&SessionList[i],
284                     &CurrentSession->LogonId);
285 
286         SessionEntry = SessionEntry->Flink;
287         i++;
288     }
289 
290     InitializeObjectAttributes(&ObjectAttributes,
291                                NULL,
292                                0,
293                                NULL,
294                                NULL);
295 
296     Status = NtOpenProcess(&ProcessHandle,
297                            PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
298                            &ObjectAttributes,
299                            &RequestMsg->h.ClientId);
300     if (!NT_SUCCESS(Status))
301     {
302         TRACE("NtOpenProcess() failed (Status %lx)\n", Status);
303         goto done;
304     }
305 
306     TRACE("Length: %lu\n", Length);
307 
308     MemSize = Length;
309     Status = NtAllocateVirtualMemory(ProcessHandle,
310                                      &ClientBaseAddress,
311                                      0,
312                                      &MemSize,
313                                      MEM_COMMIT,
314                                      PAGE_READWRITE);
315     if (!NT_SUCCESS(Status))
316     {
317         TRACE("NtAllocateVirtualMemory() failed (Status %lx)\n", Status);
318         goto done;
319     }
320 
321     TRACE("MemSize: %lu\n", MemSize);
322     TRACE("ClientBaseAddress: %p\n", ClientBaseAddress);
323 
324     Status = NtWriteVirtualMemory(ProcessHandle,
325                                   ClientBaseAddress,
326                                   SessionList,
327                                   Length,
328                                   NULL);
329     if (!NT_SUCCESS(Status))
330     {
331         TRACE("NtWriteVirtualMemory() failed (Status %lx)\n", Status);
332         goto done;
333     }
334 
335     RequestMsg->EnumLogonSessions.Reply.LogonSessionCount = SessionCount;
336     RequestMsg->EnumLogonSessions.Reply.LogonSessionBuffer = ClientBaseAddress;
337 
338 done:
339     if (ProcessHandle != NULL)
340         NtClose(ProcessHandle);
341 
342     if (SessionList != NULL)
343         RtlFreeHeap(RtlGetProcessHeap(), 0, SessionList);
344 
345     return Status;
346 }
347 
348 
349 NTSTATUS
350 LsapGetLogonSessionData(IN OUT PLSA_API_MSG RequestMsg)
351 {
352     OBJECT_ATTRIBUTES ObjectAttributes;
353     HANDLE ProcessHandle = NULL;
354     PLSAP_LOGON_SESSION Session;
355     PSECURITY_LOGON_SESSION_DATA LocalSessionData;
356     PVOID ClientBaseAddress = NULL;
357     ULONG TotalLength, SidLength = 0;
358     SIZE_T MemSize;
359     PUCHAR Ptr;
360     NTSTATUS Status;
361 
362     TRACE("LsapGetLogonSessionData(%p)\n", RequestMsg);
363 
364     TRACE("LogonId: %lx\n", RequestMsg->GetLogonSessionData.Request.LogonId.LowPart);
365     Session = LsapGetLogonSession(&RequestMsg->GetLogonSessionData.Request.LogonId);
366     if (Session == NULL)
367         return STATUS_NO_SUCH_LOGON_SESSION;
368 
369     /* Calculate the required buffer size */
370     TotalLength = sizeof(SECURITY_LOGON_SESSION_DATA) +
371                   Session->UserName.MaximumLength +
372                   Session->LogonDomain.MaximumLength +
373                   Session->AuthenticationPackage.MaximumLength +
374                   Session->LogonServer.MaximumLength +
375                   Session->DnsDomainName.MaximumLength +
376                   Session->Upn.MaximumLength;
377     if (Session->Sid != NULL)
378     {
379         SidLength = RtlLengthSid(Session->Sid);
380         TotalLength += SidLength;
381     }
382     TRACE("TotalLength: %lu\n", TotalLength);
383 
384     /* Allocate the buffer */
385     LocalSessionData = RtlAllocateHeap(RtlGetProcessHeap(),
386                                        HEAP_ZERO_MEMORY,
387                                        TotalLength);
388     if (LocalSessionData == NULL)
389         return STATUS_INSUFFICIENT_RESOURCES;
390 
391     Ptr = (PUCHAR)((ULONG_PTR)LocalSessionData + sizeof(SECURITY_LOGON_SESSION_DATA));
392     TRACE("LocalSessionData: %p  Ptr: %p\n", LocalSessionData, Ptr);
393 
394     LocalSessionData->Size = sizeof(SECURITY_LOGON_SESSION_DATA);
395 
396     /* Copy the LogonId */
397     RtlCopyLuid(&LocalSessionData->LogonId,
398                 &RequestMsg->GetLogonSessionData.Request.LogonId);
399 
400     /* Copy the UserName string*/
401     LocalSessionData->UserName.Length = Session->UserName.Length;
402     LocalSessionData->UserName.MaximumLength = Session->UserName.MaximumLength;
403 
404     if (Session->UserName.MaximumLength != 0)
405     {
406         RtlCopyMemory(Ptr, Session->UserName.Buffer, Session->UserName.MaximumLength);
407         LocalSessionData->UserName.Buffer = (PWSTR)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
408 
409         Ptr = (PUCHAR)((ULONG_PTR)Ptr + Session->UserName.MaximumLength);
410     }
411 
412     /* Copy the LogonDomain string */
413     LocalSessionData->LogonDomain.Length = Session->LogonDomain.Length;
414     LocalSessionData->LogonDomain.MaximumLength = Session->LogonDomain.MaximumLength;
415     if (Session->LogonDomain.MaximumLength != 0)
416     {
417         RtlCopyMemory(Ptr, Session->LogonDomain.Buffer, Session->LogonDomain.MaximumLength);
418         LocalSessionData->LogonDomain.Buffer = (PWSTR)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
419 
420         Ptr = (PUCHAR)((ULONG_PTR)Ptr + Session->LogonDomain.MaximumLength);
421     }
422 
423     /* Copy the AuthenticationPackage string */
424     LocalSessionData->AuthenticationPackage.Length = Session->AuthenticationPackage.Length;
425     LocalSessionData->AuthenticationPackage.MaximumLength = Session->AuthenticationPackage.MaximumLength;
426     if (Session->AuthenticationPackage.MaximumLength != 0)
427     {
428         RtlCopyMemory(Ptr, Session->AuthenticationPackage.Buffer, Session->AuthenticationPackage.MaximumLength);
429         LocalSessionData->AuthenticationPackage.Buffer = (PWSTR)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
430 
431         Ptr = (PUCHAR)((ULONG_PTR)Ptr + Session->AuthenticationPackage.MaximumLength);
432     }
433 
434     LocalSessionData->LogonType = Session->LogonType;
435     LocalSessionData->Session = 0;
436 
437     /* Sid */
438     if (Session->Sid != NULL)
439     {
440         RtlCopyMemory(Ptr, Session->Sid, SidLength);
441         LocalSessionData->Sid = (PSID)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
442 
443         Ptr = (PUCHAR)((ULONG_PTR)Ptr + SidLength);
444     }
445 
446     /* LogonTime */
447     LocalSessionData->LogonTime.QuadPart = Session->LogonTime.QuadPart;
448 
449     /* Copy the LogonServer string */
450     LocalSessionData->LogonServer.Length = Session->LogonServer.Length;
451     LocalSessionData->LogonServer.MaximumLength = Session->LogonServer.MaximumLength;
452     if (Session->LogonServer.MaximumLength != 0)
453     {
454         RtlCopyMemory(Ptr, Session->LogonServer.Buffer, Session->LogonServer.MaximumLength);
455         LocalSessionData->LogonServer.Buffer = (PWSTR)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
456 
457         Ptr = (PUCHAR)((ULONG_PTR)Ptr + Session->LogonServer.MaximumLength);
458     }
459 
460     /* Copy the DnsDomainName string */
461     LocalSessionData->DnsDomainName.Length = Session->DnsDomainName.Length;
462     LocalSessionData->DnsDomainName.MaximumLength = Session->DnsDomainName.MaximumLength;
463     if (Session->DnsDomainName.MaximumLength != 0)
464     {
465         RtlCopyMemory(Ptr, Session->DnsDomainName.Buffer, Session->DnsDomainName.MaximumLength);
466         LocalSessionData->DnsDomainName.Buffer = (PWSTR)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
467 
468         Ptr = (PUCHAR)((ULONG_PTR)Ptr + Session->DnsDomainName.MaximumLength);
469     }
470 
471     /* Copy the Upn string */
472     LocalSessionData->Upn.Length = Session->Upn.Length;
473     LocalSessionData->Upn.MaximumLength = Session->Upn.MaximumLength;
474     if (Session->Upn.MaximumLength != 0)
475     {
476         RtlCopyMemory(Ptr, Session->Upn.Buffer, Session->Upn.MaximumLength);
477         LocalSessionData->Upn.Buffer = (PWSTR)((ULONG_PTR)Ptr - (ULONG_PTR)LocalSessionData);
478 
479         Ptr = (PUCHAR)((ULONG_PTR)Ptr + Session->Upn.MaximumLength);
480     }
481 
482 
483     InitializeObjectAttributes(&ObjectAttributes,
484                                NULL,
485                                0,
486                                NULL,
487                                NULL);
488 
489     Status = NtOpenProcess(&ProcessHandle,
490                            PROCESS_VM_READ | PROCESS_VM_WRITE | PROCESS_VM_OPERATION,
491                            &ObjectAttributes,
492                            &RequestMsg->h.ClientId);
493     if (!NT_SUCCESS(Status))
494     {
495         TRACE("NtOpenProcess() failed (Status %lx)\n", Status);
496         goto done;
497     }
498 
499     MemSize = TotalLength;
500     Status = NtAllocateVirtualMemory(ProcessHandle,
501                                      &ClientBaseAddress,
502                                      0,
503                                      &MemSize,
504                                      MEM_COMMIT,
505                                      PAGE_READWRITE);
506     if (!NT_SUCCESS(Status))
507     {
508         TRACE("NtAllocateVirtualMemory() failed (Status %lx)\n", Status);
509         goto done;
510     }
511 
512     TRACE("MemSize: %lu\n", MemSize);
513     TRACE("ClientBaseAddress: %p\n", ClientBaseAddress);
514 
515     Status = NtWriteVirtualMemory(ProcessHandle,
516                                   ClientBaseAddress,
517                                   LocalSessionData,
518                                   TotalLength,
519                                   NULL);
520     if (!NT_SUCCESS(Status))
521     {
522         TRACE("NtWriteVirtualMemory() failed (Status %lx)\n", Status);
523         goto done;
524     }
525 
526     RequestMsg->GetLogonSessionData.Reply.SessionDataBuffer = ClientBaseAddress;
527 
528 done:
529     if (ProcessHandle != NULL)
530         NtClose(ProcessHandle);
531 
532     if (LocalSessionData != NULL)
533         RtlFreeHeap(RtlGetProcessHeap(), 0, LocalSessionData);
534 
535     return Status;
536 }
537 
538 /* EOF */
539