[BCRYPT_WINETEST] Sync with Wine Staging 1.9.23. CORE-12409

svn path=/trunk/; revision=73263

diff --git a/rostests/winetests/bcrypt/CMakeLists.txt b/rostests/winetests/bcrypt/CMakeLists.txt
index 7619b9f..6f1dc40 100644 (file)
--- a/rostests/winetests/bcrypt/CMakeLists.txt
+++ b/rostests/winetests/bcrypt/CMakeLists.txt
@@ -1,5 +1,6 @@
 
+remove_definitions(-D_WIN32_WINNT=0x502)
 add_executable(bcrypt_winetest bcrypt.c testlist.c)
 set_module_type(bcrypt_winetest win32cui)
-add_importlibs(bcrypt_winetest bcrypt user32 msvcrt kernel32)
+add_importlibs(bcrypt_winetest bcrypt advapi32 user32 msvcrt kernel32)
 add_cd_file(TARGET bcrypt_winetest DESTINATION reactos/bin FOR all)

diff --git a/rostests/winetests/bcrypt/bcrypt.c b/rostests/winetests/bcrypt/bcrypt.c
index 2613a07..5cdb065 100644 (file)
--- a/rostests/winetests/bcrypt/bcrypt.c
+++ b/rostests/winetests/bcrypt/bcrypt.c
@@ -26,6 +26,9 @@
 
 #include "wine/test.h"
 
