ReactOS  0.4.14-dev-606-g14ebc0b
sysfunc.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS system libraries
4  * FILE: dll/win32/advapi32/misc/sysfunc.c
5  * PURPOSE: advapi32.dll system functions (undocumented)
6  * PROGRAMMER: Emanuele Aliberti
7  * UPDATE HISTORY:
8  * 19990413 EA created
9  * 19990415 EA
10  * 20080424 Ported from WINE
11  */
12 
13 #include <advapi32.h>
14 #include <ntsecapi.h>
15 #include <ksecioctl.h>
16 #include <md4.h>
17 #include <md5.h>
18 #include <rc4.h>
19 
20 static const unsigned char CRYPT_LMhash_Magic[8] =
21  { 'K', 'G', 'S', '!', '@', '#', '$', '%' };
22 static const unsigned char DefaultSessionKey[16] =
23  {'D', 'e', 'f', 'S', 'e', 's', 's', 'i', 'o', 'n', 'K', 'e', 'y', '!', '@', '#'};
24 
25 /******************************************************************************
26  * SystemFunction001 [ADVAPI32.@]
27  *
28  * Encrypts a single block of data using DES
29  *
30  * PARAMS
31  * data [I] data to encrypt (8 bytes)
32  * key [I] key data (7 bytes)
33  * output [O] the encrypted data (8 bytes)
34  *
35  * RETURNS
36  * Success: STATUS_SUCCESS
37  * Failure: STATUS_UNSUCCESSFUL
38  *
39  */
42 {
43  if (!data || !output)
44  return STATUS_UNSUCCESSFUL;
46  return STATUS_SUCCESS;
47 }
48 
49 
50 /******************************************************************************
51  * SystemFunction002 [ADVAPI32.@]
52  *
53  * Decrypts a single block of data using DES
54  *
55  * PARAMS
56  * data [I] data to decrypt (8 bytes)
57  * key [I] key data (7 bytes)
58  * output [O] the decrypted data (8 bytes)
59  *
60  * RETURNS
61  * Success: STATUS_SUCCESS
62  * Failure: STATUS_UNSUCCESSFUL
63  *
64  */
67 {
68  if (!data || !output)
69  return STATUS_UNSUCCESSFUL;
71  return STATUS_SUCCESS;
72 }
73 
74 
75 /******************************************************************************
76  * SystemFunction003 [ADVAPI32.@]
77  *
78  * Hashes a key using DES and a fixed datablock
79  *
80  * PARAMS
81  * key [I] key data (7 bytes)
82  * output [O] hashed key (8 bytes)
83  *
84  * RETURNS
85  * Success: STATUS_SUCCESS
86  * Failure: STATUS_UNSUCCESSFUL
87  *
88  */
91 {
92  if (!output)
93  return STATUS_UNSUCCESSFUL;
95  return STATUS_SUCCESS;
96 }
97 
98 
99 /******************************************************************************
100  * SystemFunction004 [ADVAPI32.@]
101  *
102  * Encrypts a block of data with DES in ECB mode, preserving the length
103  *
104  * PARAMS
105  * data [I] data to encrypt
106  * key [I] key data (up to 7 bytes)
107  * output [O] buffer to receive encrypted data
108  *
109  * RETURNS
110  * Success: STATUS_SUCCESS
111  * Failure: STATUS_BUFFER_TOO_SMALL if the output buffer is too small
112  * Failure: STATUS_INVALID_PARAMETER_2 if the key is zero length
113  *
114  * NOTES
115  * Encrypt buffer size should be input size rounded up to 8 bytes
116  * plus an extra 8 bytes.
117  */
118 NTSTATUS
120  const struct ustring *key,
121  struct ustring *out)
122 {
123  union {
124  unsigned char uc[8];
125  unsigned int ui[2];
126  } data;
127  unsigned char deskey[7];
128  unsigned int crypt_len, ofs;
129 
130  if (key->Length<=0)
132 
133  crypt_len = ((in->Length+7)&~7);
134  if (out->MaximumLength < (crypt_len+8))
135  {
136  out->Length = crypt_len + 8;
138  }
139 
140  data.ui[0] = in->Length;
141  data.ui[1] = 1;
142 
143  if (key->Length<sizeof deskey)
144  {
145  memset(deskey, 0, sizeof deskey);
146  memcpy(deskey, key->Buffer, key->Length);
147  }
148  else
149  memcpy(deskey, key->Buffer, sizeof deskey);
150 
151  CRYPT_DEShash(out->Buffer, deskey, data.uc);
152 
153  for(ofs=0; ofs<(crypt_len-8); ofs+=8)
154  CRYPT_DEShash(out->Buffer+8+ofs, deskey, in->Buffer+ofs);
155 
156  memset(data.uc, 0, sizeof data.uc);
157  memcpy(data.uc, in->Buffer+ofs, in->Length +8-crypt_len);
158  CRYPT_DEShash(out->Buffer+8+ofs, deskey, data.uc);
159 
160  out->Length = crypt_len+8;
161 
162  return STATUS_SUCCESS;
163 }
164 
165 /******************************************************************************
166  * SystemFunction005 [ADVAPI32.@]
167  *
168  * Decrypts a block of data with DES in ECB mode
169  *
170  * PARAMS
171  * data [I] data to decrypt
172  * key [I] key data (up to 7 bytes)
173  * output [O] buffer to receive decrypted data
174  *
175  * RETURNS
176  * Success: STATUS_SUCCESS
177  * Failure: STATUS_BUFFER_TOO_SMALL if the output buffer is too small
178  * Failure: STATUS_INVALID_PARAMETER_2 if the key is zero length
179  *
180  */
181 NTSTATUS
183  const struct ustring *key,
184  struct ustring *out)
185 {
186  union {
187  unsigned char uc[8];
188  unsigned int ui[2];
189  } data;
190  unsigned char deskey[7];
191  unsigned int ofs, crypt_len;
192 
193  if (key->Length<=0)
195 
196  if (key->Length<sizeof deskey)
197  {
198  memset(deskey, 0, sizeof deskey);
199  memcpy(deskey, key->Buffer, key->Length);
200  }
201  else
202  memcpy(deskey, key->Buffer, sizeof deskey);
203 
204  CRYPT_DESunhash(data.uc, deskey, in->Buffer);
205 
206  if (data.ui[1] != 1)
208 
209  crypt_len = data.ui[0];
210  if (crypt_len > out->MaximumLength)
211  {
212  out->Length = crypt_len;
214  }
215 
216  for (ofs=0; (ofs+8)<crypt_len; ofs+=8)
217  CRYPT_DESunhash(out->Buffer+ofs, deskey, in->Buffer+ofs+8);
218 
219  if (ofs<crypt_len)
220  {
221  CRYPT_DESunhash(data.uc, deskey, in->Buffer+ofs+8);
222  memcpy(out->Buffer+ofs, data.uc, crypt_len-ofs);
223  }
224 
225  out->Length = crypt_len;
226 
227  return STATUS_SUCCESS;
228 }
229 
230 /******************************************************************************
231  * SystemFunction007 [ADVAPI32.@]
232  *
233  * MD4 hash a unicode string
234  *
235  * PARAMS
236  * string [I] the string to hash
237  * output [O] the md4 hash of the string (16 bytes)
238  *
239  * RETURNS
240  * Success: STATUS_SUCCESS
241  * Failure: STATUS_UNSUCCESSFUL
242  *
243  */
244 NTSTATUS
246 {
247  MD4_CTX ctx;
248 
249  MD4Init( &ctx );
250  MD4Update( &ctx, (const BYTE *)string->Buffer, string->Length );
251  MD4Final( &ctx );
252  memcpy( hash, ctx.digest, 0x10 );
253 
254  return STATUS_SUCCESS;
255 }
256 
257 /******************************************************************************
258  * SystemFunction008 [ADVAPI32.@]
259  *
260  * Creates a LM response from a challenge and a password hash
261  *
262  * PARAMS
263  * challenge [I] Challenge from authentication server
264  * hash [I] NTLM hash (from SystemFunction006)
265  * response [O] response to send back to the server
266  *
267  * RETURNS
268  * Success: STATUS_SUCCESS
269  * Failure: STATUS_UNSUCCESSFUL
270  *
271  * NOTES
272  * see http://davenport.sourceforge.net/ntlm.html#theLmResponse
273  *
274  */
275 NTSTATUS
276 WINAPI SystemFunction008(const BYTE *challenge, const BYTE *hash, LPBYTE response)
277 {
278  BYTE key[7*3];
279 
280  if (!challenge || !response)
281  return STATUS_UNSUCCESSFUL;
282 
283  memset(key, 0, sizeof key);
284  memcpy(key, hash, 0x10);
285 
286  CRYPT_DEShash(response, key, challenge);
287  CRYPT_DEShash(response+8, key+7, challenge);
288  CRYPT_DEShash(response+16, key+14, challenge);
289 
290  return STATUS_SUCCESS;
291 }
292 
293 /******************************************************************************
294  * SystemFunction009 [ADVAPI32.@]
295  *
296  * Seems to do the same as SystemFunction008...
297  */
298 NTSTATUS
299 WINAPI SystemFunction009(const BYTE *challenge, const BYTE *hash, LPBYTE response)
300 {
301  return SystemFunction008(challenge, hash, response);
302 }
303 
304 /******************************************************************************
305  * SystemFunction010 [ADVAPI32.@]
306  * SystemFunction011 [ADVAPI32.@]
307  *
308  * MD4 hashes 16 bytes of data
309  *
310  * PARAMS
311  * unknown [] seems to have no effect on the output
312  * data [I] pointer to data to hash (16 bytes)
313  * output [O] the md4 hash of the data (16 bytes)
314  *
315  * RETURNS
316  * Success: STATUS_SUCCESS
317  * Failure: STATUS_UNSUCCESSFUL
318  *
319  */
320 NTSTATUS
322 {
323  MD4_CTX ctx;
324 
325  MD4Init( &ctx );
326  MD4Update( &ctx, data, 0x10 );
327  MD4Final( &ctx );
328  memcpy( hash, ctx.digest, 0x10 );
329 
330  return STATUS_SUCCESS;
331 }
332 
333 /******************************************************************************
334  * SystemFunction012 [ADVAPI32.@]
335  * SystemFunction014 [ADVAPI32.@]
336  * SystemFunction016 [ADVAPI32.@]
337  * SystemFunction018 [ADVAPI32.@]
338  * SystemFunction020 [ADVAPI32.@]
339  * SystemFunction022 [ADVAPI32.@]
340  *
341  * Encrypts two DES blocks with two keys
342  *
343  * PARAMS
344  * data [I] data to encrypt (16 bytes)
345  * key [I] key data (two lots of 7 bytes)
346  * output [O] buffer to receive encrypted data (16 bytes)
347  *
348  * RETURNS
349  * Success: STATUS_SUCCESS
350  * Failure: STATUS_UNSUCCESSFUL if the input or output buffer is NULL
351  */
352 NTSTATUS
354 {
355  if (!in || !out)
356  return STATUS_UNSUCCESSFUL;
357 
358  CRYPT_DEShash(out, key, in);
359  CRYPT_DEShash(out+8, key+7, in+8);
360  return STATUS_SUCCESS;
361 }
362 
363 /******************************************************************************
364  * SystemFunction013 [ADVAPI32.@]
365  * SystemFunction015 [ADVAPI32.@]
366  * SystemFunction017 [ADVAPI32.@]
367  * SystemFunction019 [ADVAPI32.@]
368  * SystemFunction021 [ADVAPI32.@]
369  * SystemFunction023 [ADVAPI32.@]
370  *
371  * Decrypts two DES blocks with two keys
372  *
373  * PARAMS
374  * data [I] data to decrypt (16 bytes)
375  * key [I] key data (two lots of 7 bytes)
376  * output [O] buffer to receive decrypted data (16 bytes)
377  *
378  * RETURNS
379  * Success: STATUS_SUCCESS
380  * Failure: STATUS_UNSUCCESSFUL if the input or output buffer is NULL
381  */
382 NTSTATUS
384 {
385  if (!in || !out)
386  return STATUS_UNSUCCESSFUL;
388  CRYPT_DESunhash(out+8, key+7, in+8);
389  return STATUS_SUCCESS;
390 }
391 
392 /******************************************************************************
393  * SystemFunction024 [ADVAPI32.@]
394  *
395  * Encrypts two DES blocks with a 32 bit key...
396  *
397  * PARAMS
398  * data [I] data to encrypt (16 bytes)
399  * key [I] key data (4 bytes)
400  * output [O] buffer to receive encrypted data (16 bytes)
401  *
402  * RETURNS
403  * Success: STATUS_SUCCESS
404  */
405 NTSTATUS
407 {
408  BYTE deskey[0x10];
409 
410  memcpy(deskey, key, 4);
411  memcpy(deskey+4, key, 4);
412  memcpy(deskey+8, key, 4);
413  memcpy(deskey+12, key, 4);
414 
416  CRYPT_DEShash(out+8, deskey+7, in+8);
417 
418  return STATUS_SUCCESS;
419 }
420 
421 /******************************************************************************
422  * SystemFunction025 [ADVAPI32.@]
423  *
424  * Decrypts two DES blocks with a 32 bit key...
425  *
426  * PARAMS
427  * data [I] data to encrypt (16 bytes)
428  * key [I] key data (4 bytes)
429  * output [O] buffer to receive encrypted data (16 bytes)
430  *
431  * RETURNS
432  * Success: STATUS_SUCCESS
433  */
434 NTSTATUS
436 {
437  BYTE deskey[0x10];
438 
439  memcpy(deskey, key, 4);
440  memcpy(deskey+4, key, 4);
441  memcpy(deskey+8, key, 4);
442  memcpy(deskey+12, key, 4);
443 
445  CRYPT_DESunhash(out+8, deskey+7, in+8);
446 
447  return STATUS_SUCCESS;
448 }
449 
450 /**********************************************************************
451  * SystemFunction028 [ADVAPI32.@]
452  *
453  * Retrieves an encryption session key...
454  *
455  * PARAMS
456  * ContextHandle [I] RPC context handle
457  * SessionKey [O] buffer to receive the session key (16 bytes)
458  *
459  * RETURNS
460  * Success: STATUS_LOCAL_USER_SESSION_KEY
461  *
462  * @unimplemented
463  */
464 NTSTATUS
465 WINAPI
467  _In_ PVOID ContextHandle,
468  _Out_ LPBYTE SessionKey)
469 {
470  /* HACK: Always return the default key */
471  memcpy(SessionKey, DefaultSessionKey, sizeof(DefaultSessionKey));
473 
474 #if 0
475  //NDRCContextBinding();
476  //SystemFunction034()
478  return 28;
479 #endif
480 }
481 
482 
483 /**********************************************************************
484  *
485  * @unimplemented
486  */
487 INT
488 WINAPI
490 {
491  //I_RpcBindingIsClientLocal()
493  return 29;
494 }
495 
496 
497 /******************************************************************************
498  * SystemFunction030 (ADVAPI32.@)
499  *
500  * Tests if two blocks of 16 bytes are equal
501  *
502  * PARAMS
503  * b1,b2 [I] block of 16 bytes
504  *
505  * RETURNS
506  * TRUE if blocks are the same
507  * FALSE if blocks are different
508  */
509 BOOL
511 {
512  return !memcmp(b1, b2, 0x10);
513 }
514 
515 
516 /******************************************************************************
517  * SystemFunction032 [ADVAPI32.@]
518  *
519  * Encrypts a string data using ARC4
520  *
521  * PARAMS
522  * data [I/O] data to encrypt
523  * key [I] key data
524  *
525  * RETURNS
526  * Success: STATUS_SUCCESS
527  * Failure: STATUS_UNSUCCESSFUL
528  *
529  * NOTES
530  * see http://web.it.kth.se/~rom/ntsec.html#crypto-strongavail
531  */
532 NTSTATUS
534 {
535  RC4_CONTEXT a4i;
536 
537  rc4_init(&a4i, key->Buffer, key->Length);
538  rc4_crypt(&a4i, data->Buffer, data->Length);
539 
540  return STATUS_SUCCESS;
541 }
542 
543 
544 /**********************************************************************
545  *
546  * @unimplemented
547  */
548 INT
549 WINAPI
551 {
553  return 33;
554 }
555 
556 /**********************************************************************
557  *
558  * @unimplemented
559  */
560 INT
561 WINAPI
563 {
564  //RpcBindingToStringBindingW
565  //I_RpcMapWin32Status
566  //RpcStringBindingParseW
567  //RpcStringFreeW
569  return 34;
570 }
571 
572 
573 /******************************************************************************
574  * SystemFunction035 (ADVAPI32.@)
575  *
576  * Described here:
577 http://disc.server.com/discussion.cgi?disc=148775;article=942;title=Coding%2FASM%2FSystem
578  *
579  * NOTES
580  * Stub, always return TRUE.
581  */
583 {
584  //FIXME("%s: stub\n", debugstr_a(lpszDllFilePath));
585  return TRUE;
586 }
587 
588 /******************************************************************************
589  * SystemFunction036 (ADVAPI32.@)
590  *
591  * MSDN documents this function as RtlGenRandom and declares it in ntsecapi.h
592  *
593  * PARAMS
594  * pbBuffer [O] Pointer to memory to receive random bytes.
595  * dwLen [I] Number of random bytes to fetch.
596  *
597  * RETURNS
598  * Always TRUE in my tests
599  */
600 BOOLEAN
601 WINAPI
602 SystemFunction036(PVOID pbBuffer, ULONG dwLen)
603 {
606  // This function will output numbers based on the tick count. //
607  // It will NOT OUTPUT CRYPTOGRAPHIC-SAFE RANDOM NUMBERS !!! //
609 
610  DWORD dwSeed;
611  PBYTE pBuffer;
612  ULONG uPseudoRandom;
614  static ULONG uCounter = 17;
615 
616  if(!pbBuffer || !dwLen)
617  {
618  /* This function always returns TRUE, even if invalid parameters were passed. (verified under WinXP SP2) */
619  return TRUE;
620  }
621 
622  /* Get the first seed from the performance counter */
624  dwSeed = time.LowPart ^ time.HighPart ^ RtlUlongByteSwap(uCounter++);
625 
626  /* We will access the buffer bytewise */
627  pBuffer = (PBYTE)pbBuffer;
628 
629  do
630  {
631  /* Use the pseudo random number generator RtlRandom, which outputs a 4-byte value and a new seed */
632  uPseudoRandom = RtlRandom(&dwSeed);
633 
634  do
635  {
636  /* Get each byte from the pseudo random number and store it in the buffer */
637  *pBuffer = (BYTE)(uPseudoRandom >> 8 * (dwLen % 3) & 0xFF);
638  ++pBuffer;
639  } while(--dwLen % 3);
640  } while(dwLen);
641 
642  return TRUE;
643 }
644 
646 
647 static
648 NTSTATUS
650 {
651  UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\Device\\KsecDD");
656 
658  &DeviceName,
660  NULL,
661  NULL);
665  &IoStatusBlock,
668  if (!NT_SUCCESS(Status))
669  {
670  return Status;
671  }
672 
674  {
676  }
677 
678  return STATUS_SUCCESS;
679 }
680 
681 VOID
683 {
684  /* Check if we already opened a handle to ksecdd */
685  if (KsecDeviceHandle != NULL)
686  {
687  /* Close it */
690  }
691 }
692 
693 static
694 NTSTATUS
701 {
704 
705  /* Check if we already have a handle */
706  if (KsecDeviceHandle == NULL)
707  {
708  /* Try to open the device */
710  if (!NT_SUCCESS(Status))
711  {
712  //ERR("Failed to open handle to KsecDd driver!\n");
713  return Status;
714  }
715  }
716 
717  /* Call the driver */
719  NULL,
720  NULL,
721  NULL,
722  &IoStatusBlock,
724  InputBuffer,
726  OutputBuffer,
728 
729  return Status;
730 }
731 
732 /*
733  These functions have nearly identical prototypes to CryptProtectMemory and CryptUnprotectMemory,
734  in crypt32.dll.
735  */
736 
737 /******************************************************************************
738  * SystemFunction040 (ADVAPI32.@)
739  *
740  * MSDN documents this function as RtlEncryptMemory and declares it in ntsecapi.h.
741  *
742  * PARAMS
743  * memory [I/O] Pointer to memory to encrypt.
744  * length [I] Length of region to encrypt in bytes.
745  * flags [I] Control whether other processes are able to decrypt the memory.
746  * RTL_ENCRYPT_OPTION_SAME_PROCESS
747  * RTL_ENCRYPT_OPTION_CROSS_PROCESS
748  * RTL_ENCRYPT_OPTION_SAME_LOGON
749  *
750  * RETURNS
751  * Success: STATUS_SUCCESS
752  * Failure: NTSTATUS error code
753  *
754  * NOTES
755  * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
756  * If flags are specified when encrypting, the same flag value must be given
757  * when decrypting the memory.
758  */
759 NTSTATUS
760 WINAPI
763  _In_ ULONG MemoryLength,
764  _In_ ULONG OptionFlags)
765 {
767 
768  if (OptionFlags == RTL_ENCRYPT_OPTION_SAME_PROCESS)
769  {
771  }
772  else if (OptionFlags == RTL_ENCRYPT_OPTION_CROSS_PROCESS)
773  {
775  }
776  else if (OptionFlags == RTL_ENCRYPT_OPTION_SAME_LOGON)
777  {
779  }
780  else
781  {
783  }
784 
785  return KsecDeviceIoControl(IoControlCode, Memory, MemoryLength, Memory, MemoryLength);
786 }
787 
788 /******************************************************************************
789  * SystemFunction041 (ADVAPI32.@)
790  *
791  * MSDN documents this function as RtlDecryptMemory and declares it in ntsecapi.h.
792  *
793  * PARAMS
794  * memory [I/O] Pointer to memory to decrypt.
795  * length [I] Length of region to decrypt in bytes.
796  * flags [I] Control whether other processes are able to decrypt the memory.
797  * RTL_ENCRYPT_OPTION_SAME_PROCESS
798  * RTL_ENCRYPT_OPTION_CROSS_PROCESS
799  * RTL_ENCRYPT_OPTION_SAME_LOGON
800  *
801  * RETURNS
802  * Success: STATUS_SUCCESS
803  * Failure: NTSTATUS error code
804  *
805  * NOTES
806  * length must be a multiple of RTL_ENCRYPT_MEMORY_SIZE.
807  * If flags are specified when encrypting, the same flag value must be given
808  * when decrypting the memory.
809  */
810 NTSTATUS
811 WINAPI
814  _In_ ULONG MemoryLength,
815  _In_ ULONG OptionFlags)
816 {
818 
819  if (OptionFlags == RTL_ENCRYPT_OPTION_SAME_PROCESS)
820  {
822  }
823  else if (OptionFlags == RTL_ENCRYPT_OPTION_CROSS_PROCESS)
824  {
826  }
827  else if (OptionFlags == RTL_ENCRYPT_OPTION_SAME_LOGON)
828  {
830  }
831  else
832  {
834  }
835 
836  return KsecDeviceIoControl(IoControlCode, Memory, MemoryLength, Memory, MemoryLength);
837 }
838 
839 /* EOF */
NTSYSAPI ULONG NTAPI RtlRandom(_Inout_ PULONG Seed)
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
unsigned char digest[16]
Definition: util.c:86
#define TRUE
Definition: types.h:120
static UCHAR ULONG UCHAR ULONG UCHAR * output
Definition: bcrypt.c:29
#define CloseHandle
Definition: compat.h:406
_Inout_ PUSB_DEVICE_HANDLE DeviceHandle
Definition: hubbusif.h:121
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG IoControlCode
Definition: fltkernel.h:1383
static void deskey(const unsigned char *key, short edf, ulong32 *keyout)
Definition: des.c:1285
INT WINAPI SystemFunction033(INT a, INT b)
Definition: sysfunc.c:550
NTSTATUS WINAPI SystemFunction009(const BYTE *challenge, const BYTE *hash, LPBYTE response)
Definition: sysfunc.c:299
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
NTSTATUS WINAPI SystemFunction032(struct ustring *data, const struct ustring *key)
Definition: sysfunc.c:533
UINT ui
Definition: oleauto.h:49
LONG NTSTATUS
Definition: precomp.h:26
#define RTL_ENCRYPT_OPTION_CROSS_PROCESS
Definition: ksecdd.h:26
#define IOCTL_KSEC_DECRYPT_CROSS_PROCESS
Definition: ksecioctl.h:30
static ULONGLONG Memory
Definition: CcMapData_drv.c:35
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ ULONG _In_ ULONG OutputBufferLength
Definition: fltkernel.h:1374
#define IOCTL_KSEC_DECRYPT_SAME_PROCESS
Definition: ksecioctl.h:22
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
__u16 time
Definition: mkdosfs.c:366
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
WCHAR DeviceName[]
Definition: adapter.cpp:21
int32_t INT
Definition: typedefs.h:56
CHAR InputBuffer[80]
Definition: conmgr.c:33
#define FILE_SHARE_READ
Definition: compat.h:125
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
NTSTATUS WINAPI SystemFunction040(_Inout_ PVOID Memory, _In_ ULONG MemoryLength, _In_ ULONG OptionFlags)
Definition: sysfunc.c:761
VOID WINAPI MD4Init(MD4_CTX *ctx)
Definition: md4.c:45
NTSTATUS WINAPI SystemFunction003(const BYTE *key, LPBYTE output)
Definition: sysfunc.c:90
unsigned char * LPBYTE
Definition: typedefs.h:52
NTSTATUS WINAPI SystemFunction012(const BYTE *in, const BYTE *key, LPBYTE out)
Definition: sysfunc.c:353
unsigned int BOOL
Definition: ntddk_ex.h:94
#define FILE_READ_DATA
Definition: nt_native.h:628
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
HANDLE KsecDeviceHandle
Definition: sysfunc.c:645
static CRYPT_DATA_BLOB b1[]
Definition: msg.c:573
#define IOCTL_KSEC_ENCRYPT_SAME_LOGON
Definition: ksecioctl.h:34
#define IOCTL_KSEC_DECRYPT_SAME_LOGON
Definition: ksecioctl.h:38
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
PVOID pBuffer
#define STATUS_INVALID_PARAMETER_2
Definition: ntstatus.h:462
#define _Out_
Definition: no_sal2.h:323
NTSTATUS WINAPI SystemFunction001(const BYTE *data, const BYTE *key, LPBYTE output)
Definition: sysfunc.c:41
_Must_inspect_result_ __drv_aliasesMem _In_ PDEVICE_OBJECT _In_opt_ PVOID _In_ ULONG _Out_opt_ PVOID OutputBuffer
Definition: iofuncs.h:713
const char * LPCSTR
Definition: xmlstorage.h:183
void rc4_crypt(RC4_CONTEXT *a4i, unsigned char *inoutString, unsigned int length)
Definition: rc4.c:47
BOOLEAN WINAPI SystemFunction036(PVOID pbBuffer, ULONG dwLen)
Definition: sysfunc.c:602
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3951
static const unsigned char CRYPT_LMhash_Magic[8]
Definition: sysfunc.c:20
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
NTSTATUS WINAPI SystemFunction013(const BYTE *in, const BYTE *key, LPBYTE out)
Definition: sysfunc.c:383
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static NTSTATUS KsecOpenDevice()
Definition: sysfunc.c:649
NTSTATUS WINAPI SystemFunction007(const UNICODE_STRING *string, LPBYTE hash)
Definition: sysfunc.c:245
BOOL WINAPI SystemFunction035(LPCSTR lpszDllFilePath)
Definition: sysfunc.c:582
NTSTATUS WINAPI SystemFunction025(const BYTE *in, const BYTE *key, LPBYTE out)
Definition: sysfunc.c:435
#define WINAPI
Definition: msvc.h:6
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:417
#define _Inout_
Definition: no_sal2.h:244
VOID WINAPI MD4Final(MD4_CTX *ctx)
Definition: md4.c:113
Definition: id3.c:18
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define RTL_ENCRYPT_OPTION_SAME_PROCESS
Definition: ksecdd.h:25
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
NTSTATUS WINAPI SystemFunction004(const struct ustring *in, const struct ustring *key, struct ustring *out)
Definition: sysfunc.c:119
BOOL WINAPI QueryPerformanceCounter(OUT PLARGE_INTEGER lpPerformanceCount)
Definition: perfcnt.c:23
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
static const WCHAR L[]
Definition: oid.c:1250
static NTSTATUS KsecDeviceIoControl(ULONG IoControlCode, PVOID InputBuffer, SIZE_T InputBufferLength, PVOID OutputBuffer, SIZE_T OutputBufferLength)
Definition: sysfunc.c:695
NTSTATUS WINAPI SystemFunction028(_In_ PVOID ContextHandle, _Out_ LPBYTE SessionKey)
Definition: sysfunc.c:466
INT WINAPI SystemFunction029(INT a, INT b)
Definition: sysfunc.c:489
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define RTL_ENCRYPT_OPTION_SAME_LOGON
Definition: ksecdd.h:27
unsigned char BYTE
Definition: mem.h:68
unsigned char * CRYPT_DESunhash(unsigned char *dst, const unsigned char *key, const unsigned char *src) DECLSPEC_HIDDEN
Definition: crypt_des.c:299
#define SYNCHRONIZE
Definition: nt_native.h:61
#define RtlUlongByteSwap(_x)
Definition: compat.h:473
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ ULONG InputBufferLength
Definition: fltkernel.h:1372
Status
Definition: gdiplustypes.h:24
#define IOCTL_KSEC_ENCRYPT_SAME_PROCESS
Definition: ksecioctl.h:18
BOOL WINAPI SystemFunction030(LPCVOID b1, LPCVOID b2)
Definition: sysfunc.c:510
#define _In_
Definition: no_sal2.h:204
ULONG_PTR SIZE_T
Definition: typedefs.h:78
Definition: util.c:81
GLuint in
Definition: glext.h:9616
NTSTATUS WINAPI SystemFunction008(const BYTE *challenge, const BYTE *hash, LPBYTE response)
Definition: sysfunc.c:276
NTSTATUS WINAPI SystemFunction010(LPVOID unknown, const BYTE *data, LPBYTE hash)
Definition: sysfunc.c:321
unsigned char * CRYPT_DEShash(unsigned char *dst, const unsigned char *key, const unsigned char *src) DECLSPEC_HIDDEN
Definition: crypt_des.c:259
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
Definition: config.c:18
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
INT WINAPI SystemFunction034(INT a, INT b)
Definition: sysfunc.c:562
CONST void * LPCVOID
Definition: windef.h:191
NTSTATUS WINAPI SystemFunction002(const BYTE *data, const BYTE *key, LPBYTE output)
Definition: sysfunc.c:66
void rc4_init(RC4_CONTEXT *a4i, const unsigned char *key, unsigned int keyLen)
Definition: rc4.c:25
unsigned int ULONG
Definition: retypes.h:1
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:92
VOID WINAPI MD4Update(MD4_CTX *ctx, const unsigned char *buf, unsigned int len)
Definition: md4.c:59
static const unsigned char DefaultSessionKey[16]
Definition: sysfunc.c:22
static CRYPT_DATA_BLOB b2[]
Definition: msg.c:582
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
GLboolean GLboolean GLboolean GLboolean a
Definition: glext.h:6204
NTSTATUS WINAPI SystemFunction005(const struct ustring *in, const struct ustring *key, struct ustring *out)
Definition: sysfunc.c:182
NTSTATUS WINAPI SystemFunction024(const BYTE *in, const BYTE *key, LPBYTE out)
Definition: sysfunc.c:406
return STATUS_SUCCESS
Definition: btrfs.c:2938
Definition: _hash_fun.h:40
#define memset(x, y, z)
Definition: compat.h:39
VOID CloseKsecDdHandle(VOID)
Definition: sysfunc.c:682
BYTE * PBYTE
Definition: pedump.c:66
#define STATUS_UNKNOWN_REVISION
Definition: ntstatus.h:310
#define IOCTL_KSEC_ENCRYPT_CROSS_PROCESS
Definition: ksecioctl.h:26
Definition: path.c:41
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
NTSTATUS WINAPI SystemFunction041(_Inout_ PVOID Memory, _In_ ULONG MemoryLength, _In_ ULONG OptionFlags)
Definition: sysfunc.c:812
#define STATUS_LOCAL_USER_SESSION_KEY
Definition: ntstatus.h:120