util.c File Reference

#include "../precomp.h"
#include "wine/debug.h"

Include dependency graph for util.c:

Go to the source code of this file.

Macros
#define	NTLM_ALLOC_TAG   "NTLM"
#define	NTLM_ALLOC_TAG_SIZE   strlen(NTLM_ALLOC_TAG)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ntlm)
PVOID	NtlmAllocate (_In_ size_t Size, _In_ bool UsePrivateLsaHeap)
VOID	NtlmFree (_In_ PVOID Buffer, _In_ bool FromPrivateLsaHeap)
bool	NtlmUStrAlloc (_Inout_ PUNICODE_STRING Dst, _In_ UINT16 SizeInBytes, _In_ UINT16 InitLength)
VOID	NtlmUStrFree (_In_ PUNICODE_STRING String)
static bool	NtlmStructWriteStrW (_In_ PVOID DataStart, _In_ ULONG DataSize, _Out_ PWCHAR *DstDataWPtr, _In_ const WCHAR *SrcDataW, _In_ ULONG SrcDataLen, _Inout_ PBYTE *AbsoluteOffsetPtr, _In_ bool TerminateWith0)
	Helper to fill a WCHAR-String in a struct. The stringdata is appended to the struct. The function does not allocate memory.
bool	NtlmUStrWriteToStruct (_In_ PVOID DataStart, _In_ ULONG DataSize, _Out_ PUNICODE_STRING DstData, _In_ const PUNICODE_STRING SrcData, _Inout_ PBYTE *AbsoluteOffsetPtr, _In_ bool TerminateWith0)
bool	NtlmFixupAndValidateUStr (_Inout_ PUNICODE_STRING String, _In_ ULONG_PTR FixupOffset)
bool	NtlmFixupAStr (_Inout_ PSTRING String, _In_ ULONG_PTR FixupOffset)
NTSTATUS	NtlmAllocateClientBuffer (_In_ PLSA_CLIENT_REQUEST ClientRequest, _In_ ULONG BufferLength, _Inout_ PNTLM_CLIENT_BUFFER Buffer)
NTSTATUS	NtlmCopyToClientBuffer (_In_ PLSA_CLIENT_REQUEST ClientRequest, _In_ ULONG BufferLength, _Inout_ PNTLM_CLIENT_BUFFER Buffer)
VOID	NtlmFreeClientBuffer (_In_ PLSA_CLIENT_REQUEST ClientRequest, _In_ bool FreeClientBuffer, _Inout_ PNTLM_CLIENT_BUFFER Buffer)

Macro Definition Documentation

NTLM_ALLOC_TAG

#define NTLM_ALLOC_TAG   "NTLM"

Definition at line 14 of file util.c.

NTLM_ALLOC_TAG_SIZE

#define NTLM_ALLOC_TAG_SIZE   strlen(NTLM_ALLOC_TAG)

Definition at line 15 of file util.c.

Function Documentation

NtlmAllocate()

PVOID NtlmAllocate	(	_In_ size_t	Size,
		_In_ bool	UsePrivateLsaHeap
	)

Definition at line 18 of file util.c.

{
    PVOID buffer = NULL;
 
    if (Size == 0)
    {
        ERR("Allocating 0 bytes!\n");
        return NULL;
    }
 
    Size += NTLM_ALLOC_TAG_SIZE;
 
    switch (NtlmMode)
    {
        case NtlmLsaMode:
        {
            if (UsePrivateLsaHeap)
                buffer = LsaFunctions->AllocatePrivateHeap(Size);
            else
                buffer = LsaFunctions->AllocateLsaHeap(Size);
 
            if (buffer != NULL)
                RtlZeroMemory(buffer, Size);
            break;
        }
        case NtlmUserMode:
        {
            buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Size);
            break;
        }
        default:
        {
            ERR("NtlmState unknown!\n");
            break;
        }
    }
 
    memcpy(buffer, NTLM_ALLOC_TAG, NTLM_ALLOC_TAG_SIZE);
    buffer = (PBYTE)buffer + NTLM_ALLOC_TAG_SIZE;
 
    return buffer;
}

Referenced by NtlmAllocateClientBuffer(), and NtlmUStrAlloc().

NtlmAllocateClientBuffer()

NTSTATUS NtlmAllocateClientBuffer	(	_In_ PLSA_CLIENT_REQUEST	ClientRequest,
		_In_ ULONG	BufferLength,
		_Inout_ PNTLM_CLIENT_BUFFER	Buffer
	)

Definition at line 264 of file util.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (!Buffer)
        return STATUS_NO_MEMORY;
 
    Buffer->LocalBuffer = NtlmAllocate(BufferLength, false);
    if (!Buffer->LocalBuffer)
        return STATUS_NO_MEMORY;
 
    if ((HANDLE)ClientRequest == INVALID_HANDLE_VALUE)
    {
        Buffer->ClientBaseAddress = Buffer->LocalBuffer;
        //if (!ClientBaseAddress)
        //    return STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        Status = DispatchTable.AllocateClientBuffer(ClientRequest,
                                                    BufferLength,
                                                    &Buffer->ClientBaseAddress);
        if (!NT_SUCCESS(Status))
        {
            NtlmFree(Buffer->LocalBuffer, false);
            Buffer->LocalBuffer = NULL;
        }
        //FIXME: Maybe we have to free ClientBaseAddress if something
        //       goes wrong ...? I'm not sure about that ...
    }
    return Status;
}

