#include "config.h"
#include "wine/port.h"
#include <limits.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <fcntl.h>
#include "ntstatus.h"
#include "crypt.h"
#include "winnls.h"
#include "winreg.h"
#include "rpc.h"
#include "wine/debug.h"
#include "wine/unicode.h"
#include "winternl.h"

Include dependency graph for crypt.c:

Macros
#define	WIN32_NO_STATUS

#define	CRYPT_Alloc(size) (LocalAlloc(LMEM_ZEROINIT, size))

#define	CRYPT_Free(buffer) (LocalFree(buffer))

#define	CRYPT_GetProvFunc(name) if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error

#define	CRYPT_GetProvFuncOpt(name) provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (crypt)

static PWSTR	CRYPT_GetProvKeyName (PCWSTR pProvName)

static PWSTR	CRYPT_GetTypeKeyName (DWORD dwType, BOOL user)

static BOOL	CRYPT_UnicodeToANSI (LPCWSTR wstr, LPSTR *str, int strsize)

static BOOL	CRYPT_ANSIToUnicode (LPCSTR str, LPWSTR *wstr, int wstrsize)

static BOOL CALLBACK	CRYPT_VerifyImage (LPCSTR lpszImage, BYTE *pData)

static void CALLBACK	CRYPT_ReturnhWnd (HWND *phWnd)

static PCRYPTPROV	CRYPT_LoadProvider (PCWSTR pImage)

static void	CRYPT_CreateMachineGuid (void)

void WINAPI	CloseEncryptedFileRaw (PVOID context)

BOOL WINAPI	CryptAcquireContextW (HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)

BOOL WINAPI	CryptAcquireContextA (HCRYPTPROV *phProv, LPCSTR pszContainer, LPCSTR pszProvider, DWORD dwProvType, DWORD dwFlags)

BOOL WINAPI	CryptContextAddRef (HCRYPTPROV hProv, DWORD *pdwReserved, DWORD dwFlags)

BOOL WINAPI	CryptReleaseContext (HCRYPTPROV hProv, DWORD dwFlags)

BOOL WINAPI	CryptGenRandom (HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer)

BOOL WINAPI	CryptCreateHash (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)

BOOL WINAPI	CryptDecrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE pbData, DWORD pdwDataLen)

BOOL WINAPI	CryptDeriveKey (HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey)

BOOL WINAPI	CryptDestroyHash (HCRYPTHASH hHash)

BOOL WINAPI	CryptDestroyKey (HCRYPTKEY hKey)

BOOL WINAPI	CryptDuplicateHash (HCRYPTHASH hHash, DWORD pdwReserved, DWORD dwFlags, HCRYPTHASH phHash)

BOOL WINAPI	CryptDuplicateKey (HCRYPTKEY hKey, DWORD pdwReserved, DWORD dwFlags, HCRYPTKEY phKey)

BOOL WINAPI	CryptEncrypt (HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE pbData, DWORD pdwDataLen, DWORD dwBufLen)

BOOL WINAPI	CryptEnumProvidersW (DWORD dwIndex, DWORD pdwReserved, DWORD dwFlags, DWORD pdwProvType, LPWSTR pszProvName, DWORD *pcbProvName)

BOOL WINAPI	CryptEnumProvidersA (DWORD dwIndex, DWORD pdwReserved, DWORD dwFlags, DWORD pdwProvType, LPSTR pszProvName, DWORD *pcbProvName)

BOOL WINAPI	CryptEnumProviderTypesW (DWORD dwIndex, DWORD pdwReserved, DWORD dwFlags, DWORD pdwProvType, LPWSTR pszTypeName, DWORD *pcbTypeName)

BOOL WINAPI	CryptEnumProviderTypesA (DWORD dwIndex, DWORD pdwReserved, DWORD dwFlags, DWORD pdwProvType, LPSTR pszTypeName, DWORD *pcbTypeName)

BOOL WINAPI	CryptExportKey (HCRYPTKEY hKey, HCRYPTKEY hExpKey, DWORD dwBlobType, DWORD dwFlags, BYTE pbData, DWORD pdwDataLen)

BOOL WINAPI	CryptGenKey (HCRYPTPROV hProv, ALG_ID Algid, DWORD dwFlags, HCRYPTKEY *phKey)

BOOL WINAPI	CryptGetDefaultProviderW (DWORD dwProvType, DWORD pdwReserved, DWORD dwFlags, LPWSTR pszProvName, DWORD pcbProvName)

BOOL WINAPI	CryptGetDefaultProviderA (DWORD dwProvType, DWORD pdwReserved, DWORD dwFlags, LPSTR pszProvName, DWORD pcbProvName)

BOOL WINAPI	CryptGetHashParam (HCRYPTHASH hHash, DWORD dwParam, BYTE pbData, DWORD pdwDataLen, DWORD dwFlags)

BOOL WINAPI	CryptGetKeyParam (HCRYPTKEY hKey, DWORD dwParam, BYTE pbData, DWORD pdwDataLen, DWORD dwFlags)

BOOL WINAPI	CryptGetProvParam (HCRYPTPROV hProv, DWORD dwParam, BYTE pbData, DWORD pdwDataLen, DWORD dwFlags)

BOOL WINAPI	CryptGetUserKey (HCRYPTPROV hProv, DWORD dwKeySpec, HCRYPTKEY *phUserKey)

BOOL WINAPI	CryptHashData (HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)

BOOL WINAPI	CryptHashSessionKey (HCRYPTHASH hHash, HCRYPTKEY hKey, DWORD dwFlags)

BOOL WINAPI	CryptImportKey (HCRYPTPROV hProv, const BYTE pbData, DWORD dwDataLen, HCRYPTKEY hPubKey, DWORD dwFlags, HCRYPTKEY phKey)

BOOL WINAPI	CryptSignHashW (HCRYPTHASH hHash, DWORD dwKeySpec, LPCWSTR sDescription, DWORD dwFlags, BYTE pbSignature, DWORD pdwSigLen)

BOOL WINAPI	CryptSignHashA (HCRYPTHASH hHash, DWORD dwKeySpec, LPCSTR sDescription, DWORD dwFlags, BYTE pbSignature, DWORD pdwSigLen)

BOOL WINAPI	CryptSetHashParam (HCRYPTHASH hHash, DWORD dwParam, const BYTE *pbData, DWORD dwFlags)

BOOL WINAPI	CryptSetKeyParam (HCRYPTKEY hKey, DWORD dwParam, const BYTE *pbData, DWORD dwFlags)

BOOL WINAPI	CryptSetProviderA (LPCSTR pszProvName, DWORD dwProvType)

BOOL WINAPI	CryptSetProviderW (LPCWSTR pszProvName, DWORD dwProvType)

BOOL WINAPI	CryptSetProviderExW (LPCWSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)

BOOL WINAPI	CryptSetProviderExA (LPCSTR pszProvName, DWORD dwProvType, DWORD *pdwReserved, DWORD dwFlags)

BOOL WINAPI	CryptSetProvParam (HCRYPTPROV hProv, DWORD dwParam, const BYTE *pbData, DWORD dwFlags)

BOOL WINAPI	CryptVerifySignatureW (HCRYPTHASH hHash, const BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCWSTR sDescription, DWORD dwFlags)

BOOL WINAPI	CryptVerifySignatureA (HCRYPTHASH hHash, const BYTE *pbSignature, DWORD dwSigLen, HCRYPTKEY hPubKey, LPCSTR sDescription, DWORD dwFlags)

DWORD WINAPI	OpenEncryptedFileRawA (LPCSTR filename, ULONG flags, PVOID *context)

DWORD WINAPI	OpenEncryptedFileRawW (LPCWSTR filename, ULONG flags, PVOID *context)

DWORD WINAPI	ReadEncryptedFileRaw (PFE_EXPORT_FUNC export, PVOID callback, PVOID context)

BOOL WINAPI	SystemFunction030 (LPCVOID b1, LPCVOID b2)

BOOL WINAPI	SystemFunction035 (LPCSTR lpszDllFilePath)

BOOLEAN WINAPI	SystemFunction036 (PVOID pbBuffer, ULONG dwLen)

NTSTATUS WINAPI	SystemFunction040 (PVOID memory, ULONG length, ULONG flags)

NTSTATUS WINAPI	SystemFunction041 (PVOID memory, ULONG length, ULONG flags)

DWORD WINAPI	WriteEncryptedFileRaw (PFE_IMPORT_FUNC import, PVOID callback, PVOID context)

Variables
static HWND	crypt_hWindow

Macro Definition Documentation

◆ CRYPT_Alloc

#define CRYPT_Alloc ( size ) (LocalAlloc(LMEM_ZEROINIT, size))

Definition at line 61 of file crypt.c.

◆ CRYPT_Free

#define CRYPT_Free ( buffer ) (LocalFree(buffer))

Definition at line 62 of file crypt.c.

◆ CRYPT_GetProvFunc

#define CRYPT_GetProvFunc ( name ) if ( !(provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)) ) goto error

Definition at line 200 of file crypt.c.

◆ CRYPT_GetProvFuncOpt

#define CRYPT_GetProvFuncOpt ( name ) provider->pFuncs->p##name = (void*)GetProcAddress(provider->hModule, #name)

Definition at line 202 of file crypt.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 47 of file crypt.c.

Function Documentation

◆ CloseEncryptedFileRaw()

void WINAPI CloseEncryptedFileRaw ( PVOID context )

Definition at line 338 of file crypt.c.

{
    FIXME("(%p): stub\n", context);
}

◆ CRYPT_ANSIToUnicode()

static BOOL CRYPT_ANSIToUnicode	(	LPCSTR	str,
		LPWSTR *	wstr,
		int	wstrsize
	)

inlinestatic

Definition at line 158 of file crypt.c.

{
    unsigned int wcount;
 
    if (!str)
    {
        *wstr = NULL;
        return TRUE;
    }
    wcount = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
    if (wstrsize == -1)
        *wstr = CRYPT_Alloc(wcount * sizeof(WCHAR));
    else
        wcount = min( wcount, wstrsize/sizeof(WCHAR) );
    if (*wstr)
    {
        MultiByteToWideChar(CP_ACP, 0, str, -1, *wstr, wcount);
        return TRUE;
    }
    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    return FALSE;
}

Referenced by CryptAcquireContextA(), CryptSetProviderExA(), CryptSignHashA(), and CryptVerifySignatureA().

◆ CRYPT_CreateMachineGuid()

static void CRYPT_CreateMachineGuid ( void )

static

Definition at line 277 of file crypt.c.

