ReactOS 0.4.15-dev-8145-ga541a46
bcrypt.c File Reference
#include <stdio.h>
#include <ntstatus.h>
#include <windows.h>
#include <bcrypt.h>
#include "wine/test.h"
Include dependency graph for bcrypt.c:

Go to the source code of this file.

Macros

#define WIN32_NO_STATUS
 
#define test_hash_length(a, b)   _test_hash_length(__LINE__,a,b)
 
#define test_alg_name(a, b)   _test_alg_name(__LINE__,a,b)
 

Functions

static NTSTATUS (WINAPI *pBCryptOpenAlgorithmProvider)(BCRYPT_ALG_HANDLE *
 
static void test_BCryptGenRandom (void)
 
static void test_BCryptGetFipsAlgorithmMode (void)
 
static void format_hash (const UCHAR *bytes, ULONG size, char *buf)
 
static int strcmp_wa (const WCHAR *strw, const char *stra)
 
static void _test_hash_length (unsigned line, void *handle, ULONG exlen)
 
static void _test_alg_name (unsigned line, void *handle, const char *exname)
 
static void test_sha1 (void)
 
static void test_sha256 (void)
 
static void test_sha384 (void)
 
static void test_sha512 (void)
 
static void test_md5 (void)
 
static void test_BcryptHash (void)
 
static void test_rng (void)
 
 START_TEST (bcrypt)
 

Variables

static LPCWSTR
 
static ULONG
 
static BCRYPT_HASH_HANDLE PUCHAR
 

Macro Definition Documentation

◆ test_alg_name

#define test_alg_name (   a,
  b 
)    _test_alg_name(__LINE__,a,b)

Definition at line 148 of file bcrypt.c.

◆ test_hash_length

#define test_hash_length (   a,
  b 
)    _test_hash_length(__LINE__,a,b)

Definition at line 136 of file bcrypt.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 23 of file bcrypt.c.

Function Documentation

◆ _test_alg_name()

static void _test_alg_name ( unsigned  line,
void handle,
const char exname 
)
static

Definition at line 149 of file bcrypt.c.

150{
151 ULONG size = 0xdeadbeef;
152 UCHAR buf[256];
153 const WCHAR *name = (const WCHAR*)buf;
155
156 status = pBCryptGetProperty(handle, BCRYPT_ALGORITHM_NAME, buf, sizeof(buf), &size, 0);
157 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %08x\n", status);
158 ok_(__FILE__,line)(size == (strlen(exname)+1)*sizeof(WCHAR), "got %u\n", size);
159 ok_(__FILE__,line)(!strcmp_wa(name, exname), "alg name = %s, expected %s\n", wine_dbgstr_w(name), exname);
160}
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define ok_(x1, x2)
Definition: atltest.h:61
LONG NTSTATUS
Definition: precomp.h:26
static int strcmp_wa(const WCHAR *strw, const char *stra)
Definition: bcrypt.c:129
#define BCRYPT_ALGORITHM_NAME
Definition: bcrypt.h:43
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define wine_dbgstr_w
Definition: kernel32.h:34
#define STATUS_SUCCESS
Definition: shellext.h:65
Definition: parser.c:49
Definition: name.c:39
Definition: ps.c:97
uint32_t ULONG
Definition: typedefs.h:59
unsigned char UCHAR
Definition: xmlstorage.h:181
__wchar_t WCHAR
Definition: xmlstorage.h:180

◆ _test_hash_length()

static void _test_hash_length ( unsigned  line,
void handle,
ULONG  exlen 
)
static

Definition at line 137 of file bcrypt.c.

