March 2018 - Wine-devel - list.winehq.org

[PATCH 4/5] bcrypt: Initial implementation for RSA key import and signature verification.
by Hans Leidekker 26 Mar '18

26 Mar '18

From: Kimmo Myllyvirta <kimmo.myllyvirta(a)gmail.com> Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/bcrypt/bcrypt_main.c | 127 +++++++++++++++++++++++++++++++++++++++++----- include/bcrypt.h | 17 +++++++ 2 files changed, 130 insertions(+), 14 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index d41195e00d..1490089cf7 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -76,6 +76,9 @@ static gnutls_sign_algorithm_t (*pgnutls_pk_to_sign)(gnutls_pk_algorithm_t, gnut static int (*pgnutls_pubkey_verify_hash2)(gnutls_pubkey_t, gnutls_sign_algorithm_t, unsigned int, const gnutls_datum_t *, const gnutls_datum_t *); +/* Not present in gnutls version < 2.11.0 */ +static int (*pgnutls_pubkey_import_rsa_raw)(gnutls_pubkey_t key, const gnutls_datum_t *m, const gnutls_datum_t *e); + static void *libgnutls_handle; #define MAKE_FUNCPTR(f) static typeof(f) * p##f MAKE_FUNCPTR(gnutls_cipher_decrypt2); @@ -119,6 +122,11 @@ static int compat_gnutls_pubkey_verify_hash2(gnutls_pubkey_t key, gnutls_sign_al return GNUTLS_E_UNKNOWN_CIPHER_TYPE; } +static int compat_gnutls_pubkey_import_rsa_raw(gnutls_pubkey_t key, const gnutls_datum_t *m, const gnutls_datum_t *e) +{ + return GNUTLS_E_UNKNOWN_CIPHER_TYPE; +} + static void gnutls_log( int level, const char *msg ) { TRACE( "<%d> %s", level, msg ); @@ -185,6 +193,11 @@ static BOOL gnutls_initialize(void) WARN("gnutls_pubkey_verify_hash2 not found\n"); pgnutls_pubkey_verify_hash2 = compat_gnutls_pubkey_verify_hash2; } + if (!(pgnutls_pubkey_import_rsa_raw = wine_dlsym( libgnutls_handle, "gnutls_pubkey_import_rsa_raw", NULL, 0 ))) + { + WARN("gnutls_pubkey_import_rsa_raw not found\n"); + pgnutls_pubkey_import_rsa_raw = compat_gnutls_pubkey_import_rsa_raw; + } if (TRACE_ON( bcrypt )) { @@ -270,6 +283,7 @@ enum alg_id ALG_ID_MD4, ALG_ID_MD5, ALG_ID_RNG, + ALG_ID_RSA, ALG_ID_SHA1, ALG_ID_SHA256, ALG_ID_SHA384, @@ -303,6 +317,7 @@ alg_props[] = /* ALG_ID_MD4 */ { 270, 16, 512, BCRYPT_MD4_ALGORITHM, FALSE }, /* ALG_ID_MD5 */ { 274, 16, 512, BCRYPT_MD5_ALGORITHM, FALSE }, /* ALG_ID_RNG */ { 0, 0, 0, BCRYPT_RNG_ALGORITHM, FALSE }, + /* ALG_ID_RSA */ { 0, 0, 0, BCRYPT_RSA_ALGORITHM, FALSE }, /* ALG_ID_SHA1 */ { 278, 20, 512, BCRYPT_SHA1_ALGORITHM, FALSE }, /* ALG_ID_SHA256 */ { 286, 32, 512, BCRYPT_SHA256_ALGORITHM, FALSE }, /* ALG_ID_SHA384 */ { 382, 48, 1024, BCRYPT_SHA384_ALGORITHM, FALSE }, @@ -380,6 +395,7 @@ NTSTATUS WINAPI BCryptOpenAlgorithmProvider( BCRYPT_ALG_HANDLE *handle, LPCWSTR else if (!strcmpW( id, BCRYPT_MD4_ALGORITHM )) alg_id = ALG_ID_MD4; else if (!strcmpW( id, BCRYPT_MD5_ALGORITHM )) alg_id = ALG_ID_MD5; else if (!strcmpW( id, BCRYPT_RNG_ALGORITHM )) alg_id = ALG_ID_RNG; + else if (!strcmpW( id, BCRYPT_RSA_ALGORITHM )) alg_id = ALG_ID_RSA; else if (!strcmpW( id, BCRYPT_SHA1_ALGORITHM )) alg_id = ALG_ID_SHA1; else if (!strcmpW( id, BCRYPT_SHA256_ALGORITHM )) alg_id = ALG_ID_SHA256; else if (!strcmpW( id, BCRYPT_SHA384_ALGORITHM )) alg_id = ALG_ID_SHA384; @@ -1242,6 +1258,7 @@ static NTSTATUS key_asymmetric_init( struct key *key, struct algorithm *alg, con { case ALG_ID_ECDSA_P256: case ALG_ID_ECDSA_P384: + case ALG_ID_RSA: break; default: @@ -1401,6 +1418,34 @@ static NTSTATUS import_gnutls_pubkey_ecc( struct key *key, gnutls_pubkey_t *gnut return STATUS_SUCCESS; } +static NTSTATUS import_gnutls_pubkey_rsa( struct key *key, gnutls_pubkey_t *gnutls_key ) +{ + BCRYPT_RSAKEY_BLOB *rsa_blob; + gnutls_datum_t m, e; + int ret; + + if ((ret = pgnutls_pubkey_init( gnutls_key ))) + { + pgnutls_perror( ret ); + return STATUS_INTERNAL_ERROR; + } + + rsa_blob = (BCRYPT_RSAKEY_BLOB *)key->u.a.pubkey; + e.data = key->u.a.pubkey + sizeof(*rsa_blob); + e.size = rsa_blob->cbPublicExp; + m.data = key->u.a.pubkey + sizeof(*rsa_blob) + rsa_blob->cbPublicExp; + m.size = rsa_blob->cbModulus; + + if ((ret = pgnutls_pubkey_import_rsa_raw( *gnutls_key, &m, &e ))) + { + pgnutls_perror( ret ); + pgnutls_pubkey_deinit( *gnutls_key ); + return STATUS_INTERNAL_ERROR; + } + + return STATUS_SUCCESS; +} + static NTSTATUS import_gnutls_pubkey( struct key *key, gnutls_pubkey_t *gnutls_key ) { switch (key->alg_id) @@ -1409,6 +1454,9 @@ static NTSTATUS import_gnutls_pubkey( struct key *key, gnutls_pubkey_t *gnutls_k case ALG_ID_ECDSA_P384: return import_gnutls_pubkey_ecc( key, gnutls_key ); + case ALG_ID_RSA: + return import_gnutls_pubkey_rsa( key, gnutls_key ); + default: FIXME("algorithm %u not yet supported\n", key->alg_id ); return STATUS_NOT_IMPLEMENTED; @@ -1437,6 +1485,14 @@ static NTSTATUS prepare_gnutls_signature_ecc( struct key *key, UCHAR *signature, return STATUS_SUCCESS; } +static NTSTATUS prepare_gnutls_signature_rsa( struct key *key, UCHAR *signature, ULONG signature_len, + gnutls_datum_t *gnutls_signature ) +{ + gnutls_signature->data = signature; + gnutls_signature->size = signature_len; + return STATUS_SUCCESS; +} + static NTSTATUS prepare_gnutls_signature( struct key *key, UCHAR *signature, ULONG signature_len, gnutls_datum_t *gnutls_signature ) { @@ -1446,6 +1502,9 @@ static NTSTATUS prepare_gnutls_signature( struct key *key, UCHAR *signature, ULO case ALG_ID_ECDSA_P384: return prepare_gnutls_signature_ecc( key, signature, signature_len, gnutls_signature ); + case ALG_ID_RSA: + return prepare_gnutls_signature_rsa( key, signature, signature_len, gnutls_signature ); + default: FIXME( "algorithm %u not yet supported\n", key->alg_id ); return STATUS_NOT_IMPLEMENTED; @@ -1463,26 +1522,45 @@ static NTSTATUS key_asymmetric_verify( struct key *key, void *padding, UCHAR *ha NTSTATUS status; int ret; - if (flags) FIXME( "flags %08x not supported\n", flags ); - - /* only the hash size must match, not the actual hash function */ - switch (hash_len) - { - case 32: hash_alg = GNUTLS_DIG_SHA256; break; - case 48: hash_alg = GNUTLS_DIG_SHA384; break; - - default: - FIXME( "hash size %u not yet supported\n", hash_len ); - return STATUS_INVALID_SIGNATURE; - } - switch (key->alg_id) { case ALG_ID_ECDSA_P256: case ALG_ID_ECDSA_P384: + { + if (flags) FIXME( "flags %08x not supported\n", flags ); + + /* only the hash size must match, not the actual hash function */ + switch (hash_len) + { + case 32: hash_alg = GNUTLS_DIG_SHA256; break; + case 48: hash_alg = GNUTLS_DIG_SHA384; break; + + default: + FIXME( "hash size %u not yet supported\n", hash_len ); + return STATUS_INVALID_SIGNATURE; + } pk_alg = GNUTLS_PK_ECC; break; + } + case ALG_ID_RSA: + { + BCRYPT_PKCS1_PADDING_INFO *info = (BCRYPT_PKCS1_PADDING_INFO *)padding; + if (!(flags & BCRYPT_PAD_PKCS1) || !info) return STATUS_INVALID_PARAMETER; + if (!info->pszAlgId) return STATUS_INVALID_SIGNATURE; + + if (!strcmpW( info->pszAlgId, BCRYPT_SHA1_ALGORITHM )) hash_alg = GNUTLS_DIG_SHA1; + else if (!strcmpW( info->pszAlgId, BCRYPT_SHA256_ALGORITHM )) hash_alg = GNUTLS_DIG_SHA256; + else if (!strcmpW( info->pszAlgId, BCRYPT_SHA384_ALGORITHM )) hash_alg = GNUTLS_DIG_SHA384; + else if (!strcmpW( info->pszAlgId, BCRYPT_SHA512_ALGORITHM )) hash_alg = GNUTLS_DIG_SHA512; + else + { + FIXME( "hash algorithm %s not supported\n", debugstr_w(info->pszAlgId) ); + return STATUS_NOT_SUPPORTED; + } + pk_alg = GNUTLS_PK_RSA; + break; + } default: FIXME( "algorithm %u not yet supported\n", key->alg_id ); return STATUS_NOT_IMPLEMENTED; @@ -1505,7 +1583,7 @@ static NTSTATUS key_asymmetric_verify( struct key *key, void *padding, UCHAR *ha gnutls_hash.size = hash_len; ret = pgnutls_pubkey_verify_hash2( gnutls_key, sign_alg, 0, &gnutls_hash, &gnutls_signature ); - heap_free( gnutls_signature.data ); + if (gnutls_signature.data != signature) heap_free( gnutls_signature.data ); pgnutls_pubkey_deinit( gnutls_key ); return (ret < 0) ? STATUS_INVALID_SIGNATURE : STATUS_SUCCESS; } @@ -1945,6 +2023,27 @@ NTSTATUS WINAPI BCryptImportKeyPair( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HAN *ret_key = key; return STATUS_SUCCESS; } + else if (!strcmpW( type, BCRYPT_RSAPUBLIC_BLOB )) + { + BCRYPT_RSAKEY_BLOB *rsa_blob = (BCRYPT_RSAKEY_BLOB *)input; + ULONG size; + + if (input_len < sizeof(*rsa_blob)) return STATUS_INVALID_PARAMETER; + if (alg->id != ALG_ID_RSA || rsa_blob->Magic != BCRYPT_RSAPUBLIC_MAGIC) return STATUS_NOT_SUPPORTED; + + if (!(key = heap_alloc( sizeof(*key) ))) return STATUS_NO_MEMORY; + key->hdr.magic = MAGIC_KEY; + + size = sizeof(*rsa_blob) + rsa_blob->cbPublicExp + rsa_blob->cbModulus; + if ((status = key_asymmetric_init( key, alg, (BYTE *)rsa_blob, size ))) + { + heap_free( key ); + return status; + } + + *ret_key = key; + return STATUS_SUCCESS; + } FIXME( "unsupported key type %s\n", debugstr_w(type) ); return STATUS_NOT_SUPPORTED; diff --git a/include/bcrypt.h b/include/bcrypt.h index f28b0d395d..df54f621fa 100644 --- a/include/bcrypt.h +++ b/include/bcrypt.h @@ -63,6 +63,8 @@ typedef LONG NTSTATUS; #define BCRYPT_AES_WRAP_KEY_BLOB (const WCHAR []){'R','f','c','3','5','6','5','K','e','y','W','r','a','p','B','l','o','b',0} #define BCRYPT_ECCPUBLIC_BLOB (const WCHAR []){'E','C','C','P','U','B','L','I','C','B','L','O','B',0} #define BCRYPT_ECCPRIVATE_BLOB (const WCHAR []){'E','C','C','P','R','I','V','A','T','E','B','L','O','B',0} +#define BCRYPT_RSAPUBLIC_BLOB (const WCHAR []){'R','S','A','P','U','B','L','I','C','B','L','O','B',0} +#define BCRYPT_RSAPRIVATE_BLOB (const WCHAR []){'R','S','A','P','R','I','V','A','T','E','B','L','O','B',0} #define MS_PRIMITIVE_PROVIDER (const WCHAR [])\ {'M','i','c','r','o','s','o','f','t',' ','P','r','i','m','i','t','i','v','e',' ','P','r','o','v','i','d','e','r',0} @@ -74,6 +76,7 @@ typedef LONG NTSTATUS; #define BCRYPT_MD4_ALGORITHM (const WCHAR []){'M','D','4',0} #define BCRYPT_MD5_ALGORITHM (const WCHAR []){'M','D','5',0} #define BCRYPT_RNG_ALGORITHM (const WCHAR []){'R','N','G',0} +#define BCRYPT_RSA_ALGORITHM (const WCHAR []){'R','S','A',0} #define BCRYPT_SHA1_ALGORITHM (const WCHAR []){'S','H','A','1',0} #define BCRYPT_SHA256_ALGORITHM (const WCHAR []){'S','H','A','2','5','6',0} #define BCRYPT_SHA384_ALGORITHM (const WCHAR []){'S','H','A','3','8','4',0} @@ -133,6 +136,20 @@ typedef struct _BCRYPT_ECCKEY_BLOB ULONG cbKey; } BCRYPT_ECCKEY_BLOB, *PBCRYPT_ECCKEY_BLOB; +#define BCRYPT_RSAPUBLIC_MAGIC 0x31415352 +#define BCRYPT_RSAPRIVATE_MAGIC 0x32415352 +#define BCRYPT_RSAFULLPRIVATE_MAGIC 0x33415352 + +typedef struct _BCRYPT_RSAKEY_BLOB +{ + ULONG Magic; + ULONG BitLength; + ULONG cbPublicExp; + ULONG cbModulus; + ULONG cbPrime1; + ULONG cbPrime2; +} BCRYPT_RSAKEY_BLOB; + typedef struct _BCRYPT_PKCS1_PADDING_INFO { LPCWSTR pszAlgId; -- 2.11.0

1 0

[PATCH 3/5] bcrypt: Implement BCryptVerifySignature for ECDSA signatures.
by Hans Leidekker 26 Mar '18

26 Mar '18

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/bcrypt/bcrypt_main.c | 361 ++++++++++++++++++++++++++++++++++++++++++--- dlls/bcrypt/tests/bcrypt.c | 4 +- 2 files changed, 343 insertions(+), 22 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index 82a742cbc0..d41195e00d 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -27,6 +27,7 @@ #elif defined(HAVE_GNUTLS_CIPHER_INIT) #include <gnutls/gnutls.h> #include <gnutls/crypto.h> +#include <gnutls/abstract.h> #endif #include "ntstatus.h" @@ -50,9 +51,30 @@ static HINSTANCE instance; #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) WINE_DECLARE_DEBUG_CHANNEL(winediag); +#if GNUTLS_VERSION_MAJOR < 3 +#define GNUTLS_CIPHER_AES_192_CBC 92 +#define GNUTLS_CIPHER_AES_128_GCM 93 +#define GNUTLS_CIPHER_AES_256_GCM 94 +#define GNUTLS_PK_ECC 4 + +typedef enum +{ + GNUTLS_ECC_CURVE_INVALID, + GNUTLS_ECC_CURVE_SECP224R1, + GNUTLS_ECC_CURVE_SECP256R1, + GNUTLS_ECC_CURVE_SECP384R1, + GNUTLS_ECC_CURVE_SECP521R1, +} gnutls_ecc_curve_t; +#endif + /* Not present in gnutls version < 3.0 */ -static int (*pgnutls_cipher_tag)(gnutls_cipher_hd_t handle, void * tag, size_t tag_size); -static int (*pgnutls_cipher_add_auth)(gnutls_cipher_hd_t handle, const void *ptext, size_t ptext_size); +static int (*pgnutls_cipher_tag)(gnutls_cipher_hd_t, void *, size_t); +static int (*pgnutls_cipher_add_auth)(gnutls_cipher_hd_t, const void *, size_t); +static int (*pgnutls_pubkey_import_ecc_raw)(gnutls_pubkey_t, gnutls_ecc_curve_t, + const gnutls_datum_t *, const gnutls_datum_t *); +static gnutls_sign_algorithm_t (*pgnutls_pk_to_sign)(gnutls_pk_algorithm_t, gnutls_digest_algorithm_t); +static int (*pgnutls_pubkey_verify_hash2)(gnutls_pubkey_t, gnutls_sign_algorithm_t, unsigned int, + const gnutls_datum_t *, const gnutls_datum_t *); static void *libgnutls_handle; #define MAKE_FUNCPTR(f) static typeof(f) * p##f @@ -65,14 +87,10 @@ MAKE_FUNCPTR(gnutls_global_init); MAKE_FUNCPTR(gnutls_global_set_log_function); MAKE_FUNCPTR(gnutls_global_set_log_level); MAKE_FUNCPTR(gnutls_perror); +MAKE_FUNCPTR(gnutls_pubkey_init); +MAKE_FUNCPTR(gnutls_pubkey_deinit); #undef MAKE_FUNCPTR -#if GNUTLS_VERSION_MAJOR < 3 -#define GNUTLS_CIPHER_AES_192_CBC 92 -#define GNUTLS_CIPHER_AES_128_GCM 93 -#define GNUTLS_CIPHER_AES_256_GCM 94 -#endif - static int compat_gnutls_cipher_tag(gnutls_cipher_hd_t handle, void *tag, size_t tag_size) { return GNUTLS_E_UNKNOWN_CIPHER_TYPE; @@ -83,6 +101,24 @@ static int compat_gnutls_cipher_add_auth(gnutls_cipher_hd_t handle, const void * return GNUTLS_E_UNKNOWN_CIPHER_TYPE; } +static int compat_gnutls_pubkey_import_ecc_raw(gnutls_pubkey_t key, gnutls_ecc_curve_t curve, + const gnutls_datum_t *x, const gnutls_datum_t *y) +{ + return GNUTLS_E_UNKNOWN_CIPHER_TYPE; +} + +static gnutls_sign_algorithm_t compat_gnutls_pk_to_sign(gnutls_pk_algorithm_t pk, gnutls_digest_algorithm_t hash) +{ + return GNUTLS_SIGN_UNKNOWN; +} + +static int compat_gnutls_pubkey_verify_hash2(gnutls_pubkey_t key, gnutls_sign_algorithm_t algo, + unsigned int flags, const gnutls_datum_t *hash, + const gnutls_datum_t *signature) +{ + return GNUTLS_E_UNKNOWN_CIPHER_TYPE; +} + static void gnutls_log( int level, const char *msg ) { TRACE( "<%d> %s", level, msg ); @@ -114,6 +150,8 @@ static BOOL gnutls_initialize(void) LOAD_FUNCPTR(gnutls_global_set_log_function) LOAD_FUNCPTR(gnutls_global_set_log_level) LOAD_FUNCPTR(gnutls_perror) + LOAD_FUNCPTR(gnutls_pubkey_init); + LOAD_FUNCPTR(gnutls_pubkey_deinit); #undef LOAD_FUNCPTR if (!(pgnutls_cipher_tag = wine_dlsym( libgnutls_handle, "gnutls_cipher_tag", NULL, 0 ))) @@ -132,6 +170,21 @@ static BOOL gnutls_initialize(void) pgnutls_perror( ret ); goto fail; } + if (!(pgnutls_pubkey_import_ecc_raw = wine_dlsym( libgnutls_handle, "gnutls_pubkey_import_ecc_raw", NULL, 0 ))) + { + WARN("gnutls_pubkey_import_ecc_raw not found\n"); + pgnutls_pubkey_import_ecc_raw = compat_gnutls_pubkey_import_ecc_raw; + } + if (!(pgnutls_pk_to_sign = wine_dlsym( libgnutls_handle, "gnutls_pk_to_sign", NULL, 0 ))) + { + WARN("gnutls_pk_to_sign not found\n"); + pgnutls_pk_to_sign = compat_gnutls_pk_to_sign; + } + if (!(pgnutls_pubkey_verify_hash2 = wine_dlsym( libgnutls_handle, "gnutls_pubkey_verify_hash2", NULL, 0 ))) + { + WARN("gnutls_pubkey_verify_hash2 not found\n"); + pgnutls_pubkey_verify_hash2 = compat_gnutls_pubkey_verify_hash2; + } if (TRACE_ON( bcrypt )) { @@ -585,10 +638,10 @@ static NTSTATUS get_alg_property( const struct algorithm *alg, const WCHAR *prop const WCHAR *mode; switch (alg->mode) { - case MODE_ID_ECB: mode = BCRYPT_CHAIN_MODE_ECB; break; - case MODE_ID_CBC: mode = BCRYPT_CHAIN_MODE_CBC; break; - case MODE_ID_GCM: mode = BCRYPT_CHAIN_MODE_GCM; break; - default: return STATUS_NOT_IMPLEMENTED; + case MODE_ID_ECB: mode = BCRYPT_CHAIN_MODE_ECB; break; + case MODE_ID_CBC: mode = BCRYPT_CHAIN_MODE_CBC; break; + case MODE_ID_GCM: mode = BCRYPT_CHAIN_MODE_GCM; break; + default: return STATUS_NOT_IMPLEMENTED; } *ret_size = 64; @@ -1206,6 +1259,257 @@ static NTSTATUS key_asymmetric_init( struct key *key, struct algorithm *alg, con return STATUS_SUCCESS; } +struct buffer +{ + BYTE *buffer; + DWORD length; + DWORD pos; + BOOL error; +}; + +static void buffer_init( struct buffer *buffer ) +{ + buffer->buffer = NULL; + buffer->length = 0; + buffer->pos = 0; + buffer->error = FALSE; +} + +static void buffer_free( struct buffer *buffer ) +{ + heap_free( buffer->buffer ); +} + +static void buffer_append( struct buffer *buffer, BYTE *data, DWORD len ) +{ + if (!len) return; + + if (buffer->pos + len > buffer->length) + { + DWORD new_length = max( max( buffer->pos + len, buffer->length * 2 ), 64 ); + BYTE *new_buffer; + + if (!(new_buffer = heap_realloc( buffer->buffer, new_length ))) + { + ERR( "out of memory\n" ); + buffer->error = TRUE; + return; + } + + buffer->buffer = new_buffer; + buffer->length = new_length; + } + + memcpy( &buffer->buffer[buffer->pos], data, len ); + buffer->pos += len; +} + +static void buffer_append_byte( struct buffer *buffer, BYTE value ) +{ + buffer_append( buffer, &value, sizeof(value) ); +} + +static void buffer_append_asn1_length( struct buffer *buffer, DWORD length ) +{ + DWORD num_bytes; + + if (length < 128) + { + buffer_append_byte( buffer, length ); + return; + } + + if (length <= 0xff) num_bytes = 1; + else if (length <= 0xffff) num_bytes = 2; + else if (length <= 0xffffff) num_bytes = 3; + else num_bytes = 4; + + buffer_append_byte( buffer, 0x80 | num_bytes ); + while (num_bytes--) buffer_append_byte( buffer, length >> (num_bytes * 8) ); +} + +static void buffer_append_asn1_integer( struct buffer *buffer, BYTE *data, DWORD len ) +{ + DWORD leading_zero = (*data & 0x80) != 0; + + buffer_append_byte( buffer, 0x02 ); /* tag */ + buffer_append_asn1_length( buffer, len + leading_zero ); + if (leading_zero) buffer_append_byte( buffer, 0 ); + buffer_append( buffer, data, len ); +} + +static void buffer_append_asn1_sequence( struct buffer *buffer, struct buffer *content ) +{ + if (content->error) + { + buffer->error = TRUE; + return; + } + + buffer_append_byte( buffer, 0x30 ); /* tag */ + buffer_append_asn1_length( buffer, content->pos ); + buffer_append( buffer, content->buffer, content->pos ); +} + +static void buffer_append_asn1_r_s( struct buffer *buffer, BYTE *r, DWORD r_len, BYTE *s, DWORD s_len ) +{ + struct buffer value; + + buffer_init( &value ); + buffer_append_asn1_integer( &value, r, r_len ); + buffer_append_asn1_integer( &value, s, s_len ); + buffer_append_asn1_sequence( buffer, &value ); + buffer_free( &value ); +} + +static NTSTATUS import_gnutls_pubkey_ecc( struct key *key, gnutls_pubkey_t *gnutls_key ) +{ + BCRYPT_ECCKEY_BLOB *ecc_blob; + gnutls_ecc_curve_t curve; + gnutls_datum_t x, y; + int ret; + + switch (key->alg_id) + { + case ALG_ID_ECDSA_P256: curve = GNUTLS_ECC_CURVE_SECP256R1; break; + case ALG_ID_ECDSA_P384: curve = GNUTLS_ECC_CURVE_SECP384R1; break; + + default: + FIXME( "algorithm %u not yet supported\n", key->alg_id ); + return STATUS_NOT_IMPLEMENTED; + } + + if ((ret = pgnutls_pubkey_init( gnutls_key ))) + { + pgnutls_perror( ret ); + return STATUS_INTERNAL_ERROR; + } + + ecc_blob = (BCRYPT_ECCKEY_BLOB *)key->u.a.pubkey; + x.data = key->u.a.pubkey + sizeof(*ecc_blob); + x.size = ecc_blob->cbKey; + y.data = key->u.a.pubkey + sizeof(*ecc_blob) + ecc_blob->cbKey; + y.size = ecc_blob->cbKey; + + if ((ret = pgnutls_pubkey_import_ecc_raw( *gnutls_key, curve, &x, &y ))) + { + pgnutls_perror( ret ); + pgnutls_pubkey_deinit( *gnutls_key ); + return STATUS_INTERNAL_ERROR; + } + + return STATUS_SUCCESS; +} + +static NTSTATUS import_gnutls_pubkey( struct key *key, gnutls_pubkey_t *gnutls_key ) +{ + switch (key->alg_id) + { + case ALG_ID_ECDSA_P256: + case ALG_ID_ECDSA_P384: + return import_gnutls_pubkey_ecc( key, gnutls_key ); + + default: + FIXME("algorithm %u not yet supported\n", key->alg_id ); + return STATUS_NOT_IMPLEMENTED; + } +} + +static NTSTATUS prepare_gnutls_signature_ecc( struct key *key, UCHAR *signature, ULONG signature_len, + gnutls_datum_t *gnutls_signature ) +{ + struct buffer buffer; + DWORD r_len = signature_len / 2; + DWORD s_len = r_len; + BYTE *r = signature; + BYTE *s = signature + r_len; + + buffer_init( &buffer ); + buffer_append_asn1_r_s( &buffer, r, r_len, s, s_len ); + if (buffer.error) + { + buffer_free( &buffer ); + return STATUS_NO_MEMORY; + } + + gnutls_signature->data = buffer.buffer; + gnutls_signature->size = buffer.pos; + return STATUS_SUCCESS; +} + +static NTSTATUS prepare_gnutls_signature( struct key *key, UCHAR *signature, ULONG signature_len, + gnutls_datum_t *gnutls_signature ) +{ + switch (key->alg_id) + { + case ALG_ID_ECDSA_P256: + case ALG_ID_ECDSA_P384: + return prepare_gnutls_signature_ecc( key, signature, signature_len, gnutls_signature ); + + default: + FIXME( "algorithm %u not yet supported\n", key->alg_id ); + return STATUS_NOT_IMPLEMENTED; + } +} + +static NTSTATUS key_asymmetric_verify( struct key *key, void *padding, UCHAR *hash, ULONG hash_len, + UCHAR *signature, ULONG signature_len, DWORD flags ) +{ + gnutls_digest_algorithm_t hash_alg; + gnutls_sign_algorithm_t sign_alg; + gnutls_datum_t gnutls_hash, gnutls_signature; + gnutls_pk_algorithm_t pk_alg; + gnutls_pubkey_t gnutls_key; + NTSTATUS status; + int ret; + + if (flags) FIXME( "flags %08x not supported\n", flags ); + + /* only the hash size must match, not the actual hash function */ + switch (hash_len) + { + case 32: hash_alg = GNUTLS_DIG_SHA256; break; + case 48: hash_alg = GNUTLS_DIG_SHA384; break; + + default: + FIXME( "hash size %u not yet supported\n", hash_len ); + return STATUS_INVALID_SIGNATURE; + } + + switch (key->alg_id) + { + case ALG_ID_ECDSA_P256: + case ALG_ID_ECDSA_P384: + pk_alg = GNUTLS_PK_ECC; + break; + + default: + FIXME( "algorithm %u not yet supported\n", key->alg_id ); + return STATUS_NOT_IMPLEMENTED; + } + + if ((sign_alg = pgnutls_pk_to_sign( pk_alg, hash_alg )) == GNUTLS_SIGN_UNKNOWN) + { + FIXME("GnuTLS does not support algorithm %u with hash len %u\n", key->alg_id, hash_len ); + return STATUS_NOT_IMPLEMENTED; + } + + if ((status = import_gnutls_pubkey( key, &gnutls_key ))) return status; + if ((status = prepare_gnutls_signature( key, signature, signature_len, &gnutls_signature ))) + { + pgnutls_pubkey_deinit( gnutls_key ); + return status; + } + + gnutls_hash.data = hash; + gnutls_hash.size = hash_len; + ret = pgnutls_pubkey_verify_hash2( gnutls_key, sign_alg, 0, &gnutls_hash, &gnutls_signature ); + + heap_free( gnutls_signature.data ); + pgnutls_pubkey_deinit( gnutls_key ); + return (ret < 0) ? STATUS_INVALID_SIGNATURE : STATUS_SUCCESS; +} + static NTSTATUS key_destroy( struct key *key ) { if (key_is_symmetric( key )) @@ -1227,12 +1531,12 @@ static NTSTATUS key_symmetric_init( struct key *key, struct algorithm *alg, cons case ALG_ID_AES: switch (alg->mode) { - case MODE_ID_ECB: - case MODE_ID_CBC: - break; - default: - FIXME( "mode %u not supported\n", alg->mode ); - return STATUS_NOT_SUPPORTED; + case MODE_ID_ECB: + case MODE_ID_CBC: + break; + default: + FIXME( "mode %u not supported\n", alg->mode ); + return STATUS_NOT_SUPPORTED; } break; @@ -1368,6 +1672,13 @@ static NTSTATUS key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len ) return STATUS_NOT_IMPLEMENTED; } +static NTSTATUS key_asymmetric_verify( struct key *key, void *padding, UCHAR *hash, ULONG hash_len, + UCHAR *signature, ULONG signature_len, DWORD flags ) +{ + FIXME( "not implemented on Mac\n" ); + return STATUS_NOT_IMPLEMENTED; +} + static NTSTATUS key_destroy( struct key *key ) { if (key->u.s.ref_encrypt) CCCryptorRelease( key->u.s.ref_encrypt ); @@ -1433,6 +1744,13 @@ static NTSTATUS key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len ) return STATUS_NOT_IMPLEMENTED; } +static NTSTATUS key_asymmetric_verify( struct key *key, void *padding, UCHAR *hash, ULONG hash_len, + UCHAR *signature, ULONG signature_len, DWORD flags ) +{ + ERR( "support for keys not available at build time\n" ); + return STATUS_NOT_IMPLEMENTED; +} + static NTSTATUS key_destroy( struct key *key ) { ERR( "support for keys not available at build time\n" ); @@ -1637,10 +1955,13 @@ NTSTATUS WINAPI BCryptVerifySignature( BCRYPT_KEY_HANDLE handle, void *padding, { struct key *key = handle; - FIXME( "%p, %p, %p, %u, %p, %u, %08x: stub!\n", handle, padding, hash, hash_len, signature, signature_len, flags ); + TRACE( "%p, %p, %p, %u, %p, %u, %08x\n", handle, padding, hash, hash_len, signature, signature_len, flags ); if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE; - return STATUS_NOT_IMPLEMENTED; + if (!hash || !hash_len || !signature || !signature_len) return STATUS_INVALID_PARAMETER; + if (key_is_symmetric( key )) return STATUS_NOT_SUPPORTED; + + return key_asymmetric_verify( key, padding, hash, hash_len, signature, signature_len, flags ); } NTSTATUS WINAPI BCryptDestroyKey( BCRYPT_KEY_HANDLE handle ) diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index fa244d1924..57d04882b5 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -1486,10 +1486,10 @@ static void test_ECDSA(void) ok(!status, "BCryptImportKeyPair failed: %08x\n", status); status = pBCryptVerifySignature(key, NULL, certHash, sizeof(certHash) - 1, certSignature, sizeof(certSignature), 0); - todo_wine ok(status == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %08x\n", status); + ok(status == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %08x\n", status); status = pBCryptVerifySignature(key, NULL, certHash, sizeof(certHash), certSignature, sizeof(certSignature), 0); - todo_wine ok(!status, "BCryptVerifySignature failed: %08x\n", status); + ok(!status, "BCryptVerifySignature failed: %08x\n", status); pBCryptDestroyKey(key); pBCryptCloseAlgorithmProvider(alg, 0); -- 2.11.0

1 0

[PATCH 2/5] bcrypt: Implement importing of ECDSA keys.
by Hans Leidekker 26 Mar '18

26 Mar '18

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/bcrypt/bcrypt.spec | 4 +- dlls/bcrypt/bcrypt_main.c | 173 +++++++++++++++++++++++++++++++++++++++++---- dlls/bcrypt/tests/bcrypt.c | 4 +- dlls/ncrypt/ncrypt.spec | 4 +- include/bcrypt.h | 2 + 5 files changed, 167 insertions(+), 20 deletions(-) diff --git a/dlls/bcrypt/bcrypt.spec b/dlls/bcrypt/bcrypt.spec index 28c2394ce4..78824d73b3 100644 --- a/dlls/bcrypt/bcrypt.spec +++ b/dlls/bcrypt/bcrypt.spec @@ -32,7 +32,7 @@ @ stdcall BCryptHash(ptr ptr long ptr long ptr long) @ stdcall BCryptHashData(ptr ptr long long) @ stdcall BCryptImportKey(ptr ptr wstr ptr ptr long ptr long long) -@ stub BCryptImportKeyPair +@ stdcall BCryptImportKeyPair(ptr ptr wstr ptr ptr long long) @ stdcall BCryptOpenAlgorithmProvider(ptr wstr wstr long) @ stub BCryptQueryContextConfiguration @ stub BCryptQueryContextFunctionConfiguration @@ -50,7 +50,7 @@ @ stub BCryptSignHash @ stub BCryptUnregisterConfigChangeNotify @ stdcall BCryptUnregisterProvider(wstr) -@ stub BCryptVerifySignature +@ stdcall BCryptVerifySignature(ptr ptr ptr long ptr long long) @ stub GetAsymmetricEncryptionInterface @ stub GetCipherInterface @ stub GetHashInterface diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index 57cb3632d5..82a742cbc0 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -220,7 +220,9 @@ enum alg_id ALG_ID_SHA1, ALG_ID_SHA256, ALG_ID_SHA384, - ALG_ID_SHA512 + ALG_ID_SHA512, + ALG_ID_ECDSA_P256, + ALG_ID_ECDSA_P384, }; enum mode_id @@ -251,7 +253,9 @@ alg_props[] = /* ALG_ID_SHA1 */ { 278, 20, 512, BCRYPT_SHA1_ALGORITHM, FALSE }, /* ALG_ID_SHA256 */ { 286, 32, 512, BCRYPT_SHA256_ALGORITHM, FALSE }, /* ALG_ID_SHA384 */ { 382, 48, 1024, BCRYPT_SHA384_ALGORITHM, FALSE }, - /* ALG_ID_SHA512 */ { 382, 64, 1024, BCRYPT_SHA512_ALGORITHM, FALSE } + /* ALG_ID_SHA512 */ { 382, 64, 1024, BCRYPT_SHA512_ALGORITHM, FALSE }, + /* ALG_ID_ECDSA_P256 */ { 0, 0, 0, BCRYPT_ECDSA_P256_ALGORITHM, FALSE }, + /* ALG_ID_ECDSA_P384 */ { 0, 0, 0, BCRYPT_ECDSA_P384_ALGORITHM, FALSE }, }; struct algorithm @@ -327,6 +331,8 @@ NTSTATUS WINAPI BCryptOpenAlgorithmProvider( BCRYPT_ALG_HANDLE *handle, LPCWSTR else if (!strcmpW( id, BCRYPT_SHA256_ALGORITHM )) alg_id = ALG_ID_SHA256; else if (!strcmpW( id, BCRYPT_SHA384_ALGORITHM )) alg_id = ALG_ID_SHA384; else if (!strcmpW( id, BCRYPT_SHA512_ALGORITHM )) alg_id = ALG_ID_SHA512; + else if (!strcmpW( id, BCRYPT_ECDSA_P256_ALGORITHM )) alg_id = ALG_ID_ECDSA_P256; + else if (!strcmpW( id, BCRYPT_ECDSA_P384_ALGORITHM )) alg_id = ALG_ID_ECDSA_P384; else { FIXME( "algorithm %s not supported\n", debugstr_w(id) ); @@ -869,6 +875,12 @@ struct key_symmetric ULONG secret_len; }; +struct key_asymmetric +{ + UCHAR *pubkey; + ULONG pubkey_len; +}; + struct key { struct object hdr; @@ -876,6 +888,7 @@ struct key union { struct key_symmetric s; + struct key_asymmetric a; } u; }; @@ -890,6 +903,12 @@ struct key_symmetric ULONG secret_len; }; +struct key_asymmetric +{ + UCHAR *pubkey; + ULONG pubkey_len; +}; + struct key { struct object hdr; @@ -897,6 +916,7 @@ struct key union { struct key_symmetric s; + struct key_asymmetric a; } u; }; #else @@ -954,18 +974,28 @@ static NTSTATUS key_duplicate( struct key *key_orig, struct key *key_copy ) { UCHAR *buffer; - if (!key_is_symmetric( key_orig )) return STATUS_NOT_IMPLEMENTED; + memset( key_copy, 0, sizeof(*key_copy) ); + key_copy->hdr = key_orig->hdr; + key_copy->alg_id = key_orig->alg_id; - if (!(buffer = heap_alloc( key_orig->u.s.secret_len ))) return STATUS_NO_MEMORY; - memcpy( buffer, key_orig->u.s.secret, key_orig->u.s.secret_len ); + if (key_is_symmetric( key_orig )) + { + if (!(buffer = heap_alloc( key_orig->u.s.secret_len ))) return STATUS_NO_MEMORY; + memcpy( buffer, key_orig->u.s.secret, key_orig->u.s.secret_len ); - memset( key_copy, 0, sizeof(*key_copy) ); - key_copy->hdr = key_orig->hdr; - key_copy->alg_id = key_orig->alg_id; - key_copy->u.s.mode = key_orig->u.s.mode; - key_copy->u.s.block_size = key_orig->u.s.block_size; - key_copy->u.s.secret = buffer; - key_copy->u.s.secret_len = key_orig->u.s.secret_len; + key_copy->u.s.mode = key_orig->u.s.mode; + key_copy->u.s.block_size = key_orig->u.s.block_size; + key_copy->u.s.secret = buffer; + key_copy->u.s.secret_len = key_orig->u.s.secret_len; + } + else + { + if (!(buffer = heap_alloc( key_orig->u.a.pubkey_len ))) return STATUS_NO_MEMORY; + memcpy( buffer, key_orig->u.a.pubkey, key_orig->u.a.pubkey_len ); + + key_copy->u.a.pubkey = buffer; + key_copy->u.a.pubkey_len = key_orig->u.a.pubkey_len; + } return STATUS_SUCCESS; } @@ -1149,10 +1179,41 @@ static NTSTATUS key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len ) return STATUS_SUCCESS; } +static NTSTATUS key_asymmetric_init( struct key *key, struct algorithm *alg, const UCHAR *pubkey, ULONG pubkey_len ) +{ + UCHAR *buffer; + + if (!libgnutls_handle) return STATUS_INTERNAL_ERROR; + + switch (alg->id) + { + case ALG_ID_ECDSA_P256: + case ALG_ID_ECDSA_P384: + break; + + default: + FIXME( "algorithm %u not supported\n", alg->id ); + return STATUS_NOT_SUPPORTED; + } + + if (!(buffer = heap_alloc( pubkey_len ))) return STATUS_NO_MEMORY; + memcpy( buffer, pubkey, pubkey_len ); + + key->alg_id = alg->id; + key->u.a.pubkey = buffer; + key->u.a.pubkey_len = pubkey_len; + + return STATUS_SUCCESS; +} + static NTSTATUS key_destroy( struct key *key ) { - if (key->u.s.handle) pgnutls_cipher_deinit( key->u.s.handle ); - heap_free( key->u.s.secret ); + if (key_is_symmetric( key )) + { + if (key->u.s.handle) pgnutls_cipher_deinit( key->u.s.handle ); + heap_free( key->u.s.secret ); + } + else heap_free( key->u.a.pubkey ); heap_free( key ); return STATUS_SUCCESS; } @@ -1315,6 +1376,12 @@ static NTSTATUS key_destroy( struct key *key ) heap_free( key ); return STATUS_SUCCESS; } + +static NTSTATUS key_asymmetric_init( struct key *key, struct algorithm *alg, const UCHAR *pubkey, ULONG pubkey_len ) +{ + FIXME( "not implemented on Mac\n" ); + return STATUS_NOT_IMPLEMENTED; +} #else static NTSTATUS key_symmetric_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) { @@ -1383,6 +1450,12 @@ static inline BOOL key_is_symmetric( struct key *key ) ERR( "support for keys not available at build time\n" ); return FALSE; } + +static NTSTATUS key_asymmetric_init( struct key *key, struct algorithm *alg, const UCHAR *pubkey, ULONG pubkey_len ) +{ + ERR( "support for keys not available at build time\n" ); + return STATUS_NOT_IMPLEMENTED; +} #endif NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle, @@ -1498,6 +1571,78 @@ NTSTATUS WINAPI BCryptDuplicateKey( BCRYPT_KEY_HANDLE handle, BCRYPT_KEY_HANDLE return STATUS_SUCCESS; } +NTSTATUS WINAPI BCryptImportKeyPair( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE decrypt_key, const WCHAR *type, + BCRYPT_KEY_HANDLE *ret_key, UCHAR *input, ULONG input_len, ULONG flags ) +{ + struct algorithm *alg = algorithm; + NTSTATUS status; + struct key *key; + + TRACE( "%p, %p, %s, %p, %p, %u, %08x\n", algorithm, decrypt_key, debugstr_w(type), ret_key, input, + input_len, flags ); + + if (!alg || alg->hdr.magic != MAGIC_ALG) return STATUS_INVALID_HANDLE; + if (!ret_key || !type || !input) return STATUS_INVALID_PARAMETER; + if (decrypt_key) + { + FIXME( "decryption of key not yet supported\n" ); + return STATUS_NOT_IMPLEMENTED; + } + + if (!strcmpW( type, BCRYPT_ECCPUBLIC_BLOB )) + { + BCRYPT_ECCKEY_BLOB *ecc_blob = (BCRYPT_ECCKEY_BLOB *)input; + DWORD key_size, magic; + + if (input_len < sizeof(*ecc_blob)) return STATUS_INVALID_PARAMETER; + + switch (alg->id) + { + case ALG_ID_ECDSA_P256: + key_size = 32; + magic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC; + break; + + case ALG_ID_ECDSA_P384: + key_size = 48; + magic = BCRYPT_ECDSA_PUBLIC_P384_MAGIC; + break; + + default: + FIXME( "algorithm %u does not yet support importing blob of type %s\n", alg->id, debugstr_w(type) ); + return STATUS_NOT_SUPPORTED; + } + + if (ecc_blob->dwMagic != magic) return STATUS_NOT_SUPPORTED; + if (ecc_blob->cbKey != key_size) return STATUS_INVALID_PARAMETER; + + if (!(key = heap_alloc( sizeof(*key) ))) return STATUS_NO_MEMORY; + key->hdr.magic = MAGIC_KEY; + if ((status = key_asymmetric_init( key, alg, (BYTE *)ecc_blob, sizeof(*ecc_blob) + ecc_blob->cbKey * 2 ))) + { + heap_free( key ); + return status; + } + + *ret_key = key; + return STATUS_SUCCESS; + } + + FIXME( "unsupported key type %s\n", debugstr_w(type) ); + return STATUS_NOT_SUPPORTED; +} + +NTSTATUS WINAPI BCryptVerifySignature( BCRYPT_KEY_HANDLE handle, void *padding, UCHAR *hash, ULONG hash_len, + UCHAR *signature, ULONG signature_len, ULONG flags ) +{ + struct key *key = handle; + + FIXME( "%p, %p, %p, %u, %p, %u, %08x: stub!\n", handle, padding, hash, hash_len, signature, signature_len, flags ); + + if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE; + return STATUS_NOT_IMPLEMENTED; +} + NTSTATUS WINAPI BCryptDestroyKey( BCRYPT_KEY_HANDLE handle ) { struct key *key = handle; diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index 57d04882b5..fa244d1924 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -1486,10 +1486,10 @@ static void test_ECDSA(void) ok(!status, "BCryptImportKeyPair failed: %08x\n", status); status = pBCryptVerifySignature(key, NULL, certHash, sizeof(certHash) - 1, certSignature, sizeof(certSignature), 0); - ok(status == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %08x\n", status); + todo_wine ok(status == STATUS_INVALID_SIGNATURE, "Expected STATUS_INVALID_SIGNATURE, got %08x\n", status); status = pBCryptVerifySignature(key, NULL, certHash, sizeof(certHash), certSignature, sizeof(certSignature), 0); - ok(!status, "BCryptVerifySignature failed: %08x\n", status); + todo_wine ok(!status, "BCryptVerifySignature failed: %08x\n", status); pBCryptDestroyKey(key); pBCryptCloseAlgorithmProvider(alg, 0); diff --git a/dlls/ncrypt/ncrypt.spec b/dlls/ncrypt/ncrypt.spec index d0f0f56cc4..e7b12e0059 100644 --- a/dlls/ncrypt/ncrypt.spec +++ b/dlls/ncrypt/ncrypt.spec @@ -34,7 +34,7 @@ @ stdcall BCryptHash(ptr ptr long ptr long ptr long) bcrypt.BCryptHash @ stdcall BCryptHashData(ptr ptr long long) bcrypt.BCryptHashData @ stdcall BCryptImportKey(ptr ptr wstr ptr ptr long ptr long long) bcrypt.BCryptImportKey -@ stub BCryptImportKeyPair +@ stdcall BCryptImportKeyPair(ptr ptr wstr ptr ptr long long) bcrypt.BCryptImportKeyPair @ stub BCryptKeyDerivation @ stdcall BCryptOpenAlgorithmProvider(ptr wstr wstr long) bcrypt.BCryptOpenAlgorithmProvider @ stub BCryptQueryContextConfiguration @@ -53,7 +53,7 @@ @ stub BCryptSignHash @ stub BCryptUnregisterConfigChangeNotify @ stdcall BCryptUnregisterProvider(wstr) bcrypt.BCryptUnregisterProvider -@ stub BCryptVerifySignature +@ stdcall BCryptVerifySignature(ptr ptr ptr long ptr long long) bcrypt.BCryptVerifySignature @ stub GetIsolationServerInterface @ stub GetKeyStorageInterface @ stub GetSChannelInterface diff --git a/include/bcrypt.h b/include/bcrypt.h index 717d77c731..f28b0d395d 100644 --- a/include/bcrypt.h +++ b/include/bcrypt.h @@ -211,8 +211,10 @@ NTSTATUS WINAPI BCryptGetFipsAlgorithmMode(BOOLEAN *); NTSTATUS WINAPI BCryptGetProperty(BCRYPT_HANDLE, LPCWSTR, PUCHAR, ULONG, ULONG *, ULONG); NTSTATUS WINAPI BCryptHash(BCRYPT_ALG_HANDLE, PUCHAR, ULONG, PUCHAR, ULONG, PUCHAR, ULONG); NTSTATUS WINAPI BCryptHashData(BCRYPT_HASH_HANDLE, PUCHAR, ULONG, ULONG); +NTSTATUS WINAPI BCryptImportKeyPair(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, BCRYPT_KEY_HANDLE *, UCHAR *, ULONG, ULONG); NTSTATUS WINAPI BCryptOpenAlgorithmProvider(BCRYPT_ALG_HANDLE *, LPCWSTR, LPCWSTR, ULONG); NTSTATUS WINAPI BCryptSetProperty(BCRYPT_HANDLE, LPCWSTR, PUCHAR, ULONG, ULONG); NTSTATUS WINAPI BCryptDuplicateHash(BCRYPT_HASH_HANDLE, BCRYPT_HASH_HANDLE *, UCHAR *, ULONG, ULONG); +NTSTATUS WINAPI BCryptVerifySignature(BCRYPT_KEY_HANDLE, void *, UCHAR *, ULONG, UCHAR *, ULONG, ULONG); #endif /* __WINE_BCRYPT_H */ -- 2.11.0