{
    static const WCHAR cryptographyW[] = {
                'S','o','f','t','w','a','r','e','\\',
                'M','i','c','r','o','s','o','f','t','\\',
                'C','r','y','p','t','o','g','r','a','p','h','y',0 };
    static const WCHAR machineGuidW[] = {
        'M','a','c','h','i','n','e','G','u','i','d',0 };
    LONG r;
    HKEY key;
 
    r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, cryptographyW, 0, KEY_ALL_ACCESS,
              &key);
    if (!r)
    {
        DWORD size;
 
        r = RegQueryValueExW(key, machineGuidW, NULL, NULL, NULL, &size);
        if (r == ERROR_FILE_NOT_FOUND)
        {
                    UUID uuid;
                    WCHAR buf[37];
                    RPC_STATUS rs;
                    static const WCHAR uuidFmt[] = {
                        '%','0','8','x','-','%','0','4','x','-',
                        '%','0','4','x','-','%','0','2','x',
                        '%','0','2','x','-','%','0','2','x',
                        '%','0','2','x','%','0','2','x',
                        '%','0','2','x','%','0','2','x',
                        '%','0','2','x',0 };
 
                    rs = UuidCreate(&uuid);
                    if (rs == S_OK)
                    {
                        sprintfW(buf, uuidFmt,
                                 uuid.Data1, uuid.Data2, uuid.Data3,
                                 uuid.Data4[0], uuid.Data4[1],
                                 uuid.Data4[2], uuid.Data4[3],
                                 uuid.Data4[4], uuid.Data4[5],
                                 uuid.Data4[6], uuid.Data4[7] );
                        RegSetValueExW(key, machineGuidW, 0, REG_SZ,
                                       (const BYTE *)buf,
                                       (lstrlenW(buf)+1)*sizeof(WCHAR));
                    }
        }
        RegCloseKey(key);
    }
}

Referenced by CryptAcquireContextW().

◆ CRYPT_GetProvKeyName()

static PWSTR CRYPT_GetProvKeyName ( PCWSTR pProvName )

inlinestatic

Definition at line 64 of file crypt.c.

{
    static const WCHAR KEYSTR[] = {
                'S','o','f','t','w','a','r','e','\\',
                'M','i','c','r','o','s','o','f','t','\\',
                'C','r','y','p','t','o','g','r','a','p','h','y','\\',
                'D','e','f','a','u','l','t','s','\\',
                'P','r','o','v','i','d','e','r','\\',0
    };
    PWSTR keyname;
 
    keyname = CRYPT_Alloc((strlenW(KEYSTR) + strlenW(pProvName) +1)*sizeof(WCHAR));
    if (keyname)
    {
        strcpyW(keyname, KEYSTR);
        strcpyW(keyname + strlenW(KEYSTR), pProvName);
    } else
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    return keyname;
}

Referenced by CryptAcquireContextW(), and CryptSetProviderExW().

◆ CRYPT_GetTypeKeyName()

static PWSTR CRYPT_GetTypeKeyName	(	DWORD	dwType,
		BOOL	user
	)

inlinestatic

Definition at line 85 of file crypt.c.

{
    static const WCHAR MACHINESTR[] = {
                'S','o','f','t','w','a','r','e','\\',
                'M','i','c','r','o','s','o','f','t','\\',
                'C','r','y','p','t','o','g','r','a','p','h','y','\\',
                'D','e','f','a','u','l','t','s','\\',
                'P','r','o','v','i','d','e','r',' ','T','y','p','e','s','\\',
                'T','y','p','e',' ','X','X','X',0
    };
    static const WCHAR USERSTR[] = {
                'S','o','f','t','w','a','r','e','\\',
                'M','i','c','r','o','s','o','f','t','\\',
                'C','r','y','p','t','o','g','r','a','p','h','y','\\',
                'P','r','o','v','i','d','e','r',' ','T','y','p','e',' ','X','X','X',0
    };
    PWSTR keyname;
    PWSTR ptr;
 
    keyname = CRYPT_Alloc( ((user ? strlenW(USERSTR) : strlenW(MACHINESTR)) +1)*sizeof(WCHAR));
    if (keyname)
    {
        user ? strcpyW(keyname, USERSTR) : strcpyW(keyname, MACHINESTR);
        ptr = keyname + strlenW(keyname);
        *(--ptr) = (dwType % 10) + '0';
        *(--ptr) = ((dwType / 10) % 10) + '0';
        *(--ptr) = (dwType / 100) + '0';
    } else
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    return keyname;
}

Referenced by CryptAcquireContextW(), CryptGetDefaultProviderW(), and CryptSetProviderExW().

◆ CRYPT_LoadProvider()

static PCRYPTPROV CRYPT_LoadProvider ( PCWSTR pImage )

static

Definition at line 204 of file crypt.c.

{
    PCRYPTPROV provider;
    DWORD errorcode = ERROR_NOT_ENOUGH_MEMORY;
 
    if ( !(provider = CRYPT_Alloc(sizeof(CRYPTPROV))) ) goto error;
    if ( !(provider->pFuncs = CRYPT_Alloc(sizeof(PROVFUNCS))) ) goto error;
    if ( !(provider->pVTable = CRYPT_Alloc(sizeof(VTableProvStruc))) ) goto error;
    if ( !(provider->hModule = LoadLibraryW(pImage)) )
    {
        errorcode = (GetLastError() == ERROR_FILE_NOT_FOUND) ? NTE_PROV_DLL_NOT_FOUND : NTE_PROVIDER_DLL_FAIL;
        FIXME("Failed to load dll %s\n", debugstr_w(pImage));
        goto error;
    }
    provider->dwMagic = MAGIC_CRYPTPROV;
    provider->refcount = 1;
 
    errorcode = NTE_PROVIDER_DLL_FAIL;
    CRYPT_GetProvFunc(CPAcquireContext);
    CRYPT_GetProvFunc(CPCreateHash);
    CRYPT_GetProvFunc(CPDecrypt);
    CRYPT_GetProvFunc(CPDeriveKey);
    CRYPT_GetProvFunc(CPDestroyHash);
    CRYPT_GetProvFunc(CPDestroyKey);
    CRYPT_GetProvFuncOpt(CPDuplicateHash);
    CRYPT_GetProvFuncOpt(CPDuplicateKey);
    CRYPT_GetProvFunc(CPEncrypt);
    CRYPT_GetProvFunc(CPExportKey);
    CRYPT_GetProvFunc(CPGenKey);
    CRYPT_GetProvFunc(CPGenRandom);
    CRYPT_GetProvFunc(CPGetHashParam);
    CRYPT_GetProvFunc(CPGetKeyParam);
    CRYPT_GetProvFunc(CPGetProvParam);
    CRYPT_GetProvFunc(CPGetUserKey);
    CRYPT_GetProvFunc(CPHashData);
    CRYPT_GetProvFunc(CPHashSessionKey);
    CRYPT_GetProvFunc(CPImportKey);
    CRYPT_GetProvFunc(CPReleaseContext);
    CRYPT_GetProvFunc(CPSetHashParam);
    CRYPT_GetProvFunc(CPSetKeyParam);
    CRYPT_GetProvFunc(CPSetProvParam);
    CRYPT_GetProvFunc(CPSignHash);
    CRYPT_GetProvFunc(CPVerifySignature);
 
    /* FIXME: Not sure what the pbContextInfo field is for.
     *        Does it need memory allocation?
         */
    provider->pVTable->Version = 3;
    provider->pVTable->FuncVerifyImage = CRYPT_VerifyImage;
    provider->pVTable->FuncReturnhWnd = CRYPT_ReturnhWnd;
    provider->pVTable->dwProvType = 0;
    provider->pVTable->pbContextInfo = NULL;
    provider->pVTable->cbContextInfo = 0;
    provider->pVTable->pszProvName = NULL;
    return provider;
 
error:
    SetLastError(errorcode);
    if (provider)
    {
        provider->dwMagic = 0;
        if (provider->hModule)
            FreeLibrary(provider->hModule);
        CRYPT_Free(provider->pVTable);
        CRYPT_Free(provider->pFuncs);
        CRYPT_Free(provider);
    }
    return NULL;
}

Referenced by CryptAcquireContextW().

◆ CRYPT_ReturnhWnd()

static void CALLBACK CRYPT_ReturnhWnd ( HWND * phWnd )

static

Definition at line 195 of file crypt.c.

{
    if (phWnd) *phWnd = crypt_hWindow;
}

Referenced by CRYPT_LoadProvider().

◆ CRYPT_UnicodeToANSI()

static BOOL CRYPT_UnicodeToANSI	(	LPCWSTR	wstr,
		LPSTR *	str,
		int	strsize
	)

inlinestatic

Definition at line 125 of file crypt.c.

{
    if (!wstr)
    {
        *str = NULL;
        return TRUE;
    }
 
    if (!*str)
    {
        strsize = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
        *str = CRYPT_Alloc(strsize * sizeof(CHAR));
    }
    else if (strsize < 0)
    {
        strsize = INT_MAX; /* windows will pretend that the buffer is infinitely long */
    }
 
    if (*str)
    {
        WideCharToMultiByte(CP_ACP, 0, wstr, -1, *str, strsize, NULL, NULL);
        return TRUE;
    }
 
    SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    return FALSE;
}

Referenced by CryptAcquireContextW(), CryptEnumProvidersA(), CryptEnumProviderTypesA(), and CryptGetDefaultProviderA().

◆ CRYPT_VerifyImage()

static BOOL CALLBACK CRYPT_VerifyImage	(	LPCSTR	lpszImage,
		BYTE *	pData
	)

static

Definition at line 182 of file crypt.c.

{
    if (!lpszImage || !pData)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    FIXME("(%s, %p): not verifying image\n", lpszImage, pData);
 
    return TRUE;
}

Referenced by CRYPT_LoadProvider().

◆ CryptAcquireContextA()

BOOL WINAPI CryptAcquireContextA	(	HCRYPTPROV *	phProv,
		LPCSTR	pszContainer,
		LPCSTR	pszProvider,
		DWORD	dwProvType,
		DWORD	dwFlags
	)

Definition at line 569 of file crypt.c.