138{
139 ULONG len = 0xdeadbeef, size = 0xdeadbeef;
141
142 status = pBCryptGetProperty(handle, BCRYPT_HASH_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
143 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %08x\n", status);
144 ok_(__FILE__,line)(size == sizeof(len), "got %u\n", size);
145 ok_(__FILE__,line)(len == exlen, "len = %u, expected %u\n", len, exlen);
146}
#define BCRYPT_HASH_LENGTH
Definition: bcrypt.h:50
GLenum GLsizei len
Definition: glext.h:6722

◆ format_hash()

static void format_hash ( const UCHAR bytes,
ULONG  size,
char buf 
)
static

Definition at line 118 of file bcrypt.c.

119{
120 ULONG i;
121 buf[0] = '\0';
122 for (i = 0; i < size; i++)
123 {
124 sprintf(buf + i * 2, "%02x", bytes[i]);
125 }
126 return;
127}
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define sprintf(buf, format,...)
Definition: sprintf.c:55

Referenced by test_BcryptHash(), test_md5(), test_sha1(), test_sha256(), test_sha384(), and test_sha512().

◆ NTSTATUS()

static NTSTATUS ( WINAPI pBCryptOpenAlgorithmProvider)
static

◆ START_TEST()

START_TEST ( bcrypt  )

Definition at line 768 of file bcrypt.c.

769{
771
772 module = LoadLibraryA("bcrypt.dll");
773 if (!module)
774 {
775 win_skip("bcrypt.dll not found\n");
776 return;
777 }
778
779 pBCryptOpenAlgorithmProvider = (void *)GetProcAddress(module, "BCryptOpenAlgorithmProvider");
780 pBCryptCloseAlgorithmProvider = (void *)GetProcAddress(module, "BCryptCloseAlgorithmProvider");
781 pBCryptGetFipsAlgorithmMode = (void *)GetProcAddress(module, "BCryptGetFipsAlgorithmMode");
782 pBCryptCreateHash = (void *)GetProcAddress(module, "BCryptCreateHash");
783 pBCryptHash = (void *)GetProcAddress(module, "BCryptHash");
784 pBCryptHashData = (void *)GetProcAddress(module, "BCryptHashData");
785 pBCryptFinishHash = (void *)GetProcAddress(module, "BCryptFinishHash");
786 pBCryptDestroyHash = (void *)GetProcAddress(module, "BCryptDestroyHash");
787 pBCryptGenRandom = (void *)GetProcAddress(module, "BCryptGenRandom");
788 pBCryptGetProperty = (void *)GetProcAddress(module, "BCryptGetProperty");
789
792 test_sha1();
793 test_sha256();
794 test_sha384();
795 test_sha512();
796 test_md5();
797 test_rng();
798
799 if (pBCryptHash) /* >= Win 10 */
801 else
802 win_skip("BCryptHash is not available\n");
803
805}
static void test_sha512(void)
Definition: bcrypt.c:481
static void test_sha256(void)
Definition: bcrypt.c:267
static void test_BCryptGenRandom(void)
Definition: bcrypt.c:40
static void test_BcryptHash(void)
Definition: bcrypt.c:698
static void test_BCryptGetFipsAlgorithmMode(void)
Definition: bcrypt.c:70
static void test_md5(void)
Definition: bcrypt.c:591
static void test_sha1(void)
Definition: bcrypt.c:162
static void test_rng(void)
Definition: bcrypt.c:741
static void test_sha384(void)
Definition: bcrypt.c:374
#define GetProcAddress(x, y)
Definition: compat.h:753
#define FreeLibrary(x)
Definition: compat.h:748
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
#define win_skip
Definition: test.h:163

◆ strcmp_wa()

static int strcmp_wa ( const WCHAR strw,
const char stra 
)
static

Definition at line 129 of file bcrypt.c.

130{
131 WCHAR buf[512];
132 MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, sizeof(buf)/sizeof(buf[0]));
133 return lstrcmpW(strw, buf);
134}
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4242
static const char * strw(LPCWSTR x)
Definition: actctx.c:49

Referenced by _test_alg_name().

◆ test_BCryptGenRandom()

static void test_BCryptGenRandom ( void  )
static

Definition at line 40 of file bcrypt.c.

