ReactOS 0.4.17-dev-1190-g4c812f4
Classes | Macros | Functions | Variables
bcrypt.c File Reference
#include <stdio.h>
#include <ntstatus.h>
#include <windows.h>
#include <bcrypt.h>
#include <ncrypt.h>
#include <wincrypt.h>
#include "wine/test.h"
Include dependency graph for bcrypt.c:

Go to the source code of this file.

Classes

struct  hash_test
 
struct  ecdh_test
 

Macros

#define WIN32_NO_STATUS
 
#define test_object_length(a)   _test_object_length(__LINE__,a)
 
#define test_hash_length(a, b)   _test_hash_length(__LINE__,a,b)
 
#define test_hash_block_length(a, b)   _test_hash_block_length(__LINE__,a,b)
 
#define test_alg_name(a, b)   _test_alg_name(__LINE__,a,b)
 
#define RACE_TEST_COUNT   200
 

Functions

static NTSTATUS (WINAPI *pBCryptHash)(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 void _test_object_length (unsigned line, void *handle)
 
static void _test_hash_length (unsigned line, void *handle, ULONG exlen)
 
static void _test_hash_block_length (unsigned line, void *handle, ULONG exlen)
 
static void _test_alg_name (unsigned line, void *handle, const WCHAR *exname)
 
static void test_hash (const struct hash_test *test)
 
static void test_hashes (void)
 
static void test_BcryptHash (void)
 
static void test_BcryptDeriveKeyPBKDF2 (void)
 
static void test_rng (void)
 
static void test_aes (void)
 
static void test_3des (void)
 
static void test_BCryptGenerateSymmetricKey (void)
 
static DWORD WINAPI encrypt_race_thread (void *parameter)
 
static void test_BCryptEncrypt (void)
 
static void test_BCryptDecrypt (void)
 
static void test_key_import_export (void)
 
static void test_ECDSA (void)
 
static void test_rsa_encrypt (void)
 
static void test_RSA (void)
 
static void test_RSA_SIGN (void)
 
static void test_ECDH_alg (const struct ecdh_test *t)
 
static void test_ECDH (void)
 
static void test_DH (void)
 
static void test_BCryptEnumContextFunctions (void)
 
static void test_BCryptSignHash (void)
 
static void test_BCryptEnumAlgorithms (void)
 
static void test_aes_vector (void)
 
static void test_aes_vector_property (void)
 
static void test_BcryptDeriveKeyCapi (void)
 
static void test_DSA (void)
 
static void test_SecretAgreement (void)
 
static void test_RC4 (void)
 
static void test_PBKDF2 (void)
 
static void test_TLS_PRF (void)
 
static void test_HKDF (void)
 
static void test_CHACHA20_POLY1305 (void)
 
 START_TEST (bcrypt)
 

Variables

static UCHAR ULONG
 
static UCHAR password [] = "password"
 
static UCHAR salt [] = "salt"
 
static UCHAR long_password [] = "passwordPASSWORDpassword"
 
static UCHAR long_salt [] = "saltSALTsaltSALTsaltSALTsaltSALTsalt"
 
static UCHAR password_NUL [] = "pass\0word"
 
static UCHAR salt_NUL [] = "sa\0lt"
 
static UCHAR dk1 [] = "0c60c80f961f0e71f3a9b524af6012062fe037a6"
 
static UCHAR dk2 [] = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"
 
static UCHAR dk3 [] = "4b007901b765489abead49d926f721d065a429c1"
 
static UCHAR dk4 [] = "364dd6bc200ec7d197f1b85f4a61769010717124"
 
static UCHAR dk5 [] = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"
 
static UCHAR dk6 [] = "56fa6aa75548099dcc37d7f03425e0c3"
 
static UCHAR dk7 [] = "8754c32c64b0f524fc50c00f788135de"
 
struct {
   ULONG   pwd_len
 
   ULONG   salt_len
 
   ULONGLONG   iterations
 
   ULONG   dk_len
 
   UCHAR *   pwd
 
   UCHAR *   salt
 
   const UCHAR *   dk
 
} rfc6070 []
 
static LONG encrypt_race_start_barrier
 
static BYTE eccPrivkey []
 
static BYTE ecc521Privkey []
 
static BYTE eccPubkey []
 
static BYTE certHash []
 
static BYTE certSignature []
 
static BYTE cert521Signature []
 
static UCHAR rsaPublicBlob []
 
static UCHAR rsaHash []
 
static UCHAR rsaSignature []
 
static UCHAR rsaPrivateBlob []
 
static UCHAR rsaFullPrivateBlob []
 
struct {
   PUBLICKEYSTRUC   header
 
   RSAPUBKEY   rsapubkey
 
   BYTE   modulus [512/8]
 
   BYTE   prime1 [512/16]
 
   BYTE   prime2 [512/16]
 
   BYTE   exp1 [512/16]
 
   BYTE   exp2 [512/16]
 
   BYTE   coefficient [512/16]
 
   BYTE   private_exp [512/8]
 
} rsaLegacyPrivateBlob
 
static UCHAR rsaPublicBlobWithInvalidPublicExpSize []
 
static const UCHAR rsa_encrypted_no_padding []
 
static UCHAR legacy_rsa_key []
 
static const UCHAR hash_prepend [][2] = {{0xca, 0xfe}, {0xf0, 0x0d}}
 
static BYTE dh_pubkey []
 
static BYTE dh_privkey []
 
static BYTE dh_secret []
 
static BYTE dh_hashed_secret []
 
static BYTE dh_hashed_secret_prepended []
 
BCryptBuffer dh_hash_param_buffers []
 
BCryptBuffer dh_hash_param_buffers_prepended []
 
BCryptBufferDesc dh_hash_params
 
BCryptBufferDesc dh_hash_params_prepended
 
static BYTE rsapublic []
 
static UCHAR dsaHash []
 
static UCHAR dsaSignature []
 
static UCHAR dsaPublicBlob []
 
static UCHAR dssKey []
 

Macro Definition Documentation

◆ RACE_TEST_COUNT

#define RACE_TEST_COUNT   200

Definition at line 993 of file bcrypt.c.

◆ test_alg_name

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

Definition at line 181 of file bcrypt.c.

◆ test_hash_block_length

#define test_hash_block_length (   a,
  b 
)    _test_hash_block_length(__LINE__,a,b)

Definition at line 169 of file bcrypt.c.

◆ test_hash_length

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

Definition at line 157 of file bcrypt.c.

◆ test_object_length

#define test_object_length (   a)    _test_object_length(__LINE__,a)

Definition at line 121 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 WCHAR *  exname 
)
static

Definition at line 182 of file bcrypt.c.

183{
184 ULONG size = 0xdeadbeef;
185 UCHAR buf[256];
186 const WCHAR *name = (const WCHAR*)buf;
187 NTSTATUS status;
188
189 status = BCryptGetProperty(handle, BCRYPT_ALGORITHM_NAME, buf, sizeof(buf), &size, 0);
190 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %#lx\n", status);
191 ok_(__FILE__,line)(size == (lstrlenW(exname) + 1) * sizeof(WCHAR), "got %lu\n", size);
192 ok_(__FILE__,line)(!lstrcmpW(name, exname), "alg name = %s, expected %s\n", wine_dbgstr_w(name),
193 wine_dbgstr_w(exname));
194}
ok_
#define ok_(x1, x2)
Definition: atltest.h:61
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
BCRYPT_ALGORITHM_NAME
#define BCRYPT_ALGORITHM_NAME
Definition: bcrypt.h:51
BCryptGetProperty
NTSTATUS WINAPI BCryptGetProperty(BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *buffer, ULONG count, ULONG *res, ULONG flags)
Definition: bcrypt_main.c:1325
lstrlenW
#define lstrlenW
Definition: compat.h:750
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4152
size
GLsizeiptr size
Definition: glext.h:5919
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
WCHAR
short WCHAR
Definition: pedump.c:58
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
line
Definition: parser.c:49
name
Definition: name.c:39
status
Definition: ps.c:97
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
ULONG
uint32_t ULONG
Definition: typedefs.h:59

◆ _test_hash_block_length()

static void _test_hash_block_length ( unsigned  line,
void *  handle,
ULONG  exlen 
)
static

Definition at line 170 of file bcrypt.c.

171{
172 ULONG len = 0xdeadbeef, size = 0xdeadbeef;
173 NTSTATUS status;
174
175 status = BCryptGetProperty(handle, BCRYPT_HASH_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
176 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %#lx\n", status);
177 ok_(__FILE__,line)(size == sizeof(len), "got %lu\n", size);
178 ok_(__FILE__,line)(len == exlen, "len = %lu, expected %lu\n", len, exlen);
179}
BCRYPT_HASH_BLOCK_LENGTH
#define BCRYPT_HASH_BLOCK_LENGTH
Definition: bcrypt.h:57
len
GLenum GLsizei len
Definition: glext.h:6722

◆ _test_hash_length()

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

Definition at line 158 of file bcrypt.c.

159{
160 ULONG len = 0xdeadbeef, size = 0xdeadbeef;
161 NTSTATUS status;
162
163 status = BCryptGetProperty(handle, BCRYPT_HASH_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
164 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %#lx\n", status);
165 ok_(__FILE__,line)(size == sizeof(len), "got %lu\n", size);
166 ok_(__FILE__,line)(len == exlen, "len = %lu, expected %lu\n", len, exlen);
167}
BCRYPT_HASH_LENGTH
#define BCRYPT_HASH_LENGTH
Definition: bcrypt.h:58

◆ _test_object_length()

static void _test_object_length ( unsigned  line,
void *  handle 
)
static

Definition at line 122 of file bcrypt.c.

123{
124 NTSTATUS status;
125 ULONG len, size;
126
127 len = size = 0xdeadbeef;
128 status = BCryptGetProperty(NULL, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
129 ok_(__FILE__,line)(status == STATUS_INVALID_HANDLE, "BCryptGetProperty failed: %#lx\n", status);
130
131 len = size = 0xdeadbeef;
132 status = BCryptGetProperty(handle, NULL, (UCHAR *)&len, sizeof(len), &size, 0);
133 ok_(__FILE__,line)(status == STATUS_INVALID_PARAMETER, "BCryptGetProperty failed: %#lx\n", status);
134
135 len = size = 0xdeadbeef;
136 status = BCryptGetProperty(handle, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), NULL, 0);
137 ok_(__FILE__,line)(status == STATUS_INVALID_PARAMETER, "BCryptGetProperty failed: %#lx\n", status);
138
139 len = size = 0xdeadbeef;
140 status = BCryptGetProperty(handle, BCRYPT_OBJECT_LENGTH, NULL, sizeof(len), &size, 0);
141 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %#lx\n", status);
142 ok_(__FILE__,line)(size == sizeof(len), "got %lu\n", size);
143
144 len = size = 0xdeadbeef;
145 status = BCryptGetProperty(handle, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, 0, &size, 0);
146 ok_(__FILE__,line)(status == STATUS_BUFFER_TOO_SMALL, "BCryptGetProperty failed: %#lx\n", status);
147 ok_(__FILE__,line)(len == 0xdeadbeef, "got %lu\n", len);
148 ok_(__FILE__,line)(size == sizeof(len), "got %lu\n", size);
149
150 len = size = 0xdeadbeef;
151 status = BCryptGetProperty(handle, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
152 ok_(__FILE__,line)(status == STATUS_SUCCESS, "BCryptGetProperty failed: %#lx\n", status);
153 ok_(__FILE__,line)(len != 0xdeadbeef, "len not set\n");
154 ok_(__FILE__,line)(size == sizeof(len), "got %lu\n", size);
155}
BCRYPT_OBJECT_LENGTH
#define BCRYPT_OBJECT_LENGTH
Definition: bcrypt.h:65
STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40
NULL
#define NULL
Definition: types.h:112
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

◆ encrypt_race_thread()

static DWORD WINAPI encrypt_race_thread ( void *  parameter)
static

Definition at line 996 of file bcrypt.c.

997{
998 static UCHAR nonce[] =
999 {0x11,0x20,0x30,0x40,0x50,0x60,0x10,0x20,0x30,0x40,0x50,0x60};
1000 static UCHAR auth_data[] =
1001 {0x61,0x50,0x40,0x30,0x20,0x10,0x60,0x50,0x40,0x30,0x20,0x10};
1002 static UCHAR data2[] =
1003 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
1004 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10};
1005 static UCHAR expected4[] =
1006 {0xb2,0x27,0x19,0x09,0xc7,0x89,0xdc,0x52,0x24,0x83,0x3a,0x55,0x34,0x76,0x2c,0xbf,
1007 0x15,0xa1,0xcb,0x40,0x78,0x11,0xba,0xbc,0xa4,0x76,0x69,0x7c,0x75,0x4f,0x11,0xba};
1008 static UCHAR expected_tag3[] =
1009 {0xef,0xee,0x75,0x99,0xb8,0x12,0xe9,0xf0,0xb4,0xcc,0x65,0x11,0x67,0x60,0x2d,0xe6};
1010
1011 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO auth_info;
1012 BCRYPT_KEY_HANDLE key = parameter;
1013 UCHAR ciphertext[48], tag[16];
1014 unsigned int i, test;
1015 NTSTATUS ret;
1016 ULONG size;
1017
1018 memset(&auth_info, 0, sizeof(auth_info));
1019 auth_info.cbSize = sizeof(auth_info);
1020 auth_info.dwInfoVersion = 1;
1021 auth_info.pbNonce = nonce;
1022 auth_info.cbNonce = sizeof(nonce);
1023 auth_info.pbTag = tag;
1024 auth_info.cbTag = sizeof(tag);
1025 auth_info.pbAuthData = auth_data;
1026 auth_info.cbAuthData = sizeof(auth_data);
1027
1028 InterlockedIncrement(&encrypt_race_start_barrier);
1029 while (InterlockedCompareExchange(&encrypt_race_start_barrier, 3, 2) != 2)
1030 ;
1031
1032 for (test = 0; test < RACE_TEST_COUNT; ++test)
1033 {
1034 size = 0;
1035 memset(ciphertext, 0xff, sizeof(ciphertext));
1036 memset(tag, 0xff, sizeof(tag));
1037 ret = BCryptEncrypt(key, data2, 32, &auth_info, NULL, 0, ciphertext, 32, &size, 0);
1038 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1039 ok(size == 32, "got %lu\n", size);
1040 ok(!memcmp(ciphertext, expected4, sizeof(expected4)), "wrong data\n");
1041 ok(!memcmp(tag, expected_tag3, sizeof(expected_tag3)), "wrong tag\n");
1042 for (i = 0; i < 32; i++)
1043 ok(ciphertext[i] == expected4[i], "%u: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1044 for (i = 0; i < 16; i++)
1045 ok(tag[i] == expected_tag3[i], "%u: %02x != %02x\n", i, tag[i], expected_tag3[i]);
1046 }
1047
1048 return 0;
1049}
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
ok
#define ok(value,...)
Definition: atltest.h:57
encrypt_race_start_barrier
static LONG encrypt_race_start_barrier
Definition: bcrypt.c:994
RACE_TEST_COUNT
#define RACE_TEST_COUNT
Definition: bcrypt.c:993
BCryptEncrypt
NTSTATUS WINAPI BCryptEncrypt(BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv, ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:2307
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2807
ret
return ret
Definition: mutex.c:147
i
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
InterlockedCompareExchange
#define InterlockedCompareExchange
Definition: interlocked.h:119
test
#define test
Definition: rosglue.h:37
memset
#define memset(x, y, z)
Definition: compat.h:39
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO
Definition: bcrypt.h:214
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::pbTag
UCHAR * pbTag
Definition: bcrypt.h:221
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::cbAuthData
ULONG cbAuthData
Definition: bcrypt.h:220
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::cbNonce
ULONG cbNonce
Definition: bcrypt.h:218
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::pbNonce
UCHAR * pbNonce
Definition: bcrypt.h:217
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::pbAuthData
UCHAR * pbAuthData
Definition: bcrypt.h:219
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::cbTag
ULONG cbTag
Definition: bcrypt.h:222
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::cbSize
ULONG cbSize
Definition: bcrypt.h:215
_BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO::dwInfoVersion
ULONG dwInfoVersion
Definition: bcrypt.h:216
data2
Definition: tftpd.h:138
key
Definition: copy.c:22
tag
Definition: ecma_167.h:138
nonce
UINT32 nonce[3]
Definition: symcrypt_internal.h:2122

Referenced by test_BCryptEncrypt().

◆ format_hash()

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

Definition at line 110 of file bcrypt.c.

111{
112 ULONG i;
113 buf[0] = '\0';
114 for (i = 0; i < size; i++)
115 {
116 sprintf(buf + i * 2, "%02x", bytes[i]);
117 }
118 return;
119}
bytes
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
sprintf
#define sprintf
Definition: sprintf.c:45

Referenced by test_BcryptDeriveKeyPBKDF2(), test_BcryptHash(), and test_hash().

◆ NTSTATUS()

static NTSTATUS ( WINAPI *  pBCryptHash)
static

◆ START_TEST()

START_TEST ( bcrypt  )

Definition at line 5581 of file bcrypt.c.

5582{
5583 HMODULE module;
5584
5585 module = LoadLibraryA("bcrypt.dll");
5586 if (!module)
5587 {
5588 win_skip("bcrypt.dll not found\n");
5589 return;
5590 }
5591 pBCryptHash = (void *)GetProcAddress(module, "BCryptHash");
5592
5593 test_BCryptGenRandom();
5594 test_BCryptGetFipsAlgorithmMode();
5595 test_hashes();
5596 test_BcryptHash();
5597 test_BcryptDeriveKeyPBKDF2();
5598 test_rng();
5599 test_3des();
5600 test_aes();
5601 test_BCryptGenerateSymmetricKey();
5602 test_BCryptEncrypt();
5603 test_BCryptDecrypt();
5604 test_key_import_export();
5605 test_ECDSA();
5606 test_RSA();
5607 test_RSA_SIGN();
5608 test_ECDH();
5609 test_DH();
5610 test_BCryptEnumContextFunctions();
5611 test_BCryptSignHash();
5612 test_BCryptEnumAlgorithms();
5613 test_aes_vector();
5614 test_aes_vector_property();
5615 test_BcryptDeriveKeyCapi();
5616 test_DSA();
5617 test_SecretAgreement();
5618 test_rsa_encrypt();
5619 test_RC4();
5620 test_PBKDF2();
5621 test_TLS_PRF();
5622 test_HKDF();
5623 test_CHACHA20_POLY1305();
5624
5625 FreeLibrary(module);
5626}
test_BCryptDecrypt
static void test_BCryptDecrypt(void)
Definition: bcrypt.c:1720
test_HKDF
static void test_HKDF(void)
Definition: bcrypt.c:5374
test_key_import_export
static void test_key_import_export(void)
Definition: bcrypt.c:2127
test_DH
static void test_DH(void)
Definition: bcrypt.c:3914
test_aes_vector_property
static void test_aes_vector_property(void)
Definition: bcrypt.c:4352
test_ECDH
static void test_ECDH(void)
Definition: bcrypt.c:3552
test_BCryptEnumAlgorithms
static void test_BCryptEnumAlgorithms(void)
Definition: bcrypt.c:4253
test_BCryptGenRandom
static void test_BCryptGenRandom(void)
Definition: bcrypt.c:33
test_aes_vector
static void test_aes_vector(void)
Definition: bcrypt.c:4290
test_ECDSA
static void test_ECDSA(void)
Definition: bcrypt.c:2303
test_BcryptHash
static void test_BcryptHash(void)
Definition: bcrypt.c:431
test_DSA
static void test_DSA(void)
Definition: bcrypt.c:4567
test_BCryptGetFipsAlgorithmMode
static void test_BCryptGetFipsAlgorithmMode(void)
Definition: bcrypt.c:75
test_BCryptSignHash
static void test_BCryptSignHash(void)
Definition: bcrypt.c:4124
test_RSA
static void test_RSA(void)
Definition: bcrypt.c:2974
test_CHACHA20_POLY1305
static void test_CHACHA20_POLY1305(void)
Definition: bcrypt.c:5547
test_BcryptDeriveKeyPBKDF2
static void test_BcryptDeriveKeyPBKDF2(void)
Definition: bcrypt.c:529
test_BCryptEnumContextFunctions
static void test_BCryptEnumContextFunctions(void)
Definition: bcrypt.c:4092
test_rsa_encrypt
static void test_rsa_encrypt(void)
Definition: bcrypt.c:2709
test_aes
static void test_aes(void)
Definition: bcrypt.c:602
test_RSA_SIGN
static void test_RSA_SIGN(void)
Definition: bcrypt.c:3221
test_BcryptDeriveKeyCapi
static void test_BcryptDeriveKeyCapi(void)
Definition: bcrypt.c:4437
test_BCryptEncrypt
static void test_BCryptEncrypt(void)
Definition: bcrypt.c:1051
test_rng
static void test_rng(void)
Definition: bcrypt.c:571
test_3des
static void test_3des(void)
Definition: bcrypt.c:709
test_SecretAgreement
static void test_SecretAgreement(void)
Definition: bcrypt.c:4667
test_RC4
static void test_RC4(void)
Definition: bcrypt.c:5101
test_BCryptGenerateSymmetricKey
static void test_BCryptGenerateSymmetricKey(void)
Definition: bcrypt.c:770
test_hashes
static void test_hashes(void)
Definition: bcrypt.c:370
test_TLS_PRF
static void test_TLS_PRF(void)
Definition: bcrypt.c:5235
test_PBKDF2
static void test_PBKDF2(void)
Definition: bcrypt.c:5130
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:753
FreeLibrary
#define FreeLibrary(x)
Definition: compat.h:748
LoadLibraryA
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
win_skip
#define win_skip
Definition: minitest.h:67

◆ test_3des()

static void test_3des ( void  )
static

Definition at line 709 of file bcrypt.c.

710{
711 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
712 BCRYPT_ALG_HANDLE alg;
713 ULONG size, len;
714 UCHAR mode[64];
715 NTSTATUS ret;
716
717 alg = NULL;
718 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_3DES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
719 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
720 ok(alg != NULL, "alg not set\n");
721
722 len = size = 0;
723 ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
724 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
725 ok(len, "expected non-zero len\n");
726 ok(size == sizeof(len), "got %lu\n", size);
727
728 len = size = 0;
729 ret = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
730 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
731 ok(len == 8, "got %lu\n", len);
732 ok(size == sizeof(len), "got %lu\n", size);
733
734 size = 0;
735 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, 0, &size, 0);
736 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
737 ok(size == 64, "got %lu\n", size);
738
739 size = 0;
740 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, sizeof(mode) - 1, &size, 0);
741 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
742 ok(size == 64, "got %lu\n", size);
743
744 size = 0;
745 memset(mode, 0, sizeof(mode));
746 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
747 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
748 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_CBC), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
749 ok(size == 64, "got %lu\n", size);
750
751 size = 0;
752 memset(&key_lengths, 0, sizeof(key_lengths));
753 ret = BCryptGetProperty(alg, BCRYPT_KEY_LENGTHS, (UCHAR*)&key_lengths, sizeof(key_lengths), &size, 0);
754 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
755 ok(size == sizeof(key_lengths), "got %lu\n", size);
756 ok(key_lengths.dwMinLength == 192, "Expected 192, got %lu\n", key_lengths.dwMinLength);
757 ok(key_lengths.dwMaxLength == 192, "Expected 192, got %lu\n", key_lengths.dwMaxLength);
758 ok(key_lengths.dwIncrement == 0, "Expected 0, got %lu\n", key_lengths.dwIncrement);
759
760 memcpy(mode, BCRYPT_CHAIN_MODE_GCM, sizeof(BCRYPT_CHAIN_MODE_GCM));
761 ret = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, mode, 0, 0);
762 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
763
764 test_alg_name(alg, L"3DES");
765
766 ret = BCryptCloseAlgorithmProvider(alg, 0);
767 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
768}
test_alg_name
#define test_alg_name(a, b)
Definition: bcrypt.c:181
BCRYPT_KEY_LENGTHS
#define BCRYPT_KEY_LENGTHS
Definition: bcrypt.h:62
BCRYPT_3DES_ALGORITHM
#define BCRYPT_3DES_ALGORITHM
Definition: bcrypt.h:95
BCRYPT_CHAIN_MODE_GCM
#define BCRYPT_CHAIN_MODE_GCM
Definition: bcrypt.h:136
BCRYPT_CHAINING_MODE
#define BCRYPT_CHAINING_MODE
Definition: bcrypt.h:55
BCRYPT_CHAIN_MODE_CBC
#define BCRYPT_CHAIN_MODE_CBC
Definition: bcrypt.h:132
BCRYPT_BLOCK_LENGTH
#define BCRYPT_BLOCK_LENGTH
Definition: bcrypt.h:53
MS_PRIMITIVE_PROVIDER
#define MS_PRIMITIVE_PROVIDER
Definition: bcrypt.h:92
BCryptOpenAlgorithmProvider
NTSTATUS WINAPI BCryptOpenAlgorithmProvider(BCRYPT_ALG_HANDLE *handle, const WCHAR *id, const WCHAR *implementation, DWORD flags)
Definition: bcrypt_main.c:629
BCryptSetProperty
NTSTATUS WINAPI BCryptSetProperty(BCRYPT_HANDLE handle, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1230
BCryptCloseAlgorithmProvider
NTSTATUS WINAPI BCryptCloseAlgorithmProvider(BCRYPT_ALG_HANDLE handle, DWORD flags)
Definition: bcrypt_main.c:684
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
L
#define L(x)
Definition: resources.c:13
mode
GLenum mode
Definition: glext.h:6217
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
__BCRYPT_KEY_LENGTHS_STRUCT
Definition: bcrypt.h:207

Referenced by START_TEST().

◆ test_aes()

static void test_aes ( void  )
static

Definition at line 602 of file bcrypt.c.

603{
604 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
605 BCRYPT_ALG_HANDLE alg;
606 ULONG size, len;
607 UCHAR mode[64];
608 NTSTATUS ret;
609
610 alg = NULL;
611 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
612 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
613 ok(alg != NULL, "alg not set\n");
614
615 len = size = 0;
616 ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
617 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
618 ok(len, "expected non-zero len\n");
619 ok(size == sizeof(len), "got %lu\n", size);
620
621 len = size = 0;
622 ret = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
623 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
624 ok(len == 16, "got %lu\n", len);
625 ok(size == sizeof(len), "got %lu\n", size);
626
627 size = 0;
628 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, 0, &size, 0);
629 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
630 ok(size == 64, "got %lu\n", size);
631
632 size = 0;
633 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, sizeof(mode) - 1, &size, 0);
634 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
635 ok(size == 64, "got %lu\n", size);
636
637 size = 0;
638 memset(mode, 0, sizeof(mode));
639 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
640 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
641 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_CBC), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
642 ok(size == 64, "got %lu\n", size);
643
644 size = 0;
645 memset(&key_lengths, 0, sizeof(key_lengths));
646 ret = BCryptGetProperty(alg, BCRYPT_KEY_LENGTHS, (UCHAR*)&key_lengths, sizeof(key_lengths), &size, 0);
647 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
648 ok(size == sizeof(key_lengths), "got %lu\n", size);
649 ok(key_lengths.dwMinLength == 128, "Expected 128, got %lu\n", key_lengths.dwMinLength);
650 ok(key_lengths.dwMaxLength == 256, "Expected 256, got %lu\n", key_lengths.dwMaxLength);
651 ok(key_lengths.dwIncrement == 64, "Expected 64, got %lu\n", key_lengths.dwIncrement);
652
653 ret = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_GCM, 0, 0);
654 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
655
656 size = 0;
657 memset(mode, 0, sizeof(mode));
658 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
659 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
660 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_GCM), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
661 ok(size == 64, "got %lu\n", size);
662
663 ret = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_CFB, 0, 0);
664 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
665
666 size = 0;
667 memset(mode, 0, sizeof(mode));
668 ret = BCryptGetProperty(alg, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
669 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
670 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_CFB), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
671 ok(size == 64, "got %lu\n", size);
672
673 len = size = 0;
674 ret = BCryptGetProperty(alg, BCRYPT_MESSAGE_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
675 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
676 ok(len == 1, "got %lu\n", len);
677
678 len = 16;
679 ret = BCryptSetProperty(alg, BCRYPT_MESSAGE_BLOCK_LENGTH, (UCHAR *)&len, 0, 0);
680 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
681
682 test_alg_name(alg, L"AES");
683
684 ret = BCryptCloseAlgorithmProvider(alg, 0);
685 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
686
687 if (pBCryptHash)
688 {
689 ret = BCryptSetProperty(BCRYPT_AES_CBC_ALG_HANDLE, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_GCM, 0, 0);
690 ok(ret == STATUS_ACCESS_DENIED, "got %#lx\n", ret);
691
692 size = 0;
693 memset(mode, 0, sizeof(mode));
694 ret = BCryptGetProperty(BCRYPT_AES_CBC_ALG_HANDLE, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
695 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
696 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_CBC), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
697 ok(size == 64, "got %lu\n", size);
698 }
699
700 alg = NULL;
701 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_AES_GMAC_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
702 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
703 ok(alg != NULL, "alg not set\n");
704
705 ret = BCryptCloseAlgorithmProvider(alg, 0);
706 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
707}
BCRYPT_CHAIN_MODE_CFB
#define BCRYPT_CHAIN_MODE_CFB
Definition: bcrypt.h:134
BCRYPT_AES_ALGORITHM
#define BCRYPT_AES_ALGORITHM
Definition: bcrypt.h:96
BCRYPT_AES_GMAC_ALGORITHM
#define BCRYPT_AES_GMAC_ALGORITHM
Definition: bcrypt.h:97
BCRYPT_MESSAGE_BLOCK_LENGTH
#define BCRYPT_MESSAGE_BLOCK_LENGTH
Definition: bcrypt.h:155
BCRYPT_AES_CBC_ALG_HANDLE
#define BCRYPT_AES_CBC_ALG_HANDLE
Definition: bcrypt.h:442
STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145

Referenced by START_TEST().

◆ test_aes_vector()

static void test_aes_vector ( void  )
static

Definition at line 4290 of file bcrypt.c.

4291{
4292 static const UCHAR secret[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10};
4293 static const UCHAR expect[] = {0xb0,0xcb,0xf5,0x80,0xd4,0xe3,0x55,0x23,0x6e,0x19,0x5b,0xdb,0xfe,0xe0,0x6c,0xd3};
4294 static const UCHAR expect2[] = {0x06,0x0c,0x81,0xab,0xd4,0x28,0x80,0x42,0xce,0x30,0x56,0x17,0x15,0x00,0x9e,0xc1};
4295 static const UCHAR expect3[] = {0x3e,0x99,0xbf,0x02,0xf5,0xd3,0xb8,0x81,0x91,0x4d,0x93,0xea,0xd4,0x92,0x93,0x46};
4296 static UCHAR iv[16], input[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'};
4297 UCHAR output[16];
4298 BCRYPT_ALG_HANDLE alg;
4299 BCRYPT_KEY_HANDLE key;
4300 UCHAR data[sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + sizeof(secret)];
4301 BCRYPT_KEY_DATA_BLOB_HEADER *blob = (BCRYPT_KEY_DATA_BLOB_HEADER *)data;
4302 ULONG size;
4303 NTSTATUS ret;
4304
4305 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_AES_ALGORITHM, NULL, 0);
4306 ok(!ret, "got %#lx\n", ret);
4307
4308 size = sizeof(BCRYPT_CHAIN_MODE_CBC);
4309 ret = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_CBC, size, 0);
4310 ok(!ret, "got %#lx\n", ret);
4311
4312 blob->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
4313 blob->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
4314 blob->cbKeyData = sizeof(secret);
4315 memcpy(data + sizeof(*blob), secret, sizeof(secret));
4316 size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + sizeof(secret);
4317 ret = BCryptImportKey(alg, NULL, BCRYPT_KEY_DATA_BLOB, &key, NULL, 0, data, size, 0);
4318 ok(!ret, "got %#lx\n", ret);
4319
4320 /* zero initialization vector */
4321 size = 0;
4322 memset(output, 0, sizeof(output));
4323 ret = BCryptEncrypt(key, input, sizeof(input), NULL, iv, sizeof(iv), output, sizeof(output), &size, 0);
4324 ok(!ret, "got %#lx\n", ret);
4325 ok(size == 16, "got %lu\n", size);
4326 ok(!memcmp(output, expect, sizeof(expect)), "wrong cipher text\n");
4327
4328 /* same initialization vector */
4329 size = 0;
4330 memset(output, 0, sizeof(output));
4331 ret = BCryptEncrypt(key, input, sizeof(input), NULL, iv, sizeof(iv), output, sizeof(output), &size, 0);
4332 ok(!ret, "got %#lx\n", ret);
4333 ok(size == 16, "got %lu\n", size);
4334 ok(!memcmp(output, expect2, sizeof(expect2)), "wrong cipher text\n");
4335
4336 /* different initialization vector */
4337 iv[0] = 0x1;
4338 size = 0;
4339 memset(output, 0, sizeof(output));
4340 ret = BCryptEncrypt(key, input, sizeof(input), NULL, iv, sizeof(iv), output, sizeof(output), &size, 0);
4341 ok(!ret, "got %#lx\n", ret);
4342 ok(size == 16, "got %lu\n", size);
4343 ok(!memcmp(output, expect3, sizeof(expect3)), "wrong cipher text\n");
4344
4345 ret = BCryptDestroyKey(key);
4346 ok(!ret, "got %#lx\n", ret);
4347
4348 ret = BCryptCloseAlgorithmProvider(alg, 0);
4349 ok(!ret, "got %#lx\n", ret);
4350}
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
BCRYPT_KEY_DATA_BLOB_MAGIC
#define BCRYPT_KEY_DATA_BLOB_MAGIC
Definition: bcrypt.h:406
BCRYPT_KEY_DATA_BLOB
#define BCRYPT_KEY_DATA_BLOB
Definition: bcrypt.h:72
BCRYPT_KEY_DATA_BLOB_HEADER
struct _BCRYPT_KEY_DATA_BLOB_HEADER BCRYPT_KEY_DATA_BLOB_HEADER
BCRYPT_KEY_DATA_BLOB_VERSION1
#define BCRYPT_KEY_DATA_BLOB_VERSION1
Definition: bcrypt.h:407
BCryptImportKey
NTSTATUS WINAPI BCryptImportKey(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE decrypt_key_handle, const WCHAR *type, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *input, ULONG input_len, ULONG flags)
Definition: bcrypt_main.c:2101
BCryptDestroyKey
NTSTATUS WINAPI BCryptDestroyKey(BCRYPT_KEY_HANDLE handle)
Definition: bcrypt_main.c:4008
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
input
GLenum GLenum GLenum input
Definition: glext.h:9031
expect2
#define expect2(expected1, expected2, got1, got2)
Definition: listview.c:50
_BCRYPT_KEY_DATA_BLOB_HEADER
Definition: bcrypt.h:365
blob
Definition: image.c:229

Referenced by START_TEST().

◆ test_aes_vector_property()

static void test_aes_vector_property ( void  )
static

Definition at line 4352 of file bcrypt.c.

4353{
4354 static const UCHAR secret[] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10};
4355 static const UCHAR vector[] = {0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00};
4356 static const UCHAR expect[] = {0x3e,0xfa,0x1a,0xc8,0x92,0x54,0xe4,0x21,0x1a,0x3d,0xfd,0x42,0x1c,0xc0,0x7d,0x20};
4357 static const UCHAR expect2[] = {0xb0,0xcb,0xf5,0x80,0xd4,0xe3,0x55,0x23,0x6e,0x19,0x5b,0xdb,0xfe,0xe0,0x6c,0xd3};
4358 static UCHAR input[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p'};
4359 UCHAR data[sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + sizeof(secret)];
4360 BCRYPT_KEY_DATA_BLOB_HEADER *blob = (BCRYPT_KEY_DATA_BLOB_HEADER *)data;
4361 UCHAR output[16], iv[16];
4362 BCRYPT_ALG_HANDLE alg;
4363 BCRYPT_KEY_HANDLE key;
4364 ULONG size;
4365 NTSTATUS ret;
4366
4367 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_AES_ALGORITHM, NULL, 0);
4368 ok(!ret, "got %#lx\n", ret);
4369
4370 size = sizeof(BCRYPT_CHAIN_MODE_CBC);
4371 ret = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_CBC, size, 0);
4372 ok(!ret, "got %#lx\n", ret);
4373
4374 blob->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
4375 blob->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
4376 blob->cbKeyData = sizeof(secret);
4377 memcpy(data + sizeof(*blob), secret, sizeof(secret));
4378 size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + sizeof(secret);
4379 ret = BCryptImportKey(alg, NULL, BCRYPT_KEY_DATA_BLOB, &key, NULL, 0, data, size, 0);
4380 ok(!ret, "got %#lx\n", ret);
4381
4382 ret = BCryptSetProperty(key, BCRYPT_INITIALIZATION_VECTOR, (UCHAR *)vector, sizeof(vector) - 1, 0);
4383 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4384
4385 /* the initialization vector can be set on the key instead of being passed to BCryptEncrypt() */
4386 ret = BCryptSetProperty(key, BCRYPT_INITIALIZATION_VECTOR, (UCHAR *)vector, sizeof(vector), 0);
4387 ok(!ret, "got %#lx\n", ret);
4388
4389 size = 0;
4390 memset(output, 0, sizeof(output));
4391 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, output, sizeof(output), &size, 0);
4392 ok(!ret, "got %#lx\n", ret);
4393 ok(size == 16, "got %lu\n", size);
4394 ok(!memcmp(output, expect, sizeof(expect)), "wrong cipher text\n");
4395
4396 /* setting it again restarts the chain instead of continuing it */
4397 ret = BCryptSetProperty(key, BCRYPT_INITIALIZATION_VECTOR, (UCHAR *)vector, sizeof(vector), 0);
4398 ok(!ret, "got %#lx\n", ret);
4399
4400 size = 0;
4401 memset(output, 0, sizeof(output));
4402 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, output, sizeof(output), &size, 0);
4403 ok(!ret, "got %#lx\n", ret);
4404 ok(size == 16, "got %lu\n", size);
4405 ok(!memcmp(output, expect, sizeof(expect)), "wrong cipher text\n");
4406
4407 /* a vector passed to BCryptEncrypt() overrides the one set on the key */
4408 ret = BCryptSetProperty(key, BCRYPT_INITIALIZATION_VECTOR, (UCHAR *)vector, sizeof(vector), 0);
4409 ok(!ret, "got %#lx\n", ret);
4410
4411 size = 0;
4412 memset(iv, 0, sizeof(iv));
4413 memset(output, 0, sizeof(output));
4414 ret = BCryptEncrypt(key, input, sizeof(input), NULL, iv, sizeof(iv), output, sizeof(output), &size, 0);
4415 ok(!ret, "got %#lx\n", ret);
4416 ok(size == 16, "got %lu\n", size);
4417 ok(!memcmp(output, expect2, sizeof(expect2)), "wrong cipher text\n");
4418
4419 /* and the same vector decrypts what it encrypted */
4420 ret = BCryptSetProperty(key, BCRYPT_INITIALIZATION_VECTOR, (UCHAR *)vector, sizeof(vector), 0);
4421 ok(!ret, "got %#lx\n", ret);
4422
4423 size = 0;
4424 memset(output, 0, sizeof(output));
4425 ret = BCryptDecrypt(key, (UCHAR *)expect, sizeof(expect), NULL, NULL, 0, output, sizeof(output), &size, 0);
4426 ok(!ret, "got %#lx\n", ret);
4427 ok(size == 16, "got %lu\n", size);
4428 ok(!memcmp(output, input, sizeof(input)), "wrong plain text\n");
4429
4430 ret = BCryptDestroyKey(key);
4431 ok(!ret, "got %#lx\n", ret);
4432
4433 ret = BCryptCloseAlgorithmProvider(alg, 0);
4434 ok(!ret, "got %#lx\n", ret);
4435}
BCRYPT_INITIALIZATION_VECTOR
#define BCRYPT_INITIALIZATION_VECTOR
Definition: bcrypt.h:60
BCryptDecrypt
NTSTATUS WINAPI BCryptDecrypt(BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG input_len, void *padding, UCHAR *iv, ULONG iv_len, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:1968

Referenced by START_TEST().

◆ test_BCryptDecrypt()

static void test_BCryptDecrypt ( void  )
static

Definition at line 1720 of file bcrypt.c.

1721{
1722 static UCHAR nonce[] =
1723 {0x10,0x20,0x30,0x40,0x50,0x60,0x10,0x20,0x30,0x40,0x50,0x60};
1724 static UCHAR auth_data[] =
1725 {0x60,0x50,0x40,0x30,0x20,0x10,0x60,0x50,0x40,0x30,0x20,0x10};
1726 static UCHAR secret[] =
1727 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
1728 static UCHAR iv[] =
1729 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
1730 static UCHAR expected[] =
1731 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
1732 static UCHAR expected2[] =
1733 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10};
1734 static UCHAR expected3[] =
1735 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
1736 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10};
1737 static UCHAR expected4[] =
1738 {0x28,0x73,0x3d,0xef,0x84,0x8f,0xb0,0xa6,0x5d,0x1a,0x51,0xb7,0xec,0x8f,0xea,0xe9,
1739 0x10,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f};
1740 static UCHAR expected5[] =
1741 {0x29,0x73,0x3d,0xef,0x84,0x8f,0xb0,0xa6,0x5d,0x1a,0x51,0xb7,0xec,0x8f,0xea,0xe9,
1742 0x10,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f};
1743 static UCHAR ciphertext[32] =
1744 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79,
1745 0x28,0x73,0x3d,0xef,0x84,0x8f,0xb0,0xa6,0x5d,0x1a,0x51,0xb7,0xec,0x8f,0xea,0xe9};
1746 static UCHAR ciphertext2[] =
1747 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79,
1748 0x28,0x73,0x3d,0xef,0x84,0x8f,0xb0,0xa6,0x5d,0x1a,0x51,0xb7,0xec,0x8f,0xea,0xe9};
1749 static UCHAR ciphertext3[] =
1750 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79,
1751 0xb1,0xa2,0x92,0x73,0xbe,0x2c,0x42,0x07,0xa5,0xac,0xe3,0x93,0x39,0x8c,0xb6,0xfb,
1752 0x87,0x5d,0xea,0xa3,0x7e,0x0f,0xde,0xfa,0xd9,0xec,0x6c,0x4e,0x3c,0x76,0x86,0xe4};
1753 static UCHAR ciphertext4[] =
1754 {0xe1,0x82,0xc3,0xc0,0x24,0xfb,0x86,0x85,0xf3,0xf1,0x2b,0x7d,0x09,0xb4,0x73,0x67,
1755 0x86,0x64,0xc3,0xfe,0xa3,0x07,0x61,0xf8,0x16,0xc9,0x78,0x7f,0xe7,0xb1,0xc4,0x94};
1756 static UCHAR ciphertext5[] =
1757 {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a,
1758 0x84,0x07,0x66,0xb7,0x49,0xc0,0x9b,0x49,0x74,0x28,0x8c,0x10,0xb9,0xc2,0x09,0x70};
1759 static UCHAR ciphertext6[] =
1760 {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a,
1761 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99,
1762 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99};
1763 static UCHAR tag[] =
1764 {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0};
1765 static UCHAR tag2[] =
1766 {0x17,0x9d,0xc0,0x7a,0xf0,0xcf,0xaa,0xd5,0x1c,0x11,0xc4,0x4b,0xd6,0xa3,0x3e,0x77};
1767 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO auth_info;
1768 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
1769 BCRYPT_AUTH_TAG_LENGTHS_STRUCT tag_lengths;
1770 BCRYPT_ALG_HANDLE aes;
1771 BCRYPT_KEY_HANDLE key;
1772 UCHAR *buf, plaintext[48], ivbuf[16];
1773 ULONG size, len;
1774 NTSTATUS ret;
1775
1776 ret = BCryptOpenAlgorithmProvider(&aes, BCRYPT_AES_ALGORITHM, NULL, 0);
1777 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1778
1779 size = 0;
1780 memset(&key_lengths, 0, sizeof(key_lengths));
1781 ret = BCryptGetProperty(aes, BCRYPT_KEY_LENGTHS, (UCHAR*)&key_lengths, sizeof(key_lengths), &size, 0);
1782 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1783 ok(size == sizeof(key_lengths), "got %lu\n", size);
1784 ok(key_lengths.dwMinLength == 128, "Expected 128, got %lu\n", key_lengths.dwMinLength);
1785 ok(key_lengths.dwMaxLength == 256, "Expected 256, got %lu\n", key_lengths.dwMaxLength);
1786 ok(key_lengths.dwIncrement == 64, "Expected 64, got %lu\n", key_lengths.dwIncrement);
1787
1788 /******************
1789 * AES - CBC mode *
1790 ******************/
1791
1792 len = 0xdeadbeef;
1793 size = sizeof(len);
1794 ret = BCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
1795 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1796
1797 key = NULL;
1798 buf = calloc(1, len);
1799 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
1800 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1801 ok(key != NULL, "key not set\n");
1802
1803 /* input size is a multiple of block size */
1804 size = 0;
1805 memcpy(ivbuf, iv, sizeof(iv));
1806 ret = BCryptDecrypt(key, ciphertext, 32, NULL, ivbuf, 16, NULL, 0, &size, 0);
1807 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1808 ok(size == 32, "got %lu\n", size);
1809 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1810
1811 size = 0;
1812 memcpy(ivbuf, iv, sizeof(iv));
1813 memset(plaintext, 0, sizeof(plaintext));
1814 ret = BCryptDecrypt(key, ciphertext, 32, NULL, ivbuf, 16, plaintext, 32, &size, 0);
1815 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1816 ok(size == 32, "got %lu\n", size);
1817 ok(!memcmp(plaintext, expected, sizeof(expected)), "wrong data\n");
1818 ok(!memcmp(ivbuf, ciphertext + size - sizeof(iv), sizeof(iv)), "wrong iv data.\n");
1819
1820 size = 0;
1821 ++ivbuf[0];
1822 memset(plaintext, 0, sizeof(plaintext));
1823 ret = BCryptDecrypt(key, ciphertext, 32, NULL, ivbuf, 16, plaintext, 32, &size, 0);
1824 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1825 ok(size == 32, "got %lu\n", size);
1826 ok(!memcmp(plaintext, expected5, sizeof(expected)), "wrong data\n");
1827 ok(!memcmp(ivbuf, ciphertext + 32 - 16, sizeof(iv)), "wrong iv data.\n");
1828
1829 size = 0;
1830 memset(plaintext, 0, sizeof(plaintext));
1831 ret = BCryptDecrypt(key, ciphertext, 32, NULL, NULL, 0, plaintext, 32, &size, 0);
1832 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1833 ok(size == 32, "got %lu\n", size);
1834 ok(!memcmp(plaintext, expected4, sizeof(expected4)), "wrong data\n");
1835
1836 /* test with padding smaller than block size */
1837 size = 0;
1838 memcpy(ivbuf, iv, sizeof(iv));
1839 ret = BCryptDecrypt(key, ciphertext2, 32, NULL, ivbuf, 16, NULL, 0, &size, 0);
1840 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1841 ok(size == 32, "got %lu\n", size);
1842 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1843
1844 size = 0;
1845 memcpy(ivbuf, iv, sizeof(iv));
1846 memset(plaintext, 0, sizeof(plaintext));
1847 ret = BCryptDecrypt(key, ciphertext2, 32, NULL, ivbuf, 16, plaintext, 17, &size, BCRYPT_BLOCK_PADDING);
1848 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1849 ok(size == 17, "got %lu\n", size);
1850 ok(!memcmp(plaintext, expected2, sizeof(expected2)), "wrong data\n");
1851 ok(!memcmp(ivbuf, ciphertext2 + 32 - sizeof(iv), sizeof(iv)), "wrong iv data.\n");
1852
1853 size = 0;
1854 memset(plaintext, 0, sizeof(plaintext));
1855 ret = BCryptDecrypt(key, ciphertext2, 32, NULL, ivbuf, 16, plaintext, 17, &size, BCRYPT_BLOCK_PADDING);
1856 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1857 ok(size == 17, "got %lu\n", size);
1858 ok(!memcmp(plaintext, expected4, size), "wrong data\n");
1859 ok(!memcmp(ivbuf, ciphertext2 + 32 - 16, sizeof(iv)), "wrong iv data.\n");
1860
1861 /* test with padding of block size */
1862 size = 0;
1863 memcpy(ivbuf, iv, sizeof(iv));
1864 ret = BCryptDecrypt(key, ciphertext3, 48, NULL, ivbuf, 16, NULL, 0, &size, 0);
1865 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1866 ok(size == 48, "got %lu\n", size);
1867 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1868
1869 size = 0;
1870 memcpy(ivbuf, iv, sizeof(iv));
1871 memset(plaintext, 0, sizeof(plaintext));
1872 ret = BCryptDecrypt(key, ciphertext3, 48, NULL, ivbuf, 16, plaintext, 32, &size, BCRYPT_BLOCK_PADDING);
1873 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1874 ok(size == 32, "got %lu\n", size);
1875 ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n");
1876 ok(!memcmp(ivbuf, ciphertext3 + 48 - 16, sizeof(iv)), "wrong iv data.\n");
1877
1878 /* output size too small */
1879 size = 0;
1880 memcpy(ivbuf, iv, sizeof(iv));
1881 ret = BCryptDecrypt(key, ciphertext, 32, NULL, ivbuf, 16, plaintext, 31, &size, 0);
1882 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1883 ok(size == 32, "got %lu\n", size);
1884
1885 size = 0;
1886 memcpy(ivbuf, iv, sizeof(iv));
1887 ret = BCryptDecrypt(key, ciphertext2, 32, NULL, ivbuf, 16, plaintext, 15, &size, BCRYPT_BLOCK_PADDING);
1888 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1889 ok(size == 32, "got %lu\n", size);
1890
1891 size = 0;
1892 memcpy(ivbuf, iv, sizeof(iv));
1893 ret = BCryptDecrypt(key, ciphertext2, 32, NULL, ivbuf, 16, plaintext, 16, &size, BCRYPT_BLOCK_PADDING);
1894 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1895 ok(size == 17, "got %lu\n", size);
1896
1897 size = 0;
1898 memcpy(ivbuf, iv, sizeof(iv));
1899 ret = BCryptDecrypt(key, ciphertext3, 48, NULL, ivbuf, 16, plaintext, 31, &size, BCRYPT_BLOCK_PADDING);
1900 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1901 ok(size == 48, "got %lu\n", size);
1902
1903 /* input size is not a multiple of block size */
1904 size = 0;
1905 memcpy(ivbuf, iv, sizeof(iv));
1906 ret = BCryptDecrypt(key, ciphertext, 17, NULL, ivbuf, 16, NULL, 0, &size, 0);
1907 ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %#lx\n", ret);
1908 ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %lu\n", size);
1909
1910 /* input size is not a multiple of block size, block padding set */
1911 size = 0;
1912 memcpy(ivbuf, iv, sizeof(iv));
1913 ret = BCryptDecrypt(key, ciphertext, 17, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1914 ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %#lx\n", ret);
1915 ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %lu\n", size);
1916
1917 ret = BCryptDestroyKey(key);
1918 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1919 free(buf);
1920
1921 /******************
1922 * AES - GCM mode *
1923 ******************/
1924
1925 ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_GCM, sizeof(BCRYPT_CHAIN_MODE_GCM), 0);
1926 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1927
1928 key = NULL;
1929 buf = calloc(1, len);
1930 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
1931 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1932 ok(key != NULL, "key not set\n");
1933
1934 ret = BCryptGetProperty(key, BCRYPT_AUTH_TAG_LENGTH, (UCHAR*)&tag_lengths, sizeof(tag_lengths), &size, 0);
1935 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
1936
1937 memset(&auth_info, 0, sizeof(auth_info));
1938 auth_info.cbSize = sizeof(auth_info);
1939 auth_info.dwInfoVersion = 1;
1940 auth_info.pbNonce = nonce;
1941 auth_info.cbNonce = sizeof(nonce);
1942 auth_info.pbTag = tag;
1943 auth_info.cbTag = sizeof(tag);
1944
1945 /* input size is a multiple of block size */
1946 size = 0;
1947 memcpy(ivbuf, iv, sizeof(iv));
1948 memset(plaintext, 0, sizeof(plaintext));
1949 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, ivbuf, 16, plaintext, 32, &size, 0);
1950 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1951 ok(size == 32, "got %lu\n", size);
1952 ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n");
1953 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv.\n");
1954
1955 size = 0;
1956 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, ivbuf, 16, NULL, 0, &size, 0);
1957 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1958 ok(size == 32, "got %lu\n", size);
1959
1960 size = 0;
1961 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, ivbuf, 16, plaintext, 31, &size, 0);
1962 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1963 ok(size == 32, "got %lu\n", size);
1964
1965 size = 0;
1966 memset(plaintext, 0, sizeof(plaintext));
1967 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, NULL, 0, plaintext, 32, &size, 0);
1968 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1969 ok(size == 32, "got %lu\n", size);
1970 ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n");
1971
1972 size = 0;
1973 memcpy(ivbuf, iv, sizeof(iv));
1974 ++ivbuf[0];
1975 memset(plaintext, 0, sizeof(plaintext));
1976 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, ivbuf, 16, plaintext, 32, &size, 0);
1977 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1978 ok(size == 32, "got %lu\n", size);
1979 ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n");
1980 ok(!memcmp(ivbuf + 1, iv + 1, sizeof(iv) - 1), "wrong iv data.\n");
1981 ok(ivbuf[0] == iv[0] + 1, "wrong iv data.\n");
1982
1983 /* test with auth data */
1984 auth_info.pbAuthData = auth_data;
1985 auth_info.cbAuthData = sizeof(auth_data);
1986 auth_info.pbTag = tag2;
1987 auth_info.cbTag = sizeof(tag2);
1988
1989 size = 0;
1990 memcpy(ivbuf, iv, sizeof(iv));
1991 memset(plaintext, 0, sizeof(plaintext));
1992 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, ivbuf, 16, plaintext, 32, &size, 0);
1993 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1994 ok(size == 32, "got %lu\n", size);
1995 ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n");
1996 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv.\n");
1997
1998 /* test with wrong tag */
1999 memcpy(ivbuf, iv, sizeof(iv));
2000 auth_info.pbTag = iv; /* wrong tag */
2001 ret = BCryptDecrypt(key, ciphertext4, 32, &auth_info, ivbuf, 16, plaintext, 32, &size, 0);
2002 ok(ret == STATUS_AUTH_TAG_MISMATCH, "got %#lx\n", ret);
2003 ok(size == 32, "got %lu\n", size);
2004 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
2005
2006 ret = BCryptDestroyKey(key);
2007 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2008 free(buf);
2009
2010 /******************
2011 * AES - ECB mode *
2012 ******************/
2013
2014 ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0);
2015 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2016
2017 len = 0xdeadbeef;
2018 size = sizeof(len);
2019 ret = BCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
2020 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2021
2022 buf = calloc(1, len);
2023 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
2024 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2025
2026 /* initialization vector is not allowed */
2027 size = 0;
2028 memcpy(ivbuf, iv, sizeof(iv));
2029 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, ivbuf, 16, plaintext, 32, &size, 0);
2030 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
2031 ok(size == 32, "got %lu\n", size);
2032
2033 /* input size is a multiple of block size */
2034 size = 0;
2035 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, NULL, 0, &size, 0);
2036 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2037 ok(size == 32, "got %lu\n", size);
2038
2039 size = 0;
2040 memset(plaintext, 0, sizeof(plaintext));
2041 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 32, &size, 0);
2042 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2043 ok(size == 32, "got %lu\n", size);
2044 ok(!memcmp(plaintext, expected, sizeof(expected)), "wrong data\n");
2045
2046 /* test with padding smaller than block size */
2047 size = 0;
2048 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, NULL, 0, &size, 0);
2049 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2050 ok(size == 32, "got %lu\n", size);
2051
2052 size = 0;
2053 memset(plaintext, 0, sizeof(plaintext));
2054 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 17, &size, BCRYPT_BLOCK_PADDING);
2055 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2056 ok(size == 17, "got %lu\n", size);
2057 ok(!memcmp(plaintext, expected2, sizeof(expected2)), "wrong data\n");
2058
2059 /* test with padding of block size */
2060 size = 0;
2061 ret = BCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, NULL, 0, &size, 0);
2062 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2063 ok(size == 48, "got %lu\n", size);
2064
2065 size = 0;
2066 memset(plaintext, 0, sizeof(plaintext));
2067 ret = BCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, plaintext, 32, &size, BCRYPT_BLOCK_PADDING);
2068 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2069 ok(size == 32, "got %lu\n", size);
2070 ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n");
2071
2072 /* output size too small */
2073 size = 0;
2074 ret = BCryptDecrypt(key, ciphertext4, 32, NULL, NULL, 16, plaintext, 31, &size, 0);
2075 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
2076 ok(size == 32, "got %lu\n", size);
2077
2078 size = 0;
2079 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 15, &size, BCRYPT_BLOCK_PADDING);
2080 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
2081 ok(size == 32, "got %lu\n", size);
2082
2083 size = 0;
2084 ret = BCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 16, &size, BCRYPT_BLOCK_PADDING);
2085 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
2086 ok(size == 17, "got %lu\n", size);
2087
2088 size = 0;
2089 ret = BCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, plaintext, 31, &size, BCRYPT_BLOCK_PADDING);
2090 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
2091 ok(size == 48, "got %lu\n", size);
2092
2093 /* input size is not a multiple of block size */
2094 size = 0;
2095 ret = BCryptDecrypt(key, ciphertext4, 17, NULL, NULL, 16, NULL, 0, &size, 0);
2096 ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %#lx\n", ret);
2097 ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %lu\n", size);
2098
2099 /* input size is not a multiple of block size, block padding set */
2100 size = 0;
2101 ret = BCryptDecrypt(key, ciphertext4, 17, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
2102 ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %#lx\n", ret);
2103 ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %lu\n", size);
2104
2105 ret = BCryptDestroyKey(key);
2106 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2107
2108 if (0) {
2109 ret = BCryptDestroyKey(key);
2110 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
2111 }
2112 free(buf);
2113
2114 ret = BCryptDestroyKey(NULL);
2115 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
2116
2117 ret = BCryptCloseAlgorithmProvider(aes, 0);
2118 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2119
2120 ret = BCryptCloseAlgorithmProvider(aes, 0);
2121 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
2122
2123 ret = BCryptCloseAlgorithmProvider(NULL, 0);
2124 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
2125}
broken
#define broken(x)
Definition: atltest.h:178
BCRYPT_AUTH_TAG_LENGTH
#define BCRYPT_AUTH_TAG_LENGTH
Definition: bcrypt.h:52
BCRYPT_BLOCK_PADDING
#define BCRYPT_BLOCK_PADDING
Definition: bcrypt.h:484
BCRYPT_CHAIN_MODE_ECB
#define BCRYPT_CHAIN_MODE_ECB
Definition: bcrypt.h:133
BCryptGenerateSymmetricKey
NTSTATUS WINAPI BCryptGenerateSymmetricKey(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags)
Definition: bcrypt_main.c:1737
free
#define free
Definition: debug_ros.c:5
expected
BOOL expected
Definition: store.c:2000
STATUS_AUTH_TAG_MISMATCH
#define STATUS_AUTH_TAG_MISMATCH
Definition: ntstatus.h:1399
STATUS_INVALID_BUFFER_SIZE
#define STATUS_INVALID_BUFFER_SIZE
Definition: ntstatus.h:772
calloc
#define calloc
Definition: rosglue.h:14

Referenced by START_TEST().

◆ test_BcryptDeriveKeyCapi()

static void test_BcryptDeriveKeyCapi ( void  )
static

Definition at line 4437 of file bcrypt.c.

4438{
4439 static const UCHAR expect[] =
4440 {0xda,0x39,0xa3,0xee,0x5e,0x6b,0x4b,0x0d,0x32,0x55,0xbf,0xef,0x95,0x60,0x18,0x90,0xaf,0xd8,0x07,0x09};
4441 static const UCHAR expect2[] =
4442 {0x9b,0x03,0x17,0x41,0xf4,0x75,0x11,0xac,0xff,0x22,0xee,0x40,0xbb,0xe8,0xf9,0x74,0x17,0x26,0xb6,0xf2,
4443 0xf8,0xc7,0x88,0x02,0x9a,0xdc,0x0d,0xd7,0x83,0x58,0xea,0x65,0x2e,0x8b,0x85,0xc6,0xdb,0xb7,0xed,0x1c};
4444 BCRYPT_ALG_HANDLE alg;
4445 BCRYPT_HASH_HANDLE hash;
4446 UCHAR key[40];
4447 NTSTATUS ret;
4448
4449 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, NULL, 0);
4450 ok(!ret, "got %#lx\n", ret);
4451
4452 ret = BCryptCreateHash(alg, &hash, NULL, 0, NULL, 0, 0);
4453 ok(!ret, "got %#lx\n", ret);
4454
4455 ret = BCryptDeriveKeyCapi(NULL, NULL, NULL, 0, 0);
4456 ok(ret == STATUS_INVALID_PARAMETER || ret == STATUS_INVALID_HANDLE /* win7 */, "got %#lx\n", ret);
4457
4458 ret = BCryptDeriveKeyCapi(hash, NULL, NULL, 0, 0);
4459 ok(ret == STATUS_INVALID_PARAMETER || !ret /* win7 */, "got %#lx\n", ret);
4460
4461 ret = BCryptDestroyHash(hash);
4462 ok(!ret, "got %#lx\n", ret);
4463
4464 ret = BCryptCreateHash(alg, &hash, NULL, 0, NULL, 0, 0);
4465 ok(!ret, "got %#lx\n", ret);
4466
4467 ret = BCryptDeriveKeyCapi(hash, NULL, key, 0, 0);
4468 ok(ret == STATUS_INVALID_PARAMETER || !ret /* win7 */, "got %#lx\n", ret);
4469
4470 ret = BCryptDestroyHash(hash);
4471 ok(!ret, "got %#lx\n", ret);
4472
4473 ret = BCryptCreateHash(alg, &hash, NULL, 0, NULL, 0, 0);
4474 ok(!ret, "got %#lx\n", ret);
4475
4476 memset(key, 0, sizeof(key));
4477 ret = BCryptDeriveKeyCapi(hash, NULL, key, 41, 0);
4478 ok(ret == STATUS_INVALID_PARAMETER || !ret /* win7 */, "got %#lx\n", ret);
4479 if (!ret)
4480 ok(!memcmp(key, expect, sizeof(expect) - 1), "wrong key data\n");
4481
4482 ret = BCryptDestroyHash(hash);
4483 ok(!ret, "got %#lx\n", ret);
4484
4485 ret = BCryptCreateHash(alg, &hash, NULL, 0, NULL, 0, 0);
4486 ok(!ret, "got %#lx\n", ret);
4487
4488 memset(key, 0, sizeof(key));
4489 ret = BCryptDeriveKeyCapi(hash, NULL, key, 20, 0);
4490 ok(!ret, "got %#lx\n", ret);
4491 ok(!memcmp(key, expect, sizeof(expect) - 1), "wrong key data\n");
4492
4493 ret = BCryptDeriveKeyCapi(hash, NULL, key, 20, 0);
4494 todo_wine ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4495
4496 ret = BCryptHashData(hash, NULL, 0, 0);
4497 todo_wine ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4498
4499 ret = BCryptDestroyHash(hash);
4500 ok(!ret, "got %#lx\n", ret);
4501
4502 ret = BCryptCreateHash(alg, &hash, NULL, 0, NULL, 0, 0);
4503 ok(!ret, "got %#lx\n", ret);
4504
4505 ret = BCryptHashData(hash, (UCHAR *)"test", 4, 0);
4506 ok(!ret, "got %#lx\n", ret);
4507
4508 /* padding */
4509 memset(key, 0, sizeof(key));
4510 ret = BCryptDeriveKeyCapi(hash, NULL, key, 40, 0);
4511 ok(!ret, "got %#lx\n", ret);
4512 ok(!memcmp(key, expect2, sizeof(expect2) - 1), "wrong key data\n");
4513
4514 ret = BCryptCloseAlgorithmProvider(alg, 0);
4515 ok(!ret, "got %#lx\n", ret);
4516}
BCRYPT_SHA1_ALGORITHM
#define BCRYPT_SHA1_ALGORITHM
Definition: bcrypt.h:119
BCryptHashData
NTSTATUS WINAPI BCryptHashData(BCRYPT_HASH_HANDLE handle, UCHAR *input, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1503
BCryptCreateHash
NTSTATUS WINAPI BCryptCreateHash(BCRYPT_ALG_HANDLE handle, BCRYPT_HASH_HANDLE *ret_handle, UCHAR *object, ULONG object_len, UCHAR *secret, ULONG secret_len, ULONG flags)
Definition: bcrypt_main.c:1416
BCryptDestroyHash
NTSTATUS WINAPI BCryptDestroyHash(BCRYPT_HASH_HANDLE handle)
Definition: bcrypt_main.c:1483
BCryptDeriveKeyCapi
NTSTATUS WINAPI BCryptDeriveKeyCapi(BCRYPT_HASH_HANDLE handle, BCRYPT_ALG_HANDLE halg, UCHAR *key, ULONG keylen, ULONG flags)
Definition: bcrypt_main.c:4021
todo_wine
#define todo_wine
Definition: minitest.h:80

Referenced by START_TEST().

◆ test_BcryptDeriveKeyPBKDF2()

static void test_BcryptDeriveKeyPBKDF2 ( void  )
static

Definition at line 529 of file bcrypt.c.

530{
531 BCRYPT_ALG_HANDLE alg;
532 UCHAR buf[25];
533 char str[51];
534 NTSTATUS ret;
535 ULONG i;
536
537 alg = NULL;
538 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_SHA1_ALGORITHM, MS_PRIMITIVE_PROVIDER,
539 BCRYPT_ALG_HANDLE_HMAC_FLAG);
540 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
541 ok(alg != NULL, "alg not set\n");
542
543 test_hash_length(alg, 20);
544 test_alg_name(alg, L"SHA1");
545
546 ret = BCryptDeriveKeyPBKDF2(alg, rfc6070[0].pwd, rfc6070[0].pwd_len, rfc6070[0].salt, rfc6070[0].salt_len,
547 0, buf, rfc6070[0].dk_len, 0);
548 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
549
550 for (i = 0; i < ARRAY_SIZE(rfc6070); i++)
551 {
552 memset(buf, 0, sizeof(buf));
553 ret = BCryptDeriveKeyPBKDF2(alg, rfc6070[i].pwd, rfc6070[i].pwd_len, rfc6070[i].salt, rfc6070[i].salt_len,
554 rfc6070[i].iterations, buf, rfc6070[i].dk_len, 0);
555 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
556 format_hash(buf, rfc6070[i].dk_len, str);
557 ok(!memcmp(str, rfc6070[i].dk, rfc6070[i].dk_len), "got %s\n", str);
558 }
559
560 ret = BCryptCloseAlgorithmProvider(alg, 0);
561 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
562
563 if (pBCryptHash)
564 {
565 ret = BCryptDeriveKeyPBKDF2(BCRYPT_HMAC_SHA1_ALG_HANDLE, rfc6070[0].pwd, rfc6070[0].pwd_len, rfc6070[0].salt,
566 rfc6070[0].salt_len, 1, buf, rfc6070[0].dk_len, 0);
567 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
568 }
569}
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
pwd_len
ULONG pwd_len
Definition: bcrypt.c:511
iterations
ULONGLONG iterations
Definition: bcrypt.c:513
dk
const UCHAR * dk
Definition: bcrypt.c:517
pwd
UCHAR * pwd
Definition: bcrypt.c:515
rfc6070
static const struct @1909 rfc6070[]
test_hash_length
#define test_hash_length(a, b)
Definition: bcrypt.c:157
dk_len
ULONG dk_len
Definition: bcrypt.c:514
format_hash
static void format_hash(const UCHAR *bytes, ULONG size, char *buf)
Definition: bcrypt.c:110
salt_len
ULONG salt_len
Definition: bcrypt.c:512
salt
static UCHAR salt[]
Definition: bcrypt.c:495
BCRYPT_HMAC_SHA1_ALG_HANDLE
#define BCRYPT_HMAC_SHA1_ALG_HANDLE
Definition: bcrypt.h:426
BCRYPT_ALG_HANDLE_HMAC_FLAG
#define BCRYPT_ALG_HANDLE_HMAC_FLAG
Definition: bcrypt.h:481
BCryptDeriveKeyPBKDF2
NTSTATUS WINAPI BCryptDeriveKeyPBKDF2(BCRYPT_ALG_HANDLE handle, UCHAR *pwd, ULONG pwd_len, UCHAR *salt, ULONG salt_len, ULONGLONG iterations, UCHAR *key, ULONG key_len, ULONG flags)
Definition: bcrypt_main.c:4153
str
const WCHAR * str
Definition: rpc_transport.c:2696

Referenced by START_TEST().

◆ test_BCryptEncrypt()

static void test_BCryptEncrypt ( void  )
static

Definition at line 1051 of file bcrypt.c.

1052{
1053 static UCHAR nonce[] =
1054 {0x10,0x20,0x30,0x40,0x50,0x60,0x10,0x20,0x30,0x40,0x50,0x60};
1055 static UCHAR auth_data[] =
1056 {0x60,0x50,0x40,0x30,0x20,0x10,0x60,0x50,0x40,0x30,0x20,0x10};
1057 static UCHAR secret[] =
1058 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
1059 static UCHAR secret256[] =
1060 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
1061 0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00};
1062 static UCHAR iv[] =
1063 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
1064 static UCHAR data[] =
1065 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10};
1066 static UCHAR data2[] =
1067 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
1068 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10};
1069 static UCHAR expected[] =
1070 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79};
1071 static UCHAR expected2[] =
1072 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79,
1073 0x28,0x73,0x3d,0xef,0x84,0x8f,0xb0,0xa6,0x5d,0x1a,0x51,0xb7,0xec,0x8f,0xea,0xe9};
1074 static UCHAR expected3[] =
1075 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79,
1076 0xb1,0xa2,0x92,0x73,0xbe,0x2c,0x42,0x07,0xa5,0xac,0xe3,0x93,0x39,0x8c,0xb6,0xfb,
1077 0x87,0x5d,0xea,0xa3,0x7e,0x0f,0xde,0xfa,0xd9,0xec,0x6c,0x4e,0x3c,0x76,0x86,0xe4};
1078 static UCHAR expected4[] =
1079 {0xe1,0x82,0xc3,0xc0,0x24,0xfb,0x86,0x85,0xf3,0xf1,0x2b,0x7d,0x09,0xb4,0x73,0x67,
1080 0x86,0x64,0xc3,0xfe,0xa3,0x07,0x61,0xf8,0x16,0xc9,0x78,0x7f,0xe7,0xb1,0xc4,0x94};
1081 static UCHAR expected5[] =
1082 {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a};
1083 static UCHAR expected6[] =
1084 {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a,
1085 0x84,0x07,0x66,0xb7,0x49,0xc0,0x9b,0x49,0x74,0x28,0x8c,0x10,0xb9,0xc2,0x09,0x70};
1086 static UCHAR expected7[] =
1087 {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a,
1088 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99,
1089 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99};
1090 static UCHAR expected8[] =
1091 {0xb5,0x8a,0x10,0x64,0xd8,0xac,0xa9,0x9b,0xd9,0xb0,0x40,0x5b,0x85,0x45,0xf5,0xbb};
1092 static UCHAR expected9[] =
1093 {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a};
1094 static UCHAR expected10[] =
1095 {0x66,0xb8,0xbd,0xe5,0x90,0x6c,0xec,0xdf,0xfa,0x8a,0xb2,0xfd,0x92,0x84,0xeb,0xf0,
1096 0x95,0xc4,0xdf,0xa7,0x7a,0x62,0xe4,0xab,0xd4,0x0e,0x94,0x4e,0xd7,0x6e,0xa1,0x47,
1097 0x29,0x4b,0x37,0xfe,0x28,0x6d,0x5f,0x69,0x46,0x30,0x73,0xc0,0xaa,0x42,0xe4,0x46};
1098 static UCHAR expected11[] =
1099 {0x0a,0x22,0xf7,0x96,0xe1,0xb9,0x3e,0x90,0x32,0xcf,0xf8,0x04,0x83,0x8a,0xdf,0xc3};
1100 static UCHAR expected12[] =
1101 {0xb5,0x9d,0xe7,0x8e,0x0f,0x80,0x16,0xc3,0xf6,0x80,0xad,0xf8,0xac,0xef,0xf9,0x9f};
1102 static UCHAR expected13[] =
1103 {0xc6,0x41,0x37,0xd8,0x6f,0x65,0x64,0x1d,0x2b,0xa0,0xad,0xee,0x67,0xba,0x9b,0x5f};
1104 static UCHAR expected14[] =
1105 {0x0a,0x22,0xf7,0x96,0xe1,0xb9,0x3e,0x90,0x32,0xcf,0xf8,0x04,0x83,0x8a,0xdf,0xc3,
1106 0xa5,0xfa,0x54,0xd7,0x62,0x9d,0x8b,0x11,0x3d,0xd8,0xe2,0x95,0xc2,0x23,0x3f,0x29};
1107 static UCHAR expected15[] =
1108 {0x0a,0x22,0xf7,0x96,0xe1,0xb9,0x3e,0x90,0x32,0xcf,0xf8,0x04,0x83,0x8a,0xdf,0xc3,
1109 0xa5,0xe5,0xcd,0x29,0x48,0x37,0x3f,0x92,0x6f,0x09,0x84,0x5a,0xb8,0x88,0xda,0xfd,
1110 0x65,0x00,0x20,0x9a,0xc6,0xdb,0xfa,0x82,0xdb,0xbc,0xf4,0x70,0x7d,0x88,0x86,0xb5};
1111 static UCHAR expected16[] =
1112 {0x64,0xff,0xc6,0x97,0x14,0x5e,0x21,0xfa,0xe8,0x6e,0xba,0xc1,0x0c,0xb1,0x72,0x64,
1113 0x5d,0xf0,0x22,0x72,0xef,0x39,0xe3,0x2f,0x80,0x3e,0x53,0x00,0xc1,0xcf,0x3f,0xbb,
1114 0xea,0x30,0x01,0x78,0x3b,0xba,0x4d,0xca,0xa0,0x2e,0x83,0x5e,0x0e,0xe2,0x65,0xcb};
1115 static UCHAR expected_tag[] =
1116 {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0};
1117 static UCHAR expected_tag2[] =
1118 {0x9a,0x92,0x32,0x2c,0x61,0x2a,0xae,0xef,0x66,0x2a,0xfb,0x55,0xe9,0x48,0xdf,0xbd};
1119 static UCHAR expected_tag3[] =
1120 {0x17,0x9d,0xc0,0x7a,0xf0,0xcf,0xaa,0xd5,0x1c,0x11,0xc4,0x4b,0xd6,0xa3,0x3e,0x77};
1121 static UCHAR expected_tag4[] =
1122 {0x4c,0x42,0x83,0x9e,0x8d,0x40,0xf1,0x19,0xd6,0x2b,0x1c,0x66,0x03,0x2b,0x39,0x63};
1123
1124 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO auth_info;
1125 UCHAR *buf, ciphertext[48], ivbuf[16], tag[16];
1126 BCRYPT_AUTH_TAG_LENGTHS_STRUCT tag_length;
1127 ULONG size, len, i, test;
1128 BCRYPT_ALG_HANDLE aes;
1129 BCRYPT_KEY_HANDLE key;
1130 HANDLE hthread;
1131 NTSTATUS ret;
1132
1133 ret = BCryptOpenAlgorithmProvider(&aes, BCRYPT_AES_ALGORITHM, NULL, 0);
1134 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1135
1136 /******************
1137 * AES - CBC mode *
1138 ******************/
1139
1140 len = 0xdeadbeef;
1141 size = sizeof(len);
1142 ret = BCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
1143 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1144
1145 key = NULL;
1146 buf = calloc(1, len);
1147 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
1148 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1149 ok(key != NULL, "key not set\n");
1150
1151 /* input size is a multiple of block size */
1152 size = 0;
1153 memcpy(ivbuf, iv, sizeof(iv));
1154 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, NULL, 0, &size, 0);
1155 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1156 ok(size == 16, "got %lu\n", size);
1157 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1158
1159 size = 0;
1160 memcpy(ivbuf, iv, sizeof(iv));
1161 memset(ciphertext, 0, sizeof(ciphertext));
1162 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
1163 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1164 ok(size == 16, "got %lu\n", size);
1165 ok(!memcmp(ciphertext, expected, sizeof(expected)), "wrong data\n");
1166 for (i = 0; i < 16; i++)
1167 ok(ciphertext[i] == expected[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected[i]);
1168 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
1169
1170 /* NULL initialization vector */
1171 size = 0;
1172 memset(ciphertext, 0, sizeof(ciphertext));
1173 ret = BCryptEncrypt(key, data, 16, NULL, NULL, 0, ciphertext, 16, &size, 0);
1174 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1175 ok(size == 16, "got %lu\n", size);
1176 ok(!memcmp(ciphertext, expected8, sizeof(expected8)), "wrong data\n");
1177
1178 /* all zero initialization vector */
1179 size = 0;
1180 memset(ciphertext, 0, sizeof(ciphertext));
1181 memset(ivbuf, 0, sizeof(ivbuf));
1182 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
1183 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1184 ok(size == 16, "got %lu\n", size);
1185 ok(!memcmp(ciphertext, expected9, sizeof(expected9)), "wrong data\n");
1186 for (i = 0; i < 16; i++)
1187 ok(ciphertext[i] == expected9[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected9[i]);
1188 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
1189
1190 /* input size is not a multiple of block size */
1191 size = 0;
1192 memcpy(ivbuf, iv, sizeof(iv));
1193 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, NULL, 0, &size, 0);
1194 ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %#lx\n", ret);
1195 ok(size == 17, "got %lu\n", size);
1196
1197 /* input size is not a multiple of block size, block padding set */
1198 size = 0;
1199 memcpy(ivbuf, iv, sizeof(iv));
1200 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1201 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1202 ok(size == 32, "got %lu\n", size);
1203 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1204
1205 size = 0;
1206 memcpy(ivbuf, iv, sizeof(iv));
1207 memset(ciphertext, 0, sizeof(ciphertext));
1208 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1209 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1210 ok(size == 32, "got %lu\n", size);
1211 ok(!memcmp(ciphertext, expected2, sizeof(expected2)), "wrong data\n");
1212 for (i = 0; i < 32; i++)
1213 ok(ciphertext[i] == expected2[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected2[i]);
1214 ok(!memcmp(ivbuf, ciphertext + 32 - 16, sizeof(iv)), "wrong iv data.\n");
1215
1216 /* input size is a multiple of block size, block padding set */
1217 size = 0;
1218 memcpy(ivbuf, iv, sizeof(iv));
1219 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1220 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1221 ok(size == 48, "got %lu\n", size);
1222 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1223
1224 size = 0;
1225 memcpy(ivbuf, iv, sizeof(iv));
1226 memset(ciphertext, 0, sizeof(ciphertext));
1227 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING);
1228 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1229 ok(size == 48, "got %lu\n", size);
1230 ok(!memcmp(ciphertext, expected3, sizeof(expected3)), "wrong data\n");
1231 for (i = 0; i < 48; i++)
1232 ok(ciphertext[i] == expected3[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected3[i]);
1233 ok(!memcmp(ivbuf, ciphertext + 48 - 16, sizeof(iv)), "wrong iv data.\n");
1234
1235 /* output size too small */
1236 size = 0;
1237 memcpy(ivbuf, iv, sizeof(iv));
1238 memset(ciphertext, 0, sizeof(ciphertext));
1239 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, ciphertext, 31, &size, BCRYPT_BLOCK_PADDING);
1240 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1241 ok(size == 32, "got %lu\n", size);
1242
1243 size = 0;
1244 memcpy(ivbuf, iv, sizeof(iv));
1245 memset(ciphertext, 0, sizeof(ciphertext));
1246 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1247 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1248 ok(size == 48, "got %lu\n", size);
1249
1250 ret = BCryptDestroyKey(key);
1251 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1252 free(buf);
1253
1254 /* 256 bit key */
1255 buf = calloc(1, len);
1256
1257 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret256, sizeof(secret256), 0);
1258 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1259 ret = BCryptDestroyKey(key);
1260 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1261
1262 /* Key generations succeeds if the key size exceeds maximum and uses maximum key length
1263 * from secret. */
1264 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret256, sizeof(secret256) + 1, 0);
1265 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1266
1267 size = 0;
1268 memcpy(ivbuf, iv, sizeof(iv));
1269 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1270 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1271 ok(size == 48, "got %lu\n", size);
1272 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1273
1274 size = 0;
1275 memcpy(ivbuf, iv, sizeof(iv));
1276 memset(ciphertext, 0, sizeof(ciphertext));
1277 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING);
1278 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1279 ok(size == 48, "got %lu\n", size);
1280 ok(!memcmp(ciphertext, expected10, sizeof(expected10)), "wrong data\n");
1281 for (i = 0; i < 48; i++)
1282 ok(ciphertext[i] == expected10[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected10[i]);
1283 ok(!memcmp(ivbuf, ciphertext + 48 - 16, sizeof(iv)), "wrong iv data.\n");
1284
1285 ret = BCryptDestroyKey(key);
1286 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1287 free(buf);
1288
1289 /******************
1290 * AES - GCM mode *
1291 ******************/
1292
1293 size = 0;
1294 ret = BCryptGetProperty(aes, BCRYPT_AUTH_TAG_LENGTH, NULL, 0, &size, 0);
1295 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
1296
1297 ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_GCM, sizeof(BCRYPT_CHAIN_MODE_GCM), 0);
1298 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1299
1300 size = 0;
1301 ret = BCryptGetProperty(aes, BCRYPT_AUTH_TAG_LENGTH, NULL, 0, &size, 0);
1302 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1303 ok(size == sizeof(tag_length), "got %lu\n", size);
1304
1305 size = 0;
1306 memset(&tag_length, 0, sizeof(tag_length));
1307 ret = BCryptGetProperty(aes, BCRYPT_AUTH_TAG_LENGTH, (UCHAR*)&tag_length, sizeof(tag_length), &size, 0);
1308 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1309 ok(size == sizeof(tag_length), "got %lu\n", size);
1310 ok(tag_length.dwMinLength == 12, "Expected 12, got %lu\n", tag_length.dwMinLength);
1311 ok(tag_length.dwMaxLength == 16, "Expected 16, got %lu\n", tag_length.dwMaxLength);
1312 ok(tag_length.dwIncrement == 1, "Expected 1, got %lu\n", tag_length.dwIncrement);
1313
1314 len = 0xdeadbeef;
1315 size = sizeof(len);
1316 ret = BCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
1317 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1318
1319 key = NULL;
1320 buf = calloc(1, len);
1321 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
1322 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1323 ok(key != NULL, "key not set\n");
1324
1325 ret = BCryptGetProperty(key, BCRYPT_AUTH_TAG_LENGTH, (UCHAR*)&tag_length, sizeof(tag_length), &size, 0);
1326 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
1327
1328 memset(&auth_info, 0, sizeof(auth_info));
1329 auth_info.cbSize = sizeof(auth_info);
1330 auth_info.dwInfoVersion = 1;
1331 auth_info.pbNonce = nonce;
1332 auth_info.cbNonce = sizeof(nonce);
1333 auth_info.pbTag = tag;
1334 auth_info.cbTag = sizeof(tag);
1335
1336 /* input size is a multiple of block size */
1337 size = 0;
1338 memcpy(ivbuf, iv, sizeof(iv));
1339 memset(ciphertext, 0xff, sizeof(ciphertext));
1340 memset(tag, 0xff, sizeof(tag));
1341 ret = BCryptEncrypt(key, data2, 32, &auth_info, ivbuf, 16, ciphertext, 32, &size, 0);
1342 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1343 ok(size == 32, "got %lu\n", size);
1344 ok(!memcmp(ciphertext, expected4, sizeof(expected4)), "wrong data\n");
1345 ok(!memcmp(tag, expected_tag, sizeof(expected_tag)), "wrong tag\n");
1346 for (i = 0; i < 32; i++)
1347 ok(ciphertext[i] == expected4[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1348 for (i = 0; i < 16; i++)
1349 ok(tag[i] == expected_tag[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag[i]);
1350 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1351
1352 ret = BCryptEncrypt(key, data2, 32, &auth_info, ivbuf, 16, ciphertext, 31, &size, 0);
1353 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1354
1355 /* NULL initialization vector */
1356 size = 0;
1357 memset(ciphertext, 0xff, sizeof(ciphertext));
1358 memset(tag, 0xff, sizeof(tag));
1359 ret = BCryptEncrypt(key, data2, 32, &auth_info, NULL, 0, ciphertext, 32, &size, 0);
1360 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1361 ok(size == 32, "got %lu\n", size);
1362 ok(!memcmp(ciphertext, expected4, sizeof(expected4)), "wrong data\n");
1363 ok(!memcmp(tag, expected_tag, sizeof(expected_tag)), "wrong tag\n");
1364 for (i = 0; i < 32; i++)
1365 ok(ciphertext[i] == expected4[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1366 for (i = 0; i < 16; i++)
1367 ok(tag[i] == expected_tag[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag[i]);
1368
1369 /* all zero initialization vector */
1370 size = 0;
1371 memset(ciphertext, 0xff, sizeof(ciphertext));
1372 memset(tag, 0xff, sizeof(tag));
1373 memset(ivbuf, 0, sizeof(ivbuf));
1374 ret = BCryptEncrypt(key, data2, 32, &auth_info, ivbuf, 16, ciphertext, 32, &size, 0);
1375 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1376 ok(size == 32, "got %lu\n", size);
1377 ok(!memcmp(ciphertext, expected4, sizeof(expected4)), "wrong data\n");
1378 ok(!memcmp(tag, expected_tag, sizeof(expected_tag)), "wrong tag\n");
1379 for (i = 0; i < 32; i++)
1380 ok(ciphertext[i] == expected4[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1381 for (i = 0; i < 16; i++)
1382 ok(tag[i] == expected_tag[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag[i]);
1383 memset(ciphertext, 0, sizeof(iv));
1384 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
1385
1386 /* input size is not multiple of block size */
1387 size = 0;
1388 memcpy(ivbuf, iv, sizeof(iv));
1389 memset(ciphertext, 0xff, sizeof(ciphertext));
1390 memset(tag, 0xff, sizeof(tag));
1391 ret = BCryptEncrypt(key, data2, 24, &auth_info, ivbuf, 16, ciphertext, 24, &size, 0);
1392 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1393 ok(size == 24, "got %lu\n", size);
1394 ok(!memcmp(ciphertext, expected4, 24), "wrong data\n");
1395 ok(!memcmp(tag, expected_tag2, sizeof(expected_tag2)), "wrong tag\n");
1396 for (i = 0; i < 24; i++)
1397 ok(ciphertext[i] == expected4[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1398 for (i = 0; i < 16; i++)
1399 ok(tag[i] == expected_tag2[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag2[i]);
1400 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1401
1402 /* test with auth data */
1403 auth_info.pbAuthData = auth_data;
1404 auth_info.cbAuthData = sizeof(auth_data);
1405
1406 size = 0;
1407 memcpy(ivbuf, iv, sizeof(iv));
1408 memset(ciphertext, 0xff, sizeof(ciphertext));
1409 memset(tag, 0xff, sizeof(tag));
1410 ret = BCryptEncrypt(key, data2, 32, &auth_info, ivbuf, 16, ciphertext, 32, &size, 0);
1411 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1412 ok(size == 32, "got %lu\n", size);
1413 ok(!memcmp(ciphertext, expected4, sizeof(expected4)), "wrong data\n");
1414 ok(!memcmp(tag, expected_tag3, sizeof(expected_tag3)), "wrong tag\n");
1415 for (i = 0; i < 32; i++)
1416 ok(ciphertext[i] == expected4[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1417 for (i = 0; i < 16; i++)
1418 ok(tag[i] == expected_tag3[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag3[i]);
1419 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1420
1421 memset(tag, 0xff, sizeof(tag));
1422 ret = BCryptEncrypt(key, data2, 0, &auth_info, ivbuf, 16, NULL, 0, &size, 0);
1423 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1424 ok(!size, "got %lu\n", size);
1425 for (i = 0; i < 16; i++)
1426 ok(tag[i] == 0xff, "%lu: %02x != %02x\n", i, tag[i], 0xff);
1427
1428 memset(tag, 0xff, sizeof(tag));
1429 ret = BCryptEncrypt(key, NULL, 0, &auth_info, ivbuf, 16, NULL, 0, &size, 0);
1430 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1431 ok(!size, "got %lu\n", size);
1432 ok(!memcmp(tag, expected_tag4, sizeof(expected_tag4)), "wrong tag\n");
1433 for (i = 0; i < 16; i++)
1434 ok(tag[i] == expected_tag4[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag4[i]);
1435
1436 /* test with padding */
1437 memcpy(ivbuf, iv, sizeof(iv));
1438 memset(ciphertext, 0, sizeof(ciphertext));
1439 ret = BCryptEncrypt(key, data2, 32, &auth_info, ivbuf, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1440 todo_wine ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1441
1442 memcpy(ivbuf, iv, sizeof(iv));
1443 memset(ciphertext, 0, sizeof(ciphertext));
1444 ret = BCryptEncrypt(key, data2, 32, &auth_info, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING);
1445 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
1446
1447 /* race test */
1448
1449 encrypt_race_start_barrier = 0;
1450 hthread = CreateThread(NULL, 0, encrypt_race_thread, key, 0, NULL);
1451
1452 while (InterlockedCompareExchange(&encrypt_race_start_barrier, 2, 1) != 1)
1453 ;
1454
1455 for (test = 0; test < RACE_TEST_COUNT; ++test)
1456 {
1457 size = 0;
1458 memset(ciphertext, 0xff, sizeof(ciphertext));
1459 memset(tag, 0xff, sizeof(tag));
1460 ret = BCryptEncrypt(key, data2, 32, &auth_info, NULL, 0, ciphertext, 32, &size, 0);
1461 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1462 ok(size == 32, "got %lu\n", size);
1463 ok(!memcmp(ciphertext, expected4, sizeof(expected4)), "wrong data\n");
1464 ok(!memcmp(tag, expected_tag3, sizeof(expected_tag2)), "wrong tag\n");
1465 for (i = 0; i < 32; i++)
1466 ok(ciphertext[i] == expected4[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected4[i]);
1467 for (i = 0; i < 16; i++)
1468 ok(tag[i] == expected_tag3[i], "%lu: %02x != %02x\n", i, tag[i], expected_tag3[i]);
1469 }
1470
1471 WaitForSingleObject(hthread, INFINITE);
1472
1473 ret = BCryptDestroyKey(key);
1474 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1475 free(buf);
1476
1477 /******************
1478 * AES - ECB mode *
1479 ******************/
1480
1481 ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0);
1482 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1483
1484 len = 0xdeadbeef;
1485 size = sizeof(len);
1486 ret = BCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
1487 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1488
1489 buf = calloc(1, len);
1490 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
1491 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1492
1493 /* initialization vector is not allowed */
1494 size = 0;
1495 memcpy(ivbuf, iv, sizeof(iv));
1496 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
1497 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
1498 ok(size == 16, "got %lu\n", size);
1499
1500 /* input size is a multiple of block size */
1501 size = 0;
1502 ret = BCryptEncrypt(key, data, 16, NULL, NULL, 16, NULL, 0, &size, 0);
1503 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1504 ok(size == 16, "got %lu\n", size);
1505
1506 size = 0;
1507 memset(ciphertext, 0, sizeof(ciphertext));
1508 ret = BCryptEncrypt(key, data, 16, NULL, NULL, 16, ciphertext, 16, &size, 0);
1509 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1510 ok(size == 16, "got %lu\n", size);
1511 ok(!memcmp(ciphertext, expected5, sizeof(expected5)), "wrong data\n");
1512 for (i = 0; i < 16; i++)
1513 ok(ciphertext[i] == expected5[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected5[i]);
1514
1515 /* input size is not a multiple of block size */
1516 size = 0;
1517 ret = BCryptEncrypt(key, data, 17, NULL, NULL, 16, NULL, 0, &size, 0);
1518 ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %#lx\n", ret);
1519 ok(size == 17, "got %lu\n", size);
1520
1521 /* input size is not a multiple of block size, block padding set */
1522 size = 0;
1523 ret = BCryptEncrypt(key, data, 17, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1524 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1525 ok(size == 32, "got %lu\n", size);
1526
1527 size = 0;
1528 memset(ciphertext, 0, sizeof(ciphertext));
1529 ret = BCryptEncrypt(key, data, 17, NULL, NULL, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1530 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1531 ok(size == 32, "got %lu\n", size);
1532 ok(!memcmp(ciphertext, expected6, sizeof(expected6)), "wrong data\n");
1533 for (i = 0; i < 32; i++)
1534 ok(ciphertext[i] == expected6[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected6[i]);
1535
1536 /* input size is a multiple of block size, block padding set */
1537 size = 0;
1538 ret = BCryptEncrypt(key, data2, 32, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1539 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1540 ok(size == 48, "got %lu\n", size);
1541
1542 size = 0;
1543 memset(ciphertext, 0, sizeof(ciphertext));
1544 ret = BCryptEncrypt(key, data2, 32, NULL, NULL, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING);
1545 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1546 ok(size == 48, "got %lu\n", size);
1547 ok(!memcmp(ciphertext, expected7, sizeof(expected7)), "wrong data\n");
1548 for (i = 0; i < 48; i++)
1549 ok(ciphertext[i] == expected7[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected7[i]);
1550
1551 /* output size too small */
1552 size = 0;
1553 memset(ciphertext, 0, sizeof(ciphertext));
1554 ret = BCryptEncrypt(key, data, 17, NULL, NULL, 16, ciphertext, 31, &size, BCRYPT_BLOCK_PADDING);
1555 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1556 ok(size == 32, "got %lu\n", size);
1557
1558 size = 0;
1559 memset(ciphertext, 0, sizeof(ciphertext));
1560 ret = BCryptEncrypt(key, data2, 32, NULL, NULL, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1561 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1562 ok(size == 48, "got %lu\n", size);
1563
1564 ret = BCryptDestroyKey(key);
1565 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1566 free(buf);
1567
1568 /******************
1569 * AES - CFB mode *
1570 ******************/
1571
1572 ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_CFB, sizeof(BCRYPT_CHAIN_MODE_CFB), 0);
1573 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1574
1575 key = NULL;
1576 buf = calloc(1, len);
1577 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
1578 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1579 ok(key != NULL, "key not set\n");
1580
1581 /* input size is a multiple of block size */
1582 size = 0;
1583 memcpy(ivbuf, iv, sizeof(iv));
1584 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, NULL, 0, &size, 0);
1585 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1586 ok(size == 16, "got %lu\n", size);
1587 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1588
1589 size = 0;
1590 memcpy(ivbuf, iv, sizeof(iv));
1591 memset(ciphertext, 0, sizeof(ciphertext));
1592 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
1593 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1594 ok(size == 16, "got %lu\n", size);
1595 ok(!memcmp(ciphertext, expected11, sizeof(expected11)), "wrong data\n");
1596 for (i = 0; i < 16; i++)
1597 ok(ciphertext[i] == expected11[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected11[i]);
1598 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
1599
1600 /* NULL initialization vector */
1601 size = 0;
1602 memset(ciphertext, 0, sizeof(ciphertext));
1603 ret = BCryptEncrypt(key, data, 16, NULL, NULL, 0, ciphertext, 16, &size, 0);
1604 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1605 ok(size == 16, "got %lu\n", size);
1606 ok(!memcmp(ciphertext, expected12, sizeof(expected12)), "wrong data\n");
1607
1608 /* all zero initialization vector */
1609 size = 0;
1610 memset(ciphertext, 0, sizeof(ciphertext));
1611 memset(ivbuf, 0, sizeof(ivbuf));
1612 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
1613 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1614 ok(size == 16, "got %lu\n", size);
1615 ok(!memcmp(ciphertext, expected13, sizeof(expected13)), "wrong data\n");
1616 for (i = 0; i < 16; i++)
1617 ok(ciphertext[i] == expected13[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected13[i]);
1618 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
1619
1620 /* input size is not a multiple of block size */
1621 size = 0;
1622 memcpy(ivbuf, iv, sizeof(iv));
1623 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, NULL, 0, &size, 0);
1624 todo_wine ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1625 ok(size == 17, "got %lu\n", size);
1626
1627 /* input size is not a multiple of block size, block padding set */
1628 size = 0;
1629 memcpy(ivbuf, iv, sizeof(iv));
1630 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1631 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1632 ok(size == 32, "got %lu\n", size);
1633 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1634
1635 size = 0;
1636 memcpy(ivbuf, iv, sizeof(iv));
1637 memset(ciphertext, 0, sizeof(ciphertext));
1638 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1639 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1640 ok(size == 32, "got %lu\n", size);
1641 ok(!memcmp(ciphertext, expected14, sizeof(expected14)), "wrong data\n");
1642 for (i = 0; i < 32; i++)
1643 ok(ciphertext[i] == expected14[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected14[i]);
1644 ok(!memcmp(ivbuf, ciphertext + 32 - 16, sizeof(iv)), "wrong iv data.\n");
1645
1646 /* input size is a multiple of block size, block padding set */
1647 size = 0;
1648 memcpy(ivbuf, iv, sizeof(iv));
1649 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1650 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1651 ok(size == 48, "got %lu\n", size);
1652
1653 size = 0;
1654 memcpy(ivbuf, iv, sizeof(iv));
1655 memset(ciphertext, 0, sizeof(ciphertext));
1656 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING);
1657 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1658 ok(size == 48, "got %lu\n", size);
1659 ok(!memcmp(ciphertext, expected15, sizeof(expected15)), "wrong data\n");
1660 for (i = 0; i < 48; i++)
1661 ok(ciphertext[i] == expected15[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected15[i]);
1662 ok(!memcmp(ivbuf, ciphertext + 48 - 16, sizeof(iv)), "wrong iv data.\n");
1663
1664 /* output size too small */
1665 size = 0;
1666 memcpy(ivbuf, iv, sizeof(iv));
1667 memset(ciphertext, 0, sizeof(ciphertext));
1668 ret = BCryptEncrypt(key, data, 17, NULL, ivbuf, 16, ciphertext, 31, &size, BCRYPT_BLOCK_PADDING);
1669 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1670 ok(size == 32, "got %lu\n", size);
1671 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1672
1673 size = 0;
1674 memcpy(ivbuf, iv, sizeof(iv));
1675 memset(ciphertext, 0, sizeof(ciphertext));
1676 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING);
1677 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
1678 ok(size == 48, "got %lu\n", size);
1679 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1680
1681 ret = BCryptDestroyKey(key);
1682 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1683 free(buf);
1684
1685 /* 256 bit key */
1686 buf = calloc(1, len);
1687
1688 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret256, sizeof(secret256), 0);
1689 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1690 ret = BCryptDestroyKey(key);
1691 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1692
1693 /* Key generations succeeds if the key size exceeds maximum and uses maximum key length
1694 * from secret. */
1695 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret256, sizeof(secret256) + 1, 0);
1696 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1697
1698 size = 0;
1699 memcpy(ivbuf, iv, sizeof(iv));
1700 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING);
1701 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1702 ok(size == 48, "got %lu\n", size);
1703 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
1704
1705 size = 0;
1706 memcpy(ivbuf, iv, sizeof(iv));
1707 memset(ciphertext, 0, sizeof(ciphertext));
1708 ret = BCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING);
1709 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1710 ok(size == 48, "got %lu\n", size);
1711 ok(!memcmp(ciphertext, expected16, sizeof(expected16)), "wrong data\n");
1712 for (i = 0; i < 48; i++)
1713 ok(ciphertext[i] == expected16[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected16[i]);
1714 ok(!memcmp(ivbuf, ciphertext + 48 - 16, sizeof(iv)), "wrong iv data.\n");
1715
1716 ret = BCryptCloseAlgorithmProvider(aes, 0);
1717 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
1718}
encrypt_race_thread
static DWORD WINAPI encrypt_race_thread(void *parameter)
Definition: bcrypt.c:996
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:139
INFINITE
#define INFINITE
Definition: serial.h:102
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82

Referenced by START_TEST().

◆ test_BCryptEnumAlgorithms()

static void test_BCryptEnumAlgorithms ( void  )
static

Definition at line 4253 of file bcrypt.c.

4254{
4255 BCRYPT_ALGORITHM_IDENTIFIER *list;
4256 NTSTATUS ret;
4257 ULONG count, op;
4258
4259 ret = BCryptEnumAlgorithms(0, NULL, NULL, 0);
4260 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4261
4262 ret = BCryptEnumAlgorithms(0, &count, NULL, 0);
4263 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4264
4265 ret = BCryptEnumAlgorithms(0, NULL, &list, 0);
4266 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4267
4268 ret = BCryptEnumAlgorithms(~0u, &count, &list, 0);
4269 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4270
4271 count = 0;
4272 list = NULL;
4273 ret = BCryptEnumAlgorithms(0, &count, &list, 0);
4274 ok(!ret, "got %#lx\n", ret);
4275 ok(list != NULL, "NULL list\n");
4276 ok(count, "got %lu\n", count);
4277 BCryptFreeBuffer( list );
4278
4279 op = BCRYPT_CIPHER_OPERATION | BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION | BCRYPT_SIGNATURE_OPERATION |
4280 BCRYPT_SECRET_AGREEMENT_OPERATION;
4281 count = 0;
4282 list = NULL;
4283 ret = BCryptEnumAlgorithms(op, &count, &list, 0);
4284 ok(!ret, "got %#lx\n", ret);
4285 ok(list != NULL, "NULL list\n");
4286 ok(count, "got %lu\n", count);
4287 BCryptFreeBuffer( list );
4288}
BCRYPT_SECRET_AGREEMENT_OPERATION
#define BCRYPT_SECRET_AGREEMENT_OPERATION
Definition: bcrypt.h:180
BCRYPT_SIGNATURE_OPERATION
#define BCRYPT_SIGNATURE_OPERATION
Definition: bcrypt.h:181
BCRYPT_CIPHER_OPERATION
#define BCRYPT_CIPHER_OPERATION
Definition: bcrypt.h:177
BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION
#define BCRYPT_ASYMMETRIC_ENCRYPTION_OPERATION
Definition: bcrypt.h:179
BCryptEnumAlgorithms
NTSTATUS WINAPI BCryptEnumAlgorithms(ULONG type, ULONG *ret_count, BCRYPT_ALGORITHM_IDENTIFIER **ret_list, ULONG flags)
Definition: bcrypt_main.c:424
BCryptFreeBuffer
void WINAPI BCryptFreeBuffer(void *buffer)
Definition: bcrypt_main.c:332
list
Definition: list.h:39
op
UINT op
Definition: effect.c:235
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
u
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 * u
Definition: glfuncs.h:240
list
#define list
Definition: rosglue.h:35
_BCRYPT_ALGORITHM_IDENTIFIER
Definition: bcrypt.h:200

Referenced by START_TEST().

◆ test_BCryptEnumContextFunctions()

static void test_BCryptEnumContextFunctions ( void  )
static

Definition at line 4092 of file bcrypt.c.

4093{
4094 CRYPT_CONTEXT_FUNCTIONS *buffer;
4095 NTSTATUS status;
4096 ULONG buflen;
4097
4098 buffer = NULL;
4099 status = BCryptEnumContextFunctions( CRYPT_LOCAL, L"SSL", NCRYPT_SCHANNEL_INTERFACE, &buflen, &buffer );
4100 todo_wine ok( status == STATUS_SUCCESS, "got %#lx\n", status);
4101 if (status == STATUS_SUCCESS) BCryptFreeBuffer( buffer );
4102}
CRYPT_LOCAL
#define CRYPT_LOCAL
Definition: bcrypt.h:489
BCryptEnumContextFunctions
NTSTATUS WINAPI BCryptEnumContextFunctions(ULONG table, const WCHAR *ctx, ULONG iface, ULONG *buflen, CRYPT_CONTEXT_FUNCTIONS **buffer)
Definition: bcrypt_main.c:325
buffer
GLuint buffer
Definition: glext.h:5915
NCRYPT_SCHANNEL_INTERFACE
#define NCRYPT_SCHANNEL_INTERFACE
Definition: ncrypt.h:83
_CRYPT_CONTEXT_FUNCTIONS
Definition: bcrypt.h:493

Referenced by START_TEST().

◆ test_BCryptGenerateSymmetricKey()

static void test_BCryptGenerateSymmetricKey ( void  )
static

Definition at line 770 of file bcrypt.c.

771{
772 static UCHAR secret[] =
773 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
774 static UCHAR iv[] =
775 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
776 static UCHAR data[] =
777 {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f};
778 static UCHAR expected[] =
779 {0xc6,0xa1,0x3b,0x37,0x87,0x8f,0x5b,0x82,0x6f,0x4f,0x81,0x62,0xa1,0xc8,0xd8,0x79};
780 static UCHAR expected2[] =
781 {0xb5,0x8a,0x10,0x64,0xd8,0xac,0xa9,0x9b,0xd9,0xb0,0x40,0x5b,0x85,0x45,0xf5,0xbb};
782 static UCHAR expected3[] =
783 {0xe3,0x7c,0xd3,0x63,0xdd,0x7c,0x87,0xa0,0x9a,0xff,0x0e,0x3e,0x60,0xe0,0x9c,0x82};
784 BCRYPT_ALG_HANDLE aes;
785 BCRYPT_KEY_HANDLE key, key2;
786 UCHAR *buf, ciphertext[16], plaintext[16], ivbuf[16], mode[64];
787 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
788 ULONG size, len, len2, i;
789 NTSTATUS ret;
790 DWORD keylen;
791
792 ret = BCryptOpenAlgorithmProvider(&aes, BCRYPT_AES_ALGORITHM, NULL, 0);
793 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
794
795 len = size = 0xdeadbeef;
796 ret = BCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
797 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
798 len2 = len;
799
800 key = (void *)0xdeadbeef;
801 ret = BCryptGenerateSymmetricKey(NULL, &key, NULL, 0, secret, sizeof(secret), 0);
802 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
803 ok(key == (void *)0xdeadbeef, "got %p\n", key);
804
805 key = NULL;
806 buf = calloc(1, len);
807
808 key = (BCRYPT_KEY_HANDLE)0xdeadbeef;
809 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, 1, 0);
810 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
811 ok(key == (HANDLE)0xdeadbeef, "got unexpected key %p.\n", key);
812
813 key = (BCRYPT_KEY_HANDLE)0xdeadbeef;
814 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret) + 1, 0);
815 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
816 ok(key == (HANDLE)0xdeadbeef, "got unexpected key %p.\n", key);
817
818 ret = BCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0);
819 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
820 ok(key != NULL, "key not set\n");
821
822 keylen = 0;
823 ret = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&keylen, sizeof(keylen), &size, 0);
824 ok(!ret, "got %#lx\n", ret);
825 ok(size == sizeof(keylen), "got %lu\n", size);
826 ok(keylen == 128, "got %lu\n", keylen);
827
828 ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_CBC,
829 sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
830 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
831
832 todo_wine
833 {
834 keylen = 512;
835 ret = BCryptSetProperty(aes, BCRYPT_KEY_LENGTH, (UCHAR *)&keylen, sizeof(keylen), 0);
836 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
837 }
838
839 size = 0;
840 memset(mode, 0, sizeof(mode));
841 ret = BCryptGetProperty(key, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
842 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
843 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_CBC), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
844 ok(size == 64, "got %lu\n", size);
845
846 ret = BCryptSetProperty(key, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_ECB, 0, 0);
847 ok(ret == STATUS_SUCCESS || broken(ret == STATUS_NOT_SUPPORTED) /* < Win 8 */, "got %#lx\n", ret);
848 if (ret == STATUS_SUCCESS)
849 {
850 size = 0;
851 memset(mode, 0, sizeof(mode));
852 ret = BCryptGetProperty(key, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
853 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
854 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_ECB), "got %s\n", wine_dbgstr_w((const WCHAR *)mode));
855 ok(size == 64, "got %lu\n", size);
856 }
857
858 ret = BCryptSetProperty(key, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_CBC,
859 sizeof(BCRYPT_CHAIN_MODE_CBC), 0);
860 ok(ret == STATUS_SUCCESS || broken(ret == STATUS_NOT_SUPPORTED) /* < Win 8 */, "got %#lx\n", ret);
861
862 size = 0xdeadbeef;
863 ret = BCryptEncrypt(key, NULL, 0, NULL, NULL, 0, NULL, 0, &size, 0);
864 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
865 ok(!size, "got %lu\n", size);
866
867 size = 0;
868 memcpy(ivbuf, iv, sizeof(iv));
869 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, NULL, 0, &size, 0);
870 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
871 ok(size == 16, "got %lu\n", size);
872 ok(!memcmp(ivbuf, iv, sizeof(iv)), "wrong iv data.\n");
873
874 size = 0;
875 memcpy(ivbuf, iv, sizeof(iv));
876 memset(ciphertext, 0, sizeof(ciphertext));
877 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
878 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
879 ok(size == 16, "got %lu\n", size);
880 ok(!memcmp(ciphertext, expected, sizeof(expected)), "wrong data\n");
881 for (i = 0; i < 16; i++)
882 ok(ciphertext[i] == expected[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected[i]);
883 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
884
885 size = 0;
886 memset(ciphertext, 0, sizeof(ciphertext));
887 ret = BCryptEncrypt(key, data, 16, NULL, NULL, 0, ciphertext, 16, &size, 0);
888 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
889 ok(size == 16, "got %lu\n", size);
890 ok(!memcmp(ciphertext, expected2, sizeof(expected2)), "wrong data\n");
891
892 size = 0;
893 memcpy(ivbuf, iv, sizeof(iv));
894 ++ivbuf[0];
895 memset(ciphertext, 0, sizeof(ciphertext));
896 ret = BCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
897 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
898 ok(size == 16, "got %lu\n", size);
899 ok(!memcmp(ciphertext, expected3, sizeof(expected3)), "wrong data\n");
900 for (i = 0; i < 16; i++)
901 ok(ciphertext[i] == expected3[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected3[i]);
902 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
903
904 key2 = (void *)0xdeadbeef;
905 ret = BCryptDuplicateKey(NULL, &key2, NULL, 0, 0);
906 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
907 ok(key2 == (void *)0xdeadbeef, "got %p\n", key2);
908
909 if (0) /* crashes on some Windows versions */
910 {
911 ret = BCryptDuplicateKey(key, NULL, NULL, 0, 0);
912 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
913 }
914
915 key2 = (void *)0xdeadbeef;
916 ret = BCryptDuplicateKey(key, &key2, NULL, 0, 0);
917 ok(ret == STATUS_SUCCESS || broken(ret == STATUS_INVALID_PARAMETER), "got %#lx\n", ret);
918
919 if (ret == STATUS_SUCCESS)
920 {
921 size = 0;
922 memcpy(ivbuf, iv, sizeof(iv));
923 memset(ciphertext, 0, sizeof(ciphertext));
924 ret = BCryptEncrypt(key2, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0);
925 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
926 ok(size == 16, "got %lu\n", size);
927 ok(!memcmp(ciphertext, expected, sizeof(expected)), "wrong data\n");
928 for (i = 0; i < 16; i++)
929 ok(ciphertext[i] == expected[i], "%lu: %02x != %02x\n", i, ciphertext[i], expected[i]);
930 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
931
932 ret = BCryptDestroyKey(key2);
933 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
934 }
935
936 size = 0xdeadbeef;
937 ret = BCryptDecrypt(key, NULL, 0, NULL, NULL, 0, NULL, 0, &size, 0);
938 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
939 ok(!size, "got %lu\n", size);
940
941 size = 0;
942 memcpy(ivbuf, iv, sizeof(iv));
943 ret = BCryptDecrypt(key, ciphertext, 16, NULL, ivbuf, 16, NULL, 0, &size, 0);
944 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
945 ok(size == 16, "got %lu\n", size);
946
947 size = 0;
948 memcpy(ivbuf, iv, sizeof(iv));
949 memset(plaintext, 0, sizeof(plaintext));
950 ret = BCryptDecrypt(key, ciphertext, 16, NULL, ivbuf, 16, plaintext, 16, &size, 0);
951 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
952 ok(size == 16, "got %lu\n", size);
953 ok(!memcmp(plaintext, data, sizeof(data)), "wrong data\n");
954 ok(!memcmp(ivbuf, ciphertext, sizeof(iv)), "wrong iv data.\n");
955
956 memset(mode, 0, sizeof(mode));
957 ret = BCryptGetProperty(key, BCRYPT_CHAINING_MODE, mode, sizeof(mode), &size, 0);
958 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
959 ok(!lstrcmpW((const WCHAR *)mode, BCRYPT_CHAIN_MODE_CBC), "wrong mode\n");
960
961 len = 0;
962 size = 0;
963 ret = BCryptGetProperty(key, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
964 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
965 ok(len == 16, "got %lu\n", len);
966 ok(size == sizeof(len), "got %lu\n", size);
967
968 size = 0;
969 memset(&key_lengths, 0, sizeof(key_lengths));
970 ret = BCryptGetProperty(aes, BCRYPT_KEY_LENGTHS, (UCHAR*)&key_lengths, sizeof(key_lengths), &size, 0);
971 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
972 ok(size == sizeof(key_lengths), "got %lu\n", size);
973 ok(key_lengths.dwMinLength == 128, "Expected 128, got %lu\n", key_lengths.dwMinLength);
974 ok(key_lengths.dwMaxLength == 256, "Expected 256, got %lu\n", key_lengths.dwMaxLength);
975 ok(key_lengths.dwIncrement == 64, "Expected 64, got %lu\n", key_lengths.dwIncrement);
976
977 ret = BCryptDestroyKey(key);
978 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
979
980 if (pBCryptHash)
981 {
982 ret = BCryptGenerateSymmetricKey(BCRYPT_AES_CBC_ALG_HANDLE, &key, buf, len2, secret, sizeof(secret), 0);
983 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
984 ret = BCryptDestroyKey(key);
985 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
986 }
987
988 free(buf);
989 ret = BCryptCloseAlgorithmProvider(aes, 0);
990 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
991}
BCRYPT_KEY_LENGTH
#define BCRYPT_KEY_LENGTH
Definition: bcrypt.h:61
BCRYPT_KEY_STRENGTH
#define BCRYPT_KEY_STRENGTH
Definition: bcrypt.h:64
BCRYPT_KEY_HANDLE
PVOID BCRYPT_KEY_HANDLE
Definition: bcrypt.h:410
BCryptDuplicateKey
NTSTATUS WINAPI BCryptDuplicateKey(BCRYPT_KEY_HANDLE handle, BCRYPT_KEY_HANDLE *handle_copy, UCHAR *object, ULONG object_len, ULONG flags)
Definition: bcrypt_main.c:3717
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
len2
UINT32 len2
Definition: symcrypt_internal.h:3097
key2
SYMCRYPT_AES_EXPANDED_KEY key2
Definition: symcrypt_internal.h:1706

Referenced by START_TEST().

◆ test_BCryptGenRandom()

static void test_BCryptGenRandom ( void  )
static

Definition at line 33 of file bcrypt.c.

34{
35 NTSTATUS ret;
36 UCHAR buffer[256];
37
38 ret = BCryptGenRandom(NULL, NULL, 0, 0);
39 ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %#lx\n", ret);
40 ret = BCryptGenRandom(NULL, buffer, 0, 0);
41 ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %#lx\n", ret);
42 ret = BCryptGenRandom(NULL, buffer, sizeof(buffer), 0);
43 ok(ret == STATUS_INVALID_HANDLE, "Expected STATUS_INVALID_HANDLE, got %#lx\n", ret);
44 ret = BCryptGenRandom(NULL, buffer, sizeof(buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
45 ok(ret == STATUS_SUCCESS, "Expected success, got %#lx\n", ret);
46 ret = BCryptGenRandom(NULL, buffer, sizeof(buffer),
47 BCRYPT_USE_SYSTEM_PREFERRED_RNG|BCRYPT_RNG_USE_ENTROPY_IN_BUFFER);
48 ok(ret == STATUS_SUCCESS, "Expected success, got %#lx\n", ret);
49 ret = BCryptGenRandom(NULL, NULL, sizeof(buffer), BCRYPT_USE_SYSTEM_PREFERRED_RNG);
50 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", ret);
51
52 /* Zero sized buffer should work too */
53 ret = BCryptGenRandom(NULL, buffer, 0, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
54 ok(ret == STATUS_SUCCESS, "Expected success, got %#lx\n", ret);
55
56 /* Test random number generation - It's impossible for a sane RNG to return 8 zeros */
57 memset(buffer, 0, 16);
58 ret = BCryptGenRandom(NULL, buffer, 8, BCRYPT_USE_SYSTEM_PREFERRED_RNG);
59 ok(ret == STATUS_SUCCESS, "Expected success, got %#lx\n", ret);
60 ok(memcmp(buffer, buffer + 8, 8), "Expected a random number, got 0\n");
61
62 /* Test pseudo handle, which was introduced at the same time as BCryptHash */
63 if (pBCryptHash)
64 {
65 ret = BCryptGenRandom(BCRYPT_RNG_ALG_HANDLE, buffer, sizeof(buffer), 0);
66 ok(ret == STATUS_SUCCESS, "Expected success, got %#lx\n", ret);
67
68 ret = BCryptCloseAlgorithmProvider(BCRYPT_RNG_ALG_HANDLE, 0);
69 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
70 }
71 else win_skip("BCryptGenRandom pseudo handles are not available\n");
72
73}
BCRYPT_RNG_ALG_HANDLE
#define BCRYPT_RNG_ALG_HANDLE
Definition: bcrypt.h:424
BCRYPT_RNG_USE_ENTROPY_IN_BUFFER
#define BCRYPT_RNG_USE_ENTROPY_IN_BUFFER
Definition: bcrypt.h:477
BCRYPT_USE_SYSTEM_PREFERRED_RNG
#define BCRYPT_USE_SYSTEM_PREFERRED_RNG
Definition: bcrypt.h:478
BCryptGenRandom
NTSTATUS WINAPI BCryptGenRandom(BCRYPT_ALG_HANDLE handle, UCHAR *buffer, ULONG count, ULONG flags)
Definition: bcrypt_main.c:574

Referenced by START_TEST().

◆ test_BCryptGetFipsAlgorithmMode()

static void test_BCryptGetFipsAlgorithmMode ( void  )
static

Definition at line 75 of file bcrypt.c.

76{
77 HKEY hkey = NULL;
78 BOOLEAN expected;
79 BOOLEAN enabled;
80 DWORD value, count[2] = {sizeof(value), sizeof(value)};
81 NTSTATUS ret;
82
83 if (RegOpenKeyW(HKEY_LOCAL_MACHINE,
84 L"System\\CurrentControlSet\\Control\\Lsa\\FIPSAlgorithmPolicy", &hkey) == ERROR_SUCCESS &&
85 RegQueryValueExW(hkey, L"Enabled", NULL, NULL, (void *)&value, &count[0]) == ERROR_SUCCESS)
86 {
87 expected = !!value;
88 }
89 else if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Control\\Lsa", &hkey) == ERROR_SUCCESS &&
90 RegQueryValueExW(hkey, L"FIPSAlgorithmPolicy", NULL, NULL, (void *)&value, &count[0]) == ERROR_SUCCESS)
91 {
92 expected = !!value;
93 }
94 else
95 {
96 expected = FALSE;
97 todo_wine
98 ok(0, "Neither XP or Vista key is present\n");
99 }
100 RegCloseKey(hkey);
101
102 ret = BCryptGetFipsAlgorithmMode(&enabled);
103 ok(ret == STATUS_SUCCESS, "Expected STATUS_SUCCESS, got %#lx\n", ret);
104 ok(enabled == expected, "expected result %d, got %d\n", expected, enabled);
105
106 ret = BCryptGetFipsAlgorithmMode(NULL);
107 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", ret);
108}
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
BCryptGetFipsAlgorithmMode
NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *enabled)
Definition: bcrypt_main.c:696
RegCloseKey
#define RegCloseKey(hKey)
Definition: registry.h:49
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
FALSE
#define FALSE
Definition: types.h:117
RegOpenKeyW
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3268
RegQueryValueExW
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
enabled
GLenum GLenum GLsizei const GLuint GLboolean enabled
Definition: glext.h:7750
value
Definition: pdh_main.c:64
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by START_TEST().

◆ test_BcryptHash()

static void test_BcryptHash ( void  )
static

Definition at line 431 of file bcrypt.c.

432{
433 static const char expected[] =
434 "e2a3e68d23ce348b8f68b3079de3d4c9";
435 static const char expected_hmac[] =
436 "7bda029b93fa8d817fcc9e13d6bdf092";
437 BCRYPT_ALG_HANDLE alg;
438 UCHAR md5[16], md5_hmac[16];
439 char str[65];
440 NTSTATUS ret;
441
442 if (!pBCryptHash) /* < Win10 */
443 {
444 win_skip("BCryptHash is not available\n");
445 return;
446 }
447
448 alg = NULL;
449 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
450 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
451 ok(alg != NULL, "alg not set\n");
452
453 test_hash_length(alg, 16);
454 test_alg_name(alg, L"MD5");
455
456 memset(md5, 0, sizeof(md5));
457 ret = pBCryptHash(alg, NULL, 0, (UCHAR *)"test", sizeof("test"), md5, sizeof(md5));
458 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
459 format_hash( md5, sizeof(md5), str );
460 ok(!strcmp(str, expected), "got %s\n", str);
461
462 /* With a secret but without BCRYPT_ALG_HANDLE_HMAC_FLAG */
463 ret = pBCryptHash(alg, (UCHAR *)"key", sizeof("key"), (UCHAR *)"test", sizeof("test"), md5, sizeof(md5));
464 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
465
466 ret = BCryptCloseAlgorithmProvider(alg, 0);
467 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
468
469 alg = NULL;
470 memset(md5_hmac, 0, sizeof(md5_hmac));
471 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_MD5_ALGORITHM, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
472 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
473 ok(alg != NULL, "alg not set\n");
474
475 ret = pBCryptHash(alg, (UCHAR *)"key", sizeof("key"), (UCHAR *)"test", sizeof("test"), md5_hmac, sizeof(md5_hmac));
476 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
477 format_hash( md5_hmac, sizeof(md5_hmac), str );
478 ok(!strcmp(str, expected_hmac), "got %s\n", str);
479
480 ret = BCryptCloseAlgorithmProvider(alg, 0);
481 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
482
483 if (pBCryptHash)
484 {
485 memset(md5, 0, sizeof(md5));
486 ret = pBCryptHash(BCRYPT_MD5_ALG_HANDLE, NULL, 0, (UCHAR *)"test", sizeof("test"), md5, sizeof(md5));
487 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
488 format_hash( md5, sizeof(md5), str );
489 ok(!strcmp(str, expected), "got %s\n", str);
490 }
491}
BCRYPT_MD5_ALG_HANDLE
#define BCRYPT_MD5_ALG_HANDLE
Definition: bcrypt.h:418
BCRYPT_MD5_ALGORITHM
#define BCRYPT_MD5_ALGORITHM
Definition: bcrypt.h:112
md5
#define md5
Definition: compat-1.3.h:2034
strcmp
_ACRTIMP int __cdecl strcmp(const char *, const char *)
Definition: string.c:3324

Referenced by START_TEST().

◆ test_BCryptSignHash()

static void test_BCryptSignHash ( void  )
static

Definition at line 4124 of file bcrypt.c.

4125{
4126 static UCHAR hash[] =
4127 {0x7e,0xe3,0x74,0xe7,0xc5,0x0b,0x6b,0x70,0xdb,0xab,0x32,0x6d,0x1d,0x51,0xd6,0x74,0x79,0x8e,0x5b,0x4b};
4128 static UCHAR hash_sha256[] =
4129 {0x25,0x2f,0x10,0xc8,0x36,0x10,0xeb,0xca,0x1a,0x05,0x9c,0x0b,0xae,0x82,0x55,0xeb,0xa2,0xf9,0x5b,0xe4,
4130 0xd1,0xd7,0xbC,0xfA,0x89,0xd7,0x24,0x8a,0x82,0xd9,0xf1,0x11};
4131 BCRYPT_PKCS1_PADDING_INFO pad;
4132 BCRYPT_ALG_HANDLE alg;
4133 BCRYPT_KEY_HANDLE key;
4134 UCHAR sig[256];
4135 NTSTATUS ret;
4136 ULONG len;
4137
4138 /* RSA */
4139 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RSA_ALGORITHM, NULL, 0);
4140 ok(!ret, "got %#lx\n", ret);
4141
4142 /* public key */
4143 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAPUBLIC_BLOB, &key, rsapublic, sizeof(rsapublic), 0);
4144 ok(!ret, "got %#lx\n", ret);
4145
4146 len = 0;
4147 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
4148 ret = BCryptSignHash(key, &pad, NULL, 0, NULL, 0, &len, BCRYPT_PAD_PKCS1);
4149 ok(!ret, "got %#lx\n", ret);
4150 ok(len == 256, "got %lu\n", len);
4151
4152 /* test len return when only output is NULL, as described in BCryptSignHash doc */
4153 ret = BCryptSignHash(key, &pad, hash, sizeof(hash), NULL, 0, &len, BCRYPT_PAD_PKCS1);
4154 ok(!ret, "got %#lx\n", ret);
4155 ok(len == 256, "got %lu\n", len);
4156
4157 len = 0;
4158 ret = BCryptSignHash(key, &pad, hash, sizeof(hash), sig, sizeof(sig), &len, BCRYPT_PAD_PKCS1);
4159 ok(ret == STATUS_INVALID_PARAMETER || broken(ret == STATUS_INTERNAL_ERROR) /* < win7 */, "got %#lx\n", ret);
4160 ret = BCryptDestroyKey(key);
4161 ok(!ret, "got %#lx\n", ret);
4162
4163 ret = BCryptGenerateKeyPair(alg, &key, 512, 0);
4164 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4165
4166 ret = BCryptFinalizeKeyPair(key, 0);
4167 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4168
4169 ret = BCryptFinalizeKeyPair(key, 0);
4170 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
4171
4172 len = 0;
4173 memset(sig, 0, sizeof(sig));
4174
4175 /* inference of padding info on RSA not supported */
4176 ret = BCryptSignHash(key, NULL, hash, sizeof(hash), sig, sizeof(sig), &len, 0);
4177 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4178
4179 ret = BCryptSignHash(key, &pad, hash, sizeof(hash), sig, 0, &len, BCRYPT_PAD_PKCS1);
4180 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
4181
4182 ret = BCryptSignHash(key, &pad, hash, sizeof(hash), sig, sizeof(sig), &len, BCRYPT_PAD_PKCS1);
4183 ok(!ret, "got %#lx\n", ret);
4184 ok(len == 64, "got %lu\n", len);
4185
4186 ret = BCryptVerifySignature(key, &pad, hash, sizeof(hash), sig, len, BCRYPT_PAD_PKCS1);
4187 ok(!ret, "got %#lx\n", ret);
4188
4189 ret = BCryptDestroyKey(key);
4190 ok(!ret, "got %#lx\n", ret);
4191
4192 ret = BCryptCloseAlgorithmProvider(alg, 0);
4193 ok(!ret, "got %#lx\n", ret);
4194
4195 /* ECDSA */
4196 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_P256_ALGORITHM, NULL, 0);
4197 ok(!ret, "got %#lx\n", ret);
4198
4199 ret = BCryptGenerateKeyPair(alg, &key, 256, 0);
4200 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4201
4202 ret = BCryptFinalizeKeyPair(key, 0);
4203 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4204
4205 memset(sig, 0, sizeof(sig));
4206 len = 0;
4207
4208 /* automatically detects padding info */
4209 ret = BCryptSignHash(key, NULL, hash, sizeof(hash), sig, sizeof(sig), &len, 0);
4210 ok (!ret, "got %#lx\n", ret);
4211 ok (len == 64, "got %lu\n", len);
4212
4213 ret = BCryptVerifySignature(key, NULL, hash, sizeof(hash), sig, len, 0);
4214 ok(!ret, "got %#lx\n", ret);
4215
4216 /* mismatch info (SHA-1 != SHA-256) */
4217 ret = BCryptSignHash(key, &pad, hash_sha256, sizeof(hash_sha256), sig, sizeof(sig), &len, BCRYPT_PAD_PKCS1);
4218 ok (ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4219
4220 ret = BCryptDestroyKey(key);
4221 ok(!ret, "got %#lx\n", ret);
4222
4223 ret = BCryptCloseAlgorithmProvider(alg, 0);
4224 ok(!ret, "got %#lx\n", ret);
4225
4226 /* ECDSA P521 */
4227 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_P521_ALGORITHM, NULL, 0);
4228 ok(!ret, "got %#lx\n", ret);
4229
4230 ret = BCryptGenerateKeyPair(alg, &key, 256, 0);
4231 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4232 ret = BCryptGenerateKeyPair(alg, &key, 522, 0);
4233 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4234
4235 ret = BCryptGenerateKeyPair(alg, &key, 521, 0);
4236 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4237 ret = BCryptFinalizeKeyPair(key, 0);
4238 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4239 len = 0;
4240 ret = BCryptSignHash(key, NULL, hash, sizeof(hash), sig, sizeof(sig), &len, 0);
4241 ok (!ret, "got %#lx\n", ret);
4242 ok (len == 132, "got %lu\n", len);
4243
4244 ret = BCryptVerifySignature(key, NULL, hash, sizeof(hash), sig, len, 0);
4245 ok(!ret, "got %#lx\n", ret);
4246
4247 ret = BCryptDestroyKey(key);
4248 ok(!ret, "got %#lx\n", ret);
4249 ret = BCryptCloseAlgorithmProvider(alg, 0);
4250 ok(!ret, "got %#lx\n", ret);
4251}
rsapublic
static BYTE rsapublic[]
Definition: bcrypt.c:4104
BCRYPT_RSAPUBLIC_BLOB
#define BCRYPT_RSAPUBLIC_BLOB
Definition: bcrypt.h:76
BCRYPT_RSA_ALGORITHM
#define BCRYPT_RSA_ALGORITHM
Definition: bcrypt.h:117
BCRYPT_PAD_PKCS1
#define BCRYPT_PAD_PKCS1
Definition: bcrypt.h:274
BCRYPT_ECDSA_P256_ALGORITHM
#define BCRYPT_ECDSA_P256_ALGORITHM
Definition: bcrypt.h:107
BCRYPT_ECDSA_P521_ALGORITHM
#define BCRYPT_ECDSA_P521_ALGORITHM
Definition: bcrypt.h:109
BCryptImportKeyPair
NTSTATUS WINAPI BCryptImportKeyPair(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE decrypt_key_handle, const WCHAR *type, BCRYPT_KEY_HANDLE *ret_handle, UCHAR *input, ULONG input_len, ULONG flags)
Definition: bcrypt_main.c:3481
BCryptGenerateKeyPair
NTSTATUS WINAPI BCryptGenerateKeyPair(BCRYPT_ALG_HANDLE handle, BCRYPT_KEY_HANDLE *ret_handle, ULONG bitlen, ULONG flags)
Definition: bcrypt_main.c:3571
BCryptFinalizeKeyPair
NTSTATUS WINAPI BCryptFinalizeKeyPair(BCRYPT_KEY_HANDLE handle, ULONG flags)
Definition: bcrypt_main.c:3658
BCryptVerifySignature
NTSTATUS WINAPI BCryptVerifySignature(BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG flags)
Definition: bcrypt_main.c:3975
BCryptSignHash
NTSTATUS WINAPI BCryptSignHash(BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len, UCHAR *signature, ULONG signature_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:3870
STATUS_INTERNAL_ERROR
#define STATUS_INTERNAL_ERROR
Definition: ntstatus.h:559
_BCRYPT_PKCS1_PADDING_INFO
Definition: bcrypt.h:256
_BCRYPT_PKCS1_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:257

Referenced by START_TEST().

◆ test_CHACHA20_POLY1305()

static void test_CHACHA20_POLY1305 ( void  )
static

Definition at line 5547 of file bcrypt.c.

5548{
5549 BCRYPT_ALG_HANDLE alg;
5550 NTSTATUS status;
5551 ULONG len, size;
5552
5553 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_CHACHA20_POLY1305_ALGORITHM, NULL, 0);
5554 if (status == STATUS_NOT_FOUND)
5555 {
5556 win_skip("CHACHA20_POLY1305 not supported\n");
5557 return;
5558 }
5559 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5560
5561 len = size = 0;
5562 status = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5563 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5564 ok(len, "expected non-zero len\n");
5565 ok(size == sizeof(len), "got %lu\n", size);
5566
5567 len = size = 0;
5568 status = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5569 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5570 ok(len == 1, "got %lu\n", len);
5571 ok(size == sizeof(len), "got %lu\n", size);
5572
5573 size = sizeof(BCRYPT_CHAIN_MODE_NA);
5574 status = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_NA, size, 0);
5575 ok(!status, "got %#lx\n", status);
5576
5577 status = BCryptCloseAlgorithmProvider(alg, 0);
5578 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5579}
BCRYPT_CHAIN_MODE_NA
#define BCRYPT_CHAIN_MODE_NA
Definition: bcrypt.h:131
BCRYPT_CHACHA20_POLY1305_ALGORITHM
#define BCRYPT_CHACHA20_POLY1305_ALGORITHM
Definition: bcrypt.h:98
STATUS_NOT_FOUND
#define STATUS_NOT_FOUND
Definition: shellext.h:72

Referenced by START_TEST().

◆ test_DH()

static void test_DH ( void  )
static

Definition at line 3914 of file bcrypt.c.

3915{
3916 UCHAR hash[20];
3917 BCRYPT_KEY_HANDLE key, pubkey, privkey;
3918 BCRYPT_SECRET_HANDLE secret;
3919 BCRYPT_DH_KEY_BLOB *dhkey;
3920 NTSTATUS status;
3921 UCHAR *buf;
3922 ULONG size;
3923
3924 if (!pBCryptHash) /* < Win10 */
3925 {
3926 win_skip("broken DH detected\n");
3927 return;
3928 }
3929
3930 key = NULL;
3931 status = BCryptGenerateKeyPair(BCRYPT_DH_ALG_HANDLE, &key, 512, 0);
3932 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3933 ok(key != NULL, "key not set\n");
3934
3935 status = BCryptFinalizeKeyPair(key, 0);
3936 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3937 if (status != STATUS_SUCCESS)
3938 {
3939 BCryptDestroyKey(key);
3940 return;
3941 }
3942
3943 size = 0;
3944 status = BCryptExportKey(key, NULL, BCRYPT_DH_PUBLIC_BLOB, NULL, 0, &size, 0);
3945 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3946 ok(size, "size not set\n");
3947
3948 buf = malloc(size);
3949 status = BCryptExportKey(key, NULL, BCRYPT_DH_PUBLIC_BLOB, buf, size, &size, 0);
3950 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3951 dhkey = (BCRYPT_DH_KEY_BLOB *)buf;
3952 ok(dhkey->dwMagic == BCRYPT_DH_PUBLIC_MAGIC, "got %#lx\n", dhkey->dwMagic);
3953 ok(dhkey->cbKey == 64, "got %lu\n", dhkey->cbKey);
3954 ok(size == sizeof(*dhkey) + dhkey->cbKey * 3, "got %lu\n", size);
3955
3956 status = BCryptImportKeyPair(BCRYPT_DH_ALG_HANDLE, NULL, BCRYPT_DH_PUBLIC_BLOB, &pubkey, buf, size, 0);
3957 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3958 free(buf);
3959 BCryptDestroyKey(pubkey);
3960
3961 size = 0;
3962 status = BCryptExportKey(key, NULL, BCRYPT_DH_PRIVATE_BLOB, NULL, 0, &size, 0);
3963 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3964 ok(size == sizeof(*dhkey) + 64 * 4, "size not set\n");
3965
3966 buf = calloc(1, size);
3967 status = BCryptExportKey(key, NULL, BCRYPT_DH_PRIVATE_BLOB, buf, size, &size, 0);
3968 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3969 dhkey = (BCRYPT_DH_KEY_BLOB *)buf;
3970 ok(dhkey->dwMagic == BCRYPT_DH_PRIVATE_MAGIC, "got %#lx\n", dhkey->dwMagic);
3971 ok(dhkey->cbKey == 64, "got %lu\n", dhkey->cbKey);
3972 ok(size == sizeof(*dhkey) + dhkey->cbKey * 4, "got %lu\n", size);
3973 BCryptDestroyKey(key);
3974
3975 status = BCryptImportKeyPair(BCRYPT_DH_ALG_HANDLE, NULL, BCRYPT_DH_PRIVATE_BLOB, &privkey, buf, size, 0);
3976 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3977 free(buf);
3978 BCryptDestroyKey(privkey);
3979
3980 status = BCryptImportKeyPair(BCRYPT_DH_ALG_HANDLE, NULL, BCRYPT_DH_PRIVATE_BLOB, &privkey, dh_privkey,
3981 sizeof(dh_privkey), 0);
3982 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3983
3984 size = 0;
3985 status = BCryptExportKey(privkey, NULL, BCRYPT_DH_PRIVATE_BLOB, NULL, 0, &size, 0);
3986 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3987 ok(size, "size not set\n");
3988
3989 buf = malloc(size);
3990 status = BCryptExportKey(privkey, NULL, BCRYPT_DH_PRIVATE_BLOB, buf, size, &size, 0);
3991 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3992 ok(size == sizeof(dh_privkey), "got %lu\n", size);
3993 ok(!memcmp(buf, dh_privkey, size), "wrong data\n");
3994 free(buf);
3995
3996 status = BCryptImportKeyPair(BCRYPT_DH_ALG_HANDLE, NULL, BCRYPT_DH_PUBLIC_BLOB, &pubkey, dh_pubkey,
3997 sizeof(dh_pubkey), 0);
3998 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3999
4000 size = 0;
4001 status = BCryptExportKey(privkey, NULL, BCRYPT_DH_PUBLIC_BLOB, NULL, 0, &size, 0);
4002 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4003 ok(size, "size not set\n");
4004
4005 buf = malloc(size);
4006 status = BCryptExportKey(privkey, NULL, BCRYPT_DH_PUBLIC_BLOB, buf, size, &size, 0);
4007 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4008 ok(size == sizeof(dh_pubkey), "got %lu\n", size);
4009 ok(!memcmp(buf, dh_pubkey, size), "wrong data\n");
4010 free(buf);
4011
4012 status = BCryptSignHash(privkey, NULL, hash, sizeof(hash), NULL, 0, &size, 0);
4013 ok(status == STATUS_NOT_SUPPORTED, "got %#lx\n", status);
4014
4015 status = BCryptEncrypt(privkey, NULL, 0, NULL, NULL, 0, NULL, 0, &size, 0);
4016 ok(status == STATUS_NOT_SUPPORTED, "got %lx\n", status);
4017
4018 status = BCryptSecretAgreement(privkey, pubkey, &secret, 0);
4019 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4020 BCryptDestroyKey(pubkey);
4021 BCryptDestroyKey(privkey);
4022
4023 size = 0;
4024 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, NULL, 0, &size, 0);
4025 if (status == STATUS_NOT_SUPPORTED)
4026 {
4027 win_skip("BCRYPT_KDF_RAW_SECRET not supported\n"); /* < win10 */
4028 BCryptDestroySecret(secret);
4029 return;
4030 }
4031 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4032 ok(size == 64, "got %lu\n", size);
4033
4034 buf = calloc(1, size);
4035 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, buf, size, &size, 0);
4036 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4037 ok(!memcmp(dh_secret, buf, size), "wrong data\n");
4038 free(buf);
4039
4040 /* Raw secret with a BCryptBufferDesc, which is ignored */
4041 size = 0;
4042 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, &dh_hash_params_prepended, NULL, 0, &size, 0);
4043 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4044 ok(size == 64, "got %lu\n", size);
4045
4046 buf = calloc(1, size);
4047 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, &dh_hash_params_prepended, buf, size, &size, 0);
4048 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4049 ok(!memcmp(dh_secret, buf, size), "wrong data\n");
4050 free(buf);
4051
4052 size = 0;
4053 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, NULL, NULL, 0, &size, 0);
4054 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4055 ok(size == 20, "got %lu\n", size);
4056
4057 size = 0;
4058 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &dh_hash_params, NULL, 0, &size, 0);
4059 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4060 ok(size == 20, "got %lu\n", size);
4061
4062 buf = calloc(1, size);
4063 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &dh_hash_params, buf, size, NULL, 0);
4064 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
4065
4066 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &dh_hash_params, buf, size, &size, 0);
4067 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4068 ok(!memcmp(dh_hashed_secret, buf, size), "wrong data\n");
4069 ok(size == 20, "got %lu\n", size);
4070
4071 size = 0;
4072 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &dh_hash_params_prepended, NULL, 0, &size, 0);
4073 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4074 ok(size == 20, "got %lu\n", size);
4075
4076 buf = calloc(1, size);
4077 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &dh_hash_params_prepended, buf, size, &size, 0);
4078 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4079 ok(!memcmp(dh_hashed_secret_prepended, buf, size), "wrong data\n");
4080 ok(size == 20, "got %lu\n", size);
4081
4082 memset(buf, 0, 20);
4083 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &dh_hash_params, buf, 10, &size, 0);
4084 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4085 ok(!memcmp(dh_hashed_secret, buf, size), "wrong data\n");
4086 ok(size == 10, "got %lu\n", size);
4087 free(buf);
4088
4089 BCryptDestroySecret(secret);
4090}
dh_hashed_secret_prepended
static BYTE dh_hashed_secret_prepended[]
Definition: bcrypt.c:3868
dh_hash_params
BCryptBufferDesc dh_hash_params
Definition: bcrypt.c:3901
dh_hash_params_prepended
BCryptBufferDesc dh_hash_params_prepended
Definition: bcrypt.c:3907
dh_privkey
static BYTE dh_privkey[]
Definition: bcrypt.c:3828
dh_secret
static BYTE dh_secret[]
Definition: bcrypt.c:3854
dh_hashed_secret
static BYTE dh_hashed_secret[]
Definition: bcrypt.c:3862
dh_pubkey
static BYTE dh_pubkey[]
Definition: bcrypt.c:3807
BCRYPT_KDF_HASH
#define BCRYPT_KDF_HASH
Definition: bcrypt.h:146
BCRYPT_DH_PUBLIC_MAGIC
#define BCRYPT_DH_PUBLIC_MAGIC
Definition: bcrypt.h:318
BCRYPT_DH_ALG_HANDLE
#define BCRYPT_DH_ALG_HANDLE
Definition: bcrypt.h:456
BCRYPT_KDF_RAW_SECRET
#define BCRYPT_KDF_RAW_SECRET
Definition: bcrypt.h:150
BCRYPT_DH_PRIVATE_BLOB
#define BCRYPT_DH_PRIVATE_BLOB
Definition: bcrypt.h:84
BCRYPT_DH_PUBLIC_BLOB
#define BCRYPT_DH_PUBLIC_BLOB
Definition: bcrypt.h:83
BCRYPT_DH_PRIVATE_MAGIC
#define BCRYPT_DH_PRIVATE_MAGIC
Definition: bcrypt.h:319
BCryptSecretAgreement
NTSTATUS WINAPI BCryptSecretAgreement(BCRYPT_KEY_HANDLE privkey_handle, BCRYPT_KEY_HANDLE pubkey_handle, BCRYPT_SECRET_HANDLE *ret_handle, ULONG flags)
Definition: bcrypt_main.c:4071
BCryptExportKey
NTSTATUS WINAPI BCryptExportKey(BCRYPT_KEY_HANDLE export_key_handle, BCRYPT_KEY_HANDLE encrypt_key_handle, const WCHAR *type, UCHAR *output, ULONG output_len, ULONG *size, ULONG flags)
Definition: bcrypt_main.c:2749
BCryptDeriveKey
NTSTATUS WINAPI BCryptDeriveKey(BCRYPT_SECRET_HANDLE handle, const WCHAR *kdf, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:4266
BCryptDestroySecret
NTSTATUS WINAPI BCryptDestroySecret(BCRYPT_SECRET_HANDLE handle)
Definition: bcrypt_main.c:4127
malloc
#define malloc
Definition: debug_ros.c:4
pubkey
static const WCHAR pubkey[]
Definition: asmname.c:68
_BCRYPT_DH_KEY_BLOB
Definition: bcrypt.h:322
_BCRYPT_DH_KEY_BLOB::dwMagic
ULONG dwMagic
Definition: bcrypt.h:323
_BCRYPT_DH_KEY_BLOB::cbKey
ULONG cbKey
Definition: bcrypt.h:324

Referenced by START_TEST().

◆ test_DSA()

static void test_DSA ( void  )
static

Definition at line 4567 of file bcrypt.c.

4568{
4569 BCRYPT_ALG_HANDLE alg;
4570 BCRYPT_KEY_HANDLE key;
4571 BCRYPT_DSA_KEY_BLOB *dsablob;
4572 UCHAR sig[40], schemes;
4573 ULONG len, size;
4574 NTSTATUS ret;
4575 BYTE *buf, buf2[sizeof(BCRYPT_DSA_KEY_BLOB) + sizeof(dsaPublicBlob)];
4576
4577 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_DSA_ALGORITHM, NULL, 0);
4578 ok(!ret, "got %#lx\n", ret);
4579
4580 ret = BCryptGetProperty(alg, L"PaddingSchemes", (UCHAR *)&schemes, sizeof(schemes), &size, 0);
4581 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
4582
4583 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_PUBLIC_KEY_BLOB, &key, dsaPublicBlob, sizeof(dsaPublicBlob), 0);
4584 ok(!ret, "got %#lx\n", ret);
4585 BCryptDestroyKey(key);
4586
4587 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_DSA_PUBLIC_BLOB, &key, dsaPublicBlob, sizeof(dsaPublicBlob), 0);
4588 ok(!ret, "got %#lx\n", ret);
4589
4590 memset(buf2, 0xcc, sizeof(buf2));
4591 ret = BCryptExportKey(key, NULL, BCRYPT_DSA_PUBLIC_BLOB, buf2, sizeof(buf2), &size, 0);
4592 ok(!ret, "got %#lx\n", ret);
4593 dsablob = (BCRYPT_DSA_KEY_BLOB *)buf2;
4594 ok(dsablob->dwMagic == BCRYPT_DSA_PUBLIC_MAGIC, "got %#lx\n", dsablob->dwMagic);
4595 ok(dsablob->cbKey == 64, "got %lu\n", dsablob->cbKey);
4596 ok(size == sizeof(*dsablob) + dsablob->cbKey * 3, "got %lu\n", size);
4597
4598 ret = BCryptExportKey(key, NULL, BCRYPT_DSA_PRIVATE_BLOB, buf2, sizeof(buf2), &size, 0);
4599 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
4600
4601 ret = BCryptVerifySignature(key, NULL, dsaHash, sizeof(dsaHash), dsaSignature, sizeof(dsaSignature), 0);
4602 ok(!ret, "got %#lx\n", ret);
4603
4604 ret = BCryptDestroyKey(key);
4605 ok(!ret, "got %#lx\n", ret);
4606
4607 /* sign/verify with export/import round-trip */
4608 ret = BCryptGenerateKeyPair(alg, &key, 512, 0);
4609 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4610
4611 ret = BCryptFinalizeKeyPair(key, 0);
4612 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4613
4614 len = 0;
4615 memset(sig, 0, sizeof(sig));
4616 ret = BCryptSignHash(key, NULL, dsaHash, sizeof(dsaHash), sig, sizeof(sig), &len, 0);
4617 ok(!ret, "got %#lx\n", ret);
4618 ok(len == 40, "got %lu\n", len);
4619
4620 size = 0;
4621 ret = BCryptExportKey(key, NULL, BCRYPT_DSA_PUBLIC_BLOB, NULL, 0, &size, 0);
4622 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4623 ok(size, "size not set\n");
4624
4625 buf = calloc(1, size);
4626 ret = BCryptExportKey(key, NULL, BCRYPT_DSA_PUBLIC_BLOB, buf, size, &size, 0);
4627 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4628 dsablob = (BCRYPT_DSA_KEY_BLOB *)buf;
4629 ok(dsablob->dwMagic == BCRYPT_DSA_PUBLIC_MAGIC, "got %#lx\n", dsablob->dwMagic);
4630 ok(dsablob->cbKey == 64, "got %lu\n", dsablob->cbKey);
4631 ok(size == sizeof(*dsablob) + dsablob->cbKey * 3, "got %lu\n", size);
4632
4633 ret = BCryptDestroyKey(key);
4634 ok(!ret, "got %#lx\n", ret);
4635
4636 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_DSA_PUBLIC_BLOB, &key, buf, size, 0);
4637 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4638 free(buf);
4639
4640 ret = BCryptVerifySignature(key, NULL, dsaHash, sizeof(dsaHash), sig, len, 0);
4641 ok(!ret, "got %#lx\n", ret);
4642 ret = BCryptDestroyKey(key);
4643 ok(!ret, "got %#lx\n", ret);
4644
4645 ret = BCryptImportKeyPair(alg, NULL, LEGACY_DSA_V2_PRIVATE_BLOB, &key, dssKey, sizeof(dssKey), 0);
4646 ok(!ret, "got %#lx\n", ret);
4647
4648 size = 0;
4649 ret = BCryptExportKey(key, NULL, LEGACY_DSA_V2_PRIVATE_BLOB, NULL, 0, &size, 0);
4650 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4651 ok(size, "size not set\n");
4652
4653 buf = calloc(1, size);
4654 ret = BCryptExportKey(key, NULL, LEGACY_DSA_V2_PRIVATE_BLOB, buf, size, &size, 0);
4655 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
4656 ok(size == sizeof(dssKey), "got %lu expected %Iu\n", size, sizeof(dssKey));
4657 ok(!memcmp(dssKey, buf, size), "wrong data\n");
4658 free(buf);
4659
4660 ret = BCryptDestroyKey(key);
4661 ok(!ret, "got %#lx\n", ret);
4662
4663 ret = BCryptCloseAlgorithmProvider(alg, 0);
4664 ok(!ret, "got %#lx\n", ret);
4665}
dsaSignature
static UCHAR dsaSignature[]
Definition: bcrypt.c:4523
dssKey
static UCHAR dssKey[]
Definition: bcrypt.c:4546
dsaPublicBlob
static UCHAR dsaPublicBlob[]
Definition: bcrypt.c:4529
dsaHash
static UCHAR dsaHash[]
Definition: bcrypt.c:4518
LEGACY_DSA_V2_PRIVATE_BLOB
#define LEGACY_DSA_V2_PRIVATE_BLOB
Definition: bcrypt.h:88
BCRYPT_DSA_KEY_BLOB
struct _BCRYPT_DSA_KEY_BLOB BCRYPT_DSA_KEY_BLOB
BCRYPT_DSA_ALGORITHM
#define BCRYPT_DSA_ALGORITHM
Definition: bcrypt.h:101
BCRYPT_PUBLIC_KEY_BLOB
#define BCRYPT_PUBLIC_KEY_BLOB
Definition: bcrypt.h:81
BCRYPT_DSA_PUBLIC_BLOB
#define BCRYPT_DSA_PUBLIC_BLOB
Definition: bcrypt.h:79
BCRYPT_DSA_PRIVATE_BLOB
#define BCRYPT_DSA_PRIVATE_BLOB
Definition: bcrypt.h:80
BCRYPT_DSA_PUBLIC_MAGIC
#define BCRYPT_DSA_PUBLIC_MAGIC
Definition: bcrypt.h:279
_BCRYPT_DSA_KEY_BLOB
Definition: bcrypt.h:283
_BCRYPT_DSA_KEY_BLOB::cbKey
ULONG cbKey
Definition: bcrypt.h:285
_BCRYPT_DSA_KEY_BLOB::dwMagic
ULONG dwMagic
Definition: bcrypt.h:284
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by START_TEST().

◆ test_ECDH()

static void test_ECDH ( void  )
static

Definition at line 3552 of file bcrypt.c.

3553{
3554 static BYTE ecc256privkey[] =
3555 {
3556 0x45, 0x43, 0x4b, 0x32, 0x20, 0x00, 0x00, 0x00,
3557 0xfb, 0xbd, 0x3d, 0x20, 0x1b, 0x6d, 0x66, 0xb3, 0x7c, 0x9f, 0x89, 0xf3, 0xe4, 0x41, 0x16, 0xa5,
3558 0x68, 0x52, 0x77, 0xac, 0xab, 0x55, 0xb2, 0x6c, 0xb0, 0x23, 0x55, 0xcb, 0x96, 0x14, 0xfd, 0x0b,
3559 0x1c, 0xef, 0xdf, 0x07, 0x6d, 0x31, 0xaf, 0x39, 0xce, 0x8c, 0x8f, 0x9d, 0x75, 0xd0, 0x7b, 0xea,
3560 0x81, 0xdc, 0x40, 0x21, 0x1f, 0x58, 0x22, 0x5f, 0x72, 0x55, 0xfc, 0x58, 0x8a, 0xeb, 0x88, 0x5d,
3561 0x02, 0x09, 0x90, 0xd2, 0xe3, 0x36, 0xac, 0xfe, 0x83, 0x13, 0x6c, 0x88, 0x1a, 0xab, 0x9b, 0xdd,
3562 0xaa, 0x8a, 0xee, 0x69, 0x9a, 0x6a, 0x62, 0x86, 0x6a, 0x13, 0x69, 0x88, 0xb7, 0xd5, 0xa3, 0xcd
3563 };
3564 static BYTE ecdh256_pubkey[] =
3565 {
3566 0x45, 0x43, 0x4b, 0x31, 0x20, 0x00, 0x00, 0x00,
3567 0x07, 0x61, 0x9d, 0x49, 0x63, 0x6b, 0x96, 0x94, 0xd1, 0x8f, 0xd1, 0x48, 0xcc, 0xcf, 0x72, 0x4d,
3568 0xff, 0x43, 0xf4, 0x97, 0x0f, 0xa3, 0x8a, 0x72, 0xe9, 0xe0, 0xba, 0x87, 0x6d, 0xc3, 0x62, 0x15,
3569 0xae, 0x65, 0xdd, 0x31, 0x51, 0xfc, 0x3b, 0xc9, 0x59, 0xa1, 0x0a, 0x92, 0x17, 0x2b, 0x64, 0x55,
3570 0x03, 0x3e, 0x62, 0x1d, 0xac, 0x3e, 0x37, 0x40, 0x6a, 0x4c, 0xb6, 0x21, 0x3f, 0x73, 0x5c, 0xf5
3571 };
3572 static BYTE ecdh256_secret[] =
3573 {
3574 0x48, 0xb0, 0x11, 0xdb, 0x69, 0x4e, 0xb4, 0xf4, 0xf5, 0x3e, 0xe1, 0x9b, 0xca, 0x00, 0x04, 0xc8,
3575 0x9b, 0x69, 0xaf, 0xd1, 0xaf, 0x1f, 0xc2, 0xd7, 0x83, 0x0a, 0xb7, 0xf8, 0x4f, 0x24, 0x32, 0x8e,
3576 };
3577 static BYTE hashed256_secret[] =
3578 {
3579 0x1b, 0xe7, 0xbf, 0x0f, 0x65, 0x1e, 0xd0, 0x07, 0xf9, 0xf4, 0x77, 0x48, 0x48, 0x39, 0xd0, 0xf8,
3580 0xf3, 0xce, 0xfc, 0x89
3581 };
3582 static BYTE hashed256_secret_prepended[] =
3583 {
3584 0x10, 0x99, 0x5f, 0x01, 0xef, 0xa8, 0x18, 0x82, 0xd2, 0x62, 0x37, 0xab, 0xe0, 0x7c, 0x62, 0xc7,
3585 0x50, 0x7f, 0xa6, 0xa0,
3586 };
3587
3588 static BYTE ecc384privkey[] =
3589 {
3590 0x45, 0x43, 0x4b, 0x34, 0x30, 0x00, 0x00, 0x00,
3591 0xc9, 0xcb, 0x38, 0x54, 0xa1, 0xe2, 0xb6, 0x60, 0x13, 0xd9, 0x45, 0x0d, 0x76, 0x90, 0xf9, 0x49,
3592 0x75, 0x81, 0x76, 0xac, 0x43, 0x96, 0xc1, 0x04, 0x04, 0xda, 0x76, 0x72, 0xb1, 0x19, 0x38, 0xbd,
3593 0xaf, 0x96, 0x0c, 0x4e, 0xc3, 0x29, 0x67, 0x91, 0x6c, 0xac, 0xcc, 0x33, 0x51, 0x1f, 0x82, 0xd5,
3594 0x17, 0xbf, 0xa2, 0x94, 0xd7, 0x15, 0x4f, 0x83, 0xe7, 0xa3, 0xb8, 0x6d, 0xd0, 0x7f, 0xbc, 0x8a,
3595 0x30, 0x09, 0x9e, 0x13, 0xaa, 0x2e, 0xf6, 0xde, 0x1c, 0x02, 0x4a, 0x65, 0xf6, 0x72, 0xb3, 0xf0,
3596 0x4f, 0x7f, 0x1a, 0xce, 0x4e, 0x94, 0xc5, 0x98, 0x89, 0x74, 0xad, 0x51, 0x8f, 0x2b, 0x25, 0x17,
3597 0xdc, 0x4a, 0x54, 0x8a, 0x42, 0xda, 0x30, 0x1a, 0xe3, 0x6d, 0x77, 0x4d, 0x3b, 0x33, 0x9a, 0xe3,
3598 0x37, 0xd4, 0x06, 0x5b, 0xb3, 0x3f, 0x73, 0xb9, 0x7e, 0x0b, 0x37, 0x02, 0x8b, 0xed, 0x08, 0x10,
3599 0x03, 0xf8, 0x69, 0xe3, 0x2a, 0x4f, 0xbb, 0x20, 0x6c, 0x5d, 0x24, 0x09, 0x0d, 0xd9, 0x86, 0x32,
3600 };
3601 static BYTE ecdh384_pubkey[] =
3602 {
3603 0x45, 0x43, 0x4b, 0x33, 0x30, 0x00, 0x00, 0x00,
3604 0xd6, 0xc3, 0xef, 0x4a, 0xbb, 0x4c, 0xa2, 0x27, 0xa1, 0x96, 0x03, 0x3b, 0x0a, 0x83, 0x01, 0xff,
3605 0xeb, 0x9a, 0xf1, 0x06, 0xee, 0x83, 0xce, 0x7c, 0xaa, 0x6b, 0x7c, 0x43, 0x1c, 0x8b, 0x30, 0x82,
3606 0x99, 0x8f, 0xc4, 0x86, 0x0d, 0x19, 0x16, 0xb6, 0xab, 0xd1, 0x9f, 0xeb, 0xf9, 0x31, 0xda, 0xcd,
3607 0xb9, 0xf8, 0xea, 0x87, 0xa1, 0x36, 0xaf, 0x10, 0x98, 0x8f, 0x9b, 0xcc, 0x6c, 0xe3, 0x24, 0xb4,
3608 0x82, 0x37, 0xde, 0x1e, 0x04, 0x53, 0x03, 0xc0, 0x2a, 0x41, 0xe9, 0x50, 0x07, 0x87, 0xb2, 0x60,
3609 0xe6, 0x32, 0x53, 0x4c, 0x8e, 0xa7, 0x80, 0x0f, 0xad, 0x25, 0x3b, 0x01, 0xa4, 0xd6, 0xe3, 0x54,
3610 };
3611 static BYTE ecdh384_secret[] =
3612 {
3613 0x08, 0x8c, 0xd1, 0xfa, 0x57, 0xb6, 0xf9, 0x79, 0x9e, 0x0c, 0x71, 0xc3, 0xcb, 0xa5, 0xb1, 0xfd,
3614 0xde, 0xbc, 0x6d, 0x7c, 0x8a, 0x5b, 0x26, 0xe8, 0x18, 0x80, 0x61, 0x45, 0x6a, 0x38, 0xf9, 0x13,
3615 0x2a, 0x8f, 0x4b, 0xfe, 0x75, 0x02, 0x62, 0xe9, 0xb3, 0x6e, 0xc5, 0x52, 0xc9, 0x82, 0x38, 0x53,
3616 };
3617 static BYTE hashed384_secret[] =
3618 {
3619 0x78, 0xf8, 0x07, 0xab, 0x00, 0x35, 0xaa, 0x8c, 0x22, 0xd0, 0xe7, 0x06, 0xfc, 0x0b, 0x74, 0x41,
3620 0xed, 0xdc, 0x16, 0x6c,
3621 };
3622 static BYTE hashed384_secret_prepended[] =
3623 {
3624 0x3d, 0xe0, 0x30, 0xd9, 0xe2, 0xdc, 0x61, 0xad, 0x26, 0x21, 0xad, 0xa3, 0x3e, 0xaf, 0xd5, 0x8e,
3625 0xb6, 0xbc, 0x5a, 0x51,
3626 };
3627
3628 static BYTE ecc521privkey[] =
3629 {
3630 0x45, 0x43, 0x4b, 0x36, 0x42, 0x00, 0x00, 0x00,
3631 0x01, 0x96, 0xb0, 0x4e, 0x35, 0x6f, 0xbe, 0x00, 0xb6, 0xc3, 0x83, 0x53, 0x92, 0x18, 0xda, 0x86,
3632 0x9e, 0x4b, 0x0f, 0xb2, 0x0b, 0xc3, 0x9f, 0xd8, 0x9c, 0x18, 0x8a, 0x93, 0x5c, 0x91, 0xb2, 0x4f,
3633 0x56, 0x7d, 0x0e, 0xf7, 0xf4, 0xdf, 0x91, 0xc6, 0x74, 0x00, 0xc7, 0xb8, 0x59, 0xeb, 0x55, 0xc0,
3634 0xb5, 0x26, 0x7f, 0x6d, 0x49, 0x53, 0x02, 0x3b, 0x3c, 0xa0, 0x57, 0x1e, 0x1c, 0x7c, 0x5b, 0x08,
3635 0x23, 0x68, 0x01, 0x47, 0x4d, 0x47, 0xcf, 0x05, 0xfe, 0x18, 0x26, 0x81, 0x9d, 0xb4, 0x34, 0xfa,
3636 0x50, 0x7e, 0x03, 0x29, 0xa3, 0x6e, 0x90, 0x9c, 0x27, 0x69, 0x66, 0x2c, 0x70, 0x7b, 0xf9, 0xe7,
3637 0xef, 0xac, 0x27, 0xbf, 0x15, 0x86, 0xf6, 0xff, 0x2d, 0x99, 0x41, 0x9e, 0x36, 0x1f, 0xe9, 0x3a,
3638 0x99, 0x74, 0x54, 0xf3, 0xc3, 0x08, 0xb1, 0x00, 0x28, 0x84, 0x82, 0x84, 0xe3, 0xf4, 0x32, 0xfd,
3639 0x48, 0x67, 0xae, 0x08, 0x01, 0xe2, 0x08, 0x1d, 0xeb, 0x27, 0xc2, 0x98, 0x45, 0x8b, 0x33, 0x20,
3640 0x3b, 0x21, 0x5c, 0x7f, 0x56, 0xbd, 0xa5, 0x99, 0x58, 0xea, 0x19, 0xf8, 0xbc, 0xf1, 0x9e, 0x39,
3641 0x00, 0xb9, 0x2c, 0x2a, 0xb6, 0x19, 0x3a, 0xaf, 0xea, 0x4b, 0xa6, 0x22, 0xb4, 0x35, 0x09, 0x86,
3642 0x2e, 0x67, 0xe0, 0xfe, 0x81, 0x0e, 0x6a, 0x68, 0x6a, 0xb3, 0x32, 0x3b, 0xf8, 0x89, 0x45, 0x72,
3643 0x69, 0xf1, 0xe1, 0x84, 0xd7, 0xed,
3644 };
3645 static BYTE ecdh521_pubkey[] =
3646 {
3647 0x45, 0x43, 0x4b, 0x35, 0x42, 0x00, 0x00, 0x00,
3648 0x00, 0xfd, 0x72, 0xca, 0x31, 0x08, 0x76, 0xd9, 0x08, 0xb7, 0x26, 0x4a, 0x04, 0xbc, 0x73, 0x1a,
3649 0x04, 0xbb, 0x77, 0xf4, 0xe2, 0xfc, 0x3a, 0x88, 0x0a, 0xa8, 0x72, 0x8f, 0xfc, 0xe9, 0xe3, 0x5f,
3650 0x73, 0x05, 0xf1, 0x7f, 0x31, 0xee, 0x15, 0x91, 0x36, 0xe9, 0xeb, 0xed, 0xbe, 0x0e, 0x78, 0xa1,
3651 0x28, 0x4e, 0xc5, 0xcb, 0xba, 0xd8, 0x0c, 0x96, 0x75, 0x44, 0x71, 0x71, 0x00, 0x41, 0x43, 0xdf,
3652 0x27, 0x91, 0x00, 0x81, 0xcc, 0x56, 0x8d, 0x8e, 0x32, 0xae, 0x78, 0xfb, 0x3e, 0x84, 0x7b, 0x3b,
3653 0xf8, 0x8e, 0x7b, 0x27, 0x73, 0xa4, 0x11, 0x61, 0x24, 0x40, 0x9b, 0xbe, 0xd3, 0xc3, 0x0e, 0xbb,
3654 0x26, 0xae, 0x55, 0x58, 0xd1, 0xec, 0x14, 0xd3, 0x13, 0xf2, 0x6b, 0x2b, 0xc3, 0xf9, 0xa4, 0x50,
3655 0x9e, 0xce, 0xfe, 0x18, 0xa0, 0x8b, 0x10, 0x80, 0x68, 0x72, 0x2e, 0x5c, 0xa0, 0xb3, 0x01, 0x6b,
3656 0x43, 0x26, 0xad, 0x58,
3657 };
3658 static BYTE ecdh521_secret[] =
3659 {
3660 0x2d, 0xab, 0x9f, 0x38, 0x14, 0x5d, 0x49, 0x65, 0x06, 0x22, 0x04, 0xf9, 0xb3, 0x25, 0xca, 0xf9,
3661 0xe6, 0xdc, 0xc6, 0xe8, 0xf9, 0x0b, 0xbf, 0x3c, 0x9d, 0xf0, 0x08, 0x95, 0x92, 0xdd, 0x92, 0x8a,
3662 0x95, 0x85, 0xe8, 0x1c, 0x6d, 0x41, 0xb9, 0xe4, 0x7b, 0x7a, 0xa5, 0x68, 0x30, 0x48, 0x8e, 0xc0,
3663 0xbc, 0x2b, 0xc6, 0xe9, 0x75, 0x9c, 0xed, 0xc3, 0xf5, 0x3a, 0xa3, 0xd7, 0x41, 0xec, 0x28, 0x82,
3664 0xef, 0x01,
3665 };
3666 static BYTE hashed521_secret[] =
3667 {
3668 0x72, 0x39, 0x73, 0x5f, 0xc9, 0x26, 0x1f, 0x8e, 0xe3, 0x30, 0x11, 0xe1, 0x4f, 0xc4, 0x65, 0xc0,
3669 0xde, 0xf9, 0xe6, 0x6a,
3670 };
3671 static BYTE hashed521_secret_prepended[] =
3672 {
3673 0x2e, 0x6f, 0x51, 0xc9, 0x15, 0xfb, 0x9f, 0xd0, 0xad, 0x92, 0x43, 0xdb, 0xc8, 0x6b, 0xd9, 0xe6,
3674 0x1a, 0x5f, 0x52, 0xa6,
3675 };
3676
3677 static const struct ecdh_test tests[] =
3678 {
3679 {
3680 BCRYPT_ECDH_P256_ALGORITHM, 256, ecc256privkey, sizeof(ecc256privkey), ecdh256_pubkey, sizeof(ecdh256_pubkey),
3681 ecdh256_secret, sizeof(ecdh256_secret), hashed256_secret, hashed256_secret_prepended,
3682 BCRYPT_ECDH_PUBLIC_P256_MAGIC, BCRYPT_ECDH_PRIVATE_P256_MAGIC,
3683 },
3684 {
3685 BCRYPT_ECDH_P384_ALGORITHM, 384, ecc384privkey, sizeof(ecc384privkey), ecdh384_pubkey, sizeof(ecdh384_pubkey),
3686 ecdh384_secret, sizeof(ecdh384_secret), hashed384_secret, hashed384_secret_prepended,
3687 BCRYPT_ECDH_PUBLIC_P384_MAGIC, BCRYPT_ECDH_PRIVATE_P384_MAGIC,
3688 },
3689 {
3690 BCRYPT_ECDH_P521_ALGORITHM, 521, ecc521privkey, sizeof(ecc521privkey), ecdh521_pubkey, sizeof(ecdh521_pubkey),
3691 ecdh521_secret, sizeof(ecdh521_secret), hashed521_secret, hashed521_secret_prepended,
3692 BCRYPT_ECDH_PUBLIC_P521_MAGIC, BCRYPT_ECDH_PRIVATE_P521_MAGIC,
3693 },
3694 };
3695 BCRYPT_ALG_HANDLE alg;
3696 BCRYPT_KEY_HANDLE key, key2;
3697 BCRYPT_ECCKEY_BLOB *blob;
3698 NTSTATUS status;
3699 ULONG strength, size, i;
3700 UCHAR *buf;
3701
3702 for (i = 0; i < ARRAY_SIZE(tests); ++i)
3703 {
3704 winetest_push_context("%s", debugstr_w(tests[i].alg));
3705 test_ECDH_alg(&tests[i]);
3706 winetest_pop_context();
3707 }
3708
3709 /* generic ECDH provider */
3710 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDH_ALGORITHM, NULL, 0);
3711 if (status == STATUS_NOT_FOUND)
3712 {
3713 win_skip("generic ECDH provider not found\n");
3714 return;
3715 }
3716 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3717
3718 status = BCryptGenerateKeyPair(alg, &key, 0, 0);
3719 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3720
3721 status = BCryptFinalizeKeyPair(key, 0);
3722 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
3723 BCryptDestroyKey(key);
3724 BCryptCloseAlgorithmProvider(alg, 0);
3725
3726 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDH_ALGORITHM, NULL, 0);
3727 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3728
3729 status = BCryptSetProperty(alg, BCRYPT_ECC_CURVE_NAME, (UCHAR *)BCRYPT_ECC_CURVE_SECP256R1, sizeof(BCRYPT_ECC_CURVE_SECP256R1), 0);
3730 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3731
3732 status = BCryptGenerateKeyPair(alg, &key, 255, 0);
3733 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
3734
3735 status = BCryptGenerateKeyPair(alg, &key, 0, 0);
3736 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3737
3738 strength = 0;
3739 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&strength, sizeof(strength), &size, 0);
3740 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3741 ok(strength == 256, "got %lu\n", strength);
3742
3743 status = BCryptFinalizeKeyPair(key, 0);
3744 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3745 BCryptDestroyKey(key);
3746 BCryptCloseAlgorithmProvider(alg, 0);
3747
3748 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDH_ALGORITHM, NULL, 0);
3749 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3750
3751 status = BCryptSetProperty(alg, BCRYPT_ECC_CURVE_NAME, (UCHAR *)BCRYPT_ECC_CURVE_25519, sizeof(BCRYPT_ECC_CURVE_25519), 0);
3752 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3753
3754 status = BCryptGenerateKeyPair(alg, &key, 253, 0);
3755 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
3756
3757 status = BCryptGenerateKeyPair(alg, &key, 255, 0);
3758 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3759 BCryptDestroyKey(key);
3760
3761 status = BCryptGenerateKeyPair(alg, &key, 0, 0);
3762 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3763
3764 strength = 0;
3765 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&strength, sizeof(strength), &size, 0);
3766 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3767 ok(strength == 253, "got %lu\n", strength);
3768
3769 status = BCryptFinalizeKeyPair(key, 0);
3770 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3771
3772 size = 0;
3773 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, NULL, 0, &size, 0);
3774 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3775 ok(size, "size not set\n");
3776
3777 buf = malloc(size);
3778 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, buf, size, &size, 0);
3779 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3780 blob = (BCRYPT_ECCKEY_BLOB *)buf;
3781 ok(blob->dwMagic == BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC, "got %08lx\n", blob->dwMagic);
3782 ok(blob->cbKey == 32, "got %lu\n", blob->cbKey);
3783
3784 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key2, buf, size, 0);
3785 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3786
3787 free( buf );
3788 BCryptDestroyKey(key2);
3789 BCryptDestroyKey(key);
3790 BCryptCloseAlgorithmProvider(alg, 0);
3791
3792 /* Brainpool curve */
3793 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDH_ALGORITHM, NULL, 0);
3794 ok(!status, "got %#lx\n", status);
3795
3796 status = BCryptSetProperty(alg, BCRYPT_ECC_CURVE_NAME, (UCHAR *)BCRYPT_ECC_CURVE_BRAINPOOLP256R1,
3797 sizeof(BCRYPT_ECC_CURVE_BRAINPOOLP256R1), 0 );
3798 ok(!status, "got %#lx\n", status);
3799
3800 status = BCryptGenerateKeyPair(alg, &key, 256, 0);
3801 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3802
3803 BCryptDestroyKey(key);
3804 BCryptCloseAlgorithmProvider(alg, 0);
3805}
test_ECDH_alg
static void test_ECDH_alg(const struct ecdh_test *t)
Definition: bcrypt.c:3356
BCRYPT_ECDH_P384_ALGORITHM
#define BCRYPT_ECDH_P384_ALGORITHM
Definition: bcrypt.h:104
BCRYPT_ECDH_PRIVATE_P256_MAGIC
#define BCRYPT_ECDH_PRIVATE_P256_MAGIC
Definition: bcrypt.h:165
BCRYPT_ECCPUBLIC_BLOB
#define BCRYPT_ECCPUBLIC_BLOB
Definition: bcrypt.h:74
BCRYPT_ECDH_PUBLIC_P384_MAGIC
#define BCRYPT_ECDH_PUBLIC_P384_MAGIC
Definition: bcrypt.h:166
BCRYPT_ECDH_P521_ALGORITHM
#define BCRYPT_ECDH_P521_ALGORITHM
Definition: bcrypt.h:105
BCRYPT_ECC_CURVE_NAME
#define BCRYPT_ECC_CURVE_NAME
Definition: bcrypt.h:138
BCRYPT_ECC_CURVE_25519
#define BCRYPT_ECC_CURVE_25519
Definition: bcrypt.h:139
BCRYPT_ECC_CURVE_BRAINPOOLP256R1
#define BCRYPT_ECC_CURVE_BRAINPOOLP256R1
Definition: bcrypt.h:140
BCRYPT_ECDH_PUBLIC_P256_MAGIC
#define BCRYPT_ECDH_PUBLIC_P256_MAGIC
Definition: bcrypt.h:164
BCRYPT_ECCPRIVATE_BLOB
#define BCRYPT_ECCPRIVATE_BLOB
Definition: bcrypt.h:75
BCRYPT_ECDH_ALGORITHM
#define BCRYPT_ECDH_ALGORITHM
Definition: bcrypt.h:102
BCRYPT_ECDH_PRIVATE_P384_MAGIC
#define BCRYPT_ECDH_PRIVATE_P384_MAGIC
Definition: bcrypt.h:167
BCRYPT_ECC_CURVE_SECP256R1
#define BCRYPT_ECC_CURVE_SECP256R1
Definition: bcrypt.h:142
BCRYPT_ECDH_PUBLIC_P521_MAGIC
#define BCRYPT_ECDH_PUBLIC_P521_MAGIC
Definition: bcrypt.h:168
BCRYPT_ECDH_P256_ALGORITHM
#define BCRYPT_ECDH_P256_ALGORITHM
Definition: bcrypt.h:103
BCRYPT_ECDH_PRIVATE_P521_MAGIC
#define BCRYPT_ECDH_PRIVATE_P521_MAGIC
Definition: bcrypt.h:169
BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC
#define BCRYPT_ECDH_PRIVATE_GENERIC_MAGIC
Definition: bcrypt.h:172
debugstr_w
#define debugstr_w
Definition: kernel32.h:32
winetest_pop_context
void __cdecl void __cdecl void __cdecl void __cdecl void __cdecl void winetest_pop_context(void)
winetest_push_context
void __cdecl void __cdecl void __cdecl void __cdecl void __cdecl winetest_push_context(const char *fmt,...) __WINE_PRINTF_ATTR(1
Definition: test.h:539
tests
static struct test_info tests[]
_BCRYPT_ECCKEY_BLOB
Definition: bcrypt.h:236
ecdh_test
Definition: bcrypt.c:3339
ecdh_test::alg
const WCHAR * alg
Definition: bcrypt.c:3340

Referenced by START_TEST().

◆ test_ECDH_alg()

static void test_ECDH_alg ( const struct ecdh_test *  t)
static

Definition at line 3356 of file bcrypt.c.

3357{
3358 BCryptBuffer hash_param_buffers[] =
3359 {
3360 {
3361 sizeof(BCRYPT_SHA1_ALGORITHM),
3362 KDF_HASH_ALGORITHM,
3363 (void *)BCRYPT_SHA1_ALGORITHM,
3364 }
3365 };
3366 BCryptBuffer hash_param_buffers_prepended[] =
3367 {
3368 {
3369 sizeof(BCRYPT_SHA1_ALGORITHM),
3370 KDF_HASH_ALGORITHM,
3371 (void *)BCRYPT_SHA1_ALGORITHM,
3372 },
3373 {
3374 sizeof(hash_prepend[0]),
3375 KDF_SECRET_PREPEND,
3376 (void *)hash_prepend[0],
3377 },
3378 {
3379 sizeof(hash_prepend[1]),
3380 KDF_SECRET_PREPEND,
3381 (void *)hash_prepend[1],
3382 }
3383 };
3384
3385 BCryptBufferDesc hash_params =
3386 {
3387 BCRYPTBUFFER_VERSION,
3388 ARRAY_SIZE(hash_param_buffers),
3389 hash_param_buffers,
3390 };
3391 BCryptBufferDesc hash_params_prepended =
3392 {
3393 BCRYPTBUFFER_VERSION,
3394 ARRAY_SIZE(hash_param_buffers_prepended),
3395 hash_param_buffers_prepended,
3396 };
3397 BYTE *buf;
3398 BCRYPT_ECCKEY_BLOB *ecckey;
3399 BCRYPT_ALG_HANDLE alg;
3400 BCRYPT_KEY_HANDLE key, privkey, pubkey;
3401 BCRYPT_SECRET_HANDLE secret;
3402 NTSTATUS status;
3403 ULONG size;
3404
3405 status = BCryptOpenAlgorithmProvider(&alg, t->alg, NULL, 0);
3406 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3407
3408 key = NULL;
3409 status = BCryptGenerateKeyPair(alg, &key, t->bitlen, 0);
3410 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3411 ok(key != NULL, "key not set\n");
3412
3413 status = BCryptFinalizeKeyPair(key, 0);
3414 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3415
3416 size = 0;
3417 status = BCryptExportKey(key, NULL, BCRYPT_ECCPUBLIC_BLOB, NULL, 0, &size, 0);
3418 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3419 ok(size, "size not set\n");
3420
3421 buf = malloc(size);
3422 status = BCryptExportKey(key, NULL, BCRYPT_ECCPUBLIC_BLOB, buf, size, &size, 0);
3423 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3424 ecckey = (BCRYPT_ECCKEY_BLOB *)buf;
3425 ok(ecckey->dwMagic == t->public_magic, "got %#lx\n", ecckey->dwMagic);
3426 ok(ecckey->cbKey == (t->bitlen + 7) / 8, "got %lu\n", ecckey->cbKey);
3427 ok(size == sizeof(*ecckey) + ecckey->cbKey * 2, "got %lu\n", size);
3428
3429 status = BCryptImportKeyPair(alg, NULL, BCRYPT_PUBLIC_KEY_BLOB, &pubkey, buf, size, 0);
3430 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3431 BCryptDestroyKey(pubkey);
3432
3433 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &pubkey, buf, size, 0);
3434 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3435 free(buf);
3436
3437 size = 0;
3438 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, NULL, 0, &size, 0);
3439 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3440 ok(size, "size not set\n");
3441
3442 buf = malloc(size);
3443 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, buf, size, &size, 0);
3444 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3445 ecckey = (BCRYPT_ECCKEY_BLOB *)buf;
3446 ok(ecckey->dwMagic == t->private_magic, "got %#lx\n", ecckey->dwMagic);
3447 ok(ecckey->cbKey == (t->bitlen + 7) / 8, "got %lu\n", ecckey->cbKey);
3448 ok(size == sizeof(*ecckey) + ecckey->cbKey * 3, "got %lu\n", size);
3449
3450 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPRIVATE_BLOB, &privkey, buf, size, 0);
3451 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3452 free(buf);
3453 BCryptDestroyKey(pubkey);
3454 BCryptDestroyKey(privkey);
3455 BCryptDestroyKey(key);
3456
3457 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPRIVATE_BLOB, &privkey, t->eccprivkey, t->eccprivkey_len, 0);
3458 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3459
3460 size = 0;
3461 status = BCryptExportKey(privkey, NULL, BCRYPT_ECCPRIVATE_BLOB, NULL, 0, &size, 0);
3462 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3463 ok(size, "size not set\n");
3464
3465 buf = malloc(size);
3466 status = BCryptExportKey(privkey, NULL, BCRYPT_ECCPRIVATE_BLOB, buf, size, &size, 0);
3467 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3468 ok(size == t->eccprivkey_len, "got %lu\n", size);
3469 ok(!memcmp(buf, t->eccprivkey, size), "wrong data\n");
3470 free(buf);
3471
3472 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &pubkey, t->ecdh_pubkey, t->ecdh_pubkey_len, 0);
3473 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3474
3475 status = BCryptSecretAgreement(privkey, pubkey, &secret, 0);
3476 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3477 if (status != STATUS_SUCCESS) goto derive_end;
3478
3479 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, NULL, 0, &size, 0);
3480 if (status == STATUS_NOT_SUPPORTED) /* < win10 */
3481 {
3482 win_skip("BCRYPT_KDF_RAW_SECRET not supported\n");
3483 goto raw_secret_end;
3484 }
3485 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3486 if (status != STATUS_SUCCESS) goto raw_secret_end;
3487
3488 ok(size == (t->bitlen + 7) / 8, "size of secret key incorrect, got %lu, expected 32\n", size);
3489 buf = malloc(size);
3490 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, buf, size, &size, 0);
3491 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3492 ok(!(memcmp(t->ecdh_secret, buf, size)), "wrong data\n");
3493 free(buf);
3494
3495 /* Raw secret with a BCryptBufferDesc, which is ignored */
3496 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, &hash_params_prepended, NULL, 0, &size, 0);
3497 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3498
3499 ok(size == (t->bitlen + 7) / 8, "size of secret key incorrect, got %lu, expected 32\n", size);
3500 buf = malloc(size);
3501 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, &hash_params_prepended, buf, size, &size, 0);
3502 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3503 ok(!(memcmp(t->ecdh_secret, buf, size)), "wrong data\n");
3504 free(buf);
3505
3506raw_secret_end:
3507 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params, NULL, 0, &size, 0);
3508 ok (status == STATUS_SUCCESS, "got %#lx\n", status);
3509 if (status != STATUS_SUCCESS) goto derive_end;
3510
3511 ok (size == 20, "got %lu\n", size);
3512 buf = malloc(size);
3513 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params, buf, size, &size, 0);
3514 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3515 ok(!(memcmp(t->hashed_secret, buf, size)), "wrong data\n");
3516 free(buf);
3517
3518 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params_prepended, NULL, 0, &size, 0);
3519 ok (status == STATUS_SUCCESS, "got %#lx\n", status);
3520
3521 ok (size == 20, "got %lu\n", size);
3522 buf = malloc(size);
3523 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params_prepended, buf, size, &size, 0);
3524 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
3525 ok(!(memcmp(t->hashed_secret_prepended, buf, size)), "wrong data\n");
3526 free(buf);
3527
3528 /* ulVersion is not verified */
3529 hash_params.ulVersion = 0xdeadbeef;
3530 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params, NULL, 0, &size, 0);
3531 ok (status == STATUS_SUCCESS, "got %#lx\n", status);
3532
3533 hash_params.ulVersion = BCRYPTBUFFER_VERSION;
3534 hash_param_buffers[0].pvBuffer = (void*) L"INVALID";
3535 hash_param_buffers[0].cbBuffer = sizeof(L"INVALID");
3536
3537 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params, NULL, 0, &size, 0);
3538 ok (status == STATUS_NOT_SUPPORTED || broken (status == STATUS_NOT_FOUND) /* < win8 */, "got %#lx\n", status);
3539
3540 hash_param_buffers[0].pvBuffer = (void*) BCRYPT_RNG_ALGORITHM;
3541 hash_param_buffers[0].cbBuffer = sizeof(BCRYPT_RNG_ALGORITHM);
3542 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params, NULL, 0, &size, 0);
3543 ok (status == STATUS_NOT_SUPPORTED, "got %#lx\n", status);
3544
3545derive_end:
3546 BCryptDestroySecret(secret);
3547 BCryptDestroyKey(pubkey);
3548 BCryptDestroyKey(privkey);
3549 BCryptCloseAlgorithmProvider(alg, 0);
3550}
hash_prepend
static const UCHAR hash_prepend[][2]
Definition: bcrypt.c:3354
BCRYPTBUFFER_VERSION
#define BCRYPTBUFFER_VERSION
Definition: bcrypt.h:397
KDF_SECRET_PREPEND
#define KDF_SECRET_PREPEND
Definition: bcrypt.h:372
KDF_HASH_ALGORITHM
#define KDF_HASH_ALGORITHM
Definition: bcrypt.h:371
BCRYPT_RNG_ALGORITHM
#define BCRYPT_RNG_ALGORITHM
Definition: bcrypt.h:116
t
GLdouble GLdouble t
Definition: gl.h:2047
_BCRYPT_ECCKEY_BLOB::dwMagic
ULONG dwMagic
Definition: bcrypt.h:237
_BCRYPT_ECCKEY_BLOB::cbKey
ULONG cbKey
Definition: bcrypt.h:238
_BCryptBufferDesc
Definition: bcrypt.h:400
_BCryptBufferDesc::ulVersion
ULONG ulVersion
Definition: bcrypt.h:401
_BCryptBuffer
Definition: bcrypt.h:391
_BCryptBuffer::cbBuffer
ULONG cbBuffer
Definition: bcrypt.h:392
_BCryptBuffer::pvBuffer
void * pvBuffer
Definition: bcrypt.h:394

Referenced by test_ECDH().

◆ test_ECDSA()

static void test_ECDSA ( void  )
static

Definition at line 2303 of file bcrypt.c.

2304{
2305 static UCHAR hash[] =
2306 {0x7e, 0xe3, 0x74, 0xe7, 0xc5, 0x0b, 0x6b, 0x70, 0xdb, 0xab, 0x32, 0x6d, 0x1d, 0x51, 0xd6,
2307 0x74, 0x79, 0x8e, 0x5b, 0x4b};
2308 BYTE buffer[sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(ecc521Privkey)];
2309 BCRYPT_ECCKEY_BLOB *ecckey = (void *)buffer;
2310 BCRYPT_ALG_HANDLE alg;
2311 BCRYPT_KEY_HANDLE key;
2312 NTSTATUS status;
2313 DWORD keylen;
2314 ULONG size, strength;
2315 UCHAR sig[64];
2316
2317 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_P256_ALGORITHM, NULL, 0);
2318 ok(!status, "got %#lx\n", status);
2319
2320 ecckey->dwMagic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
2321 memcpy(ecckey + 1, eccPubkey, sizeof(eccPubkey));
2322
2323 ecckey->cbKey = 2;
2324 size = sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(eccPubkey);
2325 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, size, 0);
2326 ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", status);
2327
2328 ecckey->dwMagic = BCRYPT_ECDH_PUBLIC_P256_MAGIC;
2329 ecckey->cbKey = 32;
2330 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, size, 0);
2331 ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", status);
2332
2333 ecckey->dwMagic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC;
2334 ecckey->cbKey = 32;
2335 status = BCryptImportKeyPair(alg, NULL, BCRYPT_PUBLIC_KEY_BLOB, &key, buffer, size, 0);
2336 ok(!status, "BCryptImportKeyPair failed: %#lx\n", status);
2337 BCryptDestroyKey(key);
2338
2339 if (pBCryptHash)
2340 {
2341 status = BCryptImportKeyPair(BCRYPT_ECDSA_P256_ALG_HANDLE, NULL, BCRYPT_PUBLIC_KEY_BLOB, &key, buffer,
2342 size, 0);
2343 ok(!status, "BCryptImportKeyPair failed: %#lx\n", status);
2344 BCryptDestroyKey(key);
2345 }
2346
2347 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, size, 0);
2348 ok(!status, "BCryptImportKeyPair failed: %#lx\n", status);
2349
2350 keylen = 0;
2351 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&keylen, sizeof(keylen), &size, 0);
2352 ok(!status, "got %#lx\n", status);
2353 ok(size == sizeof(keylen), "got %lu\n", size);
2354 ok(keylen == 256, "got %lu\n", keylen);
2355
2356 memset(buffer, 0xcc, sizeof(buffer));
2357 status = BCryptExportKey(key, NULL, BCRYPT_ECCPUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
2358 ok(!status, "Got unexpected status %#lx\n", status);
2359 ok(ecckey->dwMagic == BCRYPT_ECDSA_PUBLIC_P256_MAGIC, "Got unexpected magic %#lx.\n", ecckey->dwMagic);
2360 ok(ecckey->cbKey == 32, "got %lu\n", ecckey->cbKey);
2361 ok(!memcmp(ecckey + 1, eccPubkey, sizeof(eccPubkey)), "Got unexpected key data.\n");
2362
2363 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, buffer, sizeof(buffer), &size, 0);
2364 ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#lx\n", status);
2365
2366 status = BCryptVerifySignature(key, NULL, certHash, sizeof(certHash) - 1, certSignature, sizeof(certSignature), 0);
2367 ok(status == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %#lx\n", status);
2368
2369 status = BCryptVerifySignature(key, NULL, certHash, sizeof(certHash), certSignature, sizeof(certSignature), 0);
2370 ok(!status, "BCryptVerifySignature failed: %#lx\n", status);
2371 BCryptDestroyKey(key);
2372
2373 ecckey->dwMagic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
2374 memcpy(ecckey + 1, eccPrivkey, sizeof(eccPrivkey));
2375
2376 ecckey->cbKey = 2;
2377 size = sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(eccPrivkey);
2378 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPRIVATE_BLOB, &key, buffer, size, 0);
2379 ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", status);
2380
2381 ecckey->dwMagic = BCRYPT_ECDH_PRIVATE_P256_MAGIC;
2382 ecckey->cbKey = 32;
2383 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPRIVATE_BLOB, &key, buffer, size, 0);
2384 ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", status);
2385
2386 ecckey->dwMagic = BCRYPT_ECDSA_PRIVATE_P256_MAGIC;
2387 ecckey->cbKey = 32;
2388 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPRIVATE_BLOB, &key, buffer, size, 0);
2389 ok(!status, "BCryptImportKeyPair failed: %#lx\n", status);
2390
2391 memset( buffer, 0xcc, sizeof(buffer) );
2392 status = BCryptExportKey(key, NULL, BCRYPT_ECCPUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
2393 ok(!status, "Got unexpected status %#lx\n", status);
2394 ok(ecckey->dwMagic == BCRYPT_ECDSA_PUBLIC_P256_MAGIC, "got %#lx\n", ecckey->dwMagic);
2395 ok(ecckey->cbKey == 32, "got %lu\n", ecckey->cbKey);
2396 ok(!memcmp(ecckey + 1, eccPrivkey, sizeof(eccPubkey)), "Got unexpected key data.\n");
2397
2398 size = sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(eccPrivkey);
2399 memset( buffer, 0, sizeof(buffer) );
2400 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, buffer, size, &size, 0);
2401 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2402 ecckey = (BCRYPT_ECCKEY_BLOB *)buffer;
2403 ok(ecckey->dwMagic == BCRYPT_ECDSA_PRIVATE_P256_MAGIC, "got %#lx\n", ecckey->dwMagic);
2404 ok(ecckey->cbKey == 32, "got %lu\n", ecckey->cbKey);
2405 ok(size == sizeof(*ecckey) + ecckey->cbKey * 3, "got %lu\n", size);
2406
2407 BCryptDestroyKey(key);
2408 BCryptCloseAlgorithmProvider(alg, 0);
2409
2410 /* P521 */
2411 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_P521_ALGORITHM, NULL, 0);
2412 ok(!status, "got %#lx\n", status);
2413
2414 ecckey->dwMagic = BCRYPT_ECDSA_PUBLIC_P521_MAGIC;
2415 ecckey->cbKey = 66;
2416 size = sizeof(BCRYPT_ECCKEY_BLOB) + ecckey->cbKey * 2;
2417 memcpy(ecckey + 1, ecc521Privkey, ecckey->cbKey * 2);
2418 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, size, 0);
2419 ok(!status, "BCryptImportKeyPair failed: %#lx\n", status);
2420
2421 keylen = 0;
2422 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&keylen, sizeof(keylen), &size, 0);
2423 ok(!status, "got %#lx\n", status);
2424 ok(size == sizeof(keylen), "got %lu\n", size);
2425 ok(keylen == 521, "got %lu\n", keylen);
2426
2427 memset(buffer, 0xcc, sizeof(buffer));
2428 status = BCryptExportKey(key, NULL, BCRYPT_ECCPUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
2429 ok(!status, "Got unexpected status %#lx\n", status);
2430 ok(ecckey->dwMagic == BCRYPT_ECDSA_PUBLIC_P521_MAGIC, "Got unexpected magic %#lx.\n", ecckey->dwMagic);
2431 ok(ecckey->cbKey == 66, "got %lu\n", ecckey->cbKey);
2432 ok(!memcmp(ecckey + 1, ecc521Privkey, ecckey->cbKey * 2), "Got unexpected key data.\n");
2433
2434 memcpy(buffer, cert521Signature, sizeof(cert521Signature));
2435 status = BCryptVerifySignature(key, NULL, certHash, sizeof(certHash), buffer, sizeof(cert521Signature), 0);
2436 ok(!status, "BCryptVerifySignature failed: %#lx\n", status);
2437
2438 ++buffer[5];
2439 status = BCryptVerifySignature(key, NULL, certHash, sizeof(certHash), buffer, sizeof(cert521Signature), 0);
2440 ok(status == STATUS_INVALID_SIGNATURE, "BCryptVerifySignature failed: %#lx\n", status);
2441
2442 BCryptDestroyKey(key);
2443
2444 ecckey->dwMagic = BCRYPT_ECDSA_PRIVATE_P521_MAGIC;
2445 ecckey->cbKey = 66;
2446 memcpy(ecckey + 1, ecc521Privkey, sizeof(ecc521Privkey));
2447 size = sizeof(*ecckey) + sizeof(ecc521Privkey);
2448 status = BCryptImportKeyPair(alg, NULL, BCRYPT_ECCPRIVATE_BLOB, &key, buffer, size, 0);
2449 ok(!status, "BCryptImportKeyPair failed: %#lx\n", status);
2450
2451 memset( buffer, 0xcc, sizeof(buffer) );
2452 status = BCryptExportKey(key, NULL, BCRYPT_ECCPUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
2453 ok(!status, "Got unexpected status %#lx\n", status);
2454 ok(ecckey->dwMagic == BCRYPT_ECDSA_PUBLIC_P521_MAGIC, "got %#lx\n", ecckey->dwMagic);
2455 ok(ecckey->cbKey == 66, "got %lu\n", ecckey->cbKey);
2456 ok(!memcmp(ecckey + 1, ecc521Privkey, ecckey->cbKey * 2), "Got unexpected key data.\n");
2457
2458 size = sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(ecc521Privkey);
2459 memset( buffer, 0xcc, sizeof(buffer) );
2460 status = BCryptExportKey(key, NULL, BCRYPT_ECCPRIVATE_BLOB, buffer, size, &size, 0);
2461 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2462 ecckey = (BCRYPT_ECCKEY_BLOB *)buffer;
2463 ok(ecckey->dwMagic == BCRYPT_ECDSA_PRIVATE_P521_MAGIC, "got %#lx\n", ecckey->dwMagic);
2464 ok(ecckey->cbKey == 66, "got %lu\n", ecckey->cbKey);
2465 ok(size == sizeof(*ecckey) + ecckey->cbKey * 3, "got %lu\n", size);
2466 ok(!memcmp(ecckey + 1, ecc521Privkey, ecckey->cbKey * 3), "Got unexpected key data.\n");
2467
2468 BCryptDestroyKey(key);
2469 BCryptCloseAlgorithmProvider(alg, 0);
2470
2471 /* generic ECDSA provider */
2472 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_ALGORITHM, NULL, 0);
2473 if (status == STATUS_NOT_FOUND)
2474 {
2475 win_skip("generic ECDSA provider not found\n");
2476 return;
2477 }
2478 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2479
2480 status = BCryptGenerateKeyPair(alg, &key, 0, 0);
2481 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2482
2483 status = BCryptFinalizeKeyPair(key, 0);
2484 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
2485 BCryptDestroyKey(key);
2486 BCryptCloseAlgorithmProvider(alg, 0);
2487
2488 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_ALGORITHM, NULL, 0);
2489 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2490
2491 status = BCryptSetProperty(alg, BCRYPT_ECC_CURVE_NAME, (UCHAR *)BCRYPT_ECC_CURVE_SECP256R1, sizeof(BCRYPT_ECC_CURVE_SECP256R1), 0);
2492 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2493
2494 status = BCryptGenerateKeyPair(alg, &key, 255, 0);
2495 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
2496
2497 status = BCryptGenerateKeyPair(alg, &key, 0, 0);
2498 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2499
2500 strength = 0;
2501 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&strength, sizeof(strength), &size, 0);
2502 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2503 ok(strength == 256, "got %lu\n", strength);
2504
2505 status = BCryptFinalizeKeyPair(key, 0);
2506 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2507 BCryptDestroyKey(key);
2508 BCryptCloseAlgorithmProvider(alg, 0);
2509
2510 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_ALGORITHM, NULL, 0);
2511 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2512
2513 status = BCryptSetProperty(alg, BCRYPT_ECC_CURVE_NAME, (UCHAR *)BCRYPT_ECC_CURVE_25519, sizeof(BCRYPT_ECC_CURVE_25519), 0);
2514 ok(status == STATUS_NOT_SUPPORTED, "got %#lx\n", status);
2515 BCryptCloseAlgorithmProvider(alg, 0);
2516
2517 /* Brainpool curve */
2518 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_ALGORITHM, NULL, 0);
2519 ok(!status, "got %#lx\n", status);
2520
2521 status = BCryptSetProperty(alg, BCRYPT_ECC_CURVE_NAME, (UCHAR *)BCRYPT_ECC_CURVE_BRAINPOOLP256R1,
2522 sizeof(BCRYPT_ECC_CURVE_BRAINPOOLP256R1), 0 );
2523 ok(!status, "got %#lx\n", status);
2524
2525 status = BCryptGenerateKeyPair(alg, &key, 256, 0);
2526 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2527
2528 strength = 0;
2529 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&strength, sizeof(strength), &size, 0);
2530 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2531 ok(strength == 256, "got %lu\n", strength);
2532
2533 status = BCryptFinalizeKeyPair(key, 0);
2534 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2535
2536 size = 0;
2537 status = BCryptSignHash(key, NULL, hash, sizeof(hash), sig, sizeof(sig), &size, 0);
2538 ok (status == STATUS_SUCCESS, "got %#lx\n", status);
2539 ok (size == 64, "got %lu\n", size);
2540
2541 status = BCryptVerifySignature(key, NULL, hash, sizeof(hash), sig, size, 0);
2542 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
2543 BCryptDestroyKey(key);
2544 BCryptCloseAlgorithmProvider(alg, 0);
2545}
cert521Signature
static BYTE cert521Signature[]
Definition: bcrypt.c:2290
ecc521Privkey
static BYTE ecc521Privkey[]
Definition: bcrypt.c:2246
eccPrivkey
static BYTE eccPrivkey[]
Definition: bcrypt.c:2234
certSignature
static BYTE certSignature[]
Definition: bcrypt.c:2281
certHash
static BYTE certHash[]
Definition: bcrypt.c:2276
eccPubkey
static BYTE eccPubkey[]
Definition: bcrypt.c:2267
BCRYPT_ECDSA_PUBLIC_P256_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P256_MAGIC
Definition: bcrypt.h:157
BCRYPT_ECDSA_ALGORITHM
#define BCRYPT_ECDSA_ALGORITHM
Definition: bcrypt.h:106
BCRYPT_ECCKEY_BLOB
struct _BCRYPT_ECCKEY_BLOB BCRYPT_ECCKEY_BLOB
BCRYPT_ECDSA_PRIVATE_P521_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P521_MAGIC
Definition: bcrypt.h:162
BCRYPT_ECDSA_PRIVATE_P256_MAGIC
#define BCRYPT_ECDSA_PRIVATE_P256_MAGIC
Definition: bcrypt.h:158
BCRYPT_ECDSA_PUBLIC_P521_MAGIC
#define BCRYPT_ECDSA_PUBLIC_P521_MAGIC
Definition: bcrypt.h:161
BCRYPT_ECDSA_P256_ALG_HANDLE
#define BCRYPT_ECDSA_P256_ALG_HANDLE
Definition: bcrypt.h:462
STATUS_INVALID_SIGNATURE
#define STATUS_INVALID_SIGNATURE
Definition: ntstatus.h:1397

Referenced by START_TEST().

◆ test_hash()

static void test_hash ( const struct hash_test *  test)
static

Definition at line 207 of file bcrypt.c.

208{
209 BCRYPT_ALG_HANDLE alg;
210 BCRYPT_HASH_HANDLE hash;
211 UCHAR buf[512], buf_hmac[1024], hash_buf[128], hmac_hash[128];
212 char str[512];
213 NTSTATUS ret;
214 ULONG len;
215
216 alg = NULL;
217 ret = BCryptOpenAlgorithmProvider(&alg, test->alg, MS_PRIMITIVE_PROVIDER, 0);
218 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
219 ok(alg != NULL, "alg not set\n");
220
221 test_object_length(alg);
222 test_hash_length(alg, test->hash_size);
223 test_hash_block_length(alg, test->block_size);
224 test_alg_name(alg, test->alg);
225
226 hash = NULL;
227 len = sizeof(buf);
228 ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, 0);
229 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
230 ok(hash != NULL, "hash not set\n");
231
232 ret = BCryptHashData(hash, NULL, 0, 0);
233 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
234
235 ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
236 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
237
238 test_hash_length(hash, test->hash_size);
239 test_alg_name(hash, test->alg);
240
241 memset(hash_buf, 0, sizeof(hash_buf));
242 ret = BCryptFinishHash(hash, hash_buf, test->hash_size, 0);
243 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
244 format_hash( hash_buf, test->hash_size, str );
245 ok(!strcmp(str, test->hash), "got %s\n", str);
246
247 ret = BCryptDestroyHash(hash);
248 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
249
250 hash = NULL;
251 len = sizeof(buf);
252 ret = BCryptCreateHash(alg, &hash, buf, len, NULL, 0, BCRYPT_HASH_REUSABLE_FLAG);
253 ok(ret == STATUS_SUCCESS || broken(ret == STATUS_INVALID_PARAMETER) /* < win8 */, "got %#lx\n", ret);
254 if (ret == STATUS_SUCCESS)
255 {
256 ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
257 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
258
259 memset(hash_buf, 0, sizeof(hash_buf));
260 ret = BCryptFinishHash(hash, hash_buf, test->hash_size, 0);
261 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
262 format_hash( hash_buf, test->hash_size, str );
263 ok(!strcmp(str, test->hash), "got %s\n", str);
264
265 /* reuse it */
266 ret = BCryptHashData(hash, (UCHAR *)"tset", sizeof("tset"), 0);
267 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
268
269 memset(hash_buf, 0, sizeof(hash_buf));
270 ret = BCryptFinishHash(hash, hash_buf, test->hash_size, 0);
271 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
272 format_hash( hash_buf, test->hash_size, str );
273 ok(!strcmp(str, test->hash2), "got %s\n", str);
274
275 ret = BCryptDestroyHash(hash);
276 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
277 }
278
279 ret = BCryptCloseAlgorithmProvider(alg, 0);
280 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
281
282 alg = NULL;
283 ret = BCryptOpenAlgorithmProvider(&alg, test->alg, MS_PRIMITIVE_PROVIDER, BCRYPT_ALG_HANDLE_HMAC_FLAG);
284 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
285 ok(alg != NULL, "alg not set\n");
286
287 hash = NULL;
288 len = sizeof(buf_hmac);
289 ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), 0);
290 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
291 ok(hash != NULL, "hash not set\n");
292
293 ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
294 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
295
296 test_hash_length(hash, test->hash_size);
297 test_alg_name(hash, test->alg);
298
299 memset(hmac_hash, 0, sizeof(hmac_hash));
300 ret = BCryptFinishHash(hash, hmac_hash, test->hash_size, 0);
301 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
302 format_hash( hmac_hash, test->hash_size, str );
303 ok(!strcmp(str, test->hmac_hash), "got %s\n", str);
304
305 ret = BCryptDestroyHash(hash);
306 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
307
308 hash = NULL;
309 len = sizeof(buf_hmac);
310 ret = BCryptCreateHash(alg, &hash, buf_hmac, len, (UCHAR *)"key", sizeof("key"), BCRYPT_HASH_REUSABLE_FLAG);
311 ok(ret == STATUS_SUCCESS || broken(ret == STATUS_INVALID_PARAMETER) /* < win8 */, "got %#lx\n", ret);
312 if (ret == STATUS_SUCCESS)
313 {
314 ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
315 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
316
317 memset(hmac_hash, 0, sizeof(hmac_hash));
318 ret = BCryptFinishHash(hash, hmac_hash, test->hash_size, 0);
319 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
320 format_hash( hmac_hash, test->hash_size, str );
321 ok(!strcmp(str, test->hmac_hash), "got %s\n", str);
322
323 /* reuse it */
324 ret = BCryptHashData(hash, (UCHAR *)"tset", sizeof("tset"), 0);
325 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
326
327 memset(hmac_hash, 0, sizeof(hmac_hash));
328 ret = BCryptFinishHash(hash, hmac_hash, test->hash_size, 0);
329 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
330 format_hash( hmac_hash, test->hash_size, str );
331 ok(!strcmp(str, test->hmac_hash2), "got %s\n", str);
332
333 ret = BCryptDestroyHash(hash);
334 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
335 }
336
337 ret = BCryptDestroyHash(hash);
338 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
339
340 ret = BCryptDestroyHash(NULL);
341 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
342
343 ret = BCryptCloseAlgorithmProvider(alg, 0);
344 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
345
346 if (pBCryptHash)
347 {
348 ret = pBCryptHash(BCRYPT_SHA1_ALG_HANDLE, NULL, 0, NULL, 0, hash_buf, 20);
349 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
350 ret = pBCryptHash(BCRYPT_SHA1_ALG_HANDLE, NULL, 0, (UCHAR *)"test", sizeof("test"), NULL, 20);
351 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
352 ret = pBCryptHash(BCRYPT_SHA1_ALG_HANDLE, NULL, 0, (UCHAR *)"test", sizeof("test"), hash_buf, 21);
353 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
354 ret = pBCryptHash(BCRYPT_SHA1_ALG_HANDLE, NULL, 0, (UCHAR *)"test", sizeof("test"), hash_buf, 20);
355 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
356
357 ret = BCryptCreateHash(BCRYPT_SHA1_ALG_HANDLE, &hash, NULL, 0, NULL, 0, 0);
358 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
359 ret = BCryptHashData(hash, (UCHAR *)"test", sizeof("test"), 0);
360 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
361 ret = BCryptFinishHash(hash, hash_buf, 21, 0);
362 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
363 ret = BCryptFinishHash(hash, hash_buf, 20, 0);
364 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
365 ret = BCryptDestroyHash(hash);
366 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
367 }
368}
test_hash_block_length
#define test_hash_block_length(a, b)
Definition: bcrypt.c:169
test_object_length
#define test_object_length(a)
Definition: bcrypt.c:121
BCRYPT_HASH_REUSABLE_FLAG
#define BCRYPT_HASH_REUSABLE_FLAG
Definition: bcrypt.h:487
BCRYPT_SHA1_ALG_HANDLE
#define BCRYPT_SHA1_ALG_HANDLE
Definition: bcrypt.h:419
BCryptFinishHash
NTSTATUS WINAPI BCryptFinishHash(BCRYPT_HASH_HANDLE handle, UCHAR *output, ULONG size, ULONG flags)
Definition: bcrypt_main.c:1525

Referenced by test_hashes().

◆ test_hashes()

static void test_hashes ( void  )
static

Definition at line 370 of file bcrypt.c.

371{
372 static const struct hash_test tests[] =
373 {
374 { L"SHA1", 20, 64,
375 "961fa64958818f767707072755d7018dcd278e94",
376 "9314f62ff64197143c91fc86de37e9ae776a3fb8",
377 "2472cf65d0e090618d769d3e46f0d9446cf212da",
378 "b2d2ba8cfd714d474cf0d9622cc5d15e1f53d53f",
379 },
380 { L"SHA256", 32, 64,
381 "ceb73749c899693706ede1e30c9929b3fd5dd926163831c2fb8bd41e6efb1126",
382 "ea0938c118a7b15954f41b85195f2b42aec3a9429c63f593cfa65c137ffaa986",
383 "34c1aa473a4468a91d06e7cdbc75bc4f93b830ccfc2a47ffd74e8e6ed29e4c72",
384 "55feb7052060bd99e33f36eb0982c7f4856eb6a84fbefe19a1afd9faafc3af6f",
385 },
386 { L"SHA384", 48, 128,
387 "62b21e90c9022b101671ba1f808f8631a8149f0f12904055839a35c1ca78ae53"
388 "63eed1e743a692d70e0504b0cfd12ef9",
389 "724db7c0bbc51ef1ac3fc793083fc54c0e5c423faec9b11378c01c236b19aaaf"
390 "a45177ad055feaf003968cc40ece44c7",
391 "4b3e6d6ff2da121790ab7e7b9247583e3a7eed2db5bd4dabc680303b1608f37d"
392 "fdc836d96a704c03283bc05b4f6c5eb8",
393 "03e1818e5c165a0e54619e513acb06c393e1a6cb0ddbb4036b5f29617b334642"
394 "e6e0be8b214d8508595b17a8c4b4e7db",
395 },
396 { L"SHA512", 64, 128,
397 "d55ced17163bf5386f2cd9ff21d6fd7fe576a915065c24744d09cfae4ec84ee1"
398 "ef6ef11bfbc5acce3639bab725b50a1fe2c204f8c820d6d7db0df0ecbc49c5ca",
399 "7752d707b54d2b00e7d1c09120d189475b0fd2e31ebb988cf0a01fc8492ddc0b"
400 "3ca9c9ca61d9d7d1fb65ca7665e87f043c1d5bc9f786f8345e951c2d91ac594f",
401 "415fb6b10018ca03b38a1b1399c42ac0be5e8aceddb9a73103f5e543bf2d888f"
402 "2eecf91373941f9315dd730a77937fa92444450fbece86f409d9cb5ec48c6513",
403 "1487bcecba46ae677622fa499e4cb2f0fdf92f6f3427cba76382d537a06e49c3"
404 "3e70a2fc1fc730092bf21128c3704cc6387f6dfbf7e2f9f315bbb894505a1205",
405 },
406 { L"MD2", 16, 16,
407 "1bb33606ba908912a84221109d29cd7e",
408 "b9a6ad9323b17e2d0cd389dddd6ef78a",
409 "7f05b0638d77f4a27f3a9c4d353cd648",
410 "05980873e6bfdd05dd7b30078de7e42a",
411 },
412 { L"MD4", 16, 64,
413 "74b5db93c0b41e36ca7074338fc0b637",
414 "a14a9ff2059a8c28f47b01e6bc48a1bf",
415 "bc2e8ac4d8248ed21b8d26227a30ea3a",
416 "b609db0eb4b8669db74f2c20099701e4",
417 },
418 { L"MD5", 16, 64,
419 "e2a3e68d23ce348b8f68b3079de3d4c9",
420 "bcdd7ca574342aa9db0e212348eacb16",
421 "7bda029b93fa8d817fcc9e13d6bdf092",
422 "dd636ab8e9592c5088e57c37d44c5bb3",
423 }
424 };
425 unsigned i;
426
427 for(i = 0; i < ARRAY_SIZE(tests); i++)
428 test_hash(tests+i);
429}
test_hash
static void test_hash(const struct hash_test *test)
Definition: bcrypt.c:207
hash_test
Definition: bcrypt.c:197

Referenced by START_TEST().

◆ test_HKDF()

static void test_HKDF ( void  )
static

Definition at line 5374 of file bcrypt.c.

5375{
5376 static const UCHAR expect[] =
5377 {
5378 0x9e,0xc7,0x96,0xeb,0x03,0xf9,0xbd,0xaa,0xfa,0x68,0x90,0x1c,0x7b,0x71,0x20,0xda,
5379 0x88,0xf1,0xc2,0x15,0x07,0xaf,0xc6,0xde,0x1a,0x86,0xb5,0x6e,0x96,0xe9,0x7d,0x7a
5380 };
5381 static const UCHAR expect2[] =
5382 {
5383 0x54,0xe0,0x42,0xd2,0x92,0xc8,0x02,0x02,0x14,0xae,0x57,0xe8,0x7e,0x67,0x32,0xd7,
5384 0x46,0x90,0xca,0x7b,0xef,0x5a,0x62,0x74,0x90,0x8f,0x1e,0x99,0x20,0x04,0x1e,0x27
5385 };
5386 static const UCHAR expect3[] =
5387 {
5388 0xb5,0x12,0x7d,0x38,0x03,0x6a,0x64,0xd0,0x76,0xde,0x48,0xe2,0xa0,0x7a,0x4f,0x3d,
5389 0x6f,0xc8,0x55,0xab,0xf5,0x14,0x66,0x5d,0xd6,0x02,0x1c,0x28,0x75,0xe7,0xdc,0x96
5390 };
5391 UCHAR buf[32], salt[] = "salt";
5392 static BCryptBuffer param_buffers[] =
5393 {
5394 {
5395 sizeof("info"),
5396 KDF_HKDF_INFO,
5397 (void *)"info",
5398 },
5399 };
5400 static BCryptBufferDesc params =
5401 {
5402 BCRYPTBUFFER_VERSION,
5403 ARRAY_SIZE(param_buffers),
5404 param_buffers,
5405 };
5406 NTSTATUS status;
5407 BCRYPT_ALG_HANDLE alg;
5408 BCRYPT_KEY_HANDLE key;
5409 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
5410 ULONG len, size;
5411
5412 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_HKDF_ALGORITHM, NULL, 0);
5413 if (status == STATUS_NOT_FOUND) /* win8 */
5414 {
5415 win_skip("BCRYPT_HKDF_ALGORITHM not available\n");
5416 return;
5417 }
5418 ok(!status, "got %#lx\n", status);
5419
5420 len = size = 0;
5421 status = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5422 ok(!status, "got %#lx\n", status);
5423 ok(len, "got %lu\n", len);
5424 ok(size == sizeof(len), "got %lu\n", size);
5425
5426 len = size = 0;
5427 status = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5428 ok(status == STATUS_NOT_SUPPORTED, "got %#lx\n", status);
5429
5430 memset(&key_lengths, 0xfe, sizeof(key_lengths));
5431 size = 0;
5432 status = BCryptGetProperty(alg, BCRYPT_KEY_LENGTHS, (UCHAR *)&key_lengths, sizeof(key_lengths), &size, 0);
5433 ok(!status, "got %#lx\n", status);
5434 ok(size == sizeof(key_lengths), "got %lu\n", size);
5435 ok(key_lengths.dwMinLength == 0, "got %lu\n", key_lengths.dwMinLength);
5436 ok(key_lengths.dwMaxLength == 16384, "got %lu\n", key_lengths.dwMaxLength);
5437 ok(key_lengths.dwIncrement == 8, "got %lu\n", key_lengths.dwIncrement);
5438
5439 /* salt, info */
5440 status = BCryptGenerateSymmetricKey(alg, &key, NULL, 0, (UCHAR *)"test", 4, 0);
5441 ok(!status, "got %#lx\n", status);
5442
5443 len = size = 0;
5444 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5445 ok(!status, "got %#lx\n", status);
5446 ok(len == strlen("test") * 8, "got %lu\n", len);
5447
5448 size = sizeof(BCRYPT_SHA256_ALGORITHM);
5449 status = BCryptSetProperty(key, BCRYPT_HKDF_HASH_ALGORITHM, (UCHAR *)BCRYPT_SHA256_ALGORITHM, size, 0);
5450 ok(!status, "got %#lx\n", status);
5451
5452 status = BCryptSetProperty(key, BCRYPT_HKDF_SALT_AND_FINALIZE, salt, sizeof(salt), 0);
5453 ok(!status, "got %#lx\n", status);
5454
5455 status = BCryptKeyDerivation(key, &params, NULL, 0, &size, 0);
5456 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
5457
5458 buf[0] = buf[1] = 'x';
5459 status = BCryptKeyDerivation(key, &params, buf, 1, &size, 0);
5460 ok(!status, "got %#lx\n", status);
5461 ok(size == 1, "size = %lu\n", size);
5462 ok(buf[0] == expect[0], "buf[0] = %x\n", buf[0]);
5463 ok(buf[1] == 'x', "buf[1] = %x\n", buf[1]);
5464
5465 memset(buf, 'x', sizeof(buf));
5466 status = BCryptKeyDerivation(key, &params, buf, sizeof(buf), &size, 0);
5467 ok(!status, "got %#lx\n", status);
5468 ok(size == sizeof(buf), "size = %lu\n", size);
5469 ok(!memcmp(buf, expect, sizeof(expect)), "wrong data (%s)\n", wine_dbgstr_an((char *)buf, size));
5470
5471 status = BCryptDestroyKey(key);
5472 ok(!status, "got %#lx\n", status);
5473
5474 /* no salt, info */
5475 status = BCryptGenerateSymmetricKey(alg, &key, NULL, 0, (UCHAR *)"test", 4, 0);
5476 ok(!status, "got %#lx\n", status);
5477
5478 len = size = 0;
5479 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5480 ok(!status, "got %#lx\n", status);
5481 ok(len == strlen("test") * 8, "got %lu\n", len);
5482
5483 size = sizeof(BCRYPT_SHA256_ALGORITHM);
5484 status = BCryptSetProperty(key, BCRYPT_HKDF_HASH_ALGORITHM, (UCHAR *)BCRYPT_SHA256_ALGORITHM, size, 0);
5485 ok(!status, "got %#lx\n", status);
5486
5487 status = BCryptSetProperty(key, BCRYPT_HKDF_PRK_AND_FINALIZE, NULL, 0, 0);
5488 ok(!status, "got %#lx\n", status);
5489
5490 status = BCryptKeyDerivation(key, &params, NULL, 0, &size, 0);
5491 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
5492
5493 buf[0] = buf[1] = 'x';
5494 status = BCryptKeyDerivation(key, &params, buf, 1, &size, 0);
5495 ok(!status, "got %#lx\n", status);
5496 ok(size == 1, "size = %lu\n", size);
5497 ok(buf[0] == expect2[0], "buf[0] = %x\n", buf[0]);
5498 ok(buf[1] == 'x', "buf[1] = %x\n", buf[1]);
5499
5500 memset(buf, 'x', sizeof(buf));
5501 status = BCryptKeyDerivation(key, &params, buf, sizeof(buf), &size, 0);
5502 ok(!status, "got %#lx\n", status);
5503 ok(size == sizeof(buf), "size = %lu\n", size);
5504 ok(!memcmp(buf, expect2, sizeof(expect2)), "wrong data (%s)\n", wine_dbgstr_an((char *)buf, size));
5505
5506 status = BCryptDestroyKey(key);
5507 ok(!status, "got %#lx\n", status);
5508
5509 /* salt, no info */
5510 status = BCryptGenerateSymmetricKey(alg, &key, NULL, 0, (UCHAR *)"test", 4, 0);
5511 ok(!status, "got %#lx\n", status);
5512
5513 len = size = 0;
5514 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5515 ok(!status, "got %#lx\n", status);
5516 ok(len == strlen("test") * 8, "got %lu\n", len);
5517
5518 size = sizeof(BCRYPT_SHA256_ALGORITHM);
5519 status = BCryptSetProperty(key, BCRYPT_HKDF_HASH_ALGORITHM, (UCHAR *)BCRYPT_SHA256_ALGORITHM, size, 0);
5520 ok(!status, "got %#lx\n", status);
5521
5522 status = BCryptSetProperty(key, BCRYPT_HKDF_SALT_AND_FINALIZE, salt, sizeof(salt), 0);
5523 ok(!status, "got %#lx\n", status);
5524
5525 status = BCryptKeyDerivation(key, NULL, NULL, 0, &size, 0);
5526 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
5527
5528 buf[0] = buf[1] = 'x';
5529 status = BCryptKeyDerivation(key, NULL, buf, 1, &size, 0);
5530 ok(!status, "got %#lx\n", status);
5531 ok(size == 1, "size = %lu\n", size);
5532 ok(buf[0] == expect3[0], "buf[0] = %x\n", buf[0]);
5533 ok(buf[1] == 'x', "buf[1] = %x\n", buf[1]);
5534
5535 memset(buf, 'x', sizeof(buf));
5536 status = BCryptKeyDerivation(key, NULL, buf, sizeof(buf), &size, 0);
5537 ok(!status, "got %#lx\n", status);
5538 ok(size == sizeof(buf), "size = %lu\n", size);
5539 ok(!memcmp(buf, expect3, sizeof(expect3)), "wrong data (%s)\n", wine_dbgstr_an((char *)buf, size));
5540
5541 status = BCryptDestroyKey(key);
5542 ok(!status, "got %#lx\n", status);
5543 status = BCryptCloseAlgorithmProvider(alg, 0);
5544 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5545}
BCRYPT_HKDF_HASH_ALGORITHM
#define BCRYPT_HKDF_HASH_ALGORITHM
Definition: bcrypt.h:127
BCRYPT_HKDF_ALGORITHM
#define BCRYPT_HKDF_ALGORITHM
Definition: bcrypt.h:125
BCRYPT_SHA256_ALGORITHM
#define BCRYPT_SHA256_ALGORITHM
Definition: bcrypt.h:120
KDF_HKDF_INFO
#define KDF_HKDF_INFO
Definition: bcrypt.h:388
BCRYPT_HKDF_PRK_AND_FINALIZE
#define BCRYPT_HKDF_PRK_AND_FINALIZE
Definition: bcrypt.h:129
BCRYPT_HKDF_SALT_AND_FINALIZE
#define BCRYPT_HKDF_SALT_AND_FINALIZE
Definition: bcrypt.h:128
BCryptKeyDerivation
NTSTATUS WINAPI BCryptKeyDerivation(BCRYPT_KEY_HANDLE handle, BCryptBufferDesc *desc, UCHAR *output, ULONG output_len, ULONG *ret_len, ULONG flags)
Definition: bcrypt_main.c:4404
wine_dbgstr_an
const char * wine_dbgstr_an(const char *str, int n)
Definition: compat.c:313
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1597
params
GLenum const GLfloat * params
Definition: glext.h:5645

Referenced by START_TEST().

◆ test_key_import_export()

static void test_key_import_export ( void  )
static

Definition at line 2127 of file bcrypt.c.

2128{
2129 static const UCHAR encrypted_blob[40] = {0x33,0x6e,0x51,0x10,
2130 0x25,0xba,0xdb,0xce,0xcb,0x25,0x00,0x85,0x51,0xc0,0xfa,0x21,
2131 0x66,0xdd,0x6d,0x67,0x46,0x76,0x0f,0x8a,0x44,0xe5,0x65,0x31,
2132 0xcb,0x02,0x52,0x9c,0x69,0x59,0x1a,0xec,0x67,0x27,0x11,0xaa};
2133 UCHAR buffer1[sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + 16];
2134 UCHAR buffer2[sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + 32], *buf;
2135 UCHAR buffer3[32 + 8], buffer4[sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + 32];
2136 BCRYPT_KEY_DATA_BLOB_HEADER *key_data1 = (void*)buffer1;
2137 BCRYPT_KEY_DATA_BLOB_HEADER *key_data2 = (void*)buffer2;
2138 BCRYPT_ALG_HANDLE aes;
2139 BCRYPT_KEY_HANDLE key, key2, key3;
2140 NTSTATUS ret;
2141 ULONG size;
2142
2143 ret = BCryptOpenAlgorithmProvider(&aes, BCRYPT_AES_ALGORITHM, NULL, 0);
2144 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2145
2146 key_data1->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
2147 key_data1->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
2148 key_data1->cbKeyData = 16;
2149 memset(&key_data1[1], 0x11, 16);
2150
2151 key = NULL;
2152 ret = BCryptImportKey(aes, NULL, BCRYPT_KEY_DATA_BLOB, &key, NULL, 0, buffer1, sizeof(buffer1), 0);
2153 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2154 ok(key != NULL, "key not set\n");
2155
2156 key_data2->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC;
2157 key_data2->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1;
2158 key_data2->cbKeyData = 32;
2159 memset(&key_data2[1], 0x22, 32);
2160 key2 = NULL;
2161 ret = BCryptImportKey(aes, NULL, BCRYPT_KEY_DATA_BLOB, &key2, NULL, 0, buffer2, sizeof(buffer2), 0);
2162 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2163 ok(key2 != NULL, "key not set\n");
2164
2165 size = 0;
2166 ret = BCryptExportKey(key2, key, BCRYPT_AES_WRAP_KEY_BLOB, NULL, 0, &size, 0);
2167 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2168 ok(size == sizeof(buffer3), "got %lu\n", size);
2169
2170 ret = BCryptExportKey(key2, key, BCRYPT_AES_WRAP_KEY_BLOB, buffer3, size, &size, 0);
2171 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2172 ok(!memcmp(buffer3, encrypted_blob, sizeof(encrypted_blob)), "blobs didn't match\n");
2173
2174 key3 = NULL;
2175 ret = BCryptImportKey(aes, key, BCRYPT_AES_WRAP_KEY_BLOB, &key3, NULL, 0, buffer3, sizeof(buffer3), 0);
2176 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2177 ok(key3 != NULL, "key not set\n");
2178
2179 size = 0;
2180 memset(buffer4, 0xff, sizeof(buffer4));
2181 ret = BCryptExportKey(key3, NULL, BCRYPT_KEY_DATA_BLOB, buffer4, sizeof(buffer4), &size, 0);
2182 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2183 ok(size == sizeof(buffer2), "Got %lu\n", size);
2184 ok(!memcmp(buffer4, buffer2, sizeof(buffer2)), "Expected exported key to match imported key\n");
2185
2186 BCryptDestroyKey(key3);
2187 BCryptDestroyKey(key2);
2188
2189 size = 0;
2190 ret = BCryptExportKey(key, NULL, BCRYPT_KEY_DATA_BLOB, buffer1, 0, &size, 0);
2191 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
2192 ok(size == sizeof(buffer1), "got %lu\n", size);
2193
2194 size = 0;
2195 memset(buffer2, 0xff, sizeof(buffer2));
2196 ret = BCryptExportKey(key, NULL, BCRYPT_KEY_DATA_BLOB, buffer2, sizeof(buffer2), &size, 0);
2197 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2198 ok(size == sizeof(buffer1), "Got %lu\n", size);
2199 ok(!memcmp(buffer1, buffer2, sizeof(buffer1)), "Expected exported key to match imported key\n");
2200
2201 /* opaque blob */
2202 size = 0;
2203 ret = BCryptExportKey(key, NULL, BCRYPT_OPAQUE_KEY_BLOB, buffer2, 0, &size, 0);
2204 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %#lx\n", ret);
2205 ok(size > 0, "got zero\n");
2206
2207 buf = malloc(size);
2208 ret = BCryptExportKey(key, NULL, BCRYPT_OPAQUE_KEY_BLOB, buf, size, &size, 0);
2209 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2210
2211 ret = BCryptDestroyKey(key);
2212 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2213
2214 key = NULL;
2215 ret = BCryptImportKey(aes, NULL, BCRYPT_OPAQUE_KEY_BLOB, &key, NULL, 0, buf, size, 0);
2216 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2217 ok(key != NULL, "key not set\n");
2218
2219 ret = BCryptDestroyKey(key);
2220 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2221
2222 if (pBCryptHash)
2223 {
2224 ret = BCryptImportKey(BCRYPT_AES_CBC_ALG_HANDLE, NULL, BCRYPT_OPAQUE_KEY_BLOB, &key, NULL, 0, buf, size, 0);
2225 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2226 BCryptDestroyKey(key);
2227 }
2228
2229 free(buf);
2230 ret = BCryptCloseAlgorithmProvider(aes, 0);
2231 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2232}
BCRYPT_AES_WRAP_KEY_BLOB
#define BCRYPT_AES_WRAP_KEY_BLOB
Definition: bcrypt.h:73
BCRYPT_OPAQUE_KEY_BLOB
#define BCRYPT_OPAQUE_KEY_BLOB
Definition: bcrypt.h:71
_BCRYPT_KEY_DATA_BLOB_HEADER::dwVersion
ULONG dwVersion
Definition: bcrypt.h:367
_BCRYPT_KEY_DATA_BLOB_HEADER::cbKeyData
ULONG cbKeyData
Definition: bcrypt.h:368
_BCRYPT_KEY_DATA_BLOB_HEADER::dwMagic
ULONG dwMagic
Definition: bcrypt.h:366

Referenced by START_TEST().

◆ test_PBKDF2()

static void test_PBKDF2 ( void  )
static

Definition at line 5130 of file bcrypt.c.

5131{
5132 static char salt[] = "cCxuHMEHLibcglJOG88dIw==";
5133 static ULONGLONG iter_count = 25;
5134 static BCryptBuffer pbkdf2_param_buffers[] =
5135 {
5136 {
5137 sizeof(BCRYPT_SHA1_ALGORITHM),
5138 KDF_HASH_ALGORITHM,
5139 (void *)BCRYPT_SHA1_ALGORITHM,
5140 },
5141 {
5142 sizeof(salt) - 1,
5143 KDF_SALT,
5144 salt,
5145 },
5146 {
5147 sizeof(iter_count),
5148 KDF_ITERATION_COUNT,
5149 (void *)&iter_count,
5150 }
5151 };
5152 static BCryptBufferDesc pbkdf2_params =
5153 {
5154 BCRYPTBUFFER_VERSION,
5155 ARRAY_SIZE(pbkdf2_param_buffers),
5156 pbkdf2_param_buffers,
5157 };
5158 static UCHAR pbkdf2_hash[] =
5159 {
5160 0x18, 0xf2, 0x58, 0x0b, 0x92, 0x6e, 0x6d, 0xfe,
5161 0x55, 0xbb, 0x62, 0x87, 0x5b, 0x1f, 0x61, 0x83,
5162 0x4d, 0x16, 0xe4, 0x04, 0xcd, 0xab, 0x43, 0x77,
5163 0x25, 0x3e, 0x1d, 0xb4, 0x95, 0x5f, 0xf7, 0x01,
5164 };
5165 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
5166 BCRYPT_ALG_HANDLE alg;
5167 BCRYPT_KEY_HANDLE key, key2;
5168 NTSTATUS status;
5169 ULONG val, size;
5170 static BYTE buf[32];
5171
5172 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_PBKDF2_ALGORITHM, NULL, 0);
5173 if (status == STATUS_NOT_FOUND)
5174 {
5175 win_skip("PBKDF2 not available\n");
5176 return;
5177 }
5178 ok(!status, "got %#lx\n", status);
5179
5180 val = size = 0;
5181 status = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&val, sizeof(val), &size, 0);
5182 ok(!status, "got %#lx\n", status);
5183 ok(val, "got %lu\n", val);
5184 ok(size == sizeof(val), "got %lu\n", size);
5185
5186 val = size = 0;
5187 status = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&val, sizeof(val), &size, 0);
5188 ok(status == STATUS_NOT_SUPPORTED, "got %#lx\n", status);
5189
5190 memset(&key_lengths, 0xfe, sizeof(key_lengths));
5191 size = 0;
5192 status = BCryptGetProperty(alg, BCRYPT_KEY_LENGTHS, (UCHAR *)&key_lengths, sizeof(key_lengths), &size, 0);
5193 ok(!status, "got %#lx\n", status);
5194 ok(size == sizeof(key_lengths), "got %lu\n", size);
5195 ok(key_lengths.dwMinLength == 0, "got %lu\n", key_lengths.dwMinLength);
5196 ok(key_lengths.dwMaxLength == 16384, "got %lu\n", key_lengths.dwMaxLength);
5197 ok(key_lengths.dwIncrement == 8, "got %lu\n", key_lengths.dwIncrement);
5198
5199 key = 0;
5200 status = BCryptGenerateSymmetricKey(alg, &key, NULL, 0, (UCHAR *)"test", 4, 0);
5201 ok(!status, "got %#lx\n", status);
5202 val = size = 0;
5203 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&val, sizeof(val), &size, 0);
5204 ok(!status, "got %#lx\n", status);
5205 ok(val == strlen("test") * 8, "got %lu\n", val);
5206
5207 status = BCryptKeyDerivation(key, &pbkdf2_params, NULL, 0, &size, 0);
5208 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
5209
5210 buf[0] = buf[1] = 'x';
5211 status = BCryptKeyDerivation(key, &pbkdf2_params, buf, 1, &size, 0);
5212 ok(!status, "got %#lx\n", status);
5213 ok(size == 1, "size = %lu\n", size);
5214 ok(buf[0] == pbkdf2_hash[0], "buf[0] = %x\n", buf[0]);
5215 ok(buf[1] == 'x', "buf[1] = %x\n", buf[1]);
5216
5217 memset(buf, 'x', sizeof(buf));
5218 status = BCryptKeyDerivation(key, &pbkdf2_params, buf, sizeof(buf), &size, 0);
5219 ok(!status, "got %#lx\n", status);
5220 ok(size == sizeof(buf), "size = %lu\n", size);
5221 ok(!memcmp(buf, pbkdf2_hash, sizeof(pbkdf2_hash)),
5222 "wrong data (%s)\n", wine_dbgstr_an((char *)buf, size));
5223
5224 status = BCryptDuplicateKey(key, &key2, NULL, 0, 0);
5225 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5226
5227 status = BCryptDestroyKey(key);
5228 ok(!status, "got %#lx\n", status);
5229 status = BCryptDestroyKey(key2);
5230 ok(!status, "got %#lx\n", status);
5231 status = BCryptCloseAlgorithmProvider(alg, 0);
5232 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5233}
KDF_SALT
#define KDF_SALT
Definition: bcrypt.h:386
KDF_ITERATION_COUNT
#define KDF_ITERATION_COUNT
Definition: bcrypt.h:387
BCRYPT_PBKDF2_ALGORITHM
#define BCRYPT_PBKDF2_ALGORITHM
Definition: bcrypt.h:113
val
GLuint GLfloat * val
Definition: glext.h:7180
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67

Referenced by START_TEST().

◆ test_RC4()

static void test_RC4 ( void  )
static

Definition at line 5101 of file bcrypt.c.

5102{
5103 BCRYPT_ALG_HANDLE alg;
5104 NTSTATUS status;
5105 ULONG len, size;
5106
5107 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RC4_ALGORITHM, NULL, 0);
5108 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5109
5110 len = size = 0;
5111 status = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5112 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5113 ok(len, "expected non-zero len\n");
5114 ok(size == sizeof(len), "got %lu\n", size);
5115
5116 len = size = 0;
5117 status = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5118 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5119 ok(len == 1, "got %lu\n", len);
5120 ok(size == sizeof(len), "got %lu\n", size);
5121
5122 size = sizeof(BCRYPT_CHAIN_MODE_NA);
5123 status = BCryptSetProperty(alg, BCRYPT_CHAINING_MODE, (UCHAR *)BCRYPT_CHAIN_MODE_NA, size, 0);
5124 ok(!status, "got %#lx\n", status);
5125
5126 status = BCryptCloseAlgorithmProvider(alg, 0);
5127 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5128}
BCRYPT_RC4_ALGORITHM
#define BCRYPT_RC4_ALGORITHM
Definition: bcrypt.h:115

Referenced by START_TEST().

◆ test_rng()

static void test_rng ( void  )
static

Definition at line 571 of file bcrypt.c.

572{
573 BCRYPT_ALG_HANDLE alg;
574 ULONG size, len;
575 UCHAR buf[16];
576 NTSTATUS ret;
577
578 alg = NULL;
579 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
580 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
581 ok(alg != NULL, "alg not set\n");
582
583 len = size = 0xdeadbeef;
584 ret = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
585 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
586
587 len = size = 0xdeadbeef;
588 ret = BCryptGetProperty(alg, BCRYPT_HASH_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
589 ok(ret == STATUS_NOT_SUPPORTED, "got %#lx\n", ret);
590
591 test_alg_name(alg, L"RNG");
592
593 memset(buf, 0, 16);
594 ret = BCryptGenRandom(alg, buf, 8, 0);
595 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
596 ok(memcmp(buf, buf + 8, 8), "got zeroes\n");
597
598 ret = BCryptCloseAlgorithmProvider(alg, 0);
599 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
600}

Referenced by START_TEST().

◆ test_RSA()

static void test_RSA ( void  )
static

Definition at line 2974 of file bcrypt.c.

2975{
2976 static UCHAR hash[] =
2977 {0x7e,0xe3,0x74,0xe7,0xc5,0x0b,0x6b,0x70,0xdb,0xab,0x32,0x6d,0x1d,0x51,0xd6,0x74,0x79,0x8e,0x5b,0x4b};
2978 static UCHAR hash48[] =
2979 {0x62,0xb2,0x1e,0x90,0xc9,0x02,0x2b,0x10,0x16,0x71,0xba,0x1f,0x80,0x8f,0x86,0x31,0xa8,0x14,0x9f,0x0f,
2980 0x12,0x90,0x40,0x55,0x83,0x9a,0x35,0xc1,0xca,0x78,0xae,0x53,0x1b,0xb3,0x36,0x06,0xba,0x90,0x89,0x12,
2981 0xa8,0x42,0x21,0x10,0x9d,0x29,0xcd,0x7e};
2982 BCRYPT_PKCS1_PADDING_INFO pad;
2983 BCRYPT_PSS_PADDING_INFO pad_pss;
2984 BCRYPT_ALG_HANDLE alg;
2985 BCRYPT_KEY_HANDLE key;
2986 BCRYPT_RSAKEY_BLOB *rsablob;
2987 UCHAR sig[256], sig_pss[256];
2988 ULONG len, size, size2, schemes;
2989 NTSTATUS ret;
2990 BYTE *buf;
2991 DWORD keylen;
2992
2993 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RSA_ALGORITHM, NULL, 0);
2994 ok(!ret, "got %#lx\n", ret);
2995
2996 schemes = size = 0;
2997 ret = BCryptGetProperty(alg, L"PaddingSchemes", (UCHAR *)&schemes, sizeof(schemes), &size, 0);
2998 ok(!ret, "got %#lx\n", ret);
2999 ok(schemes, "schemes not set\n");
3000 ok(size == sizeof(schemes), "got %lu\n", size);
3001
3002 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_PUBLIC_KEY_BLOB, &key, rsaPublicBlob, sizeof(rsaPublicBlob), 0);
3003 ok(!ret, "BCryptImportKeyPair failed: %#lx\n", ret);
3004 BCryptDestroyKey(key);
3005
3006 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAPUBLIC_BLOB, &key, rsaPublicBlob, sizeof(rsaPublicBlob), 0);
3007 ok(!ret, "BCryptImportKeyPair failed: %#lx\n", ret);
3008
3009 size = keylen = 0;
3010 ret = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&keylen, sizeof(keylen), &size, 0);
3011 ok(!ret, "got %#lx\n", ret);
3012 ok(size == sizeof(keylen), "got %lu\n", size);
3013 ok(keylen == 2048, "got %lu\n", keylen);
3014
3015 size = len = 0;
3016 ret = BCryptGetProperty(key, BCRYPT_SIGNATURE_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
3017 ok(!ret, "got %#lx\n", ret);
3018 ok(size == sizeof(len), "got %lu\n", size);
3019 ok(len == 256, "got %lu\n", len);
3020
3021 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3022 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3023 ok(!ret, "BCryptVerifySignature failed: %#lx\n", ret);
3024
3025 ret = BCryptVerifySignature(key, NULL, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3026 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", ret);
3027
3028 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3029 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), 0);
3030 ok(ret == STATUS_INVALID_SIGNATURE || ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
3031
3032 ret = BCryptVerifySignature(key, NULL, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), 0);
3033 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", ret);
3034
3035 pad.pszAlgId = BCRYPT_AES_ALGORITHM;
3036 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3037 ok(ret == STATUS_NOT_SUPPORTED, "Expected STATUS_NOT_SUPPORTED, got %#lx\n", ret);
3038
3039 pad.pszAlgId = NULL;
3040 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3041 ok(ret == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %#lx\n", ret);
3042
3043 ret = BCryptDestroyKey(key);
3044 ok(!ret, "BCryptDestroyKey failed: %#lx\n", ret);
3045
3046 /* sign/verify with export/import round-trip */
3047 ret = BCryptGenerateKeyPair(alg, &key, 1024, 0);
3048 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3049
3050 keylen = 2048;
3051 ret = BCryptSetProperty(key, BCRYPT_KEY_LENGTH, (UCHAR *)&keylen, 2, 0);
3052 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
3053 ret = BCryptSetProperty(key, BCRYPT_KEY_LENGTH, (UCHAR *)&keylen, sizeof(keylen), 0);
3054 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3055
3056 ret = BCryptFinalizeKeyPair(key, 0);
3057 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3058
3059 keylen = 0;
3060 ret = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&keylen, sizeof(keylen), &size, 0);
3061 ok(!ret, "got %#lx\n", ret);
3062 ok(size == sizeof(keylen), "got %lu\n", size);
3063 ok(keylen == 2048, "got %lu\n", keylen);
3064
3065 ret = BCryptSetProperty(key, BCRYPT_KEY_LENGTH, (UCHAR *)&keylen, sizeof(keylen), 0);
3066 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3067
3068 pad.pszAlgId = BCRYPT_MD5_ALGORITHM;
3069 memset(sig, 0, sizeof(sig));
3070 len = 0;
3071 ret = BCryptSignHash(key, &pad, hash, 16, sig, sizeof(sig), &len, BCRYPT_PAD_PKCS1);
3072 ok(!ret, "got %#lx\n", ret);
3073 ok(len == 256, "got %lu\n", len);
3074 pad.pszAlgId = BCRYPT_MD5_ALGORITHM;
3075 ret = BCryptVerifySignature(key, &pad, hash, 16, sig, len, BCRYPT_PAD_PKCS1);
3076 ok(!ret, "BCryptVerifySignature failed: %#lx\n", ret);
3077
3078 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3079 memset(sig, 0, sizeof(sig));
3080 len = 0;
3081 ret = BCryptSignHash(key, &pad, hash, sizeof(hash), sig, sizeof(sig), &len, BCRYPT_PAD_PKCS1);
3082 ok(!ret, "got %#lx\n", ret);
3083 ok(len == 256, "got %lu\n", len);
3084 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3085 ret = BCryptVerifySignature(key, &pad, hash, sizeof(hash), sig, len, BCRYPT_PAD_PKCS1);
3086 ok(!ret, "BCryptVerifySignature failed: %#lx\n", ret);
3087
3088 pad.pszAlgId = NULL;
3089 memset(sig, 0, sizeof(sig));
3090 len = 0;
3091 ret = BCryptSignHash(key, &pad, hash, sizeof(hash), sig, sizeof(sig), &len, BCRYPT_PAD_PKCS1);
3092 ok(!ret, "got %#lx\n", ret);
3093 ok(len == 256, "got %lu\n", len);
3094
3095 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3096 ret = BCryptVerifySignature(key, &pad, hash, sizeof(hash), sig, len, BCRYPT_PAD_PKCS1);
3097 ok(ret == STATUS_INVALID_SIGNATURE, "BCryptVerifySignature failed: %#lx, len %ld\n", ret, len);
3098
3099 pad.pszAlgId = NULL;
3100 ret = BCryptVerifySignature(key, &pad, hash, sizeof(hash), sig, len, BCRYPT_PAD_PKCS1);
3101 ok(!ret, "BCryptVerifySignature failed: %#lx, len %ld\n", ret, len);
3102
3103 pad_pss.pszAlgId = BCRYPT_SHA384_ALGORITHM;
3104 pad_pss.cbSalt = 48;
3105 memset(sig_pss, 0, sizeof(sig_pss));
3106 len = 0;
3107 ret = BCryptSignHash(key, &pad_pss, hash48, sizeof(hash48), sig_pss, sizeof(sig_pss), &len, BCRYPT_PAD_PSS);
3108 ok(!ret, "got %#lx\n", ret);
3109 ok(len == 256, "got %lu\n", len);
3110
3111 /* export private key */
3112 size = 0;
3113 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPRIVATE_BLOB, NULL, 0, &size, 0);
3114 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3115 ok(size, "size not set\n");
3116
3117 buf = malloc(size);
3118 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPRIVATE_BLOB, buf, size, &size, 0);
3119 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3120 rsablob = (BCRYPT_RSAKEY_BLOB *)buf;
3121 ok(rsablob->Magic == BCRYPT_RSAPRIVATE_MAGIC, "got %#lx\n", rsablob->Magic);
3122 ok(rsablob->BitLength == 2048, "got %lu\n", rsablob->BitLength);
3123 ok(rsablob->cbPublicExp == 3, "got %lu\n", rsablob->cbPublicExp);
3124 ok(rsablob->cbModulus == 256, "got %lu\n", rsablob->cbModulus);
3125 ok(rsablob->cbPrime1 == 128, "got %lu\n", rsablob->cbPrime1);
3126 ok(rsablob->cbPrime2 == 128, "got %lu\n", rsablob->cbPrime2);
3127 size2 = sizeof(*rsablob) + rsablob->cbPublicExp + rsablob->cbModulus + rsablob->cbPrime1 + rsablob->cbPrime2;
3128 ok(size == size2, "got %lu expected %lu\n", size2, size);
3129 free(buf);
3130
3131 size = 0;
3132 ret = BCryptExportKey(key, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, NULL, 0, &size, 0);
3133 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3134 ok(size, "size not set\n");
3135
3136 buf = malloc(size);
3137 ret = BCryptExportKey(key, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, buf, size, &size, 0);
3138 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3139 rsablob = (BCRYPT_RSAKEY_BLOB *)buf;
3140 ok(rsablob->Magic == BCRYPT_RSAFULLPRIVATE_MAGIC, "got %#lx\n", rsablob->Magic);
3141 ok(rsablob->BitLength == 2048, "got %lu\n", rsablob->BitLength);
3142 ok(rsablob->cbPublicExp == 3, "got %lu\n", rsablob->cbPublicExp);
3143 ok(rsablob->cbModulus == 256, "got %lu\n", rsablob->cbModulus);
3144 ok(rsablob->cbPrime1 == 128, "got %lu\n", rsablob->cbPrime1);
3145 ok(rsablob->cbPrime2 == 128, "got %lu\n", rsablob->cbPrime2);
3146 size2 = sizeof(*rsablob) + rsablob->cbPublicExp + rsablob->cbModulus * 2 + rsablob->cbPrime1 * 3 + rsablob->cbPrime2 * 2;
3147 ok(size == size2, "got %lu expected %lu\n", size2, size);
3148 free(buf);
3149
3150 /* import/export public key */
3151 size = 0;
3152 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPUBLIC_BLOB, NULL, 0, &size, 0);
3153 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3154 ok(size, "size not set\n");
3155
3156 buf = malloc(size);
3157 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPUBLIC_BLOB, buf, size, &size, 0);
3158 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3159 rsablob = (BCRYPT_RSAKEY_BLOB *)buf;
3160 ok(rsablob->Magic == BCRYPT_RSAPUBLIC_MAGIC, "got %#lx\n", rsablob->Magic);
3161 ok(rsablob->BitLength == 2048, "got %lu\n", rsablob->BitLength);
3162 ok(rsablob->cbPublicExp == 3, "got %lu\n", rsablob->cbPublicExp);
3163 ok(rsablob->cbModulus == 256, "got %lu\n", rsablob->cbModulus);
3164 ok(!rsablob->cbPrime1, "got %lu\n", rsablob->cbPrime1);
3165 ok(!rsablob->cbPrime2, "got %lu\n", rsablob->cbPrime2);
3166 ok(size == sizeof(*rsablob) + rsablob->cbPublicExp + rsablob->cbModulus, "got %lu\n", size);
3167 ret = BCryptDestroyKey(key);
3168 ok(!ret, "got %#lx\n", ret);
3169
3170 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAPUBLIC_BLOB, &key, rsaPublicBlobWithInvalidPublicExpSize,
3171 sizeof(rsaPublicBlobWithInvalidPublicExpSize), 0);
3172 ok(ret == NTE_BAD_DATA, "got %#lx\n", ret);
3173
3174 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAPUBLIC_BLOB, &key, buf, size, 0);
3175 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3176 free(buf);
3177
3178 ret = BCryptVerifySignature(key, &pad, hash, sizeof(hash), sig, sizeof(sig), BCRYPT_PAD_PKCS1);
3179 ok(!ret, "got %#lx\n", ret);
3180 ret = BCryptVerifySignature(key, &pad_pss, hash48, sizeof(hash48), sig_pss, sizeof(sig_pss), BCRYPT_PAD_PSS);
3181 ok(!ret, "got %#lx\n", ret);
3182 ret = BCryptDestroyKey(key);
3183 ok(!ret, "got %#lx\n", ret);
3184
3185 /* import/export private key */
3186 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAPRIVATE_BLOB, &key, rsaPrivateBlob, sizeof(rsaPrivateBlob), 0);
3187 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3188
3189 ret = BCryptFinalizeKeyPair(key, 0);
3190 ok(ret == STATUS_INVALID_HANDLE, "got %#lx\n", ret);
3191
3192 size = 0;
3193 buf = malloc(sizeof(rsaPrivateBlob));
3194 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPRIVATE_BLOB, buf, sizeof(rsaPrivateBlob), &size, 0);
3195 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3196 ok(size == sizeof(rsaPrivateBlob), "got %lu\n", size);
3197 ok(!memcmp(buf, rsaPrivateBlob, size), "wrong data\n");
3198 free(buf);
3199 BCryptDestroyKey(key);
3200
3201 /* import/export full private key */
3202 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, &key, rsaFullPrivateBlob, sizeof(rsaFullPrivateBlob), 0);
3203 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3204
3205 size = 0;
3206 buf = malloc(sizeof(rsaFullPrivateBlob));
3207 ret = BCryptExportKey(key, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, buf, sizeof(rsaFullPrivateBlob), &size, 0);
3208 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3209 ok(size == sizeof(rsaFullPrivateBlob), "got %lu\n", size);
3210 ok(!memcmp(buf, rsaFullPrivateBlob, size), "wrong data\n");
3211 free(buf);
3212 BCryptDestroyKey(key);
3213
3214 ret = BCryptImportKeyPair(alg, NULL, LEGACY_RSAPRIVATE_BLOB, &key, legacy_rsa_key, sizeof(legacy_rsa_key), 0);
3215 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
3216
3217 ret = BCryptCloseAlgorithmProvider(alg, 0);
3218 ok(!ret, "got %#lx\n", ret);
3219}
rsaFullPrivateBlob
static UCHAR rsaFullPrivateBlob[]
Definition: bcrypt.c:2609
rsaPrivateBlob
static UCHAR rsaPrivateBlob[]
Definition: bcrypt.c:2595
rsaPublicBlobWithInvalidPublicExpSize
static UCHAR rsaPublicBlobWithInvalidPublicExpSize[]
Definition: bcrypt.c:2684
rsaPublicBlob
static UCHAR rsaPublicBlob[]
Definition: bcrypt.c:2547
rsaSignature
static UCHAR rsaSignature[]
Definition: bcrypt.c:2575
legacy_rsa_key
static UCHAR legacy_rsa_key[]
Definition: bcrypt.c:2950
rsaHash
static UCHAR rsaHash[]
Definition: bcrypt.c:2569
LEGACY_RSAPRIVATE_BLOB
#define LEGACY_RSAPRIVATE_BLOB
Definition: bcrypt.h:90
BCRYPT_SIGNATURE_LENGTH
#define BCRYPT_SIGNATURE_LENGTH
Definition: bcrypt.h:68
BCRYPT_RSAFULLPRIVATE_MAGIC
#define BCRYPT_RSAFULLPRIVATE_MAGIC
Definition: bcrypt.h:243
BCRYPT_RSAPRIVATE_MAGIC
#define BCRYPT_RSAPRIVATE_MAGIC
Definition: bcrypt.h:242
BCRYPT_PAD_PSS
#define BCRYPT_PAD_PSS
Definition: bcrypt.h:276
BCRYPT_RSAPRIVATE_BLOB
#define BCRYPT_RSAPRIVATE_BLOB
Definition: bcrypt.h:77
BCRYPT_RSAPUBLIC_MAGIC
#define BCRYPT_RSAPUBLIC_MAGIC
Definition: bcrypt.h:241
BCRYPT_SHA384_ALGORITHM
#define BCRYPT_SHA384_ALGORITHM
Definition: bcrypt.h:121
BCRYPT_RSAFULLPRIVATE_BLOB
#define BCRYPT_RSAFULLPRIVATE_BLOB
Definition: bcrypt.h:78
_BCRYPT_PSS_PADDING_INFO
Definition: bcrypt.h:261
_BCRYPT_PSS_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:262
_BCRYPT_PSS_PADDING_INFO::cbSalt
ULONG cbSalt
Definition: bcrypt.h:263
_BCRYPT_RSAKEY_BLOB
Definition: bcrypt.h:246
_BCRYPT_RSAKEY_BLOB::cbPublicExp
ULONG cbPublicExp
Definition: bcrypt.h:249
_BCRYPT_RSAKEY_BLOB::BitLength
ULONG BitLength
Definition: bcrypt.h:248
_BCRYPT_RSAKEY_BLOB::Magic
ULONG Magic
Definition: bcrypt.h:247
_BCRYPT_RSAKEY_BLOB::cbPrime2
ULONG cbPrime2
Definition: bcrypt.h:252
_BCRYPT_RSAKEY_BLOB::cbModulus
ULONG cbModulus
Definition: bcrypt.h:250
_BCRYPT_RSAKEY_BLOB::cbPrime1
ULONG cbPrime1
Definition: bcrypt.h:251
NTE_BAD_DATA
#define NTE_BAD_DATA
Definition: winerror.h:4252

Referenced by START_TEST().

◆ test_rsa_encrypt()

static void test_rsa_encrypt ( void  )
static

Definition at line 2709 of file bcrypt.c.

2710{
2711 UCHAR input[] = "Hello World!", input_no_padding[64] = { 0 }, encrypted[64], decrypted[64];
2712 BCRYPT_ALG_HANDLE rsa;
2713 BCRYPT_KEY_HANDLE key, key2;
2714 NTSTATUS ret;
2715 DWORD encrypted_size, decrypted_size;
2716 UCHAR *encrypted_a = NULL, *encrypted_b = NULL;
2717 BCRYPT_OAEP_PADDING_INFO oaep_pad;
2718
2719 oaep_pad.pszAlgId = BCRYPT_SHA256_ALGORITHM;
2720 oaep_pad.pbLabel = (UCHAR *)"test";
2721 oaep_pad.cbLabel = 5;
2722
2723 ret = BCryptOpenAlgorithmProvider(&rsa, BCRYPT_RSA_ALGORITHM, NULL, 0);
2724 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2725 ret = BCryptGenerateKeyPair(rsa, &key, 512, 0);
2726 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2727
2728 /* Not finalized key */
2729 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, NULL, 0, &encrypted_size, 0);
2730 ok(ret == STATUS_INVALID_HANDLE, "got %lx\n", ret);
2731 BCryptDestroyKey(key);
2732
2733 /* Import a different public key first to make sure a public key from private key improted next
2734 * overrides it. */
2735 ret = BCryptImportKeyPair(rsa, NULL, BCRYPT_RSAPUBLIC_BLOB, &key, rsaPublicBlob, sizeof(rsaPublicBlob), 0);
2736 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2737
2738 ret = BCryptImportKeyPair(rsa, NULL, BCRYPT_RSAPRIVATE_BLOB, &key, rsaPrivateBlob, sizeof(rsaPrivateBlob), 0);
2739 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2740
2741 /* No padding */
2742 memset(input_no_padding, 0, sizeof(input_no_padding));
2743
2744 encrypted_size = 0;
2745 ret = BCryptEncrypt(key, input_no_padding, sizeof(input_no_padding), NULL, NULL, 0, NULL, 0, &encrypted_size, BCRYPT_PAD_NONE);
2746 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2747 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2748
2749 strcpy((char *)input_no_padding, "Hello World");
2750 encrypted_size = 0;
2751 ret = BCryptEncrypt(key, input_no_padding, sizeof(input_no_padding), NULL, NULL, 0, NULL, 0, &encrypted_size, BCRYPT_PAD_NONE);
2752 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2753 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2754
2755 encrypted_a = malloc(encrypted_size);
2756 memset(encrypted_a, 0, encrypted_size);
2757 encrypted_b = malloc(encrypted_size);
2758 memset(encrypted_b, 0xff, encrypted_size);
2759
2760 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, encrypted_a, encrypted_size, &encrypted_size, BCRYPT_PAD_NONE);
2761 ok(ret == STATUS_INVALID_PARAMETER, "got %lx\n", ret);
2762
2763 ret = BCryptEncrypt(key, input_no_padding, sizeof(input_no_padding), NULL, NULL, 0, encrypted_a, 12, &encrypted_size, BCRYPT_PAD_NONE);
2764 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %lx\n", ret);
2765 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2766
2767 ret = BCryptEncrypt(key, input_no_padding, sizeof(input_no_padding), NULL, NULL, 0, encrypted_a, encrypted_size, &encrypted_size, BCRYPT_PAD_NONE);
2768 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2769 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2770
2771 ret = BCryptEncrypt(key, input_no_padding, sizeof(input_no_padding), NULL, NULL, 0, encrypted_b, encrypted_size, &encrypted_size, BCRYPT_PAD_NONE);
2772 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2773 ok(!memcmp(encrypted_a, encrypted_b, encrypted_size), "Both outputs should be the same\n");
2774 ok(!memcmp(encrypted_b, rsa_encrypted_no_padding, encrypted_size), "Data mismatch.\n");
2775
2776 decrypted_size = 0;
2777 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, NULL, NULL, 0, NULL, 0, &decrypted_size, BCRYPT_PAD_NONE);
2778 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2779 ok(decrypted_size == sizeof(input_no_padding), "got %lu\n", decrypted_size);
2780
2781 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, NULL, NULL, 0, decrypted, decrypted_size, &decrypted_size, BCRYPT_PAD_NONE);
2782 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2783 ok(decrypted_size == sizeof(input_no_padding), "got %lu\n", decrypted_size);
2784 ok(!memcmp(decrypted, input_no_padding, sizeof(input_no_padding)), "unexpected output\n");
2785
2786 /* PKCS1 Padding */
2787 encrypted_size = 0;
2788 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, NULL, 0, &encrypted_size, BCRYPT_PAD_PKCS1);
2789 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2790 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2791
2792 encrypted_a = realloc(encrypted_a, encrypted_size);
2793 memset(encrypted_a, 0, encrypted_size);
2794 encrypted_b = realloc(encrypted_b, encrypted_size);
2795 memset(encrypted_b, 0, encrypted_size);
2796
2797 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, encrypted_a, encrypted_size, &encrypted_size, BCRYPT_PAD_PKCS1);
2798 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2799 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2800
2801 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, encrypted_b, encrypted_size, &encrypted_size, BCRYPT_PAD_PKCS1);
2802 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2803 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2804 ok(memcmp(encrypted_a, encrypted_b, encrypted_size), "Both outputs are the same\n");
2805
2806 decrypted_size = 0;
2807 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, NULL, NULL, 0, NULL, 0, &decrypted_size, BCRYPT_PAD_PKCS1);
2808 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2809 ok(decrypted_size == sizeof(input), "got size of %ld\n", decrypted_size);
2810
2811 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, NULL, NULL, 0, decrypted, decrypted_size, &decrypted_size, BCRYPT_PAD_PKCS1);
2812 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2813 ok(decrypted_size == sizeof(input), "got size of %ld\n", decrypted_size);
2814 ok(!memcmp(decrypted, input, sizeof(input)), "unexpected output\n");
2815
2816 ret = BCryptImportKeyPair(rsa, NULL, LEGACY_RSAPRIVATE_BLOB, &key2, (UCHAR *)&rsaLegacyPrivateBlob,
2817 sizeof(rsaLegacyPrivateBlob), 0);
2818 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2819
2820 ret = BCryptEncrypt(key2, input, sizeof(input), NULL, NULL, 0, encrypted, sizeof(encrypted),
2821 &encrypted_size, BCRYPT_PAD_PKCS1);
2822 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2823 ok(encrypted_size == 64, "got size of %ld\n", encrypted_size);
2824
2825 memset(decrypted, 0, sizeof(decrypted));
2826 ret = BCryptDecrypt(key, encrypted, sizeof(encrypted), NULL, NULL, 0, decrypted, sizeof(decrypted),
2827 &decrypted_size, BCRYPT_PAD_PKCS1);
2828 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2829 ok(decrypted_size == sizeof(input), "got size of %ld\n", decrypted_size);
2830 ok(!memcmp(decrypted, input, sizeof(input)), "unexpected output\n");
2831 BCryptDestroyKey(key2);
2832 BCryptDestroyKey(key);
2833
2834 /* OAEP Padding */
2835 ret = BCryptGenerateKeyPair(rsa, &key, 640 /* minimum size for sha256 hash */, 0);
2836 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2837
2838 ret = BCryptFinalizeKeyPair(key, 0);
2839 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
2840
2841 encrypted_size = 0;
2842 ret = BCryptEncrypt(key, input, sizeof(input), &oaep_pad, NULL, 0, NULL, 0, &encrypted_size, BCRYPT_PAD_OAEP);
2843 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2844 ok(encrypted_size == 80, "got size of %ld\n", encrypted_size);
2845
2846 encrypted_size = 0;
2847 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, NULL, 0, &encrypted_size, BCRYPT_PAD_OAEP);
2848 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2849 ok(encrypted_size == 80, "got size of %ld\n", encrypted_size);
2850
2851 encrypted_a = realloc(encrypted_a, encrypted_size);
2852 memset(encrypted_a, 0, encrypted_size);
2853 encrypted_b = realloc(encrypted_b, encrypted_size);
2854 memset(encrypted_b, 0, encrypted_size);
2855
2856 encrypted_size = 0;
2857 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, encrypted_a, 0, &encrypted_size, BCRYPT_PAD_OAEP);
2858 ok(ret == STATUS_BUFFER_TOO_SMALL, "got %lx\n", ret);
2859 ok(encrypted_size == 80, "got size of %ld\n", encrypted_size);
2860
2861 ret = BCryptEncrypt(key, input, sizeof(input), &oaep_pad, NULL, 0, encrypted_a, encrypted_size, &encrypted_size, BCRYPT_PAD_OAEP);
2862 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2863 ok(encrypted_size == 80, "got size of %ld\n", encrypted_size);
2864
2865 ret = BCryptEncrypt(key, input, sizeof(input), &oaep_pad, NULL, 0, encrypted_b, encrypted_size, &encrypted_size, BCRYPT_PAD_OAEP);
2866 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2867 ok(encrypted_size == 80, "got size of %ld\n", encrypted_size);
2868 ok(memcmp(encrypted_a, encrypted_b, encrypted_size), "Both outputs are the same\n");
2869
2870 decrypted_size = 0;
2871 memset(decrypted, 0, sizeof(decrypted));
2872 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, NULL, NULL, 0, NULL, 0, &decrypted_size, BCRYPT_PAD_OAEP);
2873 ok(ret == STATUS_INVALID_PARAMETER, "got %lx\n", ret);
2874
2875 decrypted_size = 0;
2876 memset(decrypted, 0, sizeof(decrypted));
2877 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, &oaep_pad, NULL, 0, NULL, 0, &decrypted_size, BCRYPT_PAD_OAEP);
2878 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2879 ok(decrypted_size == sizeof(input), "got %lu\n", decrypted_size);
2880
2881 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, &oaep_pad, NULL, 0, decrypted, decrypted_size, &decrypted_size, BCRYPT_PAD_OAEP);
2882 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2883 ok(decrypted_size == sizeof(input), "got %lu\n", decrypted_size);
2884 ok(!memcmp(decrypted, input, sizeof(input)), "unexpected output\n");
2885
2886 /* Prove empty label (pbLabel NULL, cbLabel 0) works for OAEP. */
2887 {
2888 BCRYPT_OAEP_PADDING_INFO sha1_empty_label;
2889 UCHAR roundtrip_plain[sizeof(input)];
2890 DWORD roundtrip_size;
2891
2892 sha1_empty_label.pszAlgId = BCRYPT_SHA1_ALGORITHM;
2893 sha1_empty_label.pbLabel = NULL;
2894 sha1_empty_label.cbLabel = 0;
2895
2896 encrypted_size = 0;
2897 ret = BCryptEncrypt(key, input, sizeof(input), &sha1_empty_label, NULL, 0, NULL, 0, &encrypted_size, BCRYPT_PAD_OAEP);
2898 ok(ret == STATUS_SUCCESS, "encrypt with empty label failed: %lx\n", ret);
2899
2900 encrypted_a = realloc(encrypted_a, encrypted_size);
2901 ret = BCryptEncrypt(key, input, sizeof(input), &sha1_empty_label, NULL, 0, encrypted_a, encrypted_size, &encrypted_size, BCRYPT_PAD_OAEP);
2902 ok(ret == STATUS_SUCCESS, "encrypt with empty label failed: %lx\n", ret);
2903
2904 roundtrip_size = 0;
2905 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, &sha1_empty_label, NULL, 0, NULL, 0, &roundtrip_size, BCRYPT_PAD_OAEP);
2906 ok(ret == STATUS_SUCCESS, "decrypt with empty label failed: %lx\n", ret);
2907 ok(roundtrip_size == sizeof(input), "decrypted size %lu, expected %lu\n", roundtrip_size, (unsigned long)sizeof(input));
2908
2909 ret = BCryptDecrypt(key, encrypted_a, encrypted_size, &sha1_empty_label, NULL, 0, roundtrip_plain, roundtrip_size, &roundtrip_size, BCRYPT_PAD_OAEP);
2910 ok(ret == STATUS_SUCCESS, "decrypt failed: %lx\n", ret);
2911 ok(!memcmp(roundtrip_plain, input, sizeof(input)), "roundtrip plaintext mismatch\n");
2912 }
2913
2914 /* OAEP(NULL) behavior observed on native Windows:
2915 * - size query succeeds
2916 * - actual encryption fails with STATUS_INVALID_PARAMETER */
2917 {
2918 UCHAR *encrypted_null = NULL;
2919 DWORD encrypted_null_size = 0;
2920
2921 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, NULL, 0, &encrypted_null_size, BCRYPT_PAD_OAEP);
2922 ok(ret == STATUS_SUCCESS, "unexpected OAEP(NULL) size query status %lx\n", ret);
2923
2924 if (ret == STATUS_SUCCESS)
2925 {
2926 encrypted_null = malloc(encrypted_null_size);
2927 ret = BCryptEncrypt(key, input, sizeof(input), NULL, NULL, 0, encrypted_null, encrypted_null_size,
2928 &encrypted_null_size, BCRYPT_PAD_OAEP);
2929 todo_wine ok(ret == STATUS_INVALID_PARAMETER || broken(ret == STATUS_SUCCESS),
2930 "unexpected OAEP(NULL) encrypt status %lx\n", ret);
2931
2932 free(encrypted_null);
2933 }
2934 }
2935
2936 free(encrypted_a);
2937 free(encrypted_b);
2938
2939 BCryptDestroyKey(key);
2940
2941 if (pBCryptHash)
2942 {
2943 ret = BCryptGenerateKeyPair(BCRYPT_RSA_ALG_HANDLE, &key, 512, 0);
2944 ok(ret == STATUS_SUCCESS, "got %lx\n", ret);
2945 BCryptDestroyKey(key);
2946 }
2947}
rsaLegacyPrivateBlob
static struct @1910 rsaLegacyPrivateBlob
rsa_encrypted_no_padding
static const UCHAR rsa_encrypted_no_padding[]
Definition: bcrypt.c:2701
BCRYPT_RSA_ALG_HANDLE
#define BCRYPT_RSA_ALG_HANDLE
Definition: bcrypt.h:430
BCRYPT_PAD_OAEP
#define BCRYPT_PAD_OAEP
Definition: bcrypt.h:275
BCRYPT_PAD_NONE
#define BCRYPT_PAD_NONE
Definition: bcrypt.h:273
realloc
#define realloc
Definition: debug_ros.c:6
strcpy
strcpy
Definition: string.h:131
_BCRYPT_OAEP_PADDING_INFO
Definition: bcrypt.h:267
_BCRYPT_OAEP_PADDING_INFO::pszAlgId
LPCWSTR pszAlgId
Definition: bcrypt.h:268
_BCRYPT_OAEP_PADDING_INFO::cbLabel
ULONG cbLabel
Definition: bcrypt.h:270
_BCRYPT_OAEP_PADDING_INFO::pbLabel
PUCHAR pbLabel
Definition: bcrypt.h:269

Referenced by START_TEST().

◆ test_RSA_SIGN()

static void test_RSA_SIGN ( void  )
static

Definition at line 3221 of file bcrypt.c.

3222{
3223 BCRYPT_PKCS1_PADDING_INFO pad;
3224 BCRYPT_ALG_HANDLE alg = NULL;
3225 BCRYPT_KEY_HANDLE key = NULL;
3226 BCRYPT_RSAKEY_BLOB *rsablob;
3227 NTSTATUS ret;
3228 ULONG size, size2, len;
3229 BYTE *buf, buf2[sizeof(BCRYPT_RSAKEY_BLOB) + sizeof(rsaPublicBlob)];
3230
3231 ret = BCryptOpenAlgorithmProvider(&alg, BCRYPT_RSA_SIGN_ALGORITHM, NULL, 0);
3232 ok(!ret, "got %#lx\n", ret);
3233
3234 ret = BCryptImportKeyPair(alg, NULL, BCRYPT_RSAPUBLIC_BLOB, &key, rsaPublicBlob, sizeof(rsaPublicBlob), 0);
3235 ok(!ret, "BCryptImportKeyPair failed: %#lx\n", ret);
3236
3237 memset(buf2, 0xcc, sizeof(buf2));
3238 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPUBLIC_BLOB, buf2, sizeof(buf2), &size, 0);
3239 ok(!ret, "got %#lx\n", ret);
3240 rsablob = (BCRYPT_RSAKEY_BLOB *)buf2;
3241 ok(rsablob->Magic == BCRYPT_RSAPUBLIC_MAGIC, "got %#lx\n", rsablob->Magic);
3242 ok(rsablob->BitLength == 2048, "got %lu\n", rsablob->BitLength);
3243 ok(rsablob->cbPublicExp == 3, "got %lu\n", rsablob->cbPublicExp);
3244 ok(rsablob->cbModulus == 256, "got %lu\n", rsablob->cbModulus);
3245 ok(rsablob->cbPrime1 == 0, "got %lu\n", rsablob->cbPrime1);
3246 ok(rsablob->cbPrime2 == 0, "got %lu\n", rsablob->cbPrime2);
3247 size2 = sizeof(*rsablob) + rsablob->cbPublicExp + rsablob->cbModulus + rsablob->cbPrime1 + rsablob->cbPrime2;
3248 ok(size == size2, "got %lu expected %lu\n", size2, size);
3249
3250 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPRIVATE_BLOB, buf2, sizeof(buf2), &size, 0);
3251 ok(ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
3252
3253 pad.pszAlgId = NULL;
3254 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3255 ok(ret == STATUS_INVALID_SIGNATURE, "BCryptVerifySignature failed: %#lx\n", ret);
3256
3257 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3258 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3259 ok(!ret, "BCryptVerifySignature failed: %#lx\n", ret);
3260
3261 ret = BCryptVerifySignature(key, NULL, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3262 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", ret);
3263
3264 pad.pszAlgId = BCRYPT_SHA1_ALGORITHM;
3265 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), 0);
3266 ok(ret == STATUS_INVALID_SIGNATURE || ret == STATUS_INVALID_PARAMETER, "got %#lx\n", ret);
3267
3268 ret = BCryptVerifySignature(key, NULL, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), 0);
3269 ok(ret == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %#lx\n", ret);
3270
3271 pad.pszAlgId = BCRYPT_AES_ALGORITHM;
3272 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3273 ok(ret == STATUS_NOT_SUPPORTED, "Expected STATUS_NOT_SUPPORTED, got %#lx\n", ret);
3274
3275 pad.pszAlgId = NULL;
3276 ret = BCryptVerifySignature(key, &pad, rsaHash, sizeof(rsaHash), rsaSignature, sizeof(rsaSignature), BCRYPT_PAD_PKCS1);
3277 ok(ret == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %#lx\n", ret);
3278
3279 ret = BCryptDestroyKey(key);
3280 ok(!ret, "BCryptDestroyKey failed: %#lx\n", ret);
3281
3282 /* export private key */
3283 ret = BCryptGenerateKeyPair(alg, &key, 512, 0);
3284 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3285
3286 ret = BCryptFinalizeKeyPair(key, 0);
3287 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3288
3289 size = len = 0;
3290 ret = BCryptGetProperty(key, BCRYPT_SIGNATURE_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
3291 ok(!ret, "got %#lx\n", ret);
3292 ok(size == sizeof(len), "got %lu\n", size);
3293 ok(len == 64, "got %lu\n", len);
3294
3295 size = 0;
3296 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPRIVATE_BLOB, NULL, 0, &size, 0);
3297 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3298 ok(size, "size not set\n");
3299
3300 buf = malloc(size);
3301 ret = BCryptExportKey(key, NULL, BCRYPT_RSAPRIVATE_BLOB, buf, size, &size, 0);
3302 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3303 rsablob = (BCRYPT_RSAKEY_BLOB *)buf;
3304 ok(rsablob->Magic == BCRYPT_RSAPRIVATE_MAGIC, "got %#lx\n", rsablob->Magic);
3305 ok(rsablob->BitLength == 512, "got %lu\n", rsablob->BitLength);
3306 ok(rsablob->cbPublicExp == 3, "got %lu\n", rsablob->cbPublicExp);
3307 ok(rsablob->cbModulus == 64, "got %lu\n", rsablob->cbModulus);
3308 ok(rsablob->cbPrime1 == 32, "got %lu\n", rsablob->cbPrime1);
3309 ok(rsablob->cbPrime2 == 32, "got %lu\n", rsablob->cbPrime2);
3310 size2 = sizeof(*rsablob) + rsablob->cbPublicExp + rsablob->cbModulus + rsablob->cbPrime1 + rsablob->cbPrime2;
3311 ok(size == size2, "got %lu expected %lu\n", size2, size);
3312 free(buf);
3313
3314 size = 0;
3315 ret = BCryptExportKey(key, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, NULL, 0, &size, 0);
3316 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3317 ok(size, "size not set\n");
3318
3319 buf = malloc(size);
3320 ret = BCryptExportKey(key, NULL, BCRYPT_RSAFULLPRIVATE_BLOB, buf, size, &size, 0);
3321 ok(ret == STATUS_SUCCESS, "got %#lx\n", ret);
3322 rsablob = (BCRYPT_RSAKEY_BLOB *)buf;
3323 ok(rsablob->Magic == BCRYPT_RSAFULLPRIVATE_MAGIC, "got %#lx\n", rsablob->Magic);
3324 ok(rsablob->BitLength == 512, "got %lu\n", rsablob->BitLength);
3325 ok(rsablob->cbPublicExp == 3, "got %lu\n", rsablob->cbPublicExp);
3326 ok(rsablob->cbModulus == 64, "got %lu\n", rsablob->cbModulus);
3327 ok(rsablob->cbPrime1 == 32, "got %lu\n", rsablob->cbPrime1);
3328 ok(rsablob->cbPrime2 == 32, "got %lu\n", rsablob->cbPrime2);
3329 size2 = sizeof(*rsablob) + rsablob->cbPublicExp + rsablob->cbModulus * 2 + rsablob->cbPrime1 * 3 + rsablob->cbPrime2 * 2;
3330 ok(size == size2, "got %lu expected %lu\n", size2, size);
3331 free(buf);
3332 BCryptDestroyKey(key);
3333
3334 ret = BCryptCloseAlgorithmProvider(alg, 0);
3335 ok(!ret, "BCryptCloseAlgorithmProvider failed: %#lx\n", ret);
3336}
BCRYPT_RSAKEY_BLOB
struct _BCRYPT_RSAKEY_BLOB BCRYPT_RSAKEY_BLOB
BCRYPT_RSA_SIGN_ALGORITHM
#define BCRYPT_RSA_SIGN_ALGORITHM
Definition: bcrypt.h:118

Referenced by START_TEST().

◆ test_SecretAgreement()

static void test_SecretAgreement ( void  )
static

Definition at line 4667 of file bcrypt.c.

4668{
4669 static BCryptBuffer hash_param_buffers[] =
4670 {
4671 {
4672 sizeof(BCRYPT_SHA256_ALGORITHM),
4673 KDF_HASH_ALGORITHM,
4674 (void *)BCRYPT_SHA256_ALGORITHM,
4675 }
4676 };
4677 static BCryptBufferDesc hash_params =
4678 {
4679 BCRYPTBUFFER_VERSION,
4680 ARRAY_SIZE(hash_param_buffers),
4681 hash_param_buffers,
4682 };
4683
4684 static const ULONG dh_private_key[] =
4685 {
4686 0xc4caf69c, 0x57b4db27, 0x36f7135f, 0x5ccba686, 0xc37b8819, 0x1d35c9b2, 0xbb07a1cf, 0x0c5d1c1b,
4687 0xc79acb10, 0x31dfdabb, 0x702e02b9, 0x1efab345, 0x262a8074, 0x5edf7698, 0x9b9dc630, 0x13c34b93,
4688 0xacbc928b, 0xb79eed8c, 0x7413dce9, 0xa5521280, 0x88d8e695, 0xa310269f, 0xca7c5719, 0xcd0c775b,
4689 0x9a6e2cf2, 0x9e235c51, 0xf49db62d, 0x28e72424, 0x4a44da5a, 0x3d98268d, 0x8e4d2be3, 0x254e44e6,
4690
4691 0x18a67e55, 0x572e13a1, 0x46f81ca8, 0xc331c9b9, 0xf8fe3dd4, 0x8a889e5a, 0x6c0505fd, 0xbd97a121,
4692 0xed2dbd67, 0xf39efa8e, 0x36f9c287, 0xf6bbfa6c, 0x461e42ad, 0x17dc170e, 0xc002dc2e, 0x4813d9a4,
4693 0x0b6fabb8, 0x6a9e1860, 0xa8a8cbd9, 0xb7ed6b5d, 0xabb34d23, 0xf2fbe1fd, 0x8670df1e, 0xba7fa4e6,
4694 0xf7039712, 0x94448f30, 0xe10c812e, 0x3e311976, 0xcfdd72c4, 0xbdbea98f, 0xc9a540d6, 0x89646d57,
4695
4696 0x7ab63b33, 0x03a1e9b6, 0x947f7a9b, 0x5ae59eeb, 0x1d12eb05, 0x3f425d92, 0xe028c6ba, 0xbf90ddc9,
4697 0xb554f55a, 0x7aeb88b6, 0x4a443a5f, 0xbab35111, 0x82c78a0c, 0x298dd482, 0x02937cb1, 0xc94cdc2e,
4698 0x59b010eb, 0x3bbc0a2b, 0xd845fee0, 0x04c1d0db, 0x0c8c9424, 0x1cafd4b2, 0x9aa7aed9, 0x6a478486,
4699 0xa8841fd7, 0xbfeff40a, 0x8fd7bcc5, 0x3bb28977, 0x2b9a7955, 0xa55cd2e4, 0x1b6ad657, 0x067cdf21,
4700
4701 0x06f36920, 0x63280e1b, 0xf17d930f, 0xa06e74a8, 0x463b3a6f, 0x2a464507, 0x93f8a982, 0x8f620a7d,
4702 0xeda32d11, 0x9706a6d4, 0x33dce588, 0x75a1c446, 0x048ab567, 0xd735aafa, 0x806f7c1c, 0xdcb9651a,
4703 0x26acf3b4, 0x45f91cc9, 0x2a0de6fc, 0xf3c03d0c, 0xf5aee0aa, 0x3eeaaf36, 0x18ccee61, 0x83faa783,
4704 0x4b2b5250, 0xf4ccea22, 0x5ac0714b, 0x3f0b2bc6, 0x481b13ce, 0x12040ea7, 0x66e0bbed, 0x158e1a67,
4705 };
4706 static const ULONG dh_private_key2[] =
4707 {
4708 0xffffffff, 0xffffffff, 0xa2da0fc9, 0x34c26821, 0x8b62c6c4, 0xd11cdc80, 0x084e0229, 0x74cc678a,
4709 0xa6be0b02, 0x229b133b, 0x79084a51, 0xdd04348e, 0xb31995ef, 0x1b433acd, 0x6d0a2b30, 0x37145ff2,
4710 0x6d35e14f, 0x45c2516d, 0x76b585e4, 0xc67e5e62, 0xe9424cf4, 0x6bed37a6, 0xb65cff0b, 0xedb706f4,
4711 0xfb6b38ee, 0xa59f895a, 0x11249fae, 0xe61f4b7c, 0x51662849, 0x8153e6ec, 0xffffffff, 0xffffffff,
4712
4713 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4714 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4715 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4716 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x02000000,
4717
4718 0xa0c3c734, 0xc130c92d, 0x5265abf8, 0xff409f17, 0xbcdce187, 0xff64dae3, 0x170560aa, 0xb2423ed8,
4719 0x9ee5a8b9, 0x92548030, 0x02bba1f9, 0x823e39a4, 0x69c438f5, 0xf91016ac, 0x89bfd166, 0x7f996446,
4720 0x86224203, 0x15bf689c, 0x619354a4, 0x0c1d3a1f, 0x11bcf3d2, 0x58aae029, 0x41c69824, 0x3fafc179,
4721 0xa742747c, 0x60658c7a, 0xd3b0bde4, 0x78d3f08b, 0x6cefa061, 0x33752536, 0xe84d4901, 0x48cd73f4,
4722
4723 0x8d449700, 0x1f95120e, 0xceb31745, 0x3663177b, 0xbd9bb2d5, 0x9c23c0d9, 0x814d34f8, 0xbc54edb0,
4724 0xb874659a, 0x3bac8a30, 0xa1f3dd46, 0x1705c900, 0xbc46fefe, 0x7d13875b, 0x3064351a, 0x4bd89a1c,
4725 0x9e938761, 0x931949db, 0x34490719, 0x84fb08ca, 0xa9dd355a, 0x5b3f5061, 0x2ac96663, 0xc594429e,
4726 0xbe58395d, 0x2f7d872a, 0x303d37b3, 0xa3a9b606, 0x735a6732, 0xa095bd95, 0x3d55a7c3, 0x00e54635,
4727 };
4728 static const ULONG dh_peer_key[] =
4729 {
4730 0xffffffff, 0xffffffff, 0xa2da0fc9, 0x34c26821, 0x8b62c6c4, 0xd11cdc80, 0x084e0229, 0x74cc678a,
4731 0xa6be0b02, 0x229b133b, 0x79084a51, 0xdd04348e, 0xb31995ef, 0x1b433acd, 0x6d0a2b30, 0x37145ff2,
4732 0x6d35e14f, 0x45c2516d, 0x76b585e4, 0xc67e5e62, 0xe9424cf4, 0x6bed37a6, 0xb65cff0b, 0xedb706f4,
4733 0xfb6b38ee, 0xa59f895a, 0x11249fae, 0xe61f4b7c, 0x51662849, 0x8153e6ec, 0xffffffff, 0xffffffff,
4734
4735 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4736 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4737 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
4738 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x02000000,
4739
4740 0x3bf7404b, 0x6284fffe, 0x97c0d565, 0xd830c658, 0xcc21bf39, 0xcae45bb6, 0x019df7df, 0xbf4cd293,
4741 0x6bf1989d, 0x78a81f52, 0xa4ed861c, 0x6bacf493, 0xa3e700d1, 0xd06cc206, 0x411b9727, 0x01e9c9ab,
4742 0x9b7e6efa, 0xf46bb25d, 0xd1027242, 0x6130787c, 0xa7b87d8b, 0xfee41492, 0x50db6213, 0x321199b6,
4743 0x7dace53a, 0xe8b1ec51, 0x2181b113, 0x3b33e3c0, 0x5b3a2d67, 0xbd34f0c1, 0x7037c542, 0x4a8d5540,
4744 };
4745 static const ULONG dh_shared_secret_raw[] =
4746 {
4747 0x375d89b5, 0x35a9c270, 0xfbc5ba82, 0x09eb3069, 0xd50965b0, 0xace510f7, 0x981e8731, 0x80a76115,
4748 0xf386d348, 0xca17b8df, 0x0b0e84ec, 0xf81f756e, 0x5030fa20, 0x03113b71, 0x97b7e879, 0x899b5fae,
4749 0xe6913299, 0x09270076, 0x39bc813a, 0xde3ef070, 0x65ad5b3a, 0x2b7c4ba4, 0x86c98ef9, 0x3236feaf,
4750 0x3e0253f7, 0x0489d2dd, 0x97669a3d, 0x50242fca, 0x5d4aecb1, 0xcf2d805f, 0x2258afff, 0x750e92cd,
4751 };
4752 static const ULONG dh_shared_secret_raw2[] =
4753 {
4754 0x0815f37d, 0x19ee74ab, 0x9f63f123, 0xe1b3f10c, 0xbcc9be83, 0xaddf5b9d, 0x28174e72, 0xf8a33825,
4755 0xfc74e47d, 0x2c950888, 0xf5b776d9, 0xfc712fef, 0x5b213b32, 0x489a9829, 0xfc0a4d1d, 0x6e641d3b,
4756 0x3bb2ff57, 0x63500318, 0x081ee54f, 0xf33a2805, 0xb3759e98, 0xa9a64afe, 0x964b8897, 0x04691bbc,
4757 0x80f4aae1, 0x617405ee, 0xab71724d, 0x6c10c214, 0x6f60b96f, 0xdc777b0b, 0x22f40d4f, 0x8a1c4eb5,
4758 };
4759 static const ULONG dh_shared_secret_sha1[] =
4760 {
4761 0x0babba9c, 0x0bdeacbd, 0x04e36574, 0xdd504dcd, 0x0cd88db0,
4762 };
4763 static const ULONG dh_shared_secret_sha256[] =
4764 {
4765 0x3213db5b, 0x8cc8250b, 0xc829eaab, 0x00933709, 0x68160aa9, 0xfb9f1e20, 0xf92368e6, 0x2b8e18eb,
4766 };
4767 static const struct
4768 {
4769 const WCHAR *alg;
4770 ULONG bitlen;
4771 }
4772 ecdh_algorithms[] =
4773 {
4774 { BCRYPT_ECDH_P256_ALGORITHM, 256 },
4775 { BCRYPT_ECDH_P384_ALGORITHM, 384 },
4776 { BCRYPT_ECDH_P521_ALGORITHM, 521 },
4777 };
4778 static const ULONG length = 1024;
4779 BCRYPT_DH_PARAMETER_HEADER *dh_header;
4780 BCRYPT_DH_KEY_BLOB *dh_key_blob;
4781 BCRYPT_SECRET_HANDLE secret, secret2;
4782 BCRYPT_ALG_HANDLE alg;
4783 BCRYPT_KEY_HANDLE key, key2;
4784 UCHAR buffer[2048];
4785 NTSTATUS status;
4786 ULONG size, i;
4787
4788 for (i = 0; i < ARRAY_SIZE(ecdh_algorithms); ++i)
4789 {
4790 winetest_push_context("%s", debugstr_w(ecdh_algorithms[i].alg));
4791 status = BCryptOpenAlgorithmProvider(&alg, ecdh_algorithms[i].alg, NULL, 0);
4792 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4793
4794 key = NULL;
4795 status = BCryptGenerateKeyPair(alg, &key, ecdh_algorithms[i].bitlen, 0);
4796 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4797 ok(key != NULL, "key not set\n");
4798
4799 status = BCryptFinalizeKeyPair(key, 0);
4800 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4801
4802 status = BCryptSecretAgreement(NULL, key, &secret, 0);
4803 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4804
4805 status = BCryptSecretAgreement(key, NULL, &secret, 0);
4806 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4807
4808 status = BCryptSecretAgreement(key, key, NULL, 0);
4809 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
4810
4811 status = BCryptSecretAgreement(key, key, &secret, 0);
4812 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4813
4814 status = BCryptDeriveKey(NULL, L"HASH", NULL, NULL, 0, &size, 0);
4815 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4816
4817 status = BCryptDeriveKey(key, L"HASH", NULL, NULL, 0, &size, 0);
4818 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4819
4820 status = BCryptDeriveKey(secret, NULL, NULL, NULL, 0, &size, 0);
4821 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
4822
4823 status = BCryptDeriveKey(secret, L"HASH", NULL, NULL, 0, &size, 0);
4824 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4825
4826 status = BCryptDestroyHash(secret);
4827 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
4828
4829 status = BCryptDestroyKey(secret);
4830 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4831
4832 status = BCryptDestroySecret(NULL);
4833 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4834
4835 status = BCryptDestroySecret(alg);
4836 ok(status == STATUS_INVALID_HANDLE, "got %#lx\n", status);
4837
4838 status = BCryptDestroySecret(secret);
4839 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4840
4841 status = BCryptDestroyKey(key);
4842 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4843
4844 status = BCryptCloseAlgorithmProvider(alg, 0);
4845 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4846 winetest_pop_context();
4847 }
4848
4849 /* DH */
4850 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_DH_ALGORITHM, NULL, 0);
4851 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4852
4853 key = NULL;
4854 status = BCryptGenerateKeyPair(alg, &key, 1024, 0);
4855 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4856 ok(key != NULL, "key not set\n");
4857
4858 status = BCryptFinalizeKeyPair(key, 0);
4859 if (status == STATUS_INVALID_PARAMETER)
4860 {
4861 win_skip("broken DH detected\n");
4862 BCryptCloseAlgorithmProvider(alg, 0);
4863 return;
4864 }
4865 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4866
4867 status = BCryptSecretAgreement(key, key, &secret, 0);
4868 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4869
4870 status = BCryptDestroyKey(key);
4871 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4872
4873 status = BCryptDeriveKey(secret, L"HASH", NULL, NULL, 0, &size, 0);
4874 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4875
4876 status = BCryptDestroySecret(secret);
4877 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
4878
4879 key = NULL;
4880 status = BCryptGenerateKeyPair(alg, &key, 256, 0);
4881 ok(status == STATUS_INVALID_PARAMETER, "got %08lx\n", status);
4882
4883 status = BCryptGenerateKeyPair(alg, &key, length, 0);
4884 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4885 ok(key != NULL, "key not set\n");
4886
4887 memset(buffer, 0xcc, sizeof(buffer));
4888 status = BCryptGetProperty(key, BCRYPT_DH_PARAMETERS, buffer, sizeof(buffer), &size, 0);
4889 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
4890
4891 status = BCryptExportKey(key, NULL, BCRYPT_DH_PUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
4892 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
4893
4894 status = BCryptFinalizeKeyPair(key, 0);
4895 if (status != STATUS_SUCCESS)
4896 {
4897 BCryptDestroyKey(key);
4898 BCryptCloseAlgorithmProvider(alg, 0);
4899 return;
4900 }
4901 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4902
4903 status = BCryptFinalizeKeyPair(key, 0);
4904 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
4905
4906 size = 0xdeadbeef;
4907 status = BCryptGetProperty(key, BCRYPT_DH_PARAMETERS, NULL, sizeof(buffer), &size, 0);
4908 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4909 ok(size == sizeof(BCRYPT_DH_PARAMETER_HEADER) + length / 8 * 2, "Got unexpected size %lu.\n", size);
4910
4911 size = 0xdeadbeef;
4912 status = BCryptGetProperty(key, BCRYPT_DH_PARAMETERS, buffer, 28, &size, 0);
4913 ok(status == STATUS_BUFFER_TOO_SMALL, "got %08lx\n", status);
4914 ok(size == sizeof(BCRYPT_DH_PARAMETER_HEADER) + length / 8 * 2, "Got unexpected size %lu.\n", size);
4915
4916 size = 0xdeadbeef;
4917 status = BCryptGetProperty(key, BCRYPT_DH_PARAMETERS, buffer, sizeof(buffer), &size, 0);
4918 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4919 ok(size == sizeof(BCRYPT_DH_PARAMETER_HEADER) + length / 8 * 2, "Got unexpected size %lu.\n", size);
4920
4921 dh_header = (BCRYPT_DH_PARAMETER_HEADER *)buffer;
4922 ok(dh_header->cbLength == sizeof(*dh_header) + length / 8 * 2, "Got unexpected length %lu.\n", dh_header->cbLength);
4923 ok(dh_header->cbKeyLength == length / 8, "Got unexpected length %lu.\n", dh_header->cbKeyLength);
4924 ok(dh_header->dwMagic == BCRYPT_DH_PARAMETERS_MAGIC, "Got unexpected magic %#lx.\n", dh_header->dwMagic);
4925
4926 status = BCryptDestroyKey(key);
4927 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4928
4929 dh_key_blob = (BCRYPT_DH_KEY_BLOB *)buffer;
4930 dh_key_blob->dwMagic = BCRYPT_DH_PRIVATE_MAGIC;
4931 dh_key_blob->cbKey = length / 8;
4932 memcpy(dh_key_blob + 1, dh_private_key, sizeof(dh_private_key));
4933 size = sizeof(buffer);
4934 status = BCryptImportKeyPair(alg, NULL, BCRYPT_DH_PRIVATE_BLOB, &key, buffer, size, 0);
4935 ok(status == STATUS_INVALID_PARAMETER, "got %08lx\n", status);
4936 size = sizeof(*dh_key_blob) + length / 8 * 4;
4937 status = BCryptImportKeyPair(alg, NULL, BCRYPT_DH_PRIVATE_BLOB, &key, buffer, size, 0);
4938 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4939
4940 memset(buffer, 0xcc, sizeof(buffer));
4941 size = 0xdeadbeef;
4942 status = BCryptExportKey(key, NULL, BCRYPT_DH_PUBLIC_BLOB, NULL, 0, &size, 0);
4943 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4944 ok(size == sizeof(BCRYPT_DH_KEY_BLOB) + length / 8 * 3, "Got unexpected size %lu.\n", size);
4945
4946 size = 0xdeadbeef;
4947 status = BCryptExportKey(key, NULL, BCRYPT_DH_PUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
4948 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4949 ok(size == sizeof(BCRYPT_DH_KEY_BLOB) + length / 8 * 3, "Got unexpected size %lu.\n", size);
4950 dh_key_blob = (BCRYPT_DH_KEY_BLOB *)buffer;
4951 ok(dh_key_blob->dwMagic == BCRYPT_DH_PUBLIC_MAGIC, "Got unexpected magic %#lx.\n", dh_key_blob->dwMagic);
4952 ok(dh_key_blob->cbKey == length / 8, "Got unexpected length %lu.\n", dh_key_blob->cbKey);
4953 ok(!memcmp(dh_key_blob + 1, dh_private_key, length / 8 * 3), "Key data does not match.\n");
4954
4955 status = BCryptGenerateKeyPair(alg, &key2, length, 0);
4956 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4957 dh_header = (BCRYPT_DH_PARAMETER_HEADER *)buffer;
4958 dh_header->dwMagic = BCRYPT_DH_PARAMETERS_MAGIC;
4959 dh_header->cbLength = sizeof(*dh_header) + length / 8 * 2;
4960 dh_header->cbKeyLength = length / 8;
4961 memcpy(dh_header + 1, dh_private_key, length / 8 * 2);
4962 status = BCryptSetProperty(key2, BCRYPT_DH_PARAMETERS, buffer, dh_header->cbLength, 0);
4963 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4964 status = BCryptFinalizeKeyPair(key2, 0);
4965 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4966
4967 status = BCryptExportKey(key2, NULL, BCRYPT_DH_PUBLIC_BLOB, buffer, sizeof(buffer), &size, 0);
4968 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4969 ok(size == sizeof(BCRYPT_DH_KEY_BLOB) + length / 8 * 3, "Got unexpected size %lu.\n", size);
4970 ok(dh_key_blob->dwMagic == BCRYPT_DH_PUBLIC_MAGIC, "Got unexpected dwMagic %#lx.\n", dh_key_blob->dwMagic);
4971 ok(dh_key_blob->cbKey == length / 8, "Got unexpected length %lu.\n", dh_key_blob->cbKey);
4972 ok(!memcmp(dh_key_blob + 1, dh_private_key, length / 8 * 2), "DH parameters do not match.\n");
4973 ok(memcmp((BYTE *)(dh_key_blob + 1) + length / 8 * 2, (BYTE *)dh_private_key + length / 8 * 2, length / 8),
4974 "Random public key data matches.\n");
4975
4976 memset(buffer, 0xcc, sizeof(buffer));
4977 status = BCryptExportKey(key, NULL, BCRYPT_DH_PRIVATE_BLOB, buffer, sizeof(buffer), &size, 0);
4978 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4979 dh_key_blob = (BCRYPT_DH_KEY_BLOB *)buffer;
4980 ok(size == sizeof(BCRYPT_DH_KEY_BLOB) + length / 8 * 4, "Got unexpected size %lu.\n", size);
4981 ok(dh_key_blob->dwMagic == BCRYPT_DH_PRIVATE_MAGIC, "Got unexpected dwMagic %#lx.\n", dh_key_blob->dwMagic);
4982 ok(dh_key_blob->cbKey == length / 8, "Got unexpected length %lu.\n", dh_key_blob->cbKey);
4983 ok(!memcmp(dh_key_blob + 1, dh_private_key, length / 8 * 4), "Private key data does not match.\n");
4984
4985 status = BCryptSecretAgreement(NULL, key, &secret, 0);
4986 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
4987
4988 status = BCryptSecretAgreement(key, NULL, &secret, 0);
4989 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
4990
4991 status = BCryptSecretAgreement(key, key, NULL, 0);
4992 ok(status == STATUS_INVALID_PARAMETER, "got %08lx\n", status);
4993
4994 status = BCryptSecretAgreement(key, key, &secret, 0);
4995 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
4996
4997 status = BCryptDeriveKey(NULL, L"HASH", NULL, NULL, 0, &size, 0);
4998 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
4999
5000 status = BCryptDeriveKey(key, L"HASH", NULL, NULL, 0, &size, 0);
5001 ok(status == STATUS_INVALID_HANDLE, "got %08lx\n", status);
5002
5003 status = BCryptDeriveKey(secret, NULL, NULL, NULL, 0, &size, 0);
5004 ok(status == STATUS_INVALID_PARAMETER, "got %08lx\n", status);
5005
5006 size = 0xdeadbeef;
5007 status = BCryptDeriveKey(secret, L"HASH", NULL, NULL, 0, &size, 0);
5008 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5009 ok(size == 20, "Got unexpected size %lu.\n", size);
5010
5011 size = 0xdeadbeef;
5012 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, NULL, 0, &size, 0);
5013 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5014 ok(size == length / 8, "Got unexpected size %lu.\n", size);
5015
5016 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, buffer, 128, &size, 0);
5017 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5018 ok(size == length / 8, "Got unexpected size %lu.\n", size);
5019 ok(!memcmp(buffer, dh_shared_secret_raw, size), "Raw shared secret data does not match.\n");
5020
5021 size = sizeof(buffer);
5022 memset(buffer, 0xcc, sizeof(buffer));
5023 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, NULL, buffer, 128, &size, 0);
5024 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5025 ok(size == 20, "Got unexpected size %lu.\n", size);
5026 ok(!memcmp(buffer, dh_shared_secret_sha1, sizeof(dh_shared_secret_sha1)),
5027 "sha1 shared secret data does not match.\n");
5028
5029 size = sizeof(buffer);
5030 status = BCryptDeriveKey(secret, BCRYPT_KDF_HASH, &hash_params, buffer, size, &size, 0);
5031 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5032 ok(size == 32, "Got unexpected size %lu.\n", size);
5033 ok(!memcmp(buffer, dh_shared_secret_sha256, sizeof(dh_shared_secret_sha256)),
5034 "sha256 shared secret data does not match.\n");
5035
5036 for (i = size; i < sizeof(buffer); ++i)
5037 if (buffer[i] != 0xcc) break;
5038 ok(i == sizeof(buffer), "Buffer modified at %lu, value %#x.\n", i, buffer[i]);
5039
5040 status = BCryptDestroySecret(secret);
5041 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5042
5043 status = BCryptSecretAgreement(key, key2, &secret, 0);
5044 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5045 status = BCryptSecretAgreement(key2, key, &secret2, 0);
5046 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5047
5048 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, buffer, 128, &size, 0);
5049 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5050 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, buffer + size, 128, &size, 0);
5051 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5052 ok(!memcmp(buffer, buffer + size, size), "Shared secrets do not match.\n");
5053
5054 status = BCryptDestroySecret(secret);
5055 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5056 status = BCryptDestroySecret(secret2);
5057 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5058
5059 status = BCryptDestroyKey(key);
5060 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5061 status = BCryptDestroyKey(key2);
5062 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5063
5064 dh_key_blob = (BCRYPT_DH_KEY_BLOB *)buffer;
5065 dh_key_blob->dwMagic = BCRYPT_DH_PRIVATE_MAGIC;
5066 dh_key_blob->cbKey = length / 8;
5067 memcpy(dh_key_blob + 1, dh_private_key2, sizeof(dh_private_key2));
5068
5069 size = sizeof(*dh_key_blob) + length / 8 * 4;
5070 status = BCryptImportKeyPair(alg, NULL, BCRYPT_DH_PRIVATE_BLOB, &key, buffer, size, 0);
5071 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5072
5073 dh_key_blob = (BCRYPT_DH_KEY_BLOB *)buffer;
5074 dh_key_blob->dwMagic = BCRYPT_DH_PUBLIC_MAGIC;
5075 dh_key_blob->cbKey = length / 8;
5076 memcpy(dh_key_blob + 1, dh_peer_key, sizeof(dh_peer_key));
5077
5078 size = sizeof(*dh_key_blob) + length / 8 * 3;
5079 status = BCryptImportKeyPair(alg, NULL, BCRYPT_DH_PUBLIC_BLOB, &key2, buffer, size, 0);
5080 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5081
5082 status = BCryptSecretAgreement(key, key2, &secret, 0);
5083 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5084
5085 status = BCryptDeriveKey(secret, BCRYPT_KDF_RAW_SECRET, NULL, buffer, 128, &size, 0);
5086 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5087 ok(size == length / 8, "Got unexpected size %lu.\n", size);
5088 ok(!memcmp(buffer, dh_shared_secret_raw2, size), "Raw shared secret data does not match.\n");
5089
5090 status = BCryptDestroySecret(secret);
5091 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5092 status = BCryptDestroyKey(key);
5093 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5094 status = BCryptDestroyKey(key2);
5095 ok(status == STATUS_SUCCESS, "got %08lx\n", status);
5096
5097 status = BCryptCloseAlgorithmProvider(alg, 0);
5098 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5099}
BCRYPT_DH_PARAMETERS
#define BCRYPT_DH_PARAMETERS
Definition: bcrypt.h:153
BCRYPT_DH_PARAMETERS_MAGIC
#define BCRYPT_DH_PARAMETERS_MAGIC
Definition: bcrypt.h:327
BCRYPT_DH_ALGORITHM
#define BCRYPT_DH_ALGORITHM
Definition: bcrypt.h:100
length
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
secret2
static char secret2[]
Definition: protectdata.c:31
_BCRYPT_DH_PARAMETER_HEADER
Definition: bcrypt.h:330
_BCRYPT_DH_PARAMETER_HEADER::dwMagic
ULONG dwMagic
Definition: bcrypt.h:332
_BCRYPT_DH_PARAMETER_HEADER::cbKeyLength
ULONG cbKeyLength
Definition: bcrypt.h:333
_BCRYPT_DH_PARAMETER_HEADER::cbLength
ULONG cbLength
Definition: bcrypt.h:331

Referenced by START_TEST().

◆ test_TLS_PRF()

static void test_TLS_PRF ( void  )
static

Definition at line 5235 of file bcrypt.c.

5236{
5237 static const UCHAR expect[32] =
5238 {
5239 0x28,0xd2,0xfd,0xb7,0x19,0x56,0x47,0x9d,0x88,0xd1,0x13,0x50,0x01,0x08,0x40,0x8e,
5240 0xfa,0xb3,0x92,0x80,0xe4,0xe2,0x6a,0x2a,0xd0,0xe6,0xac,0x39,0x80,0x18,0xeb,0x30
5241 };
5242 static const UCHAR expect2[32] =
5243 {
5244 0x33,0x63,0x83,0x14,0x8c,0x50,0x48,0x99,0x63,0x7b,0xc0,0x33,0x81,0xb1,0x0e,0x4f,
5245 0x5c,0x27,0xe3,0xe8,0x23,0xa8,0xb3,0xe8,0x52,0x96,0x47,0xa5,0xf8,0xca,0x17,0x24
5246 };
5247 static UCHAR label[32] = "label", seed[32] = "seed", buf[32];
5248 static BCryptBuffer param_buffers[] =
5249 {
5250 {
5251 sizeof(BCRYPT_SHA256_ALGORITHM),
5252 KDF_HASH_ALGORITHM,
5253 (void *)BCRYPT_SHA256_ALGORITHM,
5254 },
5255 {
5256 sizeof(label),
5257 KDF_TLS_PRF_LABEL,
5258 label,
5259 },
5260 {
5261 sizeof(seed),
5262 KDF_TLS_PRF_SEED,
5263 seed,
5264 }
5265 };
5266 static BCryptBufferDesc params =
5267 {
5268 BCRYPTBUFFER_VERSION,
5269 ARRAY_SIZE(param_buffers),
5270 param_buffers,
5271 };
5272 NTSTATUS status;
5273 BCRYPT_ALG_HANDLE alg;
5274 BCRYPT_KEY_HANDLE key, key2;
5275 BCRYPT_KEY_LENGTHS_STRUCT key_lengths;
5276 ULONG len, size;
5277
5278 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_TLS1_1_KDF_ALGORITHM, NULL, 0);
5279 if (status == STATUS_NOT_FOUND) /* win8 */
5280 {
5281 win_skip("BCRYPT_TLS1_1_KDF_ALGORITHM not available\n");
5282 return;
5283 }
5284 ok(!status, "got %#lx\n", status);
5285
5286 len = size = 0;
5287 status = BCryptGetProperty(alg, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5288 ok(!status, "got %#lx\n", status);
5289 ok(len, "got %lu\n", len);
5290 ok(size == sizeof(len), "got %lu\n", size);
5291
5292 len = size = 0;
5293 status = BCryptGetProperty(alg, BCRYPT_BLOCK_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5294 ok(status == STATUS_NOT_SUPPORTED, "got %#lx\n", status);
5295
5296 memset(&key_lengths, 0xfe, sizeof(key_lengths));
5297 size = 0;
5298 status = BCryptGetProperty(alg, BCRYPT_KEY_LENGTHS, (UCHAR *)&key_lengths, sizeof(key_lengths), &size, 0);
5299 ok(!status, "got %#lx\n", status);
5300 ok(size == sizeof(key_lengths), "got %lu\n", size);
5301 ok(key_lengths.dwMinLength == 0, "got %lu\n", key_lengths.dwMinLength);
5302 ok(key_lengths.dwMaxLength == 16384, "got %lu\n", key_lengths.dwMaxLength);
5303 ok(key_lengths.dwIncrement == 8, "got %lu\n", key_lengths.dwIncrement);
5304
5305 status = BCryptGenerateSymmetricKey(alg, &key, NULL, 0, (UCHAR *)"test", 4, 0);
5306 ok(!status, "got %#lx\n", status);
5307
5308 len = size = 0;
5309 status = BCryptGetProperty(key, BCRYPT_KEY_STRENGTH, (UCHAR *)&len, sizeof(len), &size, 0);
5310 ok(!status, "got %#lx\n", status);
5311 ok(len == strlen("test") * 8, "got %lu\n", len);
5312
5313 status = BCryptKeyDerivation(key, &params, NULL, 0, &size, 0);
5314 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
5315
5316 buf[0] = buf[1] = 'x';
5317 status = BCryptKeyDerivation(key, &params, buf, 1, &size, 0);
5318 ok(!status, "got %#lx\n", status);
5319 ok(size == 1, "size = %lu\n", size);
5320 ok(buf[0] == expect[0], "buf[0] = %x\n", buf[0]);
5321 ok(buf[1] == 'x', "buf[1] = %x\n", buf[1]);
5322
5323 memset(buf, 'x', sizeof(buf));
5324 status = BCryptKeyDerivation(key, &params, buf, sizeof(buf), &size, 0);
5325 ok(!status, "got %#lx\n", status);
5326 ok(size == sizeof(buf), "size = %lu\n", size);
5327 ok(!memcmp(buf, expect, sizeof(expect)), "wrong data (%s)\n", wine_dbgstr_an((char *)buf, size));
5328
5329 status = BCryptDestroyKey(key);
5330 ok(!status, "got %#lx\n", status);
5331
5332 status = BCryptCloseAlgorithmProvider(alg, 0);
5333 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5334
5335 status = BCryptOpenAlgorithmProvider(&alg, BCRYPT_TLS1_2_KDF_ALGORITHM, NULL, 0);
5336 ok(!status, "got %#lx\n", status);
5337
5338 status = BCryptGenerateSymmetricKey(alg, &key, NULL, 0, (UCHAR *)"test", 4, 0);
5339 ok(!status, "got %#lx\n", status);
5340
5341 status = BCryptKeyDerivation(key, &params, NULL, 0, &size, 0);
5342 ok(status == STATUS_INVALID_PARAMETER, "got %#lx\n", status);
5343
5344 buf[0] = buf[1] = 'x';
5345 status = BCryptKeyDerivation(key, &params, buf, 1, &size, 0);
5346 ok(!status, "got %#lx\n", status);
5347 ok(size == 1, "size = %lu\n", size);
5348 ok(buf[0] == expect2[0], "buf[0] = %x\n", buf[0]);
5349 ok(buf[1] == 'x', "buf[1] = %x\n", buf[1]);
5350
5351 memset(buf, 'x', sizeof(buf));
5352 status = BCryptKeyDerivation(key, &params, buf, sizeof(buf), &size, 0);
5353 ok(!status, "got %#lx\n", status);
5354 ok(size == sizeof(buf), "size = %lu\n", size);
5355 ok(!memcmp(buf, expect2, sizeof(expect2)), "wrong data\n");
5356
5357 /* label is optional */
5358 param_buffers[1].cbBuffer = 0;
5359 param_buffers[1].pvBuffer = NULL;
5360 status = BCryptKeyDerivation(key, &params, buf, sizeof(buf), &size, 0);
5361 ok(!status, "got %#lx\n", status);
5362
5363 status = BCryptDuplicateKey(key, &key2, NULL, 0, 0);
5364 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5365
5366 status = BCryptDestroyKey(key);
5367 ok(!status, "got %#lx\n", status);
5368 status = BCryptDestroyKey(key2);
5369 ok(!status, "got %#lx\n", status);
5370 status = BCryptCloseAlgorithmProvider(alg, 0);
5371 ok(status == STATUS_SUCCESS, "got %#lx\n", status);
5372}
KDF_TLS_PRF_SEED
#define KDF_TLS_PRF_SEED
Definition: bcrypt.h:376
BCRYPT_TLS1_2_KDF_ALGORITHM
#define BCRYPT_TLS1_2_KDF_ALGORITHM
Definition: bcrypt.h:124
KDF_TLS_PRF_LABEL
#define KDF_TLS_PRF_LABEL
Definition: bcrypt.h:375
BCRYPT_TLS1_1_KDF_ALGORITHM
#define BCRYPT_TLS1_1_KDF_ALGORITHM
Definition: bcrypt.h:123
label
static const WCHAR label[]
Definition: itemdlg.c:1608

Referenced by START_TEST().

Variable Documentation

◆ cert521Signature

BYTE cert521Signature[]
static
Initial value:
=
{
0x01, 0x6b, 0xd6, 0xca, 0xac, 0x28, 0xa8, 0xa9, 0x83, 0x9d, 0xca, 0x13, 0x08, 0xd6, 0xf2, 0x9c,
0x94, 0x6b, 0x28, 0x6b, 0x93, 0x58, 0x3c, 0x65, 0x54, 0xb4, 0xa6, 0xb8, 0x0d, 0x55, 0xed, 0x4e,
0xc9, 0x98, 0x26, 0x96, 0x1a, 0xbb, 0x9f, 0x9e, 0x5c, 0xb1, 0x1e, 0x8b, 0x04, 0x82, 0xe6, 0x32,
0x15, 0x92, 0xcb, 0xfe, 0xe7, 0x53, 0xfc, 0x17, 0xe0, 0xc9, 0x44, 0xf5, 0x1d, 0x37, 0x33, 0x02,
0xbb, 0x75, 0x01, 0x65, 0x84, 0xab, 0x89, 0xb3, 0x69, 0x56, 0xf4, 0x18, 0xb0, 0xdd, 0xfd, 0x69,
0xe6, 0x52, 0x1e, 0x75, 0x4f, 0x98, 0xa8, 0x49, 0x88, 0x84, 0x15, 0x58, 0x23, 0x9f, 0x89, 0x06,
0x73, 0x6b, 0x8c, 0xf9, 0x9a, 0x85, 0x1d, 0xd2, 0xf4, 0x06, 0x65, 0xa5, 0x88, 0x12, 0xa3, 0x4e,
0xcd, 0x99, 0x06, 0x1b, 0xf8, 0x17, 0xe0, 0xeb, 0xb8, 0x7f, 0x6b, 0x89, 0x47, 0xd2, 0x5d, 0x30,
0xf4, 0xf6, 0x5f, 0x83,
}

Definition at line 2290 of file bcrypt.c.

Referenced by test_ECDSA().

◆ certHash

BYTE certHash[]
static
Initial value:
=
{
0x28, 0x19, 0x0f, 0x15, 0x6d, 0x75, 0xcc, 0xcf, 0x62, 0xf1, 0x5e, 0xe6, 0x8a, 0xc3, 0xf0, 0x5d,
0x89, 0x28, 0x2d, 0x48, 0xd8, 0x73, 0x7c, 0x05, 0x05, 0x8e, 0xbc, 0xce, 0x28, 0xb7, 0xba, 0xc9,
}

Definition at line 2276 of file bcrypt.c.

Referenced by test_ECDSA().

◆ certSignature

BYTE certSignature[]
static
Initial value:
=
{
0xd7, 0x29, 0xce, 0x5a, 0xef, 0x74, 0x85, 0xd1, 0x18, 0x5f, 0x6e, 0xf1, 0xba, 0x53, 0xd4, 0xcd,
0xdd, 0xe0, 0x5d, 0xf1, 0x5e, 0x48, 0x51, 0xea, 0x63, 0xc0, 0xe8, 0xe2, 0xf6, 0xfa, 0x4c, 0xaf,
0xe3, 0x94, 0x15, 0x3b, 0x6c, 0x71, 0x6e, 0x44, 0x22, 0xcb, 0xa0, 0x88, 0xcd, 0x0a, 0x5a, 0x50,
0x29, 0x7c, 0x5c, 0xd6, 0x6c, 0xd2, 0xe0, 0x7f, 0xcd, 0x02, 0x92, 0x21, 0x4c, 0x2c, 0x92, 0xee,
}

Definition at line 2281 of file bcrypt.c.

Referenced by test_ECDSA().

◆ coefficient

BYTE coefficient[512/16]

Definition at line 2642 of file bcrypt.c.

Referenced by CRYPT_AsnDecodeRsaPrivKey(), export_private_key_impl(), export_rsa_key(), SymCryptMlDsaPolyElementDecode(), SymCryptMlDsaPolyElementEncode(), SymCryptMlDsaSignedCoefficientModQ(), SymCryptMlKemPolyElementCompressAndEncode(), SymCryptMlKemPolyElementDecodeAndDecompress(), SymCryptMlKemPolyElementSampleCBDFromBytes(), and test_decodeRsaPrivateKey().

◆ dh_hash_param_buffers

BCryptBuffer dh_hash_param_buffers[]
Initial value:
=
{
{
sizeof(BCRYPT_SHA1_ALGORITHM),
KDF_HASH_ALGORITHM,
(void *)BCRYPT_SHA1_ALGORITHM,
}
}

Definition at line 3874 of file bcrypt.c.

◆ dh_hash_param_buffers_prepended

BCryptBuffer dh_hash_param_buffers_prepended[]
Initial value:
=
{
{
sizeof(BCRYPT_SHA1_ALGORITHM),
KDF_HASH_ALGORITHM,
(void *)BCRYPT_SHA1_ALGORITHM,
},
{
sizeof(hash_prepend[0]),
KDF_SECRET_PREPEND,
(void *)hash_prepend[0],
},
{
sizeof(hash_prepend[1]),
KDF_SECRET_PREPEND,
(void *)hash_prepend[1],
}
}

Definition at line 3882 of file bcrypt.c.

◆ dh_hash_params

BCryptBufferDesc dh_hash_params
Initial value:
=
{
BCRYPTBUFFER_VERSION,
ARRAY_SIZE(dh_hash_param_buffers),
dh_hash_param_buffers,
}
dh_hash_param_buffers
BCryptBuffer dh_hash_param_buffers[]
Definition: bcrypt.c:3874

Definition at line 3901 of file bcrypt.c.

Referenced by test_DH().

◆ dh_hash_params_prepended

BCryptBufferDesc dh_hash_params_prepended
Initial value:
=
{
BCRYPTBUFFER_VERSION,
ARRAY_SIZE(dh_hash_param_buffers_prepended),
dh_hash_param_buffers_prepended,
}
dh_hash_param_buffers_prepended
BCryptBuffer dh_hash_param_buffers_prepended[]
Definition: bcrypt.c:3882

Definition at line 3907 of file bcrypt.c.

Referenced by test_DH().

◆ dh_hashed_secret

BYTE dh_hashed_secret[]
static
Initial value:
=
{
0xa7, 0xfc, 0xff, 0x21, 0xb3, 0xd1, 0x46, 0xb8, 0x21, 0x3d, 0xc6, 0xd4, 0xe3, 0x61, 0x97, 0x5e,
0xb5, 0x0a, 0xfe, 0x8f,
}

Definition at line 3862 of file bcrypt.c.

Referenced by test_DH().

◆ dh_hashed_secret_prepended

BYTE dh_hashed_secret_prepended[]
static
Initial value:
=
{
0x03, 0x9d, 0x31, 0x52, 0x32, 0xca, 0xfc, 0x12, 0x23, 0x2e, 0x63, 0x0b, 0x7a, 0x1c, 0xaf, 0xee,
0x17, 0xf0, 0x7b, 0xc6,
}

Definition at line 3868 of file bcrypt.c.

Referenced by test_DH().

◆ dh_privkey

BYTE dh_privkey[]
static
Initial value:
=
{
0x44, 0x48, 0x50, 0x56, 0x40, 0x00, 0x00, 0x00,
0xcf, 0x18, 0xe9, 0xa9, 0xb3, 0x97, 0x59, 0xae, 0x0d, 0xac, 0xf0, 0x99, 0x39, 0xdc, 0xd2, 0xfe,
0x1e, 0xf3, 0xfc, 0x2c, 0x49, 0xdf, 0x76, 0x89, 0xff, 0x13, 0x57, 0xc7, 0xe6, 0xbd, 0xed, 0xa7,
0x42, 0xc0, 0xc3, 0xd7, 0x8e, 0x84, 0xa8, 0xdf, 0xcd, 0x52, 0x50, 0x81, 0x73, 0x8a, 0x33, 0x60,
0xde, 0x6d, 0x56, 0xeb, 0xd5, 0xec, 0x1f, 0x9f, 0x9f, 0xd6, 0x2c, 0xe4, 0x8f, 0xab, 0x58, 0x0b,
0x5f, 0xc5, 0x50, 0x9a, 0xde, 0xf6, 0x84, 0x48, 0x39, 0xa9, 0xa7, 0xb1, 0x73, 0x0c, 0x56, 0xd4,
0x28, 0xbb, 0x12, 0x93, 0x51, 0x44, 0x33, 0xdf, 0xa6, 0xe7, 0x7f, 0x0b, 0x3f, 0xe9, 0x41, 0xef,
0x32, 0x80, 0xcd, 0x8e, 0x2b, 0x38, 0x85, 0x49, 0x4d, 0x0c, 0xcc, 0x74, 0x02, 0x07, 0x92, 0xd3,
0xe4, 0x3e, 0x37, 0x84, 0x27, 0x1f, 0xa3, 0xad, 0x94, 0x8c, 0xc1, 0xc2, 0x22, 0x99, 0x36, 0xf0,
0x22, 0xaf, 0x98, 0xeb, 0xd9, 0xc4, 0xb5, 0xbd, 0xe1, 0xab, 0x19, 0x1b, 0xe3, 0x36, 0x20, 0xca,
0xff, 0xe8, 0x6c, 0x30, 0x96, 0x3c, 0x90, 0x77, 0x0e, 0xe0, 0x96, 0xae, 0xb1, 0x47, 0xd1, 0x52,
0x2c, 0xc3, 0x65, 0x5e, 0x9b, 0x41, 0x9a, 0xa6, 0xfe, 0xab, 0x54, 0xa0, 0xf0, 0x71, 0xab, 0x6c,
0xd0, 0x0e, 0x01, 0x08, 0x5b, 0x66, 0xe5, 0x62, 0xd2, 0xe5, 0x5d, 0xae, 0x9c, 0x60, 0xb2, 0xc6,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0x71, 0x3e, 0x82,
0x8b, 0xea, 0x11, 0x77, 0xc4, 0xb4, 0x62, 0xc7, 0x4d, 0xff, 0x0f, 0x63, 0xd9, 0xe2, 0xda, 0xab,
}

Definition at line 3828 of file bcrypt.c.

Referenced by test_DH().

◆ dh_pubkey

BYTE dh_pubkey[]
static
Initial value:
=
{
0x44, 0x48, 0x50, 0x42, 0x40, 0x00, 0x00, 0x00,
0xcf, 0x18, 0xe9, 0xa9, 0xb3, 0x97, 0x59, 0xae, 0x0d, 0xac, 0xf0, 0x99, 0x39, 0xdc, 0xd2, 0xfe,
0x1e, 0xf3, 0xfc, 0x2c, 0x49, 0xdf, 0x76, 0x89, 0xff, 0x13, 0x57, 0xc7, 0xe6, 0xbd, 0xed, 0xa7,
0x42, 0xc0, 0xc3, 0xd7, 0x8e, 0x84, 0xa8, 0xdf, 0xcd, 0x52, 0x50, 0x81, 0x73, 0x8a, 0x33, 0x60,
0xde, 0x6d, 0x56, 0xeb, 0xd5, 0xec, 0x1f, 0x9f, 0x9f, 0xd6, 0x2c, 0xe4, 0x8f, 0xab, 0x58, 0x0b,
0x5f, 0xc5, 0x50, 0x9a, 0xde, 0xf6, 0x84, 0x48, 0x39, 0xa9, 0xa7, 0xb1, 0x73, 0x0c, 0x56, 0xd4,
0x28, 0xbb, 0x12, 0x93, 0x51, 0x44, 0x33, 0xdf, 0xa6, 0xe7, 0x7f, 0x0b, 0x3f, 0xe9, 0x41, 0xef,
0x32, 0x80, 0xcd, 0x8e, 0x2b, 0x38, 0x85, 0x49, 0x4d, 0x0c, 0xcc, 0x74, 0x02, 0x07, 0x92, 0xd3,
0xe4, 0x3e, 0x37, 0x84, 0x27, 0x1f, 0xa3, 0xad, 0x94, 0x8c, 0xc1, 0xc2, 0x22, 0x99, 0x36, 0xf0,
0x22, 0xaf, 0x98, 0xeb, 0xd9, 0xc4, 0xb5, 0xbd, 0xe1, 0xab, 0x19, 0x1b, 0xe3, 0x36, 0x20, 0xca,
0xff, 0xe8, 0x6c, 0x30, 0x96, 0x3c, 0x90, 0x77, 0x0e, 0xe0, 0x96, 0xae, 0xb1, 0x47, 0xd1, 0x52,
0x2c, 0xc3, 0x65, 0x5e, 0x9b, 0x41, 0x9a, 0xa6, 0xfe, 0xab, 0x54, 0xa0, 0xf0, 0x71, 0xab, 0x6c,
0xd0, 0x0e, 0x01, 0x08, 0x5b, 0x66, 0xe5, 0x62, 0xd2, 0xe5, 0x5d, 0xae, 0x9c, 0x60, 0xb2, 0xc6,
}

Definition at line 3807 of file bcrypt.c.

Referenced by test_DH().

◆ dh_secret

BYTE dh_secret[]
static
Initial value:
=
{
0x73, 0x84, 0x62, 0xc1, 0x9a, 0x9c, 0xc2, 0x91, 0x9f, 0xc1, 0xc2, 0x94, 0x0c, 0xa8, 0x2f, 0x58,
0xac, 0x50, 0xcd, 0xd5, 0x29, 0x43, 0x41, 0x8e, 0x5d, 0xca, 0x73, 0x55, 0x4d, 0x46, 0x50, 0xe5,
0xb7, 0x34, 0xa9, 0xcb, 0x3a, 0x18, 0x68, 0x99, 0x30, 0xef, 0x58, 0x26, 0xd3, 0x03, 0x61, 0x02,
0x17, 0xb7, 0xba, 0x01, 0xbc, 0xae, 0xdf, 0x3f, 0xb5, 0xb5, 0x4a, 0xb0, 0x08, 0xe5, 0xea, 0xc3,
}

Definition at line 3854 of file bcrypt.c.

Referenced by test_DH().

◆ dk

const UCHAR* dk

Definition at line 517 of file bcrypt.c.

Referenced by test_BcryptDeriveKeyPBKDF2().

◆ dk1

UCHAR dk1[] = "0c60c80f961f0e71f3a9b524af6012062fe037a6"
static

Definition at line 501 of file bcrypt.c.

◆ dk2

UCHAR dk2[] = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"
static

Definition at line 502 of file bcrypt.c.

◆ dk3

UCHAR dk3[] = "4b007901b765489abead49d926f721d065a429c1"
static

Definition at line 503 of file bcrypt.c.

◆ dk4

UCHAR dk4[] = "364dd6bc200ec7d197f1b85f4a61769010717124"
static

Definition at line 504 of file bcrypt.c.

◆ dk5

UCHAR dk5[] = "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"
static

Definition at line 505 of file bcrypt.c.

◆ dk6

UCHAR dk6[] = "56fa6aa75548099dcc37d7f03425e0c3"
static

Definition at line 506 of file bcrypt.c.

◆ dk7

UCHAR dk7[] = "8754c32c64b0f524fc50c00f788135de"
static

Definition at line 507 of file bcrypt.c.

◆ dk_len

ULONG dk_len

Definition at line 514 of file bcrypt.c.

Referenced by test_BcryptDeriveKeyPBKDF2().

◆ dsaHash

UCHAR dsaHash[]
static
Initial value:
=
{
0x7e,0xe3,0x74,0xe7,0xc5,0x0b,0x6b,0x70,0xdb,0xab,0x32,0x6d,0x1d,0x51,0xd6,0x74,0x79,0x8e,0x5b,0x4b
}

Definition at line 4518 of file bcrypt.c.

Referenced by test_DSA().

◆ dsaPublicBlob

UCHAR dsaPublicBlob[]
static
Initial value:
=
{
0x44,0x53,0x50,0x42,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x8f,0xd2,0x92,0xbb,0x92,0xb9,0x00,0xc5,0xed,
0x52,0xcc,0x48,0x4a,0x44,0x1d,0xd3,0x74,0xfb,0x75,0xd1,0x7e,0xb6,0x24,0x9b,0x5d,0x57,0x0a,0x8a,0xc4,
0x5d,0xab,0x9c,0x26,0x86,0xc6,0x25,0x16,0x20,0xf9,0xa9,0x71,0xbc,0x1d,0x30,0xc4,0xef,0x8c,0xc4,0xdf,
0x1a,0xaf,0x96,0xdf,0x90,0xd8,0x85,0x9d,0xf9,0x2c,0x86,0x8c,0x91,0x39,0x6c,0x6d,0x11,0x4e,0x53,0x63,
0x2a,0x2b,0x26,0xa7,0xf9,0x76,0x74,0x51,0xbf,0x08,0x87,0x6f,0xe0,0x71,0x91,0x24,0x8a,0xc2,0x84,0x2d,
0x84,0x9c,0x5f,0x94,0xaa,0x38,0x53,0x77,0x84,0xba,0xbc,0xff,0x49,0x3a,0x08,0x0f,0x38,0xb5,0x91,0x5c,
0x06,0x15,0xa4,0x27,0xf4,0xa5,0x59,0xaa,0x1c,0x41,0xa3,0xa0,0xbb,0xf7,0x32,0x86,0xfb,0x94,0x41,0xff,
0xcd,0xed,0x69,0xeb,0xc6,0x5e,0xb6,0xa8,0x15,0x82,0x3b,0x60,0x1e,0x91,0x55,0xd5,0x2c,0xa5,0x74,0x5a,
0x65,0x8f,0xc6,0x56,0xc4,0x3f,0x4e,0xe3,0x3a,0x71,0xb2,0x63,0x66,0xa4,0x0d,0x0d,0xf9,0xdd,0x1e,0x48,
0x81,0xe9,0xbf,0x8f,0xbb,0x85,0x47,0x81,0x68,0x11,0xb5,0x91,0x6b,0xc4,0x05,0xef,0xa3,0xc7,0xbf,0x26,
0x53,0x4f,0xc4,0x10,0xfd,0xfa,0xed,0x61,0x64,0xd6,0x2e,0xad,0x04,0x3e,0x82,0xed,0xb2,0x22,0x76,0xd0,
0x44,0xad,0xc1,0x4c,0xde,0x33,0xa3,0x61,0x55,0xec,0x24,0xe5,0x79,0x45,0xcf,0x94,0x39,0x92,0x9f,0xd8,
0x24,0xce,0x85,0xb9
}

Definition at line 4529 of file bcrypt.c.

Referenced by test_DSA().

◆ dsaSignature

UCHAR dsaSignature[]
static
Initial value:
=
{
0x5f,0x95,0x1f,0x08,0x19,0x44,0xa5,0xab,0x28,0x11,0x51,0x68,0x82,0x9b,0xe4,0xc3,0x04,0x1b,0xc9,0xdc,
0x41,0x2a,0x89,0xd4,0x4a,0x8b,0x86,0xaf,0x98,0x2c,0x59,0x0b,0xd2,0x88,0xf6,0xe8,0x29,0x13,0x84,0x49
}

Definition at line 4523 of file bcrypt.c.

Referenced by test_DSA().

◆ dssKey

UCHAR dssKey[]
static
Initial value:
=
{
0x07,0x02,0x00,0x00,0x00,0x22,0x00,0x00,0x44,0x53,0x53,0x32,0x00,0x04,0x00,0x00,0x01,0xd1,0xfc,0x7a,
0x70,0x53,0xb2,0x48,0x70,0x23,0x19,0x1f,0x3c,0xe1,0x26,0x14,0x7e,0x9f,0x0f,0x7f,0x33,0x5e,0x2b,0xf7,
0xca,0x01,0x74,0x8c,0xb4,0xfd,0xf6,0x44,0x95,0x35,0x56,0xaa,0x4d,0x62,0x48,0xe2,0xd1,0xa2,0x7e,0x6e,
0xeb,0xd6,0xcc,0x7c,0xe8,0xfd,0x21,0x9a,0xa2,0xfd,0x7a,0x9d,0x1a,0x38,0x69,0x87,0x39,0x5a,0x91,0xc0,
0x52,0x2b,0x9f,0x2a,0x54,0x78,0x37,0x82,0x9a,0x70,0x57,0xab,0xec,0x93,0x8e,0xac,0x73,0x04,0xe8,0x53,
0x72,0x72,0x32,0xc6,0xcb,0xef,0x47,0x98,0x3c,0x56,0x49,0x62,0xcb,0xbb,0xe7,0x34,0x84,0xa6,0x72,0x3a,
0xbe,0x26,0x46,0x86,0xca,0xcb,0x35,0x62,0x4f,0x19,0x18,0x0b,0xb0,0x78,0xae,0xd5,0x42,0xdf,0x26,0xdb,
0x85,0x63,0x77,0x85,0x01,0x3b,0x32,0xbe,0x5c,0xf8,0x05,0xc8,0xde,0x17,0x7f,0xb9,0x03,0x82,0xfa,0xf1,
0x9e,0x32,0x73,0xfa,0x8d,0xea,0xa3,0x30,0x48,0xe2,0xdf,0x5a,0xcb,0x83,0x3d,0xff,0x56,0xe9,0xc0,0x94,
0xf8,0x6d,0xb3,0xaf,0x4a,0x97,0xb9,0x43,0x0e,0xd4,0x28,0x98,0x57,0x2e,0x3a,0xca,0xde,0x6f,0x45,0x0d,
0xfb,0x58,0xec,0x78,0x34,0x2e,0x46,0x4d,0xfe,0x98,0x02,0xbb,0xef,0x07,0x1a,0x13,0xb6,0xc2,0x2c,0x06,
0xd9,0x0c,0xc4,0xb0,0x4c,0x3a,0xfc,0x01,0x63,0xb5,0x5a,0x5d,0x2d,0x9c,0x47,0x04,0x67,0x51,0xf2,0x52,
0xf5,0x82,0x36,0xeb,0x6e,0x66,0x58,0x4c,0x10,0x2c,0x29,0x72,0x4a,0x6f,0x6b,0x6c,0xe0,0x93,0x31,0x42,
0xf6,0xda,0xfa,0x5b,0x22,0x43,0x9b,0x1a,0x98,0x71,0xe7,0x41,0x74,0xe9,0x12,0xa4,0x1f,0x27,0x0a,0x63,
0x94,0x49,0xd7,0xad,0xa5,0xc4,0x5c,0xc3,0xc9,0x70,0xb3,0x7b,0x16,0xb6,0x1d,0xd4,0x09,0xc4,0x9a,0x46,
0x2d,0x0e,0x75,0x07,0x31,0x7b,0xed,0x45,0xcd,0x99,0x84,0x14,0xf1,0x01,0x00,0x00,0x93,0xd5,0xa3,0xe4,
0x34,0x05,0xeb,0x98,0x3b,0x5f,0x2f,0x11,0xa4,0xa5,0xc4,0xff,0xfb,0x22,0x7c,0x54
}

Definition at line 4546 of file bcrypt.c.

Referenced by test_DSA().

◆ ecc521Privkey

BYTE ecc521Privkey[]
static
Initial value:
=
{
0x00, 0x5f, 0xea, 0x1e, 0x01, 0xae, 0x69, 0xc3, 0x88, 0x1c, 0xbf, 0x7f, 0x86, 0x1a, 0x48, 0x20,
0xd3, 0xba, 0xac, 0x9f, 0x1c, 0xc9, 0x99, 0xfa, 0x7d, 0x39, 0xf6, 0xe0, 0xd6, 0x92, 0x97, 0xee,
0xf6, 0xca, 0x65, 0x40, 0x24, 0xa6, 0xf7, 0x97, 0x17, 0x8c, 0xe1, 0x81, 0x6c, 0x10, 0x92, 0xcd,
0x41, 0xbc, 0x1c, 0xde, 0x37, 0x4a, 0x21, 0xb9, 0xbc, 0x46, 0x40, 0xa9, 0x91, 0xd9, 0x61, 0x84,
0x15, 0x33,
0x00, 0x31, 0xde, 0xe9, 0x64, 0x9d, 0xb8, 0x43, 0x3a, 0x93, 0x5d, 0xc8, 0x82, 0xec, 0xe4, 0x7f,
0x83, 0x8d, 0x2c, 0xc7, 0xe8, 0x24, 0x38, 0x5a, 0x81, 0x3d, 0xe6, 0x8d, 0xd4, 0xb1, 0xa0, 0x37,
0x89, 0xae, 0x1f, 0x81, 0x23, 0x22, 0x8f, 0xd1, 0xe0, 0xc4, 0x6a, 0x99, 0xcc, 0xc8, 0xe4, 0xa0,
0x65, 0x42, 0x9e, 0xbd, 0xaf, 0x07, 0x79, 0xe8, 0x88, 0xc2, 0xfe, 0xc0, 0x2d, 0x88, 0xd5, 0x3a,
0xbd, 0xb1,
0x00, 0x8b, 0xc5, 0xd5, 0x06, 0x3a, 0x1d, 0xd2, 0xf8, 0x26, 0x8e, 0xa2, 0xd3, 0x69, 0x5a, 0xf9,
0xb6, 0x42, 0x8b, 0x1a, 0x9c, 0x34, 0x04, 0xa6, 0x1d, 0xfc, 0x67, 0xe5, 0x23, 0x71, 0x8e, 0xad,
0x61, 0x45, 0x4f, 0x00, 0x3e, 0x8f, 0x61, 0xa3, 0xfb, 0xb6, 0x7a, 0x98, 0xf8, 0x27, 0x2c, 0x1b,
0xa8, 0xda, 0xb7, 0x78, 0xe9, 0xf5, 0x9d, 0xff, 0x6a, 0x07, 0xb0, 0xe2, 0xae, 0x64, 0x15, 0x03,
0xb3, 0x8a,
}

Definition at line 2246 of file bcrypt.c.

Referenced by test_ECDSA().

◆ eccPrivkey

BYTE eccPrivkey[]
static
Initial value:
=
{
0x26, 0xff, 0x0e, 0xf9, 0x71, 0x93, 0xf8, 0xed, 0x59, 0xfa, 0x24, 0xec, 0x18, 0x13, 0xfe, 0xf5,
0x0b, 0x4a, 0xb1, 0x27, 0xb7, 0xab, 0x3e, 0x4f, 0xc5, 0x5a, 0x91, 0xa3, 0x6e, 0x21, 0x61, 0x65,
0x62, 0x7b, 0x8b, 0x30, 0x7a, 0x63, 0x4c, 0x1a, 0xf4, 0x54, 0x54, 0xbb, 0x75, 0x59, 0x68, 0x36,
0xfe, 0x49, 0x95, 0x75, 0x9e, 0x20, 0x3e, 0x69, 0x58, 0xb9, 0x7a, 0x84, 0x03, 0x45, 0x5c, 0x10,
0xb9, 0xcd, 0xbe, 0xd4, 0x75, 0x5d, 0x05, 0xe5, 0x83, 0x0c, 0xd3, 0x37, 0x34, 0x15, 0xe3, 0x2c,
0xe5, 0x85, 0x15, 0xa9, 0xee, 0xba, 0x94, 0x03, 0x03, 0x0b, 0x86, 0xea, 0x85, 0x40, 0xbd, 0x35,
}

Definition at line 2234 of file bcrypt.c.

Referenced by test_ECDSA().

◆ eccPubkey

BYTE eccPubkey[]
static
Initial value:
=
{
0x3b, 0x3c, 0x34, 0xc8, 0x3f, 0x15, 0xea, 0x02, 0x68, 0x46, 0x69, 0xdf, 0x0c, 0xa6, 0xee, 0x7a,
0xd9, 0x82, 0x08, 0x9b, 0x37, 0x53, 0x42, 0xf3, 0x13, 0x63, 0xda, 0x65, 0x79, 0xe8, 0x04, 0x9e,
0x8c, 0x77, 0xc4, 0x33, 0x77, 0xd9, 0x5a, 0x7f, 0x60, 0x7b, 0x98, 0xce, 0xf3, 0x96, 0x56, 0xd6,
0xb5, 0x8d, 0x87, 0x7a, 0x00, 0x2b, 0xf3, 0x70, 0xb3, 0x90, 0x73, 0xa0, 0x56, 0x06, 0x3b, 0x22,
}

Definition at line 2267 of file bcrypt.c.

Referenced by test_ECDSA().

◆ encrypt_race_start_barrier

LONG encrypt_race_start_barrier
static

Definition at line 994 of file bcrypt.c.

Referenced by encrypt_race_thread(), and test_BCryptEncrypt().

◆ exp1

BYTE exp1[512/16]

Definition at line 2640 of file bcrypt.c.

Referenced by test_pubexp(), and test_SystemFunction003().

◆ exp2

BYTE exp2[512/16]

Definition at line 2641 of file bcrypt.c.

Referenced by Test_ofuncs(), test_pubexp(), and test_SystemFunction003().

◆ hash_prepend

const UCHAR hash_prepend[][2] = {{0xca, 0xfe}, {0xf0, 0x0d}}
static

Definition at line 3354 of file bcrypt.c.

Referenced by test_ECDH_alg().

◆ header

PUBLICKEYSTRUC header

Definition at line 2635 of file bcrypt.c.

◆ iterations

ULONGLONG iterations

Definition at line 513 of file bcrypt.c.

Referenced by BCryptDeriveKeyPBKDF2(), find_next_pci_vendor_capability(), key_derivation_pbkdf2(), SymCryptPbkdf2Derive(), and test_BcryptDeriveKeyPBKDF2().

◆ legacy_rsa_key

UCHAR legacy_rsa_key[]
static
Initial value:
=
{
0x07, 0x02, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x52, 0x53, 0x41, 0x32, 0x00, 0x02, 0x00, 0x00,
0x01, 0x00, 0x00, 0x00, 0xab, 0xef, 0xfa, 0xc6, 0x7d, 0xe8, 0xde, 0xfb, 0x68, 0x38, 0x09, 0x92,
0xd9, 0x42, 0x7e, 0x6b, 0x89, 0x9e, 0x21, 0xd7, 0x52, 0x1c, 0x99, 0x3c, 0x17, 0x48, 0x4e, 0x3a,
0x44, 0x02, 0xf2, 0xfa, 0x74, 0x57, 0xda, 0xe4, 0xd3, 0xc0, 0x35, 0x67, 0xfa, 0x6e, 0xdf, 0x78,
0x4c, 0x75, 0x35, 0x1c, 0xa0, 0x74, 0x49, 0xe3, 0x20, 0x13, 0x71, 0x35, 0x65, 0xdf, 0x12, 0x20,
0xf5, 0xf5, 0xf5, 0xc1, 0xed, 0x5c, 0x91, 0x36, 0x75, 0xb0, 0xa9, 0x9c, 0x04, 0xdb, 0x0c, 0x8c,
0xbf, 0x99, 0x75, 0x13, 0x7e, 0x87, 0x80, 0x4b, 0x71, 0x94, 0xb8, 0x00, 0xa0, 0x7d, 0xb7, 0x53,
0xdd, 0x20, 0x63, 0xee, 0xf7, 0x83, 0x41, 0xfe, 0x16, 0xa7, 0x6e, 0xdf, 0x21, 0x7d, 0x76, 0xc0,
0x85, 0xd5, 0x65, 0x7f, 0x00, 0x23, 0x57, 0x45, 0x52, 0x02, 0x9d, 0xea, 0x69, 0xac, 0x1f, 0xfd,
0x3f, 0x8c, 0x4a, 0xd0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x64, 0xd5, 0xaa, 0xb1, 0xa6, 0x03, 0x18, 0x92, 0x03, 0xaa, 0x31, 0x2e,
0x48, 0x4b, 0x65, 0x20, 0x99, 0xcd, 0xc6, 0x0c, 0x15, 0x0c, 0xbf, 0x3e, 0xff, 0x78, 0x95, 0x67,
0xb2, 0x74, 0x5b, 0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
}

Definition at line 2950 of file bcrypt.c.

Referenced by test_RSA().

◆ long_password

UCHAR long_password[] = "passwordPASSWORDpassword"
static

Definition at line 496 of file bcrypt.c.

◆ long_salt

UCHAR long_salt[] = "saltSALTsaltSALTsaltSALTsaltSALTsalt"
static

Definition at line 497 of file bcrypt.c.

◆ modulus

BYTE modulus[512/8]

Definition at line 2637 of file bcrypt.c.

◆ password

UCHAR password[] = "password"
static

Definition at line 494 of file bcrypt.c.

Referenced by _CZipAskPassword(), ADsOpenObject(), Authenticate_Authenticate(), canonicalize_password(), CredPackAuthenticationBufferW(), CredUnPackAuthenticationBufferW(), do_authorization(), DP_IF_EnumSessions(), DP_MSG_ForwardPlayerCreation(), DP_SecureOpen(), event_redirect(), export_password_dlg_proc(), fill_url_components(), find_existing_credential(), HTMLXMLHttpRequest_open(), HTTP_DoAuthorization(), httprequest_open(), InternetCrackUrl_test(), InternetCreateUrlA_test(), iso_connect(), CZipCreatorImpl::JustDoIt(), main(), MAPILogon(), MAPILogonEx(), mcs_connect_start(), NS_SendSessionRequestBroadcast(), ntlm_AcquireCredentialsHandleW(), ntlm_InitializeSecurityContextW(), SEALED_::OnRedirect(), PFXExportCertStore(), PFXExportCertStoreEx(), PFXImportCertStore(), PFXVerifyPassword(), POP3Transport_CommandPASS(), process_redirect_pdu(), rdp2vnc_connect(), rdp_connect(), rdp_reconnect(), rdp_send_logon_info(), read_password(), receiveAddForwardRequest_(), receiveEnumSessionsRequest_(), rpcrt4_http_internet_connect(), sec_connect(), SECUR32_CreateNTLM1SessionKey(), ServerXMLHTTPRequest_open(), set_credentials(), set_request_credentials(), SspiPrepareForCredWrite(), SspiPromptForCredentialsW(), SystemFunction006(), test_create_delete_svc(), test_CredUIPromptForCredentials(), test_espassword(), test_HlinkCreateExtensionServices(), test_IWinHttpRequest(), test_proxy_direct(), test_queryconfig2(), test_sequence(), test_SspiEncodeStringsAsAuthIdentity(), unzOpenCurrentFile3(), unzOpenCurrentFilePassword(), UserLoginThread(), winhttp_request_SetCredentials(), WinHttpCrackUrl(), WinHttpCrackUrl_test(), WinHttpSetCredentials(), WININET_PasswordDialog(), WININET_ProxyPasswordDialog(), WININET_SetAuthorization(), WNetUseConnectionA(), WNetUseConnectionW(), WshNetwork2_AddPrinterConnection(), WshNetwork2_MapNetworkDrive(), XMLHTTPRequest_open(), zipOpenNewFileInZip3(), zipOpenNewFileInZip3_64(), zipOpenNewFileInZip4(), and zipOpenNewFileInZip4_64().

◆ password_NUL

UCHAR password_NUL[] = "pass\0word"
static

Definition at line 498 of file bcrypt.c.

◆ prime1

BYTE prime1[512/16]

Definition at line 2638 of file bcrypt.c.

Referenced by CRYPT_AsnDecodeRsaPrivKey(), test_decodeRsaPrivateKey(), and test_pubexp().

◆ prime2

BYTE prime2[512/16]

Definition at line 2639 of file bcrypt.c.

Referenced by CRYPT_AsnDecodeRsaPrivKey(), test_decodeRsaPrivateKey(), and test_pubexp().

◆ private_exp

BYTE private_exp[512/8]

Definition at line 2643 of file bcrypt.c.

Referenced by export_private_key_impl(), and export_rsa_key().

◆ pwd

UCHAR* pwd

Definition at line 515 of file bcrypt.c.

Referenced by BCryptDeriveKeyPBKDF2(), CRYPT_LMhash(), FTPChdir3(), GetContentsOfDialog(), GetContentsOfMenu(), InternetCrackUrlW_test(), ldap_bind_sW(), ldap_bindW(), ldap_simple_bind_sW(), ldap_simple_bindW(), MenuFill(), MenuScan(), netname2user(), StrangeMenuFill(), and test_BcryptDeriveKeyPBKDF2().

◆ pwd_len

ULONG pwd_len

Definition at line 511 of file bcrypt.c.

Referenced by BCryptDeriveKeyPBKDF2(), and test_BcryptDeriveKeyPBKDF2().

◆ 

const struct { ... } rfc6070[]
Initial value:
=
{
{ 8, 4, 1, 20, password, salt, dk1 },
{ 8, 4, 2, 20, password, salt, dk2 },
{ 8, 4, 4096, 20, password, salt, dk3 },
{ 8, 4, 1000000, 20, password, salt, dk4 },
{ 24, 36, 4096, 25, long_password, long_salt, dk5 },
{ 9, 5, 4096, 16, password_NUL, salt_NUL, dk6 },
{ 8, 0, 1, 16, password, NULL, dk7 }
}
long_password
static UCHAR long_password[]
Definition: bcrypt.c:496
dk3
static UCHAR dk3[]
Definition: bcrypt.c:503
long_salt
static UCHAR long_salt[]
Definition: bcrypt.c:497
salt_NUL
static UCHAR salt_NUL[]
Definition: bcrypt.c:499
password_NUL
static UCHAR password_NUL[]
Definition: bcrypt.c:498
password
static UCHAR password[]
Definition: bcrypt.c:494
dk5
static UCHAR dk5[]
Definition: bcrypt.c:505
dk4
static UCHAR dk4[]
Definition: bcrypt.c:504
dk2
static UCHAR dk2[]
Definition: bcrypt.c:502
dk6
static UCHAR dk6[]
Definition: bcrypt.c:506
dk1
static UCHAR dk1[]
Definition: bcrypt.c:501
dk7
static UCHAR dk7[]
Definition: bcrypt.c:507

Referenced by test_BcryptDeriveKeyPBKDF2().

◆ rsa_encrypted_no_padding

const UCHAR rsa_encrypted_no_padding[]
static
Initial value:
=
{
0x4a, 0xc1, 0xfa, 0x4f, 0xe0, 0x3f, 0x36, 0x9a, 0x64, 0xbf, 0x2e, 0x00, 0xb4, 0xb5, 0x40, 0xbe,
0x2d, 0x9a, 0x14, 0xf6, 0x8f, 0xa5, 0xc2, 0xe2, 0x20, 0xaf, 0x21, 0x79, 0xc6, 0x32, 0x7e, 0xea,
0x73, 0x00, 0x01, 0xbb, 0x9a, 0x19, 0x73, 0x41, 0x96, 0xae, 0x88, 0x6e, 0x36, 0x56, 0xe9, 0x9c,
0xac, 0x04, 0x82, 0xa8, 0x00, 0xdb, 0x4e, 0x29, 0x61, 0x7e, 0xaf, 0x64, 0xdb, 0xa2, 0x70, 0x0f,
}

Definition at line 2701 of file bcrypt.c.

Referenced by test_rsa_encrypt().

◆ rsaFullPrivateBlob

UCHAR rsaFullPrivateBlob[]
static
Initial value:
=
{
0x52, 0x53, 0x41, 0x33, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xa6, 0x8b, 0x46, 0x26, 0xb5,
0xa9, 0x69, 0x83, 0x94, 0x66, 0xa7, 0xf3, 0x33, 0x95, 0x74, 0xe9, 0xeb, 0xc8, 0xcd, 0xd7, 0x81,
0x9e, 0x45, 0x66, 0xb2, 0x48, 0x8b, 0x1f, 0xfe, 0xb3, 0x62, 0xc4, 0x0d, 0xa2, 0xf9, 0xf3, 0xe2,
0xa6, 0x86, 0xd1, 0x1e, 0x8a, 0xbb, 0x1d, 0xa5, 0xc5, 0xe8, 0xa7, 0x50, 0x37, 0xfd, 0x69, 0x1f,
0x6f, 0x99, 0x99, 0xca, 0x39, 0x13, 0xea, 0x5b, 0x6b, 0xe3, 0x91, 0xc0, 0xd2, 0x2c, 0x0b, 0x21,
0xb1, 0xac, 0xa9, 0xe8, 0xa0, 0x6d, 0xa4, 0x1f, 0x1b, 0x34, 0xcb, 0x88, 0x7f, 0x2e, 0xeb, 0x7d,
0x91, 0x38, 0x48, 0xce, 0x05, 0x73, 0x05, 0xdd, 0x22, 0x94, 0xc3, 0xdd, 0x1c, 0xfd, 0xc5, 0x41,
0x2e, 0x94, 0xf9, 0xed, 0xe5, 0x92, 0x5f, 0x3f, 0x06, 0xf8, 0x49, 0x60, 0xb8, 0x92, 0x52, 0x6a,
0x56, 0x6e, 0xd7, 0x04, 0x1a, 0xb5, 0xb5, 0x1c, 0x31, 0xd1, 0x1b, 0xa3, 0xf3, 0xd1, 0x69, 0x61,
0xab, 0xfe, 0xc1, 0xb6, 0x40, 0x7b, 0x19, 0xbb, 0x2d, 0x59, 0xf5, 0xda, 0x49, 0x32, 0x6f, 0x20,
0x24, 0xd3, 0xb3, 0xec, 0x21, 0xec, 0x0c, 0xc7, 0x5b, 0xf9, 0x1b, 0xba, 0x6e, 0xe9, 0x61, 0xda,
0x55, 0xc6, 0x72, 0xfd, 0x2d, 0x66, 0x3f, 0x3c, 0xcb, 0x49, 0xa9, 0xc5, 0x0d, 0x9b, 0x02, 0x36,
0x7a, 0xee, 0x36, 0x09, 0x55, 0xe4, 0x03, 0xf2, 0xe3, 0xe6, 0x25, 0x14, 0x89, 0x7f, 0x2b, 0xfb,
0x27, 0x0e, 0x8d, 0x37, 0x84, 0xfd, 0xad, 0x10, 0x79, 0x43, 0x4e, 0x38, 0x4a, 0xd4, 0x5e, 0xfa,
0xda, 0x9f, 0x88, 0x21, 0x7c, 0xb4, 0x98, 0xb6, 0x6e, 0x1c, 0x24, 0x09, 0xe5, 0xe7, 0x22, 0x6f,
0xd3, 0x84, 0xc0, 0xdc, 0x36, 0x09, 0xaf, 0x4b, 0x96, 0x8b, 0x5f, 0x47, 0xb3, 0x24, 0x80, 0xb5,
0x64, 0x69, 0xad, 0x83, 0xd5, 0x09, 0xe7, 0xb9, 0xe4, 0x81, 0x6f, 0x1a, 0xe2, 0x6d, 0xf1, 0x5e,
0x2b, 0xb3, 0x7a, 0xd0, 0x77, 0xef, 0x82, 0xcd, 0x55, 0x2e, 0xd5, 0xb1, 0xa7, 0x72, 0xec, 0x02,
0x9d, 0xe2, 0xcc, 0x5a, 0xf1, 0x68, 0x30, 0xe5, 0xbc, 0x8d, 0xad,
}

Definition at line 2609 of file bcrypt.c.

Referenced by test_RSA().

◆ rsaHash

UCHAR rsaHash[]
static
Initial value:
=
{
0x96, 0x1f, 0xa6, 0x49, 0x58, 0x81, 0x8f, 0x76, 0x77, 0x07, 0x07, 0x27, 0x55, 0xd7, 0x01, 0x8d,
0xcd, 0x27, 0x8e, 0x94
}

Definition at line 2569 of file bcrypt.c.

Referenced by test_RSA(), and test_RSA_SIGN().

◆ 

struct { ... } rsaLegacyPrivateBlob

Referenced by test_rsa_encrypt().

◆ rsaPrivateBlob

UCHAR rsaPrivateBlob[]
static
Initial value:
=
{
0x52, 0x53, 0x41, 0x32, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xa6, 0x8b, 0x46, 0x26, 0xb5,
0xa9, 0x69, 0x83, 0x94, 0x66, 0xa7, 0xf3, 0x33, 0x95, 0x74, 0xe9, 0xeb, 0xc8, 0xcd, 0xd7, 0x81,
0x9e, 0x45, 0x66, 0xb2, 0x48, 0x8b, 0x1f, 0xfe, 0xb3, 0x62, 0xc4, 0x0d, 0xa2, 0xf9, 0xf3, 0xe2,
0xa6, 0x86, 0xd1, 0x1e, 0x8a, 0xbb, 0x1d, 0xa5, 0xc5, 0xe8, 0xa7, 0x50, 0x37, 0xfd, 0x69, 0x1f,
0x6f, 0x99, 0x99, 0xca, 0x39, 0x13, 0xea, 0x5b, 0x6b, 0xe3, 0x91, 0xc0, 0xd2, 0x2c, 0x0b, 0x21,
0xb1, 0xac, 0xa9, 0xe8, 0xa0, 0x6d, 0xa4, 0x1f, 0x1b, 0x34, 0xcb, 0x88, 0x7f, 0x2e, 0xeb, 0x7d,
0x91, 0x38, 0x48, 0xce, 0x05, 0x73, 0x05, 0xdd, 0x22, 0x94, 0xc3, 0xdd, 0x1c, 0xfd, 0xc5, 0x41,
0x2e, 0x94, 0xf9, 0xed, 0xe5, 0x92, 0x5f, 0x3f, 0x06, 0xf8, 0x49, 0x60, 0xb8, 0x92, 0x52, 0x6a,
0x56, 0x6e, 0xd7, 0x04, 0x1a, 0xb5, 0xb5, 0x1c, 0x31, 0xd1, 0x1b,
}

Definition at line 2595 of file bcrypt.c.

Referenced by test_RSA(), and test_rsa_encrypt().

◆ rsapubkey

RSAPUBKEY rsapubkey

Definition at line 2636 of file bcrypt.c.

Referenced by CNG_ImportRSAPubKey().

◆ rsapublic

BYTE rsapublic[]
static
Initial value:
=
{
0x52, 0x53, 0x41, 0x31, 0x00, 0x08, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xd5, 0xfe, 0xf6, 0x7a, 0x9a, 0xa1, 0x2d, 0xcf, 0x98,
0x60, 0xca, 0x38, 0x60, 0x0b, 0x74, 0x4c, 0x7e, 0xa1, 0x42, 0x64, 0xad, 0x05, 0xa5, 0x29, 0x25, 0xcb, 0xd5,
0x9c, 0xaf, 0x6f, 0x63, 0x85, 0x6d, 0x5b, 0x59, 0xe5, 0x17, 0x8f, 0xf9, 0x18, 0x90, 0xa7, 0x63, 0xae, 0xe0,
0x3a, 0x62, 0xf7, 0x98, 0x57, 0xe9, 0x91, 0xda, 0xfb, 0xd9, 0x36, 0x45, 0xe4, 0x9e, 0x75, 0xf6, 0x73, 0xc4,
0x99, 0x23, 0x21, 0x1b, 0x3d, 0xe1, 0xe0, 0xa6, 0xa0, 0x4a, 0x50, 0x2a, 0xcb, 0x2a, 0x50, 0xf0, 0x8b, 0x70,
0x9c, 0xe4, 0x1a, 0x14, 0x3b, 0xbe, 0x35, 0xa5, 0x5a, 0x91, 0xa3, 0xa1, 0x82, 0xea, 0x84, 0x4d, 0xe8, 0x62,
0x3b, 0x11, 0xec, 0x61, 0x09, 0x6c, 0xfe, 0xb2, 0xcc, 0x4b, 0xa8, 0xff, 0xaf, 0x73, 0x72, 0x05, 0x4e, 0x7e,
0xe5, 0x73, 0xdf, 0x24, 0xcf, 0x7f, 0x5d, 0xaf, 0x8a, 0xf0, 0xd8, 0xcb, 0x08, 0x1e, 0xf2, 0x36, 0x70, 0x8d,
0x1b, 0x9e, 0xc8, 0x98, 0x60, 0x54, 0xeb, 0x45, 0x34, 0x21, 0x43, 0x4d, 0x42, 0x0a, 0x3a, 0x2d, 0x0f, 0x0e,
0xd6, 0x0d, 0xe4, 0x2e, 0x8c, 0x31, 0x87, 0xa8, 0x09, 0x89, 0x61, 0x16, 0xca, 0x5b, 0xbe, 0x76, 0x69, 0xbb,
0xfd, 0x91, 0x63, 0xd2, 0x66, 0x57, 0x08, 0xef, 0xe2, 0x40, 0x67, 0xd7, 0x7f, 0x50, 0x15, 0x42, 0x33, 0x97,
0x54, 0x73, 0x47, 0xe7, 0x9c, 0x14, 0xa8, 0xb0, 0x3d, 0xc9, 0x23, 0xb0, 0x27, 0x3b, 0xe7, 0xdd, 0x5f, 0xd1,
0x4f, 0x31, 0x10, 0x7d, 0xdd, 0x69, 0x8e, 0xde, 0xa3, 0xe8, 0x92, 0x00, 0xfa, 0xa5, 0xa4, 0x40, 0x51, 0x23,
0x82, 0x84, 0xc7, 0xce, 0x19, 0x61, 0x26, 0xf1, 0xae, 0xf3, 0x90, 0x93, 0x98, 0x56, 0x23, 0x9a, 0xd1, 0xbd,
0xf2, 0xdf, 0xfd, 0x13, 0x9c, 0x30, 0x07, 0xf9, 0x5a, 0x2e, 0x00, 0xc6, 0x1f
}

Definition at line 4104 of file bcrypt.c.

Referenced by test_BCryptSignHash().

◆ rsaPublicBlob

UCHAR rsaPublicBlob[]
static
Initial value:
=
{
0x52, 0x53, 0x41, 0x31, 0x00, 0x08, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0xad, 0x41, 0x09, 0xa2, 0x56,
0x3a, 0x7b, 0x75, 0x4b, 0x72, 0x9b, 0x28, 0x72, 0x3b, 0xae, 0x9f, 0xd8, 0xa8, 0x25, 0x4a, 0x4c,
0x19, 0xf5, 0xa6, 0xd0, 0x05, 0x1c, 0x59, 0x8f, 0xe3, 0xf3, 0x2d, 0x29, 0x47, 0xf8, 0x80, 0x25,
0x25, 0x21, 0x58, 0xc2, 0xac, 0xa1, 0x9e, 0x93, 0x8e, 0x82, 0x6d, 0xd7, 0xf3, 0xe7, 0x8f, 0x0b,
0xc0, 0x41, 0x85, 0x29, 0x3c, 0xf1, 0x0b, 0x2c, 0x5d, 0x49, 0xed, 0xb4, 0x30, 0x6e, 0x02, 0x15,
0x4b, 0x9a, 0x08, 0x0d, 0xe1, 0x6f, 0xa8, 0xd3, 0x12, 0xab, 0x66, 0x48, 0x4d, 0xd9, 0x28, 0x03,
0x6c, 0x9d, 0x44, 0x7a, 0xed, 0xc9, 0x43, 0x4f, 0x9d, 0x4e, 0x3c, 0x7d, 0x0e, 0xff, 0x07, 0x87,
0xeb, 0xca, 0xca, 0x65, 0x6d, 0xbe, 0xc5, 0x31, 0x8b, 0xcc, 0x7e, 0x0a, 0x71, 0x4a, 0x4d, 0x9d,
0x3d, 0xfd, 0x7a, 0x56, 0x32, 0x8a, 0x6c, 0x6d, 0x9d, 0x2a, 0xd9, 0x8e, 0x68, 0x89, 0x63, 0xc6,
0x4f, 0x24, 0xd1, 0x2a, 0x72, 0x69, 0x08, 0x77, 0xa0, 0x7f, 0xfe, 0xc6, 0x33, 0x8d, 0xb4, 0x7d,
0x73, 0x91, 0x13, 0x9c, 0x47, 0x53, 0x6a, 0x13, 0xdf, 0x19, 0xc7, 0xed, 0x48, 0x81, 0xed, 0xd8,
0x1f, 0x11, 0x11, 0xbb, 0x41, 0x15, 0x5b, 0xa4, 0xf5, 0xc9, 0x2b, 0x48, 0x5e, 0xd8, 0x4b, 0x52,
0x1f, 0xf7, 0x87, 0xf2, 0x68, 0x25, 0x28, 0x79, 0xee, 0x39, 0x41, 0xc9, 0x0e, 0xc8, 0xf9, 0xf2,
0xd8, 0x24, 0x09, 0xb4, 0xd4, 0xb7, 0x90, 0xba, 0x26, 0xe8, 0x1d, 0xb4, 0xd7, 0x09, 0x00, 0xc4,
0xa0, 0xb6, 0x14, 0xe8, 0x4c, 0x29, 0x60, 0x54, 0x2e, 0x01, 0xde, 0x54, 0x66, 0x40, 0x22, 0x50,
0x27, 0xf1, 0xe7, 0x62, 0xa9, 0x00, 0x5a, 0x61, 0x2e, 0xfa, 0xfe, 0x16, 0xd8, 0xe0, 0xe7, 0x66,
0x17, 0xda, 0xb8, 0x0c, 0xa6, 0x04, 0x8d, 0xf8, 0x21, 0x68, 0x39
}

Definition at line 2547 of file bcrypt.c.

Referenced by test_RSA(), test_rsa_encrypt(), and test_RSA_SIGN().

◆ rsaPublicBlobWithInvalidPublicExpSize

UCHAR rsaPublicBlobWithInvalidPublicExpSize[]
static
Initial value:
=
{
0x52, 0x53, 0x41, 0x31, 0x00, 0x04, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x00, 0x01, 0xc7, 0x8f, 0xac, 0x2a, 0xce, 0xbf, 0xc9, 0x6c, 0x7b,
0x85, 0x74, 0x71, 0xbb, 0xff, 0xbb, 0x9b, 0x20, 0x03, 0x79, 0x17, 0x34,
0xe7, 0x26, 0x91, 0x5c, 0x1f, 0x1b, 0x03, 0x3d, 0x46, 0xdf, 0xb6, 0xf2,
0x10, 0x55, 0xf0, 0x39, 0x55, 0x0a, 0xe3, 0x9c, 0x0c, 0x63, 0xc2, 0x14,
0x03, 0x94, 0x51, 0x0d, 0xb4, 0x22, 0x09, 0xf2, 0x5c, 0xb2, 0xd1, 0xc3,
0xac, 0x6f, 0xa8, 0xc4, 0xac, 0xb8, 0xbc, 0x59, 0xe7, 0xed, 0x77, 0x6e,
0xb1, 0x80, 0x58, 0x7d, 0xb2, 0x94, 0x46, 0xe5, 0x00, 0xe2, 0xb7, 0x33,
0x48, 0x7a, 0xd3, 0x78, 0xe9, 0x26, 0x01, 0xc7, 0x00, 0x7b, 0x41, 0x6d,
0x94, 0x3a, 0xe1, 0x50, 0x2b, 0x9f, 0x6b, 0x1c, 0x08, 0xa3, 0xfc, 0x0a,
0x44, 0x81, 0x09, 0x41, 0x80, 0x23, 0x7b, 0xf6, 0x3f, 0xaf, 0x91, 0xa1,
0x87, 0x75, 0x33, 0x15, 0xb8, 0xde, 0x32, 0x30, 0xb4, 0x5e, 0xfd
}

Definition at line 2684 of file bcrypt.c.

Referenced by test_RSA().

◆ rsaSignature

UCHAR rsaSignature[]
static
Initial value:
=
{
0xa8, 0x3a, 0x9d, 0xaf, 0x92, 0x94, 0xa4, 0x4d, 0x34, 0xba, 0x41, 0x0c, 0xc1, 0x23, 0x91, 0xc7,
0x91, 0xa8, 0xf8, 0xfc, 0x94, 0x87, 0x4d, 0x05, 0x85, 0x63, 0xe8, 0x7d, 0xea, 0x7f, 0x6b, 0x8d,
0xbb, 0x9a, 0xd4, 0x46, 0xa6, 0xc0, 0xd6, 0xdc, 0x91, 0xba, 0xd3, 0x1a, 0xbf, 0xf4, 0x52, 0xa0,
0xc7, 0x15, 0x87, 0xe9, 0x1e, 0x60, 0x49, 0x9c, 0xee, 0x5a, 0x9c, 0x6c, 0xbd, 0x7a, 0x3e, 0xc3,
0x48, 0xb3, 0xee, 0xca, 0x68, 0x40, 0x9b, 0xa1, 0x4c, 0x6e, 0x20, 0xd6, 0xca, 0x6c, 0x72, 0xaf,
0x2b, 0x6b, 0x62, 0x7c, 0x78, 0x06, 0x94, 0x4c, 0x02, 0xf3, 0x8d, 0x49, 0xe0, 0x11, 0xc4, 0x9b,
0x62, 0x5b, 0xc2, 0xfd, 0x68, 0xf4, 0x07, 0x15, 0x71, 0x11, 0x4c, 0x35, 0x97, 0x5d, 0xc0, 0xe6,
0x22, 0xc9, 0x8a, 0x7b, 0x96, 0xc9, 0xc3, 0xe4, 0x2b, 0x1e, 0x88, 0x17, 0x4f, 0x98, 0x9b, 0xf3,
0x42, 0x23, 0x0c, 0xa0, 0xfa, 0x19, 0x03, 0x2a, 0xf7, 0x13, 0x2d, 0x27, 0xac, 0x9f, 0xaf, 0x2d,
0xa3, 0xce, 0xf7, 0x63, 0xbb, 0x39, 0x9f, 0x72, 0x80, 0xdd, 0x6c, 0x73, 0x00, 0x85, 0x70, 0xf2,
0xed, 0x50, 0xed, 0xa0, 0x74, 0x42, 0xd7, 0x22, 0x46, 0x24, 0xee, 0x67, 0xdf, 0xb5, 0x45, 0xe8,
0x49, 0xf4, 0x9c, 0xe4, 0x00, 0x83, 0xf2, 0x27, 0x8e, 0xa2, 0xb1, 0xc3, 0xc2, 0x01, 0xd7, 0x59,
0x2e, 0x4d, 0xac, 0x49, 0xa2, 0xc1, 0x8d, 0x88, 0x4b, 0xfe, 0x28, 0xe5, 0xac, 0xa6, 0x85, 0xc4,
0x1f, 0xf8, 0xc5, 0xc5, 0x14, 0x4e, 0xa3, 0xcb, 0x17, 0xb7, 0x64, 0xb3, 0xc2, 0x12, 0xf8, 0xf8,
0x36, 0x99, 0x1c, 0x91, 0x9b, 0xbd, 0xed, 0x55, 0x0f, 0xfd, 0x49, 0x85, 0xbb, 0x32, 0xad, 0x78,
0xc1, 0x74, 0xe6, 0x7c, 0x18, 0x0f, 0x2b, 0x3b, 0xaa, 0xd1, 0x9d, 0x40, 0x71, 0x1d, 0x19, 0x53
}

Definition at line 2575 of file bcrypt.c.

Referenced by test_RSA(), and test_RSA_SIGN().

◆ salt

UCHAR* salt = "salt"
static

Definition at line 495 of file bcrypt.c.

Referenced by BCryptDeriveKeyPBKDF2(), BLAKE2_PACKED(), hkdf_finalize(), key_derivation_pbkdf2(), load_encryption_key(), sec_hash_48(), test_BcryptDeriveKeyPBKDF2(), test_HKDF(), test_PBKDF2(), test_rc2(), test_rc4(), test_RC4_salt(), and test_RC4_session_key().

◆ salt_len

ULONG salt_len

Definition at line 512 of file bcrypt.c.

Referenced by BCryptDeriveKeyPBKDF2(), hkdf_finalize(), key_derivation_pbkdf2(), and test_BcryptDeriveKeyPBKDF2().

◆ salt_NUL

UCHAR salt_NUL[] = "sa\0lt"
static

Definition at line 499 of file bcrypt.c.

◆ ULONG

UCHAR UCHAR UCHAR ULONG

Definition at line 31 of file bcrypt.c.