protectdata.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "windef.h"
#include "winbase.h"
#include "wincrypt.h"
#include "wine/debug.h"

Include dependency graph for protectdata.c:

Go to the source code of this file.

Classes
struct	protect_data_t

Macros
#define	CRYPT32_PROTECTDATA_PROV   PROV_RSA_FULL
#define	CRYPT32_PROTECTDATA_HASH_CALG   CALG_SHA1
#define	CRYPT32_PROTECTDATA_HASH_LEN   160
#define	CRYPT32_PROTECTDATA_KEY_CALG   CALG_3DES
#define	CRYPT32_PROTECTDATA_KEY_LEN   168
#define	CRYPT32_PROTECTDATA_SALT_LEN   16
#define	TRACE_DATA_BLOB(blob)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (crypt)
static const char *	hex_str (const unsigned char *p, int n)
static void	serialize_dword (DWORD value, BYTE **ptr)
static void	serialize_string (const BYTE *str, BYTE **ptr, DWORD len, DWORD width, BOOL prepend_len)
static BOOL	unserialize_dword (const BYTE *ptr, DWORD *index, DWORD size, DWORD *value)
static BOOL	unserialize_string (const BYTE *ptr, DWORD *index, DWORD size, DWORD len, DWORD width, BOOL inline_len, BYTE **data, DWORD *stored)
static BOOL	serialize (const struct protect_data_t *pInfo, DATA_BLOB *pSerial)
static BOOL	unserialize (const DATA_BLOB *pSerial, struct protect_data_t *pInfo)
static BOOL	valid_protect_data (const struct protect_data_t *pInfo)
static void	free_protect_data (struct protect_data_t *pInfo)
static BYTE *	convert_str_to_blob (LPCSTR str, DATA_BLOB *blob)
static BOOL	fill_protect_data (struct protect_data_t *pInfo, LPCWSTR szDataDescr, HCRYPTPROV hProv)
static BOOL	convert_hash_to_blob (HCRYPTHASH hHash, DATA_BLOB *blob)
static BOOL	hash_matches_blob (HCRYPTHASH hHash, const DATA_BLOB *two)
static BOOL	load_encryption_key (HCRYPTPROV hProv, DWORD key_len, const DATA_BLOB *salt, const DATA_BLOB *pOptionalEntropy, HCRYPTKEY *phKey)
static void	report (const DATA_BLOB *pDataIn, const DATA_BLOB *pOptionalEntropy, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags)
BOOL WINAPI	CryptProtectData (DATA_BLOB *pDataIn, LPCWSTR szDataDescr, DATA_BLOB *pOptionalEntropy, PVOID pvReserved, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags, DATA_BLOB *pDataOut)
BOOL WINAPI	CryptUnprotectData (DATA_BLOB *pDataIn, LPWSTR *ppszDataDescr, DATA_BLOB *pOptionalEntropy, PVOID pvReserved, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags, DATA_BLOB *pDataOut)

Variables
static const BYTE	crypt32_protectdata_secret []
static const char	crypt_magic_str [] = "Wine Crypt32 ok"

Macro Definition Documentation

CRYPT32_PROTECTDATA_HASH_CALG

#define CRYPT32_PROTECTDATA_HASH_CALG   CALG_SHA1

Definition at line 50 of file protectdata.c.

CRYPT32_PROTECTDATA_HASH_LEN

#define CRYPT32_PROTECTDATA_HASH_LEN   160

Definition at line 51 of file protectdata.c.

CRYPT32_PROTECTDATA_KEY_CALG

#define CRYPT32_PROTECTDATA_KEY_CALG   CALG_3DES

Definition at line 52 of file protectdata.c.

CRYPT32_PROTECTDATA_KEY_LEN

#define CRYPT32_PROTECTDATA_KEY_LEN   168

Definition at line 53 of file protectdata.c.

CRYPT32_PROTECTDATA_PROV

#define CRYPT32_PROTECTDATA_PROV   PROV_RSA_FULL

Definition at line 49 of file protectdata.c.

CRYPT32_PROTECTDATA_SALT_LEN

#define CRYPT32_PROTECTDATA_SALT_LEN   16

Definition at line 54 of file protectdata.c.

TRACE_DATA_BLOB

#define TRACE_DATA_BLOB

(

blob

)