1 0

[PATCH 1/5] bcrypt: Preparation for asymmetric keys.
by Hans Leidekker 26 Mar '18

26 Mar '18

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Hans Leidekker <hans(a)codeweavers.com> --- dlls/bcrypt/bcrypt_main.c | 395 ++++++++++++++++++++++++++-------------------- 1 file changed, 223 insertions(+), 172 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index 69d5129a7d..57cb3632d5 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -233,21 +233,25 @@ enum mode_id #define MAX_HASH_OUTPUT_BYTES 64 #define MAX_HASH_BLOCK_BITS 1024 -static const struct { - ULONG object_length; - ULONG hash_length; - ULONG block_bits; +static const struct +{ + ULONG object_length; + ULONG hash_length; + ULONG block_bits; const WCHAR *alg_name; -} alg_props[] = { - /* ALG_ID_AES */ { 654, 0, 0, BCRYPT_AES_ALGORITHM }, - /* ALG_ID_MD2 */ { 270, 16, 128, BCRYPT_MD2_ALGORITHM }, - /* ALG_ID_MD4 */ { 270, 16, 512, BCRYPT_MD4_ALGORITHM }, - /* ALG_ID_MD5 */ { 274, 16, 512, BCRYPT_MD5_ALGORITHM }, - /* ALG_ID_RNG */ { 0, 0, 0, BCRYPT_RNG_ALGORITHM }, - /* ALG_ID_SHA1 */ { 278, 20, 512, BCRYPT_SHA1_ALGORITHM }, - /* ALG_ID_SHA256 */ { 286, 32, 512, BCRYPT_SHA256_ALGORITHM }, - /* ALG_ID_SHA384 */ { 382, 48, 1024, BCRYPT_SHA384_ALGORITHM }, - /* ALG_ID_SHA512 */ { 382, 64, 1024, BCRYPT_SHA512_ALGORITHM } + BOOL symmetric; +} +alg_props[] = +{ + /* ALG_ID_AES */ { 654, 0, 0, BCRYPT_AES_ALGORITHM, TRUE }, + /* ALG_ID_MD2 */ { 270, 16, 128, BCRYPT_MD2_ALGORITHM, FALSE }, + /* ALG_ID_MD4 */ { 270, 16, 512, BCRYPT_MD4_ALGORITHM, FALSE }, + /* ALG_ID_MD5 */ { 274, 16, 512, BCRYPT_MD5_ALGORITHM, FALSE }, + /* ALG_ID_RNG */ { 0, 0, 0, BCRYPT_RNG_ALGORITHM, FALSE }, + /* ALG_ID_SHA1 */ { 278, 20, 512, BCRYPT_SHA1_ALGORITHM, FALSE }, + /* ALG_ID_SHA256 */ { 286, 32, 512, BCRYPT_SHA256_ALGORITHM, FALSE }, + /* ALG_ID_SHA384 */ { 382, 48, 1024, BCRYPT_SHA384_ALGORITHM, FALSE }, + /* ALG_ID_SHA512 */ { 382, 64, 1024, BCRYPT_SHA512_ALGORITHM, FALSE } }; struct algorithm @@ -856,21 +860,28 @@ NTSTATUS WINAPI BCryptHash( BCRYPT_ALG_HANDLE algorithm, UCHAR *secret, ULONG se } #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) +struct key_symmetric +{ + enum mode_id mode; + ULONG block_size; + gnutls_cipher_hd_t handle; + UCHAR *secret; + ULONG secret_len; +}; + struct key { - struct object hdr; - enum alg_id alg_id; - enum mode_id mode; - ULONG block_size; - gnutls_cipher_hd_t handle; - UCHAR *secret; - ULONG secret_len; + struct object hdr; + enum alg_id alg_id; + union + { + struct key_symmetric s; + } u; }; + #elif defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 -struct key +struct key_symmetric { - struct object hdr; - enum alg_id alg_id; enum mode_id mode; ULONG block_size; CCCryptorRef ref_encrypt; @@ -878,16 +889,39 @@ struct key UCHAR *secret; ULONG secret_len; }; -#else + struct key { struct object hdr; + enum alg_id alg_id; + union + { + struct key_symmetric s; + } u; +}; +#else +struct key_symmetric +{ enum mode_id mode; ULONG block_size; }; + +struct key +{ + struct object hdr; + union + { + struct key_symmetric s; + } u; +}; #endif #if defined(HAVE_GNUTLS_CIPHER_INIT) || defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 +static inline BOOL key_is_symmetric( struct key *key ) +{ + return alg_props[key->alg_id].symmetric; +} + static ULONG get_block_size( struct algorithm *alg ) { ULONG ret = 0, size = sizeof(ret); @@ -900,15 +934,15 @@ static NTSTATUS key_export( struct key *key, const WCHAR *type, UCHAR *output, U if (!strcmpW( type, BCRYPT_KEY_DATA_BLOB )) { BCRYPT_KEY_DATA_BLOB_HEADER *header = (BCRYPT_KEY_DATA_BLOB_HEADER *)output; - ULONG req_size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->secret_len; + ULONG req_size = sizeof(BCRYPT_KEY_DATA_BLOB_HEADER) + key->u.s.secret_len; *size = req_size; if (output_len < req_size) return STATUS_BUFFER_TOO_SMALL; header->dwMagic = BCRYPT_KEY_DATA_BLOB_MAGIC; header->dwVersion = BCRYPT_KEY_DATA_BLOB_VERSION1; - header->cbKeyData = key->secret_len; - memcpy( &header[1], key->secret, key->secret_len ); + header->cbKeyData = key->u.s.secret_len; + memcpy( &header[1], key->u.s.secret, key->u.s.secret_len ); return STATUS_SUCCESS; } @@ -920,23 +954,25 @@ static NTSTATUS key_duplicate( struct key *key_orig, struct key *key_copy ) { UCHAR *buffer; - if (!(buffer = heap_alloc( key_orig->secret_len ))) return STATUS_NO_MEMORY; - memcpy( buffer, key_orig->secret, key_orig->secret_len ); + if (!key_is_symmetric( key_orig )) return STATUS_NOT_IMPLEMENTED; + + if (!(buffer = heap_alloc( key_orig->u.s.secret_len ))) return STATUS_NO_MEMORY; + memcpy( buffer, key_orig->u.s.secret, key_orig->u.s.secret_len ); memset( key_copy, 0, sizeof(*key_copy) ); - key_copy->hdr = key_orig->hdr; - key_copy->alg_id = key_orig->alg_id; - key_copy->mode = key_orig->mode; - key_copy->block_size = key_orig->block_size; - key_copy->secret = buffer; - key_copy->secret_len = key_orig->secret_len; + key_copy->hdr = key_orig->hdr; + key_copy->alg_id = key_orig->alg_id; + key_copy->u.s.mode = key_orig->u.s.mode; + key_copy->u.s.block_size = key_orig->u.s.block_size; + key_copy->u.s.secret = buffer; + key_copy->u.s.secret_len = key_orig->u.s.secret_len; return STATUS_SUCCESS; } #endif #if defined(HAVE_GNUTLS_CIPHER_INIT) && !defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) -static NTSTATUS key_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) +static NTSTATUS key_symmetric_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) { UCHAR *buffer; @@ -952,15 +988,15 @@ static NTSTATUS key_init( struct key *key, struct algorithm *alg, const UCHAR *s return STATUS_NOT_SUPPORTED; } - if (!(key->block_size = get_block_size( alg ))) return STATUS_INVALID_PARAMETER; + if (!(key->u.s.block_size = get_block_size( alg ))) return STATUS_INVALID_PARAMETER; if (!(buffer = heap_alloc( secret_len ))) return STATUS_NO_MEMORY; memcpy( buffer, secret, secret_len ); - key->alg_id = alg->id; - key->mode = alg->mode; - key->handle = 0; /* initialized on first use */ - key->secret = buffer; - key->secret_len = secret_len; + key->alg_id = alg->id; + key->u.s.mode = alg->mode; + key->u.s.handle = 0; /* initialized on first use */ + key->u.s.secret = buffer; + key->u.s.secret_len = secret_len; return STATUS_SUCCESS; } @@ -971,17 +1007,17 @@ static NTSTATUS set_key_property( struct key *key, const WCHAR *prop, UCHAR *val { if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) { - key->mode = MODE_ID_ECB; + key->u.s.mode = MODE_ID_ECB; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { - key->mode = MODE_ID_CBC; + key->u.s.mode = MODE_ID_CBC; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM, size )) { - key->mode = MODE_ID_GCM; + key->u.s.mode = MODE_ID_GCM; return STATUS_SUCCESS; } else @@ -1001,53 +1037,54 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) { case ALG_ID_AES: WARN( "handle block size\n" ); - switch (key->mode) + switch (key->u.s.mode) { - case MODE_ID_GCM: - if (key->secret_len == 16) return GNUTLS_CIPHER_AES_128_GCM; - if (key->secret_len == 32) return GNUTLS_CIPHER_AES_256_GCM; - break; - case MODE_ID_ECB: /* can be emulated with CBC + empty IV */ - case MODE_ID_CBC: - if (key->secret_len == 16) return GNUTLS_CIPHER_AES_128_CBC; - if (key->secret_len == 24) return GNUTLS_CIPHER_AES_192_CBC; - if (key->secret_len == 32) return GNUTLS_CIPHER_AES_256_CBC; - break; - default: - break; + case MODE_ID_GCM: + if (key->u.s.secret_len == 16) return GNUTLS_CIPHER_AES_128_GCM; + if (key->u.s.secret_len == 32) return GNUTLS_CIPHER_AES_256_GCM; + break; + case MODE_ID_ECB: /* can be emulated with CBC + empty IV */ + case MODE_ID_CBC: + if (key->u.s.secret_len == 16) return GNUTLS_CIPHER_AES_128_CBC; + if (key->u.s.secret_len == 24) return GNUTLS_CIPHER_AES_192_CBC; + if (key->u.s.secret_len == 32) return GNUTLS_CIPHER_AES_256_CBC; + break; + default: + break; } - FIXME( "aes mode %u with key length %u not supported\n", key->mode, key->secret_len ); + FIXME( "AES mode %u with key length %u not supported\n", key->u.s.mode, key->u.s.secret_len ); return GNUTLS_CIPHER_UNKNOWN; + default: FIXME( "algorithm %u not supported\n", key->alg_id ); return GNUTLS_CIPHER_UNKNOWN; } } -static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) +static NTSTATUS key_symmetric_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) { gnutls_cipher_algorithm_t cipher; gnutls_datum_t secret, vector; int ret; - if (key->handle) + if (key->u.s.handle) { - pgnutls_cipher_deinit( key->handle ); - key->handle = NULL; + pgnutls_cipher_deinit( key->u.s.handle ); + key->u.s.handle = NULL; } if ((cipher = get_gnutls_cipher( key )) == GNUTLS_CIPHER_UNKNOWN) return STATUS_NOT_SUPPORTED; - secret.data = key->secret; - secret.size = key->secret_len; + secret.data = key->u.s.secret; + secret.size = key->u.s.secret_len; if (iv) { vector.data = iv; vector.size = iv_len; } - if ((ret = pgnutls_cipher_init( &key->handle, cipher, &secret, iv ? &vector : NULL ))) + if ((ret = pgnutls_cipher_init( &key->u.s.handle, cipher, &secret, iv ? &vector : NULL ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1056,11 +1093,13 @@ static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) return STATUS_SUCCESS; } -static NTSTATUS key_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len ) +static NTSTATUS key_symmetric_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len ) { int ret; - if ((ret = pgnutls_cipher_add_auth( key->handle, auth_data, len ))) + if (!auth_data) return STATUS_SUCCESS; + + if ((ret = pgnutls_cipher_add_auth( key->u.s.handle, auth_data, len ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1069,12 +1108,12 @@ static NTSTATUS key_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len return STATUS_SUCCESS; } -static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, - ULONG output_len ) +static NTSTATUS key_symmetric_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, + ULONG output_len ) { int ret; - if ((ret = pgnutls_cipher_encrypt2( key->handle, input, input_len, output, output_len ))) + if ((ret = pgnutls_cipher_encrypt2( key->u.s.handle, input, input_len, output, output_len ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1083,12 +1122,12 @@ static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_le return STATUS_SUCCESS; } -static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, - ULONG output_len ) +static NTSTATUS key_symmetric_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, + ULONG output_len ) { int ret; - if ((ret = pgnutls_cipher_decrypt2( key->handle, input, input_len, output, output_len ))) + if ((ret = pgnutls_cipher_decrypt2( key->u.s.handle, input, input_len, output, output_len ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1097,11 +1136,11 @@ static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_le return STATUS_SUCCESS; } -static NTSTATUS key_get_tag( struct key *key, UCHAR *tag, ULONG len ) +static NTSTATUS key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len ) { int ret; - if ((ret = pgnutls_cipher_tag( key->handle, tag, len ))) + if ((ret = pgnutls_cipher_tag( key->u.s.handle, tag, len ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1112,13 +1151,13 @@ static NTSTATUS key_get_tag( struct key *key, UCHAR *tag, ULONG len ) static NTSTATUS key_destroy( struct key *key ) { - if (key->handle) pgnutls_cipher_deinit( key->handle ); - heap_free( key->secret ); + if (key->u.s.handle) pgnutls_cipher_deinit( key->u.s.handle ); + heap_free( key->u.s.secret ); heap_free( key ); return STATUS_SUCCESS; } #elif defined(HAVE_COMMONCRYPTO_COMMONCRYPTOR_H) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1080 -static NTSTATUS key_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) +static NTSTATUS key_symmetric_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) { UCHAR *buffer; @@ -1141,16 +1180,16 @@ static NTSTATUS key_init( struct key *key, struct algorithm *alg, const UCHAR *s return STATUS_NOT_SUPPORTED; } - if (!(key->block_size = get_block_size( alg ))) return STATUS_INVALID_PARAMETER; + if (!(key->u.s.block_size = get_block_size( alg ))) return STATUS_INVALID_PARAMETER; if (!(buffer = heap_alloc( secret_len ))) return STATUS_NO_MEMORY; memcpy( buffer, secret, secret_len ); - key->alg_id = alg->id; - key->mode = alg->mode; - key->ref_encrypt = NULL; /* initialized on first use */ - key->ref_decrypt = NULL; - key->secret = buffer; - key->secret_len = secret_len; + key->alg_id = alg->id; + key->u.s.mode = alg->mode; + key->u.s.ref_encrypt = NULL; /* initialized on first use */ + key->u.s.ref_decrypt = NULL; + key->u.s.secret = buffer; + key->u.s.secret_len = secret_len; return STATUS_SUCCESS; } @@ -1161,12 +1200,12 @@ static NTSTATUS set_key_property( struct key *key, const WCHAR *prop, UCHAR *val { if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) { - key->mode = MODE_ID_ECB; + key->u.s.mode = MODE_ID_ECB; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { - key->mode = MODE_ID_CBC; + key->u.s.mode = MODE_ID_CBC; return STATUS_SUCCESS; } else @@ -1182,64 +1221,64 @@ static NTSTATUS set_key_property( struct key *key, const WCHAR *prop, UCHAR *val static CCMode get_cryptor_mode( struct key *key ) { - switch (key->mode) + switch (key->u.s.mode) { case MODE_ID_ECB: return kCCModeECB; case MODE_ID_CBC: return kCCModeCBC; default: - FIXME( "unsupported mode %u\n", key->mode ); + FIXME( "unsupported mode %u\n", key->u.s.mode ); return 0; } } -static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) +static NTSTATUS key_symmetric_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) { CCCryptorStatus status; CCMode mode; if (!(mode = get_cryptor_mode( key ))) return STATUS_NOT_SUPPORTED; - if (key->ref_encrypt) + if (key->u.s.ref_encrypt) { - CCCryptorRelease( key->ref_encrypt ); - key->ref_encrypt = NULL; + CCCryptorRelease( key->u.s.ref_encrypt ); + key->u.s.ref_encrypt = NULL; } - if (key->ref_decrypt) + if (key->u.s.ref_decrypt) { - CCCryptorRelease( key->ref_decrypt ); - key->ref_decrypt = NULL; + CCCryptorRelease( key->u.s.ref_decrypt ); + key->u.s.ref_decrypt = NULL; } - if ((status = CCCryptorCreateWithMode( kCCEncrypt, mode, kCCAlgorithmAES128, ccNoPadding, iv, key->secret, - key->secret_len, NULL, 0, 0, 0, &key->ref_encrypt )) != kCCSuccess) + if ((status = CCCryptorCreateWithMode( kCCEncrypt, mode, kCCAlgorithmAES128, ccNoPadding, iv, key->u.s.secret, + key->u.s.secret_len, NULL, 0, 0, 0, &key->u.s.ref_encrypt )) != kCCSuccess) { WARN( "CCCryptorCreateWithMode failed %d\n", status ); return STATUS_INTERNAL_ERROR; } - if ((status = CCCryptorCreateWithMode( kCCDecrypt, mode, kCCAlgorithmAES128, ccNoPadding, iv, key->secret, - key->secret_len, NULL, 0, 0, 0, &key->ref_decrypt )) != kCCSuccess) + if ((status = CCCryptorCreateWithMode( kCCDecrypt, mode, kCCAlgorithmAES128, ccNoPadding, iv, key->u.s.secret, + key->u.s.secret_len, NULL, 0, 0, 0, &key->u.s.ref_decrypt )) != kCCSuccess) { WARN( "CCCryptorCreateWithMode failed %d\n", status ); - CCCryptorRelease( key->ref_encrypt ); - key->ref_encrypt = NULL; + CCCryptorRelease( key->u.s.ref_encrypt ); + key->u.s.ref_encrypt = NULL; return STATUS_INTERNAL_ERROR; } return STATUS_SUCCESS; } -static NTSTATUS key_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len ) +static NTSTATUS key_symmetric_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len ) { FIXME( "not implemented on Mac\n" ); return STATUS_NOT_IMPLEMENTED; } -static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, - ULONG output_len ) +static NTSTATUS key_symmetric_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, + ULONG output_len ) { CCCryptorStatus status; - if ((status = CCCryptorUpdate( key->ref_encrypt, input, input_len, output, output_len, NULL )) != kCCSuccess) + if ((status = CCCryptorUpdate( key->u.s.ref_encrypt, input, input_len, output, output_len, NULL )) != kCCSuccess) { WARN( "CCCryptorUpdate failed %d\n", status ); return STATUS_INTERNAL_ERROR; @@ -1248,12 +1287,12 @@ static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_le return STATUS_SUCCESS; } -static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, - ULONG output_len ) +static NTSTATUS key_symmetric_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, + ULONG output_len ) { CCCryptorStatus status; - if ((status = CCCryptorUpdate( key->ref_decrypt, input, input_len, output, output_len, NULL )) != kCCSuccess) + if ((status = CCCryptorUpdate( key->u.s.ref_decrypt, input, input_len, output, output_len, NULL )) != kCCSuccess) { WARN( "CCCryptorUpdate failed %d\n", status ); return STATUS_INTERNAL_ERROR; @@ -1262,7 +1301,7 @@ static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_le return STATUS_SUCCESS; } -static NTSTATUS key_get_tag( struct key *key, UCHAR *tag, ULONG len ) +static NTSTATUS key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len ) { FIXME( "not implemented on Mac\n" ); return STATUS_NOT_IMPLEMENTED; @@ -1270,14 +1309,14 @@ static NTSTATUS key_get_tag( struct key *key, UCHAR *tag, ULONG len ) static NTSTATUS key_destroy( struct key *key ) { - if (key->ref_encrypt) CCCryptorRelease( key->ref_encrypt ); - if (key->ref_decrypt) CCCryptorRelease( key->ref_decrypt ); - heap_free( key->secret ); + if (key->u.s.ref_encrypt) CCCryptorRelease( key->u.s.ref_encrypt ); + if (key->u.s.ref_decrypt) CCCryptorRelease( key->u.s.ref_decrypt ); + heap_free( key->u.s.secret ); heap_free( key ); return STATUS_SUCCESS; } #else -static NTSTATUS key_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) +static NTSTATUS key_symmetric_init( struct key *key, struct algorithm *alg, const UCHAR *secret, ULONG secret_len ) { ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; @@ -1295,33 +1334,33 @@ static NTSTATUS key_duplicate( struct key *key_orig, struct key *key_copy ) return STATUS_NOT_IMPLEMENTED; } -static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) +static NTSTATUS key_symmetric_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) { ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; } -static NTSTATUS key_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len ) +static NTSTATUS key_symmetric_set_auth_data( struct key *key, UCHAR *auth_data, ULONG len ) { ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; } -static NTSTATUS key_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, - ULONG output_len ) +static NTSTATUS key_symmetric_encrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, + ULONG output_len ) { ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; } -static NTSTATUS key_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, - ULONG output_len ) +static NTSTATUS key_symmetric_decrypt( struct key *key, const UCHAR *input, ULONG input_len, UCHAR *output, + ULONG output_len ) { ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; } -static NTSTATUS key_get_tag( struct key *key, UCHAR *tag, ULONG len ) +static NTSTATUS key_symmetric_get_tag( struct key *key, UCHAR *tag, ULONG len ) { ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; @@ -1338,6 +1377,12 @@ static NTSTATUS key_export( struct key *key, const WCHAR *type, UCHAR *output, U ERR( "support for keys not available at build time\n" ); return STATUS_NOT_IMPLEMENTED; } + +static inline BOOL key_is_symmetric( struct key *key ) +{ + ERR( "support for keys not available at build time\n" ); + return FALSE; +} #endif NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_KEY_HANDLE *handle, @@ -1356,7 +1401,7 @@ NTSTATUS WINAPI BCryptGenerateSymmetricKey( BCRYPT_ALG_HANDLE algorithm, BCRYPT_ if (!(key = heap_alloc( sizeof(*key) ))) return STATUS_NO_MEMORY; key->hdr.magic = MAGIC_KEY; - if ((status = key_init( key, alg, secret, secret_len ))) + if ((status = key_symmetric_init( key, alg, secret, secret_len ))) { heap_free( key ); return status; @@ -1476,13 +1521,18 @@ NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp padding, iv, iv_len, output, output_len, ret_len, flags ); if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE; + if (!key_is_symmetric( key )) + { + FIXME( "encryption with asymmetric keys not yet supported\n" ); + return STATUS_NOT_IMPLEMENTED; + } if (flags & ~BCRYPT_BLOCK_PADDING) { FIXME( "flags %08x not implemented\n", flags ); return STATUS_NOT_IMPLEMENTED; } - if (key->mode == MODE_ID_GCM) + if (key->u.s.mode == MODE_ID_GCM) { BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *auth_info = padding; @@ -1493,7 +1543,7 @@ NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp if (auth_info->dwFlags & BCRYPT_AUTH_MODE_CHAIN_CALLS_FLAG) FIXME( "call chaining not implemented\n" ); - if ((status = key_set_params( key, auth_info->pbNonce, auth_info->cbNonce ))) + if ((status = key_symmetric_set_params( key, auth_info->pbNonce, auth_info->cbNonce ))) return status; *ret_len = input_len; @@ -1501,44 +1551,43 @@ NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp if (input && !output) return STATUS_SUCCESS; if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL; - if (auth_info->pbAuthData && (status = key_set_auth_data( key, auth_info->pbAuthData, auth_info->cbAuthData ))) - return status; - if ((status = key_encrypt( key, input, input_len, output, output_len ))) + if ((status = key_symmetric_set_auth_data( key, auth_info->pbAuthData, auth_info->cbAuthData ))) return status; + if ((status = key_symmetric_encrypt( key, input, input_len, output, output_len ))) return status; - return key_get_tag( key, auth_info->pbTag, auth_info->cbTag ); + return key_symmetric_get_tag( key, auth_info->pbTag, auth_info->cbTag ); } - if ((status = key_set_params( key, iv, iv_len ))) return status; - + if ((status = key_symmetric_set_params( key, iv, iv_len ))) return status; *ret_len = input_len; if (flags & BCRYPT_BLOCK_PADDING) - *ret_len = (input_len + key->block_size) & ~(key->block_size - 1); - else if (input_len & (key->block_size - 1)) + *ret_len = (input_len + key->u.s.block_size) & ~(key->u.s.block_size - 1); + else if (input_len & (key->u.s.block_size - 1)) return STATUS_INVALID_BUFFER_SIZE; if (!output) return STATUS_SUCCESS; if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL; - if (key->mode == MODE_ID_ECB && iv) return STATUS_INVALID_PARAMETER; + if (key->u.s.mode == MODE_ID_ECB && iv) return STATUS_INVALID_PARAMETER; src = input; dst = output; - while (bytes_left >= key->block_size) + while (bytes_left >= key->u.s.block_size) { - if ((status = key_encrypt( key, src, key->block_size, dst, key->block_size ))) return status; - if (key->mode == MODE_ID_ECB && (status = key_set_params( key, NULL, 0 ))) return status; - bytes_left -= key->block_size; - src += key->block_size; - dst += key->block_size; + if ((status = key_symmetric_encrypt( key, src, key->u.s.block_size, dst, key->u.s.block_size ))) + return status; + if (key->u.s.mode == MODE_ID_ECB && (status = key_symmetric_set_params( key, NULL, 0 ))) return status; + bytes_left -= key->u.s.block_size; + src += key->u.s.block_size; + dst += key->u.s.block_size; } if (flags & BCRYPT_BLOCK_PADDING) { - if (!(buf = heap_alloc( key->block_size ))) return STATUS_NO_MEMORY; + if (!(buf = heap_alloc( key->u.s.block_size ))) return STATUS_NO_MEMORY; memcpy( buf, src, bytes_left ); - memset( buf + bytes_left, key->block_size - bytes_left, key->block_size - bytes_left ); - status = key_encrypt( key, buf, key->block_size, dst, key->block_size ); + memset( buf + bytes_left, key->u.s.block_size - bytes_left, key->u.s.block_size - bytes_left ); + status = key_symmetric_encrypt( key, buf, key->u.s.block_size, dst, key->u.s.block_size ); heap_free( buf ); } @@ -1558,13 +1607,18 @@ NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp padding, iv, iv_len, output, output_len, ret_len, flags ); if (!key || key->hdr.magic != MAGIC_KEY) return STATUS_INVALID_HANDLE; + if (!key_is_symmetric( key )) + { + FIXME( "decryption with asymmetric keys not yet supported\n" ); + return STATUS_NOT_IMPLEMENTED; + } if (flags & ~BCRYPT_BLOCK_PADDING) { FIXME( "flags %08x not supported\n", flags ); return STATUS_NOT_IMPLEMENTED; } - if (key->mode == MODE_ID_GCM) + if (key->u.s.mode == MODE_ID_GCM) { BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO *auth_info = padding; UCHAR tag[16]; @@ -1574,7 +1628,7 @@ NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp if (!auth_info->pbTag) return STATUS_INVALID_PARAMETER; if (auth_info->cbTag < 12 || auth_info->cbTag > 16) return STATUS_INVALID_PARAMETER; - if ((status = key_set_params( key, auth_info->pbNonce, auth_info->cbNonce ))) + if ((status = key_symmetric_set_params( key, auth_info->pbNonce, auth_info->cbNonce ))) return status; *ret_len = input_len; @@ -1582,58 +1636,55 @@ NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp if (!output) return STATUS_SUCCESS; if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL; - if (auth_info->pbAuthData && (status = key_set_auth_data( key, auth_info->pbAuthData, auth_info->cbAuthData ))) - return status; - if ((status = key_decrypt( key, input, input_len, output, output_len ))) + if ((status = key_symmetric_set_auth_data( key, auth_info->pbAuthData, auth_info->cbAuthData ))) return status; + if ((status = key_symmetric_decrypt( key, input, input_len, output, output_len ))) return status; - if ((status = key_get_tag( key, tag, sizeof(tag) ))) - return status; - if (memcmp( tag, auth_info->pbTag, auth_info->cbTag )) - return STATUS_AUTH_TAG_MISMATCH; + if ((status = key_symmetric_get_tag( key, tag, sizeof(tag) ))) return status; + if (memcmp( tag, auth_info->pbTag, auth_info->cbTag )) return STATUS_AUTH_TAG_MISMATCH; return STATUS_SUCCESS; } - if ((status = key_set_params( key, iv, iv_len ))) return status; + if ((status = key_symmetric_set_params( key, iv, iv_len ))) return status; *ret_len = input_len; - if (input_len & (key->block_size - 1)) return STATUS_INVALID_BUFFER_SIZE; + if (input_len & (key->u.s.block_size - 1)) return STATUS_INVALID_BUFFER_SIZE; if (!output) return STATUS_SUCCESS; if (flags & BCRYPT_BLOCK_PADDING) { - if (output_len + key->block_size < *ret_len) return STATUS_BUFFER_TOO_SMALL; - if (input_len < key->block_size) return STATUS_BUFFER_TOO_SMALL; - bytes_left -= key->block_size; + if (output_len + key->u.s.block_size < *ret_len) return STATUS_BUFFER_TOO_SMALL; + if (input_len < key->u.s.block_size) return STATUS_BUFFER_TOO_SMALL; + bytes_left -= key->u.s.block_size; } else if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL; - if (key->mode == MODE_ID_ECB && iv) return STATUS_INVALID_PARAMETER; + if (key->u.s.mode == MODE_ID_ECB && iv) return STATUS_INVALID_PARAMETER; src = input; dst = output; - while (bytes_left >= key->block_size) + while (bytes_left >= key->u.s.block_size) { - if ((status = key_decrypt( key, src, key->block_size, dst, key->block_size ))) return status; - if (key->mode == MODE_ID_ECB && (status = key_set_params( key, NULL, 0 ))) return status; - bytes_left -= key->block_size; - src += key->block_size; - dst += key->block_size; + if ((status = key_symmetric_decrypt( key, src, key->u.s.block_size, dst, key->u.s.block_size ))) + return status; + if (key->u.s.mode == MODE_ID_ECB && (status = key_symmetric_set_params( key, NULL, 0 ))) return status; + bytes_left -= key->u.s.block_size; + src += key->u.s.block_size; + dst += key->u.s.block_size; } if (flags & BCRYPT_BLOCK_PADDING) { - if (!(buf = heap_alloc( key->block_size ))) return STATUS_NO_MEMORY; - status = key_decrypt( key, src, key->block_size, buf, key->block_size ); - if (!status && buf[ key->block_size - 1 ] <= key->block_size) + if (!(buf = heap_alloc( key->u.s.block_size ))) return STATUS_NO_MEMORY; + status = key_symmetric_decrypt( key, src, key->u.s.block_size, buf, key->u.s.block_size ); + if (!status && buf[ key->u.s.block_size - 1 ] <= key->u.s.block_size) { - *ret_len -= buf[ key->block_size - 1 ]; + *ret_len -= buf[ key->u.s.block_size - 1 ]; if (output_len < *ret_len) status = STATUS_BUFFER_TOO_SMALL; - else memcpy( dst, buf, key->block_size - buf[ key->block_size - 1 ] ); + else memcpy( dst, buf, key->u.s.block_size - buf[ key->u.s.block_size - 1 ] ); } - else - status = STATUS_UNSUCCESSFUL; /* FIXME: invalid padding */ + else status = STATUS_UNSUCCESSFUL; /* FIXME: invalid padding */ heap_free( buf ); } -- 2.11.0

