crypt.c File Reference

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

Include dependency graph for crypt.c:

Go to the source code of this file.

Classes
struct	tagMD4_CTX

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)
#define	MAX_CPUS   256

Typedefs
typedef struct tagMD4_CTX	MD4_CTX

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (crypt)
void WINAPI	MD4Init (MD4_CTX *ctx)
void WINAPI	MD4Update (MD4_CTX *ctx, const unsigned char *buf, unsigned int len)
void WINAPI	MD4Final (MD4_CTX *ctx)
static void *	pointer_from_handle (UINT_PTR handle, DWORD magic)
static PCRYPTPROV	provider_from_handle (HCRYPTPROV handle)
static PCRYPTHASH	hash_from_handle (HCRYPTHASH handle)
static PCRYPTKEY	key_from_handle (HCRYPTKEY handle)
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)
NTSTATUS WINAPI	SystemFunction007 (const UNICODE_STRING *string, LPBYTE hash)
NTSTATUS WINAPI	SystemFunction010 (LPVOID unknown, const BYTE *data, LPBYTE hash)
BOOL WINAPI	SystemFunction030 (LPCVOID b1, LPCVOID b2)
BOOL WINAPI	SystemFunction035 (LPCSTR lpszDllFilePath)
static BOOL	fill_random_buffer (void)
BOOLEAN WINAPI	SystemFunction036 (void *buffer, ULONG len)
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
static CRITICAL_SECTION	random_cs = { &random_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	random_debug
static char	random_buf [sizeof(SYSTEM_INTERRUPT_INFORMATION) *MAX_CPUS]
static ULONG	random_len
static ULONG	random_pos

Macro Definition Documentation

CRYPT_Alloc

#define CRYPT_Alloc

(

size

)

(LocalAlloc(LMEM_ZEROINIT, size))

Definition at line 63 of file crypt.c.

CRYPT_Free

#define CRYPT_Free

(

buffer

)

(LocalFree(buffer))

Definition at line 64 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 219 of file crypt.c.

CRYPT_GetProvFuncOpt

#define CRYPT_GetProvFuncOpt

(

name

)

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

Definition at line 221 of file crypt.c.

MAX_CPUS

#define MAX_CPUS   256

Definition at line 2399 of file crypt.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 38 of file crypt.c.

Typedef Documentation

MD4_CTX

typedef struct tagMD4_CTX MD4_CTX

Function Documentation

CloseEncryptedFileRaw()

void WINAPI CloseEncryptedFileRaw

(

PVOID

context

)

Definition at line 342 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 177 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 296 of file crypt.c.

{
    LONG r;
    HKEY key;
 
    r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Cryptography", 0, KEY_ALL_ACCESS | KEY_WOW64_64KEY,
              &key);
    if (!r)
    {
        DWORD size;
 
        r = RegQueryValueExW(key, L"MachineGuid", NULL, NULL, NULL, &size);
        if (r == ERROR_FILE_NOT_FOUND)
        {
                    UUID uuid;
                    WCHAR buf[37];
 
                    if (UuidCreate(&uuid) == S_OK)
                    {
                        swprintf(buf, ARRAY_SIZE(buf), L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
                                 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, L"MachineGuid", 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 101 of file crypt.c.

{
    static const WCHAR KEYSTR[] = L"Software\\Microsoft\\Cryptography\\Defaults\\Provider\\";
    PWSTR keyname;
 
    keyname = CRYPT_Alloc((lstrlenW(KEYSTR) + lstrlenW(pProvName) +1)*sizeof(WCHAR));
    if (keyname)
    {
        lstrcpyW(keyname, KEYSTR);
        lstrcpyW(keyname + lstrlenW(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 116 of file crypt.c.

{
    static const WCHAR MACHINESTR[] = L"Software\\Microsoft\\Cryptography\\Defaults\\Provider Types\\Type XXX";
    static const WCHAR USERSTR[] = L"Software\\Microsoft\\Cryptography\\Provider Type XXX";
    PWSTR keyname;
    PWSTR ptr;
 
    keyname = CRYPT_Alloc( ((user ? lstrlenW(USERSTR) : lstrlenW(MACHINESTR)) +1)*sizeof(WCHAR));
    if (keyname)
    {
        user ? lstrcpyW(keyname, USERSTR) : lstrcpyW(keyname, MACHINESTR);
        ptr = keyname + lstrlenW(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 223 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 214 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 144 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 201 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 571 of file crypt.c.

{
    PWSTR pProvider = NULL, pContainer = NULL;
    BOOL ret = FALSE;
 
    TRACE("(%p, %s, %s, %ld, %08lx)\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(), clean_up_environment(), CRYPT_CreateKeyProv(), init_aes_environment(), init_base_environment(), init_environment(), test_acquire_context(), test_container_sd(), test_CryptReleaseContext(), test_decode_msg_get_param(), test_encrypt_message(), test_enveloped_msg_open(), test_hashes(), test_incorrect_api_usage(), test_key_initialization(), test_machine_guid(), test_null_provider(), test_rc2_keylen(), 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_verify_sig(), test_VerifySignature(), testAcquireCertPrivateKey(), testCertSigs(), testCreateSelfSignCert(), and testPortPublicKeyInfo().

CryptAcquireContextW()

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

Definition at line 362 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;
 
    TRACE("(%p, %s, %s, %ld, %08lx)\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 %ld.\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 %ld.\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, L"Name", NULL, &keytype, NULL, &len);
        if( r != ERROR_SUCCESS || !len || keytype != REG_SZ)
        {
            TRACE("error %ld 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, L"Name", NULL, NULL, (LPBYTE)provname, &len);
        if( r != ERROR_SUCCESS )
        {
            TRACE("error %ld reading 'Name' from registry\n", r );
            RegCloseKey(key);
            SetLastError(NTE_PROV_TYPE_ENTRY_BAD);
            goto error;
        }
        RegCloseKey(key);
    } else {
        if ( !(provname = CRYPT_Alloc((lstrlenW(pszProvider) +1)*sizeof(WCHAR))) )
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            goto error;
        }
        lstrcpyW(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, L"Type", 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 (%ld vs expected %ld).\n", type, dwProvType);
        SetLastError(NTE_PROV_TYPE_NO_MATCH);
        goto error;
    }
 
    r = RegQueryValueExW(key, L"Image Path", NULL, &keytype, NULL, &len);
    if ( r != ERROR_SUCCESS || keytype != REG_SZ)
    {
        TRACE("error %ld 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, L"Image Path", NULL, NULL, (LPBYTE)temp, &len);
    if( r != ERROR_SUCCESS )
    {
        TRACE("error %ld 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)
        {
            *phProv = 0;
            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 catadmin_calc_hash_from_filehandle(), CertCreateSelfSignCertificate(), create_websocket_accept(), CRYPT_AcquirePrivateKeyFromProvInfo(), CRYPT_GetDefaultProvider(), CryptAcquireContextA(), CryptCATAdminEnumCatalogFromHash(), CryptProtectData(), CryptUnprotectData(), DllRegisterServer(), export_acquire_private_key(), find_key_prov_info_in_provider(), hash_file(), I_CryptGetDefaultCryptProv(), key_prov_info_matches_cert(), save_pfx(), SOFTPUB_VerifyImageHash(), START_TEST(), testAcquireSecurityContext(), and testCreateSelfSignCert().

CryptContextAddRef()

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

Definition at line 615 of file crypt.c.

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

Referenced by I_CryptGetDefaultCryptProv(), test_CryptReleaseContext(), and test_incorrect_api_usage().

CryptCreateHash()

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

Definition at line 715 of file crypt.c.

{
    PCRYPTKEY key = NULL;
    PCRYPTPROV prov;
    PCRYPTHASH hash;
 
    TRACE("(0x%Ix, 0x%x, 0x%Ix, %08lx, %p)\n", hProv, Algid, hKey, dwFlags, phHash);
 
    if (!(prov = provider_from_handle(hProv)))
        return FALSE;
 
    if (hKey && !(key = key_from_handle(hKey)))
        return FALSE;
 
    if (!phHash)
    {
        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 catadmin_calc_hash_from_filehandle(), CDecodeMsg_FinalizeHashedContent(), CHashEncodeMsg_Open(), create_silly_rename(), create_websocket_accept(), CRYPT_VerifySignature(), 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_incorrect_api_usage(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), test_sha2(), test_verify_sig(), test_verify_signature(), test_VerifySignature(), and verifySig().

CryptDecrypt()

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

Definition at line 780 of file crypt.c.

{
    PCRYPTHASH hash = NULL;
    PCRYPTPROV prov;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, 0x%Ix, %d, %08lx, %p, %p)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen);
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (hHash && !(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!pbData || !pdwDataLen || !key->pProvider || 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_incorrect_api_usage(), 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 822 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH hash;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, 0x%08x, 0x%Ix, 0x%08lx, %p)\n", hProv, Algid, hBaseData, dwFlags, phKey);
 
    if (!(prov = provider_from_handle(hProv)))
        return FALSE;
 
    if (!(hash = hash_from_handle(hBaseData)))
        return FALSE;
 
    if (!phKey)
    {
        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_incorrect_api_usage(), test_key_derivation(), test_rc2(), test_rc4(), and test_schannel_provider().

CryptDestroyHash()

BOOL WINAPI CryptDestroyHash

(

HCRYPTHASH

hHash

)

Definition at line 875 of file crypt.c.

{
    PCRYPTHASH hash;
    PCRYPTPROV prov;
    BOOL ret;
 
    TRACE("(0x%Ix)\n", hHash);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!hash->pProvider || 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 catadmin_calc_hash_from_filehandle(), CDecodeMsg_Close(), CHashEncodeMsg_Close(), create_silly_rename(), create_websocket_accept(), CRYPT_VerifySignature(), 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_incorrect_api_usage(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), test_sha2(), test_verify_sig(), test_verify_signature(), test_VerifySignature(), and verifySig().

CryptDestroyKey()

BOOL WINAPI CryptDestroyKey

(

HCRYPTKEY

hKey

)

Definition at line 911 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key;
    BOOL ret;
 
    TRACE("(0x%Ix)\n", hKey);
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (!key->pProvider || 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_incorrect_api_usage(), test_key_derivation(), test_key_initialization(), test_key_permissions(), test_mac(), test_null_provider(), test_rc2(), test_rc2_keylen(), 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_sig(), test_verify_signature(), test_VerifySignature(), testAcquireCertPrivateKey(), testAcquireSecurityContext(), testCreateSelfSignCert(), testExportPublicKey(), testImportPublicKey(), and testSignCert().

CryptDuplicateHash()

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

Definition at line 950 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH orghash, newhash;
 
    TRACE("(0x%Ix, %p, %08lx, %p)\n", hHash, pdwReserved, dwFlags, phHash);
 
    if (!(orghash = hash_from_handle(hHash)))
        return FALSE;
 
    if (pdwReserved || !phHash || !orghash->pProvider || 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 1007 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY orgkey, newkey;
 
    TRACE("(0x%Ix, %p, %08lx, %p)\n", hKey, pdwReserved, dwFlags, phKey);
 
    if (!(orgkey = key_from_handle(hKey)))
        return FALSE;
 
    if (pdwReserved || !phKey || !orgkey->pProvider || 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;
}

Referenced by test_incorrect_api_usage().

CryptEncrypt()

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

Definition at line 1071 of file crypt.c.

{
    PCRYPTHASH hash = NULL;
    PCRYPTPROV prov;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, 0x%Ix, %d, %08lx, %p, %p, %ld)\n", hKey, hHash, Final, dwFlags, pbData, pdwDataLen, dwBufLen);
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (hHash && !(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!pdwDataLen || !key->pProvider || 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_incorrect_api_usage(), 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 1203 of file crypt.c.

{
    PWSTR str = NULL;
    DWORD bufsize;
    BOOL ret;
 
    TRACE("(%ld, %p, %08lx, %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 1119 of file crypt.c.

{
    HKEY hKey;
    BOOL ret;
 
    TRACE("(%ld, %p, %ld, %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, L"Software\\Microsoft\\Cryptography\\Defaults\\Provider", &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, L"Type", 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 1329 of file crypt.c.

{
    PWSTR str = NULL;
    DWORD bufsize;
    BOOL ret;
 
    TRACE("(%ld, %p, %08lx, %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 1258 of file crypt.c.

{
    HKEY hKey, hSubkey;
    DWORD keylen, numkeys, dwType;
    PWSTR keyname, ch;
    DWORD result;
 
    TRACE("(%ld, %p, %08lx, %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, L"Software\\Microsoft\\Cryptography\\Defaults\\Provider Types", &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 + lstrlenW(keyname);
    /* Convert "Type 000" to 0, etc/ */
    *pdwProvType = *(--ch) - '0';
    *pdwProvType += (*(--ch) - '0') * 10;
    *pdwProvType += (*(--ch) - '0') * 100;
    CRYPT_Free(keyname);
    
    result = RegQueryValueExW(hSubkey, L"TypeName", 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 1383 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key, expkey = NULL;
 
    TRACE("(0x%Ix, 0x%Ix, %ld, %08lx, %p, %p)\n", hKey, hExpKey, dwBlobType, dwFlags, pbData, pdwDataLen);
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (hExpKey && !(expkey = key_from_handle(hExpKey)))
        return FALSE;
 
    if (!pdwDataLen || !key->pProvider || 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_incorrect_api_usage(), 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 1423 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, %d, %08lx, %p)\n", hProv, Algid, dwFlags, phKey);
 
    if (!(prov = provider_from_handle(hProv)))
        return FALSE;
 
    if (!phKey)
    {
        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_incorrect_api_usage(), test_null_provider(), test_rsa_round_trip(), testCreateSelfSignCert(), testExportPublicKey(), and testSignCert().

CryptGenRandom()

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

Definition at line 684 of file crypt.c.

{
    PCRYPTPROV prov = provider_from_handle(hProv);
 
    TRACE("(0x%Ix, %ld, %p)\n", hProv, dwLen, pbBuffer);
 
    if (!prov)
        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 1534 of file crypt.c.

{
    PWSTR str = NULL;
    DWORD bufsize;
    BOOL ret;
 
    TRACE("(%ld, %p, %08lx, %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 1478 of file crypt.c.

{
    HKEY hKey;
    PWSTR keyname;
    DWORD result;
 
    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, L"Name", 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 1584 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH hash;
 
    TRACE("(0x%Ix, %ld, %p, %p, %08lx)\n", hHash, dwParam, pbData, pdwDataLen, dwFlags);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
 
    if (!pdwDataLen || !hash->pProvider || 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 catadmin_calc_hash_from_filehandle(), CDecodeHashMsg_GetParam(), CDecodeSignedMsg_GetParam(), CHashEncodeMsg_GetParam(), convert_hash_to_blob(), create_silly_rename(), create_websocket_accept(), CRYPT_EncodePKCSDigestedData(), 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_incorrect_api_usage(), 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 1626 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, %ld, %p, %p, %08lx)\n", hKey, dwParam, pbData, pdwDataLen, dwFlags);
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (!pdwDataLen || !key->pProvider || 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_incorrect_api_usage(), 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 1667 of file crypt.c.

{
    PCRYPTPROV prov;
 
    TRACE("(0x%Ix, %ld, %p, %p, %08lx)\n", hProv, dwParam, pbData, pdwDataLen, dwFlags);
 
    if (!(prov = provider_from_handle(hProv)))
        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_incorrect_api_usage(), test_null_provider(), and test_prov().

CryptGetUserKey()

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

Definition at line 1694 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, %ld, %p)\n", hProv, dwKeySpec, phUserKey);
 
    if (!(prov = provider_from_handle(hProv)))
        return FALSE;
 
    if (!phUserKey)
    {
        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_incorrect_api_usage(), test_key_initialization(), test_key_permissions(), test_null_provider(), test_rsa_encrypt(), test_rsa_round_trip(), and testCreateSelfSignCert().

CryptHashData()

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

Definition at line 1745 of file crypt.c.

{
    PCRYPTHASH hash;
    PCRYPTPROV prov;
 
    TRACE("(0x%Ix, %p, %ld, %08lx)\n", hHash, pbData, dwDataLen, dwFlags);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!hash->pProvider || 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 catadmin_calc_hash_from_filehandle(), CDecodeMsg_FinalizeHashedContent(), CHashEncodeMsg_Update(), create_silly_rename(), create_websocket_accept(), CRYPT_VerifySignature(), 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(), pe_image_hash(), rdssl_hash_transform(), rdssl_hmac_md5(), test_hashes(), test_hmac(), test_import_hmac(), test_incorrect_api_usage(), test_key_derivation(), test_mac(), test_rc2(), test_rc4(), test_schannel_provider(), test_sha2(), test_verify_signature(), test_VerifySignature(), and verifySig().

CryptHashSessionKey()

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

Definition at line 1779 of file crypt.c.

{
    PCRYPTHASH hash;
    PCRYPTKEY key;
    PCRYPTPROV prov;
 
    TRACE("(0x%Ix, 0x%Ix, %08lx)\n", hHash, hKey, dwFlags);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (!hash->pProvider || hash->pProvider->dwMagic != MAGIC_CRYPTPROV)
    {
        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 1820 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY pubkey = NULL, importkey;
 
    TRACE("(0x%Ix, %p, %ld, 0x%Ix, %08lx, %p)\n", hProv, pbData, dwDataLen, hPubKey, dwFlags, phKey);
 
    if (!(prov = provider_from_handle(hProv)))
        return FALSE;
 
    if (hPubKey && !(pubkey = key_from_handle(hPubKey)))
        return FALSE;
 
    if (!pbData || !dwDataLen || !phKey)
    {
        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_incorrect_api_usage(), test_key_initialization(), test_null_provider(), test_rc2_keylen(), test_rsa_round_trip(), test_schannel_provider(), test_sign_message(), test_signed_msg_encoding(), test_signed_msg_update(), test_verify_sig(), test_verify_signature(), testAcquireCertPrivateKey(), and testAcquireSecurityContext().

CryptReleaseContext()

BOOL WINAPI CryptReleaseContext	(	HCRYPTPROV	hProv,
		DWORD	dwFlags
	)

Definition at line 641 of file crypt.c.

{
    PCRYPTPROV pProv = provider_from_handle(hProv);
    BOOL ret = TRUE;
 
    TRACE("(0x%Ix, %08lx)\n", hProv, dwFlags);
 
    if (!pProv)
        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 catadmin_calc_hash_from_filehandle(), CDecodeMsg_Close(), CEnvelopedEncodeMsg_Close(), CEnvelopedEncodeMsg_Open(), CertContext_SetProperty(), CertCreateSelfSignCertificate(), CHashEncodeMsg_Close(), clean_up_aes_environment(), clean_up_base_environment(), clean_up_environment(), create_silly_rename(), create_websocket_accept(), CRYPT_FileNameOpenStoreW(), CRYPT_FileOpenStore(), CRYPT_GetDefaultProvider(), CRYPT_MemOpenStore(), CRYPT_MsgOpenStore(), CRYPT_RegOpenStore(), CRYPT_SysOpenStoreW(), CryptCATAdminEnumCatalogFromHash(), CryptProtectData(), CryptSignMessage(), CryptUnprotectData(), CSignedEncodeMsg_Open(), DllMain(), DllRegisterServer(), export_private_key_dlg_proc(), find_key_prov_info_in_provider(), hash_file(), I_CryptGetDefaultCryptProv(), init_environment(), 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_acquire_context(), test_container_sd(), test_CryptReleaseContext(), test_decode_msg_get_param(), test_encrypt_message(), test_enveloped_msg_open(), test_getDefaultCryptProv(), test_hashes(), test_incorrect_api_usage(), test_key_initialization(), test_machine_guid(), test_null_provider(), test_rc2_keylen(), 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(), test_verify_sig(), test_VerifySignature(), testAcquireCertPrivateKey(), testAcquireSecurityContext(), testCertSigs(), testCreateSelfSignCert(), and testPortPublicKeyInfo().

CryptSetHashParam()

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

Definition at line 1941 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTHASH hash;
 
    TRACE("(0x%Ix, %ld, %p, %08lx)\n", hHash, dwParam, pbData, dwFlags);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!pbData || !hash->pProvider || 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(), test_incorrect_api_usage(), and test_schannel_provider().

CryptSetKeyParam()

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

Definition at line 1977 of file crypt.c.

{
    PCRYPTPROV prov;
    PCRYPTKEY key;
 
    TRACE("(0x%Ix, %ld, %p, %08lx)\n", hKey, dwParam, pbData, dwFlags);
 
    if (!(key = key_from_handle(hKey)))
        return FALSE;
 
    if (!key->pProvider || 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_incorrect_api_usage(), 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 2011 of file crypt.c.

{
    TRACE("(%s, %ld)\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 2123 of file crypt.c.

{
    BOOL ret = FALSE;
    PWSTR str = NULL;
 
    TRACE("(%s, %ld, %p, %08lx)\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 2043 of file crypt.c.

{
    HKEY hProvKey, hTypeKey;
    PWSTR keyname;
 
    TRACE("(%s, %ld, %p, %08lx)\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, L"Name");
    }
    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, L"Name", 0, REG_SZ, (const BYTE *)pszProvName,
            (lstrlenW(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 2022 of file crypt.c.

{
    TRACE("(%s, %ld)\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 2153 of file crypt.c.

{
    PCRYPTPROV prov;
 
    TRACE("(0x%Ix, %ld, %p, %08lx)\n", hProv, dwParam, pbData, dwFlags);
 
    if (!(prov = provider_from_handle(hProv)))
        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(), export_acquire_private_key(), and test_incorrect_api_usage().

CryptSignHashA()

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

Definition at line 1910 of file crypt.c.

{
    LPWSTR wsDescription;
    BOOL result;
 
    TRACE("(0x%Ix, %ld, %s, %08lx, %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 1882 of file crypt.c.

{
    PCRYPTHASH hash;
    PCRYPTPROV prov;
 
    TRACE("(0x%Ix, %ld, %s, %08lx, %p, %p)\n",
        hHash, dwKeySpec, debugstr_w(sDescription), dwFlags, pbSignature, pdwSigLen);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!pdwSigLen || !hash->pProvider || 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 2238 of file crypt.c.

{
    LPWSTR wsDescription;
    BOOL result;
 
    TRACE("(0x%Ix, %p, %ld, 0x%Ix, %s, %08lx)\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 2205 of file crypt.c.

{
    PCRYPTHASH hash;
    PCRYPTKEY key;
    PCRYPTPROV prov;
 
    TRACE("(0x%Ix, %p, %ld, 0x%Ix, %s, %08lx)\n", hHash, pbSignature,
            dwSigLen, hPubKey, debugstr_w(sDescription), dwFlags);
 
    if (!(hash = hash_from_handle(hHash)))
        return FALSE;
 
    if (!(key = key_from_handle(hPubKey)))
        return FALSE;
 
    if (!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(), CryptVerifySignatureA(), and test_VerifySignature().

fill_random_buffer()

static BOOL fill_random_buffer ( void  )

static

Definition at line 2405 of file crypt.c.

{
    ULONG len = sizeof(SYSTEM_INTERRUPT_INFORMATION) * min( NtCurrentTeb()->Peb->NumberOfProcessors, MAX_CPUS );
    NTSTATUS status;
 
    if ((status = NtQuerySystemInformation( SystemInterruptInformation, random_buf, len, NULL )))
    {
        WARN( "failed to get random bytes %08lx\n", status );
        return FALSE;
    }
    random_len = len;
    random_pos = 0;
    return TRUE;
}

Referenced by SystemFunction036().

hash_from_handle()

static PCRYPTHASH hash_from_handle ( HCRYPTHASH  handle )

static

Definition at line 91 of file crypt.c.

{
    return pointer_from_handle(handle, MAGIC_CRYPTHASH);
}

Referenced by CryptDecrypt(), CryptDeriveKey(), CryptDestroyHash(), CryptDuplicateHash(), CryptEncrypt(), CryptGetHashParam(), CryptHashData(), CryptHashSessionKey(), CryptSetHashParam(), CryptSignHashW(), and CryptVerifySignatureW().

key_from_handle()

static PCRYPTKEY key_from_handle ( HCRYPTKEY  handle )

static

Definition at line 96 of file crypt.c.

{
    return pointer_from_handle(handle, MAGIC_CRYPTKEY);
}

Referenced by CryptCreateHash(), CryptDecrypt(), CryptDestroyKey(), CryptDuplicateKey(), CryptEncrypt(), CryptExportKey(), CryptGetKeyParam(), CryptHashSessionKey(), CryptImportKey(), CryptSetKeyParam(), and CryptVerifySignatureW().

MD4Final()

void WINAPI MD4Final

(

MD4_CTX *

ctx

)

Definition at line 113 of file md4.c.

{
    unsigned int count;
    unsigned char *p;
 
    /* Compute number of bytes mod 64 */
    count = (ctx->i[0] >> 3) & 0x3F;
 
    /* Set the first char of padding to 0x80.  This is safe since there is
       always at least one byte free */
    p = ctx->in + count;
    *p++ = 0x80;
 
    /* Bytes of padding needed to make 64 bytes */
    count = 64 - 1 - count;
 
    /* Pad out to 56 mod 64 */
    if (count < 8)
    {
        /* Two lots of padding:  Pad the first block to 64 bytes */
        memset( p, 0, count );
        byteReverse( ctx->in, 16 );
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        /* Now fill the next block with 56 bytes */
        memset( ctx->in, 0, 56 );
    }
    else
    {
        /* Pad block to 56 bytes */
        memset( p, 0, count - 8 );
    }
 
    byteReverse( ctx->in, 14 );
 
    /* Append length in bits and transform */
    ((unsigned int *)ctx->in)[14] = ctx->i[0];
    ((unsigned int *)ctx->in)[15] = ctx->i[1];
 
    MD4Transform( ctx->buf, (unsigned int *)ctx->in );
    byteReverse( (unsigned char *)ctx->buf, 4 );
    memcpy( ctx->digest, ctx->buf, 16 );
    memset(ctx->in, 0, sizeof(ctx->in));
}

Referenced by KsecGatherEntropyData(), SystemFunction007(), and SystemFunction010().

MD4Init()

void WINAPI MD4Init

(

MD4_CTX *

ctx

)

Definition at line 45 of file md4.c.

{
    ctx->buf[0] = 0x67452301;
    ctx->buf[1] = 0xefcdab89;
    ctx->buf[2] = 0x98badcfe;
    ctx->buf[3] = 0x10325476;
 
    ctx->i[0] = ctx->i[1] = 0;
}

Referenced by KsecGatherEntropyData(), SystemFunction007(), and SystemFunction010().

MD4Update()

void WINAPI MD4Update	(	MD4_CTX *	ctx,
		const unsigned char *	buf,
		unsigned int	len
	)

Definition at line 59 of file md4.c.

{
    register unsigned int t;
 
    /* Update bitcount */
    t = ctx->i[0];
 
    if ((ctx->i[0] = t + (len << 3)) < t)
        ctx->i[1]++;        /* Carry from low to high */
 
    ctx->i[1] += len >> 29;
    t = (t >> 3) & 0x3f;
 
    /* Handle any leading odd-sized chunks */
    if (t)
    {
        unsigned char *p = (unsigned char *)ctx->in + t;
        t = 64 - t;
 
        if (len < t)
        {
            memcpy( p, buf, len );
            return;
        }
 
        memcpy( p, buf, t );
        byteReverse( ctx->in, 16 );
 
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += t;
        len -= t;
    }
 
    /* Process data in 64-byte chunks */
    while (len >= 64)
    {
        memcpy( ctx->in, buf, 64 );
        byteReverse( ctx->in, 16 );
 
        MD4Transform( ctx->buf, (unsigned int *)ctx->in );
 
        buf += 64;
        len -= 64;
    }
 
    /* Handle any remaining bytes of data. */
    memcpy( ctx->in, buf, len );
}

Referenced by KsecGatherEntropyData(), SystemFunction007(), and SystemFunction010().

OpenEncryptedFileRawA()

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

Definition at line 2259 of file crypt.c.

{
    FIXME("(%s, %lx, %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 2278 of file crypt.c.

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

pointer_from_handle()

static void * pointer_from_handle ( UINT_PTR  handle, DWORD  magic  )

static

Definition at line 66 of file crypt.c.

{
    void *ret = NULL;
 
    __TRY
    {
        if (handle && *(DWORD *)handle == magic)
            ret = (void *)handle;
    }
    __EXCEPT_PAGE_FAULT
    {
    }
    __ENDTRY
 
    if (!ret)
        SetLastError(ERROR_INVALID_PARAMETER);
 
    return ret;
}

Referenced by hash_from_handle(), key_from_handle(), and provider_from_handle().

provider_from_handle()

static PCRYPTPROV provider_from_handle ( HCRYPTPROV  handle )

static

Definition at line 86 of file crypt.c.

{
    return pointer_from_handle(handle, MAGIC_CRYPTPROV);
}

Referenced by CryptContextAddRef(), CryptCreateHash(), CryptDeriveKey(), CryptGenKey(), CryptGenRandom(), CryptGetProvParam(), CryptGetUserKey(), CryptImportKey(), CryptReleaseContext(), and CryptSetProvParam().

ReadEncryptedFileRaw()

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

Definition at line 2297 of file crypt.c.

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

SystemFunction007()

NTSTATUS WINAPI SystemFunction007	(	const UNICODE_STRING *	string,
		LPBYTE	hash
	)

Definition at line 2318 of file crypt.c.

{
    MD4_CTX ctx;
 
    MD4Init( &ctx );
    MD4Update( &ctx, (const BYTE *)string->Buffer, string->Length );
    MD4Final( &ctx );
    memcpy( hash, ctx.digest, 0x10 );
 
    return STATUS_SUCCESS;
}

SystemFunction010()

NTSTATUS WINAPI SystemFunction010	(	LPVOID	unknown,
		const BYTE *	data,
		LPBYTE	hash
	)

Definition at line 2346 of file crypt.c.

{
    MD4_CTX ctx;
 
    MD4Init( &ctx );
    MD4Update( &ctx, data, 0x10 );
    MD4Final( &ctx );
    memcpy( hash, ctx.digest, 0x10 );
 
    return STATUS_SUCCESS;
}

SystemFunction030()

BOOL WINAPI SystemFunction030	(	LPCVOID	b1,
		LPCVOID	b2
	)

Definition at line 2370 of file crypt.c.

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

SystemFunction035()

BOOL WINAPI SystemFunction035

(

LPCSTR

lpszDllFilePath

)

Definition at line 2384 of file crypt.c.

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

SystemFunction036()

BOOLEAN WINAPI SystemFunction036	(	void *	buffer,
		ULONG	len
	)

Definition at line 2434 of file crypt.c.

{
    char *ptr = buffer;
 
    EnterCriticalSection( &random_cs );
    while (len)
    {
        ULONG size;
        if (random_pos >= random_len && !fill_random_buffer())
        {
            SetLastError( NTE_FAIL );
            LeaveCriticalSection( &random_cs );
            return FALSE;
        }
        size = min( len, random_len - random_pos );
        memcpy( ptr, random_buf + random_pos, size );
        random_pos += size;
        ptr += size;
        len -= size;
    }
    LeaveCriticalSection( &random_cs );
    return TRUE;
}

SystemFunction040()

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

Definition at line 2485 of file crypt.c.

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

SystemFunction041()

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

Definition at line 2513 of file crypt.c.

{
    FIXME("(%p, %lx, %lx): 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 2533 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 61 of file crypt.c.

Referenced by CRYPT_ReturnhWnd(), and CryptSetProvParam().

random_buf

char random_buf[sizeof(SYSTEM_INTERRUPT_INFORMATION) *MAX_CPUS]

static

Definition at line 2400 of file crypt.c.

Referenced by fill_random_buffer(), and SystemFunction036().

random_cs

static CRITICAL_SECTION random_cs = { &random_debug, -1, 0, 0, 0, 0 }

static

Definition at line 2390 of file crypt.c.

Referenced by SystemFunction036().

random_debug

CRITICAL_SECTION_DEBUG random_debug

static

Initial value:

=
{
    0, 0, &random_cs,
    { &random_debug.ProcessLocksList, &random_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": random_cs") }
}

Definition at line 2391 of file crypt.c.

random_len

ULONG random_len

static

Definition at line 2401 of file crypt.c.

Referenced by fill_random_buffer(), sec_parse_crypt_info(), and SystemFunction036().

random_pos

ULONG random_pos

static

Definition at line 2402 of file crypt.c.

Referenced by fill_random_buffer(), and SystemFunction036().