{
    PWSTR pProvider = NULL, pContainer = NULL;
    BOOL ret = FALSE;
 
    TRACE("(%p, %s, %s, %d, %08x)\n", phProv, debugstr_a(pszContainer),
              debugstr_a(pszProvider), dwProvType, dwFlags);
 
    if ( !CRYPT_ANSIToUnicode(pszContainer, &pContainer, -1) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    if ( !CRYPT_ANSIToUnicode(pszProvider, &pProvider, -1) )
    {
        CRYPT_Free(pContainer);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    ret = CryptAcquireContextW(phProv, pContainer, pProvider, dwProvType, dwFlags);
 
    CRYPT_Free(pContainer);
    CRYPT_Free(pProvider);
 
    return ret;
}

Referenced by clean_up_aes_environment(), clean_up_base_environment(), CRYPT_CreateKeyProv(), init_aes_environment(), init_base_environment(), init_function_pointers(), test_container_sd(), test_hashes(), test_key_initialization(), test_null_provider(), test_rsa_round_trip(), test_schannel_provider(), and testPortPublicKeyInfo().

◆ CryptAcquireContextW()

BOOL WINAPI CryptAcquireContextW	(	HCRYPTPROV *	phProv,
		LPCWSTR	pszContainer,
		LPCWSTR	pszProvider,
		DWORD	dwProvType,
		DWORD	dwFlags
	)

Definition at line 358 of file crypt.c.

{
    PCRYPTPROV pProv = NULL;
    HKEY key;
    PWSTR imagepath = NULL, keyname = NULL, provname = NULL, temp = NULL;
    PSTR provnameA = NULL, pszContainerA = NULL;
    DWORD keytype, type, len;
    ULONG r;
    static const WCHAR nameW[] = {'N','a','m','e',0};
    static const WCHAR typeW[] = {'T','y','p','e',0};
    static const WCHAR imagepathW[] = {'I','m','a','g','e',' ','P','a','t','h',0};
 
    TRACE("(%p, %s, %s, %d, %08x)\n", phProv, debugstr_w(pszContainer),
        debugstr_w(pszProvider), dwProvType, dwFlags);
 
    if (dwProvType < 1 || dwProvType > MAXPROVTYPES)
    {
        SetLastError(NTE_BAD_PROV_TYPE);
        return FALSE;
    }
    
    if (!phProv)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* Make sure the MachineGuid value exists */
    CRYPT_CreateMachineGuid();
 
    if (!pszProvider || !*pszProvider)
    {
        /* No CSP name specified so try the user default CSP first
         * then try the machine default CSP
         */
        if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, TRUE)) ) {
            TRACE("No provider registered for crypto provider type %d.\n", dwProvType);
            SetLastError(NTE_PROV_TYPE_NOT_DEF);
            return FALSE;
        }
        if (RegOpenKeyW(HKEY_CURRENT_USER, keyname, &key))
        {
            CRYPT_Free(keyname);
            if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, FALSE)) ) {
                TRACE("No type registered for crypto provider type %d.\n", dwProvType);
                RegCloseKey(key);
                SetLastError(NTE_PROV_TYPE_NOT_DEF);
                goto error;
            }
            if (RegOpenKeyW(HKEY_LOCAL_MACHINE, keyname, &key)) {
                TRACE("Did not find registry entry of crypto provider for %s.\n", debugstr_w(keyname));
                CRYPT_Free(keyname);
                RegCloseKey(key);
                SetLastError(NTE_PROV_TYPE_NOT_DEF);
                goto error;
            }
        }
        CRYPT_Free(keyname);
        r = RegQueryValueExW(key, nameW, NULL, &keytype, NULL, &len);
        if( r != ERROR_SUCCESS || !len || keytype != REG_SZ)
        {
            TRACE("error %d reading size of 'Name' from registry\n", r );
            RegCloseKey(key);
            SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
            goto error;
        }
        if(!(provname = CRYPT_Alloc(len)))
        {
            RegCloseKey(key);
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto error;
        }
        r = RegQueryValueExW(key, nameW, NULL, NULL, (LPBYTE)provname, &len);
        if( r != ERROR_SUCCESS )
        {
            TRACE("error %d reading 'Name' from registry\n", r );
            RegCloseKey(key);
            SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
            goto error;
        }
        RegCloseKey(key);
    } else {
        if ( !(provname = CRYPT_Alloc((strlenW(pszProvider) +1)*sizeof(WCHAR))) )
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto error;
        }
        strcpyW(provname, pszProvider);
    }
 
    keyname = CRYPT_GetProvKeyName(provname);
    r = RegOpenKeyW(HKEY_LOCAL_MACHINE, keyname, &key);
    CRYPT_Free(keyname);
    if (r != ERROR_SUCCESS)
    {
        SetLastError(NTE_KEYSET_NOT_DEF);
        goto error;
    }
    len = sizeof(DWORD);
    r = RegQueryValueExW(key, typeW, NULL, NULL, (BYTE*)&type, &len);
    if (r != ERROR_SUCCESS)
    {
        SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
        goto error;
    }
    if (type != dwProvType)
    {
        TRACE("Crypto provider has wrong type (%d vs expected %d).\n", type, dwProvType);
        SetLastError(NTE_PROV_TYPE_NO_MATCH);
        goto error;
    }
 
    r = RegQueryValueExW(key, imagepathW, NULL, &keytype, NULL, &len);
    if ( r != ERROR_SUCCESS || keytype != REG_SZ)
    {
        TRACE("error %d reading size of 'Image Path' from registry\n", r );
        RegCloseKey(key);
        SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
        goto error;
    }
    if (!(temp = CRYPT_Alloc(len)))
    {
        RegCloseKey(key);
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto error;
    }
    r = RegQueryValueExW(key, imagepathW, NULL, NULL, (LPBYTE)temp, &len);
    if( r != ERROR_SUCCESS )
    {
        TRACE("error %d reading 'Image Path' from registry\n", r );
        RegCloseKey(key);
        SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
        goto error;
    }
    RegCloseKey(key);
    len = ExpandEnvironmentStringsW(temp, NULL, 0);
    if ( !(imagepath = CRYPT_Alloc(len*sizeof(WCHAR))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        goto error;
    }
    if (!ExpandEnvironmentStringsW(temp, imagepath, len))
    {
        /* ExpandEnvironmentStrings will call SetLastError */
        goto error;
    }
    pProv = CRYPT_LoadProvider(imagepath);
    if (!pProv) {
        /* CRYPT_LoadProvider calls SetLastError */
        goto error;
    }
    pProv->pVTable->dwProvType = dwProvType;
    if(!CRYPT_UnicodeToANSI(provname, &provnameA, 0))
    {
        /* CRYPT_UnicodeToANSI calls SetLastError */
        goto error;
    }
    pProv->pVTable->pszProvName = provnameA;
    if(!CRYPT_UnicodeToANSI(pszContainer, &pszContainerA, 0))
    {
        /* CRYPT_UnicodeToANSI calls SetLastError */
        goto error;
    }
    if (pProv->pFuncs->pCPAcquireContext(&pProv->hPrivate, pszContainerA, dwFlags, pProv->pVTable))
    {
        /* MSDN: When this flag is set, the value returned in phProv is undefined,
         *       and thus, the CryptReleaseContext function need not be called afterwards.
         *       Therefore, we must clean up everything now.
         */
        if (dwFlags & CRYPT_DELETEKEYSET)
        {
            pProv->dwMagic = 0;
            FreeLibrary(pProv->hModule);
            CRYPT_Free(provnameA);
            CRYPT_Free(pProv->pVTable);
            CRYPT_Free(pProv->pFuncs);
            CRYPT_Free(pProv);
        } else {
            *phProv = (HCRYPTPROV)pProv;
        }
        CRYPT_Free(pszContainerA);
        CRYPT_Free(provname);
        CRYPT_Free(temp);
        CRYPT_Free(imagepath);
        return TRUE;
    }
    /* FALLTHROUGH TO ERROR IF FALSE - CSP internal error! */
error:
    if (pProv)
    {
        pProv->dwMagic = 0;
        if (pProv->hModule)
            FreeLibrary(pProv->hModule);
        CRYPT_Free(pProv->pVTable);
        CRYPT_Free(pProv->pFuncs);
        CRYPT_Free(pProv);
    }
    CRYPT_Free(pszContainerA);
    CRYPT_Free(provnameA);
    CRYPT_Free(provname);
    CRYPT_Free(temp);
    CRYPT_Free(imagepath);
    return FALSE;
}

Referenced by CertCreateSelfSignCertificate(), CRYPT_AcquirePrivateKeyFromProvInfo(), CRYPT_GetDefaultProvider(), CryptAcquireContextA(), CryptCATAdminCalcHashFromFileHandle(), CryptCATAdminEnumCatalogFromHash(), CryptProtectData(), CryptUnprotectData(), DllRegisterServer(), export_acquire_private_key(), find_key_prov_info_in_provider(), hash_file(), I_CryptGetDefaultCryptProv(), init_function_pointers(), key_prov_info_matches_cert(), save_pfx(), SOFTPUB_VerifyImageHash(), START_TEST(), and testAcquireSecurityContext().

◆ CryptContextAddRef()

BOOL WINAPI CryptContextAddRef	(	HCRYPTPROV	hProv,
		DWORD *	pdwReserved,
		DWORD	dwFlags
	)

Definition at line 613 of file crypt.c.