Value:

    do { \
    TRACE("%s cbData: %u\n", #blob ,(unsigned int)((blob)->cbData)); \
    TRACE("%s pbData @ %p:%s\n", #blob ,(blob)->pbData, \
          hex_str((blob)->pbData, (blob)->cbData)); \
} while (0)

Definition at line 135 of file protectdata.c.

Function Documentation

convert_hash_to_blob()

static BOOL convert_hash_to_blob ( HCRYPTHASH  hHash, DATA_BLOB *  blob  )

static

Definition at line 645 of file protectdata.c.

{
    DWORD dwSize;
 
    TRACE("called\n");
 
    if (!blob) return FALSE;
 
    dwSize=sizeof(DWORD);
    if (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&blob->cbData,
                           &dwSize, 0))
    {
        ERR("failed to get hash size\n");
        return FALSE;
    }
 
    if (!(blob->pbData=CryptMemAlloc(blob->cbData)))
    {
        ERR("failed to allocate blob memory\n");
        return FALSE;
    }
 
    dwSize=blob->cbData;
    if (!CryptGetHashParam(hHash, HP_HASHVAL, blob->pbData, &dwSize, 0))
    {
        ERR("failed to get hash value\n");
        CryptMemFree(blob->pbData);
        blob->pbData=NULL;
        blob->cbData=0;
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CryptProtectData(), and hash_matches_blob().

convert_str_to_blob()

static BYTE * convert_str_to_blob ( LPCSTR  str, DATA_BLOB *  blob  )

static

Definition at line 551 of file protectdata.c.

{
    if (!str || !blob) return NULL;
 
    blob->cbData=strlen(str)+1;
    if (!(blob->pbData=CryptMemAlloc(blob->cbData)))
    {
        blob->cbData=0;
    }
    else {
        strcpy((LPSTR)blob->pbData, str);
    }
 
    return blob->pbData;
}

Referenced by fill_protect_data().

CryptProtectData()

BOOL WINAPI CryptProtectData	(	DATA_BLOB *	pDataIn,
		LPCWSTR	szDataDescr,
		DATA_BLOB *	pOptionalEntropy,
		PVOID	pvReserved,
		CRYPTPROTECT_PROMPTSTRUCT *	pPromptStruct,
		DWORD	dwFlags,
		DATA_BLOB *	pDataOut
	)

Definition at line 821 of file protectdata.c.

{
    static const WCHAR empty_str[1];
    BOOL rc = FALSE;
    HCRYPTPROV hProv;
    struct protect_data_t protect_data;
    HCRYPTHASH hHash;
    HCRYPTKEY hKey;
    DWORD dwLength;
 
    TRACE("called\n");
 
    SetLastError(ERROR_SUCCESS);
 
    if (!pDataIn || !pDataOut)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto finished;
    }
 
    /* debug: show our arguments */
    report(pDataIn,pOptionalEntropy,pPromptStruct,dwFlags);
    TRACE("\tszDataDescr: %p %s\n", szDataDescr,
          szDataDescr ? debugstr_w(szDataDescr) : "");
 
    /* Windows appears to create an empty szDataDescr instead of maintaining
     * a NULL */
    if (!szDataDescr)
        szDataDescr = empty_str;
 
    /* get crypt context */
    if (!CryptAcquireContextW(&hProv,NULL,MS_ENHANCED_PROV_W,CRYPT32_PROTECTDATA_PROV,CRYPT_VERIFYCONTEXT))
    {
        ERR("CryptAcquireContextW failed\n");
        goto finished;
    }
 
    /* populate our structure */
    if (!fill_protect_data(&protect_data,szDataDescr,hProv))
    {
        ERR("fill_protect_data\n");
        goto free_context;
    }
 
    /* load key */
    if (!load_encryption_key(hProv,protect_data.cipher_key_len,&protect_data.salt,pOptionalEntropy,&hKey))
    {
        goto free_protect_data;
    }
 
    /* create a hash for the encryption validation */
    if (!CryptCreateHash(hProv,CRYPT32_PROTECTDATA_HASH_CALG,0,0,&hHash))
    {
        ERR("CryptCreateHash\n");
        goto free_key;
    }
 
    /* calculate storage required */
    dwLength=pDataIn->cbData;
    if (CryptEncrypt(hKey, 0, TRUE, 0, pDataIn->pbData, &dwLength, 0) ||
        GetLastError()!=ERROR_MORE_DATA)
    {
        ERR("CryptEncrypt\n");
        goto free_hash;
    }
    TRACE("required encrypted storage: %u\n", dwLength);
 
    /* copy plain text into cipher area for CryptEncrypt call */
    protect_data.cipher.cbData=dwLength;
    if (!(protect_data.cipher.pbData=CryptMemAlloc(
                                                protect_data.cipher.cbData)))
    {
        ERR("CryptMemAlloc\n");
        goto free_hash;
    }
    memcpy(protect_data.cipher.pbData,pDataIn->pbData,pDataIn->cbData);
 
    /* encrypt! */
    dwLength=pDataIn->cbData;
    if (!CryptEncrypt(hKey, hHash, TRUE, 0, protect_data.cipher.pbData,
                      &dwLength, protect_data.cipher.cbData))
    {
        ERR("CryptEncrypt %u\n", GetLastError());
        goto free_hash;
    }
    protect_data.cipher.cbData=dwLength;
 
    /* debug: show the cipher */
    TRACE_DATA_BLOB(&protect_data.cipher);
 
    /* attach our fingerprint */
    if (!convert_hash_to_blob(hHash, &protect_data.fingerprint))
    {
        ERR("convert_hash_to_blob\n");
        goto free_hash;
    }
 
    /* serialize into an opaque blob */
    if (!serialize(&protect_data, pDataOut))
    {
        ERR("serialize\n");
        goto free_hash;
    }
 
    /* success! */
    rc=TRUE;
 
free_hash:
    CryptDestroyHash(hHash);
free_key:
    CryptDestroyKey(hKey);
free_protect_data:
    free_protect_data(&protect_data);
free_context:
    CryptReleaseContext(hProv,0);
finished:
    /* If some error occurred, and no error code was set, force one. */
    if (!rc && GetLastError()==ERROR_SUCCESS)
    {
        SetLastError(ERROR_INVALID_DATA);
    }
 
    if (rc)
    {
        SetLastError(ERROR_SUCCESS);
 
        TRACE_DATA_BLOB(pDataOut);
    }
 
    TRACE("returning %s\n", rc ? "ok" : "FAIL");
 
    return rc;
}

Referenced by store_key_pair().

CryptUnprotectData()

BOOL WINAPI CryptUnprotectData	(	DATA_BLOB *	pDataIn,
		LPWSTR *	ppszDataDescr,
		DATA_BLOB *	pOptionalEntropy,
		PVOID	pvReserved,
		CRYPTPROTECT_PROMPTSTRUCT *	pPromptStruct,
		DWORD	dwFlags,
		DATA_BLOB *	pDataOut
	)

Definition at line 990 of file protectdata.c.

{
    BOOL rc = FALSE;
 
    HCRYPTPROV hProv;
    struct protect_data_t protect_data;
    HCRYPTHASH hHash;
    HCRYPTKEY hKey;
    DWORD dwLength;
 
    const char * announce_bad_opaque_data = "CryptUnprotectData received a DATA_BLOB that seems to have NOT been generated by Wine.  Please enable tracing ('export WINEDEBUG=crypt') to see details.";
 
    TRACE("called\n");
 
    SetLastError(ERROR_SUCCESS);
 
    if (!pDataIn || !pDataOut)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        goto finished;
    }
    if (!pDataIn->cbData)
    {
        SetLastError(ERROR_INVALID_DATA);
        goto finished;
    }
 
    /* debug: show our arguments */
    report(pDataIn,pOptionalEntropy,pPromptStruct,dwFlags);
    TRACE("\tppszDataDescr: %p\n", ppszDataDescr);
 
    /* take apart the opaque blob */
    if (!unserialize(pDataIn, &protect_data))
    {
        SetLastError(ERROR_INVALID_DATA);
        FIXME("%s\n",announce_bad_opaque_data);
        goto finished;
    }
 
    /* perform basic validation on the resulting structure */
    if (!valid_protect_data(&protect_data))
    {
        SetLastError(ERROR_INVALID_DATA);
        FIXME("%s\n",announce_bad_opaque_data);
        goto free_protect_data;
    }
 
    /* get a crypt context */
    if (!CryptAcquireContextW(&hProv,NULL,MS_ENHANCED_PROV_W,CRYPT32_PROTECTDATA_PROV,CRYPT_VERIFYCONTEXT))
    {
        ERR("CryptAcquireContextW failed\n");
        goto free_protect_data;
    }
 
    /* load key */
    if (!load_encryption_key(hProv,protect_data.cipher_key_len,&protect_data.salt,pOptionalEntropy,&hKey))
    {
        goto free_context;
    }
 
    /* create a hash for the decryption validation */
    if (!CryptCreateHash(hProv,CRYPT32_PROTECTDATA_HASH_CALG,0,0,&hHash))
    {
        ERR("CryptCreateHash\n");
        goto free_key;
    }
 
    /* prepare for plaintext */
    pDataOut->cbData=protect_data.cipher.cbData;
    if (!(pDataOut->pbData=LocalAlloc( LPTR, pDataOut->cbData)))
    {
        ERR("CryptMemAlloc\n");
        goto free_hash;
    }
    memcpy(pDataOut->pbData,protect_data.cipher.pbData,protect_data.cipher.cbData);
 
    /* decrypt! */
    if (!CryptDecrypt(hKey, hHash, TRUE, 0, pDataOut->pbData,
                      &pDataOut->cbData) ||
        /* check the hash fingerprint */
        pDataOut->cbData > protect_data.cipher.cbData ||
        !hash_matches_blob(hHash, &protect_data.fingerprint))
    {
        SetLastError(ERROR_INVALID_DATA);
 
        LocalFree( pDataOut->pbData );
        pDataOut->pbData = NULL;
        pDataOut->cbData = 0;
 
        goto free_hash;
    }
 
    /* Copy out the description */
    dwLength = (lstrlenW(protect_data.szDataDescr)+1) * sizeof(WCHAR);
    if (ppszDataDescr)
    {
        if (!(*ppszDataDescr = LocalAlloc(LPTR,dwLength)))
        {
            ERR("LocalAlloc (ppszDataDescr)\n");
            goto free_hash;
        }
        else {
            memcpy(*ppszDataDescr,protect_data.szDataDescr,dwLength);
        }
    }
 
    /* success! */
    rc = TRUE;
 
free_hash:
    CryptDestroyHash(hHash);
free_key:
    CryptDestroyKey(hKey);
free_context:
    CryptReleaseContext(hProv,0);
free_protect_data:
    free_protect_data(&protect_data);
finished:
    /* If some error occurred, and no error code was set, force one. */
    if (!rc && GetLastError()==ERROR_SUCCESS)
    {
        SetLastError(ERROR_INVALID_DATA);
    }
 
    if (rc) {
        SetLastError(ERROR_SUCCESS);
 
        if (ppszDataDescr)
        {
            TRACE("szDataDescr: %s\n",debugstr_w(*ppszDataDescr));
        }
        TRACE_DATA_BLOB(pDataOut);
    }
 
    TRACE("returning %s\n", rc ? "ok" : "FAIL");
 
    return rc;
}

