ReactOS  0.4.13-dev-259-g5ca9c9c
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 charhex_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 BYTEconvert_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)
static const char * hex_str(const unsigned char *p, int n)
Definition: protectdata.c:116
Definition: image.c:133
_In_ HCRYPTHASH _In_ BOOL _In_ DWORD _Inout_updates_bytes_to_ pdwDataLen BYTE * pbData
Definition: wincrypt.h:4201

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.

646 {
647  DWORD dwSize;
648 
649  TRACE("called\n");
650 
651  if (!blob) return FALSE;
652 
653  dwSize=sizeof(DWORD);
654  if (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&blob->cbData,
655  &dwSize, 0))
656  {
657  ERR("failed to get hash size\n");
658  return FALSE;
659  }
660 
661  if (!(blob->pbData=CryptMemAlloc(blob->cbData)))
662  {
663  ERR("failed to allocate blob memory\n");
664  return FALSE;
665  }
666 
667  dwSize=blob->cbData;
668  if (!CryptGetHashParam(hHash, HP_HASHVAL, blob->pbData, &dwSize, 0))
669  {
670  ERR("failed to get hash value\n");
671  CryptMemFree(blob->pbData);
672  blob->pbData=NULL;
673  blob->cbData=0;
674  return FALSE;
675  }
676 
677  return TRUE;
678 }
#define TRUE
Definition: types.h:120
_In_ HCRYPTHASH hHash
Definition: wincrypt.h:4198
Definition: image.c:133
#define HP_HASHSIZE
Definition: wincrypt.h:2184
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
BOOL WINAPI CryptGetHashParam(HCRYPTHASH hHash, DWORD dwParam, BYTE *pbData, DWORD *pdwDataLen, DWORD dwFlags)
Definition: crypt.c:1615
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char BYTE
Definition: mem.h:68
#define ERR(fmt,...)
Definition: debug.h:109
static DATA_BLOB CRYPTPROTECT_PROMPTSTRUCT DWORD
Definition: protectdata.c:30
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define HP_HASHVAL
Definition: wincrypt.h:2183
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54

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.

552 {
553  if (!str || !blob) return NULL;
554 
555  blob->cbData=strlen(str)+1;
556  if (!(blob->pbData=CryptMemAlloc(blob->cbData)))
557  {
558  blob->cbData=0;
559  }
560  else {
561  strcpy((LPSTR)blob->pbData, str);
562  }
563 
564  return blob->pbData;
565 }
Definition: image.c:133
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * LPSTR
Definition: xmlstorage.h:182
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388

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.

