mirror of
https://github.com/reactos/reactos.git
synced 2024-10-30 11:35:58 +00:00
255 lines
9.7 KiB
C
255 lines
9.7 KiB
C
/*
|
|
* Schannel tests
|
|
*
|
|
* Copyright 2006 Yuval Fledel
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdarg.h>
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include <windef.h>
|
|
#include <winbase.h>
|
|
#define SECURITY_WIN32
|
|
#include <security.h>
|
|
#include <schannel.h>
|
|
#include <ntsecapi.h>
|
|
#include <ntsecpkg.h>
|
|
|
|
#include "wine/test.h"
|
|
|
|
/* Helper macros to find the size of SECPKG_FUNCTION_TABLE */
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_1 FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
|
|
SetContextAttributes)
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_2 FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
|
|
SetCredentialsAttributes)
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_3 FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
|
|
ChangeAccountPassword)
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_4 FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
|
|
QueryMetaData)
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_5 FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
|
|
ValidateTargetInfo)
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_6 FIELD_OFFSET(SECPKG_FUNCTION_TABLE, \
|
|
PostLogonUser)
|
|
#define SECPKG_FUNCTION_TABLE_SIZE_7 sizeof(SECPKG_FUNCTION_TABLE)
|
|
|
|
#define LSA_BASE_CAPS ( \
|
|
SECPKG_FLAG_INTEGRITY | \
|
|
SECPKG_FLAG_PRIVACY | \
|
|
SECPKG_FLAG_CONNECTION | \
|
|
SECPKG_FLAG_MULTI_REQUIRED | \
|
|
SECPKG_FLAG_EXTENDED_ERROR | \
|
|
SECPKG_FLAG_IMPERSONATION | \
|
|
SECPKG_FLAG_ACCEPT_WIN32_NAME | \
|
|
SECPKG_FLAG_STREAM | \
|
|
SECPKG_FLAG_MUTUAL_AUTH )
|
|
|
|
static NTSTATUS (NTAPI *pSpLsaModeInitialize)(ULONG, PULONG,
|
|
PSECPKG_FUNCTION_TABLE*, PULONG);
|
|
static NTSTATUS (NTAPI *pSpUserModeInitialize)(ULONG, PULONG,
|
|
PSECPKG_USER_FUNCTION_TABLE*, PULONG);
|
|
|
|
static void testInitialize(void)
|
|
{
|
|
PSECPKG_USER_FUNCTION_TABLE pUserTables, pUserTables2;
|
|
PSECPKG_FUNCTION_TABLE pTables, pTables2;
|
|
ULONG cTables = 0, cUserTables = 0, Version = 0;
|
|
NTSTATUS status;
|
|
|
|
/* Passing NULL into one of the parameters of SpLsaModeInitialize or
|
|
SpUserModeInitialize causes a crash. */
|
|
|
|
/* SpLsaModeInitialize does not care about the LSA version. */
|
|
status = pSpLsaModeInitialize(0, &Version, &pTables2, &cTables);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
ok(cTables == 2 ||
|
|
broken(cTables == 1), /* Win2k */
|
|
"cTables: %d\n", cTables);
|
|
ok(pTables2 != NULL,"pTables: %p\n", pTables2);
|
|
|
|
/* We can call it as many times we want. */
|
|
status = pSpLsaModeInitialize(0x10000, &Version, &pTables, &cTables);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
ok(cTables == 2 ||
|
|
broken(cTables == 1), /* Win2k */
|
|
"cTables: %d\n", cTables);
|
|
ok(pTables != NULL, "pTables: %p\n", pTables);
|
|
/* It will always return the same pointer. */
|
|
ok(pTables == pTables2, "pTables: %p, pTables2: %p\n", pTables, pTables2);
|
|
|
|
status = pSpLsaModeInitialize(0x23456, &Version, &pTables, &cTables);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
ok(cTables == 2 ||
|
|
broken(cTables == 1), /* Win2k */
|
|
"cTables: %d\n", cTables);
|
|
ok(pTables != NULL, "pTables: %p\n", pTables);
|
|
ok(pTables == pTables2, "pTables: %p, pTables2: %p\n", pTables, pTables2);
|
|
|
|
/* Bad versions to SpUserModeInitialize. Parameters unchanged */
|
|
Version = 0xdead;
|
|
cUserTables = 0xdead;
|
|
pUserTables = NULL;
|
|
status = pSpUserModeInitialize(0, &Version, &pUserTables, &cUserTables);
|
|
ok(status == STATUS_INVALID_PARAMETER, "status: 0x%x\n", status);
|
|
ok(Version == 0xdead, "Version: 0x%x\n", Version);
|
|
ok(cUserTables == 0xdead, "cTables: %d\n", cUserTables);
|
|
ok(pUserTables == NULL, "pUserTables: %p\n", pUserTables);
|
|
|
|
status = pSpUserModeInitialize(0x20000, &Version, &pUserTables,
|
|
&cUserTables);
|
|
ok(status == STATUS_INVALID_PARAMETER, "status: 0x%x\n", status);
|
|
ok(Version == 0xdead, "Version: 0x%x\n", Version);
|
|
ok(cUserTables == 0xdead, "cTables: %d\n", cUserTables);
|
|
ok(pUserTables == NULL, "pUserTables: %p\n", pUserTables);
|
|
|
|
/* Good version to SpUserModeInitialize */
|
|
status = pSpUserModeInitialize(SECPKG_INTERFACE_VERSION, &Version,
|
|
&pUserTables, &cUserTables);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
ok(Version == SECPKG_INTERFACE_VERSION, "Version: 0x%x\n", Version);
|
|
ok(cUserTables == 2 ||
|
|
broken(cUserTables == 4), /* Win2k */
|
|
"cUserTables: %d\n", cUserTables);
|
|
ok(pUserTables != NULL, "pUserTables: %p\n", pUserTables);
|
|
|
|
/* Initializing user again */
|
|
status = pSpUserModeInitialize(SECPKG_INTERFACE_VERSION, &Version,
|
|
&pUserTables2, &cTables);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
ok(pUserTables == pUserTables2, "pUserTables: %p, pUserTables2: %p\n",
|
|
pUserTables, pUserTables2);
|
|
}
|
|
|
|
/* A helper function to find the dispatch table of the next package.
|
|
Needed because SECPKG_FUNCTION_TABLE's size depend on the version */
|
|
static PSECPKG_FUNCTION_TABLE getNextSecPkgTable(PSECPKG_FUNCTION_TABLE pTable,
|
|
ULONG Version)
|
|
{
|
|
size_t size;
|
|
PSECPKG_FUNCTION_TABLE pNextTable;
|
|
|
|
if (Version == SECPKG_INTERFACE_VERSION)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_1;
|
|
else if (Version == SECPKG_INTERFACE_VERSION_2)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_2;
|
|
else if (Version == SECPKG_INTERFACE_VERSION_3)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_3;
|
|
else if (Version == SECPKG_INTERFACE_VERSION_4)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_4;
|
|
else if (Version == SECPKG_INTERFACE_VERSION_5)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_5;
|
|
else if (Version == SECPKG_INTERFACE_VERSION_6)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_6;
|
|
else if (Version == SECPKG_INTERFACE_VERSION_7)
|
|
size = SECPKG_FUNCTION_TABLE_SIZE_7;
|
|
else {
|
|
ok(FALSE, "Unknown package version 0x%x\n", Version);
|
|
return NULL;
|
|
}
|
|
|
|
pNextTable = (PSECPKG_FUNCTION_TABLE)((PBYTE)pTable + size);
|
|
/* Win7 function tables appear to be SECPKG_INTERFACE_VERSION_6 format,
|
|
but unfortunately SpLsaModeInitialize returns SECPKG_INTERFACE_VERSION_3.
|
|
We detect that by comparing the "Initialize" pointer from the old table
|
|
to the "FreeCredentialsHandle" pointer of the new table. These functions
|
|
have different numbers of arguments, so they can't possibly point to the
|
|
same implementation */
|
|
if (broken((void *) pTable->Initialize == (void *) pNextTable->FreeCredentialsHandle &&
|
|
pNextTable->FreeCredentialsHandle != NULL))
|
|
{
|
|
win_skip("Invalid function pointers for next package\n");
|
|
return NULL;
|
|
}
|
|
|
|
return pNextTable;
|
|
}
|
|
|
|
static void testGetInfo(void)
|
|
{
|
|
PSECPKG_FUNCTION_TABLE pTables;
|
|
SecPkgInfoW PackageInfo;
|
|
ULONG cTables, Version;
|
|
NTSTATUS status;
|
|
|
|
/* Get the dispatch table */
|
|
status = pSpLsaModeInitialize(0, &Version, &pTables, &cTables);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
|
|
/* Passing NULL into ->GetInfo causes a crash. */
|
|
|
|
/* First package: Unified */
|
|
status = pTables->GetInfo(&PackageInfo);
|
|
ok(status == STATUS_SUCCESS, "status: 0x%x\n", status);
|
|
ok(PackageInfo.fCapabilities == LSA_BASE_CAPS ||
|
|
PackageInfo.fCapabilities == (LSA_BASE_CAPS|SECPKG_FLAG_APPCONTAINER_PASSTHROUGH),
|
|
"fCapabilities: 0x%x\n", PackageInfo.fCapabilities);
|
|
ok(PackageInfo.wVersion == 1, "wVersion: %d\n", PackageInfo.wVersion);
|
|
ok(PackageInfo.wRPCID == 14, "wRPCID: %d\n", PackageInfo.wRPCID);
|
|
ok(PackageInfo.cbMaxToken == 0x4000 ||
|
|
PackageInfo.cbMaxToken == 0x6000, /* Vista */
|
|
"cbMaxToken: 0x%x\n",
|
|
PackageInfo.cbMaxToken);
|
|
|
|
/* Second package */
|
|
if (cTables == 1)
|
|
{
|
|
win_skip("Second package missing\n");
|
|
return;
|
|
}
|
|
pTables = getNextSecPkgTable(pTables, Version);
|
|
if (!pTables)
|
|
return;
|
|
status = pTables->GetInfo(&PackageInfo);
|
|
ok(status == STATUS_SUCCESS ||
|
|
status == SEC_E_UNSUPPORTED_FUNCTION, /* win2k3 */
|
|
"status: 0x%x\n", status);
|
|
|
|
if (status == STATUS_SUCCESS)
|
|
{
|
|
ok(PackageInfo.fCapabilities == LSA_BASE_CAPS ||
|
|
PackageInfo.fCapabilities == (LSA_BASE_CAPS|SECPKG_FLAG_APPCONTAINER_PASSTHROUGH),
|
|
"fCapabilities: 0x%x\n", PackageInfo.fCapabilities);
|
|
ok(PackageInfo.wVersion == 1, "wVersion: %d\n", PackageInfo.wVersion);
|
|
ok(PackageInfo.wRPCID == 14, "wRPCID: %d\n", PackageInfo.wRPCID);
|
|
ok(PackageInfo.cbMaxToken == 0x4000 ||
|
|
PackageInfo.cbMaxToken == 0x6000, /* Win7 */
|
|
"cbMaxToken: 0x%x\n",
|
|
PackageInfo.cbMaxToken);
|
|
}
|
|
}
|
|
|
|
START_TEST(main)
|
|
{
|
|
HMODULE hMod = LoadLibraryA("schannel.dll");
|
|
if (!hMod) {
|
|
win_skip("schannel.dll not available\n");
|
|
return;
|
|
}
|
|
|
|
pSpLsaModeInitialize = (void *)GetProcAddress(hMod, "SpLsaModeInitialize");
|
|
pSpUserModeInitialize = (void *)GetProcAddress(hMod, "SpUserModeInitialize");
|
|
|
|
if (pSpLsaModeInitialize && pSpUserModeInitialize)
|
|
{
|
|
testInitialize();
|
|
testGetInfo();
|
|
}
|
|
else win_skip( "schannel functions not found\n" );
|
|
|
|
FreeLibrary(hMod);
|
|
}
|