1 0

[PATCH 5/5] usp10: Use heap_calloc() in computeIsolatingRunsSet().
by Henri Verbeet 26 Mar '18

26 Mar '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/usp10/bidi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/usp10/bidi.c b/dlls/usp10/bidi.c index b0df781c82a..0fb03ef061a 100644 --- a/dlls/usp10/bidi.c +++ b/dlls/usp10/bidi.c @@ -998,7 +998,7 @@ static void computeIsolatingRunsSet(unsigned baselevel, WORD *pcls, const WORD * Run *runs; IsolatedRun *current_isolated; - if (!(runs = heap_alloc(uCount * sizeof(*runs)))) + if (!(runs = heap_calloc(uCount, sizeof(*runs)))) return; list_init(set); -- 2.11.0

2 1

[PATCH v3] comctl32/datetime: Change DATETIME_ReturnFieldWidth() to return width.
by Zhiyi Zhang 26 Mar '18

26 Mar '18

Supersede 143784 This avoids a clang warning of uninitialized value usage. Also removes redundant check and not useful trace. Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/comctl32/datetime.c | 24 ++++++------------------ 1 file changed, 6 insertions(+), 18 deletions(-)

2 1

[PATCH 1/2] api-ms-win-core-sidebyside-l1-1-0: Add missing forward.
by Gijs Vermeulen 26 Mar '18