828 {
829  static const WCHAR empty_str[1];
830  BOOL rc = FALSE;
832  struct protect_data_t protect_data;
834  HCRYPTKEY hKey;
835  DWORD dwLength;
836 
837  TRACE("called\n");
838 
840 
841  if (!pDataIn || !pDataOut)
842  {
844  goto finished;
845  }
846 
847  /* debug: show our arguments */
848  report(pDataIn,pOptionalEntropy,pPromptStruct,dwFlags);
849  TRACE("\tszDataDescr: %p %s\n", szDataDescr,
851 
852  /* Windows appears to create an empty szDataDescr instead of maintaining
853  * a NULL */
854  if (!szDataDescr)
856 
857  /* get crypt context */
859  {
860  ERR("CryptAcquireContextW failed\n");
861  goto finished;
862  }
863 
864  /* populate our structure */
865  if (!fill_protect_data(&protect_data,szDataDescr,hProv))
866  {
867  ERR("fill_protect_data\n");
868  goto free_context;
869  }
870 
871  /* load key */
872  if (!load_encryption_key(hProv,protect_data.cipher_key_len,&protect_data.salt,pOptionalEntropy,&hKey))
873  {
874  goto free_protect_data;
875  }
876 
877  /* create a hash for the encryption validation */
879  {
880  ERR("CryptCreateHash\n");
881  goto free_key;
882  }
883 
884  /* calculate storage required */
885  dwLength=pDataIn->cbData;
886  if (CryptEncrypt(hKey, 0, TRUE, 0, pDataIn->pbData, &dwLength, 0) ||
888  {
889  ERR("CryptEncrypt\n");
890  goto free_hash;
891  }
892  TRACE("required encrypted storage: %u\n", dwLength);
893 
894  /* copy plain text into cipher area for CryptEncrypt call */
895  protect_data.cipher.cbData=dwLength;
896  if (!(protect_data.cipher.pbData=CryptMemAlloc(
897  protect_data.cipher.cbData)))
898  {
899  ERR("CryptMemAlloc\n");
900  goto free_hash;
901  }
902  memcpy(protect_data.cipher.pbData,pDataIn->pbData,pDataIn->cbData);
903 
904  /* encrypt! */
905  dwLength=pDataIn->cbData;
906  if (!CryptEncrypt(hKey, hHash, TRUE, 0, protect_data.cipher.pbData,
907  &dwLength, protect_data.cipher.cbData))
908  {
909  ERR("CryptEncrypt %u\n", GetLastError());
910  goto free_hash;
911  }
912  protect_data.cipher.cbData=dwLength;
913 
914  /* debug: show the cipher */
915  TRACE_DATA_BLOB(&protect_data.cipher);
916 
917  /* attach our fingerprint */
918  if (!convert_hash_to_blob(hHash, &protect_data.fingerprint))
919  {
920  ERR("convert_hash_to_blob\n");
921  goto free_hash;
922  }
923 
924  /* serialize into an opaque blob */
925  if (!serialize(&protect_data, pDataOut))
926  {
927  ERR("serialize\n");
928  goto free_hash;
929  }
930 
931  /* success! */
932  rc=TRUE;
933 
934 free_hash:
936 free_key:
937  CryptDestroyKey(hKey);
939  free_protect_data(&protect_data);
940 free_context:
942 finished:
943  /* If some error occurred, and no error code was set, force one. */
944  if (!rc && GetLastError()==ERROR_SUCCESS)
945  {
947  }
948 
949  if (rc)
950  {
952 
953  TRACE_DATA_BLOB(pDataOut);
954  }
955 
956  TRACE("returning %s\n", rc ? "ok" : "FAIL");
957 
958  return rc;
959 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
static const TCHAR empty_str[]
Definition: dialog.c:32
static BOOL convert_hash_to_blob(HCRYPTHASH hHash, DATA_BLOB *blob)
Definition: protectdata.c:645
#define ERROR_SUCCESS
Definition: deptool.c:10
_In_ HCRYPTHASH hHash
Definition: wincrypt.h:4198
#define CRYPT32_PROTECTDATA_PROV
Definition: protectdata.c:49
static BOOL fill_protect_data(struct protect_data_t *pInfo, LPCWSTR szDataDescr, HCRYPTPROV hProv)
Definition: protectdata.c:571
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
static HCRYPTPROV hProv
Definition: rsaenh.c:32
WCHAR * szDataDescr
Definition: protectdata.c:99
BOOL WINAPI CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
Definition: crypt.c:358
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned int BOOL
Definition: ntddk_ex.h:94
static BOOL serialize(const struct protect_data_t *pInfo, DATA_BLOB *pSerial)
Definition: protectdata.c:217
#define debugstr_w
Definition: kernel32.h:32
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI CryptDestroyKey(HCRYPTKEY hKey)
Definition: crypt.c:935
static void report(const DATA_BLOB *pDataIn, const DATA_BLOB *pOptionalEntropy, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags)
Definition: protectdata.c:769
BOOL WINAPI CryptEncrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen, DWORD dwBufLen)
Definition: crypt.c:1098
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
static DWORD DWORD * dwLength
Definition: fusion.c:83
#define CRYPT32_PROTECTDATA_HASH_CALG
Definition: protectdata.c:50
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:895
BYTE * pbData
Definition: wincrypt.h:103
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:745
static BOOL load_encryption_key(HCRYPTPROV hProv, DWORD key_len, const DATA_BLOB *salt, const DATA_BLOB *pOptionalEntropy, HCRYPTKEY *phKey)
Definition: protectdata.c:705
#define ERROR_MORE_DATA
Definition: dderror.h:13
static const WCHAR MS_ENHANCED_PROV_W[]
Definition: wincrypt.h:1882
#define CRYPT_VERIFYCONTEXT
Definition: wincrypt.h:2069
#define ERROR_INVALID_DATA
Definition: winerror.h:116
ULONG_PTR HCRYPTHASH
Definition: wincrypt.h:50
#define ERR(fmt,...)
Definition: debug.h:109
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
static void free_protect_data(struct protect_data_t *pInfo)
Definition: protectdata.c:534
ULONG_PTR HCRYPTKEY
Definition: wincrypt.h:49
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, ULONG_PTR dwFlags)
Definition: crypt.c:651
#define TRACE_DATA_BLOB(blob)
Definition: protectdata.c:135

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.

997 {
998  BOOL rc = FALSE;
999 
1000  HCRYPTPROV hProv;
1001  struct protect_data_t protect_data;
1002  HCRYPTHASH hHash;
1003  HCRYPTKEY hKey;
1004  DWORD dwLength;
1005 
1006  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.";
1007 
1008  TRACE("called\n");
1009 
1011 
1012  if (!pDataIn || !pDataOut)
1013  {
1015  goto finished;
1016  }
1017  if (!pDataIn->cbData)
1018  {
1020  goto finished;
1021  }
1022 
1023  /* debug: show our arguments */
1024  report(pDataIn,pOptionalEntropy,pPromptStruct,dwFlags);
1025  TRACE("\tppszDataDescr: %p\n", ppszDataDescr);
1026 
1027  /* take apart the opaque blob */
1028  if (!unserialize(pDataIn, &protect_data))
1029  {
1031  FIXME("%s\n",announce_bad_opaque_data);
1032  goto finished;
1033  }
1034 
1035  /* perform basic validation on the resulting structure */
1036  if (!valid_protect_data(&protect_data))
1037  {
1039  FIXME("%s\n",announce_bad_opaque_data);
1040  goto free_protect_data;
1041  }
1042 
1043  /* get a crypt context */
1045  {
1046  ERR("CryptAcquireContextW failed\n");
1047  goto free_protect_data;
1048  }
1049 
1050  /* load key */
1051  if (!load_encryption_key(hProv,protect_data.cipher_key_len,&protect_data.salt,pOptionalEntropy,&hKey))
1052  {
1053  goto free_context;
1054  }
1055 
1056  /* create a hash for the decryption validation */
1058  {
1059  ERR("CryptCreateHash\n");
1060  goto free_key;
1061  }
1062 
1063  /* prepare for plaintext */
1064  pDataOut->cbData=protect_data.cipher.cbData;
1065  if (!(pDataOut->pbData=LocalAlloc( LPTR, pDataOut->cbData)))
1066  {
1067  ERR("CryptMemAlloc\n");
1068  goto free_hash;
1069  }
1070  memcpy(pDataOut->pbData,protect_data.cipher.pbData,protect_data.cipher.cbData);
1071 
1072  /* decrypt! */
1073  if (!CryptDecrypt(hKey, hHash, TRUE, 0, pDataOut->pbData,
1074  &pDataOut->cbData) ||
1075  /* check the hash fingerprint */
1076  pDataOut->cbData > protect_data.cipher.cbData ||
1077  !hash_matches_blob(hHash, &protect_data.fingerprint))
1078  {
1080 
1081  LocalFree( pDataOut->pbData );
1082  pDataOut->pbData = NULL;
1083  pDataOut->cbData = 0;
1084 
1085  goto free_hash;
1086  }
1087 
1088  /* Copy out the description */
1089  dwLength = (lstrlenW(protect_data.szDataDescr)+1) * sizeof(WCHAR);
1090  if (ppszDataDescr)
1091  {
1092  if (!(*ppszDataDescr = LocalAlloc(LPTR,dwLength)))
1093  {
1094  ERR("LocalAlloc (ppszDataDescr)\n");
1095  goto free_hash;
1096  }
1097  else {
1098  memcpy(*ppszDataDescr,protect_data.szDataDescr,dwLength);
1099  }
1100  }
1101 
1102  /* success! */
1103  rc = TRUE;
1104 
1105 free_hash:
1107 free_key:
1108  CryptDestroyKey(hKey);
1109 free_context:
1112  free_protect_data(&protect_data);
1113 finished:
1114  /* If some error occurred, and no error code was set, force one. */
1115  if (!rc && GetLastError()==ERROR_SUCCESS)
1116  {
1118  }
1119 
1120  if (rc) {
1122 
1123  if (ppszDataDescr)
1124  {
1125  TRACE("szDataDescr: %s\n",debugstr_w(*ppszDataDescr));
1126  }
1127  TRACE_DATA_BLOB(pDataOut);
1128  }
1129 
1130  TRACE("returning %s\n", rc ? "ok" : "FAIL");
1131 
1132  return rc;
1133 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
#define ERROR_SUCCESS
Definition: deptool.c:10
_In_ HCRYPTHASH hHash
Definition: wincrypt.h:4198
#define CRYPT32_PROTECTDATA_PROV
Definition: protectdata.c:49
static BOOL unserialize(const DATA_BLOB *pSerial, struct protect_data_t *pInfo)
Definition: protectdata.c:344
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define lstrlenW
Definition: compat.h:407
static HCRYPTPROV hProv
Definition: rsaenh.c:32
BOOL WINAPI CryptAcquireContextW(HCRYPTPROV *phProv, LPCWSTR pszContainer, LPCWSTR pszProvider, DWORD dwProvType, DWORD dwFlags)
Definition: crypt.c:358
unsigned int BOOL
Definition: ntddk_ex.h:94
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
smooth NULL
Definition: ftsmooth.c:416
static BOOL hash_matches_blob(HCRYPTHASH hHash, const DATA_BLOB *two)
Definition: protectdata.c:682
BOOL WINAPI CryptDestroyKey(HCRYPTKEY hKey)
Definition: crypt.c:935
BOOL WINAPI CryptDecrypt(HCRYPTKEY hKey, HCRYPTHASH hHash, BOOL Final, DWORD dwFlags, BYTE *pbData, DWORD *pdwDataLen)
Definition: crypt.c:805
static void report(const DATA_BLOB *pDataIn, const DATA_BLOB *pOptionalEntropy, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags)
Definition: protectdata.c:769
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
static DWORD DWORD * dwLength
Definition: fusion.c:83
#define CRYPT32_PROTECTDATA_HASH_CALG
Definition: protectdata.c:50
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:895
BYTE * pbData
Definition: wincrypt.h:103
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:745
static BOOL load_encryption_key(HCRYPTPROV hProv, DWORD key_len, const DATA_BLOB *salt, const DATA_BLOB *pOptionalEntropy, HCRYPTKEY *phKey)
Definition: protectdata.c:705
static BOOL valid_protect_data(const struct protect_data_t *pInfo)
Definition: protectdata.c:487
static const WCHAR MS_ENHANCED_PROV_W[]
Definition: wincrypt.h:1882
#define CRYPT_VERIFYCONTEXT
Definition: wincrypt.h:2069
#define ERROR_INVALID_DATA
Definition: winerror.h:116
ULONG_PTR HCRYPTHASH
Definition: wincrypt.h:50
#define ERR(fmt,...)
Definition: debug.h:109
ULONG_PTR HCRYPTPROV
Definition: wincrypt.h:46
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
static void free_protect_data(struct protect_data_t *pInfo)
Definition: protectdata.c:534
ULONG_PTR HCRYPTKEY
Definition: wincrypt.h:49
BOOL WINAPI CryptReleaseContext(HCRYPTPROV hProv, ULONG_PTR dwFlags)
Definition: crypt.c:651
#define LPTR
Definition: winbase.h:362
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
#define TRACE_DATA_BLOB(blob)
Definition: protectdata.c:135

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.

573 {
574  DWORD dwStrLen;
575 
576  TRACE("called\n");
577 
578  if (!pInfo) return FALSE;
579 
580  dwStrLen=lstrlenW(szDataDescr);
581 
582  memset(pInfo,0,sizeof(*pInfo));
583 
584  pInfo->count0=0x0001;
585 
587 
588  pInfo->count1=0x0001;
589 
591 
592  pInfo->null0=0x0000;
593 
594  if ((pInfo->szDataDescr=CryptMemAlloc((dwStrLen+1)*sizeof(WCHAR))))
595  {
596  memcpy(pInfo->szDataDescr,szDataDescr,(dwStrLen+1)*sizeof(WCHAR));
597  }
598 
601 
603 
604  pInfo->null1=0x0000;
607 
608  /* allocate memory to hold a salt */
610  {
611  /* generate random salt */
613  {
614  ERR("CryptGenRandom\n");
615  free_protect_data(pInfo);
616  return FALSE;
617  }
619  /* debug: show our salt */
620  TRACE_DATA_BLOB(&pInfo->salt);
621  }
622  pInfo->cipher.cbData=0;
623  pInfo->cipher.pbData=NULL;
624 
625  pInfo->fingerprint.cbData=0;
626  pInfo->fingerprint.pbData=NULL;
627 
628  /* check all the allocations at once */
629  if (!pInfo->info0.pbData ||
630  !pInfo->info1.pbData ||
631  !pInfo->szDataDescr ||
632  !pInfo->data0.pbData ||
633  !pInfo->salt.pbData
634  )
635  {
636  ERR("could not allocate protect_data structures\n");
637  free_protect_data(pInfo);
638  return FALSE;
639  }
640 
641  return TRUE;
642 }
static BYTE * convert_str_to_blob(LPCSTR str, DATA_BLOB *blob)
Definition: protectdata.c:551
#define TRUE
Definition: types.h:120
DATA_BLOB cipher
Definition: protectdata.c:107
static const char crypt_magic_str[]
Definition: protectdata.c:112
#define CRYPT32_PROTECTDATA_KEY_CALG
Definition: protectdata.c:52
#define CRYPT32_PROTECTDATA_KEY_LEN
Definition: protectdata.c:53
#define lstrlenW
Definition: compat.h:407
static HCRYPTPROV hProv
Definition: rsaenh.c:32
WCHAR * szDataDescr
Definition: protectdata.c:99
BOOL WINAPI CryptGenRandom(HCRYPTPROV hProv, DWORD dwLen, BYTE *pbBuffer)
Definition: crypt.c:705
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
DWORD cipher_key_len
Definition: protectdata.c:101
DATA_BLOB fingerprint
Definition: protectdata.c:108
smooth NULL
Definition: ftsmooth.c:416
DATA_BLOB info0
Definition: protectdata.c:95
DATA_BLOB salt
Definition: protectdata.c:106
DATA_BLOB info1
Definition: protectdata.c:97
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define CRYPT32_PROTECTDATA_HASH_CALG
Definition: protectdata.c:50
unsigned long DWORD
Definition: ntddk_ex.h:95
DATA_BLOB data0
Definition: protectdata.c:102
#define CRYPT32_PROTECTDATA_SALT_LEN
Definition: protectdata.c:54
BYTE * pbData
Definition: wincrypt.h:103
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ERR(fmt,...)
Definition: debug.h:109
static void free_protect_data(struct protect_data_t *pInfo)
Definition: protectdata.c:534
#define CRYPT32_PROTECTDATA_HASH_LEN
Definition: protectdata.c:51
ALG_ID cipher_alg
Definition: protectdata.c:100
#define memset(x, y, z)
Definition: compat.h:39
#define TRACE_DATA_BLOB(blob)
Definition: protectdata.c:135

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.

535 {
536  TRACE("called\n");
537 
538  if (!pInfo) return;
539 
540  CryptMemFree(pInfo->info0.pbData);
541  CryptMemFree(pInfo->info1.pbData);
542  CryptMemFree(pInfo->szDataDescr);
543  CryptMemFree(pInfo->data0.pbData);
544  CryptMemFree(pInfo->salt.pbData);
545  CryptMemFree(pInfo->cipher.pbData);
547 }
DATA_BLOB cipher
Definition: protectdata.c:107
WCHAR * szDataDescr
Definition: protectdata.c:99
DATA_BLOB fingerprint
Definition: protectdata.c:108
DATA_BLOB info0
Definition: protectdata.c:95
DATA_BLOB salt
Definition: protectdata.c:106
DATA_BLOB info1
Definition: protectdata.c:97
#define TRACE(s)
Definition: solgame.cpp:4
DATA_BLOB data0
Definition: protectdata.c:102
BYTE * pbData
Definition: wincrypt.h:103
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141

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.

683 {
684  BOOL rc = FALSE;
685  DATA_BLOB one;
686 
687  if (!two || !two->pbData) return FALSE;
688 
689  if (!convert_hash_to_blob(hHash,&one)) {
690  return FALSE;
691  }
692 
693  if ( one.cbData == two->cbData &&
694  memcmp( one.pbData, two->pbData, one.cbData ) == 0 )
695  {
696  rc = TRUE;
697  }
698 
699  CryptMemFree(one.pbData);
700  return rc;
701 }
#define TRUE
Definition: types.h:120
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
static BOOL convert_hash_to_blob(HCRYPTHASH hHash, DATA_BLOB *blob)
Definition: protectdata.c:645
_In_ HCRYPTHASH hHash
Definition: wincrypt.h:4198
static double one
Definition: j0_y0.c:80
unsigned int BOOL
Definition: ntddk_ex.h:94
static double two
Definition: jn_yn.c:52
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141

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.

117 {
118  const char * ptr;
119  char report[80];
120  int r=-1;
121  report[0]='\0';
122  ptr = wine_dbg_sprintf("%s","");
123  while (--n >= 0)
124  {
125  if (r++ % 20 == 19)
126  {
127  ptr = wine_dbg_sprintf("%s%s",ptr,report);
128  report[0]='\0';
129  }
130  sprintf(report+strlen(report),"%s%02x", r ? "," : "", *p++);
131  }
132  return wine_dbg_sprintf("%s%s",ptr,report);
133 }
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLdouble n
Definition: glext.h:7729
const char * wine_dbg_sprintf(const char *format,...)
Definition: compat.c:271
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static PVOID ptr
Definition: dispmode.c:27
static void report(const DATA_BLOB *pDataIn, const DATA_BLOB *pOptionalEntropy, CRYPTPROTECT_PROMPTSTRUCT *pPromptStruct, DWORD dwFlags)
Definition: protectdata.c:769
GLfloat GLfloat p
Definition: glext.h:8902

◆ 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.

707 {
708  BOOL rc = TRUE;
709  HCRYPTHASH hSaltHash;
710  char * szUsername = NULL;
711  DWORD dwUsernameLen;
712  DWORD dwError;
713 
714  /* create hash for salt */
715  if (!salt || !phKey ||
717  {
718  ERR("CryptCreateHash\n");
719  return FALSE;
720  }
721 
722  /* This should be the "logon credentials" instead of username */
723  dwError=GetLastError();
724  dwUsernameLen = 0;
725  if (!GetUserNameA(NULL, &dwUsernameLen) &&
726  GetLastError() == ERROR_INSUFFICIENT_BUFFER && dwUsernameLen &&
727  (szUsername = CryptMemAlloc(dwUsernameLen)))
728  {
729  szUsername[0]='\0';
730  GetUserNameA( szUsername, &dwUsernameLen );
731  }
732  SetLastError(dwError);
733 
734  /* salt the hash with:
735  * - the user id
736  * - an "internal secret"
737  * - randomness (from the salt)
738  * - user-supplied entropy
739  */
740  if ((szUsername && !CryptHashData(hSaltHash,(LPBYTE)szUsername,dwUsernameLen,0)) ||
742  sizeof(crypt32_protectdata_secret)-1,0) ||
743  !CryptHashData(hSaltHash,salt->pbData,salt->cbData,0) ||
744  (pOptionalEntropy && !CryptHashData(hSaltHash,
745  pOptionalEntropy->pbData,
746  pOptionalEntropy->cbData,0)))
747  {
748  ERR("CryptHashData\n");
749  rc = FALSE;
750  }
751 
752  /* produce a symmetric key */
754  hSaltHash,key_len << 16 | CRYPT_EXPORTABLE,phKey))
755  {
756  ERR("CryptDeriveKey\n");
757  rc = FALSE;
758  }
759 
760  /* clean up */
761  CryptDestroyHash(hSaltHash);
762  CryptMemFree(szUsername);
763 
764  return rc;
765 }
#define TRUE
Definition: types.h:120
#define CRYPT32_PROTECTDATA_KEY_CALG
Definition: protectdata.c:52
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
static HCRYPTPROV hProv
Definition: rsaenh.c:32
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
unsigned char * LPBYTE
Definition: typedefs.h:52
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
static const BYTE crypt32_protectdata_secret[]
Definition: protectdata.c:56
DATA_BLOB salt
Definition: protectdata.c:106
BOOL WINAPI CryptDeriveKey(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTHASH hBaseData, DWORD dwFlags, HCRYPTKEY *phKey)
Definition: crypt.c:843
#define CRYPT32_PROTECTDATA_HASH_CALG
Definition: protectdata.c:50
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:409
BOOL WINAPI CryptDestroyHash(HCRYPTHASH hHash)
Definition: crypt.c:895
BYTE * pbData
Definition: wincrypt.h:103
BOOL WINAPI GetUserNameA(LPSTR lpszName, LPDWORD lpSize)
Definition: misc.c:246
BOOL WINAPI CryptCreateHash(HCRYPTPROV hProv, ALG_ID Algid, HCRYPTKEY hKey, DWORD dwFlags, HCRYPTHASH *phHash)
Definition: crypt.c:745
ULONG_PTR HCRYPTHASH
Definition: wincrypt.h:50
#define ERR(fmt,...)
Definition: debug.h:109
BOOL WINAPI CryptHashData(HCRYPTHASH hHash, const BYTE *pbData, DWORD dwDataLen, DWORD dwFlags)
Definition: crypt.c:1776
VOID WINAPI CryptMemFree(LPVOID pv)
Definition: main.c:141
#define CRYPT_EXPORTABLE
Definition: wincrypt.h:2206
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10

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.

