dlls/secur32/tests/secur32.c - wine - Git at Google

 /*
  * tests
  *
  * Copyright 2006 Robert Reif
  *
  * 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 <windef.h>
 #include <winbase.h>
 #include <winnls.h>
 #include <rpc.h>
 #include <rpcdce.h>
 #define SECURITY_WIN32
 #include <security.h>
 #include <schannel.h>
 #include <wincred.h>

 #include "wine/test.h"

 static HMODULE secdll;

 static SECURITY_STATUS (SEC_ENTRY *pSspiEncodeAuthIdentityAsStrings)
     (PSEC_WINNT_AUTH_IDENTITY_OPAQUE, PCWSTR *, PCWSTR *, PCWSTR *);
 static SECURITY_STATUS (SEC_ENTRY *pSspiEncodeStringsAsAuthIdentity)
     (PCWSTR, PCWSTR, PCWSTR, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *);
 static void (SEC_ENTRY *pSspiFreeAuthIdentity)
     (PSEC_WINNT_AUTH_IDENTITY_OPAQUE);
 static void (SEC_ENTRY *pSspiLocalFree)
     (void *);
 static SECURITY_STATUS (SEC_ENTRY *pSspiPrepareForCredWrite)
     (PSEC_WINNT_AUTH_IDENTITY_OPAQUE, PCWSTR, PULONG, PCWSTR *, PCWSTR *, PUCHAR *, PULONG);
 static void (SEC_ENTRY *pSspiZeroAuthIdentity)
     (PSEC_WINNT_AUTH_IDENTITY_OPAQUE);

 static BOOLEAN (WINAPI * pGetComputerObjectNameA)(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG lpnSize);
 static BOOLEAN (WINAPI * pGetComputerObjectNameW)(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG lpnSize);
 static BOOLEAN (WINAPI * pGetUserNameExA)(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG lpnSize);
 static BOOLEAN (WINAPI * pGetUserNameExW)(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG lpnSize);
 static PSecurityFunctionTableA (SEC_ENTRY * pInitSecurityInterfaceA)(void);
 static PSecurityFunctionTableW (SEC_ENTRY * pInitSecurityInterfaceW)(void);

 static EXTENDED_NAME_FORMAT formats[] = {
     NameUnknown, NameFullyQualifiedDN, NameSamCompatible, NameDisplay,
     NameUniqueId, NameCanonical, NameUserPrincipal, NameCanonicalEx,
     NameServicePrincipal, NameDnsDomain
 };

 static void testGetComputerObjectNameA(void)
 {
     char name[256];
     ULONG size;
     BOOLEAN rc;
     UINT i;

     for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
         size = sizeof(name);
         ZeroMemory(name, sizeof(name));
         rc = pGetComputerObjectNameA(formats[i], name, &size);
         ok(rc || ((formats[i] == NameUnknown) &&
            (GetLastError() == ERROR_INVALID_PARAMETER)) ||
            (GetLastError() == ERROR_CANT_ACCESS_DOMAIN_INFO) ||
            (GetLastError() == ERROR_NO_SUCH_DOMAIN) ||
            (GetLastError() == ERROR_NO_SUCH_USER) ||
            (GetLastError() == ERROR_NONE_MAPPED) ||
            (GetLastError() == ERROR_ACCESS_DENIED),
            "GetComputerObjectNameA(%d) failed: %d\n",
            formats[i], GetLastError());
         if (rc)
             trace("GetComputerObjectNameA() returned %s\n", name);
     }
 }

 static void testGetComputerObjectNameW(void)
 {
     WCHAR nameW[256];
     ULONG size;
     BOOLEAN rc;
     UINT i;

     for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
         size = sizeof(nameW)/sizeof(nameW[0]);
         ZeroMemory(nameW, sizeof(nameW));
         rc = pGetComputerObjectNameW(formats[i], nameW, &size);
         ok(rc || ((formats[i] == NameUnknown) &&
            (GetLastError() == ERROR_INVALID_PARAMETER)) ||
            (GetLastError() == ERROR_CANT_ACCESS_DOMAIN_INFO) ||
            (GetLastError() == ERROR_NO_SUCH_DOMAIN) ||
            (GetLastError() == ERROR_NO_SUCH_USER) ||
            (GetLastError() == ERROR_NONE_MAPPED) ||
            (GetLastError() == ERROR_ACCESS_DENIED),
            "GetComputerObjectNameW(%d) failed: %d\n",
            formats[i], GetLastError());
         if (rc) {
             char name[256];
             WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, sizeof(name), NULL, NULL );
             trace("GetComputerObjectNameW() returned %s\n", name);
         }
     }
 }

 static void testGetUserNameExA(void)
 {
     char name[256];
     ULONG size;
     BOOLEAN rc;
     UINT i;

     for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
         size = sizeof(name);
         ZeroMemory(name, sizeof(name));
         rc = pGetUserNameExA(formats[i], name, &size);
         ok(rc ||
            (formats[i] == NameUnknown &&
             GetLastError() == ERROR_NO_SUCH_USER) ||
            GetLastError() == ERROR_NONE_MAPPED ||
            broken(formats[i] == NameDnsDomain &&
                   GetLastError() == ERROR_INVALID_PARAMETER),
            "GetUserNameExW(%d) failed: %d\n",
            formats[i], GetLastError());
     }

     if (0) /* Crashes on Windows */
         pGetUserNameExA(NameSamCompatible, NULL, NULL);

     size = 0;
     rc = pGetUserNameExA(NameSamCompatible, NULL, &size);
     ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
     ok(size != 0, "Expected size to be set to required size\n");

     if (0) /* Crashes on Windows with big enough size */
     {
         /* Returned size is already big enough */
         pGetUserNameExA(NameSamCompatible, NULL, &size);
     }

     size = 0;
     rc = pGetUserNameExA(NameSamCompatible, name, &size);
     ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
     ok(size != 0, "Expected size to be set to required size\n");
     size = 1;
     name[0] = 0xff;
     rc = pGetUserNameExA(NameSamCompatible, name, &size);
     ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
     ok(1 < size, "Expected size to be set to required size\n");
     ok(name[0] == (char) 0xff, "Expected unchanged buffer\n");
 }

 static void testGetUserNameExW(void)
 {
     WCHAR nameW[256];
     ULONG size;
     BOOLEAN rc;
     UINT i;

     for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
         size = sizeof(nameW);
         ZeroMemory(nameW, sizeof(nameW));
         rc = pGetUserNameExW(formats[i], nameW, &size);
         ok(rc ||
            (formats[i] == NameUnknown &&
             GetLastError() == ERROR_NO_SUCH_USER) ||
            GetLastError() == ERROR_NONE_MAPPED ||
            broken(formats[i] == NameDnsDomain &&
                   GetLastError() == ERROR_INVALID_PARAMETER),
            "GetUserNameExW(%d) failed: %d\n",
            formats[i], GetLastError());
     }

     if (0) /* Crashes on Windows */
         pGetUserNameExW(NameSamCompatible, NULL, NULL);

     size = 0;
     rc = pGetUserNameExW(NameSamCompatible, NULL, &size);
     ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
     ok(size != 0, "Expected size to be set to required size\n");

     if (0) /* Crashes on Windows with big enough size */
     {
         /* Returned size is already big enough */
         pGetUserNameExW(NameSamCompatible, NULL, &size);
     }

     size = 0;
     rc = pGetUserNameExW(NameSamCompatible, nameW, &size);
     ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
     ok(size != 0, "Expected size to be set to required size\n");
     size = 1;
     nameW[0] = 0xff;
     rc = pGetUserNameExW(NameSamCompatible, nameW, &size);
     ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
     ok(1 < size, "Expected size to be set to required size\n");
     ok(nameW[0] == (WCHAR) 0xff, "Expected unchanged buffer\n");
 }

 static void test_InitSecurityInterface(void)
 {
     PSecurityFunctionTableA sftA;
     PSecurityFunctionTableW sftW;

     sftA = pInitSecurityInterfaceA();
     ok(sftA != NULL, "pInitSecurityInterfaceA failed\n");
     ok(sftA->dwVersion == SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION, "wrong dwVersion %d in security function table\n", sftA->dwVersion);
     ok(!sftA->Reserved2,
        "Reserved2 should be NULL instead of %p in security function table\n",
        sftA->Reserved2);
     ok(sftA->Reserved3 == sftA->EncryptMessage,
        "Reserved3 should be equal to EncryptMessage in the security function table\n");
     ok(sftA->Reserved4 == sftA->DecryptMessage,
        "Reserved4 should be equal to DecryptMessage in the security function table\n");

     if (!pInitSecurityInterfaceW)
     {
         win_skip("InitSecurityInterfaceW not exported by secur32.dll\n");
         return;
     }

     sftW = pInitSecurityInterfaceW();
     ok(sftW != NULL, "pInitSecurityInterfaceW failed\n");
     ok(sftW->dwVersion == SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION, "wrong dwVersion %d in security function table\n", sftW->dwVersion);
     ok(!sftW->Reserved2, "Reserved2 should be NULL instead of %p in security function table\n", sftW->Reserved2);
     ok(sftW->Reserved3 == sftW->EncryptMessage, "Reserved3 should be equal to EncryptMessage in the security function table\n");
     ok(sftW->Reserved4 == sftW->DecryptMessage, "Reserved4 should be equal to DecryptMessage in the security function table\n");
 }

 static void test_SspiEncodeStringsAsAuthIdentity(void)
 {
     static const WCHAR username[] = {'u','s','e','r','n','a','m','e',0};
     static const WCHAR domainname[] = {'d','o','m','a','i','n','n','a','m','e',0};
     static const WCHAR password[] = {'p','a','s','s','w','o','r','d',0};
     const WCHAR *username_ptr, *domainname_ptr, *password_ptr;
     PSEC_WINNT_AUTH_IDENTITY_OPAQUE id;
     SECURITY_STATUS status;

     if (!pSspiEncodeStringsAsAuthIdentity)
     {
         win_skip( "SspiEncodeAuthIdentityAsStrings not exported by secur32.dll\n" );
         return;
     }

     status = pSspiEncodeStringsAsAuthIdentity( NULL, NULL, NULL, NULL );
     ok( status == SEC_E_INVALID_TOKEN, "got %08x\n", status );

     id = (PSEC_WINNT_AUTH_IDENTITY_OPAQUE)0xdeadbeef;
     status = pSspiEncodeStringsAsAuthIdentity( NULL, NULL, NULL, &id );
     ok( status == SEC_E_INVALID_TOKEN, "got %08x\n", status );
     ok( id == (PSEC_WINNT_AUTH_IDENTITY_OPAQUE)0xdeadbeef, "id set\n" );

     id = NULL;
     status = pSspiEncodeStringsAsAuthIdentity( NULL, NULL, password, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( id != NULL, "id not set\n" );
     pSspiFreeAuthIdentity( id );

     id = NULL;
     status = pSspiEncodeStringsAsAuthIdentity( NULL, domainname, password, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( id != NULL, "id not set\n" );
     pSspiFreeAuthIdentity( id );

     id = NULL;
     status = pSspiEncodeStringsAsAuthIdentity( username, NULL, password, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( id != NULL, "id not set\n" );
     pSspiFreeAuthIdentity( id );

     id = NULL;
     status = pSspiEncodeStringsAsAuthIdentity( username, NULL, NULL, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( id != NULL, "id not set\n" );
     pSspiFreeAuthIdentity( id );

     id = NULL;
     status = pSspiEncodeStringsAsAuthIdentity( username, domainname, password, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( id != NULL, "id not set\n" );

     username_ptr = domainname_ptr = password_ptr = NULL;
     status = pSspiEncodeAuthIdentityAsStrings( id, &username_ptr, &domainname_ptr, &password_ptr );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( !lstrcmpW( username, username_ptr ), "wrong username\n" );
     ok( !lstrcmpW( domainname, domainname_ptr ), "wrong domainname\n" );
     ok( !lstrcmpW( password, password_ptr ), "wrong password\n" );

     pSspiZeroAuthIdentity( id );

     pSspiLocalFree( (void *)username_ptr );
     pSspiLocalFree( (void *)domainname_ptr );
     pSspiLocalFree( (void *)password_ptr );
     pSspiFreeAuthIdentity( id );

     id = NULL;
     status = pSspiEncodeStringsAsAuthIdentity( username, NULL, password, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( id != NULL, "id not set\n" );

     username_ptr = password_ptr = NULL;
     domainname_ptr = (const WCHAR *)0xdeadbeef;
     status = pSspiEncodeAuthIdentityAsStrings( id, &username_ptr, &domainname_ptr, &password_ptr );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( !lstrcmpW( username, username_ptr ), "wrong username\n" );
     ok( domainname_ptr == NULL, "domainname_ptr not cleared\n" );
     ok( !lstrcmpW( password, password_ptr ), "wrong password\n" );

     pSspiLocalFree( (void *)username_ptr );
     pSspiLocalFree( (void *)password_ptr );
     pSspiFreeAuthIdentity( id );
 }

 static void test_SspiPrepareForCredWrite(void)
 {
     static const WCHAR usernameW[] =
         {'u','s','e','r','n','a','m','e',0};
     static const WCHAR domainnameW[] =
         {'d','o','m','a','i','n','n','a','m','e',0};
     static const WCHAR passwordW[] =
         {'p','a','s','s','w','o','r','d',0};
     static const WCHAR targetW[] =
         {'d','o','m','a','i','n','n','a','m','e','\\','u','s','e','r','n','a','m','e',0};
     static const WCHAR target2W[] =
         {'d','o','m','a','i','n','n','a','m','e','2','\\','u','s','e','r','n','a','m','e','2',0};
     const WCHAR *target, *username;
     PSEC_WINNT_AUTH_IDENTITY_OPAQUE id;
     SECURITY_STATUS status;
     ULONG type, size;
     UCHAR *blob;

     if (!pSspiPrepareForCredWrite)
     {
         win_skip( "SspiPrepareForCredWrite not exported by secur32.dll\n" );
         return;
     }

     status = pSspiEncodeStringsAsAuthIdentity( usernameW, domainnameW, passwordW, &id );
     ok( status == SEC_E_OK, "got %08x\n", status );

     type = size = 0;
     status = pSspiPrepareForCredWrite( id, NULL, &type, &target, &username, &blob, &size );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( type == CRED_TYPE_DOMAIN_PASSWORD, "got %u\n", type );
     ok( !lstrcmpW( target, targetW ), "got %s\n", wine_dbgstr_w(target) );
     ok( !lstrcmpW( username, targetW ), "got %s\n", wine_dbgstr_w(username) );
     ok( !memcmp( blob, passwordW, sizeof(passwordW) - sizeof(WCHAR) ), "wrong data\n" );
     ok( size == sizeof(passwordW) - sizeof(WCHAR), "got %u\n", size );
     pSspiLocalFree( (void *)target );
     pSspiLocalFree( (void *)username );
     pSspiLocalFree( blob );

     type = size = 0;
     status = pSspiPrepareForCredWrite( id, target2W, &type, &target, &username, &blob, &size );
     ok( status == SEC_E_OK, "got %08x\n", status );
     ok( type == CRED_TYPE_DOMAIN_PASSWORD, "got %u\n", type );
     ok( !lstrcmpW( target, target2W ), "got %s\n", wine_dbgstr_w(target) );
     ok( !lstrcmpW( username, targetW ), "got %s\n", wine_dbgstr_w(username) );
     ok( !memcmp( blob, passwordW, sizeof(passwordW) - sizeof(WCHAR) ), "wrong data\n" );
     ok( size == sizeof(passwordW) - sizeof(WCHAR), "got %u\n", size );
     pSspiLocalFree( (void *)target );
     pSspiLocalFree( (void *)username );
     pSspiLocalFree( blob );

     pSspiFreeAuthIdentity( id );
 }

 static void test_kerberos(void)
 {
     SecPkgInfoA *info;
     TimeStamp ttl;
     CredHandle cred;
     SECURITY_STATUS status;

     SEC_CHAR provider[] = {'K','e','r','b','e','r','o','s',0};

     static const ULONG expected_flags =
           SECPKG_FLAG_INTEGRITY
         | SECPKG_FLAG_PRIVACY
         | SECPKG_FLAG_TOKEN_ONLY
         | SECPKG_FLAG_DATAGRAM
         | SECPKG_FLAG_CONNECTION
         | SECPKG_FLAG_MULTI_REQUIRED
         | SECPKG_FLAG_EXTENDED_ERROR
         | SECPKG_FLAG_IMPERSONATION
         | SECPKG_FLAG_ACCEPT_WIN32_NAME
         | SECPKG_FLAG_NEGOTIABLE
         | SECPKG_FLAG_GSS_COMPATIBLE
         | SECPKG_FLAG_LOGON
         | SECPKG_FLAG_MUTUAL_AUTH
         | SECPKG_FLAG_DELEGATION
         | SECPKG_FLAG_READONLY_WITH_CHECKSUM;
     static const ULONG optional_mask =
           SECPKG_FLAG_RESTRICTED_TOKENS
         | SECPKG_FLAG_APPCONTAINER_CHECKS;

     status = QuerySecurityPackageInfoA(provider, &info);
     ok(status == SEC_E_OK, "Kerberos package not installed, skipping test\n");
     if(status != SEC_E_OK)
         return;

     ok( (info->fCapabilities & ~optional_mask) == expected_flags, "got %08x, expected %08x\n", info->fCapabilities, expected_flags );
     ok( info->wVersion == 1, "got %u\n", info->wVersion );
     ok( info->wRPCID == RPC_C_AUTHN_GSS_KERBEROS, "got %u\n", info->wRPCID );
     ok( info->cbMaxToken >= 12000, "got %u\n", info->cbMaxToken );
     ok( !lstrcmpA( info->Name, "Kerberos" ), "got %s\n", info->Name );
     ok( !lstrcmpA( info->Comment, "Microsoft Kerberos V1.0" ), "got %s\n", info->Comment );
     FreeContextBuffer( info );

     status = AcquireCredentialsHandleA( NULL, provider, SECPKG_CRED_OUTBOUND, NULL,
                                         NULL, NULL, NULL, &cred, &ttl );
     todo_wine ok( status == SEC_E_OK, "AcquireCredentialsHandleA returned %08x\n", status );
     if(status == SEC_E_OK)
         FreeCredentialHandle( &cred );
 }

 START_TEST(secur32)
 {
     secdll = LoadLibraryA("secur32.dll");

     if (!secdll)
         secdll = LoadLibraryA("security.dll");

     if (secdll)
     {
         pSspiEncodeAuthIdentityAsStrings = (void *)GetProcAddress(secdll, "SspiEncodeAuthIdentityAsStrings");
         pSspiEncodeStringsAsAuthIdentity = (void *)GetProcAddress(secdll, "SspiEncodeStringsAsAuthIdentity");
         pSspiFreeAuthIdentity = (void *)GetProcAddress(secdll, "SspiFreeAuthIdentity");
         pSspiLocalFree = (void *)GetProcAddress(secdll, "SspiLocalFree");
         pSspiPrepareForCredWrite = (void *)GetProcAddress(secdll, "SspiPrepareForCredWrite");
         pSspiZeroAuthIdentity = (void *)GetProcAddress(secdll, "SspiZeroAuthIdentity");
         pGetComputerObjectNameA = (PVOID)GetProcAddress(secdll, "GetComputerObjectNameA");
         pGetComputerObjectNameW = (PVOID)GetProcAddress(secdll, "GetComputerObjectNameW");
         pGetUserNameExA = (PVOID)GetProcAddress(secdll, "GetUserNameExA");
         pGetUserNameExW = (PVOID)GetProcAddress(secdll, "GetUserNameExW");
         pInitSecurityInterfaceA = (PVOID)GetProcAddress(secdll, "InitSecurityInterfaceA");
         pInitSecurityInterfaceW = (PVOID)GetProcAddress(secdll, "InitSecurityInterfaceW");

         if (pGetComputerObjectNameA)
             testGetComputerObjectNameA();
         else
             win_skip("GetComputerObjectNameA not exported by secur32.dll\n");

         if (pGetComputerObjectNameW)
             testGetComputerObjectNameW();
         else
             win_skip("GetComputerObjectNameW not exported by secur32.dll\n");

         if (pGetUserNameExA)
             testGetUserNameExA();
         else
             win_skip("GetUserNameExA not exported by secur32.dll\n");

         if (pGetUserNameExW)
             testGetUserNameExW();
         else
             win_skip("GetUserNameExW not exported by secur32.dll\n");

         test_InitSecurityInterface();
         test_SspiEncodeStringsAsAuthIdentity();
         test_SspiPrepareForCredWrite();

         FreeLibrary(secdll);
     }

     test_kerberos();
 }
	/*
	* tests
	*
	* Copyright 2006 Robert Reif
	*
	* 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 <windef.h>
	#include <winbase.h>
	#include <winnls.h>
	#include <rpc.h>
	#include <rpcdce.h>
	#define SECURITY_WIN32
	#include <security.h>
	#include <schannel.h>
	#include <wincred.h>

	#include "wine/test.h"

	static HMODULE secdll;

	static SECURITY_STATUS (SEC_ENTRY *pSspiEncodeAuthIdentityAsStrings)
	(PSEC_WINNT_AUTH_IDENTITY_OPAQUE, PCWSTR , PCWSTR , PCWSTR *);
	static SECURITY_STATUS (SEC_ENTRY *pSspiEncodeStringsAsAuthIdentity)
	(PCWSTR, PCWSTR, PCWSTR, PSEC_WINNT_AUTH_IDENTITY_OPAQUE *);
	static void (SEC_ENTRY *pSspiFreeAuthIdentity)
	(PSEC_WINNT_AUTH_IDENTITY_OPAQUE);
	static void (SEC_ENTRY *pSspiLocalFree)
	(void *);
	static SECURITY_STATUS (SEC_ENTRY *pSspiPrepareForCredWrite)
	(PSEC_WINNT_AUTH_IDENTITY_OPAQUE, PCWSTR, PULONG, PCWSTR , PCWSTR , PUCHAR *, PULONG);
	static void (SEC_ENTRY *pSspiZeroAuthIdentity)
	(PSEC_WINNT_AUTH_IDENTITY_OPAQUE);

	static BOOLEAN (WINAPI * pGetComputerObjectNameA)(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG lpnSize);
	static BOOLEAN (WINAPI * pGetComputerObjectNameW)(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG lpnSize);
	static BOOLEAN (WINAPI * pGetUserNameExA)(EXTENDED_NAME_FORMAT NameFormat, LPSTR lpNameBuffer, PULONG lpnSize);
	static BOOLEAN (WINAPI * pGetUserNameExW)(EXTENDED_NAME_FORMAT NameFormat, LPWSTR lpNameBuffer, PULONG lpnSize);
	static PSecurityFunctionTableA (SEC_ENTRY * pInitSecurityInterfaceA)(void);
	static PSecurityFunctionTableW (SEC_ENTRY * pInitSecurityInterfaceW)(void);

	static EXTENDED_NAME_FORMAT formats[] = {
	NameUnknown, NameFullyQualifiedDN, NameSamCompatible, NameDisplay,
	NameUniqueId, NameCanonical, NameUserPrincipal, NameCanonicalEx,
	NameServicePrincipal, NameDnsDomain
	};

	static void testGetComputerObjectNameA(void)
	{
	char name[256];
	ULONG size;
	BOOLEAN rc;
	UINT i;

	for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
	size = sizeof(name);
	ZeroMemory(name, sizeof(name));
	rc = pGetComputerObjectNameA(formats[i], name, &size);
	ok(rc \|\| ((formats[i] == NameUnknown) &&
	(GetLastError() == ERROR_INVALID_PARAMETER)) \|\|
	(GetLastError() == ERROR_CANT_ACCESS_DOMAIN_INFO) \|\|
	(GetLastError() == ERROR_NO_SUCH_DOMAIN) \|\|
	(GetLastError() == ERROR_NO_SUCH_USER) \|\|
	(GetLastError() == ERROR_NONE_MAPPED) \|\|
	(GetLastError() == ERROR_ACCESS_DENIED),
	"GetComputerObjectNameA(%d) failed: %d\n",
	formats[i], GetLastError());
	if (rc)
	trace("GetComputerObjectNameA() returned %s\n", name);
	}
	}

	static void testGetComputerObjectNameW(void)
	{
	WCHAR nameW[256];
	ULONG size;
	BOOLEAN rc;
	UINT i;

	for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
	size = sizeof(nameW)/sizeof(nameW[0]);
	ZeroMemory(nameW, sizeof(nameW));
	rc = pGetComputerObjectNameW(formats[i], nameW, &size);
	ok(rc \|\| ((formats[i] == NameUnknown) &&
	(GetLastError() == ERROR_INVALID_PARAMETER)) \|\|
	(GetLastError() == ERROR_CANT_ACCESS_DOMAIN_INFO) \|\|
	(GetLastError() == ERROR_NO_SUCH_DOMAIN) \|\|
	(GetLastError() == ERROR_NO_SUCH_USER) \|\|
	(GetLastError() == ERROR_NONE_MAPPED) \|\|
	(GetLastError() == ERROR_ACCESS_DENIED),
	"GetComputerObjectNameW(%d) failed: %d\n",
	formats[i], GetLastError());
	if (rc) {
	char name[256];
	WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, sizeof(name), NULL, NULL );
	trace("GetComputerObjectNameW() returned %s\n", name);
	}
	}
	}

	static void testGetUserNameExA(void)
	{
	char name[256];
	ULONG size;
	BOOLEAN rc;
	UINT i;

	for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
	size = sizeof(name);
	ZeroMemory(name, sizeof(name));
	rc = pGetUserNameExA(formats[i], name, &size);
	ok(rc \|\|
	(formats[i] == NameUnknown &&
	GetLastError() == ERROR_NO_SUCH_USER) \|\|
	GetLastError() == ERROR_NONE_MAPPED \|\|
	broken(formats[i] == NameDnsDomain &&
	GetLastError() == ERROR_INVALID_PARAMETER),
	"GetUserNameExW(%d) failed: %d\n",
	formats[i], GetLastError());
	}

	if (0) /* Crashes on Windows */
	pGetUserNameExA(NameSamCompatible, NULL, NULL);

	size = 0;
	rc = pGetUserNameExA(NameSamCompatible, NULL, &size);
	ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
	ok(size != 0, "Expected size to be set to required size\n");

	if (0) /* Crashes on Windows with big enough size */
	{
	/* Returned size is already big enough */
	pGetUserNameExA(NameSamCompatible, NULL, &size);
	}

	size = 0;
	rc = pGetUserNameExA(NameSamCompatible, name, &size);
	ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
	ok(size != 0, "Expected size to be set to required size\n");
	size = 1;
	name[0] = 0xff;
	rc = pGetUserNameExA(NameSamCompatible, name, &size);
	ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
	ok(1 < size, "Expected size to be set to required size\n");
	ok(name[0] == (char) 0xff, "Expected unchanged buffer\n");
	}

	static void testGetUserNameExW(void)
	{
	WCHAR nameW[256];
	ULONG size;
	BOOLEAN rc;
	UINT i;

	for (i = 0; i < (sizeof(formats) / sizeof(formats[0])); i++) {
	size = sizeof(nameW);
	ZeroMemory(nameW, sizeof(nameW));
	rc = pGetUserNameExW(formats[i], nameW, &size);
	ok(rc \|\|
	(formats[i] == NameUnknown &&
	GetLastError() == ERROR_NO_SUCH_USER) \|\|
	GetLastError() == ERROR_NONE_MAPPED \|\|
	broken(formats[i] == NameDnsDomain &&
	GetLastError() == ERROR_INVALID_PARAMETER),
	"GetUserNameExW(%d) failed: %d\n",
	formats[i], GetLastError());
	}

	if (0) /* Crashes on Windows */
	pGetUserNameExW(NameSamCompatible, NULL, NULL);

	size = 0;
	rc = pGetUserNameExW(NameSamCompatible, NULL, &size);
	ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
	ok(size != 0, "Expected size to be set to required size\n");

	if (0) /* Crashes on Windows with big enough size */
	{
	/* Returned size is already big enough */
	pGetUserNameExW(NameSamCompatible, NULL, &size);
	}

	size = 0;
	rc = pGetUserNameExW(NameSamCompatible, nameW, &size);
	ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
	ok(size != 0, "Expected size to be set to required size\n");
	size = 1;
	nameW[0] = 0xff;
	rc = pGetUserNameExW(NameSamCompatible, nameW, &size);
	ok(! rc && GetLastError() == ERROR_MORE_DATA, "Expected fail with ERROR_MORE_DATA, got %d with %u\n", rc, GetLastError());
	ok(1 < size, "Expected size to be set to required size\n");
	ok(nameW[0] == (WCHAR) 0xff, "Expected unchanged buffer\n");
	}

	static void test_InitSecurityInterface(void)
	{
	PSecurityFunctionTableA sftA;
	PSecurityFunctionTableW sftW;

	sftA = pInitSecurityInterfaceA();
	ok(sftA != NULL, "pInitSecurityInterfaceA failed\n");
	ok(sftA->dwVersion == SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION, "wrong dwVersion %d in security function table\n", sftA->dwVersion);
	ok(!sftA->Reserved2,
	"Reserved2 should be NULL instead of %p in security function table\n",
	sftA->Reserved2);
	ok(sftA->Reserved3 == sftA->EncryptMessage,
	"Reserved3 should be equal to EncryptMessage in the security function table\n");
	ok(sftA->Reserved4 == sftA->DecryptMessage,
	"Reserved4 should be equal to DecryptMessage in the security function table\n");

	if (!pInitSecurityInterfaceW)
	{
	win_skip("InitSecurityInterfaceW not exported by secur32.dll\n");
	return;
	}

	sftW = pInitSecurityInterfaceW();
	ok(sftW != NULL, "pInitSecurityInterfaceW failed\n");
	ok(sftW->dwVersion == SECURITY_SUPPORT_PROVIDER_INTERFACE_VERSION, "wrong dwVersion %d in security function table\n", sftW->dwVersion);
	ok(!sftW->Reserved2, "Reserved2 should be NULL instead of %p in security function table\n", sftW->Reserved2);
	ok(sftW->Reserved3 == sftW->EncryptMessage, "Reserved3 should be equal to EncryptMessage in the security function table\n");
	ok(sftW->Reserved4 == sftW->DecryptMessage, "Reserved4 should be equal to DecryptMessage in the security function table\n");
	}

	static void test_SspiEncodeStringsAsAuthIdentity(void)
	{
	static const WCHAR username[] = {'u','s','e','r','n','a','m','e',0};
	static const WCHAR domainname[] = {'d','o','m','a','i','n','n','a','m','e',0};
	static const WCHAR password[] = {'p','a','s','s','w','o','r','d',0};
	const WCHAR username_ptr, domainname_ptr, *password_ptr;
	PSEC_WINNT_AUTH_IDENTITY_OPAQUE id;
	SECURITY_STATUS status;

	if (!pSspiEncodeStringsAsAuthIdentity)
	{
	win_skip( "SspiEncodeAuthIdentityAsStrings not exported by secur32.dll\n" );
	return;
	}

	status = pSspiEncodeStringsAsAuthIdentity( NULL, NULL, NULL, NULL );
	ok( status == SEC_E_INVALID_TOKEN, "got %08x\n", status );

	id = (PSEC_WINNT_AUTH_IDENTITY_OPAQUE)0xdeadbeef;
	status = pSspiEncodeStringsAsAuthIdentity( NULL, NULL, NULL, &id );
	ok( status == SEC_E_INVALID_TOKEN, "got %08x\n", status );
	ok( id == (PSEC_WINNT_AUTH_IDENTITY_OPAQUE)0xdeadbeef, "id set\n" );

	id = NULL;
	status = pSspiEncodeStringsAsAuthIdentity( NULL, NULL, password, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( id != NULL, "id not set\n" );
	pSspiFreeAuthIdentity( id );

	id = NULL;
	status = pSspiEncodeStringsAsAuthIdentity( NULL, domainname, password, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( id != NULL, "id not set\n" );
	pSspiFreeAuthIdentity( id );

	id = NULL;
	status = pSspiEncodeStringsAsAuthIdentity( username, NULL, password, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( id != NULL, "id not set\n" );
	pSspiFreeAuthIdentity( id );

	id = NULL;
	status = pSspiEncodeStringsAsAuthIdentity( username, NULL, NULL, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( id != NULL, "id not set\n" );
	pSspiFreeAuthIdentity( id );

	id = NULL;
	status = pSspiEncodeStringsAsAuthIdentity( username, domainname, password, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( id != NULL, "id not set\n" );

	username_ptr = domainname_ptr = password_ptr = NULL;
	status = pSspiEncodeAuthIdentityAsStrings( id, &username_ptr, &domainname_ptr, &password_ptr );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( !lstrcmpW( username, username_ptr ), "wrong username\n" );
	ok( !lstrcmpW( domainname, domainname_ptr ), "wrong domainname\n" );
	ok( !lstrcmpW( password, password_ptr ), "wrong password\n" );

	pSspiZeroAuthIdentity( id );

	pSspiLocalFree( (void *)username_ptr );
	pSspiLocalFree( (void *)domainname_ptr );
	pSspiLocalFree( (void *)password_ptr );
	pSspiFreeAuthIdentity( id );

	id = NULL;
	status = pSspiEncodeStringsAsAuthIdentity( username, NULL, password, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( id != NULL, "id not set\n" );

	username_ptr = password_ptr = NULL;
	domainname_ptr = (const WCHAR *)0xdeadbeef;
	status = pSspiEncodeAuthIdentityAsStrings( id, &username_ptr, &domainname_ptr, &password_ptr );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( !lstrcmpW( username, username_ptr ), "wrong username\n" );
	ok( domainname_ptr == NULL, "domainname_ptr not cleared\n" );
	ok( !lstrcmpW( password, password_ptr ), "wrong password\n" );

	pSspiLocalFree( (void *)username_ptr );
	pSspiLocalFree( (void *)password_ptr );
	pSspiFreeAuthIdentity( id );
	}

	static void test_SspiPrepareForCredWrite(void)
	{
	static const WCHAR usernameW[] =
	{'u','s','e','r','n','a','m','e',0};
	static const WCHAR domainnameW[] =
	{'d','o','m','a','i','n','n','a','m','e',0};
	static const WCHAR passwordW[] =
	{'p','a','s','s','w','o','r','d',0};
	static const WCHAR targetW[] =
	{'d','o','m','a','i','n','n','a','m','e','\\','u','s','e','r','n','a','m','e',0};
	static const WCHAR target2W[] =
	{'d','o','m','a','i','n','n','a','m','e','2','\\','u','s','e','r','n','a','m','e','2',0};
	const WCHAR target, username;
	PSEC_WINNT_AUTH_IDENTITY_OPAQUE id;
	SECURITY_STATUS status;
	ULONG type, size;
	UCHAR *blob;

	if (!pSspiPrepareForCredWrite)
	{
	win_skip( "SspiPrepareForCredWrite not exported by secur32.dll\n" );
	return;
	}

	status = pSspiEncodeStringsAsAuthIdentity( usernameW, domainnameW, passwordW, &id );
	ok( status == SEC_E_OK, "got %08x\n", status );

	type = size = 0;
	status = pSspiPrepareForCredWrite( id, NULL, &type, &target, &username, &blob, &size );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( type == CRED_TYPE_DOMAIN_PASSWORD, "got %u\n", type );
	ok( !lstrcmpW( target, targetW ), "got %s\n", wine_dbgstr_w(target) );
	ok( !lstrcmpW( username, targetW ), "got %s\n", wine_dbgstr_w(username) );
	ok( !memcmp( blob, passwordW, sizeof(passwordW) - sizeof(WCHAR) ), "wrong data\n" );
	ok( size == sizeof(passwordW) - sizeof(WCHAR), "got %u\n", size );
	pSspiLocalFree( (void *)target );
	pSspiLocalFree( (void *)username );
	pSspiLocalFree( blob );

	type = size = 0;
	status = pSspiPrepareForCredWrite( id, target2W, &type, &target, &username, &blob, &size );
	ok( status == SEC_E_OK, "got %08x\n", status );
	ok( type == CRED_TYPE_DOMAIN_PASSWORD, "got %u\n", type );
	ok( !lstrcmpW( target, target2W ), "got %s\n", wine_dbgstr_w(target) );
	ok( !lstrcmpW( username, targetW ), "got %s\n", wine_dbgstr_w(username) );
	ok( !memcmp( blob, passwordW, sizeof(passwordW) - sizeof(WCHAR) ), "wrong data\n" );
	ok( size == sizeof(passwordW) - sizeof(WCHAR), "got %u\n", size );
	pSspiLocalFree( (void *)target );
	pSspiLocalFree( (void *)username );
	pSspiLocalFree( blob );

	pSspiFreeAuthIdentity( id );
	}

	static void test_kerberos(void)
	{
	SecPkgInfoA *info;
	TimeStamp ttl;
	CredHandle cred;
	SECURITY_STATUS status;

	SEC_CHAR provider[] = {'K','e','r','b','e','r','o','s',0};

	static const ULONG expected_flags =
	SECPKG_FLAG_INTEGRITY
	\| SECPKG_FLAG_PRIVACY
	\| SECPKG_FLAG_TOKEN_ONLY
	\| SECPKG_FLAG_DATAGRAM
	\| SECPKG_FLAG_CONNECTION
	\| SECPKG_FLAG_MULTI_REQUIRED
	\| SECPKG_FLAG_EXTENDED_ERROR
	\| SECPKG_FLAG_IMPERSONATION
	\| SECPKG_FLAG_ACCEPT_WIN32_NAME
	\| SECPKG_FLAG_NEGOTIABLE
	\| SECPKG_FLAG_GSS_COMPATIBLE
	\| SECPKG_FLAG_LOGON
	\| SECPKG_FLAG_MUTUAL_AUTH
	\| SECPKG_FLAG_DELEGATION
	\| SECPKG_FLAG_READONLY_WITH_CHECKSUM;
	static const ULONG optional_mask =
	SECPKG_FLAG_RESTRICTED_TOKENS
	\| SECPKG_FLAG_APPCONTAINER_CHECKS;

	status = QuerySecurityPackageInfoA(provider, &info);
	ok(status == SEC_E_OK, "Kerberos package not installed, skipping test\n");
	if(status != SEC_E_OK)
	return;

	ok( (info->fCapabilities & ~optional_mask) == expected_flags, "got %08x, expected %08x\n", info->fCapabilities, expected_flags );
	ok( info->wVersion == 1, "got %u\n", info->wVersion );
	ok( info->wRPCID == RPC_C_AUTHN_GSS_KERBEROS, "got %u\n", info->wRPCID );
	ok( info->cbMaxToken >= 12000, "got %u\n", info->cbMaxToken );
	ok( !lstrcmpA( info->Name, "Kerberos" ), "got %s\n", info->Name );
	ok( !lstrcmpA( info->Comment, "Microsoft Kerberos V1.0" ), "got %s\n", info->Comment );
	FreeContextBuffer( info );

	status = AcquireCredentialsHandleA( NULL, provider, SECPKG_CRED_OUTBOUND, NULL,
	NULL, NULL, NULL, &cred, &ttl );
	todo_wine ok( status == SEC_E_OK, "AcquireCredentialsHandleA returned %08x\n", status );
	if(status == SEC_E_OK)
	FreeCredentialHandle( &cred );
	}

	START_TEST(secur32)
	{
	secdll = LoadLibraryA("secur32.dll");

	if (!secdll)
	secdll = LoadLibraryA("security.dll");

	if (secdll)
	{
	pSspiEncodeAuthIdentityAsStrings = (void *)GetProcAddress(secdll, "SspiEncodeAuthIdentityAsStrings");
	pSspiEncodeStringsAsAuthIdentity = (void *)GetProcAddress(secdll, "SspiEncodeStringsAsAuthIdentity");
	pSspiFreeAuthIdentity = (void *)GetProcAddress(secdll, "SspiFreeAuthIdentity");
	pSspiLocalFree = (void *)GetProcAddress(secdll, "SspiLocalFree");
	pSspiPrepareForCredWrite = (void *)GetProcAddress(secdll, "SspiPrepareForCredWrite");
	pSspiZeroAuthIdentity = (void *)GetProcAddress(secdll, "SspiZeroAuthIdentity");
	pGetComputerObjectNameA = (PVOID)GetProcAddress(secdll, "GetComputerObjectNameA");
	pGetComputerObjectNameW = (PVOID)GetProcAddress(secdll, "GetComputerObjectNameW");
	pGetUserNameExA = (PVOID)GetProcAddress(secdll, "GetUserNameExA");
	pGetUserNameExW = (PVOID)GetProcAddress(secdll, "GetUserNameExW");
	pInitSecurityInterfaceA = (PVOID)GetProcAddress(secdll, "InitSecurityInterfaceA");
	pInitSecurityInterfaceW = (PVOID)GetProcAddress(secdll, "InitSecurityInterfaceW");

	if (pGetComputerObjectNameA)
	testGetComputerObjectNameA();
	else
	win_skip("GetComputerObjectNameA not exported by secur32.dll\n");

	if (pGetComputerObjectNameW)
	testGetComputerObjectNameW();
	else
	win_skip("GetComputerObjectNameW not exported by secur32.dll\n");

	if (pGetUserNameExA)
	testGetUserNameExA();
	else
	win_skip("GetUserNameExA not exported by secur32.dll\n");

	if (pGetUserNameExW)
	testGetUserNameExW();
	else
	win_skip("GetUserNameExW not exported by secur32.dll\n");

	test_InitSecurityInterface();
	test_SspiEncodeStringsAsAuthIdentity();
	test_SspiPrepareForCredWrite();

	FreeLibrary(secdll);
	}

	test_kerberos();
	}