git.oblomov.eu Git - wine/blob - dlls/crypt32/tests/message.c

   1 /*
   2  * Unit test suite for crypt32.dll's Crypt*Message functions
   3  *
   4  * Copyright 2007-2008 Juan Lang
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <windef.h>
  24 #include <winbase.h>
  25 #include <winerror.h>
  26 #include <wincrypt.h>
  27
  28 #include "wine/test.h"
  29
  30 static BOOL (WINAPI * pCryptAcquireContextA)
  31                         (HCRYPTPROV *, LPCSTR, LPCSTR, DWORD, DWORD);
  32
  33 static void init_function_pointers(void)
  34 {
  35     HMODULE hAdvapi32 = GetModuleHandleA("advapi32.dll");
  36
  37 #define GET_PROC(dll, func) \
  38     p ## func = (void *)GetProcAddress(dll, #func); \
  39     if(!p ## func) \
  40       trace("GetProcAddress(%s) failed\n", #func);
  41
  42     GET_PROC(hAdvapi32, CryptAcquireContextA)
  43
  44 #undef GET_PROC
  45 }
  46
  47 static const BYTE dataEmptyBareContent[] = { 0x04,0x00 };
  48 static const BYTE dataEmptyContent[] = {
  49 0x30,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x02,
  50 0x04,0x00 };
  51 static const BYTE signedEmptyBareContent[] = {
  52 0x30,0x50,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
  53 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x37,0x30,0x35,0x02,
  54 0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
  55 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
  56 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,
  57 0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
  58 static const BYTE signedEmptyContent[] = {
  59 0x30,0x5f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,0x52,
  60 0x30,0x50,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,
  61 0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0x31,0x37,0x30,0x35,0x02,
  62 0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
  63 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
  64 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,
  65 0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
  66
  67 static void test_msg_get_signer_count(void)
  68 {
  69     LONG count;
  70
  71     SetLastError(0xdeadbeef);
  72     count = CryptGetMessageSignerCount(0, NULL, 0);
  73     ok(count == -1, "Expected -1, got %d\n", count);
  74     ok(GetLastError() == E_INVALIDARG, "Expected E_INVALIDARG, got %08x\n",
  75      GetLastError());
  76     SetLastError(0xdeadbeef);
  77     count = CryptGetMessageSignerCount(PKCS_7_ASN_ENCODING, NULL, 0);
  78     ok(count == -1, "Expected -1, got %d\n", count);
  79     ok(GetLastError() == CRYPT_E_ASN1_EOD ||
  80        GetLastError() == OSS_BAD_ARG, /* win9x */
  81      "Expected CRYPT_E_ASN1_EOD, got %08x\n", GetLastError());
  82     SetLastError(0xdeadbeef);
  83     count = CryptGetMessageSignerCount(PKCS_7_ASN_ENCODING,
  84      dataEmptyBareContent, sizeof(dataEmptyBareContent));
  85     ok(count == -1, "Expected -1, got %d\n", count);
  86     ok(GetLastError() == CRYPT_E_ASN1_BADTAG ||
  87        GetLastError() == OSS_PDU_MISMATCH, /* win9x */
  88      "Expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
  89     SetLastError(0xdeadbeef);
  90     count = CryptGetMessageSignerCount(PKCS_7_ASN_ENCODING,
  91      dataEmptyContent, sizeof(dataEmptyContent));
  92     ok(count == -1, "Expected -1, got %d\n", count);
  93     ok(GetLastError() == CRYPT_E_INVALID_MSG_TYPE,
  94      "Expected CRYPT_E_INVALID_MSG_TYPE, got %08x\n", GetLastError());
  95     SetLastError(0xdeadbeef);
  96     count = CryptGetMessageSignerCount(PKCS_7_ASN_ENCODING,
  97      signedEmptyBareContent, sizeof(signedEmptyBareContent));
  98     ok(count == -1, "Expected -1, got %d\n", count);
  99     ok(GetLastError() == CRYPT_E_ASN1_BADTAG ||
 100        GetLastError() == OSS_DATA_ERROR, /* win9x */
 101      "Expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
 102     count = CryptGetMessageSignerCount(PKCS_7_ASN_ENCODING,
 103      signedEmptyContent, sizeof(signedEmptyContent));
 104     ok(count == 1 ||
 105        broken(count == -1), /* win9x */
 106        "Expected 1, got %d\n", count);
 107 }
 108
 109 static BYTE detachedHashContent[] = {
 110 0x30,0x3f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x32,
 111 0x30,0x30,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 112 0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 113 0x07,0x01,0x04,0x10,0x08,0xd6,0xc0,0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,
 114 0x9d,0x2a,0x8f,0x26,0x2f };
 115 static const BYTE msgData[] = { 1, 2, 3, 4 };
 116
 117 static void test_verify_detached_message_hash(void)
 118 {
 119     BOOL ret;
 120     CRYPT_HASH_MESSAGE_PARA para;
 121     DWORD size, hashSize;
 122     const BYTE *pMsgData = msgData;
 123     BYTE hash[16];
 124
 125     if (0)
 126     {
 127         ret = CryptVerifyDetachedMessageHash(NULL, NULL, 0, 0, NULL, NULL, NULL,
 128          NULL);
 129     }
 130     memset(&para, 0, sizeof(para));
 131     SetLastError(0xdeadbeef);
 132     ret = CryptVerifyDetachedMessageHash(&para, NULL, 0, 0, NULL, NULL, NULL,
 133      NULL);
 134     ok(!ret && GetLastError() == E_INVALIDARG,
 135      "expected E_INVALIDARG, got %08x\n", GetLastError());
 136     para.cbSize = sizeof(para);
 137     SetLastError(0xdeadbeef);
 138     ret = CryptVerifyDetachedMessageHash(&para, NULL, 0, 0, NULL, NULL, NULL,
 139      NULL);
 140     ok(!ret && GetLastError() == E_INVALIDARG,
 141      "expected E_INVALIDARG, got %08x\n", GetLastError());
 142     para.dwMsgEncodingType = PKCS_7_ASN_ENCODING;
 143     SetLastError(0xdeadbeef);
 144     ret = CryptVerifyDetachedMessageHash(&para, NULL, 0, 0, NULL, NULL, NULL,
 145      NULL);
 146     ok(!ret &&
 147      (GetLastError() == CRYPT_E_ASN1_EOD ||
 148       GetLastError() == OSS_BAD_ARG), /* win9x */
 149      "expected CRYPT_E_ASN1_EOD, got %08x\n", GetLastError());
 150     para.dwMsgEncodingType = X509_ASN_ENCODING;
 151     SetLastError(0xdeadbeef);
 152     ret = CryptVerifyDetachedMessageHash(&para, NULL, 0, 0, NULL, NULL, NULL,
 153      NULL);
 154     ok(!ret && GetLastError() == E_INVALIDARG,
 155      "expected E_INVALIDARG, got %08x\n", GetLastError());
 156     para.dwMsgEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
 157     SetLastError(0xdeadbeef);
 158     ret = CryptVerifyDetachedMessageHash(&para, NULL, 0, 0, NULL, NULL, NULL,
 159      NULL);
 160     ok(!ret &&
 161      (GetLastError() == CRYPT_E_ASN1_EOD ||
 162       GetLastError() == OSS_BAD_ARG), /* win9x */
 163      "expected CRYPT_E_ASN1_EOD, got %08x\n", GetLastError());
 164     /* Curiously, passing no data to hash succeeds.. */
 165     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 166      sizeof(detachedHashContent), 0, NULL, NULL, NULL, NULL);
 167     todo_wine
 168     ok(ret, "CryptVerifyDetachedMessageHash failed: %08x\n", GetLastError());
 169     /* as does passing the actual content of the message to hash.. */
 170     size = sizeof(msgData);
 171     pMsgData = msgData;
 172     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 173      sizeof(detachedHashContent), 1, &pMsgData, &size, NULL, NULL);
 174     ok(ret, "CryptVerifyDetachedMessageHash failed: %08x\n", GetLastError());
 175     /* while passing data to hash that isn't the content of the message fails.
 176      */
 177     size = sizeof(detachedHashContent);
 178     pMsgData = detachedHashContent;
 179     SetLastError(0xdeadbeef);
 180     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 181      sizeof(detachedHashContent), 1, &pMsgData, &size, NULL, NULL);
 182     ok(!ret && GetLastError() == CRYPT_E_HASH_VALUE,
 183      "expected CRYPT_E_HASH_VALUE, got %08x\n", GetLastError());
 184     /* Getting the size of the hash while passing no hash data causes the
 185      * hash to be checked (and fail.)
 186      */
 187     SetLastError(0xdeadbeef);
 188     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 189      sizeof(detachedHashContent), 0, NULL, NULL, NULL, &hashSize);
 190     ok(!ret && GetLastError() == CRYPT_E_HASH_VALUE,
 191      "expected CRYPT_E_HASH_VALUE, got %08x\n", GetLastError());
 192     size = sizeof(msgData);
 193     pMsgData = msgData;
 194     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 195      sizeof(detachedHashContent), 1, &pMsgData, &size, NULL, &hashSize);
 196     ok(ret, "CryptVerifyDetachedMessageHash failed: %08x\n", GetLastError());
 197     ok(hashSize == sizeof(hash), "unexpected size %d\n", hashSize);
 198     hashSize = 1;
 199     SetLastError(0xdeadbeef);
 200     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 201      sizeof(detachedHashContent), 1, &pMsgData, &size, hash, &hashSize);
 202     ok(!ret && GetLastError() == ERROR_MORE_DATA,
 203      "expected ERROR_MORE_DATA, got %08x\n", GetLastError());
 204     hashSize = sizeof(hash);
 205     ret = CryptVerifyDetachedMessageHash(&para, detachedHashContent,
 206      sizeof(detachedHashContent), 1, &pMsgData, &size, hash, &hashSize);
 207     ok(ret, "CryptVerifyDetachedMessageHash failed: %08x\n", GetLastError());
 208 }
 209
 210 static BYTE hashContent[] = {
 211 0x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
 212 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 213 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 214 0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,0x04,0x10,0x08,0xd6,0xc0,
 215 0x5a,0x21,0x51,0x2a,0x79,0xa1,0xdf,0xeb,0x9d,0x2a,0x8f,0x26,0x2f };
 216
 217 static void test_verify_message_hash(void)
 218 {
 219     BOOL ret;
 220     CRYPT_HASH_MESSAGE_PARA para;
 221     DWORD size;
 222     BYTE *buf = NULL;
 223
 224     memset(&para, 0, sizeof(para));
 225     /* Crash */
 226     if (0)
 227         ret = CryptVerifyMessageHash(NULL, NULL, 0, NULL, NULL, NULL, NULL);
 228     SetLastError(0xdeadbeef);
 229     ret = CryptVerifyMessageHash(&para, NULL, 0, NULL, NULL, NULL, NULL);
 230     ok(!ret && GetLastError() == E_INVALIDARG,
 231      "expected E_INVALIDARG, got %08x\n", GetLastError());
 232     para.cbSize = sizeof(para);
 233     SetLastError(0xdeadbeef);
 234     ret = CryptVerifyMessageHash(&para, NULL, 0, NULL, NULL, NULL, NULL);
 235     ok(!ret && GetLastError() == E_INVALIDARG,
 236      "expected E_INVALIDARG, got %08x\n", GetLastError());
 237     para.dwMsgEncodingType = PKCS_7_ASN_ENCODING;
 238     SetLastError(0xdeadbeef);
 239     ret = CryptVerifyMessageHash(&para, NULL, 0, NULL, NULL, NULL, NULL);
 240     ok(!ret, "Expected 0, got %d\n", ret);
 241     ok(GetLastError() == CRYPT_E_ASN1_EOD ||
 242        GetLastError() == OSS_BAD_ARG, /* win98 */
 243      "Expected CRYPT_E_ASN1_EOD or OSS_BAD_ARG, got %08x\n", GetLastError());
 244     /* Verifying the hash of a detached message succeeds? */
 245     ret = CryptVerifyMessageHash(&para, detachedHashContent,
 246      sizeof(detachedHashContent), NULL, NULL, NULL, NULL);
 247     todo_wine
 248     ok(ret, "CryptVerifyMessageHash failed: %08x\n", GetLastError());
 249     /* As does verifying the hash of a regular message. */
 250     ret = CryptVerifyMessageHash(&para, hashContent, sizeof(hashContent),
 251      NULL, NULL, NULL, NULL);
 252     ok(ret, "CryptVerifyMessageHash failed: %08x\n", GetLastError());
 253     ret = CryptVerifyMessageHash(&para, hashContent, sizeof(hashContent),
 254      NULL, &size, NULL, NULL);
 255     ok(ret, "CryptVerifyMessageHash failed: %08x\n", GetLastError());
 256     if (ret)
 257         buf = CryptMemAlloc(size);
 258     if (buf)
 259     {
 260         size = 1;
 261         ret = CryptVerifyMessageHash(&para, hashContent, sizeof(hashContent),
 262          buf, &size, NULL, NULL);
 263         ok(!ret && GetLastError() == ERROR_MORE_DATA,
 264          "expected ERROR_MORE_DATA, got %08x\n", GetLastError());
 265         ret = CryptVerifyMessageHash(&para, hashContent, sizeof(hashContent),
 266          buf, &size, NULL, NULL);
 267         ok(ret, "CryptVerifyMessageHash failed: %08x\n", GetLastError());
 268         ok(size == sizeof(msgData), "unexpected size %d\n", size);
 269         ok(!memcmp(buf, msgData, size), "unexpected value\n");
 270         CryptMemFree(buf);
 271     }
 272 }
 273
 274 static const BYTE signedWithCertContent[] = {
 275 0x30,0x82,0x01,0x32,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
 276 0xa0,0x82,0x01,0x23,0x30,0x82,0x01,0x1f,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
 277 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,
 278 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,
 279 0x02,0x03,0x04,0xa0,0x7c,0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,
 280 0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,
 281 0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,
 282 0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,
 283 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,
 284 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
 285 0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,
 286 0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,
 287 0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01,0x31,0x77,0x30,0x75,0x02,0x01,
 288 0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,
 289 0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,
 290 0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,
 291 0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,
 292 0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,
 293 0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,
 294 0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,
 295 0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
 296 static const BYTE signedContent[] = {
 297 0x30,0x81,0xb2,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 298 0x81,0xa4,0x30,0x81,0xa1,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 299 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,
 300 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,
 301 0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,
 302 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
 303 0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 304 0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0x81,0xa6,0x70,
 305 0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,
 306 0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,
 307 0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,
 308 0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,
 309 0x0d };
 310 static const BYTE detachedSignedContent[] = {
 311 0x30,0x81,0xaa,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 312 0x81,0x9c,0x30,0x81,0x99,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 313 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,
 314 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,
 315 0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
 316 0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,
 317 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,
 318 0x05,0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,
 319 0x9a,0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,
 320 0x1e,0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,
 321 0x64,0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,
 322 0xe4,0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
 323 static const BYTE v1CertWithValidPubKey[] = {
 324 0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,
 325 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
 326 0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,
 327 0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,
 328 0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,
 329 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
 330 0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 331 0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,0x02,0x41,0x00,0xe2,0x54,0x3a,
 332 0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,0x53,0xe6,0x1f,0xe7,0x5d,0xf1,
 333 0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,0x65,0x97,0x03,0x86,0x60,0xde,
 334 0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,0x62,0x17,0xa9,0xcd,0x79,0x3f,
 335 0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,0x18,0x10,0x6b,0xd0,0x1c,0x10,
 336 0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,0x14,0x30,0x12,0x06,0x03,0x55,
 337 0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
 338
 339 static PCCERT_CONTEXT WINAPI msg_get_signer_callback(void *pvArg,
 340  DWORD certEncodingType, PCERT_INFO signerId, HCERTSTORE store)
 341 {
 342     return CertCreateCertificateContext(X509_ASN_ENCODING,
 343      v1CertWithValidPubKey, sizeof(v1CertWithValidPubKey));
 344 }
 345
 346 static void test_verify_detached_message_signature(void)
 347 {
 348     CRYPT_VERIFY_MESSAGE_PARA para;
 349     BOOL ret;
 350     const BYTE *pContent;
 351     DWORD cbContent;
 352
 353     memset(&para, 0, sizeof(para));
 354     SetLastError(0xdeadbeef);
 355     ret = CryptVerifyDetachedMessageSignature(NULL, 0, NULL, 0, 0, NULL,
 356      NULL, NULL);
 357     ok(!ret && GetLastError() == E_INVALIDARG,
 358      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 359     SetLastError(0xdeadbeef);
 360     ret = CryptVerifyDetachedMessageSignature(&para, 0, NULL, 0, 0, NULL,
 361      NULL, NULL);
 362     ok(!ret && GetLastError() == E_INVALIDARG,
 363      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 364     para.cbSize = sizeof(para);
 365     SetLastError(0xdeadbeef);
 366     ret = CryptVerifyDetachedMessageSignature(&para, 0, NULL, 0, 0, NULL,
 367      NULL, NULL);
 368     ok(!ret && GetLastError() == E_INVALIDARG,
 369      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 370     para.dwMsgAndCertEncodingType = X509_ASN_ENCODING;
 371     SetLastError(0xdeadbeef);
 372     ret = CryptVerifyDetachedMessageSignature(&para, 0, NULL, 0, 0, NULL,
 373      NULL, NULL);
 374     ok(!ret && GetLastError() == E_INVALIDARG,
 375      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 376     para.dwMsgAndCertEncodingType = PKCS_7_ASN_ENCODING;
 377     SetLastError(0xdeadbeef);
 378     ret = CryptVerifyDetachedMessageSignature(&para, 0, NULL, 0, 0, NULL,
 379      NULL, NULL);
 380     ok(!ret, "Expected 0, got %d\n", ret);
 381     ok(GetLastError() == CRYPT_E_ASN1_EOD ||
 382      GetLastError() == OSS_BAD_ARG, /* win98 */
 383      "Expected CRYPT_E_ASN1_EOD or OSS_BAD_ARG, got %08x\n", GetLastError());
 384     /* None of these messages contains a cert in the message itself, so the
 385      * default callback isn't able to verify their signature.
 386      */
 387     SetLastError(0xdeadbeef);
 388     ret = CryptVerifyDetachedMessageSignature(&para, 0, signedWithCertContent,
 389      sizeof(signedWithCertContent), 0, NULL, NULL, NULL);
 390     ok(!ret, "Expected 0, got %d\n", ret);
 391     todo_wine
 392     ok(GetLastError() == CRYPT_E_NOT_FOUND ||
 393      GetLastError() == OSS_DATA_ERROR, /* win98 */
 394      "Expected CRYPT_E_NOT_FOUND or OSS_DATA_ERROR, got %08x\n", GetLastError());
 395     SetLastError(0xdeadbeef);
 396     ret = CryptVerifyDetachedMessageSignature(&para, 0, signedContent,
 397      sizeof(signedContent), 0, NULL, NULL, NULL);
 398     ok(!ret, "Expected 0, got %d\n", ret);
 399     ok(GetLastError() == CRYPT_E_NOT_FOUND ||
 400      GetLastError() == OSS_DATA_ERROR, /* win98 */
 401      "Expected CRYPT_E_NOT_FOUND or OSS_DATA_ERROR, got %08x\n", GetLastError());
 402     SetLastError(0xdeadbeef);
 403     ret = CryptVerifyDetachedMessageSignature(&para, 0, detachedSignedContent,
 404      sizeof(detachedSignedContent), 0, NULL, NULL, NULL);
 405     ok(!ret, "Expected 0, got %d\n", ret);
 406     ok(GetLastError() == CRYPT_E_NOT_FOUND ||
 407      GetLastError() == OSS_DATA_ERROR, /* win98 */
 408      "Expected CRYPT_E_NOT_FOUND or OSS_DATA_ERROR, got %08x\n", GetLastError());
 409     SetLastError(0xdeadbeef);
 410     pContent = msgData;
 411     cbContent = sizeof(msgData);
 412     ret = CryptVerifyDetachedMessageSignature(&para, 0, detachedSignedContent,
 413      sizeof(detachedSignedContent), 1, &pContent, &cbContent, NULL);
 414     ok(!ret, "Expected 0, got %d\n", ret);
 415     ok(GetLastError() == CRYPT_E_NOT_FOUND ||
 416      GetLastError() == OSS_DATA_ERROR, /* win98 */
 417      "Expected CRYPT_E_NOT_FOUND or OSS_DATA_ERROR, got %08x\n", GetLastError());
 418     /* Passing the correct callback results in success */
 419     para.pfnGetSignerCertificate = msg_get_signer_callback;
 420     ret = CryptVerifyDetachedMessageSignature(&para, 0, detachedSignedContent,
 421      sizeof(detachedSignedContent), 1, &pContent, &cbContent, NULL);
 422     ok(ret ||
 423      broken(!ret), /* win98 */
 424      "CryptVerifyDetachedMessageSignature failed: %08x\n",
 425      GetLastError());
 426     /* Not passing the correct data to be signed results in the signature not
 427      * matching.
 428      */
 429     SetLastError(0xdeadbeef);
 430     ret = CryptVerifyDetachedMessageSignature(&para, 0, detachedSignedContent,
 431      sizeof(detachedSignedContent), 0, NULL, NULL, NULL);
 432     ok(!ret, "Expected 0, got %d\n", ret);
 433     ok(GetLastError() == NTE_BAD_SIGNATURE ||
 434      GetLastError() == OSS_DATA_ERROR, /* win98 */
 435      "Expected NTE_BAD_SIGNATURE or OSS_DATA_ERROR, got %08x\n", GetLastError());
 436 }
 437
 438 static const BYTE signedWithCertEmptyContent[] = {
 439 0x30,0x81,0xdf,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 440 0x81,0xd1,0x30,0x81,0xce,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 441 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x7c,
 442 0x30,0x7a,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,0x30,0x11,
 443 0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,
 444 0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
 445 0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
 446 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,
 447 0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,
 448 0x00,0x30,0x07,0x30,0x02,0x06,0x00,0x03,0x01,0x00,0xa3,0x16,0x30,0x14,0x30,
 449 0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,
 450 0xff,0x02,0x01,0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,
 451 0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,
 452 0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,
 453 0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
 454 0x00 };
 455 static const BYTE signedWithCertWithPubKeyContent[] = {
 456 0x30,0x81,0xfc,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 457 0x81,0xee,0x30,0x81,0xeb,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 458 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x02,0x06,0x00,0xa0,0x81,
 459 0x98,0x30,0x81,0x95,0x02,0x01,0x01,0x30,0x02,0x06,0x00,0x30,0x15,0x31,0x13,
 460 0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,
 461 0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,
 462 0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,
 463 0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x15,0x31,0x13,0x30,
 464 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
 465 0x6e,0x67,0x00,0x30,0x22,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 466 0x01,0x01,0x01,0x05,0x00,0x03,0x11,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,
 467 0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0xa3,0x16,0x30,0x14,0x30,0x12,
 468 0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,
 469 0x02,0x01,0x01,0x31,0x37,0x30,0x35,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,
 470 0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
 471 0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
 472 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x00 };
 473 static const BYTE signedWithCertWithValidPubKeyContent[] = {
 474 0x30,0x82,0x01,0x89,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
 475 0xa0,0x82,0x01,0x7a,0x30,0x82,0x01,0x76,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
 476 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,
 477 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,
 478 0x02,0x03,0x04,0xa0,0x81,0xd2,0x30,0x81,0xcf,0x02,0x01,0x01,0x30,0x02,0x06,
 479 0x00,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,
 480 0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x22,0x18,0x0f,0x31,0x36,
 481 0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x18,0x0f,
 482 0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,
 483 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
 484 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x30,0x5c,0x30,0x0d,0x06,0x09,0x2a,
 485 0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,0x30,0x48,
 486 0x02,0x41,0x00,0xe2,0x54,0x3a,0xa7,0x83,0xb1,0x27,0x14,0x3e,0x59,0xbb,0xb4,
 487 0x53,0xe6,0x1f,0xe7,0x5d,0xf1,0x21,0x68,0xad,0x85,0x53,0xdb,0x6b,0x1e,0xeb,
 488 0x65,0x97,0x03,0x86,0x60,0xde,0xf3,0x6c,0x38,0x75,0xe0,0x4c,0x61,0xbb,0xbc,
 489 0x62,0x17,0xa9,0xcd,0x79,0x3f,0x21,0x4e,0x96,0xcb,0x0e,0xdc,0x61,0x94,0x30,
 490 0x18,0x10,0x6b,0xd0,0x1c,0x10,0x79,0x02,0x03,0x01,0x00,0x01,0xa3,0x16,0x30,
 491 0x14,0x30,0x12,0x06,0x03,0x55,0x1d,0x13,0x01,0x01,0xff,0x04,0x08,0x30,0x06,
 492 0x01,0x01,0xff,0x02,0x01,0x01,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,
 493 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
 494 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,
 495 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,
 496 0x00,0x04,0x40,0x81,0xa6,0x70,0xb3,0xef,0x59,0xd1,0x66,0xd1,0x9b,0xc0,0x9a,
 497 0xb6,0x9a,0x5e,0x6d,0x6f,0x6d,0x0d,0x59,0xa9,0xaa,0x6e,0xe9,0x2c,0xa0,0x1e,
 498 0xee,0xc2,0x60,0xbc,0x59,0xbe,0x3f,0x63,0x06,0x8d,0xc9,0x11,0x1d,0x23,0x64,
 499 0x92,0xef,0x2e,0xfc,0x57,0x29,0xa4,0xaf,0xe0,0xee,0x93,0x19,0x39,0x51,0xe4,
 500 0x44,0xb8,0x0b,0x28,0xf4,0xa8,0x0d };
 501
 502 static void test_verify_message_signature(void)
 503 {
 504     BOOL ret;
 505     CRYPT_VERIFY_MESSAGE_PARA para = { 0 };
 506     PCCERT_CONTEXT cert;
 507     DWORD cbDecoded;
 508     BYTE decoded[sizeof(msgData)];
 509
 510     SetLastError(0xdeadbeef);
 511     ret = CryptVerifyMessageSignature(NULL, 0, NULL, 0, NULL, 0, NULL);
 512     ok(!ret && GetLastError() == E_INVALIDARG,
 513      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 514     /* Is cbDecoded set when invalid parameters are passed? */
 515     cbDecoded = 0xdeadbeef;
 516     ret = CryptVerifyMessageSignature(NULL, 0, NULL, 0, NULL, &cbDecoded,
 517      NULL);
 518     ok(cbDecoded == 0, "expected 0, got %08x\n", cbDecoded);
 519     SetLastError(0xdeadbeef);
 520     ret = CryptVerifyMessageSignature(&para, 0, NULL, 0, NULL, 0, NULL);
 521     ok(!ret && GetLastError() == E_INVALIDARG,
 522      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 523     para.cbSize = sizeof(para);
 524     SetLastError(0xdeadbeef);
 525     ret = CryptVerifyMessageSignature(&para, 0, NULL, 0, NULL, 0, NULL);
 526     ok(!ret && GetLastError() == E_INVALIDARG,
 527      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 528     para.cbSize = 0;
 529     para.dwMsgAndCertEncodingType = PKCS_7_ASN_ENCODING;
 530     SetLastError(0xdeadbeef);
 531     ret = CryptVerifyMessageSignature(&para, 0, NULL, 0, NULL, 0, NULL);
 532     ok(!ret && GetLastError() == E_INVALIDARG,
 533      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 534     para.cbSize = sizeof(para);
 535     SetLastError(0xdeadbeef);
 536     ret = CryptVerifyMessageSignature(&para, 0, NULL, 0, NULL, 0, NULL);
 537     ok(!ret &&
 538      (GetLastError() == CRYPT_E_ASN1_EOD ||
 539       GetLastError() == OSS_BAD_ARG), /* win9x */
 540      "Expected CRYPT_E_ASN1_EOD, got %08x\n", GetLastError());
 541     /* Check whether cert is set on error */
 542     cert = (PCCERT_CONTEXT)0xdeadbeef;
 543     ret = CryptVerifyMessageSignature(&para, 0, NULL, 0, NULL, 0, &cert);
 544     ok(cert == NULL, "Expected NULL cert\n");
 545     /* Check whether cbDecoded is set on error */
 546     cbDecoded = 0xdeadbeef;
 547     ret = CryptVerifyMessageSignature(&para, 0, NULL, 0, NULL, &cbDecoded,
 548      NULL);
 549     ok(!cbDecoded, "Expected 0\n");
 550     SetLastError(0xdeadbeef);
 551     ret = CryptVerifyMessageSignature(&para, 0, dataEmptyBareContent,
 552      sizeof(dataEmptyBareContent), NULL, 0, NULL);
 553     ok(GetLastError() == CRYPT_E_ASN1_BADTAG ||
 554      GetLastError() == OSS_PDU_MISMATCH, /* win9x */
 555      "Expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
 556     SetLastError(0xdeadbeef);
 557     ret = CryptVerifyMessageSignature(&para, 0, dataEmptyContent,
 558      sizeof(dataEmptyContent), NULL, 0, NULL);
 559     ok(!ret && GetLastError() == CRYPT_E_UNEXPECTED_MSG_TYPE,
 560      "Expected CRYPT_E_UNEXPECTED_MSG_TYPE, got %08x\n", GetLastError());
 561     SetLastError(0xdeadbeef);
 562     ret = CryptVerifyMessageSignature(&para, 0, signedEmptyBareContent,
 563      sizeof(signedEmptyBareContent), NULL, 0, NULL);
 564     ok(!ret &&
 565      (GetLastError() == CRYPT_E_ASN1_BADTAG ||
 566       GetLastError() == OSS_DATA_ERROR), /* win9x */
 567      "Expected CRYPT_E_ASN1_BADTAG, got %08x\n", GetLastError());
 568     SetLastError(0xdeadbeef);
 569     ret = CryptVerifyMessageSignature(&para, 0, signedEmptyContent,
 570      sizeof(signedEmptyContent), NULL, 0, NULL);
 571     ok(!ret &&
 572      (GetLastError() == CRYPT_E_NOT_FOUND ||
 573       GetLastError() == OSS_DATA_ERROR), /* win9x */
 574      "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
 575     SetLastError(0xdeadbeef);
 576     ret = CryptVerifyMessageSignature(&para, 0, signedContent,
 577      sizeof(signedContent), NULL, 0, NULL);
 578     ok(!ret &&
 579      (GetLastError() == CRYPT_E_NOT_FOUND ||
 580       GetLastError() == OSS_DATA_ERROR), /* win9x */
 581      "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
 582     /* FIXME: Windows fails with CRYPT_E_NOT_FOUND for these messages, but
 583      * their signer certs have invalid public keys that fail to decode.  In
 584      * Wine therefore the failure is an ASN error.  Need some messages with
 585      * valid public keys and invalid signatures to check against.
 586      */
 587     ret = CryptVerifyMessageSignature(&para, 0, signedWithCertEmptyContent,
 588      sizeof(signedWithCertEmptyContent), NULL, 0, NULL);
 589     ok(!ret, "Expected failure\n");
 590     ret = CryptVerifyMessageSignature(&para, 0, signedWithCertContent,
 591      sizeof(signedWithCertContent), NULL, 0, NULL);
 592     ok(!ret, "Expected failure\n");
 593     ret = CryptVerifyMessageSignature(&para, 0, signedWithCertWithPubKeyContent,
 594      sizeof(signedWithCertWithPubKeyContent), NULL, 0, NULL);
 595     ok(!ret, "Expected failure\n");
 596     /* Apparently, an output pcbDecoded parameter is expected. */
 597     ret = CryptVerifyMessageSignature(&para, 0,
 598      signedWithCertWithValidPubKeyContent,
 599      sizeof(signedWithCertWithValidPubKeyContent), NULL, 0, NULL);
 600     ok(!ret, "Expected failure\n");
 601     /* Finally, a message signed with a valid public key verifies successfully
 602      */
 603     cbDecoded = 0xdeadbeef;
 604     ret = CryptVerifyMessageSignature(&para, 0,
 605      signedWithCertWithValidPubKeyContent,
 606      sizeof(signedWithCertWithValidPubKeyContent), NULL, &cbDecoded, NULL);
 607     ok(ret, "CryptVerifyMessageSignature failed: %08x\n", GetLastError());
 608     ok(cbDecoded == sizeof(msgData), "expected 4, got %d\n", cbDecoded);
 609     cbDecoded = 0;
 610     ret = CryptVerifyMessageSignature(&para, 0,
 611      signedWithCertWithValidPubKeyContent,
 612      sizeof(signedWithCertWithValidPubKeyContent), NULL, &cbDecoded, NULL);
 613     /* Setting cbDecoded to 0 succeeds when a NULL buffer is provided */
 614     ok(ret, "CryptVerifyMessageSignature failed: %08x\n", GetLastError());
 615     ok(cbDecoded == sizeof(msgData), "expected 4, got %d\n", cbDecoded);
 616     cbDecoded = 0;
 617     ret = CryptVerifyMessageSignature(&para, 0,
 618      signedWithCertWithValidPubKeyContent,
 619      sizeof(signedWithCertWithValidPubKeyContent), decoded, &cbDecoded, NULL);
 620     /* When a non-NULL buffer is provided, cbDecoded must not be too small */
 621     ok(!ret && GetLastError() == ERROR_MORE_DATA,
 622      "expected ERROR_MORE_DATA, got %d (%08x)\n", GetLastError(),
 623      GetLastError());
 624 }
 625
 626 static const BYTE detachedHashBlob[] = {
 627 0x30,0x3f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x32,
 628 0x30,0x30,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 629 0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 630 0x07,0x01,0x04,0x10,0x2d,0x1b,0xbc,0x1f,0xc7,0xab,0x36,0x8d,0xdb,0x95,0xe6,
 631 0x24,0xb9,0x66,0x7c,0x21 };
 632 static const BYTE hashBlob[] = {
 633 0x30,0x47,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x05,0xa0,0x3a,
 634 0x30,0x38,0x02,0x01,0x00,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 635 0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 636 0x07,0x01,0xa0,0x06,0x04,0x04,0xde,0xad,0xbe,0xef,0x04,0x10,0x2f,0x24,0x92,
 637 0x30,0xa8,0xe7,0xc2,0xbf,0x60,0x05,0xcc,0xd2,0x67,0x92,0x59,0xec };
 638 static const BYTE hashVal[] = {
 639 0x2d,0x1b,0xbc,0x1f,0xc7,0xab,0x36,0x8d,0xdb,0x95,0xe6,0x24,0xb9,0x66,0x7c,
 640 0x21 };
 641
 642 static void test_hash_message(void)
 643 {
 644     BOOL ret;
 645     CRYPT_HASH_MESSAGE_PARA para;
 646     static const BYTE blob1[] = { 0xde, 0xad, 0xbe, 0xef };
 647     static const BYTE blob2[] = { 0xba, 0xad, 0xf0, 0x0d };
 648     const BYTE *toHash[] = { blob1, blob2 };
 649     DWORD hashSize[] = { sizeof(blob1), sizeof(blob2) };
 650     DWORD hashedBlobSize, computedHashSize;
 651     static char oid_rsa_md5[] = szOID_RSA_MD5;
 652     LPBYTE hashedBlob, computedHash;
 653
 654     /* Crash
 655     ret = CryptHashMessage(NULL, FALSE, 0, NULL, 0, NULL, NULL, NULL, NULL);
 656      */
 657     memset(&para, 0, sizeof(para));
 658     SetLastError(0xdeadbeef);
 659     ret = CryptHashMessage(&para, FALSE, 0, NULL, NULL, NULL, NULL, NULL, NULL);
 660     ok(!ret && GetLastError() == E_INVALIDARG,
 661      "expected E_INVALIDARG, got 0x%08x\n", GetLastError());
 662     para.cbSize = sizeof(para);
 663     /* Not quite sure what "success" means in this case, but it does succeed */
 664     SetLastError(0xdeadbeef);
 665     ret = CryptHashMessage(&para, FALSE, 0, NULL, NULL, NULL, NULL, NULL, NULL);
 666     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 667     /* With a bogus encoding type it "succeeds" */
 668     para.dwMsgEncodingType = 0xdeadbeef;
 669     SetLastError(0xdeadbeef);
 670     ret = CryptHashMessage(&para, FALSE, 0, NULL, NULL, NULL, NULL, NULL, NULL);
 671     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 672     /* According to MSDN, the third parameter (cToBeHashed) must be 1 if the
 673      * second parameter (fDetached) is FALSE, but again it "succeeds."
 674      */
 675     SetLastError(0xdeadbeef);
 676     ret = CryptHashMessage(&para, FALSE, 2, NULL, NULL, NULL, NULL, NULL, NULL);
 677     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 678     /* Even passing parameters to hash results in "success." */
 679     SetLastError(0xdeadbeef);
 680     ret = CryptHashMessage(&para, FALSE, 2, toHash, hashSize, NULL, NULL, NULL,
 681      NULL);
 682     /* Try again with a valid encoding type */
 683     para.dwMsgEncodingType = PKCS_7_ASN_ENCODING;
 684     SetLastError(0xdeadbeef);
 685     ret = CryptHashMessage(&para, FALSE, 2, NULL, NULL, NULL, NULL, NULL, NULL);
 686     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 687     /* And with valid data to hash */
 688     SetLastError(0xdeadbeef);
 689     ret = CryptHashMessage(&para, FALSE, 2, toHash, hashSize, NULL, NULL, NULL,
 690      NULL);
 691     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 692     /* But requesting the size of the hashed blob and indicating there's data
 693      * to hash results in a crash
 694      */
 695     if (0)
 696     {
 697         ret = CryptHashMessage(&para, FALSE, 2, NULL, NULL, NULL,
 698          &hashedBlobSize, NULL, NULL);
 699     }
 700     /* Passing a valid pointer for the data to hash fails, as the hash
 701      * algorithm is finally checked.
 702      */
 703     SetLastError(0xdeadbeef);
 704     ret = CryptHashMessage(&para, FALSE, 2, toHash, hashSize, NULL,
 705      &hashedBlobSize, NULL, NULL);
 706     ok(!ret &&
 707      (GetLastError() == CRYPT_E_UNKNOWN_ALGO ||
 708       GetLastError() == CRYPT_E_OID_FORMAT), /* Vista */
 709      "expected CRYPT_E_UNKNOWN_ALGO or CRYPT_E_OID_FORMAT, got 0x%08x (%d)\n",
 710      GetLastError(), GetLastError());
 711     para.HashAlgorithm.pszObjId = oid_rsa_md5;
 712     /* With a valid hash algorithm, this succeeds, even though fDetached is
 713      * FALSE.
 714      */
 715     SetLastError(0xdeadbeef);
 716     ret = CryptHashMessage(&para, FALSE, 2, toHash, hashSize, NULL,
 717      &hashedBlobSize, NULL, NULL);
 718     todo_wine
 719     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 720     if (ret)
 721     {
 722         /* Actually attempting to get the hashed data fails, perhaps because
 723          * detached is FALSE.
 724          */
 725         hashedBlob = HeapAlloc(GetProcessHeap(), 0, hashedBlobSize);
 726         SetLastError(0xdeadbeef);
 727         ret = CryptHashMessage(&para, FALSE, 2, toHash, hashSize, hashedBlob,
 728          &hashedBlobSize, NULL, NULL);
 729         ok(!ret && GetLastError() == CRYPT_E_MSG_ERROR,
 730          "expected CRYPT_E_MSG_ERROR, got 0x%08x (%d)\n", GetLastError(),
 731          GetLastError());
 732         HeapFree(GetProcessHeap(), 0, hashedBlob);
 733     }
 734     /* Repeating tests with fDetached = TRUE results in success */
 735     SetLastError(0xdeadbeef);
 736     ret = CryptHashMessage(&para, TRUE, 2, toHash, hashSize, NULL,
 737      &hashedBlobSize, NULL, NULL);
 738     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 739     if (ret)
 740     {
 741         hashedBlob = HeapAlloc(GetProcessHeap(), 0, hashedBlobSize);
 742         SetLastError(0xdeadbeef);
 743         ret = CryptHashMessage(&para, TRUE, 2, toHash, hashSize, hashedBlob,
 744          &hashedBlobSize, NULL, NULL);
 745         ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 746         ok(hashedBlobSize == sizeof(detachedHashBlob),
 747          "unexpected size of detached blob %d\n", hashedBlobSize);
 748         ok(!memcmp(hashedBlob, detachedHashBlob, hashedBlobSize),
 749          "unexpected detached blob value\n");
 750         HeapFree(GetProcessHeap(), 0, hashedBlob);
 751     }
 752     /* Hashing a single item with fDetached = FALSE also succeeds */
 753     SetLastError(0xdeadbeef);
 754     ret = CryptHashMessage(&para, FALSE, 1, toHash, hashSize, NULL,
 755      &hashedBlobSize, NULL, NULL);
 756     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 757     if (ret)
 758     {
 759         hashedBlob = HeapAlloc(GetProcessHeap(), 0, hashedBlobSize);
 760         ret = CryptHashMessage(&para, FALSE, 1, toHash, hashSize, hashedBlob,
 761          &hashedBlobSize, NULL, NULL);
 762         ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 763         ok(hashedBlobSize == sizeof(hashBlob),
 764          "unexpected size of detached blob %d\n", hashedBlobSize);
 765         ok(!memcmp(hashedBlob, hashBlob, hashedBlobSize),
 766          "unexpected detached blob value\n");
 767         HeapFree(GetProcessHeap(), 0, hashedBlob);
 768     }
 769     /* Check the computed hash value too.  You don't need to get the encoded
 770      * blob to get it.
 771      */
 772     computedHashSize = 0xdeadbeef;
 773     ret = CryptHashMessage(&para, TRUE, 2, toHash, hashSize, NULL,
 774      &hashedBlobSize, NULL, &computedHashSize);
 775     ok(ret, "CryptHashMessage failed: 0x%08x\n", GetLastError());
 776     ok(computedHashSize == 16, "expected hash size of 16, got %d\n",
 777      computedHashSize);
 778     if (ret)
 779     {
 780         computedHash = HeapAlloc(GetProcessHeap(), 0, computedHashSize);
 781         SetLastError(0xdeadbeef);
 782         ret = CryptHashMessage(&para, TRUE, 2, toHash, hashSize, NULL,
 783          &hashedBlobSize, computedHash, &computedHashSize);
 784         ok(computedHashSize == sizeof(hashVal),
 785          "unexpected size of hash value %d\n", computedHashSize);
 786         ok(!memcmp(computedHash, hashVal, computedHashSize),
 787          "unexpected value\n");
 788         HeapFree(GetProcessHeap(), 0, computedHash);
 789     }
 790 }
 791
 792 static const BYTE publicPrivateKeyPair[] = {
 793 0x07,0x02,0x00,0x00,0x00,0x24,0x00,0x00,0x52,0x53,0x41,0x32,0x00,0x02,0x00,
 794 0x00,0x01,0x00,0x01,0x00,0x9b,0xd9,0x60,0xd9,0x5b,0x09,0x50,0x9e,0x09,0x94,
 795 0x1e,0x6a,0x06,0x1d,0xdd,0x39,0xc5,0x96,0x17,0xe3,0xb9,0x0c,0x71,0x9c,0xf7,
 796 0xc1,0x07,0x7b,0xd7,0x4a,0xaa,0x8a,0x3e,0xcd,0x78,0x3c,0x4c,0x95,0x98,0x28,
 797 0x29,0x2d,0xe0,0xfc,0xe6,0x4f,0x95,0xca,0x87,0x92,0xdd,0xa3,0x8d,0xf0,0x39,
 798 0xf3,0x1b,0x87,0x64,0x82,0x99,0xc0,0xa9,0xe8,0x87,0x86,0x2e,0x72,0x07,0x07,
 799 0x8f,0x45,0x54,0x51,0x2f,0x51,0xd0,0x60,0x97,0x48,0x54,0x0e,0x78,0xb5,0x7e,
 800 0x2b,0x9d,0xca,0x81,0xa8,0xa8,0x00,0x57,0x69,0xa6,0xf7,0x4d,0x45,0xe0,0xf7,
 801 0xfa,0xd2,0xeb,0xaa,0xb8,0x06,0x34,0xce,0xf0,0x9d,0x2b,0x76,0x8a,0x4f,0x70,
 802 0x51,0x90,0x33,0x72,0xcb,0x81,0x85,0x7e,0x35,0x2e,0xfb,0x81,0xf0,0xc7,0x85,
 803 0xa5,0x75,0xf9,0x2d,0x00,0x71,0x66,0x36,0xfe,0x22,0xd6,0xc9,0x36,0x61,0x9b,
 804 0x64,0x92,0xe8,0x25,0x38,0x35,0xeb,0x0c,0x84,0x83,0x76,0x42,0x90,0xf7,0x73,
 805 0x91,0xdc,0x43,0x83,0x07,0x77,0xc9,0x1b,0x3f,0x74,0xc0,0xbe,0x18,0x97,0xd6,
 806 0x86,0xe5,0xfa,0x28,0x7c,0xf7,0x8d,0x89,0xb1,0x93,0xac,0x48,0x3c,0xa1,0x02,
 807 0xfa,0xc6,0x1c,0xa0,0xb5,0xe8,0x4f,0xd7,0xd1,0x33,0x63,0x8b,0x7e,0xf1,0x94,
 808 0x56,0x07,0xbc,0x6e,0x0c,0xbd,0xa0,0x15,0xba,0x99,0x5d,0xb7,0x5e,0x09,0xf2,
 809 0x1b,0x46,0x85,0x61,0x91,0x6a,0x78,0x31,0xb5,0xf0,0xba,0x20,0xf5,0x7a,0xb4,
 810 0x8e,0xd3,0x50,0x87,0xf8,0xf3,0xe4,0xd9,0xab,0x6f,0x0e,0x59,0x42,0xac,0x7d,
 811 0xb1,0x8c,0xea,0x33,0x54,0x08,0x38,0xc9,0xcd,0xac,0x10,0x19,0x4a,0xba,0x89,
 812 0xdc,0xb6,0x73,0xef,0xec,0x56,0x93,0xd6,0xf2,0x4b,0xba,0x50,0x2d,0x8f,0x15,
 813 0xed,0x8b,0xb5,0x67,0xc8,0xfc,0x51,0x5f };
 814 static const BYTE cert1[] = {
 815 0x30,0x81,0xd0,0x30,0x81,0xbe,0xa0,0x03,0x02,0x01,0x02,0x02,0x10,0x20,0x42,
 816 0x68,0x69,0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,0x24,0x2f,0x3b,0xad,0x40,0x30,
 817 0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x30,0x0c,0x31,0x0a,0x30,
 818 0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x30,0x20,0x17,0x0d,0x31,0x30,
 819 0x30,0x39,0x31,0x34,0x31,0x33,0x31,0x39,0x30,0x39,0x5a,0x18,0x0f,0x33,0x30,
 820 0x31,0x30,0x30,0x39,0x31,0x34,0x31,0x33,0x31,0x39,0x30,0x39,0x5a,0x30,0x0c,
 821 0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x30,0x5c,0x30,
 822 0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,
 823 0x4b,0x00,0x30,0x48,0x02,0x41,0x00,0xe8,0xa9,0xc0,0x99,0x82,0x64,0x87,0x1b,
 824 0xf3,0x39,0xf0,0x8d,0xa3,0xdd,0x92,0x87,0xca,0x95,0x4f,0xe6,0xfc,0xe0,0x2d,
 825 0x29,0x28,0x98,0x95,0x4c,0x3c,0x78,0xcd,0x3e,0x8a,0xaa,0x4a,0xd7,0x7b,0x07,
 826 0xc1,0xf7,0x9c,0x71,0x0c,0xb9,0xe3,0x17,0x96,0xc5,0x39,0xdd,0x1d,0x06,0x6a,
 827 0x1e,0x94,0x09,0x9e,0x50,0x09,0x5b,0xd9,0x60,0xd9,0x9b,0x02,0x03,0x01,0x00,
 828 0x01,0x30,0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x03,0x02,0x00,
 829 0xc1 };
 830 static const BYTE cert2[] = {
 831 0x30,0x82,0x01,0x15,0x30,0x82,0x01,0x02,0xa0,0x03,0x02,0x01,0x02,0x02,0x10,
 832 0x1c,0xf2,0x1f,0xec,0x6b,0xdc,0x36,0xbf,0x4a,0xd7,0xe1,0x6c,0x84,0x85,0xcd,
 833 0x2e,0x30,0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x30,0x0c,0x31,
 834 0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x58,0x30,0x20,0x17,0x0d,
 835 0x31,0x30,0x30,0x37,0x31,0x32,0x31,0x31,0x33,0x37,0x35,0x36,0x5a,0x18,0x0f,
 836 0x33,0x30,0x31,0x30,0x30,0x37,0x31,0x32,0x31,0x31,0x33,0x37,0x35,0x36,0x5a,
 837 0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x58,0x30,
 838 0x81,0x9f,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,
 839 0x05,0x00,0x03,0x81,0x8d,0x00,0x30,0x81,0x89,0x02,0x81,0x81,0x00,0xab,0xed,
 840 0x6e,0xe0,0x00,0x3c,0xcf,0x2d,0x2b,0xda,0x05,0x88,0x6a,0x7e,0xed,0x60,0x30,
 841 0x24,0xef,0x6c,0x6b,0xad,0x28,0x9b,0x14,0x90,0xf6,0xd0,0x96,0x79,0x6d,0xad,
 842 0xac,0x46,0x14,0x7b,0x0e,0xfe,0xa9,0x8a,0x05,0x5a,0xc8,0x84,0x38,0x44,0xf9,
 843 0xce,0xb2,0xe6,0xde,0x5b,0x80,0x0b,0x15,0xff,0x1b,0x60,0x3f,0xba,0xb2,0xfe,
 844 0x6e,0xf5,0xdc,0x54,0x33,0xfc,0xfc,0x79,0x0a,0x10,0xa4,0x23,0x6d,0x67,0xeb,
 845 0x16,0xb2,0x92,0xbf,0x63,0x42,0x17,0x0a,0xde,0xe6,0xab,0x8e,0xf7,0x8e,0x41,
 846 0x8c,0x04,0xe8,0xe2,0x38,0x73,0xd3,0x82,0xd7,0xd1,0xee,0xd3,0xa6,0x54,0x8c,
 847 0xcd,0x0b,0x93,0xda,0x63,0x55,0x0d,0x1f,0x68,0x5c,0x30,0xee,0xad,0x2d,0xd5,
 848 0x40,0x56,0xe0,0xd8,0xc7,0xef,0x02,0x03,0x01,0x00,0x01,0x30,0x09,0x06,0x05,
 849 0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x03,0x02,0x00,0x06 };
 850 static const BYTE crl[] = {
 851 0x30,0x81,0xc2,0x30,0x7e,0x02,0x01,0x01,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,
 852 0x86,0xf7,0x0d,0x01,0x01,0x05,0x05,0x00,0x30,0x3c,0x31,0x0b,0x30,0x09,0x06,
 853 0x03,0x55,0x04,0x06,0x13,0x02,0x52,0x55,0x31,0x0c,0x30,0x0a,0x06,0x03,0x55,
 854 0x04,0x08,0x13,0x03,0x53,0x50,0x62,0x31,0x0c,0x30,0x0a,0x06,0x03,0x55,0x04,
 855 0x07,0x13,0x03,0x53,0x50,0x62,0x31,0x11,0x30,0x0f,0x06,0x03,0x55,0x04,0x0a,
 856 0x13,0x08,0x45,0x74,0x65,0x72,0x73,0x6f,0x66,0x74,0x17,0x0d,0x31,0x30,0x30,
 857 0x36,0x32,0x38,0x31,0x32,0x35,0x31,0x32,0x37,0x5a,0x17,0x0d,0x31,0x30,0x30,
 858 0x37,0x32,0x38,0x31,0x32,0x35,0x31,0x32,0x37,0x5a,0xa0,0x0e,0x30,0x0c,0x30,
 859 0x0a,0x06,0x03,0x55,0x1d,0x14,0x04,0x03,0x02,0x01,0x00,0x30,0x0d,0x06,0x09,
 860 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x05,0x05,0x00,0x03,0x31,0x00,0x83,
 861 0x35,0x9c,0xf5,0x35,0x5c,0xc1,0x20,0x81,0x80,0x5c,0x35,0x56,0xaf,0xb3,0x27,
 862 0x15,0xc6,0xdd,0x24,0xe1,0xff,0xb9,0xf9,0x19,0x21,0xed,0x5e,0x1b,0xff,0x72,
 863 0xc3,0x33,0xf6,0x9f,0xcb,0xde,0x84,0x0b,0x12,0x84,0xad,0x48,0x90,0x9d,0xdd,
 864 0x89,0xbb };
 865 static const BYTE signedHashForEmptyMessage[] = {
 866 0x30,0x81,0xbb,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 867 0x81,0xad,0x30,0x81,0xaa,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 868 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,
 869 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x31,0x81,0x87,0x30,0x81,0x84,0x02,0x01,
 870 0x01,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,
 871 0x01,0x4e,0x02,0x10,0x20,0x42,0x68,0x69,0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,
 872 0x24,0x2f,0x3b,0xad,0x40,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 873 0x02,0x05,0x05,0x00,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 874 0x01,0x01,0x05,0x00,0x04,0x40,0xe1,0xee,0xca,0x98,0x16,0x23,0x5a,0x34,0xfd,
 875 0x91,0x69,0x97,0x1e,0x16,0xe4,0x57,0x45,0xad,0xc9,0x5d,0x2e,0xda,0x92,0xbf,
 876 0xee,0x2f,0xb1,0xaa,0x32,0xfa,0x07,0x4e,0x63,0xfd,0xe1,0x52,0x17,0xd0,0xa4,
 877 0x49,0x30,0x54,0x4d,0x12,0xa0,0x6a,0x1c,0x64,0xea,0xc7,0x50,0x49,0xa5,0xca,
 878 0xc3,0x71,0xa4,0xf7,0x8c,0x25,0xe4,0x1a,0xca,0x89 };
 879 static const BYTE signedEmptyMessage[] = {
 880 0x30,0x81,0xbb,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 881 0x81,0xad,0x30,0x81,0xaa,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 882 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,
 883 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x31,0x81,0x87,0x30,0x81,0x84,0x02,0x01,
 884 0x01,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,
 885 0x01,0x4e,0x02,0x10,0x20,0x42,0x68,0x69,0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,
 886 0x24,0x2f,0x3b,0xad,0x40,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 887 0x02,0x05,0x05,0x00,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 888 0x01,0x01,0x05,0x00,0x04,0x40,0xe1,0xee,0xca,0x98,0x16,0x23,0x5a,0x34,0xfd,
 889 0x91,0x69,0x97,0x1e,0x16,0xe4,0x57,0x45,0xad,0xc9,0x5d,0x2e,0xda,0x92,0xbf,
 890 0xee,0x2f,0xb1,0xaa,0x32,0xfa,0x07,0x4e,0x63,0xfd,0xe1,0x52,0x17,0xd0,0xa4,
 891 0x49,0x30,0x54,0x4d,0x12,0xa0,0x6a,0x1c,0x64,0xea,0xc7,0x50,0x49,0xa5,0xca,
 892 0xc3,0x71,0xa4,0xf7,0x8c,0x25,0xe4,0x1a,0xca,0x89 };
 893 static const BYTE signedHash[] = {
 894 0x30,0x81,0xbb,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 895 0x81,0xad,0x30,0x81,0xaa,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 896 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,0x09,0x2a,0x86,
 897 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0x31,0x81,0x87,0x30,0x81,0x84,0x02,0x01,
 898 0x01,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,
 899 0x01,0x4e,0x02,0x10,0x20,0x42,0x68,0x69,0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,
 900 0x24,0x2f,0x3b,0xad,0x40,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 901 0x02,0x05,0x05,0x00,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,
 902 0x01,0x01,0x05,0x00,0x04,0x40,0x1e,0x04,0xa4,0xe3,0x90,0x54,0xed,0xcb,0x94,
 903 0xa2,0xbe,0x81,0x73,0x7e,0x05,0xf2,0x82,0xd3,0x3a,0x26,0x96,0x7a,0x53,0xcd,
 904 0x05,0xc3,0x09,0x69,0x3d,0x12,0x6c,0xb1,0xb0,0xab,0x0e,0xa1,0xec,0x1b,0xa1,
 905 0xff,0x01,0x9c,0x49,0x9f,0x4b,0x69,0x59,0x74,0x20,0x9f,0xb0,0x19,0x95,0xe7,
 906 0xed,0x1e,0x84,0xeb,0xe2,0x53,0x2c,0xa6,0x43,0xdf };
 907 static const BYTE signedHashWithCert[] = {
 908 0x30,0x82,0x01,0x93,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
 909 0xa0,0x82,0x01,0x84,0x30,0x82,0x01,0x80,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
 910 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,
 911 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x81,0xd3,0x30,0x81,
 912 0xd0,0x30,0x81,0xbe,0xa0,0x03,0x02,0x01,0x02,0x02,0x10,0x20,0x42,0x68,0x69,
 913 0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,0x24,0x2f,0x3b,0xad,0x40,0x30,0x09,0x06,
 914 0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,
 915 0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x30,0x20,0x17,0x0d,0x31,0x30,0x30,0x39,
 916 0x31,0x34,0x31,0x33,0x31,0x39,0x30,0x39,0x5a,0x18,0x0f,0x33,0x30,0x31,0x30,
 917 0x30,0x39,0x31,0x34,0x31,0x33,0x31,0x39,0x30,0x39,0x5a,0x30,0x0c,0x31,0x0a,
 918 0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x30,0x5c,0x30,0x0d,0x06,
 919 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x03,0x4b,0x00,
 920 0x30,0x48,0x02,0x41,0x00,0xe8,0xa9,0xc0,0x99,0x82,0x64,0x87,0x1b,0xf3,0x39,
 921 0xf0,0x8d,0xa3,0xdd,0x92,0x87,0xca,0x95,0x4f,0xe6,0xfc,0xe0,0x2d,0x29,0x28,
 922 0x98,0x95,0x4c,0x3c,0x78,0xcd,0x3e,0x8a,0xaa,0x4a,0xd7,0x7b,0x07,0xc1,0xf7,
 923 0x9c,0x71,0x0c,0xb9,0xe3,0x17,0x96,0xc5,0x39,0xdd,0x1d,0x06,0x6a,0x1e,0x94,
 924 0x09,0x9e,0x50,0x09,0x5b,0xd9,0x60,0xd9,0x9b,0x02,0x03,0x01,0x00,0x01,0x30,
 925 0x09,0x06,0x05,0x2b,0x0e,0x03,0x02,0x1d,0x05,0x00,0x03,0x02,0x00,0xc1,0x31,
 926 0x81,0x87,0x30,0x81,0x84,0x02,0x01,0x01,0x30,0x20,0x30,0x0c,0x31,0x0a,0x30,
 927 0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,0x20,0x42,0x68,0x69,
 928 0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,0x24,0x2f,0x3b,0xad,0x40,0x30,0x0c,0x06,
 929 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0d,0x06,0x09,
 930 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x40,0x1e,0x04,
 931 0xa4,0xe3,0x90,0x54,0xed,0xcb,0x94,0xa2,0xbe,0x81,0x73,0x7e,0x05,0xf2,0x82,
 932 0xd3,0x3a,0x26,0x96,0x7a,0x53,0xcd,0x05,0xc3,0x09,0x69,0x3d,0x12,0x6c,0xb1,
 933 0xb0,0xab,0x0e,0xa1,0xec,0x1b,0xa1,0xff,0x01,0x9c,0x49,0x9f,0x4b,0x69,0x59,
 934 0x74,0x20,0x9f,0xb0,0x19,0x95,0xe7,0xed,0x1e,0x84,0xeb,0xe2,0x53,0x2c,0xa6,
 935 0x43,0xdf };
 936 static const BYTE signedHashWithCRL[] = {
 937 0x30,0x82,0x01,0x85,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
 938 0xa0,0x82,0x01,0x76,0x30,0x82,0x01,0x72,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,
 939 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0b,0x06,
 940 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa1,0x81,0xc5,0x30,0x81,
 941 0xc2,0x30,0x7e,0x02,0x01,0x01,0x30,0x0d,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,
 942 0x0d,0x01,0x01,0x05,0x05,0x00,0x30,0x3c,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,
 943 0x04,0x06,0x13,0x02,0x52,0x55,0x31,0x0c,0x30,0x0a,0x06,0x03,0x55,0x04,0x08,
 944 0x13,0x03,0x53,0x50,0x62,0x31,0x0c,0x30,0x0a,0x06,0x03,0x55,0x04,0x07,0x13,
 945 0x03,0x53,0x50,0x62,0x31,0x11,0x30,0x0f,0x06,0x03,0x55,0x04,0x0a,0x13,0x08,
 946 0x45,0x74,0x65,0x72,0x73,0x6f,0x66,0x74,0x17,0x0d,0x31,0x30,0x30,0x36,0x32,
 947 0x38,0x31,0x32,0x35,0x31,0x32,0x37,0x5a,0x17,0x0d,0x31,0x30,0x30,0x37,0x32,
 948 0x38,0x31,0x32,0x35,0x31,0x32,0x37,0x5a,0xa0,0x0e,0x30,0x0c,0x30,0x0a,0x06,
 949 0x03,0x55,0x1d,0x14,0x04,0x03,0x02,0x01,0x00,0x30,0x0d,0x06,0x09,0x2a,0x86,
 950 0x48,0x86,0xf7,0x0d,0x01,0x01,0x05,0x05,0x00,0x03,0x31,0x00,0x83,0x35,0x9c,
 951 0xf5,0x35,0x5c,0xc1,0x20,0x81,0x80,0x5c,0x35,0x56,0xaf,0xb3,0x27,0x15,0xc6,
 952 0xdd,0x24,0xe1,0xff,0xb9,0xf9,0x19,0x21,0xed,0x5e,0x1b,0xff,0x72,0xc3,0x33,
 953 0xf6,0x9f,0xcb,0xde,0x84,0x0b,0x12,0x84,0xad,0x48,0x90,0x9d,0xdd,0x89,0xbb,
 954 0x31,0x81,0x87,0x30,0x81,0x84,0x02,0x01,0x01,0x30,0x20,0x30,0x0c,0x31,0x0a,
 955 0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,0x20,0x42,0x68,
 956 0x69,0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,0x24,0x2f,0x3b,0xad,0x40,0x30,0x0c,
 957 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0d,0x06,
 958 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x40,0x1e,
 959 0x04,0xa4,0xe3,0x90,0x54,0xed,0xcb,0x94,0xa2,0xbe,0x81,0x73,0x7e,0x05,0xf2,
 960 0x82,0xd3,0x3a,0x26,0x96,0x7a,0x53,0xcd,0x05,0xc3,0x09,0x69,0x3d,0x12,0x6c,
 961 0xb1,0xb0,0xab,0x0e,0xa1,0xec,0x1b,0xa1,0xff,0x01,0x9c,0x49,0x9f,0x4b,0x69,
 962 0x59,0x74,0x20,0x9f,0xb0,0x19,0x95,0xe7,0xed,0x1e,0x84,0xeb,0xe2,0x53,0x2c,
 963 0xa6,0x43,0xdf };
 964 static const BYTE signedData[] = {
 965 0x30,0x81,0xc3,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 966 0x81,0xb5,0x30,0x81,0xb2,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 967 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x13,0x06,0x09,0x2a,0x86,
 968 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x06,0x04,0x04,0x01,0x02,0x03,0x04,
 969 0x31,0x81,0x87,0x30,0x81,0x84,0x02,0x01,0x01,0x30,0x20,0x30,0x0c,0x31,0x0a,
 970 0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x4e,0x02,0x10,0x20,0x42,0x68,
 971 0x69,0xe9,0xea,0x61,0x83,0x11,0xdf,0xc0,0x24,0x2f,0x3b,0xad,0x40,0x30,0x0c,
 972 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x0d,0x06,
 973 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x01,0x01,0x05,0x00,0x04,0x40,0xe4,
 974 0x69,0xf5,0x62,0xfb,0x3a,0x7d,0x1c,0x7b,0x8b,0xcc,0xfc,0x6e,0x8e,0x91,0x85,
 975 0xcf,0x3c,0xb8,0xfd,0x8a,0xac,0x81,0x96,0xa0,0x42,0xac,0x88,0xc4,0x48,0xe8,
 976 0x43,0x64,0xd1,0x38,0xd2,0x6c,0xc4,0xd4,0x9b,0x9a,0xd4,0x33,0x02,0xef,0x88,
 977 0xef,0x98,0x2d,0xac,0xad,0xc1,0x93,0x60,0xc4,0x3a,0xdc,0xa7,0xd6,0x97,0x70,
 978 0x01,0xc1,0x84 };
 979
 980 static void test_sign_message(void)
 981 {
 982     BOOL ret;
 983     CRYPT_SIGN_MESSAGE_PARA para;
 984     static char oid_rsa_md5[] = szOID_RSA_MD5;
 985     static const BYTE blob1[] = { 0x01, 0x02, 0x03, 0x04 };
 986     static const BYTE blob2[] = { 0x11, 0x12, 0x13, 0x14 };
 987     const BYTE *toSign[] = { blob1, blob2 };
 988     DWORD signSize[] = { sizeof(blob1), sizeof(blob2) };
 989     LPBYTE signedBlob;
 990     DWORD signedBlobSize;
 991     PCCRL_CONTEXT crlContext;
 992     CERT_KEY_CONTEXT keyContext;
 993     HCRYPTPROV hCryptProv = 0;
 994     HCRYPTKEY hKey = 0;
 995
 996     memset(&para, 0, sizeof(para));
 997     SetLastError(0xdeadbeef);
 998     ret = CryptSignMessage(&para, FALSE, 0, NULL, NULL, NULL, &signedBlobSize);
 999     ok(!ret &&
1000      (GetLastError() == E_INVALIDARG ||
1001       GetLastError() == ERROR_ARITHMETIC_OVERFLOW), /* Win7 */
1002      "expected E_INVALIDARG or ERROR_ARITHMETIC_OVERFLOW, got %08x\n",
1003      GetLastError());
1004     para.cbSize = sizeof(para);
1005     para.dwMsgEncodingType = X509_ASN_ENCODING;
1006     SetLastError(0xdeadbeef);
1007     signedBlobSize = 255;
1008     ret = CryptSignMessage(&para, FALSE, 0, NULL, NULL, NULL, &signedBlobSize);
1009     ok(!ret && GetLastError() == E_INVALIDARG,
1010      "expected E_INVALIDARG, got %08x\n", GetLastError());
1011     ok(!signedBlobSize, "unexpected size %d\n", signedBlobSize);
1012     para.dwMsgEncodingType = PKCS_7_ASN_ENCODING;
1013     SetLastError(0xdeadbeef);
1014     signedBlobSize = 0;
1015     ret = CryptSignMessage(&para, FALSE, 0, NULL, NULL, NULL, &signedBlobSize);
1016     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1017     todo_wine
1018     ok(signedBlobSize, "bad size\n");
1019
1020     SetLastError(0xdeadbeef);
1021     ret = pCryptAcquireContextA(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
1022      CRYPT_VERIFYCONTEXT);
1023     ok(ret, "CryptAcquireContextA failed: %08x\n", GetLastError());
1024     SetLastError(0xdeadbeef);
1025     ret = CryptImportKey(hCryptProv, publicPrivateKeyPair,
1026      sizeof(publicPrivateKeyPair), 0, 0, &hKey);
1027     if (!ret && GetLastError() == NTE_PERM) /* Win9x */
1028     {
1029         skip("Failed to import a key\n");
1030         if (hCryptProv)
1031             CryptReleaseContext(hCryptProv, 0);
1032         return;
1033     }
1034     ok(ret, "CryptImportKey failed: %08x\n", GetLastError());
1035
1036     para.dwMsgEncodingType = X509_ASN_ENCODING | PKCS_7_ASN_ENCODING;
1037     SetLastError(0xdeadbeef);
1038     para.pSigningCert = CertCreateCertificateContext(X509_ASN_ENCODING |
1039      PKCS_7_ASN_ENCODING, cert1, sizeof(cert1));
1040     ok(para.pSigningCert != NULL, "CertCreateCertificateContext failed: %08x\n",
1041      GetLastError());
1042     para.HashAlgorithm.pszObjId = oid_rsa_md5;
1043
1044     memset(&keyContext, 0, sizeof(keyContext));
1045     keyContext.cbSize = sizeof(keyContext);
1046     keyContext.hCryptProv = hCryptProv;
1047     keyContext.dwKeySpec = AT_SIGNATURE;
1048     SetLastError(0xdeadbeef);
1049     ret = CertSetCertificateContextProperty(para.pSigningCert,
1050      CERT_KEY_CONTEXT_PROP_ID, 0, &keyContext);
1051     ok(ret, "CertSetCertificateContextProperty failed: %08x\n", GetLastError());
1052
1053     SetLastError(0xdeadbeef);
1054     signedBlobSize = 0;
1055     ret = CryptSignMessage(&para, TRUE, 0, NULL, NULL, NULL, &signedBlobSize);
1056     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1057     signedBlob = CryptMemAlloc(signedBlobSize);
1058     if (signedBlob)
1059     {
1060         SetLastError(0xdeadbeef);
1061         ret = CryptSignMessage(&para, TRUE, 0, NULL, NULL, signedBlob,
1062          &signedBlobSize);
1063         ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1064         ok(signedBlobSize == sizeof(signedHashForEmptyMessage),
1065          "unexpected size %d\n", signedBlobSize);
1066         ok(!memcmp(signedBlob, signedHashForEmptyMessage, signedBlobSize),
1067          "unexpected value\n");
1068         CryptMemFree(signedBlob);
1069     }
1070
1071     SetLastError(0xdeadbeef);
1072     signedBlobSize = 0;
1073     ret = CryptSignMessage(&para, FALSE, 0, NULL, NULL, NULL, &signedBlobSize);
1074     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1075     signedBlob = CryptMemAlloc(signedBlobSize);
1076     if (signedBlob)
1077     {
1078         SetLastError(0xdeadbeef);
1079         ret = CryptSignMessage(&para, FALSE, 0, NULL, NULL, signedBlob,
1080          &signedBlobSize);
1081         ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1082         ok(signedBlobSize == sizeof(signedEmptyMessage), "unexpected size %d\n",
1083          signedBlobSize);
1084         ok(!memcmp(signedBlob, signedEmptyMessage, signedBlobSize),
1085          "unexpected value\n");
1086         CryptMemFree(signedBlob);
1087     }
1088
1089     SetLastError(0xdeadbeef);
1090     signedBlobSize = 0;
1091     ret = CryptSignMessage(&para, TRUE, 2, toSign, signSize, NULL,
1092      &signedBlobSize);
1093     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1094     signedBlob = CryptMemAlloc(signedBlobSize);
1095     if (signedBlob)
1096     {
1097         SetLastError(0xdeadbeef);
1098         ret = CryptSignMessage(&para, TRUE, 2, toSign, signSize, signedBlob,
1099          &signedBlobSize);
1100         ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1101         ok(signedBlobSize == sizeof(signedHash),
1102          "unexpected size of signed blob %d\n", signedBlobSize);
1103         ok(!memcmp(signedBlob, signedHash, signedBlobSize),
1104          "unexpected value\n");
1105         CryptMemFree(signedBlob);
1106     }
1107
1108     para.cMsgCert = 1;
1109     para.rgpMsgCert = &para.pSigningCert;
1110
1111     SetLastError(0xdeadbeef);
1112     signedBlobSize = 0;
1113     ret = CryptSignMessage(&para, TRUE, 2, toSign, signSize, NULL,
1114      &signedBlobSize);
1115     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1116     signedBlob = CryptMemAlloc(signedBlobSize);
1117     if (signedBlob)
1118     {
1119         SetLastError(0xdeadbeef);
1120         ret = CryptSignMessage(&para, TRUE, 2, toSign, signSize, signedBlob,
1121          &signedBlobSize);
1122         ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1123         ok(signedBlobSize == sizeof(signedHashWithCert),
1124          "unexpected size of signed blob %d\n", signedBlobSize);
1125         ok(!memcmp(signedBlob, signedHashWithCert, signedBlobSize),
1126          "unexpected value\n");
1127         CryptMemFree(signedBlob);
1128     }
1129
1130     para.cMsgCert = 0;
1131     para.rgpMsgCert = NULL;
1132     para.cMsgCrl = 1;
1133     SetLastError(0xdeadbeef);
1134     crlContext = CertCreateCRLContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
1135      crl, sizeof(crl));
1136     ok(crlContext != NULL, "CertCreateCRLContext failed: %08x\n",
1137      GetLastError());
1138     para.rgpMsgCrl = &crlContext;
1139
1140     SetLastError(0xdeadbeef);
1141     signedBlobSize = 0;
1142     ret = CryptSignMessage(&para, TRUE, 2, toSign, signSize, NULL,
1143      &signedBlobSize);
1144     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1145     signedBlob = CryptMemAlloc(signedBlobSize);
1146     if (signedBlob)
1147     {
1148         SetLastError(0xdeadbeef);
1149         ret = CryptSignMessage(&para, TRUE, 2, toSign, signSize, signedBlob,
1150          &signedBlobSize);
1151         ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1152         ok(signedBlobSize == sizeof(signedHashWithCRL),
1153          "unexpected size of signed blob %d\n", signedBlobSize);
1154         ok(!memcmp(signedBlob, signedHashWithCRL, signedBlobSize),
1155          "unexpected value\n");
1156         CryptMemFree(signedBlob);
1157     }
1158
1159     CertFreeCRLContext(crlContext);
1160     para.cMsgCrl = 0;
1161     para.rgpMsgCrl = NULL;
1162
1163     SetLastError(0xdeadbeef);
1164     signedBlobSize = 0;
1165     ret = CryptSignMessage(&para, FALSE, 1, toSign, signSize, NULL,
1166      &signedBlobSize);
1167     ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1168     signedBlob = CryptMemAlloc(signedBlobSize);
1169     if (signedBlob)
1170     {
1171         SetLastError(0xdeadbeef);
1172         ret = CryptSignMessage(&para, FALSE, 1, toSign, signSize, signedBlob,
1173          &signedBlobSize);
1174         ok(ret, "CryptSignMessage failed: %08x\n", GetLastError());
1175         ok(signedBlobSize == sizeof(signedData),
1176          "unexpected size of signed blob %d\n", signedBlobSize);
1177         ok(!memcmp(signedBlob, signedData, signedBlobSize),
1178          "unexpected value\n");
1179         CryptMemFree(signedBlob);
1180     }
1181
1182     if (para.pSigningCert)
1183         CertFreeCertificateContext(para.pSigningCert);
1184     if (hKey)
1185         CryptDestroyKey(hKey);
1186     if (hCryptProv)
1187         CryptReleaseContext(hCryptProv, 0);
1188 }
1189
1190 static const BYTE encryptedMessage[] = {
1191 0x30,0x31,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x03,0xa0,0x24,
1192 0x30,0x22,0x02,0x01,0x00,0x31,0x00,0x30,0x1b,0x06,0x09,0x2a,0x86,0x48,0x86,
1193 0xf7,0x0d,0x01,0x07,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,
1194 0x03,0x04,0x05,0x00,0x80,0x00 };
1195
1196 static void test_encrypt_message(void)
1197 {
1198     BOOL ret;
1199     CRYPT_ENCRYPT_MESSAGE_PARA para;
1200     static char oid_rsa_rc4[] = szOID_RSA_RC4;
1201     static const BYTE blob[] = { 0x01, 0x02, 0x03, 0x04 };
1202     PCCERT_CONTEXT certs[2];
1203     HCRYPTPROV hCryptProv = 0;
1204     LPBYTE encryptedBlob;
1205     DWORD encryptedBlobSize;
1206
1207     SetLastError(0xdeadbeef);
1208     ret = pCryptAcquireContextA(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
1209      CRYPT_VERIFYCONTEXT);
1210     ok(ret, "CryptAcquireContextA failed: %08x\n", GetLastError());
1211
1212     SetLastError(0xdeadbeef);
1213     certs[0] = CertCreateCertificateContext(X509_ASN_ENCODING |
1214      PKCS_7_ASN_ENCODING, cert1, sizeof(cert1));
1215     ok(certs[0] != NULL, "CertCreateCertificateContext failed: %08x\n",
1216      GetLastError());
1217     SetLastError(0xdeadbeef);
1218     certs[1] = CertCreateCertificateContext(X509_ASN_ENCODING |
1219      PKCS_7_ASN_ENCODING, cert2, sizeof(cert2));
1220     ok(certs[1] != NULL, "CertCreateCertificateContext failed: %08x\n",
1221      GetLastError());
1222
1223     memset(&para, 0, sizeof(para));
1224     SetLastError(0xdeadbeef);
1225     encryptedBlobSize = 255;
1226     ret = CryptEncryptMessage(&para, 0, NULL, NULL, 0, NULL,
1227      &encryptedBlobSize);
1228     ok(!ret && GetLastError() == E_INVALIDARG,
1229      "expected E_INVALIDARG, got %08x\n", GetLastError());
1230     ok(!encryptedBlobSize, "unexpected size %d\n", encryptedBlobSize);
1231     para.cbSize = sizeof(para);
1232     para.dwMsgEncodingType = X509_ASN_ENCODING;
1233     SetLastError(0xdeadbeef);
1234     encryptedBlobSize = 255;
1235     ret = CryptEncryptMessage(&para, 0, NULL, NULL, 0, NULL,
1236      &encryptedBlobSize);
1237     ok(!ret && GetLastError() == E_INVALIDARG,
1238      "expected E_INVALIDARG, got %08x\n", GetLastError());
1239     ok(!encryptedBlobSize, "unexpected size %d\n", encryptedBlobSize);
1240     para.dwMsgEncodingType = PKCS_7_ASN_ENCODING;
1241     SetLastError(0xdeadbeef);
1242     encryptedBlobSize = 255;
1243     ret = CryptEncryptMessage(&para, 0, NULL, NULL, 0, NULL,
1244      &encryptedBlobSize);
1245     ok(!ret &&
1246      (GetLastError() == CRYPT_E_UNKNOWN_ALGO ||
1247       GetLastError() == E_INVALIDARG), /* Win9x */
1248      "expected CRYPT_E_UNKNOWN_ALGO or E_INVALIDARG, got %08x\n",
1249      GetLastError());
1250     ok(!encryptedBlobSize, "unexpected size %d\n", encryptedBlobSize);
1251
1252     para.hCryptProv = hCryptProv;
1253     para.ContentEncryptionAlgorithm.pszObjId = oid_rsa_rc4;
1254
1255     SetLastError(0xdeadbeef);
1256     encryptedBlobSize = 0;
1257     ret = CryptEncryptMessage(&para, 0, NULL, NULL, 0, NULL,
1258      &encryptedBlobSize);
1259     ok(ret ||
1260      broken(!ret) /* Win9x */,
1261      "CryptEncryptMessage failed: %08x\n", GetLastError());
1262     if (ret)
1263     {
1264         encryptedBlob = CryptMemAlloc(encryptedBlobSize);
1265         if (encryptedBlob)
1266         {
1267             SetLastError(0xdeadbeef);
1268             ret = CryptEncryptMessage(&para, 0, NULL, NULL, 0, encryptedBlob,
1269              &encryptedBlobSize);
1270             ok(ret, "CryptEncryptMessage failed: %08x\n", GetLastError());
1271             ok(encryptedBlobSize == sizeof(encryptedMessage),
1272              "unexpected size of encrypted blob %d\n", encryptedBlobSize);
1273             ok(!memcmp(encryptedBlob, encryptedMessage, encryptedBlobSize),
1274              "unexpected value\n");
1275             CryptMemFree(encryptedBlob);
1276         }
1277     }
1278
1279     SetLastError(0xdeadbeef);
1280     encryptedBlobSize = 0;
1281     ret = CryptEncryptMessage(&para, 2, certs, NULL, 0, NULL,
1282      &encryptedBlobSize);
1283     ok(ret, "CryptEncryptMessage failed: %08x\n", GetLastError());
1284     if (ret)
1285     {
1286         encryptedBlob = CryptMemAlloc(encryptedBlobSize);
1287         if (encryptedBlob)
1288         {
1289             SetLastError(0xdeadbeef);
1290             ret = CryptEncryptMessage(&para, 2, certs, NULL, 0, encryptedBlob,
1291              &encryptedBlobSize);
1292             ok(ret, "CryptEncryptMessage failed: %08x\n", GetLastError());
1293             CryptMemFree(encryptedBlob);
1294         }
1295     }
1296
1297     SetLastError(0xdeadbeef);
1298     encryptedBlobSize = 0;
1299     ret = CryptEncryptMessage(&para, 0, NULL, blob, sizeof(blob), NULL,
1300      &encryptedBlobSize);
1301     ok(ret ||
1302      broken(!ret) /* Win9x */,
1303      "CryptEncryptMessage failed: %08x\n", GetLastError());
1304     if (ret)
1305     {
1306         encryptedBlob = CryptMemAlloc(encryptedBlobSize);
1307         if (encryptedBlob)
1308         {
1309             SetLastError(0xdeadbeef);
1310             ret = CryptEncryptMessage(&para, 0, NULL, blob, sizeof(blob),
1311              encryptedBlob, &encryptedBlobSize);
1312             ok(ret ||
1313              broken(!ret && GetLastError() == NTE_PERM), /* some NT4 */
1314              "CryptEncryptMessage failed: %08x\n", GetLastError());
1315             if (ret)
1316             {
1317                 ok(encryptedBlobSize == 55,
1318                  "unexpected size of encrypted blob %d\n", encryptedBlobSize);
1319             }
1320             CryptMemFree(encryptedBlob);
1321         }
1322     }
1323
1324     SetLastError(0xdeadbeef);
1325     encryptedBlobSize = 0;
1326     ret = CryptEncryptMessage(&para, 2, certs, blob, sizeof(blob), NULL,
1327      &encryptedBlobSize);
1328     ok(ret, "CryptEncryptMessage failed: %08x\n", GetLastError());
1329     if (ret)
1330     {
1331         encryptedBlob = CryptMemAlloc(encryptedBlobSize);
1332         if (encryptedBlob)
1333         {
1334             SetLastError(0xdeadbeef);
1335             ret = CryptEncryptMessage(&para, 2, certs, blob, sizeof(blob),
1336              encryptedBlob, &encryptedBlobSize);
1337             ok(ret ||
1338              broken(!ret), /* some Win95 and some NT4 */
1339              "CryptEncryptMessage failed: %08x\n", GetLastError());
1340             CryptMemFree(encryptedBlob);
1341         }
1342     }
1343
1344     if (certs[0])
1345         CertFreeCertificateContext(certs[0]);
1346     if (certs[1])
1347         CertFreeCertificateContext(certs[1]);
1348     if (hCryptProv)
1349         CryptReleaseContext(hCryptProv, 0);
1350 }
1351
1352 START_TEST(message)
1353 {
1354     init_function_pointers();
1355
1356     test_msg_get_signer_count();
1357     test_verify_detached_message_hash();
1358     test_verify_message_hash();
1359     test_verify_detached_message_signature();
1360     test_verify_message_signature();
1361     test_hash_message();
1362     test_sign_message();
1363     test_encrypt_message();
1364 }