771 {
772  TRACE("pPromptStruct: %p\n", pPromptStruct);
773  if (pPromptStruct)
774  {
775  TRACE(" cbSize: 0x%x\n", pPromptStruct->cbSize);
776  TRACE(" dwPromptFlags: 0x%x\n", pPromptStruct->dwPromptFlags);
777  TRACE(" hwndApp: %p\n", pPromptStruct->hwndApp);
778  TRACE(" szPrompt: %p %s\n",
779  pPromptStruct->szPrompt,
780  pPromptStruct->szPrompt ? debugstr_w(pPromptStruct->szPrompt)
781  : "");
782  }
783  TRACE("dwFlags: 0x%04x\n", dwFlags);
784  TRACE_DATA_BLOB(pDataIn);
785  if (pOptionalEntropy)
786  {
787  TRACE_DATA_BLOB(pOptionalEntropy);
788  TRACE(" %s\n",debugstr_an((LPCSTR)pOptionalEntropy->pbData,pOptionalEntropy->cbData));
789  }
790 
791 }
#define debugstr_w
Definition: kernel32.h:32
const char * LPCSTR
Definition: xmlstorage.h:183
#define TRACE(s)
Definition: solgame.cpp:4
BYTE * pbData
Definition: wincrypt.h:103
static __inline const char * debugstr_an(const char *s, int n)
Definition: compat.h:47
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define TRACE_DATA_BLOB(blob)
Definition: protectdata.c:135

