mirror of https://github.com/lianthony/NT4.0
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.
812 lines
19 KiB
812 lines
19 KiB
//+-----------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (c) Microsoft Corporation 1992 - 1994
|
|
//
|
|
// File: stubs.cxx
|
|
//
|
|
// Contents: user-mode stubs for security API
|
|
//
|
|
//
|
|
// History: 3/5/94 MikeSw Created
|
|
//
|
|
//------------------------------------------------------------------------
|
|
#include "secdll.h"
|
|
|
|
SecurityFunctionTableW SecTableW = {SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION,
|
|
EnumerateSecurityPackagesW,
|
|
NULL,
|
|
AcquireCredentialsHandleW,
|
|
FreeCredentialsHandle,
|
|
NULL, // LogonUser
|
|
InitializeSecurityContextW,
|
|
AcceptSecurityContext,
|
|
CompleteAuthToken,
|
|
DeleteSecurityContext,
|
|
ApplyControlToken,
|
|
QueryContextAttributesW,
|
|
ImpersonateSecurityContext,
|
|
RevertSecurityContext,
|
|
MakeSignature,
|
|
VerifySignature,
|
|
FreeContextBuffer,
|
|
QuerySecurityPackageInfoW,
|
|
SealMessage,
|
|
UnsealMessage,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
QuerySecurityContextToken
|
|
};
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: InitSecurityInterfaceW
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
PSecurityFunctionTableW SEC_ENTRY
|
|
InitSecurityInterfaceW(VOID)
|
|
{
|
|
|
|
if (!NT_SUCCESS(InitializePackages()))
|
|
{
|
|
return(NULL);
|
|
}
|
|
return(&SecTableW);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: AcquireCredentialsHandleW
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
AcquireCredentialsHandleW(
|
|
LPWSTR pszPrincipal, // Name of principal
|
|
LPWSTR 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)
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet = SEC_E_OK;
|
|
PSecPkg pPackage;
|
|
|
|
scRet = InitializePackages();
|
|
if (!NT_SUCCESS(scRet))
|
|
{
|
|
return(scRet);
|
|
}
|
|
|
|
if (!pszPackageName)
|
|
{
|
|
return(SEC_E_SECPKG_NOT_FOUND);
|
|
}
|
|
|
|
if ((pPackage = LocatePackageW(pszPackageName)) == NULL)
|
|
{
|
|
return(SEC_E_SECPKG_NOT_FOUND);
|
|
}
|
|
|
|
scRet = pPackage->pftTableW->AcquireCredentialsHandleW(
|
|
pszPrincipal,
|
|
pszPackageName,
|
|
fCredentialUse,
|
|
pvLogonId,
|
|
pAuthData,
|
|
pGetKeyFn,
|
|
pvGetKeyArgument,
|
|
phCredential,
|
|
ptsExpiry);
|
|
|
|
//
|
|
// Only set the package id if it is not a builtin package.
|
|
//
|
|
|
|
if ((scRet == SEC_E_OK) &&
|
|
(pPackage->dwPackageID >= BuiltinPackageCount))
|
|
{
|
|
phCredential->dwLower = pPackage->dwPackageID;
|
|
}
|
|
return(scRet);
|
|
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: FreeCredentialsHandle
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
FreeCredentialsHandle(
|
|
PCredHandle phCredential // Handle to free
|
|
)
|
|
{
|
|
CredHandle TempCredHandle;
|
|
|
|
TempCredHandle.dwUpper = phCredential->dwUpper;
|
|
TempCredHandle.dwLower = pspPackages[phCredential->dwLower].dwOriginalPackageID;
|
|
return(pspPackages[phCredential->dwLower].pftTable->FreeCredentialHandle(&TempCredHandle));
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: InitializeSecurityContextW
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
InitializeSecurityContextW(
|
|
PCredHandle phCredential, // Cred to base context
|
|
PCtxtHandle phContext, // Existing context (OPT)
|
|
LPWSTR 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)
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet = SEC_E_OK;
|
|
CredHandle TempCredHandle;
|
|
CtxtHandle TempCtxtHandle;
|
|
ULONG PackageID, OriginalPackageID;
|
|
|
|
//
|
|
// They need to provide at least one of these two
|
|
//
|
|
|
|
if (!phCredential && !phContext)
|
|
{
|
|
return(SEC_E_INVALID_HANDLE);
|
|
}
|
|
|
|
|
|
//
|
|
// If the credential pointer is not NULL, figure out the package ID
|
|
// from it. Use that to find the original package ID. If this
|
|
// isn't a builtin package (which makes special use of the lower part)
|
|
// set the temp handle to be the same upper value with the original
|
|
// package ID for the lower handle value.
|
|
//
|
|
|
|
|
|
if (phCredential != NULL)
|
|
{
|
|
PackageID = phCredential->dwLower;
|
|
OriginalPackageID = pspPackages[PackageID].dwOriginalPackageID;
|
|
|
|
if (PackageID >= BuiltinPackageCount)
|
|
{
|
|
TempCredHandle.dwUpper = phCredential->dwUpper;
|
|
TempCredHandle.dwLower = OriginalPackageID;
|
|
|
|
if (phContext != NULL)
|
|
{
|
|
TempCtxtHandle.dwUpper = phContext->dwUpper;
|
|
TempCtxtHandle.dwLower = OriginalPackageID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TempCredHandle = *phCredential;
|
|
if (phContext != NULL)
|
|
{
|
|
TempCtxtHandle = *phContext;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The credential handle is NULL, so pick the values from the
|
|
// context handle
|
|
//
|
|
|
|
PackageID = phContext->dwLower;
|
|
OriginalPackageID = pspPackages[PackageID].dwOriginalPackageID;
|
|
|
|
TempCtxtHandle.dwUpper = phContext->dwUpper;
|
|
if (PackageID >= BuiltinPackageCount)
|
|
{
|
|
TempCtxtHandle.dwLower = OriginalPackageID;
|
|
}
|
|
else
|
|
{
|
|
TempCtxtHandle.dwLower = PackageID;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
scRet = pspPackages[PackageID].pftTableW->InitializeSecurityContextW(
|
|
(phCredential != NULL) ? &TempCredHandle : NULL,
|
|
(phContext != NULL) ? &TempCtxtHandle : NULL,
|
|
pszTargetName,
|
|
fContextReq,
|
|
Reserved1,
|
|
TargetDataRep,
|
|
pInput,
|
|
Reserved2,
|
|
phNewContext,
|
|
pOutput,
|
|
pfContextAttr,
|
|
ptsExpiry);
|
|
|
|
//
|
|
// Only set the lower part of the credential handle if we aren't
|
|
// dealing with builtin packages - they know what to do.
|
|
//
|
|
|
|
if (NT_SUCCESS(scRet) && (phNewContext) &&
|
|
(PackageID >= BuiltinPackageCount))
|
|
{
|
|
phNewContext->dwLower = PackageID;
|
|
}
|
|
|
|
|
|
return(scRet);
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: AcceptSecurityContext
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// 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)
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet = SEC_E_OK;
|
|
CredHandle TempCredHandle;
|
|
CtxtHandle TempCtxtHandle;
|
|
ULONG PackageID, OriginalPackageID;
|
|
|
|
//
|
|
// They need to provide at least one of these two
|
|
//
|
|
|
|
if (!phCredential && !phContext)
|
|
{
|
|
return(SEC_E_INVALID_HANDLE);
|
|
}
|
|
|
|
|
|
//
|
|
// If the credential pointer is not NULL, figure out the package ID
|
|
// from it. Use that to find the original package ID. If this
|
|
// isn't a builtin package (which makes special use of the lower part)
|
|
// set the temp handle to be the same upper value with the original
|
|
// package ID for the lower handle value.
|
|
//
|
|
|
|
|
|
if (phCredential != NULL)
|
|
{
|
|
PackageID = phCredential->dwLower;
|
|
OriginalPackageID = pspPackages[PackageID].dwOriginalPackageID;
|
|
|
|
|
|
if (PackageID >= BuiltinPackageCount)
|
|
{
|
|
TempCredHandle.dwUpper = phCredential->dwUpper;
|
|
TempCredHandle.dwLower = OriginalPackageID;
|
|
|
|
if (phContext != NULL)
|
|
{
|
|
TempCtxtHandle.dwUpper = phContext->dwUpper;
|
|
TempCtxtHandle.dwLower = OriginalPackageID;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TempCredHandle = *phCredential;
|
|
if (phContext != NULL)
|
|
{
|
|
TempCtxtHandle = *phContext;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// The credential handle is NULL, so pick the values from the
|
|
// context handle
|
|
//
|
|
|
|
PackageID = phContext->dwLower;
|
|
OriginalPackageID = pspPackages[PackageID].dwOriginalPackageID;
|
|
|
|
TempCtxtHandle.dwUpper = phContext->dwUpper;
|
|
TempCtxtHandle.dwLower = OriginalPackageID;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
scRet = pspPackages[PackageID].pftTable->AcceptSecurityContext(
|
|
(phCredential != NULL) ? &TempCredHandle : NULL,
|
|
(phContext != NULL) ? & TempCtxtHandle : NULL,
|
|
pInput,
|
|
fContextReq,
|
|
TargetDataRep,
|
|
phNewContext,
|
|
pOutput,
|
|
pfContextAttr,
|
|
ptsExpiry);
|
|
|
|
|
|
//
|
|
// Only set the lower part of the credential handle if we aren't
|
|
// dealing with builtin packages - they know what to do.
|
|
//
|
|
|
|
|
|
if (NT_SUCCESS(scRet) && (phNewContext) &&
|
|
(PackageID >= BuiltinPackageCount))
|
|
{
|
|
phNewContext->dwLower = PackageID;
|
|
}
|
|
|
|
return(scRet);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: DeleteSecurityContext
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
DeleteSecurityContext(
|
|
PCtxtHandle phContext // Context to delete
|
|
)
|
|
{
|
|
CtxtHandle TempCtxtHandle;
|
|
|
|
if (!phContext)
|
|
{
|
|
return(SEC_E_INVALID_HANDLE);
|
|
}
|
|
|
|
TempCtxtHandle.dwUpper = phContext->dwUpper;
|
|
TempCtxtHandle.dwLower = pspPackages[phContext->dwLower].dwOriginalPackageID;
|
|
|
|
return( pspPackages[phContext->dwLower].pftTable->DeleteSecurityContext(
|
|
&TempCtxtHandle));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: ApplyControlToken
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
ApplyControlToken(
|
|
PCtxtHandle phContext, // Context to modify
|
|
PSecBufferDesc pInput // Input token to apply
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet = SEC_E_OK;
|
|
CtxtHandle TempCtxtHandle;
|
|
|
|
|
|
if (!phContext)
|
|
{
|
|
return(SEC_E_INVALID_HANDLE);
|
|
}
|
|
|
|
TempCtxtHandle.dwUpper = phContext->dwUpper;
|
|
TempCtxtHandle.dwLower = pspPackages[phContext->dwLower].dwOriginalPackageID;
|
|
|
|
scRet = pspPackages[phContext->dwLower].pftTable->ApplyControlToken(
|
|
&TempCtxtHandle,
|
|
pInput);
|
|
|
|
|
|
return(scRet);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: EnumerateSecurityPackagesW
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// 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 = SEC_E_OK;
|
|
PSecPkgInfoW * ppTempPkgInfo = NULL;
|
|
PSecPkgInfoW pFinalPkgInfo = NULL;
|
|
ULONG cIndex;
|
|
ULONG cTempPackages;
|
|
ULONG cbFinalSize = 0;
|
|
PBYTE Where;
|
|
|
|
scRet = InitializePackages();
|
|
if (!NT_SUCCESS(scRet))
|
|
{
|
|
return(scRet);
|
|
}
|
|
|
|
//
|
|
// NOTE:
|
|
//
|
|
// Because the first two packages are actually the same one, we
|
|
// use the count of packages - 1 for enumerating. In addition,
|
|
// we start at 1 instead of zero for calling Enumerate, and subtact
|
|
// 1 for the index into the output buffers.
|
|
//
|
|
|
|
ppTempPkgInfo = (PSecPkgInfoW *) LocalAlloc(LMEM_ZEROINIT,
|
|
sizeof(PSecPkgInfoW) * (cPackages-1));
|
|
if (ppTempPkgInfo == NULL)
|
|
{
|
|
return(SEC_E_INSUFFICIENT_MEMORY);
|
|
}
|
|
|
|
//
|
|
// Loop through the packages and enumerate packages from each one
|
|
//
|
|
|
|
for ( cIndex = 1; cIndex < cPackages ; cIndex++ )
|
|
{
|
|
scRet = pspPackages[cIndex].pftTableW->QuerySecurityPackageInfoW(
|
|
pspPackages[cIndex].PackageNameW,
|
|
&ppTempPkgInfo[cIndex-1]);
|
|
|
|
//
|
|
// We require that each package return only 1 package
|
|
//
|
|
|
|
if (scRet != SEC_E_OK)
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
cbFinalSize += sizeof(SecPkgInfoW)
|
|
+ (wcslen(ppTempPkgInfo[cIndex-1]->Name) + 1) * sizeof(WCHAR)
|
|
+ (wcslen(ppTempPkgInfo[cIndex-1]->Comment) + 1) * sizeof(WCHAR);
|
|
|
|
}
|
|
|
|
//
|
|
// Copy the data into one buffer, so it can be freed with LocalFree.
|
|
//
|
|
|
|
pFinalPkgInfo = (PSecPkgInfoW) LocalAlloc(0,cbFinalSize);
|
|
if (pFinalPkgInfo == NULL)
|
|
{
|
|
scRet = SEC_E_INSUFFICIENT_MEMORY;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
|
|
Where = (cPackages - 1) * sizeof(SecPkgInfoW) + (PBYTE) pFinalPkgInfo;
|
|
|
|
for (cIndex = 0; cIndex < cPackages - 1 ; cIndex++ )
|
|
{
|
|
//
|
|
// First copy the whole structure
|
|
//
|
|
|
|
CopyMemory( &pFinalPkgInfo[cIndex],
|
|
ppTempPkgInfo[cIndex],
|
|
sizeof(SecPkgInfo));
|
|
|
|
//
|
|
// Now marshall the strings
|
|
//
|
|
|
|
pFinalPkgInfo[cIndex].Name = (LPWSTR) Where;
|
|
|
|
Where += (wcslen(ppTempPkgInfo[cIndex]->Name) + 1) * sizeof(WCHAR);
|
|
CopyMemory( pFinalPkgInfo[cIndex].Name,
|
|
ppTempPkgInfo[cIndex]->Name,
|
|
Where - (PBYTE) pFinalPkgInfo[cIndex].Name );
|
|
|
|
pFinalPkgInfo[cIndex].Comment = (LPWSTR) Where;
|
|
Where += (wcslen(ppTempPkgInfo[cIndex]->Comment) + 1) * sizeof(WCHAR);
|
|
CopyMemory( pFinalPkgInfo[cIndex].Comment,
|
|
ppTempPkgInfo[cIndex]->Comment,
|
|
Where - (PBYTE) pFinalPkgInfo[cIndex].Comment );
|
|
|
|
}
|
|
ASSERT(Where == (PBYTE) pFinalPkgInfo + cbFinalSize);
|
|
|
|
scRet = SEC_E_OK;
|
|
|
|
|
|
|
|
Cleanup:
|
|
|
|
//
|
|
// Clean up the temporary copy
|
|
//
|
|
|
|
if (ppTempPkgInfo != NULL)
|
|
{
|
|
for (cIndex = 0; cIndex < cPackages - 1 ; cIndex++ )
|
|
{
|
|
if (ppTempPkgInfo[cIndex] != NULL)
|
|
{
|
|
FreeContextBuffer(ppTempPkgInfo[cIndex]);
|
|
}
|
|
}
|
|
LocalFree(ppTempPkgInfo);
|
|
}
|
|
|
|
if (!NT_SUCCESS(scRet))
|
|
{
|
|
if (pFinalPkgInfo != NULL)
|
|
{
|
|
LocalFree(pFinalPkgInfo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*ppPackageInfo = pFinalPkgInfo;
|
|
*pcPackages = cPackages - 1;
|
|
}
|
|
|
|
return(scRet);
|
|
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: QuerySecurityPackageInfoW
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
QuerySecurityPackageInfoW(
|
|
LPWSTR pszPackageName, // Name of package
|
|
PSecPkgInfoW SEC_FAR * pPackageInfo // Receives package info
|
|
)
|
|
{
|
|
SECURITY_STATUS scRet;
|
|
PSecPkg pPackage;
|
|
|
|
scRet = InitializePackages();
|
|
if (!NT_SUCCESS(scRet))
|
|
{
|
|
return(scRet);
|
|
}
|
|
|
|
pPackage = LocatePackageW(pszPackageName);
|
|
if (pPackage == NULL)
|
|
{
|
|
return(SEC_E_SECPKG_NOT_FOUND);
|
|
}
|
|
|
|
|
|
scRet = pPackage->pftTableW->QuerySecurityPackageInfoW(
|
|
pszPackageName,
|
|
pPackageInfo
|
|
);
|
|
|
|
return(scRet);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: FreeContextBuffer
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SECURITY_STATUS SEC_ENTRY
|
|
FreeContextBuffer(
|
|
void SEC_FAR * pvContextBuffer
|
|
)
|
|
{
|
|
LocalFree(pvContextBuffer);
|
|
return(SEC_E_OK);
|
|
}
|