26 Mar '18

Signed-off-by: Gijs Vermeulen <gijsvrm(a)gmail.com> --- .../api-ms-win-core-sidebyside-l1-1-0.spec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dlls/api-ms-win-core-sidebyside-l1-1-0/api-ms-win-core-sidebyside-l1-1-0.spec b/dlls/api-ms-win-core-sidebyside-l1-1-0/api-ms-win-core-sidebyside-l1-1-0.spec index 0bf78e2911..6a58321021 100644 --- a/dlls/api-ms-win-core-sidebyside-l1-1-0/api-ms-win-core-sidebyside-l1-1-0.spec +++ b/dlls/api-ms-win-core-sidebyside-l1-1-0/api-ms-win-core-sidebyside-l1-1-0.spec @@ -5,7 +5,7 @@ @ stdcall FindActCtxSectionGuid(long ptr long ptr ptr) kernel32.FindActCtxSectionGuid @ stdcall FindActCtxSectionStringW(long ptr long wstr ptr) kernel32.FindActCtxSectionStringW @ stdcall GetCurrentActCtx(ptr) kernel32.GetCurrentActCtx -@ stub QueryActCtxSettingsW +@ stdcall QueryActCtxSettingsW(long ptr wstr wstr ptr long ptr) kernel32.QueryActCtxSettingsW @ stdcall QueryActCtxW(long ptr ptr long ptr long ptr) kernel32.QueryActCtxW @ stdcall ReleaseActCtx(ptr) kernel32.ReleaseActCtx @ stdcall ZombifyActCtx(ptr) kernel32.ZombifyActCtx -- 2.13.6

