You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1352 lines
35 KiB
1352 lines
35 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1997.
|
|
//
|
|
// File: pwdssp.c
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 9-07-97 RichardW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
|
|
#include "pwdsspp.h"
|
|
|
|
typedef struct _PWD_CRED {
|
|
DWORD Ref;
|
|
} PWD_CRED, * PPWD_CRED;
|
|
|
|
typedef struct _PWD_CONTEXT {
|
|
DWORD Tag;
|
|
HANDLE Token;
|
|
} PWD_CONTEXT, *PPWD_CONTEXT ;
|
|
|
|
PWD_CRED PwdGlobalAnsi;
|
|
PWD_CRED PwdGlobalUnicode;
|
|
|
|
#define CONTEXT_TAG 'txtC'
|
|
#define ANONYMOUS_TOKEN ((HANDLE) 1)
|
|
|
|
SecPkgInfoA PwdInfoA = { SECPKG_FLAG_CONNECTION |
|
|
SECPKG_FLAG_ACCEPT_WIN32_NAME,
|
|
1,
|
|
(WORD) -1,
|
|
768,
|
|
PWDSSP_NAME_A,
|
|
"Microsoft Clear Text Password Security Provider" };
|
|
|
|
SecPkgInfoW PwdInfoW = { SECPKG_FLAG_CONNECTION |
|
|
SECPKG_FLAG_ACCEPT_WIN32_NAME,
|
|
1,
|
|
(WORD) -1,
|
|
768,
|
|
PWDSSP_NAME_W,
|
|
L"Microsoft Clear Text Password Security Provider" };
|
|
|
|
|
|
|
|
|
|
SecurityFunctionTableA PwdTableA = {
|
|
SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
|
|
EnumerateSecurityPackagesA,
|
|
NULL,
|
|
AcquireCredentialsHandleA,
|
|
FreeCredentialsHandle,
|
|
NULL,
|
|
InitializeSecurityContextA,
|
|
AcceptSecurityContext,
|
|
CompleteAuthToken,
|
|
DeleteSecurityContext,
|
|
ApplyControlToken,
|
|
QueryContextAttributesA,
|
|
ImpersonateSecurityContext,
|
|
RevertSecurityContext,
|
|
MakeSignature,
|
|
VerifySignature,
|
|
FreeContextBuffer,
|
|
QuerySecurityPackageInfoA,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
QuerySecurityContextToken
|
|
};
|
|
|
|
SecurityFunctionTableW PwdTableW = {
|
|
SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
|
|
EnumerateSecurityPackagesW,
|
|
NULL,
|
|
AcquireCredentialsHandleW,
|
|
FreeCredentialsHandle,
|
|
NULL,
|
|
InitializeSecurityContextW,
|
|
AcceptSecurityContext,
|
|
CompleteAuthToken,
|
|
DeleteSecurityContext,
|
|
ApplyControlToken,
|
|
QueryContextAttributesW,
|
|
ImpersonateSecurityContext,
|
|
RevertSecurityContext,
|
|
MakeSignature,
|
|
VerifySignature,
|
|
FreeContextBuffer,
|
|
QuerySecurityPackageInfoW,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
QuerySecurityContextToken
|
|
};
|
|
|
|
|
|
//#define PwdAlloc(x) LsaIAllocateHeap(x)
|
|
//#define PwdFree(x) LsaIFreeHeap(x)
|
|
#define PwdAlloc(x) LocalAlloc(LMEM_FIXED|LMEM_ZEROINIT,x)
|
|
#define PwdFree(x) LocalFree(x)
|
|
|
|
NTSTATUS
|
|
VerifyCredentials(
|
|
IN PWSTR UserName,
|
|
IN PWSTR DomainName,
|
|
IN PWSTR Password,
|
|
IN ULONG VerifyFlags
|
|
);
|
|
|
|
UNICODE_STRING AuthenticationPackage;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DllMain
|
|
//
|
|
// Synopsis: Entry point
|
|
//
|
|
// Arguments: [hInstance] --
|
|
// [dwReason] --
|
|
// [lpReserved] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
WINAPI
|
|
DllMain(
|
|
HINSTANCE hInstance,
|
|
DWORD dwReason,
|
|
LPVOID lpReserved)
|
|
{
|
|
|
|
if (dwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
DisableThreadLibraryCalls( hInstance );
|
|
RtlInitUnicodeString(&AuthenticationPackage, MICROSOFT_KERBEROS_NAME_W);
|
|
|
|
if ( !CacheInitialize() ) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PwdpParseBuffers
|
|
//
|
|
// Synopsis: Parse out right buffer descriptor
|
|
//
|
|
// Arguments: [pMessage] --
|
|
// [pToken] --
|
|
// [pEmpty] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
PwdpParseBuffers(
|
|
PSecBufferDesc pMessage,
|
|
PSecBuffer * pToken,
|
|
PSecBuffer * pEmpty)
|
|
{
|
|
ULONG i;
|
|
PSecBuffer pFirstBlank = NULL;
|
|
PSecBuffer pWholeMessage = NULL;
|
|
|
|
|
|
for (i = 0 ; i < pMessage->cBuffers ; i++ )
|
|
{
|
|
if ( (pMessage->pBuffers[i].BufferType & (~SECBUFFER_ATTRMASK)) == SECBUFFER_TOKEN )
|
|
{
|
|
pWholeMessage = &pMessage->pBuffers[i];
|
|
if (pFirstBlank)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if ( (pMessage->pBuffers[i].BufferType & (~SECBUFFER_ATTRMASK)) == SECBUFFER_EMPTY )
|
|
{
|
|
pFirstBlank = &pMessage->pBuffers[i];
|
|
if (pWholeMessage)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pToken)
|
|
{
|
|
*pToken = pWholeMessage;
|
|
}
|
|
|
|
if (pEmpty)
|
|
{
|
|
*pEmpty = pFirstBlank;
|
|
}
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: AcquireCredentialsHandleW
|
|
//
|
|
// Synopsis: Get the credential handle
|
|
//
|
|
// Arguments: [pszPrincipal] --
|
|
// [pszPackageName] --
|
|
// [fCredentialUse] --
|
|
// [pvLogonId] --
|
|
// [pAuthData] --
|
|
// [pGetKeyFn] --
|
|
// [GetKey] --
|
|
// [pvGetKeyArgument] --
|
|
// [GetKey] --
|
|
// [phCredential] --
|
|
// [PTimeStamp] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
AcquireCredentialsHandleW(
|
|
SEC_WCHAR SEC_FAR * pszPrincipal, // Name of principal
|
|
SEC_WCHAR SEC_FAR * pszPackageName, // Name of package
|
|
unsigned long fCredentialUse, // Flags indicating use
|
|
void SEC_FAR * pvLogonId, // Pointer to logon ID
|
|
void SEC_FAR * pAuthData, // Package specific data
|
|
SEC_GET_KEY_FN pGetKeyFn, // Pointer to GetKey() func
|
|
void SEC_FAR * pvGetKeyArgument, // Value to pass to GetKey()
|
|
PCredHandle phCredential, // (out) Cred Handle
|
|
PTimeStamp ptsExpiry // (out) Lifetime (optional)
|
|
)
|
|
{
|
|
if (_wcsicmp(pszPackageName, PWDSSP_NAME_W))
|
|
{
|
|
return( SEC_E_SECPKG_NOT_FOUND );
|
|
}
|
|
|
|
if ( fCredentialUse & SECPKG_CRED_OUTBOUND )
|
|
{
|
|
return( SEC_E_NO_CREDENTIALS );
|
|
}
|
|
|
|
InterlockedIncrement( &PwdGlobalUnicode.Ref );
|
|
|
|
phCredential->dwUpper = (ULONG_PTR) &PwdGlobalUnicode ;
|
|
|
|
if ( ptsExpiry )
|
|
{
|
|
ptsExpiry->LowPart = (DWORD) 0xFFFFFFFF;
|
|
ptsExpiry->HighPart = (DWORD) 0x7FFFFFFF;
|
|
}
|
|
|
|
return( SEC_E_OK );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: AcquireCredentialsHandleA
|
|
//
|
|
// Synopsis: ANSI entry
|
|
//
|
|
// Arguments: [pszPrincipal] --
|
|
// [pszPackageName] --
|
|
// [fCredentialUse] --
|
|
// [pvLogonId] --
|
|
// [pAuthData] --
|
|
// [pGetKeyFn] --
|
|
// [GetKey] --
|
|
// [pvGetKeyArgument] --
|
|
// [GetKey] --
|
|
// [phCredential] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS SEC_ENTRY
|
|
AcquireCredentialsHandleA(
|
|
SEC_CHAR SEC_FAR * pszPrincipal, // Name of principal
|
|
SEC_CHAR SEC_FAR * pszPackageName, // Name of package
|
|
unsigned long fCredentialUse, // Flags indicating use
|
|
void SEC_FAR * pvLogonId, // Pointer to logon ID
|
|
void SEC_FAR * pAuthData, // Package specific data
|
|
SEC_GET_KEY_FN pGetKeyFn, // Pointer to GetKey() func
|
|
void SEC_FAR * pvGetKeyArgument, // Value to pass to GetKey()
|
|
PCredHandle phCredential, // (out) Cred Handle
|
|
PTimeStamp ptsExpiry // (out) Lifetime (optional)
|
|
)
|
|
{
|
|
|
|
if (_stricmp(pszPackageName, PWDSSP_NAME_A))
|
|
{
|
|
return( SEC_E_SECPKG_NOT_FOUND );
|
|
}
|
|
|
|
if ( fCredentialUse & SECPKG_CRED_OUTBOUND )
|
|
{
|
|
return( SEC_E_NO_CREDENTIALS );
|
|
}
|
|
|
|
InterlockedIncrement( &PwdGlobalAnsi.Ref );
|
|
|
|
phCredential->dwUpper = (ULONG_PTR) &PwdGlobalAnsi ;
|
|
|
|
if ( ptsExpiry )
|
|
{
|
|
ptsExpiry->LowPart = (DWORD) 0xFFFFFFFF;
|
|
ptsExpiry->HighPart = (DWORD) 0x7FFFFFFF;
|
|
}
|
|
|
|
|
|
return(SEC_E_OK);
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FreeCredentialHandle
|
|
//
|
|
// Synopsis: Free a credential handle
|
|
//
|
|
// Arguments: [free] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
FreeCredentialsHandle(
|
|
PCredHandle phCredential // Handle to free
|
|
)
|
|
{
|
|
PPWD_CRED Cred;
|
|
|
|
if ( (phCredential->dwUpper != (ULONG_PTR) &PwdGlobalAnsi ) &&
|
|
(phCredential->dwUpper != (ULONG_PTR) &PwdGlobalUnicode ) )
|
|
{
|
|
return( SEC_E_INVALID_HANDLE );
|
|
}
|
|
|
|
Cred = (PPWD_CRED) phCredential->dwUpper ;
|
|
|
|
InterlockedDecrement( &Cred->Ref );
|
|
|
|
return( SEC_E_OK );
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: InitializeSecurityContextW
|
|
//
|
|
// Synopsis: Initialize a security context (outbound) NOT SUPPORTED
|
|
//
|
|
// Arguments: [phCredential] --
|
|
// [phContext] --
|
|
// [pszTargetName] --
|
|
// [fContextReq] --
|
|
// [Reserved1] --
|
|
// [Reserved] --
|
|
// [TargetDataRep] --
|
|
// [pInput] --
|
|
// [Reserved2] --
|
|
// [Reserved] --
|
|
// [phNewContext] --
|
|
// [pOutput] --
|
|
// [pfContextAttr] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
InitializeSecurityContextW(
|
|
PCredHandle phCredential, // Cred to base context
|
|
PCtxtHandle phContext, // Existing context (OPT)
|
|
SEC_WCHAR SEC_FAR * pszTargetName, // Name of target
|
|
unsigned long fContextReq, // Context Requirements
|
|
unsigned long Reserved1, // Reserved, MBZ
|
|
unsigned long TargetDataRep, // Data rep of target
|
|
PSecBufferDesc pInput, // Input Buffers
|
|
unsigned long Reserved2, // Reserved, MBZ
|
|
PCtxtHandle phNewContext, // (out) New Context handle
|
|
PSecBufferDesc pOutput, // (inout) Output Buffers
|
|
unsigned long SEC_FAR * pfContextAttr, // (out) Context attrs
|
|
PTimeStamp ptsExpiry // (out) Life span (OPT)
|
|
)
|
|
{
|
|
return( SEC_E_UNSUPPORTED_FUNCTION );
|
|
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: InitializeSecurityContextA
|
|
//
|
|
// Synopsis: NOT SUPPORTED
|
|
//
|
|
// Arguments: [phCredential] --
|
|
// [phContext] --
|
|
// [pszTargetName] --
|
|
// [fContextReq] --
|
|
// [Reserved1] --
|
|
// [TargetDataRep] --
|
|
// [pInput] --
|
|
// [Reserved2] --
|
|
// [phNewContext] --
|
|
// [pOutput] --
|
|
// [pfContextAttr] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
InitializeSecurityContextA(
|
|
PCredHandle phCredential, // Cred to base context
|
|
PCtxtHandle phContext, // Existing context (OPT)
|
|
SEC_CHAR SEC_FAR * pszTargetName, // Name of target
|
|
unsigned long fContextReq, // Context Requirements
|
|
unsigned long Reserved1, // Reserved, MBZ
|
|
unsigned long TargetDataRep, // Data rep of target
|
|
PSecBufferDesc pInput, // Input Buffers
|
|
unsigned long Reserved2, // Reserved, MBZ
|
|
PCtxtHandle phNewContext, // (out) New Context handle
|
|
PSecBufferDesc pOutput, // (inout) Output Buffers
|
|
unsigned long SEC_FAR * pfContextAttr, // (out) Context attrs
|
|
PTimeStamp ptsExpiry // (out) Life span (OPT)
|
|
)
|
|
{
|
|
return( SEC_E_UNSUPPORTED_FUNCTION );
|
|
}
|
|
|
|
PSEC_WINNT_AUTH_IDENTITY_A
|
|
PwdpMakeAnsiCopy(
|
|
PSEC_WINNT_AUTH_IDENTITY_A Ansi
|
|
)
|
|
{
|
|
PSEC_WINNT_AUTH_IDENTITY_A New ;
|
|
|
|
New = PwdAlloc( sizeof( SEC_WINNT_AUTH_IDENTITY_A ) +
|
|
Ansi->UserLength + 1 +
|
|
Ansi->DomainLength + 1 +
|
|
Ansi->PasswordLength + 1 );
|
|
|
|
if ( New )
|
|
{
|
|
New->User = (PSTR) (New + 1);
|
|
CopyMemory( New->User, Ansi->User, Ansi->UserLength );
|
|
New->User[ Ansi->UserLength ] = '\0';
|
|
|
|
New->Domain = New->User + Ansi->UserLength + 1 ;
|
|
CopyMemory( New->Domain, Ansi->Domain, Ansi->DomainLength );
|
|
New->Domain[ Ansi->DomainLength ] = '\0';
|
|
|
|
New->Password = New->Domain + Ansi->DomainLength + 1 ;
|
|
CopyMemory( New->Password, Ansi->Password, Ansi->PasswordLength );
|
|
New->Password[ Ansi->PasswordLength ] = '\0';
|
|
|
|
}
|
|
|
|
return( New );
|
|
}
|
|
|
|
PSEC_WINNT_AUTH_IDENTITY_W
|
|
PwdpMakeWideCopy(
|
|
PSEC_WINNT_AUTH_IDENTITY_W Wide,
|
|
BOOLEAN ValidateOnly
|
|
)
|
|
{
|
|
PSEC_WINNT_AUTH_IDENTITY_W New ;
|
|
ULONG FlatUserLength ;
|
|
PWSTR FlatUser = NULL;
|
|
WCHAR FlatDomain[ DNLEN + 2 ];
|
|
SEC_WINNT_AUTH_IDENTITY_W Local ;
|
|
|
|
if ( (Wide->Domain == NULL) )
|
|
{
|
|
if( ValidateOnly )
|
|
{
|
|
ULONG Index;
|
|
|
|
Local = *Wide ;
|
|
|
|
FlatUserLength = wcslen( Wide->User );
|
|
|
|
for( Index = 0 ; Index < FlatUserLength ; Index++ )
|
|
{
|
|
if( Wide->User[ Index ] == '\\' )
|
|
{
|
|
Local.Domain = Wide->User;
|
|
Local.DomainLength = Index;
|
|
|
|
Local.User = &(Wide->User[Index+1]);
|
|
Local.UserLength = FlatUserLength - Index - 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
FlatUserLength = wcslen( Wide->User ) + 1;
|
|
if ( FlatUserLength < UNLEN+2 )
|
|
{
|
|
FlatUserLength = UNLEN + 2;
|
|
}
|
|
|
|
FlatUser = PwdAlloc(FlatUserLength * sizeof( WCHAR ));
|
|
if ( FlatUser == NULL )
|
|
{
|
|
return NULL ;
|
|
}
|
|
if ( ! PwdCrackName( Wide->User,
|
|
FlatDomain,
|
|
FlatUser ) )
|
|
{
|
|
PwdFree( FlatUser );
|
|
SetLastError( ERROR_NO_SUCH_USER );
|
|
return NULL ;
|
|
}
|
|
|
|
Local = *Wide ;
|
|
Local.User = FlatUser ;
|
|
Local.Domain = FlatDomain ;
|
|
Local.UserLength = wcslen( FlatUser );
|
|
Local.DomainLength = wcslen( FlatDomain );
|
|
}
|
|
|
|
Wide = &Local ;
|
|
|
|
}
|
|
|
|
New = PwdAlloc( sizeof( SEC_WINNT_AUTH_IDENTITY_W ) +
|
|
(Wide->UserLength + 1) * sizeof(WCHAR) +
|
|
(Wide->DomainLength + 1) * sizeof(WCHAR) +
|
|
(Wide->PasswordLength + 1) * sizeof(WCHAR) );
|
|
|
|
if ( New )
|
|
{
|
|
New->User = (PWSTR) (New + 1);
|
|
CopyMemory( New->User, Wide->User, Wide->UserLength * 2 );
|
|
New->User[ Wide->UserLength ] = L'\0';
|
|
|
|
New->UserLength = Wide->UserLength;
|
|
|
|
New->Domain = New->User + Wide->UserLength + 1 ;
|
|
CopyMemory( New->Domain, Wide->Domain, Wide->DomainLength * 2 );
|
|
New->Domain[ Wide->DomainLength ] = L'\0';
|
|
|
|
New->DomainLength = Wide->DomainLength;
|
|
|
|
New->Password = New->Domain + Wide->DomainLength + 1 ;
|
|
CopyMemory( New->Password, Wide->Password, Wide->PasswordLength * 2);
|
|
New->Password[ Wide->PasswordLength ] = '\0';
|
|
|
|
New->PasswordLength = Wide->PasswordLength;
|
|
|
|
}
|
|
|
|
if ( Wide == &Local )
|
|
{
|
|
if( FlatUser != NULL )
|
|
{
|
|
PwdFree( FlatUser );
|
|
}
|
|
}
|
|
|
|
return( New );
|
|
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: AcceptSecurityContext
|
|
//
|
|
// Synopsis: Server side accept security context
|
|
//
|
|
// Arguments: [phCredential] --
|
|
// [phContext] --
|
|
// [pInput] --
|
|
// [fContextReq] --
|
|
// [TargetDataRep] --
|
|
// [phNewContext] --
|
|
// [pOutput] --
|
|
// [pfContextAttr] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
AcceptSecurityContext(
|
|
PCredHandle phCredential, // Cred to base context
|
|
PCtxtHandle phContext, // Existing context (OPT)
|
|
PSecBufferDesc pInput, // Input buffer
|
|
unsigned long fContextReq, // Context Requirements
|
|
unsigned long TargetDataRep, // Target Data Rep
|
|
PCtxtHandle phNewContext, // (out) New context handle
|
|
PSecBufferDesc pOutput, // (inout) Output buffers
|
|
unsigned long SEC_FAR * pfContextAttr, // (out) Context attributes
|
|
PTimeStamp ptsExpiry // (out) Life span (OPT)
|
|
)
|
|
{
|
|
PPWD_CONTEXT Context ;
|
|
PSecBuffer Buffer ;
|
|
DWORD Type;
|
|
PSEC_WINNT_AUTH_IDENTITY_W Unknown ;
|
|
PSEC_WINNT_AUTH_IDENTITY_A Ansi;
|
|
PSEC_WINNT_AUTH_IDENTITY_W Unicode;
|
|
HANDLE Token;
|
|
BOOL Ret;
|
|
|
|
if ( phCredential->dwUpper == (ULONG_PTR) &PwdGlobalAnsi )
|
|
{
|
|
Type = 1;
|
|
}
|
|
else
|
|
{
|
|
if ( phCredential->dwUpper == (ULONG_PTR) &PwdGlobalUnicode )
|
|
{
|
|
Type = 2;
|
|
}
|
|
else
|
|
{
|
|
return( SEC_E_INVALID_HANDLE );
|
|
}
|
|
}
|
|
|
|
|
|
PwdpParseBuffers( pInput, &Buffer, NULL );
|
|
|
|
if ( !Buffer )
|
|
{
|
|
return( SEC_E_INVALID_TOKEN );
|
|
}
|
|
|
|
Unknown = (PSEC_WINNT_AUTH_IDENTITY_W) Buffer->pvBuffer ;
|
|
|
|
if ( Unknown->Flags & SEC_WINNT_AUTH_IDENTITY_UNICODE )
|
|
{
|
|
Type = 2 ;
|
|
}
|
|
|
|
if ( Type == 1 )
|
|
{
|
|
//
|
|
// ANSI:
|
|
//
|
|
|
|
Ansi = PwdpMakeAnsiCopy( (PSEC_WINNT_AUTH_IDENTITY_A) Buffer->pvBuffer);
|
|
|
|
if ( Ansi )
|
|
{
|
|
Ret = LogonUserA( Ansi->User, Ansi->Domain, Ansi->Password,
|
|
LOGON32_LOGON_NETWORK, LOGON32_PROVIDER_DEFAULT,
|
|
&Token ) ;
|
|
|
|
RtlSecureZeroMemory( Ansi->Password, Ansi->PasswordLength );
|
|
PwdFree( Ansi );
|
|
}
|
|
else
|
|
{
|
|
Ret = FALSE ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOLEAN ValidateOnly = ((fContextReq & ASC_REQ_ALLOW_NON_USER_LOGONS) != 0);
|
|
|
|
Unicode = PwdpMakeWideCopy(
|
|
(PSEC_WINNT_AUTH_IDENTITY_W) Buffer->pvBuffer,
|
|
ValidateOnly
|
|
);
|
|
|
|
if ( Unicode )
|
|
{
|
|
if( ValidateOnly )
|
|
{
|
|
PVOID DsContext = THSave();
|
|
NTSTATUS Status;
|
|
|
|
Status = VerifyCredentials(
|
|
Unicode->User,
|
|
Unicode->Domain,
|
|
Unicode->Password,
|
|
0
|
|
);
|
|
|
|
THRestore( DsContext );
|
|
|
|
if( NT_SUCCESS(Status) )
|
|
{
|
|
Ret = TRUE;
|
|
|
|
Token = ANONYMOUS_TOKEN ;
|
|
|
|
} else {
|
|
Ret = FALSE;
|
|
}
|
|
|
|
} else {
|
|
Ret = LogonUserW(
|
|
Unicode->User,
|
|
Unicode->Domain,
|
|
Unicode->Password,
|
|
LOGON32_LOGON_NETWORK,
|
|
LOGON32_PROVIDER_DEFAULT,
|
|
&Token
|
|
);
|
|
}
|
|
|
|
|
|
RtlSecureZeroMemory( Unicode->Password, Unicode->PasswordLength * sizeof(WCHAR) );
|
|
PwdFree( Unicode );
|
|
}
|
|
else
|
|
{
|
|
Ret = FALSE ;
|
|
|
|
if ( GetLastError() == ERROR_NO_SUCH_USER )
|
|
{
|
|
Unicode = (PSEC_WINNT_AUTH_IDENTITY_W) Buffer->pvBuffer ;
|
|
|
|
__try
|
|
{
|
|
if ( Unicode->PasswordLength == 0 )
|
|
{
|
|
Ret = TRUE ;
|
|
Token = ANONYMOUS_TOKEN ;
|
|
}
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER )
|
|
{
|
|
NOTHING ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( Ret )
|
|
{
|
|
Context = (PPWD_CONTEXT) PwdAlloc( sizeof( PWD_CONTEXT ) );
|
|
|
|
if ( Context )
|
|
{
|
|
Context->Tag = CONTEXT_TAG ;
|
|
|
|
Context->Token = Token ;
|
|
|
|
phNewContext->dwUpper = (ULONG_PTR) Context ;
|
|
|
|
return( SEC_E_OK );
|
|
}
|
|
|
|
if ( Token != ANONYMOUS_TOKEN )
|
|
{
|
|
CloseHandle( Token );
|
|
}
|
|
|
|
|
|
return( SEC_E_INSUFFICIENT_MEMORY );
|
|
}
|
|
|
|
return( SEC_E_INVALID_TOKEN );
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: DeleteSecurityContext
|
|
//
|
|
// Synopsis: Deletes a security context
|
|
//
|
|
// Arguments: [phContext] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
DeleteSecurityContext(
|
|
PCtxtHandle phContext )
|
|
{
|
|
PPWD_CONTEXT Context;
|
|
|
|
Context = (PPWD_CONTEXT) phContext->dwUpper ;
|
|
|
|
#if DBG
|
|
// What is the appropriate assert model? This dll does not seem to
|
|
// nt specific, win32 does not provide a model, and the crt requires
|
|
// NDEBUG to set, which is not always the case.
|
|
if (!Context) {
|
|
OutputDebugStringA("[PWDSSP]: !!Error!! - Context is NULL\n");
|
|
DebugBreak();
|
|
}
|
|
#endif
|
|
|
|
if ( Context->Tag == CONTEXT_TAG )
|
|
{
|
|
if ( Context->Token != ANONYMOUS_TOKEN )
|
|
{
|
|
CloseHandle( Context->Token );
|
|
}
|
|
|
|
PwdFree( Context );
|
|
|
|
return( SEC_E_OK );
|
|
}
|
|
|
|
return( SEC_E_INVALID_HANDLE );
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ImpersonateSecurityContext
|
|
//
|
|
// Synopsis: Impersonate the security context
|
|
//
|
|
// Arguments: [impersonate] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
ImpersonateSecurityContext(
|
|
PCtxtHandle phContext // Context to impersonate
|
|
)
|
|
{
|
|
PPWD_CONTEXT Context;
|
|
HANDLE hThread;
|
|
NTSTATUS Status ;
|
|
|
|
Context = (PPWD_CONTEXT) phContext->dwUpper ;
|
|
|
|
if ( Context->Tag == CONTEXT_TAG )
|
|
{
|
|
if ( Context->Token != ANONYMOUS_TOKEN )
|
|
{
|
|
hThread = GetCurrentThread();
|
|
|
|
if(SetThreadToken( &hThread, Context->Token ))
|
|
{
|
|
Status = SEC_E_OK ;
|
|
} else {
|
|
Status = SEC_E_NO_IMPERSONATION;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Status = NtImpersonateAnonymousToken(
|
|
NtCurrentThread() );
|
|
|
|
}
|
|
|
|
return( Status );
|
|
|
|
}
|
|
|
|
return( SEC_E_INVALID_HANDLE );
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: RevertSecurityContext
|
|
//
|
|
// Synopsis: Revert the security context
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
RevertSecurityContext(
|
|
PCtxtHandle phContext // Context from which to re
|
|
)
|
|
{
|
|
PPWD_CONTEXT Context;
|
|
|
|
Context = (PPWD_CONTEXT) phContext->dwUpper ;
|
|
|
|
if ( Context->Tag == CONTEXT_TAG )
|
|
{
|
|
RevertToSelf();
|
|
|
|
return( SEC_E_OK );
|
|
|
|
}
|
|
|
|
return( SEC_E_INVALID_HANDLE );
|
|
|
|
}
|
|
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
QueryContextAttributesA(
|
|
PCtxtHandle phContext, // Context to query
|
|
unsigned long ulAttribute, // Attribute to query
|
|
void SEC_FAR * pBuffer // Buffer for attributes
|
|
)
|
|
{
|
|
return( SEC_E_UNSUPPORTED_FUNCTION );
|
|
}
|
|
|
|
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
QueryContextAttributesW(
|
|
PCtxtHandle phContext, // Context to query
|
|
unsigned long ulAttribute, // Attribute to query
|
|
void SEC_FAR * pBuffer // Buffer for attributes
|
|
)
|
|
{
|
|
return( SEC_E_UNSUPPORTED_FUNCTION );
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PwdpCopyInfoW
|
|
//
|
|
// Synopsis: Helper - copy package info around
|
|
//
|
|
// Arguments: [ppPackageInfo] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
PwdpCopyInfoW(
|
|
PSecPkgInfoW * ppPackageInfo)
|
|
{
|
|
DWORD cbTotal;
|
|
PSecPkgInfoW pInfo;
|
|
PWSTR pszCopy;
|
|
|
|
cbTotal = sizeof(SecPkgInfoW) +
|
|
(wcslen(PwdInfoW.Name) + wcslen(PwdInfoW.Comment) + 2) * 2;
|
|
|
|
pInfo = PwdAlloc( cbTotal );
|
|
|
|
if (pInfo)
|
|
{
|
|
*pInfo = PwdInfoW;
|
|
|
|
pszCopy = (PWSTR) (pInfo + 1);
|
|
|
|
pInfo->Name = pszCopy;
|
|
|
|
wcscpy(pszCopy, PwdInfoW.Name);
|
|
|
|
pszCopy += wcslen(PwdInfoW.Name) + 1;
|
|
|
|
pInfo->Comment = pszCopy;
|
|
|
|
wcscpy(pszCopy, PwdInfoW.Comment);
|
|
|
|
*ppPackageInfo = pInfo;
|
|
|
|
return(SEC_E_OK);
|
|
|
|
}
|
|
|
|
return(SEC_E_INSUFFICIENT_MEMORY);
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PwdpCopyInfoA
|
|
//
|
|
// Synopsis: copy ansi package info around
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
PwdpCopyInfoA(
|
|
PSecPkgInfoA * ppPackageInfo)
|
|
{
|
|
DWORD cbTotal;
|
|
PSecPkgInfoA pInfo;
|
|
PSTR pszCopy;
|
|
|
|
cbTotal = sizeof(SecPkgInfoA) +
|
|
strlen(PwdInfoA.Name) + strlen(PwdInfoA.Comment) + 2;
|
|
|
|
pInfo = PwdAlloc( cbTotal );
|
|
|
|
if (pInfo)
|
|
{
|
|
*pInfo = PwdInfoA;
|
|
|
|
pszCopy = (PSTR) (pInfo + 1);
|
|
|
|
pInfo->Name = pszCopy;
|
|
|
|
strcpy(pszCopy, PwdInfoA.Name);
|
|
|
|
pszCopy += strlen(PwdInfoA.Name) + 1;
|
|
|
|
pInfo->Comment = pszCopy;
|
|
|
|
strcpy(pszCopy, PwdInfoA.Comment);
|
|
|
|
*ppPackageInfo = pInfo;
|
|
|
|
return(SEC_E_OK);
|
|
|
|
}
|
|
|
|
return(SEC_E_INSUFFICIENT_MEMORY);
|
|
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: EnumerateSecurityPackagesW
|
|
//
|
|
// Synopsis: Enumerate packages in this DLL
|
|
//
|
|
// Arguments: [pcPackages] --
|
|
// [info] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
EnumerateSecurityPackagesW(
|
|
unsigned long SEC_FAR * pcPackages, // Receives num. packages
|
|
PSecPkgInfoW SEC_FAR * ppPackageInfo // Receives array of info
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet;
|
|
|
|
*ppPackageInfo = NULL;
|
|
|
|
scRet = PwdpCopyInfoW(ppPackageInfo);
|
|
if (SUCCEEDED(scRet))
|
|
{
|
|
*pcPackages = 1;
|
|
return(scRet);
|
|
}
|
|
|
|
*pcPackages = 0;
|
|
|
|
return(scRet);
|
|
|
|
}
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: EnumerateSecurityPackagesA
|
|
//
|
|
// Synopsis: Enumerate
|
|
//
|
|
// Arguments: [pcPackages] --
|
|
// [info] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS SEC_ENTRY
|
|
EnumerateSecurityPackagesA(
|
|
unsigned long SEC_FAR * pcPackages, // Receives num. packages
|
|
PSecPkgInfoA SEC_FAR * ppPackageInfo // Receives array of info
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet;
|
|
|
|
*ppPackageInfo = NULL;
|
|
|
|
scRet = PwdpCopyInfoA(ppPackageInfo);
|
|
if (SUCCEEDED(scRet))
|
|
{
|
|
*pcPackages = 1;
|
|
return(scRet);
|
|
}
|
|
|
|
*pcPackages = 0;
|
|
|
|
return(scRet);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: QuerySecurityPackageInfoW
|
|
//
|
|
// Synopsis: Query individual package info
|
|
//
|
|
// Arguments: [pszPackageName] --
|
|
// [info] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS SEC_ENTRY
|
|
QuerySecurityPackageInfoW(
|
|
SEC_WCHAR SEC_FAR * pszPackageName, // Name of package
|
|
PSecPkgInfoW * ppPackageInfo // Receives package info
|
|
)
|
|
{
|
|
if (_wcsicmp(pszPackageName, PWDSSP_NAME_W))
|
|
{
|
|
return(SEC_E_SECPKG_NOT_FOUND);
|
|
}
|
|
|
|
return(PwdpCopyInfoW(ppPackageInfo));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: QuerySecurityPackageInfoA
|
|
//
|
|
// Synopsis: Same, ansi
|
|
//
|
|
// Arguments: [pszPackageName] --
|
|
// [info] --
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
SECURITY_STATUS SEC_ENTRY
|
|
QuerySecurityPackageInfoA(
|
|
SEC_CHAR SEC_FAR * pszPackageName, // Name of package
|
|
PSecPkgInfoA * ppPackageInfo // Receives package info
|
|
)
|
|
{
|
|
if (_stricmp(pszPackageName, PWDSSP_NAME_A))
|
|
{
|
|
return(SEC_E_SECPKG_NOT_FOUND);
|
|
}
|
|
|
|
return(PwdpCopyInfoA(ppPackageInfo));
|
|
}
|
|
|
|
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
MakeSignature(PCtxtHandle phContext,
|
|
DWORD fQOP,
|
|
PSecBufferDesc pMessage,
|
|
ULONG MessageSeqNo)
|
|
{
|
|
return(SEC_E_UNSUPPORTED_FUNCTION);
|
|
}
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
VerifySignature(PCtxtHandle phContext,
|
|
PSecBufferDesc pMessage,
|
|
ULONG MessageSeqNo,
|
|
DWORD * pfQOP)
|
|
{
|
|
return(SEC_E_UNSUPPORTED_FUNCTION);
|
|
}
|
|
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
SealMessage(PCtxtHandle phContext,
|
|
DWORD fQOP,
|
|
PSecBufferDesc pMessage,
|
|
ULONG MessageSeqNo)
|
|
{
|
|
return(SEC_E_UNSUPPORTED_FUNCTION);
|
|
}
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
UnsealMessage(PCtxtHandle phContext,
|
|
PSecBufferDesc pMessage,
|
|
ULONG MessageSeqNo,
|
|
DWORD * pfQOP)
|
|
{
|
|
return(SEC_E_UNSUPPORTED_FUNCTION);
|
|
}
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
ApplyControlToken(
|
|
PCtxtHandle phContext, // Context to modify
|
|
PSecBufferDesc pInput // Input token to apply
|
|
)
|
|
{
|
|
return( SEC_E_UNSUPPORTED_FUNCTION );
|
|
}
|
|
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
FreeContextBuffer(
|
|
PVOID p)
|
|
{
|
|
if( p != NULL )
|
|
{
|
|
PwdFree( p );
|
|
}
|
|
|
|
return( SEC_E_OK );
|
|
}
|
|
|
|
SECURITY_STATUS
|
|
SEC_ENTRY
|
|
QuerySecurityContextToken(
|
|
PCtxtHandle phContext,
|
|
PHANDLE Token)
|
|
{
|
|
PPWD_CONTEXT Context;
|
|
|
|
Context = (PPWD_CONTEXT) phContext->dwUpper ;
|
|
|
|
if ( Context->Tag == CONTEXT_TAG )
|
|
{
|
|
*Token = Context->Token ;
|
|
|
|
return( SEC_E_OK );
|
|
|
|
}
|
|
|
|
return( SEC_E_INVALID_HANDLE );
|
|
|
|
}
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
CompleteAuthToken(
|
|
PCtxtHandle phContext, // Context to complete
|
|
PSecBufferDesc pToken // Token to complete
|
|
)
|
|
{
|
|
return( SEC_E_UNSUPPORTED_FUNCTION );
|
|
}
|
|
|
|
|
|
PSecurityFunctionTableA
|
|
SEC_ENTRY
|
|
InitSecurityInterfaceA( VOID )
|
|
{
|
|
return( &PwdTableA );
|
|
}
|
|
|
|
PSecurityFunctionTableW
|
|
SEC_ENTRY
|
|
InitSecurityInterfaceW( VOID )
|
|
{
|
|
return( &PwdTableW );
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
VerifyCredentials(
|
|
IN PWSTR UserName,
|
|
IN PWSTR DomainName,
|
|
IN PWSTR Password,
|
|
IN ULONG VerifyFlags
|
|
)
|
|
{
|
|
PKERB_VERIFY_CREDENTIALS_REQUEST pVerifyRequest;
|
|
KERB_VERIFY_CREDENTIALS_REQUEST VerifyRequest;
|
|
|
|
ULONG cbVerifyRequest;
|
|
|
|
PVOID pResponse = NULL;
|
|
ULONG cbResponse;
|
|
|
|
USHORT cbUserName;
|
|
USHORT cbDomainName;
|
|
USHORT cbPassword;
|
|
|
|
NTSTATUS ProtocolStatus = STATUS_LOGON_FAILURE;
|
|
NTSTATUS Status;
|
|
|
|
cbUserName = (USHORT)(lstrlenW(UserName) * sizeof(WCHAR)) ;
|
|
cbDomainName = (USHORT)(lstrlenW(DomainName) * sizeof(WCHAR)) ;
|
|
cbPassword = (USHORT)(lstrlenW(Password) * sizeof(WCHAR)) ;
|
|
|
|
|
|
|
|
cbVerifyRequest = sizeof(VerifyRequest) +
|
|
cbUserName +
|
|
cbDomainName +
|
|
cbPassword ;
|
|
|
|
pVerifyRequest = &VerifyRequest;
|
|
ZeroMemory( &VerifyRequest, sizeof(VerifyRequest) );
|
|
|
|
|
|
pVerifyRequest->MessageType = KerbVerifyCredentialsMessage ;
|
|
|
|
//
|
|
// do the length, buffers, copy, marshall dance.
|
|
//
|
|
|
|
pVerifyRequest->UserName.Length = cbUserName;
|
|
pVerifyRequest->UserName.MaximumLength = cbUserName;
|
|
pVerifyRequest->UserName.Buffer = UserName;
|
|
|
|
pVerifyRequest->DomainName.Length = cbDomainName;
|
|
pVerifyRequest->DomainName.MaximumLength = cbDomainName;
|
|
pVerifyRequest->DomainName.Buffer = DomainName;
|
|
|
|
pVerifyRequest->Password.Length = cbPassword;
|
|
pVerifyRequest->Password.MaximumLength = cbPassword;
|
|
pVerifyRequest->Password.Buffer = Password;
|
|
|
|
pVerifyRequest->VerifyFlags = VerifyFlags;
|
|
|
|
Status = I_LsaICallPackage(
|
|
&AuthenticationPackage,
|
|
pVerifyRequest,
|
|
cbVerifyRequest,
|
|
&pResponse,
|
|
&cbResponse,
|
|
&ProtocolStatus
|
|
);
|
|
|
|
if(!NT_SUCCESS(Status))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
Status = ProtocolStatus;
|
|
|
|
Cleanup:
|
|
|
|
return Status;
|
|
}
|
|
|
|
|