Referenced by CryptProtectData(), CryptUnprotectData(), do_send_report(), 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.

218 {
219  BYTE * ptr;
220  DWORD dwStrLen;
221  DWORD dwStruct;
222 
223  TRACE("called\n");
224 
225  if (!pInfo || !pInfo->szDataDescr || !pSerial ||
226  !pInfo->info0.pbData || !pInfo->info1.pbData ||
227  !pInfo->data0.pbData || !pInfo->salt.pbData ||
228  !pInfo->cipher.pbData || !pInfo->fingerprint.pbData)
229  {
230  return FALSE;
231  }
232 
233  if (pInfo->info0.cbData!=16)
234  {
235  ERR("protect_data_t info0 not 16 bytes long\n");
236  }
237 
238  if (pInfo->info1.cbData!=16)
239  {
240  ERR("protect_data_t info1 not 16 bytes long\n");
241  }
242 
243  dwStrLen=lstrlenW(pInfo->szDataDescr);
244 
245  pSerial->cbData=0;
246  pSerial->cbData+=sizeof(DWORD)*8; /* 8 raw DWORDs */
247  pSerial->cbData+=sizeof(DWORD)*4; /* 4 BLOBs with size */
248  pSerial->cbData+=pInfo->info0.cbData;
249  pSerial->cbData+=pInfo->info1.cbData;
250  pSerial->cbData+=(dwStrLen+1)*sizeof(WCHAR) + 4; /* str, null, size */
251  pSerial->cbData+=pInfo->data0.cbData;
252  pSerial->cbData+=pInfo->salt.cbData;
253  pSerial->cbData+=pInfo->cipher.cbData;
254  pSerial->cbData+=pInfo->fingerprint.cbData;
255 
256  /* save the actual structure size */
257  dwStruct = pSerial->cbData;
258  /* There may be a 256 byte minimum, but I can't prove it. */
259  /*if (pSerial->cbData<256) pSerial->cbData=256;*/
260 
261  pSerial->pbData=LocalAlloc(LPTR,pSerial->cbData);
262  if (!pSerial->pbData) return FALSE;
263 
264  ptr=pSerial->pbData;
265 
266  /* count0 */
267  serialize_dword(pInfo->count0,&ptr);
268  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
269 
270  /* info0 */
272  pInfo->info0.cbData,sizeof(BYTE),FALSE);
273  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
274 
275  /* count1 */
276  serialize_dword(pInfo->count1,&ptr);
277  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
278 
279  /* info1 */
281  pInfo->info1.cbData,sizeof(BYTE),FALSE);
282  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
283 
284  /* null0 */
285  serialize_dword(pInfo->null0,&ptr);
286  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
287 
288  /* szDataDescr */
290  (dwStrLen+1)*sizeof(WCHAR),sizeof(BYTE),TRUE);
291  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
292 
293  /* cipher_alg */
294  serialize_dword(pInfo->cipher_alg,&ptr);
295  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
296  /* cipher_key_len */
298  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
299 
300  /* data0 */
302  pInfo->data0.cbData,sizeof(BYTE),TRUE);
303  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
304 
305  /* null1 */
306  serialize_dword(pInfo->null1,&ptr);
307  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
308 
309  /* hash_alg */
310  serialize_dword(pInfo->hash_alg,&ptr);
311  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
312  /* hash_len */
313  serialize_dword(pInfo->hash_len,&ptr);
314  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
315 
316  /* salt */
318  pInfo->salt.cbData,sizeof(BYTE),TRUE);
319  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
320 
321  /* cipher */
323  pInfo->cipher.cbData,sizeof(BYTE),TRUE);
324  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
325 
326  /* fingerprint */
328  pInfo->fingerprint.cbData,sizeof(BYTE),TRUE);
329  /*TRACE("used %u\n",ptr-pSerial->pbData);*/
330 
331  if (ptr - pSerial->pbData != dwStruct)
332  {
333  ERR("struct size changed!? expected %u\n", dwStruct);
334  LocalFree(pSerial->pbData);
335  pSerial->pbData=NULL;
336  pSerial->cbData=0;
337  return FALSE;
338  }
339 
340  return TRUE;
341 }
#define TRUE
Definition: types.h:120
static void serialize_string(const BYTE *str, BYTE **ptr, DWORD len, DWORD width, BOOL prepend_len)
Definition: protectdata.c:151
DATA_BLOB cipher
Definition: protectdata.c:107
#define lstrlenW
Definition: compat.h:407
WCHAR * szDataDescr
Definition: protectdata.c:99
DWORD cipher_key_len
Definition: protectdata.c:101
static PVOID ptr
Definition: dispmode.c:27
DATA_BLOB fingerprint
Definition: protectdata.c:108
smooth NULL
Definition: ftsmooth.c:416
static void serialize_dword(DWORD value, BYTE **ptr)
Definition: protectdata.c:142
DATA_BLOB info0
Definition: protectdata.c:95
DATA_BLOB salt
Definition: protectdata.c:106
DATA_BLOB info1
Definition: protectdata.c:97
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
DATA_BLOB data0
Definition: protectdata.c:102
BYTE * pbData
Definition: wincrypt.h:103
unsigned char BYTE
Definition: mem.h:68
#define ERR(fmt,...)
Definition: debug.h:109
static DATA_BLOB CRYPTPROTECT_PROMPTSTRUCT DWORD
Definition: protectdata.c:30
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define LPTR
Definition: winbase.h:362
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
ALG_ID cipher_alg
Definition: protectdata.c:100

