crypt32: Use SHA1 rather than MD5 to protect data.
[wine.git] / dlls / crypt32 / protectdata.c
blob1b59e4a615111723cdab9ba93ea3730676d21b6b
1 /*
2 * Copyright 2005 Kees Cook <kees@outflux.net>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 * The Win32 CryptProtectData and CryptUnprotectData functions are meant
22 * to provide a mechanism for encrypting data on a machine where other users
23 * of the system can't be trusted. It is used in many examples as a way
24 * to store username and password information to the registry, but store
25 * it not in the clear.
27 * The encryption is symmetric, but the method is unknown. However, since
28 * it is keyed to the machine and the user, it is unlikely that the values
29 * would be portable. Since programs must first call CryptProtectData to
30 * get a cipher text, the underlying system doesn't have to exactly
31 * match the real Windows version. However, attempts have been made to
32 * at least try to look like the Windows version, including guesses at the
33 * purpose of various portions of the "opaque data blob" that is used.
37 #include <stdarg.h>
38 #include <stdio.h>
39 #include <string.h>
40 #include <stdlib.h>
42 #include "windef.h"
43 #include "winbase.h"
44 #include "wincrypt.h"
45 #include "wine/debug.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
49 #define CRYPT32_PROTECTDATA_PROV PROV_RSA_FULL
50 #define CRYPT32_PROTECTDATA_HASH_CALG CALG_SHA1
51 #define CRYPT32_PROTECTDATA_KEY_CALG CALG_RC2
52 #define CRYPT32_PROTECTDATA_SALT_LEN 16
54 static const BYTE crypt32_protectdata_secret[] = {
55 'I','\'','m',' ','h','u','n','t','i','n','g',' ',
56 'w','a','b','b','i','t','s',0
60 * The data format returned by the real Windows CryptProtectData seems
61 * to be something like this:
63 DWORD count0; - how many "info0_*[16]" blocks follow (was always 1)
64 BYTE info0_0[16]; - unknown information - persistent across invocations,
65 ... reboots, password changes, and users
66 DWORD count1; - how many "info1_*[16]" blocks follow (was always 1)
67 BYTE info1_0[16]; - unknown information - unique to each user, but
68 ... persistent across reboots and password changes
69 DWORD null0; - NULL "end of records"?
70 DWORD str_len; - byte length of WCHAR string including term
71 BYTE str[str_len]; - The "dataDescription" value as a NULL-terminated
72 little-endian WCHAR string
73 ALG_ID cipher_alg; - cipher algo - was CALG_3DES
74 DWORD cipher_key_len; - cipher key bit length - was 0xa8==168
75 DWORD data_len; - length of data (was 16 in samples)
76 BYTE data[data_len]; - unknown data (fingerprint?)
77 DWORD null1; - NULL ?
78 ALG_ID hash_alg; - hash algo - was CALG_SHA1
79 DWORD hash_len; - bit length of hash - was 0xa0==160
80 DWORD salt_len; - length of salt(?) data
81 BYTE salt[salt_len]; - salt(?) for symmetric encryption
82 DWORD cipher_len; - length of cipher(?) data - was close to plain len
83 BYTE cipher[cipher_len]; - cipher text?
84 DWORD crc_len; - length of fingerprint(?) data - was 20 byte==160b SHA1
85 BYTE crc[crc_len]; - fingerprint of record?
87 * The data structures used in Wine are modelled after this guess.
90 struct protect_data_t
92 DWORD count0;
93 DATA_BLOB info0; /* using this to hold crypt_magic_str */
94 DWORD count1;
95 DATA_BLOB info1;
96 DWORD null0;
97 WCHAR * szDataDescr; /* serialized differently than the DATA_BLOBs */
98 ALG_ID cipher_alg;
99 DWORD cipher_key_len;
100 DATA_BLOB data0;
101 DWORD null1;
102 ALG_ID hash_alg;
103 DWORD hash_len;
104 DATA_BLOB salt;
105 DATA_BLOB cipher;
106 DATA_BLOB fingerprint;
109 /* this is used to check if an incoming structure was built by Wine */
110 static const char crypt_magic_str[] = "Wine Crypt32 ok";
112 /* debugging tool to print strings of hex chars */
113 static const char *
114 hex_str(const unsigned char *p, int n)
116 const char * ptr;
117 char report[80];
118 int r=-1;
119 report[0]='\0';
120 ptr = wine_dbg_sprintf("%s","");
121 while (--n >= 0)
123 if (r++ % 20 == 19)
125 ptr = wine_dbg_sprintf("%s%s",ptr,report);
126 report[0]='\0';
128 sprintf(report+strlen(report),"%s%02x", r ? "," : "", *p++);
130 return wine_dbg_sprintf("%s%s",ptr,report);
133 #define TRACE_DATA_BLOB(blob) do { \
134 TRACE("%s cbData: %u\n", #blob ,(unsigned int)((blob)->cbData)); \
135 TRACE("%s pbData @ %p:%s\n", #blob ,(blob)->pbData, \
136 hex_str((blob)->pbData, (blob)->cbData)); \
137 } while (0)
139 static
140 void serialize_dword(DWORD value,BYTE ** ptr)
142 /*TRACE("called\n");*/
144 memcpy(*ptr,&value,sizeof(DWORD));
145 *ptr+=sizeof(DWORD);
148 static
149 void serialize_string(const BYTE *str, BYTE **ptr, DWORD len, DWORD width,
150 BOOL prepend_len)
152 /*TRACE("called %ux%u\n",(unsigned int)len,(unsigned int)width);*/
154 if (prepend_len)
156 serialize_dword(len,ptr);
158 memcpy(*ptr,str,len*width);
159 *ptr+=len*width;
162 static
163 BOOL unserialize_dword(const BYTE *ptr, DWORD *index, DWORD size, DWORD *value)
165 /*TRACE("called\n");*/
167 if (!ptr || !index || !value) return FALSE;
169 if (*index+sizeof(DWORD)>size)
171 return FALSE;
174 memcpy(value,&(ptr[*index]),sizeof(DWORD));
175 *index+=sizeof(DWORD);
177 return TRUE;
180 static
181 BOOL unserialize_string(const BYTE *ptr, DWORD *index, DWORD size,
182 DWORD len, DWORD width, BOOL inline_len,
183 BYTE ** data, DWORD * stored)
185 /*TRACE("called\n");*/
187 if (!ptr || !data) return FALSE;
189 if (inline_len) {
190 if (!unserialize_dword(ptr,index,size,&len))
191 return FALSE;
194 if (*index+len*width>size)
196 return FALSE;
199 if (!(*data = CryptMemAlloc( len*width)))
201 return FALSE;
204 memcpy(*data,&(ptr[*index]),len*width);
205 if (stored)
207 *stored = len;
209 *index+=len*width;
211 return TRUE;
214 static
215 BOOL serialize(const struct protect_data_t *pInfo, DATA_BLOB *pSerial)
217 BYTE * ptr;
218 DWORD dwStrLen;
219 DWORD dwStruct;
221 TRACE("called\n");
223 if (!pInfo || !pInfo->szDataDescr || !pSerial ||
224 !pInfo->info0.pbData || !pInfo->info1.pbData ||
225 !pInfo->data0.pbData || !pInfo->salt.pbData ||
226 !pInfo->cipher.pbData || !pInfo->fingerprint.pbData)
228 return FALSE;
231 if (pInfo->info0.cbData!=16)
233 ERR("protect_data_t info0 not 16 bytes long\n");
236 if (pInfo->info1.cbData!=16)
238 ERR("protect_data_t info1 not 16 bytes long\n");
241 dwStrLen=lstrlenW(pInfo->szDataDescr);
243 pSerial->cbData=0;
244 pSerial->cbData+=sizeof(DWORD)*8; /* 8 raw DWORDs */
245 pSerial->cbData+=sizeof(DWORD)*4; /* 4 BLOBs with size */
246 pSerial->cbData+=pInfo->info0.cbData;
247 pSerial->cbData+=pInfo->info1.cbData;
248 pSerial->cbData+=(dwStrLen+1)*sizeof(WCHAR) + 4; /* str, null, size */
249 pSerial->cbData+=pInfo->data0.cbData;
250 pSerial->cbData+=pInfo->salt.cbData;
251 pSerial->cbData+=pInfo->cipher.cbData;
252 pSerial->cbData+=pInfo->fingerprint.cbData;
254 /* save the actual structure size */
255 dwStruct = pSerial->cbData;
256 /* There may be a 256 byte minimum, but I can't prove it. */
257 /*if (pSerial->cbData<256) pSerial->cbData=256;*/
259 pSerial->pbData=LocalAlloc(LPTR,pSerial->cbData);
260 if (!pSerial->pbData) return FALSE;
262 ptr=pSerial->pbData;
264 /* count0 */
265 serialize_dword(pInfo->count0,&ptr);
266 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
268 /* info0 */
269 serialize_string(pInfo->info0.pbData,&ptr,
270 pInfo->info0.cbData,sizeof(BYTE),FALSE);
271 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
273 /* count1 */
274 serialize_dword(pInfo->count1,&ptr);
275 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
277 /* info1 */
278 serialize_string(pInfo->info1.pbData,&ptr,
279 pInfo->info1.cbData,sizeof(BYTE),FALSE);
280 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
282 /* null0 */
283 serialize_dword(pInfo->null0,&ptr);
284 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
286 /* szDataDescr */
287 serialize_string((BYTE*)pInfo->szDataDescr,&ptr,
288 (dwStrLen+1)*sizeof(WCHAR),sizeof(BYTE),TRUE);
289 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
291 /* cipher_alg */
292 serialize_dword(pInfo->cipher_alg,&ptr);
293 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
294 /* cipher_key_len */
295 serialize_dword(pInfo->cipher_key_len,&ptr);
296 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
298 /* data0 */
299 serialize_string(pInfo->data0.pbData,&ptr,
300 pInfo->data0.cbData,sizeof(BYTE),TRUE);
301 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
303 /* null1 */
304 serialize_dword(pInfo->null1,&ptr);
305 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
307 /* hash_alg */
308 serialize_dword(pInfo->hash_alg,&ptr);
309 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
310 /* hash_len */
311 serialize_dword(pInfo->hash_len,&ptr);
312 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
314 /* salt */
315 serialize_string(pInfo->salt.pbData,&ptr,
316 pInfo->salt.cbData,sizeof(BYTE),TRUE);
317 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
319 /* cipher */
320 serialize_string(pInfo->cipher.pbData,&ptr,
321 pInfo->cipher.cbData,sizeof(BYTE),TRUE);
322 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
324 /* fingerprint */
325 serialize_string(pInfo->fingerprint.pbData,&ptr,
326 pInfo->fingerprint.cbData,sizeof(BYTE),TRUE);
327 /*TRACE("used %u\n",ptr-pSerial->pbData);*/
329 if (ptr - pSerial->pbData != dwStruct)
331 ERR("struct size changed!? %u != expected %u\n",
332 ptr - pSerial->pbData, (unsigned int)dwStruct);
333 LocalFree(pSerial->pbData);
334 pSerial->pbData=NULL;
335 pSerial->cbData=0;
336 return FALSE;
339 return TRUE;
342 static
343 BOOL unserialize(const DATA_BLOB *pSerial, struct protect_data_t *pInfo)
345 BYTE * ptr;
346 DWORD index;
347 DWORD size;
348 BOOL status=TRUE;
350 TRACE("called\n");
352 if (!pInfo || !pSerial || !pSerial->pbData)
353 return FALSE;
355 index=0;
356 ptr=pSerial->pbData;
357 size=pSerial->cbData;
359 /* count0 */
360 if (!unserialize_dword(ptr,&index,size,&pInfo->count0))
362 ERR("reading count0 failed!\n");
363 return FALSE;
366 /* info0 */
367 if (!unserialize_string(ptr,&index,size,16,sizeof(BYTE),FALSE,
368 &pInfo->info0.pbData, &pInfo->info0.cbData))
370 ERR("reading info0 failed!\n");
371 return FALSE;
374 /* count1 */
375 if (!unserialize_dword(ptr,&index,size,&pInfo->count1))
377 ERR("reading count1 failed!\n");
378 return FALSE;
381 /* info1 */
382 if (!unserialize_string(ptr,&index,size,16,sizeof(BYTE),FALSE,
383 &pInfo->info1.pbData, &pInfo->info1.cbData))
385 ERR("reading info1 failed!\n");
386 return FALSE;
389 /* null0 */
390 if (!unserialize_dword(ptr,&index,size,&pInfo->null0))
392 ERR("reading null0 failed!\n");
393 return FALSE;
396 /* szDataDescr */
397 if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
398 (BYTE**)&pInfo->szDataDescr, NULL))
400 ERR("reading szDataDescr failed!\n");
401 return FALSE;
404 /* cipher_alg */
405 if (!unserialize_dword(ptr,&index,size,&pInfo->cipher_alg))
407 ERR("reading cipher_alg failed!\n");
408 return FALSE;
411 /* cipher_key_len */
412 if (!unserialize_dword(ptr,&index,size,&pInfo->cipher_key_len))
414 ERR("reading cipher_key_len failed!\n");
415 return FALSE;
418 /* data0 */
419 if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
420 &pInfo->data0.pbData, &pInfo->data0.cbData))
422 ERR("reading data0 failed!\n");
423 return FALSE;
426 /* null1 */
427 if (!unserialize_dword(ptr,&index,size,&pInfo->null1))
429 ERR("reading null1 failed!\n");
430 return FALSE;
433 /* hash_alg */
434 if (!unserialize_dword(ptr,&index,size,&pInfo->hash_alg))
436 ERR("reading hash_alg failed!\n");
437 return FALSE;
440 /* hash_len */
441 if (!unserialize_dword(ptr,&index,size,&pInfo->hash_len))
443 ERR("reading hash_len failed!\n");
444 return FALSE;
447 /* salt */
448 if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
449 &pInfo->salt.pbData, &pInfo->salt.cbData))
451 ERR("reading salt failed!\n");
452 return FALSE;
455 /* cipher */
456 if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
457 &pInfo->cipher.pbData, &pInfo->cipher.cbData))
459 ERR("reading cipher failed!\n");
460 return FALSE;
463 /* fingerprint */
464 if (!unserialize_string(ptr,&index,size,0,sizeof(BYTE),TRUE,
465 &pInfo->fingerprint.pbData, &pInfo->fingerprint.cbData))
467 ERR("reading fingerprint failed!\n");
468 return FALSE;
471 /* allow structure size to be too big (since some applications
472 * will pad this up to 256 bytes, it seems) */
473 if (index>size)
475 /* this is an impossible-to-reach test, but if the padding
476 * issue is ever understood, this may become more useful */
477 ERR("loaded corrupt structure! (used %u expected %u)\n",
478 (unsigned int)index, (unsigned int)size);
479 status=FALSE;
482 return status;
485 /* perform sanity checks */
486 static
487 BOOL valid_protect_data(const struct protect_data_t *pInfo)
489 BOOL status=TRUE;
491 TRACE("called\n");
493 if (pInfo->count0 != 0x0001)
495 ERR("count0 != 0x0001 !\n");
496 status=FALSE;
498 if (pInfo->count1 != 0x0001)
500 ERR("count0 != 0x0001 !\n");
501 status=FALSE;
503 if (pInfo->null0 != 0x0000)
505 ERR("null0 != 0x0000 !\n");
506 status=FALSE;
508 if (pInfo->null1 != 0x0000)
510 ERR("null1 != 0x0000 !\n");
511 status=FALSE;
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.
518 if (pInfo->info0.cbData!=strlen(crypt_magic_str)+1 ||
519 strcmp( (LPCSTR)pInfo->info0.pbData,crypt_magic_str) != 0)
521 ERR("info0 magic value not matched !\n");
522 status=FALSE;
525 if (!status)
527 ERR("unrecognized CryptProtectData block\n");
530 return status;
533 static
534 void free_protect_data(struct protect_data_t * pInfo)
536 TRACE("called\n");
538 if (!pInfo) return;
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);
546 CryptMemFree(pInfo->fingerprint.pbData);
549 /* copies a string into a data blob */
550 static
551 BYTE *convert_str_to_blob(LPCSTR str, DATA_BLOB *blob)
553 if (!str || !blob) return NULL;
555 blob->cbData=strlen(str)+1;
556 if (!(blob->pbData=CryptMemAlloc(blob->cbData)))
558 blob->cbData=0;
560 else {
561 strcpy((LPSTR)blob->pbData, str);
564 return blob->pbData;
568 * Populates everything except "cipher" and "fingerprint".
570 static
571 BOOL fill_protect_data(struct protect_data_t * pInfo, LPCWSTR szDataDescr,
572 HCRYPTPROV hProv)
574 DWORD dwStrLen;
576 TRACE("called\n");
578 if (!pInfo) return FALSE;
580 dwStrLen=lstrlenW(szDataDescr);
582 memset(pInfo,0,sizeof(*pInfo));
584 pInfo->count0=0x0001;
586 convert_str_to_blob(crypt_magic_str, &pInfo->info0);
588 pInfo->count1=0x0001;
590 convert_str_to_blob(crypt_magic_str, &pInfo->info1);
592 pInfo->null0=0x0000;
594 if ((pInfo->szDataDescr=CryptMemAlloc((dwStrLen+1)*sizeof(WCHAR))))
596 memcpy(pInfo->szDataDescr,szDataDescr,(dwStrLen+1)*sizeof(WCHAR));
599 pInfo->cipher_alg=CRYPT32_PROTECTDATA_KEY_CALG;
600 pInfo->cipher_key_len=0x0000; /* FIXME: get correct value */
602 convert_str_to_blob(crypt_magic_str, &pInfo->data0);
604 pInfo->null1=0x0000;
605 pInfo->hash_alg=CRYPT32_PROTECTDATA_HASH_CALG;
606 pInfo->hash_len=0x0000; /* FIXME: get correct value */
608 /* allocate memory to hold a salt */
609 pInfo->salt.cbData=CRYPT32_PROTECTDATA_SALT_LEN;
610 if ((pInfo->salt.pbData=CryptMemAlloc(pInfo->salt.cbData)))
612 /* generate random salt */
613 if (!CryptGenRandom(hProv, pInfo->salt.cbData, pInfo->salt.pbData))
615 ERR("CryptGenRandom\n");
616 free_protect_data(pInfo);
617 return FALSE;
621 /* debug: show our salt */
622 TRACE_DATA_BLOB(&pInfo->salt);
624 pInfo->cipher.cbData=0;
625 pInfo->cipher.pbData=NULL;
627 pInfo->fingerprint.cbData=0;
628 pInfo->fingerprint.pbData=NULL;
630 /* check all the allocations at once */
631 if (!pInfo->info0.pbData ||
632 !pInfo->info1.pbData ||
633 !pInfo->szDataDescr ||
634 !pInfo->data0.pbData ||
635 !pInfo->salt.pbData
638 ERR("could not allocate protect_data structures\n");
639 free_protect_data(pInfo);
640 return FALSE;
643 return TRUE;
646 static
647 BOOL convert_hash_to_blob(HCRYPTHASH hHash, DATA_BLOB * blob)
649 DWORD dwSize;
651 TRACE("called\n");
653 if (!blob) return FALSE;
655 dwSize=sizeof(DWORD);
656 if (!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&blob->cbData,
657 &dwSize, 0))
659 ERR("failed to get hash size\n");
660 return FALSE;
663 if (!(blob->pbData=CryptMemAlloc(blob->cbData)))
665 ERR("failed to allocate blob memory\n");
666 return FALSE;
669 dwSize=blob->cbData;
670 if (!CryptGetHashParam(hHash, HP_HASHVAL, blob->pbData, &dwSize, 0))
672 ERR("failed to get hash value\n");
673 CryptMemFree(blob->pbData);
674 blob->pbData=NULL;
675 blob->cbData=0;
676 return FALSE;
679 return TRUE;
682 /* test that a given hash matches an exported-to-blob hash value */
683 static
684 BOOL hash_matches_blob(HCRYPTHASH hHash, const DATA_BLOB *two)
686 BOOL rc = FALSE;
687 DATA_BLOB one;
689 if (!two || !two->pbData) return FALSE;
691 if (!convert_hash_to_blob(hHash,&one)) {
692 return FALSE;
695 if ( one.cbData == two->cbData &&
696 memcmp( one.pbData, two->pbData, one.cbData ) == 0 )
698 rc = TRUE;
701 CryptMemFree(one.pbData);
702 return rc;
705 /* create an encryption key from a given salt and optional entropy */
706 static
707 BOOL load_encryption_key(HCRYPTPROV hProv, const DATA_BLOB *salt,
708 const DATA_BLOB *pOptionalEntropy, HCRYPTKEY *phKey)
710 BOOL rc = TRUE;
711 HCRYPTHASH hSaltHash;
712 char * szUsername = NULL;
713 DWORD dwUsernameLen;
714 DWORD dwError;
716 /* create hash for salt */
717 if (!salt || !phKey ||
718 !CryptCreateHash(hProv,CRYPT32_PROTECTDATA_HASH_CALG,0,0,&hSaltHash))
720 ERR("CryptCreateHash\n");
721 return FALSE;
724 /* This should be the "logon credentials" instead of username */
725 dwError=GetLastError();
726 dwUsernameLen = 0;
727 if (!GetUserNameA(NULL,&dwUsernameLen) &&
728 GetLastError()==ERROR_MORE_DATA && dwUsernameLen &&
729 (szUsername = CryptMemAlloc(dwUsernameLen)))
731 szUsername[0]='\0';
732 GetUserNameA( szUsername, &dwUsernameLen );
734 SetLastError(dwError);
736 /* salt the hash with:
737 * - the user id
738 * - an "internal secret"
739 * - randomness (from the salt)
740 * - user-supplied entropy
742 if ((szUsername && !CryptHashData(hSaltHash,(LPBYTE)szUsername,dwUsernameLen,0)) ||
743 !CryptHashData(hSaltHash,crypt32_protectdata_secret,
744 sizeof(crypt32_protectdata_secret)-1,0) ||
745 !CryptHashData(hSaltHash,salt->pbData,salt->cbData,0) ||
746 (pOptionalEntropy && !CryptHashData(hSaltHash,
747 pOptionalEntropy->pbData,
748 pOptionalEntropy->cbData,0)))
750 ERR("CryptHashData\n");
751 rc = FALSE;
754 /* produce a symmetric key */
755 if (rc && !CryptDeriveKey(hProv,CRYPT32_PROTECTDATA_KEY_CALG,
756 hSaltHash,CRYPT_EXPORTABLE,phKey))
758 ERR("CryptDeriveKey\n");
759 rc = FALSE;
762 /* clean up */
763 CryptDestroyHash(hSaltHash);
764 CryptMemFree(szUsername);
766 return rc;
769 /* debugging tool to print the structures of a ProtectData call */
770 static void
771 report(const DATA_BLOB* pDataIn, const DATA_BLOB* pOptionalEntropy,
772 CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct, DWORD dwFlags)
774 TRACE("pPromptStruct: %p\n", pPromptStruct);
775 if (pPromptStruct)
777 TRACE(" cbSize: 0x%x\n",(unsigned int)pPromptStruct->cbSize);
778 TRACE(" dwPromptFlags: 0x%x\n",(unsigned int)pPromptStruct->dwPromptFlags);
779 TRACE(" hwndApp: %p\n", pPromptStruct->hwndApp);
780 TRACE(" szPrompt: %p %s\n",
781 pPromptStruct->szPrompt,
782 pPromptStruct->szPrompt ? debugstr_w(pPromptStruct->szPrompt)
783 : "");
785 TRACE("dwFlags: 0x%04x\n",(unsigned int)dwFlags);
786 TRACE_DATA_BLOB(pDataIn);
787 if (pOptionalEntropy)
789 TRACE_DATA_BLOB(pOptionalEntropy);
790 TRACE(" %s\n",debugstr_an((LPCSTR)pOptionalEntropy->pbData,pOptionalEntropy->cbData));
796 /***************************************************************************
797 * CryptProtectData [CRYPT32.@]
799 * Generate Cipher data from given Plain and Entropy data.
801 * PARAMS
802 * pDataIn [I] Plain data to be enciphered
803 * szDataDescr [I] Optional Unicode string describing the Plain data
804 * pOptionalEntropy [I] Optional entropy data to adjust cipher, can be NULL
805 * pvReserved [I] Reserved, must be NULL
806 * pPromptStruct [I] Structure describing if/how to prompt during ciphering
807 * dwFlags [I] Flags describing options to the ciphering
808 * pDataOut [O] Resulting Cipher data, for calls to CryptUnprotectData
810 * RETURNS
811 * TRUE If a Cipher was generated.
812 * FALSE If something failed and no Cipher is available.
814 * FIXME
815 * The true Windows encryption and keying mechanisms are unknown.
817 * dwFlags and pPromptStruct are currently ignored.
819 * NOTES
820 * Memory allocated in pDataOut must be freed with LocalFree.
823 BOOL WINAPI CryptProtectData(DATA_BLOB* pDataIn,
824 LPCWSTR szDataDescr,
825 DATA_BLOB* pOptionalEntropy,
826 PVOID pvReserved,
827 CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct,
828 DWORD dwFlags,
829 DATA_BLOB* pDataOut)
831 static const WCHAR empty_str[1];
832 BOOL rc = FALSE;
833 HCRYPTPROV hProv;
834 struct protect_data_t protect_data;
835 HCRYPTHASH hHash;
836 HCRYPTKEY hKey;
837 DWORD dwLength;
839 TRACE("called\n");
841 SetLastError(ERROR_SUCCESS);
843 if (!pDataIn || !pDataOut)
845 SetLastError(ERROR_INVALID_PARAMETER);
846 goto finished;
849 /* debug: show our arguments */
850 report(pDataIn,pOptionalEntropy,pPromptStruct,dwFlags);
851 TRACE("\tszDataDescr: %p %s\n", szDataDescr,
852 szDataDescr ? debugstr_w(szDataDescr) : "");
854 /* Windows appears to create an empty szDataDescr instead of maintaining
855 * a NULL */
856 if (!szDataDescr)
857 szDataDescr = empty_str;
859 /* get crypt context */
860 if (!CryptAcquireContextW(&hProv,NULL,NULL,CRYPT32_PROTECTDATA_PROV,CRYPT_VERIFYCONTEXT))
862 ERR("CryptAcquireContextW failed\n");
863 goto finished;
866 /* populate our structure */
867 if (!fill_protect_data(&protect_data,szDataDescr,hProv))
869 ERR("fill_protect_data\n");
870 goto free_context;
873 /* load key */
874 if (!load_encryption_key(hProv,&protect_data.salt,pOptionalEntropy,&hKey))
876 goto free_protect_data;
879 /* create a hash for the encryption validation */
880 if (!CryptCreateHash(hProv,CRYPT32_PROTECTDATA_HASH_CALG,0,0,&hHash))
882 ERR("CryptCreateHash\n");
883 goto free_key;
886 /* calculate storage required */
887 dwLength=pDataIn->cbData;
888 if (CryptEncrypt(hKey, 0, TRUE, 0, pDataIn->pbData, &dwLength, 0) ||
889 GetLastError()!=ERROR_MORE_DATA)
891 ERR("CryptEncrypt\n");
892 goto free_hash;
894 TRACE("required encrypted storage: %u\n",(unsigned int)dwLength);
896 /* copy plain text into cipher area for CryptEncrypt call */
897 protect_data.cipher.cbData=dwLength;
898 if (!(protect_data.cipher.pbData=CryptMemAlloc(
899 protect_data.cipher.cbData)))
901 ERR("CryptMemAlloc\n");
902 goto free_hash;
904 memcpy(protect_data.cipher.pbData,pDataIn->pbData,pDataIn->cbData);
906 /* encrypt! */
907 dwLength=pDataIn->cbData;
908 if (!CryptEncrypt(hKey, hHash, TRUE, 0, protect_data.cipher.pbData,
909 &dwLength, protect_data.cipher.cbData))
911 ERR("CryptEncrypt %u\n",(unsigned int)GetLastError());
912 goto free_hash;
914 protect_data.cipher.cbData=dwLength;
916 /* debug: show the cipher */
917 TRACE_DATA_BLOB(&protect_data.cipher);
919 /* attach our fingerprint */
920 if (!convert_hash_to_blob(hHash, &protect_data.fingerprint))
922 ERR("convert_hash_to_blob\n");
923 goto free_hash;
926 /* serialize into an opaque blob */
927 if (!serialize(&protect_data, pDataOut))
929 ERR("serialize\n");
930 goto free_hash;
933 /* success! */
934 rc=TRUE;
936 free_hash:
937 CryptDestroyHash(hHash);
938 free_key:
939 CryptDestroyKey(hKey);
940 free_protect_data:
941 free_protect_data(&protect_data);
942 free_context:
943 CryptReleaseContext(hProv,0);
944 finished:
945 /* If some error occurred, and no error code was set, force one. */
946 if (!rc && GetLastError()==ERROR_SUCCESS)
948 SetLastError(ERROR_INVALID_DATA);
951 if (rc)
953 SetLastError(ERROR_SUCCESS);
955 TRACE_DATA_BLOB(pDataOut);
958 TRACE("returning %s\n", rc ? "ok" : "FAIL");
960 return rc;
964 /***************************************************************************
965 * CryptUnprotectData [CRYPT32.@]
967 * Generate Plain data and Description from given Cipher and Entropy data.
969 * PARAMS
970 * pDataIn [I] Cipher data to be decoded
971 * ppszDataDescr [O] Optional Unicode string describing the Plain data
972 * pOptionalEntropy [I] Optional entropy data to adjust cipher, can be NULL
973 * pvReserved [I] Reserved, must be NULL
974 * pPromptStruct [I] Structure describing if/how to prompt during decoding
975 * dwFlags [I] Flags describing options to the decoding
976 * pDataOut [O] Resulting Plain data, from calls to CryptProtectData
978 * RETURNS
979 * TRUE If a Plain was generated.
980 * FALSE If something failed and no Plain is available.
982 * FIXME
983 * The true Windows encryption and keying mechanisms are unknown.
985 * dwFlags and pPromptStruct are currently ignored.
987 * NOTES
988 * Memory allocated in pDataOut and non-NULL ppszDataDescr must be freed
989 * with LocalFree.
992 BOOL WINAPI CryptUnprotectData(DATA_BLOB* pDataIn,
993 LPWSTR * ppszDataDescr,
994 DATA_BLOB* pOptionalEntropy,
995 PVOID pvReserved,
996 CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct,
997 DWORD dwFlags,
998 DATA_BLOB* pDataOut)
1000 BOOL rc = FALSE;
1002 HCRYPTPROV hProv;
1003 struct protect_data_t protect_data;
1004 HCRYPTHASH hHash;
1005 HCRYPTKEY hKey;
1006 DWORD dwLength;
1008 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.";
1010 TRACE("called\n");
1012 SetLastError(ERROR_SUCCESS);
1014 if (!pDataIn || !pDataOut)
1016 SetLastError(ERROR_INVALID_PARAMETER);
1017 goto finished;
1019 if (!pDataIn->cbData)
1021 SetLastError(ERROR_INVALID_DATA);
1022 goto finished;
1025 /* debug: show our arguments */
1026 report(pDataIn,pOptionalEntropy,pPromptStruct,dwFlags);
1027 TRACE("\tppszDataDescr: %p\n", ppszDataDescr);
1029 /* take apart the opaque blob */
1030 if (!unserialize(pDataIn, &protect_data))
1032 SetLastError(ERROR_INVALID_DATA);
1033 FIXME("%s\n",announce_bad_opaque_data);
1034 goto finished;
1037 /* perform basic validation on the resulting structure */
1038 if (!valid_protect_data(&protect_data))
1040 SetLastError(ERROR_INVALID_DATA);
1041 FIXME("%s\n",announce_bad_opaque_data);
1042 goto free_protect_data;
1045 /* get a crypt context */
1046 if (!CryptAcquireContextW(&hProv,NULL,NULL,CRYPT32_PROTECTDATA_PROV,CRYPT_VERIFYCONTEXT))
1048 ERR("CryptAcquireContextW failed\n");
1049 goto free_protect_data;
1052 /* load key */
1053 if (!load_encryption_key(hProv,&protect_data.salt,pOptionalEntropy,&hKey))
1055 goto free_context;
1058 /* create a hash for the decryption validation */
1059 if (!CryptCreateHash(hProv,CRYPT32_PROTECTDATA_HASH_CALG,0,0,&hHash))
1061 ERR("CryptCreateHash\n");
1062 goto free_key;
1065 /* prepare for plaintext */
1066 pDataOut->cbData=protect_data.cipher.cbData;
1067 if (!(pDataOut->pbData=LocalAlloc( LPTR, pDataOut->cbData)))
1069 ERR("CryptMemAlloc\n");
1070 goto free_hash;
1072 memcpy(pDataOut->pbData,protect_data.cipher.pbData,protect_data.cipher.cbData);
1074 /* decrypt! */
1075 if (!CryptDecrypt(hKey, hHash, TRUE, 0, pDataOut->pbData,
1076 &pDataOut->cbData) ||
1077 /* check the hash fingerprint */
1078 pDataOut->cbData > protect_data.cipher.cbData ||
1079 !hash_matches_blob(hHash, &protect_data.fingerprint))
1081 SetLastError(ERROR_INVALID_DATA);
1083 LocalFree( pDataOut->pbData );
1084 pDataOut->pbData = NULL;
1085 pDataOut->cbData = 0;
1087 goto free_hash;
1090 /* Copy out the description */
1091 dwLength = (lstrlenW(protect_data.szDataDescr)+1) * sizeof(WCHAR);
1092 if (ppszDataDescr)
1094 if (!(*ppszDataDescr = LocalAlloc(LPTR,dwLength)))
1096 ERR("LocalAlloc (ppszDataDescr)\n");
1097 goto free_hash;
1099 else {
1100 memcpy(*ppszDataDescr,protect_data.szDataDescr,dwLength);
1104 /* success! */
1105 rc = TRUE;
1107 free_hash:
1108 CryptDestroyHash(hHash);
1109 free_key:
1110 CryptDestroyKey(hKey);
1111 free_context:
1112 CryptReleaseContext(hProv,0);
1113 free_protect_data:
1114 free_protect_data(&protect_data);
1115 finished:
1116 /* If some error occurred, and no error code was set, force one. */
1117 if (!rc && GetLastError()==ERROR_SUCCESS)
1119 SetLastError(ERROR_INVALID_DATA);
1122 if (rc) {
1123 SetLastError(ERROR_SUCCESS);
1125 if (ppszDataDescr)
1127 TRACE("szDataDescr: %s\n",debugstr_w(*ppszDataDescr));
1129 TRACE_DATA_BLOB(pDataOut);
1132 TRACE("returning %s\n", rc ? "ok" : "FAIL");
1134 return rc;