Referenced by BuildLm20LogonProfileBuffer().

NtlmCopyToClientBuffer()

NTSTATUS NtlmCopyToClientBuffer	(	_In_ PLSA_CLIENT_REQUEST	ClientRequest,
		_In_ ULONG	BufferLength,
		_Inout_ PNTLM_CLIENT_BUFFER	Buffer
	)

Definition at line 301 of file util.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    if ((HANDLE)ClientRequest == INVALID_HANDLE_VALUE)
    {
        // If ClientRequest ist INVALID_HANDLE_VALUE
        // Buffer->LocalBuffer == Buffer->ClientBaseAddress
        if (Buffer->ClientBaseAddress != Buffer->LocalBuffer)
        {
            ERR("Buffer->ClientBaseAddress != Buffer->LocalBuffer (something must be wrong!)\n");
            return STATUS_INTERNAL_ERROR;
        }
    }
    else
    {
        if (!Buffer->ClientBaseAddress ||
            !Buffer->LocalBuffer)
        {
            ERR("Invalid Buffer - not allocated!\n");
            return STATUS_NO_MEMORY;
        }
        Status = DispatchTable.CopyToClientBuffer(ClientRequest,
                                                  BufferLength,
                                                  Buffer->ClientBaseAddress,
                                                  Buffer->LocalBuffer);
    }
    return Status;
}

Referenced by BuildLm20LogonProfileBuffer().

NtlmFixupAndValidateUStr()

bool NtlmFixupAndValidateUStr	(	_Inout_ PUNICODE_STRING	String,
		_In_ ULONG_PTR	FixupOffset
	)

Definition at line 223 of file util.c.

{
    NTSTATUS Status;
 
    if (String->Length)
    {
        String->Buffer = FIXUP_POINTER(String->Buffer, FixupOffset);
        String->MaximumLength = String->Length;
    }
    else
    {
        String->Buffer = NULL;
        String->MaximumLength = 0;
    }
 
    Status = RtlValidateUnicodeString(0, String);
    return NT_SUCCESS(Status);
}

Referenced by LsaApLogonUserEx2_Network().

NtlmFixupAStr()

bool NtlmFixupAStr	(	_Inout_ PSTRING	String,
		_In_ ULONG_PTR	FixupOffset
	)

Definition at line 245 of file util.c.

{
    if (String->Length)
    {
        String->Buffer = (PCHAR)FIXUP_POINTER(String->Buffer, FixupOffset);
        String->MaximumLength = String->Length;
    }
    else
    {
        String->Buffer = NULL;
        String->MaximumLength = 0;
    }
 
    return true;
}

Referenced by LsaApLogonUserEx2_Network().

NtlmFree()

VOID NtlmFree	(	_In_ PVOID	Buffer,
		_In_ bool	FromPrivateLsaHeap
	)

Definition at line 64 of file util.c.

{
    if (Buffer)
    {
        Buffer = (PBYTE)Buffer - NTLM_ALLOC_TAG_SIZE;
        ASSERT(memcmp(Buffer, NTLM_ALLOC_TAG, NTLM_ALLOC_TAG_SIZE) == 0);
        *(char*)Buffer = 'D';
 
        switch (NtlmMode)
        {
            case NtlmLsaMode:
            {
                if (FromPrivateLsaHeap)
                    LsaFunctions->FreePrivateHeap(Buffer);
                else
                    LsaFunctions->FreeLsaHeap(Buffer);
                break;
            }
            case NtlmUserMode:
            {
                HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, Buffer);
                break;
            }
            default:
            {
                ERR("NtlmState unknown!\n");
                break;
            }
        }
    }
    else
    {
        ERR("Trying to free NULL!\n");
    }
}

Referenced by NtlmAllocateClientBuffer(), NtlmFreeClientBuffer(), and NtlmUStrFree().

NtlmFreeClientBuffer()

VOID NtlmFreeClientBuffer	(	_In_ PLSA_CLIENT_REQUEST	ClientRequest,
		_In_ bool	FreeClientBuffer,
		_Inout_ PNTLM_CLIENT_BUFFER	Buffer
	)

Definition at line 335 of file util.c.