Referenced by CryptProtectData().

◆ serialize_dword()

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

Definition at line 142 of file protectdata.c.

143 {
144  /*TRACE("called\n");*/
145 
146  memcpy(*ptr,&value,sizeof(DWORD));
147  *ptr+=sizeof(DWORD);
148 }
static PVOID ptr
Definition: dispmode.c:27
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static DATA_BLOB CRYPTPROTECT_PROMPTSTRUCT DWORD
Definition: protectdata.c:30

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.

153 {
154  /*TRACE("called %ux%u\n",(unsigned int)len,(unsigned int)width);*/
155 
156  if (prepend_len)
157  {
159  }
160  memcpy(*ptr,str,len*width);
161  *ptr+=len*width;
162 }
GLint GLint GLsizei width
Definition: gl.h:1546
static PVOID ptr
Definition: dispmode.c:27
const WCHAR * str
static void serialize_dword(DWORD value, BYTE **ptr)
Definition: protectdata.c:142
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722

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.

345 {
346  BYTE * ptr;
347  DWORD index;
348  DWORD size;
349  BOOL status=TRUE;
350 
351  TRACE("called\n");
352 
353  if (!pInfo || !pSerial || !pSerial->pbData)
354  return FALSE;
355 
356  index=0;
357  ptr=pSerial->pbData;
358  size=pSerial->cbData;
359 
360  /* count0 */
361  if (!unserialize_dword(ptr,&index,size,&pInfo->count0))
362  {
363  ERR("reading count0 failed!\n");
364  return FALSE;
365  }
366 
367  /* info0 */
368  if (!unserialize_string(ptr,&index,size,16,sizeof(BYTE),FALSE,
369  &pInfo->info0.pbData, &pInfo->info0.cbData))
370  {
371  ERR("reading info0 failed!\n");
372  return FALSE;
373  }
374 
375  /* count1 */
376  if (!unserialize_dword(ptr,&index,size,&pInfo->count1))
377  {
378  ERR("reading count1 failed!\n");
379  return FALSE;
380  }
381 
382  /* info1 */
383  if (!unserialize_string(ptr,&index,size,16,sizeof(BYTE),FALSE,
384  &pInfo->info1.pbData, &pInfo->info1.cbData))
385  {
386  ERR("reading info1 failed!\n");
387  return FALSE;
388  }
389 
390  /* null0 */
391  if (!unserialize_dword(ptr,&index,size,&pInfo->null0))
392  {
393  ERR("reading null0 failed!\n");
394  return FALSE;
395  }
396 
397  /* szDataDescr */
398  if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
399  (BYTE**)&pInfo->szDataDescr, NULL))
400  {
401  ERR("reading szDataDescr failed!\n");
402  return FALSE;
403  }
404 
405  /* cipher_alg */
406  if (!unserialize_dword(ptr,&index,size,&pInfo->cipher_alg))
407  {
408  ERR("reading cipher_alg failed!\n");
409  return FALSE;
410  }
411 
412  /* cipher_key_len */
414  {
415  ERR("reading cipher_key_len failed!\n");
416  return FALSE;
417  }
418 
419  /* data0 */
420  if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
421  &pInfo->data0.pbData, &pInfo->data0.cbData))
422  {
423  ERR("reading data0 failed!\n");
424  return FALSE;
425  }
426 
427  /* null1 */
428  if (!unserialize_dword(ptr,&index,size,&pInfo->null1))
429  {
430  ERR("reading null1 failed!\n");
431  return FALSE;
432  }
433 
434  /* hash_alg */
435  if (!unserialize_dword(ptr,&index,size,&pInfo->hash_alg))
436  {
437  ERR("reading hash_alg failed!\n");
438  return FALSE;
439  }
440 
441  /* hash_len */
442  if (!unserialize_dword(ptr,&index,size,&pInfo->hash_len))
443  {
444  ERR("reading hash_len failed!\n");
445  return FALSE;
446  }
447 
448  /* salt */
449  if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
450  &pInfo->salt.pbData, &pInfo->salt.cbData))
451  {
452  ERR("reading salt failed!\n");
453  return FALSE;
454  }
455 
456  /* cipher */
457  if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
458  &pInfo->cipher.pbData, &pInfo->cipher.cbData))
459  {
460  ERR("reading cipher failed!\n");
461  return FALSE;
462  }
463 
464  /* fingerprint */
465  if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
466  &pInfo->fingerprint.pbData, &pInfo->fingerprint.cbData))
467  {
468  ERR("reading fingerprint failed!\n");
469  return FALSE;
470  }
471 
472  /* allow structure size to be too big (since some applications
473  * will pad this up to 256 bytes, it seems) */
474  if (index>size)
475  {
476  /* this is an impossible-to-reach test, but if the padding
477  * issue is ever understood, this may become more useful */
478  ERR("loaded corrupt structure! (used %u expected %u)\n", index, size);
479  status=FALSE;
480  }
481 
482  return status;
483 }
#define TRUE
Definition: types.h:120
DATA_BLOB cipher
Definition: protectdata.c:107
WCHAR * szDataDescr
Definition: protectdata.c:99
DWORD cipher_key_len
Definition: protectdata.c:101
unsigned int BOOL
Definition: ntddk_ex.h:94
static PVOID ptr
Definition: dispmode.c:27
DATA_BLOB fingerprint
Definition: protectdata.c:108
smooth NULL
Definition: ftsmooth.c:416
DATA_BLOB info0
Definition: protectdata.c:95
GLuint index
Definition: glext.h:6031
static BOOL unserialize_string(const BYTE *ptr, DWORD *index, DWORD size, DWORD len, DWORD width, BOOL inline_len, BYTE **data, DWORD *stored)
Definition: protectdata.c:183
DATA_BLOB salt
Definition: protectdata.c:106
DATA_BLOB info1
Definition: protectdata.c:97
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
DATA_BLOB data0
Definition: protectdata.c:102
#define index(s, c)
Definition: various.h:29
BYTE * pbData
Definition: wincrypt.h:103
unsigned char BYTE
Definition: mem.h:68
#define ERR(fmt,...)
Definition: debug.h:109
static BOOL unserialize_dword(const BYTE *ptr, DWORD *index, DWORD size, DWORD *value)
Definition: protectdata.c:165
ALG_ID cipher_alg
Definition: protectdata.c:100
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

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.