1 1

[PATCH 4/5] ddraw: Handle DDLOCK_WRITEONLY in wined3dmapflags_from_ddrawmapflags().
by Henri Verbeet 26 Mar '18

26 Mar '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/ddraw/utils.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/dlls/ddraw/utils.c b/dlls/ddraw/utils.c index 65f24dc13fd..b0a028d4a57 100644 --- a/dlls/ddraw/utils.c +++ b/dlls/ddraw/utils.c @@ -570,7 +570,7 @@ unsigned int wined3dmapflags_from_ddrawmapflags(unsigned int flags) unsigned int wined3d_flags; wined3d_flags = flags & handled; - if (!(flags & (DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS))) + if (!(flags & (DDLOCK_NOOVERWRITE | DDLOCK_DISCARDCONTENTS | DDLOCK_WRITEONLY))) wined3d_flags |= WINED3D_MAP_READ; if (!(flags & DDLOCK_READONLY)) wined3d_flags |= WINED3D_MAP_WRITE; @@ -578,7 +578,7 @@ unsigned int wined3dmapflags_from_ddrawmapflags(unsigned int flags) wined3d_flags |= WINED3D_MAP_READ | WINED3D_MAP_WRITE; if (flags & DDLOCK_NODIRTYUPDATE) wined3d_flags |= WINED3D_MAP_NO_DIRTY_UPDATE; - flags &= ~(handled | DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_NODIRTYUPDATE); + flags &= ~(handled | DDLOCK_WAIT | DDLOCK_READONLY | DDLOCK_WRITEONLY | DDLOCK_NODIRTYUPDATE); if (flags) FIXME("Unhandled flags %#x.\n", flags); -- 2.11.0