{
    if (!Buffer->ClientBaseAddress)
        return;
 
    if ((HANDLE)ClientRequest == INVALID_HANDLE_VALUE)
    {
        if (Buffer->ClientBaseAddress != Buffer->LocalBuffer)
        {
            ERR("Buffer->ClientBaseAddress != Buffer->LocalBuffer (something must be wrong!)\n");
            return;
        }
        // LocalBuffer and ClientBaseAddress is the same
        // so we have only to free it if FreeClientBuffer is TRUE.
        Buffer->LocalBuffer = NULL;
        if (FreeClientBuffer)
        {
            NtlmFree(Buffer->ClientBaseAddress, false);
            Buffer->ClientBaseAddress = NULL;
        }
    }
    else
    {
        NtlmFree(Buffer->LocalBuffer, false);
        Buffer->LocalBuffer = NULL;
        if (FreeClientBuffer)
            DispatchTable.FreeClientBuffer(ClientRequest, Buffer->ClientBaseAddress);
        Buffer->ClientBaseAddress = NULL;
    }
}

Referenced by BuildLm20LogonProfileBuffer().

NtlmStructWriteStrW()

static bool NtlmStructWriteStrW ( _In_ PVOID  DataStart, _In_ ULONG  DataSize, _Out_ PWCHAR *  DstDataWPtr, _In_ const WCHAR *  SrcDataW, _In_ ULONG  SrcDataLen, _Inout_ PBYTE *  AbsoluteOffsetPtr, _In_ bool  TerminateWith0  )

static

Helper to fill a WCHAR-String in a struct. The stringdata is appended to the struct. The function does not allocate memory.

Parameters

[in]	DataStart	Start address of the struct
[in]	DataSize	Size of allocated memory (including payload)
[out]	DstDataWPtr	Pointer to the WCHAR* datafield. The address of the data will be written to it.
[in]	SrcDataW	Data to write/append at pOffset (payload). pOffset will be increased after writing data.
[in]	SrcDataLen	SrcDataLen is the length in bytes without terminator. if 0 it will be autodetected by assuming a 0-terminating string.
[in,out]	AbsoluteOffsetPtr	Current absolute offset. Will be increased by data length.
[in]	TerminateWith0	Whether to terminate the string with a NULL-char.

Returns

FALSE if something went wrong

Definition at line 157 of file util.c.

{
    ULONG SrcDataMaxLen;
 
    if (SrcDataLen == 0)
        SrcDataLen = wcslen(SrcDataW) * sizeof(WCHAR);
 
    SrcDataMaxLen = SrcDataLen;
    if (TerminateWith0)
        SrcDataMaxLen += sizeof(WCHAR);
 
    if (*AbsoluteOffsetPtr < (PBYTE)DataStart)
    {
        ERR("Invalid offset\n");
        return false;
    }
 
    if (*AbsoluteOffsetPtr + SrcDataMaxLen > (PBYTE)DataStart + DataSize)
    {
        ERR("Out of bounds!\n");
        return false;
    }
 
    memcpy(*AbsoluteOffsetPtr, SrcDataW, SrcDataLen);
    *DstDataWPtr = (WCHAR*)*AbsoluteOffsetPtr;
    if (TerminateWith0)
        (*DstDataWPtr)[SrcDataLen / sizeof(WCHAR)] = 0;
    *AbsoluteOffsetPtr += SrcDataMaxLen;
 
    return true;
}

Referenced by NtlmUStrWriteToStruct().

NtlmUStrAlloc()

bool NtlmUStrAlloc	(	_Inout_ PUNICODE_STRING	Dst,
		_In_ UINT16	SizeInBytes,
		_In_ UINT16	InitLength
	)

Definition at line 103 of file util.c.

{
    Dst->Length = InitLength;
    Dst->MaximumLength = SizeInBytes;
    Dst->Buffer = NtlmAllocate(SizeInBytes, false);
    return (Dst->Buffer != NULL);
}

Referenced by BuildLm20LogonProfileBuffer().

NtlmUStrFree()

VOID NtlmUStrFree

(

_In_ PUNICODE_STRING

String

)

Definition at line 115 of file util.c.

{
    if (String == NULL || String->Buffer == NULL || String->MaximumLength == 0)
        return;
 
    NtlmFree(String->Buffer, false);
    String->Buffer = NULL;
    String->MaximumLength = 0;
}

Referenced by BuildLm20LogonProfileBuffer().

NtlmUStrWriteToStruct()

bool NtlmUStrWriteToStruct	(	_In_ PVOID	DataStart,
		_In_ ULONG	DataSize,
		_Out_ PUNICODE_STRING	DstData,
		_In_ const PUNICODE_STRING	SrcData,
		_Inout_ PBYTE *	AbsoluteOffsetPtr,
		_In_ bool	TerminateWith0
	)

Definition at line 197 of file util.c.

{
    if (!NtlmStructWriteStrW(DataStart,
                             DataSize,
                             &DstData->Buffer,
                             SrcData->Buffer,
                             SrcData->Length,
                             AbsoluteOffsetPtr,
                             TerminateWith0))
        return false;
 
    DstData->Length = SrcData->Length;
    DstData->MaximumLength = SrcData->Length;
    if (TerminateWith0)
        SrcData->MaximumLength += sizeof(WCHAR);
 
    return true;
}

Referenced by BuildLm20LogonProfileBuffer().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ntlm

)