+static NTSTATUS (WINAPI *pBCryptHash)( BCRYPT_ALG_HANDLE algorithm, UCHAR *secret, ULONG secretlen,
+                                     UCHAR *input, ULONG inputlen, UCHAR *output, ULONG outputlen );
+
 static void test_BCryptGenRandom(void)
 {
     NTSTATUS ret;
@@ -58,11 +61,45 @@ static void test_BCryptGenRandom(void)
 
 static void test_BCryptGetFipsAlgorithmMode(void)
 {
-    NTSTATUS ret;
+    static const WCHAR policyKeyVistaW[] = {
+        'S','y','s','t','e','m','\\',
+        'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
+        'C','o','n','t','r','o','l','\\',
+        'L','s','a','\\',
+        'F','I','P','S','A','l','g','o','r','i','t','h','m','P','o','l','i','c','y',0};
+    static const WCHAR policyValueVistaW[] = {'E','n','a','b','l','e','d',0};
+    static const WCHAR policyKeyXPW[] = {
+        'S','y','s','t','e','m','\\',
+        'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
+        'C','o','n','t','r','o','l','\\',
+        'L','s','a',0};
+    static const WCHAR policyValueXPW[] = {
+        'F','I','P','S','A','l','g','o','r','i','t','h','m','P','o','l','i','c','y',0};
+    BOOLEAN expected;
     BOOLEAN enabled;
+    DWORD value, count[2] = {sizeof(value), sizeof(value)};
+    NTSTATUS ret;
+
+    if (!RegGetValueW(HKEY_LOCAL_MACHINE, policyKeyVistaW, policyValueVistaW,
+        RRF_RT_REG_DWORD, NULL, &value, &count[0]))
+    {
+        expected = !!value;
+    }
+    else if (!RegGetValueW(HKEY_LOCAL_MACHINE, policyKeyXPW, policyValueXPW,
+             RRF_RT_REG_DWORD, NULL, &value, &count[1]))
+    {
+        expected = !!value;
+    }
+    else
+    {
+        expected = FALSE;
+todo_wine
+        ok(0, "Neither XP or Vista key is present\n");
+    }
 
     ret = BCryptGetFipsAlgorithmMode(&enabled);
     ok(ret == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got 0x%x\n", ret);
+    ok(enabled == expected, "expected result %d, got %d\n", expected, enabled);
 
     ret = BCryptGetFipsAlgorithmMode(NULL);
     ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got 0x%x\n", ret);
@@ -115,9 +152,10 @@ static void _test_alg_name(unsigned line, void *handle, const char *exname)
 static void test_sha1(void)
 {
     static const char expected[] = "961fa64958818f767707072755d7018dcd278e94";
+    static const char expected_hmac[] = "2472cf65d0e090618d769d3e46f0d9446cf212da";
     BCRYPT_ALG_HANDLE alg;
     BCRYPT_HASH_HANDLE hash;
-    UCHAR buf[512], sha1[20];
+    UCHAR buf[512], buf_hmac[1024], sha1[20], sha1_hmac[20];
     ULONG size, len;
     char str[41];
     NTSTATUS ret;
@@ -165,6 +203,9 @@ static void test_sha1(void)
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
     ok(hash != NULL, "hash not set\n");
 
+    ret = BCryptHashData(hash, NULL, 0, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
     ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 
@@ -182,15 +223,46 @@ static void test_sha1(void)
 
     ret = BCryptCloseAlgorithmProvider(alg, 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    hash = NULL;
+    len = sizeof(buf_hmac);
+    ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(hash != NULL, "hash not set\n");
+
+    ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    test_hash_length(hash, 20);
+    test_alg_name(hash, "SHA1");
+
+    memset(sha1_hmac, 0, sizeof(sha1_hmac));
+    ret = BCryptFinishHash(hash, sha1_hmac, sizeof(sha1_hmac), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( sha1_hmac, sizeof(sha1_hmac), str );
+    ok(!strcmp(str, expected_hmac), "got %s\n", str);
+
+    ret = BCryptDestroyHash(hash);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 }
 
 static void test_sha256(void)
 {
     static const char expected[] =
         "ceb73749c899693706ede1e30c9929b3fd5dd926163831c2fb8bd41e6efb1126";
+    static const char expected_hmac[] =
+        "34c1aa473a4468a91d06e7cdbc75bc4f93b830ccfc2a47ffd74e8e6ed29e4c72";
     BCRYPT_ALG_HANDLE alg;
     BCRYPT_HASH_HANDLE hash;
-    UCHAR buf[512], sha256[32];
+    UCHAR buf[512], buf_hmac[1024], sha256[32], sha256_hmac[32];
     ULONG size, len;
     char str[65];
     NTSTATUS ret;
@@ -238,6 +310,9 @@ static void test_sha256(void)
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
     ok(hash != NULL, "hash not set\n");
 
+    ret = BCryptHashData(hash, NULL, 0, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
     ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 
@@ -255,15 +330,46 @@ static void test_sha256(void)
 
     ret = BCryptCloseAlgorithmProvider(alg, 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    hash = NULL;
+    len = sizeof(buf_hmac);
+    ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(hash != NULL, "hash not set\n");
+
+    ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    test_hash_length(hash, 32);
+    test_alg_name(hash, "SHA256");
+
+    memset(sha256_hmac, 0, sizeof(sha256_hmac));
+    ret = BCryptFinishHash(hash, sha256_hmac, sizeof(sha256_hmac), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( sha256_hmac, sizeof(sha256_hmac), str );
+    ok(!strcmp(str, expected_hmac), "got %s\n", str);
+
+    ret = BCryptDestroyHash(hash);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 }
 
 static void test_sha384(void)
 {
     static const char expected[] =
         "62b21e90c9022b101671ba1f808f8631a8149f0f12904055839a35c1ca78ae5363eed1e743a692d70e0504b0cfd12ef9";
+    static const char expected_hmac[] =
+        "4b3e6d6ff2da121790ab7e7b9247583e3a7eed2db5bd4dabc680303b1608f37dfdc836d96a704c03283bc05b4f6c5eb8";
     BCRYPT_ALG_HANDLE alg;
     BCRYPT_HASH_HANDLE hash;
-    UCHAR buf[512], sha384[48];
+    UCHAR buf[512], buf_hmac[1024], sha384[48], sha384_hmac[48];
     ULONG size, len;
     char str[97];
     NTSTATUS ret;
@@ -311,6 +417,9 @@ static void test_sha384(void)
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
     ok(hash != NULL, "hash not set\n");
 
+    ret = BCryptHashData(hash, NULL, 0, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
     ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 
@@ -328,6 +437,35 @@ static void test_sha384(void)
 
     ret = BCryptCloseAlgorithmProvider(alg, 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA384_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    hash = NULL;
+    len = sizeof(buf_hmac);
+    ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(hash != NULL, "hash not set\n");
+
+    ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    test_hash_length(hash, 48);
+    test_alg_name(hash, "SHA384");
+
+    memset(sha384_hmac, 0, sizeof(sha384_hmac));
+    ret = BCryptFinishHash(hash, sha384_hmac, sizeof(sha384_hmac), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( sha384_hmac, sizeof(sha384_hmac), str );
+    ok(!strcmp(str, expected_hmac), "got %s\n", str);
+
+    ret = BCryptDestroyHash(hash);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 }
 
 static void test_sha512(void)
@@ -335,9 +473,12 @@ static void test_sha512(void)
     static const char expected[] =
         "d55ced17163bf5386f2cd9ff21d6fd7fe576a915065c24744d09cfae4ec84ee1e"
         "f6ef11bfbc5acce3639bab725b50a1fe2c204f8c820d6d7db0df0ecbc49c5ca";
+    static const char expected_hmac[] =
+        "415fb6b10018ca03b38a1b1399c42ac0be5e8aceddb9a73103f5e543bf2d888f2"
+        "eecf91373941f9315dd730a77937fa92444450fbece86f409d9cb5ec48c6513";
     BCRYPT_ALG_HANDLE alg;
     BCRYPT_HASH_HANDLE hash;
-    UCHAR buf[512], sha512[64];
+    UCHAR buf[512], buf_hmac[1024], sha512[64], sha512_hmac[64];
     ULONG size, len;
     char str[129];
     NTSTATUS ret;
@@ -385,6 +526,9 @@ static void test_sha512(void)
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
     ok(hash != NULL, "hash not set\n");
 
+    ret = BCryptHashData(hash, NULL, 0, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
     ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
 
@@ -402,14 +546,235 @@ static void test_sha512(void)
 
     ret = BCryptCloseAlgorithmProvider(alg, 0);
     ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA512_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    hash = NULL;
+    len = sizeof(buf_hmac);
+    ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(hash != NULL, "hash not set\n");
+
+    ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    test_hash_length(hash, 64);
+    test_alg_name(hash, "SHA512");
+
+    memset(sha512_hmac, 0, sizeof(sha512_hmac));
+    ret = BCryptFinishHash(hash, sha512_hmac, sizeof(sha512_hmac), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( sha512_hmac, sizeof(sha512_hmac), str );
+    ok(!strcmp(str, expected_hmac), "got %s\n", str);
+
+    ret = BCryptDestroyHash(hash);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
 }
 
+static void test_md5(void)
+{
+    static const char expected[] =
+        "e2a3e68d23ce348b8f68b3079de3d4c9";
+    static const char expected_hmac[] =
+        "7bda029b93fa8d817fcc9e13d6bdf092";
+    BCRYPT_ALG_HANDLE alg;
+    BCRYPT_HASH_HANDLE hash;
+    UCHAR buf[512], buf_hmac[1024], md5[16], md5_hmac[16];
+    ULONG size, len;
+    char str[65];
+    NTSTATUS ret;
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    len = size = 0xdeadbeef;
+    ret = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
+    ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
+
+    len = size = 0xdeadbeef;
+    ret = BCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
+    ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+    len = size = 0xdeadbeef;
+    ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
+    ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
+
+    len = size = 0xdeadbeef;
+    ret = BCryptGetProperty(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 = BCryptGetProperty(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 = BCryptGetProperty(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);
+
+    test_hash_length(alg, 16);
+    test_alg_name(alg, "MD5");
+
+    hash = NULL;
+    len = sizeof(buf);
+    ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(hash != NULL, "hash not set\n");
+
+    ret = BCryptHashData(hash, NULL, 0, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    test_hash_length(hash, 16);
+    test_alg_name(hash, "MD5");
+
+    memset(md5, 0, sizeof(md5));
+    ret = BCryptFinishHash(hash, md5, sizeof(md5), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( md5, sizeof(md5), str );
+    ok(!strcmp(str, expected), "got %s\n", str);
+
+    ret = BCryptDestroyHash(hash);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    hash = NULL;
+    len = sizeof(buf_hmac);
+    ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(hash != NULL, "hash not set\n");
+
+    ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    test_hash_length(hash, 16);
+    test_alg_name(hash, "MD5");
+
+    memset(md5_hmac, 0, sizeof(md5_hmac));
+    ret = BCryptFinishHash(hash, md5_hmac, sizeof(md5_hmac), 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( md5_hmac, sizeof(md5_hmac), str );
+    ok(!strcmp(str, expected_hmac), "got %s\n", str);
+
+    ret = BCryptDestroyHash(hash);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
+static void test_BcryptHash(void)
+{
+    static const char expected[] =
+        "e2a3e68d23ce348b8f68b3079de3d4c9";
+    static const char expected_hmac[] =
+        "7bda029b93fa8d817fcc9e13d6bdf092";
+    BCRYPT_ALG_HANDLE alg;
+    UCHAR md5[16], md5_hmac[16];
+    char str[65];
+    NTSTATUS ret;
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    test_hash_length(alg, 16);
+    test_alg_name(alg, "MD5");
+
+    memset(md5, 0, sizeof(md5));
+    ret = pBCryptHash(alg, NULL, 0, (UCHAR *)"test", sizeof("test"), md5, sizeof(md5));
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( md5, sizeof(md5), str );
+    ok(!strcmp(str, expected), "got %s\n", str);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+
+    alg = NULL;
+    memset(md5_hmac, 0, sizeof(md5_hmac));
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    ret = pBCryptHash(alg, (UCHAR *)"key", sizeof("key"), (UCHAR *)"test", sizeof("test"), md5_hmac, sizeof(md5_hmac));
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    format_hash( md5_hmac, sizeof(md5_hmac), str );
+    ok(!strcmp(str, expected_hmac), "got %s\n", str);
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
+static void test_rng(void)
+{
+    BCRYPT_ALG_HANDLE alg;
+    ULONG size, len;
+    UCHAR buf[16];
+    NTSTATUS ret;
+
+    alg = NULL;
+    ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(alg != NULL, "alg not set\n");
+
+    len = size = 0xdeadbeef;
+    ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
+    ok(ret == STATUS_NOT_SUPPORTED, "got %08x\n", ret);
+
+    test_alg_name(alg, "RNG");
+
+    memset(buf, 0, 16);
+    ret = BCryptGenRandom(alg, buf, 8, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+    ok(memcmp(buf, buf + 8, 8), "got zeroes\n");
+
+    ret = BCryptCloseAlgorithmProvider(alg, 0);
+    ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
+}
+
+
 START_TEST(bcrypt)
 {
+    HMODULE module;
+
+    module = GetModuleHandleA( "bcrypt.dll" );
+
     test_BCryptGenRandom();
     test_BCryptGetFipsAlgorithmMode();
     test_sha1();
     test_sha256();
     test_sha384();
     test_sha512();
+    test_md5();
+    test_rng();
+
+    pBCryptHash = (void *)GetProcAddress( module, "BCryptHash" );
+
+    if (pBCryptHash)
+        test_BcryptHash();
+    else
+        win_skip("BCryptHash is not available\n");
 }