1 0

[PATCH 3/5] wined3d: Simplify wined3d_device_update_sub_resource() a little.
by Henri Verbeet 26 Mar '18

26 Mar '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/device.c | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 64437a357e6..b66b3946c46 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -4248,7 +4248,7 @@ void CDECL wined3d_device_update_sub_resource(struct wined3d_device *device, str height = 1; depth = 1; } - else if (resource->type == WINED3D_RTYPE_TEXTURE_2D || resource->type == WINED3D_RTYPE_TEXTURE_3D) + else { struct wined3d_texture *texture = texture_from_resource(resource); unsigned int level; @@ -4264,11 +4264,6 @@ void CDECL wined3d_device_update_sub_resource(struct wined3d_device *device, str height = wined3d_texture_get_level_height(texture, level); depth = wined3d_texture_get_level_depth(texture, level); } - else - { - FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(resource->type)); - return; - } if (!box) { -- 2.11.0

1 0

[PATCH 2/5] wined3d: Handle 3D textures in wined3d_device_copy_sub_resource_region().
by Henri Verbeet 26 Mar '18

26 Mar '18

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/device.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 29083ea1c7d..64437a357e6 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -4158,7 +4158,7 @@ HRESULT CDECL wined3d_device_copy_sub_resource_region(struct wined3d_device *dev wined3d_box_set(&dst_box, dst_x, 0, dst_x + (src_box->right - src_box->left), 1, 0, 1); } - else if (dst_resource->type == WINED3D_RTYPE_TEXTURE_2D) + else { struct wined3d_texture *dst_texture = texture_from_resource(dst_resource); struct wined3d_texture *src_texture = texture_from_resource(src_resource); @@ -4190,16 +4190,18 @@ HRESULT CDECL wined3d_device_copy_sub_resource_region(struct wined3d_device *dev if (!src_box) { - unsigned int src_w, src_h, dst_w, dst_h, dst_level; + unsigned int src_w, src_h, src_d, dst_w, dst_h, dst_d, dst_level; src_w = wined3d_texture_get_level_width(src_texture, src_level); src_h = wined3d_texture_get_level_height(src_texture, src_level); + src_d = wined3d_texture_get_level_depth(src_texture, src_level); dst_level = dst_sub_resource_idx % dst_texture->level_count; dst_w = wined3d_texture_get_level_width(dst_texture, dst_level) - dst_x; dst_h = wined3d_texture_get_level_height(dst_texture, dst_level) - dst_y; + dst_d = wined3d_texture_get_level_depth(dst_texture, dst_level) - dst_z; - wined3d_box_set(&b, 0, 0, min(src_w, dst_w), min(src_h, dst_h), 0, 1); + wined3d_box_set(&b, 0, 0, min(src_w, dst_w), min(src_h, dst_h), 0, min(src_d, dst_d)); src_box = &b; } else if (FAILED(wined3d_texture_check_box_dimensions(src_texture, src_level, src_box))) @@ -4209,7 +4211,7 @@ HRESULT CDECL wined3d_device_copy_sub_resource_region(struct wined3d_device *dev } wined3d_box_set(&dst_box, dst_x, dst_y, dst_x + (src_box->right - src_box->left), - dst_y + (src_box->bottom - src_box->top), 0, 1); + dst_y + (src_box->bottom - src_box->top), dst_z, dst_z + (src_box->back - src_box->front)); if (FAILED(wined3d_texture_check_box_dimensions(dst_texture, dst_sub_resource_idx % dst_texture->level_count, &dst_box))) { @@ -4217,11 +4219,6 @@ HRESULT CDECL wined3d_device_copy_sub_resource_region(struct wined3d_device *dev return WINED3DERR_INVALIDCALL; } } - else - { - FIXME("Not implemented for %s resources.\n", debug_d3dresourcetype(dst_resource->type)); - return WINED3DERR_INVALIDCALL; - } wined3d_cs_emit_blt_sub_resource(device->cs, dst_resource, dst_sub_resource_idx, &dst_box, src_resource, src_sub_resource_idx, src_box, WINED3D_BLT_RAW, NULL, WINED3D_TEXF_POINT); -- 2.11.0

1 0