Referenced by read_key_value().

fill_protect_data()

static BOOL fill_protect_data ( struct protect_data_t *  pInfo, LPCWSTR  szDataDescr, HCRYPTPROV  hProv  )

static

Definition at line 571 of file protectdata.c.

{
    DWORD dwStrLen;
 
    TRACE("called\n");
 
    if (!pInfo) return FALSE;
 
    dwStrLen=lstrlenW(szDataDescr);
 
    memset(pInfo,0,sizeof(*pInfo));
 
    pInfo->count0=0x0001;
 
    convert_str_to_blob(crypt_magic_str, &pInfo->info0);
 
    pInfo->count1=0x0001;
 
    convert_str_to_blob(crypt_magic_str, &pInfo->info1);
 
    pInfo->null0=0x0000;
 
    if ((pInfo->szDataDescr=CryptMemAlloc((dwStrLen+1)*sizeof(WCHAR))))
    {
        memcpy(pInfo->szDataDescr,szDataDescr,(dwStrLen+1)*sizeof(WCHAR));
    }
 
    pInfo->cipher_alg=CRYPT32_PROTECTDATA_KEY_CALG;
    pInfo->cipher_key_len=CRYPT32_PROTECTDATA_KEY_LEN;
 
    convert_str_to_blob(crypt_magic_str, &pInfo->data0);
 
    pInfo->null1=0x0000;
    pInfo->hash_alg=CRYPT32_PROTECTDATA_HASH_CALG;
    pInfo->hash_len=CRYPT32_PROTECTDATA_HASH_LEN;
 
    /* allocate memory to hold a salt */
    if ((pInfo->salt.pbData=CryptMemAlloc(CRYPT32_PROTECTDATA_SALT_LEN)))
    {
        /* generate random salt */
        if (!CryptGenRandom(hProv, CRYPT32_PROTECTDATA_SALT_LEN, pInfo->salt.pbData))
        {
            ERR("CryptGenRandom\n");
            free_protect_data(pInfo);
            return FALSE;
        }
        pInfo->salt.cbData=CRYPT32_PROTECTDATA_SALT_LEN;
        /* debug: show our salt */
        TRACE_DATA_BLOB(&pInfo->salt);
    }
    pInfo->cipher.cbData=0;
    pInfo->cipher.pbData=NULL;
 
    pInfo->fingerprint.cbData=0;
    pInfo->fingerprint.pbData=NULL;
 
    /* check all the allocations at once */
    if (!pInfo->info0.pbData ||
        !pInfo->info1.pbData ||
        !pInfo->szDataDescr  ||
        !pInfo->data0.pbData ||
        !pInfo->salt.pbData
        )
    {
        ERR("could not allocate protect_data structures\n");
        free_protect_data(pInfo);
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CryptProtectData().

free_protect_data()

static void free_protect_data ( struct protect_data_t *  pInfo )

static

Definition at line 534 of file protectdata.c.

{
    TRACE("called\n");
 
    if (!pInfo) return;
 
    CryptMemFree(pInfo->info0.pbData);
    CryptMemFree(pInfo->info1.pbData);
    CryptMemFree(pInfo->szDataDescr);
    CryptMemFree(pInfo->data0.pbData);
    CryptMemFree(pInfo->salt.pbData);
    CryptMemFree(pInfo->cipher.pbData);
    CryptMemFree(pInfo->fingerprint.pbData);
}

Referenced by CryptProtectData(), CryptUnprotectData(), and fill_protect_data().

hash_matches_blob()

static BOOL hash_matches_blob ( HCRYPTHASH  hHash, const DATA_BLOB *  two  )

static

Definition at line 682 of file protectdata.c.

{
    BOOL rc = FALSE;
    DATA_BLOB one;
 
    if (!two || !two->pbData) return FALSE;
 
    if (!convert_hash_to_blob(hHash,&one)) {
        return FALSE;
    }
 
    if ( one.cbData == two->cbData &&
         memcmp( one.pbData, two->pbData, one.cbData ) == 0 )
    {
        rc = TRUE;
    }
 
    CryptMemFree(one.pbData);
    return rc;
}

Referenced by CryptUnprotectData().

hex_str()

static const char * hex_str ( const unsigned char *  p, int  n  )

static

Definition at line 116 of file protectdata.c.

{
    const char * ptr;
    char report[80];
    int r=-1;
    report[0]='\0';
    ptr = wine_dbg_sprintf("%s","");
    while (--n >= 0)
    {
        if (r++ % 20 == 19)
        {
            ptr = wine_dbg_sprintf("%s%s",ptr,report);
            report[0]='\0';
        }
        sprintf(report+strlen(report),"%s%02x", r ? "," : "", *p++);
    }
    return wine_dbg_sprintf("%s%s",ptr,report);
}

load_encryption_key()

static BOOL load_encryption_key ( HCRYPTPROV  hProv, DWORD  key_len, const DATA_BLOB *  salt, const DATA_BLOB *  pOptionalEntropy, HCRYPTKEY *  phKey  )

static

Definition at line 705 of file protectdata.c.

{
    BOOL rc = TRUE;
    HCRYPTHASH hSaltHash;
    char * szUsername = NULL;
    DWORD dwUsernameLen;
    DWORD dwError;
 
    /* create hash for salt */
    if (!salt || !phKey ||
        !CryptCreateHash(hProv,CRYPT32_PROTECTDATA_HASH_CALG,0,0,&hSaltHash))
    {
        ERR("CryptCreateHash\n");
        return FALSE;
    }
 
    /* This should be the "logon credentials" instead of username */
    dwError=GetLastError();
    dwUsernameLen = 0;
    if (!GetUserNameA(NULL, &dwUsernameLen) &&
        GetLastError() == ERROR_INSUFFICIENT_BUFFER && dwUsernameLen &&
        (szUsername = CryptMemAlloc(dwUsernameLen)))
    {
        szUsername[0]='\0';
        GetUserNameA( szUsername, &dwUsernameLen );
    }
    SetLastError(dwError);
 
    /* salt the hash with:
     * - the user id
     * - an "internal secret"
     * - randomness (from the salt)
     * - user-supplied entropy
     */
    if ((szUsername && !CryptHashData(hSaltHash,(LPBYTE)szUsername,dwUsernameLen,0)) ||
        !CryptHashData(hSaltHash,crypt32_protectdata_secret,
                                 sizeof(crypt32_protectdata_secret)-1,0) ||
        !CryptHashData(hSaltHash,salt->pbData,salt->cbData,0) ||
        (pOptionalEntropy && !CryptHashData(hSaltHash,
                                            pOptionalEntropy->pbData,
                                            pOptionalEntropy->cbData,0)))
    {
        ERR("CryptHashData\n");
        rc = FALSE;
    }
 
    /* produce a symmetric key */
    if (rc && !CryptDeriveKey(hProv,CRYPT32_PROTECTDATA_KEY_CALG,
                              hSaltHash,key_len << 16 | CRYPT_EXPORTABLE,phKey))
    {
        ERR("CryptDeriveKey\n");
        rc = FALSE;
    }
 
    /* clean up */
    CryptDestroyHash(hSaltHash);
    CryptMemFree(szUsername);
 
    return rc;
}

Referenced by CryptProtectData(), and CryptUnprotectData().

report()

static void report ( const DATA_BLOB *  pDataIn, const DATA_BLOB *  pOptionalEntropy, CRYPTPROTECT_PROMPTSTRUCT *  pPromptStruct, DWORD  dwFlags  )

static

Definition at line 769 of file protectdata.c.

{
    TRACE("pPromptStruct: %p\n", pPromptStruct);
    if (pPromptStruct)
    {
        TRACE("  cbSize: 0x%x\n", pPromptStruct->cbSize);
        TRACE("  dwPromptFlags: 0x%x\n", pPromptStruct->dwPromptFlags);
        TRACE("  hwndApp: %p\n", pPromptStruct->hwndApp);
        TRACE("  szPrompt: %p %s\n",
              pPromptStruct->szPrompt,
              pPromptStruct->szPrompt ? debugstr_w(pPromptStruct->szPrompt)
              : "");
    }
    TRACE("dwFlags: 0x%04x\n", dwFlags);
    TRACE_DATA_BLOB(pDataIn);
    if (pOptionalEntropy)
    {
        TRACE_DATA_BLOB(pOptionalEntropy);
        TRACE("  %s\n",debugstr_an((LPCSTR)pOptionalEntropy->pbData,pOptionalEntropy->cbData));
    }
 
}

Referenced by CryptProtectData(), CryptUnprotectData(), extract_rev_infos(), extract_test(), get_subtests(), hex_str(), open_http(), print_version(), process_data(), remove_dir(), run_ex(), run_tests(), send_file(), strmake(), test_get_input_report(), test_read_device(), WinMain(), xmalloc(), xprintf(), xrealloc(), and xstrdup().

serialize()

static BOOL serialize ( const struct protect_data_t *  pInfo, DATA_BLOB *  pSerial  )

static

Definition at line 217 of file protectdata.c.

{
    BYTE * ptr;
    DWORD dwStrLen;
    DWORD dwStruct;
 
    TRACE("called\n");
 
    if (!pInfo || !pInfo->szDataDescr || !pSerial ||
        !pInfo->info0.pbData || !pInfo->info1.pbData ||
        !pInfo->data0.pbData || !pInfo->salt.pbData ||
        !pInfo->cipher.pbData || !pInfo->fingerprint.pbData)
    {
        return FALSE;
    }
 
    if (pInfo->info0.cbData!=16)
    {
        ERR("protect_data_t info0 not 16 bytes long\n");
    }
 
    if (pInfo->info1.cbData!=16)
    {
        ERR("protect_data_t info1 not 16 bytes long\n");
    }
 
    dwStrLen=lstrlenW(pInfo->szDataDescr);
 
    pSerial->cbData=0;
    pSerial->cbData+=sizeof(DWORD)*8; /* 8 raw DWORDs */
    pSerial->cbData+=sizeof(DWORD)*4; /* 4 BLOBs with size */
    pSerial->cbData+=pInfo->info0.cbData;
    pSerial->cbData+=pInfo->info1.cbData;
    pSerial->cbData+=(dwStrLen+1)*sizeof(WCHAR) + 4; /* str, null, size */
    pSerial->cbData+=pInfo->data0.cbData;
    pSerial->cbData+=pInfo->salt.cbData;
    pSerial->cbData+=pInfo->cipher.cbData;
    pSerial->cbData+=pInfo->fingerprint.cbData;
 
    /* save the actual structure size */
    dwStruct = pSerial->cbData;
    /* There may be a 256 byte minimum, but I can't prove it. */
    /*if (pSerial->cbData<256) pSerial->cbData=256;*/
 
    pSerial->pbData=LocalAlloc(LPTR,pSerial->cbData);
    if (!pSerial->pbData) return FALSE;
 
    ptr=pSerial->pbData;
 
    /* count0 */
    serialize_dword(pInfo->count0,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    
    /* info0 */
    serialize_string(pInfo->info0.pbData,&ptr,
                     pInfo->info0.cbData,sizeof(BYTE),FALSE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* count1 */
    serialize_dword(pInfo->count1,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* info1 */
    serialize_string(pInfo->info1.pbData,&ptr,
                     pInfo->info1.cbData,sizeof(BYTE),FALSE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* null0 */
    serialize_dword(pInfo->null0,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    
    /* szDataDescr */
    serialize_string((BYTE*)pInfo->szDataDescr,&ptr,
                     (dwStrLen+1)*sizeof(WCHAR),sizeof(BYTE),TRUE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* cipher_alg */
    serialize_dword(pInfo->cipher_alg,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    /* cipher_key_len */
    serialize_dword(pInfo->cipher_key_len,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    
    /* data0 */
    serialize_string(pInfo->data0.pbData,&ptr,
                     pInfo->data0.cbData,sizeof(BYTE),TRUE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* null1 */
    serialize_dword(pInfo->null1,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    
    /* hash_alg */
    serialize_dword(pInfo->hash_alg,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    /* hash_len */
    serialize_dword(pInfo->hash_len,&ptr);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
    
    /* salt */
    serialize_string(pInfo->salt.pbData,&ptr,
                     pInfo->salt.cbData,sizeof(BYTE),TRUE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* cipher */
    serialize_string(pInfo->cipher.pbData,&ptr,
                     pInfo->cipher.cbData,sizeof(BYTE),TRUE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    /* fingerprint */
    serialize_string(pInfo->fingerprint.pbData,&ptr,
                     pInfo->fingerprint.cbData,sizeof(BYTE),TRUE);
    /*TRACE("used %u\n",ptr-pSerial->pbData);*/
 
    if (ptr - pSerial->pbData != dwStruct)
    {
        ERR("struct size changed!? expected %u\n", dwStruct);
        LocalFree(pSerial->pbData);
        pSerial->pbData=NULL;
        pSerial->cbData=0;
        return FALSE;
    }
 
    return TRUE;
}

Referenced by CryptProtectData().

serialize_dword()

static void serialize_dword ( DWORD  value, BYTE **  ptr  )

static

Definition at line 142 of file protectdata.c.

{
    /*TRACE("called\n");*/
 
    memcpy(*ptr,&value,sizeof(DWORD));
    *ptr+=sizeof(DWORD);
}

Referenced by serialize(), and serialize_string().

serialize_string()

static void serialize_string ( const BYTE *  str, BYTE **  ptr, DWORD  len, DWORD  width, BOOL  prepend_len  )

static

Definition at line 151 of file protectdata.c.

{
    /*TRACE("called %ux%u\n",(unsigned int)len,(unsigned int)width);*/
 
    if (prepend_len)
    {
        serialize_dword(len,ptr);
    }
    memcpy(*ptr,str,len*width);
    *ptr+=len*width;
}

Referenced by serialize().

unserialize()

static BOOL unserialize ( const DATA_BLOB *  pSerial, struct protect_data_t *  pInfo  )

static

Definition at line 344 of file protectdata.c.

{
    BYTE * ptr;
    DWORD index;
    DWORD size;
    BOOL status=TRUE;
 
    TRACE("called\n");
 
    if (!pInfo || !pSerial || !pSerial->pbData)
        return FALSE;
 
    index=0;
    ptr=pSerial->pbData;
    size=pSerial->cbData;
 
    /* count0 */
    if (!unserialize_dword(ptr,&index,size,&pInfo->count0))
    {
        ERR("reading count0 failed!\n");
        return FALSE;
    }
    
    /* info0 */
    if (!unserialize_string(ptr,&index,size,16,sizeof(BYTE),FALSE,
                            &pInfo->info0.pbData, &pInfo->info0.cbData))
    {
        ERR("reading info0 failed!\n");
        return FALSE;
    }
 
    /* count1 */
    if (!unserialize_dword(ptr,&index,size,&pInfo->count1))
    {
        ERR("reading count1 failed!\n");
        return FALSE;
    }
 
    /* info1 */
    if (!unserialize_string(ptr,&index,size,16,sizeof(BYTE),FALSE,
                            &pInfo->info1.pbData, &pInfo->info1.cbData))
    {
        ERR("reading info1 failed!\n");
        return FALSE;
    }
 
    /* null0 */
    if (!unserialize_dword(ptr,&index,size,&pInfo->null0))
    {
        ERR("reading null0 failed!\n");
        return FALSE;
    }
    
    /* szDataDescr */
    if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
                            (BYTE**)&pInfo->szDataDescr, NULL))
    {
        ERR("reading szDataDescr failed!\n");
        return FALSE;
    }
 
    /* cipher_alg */
    if (!unserialize_dword(ptr,&index,size,&pInfo->cipher_alg))
    {
        ERR("reading cipher_alg failed!\n");
        return FALSE;
    }
    
    /* cipher_key_len */
    if (!unserialize_dword(ptr,&index,size,&pInfo->cipher_key_len))
    {
        ERR("reading cipher_key_len failed!\n");
        return FALSE;
    }
    
    /* data0 */
    if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
                            &pInfo->data0.pbData, &pInfo->data0.cbData))
    {
        ERR("reading data0 failed!\n");
        return FALSE;
    }
 
    /* null1 */
    if (!unserialize_dword(ptr,&index,size,&pInfo->null1))
    {
        ERR("reading null1 failed!\n");
        return FALSE;
    }
    
    /* hash_alg */
    if (!unserialize_dword(ptr,&index,size,&pInfo->hash_alg))
    {
        ERR("reading hash_alg failed!\n");
        return FALSE;
    }
    
    /* hash_len */
    if (!unserialize_dword(ptr,&index,size,&pInfo->hash_len))
    {
        ERR("reading hash_len failed!\n");
        return FALSE;
    }
    
    /* salt */
    if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
                            &pInfo->salt.pbData, &pInfo->salt.cbData))
    {
        ERR("reading salt failed!\n");
        return FALSE;
    }
 
    /* cipher */
    if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
                            &pInfo->cipher.pbData, &pInfo->cipher.cbData))
    {
        ERR("reading cipher failed!\n");
        return FALSE;
    }
 
    /* fingerprint */
    if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
                            &pInfo->fingerprint.pbData, &pInfo->fingerprint.cbData))
    {
        ERR("reading fingerprint failed!\n");
        return FALSE;
    }
 
    /* allow structure size to be too big (since some applications
     * will pad this up to 256 bytes, it seems) */
    if (index>size)
    {
        /* this is an impossible-to-reach test, but if the padding
         * issue is ever understood, this may become more useful */
        ERR("loaded corrupt structure! (used %u expected %u)\n", index, size);
        status=FALSE;
    }
 
    return status;
}

Referenced by CryptUnprotectData().

unserialize_dword()

static BOOL unserialize_dword ( const BYTE *  ptr, DWORD *  index, DWORD  size, DWORD *  value  )

static

Definition at line 165 of file protectdata.c.

{
    /*TRACE("called\n");*/
 
    if (!ptr || !index || !value) return FALSE;
 
    if (*index+sizeof(DWORD)>size)
    {
        return FALSE;
    }
 
    memcpy(value,&(ptr[*index]),sizeof(DWORD));
    *index+=sizeof(DWORD);
 
    return TRUE;
}

Referenced by unserialize(), and unserialize_string().

unserialize_string()

static BOOL unserialize_string ( const BYTE *  ptr, DWORD *  index, DWORD  size, DWORD  len, DWORD  width, BOOL  inline_len, BYTE **  data, DWORD *  stored  )

static

Definition at line 183 of file protectdata.c.

{
    /*TRACE("called\n");*/
 
    if (!ptr || !data) return FALSE;
 
    if (inline_len) {
        if (!unserialize_dword(ptr,index,size,&len))
            return FALSE;
    }
 
    if (*index+len*width>size)
    {
        return FALSE;
    }
 
    if (!(*data = CryptMemAlloc( len*width)))
    {
        return FALSE;
    }
 
    memcpy(*data,&(ptr[*index]),len*width);
    if (stored)
    {
        *stored = len;
    }
    *index+=len*width;
 
    return TRUE;
}

Referenced by unserialize().

valid_protect_data()

static BOOL valid_protect_data ( const struct protect_data_t *  pInfo )

static

Definition at line 487 of file protectdata.c.

{
    BOOL status=TRUE;
 
    TRACE("called\n");
 
    if (pInfo->count0 != 0x0001)
    {
        ERR("count0 != 0x0001 !\n");
        status=FALSE;
    }
    if (pInfo->count1 != 0x0001)
    {
        ERR("count0 != 0x0001 !\n");
        status=FALSE;
    }
    if (pInfo->null0 != 0x0000)
    {
        ERR("null0 != 0x0000 !\n");
        status=FALSE;
    }
    if (pInfo->null1 != 0x0000)
    {
        ERR("null1 != 0x0000 !\n");
        status=FALSE;
    }
    /* since we have no idea what info0 is used for, and it seems
     * rather constant, we can test for a Wine-specific magic string
     * there to be reasonably sure we're using data created by the Wine
     * implementation of CryptProtectData.
     */
    if (pInfo->info0.cbData!=strlen(crypt_magic_str)+1 ||
        strcmp( (LPCSTR)pInfo->info0.pbData,crypt_magic_str) != 0)
    {
        ERR("info0 magic value not matched !\n");
        status=FALSE;
    }
 
    if (!status)
    {
        ERR("unrecognized CryptProtectData block\n");
    }
 
    return status;
}

Referenced by CryptUnprotectData().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

crypt

)

Variable Documentation

crypt32_protectdata_secret

const BYTE crypt32_protectdata_secret[]

static

Initial value:

= {
    'I','\'','m',' ','h','u','n','t','i','n','g',' ',
    'w','a','b','b','i','t','s',0
}

Definition at line 56 of file protectdata.c.

Referenced by load_encryption_key().

crypt_magic_str

const char crypt_magic_str[] = "Wine Crypt32 ok"

static

Definition at line 112 of file protectdata.c.

Referenced by fill_protect_data(), and valid_protect_data().