[2/2] bcrypt/tests: Add tests for SHA hashes.
Hans Leidekker
hans at codeweavers.com
Mon Jan 11 04:25:26 CST 2016
Signed-off-by: Hans Leidekker <hans at codeweavers.com>
---
dlls/bcrypt/tests/bcrypt.c | 352 ++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 349 insertions(+), 3 deletions(-)
diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c
index 9e659d6..c49bbc3 100644
--- a/dlls/bcrypt/tests/bcrypt.c
+++ b/dlls/bcrypt/tests/bcrypt.c
@@ -18,6 +18,7 @@
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
+#include <stdio.h>
#include <ntstatus.h>
#define WIN32_NO_STATUS
#include <windows.h>
@@ -25,9 +26,16 @@
#include "wine/test.h"
-static NTSTATUS (WINAPI *pBCryptGenRandom)(BCRYPT_ALG_HANDLE hAlgorithm, PUCHAR pbBuffer,
- ULONG cbBuffer, ULONG dwFlags);
-static NTSTATUS (WINAPI *pBCryptGetFipsAlgorithmMode)(BOOLEAN *enabled);
+static NTSTATUS (WINAPI *pBCryptCloseAlgorithmProvider)(BCRYPT_ALG_HANDLE, DWORD);
+static NTSTATUS (WINAPI *pBCryptCreateHash)(BCRYPT_ALG_HANDLE, BCRYPT_HASH_HANDLE *, UCHAR *,
+ ULONG, UCHAR *, ULONG, ULONG);
+static NTSTATUS (WINAPI *pBCryptDestroyHash)(BCRYPT_HASH_HANDLE);
+static NTSTATUS (WINAPI *pBCryptFinishHash)(BCRYPT_HASH_HANDLE, UCHAR *, ULONG, ULONG);
+static NTSTATUS (WINAPI *pBCryptHashData)(BCRYPT_HASH_HANDLE, UCHAR *, ULONG, ULONG);
+static NTSTATUS (WINAPI *pBCryptGenRandom)(BCRYPT_ALG_HANDLE, PUCHAR, ULONG, ULONG);
+static NTSTATUS (WINAPI *pBCryptGetFipsAlgorithmMode)(BOOLEAN *);
+static NTSTATUS (WINAPI *pBCryptGetProperty)(BCRYPT_HANDLE, LPCWSTR, PUCHAR, ULONG, ULONG *, ULONG);
+static NTSTATUS (WINAPI *pBCryptOpenAlgorithmProvider)(BCRYPT_ALG_HANDLE *, LPCWSTR, LPCWSTR, DWORD);
static BOOL Init(void)
{
@@ -38,8 +46,15 @@ static BOOL Init(void)
return FALSE;
}
+ pBCryptCloseAlgorithmProvider = (void *)GetProcAddress(hbcrypt, "BCryptCloseAlgorithmProvider");
+ pBCryptCreateHash = (void *)GetProcAddress(hbcrypt, "BCryptCreateHash");
+ pBCryptDestroyHash = (void *)GetProcAddress(hbcrypt, "BCryptDestroyHash");
+ pBCryptFinishHash = (void *)GetProcAddress(hbcrypt, "BCryptFinishHash");
+ pBCryptHashData = (void *)GetProcAddress(hbcrypt, "BCryptHashData");
pBCryptGenRandom = (void *)GetProcAddress(hbcrypt, "BCryptGenRandom");
pBCryptGetFipsAlgorithmMode = (void *)GetProcAddress(hbcrypt, "BCryptGetFipsAlgorithmMode");
+ pBCryptGetProperty = (void *)GetProcAddress(hbcrypt, "BCryptGetProperty");
+ pBCryptOpenAlgorithmProvider = (void *)GetProcAddress(hbcrypt, "BCryptOpenAlgorithmProvider");
return TRUE;
}
@@ -98,6 +113,333 @@ static void test_BCryptGetFipsAlgorithmMode(void)
ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got 0x%x\n", ret);
}
+static const char *format_hash(const UCHAR *bytes, ULONG size, char *buf)
+{
+ ULONG i;
+ for (i = 0; i < size; i++)
+ {
+ buf += sprintf(buf, "%02x", bytes[i]);
+ }
+ buf[i * 2] = 0;
+ return buf;
+}
+
+static void test_sha1(void)
+{
+ static const char expected[] = "961fa64958818f767707072755d7018dcd278e94";
+ BCRYPT_ALG_HANDLE alg;
+ BCRYPT_HASH_HANDLE hash;
+ UCHAR buf[512], sha1[20];
+ ULONG size, len;
+ char str[41];
+ NTSTATUS ret;
+
+ if (!pBCryptOpenAlgorithmProvider)
+ {
+ win_skip("BCryptOpenAlgorithmProvider is not available\n");
+ return;
+ }
+
+ alg = NULL;
+ ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(alg != NULL, "alg not set");
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
+ ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
+ ok(len == 0xdeadbeef, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len != 0xdeadbeef, "len not set\n");
+ ok(size == sizeof(len), "got %u\n", size);
+
+ hash = NULL;
+ len = sizeof(buf);
+ ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(hash != NULL, "hash not set\n");
+
+ ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(hash, BCRYPT_HASH_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len == 20, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ memset(sha1, 0, sizeof(sha1));
+ ret = pBCryptFinishHash(hash, sha1, sizeof(sha1), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ format_hash( sha1, sizeof(sha1), str );
+ ok(!strcmp(str, expected), "got %s\n", str);
+
+ ret = pBCryptDestroyHash(hash);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ ret = pBCryptCloseAlgorithmProvider(alg, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
+static void test_sha256(void)
+{
+ static const char expected[] =
+ "ceb73749c899693706ede1e30c9929b3fd5dd926163831c2fb8bd41e6efb1126";
+ BCRYPT_ALG_HANDLE alg;
+ BCRYPT_HASH_HANDLE hash;
+ UCHAR buf[512], sha256[32];
+ ULONG size, len;
+ char str[65];
+ NTSTATUS ret;
+
+ if (!pBCryptOpenAlgorithmProvider)
+ {
+ win_skip("BCryptOpenAlgorithmProvider is not available\n");
+ return;
+ }
+
+ alg = NULL;
+ ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(alg != NULL, "alg not set");
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
+ ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
+ ok(len == 0xdeadbeef, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len != 0xdeadbeef, "len not set\n");
+ ok(size == sizeof(len), "got %u\n", size);
+
+ hash = NULL;
+ len = sizeof(buf);
+ ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(hash != NULL, "hash not set\n");
+
+ ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(hash, BCRYPT_HASH_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len == 32, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ memset(sha256, 0, sizeof(sha256));
+ ret = pBCryptFinishHash(hash, sha256, sizeof(sha256), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ format_hash( sha256, sizeof(sha256), str );
+ ok(!strcmp(str, expected), "got %s\n", str);
+
+ ret = pBCryptDestroyHash(hash);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ ret = pBCryptCloseAlgorithmProvider(alg, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
+static void test_sha384(void)
+{
+ static const char expected[] =
+ "62b21e90c9022b101671ba1f808f8631a8149f0f12904055839a35c1ca78ae5363eed1e743a692d70e0504b0cfd12ef9";
+ BCRYPT_ALG_HANDLE alg;
+ BCRYPT_HASH_HANDLE hash;
+ UCHAR buf[512], sha384[48];
+ ULONG size, len;
+ char str[97];
+ NTSTATUS ret;
+
+ if (!pBCryptOpenAlgorithmProvider)
+ {
+ win_skip("BCryptOpenAlgorithmProvider is not available\n");
+ return;
+ }
+
+ alg = NULL;
+ ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA384_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(alg != NULL, "alg not set");
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
+ ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
+ ok(len == 0xdeadbeef, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len != 0xdeadbeef, "len not set\n");
+ ok(size == sizeof(len), "got %u\n", size);
+
+ hash = NULL;
+ len = sizeof(buf);
+ ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(hash != NULL, "hash not set\n");
+
+ ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(hash, BCRYPT_HASH_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len == 48, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ memset(sha384, 0, sizeof(sha384));
+ ret = pBCryptFinishHash(hash, sha384, sizeof(sha384), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ format_hash( sha384, sizeof(sha384), str );
+ ok(!strcmp(str, expected), "got %s\n", str);
+
+ ret = pBCryptDestroyHash(hash);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ ret = pBCryptCloseAlgorithmProvider(alg, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
+static void test_sha512(void)
+{
+ static const char expected[] =
+ "d55ced17163bf5386f2cd9ff21d6fd7fe576a915065c24744d09cfae4ec84ee1e"
+ "f6ef11bfbc5acce3639bab725b50a1fe2c204f8c820d6d7db0df0ecbc49c5ca";
+ BCRYPT_ALG_HANDLE alg;
+ BCRYPT_HASH_HANDLE hash;
+ UCHAR buf[512], sha512[64];
+ ULONG size, len;
+ char str[129];
+ NTSTATUS ret;
+
+ if (!pBCryptOpenAlgorithmProvider)
+ {
+ win_skip("BCryptOpenAlgorithmProvider is not available\n");
+ return;
+ }
+
+ alg = NULL;
+ ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA512_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(alg != NULL, "alg not set");
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
+ ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
+ ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
+ ok(len == 0xdeadbeef, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len != 0xdeadbeef, "len not set\n");
+ ok(size == sizeof(len), "got %u\n", size);
+
+ hash = NULL;
+ len = sizeof(buf);
+ ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(hash != NULL, "hash not set\n");
+
+ ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ len = size = 0xdeadbeef;
+ ret = pBCryptGetProperty(hash, BCRYPT_HASH_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ ok(len == 64, "got %u\n", len);
+ ok(size == sizeof(len), "got %u\n", size);
+
+ memset(sha512, 0, sizeof(sha512));
+ ret = pBCryptFinishHash(hash, sha512, sizeof(sha512), 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+ format_hash( sha512, sizeof(sha512), str );
+ ok(!strcmp(str, expected), "got %s\n", str);
+
+ ret = pBCryptDestroyHash(hash);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+ ret = pBCryptCloseAlgorithmProvider(alg, 0);
+ ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
START_TEST(bcrypt)
{
if (!Init())
@@ -105,4 +447,8 @@ START_TEST(bcrypt)
test_BCryptGenRandom();
test_BCryptGetFipsAlgorithmMode();
+ test_sha1();
+ test_sha256();
+ test_sha384();
+ test_sha512();
}
--
2.6.4
More information about the wine-patches
mailing list