166 {
167  /*TRACE("called\n");*/
168 
169  if (!ptr || !index || !value) return FALSE;
170 
171  if (*index+sizeof(DWORD)>size)
172  {
173  return FALSE;
174  }
175 
176  memcpy(value,&(ptr[*index]),sizeof(DWORD));
177  *index+=sizeof(DWORD);
178 
179  return TRUE;
180 }
#define TRUE
Definition: types.h:120
static PVOID ptr
Definition: dispmode.c:27
GLuint index
Definition: glext.h:6031
GLsizeiptr size
Definition: glext.h:5919
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static DATA_BLOB CRYPTPROTECT_PROMPTSTRUCT DWORD
Definition: protectdata.c:30

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.

186 {
187  /*TRACE("called\n");*/
188 
189  if (!ptr || !data) return FALSE;
190 
191  if (inline_len) {
193  return FALSE;
194  }
195 
196  if (*index+len*width>size)
197  {
198  return FALSE;
199  }
200 
201  if (!(*data = CryptMemAlloc( len*width)))
202  {
203  return FALSE;
204  }
205 
206  memcpy(*data,&(ptr[*index]),len*width);
207  if (stored)
208  {
209  *stored = len;
210  }
211  *index+=len*width;
212 
213  return TRUE;
214 }
GLint GLint GLsizei width
Definition: gl.h:1546
#define TRUE
Definition: types.h:120
LPVOID WINAPI CryptMemAlloc(ULONG cbSize)
Definition: main.c:131
static PVOID ptr
Definition: dispmode.c:27
GLuint index
Definition: glext.h:6031
GLsizeiptr size
Definition: glext.h:5919
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
static BOOL unserialize_dword(const BYTE *ptr, DWORD *index, DWORD size, DWORD *value)
Definition: protectdata.c:165

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.