{
    PCRYPTPROV pProv = (PCRYPTPROV)hProv;   
 
    TRACE("(0x%lx, %p, %08x)\n", hProv, pdwReserved, dwFlags);
 
    if (!pProv)
    {
        SetLastError(NTE_BAD_UID);
        return FALSE;
    }
 
    if (pProv->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    InterlockedIncrement(&pProv->refcount);
    return TRUE;
}

Referenced by I_CryptGetDefaultCryptProv().

◆ CryptCreateHash()

BOOL WINAPI CryptCreateHash	(	HCRYPTPROV	hProv,
		ALG_ID	Algid,
		HCRYPTKEY	hKey,
		DWORD	dwFlags,
		HCRYPTHASH *	phHash
	)

Definition at line 740 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
    PCRYPTKEY key = (PCRYPTKEY)hKey;
    PCRYPTHASH hash;
 
    TRACE("(0x%lx, 0x%x, 0x%lx, %08x, %p)\n", hProv, Algid, hKey, dwFlags, phHash);
 
    if (!prov || !phHash || prov->dwMagic != MAGIC_CRYPTPROV ||
        (key && key->dwMagic != MAGIC_CRYPTKEY))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (dwFlags)
    {
        SetLastError(NTE_BAD_FLAGS);
        return FALSE;
    }
    if ( !(hash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    hash->pProvider = prov;
    hash->dwMagic = MAGIC_CRYPTHASH;
    if (prov->pFuncs->pCPCreateHash(prov->hPrivate, Algid,
            key ? key->hPrivate : 0, 0, &hash->hPrivate))
        {
            *phHash = (HCRYPTHASH)hash;
            return TRUE;
        }
 
    /* CSP error! */
    hash->dwMagic = 0;
    CRYPT_Free(hash);
    *phHash = 0;
    return FALSE;
}

Referenced by CDecodeMsg_FinalizeHashedContent(), CHashEncodeMsg_Open(), create_silly_rename(), CRYPT_VerifySignature(), CryptCATAdminCalcHashFromFileHandle(), CryptHashCertificate(), CryptHashPublicKeyInfo(), CryptHashToBeSigned(), CryptProtectData(), CryptSignCertificate(), CryptUnprotectData(), CSignedMsgData_ConstructSignerHandles(), derive_key(), hash_dib(), hash_file(), load_encryption_key(), nfs41_client_owner(), rdssl_hash_clear(), rdssl_hash_info_create(), rdssl_hmac_md5(), SOFTPUB_VerifyImageHash(), test_hashes(), test_hmac(), test_import_hmac(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), test_sha2(), test_verify_signature(), and verifySig().

◆ CryptDecrypt()

BOOL WINAPI CryptDecrypt	(	HCRYPTKEY	hKey,
		HCRYPTHASH	hHash,
		BOOL	Final,
		DWORD	dwFlags,
		BYTE *	pbData,
		DWORD *	pdwDataLen
	)

Definition at line 800 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key = (PCRYPTKEY)hKey;
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
 
    TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
 
    if (!key || !pbData || !pdwDataLen ||
        !key->pProvider || key->dwMagic != MAGIC_CRYPTKEY ||
        key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = key->pProvider;
    return prov->pFuncs->pCPDecrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
            Final, dwFlags, pbData, pdwDataLen);
}

Referenced by CDecodeEnvelopedMsg_CrtlDecrypt(), CryptUnprotectData(), test_3des(), test_3des112(), test_aes(), test_block_cipher_modes(), test_des(), test_import_private(), test_rc2(), test_rc4(), test_rsa_encrypt(), and test_rsa_round_trip().

◆ CryptDeriveKey()

BOOL WINAPI CryptDeriveKey	(	HCRYPTPROV	hProv,
		ALG_ID	Algid,
		HCRYPTHASH	hBaseData,
		DWORD	dwFlags,
		HCRYPTKEY *	phKey
	)

Definition at line 838 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
    PCRYPTHASH hash = (PCRYPTHASH)hBaseData;
    PCRYPTKEY key;
 
    TRACE("(0x%lx, 0x%08x, 0x%lx, 0x%08x, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);
 
    if (!prov || !hash)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!phKey || prov->dwMagic != MAGIC_CRYPTPROV || hash->dwMagic != MAGIC_CRYPTHASH)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    key->pProvider = prov;
    key->dwMagic = MAGIC_CRYPTKEY;
    if (prov->pFuncs->pCPDeriveKey(prov->hPrivate, Algid, hash->hPrivate, dwFlags, &key->hPrivate))
        {
            *phKey = (HCRYPTKEY)key;
            return TRUE;
        }
 
    /* CSP error! */
    key->dwMagic = 0;
    CRYPT_Free(key);
    *phKey = 0;
    return FALSE;
}

Referenced by derive_key(), load_encryption_key(), test_key_derivation(), test_rc2(), test_rc4(), and test_schannel_provider().

◆ CryptDestroyHash()

BOOL WINAPI CryptDestroyHash ( HCRYPTHASH hHash )

Definition at line 890 of file crypt.c.

{
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
    PCRYPTPROV prov;
    BOOL ret;
 
    TRACE("(0x%lx)\n", hHash);
 
    if (!hash)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!hash->pProvider || hash->dwMagic != MAGIC_CRYPTHASH ||
        hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = hash->pProvider;
    ret = prov->pFuncs->pCPDestroyHash(prov->hPrivate, hash->hPrivate);
    hash->dwMagic = 0;
    CRYPT_Free(hash);
    return ret;
}

Referenced by CDecodeMsg_Close(), CHashEncodeMsg_Close(), create_silly_rename(), CRYPT_VerifySignature(), CryptCATAdminCalcHashFromFileHandle(), CryptHashCertificate(), CryptHashPublicKeyInfo(), CryptHashToBeSigned(), CryptProtectData(), CryptSignCertificate(), CryptUnprotectData(), CSignedMsgData_CloseHandles(), derive_key(), hash_dib(), hash_file(), load_encryption_key(), nfs41_client_owner(), rdssl_hash_clear(), rdssl_hash_info_delete(), rdssl_hmac_md5(), SOFTPUB_VerifyImageHash(), test_hashes(), test_hmac(), test_import_hmac(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), test_sha2(), test_verify_signature(), and verifySig().

◆ CryptDestroyKey()

BOOL WINAPI CryptDestroyKey ( HCRYPTKEY hKey )

Definition at line 930 of file crypt.c.

{
    PCRYPTKEY key = (PCRYPTKEY)hKey;
    PCRYPTPROV prov;
    BOOL ret;
 
    TRACE("(0x%lx)\n", hKey);
 
    if (!key)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!key->pProvider || key->dwMagic != MAGIC_CRYPTKEY ||
        key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = key->pProvider;
    ret = prov->pFuncs->pCPDestroyKey(prov->hPrivate, key->hPrivate);
    key->dwMagic = 0;
    CRYPT_Free(key);
    return ret;
}

Referenced by CDecodeEnvelopedMsg_CrtlDecrypt(), CDecodeSignedMsg_VerifySignatureWithKey(), CEnvelopedEncodeMsg_Close(), CertCreateSelfSignCertificate(), CertGetPublicKeyLength(), CRYPT_CreateKeyProv(), CRYPT_ExportKeyTrans(), CRYPT_ExportPublicKeyInfoEx(), CRYPT_ImportKeyTrans(), CRYPT_VerifySignature(), CryptProtectData(), CryptUnprotectData(), export_is_key_exportable(), init_aes_environment(), init_base_environment(), rdssl_cert_to_rkey(), rdssl_rc4_info_delete(), rdssl_rc4_set_key(), test_3des(), test_3des112(), test_aes(), test_block_cipher_modes(), test_decode_msg_get_param(), test_des(), test_hashes(), test_hmac(), test_import_export(), test_import_hmac(), test_import_private(), test_key_derivation(), test_key_initialization(), test_key_permissions(), test_mac(), test_null_provider(), test_rc2(), test_rc4(), test_rsa_encrypt(), test_rsa_round_trip(), test_schannel_provider(), test_sign_message(), test_signed_msg_encoding(), test_signed_msg_update(), test_verify_signature(), testAcquireCertPrivateKey(), testAcquireSecurityContext(), testCreateSelfSignCert(), testExportPublicKey(), testImportPublicKey(), and testSignCert().

◆ CryptDuplicateHash()

BOOL WINAPI CryptDuplicateHash	(	HCRYPTHASH	hHash,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		HCRYPTHASH *	phHash
	)