41{
43 UCHAR buffer[256];
44
45 ret = pBCryptGenRandom(NULL, NULL, 0, 0);
46 ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got 0x%x\n", ret);
47 ret = pBCryptGenRandom(NULL, buffer, 0, 0);
48 ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got 0x%x\n", ret);
49 ret = pBCryptGenRandom(NULL, buffer, sizeof(buffer), 0);
50 ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got 0x%x\n", ret);
51 ret = pBCryptGenRandom(NULL, buffer, sizeof(buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
52 ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
53 ret = pBCryptGenRandom(NULL, buffer, sizeof(buffer),
55 ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
56 ret = pBCryptGenRandom(NULL, NULL, sizeof(buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
57 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got 0x%x\n", ret);
58
59 /* Zero sized buffer should work too */
60 ret = pBCryptGenRandom(NULL, buffer, 0, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
61 ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
62
63 /* Test random number generation - It's impossible for a sane RNG to return 8 zeros */
64 memset(buffer, 0, 16);
65 ret = pBCryptGenRandom(NULL, buffer, 8, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
66 ok(ret == STATUS_SUCCESS, "Expected success, got 0x%x\n", ret);
67 ok(memcmp(buffer, buffer + 8, 8), "Expected a random number, got 0\n");
68}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define ok(value,...)
Definition: atltest.h:57
#define BCRYPT_RNG_USE_ENTROPY_IN_BUFFER
Definition: bcrypt.h:170
#define BCRYPT_USE_SYSTEM_PREFERRED_RNG
Definition: bcrypt.h:171
#define NULL
Definition: types.h:112
GLuint buffer
Definition: glext.h:5915
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define memset(x, y, z)
Definition: compat.h:39
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
int ret

Referenced by START_TEST().

◆ test_BCryptGetFipsAlgorithmMode()

static void test_BCryptGetFipsAlgorithmMode ( void  )
static

Definition at line 70 of file bcrypt.c.

71{
72 static const WCHAR policyKeyVistaW[] = {
73 'S','y','s','t','e','m','\\',
74 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
75 'C','o','n','t','r','o','l','\\',
76 'L','s','a','\\',
77 'F','I','P','S','A','l','g','o','r','i','t','h','m','P','o','l','i','c','y',0};
78 static const WCHAR policyValueVistaW[] = {'E','n','a','b','l','e','d',0};
79 static const WCHAR policyKeyXPW[] = {
80 'S','y','s','t','e','m','\\',
81 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
82 'C','o','n','t','r','o','l','\\',
83 'L','s','a',0};
84 static const WCHAR policyValueXPW[] = {
85 'F','I','P','S','A','l','g','o','r','i','t','h','m','P','o','l','i','c','y',0};
86 HKEY hkey = NULL;
89 DWORD value, count[2] = {sizeof(value), sizeof(value)};
91
92 if (RegOpenKeyW(HKEY_LOCAL_MACHINE, policyKeyVistaW, &hkey) == ERROR_SUCCESS &&
93 RegQueryValueExW(hkey, policyValueVistaW, NULL, NULL, (void *)&value, &count[0]) == ERROR_SUCCESS)
94 {
95 expected = !!value;
96 }
97 else if (RegOpenKeyW(HKEY_LOCAL_MACHINE, policyKeyXPW, &hkey) == ERROR_SUCCESS &&
98 RegQueryValueExW(hkey, policyValueXPW, NULL, NULL, (void *)&value, &count[0]) == ERROR_SUCCESS)
99 {
100 expected = !!value;
101 }
102 else
103 {
104 expected = FALSE;
106 ok(0, "Neither XP or Vista key is present\n");
107 }
108 RegCloseKey(hkey);
109
110 ret = pBCryptGetFipsAlgorithmMode(&enabled);
111 ok(ret == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got 0x%x\n", ret);
112 ok(enabled == expected, "expected result %d, got %d\n", expected, enabled);
113
114 ret = pBCryptGetFipsAlgorithmMode(NULL);
115 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got 0x%x\n", ret);
116}
unsigned char BOOLEAN
#define RegCloseKey(hKey)
Definition: registry.h:49
#define ERROR_SUCCESS
Definition: deptool.c:10
#define FALSE
Definition: types.h:117
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3268
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
BOOL expected
Definition: store.c:2063
#define todo_wine
Definition: custom.c:79
Definition: pdh_main.c:94
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by START_TEST().

◆ test_BcryptHash()

static void test_BcryptHash ( void  )
static

Definition at line 698 of file bcrypt.c.

699{
700 static const char expected[] =
701 "e2a3e68d23ce348b8f68b3079de3d4c9";
702 static const char expected_hmac[] =
703 "7bda029b93fa8d817fcc9e13d6bdf092";
705 UCHAR md5[16], md5_hmac[16];
706 char str[65];
708
709 alg = NULL;
710 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
711 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
712 ok(alg != NULL, "alg not set\n");
713
714 test_hash_length(alg, 16);
715 test_alg_name(alg, "MD5");
716
717 memset(md5, 0, sizeof(md5));
718 ret = pBCryptHash(alg, NULL, 0, (UCHAR *)"test", sizeof("test"), md5, sizeof(md5));
719 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
720 format_hash( md5, sizeof(md5), str );
721 ok(!strcmp(str, expected), "got %s\n", str);
722
723 ret = pBCryptCloseAlgorithmProvider(alg, 0);
724 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
725
726 alg = NULL;
727 memset(md5_hmac, 0, sizeof(md5_hmac));
728 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
729 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
730 ok(alg != NULL, "alg not set\n");
731
732 ret = pBCryptHash(alg, (UCHAR *)"key", sizeof("key"), (UCHAR *)"test", sizeof("test"), md5_hmac, sizeof(md5_hmac));
733 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
734 format_hash( md5_hmac, sizeof(md5_hmac), str );
735 ok(!strcmp(str, expected_hmac), "got %s\n", str);
736
737 ret = pBCryptCloseAlgorithmProvider(alg, 0);
738 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
739}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define test_alg_name(a, b)
Definition: bcrypt.c:148
#define test_hash_length(a, b)
Definition: bcrypt.c:136
static void format_hash(const UCHAR *bytes, ULONG size, char *buf)
Definition: bcrypt.c:118
#define BCRYPT_ALG_HANDLE_HMAC_FLAG
Definition: bcrypt.h:172
#define MS_PRIMITIVE_PROVIDER
Definition: bcrypt.h:69
#define BCRYPT_MD5_ALGORITHM
Definition: bcrypt.h:72
#define md5
Definition: compat-1.3.h:2034
const WCHAR * str

Referenced by START_TEST().

◆ test_md5()

static void test_md5 ( void  )
static

Definition at line 591 of file bcrypt.c.

592{
593 static const char expected[] =
594 "e2a3e68d23ce348b8f68b3079de3d4c9";
595 static const char expected_hmac[] =
596 "7bda029b93fa8d817fcc9e13d6bdf092";
599 UCHAR buf[512], buf_hmac[1024], md5[16], md5_hmac[16];
600 ULONG size, len;
601 char str[65];
603
604 alg = NULL;
605 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
606 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
607 ok(alg != NULL, "alg not set\n");
608
609 len = size = 0xdeadbeef;
610 ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
611 ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
612
613 len = size = 0xdeadbeef;
614 ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
615 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
616
617 len = size = 0xdeadbeef;
618 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
619 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
620
621 len = size = 0xdeadbeef;
622 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
623 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
624 ok(size == sizeof(len), "got %u\n", size);
625
626 len = size = 0xdeadbeef;
627 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
628 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
629 ok(len == 0xdeadbeef, "got %u\n", len);
630 ok(size == sizeof(len), "got %u\n", size);
631
632 len = size = 0xdeadbeef;
633 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
634 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
635 ok(len != 0xdeadbeef, "len not set\n");
636 ok(size == sizeof(len), "got %u\n", size);
637
638 test_hash_length(alg, 16);
639 test_alg_name(alg, "MD5");
640
641 hash = NULL;
642 len = sizeof(buf);
643 ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
644 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
645 ok(hash != NULL, "hash not set\n");
646
647 ret = pBCryptHashData(hash, NULL, 0, 0);
648 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
649
650 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
651 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
652
654 test_alg_name(hash, "MD5");
655
656 memset(md5, 0, sizeof(md5));
657 ret = pBCryptFinishHash(hash, md5, sizeof(md5), 0);
658 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
659 format_hash( md5, sizeof(md5), str );
660 ok(!strcmp(str, expected), "got %s\n", str);
661
662 ret = pBCryptDestroyHash(hash);
663 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
664
665 ret = pBCryptCloseAlgorithmProvider(alg, 0);
666 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
667
668 alg = NULL;
669 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
670 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
671 ok(alg != NULL, "alg not set\n");
672
673 hash = NULL;
674 len = sizeof(buf_hmac);
675 ret = pBCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
676 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
677 ok(hash != NULL, "hash not set\n");
678
679 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
680 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
681
683 test_alg_name(hash, "MD5");
684
685 memset(md5_hmac, 0, sizeof(md5_hmac));
686 ret = pBCryptFinishHash(hash, md5_hmac, sizeof(md5_hmac), 0);
687 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
688 format_hash( md5_hmac, sizeof(md5_hmac), str );
689 ok(!strcmp(str, expected_hmac), "got %s\n", str);
690
691 ret = pBCryptDestroyHash(hash);
692 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
693
694 ret = pBCryptCloseAlgorithmProvider(alg, 0);
695 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
696}
#define BCRYPT_OBJECT_LENGTH
Definition: bcrypt.h:56
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
Definition: _hash_fun.h:40

Referenced by START_TEST().

◆ test_rng()

static void test_rng ( void  )
static

Definition at line 741 of file bcrypt.c.

742{
744 ULONG size, len;
745 UCHAR buf[16];
747
748 alg = NULL;
749 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
750 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
751 ok(alg != NULL, "alg not set\n");
752
753 len = size = 0xdeadbeef;
754 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
755 ok(ret == STATUS_NOT_SUPPORTED, "got %08x\n", ret);
756
757 test_alg_name(alg, "RNG");
758
759 memset(buf, 0, 16);
760 ret = pBCryptGenRandom(alg, buf, 8, 0);
761 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
762 ok(memcmp(buf, buf + 8, 8), "got zeroes\n");
763
764 ret = pBCryptCloseAlgorithmProvider(alg, 0);
765 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
766}
#define BCRYPT_RNG_ALGORITHM
Definition: bcrypt.h:73
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423

Referenced by START_TEST().

◆ test_sha1()

static void test_sha1 ( void  )
static

Definition at line 162 of file bcrypt.c.

163{
164 static const char expected[] = "961fa64958818f767707072755d7018dcd278e94";
165 static const char expected_hmac[] = "2472cf65d0e090618d769d3e46f0d9446cf212da";
168 UCHAR buf[512], buf_hmac[1024], sha1[20], sha1_hmac[20];
169 ULONG size, len;
170 char str[41];
172
173 alg = NULL;
174 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
175 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
176 ok(alg != NULL, "alg not set\n");
177
178 len = size = 0xdeadbeef;
179 ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
180 ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
181
182 len = size = 0xdeadbeef;
183 ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
184 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
185
186 len = size = 0xdeadbeef;
187 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
188 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
189
190 len = size = 0xdeadbeef;
191 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
192 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
193 ok(size == sizeof(len), "got %u\n", size);
194
195 len = size = 0xdeadbeef;
196 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
197 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
198 ok(len == 0xdeadbeef, "got %u\n", len);
199 ok(size == sizeof(len), "got %u\n", size);
200
201 len = size = 0xdeadbeef;
202 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
203 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
204 ok(len != 0xdeadbeef, "len not set\n");
205 ok(size == sizeof(len), "got %u\n", size);
206
207 test_hash_length(alg, 20);
208 test_alg_name(alg, "SHA1");
209
210 hash = NULL;
211 len = sizeof(buf);
212 ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
213 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
214 ok(hash != NULL, "hash not set\n");
215
216 ret = pBCryptHashData(hash, NULL, 0, 0);
217 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
218
219 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
220 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
221
223 test_alg_name(hash, "SHA1");
224
225 memset(sha1, 0, sizeof(sha1));
226 ret = pBCryptFinishHash(hash, sha1, sizeof(sha1), 0);
227 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
228 format_hash( sha1, sizeof(sha1), str );
229 ok(!strcmp(str, expected), "got %s\n", str);
230
231 ret = pBCryptDestroyHash(hash);
232 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
233
234 ret = pBCryptCloseAlgorithmProvider(alg, 0);
235 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
236
237 alg = NULL;
238 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
239 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
240 ok(alg != NULL, "alg not set\n");
241
242 hash = NULL;
243 len = sizeof(buf_hmac);
244 ret = pBCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
245 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
246 ok(hash != NULL, "hash not set\n");
247
248 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
249 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
250
252 test_alg_name(hash, "SHA1");
253
254 memset(sha1_hmac, 0, sizeof(sha1_hmac));
255 ret = pBCryptFinishHash(hash, sha1_hmac, sizeof(sha1_hmac), 0);
256 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
257 format_hash( sha1_hmac, sizeof(sha1_hmac), str );
258 ok(!strcmp(str, expected_hmac), "got %s\n", str);
259
260 ret = pBCryptDestroyHash(hash);
261 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
262
263 ret = pBCryptCloseAlgorithmProvider(alg, 0);
264 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
265}
#define BCRYPT_SHA1_ALGORITHM
Definition: bcrypt.h:74
#define sha1
Definition: compat-1.3.h:2261

Referenced by START_TEST().

◆ test_sha256()

static void test_sha256 ( void  )
static

Definition at line 267 of file bcrypt.c.

268{
269 static const char expected[] =
270 "ceb73749c899693706ede1e30c9929b3fd5dd926163831c2fb8bd41e6efb1126";
271 static const char expected_hmac[] =
272 "34c1aa473a4468a91d06e7cdbc75bc4f93b830ccfc2a47ffd74e8e6ed29e4c72";
275 UCHAR buf[512], buf_hmac[1024], sha256[32], sha256_hmac[32];
276 ULONG size, len;
277 char str[65];
279
280 alg = NULL;
281 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA256_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
282 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
283 ok(alg != NULL, "alg not set\n");
284
285 len = size = 0xdeadbeef;
286 ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
287 ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
288
289 len = size = 0xdeadbeef;
290 ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
291 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
292
293 len = size = 0xdeadbeef;
294 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
295 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
296
297 len = size = 0xdeadbeef;
298 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
299 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
300 ok(size == sizeof(len), "got %u\n", size);
301
302 len = size = 0xdeadbeef;
303 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
304 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
305 ok(len == 0xdeadbeef, "got %u\n", len);
306 ok(size == sizeof(len), "got %u\n", size);
307
308 len = size = 0xdeadbeef;
309 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
310 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
311 ok(len != 0xdeadbeef, "len not set\n");
312 ok(size == sizeof(len), "got %u\n", size);
313
314 test_hash_length(alg, 32);
315 test_alg_name(alg, "SHA256");
316
317 hash = NULL;
318 len = sizeof(buf);
319 ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
320 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
321 ok(hash != NULL, "hash not set\n");
322
323 ret = pBCryptHashData(hash, NULL, 0, 0);
324 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
325
326 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
327 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
328
330 test_alg_name(hash, "SHA256");
331
332 memset(sha256, 0, sizeof(sha256));
333 ret = pBCryptFinishHash(hash, sha256, sizeof(sha256), 0);
334 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
335 format_hash( sha256, sizeof(sha256), str );
336 ok(!strcmp(str, expected), "got %s\n", str);
337
338 ret = pBCryptDestroyHash(hash);
339 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
340
341 ret = pBCryptCloseAlgorithmProvider(alg, 0);
342 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
343
344 alg = NULL;
346 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
347 ok(alg != NULL, "alg not set\n");
348
349 hash = NULL;
350 len = sizeof(buf_hmac);
351 ret = pBCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
352 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
353 ok(hash != NULL, "hash not set\n");
354
355 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
356 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
357
359 test_alg_name(hash, "SHA256");
360
361 memset(sha256_hmac, 0, sizeof(sha256_hmac));
362 ret = pBCryptFinishHash(hash, sha256_hmac, sizeof(sha256_hmac), 0);
363 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
364 format_hash( sha256_hmac, sizeof(sha256_hmac), str );
365 ok(!strcmp(str, expected_hmac), "got %s\n", str);
366
367 ret = pBCryptDestroyHash(hash);
368 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
369
370 ret = pBCryptCloseAlgorithmProvider(alg, 0);
371 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
372}
#define BCRYPT_SHA256_ALGORITHM
Definition: bcrypt.h:75
#define sha256
Definition: compat-1.3.h:2272

Referenced by START_TEST().

◆ test_sha384()

static void test_sha384 ( void  )
static

Definition at line 374 of file bcrypt.c.

375{
376 static const char expected[] =
377 "62b21e90c9022b101671ba1f808f8631a8149f0f12904055839a35c1ca78ae5363eed1e743a692d70e0504b0cfd12ef9";
378 static const char expected_hmac[] =
379 "4b3e6d6ff2da121790ab7e7b9247583e3a7eed2db5bd4dabc680303b1608f37dfdc836d96a704c03283bc05b4f6c5eb8";
382 UCHAR buf[512], buf_hmac[1024], sha384[48], sha384_hmac[48];
383 ULONG size, len;
384 char str[97];
386
387 alg = NULL;
388 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA384_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
389 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
390 ok(alg != NULL, "alg not set\n");
391
392 len = size = 0xdeadbeef;
393 ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
394 ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
395
396 len = size = 0xdeadbeef;
397 ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
398 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
399
400 len = size = 0xdeadbeef;
401 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
402 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
403
404 len = size = 0xdeadbeef;
405 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
406 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
407 ok(size == sizeof(len), "got %u\n", size);
408
409 len = size = 0xdeadbeef;
410 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
411 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
412 ok(len == 0xdeadbeef, "got %u\n", len);
413 ok(size == sizeof(len), "got %u\n", size);
414
415 len = size = 0xdeadbeef;
416 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
417 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
418 ok(len != 0xdeadbeef, "len not set\n");
419 ok(size == sizeof(len), "got %u\n", size);
420
421 test_hash_length(alg, 48);
422 test_alg_name(alg, "SHA384");
423
424 hash = NULL;
425 len = sizeof(buf);
426 ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
427 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
428 ok(hash != NULL, "hash not set\n");
429
430 ret = pBCryptHashData(hash, NULL, 0, 0);
431 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
432
433 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
434 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
435
437 test_alg_name(hash, "SHA384");
438
439 memset(sha384, 0, sizeof(sha384));
440 ret = pBCryptFinishHash(hash, sha384, sizeof(sha384), 0);
441 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
442 format_hash( sha384, sizeof(sha384), str );
443 ok(!strcmp(str, expected), "got %s\n", str);
444
445 ret = pBCryptDestroyHash(hash);
446 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
447
448 ret = pBCryptCloseAlgorithmProvider(alg, 0);
449 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
450
451 alg = NULL;
453 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
454 ok(alg != NULL, "alg not set\n");
455
456 hash = NULL;
457 len = sizeof(buf_hmac);
458 ret = pBCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
459 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
460 ok(hash != NULL, "hash not set\n");
461
462 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
463 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
464
466 test_alg_name(hash, "SHA384");
467
468 memset(sha384_hmac, 0, sizeof(sha384_hmac));
469 ret = pBCryptFinishHash(hash, sha384_hmac, sizeof(sha384_hmac), 0);
470 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
471 format_hash( sha384_hmac, sizeof(sha384_hmac), str );
472 ok(!strcmp(str, expected_hmac), "got %s\n", str);
473
474 ret = pBCryptDestroyHash(hash);
475 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
476
477 ret = pBCryptCloseAlgorithmProvider(alg, 0);
478 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
479}
#define BCRYPT_SHA384_ALGORITHM
Definition: bcrypt.h:76
static const WCHAR sha384[]
Definition: oid.c:1221

Referenced by START_TEST().

◆ test_sha512()

static void test_sha512 ( void  )
static

Definition at line 481 of file bcrypt.c.

482{
483 static const char expected[] =
484 "d55ced17163bf5386f2cd9ff21d6fd7fe576a915065c24744d09cfae4ec84ee1e"
485 "f6ef11bfbc5acce3639bab725b50a1fe2c204f8c820d6d7db0df0ecbc49c5ca";
486 static const char expected_hmac[] =
487 "415fb6b10018ca03b38a1b1399c42ac0be5e8aceddb9a73103f5e543bf2d888f2"
488 "eecf91373941f9315dd730a77937fa92444450fbece86f409d9cb5ec48c6513";
491 UCHAR buf[512], buf_hmac[1024], sha512[64], sha512_hmac[64];
492 ULONG size, len;
493 char str[129];
495
496 alg = NULL;
497 ret = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA512_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
498 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
499 ok(alg != NULL, "alg not set\n");
500
501 len = size = 0xdeadbeef;
502 ret = pBCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
503 ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret);
504
505 len = size = 0xdeadbeef;
506 ret = pBCryptGetProperty(alg, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
507 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
508
509 len = size = 0xdeadbeef;
510 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
511 ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret);
512
513 len = size = 0xdeadbeef;
514 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
515 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
516 ok(size == sizeof(len), "got %u\n", size);
517
518 len = size = 0xdeadbeef;
519 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
520 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret);
521 ok(len == 0xdeadbeef, "got %u\n", len);
522 ok(size == sizeof(len), "got %u\n", size);
523
524 len = size = 0xdeadbeef;
525 ret = pBCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len , sizeof(len), &size, 0);
526 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
527 ok(len != 0xdeadbeef, "len not set\n");
528 ok(size == sizeof(len), "got %u\n", size);
529
530 test_hash_length(alg, 64);
531 test_alg_name(alg, "SHA512");
532
533 hash = NULL;
534 len = sizeof(buf);
535 ret = pBCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
536 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
537 ok(hash != NULL, "hash not set\n");
538
539 ret = pBCryptHashData(hash, NULL, 0, 0);
540 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
541
542 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
543 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
544
546 test_alg_name(hash, "SHA512");
547
548 memset(sha512, 0, sizeof(sha512));
549 ret = pBCryptFinishHash(hash, sha512, sizeof(sha512), 0);
550 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
551 format_hash( sha512, sizeof(sha512), str );
552 ok(!strcmp(str, expected), "got %s\n", str);
553
554 ret = pBCryptDestroyHash(hash);
555 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
556
557 ret = pBCryptCloseAlgorithmProvider(alg, 0);
558 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
559
560 alg = NULL;
562 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
563 ok(alg != NULL, "alg not set\n");
564
565 hash = NULL;
566 len = sizeof(buf_hmac);
567 ret = pBCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
568 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
569 ok(hash != NULL, "hash not set\n");
570
571 ret = pBCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
572 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
573
575 test_alg_name(hash, "SHA512");
576
577 memset(sha512_hmac, 0, sizeof(sha512_hmac));
578 ret = pBCryptFinishHash(hash, sha512_hmac, sizeof(sha512_hmac), 0);
579 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
580 format_hash( sha512_hmac, sizeof(sha512_hmac), str );
581 ok(!strcmp(str, expected_hmac), "got %s\n", str);
582
583 ret = pBCryptDestroyHash(hash);
584 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
585
586 ret = pBCryptCloseAlgorithmProvider(alg, 0);
587 ok(ret == STATUS_SUCCESS, "got %08x\n", ret);
588
589}
#define BCRYPT_SHA512_ALGORITHM
Definition: bcrypt.h:77
#define sha512
Definition: compat-1.3.h:2283

Referenced by START_TEST().

Variable Documentation

◆ LPCWSTR

Definition at line 29 of file bcrypt.c.

◆ PUCHAR

Definition at line 32 of file bcrypt.c.

◆ ULONG

Definition at line 29 of file bcrypt.c.