488 {
489  BOOL status=TRUE;
490 
491  TRACE("called\n");
492 
493  if (pInfo->count0 != 0x0001)
494  {
495  ERR("count0 != 0x0001 !\n");
496  status=FALSE;
497  }
498  if (pInfo->count1 != 0x0001)
499  {
500  ERR("count0 != 0x0001 !\n");
501  status=FALSE;
502  }
503  if (pInfo->null0 != 0x0000)
504  {
505  ERR("null0 != 0x0000 !\n");
506  status=FALSE;
507  }
508  if (pInfo->null1 != 0x0000)
509  {
510  ERR("null1 != 0x0000 !\n");
511  status=FALSE;
512  }
513  /* since we have no idea what info0 is used for, and it seems
514  * rather constant, we can test for a Wine-specific magic string
515  * there to be reasonably sure we're using data created by the Wine
516  * implementation of CryptProtectData.
517  */
518  if (pInfo->info0.cbData!=strlen(crypt_magic_str)+1 ||
519  strcmp( (LPCSTR)pInfo->info0.pbData,crypt_magic_str) != 0)
520  {
521  ERR("info0 magic value not matched !\n");
522  status=FALSE;
523  }
524 
525  if (!status)
526  {
527  ERR("unrecognized CryptProtectData block\n");
528  }
529 
530  return status;
531 }
#define TRUE
Definition: types.h:120
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static const char crypt_magic_str[]
Definition: protectdata.c:112
unsigned int BOOL
Definition: ntddk_ex.h:94
DATA_BLOB info0
Definition: protectdata.c:95
const char * LPCSTR
Definition: xmlstorage.h:183
#define TRACE(s)
Definition: solgame.cpp:4
BYTE * pbData
Definition: wincrypt.h:103
#define ERR(fmt,...)
Definition: debug.h:109
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

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().