From: Hans Leidekker hans@codeweavers.com
--- dlls/rsaenh/tests/rsaenh.c | 808 +++++++++++++------------------------ 1 file changed, 289 insertions(+), 519 deletions(-)
diff --git a/dlls/rsaenh/tests/rsaenh.c b/dlls/rsaenh/tests/rsaenh.c index f0c3f828aca..b0faea64529 100644 --- a/dlls/rsaenh/tests/rsaenh.c +++ b/dlls/rsaenh/tests/rsaenh.c @@ -63,8 +63,6 @@ static const cryptdata cTestData[4] = { 12,12,16} };
-static int win2k, nt4; - /* * 1. Take the MD5 Hash of the container name (with an extra null byte) * 2. Turn the hash into a 4 DWORD hex value @@ -81,16 +79,9 @@ static void uniquecontainer(char *unique) HKEY hkey; char guid[MAX_PATH]; DWORD size = MAX_PATH; - HRESULT ret;
/* Get the MachineGUID */ - ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, szCryptography, 0, KEY_READ | KEY_WOW64_64KEY, &hkey); - if (ret == ERROR_ACCESS_DENIED) - { - /* Windows 2000 can't handle KEY_WOW64_64KEY */ - RegOpenKeyA(HKEY_LOCAL_MACHINE, szCryptography, &hkey); - win2k++; - } + RegOpenKeyExA(HKEY_LOCAL_MACHINE, szCryptography, 0, KEY_READ | KEY_WOW64_64KEY, &hkey); RegQueryValueExA(hkey, szMachineGuid, NULL, NULL, (LPBYTE)guid, &size); RegCloseKey(hkey);
@@ -109,8 +100,6 @@ static void printBytes(const char *heading, const BYTE *pb, size_t cb) putchar('\n'); }
-static BOOL (WINAPI *pCryptDuplicateHash) (HCRYPTHASH, DWORD*, DWORD, HCRYPTHASH*); - static void trace_hex(BYTE *pbData, DWORD dwLen) { char szTemp[256]; DWORD i, j; @@ -133,22 +122,16 @@ static BOOL init_base_environment(const char *provider, DWORD dwKeyFlags) BOOL result;
if (provider) szProvider = provider; - - pCryptDuplicateHash = (void *)GetProcAddress(GetModuleHandleA("advapi32.dll"), "CryptDuplicateHash"); - + hProv = (HCRYPTPROV)INVALID_HANDLE_VALUE;
result = CryptAcquireContextA(&hProv, szContainer, szProvider, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); - ok(!result && (GetLastError()==NTE_BAD_FLAGS || - broken(GetLastError() == NTE_KEYSET_NOT_DEF /* Win9x/NT4 */)), - "%d, %08lx\n", result, GetLastError()); - + ok(!result && GetLastError() == NTE_BAD_FLAGS, "%d, %08lx\n", result, GetLastError()); + if (!CryptAcquireContextA(&hProv, szContainer, szProvider, PROV_RSA_FULL, 0)) { ok(GetLastError()==NTE_BAD_KEYSET || - broken(GetLastError() == NTE_TEMPORARY_PROFILE /* some Win7 setups */) || - broken(GetLastError() == NTE_KEYSET_NOT_DEF /* Win9x/NT4 */), - "%08lx\n", GetLastError()); + broken(GetLastError() == NTE_TEMPORARY_PROFILE /* some Win7 setups */), "%08lx\n", GetLastError()); if (GetLastError()!=NTE_BAD_KEYSET) { win_skip("RSA full provider not available\n"); @@ -178,7 +161,7 @@ static void clean_up_base_environment(void)
SetLastError(0xdeadbeef); result = CryptReleaseContext(hProv, 1); - ok(!result || broken(result) /* Win98 */, "Expected failure\n"); + ok(!result, "Expected failure\n"); ok(GetLastError()==NTE_BAD_FLAGS, "Expected NTE_BAD_FLAGS, got %08lx\n", GetLastError());
/* Just to prove that Win98 also released the CSP */ @@ -194,8 +177,6 @@ static BOOL init_aes_environment(void) HCRYPTKEY hKey; BOOL result;
- pCryptDuplicateHash = (void *)GetProcAddress(GetModuleHandleA("advapi32.dll"), "CryptDuplicateHash"); - hProv = (HCRYPTPROV)INVALID_HANDLE_VALUE;
/* we are using NULL as provider name for RSA_AES provider as the provider @@ -218,7 +199,6 @@ static BOOL init_aes_environment(void) result = CryptAcquireContextA(&hProv, szContainer, NULL, PROV_RSA_AES, CRYPT_NEWKEYSET); ok(result, "%08lx\n", GetLastError()); - if (!result) return FALSE; result = CryptGenKey(hProv, AT_KEYEXCHANGE, 0, &hKey); ok(result, "%08lx\n", GetLastError()); if (result) CryptDestroyKey(hKey); @@ -252,25 +232,16 @@ static void test_prov(void) { BOOL result; DWORD dwLen, dwInc; - - dwLen = (DWORD)sizeof(DWORD); + + dwLen = sizeof(DWORD); SetLastError(0xdeadbeef); result = CryptGetProvParam(hProv, PP_SIG_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0); - if (!result && GetLastError() == NTE_BAD_TYPE) - { - skip("PP_SIG_KEYSIZE_INC is not supported (win9x or NT)\n"); - nt4++; - } - else - ok(result && dwInc==8, "%08lx, %ld\n", GetLastError(), dwInc); - - dwLen = (DWORD)sizeof(DWORD); + ok(result && dwInc==8, "%08lx, %ld\n", GetLastError(), dwInc); + + dwLen = sizeof(DWORD); SetLastError(0xdeadbeef); result = CryptGetProvParam(hProv, PP_KEYX_KEYSIZE_INC, (BYTE*)&dwInc, &dwLen, 0); - if (!result && GetLastError() == NTE_BAD_TYPE) - skip("PP_KEYX_KEYSIZE_INC is not supported (win9x or NT)\n"); - else - ok(result && dwInc==8, "%08lx, %ld\n", GetLastError(), dwInc); + ok(result && dwInc == 8, "%08lx, %ld\n", GetLastError(), dwInc); }
static void test_gen_random(void) @@ -282,11 +253,6 @@ static void test_gen_random(void) memset(rnd2, 0, sizeof(rnd2));
result = CryptGenRandom(hProv, sizeof(rnd1), rnd1); - if (!result && GetLastError() == NTE_FAIL) { - /* rsaenh compiled without OpenSSL */ - return; - } - ok(result, "%08lx\n", GetLastError());
result = CryptGenRandom(hProv, sizeof(rnd2), rnd2); @@ -305,18 +271,11 @@ static BOOL derive_key(ALG_ID aiAlgid, HCRYPTKEY *phKey, DWORD len) *phKey = 0; for (i=0; i<2000; i++) pbData[i] = (unsigned char)i; result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash); - if (!result) { - /* rsaenh compiled without OpenSSL */ - ok(GetLastError()==NTE_BAD_ALGID, "%08lx\n", GetLastError()); - return FALSE; - } ok(result, "%08lx\n", GetLastError()); result = CryptHashData(hHash, pbData, sizeof(pbData), 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return FALSE; result = CryptDeriveKey(hProv, aiAlgid, hHash, (len << 16) | CRYPT_EXPORTABLE, phKey); ok(result, "%08lx\n", GetLastError()); - if (!result) return FALSE; len = 2000; result = CryptGetHashParam(hHash, HP_HASHVAL, pbData, &len, 0); ok(result, "%08lx\n", GetLastError()); @@ -444,26 +403,22 @@ static void test_hashes(void)
/* MD2 Hashing */ result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash); - if (!result) { - /* rsaenh compiled without OpenSSL */ - ok(GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError()); - } else { - result = CryptHashData(hHash, pbData, sizeof(pbData), 0); - ok(result, "%08lx\n", GetLastError()); + ok(result, "%08lx\n", GetLastError());
- len = sizeof(DWORD); - result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0); - ok(result && (hashlen == 16), "%08lx, hashlen: %ld\n", GetLastError(), hashlen); + result = CryptHashData(hHash, pbData, sizeof(pbData), 0); + ok(result, "%08lx\n", GetLastError());
- len = 16; - result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0); - ok(result, "%08lx\n", GetLastError()); + len = sizeof(DWORD); + result = CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0); + ok(result && (hashlen == 16), "%08lx, hashlen: %ld\n", GetLastError(), hashlen);
- ok(!memcmp(pbHashValue, md2hash, 16), "Wrong MD2 hash!\n"); + len = 16; + result = CryptGetHashParam(hHash, HP_HASHVAL, pbHashValue, &len, 0); + ok(result, "%08lx\n", GetLastError()); + ok(!memcmp(pbHashValue, md2hash, 16), "Wrong MD2 hash!\n");
- result = CryptDestroyHash(hHash); - ok(result, "%08lx\n", GetLastError()); - } + result = CryptDestroyHash(hHash); + ok(result, "%08lx\n", GetLastError());
/* MD4 Hashing */ result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash); @@ -474,12 +429,6 @@ static void test_hashes(void)
cryptflags = CRYPT_USERDATA; result = CryptHashData(hHash, pbData, sizeof(pbData), cryptflags); - if (!result && GetLastError() == NTE_BAD_FLAGS) /* <= NT4 */ - { - cryptflags &= ~CRYPT_USERDATA; - ok(broken(1), "Failed to support CRYPT_USERDATA flag\n"); - result = CryptHashData(hHash, pbData, sizeof(pbData), 0); - } ok(result, "%08lx\n", GetLastError());
len = sizeof(DWORD); @@ -538,8 +487,7 @@ static void test_hashes(void) SetLastError(0xdeadbeef); result = CryptHashData(hHash, pbData, sizeof(pbData), 0); ok(!result, "Expected failure\n"); - ok(GetLastError() == NTE_BAD_HASH_STATE || - GetLastError() == NTE_BAD_ALGID, /* Win9x, WinMe, NT4 */ + ok(GetLastError() == NTE_BAD_HASH_STATE, "Expected NTE_BAD_HASH_STATE or NTE_BAD_ALGID, got %08lx\n", GetLastError());
/* You can still retrieve the hash, its value just hasn't changed */ @@ -558,26 +506,23 @@ static void test_hashes(void) result = CryptHashData(hHash, pbData, 5, cryptflags); ok(result, "%08lx\n", GetLastError());
- if(pCryptDuplicateHash) { - result = pCryptDuplicateHash(hHash, 0, 0, &hHashClone); - ok(result, "%08lx\n", GetLastError()); - - result = CryptHashData(hHashClone, (BYTE*)pbData+5, sizeof(pbData)-5, 0); - ok(result, "%08lx\n", GetLastError()); + result = CryptDuplicateHash(hHash, 0, 0, &hHashClone); + ok(result, "%08lx\n", GetLastError());
- len = sizeof(DWORD); - result = CryptGetHashParam(hHashClone, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0); - ok(result && (hashlen == 20), "%08lx, hashlen: %ld\n", GetLastError(), hashlen); + result = CryptHashData(hHashClone, (BYTE*)pbData+5, sizeof(pbData)-5, 0); + ok(result, "%08lx\n", GetLastError());
- len = 20; - result = CryptGetHashParam(hHashClone, HP_HASHVAL, pbHashValue, &len, 0); - ok(result, "%08lx\n", GetLastError()); + len = sizeof(DWORD); + result = CryptGetHashParam(hHashClone, HP_HASHSIZE, (BYTE*)&hashlen, &len, 0); + ok(result && (hashlen == 20), "%08lx, hashlen: %ld\n", GetLastError(), hashlen);
- ok(!memcmp(pbHashValue, sha1hash, 20), "Wrong SHA1 hash!\n"); + len = 20; + result = CryptGetHashParam(hHashClone, HP_HASHVAL, pbHashValue, &len, 0); + ok(result, "%08lx\n", GetLastError());
- result = CryptDestroyHash(hHashClone); - ok(result, "%08lx\n", GetLastError()); - } + ok(!memcmp(pbHashValue, sha1hash, 20), "Wrong SHA1 hash!\n"); + result = CryptDestroyHash(hHashClone); + ok(result, "%08lx\n", GetLastError());
result = CryptDestroyHash(hHash); ok(result, "%08lx\n", GetLastError()); @@ -615,12 +560,6 @@ static void test_hashes(void) ok(!result, "CryptDestroyHash succeeded\n"); ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER got %lu\n", error);
- if (!pCryptDuplicateHash) - { - win_skip("CryptDuplicateHash is not available\n"); - return; - } - result = CryptAcquireContextA(&prov, NULL, szProvider, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); ok(result, "CryptAcquireContextA failed 0x%08lx\n", GetLastError());
@@ -630,7 +569,7 @@ static void test_hashes(void) result = CryptHashData(hHash, (const BYTE *)"data", sizeof("data"), 0); ok(result, "CryptHashData failed 0x%08lx\n", GetLastError());
- result = pCryptDuplicateHash(hHash, NULL, 0, &hHashClone); + result = CryptDuplicateHash(hHash, NULL, 0, &hHashClone); ok(result, "CryptDuplicateHash failed 0x%08lx\n", GetLastError());
len = 20; @@ -683,7 +622,7 @@ static void test_hashes(void) "%08lx\n", GetLastError()); result = CryptSetHashParam(hHash, HP_HASHVAL, pbHashValue, 0); ok(result, "%08lx\n", GetLastError()); - len = (DWORD)sizeof(abPlainPrivateKey); + len = sizeof(abPlainPrivateKey); result = CryptImportKey(hProv, abPlainPrivateKey, len, 0, 0, &hKeyExchangeKey); ok(result, "%08lx\n", GetLastError()); len = 0; @@ -744,7 +683,7 @@ static void test_block_cipher_modes(void)
result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwLen == 11 || broken(dwLen == 0 /* Win9x/NT4 */), "unexpected salt length %ld\n", dwLen); + ok(dwLen == 11, "unexpected salt length %ld\n", dwLen);
dwLen = 23; result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwLen, 24); @@ -831,11 +770,7 @@ static void test_3des112(void) int i;
result = derive_key(CALG_3DES_112, &hKey, 0); - if (!result) { - /* rsaenh compiled without OpenSSL */ - ok(GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError()); - return; - } + ok(result, "%08lx\n", GetLastError());
for (i=0; i<sizeof(pbData); i++) pbData[i] = (unsigned char)i;
@@ -917,20 +852,10 @@ static void test_des(void) static const BYTE des[16] = { 0x58, 0x86, 0x42, 0x46, 0x65, 0x4b, 0x92, 0x62, 0xcf, 0x0f, 0x65, 0x37, 0x43, 0x7a, 0x82, 0xb9 }; - static const BYTE des_old_behavior[16] = { - 0xb0, 0xfd, 0x11, 0x69, 0x76, 0xb1, 0xa1, 0x03, - 0xf7, 0xbc, 0x23, 0xaa, 0xd4, 0xc1, 0xc9, 0x55 }; - static const BYTE des_old_strong[16] = { - 0x9b, 0xc1, 0x2a, 0xec, 0x4a, 0xf9, 0x0f, 0x14, - 0x0a, 0xed, 0xf6, 0xd3, 0xdc, 0xad, 0xf7, 0x0c }; int i;
result = derive_key(CALG_DES, &hKey, 0); - if (!result) { - /* rsaenh compiled without OpenSSL */ - ok(GetLastError()==NTE_BAD_ALGID, "%08lx\n", GetLastError()); - return; - } + ok(result, "%08lx\n", GetLastError());
dwMode = CRYPT_MODE_ECB; result = CryptSetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, 0); @@ -1024,10 +949,7 @@ static void test_des(void) dwLen = 13; result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwLen, 16); ok(result, "%08lx\n", GetLastError()); - ok(!memcmp(pbData, des, sizeof(des)) || broken( - !memcmp(pbData, des_old_behavior, sizeof(des)) || - (STRONG_PROV && !memcmp(pbData, des_old_strong, sizeof(des)))) /* <= 2000 */, - "DES encryption failed!\n"); + ok(!memcmp(pbData, des, sizeof(des)), "DES encryption failed!\n");
result = CryptDestroyKey(hKey); ok(result, "%08lx\n", GetLastError()); @@ -1174,8 +1096,7 @@ static void test_aes(int keylen)
/* Does AES provider support salt? */ result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); - todo_wine ok(result || broken(GetLastError() == NTE_BAD_KEY), /* Vista or older */ - "Expected OK, got last error %ld\n", GetLastError()); + todo_wine ok(result, "Expected OK, got last error %ld\n", GetLastError()); if (result) ok(!dwLen, "unexpected salt length %ld\n", dwLen);
@@ -1381,7 +1302,7 @@ static void test_rc2(void) HCRYPTHASH hHash; HCRYPTKEY hKey; BOOL result; - DWORD dwLen, dwKeyLen, dwDataLen, dwMode, dwModeBits, error; + DWORD dwLen, dwKeyLen, dwDataLen, dwMode, dwModeBits; unsigned char pbData[2000], pbHashValue[16], pszBuffer[256]; int i;
@@ -1427,11 +1348,8 @@ static void test_rc2(void) dwLen = sizeof(DWORD); result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwModeBits == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwModeBits == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwModeBits); + ok(dwModeBits == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwModeBits);
dwLen = sizeof(DWORD); result = CryptGetKeyParam(hKey, KP_PERMISSIONS, (BYTE*)&dwModeBits, &dwLen, 0); @@ -1492,7 +1410,7 @@ static void test_rc2(void) if (BASE_PROV || STRONG_PROV) ok(dwLen == 11, "expected salt length 11, got %ld\n", dwLen); else - ok(dwLen == 0 || broken(nt4 && dwLen == 11), "expected salt length 0, got %ld\n", dwLen); + ok(dwLen == 0, "expected salt length 0, got %ld\n", dwLen); /* What sizes salt can I set? */ salt.pbData = pbData; for (i=0; i<24; i++) @@ -1508,9 +1426,7 @@ static void test_rc2(void) salt.cbData = 25; SetLastError(0xdeadbeef); result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0); - ok(!result || - broken(result), /* Win9x, WinMe, NT4, W2K */ - "%08lx\n", GetLastError()); + ok(!result, "%08lx\n", GetLastError());
result = CryptDestroyKey(hKey); ok(result, "%08lx\n", GetLastError()); @@ -1613,19 +1529,10 @@ static void test_rc2(void) memset(pbData, 0xAF, dwDataLen); SetLastError(0xdeadbeef); result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24); - if(result) - { - ok((ENHANCED_PROV && !memcmp(pbData, rc2_40_salt_enh, dwDataLen)) || - (STRONG_PROV && !memcmp(pbData, rc2_40_salt_strong, dwDataLen)) || - (BASE_PROV && !memcmp(pbData, rc2_40_salt_base, dwDataLen)), - "RC2 encryption failed!\n"); - } - else /* <= XP */ - { - error = GetLastError(); - ok(error == NTE_BAD_DATA || broken(error == NTE_DOUBLE_ENCRYPT), - "Expected 0x80009005, got 0x%08lX\n", error); - } + ok((ENHANCED_PROV && !memcmp(pbData, rc2_40_salt_enh, dwDataLen)) || + (STRONG_PROV && !memcmp(pbData, rc2_40_salt_strong, dwDataLen)) || + (BASE_PROV && !memcmp(pbData, rc2_40_salt_base, dwDataLen)), + "RC2 encryption failed!\n"); dwLen = sizeof(DWORD); dwKeyLen = 12345; result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0); @@ -1664,6 +1571,7 @@ static void test_rc4(void) HCRYPTHASH hHash; HCRYPTKEY hKey; DWORD dwDataLen = 5, dwKeyLen, dwLen = sizeof(DWORD), dwMode; + CRYPT_INTEGER_BLOB salt; unsigned char pbData[2000]; unsigned char pszBuffer[256]; int i; @@ -1672,135 +1580,126 @@ static void test_rc4(void)
/* MD2 Hashing */ result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash); - if (!result) { - /* rsaenh compiled without OpenSSL */ - ok(GetLastError() == NTE_BAD_ALGID, "%08lx\n", GetLastError()); - } else { - CRYPT_INTEGER_BLOB salt; - - result = CryptHashData(hHash, pbData, sizeof(pbData), 0); - ok(result, "%08lx\n", GetLastError()); + ok(result, "%08lx\n", GetLastError());
- dwLen = 16; - result = CryptGetHashParam(hHash, HP_HASHVAL, pszBuffer, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); + result = CryptHashData(hHash, pbData, sizeof(pbData), 0); + ok(result, "%08lx\n", GetLastError());
- result = CryptDeriveKey(hProv, CALG_RC4, hHash, 56 << 16, &hKey); - ok(result, "%08lx\n", GetLastError()); + dwLen = 16; + result = CryptGetHashParam(hHash, HP_HASHVAL, pszBuffer, &dwLen, 0); + ok(result, "%08lx\n", GetLastError());
- dwLen = sizeof(DWORD); - result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - ok(dwKeyLen == 56, "Expected 56, got %ld\n", dwKeyLen); + result = CryptDeriveKey(hProv, CALG_RC4, hHash, 56 << 16, &hKey); + ok(result, "%08lx\n", GetLastError());
- dwLen = sizeof(DWORD); - result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwKeyLen, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - ok(dwKeyLen == 0, "Expected 0, got %ld\n", dwKeyLen); + dwLen = sizeof(DWORD); + result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + ok(dwKeyLen == 56, "Expected 56, got %ld\n", dwKeyLen);
- dwLen = 0; - result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - result = CryptGetKeyParam(hKey, KP_IV, pszBuffer, &dwLen, 0); + dwLen = sizeof(DWORD); + result = CryptGetKeyParam(hKey, KP_BLOCKLEN, (BYTE*)&dwKeyLen, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + ok(dwKeyLen == 0, "Expected 0, got %ld\n", dwKeyLen);
- dwLen = 0; - result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - result = CryptGetKeyParam(hKey, KP_SALT, pszBuffer, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); + dwLen = 0; + result = CryptGetKeyParam(hKey, KP_IV, NULL, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + result = CryptGetKeyParam(hKey, KP_IV, pszBuffer, &dwLen, 0);
- dwLen = sizeof(DWORD); - result = CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - ok(dwMode == 0 || broken(dwMode == CRYPT_MODE_CBC) /* <= 2000 */, - "Expected 0, got %ld\n", dwMode); + dwLen = 0; + result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + result = CryptGetKeyParam(hKey, KP_SALT, pszBuffer, &dwLen, 0); + ok(result, "%08lx\n", GetLastError());
- result = CryptDestroyHash(hHash); - ok(result, "%08lx\n", GetLastError()); + dwLen = sizeof(DWORD); + result = CryptGetKeyParam(hKey, KP_MODE, (BYTE*)&dwMode, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + ok(dwMode == 0, "Expected 0, got %ld\n", dwMode);
- dwDataLen = 16; - result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwDataLen, 24); - ok(result, "%08lx\n", GetLastError()); - dwDataLen = 16; - result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24); - ok(result, "%08lx\n", GetLastError()); + result = CryptDestroyHash(hHash); + ok(result, "%08lx\n", GetLastError());
- ok(!memcmp(pbData, rc4, dwDataLen), "RC4 encryption failed!\n"); + dwDataLen = 16; + result = CryptEncrypt(hKey, 0, TRUE, 0, NULL, &dwDataLen, 24); + ok(result, "%08lx\n", GetLastError()); + dwDataLen = 16; + result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24); + ok(result, "%08lx\n", GetLastError()); + ok(!memcmp(pbData, rc4, dwDataLen), "RC4 encryption failed!\n");
- result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen); - ok(result, "%08lx\n", GetLastError()); + result = CryptDecrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen); + ok(result, "%08lx\n", GetLastError());
- /* Setting the salt value will not reset the salt length in base or strong providers */ - result = CryptSetKeyParam(hKey, KP_SALT, pbData, 0); - ok(result, "setting salt failed: %08lx\n", GetLastError()); - dwLen = 0; + /* Setting the salt value will not reset the salt length in base or strong providers */ + result = CryptSetKeyParam(hKey, KP_SALT, pbData, 0); + ok(result, "setting salt failed: %08lx\n", GetLastError()); + dwLen = 0; + result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + if (BASE_PROV || STRONG_PROV) + ok(dwLen == 11, "expected salt length 11, got %ld\n", dwLen); + else + ok(dwLen == 0, "expected salt length 0, got %ld\n", dwLen); + /* What sizes salt can I set? */ + salt.pbData = pbData; + for (i = 0; i < 24; i++) + { + salt.cbData = i; + result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0); + ok(result, "setting salt failed for size %d: %08lx\n", i, GetLastError()); + /* The returned salt length is the same as the set salt length */ result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - if (BASE_PROV || STRONG_PROV) - ok(dwLen == 11, "expected salt length 11, got %ld\n", dwLen); - else - ok(dwLen == 0 || broken(nt4 && dwLen == 11), "expected salt length 0, got %ld\n", dwLen); - /* What sizes salt can I set? */ - salt.pbData = pbData; - for (i=0; i<24; i++) - { - salt.cbData = i; - result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0); - ok(result, "setting salt failed for size %d: %08lx\n", i, GetLastError()); - /* The returned salt length is the same as the set salt length */ - result = CryptGetKeyParam(hKey, KP_SALT, NULL, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - ok(dwLen == i, "size %d: unexpected salt length %ld\n", i, dwLen); - } - salt.cbData = 25; - SetLastError(0xdeadbeef); - result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0); - ok(!result || - broken(result), /* Win9x, WinMe, NT4, W2K */ - "%08lx\n", GetLastError()); + ok(dwLen == i, "size %d: unexpected salt length %ld\n", i, dwLen); + } + salt.cbData = 25; + SetLastError(0xdeadbeef); + result = CryptSetKeyParam(hKey, KP_SALT_EX, (BYTE *)&salt, 0); + ok(!result, "%08lx\n", GetLastError());
- result = CryptDestroyKey(hKey); - ok(result, "%08lx\n", GetLastError()); + result = CryptDestroyKey(hKey); + ok(result, "%08lx\n", GetLastError());
- /* Test a 40 bit key with salt */ - result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash); - ok(result, "%08lx\n", GetLastError()); + /* Test a 40 bit key with salt */ + result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash); + ok(result, "%08lx\n", GetLastError());
- result = CryptHashData(hHash, pbData, sizeof(pbData), 0); - ok(result, "%08lx\n", GetLastError()); + result = CryptHashData(hHash, pbData, sizeof(pbData), 0); + ok(result, "%08lx\n", GetLastError());
- result = CryptDeriveKey(hProv, CALG_RC4, hHash, (40<<16)|CRYPT_CREATE_SALT, &hKey); - ok(result, "%08lx\n", GetLastError()); - dwDataLen = 16; - memset(pbData, 0xAF, dwDataLen); - SetLastError(0xdeadbeef); - result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24); - ok(result, "%08lx\n", GetLastError()); - ok((ENHANCED_PROV && !memcmp(pbData, rc4_40_salt, dwDataLen)) || - (!ENHANCED_PROV && !memcmp(pbData, rc4_40_salt_base, dwDataLen)), - "RC4 encryption failed!\n"); + result = CryptDeriveKey(hProv, CALG_RC4, hHash, (40<<16)|CRYPT_CREATE_SALT, &hKey); + ok(result, "%08lx\n", GetLastError()); + dwDataLen = 16; + memset(pbData, 0xAF, dwDataLen); + SetLastError(0xdeadbeef); + result = CryptEncrypt(hKey, 0, TRUE, 0, pbData, &dwDataLen, 24); + ok(result, "%08lx\n", GetLastError()); + ok((ENHANCED_PROV && !memcmp(pbData, rc4_40_salt, dwDataLen)) || + (!ENHANCED_PROV && !memcmp(pbData, rc4_40_salt_base, dwDataLen)), + "RC4 encryption failed!\n");
- dwLen = sizeof(DWORD); - dwKeyLen = 12345; - result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - ok(dwKeyLen == 40, "Expected 40, got %ld\n", dwKeyLen); + dwLen = sizeof(DWORD); + dwKeyLen = 12345; + result = CryptGetKeyParam(hKey, KP_KEYLEN, (BYTE*)&dwKeyLen, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + ok(dwKeyLen == 40, "Expected 40, got %ld\n", dwKeyLen);
- dwLen = sizeof(pszBuffer); - memset(pszBuffer, 0xAF, dwLen); - result = CryptGetKeyParam(hKey, KP_SALT, pszBuffer, &dwLen, 0); - ok(result, "%08lx\n", GetLastError()); - if (!ENHANCED_PROV) - ok(dwLen == 11, "Expected 11, got %ld\n", dwLen); - else - ok(dwLen == 0, "Expected 0, got %ld\n", dwLen); + dwLen = sizeof(pszBuffer); + memset(pszBuffer, 0xAF, dwLen); + result = CryptGetKeyParam(hKey, KP_SALT, pszBuffer, &dwLen, 0); + ok(result, "%08lx\n", GetLastError()); + if (!ENHANCED_PROV) + ok(dwLen == 11, "Expected 11, got %ld\n", dwLen); + else + ok(dwLen == 0, "Expected 0, got %ld\n", dwLen);
- result = CryptDestroyKey(hKey); - ok(result, "%08lx\n", GetLastError()); + result = CryptDestroyKey(hKey); + ok(result, "%08lx\n", GetLastError());
- result = CryptDestroyHash(hHash); - ok(result, "%08lx\n", GetLastError()); - } + result = CryptDestroyHash(hHash); + ok(result, "%08lx\n", GetLastError()); }
static void test_hmac(void) { @@ -1822,7 +1721,6 @@ static void test_hmac(void) {
result = CryptCreateHash(hProv, CALG_HMAC, hKey, 0, &hHash); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptSetHashParam(hHash, HP_HMAC_INFO, (BYTE*)&hmacInfo, 0); ok(result, "%08lx\n", GetLastError()); @@ -1870,7 +1768,6 @@ static void test_mac(void) {
result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
dwLen = 8; result = CryptEncrypt(hKey, 0, FALSE, 0, abEnc, &dwLen, dwLen); @@ -1940,9 +1837,7 @@ static void test_mac(void) {
SetLastError(0xdeadbeef); result = CryptCreateHash(hProv, CALG_MAC, hKey, 0, &hHash); - ok((!result && GetLastError() == NTE_BAD_KEY) || - broken(result), /* Win9x, WinMe, NT4, W2K */ - "%08lx\n", GetLastError()); + ok(!result && GetLastError() == NTE_BAD_KEY, "%08lx\n", GetLastError());
result = CryptDestroyKey(hKey); ok(result, "%08lx\n", GetLastError()); @@ -1980,30 +1875,22 @@ static void test_import_private(void) BLOBHEADER *blobHeader = (BLOBHEADER *)abPlainPrivateKey; RSAPUBKEY *rsaPubKey = (RSAPUBKEY *)(blobHeader+1);
- dwLen = (DWORD)sizeof(abPlainPrivateKey); + dwLen = sizeof(abPlainPrivateKey); result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey); - if (!result) { - /* rsaenh compiled without OpenSSL */ - ok(GetLastError() == NTE_FAIL, "%08lx\n", GetLastError()); - return; - } + ok(result, "%08lx\n", GetLastError());
- dwLen = (DWORD)sizeof(abSessionKey); + dwLen = sizeof(abSessionKey); result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
dwVal = 0xdeadbeef; dwLen = sizeof(DWORD); result = CryptGetKeyParam(hSessionKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwVal);
- dwLen = (DWORD)sizeof(abEncryptedMessage); + dwLen = sizeof(abEncryptedMessage); result = CryptDecrypt(hSessionKey, 0, TRUE, 0, abEncryptedMessage, &dwLen); ok(result, "%08lx\n", GetLastError()); ok(dwLen == 12, "expected 12, got %ld\n", dwLen); @@ -2012,16 +1899,14 @@ static void test_import_private(void)
if (!derive_key(CALG_RC4, &hSessionKey, 56)) return;
- dwLen = (DWORD)sizeof(abSessionKey); + dwLen = sizeof(abSessionKey); result = CryptExportKey(hSessionKey, hKeyExchangeKey, SIMPLEBLOB, 0, abSessionKey, &dwLen); ok(result, "%08lx\n", GetLastError()); CryptDestroyKey(hSessionKey); - if (!result) return;
- dwLen = (DWORD)sizeof(abSessionKey); + dwLen = sizeof(abSessionKey); result = CryptImportKey(hProv, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
CryptDestroyKey(hSessionKey); CryptDestroyKey(hKeyExchangeKey); @@ -2044,7 +1929,8 @@ static void test_import_private(void) static void test_verify_signature(void) { HCRYPTHASH hHash; HCRYPTKEY hPubSignKey; - BYTE abData[] = "Wine rocks!"; + BYTE abData[] = "Wine rocks!", buf[148]; + DWORD len; BOOL result; BYTE abPubKey[148] = { 0x06, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, @@ -2222,107 +2108,90 @@ static void test_verify_signature(void) {
result = CryptImportKey(hProv, abPubKey, 148, 0, 0, &hPubSignKey); ok(result, "%08lx\n", GetLastError()); - if (!result) return; + + len = sizeof(buf); + result = CryptExportKey(hPubSignKey, 0, PUBLICKEYBLOB, 0, buf, &len); + ok(result, "%08lx\n", GetLastError()); + ok(len == sizeof(buf), "got %lu\n", len); + ok(!memcmp(abPubKey, buf, sizeof(buf)), "wrong data\n");
result = CryptCreateHash(hProv, CALG_MD2, 0, 0, &hHash); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
- result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0); + result = CryptHashData(hHash, abData, sizeof(abData), 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
/*check that a NULL pointer signature is correctly handled*/ result = CryptVerifySignatureA(hHash, NULL, 128, hPubSignKey, NULL, 0); ok(!result && ERROR_INVALID_PARAMETER == GetLastError(), "Expected ERROR_INVALID_PARAMETER error, got %08lx\n", GetLastError()); - if (result) return;
/* check that we get a bad signature error when the signature is too short*/ SetLastError(0xdeadbeef); result = CryptVerifySignatureA(hHash, abSignatureMD2, 64, hPubSignKey, NULL, 0); - ok((!result && NTE_BAD_SIGNATURE == GetLastError()) || - broken(result), /* Win9x, WinMe, NT4 */ - "Expected NTE_BAD_SIGNATURE, got %08lx\n", GetLastError()); + ok(!result && NTE_BAD_SIGNATURE == GetLastError(), "Expected NTE_BAD_SIGNATURE, got %08lx\n", + GetLastError());
result = CryptVerifySignatureA(hHash, abSignatureMD2, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
/* It seems that CPVerifySignature doesn't care about the OID at all. */ result = CryptVerifySignatureA(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD2NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
CryptDestroyHash(hHash);
result = CryptCreateHash(hProv, CALG_MD4, 0, 0, &hHash); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
- result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0); + result = CryptHashData(hHash, abData, sizeof(abData), 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD4, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD4NoOID, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD4NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
CryptDestroyHash(hHash);
result = CryptCreateHash(hProv, CALG_MD5, 0, 0, &hHash); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
- result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0); + result = CryptHashData(hHash, abData, sizeof(abData), 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD5, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD5NoOID, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureMD5NoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
CryptDestroyHash(hHash);
result = CryptCreateHash(hProv, CALG_SHA, 0, 0, &hHash); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
- result = CryptHashData(hHash, abData, (DWORD)sizeof(abData), 0); + result = CryptHashData(hHash, abData, sizeof(abData), 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureSHA, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureSHANoOID, 128, hPubSignKey, NULL, 0); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptVerifySignatureA(hHash, abSignatureSHANoOID, 128, hPubSignKey, NULL, CRYPT_NOHASHOID); ok(result, "%08lx\n", GetLastError()); - if (!result) return;
CryptDestroyHash(hHash); CryptDestroyKey(hPubSignKey); @@ -2339,10 +2208,9 @@ static void test_rsa_encrypt(void) /* It is allowed to use the key exchange key for encryption/decryption */ result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hRSAKey); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
dwLen = 12; - result = CryptEncrypt(hRSAKey, 0, TRUE, 0, NULL, &dwLen, (DWORD)sizeof(abData)); + result = CryptEncrypt(hRSAKey, 0, TRUE, 0, NULL, &dwLen, sizeof(abData)); if(!ENHANCED_PROV && !result && GetLastError() == NTE_BAD_KEY) { CryptDestroyKey(hRSAKey); @@ -2352,9 +2220,8 @@ static void test_rsa_encrypt(void) ok(dwLen == 128, "Unexpected length %ld\n", dwLen); /* PKCS1 V1.5 */ dwLen = 12; - result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData)); + result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, sizeof(abData)); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptDecrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen); ok (result && dwLen == 12 && !memcmp(abData, "Wine rocks!", 12), "%08lx\n", GetLastError()); @@ -2369,7 +2236,7 @@ static void test_rsa_encrypt(void)
/* Test data length limit */ dwLen = sizeof(abData) - (20 * 2 + 2) + 1; - result = CryptEncrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen, (DWORD)sizeof(abData)); + result = CryptEncrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen, sizeof(abData)); err = GetLastError(); ok(!result && err == NTE_BAD_LEN, "%08lx\n", err);
@@ -2379,27 +2246,24 @@ static void test_rsa_encrypt(void) memcpy(abData, "Wine rocks!", dwLen); result = CryptDecrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen); err = GetLastError(); - /* NTE_DOUBLE_ENCRYPT on xp or 2003 */ - ok(!result && (err == NTE_BAD_DATA || broken(err == NTE_DOUBLE_ENCRYPT)), "%08lx\n", err); + ok(!result && err == NTE_BAD_DATA, "%08lx\n", err);
/* Test decrypt with insufficient buffer */ dwLen = 12; SetLastError(0xdeadbeef); memcpy(abData, "Wine rocks!", 12); - result = CryptEncrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen, (DWORD)sizeof(abData)); + result = CryptEncrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen, sizeof(abData)); ok(result, "%08lx\n", GetLastError()); dwLen = 11; SetLastError(0xdeadbeef); result = CryptDecrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen); err = GetLastError(); - /* broken on xp or 2003 */ - ok((!result && dwLen == 11 && err == NTE_BAD_DATA) || broken(result == TRUE && dwLen == 12 && err == ERROR_NO_TOKEN), - "%08x %ld %08lx\n", result, dwLen, err); + ok(!result && dwLen == 11 && err == NTE_BAD_DATA, "%08x %ld %08lx\n", result, dwLen, err);
/* Test normal encryption and decryption */ dwLen = 12; memcpy(abData, "Wine rocks!", dwLen); - result = CryptEncrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen, (DWORD)sizeof(abData)); + result = CryptEncrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen, sizeof(abData)); ok(result, "%08lx\n", GetLastError()); result = CryptDecrypt(hRSAKey, 0, TRUE, CRYPT_OAEP, abData, &dwLen); ok(result && dwLen == 12 && !memcmp(abData, "Wine rocks!", 12), "%08lx\n", GetLastError()); @@ -2408,11 +2272,8 @@ static void test_rsa_encrypt(void) dwLen = sizeof(DWORD); result = CryptGetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwVal);
/* An RSA key doesn't support salt */ result = CryptGetKeyParam(hRSAKey, KP_SALT, NULL, &dwLen, 0); @@ -2425,15 +2286,13 @@ static void test_rsa_encrypt(void) /* but its private key may not be. */ SetLastError(0xdeadbeef); result = CryptExportKey(hRSAKey, 0, PRIVATEKEYBLOB, 0, NULL, &dwLen); - ok((!result && GetLastError() == NTE_BAD_KEY_STATE) || - broken(result), /* Win9x/NT4 */ - "expected NTE_BAD_KEY_STATE, got %08lx\n", GetLastError()); + ok(!result && GetLastError() == NTE_BAD_KEY_STATE, "expected NTE_BAD_KEY_STATE, got %08lx\n", + GetLastError()); /* Setting the permissions of the key exchange key isn't allowed, either. */ dwVal |= CRYPT_EXPORT; SetLastError(0xdeadbeef); result = CryptSetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE *)&dwVal, 0); - ok(!result && - (GetLastError() == NTE_BAD_DATA || GetLastError() == NTE_BAD_FLAGS), + ok(!result && (GetLastError() == NTE_BAD_DATA || GetLastError() == NTE_BAD_FLAGS), "expected NTE_BAD_DATA or NTE_BAD_FLAGS, got %08lx\n", GetLastError());
CryptDestroyKey(hRSAKey); @@ -2450,11 +2309,8 @@ static void test_rsa_encrypt(void) dwLen = sizeof(DWORD); result = CryptGetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwVal);
/* The signature key's public key may also be exported.. */ result = CryptExportKey(hRSAKey, 0, PUBLICKEYBLOB, 0, NULL, &dwLen); @@ -2462,19 +2318,17 @@ static void test_rsa_encrypt(void) /* but its private key may not be. */ SetLastError(0xdeadbeef); result = CryptExportKey(hRSAKey, 0, PRIVATEKEYBLOB, 0, NULL, &dwLen); - ok((!result && GetLastError() == NTE_BAD_KEY_STATE) || - broken(result), /* Win9x/NT4 */ - "expected NTE_BAD_KEY_STATE, got %08lx\n", GetLastError()); + ok(!result && GetLastError() == NTE_BAD_KEY_STATE, "expected NTE_BAD_KEY_STATE got %08lx\n", + GetLastError()); /* Setting the permissions of the signature key isn't allowed, either. */ dwVal |= CRYPT_EXPORT; SetLastError(0xdeadbeef); result = CryptSetKeyParam(hRSAKey, KP_PERMISSIONS, (BYTE *)&dwVal, 0); - ok(!result && - (GetLastError() == NTE_BAD_DATA || GetLastError() == NTE_BAD_FLAGS), + ok(!result && (GetLastError() == NTE_BAD_DATA || GetLastError() == NTE_BAD_FLAGS), "expected NTE_BAD_DATA or NTE_BAD_FLAGS, got %08lx\n", GetLastError());
dwLen = 12; - result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, (DWORD)sizeof(abData)); + result = CryptEncrypt(hRSAKey, 0, TRUE, 0, abData, &dwLen, sizeof(abData)); ok (!result && GetLastError() == NTE_BAD_KEY, "%08lx\n", GetLastError());
CryptDestroyKey(hRSAKey); @@ -2577,82 +2431,55 @@ static void test_import_export(void) 0xe6, 0x36, 0x60, 0xb6, 0x36, 0xdc, 0x1d, 0x59, 0xb6, 0x5f, 0x01, 0x5e }; + static const BYTE expected_exported_priv_key[] = { + /* BLOBHEADER */ 0x07, 0x02, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, - 0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00, - 0x01, 0x00, 0x01, 0x00, 0xd5, 0xa2, 0x0d, 0x66, - 0xfe, 0x65, 0xb5, 0xf1, 0xc9, 0x6b, 0xf5, 0x58, - 0x04, 0x38, 0x2d, 0xf4, 0xa3, 0x5a, 0xda, 0x9e, - 0x95, 0x81, 0x85, 0x3d, 0x01, 0x07, 0xb2, 0x03, - 0x77, 0x70, 0x79, 0x6e, 0x6c, 0x26, 0x42, 0xa4, - 0x12, 0xfd, 0xaa, 0x29, 0x83, 0x04, 0xce, 0x91, - 0x90, 0x39, 0x5e, 0x49, 0x56, 0xfd, 0x0a, 0xe5, - 0xb1, 0xea, 0x3b, 0xb2, 0x70, 0xb0, 0x20, 0xc1, - 0x1f, 0x22, 0x07, 0x3e, 0x4d, 0xc0, 0x73, 0xfd, - 0x92, 0x8f, 0x87, 0xd8, 0xd1, 0xd1, 0x28, 0xd8, - 0x19, 0xd1, 0x93, 0x83, 0xe0, 0xb8, 0x9f, 0x53, - 0xf4, 0x6a, 0x7c, 0xcb, 0x10, 0x53, 0xd0, 0x37, - 0x02, 0xb4, 0xa5, 0xf7, 0xa2, 0x28, 0x6e, 0x26, - 0xef, 0x5c, 0x14, 0x01, 0x40, 0x1e, 0xa3, 0xe1, - 0xda, 0x76, 0xd0, 0x12, 0x84, 0xb7, 0x48, 0x7d, - 0xc8, 0x67, 0x5c, 0xb2, 0xd5, 0x2e, 0xaf, 0x8e, - 0x7d, 0x32, 0x59, 0x92, 0x01, 0xd6, 0x5b, 0x68, - 0x28, 0x9b, 0xb1, 0x6c, 0x69, 0xeb, 0x61, 0x5b, - 0x4b, 0x13, 0xe2, 0xbd, 0x7d, 0xbe, 0xce, 0xe8, - 0x41, 0x54, 0xca, 0xa8, 0xdd, 0xc7, 0xfe, 0x8b, - 0xdf, 0xf6, 0x55, 0x6c, 0x50, 0x11, 0xc8, 0x15, - 0x13, 0x42, 0x59, 0x9f, 0xbb, 0xea, 0x73, 0x78, - 0x7b, 0x22, 0x8d, 0x96, 0x62, 0xe5, 0xda, 0xa2, - 0x85, 0x5c, 0x20, 0x74, 0x9f, 0x1c, 0x12, 0xf2, - 0x48, 0x06, 0x1a, 0xc6, 0xd5, 0x94, 0xec, 0x31, - 0x6b, 0xb6, 0x7b, 0x54, 0x61, 0x77, 0xec, 0x7c, - 0x6f, 0xb7, 0x55, 0x3d, 0x6b, 0x98, 0x05, 0xd7, - 0x8a, 0x73, 0x25, 0xf2, 0x8f, 0xe4, 0xb8, 0x8d, - 0x27, 0x18, 0x0d, 0x05, 0xba, 0x23, 0x54, 0x37, - 0x10, 0xf0, 0x1c, 0x41, 0xa6, 0xae, 0x4c, 0x2a, - 0x6a, 0x2f, 0x7f, 0x68, 0x43, 0x86, 0xe7, 0x9c, - 0xfd, 0x9e, 0xf1, 0xfe, 0x84, 0xe3, 0xb6, 0x99, - 0x51, 0xfe, 0x1e, 0xbd, 0x01, 0xc6, 0x10, 0xef, - 0x88, 0xa4, 0xd8, 0x53, 0x14, 0x88, 0x15, 0xc9, - 0xe5, 0x86, 0xe2, 0x8d, 0x85, 0x2e, 0x0d, 0xec, - 0x15, 0xa7, 0x48, 0xfa, 0x18, 0xfb, 0x01, 0x8d, - 0x2b, 0x90, 0x70, 0x7f, 0x78, 0xb1, 0x33, 0x7e, - 0xfe, 0x82, 0x40, 0x5f, 0x4a, 0x97, 0xc2, 0x42, - 0x22, 0xd5, 0x5f, 0xbc, 0xbd, 0xab, 0x26, 0x98, - 0xcd, 0xb5, 0xdf, 0x7e, 0xa0, 0x68, 0xa7, 0x12, - 0x9e, 0xa5, 0xa2, 0x90, 0x85, 0xc5, 0xca, 0x73, - 0x4a, 0x59, 0x8a, 0xec, 0xcf, 0xdd, 0x65, 0x5d, - 0xc1, 0xaa, 0x86, 0x53, 0xd5, 0xde, 0xbb, 0x23, - 0x24, 0xb8, 0x9b, 0x74, 0x03, 0x20, 0xb4, 0xf0, - 0xe4, 0xdd, 0xd2, 0x03, 0xfd, 0x67, 0x55, 0x19, - 0x28, 0x1d, 0xc1, 0xb8, 0xa5, 0x89, 0x0e, 0xc0, - 0x80, 0x9d, 0xdd, 0xda, 0x9d, 0x30, 0x5c, 0xc8, - 0xbb, 0xfe, 0x8f, 0xce, 0xd5, 0xf6, 0xdf, 0xfa, - 0x14, 0xaf, 0xe4, 0xba, 0xb0, 0x84, 0x45, 0xd8, - 0x67, 0xa7, 0xd0, 0xce, 0x89, 0x2a, 0x30, 0x8c, - 0xfa, 0xe9, 0x65, 0xa4, 0x21, 0x2d, 0x6b, 0xa2, - 0x9b, 0x8f, 0x92, 0xbd, 0x3a, 0x10, 0x71, 0x12, - 0xc2, 0x02, 0x3d, 0xd5, 0x83, 0x1d, 0xfa, 0x42, - 0xb7, 0x48, 0x1b, 0x31, 0xe3, 0x82, 0x90, 0x2d, - 0x91, 0x59, 0xf9, 0x38, 0x52, 0xe5, 0xdb, 0xc1, - 0x4d, 0x3a, 0xe6, 0x9b, 0x6a, 0xbb, 0xea, 0xa4, - 0x8d, 0x5e, 0xc4, 0x00, 0x01, 0xb8, 0xec, 0x91, - 0xc1, 0xdb, 0x63, 0xbd, 0x57, 0xb6, 0x26, 0x15, - 0xb6, 0x3e, 0xa2, 0xdf, 0x62, 0x8d, 0xa8, 0xbe, - 0xe1, 0xf1, 0x39, 0xbd, 0x18, 0xd2, 0x6f, 0xd7, - 0xda, 0xdc, 0x71, 0x30, 0xf1, 0x21, 0x71, 0xa4, - 0x08, 0x43, 0x46, 0xdf, 0x50, 0xbd, 0x3c, 0x60, - 0x5b, 0x63, 0x35, 0xe3, 0x37, 0x5b, 0x25, 0x17, - 0x54, 0x5e, 0x68, 0x60, 0xb6, 0x49, 0xef, 0x6e, - 0x09, 0xef, 0xda, 0x90, 0x3e, 0xd4, 0x09, 0x33, - 0x36, 0x57, 0x9a, 0x14, 0xbd, 0xf7, 0xb1, 0x98, - 0x30, 0x42, 0x03, 0x84, 0x61, 0xeb, 0x8e, 0x50, - 0xdc, 0x6a, 0x93, 0x1b, 0x32, 0x51, 0xf9, 0xc6, - 0xc2, 0x19, 0xb3, 0x5d, 0xe2, 0xf8, 0xc5, 0x8f, - 0x68, 0xaa, 0x1d, 0xdb, 0xd3, 0x7f, 0x8d, 0x98, - 0x9c, 0x16, 0x8c, 0xc3, 0xcd, 0xd9, 0xdb, 0x08, - 0xe6, 0x36, 0x60, 0xb6, 0x36, 0xdc, 0x1d, 0x59, - 0xb6, 0x5f, 0x01, 0x5e + /* PUBKEY */ + 0x52, 0x53, 0x41, 0x32, 0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, + /* m */ + 0xd5, 0xa2, 0x0d, 0x66, 0xfe, 0x65, 0xb5, 0xf1, 0xc9, 0x6b, 0xf5, 0x58, 0x04, 0x38, 0x2d, 0xf4, + 0xa3, 0x5a, 0xda, 0x9e, 0x95, 0x81, 0x85, 0x3d, 0x01, 0x07, 0xb2, 0x03, 0x77, 0x70, 0x79, 0x6e, + 0x6c, 0x26, 0x42, 0xa4, 0x12, 0xfd, 0xaa, 0x29, 0x83, 0x04, 0xce, 0x91, 0x90, 0x39, 0x5e, 0x49, + 0x56, 0xfd, 0x0a, 0xe5, 0xb1, 0xea, 0x3b, 0xb2, 0x70, 0xb0, 0x20, 0xc1, 0x1f, 0x22, 0x07, 0x3e, + 0x4d, 0xc0, 0x73, 0xfd, 0x92, 0x8f, 0x87, 0xd8, 0xd1, 0xd1, 0x28, 0xd8, 0x19, 0xd1, 0x93, 0x83, + 0xe0, 0xb8, 0x9f, 0x53, 0xf4, 0x6a, 0x7c, 0xcb, 0x10, 0x53, 0xd0, 0x37, 0x02, 0xb4, 0xa5, 0xf7, + 0xa2, 0x28, 0x6e, 0x26, 0xef, 0x5c, 0x14, 0x01, 0x40, 0x1e, 0xa3, 0xe1, 0xda, 0x76, 0xd0, 0x12, + 0x84, 0xb7, 0x48, 0x7d, 0xc8, 0x67, 0x5c, 0xb2, 0xd5, 0x2e, 0xaf, 0x8e, 0x7d, 0x32, 0x59, 0x92, + /* p1 */ + 0x01, 0xd6, 0x5b, 0x68, 0x28, 0x9b, 0xb1, 0x6c, 0x69, 0xeb, 0x61, 0x5b, 0x4b, 0x13, 0xe2, 0xbd, + 0x7d, 0xbe, 0xce, 0xe8, 0x41, 0x54, 0xca, 0xa8, 0xdd, 0xc7, 0xfe, 0x8b, 0xdf, 0xf6, 0x55, 0x6c, + 0x50, 0x11, 0xc8, 0x15, 0x13, 0x42, 0x59, 0x9f, 0xbb, 0xea, 0x73, 0x78, 0x7b, 0x22, 0x8d, 0x96, + 0x62, 0xe5, 0xda, 0xa2, 0x85, 0x5c, 0x20, 0x74, 0x9f, 0x1c, 0x12, 0xf2, 0x48, 0x06, 0x1a, 0xc6, + /* p2 */ + 0xd5, 0x94, 0xec, 0x31, 0x6b, 0xb6, 0x7b, 0x54, 0x61, 0x77, 0xec, 0x7c, 0x6f, 0xb7, 0x55, 0x3d, + 0x6b, 0x98, 0x05, 0xd7, 0x8a, 0x73, 0x25, 0xf2, 0x8f, 0xe4, 0xb8, 0x8d, 0x27, 0x18, 0x0d, 0x05, + 0xba, 0x23, 0x54, 0x37, 0x10, 0xf0, 0x1c, 0x41, 0xa6, 0xae, 0x4c, 0x2a, 0x6a, 0x2f, 0x7f, 0x68, + 0x43, 0x86, 0xe7, 0x9c, 0xfd, 0x9e, 0xf1, 0xfe, 0x84, 0xe3, 0xb6, 0x99, 0x51, 0xfe, 0x1e, 0xbd, + /* e1 */ + 0x01, 0xc6, 0x10, 0xef, 0x88, 0xa4, 0xd8, 0x53, 0x14, 0x88, 0x15, 0xc9, 0xe5, 0x86, 0xe2, 0x8d, + 0x85, 0x2e, 0x0d, 0xec, 0x15, 0xa7, 0x48, 0xfa, 0x18, 0xfb, 0x01, 0x8d, 0x2b, 0x90, 0x70, 0x7f, + 0x78, 0xb1, 0x33, 0x7e, 0xfe, 0x82, 0x40, 0x5f, 0x4a, 0x97, 0xc2, 0x42, 0x22, 0xd5, 0x5f, 0xbc, + 0xbd, 0xab, 0x26, 0x98, 0xcd, 0xb5, 0xdf, 0x7e, 0xa0, 0x68, 0xa7, 0x12, 0x9e, 0xa5, 0xa2, 0x90, + /* e2 */ + 0x85, 0xc5, 0xca, 0x73, 0x4a, 0x59, 0x8a, 0xec, 0xcf, 0xdd, 0x65, 0x5d, 0xc1, 0xaa, 0x86, 0x53, + 0xd5, 0xde, 0xbb, 0x23, 0x24, 0xb8, 0x9b, 0x74, 0x03, 0x20, 0xb4, 0xf0, 0xe4, 0xdd, 0xd2, 0x03, + 0xfd, 0x67, 0x55, 0x19, 0x28, 0x1d, 0xc1, 0xb8, 0xa5, 0x89, 0x0e, 0xc0, 0x80, 0x9d, 0xdd, 0xda, + 0x9d, 0x30, 0x5c, 0xc8, 0xbb, 0xfe, 0x8f, 0xce, 0xd5, 0xf6, 0xdf, 0xfa, 0x14, 0xaf, 0xe4, 0xba, + /* u */ + 0xb0, 0x84, 0x45, 0xd8, 0x67, 0xa7, 0xd0, 0xce, 0x89, 0x2a, 0x30, 0x8c, 0xfa, 0xe9, 0x65, 0xa4, + 0x21, 0x2d, 0x6b, 0xa2, 0x9b, 0x8f, 0x92, 0xbd, 0x3a, 0x10, 0x71, 0x12, 0xc2, 0x02, 0x3d, 0xd5, + 0x83, 0x1d, 0xfa, 0x42, 0xb7, 0x48, 0x1b, 0x31, 0xe3, 0x82, 0x90, 0x2d, 0x91, 0x59, 0xf9, 0x38, + 0x52, 0xe5, 0xdb, 0xc1, 0x4d, 0x3a, 0xe6, 0x9b, 0x6a, 0xbb, 0xea, 0xa4, 0x8d, 0x5e, 0xc4, 0x00, + /* d */ + 0x01, 0xb8, 0xec, 0x91, 0xc1, 0xdb, 0x63, 0xbd, 0x57, 0xb6, 0x26, 0x15, 0xb6, 0x3e, 0xa2, 0xdf, + 0x62, 0x8d, 0xa8, 0xbe, 0xe1, 0xf1, 0x39, 0xbd, 0x18, 0xd2, 0x6f, 0xd7, 0xda, 0xdc, 0x71, 0x30, + 0xf1, 0x21, 0x71, 0xa4, 0x08, 0x43, 0x46, 0xdf, 0x50, 0xbd, 0x3c, 0x60, 0x5b, 0x63, 0x35, 0xe3, + 0x37, 0x5b, 0x25, 0x17, 0x54, 0x5e, 0x68, 0x60, 0xb6, 0x49, 0xef, 0x6e, 0x09, 0xef, 0xda, 0x90, + 0x3e, 0xd4, 0x09, 0x33, 0x36, 0x57, 0x9a, 0x14, 0xbd, 0xf7, 0xb1, 0x98, 0x30, 0x42, 0x03, 0x84, + 0x61, 0xeb, 0x8e, 0x50, 0xdc, 0x6a, 0x93, 0x1b, 0x32, 0x51, 0xf9, 0xc6, 0xc2, 0x19, 0xb3, 0x5d, + 0xe2, 0xf8, 0xc5, 0x8f, 0x68, 0xaa, 0x1d, 0xdb, 0xd3, 0x7f, 0x8d, 0x98, 0x9c, 0x16, 0x8c, 0xc3, + 0xcd, 0xd9, 0xdb, 0x08, 0xe6, 0x36, 0x60, 0xb6, 0x36, 0xdc, 0x1d, 0x59, 0xb6, 0x5f, 0x01, 0x5e };
dwLen=84; @@ -2663,16 +2490,13 @@ static void test_import_export(void) result = CryptGetKeyParam(hPublicKey, KP_ALGID, (LPBYTE)&algID, &dwDataLen, 0); ok(result, "failed to get the KP_ALGID from the imported public key\n"); ok(algID == CALG_RSA_KEYX, "Expected CALG_RSA_KEYX, got %x\n", algID); - + dwVal = 0xdeadbeef; dwDataLen = sizeof(DWORD); result = CryptGetKeyParam(hPublicKey, KP_PERMISSIONS, (BYTE*)&dwVal, &dwDataLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_DECRYPT|CRYPT_ENCRYPT," " got %08lx\n", dwVal); result = CryptExportKey(hPublicKey, 0, PUBLICKEYBLOB, 0, emptyKey, &dwLen); ok(result, "failed to export the fresh imported public key\n"); ok(dwLen == 84, "Expected exported key to be 84 bytes long but got %ld bytes.\n",dwLen); @@ -2848,7 +2672,7 @@ static void test_import_hmac(void) *key_len = test_case->key_len; memcpy(key_bytes, test_case->key, *key_len); result = CryptImportKey(hProv, blob, size, 0, CRYPT_IPSEC_HMAC_KEY, &key); - ok(result || broken(GetLastError() == NTE_BAD_FLAGS /* Win2k */), "CryptImportKey failed on test case %ld: %08lx\n", i, GetLastError()); + ok(result, "CryptImportKey failed on test case %ld: %08lx\n", i, GetLastError()); if (result) { HCRYPTHASH hash; @@ -2924,31 +2748,23 @@ static void test_schannel_provider(void) };
result = CryptAcquireContextA(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT|CRYPT_NEWKEYSET); - if (!result) - { - win_skip("no PROV_RSA_SCHANNEL support\n"); - return; - } ok (result, "%08lx\n", GetLastError()); if (result) CryptReleaseContext(hProv, 0);
result = CryptAcquireContextA(&hProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT); ok (result, "%08lx\n", GetLastError()); - if (!result) return; - + /* To get deterministic results, we import the TLS1 master secret (which * is typically generated from a random generator). Therefore, we need * an RSA key. */ - dwLen = (DWORD)sizeof(abPlainPrivateKey); + dwLen = sizeof(abPlainPrivateKey); result = CryptImportKey(hProv, abPlainPrivateKey, dwLen, 0, 0, &hRSAKey); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
- dwLen = (DWORD)sizeof(abTLS1Master); + dwLen = sizeof(abTLS1Master); result = CryptImportKey(hProv, abTLS1Master, dwLen, hRSAKey, 0, &hMasterSecret); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
/* Deriving a hash from the master secret. This is due to the CryptoAPI architecture. * (Keys can only be derived from hashes, not from other keys.) @@ -2965,13 +2781,11 @@ static void test_schannel_provider(void) data_blob.pbData = abClientSecret; result = CryptSetKeyParam(hMasterSecret, KP_CLIENT_RANDOM, (BYTE*)&data_blob, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
data_blob.cbData = 33; data_blob.pbData = abServerSecret; result = CryptSetKeyParam(hMasterSecret, KP_SERVER_RANDOM, (BYTE*)&data_blob, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptCreateHash(hProv, CALG_SCHANNEL_MASTER_HASH, hMasterSecret, 0, &hMasterHash); ok (result || @@ -3003,7 +2817,6 @@ static void test_schannel_provider(void) saSChannelAlg.dwReserved = 0; result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
saSChannelAlg.dwUse = SCHANNEL_MAC_KEY; saSChannelAlg.Algid = CALG_MD5; @@ -3012,16 +2825,13 @@ static void test_schannel_provider(void) saSChannelAlg.dwReserved = 0; result = CryptSetKeyParam(hMasterSecret, KP_SCHANNEL_ALG, (PBYTE)&saSChannelAlg, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptCreateHash(hProv, CALG_SCHANNEL_MASTER_HASH, hMasterSecret, 0, &hMasterHash); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
/* Deriving the server write encryption key from the master hash */ result = CryptDeriveKey(hProv, CALG_SCHANNEL_ENC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteKey); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
/* Encrypting some data with the server write encryption key and checking the result. */ dwLen = 12; @@ -3031,46 +2841,39 @@ static void test_schannel_provider(void) /* Second test case: Test the TLS1 pseudo random number function. */ result = CryptCreateHash(hProv, CALG_TLS1PRF, hMasterSecret, 0, &hTLS1PRF); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
/* Set the label and seed parameters for the random number function */ data_blob.cbData = 36; data_blob.pbData = abHashedHandshakes; result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_SEED, (BYTE*)&data_blob, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
data_blob.cbData = 15; data_blob.pbData = abClientFinished; result = CryptSetHashParam(hTLS1PRF, HP_TLS1PRF_LABEL, (BYTE*)&data_blob, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
/* Generate some pseudo random bytes and check if they are correct. */ - dwLen = (DWORD)sizeof(abData); + dwLen = sizeof(abData); result = CryptGetHashParam(hTLS1PRF, HP_HASHVAL, abData, &dwLen, 0); - ok (result && (dwLen==(DWORD)sizeof(abData)) && !memcmp(abData, abPRF, sizeof(abData)), + ok (result && (dwLen==sizeof(abData)) && !memcmp(abData, abPRF, sizeof(abData)), "%08lx\n", GetLastError());
/* Third test case. Derive the server write mac key. Derive an HMAC object from this one. * Hash some data with the HMAC. Compare results. */ result = CryptDeriveKey(hProv, CALG_SCHANNEL_MAC_KEY, hMasterHash, CRYPT_SERVER, &hServerWriteMACKey); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptCreateHash(hProv, CALG_HMAC, hServerWriteMACKey, 0, &hHMAC); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
result = CryptSetHashParam(hHMAC, HP_HMAC_INFO, (PBYTE)&hmacInfo, 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
- result = CryptHashData(hHMAC, abData, (DWORD)sizeof(abData), 0); + result = CryptHashData(hHMAC, abData, sizeof(abData), 0); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
- dwLen = (DWORD)sizeof(abMD5Hash); + dwLen = sizeof(abMD5Hash); result = CryptGetHashParam(hHMAC, HP_HASHVAL, abMD5Hash, &dwLen, 0); ok (result && (dwLen == 16) && !memcmp(abMD5Hash, abMD5, 16), "%08lx\n", GetLastError());
@@ -3114,9 +2917,7 @@ static void test_rsa_round_trip(void) dataLen = strlen(test_string) + 1; result = CryptEncrypt(keyExchangeKey, 0, TRUE, 0, data, &dataLen, sizeof(data)); - ok(result || broken(GetLastError() == NTE_BAD_KEY /* Win9x/2000 */) || - broken(GetLastError() == NTE_PERM /* NT4 */), - "CryptEncrypt failed: %08lx\n", GetLastError()); + ok(result, "CryptEncrypt failed: %08lx\n", GetLastError()); /* export the key... */ result = CryptExportKey(keyExchangeKey, 0, PRIVATEKEYBLOB, 0, NULL, &keyLen); @@ -3125,20 +2926,19 @@ static void test_rsa_round_trip(void) result = CryptExportKey(keyExchangeKey, 0, PRIVATEKEYBLOB, 0, exportedKey, &keyLen); ok(result, "CryptExportKey failed: %08lx\n", GetLastError()); - /* destroy the key... */ + CryptDestroyKey(keyExchangeKey); CryptDestroyKey(signKey); - /* import the key again... */ + result = CryptImportKey(prov, exportedKey, keyLen, 0, 0, &keyExchangeKey); ok(result, "CryptImportKey failed: %08lx\n", GetLastError()); HeapFree(GetProcessHeap(), 0, exportedKey); + /* and decrypt the data encrypted with the original key with the imported * key. */ result = CryptDecrypt(keyExchangeKey, 0, TRUE, 0, data, &dataLen); - ok(result || broken(GetLastError() == NTE_BAD_KEY /* Win9x/2000 */) || - broken(GetLastError() == NTE_PERM /* NT4 */), - "CryptDecrypt failed: %08lx\n", GetLastError()); + ok(result, "CryptDecrypt failed: %08lx\n", GetLastError()); if (result) { ok(dataLen == sizeof(test_string), "unexpected size %ld\n", dataLen); @@ -3162,19 +2962,18 @@ static void test_enum_container(void) SetLastError(0xdeadbeef); result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, NULL, &dwBufferLen, CRYPT_FIRST); ok (result, "%08lx\n", GetLastError()); - ok (dwBufferLen == MAX_PATH + 1 || - broken(dwBufferLen != MAX_PATH + 1), /* Win9x, WinMe, NT4 */ + ok (dwBufferLen == MAX_PATH + 1, "Expected dwBufferLen to be (MAX_PATH + 1), it was : %ld\n", dwBufferLen);
/* If the result fits into abContainerName dwBufferLen is left untouched */ - dwBufferLen = (DWORD)sizeof(abContainerName); + dwBufferLen = sizeof(abContainerName); result = CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, CRYPT_FIRST); - ok (result && dwBufferLen == (DWORD)sizeof(abContainerName), "%08lx\n", GetLastError()); + ok (result && dwBufferLen == sizeof(abContainerName), "%08lx\n", GetLastError());
/* We only check, if the currently open 'winetest' container is among the enumerated. */ do { if (!strcmp((const char*)abContainerName, "winetest")) fFound = TRUE; - dwBufferLen = (DWORD)sizeof(abContainerName); + dwBufferLen = sizeof(abContainerName); } while (CryptGetProvParam(hProv, PP_ENUMCONTAINERS, abContainerName, &dwBufferLen, 0));
ok (fFound && GetLastError() == ERROR_NO_MORE_ITEMS, "%d, %08lx\n", fFound, GetLastError()); @@ -3208,7 +3007,7 @@ static void test_null_provider(void) HCRYPTKEY key; BOOL result; DWORD keySpec, dataLen,dwParam; - char szName[MAX_PATH]; + char szName[MAX_PATH], container[MAX_PATH];
result = CryptAcquireContextA(NULL, szContainer, NULL, 0, 0); ok(!result && GetLastError() == NTE_BAD_PROV_TYPE, @@ -3240,7 +3039,6 @@ static void test_null_provider(void) result = CryptAcquireContextA(&prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT); ok(result, "CryptAcquireContextA failed: %08lx\n", GetLastError()); - if (!result) return; dataLen = sizeof(keySpec); result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0); if (result) @@ -3283,7 +3081,7 @@ static void test_null_provider(void) result = CryptAcquireContextA(&prov, szContainer, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET); ok(result, "CryptAcquireContextA failed: %08lx\n", GetLastError()); - if (!result) return; + /* Test provider parameters getter */ dataLen = sizeof(dwParam); result = CryptGetProvParam(prov, PP_PROVTYPE, (LPBYTE)&dwParam, &dataLen, 0); @@ -3300,11 +3098,8 @@ static void test_null_provider(void) dataLen = sizeof(keySpec); SetLastError(0xdeadbeef); result = CryptGetProvParam(prov, PP_KEYSPEC, (LPBYTE)&keySpec, &dataLen, 0); - if (!result && GetLastError() == NTE_BAD_TYPE) - skip("PP_KEYSPEC is not supported (win9x or NT)\n"); - else - ok(result && keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE), - "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08lx\n", keySpec); + ok(result && keySpec == (AT_KEYEXCHANGE | AT_SIGNATURE), + "Expected AT_KEYEXCHANGE | AT_SIGNATURE, got %08lx\n", keySpec); /* PP_CONTAINER parameter */ dataLen = sizeof(szName); result = CryptGetProvParam(prov, PP_CONTAINER, (LPBYTE)szName, &dataLen, 0); @@ -3315,25 +3110,12 @@ static void test_null_provider(void) dataLen = sizeof(szName); SetLastError(0xdeadbeef); result = CryptGetProvParam(prov, PP_UNIQUE_CONTAINER, (LPBYTE)szName, &dataLen, 0); - if (!result && GetLastError() == NTE_BAD_TYPE) + ok(result, "failed getting PP_UNIQUE_CONTAINER : 0x%08lX\n", GetLastError()); + uniquecontainer(container); + todo_wine { - skip("PP_UNIQUE_CONTAINER is not supported (win9x or NT)\n"); - } - else - { - char container[MAX_PATH]; - - ok(result, "failed getting PP_UNIQUE_CONTAINER : 0x%08lX\n", GetLastError()); - uniquecontainer(container); - todo_wine - { - ok(dataLen == strlen(container)+1 || - broken(dataLen == strlen(szContainer)+1) /* WinME */, - "Expected a param length of 70, got %ld\n", dataLen); - ok(!strcmp(container, szName) || - broken(!strcmp(szName, szContainer)) /* WinME */, - "Wrong container name : %s\n", szName); - } + ok(dataLen == strlen(container) + 1, "Expected a param length of 70, got %ld\n", dataLen); + ok(!strcmp(container, szName), "Wrong container name : %s\n", szName); } result = CryptGetUserKey(prov, AT_KEYEXCHANGE, &key); ok(!result && GetLastError() == NTE_NO_KEY, @@ -3363,7 +3145,7 @@ static void test_null_provider(void) result = CryptAcquireContextA(&prov, szContainer, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET); ok(result, "CryptAcquireContextA failed: %08lx\n", GetLastError()); - if (!result) return; + result = CryptImportKey(prov, signBlob, sizeof(signBlob), 0, 0, &key); ok(result, "CryptImportKey failed: %08lx\n", GetLastError()); CryptDestroyKey(key); @@ -3467,17 +3249,13 @@ static void test_key_permissions(void)
result = CryptGetUserKey(hProv, AT_KEYEXCHANGE, &hKey1); ok (result, "%08lx\n", GetLastError()); - if (!result) return;
dwVal = 0xdeadbeef; dwLen = sizeof(DWORD); result = CryptGetKeyParam(hKey1, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwVal);
/* The key exchange key's public key may be exported.. */ result = CryptExportKey(hKey1, 0, PUBLICKEYBLOB, 0, NULL, &dwLen); @@ -3488,20 +3266,14 @@ static void test_key_permissions(void) /* Turning off the key's export permissions is "allowed".. */ dwVal &= ~CRYPT_EXPORT; result = CryptSetKeyParam(hKey1, KP_PERMISSIONS, (BYTE *)&dwVal, 0); - ok(result || - broken(!result && GetLastError() == NTE_BAD_DATA) || /* W2K */ - broken(!result && GetLastError() == NTE_BAD_FLAGS), /* Win9x/WinME/NT4 */ - "%08lx\n", GetLastError()); + ok(result, "%08lx\n", GetLastError()); /* but it has no effect. */ dwVal = 0xdeadbeef; dwLen = sizeof(DWORD); result = CryptGetKeyParam(hKey1, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwVal); /* Thus, changing the export flag of the key doesn't affect whether the key * may be exported. */ @@ -3518,11 +3290,8 @@ static void test_key_permissions(void) dwLen = sizeof(DWORD); result = CryptGetKeyParam(hKey2, KP_PERMISSIONS, (BYTE*)&dwVal, &dwLen, 0); ok(result, "%08lx\n", GetLastError()); - ok(dwVal == - (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT) || - broken(dwVal == 0xffffffff), /* Win9x/NT4 */ - "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT," - " got %08lx\n", dwVal); + ok(dwVal == (CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT), + "expected CRYPT_MAC|CRYPT_WRITE|CRYPT_READ|CRYPT_EXPORT|CRYPT_DECRYPT|CRYPT_ENCRYPT got %08lx\n", dwVal);
CryptDestroyKey(hKey2); CryptDestroyKey(hKey1); @@ -3566,11 +3335,11 @@ static void test_key_initialization(void) CRYPT_NEWKEYSET); ok(result, "CryptAcquireContextA failed: %08lx\n", GetLastError()); } - dwLen = (DWORD)sizeof(abPlainPrivateKey); + dwLen = sizeof(abPlainPrivateKey); result = CryptImportKey(prov1, abPlainPrivateKey, dwLen, 0, 0, &hKeyExchangeKey); ok(result, "CryptImportKey failed: %08lx\n", GetLastError());
- dwLen = (DWORD)sizeof(abSessionKey); + dwLen = sizeof(abSessionKey); result = CryptImportKey(prov1, abSessionKey, dwLen, hKeyExchangeKey, 0, &hSessionKey); ok(result, "CryptImportKey failed: %08lx\n", GetLastError());
@@ -3598,7 +3367,7 @@ static void test_key_derivation(const char *prov) BOOL result; unsigned char pbData[128], dvData[512]; DWORD i, j, len, mode; - struct _test + struct { ALG_ID crypt_algo, hash_algo; int blocklen, hashlen, chain_mode; @@ -3923,28 +3692,31 @@ static void test_key_derivation(const char *prov) /* 59 */ }, }; - /* Due to differences between encryption from <= 2000 and >= XP some tests need to be skipped */ int old_broken[ARRAY_SIZE(tests)]; memset(old_broken, 0, sizeof(old_broken)); old_broken[3] = old_broken[4] = old_broken[15] = old_broken[16] = 1; old_broken[27] = old_broken[28] = old_broken[39] = old_broken[40] = 1; + old_broken[48] = old_broken[49] = old_broken[50] = old_broken[51] = 1; + old_broken[52] = old_broken[53] = old_broken[54] = old_broken[55] = 1; + old_broken[56] = old_broken[57] = old_broken[58] = old_broken[59] = 1; uniquecontainer(NULL);
for (i=0; i < ARRAY_SIZE(tests); i++) { - if (win2k && old_broken[i]) continue; + if (old_broken[i]) continue;
for (j=0; j<sizeof(dvData); j++) dvData[j] = (unsigned char)j+i; SetLastError(0xdeadbeef); result = CryptCreateHash(hProv, tests[i].hash_algo, 0, 0, &hHash); + ok(result, "Test [%s %ld]: CryptCreateHash failed with error 0x%08lx\n", prov, i, GetLastError()); if (!result) { - /* rsaenh compiled without OpenSSL or not supported by provider */ + /* not supported by provider */ + trace("hash %x not supported\n", tests[i].hash_algo); ok(GetLastError() == NTE_BAD_ALGID, "Test [%s %ld]: Expected NTE_BAD_ALGID, got 0x%08lx\n", prov, i, GetLastError()); continue; } - ok(result, "Test [%s %ld]: CryptCreateHash failed with error 0x%08lx\n", prov, i, GetLastError()); result = CryptHashData(hHash, dvData, sizeof(dvData), 0); ok(result, "Test [%s %ld]: CryptHashData failed with error 0x%08lx\n", prov, i, GetLastError());
@@ -3959,9 +3731,7 @@ static void test_key_derivation(const char *prov) SetLastError(0xdeadbeef); result = CryptDeriveKey(hProv, tests[i].crypt_algo, hHash, 0, &hKey); /* the provider may not support the algorithm */ - if(!result && (GetLastError() == tests[i].errorkey - || GetLastError() == ERROR_INVALID_PARAMETER /* <= NT4*/)) - goto err; + if(!result && GetLastError() == tests[i].errorkey) goto err; ok(result, "Test [%s %ld]: CryptDeriveKey failed with error 0x%08lx\n", prov, i, GetLastError());
len = sizeof(mode);
-
Hans Leidekker -
Hans Leidekker (＠hans)