1813 lines
47 KiB
C++
1813 lines
47 KiB
C++
//+-----------------------------------------------------------------------
|
||
//
|
||
// Microsoft Windows
|
||
//
|
||
// Copyright (c) Microsoft Corporation 2000
|
||
//
|
||
// File: ntdigestutil.cxx
|
||
//
|
||
// Contents: Utility functions for NtDigest package:
|
||
// UnicodeStringDuplicate
|
||
// SidDuplicate
|
||
// DigestAllocateMemory
|
||
// DigestFreeMemory
|
||
//
|
||
//
|
||
// History: KDamour 15Mar00 Stolen from NTLM ntlmutil.cxx
|
||
//
|
||
//------------------------------------------------------------------------
|
||
#include "global.h"
|
||
|
||
#include <stdio.h>
|
||
#include <malloc.h>
|
||
#include <des.h>
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: UnicodeStringDuplicate
|
||
//
|
||
// Synopsis: Duplicates a UNICODE_STRING. If the source string buffer is
|
||
// NULL the destionation will be too. Assumes Destination has
|
||
// no string info (called ClearUnicodeString)
|
||
//
|
||
// Arguments: DestinationString - Receives a copy of the source string
|
||
// SourceString - String to copy
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory with DigestAllocateMemory
|
||
//
|
||
// Notes: will add a NULL character to resulting UNICODE_STRING
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringDuplicate(
|
||
OUT PUNICODE_STRING DestinationString,
|
||
IN OPTIONAL PUNICODE_STRING SourceString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest:Entering DuplicateUnicodeString\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
ASSERT(!DestinationString->Buffer); // catch any memory leaks
|
||
|
||
DestinationString->Buffer = NULL;
|
||
DestinationString->Length = 0;
|
||
DestinationString->MaximumLength = 0;
|
||
|
||
if ((ARGUMENT_PRESENT(SourceString)) &&
|
||
(SourceString->Buffer != NULL))
|
||
{
|
||
DestinationString->Buffer = (LPWSTR) DigestAllocateMemory(SourceString->Length + sizeof(WCHAR));
|
||
if (DestinationString->Buffer != NULL)
|
||
{
|
||
|
||
DestinationString->Length = SourceString->Length;
|
||
DestinationString->MaximumLength = SourceString->Length + sizeof(WCHAR);
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
SourceString->Buffer,
|
||
SourceString->Length
|
||
);
|
||
|
||
DestinationString->Buffer[SourceString->Length/sizeof(WCHAR)] = L'\0';
|
||
}
|
||
else
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR, "NTDigest: UnicodeStringDuplicate, Allocate returns NULL\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving UnicodeStringDuplicate\n"));
|
||
return(Status);
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: UnicodeStringCopy
|
||
//
|
||
// Synopsis: Copies a UNICODE_STRING. If the source string buffer is
|
||
// NULL the destionation will be too. If there is enough room
|
||
// in the destination, no new memory will be allocated
|
||
//
|
||
// Arguments: DestinationString - Receives a copy of the source string
|
||
// SourceString - String to copy
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: no allocation of memory
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringCopy(
|
||
OUT PUNICODE_STRING DestinationString,
|
||
IN OPTIONAL PUNICODE_STRING SourceString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest: Entering StringCopy\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
// DestinationString->Buffer = NULL;
|
||
// DestinationString->Length = 0;
|
||
// DestinationString->MaximumLength = 0;
|
||
|
||
if ((ARGUMENT_PRESENT(SourceString)) &&
|
||
(SourceString->Buffer != NULL) &&
|
||
(SourceString->Length))
|
||
{
|
||
|
||
if ((DestinationString->Buffer != NULL) &&
|
||
(DestinationString->MaximumLength >= (SourceString->Length + sizeof(WCHAR))))
|
||
{
|
||
|
||
DestinationString->Length = SourceString->Length;
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
SourceString->Buffer,
|
||
SourceString->Length
|
||
);
|
||
|
||
DestinationString->Buffer[SourceString->Length/sizeof(WCHAR)] = L'\0';
|
||
}
|
||
else
|
||
{
|
||
Status = STATUS_BUFFER_TOO_SMALL;
|
||
DestinationString->Length = 0;
|
||
DebugLog((DEB_ERROR, "UnicodeStringCopy: DestinationString not enough space\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
else
|
||
{ // Indicate that there is no content in this string
|
||
DestinationString->Length = 0;
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringDuplicate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: UnicodeDuplicatePassword
|
||
//
|
||
// Synopsis: Duplicates a UNICODE_STRING. If the source string buffer is
|
||
// NULL the destionation will be too. The MaximumLength contains
|
||
// room for encryption padding data.
|
||
//
|
||
// Effects: allocates memory with LsaFunctions.AllocatePrivateHeap
|
||
//
|
||
// Arguments: DestinationString - Receives a copy of the source string
|
||
// SourceString - String to copy
|
||
//
|
||
// Requires:
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringDuplicatePassword(
|
||
OUT PUNICODE_STRING DestinationString,
|
||
IN OPTIONAL PUNICODE_STRING SourceString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "Entering UnicodeDuplicatePassword\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
ASSERT(DestinationString);
|
||
ASSERT(!DestinationString->Buffer); // catch any memory leaks
|
||
|
||
DestinationString->Buffer = NULL;
|
||
DestinationString->Length =
|
||
DestinationString->MaximumLength =
|
||
0;
|
||
|
||
if ((ARGUMENT_PRESENT(SourceString)) &&
|
||
(SourceString->Buffer != NULL))
|
||
{
|
||
USHORT PaddingLength;
|
||
|
||
PaddingLength = DESX_BLOCKLEN - (SourceString->Length % DESX_BLOCKLEN);
|
||
|
||
if( PaddingLength == DESX_BLOCKLEN )
|
||
{
|
||
PaddingLength = 0;
|
||
}
|
||
|
||
DestinationString->Buffer = (LPWSTR) DigestAllocateMemory(
|
||
SourceString->Length +
|
||
PaddingLength
|
||
);
|
||
|
||
if (DestinationString->Buffer != NULL)
|
||
{
|
||
|
||
DestinationString->Length = SourceString->Length;
|
||
DestinationString->MaximumLength = SourceString->Length + PaddingLength;
|
||
|
||
if( DestinationString->MaximumLength == SourceString->MaximumLength )
|
||
{
|
||
//
|
||
// duplicating an already padded buffer -- pickup the original
|
||
// pad.
|
||
//
|
||
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
SourceString->Buffer,
|
||
SourceString->MaximumLength
|
||
);
|
||
} else {
|
||
|
||
//
|
||
// duplicating an unpadded buffer -- pickup only the string
|
||
// and fill the rest with the boot time pad.
|
||
//
|
||
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
SourceString->Buffer,
|
||
SourceString->Length
|
||
);
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
Status = STATUS_NO_MEMORY;
|
||
DebugLog((DEB_ERROR, "UnicodeDuplicatePassword, DigestAllocateMemory returns NULL\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "Entering UnicodeDuplicatePassword\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: UnicodeStringAllocate
|
||
//
|
||
// Synopsis: Allocates cb wide chars to STRING Buffer
|
||
//
|
||
// Arguments: pString - pointer to String to allocate memory to
|
||
//
|
||
// Returns: STATUS_SUCCESS - Normal completion
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory and sets STRING sizes
|
||
//
|
||
// Notes: Must call StringFree() to release memory
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringAllocate(
|
||
IN PUNICODE_STRING pString,
|
||
IN USHORT cNumWChars
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "Entering UnicodeStringAllocate\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
USHORT cb = 0;
|
||
|
||
ASSERT(pString);
|
||
ASSERT(!pString->Buffer);
|
||
|
||
cb = cNumWChars + 1; // Add in extra room for the terminating NULL
|
||
|
||
cb = cb * sizeof(WCHAR); // now convert to wide characters
|
||
|
||
|
||
if (ARGUMENT_PRESENT(pString))
|
||
{
|
||
pString->Length = 0;
|
||
|
||
pString->Buffer = (PWSTR)DigestAllocateMemory((ULONG)(cb));
|
||
if (pString->Buffer)
|
||
{
|
||
pString->MaximumLength = cb; // this value is in terms of bytes not WCHAR count
|
||
}
|
||
else
|
||
{
|
||
pString->MaximumLength = 0;
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Status = STATUS_INVALID_PARAMETER;
|
||
goto CleanUp;
|
||
}
|
||
|
||
CleanUp:
|
||
// DebugLog((DEB_TRACE, "Leaving UnicodeStringAllocate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: UnicodeStringClear
|
||
//
|
||
// Synopsis: Clears a UnicodeString and releases the memory
|
||
//
|
||
// Arguments: pString - pointer to UnicodeString to clear
|
||
//
|
||
// Returns: SEC_E_OK - released memory succeeded
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: de-allocates memory with LsaFunctions.AllocateLsaHeap
|
||
//
|
||
// Notes:
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringFree(
|
||
OUT PUNICODE_STRING pString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest:Entering UnicodeStringClear\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
if (ARGUMENT_PRESENT(pString) &&
|
||
(pString->Buffer != NULL))
|
||
{
|
||
DigestFreeMemory(pString->Buffer);
|
||
pString->Length = 0;
|
||
pString->MaximumLength = 0;
|
||
pString->Buffer = NULL;
|
||
}
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving UnicodeStringClear\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringVerify
|
||
//
|
||
// Synopsis: If STRING length non-zero, Buffer exist
|
||
//
|
||
// Arguments: pString - pointer to String to check
|
||
//
|
||
// Returns: STATUS_SUCCESS - released memory succeeded
|
||
// STATUS_INVALID_PARAMETER - String bad format
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects:
|
||
//
|
||
// Notes: If Strings are created properly, this should never fail
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringVerify(
|
||
OUT PSTRING pString
|
||
)
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
if (!pString)
|
||
{
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
// If there is a length, buffer must exist
|
||
// MaxSize can not be smaller than string length
|
||
if (pString->Length &&
|
||
(!pString->Buffer ||
|
||
(pString->MaximumLength < pString->Length)))
|
||
{
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringDuplicate
|
||
//
|
||
// Synopsis: Duplicates a STRING. If the source string buffer is
|
||
// NULL the destionation will be too.
|
||
//
|
||
// Arguments: DestinationString - Receives a copy of the source string
|
||
// SourceString - String to copy
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory with LsaFunctions.AllocateLsaHeap
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringDuplicate(
|
||
OUT PSTRING DestinationString,
|
||
IN OPTIONAL PSTRING SourceString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest: Entering StringDuplicate\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
ASSERT(DestinationString);
|
||
ASSERT(!DestinationString->Buffer); // catch any memory leaks
|
||
|
||
DestinationString->Buffer = NULL;
|
||
DestinationString->Length = 0;
|
||
DestinationString->MaximumLength = 0;
|
||
|
||
if ((ARGUMENT_PRESENT(SourceString)) &&
|
||
(SourceString->Buffer != NULL))
|
||
{
|
||
DestinationString->Buffer = (LPSTR) DigestAllocateMemory(
|
||
SourceString->Length + sizeof(CHAR));
|
||
if (DestinationString->Buffer != NULL)
|
||
{
|
||
|
||
DestinationString->Length = SourceString->Length;
|
||
DestinationString->MaximumLength = SourceString->Length + sizeof(CHAR);
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
SourceString->Buffer,
|
||
SourceString->Length
|
||
);
|
||
|
||
DestinationString->Buffer[SourceString->Length/sizeof(CHAR)] = '\0';
|
||
}
|
||
else
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR, "NTDigest: StringDuplicate, DigestAllocateMemory returns NULL\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringDuplicate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringCopy
|
||
//
|
||
// Synopsis: Copies a STRING. If the source string buffer is
|
||
// NULL the destionation will be too. If there is enough room
|
||
// in the destination, no new memory will be allocated
|
||
//
|
||
// Arguments: DestinationString - Receives a copy of the source string
|
||
// SourceString - String to copy
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: no allocation of memory
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringCopy(
|
||
OUT PSTRING DestinationString,
|
||
IN OPTIONAL PSTRING SourceString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest: Entering StringCopy\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
// DestinationString->Buffer = NULL;
|
||
// DestinationString->Length = 0;
|
||
// DestinationString->MaximumLength = 0;
|
||
|
||
if ((ARGUMENT_PRESENT(SourceString)) &&
|
||
(SourceString->Buffer != NULL) &&
|
||
(SourceString->Length))
|
||
{
|
||
|
||
if ((DestinationString->Buffer != NULL) &&
|
||
(DestinationString->MaximumLength >= (SourceString->Length + sizeof(CHAR))))
|
||
{
|
||
|
||
DestinationString->Length = SourceString->Length;
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
SourceString->Buffer,
|
||
SourceString->Length
|
||
);
|
||
|
||
DestinationString->Buffer[SourceString->Length/sizeof(CHAR)] = '\0';
|
||
}
|
||
else
|
||
{
|
||
Status = STATUS_BUFFER_TOO_SMALL;
|
||
DestinationString->Length = 0;
|
||
DebugLog((DEB_ERROR, "StringCopy: DestinationString not enough space\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
else
|
||
{ // Indicate that there is no content in this string
|
||
DestinationString->Length = 0;
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringDuplicate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringReference
|
||
//
|
||
// Synopsis: Reference the source string to the destination. No memory allocated
|
||
//
|
||
// Arguments: DestinationString - Receives a reference of the source string
|
||
// SourceString - String to reference
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: no allocation of memory
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringReference(
|
||
OUT PSTRING pDestinationString,
|
||
IN PSTRING pSourceString
|
||
)
|
||
{
|
||
if (!pDestinationString || !pSourceString)
|
||
{
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
// This will only create a reference - no string buffer memory actually copied
|
||
memcpy(pDestinationString, pSourceString, sizeof(STRING));
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringCharDuplicate
|
||
//
|
||
// Synopsis: Duplicates a NULL terminated char. If the source string buffer is
|
||
// NULL the destionation will be too.
|
||
//
|
||
// Arguments: Destination - Receives a copy of the source NULL Term char *
|
||
// czSource - String to copy
|
||
// uCnt - number of characters to copy over (0 if copy until NULL)
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory with LsaFunctions.AllocateLsaHeap
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringCharDuplicate(
|
||
OUT PSTRING DestinationString,
|
||
IN OPTIONAL char *czSource,
|
||
IN OPTIONAL USHORT uCnt
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest: Entering StringCharDuplicate\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
USHORT cbSourceCz = 0;
|
||
|
||
//ASSERT(DestinationString);
|
||
//ASSERT(!DestinationString->Buffer); // catch any memory leaks
|
||
|
||
DestinationString->Buffer = NULL;
|
||
DestinationString->Length = 0;
|
||
DestinationString->MaximumLength = 0;
|
||
|
||
// If uCnt specified then use that as max length, otherwise locate NULL terminator
|
||
if (uCnt)
|
||
{
|
||
cbSourceCz = uCnt;
|
||
}
|
||
else
|
||
{
|
||
cbSourceCz = strlen(czSource);
|
||
}
|
||
|
||
if ((ARGUMENT_PRESENT(czSource)) &&
|
||
(cbSourceCz != 0))
|
||
{
|
||
DestinationString->Buffer = (LPSTR) DigestAllocateMemory(cbSourceCz + sizeof(CHAR));
|
||
if (DestinationString->Buffer != NULL)
|
||
{
|
||
|
||
DestinationString->Length = cbSourceCz;
|
||
DestinationString->MaximumLength = cbSourceCz + sizeof(CHAR);
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
czSource,
|
||
cbSourceCz
|
||
);
|
||
// Since AllocateMemory zeroes out buffer, already NULL terminated
|
||
}
|
||
else
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR, "NTDigest: StringCharDuplicate, DigestAllocateMemory returns NULL\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringCharDuplicate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringCharDuplicate
|
||
//
|
||
// Synopsis: Duplicates a NULL terminated char. If the source string buffer is
|
||
// NULL the destionation will be too.
|
||
//
|
||
// Arguments: Destination - Receives a copy of the source NULL Term char *
|
||
// czSource - String to copy
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory with LsaFunctions.AllocateLsaHeap
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringWCharDuplicate(
|
||
OUT PUNICODE_STRING DestinationString,
|
||
IN OPTIONAL WCHAR *szSource
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest: Entering StringCharDuplicate\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
USHORT cbSourceSz = 0;
|
||
|
||
ASSERT(DestinationString);
|
||
ASSERT(!DestinationString->Buffer); // catch any memory leaks
|
||
|
||
DestinationString->Buffer = NULL;
|
||
DestinationString->Length = 0;
|
||
DestinationString->MaximumLength = 0;
|
||
|
||
if ((ARGUMENT_PRESENT(szSource)) &&
|
||
((cbSourceSz = (USHORT)wcslen(szSource)) != 0))
|
||
{
|
||
|
||
DestinationString->Buffer = (PWSTR) DigestAllocateMemory((cbSourceSz * sizeof(WCHAR)) + sizeof(WCHAR));
|
||
if (DestinationString->Buffer != NULL)
|
||
{
|
||
|
||
DestinationString->Length = (cbSourceSz * sizeof(WCHAR));
|
||
DestinationString->MaximumLength = ((cbSourceSz * sizeof(WCHAR)) + sizeof(WCHAR)); // Account for NULL WCHAR at end
|
||
RtlCopyMemory(
|
||
DestinationString->Buffer,
|
||
szSource,
|
||
(cbSourceSz * sizeof(WCHAR))
|
||
);
|
||
|
||
DestinationString->Buffer[cbSourceSz] = '\0';
|
||
}
|
||
else
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR, "NTDigest: StringCharDuplicate, DigestAllocateMemory returns NULL\n"));
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringCharDuplicate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: UnicodeStringReference
|
||
//
|
||
// Synopsis: Reference the source unicode_string to the destination. No memory allocated
|
||
//
|
||
// Arguments: DestinationString - Receives a reference of the source string
|
||
// SourceString - String to reference
|
||
//
|
||
// Returns: SEC_E_OK - the copy succeeded
|
||
// SEC_E_INSUFFICIENT_MEMORY - the call to allocate
|
||
// memory failed.
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: no allocation of memory
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
UnicodeStringReference(
|
||
OUT PUNICODE_STRING pDestinationString,
|
||
IN PUNICODE_STRING pSourceString
|
||
)
|
||
{
|
||
if (!pDestinationString || !pSourceString)
|
||
{
|
||
return STATUS_INVALID_PARAMETER;
|
||
}
|
||
|
||
// This will only create a reference - no string buffer memory actually copied
|
||
memcpy(pDestinationString, pSourceString, sizeof(UNICODE_STRING));
|
||
|
||
return STATUS_SUCCESS;
|
||
}
|
||
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: DecodeUnicodeString
|
||
//
|
||
// Synopsis: Convert an encoded string into Unicode
|
||
//
|
||
// Arguments: pstrSource - pointer to String with encoded input
|
||
//
|
||
// pustrDestination - pointer to a destination Unicode string
|
||
//
|
||
// Returns: STATUS_SUCCESS - Normal completion
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory and sets UNICODE_STRING sizes
|
||
//
|
||
// Notes: Must call UnicodeStringFree() to release memory
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
DecodeUnicodeString(
|
||
IN PSTRING pstrSource,
|
||
IN UINT CodePage,
|
||
OUT PUNICODE_STRING pustrDestination
|
||
)
|
||
{
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
int cNumWChars = 0; // number of wide characters
|
||
int cb = 0; // number of bytes to allocate
|
||
int iRC = 0; // return code
|
||
DWORD dwError = 0;
|
||
|
||
// Handle case if there is no characters to convert
|
||
if (!pstrSource->Length)
|
||
{
|
||
pustrDestination->Length = 0;
|
||
pustrDestination->MaximumLength = 0;
|
||
pustrDestination->Buffer = NULL;
|
||
goto CleanUp;
|
||
}
|
||
|
||
// Determine number of characters needed in unicode string
|
||
cNumWChars = MultiByteToWideChar(CodePage,
|
||
0,
|
||
pstrSource->Buffer,
|
||
pstrSource->Length,
|
||
NULL,
|
||
0);
|
||
if (cNumWChars <= 0)
|
||
{
|
||
Status = E_FAIL;
|
||
dwError = GetLastError();
|
||
DebugLog((DEB_ERROR, "DecodeUnicodeString: failed to determine wchar count error 0x%x\n", dwError));
|
||
goto CleanUp;
|
||
}
|
||
|
||
Status = UnicodeStringAllocate(pustrDestination, (USHORT)cNumWChars);
|
||
if (!NT_SUCCESS(Status))
|
||
{
|
||
DebugLog((DEB_ERROR, "DecodeUnicodeString: Failed Unicode allocation\n"));
|
||
goto CleanUp;
|
||
}
|
||
|
||
// We now have the space allocated so convert encoded unicode
|
||
iRC = MultiByteToWideChar(CodePage,
|
||
0,
|
||
pstrSource->Buffer,
|
||
pstrSource->Length,
|
||
pustrDestination->Buffer,
|
||
cNumWChars);
|
||
if (iRC == 0)
|
||
{
|
||
UnicodeStringFree(pustrDestination); // Free up allocation on error
|
||
Status = E_FAIL;
|
||
dwError = GetLastError();
|
||
DebugLog((DEB_ERROR, "DecodeUnicodeString: failed to decode source string error 0x%x\n", dwError));
|
||
goto CleanUp;
|
||
}
|
||
|
||
// decoding successful set size of unicode string
|
||
|
||
pustrDestination->Length = (USHORT)(iRC * sizeof(WCHAR));
|
||
|
||
//DebugLog((DEB_TRACE, "DecodeUnicodeString: string (%Z) is unicode (%wZ)\n", pstrSource, pustrDestination));
|
||
//DebugLog((DEB_TRACE, "DecodeUnicodeString: unicode length %d maxlength %d\n",
|
||
//pustrDestination->Length, pustrDestination->MaximumLength));
|
||
|
||
CleanUp:
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: EncodeUnicodeString
|
||
//
|
||
// Synopsis: Encode a Unicode string into a charset string
|
||
//
|
||
// Arguments: pustrSource - pointer to Unicode_String with input
|
||
//
|
||
// pstrDestination - pointer to a destination encoded string
|
||
//
|
||
// pfUsedDefaultChar - pointer to BOOL if default character had to be used since
|
||
// the Source contains characters outside the character set specified
|
||
//
|
||
// Returns: STATUS_SUCCESS - Normal completion
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory and sets STRING sizes
|
||
//
|
||
// Notes: Must call StringFree() to release memory
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
EncodeUnicodeString(
|
||
IN PUNICODE_STRING pustrSource,
|
||
IN UINT CodePage,
|
||
OUT PSTRING pstrDestination,
|
||
IN OUT PBOOL pfUsedDefaultChar
|
||
)
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
int cNumChars = 0; // number of wide characters
|
||
int iRC = 0; // return code
|
||
DWORD dwError = 0;
|
||
PBOOL pfUsedDef = NULL;
|
||
DWORD dwFlags = 0;
|
||
|
||
// Handle case if there is no characters to convert
|
||
if (!pustrSource->Length)
|
||
{
|
||
pstrDestination->Length = 0;
|
||
pstrDestination->MaximumLength = 0;
|
||
pstrDestination->Buffer = NULL;
|
||
goto CleanUp;
|
||
}
|
||
|
||
// If UTF-8 then do not allow default char mapping (ref MSDN)
|
||
if (CodePage != CP_UTF8)
|
||
{
|
||
pfUsedDef = pfUsedDefaultChar;
|
||
dwFlags = WC_NO_BEST_FIT_CHARS;
|
||
}
|
||
|
||
// Determine number of characters needed in unicode string
|
||
cNumChars = WideCharToMultiByte(CodePage,
|
||
dwFlags,
|
||
pustrSource->Buffer,
|
||
(pustrSource->Length / sizeof(WCHAR)),
|
||
NULL,
|
||
0,
|
||
NULL,
|
||
NULL);
|
||
if (cNumChars <= 0)
|
||
{
|
||
Status = E_FAIL;
|
||
dwError = GetLastError();
|
||
DebugLog((DEB_ERROR, "EncodeUnicodeString: failed to determine char count error 0x%x\n", dwError));
|
||
goto CleanUp;
|
||
}
|
||
|
||
Status = StringAllocate(pstrDestination, (USHORT)cNumChars);
|
||
if (!NT_SUCCESS(Status))
|
||
{
|
||
DebugLog((DEB_ERROR, "EncodeUnicodeString: Failed String allocation\n"));
|
||
goto CleanUp;
|
||
}
|
||
|
||
// We now have the space allocated so convert to encoded unicode
|
||
iRC = WideCharToMultiByte(CodePage,
|
||
dwFlags,
|
||
pustrSource->Buffer,
|
||
(pustrSource->Length / sizeof(WCHAR)),
|
||
pstrDestination->Buffer,
|
||
cNumChars,
|
||
NULL,
|
||
pfUsedDef);
|
||
if (iRC == 0)
|
||
{
|
||
Status = E_FAIL;
|
||
dwError = GetLastError();
|
||
DebugLog((DEB_ERROR, "EncodeUnicodeString: failed to decode source string error 0x%x\n", dwError));
|
||
StringFree(pstrDestination); // Free up allocation on error
|
||
goto CleanUp;
|
||
}
|
||
|
||
// decoding successful set size of unicode string
|
||
|
||
pstrDestination->Length = (USHORT)iRC;
|
||
|
||
CleanUp:
|
||
|
||
return Status;
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringFree
|
||
//
|
||
// Synopsis: Clears a String and releases the memory
|
||
//
|
||
// Arguments: pString - pointer to String to clear
|
||
//
|
||
// Returns: SEC_E_OK - released memory succeeded
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: de-allocates memory with LsaFunctions.AllocateLsaHeap
|
||
//
|
||
// Notes:
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringFree(
|
||
IN PSTRING pString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest:Entering StringFree\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
if (ARGUMENT_PRESENT(pString) &&
|
||
(pString->Buffer != NULL))
|
||
{
|
||
DigestFreeMemory(pString->Buffer);
|
||
pString->Length = 0;
|
||
pString->MaximumLength = 0;
|
||
pString->Buffer = NULL;
|
||
}
|
||
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringFree\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: StringAllocate
|
||
//
|
||
// Synopsis: Allocates cb chars to STRING Buffer
|
||
//
|
||
// Arguments: pString - pointer to String to allocate memory to
|
||
//
|
||
// Returns: STATUS_SUCCESS - Normal completion
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory and sets STRING sizes
|
||
//
|
||
// Notes: Must call StringFree() to release memory
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
StringAllocate(
|
||
IN PSTRING pString,
|
||
IN USHORT cb
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest:Entering StringAllocate\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
ASSERT(pString);
|
||
ASSERT(!pString->Buffer); // catch any memory leaks
|
||
|
||
cb = cb + 1; // Add in extra room for the terminating NULL
|
||
|
||
if (ARGUMENT_PRESENT(pString))
|
||
{
|
||
pString->Length = 0;
|
||
|
||
pString->Buffer = (char *)DigestAllocateMemory((ULONG)(cb * sizeof(CHAR)));
|
||
if (pString->Buffer)
|
||
{
|
||
pString->MaximumLength = cb;
|
||
}
|
||
else
|
||
{
|
||
pString->MaximumLength = 0;
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
goto CleanUp;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
Status = STATUS_INVALID_PARAMETER;
|
||
goto CleanUp;
|
||
}
|
||
|
||
CleanUp:
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving StringAllocate\n"));
|
||
return(Status);
|
||
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: SidDuplicate
|
||
//
|
||
// Synopsis: Duplicates a SID
|
||
//
|
||
// Arguments: DestinationSid - Receives a copy of the SourceSid
|
||
// SourceSid - SID to copy
|
||
//
|
||
// Returns: STATUS_SUCCESS - the copy succeeded
|
||
// STATUS_INSUFFICIENT_RESOURCES - the call to allocate memory
|
||
// failed
|
||
//
|
||
// Requires:
|
||
//
|
||
// Effects: allocates memory with LsaFunctions.AllocateLsaHeap
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
SidDuplicate(
|
||
OUT PSID * DestinationSid,
|
||
IN PSID SourceSid
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "NTDigest: Entering SidDuplicate\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
ULONG SidSize;
|
||
|
||
// ASSERT(RtlValidSid(SourceSid));
|
||
|
||
SidSize = RtlLengthSid(SourceSid);
|
||
|
||
*DestinationSid = (PSID) DigestAllocateMemory( SidSize );
|
||
|
||
if (ARGUMENT_PRESENT(*DestinationSid))
|
||
{
|
||
RtlCopyMemory(
|
||
*DestinationSid,
|
||
SourceSid,
|
||
SidSize
|
||
);
|
||
}
|
||
else
|
||
{
|
||
Status = STATUS_INSUFFICIENT_RESOURCES;
|
||
DebugLog((DEB_ERROR, "NTDigest: SidDuplicate, DigestAllocateMemory returns NULL\n"));
|
||
goto CleanUp;
|
||
}
|
||
|
||
CleanUp:
|
||
// DebugLog((DEB_TRACE, "NTDigest: Leaving SidDuplicate\n"));
|
||
return(Status);
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: DigestAllocateMemory
|
||
//
|
||
// Synopsis: Allocate memory in either lsa mode or user mode
|
||
//
|
||
// Effects: Allocated chunk is zeroed out
|
||
//
|
||
// Arguments:
|
||
//
|
||
// Requires:
|
||
//
|
||
// Returns:
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
PVOID
|
||
DigestAllocateMemory(
|
||
IN ULONG BufferSize
|
||
)
|
||
{
|
||
PVOID Buffer = NULL;
|
||
// DebugLog((DEB_TRACE, "Entering DigestAllocateMemory\n"));
|
||
|
||
if (g_NtDigestState == NtDigestLsaMode)
|
||
{
|
||
Buffer = g_LsaFunctions->AllocateLsaHeap(BufferSize);
|
||
if (Buffer != NULL)
|
||
{
|
||
RtlZeroMemory(Buffer, BufferSize);
|
||
}
|
||
DebugLog((DEB_TRACE_MEM, "Memory: LSA alloc %lu bytes at 0x%x\n", BufferSize, Buffer ));
|
||
}
|
||
else
|
||
{
|
||
ASSERT(g_NtDigestState == NtDigestUserMode);
|
||
Buffer = LocalAlloc(LPTR, BufferSize);
|
||
DebugLog((DEB_TRACE_MEM, "Memory: Local alloc %lu bytes at 0x%x\n", BufferSize, Buffer ));
|
||
}
|
||
|
||
// DebugLog((DEB_TRACE, "Leaving DigestAllocateMemory\n"));
|
||
return Buffer;
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: DigestFreeMemory
|
||
//
|
||
// Synopsis: Free memory in either lsa mode or user mode
|
||
//
|
||
// Effects:
|
||
//
|
||
// Arguments:
|
||
//
|
||
// Requires:
|
||
//
|
||
// Returns:
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
VOID
|
||
DigestFreeMemory(
|
||
IN PVOID Buffer
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE, "Entering DigestFreeMemory\n"));
|
||
|
||
if (ARGUMENT_PRESENT(Buffer))
|
||
{
|
||
if (g_NtDigestState == NtDigestLsaMode)
|
||
{
|
||
DebugLog((DEB_TRACE_MEM, "DigestFreeMemory: LSA free at 0x%x\n", Buffer ));
|
||
g_LsaFunctions->FreeLsaHeap(Buffer);
|
||
}
|
||
else
|
||
{
|
||
ASSERT(g_NtDigestState == NtDigestUserMode);
|
||
DebugLog((DEB_TRACE_MEM, "DigestFreeMemory: Local free at 0x%x\n", Buffer ));
|
||
LocalFree(Buffer);
|
||
}
|
||
}
|
||
|
||
// DebugLog((DEB_TRACE, "Leaving DigestFreeMemory\n"));
|
||
}
|
||
|
||
|
||
|
||
|
||
// Helper functions
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert binary data to ASCII hex representation
|
||
|
||
Arguments:
|
||
|
||
pSrc - binary data to convert
|
||
cSrc - length of binary data
|
||
pDst - buffer receiving ASCII representation of pSrc
|
||
|
||
Return Value:
|
||
|
||
Nothing
|
||
|
||
--*/
|
||
VOID
|
||
BinToHex(
|
||
LPBYTE pSrc,
|
||
UINT cSrc,
|
||
LPSTR pDst
|
||
)
|
||
{
|
||
#define TOHEX(a) ((a)>=10 ? 'a'+(a)-10 : '0'+(a))
|
||
|
||
for ( UINT x = 0, y = 0 ; x < cSrc ; ++x )
|
||
{
|
||
UINT v;
|
||
v = pSrc[x]>>4;
|
||
pDst[y++] = TOHEX( v );
|
||
v = pSrc[x]&0x0f;
|
||
pDst[y++] = TOHEX( v );
|
||
}
|
||
pDst[y] = '\0';
|
||
}
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Convert binary data to ASCII hex representation
|
||
|
||
Arguments:
|
||
|
||
pSrc - ASCII data to convert to binary
|
||
cSrc - length of ASCII data
|
||
pDst - buffer receiving binary representation of pSrc
|
||
|
||
Return Value:
|
||
|
||
Nothing
|
||
|
||
--*/
|
||
VOID
|
||
HexToBin(
|
||
LPSTR pSrc,
|
||
UINT cSrc,
|
||
LPBYTE pDst
|
||
)
|
||
{
|
||
#define TOBIN(a) ((a)>='a' ? (a)-'a'+10 : (a)-'0')
|
||
|
||
for ( UINT x = 0, y = 0 ; x < cSrc ; x = x + 2 )
|
||
{
|
||
BYTE v;
|
||
v = TOBIN(pSrc[x])<<4;
|
||
pDst[y++] = v + TOBIN(pSrc[x+1]);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
//+-------------------------------------------------------------------------
|
||
//
|
||
// Function: CopyClientString
|
||
//
|
||
// Synopsis: copies a client string to local memory, including
|
||
// allocating space for it locally.
|
||
//
|
||
// Arguments:
|
||
// SourceString - Could be Ansi or Wchar in client process
|
||
// SourceLength - bytes
|
||
// DoUnicode - whether the string is Wchar
|
||
//
|
||
// Returns:
|
||
// DestinationString - Unicode String in Lsa Process
|
||
//
|
||
// Notes:
|
||
//
|
||
//--------------------------------------------------------------------------
|
||
NTSTATUS
|
||
CopyClientString(
|
||
IN PWSTR SourceString,
|
||
IN ULONG SourceLength,
|
||
IN BOOLEAN DoUnicode,
|
||
OUT PUNICODE_STRING DestinationString
|
||
)
|
||
{
|
||
// DebugLog((DEB_TRACE,"NTDigest: Entering CopyClientString\n"));
|
||
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
STRING TemporaryString;
|
||
ULONG SourceSize = 0;
|
||
ULONG CharacterSize = sizeof(CHAR);
|
||
|
||
ASSERT(DestinationString);
|
||
ASSERT(!DestinationString->Buffer);
|
||
|
||
//
|
||
// First initialize the string to zero, in case the source is a null
|
||
// string
|
||
//
|
||
|
||
DestinationString->Length = DestinationString->MaximumLength = 0;
|
||
DestinationString->Buffer = NULL;
|
||
TemporaryString.Buffer = NULL;
|
||
|
||
|
||
if (SourceString != NULL)
|
||
{
|
||
|
||
//
|
||
// If the length is zero, allocate one byte for a "\0" terminator
|
||
//
|
||
|
||
if (SourceLength == 0)
|
||
{
|
||
DestinationString->Buffer = (LPWSTR) DigestAllocateMemory(sizeof(WCHAR));
|
||
if (DestinationString->Buffer == NULL)
|
||
{
|
||
DebugLog((DEB_ERROR,"CopyClientString, Error from DigestAllocate is 0x%lx\n", Status));
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
goto Cleanup;
|
||
}
|
||
DestinationString->MaximumLength = sizeof(WCHAR);
|
||
*DestinationString->Buffer = L'\0';
|
||
|
||
}
|
||
else
|
||
{
|
||
//
|
||
// Allocate a temporary buffer to hold the client string. We may
|
||
// then create a buffer for the unicode version. The length
|
||
// is the length in characters, so possible expand to hold unicode
|
||
// characters and a null terminator.
|
||
//
|
||
|
||
if (DoUnicode)
|
||
{
|
||
CharacterSize = sizeof(WCHAR);
|
||
}
|
||
|
||
SourceSize = (SourceLength + 1) * CharacterSize;
|
||
|
||
//
|
||
// insure no overflow aggainst UNICODE_STRING
|
||
//
|
||
|
||
if ( (SourceSize > 0xFFFF) ||
|
||
((SourceSize - CharacterSize) > 0xFFFF)
|
||
)
|
||
{
|
||
Status = STATUS_INVALID_PARAMETER;
|
||
DebugLog((DEB_ERROR,"CopyClientString: SourceSize is too large\n"));
|
||
goto Cleanup;
|
||
}
|
||
|
||
|
||
TemporaryString.Buffer = (LPSTR) DigestAllocateMemory(SourceSize);
|
||
if (TemporaryString.Buffer == NULL)
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR,"CopyClientString: Error from DigestAllocate is 0x%lx\n", Status));
|
||
goto Cleanup;
|
||
}
|
||
TemporaryString.Length = (USHORT) (SourceSize - CharacterSize);
|
||
TemporaryString.MaximumLength = (USHORT) SourceSize;
|
||
|
||
|
||
//
|
||
// Finally copy the string from the client
|
||
//
|
||
|
||
Status = g_LsaFunctions->CopyFromClientBuffer(
|
||
NULL,
|
||
SourceSize - CharacterSize,
|
||
TemporaryString.Buffer,
|
||
SourceString
|
||
);
|
||
|
||
if (!NT_SUCCESS(Status))
|
||
{
|
||
DebugLog((DEB_ERROR,"CopyClientString: Error from LsaFunctions->CopyFromClientBuffer is 0x%lx\n", Status));
|
||
goto Cleanup;
|
||
}
|
||
|
||
//
|
||
// If we are doing unicode, finish up now
|
||
//
|
||
if (DoUnicode)
|
||
{
|
||
DestinationString->Buffer = (LPWSTR) TemporaryString.Buffer;
|
||
DestinationString->Length = (USHORT) (SourceSize - CharacterSize);
|
||
DestinationString->MaximumLength = (USHORT) SourceSize;
|
||
}
|
||
else
|
||
{
|
||
NTSTATUS Status1;
|
||
Status1 = RtlAnsiStringToUnicodeString(
|
||
DestinationString,
|
||
&TemporaryString,
|
||
TRUE
|
||
); // allocate destination
|
||
if (!NT_SUCCESS(Status1))
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR,"CopyClientString: Error from RtlAnsiStringToUnicodeString is 0x%lx\n", Status));
|
||
goto Cleanup;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Cleanup:
|
||
|
||
if (TemporaryString.Buffer != NULL)
|
||
{
|
||
//
|
||
// Free this if we failed and were doing unicode or if we weren't
|
||
// doing unicode
|
||
//
|
||
|
||
if ((DoUnicode && !NT_SUCCESS(Status)) || !DoUnicode)
|
||
{
|
||
DigestFreeMemory(TemporaryString.Buffer);
|
||
}
|
||
}
|
||
|
||
// DebugLog((DEB_TRACE,"NTDigest: Leaving CopyClientString\n"));
|
||
|
||
return(Status);
|
||
}
|
||
|
||
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine parses a Token Descriptor and pulls out the useful
|
||
information.
|
||
|
||
Arguments:
|
||
|
||
TokenDescriptor - Descriptor of the buffer containing the token.
|
||
|
||
BufferIndex - Selects which buffer to extract
|
||
|
||
Token - Handle to the SecBuffer to write selected buffer to.
|
||
|
||
ReadonlyOK - TRUE if the token buffer may be readonly.
|
||
|
||
Return Value:
|
||
|
||
TRUE - If token buffer was properly found.
|
||
|
||
--*/
|
||
|
||
BOOLEAN
|
||
SspGetTokenBufferByIndex(
|
||
IN PSecBufferDesc TokenDescriptor OPTIONAL,
|
||
IN ULONG BufferIndex,
|
||
OUT PSecBuffer * Token,
|
||
IN BOOLEAN ReadonlyOK
|
||
)
|
||
{
|
||
|
||
NTSTATUS StatusTmp = STATUS_SUCCESS;
|
||
ULONG i, Index = 0;
|
||
PSecBuffer Buffer = NULL;
|
||
|
||
//
|
||
// If there is no TokenDescriptor passed in,
|
||
// just pass out NULL to our caller.
|
||
//
|
||
|
||
ASSERT(*Token != NULL);
|
||
if ( !ARGUMENT_PRESENT( TokenDescriptor) ) {
|
||
return TRUE;
|
||
}
|
||
|
||
if (TokenDescriptor->ulVersion != SECBUFFER_VERSION)
|
||
{
|
||
DebugLog((DEB_ERROR,"SspGetTokenBufferByIndex: Wrong Version number\n"));
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Verify that it is a valid location
|
||
//
|
||
|
||
if (BufferIndex >= TokenDescriptor->cBuffers)
|
||
{
|
||
DebugLog((DEB_ERROR,"SspGetTokenBufferByIndex: Index out of range for SecBufferDesc\n"));
|
||
return FALSE;
|
||
}
|
||
|
||
// DebugLog((DEB_TRACE,"SspGetTokenBufferByIndex: NumberTokens %d\n",TokenDescriptor->cBuffers));
|
||
|
||
Buffer = &TokenDescriptor->pBuffers[BufferIndex];
|
||
|
||
//
|
||
// If the buffer is readonly and readonly isn't OK,
|
||
// reject the buffer.
|
||
//
|
||
|
||
if (!ReadonlyOK && (Buffer->BufferType & SECBUFFER_READONLY))
|
||
{
|
||
DebugLog((DEB_TRACE,"SspGetTokenBufferByIndex: request write on READONLY Token buffer\n"));
|
||
return FALSE;
|
||
}
|
||
|
||
//
|
||
// Return the requested information
|
||
//
|
||
if (Buffer->cbBuffer && Buffer->pvBuffer)
|
||
{
|
||
StatusTmp = g_LsaFunctions->MapBuffer(Buffer, Buffer);
|
||
if (!NT_SUCCESS(StatusTmp))
|
||
{
|
||
DebugLog((DEB_ERROR,"SspGetTokenBufferByIndex: Unable to MapBuffer 0x%x\n", StatusTmp));
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
*Token = Buffer;
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
// determine strlen for a counted string buffer which may or may not be terminated
|
||
size_t strlencounted(const char *string,
|
||
size_t maxcnt)
|
||
{
|
||
size_t cnt = 0;
|
||
if (maxcnt <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
while (maxcnt--)
|
||
{
|
||
if (!*string)
|
||
{
|
||
break;
|
||
}
|
||
cnt++;
|
||
string++;
|
||
}
|
||
|
||
return cnt;
|
||
}
|
||
|
||
|
||
// determine strlen for a counted string buffer which may or may not be terminated
|
||
// maxcnt is the max number of BYTES (so number of unicode chars is 1/2 the maxcnt)
|
||
size_t ustrlencounted(const short *string,
|
||
size_t maxcnt)
|
||
{
|
||
size_t cnt = 0;
|
||
if (maxcnt <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
maxcnt = maxcnt / 2; // determine number of unicode characters to search
|
||
|
||
while (maxcnt--)
|
||
{
|
||
if (!*string)
|
||
{
|
||
break;
|
||
}
|
||
cnt++;
|
||
string++;
|
||
}
|
||
|
||
return cnt;
|
||
}
|
||
|
||
// Performs a Backslash encoding of the source string into the destination string per RFC 2831
|
||
// Section 7.2 and RFC 2616 sect 2.2
|
||
NTSTATUS BackslashEncodeString(IN PSTRING pstrSrc, OUT PSTRING pstrDst)
|
||
{
|
||
NTSTATUS Status = S_OK;
|
||
USHORT uCharsMax = 0;
|
||
PCHAR pcSrc = NULL;
|
||
PCHAR pcDst = NULL;
|
||
USHORT uCharsUsed = 0;
|
||
USHORT uCharSrcCnt = 0;
|
||
|
||
StringFree(pstrDst);
|
||
|
||
if (!pstrSrc || !pstrDst || !pstrSrc->Length)
|
||
{
|
||
return S_OK;
|
||
}
|
||
|
||
uCharsMax = pstrSrc->Length * 2; // Max size if each character needs to be encoded
|
||
Status = StringAllocate(pstrDst, uCharsMax);
|
||
if (!NT_SUCCESS(Status))
|
||
{
|
||
DebugLog((DEB_ERROR,"BackshlashEncodeString: String allocation failed 0x%x\n", Status));
|
||
goto CleanUp;
|
||
}
|
||
|
||
// now map over each character - encode as necessary
|
||
pcSrc = pstrSrc->Buffer;
|
||
pcDst = pstrDst->Buffer;
|
||
while (uCharSrcCnt < pstrSrc->Length)
|
||
{
|
||
switch (*pcSrc)
|
||
{
|
||
case CHAR_DQUOTE:
|
||
case CHAR_BACKSLASH:
|
||
*pcDst++ = CHAR_BACKSLASH;
|
||
*pcDst++ = *pcSrc++;
|
||
uCharsUsed+= 2;
|
||
break;
|
||
default:
|
||
*pcDst++ = *pcSrc++;
|
||
uCharsUsed++;
|
||
break;
|
||
}
|
||
uCharSrcCnt++;
|
||
}
|
||
|
||
pstrDst->Length = uCharsUsed;
|
||
|
||
CleanUp:
|
||
return Status;
|
||
}
|
||
|
||
|
||
|
||
// Print out the date and time from a given TimeStamp (converted to localtime)
|
||
NTSTATUS PrintTimeString(TimeStamp ConvertTime, BOOL fLocalTime)
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
|
||
LARGE_INTEGER LocalTime;
|
||
LARGE_INTEGER SystemTime;
|
||
|
||
SystemTime = (LARGE_INTEGER)ConvertTime;
|
||
LocalTime.HighPart = 0;
|
||
LocalTime.LowPart = 0;
|
||
|
||
if (ConvertTime.HighPart == 0x7FFFFFFF)
|
||
{
|
||
DebugLog((DEB_TRACE, "PrintTimeString: Never ends\n"));
|
||
}
|
||
|
||
if (fLocalTime)
|
||
{
|
||
Status = RtlSystemTimeToLocalTime( &SystemTime, &LocalTime );
|
||
if (!NT_SUCCESS( Status )) {
|
||
DebugLog((DEB_ERROR, "PrintTimeString: Can't convert time from GMT to Local time\n"));
|
||
LocalTime = ConvertTime;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
LocalTime = ConvertTime;
|
||
}
|
||
|
||
TIME_FIELDS TimeFields;
|
||
|
||
RtlTimeToTimeFields( &LocalTime, &TimeFields );
|
||
|
||
DebugLog((DEB_TRACE, "PrintTimeString: %ld/%ld/%ld %ld:%2.2ld:%2.2ld\n",
|
||
TimeFields.Month,
|
||
TimeFields.Day,
|
||
TimeFields.Year,
|
||
TimeFields.Hour,
|
||
TimeFields.Minute,
|
||
TimeFields.Second));
|
||
|
||
return Status;
|
||
}
|
||
|
||
// Printout the Hex representation of a buffer
|
||
NTSTATUS MyPrintBytes(void *pbuff, USHORT uNumBytes, PSTRING pstrOutput)
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
USHORT uNumTotal = 0;
|
||
PCHAR pctr = NULL;
|
||
PCHAR pOut = NULL;
|
||
USHORT i = 0;
|
||
|
||
// Each byte will be encoded as XX <sp>
|
||
|
||
uNumTotal = (uNumBytes * 3) + 1;
|
||
|
||
StringFree(pstrOutput);
|
||
Status = StringAllocate(pstrOutput, uNumTotal);
|
||
if (!NT_SUCCESS (Status))
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR, "ContextInit: StringAllocate error 0x%x\n", Status));
|
||
goto CleanUp;
|
||
}
|
||
|
||
pOut = (PCHAR)pstrOutput->Buffer;
|
||
|
||
for (i = 0, pctr = (PCHAR)pbuff; i < uNumBytes; i++)
|
||
{
|
||
sprintf(pOut, "%02x ", (*pctr & 0xff));
|
||
pOut += 3;
|
||
pctr++;
|
||
}
|
||
pstrOutput->Length = uNumBytes * 3;
|
||
|
||
CleanUp:
|
||
|
||
return Status;
|
||
}
|