Definition at line 973 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH orghash, newhash;
 
    TRACE("(0x%lx, %p, %08x, %p)\n", hHash, pdwReserved, dwFlags, phHash);
 
    orghash = (PCRYPTHASH)hHash;
    if (!orghash || pdwReserved || !phHash || !orghash->pProvider ||
        orghash->dwMagic != MAGIC_CRYPTHASH || orghash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = orghash->pProvider;
    if (!prov->pFuncs->pCPDuplicateHash)
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    if ( !(newhash = CRYPT_Alloc(sizeof(CRYPTHASH))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    newhash->pProvider = prov;
    newhash->dwMagic = MAGIC_CRYPTHASH;
    if (prov->pFuncs->pCPDuplicateHash(prov->hPrivate, orghash->hPrivate, pdwReserved, dwFlags, &newhash->hPrivate))
    {
        *phHash = (HCRYPTHASH)newhash;
        return TRUE;
    }
    newhash->dwMagic = 0;
    CRYPT_Free(newhash);
    return FALSE;
}

◆ CryptDuplicateKey()

BOOL WINAPI CryptDuplicateKey	(	HCRYPTKEY	hKey,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		HCRYPTKEY *	phKey
	)

Definition at line 1029 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY orgkey, newkey;
 
    TRACE("(0x%lx, %p, %08x, %p)\n", hKey, pdwReserved, dwFlags, phKey);
 
    orgkey = (PCRYPTKEY)hKey;
    if (!orgkey || pdwReserved || !phKey || !orgkey->pProvider ||
        orgkey->dwMagic != MAGIC_CRYPTKEY ||
        orgkey->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = orgkey->pProvider;
    if (!prov->pFuncs->pCPDuplicateKey)
    {
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
        return FALSE;
    }
 
    if ( !(newkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    newkey->pProvider = prov;
    newkey->dwMagic = MAGIC_CRYPTKEY;
    if (prov->pFuncs->pCPDuplicateKey(prov->hPrivate, orgkey->hPrivate, pdwReserved, dwFlags, &newkey->hPrivate))
    {
        *phKey = (HCRYPTKEY)newkey;
        return TRUE;
    }
    newkey->dwMagic = 0;
    CRYPT_Free(newkey);
    return FALSE;
}

◆ CryptEncrypt()

BOOL WINAPI CryptEncrypt	(	HCRYPTKEY	hKey,
		HCRYPTHASH	hHash,
		BOOL	Final,
		DWORD	dwFlags,
		BYTE *	pbData,
		DWORD *	pdwDataLen,
		DWORD	dwBufLen
	)

Definition at line 1093 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key = (PCRYPTKEY)hKey;
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
 
    TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p, %d)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
 
    if (!key || !pdwDataLen || !key->pProvider ||
        key->dwMagic != MAGIC_CRYPTKEY || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = key->pProvider;
    return prov->pFuncs->pCPEncrypt(prov->hPrivate, key->hPrivate, hash ? hash->hPrivate : 0,
            Final, dwFlags, pbData, pdwDataLen, dwBufLen);
}

Referenced by CEnvelopedEncodeMsg_Update(), CryptProtectData(), rdssl_rc4_crypt(), test_3des(), test_3des112(), test_aes(), test_block_cipher_modes(), test_des(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_rsa_encrypt(), test_rsa_round_trip(), and test_schannel_provider().

◆ CryptEnumProvidersA()

BOOL WINAPI CryptEnumProvidersA	(	DWORD	dwIndex,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		DWORD *	pdwProvType,
		LPSTR	pszProvName,
		DWORD *	pcbProvName
	)

Definition at line 1228 of file crypt.c.

{
    PWSTR str = NULL;
    DWORD bufsize;
    BOOL ret;
 
    TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
            pdwProvType, pszProvName, pcbProvName);
 
    if(!CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
        return FALSE;
    if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    ret = CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &bufsize);
    if (str)
        CRYPT_UnicodeToANSI(str, &pszProvName, *pcbProvName);
    *pcbProvName = bufsize / sizeof(WCHAR);  /* FIXME: not correct */
    if (str)
    {
        CRYPT_Free(str);
        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        {
            SetLastError(ERROR_MORE_DATA);
            return FALSE;
        }
    }
    return ret;
}

◆ CryptEnumProvidersW()

BOOL WINAPI CryptEnumProvidersW	(	DWORD	dwIndex,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		DWORD *	pdwProvType,
		LPWSTR	pszProvName,
		DWORD *	pcbProvName
	)

Definition at line 1136 of file crypt.c.

{
    HKEY hKey;
    static const WCHAR providerW[] = {
                'S','o','f','t','w','a','r','e','\\',
                'M','i','c','r','o','s','o','f','t','\\',
                'C','r','y','p','t','o','g','r','a','p','h','y','\\',
                'D','e','f','a','u','l','t','s','\\',
                'P','r','o','v','i','d','e','r',0
        };
    static const WCHAR typeW[] = {'T','y','p','e',0};
    BOOL ret;
 
    TRACE("(%d, %p, %d, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
            pdwProvType, pszProvName, pcbProvName);
 
    if (pdwReserved || !pcbProvName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (dwFlags)
    {
        SetLastError(NTE_BAD_FLAGS);
        return FALSE;
    }
 
    if (RegOpenKeyW(HKEY_LOCAL_MACHINE, providerW, &hKey))
    {
        SetLastError(NTE_FAIL);
        return FALSE;
    }
 
    ret = TRUE;
    if (!pszProvName)
    {
        DWORD numkeys;
        WCHAR *provNameW;
        
        RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &numkeys, pcbProvName,
                 NULL, NULL, NULL, NULL, NULL, NULL);
        
        if (!(provNameW = CRYPT_Alloc(*pcbProvName * sizeof(WCHAR))))
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            RegCloseKey(hKey);
            return FALSE;
        }
 
        RegEnumKeyExW(hKey, dwIndex, provNameW, pcbProvName, NULL, NULL, NULL, NULL);
        CRYPT_Free(provNameW);
        (*pcbProvName)++;
        *pcbProvName *= sizeof(WCHAR);
 
        if (dwIndex >= numkeys)
        {
            SetLastError(ERROR_NO_MORE_ITEMS);
            ret = FALSE;
        }
    } else {
        DWORD size = sizeof(DWORD);
        DWORD result;
        HKEY subkey;
        
        result = RegEnumKeyW(hKey, dwIndex, pszProvName, *pcbProvName / sizeof(WCHAR));
        if (result)
        {
            SetLastError(result);
            RegCloseKey(hKey);
            return FALSE;
        }
        if (RegOpenKeyW(hKey, pszProvName, &subkey))
        {
            RegCloseKey(hKey);
            return FALSE;
        }
 
        if (RegQueryValueExW(subkey, typeW, NULL, NULL, (BYTE*)pdwProvType, &size))
            ret = FALSE;
 
        RegCloseKey(subkey);
    }
    RegCloseKey(hKey);
    return ret;
}

Referenced by CryptEnumProvidersA(), find_matching_provider(), and I_CryptGetDefaultCryptProv().

◆ CryptEnumProviderTypesA()

BOOL WINAPI CryptEnumProviderTypesA	(	DWORD	dwIndex,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		DWORD *	pdwProvType,
		LPSTR	pszTypeName,
		DWORD *	pcbTypeName
	)

Definition at line 1362 of file crypt.c.

{
    PWSTR str = NULL;
    DWORD bufsize;
    BOOL ret;
 
    TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex, pdwReserved, dwFlags,
            pdwProvType, pszTypeName, pcbTypeName);
 
    if(!CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, NULL, &bufsize))
        return FALSE;
    if ( pszTypeName && !(str = CRYPT_Alloc(bufsize)) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    ret = CryptEnumProviderTypesW(dwIndex, pdwReserved, dwFlags, pdwProvType, str, &bufsize);
    if (str)
        CRYPT_UnicodeToANSI(str, &pszTypeName, *pcbTypeName);
    *pcbTypeName = bufsize / sizeof(WCHAR);
    if (str)
    {
        CRYPT_Free(str);
        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        {
            SetLastError(ERROR_MORE_DATA);
            return FALSE;
        }
    }
    return ret;
}

◆ CryptEnumProviderTypesW()

BOOL WINAPI CryptEnumProviderTypesW	(	DWORD	dwIndex,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		DWORD *	pdwProvType,
		LPWSTR	pszTypeName,
		DWORD *	pcbTypeName
	)

Definition at line 1283 of file crypt.c.

{
    HKEY hKey, hSubkey;
    DWORD keylen, numkeys, dwType;
    PWSTR keyname, ch;
    DWORD result;
    static const WCHAR KEYSTR[] = {
                'S','o','f','t','w','a','r','e','\\',
                'M','i','c','r','o','s','o','f','t','\\',
                'C','r','y','p','t','o','g','r','a','p','h','y','\\',
                'D','e','f','a','u','l','t','s','\\',
                'P','r','o','v','i','d','e','r',' ','T','y','p','e','s',0
    };
    static const WCHAR typenameW[] = {'T','y','p','e','N','a','m','e',0};
 
    TRACE("(%d, %p, %08x, %p, %p, %p)\n", dwIndex, pdwReserved,
        dwFlags, pdwProvType, pszTypeName, pcbTypeName);
 
    if (pdwReserved || !pdwProvType || !pcbTypeName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (dwFlags)
    {
        SetLastError(NTE_BAD_FLAGS);
        return FALSE;
    }
 
    if (RegOpenKeyW(HKEY_LOCAL_MACHINE, KEYSTR, &hKey))
        return FALSE;
 
    RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &numkeys, &keylen, NULL, NULL, NULL, NULL, NULL, NULL);
    if (dwIndex >= numkeys)
    {
        SetLastError(ERROR_NO_MORE_ITEMS);
        RegCloseKey(hKey);
        return FALSE;
    }
    keylen++;
    if ( !(keyname = CRYPT_Alloc(keylen*sizeof(WCHAR))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        RegCloseKey(hKey);
        return FALSE;
    }
    if ( RegEnumKeyW(hKey, dwIndex, keyname, keylen) ) {
                CRYPT_Free(keyname);
        RegCloseKey(hKey);
        return FALSE;
        }
    RegOpenKeyW(hKey, keyname, &hSubkey);
    RegCloseKey(hKey);
 
    ch = keyname + strlenW(keyname);
    /* Convert "Type 000" to 0, etc/ */
    *pdwProvType = *(--ch) - '0';
    *pdwProvType += (*(--ch) - '0') * 10;
    *pdwProvType += (*(--ch) - '0') * 100;
    CRYPT_Free(keyname);
    
    result = RegQueryValueExW(hSubkey, typenameW, NULL, &dwType, (LPBYTE)pszTypeName, pcbTypeName);
    if (result)
    {
        SetLastError(result);
        RegCloseKey(hSubkey);
        return FALSE;
    }
 
    RegCloseKey(hSubkey);
    return TRUE;
}

Referenced by CryptEnumProviderTypesA().

◆ CryptExportKey()

BOOL WINAPI CryptExportKey	(	HCRYPTKEY	hKey,
		HCRYPTKEY	hExpKey,
		DWORD	dwBlobType,
		DWORD	dwFlags,
		BYTE *	pbData,
		DWORD *	pdwDataLen
	)

Definition at line 1416 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key = (PCRYPTKEY)hKey, expkey = (PCRYPTKEY)hExpKey;
 
    TRACE("(0x%lx, 0x%lx, %d, %08x, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);
 
    if (!key || !pdwDataLen || !key->pProvider ||
        key->dwMagic != MAGIC_CRYPTKEY || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = key->pProvider;
    return prov->pFuncs->pCPExportKey(prov->hPrivate, key->hPrivate, expkey ? expkey->hPrivate : 0,
            dwBlobType, dwFlags, pbData, pdwDataLen);
}

Referenced by CRYPT_ExportKeyTrans(), CRYPT_ExportPublicKeyInfoEx(), rdssl_cert_to_rkey(), test_import_export(), test_import_private(), test_key_permissions(), test_rsa_encrypt(), test_rsa_round_trip(), and testAcquireCertPrivateKey().

◆ CryptGenKey()

BOOL WINAPI CryptGenKey	(	HCRYPTPROV	hProv,
		ALG_ID	Algid,
		DWORD	dwFlags,
		HCRYPTKEY *	phKey
	)

Definition at line 1451 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
    PCRYPTKEY key;
 
    TRACE("(0x%lx, %d, %08x, %p)\n", hProv, Algid, dwFlags, phKey);
 
    if (!phKey || !prov || prov->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    key->pProvider = prov;
    key->dwMagic = MAGIC_CRYPTKEY;
    if (prov->pFuncs->pCPGenKey(prov->hPrivate, Algid, dwFlags, &key->hPrivate))
        {
            *phKey = (HCRYPTKEY)key;
            return TRUE;
        }
 
    /* CSP error! */
    key->dwMagic = 0;
    CRYPT_Free(key);
    return FALSE;
}

Referenced by CertCreateSelfSignCertificate(), CRYPT_CreateKeyProv(), CRYPT_GenKey(), init_aes_environment(), init_base_environment(), test_null_provider(), test_rsa_round_trip(), testCreateSelfSignCert(), testExportPublicKey(), and testSignCert().

◆ CryptGenRandom()

BOOL WINAPI CryptGenRandom	(	HCRYPTPROV	hProv,
		DWORD	dwLen,
		BYTE *	pbBuffer
	)

Definition at line 700 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
 
    TRACE("(0x%lx, %d, %p)\n", hProv, dwLen, pbBuffer);
 
    if (!hProv)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (prov->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    return prov->pFuncs->pCPGenRandom(prov->hPrivate, dwLen, pbBuffer);
}

Referenced by CertCreateSelfSignCertificate(), fill_protect_data(), and test_gen_random().

◆ CryptGetDefaultProviderA()

BOOL WINAPI CryptGetDefaultProviderA	(	DWORD	dwProvType,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		LPSTR	pszProvName,
		DWORD *	pcbProvName
	)

Definition at line 1560 of file crypt.c.

{
    PWSTR str = NULL;
    DWORD bufsize;
    BOOL ret;
 
    TRACE("(%d, %p, %08x, %p, %p)\n", dwProvType, pdwReserved, dwFlags, pszProvName, pcbProvName);
 
    CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, NULL, &bufsize);
    if ( pszProvName && !(str = CRYPT_Alloc(bufsize)) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    ret = CryptGetDefaultProviderW(dwProvType, pdwReserved, dwFlags, str, &bufsize);
    if (str)
        CRYPT_UnicodeToANSI(str, &pszProvName, *pcbProvName);
    *pcbProvName = bufsize / sizeof(WCHAR);
    if (str)
    {
        CRYPT_Free(str);
        if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
        {
            SetLastError(ERROR_MORE_DATA);
            return FALSE;
        }
    }
    return ret;
}

◆ CryptGetDefaultProviderW()

BOOL WINAPI CryptGetDefaultProviderW	(	DWORD	dwProvType,
		DWORD *	pdwReserved,
		DWORD	dwFlags,
		LPWSTR	pszProvName,
		DWORD *	pcbProvName
	)

Definition at line 1503 of file crypt.c.

{
    HKEY hKey;
    PWSTR keyname;
    DWORD result;
    static const WCHAR nameW[] = {'N','a','m','e',0};
 
    if (pdwReserved || !pcbProvName)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (dwFlags & ~(CRYPT_USER_DEFAULT | CRYPT_MACHINE_DEFAULT))
    {
        SetLastError(NTE_BAD_FLAGS);
        return FALSE;
    }
    if (dwProvType > 999)
    {
        SetLastError(NTE_BAD_PROV_TYPE);
        return FALSE;
    }
    if ( !(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    if (RegOpenKeyW((dwFlags & CRYPT_USER_DEFAULT) ?  HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE ,keyname, &hKey))
    {
        CRYPT_Free(keyname);
        SetLastError(NTE_PROV_TYPE_NOT_DEF);
        return FALSE;
    }
    CRYPT_Free(keyname);
    
    result = RegQueryValueExW(hKey, nameW, NULL, NULL, (LPBYTE)pszProvName, pcbProvName); 
    RegCloseKey(hKey);
 
    if (result)
    {
        if (result != ERROR_MORE_DATA)
            SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
        else
            SetLastError(result);
        
        return FALSE;
    }
    
    return TRUE;
}

Referenced by CryptGetDefaultProviderA().

◆ CryptGetHashParam()

BOOL WINAPI CryptGetHashParam	(	HCRYPTHASH	hHash,
		DWORD	dwParam,
		BYTE *	pbData,
		DWORD *	pdwDataLen,
		DWORD	dwFlags
	)

Definition at line 1610 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
 
    TRACE("(0x%lx, %d, %p, %p, %08x)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);
 
    if (!hash || !pdwDataLen || !hash->pProvider ||
        hash->dwMagic != MAGIC_CRYPTHASH || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = hash->pProvider;
    return prov->pFuncs->pCPGetHashParam(prov->hPrivate, hash->hPrivate, dwParam,
            pbData, pdwDataLen, dwFlags);
}

Referenced by CDecodeHashMsg_GetParam(), CDecodeSignedMsg_GetParam(), CHashEncodeMsg_GetParam(), convert_hash_to_blob(), create_silly_rename(), CRYPT_EncodePKCSDigestedData(), CryptCATAdminCalcHashFromFileHandle(), CryptHashCertificate(), CryptHashPublicKeyInfo(), CryptHashToBeSigned(), CryptSignCertificate(), CSignedEncodeMsg_GetParam(), CSignedMsgData_AppendMessageDigestAttribute(), derive_key(), hash_dib(), hash_file(), nfs41_client_owner(), rdssl_hash_complete(), rdssl_hmac_md5(), SOFTPUB_VerifyImageHash(), test_hashes(), test_hmac(), test_import_hmac(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), and test_sha2().

◆ CryptGetKeyParam()

BOOL WINAPI CryptGetKeyParam	(	HCRYPTKEY	hKey,
		DWORD	dwParam,
		BYTE *	pbData,
		DWORD *	pdwDataLen,
		DWORD	dwFlags
	)

Definition at line 1649 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key = (PCRYPTKEY)hKey;
 
    TRACE("(0x%lx, %d, %p, %p, %08x)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);
 
    if (!key || !pdwDataLen || !key->pProvider ||
        key->dwMagic != MAGIC_CRYPTKEY || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = key->pProvider;
    return prov->pFuncs->pCPGetKeyParam(prov->hPrivate, key->hPrivate, dwParam,
            pbData, pdwDataLen, dwFlags);
}

Referenced by CertGetPublicKeyLength(), export_is_key_exportable(), test_aes(), test_block_cipher_modes(), test_des(), test_import_export(), test_import_private(), test_key_derivation(), test_key_permissions(), test_rc2(), test_rc4(), test_rsa_encrypt(), and testImportPublicKey().

◆ CryptGetProvParam()

BOOL WINAPI CryptGetProvParam	(	HCRYPTPROV	hProv,
		DWORD	dwParam,
		BYTE *	pbData,
		DWORD *	pdwDataLen,
		DWORD	dwFlags
	)

Definition at line 1688 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
 
    TRACE("(0x%lx, %d, %p, %p, %08x)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);
 
    if (!prov || prov->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    return prov->pFuncs->pCPGetProvParam(prov->hPrivate, dwParam, pbData, pdwDataLen, dwFlags);
}

Referenced by CertContext_SetKeyProvInfo(), find_key_prov_info_in_provider(), is_supported_algid(), test_container_sd(), test_enum_container(), test_getDefaultCryptProv(), test_null_provider(), and test_prov().

◆ CryptGetUserKey()

BOOL WINAPI CryptGetUserKey	(	HCRYPTPROV	hProv,
		DWORD	dwKeySpec,
		HCRYPTKEY *	phUserKey
	)

Definition at line 1718 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
    PCRYPTKEY key;
 
    TRACE("(0x%lx, %d, %p)\n", hProv, dwKeySpec, phUserKey);
 
    if (!prov)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!phUserKey || prov->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if ( !(key = CRYPT_Alloc(sizeof(CRYPTKEY))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    key->pProvider = prov;
    key->dwMagic = MAGIC_CRYPTKEY;
    if (prov->pFuncs->pCPGetUserKey(prov->hPrivate, dwKeySpec, &key->hPrivate))
        {
            *phUserKey = (HCRYPTKEY)key;
            return TRUE;
        }
 
    /* CSP Error */
    key->dwMagic = 0;
    CRYPT_Free(key);
    *phUserKey = 0;
    return FALSE;
}

Referenced by CertCreateSelfSignCertificate(), CRYPT_ExportPublicKeyInfoEx(), CRYPT_ImportKeyTrans(), export_is_key_exportable(), test_import_export(), test_key_initialization(), test_key_permissions(), test_null_provider(), test_rsa_encrypt(), and test_rsa_round_trip().

◆ CryptHashData()

BOOL WINAPI CryptHashData	(	HCRYPTHASH	hHash,
		const BYTE *	pbData,
		DWORD	dwDataLen,
		DWORD	dwFlags
	)

Definition at line 1771 of file crypt.c.

{
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
    PCRYPTPROV prov;
 
    TRACE("(0x%lx, %p, %d, %08x)\n", hHash, pbData, dwDataLen, dwFlags);
 
    if (!hash)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!hash->pProvider || hash->dwMagic != MAGIC_CRYPTHASH ||
        hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = hash->pProvider;
    return prov->pFuncs->pCPHashData(prov->hPrivate, hash->hPrivate, pbData, dwDataLen, dwFlags);
}

Referenced by CDecodeMsg_FinalizeHashedContent(), CHashEncodeMsg_Update(), create_silly_rename(), CRYPT_VerifySignature(), CryptCATAdminCalcHashFromFileHandle(), CryptHashCertificate(), CryptHashPublicKeyInfo(), CryptHashToBeSigned(), CryptSignCertificate(), CSignedMsgData_UpdateAuthenticatedAttributes(), CSignedMsgData_UpdateHash(), derive_key(), hash_dib(), hash_file(), hash_file_data(), hash_mac_addrs(), load_encryption_key(), nfs41_client_owner(), rdssl_hash_transform(), rdssl_hmac_md5(), test_hashes(), test_hmac(), test_import_hmac(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), test_sha2(), test_verify_signature(), and verifySig().

◆ CryptHashSessionKey()

BOOL WINAPI CryptHashSessionKey	(	HCRYPTHASH	hHash,
		HCRYPTKEY	hKey,
		DWORD	dwFlags
	)

Definition at line 1808 of file crypt.c.

{
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
    PCRYPTKEY key = (PCRYPTKEY)hKey;
    PCRYPTPROV prov;
 
    TRACE("(0x%lx, 0x%lx, %08x)\n", hHash, hKey, dwFlags);
 
    if (!hash || !key)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    if (!hash->pProvider || hash->dwMagic != MAGIC_CRYPTHASH ||
        hash->pProvider->dwMagic != MAGIC_CRYPTPROV || key->dwMagic != MAGIC_CRYPTKEY)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = hash->pProvider;
    return prov->pFuncs->pCPHashSessionKey(prov->hPrivate, hash->hPrivate, key->hPrivate, dwFlags);
}

◆ CryptImportKey()

BOOL WINAPI CryptImportKey	(	HCRYPTPROV	hProv,
		const BYTE *	pbData,
		DWORD	dwDataLen,
		HCRYPTKEY	hPubKey,
		DWORD	dwFlags,
		HCRYPTKEY *	phKey
	)

Definition at line 1850 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
    PCRYPTKEY pubkey = (PCRYPTKEY)hPubKey, importkey;
 
    TRACE("(0x%lx, %p, %d, 0x%lx, %08x, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);
 
    if (!prov || !pbData || !dwDataLen || !phKey ||
        prov->dwMagic != MAGIC_CRYPTPROV ||
        (pubkey && pubkey->dwMagic != MAGIC_CRYPTKEY))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if ( !(importkey = CRYPT_Alloc(sizeof(CRYPTKEY))) )
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
 
    importkey->pProvider = prov;
    importkey->dwMagic = MAGIC_CRYPTKEY;
    if (prov->pFuncs->pCPImportKey(prov->hPrivate, pbData, dwDataLen,
            pubkey ? pubkey->hPrivate : 0, dwFlags, &importkey->hPrivate))
    {
        *phKey = (HCRYPTKEY)importkey;
        return TRUE;
    }
 
    importkey->dwMagic = 0;
    CRYPT_Free(importkey);
    return FALSE;
}

Referenced by CRYPT_ImportKeyTrans(), CRYPT_ImportPublicKeyInfoEx(), rdssl_hmac_md5(), rdssl_rc4_set_key(), test_decode_msg_get_param(), test_hashes(), test_import_export(), test_import_hmac(), test_import_private(), test_key_initialization(), test_null_provider(), test_rsa_round_trip(), test_schannel_provider(), test_sign_message(), test_signed_msg_encoding(), test_signed_msg_update(), test_verify_signature(), testAcquireCertPrivateKey(), and testAcquireSecurityContext().

◆ CryptReleaseContext()

BOOL WINAPI CryptReleaseContext	(	HCRYPTPROV	hProv,
		DWORD	dwFlags
	)

Definition at line 648 of file crypt.c.

{
    PCRYPTPROV pProv = (PCRYPTPROV)hProv;
    BOOL ret = TRUE;
 
    TRACE("(0x%lx, %08x)\n", hProv, dwFlags);
 
    if (!pProv)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (pProv->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    if (InterlockedDecrement(&pProv->refcount) == 0)
    {
        ret = pProv->pFuncs->pCPReleaseContext(pProv->hPrivate, dwFlags);
        pProv->dwMagic = 0;
        FreeLibrary(pProv->hModule);
#if 0
        CRYPT_Free(pProv->pVTable->pContextInfo);
#endif
        CRYPT_Free(pProv->pVTable->pszProvName);
        CRYPT_Free(pProv->pVTable);
        CRYPT_Free(pProv->pFuncs);
        CRYPT_Free(pProv);
    }
    return ret;
}

Referenced by CDecodeMsg_Close(), CEnvelopedEncodeMsg_Close(), CEnvelopedEncodeMsg_Open(), CertContext_SetProperty(), CertCreateSelfSignCertificate(), CHashEncodeMsg_Close(), clean_up_aes_environment(), clean_up_base_environment(), create_silly_rename(), CRYPT_FileNameOpenStoreW(), CRYPT_FileOpenStore(), CRYPT_GetDefaultProvider(), CRYPT_MemOpenStore(), CRYPT_MsgOpenStore(), CRYPT_RegOpenStore(), CRYPT_SysOpenStoreW(), CryptCATAdminCalcHashFromFileHandle(), CryptCATAdminEnumCatalogFromHash(), CryptProtectData(), CryptSignMessage(), CryptUnprotectData(), CSignedEncodeMsg_Open(), detect_nt(), DllMain(), DllRegisterServer(), export_private_key_dlg_proc(), find_key_prov_info_in_provider(), hash_file(), I_CryptGetDefaultCryptProv(), key_prov_info_matches_cert(), nfs41_client_owner(), rdssl_cert_to_rkey(), rdssl_hash_info_create(), rdssl_hash_info_delete(), rdssl_hmac_md5(), rdssl_rc4_info_delete(), SOFTPUB_VerifyImageHash(), START_TEST(), test_container_sd(), test_decode_msg_get_param(), test_encrypt_message(), test_enveloped_msg_open(), test_getDefaultCryptProv(), test_hashes(), test_key_initialization(), test_null_provider(), test_rsa_round_trip(), test_schannel_provider(), test_sign_message(), test_signed_msg_encoding(), test_signed_msg_get_param(), test_signed_msg_open(), test_signed_msg_update(), test_sip(), testAcquireCertPrivateKey(), testAcquireSecurityContext(), testCertSigs(), testCreateSelfSignCert(), and testPortPublicKeyInfo().

◆ CryptSetHashParam()

BOOL WINAPI CryptSetHashParam	(	HCRYPTHASH	hHash,
		DWORD	dwParam,
		const BYTE *	pbData,
		DWORD	dwFlags
	)

Definition at line 1970 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
 
    TRACE("(0x%lx, %d, %p, %08x)\n", hHash, dwParam, pbData, dwFlags);
 
    if (!hash || !pbData || !hash->pProvider ||
        hash->dwMagic != MAGIC_CRYPTHASH || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = hash->pProvider;
    return prov->pFuncs->pCPSetHashParam(prov->hPrivate, hash->hPrivate,
            dwParam, pbData, dwFlags);
}

Referenced by rdssl_hmac_md5(), test_hashes(), test_hmac(), test_import_hmac(), and test_schannel_provider().

◆ CryptSetKeyParam()

BOOL WINAPI CryptSetKeyParam	(	HCRYPTKEY	hKey,
		DWORD	dwParam,
		const BYTE *	pbData,
		DWORD	dwFlags
	)

Definition at line 2004 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key = (PCRYPTKEY)hKey;
 
    TRACE("(0x%lx, %d, %p, %08x)\n", hKey, dwParam, pbData, dwFlags);
 
    if (!key || !pbData || !key->pProvider ||
        key->dwMagic != MAGIC_CRYPTKEY || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = key->pProvider;
    return prov->pFuncs->pCPSetKeyParam(prov->hPrivate, key->hPrivate,
            dwParam, pbData, dwFlags);
}

Referenced by test_block_cipher_modes(), test_des(), test_key_permissions(), test_rc2(), test_rc4(), test_rsa_encrypt(), and test_schannel_provider().

◆ CryptSetProviderA()

BOOL WINAPI CryptSetProviderA	(	LPCSTR	pszProvName,
		DWORD	dwProvType
	)

Definition at line 2036 of file crypt.c.

{
    TRACE("(%s, %d)\n", pszProvName, dwProvType);
    return CryptSetProviderExA(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
}

◆ CryptSetProviderExA()

BOOL WINAPI CryptSetProviderExA	(	LPCSTR	pszProvName,
		DWORD	dwProvType,
		DWORD *	pdwReserved,
		DWORD	dwFlags
	)

Definition at line 2149 of file crypt.c.

{
    BOOL ret = FALSE;
    PWSTR str = NULL;
 
    TRACE("(%s, %d, %p, %08x)\n", pszProvName, dwProvType, pdwReserved, dwFlags);
 
    if (CRYPT_ANSIToUnicode(pszProvName, &str, -1))
    {
        ret = CryptSetProviderExW(str, dwProvType, pdwReserved, dwFlags);
        CRYPT_Free(str);
    }
    return ret;
}

Referenced by CryptSetProviderA().

◆ CryptSetProviderExW()

BOOL WINAPI CryptSetProviderExW	(	LPCWSTR	pszProvName,
		DWORD	dwProvType,
		DWORD *	pdwReserved,
		DWORD	dwFlags
	)

Definition at line 2068 of file crypt.c.

{
    HKEY hProvKey, hTypeKey;
    PWSTR keyname;
    static const WCHAR nameW[] = {'N','a','m','e',0};
 
    TRACE("(%s, %d, %p, %08x)\n", debugstr_w(pszProvName), dwProvType, pdwReserved, dwFlags);
 
    if (!pszProvName || pdwReserved)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (dwProvType > MAXPROVTYPES)
    {
        SetLastError(NTE_BAD_PROV_TYPE);
        return FALSE;
    }
    if (dwFlags & ~(CRYPT_MACHINE_DEFAULT | CRYPT_USER_DEFAULT | CRYPT_DELETE_DEFAULT)
            || dwFlags == CRYPT_DELETE_DEFAULT)
    {
        SetLastError(NTE_BAD_FLAGS);
        return FALSE;
    }
 
    if (!(keyname = CRYPT_GetTypeKeyName(dwProvType, dwFlags & CRYPT_USER_DEFAULT)))
    {
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
        return FALSE;
    }
    if (RegOpenKeyW((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
        keyname, &hTypeKey))
    {
        CRYPT_Free(keyname);
        SetLastError(NTE_BAD_PROVIDER);
        return FALSE;
    }
    CRYPT_Free(keyname);
    
    if (dwFlags & CRYPT_DELETE_DEFAULT)
    {
        RegDeleteValueW(hTypeKey, nameW);
    }
    else
    {
        if (!(keyname = CRYPT_GetProvKeyName(pszProvName)))
        {
            RegCloseKey(hTypeKey);
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
        if (RegOpenKeyW((dwFlags & CRYPT_USER_DEFAULT) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE,
            keyname, &hProvKey))
        {
            CRYPT_Free(keyname);
            RegCloseKey(hTypeKey);
            SetLastError(NTE_BAD_PROVIDER);
            return FALSE;
        }
        CRYPT_Free(keyname);
        
        if (RegSetValueExW(hTypeKey, nameW, 0, REG_SZ, (const BYTE *)pszProvName,
            (strlenW(pszProvName) + 1)*sizeof(WCHAR)))
        {
            RegCloseKey(hTypeKey);
            RegCloseKey(hProvKey);
            return FALSE;
        }
        
        RegCloseKey(hProvKey);
    }
    RegCloseKey(hTypeKey);
 
    return TRUE;
}

Referenced by CryptSetProviderExA(), and CryptSetProviderW().

◆ CryptSetProviderW()

BOOL WINAPI CryptSetProviderW	(	LPCWSTR	pszProvName,
		DWORD	dwProvType
	)

Definition at line 2047 of file crypt.c.

{
    TRACE("(%s, %d)\n", debugstr_w(pszProvName), dwProvType);
    return CryptSetProviderExW(pszProvName, dwProvType, NULL, CRYPT_USER_DEFAULT);
}

◆ CryptSetProvParam()

BOOL WINAPI CryptSetProvParam	(	HCRYPTPROV	hProv,
		DWORD	dwParam,
		const BYTE *	pbData,
		DWORD	dwFlags
	)

Definition at line 2179 of file crypt.c.

{
    PCRYPTPROV prov = (PCRYPTPROV)hProv;
 
    TRACE("(0x%lx, %d, %p, %08x)\n", hProv, dwParam, pbData, dwFlags);
 
    if (!prov)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (prov->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
    if (dwParam == PP_USE_HARDWARE_RNG)
    {
        FIXME("PP_USE_HARDWARE_RNG: What do I do with this?\n");
        FIXME("\tLetting the CSP decide.\n");
    }
    if (dwFlags & PP_CLIENT_HWND)
    {
        /* FIXME: Should verify the parameter */
        if (pbData /* && IsWindow((HWND)pbData) */)
        {
            crypt_hWindow = (HWND)(pbData);
            return TRUE;
        } else {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
    }
    /* All other flags go to the CSP */
    return prov->pFuncs->pCPSetProvParam(prov->hPrivate, dwParam, pbData, dwFlags);
}

Referenced by CRYPT_AcquirePrivateKeyFromProvInfo(), and export_acquire_private_key().

◆ CryptSignHashA()

BOOL WINAPI CryptSignHashA	(	HCRYPTHASH	hHash,
		DWORD	dwKeySpec,
		LPCSTR	sDescription,
		DWORD	dwFlags,
		BYTE *	pbSignature,
		DWORD *	pdwSigLen
	)

Definition at line 1939 of file crypt.c.

{
    LPWSTR wsDescription;
    BOOL result;
 
    TRACE("(0x%lx, %d, %s, %08x, %p, %p)\n", 
        hHash, dwKeySpec, debugstr_a(sDescription), dwFlags, pbSignature, pdwSigLen);
 
    CRYPT_ANSIToUnicode(sDescription, &wsDescription, -1);
    result = CryptSignHashW(hHash, dwKeySpec, wsDescription, dwFlags, pbSignature, pdwSigLen);
    CRYPT_Free(wsDescription);
 
    return result;
}

Referenced by test_hashes(), and verifySig().

◆ CryptSignHashW()

BOOL WINAPI CryptSignHashW	(	HCRYPTHASH	hHash,
		DWORD	dwKeySpec,
		LPCWSTR	sDescription,
		DWORD	dwFlags,
		BYTE *	pbSignature,
		DWORD *	pdwSigLen
	)

Definition at line 1908 of file crypt.c.

{
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
    PCRYPTPROV prov;
 
    TRACE("(0x%lx, %d, %s, %08x, %p, %p)\n", 
        hHash, dwKeySpec, debugstr_w(sDescription), dwFlags, pbSignature, pdwSigLen);
 
    if (!hash)
    {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
    if (!pdwSigLen || !hash->pProvider || hash->dwMagic != MAGIC_CRYPTHASH ||
         hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    prov = hash->pProvider;
    return prov->pFuncs->pCPSignHash(prov->hPrivate, hash->hPrivate, dwKeySpec, sDescription,
        dwFlags, pbSignature, pdwSigLen);
}

Referenced by CryptSignCertificate(), CryptSignHashA(), and CSignedMsgData_Sign().

◆ CryptVerifySignatureA()

BOOL WINAPI CryptVerifySignatureA	(	HCRYPTHASH	hHash,
		const BYTE *	pbSignature,
		DWORD	dwSigLen,
		HCRYPTKEY	hPubKey,
		LPCSTR	sDescription,
		DWORD	dwFlags
	)

Definition at line 2266 of file crypt.c.

{
    LPWSTR wsDescription;
    BOOL result;
 
    TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash, pbSignature,
            dwSigLen, hPubKey, debugstr_a(sDescription), dwFlags);
 
    CRYPT_ANSIToUnicode(sDescription, &wsDescription, -1);
    result = CryptVerifySignatureW(hHash, pbSignature, dwSigLen, hPubKey, wsDescription, dwFlags);
    CRYPT_Free(wsDescription);
 
    return result;
}

Referenced by test_verify_signature().

◆ CryptVerifySignatureW()

BOOL WINAPI CryptVerifySignatureW	(	HCRYPTHASH	hHash,
		const BYTE *	pbSignature,
		DWORD	dwSigLen,
		HCRYPTKEY	hPubKey,
		LPCWSTR	sDescription,
		DWORD	dwFlags
	)

Definition at line 2238 of file crypt.c.

{
    PCRYPTHASH hash = (PCRYPTHASH)hHash;
    PCRYPTKEY key = (PCRYPTKEY)hPubKey;
    PCRYPTPROV prov;
 
    TRACE("(0x%lx, %p, %d, 0x%lx, %s, %08x)\n", hHash, pbSignature,
            dwSigLen, hPubKey, debugstr_w(sDescription), dwFlags);
 
    if (!hash || !key || key->dwMagic != MAGIC_CRYPTKEY || hash->dwMagic != MAGIC_CRYPTHASH ||
        !hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV ||
        !key->pProvider || key->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
        
    prov = hash->pProvider;
    return prov->pFuncs->pCPVerifySignature(prov->hPrivate, hash->hPrivate, pbSignature, dwSigLen,
        key->hPrivate, sDescription, dwFlags);
}

Referenced by CDecodeSignedMsg_VerifySignatureWithKey(), CRYPT_VerifySignature(), and CryptVerifySignatureA().

◆ OpenEncryptedFileRawA()

DWORD WINAPI OpenEncryptedFileRawA	(	LPCSTR	filename,
		ULONG	flags,
		PVOID *	context
	)

Definition at line 2287 of file crypt.c.

{
    FIXME("(%s, %x, %p): stub\n", debugstr_a(filename), flags, context);
    return ERROR_CALL_NOT_IMPLEMENTED;
}

◆ OpenEncryptedFileRawW()

DWORD WINAPI OpenEncryptedFileRawW	(	LPCWSTR	filename,
		ULONG	flags,
		PVOID *	context
	)

Definition at line 2306 of file crypt.c.

{
    FIXME("(%s, %x, %p): stub\n", debugstr_w(filename), flags, context);
    return ERROR_CALL_NOT_IMPLEMENTED;
}

◆ ReadEncryptedFileRaw()

DWORD WINAPI ReadEncryptedFileRaw	(	PFE_EXPORT_FUNC	export,
		PVOID	callback,
		PVOID	context
	)

Definition at line 2325 of file crypt.c.

{
    FIXME("(%p, %p, %p): stub\n", export, callback, context);
    return ERROR_CALL_NOT_IMPLEMENTED;
}

◆ SystemFunction030()

BOOL WINAPI SystemFunction030	(	LPCVOID	b1,
		LPCVOID	b2
	)

Definition at line 2344 of file crypt.c.

{
    return !memcmp(b1, b2, 0x10);
}

◆ SystemFunction035()

BOOL WINAPI SystemFunction035 ( LPCSTR lpszDllFilePath )

Definition at line 2358 of file crypt.c.

{
    FIXME("%s: stub\n", debugstr_a(lpszDllFilePath));
    return TRUE;
}

◆ SystemFunction036()

BOOLEAN WINAPI SystemFunction036	(	PVOID	pbBuffer,
		ULONG	dwLen
	)

Definition at line 2378 of file crypt.c.

{
    int dev_random;
 
    dev_random = open("/dev/urandom", O_RDONLY);
    if (dev_random != -1)
    {
        if (!IsBadWritePtr( pbBuffer, dwLen ) &&
            read(dev_random, pbBuffer, dwLen) == (ssize_t)dwLen)
        {
            close(dev_random);
            return TRUE;
        }
        close(dev_random);
    }
    else
        FIXME("couldn't open /dev/urandom\n");
    SetLastError(NTE_FAIL);
    return FALSE;
}    

Referenced by gen_rand_impl().

◆ SystemFunction040()

NTSTATUS WINAPI SystemFunction040	(	PVOID	memory,
		ULONG	length,
		ULONG	flags
	)

Definition at line 2426 of file crypt.c.

{
    FIXME("(%p, %x, %x): stub [RtlEncryptMemory]\n", memory, length, flags);
    return STATUS_SUCCESS;
}

◆ SystemFunction041()

NTSTATUS WINAPI SystemFunction041	(	PVOID	memory,
		ULONG	length,
		ULONG	flags
	)

Definition at line 2454 of file crypt.c.

{
    FIXME("(%p, %x, %x): stub [RtlDecryptMemory]\n", memory, length, flags);
    return STATUS_SUCCESS;
}

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( crypt )

◆ WriteEncryptedFileRaw()

DWORD WINAPI WriteEncryptedFileRaw	(	PFE_IMPORT_FUNC	import,
		PVOID	callback,
		PVOID	context
	)

Definition at line 2474 of file crypt.c.

{
    FIXME("(%p, %p, %p): stub\n", import, callback, context);
    return ERROR_CALL_NOT_IMPLEMENTED;
}

Variable Documentation

◆ crypt_hWindow

HWND crypt_hWindow

static

Definition at line 59 of file crypt.c.

Referenced by CRYPT_ReturnhWnd(), and CryptSetProvParam().

Macros

Functions

Variables

Macro Definition Documentation

◆ CRYPT_Alloc

◆ CRYPT_Free

◆ CRYPT_GetProvFunc

◆ CRYPT_GetProvFuncOpt

◆ WIN32_NO_STATUS

Function Documentation

◆ CloseEncryptedFileRaw()

◆ CRYPT_ANSIToUnicode()

◆ CRYPT_CreateMachineGuid()

◆ CRYPT_GetProvKeyName()

◆ CRYPT_GetTypeKeyName()

◆ CRYPT_LoadProvider()

◆ CRYPT_ReturnhWnd()

◆ CRYPT_UnicodeToANSI()

◆ CRYPT_VerifyImage()

◆ CryptAcquireContextA()

◆ CryptAcquireContextW()

◆ CryptContextAddRef()

◆ CryptCreateHash()

◆ CryptDecrypt()

◆ CryptDeriveKey()

◆ CryptDestroyHash()

◆ CryptDestroyKey()

◆ CryptDuplicateHash()

◆ CryptDuplicateKey()

◆ CryptEncrypt()

◆ CryptEnumProvidersA()

◆ CryptEnumProvidersW()

◆ CryptEnumProviderTypesA()

◆ CryptEnumProviderTypesW()

◆ CryptExportKey()

◆ CryptGenKey()

◆ CryptGenRandom()

◆ CryptGetDefaultProviderA()

◆ CryptGetDefaultProviderW()

◆ CryptGetHashParam()

◆ CryptGetKeyParam()

◆ CryptGetProvParam()

◆ CryptGetUserKey()

◆ CryptHashData()

◆ CryptHashSessionKey()

◆ CryptImportKey()

◆ CryptReleaseContext()

◆ CryptSetHashParam()

◆ CryptSetKeyParam()

◆ CryptSetProviderA()

◆ CryptSetProviderExA()

◆ CryptSetProviderExW()

◆ CryptSetProviderW()

◆ CryptSetProvParam()

◆ CryptSignHashA()

◆ CryptSignHashW()

◆ CryptVerifySignatureA()

◆ CryptVerifySignatureW()

◆ OpenEncryptedFileRawA()

◆ OpenEncryptedFileRawW()

◆ ReadEncryptedFileRaw()

◆ SystemFunction030()

◆ SystemFunction035()

◆ SystemFunction036()

◆ SystemFunction040()

◆ SystemFunction041()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

◆ WriteEncryptedFileRaw()

Variable Documentation

◆ crypt_hWindow