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

[PATCH 2/5] wined3d: use upper-case enum elements in the projection_types enum.
by Henri Verbeet March 23, 2018

March 23, 2018

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/arb_program_shader.c | 48 ++++++++++++++++++++++++++------------ dlls/wined3d/ati_fragment_shader.c | 18 ++++++-------- dlls/wined3d/glsl_shader.c | 14 +++++------ dlls/wined3d/utils.c | 10 ++++---- dlls/wined3d/wined3d_private.h | 8 +++---- 5 files changed, 56 insertions(+), 42 deletions(-) diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c index 2f65d5c1c51..f0586e2d3c2 100644 --- a/dlls/wined3d/arb_program_shader.c +++ b/dlls/wined3d/arb_program_shader.c @@ -6379,12 +6379,17 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con textype = arbfp_texture_target(settings->op[stage].tex_type); - if(settings->op[stage].projected == proj_none) { + if (settings->op[stage].projected == WINED3D_PROJECTION_NONE) + { instr = "TEX"; - } else if(settings->op[stage].projected == proj_count4 || - settings->op[stage].projected == proj_count3) { + } + else if (settings->op[stage].projected == WINED3D_PROJECTION_COUNT4 + || settings->op[stage].projected == WINED3D_PROJECTION_COUNT3) + { instr = "TXP"; - } else { + } + else + { FIXME("Unexpected projection mode %d\n", settings->op[stage].projected); instr = "TXP"; } @@ -6398,18 +6403,27 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con shader_addline(&buffer, "SWZ arg1, bumpmat%u, y, w, 0, 0;\n", stage - 1); shader_addline(&buffer, "DP3 ret.y, arg1, tex%u;\n", stage - 1); - /* with projective textures, texbem only divides the static texture coord, not the displacement, - * so multiply the displacement with the dividing parameter before passing it to TXP - */ - if (settings->op[stage].projected != proj_none) { - if(settings->op[stage].projected == proj_count4) { + /* With projective textures, texbem only divides the static + * texture coordinate, not the displacement, so multiply the + * displacement with the dividing parameter before passing it to + * TXP. */ + if (settings->op[stage].projected != WINED3D_PROJECTION_NONE) + { + if (settings->op[stage].projected == WINED3D_PROJECTION_COUNT4) + { shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].w;\n", stage); - shader_addline(&buffer, "MUL ret.xyz, ret, fragment.texcoord[%u].w, fragment.texcoord[%u];\n", stage, stage); - } else { + shader_addline(&buffer, "MUL ret.xyz, ret, fragment.texcoord[%u].w, fragment.texcoord[%u];\n", + stage, stage); + } + else + { shader_addline(&buffer, "MOV ret.w, fragment.texcoord[%u].z;\n", stage); - shader_addline(&buffer, "MAD ret.xyz, ret, fragment.texcoord[%u].z, fragment.texcoord[%u];\n", stage, stage); + shader_addline(&buffer, "MAD ret.xyz, ret, fragment.texcoord[%u].z, fragment.texcoord[%u];\n", + stage, stage); } - } else { + } + else + { shader_addline(&buffer, "ADD ret, ret, fragment.texcoord[%u];\n", stage); } @@ -6421,12 +6435,16 @@ static GLuint gen_arbfp_ffp_shader(const struct ffp_frag_settings *settings, con stage - 1, stage - 1, stage - 1); shader_addline(&buffer, "MUL tex%u, tex%u, ret.x;\n", stage, stage); } - } else if(settings->op[stage].projected == proj_count3) { + } + else if (settings->op[stage].projected == WINED3D_PROJECTION_COUNT3) + { shader_addline(&buffer, "MOV ret, fragment.texcoord[%u];\n", stage); shader_addline(&buffer, "MOV ret.w, ret.z;\n"); shader_addline(&buffer, "%s tex%u, ret, texture[%u], %s;\n", instr, stage, stage, textype); - } else { + } + else + { shader_addline(&buffer, "%s tex%u, fragment.texcoord[%u], texture[%u], %s;\n", instr, stage, stage, stage, textype); } diff --git a/dlls/wined3d/ati_fragment_shader.c b/dlls/wined3d/ati_fragment_shader.c index 9d6837a2f22..3fd4758681b 100644 --- a/dlls/wined3d/ati_fragment_shader.c +++ b/dlls/wined3d/ati_fragment_shader.c @@ -505,16 +505,13 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], TRACE("glSampleMapATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, GL_SWIZZLE_STR_ATI)\n", stage, stage); - GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI + stage, - GL_TEXTURE0_ARB + stage, - GL_SWIZZLE_STR_ATI)); - if(op[stage + 1].projected == proj_none) { + GL_EXTCALL(glSampleMapATI(GL_REG_0_ATI + stage, GL_TEXTURE0_ARB + stage, GL_SWIZZLE_STR_ATI)); + if (op[stage + 1].projected == WINED3D_PROJECTION_NONE) swizzle = GL_SWIZZLE_STR_ATI; - } else if(op[stage + 1].projected == proj_count4) { + else if (op[stage + 1].projected == WINED3D_PROJECTION_COUNT4) swizzle = GL_SWIZZLE_STQ_DQ_ATI; - } else { + else swizzle = GL_SWIZZLE_STR_DR_ATI; - } TRACE("glPassTexCoordATI(GL_REG_%d_ATI, GL_TEXTURE_%d_ARB, %s)\n", stage + 1, stage + 1, debug_swizzle(swizzle)); GL_EXTCALL(glPassTexCoordATI(GL_REG_0_ATI + stage + 1, @@ -579,13 +576,12 @@ static GLuint gen_ati_shader(const struct texture_stage_op op[MAX_TEXTURES], if (op[stage].cop == WINED3D_TOP_DISABLE) break; - if(op[stage].projected == proj_none) { + if (op[stage].projected == WINED3D_PROJECTION_NONE) swizzle = GL_SWIZZLE_STR_ATI; - } else if(op[stage].projected == proj_count3) { + else if (op[stage].projected == WINED3D_PROJECTION_COUNT3) swizzle = GL_SWIZZLE_STR_DR_ATI; - } else { + else swizzle = GL_SWIZZLE_STQ_DQ_ATI; - } if (op_reads_texture(&op[stage])) { diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 1a9886353d1..6aaee8a4af5 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -9495,12 +9495,12 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv * if (!(tex_map & (1u << stage))) continue; - if (settings->op[stage].projected == proj_none) + if (settings->op[stage].projected == WINED3D_PROJECTION_NONE) { proj = FALSE; } - else if (settings->op[stage].projected == proj_count4 - || settings->op[stage].projected == proj_count3) + else if (settings->op[stage].projected == WINED3D_PROJECTION_COUNT4 + || settings->op[stage].projected == WINED3D_PROJECTION_COUNT3) { proj = TRUE; } @@ -9583,12 +9583,12 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv * shader_addline(buffer, "ret.xy = bumpenv_mat%u * tex%u.xy;\n", stage - 1, stage - 1); /* With projective textures, texbem only divides the static - * texture coord, not the displacement, so multiply the + * texture coordinate, not the displacement, so multiply the * displacement with the dividing parameter before passing it to * TXP. */ - if (settings->op[stage].projected != proj_none) + if (settings->op[stage].projected != WINED3D_PROJECTION_NONE) { - if (settings->op[stage].projected == proj_count4) + if (settings->op[stage].projected == WINED3D_PROJECTION_COUNT4) { shader_addline(buffer, "ret.xy = (ret.xy * ffp_texcoord[%u].w) + ffp_texcoord[%u].xy;\n", stage, stage); @@ -9613,7 +9613,7 @@ static GLuint shader_glsl_generate_ffp_fragment_shader(struct shader_glsl_priv * shader_addline(buffer, "tex%u *= clamp(tex%u.z * bumpenv_lum_scale%u + bumpenv_lum_offset%u, 0.0, 1.0);\n", stage, stage - 1, stage - 1, stage - 1); } - else if (settings->op[stage].projected == proj_count3) + else if (settings->op[stage].projected == WINED3D_PROJECTION_COUNT3) { shader_addline(buffer, "tex%u = %s(ps_sampler%u, ffp_texcoord[%u].xyz);\n", stage, texture_function, stage, stage); diff --git a/dlls/wined3d/utils.c b/dlls/wined3d/utils.c index a54e18efd9c..7ca371b3ffc 100644 --- a/dlls/wined3d/utils.c +++ b/dlls/wined3d/utils.c @@ -5495,7 +5495,7 @@ void gen_ffp_frag_op(const struct wined3d_context *context, const struct wined3d settings->op[i].color_fixup = COLOR_FIXUP_IDENTITY; settings->op[i].dst = resultreg; settings->op[i].tex_type = WINED3D_GL_RES_TYPE_TEX_1D; - settings->op[i].projected = proj_none; + settings->op[i].projected = WINED3D_PROJECTION_NONE; i++; break; } @@ -5619,15 +5619,15 @@ void gen_ffp_frag_op(const struct wined3d_context *context, const struct wined3d { ttff = state->texture_states[i][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS]; if (ttff == (WINED3D_TTFF_PROJECTED | WINED3D_TTFF_COUNT3)) - settings->op[i].projected = proj_count3; + settings->op[i].projected = WINED3D_PROJECTION_COUNT3; else if (ttff & WINED3D_TTFF_PROJECTED) - settings->op[i].projected = proj_count4; + settings->op[i].projected = WINED3D_PROJECTION_COUNT4; else - settings->op[i].projected = proj_none; + settings->op[i].projected = WINED3D_PROJECTION_NONE; } else { - settings->op[i].projected = proj_none; + settings->op[i].projected = WINED3D_PROJECTION_NONE; } settings->op[i].cop = cop; diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 8c739aac547..12a95fdc6c5 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2634,11 +2634,11 @@ BOOL wined3d_caps_gl_ctx_test_viewport_subpixel_bits(struct wined3d_caps_gl_ctx void install_gl_compat_wrapper(struct wined3d_gl_info *gl_info, enum wined3d_gl_extension ext) DECLSPEC_HIDDEN; -enum projection_types +enum wined3d_projection_type { - proj_none = 0, - proj_count3 = 1, - proj_count4 = 2 + WINED3D_PROJECTION_NONE = 0, + WINED3D_PROJECTION_COUNT3 = 1, + WINED3D_PROJECTION_COUNT4 = 2 }; enum dst_arg -- 2.11.0

1 0

[PATCH 1/5] wined3d: Use upper-case enum elements in the vertexprocessing_mode enum.
by Henri Verbeet March 23, 2018

March 23, 2018

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/arb_program_shader.c | 125 ++++++++++++++++++-------------------- dlls/wined3d/glsl_shader.c | 10 +-- dlls/wined3d/shader.c | 8 +-- dlls/wined3d/wined3d_private.h | 11 ++-- 4 files changed, 75 insertions(+), 79 deletions(-) diff --git a/dlls/wined3d/arb_program_shader.c b/dlls/wined3d/arb_program_shader.c index 23f69a2b586..2f65d5c1c51 100644 --- a/dlls/wined3d/arb_program_shader.c +++ b/dlls/wined3d/arb_program_shader.c @@ -1061,7 +1061,7 @@ static void shader_arb_get_register_name(const struct wined3d_shader_instruction /* This is better than nothing for now */ sprintf(register_name, "fragment.texcoord[%s + %u]", rel_reg, reg->idx[0].offset); } - else if(ctx->cur_ps_args->super.vp_mode != vertexshader) + else if(ctx->cur_ps_args->super.vp_mode != WINED3D_VP_MODE_SHADER) { /* This is problematic because we'd have to consult the ctx->ps_input strings * for where to find the varying. Some may be "0.0", others can be texcoords or @@ -3415,73 +3415,68 @@ static void init_ps_input(const struct wined3d_shader *shader, const char *semantic_name; DWORD semantic_idx; - switch(args->super.vp_mode) - { - case pretransformed: - case fixedfunction: - /* The pixelshader has to collect the varyings on its own. In any case properly load - * color0 and color1. In the case of pretransformed vertices also load texcoords. Set - * other attribs to 0.0. - * - * For fixedfunction this behavior is correct, according to the tests. For pretransformed - * we'd either need a replacement shader that can load other attribs like BINORMAL, or - * load the texcoord attrib pointers to match the pixel shader signature - */ - for (i = 0; i < shader->input_signature.element_count; ++i) - { - input = &shader->input_signature.elements[i]; - if (!(semantic_name = input->semantic_name)) - continue; - semantic_idx = input->semantic_idx; + if (args->super.vp_mode == WINED3D_VP_MODE_SHADER) + { + /* That one is easy. The vertex shaders provide v0-v7 in + * fragment.texcoord and v8 and v9 in fragment.color. */ + for (i = 0; i < 8; ++i) + { + priv->ps_input[i] = texcoords[i]; + } + priv->ps_input[8] = "fragment.color.primary"; + priv->ps_input[9] = "fragment.color.secondary"; + return; + } - if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_COLOR)) - { - if (!semantic_idx) - priv->ps_input[input->register_idx] = "fragment.color.primary"; - else if (semantic_idx == 1) - priv->ps_input[input->register_idx] = "fragment.color.secondary"; - else - priv->ps_input[input->register_idx] = "0.0"; - } - else if (args->super.vp_mode == fixedfunction) - { - priv->ps_input[input->register_idx] = "0.0"; - } - else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_TEXCOORD)) - { - if (semantic_idx < 8) - priv->ps_input[input->register_idx] = texcoords[semantic_idx]; - else - priv->ps_input[input->register_idx] = "0.0"; - } - else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_FOG)) - { - if (!semantic_idx) - priv->ps_input[input->register_idx] = "fragment.fogcoord"; - else - priv->ps_input[input->register_idx] = "0.0"; - } - else - { - priv->ps_input[input->register_idx] = "0.0"; - } + /* The fragment shader has to collect the varyings on its own. In any case + * properly load color0 and color1. In the case of pre-transformed + * vertices also load texture coordinates. Set other attributes to 0.0. + * + * For fixed-function this behavior is correct, according to the tests. + * For pre-transformed we'd either need a replacement shader that can load + * other attributes like BINORMAL, or load the texture coordinate + * attribute pointers to match the fragment shader signature. */ + for (i = 0; i < shader->input_signature.element_count; ++i) + { + input = &shader->input_signature.elements[i]; + if (!(semantic_name = input->semantic_name)) + continue; + semantic_idx = input->semantic_idx; - TRACE("v%u, semantic %s%u is %s\n", input->register_idx, - semantic_name, semantic_idx, priv->ps_input[input->register_idx]); - } - break; + if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_COLOR)) + { + if (!semantic_idx) + priv->ps_input[input->register_idx] = "fragment.color.primary"; + else if (semantic_idx == 1) + priv->ps_input[input->register_idx] = "fragment.color.secondary"; + else + priv->ps_input[input->register_idx] = "0.0"; + } + else if (args->super.vp_mode == WINED3D_VP_MODE_FF) + { + priv->ps_input[input->register_idx] = "0.0"; + } + else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_TEXCOORD)) + { + if (semantic_idx < 8) + priv->ps_input[input->register_idx] = texcoords[semantic_idx]; + else + priv->ps_input[input->register_idx] = "0.0"; + } + else if (shader_match_semantic(semantic_name, WINED3D_DECL_USAGE_FOG)) + { + if (!semantic_idx) + priv->ps_input[input->register_idx] = "fragment.fogcoord"; + else + priv->ps_input[input->register_idx] = "0.0"; + } + else + { + priv->ps_input[input->register_idx] = "0.0"; + } - case vertexshader: - /* That one is easy. The vertex shaders provide v0-v7 in fragment.texcoord and v8 and v9 in - * fragment.color - */ - for(i = 0; i < 8; i++) - { - priv->ps_input[i] = texcoords[i]; - } - priv->ps_input[8] = "fragment.color.primary"; - priv->ps_input[9] = "fragment.color.secondary"; - break; + TRACE("v%u, semantic %s%u is %s\n", input->register_idx, + semantic_name, semantic_idx, priv->ps_input[input->register_idx]); } } diff --git a/dlls/wined3d/glsl_shader.c b/dlls/wined3d/glsl_shader.c index 6cc030aaa68..1a9886353d1 100644 --- a/dlls/wined3d/glsl_shader.c +++ b/dlls/wined3d/glsl_shader.c @@ -6735,7 +6735,7 @@ static void shader_glsl_input_pack(const struct wined3d_shader *shader, struct w semantic_idx = input->semantic_idx; shader_glsl_write_mask_to_str(input->mask, reg_mask); - if (args->vp_mode == vertexshader) + if (args->vp_mode == WINED3D_VP_MODE_SHADER) { if (input->sysval_semantic == WINED3D_SV_POSITION && !semantic_idx) { @@ -6774,7 +6774,7 @@ static void shader_glsl_input_pack(const struct wined3d_shader *shader, struct w if (args->pointsprite) shader_addline(buffer, "ps_in[%u] = vec4(gl_PointCoord.xy, 0.0, 0.0);\n", shader->u.ps.input_reg_map[input->register_idx]); - else if (args->vp_mode == pretransformed && args->texcoords_initialized & (1u << semantic_idx)) + else if (args->vp_mode == WINED3D_VP_MODE_NONE && args->texcoords_initialized & (1u << semantic_idx)) shader_addline(buffer, "ps_in[%u]%s = %s[%u]%s;\n", shader->u.ps.input_reg_map[input->register_idx], reg_mask, needs_legacy_glsl_syntax(gl_info) @@ -7596,7 +7596,7 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context shader_addline(buffer, "uniform vec4 %s_samplerNP2Fixup[%u];\n", prefix, fixup->num_consts); } - if (version->major < 3 || args->vp_mode != vertexshader) + if (version->major < 3 || args->vp_mode != WINED3D_VP_MODE_SHADER) { shader_addline(buffer, "uniform struct\n{\n"); shader_addline(buffer, " vec4 color;\n"); @@ -7630,7 +7630,7 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context { unsigned int in_count = min(vec4_varyings(version->major, gl_info), shader->limits->packed_input); - if (args->vp_mode == vertexshader && reg_maps->input_registers) + if (args->vp_mode == WINED3D_VP_MODE_SHADER && reg_maps->input_registers) shader_glsl_declare_shader_inputs(gl_info, buffer, in_count, shader->u.ps.interpolation_mode, version->major >= 4); shader_addline(buffer, "vec4 %s_in[%u];\n", prefix, in_count); @@ -7729,7 +7729,7 @@ static GLuint shader_glsl_generate_pshader(const struct wined3d_context *context "vpos = vec4(0, ycorrection[0], 0, 0) + gl_FragCoord * vec4(1, ycorrection[1], 1, 1);\n"); } - if (reg_maps->shader_version.major < 3 || args->vp_mode != vertexshader) + if (reg_maps->shader_version.major < 3 || args->vp_mode != WINED3D_VP_MODE_SHADER) { unsigned int i; WORD map = reg_maps->texcoord; diff --git a/dlls/wined3d/shader.c b/dlls/wined3d/shader.c index 66e1bbf8825..2a047fadafc 100644 --- a/dlls/wined3d/shader.c +++ b/dlls/wined3d/shader.c @@ -3926,16 +3926,16 @@ void find_ps_compile_args(const struct wined3d_state *state, const struct wined3 if (shader->reg_maps.shader_version.major >= 3) { if (position_transformed) - args->vp_mode = pretransformed; + args->vp_mode = WINED3D_VP_MODE_NONE; else if (use_vs(state)) - args->vp_mode = vertexshader; + args->vp_mode = WINED3D_VP_MODE_SHADER; else - args->vp_mode = fixedfunction; + args->vp_mode = WINED3D_VP_MODE_FF; args->fog = WINED3D_FFP_PS_FOG_OFF; } else { - args->vp_mode = vertexshader; + args->vp_mode = WINED3D_VP_MODE_SHADER; if (state->render_states[WINED3D_RS_FOGENABLE]) { switch (state->render_states[WINED3D_RS_FOGTABLEMODE]) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 574ef46cea1..8c739aac547 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -1300,10 +1300,11 @@ enum wined3d_gl_resource_type WINED3D_GL_RES_TYPE_COUNT = 7, }; -enum vertexprocessing_mode { - fixedfunction, - vertexshader, - pretransformed +enum wined3d_vertex_processing_mode +{ + WINED3D_VP_MODE_FF, + WINED3D_VP_MODE_SHADER, + WINED3D_VP_MODE_NONE, }; #define WINED3D_CONST_NUM_UNUSED ~0U @@ -1338,7 +1339,7 @@ enum wined3d_shader_tex_types struct ps_compile_args { struct color_fixup_desc color_fixup[MAX_FRAGMENT_SAMPLERS]; - enum vertexprocessing_mode vp_mode; + enum wined3d_vertex_processing_mode vp_mode; enum wined3d_ffp_ps_fog_mode fog; WORD tex_transform; /* ps 1.0-1.3, 4 textures */ WORD tex_types; /* ps 1.0 - 1.4, 6 textures */ -- 2.11.0

1 0

Wine Vulkan loader (vulkan-1.dll)
by Roderick Colenbrander March 23, 2018

March 23, 2018

Hi all, Now that we have an initial Vulkan ICD, the question is how do we supply users with the Vulkan loader (vulkan-1.dll). At the moment users need to install it themselves by downloading Vulkan SDK e.g. through winetricks or lunarg website. There are a various options each with their pros and cons. 1. Use the official Vulkan loader and bundle it with Wine. The vulkan loader is open source and could thus be bundled. However last year the license switched from BSD to Apache. At some point I compiled the loader using winegcc though had to make a few code changes, which I'm sure could be upstreamed to Khronos. 2. Provide our own minimal vulkan-1.dll implementation. It would cut some corners by not supporting layers or handling of multiple ICDs, which is were most of the complexity lays. In terms of loading order we would prefer native over builtin as e.g. Steam may want to use the real loader to provide layers such as overlay. Last summer I did create such a loader, but I would need to dust it off. Most of the code is very easy to generate and would most can share some code with winevulkan e.g. dispatch structures and macros. 3. Provide vulkan loader in a wine-gecko/wine-mono kind of way through an external download. Not as user friendly and not sure how desired for Wine unit tests needing an external dependency. In an ideal world, I would prefer option 1) as it doesn't make sense to duplicate work and it also provides the most features. However, the question is whether we would want Apache 2.0 licensed code in Wine. Technically we are LGPL >= 2.1, so under 3.0 license this would be compatible (and you could offer an option to not build the dll maybe). More realistically I suppose 2) is the preferred method for now. Thoughts? Thanks, Roderick

3 3

[PATCH v2 1/2] winevulkan: add helper function for VkDeviceCreateInfo conversion.
by Roderick Colenbrander March 22, 2018

March 22, 2018

Signed-off-by: Roderick Colenbrander <thunderbird2k(a)gmail.com> --- dlls/winevulkan/vulkan.c | 73 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 69 insertions(+), 4 deletions(-) diff --git a/dlls/winevulkan/vulkan.c b/dlls/winevulkan/vulkan.c index a5b8a96e91..2a67a431b4 100644 --- a/dlls/winevulkan/vulkan.c +++ b/dlls/winevulkan/vulkan.c @@ -98,6 +98,63 @@ static struct VkQueue_T *wine_vk_device_alloc_queues(struct VkDevice_T *device, return queues; } +/* Helper function to convert win32 VkDeviceCreateInfo to host compatible. */ +static VkResult wine_vk_device_convert_create_info(const VkDeviceCreateInfo *src, + VkDeviceCreateInfo *dst) +{ + unsigned int i; + + dst->sType = src->sType; + dst->flags = src->flags; + + /* Application and loader can pass in a chain of extensions through pNext. + * We can't blindly pass these through as often these contain callbacks or + * they can even be pass structures for loader / ICD internal use. For now + * we ignore everything in pNext chain, but we print FIXMEs. + */ + if (src->pNext) + { + const struct wine_vk_structure_header *header; + + for (header = src->pNext; header; header = header->pNext) + { + switch (header->sType) + { + case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: + /* Used for loader to ICD communication. Ignore to not confuse + * host loader. + */ + break; + + default: + FIXME("Application requested a linked structure of type %d\n", header->sType); + } + } + } + /* For now don't support anything. */ + dst->pNext = NULL; + + dst->queueCreateInfoCount = src->queueCreateInfoCount; + dst->pQueueCreateInfos = src->pQueueCreateInfos; + + /* Should be filtered out by loader as ICDs don't support layers. */ + dst->enabledLayerCount = 0; + dst->ppEnabledLayerNames = NULL; + + dst->ppEnabledExtensionNames = src->ppEnabledExtensionNames; + dst->enabledExtensionCount = src->enabledExtensionCount; + + TRACE("Enabled extensions: %u\n", dst->enabledExtensionCount); + for (i = 0; i < dst->enabledExtensionCount; i++) + { + TRACE("Extension %u: %s\n", i, debugstr_a(dst->ppEnabledExtensionNames[i])); + } + + dst->pEnabledFeatures = src->pEnabledFeatures; + + return VK_SUCCESS; +} + /* Helper function used for freeing a device structure. This function supports full * and partial object cleanups and can thus be used for vkCreateDevice failures. */ @@ -470,6 +527,7 @@ VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice phys_dev, const VkAllocationCallbacks *allocator, VkDevice *device) { struct VkDevice_T *object = NULL; + VkDeviceCreateInfo create_info_host; uint32_t max_queue_families; VkResult res; unsigned int i; @@ -485,11 +543,18 @@ VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice phys_dev, object->base.loader_magic = VULKAN_ICD_MAGIC_VALUE; + res = wine_vk_device_convert_create_info(create_info, &create_info_host); + if (res != VK_SUCCESS) + { + ERR("Failed to convert device create info, res=%d\n", res); + goto err; + } + /* At least for now we can directly pass create_info through. All extensions we report * should be compatible. In addition the loader is supposed to sanitize values e.g. layers. */ res = phys_dev->instance->funcs.p_vkCreateDevice(phys_dev->phys_dev, - create_info, NULL /* allocator */, &object->device); + &create_info_host, NULL /* allocator */, &object->device); if (res != VK_SUCCESS) { ERR("Failed to create device\n"); @@ -524,10 +589,10 @@ VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice phys_dev, goto err; } - for (i = 0; i < create_info->queueCreateInfoCount; i++) + for (i = 0; i < create_info_host.queueCreateInfoCount; i++) { - uint32_t family_index = create_info->pQueueCreateInfos[i].queueFamilyIndex; - uint32_t queue_count = create_info->pQueueCreateInfos[i].queueCount; + uint32_t family_index = create_info_host.pQueueCreateInfos[i].queueFamilyIndex; + uint32_t queue_count = create_info_host.pQueueCreateInfos[i].queueCount; TRACE("queueFamilyIndex %u, queueCount %u\n", family_index, queue_count); -- 2.14.3

1 1

[v2 PATCH 3/3] bcrypt/tests: Add basic test for ecdsa.
by Alistair Leslie-Hughes March 22, 2018

March 22, 2018

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/bcrypt/tests/bcrypt.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index a302d7d..69b3167 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -50,6 +50,8 @@ static NTSTATUS (WINAPI *pBCryptDestroyKey)(BCRYPT_KEY_HANDLE); static NTSTATUS (WINAPI *pBCryptImportKey)(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, BCRYPT_KEY_HANDLE *, PUCHAR, ULONG, PUCHAR, ULONG, ULONG); static NTSTATUS (WINAPI *pBCryptExportKey)(BCRYPT_KEY_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, PUCHAR, ULONG, ULONG *, ULONG); +static NTSTATUS (WINAPI *pBCryptImportKeyPair)(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, BCRYPT_KEY_HANDLE *, UCHAR *, ULONG, ULONG); +static NTSTATUS (WINAPI *pBCryptVerifySignature)(BCRYPT_KEY_HANDLE, VOID *, UCHAR *, ULONG, UCHAR *, ULONG, ULONG); static void test_BCryptGenRandom(void) { @@ -1381,6 +1383,66 @@ static void test_key_import_export(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); } +static BYTE eccPubkey[] = +{ + /* X */ + 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, + /* Y */ + 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, +}; +static BYTE certHash[] = +{ + 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, +}; +static BYTE certSignature[] = +{ + /* r */ + 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, + /* s */ + 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, +}; + +static void test_ECDSA(void) +{ + BYTE buffer[sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(eccPubkey)]; + BCRYPT_ECCKEY_BLOB *ecckey = (void *)buffer; + BCRYPT_ALG_HANDLE alg = NULL; + BCRYPT_KEY_HANDLE key = NULL; + NTSTATUS status; + + status = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_P256_ALGORITHM, NULL, 0); + if (status) + { + todo_wine win_skip("Failed to open ECDSA provider: %08x, skipping test\n", status); + return; + } + + ecckey->dwMagic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC; + memcpy(ecckey + 1, eccPubkey, sizeof(eccPubkey)); + + ecckey->cbKey = 2; + status = pBCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, sizeof(buffer), 0); + ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %08x\n", status); + + ecckey->cbKey = sizeof(eccPubkey) / 2; + status = pBCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, sizeof(buffer), 0); + 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); + + status = pBCryptVerifySignature(key, NULL, certHash, sizeof(certHash), certSignature, sizeof(certSignature), 0); + ok(!status, "BCryptVerifySignature failed: %08x\n", status); + + pBCryptDestroyKey(key); + pBCryptCloseAlgorithmProvider(alg, 0); +} + START_TEST(bcrypt) { HMODULE module; @@ -1411,6 +1473,8 @@ START_TEST(bcrypt) pBCryptDestroyKey = (void *)GetProcAddress(module, "BCryptDestroyKey"); pBCryptImportKey = (void *)GetProcAddress(module, "BCryptImportKey"); pBCryptExportKey = (void *)GetProcAddress(module, "BCryptExportKey"); + pBCryptImportKeyPair = (void *)GetProcAddress(module, "BCryptImportKeyPair"); + pBCryptVerifySignature = (void *)GetProcAddress(module, "BCryptVerifySignature"); test_BCryptGenRandom(); test_BCryptGetFipsAlgorithmMode(); @@ -1421,6 +1485,7 @@ START_TEST(bcrypt) test_BCryptEncrypt(); test_BCryptDecrypt(); test_key_import_export(); + test_ECDSA(); if (pBCryptHash) /* >= Win 10 */ test_BcryptHash(); -- 1.9.1

1 0

[v2 PATCH 2/3] bcrypt: Add support for 192 and 256 bit aes keys.
by Alistair Leslie-Hughes March 22, 2018

March 22, 2018

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/bcrypt/bcrypt_main.c | 14 ++++++++++++-- dlls/bcrypt/tests/bcrypt.c | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index c66090d..17db4d3 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -1003,11 +1003,21 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) WARN( "handle block size\n" ); switch (key->mode) { - case MODE_ID_GCM: return GNUTLS_CIPHER_AES_128_GCM; + 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: - default: return GNUTLS_CIPHER_AES_128_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; } + FIXME( "aes mode %u with key length %u not supported\n", key->mode, key->secret_len ); + return GNUTLS_CIPHER_UNKNOWN; default: FIXME( "algorithm %u not supported\n", key->alg_id ); return GNUTLS_CIPHER_UNKNOWN; diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index cc1b27a..a302d7d 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -622,6 +622,9 @@ static void test_BCryptEncrypt(void) {0x60,0x50,0x40,0x30,0x20,0x10,0x60,0x50,0x40,0x30,0x20,0x10}; static UCHAR secret[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}; + static UCHAR secret256[] = + {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00}; static UCHAR iv[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}; static UCHAR data[] = @@ -650,6 +653,10 @@ static void test_BCryptEncrypt(void) {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99, 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99}; + static UCHAR expected8[] = + {0x66,0xb8,0xbd,0xe5,0x90,0x6c,0xec,0xdf,0xfa,0x8a,0xb2,0xfd,0x92,0x84,0xeb,0xf0, + 0x95,0xc4,0xdf,0xa7,0x7a,0x62,0xe4,0xab,0xd4,0x0e,0x94,0x4e,0xd7,0x6e,0xa1,0x47, + 0x29,0x4b,0x37,0xfe,0x28,0x6d,0x5f,0x69,0x46,0x30,0x73,0xc0,0xaa,0x42,0xe4,0x46}; static UCHAR expected_tag[] = {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0}; static UCHAR expected_tag2[] = @@ -762,6 +769,31 @@ static void test_BCryptEncrypt(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); HeapFree(GetProcessHeap(), 0, buf); + /* 256 bit key */ + buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + ret = pBCryptGenerateSymmetricKey(aes, &key, buf, len, secret256, sizeof(secret256), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + ret = pBCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + ok(!memcmp(ciphertext, expected8, sizeof(expected8)), "wrong data\n"); + for (i = 0; i < 48; i++) + ok(ciphertext[i] == expected8[i], "%u: %02x != %02x\n", i, ciphertext[i], expected8[i]); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + /****************** * AES - GCM mode * ******************/ -- 1.9.1

1 0

[v2 PATCH 1/3] bcrypt: Implement support for ECB chain mode.
by Alistair Leslie-Hughes March 22, 2018

March 22, 2018

From: Sebastian Lackner <sebastian(a)fds-team.de> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/bcrypt/bcrypt_main.c | 43 +++++++-- dlls/bcrypt/tests/bcrypt.c | 211 ++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 244 insertions(+), 10 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index e05e94c..c66090d 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -225,6 +225,7 @@ enum alg_id enum mode_id { + MODE_ID_ECB, MODE_ID_CBC, MODE_ID_GCM }; @@ -574,8 +575,9 @@ static NTSTATUS get_alg_property( const struct algorithm *alg, const WCHAR *prop const WCHAR *mode; switch (alg->mode) { - case MODE_ID_GCM: mode = BCRYPT_CHAIN_MODE_GCM; break; + 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; } @@ -628,7 +630,12 @@ static NTSTATUS set_alg_property( struct algorithm *alg, const WCHAR *prop, UCHA case ALG_ID_AES: if (!strcmpW( prop, BCRYPT_CHAINING_MODE )) { - if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) + if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) + { + alg->mode = MODE_ID_ECB; + return STATUS_SUCCESS; + } + else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { alg->mode = MODE_ID_CBC; return STATUS_SUCCESS; @@ -962,7 +969,12 @@ static NTSTATUS set_key_property( struct key *key, const WCHAR *prop, UCHAR *val { if (!strcmpW( prop, BCRYPT_CHAINING_MODE )) { - if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) + if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) + { + key->mode = MODE_ID_ECB; + return STATUS_SUCCESS; + } + else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { key->mode = MODE_ID_CBC; return STATUS_SUCCESS; @@ -992,6 +1004,7 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) switch (key->mode) { case MODE_ID_GCM: return GNUTLS_CIPHER_AES_128_GCM; + case MODE_ID_ECB: /* can be emulated with CBC + empty IV */ case MODE_ID_CBC: default: return GNUTLS_CIPHER_AES_128_CBC; } @@ -1003,6 +1016,7 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) { + static const UCHAR zero_iv[16]; gnutls_cipher_algorithm_t cipher; gnutls_datum_t secret, vector; int ret; @@ -1016,15 +1030,18 @@ static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) if ((cipher = get_gnutls_cipher( key )) == GNUTLS_CIPHER_UNKNOWN) return STATUS_NOT_SUPPORTED; - secret.data = key->secret; - secret.size = key->secret_len; - if (iv) + if (!iv) { - vector.data = iv; - vector.size = iv_len; + iv = (UCHAR *)zero_iv; + iv_len = sizeof(zero_iv); } - if ((ret = pgnutls_cipher_init( &key->handle, cipher, &secret, iv ? &vector : NULL ))) + secret.data = key->secret; + secret.size = key->secret_len; + vector.data = iv; + vector.size = iv_len; + + if ((ret = pgnutls_cipher_init( &key->handle, cipher, &secret, &vector ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1463,11 +1480,15 @@ NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp 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; + src = input; dst = output; while (bytes_left >= key->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, iv, iv_len ))) return status; bytes_left -= key->block_size; src += key->block_size; dst += key->block_size; @@ -1550,11 +1571,15 @@ NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp else if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL; + if (key->mode == MODE_ID_ECB && iv) + return STATUS_INVALID_PARAMETER; + src = input; dst = output; while (bytes_left >= key->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, iv, iv_len ))) return status; bytes_left -= key->block_size; src += key->block_size; dst += key->block_size; diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index d38e581..cc1b27a 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -641,6 +641,15 @@ static void test_BCryptEncrypt(void) static UCHAR expected4[] = {0xe1,0x82,0xc3,0xc0,0x24,0xfb,0x86,0x85,0xf3,0xf1,0x2b,0x7d,0x09,0xb4,0x73,0x67, 0x86,0x64,0xc3,0xfe,0xa3,0x07,0x61,0xf8,0x16,0xc9,0x78,0x7f,0xe7,0xb1,0xc4,0x94}; + static UCHAR expected5[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a}; + static UCHAR expected6[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x84,0x07,0x66,0xb7,0x49,0xc0,0x9b,0x49,0x74,0x28,0x8c,0x10,0xb9,0xc2,0x09,0x70}; + static UCHAR expected7[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99}; static UCHAR expected_tag[] = {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0}; static UCHAR expected_tag2[] = @@ -875,6 +884,97 @@ static void test_BCryptEncrypt(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); HeapFree(GetProcessHeap(), 0, buf); + /****************** + * AES - ECB mode * + ******************/ + + ret = pBCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + len = 0xdeadbeef; + size = sizeof(len); + ret = pBCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + ret = pBCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + /* initialization vector is not allowed */ + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + ret = pBCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0); + ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret); + ok(size == 16, "got %u\n", size); + + /* input size is a multiple of block size */ + size = 0; + ret = pBCryptEncrypt(key, data, 16, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 16, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data, 16, NULL, NULL, 16, ciphertext, 16, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 16, "got %u\n", size); + ok(!memcmp(ciphertext, expected5, sizeof(expected5)), "wrong data\n"); + for (i = 0; i < 16; i++) + ok(ciphertext[i] == expected5[i], "%u: %02x != %02x\n", i, ciphertext[i], expected5[i]); + + /* input size is not a multiple of block size */ + size = 0; + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %08x\n", ret); + ok(size == 17, "got %u\n", size); + + /* input size is not a multiple of block size, block padding set */ + size = 0; + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + ok(!memcmp(ciphertext, expected6, sizeof(expected6)), "wrong data\n"); + for (i = 0; i < 32; i++) + ok(ciphertext[i] == expected6[i], "%u: %02x != %02x\n", i, ciphertext[i], expected6[i]); + + /* input size is a multiple of block size, block padding set */ + size = 0; + ret = pBCryptEncrypt(key, data2, 32, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data2, 32, NULL, NULL, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + ok(!memcmp(ciphertext, expected7, sizeof(expected7)), "wrong data\n"); + for (i = 0; i < 48; i++) + ok(ciphertext[i] == expected7[i], "%u: %02x != %02x\n", i, ciphertext[i], expected7[i]); + + /* output size too small */ + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, ciphertext, 31, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data2, 32, NULL, NULL, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + ret = pBCryptCloseAlgorithmProvider(aes, 0); ok(ret == STATUS_SUCCESS, "got %08x\n", ret); } @@ -909,6 +1009,13 @@ static void test_BCryptDecrypt(void) static UCHAR ciphertext4[] = {0xe1,0x82,0xc3,0xc0,0x24,0xfb,0x86,0x85,0xf3,0xf1,0x2b,0x7d,0x09,0xb4,0x73,0x67, 0x86,0x64,0xc3,0xfe,0xa3,0x07,0x61,0xf8,0x16,0xc9,0x78,0x7f,0xe7,0xb1,0xc4,0x94}; + static UCHAR ciphertext5[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x84,0x07,0x66,0xb7,0x49,0xc0,0x9b,0x49,0x74,0x28,0x8c,0x10,0xb9,0xc2,0x09,0x70}; + static UCHAR ciphertext6[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99}; static UCHAR tag[] = {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0}; static UCHAR tag2[] = @@ -1040,7 +1147,7 @@ static void test_BCryptDecrypt(void) * AES - GCM mode * ******************/ - ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_GCM, sizeof(BCRYPT_CHAIN_MODE_GCM), 0); + ret = pBCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_GCM, sizeof(BCRYPT_CHAIN_MODE_GCM), 0); ok(ret == STATUS_SUCCESS, "got %08x\n", ret); key = NULL; @@ -1091,6 +1198,108 @@ static void test_BCryptDecrypt(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); HeapFree(GetProcessHeap(), 0, buf); + /****************** + * AES - ECB mode * + ******************/ + + ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + len = 0xdeadbeef; + size = sizeof(len); + ret = pBCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + ret = pBCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + /* initialization vector is not allowed */ + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, ivbuf, 16, plaintext, 32, &size, 0); + ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + /* input size is a multiple of block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(plaintext, 0, sizeof(plaintext)); + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 32, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + ok(!memcmp(plaintext, expected, sizeof(expected)), "wrong data\n"); + + /* test with padding smaller than block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(plaintext, 0, sizeof(plaintext)); + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 17, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 17, "got %u\n", size); + ok(!memcmp(plaintext, expected2, sizeof(expected2)), "wrong data\n"); + + /* test with padding of block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + size = 0; + memset(plaintext, 0, sizeof(plaintext)); + ret = pBCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, plaintext, 32, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n"); + + /* output size too small */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext4, 32, NULL, NULL, 16, plaintext, 31, &size, 0); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 15, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 16, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 17, "got %u\n", size); + + size = 0; + ret = pBCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, plaintext, 31, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + /* input size is not a multiple of block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext4, 17, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %08x\n", ret); + ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %u\n", size); + + /* input size is not a multiple of block size, block padding set */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext4, 17, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %08x\n", ret); + ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %u\n", size); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + ret = pBCryptCloseAlgorithmProvider(aes, 0); ok(ret == STATUS_SUCCESS, "got %08x\n", ret); } -- 1.9.1

1 0

[PATCH 3/3] bcrypt/tests: Add basic test for ecdsa.
by Alistair Leslie-Hughes March 22, 2018

March 22, 2018

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/bcrypt/tests/bcrypt.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index 5dc3c6e..a262251 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -50,6 +50,8 @@ static NTSTATUS (WINAPI *pBCryptDestroyKey)(BCRYPT_KEY_HANDLE); static NTSTATUS (WINAPI *pBCryptImportKey)(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, BCRYPT_KEY_HANDLE *, PUCHAR, ULONG, PUCHAR, ULONG, ULONG); static NTSTATUS (WINAPI *pBCryptExportKey)(BCRYPT_KEY_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, PUCHAR, ULONG, ULONG *, ULONG); +static NTSTATUS (WINAPI *pBCryptImportKeyPair)(BCRYPT_ALG_HANDLE, BCRYPT_KEY_HANDLE, LPCWSTR, BCRYPT_KEY_HANDLE *, UCHAR *, ULONG, ULONG); +static NTSTATUS (WINAPI *pBCryptVerifySignature)(BCRYPT_KEY_HANDLE, VOID *, UCHAR *, ULONG, UCHAR *, ULONG, ULONG); static void test_BCryptGenRandom(void) { @@ -1382,6 +1384,66 @@ static void test_key_import_export(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); } +static BYTE eccPubkey[] = +{ + /* X */ + 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, + /* Y */ + 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, +}; +static BYTE certHash[] = +{ + 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, +}; +static BYTE certSignature[] = +{ + /* r */ + 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, + /* s */ + 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, +}; + +static void test_ECDSA(void) +{ + BYTE buffer[sizeof(BCRYPT_ECCKEY_BLOB) + sizeof(eccPubkey)]; + BCRYPT_ECCKEY_BLOB *ecckey = (void *)buffer; + BCRYPT_ALG_HANDLE alg = NULL; + BCRYPT_KEY_HANDLE key = NULL; + NTSTATUS status; + + status = pBCryptOpenAlgorithmProvider(&alg, BCRYPT_ECDSA_P256_ALGORITHM, NULL, 0); + if (status) + { + todo_wine win_skip("Failed to open ECDSA provider: %08x, skipping test\n", status); + return; + } + + ecckey->dwMagic = BCRYPT_ECDSA_PUBLIC_P256_MAGIC; + memcpy(ecckey + 1, eccPubkey, sizeof(eccPubkey)); + + ecckey->cbKey = 2; + status = pBCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, sizeof(buffer), 0); + ok(status == STATUS_INVALID_PARAMETER, "Expected STATUS_INVALID_PARAMETER, got %08x\n", status); + + ecckey->cbKey = sizeof(eccPubkey) / 2; + status = pBCryptImportKeyPair(alg, NULL, BCRYPT_ECCPUBLIC_BLOB, &key, buffer, sizeof(buffer), 0); + 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); + + status = pBCryptVerifySignature(key, NULL, certHash, sizeof(certHash), certSignature, sizeof(certSignature), 0); + ok(!status, "BCryptVerifySignature failed: %08x\n", status); + + pBCryptDestroyKey(key); + pBCryptCloseAlgorithmProvider(alg, 0); +} + START_TEST(bcrypt) { HMODULE module; @@ -1412,6 +1474,8 @@ START_TEST(bcrypt) pBCryptDestroyKey = (void *)GetProcAddress(module, "BCryptDestroyKey"); pBCryptImportKey = (void *)GetProcAddress(module, "BCryptImportKey"); pBCryptExportKey = (void *)GetProcAddress(module, "BCryptExportKey"); + pBCryptImportKeyPair = (void *)GetProcAddress(module, "BCryptImportKeyPair"); + pBCryptVerifySignature = (void *)GetProcAddress(module, "BCryptVerifySignature"); test_BCryptGenRandom(); test_BCryptGetFipsAlgorithmMode(); @@ -1422,6 +1486,7 @@ START_TEST(bcrypt) test_BCryptEncrypt(); test_BCryptDecrypt(); test_key_import_export(); + test_ECDSA(); if (pBCryptHash) /* >= Win 10 */ test_BcryptHash(); -- 1.9.1

2 1

[PATCH 2/3] bcrypt: Add support for 192 and 256 bit aes keys.
by Alistair Leslie-Hughes March 22, 2018

March 22, 2018

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/bcrypt/bcrypt_main.c | 14 ++++++++++++-- dlls/bcrypt/tests/bcrypt.c | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index c66090d..17db4d3 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -1003,11 +1003,21 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) WARN( "handle block size\n" ); switch (key->mode) { - case MODE_ID_GCM: return GNUTLS_CIPHER_AES_128_GCM; + 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: - default: return GNUTLS_CIPHER_AES_128_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; } + FIXME( "aes mode %u with key length %u not supported\n", key->mode, key->secret_len ); + return GNUTLS_CIPHER_UNKNOWN; default: FIXME( "algorithm %u not supported\n", key->alg_id ); return GNUTLS_CIPHER_UNKNOWN; diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index 9d4b976..5dc3c6e 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -622,6 +622,9 @@ static void test_BCryptEncrypt(void) {0x60,0x50,0x40,0x30,0x20,0x10,0x60,0x50,0x40,0x30,0x20,0x10}; static UCHAR secret[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}; + static UCHAR secret256[] = + {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f, + 0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00}; static UCHAR iv[] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f}; static UCHAR data[] = @@ -650,6 +653,10 @@ static void test_BCryptEncrypt(void) {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99, 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99}; + static UCHAR expected8[] = + {0x66,0xb8,0xbd,0xe5,0x90,0x6c,0xec,0xdf,0xfa,0x8a,0xb2,0xfd,0x92,0x84,0xeb,0xf0, + 0x95,0xc4,0xdf,0xa7,0x7a,0x62,0xe4,0xab,0xd4,0x0e,0x94,0x4e,0xd7,0x6e,0xa1,0x47, + 0x29,0x4b,0x37,0xfe,0x28,0x6d,0x5f,0x69,0x46,0x30,0x73,0xc0,0xaa,0x42,0xe4,0x46}; static UCHAR expected_tag[] = {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0}; static UCHAR expected_tag2[] = @@ -762,6 +769,31 @@ static void test_BCryptEncrypt(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); HeapFree(GetProcessHeap(), 0, buf); + /* 256 bit key */ + buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + ret = pBCryptGenerateSymmetricKey(aes, &key, buf, len, secret256, sizeof(secret256), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + ret = pBCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data2, 32, NULL, ivbuf, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + ok(!memcmp(ciphertext, expected8, sizeof(expected8)), "wrong data\n"); + for (i = 0; i < 48; i++) + ok(ciphertext[i] == expected8[i], "%u: %02x != %02x\n", i, ciphertext[i], expected8[i]); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + /****************** * AES - GCM mode * ******************/ -- 1.9.1

2 1

[PATCH 1/3] bcrypt: Implement support for ECB chain mode.
by Alistair Leslie-Hughes March 22, 2018

March 22, 2018

From: Sebastian Lackner <sebastian(a)fds-team.de> Signed-off-by: Alistair Leslie-Hughes <leslie_alistair(a)hotmail.com> --- dlls/bcrypt/bcrypt_main.c | 43 ++++++++-- dlls/bcrypt/tests/bcrypt.c | 210 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 244 insertions(+), 9 deletions(-) diff --git a/dlls/bcrypt/bcrypt_main.c b/dlls/bcrypt/bcrypt_main.c index e05e94c..c66090d 100644 --- a/dlls/bcrypt/bcrypt_main.c +++ b/dlls/bcrypt/bcrypt_main.c @@ -225,6 +225,7 @@ enum alg_id enum mode_id { + MODE_ID_ECB, MODE_ID_CBC, MODE_ID_GCM }; @@ -574,8 +575,9 @@ static NTSTATUS get_alg_property( const struct algorithm *alg, const WCHAR *prop const WCHAR *mode; switch (alg->mode) { - case MODE_ID_GCM: mode = BCRYPT_CHAIN_MODE_GCM; break; + 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; } @@ -628,7 +630,12 @@ static NTSTATUS set_alg_property( struct algorithm *alg, const WCHAR *prop, UCHA case ALG_ID_AES: if (!strcmpW( prop, BCRYPT_CHAINING_MODE )) { - if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) + if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) + { + alg->mode = MODE_ID_ECB; + return STATUS_SUCCESS; + } + else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { alg->mode = MODE_ID_CBC; return STATUS_SUCCESS; @@ -962,7 +969,12 @@ static NTSTATUS set_key_property( struct key *key, const WCHAR *prop, UCHAR *val { if (!strcmpW( prop, BCRYPT_CHAINING_MODE )) { - if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) + if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) + { + key->mode = MODE_ID_ECB; + return STATUS_SUCCESS; + } + else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { key->mode = MODE_ID_CBC; return STATUS_SUCCESS; @@ -992,6 +1004,7 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) switch (key->mode) { case MODE_ID_GCM: return GNUTLS_CIPHER_AES_128_GCM; + case MODE_ID_ECB: /* can be emulated with CBC + empty IV */ case MODE_ID_CBC: default: return GNUTLS_CIPHER_AES_128_CBC; } @@ -1003,6 +1016,7 @@ static gnutls_cipher_algorithm_t get_gnutls_cipher( const struct key *key ) static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) { + static const UCHAR zero_iv[16]; gnutls_cipher_algorithm_t cipher; gnutls_datum_t secret, vector; int ret; @@ -1016,15 +1030,18 @@ static NTSTATUS key_set_params( struct key *key, UCHAR *iv, ULONG iv_len ) if ((cipher = get_gnutls_cipher( key )) == GNUTLS_CIPHER_UNKNOWN) return STATUS_NOT_SUPPORTED; - secret.data = key->secret; - secret.size = key->secret_len; - if (iv) + if (!iv) { - vector.data = iv; - vector.size = iv_len; + iv = (UCHAR *)zero_iv; + iv_len = sizeof(zero_iv); } - if ((ret = pgnutls_cipher_init( &key->handle, cipher, &secret, iv ? &vector : NULL ))) + secret.data = key->secret; + secret.size = key->secret_len; + vector.data = iv; + vector.size = iv_len; + + if ((ret = pgnutls_cipher_init( &key->handle, cipher, &secret, &vector ))) { pgnutls_perror( ret ); return STATUS_INTERNAL_ERROR; @@ -1463,11 +1480,15 @@ NTSTATUS WINAPI BCryptEncrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp 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; + src = input; dst = output; while (bytes_left >= key->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, iv, iv_len ))) return status; bytes_left -= key->block_size; src += key->block_size; dst += key->block_size; @@ -1550,11 +1571,15 @@ NTSTATUS WINAPI BCryptDecrypt( BCRYPT_KEY_HANDLE handle, UCHAR *input, ULONG inp else if (output_len < *ret_len) return STATUS_BUFFER_TOO_SMALL; + if (key->mode == MODE_ID_ECB && iv) + return STATUS_INVALID_PARAMETER; + src = input; dst = output; while (bytes_left >= key->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, iv, iv_len ))) return status; bytes_left -= key->block_size; src += key->block_size; dst += key->block_size; diff --git a/dlls/bcrypt/tests/bcrypt.c b/dlls/bcrypt/tests/bcrypt.c index d38e581..9d4b976 100644 --- a/dlls/bcrypt/tests/bcrypt.c +++ b/dlls/bcrypt/tests/bcrypt.c @@ -641,6 +641,15 @@ static void test_BCryptEncrypt(void) static UCHAR expected4[] = {0xe1,0x82,0xc3,0xc0,0x24,0xfb,0x86,0x85,0xf3,0xf1,0x2b,0x7d,0x09,0xb4,0x73,0x67, 0x86,0x64,0xc3,0xfe,0xa3,0x07,0x61,0xf8,0x16,0xc9,0x78,0x7f,0xe7,0xb1,0xc4,0x94}; + static UCHAR expected5[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a}; + static UCHAR expected6[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x84,0x07,0x66,0xb7,0x49,0xc0,0x9b,0x49,0x74,0x28,0x8c,0x10,0xb9,0xc2,0x09,0x70}; + static UCHAR expected7[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99}; static UCHAR expected_tag[] = {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0}; static UCHAR expected_tag2[] = @@ -875,6 +884,97 @@ static void test_BCryptEncrypt(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); HeapFree(GetProcessHeap(), 0, buf); + /****************** + * AES - ECB mode * + ******************/ + + ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + len = 0xdeadbeef; + size = sizeof(len); + ret = pBCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + ret = pBCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + /* initialization vector is not allowed */ + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + ret = pBCryptEncrypt(key, data, 16, NULL, ivbuf, 16, ciphertext, 16, &size, 0); + ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret); + ok(size == 16, "got %u\n", size); + + /* input size is a multiple of block size */ + size = 0; + ret = pBCryptEncrypt(key, data, 16, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 16, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data, 16, NULL, NULL, 16, ciphertext, 16, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 16, "got %u\n", size); + ok(!memcmp(ciphertext, expected5, sizeof(expected5)), "wrong data\n"); + for (i = 0; i < 16; i++) + ok(ciphertext[i] == expected5[i], "%u: %02x != %02x\n", i, ciphertext[i], expected5[i]); + + /* input size is not a multiple of block size */ + size = 0; + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %08x\n", ret); + ok(size == 17, "got %u\n", size); + + /* input size is not a multiple of block size, block padding set */ + size = 0; + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + ok(!memcmp(ciphertext, expected6, sizeof(expected6)), "wrong data\n"); + for (i = 0; i < 32; i++) + ok(ciphertext[i] == expected6[i], "%u: %02x != %02x\n", i, ciphertext[i], expected6[i]); + + /* input size is a multiple of block size, block padding set */ + size = 0; + ret = pBCryptEncrypt(key, data2, 32, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data2, 32, NULL, NULL, 16, ciphertext, 48, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + ok(!memcmp(ciphertext, expected7, sizeof(expected7)), "wrong data\n"); + for (i = 0; i < 48; i++) + ok(ciphertext[i] == expected7[i], "%u: %02x != %02x\n", i, ciphertext[i], expected7[i]); + + /* output size too small */ + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data, 17, NULL, NULL, 16, ciphertext, 31, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(ciphertext, 0, sizeof(ciphertext)); + ret = pBCryptEncrypt(key, data2, 32, NULL, NULL, 16, ciphertext, 32, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + ret = pBCryptCloseAlgorithmProvider(aes, 0); ok(ret == STATUS_SUCCESS, "got %08x\n", ret); } @@ -909,6 +1009,13 @@ static void test_BCryptDecrypt(void) static UCHAR ciphertext4[] = {0xe1,0x82,0xc3,0xc0,0x24,0xfb,0x86,0x85,0xf3,0xf1,0x2b,0x7d,0x09,0xb4,0x73,0x67, 0x86,0x64,0xc3,0xfe,0xa3,0x07,0x61,0xf8,0x16,0xc9,0x78,0x7f,0xe7,0xb1,0xc4,0x94}; + static UCHAR ciphertext5[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x84,0x07,0x66,0xb7,0x49,0xc0,0x9b,0x49,0x74,0x28,0x8c,0x10,0xb9,0xc2,0x09,0x70}; + static UCHAR ciphertext6[] = + {0x0a,0x94,0x0b,0xb5,0x41,0x6e,0xf0,0x45,0xf1,0xc3,0x94,0x58,0xc6,0x53,0xea,0x5a, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99, + 0x95,0x4f,0x64,0xf2,0xe4,0xe8,0x6e,0x9e,0xee,0x82,0xd2,0x02,0x16,0x68,0x48,0x99}; static UCHAR tag[] = {0x89,0xb3,0x92,0x00,0x39,0x20,0x09,0xb4,0x6a,0xd6,0xaf,0xca,0x4b,0x5b,0xfd,0xd0}; static UCHAR tag2[] = @@ -1091,6 +1198,109 @@ static void test_BCryptDecrypt(void) ok(ret == STATUS_SUCCESS, "got %08x\n", ret); HeapFree(GetProcessHeap(), 0, buf); + /****************** + * AES - ECB mode * + ******************/ + + ret = BCryptSetProperty(aes, BCRYPT_CHAINING_MODE, (UCHAR*)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + len = 0xdeadbeef; + size = sizeof(len); + ret = pBCryptGetProperty(aes, BCRYPT_OBJECT_LENGTH, (UCHAR *)&len, sizeof(len), &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len); + ret = pBCryptGenerateSymmetricKey(aes, &key, buf, len, secret, sizeof(secret), 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + + /* initialization vector is not allowed */ + size = 0; + memcpy(ivbuf, iv, sizeof(iv)); + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, ivbuf, 16, plaintext, 32, &size, 0); + ok(ret == STATUS_INVALID_PARAMETER, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + /* input size is a multiple of block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(plaintext, 0, sizeof(plaintext)); + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 32, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + ok(!memcmp(plaintext, expected, sizeof(expected)), "wrong data\n"); + + /* test with padding smaller than block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + memset(plaintext, 0, sizeof(plaintext)); + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 17, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 17, "got %u\n", size); + ok(!memcmp(plaintext, expected2, sizeof(expected2)), "wrong data\n"); + + /* test with padding of block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + size = 0; + memset(plaintext, 0, sizeof(plaintext)); + ret = pBCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, plaintext, 32, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + ok(!memcmp(plaintext, expected3, sizeof(expected3)), "wrong data\n"); + + /* output size too small */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext4, 32, NULL, NULL, 16, plaintext, 31, &size, 0); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 15, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 32, "got %u\n", size); + + size = 0; + ret = pBCryptDecrypt(key, ciphertext5, 32, NULL, NULL, 16, plaintext, 16, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 17, "got %u\n", size); + + size = 0; + ret = pBCryptDecrypt(key, ciphertext6, 48, NULL, NULL, 16, plaintext, 31, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_BUFFER_TOO_SMALL, "got %08x\n", ret); + ok(size == 48, "got %u\n", size); + + /* input size is not a multiple of block size */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext4, 17, NULL, NULL, 16, NULL, 0, &size, 0); + ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %08x\n", ret); + ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %u\n", size); + + /* input size is not a multiple of block size, block padding set */ + size = 0; + ret = pBCryptDecrypt(key, ciphertext4, 17, NULL, NULL, 16, NULL, 0, &size, BCRYPT_BLOCK_PADDING); + ok(ret == STATUS_INVALID_BUFFER_SIZE, "got %08x\n", ret); + ok(size == 17 || broken(size == 0 /* Win < 7 */), "got %u\n", size); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_SUCCESS, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + + ret = pBCryptDestroyKey(key); + ok(ret == STATUS_INVALID_HANDLE, "got %08x\n", ret); + HeapFree(GetProcessHeap(), 0, buf); + ret = pBCryptCloseAlgorithmProvider(aes, 0); ok(ret == STATUS_SUCCESS, "got %08x\n", ret); } -- 1.9.1

2 1